In LapJoint : in IsTailFeature se LapJoint a 2 facce che taglia intera sezione, da fare dopo taglio di coda

In LapJoint -> MakeMoreLongFaces corretto calcolo divisione in parti per evitare problemi di ceil con interi perfetti (ceil(3) = 3 o 4??)
- in LapJoint -> SideMillAsSaw gestito anche rabbet passante
2024-04-22 09:04:34 +02:00 · 2024-04-17 11:11:04 +02:00 · 2024-04-15 12:22:23 +02:00 · 2024-04-12 14:16:00 +02:00 · 2024-04-12 13:15:59 +02:00 · 2024-04-11 12:56:47 +02:00
14 changed files with 1351 additions and 186 deletions
@@ -24,14 +24,14 @@ variables:
    $FileList = Get-ChildItem("*.lua")
    ForEach ($File in $FileList) {
      $FileName = Split-Path $File -leaf
-      lua54 -o bin\$FileName $FileName
-      echo "lua54 -o bin\$FileName $FileName"
+      lua54 -o bin\$FileName -s $FileName
+      echo "lua54 -o bin\$FileName -s $FileName"
    }
    $FileList = Get-ChildItem("LuaLibs\*.lua")
    ForEach ($File in $FileList) {
      $FileName = Split-Path $File -leaf
-      lua54 -o bin\LuaLibs\$FileName LuaLibs\$FileName
-      echo "lua54 -o bin\LuaLibs\$FileName LuaLibs\$FileName"
+      lua54 -o bin\LuaLibs\$FileName -s LuaLibs\$FileName
+      echo "lua54 -o bin\LuaLibs\$FileName -s LuaLibs\$FileName"
    }

 # helper copia SORGENTI verso cartella di rete X:\ dei SORGENTI
@@ -4,52 +4,52 @@ REM Per togliere info di debug aggiungere flag -s prima del nome del file di inp

 REM Compilazione 32 e 64 bit

-\EgtProg\Dll32\luac54 -o bin\LuaLibs\BeamExec.lua                      LuaLibs\BeamExec.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\BeamLib.lua                       LuaLibs\BeamLib.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\DiceCut.lua                       LuaLibs\DiceCut.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\FaceByPocket.lua                  LuaLibs\FaceByPocket.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\FacesBySaw.lua                    LuaLibs\FacesBySaw.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\FeatureTopology.lua               LuaLibs\FeatureTopology.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\MachiningLib.lua                  LuaLibs\MachiningLib.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessBlockHausFront.lua         LuaLibs\ProcessBlockHausFront.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessChamfer.lua                LuaLibs\ProcessChamfer.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessCut.lua                    LuaLibs\ProcessCut.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessDecor.lua                  LuaLibs\ProcessDecor.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessDoubleCut.lua              LuaLibs\ProcessDoubleCut.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessDovetail.lua               LuaLibs\ProcessDovetail.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessDrill.lua                  LuaLibs\ProcessDrill.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessDtMortise.lua              LuaLibs\ProcessDtMortise.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessDtTenon.lua                LuaLibs\ProcessDtTenon.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessFreeContour.lua            LuaLibs\ProcessFreeContour.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessFrenchRidgeLap.lua         LuaLibs\ProcessFrenchRidgeLap.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessHeadCut.lua                LuaLibs\ProcessHeadCut.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessLapJoint.lua               LuaLibs\ProcessLapJoint.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessLongCut.lua                LuaLibs\ProcessLongCut.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessLongDoubleCut.lua          LuaLibs\ProcessLongDoubleCut.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessMark.lua                   LuaLibs\ProcessMark.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessMortise.lua                LuaLibs\ProcessMortise.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessProfCamb.lua               LuaLibs\ProcessProfCamb.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessProfConcave.lua            LuaLibs\ProcessProfConcave.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessProfConvex.lua             LuaLibs\ProcessProfConvex.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessProfFront.lua              LuaLibs\ProcessProfFront.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessProfHead.lua               LuaLibs\ProcessProfHead.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessRidgeLap.lua               LuaLibs\ProcessRidgeLap.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessRoundArch.lua              LuaLibs\ProcessRoundArch.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessSawCut.lua                 LuaLibs\ProcessSawCut.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessScarfJoint.lua             LuaLibs\ProcessScarfJoint.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessSimpleScarf.lua            LuaLibs\ProcessSimpleScarf.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessSplit.lua                  LuaLibs\ProcessSplit.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessStepJoint.lua              LuaLibs\ProcessStepJoint.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessStepJointNotch.lua         LuaLibs\ProcessStepJointNotch.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessTenon.lua                  LuaLibs\ProcessTenon.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessText.lua                   LuaLibs\ProcessText.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessTyroleanDovetail.lua       LuaLibs\ProcessTyroleanDovetail.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessVariant.lua                LuaLibs\ProcessVariant.lua
-\EgtProg\Dll32\luac54 -o bin\BatchProcess.lua                          BatchProcess.lua
-\EgtProg\Dll32\luac54 -o bin\BatchProcessNew.lua                       BatchProcessNew.lua
-\EgtProg\Dll32\luac54 -o bin\GetBeamData.lua                           GetBeamData.lua
-\EgtProg\Dll32\luac54 -o bin\NestProcess.lua                           NestProcess.lua
-\EgtProg\Dll32\luac54 -o bin\Process.lua                               Process.lua
-\EgtProg\Dll32\luac54 -o bin\Rotate.lua                                Rotate.lua
-\EgtProg\Dll32\luac54 -o bin\Swap.lua                                  Swap.lua
-\EgtProg\Dll32\luac54 -o bin\Version.lua                               Version.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\BeamExec.lua                      -s LuaLibs\BeamExec.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\BeamLib.lua                       -s LuaLibs\BeamLib.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\DiceCut.lua                       -s LuaLibs\DiceCut.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\FaceByPocket.lua                  -s LuaLibs\FaceByPocket.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\FacesBySaw.lua                    -s LuaLibs\FacesBySaw.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\FeatureTopology.lua               -s LuaLibs\FeatureTopology.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\MachiningLib.lua                  -s LuaLibs\MachiningLib.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessBlockHausFront.lua         -s LuaLibs\ProcessBlockHausFront.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessChamfer.lua                -s LuaLibs\ProcessChamfer.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessCut.lua                    -s LuaLibs\ProcessCut.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessDecor.lua                  -s LuaLibs\ProcessDecor.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessDoubleCut.lua              -s LuaLibs\ProcessDoubleCut.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessDovetail.lua               -s LuaLibs\ProcessDovetail.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessDrill.lua                  -s LuaLibs\ProcessDrill.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessDtMortise.lua              -s LuaLibs\ProcessDtMortise.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessDtTenon.lua                -s LuaLibs\ProcessDtTenon.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessFreeContour.lua            -s LuaLibs\ProcessFreeContour.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessFrenchRidgeLap.lua         -s LuaLibs\ProcessFrenchRidgeLap.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessHeadCut.lua                -s LuaLibs\ProcessHeadCut.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessLapJoint.lua               -s LuaLibs\ProcessLapJoint.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessLongCut.lua                -s LuaLibs\ProcessLongCut.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessLongDoubleCut.lua          -s LuaLibs\ProcessLongDoubleCut.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessMark.lua                   -s LuaLibs\ProcessMark.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessMortise.lua                -s LuaLibs\ProcessMortise.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessProfCamb.lua               -s LuaLibs\ProcessProfCamb.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessProfConcave.lua            -s LuaLibs\ProcessProfConcave.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessProfConvex.lua             -s LuaLibs\ProcessProfConvex.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessProfFront.lua              -s LuaLibs\ProcessProfFront.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessProfHead.lua               -s LuaLibs\ProcessProfHead.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessRidgeLap.lua               -s LuaLibs\ProcessRidgeLap.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessRoundArch.lua              -s LuaLibs\ProcessRoundArch.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessSawCut.lua                 -s LuaLibs\ProcessSawCut.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessScarfJoint.lua             -s LuaLibs\ProcessScarfJoint.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessSimpleScarf.lua            -s LuaLibs\ProcessSimpleScarf.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessSplit.lua                  -s LuaLibs\ProcessSplit.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessStepJoint.lua              -s LuaLibs\ProcessStepJoint.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessStepJointNotch.lua         -s LuaLibs\ProcessStepJointNotch.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessTenon.lua                  -s LuaLibs\ProcessTenon.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessText.lua                   -s LuaLibs\ProcessText.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessTyroleanDovetail.lua       -s LuaLibs\ProcessTyroleanDovetail.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\ProcessVariant.lua                -s LuaLibs\ProcessVariant.lua
+\EgtProg\Dll32\luac54 -o bin\BatchProcess.lua                          -s BatchProcess.lua
+\EgtProg\Dll32\luac54 -o bin\BatchProcessNew.lua                       -s BatchProcessNew.lua
+\EgtProg\Dll32\luac54 -o bin\GetBeamData.lua                           -s GetBeamData.lua
+\EgtProg\Dll32\luac54 -o bin\NestProcess.lua                           -s NestProcess.lua
+\EgtProg\Dll32\luac54 -o bin\Process.lua                               -s Process.lua
+\EgtProg\Dll32\luac54 -o bin\Rotate.lua                                -s Rotate.lua
+\EgtProg\Dll32\luac54 -o bin\Swap.lua                                  -s Swap.lua
+\EgtProg\Dll32\luac54 -o bin\Version.lua                               -s Version.lua
@@ -57,6 +57,12 @@
 --            Migliorata 'CompareFeatures' per ordine forature
 -- 2024/02/19 In Collect aggiunta la scrittura nella Proc di Width e Height delle facce.
 -- 2024/02/29 Migliorata 'CompareFeatures' per ordine forature
+-- 2024/03/04 Creata funzione calcolo dipendenze tra feature con calcolo topologia.
+-- 2024/03/07 Implementate le lavorazioni in doppio per fori specchiati non passanti e DrillPocket.
+-- 2024/03/11 In CollectFeatures si scrive ora Width e Height della faccia sia trimmate con il grezzo che intere.
+-- 2024/03/13 In CollectFeatures si scrive lunghezza foro su Proc e si controla se serve Predrill
+--            In OrderFeature, preforo sempre prima del foro
+-- 2024/04/11 In CollectFeatures aggiunta lettura info PRID, scritta in Proc.FeatureId

 -- Tabella per definizione modulo
 local BeamExec = {}
@@ -318,6 +324,7 @@ local function CollectFeatures( PartId, b3Raw, dCurrOvmH, dCurrOvmT)
            -- leggo se ci sono feature collegate
            local nAddAdjId = EgtGetInfo( ProcId, 'ADJID', 'i')
            local nAddMainId = EgtGetInfo( ProcId, 'MAINID', 'i')
+            local nFeatureId = EgtGetInfo( ProcId, 'PRID', 'i')
            if nGrp and nPrc and nDo == 1 then
               local Proc = {}
               Proc.PartId = PartId
@@ -331,6 +338,7 @@ local function CollectFeatures( PartId, b3Raw, dCurrOvmH, dCurrOvmT)
               Proc.Fce = 0
               Proc.CutId = nCutId
               Proc.TaskId = nTaskId
+               Proc.FeatureId = nFeatureId or Proc.TaskId
               -- se ci sono feature collegate ne scrivo il riferimento nella Proc
               if nAddAdjId then
                  Proc.AdjId = Proc.Id + nAddAdjId
@@ -339,30 +347,28 @@ local function CollectFeatures( PartId, b3Raw, dCurrOvmH, dCurrOvmT)
               end
               Proc.Box = EgtGetBBoxGlob( ProcId, GDB_BB.STANDARD)
               if b3Raw then
-                  local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
                  -- recupero l'elenco delle facce della parte interessate dalla feature
                  Proc.AffectedFaces = BL.GetProcessAffectedFaces( Proc)
                  -- recupero informazioni sulle facce della feature
                  if not Proc.Face then
-                     Proc.Face = {}
-                     for i = 1, Proc.Fct do
-                        local _, dFaceWidth, dFaceHeight = BL.GetFaceHvRefDim( Proc.Id, i - 1, b3Raw)
-                        Proc.Face[i] = { Id = i - 1, VtN = EgtSurfTmFacetNormVersor( Proc.Id, i - 1, GDB_ID.ROOT ), Width = dFaceWidth, Height = dFaceHeight}
-                        if Proc.Fct < 10 then
-                           Proc.Face[i].Elevation = EgtSurfTmFacetElevationInBBox( Proc.Id, i - 1, b3Solid, true, GDB_ID.ROOT)
-                        end
-                     end
+                     Proc.Face = BL.GetFacetsInfo( Proc, b3Raw)
                  end
               end
-               if Proc.Box and not Proc.Box:isEmpty() then 
-                  Proc.NeedTopology = NeedTopologyFeature( Proc)
+               if Proc.Box and not Proc.Box:isEmpty() then
                  Proc.Head = IsHeadFeature( Proc, b3Raw, dCurrOvmH)
                  Proc.Tail, Proc.AdvTail = IsTailFeature( Proc, b3Raw, dCurrOvmH, dCurrOvmT)
                  table.insert( vProc, Proc)
                  -- se foro
                  if Drill.Identify( Proc) then
                     -- assegno diametro e facce di ingresso e uscita (dati tabelle sempre per riferimento)
-                     Proc.Diam, Proc.Fcs, Proc.Fce = Drill.GetData( Proc, b3Raw)
+                     Proc.Diam, Proc.Len, Proc.Fcs, Proc.Fce = Drill.GetData( Proc, b3Raw)
+                     -- verifico se devo inserire i prefori
+                     if Drill.IsPredrillNeeded( Proc) then
+                        local bAddProc, PredrillProc= Drill.AddPredrillFromDrillProc( Proc)
+                        if bAddProc then
+                           table.insert( vProc, PredrillProc)
+                        end
+                     end
                     -- verifico se necessaria seconda lavorazione da parte opposta per foro più lungo della punta
                     if Drill.Split( Proc, b3Raw) then
                        -- aggiorno flags prima parte foro (dati tabelle sempre per riferimento)
@@ -379,6 +385,7 @@ local function CollectFeatures( PartId, b3Raw, dCurrOvmH, dCurrOvmT)
                        Proc2.Box = BBox3d( Proc.Box)
                        Proc2.Fct = Proc.Fct
                        Proc2.Diam = Proc.Diam
+                        Proc2.Len = Proc.Len
                        Proc2.Head = Drill.IsHeadFeature( Proc2, b3Raw, dCurrOvmH)
                        Proc2.Tail = Drill.IsTailFeature( Proc2, b3Raw, dCurrOvmH)
                        Proc2.Fcs = Proc.Fce
@@ -388,6 +395,13 @@ local function CollectFeatures( PartId, b3Raw, dCurrOvmH, dCurrOvmT)
                        Proc2.AdjId = Proc.AdjId
                        Proc2.MainId = Proc.MainId
                        table.insert( vProc, Proc2)
+                        -- verifico se devo inserire i prefori
+                        if Drill.IsPredrillNeeded( Proc2) then
+                           local bAddProc, PredrillProc= Drill.AddPredrillFromDrillProc( Proc2)
+                           if bAddProc then
+                              table.insert( vProc, PredrillProc)
+                           end
+                        end
                     end
                  -- se BlockHaus HalfLap
                  elseif Proc.Prc == 37 then
@@ -795,11 +809,11 @@ local function OrderFeatures( vProc, b3Raw)
         return B1.Head
      end
      -- se entrambi di testa e intersecano stesse facce e primo è scasso a due facce e secondo è un profilo caudato, lo scasso è una riduzione e va fatto prima
-      if ( ( B1.Head and B2.Head) or ( B1.Tail and B2.Tail)) and ( LapJoint.Identify( B1) and B1.Fct == 2) and ( ProfCamb.Identify( B2)) then
+      if ( ( B1.Head and B2.Head) or ( B1.Tail and B2.Tail)) and B1.Topology == 'Rabbet' and ( ProfCamb.Identify( B2) or ProfConcave.Identify( B2) or ProfConvex.Identify( B2)) then
         return true
      end
      -- se entrambi di testa e intersecano stesse facce e primo è un profilo caudato e secondo è scasso a due facce, lo scasso è una riduzione e va lasciato dopo
-      if ( ( B1.Head and B2.Head) or ( B1.Tail and B2.Tail)) and ( LapJoint.Identify( B2) and B2.Fct == 2) and ( ProfCamb.Identify( B1)) then
+      if ( ( B1.Head and B2.Head) or ( B1.Tail and B2.Tail)) and B2.Topology == 'Rabbet' and ( ProfCamb.Identify( B1) or ProfConcave.Identify( B1) or ProfConvex.Identify( B1)) then
         return false
      end
      -- se entrambi di testa e primo è scasso o mortasa e secondo no va messo dopo
@@ -821,12 +835,12 @@ local function OrderFeatures( vProc, b3Raw)
         return true
      end
      -- se primo è foro e secondo è un ribasso, il foro va sempre prima a meno che il ribasso non sia di testa
-      if Drill.Identify(B1) and ( LapJoint.Identify(B2) or Mortise.Identify(B2)) and not B2.Head and
+      if Drill.Identify(B1) and ( LapJoint.Identify(B2) or Mortise.Identify(B2)) and B2.PassedByHole and
         B1.Box:getCenter():getX() > B2.Box:getMin():getX() and B1.Box:getCenter():getX() < B2.Box:getMax():getX() then
         return true
      end
      -- se primo è un ribasso e secondo è un foro, il ribasso va sempre dopo a meno che il ribasso non sia di testa
-      if ( LapJoint.Identify(B1) or Mortise.Identify(B1))and not B1.Head and Drill.Identify(B2) and
+      if ( LapJoint.Identify(B1) or Mortise.Identify(B1))and B1.PassedByHole and Drill.Identify(B2) and
         B2.Box:getCenter():getX() > B1.Box:getMin():getX() and B2.Box:getCenter():getX() < B1.Box:getMax():getX() then
         return false
      end
@@ -908,7 +922,11 @@ local function OrderFeatures( vProc, b3Raw)
      end
      -- se entrambi fori con posizione praticamente uguale ordino secondo diametro e faccia di inizio (Fcs)
      if B1.Prc == 40  and  B2.Prc == 40  and  abs( B1.Box:getCenter():getX() - B2.Box:getCenter():getX()) < dSmallDrillRange then
-         if abs( B1.Diam - B2.Diam) < 1.0 then
+         if B1.IsPredrill and not B2.IsPredrill then
+            return true
+         elseif not B1.IsPredrill and B2.IsPredrill then
+            return false
+         elseif abs( B1.Diam - B2.Diam) < 1.0 then
            if B1.Fcs == B2.Fcs then
               if abs( B1.Box:getCenter():getX() - B2.Box:getCenter():getX()) < 1.0  then
                  if abs( B1.Box:getCenter():getY() - B2.Box:getCenter():getY()) < 1.0  then
@@ -1252,20 +1270,6 @@ local function ClassifyFeatures( vProc, b3Raw, Stats)
   return bAllOk, bSomeDown, bSomeSide, bSplitRot
 end

-------------------------------------------------------------------------------------------------------------
-local function ClassifyTopology( vProc, nRawId)
-   local b3Raw = EgtGetRawPartBBox( nRawId)
-   local nRecognized = 0
-   for i = 1, #vProc do
-      local Proc = vProc[i]
-      if Topology.Classify( Proc, b3Raw) then
-         nRecognized = nRecognized + 1
-      end
-   end
-
-   return nRecognized
-end
-
 -------------------------------------------------------------------------------------------------------------
 local function AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, bNeedHCut, b3Raw, nOrd, sDownOrSideOrStd, bPreMove, vtMove, dCurrOvmT)
   local bOk = true
@@ -1566,30 +1570,29 @@ local function CheckMirrorPocket( Proc, ProcMirror, b3Raw, AuxId)
         return false
      end
   end
-   -- devono avere il centro allineato, essere equidistanti dalla mezzaria trave e non essere troppo vicine
+   -- devono avere il centro allineato, essere equidistanti dalla mezzeria trave e non essere troppo vicine
   local vtDisplacement = ptBC - ptBCMirror
   local ptCenRaw = b3Raw:getCenter()
-   local dMinimumDistanceMirroredFeatures = 50
   if AreSameOrOppositeVectorApprox( vtExtr, Y_AX()) then
      local dYMinDistance = max( b3Proc:getMin():getY(), b3ProcMirror:getMin():getY()) - min( b3Proc:getMax():getY(), b3ProcMirror:getMax():getY())
-      if not ( abs( vtDisplacement:getX()) < 500 * GEO.EPS_SMALL and abs( vtDisplacement:getZ()) < 500 * GEO.EPS_SMALL and 
+      if not ( 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 and
-               dYMinDistance > dMinimumDistanceMirroredFeatures + 10 * GEO.EPS_SMALL) then
+               dYMinDistance > MIRROR_POCKETS_MIN_DISTANCE + 10 * GEO.EPS_SMALL) then
         return false
      end
   elseif AreSameOrOppositeVectorApprox( vtExtr, Z_AX()) then
      local dZMinDistance = max( b3Proc:getMin():getZ(), b3ProcMirror:getMin():getZ()) - min( b3Proc:getMax():getZ(), b3ProcMirror:getMax():getZ())
-      if not ( abs( vtDisplacement:getX()) < 500 * GEO.EPS_SMALL and abs( vtDisplacement:getY()) < 500 * GEO.EPS_SMALL and 
+      if not ( 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 and
-               dZMinDistance > dMinimumDistanceMirroredFeatures + 10 * GEO.EPS_SMALL) then
+               dZMinDistance > MIRROR_POCKETS_MIN_DISTANCE + 10 * GEO.EPS_SMALL) then
         return false
      end
   else
      return false
   end
   -- devono avere box con le stesse dimensioni
-   if not ( abs( b3DtMrt:getDimX() - b3DtMrtMirror:getDimX()) < 500 * GEO.EPS_SMALL and 
-            abs( b3DtMrt:getDimY() - b3DtMrtMirror:getDimY()) < 500 * GEO.EPS_SMALL and 
+   if not ( abs( b3DtMrt:getDimX() - b3DtMrtMirror:getDimX()) < 500 * GEO.EPS_SMALL and
+            abs( b3DtMrt:getDimY() - b3DtMrtMirror:getDimY()) < 500 * GEO.EPS_SMALL and
            abs( b3DtMrt:getDimZ() - b3DtMrtMirror:getDimZ()) < 500 * GEO.EPS_SMALL) then
      return false
   end
@@ -1781,18 +1784,21 @@ local function VerifyDrillMirrored( Proc, vProc, b3Raw)
   if not AuxId  or  EgtGetType( AuxId) ~= GDB_TY.CRV_ARC then
      return
   end
+   -- verifico se foratura splittata oppure da specchiare
+   local bIsDrillingOkForMirror = abs( Proc.Flg) == 2 or ( Proc.Mirror ~= nil)
+   if not bIsDrillingOkForMirror then return end
   -- recupero direzione e dimensioni del foro
   local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
   local dDiam = 2 * EgtArcRadius( AuxId)
   local dLen = abs( EgtCurveThickness( AuxId))
-   local dMachiningDepth = dLen / 2 + BD.DRILL_OVERLAP
+   local dMachiningDepth = EgtIf( abs( Proc.Flg) == 2, dLen / 2 + BD.DRILL_OVERLAP, dLen)
   -- recupero lavorazione adatta
   local sDrilling, sType, dMaxDepth = ML.FindDrilling( dDiam, dMachiningDepth, true, false, true)
   if not sDrilling then
      sDrilling, sType, dMaxDepth = ML.FindDrilling( dDiam, 0, true, false, true)
      dMachiningDepth = dMaxDepth or dMachiningDepth
   end
-   if not sDrilling or sType ~= 'Drill' or not EgtMdbSetCurrMachining( sDrilling) then
+   if not sDrilling or ( sType ~= 'Drill' and sType ~= 'Pocket') or not EgtMdbSetCurrMachining( sDrilling) then
      return
   end
   local dDrillingStep = EgtMdbGetCurrMachiningParam( MCH_MP.STEP)
@@ -1800,7 +1806,8 @@ local function VerifyDrillMirrored( Proc, vProc, b3Raw)
   if not EgtTdbSetCurrTool( EgtMdbGetCurrMachiningParam( MCH_MP.TOOL) or '') then
      return
   end
-   -- recupero la lunghezza della parte inclinata della punta
+   -- recupero diametro utensile e lunghezza della parte inclinata della punta
+   local dToolDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM, 'd')
   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')
@@ -1809,24 +1816,27 @@ local function VerifyDrillMirrored( Proc, vProc, b3Raw)
   end
   local dToolDoubleDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM, 'd')
   local dToolDoubleMaxDepth = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT)
+   dMachiningDepth = min( dMachiningDepth, dToolDoubleMaxDepth)
   -- recupero la lunghezza della parte inclinata della punta
   local dToolDoubleTipLength = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) - EgtTdbGetCurrToolParam( MCH_TP.LEN)
+   -- se foratura splittata, verifico che la distanza minima tra le due punte sia rispettata
+   if abs( Proc.Flg) == 2 and not ( ( ( 2 * dDrillingStep - dToolTipLength - dToolDoubleTipLength) - MIRROR_DRILLINGS_MIN_DISTANCE) > 10 * GEO.EPS_SMALL) then
+      return
+   end
   -- 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 and
-   (( 2 * dDrillingStep - dToolTipLength - dToolDoubleTipLength) - dMinimumDistanceMirroredFeatures) > 10 * GEO.EPS_SMALL then
-      if Proc.Fce ~= 0 then
+   if ( abs( dToolDiam - dToolDoubleDiam) < 10 * GEO.EPS_SMALL) then
+      if Proc.Fce ~= 0 or Proc.Mirror then
         if Proc.Flg == -2 then vtExtr = -vtExtr end
+         local ProcToDisable = EgtIf( abs( Proc.Flg) == 2, Proc, Proc.Mirror)
         if ( not BD.DOWN_HEAD and AreSameVectorApprox( vtExtr, Y_AX())) or
            ( BD.DOWN_HEAD and AreOppositeVectorApprox( vtExtr, Y_AX())) then
            Proc.Double = 2
            Proc.MachDepthDouble = dMachiningDepth
-            DisableOtherDrilling( Proc, vProc)
+            DisableOtherDrilling( ProcToDisable, vProc)
         elseif BD.DOWN_HEAD and AreSameVectorApprox( vtExtr, Z_AX()) then
            Proc.Double = 3
            Proc.MachDepthDouble = dMachiningDepth
-            DisableOtherDrilling( Proc, vProc)
+            DisableOtherDrilling( ProcToDisable, vProc)
         end
      end
   end
@@ -1908,11 +1918,111 @@ local function SetDrillingsToMachineAfterHeadOrTailCut( vProc, vMachineBeforeInt
   end
 end

+-------------------------------------------------------------------------------------------------------------
+local function AreDrillingsMirrored( Proc, ProcMirror, b3Raw)
+   if Proc.Id == ProcMirror.Id then return false end
+
+   -- geometria ausiliaria foro principale
+   AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i')
+   if AuxId then AuxId = AuxId + Proc.Id end
+   if not AuxId or EgtGetType( AuxId ) ~= GDB_TY.CRV_ARC then return false end
+   -- geometria ausiliaria foro specchiato
+   local AuxIdMirror = EgtGetInfo( ProcMirror.Id, 'AUXID', 'i')
+   if AuxIdMirror then AuxIdMirror = AuxIdMirror + ProcMirror.Id end
+   if not AuxIdMirror or EgtGetType( AuxIdMirror ) ~= GDB_TY.CRV_ARC then return false end
+   -- dati del foro principale
+   local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
+   local ptBC = EgtGP( AuxId, GDB_RT.GLOB)
+   -- dati del foro specchiato
+   local vtExtrMirror = EgtCurveExtrusion( AuxIdMirror, GDB_RT.GLOB)
+   local ptBCMirror = EgtGP( AuxIdMirror, GDB_RT.GLOB)
+
+   -- direzione fori
+   local nDouble
+   if AreOppositeVectorApprox( vtExtr, vtExtrMirror) then
+      -- fori lungo Y
+      -- per macchine tipo PF il foro principale è sul lato back, per macchine tipo PF1250 è sul lato front
+      if ( BD.TWO_EQUAL_HEADS and AreSameVectorApprox( vtExtr, Y_AX())) or
+      ( BD.DOWN_HEAD and AreOppositeVectorApprox( vtExtr, Y_AX())) then
+         nDouble = 2
+      -- fori lungo Z
+      elseif BD.DOWN_HEAD and AreSameVectorApprox( vtExtr, Z_AX()) then
+         nDouble = 3
+      else
+         return false
+      end
+   else
+      return false
+   end
+
+   -- centri allineati, equidistanti dalla mezzeria trave, non troppo vicini
+   local vtDisplacement = ptBC - ptBCMirror
+   local ptCenRaw = b3Raw:getCenter()
+   if nDouble == 2 then
+      local dYMinDistance = max( Proc.Box:getMin():getY(), ProcMirror.Box:getMin():getY()) - min( Proc.Box:getMax():getY(), ProcMirror.Box:getMax():getY())
+      if not ( abs( vtDisplacement:getX()) < 100 * GEO.EPS_SMALL and abs( vtDisplacement:getZ()) < 100 * GEO.EPS_SMALL and
+               ( abs( ptBC:getY() - ptCenRaw:getY()) - abs( ptBCMirror:getY() - ptCenRaw:getY())) < 100 * GEO.EPS_SMALL and
+               dYMinDistance > MIRROR_DRILLINGS_MIN_DISTANCE + 10 * GEO.EPS_SMALL) then
+         return false
+      end
+   else
+      local dZMinDistance = max( Proc.Box:getMin():getZ(), ProcMirror.Box:getMin():getZ()) - min( Proc.Box:getMax():getZ(), ProcMirror.Box:getMax():getZ())
+      if not ( abs( vtDisplacement:getX()) < 100 * GEO.EPS_SMALL and abs( vtDisplacement:getY()) < 100 * GEO.EPS_SMALL and
+               ( abs( ptBC:getZ() - ptCenRaw:getZ()) - abs( ptBCMirror:getZ() - ptCenRaw:getZ())) < 100 * GEO.EPS_SMALL and
+               dZMinDistance > MIRROR_DRILLINGS_MIN_DISTANCE + 10 * GEO.EPS_SMALL) then
+         return false
+      end
+   end
+
+   -- fori della stessa profondità
+   if abs( Proc.Len - ProcMirror.Len) > 10 * GEO.EPS_SMALL then
+      return false
+   end
+
+   return true
+end
+
+-------------------------------------------------------------------------------------------------------------
+function GetFeatureInfoAndDependency( vProc, b3Raw)
+   -- ciclo tutte le feature
+   for i = 1, #vProc do
+      local Proc = vProc[i]
+      -- calcolo topologia della feature
+      if NeedTopologyFeature( Proc) then
+         Topology.Classify( Proc, b3Raw)
+      -- se non richiesto, setto 'SPECIAL'
+      else
+         Proc.Topology = 'SPECIAL'
+         Proc.TopologyLongName = Proc.Topology
+      end
+      -- controllo la feature con tutte le altre per recuperare le dipendenze
+      for j = 1, #vProc do
+         local ProcB = vProc[j]
+         -- verifico se feature tipo LapJoint è attraversata da almeno un foro
+         if ( Proc.Topology == 'Pocket' or Proc.Topology == 'Tunnel' or Proc.Topology == 'Groove' or Mortise.Identify( Proc)) and Drill.Identify( ProcB) and Overlaps( Proc.Box, ProcB.Box) then
+            Proc.PassedByHole = true
+         end
+         -- verifiche per specchiature
+         if BD.DOWN_HEAD or BD.TWO_EQUAL_HEADS then
+            -- forature
+            if BD.DOUBLE_HEAD_DRILLING and Drill.Identify( Proc) and Drill.Identify( ProcB) and not Proc.Mirror then
+               if AreDrillingsMirrored( Proc, ProcB, b3Raw) then
+                  Proc.Mirror = ProcB
+               end
+            end
+         end
+      end
+   end
+end
+
 -------------------------------------------------------------------------------------------------------------
 function BeamExec.ProcessFeatures()
   if BD.IMPROVE_HEAD_TAIL_DRILLINGS == nil then
      BD.IMPROVE_HEAD_TAIL_DRILLINGS = true
   end
+   -- costanti per doppio
+   MIRROR_DRILLINGS_MIN_DISTANCE = 40
+   MIRROR_POCKETS_MIN_DISTANCE = 50
   -- verifica se possibile rotazione di 90 gradi
   BD.ROT90 = BD.ROT90 and Verify90DegRotation( EgtGetFirstRawPart())
   -- ciclo sui pezzi
@@ -1941,17 +2051,18 @@ function BeamExec.ProcessFeatures()
      local dCurrOvmT = EgtGetInfo( nRawId, 'TOVM', 'd') or 0
      -- recupero le feature di lavorazione della trave
      local vProc = CollectFeatures( nPartId, b3Raw, dCurrOvmH, dCurrOvmT)
+      -- recupero informazioni ausiliarie feature e dipendenze tra feature stesse
+      GetFeatureInfoAndDependency( vProc, b3Raw)
+
      -- verifica presenza forature influenzate da lavorazioni di testa o coda
      if BD.IMPROVE_HEAD_TAIL_DRILLINGS then
-         vMachBeforeIntersDrillings = CalcHeadTailMachBeforeIntersDrillings( vProc, b3Raw)
+         local vMachBeforeIntersDrillings = CalcHeadTailMachBeforeIntersDrillings( vProc, b3Raw)
         SetDrillingsToMachineAfterHeadOrTailCut( vProc, vMachBeforeIntersDrillings)
      end
      -- verifica presenza di feature specchiate per eventuali lavorazioni simultanee
      if BD.TWO_EQUAL_HEADS or BD.DOWN_HEAD then
         SetMirroredFeatures( vProc, b3Raw)
      end
-      -- classifico topologicamente le feature
-      ClassifyTopology( vProc, nRawId)
      -- le ordino lungo X
      OrderFeatures( vProc, b3Raw)
      -- le classifico
@@ -1989,6 +2100,10 @@ function BeamExec.ProcessFeatures()
            -- creo la lavorazione
            local Proc = vProc[i]
            if Proc.Flg ~= 0 and Proc.Down then
+               -- dato che ho ruotato, aggiorno alcune proprietà della feature
+               Proc.Box = EgtGetBBoxGlob( Proc.Id, GDB_BB.STANDARD)
+               Proc.Face = BL.GetFacetsInfo( Proc, b3Raw)
+               Proc.AffectedFaces = BL.GetProcessAffectedFaces( Proc)
               Proc.PrevDouble = nPrevDouble
               nPrevDouble = Proc.Double
               local bOk, sMsg, nNewPhase = AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, bNeedHCut, b3Raw, nOrd, sDownOrSideOrStd, nil, nil, dCurrOvmT)
@@ -2066,6 +2181,10 @@ function BeamExec.ProcessFeatures()
            -- creo la lavorazione
            local Proc = vProc[i]
            if Proc.Flg ~= 0 and Proc.Side then
+               -- dato che ho ruotato, aggiorno alcune proprietà della feature
+               Proc.Box = EgtGetBBoxGlob( Proc.Id, GDB_BB.STANDARD)
+               Proc.Face = BL.GetFacetsInfo( Proc, b3Raw)
+               Proc.AffectedFaces = BL.GetProcessAffectedFaces( Proc)
               Proc.PrevDouble = nPrevDouble
               nPrevDouble = Proc.Double
               local bOk, sMsg, nNewPhase = AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, false, b3Raw, nOrd, sDownOrSideOrStd, bPreMove, vtMove, dCurrOvmT)
@@ -2131,6 +2250,10 @@ function BeamExec.ProcessFeatures()
         -- creo la lavorazione
         local Proc = vProc[i]
         if Proc.Flg ~= 0 and ( not ( Proc.Down or Proc.Side) or BD.DOWN_HEAD or BD.TURN) then
+            -- dato che ho ruotato, aggiorno alcune proprietà della feature
+            Proc.Box = EgtGetBBoxGlob( Proc.Id, GDB_BB.STANDARD)
+            Proc.Face = BL.GetFacetsInfo( Proc, b3Raw)
+            Proc.AffectedFaces = BL.GetProcessAffectedFaces( Proc)
            Proc.PrevDouble = nPrevDouble
            nPrevDouble = Proc.Double
            local bOk, sMsg, nNewPhase = AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, false, b3Raw, nOrd, sDownOrSideOrStd, nil, nil, dCurrOvmT)
@@ -1169,4 +1169,47 @@ function BeamLib.IsFeatureCuttingEntireSection( b3Proc, dRawW, dRawH)
 end

 -------------------------------------------------------------------------------------------------------------
-return BeamLib
+function BeamLib.GetAdjacentFaces( Proc, nFacet)
+   local AdjacentFaces = {}
+   local vFaceAdjacencies = EgtSurfTmFacetAdjacencies( Proc.Id, nFacet)[1]
+   for i = 1, #vFaceAdjacencies do
+      if vFaceAdjacencies[i] > -1 then
+         local _, ptP1, ptP2 = EgtSurfTmFacetsContact( Proc.Id, nFacet, vFaceAdjacencies[i], GDB_ID.ROOT)
+         local dLen = dist( ptP1, ptP2)
+         table.insert( AdjacentFaces, { Id = vFaceAdjacencies[i], LengthOnMainFace = dLen})
+      end
+   end
+
+   return AdjacentFaces
+end
+
+-------------------------------------------------------------------------------------------------------------
+function BeamLib.GetFacetsInfo( Proc, b3Raw)
+   Face = {}
+   local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( Proc.PartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
+
+   for i = 1, Proc.Fct do
+      Face[i] = { Id = i - 1, VtN = EgtSurfTmFacetNormVersor( Proc.Id, i - 1, GDB_ID.ROOT )}
+      if Proc.Fct < 10 then
+         local frHV, dFaceWidthTrimmed, dFaceHeightTrimmed = BeamLib.GetFaceHvRefDim( Proc.Id, i - 1, b3Raw)
+         -- frame OCS faccia
+         Face[i].FrameHV = frHV
+         -- larghezza OCS faccia trimmata con grezzo
+         Face[i].WidthTrimmed = dFaceWidthTrimmed
+         -- altezza OCS faccia trimmata con grezzo
+         Face[i].HeightTrimmed = dFaceHeightTrimmed
+         local _, dFaceWidth, dFaceHeight = BeamLib.GetFaceHvRefDim( Proc.Id, i - 1)
+         -- larghezza OCS faccia
+         Face[i].Width = dFaceWidth
+         -- altezza OCS faccia
+         Face[i].Height = dFaceHeight
+         -- elevazione calcolata rispetto al box della parte
+         Face[i].Elevation = EgtSurfTmFacetElevationInBBox( Proc.Id, i - 1, b3Solid, true, GDB_ID.ROOT)
+      end
+   end
+
+   return Face
+end
+
+-------------------------------------------------------------------------------------------------------------
+return BeamLib
@@ -27,6 +27,7 @@
 -- 2024/01/18 Gestita lama con aggregato con asse bloccato per massimizzare capacità di taglio verticale, se da sotto.
 --            Implementata GetBlockedAxis che gestisce gli assi bloccati per tutti i tipi di utensile.
 -- 2024/02/22 Migliorato calcolo area non pinzabile in testa HCING e coda TCING
+-- 2024/03/27 In MakeTwo rimossa gestione calcolo differente su ultima passata in caso di macchina FAST

 -- Tabella per definizione modulo
 local FacesBySaw = {}
@@ -618,12 +619,7 @@ function FacesBySaw.MakeTwo( Proc, nPhase, nRawId, nPartId, dOvmHead, sCutType,
            local vtOrthO = EgtIf( ( i % 2) == 1, vtRef[nOtInd], vtRef[nUpInd])
            -- lavoro la faccia
            for j = 1, #vCuts[i] do
-               -- se FAST, pezzo alto e ultimo taglio verticale -> allungo uscita per consentire eventuale rotazione B sul posto
-               local dAccEnd = 0
-               if not BD.C_SIMM and BD.MAX_HEIGHT_ROT_B_ABOVE and b3Raw:getDimZ() > BD.MAX_HEIGHT_ROT_B_ABOVE and vtOrthO:getZ() > 0.866 and j == #vCuts[i] then
-                  dAccEnd = - ( dSawDiam / 2 + BD.CUT_SIC)
-               end
-               local bOk, sErr = FacesBySaw.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthO, dNzLimDwnUp, dCutExtra, BD.CUT_SIC, 0, 0, dAccEnd, nil, b3Raw)
+               local bOk, sErr = FacesBySaw.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthO, dNzLimDwnUp, dCutExtra, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
               if not bOk then
                  return bOk, sErr
               end
@@ -5,6 +5,7 @@
 -- 2023/10/16 In GetFacesParallelToPart rimossa Pocket e aggiunto Rabbet al check solo direzione principale
 -- 2023/11/03 In Classify ora si settano le AffectedFaces nella Proc, se non già presenti.
 --            Aggiunta groove 2 facce, differenziata da rabbet.
+-- 2024/03/04 Feature senza topologia, calcolato in BeamExec

 -- Tabella per definizione modulo
 local FeatureTopology = {}
@@ -112,11 +113,11 @@ end

 ---------------------------------------------------------------------
 -- restituisce un vettore contenente gli indici delle facce di Proc parallele ad una delle direzioni principali; il check varia in base alla famiglia topologica
-local function GetFacesParallelToPart( Proc, sFamily, bIsThrough)
+local function GetFacesParallelToPart( Proc, sFamily)
   local vFacesParallelToPart = {}
   for i = 0, Proc.Fct - 1 do
      local vtN = EgtSurfTmFacetNormVersor( Proc.Id, i, GDB_ID.ROOT)
-      if sFamily == 'Rabbet' or sFamily == 'Bevel' or sFamily == 'DoubleBevel' or sFamily == 'Strip' or sFamily == 'Tunnel' or ( sFamily == 'Groove' and bIsThrough) then
+      if sFamily == 'Rabbet' or sFamily == 'Bevel' or sFamily == 'DoubleBevel' or sFamily == 'Strip' then
         local vTriangularFaces = GetTriangularFaces( Proc)
         local bIsTriangularFace = false
         -- verifico se la faccia è triangolare
@@ -173,20 +174,18 @@ function FeatureTopology.Classify( Proc, b3Raw)
      return false
   end

-   -- se non richiesto (default true, quindi nil vale true), esco
-   if Proc.NeedTopology == false then
-      Proc.Topology = 'SPECIAL'
-      Proc.TopologyLongName = Proc.Topology
-      return true
-   end
-
   -- se già calcolato, esco
   if Proc.Topology then
      return true
   end

   -- calcoli
-   if not Proc.AffectedFaces then Proc.AffectedFaces = BL.GetProcessAffectedFaces( Proc) end
+   if not Proc.AffectedFaces then
+      Proc.AffectedFaces = BL.GetProcessAffectedFaces( Proc)
+   end
+   if not Proc.Face then
+      Proc.Face = BL.GetFacetsInfo( Proc, b3Raw)
+   end

   local vAdj = GetAdjacencyMatrix( Proc)
   local bAllAnglesConcave, bAllRightAngles = AreAllAnglesConcaveOrRight( vAdj)
@@ -214,6 +213,7 @@ function FeatureTopology.Classify( Proc, b3Raw)
   elseif Proc.Fct == 2 and bAllAnglesConcave and ( Proc.AffectedFaces.Left or Proc.AffectedFaces.Right) and ( Proc.AffectedFaces.Front or Proc.AffectedFaces.Back) then
      sFamily = 'Rabbet'
      bIsThrough = true
+   -- birdsmouth
   elseif Proc.Fct == 2 and bAllAnglesConcave then
      sFamily = 'Groove'
      bIsThrough = true
@@ -244,7 +244,7 @@ function FeatureTopology.Classify( Proc, b3Raw)
   end

   -- verifico se facce parallele a quelle della trave
-   local vFacesParallelToPart = GetFacesParallelToPart( Proc, sFamily, bIsThrough)
+   local vFacesParallelToPart = GetFacesParallelToPart( Proc, sFamily)
   local bIsParallel = ( #vFacesParallelToPart == Proc.Fct)

   -- assegnazioni
@@ -254,6 +254,7 @@ function FeatureTopology.Classify( Proc, b3Raw)
      Proc.IsThrough = bIsThrough
      Proc.AllRightAngles = bAllRightAngles
      Proc.IsParallel = bIsParallel
+      Proc.vAdj = vAdj
      return true
   else
      Proc.Topology = 'OTHER'
@@ -12,6 +12,8 @@
 -- 2024/01/19 In FindSawing aggiunto parametro opzionale bConsiderCSimmEncumberance per considerare l'ingombro dell'asse C nel massimo materiale (default false).
 -- 2024/01/23 Nella GetMachinings vengono ora raccolti i parametri utensile necessari per i VerifyTool, scritti direttamente nella tabella Machining.Tool.
 --            Le lavorazioni possono essere ora ordinate per dimensioni utensile (Longest, Shortest, Biggest, Smallest) se passato l'apposito parametro SortingCriterion in FindMachining. Al momento implementato solo per FindSawing.
+-- 2024/03/01 In VerifyPocketing implementato l'ordinamento per dimensioni utensile.
+-- 2024/03/13 Aggiunta gestione Predrill

 -- Tabella per definizione modulo
 local MachiningLib = {}
@@ -168,7 +170,7 @@ end
 ---------------------------------------------------------------------
 function VerifyTool( Machining, MachiningType, Params, bH2)
   if MachiningType == MCH_MY.DRILLING then
-      if Machining.SubType == 'Drill' or Machining.SubType == 'AngleDrill' then
+      if Machining.SubType == 'Drill' or Machining.SubType == 'AngleDrill' or Machining.SubType == 'Predrill' then
         return VerifyDrill( Machining, Params.Diam, Params.Depth, bH2)
      elseif Machining.SubType == 'DrillPocket' then
         return VerifyDrillPocket( Machining, Params.Diam, Params.Depth, bH2)
@@ -224,6 +226,8 @@ function GetMachinings( MachiningType, sType)
                     Machining.SubType = 'AngleDrill'
                  elseif EgtStartsWith( Machining.Type, 'Pocket') then
                     Machining.SubType = 'DrillPocket'
+                  elseif EgtStartsWith( Machining.Type, 'Predrill') then
+                     Machining.SubType = 'Predrill'
                  end
               end
               Machining.Tool.Diameter = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
@@ -299,7 +303,7 @@ end
 function ReturnParams( MachiningType, MachiningName, sType, ToolParams)
   if MachiningType == MCH_MY.DRILLING then
      local _, sOrigType = EgtEndsWith( sType, '_H2')
-      return MachiningName, sType, EgtIf( sOrigType == 'Drill' or sOrigType == 'Drill_AT' or sOrigType == 'AngleDrill' , ToolParams.TMaxMat, ToolParams.TMaxDepth), ToolParams.MaxToolLength, ToolParams.ToolDiam, ToolParams.DiamTh, ToolParams.FreeLen
+      return MachiningName, sType, EgtIf( sOrigType == 'Drill' or sOrigType == 'Drill_AT' or sOrigType == 'AngleDrill' or sOrigType == 'Predrill' , ToolParams.TMaxMat, ToolParams.TMaxDepth), ToolParams.MaxToolLength, ToolParams.ToolDiam, ToolParams.DiamTh, ToolParams.FreeLen
   elseif MachiningType == MCH_MY.SAWING then
      return MachiningName, ToolParams.H2
   elseif MachiningType == MCH_MY.MILLING then
@@ -466,8 +470,15 @@ function MachiningLib.FindCutting( sType, bTopHead, bDownHead)
 end

 ---------------------------------------------------------------------
-function MachiningLib.FindDrilling( dDiam, dDepth, bTopHead, bDownHead, bExcludeH2, bAngleTransmission)
-   local MachiningName, MachiningType, Param1, Param2, Param3, Param4, Param5 = FindMachining( MCH_MY.DRILLING, EgtIf( bAngleTransmission, 'Drill_AT', 'Drill'), { Diam = dDiam, Depth = dDepth}, bTopHead, bDownHead, bExcludeH2)
+function MachiningLib.FindDrilling( dDiam, dDepth, bTopHead, bDownHead, bExcludeH2, bAngleTransmission, bIsPredrill)
+   local MachiningName, MachiningType, Param1, Param2, Param3, Param4, Param5, sTypeMach
+   -- se il foro è un predrill, cerco solo punte abilitate al Predrill
+   if bIsPredrill then
+      sTypeMach = 'Predrill'
+   else
+      sTypeMach = EgtIf( bAngleTransmission, 'Drill_AT', 'Drill')
+   end
+   MachiningName, MachiningType, Param1, Param2, Param3, Param4, Param5 = FindMachining( MCH_MY.DRILLING, sTypeMach, { Diam = dDiam, Depth = dDepth}, bTopHead, bDownHead, bExcludeH2)
   if ( not MachiningName or MachiningName == '') then
      MachiningName, MachiningType, Param1, Param2, Param3, Param4, Param5 = FindMachining( MCH_MY.DRILLING, EgtIf( bAngleTransmission, 'Pocket_AT', 'Pocket'), { Diam = dDiam, Depth = dDepth}, bTopHead, bDownHead)
   end
@@ -490,8 +501,8 @@ function MachiningLib.FindMilling( sType, dDepth, sTuuidMstr, dMaxDiam, dMaxTotL
 end

 ---------------------------------------------------------------------
-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)
+function MachiningLib.FindPocketing( sType, dMaxDiam, dDepth, dMaxTotLen, bTopHead, bDownHead, bExcludeH2, bExcludeH3, sSortingCriterion)
+   return FindMachining( MCH_MY.POCKETING, sType, { MaxDiam = dMaxDiam, Depth = dDepth, MaxTotLen = dMaxTotLen}, bTopHead, bDownHead, bExcludeH2, bExcludeH3, sSortingCriterion)
 end

 ---------------------------------------------------------------------
@@ -20,6 +20,8 @@
 -- 2023/07/28 Aggiunta gestione rinvio 90deg solo per forature da sotto esattamente verticali.
 -- 2023/09/26 Se errore in applicazione lavorazione si inverte e riprova solo se foratura singola su foro aperto.
 -- 2023/11/06 Migliorata gestione dei fori con AngularTransmission.
+-- 2024/03/13 Aggiunta gestione Predrill
+-- 2024/03/18 Per Predrill corretta direzione estrusione per fori con direzione verso il basso

 -- Tabella per definizione modulo
 local ProcessDrill = {}
@@ -96,20 +98,21 @@ end
 ---------------------------------------------------------------------
 -- Recupero dati foro e adattamento se speciale
 function ProcessDrill.GetData( Proc, b3Raw)
+   local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i')
   -- verifico se foro da adattare
   if EgtExistsInfo( Proc.Id, 'DiamUser') then
-      local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i')
      if AuxId then AuxId = AuxId + Proc.Id end
      if AuxId and EgtGetType( AuxId) == GDB_TY.CRV_ARC and BD.USER_HOLE_DIAM and BD.USER_HOLE_DIAM > 1 then
         EgtModifyArcRadius( AuxId, BD.USER_HOLE_DIAM / 2)
      end
   end
-   -- recupero diametro
+   -- recupero diametro e lunghezza
   local dDiam = EgtGetInfo( Proc.Id, 'P12', 'd') or 0
+   local dLen = abs( EgtCurveThickness( Proc.Id + AuxId)) or 0
   -- recupero faccia di entrata e uscita
   local nFcs = EgtGetInfo( Proc.Id, 'FCS', 'i') or 0
   local nFce = EgtGetInfo( Proc.Id, 'FCE', 'i') or 0
-   return dDiam, nFcs, nFce
+   return dDiam, dLen, nFcs, nFce
 end

 ---------------------------------------------------------------------
@@ -139,6 +142,75 @@ function ProcessDrill.Split( Proc, b3Raw)
   return ( bOpen and ( bHoriz or BD.ROT90 or BD.DOWN_HEAD or BD.TURN or bAngTransm) and not bSlant)
 end

+---------------------------------------------------------------------
+-- Verifica se bisogna aggiungere un preforo
+function ProcessDrill.IsPredrillNeeded( Proc)
+   local dDepthPredrill = EgtGetInfo( Proc.Id, 'Q03', 'i')
+   -- se non c'è la Q oppure se zero, allora non è da fare
+   if not dDepthPredrill or dDepthPredrill <= 0 then
+      return false
+   -- altrimenti Predrill da fare
+   else
+      return true
+   end
+end
+
+---------------------------------------------------------------------
+-- Aggiunge il preforo alla feature passata
+function ProcessDrill.AddPredrillFromDrillProc( Proc)
+   local dDepthPredrill = EgtGetInfo( Proc.Id, 'Q03', 'i')
+   -- foro più corto del preforo, allora è il foro che diventa il preforo stesso
+   if Proc.Len <= dDepthPredrill then
+      Proc.IsPredrill = true
+      Proc.IsPredrillOf = Proc.Id
+      return false
+   -- altrimenti creo un nuovo process
+   else
+      -- recupero gruppo per geometria aggiuntiva
+      local nAddGrpId = BL.GetAddGroup( Proc.PartId)
+      -- recupero e verifico l'entità foro
+      local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i') or 0
+      local ptCen = EgtCP( Proc.Id + AuxId, GDB_RT.GLOB)
+      local vtExtr = EgtCurveExtrusion( Proc.Id + AuxId, GDB_RT.GLOB)
+
+      -- copio foro originale
+      local nPreHoleId = EgtCopyGlob( Proc.Id, nAddGrpId)
+      local nPreHoleAux = EgtCopyGlob( Proc.Id + AuxId, nAddGrpId)
+
+      -- se foro invertito sposto geometria dall'altro lato del foro e inverto direzione estrusione
+      if Proc.Flg == -2 then
+         local vsExtr = -vtExtr * Proc.Len
+         EgtMove( nPreHoleAux, vsExtr, GDB_RT.GLOB)
+         EgtModifyCurveExtrusion( nPreHoleAux, -vtExtr, GDB_RT.GLOB)
+      end
+      EgtModifyCurveThickness( nPreHoleAux, -dDepthPredrill)
+
+      local PredrillProc = {}
+      -- definisco dati seconda parte
+      PredrillProc.PartId = Proc.PartId
+      PredrillProc.Id = nPreHoleId
+      PredrillProc.Grp = Proc.Grp
+      PredrillProc.Prc = Proc.Prc
+      PredrillProc.Flg = 1
+      PredrillProc.Box = Proc.Box
+      PredrillProc.Fct = Proc.Fct
+      PredrillProc.Diam = Proc.Diam
+      PredrillProc.Len = dDepthPredrill
+      PredrillProc.Head = Proc.Head
+      PredrillProc.Tail = Proc.Tail
+      PredrillProc.Fcs = Proc.Fcs
+      PredrillProc.Fce = 0 -- il preforo è sempre chiuso, non ha faccia di uscita
+      PredrillProc.CutId = Proc.CutId
+      PredrillProc.TaskId = Proc.TaskId
+      PredrillProc.AdjId = Proc.AdjId
+      PredrillProc.MainId = Proc.MainId
+      PredrillProc.IsPredrill = true
+      PredrillProc.IsPredrillOf = Proc.Id
+
+      return true, PredrillProc
+   end
+end
+
 ---------------------------------------------------------------------
 -- Classificazione della feature
 function ProcessDrill.Classify( Proc, b3Raw)
@@ -289,15 +361,15 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
   local bDrillUp = ( bDownDrill and vtExtr:getZ() > -0.421)
   local bExcludeH2 = false
   if Proc.Double and Proc.Double > 0 then
-      bMillUp = true
+      -- bMillUp = true
      bDrillDown = false
      bExcludeH2 = true
   end
   -- primo gruppo di controlli con lunghezza utensile pari a metà foro se passante
   -- recupero la lavorazione
-   local sDrilling, sType, dMaxDepth, dMaxToolLength, dToolDiam, dDiamTh, dToolFreeLen = ML.FindDrilling( dDiam, dCheckDepth, bDrillUp, bDrillDown, bExcludeH2, bDrillAngTrasm)
+   local sDrilling, sType, dMaxDepth, dMaxToolLength, dToolDiam, dDiamTh, dToolFreeLen = ML.FindDrilling( dDiam, dCheckDepth, bDrillUp, bDrillDown, bExcludeH2, bDrillAngTrasm, Proc.IsPredrill)
   if not sDrilling and dCheckDepth then
-      sDrilling, sType, dMaxDepth, dMaxToolLength, dToolDiam, dDiamTh, dToolFreeLen = ML.FindDrilling( dDiam, 0, bDrillUp, bDrillDown, bExcludeH2, bDrillAngTrasm)
+      sDrilling, sType, dMaxDepth, dMaxToolLength, dToolDiam, dDiamTh, dToolFreeLen = ML.FindDrilling( dDiam, 0, bDrillUp, bDrillDown, bExcludeH2, bDrillAngTrasm, Proc.IsPredrill)
      if sDrilling then dCheckDepth = nil end
   end
   if not sDrilling then
@@ -454,7 +526,7 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
      dMaxElev = dMaxDepth
   end
   -- inserisco la lavorazione
-   local sName = 'Drill_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
+   local sName = EgtIf( EgtStartsWith( sType, 'Predrill'), 'Predrill_', 'Drill_') .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
   local nMchId = EgtAddMachining( sName, sDrilling)
   if not nMchId then
      local sErr = 'Error adding machining ' .. sName .. '-' .. sDrilling
@@ -464,7 +536,7 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
   -- aggiungo geometria
   EgtSetMachiningGeometry( {{ AuxId, -1}})
   -- eventuale inversione
-   if sType == 'Drill' or sType == 'Drill_H2' or sType == 'Drill_AT' or sType == 'AngleDrill' then
+   if sType == 'Drill' or sType == 'Drill_H2' or sType == 'Drill_AT' or sType == 'AngleDrill' or sType == 'Predrill' then
      EgtSetMachiningParam( MCH_MP.INVERT, bToInvert)
   else
      EgtSetMachiningParam( MCH_MP.TOOLINVERT, bToInvert)
@@ -9,6 +9,8 @@
 -- 2023/03/03 Corretta MakeByMark ( non definiti b3Raw e b3Aux ).
 -- 2023/06/21 In CalcSpecialAdd modificato l'angolo minimo da 5 a 15 deg.
 -- 2023/07/28 In MakeByPocket aggiunta Q06 per specificare un eventuale offset radiale del contorno.
+-- 2024/03/05 In MakebyPocket aggiunta lavorazione di smusso
+--            In MakeByMill eliminata doppia lavorazione smusso se contorno non passante

 -- Tabella per definizione modulo
 local ProcessFreeContour = {}
@@ -294,16 +296,18 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
   local bCross = false
   if abs( vtExtr:getX()) < 0.707 then
      if abs( vtExtr:getY()) > abs( vtExtr:getZ()) then
+         -- se è passante
         if b3Aux:getDimY() > b3Raw:getDimY() - 1.0 then
            bCross = true
            dDepth = min( dDepth, b3Raw:getDimY() / abs( vtExtr:getY()))
         end
         if bDown then
-            nSide = -1 
+            nSide = -1
         else
-            nSide = 1 
+            nSide = 1
         end
      else
+         -- se è passante
         if b3Aux:getDimZ() > b3Raw:getDimZ() - 1.0 then
            bCross = true
            dDepth = min( dDepth, b3Raw:getDimZ() / abs( vtExtr:getZ()))
@@ -373,28 +377,28 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
   if nChamfer > 0 and Proc.Grp ~= 0 and dOriDepth > dDepthCham and Proc.Prc ~= 70 then
      local bDoubleCham = false
      local dExtra = 2
-   local sChamferDown, sChamferUp
-   if nDouble > 1 and bCanDouble then
-      if nSide == 0  then
-         if BD.DOWN_HEAD then               
-            -- recupero la lavorazione
-            local nChamferDown
-            nChamferDown, _, sChamferDown = VerifyChamfer( Proc, AuxId, nRawId, true, true)
-            if nChamferDown < 0 then
+      local sChamferDown, sChamferUp
+      if nDouble > 1 and bCanDouble then
+         if nSide == 0  then
+            if BD.DOWN_HEAD then               
+               -- recupero la lavorazione
+               local nChamferDown
+               nChamferDown, _, sChamferDown = VerifyChamfer( Proc, AuxId, nRawId, true, true)
+               if nChamferDown < 0 then
+                  sWarn = 'Warning : chamfer from bottom not found in library'
+                  sChamferDown = nil
+                  EgtOutLog( sWarn)
+               end
+            end
+            local nChamferUp
+            nChamferUp, _, sChamferUp = VerifyChamfer( Proc, AuxId, nRawId, true, false)
+            if nChamferUp < 0 then
               sWarn = 'Warning : chamfer from bottom not found in library'
-               sChamferDown = nil
+               sChamferUp = nil
               EgtOutLog( sWarn)
            end
         end
-         local nChamferUp
-         nChamferUp, _, sChamferUp = VerifyChamfer( Proc, AuxId, nRawId, true, false)
-         if nChamferUp < 0 then
-            sWarn = 'Warning : chamfer from bottom not found in library'
-            sChamferUp = nil
-            EgtOutLog( sWarn)
-         end
      end
-   end
      -- eseguo
      for i = 1, nStep do
         -- inserisco la lavorazione
@@ -439,9 +443,9 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead)
            end
         end
         if nSide == 0 then
-            bDoubleCham = EgtIf( sChamferDown and BD.DOWN_HEAD, true, false)
+            bDoubleCham = EgtIf( sChamferDown and BD.DOWN_HEAD, true, false) and bCanDouble
         else
-            bDoubleCham = true
+            bDoubleCham = bCanDouble
         end
         -- assegno affondamento e offset radiale
         EgtSetMachiningParam( MCH_MP.DEPTH, dDepthCham + dExtra)
@@ -734,8 +738,72 @@ local function MakeByPocket( Proc, nPhase, nRawId, nPartId, dOvmHead)
   -- recupero i dati della curva e del profilo
   local dDepth = abs( EgtCurveThickness( AuxId))
   local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
-   --local bToolInv = ( vtExtr:getZ() < -0.1)
-   -- recupero la lavorazione
+   local bDownHead = ( BD.DOWN_HEAD and vtExtr:getZ() < 0.1)
+   local bToolInv = ( not bDownHead and vtExtr:getZ() < -0.1 and b3Aux:getDimZ() > b3Raw:getDimZ() - 5)
+   local dExtra = 2
+
+   -- verifico se servono gli smussi. Se lavorazione principale di svuotatura significa che è solo da un lato
+   -- generalmente sono lavorazioni non molto lunghe, quindi non si gestistono gli step
+   -- verifico i parametri Q per profondità smusso e per eseguirlo in esclusiva
+   local nChamfer, dDepthCham, sChamfer = VerifyChamfer( Proc, AuxId, nRawId, true)
+   -- se devo inserire il chamfer
+   if nChamfer > 0 and Proc.Grp ~= 0 and dDepth > dDepthCham and Proc.Prc ~= 70 then
+      -- inserisco la lavorazione
+      local sNameCh = 'Cham_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
+      local nMchId = EgtAddMachining( sNameCh, sChamfer)
+      if not nMchId then
+         local sErr = 'Error adding machining ' .. sNameCh .. '-' .. sChamfer
+         EgtOutLog( sErr)
+         return false, sErr
+      end
+      -- aggiungo geometria
+      EgtSetMachiningGeometry( {{ AuxId, -1}})
+      -- se lavorazione da sopra o da sotto
+      if Proc.Grp == 3 then
+         if not bToolInv then
+            EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
+            EgtSetMachiningParam( MCH_MP.INVERT, true)
+         else
+            EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
+            EgtSetMachiningParam( MCH_MP.INVERT, true)
+         end
+      end
+      if Proc.Grp == 4 then
+         if not bToolInv then
+            EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
+            EgtSetMachiningParam( MCH_MP.INVERT, true)
+         else
+            EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
+         end
+      end
+      -- assegno affondamento e offset radiale
+      EgtSetMachiningParam( MCH_MP.DEPTH, dDepthCham + dExtra)
+      EgtSetMachiningParam( MCH_MP.OFFSR, dExtra)
+      -- posizione braccio porta testa
+      local nSCC = MCH_SCC.NONE
+      if not BD.C_SIMM then
+         if Proc.Head then
+            nSCC = MCH_SCC.ADIR_XP
+         elseif Proc.Tail then
+            nSCC = MCH_SCC.ADIR_XM
+         elseif AreSameOrOppositeVectorApprox( vtExtr, Z_AX()) then
+            nSCC = MCH_SCC.ADIR_YP
+         elseif vtExtr:getY() > -0.01 then
+            nSCC = MCH_SCC.ADIR_YP
+         else
+            nSCC = MCH_SCC.ADIR_YM
+         end
+      end
+      EgtSetMachiningParam( MCH_MP.SCC, nSCC)
+      -- eseguo
+      if not ML.ApplyMachining( true, false) then
+         local _, sErr = EgtGetLastMachMgrError()
+         EgtSetOperationMode( nMchId, false)
+         return false, sErr
+      end
+   end
+
+   -- recupero la lavorazione di svuotatura
   local sPocketing = ML.FindPocketing( 'Pocket', nil, dDepth)
   if not sPocketing then
      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' pocketing not found in library'
@@ -1,4 +1,4 @@
-- ProcessLapJoint.lua by Egaltech s.r.l. 2023/09/26
+-- ProcessLapJoint.lua by Egaltech s.r.l. 2024/03/15
 -- Gestione calcolo mezzo-legno per Travi
 -- 2019/10/08 Agg. gestione OpenPocket.
 -- 2021/01/24 Con sega a catena ora sempre impostato asse A.
@@ -97,6 +97,14 @@
 --            Rimosso un caso di controllo per HCING/TCING
 -- 2024/02/29 In MakeMoreFaces passato b3Solid alla funzione ManageAntiSplintByMill
 -- 2024/02/29 In lapjoint 2 facce (TestTwoFacesDownHead) migliorata la scelta della lama da sotto.
+-- 2024/03/01 Migliorata VerifyPocket.
+-- 2024/03/04 Implementato attacco esterno se tasca 4 facce sulla coda ma nessun pezzo successivo.
+-- 2024/03/15 Correzione a calcolo ingombro per feature basse e lunghe dalla testa.
+-- 2024/04/02 In ForceSideMill escluso caso 4 facce senza possibilità di ingresso lungo Y.
+-- 2024/04/11 Aggiunta strategia SawPlusChain per lavorazione tasche con lama + sega a catena opzionale. Attivata con Q11.
+-- 2024/04/15 In SideMillAsSaw gestito anche rabbet
+-- 2024/04/17 In MakeMoreLongFaces corretto calcolo divisione in parti per evitare problemi di ceil con interi perfetti (ceil(3) = 3 o 4??)
+-- 2024/04/22 In IsTailFeature se LapJoint a 2 facce che taglia intera sezione, deve essere fatto dopo taglio di coda

 -- Tabella per definizione modulo
 local ProcessLapJoint = {}
@@ -170,6 +178,7 @@ local function AssignQIdent( Proc)
   Q_ANTISPLINT_TYPE    = ''
   Q_MAX_ELEVATION      = 'Q10'
   Q_STAIRCASE          = ''
+   Q_SAW_PLUS_CHAIN     = 'Q11'

   if ( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 16 then
      Q_FORCE_BLADE         = 'Q01' -- i
@@ -366,11 +375,7 @@ local function VerifyPocket( Proc, dDiam, dDepth, dMaxTotLen, sMchFindMaster, bP
   local sPocketing
   if dDepth then
      sPocketing = ML.FindPocketing( sMchFind, dDiam, dDepth, dMaxTotLen, bPocketUp, bPocketDown) or
-                   ML.FindPocketing( sMchFind, dDiam, 0.8 * dDepth, dMaxTotLen, bPocketUp, bPocketDown) or
-                   ML.FindPocketing( sMchFind, dDiam, 0.7 * dDepth, dMaxTotLen, bPocketUp, bPocketDown) or
-                   ML.FindPocketing( sMchFind, dDiam, 0.6 * dDepth, dMaxTotLen, bPocketUp, bPocketDown) or
-                   ML.FindPocketing( sMchFind, dDiam, 0.5 * dDepth, dMaxTotLen, bPocketUp, bPocketDown) or
-                   ML.FindPocketing( sMchFind, dDiam, 0.4 * dDepth, dMaxTotLen, bPocketUp, bPocketDown) or
+                   ML.FindPocketing( sMchFind, dDiam, 0, dMaxTotLen, bPocketUp, bPocketDown, nil, nil, 'Longest') or
                   ML.FindPocketing( sMchFind, dDiam, 0, dMaxTotLen)
   else
      sPocketing = ML.FindPocketing( sMchFind, dDiam, 0, dMaxTotLen)
@@ -548,9 +553,9 @@ local function VerifySideMillAsSaw( Proc, nAddGrpId, vtN, dDiam, dFacElev)
   -- cancello la copia del percorso
   EgtErase( nTestId)
   -- eseguo test
-   if not bNewIsU then
-      return false
-   end
+  if not bNewIsU and not Proc.TopologyLongName == 'Rabbet-Through-RightAngles-Parallel-2' then
+     return false
+  end
   -- Verifico sia abbastanza lunga
   if not (( Proc.TotBox and Proc.TotBox:getDimX() > ( BD.MIN_LEN_LAMELLO or 1000)) or
           ( not Proc.TotBox and Proc.Box:getDimX() > ( BD.MIN_LEN_LAMELLO or 1000))) then
@@ -663,8 +668,10 @@ local function UpdateEncumbrance( Proc, nRawId, b3Raw, b3Solid)
      elseif Proc.Box:getCenter():getX() > b3Solid:getCenter():getX() then
         local dOffs = b3Solid:getMax():getX() - Proc.Box:getMin():getX()
         local dDist = b3Solid:getMax():getX() - Proc.Box:getMax():getX()
-         -- se concavo aumento la distanza (rimane una punta...)
-         --if dAngT < 0 then dDist = dDist + 10 end
+         -- se pinze a 45° e pinza abbastanza materiale, compenso comunque, ma solo inclinazione morse
+         if not bIsVertClamps and dDeltaZClamp > BD.VICE_MINH and BD.VICE_MAXH then
+            dOffs = min( dOffs, BD.VICE_MAXH - BD.VICE_MINH)
+         end
         BL.UpdateHCING( nRawId, dOffs, dDist)
      end
   end
@@ -726,6 +733,20 @@ function ProcessLapJoint.IsTailFeature( Proc, b3Raw)
         return true
      end
   end
+
+   -- se interessa l'intera sezione
+   if BL.IsFeatureCuttingEntireSection( Proc.Box, b3Raw:getDimY(), b3Raw:getDimZ()) then
+      -- caso con due facce
+      if Proc.Fct == 2 then
+         -- verifico che il versore risultante delle normali delle due facce sia orientato verso X-
+         local vtResult = ( EgtSurfTmFacetNormVersor( Proc.Id, 0, GDB_ID.ROOT) + EgtSurfTmFacetNormVersor( Proc.Id, 1, GDB_ID.ROOT))
+         vtResult:normalize()
+         if vtResult:getX() < 0.5 then
+            return true
+         end
+      end
+   end
+
   -- in base al tipo di feature attribuisco il significato dei parametri Q
   AssignQIdent( Proc)
   -- se può essere fatto con utensile tipo lama
@@ -4582,6 +4603,704 @@ local function MakeTunnelByChainSaw( Proc, sSawing, nLundIdFace, vtOrtho, dWorkD
   return true
 end

+---------------------------------------------------------------------
+--#region SawPlusChain
+
+-- 5 facce: la faccia di fondo è il fondo della tasca, la faccia da lavorare è grande, le facce laterali sono le due piccole
+-- 4 facce con faccia di fondo piccola: la faccia da lavorare è grande (2 adj) e l'unica faccia laterale è piccola
+-- 4 facce con faccia di fondo grande: la faccia da lavorare è piccola (3 adj) e le facce laterali sono le due piccole
+-- 3 facce: la faccia di fondo è il fondo della tasca, la faccia da lavorare è grande, non ci sono facce laterali
+
+-- TODO gestione messaggi in funzione apposita (almeno per append)
+
+-- TODO gestire topologia tunnel (anche da due lati)
+
+local SawPlusChain =  {}
+SawPlusChain.Saw = {}
+SawPlusChain.Chainsaw = {}
+
+
+function SawPlusChain.IsTopologyOk( Proc)
+   if Proc.TopologyLongName == 'Pocket-Blind-RightAngles-Parallel-5' or
+      Proc.TopologyLongName == 'Groove-Through-RightAngles-Parallel-3' or
+      Proc.TopologyLongName == 'Groove-Blind-RightAngles-Parallel-4' then
+
+      return true
+   else
+      return false
+   end
+end
+
+
+function SawPlusChain.GetBottomFace( Proc)
+   -- la faccia di fondo ha sempre Fct - 1 adiacenze. Se si trovano più facce di fondo si sceglie quella con minor elevazione
+   local vBottomFace = Topology.GetFacesWithGivenAdjacencyNumber( Proc, Proc.vAdj, Proc.Fct - 1)
+   local nBottomFace
+   if #vBottomFace > 1 then
+      local dMinElevation = GEO.INFINITO
+      for i = 1, #vBottomFace do
+         for j = 1, Proc.Fct do
+            if vBottomFace[i] == Proc.Face[j].Id then
+               if Proc.Face[j].Elevation < dMinElevation then
+                  dMinElevation = Proc.Face[j].Elevation
+                  nBottomFace = Proc.Face[j].Id
+               end
+            end
+         end
+      end
+   else
+      nBottomFace = vBottomFace[1]
+   end
+
+   local BottomFace = {}
+   BottomFace.Id = nBottomFace
+   BottomFace.Width = Proc.Face[nBottomFace + 1].Width
+   BottomFace.Height = Proc.Face[nBottomFace + 1].Height
+   BottomFace.Elevation = Proc.Face[nBottomFace + 1].Elevation
+   BottomFace.VtN = Proc.Face[nBottomFace + 1].VtN
+   if BottomFace.Height > BottomFace.Width then
+      BottomFace.Height, BottomFace.Width = BottomFace.Width, BottomFace.Height
+   end
+
+   return BottomFace
+end
+
+
+function SawPlusChain.GetFaceToMachine( Proc)
+   if not Proc.Pocket.BottomFace or not Proc.Pocket.BottomFace.Id then
+      Proc.Pocket.BottomFace = SawPlusChain.GetBottomFace( Proc)
+   end
+
+   -- facce adiacenti a quella di fondo, ordinate
+   local FacesAdjacentToBottom = BL.GetAdjacentFaces( Proc, Proc.Pocket.BottomFace.Id)
+   table.sort( FacesAdjacentToBottom, function( a, b) return a.LengthOnMainFace > b.LengthOnMainFace end)
+
+   -- si sceglie la faccia adiacente sul lato più lungo
+   local FaceToMachine = {}
+   FaceToMachine.Id = FacesAdjacentToBottom[1].Id
+   for i = 1, Proc.Fct do
+      if FaceToMachine.Id == Proc.Face[i].Id then
+         FaceToMachine.Width = Proc.Face[i].Width
+         FaceToMachine.Height = Proc.Face[i].Height
+         FaceToMachine.Elevation = Proc.Face[i].Elevation
+         FaceToMachine.VtN = Proc.Face[i].VtN
+         if FaceToMachine.Height > FaceToMachine.Width then
+            FaceToMachine.Height, FaceToMachine.Width = FaceToMachine.Width, FaceToMachine.Height
+         end
+      end
+   end
+
+   return FaceToMachine
+end
+
+
+function SawPlusChain.GetSideFaces( Proc)
+   if not Proc.Pocket.BottomFace or not Proc.Pocket.BottomFace.Id then
+      Proc.Pocket.BottomFace = SawPlusChain.GetBottomFace( Proc)
+   end
+   if not Proc.Pocket.FaceToMachine or not Proc.Pocket.FaceToMachine.Id then
+      Proc.Pocket.FaceToMachine = SawPlusChain.GetFaceToMachine( Proc)
+   end
+
+   -- facce adiacenti a quella di fondo, ordinate
+   local FacesAdjacentToBottom = BL.GetAdjacentFaces( Proc, Proc.Pocket.BottomFace.Id)
+   table.sort( FacesAdjacentToBottom, function( a, b) return a.LengthOnMainFace > b.LengthOnMainFace end)
+
+   -- si determina il criterio di scelta delle facce laterali
+   local FacesAdjacentToFaceToMachine = BL.GetAdjacentFaces( Proc, Proc.Pocket.FaceToMachine.Id)
+   local bIsFaceToMachineTheLargest = not ( Proc.Fct == 4 and #FacesAdjacentToFaceToMachine == 3)
+
+   local SideFaces = {}
+   for i = 1, #FacesAdjacentToBottom do
+      if ( not bIsFaceToMachineTheLargest and i < #FacesAdjacentToBottom) or
+         ( bIsFaceToMachineTheLargest and i > 2) then
+         table.insert( SideFaces, FacesAdjacentToBottom[i])
+         SideFaces[ #SideFaces].Id = FacesAdjacentToBottom[i].Id
+         SideFaces[ #SideFaces].Width = Proc.Face[FacesAdjacentToBottom[i].Id + 1].Width
+         SideFaces[ #SideFaces].Height = Proc.Face[FacesAdjacentToBottom[i].Id + 1].Height
+         SideFaces[ #SideFaces].Elevation = Proc.Face[FacesAdjacentToBottom[i].Id + 1].Elevation
+         SideFaces[ #SideFaces].VtN = Proc.Face[FacesAdjacentToBottom[i].Id + 1].VtN
+         if SideFaces[ #SideFaces].Height > SideFaces[ #SideFaces].Width then
+            SideFaces[ #SideFaces].Height, SideFaces[ #SideFaces].Width = SideFaces[ #SideFaces].Width, SideFaces[ #SideFaces].Height
+         end
+      end
+   end
+
+   return SideFaces
+end
+
+
+function SawPlusChain.GetToolFromMachining( sMachiningName)
+   local Tool = {}
+   if EgtMdbSetCurrMachining( sMachiningName) then
+      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
+         Tool.Name = EgtTdbGetCurrToolParam( MCH_TP.NAME)
+         Tool.IsCCW = ( EgtMdbGetCurrMachiningParam( MCH_MP.SPEED) < 0)
+         Tool.Type = EgtTdbGetCurrToolParam( MCH_TP.TYPE)
+         Tool.Diameter = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or 0
+         -- lama
+         if Tool.Type == MCH_TY.SAW_STD or Tool.Type == MCH_TY.SAW_FLAT then
+            Tool.Thickness = EgtTdbGetCurrToolParam(MCH_TP.THICK) or 0
+            Tool.MaxDepth = EgtTdbGetCurrToolMaxDepth() or 0
+            Tool.SideStep = EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'SIDESTEP', 'd')
+         -- sega a catena
+         elseif Tool.Type == MCH_TY.MORTISE_STD then
+            Tool.Length = EgtTdbGetCurrToolParam( MCH_TP.LEN) or 0
+            Tool.MaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) or 0
+            Tool.Width = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or 0
+            Tool.Thickness = EgtTdbGetCurrToolParam( MCH_TP.THICK) or 0
+            Tool.CornerRadius = EgtTdbGetCurrToolParam( MCH_TP.CORNRAD) or 0
+         -- altri utensili al momento non previsti
+         else
+            error( 'Wrong tool type')
+         end
+      end
+   end
+
+   return Tool
+end
+
+
+function SawPlusChain.GetVerticalSteps( Proc, Machining)
+   if not Proc.Pocket or not Proc.Pocket.Height then
+      error( 'Missing pocket depth')
+   elseif not Machining.Tool or not Machining.Tool.Thickness then
+      error( 'Missing tool thickness')
+   end
+   local VerticalSteps = {}
+   VerticalSteps.StepLength = 0
+   VerticalSteps.Count = ceil( ( Proc.Pocket.Height - 10 * GEO.EPS_SMALL) / Machining.Tool.Thickness)
+   if VerticalSteps.Count > 1 then
+      VerticalSteps.StepLength = ( Proc.Pocket.Height - Machining.Tool.Thickness) / ( VerticalSteps.Count - 1)
+   end
+
+   return VerticalSteps
+end
+
+
+function SawPlusChain.GetHorizontalSteps( Machining)
+   if not Machining.Depth then
+      error( 'Missing machining depth')
+   end
+   local HorizontalSteps = {}
+   HorizontalSteps.StepLength = 0
+   HorizontalSteps.Count = ceil( ( Machining.Depth - 10 * GEO.EPS_SMALL) / Machining.Tool.SideStep)
+   if HorizontalSteps.Count > 1 then
+      HorizontalSteps.StepLength = ( Machining.Depth - Machining.Tool.SideStep) / ( HorizontalSteps.Count - 1)
+   end
+
+   return HorizontalSteps
+end
+
+
+function SawPlusChain.CalculateLeadInOut( Proc, Machining)
+   -- TODO implementare le funzioni di Tool Collision Avoidance (vedi wiki e FacesBysaw -> CalcLeadInOutPerpGeom)
+
+   -- si determina se l'inizio o la fine della lavorazione sono chiusi e l'eventuale riduzione da applicare
+   local bIsStartClosed = false
+   local bIsEndClosed = false
+   local bIsMortising = ( Machining.Type == MCH_OY.MORTISING)
+   local dAddLengthToReduce = 0
+   if bIsMortising then
+      dAddLengthToReduce = Machining.Tool.Diameter / 2
+   else
+      dAddLengthToReduce = sqrt( Machining.Depth * Machining.Tool.Diameter - Machining.Depth * Machining.Depth)
+   end
+   if #( Proc.Pocket.SideFaces) == 2 then
+      bIsStartClosed = true
+      bIsEndClosed = true
+   elseif #( Proc.Pocket.SideFaces) == 1 then
+      local CCWDirection = ( Machining.FaceToMachine.VtN ^ Proc.Pocket.BottomFace.VtN)
+      if Machining.ToolInvert or bIsMortising then
+         CCWDirection = - CCWDirection
+      end
+      if CCWDirection * Proc.Pocket.SideFaces[1].VtN > 10 * GEO.EPS_SMALL then
+         if Machining.Tool.IsCCW then
+            bIsStartClosed = true
+         else
+            bIsEndClosed = true
+         end
+      else
+         if Machining.Tool.IsCCW then
+            bIsEndClosed = true
+         else
+            bIsStartClosed = true
+         end
+      end
+   end
+
+   local LeadIn = {}
+   local LeadOut = {}
+   LeadIn.StartAddLength = 0
+   LeadOut.EndAddLength = 0
+   if not bIsMortising then
+      LeadIn.Type = MCH_MILL_LI.LINEAR
+      LeadOut.Type = MCH_MILL_LI.LINEAR
+      LeadIn.TangentDistance = 0
+      LeadOut.TangentDistance = 0
+      LeadIn.PerpDistance = Proc.Pocket.Depth + BD.CUT_SIC
+      LeadOut.PerpDistance = Proc.Pocket.Depth + BD.CUT_SIC
+      LeadIn.Elevation = 0
+      LeadOut.Elevation = 0
+      LeadIn.CompLength = 0
+      LeadOut.CompLength = 0
+      if bIsStartClosed and bIsEndClosed then
+         LeadIn.StartAddLength = -dAddLengthToReduce
+         LeadOut.EndAddLength = -dAddLengthToReduce
+      elseif bIsStartClosed then
+         LeadIn.StartAddLength = -dAddLengthToReduce
+         -- eventuale correzione per accorciamento maggiore di larghezza tasca
+         LeadOut.EndAddLength = max( -LeadIn.StartAddLength - Proc.Pocket.Width + 10 * BD.CUT_EXTRA, BD.CUT_EXTRA)
+      elseif bIsEndClosed then
+         LeadOut.EndAddLength = -dAddLengthToReduce
+         -- eventuale correzione per accorciamento maggiore di larghezza tasca
+         LeadIn.StartAddLength = max( -LeadOut.EndAddLength - Proc.Pocket.Width + 10 * BD.CUT_EXTRA, BD.CUT_EXTRA)
+      else
+         LeadIn.StartAddLength = BD.CUT_EXTRA
+         LeadOut.EndAddLength = BD.CUT_EXTRA
+      end
+   else
+      if bIsStartClosed then
+         LeadIn.StartAddLength = -dAddLengthToReduce
+      else
+         LeadIn.StartAddLength = BD.CUT_EXTRA
+      end
+      if bIsEndClosed then
+         LeadOut.EndAddLength = -dAddLengthToReduce
+      else
+         LeadOut.EndAddLength = BD.CUT_EXTRA
+      end
+   end
+
+   return LeadIn, LeadOut
+end
+
+
+function SawPlusChain.ApplyMachining( Machining, b3Raw)
+   local sErr = ''
+   local nOperationId = EgtAddMachining( Machining.OperationName, Machining.Name)
+   if not nOperationId then
+      sErr = 'Error adding machining ' .. Machining.OperationName .. '-' .. Machining.Name
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+
+   -- impostazione parametri lavorazione
+   local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
+   EgtSetMachiningGeometry( {{ Machining.ProcId, Machining.FaceToMachine.Id}})
+   EgtSetMachiningParam( MCH_MP.FACEUSE, Machining.Faceuse)
+   EgtSetMachiningParam( MCH_MP.SCC, Machining.SCC)
+   EgtSetMachiningParam( MCH_MP.INVERT, Machining.Invert)
+   EgtSetMachiningParam( MCH_MP.WORKSIDE, Machining.Workside)
+   EgtSetMachiningParam( MCH_MP.TOOLINVERT, Machining.ToolInvert)
+   EgtSetMachiningParam( MCH_MP.OFFSR, Machining.RadialOffset)
+   EgtSetMachiningParam( MCH_MP.OFFSL, Machining.LongitudinalOffset)
+   if Machining.Type ~= MCH_OY.MORTISING then
+      EgtSetMachiningParam( MCH_MP.LEADINTYPE, Machining.LeadIn.Type)
+      EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, Machining.LeadOut.Type)
+      EgtSetMachiningParam( MCH_MP.LITANG, Machining.LeadIn.TangentDistance)
+      EgtSetMachiningParam( MCH_MP.LOTANG, Machining.LeadOut.TangentDistance)
+      EgtSetMachiningParam( MCH_MP.LIPERP, Machining.LeadIn.PerpDistance)
+      EgtSetMachiningParam( MCH_MP.LOPERP, Machining.LeadOut.PerpDistance)
+      EgtSetMachiningParam( MCH_MP.LIELEV, Machining.LeadIn.Elevation)
+      EgtSetMachiningParam( MCH_MP.LOELEV, Machining.LeadOut.Elevation)
+      EgtSetMachiningParam( MCH_MP.LICOMPLEN, Machining.LeadIn.CompLength)
+      EgtSetMachiningParam( MCH_MP.LOCOMPLEN, Machining.LeadOut.CompLength)
+   end
+   EgtSetMachiningParam( MCH_MP.STARTADDLEN, Machining.LeadIn.StartAddLength)
+   EgtSetMachiningParam( MCH_MP.ENDADDLEN, Machining.LeadOut.EndAddLength)
+   if Machining.Steps then
+      if Machining.Steps.StepType then
+         EgtSetMachiningParam( MCH_MP.STEPTYPE, Machining.Steps.StepType)
+      end
+      if Machining.Steps.StepLength then
+         EgtSetMachiningParam( MCH_MP.STEP, Machining.Steps.StepLength)
+      end
+   end
+   EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( Machining.Name, Machining.BlockedAxis.Orientation, b3Raw, Machining.FaceToMachine.VtN, Machining.BlockedAxis.VtOut))
+   if Machining.Type == MCH_OY.MORTISING then
+      EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( Machining.FaceToMachine.VtN, Machining.Direction, Machining.SuggestedAngles.Index))
+   end
+   EgtSetMachiningParam( MCH_MP.OVERL, Machining.Overlap)
+   EgtSetMachiningParam( MCH_MP.STARTPOS, max( Machining.StartSafetyLength, EgtGetMachiningParam( MCH_MP.STARTPOS)))
+   if Machining.MaxElev then
+      sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', Machining.MaxElev)
+   end
+   EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
+
+   local bIsApplyOk = ML.ApplyMachining( true, false)
+   if not bIsApplyOk then
+      local nErr
+      nErr, sErr = EgtGetLastMachMgrError()
+      -- se mortasatura e l'errore è compatibile (Axes values not calculable) si prova con l'altra configurazione dell'asse bloccato
+      -- TODO valutare se c'è modo di capire preventivamente la configurazione dell'asse bloccato e quindi rimuovere questa parte di codice
+      if Machining.Type == MCH_OY.MORTISING and nErr == 2507 then
+         if Machining.BlockedAxis.Orientation  == 'perpendicular' then
+            Machining.BlockedAxis.Orientation = 'parallel'
+         else
+            Machining.BlockedAxis.Orientation  = 'perpendicular'
+         end
+         EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( Machining.Name, Machining.BlockedAxis.Orientation, b3Raw, Machining.FaceToMachine.VtN, Machining.BlockedAxis.VtOut))
+         if Machining.SuggestedAngles.Index == 1 then
+            Machining.SuggestedAngles.Index = 2
+         else
+            Machining.SuggestedAngles.Index = 1
+         end
+         EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( Machining.FaceToMachine.VtN, Machining.Direction, Machining.SuggestedAngles.Index))
+         sErr = ''
+         bIsApplyOk = ML.ApplyMachining( true, false)
+      end
+      if not bIsApplyOk then
+         nErr, sErr = EgtGetLastMachMgrError()
+         EgtSetOperationMode( nOperationId, false)
+         return false, sErr
+      end
+   end
+
+   return true, sErr
+end
+
+
+function SawPlusChain.Saw.GetSCC( vtMachiningDirection)
+   -- TODO implementare SCC come per FacesBySaw
+   local nSCC = MCH_SCC.NONE
+   if AreSameVectorApprox( vtMachiningDirection, Z_AX()) then
+      nSCC = MCH_SCC.ADIR_ZP
+   elseif AreOppositeVectorApprox( vtMachiningDirection, Z_AX()) then
+      nSCC = MCH_SCC.ADIR_ZM
+   elseif AreSameVectorApprox( vtMachiningDirection, Y_AX()) then
+      nSCC = MCH_SCC.ADIR_YP
+   elseif AreOppositeVectorApprox( vtMachiningDirection, Y_AX()) then
+      nSCC = MCH_SCC.ADIR_YM
+   elseif AreSameVectorApprox( vtMachiningDirection, X_AX()) then
+      nSCC = MCH_SCC.ADIR_XP
+   elseif AreOppositeVectorApprox( vtMachiningDirection, X_AX()) then
+      nSCC = MCH_SCC.ADIR_XM
+   end
+
+   return nSCC
+end
+
+
+function SawPlusChain.Saw.CalculateMachiningParameters( Proc)
+   local Cutting = {}
+   Cutting.CanApply = true
+   Cutting.Message = ''
+   Cutting.ProcId = Proc.Id
+
+   -- ricerca lavorazione
+   Cutting.Name = ML.FindCutting( 'HeadSide', true, false)
+   if not Cutting.Name then
+      Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - saw blade not found'
+      Cutting.CanApply = false
+      EgtOutLog( Cutting.Message)
+      return Cutting
+   end
+   Cutting.Type = MCH_OY.MILLING
+   Cutting.Tool = SawPlusChain.GetToolFromMachining( Cutting.Name)
+   Cutting.FaceToMachine = Proc.Pocket.FaceToMachine
+
+   -- verifica dimensioni tasca compatibili
+   -- se tasca meno spessa della lama la strategia non è applicabile
+   if Cutting.Tool.Thickness > Proc.Pocket.Height + 10 * GEO.EPS_SMALL then
+      Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade thickness'
+      Cutting.CanApply = false
+      EgtOutLog( Cutting.Message)
+      return Cutting
+   end
+   if #( Proc.Pocket.SideFaces) > 1 then
+      -- se tasca più stretta della lama la strategia non è applicabile
+      if Cutting.Tool.Diameter > Proc.Pocket.Width + 10 * GEO.EPS_SMALL then
+         Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade diameter'
+         Cutting.CanApply = false
+         EgtOutLog( Cutting.Message)
+         return Cutting
+      end
+   end
+
+   -- parametri della lavorazione
+   -- direzione utensile
+   Cutting.Direction = Proc.Pocket.Direction
+   -- lato di lavoro e inversioni
+   if Cutting.Tool.IsCCW then
+      Cutting.Workside = MCH_MILL_WS.RIGHT
+      Cutting.Invert = true
+   else
+      Cutting.Workside = MCH_MILL_WS.LEFT
+      Cutting.Invert = false
+   end
+   -- TODO gestire lama da sotto e lama downUp
+   if Cutting.FaceToMachine.VtN:getZ() < - 10 * GEO.EPS_SMALL then
+      Cutting.ToolInvert = true
+      Cutting.Invert = not Cutting.Invert
+   else
+      Cutting.ToolInvert = false
+   end
+   -- profondità e offset radiale
+   if Cutting.Tool.MaxDepth > Proc.Pocket.Depth - 10 * GEO.EPS_SMALL then
+      Cutting.Depth = Proc.Pocket.Depth
+      Cutting.RadialOffset = 0
+   else
+      Cutting.Depth = Cutting.Tool.MaxDepth
+      Cutting.RadialOffset = Proc.Pocket.Depth - Cutting.Depth
+      if Proc.Pocket.ApplyOnlySawblade then
+         Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : sawblade elevation (' .. EgtNumToString( Proc.Pocket.Depth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( Cutting.Depth, 1) .. ')'
+         EgtOutLog( Cutting.Message)
+      end
+   end
+   -- step verticale e offset longitudinale
+   Cutting.Steps = SawPlusChain.GetVerticalSteps( Proc, Cutting)
+   Cutting.Steps.StepType = MCH_MILL_ST.ONEWAY
+   Cutting.MaxElev = Cutting.Steps.StepLength * Cutting.Steps.Count - 10 * GEO.EPS_SMALL
+   if Cutting.ToolInvert and Cutting.Steps.Count > 1 then
+      Cutting.LongitudinalOffset = - Proc.Pocket.Height
+   else
+      Cutting.LongitudinalOffset = 0
+   end
+   -- distanza di sicurezza
+   Cutting.StartSafetyLength = 10
+   -- overlap
+   Cutting.Overlap = 0
+   -- faceuse
+   Cutting.Faceuse = BL.GetNearestOrthoOpposite( Cutting.Direction)
+   -- SCC
+   Cutting.SCC = SawPlusChain.Saw.GetSCC( Cutting.Direction)
+   -- angoli suggeriti
+   Cutting.SuggestedAngles = ''
+   -- asse bloccato
+   Cutting.BlockedAxis = {}
+   Cutting.BlockedAxis.Orientation = 'perpendicular'
+   Cutting.BlockedAxis.VtOut = EgtIf( Cutting.FaceToMachine.VtN:getX() > 0, X_AX(), -X_AX())
+   -- approccio e retrazione
+   Cutting.LeadIn, Cutting.LeadOut = SawPlusChain.CalculateLeadInOut( Proc, Cutting)
+   -- eventuale step orizzontale
+   Cutting.HorizontalSteps = {}
+   if Cutting.Tool.SideStep then
+      Cutting.HorizontalSteps = SawPlusChain.GetHorizontalSteps( Cutting)
+   else
+      Cutting.HorizontalSteps.Count = 1
+      Cutting.HorizontalSteps.StepLength = 0
+   end
+   -- nome operazione
+   Cutting.OperationName = 'Cut_' .. ( EgtGetName( Cutting.ProcId) or tostring( Cutting.ProcId)) .. '_' .. tostring( Cutting.FaceToMachine.Id + 1)
+
+   -- eventuale avviso di danneggiamento pezzo successivo
+   local dOffsideLength = max( Cutting.LeadIn.StartAddLength, Cutting.LeadOut.EndAddLength) + Cutting.Tool.Diameter / 2 + 10 * GEO.EPS_SMALL
+   if ( not Proc.Tail or Proc.AdvTail) and Proc.AffectedFaces.Left and ( Proc.Pocket.DistanceToNextPart < dOffsideLength) then
+      local sDamageNextPieceMessage = 'Feature '.. Proc.FeatureId .. ' : sawblade can damage next piece.'
+      if #Cutting.Message > 0 then
+         Cutting.Message = Cutting.Message .. '\n' .. sDamageNextPieceMessage
+      else
+         Cutting.Message = sDamageNextPieceMessage
+      end
+      EgtOutLog( sDamageNextPieceMessage)
+   end
+
+   return Cutting
+end
+
+
+function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc)
+   local Chainsawing = {}
+   Chainsawing.CanApply = true
+   Chainsawing.Message = ''
+   Chainsawing.ProcId = Proc.Id
+
+   -- ricerca lavorazione
+   Chainsawing.Name = ML.FindSawing( 'Sawing', Proc.Pocket.Depth)
+   if not Chainsawing.Name then
+      Chainsawing.Name = ML.FindSawing( 'Sawing', nil, nil, 'Longest')
+   end
+   if not Chainsawing.Name then
+      Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - chainsaw not found'
+      Chainsawing.CanApply = false
+      EgtOutLog( Chainsawing.Message)
+      return Chainsawing
+   end
+   Chainsawing.Type = MCH_OY.MORTISING
+   Chainsawing.Tool = SawPlusChain.GetToolFromMachining( Chainsawing.Name)
+   Chainsawing.FaceToMachine = Proc.Pocket.FaceToMachine
+
+   -- verifica dimensioni tasca compatibili
+   -- se tasca meno spessa della sega a catena la strategia non è applicabile
+   if Chainsawing.Tool.Thickness > Proc.Pocket.Height + 10 * GEO.EPS_SMALL then
+      Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw thickness'
+      Chainsawing.CanApply = false
+      EgtOutLog( Chainsawing.Message)
+      return Chainsawing
+   end
+   if #( Proc.Pocket.SideFaces) > 1 then
+      -- se tasca più stretta della sega a catena la strategia non è applicabile
+      if Chainsawing.Tool.Width > Proc.Pocket.Width + 10 * GEO.EPS_SMALL then
+         Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw width'
+         Chainsawing.CanApply = false
+         EgtOutLog( Chainsawing.Message)
+         return Chainsawing
+      end
+   end
+
+   -- parametri della lavorazione
+   -- direzione utensile
+   Chainsawing.Direction = Proc.Pocket.Direction
+   -- lato di lavoro e inversioni
+   if Chainsawing.Tool.IsCCW then
+      Chainsawing.Workside = MCH_MILL_WS.RIGHT
+      Chainsawing.Invert = false
+   else
+      Chainsawing.Workside = MCH_MILL_WS.LEFT
+      Chainsawing.Invert = true
+   end
+   Chainsawing.ToolInvert = false
+   -- profondità e offset longitudinale
+   if Chainsawing.Tool.MaxMat > Proc.Pocket.Depth - 10 * GEO.EPS_SMALL then
+      Chainsawing.Depth = Proc.Pocket.Depth
+      Chainsawing.LongitudinalOffset = 0
+   else
+      Chainsawing.Depth = Chainsawing.Tool.MaxMat
+      Chainsawing.LongitudinalOffset = Proc.Pocket.Depth - Chainsawing.Depth
+      Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : chainsaw elevation (' .. EgtNumToString( Proc.Pocket.Depth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( Chainsawing.Depth, 1) .. ')'
+      EgtOutLog( Chainsawing.Message)
+   end
+   -- offset radiale
+   Chainsawing.RadialOffset = 0
+   -- distanza di sicurezza
+   Chainsawing.StartSafetyLength = Proc.Pocket.Depth
+   -- overlap
+   Chainsawing.Overlap = 0
+   -- faceuse
+   Chainsawing.Faceuse = BL.GetNearestParalOpposite( Chainsawing.Direction)
+   -- SCC
+   Chainsawing.SCC = MCH_SCC.NONE
+   -- asse bloccato e angoli suggeriti
+   Chainsawing.BlockedAxis = {}
+   Chainsawing.BlockedAxis.Orientation = 'perpendicular'
+   Chainsawing.SuggestedAngles = {}
+   Chainsawing.SuggestedAngles.Index = 1
+   -- approccio e retrazione
+   Chainsawing.LeadIn, Chainsawing.LeadOut = SawPlusChain.CalculateLeadInOut( Proc, Chainsawing)
+   -- eventuale step verticale
+   Chainsawing.VerticalSteps = SawPlusChain.GetVerticalSteps( Proc, Chainsawing)
+   -- nome operazione
+   Chainsawing.OperationName = 'Chainsaw_' .. ( EgtGetName( Chainsawing.ProcId) or tostring( Chainsawing.ProcId)) .. '_' .. tostring( Chainsawing.FaceToMachine.Id + 1)
+
+   -- eventuale avviso di danneggiamento pezzo successivo
+   local dOffsideLength = max( Chainsawing.LeadIn.StartAddLength, Chainsawing.LeadOut.EndAddLength) + Chainsawing.Tool.Width / 2 + 10 * GEO.EPS_SMALL
+   if ( not Proc.Tail or Proc.AdvTail) and Proc.AffectedFaces.Left and ( Proc.Pocket.DistanceToNextPart < dOffsideLength) then
+      local sDamageNextPieceMessage = 'Feature '.. Proc.FeatureId .. ' : chainsaw can damage next piece.'
+      if #Chainsawing.Message > 0 then
+         Chainsawing.Message = Chainsawing.Message .. '\n' .. sDamageNextPieceMessage
+      else
+         Chainsawing.Message = sDamageNextPieceMessage
+      end
+      EgtOutLog( sDamageNextPieceMessage)
+   end
+
+   return Chainsawing
+end
+
+
+function SawPlusChain.Make( Proc, nRawId, nPhase, bOnlySaw)
+   Proc.Pocket = {}
+   Proc.Pocket.ApplyOnlySawblade = bOnlySaw
+   Proc.Pocket.Strategy = 'SawPlusChain'
+   local b3Raw = EgtGetRawPartBBox( nRawId)
+
+   -- TODO per implementare la strategia con lapjoint lunghe bisogna prima riconoscere le topologie che arrivano
+   if Proc.IsSplittedLapJoint then
+      local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented for long lapjoint'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+
+   if not SawPlusChain.IsTopologyOk( Proc) then
+      local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+
+   -- se tasca su faccia sotto la strategia non è applicabile (la sega a catena in generale non può lavorare da sotto)
+   -- TODO se OnlySaw questo test è da rimuovere ma bisogna considerare anche la lama da sotto
+   if Proc.AffectedFaces.Bottom and ( Proc.Fct > 3 or not Proc.AffectedFaces.Top)  then
+      local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket on bottom face'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+
+   -- caratteristiche della tasca
+   Proc.Pocket.BottomFace = SawPlusChain.GetBottomFace( Proc)
+   Proc.Pocket.FaceToMachine = SawPlusChain.GetFaceToMachine( Proc)
+   Proc.Pocket.SideFaces = SawPlusChain.GetSideFaces( Proc)
+   Proc.Pocket.Width = Proc.Pocket.BottomFace.Width
+   Proc.Pocket.Height = Proc.Pocket.BottomFace.Height
+   Proc.Pocket.Depth = Proc.Pocket.BottomFace.Elevation
+   Proc.Pocket.Direction = Proc.Pocket.BottomFace.VtN
+   Proc.Pocket.DistanceToNextPart = BL.GetDistanceToNextPart( nRawId, nPhase)
+
+   -- parametri lavorazione di lama
+   local Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc)
+
+   -- applicazione lavorazione di lama con eventuali step XY
+   local bIsCuttingOk = false
+   local sCuttingApplyMessage = ''
+   if Cutting.CanApply then
+      local dOriginalRadialOffset = Cutting.RadialOffset
+      local dOriginalLeadInPerpDistance = Cutting.LeadIn.PerpDistance
+      local dOriginalLeadOutPerpDistance = Cutting.LeadOut.PerpDistance
+      for i = Cutting.HorizontalSteps.Count, 1, -1 do
+         Cutting.RadialOffset = dOriginalRadialOffset + Cutting.HorizontalSteps.StepLength * ( i - 1)
+         -- update distanza perpendicolare attacco per contemplare l'offset applicato
+         Cutting.LeadIn.PerpDistance = dOriginalLeadInPerpDistance - Cutting.RadialOffset
+         Cutting.LeadOut.PerpDistance = dOriginalLeadOutPerpDistance - Cutting.RadialOffset
+         -- applicazione lavorazione
+         bIsCuttingOk, sCuttingApplyMessage = SawPlusChain.ApplyMachining( Cutting, b3Raw)
+         -- update messaggi
+         if sCuttingApplyMessage and #sCuttingApplyMessage > 0 then
+            Cutting.Message = Cutting.Message .. 'Apply : ' .. sCuttingApplyMessage .. '\n'
+         end
+      end
+   end
+
+   -- se tasca passante e la lama è arrivata sul fondo, non servono ulteriori lavorazioni
+   if #Proc.Pocket.SideFaces == 0 and Cutting.RadialOffset == 0 then
+      bOnlySaw = true
+   end
+   
+   if bOnlySaw or not bIsCuttingOk then
+      return bIsCuttingOk, Cutting.Message
+   end
+
+   -- parametri lavorazione con sega a catena
+   local Chainsawing = SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc)
+   -- si lavora solo quanto non lavorato dalla lama
+   Chainsawing.MaxElev = Cutting.RadialOffset + BD.CUT_EXTRA
+
+   -- applicazione lavorazione con sega a catena con eventuali step in Z
+   local bIsChainsawingOk = false
+   local sChainsawingApplyMessage = ''
+   if Chainsawing.CanApply then
+      local dOriginalRadialOffsetChainsawing = Chainsawing.RadialOffset
+      for i = Chainsawing.VerticalSteps.Count, 1, -1 do
+         Chainsawing.RadialOffset = dOriginalRadialOffsetChainsawing + Chainsawing.VerticalSteps.StepLength * ( i - 1)
+         -- applicazione lavorazione
+         bIsChainsawingOk, sChainsawingApplyMessage = SawPlusChain.ApplyMachining( Chainsawing, b3Raw)
+         -- update messaggi
+         if sChainsawingApplyMessage and #sChainsawingApplyMessage > 0 then
+            Chainsawing.Message = Chainsawing.Message .. '\n' .. 'Apply : ' .. sChainsawingApplyMessage
+         end
+      end
+   end
+
+   local sFinalMessage = ''
+   if #Cutting.Message > 0 or #Chainsawing.Message > 0 then
+      sFinalMessage = Cutting.Message .. '\n' .. Chainsawing.Message
+   end
+   
+   return bIsChainsawingOk, sFinalMessage
+end
+
+--#endregion SawPlusChain
+
 ---------------------------------------------------------------------
 local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePart, bPrevBhSideMill, bAllWithEndCap)
   if not BD.MAXDIAM_POCK_CORNER then
@@ -4604,6 +5323,16 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
      EgtOutLog( sErr)
      return false, sErr
   end
+
+   -- strategia lama + eventuale sega a catena
+   if ( EgtGetInfo( Proc.Id, Q_SAW_PLUS_CHAIN, 'i') or 0) > 0 then                       --TEST
+      local bOk
+      local sErr
+      local bOnlySaw = EgtGetInfo( Proc.Id, Q_SAW_PLUS_CHAIN, 'i') == 1
+      bOk, sErr = SawPlusChain.Make ( Proc, nRawId, nPhase, bOnlySaw)
+      return bOk, sErr
+   end
+
   local bClosedOrthoFaces
   local nFacInd, dFacElev, nFacInd2, dFacElev2
   local nBottomFace
@@ -4743,9 +5472,9 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
      local bIsU = ( Proc.Fct == 3 and not TestElleShape3( Proc))
      -- verifico se due facce o L con una o due facce di terminazione
      local bIsL = ( Proc.Fct == 2 or TestElleShape3( Proc) or TestElleShape4( Proc) == 2)
-      -- se parametro Q03=2 forzo la fresatura di lato; con Q03=3 forzo solo se la faccia di lavoro non è rivolta verso l'alto +/-10°; se rabbet lungo X che guarda in giù sempre fresatura di lato
+      -- se parametro Q03=2 forzo la fresatura di lato; con Q03=3 forzo solo se la faccia di lavoro non è rivolta verso l'alto +/-10°; per rabbet che guardano in giù sempre fresatura di lato
      local bIsRabbetAlongXTowardsBottom = ( Proc.TopologyLongName == 'Rabbet-Through-RightAngles-Parallel-2' and ( Proc.AffectedFaces.Front or Proc.AffectedFaces.Back) and Proc.AffectedFaces.Bottom and Proc.AffectedFaces.Left and Proc.AffectedFaces.Right)
-      local bForceSideMill = bIsRabbetAlongXTowardsBottom or ( ( EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'i') == 2 or ( EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'i') == 3 and vtN:getZ() < 0.985)) and ( Proc.Fct == 4 or Proc.Fct == 3 or Proc.Fct == 2))
+      local bForceSideMill = bIsRabbetAlongXTowardsBottom or ( ( EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'i') == 2 or ( EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'i') == 3 and vtN:getZ() < 0.985)) and ( ( Proc.Fct == 4 and ( Proc.AffectedFaces.Front or Proc.AffectedFaces.Back)) or Proc.Fct == 3 or Proc.Fct == 2))
      -- se fattibile con fresa BH di fianco e spessore utensile inferiore alla larghezza faccia
      local bMakeBySideMill, bHead, bHeadDir, sMilling, dMaxMat, dToolDiam = VerifyBHSideMill( Proc, bIsU, bIsL, bSinglePart, bPrevBhSideMill)
      if bPrevBhSideMill == nil then
@@ -5047,7 +5776,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
            local bMillUp = ( BD.DOWN_HEAD and vtN:getZ() > -0.259)
            local bMillDown = ( BD.DOWN_HEAD and vtN:getZ() < 0.342)
            -- settaggio voluto da Alessandro/Fabio (per fare angoli con fresa piccola)
-            sMchFind = 'Pocket'
+            local sMchFind = 'Pocket'
            local dDiam = min( dH, dV)
            local bTailOnSide = ( Proc.Box:getMin():getX() - b3Solid:getMin():getX() < 0.1 and not Proc.Tail and not bAllWithEndCap)
            if ( Proc.Fct == 1) or (( Proc.Fct == 2 or Proc.Fct == 3) and bIsL) or ((( Proc.Fct == 3 and bIsU) or ( Proc.Fct == 4 and not bTailOnSide)) and bSinglePart) then
@@ -5539,6 +6268,11 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                  dMachiningDepth = dFacElev + dCollSic
               end
               local bOk, sWarn2
+               local dDistToNextPiece = BL.GetDistanceToNextPart( nRawId, nPhase)
+               -- se avevo escluso l'attacco da fuori per non rovinare il pezzo successivo, riverifico con il diametro fresa effettivo
+               if ( Proc.Fct == 4 and bTailOnSide) and ( dDistToNextPiece > dToolDiameter + 10 * GEO.EPS_SMALL) then
+                  sMchFind = EgtIf( bMillDown, 'OpenPocket_H2', 'OpenPocket')
+               end
               bOk, sWarn2, sTuuidPk, dDiamTool = MakePocket( Proc, nPartId, b3Solid, ptC, tvtNx, nFacInd, sMchFind, nUseRoughTool, sPocketing, dMachiningDepth, nil, nil, bAllWithEndCap, bLapJointAngTrasm, nPhase, nRawId)
               if not bOk then return false, sWarn2 end
               if sWarn2 then
@@ -5698,7 +6432,7 @@ local function MakeLongMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead)
   -- la divido in parti lungo X
   local vAddId = {}
   local bAllWithEndCap = bAddEndCapLeftSide or bAddEndCapRightSide
-   local nPart = max( ceil( Proc.Box:getDimX() / BD.LONGCUT_MAXLEN), 2)
+   local nPart = max( ceil( Proc.Box:getDimX() / BD.LONGCUT_MAXLEN + 10 * GEO.EPS_SMALL), 2)
   local dPartLen = Proc.Box:getDimX() / nPart
   local Xmin = Proc.Box:getMin():getX()
   -- trimesh per la creazione degli EndCap
@@ -5780,12 +6514,12 @@ local function MakeLongMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead)
   for i = 1, #vAddId do
      local b3Box = EgtGetBBoxGlob( vAddId[i], GDB_BB.STANDARD)
      local nFct = EgtSurfTmFacetCount( vAddId[i])
-      local AddProc = { Id = vAddId[i], Grp = Proc.Grp, Prc = Proc.Prc, Box = b3Box, TotBox = Proc.Box, Fct = nFct, Flg = Proc.Flg, PartId = Proc.PartId}
+      local AddProc = { Id = vAddId[i], Grp = Proc.Grp, Prc = Proc.Prc, Box = b3Box, TotBox = Proc.Box, Fct = nFct, Flg = Proc.Flg, PartId = Proc.PartId, TaskId = Proc.TaskId, FeatureId = Proc.FeatureId, IsSplittedLapJoint = true, AffectedFaces = Proc.AffectedFaces}
      Topology.Classify( AddProc, b3Raw)
      -- lasciare il false nel sesto parametro (perchè internamente viene verificato se diverso da nil)
-      local bOk, sMyWarn 
+      local bOk, sMyWarn
      bOk, sMyWarn, bPrevBhSideMill = MakeMoreFaces( AddProc, nPhase, nRawId, nPartId, dOvmHead, bAllWithEndCap, bPrevBhSideMill, bAllWithEndCap)
-      if not sWarn then sWarn = sMyWarn end
+      if not sWarn or #sWarn == 0 then sWarn = sMyWarn end
      if not bOk then return bOk, sWarn end
   end
   return true, sWarn
@@ -5821,7 +6555,7 @@ local function TestTwoFacesDownHead( Proc)
      Proc.IsTopDownRabbet = abs( vtRes:getZ()) > 10 * GEO.EPS_SMALL
      for i = 1, Proc.Fct do
         Proc.Face[i].IsTooDownwardForTopBlade = Proc.Face[i].VtN:getZ() < ( BD.CUT_VZ_MIN or -0.484) - 10 * GEO.EPS_SMALL
-         Proc.Face[i].IsTooWideForTopBlade = Proc.Face[i].Width > dTopBladeMaxDepth
+         Proc.Face[i].IsTooWideForTopBlade = Proc.Face[i].WidthTrimmed > dTopBladeMaxDepth
      end
      -- serve la lama sotto se c'è almeno una faccia troppo inclinata verso il basso e non è un rabbet stretto lavorabile dal lato
      if not ( Proc.Face[1].IsTooDownwardForTopBlade or Proc.Face[2].IsTooDownwardForTopBlade) then
@@ -23,6 +23,7 @@
 -- 2023/11/24 Aggiunta Q05 per utilizzo lama anche in feature cieche conme per LongCut.
 -- 2023/11/30 Calcolo elevazione velocizzato e centralizzato tramite la funzione GetFaceElevation.
 -- 2024/01/18 Implementata GetBlockedAxis che gestisce gli assi bloccati per tutti i tipi di utensile.
+-- 2024/03/21 Corretto parametro passato a funzione BL.GetBlockedAxis. Ora tiene in considerazione anche testa sotto

 -- Tabella per definizione modulo
 local ProcessLong2Cut = {}
@@ -833,11 +834,13 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster

                  -- recupero alcune informazioni utili dalla lavorazione attuale
                  local bIsCurrentBladeCCW
+                  local sCuttingNameMach
                  if bIsTopBladeCurrent then
-                     EgtMdbSetCurrMachining( sCutting)
+                     sCuttingNameMach = sCutting
                  else
-                     EgtMdbSetCurrMachining( sCuttingDn)
+                     sCuttingNameMach = sCuttingDn
                  end
+                  EgtMdbSetCurrMachining( sCuttingNameMach)
                  bIsCurrentBladeCCW = EgtMdbGetCurrMachiningParam( MCH_MP.SPEED) < 0

                  -- imposto la direzione di lavoro per avere scarico del truciolo ottimale
@@ -880,7 +883,7 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster
                  EgtSetMachiningParam( MCH_MP.SCC, nSCC)
                  -- imposto angolo 3° asse rot
                  local vtOut = EgtIf( vtN[vOrd[j]]:getX() > 0, X_AX(), -X_AX())
-                  EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( sCutting, 'perpendicular', b3Raw, vtN, vtOut))
+                  EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( sCuttingNameMach, 'perpendicular', b3Raw, vtN, vtOut))
                  -- eseguo
                  if not ML.ApplyMachining( true, false) then
                     local _, sErr = EgtGetLastMachMgrError()
@@ -1777,7 +1780,6 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster
                  sWarn = 'Warning in LongDoubleCut : depth (' .. EgtNumToString( vWidth[vOrd[i]] + dAgg, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepthDn - dCollSic, 1) .. ')'
               end
               dDepth  = min( dMaxDepthDn - dCollSic, vWidth[vOrd[i]] + dAgg)
-               dDepth2 = vWidth[vOrd[i]] + dAgg - dDepth
               EgtSetMachiningParam( MCH_MP.DEPTH, dDepth - dExtraElev)
            else
               dCollSic    = max( BD.COLL_SIC, ( dThDiam - dToolDiam) / 2 * EgtIf(  abs(dNz) < GEO.EPS_SMALL, 1, abs( EgtIf( abs(vtN[vOrd[i]]:getY()) >= abs(vtN[vOrd[i]]:getZ()), vtN[vOrd[i]]:getZ(), vtN[vOrd[i]]:getY()) / dNz)))
@@ -1785,7 +1787,6 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster
                  sWarn = 'Warning in LongDoubleCut : depth (' .. EgtNumToString( vWidth[vOrd[i]] + dAgg, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth - dCollSic, 1) .. ')'
               end
               dDepth = min( dMaxDepth - dCollSic, vWidth[vOrd[i]] + dAgg)
-               dDepth2 = vWidth[vOrd[i]] + dAgg - dDepth
               EgtSetMachiningParam( MCH_MP.DEPTH, dDepth - dExtraElev)
            end
            -- eseguo
@@ -15,6 +15,7 @@
 -- 2023/08/10 Modificata scelta SCC per tasche in Y+/- in coda o quasi.
 -- 2024/01/18 Implementata GetBlockedAxis che gestisce gli assi bloccati per tutti i tipi di utensile.
 -- 2024/02/28 Forzata SPIRAL_IN se c'è anche un solo lato aperto
+-- 2024/03/05 Aggiunta possibilità di inserire lavorazione di smusso

 -- Tabella per definizione modulo
 local ProcessMortise = {}
@@ -30,6 +31,9 @@ EgtOutLog( ' ProcessMortise started', 1)
 local BD = require( 'BeamData')
 local ML = require( 'MachiningLib')

+-- variabili assegnazione parametri Q
+local Q_DEPTH_CHAMFER = 'Q02' -- d
+
 ---------------------------------------------------------------------
 -- Riconoscimento della feature
 function ProcessMortise.Identify( Proc)
@@ -277,7 +281,36 @@ function ProcessMortise.VerifyMortiseOrPocket( Proc, dDiam, dDepth, dMaxTotLen,
   return sPocketing, dMaxDepth, dToolDiam
 end

-   ---------------------------------------------------------------------
+---------------------------------------------------------------------
+local function VerifyChamfer( Proc, AuxId, nRawId, bMakeVertCham, bDownHead)
+   local nChamfer = 0
+   -- ingombro del grezzo
+   local b3Raw = EgtGetRawPartBBox( nRawId)
+   -- verifico che lo smusso sia richiesto
+   local dDepth = EgtGetInfo( Proc.Id, Q_DEPTH_CHAMFER, 'd') or 0
+   if dDepth > 0 then
+      nChamfer = 1
+   end
+
+   -- recupero la lavorazione
+   local sMilling
+   if nChamfer > 0 then
+      if bDownHead then
+         sMilling = ML.FindMilling( 'Mark_H2', nil, nil, nil, nil, false, true)
+      else
+         sMilling = ML.FindMilling( 'Mark')
+      end
+      if not sMilling then
+         local sErr = 'Error : Mark not found in library'
+         EgtOutLog( sErr)
+         return -1, 0, sErr
+      end
+   end
+
+   return nChamfer, dDepth, sMilling
+end
+
+---------------------------------------------------------------------
 -- Applicazione della lavorazione
 function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
   -- ingombro del pezzo
@@ -405,6 +438,63 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
   local bPockUp = ( BD.DOWN_HEAD and vtExtr:getZ() > -0.259)
   local bPockDown = ( BD.DOWN_HEAD and vtExtr:getZ() < 0.174)
   local bPockAngTrasm = ( BD.ANG_TRASM and vtExtr:getZ() < -0.1)
+
+   -- recupero i dati della curva e del profilo
+   local dDepth = dMorH
+   local bDownHead = ( BD.DOWN_HEAD and vtExtr:getZ() < 0.1)
+   local bToolInv = ( not bDownHead and vtExtr:getZ() < -0.1 and Proc.Box:getDimZ() > b3Solid:getDimZ() - 5)
+   local dExtra = 2
+
+   -- verifico se servono gli smussi. Se lavorazione principale di svuotatura significa che è solo da un lato
+   -- generalmente sono lavorazioni non molto lunghe, quindi non si gestistono gli step
+   -- verifico i parametri Q per profondità smusso e per eseguirlo in esclusiva
+   local nChamfer, dDepthCham, sChamfer = VerifyChamfer( Proc, AuxId, nRawId, true)
+   -- se devo inserire il chamfer
+   if nChamfer > 0 and Proc.Grp ~= 0 and dDepth > dDepthCham then
+      -- inserisco la lavorazione
+      local sNameCh = 'Cham_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
+      local nMchId = EgtAddMachining( sNameCh, sChamfer)
+      if not nMchId then
+         local sErr = 'Error adding machining ' .. sNameCh .. '-' .. sChamfer
+         EgtOutLog( sErr)
+         return false, sErr
+      end
+      -- aggiungo geometria
+      EgtSetMachiningGeometry( {{ AuxId, -1}})
+      if not bToolInv then
+         EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
+         EgtSetMachiningParam( MCH_MP.INVERT, true)
+      else
+         EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
+         EgtSetMachiningParam( MCH_MP.INVERT, true)
+      end
+      -- assegno affondamento e offset radiale
+      EgtSetMachiningParam( MCH_MP.DEPTH, dDepthCham + dExtra - dMorH)
+      EgtSetMachiningParam( MCH_MP.OFFSR, dExtra)
+      -- posizione braccio porta testa
+      local nSCC = MCH_SCC.NONE
+      if not BD.C_SIMM then
+         if Proc.Head then
+            nSCC = MCH_SCC.ADIR_XP
+         elseif Proc.Tail then
+            nSCC = MCH_SCC.ADIR_XM
+         elseif AreSameOrOppositeVectorApprox( vtExtr, Z_AX()) then
+            nSCC = MCH_SCC.ADIR_YP
+         elseif vtExtr:getY() > -0.01 then
+            nSCC = MCH_SCC.ADIR_YP
+         else
+            nSCC = MCH_SCC.ADIR_YM
+         end
+      end
+      EgtSetMachiningParam( MCH_MP.SCC, nSCC)
+      -- eseguo
+      if not ML.ApplyMachining( true, false) then
+         local _, sErr = EgtGetLastMachMgrError()
+         EgtSetOperationMode( nMchId, false)
+         return false, sErr
+      end
+   end
+
   -- recupero la lavorazione
   local sPockType = 'Mortise'
   local sMchExt = ''
@@ -1,5 +1,31 @@
           ==== Beam Update Log ====

+Versione 2.6d2 (11/04/2024)
+- Added : in LapJoint aggiunta strategia per fare tasche con lama + sega a catena, attivata da Q11 
+
+Versione 2.6d1 (08/04/2024)
+- Fixed : in Long2Cut corretto nome passato alla BL.GetBlockedAxis
+- Fixed : in MakeTwo rimossa gestione calcolo differente su ultima passata in caso di macchina FAST
+- Fixed : in LapJoint -> ForceSideMill escluso caso 4 facce senza possibilità di ingresso lungo Y.
+
+Versione 2.6c4 (18/03/2024)
+- Fixed : correzioni a gestione prefori.
+
+Versione 2.6c3 (15/03/2024)
+- Added : Aggiunta gestione prefori
+- Fixed : in LapJoint correzione a calcolo ingombro per feature basse e lunghe dalla testa.
+
+Versione 2.6c2 (12/03/2024)
+- Added : in Mortase Aggiunta possibilità di inserire lavorazione di smusso
+- Added : in FreeContour aggiunto smusso se lav. di svuotatura
+- Added : in BeamExec creata funzione calcolo dipendenze tra feature
+- Added : In BeamExec -> CollectFeatures si scrive ora Width e Height della faccia sia trimmate con il grezzo che intere
+- Added : implementate le lavorazioni in doppio per fori specchiati non passanti e DrillPocket
+- Modif : in LapJoint migliorata ricerca pocket (VerifyPocket)
+- Modif : implementato attacco esterno se tasca 4 facce sulla coda ma nessun pezzo successivo
+- Modif : rimossi simboli di debug da compile
+- Fixed : In FreeContour corretto caso di smusso non passante
+
 Versione 2.6c1 (29/02/2024)
 - Modif : in FacesBySaw e LapJoint migliorato calcolo area non pinzabile in testa HCING e coda TCING
 - Modif : vari miglioramenti all'ordinamento delle lavorazioni
@@ -2,5 +2,5 @@
 -- Gestione della versione di Beam

 NAME = 'Beam'
-VERSION = '2.6c1'
+VERSION = '2.6d2'
 MIN_EXE = '2.6a1'
Author	SHA1	Message	Date
andrea.villa	ec48260d73	In LapJoint : in IsTailFeature se LapJoint a 2 facce che taglia intera sezione, da fare dopo taglio di coda	2024-04-22 09:04:34 +02:00
luca.mazzoleni	06461550c3	In LapJoint -> MakeMoreLongFaces corretto calcolo divisione in parti per evitare problemi di ceil con interi perfetti (ceil(3) = 3 o 4??)	2024-04-17 11:11:04 +02:00
luca.mazzoleni	f45bcd7651	- in LapJoint -> SideMillAsSaw gestito anche rabbet passante	2024-04-15 12:22:23 +02:00
luca.mazzoleni	05fe546e38	Merge branch 'FixPartInfoAfterRotation' into develop	2024-04-12 14:16:00 +02:00
luca.mazzoleni	63c5d39112	- in BeamExec GetProcessAffectedFaces e GetFacetsInfo rilanciati dopo rotazione - in BeamExec box della feature aggiornato dopo rotazione - in LapJoint Groove verso il basso lavorata di preferenza dal lato	2024-04-12 13:15:59 +02:00
luca.mazzoleni	f8e56d8f49	Merge tag '2.6d2' into develop release	2024-04-11 12:56:47 +02:00
luca.mazzoleni	b07f2f6b19	Merge branch 'release/2.6d2'	2024-04-11 12:56:30 +02:00
luca.mazzoleni	eefd8ba037	- update log e version	2024-04-11 12:56:21 +02:00
luca.mazzoleni	076178db2c	Merge branch 'feature/SawPlusChainsaw' into develop	2024-04-11 12:49:21 +02:00
luca.mazzoleni	3699daf998	- in SawPlusChain corretta tolleranza spessore tasca	2024-04-11 12:45:56 +02:00
luca.mazzoleni	617058cdda	- in SawPlusChain nei messaggi si scrive il FeatureId invece di TaskId - commenti e piccole correzioni	2024-04-11 12:14:33 +02:00
luca.mazzoleni	d7a517160d	- in SawPlusChain piccole correzioni - in SawPlusChain aggiunta attivazione con parametro Q11	2024-04-11 10:51:05 +02:00
luca.mazzoleni	139579dbef	- in SawPlusChain corretta segnalazione errore tasca troppo stretta	2024-04-10 13:19:39 +02:00
luca.mazzoleni	72033c8b9f	- in SawPlusChain, in messaggio elevazione non raggiunta, aggiunti valori elevazione e massima profondità raggiunta	2024-04-10 10:07:52 +02:00
luca.mazzoleni	cc30f3aeb9	- chiamate a FeatureId (PRID) sostituite con TaskId - in SawPlusChain angoli iniziali gestiti solo per sega a catena	2024-04-09 19:02:10 +02:00
luca.mazzoleni	969f4cb6a0	- in FeatureTopology modifiche alla definizione di parallelo per tunnel e groove - in SawPlusChain piccole correzioni	2024-04-09 16:17:57 +02:00
luca.mazzoleni	c05e58a61e	- in SawPlusChain escluse le lapjoint lunghe - in SawPlusChain aggiunta scrittura log per tutti gli errori - proprietà facce della Proc ora lette tramite la funzione GetFacetsInfo in BeamLib	2024-04-09 09:59:00 +02:00
luca.mazzoleni	37026c548d	-in SawPlusChain migliorata gestione nome lavorazione - in SawPlusChain aggiunti angoli alternativi sega a catena - in SawPlusChain incluso caso 3 facce con fondo che non guarda verso il basso	2024-04-08 15:26:49 +02:00
luca.mazzoleni	bfaeb8e414	Merge branch 'develop' into feature/SawPlusChainsaw	2024-04-08 09:56:27 +02:00
luca.mazzoleni	3bd780d005	update log	2024-04-08 09:37:18 +02:00
luca.mazzoleni	1ffa11b2c1	Merge tag '2.6d1' into develop release	2024-04-08 09:35:02 +02:00
luca.mazzoleni	3548d8593a	Merge branch 'release/2.6d1'	2024-04-08 09:34:49 +02:00
luca.mazzoleni	0eac98ecaa	update log e versione	2024-04-08 09:34:41 +02:00
luca.mazzoleni	a950807979	- in SawPlusChain aggiunto messaggio danneggiamento pezzo successivo	2024-04-05 19:17:17 +02:00
luca.mazzoleni	7676693f66	in sawpluschain correzione tabella non definita	2024-04-04 12:49:19 +02:00
luca.mazzoleni	e03896cfef	in sawpluschain ulteriori correzioni al calcolo approccio e retrazione	2024-04-04 12:40:59 +02:00
luca.mazzoleni	b5094daa43	- in sawpluschain correzione a attacchi	2024-04-04 10:14:16 +02:00
luca.mazzoleni	5f1aaac719	- in sawpluschain migliorati approccio e retrazione lama	2024-04-04 08:48:13 +02:00
luca.mazzoleni	57d696e2fc	- in sawpluschain refactoring per migliorare leggibilità - in sawpluschain gestita estensione start se tasca troppo stretta - in BeamLib aggiunta funzione GetAdjacentFaces	2024-04-03 17:56:39 +02:00
luca.mazzoleni	99c0ada098	- in sawpluschain migliorata gestione errori chainsaw - in sawpluschain migliorato riconoscimento facce laterali	2024-04-02 19:05:05 +02:00
luca.mazzoleni	a828ca9804	Merge branch 'develop' into feature/Saw+Chainsaw	2024-04-02 12:48:39 +02:00
luca.mazzoleni	88baf851ee	-- In LapJoint -> ForceSideMill escluso caso 4 facce senza possibilità di ingresso lungo Y.	2024-04-02 12:47:47 +02:00
luca.mazzoleni	1e094aac56	- in SawPlusChain correzioni a sega a catena	2024-04-02 10:30:27 +02:00
luca.mazzoleni	51b5c7ac80	- in SawPlusChain implementata sega a catena, da testare	2024-03-29 19:20:19 +01:00
luca.mazzoleni	e3f8783c18	- in SawPlusChain piccole correzioni	2024-03-29 09:29:08 +01:00
luca.mazzoleni	d0015d8252	Merge branch 'develop' into feature/Saw+Chainsaw	2024-03-28 11:56:01 +01:00
luca.mazzoleni	5ebdda4abd	- refactoring e migliorie varie	2024-03-28 11:50:39 +01:00
andrea.villa	436dcf69ea	In MakeTwo rimossa gestione calcolo differente su ultima passata in caso di macchina FAST	2024-03-27 12:24:44 +01:00
luca.mazzoleni	b7b9ea2065	- implementate passate orizzontali	2024-03-27 11:32:09 +01:00
luca.mazzoleni	8b1d3a0efb	modifiche a SawPlusChainsaw	2024-03-27 09:24:35 +01:00
luca.mazzoleni	3d0adbdd39	- in SawPlusChainsaw aggiunta gestione accorciamenti percorsi per faccia laterale	2024-03-26 10:59:34 +01:00
luca.mazzoleni	8b51f9dca8	Merge branch 'develop' into feature/Saw+Chainsaw	2024-03-22 17:49:24 +01:00
luca.mazzoleni	f589464063	- aggiunte lavorazioni SawPlusChainsaw funzionanti - manca la gestione nel caso la feature non sia parallela al pezzo	2024-03-22 17:48:50 +01:00
andrea.villa	fc7150f9b0	In Long2Cut.Make corretto nome passato alla BL.GetBlockedAxis	2024-03-21 08:42:20 +01:00
luca.mazzoleni	5c83095891	Merge branch 'develop' into feature/Saw+Chainsaw	2024-03-20 17:23:35 +01:00
luca.mazzoleni	fe76f4b859	Merge branch 'master' into develop	2024-03-20 09:30:13 +01:00
Dario Sassi	1d2eb24903	DataBeam : - correzione in Mortise per utilizzo variabili non definite.	2024-03-19 18:00:16 +01:00
luca.mazzoleni	0bb90513b5	Merge tag '2.6c4' into develop release#	2024-03-18 15:02:27 +01:00
luca.mazzoleni	2fa68977bf	Merge branch 'release/2.6c4'	2024-03-18 15:02:07 +01:00
luca.mazzoleni	092ad0cb4c	update log e versione	2024-03-18 15:01:47 +01:00
andrea.villa	3953d079c1	ProcessDrill : Per Predrill corretta direzione estrusione per fori con direzione verso il basso	2024-03-18 13:26:22 +01:00
luca.mazzoleni	ddcea6524c	update log	2024-03-15 12:31:07 +01:00
luca.mazzoleni	fe78df8c26	Merge branch 'master' into develop	2024-03-15 12:19:34 +01:00
Dario Sassi	7a70f623d9	DataBeam : - in LapJoint correzione a calcolo ingombro per feature basse e lunghe dalla testa.	2024-03-15 11:44:13 +01:00
luca.mazzoleni	b8ac0ef249	Merge tag '2.6c3' into develop release	2024-03-15 09:55:08 +01:00
luca.mazzoleni	f456ea3c2a	Merge branch 'release/2.6c3'	2024-03-15 09:54:50 +01:00
luca.mazzoleni	8732c2fc66	update log e version	2024-03-15 09:54:25 +01:00
luca.mazzoleni	6a135228b8	- piccola correzione ai fori in doppio	2024-03-15 09:41:29 +01:00
luca.mazzoleni	653557a23d	- in lapjoint primo implemento di MakeBySawPlusChain, da completare - in BeamExec -> collect si scrive l'id della feature btl	2024-03-15 09:09:08 +01:00
andrea.villa	036ea8bcc8	Merge branch 'Feature/Predrill' into develop	2024-03-14 10:58:38 +01:00
andrea.villa	b620aef7b8	Aggiunta gestione prefori	2024-03-13 17:23:40 +01:00
andrea.villa	58eb8df247	- Gestion Predrill su foro da due parti - Ordinamento, Predrill sempre prima del foro	2024-03-13 15:24:59 +01:00
andrea.villa	38ab9d4a40	Prima versione gestione Predrill	2024-03-13 12:30:00 +01:00
luca.mazzoleni	4b7c533ae3	Merge branch 'master' into develop	2024-03-12 14:16:59 +01:00
luca.mazzoleni	d54c9c98d7	Merge branch 'develop'	2024-03-12 11:37:27 +01:00
luca.mazzoleni	d0d5ff3917	- update yml per rimuovere simboli di debug da compilazione	2024-03-12 11:37:11 +01:00
luca.mazzoleni	afb72bcf48	Merge tag '2.6c2' into develop release	2024-03-12 09:42:40 +01:00
luca.mazzoleni	0d6566e2cc	Merge branch 'release/2.6c2'	2024-03-12 09:41:46 +01:00
luca.mazzoleni	db5503f828	update log e version	2024-03-12 09:41:07 +01:00
luca.mazzoleni	0cfa1207ec	- In BeamExec -> CollectFeatures si scrive ora Width e Height della faccia sia trimmate con il grezzo che intere.	2024-03-11 16:08:29 +01:00
luca.mazzoleni	d415034d1c	Merge branch 'feature/ImproveMirrorDrillings' into develop	2024-03-07 16:11:18 +01:00
luca.mazzoleni	06964c5a34	- rimossi simboli di debug da compile	2024-03-07 16:11:03 +01:00
luca.mazzoleni	68921b5df5	- Implementate le lavorazioni in doppio per fori specchiati non passanti e DrillPocket	2024-03-07 15:08:57 +01:00
andrea.villa	7801a50ae0	Merge branch 'Ticket#1646' into develop	2024-03-05 11:36:48 +01:00
andrea.villa	c418f5b92a	In Mortise.Make: Aggiunta possibilità di inserire lavorazione di smusso	2024-03-05 11:32:18 +01:00
andrea.villa	3aa7979be4	In FreeContour aggiunto smusso se lav. di svuotatura e corretto caso non passante	2024-03-05 09:56:18 +01:00
andrea.villa	4fdf3ebdfa	Merge branch 'Feature/ImproveOrderFeat' into develop	2024-03-04 12:17:05 +01:00
andrea.villa	e25ad8e4a4	BeamExec: Creata funzione calcolo dipendenze tra feature FeatureTopology : Feature senza topologia, calcolato in BeamExec	2024-03-04 12:16:57 +01:00
andrea.villa	d5a45917ec	Merge branch 'develop' into Feature/ImproveOrderFeat	2024-03-04 12:11:56 +01:00
luca.mazzoleni	eb401d2695	- Implementato attacco esterno se tasca 4 facce sulla coda ma nessun pezzo successivo	2024-03-04 09:48:47 +01:00
luca.mazzoleni	604ffc6a35	- in LapJoint migliorata ricerca pocket (VerifyPocket)	2024-03-01 15:58:57 +01:00
luca.mazzoleni	43da69863d	Merge tag '2.6c1' into develop 2.6c12.6c12.6c12.6c12.6c12.6c1	2024-02-29 17:57:44 +01:00