Merge branch 'release/2.5i1'

- correzioni per pulizia corner in FreeContour.

GetWallData.lua

@@ -43,6 +43,7 @@ GWD.NESTING_CORNER = WD.NESTING_CORNER
 GWD.HOR_DRILL_DIAM = WD.HOR_DRILL_DIAM
 GWD.MIN_HEIGHT = WD.MIN_HEIGHT
 GWD.MAX_HEIGHT = WD.MAX_HEIGHT
+GWD.BTL_PRIORITY = WD.BTL_PRIORITY
 
 -- Tutto ok
 GWD.ERR = 0

LuaLibs/WMachiningLib.lua

@@ -3,6 +3,7 @@
 -- 2023/03/09 Piccola correzione alla SideDepth in FindMilling
 --            In FindMilling aggiunta gestione spessore e massimo materiale nel caso di lam
 -- 2023/05/25 Aggiunta funzione AddMachining che incapsula EgtAddMachining trascrivendo le priorità btl dalle feature alle lavorazioni.
+-- 2023/06/07 Alla funzione AddMachining aggiunta la scrittura dell'info ISOUTLINE alle lavorazioni.
 
 -- Tabella per definizione modulo
 local WMachiningLib = {}
@@ -181,12 +182,15 @@ function WMachiningLib.FindSurfacing( sType)
    end
 end
 
--- incapsulo EgtAddMachining e trascrivo le priorità all'interno delle note della lavorazione
+-- incapsulo EgtAddMachining e trascrivo alcune informazioni utili nelle note dell'operazione
 ---------------------------------------------------------------------
-function WMachiningLib.AddMachining( nProcId, sName, sMachining)
+function WMachiningLib.AddMachining( Proc, sName, sMachining)
    local nMchId, sFinalName = EgtAddMachining( sName, sMachining)
-   local nPriority = EgtGetInfo( nProcId, 'PRIORITY', 'i')
-   EgtSetInfo( nMchId, 'PRIORITY', nPriority)
+   if type(Proc) == 'table' then
+      local nPriority = EgtGetInfo( Proc.Id or GDB_ID.NULL, 'PRIORITY', 'i')
+      EgtSetInfo( nMchId or GDB_ID.NULL, 'PRIORITY', nPriority)
+      EgtSetInfo( nMchId or GDB_ID.NULL, 'ISOUTLINE', Proc.IsOutline)
+   end
    return nMchId, sFinalName
 end
 

LuaLibs/WProcessCut.lua

@@ -1,5 +1,6 @@
 -- WProcessCut.lua by Egaltech s.r.l. 2020/11/25
 -- Gestione calcolo taglio di testa o longitudinale per Pareti
+-- 2023/07/26 Angolo Z minimo ora gestito tramite costante da WallData CUT_VZ_MIN (default sempre -0.5).
 
 -- Tabella per definizione modulo
 local WPC = {}
@@ -31,7 +32,7 @@ function WPC.Classify( Proc, b3Raw)
    if Proc.Fct ~= 1 then return false end
    -- controllo la normale
    local vtN = EgtSurfTmFacetNormVersor( Proc.Id, 0, GDB_ID.ROOT)
-   if vtN:getZ() < - 0.5 then return false end
+   if vtN:getZ() < ( WD.CUT_VZ_MIN or - 0.5) then return false end
    return true
 end
 
@@ -40,29 +41,29 @@ end
 -- return nFlip0, nFlip1
 function WPC.FlipClassify( Proc)
    -- verifico abbia una sola faccia
-   if Proc.Fct ~= 1 then return 0, 0 end 
+   if Proc.Fct ~= 1 then return 0, 0 end
    -- controllo la normale
    local vtN = EgtSurfTmFacetNormVersor( Proc.Id, 0, GDB_ID.ROOT)
    local vtNZ = vtN:getZ()
    if vtNZ > - GEO.EPS_SMALL then
       nFlip0 = 100
-   elseif vtNZ < -0.5 then 
+   elseif vtNZ < ( WD.CUT_VZ_MIN or - 0.5) then
       nFlip0 = 0
    else
-      nFlip0 = 50 
-   end 
+      nFlip0 = 50
+   end
    
    if - vtNZ > - GEO.EPS_SMALL then
       nFlip1 = 100
-   elseif - vtNZ < -0.5 then 
+   elseif - vtNZ < ( WD.CUT_VZ_MIN or - 0.5) then
       nFlip1 = 0
    else
       nFlip1 = 50
-   end    
+   end
    
    --nFlip0 = EgtIf( vtN:getZ() < -0.5, 0, 100) 
    --nFlip1 = EgtIf( - vtN:getZ() < -0.5, 0, 100) 
-   return nFlip0, nFlip1 
+   return nFlip0, nFlip1
 end
 
 ---------------------------------------------------------------------

LuaLibs/WProcessDrill.lua

@@ -376,7 +376,7 @@ function WPD.Make( Proc, nRawId, b3Raw)
    end
    -- inserisco la lavorazione
    local sName = EgtIf( sHead == 'H5' or sHead == 'H6', 'LhDrill_', 'Drill_') .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-   local nMchId = WM.AddMachining( Proc.Id, sName, sDrilling)
+   local nMchId = WM.AddMachining( Proc, sName, sDrilling)
    if not nMchId then
       local sErr = 'Error adding machining ' .. sName .. '-' .. sDrilling
       EgtOutLog( sErr)
@@ -506,7 +506,7 @@ function WPD.Make( Proc, nRawId, b3Raw)
       
       -- inserisco la lavorazione
       local sName = 'PreDrill_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-      local nMchId = WM.AddMachining( Proc.Id, sName, sDrilling)
+      local nMchId = WM.AddMachining( Proc, sName, sDrilling)
       if not nMchId then
          local sErr = 'Error adding machining ' .. sName .. '-' .. sDrilling
          EgtOutLog( sErr)

LuaLibs/WProcessDtMortise.lua

@@ -160,7 +160,7 @@ function WPDM.Make( Proc, nRawId, b3Raw)
       end
       -- inserisco la lavorazione di svuotatura
       local sName = 'DtMtPck_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-      local nMchFId = WM.AddMachining( Proc.Id, sName, sPocketing)
+      local nMchFId = WM.AddMachining( Proc, sName, sPocketing)
       if not nMchFId then
          local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing
          EgtOutLog( sErr)
@@ -190,7 +190,7 @@ function WPDM.Make( Proc, nRawId, b3Raw)
    for i = nPass, 1, -1 do
       -- inserisco la lavorazione di contornatura
       local sNameF = 'DtMt_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( nPass)
-      local nMchFId = WM.AddMachining( Proc.Id, sNameF, sMilling)
+      local nMchFId = WM.AddMachining( Proc, sNameF, sMilling)
       if not nMchFId then
          local sErr = 'Error adding machining ' .. sNameF .. '-' .. sMilling
          EgtOutLog( sErr)

LuaLibs/WProcessFreeContour.lua

@@ -1,4 +1,4 @@
--- ProcessFreeContour.lua by Egaltech s.r.l. 2023/04/17
+-- ProcessFreeContour.lua by Egaltech s.r.l. 2023/09/12
 -- Gestione calcolo profilo libero per Pareti
 -- 2021/11/15 Penna e chiodature sono sempre riportate sulla faccia sopra anche se nel progetto sono sotto.
 -- 2021/12/10 In taglio con lama aggiunta gestione SCC per testa Gearbox.
@@ -20,6 +20,8 @@
 -- 2023/04/17 Lavorazione CleanCorner sempre forzata con lato di lavoro in centro.
 -- 2023/05/25 Funzioni EgtAddMachining sostituite da WM.AddMachining in modo da trascrivere le priorità da btl alle lavorazioni.
 -- 2023/06/06 Aggiunta gestione lavorazione per lamatura speciale affondata con Tool_ID specifico.
+-- 2023/07/26 In MakeByCut migliorata la scelta della fresa secondaria nel caso non sia disponibile una fresa di lunghezza sufficiente.
+-- 2023/09/12 Modifiche a GetTunnelDimension (asse deve essere com Z globale) e MakeLocalSurf per gestire finestre con lati inclinati.
 
 -- Tabella per definizione modulo
 local WPF = {}
@@ -544,86 +546,62 @@ end
 
 ---------------------------------------------------------------------
 local function GetTunnelDimension( nId, nPartId, nAddGrpId)
-   -- ottengo i versori delle 4 facce e ottengo l'orientamento del tunnel
-   -- recupero il numero di facce
+   -- sono necessarie almeno 2 facce
    local nFacCnt = EgtSurfTmFacetCount( nId)
    if nFacCnt < 2 then return end
-   -- recupero l'ingombro della trave
+   -- recupero l'ingombro del pezzo
    local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
-   -- variabili dimensioni fessura e id faccia lunga
-   local dDimMin
-   local dDimMax
-   local nLongIdFace = 0
-   local bNegFace
-   local bOppoFace = false
-   -- ottengo il versore ortogonale
-   local ptN1, vtN1 = EgtSurfTmFacetCenter( nId, 0, GDB_ID.ROOT)
-   local vtN2 = EgtSurfTmFacetNormVersor( nId, 1, GDB_ID.ROOT)
-   local vtOrtho = vtN1 ^ vtN2
-   if vtOrtho:isSmall() then
-      vtN2 = EgtSurfTmFacetNormVersor( nId, 2, GDB_ID.ROOT) or V_NULL()
-      vtOrtho = vtN1 ^ vtN2
-      bOppoFace = true
+   -- recupero centro e normale delle facce
+   local ptC = {}
+   local vtN = {}
+   for i = 1, nFacCnt do
+      ptC[i], vtN[i] = EgtSurfTmFacetCenter( nId, i - 1, GDB_ID.ROOT)
    end
-   if not vtOrtho:normalize() then return end
-   if vtOrtho:getZ() < -0.5 then 
-      vtOrtho = -vtOrtho
-      bNegFace = true
+   -- determino l'asse medio (le facce sono già ordinate consecutivamente)
+   local vtAx = V_NULL()
+   for i = 1, nFacCnt do
+      local j = i % nFacCnt + 1
+      local vtOrtho = vtN[i] ^ vtN[j]
+      if vtOrtho:normalize() then
+         vtAx = vtAx + vtOrtho
+      end
    end
-   -- ottengo il boundingBox e prendo le dimensioni lungo la normale (Z locale) che rappresenta la profondità della fessura
-   local frFc = Frame3d( ptN1, vtOrtho) ;
-   local bBoxLoc = EgtGetBBoxRef( nId, GDB_BB.STANDARD, frFc)
-   local dDepth = bBoxLoc:getDimZ()
-   -- mi assicuro che la Z del punto utilizzato per creare la superficie sia alla Z inferiore del bounding box locale
-   local ptN2 = Point3d(ptN1)
-   ptN2:toLoc(frFc)
-   ptN2 = Point3d( ptN2:getX(), ptN2:getY(), bBoxLoc:getMin():getZ() + 2*GEO.EPS_SMALL)
-   ptN2:toGlob(frFc)
-   -- creo superficie intermedia
-   local nSurfInt = EgtSurfTmPlaneInBBox( nAddGrpId, ptN2, vtOrtho, b3Solid, GDB_ID.ROOT)
+   if not vtAx:normalize() or abs( vtAx:getZ()) < 0.5 then return end
+   -- impongo come asse Z globale
+   vtAx = Z_AX()
+   -- recupero ingombro del tunnel nel riferimento globale
+   local b3Box = EgtGetBBoxGlob( nId, GDB_BB.STANDARD)
+   local dDepth = b3Box:getDimZ()
+   -- creo faccia in basso (di poco sollevata)
+   local nSurfInt = EgtSurfTmPlaneInBBox( nAddGrpId, b3Box:getMin() + 2 * GEO.EPS_SMALL * vtAx, vtAx, b3Solid, GDB_ID.ROOT)
    if not nSurfInt then return end
    -- ritaglio la superficie con le facce della fessura
    for i = 1, nFacCnt do
       local ptN, vtN = EgtSurfTmFacetCenter( nId, i - 1, GDB_ID.ROOT)
       EgtCutSurfTmPlane( nSurfInt, ptN, -vtN, false, GDB_ID.ROOT)
    end
-   -- sposto la geometria trovata sulla Z minima (era su di 2 * GEO.EPS_SMALL)
-   EgtMove( nSurfInt, Point3d(0,0,-2*GEO.EPS_SMALL) - ORIG(), GDB_RT.GLOB)
+   -- sposto la geometria trovata sulla Z minima del pezzo
+   EgtMove( nSurfInt, -2 * GEO.EPS_SMALL * vtAx, GDB_RT.GLOB)
    -- mi faccio dare il contorno della superfice e la ricreo in modo più corretto
    local nIdCont, nIdNum = EgtExtractSurfTmLoops( nSurfInt, nAddGrpId)
    if not nIdCont then return end
    -- elimino le entità allineate dello stesso tipo
-   EgtMergeCurvesInCurveCompo( nIdCont, 2*GEO.EPS_SMALL)
-   EgtErase(nSurfInt)
-   nSurfInt = EgtSurfTmByFlatContour( nAddGrpId, nIdCont, 2*GEO.EPS_SMALL)
-   -- elimino il contorno
+   EgtMergeCurvesInCurveCompo( nIdCont, 2 * GEO.EPS_SMALL)
+   EgtErase( nSurfInt)
+   nSurfInt = EgtSurfTmByFlatContour( nAddGrpId, nIdCont, 2 * GEO.EPS_SMALL)
    EgtErase(nIdCont)
-   -- se normale negativa inverto
-   _, vtN1 = EgtSurfTmFacetCenter( nSurfInt, 0, GDB_ID.ROOT)
-   if vtN1:getZ() < -0.5 then EgtInvertSurf( nSurfInt) end
-   local _, DimH, DimV = EgtSurfTmFacetMinAreaRectangle( nSurfInt, 0, GDB_ID.ROOT)
-   dDimMin = min( DimH, DimV)
-   dDimMax = max( DimH, DimV)
-   _, DimH, DimV = EgtSurfTmFacetMinAreaRectangle( nId, nFacCnt-1, GDB_ID.ROOT)
-   -- se faccia pari alla larghezza fessura
-   if abs(DimH - dDimMax) < GEO.EPS_SMALL or abs(DimV - dDimMax) < GEO.EPS_SMALL then
-      nLongIdFace = nFacCnt-1
-   -- altrimenti verifico anche con la faccia precedente
-   else
-      local nFaceToCheck = EgtIf( bOppoFace, nFacCnt-3, nFacCnt-2)
-      -- prendo le dimensioni della faccia e poi confronto con il minimo
-      _, DimH, DimV = EgtSurfTmFacetMinAreaRectangle( nId, nFaceToCheck, GDB_ID.ROOT)
-      -- se trovato con il minimo, questa seconda faccia non è la più lunga
-      if abs(DimH - dDimMin) < GEO.EPS_SMALL or abs(DimV - dDimMin) < GEO.EPS_SMALL then
-         nLongIdFace = nFacCnt-1
-      else
-         nLongIdFace = nFaceToCheck
+   -- ne recupero le dimensioni
+   local _, dDimMax, dDimMin = EgtSurfTmFacetMinAreaRectangle( nSurfInt, 0, GDB_ID.ROOT)
+   -- cerco faccia del contorno con lunghezza vicino alla massima
+   local nLongIdFace
+   for i = 1, nFacCnt do
+      local _, DimH, DimV = EgtSurfTmFacetMinAreaRectangle( nId, i - 1, GDB_ID.ROOT)
+      if DimH > dDimMax - 100 * GEO.EPS_SMALL then
+         nLongIdFace = i - 1
+         break
       end
    end
-   if not dDimMax then
-      return dDimMin, dDimMax, dDepth, nil, nil
-   end
-   return dDimMin, dDimMax, dDepth, vtOrtho, nLongIdFace, nSurfInt
+   return dDimMin, dDimMax, dDepth, vtAx, nLongIdFace, nSurfInt
 end
 
 ---------------------------------------------------------------------
@@ -789,40 +767,28 @@ end
 
 ---------------------------------------------------------------------
 local function MakeLocalSurf( ptP1, ptP2, ptP3, nAddGrpId)
-
+   -- verifico che i tre punti siano definiti
    if not ptP1 or not ptP2 or not ptP3 then
       return nil
    end
-
-   local pAuxId = {}
-   local nAuxId, AuxId
-   nAuxId = EgtLine( nAddGrpId, ptP1, ptP2, GDB_RT.GLOB)
-   table.insert( pAuxId, nAuxId)
-   nAuxId = EgtLine( nAddGrpId, ptP2, ptP3, GDB_RT.GLOB)
-   table.insert( pAuxId, nAuxId)
-   nAuxId = EgtLine( nAddGrpId, ptP3, ptP1, GDB_RT.GLOB)
-   table.insert( pAuxId, nAuxId)
-   -- trasformo in percorso
-   if #pAuxId ~= 3 then
+   -- creo il contorno
+   local nLoopId = EgtCurveCompoFromPoints( nAddGrpId, { ptP1, ptP2, ptP3, ptP1}, GDB_RT.GLOB)
+   if not nLoopId then
       return nil
    end
-   AuxId = EgtCurveCompo( nAddGrpId, pAuxId, true)
-   -- se non c'é il percorso esco
-   if not AuxId then
-      return nil
-   end
-   -- creo la superfice piana
-   local nidFace = EgtSurfTmByFlatContour( nAddGrpId, AuxId, 0.01)
-   if not nidFace then
-      EgtErase(AuxId)
+   -- creo la superfice triangolare (quindi piana)
+   local nFaceId = EgtSurfTmByFlatContour( nAddGrpId, nLoopId, 0.01)
+   EgtErase( nLoopId)
+   if not nFaceId then
       return nil
    end
    -- se normale negativa inverto
-   local _, vtN1 = EgtSurfTmFacetCenter( nidFace, 0, GDB_ID.ROOT)
-   if vtN1:getZ() < -0.5 then EgtInvertSurf( nidFace) end
+   local vtN1 = EgtSurfTmFacetNormVersor( nFaceId, 0, GDB_ID.ROOT)
+   if vtN1:getZ() < -0.01 then
+      EgtInvertSurf( nFaceId)
+   end
 
-   EgtErase(AuxId)
-   return nidFace
+   return nFaceId
 end
 
 ---------------------------------------------------------------------
@@ -839,7 +805,7 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
    -- se devo creare superfice locale
    if bMakeLocSurf then
       -- creo superfice locale o esco
-      local nSurfToAdd = MakeLocalSurf( tFacAdj[1][7], tFacAdj[1][8], tFacAdj[1][9], nAddGrpId)
+      local nSurfToAdd = MakeLocalSurf( tFacAdj[7], tFacAdj[8], tFacAdj[9], nAddGrpId)
       if nSurfToAdd then
          local nFacCntPre = EgtSurfTmFacetCount( nNewProc)
          -- creo copia del percorso principale e gli aggiungo la nuova faccia
@@ -858,28 +824,31 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
    end
    -- prendo il primo versore
    local _, vtN1 = EgtSurfTmFacetCenter( nNewProcLoc, nFacInd, GDB_ID.ROOT)
-   local _, vtN2 = EgtSurfTmFacetCenter( nNewProcLoc, tFacAdj[1][1], GDB_ID.ROOT)
-   local _, vtN3 = EgtSurfTmFacetCenter( nNewProcLoc, tFacAdj[1][2], GDB_ID.ROOT)
+   local _, vtN2 = EgtSurfTmFacetCenter( nNewProcLoc, tFacAdj[1], GDB_ID.ROOT)
+   local _, vtN3 = EgtSurfTmFacetCenter( nNewProcLoc, tFacAdj[2], GDB_ID.ROOT)
    -- trovo il punto sulla superfice di riferimento
-   local _, ptLocP1, ptLocP2, _ = EgtSurfTmFacetsContact( nNewProcLoc, nFacInd, tFacAdj[1][1], GDB_ID.ROOT)
-   local _, ptLocP3, ptLocP4, _ = EgtSurfTmFacetsContact( nNewProcLoc, nFacInd, tFacAdj[1][2], GDB_ID.ROOT)
+   local _, ptLocP1, ptLocP2, _ = EgtSurfTmFacetsContact( nNewProcLoc, nFacInd, tFacAdj[1], GDB_ID.ROOT)
+   local _, ptLocP3, ptLocP4, _ = EgtSurfTmFacetsContact( nNewProcLoc, nFacInd, tFacAdj[2], GDB_ID.ROOT)
    -- se ho creato faccia locale su copia superficie, cancella la copia
    if bMakeLocSurf then
       EgtErase( nNewProcLoc)
    end
+   if not ptLocP1 or not ptLocP2 then
+      return false, 'Error : clean corner with non adjacent faces'
+   end
    local nIdIniPoint
    local nIdEndPoint
    if ptLocP1 and ptLocP2 then
-      if ( dist( ptLocP1, tFacAdj[1][4]) < GEO.EPS_SMALL) or ( dist( ptLocP2, tFacAdj[1][4]) < GEO.EPS_SMALL) then
+      if ( dist( ptLocP1, tFacAdj[4]) < GEO.EPS_SMALL) or ( dist( ptLocP2, tFacAdj[4]) < GEO.EPS_SMALL) then
          nIdEndPoint = 4
          nIdIniPoint = 5
-      elseif ( dist( ptLocP1, tFacAdj[1][5]) < GEO.EPS_SMALL) or ( dist( ptLocP2, tFacAdj[1][5]) < GEO.EPS_SMALL) then
+      elseif ( dist( ptLocP1, tFacAdj[5]) < GEO.EPS_SMALL) or ( dist( ptLocP2, tFacAdj[5]) < GEO.EPS_SMALL) then
          nIdEndPoint = 5
          nIdIniPoint = 4
       end
    end
    -- versore direzione
-   local vtExtr = tFacAdj[1][nIdIniPoint] - tFacAdj[1][nIdEndPoint]
+   local vtExtr = tFacAdj[nIdIniPoint] - tFacAdj[nIdEndPoint]
    vtExtr:normalize()
    -- versore direzione di uscita
    local vtExtrExit
@@ -908,44 +877,44 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
          vtCheck:rotate( Z_AX(), dOffsAng)
       end
       -- controllo se c'è collisione con le facce della superfice
-      if nTypeConeCut == 1 and CalcInterference( nNewProc, vtCheck, tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), dDiam1, dDiam2,
+      if nTypeConeCut == 1 and CalcInterference( nNewProc, vtCheck, tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), dDiam1, dDiam2,
                                                  dTall1, dTall2, dDiam3, dTall3) then
          local sErr = 'Collision detect from clean corner tool and surface'
          EgtOutLog( sErr)
          return true, ''
       end
-      nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdIniPoint], tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
+      nAuxId = EgtLine( nAddGrpId, tFacAdj[nIdIniPoint], tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
       table.insert( pAuxId, nAuxId)
       -- se uso utensile cono 60°
       if nTypeConeCut == 1 then
          -- se offset angolare valido e/o negativo creo il baffo precedente
          if dOffsAng < ( 100 * GEO.EPS_SMALL) then
             -- se il punto finale corrisponde con il punto utilizzato in precedenza, uso l'altro
-            if dist( tFacAdj[1][nIdEndPoint], ptLocP1) < 10 * GEO.EPS_SMALL then
+            if dist( tFacAdj[nIdEndPoint], ptLocP1) < 10 * GEO.EPS_SMALL then
                ptApPoint = ptLocP2
             else
                ptApPoint = ptLocP1
             end
-            nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
-            local dLenTrimExt = dist( tFacAdj[1][nIdEndPoint], ptApPoint) - (( dToolDiam/2) + 0.2)
+            nAuxId = EgtLine( nAddGrpId, tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
+            local dLenTrimExt = dist( tFacAdj[nIdEndPoint], ptApPoint) - (( dToolDiam/2) + 0.2)
             -- se la distanza dei due punti della linea è maggiore dal raggio fresa + delta, trimmo al raggio fresa + delta
             if dLenTrimExt > 10 * GEO.EPS_SMALL then
                EgtTrimExtendCurveByLen( nAuxId , -dLenTrimExt, ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
                -- se ho l'offset angolare ruoto la linea per compensare la rotazione che verrà applicata
                if abs(dOffsAng) > 100 * GEO.EPS_SMALL then
-                  EgtRotate( nAuxId, tFacAdj[1][nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
+                  EgtRotate( nAuxId, tFacAdj[nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
                end
                -- prendo il nuovo punto finale
                ptApPoint = EgtEP( nAuxId, GDB_RT.GLOB) + Point3d( 0, 0, dDepthMach)
             else
                -- se ho l'offset angolare ruoto la linea per compensare la rotazione che verrà applicata
                if abs(dOffsAng) > 100 * GEO.EPS_SMALL then
-                  EgtRotate( nAuxId, tFacAdj[1][nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
+                  EgtRotate( nAuxId, tFacAdj[nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
                end
             end
             table.insert( pAuxId, nAuxId)
             -- creo linea di ritorno
-            nAuxId = EgtLine( nAddGrpId, ptApPoint + Point3d( 0, 0, -dDepthMach), tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
+            nAuxId = EgtLine( nAddGrpId, ptApPoint + Point3d( 0, 0, -dDepthMach), tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
             table.insert( pAuxId, nAuxId)
          end
       end
@@ -955,7 +924,7 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
    ptLocP1, ptLocP2 = ptLocP3, ptLocP4
    if ptLocP1 and ptLocP2 then
       -- se il punto finale corrisponde con il punto utilizzato in precedenza, uso l'altro
-      if dist( tFacAdj[1][nIdEndPoint], ptLocP1) < 10 * GEO.EPS_SMALL then
+      if dist( tFacAdj[nIdEndPoint], ptLocP1) < 10 * GEO.EPS_SMALL then
          ptApPoint = ptLocP2
       else
          ptApPoint = ptLocP1
@@ -964,36 +933,36 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
       if nTypeConeCut == 1 then
          -- se offset angolare valido e/o negativo creo il baffo precedente
          if dOffsAng > -( 100 * GEO.EPS_SMALL) then
-            nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
-            local dLenTrimExt = dist( tFacAdj[1][nIdEndPoint], ptApPoint) - (( dToolDiam/2) + 0.2)
+            nAuxId = EgtLine( nAddGrpId, tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
+            local dLenTrimExt = dist( tFacAdj[nIdEndPoint], ptApPoint) - (( dToolDiam/2) + 0.2)
             -- se la distanza dei due punti della linea è maggiore dal raggio fresa + delta, trimmo al raggio fresa + delta
             if dLenTrimExt > 10 * GEO.EPS_SMALL then
                EgtTrimExtendCurveByLen( nAuxId , -dLenTrimExt, ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
                -- se ho l'offset angolare ruoto la linea per compensare la rotazione che verrà applicata
                if abs(dOffsAng) > 100 * GEO.EPS_SMALL then
-                  EgtRotate( nAuxId, tFacAdj[1][nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
+                  EgtRotate( nAuxId, tFacAdj[nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
                end
                -- prendo il nuovo punto finale
                ptApPoint = EgtEP( nAuxId, GDB_RT.GLOB) + Point3d( 0, 0, dDepthMach)
             else
                -- se ho l'offset angolare ruoto la linea per compensare la rotazione che verrà applicata
                if abs(dOffsAng) > 100 * GEO.EPS_SMALL then
-                  EgtRotate( nAuxId, tFacAdj[1][nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
+                  EgtRotate( nAuxId, tFacAdj[nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
                end
             end
             table.insert( pAuxId, nAuxId)
             -- creo linea di ritorno
-            nAuxId = EgtLine( nAddGrpId, ptApPoint + Point3d( 0, 0, -dDepthMach), tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
+            nAuxId = EgtLine( nAddGrpId, ptApPoint + Point3d( 0, 0, -dDepthMach), tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
             table.insert( pAuxId, nAuxId)
          end
          -- ultima linea di distacco (5mm in direzione utensile)
-         local pEnd =  tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach) + ( 5 * vtExtr)
-         nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), pEnd, GDB_RT.GLOB)
+         local pEnd =  tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach) + ( 5 * vtExtr)
+         nAuxId = EgtLine( nAddGrpId, tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), pEnd, GDB_RT.GLOB)
          table.insert( pAuxId, nAuxId)
       else
          -- linea di distacco (2mm in direzione utensile)
-         local pEnd =  tFacAdj[1][nIdEndPoint] + ( 2 * vtExtr)
-         nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdEndPoint], pEnd, GDB_RT.GLOB)
+         local pEnd =  tFacAdj[nIdEndPoint] + ( 2 * vtExtr)
+         nAuxId = EgtLine( nAddGrpId, tFacAdj[nIdEndPoint], pEnd, GDB_RT.GLOB)
          table.insert( pAuxId, nAuxId)
          -- ultima linea di risalita in Z
          local pIni = pEnd
@@ -1016,11 +985,11 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
    EgtModifyCurveExtrusion( AuxId, vtExtr, GDB_RT.GLOB)
    -- se ho un offset angolare ruoto il percorso
    if abs(dOffsAng) > 100 * GEO.EPS_SMALL then
-      EgtRotate( AuxId, tFacAdj[1][nIdEndPoint], Z_AX(), dOffsAng, GDB_RT.GLOB)
+      EgtRotate( AuxId, tFacAdj[nIdEndPoint], Z_AX(), dOffsAng, GDB_RT.GLOB)
    end
    -- inserisco la lavorazione
    local sName = 'Clean_' .. ( EgtGetName( nNewProc) or tostring( nNewProc))
-   local nMchId = WM.AddMachining( nNewProc.Id, sName, sMilling)
+   local nMchId = WM.AddMachining( nNewProc, sName, sMilling)
    if not nMchId then
       local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
       EgtOutLog( sErr)
@@ -1110,7 +1079,7 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
          dToolLength = EgtTdbGetCurrToolParam( MCH_TP.LEN) or dToolLength
          dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth      -- qui è la distanza dal portautensile
          -- calcolo il secondo diametro del cono
-         dMillTotDiam = dMillDiam + ( abs(dThickTool) * tan(dSideAng)) * 2
+         dMillTotDiam = dMillDiam + ( abs( dThickTool) * tan( dSideAng)) * 2
       end
    end
    -- copio la feature nel layer di appoggio
@@ -1121,25 +1090,21 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
       nNewProc = EgtCopyGlob( Proc.Id, nAddGrpId) or GDB_ID.NULL
    end
    local nFacCnt = EgtSurfTmFacetCount( nNewProc)
-   local nFacInd, dDimMin, dDimMax, dDepth, nSurfInt
+   local nFacInd, dDepth, nSurfInt
    local bMakeLocSurf
    if nFacCnt <= 4 then
-      -- ottengo le dimensioni apertura, la normale e la faccia inferiore
-      dDimMin, dDimMax, dDepth, _, _, nSurfInt = GetTunnelDimension( nNewProc, Proc.PartId, nAddGrpId)
+      -- recupero profondità e faccia di fondo
+      _, _, dDepth, _, _, nSurfInt = GetTunnelDimension( nNewProc, Proc.PartId, nAddGrpId)
       if nSurfInt then
-         -- uso la dimensione minima anche nel caso che la cava sborda perchè la lavorazione potrebbe collidere con un pezzo limitrofo
-         local dMinWidth = dDimMin
-         nNewProc = EgtSurfTmBySewing( nAddGrpId, {nNewProc,nSurfInt} , true)
+         -- aggiungo la faccia di fondo appena calcolata
+         nNewProc = EgtSurfTmBySewing( nAddGrpId, { nNewProc, nSurfInt}, true)
          -- riordino le facce
          ReorderFacesFromTab( nNewProc, vFace)
-         -- acquisisco il numero della faccia   
+         -- aggiorno numero di facce e assegno indice di quella di fondo (sempre ultima)
          nFacCnt = EgtSurfTmFacetCount( nNewProc)
          nFacInd = nFacCnt - 1
       else
          return true
-         --local sErr = 'Error : cannot create base surface'
-         --EgtOutLog( sErr)
-         --return false, sErr
       end
    else
       bMakeLocSurf = true
@@ -1160,10 +1125,8 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
    while i <= #vFace do
       -- se tutta la faccia o la sua fine senza taglio, inserisco una fresatura
       if ( vFace[i].Type & 2) ~= 0  or  vFace[i].Type == 4 then
-         -- variabili costruzione geometria
-         local tFacAdj = {}
+         -- variabili costruzione geometria (nface1, nFace2, tFacAdj)
          local nFace1 = vFace[i].Fac
-         local nFace2
          -- ricavo i tre punti per eventuale superficie locale
          local ptLoc1, ptLoc2, ptLoc3
          -- punto precedente (punto precedente della faccia [i])
@@ -1174,7 +1137,7 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
          if not j then
             return true
          end
-         nFace2 = vFace[j].Fac
+         local nFace2 = vFace[j].Fac
          -- punto in comune tra le due facce (punto precedente della faccia [j])
          ptLoc1 = vFace[j].PPrev
          -- punto successivo ( precedente della faccia successiva)
@@ -1189,9 +1152,10 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
          -- ricavo i punti e l'angolo interno
          local _, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( nNewProc, nFace1, nFace2, GDB_ID.ROOT)
          -- se punti validi e angolo è interno e non è quasi piatto e >= 90 creo istanza
+         local tFacAdj = {}
          if ptP1 and ptP2 and dAng < 0 and dAng < -6 and dAng > EgtIf( nTypeConeCut == 1, -(90 + 10 * GEO.EPS_SMALL), -(180-dAngleSmall + 10 * GEO.EPS_SMALL))  then
             local dLen = dist( ptP1, ptP2)
-            table.insert( tFacAdj, { nFace1, nFace2, dLen, ptP1, ptP2, dAng, ptLoc1, ptLoc2, ptLoc3})
+            tFacAdj = { nFace1, nFace2, dLen, ptP1, ptP2, dAng, ptLoc1, ptLoc2, ptLoc3}
          end
          -- se ho un elemento creo percorso o percorsi in base al tipo di cono e all'apertura dall'angolo rispetto ai 90°
          -- con una tolleranza di 2 gradi
@@ -1315,7 +1279,7 @@ local function AddMillings( sMilling, vFace, Proc, nRawId, b3Raw, nConeCut, nAdd
       if ( vFace[i].Type & 1) ~= 0 and ( not j or vFace[j].Type == 0 or vFace[j].Type == 1 or abs( vFace[i].SideAng) > 0.1 or abs( vFace[j].SideAng) > 0.1) then
          -- inserisco la lavorazione
          local sName = 'Free_' .. ( EgtGetName( Proc.PartId) or tostring( Proc.PartId))
-         local nMchId = WM.AddMachining( Proc.Id, sName, sMilling)
+         local nMchId = WM.AddMachining( Proc, sName, sMilling)
          if not nMchId then
             local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
             EgtOutLog( sErr)
@@ -1409,7 +1373,7 @@ local function AddMillings( sMilling, vFace, Proc, nRawId, b3Raw, nConeCut, nAdd
       if ( vFace[i].Type & 2) ~= 0  or ( vFace[i].Type == 4 and ( vFace[i].Edges > 3 and not vFace[i].Is3EdgesApprox)) then
          -- inserisco la lavorazione
          local sName = 'Free_' .. ( EgtGetName( Proc.PartId) or tostring( Proc.PartId))
-         local nMchId = WM.AddMachining( Proc.Id, sName, sMilling)
+         local nMchId = WM.AddMachining( Proc, sName, sMilling)
          if not nMchId then
             local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
             EgtOutLog( sErr)
@@ -1610,7 +1574,7 @@ local function AddMillings( sMilling, vFace, Proc, nRawId, b3Raw, nConeCut, nAdd
       if vFace[i].Split then
          -- inserisco la lavorazione
          local sName = 'Free_' .. ( EgtGetName( Proc.PartId) or tostring( Proc.PartId)) .. '_M'
-         local nMchId = WM.AddMachining( Proc.Id, sName, sMilling)
+         local nMchId = WM.AddMachining( Proc, sName, sMilling)
          if not nMchId then
             local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
             EgtOutLog( sErr)
@@ -1701,7 +1665,7 @@ local function AddSawings( sSawing, vFace, Proc, nRawId, b3Raw)
       if ( vFace[i].Type & 1) ~= 0 then
          -- inserisco la lavorazione
          local sName = 'Free_' .. ( EgtGetName( Proc.PartId) or tostring( Proc.PartId))
-         local nMchId = WM.AddMachining( Proc.Id, sName, sSawing)
+         local nMchId = WM.AddMachining( Proc, sName, sSawing)
          if not nMchId then
             local sErr = 'Error adding machining ' .. sName .. '-' .. sSawing
             EgtOutLog( sErr)
@@ -1749,7 +1713,7 @@ local function AddSawings( sSawing, vFace, Proc, nRawId, b3Raw)
       if ( vFace[i].Type & 2) ~= 0 or ( vFace[i].Type == 4 and ( vFace[i].Edges > 3 and not vFace[i].Is3EdgesApprox) and vFace[i].Len > dSawDiam + 1) then
          -- inserisco la lavorazione
          local sName = 'Free_' .. ( EgtGetName( Proc.PartId) or tostring( Proc.PartId))
-         local nMchId = WM.AddMachining( Proc.Id, sName, sSawing)
+         local nMchId = WM.AddMachining( Proc, sName, sSawing)
          if not nMchId then
             local sErr = 'Error adding machining ' .. sName .. '-' .. sSawing
             EgtOutLog( sErr)
@@ -1820,7 +1784,7 @@ local function AddCuts( sCutting, vFace, Proc, nRawId, b3Raw, dSawThick)
          local h = EgtIf( i > 1, i - 1, EgtIf( bClosed, #vFace, nil))
          -- inserisco la lavorazione
          local sName = 'Cut_' .. ( EgtGetName( Proc.PartId) or tostring( Proc.PartId)) .. '_' .. tostring( i) 
-         local nMchId = WM.AddMachining( Proc.Id, sName, sCutting)
+         local nMchId = WM.AddMachining( Proc, sName, sCutting)
          if not nMchId then
             local sErr = 'Error adding machining ' .. sName .. '-' .. sCutting
             EgtOutLog( sErr)
@@ -1999,7 +1963,13 @@ local function MakeByCut( Proc, nRawId, b3Raw)
    local sMilling, dMillMaxDepth = WM.FindMilling( 'FreeContour', dMaxWidth + WD.CUT_EXTRA, nil, nil, nil, nil, true)
    local sMilling2 = WM.FindMilling( 'FreeContour', nil, nil, nil, nil, nil, true)
    if not sMilling and ( not sSawing or bSlanting) then
-      sMilling = sMilling2
+      -- se non trovo una fresa di lunghezza sufficiente, prendo la più lunga disponibile
+      local sMillingMaxLength = WM.FindMilling( 'FreeContour', 0.8 * ( dMaxWidth + WD.CUT_EXTRA), nil, nil, nil, nil, true) or
+                        WM.FindMilling( 'FreeContour', 0.6 * ( dMaxWidth + WD.CUT_EXTRA), nil, nil, nil, nil, true) or
+                        WM.FindMilling( 'FreeContour', 0.4 * ( dMaxWidth + WD.CUT_EXTRA), nil, nil, nil, nil, true) or
+                        WM.FindMilling( 'FreeContour', 0.2 * ( dMaxWidth + WD.CUT_EXTRA), nil, nil, nil, nil, true) or
+                        WM.FindMilling( 'FreeContour', nil, nil, nil, nil, nil, true)
+      sMilling = sMillingMaxLength
       if not sMilling then
          local sErr = 'Error : milling not found in library'
          EgtOutLog( sErr)
@@ -2160,7 +2130,7 @@ local function MakeByMill( Proc, nRawId, b3Raw)
    end
    -- inserisco la lavorazione
    local sName = 'Free_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-   local nMchId = WM.AddMachining( Proc.Id, sName, sMilling)
+   local nMchId = WM.AddMachining( Proc, sName, sMilling)
    if not nMchId then
       local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
       EgtOutLog( sErr)
@@ -2214,8 +2184,8 @@ local function MakeByMill( Proc, nRawId, b3Raw)
       dStep = max( ( dDepth - dMaxMat) / max( nStep, 1), 0)
       local dMaxElev = max( ( nStep + 1) * dStep - GEO.EPS_SMALL, 0)
       EgtSetMachiningParam( MCH_MP.STEP, dStep)
-      -- imposto elevazione
-      EgtSetMachiningParam( MCH_MP.USERNOTES, 'MaxElev=' .. EgtNumToString( dMaxElev, 1) .. ';')
+      -- imposto elevazione e forzo attacco dal lato aperto
+      EgtSetMachiningParam( MCH_MP.USERNOTES, 'MaxElev=' .. EgtNumToString( dMaxElev, 1) .. ';OutRaw=3;')
    end
    
    -- posizione braccio porta testa
@@ -2293,7 +2263,7 @@ local function MakeByMark( Proc, nRawId, b3Raw)
    end
    -- inserisco la lavorazione
    local sName = 'FreeMark_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-   local nMchId = WM.AddMachining( Proc.Id, sName, sMilling)
+   local nMchId = WM.AddMachining( Proc, sName, sMilling)
    if not nMchId then
       local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
       EgtOutLog( sErr)
@@ -2358,7 +2328,7 @@ local function MakeByNail( Proc, nRawId, b3Raw)
    end
    -- inserisco la lavorazione
    local sName = 'Nail_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-   local nMchId = WM.AddMachining( Proc.Id, sName, sNailing)
+   local nMchId = WM.AddMachining( Proc, sName, sNailing)
    if not nMchId then
       local sErr = 'Error adding machining ' .. sName .. '-' .. sNailing
       EgtOutLog( sErr)
@@ -2497,7 +2467,7 @@ local function MakeByPocket( Proc, nRawId, b3Raw)
    end
    -- inserisco la lavorazione di svuotatura
    local sName = 'Pock_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-   local nMchFId = WM.AddMachining( Proc.Id, sName, sPocketing)
+   local nMchFId = WM.AddMachining( Proc, sName, sPocketing)
    if not nMchFId then
       local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing
       EgtOutLog( sErr)

LuaLibs/WProcessLapJoint.lua

@@ -21,6 +21,11 @@
 -- 2023/04/17 Sistemata gestione parametri Q, eliminando quello non usato di forzatura lama e abilitandoli anche per DoubleCut.
 --            Lavorazione CleanCorner sempre forzata con lato di lavoro in centro.
 -- 2023/05/25 Funzioni EgtAddMachining sostituite da WM.AddMachining in modo da trascrivere le priorità da btl alle lavorazioni.
+-- 2023/06/30 Aggiunta lettura delle note esistenti dalle lavorazioni per evitare di sovrascriverle.
+-- 2023/07/10 In MakeSideGrooveByMill si impedisce ora di lavorare una groove se la testa deve scendere sotto al limite superiore del grezzo.
+-- 2023/07/25 Aggiunte passate laterali per SideGroove, se specificato SIDESTEP nelle note utensile.
+-- 2023/08/01 Migliorato controllo testa sotto al grezzo in SieGroove.
+-- 2023/08/07 Controllo testa sotto al grezzo in SideGroove escluso se richiesto il move after.
 
 -- Tabella per definizione modulo
 local WPL = {}
@@ -811,7 +816,7 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
          -- riordino le facce
          nNewProcLoc = ReorderFacesFromTab( nNewProcLoc, vFace)
          -- acquisisco il numero della faccia   
-         nFacCnt = EgtSurfTmFacetCount( nNewProcLoc)
+         local nFacCnt = EgtSurfTmFacetCount( nNewProcLoc)
          nFacInd = nFacCnt - 1
       else
          local sErr = 'Cannot make local bottom surface'
@@ -985,7 +990,7 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
    end
    -- inserisco la lavorazione
    local sName = 'Clean_' .. ( EgtGetName( nNewProc) or tostring( nNewProc))
-   local nMchId = WM.AddMachining( nNewProc.Id, sName, sMilling)
+   local nMchId = WM.AddMachining( nNewProc, sName, sMilling)
    if not nMchId then
       local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
       EgtOutLog( sErr)
@@ -1013,10 +1018,13 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp
    EgtSetMachiningParam( MCH_MP.DEPTH, 0)
    -- forzo lato correzione a centrato
    EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.CENTER)
+   -- leggo eventuali note esistenti della lavorazione
+   local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
    -- Note utente con dichiarazione nessuna generazione sfridi per Vmill
-   local sUserNotes = 'VMRS=0;'
+   sUserNotes = EgtSetValInNotes( sUserNotes, 'VMRS', 0)
    -- aggiungo alle note massima elevazione
-   sUserNotes = sUserNotes .. 'MaxElev=' .. EgtNumToString( 0.0, 1) .. ';'
+   sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( 0.0, 1))
+   -- scrivo le note della lavorazione
    EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
    if not EgtApplyMachining( true, false) then
       local _, sErr = EgtGetLastMachMgrError()
@@ -1276,7 +1284,7 @@ local function MakeByChainSaw( Proc, nFacet, nRawId, b3Raw, dElev, dH, dV)
    for i = 1, nStep do
       -- Applico la lavorazione con sega a catena a questa faccia
       local sName = 'Csaw_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( i)
-      local nMchFId = WM.AddMachining( Proc.Id, sName, sSawing)
+      local nMchFId = WM.AddMachining( Proc, sName, sSawing)
       if not nMchFId then
          local sErr = 'Error adding machining ' .. sName .. '-' .. sSawing
          EgtOutLog( sErr)
@@ -1302,13 +1310,16 @@ local function MakeByChainSaw( Proc, nFacet, nRawId, b3Raw, dElev, dH, dV)
       -- se necessario, limito l'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
+         local dDepth = dMaxDepth - dElev
          EgtOutLog( sWarn)
          EgtSetMachiningParam( MCH_MP.DEPTH_STR, 'TH '..EgtNumToString( dDepth, 1))
       end
+      -- leggo eventuali note esistenti della lavorazione
+      local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
       -- imposto elevazione
-      local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 2) .. ';'
-      EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
+      sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dElev, 2))
+      -- scrivo le note della lavorazione
+      EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
       -- eseguo
       if not EgtApplyMachining( true, false) then
          local _, sErr = EgtGetLastMachMgrError()
@@ -1363,7 +1374,7 @@ local function MakeByMill( Proc, nFacet, nOthFac, nRawId, b3Raw, dSideDist)
    end
    -- inserisco la lavorazione di contornatura
    local sName = 'Mill_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-   local nMchFId = WM.AddMachining( Proc.Id, sName, sMilling)
+   local nMchFId = WM.AddMachining( Proc, sName, sMilling)
    if not nMchFId then
       local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
       EgtOutLog( sErr)
@@ -1436,6 +1447,8 @@ local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw, sCustomMach, d
       EgtOutLog( sErr)
       return false, sErr
    end
+   local dGrooveMinZ = max( b3Raw:getMin():getZ(), Proc.Box:getMin():getZ())
+   local dRawMaxZ = b3Raw:getMax():getZ()
    -- recupero i dati dell'utensile
    local dMillDiam = 20
    local dMillLen = 10
@@ -1444,6 +1457,7 @@ local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw, sCustomMach, d
    local dMillDiamTh = 999
    local dMillDiamThStem = 0
    local dMillLenTh = 0
+   local dSideStep = 0
    if EgtMdbSetCurrMachining( sMilling) then
       local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
       if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
@@ -1454,6 +1468,7 @@ local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw, sCustomMach, d
          dMillDiamTh = EgtTdbGetCurrToolThDiam() or dMillDiamTh
          dMillDiamThStem = EgtTdbGetCurrToolParam( MCH_TP.STEMDIAM) or dMillDiamThStem
          dMillLenTh = EgtTdbGetCurrToolThLength() or dMillLenTh
+         dSideStep = EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'SIDESTEP', 'd') or dSideStep
          if ( EgtTdbGetCurrToolParam( MCH_TP.TYPE) & MCH_TF.SAWBLADE) ~= 0 then
             dMaxMat = EgtTdbGetCurrToolParam( MCH_TP.THICK) or dMaxMat
             if not dMaxDepthOnSide or dMaxDepthOnSide < 0.1 then
@@ -1465,8 +1480,6 @@ local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw, sCustomMach, d
                dMaxDepthOnSide = EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'SIDEDEPTH', 'd')
             end
          end
-         local dGrooveMinZ = max( b3Raw:getMin():getZ(), Proc.Box:getMin():getZ())
-         local dRawMaxZ = b3Raw:getMax():getZ()
          -- se riesco a lavorare il sottosquadro senza arrivare alla parte larga del portautensile uso la sidedepth o il diametro stretto del portautensile come diametro del gambo
          if ( dMillTotLen - dMillLenTh) > ( abs( dRawMaxZ - dGrooveMinZ) + 1) then
             if dMaxDepthOnSide and dMaxDepthOnSide > 0 then
@@ -1478,7 +1491,7 @@ local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw, sCustomMach, d
       end
    end
    -- se profondità ribasso è maggiore della capacità di sottosquadro dell'utensile
-   if ( not bEnablePreMill and bMachFromDn) and ( dElev >= ( 0.5 * ( dMillDiam - dMillDiamTh))) then
+   if ( not bEnablePreMill and bMachFromDn) and ( dElev > 0.5 * ( dMillDiam - dMillDiamTh) - 10 * GEO.EPS_SMALL) then
       local sErr = 'Error : Side Elevation (' .. dElev .. ') bigger than max tool side depth (' .. ( 0.5 * ( dMillDiam - dMillDiamTh)) ..')'
       EgtOutLog( sErr)
       return false, sErr
@@ -1490,7 +1503,20 @@ local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw, sCustomMach, d
       return false, sErr
    end
    if Proc.Fct == 2 and Proc.Box:getMin():getZ() < b3Raw:getMin():getZ() + 100 * GEO.EPS_SMALL and dMaxMat > dThick + 10 * GEO.EPS_SMALL then
-       local sErr = 'Error : Tool thickness is too big'
+      local sErr = 'Error : Tool thickness is too big'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- dimensioni della testa
+   local dHeadMaxWidth = 250
+   local dHeadMinWidth = 160
+   local dHeadMinWidthHeight = 30
+   -- se la testa scende sotto al limite superiore del grezzo e non c'è sufficiente capacità di sottosquadro
+   -- controllo disattivato se move after
+   if WD.SIDEMILL_BEFORE and not ( bEnablePreMill or bAsEnablePreMill) and
+      ( ( dMillTotLen < ( abs( dRawMaxZ - dGrooveMinZ) + 10 * GEO.EPS_SMALL) and ( dElev > 0.5 * ( dMillDiam - dHeadMinWidth) - 10 * GEO.EPS_SMALL)) or
+      ( dMillTotLen + dHeadMinWidthHeight < ( abs( dRawMaxZ - dGrooveMinZ) + 10 * GEO.EPS_SMALL) and ( dElev > 0.5 * ( dMillDiam - dHeadMaxWidth) - 10 * GEO.EPS_SMALL))) then
+      local sErr = 'Error : Tool too short, head will collide with rawpart'
       EgtOutLog( sErr)
       return false, sErr
    end
@@ -1732,8 +1758,8 @@ local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw, sCustomMach, d
             end
          end
          -- inserisco la lavorazione di fresatura
-         local sNameGorge = 'Gorge_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. tostring( nFacet) .. '_' .. tostring( nNm) 
-         local nMchFId = WM.AddMachining( Proc.Id, sNameGorge, sMillingGorge)
+         local sNameGorge = 'Gorge_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. tostring( nFacet)
+         local nMchFId = WM.AddMachining( Proc, sNameGorge, sMillingGorge)
          if not nMchFId then
             local sErr = 'Error adding machining ' .. sNameGorge .. '-' .. sMillingGorge
             EgtOutLog( sErr)
@@ -1748,7 +1774,7 @@ local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw, sCustomMach, d
          end
          EgtSetMachiningParam( MCH_MP.SCC, nSCC)
          -- imposto modo di lavorare la faccia
-         local nFaceUse = WL.GetNearestParalOpposite( Z_AX(), vtN)
+         local nFaceUse = WL.GetNearestParalOpposite( Z_AX())
          EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
          -- imposto elevazione e step
          local dStep = EgtGetMachiningParam( MCH_MP.STEP)
@@ -1783,8 +1809,8 @@ local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw, sCustomMach, d
       for i = 1, nNumStep - 1 do
          nNm = nNm + 1
          -- inserisco la lavorazione di taglio sfrido gorge
-         local sNameGorge = 'GorgeCut_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. tostring( nFacet) .. '_' .. tostring( nNm) 
-         local nMchFId = WM.AddMachining( Proc.Id, sNameGorge, sCuttingGorge)
+         local sNameGorge = 'GorgeCut_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. tostring( nFacet) .. '_' .. tostring( nNm)
+         local nMchFId = WM.AddMachining( Proc, sNameGorge, sCuttingGorge)
          if not nMchFId then
             local sErr = 'Error adding machining ' .. sNameGorge .. '-' .. sCuttingGorge
             EgtOutLog( sErr)
@@ -1841,121 +1867,147 @@ local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw, sCustomMach, d
    
    local dStepOri
    if not bExcludeSideMill then
-      -- inserisco la lavorazione di ribasso o gola
-      local sName = EgtIf( bEnablePreMill ~= nil, 'SideMill_', 'Mill_') .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-      local nMchFId = WM.AddMachining( Proc.Id, sName, sMilling)
-      if not nMchFId then
-         local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
-         EgtOutLog( sErr)
-         return false, sErr
+      local nSideStep = 1
+      if dSideStep > 0 and not ( bEnablePreMill or bAsEnablePreMill) and nModifyLeadInOut < 1 then
+         nSideStep = ceil( dElev / dSideStep)
+         dSideStep = max( dElev / nSideStep, 0)
       end
-      EgtSetInfo( nMchFId, 'Part', Proc.PartId)
-      -- se ho abilitato la lavorazione di lama per garantire passaggio utensile, setto la nota per spostare la fresatura dopo i tagli di lama
-      if bEnablePreMill or bAsEnablePreMill then
-         EgtSetInfo( nMchFId, 'MOVE_AFTER', 1)
-      end
-      -- aggiungo geometria
-      EgtSetMachiningGeometry( {{ Proc.Id, nFacet}})
-      -- imposto posizione braccio porta testa
-      local nSCC = MCH_SCC.ADIR_NEAR
-      EgtSetMachiningParam( MCH_MP.SCC, nSCC)
-      -- imposto modo di lavorare la faccia
-      local nFaceUse = WL.GetNearestParalOpposite( Z_AX(), vtN)
-      EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
-      -- imposto elevazione e step
-      local dStep = EgtGetMachiningParam( MCH_MP.STEP)
-      dStepOri = dStep
-      if dStep < GEO.EPS_SMALL then dStep = 0.75 * dMaxMat end
-      local nStep = ceil( ( dThick - dMaxMat) / dStep)
-      dStep = max( ( dThick - dMaxMat) / max( nStep, 1), 0)
-      local dMaxElev = max( ( nStep + 1) * dStep - GEO.EPS_SMALL, 0)
-      if nSinglePass and nSinglePass > 0 then
-         dStep = 0
-         if nSinglePass == 1 then
-            EgtSetMachiningParam( MCH_MP.DEPTH, dMaxMat)
+      for i = 1, nSideStep do
+         -- inserisco la lavorazione di ribasso o gola
+         local sName = EgtIf( bEnablePreMill ~= nil, 'SideMill_', 'Mill_') .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
+         local nMchFId = WM.AddMachining( Proc, sName, sMilling)
+         if not nMchFId then
+            local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
+            EgtOutLog( sErr)
+            return false, sErr
          end
-      end
-      if bUpwardMilling then
-         dStep = -dStep
-      end
-      EgtSetMachiningParam( MCH_MP.STEP, dStep)
-      EgtSetMachiningParam( MCH_MP.USERNOTES, 'MaxElev=' .. EgtNumToString( dMaxElev, 3) .. ';')
-      -- setto il lato di lavoro standard
-      EgtSetMachiningParam( MCH_MP.INVERT, true)
-      EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
-      -- modifico ingressi e uscita
-      -- se ho inserito il pretaglio modifico
-      if bEnablePreMill or bAsEnablePreMill then
-         if nModifyLeadInOut > 0 then
-            -- Confronto il raggio fresa con l'elevazione dalla normale per vedere se devo modificare l'uscita
-            if dElev > ( 0.5 * dMillDiam) then
-                  if nModifyLeadInOut == 1 then
-                  -- setto il tipo di passo a una via
-                  EgtSetMachiningParam( MCH_MP.STEPTYPE, MCH_MILL_ST.ONEWAY)
-                  -- modifico il tipo di uscita
-                  EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LO.PERP_TG)
+         EgtSetInfo( nMchFId, 'Part', Proc.PartId)
+         -- se ho abilitato la lavorazione di lama per garantire passaggio utensile, setto la nota per spostare la fresatura dopo i tagli di lama
+         if bEnablePreMill or bAsEnablePreMill then
+            EgtSetInfo( nMchFId, 'MOVE_AFTER', 1)
+         end
+         -- aggiungo geometria
+         EgtSetMachiningGeometry( {{ Proc.Id, nFacet}})
+         -- imposto posizione braccio porta testa
+         local nSCC = MCH_SCC.ADIR_NEAR
+         EgtSetMachiningParam( MCH_MP.SCC, nSCC)
+         -- imposto modo di lavorare la faccia
+         local nFaceUse = WL.GetNearestParalOpposite( Z_AX())
+         EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
+         -- imposto elevazione e step
+         local dStep = EgtGetMachiningParam( MCH_MP.STEP)
+         dStepOri = dStep
+         if dStep < GEO.EPS_SMALL then dStep = 0.75 * dMaxMat end
+         local nStep = ceil( ( dThick - dMaxMat) / dStep)
+         dStep = max( ( dThick - dMaxMat) / max( nStep, 1), 0)
+         local dMaxElev = max( ( nStep + 1) * dStep - GEO.EPS_SMALL, 0)
+         if nSinglePass and nSinglePass > 0 then
+            dStep = 0
+            if nSinglePass == 1 then
+               EgtSetMachiningParam( MCH_MP.DEPTH, dMaxMat)
+            end
+         end
+         if bUpwardMilling then
+            dStep = -dStep
+         end
+         EgtSetMachiningParam( MCH_MP.STEP, dStep)
+         -- leggo eventuali note esistenti della lavorazione
+         local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
+         -- aggiungo alle note massima elevazione
+         sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dMaxElev, 3))
+         -- scrivo le note della lavorazione
+         EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
+         -- setto il lato di lavoro standard
+         EgtSetMachiningParam( MCH_MP.INVERT, true)
+         EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
+         -- setto offset radiale per gestire le eventuali passate in orizzontale
+         local dRadialOffset = dSideStep * ( nSideStep - i)
+         EgtSetMachiningParam( MCH_MP.OFFSR, dRadialOffset)
+         -- modifico ingressi e uscita
+         -- se ho inserito il pretaglio modifico
+         if bEnablePreMill or bAsEnablePreMill then
+            if nModifyLeadInOut > 0 then
+               -- Confronto il raggio fresa con l'elevazione dalla normale per vedere se devo modificare l'uscita
+               if dElev > ( 0.5 * dMillDiam) then
+                     if nModifyLeadInOut == 1 then
+                     -- setto il tipo di passo a una via
+                     EgtSetMachiningParam( MCH_MP.STEPTYPE, MCH_MILL_ST.ONEWAY)
+                     -- modifico il tipo di uscita
+                     EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LO.PERP_TG)
+                     EgtSetMachiningParam( MCH_MP.LIPERP, 0)
+                     -- modifico dati supplementari uscita
+                     EgtSetMachiningParam( MCH_MP.LOPERP, 0.5)
+                     EgtSetMachiningParam( MCH_MP.LOTANG, -( dLongGorge + dExtraLongIni + dExtraLongEnd))
+                  else
+                     EgtSetMachiningParam( MCH_MP.LIPERP, dElev)
+                     EgtSetMachiningParam( MCH_MP.LOPERP, dElev)
+                  end
+               end
+               -- setto allungamenti iniziali e finali
+               EgtSetMachiningParam( MCH_MP.STARTADDLEN, dExtraLongIni)
+               EgtSetMachiningParam( MCH_MP.ENDADDLEN, dExtraLongEnd)
+               if bInvertMach then
+                  -- setto il lato di lavoro invertito
+                  EgtSetMachiningParam( MCH_MP.INVERT, false)
+                  EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
+               end
+            else
+               -- setto allungamenti iniziali e finali
+               EgtSetMachiningParam( MCH_MP.STARTADDLEN, dExtraLongIni)
+               EgtSetMachiningParam( MCH_MP.ENDADDLEN, dExtraLongEnd)
+               -- Confronto il raggio fresa con l'elevazione dalla normale per vedere se devo modificare l'uscita
+               if dElev > ( 0.5 * dMillDiam) then
+                  -- setto allungamenti perpendicolari
                   EgtSetMachiningParam( MCH_MP.LIPERP, 0)
-                  -- modifico dati supplementari uscita
-                  EgtSetMachiningParam( MCH_MP.LOPERP, 0.5)
-                  EgtSetMachiningParam( MCH_MP.LOTANG, -( dLongGorge + dExtraLongIni + dExtraLongEnd))
-               else
-                  EgtSetMachiningParam( MCH_MP.LIPERP, dElev)
-                  EgtSetMachiningParam( MCH_MP.LOPERP, dElev)
+                  EgtSetMachiningParam( MCH_MP.LOPERP, 0)
+               end
+            end
+            -- se richiesto, setto la nota per spostare la lavorazione alla fine
+            if not WD.SIDEMILL_BEFORE then
+               EgtSetInfo( nMchFId, 'MOVE_AFTER', 1)
+            end
+         else
+            if nModifyLeadInOut > 0 then
+               -- Confronto il raggio fresa con l'elevazione dalla normale per vedere se devo modificare l'uscita
+               if dElev > ( 0.5 * dMillDiam) then
+                  -- setto il tipo di passo a una via
+                  EgtSetMachiningParam( MCH_MP.STEPTYPE, 1)
+               end
+               if bInvertMach then
+                  -- setto il lato di lavoro invertito
+                  EgtSetMachiningParam( MCH_MP.INVERT, false)
+                  EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
                end
             end
             -- setto allungamenti iniziali e finali
             EgtSetMachiningParam( MCH_MP.STARTADDLEN, dExtraLongIni)
             EgtSetMachiningParam( MCH_MP.ENDADDLEN, dExtraLongEnd)
-            if bInvertMach then
-               -- setto il lato di lavoro invertito
-               EgtSetMachiningParam( MCH_MP.INVERT, false)
-               EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
+            -- se ho passate orizzontali riduco l'eventuale allungamento settato dall'utente
+            local dLiPerp = EgtGetMachiningParam( MCH_MP.LIPERP)
+            local dLoPerp = EgtGetMachiningParam( MCH_MP.LOPERP)
+            if dLiPerp > 0 then
+               dLiPerp = dLiPerp - dRadialOffset
             end
-         else
-            -- setto allungamenti iniziali e finali
-            EgtSetMachiningParam( MCH_MP.STARTADDLEN, dExtraLongIni)
-            EgtSetMachiningParam( MCH_MP.ENDADDLEN, dExtraLongEnd)
-            -- Confronto il raggio fresa con l'elevazione dalla normale per vedere se devo modificare l'uscita
-            if dElev > ( 0.5 * dMillDiam) then
-               -- setto allungamenti perpendicolari
-               EgtSetMachiningParam( MCH_MP.LIPERP, 0)
-               EgtSetMachiningParam( MCH_MP.LOPERP, 0)
+            if dLoPerp > 0 then
+               dLoPerp = dLoPerp - dRadialOffset
+            end
+            EgtSetMachiningParam( MCH_MP.LIPERP, dLiPerp)
+            EgtSetMachiningParam( MCH_MP.LOPERP, dLoPerp)
+            -- se richiesto, setto la nota per spostare la lavorazione alla fine
+            if not WD.SIDEMILL_BEFORE then
+               EgtSetInfo( nMchFId, 'MOVE_AFTER', 1)
             end
          end
-         -- se richiesto, setto la nota per spostare la lavorazione alla fine
-         if not WD.SIDEMILL_BEFORE then
-            EgtSetInfo( nMchFId, 'MOVE_AFTER', 1)
-         end
-      else
-         if nModifyLeadInOut > 0 then
-            -- Confronto il raggio fresa con l'elevazione dalla normale per vedere se devo modificare l'uscita
-            if dElev > ( 0.5 * dMillDiam) then
-               -- setto il tipo di passo a una via
-               EgtSetMachiningParam( MCH_MP.STEPTYPE, 1)
-            end
-            if bInvertMach then
-               -- setto il lato di lavoro invertito
-               EgtSetMachiningParam( MCH_MP.INVERT, false)
-               EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
-            end
-         end
-         -- setto allungamenti iniziali e finali
-         EgtSetMachiningParam( MCH_MP.STARTADDLEN, dExtraLongIni)
-         EgtSetMachiningParam( MCH_MP.ENDADDLEN, dExtraLongEnd)
-         -- se richiesto, setto la nota per spostare la lavorazione alla fine
-         if not WD.SIDEMILL_BEFORE then
-            EgtSetInfo( nMchFId, 'MOVE_AFTER', 1)
-         end
-      end
-      -- eseguo
-      if not EgtApplyMachining( true, false) then
-         -- provo a invertire posizione braccio porta testa
-         nSCC = MCH_SCC.ADIR_FAR
-         EgtSetMachiningParam( MCH_MP.SCC, nSCC)
+         -- eseguo
          if not EgtApplyMachining( true, false) then
-            local _, sErr = EgtGetLastMachMgrError()
-            EgtSetOperationMode( nMchFId, false)
-            return false, sErr
+            -- provo a invertire posizione braccio porta testa
+            nSCC = MCH_SCC.ADIR_FAR
+            EgtSetMachiningParam( MCH_MP.SCC, nSCC)
+            if not EgtApplyMachining( true, false) then
+               local _, sErr = EgtGetLastMachMgrError()
+               EgtSetOperationMode( nMchFId, false)
+               return false, sErr
+            end
          end
       end
    else
@@ -1967,7 +2019,7 @@ local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw, sCustomMach, d
    if dAng and dAng > -90 + 10 * GEO.EPS_SMALL and not bExcludeFinishing then
       -- inserisco la lavorazione di contornatura
       local sName = 'Mill_Oth_Fac_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-      local nMchFId = WM.AddMachining( Proc.Id, sName, sMilling)
+      local nMchFId = WM.AddMachining( Proc, sName, sMilling)
       if not nMchFId then
          local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
          EgtOutLog( sErr)
@@ -1999,7 +2051,12 @@ local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw, sCustomMach, d
          dStepOtherFace = -dStepOtherFace
       end
       EgtSetMachiningParam( MCH_MP.STEP, dStepOtherFace)
-      EgtSetMachiningParam( MCH_MP.USERNOTES, 'MaxElev=' .. EgtNumToString( dMaxElev, 3) .. ';')
+      -- leggo eventuali note esistenti della lavorazione
+      local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
+      -- aggiungo alle note massima elevazione
+      sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( dMaxElev, 3))
+      -- scrivo le note della lavorazione
+      EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
       if bMachFromDn then
          EgtSetMachiningParam( MCH_MP.INVERT, true)
          EgtSetMachiningParam( MCH_MP.DEPTH, dDepthOtherFace)
@@ -2155,7 +2212,7 @@ local function MakeByPocketing( Proc, nFacet, nRawId, b3Raw, bCheckQPar)
    end
    -- inserisco la lavorazione di svuotatura
    local sName = 'Pock_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-   local nMchFId = WM.AddMachining( Proc.Id, sName, sPocketing)
+   local nMchFId = WM.AddMachining( Proc, sName, sPocketing)
    if not nMchFId then
       local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing
       EgtOutLog( sErr)
@@ -2184,8 +2241,12 @@ local function MakeByPocketing( Proc, nFacet, nRawId, b3Raw, bCheckQPar)
       EgtOutLog( sWarn)
    end
    EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
+   -- leggo eventuali note della lavorazione
+   local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
    -- imposto elevazione
-   EgtSetMachiningParam( MCH_MP.USERNOTES, 'MaxElev=' .. EgtNumToString( min( dElev, dMaxDepth), 1) .. ';')
+   sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', EgtNumToString( min( dElev, dMaxDepth), 1))
+   -- scrivo le note della lavorazione
+   EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
    -- eseguo
    if not EgtApplyMachining( true, false) then
       local _, sErr = EgtGetLastMachMgrError()
@@ -2232,7 +2293,7 @@ local function MakeOneFace( Proc, nRawId, b3Raw)
    end
    -- eseguo il taglio di lama
    local sName = 'Cut_' .. ( EgtGetName( Proc.PartId) or tostring( Proc.PartId)) .. '_' .. tostring( Proc.Id) 
-   local nMchId = WM.AddMachining( Proc.Id, sName, sCutting)
+   local nMchId = WM.AddMachining( Proc, sName, sCutting)
    if not nMchId then
       local sErr = 'Error adding machining ' .. sName .. '-' .. sCutting
       EgtOutLog( sErr)
@@ -2510,7 +2571,7 @@ local function MakeTwoFaces( Proc, nRawId, b3Raw)
    for i = 1, 2 do
       -- inserisco la lavorazione
       local sName = 'Cut_' .. ( EgtGetName( Proc.PartId) or tostring( Proc.PartId)) .. '_' .. tostring( Proc.Id) .. '_' .. tostring( i) 
-      local nMchId = WM.AddMachining( Proc.Id, sName, sCutting)
+      local nMchId = WM.AddMachining( Proc, sName, sCutting)
       if not nMchId then
          local sErr = 'Error adding machining ' .. sName .. '-' .. sCutting
          EgtOutLog( sErr)
@@ -2605,8 +2666,12 @@ local function MakeMoreFaces( Proc, nRawId, b3Raw)
                return MakeSideGrooveByMill( Proc, nFacInd, nRawId, b3Raw, EgtIf( dMaxDepthOnSide, sMillOnSide, nil), dMaxDepthOnSide, bMakeFirstGroove, nil, nil, bLikeAsMakeFirstGroove, nSinglePass)
             end
          else
-            -- fresatura (se definita)
-            local sMilling = WM.FindMilling( 'SideGroove', nil, nil, nil, nil, min( dH, dV))
+            -- fresatura (se definita); se disponibile, cerco di usare un utensile che non lavori al limite della capacità di sottosquadro
+            local sMilling = WM.FindMilling( 'SideGroove', nil, nil, nil, nil, min( dH, dV), nil, 1.2 * dSideElev)
+            -- se non ho trovato un utensile un po' più grande del sottosquadro richiesto, passo alla ricerca standard
+            if not sMilling then
+               sMilling = WM.FindMilling( 'SideGroove', nil, nil, nil, nil, min( dH, dV), nil, dSideElev)
+            end
             -- recupero i dati dell'utensile
             local dMaxMat = 1000
             local dMaxDepthOnSide = 0
@@ -2614,7 +2679,7 @@ local function MakeMoreFaces( Proc, nRawId, b3Raw)
             if sMilling and EgtMdbSetCurrMachining( sMilling) then
                local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
                if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
-                  local dMillDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dMillDiam
+                  local dMillDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or 0
                   bIsBlade = EgtTdbGetCurrToolParam( MCH_TP.TYPE) & MCH_TF.SAWBLADE ~= 0
                   if bIsBlade then
                      dMaxMat = EgtTdbGetCurrToolParam( MCH_TP.THICK) or dMaxMat
@@ -2629,12 +2694,12 @@ local function MakeMoreFaces( Proc, nRawId, b3Raw)
                   end
                end
             end
-               if sMilling and dElev < dMaxDepthOnSide then
-                  return MakeSideGrooveByMill( Proc, nFacInd, nRawId, b3Raw, sMilling)
-               -- altrimenti sega a catena
-               else
-                  return MakeByChainSaw( Proc, nFacInd, nRawId, b3Raw, dElev, dH, dV)
-               end
+            if sMilling and dElev < dMaxDepthOnSide then
+               return MakeSideGrooveByMill( Proc, nFacInd, nRawId, b3Raw, sMilling)
+            -- altrimenti sega a catena
+            else
+               return MakeByChainSaw( Proc, nFacInd, nRawId, b3Raw, dElev, dH, dV)
+            end
          end
       end
       local nFacet = EgtIf( bPckt or vtN:getZ() >= WD.NZ_MINA, nFacInd, nFacInd2)

LuaLibs/WProcessMark.lua

@@ -108,7 +108,7 @@ function WPMK.Make( Proc, nRawId, b3Raw)
    end
    -- inserisco la lavorazione di fresatura
    local sName = 'Decor_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-   local nMchFId = WM.AddMachining( Proc.Id, sName, sMilling)
+   local nMchFId = WM.AddMachining( Proc, sName, sMilling)
    if not nMchFId then
       local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
       EgtOutLog( sErr)
@@ -132,7 +132,7 @@ function WPMK.Make( Proc, nRawId, b3Raw)
    if AuxId then
       -- inserisco la lavorazione di fresatura
       local sName2 = 'Decor2_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-      local nMchF2Id = WM.AddMachining( Proc.Id, sName, sMilling)
+      local nMchF2Id = WM.AddMachining( Proc, sName, sMilling)
       if not nMchF2Id then
          local sErr = 'Error adding machining ' .. sName2 .. '-' .. sMilling
          EgtOutLog( sErr)

LuaLibs/WProcessMortise.lua

@@ -251,7 +251,7 @@ function WPM.Make( Proc, nRawId, b3Raw)
    end
    -- inserisco la lavorazione di svuotatura
    local sName = 'Mort_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-   local nMchFId = WM.AddMachining( Proc.Id, sName, sPocketing)
+   local nMchFId = WM.AddMachining( Proc, sName, sPocketing)
    if not nMchFId then
       local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing
       EgtOutLog( sErr)

LuaLibs/WProcessText.lua

@@ -78,7 +78,7 @@ function WPT.Make( Proc, nRawId, b3Raw)
    end
    -- inserisco la lavorazione di fresatura
    local sName = 'Text_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-   local nMchFId = WM.AddMachining( Proc.Id, sName, sMilling)
+   local nMchFId = WM.AddMachining( Proc, sName, sMilling)
    if not nMchFId then
       local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
       EgtOutLog( sErr)

LuaLibs/WProcessVariant.lua

@@ -72,7 +72,7 @@ local function MakeCode_1( Proc, nRawId, b3Raw)
    end
    -- inserisco la lavorazione di finitura superficie
    local sName = 'SurfFin_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
-   local nMchFId = WM.AddMachining( Proc.Id, sName, sSurfFin)
+   local nMchFId = WM.AddMachining( Proc, sName, sSurfFin)
    if not nMchFId then
       local sErr = 'Error adding machining ' .. sName .. '-' .. sSurfFin
       EgtOutLog( sErr)

LuaLibs/WallExec.lua

@@ -1,6 +1,9 @@
--- WallExec.lua by Egaltech s.r.l. 2023/03/06
+-- WallExec.lua by Egaltech s.r.l. 2023/07/04
 -- Libreria esecuzione lavorazioni per Pareti
--- 2023/05/25 Aggiunto ordinamento in base a prioritò da btl.
+-- 2023/05/25 Aggiunto ordinamento in base a priorità da btl.
+-- 2023/06/07 Nel caso di outline con priorità aggiunta la rimozione degli sfridi nella lavorazione successiva.
+-- 2023/06/27 Aggiunte origini TN e BN.
+-- 2023/07/04 Se c'è funzione di macchina WD.GetOrigCorner si lascia scegliere posizione default a questa impostando 0 se non c'è 'REFPOS'.
 
 -- Tabella per definizione modulo
 local WallExec = {}
@@ -72,7 +75,7 @@ function WallExec.ProcessWalls( dRawL, dRawW, dRawH, vWall, bMachGroupOk, bNewPr
    local nCorner
    local sOrigCorner = WD.ORIG_CORNER or 'BR'
    if WD.GetOrigCorner then
-      sOrigCorner = WD.GetOrigCorner( EgtGetInfo( EgtGetFirstNameInGroup( GDB_ID.ROOT, 'BtlInfo') or GDB_ID.NULL, 'REFPOS', 'i') or 1)
+      sOrigCorner = WD.GetOrigCorner( EgtGetInfo( EgtGetFirstNameInGroup( GDB_ID.ROOT, 'BtlInfo') or GDB_ID.NULL, 'REFPOS', 'i') or 0)
    end 
    if sOrigCorner == 'TL' then
       nCorner = MCH_CR.TL
@@ -92,6 +95,12 @@ function WallExec.ProcessWalls( dRawL, dRawW, dRawH, vWall, bMachGroupOk, bNewPr
    elseif sOrigCorner == 'BM' then
       nCorner = MCH_CR.BR
       OrigOnTab = Point3d( WD.MID_REF - abs( WD.DELTA_X or 0), abs( WD.DELTA_Y or 0), ( WD.DELTA_Z or 0))
+   elseif sOrigCorner == 'TN' then
+      nCorner = MCH_CR.TL
+      OrigOnTab = Point3d( WD.NEW_REF + abs( WD.DELTA_X or 0), b3Tab:getDimY() - abs( WD.DELTA_Y or 0), ( WD.DELTA_Z or 0))
+   elseif sOrigCorner == 'BN' then
+      nCorner = MCH_CR.BL
+      OrigOnTab = Point3d( WD.NEW_REF + abs( WD.DELTA_X or 0), abs( WD.DELTA_Y or 0), ( WD.DELTA_Z or 0))
    end
    -- Impostazione dell'attrezzaggio di default
    EgtImportSetup()
@@ -180,7 +189,8 @@ function WallExec.CollectFeatures( PartId, b3Raw)
                Proc.CutId = nCutId
                Proc.TaskId = nTaskId
                Proc.Box = EgtGetBBoxGlob( ProcId, GDB_BB.STANDARD)
-               if Proc.Box and not Proc.Box:isEmpty() then 
+               Proc.IsOutline = ( Proc.Prc == 251 or Proc.Prc == 252)
+               if Proc.Box and not Proc.Box:isEmpty() then
                   table.insert( vProc, Proc)
                   -- se foro
                   if Drill.Identify( Proc) then
@@ -584,6 +594,27 @@ local function SortMachinings( nPhase, PrevMch, nPartId, nPriority)
    return PrevMch
 end
 
+-------------------------------------------------------------------------------------------------------------
+-- setto la rimozione sfridi dopo le lavorazioni di outline
+function InsertScrapRemoval( nPhase)
+   local nCurrentOperationId = EgtGetNextOperation( EgtGetPhaseDisposition( nPhase))
+   local nActiveMachiningId = EgtGetCurrMachining()
+   while nCurrentOperationId do
+      local bIsCurrentOperationOutline = ( EgtGetInfo( nCurrentOperationId or GDB_ID.NULL, 'ISOUTLINE', 'b' ) == true)
+      local bIsCurrentOperationWithPriority = ( ( EgtGetInfo( nCurrentOperationId or GDB_ID.NULL, 'PRIORITY', 'i' ) or 0) > 0)
+      local nNextOperationId = EgtGetNextOperation (nCurrentOperationId)
+      local bIsNextOperationOutline = ( EgtGetInfo( nNextOperationId or GDB_ID.NULL, 'ISOUTLINE', 'b' ) == true)
+      if bIsCurrentOperationOutline and bIsCurrentOperationWithPriority and nNextOperationId and not bIsNextOperationOutline then
+         EgtSetCurrMachining( nNextOperationId)
+         local sMachiningNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
+         sMachiningNotes = sMachiningNotes .. 'ScrapRemove=1;'
+         EgtSetMachiningParam( MCH_MP.USERNOTES, sMachiningNotes)
+      end
+      nCurrentOperationId = EgtGetNextOperation( nCurrentOperationId)
+   end
+   EgtSetCurrMachining( nActiveMachiningId or GDB_ID.NULL)
+end
+
 -------------------------------------------------------------------------------------------------------------
 function WallExec.ProcessFeatures()
    -- errori e stato
@@ -676,9 +707,13 @@ function WallExec.ProcessFeatures()
             end
          end
       end
-
+      -- ordinamento standard
       SortMachinings( nPhase, PrevMch)
+
       -- Aggiornamento finale di tutto
+      if nGetPriorityFromBtl > 0 then
+         InsertScrapRemoval( nPhase)
+      end
       EgtSetCurrPhase( 1)
       EgtApplyAllMachinings()
    -- altrimenti macchina travi

UpdateLog.txt

@@ -1,5 +1,35 @@
            ==== Wall Update Log ====
 
+Versione 2.5i1 (12/09/2023)
+- Fixed : correzioni per pulizia corner in FreeContour.
+
+Versione 2.5h1 (01/08/2023)
+- Modif : in sideGroove migliorato il controllo che la testa non scenda sotto al livello del grezzo (ora considera anche il diametro minimo della testa e non interviene se la lavorazione è spostata a dopo il taglio outline).
+- Fixed : corretto bug in MachiningLib -> AddMachining che contempla il caso in cui Proc non sia una tabella
+
+Versione 2.5g3 (26/07/2023)
+- Modif : Nei tagli di lama angolo Z minimo ora gestito tramite costante da WallData CUT_VZ_MIN (default -0.5)
+- Modif : Nelle fresature di ripresa angoli dei contorni migliorata la scelta della fresa secondaria in caso non sia disponibile una fresa di lunghezza sufficiente.
+
+Versione 2.5g2 (25/07/2023)
+- Added : aggiunte passate laterali per SideGroove, se specificato SIDESTEP nelle note utensile.
+
+Versione 2.5g1 (04/07/2023)
+- Modif : per posizione default del grezzo ora si assegna 0 per lasciare il compito a WD.GetOrigCorner di macchina.
+
+Versione 2.5f3 (30/06/2023)
+- Modif : in LapJoint aggiunta lettura di eventuali note di lavorazione esistenti.
+
+Versione 2.5f2 (28/06/2023)
+- Added : aggiunte due nuove origini (TN e BN che come X usano WD.NEW_REF), in totale ora sono 8.
+
+Versione 2.5f1 (13/06/2023)
+- Added : aggiunta gestione priorità da btl
+- Added : aggiunta gestione lavorazione per lamatura speciale affondata con Tool_ID specifico.
+
+Versione 2.5e1 (04/05/2023)
+- Modif : modifiche per gestione traduzione messaggi
+
 Versione 2.5d2 (20/04/2023)
 - Added : in TS3v7 aggiunta gestione flag per taglio feature con outline (da parametro macchina WD.CUT_WITH_OUTLINE)
 - Added : in TS3v7 aggiunta gestione flag per rotazione grezzo di 180deg (da parametro macchina WD.RAWPART_ROT)

Version.lua

@@ -1,6 +1,6 @@
--- Version.lua by Egalware s.r.l. 2023/05/04
+-- Version.lua by Egalware s.r.l. 2023/09/12
 -- Gestione della versione di Wall
 
 NAME = 'Wall'
-VERSION = '2.5e1'
+VERSION = '2.5i1'
 MIN_EXE = '2.5b3'