Dario Sassi
413 lines
12 KiB
C++
413 lines
12 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2020-2020
|
|
//----------------------------------------------------------------------------
|
|
// File : LUA_GdbGetCurve.cpp Data : 23.03.20 Versione : 2.2c3
|
|
// Contenuto : Funzioni di interrogazione delle curve per LUA.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 23.03.20 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/EGkLuaAux.h"
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaCurveDomain( lua_State* L)
|
|
{
|
|
// 1 parametro : Id
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// recupero il dominio della curva
|
|
double dStart, dEnd ;
|
|
if ( ExeCurveDomain( nId, &dStart, &dEnd)) {
|
|
LuaSetParam( L, dStart) ;
|
|
LuaSetParam( L, dEnd) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaCurveLength( lua_State* L)
|
|
{
|
|
// 1 parametro : Id
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// recupero la lunghezza della curva
|
|
double dLen ;
|
|
if ( ExeCurveLength( nId, &dLen))
|
|
LuaSetParam( L, dLen) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaCurveIsClosed( lua_State* L)
|
|
{
|
|
// 1 parametro : Id
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// verifico se curva chiusa
|
|
bool bClosed = ExeCurveIsClosed( nId) ;
|
|
LuaSetParam( L, bClosed) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaCurveIsFlat( lua_State* L)
|
|
{
|
|
// 1 o 2 parametri : Id [, dToler]
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
double dToler = EPS_SMALL ;
|
|
LuaGetParam( L, 2, dToler) ;
|
|
LuaClearStack( L) ;
|
|
// verifico se curva piatta e restituisco il piano medio
|
|
Plane3d Plane ;
|
|
bool bFlat = ExeCurveIsFlat( nId, Plane, false, dToler) ;
|
|
LuaSetParam( L, bFlat) ;
|
|
LuaSetParam( L, Plane.GetVersN()) ;
|
|
LuaSetParam( L, Plane.GetDist()) ;
|
|
return 3 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaCurveIsACircle( lua_State* L)
|
|
{
|
|
// 1 o 2 parametri : Id [, dToler]
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
double dToler = EPS_SMALL ;
|
|
LuaGetParam( L, 2, dToler) ;
|
|
LuaClearStack( L) ;
|
|
// verifico se curva è equivalente ad una circonferenza
|
|
Point3d ptCen ;
|
|
Vector3d vtN ;
|
|
double dRad ;
|
|
bool bCCW ;
|
|
bool bCircle = ExeCurveIsACircle( nId, ptCen, vtN, dRad, bCCW, dToler) ;
|
|
LuaSetParam( L, bCircle) ;
|
|
LuaSetParam( L, ptCen) ;
|
|
LuaSetParam( L, vtN) ;
|
|
LuaSetParam( L, dRad) ;
|
|
LuaSetParam( L, bCCW) ;
|
|
return 5 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaCurveAreaXY( lua_State* L)
|
|
{
|
|
// 1 parametro : Id
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// recupero l'area della curva proiettata sul piano XY
|
|
double dArea ;
|
|
if ( ExeCurveAreaXY( nId, dArea))
|
|
LuaSetParam( L, dArea) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaCurveArea( lua_State* L)
|
|
{
|
|
// 1 parametro : Id
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// recupero il piano medio della curva e la sua area su di esso
|
|
Plane3d Plane ;
|
|
double dArea ;
|
|
if ( ExeCurveArea( nId, Plane, dArea)) {
|
|
LuaSetParam( L, Plane.GetVersN()) ;
|
|
LuaSetParam( L, Plane.GetDist()) ;
|
|
LuaSetParam( L, dArea) ;
|
|
return 3 ;
|
|
}
|
|
else {
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaCurveExtrusion( lua_State* L)
|
|
{
|
|
// 1 o 2 parametri : Id [, nRefId]
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
int nRefId = nId ;
|
|
LuaGetParam( L, 2, nRefId) ;
|
|
LuaClearStack( L) ;
|
|
// recupero il versore
|
|
Vector3d vtExtr ;
|
|
if ( ExeCurveExtrusion( nId, nRefId, vtExtr))
|
|
LuaSetParam( L, vtExtr) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaCurveThickness( lua_State* L)
|
|
{
|
|
// 1 parametro : Id
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// recupero lo spessore
|
|
double dThick ;
|
|
if ( ExeCurveThickness( nId, &dThick))
|
|
LuaSetParam( L, dThick) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaCurveSelfIntersCount( lua_State* L)
|
|
{
|
|
// 1 parametro : Id
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// recupero il numero di auto-intersezioni
|
|
int nCount ;
|
|
if ( ExeCurveSelfIntersCount( nId, &nCount))
|
|
LuaSetParam( L, nCount) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaCurveMinAreaRectangleXY( lua_State* L)
|
|
{
|
|
// 1 o 2 parametri : Id [, nRefId]
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
int nRefId = nId ;
|
|
LuaGetParam( L, 2, nRefId) ;
|
|
LuaClearStack( L) ;
|
|
// recupero i dati del rettangolo
|
|
Frame3d frRect ;
|
|
double dDimX ;
|
|
double dDimY ;
|
|
bool bOk = ExeCurveMinAreaRectangleXY( nId, nRefId, frRect, dDimX, dDimY) ;
|
|
if ( bOk) {
|
|
LuaSetParam( L, frRect) ;
|
|
LuaSetParam( L, dDimX) ;
|
|
LuaSetParam( L, dDimY) ;
|
|
return 3 ;
|
|
}
|
|
else {
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaGetCurveLinearConvexHullXY( lua_State* L)
|
|
{
|
|
// 1 o 2 o 3 parametri : nId [, dLinTol [, nRefType]]
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
double dLinTol = LIN_TOL_STD ;
|
|
LuaGetParam( L, 2, dLinTol) ;
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 3, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// calcolo il convex hull della curva nel piano XY del riferimento indicato
|
|
int nNewId = ExeGetCurveLinearConvexHullXY( nId, dLinTol, nRefType) ;
|
|
if ( nNewId != GDB_ID_NULL)
|
|
LuaSetParam( L, nNewId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaCurveWithRegionClassify( lua_State* L)
|
|
{
|
|
// 2 parametri : nCurveId, nRegionId
|
|
int nCurveId ;
|
|
LuaCheckParam( L, 1, nCurveId)
|
|
int nRegionId ;
|
|
LuaCheckParam( L, 2, nRegionId) ;
|
|
LuaClearStack( L) ;
|
|
// eseguo la classificazione
|
|
int nRes = ExeCurveWithRegionClassify( nCurveId, nRegionId) ;
|
|
if ( nRes != CRC_NULL)
|
|
LuaSetParam( L, nRes) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaArcRadius( lua_State* L)
|
|
{
|
|
// 1 parametro : Id
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// recupero il raggio
|
|
double dRad ;
|
|
if ( ExeArcRadius( nId, &dRad))
|
|
LuaSetParam( L, dRad) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaArcAngCenter( lua_State* L)
|
|
{
|
|
// 1 parametro : Id
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// recupero l'angolo al centro in gradi
|
|
double pdAngDeg ;
|
|
if ( ExeArcAngCenter( nId, &pdAngDeg))
|
|
LuaSetParam( L, pdAngDeg) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaArcDeltaN( lua_State* L)
|
|
{
|
|
// 1 parametro : Id
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// recupero il delta su normale al suo piano
|
|
double dDeltaN ;
|
|
if ( ExeArcDeltaN( nId, &dDeltaN))
|
|
LuaSetParam( L, dDeltaN) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaArcNormVersor( lua_State* L)
|
|
{
|
|
// 1 o 2 parametri : Id [, nRefId]
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
int nRefId = nId ;
|
|
LuaGetParam( L, 2, nRefId) ;
|
|
LuaClearStack( L) ;
|
|
// recupero il versore
|
|
Vector3d vtNorm ;
|
|
if ( ExeArcNormVersor( nId, nRefId, vtNorm))
|
|
LuaSetParam( L, vtNorm) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaCurveCompoCenter( lua_State* L)
|
|
{
|
|
// 2 o 3 parametri : Id, nCrv [, nRefId]
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
int nCrv ;
|
|
LuaCheckParam( L, 2, nCrv)
|
|
int nRefId = nId ;
|
|
LuaGetParam( L, 3, nRefId) ;
|
|
LuaClearStack( L) ;
|
|
// recupero il centro della curva semplice indicizzata
|
|
Point3d ptCen ;
|
|
if ( ExeCurveCompoCenter( nId, nCrv, nRefId, ptCen))
|
|
LuaSetParam( L, ptCen) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaCurveCompoRadius( lua_State* L)
|
|
{
|
|
// 2 parametri : Id, nCrv
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
int nCrv ;
|
|
LuaCheckParam( L, 2, nCrv)
|
|
LuaClearStack( L) ;
|
|
// recupero il raggio della curva semplice indicizzata
|
|
double dRadius ;
|
|
if ( ExeCurveCompoRadius( nId, nCrv, dRadius))
|
|
LuaSetParam( L, dRadius) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
bool
|
|
LuaInstallGdbGetCurve( LuaMgr& luaMgr)
|
|
{
|
|
bool bOk = ( &luaMgr != nullptr) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveDomain", LuaCurveDomain) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveLength", LuaCurveLength) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveIsClosed", LuaCurveIsClosed) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveIsFlat", LuaCurveIsFlat) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveIsACircle", LuaCurveIsACircle) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveAreaXY", LuaCurveAreaXY) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveArea", LuaCurveArea) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveExtrusion", LuaCurveExtrusion) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveThickness", LuaCurveThickness) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveSelfIntersCount", LuaCurveSelfIntersCount) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveMinAreaRectangleXY", LuaCurveMinAreaRectangleXY) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetCurveLinearConvexHullXY", LuaGetCurveLinearConvexHullXY) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveWithRegionClassify", LuaCurveWithRegionClassify) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtArcRadius", LuaArcRadius) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtArcAngCenter", LuaArcAngCenter) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtArcDeltaN", LuaArcDeltaN) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtArcNormVersor", LuaArcNormVersor) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoCenter", LuaCurveCompoCenter) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoRadius", LuaCurveCompoRadius) ;
|
|
return bOk ;
|
|
}
|