Shape.h

Go to the documentation of this file.

#pragma once
#pragma warning(disable : 4251)

#include <Base/Base.h>
#include <Base/Enums.h>
#include <Core/DbgInfo.h>
#include <Core/Settings.h>
#include <Core/Variant.h>
#include <Geom/Bnd_Box.h>
#include <Geom/Dir.h>
#include <Geom/IndexedMesh.h>
#include <Geom/Pnt.h>
#include <Geom/Trsf.h>
#include <Topo/topo_defines.h>

#include <memory>
#include <vector>

namespace Core
{
class Variant;
class DbgInfo;
}  // namespace Core

namespace Topo
{
class TopologicalItem;
class Shape;
class LazyFacetedBrepShape;
class MeshShape;
class Compound;
class ShapeSet;
class Solid;
class Shell;
class Face;
class Wire;
class Edge;
class Coedge;
class Vertex;
class Geometry;
class ShapeAttributes;

class FacetedShape;
class IndexedDrawable;
struct GeometricInformation;

enum class ShapeType
{
    MESH,
    COMPOUND,
    COMPSOLID,
    NCOMPOUND,
    SOLID,
    SHELL,
    FACE,
    WIRE,
    EDGE,
    VERTEX,
    SHAPE,
    UNDEFINED
};

enum class OrientationType
{
    UNDEFINED,
    FORWARD,
    REVERSED,
    INTERNAL,
    EXTERNAL
};

}  // namespace Topo

typedef std::shared_ptr<Base::BaseClass> pBaseClass;
typedef std::shared_ptr<Topo::TopologicalItem> pTopologicalItem;
typedef std::shared_ptr<Topo::Shape> pShape;
typedef std::shared_ptr<Topo::LazyFacetedBrepShape> pLazyFacetedBrepShape;
typedef std::shared_ptr<Topo::MeshShape> pMesh;
typedef std::shared_ptr<Topo::Compound> pCompound;
typedef std::shared_ptr<Topo::Solid> pSolid;
typedef std::shared_ptr<Topo::Shell> pShell;
typedef std::shared_ptr<Topo::Face> pFace;
typedef std::shared_ptr<Topo::Wire> pWire;
typedef std::shared_ptr<Topo::Edge> pEdge;
typedef std::shared_ptr<Topo::Coedge> pCoedge;
typedef std::shared_ptr<Topo::Vertex> pVertex;
typedef std::shared_ptr<Topo::IndexedDrawable> pIndexedDrawable;

typedef std::shared_ptr<Base::BaseClass const> pConstBaseClass;
typedef std::shared_ptr<Topo::TopologicalItem const> pConstTopologicalItem;
typedef std::shared_ptr<Topo::Shape const> pConstShape;
typedef std::shared_ptr<Topo::LazyFacetedBrepShape const> pConstLazyFacetedBrepShape;
typedef std::shared_ptr<Topo::MeshShape const> pConstMesh;
typedef std::shared_ptr<Topo::Compound const> pConstCompound;
typedef std::shared_ptr<Topo::Solid const> pConstSolid;
typedef std::shared_ptr<Topo::Shell const> pConstShell;
typedef std::shared_ptr<Topo::Face const> pConstFace;
typedef std::shared_ptr<Topo::Wire const> pConstWire;
typedef std::shared_ptr<Topo::Edge const> pConstEdge;
typedef std::shared_ptr<Topo::Coedge const> pConstCoedge;
typedef std::shared_ptr<Topo::Vertex const> pConstVertex;

typedef std::unique_ptr<Base::BaseClass> uniqueBaseClass;
typedef std::unique_ptr<Topo::TopologicalItem> uniqueTopologicalItem;
typedef std::unique_ptr<Topo::Shape> uniqueShape;
typedef std::unique_ptr<Topo::MeshShape> uniqueMesh;
typedef std::unique_ptr<Topo::Compound> uniqueCompound;
typedef std::unique_ptr<Topo::ShapeSet> uniqueShapeSet;
typedef std::unique_ptr<Topo::Solid> uniqueSolid;
typedef std::unique_ptr<Topo::Shell> uniqueShell;
typedef std::unique_ptr<Topo::Face> uniqueFace;
typedef std::unique_ptr<Topo::Wire> uniqueWire;
typedef std::unique_ptr<Topo::Edge> uniqueEdge;
typedef std::unique_ptr<Topo::Coedge> uniqueCoedge;
typedef std::unique_ptr<Topo::Vertex> uniqueVertex;
typedef std::unique_ptr<Topo::FacetedShape> uniqueFacetedShape;


class CA_Detail;
class CA_Snap;
class ENTITY;

namespace Acis
{
class AcisShapeTool;
class AcisElementTool;
class AcisWireTool;
class AcisFaceTool;
class AcisEdgeTool;
class AcisVertexTool;
}  // namespace Acis

namespace Topo
{
class ShapeTool;
class MeshTool;
class CompoundTool;
class SolidTool;
class ShellTool;
class FaceTool;
class WireTool;
class EdgeTool;
class VertexTool;
class Shape;
class ShapeVariantHandler;

class TOPO_EXPORT ShapeTessellationQuality
{
public:
    Core::Settings::ShapeTessellationQuality quality;
    Core::Settings::ShapeTessellationMode mode;
    bool globalMeshMode;
    ShapeTessellationQuality();
};

class TOPO_EXPORT ShapeFactory
{
public:
    friend class Shape;
    static std::map<std::string, ShapeFactory*> registry;
    static pShape read(const std::string& format, const std::string& data, int version);
    static pShape read(const std::string& format, std::istream& reader);
    static pShape read(const std::string& format, const Base::String& fileName);

private:
    virtual pShape read(const std::string& data, int version) = 0;
    virtual pShape read(std::istream& reader) = 0;
    virtual pShape read(const Base::String& fileName) = 0;
};

class TOPO_EXPORT TopologicalItem

#ifndef SWIG
    : public Base::BaseClass
#endif

{
    TYPESYSTEM_HEADER();

public:
    TopologicalItem() {}
    virtual ~TopologicalItem(void) {}

    enum class MesherType
    {
        Default_Mesher,
        Acis_Mesher,
        Compound_Mesher
    };

    enum class ModellingKernel
    {
        OCC,
        ACIS,
        CARVE,
        MIXED,  // -> for compound
        UNKNOWN
    };

    virtual Topo::TopologicalItem::MesherType getMesherType() const = 0;
    virtual Topo::TopologicalItem::ModellingKernel getModellingKernel() const = 0;
    virtual pConstTopologicalItem getOwner() const = 0;
    virtual Topo::ShapeTool* getShapeTool() const = 0;
    virtual ENTITY* getEntity() const { return 0; };
    virtual bool getGeometricInformation(Topo::GeometricInformation&) const = 0;


protected:
    TopologicalItem(ENTITY* /*ent*/) {}

    pConstTopologicalItem source;

private:
};

class TOPO_EXPORT Shape : public Topo::TopologicalItem

#ifndef SWIG
    ,
                          public std::enable_shared_from_this<Topo::Shape>
#endif

{
    TYPESYSTEM_HEADER();

public:
    Shape(void);
    Shape(pConstShape rhs);
    virtual ~Shape(void);

    friend class ShapeTool;
    friend class FaceTool;

    enum CheckShape
    {
        CheckShapeIsValidAndThrowException,
        CheckShapeIsValid,
        Unchecked
    };

    mutable std::set<Core::DocObject*> m_appGeometryBackLinks;


    virtual void transform(const Geom::Trsf& t);
    virtual Geom::Trsf getTransform() const;
    virtual Topo::ShapeType getShapeType() const = 0;

    // virtual bool isEqual(pConstShape rhs) const = 0;

    operator Core::Variant() const;
    virtual pConstTopologicalItem getOwner() const;

    bool hasShapeAttributes() const;
    Topo::ShapeAttributes* getShapeAttributes() const;
    void addShapeAttributes(Topo::ShapeAttributes* atts);
    void releaseShapesAttributes();
    virtual Geom::Bnd_Box getBoundingBox() const = 0;

    virtual void setIndexMesh(pIndexedMesh m);
    virtual pIndexedMesh getIndexedMesh() const;
    virtual bool createIndexedMesh(pIndexedMesh m) const;

    virtual void setIndexedDrawable(pIndexedDrawable);
    virtual pIndexedDrawable getIndexedDrawable() const;

    virtual std::shared_ptr<Core::DbgInfo> getDbgInfo() const;
    virtual Topo::Shape* clone(bool deepcopy) const = 0;

    virtual bool getGeometricInformation(Topo::GeometricInformation&) const { return false; };

    virtual bool wasCreatedWithProblems() const { return false; }
    virtual void setWasCreatedWithProblems(bool) {}

    // virtual setIndexedMesh(  )


protected:
    Shape(ENTITY* ent);

    virtual void copyFrom(pConstShape rhs, bool deepCopy = true) = 0;
    virtual bool isSingleFace() const;
    virtual bool isSingleWire() const;
    virtual bool isSingleEdge() const;
    virtual bool isSingleVertex() const;
    virtual bool isSolid() const;
    virtual bool isClosedSolid() const;
    virtual bool isWire() const;
    virtual bool isCompound() const;
    virtual bool isMesh() const { return false; }

    bool _copy(const Topo::Shape* rhs, bool deepCopy = true);


private:
    static Topo::ShapeVariantHandler* _vHnd;
    Topo::ShapeAttributes* _myAtts = nullptr;
    pIndexedMesh _indexedMesh;
    pIndexedDrawable _indexedDrawable;
};

class TOPO_EXPORT LazyFacetedBrepShape : public Topo::Shape
{
    TYPESYSTEM_HEADER();

public:
    LazyFacetedBrepShape(void);
    LazyFacetedBrepShape(pConstShape rhs);
    virtual ~LazyFacetedBrepShape(void);
};

class TOPO_EXPORT FacetedShape
{
public:
    FacetedShape(void);
    virtual ~FacetedShape(void);

    std::vector<Geom::Pnt> face_vertices;
    std::vector<long> face_coordinateIndices;
    std::vector<Geom::Dir> face_per_vertex_normals;

    std::vector<Geom::Pnt> wire_vertices;
    std::vector<long> wire_coordinateIndices;
};


class TOPO_EXPORT MeshShape : public Topo::Shape
{
    TYPESYSTEM_HEADER();

public:
    typedef std::vector<int> MeshModel;
    typedef std::vector<MeshModel> SubMeshModels;

    MeshShape(void);
    MeshShape(pConstMesh rhs, bool deepCopy = true);
    virtual ~MeshShape(void);

    friend class MeshTool;
    virtual void copyFrom(pConstMesh rhs, bool deepCopy = true) = 0;



    virtual Geom::Bnd_Box getBoundingBox() const = 0;
    virtual pConstBrepData getMeshAsBrepData() const = 0;
    virtual void getTextureCoordinates(std::vector<Geom::Pnt2d>& textureCoordinates, std::vector<int>& textureIndices) const = 0;
    virtual bool calculateDetail(CA_Detail& detail, const CA_Snap& theSnap) = 0;
    virtual void getEdges(std::vector<std::pair<Geom::Pnt, Geom::Pnt> >& lines) const = 0;
    virtual void getPoints(std::vector<Geom::Pnt>& points) const = 0;
    virtual void getModel(Topo::MeshShape::MeshModel& model) const = 0;
    virtual void getOuterBoundaries(std::vector<Geom::Pnt>& points, std::vector<int>& edges) const = 0;
    virtual void getFacePoints(int index, std::vector<Geom::Pnt>& points) const = 0;
    virtual bool getGeometricInformation(Topo::GeometricInformation&) const { return false; };

protected:
    virtual Topo::MeshTool* getMeshTool() const = 0;

private:
    void copyFrom(pConstShape rhs, bool deepCopy = true);
};

class TOPO_EXPORT Compound : public Topo::Shape
{
    TYPESYSTEM_HEADER();

public:
    Compound(void);
    Compound(pConstCompound rhs, bool deepCopy = true);
    virtual ~Compound(void);

    friend class CompoundTool;
    virtual void copyFrom(pConstCompound rhs, bool deepCopy = true) = 0;
    virtual void transform(const Geom::Trsf&) {}
    virtual bool getGeometricInformation(Topo::GeometricInformation&) const { return false; };

protected:
    Compound(ENTITY* ent) : Shape(ent) {}
    virtual Topo::CompoundTool* getCompoundTool() const = 0;

private:
};

class TOPO_EXPORT Solid : public Topo::Shape
{
    TYPESYSTEM_HEADER();

public:
    Solid(void);
    Solid(pConstSolid rhs, bool deepCopy = true);
    virtual ~Solid(void);

    friend class SolidTool;
    virtual void copyFrom(pConstSolid rhs, bool deepCopy = true) = 0;
    virtual bool getGeometricInformation(Topo::GeometricInformation&) const { return false; };

protected:
    Solid(ENTITY* ent) : Shape(ent) {}
    virtual Topo::SolidTool* getSolidTool() const = 0;
};

class TOPO_EXPORT Shell : public Topo::TopologicalItem

#ifndef SWIG
    ,
                          public std::enable_shared_from_this<Topo::Shell>
#endif

{
    TYPESYSTEM_HEADER();

public:
    Shell(void);
    Shell(pConstShell rhs, bool deepCopy = true);
    virtual ~Shell(void);

    friend class ShellTool;
    virtual void copyFrom(pConstShell rhs, bool deepCopy = true) = 0;
    virtual bool getGeometricInformation(Topo::GeometricInformation&) const { return false; };

protected:
    Shell(ENTITY* ent) : TopologicalItem(ent) {}
    virtual Topo::ShellTool* getShellTool() const = 0;

private:
    virtual void transform(const Geom::Trsf&) {}
};


class TOPO_EXPORT Face : public Topo::TopologicalItem

#ifndef SWIG
    ,
                         public std::enable_shared_from_this<Topo::Face>
#endif

{
    TYPESYSTEM_HEADER();

public:
    Face(void);
    Face(pConstFace rhs, bool deepCopy = false);
    virtual ~Face(void);

    friend class FaceTool;

    virtual bool getFaceNormal(const Geom::Pnt& pnt, Geom::Dir& dir, Geom::Pnt& pointOnFace) const = 0;
    virtual void copyFrom(pConstFace rhs, bool deepCopy = true) = 0;
    virtual Core::DocObject* getGeometry() const;
    virtual void transform(const Geom::Trsf&) {}
    virtual bool getGeometricInformation(Topo::GeometricInformation&) const { return false; };

protected:
    Face(ENTITY* ent) : TopologicalItem(ent) {}
    virtual Topo::FaceTool* getFaceTool() const = 0;

private:
};

class TOPO_EXPORT Wire : public Topo::TopologicalItem

#ifndef SWIG
    ,
                         public std::enable_shared_from_this<Topo::Wire>
#endif

{
    TYPESYSTEM_HEADER();

public:
    Wire(void);
    Wire(pConstWire rhs, bool deepCopy = false);
    virtual ~Wire(void);

    friend class WireTool;
    friend class Acis::AcisWireTool;

    virtual void copyFrom(pConstWire rhs, bool deepCopy = true) = 0;
    virtual int getEdgeCount() const = 0;
    virtual pConstEdge getEdgeByIndex(int idx) const = 0;
    virtual void transform(const Geom::Trsf&) {}
    virtual bool isLoop() const;
    virtual bool getGeometricInformation(Topo::GeometricInformation&) const { return false; };

protected:
    Wire(ENTITY* ent) : TopologicalItem(ent) {}
    virtual Topo::WireTool* getWireTool() const = 0;

private:
};

class TOPO_EXPORT Edge : public Topo::TopologicalItem

#ifndef SWIG
    ,
                         public std::enable_shared_from_this<Topo::Edge>
#endif

{
    TYPESYSTEM_HEADER();

public:
    Edge(void);
    Edge(pConstEdge rhs, bool deepCopy = true);
    virtual ~Edge(void);

    friend class EdgeTool;

    virtual void copyFrom(pConstEdge rhs, bool deepCopy = true) = 0;
    operator Core::Variant() const;
    virtual void transform(const Geom::Trsf&) {}
    virtual bool getGeometricInformation(Topo::GeometricInformation&) const { return false; };

protected:
    Edge(ENTITY* ent) : TopologicalItem(ent) {}
    virtual Topo::EdgeTool* getEdgeTool() const = 0;

private:
    double _passagePntParam;
    bool _hasPassagePntParam;
};

class TOPO_EXPORT Coedge : public Topo::TopologicalItem

#ifndef SWIG
    ,
                           public std::enable_shared_from_this<Topo::Coedge>
#endif

{
    TYPESYSTEM_HEADER();

public:
    Coedge(void);
    Coedge(pConstCoedge rhs, bool deepCopy = true);
    virtual ~Coedge(void);

    friend class EdgeTool;

    virtual void copyFrom(pConstCoedge rhs, bool deepCopy = true) = 0;
    operator Core::Variant() const;
    virtual void transform(const Geom::Trsf&) {}
    virtual pConstEdge getEdge() const = 0;
    virtual bool getGeometricInformation(Topo::GeometricInformation&) const { return false; };

protected:
    Coedge(ENTITY* ent) : TopologicalItem(ent) {}
    virtual Topo::EdgeTool* getEdgeTool() const = 0;

private:
    double _passagePntParam;
    bool _hasPassagePntParam;
};

class TOPO_EXPORT Vertex : public Topo::TopologicalItem

#ifndef SWIG
    ,
                           public std::enable_shared_from_this<Topo::Vertex>
#endif

{
    TYPESYSTEM_HEADER();

public:
    Vertex(void);
    Vertex(pConstVertex rhs, bool deepCopy = true);
    virtual ~Vertex(void);

    friend class VertexTool;

    virtual void copyFrom(pConstVertex rhs, bool deepCopy = true) = 0;
    virtual Geom::Pnt getPoint() const = 0;
    virtual void transform(const Geom::Trsf&) {}
    virtual bool getGeometricInformation(Topo::GeometricInformation&) const { return false; };

protected:
    Vertex(ENTITY* ent) : TopologicalItem(ent) {}
    virtual Topo::VertexTool* getVertexTool() const = 0;

private:
};


class TOPO_EXPORT ShapeVariantHandler : public Core::VariantHandler
{
public:
    Core::Variant create();
    bool isEqual(const Core::Variant& v1, const Core::Variant& v2, double /*tolerance*/ = 1E-06) const
    {
        bool ok1, ok2;
        if (v1.getValue<pShape>(&ok1) == v2.getValue<pShape>(&ok2) && ok1 && ok2)
            return true;
        else
            return false;
    }
    int getType() { return (int)Core::Variant::Shape; }
    Base::String getAsString(const Core::Variant& v) const;
};

class TOPO_EXPORT ConstShapeVariantHandler : public Core::VariantHandler
{
public:
    Core::Variant create();
    bool isEqual(const Core::Variant& v1, const Core::Variant& v2, double /*tolerance*/ = 1E-06) const
    {
        bool ok1, ok2;
        if (v1.getValue<pConstShape>(&ok1) == v2.getValue<pConstShape>(&ok2) && ok1 && ok2)
            return true;
        else
            return false;
    }
    int getType() { return (int)Core::Variant::ConstShape; }
    Base::String getAsString(const Core::Variant& v) const;
};



class TOPO_EXPORT ToolOutcome
{
public:
    ToolOutcome();
    ToolOutcome(bool okay);
    ~ToolOutcome();

    bool isOkay();
    void setOkay(bool ok);

private:
    bool _okay;
};

class SpecialFaceInfo
{
public:
    virtual Geom::SurfaceType getSurfaceType() const = 0;
};

class SpecialFaceInfo_Cylinder : public SpecialFaceInfo
{
public:
    Geom::SurfaceType getSurfaceType() const { return Geom::SurfaceType::CYLINDER; }
    Geom::Ax2 position;
    double radius;
};

class SpecialFaceInfo_Cone : public SpecialFaceInfo
{
public:
    Geom::SurfaceType getSurfaceType() const { return Geom::SurfaceType::CONE; }
    Geom::Ax2 position;
    double angle;
    double radius;
};

class TOPO_EXPORT IndexedFace
{
public:
    IndexedFace();
    IndexedFace(const IndexedFace& rhs);
    std::vector<Geom::Pnt> vertices;
    std::vector<Geom::Dir> verticesNormals;
    std::vector<int> coordinateIndices;
    int index;
    std::shared_ptr<Topo::SpecialFaceInfo> info;
    void dump() const;
};

class TOPO_EXPORT IndexedEdge
{
public:
    IndexedEdge();
    IndexedEdge(const IndexedEdge& rhs);
    std::vector<Geom::Pnt> vertices;
    std::vector<int> edge_coordinateIndices;
    int index;
    void dump() const;
};


class TOPO_EXPORT IndexedDrawable
{
public:
    IndexedDrawable(void);
    IndexedDrawable(const IndexedDrawable& rhs);
    virtual ~IndexedDrawable(void);
    std::vector<IndexedFace> faces;
    std::vector<IndexedEdge> edges;
    void clean();
    std::string createMD5();
    void create_IndexedMesh(Geom::IndexedMesh& mesh);
    // void* faces_root = 0;
    // void* edges_root = 0;
    // std::string md5;
    virtual void transform(Geom::Trsf& t);
    void dump();
};

}  // namespace Topo

#define REGISTER_SHAPE_FACTORY(_factoryName_, _shapeFormat_) Topo::ShapeFactory::registry[_shapeFormat_] = (Topo::ShapeFactory*)new _factoryName_();