C3D Toolkit  Kernel - 117982, Vision - 2.9.2.2
Construction of Curves
Collaboration diagram for Construction of Curves:

Functions

MbCurveSetProportionalParametrization (MbCurve *curve, double tMin, double tMax)
Set curve parametrization proportional to the curve length. More...

MbResultType Line (const MbCartPoint3D &point1, const MbCartPoint3D &point2, MbCurve3D *&result)
Create a line. More...

MbResultType Segment (const MbCartPoint3D &point1, const MbCartPoint3D &point2, MbCurve3D *&result)
Create a line segment. More...

MbResultType Arc (const MbCartPoint3D &centre, const SArray< MbCartPoint3D > &points, bool curveClosed, double angle, double &a, double &b, MbCurve3D *&result)
Create an ellipse (circle) or an elliptical (circular) arc. More...

MbResultType SplineCurve (const SArray< MbCartPoint3D > &pointList, bool curveClosed, MbeSpaceType curveType, MbCurve3D *&result)
Create a curve passing through a set of points. More...

MbResultType NurbsCurve (const SArray< MbCartPoint3D > &pointList, const SArray< double > &weightList, size_t degree, const SArray< double > &knotList, bool curveClosed, MbCurve3D *&result)
Create a NURBS-curve. More...

double NurbsFitting (const std::vector< MbCartPoint3D > &pointList, bool curveClosed, size_t degree, size_t mode, double &accuracy, MbCurve3D *&result)
Create a Nurbs curve with sorting points by distance passing through a set of points. More...

MbResultType NurbsCopy (const MbCurve3D &curve, MbCurve3D *&result)
Create a copy of a curve as a NURBS-curve. More...

MbResultType NurbsCopy (const MbCurve3D &curve, const MbNurbsParameters &params, MbNurbsCopyCurveResult &result)
Create a NURBS curve copy by given parameters. More...

MbResultType RegularPolygon (const MbCartPoint3D &centre, const MbCartPoint3D &point, const MbVector3D &axisZ, size_t vertexCount, bool describe, MbCurve3D *&result)
Create a regular polygon inscribed in a circle. More...

MbResultType SpiralCurve (const MbPlacement3D &place, double radius, double step, MbCurve &lawCurve, bool spiralAxis, MbCurve3D *&result)
Create a spiral. More...

MbResultType SpiralCurve (const MbCartPoint3D &point0, const MbCartPoint3D &point1, const MbCartPoint3D &point2, double radius, double step, double angle, MbCurve *lawCurve, bool spiralAxis, MbCurve3D *&result)
Create a spiral. More...

MbResultType CreateContour (MbCurve3D &curve, MbContour3D *&result)
Create a composite curve (contour). More...

MbCurve3DDuplicateCurve (const MbCurve3D &curve, VERSION version=Math::DefaultMathVersion())
Create a copy of a curve. More...

MbResultType AddCurveToContour (MbCurve3D &curve, MbCurve3D &contour, bool toEnd)
Add a curve to a composite curve (a contour). More...

MbResultType PlaneCurve (const MbPlacement3D &place, const MbCurve &curve, MbCurve3D *&result)
Create a space curve from a two-dimensional curve. More...

MbResultType SurfaceCurve (const MbSurface &surface, const MbCurve &curve, MbCurve3D *&result)
Create a curve on a surface given a two-dimensional curve. More...

MbResultType CurveOnSurface (const MbCurve3D &curve, const MbSurface &surf, bool sameSurf, bool extSurf, MbCurve3D *&result, bool strictOnSurface=false)
Create a curve on a surface from a space curve lying on the surface. More...

bool IsCurveOnSurface (const MbCurve3D &curve, const MbSurface &surf, bool ext, bool strictOnSurface, VERSION version=Math::DefaultMathVersion())
Determine whether the curve lies on the surface. More...

MbResultType CreateContours (RPArray< MbCurve3D > &curves, double metricEps, RPArray< MbContour3D > &result, bool onlySmoothConnected=false, VERSION version=Math::DefaultMathVersion())
Create an array of contours given an array of curves. More...

MbResultType CreateContours (RPArray< MbCurve3D > &curves, double metricAcc, bool onlySmoothConnected=false, VERSION version=Math::DefaultMathVersion())
Create contours given a set of curves with elimination of degenerate ones. More...

MbResultType WireFrame (const MbCurve3D &curve, const MbName &curveName, SimpleName mainName, MbWireFrame *&result)
Create a named three-dimensional wireframe. More...

MbResultType WireFrame (const RPArray< MbCurve3D > &curves, const RPArray< MbName > &curveNames, SimpleName mainName, MbWireFrame *&result)
Create a named three-dimensional wireframe. More...

Approximate a contour with arcs and line segments. More...

bool GetSpaceCurve (MbItem &item, bool keepPlacement, c3d::SpaceCurveSPtr &curve0, c3d::SpaceCurvesSPtrVector *curves=nullptr)
Get or create a space curve. More...

MbCurve3DUnwrapCurve (const MbCurve3D &curve, const MbPlacement3D &placement, const MbCartPoint3D &point, double deviationAngle=DEVIATION_SAG)
Construct a unwrapping curve/contour. More...

MbResultType EvolutionSection (const MbSweptData &generCurves, const MbCurve3D &guideCurve, double guideParam, const EvolutionValues &params, MbSweptData &result, VERSION version=Math::DefaultMathVersion(), double angleEpsilon=ANGLE_EPSILON)
Create a section of evolution solid for defined parameter on the guide curve. More...

bool IsLikeStraightLine (const MbCurve3D &curve, double eps)
Whether the curve is like straight-line regardless of its parameterisation. More...

MbResultType CreateFairBSplineCurveOnBasePolyline (MbCurve3D *polyline, MbFairCurveData &data, MbCurve3D *&result)
Create a fair B-spline on base polyline. More...

MbResultType CreateFairBSplineCurveOnTangentPolyline (MbCurve3D *polyline, MbFairCurveData &data, MbCurve3D *&result)
Create a fair B-spline on tangent polyline. More...

MbResultType CreateFairBezierCurveOnBasePolyline (MbCurve3D *polyline, MbFairCurveData &data, MbCurve3D *&result)
Create a fair Bezier curve on base polyline. More...

MbResultType CreateFairBezierFilletOnPolyline (MbCurve3D *pllne, MbFairCurveData &data, MbCurve3D *&resCurve)
Create a fillet fair Bezier curve on base polyline. More...

MbResultType CreateFairBezierCurveOnTangentPolyline (MbCurve3D *polyline, MbFairCurveData &data, MbCurve3D *&result)
Create a fair Bezier curve on tangent polyline. More...

MbResultType KernelCreateHermiteGDOnBezierCurve (const MbNurbs3D *curve, MbeFairCurveType type, MbFairCurveData &data, MbCurve3D *&polyline)
Create Hermite GD on a Bezier curve. More...

MbResultType CreateBezierCurveOnHermiteGD (MbCurve3D *polyline, MbFairCurveData &data, MbCurve3D *&result)
Create a Bezier on Hermite GD. More...

MbResultType CreateBSplineCurveOnHermiteGD (MbCurve3D *polyline, MbFairCurveData &data, MbCurve3D *&result)
Create a B-spline on Hermite GD. More...

MbResultType CreateFairBezierCurveOnBasePolylineOfHermiteGD (MbCurve3D *polyline, MbFairCurveData &data, MbCurve3D *&result)
Create a fair Bezier curve on base polyline of Hermite GD. More...

MbResultType CreateFairBezierCurveOnTangentsOfHermiteGD (MbCurve3D *polyline, MbFairCurveData &data, MbCurve3D *&result)
Create a fair Bezier curve on tangent lines of Hermite GD. More...

MbResultType CreateFairBSplineCurveOnBasePolylineOfHermiteGD (MbCurve3D *polyline, MbFairCurveData &data, MbCurve3D *&result)
Create a fair B-spline curve on base polyline of Hermite GD. More...

MbResultType CreateFairBSplineCurveOnBasePolylineOfHermiteGDInflex (const MbCurve3D *pllne, MbFairCurveData &data, MbCurve3D *&resCurve)
Create a fair B-spline curve on base polyline of Hermite GD. More...

MbResultType CreateFairBSplineCurveOnNoisyData (MbCurve3D *pllne, int inType, MbFairCurveData &data, MbCurve3D *&resCurve)
Create a fair B-spline curve with smoothing and reparametrization on noisy data. More...

MbResultType CreateFairBSplineCurveOnTangentsOfHermiteGD (MbCurve3D *polyline, MbFairCurveData &data, MbCurve3D *&result)
Create a fair B-spline curve on tangent lines of Hermite GD. More...

MbResultType KernelCreateClothoid (MbFairCurveData &data, MbCurve3D *&result)
Create a clothoid. More...

MbResultType KernelCreateSectrix (MbCurve3D *polyline, MbFairCurveData &data, MbCurve3D *&result)
Create a sectrix. More...

MbResultType ElevateDegreeNurbzs (MbNurbs3D *curve, MbFairCurveData &data, MbCurve3D *&result)
Elevate the degree of the NURBzS curve. More...

MbResultType ReparamNurbs (MbNurbs3D *curve, MbFairCurveData &data, MbCurve3D *&resCurve)
Reparametrize the NURBS curve. More...

MbResultType SubdivideNurbs (MbNurbs3D *curve, MbFairCurveData &data, MbCurve3D *&result)
Subdivide the NURBS curve. More...

MbResultType ExtractChangeNurbs (MbNurbs3D *curve, MbFairCurveData &data, MbCurve3D *&result)
To extract part of NURBS curve / change the format of the NURBS curve. More...

MbResultType ExtractChangeNurbsParams (MbNurbs3D *curve, MbFairCurveData &data, SArray< double > &resWts, SArray< double > &resKnots, MbCurve3D *&resCurve)
To extract part of NURBS curve / change the format of the NURBS curve. Return parameters of created curve. More...

MbResultType AddKnotNurbs (MbNurbs3D *curve, MbFairCurveData &data, MbCurve3D *&result)
Insert node in NURBS. More...

MbResultType ExtractExtrapolFromSegment (MbNurbs3D *curve, MbFairCurveData &data, MbCurve3D *&resCurve)
Insert a knot into the onesegmented NURBS curve. More...

MbResultType ConicNurbs (MbNurbs3D *curve, MbFairCurveData &data, MbCurve3D *&result)
Convert a conical NURBzS into a conical NURBS. More...

MbResultType Cabling (const MbCartPoint3D &begPoint, const MbVector3D &begDirection, const MbCartPoint3D &endPoint, const MbVector3D &endDirection, double length, double accuracy, double &maxCurvature, MbCurve3D *&result)
Connecting the specified points by a curve of a specified length. More...

MbCurve3DSetProportionalParametrization (MbCurve3D *curve, double tMin, double tMax)
Set curve parametrization proportional to the curve length. More...

MbResultType ExtendCurve (const MbCurve3D &sourceCurve, const MbCurveExtensionParameters3D &parameters, SPtr< MbWireFrame > &resFrame)
Extend the given curve. More...

MbResultType CreateContourChamfer (const MbContourChamferParams &paramList, MbCurve3D *&resultChamferContour)
Create chamfers on the contour joints. More...

MbResultType UnwrapCurve (const MbCurvesWrappingParams &parameters, MbCurvesWrappingResults &result)
Construct unwrapped curves and points. More...

MbResultType WrapCurve (const MbCurvesWrappingParams &parameters, MbCurvesWrappingResults &result)
Perform the operation of wrapping curves and points on a surface. More...

bool CheckJoinedParams (const MbCurve3D &curve, SArray< double > &params, bool isAscending)
Check the curve parameters for creation of a joint solid. More...

MbCurve3DCreateJoinedCurve (const RPArray< MbCurveEdge > &edges, const SArray< bool > &orients, const MbMatrix3D &matr, MbResultType &res)
Create a curve from a set of edges. More...

MbCurve3DTrimClosedSpine (const MbCurve3D &curve, double t)
Create a trimmed closed curve on a curve copy. More...

MbResultType CalculatePipePoints (const MbCartPoint3D &origin1, const MbVector3D &direction1, double length1, double radius1, const MbCartPoint3D &origin2, const MbVector3D &direction2, double length2, double radius2, MbCartPoint3D &result1, MbCartPoint3D &result2)
Compute the vertices of a polyline. More...

MbResultType OffsetPlaneCurve (const MbCurve3D &curve, double dist, MbCurve3D *&result)
Create an offset curve. More...

MbResultType OffsetCurve (const MbCurve3D &initCurve, const MbSpatialOffsetCurveParams &params, c3d::WireFrameSPtr &result)
Create an offset curve in space. More...

MbResultType OffsetCurve (const MbCurve3D &curve, const MbSurfaceOffsetCurveParams &params, c3d::WireFrameSPtr &result)
Create an offset curve on a surface. More...

MbResultType CurveProjection (const MbSurface &surface, const MbCurve3D &curve, MbVector3D *direction, bool createExact, bool truncateByBounds, RPArray< MbCurve3D > &result, VERSION version=Math::DefaultMathVersion())
Create a curve projection onto the surface. More...

MbResultType CurveProjection (const MbSurface &surface, const MbCurve3D &curve, MbVector3D *direction, bool createExact, bool truncateByBounds, c3d::SpaceCurvesSPtrVector &result, VERSION version=Math::DefaultMathVersion())
Create a curve projection onto the surface. More...

MbResultType CurveByTwoProjections (const MbPlacement3D &place1, const MbCurve &curve1, const MbPlacement3D &place2, const MbCurve &curve2, RPArray< MbCurve3D > &result, VERSION version=Math::DefaultMathVersion())
Create a space curve from two planar projections. More...

MbResultType ProjectionCurve (const MbCurve3D &curve, const RPArray< MbFace > &faces, const MbVector3D *dir, const bool createExact, const bool truncateByBounds, const MbSNameMaker &snMaker, RPArray< MbCurve3D > &result, SArray< uintptr_t > *resultIndices)
Create a projection curve from a normal or from a direction. More...

MbResultType ProjectionCurve (const MbWireFrame &wireFrame, const bool sameWireFrame, const MbSolid &solid, const bool same, const SArray< size_t > &faceIndices, const MbVector3D *dir, const bool createExact, const bool truncateByBounds, const MbSNameMaker &snMaker, MbWireFrame *&resFrame)
Create a projection wireframe from a normal or from a direction. More...

bool EliminateProjectionCurveOverlay (RPArray< MbCurve3D > &curves, SArray< uintptr_t > *indices)
Eliminate the projection curve segments overlay. More...

MbResultType IntersectionCurve (const MbSurface &surface1, const MbSurface &surface2, const MbIntCurveParams &params, MbWireFrame *&result)
Create the intersection curves of two surfaces. More...

MbResultType IntersectionCurve (MbFace &face1, MbFace &face2, const MbIntCurveParams &params, MbWireFrame *&result)
Create intersection curves of two faces. More...

MbResultType IntersectionCurve (MbFace &face1, MbFace &face2, const MbIntCurveParams &params, MbIntCurveResults &results)
Create intersection curves of two faces. More...

MbResultType IntersectionCurve (const MbSolid &solid1, const c3d::IndicesVector &faceIndices1, const MbSolid &solid2, const c3d::IndicesVector &faceIndices2, const MbIntCurveParams &params, MbWireFrame *&result)
Create intersection curves of two shells faces. More...

MbResultType IntersectionCurve (const MbSolid &solid1, const c3d::IndicesVector &faceIndices1, bool same1, const MbSolid &solid2, const c3d::IndicesVector &faceIndices2, bool same2, const MbIntCurveParams &params, MbWireFrame *&result)
Create intersection curves of two shells faces. More...

MbResultType IntersectionCurve (const MbSolid &solid1, const MbSolid &solid2, const MbIntCurveShellParams &params, MbIntCurveResults &results)
Create intersection curves of two shells faces. More...

MbResultType IntersectionCurve (const MbSurface &surface1, const MbSurface &surface2, const MbIntCurveParams &params, MbIntCurveResults &results)
Create an intersection curve of surfaces. More...

MbResultType IntersectionCurve (const MbSurface &surface1, bool ext1, const MbCartPoint &uv1beg, const MbCartPoint &uv1end, const MbSurface &surface2, bool ext2, const MbCartPoint &uv2beg, const MbCartPoint &uv2end, const MbVector3D &dir, MbCurve *&result1, MbCurve *&result2, MbeCurveBuildType &label)
Create an intersection curve of surfaces. More...

MbResultType IntersectionCurve (const MbSurface &surf1, bool ext1, const MbCartPoint &uv1beg, const MbCartPoint &uv1end, const MbSurface &surf2, bool ext2, const MbCartPoint &uv2beg, const MbCartPoint &uv2end, const MbCurve3D *guideCurve, bool useRedetermination, bool checkPoles, MbCurve *&pCurve1, MbCurve *&pCurve2, MbeCurveBuildType &label)
Create an intersection curve of surfaces. More...

MbResultType SpaceSplineThrough (const SArray< MbCartPoint3D > &points, MbeSplineParamType paramType, size_t degree, bool closed, RPArray< c3d::PntMatingData3D > &transitions, const MbSNameMaker &snMaker, MbWireFrame *&result)
Create a spatial spline through points and with the given derivatives. More...

MbResultType SpaceSplineBy (const SArray< MbCartPoint3D > &points, size_t degree, bool closed, const SArray< double > *weights, const SArray< double > *knots, c3d::PntMatingData3D *begData, c3d::PntMatingData3D *endData, const MbSNameMaker &snMaker, MbWireFrame *&result)
Create a spatial spline from points and derivatives. More...

MbResultType SurfaceSpline (const MbSurface &surface, bool throughPoints, SArray< MbCartPoint > &paramPnts, SArray< double > &paramWts, bool paramClosed, RPArray< c3d::PntMatingData3D > &spaceTransitions, const MbSNameMaker &snMaker, MbWireFrame *&result)
Create a curve on a surface. More...

MbResultType IsoparametricCurve (const MbSurface &surface, double x, bool isU, const MbRect1D *yRange, MbCurve3D *&result)
Create an isoparametric curve. More...

MbResultType BridgeCurve (const MbCurve3D &curve1, double t1, bool sense1, const MbCurve3D &curve2, double t2, bool sense2, const MbSNameMaker &names, MbWireFrame *&result)
Create a transition curve connecting curves 'curve1' and 'curve2'. More...

MbResultType ConnectingCurve (const MbCurve3D &curve1, bool isBegin1, double radius1, const MbCurve3D &curve2, bool isBegin2, double radius2, const MbSNameMaker &names, MbWireFrame *&result)
Create a composite curve smoothly connecting two curves ends. More...

MbResultType ConnectingSpline (const MbCurve3D &curve1, double t1, MbeMatingType mating1, const MbCurve3D &curve2, double t2, MbeMatingType mating2, double tension1, double tension2, const MbSNameMaker &names, MbWireFrame *&result)
Create a connecting NURBS curve for curves 'curve1' and 'curve2'. More...

MbResultType FilletCurve (const MbCurve3D &curve1, double &t1, double &w1, const MbCurve3D &curve2, double &t2, double &w2, double &radius, bool sense, bool &unchanged, const MbeConnectingType type, const MbSNameMaker &names, MbElementarySurface *&surface, MbWireFrame *&result)
Create a fillet curve for curves. More...

MbResultType CreateContourFillets (const MbContour3D &contour, SArray< double > &radiuses, MbCurve3D *&result, const MbeConnectingType type)
Create a curve for fillet of all the curves of a contour. More...

MbResultType CurvesWrapping (const MbCurvesWrappingParams &parameters, c3d::PlaneCurvesSPtrVector &surfaceCurves)
Construct curves that wrap the surface. More...

MbResultType CurvesWrapping (const MbCurvesWrappingParams &parameters, c3d::SpaceCurvesSPtrVector &resultCurves)
Construct curves that wrap the surface. More...

MbResultType CurvesUnwrapping (const MbCurvesWrappingParams &params, c3d::PlaneCurvesSPtrVector &surfaceCurves)
Construct a unwrapping curve/contour. More...

MbResultType CurvesUnwrapping (const MbCurvesWrappingParams &parameters, c3d::SpaceCurvesSPtrVector &resultCurves)
Construct a unwrapping curve/contour. More...

MbCurve3DMakeCurveOnSurface (const MbFace &face, const std::vector< const MbCurveEdge * > &edges, double accuracy)
Construct a curve or contour on the surface of a face along the specified edges. More...

MbResultType FairCurve (const MbFairCurveParams &initParams, const MbFairCurveMethod &method, const MbFairCreateData &curveData, MbFairCurveResult &result)
Construct a fair curve of the specified type according to the specified parameters. More...

MbResultType FairCurve (const MbFairCurveParams &initParams, const MbFairFilletData &curveData, MbFairCurveResult &result)
Construct a fair fillet curve. More...

MbResultType FairCurve (const MbFairCurveParams &initParams, const MbFairCurveMethod &method, const MbFairChangeData &changeData, c3d::WireFrameSPtr &result)
Change a fair curve. More...

MbResultType FairCurve (const MbClothoidParams &parameters, const MbSNameMaker &snMaker, c3d::WireFrameSPtr &result)
Creating a clothoid. More...

MbCurve3DNurbsConic_1 (const MbCartPoint3D &mbPoint0, const MbCartPoint3D &mbPoint1, const MbCartPoint3D &mbPoint2, double fDiscr)
Construct a conic section by two points, an angle vertex and a discriminant. More...

MbCurve3DNurbsConic_2 (std::vector< MbCartPoint3D > &vmbConicPoints, const MbCartPoint3D &mbVertex)
Construct a conic section by three points, and an angle vertex. More...

MbCurve3DNurbsConic_3 (const std::vector< MbCartPoint3D > &vmbConicPoints, MbVector3D &mbTangent1, MbVector3D &mbTangent2)
Construct a conic section by three points and two inclinations. More...

MbCurve3DNurbsConic_4 (const MbCartPoint3D &mbPoint1, const MbCartPoint3D &mbPoint2, const MbVector3D &mbTangent1, const MbVector3D &mbTangent2, double fDiscr)
Construct a conic section by two points, two inclinations and a discriminant. More...

MbCurve3DNurbsConic_5 (const std::vector< MbCartPoint3D > &vmbConicPoints, MbVector3D &mbTangent1, size_t tanPntNb=1)
Construct a conic section by four points, and an inclination. More...

MbCurve3DNurbsConic_6 (const std::vector< MbCartPoint3D > &vmbConicPoints)
Construct a conic section by five points. More...

bool InitContour3D (MbContour3D &contour, bool closed, SArray< Polyline3DPoint > &initList, SArray< ptrdiff_t > &errorIndexes, double lengthEpsilon=Math::lengthEpsilon)
Construct a contour from segments by given points. More...

c3d::CreatorSPtr CreateBeamCurves (const MbSolid &sourceSolid, const MbBeamElementParams &parameters, MbResultType &res, MbBeamElementResults &result)
Create a constructor of beam curve. More...

MbCreatorCreateFilletEdge (const MbCurve3D &curve1, double &t1, const MbCurve3D &curve2, double &t2, double &radius, bool sense, MbeConnectingType type, const MbSNameMaker &names, MbResultType &res, bool &unchanged, MbElementarySurface *&surface, MbEdge *&edge)
Create two curves fillet constructor. More...

MbCreatorCreateSplineEdge (const MbCurve3D &curve1, double t1, MbeMatingType mating1, const MbCurve3D &curve2, double t2, MbeMatingType mating2, double tension1, double tension2, const MbSNameMaker &names, MbResultType &res, MbEdge *&edge)
Create constructor of two curves connection by a spline. More...

MbCreatorCreateConnectingEdge (const MbCurve3D &curve1, bool isBegin1, double radius1, const MbCurve3D &curve2, bool isBegin2, double radius2, const MbSNameMaker &names, MbResultType &res, MbEdge *&edge)
Create a constructor of conjugation of two curves end points by a composite curve of smooth connection. More...

MbCreatorCreateBridgeEdge (const MbCurve3D &curve1, double t1, bool sense1, const MbCurve3D &curve2, double t2, bool sense2, const MbSNameMaker &names, MbResultType &res, MbEdge *&edge)
Create a constructor of two curves conjugation by a cubic Hermite spline (transition curve). More...

c3d::CreatorSPtr CreateExtendedCurve (const MbCurve3D &sourceCurve, const MbCurveExtensionParameters3D &parameters, MbResultType &res, c3d::SpaceCurveSPtr &resCurve)
Create a constructor of extending curve. More...

c3d::CreatorSPtr CreateFairCurve (const MbCurve3D &sourceCurve, const MbFairCurveMethod &method, const MbFairCreateData &parameters, const MbSNameMaker &snMaker, MbFairCreatorResult &result)
Create a fair curve. More...

c3d::CreatorSPtr CreateFairCurve (const MbCurve3D &sourceCurve, const MbFairCurveMethod &method, const MbFairChangeData &parameters, const MbSNameMaker &snMaker, MbFairCreatorResult &result)
Changing a fair curve. More...

c3d::CreatorSPtr CreateFairCurve (const MbCurve3D &sourceCurve, const MbFairFilletData &parameters, const MbSNameMaker &snMaker, MbFairCreatorResult &result)
Creating a fair fillet curve. More...

c3d::CreatorSPtr CreateFairCurve (const MbClothoidParams &parameters, const MbSNameMaker &snMaker, MbFairCreatorResult &result)
Creating a clothoid. More...

MbCreatorCreateFillet (MbFaceShell *solid, MbeCopyMode sameShell, const MbShellFilletValues &filletParams, MbResultType &res, c3d::ShellSPtr &shell, IProgressIndicator *progInd=nullptr)
Create a shell with edges fillet. More...

MbCreatorCreateSplineThrough (const SArray< MbCartPoint3D > &points, MbeSplineParamType paramType, size_t degree, bool closed, RPArray< c3d::PntMatingData3D > &transitions, const MbSNameMaker &snMaker, MbResultType &resType, MbCurve3D *&resCurve)
Create a spatial spline through points and with the given tangents. More...

MbCreatorCreateSplineBy (const SArray< MbCartPoint3D > &points, size_t degree, bool closed, const SArray< double > *weights, const SArray< double > *knots, c3d::PntMatingData3D *begData, c3d::PntMatingData3D *endData, const MbSNameMaker &snMaker, MbResultType &resType, MbCurve3D *&resCurve)
Create a spatial spline from points and tangents. More...

MbCreatorCreateOffsetCurve (const MbCurve3D &initCurve, const MbSpatialOffsetCurveParams &params, MbResultType &resType, MbCurve3D *&resCurve)
Create an offset curve from three-dimensional curve and direction. More...

MbCreatorCreateOffsetCurve (const MbCurve3D &curve, const MbSurfaceOffsetCurveParams &params, MbResultType &resType, RPArray< MbCurve3D > &resCurves)
Create an offset curve from a spatial curve and offset value. More...

MbCreatorCreateSurfaceSpline (const MbSurface &surface, bool throughPoints, SArray< MbCartPoint > &paramPnts, SArray< double > &paramWts, bool paramClosed, RPArray< c3d::PntMatingData3D > &spaceTransitions, const MbSNameMaker &snMaker, MbResultType &resType, RPArray< MbCurve3D > &resCurves)
Create a curve on a surface. More...

c3d::CreatorSPtr CreateUnwrappedCurve (const MbCurvesWrappingParams &parameters, MbResultType &res, c3d::WireFrameSPtr &resWire)
Create a constructor of unwrapped curve. More...

c3d::CreatorSPtr CreateWrappedCurve (const MbCurvesWrappingParams &parameters, MbResultType &res, c3d::WireFrameSPtr &resWire)
Create a constructor of wrapped curve. More...

MbCurve3DMakeCurve3D (const MbCurve &curve, const MbPlacement3D &)
Create a spatial curve. More...

MbResultType ApproximatePolylineByNurbs (const MbApproxNurbsParameters< MbCartPoint3D, MbVector3D, MbNurbs3D > &param, MbApproxNurbsCurveResult< MbNurbs3D > &result)
Approximate 3D points by NURBS curve. More...

template<class CurvesVector >
void ExtractCurves (c3d::WireFrameSPtr &wireFrame, CurvesVector &curves)
Extract curves. More...

template<class CurvesVector >
void ExtractCurvesDeleteFrame (MbWireFrame *&wireFrame, CurvesVector &curves)
Take curves and delete a frame if it is not used. More...

void ExtractCurveDeleteFrame (MbWireFrame *&wireFrame, MbCurve3D *&curve)
Take the first curve and delete a frame if it is empty and not used. More...

bool CreateWireFrame (MbWireFrame *&result, const RPArray< MbCurve3D > &curves, const MbSNameMaker &snMaker, const MbCreator *creator=nullptr)
Create a frame by a set of curves. More...

bool CreateWireFrame (MbWireFrame *&result, const MbCurve3D &curve, const MbSNameMaker &snMaker, const MbCreator *creator=nullptr)
Create a frame by a curve. More...

bool CreateWireFrame (const MbCurve3D &curve, const MbSNameMaker &snMaker, c3d::WireFrameSPtr &result, const c3d::CreatorSPtr &creator=nullptr)
Create a frame by a curve. More...

bool CreateWireFrame (const c3d::SpaceCurvesSPtrVector &curves, const MbSNameMaker &snMaker, c3d::WireFrameSPtr &result, const c3d::CreatorSPtr &creator=nullptr)
Create a frame by a set of curves. More...

◆ SetProportionalParametrization() [1/2]

 MbCurve* SetProportionalParametrization ( MbCurve * curve, double tMin, double tMax )

Set curve parametrization proportional to the curve length.

If the curve parameterization is not proportional to the length of the curve, then change the curve parameterization to make it proportional to the length of the curve.
In general, the curve will be replaced by a MbReparamCurve3D curve with length proportional parameterization. In special cases, when the curve has a proportional parametrization with the required boundaries, the original curve will be returned.

Parameters
 [in] curve - The original curve to be reparametrized. [in] tMin - New minimal parameter of the curve. [in] tMax - New maximal parameter of the curve.
Returns
Returns created curve with proportional length parameterization.

◆ Line()

 MbResultType Line ( const MbCartPoint3D & point1, const MbCartPoint3D & point2, MbCurve3D *& result )

Create a line.

Create a line given two points.

Parameters
 [in] point1 - The first point. [in] point2 - The second point. [out] result - The line.
Returns
Returns operation result code.

◆ Segment()

 MbResultType Segment ( const MbCartPoint3D & point1, const MbCartPoint3D & point2, MbCurve3D *& result )

Create a line segment.

Create a line segment given two points.

Parameters
 [in] point1 - The first point. [in] point2 - The second point. [out] result - The segment.
Returns
Returns operation result code.

◆ Arc()

 MbResultType Arc ( const MbCartPoint3D & centre, const SArray< MbCartPoint3D > & points, bool curveClosed, double angle, double & a, double & b, MbCurve3D *& result )

Create an ellipse (circle) or an elliptical (circular) arc.

Create an ellipse (circle) or an elliptical (circular) arc.
The container 'points' should contain 0 or 2 elements.

Parameters
 [in] centre - The center of an ellipse (circle). [in] points - Points on the arc. [in] curveClosed - The closedness of the arc. [in] angle - The inclination angle. [in,out] a - The major axis length. [in,out] b - The minor axis length. [out] result - The ellipse (circle) or the elliptical (circular) arc.
Returns
Returns operation result code.

◆ SplineCurve()

 MbResultType SplineCurve ( const SArray< MbCartPoint3D > & pointList, bool curveClosed, MbeSpaceType curveType, MbCurve3D *& result )

Create a curve passing through a set of points.

Create a curve passing through a set of points that has the following type:
curveType == st_LineSegment3D - a line segment,
curveType == st_Arc3D - a circle or an arc,
curveType == st_Polyline3D - a polyline,
curveType == st_Bezier3D - a Bezier curve,
curveType == st_CubicSpline3D - a cubic spline,
curveType == st_Hermit3D - a cubic Hermite spline,
curveType == st_Nurbs3D - a nonuniform rational B-spline of fourth order (cubic).

Parameters
 [in] pointList - A point set. [in] curveClosed - A curve closedness. [in] curveType - A curve type. [out] result - The curve.
Returns
Returns operation result code.

◆ NurbsCurve()

 MbResultType NurbsCurve ( const SArray< MbCartPoint3D > & pointList, const SArray< double > & weightList, size_t degree, const SArray< double > & knotList, bool curveClosed, MbCurve3D *& result )

Create a NURBS-curve.

Create a NURBS-curve given a sequence of control points.
Container 'weightList' can be empty.
Container 'knotList' can be empty.

Parameters
 [in] pointList - An array of points. [in] weightList - An array of weights. [in] degree - A spline degree. [in] knotList - An array of parametric knots (A knot vector). [in] curveClosed - A curve closedness. [out] result - The spline curve.
Returns
Returns operation result code.

◆ NurbsFitting()

 double NurbsFitting ( const std::vector< MbCartPoint3D > & pointList, bool curveClosed, size_t degree, size_t mode, double & accuracy, MbCurve3D *& result )

Create a Nurbs curve with sorting points by distance passing through a set of points.

Create a Nurbs curve with sorting points by distance passing through a set of points that has the following type:

Parameters
 [in] pointList - The initial curve. [in] curveClosed - Closure of the curve. [in] degree - A curve degree (for Nurbs). [in] mode - A Curve construction option. [in/out] accuracy - Thye desired accuracy / max deviation of constructed curve. [out] result - The constructed curve.
Returns
Returns average deviation of constructed curve.

◆ NurbsCopy() [1/2]

 MbResultType NurbsCopy ( const MbCurve3D & curve, MbCurve3D *& result )

Create a copy of a curve as a NURBS-curve.

Create a copy of a curve as a NURBS-curve.

Parameters
 [in] curve - The initial curve. [out] result - The spline copy of the curve.
Returns
Returns operation result code.

◆ NurbsCopy() [2/2]

 MbResultType NurbsCopy ( const MbCurve3D & curve, const MbNurbsParameters & params, MbNurbsCopyCurveResult & result )

Create a NURBS curve copy by given parameters.

A copy is created with the specified accuracy sent from parameters. If accuracy <= LENGTH_EPSILON, a NURBS copy is created without regard to accuracy.

Parameters
 [in] curve - The initial curve. [in] params - Parameters for the construction of a NURBS copy of the object. [out] result - Output data for create NURBS copy of curve.
Returns
Returns operation result code.

◆ RegularPolygon()

 MbResultType RegularPolygon ( const MbCartPoint3D & centre, const MbCartPoint3D & point, const MbVector3D & axisZ, size_t vertexCount, bool describe, MbCurve3D *& result )

Create a regular polygon inscribed in a circle.

Create a regular polygon inscribed in a circle
(if 'describe' == true circumscribed around a circle) with the specified centre and passing through the given point:

• if vertexCount <= 1, a circle with center 'center' passing through 'point' is created,
• if vertexCount == 2, a rectangle aligned with the global axes with the opposite vertices at points 'centre' and 'point' is created.
Parameters
 [in] centre - The center. [in] point - A point. [in] axisZ - Z-axis for curve LCS creation. [in] vertexCount - Number of vertices. [in] describe - Circumscribing around the circle. [out] result - The regular polygon.
Returns
Returns operation result code.

◆ SpiralCurve() [1/2]

 MbResultType SpiralCurve ( const MbPlacement3D & place, double radius, double step, MbCurve & lawCurve, bool spiralAxis, MbCurve3D *& result )

Create a spiral.

Create a spiral.
If 'spiralAxis' == true, 'lawCurve' determines the axis of a spiral.
If spiralAxis == false, then 'lawCurve' - determines a radius law.

Parameters
 [in] place - A local coordinate system. [in] radius - A spiral radius. [in] step - A pitch. [in] lawCurve - A guide curve. [in] spiralAxis - A spiral construction mode. [out] result - The spiral curve.
Returns
Returns operation result code.

◆ SpiralCurve() [2/2]

 MbResultType SpiralCurve ( const MbCartPoint3D & point0, const MbCartPoint3D & point1, const MbCartPoint3D & point2, double radius, double step, double angle, MbCurve * lawCurve, bool spiralAxis, MbCurve3D *& result )

Create a spiral.

Create a spiral.
If 'spiralAxis' == true, 'lawCurve' determines the axis of a spiral.
If spiralAxis == false, then 'lawCurve' - determines a radius law.
If lawCurve == nullptr, a conical spiral is created with the specified taper angle.

Parameters
 [in] point0 - The origin of local coordinate system (LCS). [in] point1 - A point on Z-axis of LCS. [in] point2 - A point on the X-axis of LCS. [in] radius - A spiral radius. [in] step - A pitch. [in] angle - A taper angle. [in] lawCurve - A guide curve. [in] spiralAxis - A spiral construction mode. [out] result - The spiral curve.
Returns
Returns operation result code.

◆ CreateContour()

 MbResultType CreateContour ( MbCurve3D & curve, MbContour3D *& result )

Create a composite curve (contour).

Create a composite curve (contour) on the basis of the given curve.

Parameters
 [in] curve - The initial curve. [out] result - The contour created on the basis of the curve.
Returns
Returns operation result code.

◆ DuplicateCurve()

 MbCurve3D* DuplicateCurve ( const MbCurve3D & curve, VERSION version = `Math::DefaultMathVersion()` )

Create a copy of a curve.

Create a copy of a curve with splitting of a polyline and replacement of some curves.

Parameters
 [in] curve - The initial curve. [in] version - The version.
Returns
Returns a modified copy of the curve if it has been successfully created.

 MbResultType AddCurveToContour ( MbCurve3D & curve, MbCurve3D & contour, bool toEnd )

Add a curve to a composite curve (a contour).

Add a curve to a composite curve (a contour) 'contour'.
If toEnd == true, the curve is to be added to the end.
If toEnd == true, the curve is to be added to the beginning.

Parameters
 [in] curve - A curve to be added. [in,out] contour - A contour to be modified. [in] toEnd - The flag determines the place of the curve in the contour.
Returns
Returns operation result code.

◆ PlaneCurve()

 MbResultType PlaneCurve ( const MbPlacement3D & place, const MbCurve & curve, MbCurve3D *& result )

Create a space curve from a two-dimensional curve.

Create a space curve from a two-dimensional curve 'curve' lying on plane 'place'.
The construction is performed on the source curve.

Parameters
 [in] place - The plane coordinate system. [in] curve - A two-dimensional curve [out] result - The planar curve.
Returns
Returns operation result code.

◆ SurfaceCurve()

 MbResultType SurfaceCurve ( const MbSurface & surface, const MbCurve & curve, MbCurve3D *& result )

Create a curve on a surface given a two-dimensional curve.

Create a curve on a surface 'surface' given a two-dimensional curve 'curve'.
The construction is performed on the original curve and surface.

Parameters
 [in] surface - A surface. [in] curve - A two-dimensional curve [out] result - The curve on the specified surface.
Returns
Returns operation result code.

◆ CurveOnSurface()

 MbResultType CurveOnSurface ( const MbCurve3D & curve, const MbSurface & surf, bool sameSurf, bool extSurf, MbCurve3D *& result, bool strictOnSurface = `false` )

Create a curve on a surface from a space curve lying on the surface.

Create a curve on a surface from a space curve lying on the surface.
The special cases of curves exactly lying on the specified surfaces are treated. In the general case a space curve is considered to lie on the surface if a group of points obtained by sampling the curve with the given turning angle belongs to the surface. In this case a two-dimensional curve is created as the projection of the curve on the surface.

Parameters
 [in] curve - A space curve. [in] surf - A surface. [in] sameSurf - Whether to use the source surface. [in] extSurf - Whether to use the extended surface. [in] strictOnSurface - All the points of the curve belong to the surface (true) or a part of the points belong to the surface (false). [out] result - The curve on the specified surface.
Returns
Returns operation result code.

◆ IsCurveOnSurface()

 bool IsCurveOnSurface ( const MbCurve3D & curve, const MbSurface & surf, bool ext, bool strictOnSurface, VERSION version = `Math::DefaultMathVersion()` )

Determine whether the curve lies on the surface.

Determine whether the curve entirely lies on the surface.

Parameters
 [in] curve - A space curve. [in] surf - A surface. [in] ext - Whether to use the extended surface. [in] strictOnSurface - All the points of the curve belong to the surface (true) or a part of the points belong to the surface (false).
Returns
Returns true if the curve lies on the surface.

◆ CreateContours() [1/2]

 MbResultType CreateContours ( RPArray< MbCurve3D > & curves, double metricEps, RPArray< MbContour3D > & result, bool onlySmoothConnected = `false`, VERSION version = `Math::DefaultMathVersion()` )

Create an array of contours given an array of curves.

Create an array of contours given an array of curves (using the original curves). Degenerate curves, curves with a null pointer and duplicates of the curves are removed from the input array if they do not have an owner.

Parameters
 [in] curves - An array of curves. [in] metricEps - The radius for curves joining. [out] result - The array of contours. [in] onlySmoothConnected - Whether to add only smoothly connected segments. [in] version - Version.
Returns
Returns operation result code.

◆ CreateContours() [2/2]

 MbResultType CreateContours ( RPArray< MbCurve3D > & curves, double metricAcc, bool onlySmoothConnected = `false`, VERSION version = `Math::DefaultMathVersion()` )

Create contours given a set of curves with elimination of degenerate ones.

Create contours given a set of curves with elimination of degenerate ones (the original curves are used). Degenerate curves, curves with a null pointer and duplicates of the curves are removed from the input array if they do not have an owner.

Parameters
 [in,out] curves - An array of curves. [in] metricAcc - The radius for curves joining. [in] onlySmoothConnected - Whether to add only smoothly connected segments. [in] version - Version.
Returns
Returns operation result code.

◆ WireFrame() [1/2]

 MbResultType WireFrame ( const MbCurve3D & curve, const MbName & curveName, SimpleName mainName, MbWireFrame *& result )

Create a named three-dimensional wireframe.

Create a named three-dimensional wireframe from a curve.

Parameters
 [in] curve - The curve. [in] curveName - The curve name. [in] mainName - The operation main name. [out] result - The wireframe.
Returns
Returns operation result code.

◆ WireFrame() [2/2]

 MbResultType WireFrame ( const RPArray< MbCurve3D > & curves, const RPArray< MbName > & curveNames, SimpleName mainName, MbWireFrame *& result )

Create a named three-dimensional wireframe.

Create a named three-dimensional wireframe from a given array of curves.

Parameters
 [in] curves - An array of curves. [in] curveNames - An array of the curves names. [in] mainName - The operation main name. [out] result - The wireframe.
Returns
Returns operation result code.

◆ CreatePolyArcCurve3D()

 MbResultType CreatePolyArcCurve3D ( const MbCurve3D & curve, MbCurve3D *& result, double & eps, double minRad = `Math::minRadius`, double maxRad = `Math::maxRadius` )

Approximate a contour with arcs and line segments.

Approximate a contour with arcs and line segments.
The approximation is performed for each segment of the contour.

Parameters
 [in] curve - A curve or a contour to approximate. [out] result - The approximation result. [in] eps - The approximation precision. [in] minRad - The minimal acceptable radius of the circles used for the approximation. [in] maxRad - The maximal acceptable radius of the circles used for the approximation.
Returns
- Returns operation result code.

◆ GetSpaceCurve()

 bool GetSpaceCurve ( MbItem & item, bool keepPlacement, c3d::SpaceCurveSPtr & curve0, c3d::SpaceCurvesSPtrVector * curves = `nullptr` )

Get or create a space curve.

Get or create a space curve from a model object data. with optional keeping of supporting plane in the case of a planar object.
A two-dimensional contour is to be converted not to a contour on a plane but to a three-dimensional contour.

Parameters
 [in] item - A model object. [in] keepPlacement - Whether to keep the supporting plane. [out] curve0 - A space curve. [out] curves - Additional space curve (It's possible if a object "MbItem" is the object "MbPlaneInstance").
Returns
- Returns whether the result is successful.

◆ UnwrapCurve() [1/2]

 MbCurve3D* UnwrapCurve ( const MbCurve3D & curve, const MbPlacement3D & placement, const MbCartPoint3D & point, double deviationAngle = `DEVIATION_SAG` )

Construct a unwrapping curve/contour.

Construction unwrapping of the curve/contour on a plane. Each segment of the contour is unwrapped by the function UnwrapCurve. Unwrapping starting with a segment which lies in the plane or crosses the plane and which is closest to the given point. Unwrapping of the first segment is constructed in the manner, that cross point or closest projection of the segment on the plane were stationary.

Parameters
 [in] curve - Original curve/contour. [in] placement - The placement of the plane. [in] point - The point for determine first segment. [in] deviationAngle - The parameter of accuracy.
Returns
The pointer to the constructed curve with zero counter of references
return nullptr, if unwrap curve can't be construvted for this parameters

◆ EvolutionSection()

 MbResultType EvolutionSection ( const MbSweptData & generCurves, const MbCurve3D & guideCurve, double guideParam, const EvolutionValues & params, MbSweptData & result, VERSION version = `Math::DefaultMathVersion()`, double angleEpsilon = `ANGLE_EPSILON` )

Create a section of evolution solid for defined parameter on the guide curve.

Create a section of evolution solid (sweep solid with guide curve) for defined parameter on guide curve. If the guide curve is a contour, then this contour have to be smooth.

Parameters
 [in] generCurves - An array of forming curves. [in] guideCurve - An guide curve (or contour). [in] guideParam - A parameter on the guide curve. [in] params - The operation parameters. [out] result - Curves of evolution solid section. [in] version - The version. [in] angleEpsilon - The desired angular precision parallel to the tangent at the point of junction path segments.
Returns
Returns operation result code.

◆ IsLikeStraightLine()

 bool IsLikeStraightLine ( const MbCurve3D & curve, double eps )

Whether the curve is like straight-line regardless of its parameterisation.

Whether the curve is like straight-line regardless of its parameterisation.

Parameters
 [in] curve - Curve. [in] eps - Accuracy.
Returns
Returns true, if a curve is geometrically straight.

◆ CreateFairBSplineCurveOnBasePolyline()

 MbResultType CreateFairBSplineCurveOnBasePolyline ( MbCurve3D * polyline, MbFairCurveData & data, MbCurve3D *& result )

Create a fair B-spline on base polyline.

Create a fair V-curve on the base polyline and approximate by a B-spline curve. The degree of spline m, (m = 3, 4, ... , 9, 10) is set by variable degreeBSpline. For harmonious redistribution of points, the value of the variable arrange == true. Otherwise, == false. To subdivide a curve, the value of the variable subdivision > 0 (1 for a single subdivision, 2 for a double subdivision). The direction of the vector at the inflection points is taken into account by the value of the variable InflexVector (0 - as the direction of the S-polygon segment, 1 - as the direction of the tangent vector).

Attention
Experimental class.
Parameters
 [in] polyline - An initial polyline. [in] data - The curve construction data. [out] result - The spline curve.
Returns
Returns operation result code.

◆ CreateFairBSplineCurveOnTangentPolyline()

 MbResultType CreateFairBSplineCurveOnTangentPolyline ( MbCurve3D * polyline, MbFairCurveData & data, MbCurve3D *& result )

Create a fair B-spline on tangent polyline.

Create a fair V-curve on the base polyline and approximate by a B-spline curve. The degree of spline m, (m = 3, 4, ... , 9, 10) is set by variable degreeBSpline. To subdivide a curve, the value of the variable subdivision > 0 (1 for a single subdivision, 2 for a double subdivision). The direction of the tangent vector at the inflection points coincides with the direction of the inflection segment of tangent polyline).

Parameters
 [in] polyline - An initial polyline. [in] data - The curve construction data. [out] result - The spline curve.
Returns
Returns operation result code.

◆ CreateFairBezierCurveOnBasePolyline()

 MbResultType CreateFairBezierCurveOnBasePolyline ( MbCurve3D * polyline, MbFairCurveData & data, MbCurve3D *& result )

Create a fair Bezier curve on base polyline.

Create a smooth V-curve on the reference polyline and approximate a rational cubic Bezier curve. For harmonious redistribution of points, the value of the variable arrange == true. Otherwise, == false. To subdivide a curve, the value of the variable subdivision > 0 (1 for a single subdivision, 2 for a double subdivision).

Parameters
 [in] polyline - An initial polyline. [in] data - The curve construction data. [out] result - The spline curve.
Returns
Returns operation result code.

◆ CreateFairBezierFilletOnPolyline()

 MbResultType CreateFairBezierFilletOnPolyline ( MbCurve3D * pllne, MbFairCurveData & data, MbCurve3D *& resCurve )

Create a fillet fair Bezier curve on base polyline.

Create a fillet fair Bezier curve on base polyline and approximate a rational cubic Bezier curve.

Parameters
 [in] polyline - An initial polyline. [in] data - The curve construction data. [out] resCurve - The spline curve.
Returns
Returns operation result code.

◆ CreateFairBezierCurveOnTangentPolyline()

 MbResultType CreateFairBezierCurveOnTangentPolyline ( MbCurve3D * polyline, MbFairCurveData & data, MbCurve3D *& result )

Create a fair Bezier curve on tangent polyline.

Create a smooth V-curve on a tangent polyline and approximate a rational cubic Bezier curve. To subdivide a curve, the value of the variable subdivision > 0 (1 for a single subdivision, 2 for a double subdivision).

Parameters
 [in] polyline - An initial polyline. [in] data - The curve construction data. [out] result - The spline curve.
Returns
Returns operation result value. 0 - upon successful creation of the curve. If > 0, the value is equal to the error message number.from the message list of the MessageError method.

◆ KernelCreateHermiteGDOnBezierCurve()

 MbResultType KernelCreateHermiteGDOnBezierCurve ( const MbNurbs3D * curve, MbeFairCurveType type, MbFairCurveData & data, MbCurve3D *& polyline )

Create Hermite GD on a Bezier curve.

Create a Hermite geometric determinant (GD) in the form of a polyline on a rational Bezier spline curve.
The type parameter defines a type of created curve: polyline, tangent polyline, or Hermite GD. If the Hermite GD type is defined, then a base polyline is defined on the curve, the vertices of which belong to the nodal points of the spline.
The tangent vectors and the curvature vectors are determined. The tangent vector can be of arbitrary length.
The curvature vector must have a length equal to the value of curvature at a given vertex of the base polyline.
If the curvature value is zero at the inflection point, then the curvature vector is set in the direction of the tangent vector at the given vertex
and has an arbitrary nonzero length not exceeding the length of the tangent vector. \ n A directional polyline of Hermite GD sequentially bypasses the vertices of the base polyline, the ends of the tangent vectors and the ends of the curvature vectors.
Bypass occurs as follows: from the vertex of the base polyline to the end of the tangent vector, then return to the vertex of the base polyline, transition to the end of the curvature vector, return to the vertex of the base polyline, then transition to the next vertex of the base polyline, etc. The vertex with number 1 and the vertices with numbers in 5 (1, 6, 11, ...) belong to the ends of the tangent vectors.
The vertex with number 3 and the vertices with numbers in 5 (3, 8, 13, ...) belong to the ends of the curvature vectors.

Parameters
 [in] curve - An initial curve. [in] type - A type of a constructed curve. The allowed values: fairCrvType_Poly, fairCrvType_PolyTangent, fairCrvType_HermiteGD. [in] data - The curve construction data. [out] polyline - 3D polyline of Hermite GD.
Returns
Returns operation result value. 0 - upon successful creation of the curve. If > 0, the value is equal to the error message number from the message list of the MessageError method.

◆ CreateBezierCurveOnHermiteGD()

 MbResultType CreateBezierCurveOnHermiteGD ( MbCurve3D * polyline, MbFairCurveData & data, MbCurve3D *& result )

Create a Bezier on Hermite GD.

Isogeometrically create a cubic rational Bezier curve on a Hermite GD of second-order fixation. Used all params of Hermite GD of second-order fixation: points, tangent vectors and values of curvature.

Parameters
 [in] polyline - An initial polyline. [in] data - The curve construction data. [out] result - The spline curve.
Returns
Returns operation result value. 0 - upon successful creation of the curve. If > 0, the value is equal to the error message number from the message list of the MessageError method.

◆ CreateBSplineCurveOnHermiteGD()

 MbResultType CreateBSplineCurveOnHermiteGD ( MbCurve3D * polyline, MbFairCurveData & data, MbCurve3D *& result )

Create a B-spline on Hermite GD.

Create a B-spline curve on Hermite's GD of first-order fixation. \ n                The directions of the tangent vectors of the Hermite GD determine the directions of the S-polygon segmentss.
The direction of the vector at the inflection points is taken into account by the value of the variable InflexVector (0 - as the direction of the S-polygon segment,                1 - as the direction of the tangent vector).
The curvature at the end points is taken into account by the value of accountCurvature (0 - not taken into account, 1 - at the start point, 2 - at the end point, 3 - are taken into account at both ends).

Parameters
 [in] polyline - An initial polyline. [in] data - The curve construction data. [out] result - The spline curve.
Returns
Returns operation result value. 0 - upon successful creation of the curve. If > 0, the value is equal to the error message number from the message list of the MessageError method.

◆ CreateFairBezierCurveOnBasePolylineOfHermiteGD()

 MbResultType CreateFairBezierCurveOnBasePolylineOfHermiteGD ( MbCurve3D * polyline, MbFairCurveData & data, MbCurve3D *& result )

Create a fair Bezier curve on base polyline of Hermite GD.

Create a fair V-curve on the base polyline and approximate by a rational cubic Bezier curve. \ n The end values of the curvature and directions of the tangents at the inflection points of the Hermite GO are taken into account. For harmonious redistribution of points, the value of the variable arrange == true. Otherwise, == false. To subdivide a curve, the value of the variable subdivision> 0 (1 for a single subdivision, 2 for a double subdivision).

Parameters
 [in] polyline - An initial polyline. [in] data - The curve construction data. [out] result - The spline curve.
Returns
Returns operation result value. 0 - upon successful creation of the curve. If > 0, the value is equal to the error message number from the message list of the MessageError method.

◆ CreateFairBezierCurveOnTangentsOfHermiteGD()

 MbResultType CreateFairBezierCurveOnTangentsOfHermiteGD ( MbCurve3D * polyline, MbFairCurveData & data, MbCurve3D *& result )

Create a fair Bezier curve on tangent lines of Hermite GD.

Create a fair V-curve on the base polyline and approximate by a rational cubic Bezier curve. \ n   The end values of the curvature and directions of the tangents at the inflection points of the Hermite GO are taken into account. To subdivide a curve, set the value of the variable subdivision > 0 (1 for a single subdivision, 2 for a double subdivision).

Parameters
 [in] polyline - An initial polyline. [in] data - The curve construction data. [out] result - The spline curve.
Returns
Returns operation result value. 0 - upon successful creation of the curve. If > 0, the value is equal to the error message number \ n               from the message list of the MessageError method.

◆ CreateFairBSplineCurveOnBasePolylineOfHermiteGD()

 MbResultType CreateFairBSplineCurveOnBasePolylineOfHermiteGD ( MbCurve3D * polyline, MbFairCurveData & data, MbCurve3D *& result )

Create a fair B-spline curve on base polyline of Hermite GD.

Create a fair V-curve on the base polyline and approximate by a B-spline curve. \ n The degree of spline m, (m = 3, 4, ... , 9, 10) is set by variable degreeBSpline. For harmonious redistribution of points, the value of the variable arrange == true. Otherwise, == false. To subdivide a curve, the value of the variable subdivision > 0 (1 for a single subdivision, 2 for a double subdivision). The directions of the tangent vectors of the Hermite GD determine the directions of the S-polygon segmentss.
The direction of the vector at the inflection points is taken into account by the value of the variable InflexVector (0 - as the direction of the S-polygon segment, \ n 1 - as the direction of the tangent vector).
The curvature at the end points is taken into account by the value of accountCurvature (0 - not taken into account, 1 - at the start point, 2 - at the end point, 3 - are taken into account at both ends).

Attention
Experimental class.
Parameters
 [in] polyline - An initial polyline. [in] data - The curve construction data. [out] result - The spline curve.
Returns
Returns operation result value. 0 - upon successful creation of the curve. If > 0, the value is equal to the error message number from the message list of the MessageError method.

◆ CreateFairBSplineCurveOnBasePolylineOfHermiteGDInflex()

 MbResultType CreateFairBSplineCurveOnBasePolylineOfHermiteGDInflex ( const MbCurve3D * pllne, MbFairCurveData & data, MbCurve3D *& resCurve )

Create a fair B-spline curve on base polyline of Hermite GD.

Create a fair V-curve on the base polyline and approximate by a B-spline curve. \ n The degree of spline m, (m = 3, 4, ... , 9, 10) is set by variable degreeBSpline. For harmonious redistribution of points, the value of the variable arrange == true. Otherwise, == false. To subdivide a curve, the value of the variable subdivision > 0 (1 for a single subdivision, 2 for a double subdivision). The directions of the tangent vectors of the Hermite GD determine the directions of the S-polygon segmentss.
The direction of the vector at the inflection points is taken into account by the value of the variable InflexVector (0 - as the direction of the S-polygon segment, \ n 1 - as the direction of the tangent vector).
The curvature at the end points is taken into account by the value of accountCurvature (0 - not taken into account, 1 - at the start point, 2 - at the end point, 3 - are taken into account at both ends).

Attention
Experimental class.
Parameters
 [in] polyline - An initial polyline. [in] data - The curve construction data. [out] result - The spline curve.
Returns
Returns operation result value. 0 - upon successful creation of the curve. If > 0, the value is equal to the error message number from the message list of the MessageError method.

◆ CreateFairBSplineCurveOnNoisyData()

 MbResultType CreateFairBSplineCurveOnNoisyData ( MbCurve3D * pllne, int inType, MbFairCurveData & data, MbCurve3D *& resCurve )

Create a fair B-spline curve with smoothing and reparametrization on noisy data.

Create a fair B-spline curve with smoothing and reparametrization on noisy data (base polyline of Hermite GD).

Attention
Experimental class.
Parameters
 [in] polyline - An initial polyline. [in] inType - The type of the curve construction data. [in] data - The curve construction data. [out] resCurve - The spline curve.
Returns
Returns operation result value. 0 - upon successful creation of the curve. If > 0, the value is equal to the error message number from the message list of the MessageError method.

◆ CreateFairBSplineCurveOnTangentsOfHermiteGD()

 MbResultType CreateFairBSplineCurveOnTangentsOfHermiteGD ( MbCurve3D * polyline, MbFairCurveData & data, MbCurve3D *& result )

Create a fair B-spline curve on tangent lines of Hermite GD.

Create a fair V-curve on the base polyline of Hermite GD and approximate by a B-spline curve. \ n The degree of spline m, (m = 3, 4, ... , 9, 10) is set by variable degree. For harmonious redistribution of points, the value of the variable arrange == true. Otherwise, == false. To subdivide a curve, set the value of the variable subdivision > 0 (1 for a single subdivision, 2 for a double subdivision). The curvature at the end points is taken into account by the value of accountCurvature (0 - not taken into account, 1 - at the start point, 2 - at the end point, 3 - are taken into account at both ends).

Parameters
 [in] polyline - An initial polyline. [in] data - The curve construction data. [out] result - The spline curve.
Returns
Returns operation result value. 0 - upon successful creation of the curve. If > 0, the value is equal to the error message number from the message list of the MessageError method.

◆ KernelCreateClothoid()

 MbResultType KernelCreateClothoid ( MbFairCurveData & data, MbCurve3D *& result )

Create a clothoid.

Create the starting part of the clothoid. \ n              The parameters to create the clothoid are set in the data. The maximum length of the initial section of the clothoid in the variable clothoidMax and the minimum radius at the end of the section in the variable clothoidRMin. The variable clothoidSegms sets the number of segments of the Bezier spline curve approximating the clothoid .

Parameters
 [in] data - The curve construction data. [out] result - The spline curve.
Returns
Returns operation result value.

◆ KernelCreateSectrix()

 MbResultType KernelCreateSectrix ( MbCurve3D * polyline, MbFairCurveData & data, MbCurve3D *& result )

Create a sectrix.

Create a sectrix of Maclourin. On a tangent polyline of two links, points of the Maclaurin sectrix â€” a curve with a monotonic change in curvature â€” are generated.              The Maclaurin sectrix is isometrically approximated with the preservation of monotony by the Bezier spline curve.

Parameters
 [in] polyline - An initial polyline. [in] data - The curve construction data. [out] result - The spline curve.
Returns
Returns operation result value.

◆ ElevateDegreeNurbzs()

 MbResultType ElevateDegreeNurbzs ( MbNurbs3D * curve, MbFairCurveData & data, MbCurve3D *& result )

Elevate the degree of the NURBzS curve.

The increasing the degree of the NURBzS curve.
The degree of the cubic curve increases to the sixth degree.              Degrees greater than 6 increase by one. The maximum degree is 10.

Parameters
 [in] curve - An initial curve. [in] data - The curve construction data. [out] result - The spline curve.
Returns
Returns operation result value.

◆ ReparamNurbs()

 MbResultType ReparamNurbs ( MbNurbs3D * curve, MbFairCurveData & data, MbCurve3D *& resCurve )

Reparametrize the NURBS curve.

Reparametrize the NURBS curve.

Parameters
 [in] curve - An initial curve. [in] data - Curve reparametrization data. [out] resCurve - The spline curve.
Returns
Returns operation result value.

◆ SubdivideNurbs()

 MbResultType SubdivideNurbs ( MbNurbs3D * curve, MbFairCurveData & data, MbCurve3D *& result )

Subdivide the NURBS curve.

Single subdivision of NURBS curve.

Parameters
 [in] curve - An initial curve. [in] data - Curve construction and transformation data. [out] result - The spline curve.
Returns
Returns operation result value.

◆ ExtractChangeNurbs()

 MbResultType ExtractChangeNurbs ( MbNurbs3D * curve, MbFairCurveData & data, MbCurve3D *& result )

To extract part of NURBS curve / change the format of the NURBS curve.

To extract part of NURBS curve / change the format of the NURBS curve.
Transformation variables are set in data. The extracting part is determined by the number of the starting segment in the variable numSegment and the number of segments in the variable numSegments. The output spline format is defined in the outFormat variable.    If the value is 2 - NURBS curve with control S-polygon. If the value is 3 - rational Bezier curve with GB-control polygon.

Parameters
 [in] curve - An initial curve. [in] data - Curve construction and transformation data. [out] result - The spline curve.
Returns
Returns operation result value.

◆ ExtractChangeNurbsParams()

 MbResultType ExtractChangeNurbsParams ( MbNurbs3D * curve, MbFairCurveData & data, SArray< double > & resWts, SArray< double > & resKnots, MbCurve3D *& resCurve )

To extract part of NURBS curve / change the format of the NURBS curve. Return parameters of created curve.

To extract part of NURBS curve / change the format of the NURBS curve. Return parameters of created curve.
Transformation variables are set in data. The extracting part is determined by the number of the starting segment in the variable numSegment and the number of segments in the variable numSegments. The output spline format is defined in the outFormat variable. If the value is 2 - NURBS curve with control S-polygon. If the value is 3 - rational Bezier curve with GB-control polygon.

Parameters
 [in] curve - An initial curve. [in] data - Curve construction and transformation data. [out] resWts - Weights of the result curve. [out] resKnots - Knots of the result curve. [out] result - The spline curve.
Returns
Returns operation result value.

 MbResultType AddKnotNurbs ( MbNurbs3D * curve, MbFairCurveData & data, MbCurve3D *& result )

Insert node in NURBS.

Insert node in NURBS. Transformation variables are set in data. The insertion position of the node is determined by the variables nSegment and tParam.              The nSegment variable sets the segment number, the tParam variable (0.1 <tParam <0.9) sets the value of the internal parameter on the spline segment.

Parameters
 [in] curve - An initial curve. [in] data - The curve construction data. [out] result - The spline curve.
Returns
Returns operation result value.

◆ ExtractExtrapolFromSegment()

 MbResultType ExtractExtrapolFromSegment ( MbNurbs3D * curve, MbFairCurveData & data, MbCurve3D *& resCurve )

Insert a knot into the onesegmented NURBS curve.

Insert a knot into the onesegmented NURBS curve.
The output parameter of the method is a NURBS curve of first segment.

Parameters
 [in] curve - NURBS curve in any format. [in] data - The curve construction data. [out] resCurve - NURBS curve.
Returns
Returns operation result value.

◆ ConicNurbs()

 MbResultType ConicNurbs ( MbNurbs3D * curve, MbFairCurveData & data, MbCurve3D *& result )

Convert a conical NURBzS into a conical NURBS.

Convert a NURBzS curve geometrically representing a conic curve into a rational B-spline curve of degree 6 geometrically representing a conic curve

Parameters
 [in] curve - An initial curve. [in] data - The curve construction data. [out] result - The spline curve.
Returns
Returns operation result value.

◆ Cabling()

 MbResultType Cabling ( const MbCartPoint3D & begPoint, const MbVector3D & begDirection, const MbCartPoint3D & endPoint, const MbVector3D & endDirection, double length, double accuracy, double & maxCurvature, MbCurve3D *& result )

Connecting the specified points by a curve of a specified length.

The resulting curve must start at a given point in a given direction and end at a given point in a given direction. The curvature of the curve must not exceed the specified maximum value.

Parameters
 [in] begPoint - The start point. [in] begDirection - The curve direction at the start point. [in] endPoint - The end point. [in] endDirection - The curve direction at the end point. [in] length - The curve length evaluation. [in] accuracy - Relative accuracy calculate the length of a curve. [in,out] maxCurvatre - The maximum curvature of the resulting curve. [out] result - The resulting curve.
Returns
Returns operation result value.

◆ SetProportionalParametrization() [2/2]

 MbCurve3D* SetProportionalParametrization ( MbCurve3D * curve, double tMin, double tMax )

Set curve parametrization proportional to the curve length.

If the curve parameterization is not proportional to the length of the curve, then change the curve parameterization to make it proportional to the length of the curve.
In general, the curve will be replaced by a MbReparamCurve3D curve with length proportional parameterization. In special cases, when the curve has a proportional parametrization with the required boundaries, the original curve will be returned.

Parameters
 [in] curve - The original curve to be reparametrized. [in] tMin - New minimal parameter of the curve. [in] tMax - New maximal parameter of the curve.
Returns
Returns created curve with proportional length parameterization.

◆ ExtendCurve()

 MbResultType ExtendCurve ( const MbCurve3D & sourceCurve, const MbCurveExtensionParameters3D & parameters, SPtr< MbWireFrame > & resFrame )

Extend the given curve.

Extend the given curve according to the given parameters.

Parameters
 [in] sourceCurve - Source (extended) curve. [in] parameters - Parameters of extension. [in] snMaker - An object defining the edges names. [out] resFrame - Result curve in the wire-frame.
Returns
Returns the code of the operation result. In case of success, the result curve cannot be nullptr (it will be possibly the same as the source one).

◆ CreateContourChamfer()

 MbResultType CreateContourChamfer ( const MbContourChamferParams & paramList, MbCurve3D *& resultChamferContour )

Create chamfers on the contour joints.

Create chamfers on the contour joints

Parameters
 [in] paramList - Set of input parameters: the source curve and the list of joints with parameters. The source curve can be one of the following types: 3d contour, 3d polyline, contour on a surface, polyline on a surface. For other types the successful chamfer creation is not guaranteed.
Returns
Returns the code of the operation result. In case of success, the result curve cannot be nullptr. In case of failure the result may be nullptr. The possible error codes are: rt_ParameterError, rt_PartlyChamfer. rt_ParameterError means the error in the input parameters. Some of the possible reasons: index of the non-existing joint, repetitive jount index, wrong source curve; in this case the result curve is not created. rt_PartlyChamfer means the error during the chamfer creation on at least one of the segments; the result curve may not exist in this case. Some of the possible reasons: chamfer hits an edge of a segment, a collision with another chamfer; in this case the chamfer is not created. If no chamfers were created, the resulting curve is not created.

◆ UnwrapCurve() [2/2]

 MbResultType UnwrapCurve ( const MbCurvesWrappingParams & parameters, MbCurvesWrappingResults & result )

Construct unwrapped curves and points.

Construct unwrapped curves and points on a plane. Also check out CurvesUnwrapping.

Parameters
 [in] params - Unwrapping parameters. [out] result - Wrapping result.
Returns
Returns operation result code.

◆ WrapCurve()

 MbResultType WrapCurve ( const MbCurvesWrappingParams & parameters, MbCurvesWrappingResults & result )

Perform the operation of wrapping curves and points on a surface.

Perform the operation of wrapping curves on a surface. Also check out CurvesWrapping.

Parameters
 [in] params - Wrapping parameters. [out] result - Wrapping result.
Returns
Returns operation result code.

◆ CheckJoinedParams()

 bool CheckJoinedParams ( const MbCurve3D & curve, SArray< double > & params, bool isAscending )

Check the curve parameters for creation of a joint solid.

Check the curve parameters and normalize a closed curve parameters.

Parameters
 [in] curve - The curve. [in,out] params - An array of the curve parameters. [in] isAscending - Whether the parameters are specified in the ascending order.
Returns
Returns true if the parameter array has been successfully normalized.
Warning
An auxiliary function of operation JoinShell.

◆ CreateJoinedCurve()

 MbCurve3D* CreateJoinedCurve ( const RPArray< MbCurveEdge > & edges, const SArray< bool > & orients, const MbMatrix3D & matr, MbResultType & res )

Create a curve from a set of edges.

Create a curve for a surface of the joint from a list of edges.

Parameters
 [in] edges - A set of edges. [in] orients - Edges senses. [in] matr - Edges transformation matrix. [out] res - The operation result.
Returns
Returns a pointer to the curve if it has been successfully created, otherwise it returns null.
Warning
An auxiliary function of operation JoinShell.

◆ TrimClosedSpine()

 MbCurve3D* TrimClosedSpine ( const MbCurve3D & curve, double t )

Create a trimmed closed curve on a curve copy.

Create a copy of a closed curve starting at a point with parameter t.

Parameters
 [in] curve - The spine curve. [in] t - A curve parameter.
Returns
Returns a constructed curve copy starting at the specified point if it has been successfully created, otherwise it returns null.
Warning
An auxiliary function of operations EvolutionSolid and EvolutionResult.

◆ CalculatePipePoints()

 MbResultType CalculatePipePoints ( const MbCartPoint3D & origin1, const MbVector3D & direction1, double length1, double radius1, const MbCartPoint3D & origin2, const MbVector3D & direction2, double length2, double radius2, MbCartPoint3D & result1, MbCartPoint3D & result2 )

Compute the vertices of a polyline.

Compute the vertices 'point1' and 'point2' of a polyline connecting points 'origin1' and 'origin2' translated in the directions 'direction1' and 'direction2' by distances 'length1' and 'length2' which can be rounded with radius 'radius1' and 'radius2'.

Parameters
 [in] origin1 - The first point. [in] direction1 - The direction of the first point translation. [in] length1 - The distance of the first point translation. [in] radius1 - The rounding radius for the first point. [in] origin2 - The second point. [in] direction2 - The direction of the second point translation. [in] length2 - The distance of the second point translation. [in] radius2 - The rounding radius for the second point. [out] result1 - The first point of the polyline. [out] result2 - The second point of the polyline.
Returns
Returns operation result code.

◆ OffsetPlaneCurve()

 MbResultType OffsetPlaneCurve ( const MbCurve3D & curve, double dist, MbCurve3D *& result )

Create an offset curve.

Create an offset curve from a planar curve.

Parameters
 [in] curve - The initial curve. [in] dist - The offset distance. [out] result - The offset curve.
Returns
Returns operation result code.

◆ OffsetCurve() [1/2]

 MbResultType OffsetCurve ( const MbCurve3D & initCurve, const MbSpatialOffsetCurveParams & params, c3d::WireFrameSPtr & result )

Create an offset curve in space.

Create an offset curve in space from a three-dimensional curve and a direction vector.

Parameters
 [in] initCurve - A space curve for which to construct the offset curve. [in] params - Parameters. [out] result - The frame with the constructed curves.
Returns
Returns operation result code.

◆ OffsetCurve() [2/2]

 MbResultType OffsetCurve ( const MbCurve3D & curve, const MbSurfaceOffsetCurveParams & params, c3d::WireFrameSPtr & result )

Create an offset curve on a surface.

Create an offset curve on a surface from a curve on the surface and a shift value.

Parameters
 [in] curve - A curve on face 'face' surface. [in] params - Parameters. [out] result - The frame with the constructed curves.
Returns
Returns operation result code.

◆ CurveProjection() [1/2]

 MbResultType CurveProjection ( const MbSurface & surface, const MbCurve3D & curve, MbVector3D * direction, bool createExact, bool truncateByBounds, RPArray< MbCurve3D > & result, VERSION version = `Math::DefaultMathVersion()` )

Create a curve projection onto the surface.

Create the projection of a curve onto surface 'surface' (the projection direction 'direction' can be nullptr).

Parameters
 [in] surface - The surface to project onto. [in] curve - The curve to project. [in] direction - The projection direction (if not specified, the projection along the normal). [in] createExact - Create a projection curve if necessary. [in] truncateByBounds - Truncate by the surface bounds. [in] version - The version. [out] result - An array of curves on the surface.
Returns
Returns operation result code.

◆ CurveProjection() [2/2]

 MbResultType CurveProjection ( const MbSurface & surface, const MbCurve3D & curve, MbVector3D * direction, bool createExact, bool truncateByBounds, c3d::SpaceCurvesSPtrVector & result, VERSION version = `Math::DefaultMathVersion()` )

Create a curve projection onto the surface.

Create the projection of a curve onto surface 'surface' (the projection direction 'direction' can be nullptr).

Parameters
 [in] surface - The surface to project onto. [in] curve - The curve to project. [in] direction - The projection direction (if not specified, the projection along the normal). [in] createExact - Create a projection curve if necessary. [in] truncateByBounds - Truncate by the surface bounds. [in] version - The version. [out] result - An array of curves on the surface.
Returns
Returns operation result code.

◆ CurveByTwoProjections()

 MbResultType CurveByTwoProjections ( const MbPlacement3D & place1, const MbCurve & curve1, const MbPlacement3D & place2, const MbCurve & curve2, RPArray< MbCurve3D > & result, VERSION version = `Math::DefaultMathVersion()` )

Create a space curve from two planar projections.

Create a space curve from two planar projections.

Parameters
 [in] place1 - A local coordinate system 1. [in] curve1 - A two-dimensional curve 1. [in] place2 - A local coordinate system 2. [in] curve2 - A two-dimensional curve 2. [out] result - The array of three-dimensional curves.
Returns
Returns operation result code.

◆ ProjectionCurve() [1/2]

 MbResultType ProjectionCurve ( const MbCurve3D & curve, const RPArray< MbFace > & faces, const MbVector3D * dir, const bool createExact, const bool truncateByBounds, const MbSNameMaker & snMaker, RPArray< MbCurve3D > & result, SArray< uintptr_t > * resultIndices )

Create a projection curve from a normal or from a direction.

Create a projection curve from a normal or from a direction.
If the projection is onto the constructive plane (a plane without bounds), create a face on the basis of this projection.

Parameters
 [in] curve - The curve to project. [in] faces - A connected set of faces. [in] dir - The direction vector (if it is absent, the normal projection). [in] createExact - Create a projection curve if necessary. [in] truncateByBounds - Truncate by bounds. [in] snMaker - An object defining the names with the version. [out] result - The projection curves. [out] resultIndices - The indices of faces in the initial array.
Returns
Returns operation result code.

◆ ProjectionCurve() [2/2]

 MbResultType ProjectionCurve ( const MbWireFrame & wireFrame, const bool sameWireFrame, const MbSolid & solid, const bool same, const SArray< size_t > & faceIndices, const MbVector3D * dir, const bool createExact, const bool truncateByBounds, const MbSNameMaker & snMaker, MbWireFrame *& resFrame )

Create a projection wireframe from a normal or from a direction.

Create a projection curve from a normal or from a direction.
If the projection is onto the constructive plane (a plane without bounds), create a face on the basis of this projection.

Parameters
 [in] wireFrame - The wireframe to project. [in] sameWireFrame - Flag whether to use the same wireframe or make a copy of it. [in] solid - Solid. [in] same - Flag whether to use the same creators of the body or make a copy. [in] faceIndices - The numbers of faces in the first shell. [in] dir - The direction vector (if it is absent, the normal projection). [in] createExact - Create a projection curve if necessary. [in] truncateByBounds - Truncate by bounds. [in] snMaker - An object defining the names with the version. [out] resFrame - The resulting wireframe, the attributes of the edges contain the names of corresponding faces.
Returns
Returns operation result code.

◆ EliminateProjectionCurveOverlay()

 bool EliminateProjectionCurveOverlay ( RPArray< MbCurve3D > & curves, SArray< uintptr_t > * indices )

Eliminate the projection curve segments overlay.

Eliminate the projection curve segments overlay (an auxiliary function for function ProjectionCurve).

Parameters
 [in,out] curves - An array of curves. [in,out] indices - An array of indices synchronized with the array of curves.
Returns
Returns true if something has modified in the curve set.

◆ IntersectionCurve() [1/9]

 MbResultType IntersectionCurve ( const MbSurface & surface1, const MbSurface & surface2, const MbIntCurveParams & params, MbWireFrame *& result )

Create the intersection curves of two surfaces.

Create the intersection curves of two surfaces. The result is an array of intersection curves of surfaces.

Deprecated:
The function is deprecated, instead use IntersectionCurve with the parameter list MbIntCurveParams and MbIntCurveResults.
Parameters
 [in] surface1 - The first surface. [in] surface2 - The second surface. [in] params - Parameters. [out] result - The frame with the constructed curves.
Returns
Returns operation result code.
Warning
It is better to use IntersectionCurve on faces since the surfaces bounds can be inexact,
and it will result in inexact position of intersection curves ends.
But the surface bounds in faces are exact since they are stored in the form of intersection curves, not in the form of two-dimensional curves.

◆ IntersectionCurve() [2/9]

 MbResultType IntersectionCurve ( MbFace & face1, MbFace & face2, const MbIntCurveParams & params, MbWireFrame *& result )

Create intersection curves of two faces.

Create intersection curves of two faces. The result is an array of intersection curves of surfaces.

Deprecated:
The function is deprecated, instead use IntersectionCurve with the parameter list MbIntCurveParams and MbIntCurveResults.
Parameters
 [in] face1 - The first face of the shell. [in] face2 - The second face of the shell. [in] params - Parameters. [out] result - The frame with the constructed curves.
Returns
Returns operation result code.

◆ IntersectionCurve() [3/9]

 MbResultType IntersectionCurve ( MbFace & face1, MbFace & face2, const MbIntCurveParams & params, MbIntCurveResults & results )

Create intersection curves of two faces.

Create intersection curves of two faces. The result is an array of intersection curves of surfaces.

Parameters
 [in] face1 - The first face of the shell. [in] face2 - The second face of the shell. [in] params - Parameters. [out] results - Output parameters.
Returns
Returns operation result code.

◆ IntersectionCurve() [4/9]

 MbResultType IntersectionCurve ( const MbSolid & solid1, const c3d::IndicesVector & faceIndices1, const MbSolid & solid2, const c3d::IndicesVector & faceIndices2, const MbIntCurveParams & params, MbWireFrame *& result )

Create intersection curves of two shells faces.

Create intersection curves of two shells faces. The result is an array of intersection curves of surfaces.

Deprecated:
The function is deprecated, instead use IntersectionCurve with the parameter list MbIntCurveShellParams and MbIntCurveResults.
Parameters
 [in] solid1 - The first shell. [in] faceIndices1 - The numbers of faces in the first shell. [in] solid2 - The second shell. [in] faceIndices2 - The numbers of faces in the second shell. [in] params - Parameters. [out] result - The frame with the constructed curves.
Returns
Returns operation result code.

◆ IntersectionCurve() [5/9]

 MbResultType IntersectionCurve ( const MbSolid & solid1, const c3d::IndicesVector & faceIndices1, bool same1, const MbSolid & solid2, const c3d::IndicesVector & faceIndices2, bool same2, const MbIntCurveParams & params, MbWireFrame *& result )

Create intersection curves of two shells faces.

Create intersection curves of two shells faces. The result is an array of intersection curves of surfaces.

Deprecated:
The function is deprecated, instead use IntersectionCurve with the parameter list MbIntCurveShellParams and MbIntCurveResults.
Parameters
 [in] solid1 - The first shell. [in] faceIndices1 - The numbers of faces in the first shell. [in] same1 - Flag whether to use the same creators of the first body or make a copy. [in] solid2 - The second shell. [in] faceIndices2 - The numbers of faces in the second shell. [in] same2 - Flag whether to use the same creators of the second body or make a copy. [in] params - Parameters. [out] result - The frame with the constructed curves.
Returns
Returns operation result code.

◆ IntersectionCurve() [6/9]

 MbResultType IntersectionCurve ( const MbSolid & solid1, const MbSolid & solid2, const MbIntCurveShellParams & params, MbIntCurveResults & results )

Create intersection curves of two shells faces.

Create intersection curves of two shells faces. The result is an array of intersection curves of surfaces.

Parameters
 [in] solid1 - The first shell. [in] solid2 - The second shell. [in] params - Inpit parameters. [out] results - Output parameters.
Returns
Returns operation result code.

◆ IntersectionCurve() [7/9]

 MbResultType IntersectionCurve ( const MbSurface & surface1, const MbSurface & surface2, const MbIntCurveParams & params, MbIntCurveResults & results )

Create an intersection curve of surfaces.

Create an intersection curve of the two surfaces. Possible options of creation are:
) General case resulting with MbWireFrame. Warning: In general case it is better to use IntersectionCurve on faces since the surfaces bounds can be inexact, and it will result in inexact position of intersection curve edges. But the surface bounds in faces are exact since they are stored in the form of intersection curves, not in the form of two-dimensional curves.
) From the specified starting point and the initial direction of the intersection curve.
) From the specified starting and ending points of the intersection curve and the initial direction.
) From the specified starting and ending points of the intersection curve and the guide curve that approximates the desired curve.

Parameters
 [in] surface1 - The first surface. [in] surface2 - The second surface. [in] params - Inpit parameters. [out] results - Output parameters.
Returns
Returns the operation result code.

◆ IntersectionCurve() [8/9]

 MbResultType IntersectionCurve ( const MbSurface & surface1, bool ext1, const MbCartPoint & uv1beg, const MbCartPoint & uv1end, const MbSurface & surface2, bool ext2, const MbCartPoint & uv2beg, const MbCartPoint & uv2end, const MbVector3D & dir, MbCurve *& result1, MbCurve *& result2, MbeCurveBuildType & label )

Create an intersection curve of surfaces.

Create an intersection curve of surfaces 'surf1' and 'surf2' from the specified start point and end point of the intersection curve.

Deprecated:
The function is deprecated, instead use IntersectionCurve with the parameter list MbIntCurveParams and MbIntCurveResults.
Parameters
 [in] surface1 - The first surface. [in] ext1 - Whether to create on the extended surface. [in] uv1beg - The start point on the first surface. [in] uv1end - The end point on the first surface. [in] surface2 - The second surface. [in] ext2 - Whether to create on the extended second surface. [in] uv2beg - The start point on the second surface. [in] uv2end - The end point on the second surface. [in] dir - The start direction for intersection curve creation. [out] result1 - The two-dimensional curve on the first surface. [out] result2 - The two-dimensional curve on the second surface. [out] label - The resultant intersection curve type.
Returns
Returns operation result code.

◆ IntersectionCurve() [9/9]

 MbResultType IntersectionCurve ( const MbSurface & surf1, bool ext1, const MbCartPoint & uv1beg, const MbCartPoint & uv1end, const MbSurface & surf2, bool ext2, const MbCartPoint & uv2beg, const MbCartPoint & uv2end, const MbCurve3D * guideCurve, bool useRedetermination, bool checkPoles, MbCurve *& pCurve1, MbCurve *& pCurve2, MbeCurveBuildType & label )

Create an intersection curve of surfaces.

Create an intersection curve of surfaces 'surf1' and 'surf2' from the specified start point and end point of the intersection curve and guide curve that approximates the desired curve.

Deprecated:
The function is deprecated, instead use IntersectionCurve with the parameter list MbIntCurveParams and MbIntCurveResults.
Parameters
 [in] surface1 - The first surface. [in] ext1 - Whether to create on the extended surface. [in] uv1beg - The start point on the first surface. [in] uv1end - The end point on the first surface. [in] surface2 - The second surface. [in] ext2 - Whether to create on the extended second surface. [in] uv2beg - The start point on the second surface. [in] uv2end - The end point on the second surface. [in] guideCurve - The guide curve that approximates the desired curve. [in] useRedetermination - The flag that determines whether it is necessary to specify the next point build step as compared to the DeviationStep function. [in] checkPoles - The flag that determines whether it is necessary to check and correct pole points. [out] result1 - The two-dimensional curve on the first surface. [out] result2 - The two-dimensional curve on the second surface. [out] label - The resultant intersection curve type.
Returns
Returns operation result code.

◆ SpaceSplineThrough()

 MbResultType SpaceSplineThrough ( const SArray< MbCartPoint3D > & points, MbeSplineParamType paramType, size_t degree, bool closed, RPArray< c3d::PntMatingData3D > & transitions, const MbSNameMaker & snMaker, MbWireFrame *& result )

Create a spatial spline through points and with the given derivatives.

Create a spatial spline through points and with the given derivatives.
Notes:
If derivatives are specified, the number of derivatives should be equal to the number of points.
Missing derivatives should be represented by null pointers in the array

Parameters
 [in] points - Points. [in] paramType - The parametrization type. [in] degree - A spline degree. [in] closed - The spline closedness. [in] transitions - The specified derivatives. [in] snMaker - An object defining the frame curves names. [out] result - The frame with the constructed curves.
Returns
Returns operation result code.

◆ SpaceSplineBy()

 MbResultType SpaceSplineBy ( const SArray< MbCartPoint3D > & points, size_t degree, bool closed, const SArray< double > * weights, const SArray< double > * knots, c3d::PntMatingData3D * begData, c3d::PntMatingData3D * endData, const MbSNameMaker & snMaker, MbWireFrame *& result )

Create a spatial spline from points and derivatives.

Create a spatial spline from points and derivatives.

Parameters
 [in] points - An array of points. [in] degree - A spline degree. [in] closed - Create a closed spline. [in] weights - An array of points weights. [in] knots - A knot vector of the spline. [in] begData - The start derivative. [in] endData - The end derivative. [in] snMaker - An object defining the frame curves names. [out] result - The frame with the constructed curves.
Returns
Returns operation result code.

◆ SurfaceSpline()

 MbResultType SurfaceSpline ( const MbSurface & surface, bool throughPoints, SArray< MbCartPoint > & paramPnts, SArray< double > & paramWts, bool paramClosed, RPArray< c3d::PntMatingData3D > & spaceTransitions, const MbSNameMaker & snMaker, MbWireFrame *& result )

Create a curve on a surface.

Create a curve on a surface.
Notes:

1. If derivatives are specified, the number of derivatives should be equal to the number of points.
Missing derivatives should be represented by null pointers in the array
2. If the spline is created from points, arbitrary derivatives can be defined.
1. If the spline is created from poles and it is open, only the end derivatives can be specified.
2. If the spline is constructed from poles and it is closed, the derivatives cannot be specified.
3. An array of weights should be empty or synchronized with the point array by size (with option throughPoints weights are ignored).
Parameters
 [in] surface - The surface. [in] throughPoints - Create a spline through points. [in] paramPnts - An array of parametric points. [in] paramWts - An array of parametric point weights. [in] paramClosed - Create a closed parametric spline. [in] spaceTransitions - Derivatives in the points. [in] snMaker - An object defining the frame curves names. [out] result - The frame with the constructed curves.
Returns
Returns operation result code.

◆ IsoparametricCurve()

 MbResultType IsoparametricCurve ( const MbSurface & surface, double x, bool isU, const MbRect1D * yRange, MbCurve3D *& result )

Create an isoparametric curve.

Create an isoparametric curve on surface 'surface'.

Parameters
 [in] surface - The surface. [in] x - A value of the first parameter. [in] isU - Whether the first parameter is U. [in] yRange - A range of the second parameter (if not defined, the parametric bounds of the surface are used). [out] result - The isoparametric curve.
Returns
Returns operation result code.

◆ BridgeCurve()

 MbResultType BridgeCurve ( const MbCurve3D & curve1, double t1, bool sense1, const MbCurve3D & curve2, double t2, bool sense2, const MbSNameMaker & names, MbWireFrame *& result )

Create a transition curve connecting curves 'curve1' and 'curve2'.

Create a transition curve connecting curves 'curve1' and 'curve2' by a cubic Hermite spline.

Parameters
 [in] curve1 - A curve 1 to be connected. [in] t1 - A point parameter on the curve 1. [in] sense1 - The beginning of the transition curve is equal to the direction of 'curve1' (true). [in] curve2 - A curve 2 to be connected. [in] t2 - A point parameter on the curve 2. [in] sense2 - The end of the transition curve is equal to the direction of 'curve2' (true). [in] names - An object defining the frame curves names. [out] result - The frame with the constructed curves.
Returns
Returns operation result code.

◆ ConnectingCurve()

 MbResultType ConnectingCurve ( const MbCurve3D & curve1, bool isBegin1, double radius1, const MbCurve3D & curve2, bool isBegin2, double radius2, const MbSNameMaker & names, MbWireFrame *& result )

Create a composite curve smoothly connecting two curves ends.

Create a composite curve smoothly connecting two curves ends.
The constructed curve consists of a three-dimensional arc of radius 'radius1', a segment (in specific cases a segment is absent), a three-dimensional arc of radius 'radius2'.

Parameters
 [in] curve1 - A curve 1 to be connected. [in] isBegin1 - The beginning of the curve 1 (true). [in] radius1 - The conjugation raidus of curve 1. [in] curve2 - A curve 2 to be connected. [in] isBegin2 - The beginning of the curve 2 (true). [in] radius2 - The conjugation raidus of curve 2. [in] names - An object defining the frame curves names. [out] result - The frame with the constructed curves.
Returns
Returns operation result code.

◆ ConnectingSpline()

 MbResultType ConnectingSpline ( const MbCurve3D & curve1, double t1, MbeMatingType mating1, const MbCurve3D & curve2, double t2, MbeMatingType mating2, double tension1, double tension2, const MbSNameMaker & names, MbWireFrame *& result )

Create a connecting NURBS curve for curves 'curve1' and 'curve2'.

Create a connecting NURBS curve for curves 'curve1' and 'curve2'.
t1 and t2 are parameters of curves 'curve1' and 'curve2' which correspond to the start point and the end point of the connecting curve.

Parameters
 [in] curve1 - A curve 1 to be connected. [in] t1 - A point parameter on curve 1. [in] mating1 - The connection type for curve 1. [in] curve2 - A curve 2 to be connected. [in] t2 - A point parameter on curve 2. [in] mating2 - The connection type for curve 2. [in] tension1 - The "tension" parameter of the connecting curve at the intersection with the curve 1 (0 <= tension1 <=1). [in] tension2 - The "tension" parameter of the connecting curve at the intersection with the curve 2 (0 <= tension2 <=1). [in] names - An object defining the frame curves names. [out] result - The frame with the constructed curves.
Returns
Returns operation result code.

◆ FilletCurve()

 MbResultType FilletCurve ( const MbCurve3D & curve1, double & t1, double & w1, const MbCurve3D & curve2, double & t2, double & w2, double & radius, bool sense, bool & unchanged, const MbeConnectingType type, const MbSNameMaker & names, MbElementarySurface *& surface, MbWireFrame *& result )

Create a fillet curve for curves.

Create a fillet curve for curves.
Curve 'filletCurve' is created for smooth connection of curves 'curve1' and 'curve2'.
On input t1 and t2 are the initial estimations which determine a sector for fillet construction, w1 and w2 are not used.
On input 'type' is a fillet type (ordinary or on a surface).
On output t1 and t2 are the parameters of touching of curves 'curve1' and 'curve2' with curve 'filletCurve'.
On output t1 and w1 determines parameters of a part to be kept while trimming curve1.
On output t2 and w2 determines parameters of a part to be kept while trimming curve2.
If radius 'radius' is not defined (equal to zero), it is computed from the condition that the fillet curve start is at the point with parameter t1, t1 and t2 are parameters of curves 'curve1' and 'curve2' which correspond to the start point and the end point of the fillet.
Parameter 'sense' determines forward or backward orientation of the fillet curve.
Curve filletCurve is a fillet curve, an arc (when 'surface' == nullptr) or a curve on a cylindric surface 'surface'.
Surface 'surface' is a cylindric surface on which the fillet curve is constructed in general case. Use ::AddRefItem(surface) and ::ReleaseItem(surface) methods to manage the surface lifecycle.

Parameters
 [in] curve1 - A curve 1 to be connected. [in,out] t1 - A point parameter on curve 1 of connection with fillet curve. [out] w1 - The parameter of curve 1 end point. [in] curve2 - A curve 2 to be connected. [in,out] t2 - A point parameter on curve 2 of connection with fillet curve. [out] w2 - The parameter of curve 2 end point. [in,out] radius - The radius of an arc or a cylinder. [in] sense - The forward (true) or the backward (false) direction of the fillet curve. [out] unchanged - The fillet radius has not changed (true) or has changed (false). [in] type - The fillet type. [in] names - An object defining the frame curves names. [out] surface - A surface on which the fillet curve is based on, it will be created by the method (can be nullptr). [out] result - The frame with the constructed curves.
Returns
Returns operation result code.

◆ CreateContourFillets()

 MbResultType CreateContourFillets ( const MbContour3D & contour, SArray< double > & radiuses, MbCurve3D *& result, const MbeConnectingType type )

Create a curve for fillet of all the curves of a contour.

Create a curve for fillet of all the curves of a contour 'contour'.
'type' is a fillet type (ordinary or on a surface).
'radiuses' are the fillet radii, the i-th radius corresponds to the joint of the i-th and the i+1-th segments.
If two curves in contours are smoothly connected, the fillet is not created at this joint, the radius is ignored.

Parameters
 [in] contour - The initial contour. [in] radiuses - An array of fillet radii. [out] result - The contour with the fillets. The name of the fillet segment - Hash32SN() of initial segments names. [in] type - The type of fillets.
Returns
Returns operation result code.

◆ CurvesWrapping() [1/2]

 MbResultType CurvesWrapping ( const MbCurvesWrappingParams & parameters, c3d::PlaneCurvesSPtrVector & surfaceCurves )

Construct curves that wrap the surface.

Construction of curves that wrap the surface.

Parameters
 [in] parameters - Parameters MbCurvesWrappingParams for transferring copies of two-dimensional curves on another medium. [out] surfaceCurves - Constructed 2d-curves.
Returns
Returns operation result code.
Deprecated:
The method is deprecated.

◆ CurvesWrapping() [2/2]

 MbResultType CurvesWrapping ( const MbCurvesWrappingParams & parameters, c3d::SpaceCurvesSPtrVector & resultCurves )

Construct curves that wrap the surface.

Construction of curves that wrap the surface.

Parameters
 [in] parameters - Parameters MbCurvesWrappingParams for transferring copies of two-dimensional curves on another medium. [out] resultCurves - Constructed 3d-curves based on the input surface.
Returns
Returns operation result code.
Deprecated:
The method is deprecated.

◆ CurvesUnwrapping() [1/2]

 MbResultType CurvesUnwrapping ( const MbCurvesWrappingParams & params, c3d::PlaneCurvesSPtrVector & surfaceCurves )

Construct a unwrapping curve/contour.

Construction unwrapping of the curve/contour on a plane.

Parameters
 [in] params - Unwrapping parameters MbCurvesWrappingParams. [in] resultCurves - Unwrapped 2d-curves.
Returns
Returns operation result code.
Deprecated:
The method is deprecated.

◆ CurvesUnwrapping() [2/2]

 MbResultType CurvesUnwrapping ( const MbCurvesWrappingParams & parameters, c3d::SpaceCurvesSPtrVector & resultCurves )

Construct a unwrapping curve/contour.

Construction unwrapping of the curve/contour on a plane.

Parameters
 [in] params - Unwrapping parameters MbCurvesWrappingParams. [in] resultCurves - Unwrapped 3d-curves on the input plane.
Returns
Returns operation result code.
Deprecated:
The method is deprecated.

◆ MakeCurveOnSurface()

 MbCurve3D* MakeCurveOnSurface ( const MbFace & face, const std::vector< const MbCurveEdge * > & edges, double accuracy )

Construct a curve or contour on the surface of a face along the specified edges.

A curve or contour is constructed on the surface of a face based on copies of the corresponding two-dimensional curves lying in the intersection curves of edges.

Parameters
 [in] face - The face common to the edges. [in] edges - The edges. [in] accuracy - The maximum distance of segment points at the junction.
Returns
Returns a curve or contour on a surface (nullptr - in case of failure).

◆ FairCurve() [1/4]

 MbResultType FairCurve ( const MbFairCurveParams & initParams, const MbFairCurveMethod & method, const MbFairCreateData & curveData, MbFairCurveResult & result )

Construct a fair curve of the specified type according to the specified parameters.

Construct a fair curve of the specified type according to the specified parameters.

Parameters
 [in] initParams - An initial curve data. [in] method - Method of a curve construction. [in] curveData - Parameters of a curve construction. [out] result - The result curve with approximation error data.
Returns
Returns operation result code.
Warning
Under development.

◆ FairCurve() [2/4]

 MbResultType FairCurve ( const MbFairCurveParams & initParams, const MbFairFilletData & curveData, MbFairCurveResult & result )

Construct a fair fillet curve.

Construct a fair fillet curve according to the specified parameters.

Parameters
 [in] initParams - An initial curve data. [in] curveData - Parameters of a curve construction. [out] result - The result curve with approximation error data.
Returns
Returns operation result code.
Warning
Under development.

◆ FairCurve() [3/4]

 MbResultType FairCurve ( const MbFairCurveParams & initParams, const MbFairCurveMethod & method, const MbFairChangeData & changeData, c3d::WireFrameSPtr & result )

Change a fair curve.

Change a fair curve by the specified method.

Parameters
 [in] initParams - An initial curve data. [in] method - Method of a curve change. [in] changeData - Changing parameters. [out] result - The result curve with approximation error data.
Returns
Returns operation result code.
Warning
Under development.

◆ FairCurve() [4/4]

 MbResultType FairCurve ( const MbClothoidParams & parameters, const MbSNameMaker & snMaker, c3d::WireFrameSPtr & result )

Creating a clothoid.

Creating a clothoid.

Parameters
 [in] parameters - Parameters of a curve construction. [in] snMaker - An object defining the frame curves names. [out] result - The frame with the constructed curve.
Returns
Returns operation result code.
Warning
Under development.

◆ NurbsConic_1()

 MbCurve3D* NurbsConic_1 ( const MbCartPoint3D & mbPoint0, const MbCartPoint3D & mbPoint1, const MbCartPoint3D & mbPoint2, double fDiscr )

Construct a conic section by two points, an angle vertex and a discriminant.

Construction of a conic section as a NURBS curve of the third degree by two points setting ends of a curve, a vertex of enginer triangle and a discriminant which is used for the definition of the third point.

Parameters
 [in] mbPoint0 - Coordinates of the conic start point. [in] mbPoint1 - Coordinates of the vertex of angle which should be inscribed into the conic. [in] mbPoint2 - Coordinates of the conic end point. [in] fDiscr - The discriminant is less than 1. Otherwise it will be set to 0.99999999 automatically.
Returns
The pointer to the constructed curve
is nullptr if a try to construct a conic for a given parameters has failed.

◆ NurbsConic_2()

 MbCurve3D* NurbsConic_2 ( std::vector< MbCartPoint3D > & vmbConicPoints, const MbCartPoint3D & mbVertex )

Construct a conic section by three points, and an angle vertex.

Construction of a conic section as a NURBS curve of the third degree by three points: ends of a curve, its average point and by a vertex of an angle, a conic should be inscribed in.

Parameters
 [in] vmbConicPoints - The container for points of a conic: start point, average point and end point; there should be exactly 3 points. [in] mbVertex - Coordinates of the vertex of angle which should be inscribed into the conic.
Returns
The pointer to the constructed curve
is nullptr if a try to construct a conic for given parameters has failed.

◆ NurbsConic_3()

 MbCurve3D* NurbsConic_3 ( const std::vector< MbCartPoint3D > & vmbConicPoints, MbVector3D & mbTangent1, MbVector3D & mbTangent2 )

Construct a conic section by three points and two inclinations.

Construction of a conic section as a NURBS curve of the third degree by 3 points setting begin, end and an average point of a curve and two inclinations outgoing from the start point and from the end point

Parameters
 [in] vmbConicPoints - The container for points of a conic: start point, average point and end point; there should be exactly 3 points. [in] mbTangent1 - Inclination at start of a curve. [in] mbTangent2 - Inclination at end of a curve.
Returns
The pointer to the constructed curve
is nullptr if a try to construct a conic for given parameters has failed.

◆ NurbsConic_4()

 MbCurve3D* NurbsConic_4 ( const MbCartPoint3D & mbPoint1, const MbCartPoint3D & mbPoint2, const MbVector3D & mbTangent1, const MbVector3D & mbTangent2, double fDiscr )

Construct a conic section by two points, two inclinations and a discriminant.

Construction of a conic section as a NURBS curve of the third degree by 2 points setting start and end of a curve, two incllinations outgoing from these points and a discriminant.

Parameters
 [in] mbPoint1 - Coordinates of the conic start point. [in] mbPoint2 - Coordinates of the conic end point. [in] mbTangent1 - Inclination at start of conic. [in] mbTangent2 - Inclination at end of conic. [in] fDiscr - The discriminant is less than 1. Otherwise it will be set to 0.99999999 automatically.
Returns
The pointer to the constructed curve
is nullptr if a try to construct a conic for given parameters has failed.

◆ NurbsConic_5()

 MbCurve3D* NurbsConic_5 ( const std::vector< MbCartPoint3D > & vmbConicPoints, MbVector3D & mbTangent1, size_t tanPntNb = `1` )

Construct a conic section by four points, and an inclination.

Construction of a conic section as a NURBS curve of the third degree by 4 points and inclination in the first of them.
By substituting of start points in the common equation of the conic Ax^2 + Bxy + Cy^2 + Dx + Ey + F = 0 and its tangent at the start point (x1, y1): (2Ax1 + By1 + D)(x - x1) + (2Cy1 + Bx1 + E)(y - y1) = 0 we get the SLAE. Having SLAE solved relative to parameters A,B,C,D,E we find the required conic.

Parameters
 [in] vmbConicPoints - The container for points of a conic: the first point is start point, the last point is end point. there should be exactly 4 points. [in] mbTangent1 - Inclination at point of conic. [in] tanPntNb - Point number at which the inclination is specified.
Returns
The pointer to the constructed curve
is nullptr if a try to construct a conic for given parameters has failed.

◆ NurbsConic_6()

 MbCurve3D* NurbsConic_6 ( const std::vector< MbCartPoint3D > & vmbConicPoints )

Construct a conic section by five points.

Construction of a conic section as a NURBS curve of the third degree by 5 points.
By substituting of start points in the common equation of the conic Ax^2 + Bxy + Cy^2 + Dx + Ey + F = 0 we get the SLAE. Having SLAE solved relative to parameters A,B,C,D,E we find the required conic.

Parameters
 [in] vmbConicPoints - The container for points of a conic: the first point is start point, the last point is end point. there should be exactly 5 points.
Returns
The pointer to the constructed curve
is nullptr if a try to construct a conic for given parameters has failed.

◆ InitContour3D()

 bool InitContour3D ( MbContour3D & contour, bool closed, SArray< Polyline3DPoint > & initList, SArray< ptrdiff_t > & errorIndexes, double lengthEpsilon = `Math::lengthEpsilon` )

Construct a contour from segments by given points.

Vertices of joint are rounded. Some fillet radius corresponds to every vertex.
If two vertices are coincident then one of them and the corresponding radius are deleted.

Parameters
 [out] contour - The countour. [in] closed - Whether the contour is closed. [in] initList - The array of points of a polyline. [out] errorIndexes - The array of segments indices, each of which has been jointed with the next one with errors. [in] lengthEpsilon - The tolerance of polyline elements construction.
Returns
true if the number of segments is greater than zero.

◆ CreateBeamCurves()

 c3d::CreatorSPtr CreateBeamCurves ( const MbSolid & sourceSolid, const MbBeamElementParams & parameters, MbResultType & res, MbBeamElementResults & result )

Create a constructor of beam curve.

Create a constructor of beam curve.

Parameters
 [in] sourceCurve - Source solid. [in] parameters - Input parameters. [in] names - An object defining the wireframe names. [out] res - Operation result code. [out] result - Output parameters.
Returns
Returns the constructor.
Warning
Under development.

◆ CreateFilletEdge()

 MbCreator* CreateFilletEdge ( const MbCurve3D & curve1, double & t1, const MbCurve3D & curve2, double & t2, double & radius, bool sense, MbeConnectingType type, const MbSNameMaker & names, MbResultType & res, bool & unchanged, MbElementarySurface *& surface, MbEdge *& edge )

Create two curves fillet constructor.

Create two curves fillet constructor.

Parameters
 [in] curve1 - Curve 1. [in,out] t1 - A point parameter on curve 1 of connection with fillet curve. [in] curve2 - Curve 2. [in,out] t2 - A point parameter on curve 2 of connection with fillet curve. [in,out] radius - The radius of an arc or a cylinder. [in] type - The fillet type. [in] names - An object defining the edges names. [out] res - Operation result code. [out] surface - A surface on which the fillet curve is based on, it will be created by the method (can be nullptr). [out] edge - The constructed conjugation edge.
Returns
Returns the constructor.

◆ CreateSplineEdge()

 MbCreator* CreateSplineEdge ( const MbCurve3D & curve1, double t1, MbeMatingType mating1, const MbCurve3D & curve2, double t2, MbeMatingType mating2, double tension1, double tension2, const MbSNameMaker & names, MbResultType & res, MbEdge *& edge )

Create constructor of two curves connection by a spline.

Create constructor of two curves connection by a spline.

Parameters
 [in] curve1 - Curve 1. [in] curve2 - Curve 2. [out] edge - The constructed conjugation edge.
Returns
Returns the constructor.

◆ CreateConnectingEdge()

 MbCreator* CreateConnectingEdge ( const MbCurve3D & curve1, bool isBegin1, double radius1, const MbCurve3D & curve2, bool isBegin2, double radius2, const MbSNameMaker & names, MbResultType & res, MbEdge *& edge )

Create a constructor of conjugation of two curves end points by a composite curve of smooth connection.

Create a constructor of conjugation of two curves end points by a composite curve of smooth connection.

Parameters
 [in] curve1 - Curve 1. [in] curve2 - Curve 2. [out] edge - The constructed conjugation edge.
Returns
Returns the constructor.

◆ CreateBridgeEdge()

 MbCreator* CreateBridgeEdge ( const MbCurve3D & curve1, double t1, bool sense1, const MbCurve3D & curve2, double t2, bool sense2, const MbSNameMaker & names, MbResultType & res, MbEdge *& edge )

Create a constructor of two curves conjugation by a cubic Hermite spline (transition curve).

Create a constructor of two curves conjugation by a cubic Hermite spline (transition curve).

Parameters
 [in] curve1 - Curve 1. [in] curve2 - Curve 2. [out] edge - The constructed conjugation edge.
Returns
Returns the constructor.

◆ CreateExtendedCurve()

 c3d::CreatorSPtr CreateExtendedCurve ( const MbCurve3D & sourceCurve, const MbCurveExtensionParameters3D & parameters, MbResultType & res, c3d::SpaceCurveSPtr & resCurve )

Create a constructor of extending curve.

Create a constructor of extending curve.

Parameters
 [in] sourceCurve - Source (extended) curve. [in] parameters - Parameters of the operation. [out] res - Operation result code. [out] resCurve - The curve returned (extended). Can be nullptr.
Returns
Returns the constructor.

◆ CreateFairCurve() [1/4]

 c3d::CreatorSPtr CreateFairCurve ( const MbCurve3D & sourceCurve, const MbFairCurveMethod & method, const MbFairCreateData & parameters, const MbSNameMaker & snMaker, MbFairCreatorResult & result )

Create a fair curve.

Create a fair curve.

Parameters
 [in] sourceCurve - An initial curve. [in] method - Method of a curve construction. [in] parameters - Construction parameters. [in] snMaker - An object defining curves names. [out] res - Operation result code. [out] errInfo - Approximation error information. [out] resCurve - The result.
Returns
Returns the constructor.
Warning
Under development.

◆ CreateFairCurve() [2/4]

 c3d::CreatorSPtr CreateFairCurve ( const MbCurve3D & sourceCurve, const MbFairCurveMethod & method, const MbFairChangeData & parameters, const MbSNameMaker & snMaker, MbFairCreatorResult & result )

Changing a fair curve.

Changing a fair curve.

Parameters
 [in] sourceCurve - An initial curve. [in] parameters - Changing parameters. [in] method - Method of a curve changing. [in] snMaker - An object defining curves names. [out] res - Operation result code. [out] resCurve - The result.
Returns
Returns the constructor.
Warning
Under development.

◆ CreateFairCurve() [3/4]

 c3d::CreatorSPtr CreateFairCurve ( const MbCurve3D & sourceCurve, const MbFairFilletData & parameters, const MbSNameMaker & snMaker, MbFairCreatorResult & result )

Creating a fair fillet curve.

Creating a fair fillet curve.

Parameters
 [in] sourceCurve - An initial curve. [in] parameters - Construction parameters. [in] snMaker - An object defining curves names. [out] res - Operation result code. [out] resCurve - The result.
Returns
Returns the constructor.
Warning
Under development.

◆ CreateFairCurve() [4/4]

 c3d::CreatorSPtr CreateFairCurve ( const MbClothoidParams & parameters, const MbSNameMaker & snMaker, MbFairCreatorResult & result )

Creating a clothoid.

Creating a clothoid.

Parameters
 [in] parameters - Creation parameters. [in] snMaker - An object defining curves names. [out] res - Operation result code. [out] resCurve - The result.
Returns
Returns the constructor.
Warning
Under development.

◆ CreateFillet()

 MbCreator* CreateFillet ( MbFaceShell * solid, MbeCopyMode sameShell, const MbShellFilletValues & filletParams, MbResultType & res, c3d::ShellSPtr & shell, IProgressIndicator * progInd = `nullptr` )

Create a shell with edges fillet.

For a given shell create a shell with edges fillet.
The function simultaneously creates the shell and its constructor. The way of creating a fillet is determined by a set of parameters in filletParams:

• Fillet the specified edges of the solid with a constant radius.
• Create fillets on vertices and the edges of the solid adjacent to these vertices with a constant radius. Three edges must be incident to each vertex.
• Fillet the given edges of the solid with a variable radius specified by MbEdgeFunction.function. The parameters of the cross-section can vary by the specified law.
Parameters
 [in] solid - The source shell. [in] sameShell - Method of copying the source shell faces. [in] filletParams - The operation parameters. [out] res - Operation result code. [out] shell - Constructed set of faces.
Returns
Returns the constructor if the operation has been successfully performed.

◆ CreateSplineThrough()

 MbCreator* CreateSplineThrough ( const SArray< MbCartPoint3D > & points, MbeSplineParamType paramType, size_t degree, bool closed, RPArray< c3d::PntMatingData3D > & transitions, const MbSNameMaker & snMaker, MbResultType & resType, MbCurve3D *& resCurve )

Create a spatial spline through points and with the given tangents.

Create a spatial spline through points with tangents If the tangents are specified, then the number of tangents should be equal to the number of points. The missing tangents should be represented as the null pointers in the array.

Returns
Returns the constructor.

◆ CreateSplineBy()

 MbCreator* CreateSplineBy ( const SArray< MbCartPoint3D > & points, size_t degree, bool closed, const SArray< double > * weights, const SArray< double > * knots, c3d::PntMatingData3D * begData, c3d::PntMatingData3D * endData, const MbSNameMaker & snMaker, MbResultType & resType, MbCurve3D *& resCurve )

Create a spatial spline from points and tangents.

Create a spatial spline from points and tangents.

Returns
Returns the constructor.

◆ CreateOffsetCurve() [1/2]

 MbCreator* CreateOffsetCurve ( const MbCurve3D & initCurve, const MbSpatialOffsetCurveParams & params, MbResultType & resType, MbCurve3D *& resCurve )

Create an offset curve from three-dimensional curve and direction.

Create an offset curve in space from three-dimensional curve and direction.

Parameters
 [in] initCurve - A space curve for which to construct the offset curve. [in] params - Parameters. [out] resType - Operation result code [out] resCurve - The offset curve.
Returns
Returns the constructor.

◆ CreateOffsetCurve() [2/2]

 MbCreator* CreateOffsetCurve ( const MbCurve3D & curve, const MbSurfaceOffsetCurveParams & params, MbResultType & resType, RPArray< MbCurve3D > & resCurves )

Create an offset curve from a spatial curve and offset value.

Create an offset curve from a spatial curve and offset value.

Parameters
 [in] curve - A curve on face 'face' surface. [in] params - Parameters. [out] resType - Operation result code [out] resCurves - Offset curve array.
Returns
Returns the constructor.

◆ CreateSurfaceSpline()

 MbCreator* CreateSurfaceSpline ( const MbSurface & surface, bool throughPoints, SArray< MbCartPoint > & paramPnts, SArray< double > & paramWts, bool paramClosed, RPArray< c3d::PntMatingData3D > & spaceTransitions, const MbSNameMaker & snMaker, MbResultType & resType, RPArray< MbCurve3D > & resCurves )

Create a curve on a surface.

Create a curve on a surface.
Notes:

1. If the tangents are specified, then the number of tangents should be equal to the number of points.
Missing tangents should be represented by null pointers in the array
2. If the spline is created from points, arbitrary tangents can be defined.
1. If the spline is created from poles and it is open, only the end tangents can be specified.
2. If the spline is constructed from poles and it is closed, the tangents cannot be specified.
3. The weight array should be empty or synchronized with the point array by size (with option throughPoints the weights are ignored).
Parameters
 [in] surface - The surface. [in] throughPoints - Create a spline through points. [in] paramPnts - Parametric point array. [in] paramWts - An array of parametric point weights. [in] paramClosed - Create a closed parametric spline. [in] spaceTransitions - Tangents at the points. [in] snMaker - An object defining the frame curves names. [out] resType - Operation result code [out] resCurves - Offset curve array.
Returns
Returns the constructor.

◆ CreateUnwrappedCurve()

 c3d::CreatorSPtr CreateUnwrappedCurve ( const MbCurvesWrappingParams & parameters, MbResultType & res, c3d::WireFrameSPtr & resWire )

Create a constructor of unwrapped curve.

Create a constructor of unwrapped curve. It is expected to receive as input 1 curve or an array of connected curves. Otherwise the correct unwrapping is not guaranteed.

Parameters
 [in] parameters - Parameters of the operation. [out] res - Operation result code. [out] resWire - The unwrapped curve. Can be nullptr.
Returns
Returns the creator.
Deprecated:
The method is deprecated.

◆ CreateWrappedCurve()

 c3d::CreatorSPtr CreateWrappedCurve ( const MbCurvesWrappingParams & parameters, MbResultType & res, c3d::WireFrameSPtr & resWire )

Create a constructor of wrapped curve.

Create a constructor of wrapped curve. It is expected to receive as input 1 curve or an array of connected curves. Otherwise the correct wrapping is not guaranteed.

Parameters
 [in] parameters - Parameters of the operation. [out] res - Operation result code. [out] resWire - Wrapped curves wireframe. Can be nullptr.
Returns
Returns the creator.
Deprecated:
The method is deprecated.

◆ MakeCurve3D()

 MbCurve3D* MakeCurve3D ( const MbCurve & curve, const MbPlacement3D & )

Create a spatial curve.

Create a spatial curve as an accurate representation of the two-dimensional uv-curve on the plane.

◆ ApproximatePolylineByNurbs()

 MbResultType ApproximatePolylineByNurbs ( const MbApproxNurbsParameters< MbCartPoint3D, MbVector3D, MbNurbs3D > & param, MbApproxNurbsCurveResult< MbNurbs3D > & result )

Approximate 3D points by NURBS curve.

IApproximate points by NURBS curve.

Parameters
 [in] param - Parameters for approximation. [out] result - Operation result.
Returns
Error code.
Warning
Under development.

◆ ExtractCurves()

template<class CurvesVector >
 void ExtractCurves ( c3d::WireFrameSPtr & wireFrame, CurvesVector & curves )

Extract curves.

Extract curves, removing from wireframe.

Parameters
 [in] wireFrame - A frame. [out] curves - Curves obtained from the frame.

◆ ExtractCurvesDeleteFrame()

template<class CurvesVector >
 void ExtractCurvesDeleteFrame ( MbWireFrame *& wireFrame, CurvesVector & curves )

Take curves and delete a frame if it is not used.

Take curves and delete a frame if it is not used.

Parameters
 [in] wireFrame - A frame to delete. [out] curves - Curves obtained from the frame.

◆ ExtractCurveDeleteFrame()

 void ExtractCurveDeleteFrame ( MbWireFrame *& wireFrame, MbCurve3D *& curve )
inline

Take the first curve and delete a frame if it is empty and not used.

Take the first curve and delete a frame if it is empty and not used.

Parameters
 [in] wireFrame - A frame to delete. [out] curve - A curve obtained from the frame.

◆ CreateWireFrame() [1/4]

 bool CreateWireFrame ( MbWireFrame *& result, const RPArray< MbCurve3D > & curves, const MbSNameMaker & snMaker, const MbCreator * creator = `nullptr` )

Create a frame by a set of curves.

Create or update a frame by a set of curves.

Parameters
 [out] result - A frame to replace or construct. [in] curves - Curves for the frame construction. [in] snMaker - An object defining the frame curves names. [in] creator - A creator of a frame.
Returns
Returns true if the sent frame has been updated or if the new frame has been created without a frame in the input.

◆ CreateWireFrame() [2/4]

 bool CreateWireFrame ( MbWireFrame *& result, const MbCurve3D & curve, const MbSNameMaker & snMaker, const MbCreator * creator = `nullptr` )

Create a frame by a curve.

Create or update a frame by a curve.

Parameters
 [out] result - A frame to replace or construct. [in] curve - A curve for the frame construction. [in] snMaker - An object defining the frame curves names. [in] creator - A creator of a frame.
Returns
Returns true if the sent frame has been updated or if the new frame has been created without a frame in the input.

◆ CreateWireFrame() [3/4]

 bool CreateWireFrame ( const MbCurve3D & curve, const MbSNameMaker & snMaker, c3d::WireFrameSPtr & result, const c3d::CreatorSPtr & creator = `nullptr` )

Create a frame by a curve.

Create or update a frame by a curve.

Parameters
 [in] curve - A curve for the frame construction. [in] snMaker - An object defining the frame curves names. [out] result - A frame to replace or construct. [in] creator - A creator of a frame.
Returns
Returns true if the sent frame has been updated or if the new frame has been created without a frame in the input.

◆ CreateWireFrame() [4/4]

 bool CreateWireFrame ( const c3d::SpaceCurvesSPtrVector & curves, const MbSNameMaker & snMaker, c3d::WireFrameSPtr & result, const c3d::CreatorSPtr & creator = `nullptr` )

Create a frame by a set of curves.

Create or update a frame by a set of curves.

Parameters
 [in] curves - Curves for the frame construction. [in] snMaker - An object defining the frame curves names. [out] result - A frame to replace or construct. [in] creator - A creator of a frame.
Returns
Returns true if the sent frame has been updated or if the new frame has been created without a frame in the input.