Feature/LapJointStepOnF1: aggiunta gestione parametro Q03=3. Si comporta come Q03=2 ma esclude le feature con facce di lavoro rivolte verso l'alto (+/- 10°)

- Modifiche per sega a catena di testa e relativa MaxElev.

LuaLibs/BeamExec.lua

@@ -30,8 +30,6 @@
 -- 2022/06/10 Per sezioni alte e larghe modificata la gestione del sovramateriale per considerare la presenza di feature preesistenti ed
 --            eventuale parametro Q05, che determinano la presenza o meno della finitura.
 --            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.
 
 -- Tabella per definizione modulo
 local BeamExec = {}
@@ -125,6 +123,7 @@ local FreeContour = require( 'ProcessFreeContour')
 local Decor = require( 'ProcessDecor')
 
 EgtOutLog( ' BeamExec started', 1)
+
 EgtMdbSetGeneralParam( MCH_GP.MAXDEPTHSAFE, BD.COLL_SIC)
 EgtMdbSave()
 
@@ -227,23 +226,13 @@ local function IsTailFeature( Proc, b3Raw, dCurrOvmH, dCurrOvmT)
    return false
 end
 
--------------------------------------------------------------------------------------------------------------
--- restituisce vero se la feature con box b3Proc taglia l'intera sezione della barra, rappresentata dalle sue dimensioni W e H
-local function IsFeatureCuttingEntireSection( b3Proc, dRawW, dRawH)
-   return ((abs(b3Proc:getDimY() - dRawW) < 10 * GEO.EPS_SMALL or b3Proc:getDimY() > dRawW) and (abs(b3Proc:getDimZ() - dRawH) < 10 * GEO.EPS_SMALL or b3Proc:getDimZ() > dRawH))
-end
-
 -------------------------------------------------------------------------------------------------------------
 local function CollectFeatures( PartId, b3Raw, dCurrOvmH, dCurrOvmT)
-   local dRawW = b3Raw:getDimY()
-   local dRawH = b3Raw:getDimZ()
    -- recupero le feature
    local vProc = {}
    local LayerId = {}
    LayerId[1] = BL.GetAddGroup( PartId)
    LayerId[2] = EgtGetFirstNameInGroup( PartId or GDB_ID.NULL, 'Processings')
-   local nMachineBeforeIntersectingDrillingsIdHead, dMachineBeforeIntersectingDrillingsXHead, nMachineBeforeIntersectingDrillingsIdTail, dMachineBeforeIntersectingDrillingsXTail = nil, GEO.INFINITO, nil, -GEO.INFINITO
-   local b3MachineBeforeIntersectingDrillingsBoxHead, b3MachineBeforeIntersectingDrillingsBoxTail = nil, nil
    for nInd = 1, 2 do
       local ProcId = EgtGetFirstInGroup( LayerId[nInd] or GDB_ID.NULL)
       while ProcId do
@@ -271,17 +260,6 @@ local function CollectFeatures( PartId, b3Raw, dCurrOvmH, dCurrOvmT)
                if Proc.Box and not Proc.Box:isEmpty() then 
                   Proc.Head = IsHeadFeature( Proc, b3Raw, dCurrOvmH)
                   Proc.Tail, Proc.AdvTail = IsTailFeature( Proc, b3Raw, dCurrOvmH, dCurrOvmT)
-                  if Proc.Fct == 1 and IsFeatureCuttingEntireSection( Proc.Box , dRawW, dRawH) and ( Proc.Head or Proc.Tail) and Proc.Prc ~= 340 and Proc.Prc ~= 350 then
-                     if Proc.Head and Proc.Box:getCenter():getX() < dMachineBeforeIntersectingDrillingsXHead then
-                        dMachineBeforeIntersectingDrillingsXHead = Proc.Box:getCenter():getX()
-                        nMachineBeforeIntersectingDrillingsIdHead = Proc.Id
-                        b3MachineBeforeIntersectingDrillingsBoxHead = Proc.Box
-                     elseif Proc.Tail and Proc.Box:getCenter():getX() > dMachineBeforeIntersectingDrillingsXTail then
-                        dMachineBeforeIntersectingDrillingsXTail = Proc.Box:getCenter():getX()
-                        nMachineBeforeIntersectingDrillingsIdTail = Proc.Id
-                        b3MachineBeforeIntersectingDrillingsBoxTail = Proc.Box
-                     end
-                  end
                   table.insert( vProc, Proc)
                   -- se foro
                   if Drill.Identify( Proc) then
@@ -332,11 +310,7 @@ local function CollectFeatures( PartId, b3Raw, dCurrOvmH, dCurrOvmT)
          ProcId = EgtGetNext( ProcId)
       end
    end
-   local vMachineBeforeIntersectingDrillings = {
-      Head = { Id = nMachineBeforeIntersectingDrillingsIdHead, Box = b3MachineBeforeIntersectingDrillingsBoxHead},
-      Tail = { Id = nMachineBeforeIntersectingDrillingsIdTail, Box = b3MachineBeforeIntersectingDrillingsBoxTail}
-   }
-   return vProc, vMachineBeforeIntersectingDrillings
+   return vProc
 end
 
 -------------------------------------------------------------------------------------------------------------
@@ -356,7 +330,8 @@ local function AnalyzeHeadFeatures( b3Solid, vProc, dRawW, dRawH)
       end
       if Proc.Head and Proc.Id ~= nReplacedFeatureId and Proc.Prc ~= 340 then
          -- controllo se la feature taglia l'intera sezione; in caso positivo la finitura non è necessaria
-         bHeadFinishingNeeded = not IsFeatureCuttingEntireSection( Proc.Box, dRawW, dRawH)
+         bHeadFinishingNeeded = not (( abs( Proc.Box:getDimY() - dRawW) < 10 * GEO.EPS_SMALL or Proc.Box:getDimY() > dRawW) and
+                                     ( abs( Proc.Box:getDimZ() - dRawH) < 10 * GEO.EPS_SMALL or Proc.Box:getDimZ() > dRawH))
       end
    end
    return bHeadFinishingNeeded, nReplacedFeatureId
@@ -379,7 +354,8 @@ local function AnalyzeTailFeatures( b3Solid, vProc, dRawW, dRawH)
       end
       if Proc.Tail and Proc.Id ~= nReplacedFeatureId and Proc.Prc ~= 350 then
          -- controllo se la feature taglia l'intera sezione; in caso positivo la finitura non è necessaria
-         bTailFinishingNeeded = not IsFeatureCuttingEntireSection( Proc.Box, dRawW, dRawH)
+         bTailFinishingNeeded = not (( abs( Proc.Box:getDimY() - dRawW) < 10 * GEO.EPS_SMALL or Proc.Box:getDimY() > dRawW) and
+                                     ( abs( Proc.Box:getDimZ() - dRawH) < 10 * GEO.EPS_SMALL or Proc.Box:getDimZ() > dRawH))
       end
    end
    return bTailFinishingNeeded, nReplacedFeatureId
@@ -885,18 +861,12 @@ local function ClassifyFeatures( vProc, b3Raw, Stats)
    local bSplitRot = false
    local nHeading
    local nSplitting
-   local vMachineBeforeIntersectingDrillingsId = {}
    for i = 1, #vProc do
       local Proc = vProc[i]
       local bOk = true
       local bDown = false
       local bSide = false
       local bDownSideOnHeadOk = false
-      
-      if Proc.MachineBeforeIntersectingDrillings then
-         table.Insert ( vMachineBeforeIntersectingDrillingsId, Proc.Id)
-      end
-      
       -- se senza geometria (già disabilitato
       if Proc.Flg == 0 then
          bOk = false
@@ -1313,68 +1283,8 @@ local function MoveDrillsOnTenon( vProc)
    end
 end
 
--------------------------------------------------------------------------------------------------------------
--- verifica se ci sono forature da lavorare dopo tagli di testa o coda e nel caso le classifica come Head o Tail e gli assegna l'Id della rispettiva feature di taglio
-local function SetDrillingsToMachineAfterHeadOrTailCut( vProc, vMachineBeforeIntersectingDrillings)
-   for i = 1, #vProc do
-      if Drill.Identify( vProc[i]) then
-         -- recupero e verifico l'entità foro
-         local AuxId = EgtGetInfo( vProc[i].Id, 'AUXID', 'i')
-         if AuxId then AuxId = AuxId + vProc[i].Id end
-         if not AuxId  or  EgtGetType( AuxId) ~= GDB_TY.CRV_ARC then
-            return false
-         end
-         -- recupero il vettore estrusione
-         local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
-         local bOpen = ( vProc[i].Fcs ~= 0  and  vProc[i].Fce ~= 0)
-         local ptCen = EgtCP( AuxId, GDB_RT.GLOB)
-         local vDistHead, vDistTail
-         -- check intersezione con feature di testa
-         if vMachineBeforeIntersectingDrillings.Head.Id then
-            -- verifico che ci sia intersezione tra la feature foro e la feature taglio di testa
-            local bIntersectionWithHead =
-            vMachineBeforeIntersectingDrillings.Head.Box and vProc[i].Box:getMin():getX() < vMachineBeforeIntersectingDrillings.Head.Box:getMax():getX() + 100 * GEO.EPS_SMALL and
-            vMachineBeforeIntersectingDrillings.Head.Box:getMin():getX() < vProc[i].Box:getMax():getX() + 100 * GEO.EPS_SMALL
-            -- verifico che ci sia intersezione tra la direzione di estrusione e la faccia della feature taglio di testa
-            if bIntersectionWithHead then
-               _, _, vDistHead = EgtLineSurfTmInters( ptCen, -vtExtr, vMachineBeforeIntersectingDrillings.Head.Id, GDB_RT.GLOB)
-            end
-         end
-         -- check intersezione con feature di coda
-         if vMachineBeforeIntersectingDrillings.Tail.Id then
-            -- verifico che ci sia intersezione tra la feature foro e la feature taglio di coda
-            local bIntersectionWithTail =
-            vMachineBeforeIntersectingDrillings.Tail.Box and vProc[i].Box:getMin():getX() < vMachineBeforeIntersectingDrillings.Tail.Box:getMax():getX() + 100 * GEO.EPS_SMALL and
-            vMachineBeforeIntersectingDrillings.Tail.Box:getMin():getX() < vProc[i].Box:getMax():getX() + 100 * GEO.EPS_SMALL
-            -- verifico che ci sia intersezione tra la direzione di estrusione e la faccia della feature taglio di coda
-            if bIntersectionWithTail then
-               _, _, vDistTail = EgtLineSurfTmInters( ptCen, -vtExtr, vMachineBeforeIntersectingDrillings.Tail.Id, GDB_RT.GLOB)
-            end
-         end
-         -- se esiste intersezione tra il foro e la feature di testa
-         if vDistHead and #vDistHead > 0 then
-            -- verifico che il foro sia di testa
-            if ( bOpen or ( not bOpen and vtExtr:getX() > 0 and vProc[i].Fcs ~= 0) or ( not bOpen and vtExtr:getX() < 0 and vProc[i].Fce ~= 0)) then
-               vProc[i].MachineAfterHeadCutId = vMachineBeforeIntersectingDrillings.Head.Id
-               vProc[i].Head = true
-            end
-         -- se esiste intersezione tra il foro e la feature di coda
-         elseif vDistTail and #vDistTail > 0 then
-            -- verifico che il foro sia di coda
-            if ( bOpen or ( not bOpen and vtExtr:getX() < 0 and vProc[i].Fcs ~= 0) or ( not bOpen and vtExtr:getX() > 0 and vProc[i].Fce ~= 0)) then
-               vProc[i].MachineAfterTailCutId = vMachineBeforeIntersectingDrillings.Tail.Id
-               vProc[i].Tail = true
-            end
-         end
-      end
-   end
-end
-
 -------------------------------------------------------------------------------------------------------------
 function BeamExec.ProcessFeatures()
-   if BD.IMPROVE_HEAD_TAIL_DRILLINGS == nil then
-      BD.IMPROVE_HEAD_TAIL_DRILLINGS = true
-   end
    -- verifica se possibile rotazione di 90 gradi
    BD.ROT90 = BD.ROT90 and Verify90DegRotation( EgtGetFirstRawPart())
    -- ciclo sui pezzi
@@ -1402,11 +1312,7 @@ function BeamExec.ProcessFeatures()
       local dCurrOvmH = EgtGetInfo( nRawId, 'HOVM', 'd') or 0
       local dCurrOvmT = EgtGetInfo( nRawId, 'TOVM', 'd') or 0
       -- recupero le feature di lavorazione della trave
-      local vProc, vMachineBeforeIntersectingDrillings = CollectFeatures( nPartId, b3Raw, dCurrOvmH, dCurrOvmT)
-      -- verifica presenza forature influenzate da lavorazioni di testa o coda
-      if BD.IMPROVE_HEAD_TAIL_DRILLINGS then
-         SetDrillingsToMachineAfterHeadOrTailCut( vProc, vMachineBeforeIntersectingDrillings)
-      end
+      local vProc = CollectFeatures( nPartId, b3Raw, dCurrOvmH, dCurrOvmT)
       -- le ordino lungo X
       OrderFeatures( vProc, b3Raw)
       -- le classifico

LuaLibs/ProcessDrill.lua

@@ -8,8 +8,6 @@
 -- 2022/03/29 DS Corretta assegnazione fori molto inclinati fianco/coda a coda.
 -- 2022/04/21 DS Corretto riconoscimento fori di coda.
 -- 2022/06/22 Nel riconoscimento fori di coda si utilizza ora il reale sovramateriale di coda (dOvmTail) invece di BD.OVM_MID.
--- 2022/07/01 Aggiunta gestione allungamento percorsi fori in caso di materiale già rimosso da lavorazioni precedenti
--- 2022/07/07 Aggiunta la gestione delle forature migliorate in presenza di feature testa/coda che tagliano tutta la sezione; gli Id delle feature sono nelle proprietà MachineAfterHeadCutId e MachineAfterTailCutId.
 
 -- Tabella per definizione modulo
 local ProcessDrill = {}
@@ -312,8 +310,6 @@ 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
-   local dMaxDepthOri = dMaxDepth
    -- verifico il massimo affondamento
    local dSubL1 = 0
    local dSubL2 = 0
@@ -395,62 +391,18 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId)
       nSCC = MCH_SCC.NONE
    end
    EgtSetMachiningParam( MCH_MP.SCC, nSCC)
-   -- aggiusto affondamento e MaxElev
-   local dMaxElev = dDepth
+   -- aggiusto l'affondamento
    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 > 0 then
-               dMaxElev = dLen - dHoleToCutDistance
-            elseif dHoleToCutDistance < 0 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
+      sMyWarn = 'Warning in drill : depth (' .. EgtNumToString( dDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
+      dDepth = dMaxDepth
+      EgtOutLog( sMyWarn)
    end
    EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
    -- 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) .. ';'
+   sUserNotes = sUserNotes .. 'MaxElev=' .. EgtNumToString( dDepth, 1) .. ';'
    -- se foro passante, aggiungo questa qualifica alle note
    if ( sType == 'Drill' or sType == 'Drill_H2') and  bOpen then
       sUserNotes = sUserNotes .. 'Open=1;'

LuaLibs/ProcessLapJoint.lua

@@ -1,4 +1,4 @@
--- ProcessLapJoint.lua by Egaltech s.r.l. 2022/07/03
+-- ProcessLapJoint.lua by Egaltech s.r.l. 2022/07/05
 -- Gestione calcolo mezzo-legno per Travi
 -- 2019/10/08 Agg. gestione OpenPocket.
 -- 2021/01/24 Con sega a catena ora sempre impostato asse A.
@@ -47,6 +47,7 @@
 -- 2022/06/16 Implemento lavorazioni con fresatura di lato per L30 (al momento solo passanti) se parametro Q03=2. Modificate funzioni Make, MakeMoreFaces, Classify.
 -- 2022/06/21 Implemento di lavorazioni non passanti con fresatura di lato per L30 se parametro Q03=2. Modificate funzioni MakeMoreFaces, Classify.
 -- 2022/06/29 Migliorate lavorazioni con fresatura di lato per L30 se parametro Q03=2. Ora con 4 facce / 3 facce a L può entrare una fresa grande fino al doppio dell'altezza della tasca / doppio della dimensione minima.
+-- 2022/07/05 Modifiche per sega a catena di testa e relativa MaxElev.
 
 -- Tabella per definizione modulo
 local ProcessLapJoint = {}
@@ -694,8 +695,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 non devo ruotare
-      local bForceSideMill = ( Proc.Prc == 30 and EgtGetInfo( Proc.Id, 'Q03', 'd') == 2)
+      -- 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))
       bDown = ( bDown and not BD.DOWN_HEAD and not BD.TURN and not bForceSideMill)
       return true, bDown
    -- se più di 2 facce
@@ -795,8 +796,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 non devo ruotare
-               local bForceSideMill = ( Proc.Prc == 30 and EgtGetInfo( Proc.Id, 'Q03', 'd') == 2 and ( Proc.Fct == 3 or Proc.Fct == 4))
+               -- 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))
                if bForceSideMill then
                   bDown = false 
                elseif nFacInd2 and dElev2 < 2 * dElev then
@@ -2793,14 +2794,15 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
                                  rfFac, dH, dV, dElev, bForceUseBlade, 
                                  dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, 
                                  bOrthoFacesMaster, nBottomFace, nChamfer, nAddGrpId, b3Solid, 
-                                 dDepthCham, nSurfInt, bIs3Faces)
+                                 dDepthCham, nSurfInt)
    local sWarn
    -- ingombro del grezzo
    local b3Raw = EgtGetRawPartBBox( nRawId)
    -- ottengo la distanza tra la fine del pezzo e il pezzo successivo
    local dDistToNextPiece = EgtGetInfo( nRawId, 'BDST', 'd') or 5.4
-   -- verifico e fessura con 3 facce o tunnel
+   -- verifico se fessura con 3 facce o tunnel
    local bOrthoFaces
+   local bIs3Faces = ( Proc.Fct == 3)
    if bIs3Faces then
       -- recupero la faccia con il maggior numero di adiacenze e l'elevazione relativa
       local nFacInd1, dFacElev1, nFacInd2, dFacElev2 = BL.GetFaceWithMostAdj( Proc.Id, nPartId, bIs3Faces)
@@ -3039,14 +3041,14 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
             -- imposto offset radiale
             local dOffs = ( i - 1) * dStep
             EgtSetMachiningParam( MCH_MP.OFFSR, dOffs)
-            -- se necessario, limito l'affondamento
+            -- se necessario, avverto limitazioneo dell'affondamento
             if dElev > dMaxDepth + 10 * GEO.EPS_SMALL then
                sWarn = 'Warning in LapJoint : elevation (' .. EgtNumToString( dElev, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
-               dDepth = dMaxDepth - dElev
                EgtOutLog( sWarn)
-               EgtSetMachiningParam( MCH_MP.DEPTH_STR, 'TH '..EgtNumToString( dDepth, 1))
+               --local dDepth = dMaxDepth - dElev
+               --EgtSetMachiningParam( MCH_MP.DEPTH_STR, 'TH '..EgtNumToString( dDepth, 1))
             end
-            -- imposto elevazione
+            -- imposto massima elevazione
             local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 2) .. ';'
             EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
             -- eseguo
@@ -3071,7 +3073,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
                return false, sWarn
             end
          end
-      -- altrimenti segacatena di fianco 
+      -- altrimenti sega a catena di fianco 
       else
          -- verifico se posso farlo con la sega-catena
          local bMakeChainSaw, sSawing2, dMaxMat2, dSawCornerRad2, dSawThick2 = VerifyChainSaw( Proc, dDimMin, dDimMax)
@@ -3120,7 +3122,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
                   EgtOutLog( sWarn)
                end
                -- considero estremi inizio/fine chiusi
-               -- recupero massima elevazione da utente
+               -- imposto massima elevazione
                local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';'
                EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
                -- eseguo
@@ -4544,8 +4546,8 @@ 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
-      local bForceSideMill = EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'i') == 2 and ( Proc.Fct == 4 or Proc.Fct == 3 or Proc.Fct == 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°
+      local bForceSideMill = ( 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)
       -- 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
@@ -5038,7 +5040,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                                                               rfFac, dH, dV, dFacElev, bForceUseBlade, 
                                                               dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, 
                                                               bOrthoFaces, nBottomFace, nChamfer, nAddGrpId, b3Solid, 
-                                                              dDepthCham, nSurfInt, true)
+                                                              dDepthCham, nSurfInt)
                         if not bOk then
                            -- in base al flag interno e al numero di facce e se ha forma ad U:  provo prima la svuotatura sul fianco e 
                            -- se non è possibile allora provo in seguito con lama o segacatena