//---------------------------------------------------------------------------- // EgalTech 2015-2015 //---------------------------------------------------------------------------- // File : LUA_Nesting.cpp Data : 08.09.15 Versione : 1.6i5 // Contenuto : Funzioni Nesting per LUA. // // // // Modifiche : 08.09.15 DS Creazione modulo. // // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "LUA.h" #include "/EgtDev/Include/EXeExecutor.h" #include "/EgtDev/Include/EGkLuaAux.h" using namespace std ; //------------------------------------------------------------------------------- static int LuaPackBox( lua_State* L) { // 7 parametri : Id, dXmin, dYmin, dXmax, dYmax, dOffs, bBottomUp int nId ; LuaCheckParam( L, 1, nId) double dXmin ; LuaCheckParam( L, 2, dXmin) double dYmin ; LuaCheckParam( L, 3, dYmin) double dXmax ; LuaCheckParam( L, 4, dXmax) double dYmax ; LuaCheckParam( L, 5, dYmax) double dOffs ; LuaCheckParam( L, 6, dOffs) bool bBottomUp ; LuaCheckParam( L, 7, bBottomUp) LuaClearStack( L) ; // eseguo il nesting del pezzo bool bOk = ExePackBox( nId, dXmin, dYmin, dXmax, dYmax, dOffs, bBottomUp) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaPackBoxCluster( lua_State* L) { // 7 parametri : Id/s, dXmin, dYmin, dXmax, dYmax, dOffs, bBottomUp INTVECTOR vIds ; LuaCheckParam( L, 1, vIds) double dXmin ; LuaCheckParam( L, 2, dXmin) double dYmin ; LuaCheckParam( L, 3, dYmin) double dXmax ; LuaCheckParam( L, 4, dXmax) double dYmax ; LuaCheckParam( L, 5, dYmax) double dOffs ; LuaCheckParam( L, 6, dOffs) bool bBottomUp ; LuaCheckParam( L, 7, bBottomUp) LuaClearStack( L) ; // eseguo il nesting dell'insieme di pezzi bool bOk = ExePackBoxCluster( vIds, dXmin, dYmin, dXmax, dYmax, dOffs, bBottomUp) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaVerifyMachining( lua_State* L) { // 1 parametro : OperId int nOperId ; LuaCheckParam( L, 1, nOperId) LuaClearStack( L) ; // eseguo la verifica di interferenza della lavorazione int nFlag ; bool bOk = ExeVerifyMachining( nOperId, nFlag) ; // restituisco il risultato if ( bOk) LuaSetParam( L, nFlag) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaAutoNestStart( lua_State* L) { // nessu parametro LuaClearStack( L) ; // imposto inizio nuovo nesting bool bOk = ExeAutoNestStart() ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaAutoNestSetGuillotineMode( lua_State* L) { // nessu parametro LuaClearStack( L) ; // imposto modalità ghigliottina bool bOk = ExeAutoNestSetGuillotineMode() ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaAutoNestSetStartCorner( lua_State* L) { // 1 parametro : nCorner int nCorner ; LuaCheckParam( L, 1, nCorner) LuaClearStack( L) ; // imposto corner di partenza bool bOk = ExeAutoNestSetStartCorner( nCorner) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaAutoNestAddSheet( lua_State* L) { // 5 parametri : nSheetId, nOutlineId, dKerf, nPriority, nCount int nSheetId ; LuaCheckParam( L, 1, nSheetId) int nOutlineId ; LuaCheckParam( L, 2, nOutlineId) double dKerf ; LuaCheckParam( L, 3, dKerf) int nPriority ; LuaCheckParam( L, 4, nPriority) int nCount ; LuaCheckParam( L, 5, nCount) LuaClearStack( L) ; // aggiungo un pannello al nesting corrente bool bIsRect = false ; bool bOk = ExeAutoNestAddSheet( nSheetId, nOutlineId, dKerf, nPriority, nCount, &bIsRect) ; // restituisco il risultato LuaSetParam( L, bOk) ; LuaSetParam( L, bIsRect) ; return 2 ; } //------------------------------------------------------------------------------- static int LuaAutoNestAddDefectToSheet( lua_State* L) { // 2 parametri : nSheetId, nDefectId int nSheetId ; LuaCheckParam( L, 1, nSheetId) int nDefectId ; LuaCheckParam( L, 2, nDefectId) LuaClearStack( L) ; // aggiungo un difetto al pannello indicato bool bOk = ExeAutoNestAddDefectToSheet( nSheetId, nDefectId) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaAutoNestAddRestrictedZoneToSheet( lua_State* L) { // 3 parametri : nSheetId, nRstZoneId, nRzConstrId int nSheetId ; LuaCheckParam( L, 1, nSheetId) int nRstZoneId ; LuaCheckParam( L, 2, nRstZoneId) int nRzConstrId ; LuaCheckParam( L, 3, nRzConstrId) LuaClearStack( L) ; // aggiungo un difetto al pannello indicato bool bOk = ExeAutoNestAddRestrictedZoneToSheet( nSheetId, nRstZoneId, nRzConstrId) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaAutoNestAddPart( lua_State* L) { // 7 parametri : nPartId, nOutlineId, bCanFlip, bCanRotate, dRotStep, nPriority, nCount int nPartId ; LuaCheckParam( L, 1, nPartId) int nOutlineId ; LuaCheckParam( L, 2, nOutlineId) bool bCanFlip ; LuaCheckParam( L, 3, bCanFlip) bool bCanRotate ; LuaCheckParam( L, 4, bCanRotate) double dRotStep ; LuaCheckParam( L, 5, dRotStep) int nPriority ; LuaCheckParam( L, 6, nPriority) int nCount ; LuaCheckParam( L, 7, nCount) LuaClearStack( L) ; // aggiungo un pezzo al nesting corrente bool bOk = ExeAutoNestAddPart( nPartId, nOutlineId, bCanFlip, bCanRotate, dRotStep, nPriority, nCount) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaAutoNestAddHoleToPart( lua_State* L) { // 2 parametri : nPartId, nHoleId int nPartId ; LuaCheckParam( L, 1, nPartId) int nHoleId ; LuaCheckParam( L, 2, nHoleId) // aggiungo un buco al pezzo indicato bool bOk = ExeAutoNestAddHoleToPart( nPartId, nHoleId) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaAutoNestAddAnotherOutlineToPart( lua_State* L) { // 2 parametri : nPartId, nAnotherOutlineId int nPartId ; LuaCheckParam( L, 1, nPartId) int nAnotherOutlineId ; LuaCheckParam( L, 2, nAnotherOutlineId) // aggiungo un contorno aggiuntivo al pezzo indicato bool bOk = ExeAutoNestAddAnotherOutlineToPart( nPartId, nAnotherOutlineId) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaAutoNestAddToolOutlineToPart( lua_State* L) { // 2 parametri : nPartId, nToolOutlineId int nPartId ; LuaCheckParam( L, 1, nPartId) int nToolOutlineId ; LuaCheckParam( L, 2, nToolOutlineId) // aggiungo una lavorazione al pezzo indicato bool bOk = ExeAutoNestAddToolOutlineToPart( nPartId, nToolOutlineId) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaAutoNestSetRestrictedZoneToPart( lua_State* L) { // 2 parametri : nPartId, nRzConstrId int nPartId ; LuaCheckParam( L, 1, nPartId) int nRzConstrId ; LuaCheckParam( L, 2, nRzConstrId) // aggiungo un vincolo di zona protetta al pezzo indicato bool bOk = ExeAutoNestSetRestrictedZoneToPart( nPartId, nRzConstrId) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaAutoNestSetStripYconstraintToPart( lua_State* L) { // 4 parametri : nPartId, ptRef, dStripStart, dStripRepeat int nPartId ; LuaCheckParam( L, 1, nPartId) Point3d ptRef ; LuaCheckParam( L, 2, ptRef) double dStripStart ; LuaCheckParam( L, 3, dStripStart) double dStripRepeat ; LuaCheckParam( L, 4, dStripRepeat) // aggiungo il vincolo di punto su linee parallele a Y costante (parallele ad asse X) al pezzo bool bOk = ExeAutoNestSetStripYconstraintToPart( nPartId, ptRef, dStripStart, dStripRepeat) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaAutoNestSetStripXconstraintToPart( lua_State* L) { // 4 parametri : nPartId, ptRef, dStripStart, dStripRepeat int nPartId ; LuaCheckParam( L, 1, nPartId) Point3d ptRef ; LuaCheckParam( L, 2, ptRef) double dStripStart ; LuaCheckParam( L, 3, dStripStart) double dStripRepeat ; LuaCheckParam( L, 4, dStripRepeat) // aggiungo il vincolo di punto su linee parallele a X costante (parallele ad asse Y) al pezzo bool bOk = ExeAutoNestSetStripXconstraintToPart( nPartId, ptRef, dStripStart, dStripRepeat) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaAutoNestSetInterpartGap( lua_State* L) { // 1 parametro : dGap double dGap ; LuaCheckParam( L, 1, dGap) LuaClearStack( L) ; // imposto la distanza minima tra i pezzi al nesting corrente bool bOk = ExeAutoNestSetInterpartGap( dGap) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaAutoNestSetShearGap( lua_State* L) { // 1 parametro : dShearGap double dShearGap ; LuaCheckParam( L, 1, dShearGap) LuaClearStack( L) ; // imposto shear gap bool bOk = ExeAutoNestSetShearGap( dShearGap) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaAutoNestSetReportFile( lua_State* L) { // 1 parametro : sReportFile string sReportFile ; LuaCheckParam( L, 1, sReportFile) LuaClearStack( L) ; // imposto file di report di tutti i dati di nesting bool bOk = ExeAutoNestSetReportFile( sReportFile) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaAutoNestCompute( lua_State* L) { // 2 parametro : bMinimizeOnXvsY nMaxTime (ms) bool bMinimizeOnXvsY ; LuaCheckParam( L, 1, bMinimizeOnXvsY) int nMaxTime ; LuaCheckParam( L, 2, nMaxTime) LuaClearStack( L) ; // lancio calcolo del nesting bool bOk = ExeAutoNestCompute( bMinimizeOnXvsY, nMaxTime) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaAutoNestCancelComputation( lua_State* L) { // nessun parametro LuaClearStack( L) ; // lancio interruzione calcolo del nesting bool bOk = ExeAutoNestCancelComputation() ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaAutoNestGetComputationStatus( lua_State* L) { // nessun parametro LuaClearStack( L) ; // recupero lo stato di esecuzione del nesting int nStatus ; bool bOk = ExeAutoNestGetComputationStatus( nStatus) ; // restituisco il risultato LuaSetParam( L, bOk) ; LuaSetParam( L, nStatus) ; return 2 ; } //------------------------------------------------------------------------------- static int LuaAutoNestPrintResults( lua_State* L) { // 1 parametro : sHtmlFile string sHtmlFile ; LuaCheckParam( L, 1, sHtmlFile) LuaClearStack( L) ; // lancio stampa soluzione corrente bool bOk = ExeAutoNestPrintResults( sHtmlFile) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaAutoNestGetResults( lua_State* L) { // nessun parametro LuaClearStack( L) ; // recupero il risultato della soluzione int nNestedParts, nParts, nSheets, nNestings ; double dTotFillRatio ; bool bOk = ExeAutoNestGetResults( nNestedParts, nParts, nSheets, nNestings, dTotFillRatio) ; // restituisco il risultato if ( bOk) { LuaSetParam( L, nNestedParts) ; LuaSetParam( L, nParts) ; LuaSetParam( L, nSheets) ; LuaSetParam( L, nNestings) ; LuaSetParam( L, dTotFillRatio) ; return 5 ; } else { LuaSetParam( L) ; return 1 ; } } //------------------------------------------------------------------------------- static int LuaAutoNestGetOneResult( lua_State* L) { // 1 parametro : nInd int nInd ; LuaCheckParam( L, 1, nInd) LuaClearStack( L) ; // recupero i risultati del nesting int nType, nId, nFlag ; double dX, dY, dAngRot ; bool bOk = ExeAutoNestGetOneResult( nInd, nType, nId, nFlag, dX, dY, dAngRot) ; // restituisco il risultato if ( bOk) { LuaSetParam( L, nType) ; LuaSetParam( L, nId) ; LuaSetParam( L, nFlag) ; LuaSetParam( L, dX) ; LuaSetParam( L, dY) ; LuaSetParam( L, dAngRot) ; return 6 ; } else { LuaSetParam( L) ; return 1 ; } } //------------------------------------------------------------------------------- static int LuaAutoNestCalcShearSequence( lua_State* L) { // 1 parametro : nNesting int nNesting ; LuaCheckParam( L, 1, nNesting) LuaClearStack( L) ; // calcolo shear sequence PNTVECTOR vPtStart, vPtEnd ; bool bOk = ExeAutoNestCalcShearSequence( nNesting, vPtStart, vPtEnd) ; // restituisco il risultato LuaSetParam( L, bOk) ; if ( bOk) { LuaSetParam( L, vPtStart) ; LuaSetParam( L, vPtEnd) ; return 3 ; } else return 1 ; } //------------------------------------------------------------------------------- bool LuaInstallNesting( LuaMgr& luaMgr) { bool bOk = ( &luaMgr != nullptr) ; bOk = bOk && luaMgr.RegisterFunction( "EgtPackBox", LuaPackBox) ; bOk = bOk && luaMgr.RegisterFunction( "EgtPackBoxCluster", LuaPackBoxCluster) ; bOk = bOk && luaMgr.RegisterFunction( "EgtVerifyMachining", LuaVerifyMachining) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestStart", LuaAutoNestStart) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestSetGuillotineMode", LuaAutoNestSetGuillotineMode) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestSetStartCorner", LuaAutoNestSetStartCorner) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestAddSheet", LuaAutoNestAddSheet) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestAddDefectToSheet", LuaAutoNestAddDefectToSheet) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestAddRestrictedZoneToSheet", LuaAutoNestAddRestrictedZoneToSheet) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestAddPart", LuaAutoNestAddPart) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestAddHoleToPart", LuaAutoNestAddHoleToPart) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestAddAnotherOutlineToPart", LuaAutoNestAddAnotherOutlineToPart) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestAddToolOutlineToPart", LuaAutoNestAddToolOutlineToPart) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestSetRestrictedZoneToPart", LuaAutoNestSetRestrictedZoneToPart) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestSetStripYconstraintToPart", LuaAutoNestSetStripYconstraintToPart) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestSetStripXconstraintToPart", LuaAutoNestSetStripXconstraintToPart) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestSetInterpartGap", LuaAutoNestSetInterpartGap) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestSetShearGap", LuaAutoNestSetShearGap) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestSetReportFile", LuaAutoNestSetReportFile) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestCompute", LuaAutoNestCompute) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestCancelComputation", LuaAutoNestCancelComputation) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestGetComputationStatus", LuaAutoNestGetComputationStatus) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestPrintResults", LuaAutoNestPrintResults) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestGetResults", LuaAutoNestGetResults) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestGetOneResult", LuaAutoNestGetOneResult) ; bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestCalcShearSequence", LuaAutoNestCalcShearSequence) ; return bOk ; }