CurveLayoutGenerator.h

#pragma once
#include <Atoms/LayoutGenerators/DynamicLayoutGenerator.h>
#include <AtomsUtils/Curve.h>
 
namespace Atoms
{
    class ATOMS_EXPORT CurveLayoutGenerator : public DynamicLayoutGenerator
    {
    public:
 
        CurveLayoutGenerator();
 
        virtual ~CurveLayoutGenerator();
 
        // the generator function
        virtual std::vector<AgentInitData> generate(double time)
        #ifdef __APPLE__
                override
        #endif
        ;
 
        inline void setCurve(AtomsUtils::Curve& curve) { m_curve = curve; }
 
        inline void setDirection(AtomsCore::Vector3& dir) { m_direction = dir; }
 
        inline void setUpVector(AtomsCore::Vector3& dir) { m_upVector = dir; }
 
        inline void setNumberOfAgents(size_t value) { m_numberOfAgents = value; }
 
        inline void setDepth(size_t value) { m_depth = value; }
 
        inline void setDepthSpace(double value) { m_depthSpace = 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 setRandomSpace(AtomsCore::Vector3& dir) { m_randomSpace = dir; }
 
        inline void setSeed(size_t value) { m_seed = value; }
 
        inline const char* typeName() override { return "curveLayout"; };
 
    private:
 
        // Input curve
        AtomsUtils::Curve m_curve;
 
        // Agent direction
        AtomsCore::Vector3 m_direction;
 
        // Up vector
        AtomsCore::Vector3 m_upVector;
 
        // Random space
        AtomsCore::Vector3 m_randomSpace;
 
        // 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 curve
        size_t m_numberOfAgents;
 
        // Number of depth rows
        size_t m_depth;
 
        // Seed
        size_t m_seed;
 
        // Depth row space
        double m_depthSpace;
 
        // 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;
 
    };
}