tfColorMapper.h

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of Tissue Forge.
 * Copyright (c) 2022-2024 T.J. Sego
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * 
 ******************************************************************************/

 
#ifndef _SOURCE_RENDERING_TFCOLORMAPPER_H_
#define _SOURCE_RENDERING_TFCOLORMAPPER_H_
 
#include <io/tf_io.h>
#include <TissueForge_private.h>
 
#include "tfColorMaps.h"
 
#include <vector>
 
 
namespace TissueForge {
 
 
    struct ParticleType;
 
    struct Angle;
    struct Bond;
    struct Dihedral;
    struct Particle;
 
 
    namespace rendering {
 
 
        typedef float (*ParticleColorMapperFunc)(TissueForge::Particle* o, struct ColorMapper* mapper);
        typedef float (*AngleColorMapperFunc)(TissueForge::Angle* o, struct ColorMapper* mapper);
        typedef float (*BondColorMapperFunc)(TissueForge::Bond* o, struct ColorMapper* mapper);
        typedef float (*DihedralColorMapperFunc)(TissueForge::Dihedral* o, struct ColorMapper* mapper);
 

        struct CAPI_EXPORT ColorMapper
        {
            ColorMapperFunc map;
            int species_index;
            
            float min_val;

            float max_val;
 
            ColorMapper(const std::string &name, const float &min=0.f, const float &max=1.f);
            ColorMapper();
            ~ColorMapper() {};

            fVector4 mapScalar(const float& val) const;

            fVector4 mapObj(Particle* o);

            fVector4 mapObj(Angle* o);

            fVector4 mapObj(Bond* o);

            fVector4 mapObj(Dihedral* o);

            const bool hasMapParticle() const;

            const bool hasMapAngle() const;

            const bool hasMapBond() const;

            const bool hasMapDihedral() const;

            void clearMapParticle();

            void clearMapAngle();

            void clearMapBond();

            void clearMapDihedral();

            unsigned int getMapParticle() const { return map_enum_particle; }

            unsigned int getMapAngle() const { return map_enum_angle; }

            unsigned int getMapBond() const { return map_enum_bond; }

            unsigned int getMapDihedral() const { return map_enum_dihedral; }

            void setMapParticle(const unsigned int& label);

            void setMapAngle(const unsigned int& label);

            void setMapBond(const unsigned int& label);

            void setMapDihedral(const unsigned int& label);

            void setMapParticlePositionX();

            void setMapParticlePositionY();

            void setMapParticlePositionZ();

            void setMapParticleVelocityX();

            void setMapParticleVelocityY();

            void setMapParticleVelocityZ();

            void setMapParticleSpeed();

            void setMapParticleForceX();

            void setMapParticleForceY();

            void setMapParticleForceZ();

            void setMapParticleSpecies(ParticleType* pType, const std::string& name);

            void setMapAngleAngle();

            void setMapAngleAngleEq();

            void setMapBondLength();

            void setMapBondLengthEq();

            void setMapDihedralAngle();

            void setMapDihedralAngleEq();
            
            bool set_colormap(const std::string& s);

            static std::vector<std::string> getNames();

            std::string getColorMapName() const;
 
        private:
 
            AngleColorMapperFunc mapper_angle;
            BondColorMapperFunc mapper_bond;
            DihedralColorMapperFunc mapper_dihedral;
            ParticleColorMapperFunc mapper_particle;
 
            unsigned int map_enum_angle;
            unsigned int map_enum_bond;
            unsigned int map_enum_dihedral;
            unsigned int map_enum_particle;
        };
 
    }
 
    namespace io {
 
        template <>
        HRESULT toFile(const rendering::ColorMapper &dataElement, const MetaData &metaData, IOElement &fileElement);
 
        template <>
        HRESULT fromFile(const IOElement &fileElement, const MetaData &metaData, rendering::ColorMapper *dataElement);
 
    }
 
};
 
#endif // _SOURCE_RENDERING_TFCOLORMAPPER_H_