EgtInterface/LUA_GdbModifyCurve.cpp

//----------------------------------------------------------------------------
//  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 "API.h"
#include "LUA.h"
#include "LUA_Base.h"
#include "/EgtDev/Include/EInAPI.h"
#include "/EgtDev/Include/EInConst.h"
#include "/EgtDev/Include/EGkCurve.h"
#include "/EgtDev/Include/EGkLuaAux.h"
#include "/EgtDev/Include/EGnStringUtils.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 = EgtInvertCurve( vId) ;
  // restituisco il risultato
   LuaSetReturn( 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 = ( EgtOffsetCurve( nId, dDist, nType) != FALSE) ;
   LuaSetReturn( 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 = ( EgtChangeClosedCurveStartPoint( nId, ptStart.v, nRefType) != FALSE) ;
   LuaSetReturn( 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 = ( EgtModifyCurveStartPoint( nId, ptStart.v, nRefType) != FALSE) ;
   LuaSetReturn( 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 = ( EgtModifyCurveEndPoint( nId, ptEnd.v, nRefType) != FALSE) ;
   LuaSetReturn( 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 = EgtModifyCurveExtrusion( vId, vtExtr, nRefType) ;
  // restituisco il risultato
   LuaSetReturn( 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 = EgtModifyCurveThickness( vId, dThick) ;
  // restituisco il risultato
   LuaSetReturn( 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 = ( EgtTrimCurveStartAtLen( nId, dLen) != FALSE) ;
   LuaSetReturn( 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 = ( EgtTrimCurveEndAtLen( nId, dLen) != FALSE) ;
   LuaSetReturn( 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 = ( EgtTrimCurveStartAtParam( nId, dPar) != FALSE) ;
   LuaSetReturn( 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 = ( EgtTrimCurveEndAtParam( nId, dPar) != FALSE) ;
   LuaSetReturn( 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 = ( EgtTrimCurveStartEndAtParam( nId, dParS, dParE) != FALSE) ;
   LuaSetReturn( 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 = ( EgtTrimExtendCurveByLen( nId, dLen, ptNear.v, nRefType) != FALSE) ;
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
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 = EgtSplitCurve( nId, nParts) ;
   if ( nFirstId != GDB_ID_NULL)
      LuaSetReturn( L, nFirstId) ;
   else
      LuaSetReturn( 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 = EgtSplitCurveAtPoint( nId, ptOn.v, nRefType) ;
   if ( nNewId != GDB_ID_NULL)
      LuaSetReturn( L, nNewId) ;
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaModifyCurveArcRadius( lua_State* L)
{
  // 2 parametri : Id, dNewRad
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dNewRad ;
   LuaCheckParam( L, 2, dNewRad)
   LuaClearStack( L) ;
  // modifica del raggio
   bool bOk = ( EgtModifyCurveArcRadius( nId, dNewRad) != FALSE) ;
   LuaSetReturn( 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 = EgtExplodeCurveCompo( nId, &nCount) ;
   if ( nFirstId != GDB_ID_NULL)
      LuaSetReturn( L, nFirstId) ;
   else
      LuaSetReturn( L) ;
   LuaSetReturn( L, nCount) ;
   return 2 ;
}

//-------------------------------------------------------------------------------
static int
LuaApproxCurveArc( 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) ;
  // approssimazione dell'arco con rette
   int nNewId = EgtApproxCurveArc( nId, dLinTol) ;
   if ( nNewId != GDB_ID_NULL)
      LuaSetReturn( L, nNewId) ;
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaApproxCurveBezier( lua_State* L)
{
  // 2 o 3 parametri : Id, nArcsVsLines [, dLinTol]
   int nId ;
   LuaCheckParam( L, 1, nId)
   int nTemp ;
   LuaCheckParam( L, 2, nTemp)
   bool bArcsVsLines = ( nTemp != 0) ;
   double dLinTol = 0.01 ;
   LuaGetParam( L, 3, dLinTol) ;
   LuaClearStack( L) ;
  // approssimazione della curva di Bezier con archi o rette
   int nNewId = EgtApproxCurveBezier( nId, bArcsVsLines, dLinTol) ;
   if ( nNewId != GDB_ID_NULL)
      LuaSetReturn( L, nNewId) ;
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
bool
LuaInstallGdbModifyCurve( void)
{
   bool bOk = true ;
   bOk = bOk && LuaRegisterFunction( "EgtInvertCurve", LuaInvertCurve) ;
   bOk = bOk && LuaRegisterFunction( "EgtOffsetCurve", LuaOffsetCurve) ;
   bOk = bOk && LuaRegisterFunction( "EgtChangeClosedCurveStartPoint", LuaChangeClosedCurveStartPoint) ;
   bOk = bOk && LuaRegisterFunction( "EgtModifyCurveStartPoint", LuaModifyCurveStartPoint) ;
   bOk = bOk && LuaRegisterFunction( "EgtModifyCurveEndPoint", LuaModifyCurveEndPoint) ;
   bOk = bOk && LuaRegisterFunction( "EgtModifyCurveExtrusion", LuaModifyCurveExtrusion) ;
   bOk = bOk && LuaRegisterFunction( "EgtModifyCurveThickness", LuaModifyCurveThickness) ;
   bOk = bOk && LuaRegisterFunction( "EgtTrimCurveStartAtLen", LuaTrimCurveStartAtLen) ;
   bOk = bOk && LuaRegisterFunction( "EgtTrimCurveEndAtLen", LuaTrimCurveEndAtLen) ;
   bOk = bOk && LuaRegisterFunction( "EgtTrimCurveStartAtParam", LuaTrimCurveStartAtParam) ;
   bOk = bOk && LuaRegisterFunction( "EgtTrimCurveEndAtParam", LuaTrimCurveEndAtParam) ;
   bOk = bOk && LuaRegisterFunction( "EgtTrimCurveStartEndAtParam", LuaTrimCurveStartEndAtParam) ;
   bOk = bOk && LuaRegisterFunction( "EgtTrimExtendCurveByLen", LuaTrimExtendCurveByLen) ;
   bOk = bOk && LuaRegisterFunction( "EgtSplitCurve", LuaSplitCurve) ;
   bOk = bOk && LuaRegisterFunction( "EgtSplitCurveAtPoint", LuaSplitCurveAtPoint) ;
   bOk = bOk && LuaRegisterFunction( "EgtModifyCurveArcRadius", LuaModifyCurveArcRadius) ;
   bOk = bOk && LuaRegisterFunction( "EgtExplodeCurveCompo", LuaExplodeCurveCompo) ;
   bOk = bOk && LuaRegisterFunction( "EgtApproxCurveArc", LuaApproxCurveArc) ;
   bOk = bOk && LuaRegisterFunction( "EgtApproxCurveBezier", LuaApproxCurveBezier) ;
   return bOk ;
}