BugFix/ScarfOneFaceReduceToCut:

ora se il giunto Gerber ha una sola faccia viene richiamata la Process.Cut
Merge branch 'master' into develop
2022-08-09 09:41:17 +02:00 · 2022-08-09 09:15:38 +02:00 · 2022-08-09 07:09:35 +02:00 · 2022-08-03 08:38:33 +02:00 · 2022-08-01 17:39:49 +02:00 · 2022-07-29 18:50:51 +02:00
11 changed files with 310 additions and 280 deletions
@@ -1,4 +1,4 @@
-- BatchProcessNew.lua by Egaltech s.r.l. 2022/07/24
+-- BatchProcessNew.lua by Egaltech s.r.l. 2022/08/01
 -- Gestione calcolo batch disposizione e lavorazioni per Travi
 -- 2021/01/07 Per nuova interfaccia Egt.
 -- 2021/01/15 CREATE_BAR ora FLAG = 6 (prima 5).
@@ -11,6 +11,7 @@
 -- 2022/02/09 Aggiornato come Wall per gestione errori e verifica attrezzaggio utensili.
 -- 2022/04/28 In info generazione aggiunta indicazione se 64bit.
 -- 2022/07/24 Modifica per cancellare lavorazioni con ricalcolo e barra già definita.
+-- 2022/08/01 Tolleranza su sezione portata a 0.1 mm (100 * GEO.EPS_SMALL).

 -- Intestazioni
 require( 'EgtBase')
@@ -334,8 +335,8 @@ if bToProcess then
      for i = 2, #vBeam do
         local dDimW = vBeam[i].Box:getDimY()
         local dDimH = vBeam[i].Box:getDimZ()
-         if ( abs( dDimW - dRawW) > 10 * GEO.EPS_SMALL  or  abs( dDimH - dRawH) > 10 * GEO.EPS_SMALL)  and
-            ( abs( dDimH - dRawW) > 10 * GEO.EPS_SMALL  or  abs( dDimW - dRawH) > 10 * GEO.EPS_SMALL) then
+         if ( abs( dDimW - dRawW) > 100 * GEO.EPS_SMALL  or  abs( dDimH - dRawH) > 100 * GEO.EPS_SMALL)  and
+            ( abs( dDimH - dRawW) > 100 * GEO.EPS_SMALL  or  abs( dDimW - dRawH) > 100 * GEO.EPS_SMALL) then
            table.insert( vBeamErr, i)
         end
      end
@@ -1,4 +1,4 @@
-- BeamExec.lua by Egaltech s.r.l. 2022/07/27
+-- BeamExec.lua by Egaltech s.r.l. 2022/08/08
 -- Libreria esecuzione lavorazioni per Travi
 -- 2019/07/11 Aggiunta gestione stato rotazione di feature per TS3.
 -- 2019/09/04 Corretto controllo feature di testa e coda con sovramateriale di testa elevato.
@@ -32,6 +32,8 @@
 --            Create le funzioni AnalyzeHeadFeatures e AnalyzeTailFeatures. Spostate più in alto le funzioni CollectFeatures, isHeadFeature e isTailFeature.
 -- 2022/07/01 Aggiunta la gestione delle forature migliorate in presenza di feature testa/coda ad 1 faccia che tagliano tutta la sezione,
 --            controllata tramite il parametro IMPROVE_HEAD_TAIL_DRILLINGS da BeamData. Attivata di default.
+-- 2022/08/01 Tolleranza su sezione portata a 0.1 mm (100 * GEO.EPS_SMALL).
+-- 2022/08/08 Modifica per macchine senza BD.MAX_WIDTH2 e BD.MAX_HEIGHT2.

 -- Tabella per definizione modulo
 local BeamExec = {}
@@ -489,8 +491,8 @@ function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, vBeam, bMachGroup
      local PartWidth = b3Solid:getDimY()
      local PartHeight = b3Solid:getDimZ()
      local NextLen = Len - DeltaS - PartLen - DeltaE
-      if (( abs( PartWidth - dRawW) < 10 * GEO.EPS_SMALL  and  abs( PartHeight - dRawH) < 10 * GEO.EPS_SMALL)  or
-          ( abs( PartHeight - dRawW) < 10 * GEO.EPS_SMALL  and  abs( PartWidth - dRawH) < 10 * GEO.EPS_SMALL))  and
+      if (( abs( PartWidth - dRawW) < 100 * GEO.EPS_SMALL  and  abs( PartHeight - dRawH) < 100 * GEO.EPS_SMALL)  or
+          ( abs( PartHeight - dRawW) < 100 * GEO.EPS_SMALL  and  abs( PartWidth - dRawH) < 100 * GEO.EPS_SMALL))  and
         NextLen + DeltaE >= 0 then
         -- eventuale sovramateriale di testa
         if i > 1 and vBeam[i].PosX then
@@ -529,7 +531,7 @@ function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, vBeam, bMachGroup
         EgtDeselectPartObjs( Pz)
         local ptPos = b3Part:getMin() - b3Solid:getMin() + Vector3d( Delta, ( dRawW - PartWidth) / 2, ( dRawH - PartHeight) / 2)
         EgtAddPartToRawPart( Pz, ptPos, nRaw)
-         if abs( PartWidth - dRawW) > 10 * GEO.EPS_SMALL then
+         if abs( PartWidth - dRawW) > 100 * GEO.EPS_SMALL then
            -- rotazione attorno a centro geometria complessiva del pezzo
            EgtRotatePartInRawPart( Pz, X_AX(), 90)
            -- correggo per eccentricità solido rispetto a geometria complessiva del pezzo
@@ -596,8 +598,12 @@ local function Verify90DegRotation( nRawId)
   local dRawW = EgtGetRawPartBBox( nRawId):getDimY()
   local dRawH = EgtGetRawPartBBox( nRawId):getDimZ()
   -- verifica dell'altezza rispetto alla massima larghezza
-   return ( dRawH < BD.MAX_WIDTH + 10 * GEO.EPS_SMALL and dRawW < BD.MAX_HEIGHT + 10 * GEO.EPS_SMALL) or
-          ( dRawH < BD.MAX_WIDTH2 + 10 * GEO.EPS_SMALL and dRawW < BD.MAX_HEIGHT2 + 10 * GEO.EPS_SMALL)
+   if not BD.MAX_WIDTH2 or not BD.MAX_HEIGHT2 then
+      return ( dRawH < BD.MAX_WIDTH + 10 * GEO.EPS_SMALL and dRawW < BD.MAX_HEIGHT + 10 * GEO.EPS_SMALL)
+   else
+      return ( dRawH < BD.MAX_WIDTH + 10 * GEO.EPS_SMALL and dRawW < BD.MAX_HEIGHT + 10 * GEO.EPS_SMALL) or
+            ( dRawH < BD.MAX_WIDTH2 + 10 * GEO.EPS_SMALL and dRawW < BD.MAX_HEIGHT2 + 10 * GEO.EPS_SMALL)
+   end
 end

 -------------------------------------------------------------------------------------------------------------
@@ -705,7 +705,7 @@ function BeamLib.GetNzLimDownUp( b3Raw, vtN, vtOrtho)
   if BD.C_SIMM or BD.TURN then
      return -0.484
   else
-      if vtOrtho and vtOrtho:getZ() > 0.5 then
+      if vtOrtho and vtOrtho:getZ() > 0.35 then
         -- N_HorAng < 15° or N_HorAng > 55°
         if vtN and ( abs( vtN:getY()) < 0.259 or abs( vtN:getY()) > 0.819) then
            return -0.708
@@ -111,24 +111,6 @@ local function SetCurrMachiningAndTool( sMachName)
   return bActive, sTool, bH2, bFixed
 end

---------------------------------------------------------------------
-local function StartsWith( sStr, sStart)
-   if ( sStart == "" or sStr:sub( 1, #sStart) == sStart) then
-      return true, sStr:sub( 1, #sStr - #sStart)
-   else
-      return false, sStr
-   end
-end
-
---------------------------------------------------------------------
-local function EndsWith( sStr, sEnd)
-   if ( sEnd == "" or sStr:sub(-#sEnd) == sEnd) then
-      return true, sStr:sub(1, #sStr - #sEnd)
-   else
-      return false, sStr
-   end
-end
-
 ---------------------------------------------------------------------
 function VerifyDrill( dDiam, dDepth, bH2)
   local dTDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
@@ -189,9 +171,9 @@ end
 ---------------------------------------------------------------------
 function VerifyTool( MachiningType, sType, Params, bH2)
   if MachiningType == MCH_MY.DRILLING then
-      if StartsWith( sType, 'Drill') or StartsWith( sType, 'AngleDrill') then
+      if EgtStartsWith( sType, 'Drill') or EgtStartsWith( sType, 'AngleDrill') then
         return VerifyDrill( Params.Diam, Params.Depth, bH2)
-      elseif StartsWith( sType, 'Pocket') then
+      elseif EgtStartsWith( sType, 'Pocket') then
         return VerifyDrillPocket( Params.Diam, Params.Depth, bH2)
      end
   elseif MachiningType == MCH_MY.SAWING then
@@ -225,7 +207,7 @@ end
 ---------------------------------------------------------------------
 function ReturnParams( MachiningType, MachiningName, sType, ToolParams)
   if MachiningType == MCH_MY.DRILLING then
-      local _, sOrigType = EndsWith( sType, '_H2')
+      local _, sOrigType = EgtEndsWith( sType, '_H2')
      return MachiningName, sType, EgtIf( sOrigType == 'Drill' or sOrigType == 'AngleDrill' , ToolParams.TMaxMat, ToolParams.TMaxDepth), ToolParams.MaxToolLength, ToolParams.ToolDiam, ToolParams.DiamTh, ToolParams.FreeLen
   elseif MachiningType == MCH_MY.SAWING then
      return MachiningName, ToolParams.H2
@@ -267,9 +249,9 @@ local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead)
      ForStep = -1
   end
   if ( BEAM and BEAM.BW) or MachineHeadType == ONE_HEAD or MachineHeadType == TWO_EQUAL_HEADS or ( MachineHeadType == TWO_UP_DOWN_HEADS and not bDownHead) then
-      _, sType = EndsWith( sType, '_H2')
+      _, sType = EgtEndsWith( sType, '_H2')
   elseif ( not BEAM or not BEAM.BW) and MachineHeadType == TWO_UP_DOWN_HEADS and bDownHead then
-      if not EndsWith( sType, '_H2') then
+      if not EgtEndsWith( sType, '_H2') then
         sType = sType .. '_H2'
      end
   end
@@ -285,7 +267,7 @@ local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead)
      local Machining = Machinings[i]
      local sMachiningType = Machining.Type
      if BEAM and BEAM.BW then
-         _, sMachiningType = EndsWith( Machining.Type, '_H2')
+         _, sMachiningType = EgtEndsWith( Machining.Type, '_H2')
      end
      -- recupero dati utensile
      local bToolActive, sToolName, bH2, bFixed = SetCurrMachiningAndTool( Machining.Name)
@@ -356,7 +338,7 @@ local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead)
         end
      end
   end
-   local bH2, sOrigType = EndsWith( sType, '_H2')
+   local bH2, sOrigType = EgtEndsWith( sType, '_H2')
   if ( not BEAM or not BEAM.BW) and MachineHeadType == TWO_UP_DOWN_HEADS and bH2 and bTopHead then
      return FindMachining( MachiningType, sOrigType, Params, true, false)
   end
@@ -1,4 +1,4 @@
-- ProcessCut.lua by Egaltech s.r.l. 2022/06/28
+-- ProcessCut.lua by Egaltech s.r.l. 2022/07/28
 -- Gestione calcolo singoli tagli di lama per Travi
 -- 2021/05/18 I due tagli con testa da sotto di un cubetto sono fatti di seguito.
 -- 2021/06/06 Correzioni per tagli con testa da sotto.
@@ -403,14 +403,12 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
            else
               if bHorizCut then
                  vtOrthoO = Z_AX()
-               elseif vtN:getY() > -0.02 then
-                  if not Proc.Head then
-                     vtOrthoO = -Y_AX()
-                  else
-                     vtOrthoO = Y_AX()
-                  end
               else
-                  vtOrthoO = -Y_AX()
+                  if vtN:getZ() < dNzLimDwnUp then
+                     vtOrthoO = EgtIf( vtN:getY() > -0.02, -Y_AX(), Y_AX())
+                  else
+                     vtOrthoO = EgtIf( vtN:getY() > 0.02, Y_AX(), -Y_AX())
+                  end
               end
            end
         end
@@ -169,11 +169,43 @@ function ProcessDrill.Classify( Proc, b3Raw)
   end
 end

+---------------------------------------------------------------------
+-- Funzione per riconoscimento faccia inizio foro e dati correlati
+-- Indice faccia :1=Front, 2=Bottom, 3=Back, 4=Top, 5=Left, 6=Right
+local function GetHoleStartData( ptCen, vtExtr, b3Solid)
+   -- Facce della trave
+   local vFaces = { { Dist = -b3Solid:getMin():getY(), Norm = -Y_AX()},
+                    { Dist = -b3Solid:getMin():getZ(), Norm = -Z_AX()},
+                    { Dist = b3Solid:getMax():getY(), Norm = Y_AX()},
+                    { Dist = b3Solid:getMax():getZ(), Norm = Z_AX()},
+                    { Dist = -b3Solid:getMin():getX(), Norm = -X_AX()},
+                    { Dist = b3Solid:getMax():getX(), Norm = X_AX()}}
+   -- Ricerca della faccia di inizio
+   local nFac = 0
+   local dCosMin = 0.0871
+   for i = 1, 6 do
+      if ( ptCen - ORIG()) * vFaces[i].Norm - vFaces[i].Dist > -2 then
+         local dCos = vtExtr * vFaces[i].Norm
+         if dCos > dCosMin then
+            nFac = i
+            dCosMin = dCos
+            if dCos > 0.7072 then break end
+         end
+      end
+   end
+   -- Coseno angolo dalla faccia
+   local CosB = 0
+   if nFac ~= 0 then
+      CosB = sqrt( 1 - sqr( vtExtr * vFaces[nFac].Norm))
+   end
+   return nFac, CosB, vFaces
+end
+
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
 function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
   -- default per costanti
-   BD.DRILL_VX_MAX_ANGLEDRILL = ( BD.DRILL_VX_MAX_ANGLEDRILL or 0.921)
+   BD.DRILL_VX_MAX_ANGLEDRILL = ( BD.DRILL_VX_MAX_ANGLEDRILL or 0.928)
   -- ingombro del pezzo
   local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
   if not b3Solid then
@@ -192,21 +224,32 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
   -- recupero i dati del foro
   local dDiam = 2 * EgtArcRadius( AuxId)
   local dLen = abs( EgtCurveThickness( AuxId))
+   local ptCen = EgtCP( AuxId, GDB_RT.GLOB)
   local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
-   if Proc.Flg == -2 then vtExtr = - vtExtr end
+   if Proc.Flg == -2 then
+      ptCen = ptCen - vtExtr * dLen
+      vtExtr = - vtExtr
+   end
   local bOpen = ( Proc.Fcs ~= 0  and  Proc.Fce ~= 0)
   -- verifico che il foro non sia fattibile solo da sotto
-   local bToInvert = ( vtExtr:getZ() < BD.DRILL_VZ_MIN) and not BD.DOWN_HEAD
+   local bToInvert = ( vtExtr:getZ() < BD.DRILL_VZ_MIN and not BD.DOWN_HEAD)
   if bToInvert  and  ( not bOpen or Proc.Flg ~= 1) then
      local sErr = 'Error : drilling from bottom impossible'
      EgtOutLog( sErr)
      return false, sErr
   end
-   -- se il foro è cieco o troppo inclinato all'inizio, lo inverto
-   if Proc.Fcs == 0 or ( abs( vtExtr:getX()) > BD.DRILL_VX_MAX and Proc.Fcs ~= 5  and Proc.Fcs ~= 6) then
-      bToInvert = true
+   -- se non già richiesta inversione e invertibile
+   if not bToInvert and Proc.Flg == 1 and ( -vtExtr:getZ() >= BD.DRILL_VZ_MIN or BD.DOWN_HEAD) then
+      -- se il foro è cieco o troppo inclinato all'inizio, lo inverto
+      local _, CosB, _ = GetHoleStartData( ptCen, vtExtr, b3Solid)
+      if Proc.Fcs == 0 or ( CosB > BD.DRILL_VX_MAX and bOpen) then
+         bToInvert = true
+      end
+   end
+   if bToInvert then
+      ptCen = ptCen - vtExtr * dLen
+      vtExtr = - vtExtr
   end
-   if bToInvert then vtExtr = - vtExtr end
   -- se foro è splittato ed è la parte opposta, inverto
   if Proc.Flg == -2 then bToInvert = true end
   -- profondità geometrica del foro
@@ -220,7 +263,7 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
   local nErrorCode = 0
   -- abilitazione foratura da sotto
   local bDrillDown = ( BD.DOWN_HEAD and ( Proc.Down or vtExtr:getZ() < -0.1 or vtExtr:getZ() < 0.259))
-   local bDrillUp = ( BD.DOWN_HEAD and vtExtr:getZ() > -0.259)
+   local bDrillUp = ( BD.DOWN_HEAD and vtExtr:getZ() > -0.5)
   -- 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)
@@ -282,6 +325,7 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
   local bCommonCompare = BD.MAX_TOOL_LEN_BACK_HOR_MACH and bOpen and abs(vtExtr:getX()) < 0.5 and abs(vtExtr:getZ()) < 0.5
   if nErrorCode == 0 and not bToInvert and bCommonCompare and vtExtr:getY() > 0.866 and Proc.Flg == 1 and dMaxToolLength > BD.MAX_TOOL_LEN_BACK_HOR_MACH then
      bToInvert = true
+      ptCen = ptCen - vtExtr * dLen
      vtExtr = - vtExtr
   ---------------------------------------------------------------------------------------------------------------------------------------------------------
   ---------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -300,8 +344,9 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
      dToolFreeLen = dToolFreeLen2
      dDepth       = dDepth2
      if vtExtr:getY() > 0 then
-         bToInvert    = true
-         vtExtr       = - vtExtr
+         bToInvert = true
+         ptCen = ptCen - vtExtr * dLen
+         vtExtr = - vtExtr
      end
   -- se sono al secondo mezzo foro con utensile che supera la lunghezza di riferimento non lo eseguo
   elseif nErrorCode == 0 and bCommonCompare and abs(vtExtr:getY()) > 0.866 and Proc.Flg == -2 and dMaxToolLength2 > BD.MAX_TOOL_LEN_BACK_HOR_MACH then
@@ -316,81 +361,65 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
      EgtOutLog( sErr)
      return false, sErr
   end
-   -- conservo il valore originale di MaxDepth per poter eventualmente bypassare i check successivi
+   -- Determino la faccia di inizio del foro e dati correlati 
+   local nFac, CosB, vFaces = GetHoleStartData( ptCen, vtExtr, b3Solid)
+   -- Calcolo acciorciamento affondamento utile per evitare collisione portautensile con faccia
+   local TgA = CosB / sqrt( 1 - CosB * CosB)
+   local dSubL = ( dDiamTh / 2 + ( Proc.Diam - dToolDiam) / 2 + 2) * TgA
   local dMaxDepthOri = dMaxDepth
-   -- verifico il massimo affondamento
-   local dSubL1 = 0
-   local dSubL2 = 0
-   local dSubL3 = 0
-   local dDeltaRad = ( Proc.Diam - dToolDiam) / 2
-   -- se foro non su testa o coda e inclinato
-   local bInMid = false 
-   local bInvertFcse = ( bToInvert and Proc.Flg ~= -2)
-   local bTryAngleDrill = false
-   if ( not bInvertFcse and Proc.Fcs ~= 5 and Proc.Fcs ~= 6) or ( bInvertFcse and Proc.Fce ~= 5 and Proc.Fce ~= 6) then
-      bInMid = true
-      local CosB = abs( vtExtr:getX())
-      if CosB < BD.DRILL_VX_MAX then
-         local TgA = CosB / sqrt( 1 - CosB * CosB)
-         dSubL1 = ( dDiamTh / 2 + dDeltaRad + 2) * TgA
-      else
-         -- settando dMaxDepth a 0 la lavorazione verrà disattivata
-         dMaxDepth = 0
-         -- se il foro è molto inclinato ma entro un certo limite, si cercheranno le forature speciali AngleDrill
-         if CosB < BD.DRILL_VX_MAX_ANGLEDRILL then
-            bTryAngleDrill = true
-         end
-      end
-   end
-   -- se foro davanti o dietro e inclinato
-   if dMaxDepth > 0 and abs( vtExtr:getY()) > abs( vtExtr:getZ()) then
-      local CosB = abs( vtExtr:getY())
-      if bInMid then
-         CosB = sqrt( vtExtr:getZ() * vtExtr:getZ() + vtExtr:getX() * vtExtr:getX())
-      end
-      if CosB < BD.DRILL_VX_MAX then
-         local TgA = CosB / sqrt( 1 - CosB * CosB)
-         dSubL2 = ( dDiamTh / 2 + dDeltaRad + 2) * TgA
-      else
-         -- settando dMaxDepth a 0 la lavorazione verrà disattivata
-         dMaxDepth = 0
-         -- se il foro è molto inclinato ma entro un certo limite, si cercheranno le forature speciali AngleDrill
-         if CosB < BD.DRILL_VX_MAX_ANGLEDRILL then
-            bTryAngleDrill = true
-         end
-      end
-   end
-   -- se foro sopra o sotto e inclinato
-   if dMaxDepth > 0 and abs( vtExtr:getZ()) > abs( vtExtr:getY()) then
-      local CosB = abs( vtExtr:getZ())
-      if bInMid then
-         CosB = sqrt( vtExtr:getY() * vtExtr:getY() + vtExtr:getX() * vtExtr:getX())
-      end
-      if CosB < BD.DRILL_VX_MAX then
-         local TgA = CosB / sqrt( 1 - CosB * CosB)
-         dSubL3 = ( dDiamTh / 2 + dDeltaRad + 2) * TgA
-      else
-         -- settando dMaxDepth a 0 la lavorazione verrà disattivata
-         dMaxDepth = 0
-         -- se il foro è molto inclinato ma entro un certo limite, si cercheranno le forature speciali AngleDrill
-         if CosB < BD.DRILL_VX_MAX_ANGLEDRILL then
-            bTryAngleDrill = true
-         end
-      end
-   end
-   local dSubL = max( dSubL1, dSubL2, dSubL3)
-   if dMaxDepth > 0 then
-      dMaxDepth = min( dMaxDepth, dToolFreeLen - dSubL)
-   end
-   if bTryAngleDrill then
+   dMaxDepth = min( dMaxDepth, dToolFreeLen - dSubL)
+   -- Verifico inclinazione foro nei limiti
+   local bTryDrill = ( CosB < BD.DRILL_VX_MAX)
+   if ( CosB > 0.8 * BD.DRILL_VX_MAX and CosB < BD.DRILL_VX_MAX_ANGLEDRILL) then
      -- cerco le forature speciali AngleDrill
      local sDrilling3, sType3, dMaxDepth3 = ML.FindAngleDrilling( dDiam, dCheckDepth, bDrillUp, bDrillDown)
      if sDrilling3 then
         sDrilling = sDrilling3
         sType = sType3
         dMaxDepth = dMaxDepth3
+         bTryDrill = true
      end
   end
+   -- aggiusto affondamento e MaxElev
+   local dMaxElev
+   local sMyWarn
+   -- se c'è un taglio precedente di testa o coda in cui il foro "entra" devo ricalcolare i dati della foratura
+   if (( Proc.MachineAfterHeadCutId and vtExtr:getX() > 0) or ( Proc.MachineAfterTailCutId and vtExtr:getX() < 0)) then
+      local bIntersectionOk, _, vDistance = EgtLineSurfTmInters( ptCen, -vtExtr, Proc.MachineAfterHeadCutId or Proc.MachineAfterTailCutId, GDB_RT.GLOB)
+      if bIntersectionOk then
+         local dHoleToCutDistance = vDistance[1]
+         -- se il taglio accorcia realmente il foro
+         if dHoleToCutDistance > 10 * GEO.EPS_SMALL and dHoleToCutDistance < dLen then
+            dMaxDepth = dMaxDepthOri
+            dMaxElev = dLen - dHoleToCutDistance
+            bTryDrill = true
+            local dToolAddLength = dLen - dMaxElev
+            -- se l'utensile è comunque troppo corto lavoro il massimo possibile
+            if dDepth - dToolAddLength > dMaxDepth + 10 * GEO.EPS_SMALL then
+               sMyWarn = 'Warning in drill : depth (' .. EgtNumToString( dDepth - dToolAddLength, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
+               dDepth = dLen
+            else
+               -- se è un foro splittato cerco comunque di arrivare alla massima profondità possibile, evitando di sfondare dall'altro lato.
+               if Proc.Flg == 2 or Proc.Flg == -2 then
+                  dDepth = dLen - 10
+               end
+               -- se non lavoro la massima lunghezza disponibile devo correggere MaxElev
+               dMaxElev = dMaxElev - dLen + dDepth
+            end
+         end
+      end
+   end
+   -- se foro da saltare per eccessiva inclinazione
+   if not bTryDrill then
+      sMyWarn = 'Warning in drill : too slant hole'
+      dDepth = 0
+      return true, sMyWarn
+   -- se non ridotto e affondamento richiesto supera il consentito
+   elseif not dMaxElev and dDepth > dMaxDepth + 10 * GEO.EPS_SMALL then
+      sMyWarn = 'Warning in drill : depth (' .. EgtNumToString( dDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
+      dDepth = dMaxDepth
+      dMaxElev = dMaxDepth
+   end
   -- inserisco la lavorazione
   local sName = 'Drill_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
   local nMchId = EgtAddMachining( sName, sDrilling)
@@ -424,57 +453,7 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
      nSCC = MCH_SCC.NONE
   end
   EgtSetMachiningParam( MCH_MP.SCC, nSCC)
-   -- aggiusto affondamento e MaxElev
-   local dMaxElev = dDepth
-   local sMyWarn
-   if dDepth > dMaxDepth + 10 * GEO.EPS_SMALL then
-      -- se c'è un taglio precedente di testa o coda posso impostare MaxElev per allungare il percorso
-      -- considero solo i fori "entranti" in testa o coda
-      if (( Proc.MachineAfterHeadCutId and vtExtr:getX() > 0) or ( Proc.MachineAfterTailCutId and vtExtr:getX() < 0)) then
-         local ptCen = EgtCP( AuxId, GDB_RT.GLOB)
-         local bIntersectionOk, _, vDistance = EgtLineSurfTmInters( ptCen, -vtExtr, Proc.MachineAfterHeadCutId or Proc.MachineAfterTailCutId, GDB_RT.GLOB)
-         dHoleToCutDistance = vDistance[1]
-         -- setto MaxElev
-         -- il segno della distanza data dalla funzione di intersezione mi indica dove sia la geometria del foro
-         if bIntersectionOk then
-            -- se MaxDepth era stato settato a 0 per disattivare la lavorazione gli riassegno il valore originale
-            if dMaxDepth == 0 then
-               dMaxDepth = dMaxDepthOri
-            end
-            if dHoleToCutDistance > 10 * GEO.EPS_SMALL then
-               dMaxElev = dLen - dHoleToCutDistance
-            elseif dHoleToCutDistance < -10 * GEO.EPS_SMALL then
-               dMaxElev = -dHoleToCutDistance
-            end
-            local dToolAddLength = dLen - dMaxElev
-            -- se l'utensile è comunque troppo corto lavoro il massimo possibile
-            if dDepth - dToolAddLength > dMaxDepth + 10 * GEO.EPS_SMALL then
-               sMyWarn = 'Warning in drill : depth (' .. EgtNumToString( dDepth - dToolAddLength, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
-               dDepth = dLen
-            else
-               -- se è un foro splittato cerco comunque di arrivare alla massima profondità possibile, evitando di sfondare dall'altro lato.
-               if Proc.Flg == 2 or Proc.Flg == -2 then
-                  dDepth = dLen - 10
-               end
-               -- se non lavoro la massima lunghezza disponibile devo correggere MaxElev
-               dMaxElev = dMaxElev - dLen + dDepth
-            end
-         -- se per qualche motivo fallisce l'intersezione torno al caso standard
-         else
-            sMyWarn = 'Warning in drill : depth (' .. EgtNumToString( dDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
-            dDepth = dMaxDepth
-            dMaxElev = dMaxDepth
-         end
-      -- caso standard
-      else
-         sMyWarn = 'Warning in drill : depth (' .. EgtNumToString( dDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
-         dDepth = dMaxDepth
-         dMaxElev = dMaxDepth
-      end
-      if sMyWarn then
-         EgtOutLog( sMyWarn)
-      end
-   end
+   -- imposto affondamento
   EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
   -- imposto il valore della distanza di sicurezza per l'attacco. Se il valore del db utensili è troppo basso lo alzo a 10.
   local dToolDbStartPos = EgtGetMachiningParam( MCH_MP.STARTPOS)
@@ -484,7 +463,9 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
   -- Note utente con dichiarazione nessuna generazione sfridi per Vmill
   local sUserNotes = 'VMRS=0;'
   -- aggiungo alle note massima elevazione (coincide con affondamento)
-   sUserNotes = sUserNotes .. 'MaxElev=' .. EgtNumToString( dMaxElev, 1) .. ';'
+   if dMaxElev then
+      sUserNotes = sUserNotes .. 'MaxElev=' .. EgtNumToString( dMaxElev, 1) .. ';'
+   end
   -- se foro passante, aggiungo questa qualifica alle note
   if ( sType == 'Drill' or sType == 'Drill_H2' or sType == 'AngleDrill') and  bOpen then
      sUserNotes = sUserNotes .. 'Open=1;'
@@ -696,8 +696,8 @@ function ProcessLapJoint.Classify( Proc, b3Raw)
      local bDown = ( vtN[1]:getZ() < BD.NZ_MINB and vtN[2]:getZ() < BD.NZ_MINB) or
                    ( vtN[1]:getZ() < BD.NZ_MINA and vtN[2]:getZ() < 0.5 and ( vtN[2]:getZ() < -0.1 or not bSmall)) or
                    ( vtN[2]:getZ() < BD.NZ_MINA and vtN[1]:getZ() < 0.5 and ( vtN[1]:getZ() < -0.1 or not bSmall))
-      -- per L30, se forzata la lavorazione con fresa di lato da parametro Q03=2 oppure Q03=3 non devo ruotare
-      local bForceSideMill = ( Proc.Prc == 30 and ( EgtGetInfo( Proc.Id, 'Q03', 'd') == 2 or EgtGetInfo( Proc.Id, 'Q03', 'd') == 3))
+      -- se forzata la lavorazione con fresa di lato da parametro Q03=2/3 non devo ruotare
+      local bForceSideMill = ( EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'd') == 2 or EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'd') == 3)
      bDown = ( bDown and not BD.DOWN_HEAD and not BD.TURN and not bForceSideMill)
      return true, bDown
   -- se più di 2 facce
@@ -797,8 +797,8 @@ function ProcessLapJoint.Classify( Proc, b3Raw)
            -- se verso il basso, verifico se utilizzabile seconda faccia
            if bDown then
               local bIsU = ( Proc.Fct == 3 and not TestElleShape3( Proc))
-               -- per lapjoint proc 30, se forzata la lavorazione con fresa di lato da parametro Q03=2 oppure Q03=3 non devo ruotare
-               local bForceSideMill = ( Proc.Prc == 30 and ( EgtGetInfo( Proc.Id, 'Q03', 'd') == 2 or EgtGetInfo( Proc.Id, 'Q03', 'd') == 3) and ( Proc.Fct == 3 or Proc.Fct == 4))
+               -- se forzata la lavorazione con fresa di lato da parametro Q03=2/3 non devo ruotare
+               local bForceSideMill = ( ( EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'd') == 2 or EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'd') == 3) and ( Proc.Fct == 3 or Proc.Fct == 4))
               if bForceSideMill then
                  bDown = false 
               elseif nFacInd2 and dElev2 < 2 * dElev then
@@ -3520,7 +3520,7 @@ local function GetUShapeWidth( Proc, nFacInd)
   -- Recupero le facce adiacenti alla principale
   local vAdj = EgtSurfTmFacetAdjacencies( Proc.Id, nFacInd)[1]
   -- se non ho facce adiacenti esco subito
-   if not vAdj or #vAdj == 0 then return nil end
+   if not vAdj or #vAdj == 0 then return 0 end
   -- Normale della faccia
   local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, nFacInd, GDB_ID.ROOT)
   -- Cerco le facce adiacenti alla principale con angolo concavo >= 90
@@ -3575,13 +3575,24 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha
   if bOrthoFaces then
      -- ottengo le dimensioni del tunnel 
      dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = GetTunnelDimension( Proc, nPartId)
-      local nPathInt
+      -- se due facce posso utilizzare utensile con diametro doppio della dimensione minima
+      if Proc.Fct == 2 then
+         dDimMin = 2 * dDimMin
+      -- se tre facce aumento il diametro di quanto possibile
+      elseif Proc.Fct == 3 then
+         local nFacInd = BL.GetFaceWithMostAdj( Proc.Id, nPartId, false)
+         local dWidth = GetUShapeWidth( Proc, nFacInd or -1)
+         if dWidth > dDimMin then
+            dDimMin = min( 2 * dDimMin, dWidth)
+         end
+      end
      -- se devo inserire il chamfer
      if nChamfer > 0 then
         local nOk, sErr = MakeChamfer( Proc, bIs3Faces, nAddGrpId, vtOrtho, b3Solid, nSurfInt, dDepthCham)
         if nOk < 0 then return -1, sErr end
      end
      -- se smusso non è esclusivo
+      local nPathInt
      if nChamfer < 2 then
         -- ricalcolo se è lavorabile da sotto
         bMillDown = ( BD.DOWN_HEAD == true)
@@ -4443,6 +4454,16 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
         -- verifico se posso farlo con la sega-catena
         local bMakeChainSaw, sSawing, dMaxMat, dSawCornerRad, dSawThick = VerifyChainSaw( Proc, dDimMin, dDimMax)
         if bMakeChainSaw then
+            -- Ricalcolo l'affondamento tenendo conto di eventuale inclinazione
+            local dSlDepth
+            local frSlDh = Frame3d( Proc.Box:getCenter(), vtOrtho)
+            for i = 1, Proc.Fct do
+               local b3Fac = EgtSurfTmGetFacetBBoxRef( Proc.Id, i - 1, GDB_BB.STANDARD, frSlDh)
+               if b3Fac and ( not dSlDepth or b3Fac:getDimZ() < dSlDepth) then
+                  dSlDepth = b3Fac:getDimZ()
+               end
+            end
+            if dSlDepth then dDepth = dSlDepth end
            -- Verifico se necessarie più passate
            local nStep = ceil( ( dDimMin - 100 * GEO.EPS_SMALL) / dSawThick)
            local dStep = 0
@@ -4462,7 +4483,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
               EgtSetMachiningGeometry( {{ Proc.Id, nLundIdFace}})
               -- imposto uso del lato faccia
               -- al momento, dato che la fessura è passante da parte a parte, gestisco solo la lavorazione
-               -- dall'alto e di fronte (da dietro è disabilitata perchè ho exracorsa con la FAST). 
+               -- dall'alto e di fronte (da dietro è disabilitata perchè ho extracorsa con la FAST). 
               -- Questa feature non è applicata su facce di testa e quindi non controllo l'entrata in X
               if abs(vtOrtho:getZ()) >= 0.707 then
                  EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.PARAL_DOWN)
@@ -877,7 +877,7 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster
      -- recupero la lavorazione
      local sMilling
      local bDownHead = ( nSide == -1 and BD.DOWN_HEAD)
-      sMilling = ML.FindMilling( 'Long2Cut_H2', dElev, nil, nil, nil, not bDownHead, bDownHead)
+      sMilling = ML.FindMilling( 'Long2Cut', dElev, nil, nil, nil, not bDownHead, bDownHead)

      if not sMilling then
         local sErr = 'Error : Long2Cut not found in library'
@@ -82,7 +82,8 @@ end

 ---------------------------------------------------------------------
 -- Aggiunge la lavorazione di pulizia angoli
-   local function AddCleanCornersMachining( nProcId, sMortising, nWorkFaceInd, vtN)
+   local function AddCleanCornersMachining( nProcId, sMortising, nWorkFaceInd, vtN, dDepth)
+      -- aggiungo la lavorazione
      local sName = 'Mort_' .. ( EgtGetName( nProcId) or tostring( nProcId)) .. '_CleanCorners1'
      local nMchFId = EgtAddMachining( sName, sMortising)
      if not nMchFId then
@@ -90,19 +91,28 @@ end
         EgtOutLog( sErr)
         return false, sErr
      end
-      sName = EgtGetOperationName( nMchFId)
-      -- aggiungo geometria
+      -- imposto geometria
      EgtSetMachiningGeometry( {{ nProcId, nWorkFaceInd}})
-      local nFaceUse = BL.GetNearestParalOpposite( vtN)
-      local vtOrtho = BL.GetVersRef( nFaceUse)
-      -- imposto angolo 3° asse rot
-      EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetChainSawBlockedAxis( 1))
-      EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( vtN, vtOrtho, 1))
+      -- imposto lato di lavoro e inversione
+      local vtFaceN = EgtSurfTmFacetNormVersor( nProcId, nWorkFaceInd, GDB_ID.ROOT)
+      local bInvert = ( vtFaceN:getZ() < -GEO.EPS_SMALL or vtFaceN:getY() > GEO.EPS_SMALL)
+      EgtSetMachiningParam( MCH_MP.WORKSIDE, EgtIf( bInvert, MCH_MORTISE_WS.LEFT, MCH_MORTISE_WS.RIGHT))
+      EgtSetMachiningParam( MCH_MP.INVERT, bInvert)
+      -- se richiesto, imposto affondamento
+      if dDepth then
+         EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
+      end
      -- imposto uso del lato faccia
+      local nFaceUse = BL.GetNearestParalOpposite( vtN)
      EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
      -- applico il parametro plunge, che setta la lavorazione per affondare solamente, senza lavorare tutto il contorno; 1: solo lato iniziale, 2: solo lato finale, 3: entrambi
      sNotes = 'Plunge=3;'
      EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
+      -- imposto angolo 3° asse rot
+      local vtOrtho = BL.GetVersRef( nFaceUse)
+      EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetChainSawBlockedAxis( 1))
+      EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( vtN, vtOrtho, 1))
+      -- calcolo la lavorazione
      if not ML.ApplyMachining( true, false) then
         if EgtGetOutstrokeInfo() then
            local _, sErr = EgtGetLastMachMgrError()
@@ -128,77 +138,95 @@ end

 ---------------------------------------------------------------------
 -- Pulizia angoli nel caso sia settato il parametro P04=1
-local function CleanCorners( Proc, dMorH, vtN, bOpenBtm, AuxId)
+local function CleanCorners( Proc, dMorH, vtN, bDoubleDir, AuxId)
   -- verifico se è attiva la pulizia e se l'orientamento della feature è adeguato
   local bCleanCorners = ( EgtGetInfo( Proc.Id, 'P04', 'i') == 1 and
-                         ( AreSameOrOppositeVectorApprox( vtN, X_AX()) or 
-                           AreSameOrOppositeVectorApprox( vtN, Y_AX()) or
-                           AreSameOrOppositeVectorApprox( vtN, Z_AX())))
+                           ( AreSameOrOppositeVectorApprox( vtN, X_AX()) or 
+                             AreSameOrOppositeVectorApprox( vtN, Y_AX()) or
+                             AreSameOrOppositeVectorApprox( vtN, Z_AX())))
+   if not bCleanCorners then
+      EgtOutLog( 'Warning: mortising not aligned with XYZ axes, corner cleaning skipped')
+      return
+   end
   -- cerco la lavorazione adatta
   local sMortisingCleanCorners = ML.FindSawing( 'Mortising')
-   if bCleanCorners and sMortisingCleanCorners then
-      local dSawWidth = 50
-      local dSawThick = 12
-      local dMaxDepth = 200 
-      -- se non trova la lavorazione non faccio nulla
-      if not sMortisingCleanCorners then
-         local sWarn = 'Warning: mortising tool not found, corner cleaning skipped'
-         EgtOutLog( sWarn)
-         return true, sWarn
-      else
-         -- recupero i dati dell'utensile
-         if EgtMdbSetCurrMachining( sMortisingCleanCorners) then
-            local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
-            if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
-               dSawWidth = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawWidth
-               dSawThick = EgtTdbGetCurrToolParam( MCH_TP.THICK) or dSawThick
-               dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
-            end
-         end
-         -- al momento se l'utensile non arriva salto la lavorazione
-         local dFullMorH = EgtIf( bOpenBtm, dMorH * 2, dMorH)
-         if dFullMorH > dMaxDepth + 10 * GEO.EPS_SMALL then
-            local sErr = 'Error in Mortise - corner cleaning : elevation (' .. EgtNumToString( dFullMorH, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
-            EgtOutLog( sErr)
-            return false, sErr
-         end
-         -- verifico se la tasca ha dimensioni sufficienti per l'utensile
-         local nSurf = EgtSurfTmByFlatContour( EgtGetParent( AuxId), AuxId, 0.05)
-         local frMor, dMortiseWidth, dMortiseThick = EgtSurfTmFacetMinAreaRectangle( nSurf, 0, GDB_ID.ROOT)
-         if abs( frMor:getVersX() * X_AX()) < abs( frMor:getVersY() * X_AX()) then
-            dMortiseWidth, dMortiseThick = dMortiseThick, dMortiseWidth
-         end
-         EgtErase( nFlat)
-         if dSawWidth >= dMortiseWidth + 10 * GEO.EPS_SMALL or dSawThick >= dMortiseThick + 10 * GEO.EPS_SMALL then
-            local sErr = 'Error in Mortise - corner cleaning: pocket too small'
-            EgtOutLog( sErr)
-            return false, sErr
-         end
-         -- cerco le due facce migliori da lavorare
-         local nWorkFaceInd, nWorkFaceInd2
-         if AreSameOrOppositeVectorApprox( vtN, X_AX()) then
-            nWorkFaceInd, _, _ = BL.FindFaceBestOrientedAsAxis( Proc, vtN ^ Y_AX())
-            nWorkFaceInd2, _, _ = BL.FindFaceBestOrientedAsAxis( Proc, vtN ^ Y_AX(), nWorkFaceInd)
-         else
-            nWorkFaceInd, _, _ = BL.FindFaceBestOrientedAsAxis( Proc, vtN ^ X_AX())
-            nWorkFaceInd2, _, _ = BL.FindFaceBestOrientedAsAxis( Proc, vtN ^ X_AX(), nWorkFaceInd)
-         end
-         -- lavoro la prima faccia
-         local bOk1, sErr = AddCleanCornersMachining( Proc.Id, sMortisingCleanCorners, nWorkFaceInd, vtN)
-         -- lavoro la seconda faccia
-         local bOk2, sErr2 = AddCleanCornersMachining( Proc.Id, sMortisingCleanCorners, nWorkFaceInd2, vtN)
-         if sErr2 then
-            if not sErr then sErr = '' end
-            if sErr ~= sErr2 then
-               sErr = EgtIf( #sErr > 0, sErr .. '\n' .. sErr2, sErr2)
-            end
-         end
-         if not bOk1 or not bOk2 then
-            return false, sErr
-         end
-         return true, sErr
+   if not sMortisingCleanCorners then
+      EgtOutLog( 'Warning: mortising tool not found, corner cleaning skipped')
+      return
+   end
+   -- recupero i dati dell'utensile
+   local dSawWidth = 50
+   local dSawThick = 12
+   local dMaxDepth = 200 
+   if EgtMdbSetCurrMachining( sMortisingCleanCorners) then
+      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
+         dSawWidth = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawWidth
+         dSawThick = EgtTdbGetCurrToolParam( MCH_TP.THICK) or dSawThick
+         dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
      end
   end
+   -- se l'utensile non arriva in fondo, riduco l'affondamento
+   local sWarn
+   local dDepth
+   local bUseDoubleDir
+   if bDoubleDir then
+      if ( 2 * dMorH + dSawWidth / 2) > dMaxDepth + 10 * GEO.EPS_SMALL then
+         bUseDoubleDir = true
+         if ( dMorH + dSawWidth / 2) > dMaxDepth + 10 * GEO.EPS_SMALL then
+            dDepth = dMaxDepth
+            sWarn = 'Warning in corner cleaning with mortise: elevation (' .. EgtNumToString( dMorH + dSawWidth / 2, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
+            EgtOutLog( sWarn)
+         else
+            dDepth = dMorH + dSawWidth / 2
+         end
+      else
+         dDepth = 2 * dMorH + dSawWidth / 2
+      end
+   else
+      if dMorH > dMaxDepth + 10 * GEO.EPS_SMALL then
+         dDepth = dMaxDepth
+         sWarn = 'Warning in corner cleaning with mortise: elevation (' .. EgtNumToString( dMorH, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
+         EgtOutLog( sWarn)
+      end
+   end
+   -- verifico se la tasca ha dimensioni sufficienti per l'utensile
+   local nFlat = EgtSurfTmByFlatContour( EgtGetParent( AuxId), AuxId, 0.05)
+   local frMor, dMortiseWidth, dMortiseThick = EgtSurfTmFacetMinAreaRectangle( nFlat, 0, GDB_ID.ROOT)
+   if abs( frMor:getVersX() * X_AX()) < abs( frMor:getVersY() * X_AX()) then
+      dMortiseWidth, dMortiseThick = dMortiseThick, dMortiseWidth
+   end
+   EgtErase( nFlat)
+   if dSawWidth >= dMortiseWidth + 10 * GEO.EPS_SMALL or dSawThick >= dMortiseThick + 10 * GEO.EPS_SMALL then
+      sWarn = 'warning in corner cleaning with mortise: pocket too small'
+      EgtOutLog( sWarn)
+      return true, sWarn
+   end
+   -- cerco le due facce migliori da lavorare
+   local nWorkFaceInd, nWorkFaceInd2
+   if AreSameOrOppositeVectorApprox( vtN, X_AX()) then
+      nWorkFaceInd, _, _ = BL.FindFaceBestOrientedAsAxis( Proc, vtN ^ Y_AX())
+      nWorkFaceInd2, _, _ = BL.FindFaceBestOrientedAsAxis( Proc, vtN ^ Y_AX(), nWorkFaceInd)
+   else
+      nWorkFaceInd, _, _ = BL.FindFaceBestOrientedAsAxis( Proc, vtN ^ X_AX())
+      nWorkFaceInd2, _, _ = BL.FindFaceBestOrientedAsAxis( Proc, vtN ^ X_AX(), nWorkFaceInd)
+   end
+   -- lavoro la prima faccia
+   local bOk1, sErr = AddCleanCornersMachining( Proc.Id, sMortisingCleanCorners, nWorkFaceInd, vtN, dDepth)
+   -- lavoro la seconda faccia
+   local bOk2, sErr2 = AddCleanCornersMachining( Proc.Id, sMortisingCleanCorners, nWorkFaceInd2, vtN, dDepth)
+   if sErr2 then sErr = ( sErr or '') .. EgtIf( sErr,  '\n', '') .. sErr2 end
+   -- se richiesto di lavorare dall'altra parte
+   if bUseDoubleDir then
+      local bOk3, sErr3 = AddCleanCornersMachining( Proc.Id, sMortisingCleanCorners, nWorkFaceInd, -vtN, dDepth)
+      if sErr3 then sErr = ( sErr or '') .. EgtIf( sErr,  '\n', '') .. sErr3 end
+      local bOk4, sErr4 = AddCleanCornersMachining( Proc.Id, sMortisingCleanCorners, nWorkFaceInd2, -vtN, dDepth)
+      if sErr4 then sErr = ( sErr or '') .. EgtIf( sErr,  '\n', '') .. sErr4 end
+   end
+   if not bOk1 or not bOk2 or not bOk3 or not bOk4 then
+      return false, sErr
+   end
+   return true, sWarn
 end

   ---------------------------------------------------------------------
@@ -280,7 +308,7 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
         local dMove = bxMin:getZ()-bxMax:getZ()
         -- se il percorso ausiliario è esterno al grezzo, lo riavvicino
         if abs( dMove) > GEO.EPS_SMALL then
-            AuxId = EgtCopyGlob( AuxId, BL.GetAddGroup(nPartId))
+            AuxId = EgtCopyGlob( AuxId, BL.GetAddGroup( nPartId))
            EgtMove( AuxId, Vector3d(0,0,-dMove))
            EgtMove( nFlat, Vector3d(0,0,-dMove))
            frMor, dL, dW = EgtSurfTmFacetMinAreaRectangle( nFlat, 0, GDB_ID.ROOT)
@@ -409,8 +437,12 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
   local nSCC = MCH_SCC.NONE
   if bPockAngTrasm then
      nSCC = MCH_SCC.ADIR_NEAR
-   elseif not BD.C_SIMM then 
-      if vtN:getY() < GEO.EPS_SMALL then
+   elseif not BD.C_SIMM then
+      if abs( vtN:getX()) < GEO.EPS_SMALL and abs( vtN:getY()) < GEO.EPS_SMALL then
+         nSCC = MCH_SCC.ADIR_YM
+      elseif abs( vtN:getX()) < GEO.EPS_SMALL then
+         nSCC = MCH_SCC.ADIR_XP
+      elseif vtN:getY() < GEO.EPS_SMALL then
         nSCC = EgtIf( bRevertSide, MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
      else
         nSCC = EgtIf( bRevertSide, MCH_SCC.ADIR_YM, MCH_SCC.ADIR_YP)
@@ -449,12 +481,6 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
      EgtSetOperationMode( nMchFId, false)
      return false, sErr
   end
-   -- verifico se necessaria la pulizia degli angoli ( tenone ad angoli non raggiati) e applico nel caso
-   local _, sWarn2 = CleanCorners( Proc, dMorH, vtN, bOpenBtm, AuxId)
-   if sWarn2 then
-      if not sWarn then sWarn = '' end
-      sWarn = EgtIf( #sWarn > 0, sWarn .. '\n' .. sWarn2, sWarn2)
-   end
   -- Se non c'è il fondo e la lavorazione non ha lavorato tutta la superficie per limite altezza utensile
   -- inserisco una ulteriore lavorazione contraria
   if bOpenBtm and not bForceOneSide and nDepthMin and abs(nDepthMin) > 0 then
@@ -475,11 +501,19 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
      -- sistemo la direzione di lavoro
      EgtSetMachiningParam( MCH_MP.INVERT, EgtIf( bCW, true, false))
      -- imposto posizione braccio porta testa
-      if vtN:getY() < GEO.EPS_SMALL then
-         EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP)
-      else
-         EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM)
+      local nSCC = MCH_SCC.NONE
+      if not BD.C_SIMM then
+         if abs( vtN:getX()) < GEO.EPS_SMALL and abs( vtN:getY()) < GEO.EPS_SMALL then
+            nSCC = MCH_SCC.ADIR_YM
+         elseif abs( vtN:getX()) < GEO.EPS_SMALL then
+            nSCC = MCH_SCC.ADIR_XP
+         elseif vtN:getY() < GEO.EPS_SMALL then
+            nSCC = MCH_SCC.ADIR_YP
+         else
+            nSCC = MCH_SCC.ADIR_YM
+         end
      end
+      EgtSetMachiningParam( MCH_MP.SCC, nSCC)
      -- se altezza mortasa differente da altezza massima lavorabile
      if abs( dMorH - dMaxDepth) > GEO.EPS_SMALL then
         nDepthMin = -dMorH
@@ -497,6 +531,12 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
         return false, sErr
      end
   end
+   -- verifico se necessaria la pulizia degli angoli ( tenone ad angoli non raggiati) e applico nel caso
+   local _, sWarn2 = CleanCorners( Proc, dMorH, vtN, bOpenBtm and not bForceOneSide, AuxId)
+   if sWarn2 then
+      if not sWarn then sWarn = '' end
+      sWarn = EgtIf( #sWarn > 0, sWarn .. '\n' .. sWarn2, sWarn2)
+   end

   return true, sWarn
 end
@@ -1,6 +1,7 @@
 -- ProcessSimpleScarf.lua by Egaltech s.r.l. 2020/06/04
 -- Gestione calcolo giunto Gerber per Travi
 -- 2022/06/10 Aggiunto il parametro dOvmTail per gestire sovramateriali in coda diversi da OVM_MID (sezioni alte e larghe)
+-- 2022/08/09 Ora se la feature ha meno di due facce viene richiamata la normale Cut.

 -- Tabella per definizione modulo
 local ProcessSimpleScarf = {}
@@ -10,6 +11,7 @@ require( 'EgtBase')
 local BL = require( 'BeamLib')
 local Fbs = require( 'FacesBySaw')
 local DC = require( 'DiceCut')
+local Cut = require( 'ProcessCut')

 EgtOutLog( ' ProcessSimpleScarf started', 1)

@@ -138,12 +140,11 @@ function ProcessSimpleScarf.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmT
      EgtOutLog( sErr)
      return false, sErr
   end
-   -- verifico che ci siano almeno due facce (altrimenti non è da lavorare)
+   -- se ci sono meno di due facce si riduce a una normale Cut
   local nFacetCnt = EgtSurfTmFacetCount( Proc.Id)
   if nFacetCnt < 2 then
-      local sErr = 'Error : number of faces not enough'
-      EgtOutLog( sErr)
-      return false, sErr
+      local bOk, sErr = Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, nil, nil, nil, nil, nil, dOvmTail)
+      return bOk, sErr
   end
   -- dati delle facce
   local ptC = {}
@@ -1,5 +1,5 @@
 -- BeamNestProcess.lua by Egaltech s.r.l. 2021/06/14
-- Gestione nesting automatico pareti
+-- Gestione nesting automatico travi

 -- Intestazioni
 require( 'EgtBase')
@@ -257,7 +257,7 @@ while TotRawCount( Raws) > 0 and PartsToFill( Parts) > 0 do
   local Results = {}
   for RawIndex = 1, #Raws do
      if Raws[RawIndex].Count > 0 then
-      Results[RawIndex] = ExecMaximumFilling( Raws[RawIndex], PartsToNest)
+         Results[RawIndex] = ExecMaximumFilling( Raws[RawIndex], PartsToNest)
      else
         Results[RawIndex] = { FillRatio = 0.001, LenToFill = 1000}
      end
@@ -267,10 +267,10 @@ while TotRawCount( Raws) > 0 and PartsToFill( Parts) > 0 do
   local dMinWaste = 100000
   for ResultIndex = 1, #Results do
      if Results[ResultIndex] then
-      local dWaste = (1 - Results[ResultIndex].FillRatio) * Raws[ResultIndex].LenToFill
-      if dWaste < dMinWaste then
-         dMinWaste = dWaste
-         nMinWasteRawIndex = ResultIndex
+         local dWaste = (1 - Results[ResultIndex].FillRatio) * Raws[ResultIndex].LenToFill
+         if dWaste < dMinWaste then
+            dMinWaste = dWaste
+            nMinWasteRawIndex = ResultIndex
         end
      end
   end
@@ -301,11 +301,11 @@ while TotRawCount( Raws) > 0 and PartsToFill( Parts) > 0 do
         end
      end
      nRawTot = nRawTot + 1
-   -- Aggiorno per prossima iterazione
-   Raws[nMinWasteRawIndex].Count = Raws[nMinWasteRawIndex].Count - 1
-   for i = 1, Results[nMinWasteRawIndex].DiffParts do
-      local PartId = Results[nMinWasteRawIndex].Data[i].Id
-      PartsToNest[PartId].Cnt = PartsToNest[PartId].Cnt - Results[nMinWasteRawIndex].Data[i].Count
+      -- Aggiorno per prossima iterazione
+      Raws[nMinWasteRawIndex].Count = Raws[nMinWasteRawIndex].Count - 1
+      for i = 1, Results[nMinWasteRawIndex].DiffParts do
+         local PartId = Results[nMinWasteRawIndex].Data[i].Id
+         PartsToNest[PartId].Cnt = PartsToNest[PartId].Cnt - Results[nMinWasteRawIndex].Data[i].Count
      end
   end
   nCycle = nCycle + 1
Author	SHA1	Message	Date
luca.mazzoleni	2081b15276	BugFix/ScarfOneFaceReduceToCut: ora se il giunto Gerber ha una sola faccia viene richiamata la Process.Cut	2022-08-09 09:41:17 +02:00
luca.mazzoleni	c810aea200	Merge branch 'master' into develop	2022-08-09 09:15:38 +02:00
DarioS	a684b5a5db	DataBeam : - correzione in BeamExec per macchine senza BD.MAX_WIDTH2 e BD.MAX_HEIGHT2 - migliorata gestione L030 sotto con 3 facce - migliorata gestione affondamento/elevazione lavorazioni con sega a catena.	2022-08-09 07:09:35 +02:00
DarioS	a5f80f5c25	DataBeam : - modifiche a Mortise per lato mensola asse C FAST e per direzione lavoro con mortasatrice a catena.	2022-08-03 08:38:33 +02:00
DarioS	28af706910	DataBeam : - tolleranza su sezione portata a 0.1 mm (100 * GEO.EPS_SMALL) - funzioni StartsWith e EndsWith sostituite da analoghe funzioni di libreria (con prefisso Egt) - corretta gestione tagli con testa che taglia da sotto in su - riordino forature per gestione inclinazione limite da superficie trave - in Mortasature se non si può pulire angoli con mortasatrice warning invece di errore.	2022-08-01 17:39:49 +02:00
luca.mazzoleni	94508d51c8	Merge branch 'Feature/MortiseCornerFinishing' into develop	2022-07-29 18:50:51 +02:00
luca.mazzoleni	acf568d8db	Merge branch 'Feature/MortiseCornerFinishing' into develop	2022-07-29 10:06:51 +02:00
luca.mazzoleni	6780d5e5f5	Merge branch 'Feature/AngledDrillings' into develop	2022-07-28 09:39:17 +02:00