EgtExecutor/LUA_MachOpt.cpp

//----------------------------------------------------------------------------
//  EgalTech 2025-2025
//----------------------------------------------------------------------------
// File : LUA_MachOpt.cpp       Data : 02.04.25       Versione : 2.7c1
// Contenuto : Funzioni per Ottimizzare i tempi tra le lavorazioni per LUA.
//
//
//
// Modifiche : 02.04.25 RE Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "LUA.h"
#include "/EgtDev/Include/EXeExecutor.h"
#include "/EgtDev/Include/EGkLuaAux.h"
#include "/EgtDev/Include/EGnStringUtils.h"

using namespace std ;

//-------------------------------------------------------------------------------
static int
LuaOptMachInit( lua_State* L)
{
  // Nessun parametro
   LuaClearStack( L) ;
  // Inizializzo il calcolatore per minimizzare i tempi tra le lavorazioni
   bool bOk = ExeOptMachInit() ;
  // Restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaOptMachTerminate( lua_State* L)
{
  // Nessun parametro
   LuaClearStack( L) ;
  // Termino il calcolatore per minimizzare i tempi tra le lavorazioni
   bool bOk = ExeOptMachTerminate() ;
  // Restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaOptMachAddTool( lua_State* L)
{
  // Definizione 9 parametri (3 obbligatori)
   int nId ;
   LuaCheckParam( L, 1, nId) ;
   double dTLoad ;
   LuaCheckParam( L, 2, dTLoad) ;
   double dTUnload ;
   LuaCheckParam( L, 3, dTUnload) ;
   double dTC_X = 0. ;
   bool bTC_X = LuaGetParam( L, 4, dTC_X) ;
   double dTC_Y = 0. ;
   bool bTC_Y = LuaGetParam( L, 5, dTC_Y) ;
   double dTC_Z = 0. ;
   bool bTC_Z = LuaGetParam( L, 6, dTC_Z) ;
   double dTC_A = 0. ;
   bool bTC_A = LuaGetParam( L, 7, dTC_A) ;
   double dTC_B = 0. ;
   bool bTC_B = LuaGetParam( L, 8, dTC_B) ;
   double dTC_C = 0. ;
   bool bTC_C = LuaGetParam( L, 9, dTC_C) ;
   LuaClearStack( L) ;
  // Aggiungo la Lavorazione
   bool bOk = ExeOptMachAddTool( nId, dTC_X, dTC_Y, dTC_Z, dTC_A, dTC_B, dTC_C,
                                      bTC_X, bTC_Y, bTC_Z, bTC_A, bTC_B, bTC_C,
                                 dTLoad, dTUnload) ;
  // Rstituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaOptMachAddMachining( lua_State* L)
{
  // Definizione 5 parametri
   int nId ;
   LuaCheckParam( L, 1, nId) ;
   int nToolId ;
   LuaCheckParam( L, 2, nToolId) ;
   int nGroup ;
   LuaCheckParam( L, 3, nGroup) ;
   DBLVECTOR vAxStart ;
   LuaCheckParam( L, 4, vAxStart) ;
   DBLVECTOR vAxEnd ;
   LuaCheckParam( L, 5, vAxEnd) ;
   LuaClearStack( L) ;
  // Completamento valori assi
   while ( vAxStart.size() < 6)
      vAxStart.push_back( 0) ;
   while ( vAxEnd.size() < 6)
      vAxEnd.push_back( 0) ;
  // Aggiungo la Lavorazione
   bool bOk = ExeOptMachAddMachining( nId, nToolId, nGroup,
                                      vAxStart[0], vAxStart[1], vAxStart[2], vAxStart[3], vAxStart[4], vAxStart[5],
                                      vAxEnd[0], vAxEnd[1], vAxEnd[2], vAxEnd[3], vAxEnd[4], vAxEnd[5]) ;
  // Rstituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaOptMachSetFirstMachining( lua_State* L)
{
   // 1 parametro : nId
   int nId = 0 ;
   LuaCheckParam( L, 1, nId) ;
   LuaClearStack( L) ;
  // Imposto la prima lavorazione
   bool bOk = ExeOptMachSetFirstMachining( nId) ;
  // Restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//------------------------------------------------------------------------------
static int
LuaOptMachSetLastMachining( lua_State* L)
{
   // 1 parametro : nId
   int nId = 0 ;
   LuaCheckParam( L, 1, nId) ;
   LuaClearStack( L) ;
  // Imposto la prima lavorazione
   bool bOk = ExeOptMachSetLastMachining( nId) ;
  // Restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//------------------------------------------------------------------------------
static int
LuaOptMachSetFeeds( lua_State* L)
{
  // 2 Parametri : dFeedL, dFeedA
   double dFeedL = 1. ;
   LuaCheckParam( L, 1, dFeedL) ;
   double dFeedA = 1. ;
   LuaCheckParam( L, 2, dFeedA) ;
   LuaClearStack( L) ;
  // Imposto le Feeds
   bool bOk = ExeOptMachSetFeeds( dFeedL, dFeedA) ;
  // Restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaOptMachAddDependence( lua_State* L)
{
  // 2 parametri : nIdPrev, nIdSucc
   int nIdPrev = 0 ; int nIdNext = 0 ;
   LuaCheckParam( L, 1, nIdPrev) ;
   LuaCheckParam( L, 2, nIdNext) ;
   LuaClearStack( L) ;
  // Imposto Dipendenza obbligatoria
   bool bOk = ExeOptMachAddDependence( nIdPrev, nIdNext) ;
  // Restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaOptMachAddSuggestedDependence( lua_State* L)
{
  // 2 parametri : nIdPrev, nIdSucc
   int nIdPrev = 0 ; int nIdNext = 0 ;
   LuaCheckParam( L, 1, nIdPrev) ;
   LuaCheckParam( L, 2, nIdNext) ;
   LuaClearStack( L) ;
  // Imposto Dipendenza suggerita
   bool bOk = ExeOptMachAddSuggestedDependence( nIdPrev, nIdNext) ;
  // Restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaOptMachSetAllGroupDependencesAsMandatory( lua_State* L)
{
  // 1 Parametro : bAllMendatory
   bool bAllMendatory = false ;
   LuaCheckParam( L, 1, bAllMendatory) ;
   LuaClearStack( L) ;
  // Imposto il Flag
   bool bOk = ExeOptMachSetAllGroupDependencesAsMandatory( bAllMendatory) ;
  // Restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaOptMachSetOptimizationForGroups( lua_State* L)
{
  // 1 Parametro : bOptForGroups
   bool bOptForGroups = false ;
   LuaCheckParam( L, 1, bOptForGroups) ;
   LuaClearStack( L) ;
  // Imposto il Flag
   bool bOk = ExeOptMachSetOptimizationForGroups( bOptForGroups) ;
  // Restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaOptMachSetOpenBound( lua_State* L)
{
  // 5 parametri : bStartVsEnd, nFlag, dX, dY, dZ
   bool bStartVsEnd ;
   LuaCheckParam( L, 1, bStartVsEnd) ;
   int nFlag ;
   LuaCheckParam( L, 2, nFlag) ;
   double dX ;
   LuaCheckParam( L, 3, dX) ;
   double dY ;
   LuaCheckParam( L, 4, dY) ;
   double dZ ;
   LuaCheckParam( L, 5, dZ) ;
   LuaClearStack( L) ;
  // Imposto la condizione
   bool bOk = ExeOptMachSetOpenBound( bStartVsEnd, nFlag, dX, dY, dZ) ;
  // Restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaOptMachSetOpenBoundForGroups( lua_State* L)
{
  // 6 parametri : nGroup, bStartVsEnd, nFlag, dX, dY, dZ
   int nGroup ;
   LuaCheckParam( L, 1, nGroup) ;
   bool bStartVsEnd ;
   LuaCheckParam( L, 2, bStartVsEnd) ;
   int nFlag ;
   LuaCheckParam( L, 3, nFlag) ;
   double dX ;
   LuaCheckParam( L, 4, dX) ;
   double dY ;
   LuaCheckParam( L, 5, dY) ;
   double dZ ;
   LuaCheckParam( L, 6, dZ) ;
   LuaClearStack( L) ;
  // Imposto la condizione
   bool bOk = ExeOptMachSetOpenBoundForGroups( nGroup, bStartVsEnd, nFlag, dX, dY, dZ) ;
  // Restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaOptMachCalculate( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // eseguo calcolo di minimo percorso
   INTVECTOR vOrder ;
   bool bOk = ExeOptMachCalculate( vOrder) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, vOrder) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
bool
LuaInstallMachiningOptimization( LuaMgr& luaMgr)
{
   bool bOk = ( &luaMgr != nullptr) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachInit", LuaOptMachInit) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachTerminate", LuaOptMachTerminate) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachAddTool", LuaOptMachAddTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachAddMachining", LuaOptMachAddMachining) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetFirstMachining", LuaOptMachSetFirstMachining) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetLastMachining", LuaOptMachSetLastMachining) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetFeeds", LuaOptMachSetFeeds) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachAddDependence", LuaOptMachAddDependence) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachAddSuggestedDependence", LuaOptMachAddSuggestedDependence) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetAllGroupsDependencesAsMandatory", LuaOptMachSetAllGroupDependencesAsMandatory) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetOptimizationForGroups", LuaOptMachSetOptimizationForGroups) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetOpenBound", LuaOptMachSetOpenBound) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetOpenBoundForGroups", LuaOptMachSetOpenBoundForGroups) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachCalculate", LuaOptMachCalculate) ;
   return bOk ;
}