//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : LUA_GdbModifyCurve.cpp       Data : 28.12.14        Versione : 1.5l2
// Contenuto : Funzioni di modifica delle curve per LUA.
//
//
//
// Modifiche : 03.10.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "EXE_Const.h"
#include "LUA.h"
#include "/EgtDev/Include/EXeExecutor.h"
#include "/EgtDev/Include/EXeConst.h"
#include "/EgtDev/Include/EGkCurve.h"
#include "/EgtDev/Include/EGkLuaAux.h"
#include "/EgtDev/Include/EGkCalcPocketing.h"

using namespace std ;

//----------------------------------------------------------------------------
static int
LuaInvertCurve( lua_State* L)
{
  // 1 parametro : Id/s
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   LuaClearStack( L) ;
  // eseguo inversione curve
   bool bOk = ExeInvertCurve( vId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaOffsetCurve( lua_State* L)
{
  // 2 o 3 parametri : Id, dDist [, nType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dDist ;
   LuaCheckParam( L, 2, dDist)
   int nType = ICurve::OFF_FILLET ;
   LuaGetParam( L, 3, nType) ;
   LuaClearStack( L) ;
  // offset della curva
   bool bOk = ExeOffsetCurve( nId, dDist, nType) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaOffsetCurveAdv( lua_State* L)
{
  // 2 o 3 o 4 parametri : Id, dDist [, nType] [, dLinTol]
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dDist ;
   LuaCheckParam( L, 2, dDist)
   int nType = ICurve::OFF_FILLET ;
   LuaGetParam( L, 3, nType) ;
   double dLinTol = 10 * EPS_SMALL ;
   LuaGetParam( L, 4, dLinTol) ;
   LuaClearStack( L) ;
  // offset della curva
   int nCount ;
   int nNewId = ExeOffsetCurveAdv( nId, dDist, nType, &nCount, dLinTol) ;
   if ( nCount >= 0) {
      LuaSetParam( L, nNewId) ;
      LuaSetParam( L, nCount) ;
   }
   else {
      LuaSetParam( L) ;
      LuaSetParam( L, nCount) ;
   }
   return 2 ;
}

//-------------------------------------------------------------------------------
static int
LuaCurveMedialAxis( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // calcolo del Medial Axis della curva
   int nNewId = ExeCurveMedialAxis( nId) ;
   if ( nNewId != GDB_ID_NULL)
      LuaSetParam( L, nNewId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaApproxCurve( lua_State* L)
{
  // 2 o 3 o 4 parametri : Id, nApprType [, dLinTol [, dMaxSegmLen]]
   int nId ;
   LuaCheckParam( L, 1, nId)
   int nApprType ;
   LuaCheckParam( L, 2, nApprType)
   double dLinTol = 0.01 ;
   double dMaxSegmLen = INFINITO ;
   if ( LuaGetParam( L, 3, dLinTol))
      LuaGetParam( L, 4, dMaxSegmLen) ;
   LuaClearStack( L) ;
  // approssimazione della curva con rette
   bool bOk = ExeApproxCurve( nId, nApprType, dLinTol, dMaxSegmLen) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaProjectCurveOnPlane( lua_State* L)
{
  // 3 o 4 parametri : Id, ptOn, vtN [, nRefType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   Point3d ptOn ;
   LuaCheckParam( L, 2, ptOn)
   Vector3d vtN ;
   LuaCheckParam( L, 3, vtN)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 4, nRefType) ;
   LuaClearStack( L) ;
  // proiezione della curva sul piano indicato
   bool bOk = ExeProjectCurveOnPlane( nId, ptOn, vtN, nRefType) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaChangeClosedCurveStart( lua_State* L)
{
  // 2 parametri : Id, dUStart
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dUStart ;
   LuaCheckParam( L, 2, dUStart)
   LuaClearStack( L) ;
  // modifico il punto iniziale
   bool bOk = ExeChangeClosedCurveStart( nId, dUStart) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaChangeClosedCurveStartPoint( lua_State* L)
{
  // 2 o 3 parametri : Id, NewStart [, nRefType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   Point3d ptStart ;
   LuaCheckParam( L, 2, ptStart)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 3, nRefType) ;
   LuaClearStack( L) ;
  // modifico il punto iniziale
   bool bOk = ExeChangeClosedCurveStartPoint( nId, ptStart, nRefType) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaModifyCurveStartPoint( lua_State* L)
{
  // 2 o 3 parametri : Id, NewStart [, nRefType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   Point3d ptStart ;
   LuaCheckParam( L, 2, ptStart)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 3, nRefType) ;
   LuaClearStack( L) ;
  // modifico il punto iniziale
   bool bOk = ExeModifyCurveStartPoint( nId, ptStart, nRefType) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaModifyCurveEndPoint( lua_State* L)
{
  // 2 o 3 parametri : Id, NewEnd [, nRefType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   Point3d ptEnd ;
   LuaCheckParam( L, 2, ptEnd)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 3, nRefType) ;
   LuaClearStack( L) ;
  // modifico il punto finale
   bool bOk = ExeModifyCurveEndPoint( nId, ptEnd, nRefType) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaSpiralizeCurveAlongExtrusion( lua_State* L)
{
  // 2 parametri : Id, Delta
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dDelta ;
   LuaCheckParam( L, 2, dDelta)
   LuaClearStack( L) ;
  // modifico la curva
   bool bOk = ExeSpiralizeCurveAlongExtrusion( nId, dDelta) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaSpiralizeCurveAlongGuide( lua_State* L)
{
  // 2 o 3 parametri : Id, IdGuide, dTol
   int nId ;
   LuaCheckParam( L, 1, nId)
   int nGuideId ; 
   LuaCheckParam( L, 2, nGuideId) 
   double dTol = 10 * EPS_SMALL ;
   LuaGetParam( L, 3, dTol) ;
   LuaClearStack( L) ;
  // modifico la curva
   bool bOk = ExeSpiralizeCurveAlongGuide( nId, nGuideId, dTol) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaModifyCurveExtrusion( lua_State* L)
{
  // 2 o 3 parametri : Id/s, vtExtr [, nRefType]
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   Vector3d vtExtr ;
   LuaCheckParam( L, 2, vtExtr)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 3, nRefType) ;
   LuaClearStack( L) ;
  // modifico il vettore estrusione
   bool bOk = ExeModifyCurveExtrusion( vId, vtExtr, nRefType) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaModifyCurveThickness( lua_State* L)
{
  // 2 parametri : Id/s, Thick
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   double dThick ;
   LuaCheckParam( L, 2, dThick)
   LuaClearStack( L) ;
  // modifico lo spessore di estrusione
   bool bOk = ExeModifyCurveThickness( vId, dThick) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaTrimCurveStartAtLen( lua_State* L)
{
  // 2 parametri : Id, dLen
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dLen ;
   LuaCheckParam( L, 2, dLen)
   LuaClearStack( L) ;
  // taglio la curva all'inizio
   bool bOk = ExeTrimCurveStartAtLen( nId, dLen) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaTrimCurveEndAtLen( lua_State* L)
{
  // 2 parametri : Id, dLen
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dLen ;
   LuaCheckParam( L, 2, dLen)
   LuaClearStack( L) ;
  // taglio la curva alla fine
   bool bOk = ExeTrimCurveEndAtLen( nId, dLen) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaTrimCurveStartAtParam( lua_State* L)
{
  // 2 parametri : Id, dPar
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dPar ;
   LuaCheckParam( L, 2, dPar)
   LuaClearStack( L) ;
  // taglio la curva all' inizio
   bool bOk = ExeTrimCurveStartAtParam( nId, dPar) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaTrimCurveEndAtParam( lua_State* L)
{
  // 2 parametri : Id, dPar
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dPar ;
   LuaCheckParam( L, 2, dPar)
   LuaClearStack( L) ;
  // taglio la curva alla fine
   bool bOk = ExeTrimCurveEndAtParam( nId, dPar) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaTrimCurveStartEndAtParam( lua_State* L)
{
  // 3 parametri : Id, dParS, dParE
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dParS ;
   LuaCheckParam( L, 2, dParS)
   double dParE ;
   LuaCheckParam( L, 3, dParE)
   LuaClearStack( L) ;
  // taglio la curva alla fine
   bool bOk = ExeTrimCurveStartEndAtParam( nId, dParS, dParE) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaExtendCurveStartByLen( lua_State* L)
{
  // 2 parametri : Id, dPar
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dPar ;
   LuaCheckParam( L, 2, dPar)
   LuaClearStack( L) ;
  // allungo la curva all' inizio
   bool bOk = ExeExtendCurveStartByLen( nId, dPar) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaExtendCurveEndByLen( lua_State* L)
{
  // 2 parametri : Id, dPar
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dPar ;
   LuaCheckParam( L, 2, dPar)
   LuaClearStack( L) ;
  // allungo la curva alla fine
   bool bOk = ExeExtendCurveEndByLen( nId, dPar) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaTrimExtendCurveByLen( lua_State* L)
{
  // 3 o 4 parametri : Id, dLen, ptNear [, nRefType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dLen ;
   LuaCheckParam( L, 2, dLen)
   Point3d ptNear ;
   LuaCheckParam( L, 3, ptNear)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 4, nRefType) ;
   LuaClearStack( L) ;
  // taglio o allungo la curva nell'estremo più vicino al punto
   bool bOk = ExeTrimExtendCurveByLen( nId, dLen, ptNear, nRefType) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaTrimCurveWithRegion( lua_State* L)
{
  // 4 parametri : nCrvId, nRegId, bInVsOut, bOn
   int nCrvId ;
   LuaCheckParam( L, 1, nCrvId)
   int nRegId ;
   LuaCheckParam( L, 2, nRegId)
   bool bInVsOut ;
   LuaCheckParam( L, 3, bInVsOut)
   bool bOn ;
   LuaCheckParam( L, 4, bOn)
   LuaClearStack( L) ;
  // conservo le parti di curva desiderate
   int nCount ;
   int nNewId = ExeTrimCurveWithRegion( nCrvId, nRegId, bInVsOut, bOn, &nCount) ;
   if ( nNewId != GDB_ID_NULL)
      LuaSetParam( L, nNewId) ;
   else
      LuaSetParam( L) ;
   LuaSetParam( L, nCount) ;
   return 2 ;
}

//----------------------------------------------------------------------------
static int
LuaTrimFlatCurveWithBox( lua_State* L)
{
  // 5 o 6 parametri : nCrvId, frBox, vtDiag, bInVsOut, bOn [, nRefType]
   int nCrvId ;
   LuaCheckParam( L, 1, nCrvId)
   Frame3d frBox ;
   LuaCheckParam( L, 2, frBox)
   Vector3d vtDiag ;
   LuaCheckParam( L, 3, vtDiag)
   bool bInVsOut ;
   LuaCheckParam( L, 4, bInVsOut)
   bool bOn ;
   LuaCheckParam( L, 5, bOn)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 6, nRefType) ;
   LuaClearStack( L) ;
  // conservo le parti di curva desiderate
   int nCount ;
   int nNewId = ExeTrimFlatCurveWithBox( nCrvId, frBox, vtDiag, bInVsOut, bOn, nRefType, &nCount) ;
   if ( nNewId != GDB_ID_NULL)
      LuaSetParam( L, nNewId) ;
   else
      LuaSetParam( L) ;
   LuaSetParam( L, nCount) ;
   return 2 ;
}

//----------------------------------------------------------------------------
static int
LuaSplitCurve( lua_State* L)
{
  // 2 parametri : Id, nParts
   int nId ;
   LuaCheckParam( L, 1, nId)
   int nParts ;
   LuaCheckParam( L, 2, nParts)
   LuaClearStack( L) ;
  // divido la curva nel punto
   int nFirstId = ExeSplitCurve( nId, nParts) ;
   if ( nFirstId != GDB_ID_NULL)
      LuaSetParam( L, nFirstId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaSplitCurveAtPoint( lua_State* L)
{
  // 2 o 3 parametri : Id, ptOn [, nRefType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   Point3d ptOn ;
   LuaCheckParam( L, 2, ptOn)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 3, nRefType) ;
   LuaClearStack( L) ;
  // divido la curva nel punto
   int nNewId = ExeSplitCurveAtPoint( nId, ptOn, nRefType) ;
   if ( nNewId != GDB_ID_NULL)
      LuaSetParam( L, nNewId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaSplitCurveAtParam( lua_State* L)
{
  // 2 parametri : Id, dParam
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dParam ;
   LuaCheckParam( L, 2, dParam)
   LuaClearStack( L) ;
  // divido la curva nel punto
   int nFirstId = ExeSplitCurveAtParam( nId, dParam) ;
   if ( nFirstId != GDB_ID_NULL)
      LuaSetParam( L, nFirstId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaSplitCurveAtCorners( lua_State* L)
{
  // 2 parametri : Id, dTgAngToler
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dTgAngToler ;
   LuaCheckParam( L, 2, dTgAngToler)
   LuaClearStack( L) ;
  // divido la curva nei punti angolosi
   int nCount ;
   int nNewId = ExeSplitCurveAtCorners( nId, dTgAngToler, &nCount) ;
   if ( nNewId != GDB_ID_NULL)
      LuaSetParam( L, nNewId) ;
   else
      LuaSetParam( L) ;
   LuaSetParam( L, nCount) ;
   return 2 ;
}

//----------------------------------------------------------------------------
static int
LuaSplitCurveAtSelfInters( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // divido la curva negli eventuali punti di autointersezione
   int nCount ;
   int nNewId = ExeSplitCurveAtSelfInters( nId, &nCount) ;
   if ( nNewId != GDB_ID_NULL)
      LuaSetParam( L, nNewId) ;
   else
      LuaSetParam( L) ;
   LuaSetParam( L, nCount) ;
   return 2 ;
}

//-------------------------------------------------------------------------------
static int
LuaModifyArcRadius( lua_State* L)
{
  // 2 o 3 parametri : Id, dNewRad [, bKeepCenter]
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dNewRad ;
   LuaCheckParam( L, 2, dNewRad)
   bool bKeepCenter = true ;
   LuaGetParam( L, 3, bKeepCenter) ;
   LuaClearStack( L) ;
  // modifica del raggio
   bool bOk = ExeModifyArcRadius( nId, dNewRad, bKeepCenter) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaModifyArcAngCenter( lua_State* L)
{
  // 2 parametri : Id, dNewAngCenter
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dNewAngCenter ;
   LuaCheckParam( L, 2, dNewAngCenter)
   LuaClearStack( L) ;
  // modifica dell'angolo al centro
   bool bOk = ExeModifyArcAngCenter( nId, dNewAngCenter) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaModifyArcToExplementary( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // modifica del raggio
   bool bOk = ExeModifyArcToExplementary( nId) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaModifyArcByFlip( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // modifica del raggio
   bool bOk = ExeModifyArcByFlip( nId) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaCloseCurveCompo( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // eseguo chiusura della curva composita
   bool bOk = ExeCloseCurveCompo( nId) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaAddCurveCompoCurve( lua_State* L)
{
  // 2, 3 o 4 parametri : Id, AddCrvId [, bEraseOrig [, bEndVsStart]]
   int nId ;
   LuaCheckParam( L, 1, nId)
   int nAddCrvId ;
   LuaCheckParam( L, 2, nAddCrvId)
   bool bEraseOrig = true ;
   bool bEndVsStart = true ;
   if ( LuaGetParam( L, 3, bEraseOrig))
      LuaGetParam( L, 4, bEndVsStart) ;
   LuaClearStack( L) ;
  // aggiungo la curva in coda alla curva composita
   bool bOk = ExeAddCurveCompoCurve( nId, nAddCrvId, bEraseOrig, bEndVsStart) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaAddCurveCompoLine( lua_State* L)
{
  // 2, 3 o 4 parametri : Id, ptNew [, bEndVsStart] [, nRefType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   Point3d ptNew ;
   LuaCheckParam( L, 2, ptNew)
   bool bEndVsStart = true ;
   int nRefType = RTY_DEFAULT ;
   if ( LuaGetParam( L, 3, bEndVsStart))
      LuaGetParam( L, 4, nRefType) ;
   else
      LuaGetParam( L, 3, nRefType) ;
   LuaClearStack( L) ;
  // aggiungo una linea in coda alla curva composita
   bool bOk = ExeAddCurveCompoLine( nId, ptNew, bEndVsStart, nRefType) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaAddCurveCompoLineTg( lua_State* L)
{
  // 2 o 3 parametri : Id, dLen [, bEndVsStart]
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dLen ;
   LuaCheckParam( L, 2, dLen)
   bool bEndVsStart = true ;
   LuaGetParam( L, 3, bEndVsStart) ;
   LuaClearStack( L) ;
  // aggiungo una linea in coda alla curva composita
   bool bOk = ExeAddCurveCompoLineTg( nId, dLen, bEndVsStart) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaAddCurveCompoArc2P( lua_State* L)
{
  // 3, 4 o 5 parametri : Id, ptMid, ptNew [, bEndVsStart] [, nRefType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   Point3d ptMid ;
   LuaCheckParam( L, 2, ptMid)
   Point3d ptNew ;
   LuaCheckParam( L, 3, ptNew)
   bool bEndVsStart = true ;
   int nRefType = RTY_DEFAULT ;
   if ( LuaGetParam( L, 4, bEndVsStart))
      LuaGetParam( L, 5, nRefType) ;
   else
   LuaGetParam( L, 4, nRefType) ;
   LuaClearStack( L) ;
  // aggiungo arco per 3P in coda alla curva composita
   bool bOk = ExeAddCurveCompoArc2P( nId, ptMid, ptNew, bEndVsStart, nRefType) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaAddCurveCompoArcTg( lua_State* L)
{
  // 2, 3 o 4 parametri : Id, ptNew [, bEndVsStart] [, nRefType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   Point3d ptNew ;
   LuaCheckParam( L, 2, ptNew)
   bool bEndVsStart = true ;
   int nRefType = RTY_DEFAULT ;
   if ( LuaGetParam( L, 3, bEndVsStart))
      LuaGetParam( L, 4, nRefType) ;
   else
      LuaGetParam( L, 3, nRefType) ;
   LuaClearStack( L) ;
  // aggiungo un arco tangente in coda alla curva composita
   bool bOk = ExeAddCurveCompoArcTg( nId, ptNew, bEndVsStart, nRefType) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaRemoveCurveCompoCurve( lua_State* L)
{
  // 1 o 2 parametri : Id [, bLast]
   int nId ;
   LuaCheckParam( L, 1, nId)
   bool bLast = true ;
   LuaGetParam( L, 2, bLast) ;
   LuaClearStack( L) ;
  // rimuovo prima o ultima curva della composita
   bool bOk = ExeRemoveCurveCompoCurve( nId, bLast) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaAddCurveCompoJoint( lua_State* L)
{
  // 2 parametri : Id, dU
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dU ;
   LuaCheckParam( L, 2, dU)
   LuaClearStack( L) ;
  // aggiungo la giunzione
   bool bOk = ExeAddCurveCompoJoint( nId, dU) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaModifyCurveCompoJoint( lua_State* L)
{
  // 3 o 4 parametri : Id, nU, ptJoint [, nRefType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   int nU ;
   LuaCheckParam( L, 2, nU)
   Point3d ptJoint ;
   LuaCheckParam( L, 3, ptJoint)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 4, nRefType) ;
   LuaClearStack( L) ;
  // modifico il punto di giunzione nU-esimo
   bool bOk = ExeModifyCurveCompoJoint( nId, nU, ptJoint, nRefType) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaRemoveCurveCompoJoint( lua_State* L)
{
  // 2 parametri : Id, nU
   int nId ;
   LuaCheckParam( L, 1, nId)
   int nU ;
   LuaCheckParam( L, 2, nU)
   LuaClearStack( L) ;
  // rimuovo la giunzione
   bool bOk = ExeRemoveCurveCompoJoint( nId, nU) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaMoveCurveCompoCurve( lua_State* L)
{
  // 3 o 4 parametri : Id, nCrv, vtMove [, nRefType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   int nCrv ;
   LuaCheckParam( L, 2, nCrv)
   Vector3d vtMove ;
   LuaCheckParam( L, 3, vtMove)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 4, nRefType) ;
   LuaClearStack( L) ;
  // muovo la curva
   bool bOk = ExeMoveCurveCompoCurve( nId, nCrv, vtMove, nRefType) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaModifyCurveCompoCurveToArc( lua_State* L)
{
  // 3 o 4 parametri : Id, nCrv, ptMid [, nRefType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   int nCrv ;
   LuaCheckParam( L, 2, nCrv)
   Point3d ptMid ;
   LuaCheckParam( L, 3, ptMid)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 4, nRefType) ;
   LuaClearStack( L) ;
  // modifico la curva in arco
   bool bOk = ExeModifyCurveCompoCurveToArc( nId, nCrv, ptMid, nRefType) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaModifyCurveCompoCurveToLine( lua_State* L)
{
  // 2 parametri : Id, nCrv
   int nId ;
   LuaCheckParam( L, 1, nId)
   int nCrv ;
   LuaCheckParam( L, 2, nCrv)
   LuaClearStack( L) ;
  // modifico la curva in segmento di retta
   bool bOk = ExeModifyCurveCompoCurveToLine( nId, nCrv) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaExplodeCurveCompo( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // esplosione della curva composita
   int nCount ;
   int nFirstId = ExeExplodeCurveCompo( nId, &nCount) ;
   if ( nFirstId != GDB_ID_NULL)
      LuaSetParam( L, nFirstId) ;
   else
      LuaSetParam( L) ;
   LuaSetParam( L, nCount) ;
   return 2 ;
}

//-------------------------------------------------------------------------------
static int
LuaMergeCurvesInCurveCompo( lua_State* L)
{
  // 1 o 2 o 3 parametri : Id [, dLinTol] [, bStartEnd]
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dLinTol = 0.01 ;
   bool bStartEnd = true ;
   if ( LuaGetParam( L, 2, dLinTol))
      LuaGetParam( L, 3, bStartEnd) ;
   else
      LuaGetParam( L, 2, bStartEnd) ;
   LuaClearStack( L) ;
  // esplosione della curva composita
   bool bOk = ExeMergeCurvesInCurveCompo( nId, dLinTol, bStartEnd) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRemoveCurveCompoUndercutOnY( lua_State* L)
{
  // 1 o 2 parametri : Id [, dLinTol]
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dLinTol = 0.01 ;
   LuaGetParam( L, 2, dLinTol) ;
   LuaClearStack( L) ;
  // eliminazioni delle parti sotto rispetto alla direzione Y+
   bool bOk = ExeRemoveCurveCompoUndercutOnY( nId, dLinTol) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaCurveCompoSetTempProp( lua_State* L)
{
  // 3 parametri : Id, nCrv, nProp [, nPropInd]
   int nId ;
   LuaCheckParam( L, 1, nId)
   int nCrv ;
   LuaCheckParam( L, 2, nCrv)
   int nProp ;
   LuaCheckParam( L, 3, nProp)
   int nPropInd = 0 ;
   LuaGetParam( L, 4, nPropInd) ;
   LuaClearStack( L) ;
  // imposto sulla curva della composita la proprietà temporanea
   bool bOk = ExeCurveCompoSetTempProp( nId, nCrv, nProp, nPropInd) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaCurveCompoSetTempParam( lua_State* L)
{
  // 3 parametri : Id, nCrv, dParam [, nParamInd]
   int nId ;
   LuaCheckParam( L, 1, nId)
   int nCrv ;
   LuaCheckParam( L, 2, nCrv)
   double dParam ;
   LuaCheckParam( L, 3, dParam)
   int nParamInd = 0 ;
   LuaGetParam( L, 4, nParamInd) ;
   LuaClearStack( L) ;
  // imposto sulla curva della composita il parametro temporaneo
   bool bOk = ExeCurveCompoSetTempParam( nId, nCrv, dParam, nParamInd) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaChainCurvesInGroup( lua_State* L)
{
  // 2, 3 o 4 parametri : nGroupId, ptNear [, nRefType] [, dToler]
   int nGroupId ;
   LuaCheckParam( L, 1, nGroupId)
   Point3d ptNear ;
   LuaCheckParam( L, 2, ptNear)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 3, nRefType) ;
   double dToler = 10 * EPS_SMALL ;
   LuaGetParam( L, 4, dToler) ;
   LuaClearStack( L) ;
  // concateno le curve nel gruppo (senza fonderle in una curva composita)
   bool bOk = ExeChainCurvesInGroup( nGroupId, ptNear, nRefType, dToler) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaReorderCurvesInGroup( lua_State* L)
{
  // 2, 3 o 4 parametri : nGroupId, ptNear [, nRefType] [, dToler]
   int nGroupId ;
   LuaCheckParam( L, 1, nGroupId)
   Point3d ptNear ;
   LuaCheckParam( L, 2, ptNear)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 3, nRefType) ;
   double dToler = 10 * EPS_SMALL ;
   LuaGetParam( L, 4, dToler) ;
   LuaClearStack( L) ;
  // riordino le curve nel gruppo (senza fonderle in una curva composita)
   bool bOk = ExeReorderCurvesInGroup( nGroupId, ptNear, nRefType, dToler) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaProjectCurveOnSurf( lua_State* L)
{
  // 3, 4 o 5 parametri : nCurveId, vSurfId, nDestGrpId [, dLinTol [, dMaxSegmLen]]
   int nCurveId ;
   LuaCheckParam( L, 1, nCurveId)
   INTVECTOR vSurfId ;
   LuaCheckParam( L, 2, vSurfId)
   int nDestGrpId ;
   LuaCheckParam( L, 3, nDestGrpId)
   double dLinTol = 0.01 ;
   double dMaxSegmLen = INFINITO ;
   if ( LuaGetParam( L, 4, dLinTol))
      LuaGetParam( L, 5, dMaxSegmLen) ;
   LuaClearStack( L) ;
  // proietto la curva su una o più superfici a minima distanza
   bool bOk = ExeProjectCurveOnSurf( nCurveId, vSurfId, nDestGrpId, dLinTol, dMaxSegmLen) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaProjectCurveOnSurfDir( lua_State* L)
{
  // 4, 5, 6, 7 o 8 parametri : nCurveId, vSurfId, vtDir, nDestGrpId [, dLinTol [, dMaxSegmLen] [, bDirFromProj] [,bFromVsTo] [, nRefType]]
   int nCurveId ;
   LuaCheckParam( L, 1, nCurveId)
   INTVECTOR vSurfId ;
   LuaCheckParam( L, 2, vSurfId)
   Vector3d vtDir ;
   LuaCheckParam( L, 3, vtDir)
   int nDestGrpId ;
   LuaCheckParam( L, 4, nDestGrpId)
   double dLinTol = 0.01 ;
   double dMaxSegmLen = INFINITO ;
   bool bDirFromProj = false ;
   bool bFromVsTo = true ;
   int nRefType = RTY_DEFAULT ;
   if ( LuaGetParam( L, 5, dLinTol)  &&
        LuaGetParam( L, 6, dMaxSegmLen)  &&
        LuaGetParam( L, 7, bDirFromProj)  &&
        LuaGetParam( L, 8, bFromVsTo))
      LuaGetParam( L, 9, nRefType) ;
   LuaClearStack( L) ;
  // proietto la curva su una o più superfici secondo la direzione data
   bool bOk = ExeProjectCurveOnSurfDir( nCurveId, vSurfId, vtDir, nDestGrpId, dLinTol, dMaxSegmLen, bDirFromProj, bFromVsTo, nRefType) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaProjectCurveOnSurfExt( lua_State* L)
{
  // 4, 5, 6 o 7 parametri : nCurveId, vSurfId, nGuideId, nDestGrpId [, dLinTol [, dMaxSegmLen] [, bDirFromGuide] [,bFromVsTo]]
   int nCurveId ;
   LuaCheckParam( L, 1, nCurveId)
   INTVECTOR vSurfId ;
   LuaCheckParam( L, 2, vSurfId)
   int nGuideId ;
   LuaCheckParam( L, 3, nGuideId)
   int nDestGrpId ;
   LuaCheckParam( L, 4, nDestGrpId)
   double dLinTol = 0.01 ;
   double dMaxSegmLen = INFINITO ;
   bool bDirFromGuide = false ;
   bool bFromVsTo = true ;
   if ( LuaGetParam( L, 5, dLinTol)  &&
        LuaGetParam( L, 6, dMaxSegmLen)  &&
        LuaGetParam( L, 7, bDirFromGuide))
      LuaGetParam( L, 8, bFromVsTo) ;
   LuaClearStack( L) ;
  // proietto la curva su una o più superfici secondo la direzione verso la guida
   bool bOk = ExeProjectCurveOnSurfExt( nCurveId, vSurfId, nGuideId, nDestGrpId, dLinTol, dMaxSegmLen, bDirFromGuide, bFromVsTo) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaCurveGetVoronoi( lua_State* L)
{
  // 2 o 3 parametri : Id/s, nDestGrpId [, nBound]
   INTVECTOR vIds ;
   LuaCheckParam( L, 1, vIds)
   int nDestGrpId ;
   LuaCheckParam( L, 2, nDestGrpId)
   int nBound = 3 ;      // VORONOI_STD_BOUND
   LuaGetParam( L, 3, nBound) ;
   LuaClearStack( L) ;
  // eseguo
   int nCount = 0 ;
   int nNewId = ExeCurveGetVoronoi( vIds, nDestGrpId, nBound, &nCount) ;
   if ( nNewId != GDB_ID_NULL)
      LuaSetParam( L, nNewId) ;
   else
      LuaSetParam( L) ;
   LuaSetParam( L, nCount) ;

   return 2 ;
}

//----------------------------------------------------------------------------
static int
LuaCurveMedialAxisAdv( lua_State* L)
{
  // 2 o 3 parametri : Id/s, nDestGrpId [, nSide]
   INTVECTOR vIds ;
   LuaCheckParam( L, 1, vIds)
   int nDestGrpId ;
   LuaCheckParam( L, 2, nDestGrpId)
   int nSide = 1 ;         // WMAT_LEFT
   LuaGetParam( L, 3, nSide) ;
   LuaClearStack( L) ;
  // eseguo
   int nCount = 0 ;
   int nNewId = ExeCurveGetMedialAxis( vIds, nDestGrpId, nSide, &nCount) ;
   if ( nNewId != GDB_ID_NULL)
      LuaSetParam( L, nNewId) ;
   else
      LuaSetParam( L) ;
   LuaSetParam( L, nCount) ;

   return 2 ;
}

//----------------------------------------------------------------------------
static int
LuaCurveGetFatCurve( lua_State* L)
{
  // 4 o 5 parametri : Id, nDestGrpId, dRad, bSquare [, bSquareMids]
   int nId ;
   LuaCheckParam( L, 1, nId)
   int nDestGrpId ;
   LuaCheckParam( L, 2, nDestGrpId)
   double dRad ;
   LuaCheckParam( L, 3, dRad)
   bool bSquareEnds ;
   LuaCheckParam( L, 4, bSquareEnds)
   bool bSquareMids = bSquareEnds ;
   LuaGetParam( L, 5, bSquareMids) ;
   LuaClearStack( L) ;
  // eseguo
   int nCount = 0 ;
   int nNewId = ExeCurveGetFatCurve( nId, nDestGrpId, dRad, bSquareEnds, bSquareMids, &nCount) ;
   if ( nNewId != GDB_ID_NULL)
      LuaSetParam( L, nNewId) ;
   else
      LuaSetParam( L) ;
   LuaSetParam( L, nCount) ;

   return 2 ;
}

//----------------------------------------------------------------------------
static int
LuaCurveBezierIncreaseDegree( lua_State* L)
{
   // 1 parametro : CrvId
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
   // eseguo
   bool bOk = ExeCurveBezierIncreaseDegree( nId) ;
   LuaSetParam( L, bOk) ;

   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaCurveBezierDecreaseDegree( lua_State* L)
{
   // 1 parametro : CrvId
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
   // eseguo
   bool bOk = ExeCurveBezierDecreaseDegree( nId) ;
   LuaSetParam( L, bOk) ;

   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaCurveBezierApproxToNonRat( lua_State* L)
{
   // 1 o 2 parametri : CrvId [, dTol]
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dTol = 10 * EPS_SMALL ;
   LuaGetParam( L, 2, dTol) ;
   LuaClearStack( L) ;
   // eseguo
   bool bOk = ExeCurveBezierApproxToNonRat( nId, dTol) ;
   LuaSetParam( L, bOk) ;

   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaCurveBezierApproxWithCubicBeziers( lua_State* L)
{
   // 1 o 2 parametri : CrvId [, dTol]
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dTol = 10 * EPS_SMALL ;
   LuaGetParam( L, 2, dTol) ;
   LuaClearStack( L) ;
   // eseguo
   bool bOk = ExeCurveBezierApproxWithCubicBeziers( nId, dTol) ;
   LuaSetParam( L, bOk) ;

   return 1 ;
}
 
//-------------------------------------------------------------------------------
bool
LuaInstallGdbModifyCurve( LuaMgr& luaMgr)
{
   bool bOk = ( &luaMgr != nullptr) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtInvertCurve", LuaInvertCurve) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOffsetCurve", LuaOffsetCurve) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOffsetCurveAdv", LuaOffsetCurveAdv) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveMedialAxis", LuaCurveMedialAxis) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtApproxCurve", LuaApproxCurve) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtProjectCurveOnPlane", LuaProjectCurveOnPlane) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtChangeClosedCurveStart", LuaChangeClosedCurveStart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtChangeClosedCurveStartPoint", LuaChangeClosedCurveStartPoint) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyCurveStartPoint", LuaModifyCurveStartPoint) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyCurveEndPoint", LuaModifyCurveEndPoint) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSpiralizeCurveAlongExtrusion", LuaSpiralizeCurveAlongExtrusion) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSpiralizeCurveAlongGuide", LuaSpiralizeCurveAlongGuide) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyCurveExtrusion", LuaModifyCurveExtrusion) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyCurveThickness", LuaModifyCurveThickness) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimCurveStartAtLen", LuaTrimCurveStartAtLen) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimCurveEndAtLen", LuaTrimCurveEndAtLen) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimCurveStartAtParam", LuaTrimCurveStartAtParam) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimCurveEndAtParam", LuaTrimCurveEndAtParam) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimCurveStartEndAtParam", LuaTrimCurveStartEndAtParam) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtExtendCurveStartByLen", LuaExtendCurveStartByLen) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtExtendCurveEndByLen", LuaExtendCurveEndByLen) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimExtendCurveByLen", LuaTrimExtendCurveByLen) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimCurveWithRegion", LuaTrimCurveWithRegion) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimFlatCurveWithBox", LuaTrimFlatCurveWithBox) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSplitCurve", LuaSplitCurve) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSplitCurveAtPoint", LuaSplitCurveAtPoint) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSplitCurveAtParam", LuaSplitCurveAtParam) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSplitCurveAtCorners", LuaSplitCurveAtCorners) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSplitCurveAtSelfInters", LuaSplitCurveAtSelfInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyArcRadius", LuaModifyArcRadius) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyArcAngCenter", LuaModifyArcAngCenter) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyArcToExplementary", LuaModifyArcToExplementary) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyArcByFlip", LuaModifyArcByFlip) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCloseCurveCompo", LuaCloseCurveCompo) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAddCurveCompoCurve", LuaAddCurveCompoCurve) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAddCurveCompoLine", LuaAddCurveCompoLine) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAddCurveCompoLineTg", LuaAddCurveCompoLineTg) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAddCurveCompoArc2P", LuaAddCurveCompoArc2P) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAddCurveCompoArcTg", LuaAddCurveCompoArcTg) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveCurveCompoCurve", LuaRemoveCurveCompoCurve) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAddCurveCompoJoint", LuaAddCurveCompoJoint) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyCurveCompoJoint", LuaModifyCurveCompoJoint) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveCurveCompoJoint", LuaRemoveCurveCompoJoint) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMoveCurveCompoCurve", LuaMoveCurveCompoCurve) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyCurveCompoCurveToArc", LuaModifyCurveCompoCurveToArc) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyCurveCompoCurveToLine", LuaModifyCurveCompoCurveToLine) ;  
   bOk = bOk && luaMgr.RegisterFunction( "EgtExplodeCurveCompo", LuaExplodeCurveCompo) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMergeCurvesInCurveCompo", LuaMergeCurvesInCurveCompo) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveCurveCompoUndercutOnY", LuaRemoveCurveCompoUndercutOnY) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoSetTempProp", LuaCurveCompoSetTempProp) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoSetTempParam", LuaCurveCompoSetTempParam) ;  
   bOk = bOk && luaMgr.RegisterFunction( "EgtChainCurvesInGroup", LuaChainCurvesInGroup) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtReorderCurvesInGroup", LuaReorderCurvesInGroup) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtProjectCurveOnSurf", LuaProjectCurveOnSurf) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtProjectCurveOnSurfDir", LuaProjectCurveOnSurfDir) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtProjectCurveOnSurfExt", LuaProjectCurveOnSurfExt) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveGetVoronoi", LuaCurveGetVoronoi) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveMedialAxisAdv", LuaCurveMedialAxisAdv) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveGetFatCurve", LuaCurveGetFatCurve) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveBezierIncreaseDeg", LuaCurveBezierIncreaseDegree) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveBezierDecreaseDeg", LuaCurveBezierDecreaseDegree) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveBezierApproxToNonRat", LuaCurveBezierApproxToNonRat) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtApproxBezierWithCubics", LuaCurveBezierApproxWithCubicBeziers) ;
   return bOk ;
}