BugFix/AvoidSawDamagingRemainingBarIfNotShort

Fix implementato per LongCut

LuaLibs/BeamLib.lua

@@ -1,4 +1,4 @@
--- BeamLib.lua by Egaltech s.r.l. 2022/06/25
+-- BeamLib.lua by Egaltech s.r.l. 2022/07/12
 -- Libreria globale per Travi
 -- 2020/07/28 Corretto calcolo attacchi e uscite di lame per non uscire dalla faccia sotto.
 -- 2020/08/18 Aggiunto a GetNearestParalOpposite e GetNearestOrthoOpposite parametro opzionale vtNorm.
@@ -13,6 +13,7 @@
 -- 2022/05/03 Ulteriore limitazione a GetNzLimDownUp per FAST.
 -- 2022/05/18 Correzioni e migliorie a PutStartNearestToEdge.
 -- 2022/06/25 Rese globali le funzioni GetChainSawBlockedAxis e GetChainSawInitAngs prima in ProcessLapJpoint.
+-- 2022/07/12 A GetFaceHvRefDim aggiunta possibilità di confronto e limitazione dimensioni con grezzo/pezzo (conta solo la sezione).
 
 -- Tabella per definizione modulo
 local BeamLib = {}
@@ -650,7 +651,7 @@ function BeamLib.GetFaceWithMostAdj( nSurfId, nPartId, bCompare3Fc, dCosSideAng)
 end
 
 ---------------------------------------------------------------------
-function BeamLib.GetFaceHvRefDim( nSurfId, nFacet)
+function BeamLib.GetFaceHvRefDim( nSurfId, nFacet, b3Raw)
    -- recupero centro e normale della faccia
    local ptC, vtN = EgtSurfTmFacetCenter( nSurfId, nFacet, GDB_ID.ROOT)
    if not ptC or not vtN then return end
@@ -661,8 +662,21 @@ function BeamLib.GetFaceHvRefDim( nSurfId, nFacet)
    end
    -- determino l'ingombro in questo riferimento
    local b3HV = EgtSurfTmGetFacetBBoxRef( nSurfId, nFacet, GDB_BB.STANDARD, frHV)
+   local dDimH = b3HV:getDimX()
+   local dDimV = b3HV:getDimY()
+   -- se definito grezzo (o solido), applico eventuali limiti
+   if b3Raw then
+      local dCoeffY = abs( frHV:getVersX():getY())
+      if dCoeffY > GEO.EPS_SMALL then
+         dDimH = min( dDimH, b3Raw:getDimY() / dCoeffY)
+      end
+      local dCoeffZ = abs( frHV:getVersY():getZ())
+      if dCoeffZ > GEO.EPS_SMALL then
+         dDimV = min( dDimV, b3Raw:getDimZ() / dCoeffZ)
+      end
+   end
    -- restituisco i valori calcolati
-   return frHV, b3HV:getDimX(), b3HV:getDimY()
+   return frHV, dDimH, dDimV
 end
 
 -------------------------------------------------------------------------------------------------------------
@@ -718,10 +732,15 @@ function BeamLib.GetNzLimDownUp( b3Raw, vtN, vtOrtho)
                if vtN and ( abs( vtN:getY()) < 0.174) then
                   return -0.5
                else
-                  return -0.240
+                  return -0.24
                end
             else
-               return -0.174
+               -- N_HorAng < 10°
+               if vtN and ( abs( vtN:getY()) < 0.174) then
+                  return -0.383
+               else
+                  return -0.174
+               end
             end
          end
       end

LuaLibs/FacesBySaw.lua

@@ -242,8 +242,8 @@ function FacesBySaw.MakeTwo( Proc, nPhase, nRawId, nPartId, dOvmHead, sCutType,
    local bConvex = ( dAngT > 0)
    -- verifico non siano orientate troppo verso il basso e molto sbandate (oltre 10 deg)
    local bFaceOk = {}
-   bFaceOk[1] = ( vtN[1]:getZ() >= BD.NZ_MINB or ( not bConvex and abs( vtN[1]:getY()) < 0.174))
-   bFaceOk[2] = ( vtN[2]:getZ() >= BD.NZ_MINB or ( not bConvex and abs( vtN[2]:getY()) < 0.174))
+   bFaceOk[1] = ( vtN[1]:getZ() >= BD.NZ_MINB or abs( vtN[1]:getY()) < 0.174)
+   bFaceOk[2] = ( vtN[2]:getZ() >= BD.NZ_MINB or abs( vtN[2]:getY()) < 0.174)
    if  not bDownHead  and  not bFaceOk[1]  and  not bFaceOk[2]  then
       local sErr = 'Error : TwoFacesBySaw from bottom impossible'
       EgtOutLog( sErr)

LuaLibs/ProcessCut.lua

@@ -44,19 +44,21 @@ function ProcessCut.Classify( Proc, b3Raw)
    -- recupero i dati del taglio
    local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
    if vtN:getZ() <= - 0.5 and abs( vtN:getY()) > 0.1 or ( vtN:getZ() <= - 0.174 and abs( vtN:getY()) > 0.866) then
-      local _, DimH, DimV = BL.GetFaceHvRefDim( Proc.Id, 0)
+      -- calcolo le massime estensioni lineari orizzontale e verticale della faccia
+      local _, DimH, DimV = BL.GetFaceHvRefDim( Proc.Id, 0, b3Raw)
+      -- confronto queste estensioni con la massima dimensione del DiceCut (impossibile lavorare se entrambe maggiori)
       if DimH > BD.MAX_DIM_DICE and DimV > BD.MAX_DIM_DICE then
          return true, true
       end
    end
-   -- verifico se c'è un taglio da sotto e se è nei limiti
+   -- se è un taglio da sotto, lo verifico
    local dNzLimDwnUp = BL.GetNzLimDownUp( b3Raw)
    local bDownCut = ( vtN:getZ() <= dNzLimDwnUp)
    if bDownCut then
+      -- calcolo l'ingombro orizzontale della faccia
       local _, DimH, DimV = BL.GetFaceHvRefDim( Proc.Id, 0)
-      -- confronto anche qua la distanza maggiore della faccia con la massima distanza del DiceCut
-      -- e se il rapporto supera il 2 (implica che genera 3 tagli) dichiaro impossibile la lavorazione
-      if DimH and BD.MAX_DIM_DICE and abs( BD.MAX_DIM_DICE) > 20 * GEO.EPS_SMALL and abs( DimH / BD.MAX_DIM_DICE) > 2 then
+      -- confronto questo ingombro con il doppio della massima dimensione del DiceCut (impossibile lavorare sotto da sopra se più di 2 tagli)
+      if DimH > 2 * BD.MAX_DIM_DICE then
          return true, true
       end
    end
@@ -309,8 +311,7 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
    end
    local dMaxVertDepth = dMaxDepth - ( BD.DECR_VERT_CUT or 0)
    -- determino la direzione di taglio preferenziale
-   local frFac, dCutH, dCutV = BL.GetFaceHvRefDim( Proc.Id, 0)
-   dCutH = min( dCutH, b3Raw:getDimY() / abs( frFac:getVersX():getY()))
+   local frFac, dCutH, dCutV = BL.GetFaceHvRefDim( Proc.Id, 0, b3Raw)
    local bHorizCut = ( dCutV < dMaxVertDepth - BD.CUT_EXTRA and not bDownCut)
    local bVertCutOk = ( dCutH < dMaxDepth - BD.CUT_EXTRA)
    -- recupero gruppo per geometria addizionale
@@ -474,7 +475,11 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
       elseif Proc.Head then
          vtOrthoO = EgtIf( vtN:getY() > -0.02, -Y_AX(), Y_AX())
       else
-         vtOrthoO = EgtIf( vtN:getY() > 0.02, Y_AX(), -Y_AX())
+         if vtN:getZ() < dVzLimDwnUp then
+            vtOrthoO = EgtIf( vtN:getY() > -0.02, -Y_AX(), Y_AX())
+         else
+            vtOrthoO = EgtIf( vtN:getY() > 0.02, Y_AX(), -Y_AX())
+         end
       end
       -- taglio
       local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, vtOrthoO, dVzLimDwnUp, dCutExtra, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
@@ -511,8 +516,7 @@ local function MakeFromDown( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead)
    end
    local dMaxVertDepth = dMaxDepth
    -- determino la direzione di taglio preferenziale
-   local frFac, dCutH, dCutV = BL.GetFaceHvRefDim( Proc.Id, 0)
-   dCutH = min( dCutH, b3Raw:getDimY() / abs( frFac:getVersX():getY()))
+   local frFac, dCutH, dCutV = BL.GetFaceHvRefDim( Proc.Id, 0, b3Raw)
    local bHorizCut = ( dCutV < dMaxVertDepth - BD.CUT_EXTRA) or Proc.AdvTail
    -- recupero gruppo per geometria addizionale
    local nAddGrpId = BL.GetAddGroup( nPartId)

LuaLibs/ProcessDoubleCut.lua

@@ -1,4 +1,4 @@
--- ProcessDoubleCut.lua by Egaltech s.r.l. 2021/11/25
+-- ProcessDoubleCut.lua by Egaltech s.r.l. 2022/07/11
 -- Gestione calcolo doppi tagli di lama per Travi
 
 -- Tabella per definizione modulo
@@ -28,54 +28,70 @@ end
 function ProcessDoubleCut.Classify( Proc, b3Raw)
    --se una faccia, uso la classificazione dei tagli singoli
    if Proc.Fct == 1 then return Cut.Classify( Proc, b3Raw) end
-   -- se PF con testa da sotto, ammessa qualunque orientazione
-   if BD.C_SIMM and BD.DOWN_HEAD then
+   -- se PF con testa da sotto o TURN, ammessa qualunque orientazione
+   if ( BD.C_SIMM and BD.DOWN_HEAD) or BD.TURN then
       return true
    end
-   -- limite per facce da sotto
-   local dNzLimDwnUp = BL.GetNzLimDownUp( b3Raw)
-   -- verifico se convesso
+   -- determino se convesso o concavo
    local bAdj, _, _, dAng = EgtSurfTmFacetsContact( Proc.Id, 0, 1, GDB_ID.ROOT)
    local bConvex = ( not bAdj or ( dAng > 0))
+   -- se convesso
    if bConvex then
      -- recupero i dati di ogni singola faccia
       for i = 1, 2 do
          local nFac = i - 1
          local vtN = EgtSurfTmFacetNormVersor( Proc.Id, nFac, GDB_ID.ROOT)
          if ( vtN:getZ() <= - 0.5 and abs( vtN:getY()) > 0.1) or ( vtN:getZ() <= - 0.174 and abs( vtN:getY()) > 0.866) then
-            local _, DimH, DimV = BL.GetFaceHvRefDim( Proc.Id, nFac)
-            if DimH > BD.MAX_DIM_DICE then
+            -- calcolo la massima estensione orizzontale lineare della faccia
+            local _, DimH, DimV = BL.GetFaceHvRefDim( Proc.Id, nFac, b3Raw)
+            -- confronto questa estensione con la massima dimensione del DiceCut (impossibile lavorare se maggiore)
+            if DimH > BD.MAX_DIM_DICE and DimV > BD.MAX_DIM_DICE then
                return true, true
             end
          end
+         local dNzLimDwnUp = BL.GetNzLimDownUp( b3Raw, vtN)
          local bDownCut = ( vtN:getZ() <= dNzLimDwnUp)
          if bDownCut then
+            -- calcolo l'ingombro orizzontale della faccia
             local _, DimH, DimV = BL.GetFaceHvRefDim( Proc.Id, nFac)
-            -- confronto anche qua la distanza maggiore della faccia con la massima distanza del DiceCut
-            -- e se il rapporto supera il 2 (implica che genera 3 tagli) dichiaro impossibile la lavorazione
-            if DimH and BD.MAX_DIM_DICE and abs( BD.MAX_DIM_DICE) > 20 * GEO.EPS_SMALL and abs( DimH / BD.MAX_DIM_DICE) > 2 then
+            -- confronto questo ingombro con il doppio della massima dimensione del DiceCut (impossibile lavorare sotto da sopra se più di 2 tagli)
+            if DimH > 2 * BD.MAX_DIM_DICE then
                return true, true
             end
          end
       end
       return true, false
-   end
    -- altrimenti concavo, verifico le normali delle facce per tagli da sotto
-   for i = 1, 2 do
-      local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, i-1, GDB_ID.ROOT)
-      local bDownCut = ( vtN:getZ() <= dNzLimDwnUp)
-      if bDownCut then
-         -- dimensione della faccia perpendicolare alla linea di intersezione tra le facce
-         local vtN2 = EgtSurfTmFacetNormVersor( Proc.Id, 2-i, GDB_ID.ROOT)
-         local vtX = vtN2 ^ vtN
-         local frRef = Frame3d( ptC, ptC + 100 * vtX, ptC + 100 * vtN2)
-         local b3Ref = EgtSurfTmGetFacetBBoxRef( Proc.Id, i-1, GDB_BB.STANDARD, frRef)
-         if b3Ref:getDimY() > BD.MAX_DIM_DICE then
-            return true, true
+   else
+      local ptC = {}
+      local vtN = {}
+      ptC[1], vtN[1] = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
+      ptC[2], vtN[2] = EgtSurfTmFacetCenter( Proc.Id, 1, GDB_ID.ROOT)
+      local vtX = vtN[1] ^ vtN[2] ; vtX:normalize()
+      local vtY = { vtX ^ vtN[1], - vtX ^ vtN[2]}
+      for i = 1, 2 do
+         local dNzLimDwnUp = BL.GetNzLimDownUp( b3Raw, vtN[i], vtY[i])
+         local bDownCut = ( vtN[i]:getZ() <= dNzLimDwnUp)
+         if bDownCut then
+            -- dimensione della faccia perpendicolarmente alla linea di intersezione tra le facce
+            local frRef = Frame3d( ptC[i], ptC[i] + 100 * vtX, ptC[i] + 100 * vtY[i])
+            local b3Ref = EgtSurfTmGetFacetBBoxRef( Proc.Id, i-1, GDB_BB.STANDARD, frRef)
+            -- dimensione dell'altra faccia perpendicolarmente alla linea di intersezione tra le facce
+            local frRef2 = Frame3d( ptC[3-i], ptC[3-i] + 100 * vtX, ptC[3-i] + 100 * vtY[3-1])
+            local b3Ref2 = EgtSurfTmGetFacetBBoxRef( Proc.Id, 2-i, GDB_BB.STANDARD, frRef2)
+            -- se faccia grande
+            if b3Ref:getDimY() > BD.MAX_DIM_DICE then
+               -- se altra faccia piccola
+               if b3Ref2:getDimY() < BD.MAX_DIM_DICE then 
+                  return true, true
+               else
+                  return false
+               end
+            end
          end
       end
+      return true, false
    end
-   return true, false
 end
 
 ---------------------------------------------------------------------
@@ -256,6 +272,7 @@ function ProcessDoubleCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
    else
       -- eseguo
       local sCutType = EgtIf( bHead, 'HeadSide', 'TailSide')
+      local bDownHead = ( BD.DOWN_HEAD and vtNm:getZ() < BD.NZ_MINB)
       local bOk, sErr = Fbs.MakeTwo( Proc, nPhase, nRawId, nPartId, dOvmHead, sCutType, false, bDownHead)
       if not bOk then return bOk, sErr end
       -- segnalazione ingombro di testa o coda

LuaLibs/ProcessDrill.lua

@@ -10,6 +10,7 @@
 -- 2022/06/22 Nel riconoscimento fori di coda si utilizza ora il reale sovramateriale di coda (dOvmTail) invece di BD.OVM_MID.
 -- 2022/07/01 Aggiunta gestione allungamento percorsi fori in caso di materiale già rimosso da lavorazioni precedenti
 -- 2022/07/07 Aggiunta la gestione delle forature migliorate in presenza di feature testa/coda che tagliano tutta la sezione; gli Id delle feature sono nelle proprietà MachineAfterHeadCutId e MachineAfterTailCutId.
+-- 2022/07/12 Aggiunto un valore minimo (10) per la distanza di sicurezza.
 
 -- Tabella per definizione modulo
 local ProcessDrill = {}
@@ -412,9 +413,9 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
             if dMaxDepth == 0 then
                dMaxDepth = dMaxDepthOri
             end
-            if dHoleToCutDistance > 0 then
+            if dHoleToCutDistance > 10 * GEO.EPS_SMALL then
                dMaxElev = dLen - dHoleToCutDistance
-            elseif dHoleToCutDistance < 0 then
+            elseif dHoleToCutDistance < -10 * GEO.EPS_SMALL then
                dMaxElev = -dHoleToCutDistance
             end
             local dToolAddLength = dLen - dMaxElev
@@ -447,6 +448,11 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
       end
    end
    EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
+   -- imposto il valore della distanza di sicurezza per l'attacco. Se il valore del db utensili è troppo basso lo alzo a 10.
+   local dToolDbStartPos = EgtGetMachiningParam( MCH_MP.STARTPOS)
+   local dMinStartPos = 10
+   local dStartPos = max( dMinStartPos, dToolDbStartPos)
+   EgtSetMachiningParam( MCH_MP.STARTPOS, dStartPos)
    -- Note utente con dichiarazione nessuna generazione sfridi per Vmill
    local sUserNotes = 'VMRS=0;'
    -- aggiungo alle note massima elevazione (coincide con affondamento)

LuaLibs/ProcessLapJoint.lua

@@ -1,4 +1,4 @@
--- ProcessLapJoint.lua by Egaltech s.r.l. 2022/07/03
+-- ProcessLapJoint.lua by Egaltech s.r.l. 2022/07/05
 -- Gestione calcolo mezzo-legno per Travi
 -- 2019/10/08 Agg. gestione OpenPocket.
 -- 2021/01/24 Con sega a catena ora sempre impostato asse A.
@@ -47,6 +47,8 @@
 -- 2022/06/16 Implemento lavorazioni con fresatura di lato per L30 (al momento solo passanti) se parametro Q03=2. Modificate funzioni Make, MakeMoreFaces, Classify.
 -- 2022/06/21 Implemento di lavorazioni non passanti con fresatura di lato per L30 se parametro Q03=2. Modificate funzioni MakeMoreFaces, Classify.
 -- 2022/06/29 Migliorate lavorazioni con fresatura di lato per L30 se parametro Q03=2. Ora con 4 facce / 3 facce a L può entrare una fresa grande fino al doppio dell'altezza della tasca / doppio della dimensione minima.
+-- 2022/07/05 Modifiche per sega a catena di testa e relativa MaxElev.
+-- 2022/07/12 In MakeByChainOrSaw aggiunto check per feature L20 usata in modo improprio e, nel caso, si passa a una lavorazione tasca.
 
 -- Tabella per definizione modulo
 local ProcessLapJoint = {}
@@ -694,8 +696,8 @@ function ProcessLapJoint.Classify( Proc, b3Raw)
       local bDown = ( vtN[1]:getZ() < BD.NZ_MINB and vtN[2]:getZ() < BD.NZ_MINB) or
                     ( vtN[1]:getZ() < BD.NZ_MINA and vtN[2]:getZ() < 0.5 and ( vtN[2]:getZ() < -0.1 or not bSmall)) or
                     ( vtN[2]:getZ() < BD.NZ_MINA and vtN[1]:getZ() < 0.5 and ( vtN[1]:getZ() < -0.1 or not bSmall))
-      -- per L30, se forzata la lavorazione con fresa di lato da parametro Q03=2 non devo ruotare
-      local bForceSideMill = ( Proc.Prc == 30 and EgtGetInfo( Proc.Id, 'Q03', 'd') == 2)
+      -- per L30, se forzata la lavorazione con fresa di lato da parametro Q03=2 oppure Q03=3 non devo ruotare
+      local bForceSideMill = ( Proc.Prc == 30 and ( EgtGetInfo( Proc.Id, 'Q03', 'd') == 2 or EgtGetInfo( Proc.Id, 'Q03', 'd') == 3))
       bDown = ( bDown and not BD.DOWN_HEAD and not BD.TURN and not bForceSideMill)
       return true, bDown
    -- se più di 2 facce
@@ -795,8 +797,8 @@ function ProcessLapJoint.Classify( Proc, b3Raw)
             -- se verso il basso, verifico se utilizzabile seconda faccia
             if bDown then
                local bIsU = ( Proc.Fct == 3 and not TestElleShape3( Proc))
-               -- per lapjoint proc 30, se forzata la lavorazione con fresa di lato da parametro Q03=2 non devo ruotare
-               local bForceSideMill = ( Proc.Prc == 30 and EgtGetInfo( Proc.Id, 'Q03', 'd') == 2 and ( Proc.Fct == 3 or Proc.Fct == 4))
+               -- per lapjoint proc 30, se forzata la lavorazione con fresa di lato da parametro Q03=2 oppure Q03=3 non devo ruotare
+               local bForceSideMill = ( Proc.Prc == 30 and ( EgtGetInfo( Proc.Id, 'Q03', 'd') == 2 or EgtGetInfo( Proc.Id, 'Q03', 'd') == 3) and ( Proc.Fct == 3 or Proc.Fct == 4))
                if bForceSideMill then
                   bDown = false 
                elseif nFacInd2 and dElev2 < 2 * dElev then
@@ -2793,14 +2795,15 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
                                  rfFac, dH, dV, dElev, bForceUseBlade, 
                                  dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, 
                                  bOrthoFacesMaster, nBottomFace, nChamfer, nAddGrpId, b3Solid, 
-                                 dDepthCham, nSurfInt, bIs3Faces)
+                                 dDepthCham, nSurfInt)
    local sWarn
    -- ingombro del grezzo
    local b3Raw = EgtGetRawPartBBox( nRawId)
    -- ottengo la distanza tra la fine del pezzo e il pezzo successivo
    local dDistToNextPiece = EgtGetInfo( nRawId, 'BDST', 'd') or 5.4
-   -- verifico e fessura con 3 facce o tunnel
+   -- verifico se fessura con 3 facce o tunnel
    local bOrthoFaces
+   local bIs3Faces = ( Proc.Fct == 3)
    if bIs3Faces then
       -- recupero la faccia con il maggior numero di adiacenze e l'elevazione relativa
       local nFacInd1, dFacElev1, nFacInd2, dFacElev2 = BL.GetFaceWithMostAdj( Proc.Id, nPartId, bIs3Faces)
@@ -2844,12 +2847,15 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
    local dMaxLen = 0
    for i = 1, #vAdj do
       if vAdj[i] >= 0 then
-         local _, ptP1, ptP2, _ = EgtSurfTmFacetsContact( Proc.Id, nFacInd, vAdj[i], GDB_ID.ROOT)
-         local dLen = dist( ptP1, ptP2)
-         if dLen > dMaxLen then
-            nFacAdj = vAdj[i]
-            dMaxLen = dLen
-            EgtOutLog( string.format( 'Adjac=%d Len=%.3f H=%.3f V=%.3f', vAdj[i], dLen, dH, dV), 3)
+         local vtAdjN = EgtSurfTmFacetNormVersor( Proc.Id, vAdj[i], GDB_ID.ROOT)
+         if not bIs3Faces or abs( rfFac:getVersZ():getY()) < 0.174 or abs( rfFac:getVersZ():getY()) > 0.984 or vtAdjN:getY() * rfFac:getVersZ():getY() > 0.1 then
+            local _, ptP1, ptP2 = EgtSurfTmFacetsContact( Proc.Id, nFacInd, vAdj[i], GDB_ID.ROOT)
+            local dLen = dist( ptP1, ptP2)
+            if dLen > dMaxLen then
+               nFacAdj = vAdj[i]
+               dMaxLen = dLen
+               EgtOutLog( string.format( 'Adjac=%d Len=%.3f H=%.3f V=%.3f', vAdj[i], dLen, dH, dV), 3)
+            end
          end
       end
    end
@@ -2896,6 +2902,11 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
          end
       end
    end
+   -- escludo caso per L20 che porterebbe ad una lavorazione con lama non corretta; ritorno anche 'MNF' in modo da forzare una lavorazione tasca
+   if Proc.Prc == 20 and Proc.Fct >= 4 and bOpenStart and bOpenEnd and #vAdj >= 3 then
+      local sErr = 'Error: improper use of L020 feature'
+      return false, sErr, 'MNF'
+   end
    -- verifico se uso lama da sotto
    local bCutDown = ( BD.DOWN_HEAD and rfFac:getVersZ():getZ() < - 0.5)
    -- Recupero il massimo affondamento possibile con la lama
@@ -2983,7 +2994,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
       -- se la lunghezza utensile non riesce ad arrivare sul fondo assegno la possibilità di lavorare di fianco (se possibile)
       if dElev > dMaxDepth + 10 * GEO.EPS_SMALL then
          -- continuo di testa se fessura con tre facce o non è tunnel
-         bGoFromHead = ( bIs3Faces or not bOrthoFaces)
+         bGoFromHead = (( bIs3Faces and dMaxElev) or not bOrthoFaces)
       end
       -- se continuo a lavorare di testa
       if bGoFromHead then
@@ -3039,14 +3050,14 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
             -- imposto offset radiale
             local dOffs = ( i - 1) * dStep
             EgtSetMachiningParam( MCH_MP.OFFSR, dOffs)
-            -- se necessario, limito l'affondamento
+            -- se necessario, avverto limitazioneo dell'affondamento
             if dElev > dMaxDepth + 10 * GEO.EPS_SMALL then
                sWarn = 'Warning in LapJoint : elevation (' .. EgtNumToString( dElev, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
-               dDepth = dMaxDepth - dElev
                EgtOutLog( sWarn)
-               EgtSetMachiningParam( MCH_MP.DEPTH_STR, 'TH '..EgtNumToString( dDepth, 1))
+               --local dDepth = dMaxDepth - dElev
+               --EgtSetMachiningParam( MCH_MP.DEPTH_STR, 'TH '..EgtNumToString( dDepth, 1))
             end
-            -- imposto elevazione
+            -- imposto massima elevazione
             local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 2) .. ';'
             EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
             -- eseguo
@@ -3071,7 +3082,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
                return false, sWarn
             end
          end
-      -- altrimenti segacatena di fianco 
+      -- altrimenti sega a catena di fianco 
       else
          -- verifico se posso farlo con la sega-catena
          local bMakeChainSaw, sSawing2, dMaxMat2, dSawCornerRad2, dSawThick2 = VerifyChainSaw( Proc, dDimMin, dDimMax)
@@ -3120,7 +3131,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
                   EgtOutLog( sWarn)
                end
                -- considero estremi inizio/fine chiusi
-               -- recupero massima elevazione da utente
+               -- imposto massima elevazione
                local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';'
                EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
                -- eseguo
@@ -4519,33 +4530,31 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
       -- dati della faccia
       local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, nFacInd, GDB_ID.ROOT)
       -- larghezza della faccia
-      local dV = 0
-      local dH = 0
+      local _, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd, GDB_ID.ROOT)
+      if Proc.Box:getDimX() > Proc.Box:getDimY() then
+         if dH > dV then dH, dV = dV, dH end
+      else
+         if dH < dV then dH, dV = dV, dH end
+      end
       -- se due o più facce (recupero la larghezza della faccia perpendicolarmente alle altre)
       if Proc.Fct >= 2 then
          local vtN2 = EgtSurfTmFacetNormVersor( Proc.Id, EgtIf( nFacInd == 0, 1, 0), GDB_ID.ROOT)
          local vtX = vtN2 ^ vtN
-         local frRef = Frame3d( ptC, ptC + 100 * vtX, ptC + 100 * vtN2)
-         local b3Ref = EgtSurfTmGetFacetBBoxRef( Proc.Id, nFacInd, GDB_BB.STANDARD, frRef)
-         if b3Ref then
-            dH = b3Ref:getDimX()
-            dV = b3Ref:getDimY()
-         end
-      -- altrimenti una sola faccia
-      else
-         _, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd, GDB_ID.ROOT)
-         if Proc.Box:getDimX() > Proc.Box:getDimY() then
-            if dH > dV then dH, dV = dV, dH end
-         else
-            if dH < dV then dH, dV = dV, dH end
+         if not vtX:isSmall() then
+            local frRef = Frame3d( ptC, ptC + 100 * vtX, ptC + 100 * vtN2)
+            local b3Ref = EgtSurfTmGetFacetBBoxRef( Proc.Id, nFacInd, GDB_BB.STANDARD, frRef)
+            if b3Ref then
+               dH = b3Ref:getDimX()
+               dV = b3Ref:getDimY()
+            end
          end
       end
       -- verifico se U
       local bIsU = ( Proc.Fct == 3 and not TestElleShape3( Proc))
       -- verifico se due facce o L con una o due facce di terminazione
       local bIsL = ( Proc.Fct == 2 or TestElleShape3( Proc) or TestElleShape4( Proc) == 2)
-      -- se parametro Q03=2 forzo la fresatura di lato
-      local bForceSideMill = EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'i') == 2 and ( Proc.Fct == 4 or Proc.Fct == 3 or Proc.Fct == 2)
+      -- se parametro Q03=2 forzo la fresatura di lato; con Q03=3 forzo solo se la faccia di lavoro non è rivolta verso l'alto +/-10°
+      local bForceSideMill = ( EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'i') == 2 or ( EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'i') == 3 and vtN:getZ() < 0.985)) and ( Proc.Fct == 4 or Proc.Fct == 3 or Proc.Fct == 2)
       -- se fattibile con fresa BH di fianco e spessore utensile inferiore alla larghezza faccia
       local bMakeBySideMill, bHead, bHeadDir, sMilling, dMaxMat, dToolDiam = VerifyBHSideMill( Proc, bIsU, bIsL, bSinglePart, bPrevBhSideMill)
       if bPrevBhSideMill == nil then
@@ -5038,7 +5047,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                                                               rfFac, dH, dV, dFacElev, bForceUseBlade, 
                                                               dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, 
                                                               bOrthoFaces, nBottomFace, nChamfer, nAddGrpId, b3Solid, 
-                                                              dDepthCham, nSurfInt, true)
+                                                              dDepthCham, nSurfInt)
                         if not bOk then
                            -- in base al flag interno e al numero di facce e se ha forma ad U:  provo prima la svuotatura sul fianco e 
                            -- se non è possibile allora provo in seguito con lama o segacatena

LuaLibs/ProcessLongCut.lua

@@ -10,6 +10,7 @@
 -- 2021/11/04 Migliorata gestione sicurezza aggiuntiva in fresate di fianco (distinzione tra larga come tutta la faccia o meno).
 -- 2021/11/08 Se con lama e flag BD.USE_LONGCUT si lavora in direzione contraria allo standard.
 -- 2022/03/07 Razionalizzata gestione casi con fresa di fianco. Aggiunta gestione Long2Cut anche con testa sotto.
+-- 2022/07/14 Aggiunta limitazione lavorazione a sinistra anche se il grezzo successivo non ha lavorazioni (finale barra) ma è abbastanza lungo da poter essere riutilizzato (BD.MinRaw).
 
 -- Tabella per definizione modulo
 local ProcessLongCut = {}
@@ -507,8 +508,9 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
             end
          end
       end
-      -- se la fine (a sinistra) non è limitata e ho un pezzo successivo meno distante di metà raggio. setto la fine come limitata
-      if ( bCanUseBlade or bCanUseUnderBlade) and ( dDistToNextPiece < dToolDiam/2 or dDistToNextPiece < dToolDiamDn/2) and not bLimXmin then
+      local nNextRawId = EgtGetNextRawPart( nRawId)
+      -- se la fine (a sinistra) non è limitata e ho un pezzo successivo meno distante di metà raggio, oppure se grezzo finale della barra di lunghezza sufficiente, setto la fine come limitata
+      if ((( bCanUseBlade or bCanUseUnderBlade) and ( dDistToNextPiece < dToolDiam/2 or dDistToNextPiece < dToolDiamDn/2)) or (nNextRawId and EgtGetPartInRawPartCount( nNextRawId) <= 0 and EgtGetRawPartBBox( nNextRawId):getDimX() >= BD.MinRaw)) and not bLimXmin then
          if bForceUseBladeOnNotThruFace then
             bForcedLim = true
             bLimXmin = true

LuaLibs/ProcessScarfJoint.lua

@@ -1,7 +1,8 @@
--- ProcessScarfJoint.lua by Egaltech s.r.l. 2021/06/28
+-- ProcessScarfJoint.lua by Egaltech s.r.l. 2022/07/12
 -- Gestione calcolo giunto Gerber per Travi
 -- 2021/06/28 Aggiunto extra-taglio alle lamate orizzontali.
 -- 2022/06/10 Aggiunto il parametro dOvmTail per gestire sovramateriali in coda diversi da OVM_MID (sezioni alte e larghe)
+-- 2022/07/12 Aggiunta gestione PF1250 e TURN.
 
 -- Tabella per definizione modulo
 local ProcessScarfJoint = {}
@@ -27,6 +28,10 @@ end
 ---------------------------------------------------------------------
 -- Classificazione della feature
 function ProcessScarfJoint.Classify( Proc)
+   -- se PF con testa da sotto o TURN, ammessa qualunque orientazione
+   if ( BD.C_SIMM and BD.DOWN_HEAD) or BD.TURN then
+      return true
+   end
    -- verifico le normali delle facce
    local nFacetCnt = EgtSurfTmFacetCount( Proc.Id)
    for i = 1, nFacetCnt do
@@ -127,10 +132,10 @@ end
 ---------------------------------------------------------------------
 local function ApplyDiceCut( vFaceOrd, nGoodFace1, nGoodFace4, nAddGrpId, b3Solid, ptC, vtN, Proc, vtRef, bHead, sCutting, dSawDiam, b3Raw, dNewDiceDim)
 
-   local vCuts = {}
    local bOk = true
    local sErr = ''
 
+   local vCuts = {}
    if nGoodFace1 and nGoodFace4 and nGoodFace1 > 0 and nGoodFace4 > 0 then
       -- lavoro solo la faccia inclinata perché la faccia tappo completa la lavoro successivamente
       -- questo evita di lavorare due volte la faccia tappo
@@ -139,6 +144,8 @@ local function ApplyDiceCut( vFaceOrd, nGoodFace1, nGoodFace4, nAddGrpId, b3Soli
       vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC[vFaceOrd[4]], vtN[vFaceOrd[4]], true, nil, nil, nil, dNewDiceDim)
    end
 
+   local dVzLimDwnUp = EgtIf( vtRef:getZ() < -0.017, -2, nil)
+
    if #vCuts > 0 then
       -- sistemo posizione nel DB e nome
       for i = 1, #vCuts do
@@ -174,7 +181,7 @@ local function ApplyDiceCut( vFaceOrd, nGoodFace1, nGoodFace4, nAddGrpId, b3Soli
          local dExtraCut = EgtIf( i % 2 == 1, 0, BD.CUT_EXTRA)
          -- lavoro la faccia
          for j = 1, #vCuts[i] do
-            bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO, nil, dExtraCut, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+            bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO, dVzLimDwnUp, dExtraCut, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
             if not bOk then return bOk, sErr end
          end
       end
@@ -182,14 +189,14 @@ local function ApplyDiceCut( vFaceOrd, nGoodFace1, nGoodFace4, nAddGrpId, b3Soli
       if vFaceOrd[1] ~= 0 then
          -- inserisco la lavorazione
          local vtOrthoO = Vector3d( vtRef)
-         bOk, sErr = Fbs.MakeOne( Proc.Id, vFaceOrd[1] - 1, sCutting, dSawDiam, vtOrthoO, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+         bOk, sErr = Fbs.MakeOne( Proc.Id, vFaceOrd[1] - 1, sCutting, dSawDiam, vtOrthoO, dVzLimDwnUp, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
          if not bOk then return bOk, sErr end
       end
       -- lavoro la faccia opposta (definita dal parametro P11)
       if vFaceOrd[3] ~= 0 then
          -- inserisco la lavorazione
          local vtOrthoO = Vector3d( vtRef)
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, vFaceOrd[3] - 1, sCutting, dSawDiam, vtOrthoO, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+         local bOk, sErr = Fbs.MakeOne( Proc.Id, vFaceOrd[3] - 1, sCutting, dSawDiam, vtOrthoO, dVzLimDwnUp, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
          if not bOk then return bOk, sErr end
       end
    end
@@ -290,8 +297,12 @@ function ProcessScarfJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmTa
    local bOkc, sErrC = MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead)
    if not bOkc then return bOkc, sErrC end
 
+   -- abilitazione lavorazione da sotto (testa da sotto e direzione normale sotto -20deg)
+   local bDownHead = ( BD.DOWN_HEAD and vtRef:getZ() < -0.01)
+   local bTopHead = ( BD.DOWN_HEAD and ( vtRef:getZ() > -0.01 or not bDownHead))
+
    -- recupero la lavorazione
-   local sCutting = ML.FindCutting( 'HeadSide')
+   local sCutting = ML.FindCutting( 'HeadSide', bTopHead, bDownHead)
    if not sCutting then
       local sErr = 'Error : cutting not found in library'
       EgtOutLog( sErr)
@@ -441,9 +452,9 @@ function ProcessScarfJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmTa
       -- recupero la lavorazione. considerando l dimensione del lato e l'affondamento
       local sPocketing
       if dDistFaces then
-         sPocketing = ML.FindPocketing( 'OpenPocket', dDiamMax, dDistFaces)
+         sPocketing = ML.FindPocketing( 'OpenPocket', dDiamMax, dDistFaces, nil, bTopHead, bDownHead)
       else
-         sPocketing = ML.FindPocketing( 'OpenPocket', dDiamMax)
+         sPocketing = ML.FindPocketing( 'OpenPocket', dDiamMax, nil, nil, bTopHead, bDownHead)
       end
 
       if not sPocketing then

LuaLibs/ProcessTenon.lua

@@ -202,7 +202,7 @@ function ProcessTenon.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
    local OVERLAP_COEFF = 0.7
    -- porto inizio curva il più possibile sul bordo in alto o in basso
    local dMaxDist = OVERLAP_COEFF * dMillDiam * MAX_PASS
-   local bMyShortPart = ( bShortPart and abs( vtN:getX()) < 0.999)
+   local bMyShortPart = ( bShortPart and abs( vtN:getX()) < 0.999 and abs( vtN:getY()) < 0.259)
    BL.PutStartNearestToEdge( AuxId, b3Solid, dMaxDist, bH2 ~= bMyShortPart)
    -- se elevazione superiore a massimo affondamento della fresa, riduco opportunamente
    local sWarn