/////////////////////////////////////////////////////////////////////////////// 
// 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_GEGBL_H
#define OD_GEGBL_H /*!DOM*/

#include "Ge/GeTol.h"

#include "Ge/Ge.h"
#include "OdArrayPreDef.h"
#include "Ge/GePoint3dArray.h"

class OdGeSurface;
class OdGeVector3d;
class OdGePlane;
class OdGeCurve3d;
class OdGeNurbCurve2d;
class OdGeNurbCurve3d;
class OdGePoint3d;

#include "TD_PackPush.h"

/** \details
    This structure provides a namespace for tolerance values and functions ubiquitous to the OdGe library.

    \sa
    TD_Ge

    <group !!RECORDS_TD_APIRef>
*/
struct GE_TOOLKIT_EXPORT OdGeContext
{
  /** \details
    Provides the global default OdGeTol tolerance object.
    \remarks
    gTol.equalPoint == 1e-10  gTolequalVector == 1.e-10.
  */
  GE_STATIC_EXPORT static OdGeTol gTol;

  /** \details
    Provides the global 0.0 default OdGeTol tolerance object.
    \remarks
    gZeroTol.equalPoint == 0.0 and gZeroTol.equalVector == 1.e-10.
  */
  GE_STATIC_EXPORT static OdGeTol gZeroTol;

  /** \details
    A function pointer to a user-defined error handler.
    \remarks
    By default, points to a function that does nothing but return.
  */
  GE_STATIC_EXPORT static void (*gErrorFunc)(OdResult);

  /** \details
    A function pointer to a user-defined function that returns orthoVector orthogonal to vect.

    \remarks
    By default, points to a function that computes orthoVector with the arbitrary axis algorithm:

                if ( (vect.x < 0.015625) && (vect.x < 0.015625)) {
                  orthoVector.x = vect.z;
                  orthoVector.y = 0.0;
                  orthoVector.z = -vect.x;
                }
                else {
                  orthoVector.x = -vect.y;
                  orthoVector.y = vect.x;
                  orthoVector.z = 0.0;
                }
    \param vect [in]  Vector.
    \param orthoVector [out]  Receives the orthogonal vector.
  */
  GE_STATIC_EXPORT static void (*gOrthoVector) (const OdGeVector3d& vect, OdGeVector3d& orthoVector);

  /** \details
    A function pointer to a user-defined memory allocation function
    for all new operations in the OdGe library.
    \remarks
    Allows the OdGe library to use the same memory manager as the user application.
    \param size [in]  Size in bytes to allocate.
  */
  GE_STATIC_EXPORT static void* (*gAllocMem) (unsigned long size);


  /** A function pointer to a user-defined memory allocation function
    for all delete operations in the OdGe library.

    \remarks
    Allows the OdGe library to use the same memory manager as the user application.

    \param memBlock [in]  Allocated memory block to be freed.
  */
  GE_STATIC_EXPORT static void (*gFreeMem) (void* memBlock);
};

  /** \details
    Checks topology of a triangulated solid.

    \param points [in]  Array of 3D points (in order of the triangles they form).
    \param isValid [out]  Receives the validation result.
    \param tol [in]  Geometric tolerance.

    \remarks
    Array of points should be divided by 3 without remainder.

    Library: TD_Ge
  */
GE_TOOLKIT_EXPORT OdGeError geValidSolid (
    const OdGePoint3dArray &points,
    bool &isValid,
    const OdGeTol &tol = OdGeContext::gTol);

  /** \details
    Calculates signed volume of a triangulated solid.

    \param points [in]  Array of 3D points (in order of the triangles they form).
    \param volume [out]  Receives the volume value.
    \param basePoint [in]  Point to replace (0,0,0) for calculation purposes.
    
    \remarks
    Array of points should be divided by 3 without remainder.
    Negative sign of volume means that triangles in the solid are ordered clockwise.

    Library: TD_Ge
  */
GE_TOOLKIT_EXPORT OdGeError geSolidSignedVolume (
    const OdGePoint3dArray &points,
    double &volume,
    const OdGePoint3d *basePoint);

/** \details
    Returns the normal to the plane defined by the specified points.

    \param points [in]  Array of 3D points.
    \param numPoints [in]  Number of points.
    \param pNormal [out]  Receives the normal to the calculated plane.
    \param tol [in]  Geometric tolerance.

    \remarks
    Possible return values are as follows:

    @untitled table
    kOk
    kNonCoplanarGeometry
    kDegenerateGeometry
    kSingularPoint

    Library: TD_Ge
*/
GE_TOOLKIT_EXPORT OdGeError geCalculateNormal (
    const OdGePoint3dArray& points,
    OdGeVector3d * pNormal,
    const OdGeTol& tol = OdGeContext::gTol);

GE_TOOLKIT_EXPORT OdGeError geCalculateNormal (
    const OdGePoint3d *points,
    OdUInt32 numPoints,
    OdGeVector3d * pNormal,
    const OdGeTol& tol = OdGeContext::gTol);

// Same with previous functions, but returns result as plane

/** \details
    Returns the plane defined by the specified points.

    \param points [in]  Array of 3D points.
    \param curves [in]  Array of 3D curves.
    \param numPoints [in]  Number of points.
    \param numCurves [in]  Number of curves.
    \param plane [out]  Receives the calculated plane.
    \param tol [in]  Geometric tolerance.

    \remarks
    Supported curves are OdGeCircArc3d, OdGeEllipArc3d, OdGeNurbCurve3d, and OdGeLineSeg3d.

    Possible return values are as follows:

    @untitled table
    kOk
    kNonCoplanarGeometry
    kDegenerateGeometry
    kSingularPoint

    Library: TD_Ge
*/
GE_TOOLKIT_EXPORT OdGeError geCalculatePlane (
    const OdGePoint3dArray& points,
    OdGePlane& plane,
    const OdGeTol& tol = OdGeContext::gTol);

GE_TOOLKIT_EXPORT OdGeError geCalculatePlane (
    const OdGePoint3d *points,
    OdUInt32 numPoints,
    OdGePlane& plane,
    const OdGeTol& tol = OdGeContext::gTol);

GE_TOOLKIT_EXPORT OdGeError geCalculatePlane (
    const OdGeCurve3d * const* curves,
    OdUInt32 numCurves,
    OdGePlane& plane,
    const OdGeTol& tol = OdGeContext::gTol);

/** \details
    Converts a 3D NURBS curve to a 2D NURBS curve by projecting it onto the specified plane.

    \param nurb3d [in]  Any 3D NURBS curve.
    \param plane [in]  Projection plane.
    \param nurb2d [out]  Receives the 2D NURBS curve.
    \param tol [in]  Geometric tolerance.

    Library: TD_Ge
*/
GE_TOOLKIT_EXPORT bool geNurb3dTo2d (
    const OdGeNurbCurve3d &nurb3d,
    OdGePlane& plane,
    OdGeNurbCurve2d &nurb2d,
    const OdGeTol& tol = OdGeContext::gTol);

/** \details
    Calculates a properties for a specified surface.

    \param pS [in]  Any surface.
    \param propU, propV [out] Receives the properties.
    \param tol [in] Geometric tolerance.

    Library: TD_Ge

    \remarks
      Rational state valid only for NURB surfaces.
*/
GE_TOOLKIT_EXPORT bool geSurfaceProp(
    const OdGeSurface &pS, 
    OdGe::NurbSurfaceProperties &propU,
    OdGe::NurbSurfaceProperties &propV,
    const OdGeTol& tol);

// was moved from Examples\Common\toString
/// Convert the specified value to an OdGe::EntityId string
GE_TOOLKIT_EXPORT OdString geToString(const OdGe::EntityId val);

#include "TD_PackPop.h"

inline void GE_ERROR(OdResult res)
{
  (*OdGeContext::gErrorFunc)(res);
}

/** \details
  <group Error_Classes> 

  Library: TD_Ge
*/
class GE_TOOLKIT_EXPORT OdError_GeNotImplemted : public OdError
{
public:
  OdError_GeNotImplemted(const OdString& sMessage);
};

#define GE_NOT_IMPL(pGeEnt) \
{ \
  try \
  { \
    (*OdGeContext::gErrorFunc)(eNotImplemented); \
  } \
  catch (OdError &err) \
  { \
    if (err.code() == eNotImplemented) \
    { \
      OdString sFunc(TD_FUNC); \
      OdString sMessage; \
      sMessage.format(OD_T("%s method %s for Ge type %s"), \
                      OD_T("%s"), \
                      sFunc.c_str(), \
                      geToString(pGeEnt->type()).c_str()); \
      throw OdError_GeNotImplemted(sMessage); \
    } \
    throw; \
  } \
}

#endif // OD_GEGBL_H