d8/dad/_f_m_mdl_body_8h_source.html

 // Copyright (C) 2002-2015, 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 Teigha(R) software pursuant to a license

 //   agreement with Open Design Alliance.

 //   Teigha(R) Copyright (C) 2002-2015 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 FacetModeler

 {


 class VertexSurfData;

 class Surface;

 typedef OdArray<const Face*, OdMemoryAllocator<const Face*> > FaceConstPtrArray;


 class FMGEOMETRY_API Body

 {

     protected:

         Body( class BodyImpl* pImpl );

     public:

         Body();


         Body(const Body& B);


         ~Body();


         Body& operator = (const Body& B);


         void clear();


         Body clone() const;


         void transform( const OdGeMatrix3d& mMatrix );


         void negate();


         bool isNull() const;


         bool isClosed() const;


         bool mergeCoincidentVertices();


         void mergeCoplanarEntities();


         bool containsNonManifoldEdges() const;


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


         Body combine( Body& rAnother );


         OdUInt32 vertexCount() const;


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


         OdUInt32 countEdges() const;


         OdUInt32 cachedEdgesCount() const;


         OdUInt32 faceCount() const;


         FacetModeler::Face* addFace(Surface* pSurface = 0);


         OdUInt32 surfaceCount() const;


         void addSurface(Surface* pSurface);


         FacetModeler::Face* faceList() const;


         FacetModeler::Vertex* vertexList() const;


         Surface* surfaceList() const;


         void clearVertexTags( FacetModeler::AecTagType clearValue = 0 );


         void clearSurfaceTags( FacetModeler::AecTagType clearValue = 0 );


         void clearEdgeTags( FacetModeler::AecTagType clearValue = 0 );


         void clearFaceTags( FacetModeler::AecTagType clearValue = 0 );


         void clearBodyTags( FacetModeler::AecTagType clearValue = 0 ) { setTag( clearValue ); }


         FacetModeler::AecTagType tag() const;


         void setTag( FacetModeler::AecTagType iTag );


         void deleteUnusedVertices();


         OdGeExtents3d interval() const;


         double volume() const;


         void slice( const OdGePlane& rCutter,

             Profile3D& rResult, bool bIncludeBoundary = true ) const;


         void sliceFaceDbg(const OdGePlane& rCutter, OdUInt32 faceNum);


         void slice( const OdGePlane& rCutter,

           Profile2D* pResultIncludingBoundary,

           Profile2D* pResultExcludingCoincidingBoundary = 0,

           Profile2D* pResultExcludingOppositeBoundary = 0,

           Profile2D* pResultExcludingBoundary = 0,

           FaceConstPtrArray* pCoincidingFaces = 0,

           FaceConstPtrArray* pOppositeFaces = 0

           ) const;


         void slice( const Contour2D& cCutLine, const OdGePlane& pProjectOn,

             Profile3D& rResult, bool bIncludeBoundary = true ) const;


         bool intersectLine( const OdGeLinearEnt3d& gLine, std::vector< OdGePoint3d >& vecPoints, bool bSortResults = false ) const;


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

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


         FMGEOMETRY_API_STATIC static const Body kEmpty;


         static Body box( const OdGePoint3d& ptOrigin,

             const OdGeVector3d& vSizes );


         static Body pyramid( const Profile2D& rBase,

             const OdGePoint3d& ptApex,

             const DeviationParams& devDeviation = FMGeGbl::gDefDev );


         static Body extrusion( const Profile2D& rBase,

             const OdGeVector3d& vDir,

             const DeviationParams& devDeviation = FMGeGbl::gDefDev );


         /*static Body extrusion( const Profile2D& rBase,

             const Contour3D& rPath,

             const DeviationParams& devDeviation = FMGeGbl::gDefDev );*/


         /*static Body extrusion( const Profile2D& rBase,

             const std::vector<OdGePoint3d>& rPath,

             const OdGeVector3d& vNormal,

             const DeviationParams& devDeviation = FMGeGbl::gDefDev );*/


         static Body revolution( const Profile2D& rBase,

             double dRadius, double dHeight,

             const DeviationParams& devDeviation = FMGeGbl::gDefDev );


         static Body revolution(

             const Profile2D&        base,

             const OdGeCircArc3d&    revolutionAxisAndAngles,

             const DeviationParams&  deviation = FMGeGbl::gDefDev,

             const OdGeMatrix2d*     pBaseTransform = 0 );


         static Body insideBody( const Profile2D& rBase,

             double dDepth, double dDepthOrigin,

             const DeviationParams& devDeviation = FMGeGbl::gDefDev );


         static Body insideFrame( const Profile2D& rBase,

             double dWidth, double dDepth, double dDepthOrigin,

             const DeviationParams& devDeviation = FMGeGbl::gDefDev );


         static Body infExtrusion( const Body& rBase,

             const Profile3D& rCutter,

             const DeviationParams& devDeviation = FMGeGbl::gDefDev ) ;

         static Body singleFace( const Profile2D& rBase,

             const DeviationParams& devDeviation = FMGeGbl::gDefDev );


         struct FMGEOMETRY_API SurfaceData {

           OdArray<Surface*>        surfaces;

           OdArray<Surface*>        face2Surface;

           OdArray<VertexSurfData*> vertexSurfData;


           void addVertexSurfData( int nVertex, Surface* pSurf );

         };


         static Body custom( const std::vector<OdGePoint3d>& aVertices,

             const std::vector<OdInt32>& aFaceData,

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

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

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

             const SurfaceData* pSurfaceData = 0

             );


         static Body customC( const std::vector<OdGePoint3d>& aVertices,

             const std::vector<OdInt32>& aFaceData,

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

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

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

             const SurfaceData* pSurfaceData = 0,

             std::vector<OdUInt32>* pFaceColors = 0,

             std::vector<OdUInt32>* pEdgeColors = 0

             );


         /*static Body customRemoveTJ( const std::vector<OdGePoint3d>& aVertices,

             const std::vector<OdInt32>& aFaceData,

             std::vector<OdUInt32>* aEdgeFlags = 0,

             std::vector<OdUInt32>* aFaceFlags = 0,

             std::vector<OdUInt32>* aVertexFlags = 0 );*/


         //static Body convertFromEntity( const OdDbObjectId& idEntity );


         void resetColors();


         static Body boolOper( BooleanOperation eOperation,

             Body& rOperandA, Body& rOperandB );


         //static Body section( Body& rBase,

         //    const OdGePlane& rCutter );


         static Body cutWithExtrusion( Body& rBase,

             const Profile3D& rCutter, bool bInside, double dDepth,

             const DeviationParams& devDeviation = FMGeGbl::gDefDev );


         static Body cutWithInfExtrusion( Body& rBase,

             const Profile3D& rCutter, bool bInside,

             const DeviationParams& devDeviation = FMGeGbl::gDefDev );


         void splitFace( FacetModeler::Face* pFace,

             const OdGePlane& pPlane,

             std::vector<FacetModeler::Face*>* pNewOuter = 0,

             std::vector<FacetModeler::Face*>* pNewInner = 0 );


         void addFace( FacetModeler::Face* pFace );


         void removeFace( FacetModeler::Face* pFace );


         void deleteFace( FacetModeler::Face* pFace );


         //

         void regeneratePairEdges();


         // If pFirstErrorDetected is provided then method returns false and assign error message to passed OdString

         // otherwise OdError with the error message is thrown if error is detected

         bool checkInternalConsistence( OdString* pFirstErrorDetected = 0 ) const;


         bool hasCoincidentEdges() const;

         bool hasCoincidentVertices() const;


         void clone_impl_if_referenced();


 private:

         void addFace2(Face* pFace);


         Face* addFace2(Surface* pSurface);


         // returns new starting edge of the loop

         Edge* mergeEdgesInLoop( Edge* pFirstEdge, const OdGeTol& gTol );


         // delete edge (without partners) and update face loop start, if the edge was first in a loop

         void deleteEdge( Edge* pEdge, Edge* pNewLoopStart );


         // split edge and all partners preserving topology

         // the vertex->point() must be at the edge

         void splitEdge( Edge* pEdge, Vertex* pNewVertex );


         //

         //void removeTJunctions();


         //

         void collectLoopsLight( Face* pFace );

         Body cloneByFaceList(std::vector<Face*> aFaceList) const;


       public:

         static Body customInternal( const std::vector<OdGePoint3d>& aVertices,

             const std::vector<OdInt32>& aFaceData,

             bool bRemoveTJ,

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

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

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

             const SurfaceData* pSurfaceData = 0,

             const std::vector<OdUInt32>* aFaceColors = 0,

             const std::vector<OdUInt32>* aEdgeColors = 0);

       private:


         //static Body CallOldBooleanOp( BooleanOperation operation, Body& rOperandA, Body& rOperandB );

         static Body DoUnionOperation( Body& rOperandA, Body& rOperandB );

         static Body DoIntersectionOperation( Body& rOperandA, Body& rOperandB );

         static Body DoDifferenceOperation( Body& rOperandA, Body& rOperandB );

         static Body DoXOROperation( Body& rOperandA, Body& rOperandB );


         static void CheckOperationResult( BooleanOperation operation, Body& rOperandA, Body& rOperandB, Body& rResult );


       public:

         FacetModeler::Vertex* getVertexList();

         void setVertexList(FacetModeler::Vertex* pList);

         FacetModeler::Surface* getSurfaceList();

         void setSurfaceList(FacetModeler::Surface* pList);

         OdUInt32 getSurfaceCount();

         void setSurfaceCount(OdUInt32 count);

         //OdUInt32 getVertexCount();

         void setVertexCount(OdUInt32 count);


       private:


         class BodyImpl* m_pImpl;


     friend class Vertex;

     friend class Face;

     friend class Surface;

     friend class BodyImpl;

     friend class BodyInternalConsistencyRestorer;

 };


 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__

FMContour3D.h

FMMdlBase.h

FMProfile3D.h

OdUInt32
unsigned int OdUInt32
Definition: OdPlatformSettings.h:783

FacetModeler::Body
Definition: FMMdlBody.h:47

FacetModeler::Body::getVertexList
FacetModeler::Vertex * getVertexList()

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

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

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

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

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

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

FacetModeler::Body::mergeCoincidentVertices
bool mergeCoincidentVertices()

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

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

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

FacetModeler::Body::sliceFaceDbg
void sliceFaceDbg(const OdGePlane &rCutter, OdUInt32 faceNum)

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

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

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

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::volume
double volume() const

FacetModeler::Body::regeneratePairEdges
void regeneratePairEdges()

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

FacetModeler::Body::insideBody
static Body insideBody(const Profile2D &rBase, double dDepth, double dDepthOrigin, const DeviationParams &devDeviation=FMGeGbl::gDefDev)

FacetModeler::Body::clone_impl_if_referenced
void clone_impl_if_referenced()

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

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

FacetModeler::Body::Body
Body()

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

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

FacetModeler::Body::clear
void clear()

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

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

FacetModeler::Body::slice
void slice(const OdGePlane &rCutter, Profile2D *pResultIncludingBoundary, Profile2D *pResultExcludingCoincidingBoundary=0, Profile2D *pResultExcludingOppositeBoundary=0, Profile2D *pResultExcludingBoundary=0, FaceConstPtrArray *pCoincidingFaces=0, FaceConstPtrArray *pOppositeFaces=0) const

FacetModeler::Body::boolOper
static Body boolOper(BooleanOperation eOperation, Body &rOperandA, Body &rOperandB)

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

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

FacetModeler::Body::custom
static Body custom(const std::vector< OdGePoint3d > &aVertices, const std::vector< OdInt32 > &aFaceData, const std::vector< OdUInt32 > *aEdgeFlags=0, const std::vector< OdUInt32 > *aFaceFlags=0, const std::vector< OdUInt32 > *aVertexFlags=0, const SurfaceData *pSurfaceData=0)

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

FacetModeler::Body::negate
void negate()

FacetModeler::Body::getSurfaceList
FacetModeler::Surface * getSurfaceList()

FacetModeler::Body::cutWithExtrusion
static Body cutWithExtrusion(Body &rBase, const Profile3D &rCutter, bool bInside, double dDepth, const DeviationParams &devDeviation=FMGeGbl::gDefDev)

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

FacetModeler::Body::cutWithInfExtrusion
static Body cutWithInfExtrusion(Body &rBase, const Profile3D &rCutter, bool bInside, const DeviationParams &devDeviation=FMGeGbl::gDefDev)

FacetModeler::Body::resetColors
void resetColors()

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

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

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

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

FacetModeler::Body::tag
FacetModeler::AecTagType tag() const

FacetModeler::Body::mergeCoplanarEntities
void mergeCoplanarEntities()

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

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

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

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

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

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

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

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

FacetModeler::Body::insideFrame
static Body insideFrame(const Profile2D &rBase, double dWidth, double dDepth, double dDepthOrigin, const DeviationParams &devDeviation=FMGeGbl::gDefDev)

FacetModeler::Body::clearBodyTags
void clearBodyTags(FacetModeler::AecTagType clearValue=0)
Definition: FMMdlBody.h:202

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

FacetModeler::Body::customC
static Body customC(const std::vector< OdGePoint3d > &aVertices, const std::vector< OdInt32 > &aFaceData, const std::vector< OdUInt32 > *aEdgeFlags=0, const std::vector< OdUInt32 > *aFaceFlags=0, const std::vector< OdUInt32 > *aVertexFlags=0, const SurfaceData *pSurfaceData=0, std::vector< OdUInt32 > *pFaceColors=0, std::vector< OdUInt32 > *pEdgeColors=0)

FacetModeler::Body::customInternal
static Body customInternal(const std::vector< OdGePoint3d > &aVertices, const std::vector< OdInt32 > &aFaceData, bool bRemoveTJ, const std::vector< OdUInt32 > *aEdgeFlags=0, const std::vector< OdUInt32 > *aFaceFlags=0, const std::vector< OdUInt32 > *aVertexFlags=0, const SurfaceData *pSurfaceData=0, const std::vector< OdUInt32 > *aFaceColors=0, const std::vector< OdUInt32 > *aEdgeColors=0)

FacetModeler::Body::infExtrusion
static Body infExtrusion(const Body &rBase, const Profile3D &rCutter, const DeviationParams &devDeviation=FMGeGbl::gDefDev)

FacetModeler::Body::getSurfaceCount
OdUInt32 getSurfaceCount()

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

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

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

FacetModeler::Body::singleFace
static Body singleFace(const Profile2D &rBase, const DeviationParams &devDeviation=FMGeGbl::gDefDev)

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

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

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

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

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

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

FacetModeler::Contour2D
Definition: FMContour2D.h:75

FacetModeler::Edge
Definition: FMMdlEdge.h:43

FacetModeler::Face
Definition: FMMdlFace.h:47

FacetModeler::Profile2D
Definition: FMProfile2D.h:39

FacetModeler::Profile3D
Definition: FMProfile3D.h:43

FacetModeler::Surface
Definition: FMMdlSurface.h:40

FacetModeler::Vertex
Definition: FMMdlVertex.h:42

OdArray
Definition: OdArray.h:591

OdGeCircArc3d
Definition: GeCircArc3d.h:48

OdGeExtents3d
Definition: GeExtents3d.h:45

OdGeLinearEnt3d
Definition: GeLinearEnt3d.h:44

OdGeMatrix2d
Definition: GeMatrix2d.h:73

OdGeMatrix3d
Definition: GeMatrix3d.h:73

OdGePlane
Definition: GePlane.h:45

OdGePoint3d
Definition: GePoint3d.h:55

OdGeTol
Definition: GeTol.h:49

OdGeVector3d
Definition: GeVector3d.h:54

OdString
Definition: OdString.h:95

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

FacetModeler
Definition: FMContour2D.h:35

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

FacetModeler::BooleanOperation
BooleanOperation
Definition: FMGeometry.h:56

FacetModeler::FaceConstPtrArray
OdArray< const Face *, OdMemoryAllocator< const Face * > > FaceConstPtrArray
Definition: FMMdlBody.h:40

FacetModeler::AecTagType
ptrdiff_t AecTagType
Definition: FMMdlBase.h:42

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

OdDAI::operator!=
bool DAI_EXPORT operator!=(const OdDAI::OdSelect &left, const OdDAI::OdSelect &right)

FacetModeler::Body::SurfaceData
Definition: FMMdlBody.h:430

FacetModeler::Body::SurfaceData::vertexSurfData
OdArray< VertexSurfData * > vertexSurfData
Definition: FMMdlBody.h:433

FacetModeler::Body::SurfaceData::surfaces
OdArray< Surface * > surfaces
Definition: FMMdlBody.h:431

FacetModeler::Body::SurfaceData::face2Surface
OdArray< Surface * > face2Surface
Definition: FMMdlBody.h:432

FacetModeler::Body::SurfaceData::addVertexSurfData
void addVertexSurfData(int nVertex, Surface *pSurf)

FacetModeler::DeviationParams
Definition: FMGeometry.h:43

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