EXPR_Ellipsoid.h

#ifndef EXPR_Ellipsoid_H
#define EXPR_Ellipsoid_H
 
#include "EXPR_ElementaryGeometryNode.h"
 
 
class EXPR_Ellipsoid : 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> mW;
 
    
    //size of the ellipoide per direction
    std::array<tReal,3> mSize;
 
    
private:
    //associations
protected:
    //builders
    
    EXPR_Ellipsoid();
    //deleters
    virtual ~EXPR_Ellipsoid();
   
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+=mW.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_Ellipsoid> New() {
        CORE_UniquePointer<EXPR_Ellipsoid> p(new EXPR_Ellipsoid(),
                                            EXPR_Ellipsoid::Delete());
        
        return p;
    }
    
    virtual void copy(const EXPR_Node& node) override  {
        EXPR_ElementaryGeometryNode::copy(node);
        const EXPR_Ellipsoid *cyl=dynamic_cast< const EXPR_Ellipsoid *>(&node);
        if (cyl!=null) {
            setCenter(cyl->getCenter());
            
            setMainDirection(cyl->getMainDirection());
            setSecondDirection(cyl->getSecondDirection());
           
            setMainRadius(cyl->getMainRadius());
            setSecondRadius(cyl->getSecondRadius());
            setThirdRadius(cyl->getThirdRadius());
 
            orthogonalize();
        }
    }
    
    virtual void setArguments(const std::vector<tString>& args) override ;
 
 
    //center
    //------
    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;
    }
 
    //Main Direction U
    //----------------
    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 setMainRadius(const tReal& L) {
        mSize[0]=L;
    }
   
    inline const tReal& getMainRadius() const {
        return mSize[0];
    }
    //Second direction V
    //------------------
    inline void setSecondDirection(const std::array<tReal,3>& V) {
         memcpy(mV.data(),V.data(),V.size()*sizeof(tReal));
    }
    inline void setSecondDirection(std::initializer_list<tReal>&& V) {
        auto iV=std::cbegin(V);
        for(auto& Vk:mV) {
            Vk=(*iV);
            iV++;
        }
    }
    inline const std::array<tReal,3>& getSecondDirection() const {
        return mV;
    }
 
   
    inline void setSecondRadius(const tReal& L) {
        mSize[1]=L;
    }
    inline const tReal& getSecondRadius() const {
        return mSize[1];
    }
    //third direction W
    //------------------
    
   
    inline void setThirdRadius(const tReal& L) {
        mSize[2]=L;
    }
    inline const tReal& getThirdRadius() const {
        return mSize[2];
    }
 
    //orthogonalize the diections
    //---------------------------
 
    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