Dario Sassi
b19dc441e7
- aggiunte ExeCreateCurveCompoByApproximation e la corrispondente per LUA_GdbCreateCurve.cpp - corretta ExeCurveDomain
955 lines
30 KiB
C++
955 lines
30 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2014-2014
|
|
//----------------------------------------------------------------------------
|
|
// File : LUA_GdbCreateCurve.cpp Data : 07.01.15 Versione : 1.6a1
|
|
// Contenuto : Funzioni di creazione curve per LUA.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 07.01.15 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "LUA.h"
|
|
#include "/EgtDev/Include/EXeExecutor.h"
|
|
#include "/EgtDev/Include/EXeConst.h"
|
|
#include "/EgtDev/Include/EGkGdbConst.h"
|
|
#include "/EgtDev/Include/EGkLuaAux.h"
|
|
|
|
using namespace std ;
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveLine( lua_State* L)
|
|
{
|
|
// 3 o 4 parametri : ParentId, PtIni, PtFin [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptIni ;
|
|
LuaCheckParam( L, 2, ptIni)
|
|
Point3d ptFin ;
|
|
LuaCheckParam( L, 3, ptFin)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 4, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo il segmento di retta
|
|
int nId = ExeCreateCurveLine( nParentId, ptIni, ptFin, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveLineEx( lua_State* L)
|
|
{
|
|
// 7 o 8 parametri : ParentId, PtIni, nSepI, nIdI, PtFin, nSepF, nIdF [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptIni ;
|
|
LuaCheckParam( L, 2, ptIni)
|
|
int nSepI ;
|
|
LuaCheckParam( L, 3, nSepI)
|
|
int nIdI ;
|
|
LuaCheckParam( L, 4, nIdI)
|
|
Point3d ptFin ;
|
|
LuaCheckParam( L, 5, ptFin)
|
|
int nSepF ;
|
|
LuaCheckParam( L, 6, nSepF)
|
|
int nIdF ;
|
|
LuaCheckParam( L, 7, nIdF)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 8, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo il segmento di retta
|
|
int nId = ExeCreateCurveLineEx( nParentId,
|
|
ptIni, nSepI, nIdI,
|
|
ptFin, nSepF, nIdF, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveLinePDL( lua_State* L)
|
|
{
|
|
// 4 o 5 parametri : ParentId, PtIni, dDirDeg, dLen [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptIni ;
|
|
LuaCheckParam( L, 2, ptIni)
|
|
double dDirDeg ;
|
|
LuaCheckParam( L, 3, dDirDeg)
|
|
double dLen ;
|
|
LuaCheckParam( L, 4, dLen)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 5, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo il segmento di retta
|
|
int nId = ExeCreateCurveLinePDL( nParentId, ptIni, dDirDeg, dLen, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveLinePVL( lua_State* L)
|
|
{
|
|
// 4 o 5 parametri : ParentId, PtIni, VtDir, dLen [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptIni ;
|
|
LuaCheckParam( L, 2, ptIni)
|
|
Vector3d vtDir ;
|
|
LuaCheckParam( L, 3, vtDir)
|
|
double dLen ;
|
|
LuaCheckParam( L, 4, dLen)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 5, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo il segmento di retta
|
|
int nId = ExeCreateCurveLinePVL( nParentId, ptIni, vtDir, dLen, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveLineMinPointCurve( lua_State* L)
|
|
{
|
|
// 3 o 4 o 5 parametri : ParentId, PtIni, CrvId [, NearPar] [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptIni ;
|
|
LuaCheckParam( L, 2, ptIni)
|
|
int nCrvId ;
|
|
LuaCheckParam( L, 3, nCrvId)
|
|
double dNearPar = 0 ;
|
|
int nRefType = RTY_DEFAULT ;
|
|
if ( LuaGetParam( L, 4, dNearPar))
|
|
LuaGetParam( L, 5, nRefType) ;
|
|
else
|
|
LuaGetParam( L, 4, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo il segmento di retta
|
|
int nId = ExeCreateCurveLineMinPointCurve( nParentId, ptIni, nCrvId, dNearPar, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveCircle( lua_State* L)
|
|
{
|
|
// 3 o 4 parametri : ParentId, PtCen, Rad [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptCen ;
|
|
LuaCheckParam( L, 2, ptCen)
|
|
double dRad ;
|
|
LuaCheckParam( L, 3, dRad)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 4, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = ExeCreateCurveCircle( nParentId, ptCen, dRad, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveCircleCP( lua_State* L)
|
|
{
|
|
// 3 o 4 parametri : ParentId, PtCen, PtOn [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptCen ;
|
|
LuaCheckParam( L, 2, ptCen)
|
|
Point3d ptOn ;
|
|
LuaCheckParam( L, 3, ptOn)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 4, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = ExeCreateCurveCircleCP( nParentId, ptCen, ptOn, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveCircleCPEx( lua_State* L)
|
|
{
|
|
// 5 o 6 parametri : ParentId, PtCen, PtOn, nSepO, nIdO [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptCen ;
|
|
LuaCheckParam( L, 2, ptCen)
|
|
Point3d ptOn ;
|
|
LuaCheckParam( L, 3, ptOn)
|
|
int nSepO ;
|
|
LuaCheckParam( L, 4, nSepO)
|
|
int nIdO ;
|
|
LuaCheckParam( L, 5, nIdO)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 6, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = ExeCreateCurveCircleCPEx( nParentId, ptCen, ptOn, nSepO, nIdO, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveCircle3P( lua_State* L)
|
|
{
|
|
// 4 o 5 parametri : ParentId, PtP1, PtP2, PtP3 [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptP1 ;
|
|
LuaCheckParam( L, 2, ptP1)
|
|
Point3d ptP2 ;
|
|
LuaCheckParam( L, 3, ptP2)
|
|
Point3d ptP3 ;
|
|
LuaCheckParam( L, 4, ptP3)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 5, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = ExeCreateCurveCircle3P( nParentId, ptP1, ptP2, ptP3, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveArc( lua_State* L)
|
|
{
|
|
// 6 o 7 parametri : ParentId, PtCen, Rad, AngIniDeg, AngCenDeg, DeltaN [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptCen ;
|
|
LuaCheckParam( L, 2, ptCen)
|
|
double dRad ;
|
|
LuaCheckParam( L, 3, dRad)
|
|
double dAngIniDeg ;
|
|
LuaCheckParam( L, 4, dAngIniDeg)
|
|
double dAngCenDeg ;
|
|
LuaCheckParam( L, 5, dAngCenDeg)
|
|
double dDeltaN ;
|
|
LuaCheckParam( L, 6, dDeltaN)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 7, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = ExeCreateCurveArc( nParentId, ptCen, dRad, dAngIniDeg, dAngCenDeg, dDeltaN, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveArcC2P( lua_State* L)
|
|
{
|
|
// 4 o 5 parametri : ParentId, PtCen, PtStart, PtNearEnd [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptCen ;
|
|
LuaCheckParam( L, 2, ptCen)
|
|
Point3d ptStart ;
|
|
LuaCheckParam( L, 3, ptStart)
|
|
Point3d ptNearEnd ;
|
|
LuaCheckParam( L, 4, ptNearEnd)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 5, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = ExeCreateCurveArcC2P( nParentId, ptCen, ptStart, ptNearEnd, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveArcC2PEx( lua_State* L)
|
|
{
|
|
// 6 o 7 parametri : ParentId, PtCen, PtStart, nSepS, nIdS, PtNearEnd [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptCen ;
|
|
LuaCheckParam( L, 2, ptCen)
|
|
Point3d ptStart ;
|
|
LuaCheckParam( L, 3, ptStart)
|
|
int nSepS ;
|
|
LuaCheckParam( L, 4, nSepS)
|
|
int nIdS ;
|
|
LuaCheckParam( L, 5, nIdS)
|
|
Point3d ptNearEnd ;
|
|
LuaCheckParam( L, 6, ptNearEnd)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 7, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = ExeCreateCurveArcC2PEx( nParentId, ptCen, ptStart, nSepS, nIdS, ptNearEnd, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveArc3P( lua_State* L)
|
|
{
|
|
// 4 o 5 parametri : ParentId, PtP1, PtP2, PtP3 [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptP1 ;
|
|
LuaCheckParam( L, 2, ptP1)
|
|
Point3d ptP2 ;
|
|
LuaCheckParam( L, 3, ptP2)
|
|
Point3d ptP3 ;
|
|
LuaCheckParam( L, 4, ptP3)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 5, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = ExeCreateCurveArc3P( nParentId, ptP1, ptP2, ptP3, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveArc2PD( lua_State* L)
|
|
{
|
|
// 4 o 5 parametri : ParentId, PtStart, PtEnd, dDirSDeg [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptStart ;
|
|
LuaCheckParam( L, 2, ptStart)
|
|
Point3d ptEnd ;
|
|
LuaCheckParam( L, 3, ptEnd)
|
|
double dDirSDeg ;
|
|
LuaCheckParam( L, 4, dDirSDeg)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 5, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = ExeCreateCurveArc2PD( nParentId, ptStart, ptEnd, dDirSDeg, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveArc2PDEx( lua_State* L)
|
|
{
|
|
// 6 o 7 parametri : ParentId, PtStart, PtEnd, nSepE, nIdE, dDirSDeg [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptStart ;
|
|
LuaCheckParam( L, 2, ptStart)
|
|
Point3d ptEnd ;
|
|
LuaCheckParam( L, 3, ptEnd)
|
|
int nSepE ;
|
|
LuaCheckParam( L, 4, nSepE)
|
|
int nIdE ;
|
|
LuaCheckParam( L, 5, nIdE)
|
|
double dDirSDeg ;
|
|
LuaCheckParam( L, 6, dDirSDeg)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 7, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = ExeCreateCurveArc2PDEx( nParentId, ptStart, ptEnd, nSepE, nIdE,
|
|
dDirSDeg, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveArc2PV( lua_State* L)
|
|
{
|
|
// 4 o 5 parametri : ParentId, PtStart, PtEnd, VtDirS [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptStart ;
|
|
LuaCheckParam( L, 2, ptStart)
|
|
Point3d ptEnd ;
|
|
LuaCheckParam( L, 3, ptEnd)
|
|
Vector3d vtDirS ;
|
|
LuaCheckParam( L, 4, vtDirS)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 5, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = ExeCreateCurveArc2PV( nParentId, ptStart, ptEnd, vtDirS, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveBiArc( lua_State* L)
|
|
{
|
|
// 6 o 7 parametri : ParentId, ptStart, ptEnd, dDirSDeg, dDirEDeg, dPar [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptStart ;
|
|
LuaCheckParam( L, 2, ptStart)
|
|
Point3d ptEnd ;
|
|
LuaCheckParam( L, 3, ptEnd)
|
|
double dDirSDeg ;
|
|
LuaCheckParam( L, 4, dDirSDeg)
|
|
double dDirEDeg ;
|
|
LuaCheckParam( L, 5, dDirEDeg)
|
|
double dPar ;
|
|
LuaCheckParam( L, 6, dPar)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 7, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo l'arco di fillet
|
|
int nId = ExeCreateCurveBiArc( nParentId, ptStart, ptEnd, dDirSDeg, dDirEDeg, dPar, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveFillet( lua_State* L)
|
|
{
|
|
// 7 o 8 parametri : ParentId, nCrv1, PtNear1, nCrv2, PtNear2, dRad, bTrim [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
int nCrv1 ;
|
|
LuaCheckParam( L, 2, nCrv1)
|
|
Point3d ptNear1 ;
|
|
LuaCheckParam( L, 3, ptNear1)
|
|
int nCrv2 ;
|
|
LuaCheckParam( L, 4, nCrv2)
|
|
Point3d ptNear2 ;
|
|
LuaCheckParam( L, 5, ptNear2)
|
|
double dRad ;
|
|
LuaCheckParam( L, 6, dRad)
|
|
bool bTrim ;
|
|
LuaCheckParam( L, 7, bTrim)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 8, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo l'arco di fillet
|
|
int nId = ExeCreateCurveFillet( nParentId, nCrv1, ptNear1, nCrv2, ptNear2,
|
|
dRad, bTrim, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveChamfer( lua_State* L)
|
|
{
|
|
// 7 o 8 parametri : ParentId, nCrv1, PtNear1, nCrv2, PtNear2, dDist, bTrim [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
int nCrv1 ;
|
|
LuaCheckParam( L, 2, nCrv1)
|
|
Point3d ptNear1 ;
|
|
LuaCheckParam( L, 3, ptNear1)
|
|
int nCrv2 ;
|
|
LuaCheckParam( L, 4, nCrv2)
|
|
Point3d ptNear2 ;
|
|
LuaCheckParam( L, 5, ptNear2)
|
|
double dDist ;
|
|
LuaCheckParam( L, 6, dDist)
|
|
bool bTrim ;
|
|
LuaCheckParam( L, 7, bTrim)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 8, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo l'arco di fillet
|
|
int nId = ExeCreateCurveChamfer( nParentId, nCrv1, ptNear1, nCrv2, ptNear2,
|
|
dDist, bTrim, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveBezier( lua_State* L)
|
|
{
|
|
// 3 o 4 parametri : ParentId, Degree, CtrlPnts [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
int nDegree ;
|
|
LuaCheckParam( L, 2, nDegree)
|
|
PNTVECTOR vPnt ;
|
|
LuaCheckParam( L, 3, vPnt)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 4, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo la curva
|
|
int nId = ExeCreateCurveBezier( nParentId, nDegree, vPnt, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveBezierRational( lua_State* L)
|
|
{
|
|
// 3 o 4 parametri : ParentId, Degree, CtrlPntWs [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
int nDegree ;
|
|
LuaCheckParam( L, 2, nDegree)
|
|
PNTUVECTOR vPntW ;
|
|
LuaCheckParam( L, 3, vPntW)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 4, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo la curva
|
|
int nId = ExeCreateCurveBezierRational( nParentId, nDegree, vPntW, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveBezierFromArc( lua_State* L)
|
|
{
|
|
// 2 o 3 parametri : ParentId, ArcId[ , Erase]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
int nArcId ;
|
|
LuaCheckParam( L, 2, nArcId)
|
|
bool bErase = true ;
|
|
LuaGetParam( L, 3, bErase) ;
|
|
LuaClearStack( L) ;
|
|
// creo la curva
|
|
int nId = ExeCreateCurveBezierFromArc( nParentId, nArcId, bErase) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveCompo( lua_State* L)
|
|
{
|
|
// 2 o 3 parametri : ParentId, nIds [, Erase]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
INTVECTOR vIds ;
|
|
LuaCheckParam( L, 2, vIds)
|
|
bool bErase = true ;
|
|
LuaGetParam( L, 3, bErase) ;
|
|
LuaClearStack( L) ;
|
|
// creo la curva composita
|
|
int nId = ExeCreateCurveCompo( nParentId, vIds, bErase) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveCompoByChain( lua_State* L)
|
|
{
|
|
// 3 o 4 o 5 parametri : ParentId, nIds, PtNear [, Erase] [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
INTVECTOR vIds ;
|
|
LuaCheckParam( L, 2, vIds)
|
|
Point3d ptNear ;
|
|
LuaCheckParam( L, 3, ptNear)
|
|
bool bErase = true ;
|
|
int nRefType = RTY_DEFAULT ;
|
|
if ( LuaGetParam( L, 4, bErase))
|
|
LuaGetParam( L, 5, nRefType) ;
|
|
else
|
|
LuaGetParam( L, 4, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo la curva composita
|
|
int nCount = 0 ;
|
|
int nId = ExeCreateCurveCompoByChain( nParentId, vIds, ptNear, bErase, nRefType, &nCount) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
LuaSetParam( L, nCount) ;
|
|
return 2 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveCompoByInterpolation( lua_State* L)
|
|
{
|
|
// 3 o 4 parametri : ParentId, ptPs, nType [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
PNTVECTOR vPnt ;
|
|
LuaCheckParam( L, 2, vPnt)
|
|
int nType ;
|
|
LuaGetParam( L, 3, nType) ;
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 4, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
PolyLine PL ;
|
|
// creo una polilinea a partire dai punti
|
|
for ( size_t i = 0 ; i < vPnt.size() ; ++ i)
|
|
PL.AddUPoint( 0, vPnt[i]) ;
|
|
// creo la curva composita
|
|
int nId = ExeCreateCurveCompoByInterpolation( nParentId, PL, nType, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveCompoByApproximation( lua_State* L)
|
|
{
|
|
// 4 o 5 parametri : ParentId, ptPs, nType, dLinTol [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
PNTVECTOR vPnt ;
|
|
LuaCheckParam( L, 2, vPnt)
|
|
int nType ;
|
|
LuaGetParam( L, 3, nType) ;
|
|
double dLinTol ;
|
|
LuaGetParam( L, 4, dLinTol) ;
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 5, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
PolyLine PL ;
|
|
// creo una polilinea a partire dai punti
|
|
for ( size_t i = 0 ; i < vPnt.size() ; ++ i)
|
|
PL.AddUPoint( 0, vPnt[i]) ;
|
|
// creo la curva composita
|
|
int nId = ExeCreateCurveCompoByApproximation( nParentId, PL, nType, dLinTol, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveCompoFromPoints( lua_State* L)
|
|
{
|
|
// 2 o 3 parametri : ParentId, ptPs [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
PNTVECTOR vPnt ;
|
|
LuaCheckParam( L, 2, vPnt)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 3, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
PolyLine PL ;
|
|
// creo una polilinea a partire dai punti
|
|
for ( size_t i = 0 ; i < vPnt.size() ; ++ i)
|
|
PL.AddUPoint( 0, vPnt[i]) ;
|
|
// creo la curva composita
|
|
int nId = ExeCreateCurveCompoFromPoints( nParentId, PL, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveCompoFromPointBulges( lua_State* L)
|
|
{
|
|
// 2 o 3 parametri : ParentId, ptPBs [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
PNTUVECTOR vPntB ;
|
|
LuaCheckParam( L, 2, vPntB)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 3, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo un poliarco a partire dai punti con bulge
|
|
PolyArc PA ;
|
|
for ( size_t i = 0 ; i < vPntB.size() ; ++ i)
|
|
PA.AddUPoint( 0, vPntB[i].first, vPntB[i].second) ;
|
|
// creo la curva composita
|
|
int nId = ExeCreateCurveCompoFromPointBulges( nParentId, PA, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateRectangle2P( lua_State* L)
|
|
{
|
|
// 3 o 4 parametri : ParentId, PtIni, PtCross [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptIni ;
|
|
LuaCheckParam( L, 2, ptIni)
|
|
Point3d ptCross ;
|
|
LuaCheckParam( L, 3, ptCross)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 4, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo il poligono
|
|
int nId = ExeCreateRectangle2P( nParentId, ptIni, ptCross, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateRectangle3P( lua_State* L)
|
|
{
|
|
// 4 o 5 parametri : ParentId, PtIni, PtCross, PtDir [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptIni ;
|
|
LuaCheckParam( L, 2, ptIni)
|
|
Point3d ptCross ;
|
|
LuaCheckParam( L, 3, ptCross)
|
|
Point3d ptDir ;
|
|
LuaCheckParam( L, 4, ptDir)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 5, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo il poligono
|
|
int nId = ExeCreateRectangle3P( nParentId, ptIni, ptCross, ptDir, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreatePolygonFromRadius( lua_State* L)
|
|
{
|
|
// 4 o 5 parametri : ParentId, nNumSides, PtCen, PtCorn [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
int nNumSides ;
|
|
LuaCheckParam( L, 2, nNumSides)
|
|
Point3d PtCen ;
|
|
LuaCheckParam( L, 3, PtCen)
|
|
Point3d PtCorn ;
|
|
LuaCheckParam( L, 4, PtCorn)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 5, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo il poligono
|
|
int nId = ExeCreatePolygonFromRadius( nParentId, nNumSides, PtCen, PtCorn, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreatePolygonFromApothem( lua_State* L)
|
|
{
|
|
// 4 o 5 parametri : ParentId, nNumSides, PtCen, PtMid [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
int nNumSides ;
|
|
LuaCheckParam( L, 2, nNumSides)
|
|
Point3d PtCen ;
|
|
LuaCheckParam( L, 3, PtCen)
|
|
Point3d PtMid ;
|
|
LuaCheckParam( L, 4, PtMid)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 5, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo il poligono
|
|
int nId = ExeCreatePolygonFromApothem( nParentId, nNumSides, PtCen, PtMid, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreatePolygonFromSide( lua_State* L)
|
|
{
|
|
// 4 o 5 parametri : ParentId, nNumSides, PtIni, PtFin [, nRefType]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
int nNumSides ;
|
|
LuaCheckParam( L, 2, nNumSides)
|
|
Point3d ptIni ;
|
|
LuaCheckParam( L, 3, ptIni)
|
|
Point3d ptFin ;
|
|
LuaCheckParam( L, 4, ptFin)
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 5, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// creo il poligono
|
|
int nId = ExeCreatePolygonFromSide( nParentId, nNumSides, ptIni, ptFin, nRefType) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
bool
|
|
LuaInstallGdbCreateCurve( LuaMgr& luaMgr)
|
|
{
|
|
bool bOk = ( &luaMgr != nullptr) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtLine", LuaCreateCurveLine) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtLineEx", LuaCreateCurveLineEx) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtLinePDL", LuaCreateCurveLinePDL) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtLinePVL", LuaCreateCurveLinePVL) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtLineMinPointCurve", LuaCreateCurveLineMinPointCurve) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCircle", LuaCreateCurveCircle) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCircleCP", LuaCreateCurveCircleCP) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCircleCPEx", LuaCreateCurveCircleCPEx) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCircle3P", LuaCreateCurveCircle3P) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtArc", LuaCreateCurveArc) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtArcC2P", LuaCreateCurveArcC2P) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtArcC2PEx", LuaCreateCurveArcC2PEx) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtArc3P", LuaCreateCurveArc3P) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtArc2PD", LuaCreateCurveArc2PD) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtArc2PDEx", LuaCreateCurveArc2PDEx) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtArc2PV", LuaCreateCurveArc2PV) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtBiArc", LuaCreateCurveBiArc) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveFillet", LuaCreateCurveFillet) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveChamfer", LuaCreateCurveChamfer) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveBezier", LuaCreateCurveBezier) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveBezierRat", LuaCreateCurveBezierRational) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveBezierFromArc", LuaCreateCurveBezierFromArc) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompo", LuaCreateCurveCompo) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoByChain", LuaCreateCurveCompoByChain) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoByInterpolation", LuaCreateCurveCompoByInterpolation) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoByApproximation", LuaCreateCurveCompoByApproximation) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoFromPoints", LuaCreateCurveCompoFromPoints) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoFromPointBulges", LuaCreateCurveCompoFromPointBulges) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtRectangle2P", LuaCreateRectangle2P) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtRectangle3P", LuaCreateRectangle3P) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtPolygonFromRadius", LuaCreatePolygonFromRadius) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtPolygonFromApothem", LuaCreatePolygonFromApothem) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtPolygonFromSide", LuaCreatePolygonFromSide) ;
|
|
return bOk ;
|
|
}
|