diff --git a/BatchProcessNew.lua b/BatchProcessNew.lua
index dce4acf..6b9d0b2 100644
--- a/BatchProcessNew.lua
+++ b/BatchProcessNew.lua
@@ -58,6 +58,7 @@ _G.package.loaded.FeatureLib = nil
 _G.package.loaded.Identity = nil
 _G.package.loaded.Logs = nil
 _G.package.loaded.MachiningLib = nil
+_G.package.loaded.PreCollisionLib = nil
 -- strategie di base sempre presenti
 _G.package.loaded['HEADCUT\\HEADCUT'] = nil
 _G.package.loaded['TAILCUT\\TAILCUT'] = nil
diff --git a/LuaLibs/PreCollisionLib.lua b/LuaLibs/PreCollisionLib.lua
index f653856..63bf790 100644
--- a/LuaLibs/PreCollisionLib.lua
+++ b/LuaLibs/PreCollisionLib.lua
@@ -51,13 +51,59 @@ local function GetRestlengthSurfFrInPlane( Part, vtDirection)
    return idRestlengthSurfFr
 end
 
+-------------------------------------------------------------------------------------------------------------
+-- calcolo pivot in riferimento globale
+local function GetGlobalPivot( ptRef, vtHead, vtNEdge, Tool)
+
+   -- frame solidale all'utensile (lo stesso in cui vtPivot è definito)
+   local frTool = Frame3d( ptRef, vtHead, vtNEdge)
+   -- TODO vtPivotGlob dovrà arrivare da funzione perchè può cambiare con SCC (es: aggregato)
+   local vtPivotGlob = Vector3d( Tool.SetupInfo.vtPivot)
+   vtPivotGlob:toGlob( frTool)
+   local ptPivot = ptRef + vtPivotGlob
+
+   return ptPivot
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- restituisce i punti notevoli della lavorazioni in cui fare il controllo
+local function GetMachiningPoints( Edge, dDepthToMachine)
+
+   local MachiningPoints = {}
+
+   -- punti notevoli
+   local ptStart = Edge.ptStart + Edge.vtN * ( Edge.dElevation - dDepthToMachine)
+   local ptEnd = Edge.ptEnd + Edge.vtN * ( Edge.dElevation - dDepthToMachine)
+   local ptMid = Point3d( ( ptStart + ptEnd) / 2)
+
+   -- caso ottimizzato: lato parallelo ad una direzione principale
+   local vtEdge = Edge.ptEnd - Edge.ptStart
+   vtEdge:normalize()
+   local bIsEdgeParallelToMainDirection =
+      AreSameOrOppositeVectorApprox( vtEdge, X_AX())
+      or AreSameOrOppositeVectorApprox( vtEdge, Y_AX())
+      or AreSameOrOppositeVectorApprox( vtEdge, Z_AX())
+
+   -- aggiunta punti
+   -- inizio e fine solo se lato obliquo
+   if bIsEdgeParallelToMainDirection then
+      table.insert( MachiningPoints, ptStart)
+   end
+   table.insert( MachiningPoints, ptMid)
+   if bIsEdgeParallelToMainDirection then
+      table.insert( MachiningPoints, ptEnd)
+   end
+
+   return MachiningPoints
+end
+
 -------------------------------------------------------------------------------------------------------------
 -- si controlla la collisione con il carro Z nei 3 piani globali X, Y e Z. Se c'è collisione in tutti i piani, il carro sarà in collisione.
 function PreCollisionLib.CheckCollisionAxisZ( Edge, vtNFace, vtHead, Part, Tool, dDepthToMachine)
 
    -- se faccia non parallela a direzione testa c'è qualcosa che non va
    if not AreSameOrOppositeVectorApprox( vtNFace, vtHead) then
-      error( 'CheckCollisionAxisZ : invalid directions')
+      error( 'CheckCollision : invalid directions')
    end
 
    -- TODO modificare e rimettere (Hmax pezzo)
@@ -70,11 +116,7 @@ function PreCollisionLib.CheckCollisionAxisZ( Edge, vtNFace, vtHead, Part, Tool,
    -- end
 
    -- punti notevoli della lavorazione in cui fare il check
-   local MachiningPoints = {
-      Edge.ptStart + Edge.vtN * ( Edge.dElevation - dDepthToMachine),
-      Point3d( ( Edge.ptStart + Edge.ptEnd) / 2) + Edge.vtN * ( Edge.dElevation - dDepthToMachine),
-      Edge.ptEnd + Edge.vtN * ( Edge.dElevation - dDepthToMachine)
-   }
+   local MachiningPoints = GetMachiningPoints( Edge, dDepthToMachine)
 
    -- punti in centro lama su naso mandrino o aggregato. In base a direzione e punto
    local bIsDownUp = AreOppositeVectorApprox( vtNFace, vtHead)
@@ -95,46 +137,90 @@ function PreCollisionLib.CheckCollisionAxisZ( Edge, vtNFace, vtHead, Part, Tool,
    local Color = Color3d( math.random(0, 255), math.random(0, 255), math.random(0, 255))
    -- TEST
 
-   -- per ogni punto in cui controllare si crea una flat region
-   local CollisionCurves = {}
+   local bMoveAfterSplit = false
 
-   for j = 1, #ToolExitPoints do
+   -- nel singolo punto notevole si ha collisione se si trova intersezione in tutte le direzioni
+   -- se almeno in un punto c'è collisione con il pezzo si ritorna collisione
+   -- se non si trova collisione si ritorna se è necessario separare prima di effettuare la lavorazione (ossia non c'è collisione con il pezzo ma c'è con il grezzo restante)
+   for i = 1, #ToolExitPoints do
 
-      -- calcolo pivot in riferimento globale
-      local ptRef = ToolExitPoints[j]
-      local frTool = Frame3d( ptRef, vtHead, Edge.vtN)
-      -- TODO vtPivotGlob dovrà arrivare da funzione perchè può cambiare con SCC (es: aggregato)
-      local vtPivotGlob = Vector3d( Tool.SetupInfo.vtPivot)
-      vtPivotGlob:toGlob( frTool)
-      local ptPivot = ptRef + vtPivotGlob
+      -- pivot in globale
+      local ptRef = ToolExitPoints[i]
+      local ptPivot = GetGlobalPivot( ptRef, vtHead, Edge.vtN, Tool)
 
-      for i = 1, #CheckDirections do
+      local nCollisionCountPiece = 0
+      local nCollisionCountRestlength = 0
 
-         local vtDirectionX = CheckDirections[i].vtDirectionX
-         local vtDirectionZ = CheckDirections[i].vtDirectionZ
-         local sDirectionName = CheckDirections[i].sDirectionName
+      for j = 1, #CheckDirections do
 
-         -- costruzione flat region del pezzo e del grezzo restante nel piano perpendicolare al taglio
-         local idPartSurfFr = GetPartSurfFrInPlane( Part, vtDirectionZ)
-         local idRestLengthSurfFr = GetRestlengthSurfFrInPlane( Part, vtDirectionZ)
-
-         -- costruzione flat region della curva di collisione nel piano scelto, per tutti i punti notevoli scelti
-         -- recupero punti da macchina per costruire flat region
-         local ZAxisPoints = Tool.SetupInfo.GetAxisZPoints( sDirectionName)
-
-         -- curva di collisione in riferimento locale
-         local idCollisionCurve = EgtCurveCompoFromPoints( Part.idTempGroup, ZAxisPoints)
-         table.insert( CollisionCurves, idCollisionCurve)
+         local vtDirectionX = CheckDirections[j].vtDirectionX
+         local vtDirectionZ = CheckDirections[j].vtDirectionZ
+         local sDirectionName = CheckDirections[j].sDirectionName
          
+         -- costruzione flat region della curva di collisione nel piano scelto
+         -- recupero punti da macchina per costruire flat region
+         local CollisionCurvePoints = Tool.SetupInfo.GetAxisPoints( 'Z', sDirectionName)
+         -- curva di collisione in riferimento locale
+         local idCollisionCurve = EgtCurveCompoFromPoints( Part.idTempGroup, CollisionCurvePoints)
          -- TEST
          EgtSetColor( idCollisionCurve, Color)
          -- TEST
-            
          -- curva in riferimento globale
          local frReference = Frame3d( ptPivot, vtDirectionZ, vtDirectionX)
          EgtTransform( idCollisionCurve, frReference, GDB_RT.GLOB )
+         -- flat region di collisione
+         local idCollisionSurfFr = EgtSurfFlatRegion( Part.idTempGroup, idCollisionCurve)
+
+         -- check collisione con pezzo (per la collisione deve esserci intersezione su tutti e 3 i piani)
+         -- si controlla solo se nelle direzioni precedenti è stata trovata collisione col pezzo,
+         -- altrimenti significa che non si è usciti dal ciclo solamente la collisione con grezzo per restituire bMoveAfterSplit
+         local bCollisionFoundPiece = false
+         if nCollisionCountPiece == j - 1 then
+            local idPartSurfFr = GetPartSurfFrInPlane( Part, vtDirectionZ)
+            local bIntersectSuccess = EgtSurfFrIntersect( idPartSurfFr, idCollisionSurfFr)
+            if not bIntersectSuccess then
+               error( 'CheckCollision : intersect fail')
+            end
+
+            bCollisionFoundPiece = EgtExistsObj( idPartSurfFr)
+         end
+
+         -- check collisione con grezzo restante, se con il pezzo non c'è collisione
+         local bCollisionFoundRestLength = false
+         if not bCollisionFoundPiece then
+            local idRestLengthSurfFr = GetRestlengthSurfFrInPlane( Part, vtDirectionZ)
+            local bIntersectSuccess = EgtSurfFrIntersect( idRestLengthSurfFr, idCollisionSurfFr)
+            if not bIntersectSuccess then
+               error( 'CheckCollision : intersect fail')
+            end
+
+            bCollisionFoundRestLength = EgtExistsObj( idRestLengthSurfFr)
+         end
+
+         -- se non trovata collisione si passa al punto successivo
+         if not ( bCollisionFoundPiece or bCollisionFoundRestLength) then
+            nCollisionCountPiece = 0
+            nCollisionCountRestlength = 0
+            break
+         -- altrimenti si aggiorna il numero di collisioni con pezzo e con grezzo restante
+         elseif bCollisionFoundPiece then
+            nCollisionCountPiece = nCollisionCountPiece + 1
+         elseif bCollisionFoundRestLength then
+            nCollisionCountRestlength = nCollisionCountRestlength + 1
+         end
+      end
+
+      -- collisione trovata
+      if nCollisionCountPiece == #CheckDirections then
+         return true, nil
+      -- nessuna collisione trovata con pezzo ma serve separazione
+      elseif nCollisionCountRestlength == #CheckDirections then
+         bMoveAfterSplit = true
       end
    end
+
+   -- se si arriva qui significa che non è stata trovata alcuna collisione con pezzo
+   return false, bMoveAfterSplit
 end
 
 -------------------------------------------------------------------------------------------------------------
diff --git a/Process.lua b/Process.lua
index ce5a431..0bf3bb8 100644
--- a/Process.lua
+++ b/Process.lua
@@ -46,6 +46,7 @@ _G.package.loaded.FeatureLib = nil
 _G.package.loaded.Identity = nil
 _G.package.loaded.Logs = nil
 _G.package.loaded.MachiningLib = nil
+_G.package.loaded.PreCollisionLib = nil
 -- strategie di base sempre presenti
 _G.package.loaded['HEADCUT\\HEADCUT'] = nil
 _G.package.loaded['TAILCUT\\TAILCUT'] = nil