///////////////////////////////////////////////////////////////////////////////
|
// 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_GENURB2d_H
|
#define OD_GENURB2d_H /*!DOM*/
|
|
#include "Ge/GeSplineEnt2d.h"
|
#include "OdPlatformSettings.h"
|
|
class OdGeNurbCurve2dImpl;
|
class OdGePolyline2d;
|
class OdGeEllipArc2d;
|
class OdGeLineSeg2d;
|
class OdGeKnotVector;
|
|
#include "TD_PackPush.h"
|
|
/** \details
|
This class represents non-uniform rational B-splines (NURBS) in 2D space.
|
|
Library: TD_Ge
|
|
<group OdGe_Classes>
|
|
\sa
|
<link ge_OdGeNurbCurve3d.html, Working with NURBS curves>
|
*/
|
class GE_TOOLKIT_EXPORT OdGeNurbCurve2d : public OdGeSplineEnt2d
|
{
|
public:
|
|
|
/** \param degree [in] Degree of spline.
|
\param knots [in] Knot vector.
|
\param controlPoints [in] Array of 2D control points.
|
\param weights [in] Array of weights
|
\param isPeriodic [in] True if and only if the spline is to be periodic.
|
\param source [in] Object to be cloned.
|
|
\remarks
|
* If weights is not specified, a non-rational spline is constructed.
|
* If weights is specified, then a rational spline is constructed, and controlPoints.length() must equal weights.length()
|
* If isPeriodic is false, then knots.length() must equal controlPoints.length() + degree + 1
|
* If isPeriodic is true, then knots.length() must equal controlPoints.length(), the first and last controlPoints must be equal
|
and the first and last weights (if provided) must be equal.
|
*/
|
OdGeNurbCurve2d();
|
OdGeNurbCurve2d(
|
const OdGeNurbCurve2d& source);
|
OdGeNurbCurve2d(
|
int degree,
|
const OdGeKnotVector& knots,
|
const OdGePoint2dArray& controlPoints,
|
bool isPeriodic = false);
|
OdGeNurbCurve2d(
|
int degree,
|
const OdGeKnotVector& knots,
|
const OdGePoint2dArray& controlPoints,
|
const OdGeDoubleArray& weights,
|
bool isPeriodic = false);
|
OdGeNurbCurve2d(
|
int degree,
|
const OdGePolyline2d& fitPolyline,
|
bool isPeriodic = false);
|
OdGeNurbCurve2d(
|
const OdGePoint2dArray& fitPoints,
|
const OdGeVector2d& startTangent,
|
const OdGeVector2d& endTangent,
|
bool startTangentDefined = true,
|
bool endTangentDefined = true,
|
const OdGeTol& fitTolerance = OdGeContext::gTol);
|
OdGeNurbCurve2d(
|
const OdGePoint2dArray& fitPoints,
|
const OdGeTol& fitTolerance = OdGeContext::gTol);
|
OdGeNurbCurve2d(
|
const OdGePoint2dArray& fitPoints,
|
const OdGeVector2dArray& fitTangents,
|
const OdGeTol& fitTolerance = OdGeContext::gTol,
|
bool isPeriodic = false);
|
OdGeNurbCurve2d(
|
const OdGeEllipArc2d& ellipse);
|
OdGeNurbCurve2d(
|
const OdGeLineSeg2d& linSeg);
|
|
OdGeNurbCurve2d(
|
const OdGePoint2dArray& fitPoints,
|
const OdGeVector2d& startTangent,
|
const OdGeVector2d& endTangent,
|
bool startTangentDefined,
|
bool endTangentDefined,
|
OdGeKnotParameterization knotParam,
|
const OdGeTol& fitTol = OdGeContext::gTol);
|
|
|
int numFitPoints() const;
|
|
/** \details
|
Returns true if and only if 0 <= index < numFitPoints(),
|
and returns the fit point at the specified index.
|
|
\param fitPointIndex [in] Fit point index.
|
\param point [out] Receives the fit point.
|
*/
|
bool getFitPointAt(
|
int index,
|
OdGePoint2d& point) const;
|
|
/** \details
|
Returns true if and only if this spline was constructed
|
with fit points, and gets the fit tolerance that is
|
used to construct this spline.
|
|
\param fitTolerance [out] Recieves the geometric tolerance.
|
*/
|
bool getFitTolerance(
|
OdGeTol& fitTolerance) const;
|
|
/** Descripton:
|
Returns true if and only if this spline was constructed with fit data, and
|
returns the starting and ending tangents.
|
|
\param startTangent [out] Receives the starting tangent
|
\param endTangent [out] Receives the ending tangent.
|
*/
|
bool getFitTangents(
|
OdGeVector2d& startTangent,
|
OdGeVector2d& endTangent) const;
|
|
/** \details
|
Returns true if and only if this spline was constructed with fit data,
|
and returns all the fit data used to construct this spline.
|
|
\param fitPoints [out] Receives the interpolation points.
|
\param fitTolerance [out] Receives the geometric tolerance.
|
\param tangentsExist [out] Receives true if and only if tangents were used in constructing this spline.
|
\param startTangent [out] Receives the starting tangent
|
\param endTangent [out] Receives the ending tangent.
|
\param knotParam [out] Receives the knot parameterization.
|
|
\remarks
|
startTangent and endTangent are meaningful if and only if tangentsExist == true.
|
|
\note
|
Currently not implemented.
|
*/
|
bool getFitData(
|
OdGePoint2dArray& fitPoints,
|
OdGeTol& fitTolerance,
|
bool& tangentsExist,
|
OdGeVector2d& startTangent,
|
OdGeVector2d& endTangent) const;
|
|
bool getFitData(
|
OdGePoint2dArray& fitPoints,
|
OdGeTol& fitTolerance,
|
bool& tangentsExist,
|
OdGeVector2d& startTangent,
|
OdGeVector2d& endTangent,
|
OdGeKnotParameterization& knotParam) const;
|
|
/** \details
|
Gets the knot parametrization of the spline created with fit points and returns true if successful.
|
|
\param knotParam [out] Receives the knot parametrization.
|
|
\note
|
Currently not implemented.
|
*/
|
bool getFitKnotParameterization(OdGeKnotParameterization& knotParam) const;
|
|
/** \details
|
Returns all the data that define the spline.
|
|
\param degree [out] Receives the degree of spline.
|
\param knots [out] Receives the knot vector.
|
\param controlPoints [out] Receives an array of 2D control points.
|
\param weights [out] Receives an array of weights.
|
\param rational [out] Receives true if and only if the spline is rational.
|
\param periodic [out] Receives true true if and only if the spline is periodic.
|
|
\remarks
|
The weights array will be empty if the spline is not rational.
|
*/
|
void getDefinitionData(
|
int& degree,
|
bool& rational,
|
bool& periodic,
|
OdGeKnotVector& knots,
|
OdGePoint2dArray& controlPoints,
|
OdGeDoubleArray& weights) const;
|
|
/** \details
|
Returns the number of weights in the spline.
|
|
\remarks
|
Feturns numControlPoints() if this spline is rational, 0 if it is not.
|
*/
|
int numWeights() const;
|
|
/** \details
|
Returns the weight at the specified index.
|
|
\param weightIndex [in] Weight index.
|
*/
|
double weightAt(
|
int weightIndex) const;
|
|
/** \details
|
Returns the current evaluation mode.
|
|
\note
|
Currently not implemented.
|
*/
|
bool evalMode() const;
|
|
/** \note
|
Currently not implemented.
|
*/
|
bool getParamsOfC1Discontinuity(
|
OdGeDoubleArray& params,
|
const OdGeTol& tol = OdGeContext::gTol) const;
|
|
/** \note
|
Currently not implemented.
|
*/
|
bool getParamsOfG1Discontinuity(
|
OdGeDoubleArray& params,
|
const OdGeTol& tol = OdGeContext::gTol) const;
|
|
/** \details
|
Sets the fit point at the specified index.
|
|
\param fitPointIndex [in] Fit point index.
|
\param point [in] Fit point.
|
*/
|
bool setFitPointAt(
|
int index,
|
const OdGePoint2d& point);
|
|
/** \details
|
Returns true if and only if this spline was created with
|
fit data, and inserts the fit point at the specified index.
|
|
\param fitPointIndex [in] Fit point index.
|
\param point [in] Fit point.
|
*/
|
bool addFitPointAt(
|
int index,
|
const OdGePoint2d& point);
|
|
/** \details
|
Removes a fit point with the specified index. The index must be greater than or equal to 0 and less than or equal to the number of fit points.
|
|
\param index [in] The index of fit point that is to be removed.
|
|
\note
|
Returns true if the fit point is successfully deleted and false otherwise.
|
*/
|
bool deleteFitPointAt(
|
int index);
|
|
/** \details
|
Sets the fit tolerance that is used for interpolating fit points.
|
|
\param fitTol [in] Geometric tolerance.
|
|
\note
|
Returns true if the tolerance value is successfully set. false is returned if the spline doesn't contain fit data.
|
*/
|
bool setFitTolerance(
|
const OdGeTol& fitTol = OdGeContext::gTol);
|
|
/** \details
|
Sets the fit tangents for this spline.
|
|
\param startTangent [in] Starting tangent.
|
\param endTangent [in] Ending tangent.
|
|
\note
|
Returns true if and only if this spline was constructed with fit data.
|
*/
|
bool setFitTangents(
|
const OdGeVector2d& startTangent,
|
const OdGeVector2d& endTangent);
|
|
/** \details
|
Sets the specified knot parameterization if the spline is created by fit points and returns true if the knot parameterization is successfully set.
|
|
\param knotParam [in] The knot parameterization to be set.
|
|
\note
|
Currently not implemented.
|
*/
|
bool setFitKnotParameterization(OdGeKnotParameterization knotParam);
|
|
/** \details
|
Sets the fit data for this spline.
|
|
\param fitPoints [in] Interpolation points.
|
\param fitTol [in] Geometric tolerance.
|
\param startTangent [in] Starting tangent.
|
\param endTangent [in] Ending tangent.
|
*/
|
OdGeNurbCurve2d& setFitData(
|
const OdGePoint2dArray& fitPoints,
|
const OdGeVector2d& startTangent,
|
const OdGeVector2d& endTangent,
|
const OdGeTol& fitTol = OdGeContext::gTol);
|
OdGeNurbCurve2d& setFitData(
|
const OdGeKnotVector& fitKnots,
|
const OdGePoint2dArray& fitPoints,
|
const OdGeVector2d& startTangent,
|
const OdGeVector2d& endTangent,
|
const OdGeTol& fitTol = OdGeContext::gTol,
|
bool isPeriodic = false);
|
OdGeNurbCurve2d& setFitData(
|
int degree,
|
const OdGePoint2dArray& fitPoints,
|
const OdGeTol& fitTol = OdGeContext::gTol);
|
|
OdGeNurbCurve2d& setFitData(
|
const OdGePoint2dArray& fitPoints,
|
const OdGeVector2d& startTangent,
|
const OdGeVector2d& endTangent,
|
OdGeKnotParameterization knotParam,
|
const OdGeTol& fitTol = OdGeContext::gTol);
|
|
|
|
/** \details
|
Deletes all the fit data used to construct this spline.
|
Returns true if and only if the spline was constructed with fit data.
|
|
\remarks
|
The definition of the spline is unchanged.
|
*/
|
bool purgeFitData();
|
|
/** \details
|
Adds new knot to the spline knot array and returns reference to this spline object.
|
|
\param newKnot [in] New knot.
|
*/
|
OdGeNurbCurve2d& addKnot(
|
double newKnot);
|
|
/** \details
|
Inserts new knot to the spline knot array and returns reference to this spline object. If there is already such knot, then the multiplicity of the knot is increased by 1.
|
|
\param newKnot [in] New knot.
|
*/
|
OdGeNurbCurve2d& insertKnot(
|
double newKnot);
|
|
/** \details
|
Sets the weight at the specified control point.
|
|
\param controlPointIndex [in] Control point index.
|
\param weight [in] The weight to be assigned to that control point.
|
*/
|
OdGeSplineEnt2d& setWeightAt(
|
int controlPointIndex,
|
double weight);
|
|
/** \details
|
Sets the evaluation mode.
|
|
\note
|
Currently not implemented.
|
*/
|
OdGeNurbCurve2d& setEvalMode(
|
bool evalMode = false);
|
|
/** \details
|
Joins the specified spline with this spline and returns a reference to the recomputed spline.
|
Both splines must be open and the start point of the input spline must be equal to the endpoint of the initial spline.
|
|
\param curve [in] Spline to be joined with this spline.
|
*/
|
OdGeNurbCurve2d& joinWith(
|
const OdGeNurbCurve2d& curve);
|
|
/** \details
|
Trims the spline by the new start and end parameters, and returns a reference to the recalculated spline.
|
|
\param newStartParam [in] New start parameter.
|
\param newEndParam [in] New end parameter.
|
*/
|
OdGeNurbCurve2d& hardTrimByParams(
|
double newStartParam,
|
double newEndParam);
|
|
/** \details
|
Makes this spline rational.
|
|
\param weight [in] The weight to be assigned to each control point.
|
|
\remarks
|
When called for a non-rational spline, this spline is made rational, and the specified weight is assigned to each control point.
|
|
When called for a rational spline, the weight at each control point is multiplied by the specified weight.
|
*/
|
OdGeNurbCurve2d& makeRational(
|
double weight = 1.0);
|
|
/** \details
|
Makes the opened spline closed, and returns a reference to this spline. Closed spline is made by creating a smooth spline between the first and the end points and joining it with the initial spline.
|
|
\remarks
|
If this spline is already closed, then the method does nothing.
|
*/
|
OdGeNurbCurve2d& makeClosed();
|
|
/** \details
|
Makes non-periodic spline periodic.
|
|
\note
|
Currently not implemented.
|
*/
|
OdGeNurbCurve2d& makePeriodic();
|
|
/** \details
|
Makes periodic spline non-periodic.
|
|
\note
|
Currently not implemented.
|
*/
|
OdGeNurbCurve2d& makeNonPeriodic();
|
|
/** \details
|
Makes closed spline open.
|
|
\note
|
Currently not implemented.
|
*/
|
OdGeNurbCurve2d& makeOpen();
|
|
/** \details
|
Increases spline degree by the specified value and returns a reference to this spline object.
|
|
\param plusDegree [in] Degree increment value.
|
|
*/
|
OdGeNurbCurve2d& elevateDegree(
|
int plusDegree);
|
|
OdGeNurbCurve2d& operator =(
|
const OdGeNurbCurve2d& spline);
|
|
/** \details
|
Adds a control point at the specified knot.
|
|
\param newKnot [in] The knot parameter to add the control point at.
|
\param point [in] Coordinates of the control point to be added.
|
\param weight [in] The weight to be assigned to the control point.
|
|
\remarks
|
When called for a non-rational spline, weight is ignored.
|
|
\remarks
|
Currently not implemented.
|
*/
|
bool addControlPointAt(double newKnot, const OdGePoint2d& point, double weight = 1.0);
|
|
/** \details
|
Deletes a control point at the specified index.
|
|
\param index [in] The index of the control point to be deleted.
|
|
\remarks
|
Currently not implemented.
|
*/
|
bool deleteControlPointAt(int index);
|
|
|
//////////////////////////////////////////////////////////////////////////
|
// Overrides :
|
|
//////////////////////////////////////////////////////////////////////////
|
// TD Special :
|
|
/** \details
|
Returns true if and only if this spline intersects with the specified linear entity.
|
|
\remarks
|
Returns the intersection points well as the parameters of this spline said points.
|
|
\param line [in] Any 2D linear entity.
|
\param pnts2D [out] Receives an array of 2D points.
|
\param tol [in] Geometric tolerance.
|
\param params [out] Receives an array of parameters.
|
*/
|
bool intersectWith(
|
const OdGeLine2d &line2d,
|
OdGePoint2dArray &pnts2d,
|
const OdGeTol& tol = OdGeContext::gTol,
|
OdGeDoubleArray *params = NULL) const;
|
|
/** \details
|
Sets the parameters for this spline according to the arguments,
|
and returns a reference to this spline.
|
|
\param degree [in] Degree of spline.
|
\param knots [in] Knot vector.
|
\param controlPoints [in] Array of 2D control points.
|
\param weights [in] Array of weights
|
\param isPeriodic [in] True if and only if the spline is to be periodic (closed).
|
|
\remarks
|
* If weights is not specified, a non-rational spline is constructed.
|
* If weights is specified, then a rational spline is constructed, and controlPoints.length() must equal weights.length()
|
* If isPeriodic is false, then knots.length() must equal controlPoints.length() + degree + 1
|
* If isPeriodic is true, then knots.length() must equal controlPoints.length(), the first and last controlPoints must
|
be equal, and the first and last weights (if provided) must be equal.
|
*/
|
void set(
|
int degree,
|
const OdGeKnotVector& knots,
|
const OdGePoint2dArray& controlPoints,
|
const OdGeDoubleArray& weights,
|
bool isPeriodic = false);
|
|
protected:
|
friend class OdDbGeEdgesDwgIO;
|
friend class OdDbGeEdgesDxfIO;
|
|
void set(int degree, const OdGeKnotVector& knots,
|
const OdGePoint2dArray& cntrlPnts, const OdGeDoubleArray& weights, bool isPeriodic,
|
const OdGePoint2dArray& fitPoints,
|
const OdGeVector2d& startTangent,
|
const OdGeVector2d& endTangent);
|
};
|
|
#include "TD_PackPop.h"
|
|
#endif
|
