Feature/FindMirroredFeatures:

- lieve bugfix
2023-01-31 17:36:39 +01:00 · 2023-01-31 15:23:44 +01:00 · 2023-01-31 09:20:05 +01:00 · 2023-01-31 08:55:07 +01:00 · 2023-01-27 17:31:07 +01:00 · 2023-01-27 12:13:55 +01:00
11 changed files with 420 additions and 212 deletions
@@ -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
-local function CheckMirrorDtMortise( Proc, ProcMirror, b3Raw, AuxId)
+-- Controlla se la feature ProcMirror è la specchiata di Proc, per feature di tipo tasca o simile
+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
@@ -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
-         if dD < dMaxDist and dZ < dZopt + GEO.EPS_SMALL then
+         local dS
+         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
@@ -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)
-   return FindMachining( MCH_MY.POCKETING, sType, { MaxDiam = dMaxDiam, Depth = dDepth, MaxTotLen = 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, bExcludeH2, bExcludeH3)
 end

 ---------------------------------------------------------------------
@@ -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
@@ -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)
@@ -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
-         -- e limitata per ora alla feature 20
-         if bSpecial3faces and Proc.Prc == 20 and nFacInd2 then
+         -- se riconosciuta gestione 3 facce (limitatamente per ora alla feature 20)
+         if bSpecial3faces and Proc.Prc == 20 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
@@ -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.LOTANG, dToolDiam / 2 + 30)
+      EgtSetMachiningParam( MCH_MP.LOPERP, 2)
+      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
-   local dDistToNextPiece = EgtGetInfo( nRawId, 'BDST', 'd') or BD.OVM_MID
+   -- Ottengo la distanza tra la fine del pezzo e il pezzo successivo o grezzo utilizzabile e non ancora separato
+   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
@@ -554,13 +561,7 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
      EgtOutLog( sErr)
      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
-      if ((( bCanUseBlade or bCanUseUnderBlade) and ( dDistToNextPiece < dToolDiam/2 or dDistToNextPiece < dToolDiamDn/2)) or bIsNextRawPartUnloadable) and not bLimXmin then
+      -- 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)) 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 bAddOpposite = true
-            local dAddExtraPerp = 0
-            -- se faccia da sotto e angolo inferiore ai 12° o faccia di fianco e angolo inferiore a 15° (al di sotto di questo angolo
-            -- l'attacco lama si comporta in modo diverso) allora calcolo il valore perpendicolare con la funzione CalcLeadInOutPerpGeom
-            if ( nSide == -1 and abs(vtN:getY()) >= 0.2079) or ( abs(nSide) == 2 and abs(vtN:getZ()) >= 0.2588) then
-               bAddOpposite = false
-            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 nSide == 1 or ( nSide == -1 and k == 1) or ( abs(nSide) == 2 and k == 2) then 
-               bAddOpposite = false
-            end
-            if bAddOpposite then
-               -- controllo se devo aggiungere un extra all'attacco perpendicolare
-               if nSide == -1 then
-                  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()
+            local nStep = 1
+            if k == 2 then nStep = nStepDownBlade end
+            for Zstep = nStep, 1, -1 do
+               local dLioPerp = ( dWidth - dDimStrip) / 2 + BD.CUT_SIC
+               local bAddOpposite = true
+               local dAddExtraPerp = 0
+               -- se faccia da sotto e angolo inferiore ai 12° o faccia di fianco e angolo inferiore a 15° (al di sotto di questo angolo
+               -- l'attacco lama si comporta in modo diverso) allora calcolo il valore perpendicolare con la funzione CalcLeadInOutPerpGeom
+               if ( nSide == -1 and abs(vtN:getY()) >= 0.2079) or ( abs(nSide) == 2 and abs(vtN:getZ()) >= 0.2588) then
+                  bAddOpposite = false
+               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 nSide == 1 or ( nSide == -1 and k == 1) or ( abs(nSide) == 2 and k == 2) then 
+                  bAddOpposite = false
+               end
+               if bAddOpposite then
+                  -- controllo se devo aggiungere un extra all'attacco perpendicolare
+                  if nSide == -1 then
+                     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
-                  dAddExtraPerp = Proc.Box:getMin():getZ() - b3Solid:getMin():getZ()
+                  dLioPerp = dLioPerp + dAddExtraPerp
               end
-               dLioPerp = dLioPerp + dAddExtraPerp
-            end
-            -- inserisco le parti di lavorazione
-            nM = nM + 1
-            local sNameF
-            local nMchFId
+               -- inserisco le parti di lavorazione
+               nM = nM + 1
+               local sNameF
+               local nMchFId

-            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)
-               nMchFId = EgtAddMachining( sNameF, sCutting)
-               if not nMchFId then
-                  local sErr = 'Error adding machining ' .. sNameF .. '-' .. sCutting
-                  EgtOutLog( sErr)
-                  return false, sErr
+               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)
+                  nMchFId = EgtAddMachining( sNameF, sCutting)
+                  if not nMchFId then
+                     local sErr = 'Error adding machining ' .. sNameF .. '-' .. sCutting
+                     EgtOutLog( 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
-               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
+               -- 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
-               -- 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
-               EgtSetMachiningParam( MCH_MP.INVERT, true)
-               EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
-               dSal, dEal = dEal, dSal
-               -- imposto uso della faccia
-               EgtSetMachiningParam( MCH_MP.FACEUSE, EgtIf( k == 1, nFaceUse2, nFaceUse))
-            elseif bCanUseBlade and BD.USE_LONGCUT then
-               EgtSetMachiningParam( MCH_MP.INVERT, true)
-               EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
-               dSal, dEal = dEal, dSal
-               -- imposto uso della faccia
-               EgtSetMachiningParam( MCH_MP.FACEUSE, EgtIf( k == 1, nFaceUse2, nFaceUse))
-            elseif bCanUseUnderBlade then
-               if abs(nSide) ~= 2 then
-                  EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
-               end
-               -- imposto uso della faccia
-               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)
+    
+               if bCanUseBlade and bCanUseUnderBlade then
+                  EgtSetMachiningParam( MCH_MP.INVERT, true)
+                  EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
+                  dSal, dEal = dEal, dSal
+                  -- imposto uso della faccia
+                  EgtSetMachiningParam( MCH_MP.FACEUSE, EgtIf( k == 1, nFaceUse2, nFaceUse))
+               elseif bCanUseBlade and BD.USE_LONGCUT then
+                  EgtSetMachiningParam( MCH_MP.INVERT, true)
+                  EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
+                  dSal, dEal = dEal, dSal
+                  -- imposto uso della faccia
+                  EgtSetMachiningParam( MCH_MP.FACEUSE, EgtIf( k == 1, nFaceUse2, nFaceUse))
+               elseif bCanUseUnderBlade then
+                  if abs(nSide) ~= 2 then
+                     EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
+                  end
+                  -- imposto uso della faccia
+                  EgtSetMachiningParam( MCH_MP.FACEUSE, EgtIf( k == 1, nFaceUse, nFaceUse2))
               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
-      if ( dDistToNextPiece < dToolDiam/2 or bIsNextRawPartUnloadable) and not bLimXmin then
+      -- 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 and not bLimXmin then
         bForcedLim = true
         bLimXmin = true
      end
@@ -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.LOTANG, dToolDiam / 2 + 30)
+   EgtSetMachiningParam( MCH_MP.LOPERP, 2)
+   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
@@ -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
-                   ML.FindPocketing( sType, dDiam, 0.8 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or
-                   ML.FindPocketing( sType, dDiam, 0.6 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or
-                   ML.FindPocketing( sType, dDiam, 0.4 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or
-                   ML.FindPocketing( sType, dDiam, 0, dMaxTotLen)
+      sPocketing = ML.FindPocketing( sType, dDiam, dDepth, dMaxTotLen, not bPocketDown, bPocketDown, bExcludeH2) 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, bExcludeH2) or
+                   ML.FindPocketing( sType, dDiam, 0.4 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown, bExcludeH2) or
+                   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
-   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
-         -- 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
+   -- se curva di contorno aperta la rendo chiusa
+   BL.ConvertToClosedCurve( Proc, AuxId)
   -- 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()
@@ -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
@@ -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
Author	SHA1	Message	Date
luca.mazzoleni	72e653fe4b	Feature/FindMirroredFeatures: - lieve bugfix	2023-01-31 17:36:39 +01:00
luca.mazzoleni	14d2d14ba4	Feature/FindMirroredFeatures: - aggiunta una minima distanza tra le feature specchiate al di sotto della quale la lavorazione non viene fatta in doppio - alcuni bugfix minori	2023-01-31 15:23:44 +01:00
luca.mazzoleni	f3d54fd124	Feature/FindMirroredFeatures: - aggiunta gestione mortise L050/L051 in doppio	2023-01-31 09:20:05 +01:00
luca.mazzoleni	a357faeabe	Merge branch 'develop' into Feature/FindMirroredFeatures	2023-01-31 08:55:07 +01:00
luca.mazzoleni	4b531271af	Improvement: - in LongCut con lavorazione aggiuntiva di sega a catena aggiunti step parziali per la lavorazione con lama da sotto	2023-01-27 17:31:07 +01:00
luca.mazzoleni	8bde91b13c	Merge remote-tracking branch 'origin/master' into develop	2023-01-27 12:13:55 +01:00
luca.mazzoleni	b21cc7a85b	Fix: - in LongCut e Long2Cut, nella pulitura della faccia laterale, lead out fissato a 10 mm	2023-01-27 10:21:40 +01:00
luca.mazzoleni	c40f03e8a4	Fix minore	2023-01-26 17:18:47 +01:00
DarioS	59bfbd3bbe	Merge branch 'develop' of https://gitlab.steamware.net/egaltech/DataBeam	2023-01-26 17:18:42 +01:00
luca.mazzoleni	7beee74638	Bugfix minore	2023-01-26 17:13:05 +01:00
luca.mazzoleni	6eef34f1ef	Fix: - in longCut/longDoubleCut rimossa la pulitura della faccia laterale nel caso in cui la feature abbia almeno una faccia rivolta verso il basso	2023-01-26 16:30:58 +01:00
luca.mazzoleni	0738cde565	Merge remote-tracking branch 'origin/master' into develop	2023-01-26 15:03:16 +01:00
DarioS	4be2686584	Merge branch 'develop' of https://gitlab.steamware.net/egaltech/DataBeam	2023-01-26 12:41:15 +01:00
DarioS	4bd7ad4263	DataBeam : - corretta scelta lavorazione per macchine con due teste solo da sopra (PF e PFrl) - modifica a LapJoint trasversale stretto, se la lavorazione non genera toolpath allora si passa a tentare con la lama - in Split aggiunto controllo per evitare sqrt di valori negativi.	2023-01-26 12:40:55 +01:00
luca.mazzoleni	1a2675ed56	fix commenti	2023-01-26 09:38:42 +01:00
luca.mazzoleni	aa8fd354d9	Improvement: - in ProcessCut migliorata in alcuni casi la direzione di lavoro della lama, per scaricare il truciolo nella direzione ottimale - in ProcessLapJoint leggera correzione al diametro massimo utensile per tasche 3 facce a L	2023-01-26 09:35:40 +01:00
luca.mazzoleni	89b968f0d1	Fix: - in LapJoint piccola modifica al diametro massimo dell'utensile per tasche 3 facce a L	2023-01-25 14:43:35 +01:00
luca.mazzoleni	d5fdf37c9c	BugFix: - in LapJoint -> MakeByPocket gestito caso in cui poteva essere applicata una lavorazione con percorso vuoto	2023-01-25 09:26:11 +01:00
luca.mazzoleni	ab67c86657	Merge branch 'master' into develop	2023-01-23 08:53:02 +01:00
DarioS	ca9fa091cc	DataBeam : - aggiunta funzione BeamLib.GetDistanceToNextPart per facilitare controllo di non rovinare parti in coda su lavorazioni longitudinali - utilizzata in LongCut, LongDoubleCut e in LapJoint dove serve.	2023-01-22 16:12:50 +01:00
DarioS	60a00a81fa	DataBeam : - in lavorazione Tenoni modificata scelta lato di attacco per pezzo piccolo su macchine con pinza speciale (pinza 5) - in lavorazione LapJoint (sottospecie L020) migliorato riconoscimento caso Special3faces - estesa funzione di libreria PutStartNearestToEdge per gestire lato preferito come Y+, Y-, z*, Z-.	2023-01-21 10:02:28 +01:00
luca.mazzoleni	bd870c8ac6	Fix: - in LongCut azzerato il sovramateriale lasciato dalla eventuale lavorazione aggiuntiva di sega a catena	2023-01-20 16:20:35 +01:00
luca.mazzoleni	623fd30a6c	Merge branch 'Feature/L010MillStopIfUnloadableRawPiece' into develop	2023-01-20 15:34:29 +01:00