SaraP
4a98a0a25e
- aggiunte funzioni Exe e Lua per calcolo shear sequence nei nesting a ghigliottina.
540 lines
18 KiB
C++
540 lines
18 KiB
C++
//----------------------------------------------------------------------------
|
|
// 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 ;
|
|
}
|