EXPR_Paver.h

#ifndef EXPR_Paver_H
#define EXPR_Paver_H
 
#include "EXPR_ElementaryGeometryNode.h"
 
 
class EXPR_Paver : public  EXPR_ElementaryGeometryNode {
    
private:
    
  
    std::array<tReal,3> mMinPoint;
    std::array<tReal,3> mMaxPoint;
    
private:
    //associations
protected:
    //builders
    
    EXPR_Paver() {
        setName("PAVER");
        for(auto& Pk:mMinPoint) Pk=0;
        for(auto& Pk:mMaxPoint) Pk=1;
        
    }
    //deleters
    virtual ~EXPR_Paver() {
    }
       
public:
    //MEMORY
    //======
    virtual tMemSize getMemorySize() const override {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const override {
        tMemSize mem=EXPR_ElementaryGeometryNode::getContentsMemorySize();
        mem+=mMinPoint.size()*sizeof(tReal);
        mem+=mMaxPoint.size()*sizeof(tReal);
        return mem;
    }
 
public:
    virtual  CORE_UniquePointer<EXPR_ElementaryGeometryNode> newInstance() const override {
        return New();
    }
    
    static inline CORE_UniquePointer<EXPR_Paver> New() {
        CORE_UniquePointer<EXPR_Paver> p(new EXPR_Paver(),
                                         EXPR_Paver::Delete());
        
        return p;
    }
 
    
 
    
    virtual void copy(const EXPR_Node& node) override {
        EXPR_ElementaryGeometryNode::copy(node);
        const EXPR_Paver *paver=dynamic_cast< const EXPR_Paver *>(&node);
        if (paver!=null) {
            setMinPoint(paver->getMinPoint());
            setMaxPoint(paver->getMaxPoint());
        }
    }
    virtual void setArguments(const std::vector<tString>& args) override;
    
    inline void setBox(const tReal& x0,const tReal& x1,
                       const tReal& y0,const tReal& y1,
                       const tReal& z0,const tReal& z1) {
        tReal *P=mMinPoint.data(),*Q=mMaxPoint.data();
        *P=x0;P++;
        *P=y0;P++;
        *P=z0;
        *Q=x1;Q++;
        *Q=y1;Q++;
        *Q=z1;
      
    } 
    inline void setBox(const std::array<tReal,6>& x) {
        //iretaror on min & max points
        tReal *iP=mMinPoint.data(),*iQ=mMaxPoint.data();
        //iterators on x
        const tReal *iX=x.data();
        const tReal *eX=iX;eX+=x.size();
        
        while (iX!=eX) {
            (*iP)=(*iX);iP++;iX++;
            (*iQ)=(*iX);iQ++;iX++;
        }
      
      
    }
 
    inline void setMinPoint(const std::array<tReal,3>& A) {
        memcpy(mMinPoint.data(),A.data(),A.size()*sizeof(tReal));
    }
    inline void setMaxPoint(const std::array<tReal,3>& A) {
        memcpy(mMaxPoint.data(),A.data(),A.size()*sizeof(tReal));
    }
    inline const std::array<tReal,3>&  getMinPoint() const {
        return mMinPoint;
    }
    inline const std::array<tReal,3>&  getMaxPoint() const {
        return mMaxPoint;
    }
    inline tReal  getSize(const tUSInt& k) const {
        if (k<3) return (mMaxPoint[k]-mMinPoint[k]);
        return 0;
    }
    inline void setSize(const std::array<tReal,3>& H) {
        const tReal *iP=mMinPoint.data();
        const tReal *iH=H.data();
        for(auto& Qk:mMaxPoint) {
            Qk=(*iP)+(*iH);
            iP++;
            iH++;
        }
    }
    
    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 ;
  
        
private:
    virtual tString toString() const final;
};
 
 
 
 
 
#endif