Daniele Bariletti
330 lines
11 KiB
C++
330 lines
11 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2025-2025
|
|
//----------------------------------------------------------------------------
|
|
// File : LUA_Trimming.cpp Data : 23.10.25 Versione : 2.7j3
|
|
// Contenuto : Funzioni per le lavorazioni di Trimming.
|
|
//
|
|
// Modifiche : 23.10.25 RE Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "LUA.h"
|
|
#include "/EgtDev/Include/EXeExecutor.h"
|
|
#include "/EgtDev/Include/EXeConst.h"
|
|
#include "/EgtDev/Include/EGkLuaAux.h"
|
|
#include "/EgtDev/Include/EGnStringUtils.h"
|
|
|
|
using namespace std ;
|
|
|
|
// ------------------------------------------------------------------------------
|
|
static int
|
|
LuaTrimmingGetHoleBorder( lua_State* L)
|
|
{
|
|
// 7 parametri : nPartId, vSurfIds, vOtherSurfIds, dSurfLinTol, dSurfAngTol, dEdgeLinTol, dEdgeAngTol, dEdgeThick
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId) ;
|
|
INTVECTOR vSurfIds ;
|
|
LuaCheckParam( L, 2, vSurfIds) ;
|
|
INTVECTOR vOtherSurfIds ;
|
|
LuaCheckParam( L, 3, vOtherSurfIds) ;
|
|
double dSurfLinTol ;
|
|
LuaCheckParam( L, 4, dSurfLinTol) ;
|
|
double dSurfAngTol ;
|
|
LuaCheckParam( L, 5, dSurfAngTol) ;
|
|
double dEdgeLinTol ;
|
|
LuaCheckParam( L, 6, dEdgeLinTol) ;
|
|
double dEdgeAngTol ;
|
|
LuaCheckParam( L, 7, dEdgeAngTol) ;
|
|
double dEdgeThick ;
|
|
LuaCheckParam( L, 8, dEdgeThick) ;
|
|
LuaClearStack( L) ;
|
|
// Recupero le Curve per Asole e Fori
|
|
int nFirstId = GDB_ID_NULL, nCount = 0 ;
|
|
bool bOk = ExeTrimmingGetHoleBorder( nParentId, vSurfIds, vOtherSurfIds, dSurfLinTol, dSurfAngTol, dEdgeLinTol,
|
|
dEdgeAngTol, dEdgeThick, nFirstId, nCount) ;
|
|
LuaSetParam( L, bOk) ;
|
|
LuaSetParam( L, nFirstId) ;
|
|
LuaSetParam( L, nCount) ;
|
|
return 3 ;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------
|
|
static int
|
|
LuaTrimmingGetSurfTmFaceAdj( lua_State* L)
|
|
{
|
|
// 7 parametri : nParentId, nSurfId, nTria, ptTria, dAngTol, dSize, dSizeTol
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId) ;
|
|
int nSurfId ;
|
|
LuaCheckParam( L, 2, nSurfId)
|
|
int nTria ;
|
|
LuaCheckParam( L, 3, nTria)
|
|
Point3d ptTria ;
|
|
LuaCheckParam( L, 4, ptTria)
|
|
double dAngTol ;
|
|
LuaCheckParam( L, 5, dAngTol)
|
|
double dSize ;
|
|
LuaCheckParam( L, 6, dSize)
|
|
double dSizeTol ;
|
|
LuaCheckParam( L, 7, dSizeTol)
|
|
LuaClearStack( L) ;
|
|
// Recupero le facce adiacenti in tolleranza angolare
|
|
INTVECTOR vOtherFaces ;
|
|
int nNewSurfId = ExeTrimmingGetSurfTmFaceAdj( nParentId, nSurfId, nTria, ptTria, dAngTol, dSize, dSizeTol) ;
|
|
LuaSetParam( L, nNewSurfId) ;
|
|
return 1 ;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------
|
|
static int
|
|
LuaTrimmingGetAdjSurfs( lua_State* L)
|
|
{
|
|
// 5 parametri : nRefSfrId, vAllSurfId, dLinTol, dAngTol, dAngFaceTol
|
|
INTVECTOR vRefSurfId ;
|
|
LuaCheckParam( L, 1, vRefSurfId)
|
|
INTVECTOR vOtherSurfId ;
|
|
LuaCheckParam( L, 2, vOtherSurfId)
|
|
double dLinTol ;
|
|
LuaCheckParam( L, 3, dLinTol)
|
|
double dAngTol ;
|
|
LuaCheckParam( L, 4, dAngTol)
|
|
double dAngFaceTol ;
|
|
LuaCheckParam( L, 5, dAngFaceTol)
|
|
LuaClearStack( L) ;
|
|
// Calcolo le facce adiacenti per tolleranza
|
|
INTVECTOR vOtherSurf ;
|
|
bool bOk = ExeTrimmingGetAdjSurfs( vRefSurfId, vOtherSurfId, dLinTol, dAngTol, dAngFaceTol, vOtherSurf) ;
|
|
// Restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
LuaSetParam( L, vOtherSurf) ;
|
|
return 2 ;
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------
|
|
static int
|
|
LuaTrimmingGetBorders( lua_State* L)
|
|
{
|
|
// 6 parametri : nParentId, vIds, dSurfLinTol, dSurfAngTol, dLinTol, dAngTol
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
SELVECTOR vIds ;
|
|
LuaCheckParam( L, 2, vIds)
|
|
double dSurfLinTol ;
|
|
LuaCheckParam( L, 3, dSurfLinTol) ;
|
|
double dSurfAngTol ;
|
|
LuaCheckParam( L, 4, dSurfAngTol) ;
|
|
double dLinTol ;
|
|
LuaCheckParam( L, 5, dLinTol)
|
|
double dAngTol ;
|
|
LuaCheckParam( L, 6, dAngTol)
|
|
LuaClearStack( L) ;
|
|
// Creo le curve di Edge grezze
|
|
int nFirstId = GDB_ID_NULL ;
|
|
int nCount = 0 ;
|
|
bool bOk = ExeTrimmingGetBorders( nParentId, vIds, dSurfLinTol, dSurfAngTol, dLinTol, dAngTol, nFirstId, nCount) ;
|
|
LuaSetParam( L, bOk) ;
|
|
LuaSetParam( L, nFirstId) ;
|
|
LuaSetParam( L, nCount) ;
|
|
return 3 ;
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------
|
|
static int
|
|
LuaTrimmingGetBordersByNormals( lua_State* L)
|
|
{
|
|
// 7 o 8 parametri : nParentId, vIds, dSurfLinTol, dSurfAngTol, dThickness
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
SELVECTOR vIds ;
|
|
LuaCheckParam( L, 2, vIds)
|
|
double dSurfLinTol ;
|
|
LuaCheckParam( L, 3, dSurfLinTol) ;
|
|
double dSurfAngTol ;
|
|
LuaCheckParam( L, 4, dSurfAngTol) ;
|
|
double dLinTol ;
|
|
LuaCheckParam( L, 5, dLinTol)
|
|
double dAngTol ;
|
|
LuaCheckParam( L, 6, dAngTol)
|
|
double dThickness ;
|
|
LuaCheckParam( L, 7, dThickness)
|
|
LuaClearStack( L) ;
|
|
// Creo le curve di Edge grezze
|
|
int nFirstId = GDB_ID_NULL ;
|
|
int nCount = 0 ;
|
|
bool bOk = ExeTrimmingGetBordersByNormals( nParentId, vIds, dSurfLinTol, dSurfAngTol, dLinTol, dAngTol, dThickness, nFirstId, nCount) ;
|
|
LuaSetParam( L, bOk) ;
|
|
LuaSetParam( L, nFirstId) ;
|
|
LuaSetParam( L, nCount) ;
|
|
return 3 ;
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------
|
|
static int
|
|
LuaTrimmingGetFinalBorders( lua_State* L)
|
|
{
|
|
// 4 o 5 o 6 o 7 parametri : nParentId, vCrvBezierId, dLinTol, dAngTol [,vBreakingPts] [,dThick [,dThickTol]]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
INTVECTOR vCrvBezierId ;
|
|
LuaCheckParam( L, 2, vCrvBezierId)
|
|
double dLinTol ;
|
|
LuaCheckParam( L, 3, dLinTol)
|
|
double dAngTol ;
|
|
LuaCheckParam( L, 4, dAngTol)
|
|
PNTVECTOR vBreakingPts ;
|
|
int nInd = 5 ;
|
|
if ( LuaGetParam( L, nInd, vBreakingPts))
|
|
++ nInd ;
|
|
double dThick = 0., dThickTol = EPS_SMALL ;
|
|
if ( LuaGetParam( L, nInd, dThick)) {
|
|
if ( ! LuaGetParam( L, nInd + 1, dThickTol)) {
|
|
LuaClearStack( L) ;
|
|
LuaSetParam( L, false) ;
|
|
return 1 ;
|
|
}
|
|
}
|
|
LuaClearStack( L) ;
|
|
// Creo le curve Edges
|
|
int nFirstId = GDB_ID_NULL ;
|
|
int nCount = 0 ;
|
|
bool bOk = ExeTrimmingGetFinalBorders( nParentId, vCrvBezierId, dLinTol, dAngTol, vBreakingPts, dThick, dThickTol,
|
|
nFirstId, nCount) ;
|
|
LuaSetParam( L, bOk) ;
|
|
LuaSetParam( L, nFirstId) ;
|
|
LuaSetParam( L, nCount) ;
|
|
return 3 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTrimmingGetRuledBezier( lua_State* L)
|
|
{
|
|
// 5 o 6 parametri : nParentId, vIds, nEdge1Id, nEdge2Id, dLinTol [,vnLineId]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
INTVECTOR vIds ;
|
|
LuaCheckParam( L, 2, vIds) ; // serve per orientare la superficie rigata ( Ids delle superfici)
|
|
int nEdge1Id ;
|
|
LuaCheckParam( L, 3, nEdge1Id)
|
|
int nEdge2Id ;
|
|
LuaCheckParam( L, 4, nEdge2Id)
|
|
double dLinTol ;
|
|
LuaCheckParam( L, 5, dLinTol)
|
|
INTVECTOR vnLineId ;
|
|
LuaGetParam( L, 6, vnLineId) ;
|
|
LuaClearStack( L) ;
|
|
// Calcolo la superficie di Bezier rigata
|
|
int nId = ExeTrimmingGetRuledBezier( nParentId, vIds, nEdge1Id, nEdge2Id, dLinTol, vnLineId) ;
|
|
LuaSetParam( L, nId) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTrimmingInterpolateSyncLines( lua_State* L)
|
|
{
|
|
// 7 parametri : nParentId, nFirstSyncId, nSecondSyncId, nBorder1Id, nBorder2Id, dEdgeLinTol, dEdgeAngTol
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId) ;
|
|
int nSync1Id ;
|
|
LuaCheckParam( L, 2, nSync1Id) ;
|
|
int nSync2Id ;
|
|
LuaCheckParam( L, 3, nSync2Id) ;
|
|
int nBorder1Id ;
|
|
LuaCheckParam( L, 4, nBorder1Id) ;
|
|
int nBorder2Id ;
|
|
LuaCheckParam( L, 5, nBorder2Id) ;
|
|
double dEdgeLinTol ;
|
|
LuaCheckParam( L, 6, dEdgeLinTol) ;
|
|
double dEdgeAngTol ;
|
|
LuaCheckParam( L, 7, dEdgeAngTol) ;
|
|
LuaClearStack( L) ;
|
|
// Interpolo le curve di sincronizzazione
|
|
int nFirstId = GDB_ID_NULL ;
|
|
int nCount = 0 ;
|
|
bool bOk = ExeTrimmingInterpolateSyncLines( nParentId, nSync1Id, nSync2Id, nBorder1Id,
|
|
nBorder2Id, dEdgeLinTol, dEdgeAngTol, nFirstId, nCount) ;
|
|
LuaSetParam( L, bOk) ;
|
|
LuaSetParam( L, nFirstId) ;
|
|
LuaSetParam( L, nCount) ;
|
|
return 3 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTrimmingGetSurfBzSyncPoints( lua_State* L)
|
|
{
|
|
// 7 parametri : nParentId, nEdge1Id, nEdge2Id, dLinTol, dAngTol, nLinesNbr, bShowOnCorners
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
int nEdge1Id ;
|
|
LuaCheckParam( L, 2, nEdge1Id)
|
|
int nEdge2Id ;
|
|
LuaCheckParam( L, 3, nEdge2Id)
|
|
double dLinTol ;
|
|
LuaCheckParam( L, 4, dLinTol)
|
|
double dAngTol ;
|
|
LuaCheckParam( L, 5, dAngTol)
|
|
int nLineNbr ;
|
|
LuaCheckParam( L, 6, nLineNbr)
|
|
bool bShowOnCorners ;
|
|
LuaCheckParam( L, 7, bShowOnCorners)
|
|
LuaClearStack( L) ;
|
|
// Inserisco i tratti lineari associati ai punti di sincronizzazione
|
|
int nFirstId = GDB_ID_NULL ;
|
|
int nCount = 0 ;
|
|
bool bOk = ExeTrimmingGetSurfBzSyncPoints( nParentId, nEdge1Id, nEdge2Id, dLinTol, dAngTol, nLineNbr, bShowOnCorners, nFirstId, nCount) ;
|
|
LuaSetParam( L, bOk) ;
|
|
LuaSetParam( L, nFirstId) ;
|
|
LuaSetParam( L, nCount) ;
|
|
return 3 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaRegolarizeSurfaceLocally( lua_State* L)
|
|
{
|
|
int nParentId = GDB_ID_NULL ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
int nSurfId = GDB_ID_NULL ;
|
|
LuaCheckParam( L, 2, nSurfId)
|
|
int nSyncStartId ;
|
|
LuaCheckParam( L, 3, nSyncStartId)
|
|
int nSyncEndId ;
|
|
LuaCheckParam( L, 4, nSyncEndId)
|
|
double dLinTol ;
|
|
LuaCheckParam( L, 5, dLinTol)
|
|
int nType = 0 ;
|
|
LuaCheckParam( L, 6, nType)
|
|
|
|
int nId = ExeRegolarizeSurfaceLocally( nParentId, nSurfId, nSyncStartId, nSyncEndId, dLinTol, nType) ;
|
|
LuaSetParam( L, nId) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
bool
|
|
LuaInstallTrimming( LuaMgr& luaMgr)
|
|
{
|
|
bool bOk = ( &luaMgr != nullptr) ;
|
|
// --- Ricerca Fori e Asole
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetHoleBorder", LuaTrimmingGetHoleBorder) ;
|
|
// --- Ricerca Superifici
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetSurfTmFaceAdj", LuaTrimmingGetSurfTmFaceAdj) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetAdjSurfs", LuaTrimmingGetAdjSurfs) ;
|
|
// --- Estrazione dei Bordi
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetBorders", LuaTrimmingGetBorders) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetBordersByNormals", LuaTrimmingGetBordersByNormals) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetFinalBorders", LuaTrimmingGetFinalBorders) ;
|
|
// --- Recupero Surf Bezier Ruled
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetRuledBezier", LuaTrimmingGetRuledBezier) ;
|
|
// --- Recupero linee di sincronizzazione
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingInterpolateSyncLines", LuaTrimmingInterpolateSyncLines) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetSurfBzSyncPoints", LuaTrimmingGetSurfBzSyncPoints) ;
|
|
// --- Modifica della superficie
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtRegolarizeSurfaceLocally", LuaRegolarizeSurfaceLocally) ;
|
|
return bOk ;
|
|
} |