-- NestProcess.lua by Egaltech s.r.l. 2022/11/24
-- Gestione nesting automatico pareti

-- Intestazioni
require( 'EgtBase')
_ENV = EgtProtectGlobal()
EgtEnableDebug( false)

-- Per test
--NEST = {}
--NEST.FILE = 'c:\\TechnoEssetre7\\EgtData\\Prods\\0010\\Bar_10_1.btl'
--NEST.MACHINE = 'Essetre-90480019_MW'
--NEST.FLAG = 3
--NEST.MIN_ANGLE_PNT = 60
--NEST.DRILL_MACH_AREA = 0
NEST.LAP_JOINT_U_MACH_AREA = 1  -- 0
NEST.MACH_AREA_USE_OTHER_DIAM = 1  -- 0
NEST.MACH_AREA_OTHER_DIAM = 200
NEST.MACH_AREA_IGNORE_3rdFACE = 1  -- 0

if NEST.FLAG ~= 11 then
   local sLog = 'NestProcess : ' .. NEST.FILE .. ', ' .. NEST.MACHINE .. ', ' .. LEN[1] .. ', ' .. WIDTH[1]
   EgtOutLog( sLog)

   -- Cancello file di log specifico
   local sLogFile = EgtChangePathExtension( NEST.FILE, '.txt')
   EgtEraseFile( sLogFile)
end

-- Imposto direttorio libreria specializzata per Travi
EgtAddToPackagePath( NEST.BASEDIR .. '\\LuaLibs\\?.lua')

-- Verifico che la macchina corrente sia abilitata per la lavorazione delle Pareti
local sMachDir = EgtGetCurrMachineDir()
if not EgtExistsFile( sMachDir .. '\\Wall\\WallData.lua') then
   NEST.ERR = 12
   NEST.MSG = 'Error not configured for walls machine : ' .. sMachine
   WriteErrToLogFile( NEST.ERR, NEST.MSG)
   PostErrView( NEST.ERR, NEST.MSG)
   return
end

-- Elimino direttori altre macchine e imposto direttorio macchina corrente per ricerca librerie
EgtRemoveBaseMachineDirFromPackagePath()
EgtAddToPackagePath( sMachDir .. '\\Wall\\?.lua')

-- Carico le librerie
_G.package.loaded.WallExec = nil
local WE = require( 'WallExec')
_G.package.loaded.WallLib = nil
local WL = require( 'WallLib')
_G.package.loaded.WProcessLapJoint = nil
local LapJoint = require( 'WProcessLapJoint')
_G.package.loaded.WProcessDrill = nil
local Drill = require( 'WProcessDrill')
_G.package.loaded.WProcessDoubleCut = nil
local DoubleCut = require( 'WProcessDoubleCut')
_G.package.loaded.WProcessFreeContour = nil
local FreeContour = require( 'WProcessFreeContour')
_G.package.loaded.PanelSaw = nil
local PanelSaw = require( 'PanelSaw')

-- Carico i dati globali
local WD = require( 'WallData')

-- Recupero alcuni dati dal WallData o li setto a valori di default
local s_dSideMillDiamDown = WD.SIDEMILL_DIAM_DOWN or 350
local s_dSideMillDiamUp = WD.SIDEMILL_DIAM_UP or 65
local s_dHorDrillLen = WD.HOR_DRILL_LEN or 1780
local s_dHorDrillDiam = WD.HOR_DRILL_DIAM or 35
local s_dHorDrillDiam5Axes = WD.HOR_DRILL_DIAM_5AX or 0
local s_sOrigCorner = WD.ORIG_CORNER or 'TL'
local s_dIntRulli = WD.INTRULLI or 1200
local s_dMinRawYHorDrill = WD.MINRAWY_HOR_DRILL or 2800
local s_dNestHoleMinArea = WD.NEST_HOLE_MIN_AREA or 200000
local s_dInsideRawTol = WD.INSIDE_RAW_TOL or 30

-- lista dei pezzi con flip o rotazione
local PartStates = {}

------------------------------------------------------------------
-- Funzioni per scrittura su file di log specifico
local function WriteErrToLogFile( nErr, sMsg, nRot, nCutId, nTaskId)
   local hFile = io.open( sLogFile, 'a')
   hFile:write( 'ERR=' .. tostring( nErr) .. '\n')
   hFile:write( sMsg .. '\n')
   hFile:write( 'ROT=' .. tostring( nRot or 0) .. '\n')
   hFile:write( 'CUTID=' .. tostring( nCutId or 0) .. '\n')
   hFile:write( 'TASKID=' .. tostring( nTaskId or 0) .. '\n')
   hFile:close()
end

------------------------------------------------------------------
local function WriteTimeToLogFile( dTime)
   local hFile = io.open( sLogFile, 'a')
   hFile:write( 'TIME=' .. EgtNumToString( dTime) .. '\n')
   hFile:close()
end

------------------------------------------------------------------
-- Funzione per gestire visualizzazione dopo errore
local function PostErrView( nErr, sMsg)
   if nErr ~= 0 and ( NEST.FLAG == 1 or NEST.FLAG == 2 or NEST.FLAG == 5) then
      EgtSetView( SCE_VD.ISO_SW, false)
      EgtZoom( SCE_ZM.ALL)
      EgtOutBox( sMsg, 'BatchProcess (err=' .. tostring( nErr) .. ')', 'ERRORS')
   end
end

------------------------------------------------------------------
-- Funzione per gestire visualizzazione dopo warning
local function PostWarnView( nWarn, sMsg)
   if nWarn ~= 0 and ( NEST.FLAG == 1 or NEST.FLAG == 2 or NEST.FLAG == 5) then
      EgtSetView( SCE_VD.ISO_SW, false)
      EgtZoom( SCE_ZM.ALL)
      EgtOutBox( sMsg, 'BatchProcess (wrn=' .. tostring( nWarn) .. ')', 'WARNINGS')
   end
end

------------------------------------------------------------------
-- Funzione per aggiornare dati ausiliari
local function UpdateAuxData( sAuxFile)
   local bModif = false
   -- Se definito LOAD90, aggiorno
   local sLoad90 = EgtGetStringFromIni( 'AuxData', 'LOAD90', '', sAuxFile) 
   if sLoad90 ~= '' then
      local BtlInfoId = EgtGetFirstNameInGroup( GDB_ID.ROOT, 'BtlInfo') or GDB_ID.NULL
      EgtSetInfo( BtlInfoId, 'LOAD90', sLoad90)
      bModif = true
   end
   return bModif
end

------------------------------------------------------------------
-- Funzione per trovare nome MachGroup
local function NewMachGroupName()
   local nMachGroupId = EgtGetFirstMachGroup()
   if not nMachGroupId then return 1 end
   local nMaxMachGroup = 0
   while nMachGroupId do
      sMachGroupName = EgtGetMachGroupName(nMachGroupId)
      local nMachGroupName = tonumber(sMachGroupName)
      if nMachGroupName > nMaxMachGroup then
         nMaxMachGroup = nMachGroupName
      end
      nMachGroupId = EgtGetNextMachGroup(nMachGroupId)
   end
   return nMaxMachGroup + 1
end

------------------------------------------------------------------
-- Funzione che crea il rettangolo della lavorazione 
local function CreateToolRectangle( ptP1, dValP1, ptP2, dValP2, vtFace, dValFace, nOutlineGrp)
   local dExtra = 5
   local vtX = ptP2 - ptP1 
   vtX:normalize()
   -- creo il rettangolo della lavorazione 
   ptP1 = ptP1 - vtX * ( dValP1  + dExtra)
   ptP2 = ptP2 + vtX * ( dValP2  + dExtra)
   ptP2 = ptP2 + vtFace * ( dValFace + dExtra)  
   --local nId = EgtRectangle2P( nOutlineGrp, Point3d(ptP2:getX(), ptP2:getY(), 0), Point3d( ptP1:getX(), ptP1:getY(), 0))  
   local nId = EgtRectangle2P( nOutlineGrp, ptP2, ptP1)  
   return nId                
end

------------------------------------------------------------------
-- Funzione che verifica se la lavorazione è lap joint dal basso ed eventualmente ne calcola l'area di lavorazione 
local function IdentifyLJFromBottom( Proc, bCompute, nOutlineGrp)
   
   local bLJFromBottom = false 
   local nRectId
   local vtFace 
   
   local dMinCompZ = 0.95
   if Proc.Fct == 2 then 
      local vtN = {}
      vtN[1] = EgtSurfTmFacetNormVersor( Proc.Id, 0, GDB_ID.ROOT)
      vtN[2] = EgtSurfTmFacetNormVersor( Proc.Id, 1, GDB_ID.ROOT)
      
      -- se rivolto verso il basso
      if ( vtN[1]:getZ() < - dMinCompZ or vtN[2]:getZ() < - dMinCompZ) then
         vtFace = EgtIf( vtN[1]:getZ() < - dMinCompZ, vtN[2], vtN[1])
         if not ( vtFace:getZ() > dMinCompZ or vtFace:getZ() < - dMinCompZ) then 
            bLJFromBottom = true
            if bCompute then 
               local bAdj, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, 0, 1, GDB_ID.ROOT)
               -- creo il rettangolo della lavorazione 
               nRectId = CreateToolRectangle( ptP1, s_dSideMillDiamDown / 2, ptP2, s_dSideMillDiamDown / 2, vtFace, s_dSideMillDiamDown, nOutlineGrp)
            end
         end
      end

   elseif Proc.Fct == 3 then
      local nFacInd, dElev, nFacInd2 = WL.GetFaceWithMostAdj( Proc.Id, Proc.PartId)
      
      -- se nel mezzo di una faccia
      if not nFacInd2 then 
         if nFacInd ~= -2  and nFacInd ~= GDB_ID.NULL then 
            vtFace = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT)
            if not ( vtFace:getZ() > dMinCompZ or vtFace:getZ() < - dMinCompZ) then
               local nOtherFace = EgtIf( nFacInd == 0, 1, 0)
               local bAdj, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, nFacInd, nOtherFace, GDB_ID.ROOT)
               if abs( ptP1:getZ() - ptP2:getZ()) < GEO.EPS_SMALL then 
                  bLJFromBottom = true 
                  if bCompute then 
                     nRectId = CreateToolRectangle( ptP1, s_dSideMillDiamDown / 2, ptP2, s_dSideMillDiamDown / 2, vtFace, s_dSideMillDiamDown, nOutlineGrp)
                  end
               end
            end
         end
           
      -- se dal basso
      else
         local nFaceZ = -1
         for nIdx = 0, 2 do
            local vtN2 = EgtSurfTmFacetNormVersor( Proc.Id, nIdx, GDB_ID.ROOT)
            if vtN2:getZ() < - dMinCompZ then
               nFaceZ = nIdx
               break
            end
         end
         if nFaceZ ~= -1 then
            local nFace = EgtIf( nFaceZ == nFacInd, nFacInd2, nFacInd)
            local nOtherFace = EgtIf( nFaceZ + nFace == 3, 0, EgtIf( nFaceZ + nFace == 2, 1, 2))
            vtFace = EgtSurfTmFacetNormVersor( Proc.Id, nFace, GDB_ID.ROOT)
            --vtFace[2] = EgtSurfTmFacetNormVersor( Proc.Id, nOtherFace, GDB_ID.ROOT)
            bLJFromBottom = true 
            if bCompute then
               local bAdj, ptP1, ptP2 = EgtSurfTmFacetsContact( Proc.Id, nFace, nFaceZ, GDB_ID.ROOT)
               local bAdj2, ptP3, ptP4 = EgtSurfTmFacetsContact( Proc.Id, nFace, nOtherFace, GDB_ID.ROOT)
               if AreSamePointApprox( ptP2, ptP3) or AreSamePointApprox( ptP2, ptP4) then
                  ptP1, ptP2 = ptP2, ptP1 
               end 
               local dVal = EgtIf( NEST.MACH_AREA_IGNORE_3rdFACE == 1, s_dSideMillDiamDown / 2, 0)
               nRectId = CreateToolRectangle( ptP1, dVal, ptP2, s_dSideMillDiamDown / 2, vtFace, s_dSideMillDiamDown, nOutlineGrp)
            end
         end
      end
      
   elseif Proc.Fct == 4 then
      local nFacInd, dElev, nFacInd2, dElev2 = WL.GetFaceWithMostAdj( Proc.Id, Proc.PartId)
      if nFacInd ~= -2  and nFacInd ~= GDB_ID.NULL then
         vtFace = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT)
         
         if not ( vtFace:getZ() > dMinCompZ or vtFace:getZ() < - dMinCompZ) then
            local nOtherFace = -1
            for nIdx = 0, 3 do
              local vtN2 = EgtSurfTmFacetNormVersor( Proc.Id, nIdx, GDB_ID.ROOT)
              if vtN2:getZ() > dMinCompZ or vtN2:getZ() < - dMinCompZ then
                 nOtherFace = nIdx
                 break 
              end
            end
            if nOtherFace ~= -1 and nOtherFace ~= nFacInd and nOtherFace ~= nFacInd2 then
               bLJFromBottom = true 
               if bCompute then
                  local bAdj, ptP1, ptP2 = EgtSurfTmFacetsContact( Proc.Id, nFacInd, nOtherFace, GDB_ID.ROOT)
                  local bAdj2, ptP3, ptP4 = EgtSurfTmFacetsContact( Proc.Id, nFacInd, nFacInd2, GDB_ID.ROOT)
                  if AreSamePointApprox( ptP2, ptP3) or AreSamePointApprox( ptP2, ptP4) then
                     ptP1, ptP2 = ptP2, ptP1
                  end
                  nRectId = CreateToolRectangle( ptP1, 0, ptP2, s_dSideMillDiamDown / 2, vtFace, s_dSideMillDiamDown, nOutlineGrp)
               end
            end
         end
         
         if nFacInd2 and nFacInd2 ~= GDB_ID.NULL then 
            local vtFace2 = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd2, GDB_ID.ROOT)
            if ( vtFace2:getZ() < - dMinCompZ or vtFace:getZ() < - dMinCompZ) then
               bLJFromBottom = true 
               if vtFace:getZ() < -dMinCompZ then vtFace = vtFace2 end
               if bCompute then
                  local bAdj, ptP1, ptP2 = EgtSurfTmFacetsContact( Proc.Id, nFacInd, nFacInd2, GDB_ID.ROOT)
                  nRectId = CreateToolRectangle( ptP1, 0, ptP2, 0, vtFace, s_dSideMillDiamDown, nOutlineGrp)
               end
            end
         end
      end
   end

   if bLJFromBottom then
      return vtFace, nRectId 
   else
      return
   end
end

------------------------------------------------------------------
-- Funzione che verifica se la lavorazione è lap joint da sopra ed eventualmente ne calcola l'area di lavorazione 
local function IdentifyLJFromTop( Proc, bCompute, nOutlineGrp)
   
   local bLJFromTop = false
   local vtFace, nRectId
   
   if s_dSideMillDiamUp < GEO.EPS_SMALL then return end
   
   local dMinComp = 0.95
   if Proc.Fct == 2 then
      local vtN = {}
      vtN[1] = EgtSurfTmFacetNormVersor( Proc.Id, 0, GDB_ID.ROOT)
      vtN[2] = EgtSurfTmFacetNormVersor( Proc.Id, 1, GDB_ID.ROOT)
      
      -- se rivolto verso l'alto
      if (vtN[1]:getZ() > dMinComp or vtN[2]:getZ() > dMinComp) then 
         bLJFromTop = true 
         vtFace = EgtIf( vtN[1]:getZ() > dMinComp, vtN[2], vtN[1])
         if bCompute then 
            local bAdj, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, 0, 1, GDB_ID.ROOT)
            local b3Face = EgtSurfTmGetFacetBBoxGlob( Proc.Id, EgtIf( vtN[1]:getZ() > dMinComp, 0, 1), GDB_BB.STANDARD)
            local dDim = 0
            if vtFace:getX() > dMinComp or vtFace:getX() < - dMinComp  then
               dDim = b3Face:getDimX()
            elseif vtFace:getY() > dMinComp or vtFace:getY() < - dMinComp then
               dDim = b3Face:getDimY()
            end
            local dValFace = max( dDim + s_dSideMillDiamUp / 2, s_dSideMillDiamUp)
            local dVal = s_dSideMillDiamUp / 2
            if NEST.MACH_AREA_USE_OTHER_DIAM == 1 then
               dVal = NEST.MACH_AREA_OTHER_DIAM / 2
            end
            nRectId = CreateToolRectangle( ptP1, dVal, ptP2, dVal, vtFace, dValFace, nOutlineGrp)
         end
      end
    
   -- caso 3 facce
   elseif Proc.Fct == 3 then
      local nFacInd, dElev, nFacInd2 = WL.GetFaceWithMostAdj( Proc.Id, Proc.PartId)
      
      -- forma ad U
      if not nFacInd2 and nFacInd ~= GDB_ID.NULL and NEST.LAP_JOINT_U_MACH_AREA == 1 then
         local vtFace = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT)
         if vtFace:getZ() > dMinComp then
            bLJFromTop = true
            if bCompute then
               local b3Face = EgtSurfTmGetFacetBBoxGlob( Proc.Id, nFacInd, GDB_BB.STANDARD)
               local nOtherFace = EgtIf( nFacInd == 0, 1, 0)
               local vtNOther = EgtSurfTmFacetNormVersor( Proc.Id, nOtherFace, GDB_ID.ROOT)
               local vtDir = EgtIf( AreSameOrOppositeVectorApprox( vtNOther, X_AX()), Y_AX(), X_AX())
               local dVal = s_dSideMillDiamUp / 2 + 5
               local ptMin = b3Face:getMin() - dVal * vtDir
               local ptMax = b3Face:getMax() + dVal * vtDir
               -- nRectId = EgtRectangle2P( nOutlineGrp, Point3d(ptMax:getX(), ptMax:getY(), 0), Point3d( ptMin:getX(), ptMin:getY(), 0))
               nRectId = EgtRectangle2P( nOutlineGrp, ptMax, ptMin)
            end
         end
      
      elseif nFacInd2 then
         local nFaceZ = -1
         for nIdx = 0, 2 do
            local vtN2 = EgtSurfTmFacetNormVersor( Proc.Id, nIdx, GDB_ID.ROOT)
            if vtN2:getZ() > dMinComp then 
               nFaceZ = nIdx
               break 
            end
         end
         if nFaceZ ~= -1 then
            local nFace = EgtIf( nFaceZ == nFacInd, nFacInd2, nFacInd)
            local nOtherFace = EgtIf( nFaceZ + nFace == 3, 0, EgtIf( nFaceZ + nFace == 2, 1, 2))
            local vtFace = {}
            vtFace = EgtSurfTmFacetNormVersor( Proc.Id, nFace, GDB_ID.ROOT)
            --vtFace = EgtSurfTmFacetNormVersor( Proc.Id, nOtherFace, GDB_ID.ROOT)
            bLJFromTop = true
            if bCompute then
               local bAdj, ptP1, ptP2 = EgtSurfTmFacetsContact( Proc.Id, nFace, nFaceZ, GDB_ID.ROOT)
               local bAdj2, ptP3, ptP4 = EgtSurfTmFacetsContact( Proc.Id, nFace, nOtherFace, GDB_ID.ROOT)
               if AreSamePointApprox( ptP2, ptP3) or AreSamePointApprox( ptP2, ptP4) then
                  ptP1, ptP2 = ptP2, ptP1
               end
               
               local b3Face = EgtSurfTmGetFacetBBoxGlob( Proc.Id, nFaceZ, GDB_BB.STANDARD)
               local dDim = 0
               if vtFace:getX() > dMinComp or vtFace:getX() < - dMinComp  then
                  dDim = b3Face:getDimX()
               elseif vtFace:getY() > dMinComp or vtFace:getY() < - dMinComp then
                  dDim = b3Face:getDimY()
               end
               local dValFace = max( dDim + s_dSideMillDiamUp / 2, s_dSideMillDiamUp)
               local dVal = s_dSideMillDiamUp / 2
               if NEST.MACH_AREA_USE_OTHER_DIAM == 1 then
                  dVal = NEST.MACH_AREA_OTHER_DIAM / 2
               end   
               nRectId = CreateToolRectangle( ptP1, 0, ptP2, dVal, vtFace, dValFace, nOutlineGrp) 
            end
         end
      end
   end
   
    if bLJFromTop then
      return vtFace, nRectId 
   else 
      return
   end 
end

------------------------------------------------------------------
-- Funzione che crea le regioni occupate dalle lavorazioni
local function ComputeToolOutlines( nPartId)
  
   local ToolOutlineId = {}
   EgtRemoveInfo( nPartId, "ToolOutlines")
   
   -- recupero il gruppo con gli outlines degli utensili
   local nOutlineGrp = EgtGetFirstNameInGroup(GDB_ID.ROOT, "ToolOutlines")
   if not nOutlineGrp or nOutlineGrp == GDB_ID.NULL then
      nOutlineGrp = EgtGroup( GDB_ID.ROOT)
      EgtSetName( nOutlineGrp, "ToolOutlines")
      EgtSetStatus( nOutlineGrp, GDB_ST.OFF)
   end 
   
   local vPartProc = WE.CollectFeatures( nPartId, b3Raw)
   for nInd = 1, #vPartProc do
      
      local Proc = vPartProc[nInd]
      
      -- lap joint
      if LapJoint.Identify( Proc) then
         -- verifico se dal basso 
         local _ , nRectId = IdentifyLJFromBottom( Proc, true, nOutlineGrp)         
         if nRectId then
            EgtSetColor( nRectId, EgtStdColor("BLUE"))
            table.insert( ToolOutlineId, nRectId) 
         else
            -- verifico se dall'alto
            local _ , nRectId = IdentifyLJFromTop( Proc, true, nOutlineGrp)
            if nRectId then
               EgtSetColor( nRectId, EgtStdColor("AQUA"))
               local nPrId = EgtGetInfo( Proc.Id, "PRID", 'i')
               EgtSetInfo( nRectId, "PRID", nPrId)
               table.insert( ToolOutlineId, nRectId)
            end
         end
      end

      -- fori
      if NEST.DRILL_MACH_AREA == 1 and Drill.Identify( Proc) then
         -- recupero dati del foro 
         local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i') or 0
         if AuxId then AuxId = AuxId + Proc.Id end
         local dLen = abs( EgtCurveThickness( AuxId))
         local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
         local bOpen = ( Proc.Fcs ~= 0  and  Proc.Fce ~= 0)
         local dDiam = 2 * EgtArcRadius( AuxId)
         
         -- verifico se la lunghezza del foro è maggiore della lunghezza della punta 
         if bOpen and AreSameOrOppositeVectorApprox( vtExtr, Y_AX()) and dLen > s_dHorDrillLen - 1 then
            local ptP1 = Proc.Box:getMin()
            local ptP2 = Proc.Box:getMax()            
            local dExtra = 10 
            ptP1 = ptP1 - ( WD.MAX_WIDTH - dLen + dExtra) * Y_AX()
            ptP2 = ptP2 + ( WD.MAX_WIDTH - dLen + dExtra) * Y_AX() 
           
            --local nId = EgtRectangle2P( nOutlineGrp, Point3d(ptP2:getX(), ptP2:getY(), 0), Point3d( ptP1:getX(), ptP1:getY(), 0))  
            local nId = EgtRectangle2P( nOutlineGrp, ptP2, ptP1)  
            EgtSetColor( nId, EgtStdColor("AQUA"))
            if nId ~= GDB_ID.NULL then table.insert(ToolOutlineId, nId) end            
         end
      end
      
      -- lati inclinati free contour 
      if FreeContour.Identify( Proc) then 
         local bPocket = EgtGetInfo( Proc.Id, 'PCKT', 'b') 
         if not bPocket then 
            for nInd = 0, Proc.Fct - 1 do
               local vtN = EgtSurfTmFacetNormVersor( Proc.Id, nInd, GDB_ID.ROOT)          
               -- se inclinato 
               if abs( vtN:getZ()) > GEO.EPS_SMALL then
                  local bUnderCut = vtN:getZ() < - GEO.EPS_SMALL
                  
                  local dCosAlpha = (vtN ^ Z_AX()):len()
                  local dVal 
                  if bUnderCut then 
                     dVal = ( NEST.OFFSET + 0.1) / dCosAlpha
                  else
                     dVal = ( NEST.OFFSET + 0.1) * dCosAlpha
                  end
               
                  local frLoc, dDimX, dDimY = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nInd, GDB_ID.ROOT)      
                  local b3Face = EgtSurfTmGetFacetBBoxRef( Proc.Id, nInd, GDB_BB.STANDARD, frLoc)
                  local ptA = b3Face:getMin()
                  local ptC = b3Face:getMax()
                  local ptB = ptA + dDimY * Y_AX() 
                  local ptD = ptA + dDimX * X_AX()
                  ptA:toGlob( frLoc)
                  ptB:toGlob( frLoc)
                  ptC:toGlob( frLoc)
                  ptD:toGlob( frLoc)
                     
                  local ptP1, ptP2
                  if bUnderCut then
                     ptP1 = EgtIf( ptA:getZ() > ptC:getZ(), ptA, ptC)
                     ptP2 = EgtIf( ptB:getZ() > ptD:getZ(), ptB, ptD)
                  else
                     ptP1 = EgtIf( ptA:getZ() < ptC:getZ(), ptA, ptC)
                     ptP2 = EgtIf( ptB:getZ() < ptD:getZ(), ptB, ptD)
                  end  
                  
                  local vtDir = ptP2 - ptP1
                  vtDir:normalize()
                  ptP1 = ptP1 - vtDir * 0.5 * NEST.OFFSET
                  ptP2 = ptP2 + vtDir * 0.5 * NEST.OFFSET
                  local vtNxy = Vector3d( vtN:getX(), vtN:getY(), 0)
                  vtNxy:normalize()
                  local ptP4 = ptP2 + dVal * vtNxy
                  
                  local nRectId = EgtRectangle3P( nOutlineGrp, ptP1, ptP4, ptP2)
                  EgtSetColor( nRectId, EgtStdColor("AQUA"))
                  if nRectId ~= GDB_ID.NULL then table.insert( ToolOutlineId, nRectId) end
               end
            end
         end
      end
   end

   return ToolOutlineId
end

------------------------------------------------------------------
local function ClassifyDrillsOnLateralFaces( nPartId, dMinSheetWidth)
   
   local dDeltaRaw = WD.MAX_WIDTH - dMinSheetWidth + NEST.KERF 
   local DrillClassif 
   local DrillOnFaces = { F = {nbr = 0, closed = false, long = false, OnlyOnRef = false}, B = {nbr = 0, closed = false, long = false, OnlyOnRef = false}, 
                          L = {nbr = 0, closed = false, long = false, OnlyOnRef = false}, R = {nbr = 0, closed = false, long = false, OnlyOnRef = false}}    
   local nBoxLayerId = EgtGetFirstNameInGroup( nPartId, "Box")
   local nBoxId = EgtGetFirstNameInGroup( nBoxLayerId, "Box")
   local b3Part = EgtGetBBoxGlob(nBoxId, GDB_BB.STANDARD)
   local ptPartMin = b3Part:getMin()
   local ptPartMax = b3Part:getMax()
   
   local vPartProc = WE.CollectFeatures( nPartId)
   for nInd = 1, #vPartProc do repeat
      
      if Drill.Identify( vPartProc[nInd]) then
         
         -- identifico su quali facce si trova il foro
         local bOpen = ( vPartProc[nInd].Fcs ~= 0 and vPartProc[nInd].Fce ~= 0)
         local AuxId = EgtGetInfo( vPartProc[nInd].Id, 'AUXID', 'i') or 0
         if AuxId then AuxId = AuxId + vPartProc[nInd].Id end
         if not AuxId  or  EgtGetType( AuxId) ~= GDB_TY.CRV_ARC then break end
         -- verifico se diametro compatibile con la punta
         local dDiam = 2 * EgtArcRadius( AuxId)
         if ( abs( dDiam - s_dHorDrillDiam5Axes) < WD.DRILL_TOL + GEO.EPS_SMALL) or ( abs( dDiam - s_dHorDrillDiam) < WD.DRILL_TOL + GEO.EPS_SMALL) then
            local ptDrill = EgtCP( AuxId, GDB_RT.GLOB)
            local dLen = abs( EgtCurveThickness( AuxId))
            local bLong = dLen > s_dHorDrillLen - 1
            local bOnlyOnRef = dLen + dDeltaRaw > s_dHorDrillLen - GEO.EPS_SMALL and not bLong 
            
            -- faccia Front
            local dTol = GEO.EPS_SMALL
            if ( abs( ptDrill:getY() - ptPartMin:getY()) < dTol) then 
               DrillOnFaces.F.nbr = DrillOnFaces.F.nbr  + 1
               if bOnlyOnRef then DrillOnFaces.F.OnlyOnRef = true end 
               if bOpen then 
                  DrillOnFaces.B.nbr = DrillOnFaces.B.nbr + 1 
                  if bOnlyOnRef then DrillOnFaces.B.OnlyOnRef = true end
               else
                  DrillOnFaces.F.closed = true
                  
               end
               if bLong then 
                  DrillOnFaces.F.long = true 
                  if bOpen then DrillOnFaces.B.long = true end
               end
               
            -- faccia Back
            elseif ( abs( ptDrill:getY() - ptPartMax:getY()) < dTol) then 
               DrillOnFaces.B.nbr = DrillOnFaces.B.nbr + 1 
               if bOnlyOnRef then DrillOnFaces.B.OnlyOnRef = true end
               if bOpen then 
                  DrillOnFaces.F.nbr = DrillOnFaces.F.nbr  + 1
                  if bOnlyOnRef then DrillOnFaces.F.OnlyOnRef = true end
               else
                  DrillOnFaces.B.closed = true
               end
            if bLong then 
                  DrillOnFaces.B.long = true 
                  if bOpen then DrillOnFaces.F.long = true end
               end
               
            -- faccia Left
            elseif ( abs( ptDrill:getX() - ptPartMin:getX()) < dTol) then
               DrillOnFaces.L.nbr = DrillOnFaces.L.nbr + 1  
               if bOnlyOnRef then DrillOnFaces.L.OnlyOnRef = true end
               if bOpen then 
                  DrillOnFaces.R.nbr = DrillOnFaces.R.nbr + 1 
                  if bOnlyOnRef then DrillOnFaces.R.OnlyOnRef = true end
               else
                  DrillOnFaces.L.closed = true
               end
               if bLong then 
                  DrillOnFaces.L.long = true 
                  if bOpen then DrillOnFaces.R.long = true end
               end
               
            -- faccia Right
            elseif ( abs( ptDrill:getX() - ptPartMax:getX()) < dTol) then
               DrillOnFaces.R.nbr = DrillOnFaces.R.nbr + 1  
               if bOnlyOnRef then DrillOnFaces.R.OnlyOnRef = true end
               if bOpen then 
                  DrillOnFaces.L.nbr = DrillOnFaces.L.nbr + 1
                  if bOnlyOnRef then DrillOnFaces.L.OnlyOnRef = true end
               else
                  DrillOnFaces.R.closed = true
               end  
               if bLong then 
                  DrillOnFaces.R.long = true 
                  if bOpen then DrillOnFaces.L.long = true end 
               end
            end
         end
      end
      
      until true 
   end
   
   -- identifico la faccia da mettere sul lato del grezzo
   local sDrillFace, nMax = '', -100
   for k, v in pairs( DrillOnFaces) do
      if v.nbr > nMax or ( v.nbr == nMax and not DrillOnFaces[sDrillFace].OnlyOnRef and v.OnlyOnRef) then
         sDrillFace, nMax = k, v.nbr
      end
   end
   
   local sDrillFace2
   if nMax > 0 then
      if sDrillFace == 'F' or sDrillFace == 'B' then
         -- cerco chi vince tra faccia left e right
         if DrillOnFaces.L.nbr > DrillOnFaces.R.nbr then 
            sDrillFace2 = 'L'
         elseif DrillOnFaces.L.nbr < DrillOnFaces.R.nbr then 
            sDrillFace2 = 'R'
         elseif DrillOnFaces.L.nbr == DrillOnFaces.R.nbr and DrillOnFaces.L.nbr > 0 then
            if DrillOnFaces.L.OnlyOnRef then
               sDrillFace2 = 'L'
            else
               sDrillFace2 = 'R'
            end
         end 
         
      else
         -- cerco chi vince tra faccia front e back
         if DrillOnFaces.F.nbr > DrillOnFaces.B.nbr then 
            sDrillFace2 = 'F'
         elseif DrillOnFaces.F.nbr < DrillOnFaces.B.nbr then 
            sDrillFace2 = 'B'
         elseif DrillOnFaces.F.nbr == DrillOnFaces.B.nbr and DrillOnFaces.F.nbr > 0 then
            if DrillOnFaces.F.OnlyOnRef then
               sDrillFace2 = 'F'
            else
               sDrillFace2 = 'B'
            end
         end
      end
   end
   
   if NEST.DRILL_MACH_AREA == 0 then 
      DrillOnFaces[sDrillFace].long = false
   end
   
   if nMax > 0 then
      DrillClassif = { sCase = sDrillFace, bClosed = DrillOnFaces[sDrillFace].closed, bLong = DrillOnFaces[sDrillFace].long, bOnlyOnRef = DrillOnFaces[sDrillFace].OnlyOnRef}
   end
   
   local DrillClassif2 
   if sDrillFace2 then
      if NEST.DRILL_MACH_AREA == 0 then 
         DrillOnFaces[sDrillFace2].long = false
      end
      DrillClassif2 = { sCase = sDrillFace2, bClosed = DrillOnFaces[sDrillFace2].closed, bLong = DrillOnFaces[sDrillFace2].long, bOnlyOnRef = DrillOnFaces[sDrillFace2].OnlyOnRef}
   end
   

   return DrillClassif, DrillClassif2
end

------------------------------------------------------------------
local function ClassifyLapJointsFromBottom( nPartId)
   
   local res = { Nbr = 0, sCase = '', bParall = false}

   local b3Part = EgtGetBBoxGlob( nPartId, GDB_BB.STANDARD)
   local ptPartMin = b3Part:getMin()
   local ptPartMax = b3Part:getMax()
   
   local vtLapJoints = {}  
   local dMinComponentVal = 0.95
   local vPartProc = WE.CollectFeatures( nPartId)
   for nInd = 1, #vPartProc do
      
      if LapJoint.Identify( vPartProc[nInd]) then
         -- verifico se LJ da sotto
         local vtFace = IdentifyLJFromBottom( vPartProc[nInd], false)
         if vtFace then             
            if vtFace:getX() > dMinComponentVal then
               vtLapJoints["R"] = 1
            elseif vtFace:getX() < - dMinComponentVal then
               vtLapJoints["L"] = 1
            elseif vtFace:getY() > dMinComponentVal then
               vtLapJoints["B"] = 1
            elseif vtFace:getY() < - dMinComponentVal then
               vtLapJoints["F"] = 1   
            end
         end
      end
   end
   
   local nCnt = 0
   for _ in pairs(vtLapJoints) do nCnt = nCnt + 1 end
   
   if nCnt == 1 then
      res.Nbr = 1
      for k, _ in pairs( vtLapJoints) do
         res.sCase = k 
      end
  
   elseif nCnt == 2 then
      res.Nbr = 2
      if vtLapJoints["F"] and vtLapJoints["B"] then
         res.bParall = true 
         res.sCase = "F"
      elseif  vtLapJoints["R"] and vtLapJoints["L"] then
         res.bParall = true 
         res.sCase = "R"
      else
         res.bParall = false 
         if vtLapJoints["B"] and vtLapJoints["R"] then
            res.sCase = 'BR'
         elseif vtLapJoints["B"] and vtLapJoints["L"] then
            res.sCase = 'BL'
         elseif vtLapJoints["F"] and vtLapJoints["R"] then
            res.sCase = 'FR'
         elseif vtLapJoints["F"] and vtLapJoints["L"] then
            res.sCase = 'FL'
         end
      end
            
   elseif nCnt == 3 then
      res.Nbr = 3
      if not vtLapJoints["F"] then
         res.sCase = "F"
      elseif not vtLapJoints["B"] then
         res.sCase = "B"
      elseif not vtLapJoints["R"] then
         res.sCase = "R"
      elseif not vtLapJoints["L"] then
         res.sCase = "L"
      end
      
   elseif nCnt == 4 then
      res.Nbr = 4
   elseif nCnt ~= 0 then 
      return
   end
   
   return res

end

------------------------------------------------------------------
local function CreateDefectOnAngle( nPartId, RawPart, bDrillLong, bOnOppositeAng)   
  
   local PartTab = {}
   -- recupero il gruppo dove salvo i defects
   local nOutlineGrp = EgtGetFirstNameInGroup(GDB_ID.ROOT, "SheetDefects")
   if not nOutlineGrp or nOutlineGrp == GDB_ID.NULL then
      nOutlineGrp = EgtGroup( GDB_ID.ROOT)
      EgtSetName( nOutlineGrp, "SheetDefects")
      EgtSetStatus( nOutlineGrp, GDB_ST.OFF)
   end 
   
   local dExtraMachArea = s_dSideMillDiamDown   -- per tenere conto dell'area di lavorazione 
   local dExtra = NEST.KERF
         
   -- local b3Part = EgtGetBBoxGlob( nPartId, GDB_BB.STANDARD)
   local nBoxLayerId = EgtGetFirstNameInGroup( nPartId, "Box")
   local nBoxId = EgtGetFirstNameInGroup( nBoxLayerId, "Box")
   local b3Part = EgtGetBBoxGlob(nBoxId, GDB_BB.STANDARD)
   local b3PartX = b3Part:getDimX()
   local b3PartY = b3Part:getDimY()
   -- se ho fori lunghi devo riservare tutto lo spazio
   if bDrillLong then
      b3PartY = RawPart.Width
   end  
   
   -- calcolo i punti che definiscono il rettangolo 
   local ptP1, ptP2
   if ( s_sOrigCorner == 'TL' and not bOnOppositeAng) or ( s_sOrigCorner == 'BL' and bOnOppositeAng) then
      -- angolo TL
      ptP1 = Point3d( 0, RawPart.Width - b3PartY - dExtra, 0)
      ptP2 = Point3d( b3PartX + dExtra, RawPart.Width, 0)
      PartTab.posX = NEST.KERF
      PartTab.posY = RawPart.Width - b3Part:getDimY() - NEST.KERF
   elseif ( s_sOrigCorner == 'BL' and not bOnOppositeAng) or ( s_sOrigCorner == 'TL' and bOnOppositeAng) then
      -- angolo BL
      ptP1 = Point3d( 0, 0, 0)
      ptP2 = Point3d( b3PartX + dExtra, b3PartY + dExtra, 0)
      PartTab.posX = NEST.KERF
      PartTab.posY = NEST.KERF
   elseif ( s_sOrigCorner == 'TR' and not bOnOppositeAng) or ( s_sOrigCorner == 'BR' and bOnOppositeAng) then
      -- angolo TR
      ptP1 = Point3d( RawPart.Len - b3PartX - dExtra, RawPart.Width - b3PartY - dExtra, 0)
      ptP2 = Point3d( RawPart.Len, RawPart.Width, 0)
      PartTab.posX = RawPart.Len - b3Part:getDimX() - NEST.KERF
      PartTab.posY = RawPart.Width - b3Part:getDimY() - NEST.KERF
   elseif ( s_sOrigCorner == 'BR' and not bOnOppositeAng) or ( s_sOrigCorner == 'TR' and bOnOppositeAng) then
      -- angolo BR
      ptP1 = Point3d( RawPart.Len - b3PartX - dExtra, 0, 0)
      ptP2 = Point3d( RawPart.Len, b3PartY + dExtra, 0)
      PartTab.posX = RawPart.Len - b3Part:getDimX() - NEST.KERF
      PartTab.posY = NEST.KERF
   end
   
   PartTab.Id = tonumber(nPartId)
   PartTab.DefectId =  EgtRectangle2P( nOutlineGrp, Point3d(ptP2:getX() + dExtraMachArea, ptP2:getY() + dExtraMachArea , 0), Point3d( ptP1:getX() - dExtraMachArea , ptP1:getY() - dExtraMachArea, 0)) 
   EgtSetName( PartTab.DefectId, "Defect")

   return PartTab 
end

------------------------------------------------------------------
local function RotateOptimalCase( nPartId, nAngle, nAngleValidRot, RawPart, nPnt1, nPnt2)
   
   local bOptimal = false
   local b3Part = EgtGetBBoxGlob( nPartId, GDB_BB.STANDARD)
   EgtRotate( nPartId, b3Part:getCenter(), Z_AX(), nAngle, GDB_RT.GLOB)
   local nRotate = nAngle
   local nAnglePnt
   local nBoxLayerId = EgtGetFirstNameInGroup( nPartId, "Box")
   local nBoxId = EgtGetFirstNameInGroup( nBoxLayerId, "Box")
   b3Part = EgtGetBBoxGlob(nBoxId, GDB_BB.STANDARD)
   -- b3Part = EgtGetBBoxGlob( nPartId, GDB_BB.STANDARD)
   local bIsValidRotation = b3Part:getDimX() < RawPart.Len - 2 * NEST.KERF + GEO.EPS_SMALL and b3Part:getDimY() < RawPart.Width - 2 * NEST.KERF + GEO.EPS_SMALL
   if bIsValidRotation then
      bOptimal = true
      nAnglePnt = nPnt1
   else
      bOptimal = false 
       -- ruoto nella migliore posizione ammissibile
      EgtRotate( nPartId, b3Part:getCenter(), Z_AX(), nAngleValidRot, GDB_RT.GLOB)
      nRotate = nRotate + nAngleValidRot
      nAnglePnt = nPnt2
   end  
   
   if nRotate >= 360 then
      nRotate = nRotate - 360
   end
   
   return nAnglePnt, nRotate, bOptimal
end

------------------------------------------------------------------
local function RotateOptimalCaseDrill( nPartId, bCanRotate, nPnt1, nPnt2)
   
   local nRotate = 0
   local nAnglePnt
   
   if bCanRotate then
      local b3Part = EgtGetBBoxGlob( nPartId, GDB_BB.STANDARD)
      EgtRotate( nPartId, b3Part:getCenter(), Z_AX(), 180, GDB_RT.GLOB)
      nRotate = 180
      nAnglePnt = nPnt1
   else
      nAnglePnt = nPnt2
   end
   
   return nAnglePnt, nRotate
end

------------------------------------------------------------------
-- Funzione che classifica i pezzi in base alla loro necessità di stare negli angoli
local function ClassifyAngles( nPartId, RawPart, sRefOrig, bLockedRot, dMinSheetWidth)

   -- elimino eventuali info 
   EgtSetInfo( nPartId, "NestOnEdge", 0)
   EgtSetInfo( nPartId, "NestOnAngle", 0)
   EgtSetInfo( nPartId, "OnlyOnRefSide", 0)
   
   local nAngle
   local nRotate = 0
   local bOptimal
   local bManual = false
   local bOnly180Rot = EgtGetInfo( nPartId, "HasGrainDirection", 'b') or false
   local b3Part = EgtGetBBoxGlob( nPartId, GDB_BB.STANDARD)
   
   -- fori 
   local DrillClassif, DrillClassif2 = ClassifyDrillsOnLateralFaces( nPartId, dMinSheetWidth)   
   local bDrill = false
   local bDrillOpen = false
   local bLongDrill = false 
   
   if DrillClassif then
      bDrill = true
      bDrillOpen = not DrillClassif.bClosed
      bLongDrill = DrillClassif.bLong
      if DrillClassif.bOnlyOnRef then
         EgtSetInfo( nPartId, "OnlyOnRefSide", 1)
      end
   end 
   
   -- oriento il pezzo in base al foro
   if bDrill and not bLockedRot then
      local RotationAngles
      if sRefOrig == 'TL' or sRefOrig == 'TR' then 
         RotationAngles = { F = 180, B = 0, L = 270, R = 90} 
      else
         RotationAngles = { F = 0, B = 180, L = 90, R = 270} 
      end 
      
      -- se rotazione è libera
      if not bOnly180Rot then 
         EgtRotate( nPartId, b3Part:getCenter(), Z_AX(), RotationAngles[DrillClassif.sCase], GDB_RT.GLOB)
         nRotate = nRotate + RotationAngles[DrillClassif.sCase]   
         
         -- verifico se la rotazione è valida 
         local nBoxLayerId = EgtGetFirstNameInGroup( nPartId, "Box")
         local nBoxId = EgtGetFirstNameInGroup( nBoxLayerId, "Box")
         local b3Part = EgtGetBBoxGlob(nBoxId, GDB_BB.STANDARD)
         -- b3Part = EgtGetBBoxGlob( nPartId, GDB_BB.STANDARD)
         local bIsValidRotation = b3Part:getDimX() < RawPart.Len - 2 * NEST.KERF + GEO.EPS_SMALL and b3Part:getDimY() < RawPart.Width - 2 * NEST.KERF + GEO.EPS_SMALL
         if not bIsValidRotation then 
            -- ritorno nella posizione originaria
            EgtRotate( nPartId, b3Part:getCenter(), Z_AX(), - RotationAngles[DrillClassif.sCase], GDB_RT.GLOB)
            nRotate = nRotate - RotationAngles[DrillClassif.sCase] 
            -- se ho un'altra posizione possibile ruoto in quella
            if DrillClassif2 then
               EgtRotate( nPartId, b3Part:getCenter(), Z_AX(), RotationAngles[DrillClassif2.sCase], GDB_RT.GLOB)
               nRotate = nRotate + RotationAngles[DrillClassif2.sCase]
               bDrillOpen = not DrillClassif2.bClosed
               bLongDrill = DrillClassif2.bLong
               if DrillClassif2.bOnlyOnRef then
                  EgtSetInfo( nPartId, "OnlyOnRefSide", 1)
               end
            else
               -- dimentico di avere il foro
               bDrill = false 
            end
         end 
         
      -- se posso ruotare solo di 180° per venatura
      else
         if RotationAngles[DrillClassif.sCase] == 0 or RotationAngles[DrillClassif.sCase] == 180 then
            EgtRotate( nPartId, b3Part:getCenter(), Z_AX(), RotationAngles[DrillClassif.sCase], GDB_RT.GLOB)
            nRotate = nRotate + RotationAngles[DrillClassif.sCase]
         else
            -- vedo se ho un'altra posizione possibile
            if DrillClassif2 and ( RotationAngles[DrillClassif2.sCase] == 0 or RotationAngles[DrillClassif2.sCase] == 180) then
               EgtRotate( nPartId, b3Part:getCenter(), Z_AX(), RotationAngles[DrillClassif2.sCase], GDB_RT.GLOB)
               nRotate = nRotate + RotationAngles[DrillClassif2.sCase]
               bDrillOpen = not DrillClassif2.bClosed
               bLongDrill = DrillClassif2.bLong
               if DrillClassif2.bOnlyOnRef then
                  EgtSetInfo( nPartId, "OnlyOnRefSide", 1)
               end
            else
               -- dimentico di avere il foro
               bDrill = false 
            end
         end
      end
   end

   -- se non ho venature e fori scelgo una posizione che non faccia cadere il pezzo    
   if not bDrill and not bOnly180Rot and not bLockedRot then
      b3Part = EgtGetBBoxGlob( nPartId, GDB_BB.STANDARD)
      local bIsValid = b3Part:getDimX() > s_dIntRulli
      local bRotatedIsValid = b3Part:getDimY() > s_dIntRulli
      if not bIsValid and not bRotatedIsValid then
         EgtSetInfo( nPartId, "REDUCECUT", 1) 
      elseif not bIsValid or not bRotatedIsValid then 
         bOnly180Rot = true 
         EgtSetInfo( nPartId, "NestStepRot", 180)
      end      
      if not bIsValid and bRotatedIsValid then
         EgtRotate( nPartId, b3Part:getCenter(), Z_AX(), 90, GDB_RT.GLOB)
         nRotate = nRotate + 90
      end
   end
   
   -- lap joints 
   local ResLapJoints = ClassifyLapJointsFromBottom( nPartId)
   b3Part = EgtGetBBoxGlob( nPartId, GDB_BB.STANDARD)
   local bAdd = true
   
   if ResLapJoints.Nbr > 0 and bLockedRot then
      b3Part = EgtGetBBoxGlob( nPartId, GDB_BB.STANDARD)
      if b3Part:getDimX() > s_dIntRulli then
         EgtSetInfo( nPartId, "REDUCECUT", 1)
      end 
      local PartAngleClassification = { PartId = tostring( nPartId), Angle = 100, nRotate = 0, bDrill = true, bLongDrill = true}
      return PartAngleClassification 
   end
   
   -- se anche fori oppure possibile solo rotazione di 180° per non far cadere il pezzo
   if bDrill or bOnly180Rot then
      local bCanRotate = not bDrill or ( bDrill and bDrillOpen)
      
      if ResLapJoints.Nbr == 0 then
         nAngle = 0 
         if not bDrill then bAdd = false end
         
      elseif ResLapJoints.Nbr == 1 then
         if (( sRefOrig == 'TL' or sRefOrig == 'TR') and ResLapJoints.sCase == 'B' ) or
            (( sRefOrig == 'BL' or sRefOrig == 'BR') and ResLapJoints.sCase == 'F' ) then
            nAngle = 20
         elseif (( sRefOrig == 'TL' or sRefOrig == 'TR') and ResLapJoints.sCase == 'F' ) or
                (( sRefOrig == 'BL' or sRefOrig == 'BR') and ResLapJoints.sCase == 'B' ) then
            nAngle, nRotate2 = RotateOptimalCaseDrill( nPartId, bCanRotate, 20, 100)
            nRotate = nRotate + nRotate2 
         elseif ResLapJoints.sCase == 'R' then
            if bCanRotate then bManual = true end
            if  sRefOrig == 'TL' or sRefOrig == 'BL'then 
               nAngle, nRotate2 = RotateOptimalCaseDrill( nPartId, bCanRotate, 40, 0)
               nRotate = nRotate + nRotate2
            else
               nAngle = 40
            end
         elseif ResLapJoints.sCase == 'L' then
            if bCanRotate then bManual = true end
            if  sRefOrig == 'TR' or sRefOrig == 'BR' then 
               nAngle, nRotate2 = RotateOptimalCaseDrill( nPartId, bCanRotate, 40, 0)
               nRotate = nRotate + nRotate2
            else
               nAngle = 40
            end
         end
         
      elseif ResLapJoints.Nbr == 2 then
         if ResLapJoints.bParall then
            if ResLapJoints.sCase == 'F' then
               nAngle = 100
            else
               nAngle = 80
            end
         else
            if (( sRefOrig == 'TL' or sRefOrig == 'TR') and (ResLapJoints.sCase == 'BL' or ResLapJoints.sCase == 'BR')) or
               (( sRefOrig == 'BL' or sRefOrig == 'BR') and (ResLapJoints.sCase == 'FL' or ResLapJoints.sCase == 'FR')) then
               nAngle = 40
            else
               nAngle, nRotate2 = RotateOptimalCaseDrill( nPartId, bCanRotate, 40, 100)
               nRotate = nRotate + nRotate2
            end
         end
         
      elseif ResLapJoints.Nbr == 3 then
         if (( sRefOrig == 'TL' or sRefOrig == 'TR') and ResLapJoints.sCase == 'F' ) or
            (( sRefOrig == 'BL' or sRefOrig == 'BR') and ResLapJoints.sCase == 'B' ) then 
            nAngle = 80
         elseif (( sRefOrig == 'TL' or sRefOrig == 'TR') and ResLapJoints.sCase == 'B' ) or
                (( sRefOrig == 'BL' or sRefOrig == 'BR') and ResLapJoints.sCase == 'F' ) then 
            nAngle, nRotate2 = RotateOptimalCaseDrill( nPartId, bCanRotate, 80, 100)
            nRotate = nRotate + nRotate2 
         elseif ResLapJoints.sCase == 'R' then
            if bCanRotate then bManual = true end
            if sRefOrig == 'TR' or sRefOrig == 'BR' then
               nAngle, nRotate2 = RotateOptimalCaseDrill( nPartId, bCanRotate, 100, 100)
               nRotate = nRotate + nRotate2 
            end 
            nAngle = 100
         elseif ResLapJoints.sCase == 'L' then
            if bCanRotate then bManual = true end
            if sRefOrig == 'TL' or sRefOrig == 'BL' then
               nAngle, nRotate2 = RotateOptimalCaseDrill( nPartId, bCanRotate, 100, 100)
               nRotate = nRotate + nRotate2 
            end 
            nAngle = 100
         end
         
      elseif ResLapJoints.Nbr == 4 then
         nAngle = 100
      end
   
   -- no fori
   else
      if ResLapJoints.Nbr == 0 then
         bAdd = false
         
      elseif ResLapJoints.Nbr == 1 then
         if sRefOrig == 'TL' or sRefOrig == 'TR' then 
            RotationAngles = { F = 180, B = 0, R = 90, L = 270}
         elseif sRefOrig == 'BL'or sRefOrig == 'BR' then
            RotationAngles = { F = 0, B = 180, R = 270, L = 90}
         end
         local nAngleValidRot = EgtIf( sRefOrig == 'TL' or sRefOrig == 'BR', 90, 270)
         nAngle, nRotate2, bOptimal = RotateOptimalCase( nPartId, RotationAngles[ResLapJoints.sCase], nAngleValidRot, RawPart, 20, 40)
         nRotate = nRotate + nRotate2
         if not bOptimal then bManual = true end
         
      elseif ResLapJoints.Nbr == 2 then
         if ResLapJoints.bParall then 
            -- se lap joints su lati paralleli
            RotationAngles = { F = 90, R = 0}
            nAngle, nRotate2 = RotateOptimalCase( nPartId, RotationAngles[ResLapJoints.sCase], 90, RawPart, 80, 100)
            nRotate = nRotate + nRotate2
         else
            -- se lap joints su lati adiacenti
            if sRefOrig == 'TR' then
               RotationAngles = { FR = 90, BR = 0, BL = 270, FL = 180}
            elseif sRefOrig == 'TL' then
               RotationAngles = { FR = 180, BR = 90, BL = 0, FL = 270}
            elseif sRefOrig == 'BR' then
               RotationAngles = { FR = 0, BR = 270, BL = 180, FL = 90}
            elseif sRefOrig == 'BL' then
               RotationAngles = { FR = 270, BR = 180, BL = 90, FL = 0}
            end
            local nAngleValidRot = EgtIf( sRefOrig == 'TL' or sRefOrig == 'BR', 270, 90)
            nAngle, nRotate2, bOptimal = RotateOptimalCase( nPartId, RotationAngles[ResLapJoints.sCase], nAngleValidRot, RawPart, 40, 40)
            nRotate = nRotate + nRotate2
            
            local b3Part = EgtGetBBoxGlob( nPartId, GDB_BB.STANDARD)
            local bCanRotate = b3Part:getDimX() < RawPart.Width
            if bOptimal and bCanRotate then bManual = true end
         end
         
      elseif ResLapJoints.Nbr == 3 then
         if sRefOrig == 'TL' or sRefOrig == 'TR' then
            RotationAngles = { F = 0, B = 180, R = 270, L = 90}
         elseif sRefOrig == 'BL' or sRefOrig == 'BR' then
            RotationAngles = { F = 180, B = 0, R = 90, L = 270}
         end
         local nAngleValidRot = EgtIf( sRefOrig == 'TL' or sRefOrig == 'BR', 90, 270)
         nAngle, nRotate2, bOptimal = RotateOptimalCase( nPartId, RotationAngles[ResLapJoints.sCase], nAngleValidRot, RawPart, 80, 100)
         nRotate = nRotate + nRotate2 
         if not bOptimal then bManual = true end
         
      elseif ResLapJoints.Nbr == 4 then
         nAngle, nRotate2 = RotateOptimalCase( nPartId, 0, 90, RawPart, 100, 100)
         nRotate = nRotate + nRotate2
      end
   end
   
   -- aggiorno le info di rotazione del pezzo 
   if nRotate >= 360 then
      nRotate = nRotate - 360
   end   
   if nRotate > 0 then
      local bPartFlip = ( ( EgtGetInfo( nPartId, "INVERTED", 'i') or 0) == 180)
      local nPartRot = EgtGetInfo( nPartId, "ROTATED", 'i') or 0
      local nTotRot = nPartRot - EgtIf( bPartFlip, -nRotate, nRotate)
      nTotRot = EgtIf( nTotRot < 0, nTotRot + 360, nTotRot)  
      EgtSetInfo( nPartId, "ROTATED", nTotRot)
      EgtSetInfo( nPartId, "MODIFIEDFORNEST", 1)
   end
   
   if not bAdd then
      return
   end

   local PartAngleClassification = { PartId = tostring( nPartId), Angle = nAngle, nRotate = nRotate, bDrill = bDrill, bLongDrill = bLongDrill, bManual = bManual}
  
   local bCanBeOnOtherEdge = not bDrill or ( bDrill and RawPart.Width > s_dMinRawYHorDrill - GEO.EPS_SMALL)
   if bOnly180Rot then
      if bCanBeOnOtherEdge then 
         EgtSetInfo( nPartId, "NestAllowRot", 1) 
         EgtSetInfo( nPartId, "NestStepRot", 180)
      else
         EgtSetInfo( nPartId, "NestAllowRot", 0) 
         EgtSetInfo( nPartId, "NestStepRot", 0)
      end
   end
   
   -- verifico se il pezzo cade (caso di foro)
   b3Part = EgtGetBBoxGlob( nPartId, GDB_BB.STANDARD)
   if b3Part:getDimX() > s_dIntRulli then
      EgtSetInfo( nPartId, "REDUCECUT", 1)
   end
       
   return PartAngleClassification
end

------------------------------------------------------------------
local function ComputeRestrictedZones( RawParts)
   
   local dTotArea = 0 
   -- area totale dei pezzi 
   for nPartId, nCount in pairs( PART) do
      local b3Part = EgtGetBBoxGlob( nPartId, GDB_BB.STANDARD)
      local dPartArea = b3Part:getDimX() * b3Part:getDimY()
      dTotArea = dTotArea + dPartArea * nCount 
   end
   
   -- stimo il numero di angoli disponibili
   local vSheetNbrEstimate = {}
   local nSheetNbrEstimate = 0
   local nSheetNbrCorrection = - 2
   local nAnglesNbrEstimate = 0
   local nAngelsNbrCorrection = 0
   
   local vRawDistrib = {}
   if #RawParts == 1 then
      vRawDistrib  = {1}
   elseif #RawParts == 2 then
      vRawDistrib  = {0.7, 0.3}
   else
      for nInd = 1, #RawParts do
         table.insert( vRawDistrib, 1 / #RawParts)
      end
   end
   
   local dMaxSheetWidth = -100
   local nMaxSheet = 1
   local dMinSheetWidth = WD.MAX_WIDTH
   for nInd = 1, #RawParts do  
      local dSheetArea = RawParts[nInd].Len * RawParts[nInd].Width 
      if RawParts[nInd].Width > dMaxSheetWidth + GEO.EPS_SMALL then 
         dMaxSheetWidth = RawParts[nInd].Width
         nMaxSheet = nInd  
      elseif abs( RawParts[nInd].Width - dMaxSheetWidth) < GEO.EPS_SMALL then
         if RawParts[nInd].Len > RawParts[nMaxSheet].Len then
            nMaxSheet = nInd
         end
      end
      if RawParts[nInd].Width < dMinSheetWidth then
         dMinSheetWidth = RawParts[nInd].Width
      end
      
      vSheetNbrEstimate[nInd] = min( ceil( dTotArea * vRawDistrib[nInd] / dSheetArea) + nSheetNbrCorrection, RawParts[nInd].Qty)
      if vSheetNbrEstimate[nInd] <= 0 then
         vSheetNbrEstimate[nInd] = min( RawParts[nInd].Qty, 1)
      end
      
      nSheetNbrEstimate = nSheetNbrEstimate + vSheetNbrEstimate[nInd]
      nAnglesNbrEstimate = nAnglesNbrEstimate + vSheetNbrEstimate[nInd] * 2
   end
   nAnglesNbrEstimate = nAnglesNbrEstimate + nAngelsNbrCorrection
   
   -- classificazione dei pezzi in base alla loro necessità di stare negli angoli
   local nTotParts = 0
   for _ in pairs( PART) do nTotParts = nTotParts + 1 end
   local nPartIndex = 0
   local AngleClassification = {}
   for nPartId, nCount in pairs( PART) do 
      nPartIndex = nPartIndex + 1
      local bManualRot = EgtGetInfo( nPartId, "MANUALROT", 'b')
      local PartClassif = ClassifyAngles(tonumber(nPartId), RawParts[nMaxSheet], s_sOrigCorner, bManualRot, dMinSheetWidth)
      if PartClassif then
         for nI = 1, nCount do
            local newTab = {PartId = PartClassif.PartId, Angle = PartClassif.Angle, nRotate = PartClassif.nRotate, bDrill = PartClassif.bDrill, bLongDrill = PartClassif.bLongDrill, bManual = PartClassif.bManual}
            table.insert( AngleClassification, newTab)
         end
      end
      
      if EgtProcessEvents( nPartIndex / nTotParts * 100, 0) == 1 then
         return false
      end
   end
   
   table.sort( AngleClassification, function(a, b) return a.Angle > b.Angle end)

   local vManuallyDone = {}
   local vPartsManuallyDone = {}
   for nInd = 1, #vSheetNbrEstimate do 
      for nInd2 = 1, vSheetNbrEstimate[nInd] do 
         table.insert( vManuallyDone, { RawPartId = nInd, Done = 0, Parts = {}})   
      end      
   end
   local nSheetNbr = #vManuallyDone
   local vFilledSheets = {}
   for nInd = 1, #vSheetNbrEstimate do 
      for nInd2 = 1, vSheetNbrEstimate[nInd] do 
         table.insert( vFilledSheets, { Width = RawParts[nInd].Width, OrigWidth = RawParts[nInd].Width})
      end
   end
   
   for nInd = 1, #AngleClassification do
      
      if AngleClassification[nInd].Angle >= NEST.MIN_ANGLE_PNT and AngleClassification[nInd].Angle > 0 then  
         
         -- verifico di avere ancora angoli a disposizione secondo la stima dei grezzi
         local bFound = false
         local nBoxLayerId = EgtGetFirstNameInGroup( AngleClassification[nInd].PartId, "Box")
         local nBoxId = EgtGetFirstNameInGroup( nBoxLayerId, "Box")
         local b3Part = EgtGetBBoxGlob(nBoxId, GDB_BB.STANDARD)
         local dPartWidth = b3Part:getDimY() + NEST.KERF
         for nInd2 = 1, #vFilledSheets do
            if dPartWidth < vFilledSheets[nInd2].Width then
               -- verifico se il grezzo aveva già un pezzo in un angolo
               if abs( vFilledSheets[nInd2].Width - vFilledSheets[nInd2].OrigWidth) < GEO.EPS_SMALL then
                  vFilledSheets[nInd2].Width = vFilledSheets[nInd2].Width - dPartWidth - s_dSideMillDiamDown
               else
                  -- se il grezzo aveva già un pezzo nell'angolo, dopo il pezzo corrente non ne posso mettere altri
                  vFilledSheets[nInd2].Width = 0
               end
               bFound = true
               break
            end
         end
         
         -- se ho ancora angoli a disposizione oppure il pezzo deve stare necessariamente sull'angolo per essere lavorato 
         if bFound or AngleClassification[nInd].Angle == 100 then
            -- verifico se va nestato manualmente
            if AngleClassification[nInd].bManual then
               
               -- trovo il punto della lista dove inserirlo
               local nIdx = -1
               local bOnOppositeSide = false
               for nInd2 = 1, #vManuallyDone do
                  -- verifico se il pezzo può stare sull'altro angolo
                  local bOnlyOnRef = EgtGetInfo( AngleClassification[nInd].PartId, "OnlyOnRefSide", 'b')
                  local bCanBeOnOtherAngle = not bOnlyOnRef and 
                                            ( not AngleClassification[nInd].bDrill or
                                                ( AngleClassification[nInd].bDrill and not AngleClassification[nInd].bLongDrill and 
                                                RawParts[vManuallyDone[nInd2].RawPartId].Width > s_dMinRawYHorDrill - GEO.EPS_SMALL))
                                             
                  if #(vManuallyDone[nInd2].Parts) == 0 then
                     -- verifico che il pezzo stia in questo grezzo
                     local b3Part = EgtGetBBoxGlob( AngleClassification[nInd].PartId, GDB_BB.STANDARD)
                     if b3Part:getDimX() < RawParts[vManuallyDone[nInd2].RawPartId].Len and b3Part:getDimY() < RawParts[vManuallyDone[nInd2].RawPartId].Width then 
                        nIdx = nInd2
                        break
                     end
                     
                  elseif #(vManuallyDone[nInd2].Parts) == 1 and bCanBeOnOtherAngle then
                     -- verifico se il pezzo già posizionato nell'angolo non ha fori lunghi
                     if not vManuallyDone[nInd2].Parts[1].bLongDrill then
                        -- oriento il pezzo in modo ottimale per andare su quell'angolo
                        local sRefOrig
                        if s_sOrigCorner == 'TL' then sRefOrig = 'BL' end
                        if s_sOrigCorner == 'BL' then sRefOrig = 'TL' end
                        if s_sOrigCorner == 'TR' then sRefOrig = 'BR' end
                        if s_sOrigCorner == 'BR' then sRefOrig = 'TR' end
                        local bManTmp
                        local res = ClassifyAngles( AngleClassification[nInd].PartId, RawParts[vManuallyDone[nInd2].RawPartId], sRefOrig, bManTmp, dMinSheetWidth)
                        -- verifico sia compatibile con pezzo già inserito
                        local b3OtherPart = EgtGetBBoxGlob( vManuallyDone[nInd2].Parts[1].Id, GDB_BB.STANDARD)
                        local b3Part = EgtGetBBoxGlob( AngleClassification[nInd].PartId, GDB_BB.STANDARD)
                        local dExtra = 2 * NEST.KERF + s_dSideMillDiamDown + 1
                        -- se è compatibile assegno questa rotazione al pezzo
                        if b3Part:getDimY() + b3OtherPart:getDimY() + dExtra < RawParts[vManuallyDone[nInd2].RawPartId].Width  then
                           nIdx = nInd2 
                           bOnOppositeSide = true 
                           -- aggiorno le info di rotazione
                           if res.nRotate > 0 then
                              local bPartFlip = ( ( EgtGetInfo( AngleClassification[nInd].PartId, "INVERTED", 'i') or 0) == 180)
                              local nPartRot = EgtGetInfo( AngleClassification[nInd].PartId, "ROTATED", 'i') or 0
                              local nTotRot = nPartRot - EgtIf( bPartFlip, -res.nRotate, res.nRotate)
                              nTotRot = EgtIf( nTotRot < 0, nTotRot + 360, nTotRot)    
                              EgtSetInfo( AngleClassification[nInd].PartId, "ROTATED", nTotRot)
                              EgtSetInfo( AngleClassification[nInd].PartId, "MODIFIEDFORNEST", 1)
                           end
                           break
                        end
                        -- altrimenti lo riporto nella sua posizione originaria 
                        EgtRotate( AngleClassification[nInd].PartId, b3Part:getCenter(), Z_AX(), - res.nRotate, GDB_RT.GLOB)
                     end
                  end  
               end
               
               -- nesto il pezzo a mano
               if nIdx ~= -1 then
                  -- aree di lavorazione
                  local nToolOutlineIds = ComputeToolOutlines( AngleClassification[nInd].PartId)
                  local sInfo = ""
                  for nInd = 1, #nToolOutlineIds do
                     sInfo = sInfo .. tostring(nToolOutlineIds[nInd]) .. ","
                  end   
                  -- salvo tra le info del pezzo gli id delle sue aree di lavorazione 
                  if sInfo ~= "" then
                     EgtSetInfo( AngleClassification[nInd].PartId, "ToolOutlines", sInfo)
                  end        
                  
                  -- calcolo defect corrispondente al pezzo
                  local PartTab = CreateDefectOnAngle( AngleClassification[nInd].PartId, RawParts[vManuallyDone[nIdx].RawPartId], AngleClassification[nInd].bLongDrill, bOnOppositeSide)
                  PartTab.bLongDrill = AngleClassification[nInd].bLongDrill
                  table.insert( vManuallyDone[nIdx].Parts, PartTab)
                  table.insert( vPartsManuallyDone, tonumber( AngleClassification[nInd].PartId))
                  
               else
                  -- aggiungo info per il nesting per ricordare che andrà su angolo
                  EgtSetInfo( AngleClassification[nInd].PartId, "NestOnAngle", 1)
               end 
            else
               -- se non va nestato manualmente segno info per nesting 
               EgtSetInfo( AngleClassification[nInd].PartId, "NestOnAngle", 1)
            end
            
         else
            -- se non ho più angoli a disposizione lo metto sul lato
            EgtSetInfo(AngleClassification[nInd].PartId, "NestOnEdge", 1)
         end
         
      else
         EgtSetInfo(AngleClassification[nInd].PartId, "NestOnEdge", 1)
      end

   end
   
   local nInd = 1
   while nInd <= #vManuallyDone do
      if #(vManuallyDone[nInd].Parts) == 0 then 
         table.remove( vManuallyDone, nInd)
      else
         nInd = nInd + 1
      end
   end
   
   return vManuallyDone, vPartsManuallyDone
end

------------------------------------------------------------------
-- Funzione che sposta e aggiunge pezzi per nesting
local function AddRawParts(RawParts, vDoneManually)
   
   local OUTLINE = "Outline"
   for nIndex = 1, #RawParts do
      RawParts[nIndex].PartId = {}
      
      -- pannelli con pezzi inseriti manualmente 
      local nTotSheetWithDefects = 0 
      for nInd = 1, #vDoneManually do
         if vDoneManually[nInd].RawPartId == nIndex then
            -- creo pannello del materiale
            local SheetPartId = EgtGroup(GDB_ID.ROOT)
            table.insert( RawParts[nIndex].PartId, SheetPartId)
            EgtSetName(SheetPartId, "Sheet")
            local SheetLayerId = EgtGroup(SheetPartId)
            EgtSetName(SheetLayerId, OUTLINE)
            local SheetOutlineId = EgtRectangle2P(SheetLayerId, Point3d(0,0,0), Point3d(RawParts[nIndex].Len + 0.1, RawParts[nIndex].Width + 0.1, 0), GDB_RT.GLOB)     
            EgtSetName(SheetOutlineId, OUTLINE)
            -- creo foglio per nesting
            EgtAutoNestAddSheet( SheetPartId, SheetOutlineId, NEST.KERF, 0, 1) 
            -- aggiungo defects
            for nInd2 = 1, #(vDoneManually[nInd].Parts) do
               EgtAutoNestAddDefectToSheet( SheetPartId, vDoneManually[nInd].Parts[nInd2].DefectId)               
            end
            vDoneManually[nInd].SheetId = SheetPartId 
            nTotSheetWithDefects = nTotSheetWithDefects + 1 
         end
      end
      
      -- pannelli senza pezzi inseriti manualmente
      local SheetPartId = EgtGroup(GDB_ID.ROOT)
      table.insert( RawParts[nIndex].PartId, SheetPartId)
      EgtSetName(SheetPartId, "Sheet")
      local SheetLayerId = EgtGroup(SheetPartId)
      EgtSetName(SheetLayerId, OUTLINE)
      local SheetOutlineId = EgtRectangle2P(SheetLayerId, Point3d(0,0,0), Point3d(RawParts[nIndex].Len + 0.1, RawParts[nIndex].Width + 0.1, 0), GDB_RT.GLOB)
      -- EgtModifyCurveThickness(SheetOutlineId, -Material.T_mm)
      EgtSetName(SheetOutlineId, OUTLINE)
    
      -- creo foglio per nesting
      EgtAutoNestAddSheet( SheetPartId, SheetOutlineId, NEST.KERF, 1, RawParts[nIndex].Qty - nTotSheetWithDefects)           
      -- EgtAutoNestAddSheet( SheetId, OutlineId, dKerf, nPriority, nCount)
   end
end

------------------------------------------------------------------
local function AddParts(RawParts, vPartsDoneManually)
   
   -- cerco la width massima dei grezzi
   local dRawMaxWidth = - 100
   for nIndex = 1, #RawParts do
      if RawParts[nIndex].Width > dRawMaxWidth then
         dRawMaxWidth = RawParts[nIndex].Width
      end
   end
   
   -- valori correttivi per vincoli StripX e StripY
   local dStripYCorr = GEO.EPS_SMALL
   local dStripXCorr = GEO.EPS_SMALL
   if NEST.CORNER == NST_CORNER.TL or NEST.CORNER == NST_CORNER.TR then
      dStripYCorr = 0.1 - GEO.EPS_SMALL
   end
   if NEST.CORNER == NST_CORNER.BR or NEST.CORNER == NST_CORNER.TR then
      dStripXCorr = 0.1 - GEO.EPS_SMALL
   end
   
   local nTotParts = 0
   for _ in pairs( PART) do nTotParts = nTotParts + 1 end
   local nPartIndex = 0
   -- ciclo su pezzi per aggiungerli al nesting
   for nPartId, nCount in pairs( PART) do repeat
      
      -- conto quanti pezzi di questo tipo sono già stati posizionati a mano 
      nManuallyDone = 0 
      for nJ = 1, #vPartsDoneManually do 
         if vPartsDoneManually[nJ] == tonumber( nPartId) then
            nManuallyDone = nManuallyDone + 1
         end
      end 
      
      if nManuallyDone == nCount then
         -- se tutti posizionati passo al pezzo successivo 
         break
      else
         -- posiziono con il nesting solo quelli mancanti 
         nCount = nCount - nManuallyDone
      end
      
      nPartIndex = nPartIndex + 1
      
      -- calcolo bbox pezzo per rotazioni
      local b3Part = EgtGetBBoxGlob( nPartId, GDB_BB.STANDARD)
     
      -- recupero eventuali stati di flip e rotazione dalle info del pezzo
      local bFlipNest = true
      local bFlip = false 
      local bRotNest = true
      local nStepRotNest = 90
      local nRotate = 0 
      
     -- flip
      local bManualFlip = EgtGetInfo( nPartId, "MANUALFLIP", 'b')
      if bManualFlip then
         bFlipNest = false
      elseif EgtExistsInfo( nPartId, "NestFlip") then   
         bFlipNest = EgtGetInfo( nPartId, "NestAllowFlip", 'b')
         bFlip = EgtGetInfo( nPartId, "NestFlip", 'b')
      end
      
      -- rotation
      local bManualRot = EgtGetInfo( nPartId, "MANUALROT", 'b')
      if bManualRot then 
         bRotNest = false
      elseif EgtExistsInfo( nPartId, "NestRot") then 
         nStepRotNest = EgtGetInfo( nPartId, "NestStepRot", 'i')
         bRotNest = EgtGetInfo( nPartId, "NestAllowRot", 'b')
         -- verifico se rotazione è valida (pezzo è contenuto nel grezzo)
         local bValidRotationInRaw = b3Part:getDimX() < RawParts[1].Len - 2 * NEST.KERF + GEO.EPS_SMALL and b3Part:getDimY() < dRawMaxWidth - 2 * NEST.KERF + GEO.EPS_SMALL
         if not bValidRotationInRaw then
            bRotNest = true
            nStepRotNest = 90
         end
      end

      -- recupero vecchio contorno se già presente 
      local nOutlineLayer = EgtGetFirstNameInGroup(nPartId, "Outline")
      local nOldOutline = EgtGetFirstNameInGroup(nOutlineLayer, 'ON_TMP')
      local nOutline, nCnt

      -- se l'outline non è stato calcolato oppure il pezzo è stato modificato, lo ricalcolo
      local bPartIsModified = EgtGetInfo( nPartId, "MODIFIEDFORNEST", 'b')
      if not nOldOutline or bPartIsModified then
         
         -- elimino il vecchio contorno se pesente
         while ( nOldOutline) do 
            EgtErase(nOldOutline or GDB_ID.NULL)
            nOldOutline = EgtGetFirstNameInGroup( nOutlineLayer, 'ON_TMP')
         end
         
         -- Recupero o ricalcolo il solido
         local SolidId = EgtBeamGetSolid( nPartId)
         if not SolidId or not EgtGetInfo( SolidId, 'VALID') then
            EgtBeamCalcSolid( nPartId, true)
            SolidId = EgtBeamGetSolid( nPartId)
         end
         nOutline, nCnt = EgtGetSurfTmSilhouette( SolidId, Z_AX(), 10, nOutlineLayer, GDB_RT.GLOB)
         EgtBeamShowSolid( nPartId, false)

         for nInd = 0, nCnt - 1 do
            EgtSetName( nOutline + nInd, 'ON_TMP')
            EgtSetStatus( nOutline + nInd, 0)
         end

         local nCurrOutline = nOutline
         if nCnt > 0 then
            local frSum
            EgtScale( nOutline, GLOB_FRM(), 1, 1, 0, GDB_RT.GLOB)
            EgtModifyCurveExtrusion( nOutline, Z_AX(), GDB_RT.GLOB)

           -- verifico che la prima curva sia l'unico loop esterno
           local vtCrvRefN = EgtCurveArea( nOutline)
           for nInd = 1, nCnt - 1 do
              local vtCrvN = EgtCurveArea( nOutline + nInd)
              -- se trovo più loop esterni uso come contorno quello del box (quindi forzo nCurrOutline a nil)
              if vtCrvN and vtCrvRefN and AreSameVectorApprox( vtCrvN, vtCrvRefN) then
                 nCurrOutline = nil
                 for nInd2 = 0, nCnt - 1 do
                    EgtErase( nOutline + nInd2)
                 end
                 nCnt = 1
                 break
              end
           end
         end

         if nCurrOutline and nCurrOutline ~= GDB_ID.NULL then
            nOutline = nCurrOutline
         else
            -- se non ho trovato contorno, lo recupero dal Box
            local nBoxLayer = EgtGetFirstNameInGroup(nPartId, "Box")
            local nBox = EgtGetFirstNameInGroup(nBoxLayer, "Box")
            local BBox = EgtGetBBoxGlob(nBox, GDB_BB.STANDARD)
            nOutline = EgtRectangle2P(nOutlineLayer, Point3d( BBox:getMin():getX(), BBox:getMin():getY(), 0), Point3d( BBox:getMax():getX(), BBox:getMax():getY(), 0), GDB_RT.GLOB)
            EgtOutLog("Impossible creating silhouette for part " .. tostring(nPartId))
            nCnt = 1
         end
         
         EgtSetName( nOutline, 'ON_TMP')
         EgtSetStatus( nOutline, 0)
         
      else
         -- altrimenti uso l'outline già calcolato
         nOutline = nOldOutline
         -- recupero il valore di nCnt
         local vOutlinesIds = EgtGetNameInGroup( nOutlineLayer, 'ON_TMP') 
         nCnt = #vOutlinesIds
      end
      
      -- calcolo aree lavorazione
      local nToolOutlineIds = ComputeToolOutlines( nPartId)
      if bFlipNest and #nToolOutlineIds > 0 then
         bFlipNest = false
      end      
      
      if nOutline then
         -- aggiungo pezzo al nesting
            EgtAutoNestAddPart( nPartId, nOutline, bFlipNest, bRotNest, nStepRotNest, 0, nCount)
         -- EgtAutoNestAddPart( PartId, OutlineId, bCanFlip, bCanRotate, dRotStep, nPriority, nCount)
      end
      -- aggiungo finestre
      for nInd = 1, nCnt - 1 do
         local _, _, dArea =  EgtCurveArea( nOutline + nInd) 
         if dArea and dArea > s_dNestHoleMinArea then 
            EgtModifyCurveExtrusion( nOutline + nInd, Z_AX(), GDB_RT.GLOB)  
            EgtAutoNestAddHoleToPart( nPartId, nOutline + nInd)           
         end
      end
      
      -- aggiungo aree di lavorazione del pezzo 
      local sInfo = ""
      for nInd = 1, #nToolOutlineIds do
         EgtAutoNestAddToolOutlineToPart( nPartId, nToolOutlineIds[nInd])  
         sInfo = sInfo .. tostring(nToolOutlineIds[nInd]) .. ","
      end   
      -- salvo tra le info del pezzo gli id delle sue aree di lavorazione 
      if sInfo ~= "" then
         EgtSetInfo( nPartId, "ToolOutlines", sInfo)
      end        
      
      -- Eventuali vincoli StripX e StripY
      local bOnEdge = EgtGetInfo(nPartId, "NestOnEdge", 'b')
      local bOnAngle = EgtGetInfo(nPartId, "NestOnAngle", 'b')
      if bOnEdge or bOnAngle then 
         local nBoxLayerId = EgtGetFirstNameInGroup( nPartId, "Box")
         local nBoxId = EgtGetFirstNameInGroup( nBoxLayerId, "Box")
         local b3Part = EgtGetBBoxGlob(nBoxId, GDB_BB.STANDARD)
         
         -- punto di riferimento sul pezzo
         local ptRef 
         local dval = 10
         if ( s_sOrigCorner == 'TL' or s_sOrigCorner == 'TR') then
            ptRef = Point3d( b3Part:getMax():getX() - b3Part:getDimX() / 2, b3Part:getMax():getY() - dval, 0)
         else
            ptRef = Point3d( b3Part:getMin():getX() + b3Part:getDimX() / 2, b3Part:getMin():getY() + dval, 0)
         end
         
         -- vincolo StripY
         local bOnlyOnRefSide = EgtGetInfo( nPartId, "OnlyOnRefSide", 'b')
         if bOnlyOnRefSide then
            if s_sOrigCorner == 'BL' or s_sOrigCorner == 'BR' then
               EgtAutoNestSetStripYconstraintToPart( nPartId, ptRef, NEST.KERF + dval + dStripYCorr, 100000)
            else
               EgtAutoNestSetStripYconstraintToPart( nPartId, ptRef, - 1000, dRawMaxWidth + 1000 - ( NEST.KERF + dval - dStripYCorr))
            end
         else
            EgtAutoNestSetStripYconstraintToPart( nPartId, ptRef, NEST.KERF + dval + dStripYCorr, dRawMaxWidth - 2 * ( NEST.KERF + dval))
         end
          
          -- se sull'angolo aggiungo anche vincolo StripX
         if bOnAngle then
            if s_sOrigCorner == 'TL' or s_sOrigCorner == 'BL' then
               EgtAutoNestSetStripXconstraintToPart( nPartId, ptRef, NEST.KERF + b3Part:getDimX() / 2 + dStripXCorr, 100000)
            else
               EgtAutoNestSetStripXconstraintToPart( nPartId, ptRef, -100, RawParts[1].Len + 100 - NEST.KERF - b3Part:getDimX() / 2 + dStripXCorr)
            end
         end
      end
  
      -- verifico se anullato nesting
      if EgtProcessEvents( 100 + ( nPartIndex / nTotParts * 100), 0) == 1 then
         return false
      end
      until true
   end
   
   return true
end

------------------------------------------------------------------
------------------------------------------------------------------
-- Inizializzo contatori errori e avvisi
local nErrCnt = 0
local nWarnCnt = 0
local bOk = true
NEST.ERR = 0

-- resetto gruppo di lavorazione corrente
EgtResetCurrMachGroup()

-- modalità nesting utile per cabinet: un grezzo per ogni pezzo, pezzo centrato nel grezzo. Il grezzo non viene preso da magazzino ma creato ad hoc, con un dato sovramateriale.
-- il numero del MachGroup deve coincidere con il PDN del pezzo originale
if NEST.FLAG ~= 11 and WD.ENABLE_SIMPLE_NESTING then

   -- sovramateriale richiesto
   local dOverMaterial = max( 0, NEST.KERF or 2)

   -- inizializzazione parametri per creazione grezzo tramite BatchProcessNew
   _G.WALL = {}
   WALL.FILE = NEST.FILE
   WALL.MACHINE = NEST.MACHINE
   WALL.BASEDIR = NEST.BASEDIR
   WALL.FLAG = 6    -- CREATE_PANEL
   WALL.NESTING_REF = 'BL'

   -- si ricrea la lista pezzi ordinata
   local PartList = {}
   local nPartCounter = 0
   for nPartId, nCount in pairs( PART) do
      nPartCounter = nPartCounter + 1
      PartList[nPartCounter] = {}
      PartList[nPartCounter].nId = nPartId
      PartList[nPartCounter].nCount = nCount
      PartList[nPartCounter].nPdn = EgtGetInfo( nPartId, "PDN", 'i')
      PartList[nPartCounter].bAddCounterToNaming = false
      -- se presente un pezzo con multipli il PDN sarà seguito da un contatore
      if nCount > 1 then
         PartList[nPartCounter].bAddCounterToNaming = true
      end
   end
   -- si riordina in base al PDN
   table.sort( PartList, function(a, b) return tonumber( a.nPdn) < tonumber( b.nPdn) end)

   -- per ogni singolo pezzo si chiama la fliprot per avere la migliore orientazione
   -- si creano duplo e machgroup e si settano le note opportune per poi creare i grezzi richiamando la BatchProcessNew (flag 6)
   for i = 1, #PartList do

      local nPartId = PartList[i].nId
      local nPartCount = PartList[i].nCount
      local nPdn = PartList[i].nPdn
      local bAddCounterToNaming = PartList[i].bAddCounterToNaming

      -- si ruotano e invertono i pezzi per avere la migliore posizione di lavorazione
      _G.NFAR = {}
      NFAR.ERR = 0
      NFAR.MSG = ''
      NFAR.PARTID = nPartId
      NFAR.BASEDIR = NEST.BASEDIR
      dofile( NEST.BASEDIR .. "\\NestFlipAndRotate.lua")

      -- informazioni dalla parte originale
      -- box e relative dimensioni
      local nBoxLayerId = EgtGetFirstNameInGroup( nPartId, "Box")
      local nBoxId = EgtGetFirstNameInGroup( nBoxLayerId, "Box")
      local b3Part = EgtGetBBoxGlob( nBoxId, GDB_BB.STANDARD)
      -- inversione e rotazione
      local nPartFlip = EgtGetInfo( nPartId, "INVERTED", 'i') or 0
      local nPartRotation = EgtGetInfo( nPartId, "ROTATED", 'i') or 0

      -- dimensioni grezzo, considerando sovramateriale
      local dRawLength = b3Part:getDimX() + 2 * dOverMaterial
      local dRawWidth = b3Part:getDimY() + 2 * dOverMaterial

      for j = 1, nPartCount do
         -- creazione gruppo di lavoro
         local sMachGroupName = nPdn
         if bAddCounterToNaming then
            sMachGroupName = nPdn .. '_' .. string.format("%02d", j)
         end
         local nMachGroupId = EgtAddMachGroup( sMachGroupName)
         if not nMachGroupId then
            EgtOutLog( "Errore: MachGroup " .. nPdn .. " già presente")
            EgtOutBox( 'Error : MachGroup ' .. nPdn .. ' already existing', 'Nesting failed')
            NEST.ERR = 2
            return
         end
         -- settaggio note in gruppo di lavoro
         EgtSetInfo( nMachGroupId, "PANELLEN", dRawLength)
         EgtSetInfo( nMachGroupId, "PANELWIDTH", dRawWidth)
         EgtSetInfo( nMachGroupId, "MATERIAL", NEST.MATERIAL)
         EgtSetInfo( nMachGroupId, "PRODID", NEST.PRODID)
         EgtSetInfo( nMachGroupId, "PATTID", nMachGroupId)

         -- creazione duplo
         local nPartDuploId = EgtDuploNew( nPartId)
         -- settaggio note in duplo
         EgtSetInfo( nMachGroupId, "PART" .. 1, nPartDuploId .. "," .. EgtNumToString( dOverMaterial) .. "," .. EgtNumToString( dOverMaterial) .. "," .. 0 .."," .. 0)
         EgtSetInfo( nPartDuploId, "POSY", dOverMaterial)
         EgtSetInfo( nPartDuploId, "POSX", dOverMaterial)
         EgtSetInfo( nPartDuploId, "FLIP", nPartFlip)
         EgtSetInfo( nPartDuploId, "ROT", nPartRotation)

         -- creazione grezzi tramite BatchProcessNew
         EgtSetCurrMachGroup( nMachGroupId)
         EgtSetInfo( nMachGroupId, "UPDATEUI", 1)
         dofile( NEST.BASEDIR .. "\\BatchProcessNew.lua")
      end
   end

   EgtProcessEvents( 200 + 100, 0)
   EgtResetCurrMachGroup()
   EgtOutLog( ' +++ NestProcess completed')

   EgtOutLog( ' +++ Generating Cutting List')

   return

elseif NEST.FLAG == 11 then

   local vCuttingListType = EgtSplitString( WD.PANELSAW_TYPE)
   for i = 1, #vCuttingListType do
      local sCuttingListType = vCuttingListType[i]
      PanelSaw.GenerateCuttingList( sCuttingListType)
   end

   return
end

-- inizio nesting automatico
EgtAutoNestStart()

-- lista dei grezzi
local RawParts = {}
-- creo tabella dei grezzi
for sIndex, dLen in pairs( LEN) do
   RawParts[tonumber(sIndex)] = { Len = dLen}
end
for sIndex, dWidth in pairs( WIDTH) do
   RawParts[tonumber(sIndex)].Width = dWidth
end
for sIndex, nQty in pairs( QTY) do
   RawParts[tonumber(sIndex)].Qty = nQty
end
for sIndex, sMaterial in pairs( MATERIAL) do
   RawParts[tonumber(sIndex)].Material = sMaterial
end

-- 
local vDoneManually, vPartsDoneManually = ComputeRestrictedZones( RawParts)

-- creo grezzi e li aggiungo al nesting
AddRawParts(RawParts, vDoneManually)

if not bOk then
   EgtOutLog("Interruzione nesting")
   NEST.ERR = 1
end

-- calcolo rotazioni e flip ed aggiungo pezzi al nesting
if bOk then
   bOk = AddParts(RawParts, vPartsDoneManually)
end

if not bOk then
   EgtOutLog("Interruzione nesting")
   NEST.ERR = 1
end

if bOk then
   -- aggiungo offset tra pezzi
   EgtAutoNestSetInterpartGap( NEST.OFFSET)

   -- Impostazione corner di inizio del nesting (NST_CORNER.BL, TL, BR, TR)
   EgtAutoNestSetStartCorner( NEST.CORNER)
   
   -- Report dei dati di nesting per debug
   EgtAutoNestSetReportFile( EgtGetTempDir() .. '\\LastNest.json')

   -- imposto tempo di nesting e lo avvio
   EgtAutoNestCompute( true, NEST.TIME)
end

-- Variabili di calcolo
local nNestedParts, nParts, nSheets, nNestings, dTotFillRatio
local bNestingOk = bOk
-- Attesa fine calcolo
local nTime = 0
while bNestingOk do
   bNestingOk, nStat = EgtAutoNestGetComputationStatus()
   if nStat == 2 or nStat == 3 then
      nNestedParts, nParts, nSheets, nNestings, dTotFillRatio = EgtAutoNestGetResults()
      --EgtOutText( string.format( 'Parts : %d/%d   Filling : %.2f%%', nNestedParts, nParts, 100 * dTotFillRatio))
   end
   if nStat == 3 then break end
   nTime = nTime + 1
   if EgtProcessEvents( nTime / NEST.TIME * 100, 995) == 1 then
      bNestingOk = EgtAutoNestCancelComputation()
      bOk = false
      EgtOutLog("Interruzione nesting")
      NEST.ERR = 1
      break
   end
end


local dXCorr = 0
local dYCorr = 0
if NEST.CORNER == NST_CORNER.TL then
   dYCorr = - 0.1
elseif NEST.CORNER == NST_CORNER.TR then
   dYCorr = - 0.1
   dXCorr = - 0.1
elseif NEST.CORNER == NST_CORNER.BR then
   dXCorr = - 0.1
end


-- se nesting andato bene
if bNestingOk then

   -- disposizione sheet e parts
   local SheetId = GDB_ID.NULL
   local vtAdd = V_NULL()
   local MachGroupList = {}
   local nPartCount = 0
   local Sheet = {PartList = {}}
   local bFirstSheet = true
   for i = 0, 999 do
      local nType, nId, nFlag, dX, dY, dAngRot = EgtAutoNestGetOneResult( i)
      if not nType then break end
      -- se sheet
      if nType > 0 then
         MachGroupList = {}
         for MGIndex = 1, nType do
            -- creo gruppo di lavorazione
            local MachGroupName = NewMachGroupName()
            local nMachGroup = EgtAddMachGroup(MachGroupName, sCurrMachName)
            table.insert( MachGroupList, { MGId = nMachGroup})
            for nIndex = 1, #RawParts do
               for nInd2 = 1, #(RawParts[nIndex].PartId) do 
                  if RawParts[nIndex].PartId[nInd2] == nId then
                     EgtSetInfo(nMachGroup, "PANELLEN", RawParts[nIndex].Len)
                     EgtSetInfo(nMachGroup, "PANELWIDTH", RawParts[nIndex].Width)
                     EgtSetInfo(nMachGroup, "MATERIAL", NEST.MATERIAL)
                     EgtSetInfo(nMachGroup, "AUTONEST", 1)
                     -- scrivo dati per variabili P di comunicazione con la macchina in gruppo di lavorazione
                     EgtSetInfo( nMachGroup, "PRODID", NEST.PRODID)
                     EgtSetInfo( nMachGroup, "PATTID", nMachGroup)
                  end
               end
            end
            
            -- aggiungo pezzi nestati a mano
            nPartCount = 0 
            for nInd = 1, #vDoneManually do
               if vDoneManually[nInd].SheetId == nId then
                  vDoneManually[nInd].Done = 1 
                  for nInd2 = 1, #(vDoneManually[nInd].Parts) do
                     nPartCount = nPartCount + 1
                     local nPartDuploId = EgtDuploNew( vDoneManually[nInd].Parts[nInd2].Id)  
                     
                     -- aggiungo le curve corrispondenti alle aree di lavorazione del pezzo 
                     local sToolOutlines = EgtGetInfo( vDoneManually[nInd].Parts[nInd2].Id, "ToolOutlines", 's')
                     if sToolOutlines then 
                        -- recupero o creo il gruppo per gli outlines
                        local nToolOutlinesGrp = EgtGetFirstNameInGroup( nPartDuploId, "ToolOutlines")
                        if not nToolOutlinesGrp then
                           nToolOutlinesGrp = EgtGroup( nPartDuploId)
                           EgtSetName( nToolOutlinesGrp, "ToolOutlines")
                           EgtSetStatus( nToolOutlinesGrp, GDB_ST.ON)
                        end
                     
                        for str in string.gmatch(sToolOutlines, "([^"..",".."]+)") do 
                           EgtCopyGlob( tonumber(str), nToolOutlinesGrp)
                        end
                     end
                     
                     -- applico flip, rotazione e traslazione pezzo e box da nesting
                     EgtSetInfo( nMachGroup, "PART" .. nPartCount, nPartDuploId .. "," .. EgtNumToString( vDoneManually[nInd].Parts[nInd2].posX, 3) .. "," .. EgtNumToString( vDoneManually[nInd].Parts[nInd2].posY, 3) .. "," .. 0 .."," .. 0)
                     EgtSetInfo( nPartDuploId, "POSX", vDoneManually[nInd].Parts[nInd2].posX)
                     EgtSetInfo( nPartDuploId, "POSY", vDoneManually[nInd].Parts[nInd2].posY)
                  end
               end
            end
         end
      
      -- altrimenti pezzo 
      else
         nPartCount = nPartCount + 1
         for MGIndex = 1, #MachGroupList do
            local nMachGroup = MachGroupList[MGIndex].MGId
            --EgtSetCurrMachGroup(nMachGroup)
            -- se c'e' un grezzo valido
            if nMachGroup and nMachGroup ~= GDB_ID.NULL then
               -- creo pezzo copia
               local nPartDuploId = EgtDuploNew( nId)
               local nPartInd
               
               -- aggiungo le curve corrispondenti alle aree di lavorazione del pezzo 
               local sToolOutlines = EgtGetInfo( nId, "ToolOutlines", 's')
               if sToolOutlines then 
                  -- recupero o creo il gruppo per gli outlines
                  local nToolOutlinesGrp = EgtGetFirstNameInGroup( nPartDuploId, "ToolOutlines")
                  if not nToolOutlinesGrp then
                     nToolOutlinesGrp = EgtGroup( nPartDuploId)
                     EgtSetName( nToolOutlinesGrp, "ToolOutlines")
                     EgtSetStatus( nToolOutlinesGrp, GDB_ST.ON)
                  end
               
                  for str in string.gmatch(sToolOutlines, "([^"..",".."]+)") do 
                     EgtCopyGlob( tonumber(str), nToolOutlinesGrp)
                  end
               end
               
                -- applico flip, rotazione e traslazione pezzo e box da nesting
               if nFlag == 1 then 
                  EgtRotate( nPartDuploId, ORIG(), X_AX(), 180, GDB_RT.GLOB)
               end             
               EgtRotate( nPartDuploId, ORIG(), Z_AX(), dAngRot, GDB_RT.GLOB)   
               EgtMove( nPartDuploId, Vector3d( dX, dY, 0), GDB_RT.GLOB)
               
               local nBoxLayerId = EgtGetFirstNameInGroup( nPartDuploId, "Box")
               local nBoxId = EgtGetFirstNameInGroup( nBoxLayerId, "Box")
               local PartBBox = EgtGetBBoxGlob(nBoxId, GDB_BB.STANDARD)
               local ptPos = Point3d( PartBBox:getMin():getX(), PartBBox:getMin():getY(), 0)
               EgtSetInfo( nMachGroup, "PART" .. nPartCount, nPartDuploId .. "," .. EgtNumToString( ptPos:getX() + dXCorr, 3) .. "," .. EgtNumToString( ptPos:getY() + dYCorr, 3) .. "," .. 0 .."," .. 0)
               EgtSetInfo( nPartDuploId, "POSX", ptPos:getX() + dXCorr)
               EgtSetInfo( nPartDuploId, "POSY", ptPos:getY() + dYCorr)
               
               local nPartFlip = EgtGetInfo( nId, "INVERTED", 'i') or 0
               nPartFlip = EgtIf( nPartFlip == 180, 1, 0)
               local nTotFlip = EgtIf( nPartFlip ~= nFlag, 180, 0)
               EgtSetInfo( nPartDuploId, "FLIP", nTotFlip)
               
               local bPartFlip = ( nTotFlip == 180)
               local nPartRot = EgtGetInfo( nId, "ROTATED", 'i') or 0
               local nTotRot = nPartRot - EgtIf( bPartFlip, -dAngRot, dAngRot)
               if nTotRot < 0 then
                  nTotRot = nTotRot + 360
               elseif nTotRot >= 360 then
                  nTotRot = nTotRot - 360
               end
               EgtSetInfo( nPartDuploId, "ROT", nTotRot)
            
            end
         end
      end
   end
   
   -- creo gruppi di lavorazione per fogli con pezzi nestati solo a mano 
   for nInd = 1, #vDoneManually do
      if vDoneManually[nInd].Done == 0 then
         -- creo gruppo di lavorazione
         local MachGroupName = NewMachGroupName()
         local nMachGroup = EgtAddMachGroup(MachGroupName, sCurrMachName)
         table.insert( MachGroupList, { MGId = nMachGroup})
         for nIndex = 1, #RawParts do
            for nInd2 = 1, #(RawParts[nIndex].PartId) do 
               if RawParts[nIndex].PartId[nInd2] == vDoneManually[nInd].SheetId then
                  EgtSetInfo(nMachGroup, "PANELLEN", RawParts[nIndex].Len)
                  EgtSetInfo(nMachGroup, "PANELWIDTH", RawParts[nIndex].Width)
                  EgtSetInfo(nMachGroup, "MATERIAL", NEST.MATERIAL)
                  EgtSetInfo(nMachGroup, "AUTONEST", 1)
                  -- scrivo dati per variabili P di comunicazione con la macchina in gruppo di lavorazione
                  EgtSetInfo( nMachGroup, "PRODID", NEST.PRODID)
                  EgtSetInfo( nMachGroup, "PATTID", nMachGroup)
               end
            end
         end
         
         -- aggiungo pezzi nestati a mano
         nPartCount = 0
         for nInd2 = 1, #(vDoneManually[nInd].Parts) do
            nPartCount = nPartCount + 1
            local nPartDuploId = EgtDuploNew( vDoneManually[nInd].Parts[nInd2].Id)
            
            -- aggiungo le curve corrispondenti alle aree di lavorazione del pezzo 
            local sToolOutlines = EgtGetInfo( vDoneManually[nInd].Parts[nInd2].Id, "ToolOutlines", 's')
            if sToolOutlines then 
               -- recupero o creo il gruppo per gli outlines
               local nToolOutlinesGrp = EgtGetFirstNameInGroup( nPartDuploId, "ToolOutlines")
               if not nToolOutlinesGrp then
                  nToolOutlinesGrp = EgtGroup( nPartDuploId)
                  EgtSetName( nToolOutlinesGrp, "ToolOutlines")
                  EgtSetStatus( nToolOutlinesGrp, GDB_ST.ON)
               end
            
               for str in string.gmatch(sToolOutlines, "([^"..",".."]+)") do 
                  EgtCopyGlob( tonumber(str), nToolOutlinesGrp)
               end
            end
            
            -- applico flip, rotazione e traslazione pezzo e box da nesting
            EgtSetInfo( nMachGroup, "PART" .. nPartCount, nPartDuploId .. "," .. EgtNumToString( vDoneManually[nInd].Parts[nInd2].posX, 3) .. "," .. EgtNumToString( vDoneManually[nInd].Parts[nInd2].posY, 3) .. "," .. 0 .."," .. 0)
            EgtSetInfo( nPartDuploId, "POSX", vDoneManually[nInd].Parts[nInd2].posX)
            EgtSetInfo( nPartDuploId, "POSY", vDoneManually[nInd].Parts[nInd2].posY)
         end
      end
   end

   -- creo grezzi per ogni gruppo di lavorazione
   local MachGroupToTCnt = EgtGetMachGroupCount()
   local MachGroupIndex = 0
   _G.WALL = {}
   WALL.FILE = NEST.FILE
   WALL.MACHINE = NEST.MACHINE
   WALL.BASEDIR = NEST.BASEDIR
   WALL.FLAG = 6    -- CREATE_PANEL
   WALL.NESTING_REF = 'BL'
   nMachGroup = EgtGetFirstMachGroup()
   while nMachGroup do
      EgtSetCurrMachGroup( nMachGroup)
      if EgtGetInfo( nMachGroup, "AUTONEST",'i') == 1 then
         MachGroupIndex = MachGroupIndex + 1
         EgtRemoveInfo( nMachGroup, "AUTONEST")
         EgtSetInfo( nMachGroup, "UPDATEUI", 1)
         dofile( NEST.BASEDIR .. "\\BatchProcessNew.lua")
         -- aggiorno interfaccia
         EgtProcessEvents( 200 + ( MachGroupIndex / MachGroupToTCnt * 100), 0)
      end
      
      -- ciclo sui duplo per sistemare Q
      local nRawPartId = EgtGetFirstRawPart()
      -- recupero box grezzo ridotto della tolleranza
      local b3Raw = EgtGetRawPartBBox( nRawPartId)
      b3Raw:expand( - s_dInsideRawTol)
      EgtOutLog( 'RawBox='..tostring( b3Raw))
      
      local nPartDuploId = EgtGetFirstPartInRawPart( nRawPartId)
      while nPartDuploId do
         local vPartProc = WE.CollectFeatures( nPartDuploId)
         for ProcIndex = 1, #vPartProc do
            local Proc = vPartProc[ProcIndex]
            
            if LapJoint.Identify( Proc) then
               -- cerco la faccia rivolta verso l'alto e la faccia rivolta verso il basso 
               local nFaceInd = -1
               local nFaceDownInd = -1
               for nIdx = 0, Proc.Fct - 1 do
                  local vtN = EgtSurfTmFacetNormVersor( Proc.Id, nIdx, GDB_ID.ROOT)
                  if vtN:getZ() > 0.95 then 
                     nFaceInd = nIdx
                  elseif vtN:getZ() < - 0.95 then
                     nFaceDownInd = nIdx
                  end
               end
               -- se è lap joint dall'alto
               if nFaceInd ~= -1 and nFaceDownInd == -1 then
                  local bResetQ = false
                  local ptCen = EgtSurfTmFacetCenter( Proc.Id, nFaceInd, GDB_ID.ROOT)
                  -- se all'interno rimuovo info Q
                  if EnclosesPointXY( b3Raw, ptCen) then
                     bResetQ = true
                  elseif Proc.Fct == 2 then
                     -- se non è interno ma ha 2 facce non ortogonali rimuovo info Q
                     local vtN1 = EgtSurfTmFacetNormVersor( Proc.Id, 0, GDB_ID.ROOT)
                     local vtN2 = EgtSurfTmFacetNormVersor( Proc.Id, 1, GDB_ID.ROOT)
                     if abs( vtN1 * vtN2) > GEO.EPS_SMALL then
                        bResetQ = true
                     end
                  end
                  
                  if bResetQ then
                     -- resetto parametro Q
                     if Proc.Prc == 30 then
                        EgtRemoveInfo( Proc.Id, "Q08")
                        EgtRemoveInfo( Proc.Id, "Q08A")
                     else
                        EgtRemoveInfo( Proc.Id, "Q03")
                        EgtRemoveInfo( Proc.Id, "Q03A")
                     end
                  end
               end

            elseif DoubleCut.Identify( Proc) then
               -- verifico se due facce e rivolto verso l'alto
               if Proc.Fct == 2 then
                  local vtN = {}
                  vtN[1] = EgtSurfTmFacetNormVersor( Proc.Id, 0, GDB_ID.ROOT)
                  vtN[2] = EgtSurfTmFacetNormVersor( Proc.Id, 1, GDB_ID.ROOT)
                  
                  if ( vtN[1]:getZ() >= 0.95 or vtN[2]:getZ() >= 0.95) then
                     local nFaceInd = EgtIf( vtN[1]:getZ() >= 0.95, 0, 1)
                     local ptCen = EgtSurfTmFacetCenter( Proc.Id, nFaceInd, GDB_ID.ROOT)
                     -- se all'interno rimuovo info Q
                     if EnclosesPointXY( b3Raw, ptCen) then
                        -- resetto parametro Q
                        if Proc.Prc == 12 then
                           EgtRemoveInfo( Proc.Id, "Q02")
                           EgtRemoveInfo( Proc.Id, "Q02A")    
                        end
                     end
                  end
               end  
            end            
         end    
         nPartDuploId = EgtGetNextPartInRawPart(nPartDuploId)
      end
      nMachGroup = EgtGetNextMachGroup(nMachGroup)
   end
   
else
   EgtOutLog("Errore: nesting fallito")
   NEST.ERR = 2
end

EgtResetCurrMachGroup()

 -- cancello rettangolo del materiale per nesting
for RawPartId = 1, #RawParts do
   EgtErase(RawParts[RawPartId].PartId)
end

local nOutlineGrp = EgtGetFirstNameInGroup(GDB_ID.ROOT, "ToolOutlines")
if nOutlineGrp and nOutlineGrp ~= GDB_ID.NULL then EgtErase( nOutlineGrp) end
local nSheetDefectsGrp = EgtGetFirstNameInGroup(GDB_ID.ROOT, "SheetDefects")
if nSheetDefectsGrp and nSheetDefectsGrp ~= GDB_ID.NULL then EgtErase( nSheetDefectsGrp) end

-- EgtSaveFile( "C:\\EgtData\\EgtBEAMWALL\\Temp\\file.nge")

EgtOutLog( ' +++ NestProcess completed')