ModelerGeometry.h

Go to the documentation of this file.

// Copyright (C) 2002-2024, 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-2024 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 _OD_MODELERGEOMETRY_INCLUDED_
#define _OD_MODELERGEOMETRY_INCLUDED_
 
#define STL_USING_MAP
#define STL_USING_VECTOR
#include "OdaSTL.h"
#include "RxObject.h"
#include "ModelerDefs.h"
#include "DbEntity.h"
#include "Db3dSolid.h"
#include "DbRegion.h"
#include "DbSubDMesh.h"
#include "DbNurbSurface.h"
#include "Db3dProfile.h"
#include "Ge/GeMatrix3dArray.h"
#include "Ge/GeNurbCurve3d.h"
#include "Ge/GeCurve3dPtrArray.h"
#include "MaterialResolver.h"
#include "ModelerGeometryDefs.h"
 
class OdStreamBuf;
class OdBrBrep;
class OdBrEntity;
class OdGiCommonDraw;
class OdGiViewportDraw;
class OdDbCurve;
class OdDbRevolveOptions;
class OdDbSweepOptions;
class OdDbLoftOptions;
class OdDbBlendOptions;
class OdDbSection;
class SectArgs;
class OdBrMesh2dFilter;
class OdBrMesh2d;
namespace GeMesh { class OdGeTrMesh; }
class wrTriangulationParams;
namespace OdDbModeler { 
  struct OdSectionViewParams;
  struct OdHlrCurvesParams;
}
 
#include "TD_PackPush.h"

class DBENT_EXPORT OdModelerGeometry : public OdRxObject
{
protected:
  //DOM-IGNORE-BEGIN
  OdModelerGeometry() {}
  //DOM-IGNORE-END
 
public:
  //DOM-IGNORE-BEGIN
  ODRX_DECLARE_MEMBERS(OdModelerGeometry);
  //DOM-IGNORE-END
 
  // in/out functionality

  virtual OdResult in(OdStreamBuf* pStreamBuf, AfTypeVer *typeVer = 0, bool standardSaveFlag = true) = 0;
 

  virtual OdResult out(OdStreamBuf* pStreamBuf, AfTypeVer typeVer, bool standardSaveFlag = true) const = 0;

  virtual bool brep(OdBrBrep& brBrep) const = 0;
 
  virtual OdResult getEdgeSubentityGeometry(OdArray<OdUInt32> indexesOfEdgeCalculation, OdGeCurve3d*& pEdgeCurve) = 0;

  virtual OdResult setSubentPath(OdBrEntity& /*pInpEnt*/, OdDbFullSubentPath& /*subpath*/) { return eNotImplemented; }

  virtual OdResult generateMesh(const OdBrMesh2dFilter& /*filter*/, OdBrMesh2d& /*mesh2d*/) { return eNotImplemented; }

  virtual bool setFACETRES(double facetRes) = 0;

  struct NumIsolines
  {
    OdUInt32 numU;
    OdUInt32 numV;
  };

  virtual bool worldDraw(OdGiCommonDraw* pWd, OdUInt32 geomType, const NumIsolines *pNumIsolines = 0) = 0;

  virtual bool drawSilhouettes(OdGiViewportDraw* pVd) = 0;
 
  virtual OdResult getCachedSilhouettes(OdGeCurve3dPtrArray* cachedSilhouettes) = 0;

  virtual OdResult getHlrCurves(OdDbModeler::OdHlrCurvesParams& params) = 0;

  virtual bool getTransformation(OdGeMatrix3d& xfm) = 0;

  virtual void transformBy( const OdGeMatrix3d& xfm ) = 0;

  virtual void createBox( double xLen, double yLen, double zLen ) = 0;

  virtual void createFrustum( double height, double xRadius, double yRadius, double topXRadius ) = 0;

  virtual void createSphere( double radius ) = 0;

  virtual void createTorus( double majorRadius, double minorRadius ) = 0;

  virtual void createWedge( double xLen, double yLen, double zLen ) = 0;

  virtual OdResult extrude(const OdDbRegion* pRegion, double height, double taperAngle, bool isSolid = true) = 0;

  virtual OdResult revolve(const OdDbRegion* pRegion, const OdGePoint3d& axisPoint,
    const OdGeVector3d& axisDir, double angleOfRevolution, bool isSolid = true) = 0;

  virtual void ClearColorAttributes() = 0;

  virtual void ClearMaterialAttributes(const OdArray<OdDbSubentId>* aSubents = NULL) = 0;

  virtual void ClearMaterialMapperAttributes() = 0;

  enum MaterialState
  {
    kNoMaterials = 0, 
    kHasMaterials = 1,
    kUnknown = 2
  };

  virtual MaterialState hasMaterials() const {return kUnknown; }

  virtual bool hasTrueColorAttributes() const = 0;

  virtual OdResult getPlane(OdGePlane& regionPlane) const = 0;

  virtual bool setMMPerUnit(double  mmPerUnit) = 0;

  virtual bool getMMPerUnit(double &mmPerUnit) const = 0;

  enum geomType
  {
    kUndefined = 0,
    kBody      = 1,
    kSolid     = 2,
    kRegion    = 3,
    kSurface   = 4
  };

  virtual geomType bodyType() const = 0;

  virtual bool explode(geomType typeThis, OdDbEntityPtrArray& entitySet) const = 0;

  virtual OdResult booleanOper(OdDbDatabase* database, OdDb::BoolOperType operation, OdModelerGeometry* otherBody,
    geomType typeThis, geomType typeOther) = 0;
  
  virtual OdResult booleanOper(OdDbDatabase* database, OdDb::BoolOperType operation, const OdModelerGeometry* otherBody,
    geomType typeThis, geomType typeOther, OdSmartPtr<OdModelerGeometry>& result, OdDbEntityPtrArray* intersectionEntities = NULL) const = 0;

  virtual OdResult checkInterference(OdDbDatabase* database,
    const OdModelerGeometry* otherSolid,
    bool createNewSolid,
    bool& solidsInterfere,
    OdDb3dSolidPtr& commonVolumeSolid)
    const = 0;

  virtual OdResult getArea(double& regionArea) const = 0;

  virtual OdResult getPerimeter(double&) const = 0;

  virtual OdResult getAreaProp( const OdGePoint3d& origin, const OdGeVector3d& xAxis,
    const OdGeVector3d& yAxis, double& perimeter,
    double& area, OdGePoint2d& centroid,
    double momInertia[2], double& prodInertia,
    double prinMoments[2], OdGeVector2d prinAxes[2],
    double radiiGyration[2], OdGePoint2d& extentsLow,
    OdGePoint2d& extentsHigh ) const = 0;

  virtual OdResult clear( ) = 0;

  virtual OdResult extrudeAlongPath(const OdDbRegion* region, const OdDbCurve* path, double taperAngle = 0.0, bool isSolid = true) = 0;

  virtual OdResult imprintEntity(const OdDbEntity *pEntity) = 0;

  virtual OdResult getMassProp(double& volume,
    OdGePoint3d& centroid,
    double momInertia[3],
    double prodInertia[3],
    double prinMoments[3],
    OdGeVector3d prinAxes[3],
    double radiiGyration[3],
    OdGeExtents3d& extents) const = 0;

  virtual OdResult getSection(const OdGePlane& plane, OdDbRegionPtr &sectionRegion, OdDbEntityPtrArray* pSectionCurves = NULL) const = 0;

  virtual OdResult getSlice(const OdGePlane& plane, bool getNegHalfToo, OdDb3dSolidPtr &negHalfSolid) = 0;

  virtual OdResult getSlice(OdDbSurface* pSurface, bool bGetNegHalfToo, OdDb3dSolidPtr& pNegHalfSolid) = 0;

  virtual OdResult cleanBody() = 0;

  virtual OdResult offsetBody(double offsetDistance) = 0;
 
  //virtual OdResult offsetBody(OdDbEntity* pOffsetEnt, double offsetDistance) = 0;

  virtual OdResult separateBody(OdDb3dSolidPtrArray &newSolids) = 0;

  virtual OdResult createExtrudedObject ( OdDbEntity* pSweepEnt,
                                          const OdGeVector3d& directionVec,
                                          OdDbSweepOptions& sweepOptions,
                                          bool isSolid = true,
                                          bool bHistoryEnabled = false) = 0;

  virtual OdResult createLoftedObject (
    OdDbEntityPtrArray& crossSectionCurves,
    OdDbEntityPtrArray& guideCurves,
    OdDbEntity* pPathCurve,
    OdDbLoftOptions& loftOptions,
    bool isSolid = true) = 0;

  virtual OdResult createBlendObject(
    OdDbEntityPtrArray& blendedEdges,
    OdDbBlendOptions& blendOptions,
    bool isSolid = true) = 0;

  //virtual OdResult createLoftedObjectByCoedges(
  //  OdDbEntityPtrArray& crossSectionCurves,
  //  OdDbEntityPtrArray& guideCurves,
  //  OdDbEntity* pPathCurve,
  //  OdDbLoftOptions& loftOptions,
  //  bool isSolid = true) = 0;

  virtual OdResult createPyramid(double height, int sides,
    double radius, double topRadius = 0.0 ) = 0;

  virtual OdResult createRevolvedObject ( OdDbEntity* pRevEnt,
    const OdGePoint3d& axisPnt,
    const OdGeVector3d& axisDir,
    double revAngle, double startAngle,
    OdDbRevolveOptions& revolveOptions,
    bool isSolid = true,
    bool bHistoryEnabled = false) = 0;

  virtual OdResult createSweptObject ( OdDbEntity* pSweepEnt,
    OdDbEntity* pPathEnt,
    OdDbSweepOptions& sweepOptions,
    bool isSolid = true,
    bool bHistoryEnabled = false) = 0;
 
  // Loft options utility functions

  virtual OdResult checkCrossSectionCurves (
    OdDbEntityPtrArray& crossSectionCurves,
    bool& allOpen, bool& allClosed, bool& allPlanar,
    bool displayErrorMessages = false ) = 0;

  virtual OdResult checkGuideCurves ( OdDbEntityPtrArray& guideCurves,
    bool displayErrorMessages = false ) = 0;

  virtual OdResult checkPathCurve ( OdDbEntity *pPathCurve,
    bool displayErrorMessages = false ) = 0;
 
  // Sweep options utility functions

  virtual OdResult  checkSweepCurve ( OdDbEntity *pSweepEnt,
    OdDb::Planarity& planarity, OdGePoint3d& pnt, OdGeVector3d& vec,
    bool& closed, double& approxArcLen, bool displayErrorMessages = false ) = 0;

  virtual OdResult  checkSweepPathCurve ( OdDbEntity *pPathEnt,    bool displayErrorMessages = false ) = 0;
 
  // Revolve options utility functions

  virtual OdResult checkRevolveCurve(
    OdDbEntity* pRevEnt,
    const OdGePoint3d& axisPnt,
    const OdGeVector3d& axisDir,
    bool& closed,
    bool& endPointsOnAxis,
    bool& planar,
    bool displayErrorMessages = false) = 0;

  virtual OdResult createFrom ( const OdDbEntity* pFromEntity, bool bFrom3dSolid) = 0;

  virtual OdResult convertToRegion ( OdDbEntityPtrArray& regions ) = 0;

  virtual OdResult thicken(double thickness, bool bBothSides, OdDb3dSolidPtr& pSolid) const = 0;

  virtual OdResult intersectWith( const OdDbEntity* ent, OdDb::Intersect intType,
    OdGePoint3dArray& points, OdGsMarker thisGsMarker, OdGsMarker otherGsMarker ) const = 0;

  virtual OdResult intersectWith( const OdDbEntity* ent, OdDb::Intersect intType, const OdGePlane& projPlane,
    OdGePoint3dArray& points, OdGsMarker thisGsMarker, OdGsMarker otherGsMarker ) const = 0;

  virtual OdResult copySubEntity(const OdDbSubentId &subentId, OdDbEntityPtr &newEntity) const = 0;

  virtual OdResult taperFaces(const OdArray<OdDbSubentId *> &faceSubentIds, const OdGePoint3d &basePoint,
                              const OdGeVector3d &draftVector, double draftAngle) = 0;

  virtual OdResult removeFaces(const OdArray<OdDbSubentId *> &faceSubentIds) = 0;

  virtual OdResult offsetFaces(const OdArray<OdDbSubentId *> &faceSubentIds, double offsetDistance) = 0;

  virtual OdResult shellBody(const OdArray<OdDbSubentId *> &faceSubentIds, double offsetDistance) = 0;

  virtual OdResult transformFaces(const OdArray<OdDbSubentId *> &faceSubentIds, const OdGeMatrix3d &matrix) = 0;

  virtual OdResult getSubentPathsAtGsMarker(OdDb::SubentType type,
                                            OdGsMarker gsMark, 
                                            const OdGePoint3d& pickPoint,
                                            const OdGeMatrix3d& viewXform, 
                                            OdDbFullSubentPathArray& subentPaths, 
                                            const OdDbObjectIdArray* entAndInsertStack = 0) const = 0;

  virtual OdResult getGsMarkersAtSubentPath(const OdDbFullSubentPath& subPath,
                                            OdGsMarkerArray& gsMarkers) const = 0;
 
  //DOM-IGNORE-BEGIN
  virtual OdDbSubentId internalSubentId(void* ent) const = 0;

  virtual void* internalSubentPtr(const OdDbSubentId& id) const = 0;
 
  virtual bool getNurbCurvesCache(OdGeCurve3dPtrArray &)  const { return false; }
 
  // for internal use only
  virtual OdResult setBody(const void * /*pBody*/) { return eNotImplemented; }
  virtual void * body( ) const { return 0; }
  //DOM-IGNORE-END

  virtual OdResult setSubentColor(const OdDbSubentId &subentId, const OdCmColor &color) = 0;

  virtual OdResult getSubentColor(const OdDbSubentId &subentId, OdCmColor &color) const = 0;

  virtual OdResult setSubentMaterial(const OdDbSubentId &subentId, OdDbObjectId matId) = 0;

  virtual OdResult getSubentMaterial(const OdDbSubentId &subentId, OdUInt64& matId) const = 0;

  virtual OdResult setSubentMaterialMapper( const OdDbSubentId &subentId,
                                            OdGeMatrix3d &mx,
                                            OdUInt8 &projection,
                                            OdUInt8 &tiling,
                                            OdUInt8 &autoTransform) = 0;

  virtual OdResult getSubentMaterialMapper( const OdDbSubentId &subentId,
                                            OdGeMatrix3d &mx,
                                            OdUInt8 &projection,
                                            OdUInt8 &tiling,
                                            OdUInt8 &autoTransform) const = 0;

  virtual OdResult chamferEdges(const OdArray<OdDbSubentId *> &edgeSubentIds,
                                const OdDbSubentId& baseFaceSubentId,
                                double baseDist,
                                double otherDist) = 0;

  virtual OdResult filletEdges( const OdArray<OdDbSubentId *> &edgeSubentIds,
                                const OdGeDoubleArray& radius,
                                const OdGeDoubleArray& startSetback,
                                const OdGeDoubleArray& endSetback) = 0;

  virtual OdResult createSectionObjects(const OdGePlane& sectionPlane, OdDbEntityPtrArray& sectionObjects) const = 0;

  virtual OdResult sliceByPlane(const OdGePlane& slicePlane, OdDbSurfacePtr& pNegHalfSurface, OdDbSurfacePtr& pNewSurface, bool bNotModifyItself) = 0;

  virtual OdResult sliceBySurface(const OdDbSurfacePtr pSlicingSurface, OdDbSurfacePtr& pNegHalfSurface, OdDbSurfacePtr& pNewSurface, bool bNotModifyItself) = 0;

  virtual OdResult extrudeFaces(const OdArray<OdDbSubentId *> &faceSubentIds, double height, double taper) = 0;
  
  virtual OdResult extrudeFacesAlongPath(const OdArray<OdDbSubentId *> &faceSubentIds, const OdDbCurve* path) = 0;

  virtual OdResult ChangeFacesDoubleSidedParam(bool isDoubleSided) = 0;

  virtual OdResult convertToNurbSurface(OdDbNurbSurfacePtrArray& nurbSurfaceArray) = 0;

  virtual OdResult get( int& iUDegree, int& iVDegree, bool& bRational, int& iUNumControlPoints, int& iVNumControlPoints,
                        OdGePoint3dArray& ctrlPtsArr, OdGeDoubleArray& weights, 
                        OdGeKnotVector& uKnots, OdGeKnotVector& vKnots) const = 0;

  virtual OdResult set (int iUDegree, int iVDegree, bool bRational, int iUNumControlPoints, int iVNumControlPoints,
                        const OdGePoint3dArray& ctrlPtsArr, const OdGeDoubleArray& weights, 
                        const OdGeKnotVector& uKnots, const OdGeKnotVector& vKnots) = 0;

  virtual OdResult getNumberOfControlPointsInU(int& iCount) const = 0;

  virtual OdResult getNumberOfControlPointsInV(int& iCount) const = 0;

  virtual OdResult getNumberOfKnotsInU(int& iCount) const = 0;

  virtual OdResult getNumberOfKnotsInV(int& iCount) const = 0;

  virtual OdResult getUKnots(OdGeKnotVector& knots) const = 0;

  virtual OdResult getVKnots(OdGeKnotVector& knots) const = 0;

  virtual OdResult getDegreeInU(int& iDegree) const = 0;

  virtual OdResult getDegreeInV(int& iDegree) const = 0;

  virtual OdResult isClosedInU(bool& bIsClosed) const = 0;

  virtual OdResult isClosedInV(bool& bIsClosed) const = 0;

  virtual OdResult isPeriodicInU(bool& bIsPeriodic) const = 0;

  virtual OdResult isPeriodicInV(bool& bIsPeriodic) const = 0;

  virtual OdResult getPeriodInU(double& dPeriod) const = 0;

  virtual OdResult getPeriodInV(double& dPeriod) const = 0;

  virtual OdResult evaluate(double dU, double dV, OdGePoint3d& pos) const = 0;

  virtual OdResult evaluate(double dU, double dV, OdGePoint3d& pos, OdGeVector3d& uDeriv, OdGeVector3d& vDeriv) const = 0;

  virtual OdResult evaluate(double dU, double dV, OdGePoint3d& pos, OdGeVector3d& uDeriv, OdGeVector3d& vDeriv,
                            OdGeVector3d& uuDeriv, OdGeVector3d& uvDeriv, OdGeVector3d& vvDeriv) const = 0;

  virtual OdResult evaluate(double dU, double dV, int iDerivDegree, OdGePoint3d& point, OdGeVector3dArray& derivatives) const = 0;

  virtual OdResult isRational(bool& bIsRational) const = 0;

  virtual OdResult isPlanar(bool& bIsPlanar, OdGePoint3d& ptOnSurface, OdGeVector3d& normal) const = 0;

  virtual OdResult isPointOnSurface(const OdGePoint3d& point, bool& bOnSurface) const = 0;

  virtual OdResult getNormal(double dU, double dV, OdGeVector3d& normal) const = 0;

  virtual OdResult getNumberOfSpansInU(int& iSpan) const = 0;

  virtual OdResult getNumberOfSpansInV(int& iSpan) const = 0;

  virtual OdResult getIsolineAtU(double dU, OdDbCurvePtrArray& lineSegments) const = 0;

  virtual OdResult getIsolineAtV(double dV, OdDbCurvePtrArray& lineSegments) const = 0;

  virtual OdResult InsertKnot(double dVal, int iUorV) = 0;

  virtual OdResult InsertControlPointsAtU(double dU, const OdGePoint3dArray& vCtrlPts, const OdGeDoubleArray& vWeights) = 0;

  virtual OdResult InsertControlPointsAtV(double dV, const OdGePoint3dArray& uCtrlPts, const OdGeDoubleArray& uWeights) = 0;

  virtual OdResult RemoveControlPointsAtU(int iUDegree) = 0;

  virtual OdResult RemoveControlPointsAtV(int iVDegree) = 0;

  virtual OdResult rebuild(int iUDegree, int iVDegree, int iNumUCtrlPts, int iNumVCtrlPts, bool bRestore) = 0;

  virtual OdResult modifyPositionAndTangent(double dU, double dV, const OdGePoint3d& point, const OdGeVector3d* uDeriv, const OdGeVector3d* vDeriv) = 0;

  virtual OdResult getParameterOfPoint(const OdGePoint3d& point, double& dU, double& dV) const = 0;

  virtual OdResult getControlPoints(int& iUCount, int& iVCount, OdGePoint3dArray& points) const = 0;

  virtual OdResult setControlPoints(int iUCount, int iVCount, const OdGePoint3dArray& points) = 0;

  virtual OdResult getControlPointAndWeight(int iUIndex, int iVIndex, OdGePoint3d& point, double& weight, bool& bIsRational) const = 0;

  virtual OdResult setControlPointAndWeight(int iUIndex, int iVIndex, const OdGePoint3d& point, double weight) = 0;

  virtual OdResult setColorToSubents(OdCmColor const& color) = 0;

  virtual OdResult setMaterialToSubents(OdDbObjectId materialId) = 0;

  virtual OdResult setMaterialResolver(const OdMaterialResolver *) { return eNotImplemented; }

  virtual OdResult setMaterialMapperToSubents(OdGeMatrix3d &mx, OdUInt8 &projection,
                                              OdUInt8 &tiling, OdUInt8 &autoTransform) = 0;

  virtual OdResult trimSurface( const OdDbObjectIdArray& toolIds,
                                const OdDbObjectIdArray& toolCurveIds,
                                const OdGeVector3dArray& projVectors,
                                const OdGePoint3d&       pickPoint,
                                const OdGeVector3d&      viewVector,
                                bool                     bAutoExtend,
                                bool                     bAssociativeEnabled) = 0;

  virtual OdResult projectOnToEntity( const OdDbEntity*   pEntityToProject,
                                      const OdGeVector3d& projectionDirection,
                                      OdDbEntityPtrArray& projectedEntities ) const = 0;

  virtual OdResult createSculptedSolid(OdDbEntityPtrArray& limitingBodies,
                                       const OdGeIntArray& limitingFlags) = 0;
 
  //FELIX_CHANGE_BEGIN
  virtual OdResult rayTestEntities( const OdGePoint3d&        rayBasePoint,
                                    const OdGeVector3d&       rayDir,
                                    double                    dRayRadius,
                                    std::vector<OdDbEntityPtr> &   i_entities,
                                    OdArray<OdDbSubentId> &   o_subEntIds,
                                    std::vector<int> &        o_indexentities,
                                    OdGeDoubleArray&          parameters ) const = 0;
  virtual OdResult rayTestSolids( const OdGePoint3d&          rayBasePoint,
                                  const OdGeVector3d&         rayDir,
                                  double                      dRayRadius,
                                  std::vector<OdDb3dSolidPtr> &i_solids,
                                  OdArray<OdDbSubentId> &     o_subEntIds,
                                  std::vector<int> &          o_indexsolids,
                                  OdGeDoubleArray&            parameters ) const = 0;
  //FELIX_CHANGE_END
  virtual OdResult rayTest( const OdGePoint3d&      rayBasePoint,
                            const OdGeVector3d&     rayDir,
                            double                  rayRadius,
                            OdArray<OdDbSubentId> & subEntIds,
                            OdGeDoubleArray&        parameters) const = 0;

  virtual OdResult createFilletSurface (OdDbSurfacePtr&      surf1,
                                        const OdGePoint3d&   pickPt1,
                                        OdDbSurfacePtr&      surf2,
                                        const OdGePoint3d&   pickPt2,
                                        double               dRadius,
                                        OdDb::FilletTrimMode trimMode,
                                        const OdGeVector3d&  projDir) = 0;
 
  virtual OdResult createNetworkSurface(const OdArray<OdDb3dProfilePtr>& uProfiles,
                                        const OdArray<OdDb3dProfilePtr>& vProfiles) = 0;

  virtual OdResult extendEdges( OdDbFullSubentPathArray& edgesId,
                                double                   dExtDist,
                                OdDbSurface::EdgeExtensionType        extOption ) = 0;

  virtual OdResult getObjectMesh( const OdDbFaceterSettings *faceter,
                                  OdGePoint3dArray& vertexArray,
                                  OdInt32Array& faceArray,
                                  OdGiFaceData*& faceData ) = 0;
                                  
  virtual OdResult getBoundingBox(OdGeExtents3d &box) = 0;

  virtual OdResult generateSectionGeometry( SectArgs& sectArgs, OdDbEntity *pEnt, bool* bHasForeground ) = 0;

  virtual OdResult getSectionViewInfo(OdDbModeler::OdSectionViewParams& params) const = 0;

  virtual OdResult createCachedCurves(OdGeCurve3dPtrArray& pCurves) = 0;

  virtual OdResult restoreAttributes(OdModelerGeometry* oldmodeler) = 0;

  virtual OdResult addSubentitySpecialSettings(AcisDataType addedDT, AcisDataTypeArrFirst addedDTFirst, const OdDbSubentId subentId, OdArray<OdUInt32>& retArray, OdUInt32 idx) = 0;

  virtual OdResult convertTo(const OdGePoint3dArray &arrVertexes, const OdInt32Array &arrEdges, const OdArray<OdInt32Array>& arrArrFaces, OdGiFaceData &fd,
    OdBoolArray &arrFacesColors, OdBoolArray &arrFacesMaterials, OdDbEntity* pEntity) = 0;

  virtual OdResult convertTo(const OdArray< OdArray<std::pair<OdUInt64, OdGeNurbCurve3d> > >& aLoopEdges,
    const OdArray<OdGeNurbSurface>& aNurbSurface,
    const OdArray<OdCmEntityColor>& aColors,
    const OdArray < OdDbStub*>& aMaterials,
    const OdBoolArray& arrIsFacesColors,
    const OdBoolArray& arrFacesMaterials,
    OdDbEntity* pEntity) = 0;

  virtual bool getFaceMesh(GeMesh::OdGeTrMesh& mesh, OdGsMarker iFace, const wrTriangulationParams& triangulationParams) = 0;

  virtual OdResult auditAcisData(OdDbAuditInfo* /*pInfo*/, const OdRxObject* /*pObj*/) { return eNotImplemented; }

  virtual void enableAcisAudit(bool bEnable) = 0;
};

typedef OdSmartPtr<OdModelerGeometry> OdModelerGeometryPtr;

typedef OdArray<OdModelerGeometryPtr> OdModelerGeometryPtrArray;
#include "TD_PackPop.h"
 
#endif // _OD_MODELERGEOMETRY_INCLUDED_