BasicShapes.hpp

/*---------------------------------------------------------------------------*\
 *
 *  mimmo
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of mimmo.
 *
 *  mimmo is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  mimmo is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
 *  License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with mimmo. If not, see <http://www.gnu.org/licenses/>.
 *
 \ *---------------------------------------------------------------------------*/
 
#ifndef __MIMMOBASICSHAPES_HH
#define __MIMMOBASICSHAPES_HH
 
#include "MimmoObject.hpp"
#include <mimmo_binary_stream.hpp>
#include <unordered_set>
 
namespace mimmo{
 
enum class ShapeType{
    CUBE    =0, 
    CYLINDER=1, 
    SPHERE  =3, 
    WEDGE   =4  
};
 
enum class CoordType{
 
    UNCLAMPED =0,  
    CLAMPED   =1,  
    PERIODIC  =2,  
    SYMMETRIC =3  
};
 
}
//Binary stream occurring to Classes memebers for port exchange
mimmo::IBinaryStream& operator>>(mimmo::IBinaryStream &buf, mimmo::CoordType& element);
mimmo::OBinaryStream& operator<<(mimmo::OBinaryStream &buf, const mimmo::CoordType& element);
 
mimmo::IBinaryStream& operator>>(mimmo::IBinaryStream &buf, mimmo::ShapeType& element);
mimmo::OBinaryStream& operator<<(mimmo::OBinaryStream &buf, const mimmo::ShapeType& element);
 namespace mimmo{
 
class BasicShape {
 
protected:
    ShapeType   m_shape;        
    darray3E    m_origin;       
    darray3E    m_span;         
    darray3E    m_infLimits;    
    dmatrix33E  m_sdr;          
    dmatrix33E  m_sdr_inverse;  
    darray3E    m_scaling;      
    std::array<CoordType,3>     m_typeCoord;    
    dvecarr3E m_bbox;     //temporary not copied build with get bounding box !!!
 
public:
 
    //Costructors, Destructor
    BasicShape();
    virtual ~BasicShape();
 
    //set-get methods
    void        setOrigin(darray3E);
    void        setSpan(double, double, double);
    void        setSpan(darray3E);
    void        setInfLimits(double val, int dir);
    void        setInfLimits(darray3E val);
    void        setRefSystem(darray3E, darray3E, darray3E);
    void        setRefSystem(int, darray3E);
    void        setRefSystem(dmatrix33E axes);
    void        setCoordinateType(CoordType, int dir);
 
    darray3E    getOrigin();
    darray3E    getSpan();
    darray3E    getInfLimits();
    dmatrix33E  getRefSystem();
    CoordType   getCoordinateType(int dir);
    ShapeType   getShapeType();
    ShapeType   getShapeType() const;
 
    darray3E    getScaling();
    darray3E    getLocalSpan();
 
 
    //functionalities
    livector1D  includeGeometry(MimmoSharedPointer<MimmoObject> );
    livector1D  excludeGeometry(MimmoSharedPointer<MimmoObject> );
 
    livector1D  includeGeometry(bitpit::PatchKernel * );
    livector1D  excludeGeometry(bitpit::PatchKernel * );
 
    livector1D  includeCloudPoints(const dvecarr3E &);
    livector1D  excludeCloudPoints(const dvecarr3E &);
 
    livector1D  includeCloudPoints(bitpit::PatchKernel * );
    livector1D  excludeCloudPoints(bitpit::PatchKernel * );
 
    livector1D  includeCloudPoints(MimmoSharedPointer<MimmoObject> );
    livector1D  excludeCloudPoints(MimmoSharedPointer<MimmoObject> );
 
    bool        isSimplexIncluded(const dvecarr3E &);
    bool        isSimplexIncluded(bitpit::PatchKernel * , const long int &indexT);
    bool        isPointIncluded(const darray3E &);
    bool        isPointIncluded(bitpit::PatchKernel * , const long int &indexV);
 
    virtual bool    intersectShapeAABBox(const darray3E &bMin, const darray3E &bMax)=0;
 
 
    virtual darray3E    toWorldCoord(const darray3E & point)=0;
 
    virtual darray3E    toLocalCoord(const darray3E & point)=0;
 
    virtual darray3E    getLocalOrigin()=0;
 
protected:
    uint32_t    intersectShapePlane(int level, const darray3E & target);
    darray3E    checkNearestPointToAABBox(const darray3E &point, const darray3E &bMin, const darray3E &bMax);
    void swap(BasicShape & ) noexcept;
    static dmatrix33E transpose(const dmatrix33E & mat);
    static dmatrix33E inverse(const dmatrix33E & mat);
    static darray3E   matmul(const darray3E & vec, const dmatrix33E & mat);
    static darray3E   matmul(const dmatrix33E & mat,const darray3E & vec);
 
private:
    virtual darray3E    basicToLocal(const darray3E &point)=0;
 
    virtual darray3E    localToBasic(const darray3E &point)=0;
 
    virtual void    checkSpan(double &s0, double &s1, double &s2)=0;
 
    virtual bool    checkInfLimits(double & orig, int &dir)=0;
 
    virtual void    setScaling(const double &s0, const double &s1, const double &s2)=0;
 
    void        searchKdTreeMatches(bitpit::KdTree<3,bitpit::Vertex,long> & tree, livector1D & result, bool squeeze = true);
    void        searchBvTreeMatches(bitpit::PatchSkdTree & tree, bitpit::PatchKernel * geo, livector1D & result, bool squeeze = true);
 
    virtual void    getTempBBox()=0;
};
 
class Cube: public BasicShape {
 
public:
 
    //Costructors, Destructor, Copy/Assignment operators
    Cube();
    Cube(const darray3E &origin, const darray3E &span);
    ~Cube();
 
    Cube(const Cube &);
 
    //reimplementing pure virtuals
 
    darray3E    toWorldCoord(const darray3E &point);
    darray3E    toLocalCoord(const darray3E &point);
    darray3E    getLocalOrigin();
    bool    intersectShapeAABBox(const darray3E &bMin, const darray3E &bMax);
 
private:
    darray3E    basicToLocal(const darray3E &point);
    darray3E    localToBasic(const darray3E &point);
    void        checkSpan(double &, double &, double &);
    bool        checkInfLimits(double &, int & dir);
    void        setScaling(const double &, const double &, const double &);
    void        getTempBBox();
};
 
class Cylinder: public BasicShape {
 
public:
    //Costructors, Destructor, Copy/Assignment operators
    Cylinder();
    Cylinder(const darray3E &origin, const darray3E &span);
    ~Cylinder();
 
    Cylinder(const Cylinder &);
 
    //reimplementing pure virtuals
    darray3E    toWorldCoord(const darray3E &point);
    darray3E    toLocalCoord(const darray3E &point);
    darray3E    getLocalOrigin();
    bool        intersectShapeAABBox(const darray3E &bMin, const darray3E &bMax);
 
private:
    darray3E    basicToLocal(const darray3E &point);
    darray3E    localToBasic(const darray3E &point);
    void        checkSpan(double &, double &, double &);
    bool        checkInfLimits( double &, int &);
    void        setScaling(const double &, const double &, const double &);
    void        getTempBBox();
};
 
 
class Sphere: public BasicShape {
 
public:
    //Costructors, Destructor, Copy/Assignment operators
    Sphere();
    Sphere(const darray3E &origin, const darray3E &span);
    ~Sphere();
 
    Sphere(const Sphere &);
 
    //reimplementing pure virtuals
    darray3E    toWorldCoord(const darray3E &point);
    darray3E    toLocalCoord(const darray3E &point);
    darray3E    getLocalOrigin();
    bool        intersectShapeAABBox(const darray3E &bMin, const darray3E &bMax);
 
private:
    darray3E    basicToLocal(const darray3E &point);
    darray3E    localToBasic(const darray3E &point);
    void        checkSpan(double &, double &, double &);
    bool        checkInfLimits(double &, int &);
    void        setScaling(const double &, const double &, const double &);
    void        getTempBBox();
};
 
class Wedge: public BasicShape {
 
public:
 
    //Costructors, Destructor, Copy/Assignment operators
    Wedge();
    Wedge(const darray3E &origin, const darray3E &span);
    ~Wedge();
 
    Wedge(const Wedge &);
 
    //reimplementing pure virtuals
    darray3E    toWorldCoord(const darray3E &point);
    darray3E    toLocalCoord(const darray3E &point);
    darray3E    getLocalOrigin();
    bool        intersectShapeAABBox(const darray3E &bMin, const darray3E &bMax);
 
private:
    darray3E    basicToLocal(const darray3E &point);
    darray3E    localToBasic(const darray3E &point);
    void        checkSpan( double &, double &, double &);
    bool        checkInfLimits(double &, int &);
    void        setScaling(const double &, const double &, const double &);
    void        getTempBBox();
 
};
 
 
 
}
 
#endif //  __MIMMOBASICSHAPES_HH