EXPR_Cylinder.h

#ifndef EXPR_Cylinder_H
#define EXPR_Cylinder_H
 
#include "EXPR_ElementaryGeometryNode.h"
 
 
class EXPR_Cylinder : public  EXPR_ElementaryGeometryNode {
    
private:
    //attributes
 
    //bounding box points
    static const std::array<tCInt,24> BOUNDING_BOX_POINTS;
    
    //center of the ellipoide
    std::array<tReal,3> mCenter;
    
    //axe of the ellipsoide
    std::array<tReal,3> mU;
    std::array<tReal,3> mV;
    std::array<tReal,3> mK;
    
    //size in each direction U,V,W
    std::array<tReal,3> mSize;
    
private:
    //associations
protected:
    //builders
    
    EXPR_Cylinder();
    //deleters
    virtual ~EXPR_Cylinder();
 
public:
    //MEMORY
    //======
    virtual tMemSize getMemorySize() const override {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const override {
        tMemSize mem=EXPR_ElementaryGeometryNode::getContentsMemorySize();
        mem+=mCenter.size()*sizeof(tReal);
        mem+=mU.size()*sizeof(tReal);
        mem+=mV.size()*sizeof(tReal);
        mem+=mK.size()*sizeof(tReal);
        mem+=mSize.size()*sizeof(tReal);
        return mem;
    }
 
public:
    virtual CORE_UniquePointer<EXPR_ElementaryGeometryNode> newInstance() const override {
        return New();
    }
    
    static inline CORE_UniquePointer<EXPR_Cylinder> New() {
        CORE_UniquePointer<EXPR_Cylinder> p(new EXPR_Cylinder(),
                                            EXPR_Cylinder::Delete());
        
        return p;
    }
    
    virtual void copy(const EXPR_Node& node) override  {
        EXPR_ElementaryGeometryNode::copy(node);
        const EXPR_Cylinder *cyl=dynamic_cast< const EXPR_Cylinder *>(&node);
        if (cyl!=null) {
            setCenter(cyl->getCenter());
            setMainDirection(cyl->getMainDirection());
            setSecondDirection(cyl->getSecondDirection());
            setLength(cyl->getLength());
            setMainRadius(cyl->getMainRadius());
            setSecondRadius(cyl->getSecondRadius());
            orthogonalize();
        }
    }
    
    virtual void setArguments(const std::vector<tString>& args) override ;
    
    inline void setCenter(const std::array<tReal,3>& X) {
        memcpy(mCenter.data(),X.data(),X.size()*sizeof(tReal));
    }
    inline void setCenter(std::initializer_list<tReal>&& X) {
        auto iX=std::cbegin(X);
        for(auto& Ck:mCenter) {
            Ck=(*iX);
            iX++;
        }
    }
    inline const std::array<tReal,3>& getCenter() const {
        return mCenter;
    }
    inline void setMainDirection(const std::array<tReal,3>& U) {
        memcpy(mU.data(),U.data(),U.size()*sizeof(tReal));
    }
    inline void setMainDirection(std::initializer_list<tReal>&& U) {
         auto iU=std::cbegin(U);
        for(auto& Uk:mU) {
            Uk=(*iU);
            iU++;
        }
    }
    inline const std::array<tReal,3>& getMainDirection() const {
        return mU;
    }
    inline void setSecondDirection(const std::array<tReal,3>& U) {
         memcpy(mV.data(),U.data(),U.size()*sizeof(tReal));
    }
    inline void setSecondDirection(std::initializer_list<tReal>&& U) {
        auto iU=std::cbegin(U);
        for(auto& Uk:mV) {
            Uk=(*iU);
            iU++;
        }
    }
    inline const std::array<tReal,3>& getSecondDirection() const {
        return mV;
    }
    void setLength(const tReal& L) {
        mSize[2]=L;
    }
 
    inline const tReal& getLength() const {
        return mSize[2];
    }
    
 
    inline void setMainRadius(const tReal& L) {
        mSize[0]=L;
    }
    inline const tReal& getMainRadius() const {
        return mSize[0];
    }
    inline void setSecondRadius(const tReal& L) {
        mSize[1]=L;
    }
    inline const tReal& getSecondRadius() const {
        return mSize[1];
    }
 
    void orthogonalize();
    
    virtual void adimensionize(const tReal& L) final ;
    
   
 
protected:
    virtual tBoolean isInsideCanonicalGeometry(const std::array<tReal,3>& P) const final;
 
    virtual void computeCanonicalBoundingBox(std::array<tReal,3>& minPoint,std::array<tReal,3>& maxPoint) const final ;
 
 
public:
    virtual tString toString() const final;
};
 
 
 
 
 
#endif