GeNurbCurve3d.h

Go to the documentation of this file.

// Copyright (C) 2002-2017, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2017 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
#ifndef OD_GENURB3D_H
#define OD_GENURB3D_H 
class OdGeEllipArc3d;
class OdGeLineSeg3d;
class OdGePolyline3d;
class OdGeKnotVector;
class OdGeNurbCurve3dImpl;
 
#include "Ge/GeSplineEnt3d.h"
#include "OdPlatformSettings.h"
 
#include "TD_PackPush.h"
 
class GE_TOOLKIT_EXPORT OdGeNurbCurve3d : public OdGeSplineEnt3d
{
public:
 
 
  OdGeNurbCurve3d();
  OdGeNurbCurve3d(
    const OdGeNurbCurve3d& source);
  OdGeNurbCurve3d(
    int degree,
    const OdGeKnotVector& knots,
    const OdGePoint3dArray& controlPoints,
    bool isPeriodic = false);
  OdGeNurbCurve3d(
    int degree,
    const OdGeKnotVector& knots,
    const OdGePoint3dArray& controlPoints,
    const OdGeDoubleArray& weights,
    bool isPeriodic = false);
  // TD Special
  OdGeNurbCurve3d(
    int degree,
    const OdGeKnotVector& knots,
    const OdGePoint3d* controlPoints,
    OdUInt32 numControlPoints,
    const double* weights,
    OdUInt32 numWeights,
    bool isPeriodic = false);
  //
  OdGeNurbCurve3d(
    int degree, 
    const OdGePolyline3d& fitPolyline,
    bool isPeriodic = false);
  OdGeNurbCurve3d(
    const OdGePoint3dArray& fitPoints,
    const OdGeVector3d& startTangent,
    const OdGeVector3d& endTangent,
    bool startTangentDefined = true,
    bool endTangentDefined = true,
    const OdGeTol& fitTol = OdGeContext::gTol);
  OdGeNurbCurve3d(
    const OdGePoint3dArray& fitPoints,
    const OdGeTol& fitTolerance = OdGeContext::gTol);
  OdGeNurbCurve3d(
    const OdGePoint3dArray& fitPoints,
    const OdGeVector3dArray& fitTangents,
    const OdGeTol& fitTolerance = OdGeContext::gTol,
    bool isPeriodic = false);
 
  OdGeNurbCurve3d(
    const OdGePoint3dArray& fitPoints, 
    const OdGeVector3d& startTangent, 
    const OdGeVector3d& endTangent,
    bool startTangentDefined,
    bool endTangentDefined,
    OdGeKnotParameterization knotParam,
    const OdGeTol& fitTolerance = OdGeContext::gTol);
  // numSpans - the number of knot spans in nurbs curve
  // if numSpans == 0 (default) it is automatically calculated from 
  // ellipse domain
 
 
  OdGeNurbCurve3d(
    const OdGeEllipArc3d& ellipse, 
    int numSpans = 0);
 
  OdGeNurbCurve3d(
    const OdGeLineSeg3d& lineSeg);
 
   int numFitPoints() const;
 
   bool getFitKnotParameterization(OdGeKnotParameterization& knotParam) const;
 
   bool getFitPointAt(
    int fitPointIndex, 
    OdGePoint3d& point) const;
 
   bool getFitTolerance(
    OdGeTol& fitTolerance) const;
 
   bool getFitTangents(
    OdGeVector3d& startTangent,
    OdGeVector3d& endTangent) const;
 
  bool getFitTangents(
    OdGeVector3d& startTangent,
    OdGeVector3d& endTangent,
    bool& startTangentDefined,
    bool& endTangentDefined) const;
 
   bool getFitData(
    OdGePoint3dArray& fitPoints,
    OdGeTol& fitTolerance,
    bool& tangentsExist,
    OdGeVector3d& startTangent,
    OdGeVector3d& endTangent) const;
 
   bool  getFitData(
     OdGePoint3dArray& fitPoints,
     OdGeTol& fitTolerance,
     bool& tangentsExist,
     OdGeVector3d& startTangent, 
     OdGeVector3d& endTangent,
     OdGeKnotParameterization& knotParam) const;
 
  // NURBS data query functions
 
   void getDefinitionData(
    int& degree,
    bool& rational,
    bool& periodic,
    OdGeKnotVector& knots,
    OdGePoint3dArray& controlPoints,
    OdGeDoubleArray& weights) const;
 
   int numWeights() const;
 
   double weightAt(
    int weightIndex) const;
 
   bool evalMode() const;
 
   bool getParamsOfC1Discontinuity(
    OdGeDoubleArray& params,
    const OdGeTol& tol = OdGeContext::gTol) const;
 
   bool getParamsOfG1Discontinuity(
    OdGeDoubleArray& params,
    const OdGeTol& tol = OdGeContext::gTol) const;
 
  // Fit data edit functions
 
   bool setFitPointAt(
    int fitPointIndex, 
    const OdGePoint3d& point);
 
   bool addFitPointAt(
    int fitPointIndex, 
    const OdGePoint3d& point);
 
   bool addControlPointAt(double newKnot, const OdGePoint3d& point, double weight = 1.0);
 
   bool deleteControlPointAt(int index);
 
   bool deleteFitPointAt(
    int fitPointIndex);
 
   bool setFitKnotParameterization(OdGeKnotParameterization knotParam);
 
   bool setFitTolerance(
    const OdGeTol& fitTol = OdGeContext::gTol);
 
   bool setFitTangents(
    const OdGeVector3d& startTangent,
    const OdGeVector3d& endTangent);
 
  bool setFitTangents(
    const OdGeVector3d& startTangent,
    const OdGeVector3d& endTangent,
    bool startTangentDefined,
    bool endTangentDefined);
 
  OdGeNurbCurve3d& setFitData(
    const OdGePoint3dArray& fitPoints,
    const OdGeVector3d& startTangent,
    const OdGeVector3d& endTangent,
    const OdGeTol& fitTol = OdGeContext::gTol);
 
  OdGeNurbCurve3d& setFitData(
    const OdGeKnotVector& fitKnots,
    const OdGePoint3dArray& fitPoints,
    const OdGeVector3d& startTangent,
    const OdGeVector3d& endTangent,
    const OdGeTol& fitTol = OdGeContext::gTol,
    bool isPeriodic = false);
 
    
   OdGeNurbCurve3d& setFitData(
    int degree,
    const OdGePoint3dArray& fitPoints,
    const OdGeTol& fitTol = OdGeContext::gTol);
 
   OdGeNurbCurve3d& setFitData(
     const OdGePoint3dArray& fitPoints,                                             
     const OdGeVector3d& startTangent, 
     const OdGeVector3d& endTangent,
     OdGeKnotParameterization knotParam,
     const OdGeTol& fitTol = OdGeContext::gTol);
 
  
   bool purgeFitData();
 
   OdGeNurbCurve3d& addKnot(double newKnot);
 
 
   OdGeNurbCurve3d& insertKnot(double newKnot);
 
   OdGeSplineEnt3d& setWeightAt(
    int fitPointIndex, 
    double weight);
 
   OdGeNurbCurve3d& setEvalMode(
    bool evalMode = false);
 
   OdGeNurbCurve3d& joinWith(
    const OdGeNurbCurve3d& curve);
 
   OdGeNurbCurve3d& hardTrimByParams(
    double newStartParam,
    double newEndParam);
 
   OdGeNurbCurve3d& makeRational(
    double weight = 1.0);
 
   OdGeNurbCurve3d& makeClosed();
 
   OdGeNurbCurve3d& makePeriodic();
 
   OdGeNurbCurve3d& makeNonPeriodic();
 
   OdGeNurbCurve3d& makeOpen();
 
  OdGeNurbCurve3d& elevateDegree(int plusDegree);
 
  // Assignment operator.
  OdGeNurbCurve3d& operator =(
    const OdGeNurbCurve3d& spline);
 
  // TD Special :
 
  TD_USING(OdGeSplineEnt3d::evalPoint);
 
  // This is only for internal use
   OdGePoint3d evalPoint(
    double param, 
    int hint) const;  
 
  // This is need in surface (for rational case only)
  void evalPointDivider(
    double param, 
    OdGePoint3d& point, 
    double& divider, 
    int hint) const;
 
  // NURBS data edit functions
  
   void set(
    int degree,
    const OdGeKnotVector& knots,
    const OdGePoint3dArray& controlPoints,
    const OdGeDoubleArray& weights,
    bool isPeriodic = false);
 
   bool buildFitData(OdGeKnotParameterization knotParam = OdGe::kChord);
 
//FELIX_CHANGE_BEGIN
   static OdGeNurbCurve3d* convertFrom(const OdGeCurve3d* source, const OdGeTol& tol = OdGeContext::gTol, bool sameParametrization = false);
//FELIX_CHANGE_END
   
protected:
   bool modifyPositionAndTangent(double param, const OdGePoint3d& point, const OdGeVector3d* deriv);
   void makeClosedFit();
   
protected:
 
  void setData(int degree, const OdGePoint3dArray& controlPoints, const OdGeKnotVector& knots, const OdGeDoubleArray& weights
    , const OdGePoint3dArray& fitPoints, const OdGeVector3d& startTangent, const OdGeVector3d& endTangent
    , bool isStartTangentDefined, bool isEndTangentDefined, bool isPeriodic, const OdGeTol& fitTol);
 
   void setKnotTolerance(double tol);
};
 
GE_TOOLKIT_EXPORT OdGeNurbCurve3d* convertFrom( const OdGeCurve3d* source, const OdGeTol& tol = OdGeContext::gTol, bool sameParametrization = false );
 
#include "TD_PackPop.h"
 
#endif // OD_GENURB3D_H