/////////////////////////////////////////////////////////////////////////////// // Copyright (C) 2002-2025, 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-2025 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_GE_CURVE_BOUNDARY_H #define OD_GE_CURVE_BOUNDARY_H /*!DOM*/ #include "Ge/GeEntity3d.h" class OdGeCurve2d; class OdGeEntity3d; class OdGePosition3d; #include "TD_PackPush.h" /** \details This class represents the boundary geometry (face loops) on a bounded surface. \remarks Each face loop consists of four arrays: * 3D curve or position pointers * 2D parameter space curve pointers * 3D orientations * 2D orientations There is a one-to-one correspondence between elements in the arrays, although certain elements of a given array could be nullptr, or meaningless. Loop degeneracies are represented as follows: * The entire loop degenerates to a single model space point, which is represented by the tuple (numElements = 1, position3d, curve2d). The curve2d may be nullptr. The edge sense, and the curve2d sense are irrelevant. isDegenerate() method allows the determination of this condition on a loop. * A loop consisting of one or more model space degeneracies is represented as the general case with those edges that are degenerate represented by position3d. This implies that in the general case, model space geometry of a curve boundary may consist of curve3d and/or position3d pointers. Consequently, this geometry is obtained by the user as entity3d pointers. The degeneracy of a constituent edge can be detected by the type of the model space geometry. This class also supports the ownership of its geometry. Being the owner of its geometry would cause it to remove the geometry on destruction of an instance of the class. Corresponding C++ library: TD_Ge \sa */ class GE_TOOLKIT_EXPORT OdGeCurveBoundary { public: /** \details Default constructor for the OdGeCurveBoundary class. Constructs an empty curve boundary. */ OdGeCurveBoundary(); /** \details Constructor for the OdGeCurveBoundary class. Constructs a curve boundary with the specified parameters. \param numCurves [in] Number of curves in the curve boundary. \param crv3d [in] Array of 3D curves of each element in the curve boundary. \param crv2d [in] Array of 2D curves of each element in the curve boundary. \param orientation3d [in] Array of orientation flags for each 3D curve element (regular or revesed). Valid only if crv3d is not nullptr; \param orientation2d [in] Array of orientation flags for each 2D curve element (regular or revesed). Valid only if crv2d is not nullptr; \param makeCopy [in] If true, makes a copy of 3D and 2D curves (if corresponding arrays are not nullptr). */ OdGeCurveBoundary( int numCurves, const OdGeEntity3d *const * crv3d, const OdGeCurve2d *const * crv2d, bool* orientation3d, bool* orientation2d, bool makeCopy = true); /** \details Copy constructor for the OdGeCurveBoundary class. Copies the specified curve boundary. \param source [in] Curve boundary to copy. */ OdGeCurveBoundary(const OdGeCurveBoundary& source); /** \details Destructor for the OdGeCurveBoundary class. Frees the allocated resources for owned curves (if the option for making curve copies was used). */ ~OdGeCurveBoundary(); /** \details Assignment operator for the OdGeCurveBoundary class. Assigns properties of the specified cubic spline curve. Currently not implemented. \param crvBoundary [in] Curve boundary to assign. */ OdGeCurveBoundary& operator =( const OdGeCurveBoundary& crvBoundary); // Query the data. // /** \details Checks whether the curve boundary degenerates to a single 3D point. Currently not implemented. \returns true if this curve boundary is degenerate, false otherwise. */ bool isDegenerate() const; /** \details Checks whether the curve boundary degenerates to a single 3D point. Currently not implemented. \param degenPoint [out] Receives the point to which the boundary degenerates. \param paramCurve [out] Receives the paramater curve corresponding to degenPoint. \remarks If this method returns true, paramCurve is created with the new operator, and it is the responsibility of the caller to delete it. \returns true if this curve boundary is degenerate, false otherwise. */ bool isDegenerate( OdGePosition3d& degenPoint, OdGeCurve2d** paramCurve) const; /** \details Returns the number of elements in the curve boundary. */ int numElements() const; /** \details Returns the paramaters for the curve boundary. \param numCurves [out] Receives the number of curves in the curve boundary. \param crv3d [out] Receives an array of 3D curves for each element in the curve boundary. \param crv2d [out] Receives an array of 2D curves for each element in the curve boundary. \param orientation3d [out] Receives an array of orientation flags for each 3D curve element. Valid only if crv3d is not nullptr; if nullptr, the caller must delete allocated memory that was intended for numCurves. \param orientation2d [out] Receives an array of orientation flags for each 2D curve element. Valid only if crv2d is not nullptr; if nullptr, the caller must delete allocated memory that was intended for numCurves. \remarks For each array, provide memory for the array or allow getCountour to allocate it, and delete the elements of the array. If an array is nullptr, getCountour allocates memory and the caller must also delete the corresponding array. */ void getContour( int& numCurves, OdGeEntity3d*** crv3d, OdGeCurve2d*** crv2d, bool** orientation3d, bool** orientation2d) const; /** \details Sets the parameters for the curve boundary and returns a reference to it. \param numCurves [in] Number of curves in the curve boundary. \param crv3d [in] Array of 3D curves of each element in the curve boundary. \param crv2d [in] Array of 2D curves of each element in the curve boundary. \param orientation3d [in] Array of orientation flags for each 3D curve element (regular or revesed). Valid only if crv3d is not nullptr; \param orientation2d [in] Array of orientation flags for each 2D curve element (regular or revesed). Valid only if crv2d is not nullptr; \param makeCopy [in] If true, makes a copy of each 3D and 2D curve. */ OdGeCurveBoundary& set( int numCurves, const OdGeEntity3d *const * crv3d, const OdGeCurve2d *const * crv2d, bool* orientation3d, bool* orientation2d, bool makeCopy = true); // Curve ownership. // /** \details Checks whether the curve boundary is the owner of the curve boundary parameters. \returns true if this curve boundary owns the curve boundary parameters, false otherwise. */ bool isOwnerOfCurves() const; /** \details Makes the curve boundary own the curve data and returns a reference to the boundary. \remarks If the external boundary owns the data, it will be destroyed when the boundary is destroyed. */ OdGeCurveBoundary& setToOwnCurves(); protected: int m_iNumCurves; OdGeEntity3d** m_pArrCrv3d; OdGeCurve2d** m_pArrCrv2d; bool* m_bArrOrientation3d; bool* m_bArrOrientation2d; bool m_bMakeCopy; }; #include "TD_PackPop.h" #endif // OD_GE_CURVE_BOUNDARY_H