In DtMortise - Aggiunto parametro Q01=1 per non eseguire l'antischeggia

BatchProcessNew.lua

@@ -277,15 +277,6 @@ if bToProcess then
             else
                vBeam[i].Box = b3Solid
             end
-            if BD.MAX_LENGTH and BD.MAX_LENGTH > 10 and b3Solid:getDimX() > BD.MAX_LENGTH then
-               local sOut = 'Piece-Length ('  .. EgtNumToString( b3Solid:getDimX(), 2) .. ') ' ..
-                         'out of machine limits (' .. EgtNumToString( BD.MAX_LENGTH, 2) .. ') '
-               BEAM.ERR = 17
-               BEAM.MSG = sOut
-               WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
-               PostErrView( BEAM.ERR, BEAM.MSG)
-               return
-            end
          end
          -- Assegno lunghezza della barra
          dBarLen = vBeam[1].Box:getDimX() + 10
@@ -339,15 +330,6 @@ if bToProcess then
          else
             vBeam[i].Box = b3Solid
          end
-         if BD.MAX_LENGTH and BD.MAX_LENGTH > 10 and b3Solid:getDimX() > BD.MAX_LENGTH then
-            local sOut = 'Piece-Length ('  .. EgtNumToString( b3Solid:getDimX(), 2) .. ') ' ..
-                         'out of machine limits (' .. EgtNumToString( BD.MAX_LENGTH, 2) .. ') '
-            BEAM.ERR = 17
-            BEAM.MSG = sOut
-            WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
-            PostErrView( BEAM.ERR, BEAM.MSG)
-            return
-         end
       end
    end
 

LuaLibs/BeamExec.lua

@@ -1641,8 +1641,7 @@ local function SetCutsOnFrontMortises( vProc)
                   -- verifico se i piani coincidono
                   local bSamePlane = ( ptC1 and vtN1 and ptC2 and vtN2 and AreSameVectorApprox( vtN1, vtN2) and ( ptC2 - ptC1) * vtN1 < 1.0)
                   if bSamePlane then
-                     --vProc[i].CutFront = vProc[j].Id
-                     vProc[j].bSkipCut = true
+                     vProc[i].CutFront = vProc[j].Id
                   end
                   -- log
                   local sMsg = string.format( 'Cut %d meet Mortise %d', vProc[i].Id, vProc[j].Id) .. EgtIf( bSamePlane, ' with same plane', '')
@@ -1659,8 +1658,7 @@ local function SetCutsOnFrontMortises( vProc)
                   -- verifico se i piani coincidono
                   local bSamePlane = ( ptC1 and vtN1 and ptC2 and vtN2 and AreSameVectorApprox( vtN1, vtN2) and ( ptC2 - ptC1) * vtN1 < 1.0)
                   if bSamePlane then
-                     --vProc[i].CutFront = vProc[j].Id
-                     vProc[j].bSkipCut = true
+                     vProc[i].CutFront = vProc[j].Id
                   end
                   -- log
                   local sMsg = string.format( 'Cut %d meet DtMortise %d', vProc[i].Id, vProc[j].Id) .. EgtIf( bSamePlane, ' with same plane', '')
@@ -1993,9 +1991,6 @@ local function VerifyDrillMirrored( Proc, vProc, b3Raw)
    end
    local dToolDoubleDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM, 'd')
    local dToolDoubleMaxDepth = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT)
-   if ( sType == 'Pocket_AT' or sType == 'Pocket') then
-      dToolDoubleMaxDepth = EgtTdbGetCurrToolMaxDepth()
-   end
    dMachiningDepth = min( dMachiningDepth, dToolDoubleMaxDepth)
    -- recupero la lunghezza della parte inclinata della punta
    local dToolDoubleTipLength = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) - EgtTdbGetCurrToolParam( MCH_TP.LEN)

LuaLibs/BeamLib.lua

@@ -883,25 +883,6 @@ function BeamLib.GetBlockedAxis( sMachining, sBlockedAxis, b3Raw, vtTool, vtOut)
    return ''
 end
 
----------------------------------------------------------------------
-function BeamLib.GetAuxDir( sMachining, sBlockedAxis, b3Raw, vtTool, vtOut)
-   -- informazioni sull'utensile della lavorazione
-   local nToolType, sHead
-   if EgtMdbSetCurrMachining( sMachining) then
-      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
-      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
-         nToolType = EgtTdbGetCurrToolParam( MCH_TP.TYPE)
-         sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
-      end
-   end
-   -- se presente funzione specifica nella macchina, la richiamo
-   if BD.GetAuxDir then
-      return BD.GetAuxDir( sHead, nToolType, sBlockedAxis, b3Raw, vtTool, vtOut)
-   end
-   -- niente
-   return nil
-end
-
 ---------------------------------------------------------------------
 -- Trova l'Ind (0 based) della faccia meglio orientata come l'asse vtAx. Restituisce anche vtN e ptC della faccia stessa. La faccia di indice (0 based) fctExclude non viene considerata nella ricerca.
 function BeamLib.FindFaceBestOrientedAsAxis( Proc, vtAx, fctExclude)
@@ -1177,31 +1158,6 @@ function BeamLib.Is3EdgesApprox( Proc, nFacet, nAddGrpId)
    return bResult
 end
 
--------------------------------------------------------------------------------------------------------------
-function BeamLib.IsPointOnBoxLimits( ptPoint, b3Solid)
-    local dTol = 500 * GEO.EPS_SMALL
-
-    local dMinX = b3Solid:getMin():getX()
-    local dMinY = b3Solid:getMin():getY()
-    local dMinZ = b3Solid:getMin():getZ()
-
-    local dMaxX = b3Solid:getMax():getX()
-    local dMaxY = b3Solid:getMax():getY()
-    local dMaxZ = b3Solid:getMax():getZ()
-
-    -- Check di ogni piano limite
-    if abs( ptPoint:getX() - dMinX) < dTol then return true, "Left" end
-    if abs( ptPoint:getX() - dMaxX) < dTol then return true, "Right" end
- 
-    if abs( ptPoint:getY() - dMinY) < dTol then return true, "Front" end
-    if abs( ptPoint:getY() - dMaxY) < dTol then return true, "Back" end
- 
-    if abs( ptPoint:getZ() - dMinZ) < dTol then return true, "Bottom" end
-    if abs( ptPoint:getZ() - dMaxZ) < dTol then return true, "Top" end
-
-    return false
-end
-
 -------------------------------------------------------------------------------------------------------------
 -- restituisce le facce della parte interessate dalla feature Proc
 function BeamLib.GetProcessAffectedFaces( Proc)

LuaLibs/FacesBySaw.lua

@@ -170,12 +170,6 @@ function MakeParallelOne( nSurfId, nFacet, sCutting, dSawDiam, nFaceUse, dVzLimD
    end
    local vtOut = EgtIf( vtN:getX() > 0, X_AX(), -X_AX())
    EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( sCutting, 'perpendicular', b3Raw, vtTool, vtOut))
-   local sAuxDir, sInitAngs = BL.GetAuxDir( sCutting, 'perpendicular', b3Raw, vtTool, vtOut)
-   if sAuxDir then
-      sNotes = EgtSetValInNotes( sNotes, 'VtAuxDir', sAuxDir)
-      EgtSetMachiningParam( MCH_MP.INITANGS, sInitAngs)
-      EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.STD)
-   end
    -- eventuali note
    if ( sLeadInOutType == 'PerpendicularOutraw') then
       sNotes = EgtSetValInNotes( sNotes, 'OutRaw', 3)
@@ -457,7 +451,7 @@ function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDw
          -- se distanza al punto è maggiore del raggio lama, significa che non ho già lavorato, quindi calcolo entrata opportunamente
          if dDistPointToCenter > 0.5 * dSawDiam then
             dLiTang = -dAllStart * dCosAlpha
-            dLiPerp = dDist1 * dSinAlpha
+            dLiPerp = dDist1 * dSinAlpha 
          end
       end
       -- se ho accorciato uscita, setto componente tangente e perpendicolare sul percorso di uscita
@@ -637,12 +631,6 @@ function FacesBySaw.MakeOne( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDw
    -- imposto angolo 3° asse rot
    local sBlockedAxis = EgtIf( bMaximizeVerticalDepth, 'parallel', 'perpendicular')
    EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( sCutting, sBlockedAxis, b3Raw, vtN, vtOrthO))
-   local sAuxDir, sInitAngs = BL.GetAuxDir( sCutting, sBlockedAxis, b3Raw, vtN, vtOrthO)
-   if sAuxDir then
-      sNotes = EgtSetValInNotes( sNotes, 'VtAuxDir', sAuxDir)
-      EgtSetMachiningParam( MCH_MP.INITANGS, sInitAngs)
-      EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.STD)
-   end
    -- eventuali note
    if ( sLeadInOutType == 'PerpendicularOutraw') then
       sNotes = EgtSetValInNotes( sNotes, 'OutRaw', 3)

LuaLibs/ProcessCut.lua

@@ -63,7 +63,6 @@ function ProcessCut.Classify( Proc, b3Raw)
    if ( BD.C_SIMM and BD.DOWN_HEAD) or BD.TURN then
       return true
    end
-   local bForceNoBeamRotation = ( EgtGetInfo( Proc.Id, 'Q18', 'i') == 1)
    -- recupero i dati del taglio
    local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
    -- calcolo le massime estensioni lineari orizzontale e verticale della faccia
@@ -74,7 +73,7 @@ function ProcessCut.Classify( Proc, b3Raw)
    then
       -- confronto queste estensioni con la massima dimensione del DiceCut (impossibile lavorare se entrambe maggiori)
       if DimH > BD.MAX_DIM_DICE + 100 * GEO.EPS_SMALL and DimV > BD.MAX_DIM_DICE + 100 * GEO.EPS_SMALL then
-         return true, not bForceNoBeamRotation
+         return true, true
       end
    end
    -- se è un taglio da sotto, lo verifico
@@ -97,7 +96,7 @@ function ProcessCut.Classify( Proc, b3Raw)
       _, DimH, DimV = BL.GetFaceHvRefDim( Proc.Id, 0)
       -- confronto questo ingombro con il doppio della massima dimensione del DiceCut (impossibile lavorare sotto da sopra se più di 2 tagli oppure se tipo PF, taglio inclinato in Y e non taglio singolo orizzontale)
       if DimH > 2 * BD.MAX_DIM_DICE  or ( BD.C_SIMM and ( abs( vtN:getY()) > 0.1) and dMaxMat < DimH + BD.CUT_EXTRA) then
-         return true, not bForceNoBeamRotation
+         return true, true
       end
    end
    return true, false
@@ -479,16 +478,12 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
          -- determino il modo di tagliare
          local vtOrthoO
          local bNoPerpCuts = false
-         local vtO
-         -- Se tagli ortogonali (indice dispari)
          if i % 2 == 1 then
             vtOrthoO = Vector3d( vtN)
-         -- Se tagli perpendicolari (indice pari)
          else
-            -- Se elemento precedente contiene tagli ortogonali
+            local vtO
             if #vCuts[i-1] > 0 then
                vtO = EgtSurfTmFacetNormVersor( vCuts[i-1][1], 0, GDB_ID.ROOT)
-            -- Se elemento successivo contiene tagli ortogonali
             elseif vCuts[i+1] and #vCuts[i+1] > 0 then
                -- lunghezza faccia nell'eventuale direzione ortogonale
                local asseX = EgtSurfTmFacetNormVersor( vCuts[i+1][1], 0, GDB_ID.ROOT)
@@ -556,51 +551,8 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
             end
             local bOk2, sErr2 = Fbs.MakeOne( nSurfToCut, 0, sCutting, dSawDiam, nFaceUseCut2, nil, dCutExtra, BD.CUT_SIC, 0, 0, 0, '', b3Raw)
             if not bOk2 then return false, sErr2 end
-
          -- caso standard
          else
-            -- se necessario aggiungo tagli obliqui per cubettare pezzi lunghi che potrebbero cadere sul motore
-            if ( i % 2) == 0 and Proc.Fct == 1 and AreSameOrOppositeVectorApprox( vtO, Z_AX()) then
-               local vtOrthoVert = vtN ^ vtO
-               -- inverte direzione superfici per corretta direzione SCC
-               if ( vtN:getY() > 0 and vtOrthoVert:getY() > 0) or ( vtN:getY() < 0 and vtOrthoVert:getY() < 0) then
-                  vtOrthoVert = -vtOrthoVert
-               end
-               local Frame = Frame3d( ptC, vtN, vtO)
-               local b3Fac = EgtGetBBoxRef( vCuts[i][1], GDB_BB.STANDARD, Frame)
-               -- se cubetto più grande di MAX_DIM_DICE
-               if abs( b3Fac:getDimY() - BD.MAX_DIM_DICE) > 10 * GEO.EPS_SMALL then
-                  local nVerticalCuts = ceil( b3Fac:getDimY() / ( BD.MAX_LEN_DICE)) - 1
-                  local dVerticalSliceDist = b3Fac:getDimY() / ( nVerticalCuts + 1)
-                  -- selezione utensile
-                  local dSawDiam = 400
-                  if EgtMdbSetCurrMachining( sCutting) then
-                     local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
-                     if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
-                        dSawDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam
-                     end
-                  end
-                  -- crea faccia per tagli verticali e le taglia a dimensione corretta
-                  for k = 1, nVerticalCuts do
-                     local nFaceUse = BL.GetNearestOrthoOpposite( vtN)
-                     local dVerticalCutOffset = dVerticalSliceDist * k
-                     local sLeadInOutType = 'Perpendicular'
-                     local nMergedParallelSurfId = EgtSurfTmBySewing( nAddGrpId, vCuts[i], false)
-                     local ptVertCut = EgtSurfTmFacetCenter( nMergedParallelSurfId, 0, GDB_ID.ROOT)
-                     ptVertCut = ptVertCut + ( -b3Fac:getDimY()/2 + dVerticalCutOffset) * vtOrthoVert
-                     local nSurfId = EgtSurfTmPlaneInBBox( nAddGrpId, ptVertCut, vtOrthoVert, b3Raw, GDB_RT.GLOB)
-                     -- se non è il primo taglio parallelo taglia anche le superfici con la faccia parallela precedente
-                     if i ~= 2 then
-                        local nMergedPreviousParallelSurfId = EgtSurfTmBySewing( nAddGrpId, vCuts[i-2], false)
-                        local ptOnPreviousParallelSurf = EgtSurfTmFacetCenter( nMergedPreviousParallelSurfId, 0, GDB_ID.ROOT)
-                        EgtCutSurfTmPlane( nSurfId, ptOnPreviousParallelSurf, vtN, false, GDB_RT.GLOB)
-                     end
-                     EgtCutSurfTmPlane( nSurfId, ptVertCut, -vtN, false, GDB_RT.GLOB)
-                     local bOk, sErr = Fbs.MakeOne( nSurfId, 0, sCutting, dSawDiam, nFaceUse, nil, -0.1, BD.CUT_SIC, 0, 0, 0, '', b3Raw, nil, nil, nil, sLeadInOutType, nil, 0, nil)
-                     if not bOk then return bOk, sErr end
-                  end
-               end
-            end
             -- lavoro la faccia
             for j = 1, #vCuts[i] do
                -- se taglio dal basso

LuaLibs/ProcessDrill.lua

@@ -594,10 +594,8 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
          local dHoleToCutDistance = vDistance[1]
          -- se il taglio accorcia realmente il foro
          if ( dHoleToCutDistance > 10 * GEO.EPS_SMALL or Proc.AffectedFaces.Right) and dHoleToCutDistance < dLen then
-            local dToolTipFromCenterDrill = ( ( dDiam / 2) - ( dToolDiam / 2))
-            local dExtraSicDistFromThToTiltedCut = sqrt( ( dToolTipFromCenterDrill / CosB)^2 - dToolTipFromCenterDrill^2) + sqrt( ( ( dDiamTh / 2) / CosB)^2 - (dDiamTh / 2)^2)
             dMaxDepth = dMaxDepthOri
-            dMaxElev = dLen - ( dHoleToCutDistance - dExtraSicDistFromThToTiltedCut)
+            dMaxElev = dLen - dHoleToCutDistance
             bTryDrill = true
             local dToolAddLength = dLen - dMaxElev
             -- se l'utensile è comunque troppo corto lavoro il massimo possibile
@@ -615,7 +613,6 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
          end
       end
    end
-   local dDepthOri = dDepth
    -- se foro da saltare per eccessiva inclinazione
    if not bTryDrill then
       sMyWarn = 'Warning in drill : too slant hole'
@@ -657,9 +654,6 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
             local dReduceDepth = MIRROR_POCKETS_MIN_DISTANCE / 2 + 10
             dLastStepDepth = dDepth + dReduceDepth
             dDepth = dDepth - dReduceDepth
-            if ( dLastStepDepth > dMaxDepth + 10 * GEO.EPS_SMALL) and ( dMaxDepth <= ( dLen / 2) - dReduceDepth) and ( dDepthOri ~= dDepth) then
-               dDepth = dMaxDepth
-            end
          end
       else
          sUserNotes = EgtSetValInNotes( sUserNotes, 'LastStep', MIRROR_DRILLINGS_MIN_DISTANCE / 2 + 15)
@@ -724,12 +718,12 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
       else
          -- se DrillPocket passante in doppio si fa lavorazione aggiuntiva dell'ultimo step
          if Proc.Double and Proc.Double > 0 and ( sType == 'Pocket_AT' or sType == 'Pocket') and bOpen then
-            if dLastStepDepth > dMaxDepth + 10 * GEO.EPS_SMALL then
-               sMyWarn = 'Warning in drill pocket last step: depth (' .. EgtNumToString( dLastStepDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
-               return false, sMyWarn
-            end
             local idMachiningLastStep = EgtCopyMachining( EgtIf( EgtStartsWith( sType, 'Predrill'), 'Predrill_', 'Drill_') .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)), sName)
             EgtSetCurrMachining( idMachiningLastStep)
+            if dLastStepDepth  > dMaxDepth + 10 * GEO.EPS_SMALL then
+               sMyWarn = 'Warning in drill pocket last step: depth (' .. EgtNumToString( dLastStepDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
+               dLastStepDepth = dMaxDepth
+            end
             local dMaxElevLastStep = dLastStepDepth - dDepth
             sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dMaxElevLastStep, 1))
             EgtSetMachiningParam( MCH_MP.DEPTH, dLastStepDepth)

LuaLibs/ProcessDtMortise.lua

@@ -229,14 +229,14 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
    end
    local b3DtMrt = EgtGetBBoxRef( Proc.Id, GDB_BB.STANDARD, rfDtMrt)
    local dAltMort = b3DtMrt:getDimZ()
-   -- verifico se di tipo pocket o se antischeggia disabilitato
+   -- verifico se di tipo pocket
    local bPocket = ( EgtGetInfo( Proc.Id, 'P05', 'i') == 1)
-   local bDisableAntiSplint = ( EgtGetInfo( Proc.Id, 'Q01', 'i') or 0) == 1
-   if bPocket or bDisableAntiSplint then bMakeAntiSplitPath = false end
+   local dForcePrecutBypass = EgtGetInfo( Proc.Id, 'Q01', 'i')
+   if bPocket or dForcePrecutBypass == 1 then bMakeAntiSplitPath = false end
    -- verifico se frontale
    local bFront = ( Proc.Prc == 56)
    -- se mortasa di fronte, eseguo il taglio della faccia
-   if bFront and not Proc.bSkipCut then
+   if bFront then
       -- verifico esista la faccia di taglio
       local ptCutC, vtCutN = EgtSurfTmFacetCenter( Proc.Id, 1, GDB_ID.ROOT)
       if ptCutC and vtCutN and AreSameVectorApprox( vtExtr, vtCutN) then
@@ -362,7 +362,7 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
       dMaxMat = 30
       dSideAng = 0
       bCW = true
-      bMillOnAggregate = ( sMchExt == '_AT')
+      bMillOnAggregate = sMchExt == '_AT'
       if EgtMdbSetCurrMachining( sMilling) then
          local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
          if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
@@ -424,16 +424,8 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
       end
       -- aggiungo geometria
       EgtSetMachiningGeometry( {{ Aux2Id, -1}})
-      -- recupero note utente per aggiornarle
-      local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) or ''
-      -- eventuali impostazioni per 3° asse rot
-      local sAuxDir, sInitAngs = BL.GetAuxDir( sPocketing, "", b3Solid, vtExtr, vtExtr)
-      if sAuxDir then
-         sUserNotes = EgtSetValInNotes( sUserNotes, 'VtAuxDir', sAuxDir)
-         EgtSetMachiningParam( MCH_MP.INITANGS, sInitAngs)
-         EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.STD)
-      end
       -- dichiaro non si generano sfridi per VMill
+      local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) or ''
       sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dMaxMat - 0.1, 1))
       sUserNotes = EgtSetValInNotes( sUserNotes, 'VMRS', 0)
       EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
@@ -545,16 +537,8 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
                if nSCC then 
                   EgtSetMachiningParam( MCH_MP.SCC, nSCC)
                end
-               -- recupero note utente per aggiornarle
-               local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) or ''
-               -- eventuali impostazioni per 3° asse rot
-               local sAuxDir, sInitAngs = BL.GetAuxDir( sMilling, "", b3Solid, vtExtr, vtExtr)
-               if sAuxDir then
-                  sUserNotes = EgtSetValInNotes( sUserNotes, 'VtAuxDir', sAuxDir)
-                  EgtSetMachiningParam( MCH_MP.INITANGS, sInitAngs)
-                  EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.STD)
-               end
                -- dichiaro non si generano sfridi per VMill
+               local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) or ''
                sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dAltMort, 1))
                sUserNotes = EgtSetValInNotes( sUserNotes, 'VMRS', 0)
                -- se lavorazione in doppio
@@ -713,20 +697,12 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
       if nSCC then
          EgtSetMachiningParam( MCH_MP.SCC, nSCC)
       end
-      -- recupero note utente per aggiornarle
-      local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) or ''
-      -- eventuali impostazioni per 3° asse rot
-      local sAuxDir, sInitAngs = BL.GetAuxDir( sMilling, "", b3Solid, vtExtr, vtExtr)
-      if sAuxDir then
-         sUserNotes = EgtSetValInNotes( sUserNotes, 'VtAuxDir', sAuxDir)
-         EgtSetMachiningParam( MCH_MP.INITANGS, sInitAngs)
-         EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.STD)
-      end
       -- dichiaro massima elevazione e assenza sfridi per VMill
       local dMaxElev = dMaxMat
       if bMultipleZPasses then
          dMaxElev = dVerticalStep
       end
+      local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) or ''
       sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dMaxElev - 0.1, 1))
       sUserNotes = EgtSetValInNotes( sUserNotes, 'VMRS', 0)
       -- in presenza di pocket dichiaro che non sto entrando e uscendo nel grezzo

LuaLibs/ProcessHeadCut.lua

@@ -162,11 +162,10 @@ end
 ---------------------------------------------------------------------
 -- smussi in testa
 local function MakeHeadChamfer( idProc, nPartId)
-   
    local dDepthHeadChamfer = EgtGetInfo( idProc, 'Q08', 'd') or 0
    -- se non attivo esco subito
    if dDepthHeadChamfer < 100 * GEO.EPS_SMALL then
-      return true, nil
+      return
    end
 
    -- recupero gruppo per geometria aggiuntiva
@@ -255,8 +254,7 @@ local function MakeHeadChamfer( idProc, nPartId)
    EgtSetMachiningParam( MCH_MP.DEPTH, dDepthHeadChamfer + dExtra)
    EgtSetMachiningParam( MCH_MP.OFFSR, dExtra)
    -- assegno lato di lavoro
-   EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
-   EgtSetMachiningParam( MCH_MP.INVERT, true)
+   EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
    -- eseguo
    if not ML.ApplyMachining( true, false) then
       local _, sErr = EgtGetLastMachMgrError()
@@ -641,12 +639,11 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
    
    local bOk, sErr = MakeStandardCuts( Proc, b3Raw, nCuts, dOffsL, HeadCutType, Cutting1Data, Cutting2Data, nil, dOvmHead)
 
+
    -- alla fine del taglio si aggiungono gli smussi in testa
    local _, sErrHeadChamfer = MakeHeadChamfer( nOriId or Proc.Id, nPartId)
    if sErr then
-      if sErrHeadChamfer then
-         sErr = sErr..'\n'..sErrHeadChamfer
-      end
+      sErr = sErr..'\n'..sErrHeadChamfer
    else
       sErr = sErrHeadChamfer
    end

LuaLibs/ProcessLapJoint.lua

@@ -2099,27 +2099,6 @@ local function MakeRoundCleanCornerOrContour( Proc, nPhase, nRawId, nPartId, b3R
    end
 end
 
----------------------------------------------------------------------
-local function CalcInterference( nNewProc, vtExtr, ptCentr, ToolData)
-   -- controllo collisione tagliente - finito
-   local ptCentrGrid1 = ptCentr + ( vtExtr * ( 10 * GEO.EPS_SMALL))
-   local frOriTool = Frame3d( ptCentrGrid1, vtExtr)
-   local bColl1 = EgtTestConeSurface( frOriTool, ToolData.dToolDiam/2, ToolData.dToolTotDiam/2, ToolData.dCutEdgeLen, nNewProc, 0, GDB_RT.GLOB)
-   if bColl1 then return true end
-   -- controllo collisione gambo - finito
-   local ptCentrGrid2 = ptCentr + ( vtExtr * ToolData.dCutEdgeLen)
-   frOriTool = Frame3d( ptCentrGrid2, vtExtr)
-   local bColl2 = EgtTestCylSurface( frOriTool, ( ToolData.dStemDiameter + ( 10 * GEO.EPS_SMALL)) / 2, ToolData.dStemLen, nNewProc, 0, GDB_RT.GLOB)
-   if bColl2 then return true end
-   -- controllo collisione TH - finito
-   local ptCentrGrid3 = ptCentr + ( vtExtr * ( ToolData.dCutEdgeLen + ToolData.dStemLen))
-   frOriTool = Frame3d( ptCentrGrid3, vtExtr)
-   local bColl3 = EgtTestCylSurface( frOriTool, ToolData.dDiamTh/2, ToolData.dLenTh, nNewProc, 0, GDB_RT.GLOB)
-   if bColl3 then return true end
-   -- restituisco risultato controllo collisioni
-   return false
-end
-
 ---------------------------------------------------------------------
 local function MakeSharpCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, nAddGrpId, dDiam)
 
@@ -2132,43 +2111,6 @@ local function MakeSharpCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacI
    local sMilling
    local dMaxDepth = 0
 
-   -- recupero la lavorazione non calcolando l'elevazione
-   sMilling = ML.FindMilling( 'CleanCorner', ( 0.5 * dDiam))
-   if not sMilling then
-      local sErr = 'Error : CleanCorner not found in library'
-      EgtOutLog( sErr)
-      return false, sErr
-   end
-
-   -- recupero i dati dell'utensile
-   local ToolData = {
-      dToolTotDiam = 20,
-      dToolDiam = 20,
-      dSideAng = 0,
-      dCutEdgeLen = 20,
-      dToolLength = 20,
-      dStemDiameter = 20,
-      dStemLen = 20,
-      dDiamTh = 20,
-      dLenTh = 20
-   }
-   if EgtMdbSetCurrMachining( sMilling) then
-      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
-      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
-         ToolData.dToolTotDiam = EgtTdbGetCurrToolParam( MCH_TP.TOTDIAM) or ToolData.dToolTotDiam
-         ToolData.dToolDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or ToolData.dToolDiam
-         ToolData.dSideAng = EgtTdbGetCurrToolParam( MCH_TP.SIDEANG) or ToolData.dSideAng
-         ToolData.dCutEdgeLen = abs( EgtTdbGetCurrToolParam( MCH_TP.THICK)) or ToolData.dCutEdgeLen
-         ToolData.dToolLength = EgtTdbGetCurrToolParam( MCH_TP.LEN) or ToolData.dToolLength
-         ToolData.dStemDiameter = EgtTdbGetCurrToolParam( MCH_TP.STEMDIAM) or ToolData.dStemDiameter
-         ToolData.dDiamTh = EgtTdbGetCurrToolThDiam() or ToolData.dDiamTh
-         ToolData.dLenTh = EgtTdbGetCurrToolThLength() or ToolData.dLenTh
-         -- calcolo il secondo diametro del cono
-         ToolData.dToolTotDiam = ToolData.dToolDiam + ( abs( ToolData.dCutEdgeLen) * tan( ToolData.dSideAng)) * 2
-         ToolData.dStemLen = ToolData.dToolLength - ToolData.dCutEdgeLen - ToolData.dLenTh
-      end
-   end
-
    -- cerco l'angolo di riferimento dove applicare il percorso di pulitura, altrimenti esco
    local _, nIdLine, tFacAdj = ChooseCorner( Proc, nFacInd)
    if #tFacAdj == 0 then
@@ -2194,8 +2136,6 @@ local function MakeSharpCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacI
    -- versore direzione
    local vtExtr = tFacAdj[nIdLine][nIdIniPoint] - tFacAdj[nIdLine][nIdEndPoint]
    vtExtr:normalize()
-   -- versore direzione di uscita
-   local vtExtrExit
    -- inserisco le prime tre linee
    if nIdIniPoint and nIdEndPoint then
       -- se fresatura da sotto salto la lavorazione
@@ -2204,24 +2144,16 @@ local function MakeSharpCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacI
          EgtOutLog( sErr)
          return false, sErr
       end
-      -- sommo i tre versori per avere una direzione media
-      vtExtrExit = vtN2 + vtN3
-      vtExtrExit:normalize()
-      -- calcolo la componente Z dipendente dall'angolo tilt
-      local dAlfa = EgtClamp( ToolData.dSideAng, 15, 30)
-      local dGamma = 90 - asin( sqrt( 2) * sin( dAlfa))
-      local dTanGamma = sin( dGamma) / cos( dGamma)
-      vtExtr = vtExtrExit + ( vtN2 ^ vtN3) * dTanGamma
+      -- sommo i tre versori per avre una direzione media
+      vtExtr = vtN1 + vtN2 + vtN3
       vtExtr:normalize()
-      local vtCheck = Vector3d(vtExtr)
-      
-      -- controllo se c'è collisione con le facce della superfice
-      if CalcInterference( Proc.Id, vtCheck, tFacAdj[nIdLine][nIdEndPoint], ToolData) then
-         local sErr = 'Collision detected between clean corner tool and surface'
+      -- recupero la lavorazione non calcolando l'elevazione
+      sMilling = ML.FindMilling( 'CleanCorner', ( 0.5 * dDiam))
+      if not sMilling then
+         local sErr = 'Error : CleanCorner not found in library'
          EgtOutLog( sErr)
-         return true, ''
+         return false, sErr
       end
-      
       -- recupero i dati dell'utensile ( temporaneo, per compensare errore nella lavorazione)
       if EgtMdbSetCurrMachining( sMilling) then
          local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
@@ -3476,9 +3408,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
             bGoFromHead = false
          -- continuo di testa se fessura con tre facce o non è tunnel
          else
-            bGoFromHead = (( bIs3Faces and ( dMaxElev 
-                           or ( Proc.Topology == 'Groove' and Proc.IsThrough and (Proc.AffectedFaces.Left or Proc.AffectedFaces.Right) and not Proc.IsParallel))) 
-                           or not bOrthoFaces)
+            bGoFromHead = (( bIs3Faces and dMaxElev) or not bOrthoFaces)
          end
       end
       -- se continuo a lavorare di testa
@@ -3543,35 +3473,17 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
             -- imposto offset radiale
             local dOffs = ( i - 1) * dStep
             EgtSetMachiningParam( MCH_MP.OFFSR, dOffs)
-            local bElevAdj
-            local dToolEntryAngle, _, _, dTanToolEntryAngle = GetToolEntryAngle( Proc, rfFac:getVersZ())
             -- se necessario, avverto limitazione dell'affondamento
-            if dElev > dMaxDepth + 10 * GEO.EPS_SMALL then
-               if Proc.Fct == 3 and Proc.Topology == 'Groove' and Proc.IsThrough and (Proc.AffectedFaces.Left or Proc.AffectedFaces.Right) and not Proc.IsParallel then
-                  local Edges = BL.GetEdgesInfo( Proc, Proc.Face[nFacAdj+1])
-                  local dWorkEdgeWidth
-                  for i = 1, #Edges do 
-                     if Edges[i].AdjacentFaceId == nFacInd then
-                        dWorkEdgeWidth = Edges[i].Length
-                        break
-                     end
-                  end
-                  local dDeltaDepth = dWorkEdgeWidth * cos( dToolEntryAngle)
-                  bElevAdj = true
-                  EgtSetMachiningParam( MCH_MP.DEPTH, dMaxDepth - dDeltaDepth)
-               else
-                  EgtSetMachiningParam( MCH_MP.DEPTH, dMaxDepth)
-                  sWarn = 'Warning in LapJoint : elevation (' .. EgtNumToString( dElev, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
-                  EgtOutLog( sWarn)
-               end
-               
+               if dElev > dMaxDepth + 10 * GEO.EPS_SMALL then
+               EgtSetMachiningParam( MCH_MP.DEPTH, dMaxDepth)
+               sWarn = 'Warning in LapJoint : elevation (' .. EgtNumToString( dElev, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
+               EgtOutLog( sWarn)
                --local dDepth = dMaxDepth - dElev
                --EgtSetMachiningParam( MCH_MP.DEPTH_STR, 'TH '..EgtNumToString( dDepth, 1))
             end
             -- imposto massima elevazione
             local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) or ''
-            local dElevAdj = EgtIf( bElevAdj, dElev / sin( dToolEntryAngle), dElev)
-            sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dElevAdj, 2))
+            sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dElev, 2))
             EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
             -- eseguo
             if not ML.ApplyMachining( true, false) then
@@ -4800,16 +4712,6 @@ local function ManageAntiSplintBySaw( Proc, b3Raw, b3Solid, bIsU, vtN, nFacInd,
          local dSawThick = 0
          local dMaxDepth = 200
          local bAdj, dAng, dExtraOffs, sWarn2, nIdMach
-         -- Se faccia sulla quale cerca di applicare l'antisplint è chiusa e limitata da altre facce non lo applica
-         local FacetEdge = BL.GetEdgesInfo( Proc, Proc.Face[nFacet+1])
-         for nEdge = 1, #FacetEdge do
-            if AreSameVectorApprox( FacetEdge[nEdge].ToolDirection, vtN) and ( not FacetEdge[nEdge].IsStartOpen or not FacetEdge[nEdge].IsEndOpen) and not FacetEdge[nEdge].IsOpen then
-               sWarn2 = 'Warning : antisplint not applicable on closed face'
-               if not sWarn then sWarn = '' end
-               sWarn = EgtIf( #sWarn > 0, sWarn .. '\n' .. sWarn2, sWarn2)
-               return bMadeASbyBld, true, sWarn
-            end
-         end
          bMadeASbyBld, sWarn2, nIdMach, dSawThick, dMaxDepth, bAdj, dAng, dExtraOffs = MakeAntiSplintBySaw( Proc, nFacet, vtN, b3Raw, nFacInd, bReduceDepth, bMillDown)
          if not bMadeASbyBld then return bMadeASbyBld, false, sWarn2 end
          if sWarn2 then
@@ -4901,7 +4803,7 @@ local function ManageAntiSplintBySaw( Proc, b3Raw, b3Solid, bIsU, vtN, nFacInd,
 end
 
 ---------------------------------------------------------------------
-local function MakePathsOnExtremePoints( nAddGrpId, nIdPath, pPaths, dTDiam, b3Solid)
+local function MakePathsOnExtremPoints( nAddGrpId, nIdPath, pPaths, dTDiam)
 
    local dLength = 2
    if not nIdPath then return pPaths end
@@ -4917,20 +4819,15 @@ local function MakePathsOnExtremePoints( nAddGrpId, nIdPath, pPaths, dTDiam, b3S
    local vtIni = EgtSV( nIdPath, GDB_RT.GLOB)
    local vtEnd = EgtEV( nIdPath, GDB_RT.GLOB)
 
-   -- si costruisce il percorso solo per i punti sui bordi del grezzo
-   if BL.IsPointOnBoxLimits( ptIni, b3Solid) then
-      local ptIniP = ptIni
-      local ptEndP = ptIniP + (vtIni * dLength)
-      local nAuxId = EgtLine( nAddGrpId, ptIniP, ptEndP, GDB_RT.GLOB)
-      table.insert( pPaths, { nAuxId, 1, ptIniP})
-   end
+   local ptIniP = ptIni
+   local ptEndP = ptIniP + (vtIni * dLength)
+   local nAuxId = EgtLine( nAddGrpId, ptIniP, ptEndP, GDB_RT.GLOB)
+   table.insert( pPaths, { nAuxId, 1, ptIniP})
 
-   if BL.IsPointOnBoxLimits( ptEnd, b3Solid) then
-      local ptIniP = ptEnd
-      local ptEndP = ptEnd - ( vtEnd * dLength)
-      local nAuxId = EgtLine( nAddGrpId, ptIniP, ptEndP, GDB_RT.GLOB)
-      table.insert( pPaths, { nAuxId, 2, ptIniP})
-   end
+   ptIniP = ptEnd
+   ptEndP = ptEnd - ( vtEnd * dLength)
+   nAuxId = EgtLine( nAddGrpId, ptIniP, ptEndP, GDB_RT.GLOB)
+   table.insert( pPaths, { nAuxId, 2, ptIniP})
 
    return pPaths
 end
@@ -5184,7 +5081,7 @@ local function ManageAntiSplintByMill( Proc, nPhase, nRawId, nPartId, b3Raw,
             -- creo percorsi antisplint dagli estremi dei percorsi di contorno trovati
             for i = 1, nNumId do
                local nIdPath = nFirstId + i - 1
-               pPaths = MakePathsOnExtremePoints( nAddGrpId, nIdPath, pPaths, dTDiam, b3Solid)
+               pPaths = MakePathsOnExtremPoints( nAddGrpId, nIdPath, pPaths, dTDiam)
             end
          end
       -- alrimenti ho la faccia aggiunta
@@ -5219,7 +5116,7 @@ local function ManageAntiSplintByMill( Proc, nPhase, nRawId, nPartId, b3Raw,
          -- se non ho un percorso chiuso estraggo i percorsi
          if bOpenPath then
             -- creo percorsi antisplint dagli estremi dei percorsi di contorno trovati
-            pPaths = MakePathsOnExtremePoints( nAddGrpId, nFirstId, pPaths, dTDiam, b3Solid)
+            pPaths = MakePathsOnExtremPoints( nAddGrpId, nFirstId, pPaths, dTDiam)
          end
          EgtErase(nFirstId)
       end
@@ -6361,6 +6258,24 @@ local function ReorderFacesFromTab( nIdSurf, vFace)
    return nIdSurf
 end
 
+---------------------------------------------------------------------
+local function CalcInterference( nNewProc, vtExtr, ptCentr, dDiam1, dDiam2,
+                                 dTall1, dTall2, dDiam3, dTall3)
+   local ptCentrGrid1 = ptCentr + ( vtExtr * 0.01)
+   local frOriTool = Frame3d( ptCentrGrid1, vtExtr)
+   local bColl1 = EgtTestConeSurface( frOriTool, dDiam1/2, dDiam2/2, dTall1, nNewProc, 0, GDB_RT.GLOB)
+   if bColl1 then return true end
+   local ptCentrGrid2 = ptCentr + ( vtExtr * ( dTall1 + 0.01))
+   frOriTool = Frame3d( ptCentrGrid2, vtExtr)
+   local bColl2 = EgtTestCylSurface( frOriTool, dDiam2/2, dTall2, nNewProc, 0, GDB_RT.GLOB)
+   if bColl2 then return true end
+   local ptCentrGrid3 = ptCentr + ( vtExtr * ( dTall2 + 0.01))
+   frOriTool = Frame3d( ptCentrGrid3, vtExtr)
+   local bColl3 = EgtTestCylSurface( frOriTool, dDiam3/2, dTall3, nNewProc, 0, GDB_RT.GLOB)
+   if bColl3 then return true end
+   -- restituisco risultato controllo collisioni
+   return false
+end
 
 ---------------------------------------------------------------------
 local function MakeLocalSurf( ptP1, ptP2, ptP3, nAddGrpId)
@@ -6391,7 +6306,8 @@ end
 ---------------------------------------------------------------------
 local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nAddGrpId,
                                        dToolDiam, sMilling, dOffsAng,
-                                       ToolData, bMakeLocSurf, vFace, vtN)
+                                       dDiam1, dDiam2, dTall1,
+                                       dTall2, dDiam3, dTall3, bMakeLocSurf, vFace, vtN)
 
    -- variabili costruzione geometria
    local pAuxId = {}
@@ -6471,7 +6387,8 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nAdd
          vtCheck:rotate( vtN, dOffsAng)
       end
       -- controllo se c'è collisione con le facce della superfice
-      if CalcInterference( nNewProc.Id, vtCheck, tFacAdj[nIdEndPoint], ToolData) then
+      if CalcInterference( nNewProc.Id, vtCheck, tFacAdj[nIdEndPoint], dDiam1, dDiam2,
+                                                 dTall1, dTall2, dDiam3, dTall3) then
          local sErr = 'Collision detect from clean corner tool and surface'
          EgtOutLog( sErr)
          return true, ''
@@ -6619,39 +6536,32 @@ local function AddMillCorner( vFace, Proc, dToolDiam, nAddGrpId, nMasterNewProc,
    -- se ripresa angolo con fresa cono 60° con ripresa
 
    -- recupero la lavorazione di fresatura
-   sMilling, dMaxDepth = ML.FindMilling( 'CleanCorner')
+   sMilling, dMaxDepth = ML.FindMilling( 'CleanCorner60')
    if not sMilling then
-      local sErr = 'Error : CleanCorner not found in library'
+      local sErr = 'Error : CleanCorner 60 not found in library'
       EgtOutLog( sErr)
       return false, sErr
    end
 
    -- recupero i dati dell'utensile
-   local ToolData = {
-      dToolTotDiam = 20,
-      dToolDiam = 20,
-      dSideAng = 0,
-      dCutEdgeLen = 20,
-      dToolLength = 20,
-      dStemDiameter = 20,
-      dStemLen = 20,
-      dDiamTh = 20,
-      dLenTh = 20
-   }
+   local dMillDiam = 20
+   local dMillTotDiam = 20
+   local dMillDiamTh = 20
+   local dToolLength = 20
+   local dThickTool = 20
+   local dSideAng = 0
    if EgtMdbSetCurrMachining( sMilling) then
       local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
       if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
-         ToolData.dToolTotDiam = EgtTdbGetCurrToolParam( MCH_TP.TOTDIAM) or ToolData.dToolTotDiam
-         ToolData.dToolDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or ToolData.dToolDiam
-         ToolData.dSideAng = EgtTdbGetCurrToolParam( MCH_TP.SIDEANG) or ToolData.dSideAng
-         ToolData.dCutEdgeLen = abs( EgtTdbGetCurrToolParam( MCH_TP.THICK)) or ToolData.dCutEdgeLen
-         ToolData.dToolLength = EgtTdbGetCurrToolParam( MCH_TP.LEN) or ToolData.dToolLength
-         ToolData.dStemDiameter = EgtTdbGetCurrToolParam( MCH_TP.STEMDIAM) or ToolData.dStemDiameter
-         ToolData.dDiamTh = EgtTdbGetCurrToolThDiam() or ToolData.dDiamTh
-         ToolData.dLenTh = EgtTdbGetCurrToolThLength() or ToolData.dLenTh
+         dMillDiamTh = EgtTdbGetCurrToolThDiam() or dMillDiamTh
+         dMillTotDiam = EgtTdbGetCurrToolParam( MCH_TP.TOTDIAM) or dMillTotDiam
+         dSideAng = EgtTdbGetCurrToolParam( MCH_TP.SIDEANG) or dSideAng
+         dMillDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dMillDiam
+         dThickTool = EgtTdbGetCurrToolParam( MCH_TP.THICK) or dThickTool
+         dToolLength = EgtTdbGetCurrToolParam( MCH_TP.LEN) or dToolLength
+         dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth    -- qui è la distanza dal portautensile
          -- calcolo il secondo diametro del cono
-         ToolData.dToolTotDiam = ToolData.dToolDiam + ( abs( ToolData.dCutEdgeLen) * tan( ToolData.dSideAng)) * 2
-         ToolData.dStemLen = ToolData.dToolLength - ToolData.dCutEdgeLen - ToolData.dLenTh
+         dMillTotDiam = dMillDiam + ( abs(dThickTool) * tan(dSideAng)) * 2
       end
    end
    -- copio la feature nel layer di appoggio
@@ -6729,18 +6639,21 @@ local function AddMillCorner( vFace, Proc, dToolDiam, nAddGrpId, nMasterNewProc,
                -- primo taglio
                local bOk, sErr = AddMillCornerMachining( Proc.PartId, nNewProc, nFacInd, tFacAdj, nAddGrpId, 
                                                          dToolDiam, sMilling, -dAngOffs,
-                                                         ToolData, bMakeLocSurf, vFace, vtN)
+                                                         dMillDiam, dMillTotDiam, abs( dThickTool),
+                                                         dMaxDepth, dMillDiamTh, dToolLength, bMakeLocSurf, vFace, vtN)
                if not bOk then return bOk, sErr end
                -- secondo taglio
                bOk, sErr = AddMillCornerMachining( Proc.PartId, nNewProc, nFacInd, tFacAdj, nAddGrpId, 
                                                    dToolDiam, sMilling, dAngOffs,
-                                                   ToolData, bMakeLocSurf, vFace, vtN)
+                                                   dMillDiam, dMillTotDiam, abs( dThickTool),
+                                                   dMaxDepth, dMillDiamTh, dToolLength, bMakeLocSurf, vFace, vtN)
                if not bOk then return bOk, sErr end
             -- altrimenti ho un solo percorso
             else
                local bOk, sErr = AddMillCornerMachining( Proc.PartId, nNewProc, nFacInd, tFacAdj, nAddGrpId, 
                                                          dToolDiam, sMilling, 0,
-                                                         ToolData, bMakeLocSurf, vFace, vtN)
+                                                         dMillDiam, dMillTotDiam, abs( dThickTool),
+                                                         dMaxDepth, dMillDiamTh, dToolLength, bMakeLocSurf, vFace, vtN)
                if not bOk then return bOk, sErr end
             end
          end
@@ -8964,7 +8877,7 @@ function ProcessLapJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
             return Fbp.Make( Proc, Proc.Id, 0, sPocketing, nPartId, b3Solid)
          -- altrimenti, con lama
          else
-            return Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
+            return Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, nil, nil, nil, nil, nil, nil, true)
          end
       -- due facce
       elseif Proc.Fct == 2 then

LuaLibs/ProcessMortise.lua

@@ -32,7 +32,7 @@ local BD = require( 'BeamData')
 local ML = require( 'MachiningLib')
 
 -- variabili assegnazione parametri Q
-local Q_DEPTH_CHAMFER = 'Q01' -- d
+local Q_DEPTH_CHAMFER = 'Q02' -- d
 
 ---------------------------------------------------------------------
 -- Riconoscimento della feature
@@ -467,7 +467,7 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
    end
 
    -- se mortasa di fronte, eseguo il taglio della faccia
-   if bFront and not Proc.bSkipCut then
+   if bFront then
       -- verifico esista la faccia di taglio
       local ptCutC, vtCutN = EgtSurfTmFacetCenter( Proc.Id, 1, GDB_ID.ROOT)
       if ptCutC and vtCutN and AreSameVectorApprox( vtExtr, vtCutN) then

LuaLibs/ProcessSplit.lua

@@ -258,8 +258,7 @@ local function MakeTailChamfer( idProc, nPartId, dDepthTailChamfer)
    EgtSetMachiningParam( MCH_MP.DEPTH, dDepthTailChamfer + dExtra)
    EgtSetMachiningParam( MCH_MP.OFFSR, dExtra)
    -- assegno lato di lavoro
-   EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
-   EgtSetMachiningParam( MCH_MP.INVERT, true)
+   EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
    -- eseguo
    if not ML.ApplyMachining( true, false) then
       local _, sErr = EgtGetLastMachMgrError()

Process.lua

@@ -89,14 +89,6 @@ local function MyProcessInputData()
       else
          vBeam[i].Box = b3Solid
       end
-      if BD.MAX_LENGTH and BD.MAX_LENGTH > 10 and b3Solid:getDimX() > BD.MAX_LENGTH then
-         local sOut = 'Lunghezza ('  .. EgtNumToString( b3Solid:getDimX(), 2) .. ') ' ..
-                      'oltre i limiti della macchina (' .. EgtNumToString( BD.MAX_LENGTH, 2) .. ') '
-         EgtOutLog( sOut)
-         EgtOutBox( sOut, 'Lavora Travi', 'WARNING')
-         EgtDraw()
-         return false
-      end
    end
    dRawW = vBeam[1].Box:getDimY()
    dRawH = vBeam[1].Box:getDimZ()

UpdateLog.txt

@@ -1,23 +1,4 @@
            ==== Beam Update Log ====
-
-Versione 3.1f1 (17/06/2026)
-- Added : Tagli per dividere il cubetto in caso sia troppo lungo
-- Modif : DepthChamfer su feature Mortase (050 e 051) cambio di Q. Prima era Q02, ora è Q01
-
-Versione 3.1e2 (01/06/2026)
-- Added : in Cut aggiunta Q18 per evitare di ruotare
-- Modif : gli smussi di testa sono in senso orario
-- Modif : in mortasa coda di rondine piccole correzioni
-
-Versione 3.1e1 (05/05/2026)
-- Modif : in LapJoint migliorate slot con sega a catena
-- Fixed : in DrillPocket in doppio eliminata lavorazione aggiuntiva in caso di utensile non abbastanza lungo
-
-Versione 3.1d2 (10/04/2026)
-- Added : in StepJoint aggiunto Q02=1 per forzare fresa
-- Added : in DtMortise aggiunto Q01=1 per disabilitare antischeggia
-- Fixed : in LapJoint correzione a antischeggia con fresa in caso di feature spezzata
-
 Versione 3.1d1 (08/04/2026)
 - Added : le forature vengono accorciate con massima elevazione anche in presenza di tagli di testa
 - Modif : nelle slot con lama verticali si lavora sempre in concordanza

Version.lua

@@ -1,6 +1,6 @@
--- Version.lua by Egaltech s.r.l. 2026/05/31
+-- Version.lua by Egaltech s.r.l. 2026/02/09
 -- Gestione della versione di Beam
 
 NAME = 'Beam'
-VERSION = '3.1f1'
+VERSION = '3.1d1'
 MIN_EXE = '3.1b1'