SaraP
3ff02fe0fe
- nelle funzioni exe e lua ChainCurvesInGroup e ReorderCurvesInGroup aggiunta tolleranza come parametro opzionale.
1302 lines
41 KiB
C++
1302 lines
41 KiB
C++
//----------------------------------------------------------------------------
|
|
// 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 ;
|
|
}
|