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__