Merge branch 'release/2.5j3'

- nella ricerca lavorazione da usare controllo di utensile attivo sostituito con controllo utensile presente nel setup corrente
- aggiunta gestione aree vietate per chiodature (LockOut for Nail).

LuaLibs/WMachiningLib.lua

@@ -1,9 +1,10 @@
--- MachiningLib.lua by Egaltech s.r.l. 2022/01/12
+-- MachiningLib.lua by Egaltech s.r.l. 2023/10/18
 -- Libreria ricerca lavorazioni per Pareti
 -- 2023/03/09 Piccola correzione alla SideDepth in FindMilling
 --            In FindMilling aggiunta gestione spessore e massimo materiale nel caso di lam
 -- 2023/05/25 Aggiunta funzione AddMachining che incapsula EgtAddMachining trascrivendo le priorità btl dalle feature alle lavorazioni.
 -- 2023/06/07 Alla funzione AddMachining aggiunta la scrittura dell'info ISOUTLINE alle lavorazioni.
+-- 2023/10/18 In SetCurrMachiningAndTool sostituito controllo di utensile attivo con controllo utensile nel setup corrente.
 
 -- Tabella per definizione modulo
 local WMachiningLib = {}
@@ -32,7 +33,7 @@ local function SetCurrMachiningAndTool( sMachName)
    local sTool = EgtTdbGetToolFromUUID( sTuuid)
    if not sTool then return false end
    if not EgtTdbSetCurrTool( sTool) then return false end
-   return EgtTdbGetCurrToolParam( MCH_TP.ACTIVE)
+   return EgtFindToolInCurrSetup( sTool) 
 end
 
 ---------------------------------------------------------------------
@@ -186,7 +187,7 @@ end
 ---------------------------------------------------------------------
 function WMachiningLib.AddMachining( Proc, sName, sMachining)
    local nMchId, sFinalName = EgtAddMachining( sName, sMachining)
-   if type(Proc) == 'table' then
+   if type( Proc) == 'table' then
       local nPriority = EgtGetInfo( Proc.Id or GDB_ID.NULL, 'PRIORITY', 'i')
       EgtSetInfo( nMchId or GDB_ID.NULL, 'PRIORITY', nPriority)
       EgtSetInfo( nMchId or GDB_ID.NULL, 'ISOUTLINE', Proc.IsOutline)

LuaLibs/WProcessFreeContour.lua

@@ -1,4 +1,4 @@
--- ProcessFreeContour.lua by Egaltech s.r.l. 2023/09/26
+-- ProcessFreeContour.lua by Egaltech s.r.l. 2023/10/02
 -- Gestione calcolo profilo libero per Pareti
 -- 2021/11/15 Penna e chiodature sono sempre riportate sulla faccia sopra anche se nel progetto sono sotto.
 -- 2021/12/10 In taglio con lama aggiunta gestione SCC per testa Gearbox.
@@ -24,6 +24,7 @@
 -- 2023/09/12 Modifiche a GetTunnelDimension (asse deve essere com Z globale) e MakeLocalSurf per gestire finestre con lati inclinati.
 -- 2023/09/21 In MakeByMill modificato SCC per correggere caso con lama su testa fresa.
 -- 2023/09/26 In Is3EdgesApprox aggiunta cancellazione dei loop temporanei.
+-- 2023/10/02 Correzione a MakeCustomPath per calcolare correttamente puliture spigoli di tipo 2 (Clean 30) e 3 (Gola di Scarico).
 
 -- Tabella per definizione modulo
 local WPF = {}
@@ -63,6 +64,8 @@ end
 ---------------------------------------------------------------------
 -- Classificazione della feature
 function WPF.Classify( Proc, b3Raw)
+   -- se area vietata (LockOut) non faccio nulla
+   if Proc.LockOut then return true end
    -- verifico se di tipo pocket
    local bPocket = ( EgtGetInfo( Proc.Id, 'PCKT', 'i') == 1)
    -- recupero la curva associata
@@ -629,41 +632,48 @@ end
 ---------------------------------------------------------------------
 local function MakeCustomPath( vGeom, nConeCut, dMillDiam, nAddGrpId, dThick, bClosed)
 
+   -- creo il percorso di lavorazione come contorni inferiori delle facce
    local nPath = {}
-   local nPathData = {}
-
    for i = 1, #vGeom do
-      local dAng
       -- ottengo curva inferiore 1
-      local ptP1, ptP2, ptP3, vtV1, vtV2, dDim1, dDim2 = EgtSurfTmFacetOppositeSide( vGeom[i][1], vGeom[i][2], Z_AX() , GDB_ID.ROOT)
-      if i < #vGeom then
-         -- ricavo i punti e l'angolo interno
-         _, _, _, dAng = EgtSurfTmFacetsContact( vGeom[i][1], vGeom[i][2], vGeom[i+1][2], GDB_ID.ROOT)
-      elseif bClosed then
-         -- ricavo i punti e l'angolo interno
-         _, _, _, dAng = EgtSurfTmFacetsContact( vGeom[i][1], vGeom[i][2], vGeom[1][2], GDB_ID.ROOT)
-      else
-         dAng = 0
-      end
+      local ptP1, _, ptP3 = EgtSurfTmFacetOppositeSide( vGeom[i][1], vGeom[i][2], Z_AX() , GDB_ID.ROOT)
       -- creo linea
       local nId1 = EgtLine( nAddGrpId, ptP1, ptP3, GDB_RT.GLOB)
       table.insert( nPath, nId1)
-      table.insert( nPathData, {nId1, dAng})
    end
-   
-   -- creo il percorso e poi lo offsetto del raggio utensile
    local AuxId = EgtCurveCompo( nAddGrpId, nPath, true)
-   EgtOffsetCurve( AuxId, dMillDiam / 2, GDB_OT.EXTEND)
+
+   -- offsetto a destra il percorso del raggio utensile
+   EgtOffsetCurve( AuxId, dMillDiam / 2, GDB_OT.FILLET)
    -- spezzo il percorso nelle entità componenti
    local nId1st, nIdCount = EgtExplodeCurveCompo( AuxId)
    -- se il numero entità è diverso da quelle iniziali esco con errore
-   if nIdCount ~= #vGeom then
+   if not nId1st then
       local sErr = 'Error : cannot make offset path'
       return 0, sErr
    end
+
+   -- calcolo angoli tra le entità consecutive
+   local nPathData = {}
+   local nIdLast = nId1st + nIdCount - 1
+   for i = nId1st, nIdLast do
+      if i < nIdLast or bClosed then
+         local j = EgtIf( i < nIdLast, i + 1, nId1st)
+         local vtDirFin = EgtEV( i, GDB_ID.ROOT)
+         local vtDirSta = EgtSV( j, GDB_ID.ROOT)
+         local dAng = GetAngleXY( vtDirFin, vtDirSta)
+         local vtBisett = -vtDirFin + vtDirSta
+         if not vtBisett:normalize() then
+            vtBisett = VectorFromRotated( vtDirFin, Z_AX(), -90) 
+         end
+         table.insert( nPathData, { i, dAng, vtBisett})
+      end
+   end
+
    -- resetto la tabella
    nPath = {}
    AuxId = nil
+
    -- in base al tipo di ripresa spigolo modifico il percorso
    if nConeCut == 2 then
       -- acquisisco la lunghezza utensile
@@ -690,13 +700,10 @@ local function MakeCustomPath( vGeom, nConeCut, dMillDiam, nAddGrpId, dThick, bC
          table.insert( nPath, ( nId1st + i - 1))
          -- se non è la linea finale e l'angolo tra le due facce è ammesso
          if ( i < nIdCount or bClosed) and  dThick <= ( WD.MAX_CLEAN_CRN30 + 20 * GEO.EPS_SMALL) and
-            nPathData[i][2] < 0 and nPathData[i][2] > -( 180 - dAngleSmall + 10 * GEO.EPS_SMALL) then
+            nPathData[i][2] < -5 and nPathData[i][2] > -( 180 - dAngleSmall + 10 * GEO.EPS_SMALL) then
             -- aggiungo una retta sulla bisettrice
-            local _, vtN2 = EgtSurfTmFacetCenter( vGeom[i][1], vGeom[i][2], GDB_ID.ROOT)
-            local _, vtN3 = EgtSurfTmFacetCenter( vGeom[i][1], vGeom[EgtIf( i == nIdCount, 1, i+1)][2], GDB_ID.ROOT)
             local ptP1 = EgtEP( ( nId1st + i - 1), GDB_ID.ROOT)
-            -- sommo i tre versori per avere una direzione media
-            local vtExtrExit = vtN2 + vtN3
+            local vtExtrExit = nPathData[i][3]
             vtExtrExit:normalize()
             -- linea intermedia (componente lunghezza utensile in direzione bisettrice)
             local pEnd = ptP1 + ( dLenAdd * vtExtrExit)
@@ -718,15 +725,12 @@ local function MakeCustomPath( vGeom, nConeCut, dMillDiam, nAddGrpId, dThick, bC
          -- se non è la linea finale e l'angolo tra le due facce è ammesso
          if ( i < nIdCount or bClosed) and nPathData[i][2] < 0 then
             -- aggiungo una retta sulla bisettrice
-            local _, vtN2 = EgtSurfTmFacetCenter( vGeom[i][1], vGeom[i][2], GDB_ID.ROOT)
-            local _, vtN3 = EgtSurfTmFacetCenter( vGeom[i][1], vGeom[EgtIf( i == nIdCount, 1, i+1)][2], GDB_ID.ROOT)
             local ptP1 = EgtEP( ( nId1st + i - 1), GDB_ID.ROOT)
-            -- sommo i tre versori per avere una direzione media
-            local vtExtrExit = vtN2 + vtN3
+            local vtExtrExit = nPathData[i][3]
             vtExtrExit:normalize()
             vtExtrExit = -vtExtrExit
             -- calcolo di quanto entrare
-            local dLenAdd = abs( (dMillDiam/2) / cos( nPathData[i][2]/2)) + dExtraCorner - (dMillDiam/2)
+            local dLenAdd = abs( (dMillDiam/2) / cos( nPathData[i][2]/2)) + dExtraCorner - ( dMillDiam / 2)
             -- linea intermedia (componente lunghezza utensile in direzione bisettrice)
             local pEnd = ptP1 + ( dLenAdd * vtExtrExit)
             local nAuxId = EgtLine( nAddGrpId, ptP1, pEnd, GDB_RT.GLOB)
@@ -1257,7 +1261,7 @@ local function AddMillings( sMilling, vFace, Proc, nRawId, b3Raw, nConeCut, nAdd
          dMaxDepth = EgtIf( WD.MILL_MAX_DEPTH_AS_MAT, EgtTdbGetCurrToolParam( MCH_TP.MAXMAT), dFreeLen) or dMaxDepth
       end
    end
-   -- verifico se la facce hanno alcuni lati molto corti e possono quindi essere approssimate a 3 lati
+   -- verifico se le facce hanno alcuni lati molto corti e possono quindi essere approssimate a 3 lati
    for currentFace = 1, #vFace do
       if Is3EdgesApprox( Proc, vFace[currentFace].Fac, nAddGrpId) then
          vFace[currentFace].Is3EdgesApprox = true
@@ -1863,7 +1867,8 @@ local function AddCuts( sCutting, vFace, Proc, nRawId, b3Raw, dSawThick)
             EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_NEAR)
          end
          -- eseguo
-         if not EgtApplyMachining( true, false) then
+         local bApplyOk = EgtApplyMachining( true, false)
+         if not bApplyOk then
             -- provo a invertire direzione, lato di lavoro e attacco/uscita
             EgtSetMachiningParam( MCH_MP.INVERT, not bInvert)
             EgtSetMachiningParam( MCH_MP.WORKSIDE, EgtIf( not bInvert, MCH_SAW_WS.LEFT, MCH_SAW_WS.RIGHT))
@@ -1872,14 +1877,22 @@ local function AddCuts( sCutting, vFace, Proc, nRawId, b3Raw, dSawThick)
             EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, EgtIf( nLeadIn == MCH_SAW_LI.STRICT, MCH_SAW_LO.STRICT, MCH_SAW_LO.CENT))
             EgtSetMachiningParam( MCH_MP.ENDADDLEN, dSal)
             -- ri-eseguo
-            if not EgtApplyMachining( true, false) then
-               local _, sErr = EgtGetLastMachMgrError()
-               EgtSetOperationMode( nMchId, false)
-               return false, sErr
+            bApplyOk = EgtApplyMachining( true, false)
+            if not bApplyOk then
+               local  nErr, sErr = EgtGetLastMachMgrError()
+               -- se direzione irraggiungibile (solitamente lama su testa fresa 5A e taglio inclinato) si imposta di usare fresa
+               if nErr == 2215 then
+                  EgtOutLog( ' Warning : sawing impossible due to unreachable direction, try milling')
+                  EgtRemoveOperation( nMchId) 
+                  vFace[i].Type = 4
+               else
+                  EgtSetOperationMode( nMchId, false)
+                  return false, sErr
+               end
             end
          end
          -- se limite lunghezza di taglio e taglio lo supera
-         if WD.CUT_MAX_LENGTH and vFace[i].Len > WD.CUT_MAX_LENGTH then
+         if bApplyOk and WD.CUT_MAX_LENGTH and vFace[i].Len > WD.CUT_MAX_LENGTH then
             -- sdoppio la lavorazione
             local sSouName = EgtGetName( nMchId)
             local nNewMchId = EgtCopyMachining( sSouName..'_B', sSouName)
@@ -2295,7 +2308,7 @@ local function MakeByMark( Proc, nRawId, b3Raw)
 end
 
 ---------------------------------------------------------------------
-local function MakeByNail( Proc, nRawId, b3Raw)
+local function MakeByNail( Proc, nRawId, b3Raw, vNLO)
    -- ingombro del pezzo
    local Ls = EgtGetFirstNameInGroup( Proc.PartId, 'Box')
    local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD)
@@ -2322,6 +2335,36 @@ local function MakeByNail( Proc, nRawId, b3Raw)
       nCntData = nCntData + 10
    end
    local dCntPar = EgtGetInfo( Proc.Id, 'CNT_PAR', 'd') or 100
+   -- se presenti aree vietate alle chiodature, gestisco le geometrie
+   local vCrvs = {}
+   if #vNLO > 0 then
+      -- in presenza di aree vietate non sono ammesse lavorazioni in doppio (non dovrebbe mai accadere per precedenti controlli)
+      if Proc.Double then
+         local sErr = 'Error : nailing in double with LockOut Area not allowed'
+         EgtOutLog( sErr)
+         return false, sErr
+      end
+      -- gruppo ausiliario
+      local nAddGrpId = WL.GetAddGroup( Proc.PartId)
+      -- copio la curva da lavorare
+      vCrvs[1] = EgtCopyGlob( AuxId, nAddGrpId)
+      -- la trimmo con tutte le aree vietate
+      for i = 1, #vNLO do
+         local vRes = {}
+         for j = 1, #vCrvs do
+            local nNewId, nCount = EgtTrimCurveWithRegion( vCrvs[j], vNLO[i], false, false)
+            if nNewId then
+               vRes = EgtTableAdd( vRes, nNewId, nCount) 
+            end
+         end
+         vCrvs = vRes
+      end
+   else
+      vCrvs[1] = AuxId
+   end
+   -- per debug
+   local sOut = table.concat( vCrvs, ',')
+   EgtOutLog( 'Nailing curve : '.. ( sOut or ''))
    -- recupero la lavorazione
    local sNailing = WM.FindNailing( nCntData)
    if not sNailing then
@@ -2329,49 +2372,51 @@ local function MakeByNail( Proc, nRawId, b3Raw)
       EgtOutLog( sErr)
       return false, sErr
    end
-   -- inserisco la lavorazione
-   local sName = 'Nail_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-   local nMchId = WM.AddMachining( Proc, sName, sNailing)
-   if not nMchId then
-      local sErr = 'Error adding machining ' .. sName .. '-' .. sNailing
-      EgtOutLog( sErr)
-      return false, sErr
-   end
-   EgtSetInfo( nMchId, 'Part', Proc.PartId)
-   -- aggiungo geometria
-   EgtSetMachiningGeometry( {{ AuxId, -1}})
-   -- percorso da non invertire
-   EgtSetMachiningParam( MCH_MP.INVERT, false)
-   -- se estrusione da sotto, inverto direzione fresa
-   if bToolInv then
-      EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
-   end
-   -- assegno affondamento
-   EgtSetMachiningParam( MCH_MP.DEPTH, 10)
-   -- assegno lato di lavoro
-   EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.CENTER)
-   -- se in doppio lungo Y, devo dimezzare opportunamente la lavorazione
-   local dExtraDelta = 0
-   if Proc.Double == 2 then
-      dExtraDelta = 0.45 * dCntPar
-      if Proc.Delta > 0 then
-         EgtSetMachiningParam( MCH_MP.ENDADDLEN, -Proc.DblAcc - dExtraDelta)
-      else
-         EgtSetMachiningParam( MCH_MP.STARTADDLEN, -Proc.DblAcc - dExtraDelta)
+   for i = 1, #vCrvs do
+      -- inserisco la lavorazione
+      local sName = 'Nail_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_'..tostring( i)
+      local nMchId = WM.AddMachining( Proc, sName, sNailing)
+      if not nMchId then
+         local sErr = 'Error adding machining ' .. sName .. '-' .. sNailing
+         EgtOutLog( sErr)
+         return false, sErr
+      end
+      EgtSetInfo( nMchId, 'Part', Proc.PartId)
+      -- aggiungo geometria
+      EgtSetMachiningGeometry( {{ vCrvs[i], -1}})
+      -- percorso da non invertire
+      EgtSetMachiningParam( MCH_MP.INVERT, false)
+      -- se estrusione da sotto, inverto direzione fresa
+      if bToolInv then
+         EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
+      end
+      -- assegno affondamento
+      EgtSetMachiningParam( MCH_MP.DEPTH, 10)
+      -- assegno lato di lavoro
+      EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.CENTER)
+      -- se in doppio lungo Y, devo dimezzare opportunamente la lavorazione
+      local dExtraDelta = 0
+      if Proc.Double == 2 then
+         dExtraDelta = 0.45 * dCntPar
+         if Proc.Delta > 0 then
+            EgtSetMachiningParam( MCH_MP.ENDADDLEN, -Proc.DblAcc - dExtraDelta)
+         else
+            EgtSetMachiningParam( MCH_MP.STARTADDLEN, -Proc.DblAcc - dExtraDelta)
+         end
+      end
+      -- assegno parametri a note utente
+      local sUserNotes = 'Par=' .. EgtNumToString( dCntPar, 0) .. ';'
+      if Proc.Double and Proc.Double > 0 then
+         sUserNotes = sUserNotes .. 'Dbl=' .. EgtNumToString( Proc.Double, 0) .. ';' ..
+                                    'Dlt=' .. EgtNumToString( abs( Proc.Delta) + dExtraDelta, 0) .. ';'
+      end
+      EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
+      -- eseguo
+      if not EgtApplyMachining( true, false) then
+         local _, sErr = EgtGetLastMachMgrError()
+         EgtSetOperationMode( nMchId, false)
+         return false, sErr
       end
-   end
-   -- assegno parametri a note utente
-   local sUserNotes = 'Par=' .. EgtNumToString( dCntPar, 0) .. ';'
-   if Proc.Double and Proc.Double > 0 then
-      sUserNotes = sUserNotes .. 'Dbl=' .. EgtNumToString( Proc.Double, 0) .. ';' ..
-                                 'Dlt=' .. EgtNumToString( abs( Proc.Delta) + dExtraDelta, 0) .. ';'
-   end
-   EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
-   -- eseguo
-   if not EgtApplyMachining( true, false) then
-      local _, sErr = EgtGetLastMachMgrError()
-      EgtSetOperationMode( nMchId, false)
-      return false, sErr
    end
    return true
 end
@@ -2558,7 +2603,7 @@ end
 
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
-function WPF.Make( Proc, nRawId, b3Raw)
+function WPF.Make( Proc, nRawId, b3Raw, vNLO)
    -- recupero la tipologia (contorno o tasca)
    local bPocket = ( EgtGetInfo( Proc.Id, 'PCKT', 'i') == 1)
    -- se svuotatura
@@ -2578,10 +2623,7 @@ function WPF.Make( Proc, nRawId, b3Raw)
          return MakeByMark( Proc, nRawId, b3Raw)
       -- se chiodatura
       elseif nCntType == 20 then
-         return MakeByNail( Proc, nRawId, b3Raw)
-      -- area vietata
-      elseif nCntType == 200 then
-         return true, 'Lock-out area Ignored'
+         return MakeByNail( Proc, nRawId, b3Raw, vNLO)
       -- altrimenti, taglio con lama e pulizia angoli con fresa
       else
          return MakeByCut( Proc, nRawId, b3Raw)

LuaLibs/WProcessLapJoint.lua

@@ -1,4 +1,4 @@
--- WProcessLapJoint.lua by Egaltech s.r.l. 2023/09/21
+-- WProcessLapJoint.lua by Egaltech s.r.l. 2023/10/02
 -- Gestione calcolo mezzo-legno per Pareti
 -- 2021/08/27 DS Se tre o più facce con flag PCKT=1 forzo svuotatura con fresa (per Variant).
 -- 2021/08/29 DS Se svuotatura di fianco setto flag per farla dopo i tagli.
@@ -29,6 +29,7 @@
 -- 2023/09/19 Controllo lavorabilità con una sola faccia ora ha limiti come FreeContour.
 -- 2023/09/21 Modifica controllo lavorabilità con tre facce tipo tunnel ma non ortogonali tra loro.
 -- 2023/09/21 In MakeByMill modificato SCC per correggere caso con lama su testa fresa.
+-- 2023/10/02 Aggiunta segnalazione lavorazione tipo Side non trovata.
 
 -- Tabella per definizione modulo
 local WPL = {}
@@ -1345,7 +1346,11 @@ local function MakeByMill( Proc, nFacet, nOthFac, nRawId, b3Raw, dSideDist)
    local _, vtRef = EgtSurfTmFacetCenter( Proc.Id, nOthFac, GDB_ID.ROOT)
    -- recupero la lavorazione
    local sMilling = WM.FindMilling( 'Side')
-   if not sMilling then return false end
+   if not sMilling then
+      local sErr = 'Error : Side not found in library'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
    -- recupero i dati dell'utensile
    local dMillDiam = 20
    local dMillLen = 10

LuaLibs/WallExec.lua

@@ -1,9 +1,10 @@
--- WallExec.lua by Egaltech s.r.l. 2023/07/04
+-- WallExec.lua by Egaltech s.r.l. 2023/10/16
 -- Libreria esecuzione lavorazioni per Pareti
 -- 2023/05/25 Aggiunto ordinamento in base a priorità da btl.
 -- 2023/06/07 Nel caso di outline con priorità aggiunta la rimozione degli sfridi nella lavorazione successiva.
 -- 2023/06/27 Aggiunte origini TN e BN.
 -- 2023/07/04 Se c'è funzione di macchina WD.GetOrigCorner si lascia scegliere posizione default a questa impostando 0 se non c'è 'REFPOS'.
+-- 2023/10/16 Aggiunta gestione Aree vietate (LockOut) per chiodature.
 
 -- Tabella per definizione modulo
 local WallExec = {}
@@ -216,6 +217,16 @@ function WallExec.CollectFeatures( PartId, b3Raw)
                         Proc2.TaskId = Proc.TaskId
                         table.insert( vProc, Proc2)
                      end
+                  -- se free contour
+                  elseif FreeContour.Identify( Proc) then
+                     -- recupero il tipo e il dato della lavorazione
+                     local nCntType = EgtGetInfo( Proc.Id, 'CNT_TYPE', 'i') or 0
+                     local nCntData = EgtGetInfo( Proc.Id, 'CNT_DATA', 'i') or 0
+                     -- imposto se area vietata
+                     if nCntType == 200 then
+                        Proc.LockOut = EgtIf( ( nCntData == 0 or ( nCntData & 1) ~= 0), 1, -1)
+                     end
+                     if Proc.LockOut then Proc.Flg = 0 end
                   end
                else
                   EgtOutLog( ' Feature ' .. tostring( Proc.Id) .. ' is empty (no geometry)')
@@ -285,15 +296,15 @@ local function PrintFeatures( vProc)
    EgtOutLog( ' *** Feature List ***')
    for i = 1, #vProc do
       local Proc = vProc[i]
-      local sOut = string.format( 'Part=%3d Proc=%3d Grp=%1d Prc=%3d TC=%2d/%d Flg=%2d Fcse=%1d,%1d Diam=%.2f Fct=%2d Dbl=%2d Dlt=%.1f Box=%s',
+      local sOut = string.format( 'Part=%3d Proc=%3d Grp=%1d Prc=%3d TC=%2d/%d Flg=%2d Lo=%d Fcse=%1d,%1d Diam=%.2f Fct=%2d Dbl=%2d Dlt=%.1f Box=%s',
                                   Proc.PartId, Proc.Id, Proc.Grp, Proc.Prc, Proc.TaskId, Proc.CutId,
-                                  Proc.Flg, Proc.Fcs, Proc.Fce, Proc.Diam, Proc.Fct, Proc.Double or 0, Proc.Delta or 0, tostring( Proc.Box))
+                                  Proc.Flg, EgtIf( Proc.LockOut, 1, 0), Proc.Fcs, Proc.Fce, Proc.Diam, Proc.Fct, Proc.Double or 0, Proc.Delta or 0, tostring( Proc.Box))
       EgtOutLog( sOut)
    end
 end
 
 -------------------------------------------------------------------------------------------------------------
-local function AddFeatureMachining( Proc, nRawId, b3Raw)
+local function AddFeatureMachining( Proc, nRawId, b3Raw, vNLO)
    local bOk = true
    local sErr = ''
    EgtOutLog( ' * Process ' .. tostring( Proc.Id) .. ' *', 1)
@@ -335,8 +346,8 @@ local function AddFeatureMachining( Proc, nRawId, b3Raw)
       bOk, sErr = Text.Make( Proc, nRawId, b3Raw)
    -- se contorno libero, outline o apertura ( 0/3/4-250/251/252-X)
    elseif FreeContour.Identify( Proc) then
-      -- esecuzione contorno
-      bOk, sErr = FreeContour.Make( Proc, nRawId, b3Raw)
+      -- esecuzione contorno libero
+      bOk, sErr = FreeContour.Make( Proc, nRawId, b3Raw, vNLO)
    -- se feature custom (Variant)
    elseif Variant.Identify( Proc) then
       -- esecuzione
@@ -641,9 +652,11 @@ function WallExec.ProcessFeatures()
    end
    -- classifico le feature
    ClassifyFeatures( vProc, b3Raw)
-   -- Eventuale determinazione delle feature lavorabili in parallelo (implementata nella configurazione macchina)
+   -- recupero l'elenco delle aree vietate alle chiodature
+   local vNLO = WL.GetNailLockOutAreas( vProc)
+   -- Se non ci sono aree vietate alle chiodature, eventuale determinazione delle feature lavorabili in parallelo (implementata nella configurazione macchina)
    -- si impostano i flag Double (nil/0=no, 1=su X, 2=su Y) e Delta (offset tra T14 e T12 positivo o negativo)
-   if WD.FindFeaturesInDouble then
+   if #vNLO == 0 and WD.FindFeaturesInDouble then
       WD.FindFeaturesInDouble( vProc, b3Raw)
    end
    -- debug
@@ -656,7 +669,7 @@ function WallExec.ProcessFeatures()
       -- creo la lavorazione
       local Proc = vProc[i]
       if Proc.Flg ~= 0 then
-         local bOk, sMsg = AddFeatureMachining( Proc, nRawId, b3Raw)
+         local bOk, sMsg = AddFeatureMachining( Proc, nRawId, b3Raw, vNLO)
          if not bOk then
             nTotErr = nTotErr + 1
             table.insert( Stats, {Err=1, Msg=sMsg, Rot=0, CutId=Proc.CutId, TaskId=Proc.TaskId})
@@ -665,7 +678,7 @@ function WallExec.ProcessFeatures()
          else
             table.insert( Stats, {Err=0, Msg='', Rot=0, CutId=Proc.CutId, TaskId=Proc.TaskId})
          end
-      elseif not Proc.Double then 
+      elseif not Proc.Double and not Proc.LockOut then 
          local sMsg = 'Feature not machinable by orientation'
          table.insert( Stats, {Err=1, Msg=sMsg, Rot=0, CutId=Proc.CutId, TaskId=Proc.TaskId})
       end

LuaLibs/WallLib.lua

@@ -1,4 +1,4 @@
--- WallLib.lua by Egaltech s.r.l. 2022/04/04
+-- WallLib.lua by Egaltech s.r.l. 2023/10/16
 -- Libreria globale per Pareti
 
 -- Tabella per definizione modulo
@@ -316,5 +316,24 @@ function WallLib.GetNearestOrthoOpposite( vtRef, vtNorm)
    return nil
 end
 
+-------------------------------------------------------------------------------------------------------------
+function WallLib.GetNailLockOutAreas( vProc)
+   local vNLO = {}
+   for i = 1, #vProc do
+      if vProc[i].LockOut == 1 then
+         local AuxId = EgtGetInfo( vProc[i].Id, 'AUXID', 'i')
+         if AuxId then AuxId = AuxId + vProc[i].Id end
+         if AuxId then
+            local nAddGrpId = WallLib.GetAddGroup( vProc[i].PartId)
+            local nSfrId = EgtSurfFlatRegion( nAddGrpId, {AuxId}) 
+            if nSfrId then
+               table.insert( vNLO, nSfrId)
+            end
+         end
+      end
+   end
+   return vNLO
+end
+
 -------------------------------------------------------------------------------------------------------------
 return WallLib

UpdateLog.txt

@@ -1,5 +1,13 @@
            ==== Wall Update Log ====
 
+Versione 2.5j3 (23/10/2023)
+- Added : aggiunta gestione aree vietate per chiodature (LockOut for Nail)
+- Modif : in FreeContour conversione automatica di facce non fattibili con lama per limiti di orientamento in facce da fare con fresa.
+- Modif : in LapJoint aggiunta segnalazione lavorazione tipo Side non trovata.
+- Modif : migliorata funzione Is3EdgesApprox in WallLib
+- Modif : nella ricerca lavorazione da usare controllo di utensile attivo sostituito con controllo utensile presente nel setup corrente
+- Fixed : in FreeContour correzione a MakeCustomPath per calcolare correttamente puliture spigoli di tipo 2 (Clean 30) e 3 (Gola di Scarico)
+
 Versione 2.5i3 (21/09/2023)
 - Modif : per pulizia corner di FreeContour disabilitato metodo con tunnel ed esteso metodo con tre punti
 - Modif : in LapJoint aggiornata pulizia corner come FreeContour

Version.lua

@@ -1,6 +1,6 @@
--- Version.lua by Egalware s.r.l. 2023/09/18
+-- Version.lua by Egalware s.r.l. 2023/10/11
 -- Gestione della versione di Wall
 
 NAME = 'Wall'
-VERSION = '2.5i3'
+VERSION = '2.5j3'
 MIN_EXE = '2.5b3'