diff --git a/LuaLibs/AddManData.lua b/LuaLibs/AddManData.lua
index f88b156..66889c5 100644
--- a/LuaLibs/AddManData.lua
+++ b/LuaLibs/AddManData.lua
@@ -31,6 +31,8 @@ INFO_PARTD_ID = "PartId"
 
 DEFAULT_SECTION = "Default"
 LAYER_SECTION = ""
+KEY_SLICING_45 = "Slicing45"
+KEY_SLICING_DIR="SlicingDir"
 KEY_SLICE_Z = "SliceZ"
 KEY_SLICE_NBR = "SliceNbr"
 KEY_SLICE_STEP = "StrandH"
@@ -67,6 +69,7 @@ KEY_LEAD_OUT_ORTHO_DIST= "LeadOutOrthoDist"
 KEY_OFFSET_LEAD_POINT = "OffsetLeadPoint"
 KEY_COASTING_LEN = "CoastingLen"
 KEY_WIPE_LEN = "WipeLen"
+KEY_TOOL_DIAM = "ToolDiam" 
 
 TYPE = {
    OUTER_SHELL = 1,
diff --git a/LuaLibs/CalcPaths.lua b/LuaLibs/CalcPaths.lua
index f582e8a..c1d4ddf 100644
--- a/LuaLibs/CalcPaths.lua
+++ b/LuaLibs/CalcPaths.lua
@@ -24,9 +24,20 @@ local function GetLayerParamsForPathCalc()
 end
 
 ---------------------------------------------------------------------
-local function GetLayerStartPoint()
-   local nParamsGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, PARAMS_GRP)
-   local ptStart = EgtGetInfo( nParamsGrp, KEY_START_POINT, 'p')  
+local function GetLayerStartPoint( nLayId)  
+   
+   local ptStart
+   -- recupero il punto di partenza usato nel layer precedente
+   local nPrev = EgtGetPrev( nLayId) 
+   local nCrvGrp = EgtGetFirstNameInGroup( nPrev, CONTOUR_GRP..'*') 
+   local nPathGrp = EgtGetFirstNameInGroup( nCrvGrp, PATH_GRP) 
+   local nCrv = EgtGetFirstInGroup( nPathGrp) 
+   if nCrv then 
+      ptStart = EgtSP( nCrv, GDB_ID.ROOT)
+   else
+      local nParamsGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, PARAMS_GRP)
+      ptStart = EgtGetInfo( nParamsGrp, KEY_START_POINT, 'p')  
+   end  
    return ptStart
 end
 
@@ -94,11 +105,11 @@ function CalcPaths.Exec( nPartId)
      return 
    end
 
+   -- recupero i parametri per calcolo dei path
+   local LayerParams = GetLayerParamsForPathCalc()
+      
    -- scorro tutti i suoi layer 
-   for nIdx = 1, #vLayIds do
-
-      -- recupero i parametri relativi al layer
-      local LayerParams = GetLayerParamsForPathCalc()
+   for nIdx = 1, #vLayIds do    
 
       -- scorro tutti i gruppi di contorni
       local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[nIdx], CONTOUR_GRP.."*") or GDB_ID.NULL
@@ -132,12 +143,12 @@ function CalcPaths.Exec( nPartId)
             end
             -- se offset riuscito, estraggo i contorni (pareti esterne)
             if bOk then
-               GetPathsFromSurf( nSrfId, SHELL_CRV..'0', TYPE.OUTER_SHELL, nGrpId, nLayId, LayerParams.dStrand)
+               GetPathsFromSurf( nSrfId, SHELL_CRV..'0', TYPE.OUTER_SHELL, nGrpId, vLayIds[nIdx], LayerParams.dStrand)               
             else
                EgtOutLog( 'Error on ExtOffset (layer '..tostring( nIdx)..') - CalcPaths')
             end
             EgtErase( nSrfId)
-
+            
             -- calcolo pareti interne
             for nInd2 = 1, LayerParams.nShellsNbr - 1 do
                -- offset della superficie originale
@@ -150,7 +161,7 @@ function CalcPaths.Exec( nPartId)
                end
                -- se offset riuscito, estraggo i contorni ( pareti interne)
                if bOk then
-                  GetPathsFromSurf( nSrfId, SHELL_CRV..tostring( nInd2), TYPE.INNER_SHELL, nGrpId, nLayId, LayerParams.dStrand)
+                  GetPathsFromSurf( nSrfId, SHELL_CRV..tostring( nInd2), TYPE.INNER_SHELL, nGrpId, vLayIds[nIdx], LayerParams.dStrand)
                else
                   EgtOutLog( 'Error on IntOffset (layer '..tostring( nIdx)..') - CalcPaths')
                end
diff --git a/LuaLibs/CalcSlices.lua b/LuaLibs/CalcSlices.lua
index ea38bbc..3b3ac15 100644
--- a/LuaLibs/CalcSlices.lua
+++ b/LuaLibs/CalcSlices.lua
@@ -21,16 +21,42 @@ end
 
 ---------------------------------------------------------------------
 local function ComputeZSlices( dZmin, dDeltaZ, dZmax)
+   local dSliceStep = GetSliceStep()
    local ptSlices = { dZmin + dDeltaZ}
-   local dPosZ = dZmin + GetSliceStep( dZmin)
+   local dPosZ = dZmin + dSliceStep
    while dPosZ < dZmax do
       table.insert( ptSlices, dPosZ)
-      dPosZ = dPosZ + GetSliceStep( dPosZ)
-   end  
-   
+      dPosZ = dPosZ + dSliceStep
+   end 
    return ptSlices
 end
 
+--------------------------------------------------------------------
+local function ComputeMaxH( nStmId, frSlicing, HMax)
+   
+   local b3BoxGlob = EgtGetBBoxGlob( nStmId, GDB_BB.STANDARD)
+   if b3BoxGlob:getMax():getZ() < b3BoxGlob:getMin():getZ() + HMax + GEO.EPS_SMALL then
+      return GEO.INFINITO
+   end
+   
+   if AreSameVectorApprox( frSlicing:getVersZ(), Z_AX()) then
+      return HMax
+   else   
+      -- se slicing inclinato
+      local nGrpTmp = EgtGroup( EgtGetParent( nStmId))
+      local nNewId, nPnt, nCrv, nSrf = EgtPlaneSurfTmInters( Point3d( 0, 0, HMax), Z_AX(), nStmId, nGrpTmp)
+      if not nNewId then
+         return GEO.INFINITO
+      end
+      local b3Box = EgtGetBBoxGlob( nGrpTmp, GDB_BB.STANDARD)
+      EgtErase( nGrpTmp)
+      local ptMin = b3Box:getMin()
+      ptMin:toLoc( frSlicing)      
+      return ptMin:getZ()
+   end
+   return GEO.INFINITO
+end
+
 ---------------------------------------------------------------------
 function CalcSlices.Exec( nPartId, nStmId, HMax)
 
@@ -41,8 +67,18 @@ function CalcSlices.Exec( nPartId, nStmId, HMax)
    local MIN_LEN = 20.0
    local MIN_AREA = 25.0
 
+   -- recupero la direzione dello slicing
+   local vtSlicing = Z_AX()
+   local nParamsGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, PARAMS_GRP) 
+   local bSlicing45 = EgtGetInfo( nParamsGrp, KEY_SLICING_45, 'b')
+   if bSlicing45 then 
+      vtSlicing = Vector3d( sqrt(2)/2, 0, sqrt(2)/2)
+   end
+   EgtSetInfo( nParamsGrp, KEY_SLICING_DIR, vtSlicing)
+   local frSlicing = Frame3d( ORIG(), vtSlicing)
+   
    -- recupero il box della superficie 
-   local b3Box = EgtGetBBoxRef( nStmId, GDB_BB.STANDARD, EgtGetGridFrame())
+   local b3Box = EgtGetBBoxRef( nStmId, GDB_BB.STANDARD, frSlicing)   
    if not b3Box or b3Box:isEmpty() then
       EgtOutText( 'La superficie selezionata è vuota')
       EgtPause( 1000)
@@ -52,9 +88,10 @@ function CalcSlices.Exec( nPartId, nStmId, HMax)
    -- Parametri di slicing
    local dZmin = b3Box:getMin():getZ()
    local dZmax = b3Box:getMax():getZ()
-   dZmax = min( dZmax, dZmin + HMax)
+   local dMaxH = ComputeMaxH( nStmId, frSlicing, HMax)
+   dZmax = min( dZmax, dMaxH)
    --dZmin = 1022
-   --dZmax = 1023
+   --dZmax = 1023   
 
    -- se slicing già presente lo cancello
    for i = 1, 2 do
@@ -72,14 +109,14 @@ function CalcSlices.Exec( nPartId, nStmId, HMax)
    local dDeltaZStart = 0.2 
    --dDeltaZStart = 0
    local vZSlices = ComputeZSlices( dZmin, dDeltaZStart, dZmax)
-   local nLayId = EgtParPlanesSurfTmInters( ORIG(), Z_AX(), vZSlices, nStmId, nPartId, GDB_RT.GLOB, TOLER) 
+   local nLayId = EgtParPlanesSurfTmInters( ORIG(), vtSlicing, vZSlices, nStmId, nPartId, GDB_RT.GLOB, TOLER) 
    local vErr = {}
    -- scorro i risultati dello slicing 
    while nLayId do
       
       local dDeltaZ = EgtIf( nLayCnt == 1, dDeltaZStart, 0) 
       local dPosZ = vZSlices[nLayCnt]- dDeltaZ
-      EgtSetInfo( nLayId, KEY_SLICE_Z, dPosZ)
+      EgtSetInfo( nLayId, KEY_SLICE_Z, dPosZ - dZmin)
       EgtSetInfo( nLayId, KEY_SLICE_NBR, nLayCnt)      
       
       -- verifico se necessario ricalcolo 
@@ -96,13 +133,13 @@ function CalcSlices.Exec( nPartId, nStmId, HMax)
          end 
          nId = EgtGetPrev( nId)
       end
-      -- eseguo eventuale ricalcolo      
-      if bRecalc then 
+      -- eseguo eventuale ricalcolo  
+      if bRecalc then
          nRecalc = nRecalc + 1
          EgtEmptyGroup( nLayId)   
          dDeltaZ = dDeltaZ + EgtIf( vtRecalc and vtRecalc:getZ() > 0, -0.01, 0.01)
          -- eseguo il ricalcolo solo a quella quota
-         EgtPlaneSurfTmInters( Point3d( 0, 0, dPosZ + dDeltaZ), Z_AX(), nStmId, nLayId, GDB_RT.GLOB, TOLER)         
+         EgtPlaneSurfTmInters( ORIG() + ( dPosZ + dDeltaZ) * vtSlicing, vtSlicing, nStmId, nLayId, GDB_RT.GLOB, TOLER)
       end
 
       -- salvo i risultati nel layer
@@ -116,7 +153,7 @@ function CalcSlices.Exec( nPartId, nStmId, HMax)
          else
             -- correggo eventuali spostamenti in Z
             if abs( dDeltaZ) > GEO.EPS_SMALL then 
-               EgtMove( nId, Vector3d( 0, 0, -dDeltaZ))
+               EgtMove( nId, - dDeltaZ * vtSlicing)
             end            
             -- verifico presenza contorni aperti
             if EgtCurveIsClosed( nId) then
@@ -174,16 +211,20 @@ function CalcSlices.Exec( nPartId, nStmId, HMax)
       EgtSetColor( vClosedId or {}, 'TEAL')
       EgtSetColor( vOpenId or {}, 'RED')
 
-      -- creo flat region a partire dalle curve chiuse ottenute con lo slicing
+      -- creo flat region a partire dalle curve chiuse ottenute con lo slicing      
+      local nGrp = EgtGroup( nLayId, frSlicing)
       for i = 1, #vClosedId do
+         EgtRelocateGlob( vClosedId[i], nGrp)
          EgtApproxCurve( vClosedId[i], GDB_CA.ARCS, SMALL_TOLER)
-      end   
+         EgtRelocateGlob( vClosedId[i], nLayId)
+      end
+      EgtErase( nGrp)     
       local nSurfFR, nSrfNbr = EgtSurfFlatRegion( nLayId, vClosedId)
       for i = 1, #vClosedId do
          EgtErase( vClosedId[i])
       end
    
-      if nSurfFR then 
+      if nSurfFR then
          local nCrv = 0 
          for j = 0, nSrfNbr - 1 do 
             -- analizzo i singoli chunks
@@ -202,7 +243,7 @@ function CalcSlices.Exec( nPartId, nStmId, HMax)
                   EgtSetName( nId2, OUTER_CRV)
                   EgtSetColor( nId2, 'BLACK')
                end
-            end            
+            end
          end
       else
          -- errore
diff --git a/LuaLibs/CalcSolids.lua b/LuaLibs/CalcSolids.lua
index 9550cbc..217dabb 100644
--- a/LuaLibs/CalcSolids.lua
+++ b/LuaLibs/CalcSolids.lua
@@ -20,10 +20,10 @@ local function GetLayerParamsForSolidCalc()
    LayerParams.dLayHeight = EgtGetInfo( nParamsGrp, KEY_SLICE_STEP, 'd')
    LayerParams.dStrand = EgtGetInfo( nParamsGrp, KEY_STRAND, 'd')
    LayerParams.nOrder = EgtGetInfo( nParamsGrp, KEY_PRINT_ORDER, 'i')
-   return LayerParams 
+   LayerParams.vtSlicing = EgtGetInfo( nParamsGrp, KEY_SLICING_DIR, 'v')
+   return LayerParams
 end
 
-
 ---------------------------------------------------------------------
 local function CalcSectionParams( dStrand, dH)
    local dL = dStrand
@@ -54,13 +54,13 @@ local function CalcSectionParams( dStrand, dH)
 end
 
 ---------------------------------------------------------------------
-local function CreateSection( ptS, vtDir, dStrand, dH, nSolidGrp)
+local function CreateSection( ptS, vtDir, dStrand, dH, vtSlicing, nSolidGrp)
 
    local dD1, dD2, dD3, dD4 = CalcSectionParams( dStrand, dH)
-   local ptA = ptS - dH * Z_AX() + dD1 * vtDir
-   local ptB = ptA + dD2 * vtDir + dD3 * Z_AX()
-   local ptC = ptB + dD4 * Z_AX()
-   local ptD = ptA + dH * Z_AX()
+   local ptA = ptS - dH * vtSlicing + dD1 * vtDir
+   local ptB = ptA + dD2 * vtDir + dD3 *vtSlicing
+   local ptC = ptB + dD4 * vtSlicing
+   local ptD = ptA + dH * vtSlicing
    local ptE = ptD - 2 * dD1 * vtDir 
    local ptF = ptC - 2 * ( dD1 + dD2) * vtDir
    local ptG = ptB - 2 * ( dD1 + dD2) * vtDir
@@ -68,57 +68,57 @@ local function CreateSection( ptS, vtDir, dStrand, dH, nSolidGrp)
 
    local nId = EgtCurveCompoFromPoints( nSolidGrp, {ptA, ptB, ptC, ptD, ptE, ptF, ptG, ptH, ptA})
    EgtInvertCurve( nId)
-
-   return nId   
+   
+   return nId 
 end
 
 ---------------------------------------------------------------------
-local function CreateHalfSection( ptS, vtDir, dStrand, dH, nSolidGrp)
+local function CreateHalfSection( ptS, vtDir, dStrand, dH, vtSlicing, nSolidGrp)
 
    local dD1, dD2, dD3, dD4 = CalcSectionParams( dStrand, dH)
-   local ptA = ptS - dH * Z_AX() + dD1 * vtDir
-   local ptB = ptA + dD2 * vtDir + dD3 * Z_AX()
-   local ptC = ptB + dD4 * Z_AX()
-   local ptD = ptA + dH * Z_AX()
-
-   local nId = EgtCurveCompoFromPoints( nSolidGrp, { ptS - dH * Z_AX(), ptA, ptB, ptC, ptD, ptS})
-
+   local ptA = ptS - dH * vtSlicing + dD1 * vtDir
+   local ptB = ptA + dD2 * vtDir + dD3 * vtSlicing
+   local ptC = ptB + dD4 * vtSlicing
+   local ptD = ptA + dH * vtSlicing
+ 
+   local nId = EgtCurveCompoFromPoints( nSolidGrp, { ptS - dH * vtSlicing, ptA, ptB, ptC, ptD, ptS})
+   
    return nId
 end
 
 --------------------------------------------------------------------
-local function CreateSolid( nCrvId, nSolidGrp, dStrand, dH)
+local function CreateSolid( nCrvId, nSolidGrp, dStrand, dH, vtSlicing)
    -- punti e direzioni all'inizio e fine della curva guida
    local ptS = EgtSP( nCrvId) 
    local vtS = EgtSV( nCrvId)
-   vtS:rotate( Z_AX(), 90)
+   vtS:rotate( vtSlicing, 90)
    local ptE = EgtEP( nCrvId) 
    local vtE = EgtEV( nCrvId)
-   vtE:rotate( Z_AX(), -90)
+   vtE:rotate( vtSlicing, -90)
    -- creazione del solido aperto (tubo)
-   local nSectId = CreateSection( ptS, vtS, dStrand, dH, nSolidGrp) 
+   local nSectId = CreateSection( ptS, vtS, dStrand, dH, vtSlicing, nSolidGrp) 
    local nSrfId = EgtSurfTmSwept( nSolidGrp, nSectId, nCrvId, false, 0.1)
-   EgtErase( nSectId)  
+   EgtErase( nSectId)
    if not nSrfId then return nil end
    -- creazione del mezzo disco iniziale
-   local nSectS = CreateHalfSection( ptS, vtS, dStrand, dH, nSolidGrp) 
-   local nSrfS = EgtSurfTmByScrewing( nSolidGrp, nSectS, ptS, Z_AX(), 180, 0, false, 0.1)
+   local nSectS = CreateHalfSection( ptS, vtS, dStrand, dH, vtSlicing, nSolidGrp) 
+   local nSrfS = EgtSurfTmByScrewing( nSolidGrp, nSectS, ptS, vtSlicing, 180, 0, false, 0.1)
    EgtErase( nSectS)
    if not nSrfS then return nil end
    -- creazione del mezzo disco finale
-   local nSectE = CreateHalfSection( ptE, vtE, dStrand, dH, nSolidGrp) 
-   local nSrfE = EgtSurfTmByScrewing( nSolidGrp, nSectE, ptE, Z_AX(), 180, 0, false, 0.1)
+   local nSectE = CreateHalfSection( ptE, vtE, dStrand, dH, vtSlicing, nSolidGrp) 
+   local nSrfE = EgtSurfTmByScrewing( nSolidGrp, nSectE, ptE, vtSlicing, 180, 0, false, 0.1)
    EgtErase( nSectE)
    if not nSrfE then return nil end
    -- unione delle tre superfici
-   return EgtSurfTmBySewing( nSolidGrp, { nSrfId, nSrfS, nSrfE}) 
+   return EgtSurfTmBySewing( nSolidGrp, { nSrfId, nSrfS, nSrfE})
 end
 
 ---------------------------------------------------------------------
 local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams)
   
    local nType = EgtGetInfo( nCrvId, KEY_TYPE, 'i')   
-   if nType == TYPE.WIPE then return end 
+   if nType == TYPE.WIPE then return true end 
    -- scelta del colore
    local Color = EgtStdColor( 'GRAY') 
    if nType == TYPE.OUTER_SHELL then 
@@ -135,36 +135,36 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams)
 
    local nParts = EgtIf( nType == TYPE.LINK or nType == TYPE.COASTING, 1, 10)
 
-   local nCopyId = EgtCopyGlob( nCrvId, nSolidGrp)
-   EgtApproxCurve( nCopyId, GDB_CA.ARCS, 0.1)
-   EgtChangeClosedCurveStartPoint( nCopyId, EgtSP( nCrvId))
-   local nId = EgtSplitCurve( nCopyId, nParts) 
-
+   local nCopyId = EgtCopyGlob( nCrvId, nSolidGrp)   
+   local nId = EgtSplitCurve( nCopyId, nParts)
    local bOk = true
    for nInd = 0, nParts - 1 do
       local nGuideId = nId + nInd 
-      local nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams.dStrand, LayerParams.dLayHeight)
+      local nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams.dStrand, LayerParams.dLayHeight, LayerParams.vtSlicing)
       
       if not nSrfId then 
          -- ritento con sezione leggermente modificata 
-         nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams.dStrand - 100 * GEO.EPS_SMALL, LayerParams.dLayHeight)
-         if not nSrfId then 
-            -- ritento spezzando la curva
-            local nFirstCrv, nCrvNbr = EgtSplitCurveAtCorners( nGuideId, 60)
-            if nFirstCrv then 
-               local nSrfIds = {}
-               for nInd2 = 0, nCrvNbr-1 do
-                  local nSrfId2 = CreateSolid( nFirstCrv + nInd2, nSolidGrp, LayerParams.dStrand - 100 * GEO.EPS_SMALL, LayerParams.dLayHeight)
-                  EgtErase( nFirstCrv + nInd2)
-                  if nSrfId2 then
-                     table.insert( nSrfIds, nSrfId2)
-                  end                 
-               end
-               if #nSrfIds == nCrvNbr then  
-                  nSrfId = EgtSurfTmBySewing( nSolidGrp, nSrfIds) 
+         nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams.dStrand - 100 * GEO.EPS_SMALL, LayerParams.dLayHeight, LayerParams.vtSlicing)
+         if not nSrfId then
+            nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams.dStrand + 100 * GEO.EPS_SMALL, LayerParams.dLayHeight, LayerParams.vtSlicing)
+            if not nSrfId then 
+               -- ritento spezzando la curva
+               local nFirstCrv, nCrvNbr = EgtSplitCurveAtCorners( nGuideId, 60)
+               if nFirstCrv then 
+                  local nSrfIds = {}
+                  for nInd2 = 0, nCrvNbr-1 do
+                     local nSrfId2 = CreateSolid( nFirstCrv + nInd2, nSolidGrp, LayerParams.dStrand - 100 * GEO.EPS_SMALL, LayerParams.dLayHeight, LayerParams.vtSlicing)
+                     EgtErase( nFirstCrv + nInd2)
+                     if nSrfId2 then
+                        table.insert( nSrfIds, nSrfId2)
+                     end                 
+                  end
+                  if #nSrfIds == nCrvNbr then  
+                     nSrfId = EgtSurfTmBySewing( nSolidGrp, nSrfIds) 
+                  end
                end
             end
-         end         
+         end
       end
       
       if nSrfId then
@@ -189,10 +189,11 @@ function CalcSolids.Exec( nPartId)
    end
 
    local vErr = {}
+   -- recupero i parametri necessari al calcolo dei solidi 
+   local LayerParams = GetLayerParamsForSolidCalc()
+   
    for nIdx = 1, #vLayIds do
-      -- recupero i parametri relativi al layer
-      local LayerParams = GetLayerParamsForSolidCalc()
-
+      
       -- scorro tutti i gruppi di contorni
       local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*") or GDB_ID.NULL
       while nCrvGrpId ~= GDB_ID.NULL do
diff --git a/LuaLibs/CalcToolPath.lua b/LuaLibs/CalcToolPath.lua
index bc9fee3..c225f7e 100644
--- a/LuaLibs/CalcToolPath.lua
+++ b/LuaLibs/CalcToolPath.lua
@@ -18,6 +18,7 @@ local function GetLayerParamsForToolPathCalc()
    local LayerParams = {}
    LayerParams.dStrand = EgtGetInfo( nParamsGrp, KEY_STRAND, 'd')
    LayerParams.dLayHeight = EgtGetInfo( nParamsGrp, KEY_SLICE_STEP, 'd')
+   LayerParams.dOffs = EgtGetInfo( nParamsGrp, KEY_OFFSET_SLICE, 'd')
    LayerParams.bInvert = ( EgtGetInfo( nParamsGrp, KEY_PRINT_DIRECTION, 'i') == PRINT_DIRECTION.CW)
    LayerParams.nOrder = EgtGetInfo( nParamsGrp, KEY_PRINT_ORDER, 'i')
    LayerParams.nLinkType = EgtGetInfo( nParamsGrp, KEY_LINK_TYPE, 'i')
@@ -32,39 +33,47 @@ local function GetLayerParamsForToolPathCalc()
    LayerParams.dSPOffs = EgtGetInfo( nParamsGrp, KEY_SP_OFFSET_ON_SLICE, 'd')
    LayerParams.dCoastingLen = EgtGetInfo( nParamsGrp, KEY_COASTING_LEN, 'd')
    LayerParams.dWipeLen = EgtGetInfo( nParamsGrp, KEY_WIPE_LEN, 'd')
-   
+   LayerParams.vtSlicing = EgtGetInfo( nParamsGrp, KEY_SLICING_DIR, 'v')
+   LayerParams.dTDiam = EgtGetInfo( nParamsGrp, KEY_TOOL_DIAM, 'd')
+
    return LayerParams 
 end
 
+--------------------------------------------------------------------
+local function ComputeZCorrection( LayerParams)
+   local _, dAng, _ = SphericalFromVector( LayerParams.vtSlicing)
+   -- correzione per l'offset
+   local dCorr1 = LayerParams.dOffs * sin( dAng)
+   -- eventuale correzione per il diametro ugello
+   local dCorr2 = max( LayerParams.dTDiam * 0.5 * sin( dAng) - LayerParams.dLayHeight * cos( dAng) - LayerParams.dStrand * 0.5 * sin( dAng) + 10 * GEO.EPS_SMALL, 0.0)
+   return dCorr1 + dCorr2 
+end
+
 --------------------------------------------------------------------
 local function AddLeadIn( nCrvId, LayerParams, nGrpId)
  
    local ptE = EgtSP( nCrvId)
    local vtTang = EgtSV( nCrvId)   
    local vtOrtho = Vector3d( vtTang)
-   local dAng = 90 
+   local dAng = 90
    if ( LayerParams.bInvert and LayerParams.nOrder == PRINT_ORDER.INF_INT_EXT) or 
       ( not LayerParams.bInvert and LayerParams.nOrder == PRINT_ORDER.EXT_INT_INF) then
       dAng = - 90
    end
 
-   vtOrtho:rotate( Z_AX(), dAng)
-   local ptS = ptE - LayerParams.dLeadInTangDist * vtTang + LayerParams.dLeadInOrthoDist * vtOrtho 
-   -- impongo che la coordinata z dei due punti sia la stessa
-   ptS = Point3d( ptS:getX(), ptS:getY(), ptE:getZ())
+   vtOrtho:rotate( LayerParams.vtSlicing, dAng)
+   local ptS = ptE - LayerParams.dLeadInTangDist * vtTang + LayerParams.dLeadInOrthoDist * vtOrtho
 
    local nLeadInCrv = GDB_ID.NULL
    if LayerParams.nLeadInType == LEAD_TYPE.LINEAR then
-      nLeadInCrv = EgtLine( nGrpId, ptS, ptE)       
+      nLeadInCrv = EgtCurveCompoFromPoints( nGrpId, {ptS, ptE})
    elseif LayerParams.nLeadInType == LEAD_TYPE.ARC then
-      local _, _, dAngIni = SphericalFromVector( vtTang)
-      nLeadInCrv = EgtArc2PD( nGrpId, ptE, ptS, 180 + dAngIni) 
+      nLeadInCrv = EgtArc2PV( nGrpId, ptE, ptS, -vtTang)
       EgtInvertCurve( nLeadInCrv)
    end      
    EgtRelocate( nLeadInCrv, nGrpId, GDB_IN.FIRST_SON)   
-   EgtModifyCurveExtrusion( nLeadInCrv, Z_AX(), GDB_RT.GLOB)
+   EgtModifyCurveExtrusion( nLeadInCrv, LayerParams.vtSlicing, GDB_RT.GLOB)
    EgtSetInfo( nLeadInCrv, KEY_TYPE, TYPE.LINK)
-   EgtSetColor( nLeadInCrv, EgtStdColor('GRAY'))
 end
 
 --------------------------------------------------------------------
@@ -78,23 +87,19 @@ local function AddLeadOut( nCrvId, LayerParams, nGrpId)
       ( not LayerParams.bInvert and LayerParams.nOrder == PRINT_ORDER.EXT_INT_INF) then
       dAng = 90
    end
-
-   vtOrtho:rotate( Z_AX(), dAng)
+   
+   vtOrtho:rotate( LayerParams.vtSlicing, dAng)
    local ptE = ptS + LayerParams.dLeadOutTangDist * vtTang + LayerParams.dLeadOutOrthoDist * vtOrtho
-   -- impongo che la coordinata z dei due punti sia la stessa
-   ptE = Point3d( ptE:getX(), ptE:getY(), ptS:getZ())
    
    local nLeadOutCrv = GDB_ID.NULL
    if LayerParams.nLeadOutType == LEAD_TYPE.LINEAR then
-      nLeadOutCrv = EgtLine( nGrpId, ptS, ptE)       
+      nLeadOutCrv = EgtCurveCompoFromPoints( nGrpId, {ptS, ptE})  
    elseif LayerParams.nLeadOutType == LEAD_TYPE.ARC then
-      local _, _, dAngIni = SphericalFromVector( vtTang)
-      nLeadOutCrv = EgtArc2PD( nGrpId, ptS, ptE, dAngIni) 
+      nLeadOutCrv = EgtArc2PV( nGrpId, ptS, ptE, vtTang)      
    end
    EgtRelocate( nLeadOutCrv, nGrpId, GDB_IN.LAST_SON)   
-   EgtModifyCurveExtrusion( nLeadOutCrv, Z_AX(), GDB_RT.GLOB)
+   EgtModifyCurveExtrusion( nLeadOutCrv, LayerParams.vtSlicing, GDB_RT.GLOB)
    EgtSetInfo( nLeadOutCrv, KEY_TYPE, TYPE.LINK)
-   EgtSetColor( nLeadOutCrv, EgtStdColor('GRAY'))
 end
 
 --------------------------------------------------------------------
@@ -134,7 +139,7 @@ end
 --------------------------------------------------------------------
 local function AddRetractionOnLastCrv( nTpathGrpId, LayerParams)
 
-   local nCrvId = EgtGetLastNameInGroup( nTpathGrpId, SHELL_CRV .. "*")
+   local nCrvId = EgtGetLastNameInGroup( nTpathGrpId, SHELL_CRV .. "*")              
    if LayerParams.nLeadOutType == LEAD_TYPE.NONE then
       AddRetraction( nCrvId, LayerParams.dCoastingLen, LayerParams.dWipeLen)
    else
@@ -169,10 +174,12 @@ function CalcToolPath.Exec( nPartId)
       return 
    end
 
+   -- recupero i parametri per calcolo dei toolpath
+   local LayerParams = GetLayerParamsForToolPathCalc()
+      
    -- Ciclo sui layer
    for nIdx = 1, #vLayIds do
-      -- recupero i parametri relativi al layer
-      local LayerParams = GetLayerParamsForToolPathCalc()
+      
       -- scorro tutti i gruppi di contorni
       local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*")
       while nCrvGrpId do
@@ -197,11 +204,15 @@ function CalcToolPath.Exec( nPartId)
          local nEntId = EgtGetFirstInGroup( nPathGrpId)
          while nEntId do
             local nNewEntId = EgtCopyGlob( nEntId, nTpathGrpId, EgtIf( LayerParams.nOrder == PRINT_ORDER.INF_INT_EXT, GDB_IN.FIRST_SON, GDB_IN.LAST_SON))
-            EgtMove( nNewEntId, Vector3d( 0, 0, LayerParams.dLayHeight), GDB_RT.GLOB)
+            -- correggo posizione in Z ( per essere sicuri di appoggiare sul piano)
+            local dCorr = ComputeZCorrection( LayerParams)
+            EgtMove( nNewEntId, dCorr * Z_AX(), GDB_RT.GLOB)
+            -- mi sposto dell'altezza layer
+            EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
             if LayerParams.bInvert then
                EgtInvertCurve( nNewEntId)
             end   
-            EgtModifyCurveExtrusion( nNewEntId, Z_AX(), GDB_RT.GLOB)
+            EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB)
             EgtSetColor( nNewEntId, EgtStdColor('GRAY'))
             nEntId = EgtGetNext( nEntId)
          end
@@ -240,17 +251,20 @@ function CalcToolPath.Exec( nPartId)
                   EgtTrimCurveEndAtLen( nPrevId, EgtCurveLength( nPrevId) - LayerParams.dLinkParam / 2)
                   EgtTrimCurveStartAtLen( nCurrId, LayerParams.dLinkParam / 2)
                   if LayerParams.nLinkType == LINK_TYPE.LINEAR then
-                     nLinkId = EgtLine( nTpathGrpId, EgtEP( nPrevId), EgtSP( nCurrId))
+                     nLinkId = EgtCurveCompoFromPoints( nTpathGrpId, {EgtEP( nPrevId), EgtSP( nCurrId)})
                   elseif LayerParams.nLinkType == LINK_TYPE.BIARC then
-                     local _, _, dAngIni = SphericalFromVector( EgtEV( nPrevId))
-                     local _, _, dAngFin = SphericalFromVector( EgtSV( nCurrId))
-                     nLinkId = EgtBiArc( nTpathGrpId, EgtEP( nPrevId), EgtSP( nCurrId), dAngIni, dAngFin, 0.5)
+                     local frLoc = Frame3d( ORIG(), LayerParams.vtSlicing)
+                     local nGrpTmp = EgtGroup( nTpathGrpId, frLoc)
+                     local _, _, dAngIni = SphericalFromVector( EgtEV( nPrevId, nGrpTmp))
+                     local _, _, dAngFin = SphericalFromVector( EgtSV( nCurrId, nGrpTmp))                    
+                     nLinkId = EgtBiArc( nGrpTmp, EgtEP( nPrevId, nGrpTmp), EgtSP( nCurrId, nGrpTmp), dAngIni, dAngFin, 0.5)
+                     EgtRelocateGlob( nLinkId, nTpathGrpId, GDB_IN.LAST_SON)
+                     EgtErase( nGrpTmp)    
                   end
 
                   if nLinkId then
-                     EgtRelocate( nLinkId, nCurrId, GDB_IN.BEFORE)
-                     EgtSetColor( nLinkId, EgtStdColor('GRAY'))
-                     EgtModifyCurveExtrusion( nLinkId, Z_AX(), GDB_RT.GLOB)
+                     EgtRelocate( nLinkId, nCurrId, GDB_IN.BEFORE)                  
+                     EgtModifyCurveExtrusion( nLinkId, LayerParams.vtSlicing, GDB_RT.GLOB)
                      EgtSetInfo( nLinkId, KEY_TYPE, TYPE.LINK)  
                   end
                end
@@ -277,7 +291,7 @@ function CalcToolPath.Exec( nPartId)
          local nId = EgtGetFirstNameInGroup( nTpathGrpId, SHELL_CRV .. "*")
          local nFirstId = nId
          local nLastId = EgtGetLastNameInGroup( nTpathGrpId, SHELL_CRV .. "*")         
-         while nId do
+         while nId do            
             if nId == nLastId then
                AddRetractionOnLastCrv( nTpathGrpId, LayerParams)
             else
@@ -292,7 +306,7 @@ function CalcToolPath.Exec( nPartId)
                   end
                end
             end
-            nId = EgtGetNextName( nId, SHELL_CRV .. "*")               
+            nId = EgtGetNextName( nId, SHELL_CRV .. "*")
          end
          
          --passo al gruppo di contorni successivo
diff --git a/LuaLibs/RunSlicing.lua b/LuaLibs/RunSlicing.lua
index 9b1b952..33650e5 100644
--- a/LuaLibs/RunSlicing.lua
+++ b/LuaLibs/RunSlicing.lua
@@ -42,6 +42,7 @@ local function LoadParams( sFile, nPartId)
 
    EgtSetInfo( nParamsGrp, INFO_PARTD_ID, nPartId)
 
+   SetParamInfo( sFile, nParamsGrp, DEFAULT_SECTION, KEY_SLICING_45, '0')
    SetParamInfo( sFile, nParamsGrp, DEFAULT_SECTION, KEY_SLICE_STEP, '1.0')
    SetParamInfo( sFile, nParamsGrp, DEFAULT_SECTION, KEY_STRAND, '6.0')
    SetParamInfo( sFile, nParamsGrp, DEFAULT_SECTION, KEY_SHELLS_NBR, '3')
@@ -84,6 +85,7 @@ local function LoadParams( sFile, nPartId)
    SetParamInfo( sFile, nParamsGrp, DEFAULT_SECTION, KEY_SUPPORT_FEED, '0.0')
    SetParamInfo( sFile, nParamsGrp, DEFAULT_SECTION, KEY_G0_FEED, '0.0')  
    SetParamInfo( sFile, nParamsGrp, DEFAULT_SECTION, KEY_MATERIAL, '')
+   SetParamInfo( sFile, nParamsGrp, DEFAULT_SECTION, KEY_TOOL_DIAM, '0.0')
    
    local sLeadInType = EgtGetStringFromIni( DEFAULT_SECTION, KEY_LEAD_IN_TYPE, 'None', sFile)
    if sLeadInType == 'Linear' then