BrepData.h

Go to the documentation of this file.

#pragma warning(disable : 4251)

#pragma once

#include <Geom/Dir.h>
#include <Geom/GeomEnums.h>
#include <Geom/Pnt.h>
#include <Geom/PointMapWithTolerance.h>
#include <Geom/Precision.h>
#include <Geom/geom_defines.h>

#include <map>
#include <memory>
#include <vector>

namespace Core
{
class PropertyBrepData;
class PropertyBrepDataSet;
}  // namespace Core

namespace Topo
{
class FaceTool;
}

namespace Geom
{
class BrepLoop;
class BrepFace;
class BrepData;
}  // namespace Geom

typedef std::shared_ptr<Geom::BrepData> pBrepData;
typedef std::shared_ptr<Geom::BrepFace> pBrepFace;
typedef std::shared_ptr<Geom::BrepFace> pBrepLoop;
typedef std::shared_ptr<const Geom::BrepData> pConstBrepData;
typedef std::shared_ptr<const Geom::BrepFace> pConstBrepFace;
typedef std::shared_ptr<const Geom::BrepLoop> pConstBrepLoop;

GEOM_EXPIMP_TEMPLATE template class GEOM_EXPORT std::weak_ptr<const Geom::BrepData>;
GEOM_EXPIMP_TEMPLATE template class GEOM_EXPORT std::weak_ptr<const Geom::BrepFace>;
GEOM_EXPIMP_TEMPLATE template class GEOM_EXPORT std::enable_shared_from_this<const Geom::BrepData>;
GEOM_EXPIMP_TEMPLATE template class GEOM_EXPORT std::enable_shared_from_this<const Geom::BrepFace>;

namespace Geom
{
class BrepFaceP;
class BrepLoopP;
class BrepDataP;

class GEOM_EXPORT BrepEdge : public std::enable_shared_from_this<const Geom::BrepEdge>
{
public:
};

class GEOM_EXPORT BrepStraight : public Geom::BrepEdge
{
public:
    int from = -1;
    int to = -1;
};

class GEOM_EXPORT BrepArc : public Geom::BrepEdge
{
public:
    int center = -1;
    double radius = 0;
    double trim1 = 0;
    double trim2 = 0;
    bool sense = true;
};

class GEOM_EXPORT BrepFace : public std::enable_shared_from_this<const Geom::BrepFace>
{
public:
    BrepFace(pConstBrepData elem, int idx, size_t itPos);
    virtual ~BrepFace();
    std::vector<int> getModel() const;
    bool getFaceNormal(Geom::Dir& normal, Geom::Pnt& pntOnFace) const;
    pConstBrepLoop getOuterLoop() const;
    std::vector<pConstBrepLoop> getInnerLoops() const;
    pConstBrepData getElement() const;

private:
    BrepFaceP* _pimpl = nullptr;
    BrepFace() {}
};

class GEOM_EXPORT BrepLoop
{
public:
    BrepLoop(pConstBrepFace face, const std::vector<int>& model);
    virtual ~BrepLoop();
    void getPolygon(std::vector<Geom::Pnt>& poly) const;
    std::vector<const Geom::Pnt*> getPolygonPtr() const;
    const std::vector<int>& getModel() const;

private:
    BrepLoop() {}
    BrepLoopP* _pimpl = nullptr;
};

class GEOM_EXPORT BrepData : public std::enable_shared_from_this<const Geom::BrepData>
{
public:
    //                                                       //
    // --------------------- BEGIN API --------------------- //
    //                                                       //
    // ATTENTION: DO NOT CHANGE ANY SIGNATURES IN THE API !  //
    //                                                       //

    friend class Core::PropertyBrepData;
    friend class Core::PropertyBrepDataSet;
    friend class BrepFace;
    friend class BrepLoop;
    friend class Topo::FaceTool;


    BrepData();
    BrepData(double tolerance);
    ~BrepData(void);

    BrepData::BrepData(const BrepData& p);
    BrepData(const std::vector<Geom::Pnt>& baseFace, const Geom::Vec& extrude);

    std::vector<Geom::Pnt> getPoints() const;
    int64_t getUniquePointsCnt() const;
    std::vector<int> getModel() const;
    void setModel(const std::vector<int>& model);

    bool checkLoop(const std::vector<int>& model) const;
    bool hasDegeneratedLoops() const;

    void add(pConstBrepData data);
    int addUniquePoint(const Geom::Pnt& p);
    int addModelIndex(int idx);
    int getModelIndexAt(int idx) const;
    const Geom::Pnt* getPointAt(int idx) const;
    bool hasPoint(const Geom::Pnt& p);
    void setEmpty();

    bool isEmpty() const;
    int getFaceCount() const;

    std::vector<pConstBrepFace> getFaces() const;
    double getModelingTolerance() const { return _tolerance; }
    bool hasVoids() const;
    void reverse();
    void lock();
    void unlock();

    Geom::BrepData& operator=(const Geom::BrepData& rhs);
    bool operator==(const Geom::BrepData& other) const;
    bool operator!=(const Geom::BrepData& other) const;

    void addFace(std::vector<int> index);

    //                                                       //
    // ---------------------- END API ---------------------- //
    //                                                       //

    int64_t addUniquePointCheckIsNew(const Geom::Pnt& p, bool& r_is_new);

    void transform(const Geom::Trsf& T);
    Geom::BrepData transformed(const Geom::Trsf& T) const;

    void dump();
    void _addPointAtIndex(const Geom::Pnt& p, int idx);

private:
    // pConstBrepFace getFace(int idx) const;

    // BrepDataPimp* _private;


#ifdef _MSC_VER
#pragma warning(disable : 4251)
#endif
    Geom::PointMapWithTolerance uniquePoints;
    std::vector<int> model;
    int highestIndex;
    double _tolerance;

    BrepDataP* _pimpl;
};



}  // namespace Geom