BugFix/HeadSplitCutOnBigSection:

- corretto anche per Split il flag Q05 non inizializzato
- ora la gestione dei tagli per BigSection è quella standard (HorizCut, double, etc.)

.gitlab-ci.yml

@@ -2,9 +2,8 @@ variables:
  VERS_MAIN: '1.0'
  APP_NAME: 'Beam'
  NEW_REL: ''
- NET_SHARE_R: '\\10.74.82.201\Artifacts\EGT_SRV\EgtTech'
- NET_USER: '10.74.82.50\Server'
- NET_SHARE_Z: '\\10.74.82.200\Artifacts'
+ NET_SHARE_R: '\\10.74.82.201\EgwTech'
+ NET_SHARE_Z: '\\10.74.82.201\Artifacts'
  NET_USERQ: 'steamw\egalware'
 
 #Note compilazione LUA:

LuaLibs/BeamExec.lua

@@ -1,4 +1,4 @@
--- BeamExec.lua by Egaltech s.r.l. 2022/08/18
+-- BeamExec.lua by Egaltech s.r.l. 2022/09/24
 -- Libreria esecuzione lavorazioni per Travi
 -- 2019/07/11 Aggiunta gestione stato rotazione di feature per TS3.
 -- 2019/09/04 Corretto controllo feature di testa e coda con sovramateriale di testa elevato.
@@ -35,6 +35,7 @@
 -- 2022/08/01 Tolleranza su sezione portata a 0.1 mm (100 * GEO.EPS_SMALL).
 -- 2022/08/08 Modifica per macchine senza BD.MAX_WIDTH2 e BD.MAX_HEIGHT2.
 -- 2022/08/18 Aggiunta gestione macchine con testa da sotto con lama da sotto disabilitata.
+-- 2022/09/21 Nella funzione di ordinamento il foro del birdsmouth viene sempre fatto prima della lavorazione stessa
 
 -- Tabella per definizione modulo
 local BeamExec = {}
@@ -258,6 +259,9 @@ local function CollectFeatures( PartId, b3Raw, dCurrOvmH, dCurrOvmT)
             local nDo = EgtGetInfo( ProcId, 'DO', 'i') or 1
             local nCutId = EgtGetInfo( EgtGetParent( EgtGetParent( ProcId)), 'CUTID', 'i') or 0
             local nTaskId = EgtGetInfo( ProcId, 'TASKID', 'i') or 0
+            -- leggo se ci sono feature collegate
+            local nAddAdjId = EgtGetInfo( ProcId, 'ADJID', 'i')
+            local nAddMainId = EgtGetInfo( ProcId, 'MAINID', 'i')
             if nGrp and nPrc and nDo == 1 then
                local Proc = {}
                Proc.Id = ProcId
@@ -270,6 +274,12 @@ local function CollectFeatures( PartId, b3Raw, dCurrOvmH, dCurrOvmT)
                Proc.Fce = 0
                Proc.CutId = nCutId
                Proc.TaskId = nTaskId
+               -- se ci sono feature collegate ne scrivo il riferimento nella Proc
+               if nAddAdjId then
+                  Proc.AdjId = Proc.Id + nAddAdjId
+               elseif nAddMainId then
+                  Proc.MainId = Proc.Id + nAddMainId
+               end
                Proc.Box = EgtGetBBoxGlob( ProcId, GDB_BB.STANDARD)
                if Proc.Box and not Proc.Box:isEmpty() then 
                   Proc.Head = IsHeadFeature( Proc, b3Raw, dCurrOvmH)
@@ -670,6 +680,14 @@ local function OrderFeatures( vProc, b3Raw)
       if B1.Head ~= B2.Head then
          return B1.Head
       end
+      -- se primo è foro di un birdsmouth e secondo è il suo birdsmouth, il foro va sempre prima
+      if Drill.Identify(B1) and LapJoint.Identify(B2) and B1.MainId == B2.Id then
+         return true
+      end
+      -- se primo è birdsmouth e secondo è il suo foro, il birdsmouth va sempre dopo
+      if LapJoint.Identify(B1) and Drill.Identify(B2) and B1.AdjId == B2.Id then
+         return false
+      end
       -- se entrambi tenoni e si intersecano, metto prima tenone vero e poi base tenone
       if ( Tenon.Identify( B1) or DtTenon.Identify( B1)) and ( Tenon.Identify( B2) or DtTenon.Identify( B2)) and
          B1.Box:getMin():getX() < B2.Box:getMax():getX() + 100 * GEO.EPS_SMALL and B2.Box:getMin():getX() < B1.Box:getMax():getX() + 100 * GEO.EPS_SMALL then
@@ -1238,7 +1256,7 @@ local function AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, bN
       EgtOutLog( sErr)
       bOk = false
    end
-   return bOk, sErr, nNewPhase
+   return bOk, sErr, ( nNewPhase or -1)
 end
 
 -------------------------------------------------------------------------------------------------------------

LuaLibs/BeamLib.lua

@@ -308,7 +308,7 @@ function BeamLib.GetNearestOrthoOpposite( vtRef, vtNorm)
       vtMyRef:normalize()
    end
    -- se prevalente una componente orizzontale (con piccolissimo vantaggio)
-   if abs( vtMyRef:getX()) > 0.95 * abs( vtMyRef:getZ()) or abs( vtMyRef:getY()) > 0.95 * abs( vtMyRef:getZ()) then
+   if abs( vtMyRef:getX()) > 0.91 * abs( vtMyRef:getZ()) or abs( vtMyRef:getY()) > 0.91 * abs( vtMyRef:getZ()) then
       -- se prevale la componente destra/sinistra
       if abs( vtMyRef:getX()) > 0.95 * abs( vtMyRef:getY()) then
          if vtMyRef:getX() > -GEO.EPS_SMALL then
@@ -703,8 +703,10 @@ end
 
 -------------------------------------------------------------------------------------------------------------
 function BeamLib.GetNzLimDownUp( b3Raw, vtN, vtOrtho)
-   if BD.C_SIMM or BD.TURN then
+   if BD.C_SIMM then
       return -0.484
+   elseif BD.TURN then
+      return -2
    else
       if vtOrtho and vtOrtho:getZ() > 0.35 then
          -- N_HorAng < 15° or N_HorAng > 55°

LuaLibs/DiceCut.lua

@@ -496,6 +496,12 @@ function DiceCut.GetDice( nParent, BBoxRawPart, ptCPlanes, vtNPlanes, bGetOrtoPl
          if bDownHead and vtO:getZ() > 0.05 then
             vtO = -vtO
          end
+         -- per macchina TURN
+         if BD.TURN then
+            if vtO:getY() > 0.707 then
+               vtO = -vtO
+            end
+         end
          -- calcolo le dimensioni dell'offset e dove posizionare la prima faccia:
          --   CopyPlane: 0 => crea la prima faccia direttamente sul punto passato
          --   CopyPlane: 1 => crea la prima faccia e tutte le altre con l'offset passato

LuaLibs/FacesBySaw.lua

@@ -1,4 +1,4 @@
--- FacesBySaw.lua by Egaltech s.r.l. 2022/06/29
+-- FacesBySaw.lua by Egaltech s.r.l. 2022/09/24
 -- Gestione taglio con lama di feature con una o due facce
 -- 2021/01/06 Cambiato limite per attacco Tg con lama e CalcLeadInOutGeom rinominata in CalcLeadInOutPerpGeom.
 -- 2021/02/03 In taglio lama si accettano anche due lati con deviazione minore di 20deg.
@@ -126,7 +126,7 @@ function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDw
    local ptP1act = ptP1 + vtN * dCutOffset
    local ptP2act = ptP2 + vtN * dCutOffset
    -- attacco perpendicolare
-   local dLiTang, dLiPerp, dLoTang, dLoPerp = FacesBySaw.CalcLeadInOutPerpGeom( ptP1act, ptP2act, vtV1, vtV2, vtN, dSawDiam/2, vtRef, dCutExtra, b3Box)
+   local dLiTang, dLiPerp, dLoTang, dLoPerp, vtLio = FacesBySaw.CalcLeadInOutPerpGeom( ptP1act, ptP2act, vtV1, vtV2, vtN, dSawDiam/2, vtRef, dCutExtra, b3Box)
    local dLenLi = sqrt( dLiTang * dLiTang + dLiPerp * dLiPerp)
    local dLenLo = sqrt( dLoTang * dLoTang + dLoPerp * dLoPerp)
    -- attacco tangente
@@ -160,11 +160,26 @@ function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDw
          nSCC = EgtIf( ( vtAux:getY() > -GEO.EPS_SMALL), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
       end
    else
-      local vtTest = EgtIf( bTurnTang, EgtIf( bInvert, vtTg, -vtTg), vtOut)
-      if abs( vtTest:getY()) > abs( vtTest:getZ()) then
-         nSCC = EgtIf( vtTest:getY() > 0, MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
+      if bTurnTang then
+         local vtTest = EgtIf( bInvert, vtTg, -vtTg)
+         if abs( vtTest:getY()) > abs( vtTest:getZ()) then
+            nSCC = EgtIf( vtTest:getY() > 0, MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
+         else
+            nSCC = EgtIf( vtTest:getZ() > 0, MCH_SCC.ADIR_ZP, MCH_SCC.ADIR_ZM)
+         end
       else
-         nSCC = EgtIf( vtTest:getZ() > 0, MCH_SCC.ADIR_ZP, MCH_SCC.ADIR_ZM)
+         local vtTest = vtOut   -- vtLio
+         if abs( vtN:getY()) < 0.174 and abs( vtN:getZ()) < 0.174 then
+            if abs( vtTest:getY()) > abs( vtTest:getZ()) then
+               nSCC = EgtIf( vtTest:getY() > 0, MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
+            else
+               nSCC = EgtIf( vtTest:getZ() > 0, MCH_SCC.ADIR_ZP, MCH_SCC.ADIR_ZM)
+            end
+         elseif abs( vtN:getZ()) < 0.174 then
+            nSCC = EgtIf( vtTest:getZ() > -0.017, MCH_SCC.ADIR_ZP, MCH_SCC.ADIR_ZM)
+         else
+            nSCC = EgtIf( vtTest:getY() > 0, MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
+         end
       end
    end
    -- inserisco la lavorazione di taglio
@@ -464,29 +479,24 @@ function FacesBySaw.CalcLeadInOutPerpGeom( ptP1, ptP2, vtV1, vtV2, vtN, dRad, vt
    local vtX = vtTg ^ vtN
    local frFace = Frame3d( ptP1, vtX, vtTg, vtN)
    EgtOutLog( 'Vref=' .. tostring( vtRef) .. ' V1=' .. tostring( vtV1) .. ' V2=' .. tostring( vtV2), 3)
-   -- Versori di attacco e uscita
+   -- Versore di attacco e uscita
    local dCos1 = vtV1 * vtRef
    local dCos2 = vtV2 * vtRef
-   local vtLi, vtLo
+   local vtLio
    if abs( dCos1 - dCos2) < 0.001 then
       if abs( vtV1:getZ()) < abs( vtV2:getZ()) then
-         vtLi = vtV1
-         vtLo = vtV1
+         vtLio = vtV1
       else
-         vtLi = vtV2
-         vtLo = vtV2
+         vtLio = vtV2
       end
    elseif dCos1 > dCos2 then
-      vtLi = vtV1
-      vtLo = vtV1
+      vtLio = vtV1
    else
-      vtLi = vtV2
-      vtLo = vtV2
+      vtLio = vtV2
    end
-   local bRight = ( vtX * vtLi > 0)
-   -- Versori di attacco e uscita nel riferimento intrinseco al taglio
-   local vtLiL = Vector3d( vtLi) ;   vtLiL:toLoc( frFace)
-   local vtLoL = Vector3d( vtLo) ;   vtLoL:toLoc( frFace)
+   local bRight = ( vtX * vtLio > 0)
+   -- Versore di attacco e uscita nel riferimento intrinseco al taglio
+   local vtLioL = Vector3d( vtLio) ;   vtLioL:toLoc( frFace)
    -- Spostamento punti per effetto dell'extra o della deficienza di taglio
    ptP1 = ptP1 + vtX * ( EgtIf( bRight, - dCutExtra, dCutExtra))
    ptP2 = ptP2 + vtX * ( EgtIf( bRight, - dCutExtra, dCutExtra))
@@ -496,30 +506,30 @@ function FacesBySaw.CalcLeadInOutPerpGeom( ptP1, ptP2, vtV1, vtV2, vtN, dRad, vt
    -- Attacco
    local dLiTang = 10000
    local dLiPerp = 10000
-   local bLiOk, _, vLiPar = EgtLineBoxInters( ptP1, vtLi, b3MyBox)
+   local bLiOk, _, vLiPar = EgtLineBoxInters( ptP1, vtLio, b3MyBox)
    if bLiOk and #vLiPar > 0 then
       -- con la prima faccia di uscita
       local dLen = vLiPar[#vLiPar]
-      local ptInt = ptP1 + vtLi * dLen
-      local vtFN = BL.GetBoxFaceNorm( b3MyBox, ptInt, vtLi)
+      local ptInt = ptP1 + vtLio * dLen
+      local vtFN = BL.GetBoxFaceNorm( b3MyBox, ptInt, vtLio)
       EgtOutLog( 'LiFaceNorm=' .. tostring( vtFN), 3)
-      local dAddLen = dRad * ( sqrt( 1 - ( vtN * vtFN) * ( vtN * vtFN)) - abs( vtX * vtFN)) / ( vtLi * vtFN)
+      local dAddLen = dRad * ( sqrt( 1 - ( vtN * vtFN) * ( vtN * vtFN)) - abs( vtX * vtFN)) / ( vtLio * vtFN)
       local dLiLen = dLen + dAddLen
       EgtOutLog( 'LeadIn Dist=' .. EgtNumToString( dLiLen), 3)
-      dLiTang = - dLiLen * vtLiL:getY()
-      dLiPerp = EgtIf( bRight, dLiLen, - dLiLen) * vtLiL:getX()
+      dLiTang = - dLiLen * vtLioL:getY()
+      dLiPerp = EgtIf( bRight, dLiLen, - dLiLen) * vtLioL:getX()
       -- verifico se miglioro calcolando con faccia successiva
       local b3Mod = BBox3d( b3MyBox) ;  b3Mod:Add( ptInt + 1000 * vtFN)
-      local bLiOk2, _, vLiPar2 = EgtLineBoxInters( ptP1, vtLi, b3Mod)
+      local bLiOk2, _, vLiPar2 = EgtLineBoxInters( ptP1, vtLio, b3Mod)
       if bLiOk2 and #vLiPar2 > 0 then
          local dLen2 = vLiPar2[#vLiPar2]
-         local vtFN2 = BL.GetBoxFaceNorm( b3Mod, ptP1 + vtLi * dLen2, vtLi)
+         local vtFN2 = BL.GetBoxFaceNorm( b3Mod, ptP1 + vtLio * dLen2, vtLio)
          EgtOutLog( 'LiFaceNorm2=' .. tostring( vtFN2), 3)
-         local dAddLen2 = dRad * ( sqrt( 1 - ( vtN * vtFN2) * ( vtN * vtFN2)) - abs( vtX * vtFN2)) / ( vtLi * vtFN2)
+         local dAddLen2 = dRad * ( sqrt( 1 - ( vtN * vtFN2) * ( vtN * vtFN2)) - abs( vtX * vtFN2)) / ( vtLio * vtFN2)
          local dLiLen2 = dLen2 + dAddLen2
          EgtOutLog( 'LeadIn Dist2=' .. EgtNumToString( dLiLen2), 3)
-         local dLiTang2 = - dLiLen2 * vtLiL:getY()
-         local dLiPerp2 = EgtIf( bRight, dLiLen2, - dLiLen2) * vtLiL:getX()
+         local dLiTang2 = - dLiLen2 * vtLioL:getY()
+         local dLiPerp2 = EgtIf( bRight, dLiLen2, - dLiLen2) * vtLioL:getX()
          if dLiLen2 < dLiLen then
             dLiTang = dLiTang2
             dLiPerp = dLiPerp2
@@ -529,37 +539,37 @@ function FacesBySaw.CalcLeadInOutPerpGeom( ptP1, ptP2, vtV1, vtV2, vtN, dRad, vt
    -- Lunghezza di uscita
    local dLoTang = 10000
    local dLoPerp = 10000
-   local bLoOk, _, vLoPar = EgtLineBoxInters( ptP2, vtLo, b3MyBox)
+   local bLoOk, _, vLoPar = EgtLineBoxInters( ptP2, vtLio, b3MyBox)
    if bLoOk and #vLoPar > 0 then
       -- con la prima faccia di uscita
       local dLen = vLoPar[#vLoPar]
-      local ptInt = ptP2 + vtLo * dLen
-      local vtFN = BL.GetBoxFaceNorm( b3MyBox, ptInt, vtLo)
+      local ptInt = ptP2 + vtLio * dLen
+      local vtFN = BL.GetBoxFaceNorm( b3MyBox, ptInt, vtLio)
       EgtOutLog( 'LoFaceNorm=' .. tostring( vtFN), 3)
-      local dAddLen = dRad * ( sqrt( 1 - ( vtN * vtFN) * ( vtN * vtFN)) - abs( vtX * vtFN)) / ( vtLo * vtFN)
+      local dAddLen = dRad * ( sqrt( 1 - ( vtN * vtFN) * ( vtN * vtFN)) - abs( vtX * vtFN)) / ( vtLio * vtFN)
       local dLoLen = dLen + dAddLen
       EgtOutLog( 'LeadOut Dist=' .. EgtNumToString( dLoLen), 3)
-      dLoTang = dLoLen * vtLoL:getY()
-      dLoPerp = EgtIf( bRight, dLoLen, - dLoLen) * vtLoL:getX()
+      dLoTang = dLoLen * vtLioL:getY()
+      dLoPerp = EgtIf( bRight, dLoLen, - dLoLen) * vtLioL:getX()
       -- verifico se miglioro calcolando con faccia successiva
       local b3Mod = BBox3d( b3MyBox) ;  b3Mod:Add( ptInt + 1000 * vtFN)
-      local bLoOk2, _, vLoPar2 = EgtLineBoxInters( ptP2, vtLo, b3Mod)
+      local bLoOk2, _, vLoPar2 = EgtLineBoxInters( ptP2, vtLio, b3Mod)
       if bLoOk2 and #vLoPar2 > 0 then
          local dLen2 = vLoPar2[#vLoPar2]
-         local vtFN2 = BL.GetBoxFaceNorm( b3Mod, ptP2 + vtLo * dLen2, vtLo)
+         local vtFN2 = BL.GetBoxFaceNorm( b3Mod, ptP2 + vtLio * dLen2, vtLio)
          EgtOutLog( 'LoFaceNorm2=' .. tostring( vtFN2), 3)
-         local dAddLen2 = dRad * ( sqrt( 1 - ( vtN * vtFN2) * ( vtN * vtFN2)) - abs( vtX * vtFN2)) / ( vtLo * vtFN2)
+         local dAddLen2 = dRad * ( sqrt( 1 - ( vtN * vtFN2) * ( vtN * vtFN2)) - abs( vtX * vtFN2)) / ( vtLio * vtFN2)
          local dLoLen2 = dLen2 + dAddLen2
          EgtOutLog( 'LeadOut Dist2=' .. EgtNumToString( dLoLen2), 3)
-         local dLoTang2 = dLoLen2 * vtLoL:getY()
-         local dLoPerp2 = EgtIf( bRight, dLoLen2, - dLoLen2) * vtLoL:getX()
+         local dLoTang2 = dLoLen2 * vtLioL:getY()
+         local dLoPerp2 = EgtIf( bRight, dLoLen2, - dLoLen2) * vtLioL:getX()
          if dLoLen2 < dLoLen then
             dLoTang = dLoTang2
             dLoPerp = dLoPerp2
          end
       end
    end
-   return dLiTang, dLiPerp, dLoTang, dLoPerp
+   return dLiTang, dLiPerp, dLoTang, dLoPerp, vtLio
 end
 
 ---------------------------------------------------------------------

LuaLibs/ProcessCut.lua

@@ -16,6 +16,7 @@
 -- 2022/08/24 Disabilitato il dicing per i tagli meno spessi della lama.
 -- 2022/08/25 In caso di AdvTail con taglio lungo Y la profondità di lavorazione è opportunamente diminuita.
 -- 2022/08/30 Modificata la condizione che determina l'utilizzo della testa da sotto. Ora controlla se la trave è più grande del doppio della massima larghezza del cubetto.
+-- 2022/09/23 Corretta la condizione per cui è richiesto l'aggiornamento del grezzo.
 
 -- Tabella per definizione modulo
 local ProcessCut = {}
@@ -249,17 +250,21 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
                       Proc.Box:getDimY() > b3Solid:getDimY() - 10 * GEO.EPS_SMALL and
                       ( Proc.Box:getDimX() > 0.75 * b3Solid:getDimX() or Proc.Box:getDimX() > 600.000))
    -- verifico se da considerare taglio lungo dal lato, solo per macchine tipo PF1250, inclinato non più di 30deg
-   local bLongCutFromSide = ( not bDownCut and ( BD.C_SIMM and BD.DOWN_HEAD and ( vtN:getY() > 0.865 or vtN:getY() < -0.865) and
+   local bLongCutFromSide = ( not bDownCut and ( BD.C_SIMM and BD.DOWN_HEAD and ( abs(vtN:getY()) > 0.865) and
                               Proc.Box:getDimZ() > b3Solid:getDimZ() - 10 * GEO.EPS_SMALL) and
                               ( Proc.Box:getDimX() > 0.75 * b3Solid:getDimX() or Proc.Box:getDimX() > 600.000))
    -- se taglio lungo e Q04 = 1 allora lancio il processo dell'L10
    local bNoDicing = EgtGetInfo( Proc.Id, 'Q04', 'i') == 1
    if bNoDicing then
       if bLongCut then
-         return LongCut.Make( Proc, nPhase, nRawId, nPartId, true)
+         local bOk, sErr = LongCut.Make( Proc, nPhase, nRawId, nPartId, true)
+         return bOk, sErr, bNoDicing
       elseif bLongCutFromSide then
-         return LongCut.Make( Proc, nPhase, nRawId, nPartId, false, 2)
+         local bOk, sErr = LongCut.Make( Proc, nPhase, nRawId, nPartId, false, 2)
+         return bOk, sErr, bNoDicing
       end
+      -- se non passa dal LongCut rimetto a false perchè ha fatto un taglio standard
+      bNoDicing = false
    end
    -- se pezzo ancora attaccato alla trave, per non rovinare quello successivo
    local bFillAreaPiece
@@ -430,7 +435,7 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
                   local dVzLimDwnUp = dNzLimDwnUp
                   if j ~= 1 then
                      vtNewOrthoO = -vtOrthoO
-                     if not BD.C_SIMM and abs( vtN:getY()) > 0.05 then dVzLimDwnUp = -0.707 end
+                     if not BD.C_SIMM and not BD.TURN and abs( vtN:getY()) > 0.05 then dVzLimDwnUp = -0.708 end
                   end
                   local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtNewOrthoO, dVzLimDwnUp, BD.CUT_EXTRA, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
                   if not bOk then return bOk, sErr end
@@ -454,7 +459,7 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
                   end
                end
                local dVzLimDwnUp = dNzLimDwnUp
-               if not BD.C_SIMM and vtN:getZ() > 0.707 then dVzLimDwnUp = -0.708 end
+               if not BD.C_SIMM and not BD.TURN and vtN:getZ() > 0.707 then dVzLimDwnUp = -0.708 end
                local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO, dVzLimDwnUp, dExtraCut, BD.CUT_SIC, 0, 0, 0, sNotes, b3Raw)
                if not bOk then return bOk, sErr end
             end
@@ -737,9 +742,11 @@ function ProcessCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom,
       EgtOutLog( sErr)
       return false, sErr
    end
+   local bNoDicing = false
    -- se taglio con testa da sopra
    if not bDownHead and not bDownTurn then
-      local bOk, sErr = MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom, bCustDiceCut, bForced, b3Raw, sNotes)
+      local bOk, sErr, bNoDicing2 = MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom, bCustDiceCut, bForced, b3Raw, sNotes)
+      bNoDicing = bNoDicing2
       if not bOk then return false, sErr end
    -- altrimenti taglio con testa da sotto
    else
@@ -747,7 +754,8 @@ function ProcessCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom,
       if not bOk then return false, sErr end
    end
    -- Aggiornamento ingombro (se vero taglio o richiesto)
-   if ProcessCut.Identify( Proc) or bUpdateIng then
+   -- Se lascio il cordolo (bNoDicing) non aggiorno il grezzo perchè lo scarto rimane attaccato
+   if ( ProcessCut.Identify( Proc) or bUpdateIng) and not bNoDicing then
       UpdateEncumbrance( Proc, vtN, dOvmHead, nRawId, b3Solid, b3Raw)
    end
    return true

LuaLibs/ProcessDoubleCut.lua

@@ -581,7 +581,7 @@ function ProcessDoubleCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
          local _, _, dDimV2 = BL.GetFaceHvRefDim( Proc.Id, 1, b3Raw)
          local bFace1TooLongForBlade, bFace2TooLongForBlade = ( dDimV1 >= dMaxDepth), ( dDimV2 >= dMaxDepth)
          local dFace1Ang, dFace2Ang = vtN[1]:getZ(), vtN[2]:getZ()
-         if bFace1TooLongForBlade and dFace1Ang < ( BD.CUT_VZ_MIN or -0.485) or bFace2TooLongForBlade and dFace2Ang < ( BD.CUT_VZ_MIN or -0.485) then
+         if bFace1TooLongForBlade and dFace1Ang < ( BD.CUT_VZ_MIN or -0.484) or bFace2TooLongForBlade and dFace2Ang < ( BD.CUT_VZ_MIN or -0.484) then
             local bOk, sErr = MakeBySidePocket(  Proc, nPhase, nRawId, nPartId, nAddGrpId, b3Solid)
             return bOk, sErr
          end

LuaLibs/ProcessFreeContour.lua

@@ -1,6 +1,8 @@
 -- ProcessFreeContour.lua by Egaltech s.r.l. 2021/10/07
 -- Gestione calcolo profilo libero per Travi
 -- 2022/08/23 Aggiunta la funzione MakeByMark per la gestione del caso P13=10
+-- 2022/09/21 In MakeByMill aggiunto messaggio per elevazione non raggiunta
+
 
 -- Tabella per definizione modulo
 local ProcessFreeContour = {}
@@ -313,6 +315,7 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
          dDepth = dDepth + BD.CUT_EXTRA
       end
    end
+   local bIsDepthReduced = false
    -- se parametro beamdata forza codolo in centro e lavorazione orizzontale e se larghezza trave è sufficientemente larga
    if BD.DIM_TO_CENTER_STRIP and BD.DIM_TO_CENTER_STRIP > 10 * GEO.EPS_SMALL and nStep > 1 and
       bCanDouble and b3Raw:getDimY() > BD.DIM_TO_CENTER_STRIP - 0.1 then
@@ -324,11 +327,21 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
          if bCanDouble then
             nDouble = 2
             dDepth = min( 0.5 * dDepth, dMaxDepth)
+            if dDepth < 0.5 * dDepth - 10 * GEO.EPS_SMALL then
+               bIsDepthReduced = true
+            end
          else
             dDepth = dMaxDepth
+            bIsDepthReduced = true
          end
       end
    end
+   local sWarn = ''
+   -- se ho ridotto l'altezza emetto warning
+   if bIsDepthReduced then
+      sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' (Free Contour) : elevation bigger than max tool depth'
+      EgtOutLog( sWarn)
+   end
    -- se utensile orizzontale verso Y+, non in doppio e codolo da lasciare, devo invertire per lavorare sempre da Y-
    if vtExtr:getY() > 0.707 and  nDouble == 1 and bStripOnSide then
       bToolInv = true
@@ -623,7 +636,7 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
          BL.UpdateTCING( nRawId, dOffs)
       end
    end
-   return true
+   return true, sWarn
 end
 
 ---------------------------------------------------------------------

LuaLibs/ProcessHeadCut.lua

@@ -1,9 +1,10 @@
--- ProcessSplit.lua by Egaltech s.r.l. 2022/08/18
+-- ProcessSplit.lua by Egaltech s.r.l. 2022/09/26
 -- Gestione calcolo tagli di testa per Travi
 -- 2022/05/31 Aggiunta gestione sezioni alte e larghe con taglio di tipo diceCut.
 -- 2022/06/10 Per sezioni alte e larghe aggiunta gestione finitura in base a sovramateriale e a parametro Q05 dell' eventuale lavorazione sostituita.
 -- 2022/08/18 Aggiunta gestione macchine con testa da sotto con lama da sotto disabilitata.
 -- 2022/09/08 Migliorato verso di lavorazione in caso di DoubleCut
+-- 2022/09/26 Gestione dei tagli di lama (Horiz, double, etc.) estesa anche a BigSection 
 
 -- Tabella per definizione modulo
 local ProcessHeadCut = {}
@@ -191,9 +192,9 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
    local dDimYRef = EgtIf( b3Raw:getDimZ() < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL, dMaxDepth, abs( BD.MAX_DIM_HTCUT_HBEAM))
    local bBigSectionCut = ( b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) and
                           ( b3Raw:getDimZ() > EgtIf( BD.TURN, 2 * dMaxVertDepth, dMaxVertDepth + dMaxDepth2) - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
-   local bHorizCut = ( not bBigSectionCut and ( b3Raw:getDimY() > b3Raw:getDimZ() + 10 * GEO.EPS_SMALL or BD.TURN) and b3Raw:getDimZ() < dMaxVertDepth - BD.CUT_EXTRA)
-   local bDoubleHorizCut = ( ( BD.DOWN_HEAD or BD.TURN) and not bBigSectionCut and not bHorizCut and b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
-   local bDoubleCut = ( not bBigSectionCut and not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA + 10 * GEO.EPS_SMALL)
+   local bHorizCut = ( ( b3Raw:getDimY() > b3Raw:getDimZ() + 10 * GEO.EPS_SMALL or BD.TURN) and b3Raw:getDimZ() < dMaxVertDepth - BD.CUT_EXTRA)
+   local bDoubleHorizCut = ( ( BD.DOWN_HEAD or BD.TURN) and not bHorizCut and b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
+   local bDoubleCut = ( not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA + 10 * GEO.EPS_SMALL)
    -- dati geometrici del taglio
    local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
    -- se non obbligatorio e coincide con inizio grezzo, non va fatto
@@ -203,15 +204,16 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
    -- determino se più tagli con offset
    local nCuts = max( ceil( dOvmHead / ( BD.MAX_LEN_SCRAP_START or BD.MAX_LEN_SCRAP)), 1)
    local dOffsL = dOvmHead / nCuts
+   local bFinishByBlade = not bBigSectionCut
    -- se taglio per sezioni alte e larghe
    if bBigSectionCut then
       if dOvmHead > 0 then
-         -- se finitura con lama
-         if not nOriId or EgtGetInfo( nOriId, 'Q05', 'i') == 1 or EgtGetInfo( nOriId, 'Q05', 'i') == 0 then
-            local bOk, sErr = Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, nil, false, true, nil, nil, dCurrOvmT)
-            if not bOk then return bOk, sErr end
+         local nQ05 = EgtGetInfo( nOriId or GDB_ID.NULL, 'Q05', 'i') or 0
+         -- se finitura con lama rimando ai casi standard
+         if nQ05 == 1 or nQ05 == 0 then
+            bFinishByBlade = true
          -- se finitura con truciolatore
-         elseif EgtGetInfo( nOriId, 'Q05', 'i') == 2 then
+         elseif nQ05 == 2 then
             local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
             if not b3Solid then
                local sErr = 'Error : part box not found'
@@ -228,73 +230,76 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
             if not bOk then return bOk, sErr end
          end
       end
-   -- se tagli standard
-   elseif not bDoubleHorizCut then
-      -- flag di lavorazione faccia
-      local nOrthoOpposite = EgtIf( bHorizCut, MCH_MILL_FU.ORTHO_DOWN, MCH_MILL_FU.ORTHO_FRONT)
-      -- calcolo extra taglio ed accorciamento
-      local dCutExtra = 0
-      local dAccStart = 0
-      local dAccEnd = 0
-      if b3Raw:getDimZ() < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL or b3Raw:getDimY() < 2 * BD.MAX_DIM_HTCUT_HBEAM + 10 * GEO.EPS_SMALL then
-         dCutExtra = EgtIf( bDoubleCut, - 0.5 * b3Raw:getDimY() + BD.CUT_EXTRA_MIN,  BD.CUT_EXTRA)
-      else
-         dCutExtra = - ( b3Raw:getDimY() - dMaxDepth)
-         local dSawRad = dSawDiam / 2
-         local dKL = dSawRad - dMaxDepth + b3Raw:getDimY() / 2 + BD.CUT_EXTRA_MIN
-         if BD.C_SIMM then
-            dAccEnd = sqrt( dSawRad * dSawRad - dKL * dKL)
+   end
+   -- tagli standard con lama
+   if bFinishByBlade then
+      if not bDoubleHorizCut then
+         -- flag di lavorazione faccia
+         local nOrthoOpposite = EgtIf( bHorizCut, MCH_MILL_FU.ORTHO_DOWN, MCH_MILL_FU.ORTHO_FRONT)
+         -- calcolo extra taglio ed accorciamento
+         local dCutExtra = 0
+         local dAccStart = 0
+         local dAccEnd = 0
+         if b3Raw:getDimZ() < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL or b3Raw:getDimY() < 2 * BD.MAX_DIM_HTCUT_HBEAM + 10 * GEO.EPS_SMALL then
+            dCutExtra = EgtIf( bDoubleCut, - 0.5 * b3Raw:getDimY() + BD.CUT_EXTRA_MIN,  BD.CUT_EXTRA)
          else
-            dAccStart = sqrt( dSawRad * dSawRad - dKL * dKL)
+            dCutExtra = - ( b3Raw:getDimY() - dMaxDepth)
+            local dSawRad = dSawDiam / 2
+            local dKL = dSawRad - dMaxDepth + b3Raw:getDimY() / 2 + BD.CUT_EXTRA_MIN
+            if BD.C_SIMM then
+               dAccEnd = sqrt( dSawRad * dSawRad - dKL * dKL)
+            else
+               dAccStart = sqrt( dSawRad * dSawRad - dKL * dKL)
+            end
          end
-      end
-      -- se necessari tagli in doppio, eseguo gli opposti
-      if bDoubleCut then
+         -- se necessari tagli in doppio, eseguo gli opposti
+         if bDoubleCut then
+            for i = nCuts, 1, -1 do
+               local dCutOffset = ( i - 1) * dOffsL
+               local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_BACK, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, dAccEnd, '', b3Raw, true)
+               if not bOk then return false, sErr end
+            end
+         end
+         -- eseguo i tagli necessari
          for i = nCuts, 1, -1 do
             local dCutOffset = ( i - 1) * dOffsL
-            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_BACK, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, dAccEnd, '', b3Raw, true)
+            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, nOrthoOpposite, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, dAccEnd, '', b3Raw)
+            if not bOk then return false, sErr end
+         end
+      -- altrimenti necessari tagli da sopra e sotto con testa opportuna
+      else
+         -- verifico esistenza della lavorazione con lama da sotto
+         if not sCutting2 then
+            local sErr = 'Error : cutting H2 not found in library'
+            EgtOutLog( sErr)
+            return false, sErr
+         end
+         -- verifico che le due lame riescano a lavorare la sezione
+         local dDimZ = b3Raw:getDimZ()
+         local dExtra = dMaxVertDepth + dMaxDepth2 - dDimZ
+         if dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0 then
+            local sErr = 'Error : section too big for head cut'
+            EgtOutLog( sErr)
+            return false, sErr
+         end
+         -- calcolo extra taglio ed accorciamento
+         local dCutExtra = -dMaxDepth2 + dExtra / 2 + BD.CUT_EXTRA_MIN
+         local dCutExtra2 = -dMaxVertDepth + dExtra / 2 + BD.CUT_EXTRA_MIN
+         local dAccStart = 0
+         local dVzLimDwnUp
+         if BD.TURN then dVzLimDwnUp = -2 end
+         -- eseguo i tagli da sotto necessari
+         for i = nCuts, 1, -1 do
+            local dCutOffset = ( i - 1) * dOffsL
+            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting2, dSawDiam2, MCH_MILL_FU.ORTHO_TOP, dVzLimDwnUp, dCutExtra2, BD.CUT_SIC, dCutOffset, dAccStart, 0, '', b3Raw)
+            if not bOk then return false, sErr end
+         end
+         -- eseguo i tagli da sopra necessari
+         for i = nCuts, 1, -1 do
+            local dCutOffset = ( i - 1) * dOffsL
+            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_DOWN, dVzLimDwnUp, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, 0, '', b3Raw)
             if not bOk then return false, sErr end
          end
-      end
-      -- eseguo i tagli necessari
-      for i = nCuts, 1, -1 do
-         local dCutOffset = ( i - 1) * dOffsL
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, nOrthoOpposite, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, dAccEnd, '', b3Raw)
-         if not bOk then return false, sErr end
-      end
-   -- altrimenti necessari tagli da sopra e sotto con testa opportuna
-   else
-      -- verifico esistenza della lavorazione con lama da sotto
-      if not sCutting2 then
-         local sErr = 'Error : cutting H2 not found in library'
-         EgtOutLog( sErr)
-         return false, sErr
-      end
-      -- verifico che le due lame riescano a lavorare la sezione
-      local dDimZ = b3Raw:getDimZ()
-      local dExtra = dMaxVertDepth + dMaxDepth2 - dDimZ
-      if dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0 then
-         local sErr = 'Error : section too big for head cut'
-         EgtOutLog( sErr)
-         return false, sErr
-      end
-      -- calcolo extra taglio ed accorciamento
-      local dCutExtra = -dMaxDepth2 + dExtra / 2 + BD.CUT_EXTRA_MIN
-      local dCutExtra2 = -dMaxVertDepth + dExtra / 2 + BD.CUT_EXTRA_MIN
-      local dAccStart = 0
-      local dVzLimDwnUp
-      if BD.TURN then dVzLimDwnUp = -2 end
-      -- eseguo i tagli da sotto necessari
-      for i = nCuts, 1, -1 do
-         local dCutOffset = ( i - 1) * dOffsL
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting2, dSawDiam2, MCH_MILL_FU.ORTHO_TOP, dVzLimDwnUp, dCutExtra2, BD.CUT_SIC, dCutOffset, dAccStart, 0, '', b3Raw)
-         if not bOk then return false, sErr end
-      end
-      -- eseguo i tagli da sopra necessari
-      for i = nCuts, 1, -1 do
-         local dCutOffset = ( i - 1) * dOffsL
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_DOWN, dVzLimDwnUp, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, 0, '', b3Raw)
-         if not bOk then return false, sErr end
       end
    end
    return true

LuaLibs/ProcessLapJoint.lua

@@ -3097,7 +3097,7 @@ local function MakePocket( Proc, nPartId, ptPs, tvtN, nFaceRef, sMchFind, nUseRo
    local sWarn
    local dDepth = dElev
    if dElev > dMaxDepth + 10 * GEO.EPS_SMALL then
-      dDepth = dElev
+      dDepth = dMaxDepth - dElev
       EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
       dElev = dMaxDepth
       sWarn = 'Warning : elevation bigger than max tool depth'

LuaLibs/ProcessLongCut.lua

@@ -11,6 +11,7 @@
 -- 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).
+-- 2022/09/23 Modificato l'angolo per l'abilitazione della lama da sotto: ora interviene anche per facce verticali.
 
 -- Tabella per definizione modulo
 local ProcessLongCut = {}
@@ -436,8 +437,8 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
       if ( nSide == -1 or abs(nSide) == 2) and vtN:getZ() <= -0.5 then
          bCanUseUnderBlade = true
       end
-      -- se faccia da sotto o di lato ma con versore Z negativo abilito la lavorazione con lame mixate 
-      if ( nSide == -1 or abs(nSide) == 2) and vtN:getZ() <= -0.0175 then
+      -- se faccia da sotto o di lato ma con versore Z sotto l'orizzontale abilito la lavorazione con lame mixate 
+      if ( nSide == -1 or abs(nSide) == 2) and vtN:getZ() <= 0.0175 then
          bCanUseUnderBlade = true
       end
       -- se faccia da sopra o di lato ma con versore Z negativo verifico che abbia un angolo compatibile (28deg) per non avere extracorsa

LuaLibs/ProcessSplit.lua

@@ -4,6 +4,7 @@
 -- 2022/06/10 Per sezioni alte e larghe aggiunta gestione finitura in base a sovramateriale e a parametro Q05 dell' eventuale lavorazione sostituita.
 -- 2022/08/18 Aggiunta gestione macchine con testa da sotto con lama da sotto disabilitata.
 -- 2022/09/08 Migliorato verso di lavorazione in caso di DoubleCut
+-- 2022/09/26 Gestione dei tagli di lama (Horiz, double, etc.) estesa anche a BigSection 
 
 -- Tabella per definizione modulo
 local ProcessSplit = {}
@@ -279,9 +280,9 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
    local dDimYRef = EgtIf( b3Raw:getDimZ() < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL, dMaxDepth, abs( BD.MAX_DIM_HTCUT_HBEAM))
    local bBigSectionCut = ( b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) and
                           ( b3Raw:getDimZ() > EgtIf( BD.TURN, 2 * dMaxVertDepth,  dMaxVertDepth + dMaxDepth2) - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
-   local bHorizCut = ( not bBigSectionCut and ( b3Raw:getDimY() > b3Raw:getDimZ() + 10 * GEO.EPS_SMALL or BD.TURN) and ( b3Raw:getDimZ() < dMaxVertDepth - BD.CUT_EXTRA))
-   local bDoubleHorizCut = ( ( BD.DOWN_HEAD or BD.TURN) and not bBigSectionCut and not bHorizCut and b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
-   local bDoubleCut = ( not bBigSectionCut and not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA  + 10 * GEO.EPS_SMALL)
+   local bHorizCut = ( ( b3Raw:getDimY() > b3Raw:getDimZ() + 10 * GEO.EPS_SMALL or BD.TURN) and ( b3Raw:getDimZ() < dMaxVertDepth - BD.CUT_EXTRA))
+   local bDoubleHorizCut = ( ( BD.DOWN_HEAD or BD.TURN) and not bHorizCut and b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
+   local bDoubleCut = ( not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA  + 10 * GEO.EPS_SMALL)
    -- dati geometrici del taglio
    local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
    -- flag di lavorazione faccia
@@ -305,6 +306,7 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
    end
    -- se taglio per pezzi alti e larghi
    local nNewPhase = 0
+   local bFinishByBlade = not bBigSectionCut
    if bBigSectionCut then
       local bFinishingNeeded = false
       if bSplit then
@@ -381,12 +383,12 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
             sNotes = 'Precut;'
             sNotesFinal = 'Cut;'
          end
-         -- se finitura con lama
-         if not nOriId or EgtGetInfo( nOriId, 'Q05', 'i') == 1 or EgtGetInfo( nOriId, 'Q05', 'i') == 0 or not bSplit then
-            local bOk, sErr = Cut.Make( Proc, nNewPhase, nRawId, nPartId, dLenEndRaw, nil, false, true, b3Raw, sNotes, dCurrOvmT)
-            if not bOk then return bOk, sErr, nNewPhase end
+         local nQ05 = EgtGetInfo( nOriId or GDB_ID.NULL, 'Q05', 'i') or 0
+         -- se finitura con lama rimando ai casi standard
+         if nQ05 == 1 or nQ05 == 0 or not bSplit then
+            bFinishByBlade = true
          -- se finitura con truciolatore
-         elseif EgtGetInfo( nOriId, 'Q05', 'i') == 2 then
+         elseif nQ05 == 2 then
             local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
             if not b3Solid then
                local sErr = 'Error : part box not found'
@@ -406,86 +408,89 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
             EgtSetMachiningParam( MCH_MP.USERNOTES, sNotesFinal)
          end
       end
-   -- se tagli standard
-   elseif not bDoubleHorizCut then
-      -- calcolo extra taglio ed accorciamento
-      local dCutExtra = 0
-      local dAccStart = 0
-      local dAccEnd = 0
-      if b3Raw:getDimZ() < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL or b3Raw:getDimY() < 2 * BD.MAX_DIM_HTCUT_HBEAM + 10 * GEO.EPS_SMALL then
-         dCutExtra = EgtIf( bDoubleCut, - 0.5 * b3Raw:getDimY() + BD.CUT_EXTRA_MIN, BD.CUT_EXTRA)
-      else
-         dCutExtra = - ( b3Raw:getDimY() - dMaxDepth)
-         local dSawRad = dSawDiam / 2
-         local dKL = dSawRad - dMaxDepth + b3Raw:getDimY() / 2 + BD.CUT_EXTRA_MIN
-         if BD.C_SIMM then
-            dAccEnd = sqrt( dSawRad * dSawRad - dKL * dKL)
+   end
+   -- tagli standard con lama
+   if bFinishByBlade then
+      if not bDoubleHorizCut then
+         -- calcolo extra taglio ed accorciamento
+         local dCutExtra = 0
+         local dAccStart = 0
+         local dAccEnd = 0
+         if b3Raw:getDimZ() < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL or b3Raw:getDimY() < 2 * BD.MAX_DIM_HTCUT_HBEAM + 10 * GEO.EPS_SMALL then
+            dCutExtra = EgtIf( bDoubleCut, - 0.5 * b3Raw:getDimY() + BD.CUT_EXTRA_MIN, BD.CUT_EXTRA)
          else
-            dAccStart = sqrt( dSawRad * dSawRad - dKL * dKL)
+            dCutExtra = - ( b3Raw:getDimY() - dMaxDepth)
+            local dSawRad = dSawDiam / 2
+            local dKL = dSawRad - dMaxDepth + b3Raw:getDimY() / 2 + BD.CUT_EXTRA_MIN
+            if BD.C_SIMM then
+               dAccEnd = sqrt( dSawRad * dSawRad - dKL * dKL)
+            else
+               dAccStart = sqrt( dSawRad * dSawRad - dKL * dKL)
+            end
          end
-      end
-      -- se necessari tagli in doppio, eseguo gli opposti
-      if bDoubleCut then
+         -- se necessari tagli in doppio, eseguo gli opposti
+         if bDoubleCut then
+            for i = nCuts, 1, -1 do
+               local dCutOffset = ( i - 1) * dOffsL
+               local sNotes = EgtIf( bSplit, 'Presplit;', 'Precut;')
+               local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_FRONT, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, dAccEnd, sNotes, b3Raw, true)
+               if not bOk then return false, sErr end
+            end
+         end
+         -- eseguo i tagli necessari
+         for i = nCuts, 1, -1 do
+            local dCutOffset = ( i - 1) * dOffsL
+            local sNotes
+            if bSplit then
+               sNotes = EgtIf( i == 1, 'Split;', 'Presplit;')
+            else
+               sNotes = EgtIf( i == 1, 'Cut;', 'Precut;')
+            end
+            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, nOrthoOpposite, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, dAccEnd, sNotes, b3Raw)
+            if not bOk then return false, sErr end
+         end
+      -- altrimenti necessari tagli da sopra e sotto con testa opportuna
+      else
+         -- verifico esistenza della lavorazione con lama da sotto
+         if not sCutting2 then
+            local sErr = 'Error : cutting H2 not found in library'
+            EgtOutLog( sErr)
+            return false, sErr
+         end
+         -- verifico che le due lame riescano a lavorare la sezione
+         local dDimZ = b3Raw:getDimZ()
+         local dExtra = dMaxVertDepth + dMaxDepth2 - dDimZ
+         if dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0 then
+            local sErr = 'Error : section too big for tail cut'
+            EgtOutLog( sErr)
+            return false, sErr
+         end
+         -- calcolo extra taglio ed accorciamento
+         local dCutExtra = -dMaxDepth2 + dExtra / 2 + BD.CUT_EXTRA_MIN
+         local dCutExtra2 = -dMaxVertDepth + dExtra / 2 + BD.CUT_EXTRA_MIN
+         local dAccStart = 0
+         -- limiti da sotto
+         local dVzLimDwnUp
+         if BD.TURN then dVzLimDwnUp = -2 end
+         -- eseguo i tagli da sotto necessari
          for i = nCuts, 1, -1 do
             local dCutOffset = ( i - 1) * dOffsL
             local sNotes = EgtIf( bSplit, 'Presplit;', 'Precut;')
-            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_FRONT, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, dAccEnd, sNotes, b3Raw, true)
+            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting2, dSawDiam2, MCH_MILL_FU.ORTHO_TOP, dVzLimDwnUp, dCutExtra2, BD.CUT_SIC, dCutOffset, dAccStart, 0, sNotes, b3Raw)
             if not bOk then return false, sErr end
          end
-      end
-      -- eseguo i tagli necessari
-      for i = nCuts, 1, -1 do
-         local dCutOffset = ( i - 1) * dOffsL
-         local sNotes
-         if bSplit then
-            sNotes = EgtIf( i == 1, 'Split;', 'Presplit;')
-         else
-            sNotes = EgtIf( i == 1, 'Cut;', 'Precut;')
+         -- eseguo i tagli da sopra necessari
+         for i = nCuts, 1, -1 do
+            local dCutOffset = ( i - 1) * dOffsL
+            local sNotes
+            if bSplit then
+               sNotes = EgtIf( i == 1, 'Split;', 'Presplit;')
+            else
+               sNotes = EgtIf( i == 1, 'Cut;', 'Precut;')
+            end
+            local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_DOWN, dVzLimDwnUp, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, 0, sNotes, b3Raw)
+            if not bOk then return false, sErr end
          end
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, nOrthoOpposite, nil, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, dAccEnd, sNotes, b3Raw)
-         if not bOk then return false, sErr end
-      end
-   -- altrimenti necessari tagli da sopra e sotto con testa opportuna
-   else
-      -- verifico esistenza della lavorazione con lama da sotto
-      if not sCutting2 then
-         local sErr = 'Error : cutting H2 not found in library'
-         EgtOutLog( sErr)
-         return false, sErr
-      end
-      -- verifico che le due lame riescano a lavorare la sezione
-      local dDimZ = b3Raw:getDimZ()
-      local dExtra = dMaxVertDepth + dMaxDepth2 - dDimZ
-      if dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0 then
-         local sErr = 'Error : section too big for tail cut'
-         EgtOutLog( sErr)
-         return false, sErr
-      end
-      -- calcolo extra taglio ed accorciamento
-      local dCutExtra = -dMaxDepth2 + dExtra / 2 + BD.CUT_EXTRA_MIN
-      local dCutExtra2 = -dMaxVertDepth + dExtra / 2 + BD.CUT_EXTRA_MIN
-      local dAccStart = 0
-      -- limiti da sotto
-      local dVzLimDwnUp
-      if BD.TURN then dVzLimDwnUp = -2 end
-      -- eseguo i tagli da sotto necessari
-      for i = nCuts, 1, -1 do
-         local dCutOffset = ( i - 1) * dOffsL
-         local sNotes = EgtIf( bSplit, 'Presplit;', 'Precut;')
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting2, dSawDiam2, MCH_MILL_FU.ORTHO_TOP, dVzLimDwnUp, dCutExtra2, BD.CUT_SIC, dCutOffset, dAccStart, 0, sNotes, b3Raw)
-         if not bOk then return false, sErr end
-      end
-      -- eseguo i tagli da sopra necessari
-      for i = nCuts, 1, -1 do
-         local dCutOffset = ( i - 1) * dOffsL
-         local sNotes
-         if bSplit then
-            sNotes = EgtIf( i == 1, 'Split;', 'Presplit;')
-         else
-            sNotes = EgtIf( i == 1, 'Cut;', 'Precut;')
-         end
-         local bOk, sErr = Fbs.MakeOne( Proc.Id, 0, sCutting, dSawDiam, MCH_MILL_FU.ORTHO_DOWN, dVzLimDwnUp, dCutExtra, BD.CUT_SIC, dCutOffset, dAccStart, 0, sNotes, b3Raw)
-         if not bOk then return false, sErr end
       end
    end
    return true, nil, nNewPhase

LuaLibs/ProcessTenon.lua

@@ -4,6 +4,7 @@
 -- 2022/02/15 Aggiornata VerifyOrientation per macchine con testa da sotto.
 -- 2022/05/18 Migliorata gestione attacco.
 -- 2022/05/28 Spostato calcolo svuotatura in modulo di libreria.
+-- 2022/09/20 Migliorato il calcolo delle passate laterali; ora considera la reale distanza tra contorno del tenone e estremi della faccia
 
 -- Tabella per definizione modulo
 local ProcessTenon = {}
@@ -120,11 +121,32 @@ function ProcessTenon.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
    local vtN = vtExtr
    local ptC = ptBC + vtN * dTenH
    EgtOutLog( 'ptC=' .. tostring( ptC) ..' vtN=' .. tostring( vtN), 3)
-   -- determino larghezza massima di svuotatura
-   local b3Aux = EgtGetBBoxRef( AuxId, GDB_BB.STANDARD, frTen)
-   local dPockX = max( b3Ten:getMax():getX() - b3Aux:getMax():getX(), b3Aux:getMin():getX() - b3Ten:getMin():getX())
-   local dPockY = max( b3Ten:getMax():getY() - b3Aux:getMax():getY(), b3Aux:getMin():getY() - b3Ten:getMin():getY())
-   local dPockL = sqrt( dPockX * dPockX + dPockY * dPockY)
+   -- determino larghezza svuotatura per calcolare il numero di passate laterali
+   -- ricavo i contorni della faccia principale
+   local nLoopId, nLoopCnt = EgtExtractSurfTmFacetLoops( Proc.Id, 0, EgtGetParent( Proc.Id))
+   local dPockL = 0
+   -- ricavo la massima distanza tra gli estremi della faccia e la curva del tenone
+   if nLoopId then
+      local dUmin, dUmax = EgtCurveDomain( nLoopId)
+      for dU = dUmin, dUmax do
+         local ptP = EgtUP( nLoopId, dU, GDB_ID.ROOT)
+         local ptNear = EgtNP( AuxId, ptP, GDB_ID.ROOT)
+         local dDist = dist( ptP, ptNear)
+         if dDist > dPockL then
+            dPockL = dDist
+         end
+      end
+      -- cancello i contorni dopo averli analizzati
+      for i = 1, nLoopCnt do
+         EgtErase( nLoopId + i - 1)
+      end
+   else
+      -- se il metodo sopra non funziona uso il metodo semplice (distanza tra gli angoli retti della curva tenone e faccia principale)
+      local b3Aux = EgtGetBBoxRef( AuxId, GDB_BB.STANDARD, frTen)
+      local dPockX = max( b3Ten:getMax():getX() - b3Aux:getMax():getX(), b3Aux:getMin():getX() - b3Ten:getMin():getX())
+      local dPockY = max( b3Ten:getMax():getY() - b3Aux:getMax():getY(), b3Aux:getMin():getY() - b3Ten:getMin():getY())
+      dPockL = sqrt( dPockX * dPockX + dPockY * dPockY)
+   end
    -- abilitazione lavorazione da sotto
    local bMillUp = ( BD.DOWN_HEAD and vtExtr:getZ() > -0.259)
    local bMillDown = ( BD.DOWN_HEAD and vtExtr:getZ() < 0.1)