EXPR_ElementaryGeometryNode.h

#ifndef EXPR_ElementaryGeometryNode_H
#define EXPR_ElementaryGeometryNode_H
 
#include "EXPR_LeafNode.h"
 
#include <vector>
 
 
class EXPR_ElementaryGeometryNode : public  EXPR_LeafNode {
  
    
private:
    //attributes
    tString mName;
    
 
private:
    //associations
protected:
    //builders
    
    EXPR_ElementaryGeometryNode() {
    }
    //deleters
    virtual ~EXPR_ElementaryGeometryNode() {
    }
    
public:
    
    virtual CORE_UniquePointer<EXPR_ElementaryGeometryNode> newInstance() const=0;
 
    //MEMORY
    //======
    virtual tMemSize getMemorySize() const override {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const override {
        tMemSize mem=EXPR_LeafNode::getContentsMemorySize();
        mem+=sizeof(tUChar)*mName.length();
        return mem;
    }
    
    virtual void copy(const EXPR_Node& node) override {
        EXPR_LeafNode::copy(node);
        const EXPR_ElementaryGeometryNode *geo=dynamic_cast<const EXPR_ElementaryGeometryNode*>(&node);
        if (geo!=null) setName(geo->getName());
    }
protected:
    inline void setName(const tString& name) {
        mName=name;
    }
public:
    inline const tString& getName() const {
        return mName;
    }
    
    virtual void setArguments(const std::vector<tString>& args)=0;
    
    
    virtual tBoolean isInside(std::array<tReal,3> P) const override {
        //test if the point p is in the box
        if (!isInsideBoundingBox(P)) {
            
            return false;
        }
        applyInverse(P);
        return isInsideCanonicalGeometry(P);
    }
    
    
    inline void computeBoundingBox() {
        std::array<tReal,3>& P=getBoundingBoxMinPoint();
        std::array<tReal,3>& Q=getBoundingBoxMaxPoint();
        computeCanonicalBoundingBox(P,Q);
        linearTransformBoundingBox(P,Q);
    }
    
    virtual void computeBoundingBox(std::map<tString,tBoolean>& alreadyComputed) override {
        if (alreadyComputed.find(getIdentityString())==alreadyComputed.end()) {
            computeBoundingBox();
            alreadyComputed[getIdentityString()]=true;
        }
    }
    
    virtual void adimensionize(const tReal& L,std::map<tString,tBoolean>& alreadyComputed) override {
        if (alreadyComputed.find(getIdentityString())==alreadyComputed.end()) {
            adimensionize(L);
            EXPR_ChildNode::adimensionize(L,alreadyComputed);
            
        }
    }
    
    
    virtual void adimensionize(const tReal& L)=0;
    
    
protected:
    virtual tBoolean isInsideCanonicalGeometry(const std::array<tReal,3>& P) const=0;
    
    virtual void computeCanonicalBoundingBox(std::array<tReal,3>& minPoint,
                                             std::array<tReal,3>& maxPoint) const=0;
public:
    
    inline static void GetSphericalCoordinates(const std::array<tReal,3>& M,
                                               const std::array<tReal,3>& C,
                                               tReal& r,
                                               tReal& theta,
                                               tReal& phi) {
        const tReal *Mk=M.data();
        const tReal *Ck=C.data();
        //(r,theta,phi)=CM
        tReal x=(*Mk)-(*Ck);Mk++;Ck++;
        tReal y=(*Mk)-(*Ck);Mk++;Ck++;
        tReal z=(*Mk)-(*Ck);
        
        //r=|CM|
        r=sqrt(x*x+y*y+z*z);
        //theta=acos(z/r)
        theta=acos(z/r);
        //phi=atan(y/x)
        phi=atan2(y,x);
        
    }
    
    
public:
    virtual tString toString() const override {
        std::stringstream sout;
        sout<<EXPR_LeafNode::toString()<<"\n";
        sout<<"name:"<<mName<<"\n";
        return sout.str();
        
    }
};
 
 
 
 
 
#endif