Db3dSolid.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 GEOMENT_DBSOL3D_H
#define GEOMENT_DBSOL3D_H 
 
#include "TD_PackPush.h"
#include "ModelerDefs.h"
#include "DbRegion.h"
#include "DbSubentId.h"
 
class OdDbSubentId;
class OdDbCurve;
class OdBrBrep;
class OdModelerGeometry;
class OdDbLoftOptions;
class OdDbSweepOptions;
class OdDbRevolveOptions;
struct OdDb3dSolidGeomParams;
class OdDbSurface;
namespace GeMesh { class OdGeTrMesh; }
class wrTriangulationParams;
 
#include "DbEntity.h"
#include "OdArray.h"
#include "DwgDeclareMembers.h"
 
 
 
class OdDb3dSolid;

typedef OdSmartPtr<OdDb3dSolid> OdDb3dSolidPtr;

typedef OdArray<OdDb3dSolidPtr> OdDb3dSolidPtrArray;
 

class DBENT_EXPORT OdDb3dSolid : public OdDbEntity
{
public:
  //DOM-IGNORE-BEGIN
  DWGMAP_DECLARE_MEMBERS(OdDb3dSolid);
  //DOM-IGNORE-END

  OdDb3dSolid();

  bool isNull() const;

  OdResult acisOut(
    OdStreamBuf* pStreamBuf,
    AfTypeVer typeVer = kAfTypeVerAny) const;

  OdResult acisIn(
    OdStreamBuf* pStreamBuf,
    AfTypeVer *pTypeVer = 0);

  void brep(
    OdBrBrep& brep);

  bool getFaceMesh(GeMesh::OdGeTrMesh& mesh, OdGsMarker iFace, const wrTriangulationParams& triangulationParams) const;
 
  virtual bool subWorldDraw(
    OdGiWorldDraw* pWd) const;
 
  virtual void subViewportDraw(
    OdGiViewportDraw* pVd) const;
 
  virtual OdResult dwgInFields(
    OdDbDwgFiler* pFiler);
 
  virtual void dwgOutFields(
    OdDbDwgFiler* pFiler) const;
 
  virtual OdResult dxfInFields(
    OdDbDxfFiler* pFiler);
 
  virtual void dxfOutFields(
    OdDbDxfFiler* pFiler) const;
 
  virtual OdResult subGetClassID(
    void* pClsid) const;

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

  virtual void createFrustum(
    double height,
    double majorRadius,
    double minorRadius,
    double topMajorRadius);

  virtual void createSphere(
    double radius);

  virtual void createTorus(
    double majorRadius,
    double minorRadius);

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

  virtual OdResult extrude(
    const OdDbRegion* pRegion,
    double height,
    double taperAngle = 0.0);

  virtual OdResult revolve(
    const OdDbRegion* pRegion,
    const OdGePoint3d& axisPoint,
    const OdGeVector3d& axisDir,
    double angleOfRevolution);

  virtual OdResult booleanOper(OdDb::BoolOperType operation, OdDb3dSolid* solid);

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

  virtual OdResult imprintEntity(const OdDbEntity *pEntity);

  virtual OdResult getArea(double& area) const;

  virtual OdResult checkInterference(const OdDb3dSolid* otherSolid,
    bool createNewSolid,
    bool& solidsInterfere,
    OdDb3dSolidPtr& commonVolumeSolid)
    const;

  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;

  virtual OdResult getSection(const OdGePlane& plane, OdDbRegionPtr &sectionRegion) const;

  virtual OdResult getSlice(const OdGePlane& plane, bool bGetNegHalfToo, OdDb3dSolidPtr& pNegHalfSolid);

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

  virtual OdResult cleanBody();

  virtual OdResult offsetBody(double offsetDistance);

  virtual OdResult separateBody(OdDb3dSolidPtrArray &newSolids);

  virtual OdResult createExtrudedSolid ( OdDbEntity* pSweepEnt,
    const OdGeVector3d& directionVec,
    OdDbSweepOptions& sweepOptions );

  virtual OdResult createExtrudedSolid ( OdDbEntity* pSweepEnt,
    const OdDbSubentId& faceSubentId,
    const OdGeVector3d& directionVec,
    OdDbSweepOptions& sweepOptions );

  virtual OdResult createExtrudedSolid ( OdDbEntity* pSweepEnt,
    const OdDbSubentId& faceSubentId,
    double height,
    OdDbSweepOptions& sweepOptions );

  virtual OdResult createLoftedSolid (
    OdDbEntityPtrArray& crossSectionCurves,
    OdDbEntityPtrArray& guideCurves,
    OdDbEntity* pPathCurve, OdDbLoftOptions& loftOptions );

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

  virtual OdResult createRevolvedSolid ( OdDbEntity* pRevEnt,
    const OdGePoint3d& axisPnt,
    const OdGeVector3d& axisDir,
    double revAngle, double startAngle,
    OdDbRevolveOptions& revolveOptions );

  virtual OdResult createRevolvedSolid ( OdDbEntity* pRevEnt,
    const OdDbSubentId& faceSubentId,
    const OdGePoint3d& axisPnt,
    const OdGeVector3d& axisDir,
    double revAngle, double startAngle,
    OdDbRevolveOptions& revolveOptions );

  virtual OdResult createSweptSolid ( OdDbEntity *pSweepEnt,
    const OdDbSubentId& faceSubentId,
    OdDbEntity* pPathEnt,
    OdDbSweepOptions& sweepOptions );

  virtual OdResult createSweptSolid ( OdDbEntity* pSweepEnt,
    OdDbEntity* pPathEnt,
    OdDbSweepOptions& sweepOptions );

  virtual OdResult stlOut(OdStreamBuf* output, bool asciiFormat, double maxSurfaceDeviation = 0.0) const;

  virtual OdResult stlOut(const OdChar* filename, bool asciiFormat, double maxSurfaceDeviation = 0.0) const;
 
  virtual OdDbObjectPtr decomposeForSave(
    OdDb::DwgVersion ver,
    OdDbObjectId& replaceId,
    bool& exchangeXData);
 
  virtual OdResult subExplode(
    OdRxObjectPtrArray& entitySet) const;
 
  virtual OdResult subTransformBy(
    const OdGeMatrix3d& xfm );

  virtual void saveAs(
    OdGiWorldDraw* pWd,
    OdDb::DwgVersion ver) const;

  virtual OdResult setBody(const void* pGeometry);

  virtual void* body() const;

  virtual OdResult copyEdge(const OdDbSubentId &subentId, OdDbEntityPtr &newEntity);

  virtual OdResult copyFace(const OdDbSubentId &subentId, OdDbEntityPtr &newEntity);
 
  virtual OdResult subGetSubentPathsAtGsMarker(OdDb::SubentType type,
                                               OdGsMarker gsMark,
                                               const OdGePoint3d& pickPoint,
                                               const OdGeMatrix3d& viewXform,
                                               OdDbFullSubentPathArray& subentPaths,
                                               const OdDbObjectIdArray* pEntAndInsertStack = 0) const;
 
  virtual OdDbSubentId internalSubentId(void* ent) const;
 
  virtual void* internalSubentPtr(const OdDbSubentId& id) const;
 
  virtual OdResult subGetGsMarkersAtSubentPath(const OdDbFullSubentPath& subPath,
                                               OdGsMarkerArray& gsMarkers) const;
 
  virtual OdDbEntityPtr subSubentPtr(const OdDbFullSubentPath& id) const;

  virtual OdResult extrudeFaces(const OdArray<OdDbSubentId *> &faceSubentIds,
    double height, double taper);

  virtual OdResult extrudeFacesAlongPath(const OdArray<OdDbSubentId *> &faceSubentIds,
    const OdDbCurve* path);

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

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

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

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

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

  virtual OdUInt32 numChanges() const;

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

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

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

  virtual OdResult getSubentMaterial(const OdDbSubentId &subentId, OdDbObjectId& matId) const;

  virtual OdResult setSubentMaterialMapper(const OdDbSubentId &subentId, const OdGiMapper& mapper);

  virtual OdResult getSubentMaterialMapper(const OdDbSubentId &subentId, OdGiMapper& mapper) const;

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

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

  virtual OdResult createFrom(const OdDbEntity* pFromEntity);

  virtual bool recordHistory() const;

  virtual bool showHistory() const;

  virtual OdResult setRecordHistory(bool bRecord);

  virtual OdResult setShowHistory(bool bShow);

  virtual OdResult convertToBrepAtSubentPaths(const OdDbFullSubentPathArray& /*paths*/);
 
  virtual OdUInt32 subSetAttributes(OdGiDrawableTraits* pTraits) const;

  OdResult projectOnToSolid( const OdDbEntity*   pEntityToProject,
                             const OdGeVector3d& projectionDirection,
                             OdDbEntityPtrArray& projectedEntities) const;

  OdResult createSculptedSolid(OdDbEntityPtrArray& limitingBodies,
                               const OdGeIntArray& limitingFlags);

  virtual void subClose();
 
  virtual OdResult subGetGeomExtents(OdGeExtents3d& extents) const;

  enum GeomType
  {
    eUndefinedType,
    eSphere,
    eTorus,
    eCylinder,
    eCone,
    eBox,
    eWedge,
    ePyramid,
    eExtrusion,
    eSweep,
    eLoft,
    eRevolve
  };

  GeomType determineGeomType(bool byBrep = false, OdDb3dSolidGeomParams** params = nullptr) const;

  bool isSphere(bool byBrep = false, double* radius = nullptr, OdGeMatrix3d* matrix = nullptr) const;

  bool isTorus(bool byBrep = false, double* majorRadius = nullptr, double* minorRadius = nullptr, OdGeMatrix3d* matrix = nullptr) const;

  bool isCylinder(bool byBrep = false,
    double* height = nullptr,
    double* majorRadius = nullptr,
    double* minorRadius = nullptr,
    OdGeMatrix3d* matrix = nullptr) const;

  bool isCone(bool byBrep = false,
    double* height = nullptr,
    double* majorRadius = nullptr,
    double* minorRadius = nullptr,
    double* topMajorRadius = nullptr,
    OdGeMatrix3d* matrix = nullptr) const;

  bool isBox(bool byBrep = false, double* xLen = nullptr, double* yLen = nullptr, double* zLen = nullptr, OdGeMatrix3d* matrix = nullptr) const;

  bool isWedge(bool byBrep = false, double* xLen = nullptr, double* yLen = nullptr, double* zLen = nullptr, OdGeMatrix3d* matrix = nullptr) const;

  bool isPyramid(bool byBrep = false,
    double* height = nullptr,
    int* sides = nullptr,
    double* radius = nullptr,
    double* topRadius = nullptr,
    OdGeMatrix3d* matrix = nullptr) const;

  bool isExtrusion(bool byBrep = false,
    OdGeVector3d* direction = nullptr,
    OdDbEntity** extrusionEntity = nullptr,
    OdDbSweepOptions* options = nullptr,
    OdGeMatrix3d* matrix = nullptr) const;

  bool isSweep(bool byBrep = false,
    OdDbEntity** sweepEntity = nullptr,
    OdDbEntity** pathEntity = nullptr,
    OdDbSweepOptions* options = nullptr,
    OdGeMatrix3d* matrix = nullptr) const;

  bool isLoft(bool byBrep = false,
    OdDbEntityPtrArray* crossSectionCurves = nullptr,
    OdDbEntityPtrArray* guideCurves = nullptr,
    OdDbEntity** pathCurve = nullptr,
    OdDbLoftOptions* options = nullptr,
    OdGeMatrix3d* matrix = nullptr) const;

  bool isRevolve(bool byBrep = false,
    double* revolveAngle = nullptr,
    double* startAngle = nullptr,
    OdGePoint3d* axisPoint = nullptr,
    OdGeVector3d* axisDir = nullptr,
    OdDbEntity** revolveEntity = nullptr,
    OdDbRevolveOptions* options = nullptr,
    OdGeMatrix3d* matrix = nullptr) const;
 
  //DOM-IGNORE-BEGIN
  virtual void copyFrom(const OdRxObject* pSource) ODRX_OVERRIDE;
  //DOM-IGNORE-END
};
 
#include "TD_PackPop.h"
 
#endif