d8/dad/_f_m_mdl_body_8h_source.html

// Copyright (C) 2002-2022, Open Design Alliance (the "Alliance").

// All rights reserved.

//

// This software and its documentation and related materials are owned by

// the Alliance. The software may only be incorporated into application

// programs owned by members of the Alliance, subject to a signed

// Membership Agreement and Supplemental Software License Agreement with the

// Alliance. The structure and organization of this software are the valuable

// trade secrets of the Alliance and its suppliers. The software is also

// protected by copyright law and international treaty provisions. Application

// programs incorporating this software must include the following statement

// with their copyright notices:

//

//   This application incorporates Open Design Alliance software pursuant to a license

//   agreement with Open Design Alliance.

//   Open Design Alliance Copyright (C) 2002-2022 by Open Design Alliance.

//   All rights reserved.

//

// By use of this software, its documentation or related materials, you

// acknowledge and accept the above terms.


#ifndef __FMMDL_BODY_H__

#define __FMMDL_BODY_H__


#include "Modeler/FMMdlBase.h"

#include "FMContour3D.h"

#include "FMProfile3D.h"


class OdGeCircArc3d;

namespace GeMesh { class OdGeTrMesh; }


namespace FacetModeler

{

  class FMGEOMETRY_API Body

  {

  public:

    Body();


    Body(const Body& B);


    Body& operator = (const Body& B);


    bool operator == (const Body& aBody) const;


    bool operator != (const Body& aBody) const;


    void clear();


    Body clone() const;


    Body combine(Body& rAnother);


    void decomposeIntoLumps(std::vector<Body>& aLumps);


    void transform(const OdGeMatrix3d& mMatrix);


    void negate();


    void regeneratePairEdges();


    void deleteUnusedVertices();


    bool mergeCoincidentVertices();


    void mergeCoplanarEntities();


    bool containsNonManifoldEdges() const;


    bool checkInternalConsistence(OdString* pFirstErrorDetected = NULL) const;


    bool hasCoincidentEdges() const;


    bool hasCoincidentVertices() const;


    bool isNull() const;


    bool isClosed() const;


    void splitFace(Face* pFace,

      const OdGePlane& pPlane,

      std::vector<Face*>* pNewOuter = NULL,

      std::vector<Face*>* pNewInner = NULL);


    // Tags and flags


    void clearVertexTags(TagType clearValue = 0);


    void clearSurfaceTags(TagType clearValue = 0);


    void clearEdgeTags(TagType clearValue = 0);


    void clearFaceTags(TagType clearValue = 0);


    void clearFaceFlags(OdUInt32 clearValue = 0);


    inline void clearBodyTags(TagType clearValue = 0) { setTag(clearValue); }


    TagType tag() const;


    void setTag(TagType iTag);


    // Geometric properties


    OdGeExtents3d interval() const;


    double volume() const;


    // Intersections


    void slice(const OdGePlane& rCutter,

      Profile3D& rResult, bool bIncludeBoundary = true) const;


    void slice(const OdGePlane& rCutter, Body& result, TagType tagSection = 0) const;


    bool intersectLine(const OdGeLinearEnt3d& gLine,

      std::vector< OdGePoint3d >& aPoints, bool bSortResults = false) const;


    // Primitives


    static Body box(const OdGePoint3d& ptOrigin,

      const OdGeVector3d& vSizes);


    static Body pyramid(const Profile2D& rBase,

      const OdGePoint3d& ptApex,

      const DeviationParams& deviation = FMGeGbl::gDefDev);


    static Body extrusion(const Profile2D& rBase,

      const OdGeVector3d& vDir,

      const DeviationParams& deviation = FMGeGbl::gDefDev);


    static Body extrusion(const Profile2D& rBase,

        const Contour3D& rPath,

        const DeviationParams& deviation = FMGeGbl::gDefDev);


    static Body extrusion(const Profile2D& rBase,

        const OdGePoint3dArray& rPath,

        const OdGeVector3d& vNormal,

        const DeviationParams& devDeviation = FMGeGbl::gDefDev);


    static Body extrusion(const Profile2D& rBase,

      const OdGeMatrix3d& mBasePlane,

      const OdGeVector3d& vDir,

      const DeviationParams& deviation = FMGeGbl::gDefDev);


    static Body revolution(const Profile2D& rBase,

      double dRadius, double dHeight,

      const DeviationParams& deviation = FMGeGbl::gDefDev);


    static Body revolution(

      const Profile2D& base,

      const OdGeCircArc3d& revAxisAndAngles,

      const DeviationParams& deviation = FMGeGbl::gDefDev,

      const OdGeMatrix2d* pBaseTransform = NULL);


    static Body revolution(

      const Profile2D& base,

      const OdGeVector3d& revAxis,

      const OdGePoint3d& axisPosition,

      double startAng,

      double endAng,

      const DeviationParams& deviation = FMGeGbl::gDefDev);


    static Body boolOper(BooleanOperation eOperation,

      Body& rOperandA, Body& rOperandB, bool bOptimization = false);


    static Body createFromMesh(

      const std::vector<OdGePoint3d>& aVertices,

      const std::vector<OdInt32>& aFaceData,

      const std::vector<OdUInt32>* aFaceFlags = NULL,

      const std::vector<OdUInt32>* aEdgeFlags = NULL,

      const std::vector<OdUInt32>* aVertexFlags = NULL,

      const std::vector<OdUInt32>* pFaceColors = NULL,

      const std::vector<OdUInt32>* pEdgeColors = NULL,

      const std::vector<OdGePoint2d>* pMappingCoords = NULL

    );


    void generateMesh(GeMesh::OdGeTrMesh& mesh) const;


    // Working with topological entities


    void setColor(OdUInt32 iColor);


    void addFace(Face* pFace);


    void removeFace(Face* pFace);


    void deleteFace(Face* pFace);


    void addSurface(Surface* pSurface);


    void addVertex(Vertex* pVertex);


    Vertex* addVertex(const OdGePoint3d& pt);


    Face* addFace(Surface* pSurface = NULL);


    OdUInt32 vertexCount() const;


    OdUInt32 countEdges() const;


    OdUInt32 cachedEdgesCount() const;


    OdUInt32 faceCount() const;


    OdUInt32 surfaceCount() const;


    Face* faceList() const;


    Vertex* vertexList() const;


    Surface* surfaceList() const;


    void setVertexList(Vertex* pList);


    void setFaceList(Face* pList);


    void setSurfaceList(Surface* pList);


    void deleteUnusedSurfaces();


    void setVertexCount(OdUInt32 count);


    void setFaceCount(OdUInt32 count);


    void setSurfaceCount(OdUInt32 count);


    FMGEOMETRY_API_STATIC static const Body kEmpty;


    ~Body();


    void simplify(double param);


#if 0

  public:

    void testCheckUnusedSurfaceData();

#endif


  protected:

    explicit Body(class BodyImpl* pImpl);


  private:


    BodyImpl* m_pImpl; // Implementation object pointer.


    //DOM-IGNORE-BEGIN

    friend class Vertex;

    friend class Face;

    friend class Surface;

    friend class BodyImpl;

    friend class BodyCustom;

    friend class BodyInternalConsistencyRestorer;

    //DOM-IGNORE-END

  };


  FMGEOMETRY_API void MarkShadedSurfaces(Body& aBody, double angleTol, bool bDetectSharpEdges = false);


  FMGEOMETRY_API void ClearShadedSurfaces(Body& aBody);


  void MergeShadedSurfaces(Body& aBody, const OdArray<std::set<Surface*> >& shadedMergeData);


FMGEOMETRY_API Body extrusion( const Profile2D& rBase,

                               const OdGeMatrix3d& mBasePlane,

                               const OdGeVector3d& vDir,

                               const DeviationParams& devDeviation = FMGeGbl::gDefDev );


FMGEOMETRY_API Body revolution( const Profile2D& base,

                                const OdGeVector3d& revAxis,

                                const OdGePoint3d& axisPosition,

                                double startAng,

                                double endAng,

                                const DeviationParams& deviation = FMGeGbl::gDefDev );


}


#endif //__FMMDL_BODY_H__

FMGEOMETRY_API
#define FMGEOMETRY_API
Definition: FMBuildSettings.h:37

FMGEOMETRY_API_STATIC
#define FMGEOMETRY_API_STATIC
Definition: FMBuildSettings.h:38

FMContour3D.h

FMMdlBase.h

FMProfile3D.h

operator!=
bool operator!=(T left, const OdGiVariant::EnumType right)
Definition: GiVariant.h:403

operator==
bool operator==(T left, const OdGiVariant::EnumType right)
Definition: GiVariant.h:397

OdUInt32
unsigned int OdUInt32
Definition: OdPlatformSettings.h:814

FacetModeler::Body
Definition: FMMdlBody.h:40

FacetModeler::Body::pyramid
static Body pyramid(const Profile2D &rBase, const OdGePoint3d &ptApex, const DeviationParams &deviation=FMGeGbl::gDefDev)

FacetModeler::Body::~Body
~Body()

FacetModeler::Body::extrusion
static Body extrusion(const Profile2D &rBase, const Contour3D &rPath, const DeviationParams &deviation=FMGeGbl::gDefDev)

FacetModeler::Body::setVertexList
void setVertexList(Vertex *pList)

FacetModeler::Body::removeFace
void removeFace(Face *pFace)

FacetModeler::Body::deleteUnusedSurfaces
void deleteUnusedSurfaces()

FacetModeler::Body::checkInternalConsistence
bool checkInternalConsistence(OdString *pFirstErrorDetected=NULL) const

FacetModeler::Body::setSurfaceCount
void setSurfaceCount(OdUInt32 count)

FacetModeler::Body::mergeCoincidentVertices
bool mergeCoincidentVertices()

FacetModeler::Body::surfaceList
Surface * surfaceList() const

FacetModeler::Body::setTag
void setTag(TagType iTag)

FacetModeler::Body::surfaceCount
OdUInt32 surfaceCount() const

FacetModeler::Body::extrusion
static Body extrusion(const Profile2D &rBase, const OdGeVector3d &vDir, const DeviationParams &deviation=FMGeGbl::gDefDev)

FacetModeler::Body::createFromMesh
static Body createFromMesh(const std::vector< OdGePoint3d > &aVertices, const std::vector< OdInt32 > &aFaceData, const std::vector< OdUInt32 > *aFaceFlags=NULL, const std::vector< OdUInt32 > *aEdgeFlags=NULL, const std::vector< OdUInt32 > *aVertexFlags=NULL, const std::vector< OdUInt32 > *pFaceColors=NULL, const std::vector< OdUInt32 > *pEdgeColors=NULL, const std::vector< OdGePoint2d > *pMappingCoords=NULL)

FacetModeler::Body::setVertexCount
void setVertexCount(OdUInt32 count)

FacetModeler::Body::addSurface
void addSurface(Surface *pSurface)

FacetModeler::Body::slice
void slice(const OdGePlane &rCutter, Profile3D &rResult, bool bIncludeBoundary=true) const

FacetModeler::Body::deleteUnusedVertices
void deleteUnusedVertices()

FacetModeler::Body::box
static Body box(const OdGePoint3d &ptOrigin, const OdGeVector3d &vSizes)

FacetModeler::Body::combine
Body combine(Body &rAnother)

FacetModeler::Body::clearFaceFlags
void clearFaceFlags(OdUInt32 clearValue=0)

FacetModeler::Body::volume
double volume() const

FacetModeler::Body::boolOper
static Body boolOper(BooleanOperation eOperation, Body &rOperandA, Body &rOperandB, bool bOptimization=false)

FacetModeler::Body::regeneratePairEdges
void regeneratePairEdges()

FacetModeler::Body::faceCount
OdUInt32 faceCount() const

FacetModeler::Body::splitFace
void splitFace(Face *pFace, const OdGePlane &pPlane, std::vector< Face * > *pNewOuter=NULL, std::vector< Face * > *pNewInner=NULL)

FacetModeler::Body::Body
Body()

FacetModeler::Body::intersectLine
bool intersectLine(const OdGeLinearEnt3d &gLine, std::vector< OdGePoint3d > &aPoints, bool bSortResults=false) const

FacetModeler::Body::transform
void transform(const OdGeMatrix3d &mMatrix)

FacetModeler::Body::clear
void clear()

FacetModeler::Body::revolution
static Body revolution(const Profile2D &rBase, double dRadius, double dHeight, const DeviationParams &deviation=FMGeGbl::gDefDev)

FacetModeler::Body::clearBodyTags
void clearBodyTags(TagType clearValue=0)
Definition: FMMdlBody.h:259

FacetModeler::Body::slice
void slice(const OdGePlane &rCutter, Body &result, TagType tagSection=0) const

FacetModeler::Body::setFaceList
void setFaceList(Face *pList)

FacetModeler::Body::cachedEdgesCount
OdUInt32 cachedEdgesCount() const

FacetModeler::Body::faceList
Face * faceList() const

FacetModeler::Body::addFace
void addFace(Face *pFace)

FacetModeler::Body::extrusion
static Body extrusion(const Profile2D &rBase, const OdGeMatrix3d &mBasePlane, const OdGeVector3d &vDir, const DeviationParams &deviation=FMGeGbl::gDefDev)

FacetModeler::Body::vertexList
Vertex * vertexList() const

FacetModeler::Body::clearEdgeTags
void clearEdgeTags(TagType clearValue=0)

FacetModeler::Body::addVertex
Vertex * addVertex(const OdGePoint3d &pt)

FacetModeler::Body::negate
void negate()

FacetModeler::Body::hasCoincidentEdges
bool hasCoincidentEdges() const

FacetModeler::Body::setSurfaceList
void setSurfaceList(Surface *pList)

FacetModeler::Body::setColor
void setColor(OdUInt32 iColor)

FacetModeler::Body::hasCoincidentVertices
bool hasCoincidentVertices() const

FacetModeler::Body::vertexCount
OdUInt32 vertexCount() const

FacetModeler::Body::mergeCoplanarEntities
void mergeCoplanarEntities()

FacetModeler::Body::revolution
static Body revolution(const Profile2D &base, const OdGeVector3d &revAxis, const OdGePoint3d &axisPosition, double startAng, double endAng, const DeviationParams &deviation=FMGeGbl::gDefDev)

FacetModeler::Body::setFaceCount
void setFaceCount(OdUInt32 count)

FacetModeler::Body::isClosed
bool isClosed() const

FacetModeler::Body::clearSurfaceTags
void clearSurfaceTags(TagType clearValue=0)

FacetModeler::Body::containsNonManifoldEdges
bool containsNonManifoldEdges() const

FacetModeler::Body::clearFaceTags
void clearFaceTags(TagType clearValue=0)

FacetModeler::Body::generateMesh
void generateMesh(GeMesh::OdGeTrMesh &mesh) const

FacetModeler::Body::interval
OdGeExtents3d interval() const

FacetModeler::Body::extrusion
static Body extrusion(const Profile2D &rBase, const OdGePoint3dArray &rPath, const OdGeVector3d &vNormal, const DeviationParams &devDeviation=FMGeGbl::gDefDev)

FacetModeler::Body::Body
Body(const Body &B)

FacetModeler::Body::countEdges
OdUInt32 countEdges() const

FacetModeler::Body::revolution
static Body revolution(const Profile2D &base, const OdGeCircArc3d &revAxisAndAngles, const DeviationParams &deviation=FMGeGbl::gDefDev, const OdGeMatrix2d *pBaseTransform=NULL)

FacetModeler::Body::simplify
void simplify(double param)

FacetModeler::Body::decomposeIntoLumps
void decomposeIntoLumps(std::vector< Body > &aLumps)

FacetModeler::Body::addVertex
void addVertex(Vertex *pVertex)

FacetModeler::Body::clearVertexTags
void clearVertexTags(TagType clearValue=0)

FacetModeler::Body::tag
TagType tag() const

FacetModeler::Body::deleteFace
void deleteFace(Face *pFace)

FacetModeler::Body::kEmpty
static FMGEOMETRY_API_STATIC const Body kEmpty
Definition: FMMdlBody.h:710

FacetModeler::Body::clone
Body clone() const

FacetModeler::Body::addFace
Face * addFace(Surface *pSurface=NULL)

FacetModeler::Body::isNull
bool isNull() const

FacetModeler::Body::Body
Body(class BodyImpl *pImpl)

FacetModeler::Contour3D
Definition: FMContour3D.h:40

FacetModeler::Face
Definition: FMMdlFace.h:43

FacetModeler::Profile2D
Definition: FMProfile2D.h:36

FacetModeler::Profile3D
Definition: FMProfile3D.h:40

FacetModeler::Surface
Definition: FMMdlSurface.h:37

FacetModeler::Vertex
Definition: FMMdlVertex.h:38

GeMesh::OdGeTrMesh
Definition: GeTrMeshSimplification.h:85

OdArray< OdGePoint3d, OdMemoryAllocator< OdGePoint3d > >

OdGeCircArc3d
Definition: GeCircArc3d.h:48

OdGeExtents3d
Definition: GeExtents3d.h:45

OdGeLinearEnt3d
Definition: GeLinearEnt3d.h:44

OdGeMatrix2d
Definition: GeMatrix2d.h:79

OdGeMatrix3d
Definition: GeMatrix3d.h:79

OdGePlane
Definition: GePlane.h:47

OdGePoint3d
Definition: GePoint3d.h:57

OdGeVector3d
Definition: GeVector3d.h:55

OdString
Definition: OdString.h:95

count
GLsizei GLsizei * count
Definition: gles2_ext.h:276

FacetModeler
Definition: AECDbOpeningBase.h:33

FacetModeler::MarkShadedSurfaces
FMGEOMETRY_API void MarkShadedSurfaces(Body &aBody, double angleTol, bool bDetectSharpEdges=false)

FacetModeler::extrusion
FMGEOMETRY_API Body extrusion(const Profile2D &rBase, const OdGeMatrix3d &mBasePlane, const OdGeVector3d &vDir, const DeviationParams &devDeviation=FMGeGbl::gDefDev)

FacetModeler::MergeShadedSurfaces
void MergeShadedSurfaces(Body &aBody, const OdArray< std::set< Surface * > > &shadedMergeData)

FacetModeler::ClearShadedSurfaces
FMGEOMETRY_API void ClearShadedSurfaces(Body &aBody)

FacetModeler::BooleanOperation
BooleanOperation
Definition: FMGeometry.h:70

FacetModeler::TagType
ptrdiff_t TagType
Definition: FMMdlBase.h:46

FacetModeler::revolution
FMGEOMETRY_API Body revolution(const Profile2D &base, const OdGeVector3d &revAxis, const OdGePoint3d &axisPosition, double startAng, double endAng, const DeviationParams &deviation=FMGeGbl::gDefDev)

GeMesh
Definition: BrepRenderer.h:43

FacetModeler::DeviationParams
Definition: FMGeometry.h:43

FacetModeler::FMGeGbl::gDefDev
static FMGEOMETRY_API_STATIC DeviationParams gDefDev
Definition: FMGeometry.h:161