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_