- in RidgeLap correzione alla direzione di lavoro cubetti

2.7g1

LuaLibs/BeamLib.lua

@@ -899,6 +899,27 @@ function BeamLib.FindFaceBestOrientedAsAxis( Proc, vtAx, fctExclude)
    return nFaceIndMax, ptC, vtN
 end
 
+---------------------------------------------------------------------
+function BeamLib.GetEdgeToMachineFromVector( nSurfId, nFacet, vtOrtho)
+   local _, EdgesEgt = EgtSurfTmGetFacetOutlineInfo( nSurfId, nFacet, GDB_ID.ROOT)
+
+   local nEdgeIndMax = 0
+   local dMaxComp = - GEO.INFINITO
+   for i = 1, #EdgesEgt do
+      local vtN = EdgesEgt[i].Norm
+      if EdgesEgt[i].Open then
+         vtN = -vtN
+      end
+      local dComp = vtN * vtOrtho
+      if dComp > dMaxComp then
+         nEdgeIndMax = i -1
+         dMaxComp = dComp
+      end
+   end
+
+   return nEdgeIndMax
+end
+
 ---------------------------------------------------------------------
 function BeamLib.GetTunnelDimension( Proc, nPartId)
    -- sono necessarie almeno due facce

LuaLibs/ProcessDtMortise.lua

@@ -104,7 +104,7 @@ function ProcessDtMortise.GetCutPlane( Proc)
 end
 
 ---------------------------------------------------------------------
-local function CalcTopPath( nProcId, AuxId, nAddGrpId, dAltMort, dSideAng, b3Solid)
+local function CalcPathAtHeight( nProcId, AuxId, nAddGrpId, dHeight, dSideAng, b3Solid)
    -- copio la curva di base
    local NewAuxId = EgtCopyGlob( AuxId, nAddGrpId)
    if not NewAuxId then return end
@@ -112,7 +112,7 @@ local function CalcTopPath( nProcId, AuxId, nAddGrpId, dAltMort, dSideAng, b3Sol
    EgtAddCurveCompoLineTg( NewAuxId, 100, false)
    EgtAddCurveCompoLineTg( NewAuxId, 100, true)
    EgtMergeCurvesInCurveCompo( NewAuxId)
-   local dOffset = dAltMort * tan( dSideAng)
+   local dOffset = dHeight * tan( dSideAng)
    if not EgtOffsetCurve( NewAuxId, dOffset) then return end
    -- la limito entro la trave
    local refBox = Frame3d( b3Solid:getMin())
@@ -120,7 +120,7 @@ local function CalcTopPath( nProcId, AuxId, nAddGrpId, dAltMort, dSideAng, b3Sol
    local nCount
    NewAuxId, nCount = EgtTrimFlatCurveWithBox( NewAuxId, refBox, vtBoxDiag, true, true, GDB_RT.GLOB)
    -- eseguo traslazione e offset per portarla sul top
-   local vtMove = EgtCurveExtrusion( AuxId, GDB_RT.GLOB) * ( dAltMort - 10 * GEO.EPS_SMALL)
+   local vtMove = EgtCurveExtrusion( AuxId, GDB_RT.GLOB) * ( dHeight - 10 * GEO.EPS_SMALL)
    EgtMove( NewAuxId, vtMove, GDB_RT.GLOB)
    -- se divisa in più parti, le unisco congiungendole con segmenti
    if nCount > 1 then
@@ -137,6 +137,23 @@ local function CalcTopPath( nProcId, AuxId, nAddGrpId, dAltMort, dSideAng, b3Sol
    return NewAuxId
 end
 
+---------------------------------------------------------------------
+local function GetVerticalSteps( dMachiningDepth, dStep )
+    local MachiningSteps = {}
+    MachiningSteps.StepLength = 0
+    
+    if dMachiningDepth <= 0 then
+        MachiningSteps.Count = 0
+        return MachiningSteps
+    end
+
+    MachiningSteps.Count = ceil( (dMachiningDepth - 10 * GEO.EPS_SMALL) / dStep )
+    
+    MachiningSteps.StepLength = dMachiningDepth / MachiningSteps.Count
+
+    return MachiningSteps
+end
+
 ---------------------------------------------------------------------
 -- verifica che il box includa il punto in XY
 function EnclosesPoint( b3Box, ptP)
@@ -155,6 +172,7 @@ end
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
 function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
+   bMakeAntiSplitPath = true
    -- ingombro del pezzo
    local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
    if not b3Solid then
@@ -289,12 +307,56 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
          bCW = ( dSpeed >= 0)
       end
    end
-   -- verifico che la profondità non superi il massimo materiale dell'utensile
+   local bMultipleZPasses = false
+   -- se necessario, cerco un utensile più lungo
    if dAltMort > dMaxMat + 10 * GEO.EPS_SMALL then
-      local sErr = 'Error : DtMortise Depth bigger than Tool Cutting edge'
-      EgtOutLog( sErr)
-      return false, sErr
+      -- recupero la lavorazione : prima ricerca per sola tipologia
+      sMilling = ML.FindMilling( sMillType..sMchExt, nil, nil, nil, nil, bMillUp, bMillDown, bExcludeH2, nil, 'Longest')
+      if not sMilling and bMillUp then
+         sMilling = ML.FindMilling( sMillType, nil, nil, nil, nil, bMillUp, bMillDown, bExcludeH2, nil, 'Longest')
+      end
+      if not sMilling then
+         local sErr = 'Milling not found in library : Error on DtMortise ' .. tostring( Proc.Id)
+         EgtOutLog( sErr)
+         return false, sErr
+      end
+      -- recupero la lavorazione : seconda ricerca con tipologia e diametro massimo
+      sMilling = ML.FindMilling( sMillType..sMchExt, nil, nil, 2 * dMinRad, nil, bMillUp, bMillDown, bExcludeH2, nil, 'Longest')
+      if not sMilling and bMillUp then
+         sMilling = ML.FindMilling( sMillType, nil, nil, 2 * dMinRad, nil, bMillUp, bMillDown, bExcludeH2, nil, 'Longest')
+         sMchExt = ''
+      end
+      if not sMilling then
+         local sErr = 'Radius too small : Error on DtMortise ' .. tostring( Proc.Id)
+         EgtOutLog( sErr)
+         return false, sErr
+      end
+      if not sMilling then
+         local sErr = 'Error : DtMortise Depth bigger than Tool Cutting edge'
+         EgtOutLog( sErr)
+         return false, sErr
+      end
+      -- riassegno dati utensile
+      dToolDiam = 100
+      dMaxMat = 30
+      dSideAng = 0
+      bCW = true
+      bMillOnAggregate = sMchExt == '_AT'
+      if EgtMdbSetCurrMachining( sMilling) then
+         local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+         if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
+            dToolDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dToolDiam
+            dToolDiam = max( dToolDiam, 10)
+            dMaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) or dMaxMat
+            dSideAng = EgtTdbGetCurrToolParam( MCH_TP.SIDEANG) or dSideAng
+            local dSpeed = EgtMdbGetCurrMachiningParam( MCH_MP.SPEED) or 0
+            bCW = ( dSpeed >= 0)
+         end
+      end
+      
+      bMultipleZPasses = true
    end
+   
 
    -- tastatura se richiesta
    local Info = { vtProbe = vtExtr, ptProbe = ptBC,  sType = 'DTMortise', sHead = sHeadTool}
@@ -382,7 +444,7 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
          return false, sErr
       end
       -- calcolo il percorso top mortise
-      local nAuxId1 = CalcTopPath( Proc.Id, AuxId, nAddGrpId, dAltMort, dSideAng, b3Solid)
+      local nAuxId1 = CalcPathAtHeight( Proc.Id, AuxId, nAddGrpId, dAltMort, dSideAng, b3Solid)
       -- se esiste il percorso
       if nAuxId1 then
          -- creo percorso sulla parte alta della mortasa
@@ -441,6 +503,10 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
             EgtSetMachiningParam( MCH_MP.DEPTH, dAltMort)
             -- setto offset radiale con aggiunto un ulteriore allargamento di 1mm
             EgtSetMachiningParam( MCH_MP.OFFSR, dToolRadDelta - 1)
+            -- antischeggia sempre con una passata
+            if bMultipleZPasses then
+               EgtSetMachiningParam( MCH_MP.STEP, 0)
+            end
             -- sistemo il lato e la direzione di lavoro
             EgtSetMachiningParam( MCH_MP.WORKSIDE, EgtIf( bCW, MCH_MILL_WS.LEFT, MCH_MILL_WS.RIGHT))
             EgtSetMachiningParam( MCH_MP.INVERT, EgtIf( bCW, false, true))
@@ -484,6 +550,23 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
    local nPass = ceil( dDist / ( 1.9 * dToolDiam))
    local dStep = 0
    if nPass > 1 then dStep = max( ( dDist - 2 * dToolDiam) / ( 2 * nPass - 2), 0.25 * dToolDiam) end
+
+   local dVerticalStep = 0
+   if bMultipleZPasses then
+      local dToolVerticalStep = 0
+      if EgtMdbSetCurrMachining( sMilling) then
+         dToolVerticalStep = EgtMdbGetCurrMachiningParam( MCH_MP.STEP) or 0
+      end
+      if dToolVerticalStep < 10 * GEO.EPS_SMALL then
+         dToolVerticalStep = dMaxMat / 3
+      else
+         dToolVerticalStep = min( dToolVerticalStep, dMaxMat / 3)
+      end
+      local VerticalSteps = GetVerticalSteps( dAltMort, dToolVerticalStep)
+      dVerticalStep = VerticalSteps.StepLength
+      nPass = VerticalSteps.Count
+   end
+
    for i = nPass, 1, -1 do
       -- inserisco la lavorazione di contornatura
       local sNameF = 'DtMt_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( nPass)
@@ -494,10 +577,39 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
          return false, sErr
       end
       -- aggiungo geometria
-      EgtSetMachiningGeometry( {{ AuxId, -1}})
+      local GeomId = AuxId
+      if ( i > 1) and bMultipleZPasses then
+         local dCurrentHeight = dAltMort - ( ( nPass - i + 1) * dVerticalStep)
+         -- recupero gruppo per geometria addizionale
+         local nAddGrpId = BL.GetAddGroup( nPartId)
+         if not nAddGrpId then
+            local sErr = 'Error : missing AddGroup'
+            EgtOutLog( sErr)
+            return false, sErr
+         end
+         local b3MortiseNoPocket = EgtGetBBoxGlob( AuxId, GDB_BB.STANDARD)
+         GeomId = CalcPathAtHeight( Proc.Id, AuxId, nAddGrpId, dCurrentHeight, dSideAng, b3MortiseNoPocket)
+         if not GeomId then
+            local sErr = 'Wrong geometry : Error on DtMortise ' .. tostring( Proc.Id)
+            EgtOutLog( sErr)
+            return false, sErr
+         end
+      end
+      EgtSetMachiningGeometry( {{ GeomId, -1}})
       -- imposto offset
       local dOffs = ( i - 1) * dStep
+      if bMultipleZPasses then
+         if i > 1 then
+            dOffs = 1
+         else
+            dOffs = 0
+         end
+      end
       EgtSetMachiningParam( MCH_MP.OFFSR, dOffs)
+      -- in caso di passate in Z già calcolate lo step deve essere nullo per garantire passate singole
+      if bMultipleZPasses then
+         EgtSetMachiningParam( MCH_MP.STEP, 0)
+      end
       -- sistemo il lato e la direzione di lavoro
       EgtSetMachiningParam( MCH_MP.WORKSIDE, EgtIf( bCW, MCH_MILL_WS.LEFT, MCH_MILL_WS.RIGHT))
       EgtSetMachiningParam( MCH_MP.INVERT, EgtIf( bCW, false, true))
@@ -534,7 +646,11 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
          EgtSetMachiningParam( MCH_MP.SCC, nSCC)
       end
       -- dichiaro massima elevazione e assenza sfridi per VMill
-      local sUserNotes = EgtSetVal( 'MaxElev', EgtNumToString( dMaxMat - 0.1, 1)) .. ';' .. EgtSetVal( 'VMRS', 0) .. ';'
+      local dMaxElev = dMaxMat
+      if bMultipleZPasses then
+         dMaxElev = dVerticalStep
+      end
+      local sUserNotes = EgtSetVal( 'MaxElev', EgtNumToString( dMaxElev - 0.1, 1)) .. ';' .. EgtSetVal( 'VMRS', 0) .. ';'
       -- in presenza di pocket dichiaro che non sto entrando e uscendo nel grezzo
       if bPocket then
          sUserNotes = EgtSetValInNotes( sUserNotes, 'OutRaw', 3)

LuaLibs/ProcessDtTenon.lua

@@ -236,11 +236,32 @@ function ProcessDtTenon.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
          bCW = ( dSpeed >= 0)
       end
    end
-   -- verifico che l'altezza non superi il massimo materiale dell'utensile
+   -- se necessario, cerco un utensile più lungo
    if dDtTenH > dMaxMat + 10 * GEO.EPS_SMALL then
-      local sErr = 'Error : DtTenon Height bigger than Tool Cutting edge'
-      EgtOutLog( sErr)
-      return false, sErr
+      sMilling = ML.FindMilling( sMillType .. EgtIf( bMillDown and not bMillUp, '_H2', ''), nil, nil, nil, nil, bMillUp, bMillDown, nil, nil, 'Longest')
+      if not sMilling then
+         local sErr = 'Error : milling not found in library'
+         EgtOutLog( sErr)
+         return false, sErr
+      end
+      if not sMilling then
+         local sErr = 'Error : DtTenon Height bigger than Tool Cutting edge'
+         EgtOutLog( sErr)
+         return false, sErr
+      end
+      -- riassegno dati utensile
+      dTDiam = 50
+      dMaxMat = 30
+      bCW = true
+      if EgtMdbSetCurrMachining( sMilling) then
+         local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+         if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
+            dTDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dTDiam
+            dMaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) or dMaxMat
+            local dSpeed = EgtMdbGetCurrMachiningParam( MCH_MP.SPEED) or 0
+            bCW = ( dSpeed >= 0)
+         end
+      end
    end
    -- calcolo distanza massima della curva dal punto più lontano della base tenone Dt (facet 0)
    local dMaxDist

LuaLibs/ProcessLapJoint.lua

@@ -145,6 +145,7 @@ local Q_BLADE_ON_ALONG_FACE = '' -- i
 local Q_MAX_ELEVATION       = '' -- d
 local Q_SAW_PLUS_CHAIN      = '' -- i
 local Q_FORCE_CHAINSAW      = '' -- i
+local Q_CHAINSAW_FROM_SIDE  = '' -- i
 
 
 -- variabile smussi
@@ -192,7 +193,8 @@ local function AssignQIdent( Proc)
    Q_STAIRCASE          = ''
    Q_SAW_PLUS_CHAIN     = 'Q11'
    Q_FORCE_CHAINSAW     = 'Q12'
-   Q_NO_ROTATION        = 'Q13'
+   -- TODO da riportare a Q13 quando è sistemata la gestione del movimento in macchina nell'attacco laterale
+   Q_CHAINSAW_FROM_SIDE = 'Q999'
 
    if ( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 16 then
       Q_FORCE_BLADE         = 'Q01' -- i
@@ -967,7 +969,7 @@ function ProcessLapJoint.Classify( Proc, b3Raw)
                end
             end
             
-            local bNoRotation = ( EgtGetInfo( Proc.Id, Q_NO_ROTATION, 'i') or 0) == 1
+            local bNoRotation = ( EgtGetInfo( Proc.Id, Q_CHAINSAW_FROM_SIDE, 'i') or 0) == 1
             if bDown and bNoRotation then
                bDown = false
             end
@@ -3094,7 +3096,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
          return false, sErr
       end
       local bGoFromHead = true
-      local bAttackFromSide = ( ( EgtGetInfo( Proc.Id, Q_NO_ROTATION, 'i') or 0) == 1)
+      local bAttackFromSide = ( ( EgtGetInfo( Proc.Id, Q_CHAINSAW_FROM_SIDE, 'i') or 0) == 1)
                               and ( Proc.Fct == 4) and ( Proc.Topology == 'Groove')
       -- se normale lungo Z è da sopra: si tenta attacco laterale se richiesto
       if AreSameOrOppositeVectorApprox( Proc.Face[ nFacInd + 1].VtN, Z_AX()) then
@@ -3211,7 +3213,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
          if vtRef and ( vtRef:getY() > 0.5 or vtRef:getZ() < -0.1) then
             vtRef = -vtRef
          end
-         if not ( Proc.Topology == 'Tunnel') then
+         if bAttackFromSide then
             dDimMin = min( Proc.Face[ nFacInd + 1].Width, Proc.Face[ nFacInd + 1].Height)
             dDimMax = min( Proc.Face[ nFacAdj + 1].Width, Proc.Face[ nFacAdj + 1].Height)
             nLundIdFace = nFacAdj
@@ -3224,6 +3226,8 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
                   vtRef = -Z_AX()
                   nFaceZ = BL.FindFaceBestOrientedAsAxis( Proc, -Z_AX())
                end
+            else
+               nFaceZ = nFacInd
             end
             dDepth = Proc.Face[ nFaceZ + 1].Elevation
          end
@@ -3259,7 +3263,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
                local dOffs = ( i - 1) * dStep
                EgtSetMachiningParam( MCH_MP.OFFSR, dOffs)
                local dMachiningDepth = dDepth
-               if Proc.Topology == 'Tunnel' then
+               if not bAttackFromSide then
                   -- se possibile aumento l'affondamento pari al raggio corner + 1
                   if dMaxMat2 > ( dDepth + dSawCornerRad2 + 1) then
                      dMachiningDepth = ( dDepth + dSawCornerRad2 + 1)
@@ -3284,24 +3288,33 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
                      EgtOutLog( sWarn)
                   end
                   EgtSetMachiningParam( MCH_MP.DEPTH, dMachiningDepth)
-                  local dStartAddLen = dSawWidth / 2 + EgtMdbGetGeneralParam( MCH_GP.SAFEZ) + EgtMdbGetGeneralParam( MCH_GP.SAFEAGGRBOTTZ)
-                  local dEndAddLen = - dSawWidth / 2
-                  if vtRef:getZ() > 10 * GEO.EPS_SMALL then
+                  -- si decidono lato di lavoro, inversione e estensione in base al lato aperto
+                  local nEdgeIndex = BL.GetEdgeToMachineFromVector( Proc.Id, nFacAdj, vtRef)
+                  local EdgesEgt = BL.GetEdgesInfo( Proc, Proc.Face[nFacAdj+1])
+                  local CurrentEdge = EdgesEgt[nEdgeIndex+1]
+                  local dStartAddLen = 0
+                  local dEndAddLen = 0
+                  if CurrentEdge.IsStartOpen then
+                     EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MORTISE_WS.RIGHT)
+                     EgtSetMachiningParam( MCH_MP.INVERT, false)
+                  else
                      EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MORTISE_WS.LEFT)
                      EgtSetMachiningParam( MCH_MP.INVERT, true)
                   end
+                  dStartAddLen = dSawWidth / 2 + EgtMdbGetGeneralParam( MCH_GP.SAFEZ) + EgtMdbGetGeneralParam( MCH_GP.SAFEAGGRBOTTZ)
+                  dEndAddLen = - dSawWidth / 2
                   EgtSetMachiningParam( MCH_MP.STARTADDLEN, dStartAddLen)
                   EgtSetMachiningParam( MCH_MP.ENDADDLEN, dEndAddLen)
                end
                -- in caso di attacco esterno si setta in modo da fare un primo step adeguato per evitare finecorsa
                -- si riduce la feed opportunamente
-               if not ( Proc.Topology == 'Tunnel') then
+               if bAttackFromSide then
                   local dMachiningStep = EgtGetMachiningParam( MCH_MP.STEP) or 0
                   -- TODO qui sostituire con valore preciso da GetSetupInfo
                   if BD.C_SIMM then
-                     dMachiningStep = 165
+                     dMachiningStep = 175
                      if vtRef:getZ() < - 10 * GEO.EPS_SMALL then
-                        dMachiningStep = 250
+                        dMachiningStep = 260
                      end
                   end
                   local dActualStep = ( dMachiningDepth - dMachiningStep) / ( 2 + 1)
@@ -3316,7 +3329,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
                   EgtSetMachiningParam( MCH_MP.FEED, dFeed)
                end
                local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';'
-               if not ( Proc.Topology == 'Tunnel') then
+               if bAttackFromSide then
                   sNotes = EgtSetValInNotes( sNotes, 'Plunge', 10)
                end
                EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)

LuaLibs/ProcessLongDoubleCut.lua

@@ -1432,7 +1432,7 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster
             end
          end
       end
-      if not Proc.bMoveAfterSplit and not bEndFixed and not bConvex then
+      if not Proc.bMoveAfterSplit and not bConvex and Proc.AffectedFaces.Left then
          -- recupero gruppo per geometria addizionale
          local nAddGrpId = BL.GetAddGroup( nPartId)
          if not nAddGrpId then

LuaLibs/ProcessRidgeLap.lua

@@ -176,15 +176,15 @@ function ProcessRidgeLap.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
       local vtRef2 = Vector3d( vtN[vFaceOrd[2]])
       -- eseguo
       for i = 1, #vCuts do
-         local nOrthoOpposite
+         local vtOrtho
          if i % 2 == 1 then
-            nOrthoOpposite = BL.GetNearestOrthoOpposite( vtRef)
+            vtOrtho = vtRef
          else
-            nOrthoOpposite = BL.GetNearestOrthoOpposite( vtRef2)
+            vtOrtho = vtRef2
          end
          -- lavoro la faccia
          for j = 1, #vCuts[i] do
-            local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, nOrthoOpposite, dVzLimDwnUp, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+            local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrtho, dVzLimDwnUp, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
             if not bOk then
                return bOk, sErr
             end

UpdateLog.txt

@@ -1,7 +1,20 @@
            ==== Beam Update Log ====
 
+Versione 2.7g2 (10/07/2025)
+- Fixed : in LapJoint correzione per caso in cui la sega a catena lavorava la tasca in modo errato
+
+Versione 2.7g1 (08/07/2025)
+- Added : in LapJoint, aggiunti smussi anche se lavorazione con truciolatore
+- Added : per profilo caudato aggiunta finitura con fresa piccola
+- Added : gestione tastatura
+- Modif : nei tagli di testa e coda, compresi quelli di spezzatura, la lama evita di arretrare se non necessario
+- Modif : in LongDoubleCut migliorie varie
+- Modif : in RidgeLap migliorie varie
+- Modif : nelle forature che attraversano un taglio ora si considera la profondità già lavorata
+- Fixed : in LongDoubleCut corretta lavorazione aggiunta erroneamente dopo separazione
+
 Versione 2.7f3 (19/06/2025)
-- Modifx : in StepJointNotch corretta distanza attacco in/out
+- Modif : in StepJointNotch corretta distanza attacco in/out
 
 Versione 2.7f2 (18/06/2025)
 - Modif : in LongDoubleCut aggiunto messaggio feature non completa se utensile non arriva sul fondo
@@ -20,10 +33,10 @@ Versione 2.7e2 (23/05/2025)
 - Fixed : in Scarf Joint correzione alla scelta faccia da lavorare
 
 Versione 2.7e1 (05/05/2025)
+- Modif : in LapJoint se tunnel verticale lavorato solo da sopra e l'utensile non arriva, si restituisce warning
 - Fixed : in taglio di separazione si riduce percorso di taglio solo se il pezzo è effettivamente alto
 - Fixed : in foratura corretto caso in cui non si sceglieva l'utensile più lungo disponibile
 - Fixed : In BatchProcess (Ts7) corretta generazione in caso di progetto senza ricalcolo
-- Modif : in LapJoint se tunnel verticale lavorato solo da sopra e l'utensile non arriva, si restituisce warning
 
 Versione 2.7d3 (22/04/2025)
 - Fixed : in LapJoint corretta gestione errata Q04

Version.lua

@@ -2,5 +2,5 @@
 -- Gestione della versione di Beam
 
 NAME = 'Beam'
-VERSION = '2.7f3'
+VERSION = '2.7g2'
 MIN_EXE = '2.7f2'