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).

Compile.bat

@@ -1,5 +1,5 @@
 
-REM Compilazione degli script Wall Egaltech                         2023.02.27
+REM Compilazione degli script Wall Egaltech                         2023.09.26
 REM Per togliere info di debug aggiungere flag -s prima del nome del file di input
 
 REM Compilazione 32 e 64 bit
@@ -11,6 +11,7 @@ REM Compilazione 32 e 64 bit
 \EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessDoubleCut.lua             LuaLibs\WProcessDoubleCut.lua
 \EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessDrill.lua                 LuaLibs\WProcessDrill.lua
 \EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessDtMortise.lua             LuaLibs\WProcessDtMortise.lua
+REM \EgtProg\Dll32\luac54 -o bin\LuaLibs\WFeatureTopology.lua             LuaLibs\WFeatureTopology.lua
 \EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessFreeContour.lua           LuaLibs\WProcessFreeContour.lua
 \EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessLapJoint.lua              LuaLibs\WProcessLapJoint.lua
 \EgtProg\Dll32\luac54 -o bin\LuaLibs\WProcessMark.lua                  LuaLibs\WProcessMark.lua

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/12
+-- 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.
@@ -22,6 +22,9 @@
 -- 2023/06/06 Aggiunta gestione lavorazione per lamatura speciale affondata con Tool_ID specifico.
 -- 2023/07/26 In MakeByCut migliorata la scelta della fresa secondaria nel caso non sia disponibile una fresa di lunghezza sufficiente.
 -- 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 = {}
@@ -61,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
@@ -627,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
@@ -688,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)
@@ -716,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)
@@ -1091,7 +1097,8 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
    local nFacCnt = EgtSurfTmFacetCount( nNewProc)
    local nFacInd, dDepth, nSurfInt
    local bMakeLocSurf
-   if nFacCnt <= 4 then
+   -- RIMUOVERE
+   if false and nFacCnt <= 4 then
       -- recupero profondità e faccia di fondo
       _, _, dDepth, _, _, nSurfInt = GetTunnelDimension( nNewProc, Proc.PartId, nAddGrpId, bClosed)
       if nSurfInt then
@@ -1105,6 +1112,7 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
       else
          return true
       end
+      -- FINE PARTE DA RIMUOVERE
    else
       bMakeLocSurf = true
    end
@@ -1122,27 +1130,27 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
    while i <= #vFace do
       -- se tutta la faccia o la sua fine senza taglio, inserisco una fresatura
       if ( vFace[i].Type & 2) ~= 0  or  vFace[i].Type == 4 then
-         -- variabili costruzione geometria (nface1, nFace2, tFacAdj)
+         -- variabili costruzione geometria (nFace1, nFace2, tFacAdj)
          local nFace1 = vFace[i].Fac
+         -- aggiungo geometria
+         local j = EgtIf( i < #vFace, i + 1, EgtIf( bClosed, 1, nil))
+         if not j then return true end
+         local nFace2 = vFace[j].Fac
          -- ricavo i tre punti per eventuale superficie locale
          local ptLoc1, ptLoc2, ptLoc3
-         -- punto precedente (punto precedente della faccia [i])
-         ptLoc3 = vFace[i].PPrev
-         -- aggiungo geometria
-         i = i + 1
-         local j = EgtIf( i <= #vFace, i, EgtIf( bClosed, 1, nil))
-         if not j then
-            return true
-         end
-         local nFace2 = vFace[j].Fac
          -- punto in comune tra le due facce (punto precedente della faccia [j])
          ptLoc1 = vFace[j].PPrev
+         -- punto precedente (punto precedente della faccia [i])
+         if vFace[i].PPrev then
+            ptLoc3 = vFace[i].PPrev
+         else
+            ptLoc3 = Point3d( vFace[i].Cen:getX(), vFace[i].Cen:getY(), ptLoc1:getZ())
+         end
          -- punto successivo ( precedente della faccia successiva)
-         j = j + 1
-         local k = EgtIf( j <= #vFace, j, EgtIf( bClosed, 1, nil))
+         local k = EgtIf( j < #vFace, j + 1, EgtIf( bClosed, 1, nil))
          -- se è un percorso aperto prendo il punto medio della seconda faccia come punto locale 2
          if not k then
-            ptLoc2 = Point3d( vFace[j-1].Cen:getX(), vFace[j-1].Cen:getY(), ptLoc1:getZ())
+            ptLoc2 = Point3d( vFace[j].Cen:getX(), vFace[j].Cen:getY(), ptLoc1:getZ())
          else
             ptLoc2 = vFace[k].PPrev
          end
@@ -1180,9 +1188,9 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
                if not bOk then return bOk, sErr end
             end
          end
-      else
-         i = i + 1
       end
+      -- passo alla successiva
+      i = i + 1
    end
    -- cancello la copia della superfice
    if nNewProc then
@@ -1207,26 +1215,28 @@ end
 ---------------------------------------------------------------------
 -- Funzione per determinare se la faccia ha lati molto corti (trascurabili) ed è quindi approssimabile ad una 3 facce
 local function Is3EdgesApprox( Proc, nFacet, nAddGrpId)
-   local bResult = false
-   local nContourId = EgtExtractSurfTmFacetLoops( Proc.Id, nFacet, nAddGrpId)
+   nAddGrpId = nAddGrpId or WL.GetAddGroup( Proc.PartId)
+   -- recupero il contorno della faccia
+   local nContourId, nContourCnt = EgtExtractSurfTmFacetLoops( Proc.Id, nFacet, nAddGrpId)
+   if not nContourId then return false end
    EgtMergeCurvesInCurveCompo( nContourId)
-   -- recupero il numero effettivo di lati
+   -- recupero il numero di lati del contorno
    local _, nEntityCount = EgtCurveDomain( nContourId)
+   if not nEntityCount then return false end
+   -- se sono già tre, ho finito
+   if nEntityCount == 3 then return true end
+   -- rimuovo i lati molto corti dal conteggio totale
    local nEdges = nEntityCount
-   if nContourId then
-      if nEntityCount and nEntityCount  == 3 then
-         bResult = true
-      -- rimuovo i lati molto corti dal conteggio totale
-      elseif nEntityCount then
-         for i = 1, nEntityCount do
-            local dLength = EgtCurveCompoLength( nContourId, i - 1)
-            if dLength < 15 then nEdges = nEdges - 1 end
-         end
-      end
-      if nEdges == 3 then bResult = true end
+   for i = 1, nEntityCount do
+      local dLength = EgtCurveCompoLength( nContourId, i - 1)
+      if dLength < 15 then nEdges = nEdges - 1 end
    end
-   if bResult == true then
-      EgtOutLog( 'FreeContour : Face with ' .. tointeger( nEntityCount) .. ' edges skipped (approx 3 edges)')
+   -- verifico il numero significativo di lati
+   local bResult = ( nEdges == 3)
+   -- cancello tutti i contorni appena creati
+   EgtErase( EgtTableFill( nContourId, nContourCnt))
+   if bResult then
+      EgtOutLog( 'FreeContour : Face with ' .. tostring( nEntityCount) .. ' edges skipped (approx 3 edges)')
    end
    return bResult
 end
@@ -1251,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
@@ -1857,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))
@@ -1866,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)
@@ -2188,7 +2207,7 @@ local function MakeByMill( Proc, nRawId, b3Raw)
    -- posizione braccio porta testa
    local nSCC = MCH_SCC.ADIR_ZP
    if AreSameOrOppositeVectorApprox( vtExtr, Z_AX()) then
-      nSCC = EgtIf( Proc.Box:getDimX() >= Proc.Box:getDimY(), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_XP)
+      nSCC = EgtIf( Proc.Box:getDimX() >= Proc.Box:getDimY(), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_XM)
    end
    EgtSetMachiningParam( MCH_MP.SCC, nSCC)
    -- eseguo
@@ -2289,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)
@@ -2316,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
@@ -2323,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
@@ -2552,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
@@ -2572,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/19
+-- 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.
@@ -27,6 +27,9 @@
 -- 2023/08/01 Migliorato controllo testa sotto al grezzo in SieGroove.
 -- 2023/08/07 Controllo testa sotto al grezzo in SideGroove escluso se richiesto il move after.
 -- 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 = {}
@@ -192,8 +195,8 @@ function WPL.Classify( Proc, b3Raw)
          else
             return false
          end
-      -- se altrimenti tunnel
-      elseif nFacInd == -1 then
+      -- se altrimenti tunnel o assimilabile
+      elseif nFacInd == -1 or nFacInd == -2 then
          -- dati delle prime tre facce
          local vtN = {}
          vtN[1] = EgtSurfTmFacetNormVersor( Proc.Id, 0, GDB_ID.ROOT)
@@ -808,7 +811,7 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
    -- se devo creare superfice locale
    if bMakeLocSurf then
       -- creo superfice locale o esco
-      local nSurfToAdd = MakeLocalSurf( tFacAdj[1][7], tFacAdj[1][8], tFacAdj[1][9], nAddGrpId)
+      local nSurfToAdd = MakeLocalSurf( tFacAdj[7], tFacAdj[8], tFacAdj[9], nAddGrpId)
       if nSurfToAdd then
          local nFacCntPre = EgtSurfTmFacetCount( nNewProc)
          -- creo copia del percorso principale e gli aggiungo la nuova faccia
@@ -829,11 +832,11 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
    end
    -- prendo il primo versore
    local _, vtN1 = EgtSurfTmFacetCenter( nNewProcLoc, nFacInd, GDB_ID.ROOT)
-   local _, vtN2 = EgtSurfTmFacetCenter( nNewProcLoc, tFacAdj[1][1], GDB_ID.ROOT)
-   local _, vtN3 = EgtSurfTmFacetCenter( nNewProcLoc, tFacAdj[1][2], GDB_ID.ROOT)
+   local _, vtN2 = EgtSurfTmFacetCenter( nNewProcLoc, tFacAdj[1], GDB_ID.ROOT)
+   local _, vtN3 = EgtSurfTmFacetCenter( nNewProcLoc, tFacAdj[2], GDB_ID.ROOT)
    -- trovo il punto sulla superfice di riferimento
-   local _, ptLocP1, ptLocP2, _ = EgtSurfTmFacetsContact( nNewProcLoc, nFacInd, tFacAdj[1][1], GDB_ID.ROOT)
-   local _, ptLocP3, ptLocP4, _ = EgtSurfTmFacetsContact( nNewProcLoc, nFacInd, tFacAdj[1][2], GDB_ID.ROOT)
+   local _, ptLocP1, ptLocP2, _ = EgtSurfTmFacetsContact( nNewProcLoc, nFacInd, tFacAdj[1], GDB_ID.ROOT)
+   local _, ptLocP3, ptLocP4, _ = EgtSurfTmFacetsContact( nNewProcLoc, nFacInd, tFacAdj[2], GDB_ID.ROOT)
    -- se ho creato faccia locale su copia superficie, cancella la copia
    if bMakeLocSurf then
       EgtErase( nNewProcLoc)
@@ -841,16 +844,16 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
    local nIdIniPoint
    local nIdEndPoint
    if ptLocP1 and ptLocP2 then
-      if ( dist( ptLocP1, tFacAdj[1][4]) < GEO.EPS_SMALL) or ( dist( ptLocP2, tFacAdj[1][4]) < GEO.EPS_SMALL) then
+      if ( dist( ptLocP1, tFacAdj[4]) < GEO.EPS_SMALL) or ( dist( ptLocP2, tFacAdj[4]) < GEO.EPS_SMALL) then
          nIdEndPoint = 4
          nIdIniPoint = 5
-      elseif ( dist( ptLocP1, tFacAdj[1][5]) < GEO.EPS_SMALL) or ( dist( ptLocP2, tFacAdj[1][5]) < GEO.EPS_SMALL) then
+      elseif ( dist( ptLocP1, tFacAdj[5]) < GEO.EPS_SMALL) or ( dist( ptLocP2, tFacAdj[5]) < GEO.EPS_SMALL) then
          nIdEndPoint = 5
          nIdIniPoint = 4
       end
    end
    -- versore direzione
-   local vtExtr = tFacAdj[1][nIdIniPoint] - tFacAdj[1][nIdEndPoint]
+   local vtExtr = tFacAdj[nIdIniPoint] - tFacAdj[nIdEndPoint]
    vtExtr:normalize()
    -- versore direzione di uscita
    local vtExtrExit
@@ -879,44 +882,44 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
          vtCheck:rotate( Z_AX(), dOffsAng)
       end
       -- controllo se c'è collisione con le facce della superfice
-      if nTypeConeCut == 1 and CalcInterference( nNewProc, vtCheck, tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), dDiam1, dDiam2, 
+      if nTypeConeCut == 1 and CalcInterference( nNewProc, vtCheck, tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), dDiam1, dDiam2, 
                                                  dTall1, dTall2, dDiam3, dTall3) then
          local sErr = 'Collision detect from clean corner tool and surface'
          EgtOutLog( sErr)
          return true, ''
       end
-      nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdIniPoint], tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
+      nAuxId = EgtLine( nAddGrpId, tFacAdj[nIdIniPoint], tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
       table.insert( pAuxId, nAuxId)
       -- se uso utensile cono 60°
       if nTypeConeCut == 1 then
          -- se offset angolare valido e/o negativo creo il baffo precedente
          if dOffsAng < ( 100 * GEO.EPS_SMALL) then
             -- se il punto finale corrisponde con il punto utilizzato in precedenza, uso l'altro
-            if dist( tFacAdj[1][nIdEndPoint], ptLocP1) < 10 * GEO.EPS_SMALL then
+            if dist( tFacAdj[nIdEndPoint], ptLocP1) < 10 * GEO.EPS_SMALL then
                ptApPoint = ptLocP2
             else
                ptApPoint = ptLocP1
             end
-            nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
-            local dLenTrimExt = dist( tFacAdj[1][nIdEndPoint], ptApPoint) - (( dToolDiam/2) + 0.2)
+            nAuxId = EgtLine( nAddGrpId, tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
+            local dLenTrimExt = dist( tFacAdj[nIdEndPoint], ptApPoint) - (( dToolDiam/2) + 0.2)
             -- se la distanza dei due punti della linea è maggiore dal raggio fresa + delta, trimmo al raggio fresa + delta
             if dLenTrimExt > 10 * GEO.EPS_SMALL then
                EgtTrimExtendCurveByLen( nAuxId , -dLenTrimExt, ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
                -- se ho l'offset angolare ruoto la linea per compensare la rotazione che verrà applicata
                if abs(dOffsAng) > 100 * GEO.EPS_SMALL then
-                  EgtRotate( nAuxId, tFacAdj[1][nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
+                  EgtRotate( nAuxId, tFacAdj[nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
                end
                -- prendo il nuovo punto finale
                ptApPoint = EgtEP( nAuxId, GDB_RT.GLOB) + Point3d( 0, 0, dDepthMach)
             else
                -- se ho l'offset angolare ruoto la linea per compensare la rotazione che verrà applicata
                if abs(dOffsAng) > 100 * GEO.EPS_SMALL then
-                  EgtRotate( nAuxId, tFacAdj[1][nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
+                  EgtRotate( nAuxId, tFacAdj[nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
                end
             end
             table.insert( pAuxId, nAuxId)
             -- creo linea di ritorno
-            nAuxId = EgtLine( nAddGrpId, ptApPoint + Point3d( 0, 0, -dDepthMach), tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
+            nAuxId = EgtLine( nAddGrpId, ptApPoint + Point3d( 0, 0, -dDepthMach), tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
             table.insert( pAuxId, nAuxId)
          end
       end
@@ -926,7 +929,7 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
    ptLocP1, ptLocP2 = ptLocP3, ptLocP4
    if ptLocP1 and ptLocP2 then
       -- se il punto finale corrisponde con il punto utilizzato in precedenza, uso l'altro
-      if dist( tFacAdj[1][nIdEndPoint], ptLocP1) < 10 * GEO.EPS_SMALL then
+      if dist( tFacAdj[nIdEndPoint], ptLocP1) < 10 * GEO.EPS_SMALL then
          ptApPoint = ptLocP2
       else
          ptApPoint = ptLocP1
@@ -935,36 +938,36 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
       if nTypeConeCut == 1 then
          -- se offset angolare valido e/o negativo creo il baffo precedente
          if dOffsAng > -( 100 * GEO.EPS_SMALL) then
-            nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
-            local dLenTrimExt = dist( tFacAdj[1][nIdEndPoint], ptApPoint) - (( dToolDiam/2) + 0.2)
+            nAuxId = EgtLine( nAddGrpId, tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
+            local dLenTrimExt = dist( tFacAdj[nIdEndPoint], ptApPoint) - (( dToolDiam/2) + 0.2)
             -- se la distanza dei due punti della linea è maggiore dal raggio fresa + delta, trimmo al raggio fresa + delta
             if dLenTrimExt > 10 * GEO.EPS_SMALL then
                EgtTrimExtendCurveByLen( nAuxId , -dLenTrimExt, ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
                -- se ho l'offset angolare ruoto la linea per compensare la rotazione che verrà applicata
                if abs(dOffsAng) > 100 * GEO.EPS_SMALL then
-                  EgtRotate( nAuxId, tFacAdj[1][nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
+                  EgtRotate( nAuxId, tFacAdj[nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
                end
                -- prendo il nuovo punto finale
                ptApPoint = EgtEP( nAuxId, GDB_RT.GLOB) + Point3d( 0, 0, dDepthMach)
             else
                -- se ho l'offset angolare ruoto la linea per compensare la rotazione che verrà applicata
                if abs(dOffsAng) > 100 * GEO.EPS_SMALL then
-                  EgtRotate( nAuxId, tFacAdj[1][nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
+                  EgtRotate( nAuxId, tFacAdj[nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
                end
             end
             table.insert( pAuxId, nAuxId)
             -- creo linea di ritorno
-            nAuxId = EgtLine( nAddGrpId, ptApPoint + Point3d( 0, 0, -dDepthMach), tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
+            nAuxId = EgtLine( nAddGrpId, ptApPoint + Point3d( 0, 0, -dDepthMach), tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
             table.insert( pAuxId, nAuxId)
          end
          -- ultima linea di distacco (5mm in direzione utensile)
-         local pEnd =  tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach) + ( 5 * vtExtr)
-         nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), pEnd, GDB_RT.GLOB)
+         local pEnd =  tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach) + ( 5 * vtExtr)
+         nAuxId = EgtLine( nAddGrpId, tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), pEnd, GDB_RT.GLOB)
          table.insert( pAuxId, nAuxId)
       else
          -- linea di distacco (2mm in direzione utensile)
-         local pEnd =  tFacAdj[1][nIdEndPoint] + ( 2 * vtExtr)
-         nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdEndPoint], pEnd, GDB_RT.GLOB)
+         local pEnd =  tFacAdj[nIdEndPoint] + ( 2 * vtExtr)
+         nAuxId = EgtLine( nAddGrpId, tFacAdj[nIdEndPoint], pEnd, GDB_RT.GLOB)
          table.insert( pAuxId, nAuxId)
          -- ultima linea di risalita in Z
          local pIni = pEnd
@@ -987,7 +990,7 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
    EgtModifyCurveExtrusion( AuxId, vtExtr, GDB_RT.GLOB)
    -- se ho un offset angolare ruoto il percorso
    if abs(dOffsAng) > 100 * GEO.EPS_SMALL then
-      EgtRotate( AuxId, tFacAdj[1][nIdEndPoint], Z_AX(), dOffsAng, GDB_RT.GLOB)
+      EgtRotate( AuxId, tFacAdj[nIdEndPoint], Z_AX(), dOffsAng, GDB_RT.GLOB)
    end
    -- inserisco la lavorazione
    local sName = 'Clean_' .. ( EgtGetName( nNewProc) or tostring( nNewProc))
@@ -1094,7 +1097,8 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
    local nFacCnt = EgtSurfTmFacetCount( nNewProc)
    local nFacInd, dDimMin, dDimMax, dDepth, nSurfInt
    local bMakeLocSurf
-   if nFacCnt <= 4 then
+   -- RIMUOVERE
+   if false and nFacCnt <= 4 then
       -- ottengo le dimensioni apertura, la normale e la faccia inferiore
       dDimMin, dDimMax, dDepth, _, _, nSurfInt = GetTunnelDimension( nNewProc, Proc.PartId, nAddGrpId)
       if nSurfInt then
@@ -1111,6 +1115,7 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
          EgtOutLog( sErr)
          return false, sErr
       end
+      -- FINE PARTE DA RIMUOVERE
    else
       bMakeLocSurf = true
    end
@@ -1130,38 +1135,37 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
    while i <= #vFace do
       -- se tutta la faccia o la sua fine senza taglio, inserisco una fresatura
       if ( vFace[i].Type & 2) ~= 0  or  vFace[i].Type == 4 then
-         -- variabili costruzione geometria
-         local tFacAdj = {}
+         -- variabili costruzione geometria (nFace1, nFace2, tFacAdj)
          local nFace1 = vFace[i].Fac
-         local nFace2
          -- ricavo i tre punti per eventuale superficie locale
          local ptLoc1, ptLoc2, ptLoc3
-         -- punto precedente (punto precedente della faccia [i])
-         ptLoc3 = vFace[i].PPrev
          -- aggiungo geometria
-         i = i + 1
-         local j = EgtIf( i <= #vFace, i, EgtIf( bClosed, 1, nil))
-         if not j then
-            return true
-         end
-         nFace2 = vFace[j].Fac
+         local j = EgtIf( i < #vFace, i + 1, EgtIf( bClosed, 1, nil))
+         if not j then return true end
+         local nFace2 = vFace[j].Fac
          -- punto in comune tra le due facce (punto precedente della faccia [j])
          ptLoc1 = vFace[j].PPrev
+         -- punto precedente (punto precedente della faccia [i])
+         if vFace[i].PPrev then
+            ptLoc3 = vFace[i].PPrev
+         else
+            ptLoc3 = Point3d( vFace[i].Cen:getX(), vFace[i].Cen:getY(), ptLoc1:getZ())
+         end
          -- punto successivo ( precedente della faccia successiva)
-         j = j + 1
-         local k = EgtIf( j <= #vFace, j, EgtIf( bClosed, 1, nil))
+         local k = EgtIf( j < #vFace, j + 1, EgtIf( bClosed, 1, nil))
          -- se è un percorso aperto prendo il punto medio della seconda faccia come punto locale 2
          if not k then
-            ptLoc2 = Point3d( vFace[j-1].Cen:getX(), vFace[j-1].Cen:getY(), ptLoc1:getZ())
+            ptLoc2 = Point3d( vFace[j].Cen:getX(), vFace[j].Cen:getY(), ptLoc1:getZ())
          else
             ptLoc2 = vFace[k].PPrev
          end
          -- ricavo i punti e l'angolo interno
          local _, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( nNewProc, nFace1, nFace2, GDB_ID.ROOT)
          -- se punti validi e angolo è interno e non è quasi piatto e >= 90 creo istanza
+         local tFacAdj = {}
          if ptP1 and ptP2 and dAng < 0 and dAng < -6 and dAng > EgtIf( nTypeConeCut == 1, -(90 + 10 * GEO.EPS_SMALL), -(180-dAngleSmall + 10 * GEO.EPS_SMALL))  then
             local dLen = dist( ptP1, ptP2)
-            table.insert( tFacAdj, { nFace1, nFace2, dLen, ptP1, ptP2, dAng, ptLoc1, ptLoc2, ptLoc3})
+            tFacAdj = { nFace1, nFace2, dLen, ptP1, ptP2, dAng, ptLoc1, ptLoc2, ptLoc3}
          end
          -- se ho un elemento creo percorso o percorsi in base al tipo di cono e all'apertura dall'angolo rispetto ai 90°
          -- con una tolleranza di 2 gradi
@@ -1189,9 +1193,9 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
                if not bOk then return bOk, sErr end
             end
          end
-      else
-         i = i + 1
       end
+      -- passo alla successiva
+      i = i + 1
    end
    -- cancello la copia della superfice
    if nNewProc then
@@ -1342,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
@@ -1399,7 +1407,7 @@ local function MakeByMill( Proc, nFacet, nOthFac, nRawId, b3Raw, dSideDist)
    -- imposto posizione braccio porta testa
    local nSCC = MCH_SCC.ADIR_ZP
    if AreSameOrOppositeVectorApprox( vtN, Z_AX()) then
-      nSCC = EgtIf( Proc.Box:getDimX() >= Proc.Box:getDimY(), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_XP)
+      nSCC = EgtIf( Proc.Box:getDimX() >= Proc.Box:getDimY(), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_XM)
    end
    EgtSetMachiningParam( MCH_MP.SCC, nSCC)
    -- imposto modo di lavorare la faccia

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,18 @@
            ==== 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
+- Fixed : in FreeContour e Lapjoint, in MakeByMill, modificato SCC per correggere caso con lama su testa fresa.
+
 Versione 2.5i2 (20/09/2023)
 - Modif : in LapJoint con una sola faccia controllo lavorabilità ora come per FreeContour
 - Modif : in CleanCorner ora AuxDir (SCC) sempre Z+

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.5i2'
+VERSION = '2.5j3'
 MIN_EXE = '2.5b3'