Feature/FindMirroredFeatures:

- lieve bugfix

LuaLibs/BeamExec.lua

@@ -39,6 +39,8 @@
 -- 2022/09/29 Aggiunta la ricerca di feature specchiate, al momento solo per DtMortise, con le relative funzioni.
 -- 2022/12/23 Corrette rotazioni 90 deg per macchine con carico da destra.
 -- 2022/12/28 Implementata gestione forature e code di rondine in doppio.
+-- 2023/01/31 Implementata gestione mortase in doppio.
+-- 2023/01/31 Nelle lavorazioni in doppio aggiunta la minima distanza tra le feature.
 
 
 -- Tabella per definizione modulo
@@ -1378,14 +1380,15 @@ local function MoveDrillsOnTenon( vProc)
 end
 
 -------------------------------------------------------------------------------------------------------------
--- Controlla se la feature ProcMirror è la specchiata di Proc, per feature di tipo DtMortise
+-- Controlla se la feature ProcMirror è la specchiata di Proc, per feature di tipo tasca o simile
-local function CheckMirrorDtMortise( Proc, ProcMirror, b3Raw, AuxId)
+local function CheckMirrorPocket( Proc, ProcMirror, b3Raw, AuxId)
    
    -- recupero i dati geometrici della curva Proc
    local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
    local ptBC = EgtGP( AuxId, GDB_RT.GLOB)
    local rfDtMrt = EgtSurfTmFacetMinAreaRectangle( Proc.Id, 0, GDB_RT.GLOB) 
    local b3DtMrt = EgtGetBBoxRef( Proc.Id, GDB_BB.STANDARD, rfDtMrt)
+   local b3Proc = EgtGetBBoxGlob( Proc.Id, GDB_BB.STANDARD)
    -- determino l'asse della curva Proc
    local vtAx = EgtEV( AuxId, GDB_RT.GLOB) - EgtSV( AuxId, GDB_RT.GLOB)
    
@@ -1395,10 +1398,15 @@ local function CheckMirrorDtMortise( Proc, ProcMirror, b3Raw, AuxId)
    if not AuxIdMirror or ( EgtGetType( AuxIdMirror) & GDB_FY.GEO_CURVE) == 0 then
       return false
    end
+   -- se Mortise, se curva di contorno aperta la rendo chiusa
+   if Mortise.SideIdentify( ProcMirror) then
+      BL.ConvertToClosedCurve( ProcMirror, AuxIdMirror)
+   end
    -- recupero i dati geometrici della curva ProcMirror
    local vtExtrMirror = EgtCurveExtrusion( AuxIdMirror, GDB_RT.GLOB)
    local ptBCMirror = EgtGP( AuxIdMirror, GDB_RT.GLOB)
    local b3DtMrtMirror = EgtGetBBoxRef( ProcMirror.Id, GDB_BB.STANDARD, rfDtMrt)
+   local b3ProcMirror = EgtGetBBoxGlob( ProcMirror.Id, GDB_BB.STANDARD)
    -- determino l'asse della curva ProcMirror
    local vtAxMirror = EgtEV( AuxIdMirror, GDB_RT.GLOB) - EgtSV( AuxIdMirror, GDB_RT.GLOB)
    
@@ -1406,13 +1414,19 @@ local function CheckMirrorDtMortise( Proc, ProcMirror, b3Raw, AuxId)
    local bIsMirror = true
    local vtDisplacement = ptBC - ptBCMirror
    local ptCenRaw = b3Raw:getCenter()
-   -- controllo che il centro delle due mortase sia allineato e che queste siano equidistanti dalla mezzeria della trave
+   local dYMinDistance = EgtIf( ptBC:getY() > ptBCMirror:getY(), abs( b3ProcMirror:getMax():getY() - b3Proc:getMin():getY()), abs( b3Proc:getMax():getY() - b3ProcMirror:getMin():getY()))
+   local dZMinDistance = EgtIf( ptBC:getZ() > ptBCMirror:getZ(), abs( b3ProcMirror:getMax():getZ() - b3Proc:getMin():getZ()), abs( b3Proc:getMax():getZ() - b3ProcMirror:getMin():getZ()))
+   local dMinimumDistanceMirroredFeatures = 60
+   -- controllo che il centro delle due mortase sia allineato, che queste siano equidistanti dalla mezzeria della trave
+   -- e che queste non siano troppo vicine
    if AreSameOrOppositeVectorApprox( vtExtr, Y_AX()) then
       bIsMirror = abs( vtDisplacement:getX()) < 500 * GEO.EPS_SMALL and abs( vtDisplacement:getZ()) < 500 * GEO.EPS_SMALL and 
-                  ( abs( ptBC:getY() - ptCenRaw:getY()) - abs( ptBCMirror:getY() - ptCenRaw:getY())) < 500 * GEO.EPS_SMALL
+                  ( abs( ptBC:getY() - ptCenRaw:getY()) - abs( ptBCMirror:getY() - ptCenRaw:getY())) < 500 * GEO.EPS_SMALL and
+                  dYMinDistance - dMinimumDistanceMirroredFeatures > 10 * GEO.EPS_SMALL
    elseif AreSameOrOppositeVectorApprox( vtExtr, Z_AX()) then
       bIsMirror = abs( vtDisplacement:getX()) < 500 * GEO.EPS_SMALL and abs( vtDisplacement:getY()) < 500 * GEO.EPS_SMALL and 
-                  ( abs( ptBC:getZ() - ptCenRaw:getZ()) - abs( ptBCMirror:getZ() - ptCenRaw:getZ())) < 500 * GEO.EPS_SMALL
+                  ( abs( ptBC:getZ() - ptCenRaw:getZ()) - abs( ptBCMirror:getZ() - ptCenRaw:getZ())) < 500 * GEO.EPS_SMALL and
+                  dZMinDistance - dMinimumDistanceMirroredFeatures > 10 * GEO.EPS_SMALL
    end
    -- controllo che le dimensioni dei due box siano le stesse
    bIsMirror = bIsMirror and abs( b3DtMrt:getDimX() - b3DtMrtMirror:getDimX()) < 500 * GEO.EPS_SMALL and 
@@ -1424,6 +1438,96 @@ local function CheckMirrorDtMortise( Proc, ProcMirror, b3Raw, AuxId)
    return bIsMirror
 end
 
+-------------------------------------------------------------------------------------------------------------
+-- Verifica se Proc (mortasa) è lavorabile in doppio e nel caso ne imposta i dati.
+local function VerifyMortiseMirrored( Proc, vProc, b3Raw)
+   -- recupero e verifico l'entità curva
+   local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i')
+   if AuxId then 
+      AuxId = AuxId + Proc.Id
+   end
+   if not AuxId  or  ( EgtGetType( AuxId) & GDB_FY.GEO_CURVE) == 0 then
+      local sErr = 'Error : missing profile geometry'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- recupero versore estrusione della curva supplementare
+   local vtExtr = EgtCurveExtrusion( AuxId, GDB_ID.ROOT)
+   -- Se curva di contorno aperta la converto in curva chiusa
+   BL.ConvertToClosedCurve( Proc, AuxId)
+   -- recupero i dati della faccia di fondo
+   local frMor, dL, dW = EgtSurfTmFacetMinAreaRectangle( Proc.Id, 0, GDB_ID.ROOT)
+   -- determino larghezza della mortasa
+   if dL < dW then dL, dW = dW, dL end
+   local ptC = ORIG()
+   local vtN = V_NULL()
+   if frMor then
+      ptC = frMor:getOrigin()
+      vtN = frMor:getVersZ()
+   end
+   -- se mortasa passante esco
+   local bOpenBtm = not AreSameVectorApprox( vtExtr, vtN)
+   if bOpenBtm then
+      return
+   end
+   -- determino altezza della mortasa
+   local b3Mor = EgtGetBBoxRef( Proc.Id, GDB_BB.STANDARD, frMor) 
+   local dMorH = b3Mor:getDimZ()
+   -- elevazione del punto centrale
+   local _, dCenElev = BL.GetPointDirDepth( nPartId, ptC, vtN)
+   dMorH = max( dMorH, dCenElev or 0)
+   -- recupero lavorazione adatta
+   local sPockType = 'Mortise'
+   local sPocketing
+   if Proc.Prc ~= 53 then
+      sPocketing = Mortise.VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType, false)
+   end
+   if not sPocketing then
+      sPockType = 'Pocket'
+      sPocketing = Mortise.VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType, false)
+   end
+   if not sPocketing or not EgtMdbSetCurrMachining( sPocketing) then
+      return
+   end
+   -- recupero il suo utensile
+   if not EgtTdbSetCurrTool( EgtMdbGetCurrMachiningParam( MCH_MP.TOOL) or '') then
+      return
+   end
+   -- recupero eventuale utensile in doppio e suo diametro
+   local sToolDoubleName = EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'DOUBLE', 's')
+   if not sToolDoubleName or not EgtTdbSetCurrTool( sToolDoubleName) or not EgtTdbGetCurrToolParam( MCH_TP.ACTIVE) then
+      return
+   end
+   local dToolDoubleDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM, 'd')
+   -- verifico se possibile in doppio (diametro utensile e direzione feature)
+   if dToolDoubleDiam < dW + GEO.EPS_SMALL and ( AreSameOrOppositeVectorApprox( vtExtr, Y_AX()) or AreSameVectorApprox( vtExtr, Z_AX())) then
+      for i = 1, #vProc do
+         local ProcMirror = vProc[i]
+         if Mortise.SideIdentify( ProcMirror) and ProcMirror.Id ~= Proc.Id and ProcMirror.Flg ~= 0 then
+            if CheckMirrorPocket( Proc, ProcMirror, b3Raw, AuxId) then
+               if ( not BD.DOWN_HEAD and AreSameVectorApprox( vtExtr, Y_AX())) or
+                  ( BD.DOWN_HEAD and AreOppositeVectorApprox( vtExtr, Y_AX())) then
+                  Proc.Double = 2
+                  Proc.MirrorId = ProcMirror.Id
+                  Proc.MirrorCutId = ProcMirror.CutId
+                  Proc.MirrorTaskId = ProcMirror.TaskId
+                  ProcMirror.Flg = 0
+                  ProcMirror.Double = 0
+               elseif BD.DOWN_HEAD and AreSameVectorApprox( vtExtr, Z_AX()) then
+                  Proc.Double = 3
+                  Proc.MirrorId = ProcMirror.Id
+                  Proc.MirrorCutId = ProcMirror.CutId
+                  Proc.MirrorTaskId = ProcMirror.TaskId
+                  ProcMirror.Flg = 0
+                  ProcMirror.Double = 0
+               end
+               break
+            end
+         end
+      end
+   end
+end
+
 -------------------------------------------------------------------------------------------------------------
 -- Verifica se Proc (mortasa a coda di rondine) è lavorabile in doppio e nel caso ne imposta i dati.
 local function VerifyDtMortiseMirrored( Proc, vProc, b3Raw)
@@ -1464,12 +1568,12 @@ local function VerifyDtMortiseMirrored( Proc, vProc, b3Raw)
       return
    end
    local dToolDoubleDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM, 'd')
-   -- verifico se possibile in doppio (diametro utensile e direzione feaure)
+   -- verifico se possibile in doppio (diametro utensile e direzione feature)
    if dToolDoubleDiam < dMaxDiam + GEO.EPS_SMALL and ( AreSameOrOppositeVectorApprox( vtExtr, Y_AX()) or AreSameVectorApprox( vtExtr, Z_AX())) then
       for i = 1, #vProc do
          local ProcMirror = vProc[i]
          if DtMortise.SideIdentify( ProcMirror) and ProcMirror.Id ~= Proc.Id and ProcMirror.Flg ~= 0 then
-            if CheckMirrorDtMortise( Proc, ProcMirror, b3Raw, AuxId) then
+            if CheckMirrorPocket( Proc, ProcMirror, b3Raw, AuxId) then
                if ( not BD.DOWN_HEAD and AreSameVectorApprox( vtExtr, Y_AX())) or
                   ( BD.DOWN_HEAD and AreOppositeVectorApprox( vtExtr, Y_AX())) then
                   Proc.Double = 2
@@ -1532,10 +1636,13 @@ local function VerifyDrillMirrored( Proc, vProc, b3Raw)
    if not sDrilling or sType ~= 'Drill' or not EgtMdbSetCurrMachining( sDrilling) then
       return
    end
+   local dDrillingStep = EgtMdbGetCurrMachiningParam( MCH_MP.STEP)
    -- recupero il suo utensile
    if not EgtTdbSetCurrTool( EgtMdbGetCurrMachiningParam( MCH_MP.TOOL) or '') then
       return
    end
+   -- recupero la lunghezza della parte inclinata della punta
+   local dToolTipLength = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) - EgtTdbGetCurrToolParam( MCH_TP.LEN)
    -- recupero eventuale utensile in doppio, suo diametro e massima lavorazione
    local sToolDoubleName = EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'DOUBLE', 's')
    if not sToolDoubleName or not EgtTdbSetCurrTool( sToolDoubleName) or not EgtTdbGetCurrToolParam( MCH_TP.ACTIVE) then
@@ -1543,9 +1650,13 @@ local function VerifyDrillMirrored( Proc, vProc, b3Raw)
    end
    local dToolDoubleDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM, 'd')
    local dToolDoubleMaxDepth = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT)
+   -- recupero la lunghezza della parte inclinata della punta
+   local dToolDoubleTipLength = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) - EgtTdbGetCurrToolParam( MCH_TP.LEN)
    -- verifico se in doppio
+   local dMinimumDistanceMirroredFeatures = 40
    dMachiningDepth = min( dMachiningDepth, dToolDoubleMaxDepth)
-   if abs( Proc.Flg) == 2 and dToolDoubleDiam < dDiam + 10 * GEO.EPS_SMALL and dToolDoubleDiam > dDiam - BD.DRILL_TOL - 10 * GEO.EPS_SMALL then
+   if abs( Proc.Flg) == 2 and dToolDoubleDiam < dDiam + 10 * GEO.EPS_SMALL and dToolDoubleDiam > dDiam - BD.DRILL_TOL - 10 * GEO.EPS_SMALL and
+   (( 2 * dDrillingStep - dToolTipLength - dToolDoubleTipLength) - dMinimumDistanceMirroredFeatures) > 10 * GEO.EPS_SMALL then
       if Proc.Fce ~= 0 then
          if Proc.Flg == -2 then vtExtr = -vtExtr end
          if ( not BD.DOWN_HEAD and AreSameVectorApprox( vtExtr, Y_AX())) or
@@ -1572,6 +1683,8 @@ local function SetMirroredFeatures( vProc, b3Raw)
          -- Proc.MirrorId -> Id della feature mirrorata
          if DtMortise.SideIdentify( Proc) and BD.DOUBLE_HEAD_DOVETAIL then
             VerifyDtMortiseMirrored( Proc, vProc, b3Raw)
+         elseif Mortise.SideIdentify( Proc) and BD.DOUBLE_HEAD_MORTISE then
+            VerifyMortiseMirrored( Proc, vProc, b3Raw)
          elseif Drill.Identify( Proc) and BD.DOUBLE_HEAD_DRILLING then
             VerifyDrillMirrored( Proc, vProc, b3Raw)
          end

LuaLibs/BeamLib.lua

@@ -1,4 +1,4 @@
--- BeamLib.lua by Egaltech s.r.l. 2022/07/12
+-- BeamLib.lua by Egaltech s.r.l. 2023/01/20
 -- 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.
@@ -18,6 +18,8 @@
 -- 2022/07/26 Alla funzione FindFaceBestOrientedAsAxis aggiunta la possibilità di escludere una faccia dalla ricerca
 -- 2022/09/01 Aggiunte le funzioni GetTunnelDimension, CalcCollisionSafety, SetOpenSide, precedentemente in ProcessLapJoint.
 -- 2023/01/10 In GetFaceWithMostAdj aggiunta verifica che la feature abbia almeno una faccia aperta.
+-- 2023/01/20 Modificata PutStartNearestToEdge per gestire lato preferito come Y+, Y-, z*, Z-. Aggiunta funzione GetDistanceToNextPart.
+-- 2023/01/31 Aggiunta funzione ConvertToClosedCurve, precedentemente parte di ProcessMortise.Make
 
 -- Tabella per definizione modulo
 local BeamLib = {}
@@ -195,7 +197,8 @@ function BeamLib.PutStartOnLonger( nCrvId)
 end
 
 -------------------------------------------------------------------------------------------------------------
-function BeamLib.PutStartNearestToEdge( nCrvId, b3Raw, dMaxDist, bDown)
+-- nNearSide : 2=Y+, -2=Y-, 3=Z+, -3=Z- 
+function BeamLib.PutStartNearestToEdge( nCrvId, b3Raw, dMaxDist, nNearSide)
    -- verifico che la curva sia chiusa
    if not EgtCurveIsClosed( nCrvId) then return false end
    -- recupero il versore normale al piano di lavoro o estrusione
@@ -208,7 +211,7 @@ function BeamLib.PutStartNearestToEdge( nCrvId, b3Raw, dMaxDist, bDown)
    -- cerco l'estremo più vicino al box e lo imposto come inizio (se da sotto escludo Zmax e viceversa)
    local dUopt = 0
    local dDopt = GEO.INFINITO
-   local dZopt = GEO.INFINITO
+   local dSopt = GEO.INFINITO
    local dUi, dUf = EgtCurveDomain( nCrvId)
    for dU = dUi, dUf, 0.5 do
       local ptP = EgtUP( nCrvId, dU, GDB_ID.ROOT)
@@ -222,11 +225,20 @@ function BeamLib.PutStartNearestToEdge( nCrvId, b3Raw, dMaxDist, bDown)
          dD = min( abs( vtMax:getY()) * dCoeffY, dD)
          dD = min( abs( vtMin:getZ()) * dCoeffZ, dD)
          dD = min( abs( vtMax:getZ()) * dCoeffZ, dD)
-         local dZ = abs( EgtIf( bDown, vtMin:getZ(), vtMax:getZ())) * dCoeffZ
+         local dS
-         if dD < dMaxDist and dZ < dZopt + GEO.EPS_SMALL then
+         if nNearSide == -2 then
+            dS = abs( vtMin:getY() * dCoeffY)
+         elseif nNearSide == 2 then
+            dS = abs( vtMax:getY() * dCoeffY)
+         elseif nNearSide == -3 then
+            dS = abs( vtMin:getZ() * dCoeffZ)
+         else  --nNearSide == 3
+            dS = abs( vtMax:getZ() * dCoeffZ)
+         end
+         if dD < dMaxDist and dS < dSopt + GEO.EPS_SMALL then
             dUopt = dU
             dDopt = dD
-            dZopt = dZ
+            dSopt = dS
          end
       end
    end
@@ -774,6 +786,22 @@ function BeamLib.GetPhaseType( nPhase)
    return ( EgtGetInfo( EgtGetPhaseDisposition( nPhase) or GDB_ID.NULL, 'TYPE') or '')
 end
 
+---------------------------------------------------------------------
+function BeamLib.GetDistanceToNextPart( nRawId, nPhase)
+   -- Recupero la distanza tra la fine del pezzo e il pezzo successivo
+   local dDistToNextPiece = EgtGetInfo( nRawId, 'BDST', 'd') or BD.OVM_MID
+   -- se segue una parte rimanente riutilizzabile, modifico opportunamente questa distanza
+   if not BeamLib.IsSplittedPartPhase( nPhase) then
+      local nNextRawId = EgtGetNextRawPart( nRawId)
+      if  nNextRawId and 
+          EgtGetPartInRawPartCount( nNextRawId) <= 0 and 
+          EgtGetRawPartBBox( nNextRawId):getDimX() >= BD.MinRaw then
+         dDistToNextPiece = BD.OVM_MID
+      end
+   end
+   return dDistToNextPiece
+end
+
 ---------------------------------------------------------------------
 function BeamLib.GetChainSawBlockedAxis( nInd)
    if BD.GetChainSawBlockedAxis then
@@ -1054,5 +1082,41 @@ function BeamLib.SetOpenSide( nPathInt, vtOrtho, b3Solid, nAddGrpId, nStartPoint
    return false
 end
 
+-------------------------------------------------------------------------------------------------------------
+function BeamLib.ConvertToClosedCurve( Proc, AuxId)
+   local bCurveModified = false
+   if not EgtCurveIsClosed( AuxId) then
+      local NewId, nCount = EgtExtractSurfTmFacetLoops( Proc.Id, 0, EgtGetParent( Proc.Id))
+      if NewId then
+         -- elimino eventuali loop interni (non dovrebbero comunque esserci)
+         for i = 1, nCount - 1 do
+            EgtErase( NewId + i)
+         end
+         local vtExtr = EgtCurveExtrusion( AuxId, GDB_ID.ROOT)
+         -- sostituisco il loop esterno alla curva originale
+         EgtModifyCurveExtrusion( NewId, vtExtr, GDB_ID.ROOT)
+         EgtRelocate( NewId, AuxId, GDB_IN.AFTER)
+         EgtErase( AuxId)
+         EgtChangeId( NewId, AuxId)
+         bCurveModified = true
+         -- sistemo i lati aperti
+         local vFacAdj = EgtSurfTmFacetAdjacencies( Proc.Id, 0)[1]
+         if vFacAdj then
+            local sOpen = ''
+            for i = 1, #vFacAdj do
+               if vFacAdj[i] < 0 then
+                  sOpen = sOpen .. EgtIf( #sOpen > 0, ',', '') .. tostring( i - 1)
+               end
+            end
+            if #sOpen > 0 then
+               EgtSetInfo( AuxId, 'OPEN', sOpen)
+            end
+         end
+      end
+   end
+   
+   return true, bCurveModified
+end
+
 -------------------------------------------------------------------------------------------------------------
 return BeamLib

LuaLibs/MachiningLib.lua

@@ -5,6 +5,7 @@
 -- 2022/11/02 Modificata scelta utensile ottimizzata. Ora se c'è un utensile più grande disponibile si dà preferenza a quello.
 -- 2022/11/25 Per FindMilling implementata la possibilità di escludere la testa H3 dalla ricerca utensile.
 -- 2022/12/28 Per FindMilling e FindDrilling possibilità di escludere la testa H2 dalla ricerca utensile.
+-- 2023/01/31 Per FindPocketing implementata la possibilità di escludere le teste H2 o H3 dalla ricerca utensile.
 
 -- Tabella per definizione modulo
 local MachiningLib = {}
@@ -241,6 +242,10 @@ local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead,
       bExcludeH3 = false
    end
    SetCurrMachineHeadType()
+   -- verifico se non richiesta testa sopra e macchina ha solo teste sopra
+   if not bTopHead and MachineHeadType ~= TWO_UP_DOWN_HEADS and not BD.TURN then
+      return nil
+   end
    -- verifico se testa attiva va bene
    local sH1Mach = ''
    local sH1Tool = ''
@@ -398,8 +403,8 @@ function MachiningLib.FindMilling( sType, dDepth, sTuuidMstr, dMaxDiam, dMaxTotL
 end
 
 ---------------------------------------------------------------------
-function MachiningLib.FindPocketing( sType, dMaxDiam, dDepth, dMaxTotLen, bTopHead, bDownHead)
+function MachiningLib.FindPocketing( sType, dMaxDiam, dDepth, dMaxTotLen, bTopHead, bDownHead, bExcludeH2, bExcludeH3)
-   return FindMachining( MCH_MY.POCKETING, sType, { MaxDiam = dMaxDiam, Depth = dDepth, MaxTotLen = dMaxTotLen}, bTopHead, bDownHead)
+   return FindMachining( MCH_MY.POCKETING, sType, { MaxDiam = dMaxDiam, Depth = dDepth, MaxTotLen = dMaxTotLen}, bTopHead, bDownHead, bExcludeH2, bExcludeH3)
 end
 
 ---------------------------------------------------------------------

LuaLibs/ProcessCut.lua

@@ -17,6 +17,7 @@
 -- 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.
+-- 2023/01/26 Migliorata la direzione di lavoro della lama in alcuni casi in cui il truciolo veniva scaricato dal lato errato.
 
 -- Tabella per definizione modulo
 local ProcessCut = {}
@@ -522,8 +523,10 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
             vtOrthoO = -X_AX()
          end
       else
-         if vtN:getZ() < dVzLimDwnUp or Proc.Head or Proc.Tail then
+         if vtN:getZ() < dVzLimDwnUp or Proc.Tail or ( Proc.Head and abs( vtN:getY()) > 0.01) then
             vtOrthoO = EgtIf( vtN:getY() > -0.02, -Y_AX(), Y_AX())
+         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())
          end

LuaLibs/ProcessDtMortise.lua

@@ -8,6 +8,7 @@
 -- 2022/06/01 Modifiche per evitare di entrare nel legno con mortase parziali.
 -- 2022/08/18 Migliorato calcolo dello step.
 -- 2022/09/29 Aggiunto riconoscimento della sola feature laterale.
+-- 2022/12/28 Aggiunta gestione lavorazione in doppio.
 
 -- Tabella per definizione modulo
 local ProcessDtMortise = {}
@@ -237,6 +238,7 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
       bMillUp = true
       bMillDown = false
       bExcludeH2 = true
+      sMchExt = ''
    end
    -- recupero la lavorazione : prima ricerca per sola tipologia
    local sMilling = ML.FindMilling( sMillType..sMchExt, nil, nil, nil, nil, bMillUp, bMillDown, bExcludeH2)

LuaLibs/ProcessLapJoint.lua

@@ -59,7 +59,8 @@
 -- 2022/12/12 Default 1000 per BD.MIN_LEN_LAMELLO. In MachineByMill migliorata ricerca utensile e gestione inversione in funzione del lato di lavoro.
 -- 2022/12/16 Implementato parametro Q_SIDE_ROUGH_TOOL anche per L20
 -- 2022/12/21 Sistemata gestione SideMillAsSaw.
--- 2022/01/19 In MakeMoreFaces -> MakeBySideMill aggiunto controllo che lo step finale non superi lo spessore utensile.
+-- 2023/01/19 In MakeMoreFaces -> MakeBySideMill aggiunto controllo che lo step finale non superi lo spessore utensile.
+-- 2023/01/24 In MakeByPocket gestito caso il caso in cui veniva applicata una fresatura con percorso vuoto. Ora viene rimossa e la tasca viene fatta con lama.
 
 -- Tabella per definizione modulo
 local ProcessLapJoint = {}
@@ -2499,7 +2500,7 @@ local function MakeByMillAsSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
    -- 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.
+   local dDistToNextPiece = BL.GetDistanceToNextPart( nRawId, nPhase)
    -- verifico definizione faccia con il maggior numero di adiacenze
    if not nFacInd then
       local sErr = 'Error : MakeByMillAsSaw could not find reference face'
@@ -2643,7 +2644,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
    -- 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
+   local dDistToNextPiece = BL.GetDistanceToNextPart( nRawId, nPhase)
    -- verifico se fessura con 3 facce o tunnel
    local bOrthoFaces
    local bIs3Faces = ( Proc.Fct == 3)
@@ -3683,13 +3684,17 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
             sNotes = sNotes .. 'VMRS=0;'
             EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
             -- eseguo
-            if not ML.ApplyMachining( true, false) then
+            if not ML.ApplyMachining( true, false) or EgtIsMachiningEmpty() then
                -- provo ad allargare leggermente la tasca
                EgtSetMachiningParam( MCH_MP.OFFSR, -0.1)
                if not ML.ApplyMachining( true, false) then
                   local _, sErr = EgtGetLastMachMgrError()
                   EgtSetOperationMode( nMchFId, false)
                   return -1, sErr
+               elseif EgtIsMachiningEmpty() then
+                  EgtRemoveOperation( nMchFId)
+                  local sErr = 'Impossible to machine (empty toolpath)'
+                  return -3, sErr
                end
             end
             -- se posso applicare la svuotatura sul lato opposto
@@ -4746,12 +4751,11 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
          -- verifico se lavorando la faccia principale rimane esclusa molta sezione trasversale complessiva della feature (da box)
          local rfFac, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd, GDB_ID.ROOT)
          local bBoxF = EgtGetBBoxRef( Proc.Id, GDB_BB.STANDARD, rfFac)
-         if dH * dV < 0.9 * ( bBoxF:getDimX() * bBoxF:getDimY()) then
+         if dH * dV < 0.9 * ( bBoxF:getDimX() * bBoxF:getDimY()) and nFacInd2 and dFacElev2 < 1.5 * dFacElev then
             bSpecial3faces = true
          end
-         -- se riconosciuta gestione 3 facce
+         -- se riconosciuta gestione 3 facce (limitatamente per ora alla feature 20)
-         -- e limitata per ora alla feature 20
+         if bSpecial3faces and Proc.Prc == 20 then
-         if bSpecial3faces and Proc.Prc == 20 and nFacInd2 then
             -- se smusso non è esclusivo
             if nChamfer < 2 then
                -- entrambe le facce non devono essere orientate verso il basso
@@ -4938,7 +4942,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                   end
                elseif Proc.Fct == 3 and bIsL then
                   -- per rifinire gli angoli premio utensile diam 25 o da BD
-                  dDiam = min( ( 2 * dDiam) - 1, BD.MAXDIAM_POCK_CORNER)
+                  dDiam = min( ( 2 * dDiam) + 10 * GEO.EPS_SMALL, BD.MAXDIAM_POCK_CORNER)
                else
                   dDiam = 2 * dDiam
                end
@@ -5239,7 +5243,9 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                            end
                            nOk, sErr, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, dDiamTool, bDoubleSide, nPathInt, nSurfInt, bOneShot, bMillDown, nFirstMachId, 
                            bOrthoFaces = MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCham, nAddGrpId, sMyMchFind, bIs3Faces, b3Solid, bOrthoFacesMaster, bMillDown, bSetOpenBorders, bIsU, bIsL)
-                           if nOk == -2 then
+                           if nOk == -3 then
+                              bTryWithBlades = true
+                           elseif nOk == -2 then
                               if not sMchFind then 
                                  sMchFind = sMchFindBackUp 
                               end
@@ -5475,7 +5481,7 @@ local function MakeLongMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead)
    -- recupero l'ingombro del grezzo di appartenenza
    local b3Raw = EgtGetRawPartBBox( nRawId)
    -- ottengo la distanza tra la fine del pezzo e il pezzo successivo
-   local dDistToNextPiece = EgtGetInfo( nRawId, 'BDST', 'd') or BD.OVM_MID
+   local dDistToNextPiece = BL.GetDistanceToNextPart( nRawId, nPhase)
    -- verifico se applicare gestione speciale delle giunzioni (U diretta come asse X)
    local bAddEndCap = false
    local dAddLen = 0

LuaLibs/ProcessLongCut.lua

@@ -1,4 +1,4 @@
--- ProcessLongCut.lua by Egaltech s.r.l. 2022/11/30
+-- ProcessLongCut.lua by Egaltech s.r.l. 2023/01/18
 -- Gestione calcolo taglio longitudinale per Travi
 -- 2021/02/03 Corretto FaceUse con fresa orizzontale su taglio orizzontale.
 -- 2021/05/18 Possibile taglio con lama anche di fianco su macchina con testa da sotto.
@@ -15,7 +15,10 @@
 -- 2022/11/04 Aggiunto passaggio parametro bDownHead (Testa da Sotto) nelle chiamate a MakeSideFace.
 -- 2022/11/28 Correzioni varie per attacco, pulizia spigoli, utilizzo H3
 -- 2022/11/30 Modifiche su SCC per TURN.
--- 2022/01/18 Aggiunta, se richiesta, una lavorazione ulteriore con sega a catena nei casi in cui la doppia lama non sia sufficiente.
+-- 2023/01/18 Aggiunta, se richiesta, una lavorazione ulteriore con sega a catena nei casi in cui la doppia lama non sia sufficiente.
+-- 2023/01/26 Rimossa la pulitura della faccia laterale nel caso in cui la feature abbia almeno una faccia rivolta verso il basso.
+-- 2023/01/27 In MakeSideFace il prolungamento di uscita è ora fissato a 10 mm.
+-- 2023/01/27 In caso di lavorazione aggiuntiva con fresa a catena il taglio con lama da sotto viene effettuato a step.
 
 -- Tabella per definizione modulo
 local ProcessLongCut = {}
@@ -55,6 +58,10 @@ end
 
 -----------------------------------------------------------------------------------------------
 local function MakeSideFace( nId, nFac, nSide, sMilling, dToolDiam, bForcedLim, dDistToMachine, bUnderDir)
+   if ( not BD.DOWN_HEAD or not BD.TURN) and nSide == -1 then
+      EgtOutLog( 'LongCut : side face finishing skipped , down head required')
+      return true
+   end
    -- inserisco la lavorazione
    local nM = 1
    local nP = 1
@@ -102,8 +109,8 @@ local function MakeSideFace( nId, nFac, nSide, sMilling, dToolDiam, bForcedLim,
       -- attacco e uscita
       EgtSetMachiningParam( MCH_MP.LIPERP, 0)
       EgtSetMachiningParam( MCH_MP.LITANG, dToolDiam / 2 + 30)
-      EgtSetMachiningParam( MCH_MP.LOPERP, 0)
+      EgtSetMachiningParam( MCH_MP.LOPERP, 2)
-      EgtSetMachiningParam( MCH_MP.LOTANG, dToolDiam / 2 + 30)
+      EgtSetMachiningParam( MCH_MP.LOTANG, 10)
       -- eseguo
       if not ML.ApplyMachining( true, false) then
          local _, sErr = EgtGetLastMachMgrError()
@@ -463,10 +470,10 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
    local bTopStart = ( Proc.Box:getMax():getZ() > b3Solid:getMax():getZ() - 20)
    -- Determino se parte da sotto
    local bBottomStart = ( Proc.Box:getMin():getZ() < b3Solid:getMin():getZ() + 20)
-   -- determino se lavorazione da davanti o da dietro
+   -- Determino se lavorazione da davanti o da dietro
    local bFront = ( vtN:getY() < 0)
-   -- ottengo la distanza tra la fine del pezzo e il pezzo successivo
+   -- Ottengo la distanza tra la fine del pezzo e il pezzo successivo o grezzo utilizzabile e non ancora separato
-   local dDistToNextPiece = EgtGetInfo( nRawId, 'BDST', 'd') or BD.OVM_MID
+   local dDistToNextPiece = BL.GetDistanceToNextPart( nRawId, nPhase)
    local bForcedLim
    local sWarn
    ---------------------------------------------------------------------------------------------------------------------------------------- 
@@ -477,7 +484,7 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
    -- Questo viene fatto se Q07=1 o fresa da sotto
    ---------------------------------------------------------------------------------------------------------------------------------------- 
    local nUseBlade = 0
-   if bCustUseBlade and bCustUseBlade == 1 then
+   if bCustUseBlade then
       nUseBlade = 1
    -- leggo il parametro Q05 solo se è una vera longcut L010
    elseif ProcessLongCut.Identify( Proc) then
@@ -555,12 +562,6 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
       return false, sErr
    end
 
-   -- verifico se la parte rimanente della barra è riutilizzabile
-   local nNextRawId = EgtGetNextRawPart( nRawId)
-   local bIsNextRawPartUnloadable = nNextRawId and 
-                                    EgtGetPartInRawPartCount( nNextRawId) <= 0 and 
-                                    EgtGetRawPartBBox( nNextRawId):getDimX() >= BD.MinRaw
-                                    
    -- Se non limitato o forzato uso lama e da sopra e richiesto con doppio taglio di lama e superiore al limite minimo
    if ( ( not bLimXmin and not bLimXmax) or bForceUseBladeOnNotThruFace) and ( bCanUseUnderBlade or bCanUseBlade) and nUseBlade > 0 and b3Solid:getDimX() > dLimMinPiece - 1 then
       local sCutting
@@ -607,8 +608,8 @@ 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, oppure se grezzo finale della barra di lunghezza sufficiente, setto la fine come limitata
+      -- se la fine (a sinistra) non è limitata e ho un pezzo successivo o grezzo riutilizzabile meno distante di metà raggio, setto la fine come limitata
-      if ((( bCanUseBlade or bCanUseUnderBlade) and ( dDistToNextPiece < dToolDiam/2 or dDistToNextPiece < dToolDiamDn/2)) or bIsNextRawPartUnloadable) and not bLimXmin then
+      if (( bCanUseBlade or bCanUseUnderBlade) and ( dDistToNextPiece < dToolDiam/2 or dDistToNextPiece < dToolDiamDn/2)) and not bLimXmin then
          if bForceUseBladeOnNotThruFace then
             bForcedLim = true
             bLimXmin = true
@@ -741,7 +742,7 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
       -- solo per T010
       local bFinishWithChainSaw = false
       if ( Proc.Prc == 10 and not ProcessLongCut.Identify( Proc)) and bLarghAsFace and abs( nSide) == 2 and ( bCanUseBlade and bCanUseUnderBlade) and Proc.Fct == 1 then
-         bFinishWithChainSaw = EgtIf ( EgtGetInfo( Proc.Id, 'Q05', 'i') or 0 == 1, true, false)
+         bFinishWithChainSaw = EgtIf ( ( EgtGetInfo( Proc.Id, 'Q05', 'i') or 0) == 1, true, false)
       end
       
       local nFaceUse 
@@ -760,11 +761,17 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
       -- calcolo quanto è l'affondamento del taglio
       local dOffsetTopBlade = ( dWidth + dDimStrip) / 2
       local dOffsetDownBlade = ( dWidth + dDimStrip) / 2
+      local nStepDownBlade = 1
+      local dStepDownBlade = dWidth - dOffsetDownBlade
       -- se lama da sotto verifico se la componente Y della profondità di taglio supera la capacità della lama
       if ( nSide == -1 or abs(nSide) == 2) and bCanUseUnderBlade and (( dWidth - dDimStrip) / 2) > dMaxDepthDn then
          if bFinishWithChainSaw then
             dOffsetTopBlade = max( dWidth - dMaxDepth + ( BD.DECR_VERT_CUT or 0), dOffsetTopBlade)
             dOffsetDownBlade = max( dWidth - dMaxDepthDn, dOffsetDownBlade)
+            local dHCutDownBlade = dWidth - dOffsetDownBlade
+            local dMaxStepDownBlade = 64
+            nStepDownBlade = ceil( dHCutDownBlade / dMaxStepDownBlade)
+            dStepDownBlade = dHCutDownBlade / nStepDownBlade
          else
             local sErr = 'Error : side depth is bigger than underneath blade cut depth'
             EgtOutLog( sErr)
@@ -845,128 +852,132 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
          local dLioTang = 0
 
          for k = 1, 2 do
-            local dLioPerp = ( dWidth - dDimStrip) / 2 + BD.CUT_SIC
+            local nStep = 1
-            local bAddOpposite = true
+            if k == 2 then nStep = nStepDownBlade end
-            local dAddExtraPerp = 0
+            for Zstep = nStep, 1, -1 do
-            -- se faccia da sotto e angolo inferiore ai 12° o faccia di fianco e angolo inferiore a 15° (al di sotto di questo angolo
+               local dLioPerp = ( dWidth - dDimStrip) / 2 + BD.CUT_SIC
-            -- l'attacco lama si comporta in modo diverso) allora calcolo il valore perpendicolare con la funzione CalcLeadInOutPerpGeom
+               local bAddOpposite = true
-            if ( nSide == -1 and abs(vtN:getY()) >= 0.2079) or ( abs(nSide) == 2 and abs(vtN:getZ()) >= 0.2588) then
+               local dAddExtraPerp = 0
-               bAddOpposite = false
+               -- se faccia da sotto e angolo inferiore ai 12° o faccia di fianco e angolo inferiore a 15° (al di sotto di questo angolo
-            end
+               -- l'attacco lama si comporta in modo diverso) allora calcolo il valore perpendicolare con la funzione CalcLeadInOutPerpGeom
-            -- faccio in modo di calcolare il valore perpendicolare solo sulla faccia da sotto nel secondo passo o sulla faccia di fianco nel primo passo
+               if ( nSide == -1 and abs(vtN:getY()) >= 0.2079) or ( abs(nSide) == 2 and abs(vtN:getZ()) >= 0.2588) then
-            if nSide == 1 or ( nSide == -1 and k == 1) or ( abs(nSide) == 2 and k == 2) then 
+                  bAddOpposite = false
-               bAddOpposite = false
+               end
-            end
+               -- faccio in modo di calcolare il valore perpendicolare solo sulla faccia da sotto nel secondo passo o sulla faccia di fianco nel primo passo
-            if bAddOpposite then
+               if nSide == 1 or ( nSide == -1 and k == 1) or ( abs(nSide) == 2 and k == 2) then 
-               -- controllo se devo aggiungere un extra all'attacco perpendicolare
+                  bAddOpposite = false
-               if nSide == -1 then
+               end
-                  if vtN:getY() > 0 then
+               if bAddOpposite then
-                     dAddExtraPerp = Proc.Box:getMin():getY() - b3Solid:getMin():getY()
+                  -- controllo se devo aggiungere un extra all'attacco perpendicolare
-                  elseif vtN:getY() < 0 then
+                  if nSide == -1 then
-                     dAddExtraPerp = b3Solid:getMax():getY() - Proc.Box:getMax():getY()
+                     if vtN:getY() > 0 then
+                        dAddExtraPerp = Proc.Box:getMin():getY() - b3Solid:getMin():getY()
+                     elseif vtN:getY() < 0 then
+                        dAddExtraPerp = b3Solid:getMax():getY() - Proc.Box:getMax():getY()
+                     end
+                  elseif abs(nSide) == 2 then
+                     dAddExtraPerp = Proc.Box:getMin():getZ() - b3Solid:getMin():getZ()
                   end
-               elseif abs(nSide) == 2 then
+                  dLioPerp = dLioPerp + dAddExtraPerp
-                  dAddExtraPerp = Proc.Box:getMin():getZ() - b3Solid:getMin():getZ()
                end
-               dLioPerp = dLioPerp + dAddExtraPerp
+               -- inserisco le parti di lavorazione
-            end
+               nM = nM + 1
-            -- inserisco le parti di lavorazione
+               local sNameF
-            nM = nM + 1
+               local nMchFId
-            local sNameF
-            local nMchFId
 
-            if ( k == 1 and bCanUseBlade) or ( k == 2 and ( bCanUseBlade and not bCanUseUnderBlade)) then
+               if ( k == 1 and bCanUseBlade) or ( k == 2 and ( bCanUseBlade and not bCanUseUnderBlade)) then
-               sNameF = 'L2C_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( nM)
+                  sNameF = 'L2C_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( nM)
-               nMchFId = EgtAddMachining( sNameF, sCutting)
+                  nMchFId = EgtAddMachining( sNameF, sCutting)
-               if not nMchFId then
+                  if not nMchFId then
-                  local sErr = 'Error adding machining ' .. sNameF .. '-' .. sCutting
+                     local sErr = 'Error adding machining ' .. sNameF .. '-' .. sCutting
-                  EgtOutLog( sErr)
+                     EgtOutLog( sErr)
-                  return false, sErr
+                     return false, sErr
+                  end
+                  -- setto le variabili delle distanze dagli estremi
+                  dEndDist      = dEndDistUp
+                  dEndAccDist   = dEndAccDistUp
+                  dStartDist    = dStartDistUp
+                  dStartAccDist = dStartAccDistUp
+               elseif ( k == 2 and bCanUseUnderBlade) or ( k == 1 and ( bCanUseUnderBlade and not bCanUseBlade)) then
+                  sNameF = 'L2CD_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( nM)
+                  nMchFId = EgtAddMachining( sNameF, sCuttingDn)
+                  if not nMchFId then
+                     local sErr = 'Error adding machining ' .. sNameF .. '-' .. sCuttingDn
+                     EgtOutLog( sErr)
+                     return false, sErr
+                  end
+                  -- setto le variabili delle distanze dagli estremi
+                  dEndDist      = dEndDistDn
+                  dEndAccDist   = dEndAccDistDn
+                  dStartDist    = dStartDistDn
+                  dStartAccDist = dStartAccDistDn
                end
-               -- setto le variabili delle distanze dagli estremi
+               -- aggiungo geometria
-               dEndDist      = dEndDistUp
+               EgtSetMachiningGeometry( {{ Proc.Id, 0}})
-               dEndAccDist   = dEndAccDistUp
+               -- limito opportunamente la lavorazione
-               dStartDist    = dStartDistUp
+               local dSal = EgtIf( i == nC, -dEndDist, - dEndAccDist - ( nC - i - 1) * dC)
-               dStartAccDist = dStartAccDistUp
+               local dEal = EgtIf( i == 1, -dStartDist, - dStartAccDist - ( i - 2) * dC)
-            elseif ( k == 2 and bCanUseUnderBlade) or ( k == 1 and ( bCanUseUnderBlade and not bCanUseBlade)) then
+               if ( not bFront and k == 1) or ( bFront and k == 2) then
-               sNameF = 'L2CD_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( nM)
+                  dSal, dEal = dEal, dSal
-               nMchFId = EgtAddMachining( sNameF, sCuttingDn)
-               if not nMchFId then
-                  local sErr = 'Error adding machining ' .. sNameF .. '-' .. sCuttingDn
-                  EgtOutLog( sErr)
-                  return false, sErr
                end
-               -- setto le variabili delle distanze dagli estremi
-               dEndDist      = dEndDistDn
-               dEndAccDist   = dEndAccDistDn
-               dStartDist    = dStartDistDn
-               dStartAccDist = dStartAccDistDn
-            end
-            -- aggiungo geometria
-            EgtSetMachiningGeometry( {{ Proc.Id, 0}})
-            -- limito opportunamente la lavorazione
-            local dSal = EgtIf( i == nC, -dEndDist, - dEndAccDist - ( nC - i - 1) * dC)
-            local dEal = EgtIf( i == 1, -dStartDist, - dStartAccDist - ( i - 2) * dC)
-            if ( not bFront and k == 1) or ( bFront and k == 2) then
-               dSal, dEal = dEal, dSal
-            end
     
-            if bCanUseBlade and bCanUseUnderBlade then
+               if bCanUseBlade and bCanUseUnderBlade then
-               EgtSetMachiningParam( MCH_MP.INVERT, true)
+                  EgtSetMachiningParam( MCH_MP.INVERT, true)
-               EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
+                  EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
-               dSal, dEal = dEal, dSal
+                  dSal, dEal = dEal, dSal
-               -- imposto uso della faccia
+                  -- imposto uso della faccia
-               EgtSetMachiningParam( MCH_MP.FACEUSE, EgtIf( k == 1, nFaceUse2, nFaceUse))
+                  EgtSetMachiningParam( MCH_MP.FACEUSE, EgtIf( k == 1, nFaceUse2, nFaceUse))
-            elseif bCanUseBlade and BD.USE_LONGCUT then
+               elseif bCanUseBlade and BD.USE_LONGCUT then
-               EgtSetMachiningParam( MCH_MP.INVERT, true)
+                  EgtSetMachiningParam( MCH_MP.INVERT, true)
-               EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
+                  EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
-               dSal, dEal = dEal, dSal
+                  dSal, dEal = dEal, dSal
-               -- imposto uso della faccia
+                  -- imposto uso della faccia
-               EgtSetMachiningParam( MCH_MP.FACEUSE, EgtIf( k == 1, nFaceUse2, nFaceUse))
+                  EgtSetMachiningParam( MCH_MP.FACEUSE, EgtIf( k == 1, nFaceUse2, nFaceUse))
-            elseif bCanUseUnderBlade then
+               elseif bCanUseUnderBlade then
-               if abs(nSide) ~= 2 then
+                  if abs(nSide) ~= 2 then
-                  EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
+                     EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
-               end
+                  end
-               -- imposto uso della faccia
+                  -- imposto uso della faccia
-               EgtSetMachiningParam( MCH_MP.FACEUSE, EgtIf( k == 1, nFaceUse, nFaceUse2))
+                  EgtSetMachiningParam( MCH_MP.FACEUSE, EgtIf( k == 1, nFaceUse, nFaceUse2))
-            else
-               -- imposto uso della faccia
-               EgtSetMachiningParam( MCH_MP.FACEUSE, EgtIf( k == 1, nFaceUse, nFaceUse2))
-            end
-
-            EgtSetMachiningParam( MCH_MP.STARTADDLEN, dSal)
-            EgtSetMachiningParam( MCH_MP.ENDADDLEN, dEal)
-            -- imposto offset radiale
-            local dOffset = EgtIf( k == 1, dOffsetTopBlade, dOffsetDownBlade)
-            EgtSetMachiningParam( MCH_MP.OFFSR, EgtIf( nSide == -1, -dOffset, dOffset))
-            -- imposto attacco/uscita
-            EgtSetMachiningParam( MCH_MP.LITANG, dLioTang)
-            EgtSetMachiningParam( MCH_MP.LIPERP, dLioPerp)
-            EgtSetMachiningParam( MCH_MP.LOTANG, dLioTang)
-            EgtSetMachiningParam( MCH_MP.LOPERP, dLioPerp)
-            -- se il flag uso lama custom abilitato (indica che questo script è lanciato dal ProcessCut)
-            -- controllo se componente X versore è maggiore di un valore limite cambio la direzione della forcella
-            if bCustUseBlade and abs(vtN:getX()) > 0.009 + 5 * GEO.EPS_SMALL then
-               if BD.USE_LONGCUT then
-                  nSCC = EgtIf( ( bFront and k == 1) or ( not bFront and k == 2), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
                else
-                  nSCC = EgtIf( ( not bFront and k == 1) or ( bFront and k == 2), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
+                  -- imposto uso della faccia
+                  EgtSetMachiningParam( MCH_MP.FACEUSE, EgtIf( k == 1, nFaceUse, nFaceUse2))
+               end
+
+               EgtSetMachiningParam( MCH_MP.STARTADDLEN, dSal)
+               EgtSetMachiningParam( MCH_MP.ENDADDLEN, dEal)
+               -- imposto offset radiale
+               local dOffset = EgtIf( k == 1, dOffsetTopBlade, dOffsetDownBlade + dStepDownBlade * ( Zstep - 1))
+               EgtSetMachiningParam( MCH_MP.OFFSR, EgtIf( nSide == -1, -dOffset, dOffset))
+               -- imposto attacco/uscita
+               EgtSetMachiningParam( MCH_MP.LITANG, dLioTang)
+               EgtSetMachiningParam( MCH_MP.LIPERP, dLioPerp)
+               EgtSetMachiningParam( MCH_MP.LOTANG, dLioTang)
+               EgtSetMachiningParam( MCH_MP.LOPERP, dLioPerp)
+               -- se il flag uso lama custom abilitato (indica che questo script è lanciato dal ProcessCut)
+               -- controllo se componente X versore è maggiore di un valore limite cambio la direzione della forcella
+               if bCustUseBlade and abs(vtN:getX()) > 0.009 + 5 * GEO.EPS_SMALL then
+                  if BD.USE_LONGCUT then
+                     nSCC = EgtIf( ( bFront and k == 1) or ( not bFront and k == 2), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
+                  else
+                     nSCC = EgtIf( ( not bFront and k == 1) or ( bFront and k == 2), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
+                  end
+               end
+               -- imposto posizione braccio porta testa per non ingombrare agli estremi
+               EgtSetMachiningParam( MCH_MP.SCC, nSCC)
+               -- eseguo
+               if not ML.ApplyMachining( true, false) then
+                  local _, sErr = EgtGetLastMachMgrError()
+                  EgtSetOperationMode( nMchFId, false)
+                  return false, sErr
                end
-            end
-            -- imposto posizione braccio porta testa per non ingombrare agli estremi
-            EgtSetMachiningParam( MCH_MP.SCC, nSCC)
-            -- eseguo
-            if not ML.ApplyMachining( true, false) then
-               local _, sErr = EgtGetLastMachMgrError()
-               EgtSetOperationMode( nMchFId, false)
-               return false, sErr
             end
          end
       end
       
       -- se richiesto aggiungo la lavorazione con sega a catena
       if bFinishWithChainSaw then
-         local dChainSawOverMaterial = 3
+         local dChainSawOverMaterial = 0
          local dChainSawDepth = dOffsetDownBlade - dDimStrip
          dEndDist      = dEndDistUp
          dEndAccDist   = dEndAccDistUp
@@ -1004,8 +1015,8 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
             dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
          end
       end
-      -- 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
+      -- se la fine (a sinistra) non è limitata e ho un pezzo successivo o grezzo riutilizzabile meno distante di metà raggio, setto la fine come limitata
-      if ( dDistToNextPiece < dToolDiam/2 or bIsNextRawPartUnloadable) and not bLimXmin then
+      if dDistToNextPiece < dToolDiam/2 and not bLimXmin then
          bForcedLim = true
          bLimXmin = true
       end

LuaLibs/ProcessLongDoubleCut.lua

@@ -10,6 +10,8 @@
 -- 2022/05/27 Corretto ordine per casi sui lati.
 -- 2022/06/29 Corretto calcolo lunghezza attacco/uscita perpendicolare per lavorazioni di fianco.
 -- 2022/11/30 Modifiche su SCC per TURN.
+-- 2023/01/26 Rimossa la pulitura della faccia laterale nel caso in cui la feature abbia almeno una faccia rivolta verso il basso.
+-- 2023/01/27 In MakeSideFace il prolungamento di uscita è ora fissato a 10 mm.
 
 -- Tabella per definizione modulo
 local ProcessLong2Cut = {}
@@ -118,7 +120,11 @@ function ProcessLong2Cut.GetLongFacesCount( Proc)
 end
 
 ---------------------------------------------------------------------
-local function MakeSideFace( nId, nFac, nSide, sMilling, dToolDiam, nL2CSide)
+local function MakeSideFace( nId, nFac, nSideLimitingFace, sMilling, dToolDiam, nL2CSide, bIsAnyFaceUpsideDown)
+   if ( not BD.DOWN_HEAD or not BD.TURN) and bIsAnyFaceUpsideDown then
+      EgtOutLog( 'Long2Cut : side face finishing skipped , down head required')
+      return true
+   end
    -- inserisco la lavorazione
    local sNameF = 'L2C_' .. ( EgtGetName( nId) or tostring( nId)) .. '_' .. tostring( nFac)
    local nMchFId = EgtAddMachining( sNameF, sMilling)
@@ -133,15 +139,15 @@ local function MakeSideFace( nId, nFac, nSide, sMilling, dToolDiam, nL2CSide)
    EgtSetMachiningParam( MCH_MP.INVERT, false)
    EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
    -- uso della faccia
-   local nFaceUse = EgtIf( nSide == 1, MCH_MILL_FU.ORTHO_RIGHT, MCH_MILL_FU.ORTHO_LEFT)
+   local nFaceUse = EgtIf( nSideLimitingFace == 1, MCH_MILL_FU.ORTHO_RIGHT, MCH_MILL_FU.ORTHO_LEFT)
    EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
    -- annullo offset radiale
    EgtSetMachiningParam( MCH_MP.OFFSR, 0)
    -- attacco e uscita
    EgtSetMachiningParam( MCH_MP.LIPERP, 0)
    EgtSetMachiningParam( MCH_MP.LITANG, dToolDiam / 2 + 30)
-   EgtSetMachiningParam( MCH_MP.LOPERP, 0)
+   EgtSetMachiningParam( MCH_MP.LOPERP, 2)
-   EgtSetMachiningParam( MCH_MP.LOTANG, dToolDiam / 2 + 30)
+   EgtSetMachiningParam( MCH_MP.LOTANG, 10)
    -- se faccia di fianco e testa da sotto, aumento la sicurezza
    if nL2CSide == 0 and BD.DOWN_HEAD then
        EgtSetMachiningParam( MCH_MP.STARTPOS, 80)
@@ -302,6 +308,7 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster
    elseif vtN[1]:getZ() < -0.0175 and vtN[2]:getZ() < -0.0175 then
       nSide = -1
    end
+   local bIsAnyFaceUpsideDown = vtN[1]:getZ() < -0.0175 or vtN[2]:getZ() < -0.0175
 
    -- angolo diedro per stabilire se taglio convesso
    local bInt, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, tFaceLong[1], tFaceLong[2], GDB_ID.ROOT)
@@ -325,7 +332,7 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster
    end
 
     -- ottengo la distanza tra la fine del pezzo e il pezzo successivo
-   local dDistToNextPiece = EgtGetInfo( nRawId, 'BDST', 'd') or 5.4
+   local dDistToNextPiece = BL.GetDistanceToNextPart( nRawId, nPhase)
    local bForcedLim
    local sWarn
    ---------------------------------------------------------------------------------------------------------------------------------------- 
@@ -1125,11 +1132,11 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster
             end
             -- se facce principali convesse, eventuale lavorazione della faccia limitante l'inizio (a destra)
             if bConvex and j == 1 and not bStartFixed then
-               MakeSideFace( Proc.Id, tFaceLong[vOrd[i]], 1, sMilling, dToolDiam, nSide)
+               MakeSideFace( Proc.Id, tFaceLong[vOrd[i]], 1, sMilling, dToolDiam, nSide, bIsAnyFaceUpsideDown)
             end
             -- se facce principali convesse, eventuale lavorazione della faccia limitante la fine (a sinistra)
             if bConvex and j == nC and not bEndFixed then
-               MakeSideFace( Proc.Id, tFaceLong[vOrd[i]], -1, sMilling, dToolDiam, nSide)
+               MakeSideFace( Proc.Id, tFaceLong[vOrd[i]], -1, sMilling, dToolDiam, nSide, bIsAnyFaceUpsideDown)
             end
          end
       end

LuaLibs/ProcessMortise.lua

@@ -7,6 +7,8 @@
 -- 2022/09/27 Migliorata la scelta utensile. Se c'è almeno una lavorazione 'mortise' si cerca di usare quelle, riducendo l'elevazione se necessario.
 --            Se non c'è nemmeno una lavorazione 'mortise' si passa alle pocket.
 -- 2022/12/12 Migliorato controllo necessità CleanCorners.
+-- 2023/01/31 Aggiunta gestione lavorazione in doppio.
+-- 2023/01/31 Creata la funzione ConvertToClosedCurve (parte della ProcessMortise.Make) e spostata in BeamLib.
 
 -- Tabella per definizione modulo
 local ProcessMortise = {}
@@ -36,6 +38,13 @@ function ProcessMortise.FrontIdentify( Proc)
    return (( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 51)
 end
 
+---------------------------------------------------------------------
+-- Riconoscimento delle sole feature laterali
+function ProcessMortise.SideIdentify( Proc)
+   return ( (( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 50) or
+            (( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 53))
+end
+
 ---------------------------------------------------------------------
 -- Classificazione della feature: decide se la feature è in una posizione che per lavorala
 -- deve essere ribaltata o no
@@ -234,17 +243,17 @@ local function CleanCorners( Proc, dMorH, vtN, bDoubleDir, AuxId)
 end
 
 ---------------------------------------------------------------------
-local function VerifyMortiseOrPocket( Proc, dDiam, dDepth, dMaxTotLen, sType, bPocketDown)
+function ProcessMortise.VerifyMortiseOrPocket( Proc, dDiam, dDepth, dMaxTotLen, sType, bPocketDown, bExcludeH2)
    -- ricerca della svuotatura
    local sPocketing
    if dDepth then
-      sPocketing = ML.FindPocketing( sType, dDiam, dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or
+      sPocketing = ML.FindPocketing( sType, dDiam, dDepth, dMaxTotLen, not bPocketDown, bPocketDown, bExcludeH2) or
-                   ML.FindPocketing( sType, dDiam, 0.8 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or
+                   ML.FindPocketing( sType, dDiam, 0.8 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown, bExcludeH2) or
-                   ML.FindPocketing( sType, dDiam, 0.6 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or
+                   ML.FindPocketing( sType, dDiam, 0.6 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown, bExcludeH2) or
-                   ML.FindPocketing( sType, dDiam, 0.4 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or
+                   ML.FindPocketing( sType, dDiam, 0.4 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown, bExcludeH2) or
-                   ML.FindPocketing( sType, dDiam, 0, dMaxTotLen)
+                   ML.FindPocketing( sType, dDiam, 0, dMaxTotLen, bExcludeH2)
    else
-      sPocketing = ML.FindPocketing( sType, dDiam, 0, dMaxTotLen)
+      sPocketing = ML.FindPocketing( sType, dDiam, 0, dMaxTotLen, bExcludeH2)
    end
    if not sPocketing then
       return false
@@ -286,34 +295,8 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
    end
    -- recupero versore estrusione della curva supplementare
    local vtExtr = EgtCurveExtrusion( AuxId, GDB_ID.ROOT)
-   -- Se curva di contorno aperta
+   -- se curva di contorno aperta la rendo chiusa
-   if not EgtCurveIsClosed( AuxId) then
+   BL.ConvertToClosedCurve( Proc, AuxId)
-      local NewId, nCount = EgtExtractSurfTmFacetLoops( Proc.Id, 0, EgtGetParent( Proc.Id))
-      if NewId then
-         -- elimino eventuali loop interni (non dovrebbero comunque esserci)
-         for i = 1, nCount - 1 do
-            EgtErase( NewId + i)
-         end
-         -- sostituisco il loop esterno alla curva originale
-         EgtModifyCurveExtrusion( NewId, vtExtr, GDB_ID.ROOT)
-         EgtRelocate( NewId, AuxId, GDB_IN.AFTER)
-         EgtErase( AuxId)
-         EgtChangeId( NewId, AuxId)
-         -- sistemo i lati aperti
-         local vFacAdj = EgtSurfTmFacetAdjacencies( Proc.Id, 0)[1]
-         if vFacAdj then
-            local sOpen = ''
-            for i = 1, #vFacAdj do
-               if vFacAdj[i] < 0 then
-                  sOpen = sOpen .. EgtIf( #sOpen > 0, ',', '') .. tostring( i - 1)
-               end
-            end
-            if #sOpen > 0 then
-               EgtSetInfo( AuxId, 'OPEN', sOpen)
-            end
-         end
-      end
-   end
    -- verifico se frontale
    local bFront = ( Proc.Prc == 51)
    -- recupero i dati della faccia di fondo
@@ -420,18 +403,25 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
    elseif bPockAngTrasm then
       sMchExt = '_AT'
    end
+   local bExcludeH2 = false
+   if Proc.Double and Proc.Double > 0 then
+      bPockUp = false
+      bPockDown = false
+      bExcludeH2 = true
+      sMchExt = ''
+   end
    local sPocketing
    if Proc.Prc ~= 53 then
-      sPocketing = VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt, bPockDown)
+      sPocketing = ProcessMortise.VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt, bPockDown, bExcludeH2)
       if not sPocketing and bPockUp then
-         sPocketing = VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt)
+         sPocketing = ProcessMortise.VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt, _, bExcludeH2)
       end
    end
    if not sPocketing then
       sPockType = 'Pocket'
-      sPocketing = VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt, bPockDown)
+      sPocketing = ProcessMortise.VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt, bPockDown, bExcludeH2)
       if not sPocketing and bPockUp then
-         sPocketing = VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt)
+         sPocketing = ProcessMortise.VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt, _, bExcludeH2)
       end
    end
    if not sPocketing then
@@ -509,7 +499,12 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
       end
    end
    -- imposto elevazione
-   EgtSetMachiningParam( MCH_MP.USERNOTES, 'MaxElev=' .. EgtNumToString( dMorH, 1) .. ';')
+   local sUserNotes = 'MaxElev=' .. EgtNumToString( dMorH, 1) .. ';'
+   -- se lavorazione in doppio
+   if Proc.Double and Proc.Double > 0 then
+      sUserNotes = EgtSetValInNotes( sUserNotes, 'DOUBLE', Proc.Double)
+   end
+   EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
    -- eseguo
    if not ML.ApplyMachining( true, false) then
       local _, sErr = EgtGetLastMachMgrError()

LuaLibs/ProcessSplit.lua

@@ -453,9 +453,9 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt
          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)
+            dAccEnd = sqrt( max( dSawRad * dSawRad - dKL * dKL, 0))
          else
-            dAccStart = sqrt( dSawRad * dSawRad - dKL * dKL)
+            dAccStart = sqrt( max( dSawRad * dSawRad - dKL * dKL, 0))
          end
       end
       -- se necessari tagli in doppio, eseguo gli opposti

LuaLibs/ProcessTenon.lua

@@ -1,4 +1,4 @@
--- ProcessTenon.lua by Egaltech s.r.l. 2022/12/20
+-- ProcessTenon.lua by Egaltech s.r.l. 2023/01/20
 -- Gestione calcolo tenone per Travi
 -- 2021/10/04 Corretto calcolo HCING per pezzi piccoli.
 -- 2022/02/15 Aggiornata VerifyOrientation per macchine con testa da sotto.
@@ -8,6 +8,7 @@
 -- 2022/11/03 Corretto uso di bH2 (da sotto solo se anche bMillDown vero).
 -- 2022/12/12 Su macchine con rulli pressori e pinze separate si riduce di meno l'ingombro con tenoni inclinati.
 -- 2022/12/20 Aggiunta gestione smusso. Migliorata scelta tra sopra e sotto per il punto di inizio. In VerifyOrientation aggiunta trave medio alta.
+-- 2023/01/20 Modificata scelta lato di attacco per pezzo piccolo su macchine con pinza speciale (pinza 5).
 
 -- Tabella per definizione modulo
 local ProcessTenon = {}
@@ -271,16 +272,17 @@ function ProcessTenon.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
    -- massimo numero di passate e coefficiente di sovrapposizione ta passate
    local MAX_PASS = 6
    local OVERLAP_COEFF = 0.7
-   -- porto inizio curva il più possibile sul bordo in alto o in basso
+   -- porto inizio curva il più possibile sul bordo in alto, in basso o di lato a seconda delle necessità
    local dMaxDist = OVERLAP_COEFF * dMillDiam * MAX_PASS
-   local bFromBottom
+   local nNearSide = 3
    local bMyShortPart = ( bShortPart and vtN:getX() < 0 and abs( vtN:getX()) < 0.999 and abs( vtN:getY()) < 0.259)
    if bH2 and bMillDown then
-      bFromBottom = EgtIf( bMyShortPart and vtN:getZ() < -0.018, false, true)
+      nNearSide = EgtIf( bMyShortPart and vtN:getZ() < -0.018, 3, -3)
    else
-      bFromBottom = EgtIf( bMyShortPart and vtN:getZ() > 0.018, true, false)
+      nNearSide = EgtIf( bMyShortPart and vtN:getZ() > 0.018, -3, 3)
    end
-   BL.PutStartNearestToEdge( AuxId, b3Solid, dMaxDist, bFromBottom)
+   if bMyShortPart and BD.CLAMP5 then nNearSide = -2 end
+   BL.PutStartNearestToEdge( AuxId, b3Solid, dMaxDist, nNearSide)
    -- se elevazione superiore a massimo affondamento della fresa, riduco opportunamente
    local sWarn
    local dDepth = 0