///////////////////////////////////////////////////////////////////////////////
|
// Copyright (C) 2002-2016, 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-2016 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
|
#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 "Ge/GeNurbCurve3d.h"
|
#include "Ge/GeCurve3dPtrArray.h"
|
#include "MaterialResolver.h"
|
|
class OdStreamBuf;
|
class OdBrBrep;
|
class OdBrEntity;
|
class OdGiCommonDraw;
|
class OdGiViewportDraw;
|
class OdDbCurve;
|
class OdDbRevolveOptions;
|
class OdDbSweepOptions;
|
class OdDbLoftOptions;
|
class OdDbSection;
|
class SectArgs;
|
class OdBrMesh2dFilter;
|
class OdBrMesh2d;
|
|
#include "TD_PackPush.h"
|
|
/** \details
|
This class defines the interface for classes that
|
provide conversion services for ACIS SAT and SAB data.
|
|
\remarks
|
This class is used to convert ACIS data between various
|
versions of SAT and SAB.
|
|
For example, if a version 2004 .dwg file is saved as an R15 .dxf file,
|
the SAB data in the 2004 file must be converted to version 700 SAT,
|
so as to be be valid within the R15 .dxf file.
|
|
Library: ModelerGeometry
|
<group Other_Classes>
|
*/
|
class TOOLKIT_EXPORT OdModelerGeometry : public OdRxObject
|
{
|
protected:
|
OdModelerGeometry() {}
|
|
public:
|
ODRX_DECLARE_MEMBERS(OdModelerGeometry);
|
|
// in/out functionality
|
|
/** \details
|
Reads the ACIS data from the specified StreamBuf object into this ModelerGeometry object.
|
|
\remarks
|
The implementation of this function is responsible for determining
|
the type (SAT/SAB) and version of the data read.
|
|
\param pStreamBuf [in] Pointer to the StreamBuf object from which the data is to be read.
|
\param typeVer [out] Receives the type and version of the ACIS file.
|
\param standardSaveFlag [in] Controls the saving and restoring of used count data in the saved file.
|
|
\remarks
|
Returns eOk if successful, or an appropriate error code if not.
|
|
pStreamIn may be NULL.
|
|
\sa
|
AfTypeVerEnum
|
*/
|
virtual OdResult in(OdStreamBuf* pStreamBuf, AfTypeVer *typeVer = 0, bool standardSaveFlag = true) = 0;
|
|
|
/** \details
|
Writes the ACIS data from this ModelerGeometry object to the specified StreamBuf object.
|
|
\note
|
This function is responsible for converting
|
the contained ACIS data to the specified type and format. If afVer == kAfTypeVerAny,
|
then any type or version may be written.
|
|
\param pStreamBuf [in] Pointer to the StreamBuf object to which the data is to be written.
|
\param typeVer [in] Type and version of the ACIS file.
|
\param standardSaveFlag [in] Controls the saving and restoring of used count data in the saved file.
|
|
\remarks
|
Returns eOk if successful, or an appropriate error code if not.
|
|
\sa
|
AfTypeVerEnum
|
*/
|
virtual OdResult out(OdStreamBuf* pStreamBuf, AfTypeVer typeVer, bool standardSaveFlag = true) const = 0;
|
|
/** \details
|
Populates the specified BrBrep object with the ACIS BREP data of this ModelerGeometry object.
|
\param brBrep [out] Receives the BREP data.
|
\remarks
|
Returns true if and only if successful.
|
|
*/
|
virtual bool brep(OdBrBrep& brBrep) const = 0;
|
|
|
virtual OdResult setSubentPath(OdBrEntity & /*pInpEnt*/, OdDbFullSubentPath& /*subpath*/) { return eNotImplemented; }
|
|
virtual OdResult generateMesh(const OdBrMesh2dFilter& filter, OdBrMesh2d &mesh2d) { return eNotImplemented; }
|
|
/** \details
|
Draw functionality.
|
*/
|
enum
|
{
|
kNothing = 0,
|
kIsolines = 1,
|
kEdges = 2,
|
kShells = 4,
|
kOrderedEdges = 8, // Geometry is returned as closed loops.
|
kSurfIsolines = 16
|
};
|
|
/** \details
|
Sets the Facetres for this ModelerGeometry object.
|
\param facetRes [in] Facet resolution.
|
*/
|
virtual bool setFACETRES(double facetRes) = 0;
|
|
struct NumIsolines
|
{
|
OdUInt32 numU, numV;
|
};
|
/** \details
|
Creates a viewport-independent geometric representation of this ModelerGeometry object.
|
|
\remarks
|
Returns true if and only if the geometric representation can be generated in a
|
viewport-independent manner.
|
|
\note
|
A return value of false indicates that viewportDraw() must be called for this object.
|
|
The 3D GS will call this function at least once, but may cache subsequent display updates.
|
|
\param pWd [in] Pointer to the OdGiCommonDraw interface.
|
\param geomType [in] Geometry type.
|
\param pNumIsolines [in] Number of isolines in U and V directions.
|
|
\remarks
|
geomType must be a combination of one or more of the following:
|
|
<table>
|
Name Value
|
kNothing 0
|
kIsolines 1
|
kEdges 2
|
kShells 4
|
kOrderedEdges 8
|
kSurfIsolines 16
|
</table>
|
*/
|
virtual bool worldDraw(OdGiCommonDraw* pWd, OdUInt32 geomType, const NumIsolines *pNumIsolines = 0) = 0;
|
|
/** \details
|
Creates a viewport-dependent silhouette representation of this ModelerGeometry object.
|
|
\remarks
|
Causes this ModelerGeometry object to describe its geometry to the specified OdGiViewportDraw object.
|
|
This function is called once per viewport.
|
|
\remarks
|
It is possible to have totally different images in each viewport; a schematic
|
in one viewport, a layout in another.
|
|
\param pVd [in] Pointer to the OdGiViewportDraw interface.
|
*/
|
virtual bool drawSilhouettes(OdGiViewportDraw* pVd) = 0;
|
virtual OdResult getCachedSilhouettes(OdGeCurve3dPtrArray* cachedSilhouettes) = 0;
|
|
/** \details
|
Explodes this ModelerGeometry object into a set of OdDbEntity objects.
|
|
\param entitySet [in/out] Receives an array of pointers to the new entities.
|
|
\remarks
|
Returns eOk if successful, or an appropriate error code if not.
|
|
\note
|
Entities resulting from the explosion are appended to the specified array.
|
|
The newly created entities are not database residents.
|
*/
|
virtual bool explode(OdDbEntityPtrArray& entitySet) const = 0;
|
|
/** \details
|
Returns the transformation matrix for this ModelerGeometry object.
|
\param xfm [out] Receives the transformation matrix.
|
*/
|
virtual bool getTransformation(OdGeMatrix3d& xfm) = 0;
|
|
/** \details
|
Applies the specified 3D transformation matrix to this ModelerGeometry object.
|
|
\param xfm [in] 3D transformation matrix.
|
*/
|
virtual void transformBy( const OdGeMatrix3d& xfm ) = 0;
|
|
/** \details
|
Creates a WCS aligned solid box centered about the world origin.
|
|
\param xLen [in] Dimension along the WCS X-axis.
|
\param yLen [in] Dimension along the WCS Y-axis.
|
\param zLen [in] Dimension along the WCS Z-axis.
|
|
\remarks
|
Returns eOk if successful, or an appropriate error code if not.
|
|
\note
|
The following constraints apply:
|
|
* xLen >= 1e-6.
|
* yLen >= 1e-6.
|
* zLen >= 1e-6.
|
*/
|
virtual void createBox( double xLen, double yLen, double zLen ) = 0;
|
/** \details
|
Creates a WCS aligned frustum centered about the world origin.
|
|
\param height [in] Dimension along the WCS Z-axis.
|
\param xRadius [in] Base radius along the WCS X-axis.
|
\param yRadius [in] Base radius along the WCS Y-axis.
|
\param topXRadius [in] Top radius along the WCS X-axis.
|
|
\remarks
|
The function can generate a frustum that is any one of the following:
|
|
* A circular cylinder
|
* An elliptical cylinder
|
* A circular cone
|
* An elliptical cone
|
* A truncated circular cone
|
* A truncated elliptical cone
|
|
\note
|
The following constraints apply:
|
|
* height >= 1e-6.
|
* xRadius >= 1e-6.
|
* yRadius >= 1e-6.
|
* topXRadius >= 1e-6.
|
*/
|
virtual void createFrustum( double height, double xRadius, double yRadius, double topXRadius ) = 0;
|
/** \details
|
Creates a sphere centered about the world origin.
|
|
\param radius [in] Radius.
|
|
\note
|
The following constraints apply:
|
|
* radius >= 1e-6.
|
|
*/
|
virtual void createSphere( double radius ) = 0;
|
/** \details
|
Creates a WCS aligned torus centered about the world origin
|
and with the Z-axis as its axis of rotation.
|
|
\param majorRadius [in] Radius of the torus
|
\param minorRadius [in] Radius of the tube.
|
|
\note
|
The following constraints apply:
|
|
* minorRadius >= 1e-6.
|
* |majorRadius| >= 1e-6
|
* if majorRadius < 0, then minorRadius > |majorRadius| + 1e-6
|
*/
|
virtual void createTorus( double majorRadius, double minorRadius ) = 0;
|
|
/** \details
|
Creates a WCS aligned wedge centered about the world origin.
|
|
\param xLen [in] Dimension along the WCS X-axis.
|
\param yLen [in] Dimension along the WCS Y-axis.
|
\param zLen [in] Dimension along the WCS Z-axis.
|
|
\remarks
|
The inclined face is defined by the points
|
|
( xLen/2, -yLen/2, -zLen/2)
|
(-xLen/2, -yLen/2, zLen/2)
|
( xLen/2, yLen/2, -zLen/2)
|
(-xLen/2, +yLen/2, zLen/2)
|
|
\note
|
The following constraints apply:
|
|
* xLen >= 1e-6.
|
* yLen >= 1e-6.
|
* zLen >= 1e-6.
|
*/
|
virtual void createWedge( double xLen, double yLen, double zLen ) = 0;
|
|
/** \details
|
Creates a solid by extruding the specified region.
|
|
\param pRegion [in] Pointer to the region to be extruded.
|
\param height [in] Height of the extrusion.
|
\param taperAngle [in] Taper angle.
|
|
\remarks
|
The extrusion direction is along the normal of the region. Height may be negative.
|
|
|
\note
|
All angles are expressed in radians.
|
|
The following constraints apply:
|
|
* |height| >= 1e-6.
|
* |taperAngle| < OdaPI2 - 1e-6.
|
*/
|
virtual OdResult extrude(const OdDbRegion* pRegion, double height, double taperAngle, bool isSolid = true) = 0;
|
|
/** \details
|
Creates a solid by revolving the specified region.
|
|
\param pRegion [in] Pointer to the region to be extruded.
|
\param axisPoint [in] Point on the axis of revolution.
|
\param axisDir [in] Vector defining the axis of revolution.
|
\param angleOfRevolution [in] Angle of revolution.
|
|
\remarks
|
The axis of revolution is projected onto the plane of the region, parallel to its normal.
|
|
\note
|
All angles are expressed in radians.
|
|
The following constraints apply:
|
|
* The projected axis of revolution cannot intersect the region.
|
* angleOfRevolution >= 1e-6
|
*/
|
virtual OdResult revolve(const OdDbRegion* pRegion, const OdGePoint3d& axisPoint,
|
const OdGeVector3d& axisDir, double angleOfRevolution, bool isSolid = true) = 0;
|
|
/** \details
|
Clears the color attributes of this ModelerGeometry object.
|
*/
|
virtual void ClearColorAttributes() = 0;
|
|
/** \details
|
Clears the material attributes of this ModelerGeometry object.
|
*/
|
virtual void ClearMaterialAttributes() = 0;
|
|
/** \details
|
Clears the material mapper attributes of this ModelerGeometry object.
|
*/
|
virtual void ClearMaterialMapperAttributes() = 0;
|
|
/** \details
|
Describes a material state.
|
*/
|
enum MaterialState
|
{
|
kNoMaterials = 0,
|
kHasMaterials = 1,
|
kUnknown = 2
|
};
|
virtual MaterialState hasMaterials() const {return kUnknown; }
|
|
/** \details
|
Returns true if and only if TrueColor attributes are attached to the faces and/or
|
edges of this ModelerGeometry object.
|
*/
|
virtual bool hasTrueColorAttributes() const = 0;
|
|
/** \details
|
Returns the plane of this ModelerGeometry object.
|
|
\param regionPlane [out] Receives the region plane.
|
\remarks
|
Returns eOk if successful, or an appropriate error code if (bodyType() != kRegion).
|
|
*/
|
virtual OdResult getPlane(OdGePlane& regionPlane) const = 0;
|
|
/** \details
|
Sets the mm/unit for this ModelerGeometry object.
|
\param mmPerUnit [in] mm/unit.
|
\remarks
|
Returns true if and only if successful.
|
*/
|
virtual bool setMMPerUnit(double mmPerUnit) = 0;
|
/** \details
|
Returns the mm/unit for this ModelerGeometry object.
|
\param mmPerUnit [out] mm/unit.
|
\remarks
|
Returns true if and only if successful.
|
*/
|
virtual bool getMMPerUnit(double &mmPerUnit) const = 0;
|
|
/** \details
|
Geometry type.
|
*/
|
enum geomType
|
{
|
kUndefined = 0,
|
kBody = 1,
|
kSolid = 2,
|
kRegion = 3,
|
kSurface = 4
|
};
|
|
/** \details
|
Returns the body type of this ModelerGeometry object:
|
\remarks
|
bodyType returns one of the following:
|
|
<table>
|
Name Value
|
kUndefined 0
|
kBody 1
|
kSolid 2
|
kRegion 3
|
</table>
|
*/
|
virtual geomType bodyType() const = 0;
|
|
// new methods
|
/** \details
|
Performs a Boolean operation between this ModelerGeometry object and another ModelerGeometry object.
|
|
\param operation [in] Type of Boolean operation.
|
\param otherRegion [out] Pointer to the other ModelerGeometry object which also will contain the result of the Boolean operation.
|
|
\returns Returns eOk if the Boolean operation is successful or an appropriate error code if not.
|
If ModelerGeometry is null, eInvalidInput is returned.
|
|
\remarks
|
Possible operation types are:
|
* kBoolUnite - Unites two ModelerGeometry objects into one.
|
* kBoolIntersect - Returns the intersection of two ModelerGeometry objects.
|
* kBoolSubtract - Subtracts the second ModelerGeometry object from the first one.
|
*/
|
virtual OdResult booleanOper(OdDb::BoolOperType operation, OdSmartPtr<OdModelerGeometry> otherRegion) = 0;
|
|
/** \details
|
Performs a Boolean operation between this ModelerGeometry object and another ModelerGeometry object.
|
|
\param operation [in] Type of Boolean operation.
|
\param pModelerPar [in] Pointer to the other ModelerGeometry object which also will contain the result of the Boolean operation.
|
\param intersectionEntities [out] Array of intersection entities.
|
|
\returns Returns eOk if Boolean operation is successful or an appropriate error code if not.
|
If ModelerGeometry is null, eInvalidInput is returned.
|
|
\remarks
|
Possible operation types are:
|
* kBoolUnite - Unites two ModelerGeometry objects into one.
|
* kBoolIntersect - Returns the intersection of two ModelerGeometry objects.
|
* kBoolSubtract - Subtracts the second ModelerGeometry object from the first one.
|
*/
|
virtual OdResult booleanOper(OdDb::BoolOperType operation, const OdSmartPtr<OdModelerGeometry> pModelerPar, OdDbEntityPtrArray& intersectionEntities) = 0;
|
|
/** \details
|
Returns the area of this ModelerGeometry object.
|
\param regionArea [out] Reference for returning the area value.
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
Area value is returned in square drawing units.
|
*/
|
virtual OdResult getArea(double& regionArea) const = 0;
|
|
/** \details
|
Returns the perimeter of this ModelerGeometry object.
|
\param dRegionPerimeter [out] Reference to a double value to store the perimeter.
|
|
\returns Returns eOk if the perimeter was successfully returned to the calling
|
subroutine or an appropriate error code in the other case.
|
*/
|
virtual OdResult getPerimeter(double&) const = 0;
|
|
/** \details
|
Calculates the area properties of this ModelerGeometry object.
|
|
The method validates the origin, xAxis, and yAxis parameters to ensure that:
|
* axes are perpendicular to each other.
|
* axes and the origin lie in the same plane as the region.
|
|
\param origin [in] Origin of the coordinate system to use for evaluation (WCS).
|
\param xAxis [in] X-axis of the coordinate system to use for evaluation (WCS).
|
\param yAxis [in] Y-axis of the coordinate system to use for evaluation (WCS).
|
\param perimeter [out] Reference for returning the value of the ModelerGeometry object's perimeter.
|
\param area [out] Reference for returning the value of the ModelerGeometry object's area.
|
\param centroid [out] Reference for returning the centroid of the ModelerGeometry object.
|
\param momInertia [out] Static array for returning moments of inertia for the ModelerGeometry object.
|
\param prodInertia [out] Reference for returning the ModelerGeometry object's product of inertia.
|
\param prinMoments [out] Static array for returning principal moments for the ModelerGeometry object.
|
\param prinAxes [out] Static array for returning principle axes of the ModelerGeometry object.
|
\param radiiGyration [out] Static array for returning radii of gyration of the ModelerGeometry object.
|
\param extentsLow [out] Reference for returning the ModelerGeometry object's minimum extents point.
|
\param extentsHigh [out] Reference for returning the ModelerGeometry object's maximum extents point.
|
|
\returns Returns eOk if successful, or an appropriate error code otherwise.
|
|
\remarks
|
Returned values are measured using the values of origin, xAxis, and yAxis parameters,
|
and are represented in WCS coordinates.
|
*/
|
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;
|
|
/** \details
|
Clears the contents of this ModelerGeometry object.
|
|
\returns Returns eOk if successful, or an appropriate error code otherwise.
|
*/
|
virtual OdResult clear( ) = 0;
|
|
/** \details
|
Creates a ModelerGeometry object by extruding a region along a path curve.
|
|
\param region [in] Pointer to a region object for extruding from.
|
\param path [in] Pointer to a curve object to extrude along. Must be one of the following:
|
* Line
|
* OdDbArc
|
* OdDbCircle
|
* Ellipse
|
* OdDbSpline
|
* OdDb2dPolyline
|
* non-spline fit OdDb3dPolyline
|
|
\param taperAngle [in] Extrusion taper angle in radians. Default value is 0.0.
|
Value must be between 0.5 pi and -0.5 pi.
|
If the path represented by the OdDbCurve object is closed, the taper angle parameter is ignored.
|
\param isSolid [in] Boolean flag that indicates that the ModelerGeometry object is a solid.
|
|
\returns Returns eOk if extruding operation is successful or an appropriate error code if not.
|
|
\remarks
|
Entity path must not have self-intersections, and it is recommended that the path not have high curvature areas.
|
The following constraints are applied: |taper Angle| >= 1e-6
|
*/
|
virtual OdResult extrudeAlongPath(const OdDbRegion* region, const OdDbCurve* path, double taperAngle = 0.0, bool isSolid = true) = 0;
|
|
/** \details
|
Intersects the given entity with this ModelerGeometry object and imprints their intersection graph
|
onto the ModelerGeometry object.
|
|
\param pEntity [in] A pointer to an entity to be imprinted.
|
|
\returns Returns eOk if imprinting entity onto the ModelerGeometry object is successful or an appropriate error code if not.
|
|
\remarks
|
The given entity must be one of the following:
|
* Curve
|
* OdDb3dSolid
|
* Body
|
* Region
|
* Trace
|
* OdDbSolid
|
* Face
|
|
If the ModelerGeometry object is null, or if the given entity is not one of the entities listed
|
above, eInvalidInput is returned.
|
If as a result of intersection a closed loop of new edges is created, a new face will be made.
|
If an open loop of edges is made, it can be added to an existing loop as a spur.
|
Or it can be added as a slit in the face.
|
*/
|
virtual OdResult imprintEntity(const OdDbEntity *pEntity) = 0;
|
|
/** \details
|
Checks whether the solid interferes with another solid object.
|
|
\param otherSolid [in] A pointer to another solid object for checking interference.
|
\param createNewSolid [in] A flag determining where a new solid object containing the interference must be created.
|
\param solidsInterfere [out] A reference to a boolean variable where the result of the interference checking will be stored and returned.
|
\param commonVolumeSolid [out] A reference to a pointer to a new solid containing the interference of the origin solid and otherSolid.
|
|
\returns Returns eOk if interference checking is successful or an appropriate error code in other case.
|
|
\remarks
|
The caller of this function is responsible for the memory used by the object pointed to by commonVolumeSolid (resulting from intersection of this solid and otherSolid) when the function finishes.
|
If commonVolumeSolid is added to a database, the database takes responsibility for the memory pointed to by commonVolumeSolid.
|
If commonVolumeSolid is not added to a database, the caller must delete memory when it is no longer needed to avoid a memory leak.
|
*/
|
virtual OdResult checkInterference(const OdDb3dSolid* otherSolid,
|
bool createNewSolid,
|
bool& solidsInterfere,
|
OdDb3dSolidPtr &commonVolumeSolid)
|
const = 0;
|
|
/** \details
|
Returns volume properties of the ModelerGeometry object.
|
|
\param volume [out] Reference for returning the volume of the ModelerGeometry object.
|
\param centroid [out] Reference to an OdGePoint3d object for returning the point, representing the centroid of the ModelerGeometry object.
|
\param momInertia [out] A static array for returning X, Y, Z moments of inertia of the ModelerGeometry object.
|
\param prodInertia [out] A static array for returning X, Y, Z products of inertia of the ModelerGeometry object.
|
\param prinMoments [out] A static array for returning X, Y, Z principal moments of the ModelerGeometry object.
|
\param prinAxes [out] A static array for returning an OdGeVector3d object, determining principal axes of the ModelerGeometry object.
|
\param radiiGyration [out] A static array for returning X, Y, Z radii of gyration of the ModelerGeometry object.
|
\param extents [out] A reference to an OdGeExtents3d object for returning the bounding box of the ModelerGeometry object.
|
|
\returns Returns the result of getting volume properties of the ModelerGeometry object:
|
eOk if successful or an appropriate error code in other case. All properties are evaluated in the WCS.
|
*/
|
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;
|
|
/** \details
|
Creates a DbRegion entity as a result of the intersection between the specified plane and the ModelerGeometry object.
|
|
\param plane [in] Reference to an OdGePlane object to use as the section cutting plane.
|
\param sectionRegion [out] Reference to a new region created as the result of the intersection between the specified plane and the ModelerGeometry object.
|
\param pSectionCurves [out] Pointer to an array of section curves.
|
|
\returns Returns the result of intersecting the ModelerGeometry object with a
|
plane: eOk if successful or an appropriate error code in other case.
|
Value eOk is also returned when a plane and the ModelerGeometry object do not
|
intersect each other or if the intersection region is not a valid region, that is,
|
it intersects at a point, along a bounding face of the ModelerGeometry object and so on.
|
*/
|
virtual OdResult getSection(const OdGePlane& plane, OdDbRegionPtr §ionRegion, OdDbEntityPtrArray* pSectionCurves = NULL) const = 0;
|
|
/** \details
|
Slices the ModelerGeometry object with a plane and transforms the native ModelerGeometry object
|
to be the portion remaining on the positive side of the normal of the slicing plane.
|
|
\param plane [in] Reference to a slicing plane.
|
\param getNegHalfToo [in] Flag determining whether the other (negative) part of the native ModelerGeometry object should be created as a separate ModelerGeometry object (when true).
|
\param negHalfSolid [out] Reference to a pointer to the created ModelerGeometry object representing the negative half of the native ModelerGeometry object. If getNegHalfToo is false, NULL value is returned.
|
|
\returns Returns eOk if the native ModelerGeometry object was successfully sliced or an appropriate error code in other case.
|
If the slicing plane does not intersect the ModelerGeometry object, the ModelerGeometry object is left unchanged, negHalfSolid is set to NULL, and eOk is returned.
|
|
\remarks
|
The caller of this function is responsible for the memory used by the object pointed to by negHalfSolid when the function finishes.
|
If negHalfSolid is added to a database, the database takes responsibility for the memory.
|
If negHalfSolid is not added to a database, the caller must delete memory when it is no longer needed to avoid a memory leak.
|
*/
|
virtual OdResult getSlice(const OdGePlane& plane, bool getNegHalfToo, OdDb3dSolidPtr &negHalfSolid) = 0;
|
|
/** \details
|
Slices the ModelerGeometry object with a surface and transforms the native ModelerGeometry object to be the portion remaining on the positive side of the slicing surface normal.
|
|
\param pSurface [in] Pointer to a slicing surface.
|
\param bGetNegHalfToo [in] Flag determining whether the other (negative) part of the native ModelerGeometry object should be created as a separate ModelerGeometry object (when true).
|
\param pNegHalfSolid [out] Reference to a pointer to the created ModelerGeometry object representing the negative half of the native ModelerGeometry object. If bGetNegHalfToo is false, NULL value is returned.
|
|
\returns Returns eOk if the native ModelerGeometry object was successfully sliced or an appropriate error code in other case.
|
If pSurface pointer is NULL or the ModelerGeometry object is empty, returns eInvalidInput.
|
|
\remarks
|
The native ModelerGeometry object will be transformed to a resulting body which is located in the negative side of the surface normal.
|
|
The caller of this function is responsible for the memory used by the object pointed to by pNegHalfSolid when the function finishes.
|
If pNegHalfSolid is added to a database, the database takes responsibility for the memory.
|
If pNegHalfSolid is not added to a database, the caller must delete memory when it is no longer needed to avoid a memory leak.
|
*/
|
virtual OdResult getSlice(OdDbSurface* pSurface, bool bGetNegHalfToo, OdDb3dSolidPtr& pNegHalfSolid) = 0;
|
|
/** \details
|
Removes all edges and faces that are not needed for supporting the topology of the ModelerGeometry object.
|
|
\returns Returns eOk if successful or an appropriate error code in other case.
|
*/
|
virtual OdResult cleanBody() = 0;
|
|
/** \details
|
Offsets all faces by the specified distance.
|
|
\param offsetDistance) [in] A distance for offset.
|
|
\returns Returns eOk if all faces are successfully offset, or an appropriate error code in other case.
|
Returns eInvalidInput if the offsetDistance is less than -maxSide/2,
|
where maxSide is the size of the greater side of the ModelerGeometry object's bounding box.
|
Also, eInvalidInput is returned when the absolute value of offsetDistance is less than 1e-6.
|
|
\remarks
|
If a face has surfaces that cannot be offset, it is removed. Therefore, the offset operation
|
can cause the ModelerGeometry object to become invalid.
|
*/
|
virtual OdResult offsetBody(double offsetDistance) = 0;
|
|
/** \details
|
Separates the ModelerGeometry object into an array of solids representing the additional disjoint volumes.
|
This ModelerGeometry object is reduced to a solid with one volume.
|
|
\param newSolids [out] Reference to an array of pointers to OdDb3dSolid objects representing the additional disjoint volumes.
|
|
\returns Returns eOk if separating was successful or an appropriate error code in other case.
|
|
\remarks
|
The calling application is responsible for the resulting entities (either appending them to a database or deleting them when they are no longer needed).
|
If the new solids from the output array are not appended to the database, there will be a memory leak.
|
*/
|
virtual OdResult separateBody(OdDb3dSolidPtrArray &newSolids) = 0;
|
/** \details
|
Creates an object by sweeping a planar curve, region, or planar surface in the direction of the given vector using a distance equal to the length of the vector.
|
|
\param pSweepEnt [in] A pointer to the swept entity.
|
\param directionVec [in] Vector determining the direction and length of extruding.
|
\param sweepOptions [in] A set of sweeping options.
|
\param isSolid [in] Boolean flag that indicates that this ModelerGeometry object is solid.
|
|
\returns Returns eOk if extruding was successful or an appropriate error code in other case.
|
|
\remarks
|
Sweeping parameters (for example, angle) are set through the sweepOptions object reference.
|
*/
|
virtual OdResult createExtrudedObject ( OdDbEntity* pSweepEnt,
|
const OdGeVector3d& directionVec,
|
OdDbSweepOptions& sweepOptions,
|
bool isSolid = true) = 0;
|
/** \details
|
Creates a lofted object from the given curves.
|
|
\param crossSectionCurves [in] Array of curve entities to be used as cross sections for the lofting operation.
|
\param guideCurves [in] Array of guide curves.
|
\param pPathCurve [in] Path curve.
|
\param loftOptions [in] Options for lofting.
|
\param isSolid [in] Boolean flag.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
|
\remarks
|
Lofting parameters can be passed with the loftOptions parameter.
|
*/
|
virtual OdResult createLoftedObject (
|
OdDbEntityPtrArray& crossSectionCurves,
|
OdDbEntityPtrArray& guideCurves,
|
OdDbEntity* pPathCurve,
|
OdDbLoftOptions& loftOptions,
|
bool isSolid = true) = 0;
|
|
/** \details
|
Creates a pyramid. World origin is centered about the base of the pyramid and the pyramid is positioned at half of the specified height above the world origin.
|
|
\param height [in] Value of the pyramid's height.
|
\param sides [in] Quantity of sides for the pyramid.
|
\param radius [in] Radius for circle inscribed into the bottom polygon.
|
\param topRadius [in] Radius for circle inscribed into the top polygon.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
|
\remarks
|
The pyramid's base is located in the X-Y plane of the WCS. The pyramid's direction (from the base to the top) coincides with the positive direction of the Z-axis.
|
When radius and topRadius values are equal, a prism is created.
|
|
The following constraints are applied:
|
* |height| >= 1e-6;
|
* |radius| >= 1e-6;
|
* |topRadius| >= 1e-6;
|
* 3 <= sides <= 64.
|
*/
|
virtual OdResult createPyramid(double height, int sides,
|
double radius, double topRadius = 0.0 ) = 0;
|
|
/** \details
|
Creates an object by revolving a specified curve, region, or planar surface around the specified axis of revolution.
|
|
\param pRevEnt [in] Pointer to the planar curve, region, or planar surface that must be revolved.
|
\param axisPnt [in] Point on the axis of revolution.
|
\param axisDir [in] Direction of the revolution axis.
|
\param revAngle [in] Revolve angle in radians.
|
\param startAngle [in] Start angle of rotation. If 0, rotation will start from the current position of pRevEnt.
|
\param revolveOptions [in] Revolve options.
|
\param isSolid [in] Boolean flag.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
|
\remarks
|
Axis of revolution is defined by a point (axisPnt) and vector (axisDir).
|
pRevEnt will be revolved according to the start and revolve angles counter-clockwise about the axisDir vector.
|
|
Options for revolving can be specified with the revolveOptions object reference.
|
*/
|
virtual OdResult createRevolvedObject ( OdDbEntity* pRevEnt,
|
const OdGePoint3d& axisPnt,
|
const OdGeVector3d& axisDir,
|
double revAngle, double startAngle,
|
OdDbRevolveOptions& revolveOptions,
|
bool isSolid = true) = 0;
|
|
/** \details
|
Creates a swept object by sweeping a face along the specified path.
|
|
\param pSweepEnt [in] Pointer to the face entity for sweeping.
|
\param pPathEnt [in] Pointer to the curve entity that determines the path to sweep along.
|
\param sweepOptions [in] Sweep options.
|
\param isSolid [in] Boolean flag.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
|
\remarks
|
To set optional sweep parameters (for example, draft angle) use the sweepOptions parameter.
|
The default value for the alignment option of OdDbSweepOptions (returned by align() method) is kNoAlignment.
|
Set it to kAlignSweepEntityToPath before calling this method.
|
*/
|
virtual OdResult createSweptObject ( OdDbEntity* pSweepEnt,
|
OdDbEntity* pPathEnt,
|
OdDbSweepOptions& sweepOptions,
|
bool isSolid = true) = 0;
|
|
// Loft options utility functions
|
/** \details
|
Checks whether cross section curves are valid for the lofting operation.
|
|
\param crossSectionCurves [in] A list of cross-section curves.
|
\param allOpen [out] A passed-in parameter indicating whether all of the cross-section curves are open.
|
\param allClosed [out] A passed-in parameter indicating whether all of the cross-section curves are closed.
|
\param allPlanar [out] A passed-in parameter indicating whether all of the cross-section curves are planar.
|
\param displayErrorMessages [in] Indicates whether error messages are displayed. Default value is false.
|
|
\returns Returns eOk if curves are valid or eInvalidInput otherwise.
|
*/
|
virtual OdResult checkCrossSectionCurves (
|
OdDbEntityPtrArray& crossSectionCurves,
|
bool& allOpen, bool& allClosed, bool& allPlanar,
|
bool displayErrorMessages = false ) = 0;
|
|
/** \details
|
Checks whether guide curves are valid for the lofting operation.
|
|
\param guideCurves [in] A list of guide curves.
|
\param displayErrorMessages [in] Indicates whether error messages are displayed. Default value is false.
|
|
\returns Returns eOk if guide curves are valid or eInvalidInput otherwise.
|
*/
|
virtual OdResult checkGuideCurves ( OdDbEntityPtrArray& guideCurves,
|
bool displayErrorMessages = false ) = 0;
|
|
/** \details
|
Checks whether a path curve is valid for the lofting operation.
|
|
\param pPathCurve [in] A pointer to the path curve (can be NULL).
|
\param displayErrorMessages [in] Indicates whether error messages are displayed. Default value is false.
|
|
\returns Returns eOk if a path curve is valid or eInvalidInput otherwise.
|
*/
|
virtual OdResult checkPathCurve ( OdDbEntity *pPathCurve,
|
bool displayErrorMessages = false ) = 0;
|
|
// Sweep options utility functions
|
/** \details
|
Determines if the specified sweep entity is valid and returns the planarity of the sweep entity.
|
|
\param pSweepEnt [in] A pointer to the curve, region, or planar surface to be swept.
|
\param planarity [out] A passed-in parameter for returning the planarity flag of the entity.
|
\param pnt [out] A passed-in parameter for returning the point on the sweep entity if planarity is kPlanar, or a point on the line if planarity is kLinear.
|
\param vec [out] A passed-in parameter for returning the normal vector of the entity if planarity is kPlanar, or the line direction if planarity is kLinear.
|
\param closed [out] A passed-in parameter for returning the closed flag determining whether an entity to be swept is a closed entity.
|
\param approxArcLen [out] A passed-in parameter for returning the approximate arc length.
|
\param displayErrorMessages [in] Indicates whether error messages are displayed. Default value is false.
|
|
\returns If kPlanar is returned, then pnt and vec will specify the normal plane
|
of the entity. If kLinear is returned, then pnt and vec will specify
|
a defining point and direction of the sweep entity.
|
*/
|
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
|
/** \details
|
Checks whether a specified entity is valid for the revolve operation.
|
|
\param pRevEnt [in] A pointer to the entity (curve or region) to be revolved.
|
\param axisPnt [in] A point on the axis of revolution.
|
\param axisDir [in] A vector determining the direction of the revolution axis.
|
\param closed [out] A passed-in parameter for returning the indicator determining whether the revolved entity is closed.
|
\param endPointsOnAxis [out] A passed-in parameter for returning the indicator determining whether the revolved entity is open and whether its endpoints lie on the axis of revolution.
|
\param planar [out] A passed-in parameter for returning the indicator determining whether the revolved entity is planar.
|
\param displayErrorMessages [in] Indicates whether error messages are displayed. Default value is false.
|
|
\returns Returns eOk if a specified entity is valid for revolving, or eInvalidInput otherwise.
|
*/
|
virtual OdResult checkRevolveCurve(
|
OdDbEntity* pRevEnt,
|
const OdGePoint3d& axisPnt,
|
const OdGeVector3d& axisDir,
|
bool& closed,
|
bool& endPointsOnAxis,
|
bool& planar,
|
bool displayErrorMessages = false) = 0;
|
|
/** \details
|
Creates an extruded surface when given a planar entity with thickness,
|
or creates a plane surface when given a simple, closed planar entity.
|
|
\param pFromEntity [in] Pointer to either a planar entity with thickness, a simple, closed planar entity, or an OdDbSolid entity
|
pointed to by pFromEntity.
|
|
\remarks
|
Returns eOk if successful, or an appropriate error code if not.
|
*/
|
virtual OdResult createFrom ( const OdDbEntity* pFromEntity ) = 0;
|
|
/** \details
|
Creates region (OdDbRegion class) entities for each face of the ModelerGeometry object.
|
|
\param regions [out] Reference to an array of the OdDbRegion entities created from the face of the ModelerGeometry object.
|
|
\returns Returns eOk if successful, or an appropriate error code otherwise.
|
*/
|
virtual OdResult convertToRegion ( OdDbEntityPtrArray& regions ) = 0;
|
|
/** \details
|
Creates a 3D solid object by thickening the surface by a specified amount.
|
|
\param thickness [in] Amount to thicken the surface.
|
\param bBothSides [in] Flag indicating whether the thickening should be applied to both sides of the surface.
|
\param pSolid [out] Reference to an OdDb3dSolid object pointer created during the thickening. If thickening fails, this parameter is NULL.
|
|
\returns Returns eOk if successful, or an appropriate error code otherwise.
|
*/
|
virtual OdResult thicken(double thickness, bool bBothSides, OdDb3dSolidPtr& pSolid) const = 0;
|
/** \details
|
This method returns eOk if successful.
|
|
\param ent [in] An entity with which this entity is intersected.
|
\param intType [in] Type of intersection.
|
\param points [out] An array of points in which the intersection points should be appended.
|
\param thisGsMarker [in] GS marker of the subentity of this entity which is involved in the intersection.
|
\param otherGsMarker [in] GS marker of the subentity of the entity pointed to by pEnt which is involved in the intersection.
|
*/
|
virtual OdResult intersectWith( const OdDbEntity* ent, OdDb::Intersect intType,
|
OdGePoint3dArray& points, OdGsMarker thisGsMarker, OdGsMarker otherGsMarker ) const = 0;
|
|
/** \details
|
This method returns eOk if successful.
|
|
\param ent [in] An entity with which this entity is intersected.
|
\param intType [in] Type of intersection.
|
\param projPlane [in] A projection plane for the intersection of the two entities.
|
\param points [out] An array of points in which the intersection points should be appended.
|
\param thisGsMarker [in] GS marker of the subentity of this entity which is involved in the intersection.
|
\param otherGsMarker [in] GS marker of the subentity of the entity pointed to by pEnt which is involved in the intersection.
|
*/
|
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;
|
/** \details
|
Tapers specified faces about a specified base point and draft vector for a specified draft angle.
|
|
\param faceSubentIds [in] Array of faces' subentity IDs. Faces with specified IDs will be tapered.
|
\param basePoint [in] Reference to the base point of the draft plane.
|
\param draftVector [in] Reference to the draft direction vector.
|
\param draftAngle [in] Draft angle in radians.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
|
\remarks
|
The base point and draft vector define a draft plane about which faces are tapered.
|
If a face is lying in the draft plane, it will not be modified.
|
*/
|
virtual OdResult taperFaces(const OdArray<OdDbSubentId *> &faceSubentIds, const OdGePoint3d &basePoint,
|
const OdGeVector3d &draftVector, double draftAngle) = 0;
|
/** \details
|
Removes the specified faces from this ModelerGeometry object.
|
|
\param faceSubentIds [in] Array of faces' subentity IDs. Faces with specified IDs will be removed.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
|
\remarks
|
After removing the specified faces, the adjacent faces will enlarge to fill the gaps.
|
*/
|
virtual OdResult removeFaces(const OdArray<OdDbSubentId *> &faceSubentIds) = 0;
|
|
/** \details
|
Offsets the specified faces of this ModelerGeometry object for the specified distance.
|
|
\param faceSubentIds [in] Array of faces' subentity IDs. Faces with specified IDs will be offset.
|
\param offsetDistance [in] Offset distance.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
|
\remarks
|
The following constraints are applied:
|
* number of specified faces (in faceSubentIds parameter) must be more than zero
|
* offsetDistance >= minus half of the max side of the ModelerGeometry object's bounding box
|
* |offsetDistance| >= 1e-6
|
*/
|
virtual OdResult offsetFaces(const OdArray<OdDbSubentId *> &faceSubentIds, double offsetDistance) = 0;
|
|
/** \details
|
Transforms this ModelerGeometry object into a thin-walled ModelerGeometry object shell by offsetting faces.
|
|
\param faceSubentIds [in] Array of faces' subentity IDs. Faces with specified IDs will be removed from the shell.
|
\param offsetDistance [in] Offset distance for each face.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
|
\remarks
|
Offset can have an outside or inside direction related to the ModelerGeometry object, depending on the sign of the offsetDistance parameter:
|
* positive value means outside direction
|
* negative value means inside direction
|
*/
|
virtual OdResult shellBody(const OdArray<OdDbSubentId *> &faceSubentIds, double offsetDistance) = 0;
|
|
/** \details
|
Transforms the specified faces of a ModelerGeometry object by applying the transformation
|
matrix for rotation and (or) moving the faces.
|
|
\param faceSubentIds [in] Array of faces' subentity IDs. Faces with specified IDs will be transformed.
|
\param matrix [in] Transformation matrix to be applied to the specified faces.
|
|
\returns Returns eOk if successful or an appropriate error code in other case.
|
*/
|
virtual OdResult transformFaces(const OdArray<OdDbSubentId *> &faceSubentIds, const OdGeMatrix3d &matrix) = 0;
|
|
/** \details
|
This method returns eOk if successful.
|
|
\param type [in] A subentity type specified by the OdDb::SubentType enumeration.
|
\param gsMark [in] GS marker representing a specific subentity.
|
\param pickPoint [in] WCS coordinates of the point picked during the selection of the entity.
|
\param viewXform [in] A transformation matrix to transform from WCS to DCS.
|
\param subentPaths [out] An array of full subentity path objects identifying the subentities generated from the GS marker.
|
\param entAndInsertStack [in] An array of object IDs that are the nested containers of the subentity.
|
*/
|
virtual OdResult getSubentPathsAtGsMarker(OdDb::SubentType type,
|
OdGsMarker gsMark,
|
const OdGePoint3d& pickPoint,
|
const OdGeMatrix3d& viewXform,
|
OdDbFullSubentPathArray& subentPaths,
|
const OdDbObjectIdArray* entAndInsertStack = 0) const = 0;
|
/** \details
|
Returns an array of GS markers.
|
|
\param subPath [in] A full subentity path object identifying the subentity.
|
\param gsMarkers [out] An array with GSMarkers for the subentities.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
*/
|
virtual OdResult getGsMarkersAtSubentPath(const OdDbFullSubentPath& subPath,
|
OdGsMarkerArray& gsMarkers) const = 0;
|
/** \details
|
For internal use only.
|
|
\param ent [in] ACIS object pointer.
|
*/
|
virtual OdDbSubentId internalSubentId(void* ent) const = 0;
|
|
/** \details
|
For internal use only.
|
|
\param id [out] Subentity ID in the ACIS object.
|
*/
|
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; }
|
|
/** \details
|
Sets the color of the specified face or edge subentity.
|
|
\param subentId [in] ID of the subentity (face or edge) to be colored.
|
\param color [in] Color value to set.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
*/
|
virtual OdResult setSubentColor(const OdDbSubentId &subentId, const OdCmColor &color) = 0;
|
|
/** \details
|
Returns the color of the specified subentity.
|
|
\param subentId [in] ID of the subentity.
|
\param color [in] A reference to an OdCmColor object to store the current color of the specified subentity.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
*/
|
virtual OdResult getSubentColor(const OdDbSubentId &subentId, OdCmColor &color) const = 0;
|
|
/** \details
|
Sets a material for the specified subentity.
|
|
\param subentId [in] Subentity ID.
|
\param matId [in] Object ID for the material.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
|
\remarks
|
To remove the currently assigned material, set matId parameter value to NULL.
|
*/
|
virtual OdResult setSubentMaterial(const OdDbSubentId &subentId, OdDbObjectId matId) = 0;
|
|
/** \details
|
Returns the material of the specified subentity.
|
|
\param subentId [in] Subentity ID.
|
\param matId [in] Reference to an OdDbObjectId for returning the material object ID.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
*/
|
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;
|
/** \details
|
Creates chamfers at the edges of a ModelerGeometry object.
|
|
\param edgeSubentIds [in] Array of edge object IDs. The chamfer will be applied at the specified edges.
|
\param baseFaceSubentId [in] Base face object IDs. Chamfer will be applied on the specified face.
|
\param baseDist [in] Chamfer distance for the base face.
|
\param otherDist [in] Chamfer distance for the other faces.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
*/
|
virtual OdResult chamferEdges(const OdArray<OdDbSubentId *> &edgeSubentIds,
|
const OdDbSubentId& baseFaceSubentId,
|
double baseDist,
|
double otherDist) = 0;
|
/** \details
|
Creates rounded fillets on the edges of a ModelerGeometry object.
|
|
\param edgeSubentIds [in] Array of edges' object IDs. Fillet will be applied on the specified edges.
|
\param radius [in] Array of fillet radius values for the corresponding edges.
|
\param startSetback [in] Array of start setback values for the corresponding edges.
|
\param endSetback [in] Array of end setback values for the corresponding edges.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
*/
|
virtual OdResult filletEdges( const OdArray<OdDbSubentId *> &edgeSubentIds,
|
const OdGeDoubleArray& radius,
|
const OdGeDoubleArray& startSetback,
|
const OdGeDoubleArray& endSetback) = 0;
|
|
/** \details
|
Intersects the specified plane with this ModelerGeometry object and creates the intersection in a resulting array.
|
|
\param sectionPlane [in] Pointer to a plane object used for intersection (section cutting plane).
|
\param sectionObjects [out] A reference to an entity array for representing resulting sections.
|
|
\returns
|
Returns eOk if the intersection operation is successfully performed, or an appropriate error code otherwise.
|
*/
|
virtual OdResult createSectionObjects(const OdGePlane& sectionPlane, OdDbEntityPtrArray& sectionObjects) const = 0;
|
|
/** \details
|
Creates new entities that represent the result of interference between this ModelerGeometry object and a specified entity.
|
Created entities are appended to the specified array.
|
|
\param interferenceObjects [out] Output array of interference entities.
|
\param pEntity [in] Pointer to an entity the object must interfere with. pEntity can point to the following entity types: OdDbSurface, OdDb3dSolid, OdDbRegion, or OdDbBody.
|
\param flags [in] Interference flags; equal to kDefault (0x00).
|
|
\returns Returns eOk if interference entities are successfully created or an appropriate error code otherwise.
|
For example, if interference entities are not created, eNoIntersection error code is returned.
|
eInvalidInput is returned if an unsupported entity or NULL pointer is provided as a value of pEntity.
|
*/
|
virtual OdResult createInterferenceObjects( OdDbEntityPtrArray& interferenceObjects,
|
OdDbEntityPtr pEntity,
|
unsigned int flags ) const = 0;
|
/** \details
|
Slices this ModelerGeometry object with the specified plane and sets the object to be the portion on the positive normal side plane.
|
|
\param slicePlane [in] Reference to a plane object to be used for slicing the ModelerGeometry object.
|
\param pNegHalfSurface [out] Pointer to a new surface representing the negative side of the object that is sliced by the specified plane.
|
\param pNewSurface [out] Pointer to a new surface representing the positive half of the object that is sliced by the specified plane.
|
\param bNotModifyItself [in] Boolean flag.
|
|
\returns Returns eOk if the slicing operation is successfully performed or an appropriate error code otherwise.
|
*/
|
virtual OdResult sliceByPlane(const OdGePlane& slicePlane, OdDbSurfacePtr& pNegHalfSurface, OdDbSurfacePtr& pNewSurface, bool bNotModifyItself) = 0;
|
|
/** \details
|
Slices this ModelerGeometry object with the specified surface.
|
|
\param pSlicingSurface [in] Pointer to the surface to be used to slice this object.
|
\param pNegHalfSurface [out] Pointer to a new surface object representing the other (negative) side of the sliced surface.
|
\param pNewSurface [out] Pointer to a new surface object representing the positive side of the sliced surface.
|
\param bNotModifyItself [in] Boolean flag.
|
|
\returns Returns eOk if the slicing operation is successfully performed or an appropriate error code otherwise.
|
*/
|
virtual OdResult sliceBySurface(const OdDbSurfacePtr pSlicingSurface, OdDbSurfacePtr& pNegHalfSurface, OdDbSurfacePtr& pNewSurface, bool bNotModifyItself) = 0;
|
|
/** \details
|
Extrudes faces of the ModelerGeometry object with specified distance and taper angle.
|
|
\param faceSubentIds [in] Face's subentity ID in the drawing object.
|
\param height [in] Distance of extrusion.
|
\param taper [in] Taper angle.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
|
\remarks
|
The distance of extrusion is determined by the height parameter and the taper angle (the taper parameter).
|
|
The extrusion direction can be along or opposite the normal of each extruded face depending on the height value:
|
* If height is positive, direction is along the normal (extruding faces outward from the drawing object).
|
* If height is negative, direction is opposite the normal (extruding faces into the drawing object).
|
|
If the absolute value of taper is less than 1e-6, taper angle is assumed to be equal to 0.0.
|
|
If taper value does not equal 0.0, each face should have edges that join together smoothly (i.e. tangents at the points of connection must be equal).
|
|
The following constraints are applied:
|
* number of specified faces (in faceSubentIds parameter) must be more than zero
|
* |height| >= 1e-6
|
* |taper| >= (PI/2) - 1e-6
|
*/
|
virtual OdResult extrudeFaces(const OdArray<OdDbSubentId *> &faceSubentIds, double height, double taper) = 0;
|
|
/** \details
|
Extrudes specified faces along the specified path determined by a curve entity.
|
|
\param faceSubentIds [in] Array of faces' subentity IDs. Faces with specified IDs will be extruded.
|
\param path [in] Pointer to a curve object to extrude along (extrusion path). Can not be NULL.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
|
Faces for extrusion must be planar.
|
|
Curve entity must be one of the following:
|
* OdDbLine
|
* OdDbArc
|
* OdDbEllipse
|
* OdDbSpline
|
* OdDb2dPolyline
|
* Non-spline fit OdDb3dPolyline
|
|
Extrusion path must not have self-intersections. Also it is recommended that the path doesn't have high curvature areas.
|
If one of the end points of the path is not located on the region's plane, the path will move the point on the plane.
|
*/
|
virtual OdResult extrudeFacesAlongPath(const OdArray<OdDbSubentId *> &faceSubentIds, const OdDbCurve* path) = 0;
|
|
virtual OdResult ChangeFacesDoubleSidedParam(bool isDoubleSided) = 0;
|
|
/** \details
|
Converts this ModelerGeometry object to nurb surfaces.
|
|
\param nurbSurfaceArray [in] Array of generated nurb surfaces.
|
|
\returns Returns eOk if converting operation was successfully finished or an appropriate error code otherwise.
|
*/
|
virtual OdResult convertToNurbSurface(OdDbNurbSurfaceArray& 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;
|
/** \details
|
Returns the quantity of control points in the u direction.
|
|
\param iCount [out] A passed-in parameter for returning the quantity of control points in the u direction.
|
|
\returns Returns eOk if successful or an appropriate error code otherwise.
|
*/
|
virtual OdResult getNumberOfControlPointsInU(int& iCount) const = 0;
|
|
/** \details
|
Returns the quantity of control points in the v direction.
|
|
\param iCount [out] A passed-in parameter for returning the quantity of control points in the v direction.
|
|
\returns Returns eOk if successful or an appropriate error code otherwise.
|
*/
|
virtual OdResult getNumberOfControlPointsInV(int& iCount) const = 0;
|
|
/** \details
|
Returns the quantity of knots in the u direction.
|
|
\param iCount [out] A passed-in parameter for returning the quantity of knots in the u direction.
|
|
\returns Returns eOk if successful or an appropriate error code otherwise.
|
*/
|
virtual OdResult getNumberOfKnotsInU(int& iCount) const = 0;
|
|
/** \details
|
Returns the quantity of knots in the v direction.
|
|
\param iCount [out] A passed-in parameter for returning the quantity of knots in the v direction.
|
|
\returns Returns eOk if successful or an appropriate error code otherwise.
|
*/
|
virtual OdResult getNumberOfKnotsInV(int& iCount) const = 0;
|
|
/** \details
|
Returns the knot vector in the u direction.
|
|
\param knots [out] A passed-in parameter for returning the knot vector in the u direction.
|
|
\returns Returns eOk if successful or an appropriate error code otherwise.
|
*/
|
virtual OdResult getUKnots(OdGeKnotVector& knots) const = 0;
|
|
/** \details
|
Returns the knot vector in the v direction.
|
|
\param knots [out] A passed-in parameter for returning the knot vector in the v direction.
|
|
\returns Returns eOk if successful or an appropriate error code otherwise.
|
*/
|
virtual OdResult getVKnots(OdGeKnotVector& knots) const = 0;
|
|
/** \details
|
Returns the degree of the ModelerGeometry object in the u direction.
|
|
\param iDegree [out] A passed-in parameter for returning the degree in the u direction.
|
|
\returns Returns eOk if successful.
|
*/
|
virtual OdResult getDegreeInU(int& iDegree) const = 0;
|
|
/** \details
|
Returns the degree of the ModelerGeometry object in the v direction.
|
|
\param iDegree [out] A passed-in parameter for returning the degree in the v direction.
|
|
\returns Returns eOk if successful.
|
*/
|
virtual OdResult getDegreeInV(int& iDegree) const = 0;
|
|
/** \details
|
Determines whether the ModelerGeometry object is closed in the u direction.
|
|
\param bIsClosed [out] A passed-in parameter for returning the indicator of whether the ModelerGeometry object is closed in the u direction.
|
bIsClosed is equal to true if the ModelerGeometry object is closed in the u direction, otherwise it is equal to false.
|
|
\returns Returns eOk if successful.
|
*/
|
virtual OdResult isClosedInU(bool& bIsClosed) const = 0;
|
|
/** \details
|
Determines whether the ModelerGeometry object is closed in the v direction.
|
|
\param bIsClosed [out] A passed-in parameter for returning the indicator of whether the ModelerGeometry object is closed in the v direction.
|
bIsClosed is equal to true if the ModelerGeometry object is closed in the v direction, otherwise it is equal to false.
|
|
\returns Returns eOk if successful.
|
*/
|
virtual OdResult isClosedInV(bool& bIsClosed) const = 0;
|
|
/** \details
|
Determines whether the ModelerGeometry object is periodic in the u direction.
|
|
\param bIsPeriodic [out] A passed-in parameter for returning the indicator of whether the ModelerGeometry object is periodic in the u direction.
|
bIsPeriodic is equal to true if the ModelerGeometry object is periodic in the u direction, otherwise it is equal to false.
|
|
\returns Returns eOk if successful.
|
*/
|
virtual OdResult isPeriodicInU(bool& bIsPeriodic) const = 0;
|
|
/** \details
|
Determines whether the ModelerGeometry object is periodic in the v direction.
|
|
\param bIsPeriodic [out] A passed-in parameter for returning the indicator of whether the ModelerGeometry object is periodic in the v direction.
|
bIsPeriodic is equal to true if the ModelerGeometry object is periodic in the v direction, otherwise it is equal to false.
|
|
\returns Returns eOk if successful.
|
*/
|
virtual OdResult isPeriodicInV(bool& bIsPeriodic) const = 0;
|
|
/** \details
|
Returns the period value in the u direction for the ModelerGeometry object.
|
Returned value is valid only if the ModelerGeometry object is periodic in the u direction.
|
|
\param dPeriod [out] A passed-in parameter for returning the period value in the u direction.
|
|
\returns Returns eOk if successful.
|
*/
|
virtual OdResult getPeriodInU(double& dPeriod) const = 0;
|
/** \details
|
Returns the period value in the v direction for the ModelerGeometry object.
|
Returned value is valid only if the ModelerGeometry object is periodic in the v direction.
|
|
\param dPeriod [out] A passed-in parameter for returning the period value in the v direction.
|
|
\returns Returns eOk if successful.
|
*/
|
virtual OdResult getPeriodInV(double& dPeriod) const = 0;
|
|
/** \details
|
Evaluates the position on the ModelerGeometry object at the specified parameter value (u, v).
|
|
\param dU [in] u direction parameter.
|
\param dV [in] v direction parameter.
|
\param pos [out] A passed-in parameter for returning the evaluated position on the ModelerGeometry object.
|
|
\returns Returns eOk if evaluation is successfully done.
|
If the u or v value is out of range, returns eOutOfRange.
|
*/
|
virtual OdResult evaluate(double dU, double dV, OdGePoint3d& pos) const = 0;
|
|
/** \details
|
Evaluates the position and first derivatives on the ModelerGeometry object at the specified parameter value (u, v).
|
|
\param dU [in] u direction parameter.
|
\param dV [in] v direction parameter.
|
\param pos [out] A passed-in parameter for returning the evaluated position on the ModelerGeometry object.
|
\param uDeriv [out] A passed-in parameter for returning the first derivative with respect to u.
|
\param vDeriv [out] A passed-in parameter for returning the first derivative with respect to v.
|
|
\returns
|
Returns eOk if evaluation is successfully done.
|
If the u or v value is out of range, returns eOutOfRange.
|
*/
|
virtual OdResult evaluate(double dU, double dV, OdGePoint3d& pos, OdGeVector3d& uDeriv, OdGeVector3d& vDeriv) const = 0;
|
|
/** \details
|
Evaluates the position and first and second derivatives on the ModelerGeometry object at the specified parameter value (u, v).
|
|
\param dU [in] u direction parameter.
|
\param dV [in] v direction parameter.
|
\param pos [out] A passed-in parameter for returning the evaluated position on the surface.
|
\param uDeriv [out] A passed-in parameter for returning the first derivative with respect to u.
|
\param vDeriv [out] A passed-in parameter for returning the first derivative with respect to v.
|
\param uuDeriv [out] A passed-in parameter for returning the second derivative with respect to u twice.
|
\param uvDeriv [out] A passed-in parameter for returning the second derivative with respect to u and v.
|
\param vvDeriv [out] A passed-in parameter for returning the second derivative with respect to v twice.
|
|
\returns Returns eOk if evaluation is successfully done.
|
If the u or v value is out of range, returns eOutOfRange.
|
*/
|
virtual OdResult evaluate(double dU, double dV, OdGePoint3d& pos, OdGeVector3d& uDeriv, OdGeVector3d& vDeriv,
|
OdGeVector3d& uuDeriv, OdGeVector3d& uvDeriv, OdGeVector3d& vvDeriv) const = 0;
|
|
/** \details
|
Evaluates the position and an arbitrary number of derivatives of the ModelerGeometry object at the specified parameter value (u, v).
|
|
\param dU [in] u direction parameter.
|
\param dV [in] v direction parameter.
|
\param iDerivDegree [in] The degree of derivatives to evaluate.
|
\param point [out] A passed-in parameter for returning the evaluated position on the ModelerGeometry object.
|
\param derivatives [out] A passed-in parameter for returning derivatives array of vectors, in the order of uDeriv, vDeriv, uuDeriv, uvDeriv, vvDeriv.
|
|
\returns Returns eOk if evaluation is successfully done.
|
If the u or v value is out of range, returns eOutOfRange.
|
*/
|
virtual OdResult evaluate(double dU, double dV, int iDerivDegree, OdGePoint3d& point, OdGeVector3dArray& derivatives) const = 0;
|
|
/** \details
|
Determines whether the ModelerGeometry object is rational.
|
If the ModelerGeometry object is rational, the method returns true, otherwise the method returns false.
|
|
\param bIsRational [out] A passed-in parameter for returning the indicator of whether the ModelerGeometry object is rational.
|
|
\returns Returns eOk if successful.
|
*/
|
virtual OdResult isRational(bool& bIsRational) const = 0;
|
|
/** \details
|
Determines whether the ModelerGeometry object is a planar surface. If the surface is planar, also returns the plane information and normal.
|
If the surface is planar, the method returns true via the bIsPlanar parameter, otherwise the method returns false.
|
|
\param bIsPlanar [out] A passed-in parameter for returning the indicator of whether the surface is planar.
|
\param ptOnSurface [out] A passed-in parameter for returning the point on the surface (if the surface is planar).
|
\param normal [out] A passed-in parameter for returning the plane normal (if the surface is planar).
|
|
\returns Returns eOk if successful. If the surface doesn't contain any NURBS information, returns eFail.
|
*/
|
virtual OdResult isPlanar(bool& bIsPlanar, OdGePoint3d& ptOnSurface, OdGeVector3d& normal) const = 0;
|
|
/** \details
|
Determines whether a specified point is on the ModelerGeometry object.
|
If the specified point is on the ModelerGeometry object, the method returns true via bOnSurface, otherwise the method returns false.
|
|
\param point [in] A point.
|
\param bOnSurface [out] A passed-in parameter for returning the indicator of whether the specified point is on the surface.
|
|
\returns Returns eOk if successful.
|
*/
|
virtual OdResult isPointOnSurface(const OdGePoint3d& point, bool& bOnSurface) const = 0;
|
|
/** \details
|
Returns the normal vector at the specified parameter location ([u, v]).
|
|
\param dU [in] u parameter.
|
\param dV [in] v parameter.
|
\param normal [out] A passed-in parameter for returning the normal vector.
|
|
\returns Returns eOk if successful. If the dU or dV values are invalid, returns eOutOfRange.
|
*/
|
virtual OdResult getNormal(double dU, double dV, OdGeVector3d& normal) const = 0;
|
|
/** \details
|
Returns the simple patches in the u direction.
|
|
\param span [out] A passed-in parameter for returning the number of simple patches in the u direction.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
*/
|
virtual OdResult getNumberOfSpansInU(int& iSpan) const = 0;
|
|
/** \details
|
Returns the simple patches in the v direction.
|
|
\param span [out] A passed-in parameter for returning the number of simple patches in the v direction.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
*/
|
virtual OdResult getNumberOfSpansInV(int& iSpan) const = 0;
|
|
/** \details
|
Returns the specified number of isolines created in the v direction.
|
|
\param dNumberSegments [in] Number of isoline segments.
|
\param lineSegments [out] Array of isoline segments.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
*/
|
virtual OdResult getIsolineAtU(double dNumberSegments, OdDbCurvePtrArray& lineSegments) const = 0;
|
|
/** \details
|
Returns the specified number of isolines created in the u direction.
|
|
\param dNumberSegments [in] Number of isoline segments.
|
\param lineSegments [out] Array of isoline segments.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
*/
|
virtual OdResult getIsolineAtV(double dNumberSegments, OdDbCurvePtrArray& lineSegments) const = 0;
|
|
/** \details
|
Inserts a knot at the specified u or v parameter.
|
The knot insertion doesn't modify the shape of the ModelerGeometry object.
|
|
\param dVal [in] New knot.
|
\param iUorV [in] u or v parameter.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
|
*/
|
virtual OdResult InsertKnot(double dVal, int iUorV) = 0;
|
|
/** \details
|
Inserts a row of control points at the given u knot parameter.
|
|
\param dU [in] u parameter.
|
\param vCtrlPts [in] An array of control points to be added.
|
\param vWeights [in] Array of weight values to add if the surface is rational.
|
|
\returns Returns eOk if successful.
|
If the dU parameter is out of range, returns eOutOfRange.
|
*/
|
virtual OdResult InsertControlPointsAtU(double dU, const OdGePoint3dArray& vCtrlPts, const OdGeDoubleArray& vWeights) = 0;
|
|
/** \details
|
Inserts a row of control points at the given v knot parameter.
|
|
\param dU [in] v parameter.
|
\param vCtrlPts [in] An array of control points to be added.
|
\param vWeights [in] Array of weight values to add if the surface is rational.
|
|
\returns Returns eOk if successful.
|
If the dU parameter is out of range, returns eOutOfRange.
|
*/
|
virtual OdResult InsertControlPointsAtV(double dV, const OdGePoint3dArray& uCtrlPts, const OdGeDoubleArray& uWeights) = 0;
|
|
/** \details
|
Removes a row of control points at the specified position in the control points array.
|
The method modifies the shape of the ModelerGeometry object.
|
|
\param iUDegree [in] An index of the control point to remove from the array.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
*/
|
virtual OdResult RemoveControlPointsAtU(int iUDegree) = 0;
|
|
/** \details
|
Removes a row of control points at the specified position in the control points array.
|
The method modifies the shape of the ModelerGeometry object.
|
|
\param iVDegree [in] An index of the control point to remove from the array.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
*/
|
virtual OdResult RemoveControlPointsAtV(int iVDegree) = 0;
|
|
/** \details
|
Rebuilds this ModelerGeometry object with a specified new degree and quantity of control points in the u and v directions.
|
This operation modifies the shape of the ModelerGeometry object.
|
|
\param iUDegree [in] The new degree value in the u direction.
|
\param iVDegree [in] The new degree value in the v direction.
|
\param iNumUCtrlPts [in] The new quantity of control points in the u direction.
|
\param iNumVCtrlPts [in] The new quantity of control points in the v direction.
|
\param bRestore [in] Restore flag.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
*/
|
virtual OdResult rebuild(int iUDegree, int iVDegree, int iNumUCtrlPts, int iNumVCtrlPts, bool bRestore) = 0;
|
|
/** \details
|
Adjusts the location and tangent of a point on this ModelerGeometry object with the specified parameter ([u, v]).
|
The local control points are adjusted accordingly.
|
If the pointer uDeriv and vDeriv are equal to NULL, then only the location of the point is adjusted.
|
|
\param dU [in] u parameter.
|
\param dV [in] v parameter.
|
\param point [in] A new location of the point on the surface.
|
\param uDeriv [in] The tangent vector in the u direction.
|
\param vDeriv [in] The tangent vector in the v direction.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
*/
|
virtual OdResult modifyPositionAndTangent(double dU, double dV, const OdGePoint3d& point, const OdGeVector3d* uDeriv, const OdGeVector3d* vDeriv) = 0;
|
|
/** \details
|
Returns the u and v parameter for a point on this ModelerGeometry object.
|
|
\param point [in] A point on the ModelerGeometry object.
|
\param dU [in] A passed-in parameter for returning the value of the u parameter.
|
\param dV [in] A passed-in parameter for returning the value of the v parameter.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
*/
|
virtual OdResult getParameterOfPoint(const OdGePoint3d& point, double& dU, double& dV) const = 0;
|
|
/** \details
|
Returns the control points and the quantity of control points in both u and v directions.
|
|
\param iUCount [out] The quantity of control points in the u direction.
|
\param iVCount [out] The quantity of control points in the v direction.
|
\param points [out] Array of control points (in WCS coordinates).
|
|
\returns Returns eOk if control points were successfully returned, or an appropriate error code in the other case.
|
|
\remarks
|
The control points will be allocated in the passed-in OdGePoint3d array.
|
The column indexes are for the v direction, and row indexes are for the u direction.
|
For example, if the surface has n control points in the u direction and m control points in the v direction,
|
the array looks like [0,0], [0,1], ...[0,vCount-1], ..., [uCount-1,0], [uCount-1,1], ...[uCount-1,vCount-1].
|
*/
|
virtual OdResult getControlPoints(int& iUCount, int& iVCount, OdGePoint3dArray& points) const = 0;
|
|
/** \details
|
Sets the control points.
|
|
\param iUCount [in] The new value of the quantity of control points in the u direction.
|
\param iVCount [in] The new value of the quantity of control points in the v direction.
|
\param points [in] New array of control points (in WCS coordinates).
|
|
\returns Returns eOk if control points were successfully set or an appropriate error code in the other case.
|
|
\remarks
|
The new quantity of control points in the u and v direction must be equal to the current values.
|
New control points are allocated in an AcGePoint3d array.
|
The column indexes are for the v direction, and row indexes are for the u direction.
|
For example, if the surface has n control points in the u direction and m control points in the v direction, the array looks like [0,0], [0,1], ...[0,vCount-1], ..., [uCount-1,0], [uCount-1,1], ...[uCount-1,vCount-1].
|
*/
|
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;
|
|
/** \details
|
Sets the new color for subentities.
|
|
\param color [in] New color value.
|
|
\returns Returns eOk if the new color value was successfully set or an appropriate error code in the other case.
|
*/
|
virtual OdResult setColorToSubents(OdCmColor const& color) = 0;
|
|
/** \details
|
Sets the material.
|
|
\param materialId [in] New material.
|
|
\returns Returns eOk if the new material value was successfully set or an appropriate error code in the other case.
|
*/
|
virtual OdResult setMaterialToSubents(OdDbObjectId materialId) = 0;
|
|
virtual OdResult setMaterialResolver(const OdMaterialResolver *pResolver) = 0;
|
|
virtual OdResult setMaterialMapperToSubents(OdGeMatrix3d &mx, OdUInt8 &projection,
|
OdUInt8 &tiling, OdUInt8 &autoTransform) = 0;
|
|
virtual OdResult generateSectionGeometry(const OdDbSection* pSection,
|
OdDbEntityPtrArray& sourceEntArr,
|
OdArray<OdDbEntityPtr>& intBoundaryEnts,
|
OdArray<OdDbEntityPtr>& intFillEnts,
|
OdArray<OdDbEntityPtr>& backgroundEnts,
|
OdArray<OdDbEntityPtr>& foregroundEnts,
|
OdArray<OdDbEntityPtr>& curveTangencyEnts,
|
bool bIsSetProperties) = 0;
|
/** \details
|
Trims the surface with specified cutting curves.
|
When curves are used, the actual trimming boundary is formed by projecting
|
the curves onto the surface, so the additional information of project direction needs to be provided.
|
|
\param toolIds [in] Reference to an array of the cutting entity's IDs. Bodies of specified entities are used to trim the specified surface.
|
\param toolCurveIds [in] Reference to an array of the cutting curve's IDs. The specified surface will be trimmed by projecting curves to it.
|
\param projVectors [in] Reference to an array of projection direction for each cutting curve.
|
\param pickPoint [in] Pick point that specifies which area of the specified surface must be trimmed.
|
\param viewVector [in] Vector representing the view direction for creating a ray starting from the pick point.
|
\param bAutoExtend [in] If this option is set, then when a tool body consists of a single face with analytic geometry, the underlying geometry will be extended as much as possible to make sure the surface is trimmed. The tool body supplied will not be modified.
|
\param bAssociativeEnabled [in] Specifies whether the surface trimming operation should be associative.
|
|
\returns Returns eOk if trimming operation was successfully finished or an appropriate error code otherwise.
|
*/
|
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;
|
|
/** \details
|
Creates a solid by trimming and (or) extending the specified surfaces and 3D solids, forming an enclosed volume.
|
|
\param limitingBodies [in] Reference to the entity array (representing surface and solids) that are used to create a solid.
|
\params limitingFlags [in] Reserved for internal use.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
*/
|
virtual OdResult createSculptedSolid(OdDbEntityPtrArray& limitingBodies,
|
const OdGeIntArray& limitingFlags) = 0;
|
|
/** \details
|
Creates a ray which starts from a specified point and has a specified direction.
|
|
\param rayBasePoint [in] A base point to start a ray from.
|
\param rayDir [in] A ray direction.
|
\param rayRadius [in] A ray radius. It defines the tolerance used for intersection checking.
|
\param subEntIds [out] A reference to subentities array to return. Returned subentities can be one of the following: faces, edges, or vertices.
|
\param parameters [out] An array of parameters to return. Parameters shows the intersection between a ray and subentities.
|
|
\returns Returns eOk if a ray was successfully created or an appropriate error code in the other case.
|
*/
|
virtual OdResult rayTest( const OdGePoint3d& rayBasePoint,
|
const OdGeVector3d& rayDir,
|
double rayRadius,
|
OdArray<OdDbSubentId> & subEntIds,
|
OdGeDoubleArray& parameters) const = 0;
|
|
/** \details
|
Creates a tangent surface between two edges of a surface with constant radius and trimming or no trimming of the original surfaces.
|
|
\param surf1 [out] Pointer to a first source surface.
|
\param pickPt1 [in] 3D point specifying the side on the first source surface that will be kept after filleting.
|
\param surf2 [out] Pointer to a second source surface.
|
\param pickPt2 [in] 3D point specifying the side on the second source surface that will be kept after filleting.
|
\param dRadius [in] Radius for fillet operation (positive value).
|
\param trimMode [in] Flag that specifies the OdDb::FilletTrimMode value.
|
\param projDir [in] 3D vector specifying the projection (view) direction for pick points.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
|
\remarks
|
The trimMode can be one of the following:
|
* kTrimNone
|
* kTrimFirst
|
* kTrimSecond
|
* kTrimBoth
|
*/
|
virtual OdResult createFilletSurface (OdDbSurfacePtr& surf1,
|
const OdGePoint3d& pickPt1,
|
OdDbSurfacePtr& surf2,
|
const OdGePoint3d& pickPt2,
|
double dRadius,
|
OdDb::FilletTrimMode trimMode,
|
const OdGeVector3d& projDir) = 0;
|
|
/** \details
|
Extends the edges of this ModelerGeometry object.
|
|
\param edgesId [out] Array of full sub-entity paths of the edges that need to be extended.
|
\param dExtDist [in] Distance at which the ModelerGeometry object should be expanded.
|
\param extOption [in] Extension option, if edges need to be extended or stretched.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
*/
|
virtual OdResult extendEdges( OdDbFullSubentPathArray& edgesId,
|
double dExtDist,
|
EdgeExtensionType extOption ) = 0;
|
|
virtual OdResult getObjectMesh( const OdDbFaceterSettings *faceter,
|
OdGePoint3dArray& vertexArray,
|
OdInt32Array& faceArray,
|
OdGiFaceData*& faceData ) = 0;
|
|
|
/** \details
|
Returns the bounding box.
|
|
\param box [out] 3D bounding boxes as minimum and maximum 3D points.
|
|
\returns Returns eOk if successful or an appropriate error code in the other case.
|
*/
|
virtual OdResult getBoundingBox(OdGeExtents3d &box) = 0;
|
|
/** \details
|
For internal use only.
|
*/
|
virtual OdResult generateSectionGeometry( SectArgs& sectArgs, OdDbEntity *pEnt, bool* bHasForeground ) = 0;
|
|
virtual OdResult createCachedCurves(OdGeCurve3dPtrArray& pCurves) = 0;
|
|
#ifdef SOLID_HISTORY
|
virtual OdResult SetPerSubentityAttributes(unsigned long iEntIndex) = 0;
|
#endif
|
|
virtual OdResult convertTo(const OdGePoint3dArray &arrVertexes, const OdInt32Array &arrEdges, const OdInt32Array &arrFaces, OdGiFaceData &fd,
|
OdInt32Array &arrFacesColors, OdInt32Array &arrFacesMaterials, OdDbEntity* pEntity) = 0;
|
};
|
|
/** \details
|
This template class is a specialization of the OdSmartPtr class for OdModelerGeometry object pointers.
|
*/
|
typedef OdSmartPtr<OdModelerGeometry> OdModelerGeometryPtr;
|
|
#include "TD_PackPop.h"
|
|
#endif // _OD_MODELERGEOMETRY_INCLUDED_
|
