-- CalcToolPath.lua by Egaltech s.r.l. 2022/04/19
-- Calcolo percorsi di lavoro per Stampa 3d

-- Tabella per definizione modulo
local CalcToolPath = {}

-- Intestazioni
require( 'EgtBase')

EgtOutLog( ' CalcToolPath started', 1)

-- Dati
local AMD = require( 'AddManData')

---------------------------------------------------------------------
local s_nPartId

---------------------------------------------------------------------
local function GetLayerParamsForToolPathCalc()
   local LayerParams = {}
   LayerParams.dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd')
   LayerParams.dLayHeight = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd')
   LayerParams.dOffs = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd')
   LayerParams.bInvert = ( EgtGetInfo( s_nPartId, KEY_PRINT_DIRECTION, 'i') == PRINT_DIRECTION.CW)
   LayerParams.nOrder = EgtGetInfo( s_nPartId, KEY_PRINT_ORDER, 'i')
   LayerParams.nLinkType = EgtGetInfo( s_nPartId, KEY_LINK_TYPE, 'i')
   LayerParams.dLinkParam = EgtGetInfo( s_nPartId, KEY_LINK_PARAM, 'd')
   LayerParams.nLeadInType = EgtGetInfo( s_nPartId, KEY_LEAD_IN_TYPE, 'i')
   LayerParams.dLeadInTangDist = EgtGetInfo( s_nPartId, KEY_LEAD_IN_TANG_DIST, 'd')
   LayerParams.dLeadInOrthoDist = EgtGetInfo( s_nPartId, KEY_LEAD_IN_ORTHO_DIST, 'd')
   LayerParams.nLeadOutType = EgtGetInfo( s_nPartId, KEY_LEAD_OUT_TYPE, 'i')
   LayerParams.dLeadOutTangDist = EgtGetInfo( s_nPartId, KEY_LEAD_OUT_TANG_DIST, 'd')
   LayerParams.dLeadOutOrthoDist = EgtGetInfo( s_nPartId, KEY_LEAD_OUT_ORTHO_DIST, 'd')
   LayerParams.dOffsetLP = EgtGetInfo( s_nPartId, KEY_OFFSET_LEAD_POINT, 'd')   
   LayerParams.dSPOffs = EgtGetInfo( s_nPartId, KEY_SP_OFFSET_ON_SLICE, 'd')
   LayerParams.dCoastingLen = EgtGetInfo( s_nPartId, KEY_COASTING_LEN, 'd')
   LayerParams.dWipeLen = EgtGetInfo( s_nPartId, KEY_WIPE_LEN, 'd')
   LayerParams.vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v')
   LayerParams.dTDiam = EgtGetInfo( s_nPartId, KEY_TOOL_DIAM, 'd')
   -- Parametri setti 
   LayerParams.nSettiShellsNbr = EgtGetInfo( s_nPartId, KEY_SETTI_SHELLS_NBR, 'i')
   LayerParams.bSettiLink = EgtGetInfo( s_nPartId, KEY_SETTI_LINK, 'b')
   LayerParams.bSettiInvert = EgtGetInfo( s_nPartId, KEY_SETTI_INVERT, 'b')
   LayerParams.bSettiLIInvert = EgtGetInfo( s_nPartId, KEY_SETTI_LEAD_IN_INVERT, 'b')
   LayerParams.dSettiLILen = EgtGetInfo( s_nPartId, KEY_SETTI_LEAD_IN_LEN, 'd')
   LayerParams.bSettiLOInvert = EgtGetInfo( s_nPartId, KEY_SETTI_LEAD_OUT_INVERT, 'b')
   LayerParams.dSettiLOLen = EgtGetInfo( s_nPartId, KEY_SETTI_LEAD_OUT_LEN, 'd')
   LayerParams.dSettiLOWipeTang = EgtGetInfo( s_nPartId, KEY_SETTI_LEAD_OUT_WIPE1, 'd')
   LayerParams.dSettiLOWipe = EgtGetInfo( s_nPartId, KEY_SETTI_LEAD_OUT_WIPE2, 'd')
   LayerParams.dSettiLOWipeAng = EgtGetInfo( s_nPartId, KEY_SETTI_LEAD_OUT_WIPE_DIR, '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
   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( 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 = EgtCurveCompoFromPoints( nGrpId, {ptS, ptE})
   elseif LayerParams.nLeadInType == LEAD_TYPE.ARC then
      nLeadInCrv = EgtArc2PV( nGrpId, ptE, ptS, -vtTang)
      EgtInvertCurve( nLeadInCrv)
   end      
   EgtRelocate( nLeadInCrv, nGrpId, GDB_IN.FIRST_SON)   
   EgtModifyCurveExtrusion( nLeadInCrv, LayerParams.vtSlicing, GDB_RT.GLOB)
   EgtSetInfo( nLeadInCrv, KEY_TYPE, TYPE.LINK)
end

--------------------------------------------------------------------
local function AddLeadOut( nCrvId, LayerParams, nGrpId)

   local ptS = EgtEP( nCrvId)
   local vtTang = EgtEV( nCrvId)
   local vtOrtho = Vector3d( vtTang)
   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( LayerParams.vtSlicing, dAng)
   local ptE = ptS + LayerParams.dLeadOutTangDist * vtTang + LayerParams.dLeadOutOrthoDist * vtOrtho
   
   local nLeadOutCrv = GDB_ID.NULL
   if LayerParams.nLeadOutType == LEAD_TYPE.LINEAR then
      nLeadOutCrv = EgtCurveCompoFromPoints( nGrpId, {ptS, ptE})  
   elseif LayerParams.nLeadOutType == LEAD_TYPE.ARC then
      nLeadOutCrv = EgtArc2PV( nGrpId, ptS, ptE, vtTang)      
   end
   EgtRelocate( nLeadOutCrv, nGrpId, GDB_IN.LAST_SON)   
   EgtModifyCurveExtrusion( nLeadOutCrv, LayerParams.vtSlicing, GDB_RT.GLOB)
   EgtSetInfo( nLeadOutCrv, KEY_TYPE, TYPE.LINK)
end

--------------------------------------------------------------------
local function AddRetraction( nCrvId, dCoastingLen, dWipeLen)
   
   local nCoastingId
   if dCoastingLen > GEO.EPS_SMALL then
      nCoastingId = EgtCopyGlob( nCrvId, nCrvId, GDB_IN.AFTER)
      local dPar = EgtCurveParamAtLength( nCoastingId, EgtCurveLength( nCoastingId) - dCoastingLen)
      if not dPar then 
         EgtErase( nCoastingId)
         return
      end      
      EgtTrimCurveStartAtParam( nCoastingId, dPar)      
      -- aggiorno la curva originale 
      if dPar > GEO.EPS_SMALL then
         EgtTrimCurveEndAtParam( nCrvId, dPar)
      else
         EgtErase( nCrvId)
      end
      EgtSetName( nCoastingId, COASTING_CRV)
      EgtSetInfo( nCoastingId, KEY_TYPE, TYPE.COASTING)
      EgtSetColor( nCoastingId, EgtStdColor('ORANGE'))
   end

   if dWipeLen > GEO.EPS_SMALL then
      local nWipeId = EgtCopyGlob( nCrvId, EgtIf( nCoastingId, nCoastingId, nCrvId), GDB_IN.AFTER)
      EgtTrimCurveEndAtLen( nWipeId, dWipeLen) 
      EgtSetName( nWipeId, WIPE_CRV)
      EgtSetInfo( nWipeId, KEY_TYPE, TYPE.WIPE)
      EgtSetColor( nWipeId, EgtStdColor('TEAL'))
   end
   
   return nCoastingId
end

--------------------------------------------------------------------
local function AddRetractionOnLastCrv( nTpathGrpId, LayerParams)

   local nCrvId = EgtGetLastNameInGroup( nTpathGrpId, SHELL_CRV .. "*")              
   if LayerParams.nLeadOutType == LEAD_TYPE.NONE then
      AddRetraction( nCrvId, LayerParams.dCoastingLen, LayerParams.dWipeLen)
   else
      local nLeadOutId = EgtGetLastInGroup( nTpathGrpId)
      local dLen = EgtCurveLength( nLeadOutId)
      if dLen > LayerParams.dCoastingLen - 500 * GEO.EPS_SMALL then
         -- coinvolge solo la curva di lead out
         local dNewCoastingLen = EgtIf( abs( LayerParams.dCoastingLen - dLen) < 500 * GEO.EPS_SMALL, dLen, LayerParams.dCoastingLen)   -- verifico se interamente coinvolta 
         AddRetraction( nLeadOutId, dNewCoastingLen, 0.0)
      else
         -- coinvolge parte dell'ultima shell crv
         local dNewCoastingLen = LayerParams.dCoastingLen - dLen
         local nCoastingId = AddRetraction( nCrvId, dNewCoastingLen, 0.0)
         EgtAddCurveCompoCurve( nCoastingId, nLeadOutId)
      end
   end
end

--------------------------------------------------------------------
local function CalcSettiLink( ptS, ptE, nCurr, nLoopGrp)
   
   local nCrvId = EgtGetFirstInGroup( nLoopGrp)
  
   local dParS = EgtCurveParamAtPoint( nCrvId, ptS)
   local dParE = EgtCurveParamAtPoint( nCrvId, ptE)

   if dParS and dParE then
      -- verifico i due percorsi ( dParS->dParE e dParE->dParS)
      local nCopyId1 = EgtCopyGlob( nCrvId, nCurr, GDB_IN.AFTER)
      local nCopyId2 = EgtCopyGlob( nCrvId, nCurr, GDB_IN.AFTER)
      EgtTrimCurveStartEndAtParam( nCopyId1, dParS, dParE)
      EgtTrimCurveStartEndAtParam( nCopyId2, dParE, dParS)
      EgtInvertCurve( nCopyId2)
      
      local dLen1 = EgtCurveLength( nCopyId1)
      local dLen2 = EgtCurveLength( nCopyId2)
      if dLen1 < dLen2 then
         EgtErase( nCopyId2)
         EgtSetInfo( nCopyId1, KEY_TYPE, TYPE.SETTO)
      else
         EgtErase( nCopyId1)
         EgtSetInfo( nCopyId2, KEY_TYPE, TYPE.SETTO)
      end
   end
   
end

--------------------------------------------------------------------
local function AddSettiLeadIn( nCrv, nLoopsGrp, dLeadInLen, bInvert)
   
   if dLeadInLen < GEO.EPS_SMALL then return end
   -- recupero la curva di offset 
   local nCrvOffs = EgtGetFirstInGroup( nLoopsGrp)
   
   local ptS = EgtSP( nCrv)  
   local dParS = EgtCurveParamAtPoint( nCrvOffs, ptS)
   if not dParS then return end
   
   local nCopyOffs = EgtCopyGlob( nCrvOffs, nCrv, GDB_IN.BEFORE)
   EgtChangeClosedCurveStartPoint( nCopyOffs, ptS)
   if bInvert then
      EgtInvertCurve( nCopyOffs)
   end
   EgtTrimCurveEndAtLen( nCopyOffs, dLeadInLen)
   EgtInvertCurve( nCopyOffs)
   EgtSetInfo( nCopyOffs, KEY_TYPE, TYPE.SETTO)
   
end

--------------------------------------------------------------------
local function AddSettiLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams, bInvert)
   
   -- recupero la curva di offset 
   local nCrvOffs = EgtGetFirstInGroup( nLoopsGrp)
   local ptE = EgtEP( nCrv)
   local dParE = EgtCurveParamAtPoint( nCrvOffs, ptE)
   if not dParE then return end
   local vtE = EgtUV( nCrvOffs, dParE, 1)
   if bInvert then vtE = - vtE end 
   local nCrvLO
   local nWipe

   -- primo tratto ( segue offset con flusso aperto)
   if LayerParams.dSettiLOLen > GEO.EPS_SMALL then  
      nCrvLO = EgtCopyGlob( nCrvOffs, nCrv, GDB_IN.AFTER)
      EgtChangeClosedCurveStartPoint( nCrvLO, ptE)
      if bInvert then 
         EgtInvertCurve( nCrvLO) 
      end
      EgtTrimCurveEndAtLen( nCrvLO, LayerParams.dSettiLOLen)
      EgtSetInfo( nCrvLO, KEY_TYPE, TYPE.SETTO)    
      -- aggiorno ptE e vtE
      ptE = EgtEP( nCrvLO)
      vtE = EgtEV( nCrvLO)
   end 

    -- secondo tratto ( segue offset con flusso chiuso) 
   if LayerParams.dSettiLOWipeTang > GEO.EPS_SMALL then  
      nWipe = EgtCopyGlob( nCrvOffs, nCrvLO or nCrv, GDB_IN.AFTER)
      EgtChangeClosedCurveStartPoint( nWipe, ptE)
      if bInvert then 
         EgtInvertCurve( nWipe) 
      end
      EgtTrimCurveEndAtLen( nWipe, LayerParams.dSettiLOWipeTang)
      -- aggiorno ptE e vtE
      ptE = EgtEP( nWipe)
      vtE = EgtEV( nWipe)
   end
   
   -- terzo tratto ( diretto verso esterno con ugello chiuso)
   if LayerParams.dSettiLOWipe > GEO.EPS_SMALL then
      local dAng = EgtIf( bInvert, 90, - 90) + LayerParams.dSettiLOWipeAng
      vtE:rotate( LayerParams.vtSlicing, dAng)
      local ptFinal = ptE + vtE * LayerParams.dSettiLOWipe
      if nWipe then
         -- unisco al secondo tratto così da averne uno solo per il wiping 
         EgtAddCurveCompoLine( nWipe, ptFinal)
      else
         nWipe = EgtCurveCompoFromPoints( nTPathGrp, { ptE, ptFinal})
         EgtRelocateGlob( nWipe, nCrvLO or nCrv, GDB_IN.AFTER)
      end
   end

   if nWipe then
      EgtSetName( nWipe, WIPE_CRV)
      EgtSetInfo( nWipe, KEY_TYPE, TYPE.WIPE)
      EgtSetColor( nWipe, EgtStdColor('TEAL'))
   end

end

---------------------------------------------------------------------
local function CalcSettiToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ)

   local nSettiGrp = EgtGetFirstNameInGroup( nCrvGrp, SETTI_GRP)
   -- aggiungo i setti nel toolpath
   local vEntIds = EgtGetNameInGroup( nSettiGrp, SETTI_CRV .. '*')
   for i = 1, #vEntIds do
      -- copio entità nel gruppo toolpath 
      local nNewEntId = EgtCopyGlob( vEntIds[i], nTpathGrpId, GDB_IN.LAST_SON)
      -- correggo posizione in Z ( per essere sicuri di appoggiare sul piano)
      EgtMove( nNewEntId, dCorrZ * Z_AX(), GDB_RT.GLOB)
      -- mi sposto dell'altezza layer
      EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
      EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB)
      EgtSetColor( nNewEntId, EgtStdColor('GRAY'))      
   end   
  
   -- estraggo i contorni delle superfici di offset   
   local nLoopGrp = EgtGroup( nSettiGrp)
   local nSrfId = EgtGetFirstNameInGroup( nSettiGrp, LAYER_SRF)
   local nChunksNbr = EgtSurfFrChunkCount( nSrfId)
   for i = 0, nChunksNbr do
      local nRes, nCnt = EgtExtractSurfFrChunkLoops( nSrfId, i, nLoopGrp)
      if nRes then 
         for j = nRes, nRes + nCnt - 1 do
            EgtMove( j, dCorrZ * Z_AX(), GDB_RT.GLOB)
            -- mi sposto dell'altezza layer
            EgtMove( j, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
         end 
      end
   end 
   
   -- orientamento delle curve
   local nInd = EgtGetFirstNameInGroup( nTpathGrpId, SETTI_CRV .. '*')
   local bInvert = LayerParams.bSettiInvert 
   while nInd do
      local sName = EgtGetName( nInd) 
      -- considero tutte le passate relative al setto corrente 
      local vIds = EgtGetNameInGroup( nTpathGrpId, sName)
      for i = 1, #vIds do
         if ( bInvert and i % 2 == 1) or ( not bInvert and i % 2 == 0) then
            EgtInvertCurve( vIds[i])
         end
      end
       -- passo al gruppo di setti successivo 
      nInd = EgtGetNextName( vIds[#vIds], SETTI_CRV .. '*')
      -- aggiorno bInvert per il gruppo successivo 
      if LayerParams.bSettiLink and LayerParams.nSettiShellsNbr % 2 == 1 then
         bInvert = not bInvert
      end
   end   
  
   -- collegamenti 
   local vSettiIds = EgtGetNameInGroup( nTpathGrpId, SETTI_CRV .. '*')
   for i = 1, #vSettiIds - 1 do
      local sNameCurr = EgtGetName( vSettiIds[i])
      local sNameNext = EgtGetName( vSettiIds[i + 1])
      
      local ptS = EgtEP( vSettiIds[i])
      local ptE = EgtSP( vSettiIds[i + 1])
      if LayerParams.bSettiLink then
         CalcSettiLink( ptS, ptE, vSettiIds[i], nLoopGrp)
      else
         -- collego solo le passate dello stesso setto
         if sNameCurr == sNameNext then
            CalcSettiLink( ptS, ptE, vSettiIds[i], nLoopGrp)
         end
      end
   end   

   -- leadin/leadout
   local bInvertLI = EgtIf( LayerParams.nSettiShellsNbr == 1, LayerParams.bSettiLIInvert, not LayerParams.bSettiInvert)
   local bInvertLO = LayerParams.bSettiLOInvert   
      
   if LayerParams.bSettiLink then
      -- aggiungo ingresso e uscita solo sul primo e sull'ultimo setto
      local nFirst = EgtGetFirstNameInGroup( nTpathGrpId, SETTI_CRV .. '*')      
      if nFirst then AddSettiLeadIn( nFirst, nLoopGrp, LayerParams.dSettiLILen, bInvertLI) end
      local nLast = EgtGetLastNameInGroup( nTpathGrpId, SETTI_CRV .. '*')
      if LayerParams.nSettiShellsNbr > 1 then
         bInvertLO = EgtIf( #vEntIds % 2 == 0, not bInvertLI, bInvertLI)
      end
      if nLast then AddSettiLeadOut( nLast, nTpathGrpId, nLoopGrp, LayerParams, bInvertLO) end
   else
      local nFirst = EgtGetFirstNameInGroup( nTpathGrpId, SETTI_CRV .. '*')
      while nFirst do
         local sName = EgtGetName( nFirst)
         local vEnt = EgtGetNameInGroup( nTpathGrpId, sName)
         AddSettiLeadIn( nFirst, nLoopGrp, LayerParams.dSettiLILen, bInvertLI)
         if LayerParams.nSettiShellsNbr > 1 then
            bInvertLO = EgtIf( #vEnt % 2 == 0, not bInvertLI, bInvertLI)
         end
         AddSettiLeadOut( vEnt[#vEnt], nTpathGrpId, nLoopGrp, LayerParams, bInvertLO)          
         nFirst = EgtGetNextName( vEnt[#vEnt], SETTI_CRV .. '*')
      end
   end

end

---------------------------------------------------------------------
function CalcToolPath.Exec( nPartId)

   s_nPartId = nPartId

   -- Verifico il pezzo
   if not s_nPartId then
      EgtOutBox( 'Error missing part', 'ToolPathCalc')
      return 
   end

   -- Recupero i layer da processare
   local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*") 
   if not vLayIds then
      EgtOutBox( 'Error missing slices', 'ToolPathCalc')
      return 
   end

   -- recupero i parametri per calcolo dei toolpath
   local LayerParams = GetLayerParamsForToolPathCalc()
   local dCorrZ = ComputeZCorrection( LayerParams)
   
   -- Ciclo sui layer
   for nIdx = 1, #vLayIds do
      
      -- scorro tutti i gruppi di contorni
      local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*")
      while nCrvGrpId do
         -- recupero il gruppo dei percorsi
         local nPathGrpId = EgtGetFirstNameInGroup( nCrvGrpId, PATH_GRP)
         if not nPathGrpId then
            EgtOutBox( 'Error missing paths', 'ToolPathCalc')
            return 
         else
            EgtSetStatus( nPathGrpId, GDB_ST.OFF)
         end         
         -- recupero il gruppo dei percorsi utensile
         local nTpathGrpId = EgtGetFirstNameInGroup( nCrvGrpId, TOOLPATH_GRP)
         if not nTpathGrpId then
            nTpathGrpId = EgtGroup( nCrvGrpId)
            EgtSetName( nTpathGrpId, TOOLPATH_GRP)
         else
            EgtEmptyGroup( nTpathGrpId)
         end
         -- creo il percorso di lavoro :
         -- copio le curve, le ordino, le oriento e le muovo in Z
         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))
            -- correggo posizione in Z ( per essere sicuri di appoggiare sul piano)            
            EgtMove( nNewEntId, dCorrZ * 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, LayerParams.vtSlicing, GDB_RT.GLOB)
            EgtSetColor( nNewEntId, EgtStdColor('GRAY'))
            nEntId = EgtGetNext( nEntId)
         end

         -- aggiungo gli opportuni raccordi
         local nPrevId = EgtGetFirstInGroup( nTpathGrpId)
         local nCurrId = EgtGetNext( nPrevId or GDB_ID.NULL)
         k = 0
         local nPrevShellNbr
         if nPrevId then nPrevShellNbr = tonumber( EgtGetName( nPrevId):sub(6)) end
         while nCurrId do

            local nCurrShellNbr = tonumber( EgtGetName( nCurrId):sub(6))
            if nCurrShellNbr ~= nPrevShellNbr then k = k + 1 end

            -- se nessun raccordo modifico solo lo start point della curva
            if LayerParams.nLinkType == LINK_TYPE.NONE then
               local dLen = k * LayerParams.dSPOffs 
               if LayerParams.dSPOffs < 0 then
                  dLen = EgtCurveLength( nCurrId) + dLen
               end
               local dPar = EgtCurveParamAtLength( nCurrId, dLen)
               if dPar then EgtChangeClosedCurveStart( nCurrId, dPar) end
               
            else
               -- altrimenti verifico se ha senso creare raccordo
               if abs( dist( EgtEP( nPrevId), EgtSP( nCurrId))) <  LayerParams.dStrand + 10 then   
                  local nLinkId
                  if k > 1 then
                     -- modifico lo start point
                     local dLen = EgtCurveLength( nPrevId) - abs( LayerParams.dSPOffs)
                     EgtTrimCurveEndAtLen( nPrevId, dLen)
                     EgtChangeClosedCurveStartPoint( nCurrId, EgtEP( nPrevId))
                  end
                  -- aggiungo il raccordo
                  EgtTrimCurveEndAtLen( nPrevId, EgtCurveLength( nPrevId) - LayerParams.dLinkParam / 2)
                  EgtTrimCurveStartAtLen( nCurrId, LayerParams.dLinkParam / 2)
                  if LayerParams.nLinkType == LINK_TYPE.LINEAR then
                     nLinkId = EgtCurveCompoFromPoints( nTpathGrpId, {EgtEP( nPrevId), EgtSP( nCurrId)})
                  elseif LayerParams.nLinkType == LINK_TYPE.BIARC then
                     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)                  
                     EgtModifyCurveExtrusion( nLinkId, LayerParams.vtSlicing, GDB_RT.GLOB)
                     EgtSetInfo( nLinkId, KEY_TYPE, TYPE.LINK)  
                  end
               end
            end
          
            nPrevShellNbr = nCurrShellNbr
            nPrevId = nCurrId    
            nCurrId = EgtGetNext( nCurrId)
         end
         
         -- aggiungo leadin/leadout
         local nFirstCurve = EgtGetFirstInGroup( nTpathGrpId)
         if nFirstCurve and LayerParams.nLeadInType ~= LEAD_TYPE.NONE then
            EgtTrimCurveStartAtLen( nFirstCurve, LayerParams.dOffsetLP)
            AddLeadIn( nFirstCurve, LayerParams, nTpathGrpId)
         end
         local nLastCurve = EgtGetLastInGroup( nTpathGrpId)
         if nLastCurve and LayerParams.nLeadOutType ~= LEAD_TYPE.NONE then
            EgtTrimCurveEndAtLen( nLastCurve, EgtCurveLength( nLastCurve) - LayerParams.dOffsetLP)
            AddLeadOut( nLastCurve, LayerParams, nTpathGrpId)
         end
       
         -- aggiungo coasting/wipe
         local nId = EgtGetFirstNameInGroup( nTpathGrpId, SHELL_CRV .. "*")
         local nFirstId = nId
         local nLastId = EgtGetLastNameInGroup( nTpathGrpId, SHELL_CRV .. "*")         
         while nId do            
            if nId == nLastId then
               AddRetractionOnLastCrv( nTpathGrpId, LayerParams)
            else
               local nNextId = EgtGetNext( nId)
               if EgtGetInfo( nNextId, KEY_TYPE, 'i') ~= TYPE.LINK then
                  -- aggiungo retrazione
                  if nId == nFirstId then
                     local dWipeLen = EgtIf( LayerParams.nLeadInType == LEAD_TYPE.NONE, LayerParams.dWipeLen, 0)
                     AddRetraction( nId, LayerParams.dCoastingLen, dWipeLen)
                  else
                     AddRetraction( nId, LayerParams.dCoastingLen, LayerParams.dWipeLen)
                  end
               end
            end
            nId = EgtGetNextName( nId, SHELL_CRV .. "*")
         end
         
         -- sistemo i setti 
         local nSettiGrp = EgtGetFirstNameInGroup( nCrvGrpId, SETTI_GRP)
         if nSettiGrp then 
            CalcSettiToolPath( nCrvGrpId, nTpathGrpId, LayerParams, dCorrZ)
         end
         
         --passo al gruppo di contorni successivo
         nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*")
      end
   end   
end

---------------------------------------------------------------------
return CalcToolPath