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 "LUA.h"
#include "API.h"
#include "/EgtDev/Include/EInAPI.h"
#include "/EgtDev/Include/EGkCurve.h"
#include "/EgtDev/Extern/Lua/Include/lua.hpp"

using namespace std ;


//----------------------------------------------------------------------------
static int
LuaInvertCurve( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // inverto la curva
   bool bOk = ( EgtInvertCurve( nId) ? true : false) ;
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaOffsetCurve( lua_State* L)
{
  // 3 parametri : Id, dDist, nType
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dDist ;
   LuaCheckParam( L, 2, dDist)
   int nType = ICurve::OFF_FILLET ;
   if ( lua_gettop( L) >= 3) {
      string sType ;
      LuaCheckParam( L, 3, sType)
      if ( sType == "CHAMFER")
         nType = ICurve::OFF_CHAMFER ;
      else if ( sType == "EXTEND")
         nType = ICurve::OFF_EXTEND ;
   }
   LuaClearStack( L) ;
  // offset della curva
   bool bOk = ( EgtOffsetCurve( nId, dDist, nType) != FALSE) ;
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaModifyCurveStartPoint( lua_State* L)
{
  // 2 parametri : Id, NewStart
   int nId ;
   LuaCheckParam( L, 1, nId)
   Point3d ptStart ;
   LuaCheckParam( L, 2, ptStart)
   LuaClearStack( L) ;
  // modifico il punto iniziale
   bool bOk = ( EgtModifyCurveStartPoint( nId, ptStart.v) ? true : false) ;
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaModifyCurveEndPoint( lua_State* L)
{
  // 2 parametri : Id, NewEnd
   int nId ;
   LuaCheckParam( L, 1, nId)
   Point3d ptEnd ;
   LuaCheckParam( L, 2, ptEnd)
   LuaClearStack( L) ;
  // modifico il punto finale
   bool bOk = ( EgtModifyCurveEndPoint( nId, ptEnd.v) ? true : false) ;
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaModifyCurveExtrusion( lua_State* L)
{
  // 2 parametri : Id/s, vtExtr
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   Vector3d vtExtr ;
   LuaCheckParam( L, 2, vtExtr)
   LuaClearStack( L) ;
  // modifico il vettore estrusione
   bool bOk = true ;
   for ( size_t i = 0 ; i < vId.size() && bOk ; ++ i) {
      if ( EgtModifyCurveExtrusion( vId[i], vtExtr.v) == FALSE)
         bOk = false ;
   }
  // 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 il vettore estrusione
   bool bOk = true ;
   for ( size_t i = 0 ; i < vId.size() && bOk ; ++ i) {
      if ( EgtModifyCurveThickness( vId[i], dThick) == 0)
         bOk = false ;
   }
  // 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) ? true : 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) ? true : 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) ? true : 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) ? true : 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) ? true : false) ;
   LuaSetReturn( L, bOk) ;
   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 ;
}

//-------------------------------------------------------------------------------
bool
LuaInstallGdbModifyCurve( lua_State* L)
{
   try {
      lua_register( L, "EgtInvertCurve", LuaInvertCurve) ;
      lua_register( L, "EgtOffsetCurve", LuaOffsetCurve) ;
      lua_register( L, "EgtModifyCurveStartPoint", LuaModifyCurveStartPoint) ;
      lua_register( L, "EgtModifyCurveEndPoint", LuaModifyCurveEndPoint) ;
      lua_register( L, "EgtModifyCurveExtrusion", LuaModifyCurveExtrusion) ;
      lua_register( L, "EgtModifyCurveThickness", LuaModifyCurveThickness) ;
      lua_register( L, "EgtTrimCurveStartAtLen", LuaTrimCurveStartAtLen) ;
      lua_register( L, "EgtTrimCurveEndAtLen", LuaTrimCurveEndAtLen) ;
      lua_register( L, "EgtTrimCurveStartAtParam", LuaTrimCurveStartAtParam) ;
      lua_register( L, "EgtTrimCurveEndAtParam", LuaTrimCurveEndAtParam) ;
      lua_register( L, "EgtTrimCurveStartEndAtParam", LuaTrimCurveStartEndAtParam) ;
      lua_register( L, "EgtModifyCurveArcRadius", LuaModifyCurveArcRadius) ;
   }
   catch ( ...) {
      return false ;
   }
   return true ;
}