/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2016, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2016 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////

#ifndef _OD_GECURVE3D_H_
#define _OD_GECURVE3D_H_ /*!DOM*/

#include "Ge/GeEntity3d.h"
#include "Ge/GeDoubleArray.h"
#include "Ge/GeVector3dArray.h"
#include "Ge/GeCurve3dPtrArray.h"
#include "Ge/GeIntArray.h"
#include "Ge/GeInterval.h"
#include "Ge/GeBoundBlock3d.h"
class OdGeCurve2d;
class OdGeSurface;
class OdGePoint3d;
class OdGePlane;
class OdGeVector3d;
class OdGeLinearEnt3d;
class OdGeLine3d;
class OdGePointOnCurve3d;
class OdGePointOnSurface;
class OdGeMatrix3d;
class OdGePointOnCurve3dData;

#include "TD_PackPush.h"

/** \details
    This class is the base class for all OdGe 3D curves.

    Library: TD_Ge

   <group OdGe_Classes> 
*/
class GE_TOOLKIT_EXPORT OdGeCurve3d : public OdGeEntity3d
{
public:


  /** \details
      Returns the parametric interval of this curve.

      \param interval [out]  Receives the parametric interval of this curve.

    \note
    By default this function throws exception "not Implemented". Should be implemented in derived classes.
  */
    void getInterval(
    OdGeInterval& interval) const;
   void getInterval(
    OdGeInterval& interval, 
    OdGePoint3d& start, 
    OdGePoint3d& end) const;

  /** \details
    Reverses the parameter direction this curve.   

    \remarks
    The point set of this curve is unchanged.

    \note
    By default this function throws exception "not Implemented". Should be implemented in derived classes.

    Throws:
    <table>
    Exception    
    eNotImplemented
    </table>
  */
   OdGeCurve3d& reverseParam();

  /** \details
    Sets the parametric interval of this curve.

    \param interval [in]  Parametric interval of this curve
    
    \note
    By default this function throws exception "not Implemented". Should be implemented in derived classes.

    Throws:
    <table>
    Exception    
    eNotImplemented
    </table>
  */
         OdGeCurve3d& setInterval();
   bool setInterval(
    const OdGeInterval& interval);

  /** \details
    Returns the distance to the point on this curve closest to the specified point or curve.

    \param point [in]  Any 3D point.
    \param curve [in]  Any 3D curve.
    \param tol [in]  Geometric tolerance.
  */
   double distanceTo(
    const OdGePoint3d& point, 
    const OdGeTol& tol = OdGeContext::gTol) const;
   double distanceTo(
    const OdGeCurve3d& curve, 
    const OdGeTol& tol = OdGeContext::gTol) const;

  /** \details
    Returns the point on this curve closest to the specified point or curve, and the point
    on the other curve closest to this curve.

    \param point [in]  Any 3D point.
    \param curve [in]  Any 3D curve.
    \param pntOnOtherCrv [out]  Receives the closest point on other curve.
    \param tol [in]  Geometric tolerance.
  */
   OdGePoint3d closestPointTo(
    const OdGePoint3d& point, 
    const OdGeTol& tol = OdGeContext::gTol) const;
   OdGePoint3d closestPointTo(
    const OdGeCurve3d& curve, 
    OdGePoint3d& pntOnOtherCrv, 
    const OdGeTol& tol = OdGeContext::gTol) const;

  /** \details
    Returns the point on this curve closest to the specified point or curve, 
    and the point on the other curve closest to this curve.

    \param point [in]  Any 3D point.
    \param curve [in]  Any 3D curve.
    \param pntOnThisCrv [out]  Receives the closest point on this curve.
    \param pntOnOtherCrv [out]  Receives the closest point on other curve.
    \param tol [in]  Geometric tolerance.

    \note
    By default this function throws exception "not Implemented". Should be implemented in derived classes.
  */
   void getClosestPointTo(
    const OdGePoint3d& point, 
    OdGePointOnCurve3d& pntOnCrv, 
    const OdGeTol& tol = OdGeContext::gTol) const;
   void getClosestPointTo(
    const OdGeCurve3d& curve, 
    OdGePointOnCurve3d& pntOnThisCrv, 
    OdGePointOnCurve3d& pntOnOtherCrv, 
    const OdGeTol& tol = OdGeContext::gTol) const;

  /** \details
    Returns the point on this curve closest to the specified point or curve, 
    and the point on the other curve closest to this curve, when this curve
    is projected in the specified direction.

    \param point [in]  Any 3D point.
    \param curve [in]  Any 3D curve.
    \param projectDirection [in]  Projection Direction.
    \param pntOnOtherCrv [out]  Receives the closest point on other curve.
    \param tol [in]  Geometric tolerance.
   
    \note
    By default this function throws exception "not Implemented". Should be implemented in derived classes.

    Throws:
    <table>
    Exception    
    eNotImplemented
    </table>
  */
   OdGePoint3d projClosestPointTo(
    const OdGePoint3d& point, 
    const OdGeVector3d& projectDirection, 
    const OdGeTol& tol = OdGeContext::gTol) const;
   OdGePoint3d projClosestPointTo(
    const OdGeCurve3d& curve, 
    const OdGeVector3d& projectDirection, 
    OdGePoint3d& pntOnOtherCrv, 
    const OdGeTol& tol = OdGeContext::gTol) const;

  /** \details
    Returns the point on this curve closest to the specified point or curve, 
    and the point on the other curve closest to this curve, when this curve
    is projected in the specified direction.

    \param point [in]  Any 3D point.
    \param curve [in]  Any 3D curve.
    \param projectDirection [in]  Projection Direction.
    \param pntOnCrv [out]  Receives the closest point on this curve.
    \param pntOnOtherCrv [out]  Receives the closest point on other curve.
    \param tol [in]  Geometric tolerance.
   
    \note
    By default this function throws exception "not Implemented". Should be implemented in derived classes.

    Throws:
    <table>
    Exception    
    eNotImplemented
    </table>
  */
   void getProjClosestPointTo(
    const OdGePoint3d& point, 
    const OdGeVector3d& projectDirection, 
    OdGePointOnCurve3d& pntOnCrv, 
    const OdGeTol& tol = OdGeContext::gTol) const;
   void getProjClosestPointTo(
    const OdGeCurve3d& curve,
    const OdGeVector3d& projectDirection,
    OdGePointOnCurve3d& pntOnThisCrv,
    OdGePointOnCurve3d& pntOnOtherCrv,
    const OdGeTol& tol = OdGeContext::gTol) const;

  /** \details
    Returns true, and the point on this curve whose normal vector passes through the specified point,
    if and only if a normal point was found.

    \param point [in]  Any 3D point.
    \param pntOnCrv [out]  Receives the normal point.
    \param tol [in]  Geometric tolerance.

    \note
    By default this function throws exception "not Implemented". Should be implemented in derived classes.

    Throws:
    <table>
    Exception    
    eNotImplemented
    </table>
  */
   bool getNormalPoint(
    const OdGePoint3d& point, 
    OdGePointOnCurve3d& pntOnCrv, 
    const OdGeTol& tol = OdGeContext::gTol) const;

  /** \details
    Returns the oriented bounding box of curve.

    \param range [in]  Sub-interval of this curve to be bounded.

    \note
    By default this function throws exception "not Implemented". Should be implemented in derived classes.

    Throws:
    <table>
    Exception    
    eNotImplemented
    </table>
  */
   OdGeBoundBlock3d boundBlock() const;
   OdGeBoundBlock3d boundBlock(
    const OdGeInterval& range) const;

  /** \details
    Returns the bounding box whose edges are aligned with the coordinate axes.

    \param range [in]  Interval of this curve to be bounded.
  */
   OdGeBoundBlock3d orthoBoundBlock() const;
   OdGeBoundBlock3d orthoBoundBlock(
    const OdGeInterval& range) const;

   OdGeEntity3d* project(
    const OdGePlane& projectionPlane,
    const OdGeVector3d& projectDirection,
    const OdGeTol& tol = OdGeContext::gTol) const;
  
   OdGeEntity3d* orthoProject(
    const OdGePlane& projectionPlane,
    const OdGeTol& tol = OdGeContext::gTol) const;

  // Tests if point is on *curve*.
  TD_USING(OdGeEntity3d::isOn);
   bool isOn(
    const OdGePoint3d& point, 
    double& param,
    const OdGeTol& tol = OdGeContext::gTol) const;
   bool isOn(
    double param, 
    const OdGeTol& tol = OdGeContext::gTol) const;

  /** \details
    Returns the parameter value of a point.

    \param point [in]  Point to be evaluated.
    \param tol [in]  Geometric tolerance.

    \remarks
    The returned parameters specify a point within tol of point.
    If point is not on this curve, the results are unpredictable.
    If you are not sure the point is on this curve, use 
    isOn () instead of this function.

    \note
    By default this function throws exception "not Implemented". Should be implemented in derived classes.
    
    Throws:
    <table>
    Exception    
    eNotImplemented
    </table>
  */
   double paramOf(
    const OdGePoint3d& point, 
    const OdGeTol& tol = OdGeContext::gTol) const;

  /** \details
    Returns one or more trimmed offset curves.

    \param distance [in]  Offset distance.
    \param planeNormal [in]  A normal to the plane of this curve.
    \param offsetCurveList [out]  Receives an array of trimmed offset curves.
    \param extensionType [in]  How curves will be extended at discontinuities of type C1.
    \param tol [in]  Geometric tolerance.

    \remarks
    The offsets are trimmed to eliminate self-intersecting loops.

    The curve is assumed to be planar, and planeNomal is assumed to be 
    normal to the curve plane.

    the direction of positive offset at any point on this curve
    is the cross product of planeNormal and the tangent to the
    curve at that point.

    The new operator is used to create the curves returned by 
    offsetCurveList. It is up to the caller to delete these curves.

    \note
    Currently not implemented. 

    Throws:
    <table>
    Exception    
    eNotImplemented
    </table>
  */
   void getTrimmedOffset(
    double distance, 
    const OdGeVector3d& planeNormal, 
    OdGeCurve3dPtrArray& offsetCurveList, 
    OdGe::OffsetCrvExtType extensionType = OdGe::kFillet, 
    const OdGeTol& tol = OdGeContext::gTol) const;

  /** \details
    Returns true if and only if this curve is closed within the specified tolerance.

    \param tol [in]  Geometric tolerance.
  */
   bool isClosed(
    const OdGeTol& tol = OdGeContext::gTol) const;

  /** \details
    Returns true if and only if this curve is planar, and returns
    the plane of this curve.

    \param plane [out]  Receives the plane of this curve.
    \param tol [in]  Geometric tolerance.

    \remarks
    Lines are considered planar the returned plane is an
    arbitrary plane containing the line.
  */
   bool isPlanar(
    OdGePlane& plane, 
    const OdGeTol& tol = OdGeContext::gTol) const;

  /** \details
    Returns true, and a linear entity coincident with this curve,
    if and only if this curve is linear.

    \param line [out]  Receives the line coincident with this curve.
    \param tol [in]  Geometric tolerance.

    \remarks
    An infinite line is returned, even if this curve is bounded.
    
    \note
    As implemented, this function does nothing but
    return false.
    It will be fully implemented in a future release.
    
  */
   bool isLinear(
    OdGeLine3d& line,
    const OdGeTol& tol = OdGeContext::gTol) const;

  /** \details
    Returns True if the specified curve entity is coplanar with 
    this curve and returns the common plane.

    \param curve [in]  Any 3D curve.
    \param plane [out]  Receives the plane of the curves.
    \param tol [in]  Geometric tolerance.
  */
   bool isCoplanarWith(
    const OdGeCurve3d& curve, 
    OdGePlane& plane, 
    const OdGeTol& tol = OdGeContext::gTol) const;

  /** \details
    Returns true if and only if this curve is periodic for the specified period.

    \param period [out]  Receives the period of this curve. 
  */
   bool isPeriodic(
    double& period) const;

  /** \details
    Returns the length of this curve over the specified parameter range.

    \param fromParam [in]  Starting parameter value.
    \param toParam [in]  Ending parameter value.
    \param tol [in]  Geometric tolerance.
    
  */
         double length(
    double fromParam, 
    double toParam, 
    double tol 
#ifndef SWIG
    = OdGeContext::gTol.equalPoint()
#endif
    ) const;

   double length(
    double tol 
#ifndef SWIG
    = OdGeContext::gTol.equalPoint()
#endif
    ) const;

  /** \details
    Returns the parameter of the point a specified distance 
    from the starting point corresponding to datumParam.

    \param datumParam [in]  Parameter corresponding to the start point.
    \param length [in]  Distance along curve from the start point.
    \param posParamDir [in]  True if and only if returned parameter is to be greater than dataParam.
    \param tol [in]  Geometric tolerance.
  */
         double paramAtLength( 
    double datumParam, 
    double length, 
    bool posParamDir 
#ifndef SWIG
    = true
#endif
    , double tol 
#ifndef SWIG
    = OdGeContext::gTol.equalPoint()
#endif
    ) const;

  /** \details
    Determines the area of this curve between the specified parameters. 
    Returns true (and a value) if and only if this curve is planar. 

    \param startParam [in]  Starting parameter value.
    \param endParam [in]  Ending parameter value.
    \param value [out]  Receives the area.
    \param tol [in]  Geometric tolerance.
  */
         bool area(
    double startParam, 
    double endParam, 
    double& value, 
    const OdGeTol& tol = OdGeContext::gTol) const;

  /** \details
    Returns true if and only if this curve degenerates, and returns
    the entity or type of entity to which this curve degenerates.

    \param degenerateType [out]  Receives the type of curve to which this curve degenerates.
    \param pConvertedEntity [out]  Receives a pointer to the object to which this curve degenerates.
    \param tol [in]  Geometric tolerance.

    \remarks
    If isDegenerate returns true, the returned object was created with the new operator, and it is the responsibility of the caller to delete it.
  */
         bool isDegenerate(
    OdGe::EntityId& degenerateType, 
    const OdGeTol& tol = OdGeContext::gTol) const;
   bool isDegenerate(
    OdGeEntity3d*& pConvertedEntity, 
    const OdGeTol& tol = OdGeContext::gTol) const;

  /** \details
    Returns pointers to the two curves that result from splitting this curve at the point corresponding 
    to param.

    \param param [in]  The parameter value corresponding to the split point.
    \param piece1 [out]  Receives a pointer to the first curve.
    \param piece2 [out]  Receives a pointer to the second curve.

    \remarks
    If param corresponds to a point not on this curve,
    or to the start point or end point of this curve,
    piece1 and piece2 are set to NULL.

    The curves pointed to by piece1 and piece2 
    are created with the new command, and must be deleted by the caller. 
  */
         void getSplitCurves(
    double param, 
    OdGeCurve3d*& piece1,
    OdGeCurve3d*& piece2) const;

  /** \details
    Explodes this curve over the specified interval.

    \param explodedCurves [out]  Receives an array of pointers to the subcurves from the explosion.
    \param newExplodedCurves [out]  Receives an array of flags which, if true, correspond to those explodedCurves the caller must delete.
    \param pInterval [in]  Pointer to the interval to be exploded. Defaults to entire curve.

    \remarks
    The original curve is not changed.
  */
         bool explode(
    OdGeCurve3dPtrArray& explodedCurves, 
    OdGeIntArray& newExplodedCurves, 
    const OdGeInterval* pInterval = NULL) const;

  /** \details
    Returns the point on this curve locally closest to the specified point
    or curve, and the point on the other curve locally closest to this curve.

    \param point [in]  Any 3D point.
    \param curve [in]  Any 3D curve.
    \param approxPntOnThisCrv [in/out] Approximate point on this curve.
    \param approxPntOnOtherCrv [in/out] Approximate point on other curve.
    \param pInterval1 [in] Pointer to the interval in which the point on this curve must lie.
    \param pInterval2 [in] Pointer to the interval in which the point on the other curve must lie.
    \param tol [in] Geometric tolerance.
  */
         void getLocalClosestPoints(
    const OdGePoint3d& point,
    OdGePointOnCurve3d& approxPntOnThisCrv,
    const OdGeInterval* pInterval1 = NULL,
    const OdGeTol& tol = OdGeContext::gTol) const;

   void getLocalClosestPoints(
    const OdGeCurve3d& curve,
    OdGePointOnCurve3d& approxPntOnThisCrv,
    OdGePointOnCurve3d& approxPntOnOtherCrv,
    const OdGeInterval* pInterval1 = NULL,
    const OdGeInterval* pInterval2 = NULL,
    const OdGeTol& tol = OdGeContext::gTol) const;

  /** \details
    Returns true, and the start point, if and only if the parametric interval of this curve has a lower bound.

    \param startPoint [out]  Receives the start point.
  */
   bool hasStartPoint(
    OdGePoint3d& startPoint) const;

  /** \details
    Returns true, and the end point,  if and only if the parametric interval of this curve has an upper bound.

    \param endPoint [out]  Receives the end point.
  */
   bool hasEndPoint(
    OdGePoint3d& endPoint) const;

  /** \details
    Returns the point on this curve corresponding to the specified parameter value,
    and the derivatives at that point.

    \param param [in]  Parameter to be evaluated.
    \param numDeriv [in]  Number of derivatives to be computed.
    \param derivatives [out]  Receives an array of derivatives at the point corresponding to param.

  */
   OdGePoint3d evalPoint(
    double param) const;
   OdGePoint3d evalPoint(
    double param, 
    int numDeriv, 
    OdGeVector3dArray& derivatives) const;

  /** \details
    Returns sample points along this curve and their parameter values in the specified arrays.

    \param fromParam [in]  Starting parameter value.
    \param toParam [in]  Ending parameter value.
    \param paramInterval [in]  Pointer to the parametric interval.
    \param approxEps [in]  Approximate spacing along a curve.
    \param numSample [in]  Number of samples.
    \param pointArray [out]  Receives an array of sample points.
    \param paramArray [out]  Receives an array of parameters at each point.
    \param forceResampling [in]  sample points are forced to be regenerated
  */
   void getSamplePoints(
    double fromParam, 
    double toParam, 
    double approxEps, 
    OdGePoint3dArray& pointArray, 
    OdGeDoubleArray& paramArray,
    bool forceResampling = false) const;
   void getSamplePoints(
    int numSample, 
    OdGePoint3dArray& pointArray) const;
   void getSamplePoints(
    int numSample, 
    OdGePoint3dArray& pointArray,
    OdGeDoubleArray& paramArray) const;

  // Assignment operator.
  OdGeCurve3d& operator =(const OdGeCurve3d& curve);

  ///////////////////////////////////////////////////////////////////////////
  // TD Special :

  /** \details
    Returns sample points along this curve and their parameter values in the specified arrays.
	Not implemented for third-party use only.

    \param paramInterval [in]  Pointer to the parametric interval.

    \remarks
    If paramInterval is null, the current curve interval will be used.
  */
   void getSamplePoints(
    double fromParam, 
    double toParam, 
    double approxEps, 
    OdGePoint3dArray& pointArray, 
    OdGeDoubleArray* paramArray = NULL) const;
   void getSamplePoints(
    const OdGeInterval* paramInterval,
    double approxEps, 
    OdGePoint3dArray& pointArray,
    OdGeDoubleArray* pParamArray = NULL) const;

  /** \details
    Appends sample points along this curve and their parameter values to the specified arrays.
	
    \param fromParam [in]  Starting parameter value.
    \param toParam [in]  Ending parameter value.
    \param paramInterval [in]  Pointer to the parametric interval.
    \param approxEps [in]  Approximate spacing along a curve.
    \param numSample [in]  Number of samples.
    \param pointArray [out]  Receives an array of sample points.
    \param paramArray [out]  Receives an array of parameters at each point.

    \remarks
    If paramInterval is null, the current curve interval will be used.
    The signature appendSamplePoints(double, double, double, OdGePoint3dArray&, OdGeDoubleArray*) is currently not implemented.
  */
   void appendSamplePoints(
    double fromParam, 
    double toParam, 
    double approxEps, 
    OdGePoint3dArray& pointArray, 
    OdGeDoubleArray* pParamArray = NULL) const;
   void appendSamplePoints(
    int numSample, 
    OdGePoint3dArray& pointArray,
    OdGeDoubleArray* pParamArray = NULL) const;
   void appendSamplePoints(
    const OdGeInterval *paramInterval, 
    double approxEps, 
    OdGePoint3dArray& pointArray, 
    OdGeDoubleArray* pParamArray = NULL) const;

protected:
  OdGeCurve3d();
  OdGeCurve3d(
    const OdGeCurve3d& source);
};

#include "TD_PackPop.h"

#endif