CurvePairLayoutGenerator.h

#pragma once
#include <Atoms/LayoutGenerators/DynamicLayoutGenerator.h>
#include <AtomsUtils/Curve.h>
 
namespace Atoms
{
    class ATOMS_EXPORT CurvePairLayoutGenerator : public DynamicLayoutGenerator
    {
    public:
 
        CurvePairLayoutGenerator();
 
        virtual ~CurvePairLayoutGenerator();
 
        // the generator function
        virtual std::vector<AgentInitData> generate(double time)
        #ifdef __APPLE__
                override
        #endif
        ;
 
        inline void setCurves(AtomsUtils::Curve& curve1, AtomsUtils::Curve& curve2) { m_curve1 = curve1; m_curve2 = curve2; }
 
        inline void setDirection(AtomsCore::Vector3& dir) { m_direction = dir; }
 
        inline void setUpVector(AtomsCore::Vector3& dir) { m_upVector = dir; }
 
        inline void setSeed(const int value) { m_seed = value; }
 
        inline void setRandomRange(const int minValue, const int maxValue) { m_minRandomRange = minValue; m_maxRandomRange = maxValue; }
 
        inline void setNumberOfAgents(size_t value1, size_t value2) { m_numberOfAgents1 = value1; m_numberOfAgents2 = value2; }
 
        inline void setNumberOfRows(size_t value) { m_numberOfRows = value; }
 
        inline void setUseCVs(bool value) { m_useCVs = value; }
 
        inline void setDirectionType(short value) { m_directionType = value; }
 
        inline void setInvertDirection(bool value) { m_invertDirection = value; }
 
        inline void setAgentTypeOverride(const std::map<int, std::string>& value) { m_agentTypeOverride = value; }
 
        inline void setDirectionOverride(const std::map<int, AtomsCore::Vector3>& value) { m_directionOverride = value; }
 
        inline void setRandomDistribution(const bool randomDistribution) { m_randomDistribution = randomDistribution;}
 
        inline void setRandomDistributionRange(const float minValue, const float maxValue) { m_minRandomDistribution = minValue; m_maxRandomDistribution = maxValue; }
 
        inline const char* typeName() override { return "curvePairLayout"; };
 
        inline void setOffset(const AtomsCore::Vector3& offset) { m_offset = offset; };
 
 
    private:
 
        // Input curve
        AtomsUtils::Curve m_curve1;
        AtomsUtils::Curve m_curve2;
 
        // Agent direction
        AtomsCore::Vector3 m_direction;
 
        // Up vector
        AtomsCore::Vector3 m_upVector;
 
        // Offset
        AtomsCore::Vector3 m_offset;
 
        // Agent direction override
        std::map<int, AtomsCore::Vector3> m_directionOverride;
 
        // Agent type override
        std::map<int, std::string> m_agentTypeOverride;
 
        // Number of agents along the curves
        size_t m_numberOfAgents1;
        size_t m_numberOfAgents2;
 
        // Number of rows
        size_t m_numberOfRows;
 
        // Direction type: 0 - tangent, 1 - normal, 2 - custom
        short m_directionType;
 
        // Invert the direction
        bool m_invertDirection;
 
        // Use cvs instead num agents
        bool m_useCVs;
 
        // seed for random generation
        int m_seed;
 
        // Random range values
        int m_minRandomRange;
        int m_maxRandomRange;
 
        // Random distribution flag
        bool m_randomDistribution;
        float m_minRandomDistribution;
        float m_maxRandomDistribution;
    };
}