-- RunCalcSolids.lua by Egaltech s.r.l. 2022/11/02
-- Calcolo percorsi di lavoro per Stampa 3d

-- Tabella per definizione modulo
local RunCalcSolids = {}

-- Intestazioni
require( 'EgtBase')

EgtOutLog( ' RunCalcSolids started', 1)

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

--------------------------------------------------------------------
local s_dTol = 0.1
local s_nSimplifiedSection = 0
local s_dMultiPlanarH = 0
local s_dColorFactor = 0.9
local s_nPartId

---------------------------------------------------------------------
local function GetLayerParamsForSolidCalc( nPartId)
   local LayerParams = {}
   LayerParams.bSpiralVase = EgtGetInfo( nPartId, KEY_SPIRAL_VASE, 'b') or false
   LayerParams.dLayHeight = EgtGetInfo( nPartId, KEY_SLICE_STEP, 'd')
   LayerParams.vtSlicing = EgtGetInfo( nPartId, KEY_SLICE_DIR, 'v') or EgtGetInfo( nPartId, 'SlicingDir', 'v')
   LayerParams.dStrand = EgtGetInfo( nPartId, KEY_STRAND, 'd')
   LayerParams.vtCorr = EgtGetInfo( nPartId, KEY_MOVED_PART2, 'v') or V_NULL()
   return LayerParams
end

---------------------------------------------------------------------
local function CalcSectionParams( dStrand, dH)
   local dBevelX = 0
   local dBevelY = 0
   if s_nSimplifiedSection == 0 then
      -- sezione ottagonale
      dBevelX = dStrand / 10
      dBevelY = dH / 6
   end
   return dBevelX, dBevelY
end

----------------------------------------------------------------------
local function CreateStandardSolid( nCrvId, nSolidGrp, dH, dStrand)
   
   local dBevelX, dBevelY = CalcSectionParams( dStrand, dH)
   local nSrfId = EgtSurfTmRectSwept( nSolidGrp, dStrand, dH, dBevelX, dBevelY, nCrvId, GDB_RSCT.BEVEL, s_dTol)
   return nSrfId
end

---------------------------------------------------------------------
local function CreateSection( ptS, vtDir, dStrand, dH, vtSlicing, nSolidGrp)

   local dBevelX, dBevelY = CalcSectionParams( dStrand, dH)
   local ptA = ptS - dH * vtSlicing  + ( 0.5 * dStrand - dBevelX) * vtDir
   local ptB = ptA + dBevelY * vtSlicing + dBevelX * vtDir
   local ptC = ptB + ( dH - 2 * dBevelY) * vtSlicing
   local ptD = ptA + dH * vtSlicing
   local ptE = ptD - ( dStrand - 2 * dBevelX) * vtDir
   local ptF = ptC - dStrand * vtDir
   local ptG = ptB - dStrand * vtDir
   local ptH = ptA - ( dStrand - 2 * dBevelX) * vtDir
   
   local nId = EgtCurveCompoFromPoints( nSolidGrp, {ptA, ptB, ptC, ptD, ptE, ptF, ptG, ptH, ptA}, GDB_RT.GLOB)
   EgtInvertCurve( nId)
   
   return nId
end

------------------------------------------------------------------------------
local function CreateSpiralVaseCap( nSectId, vtDir, nSolidGrp)
   
   local vPt = {}
   local nLast = EgtIf( s_nSimplifiedSection == 1, 3, 7)
   for i = 0, nLast do
      vPt[i + 1] = EgtUP( nSectId, i, GDB_ID.ROOT)
   end
   
   local vCrvs = {}
   -- calcolo gli archi che definiscono la superficie laterale
   if s_nSimplifiedSection == 1 then
      -- sezione quadrata
      vCrvs[1] = EgtArc2PV( nSolidGrp, vPt[1], vPt[2], vtDir, GDB_RT.GLOB)
      vCrvs[2] = EgtArc2PV( nSolidGrp, vPt[4], vPt[3], vtDir, GDB_RT.GLOB)
   else
      -- sezione ottagonale
      vCrvs[1] = EgtArc2PV( nSolidGrp, vPt[1], vPt[2], vtDir, GDB_RT.GLOB)
      vCrvs[2] = EgtArc2PV( nSolidGrp, vPt[8], vPt[3], vtDir, GDB_RT.GLOB)
      vCrvs[3] = EgtArc2PV( nSolidGrp, vPt[7], vPt[4], vtDir, GDB_RT.GLOB)
      vCrvs[4] = EgtArc2PV( nSolidGrp, vPt[6], vPt[5], vtDir, GDB_RT.GLOB)
   end
   -- creo le rigate
   local vSurfs = {}
   for i = 1, #vCrvs - 1 do
      vSurfs[i] = EgtSurfTmRuled( nSolidGrp, vCrvs[i], vCrvs[i+1], GDB_RUL.ISOPAR, s_dTol)
   end
   -- calcolo le superfici top e bottom del cap
   local nCrvBottom = EgtCurveCompo( nSolidGrp, {vCrvs[1]}, false, GDB_RT.GLOB)
   EgtCloseCurveCompo( nCrvBottom)
   local nSurfBottom = EgtSurfTmByRegion( nSolidGrp, nCrvBottom, s_dTol)
   local nCrvTop = EgtCurveCompo( nSolidGrp, {vCrvs[#vCrvs]}, false, GDB_RT.GLOB)
   EgtCloseCurveCompo( nCrvTop)
   local nSurfTop = EgtSurfTmByRegion( nSolidGrp, nCrvTop, s_dTol)
   table.insert( vSurfs, nSurfTop)
   table.insert( vSurfs, nSurfBottom)
   
   local nCapSrf = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
   
   -- cancello curve di costruzione
   EgtErase( vCrvs)
   EgtErase( nCrvTop)
   EgtErase( nCrvBottom)
   
   return nCapSrf
end

-------------------------------------------------------------------------------
local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, vtSlicing, dH, dStrand)
   
   -- gruppo temporaneo per conti 
   local nGrpTmp = EgtGroup( nSolidGrp, Frame3d( ORIG(), vtSlicing, GDB_RT.GLOB))
   
   -- accorcio leggermente la curva per evitare problemi di inconsistent orientation nel solido
   local dLen = EgtCurveLength( nCrvId)
   EgtTrimCurveEndAtLen( nCrvId, dLen - 20 * GEO.EPS_SMALL)
   
   local ptS = EgtSP( nCrvId, GDB_ID.ROOT)
   local vtS = EgtSV( nCrvId, GDB_ID.ROOT)
   local ptE = EgtEP( nCrvId, GDB_ID.ROOT)
   local vtE = EgtEV( nCrvId, GDB_ID.ROOT)
   local dDelta = ( ptE - ptS) * vtSlicing
   -- se non è vero spiral vase, chiamo funzione standard
   if dDelta < GEO.EPS_SMALL then
      EgtErase( nGrpTmp)
      return CreateStandardSolid( nCrvId, nSolidGrp, dH, dStrand)
   end
   
   -- appiattisco la curva
   local nCrvCopy = EgtCopyGlob( nCrvId, nGrpTmp)
   EgtModifyCurveExtrusion( nCrvCopy, vtSlicing, GDB_RT.GLOB)
   EgtProjectCurveOnPlane( nCrvCopy, ptS, vtSlicing, GDB_RT.GLOB)
   EgtMergeCurvesInCurveCompo( nCrvCopy)
   EgtChangeClosedCurveStartPoint( nCrvCopy, ptS, GDB_RT.GLOB)
  
   -- calcolo la sezione iniziale
   local vtDir = EgtSV( nCrvCopy, GDB_ID.ROOT)
   vtDir:rotate( vtSlicing, 90)
   local nSectId = CreateSection( ptS, vtDir, dStrand, dH, vtSlicing, nGrpTmp)
   -- creo la sezione finale
   local vtDir2 = EgtEV( nCrvCopy, GDB_ID.ROOT)
   vtDir2:rotate( vtSlicing, 90)
   local nSectE = CreateSection( ptE, vtDir2, dStrand, dH, vtSlicing, nGrpTmp)
   
   -- creo il solido aperto (tubo)
   local vCrvs = {}
   local _, dParE = EgtCurveDomain( nSectId)
   for i = 0, dParE do
      local ptRef = EgtUP( nSectId, i, GDB_ID.ROOT)
      local dOffs = ( ptS - ptRef) * vtDir
      vCrvs[i+1] = EgtOffsetCurveAdv( nCrvCopy, dOffs)
      if not vCrvs[i+1] or vCrvs[i+1] == GDB_ID.NULL then
         EgtErase( nGrpTmp)
         return nil
      end
      local dMove = ( ptRef - ptS) * vtSlicing
      EgtMove( vCrvs[i+1], vtSlicing * dMove, GDB_RT.GLOB)
      EgtSpiralizeCurveAlongExtrusion( vCrvs[i+1], dDelta)

      -- modifico la curva per congiungerla ai caps
      EgtApproxCurve( vCrvs[i+1], GDB_CA.LINES, s_dTol)
      EgtModifyCurveStartPoint( vCrvs[i+1], ptRef, GDB_RT.GLOB)
      local ptRefEnd = EgtUP( nSectE, i, GDB_ID.ROOT)
      local _, _, dParMinDist = EgtPointCurveDist( ptRefEnd, vCrvs[i+1], GDB_ID.ROOT)
      local _, dParE = EgtCurveDomain( vCrvs[i+1])
      if abs( dParE - dParMinDist) > GEO.EPS_SMALL and dParMinDist > 0.5 * dParE then
         EgtTrimCurveEndAtParam( vCrvs[i+1], dParMinDist)
      end
      EgtModifyCurveEndPoint( vCrvs[i+1], ptRefEnd, GDB_RT.GLOB)
   end
   
   local vSurfs = {}
   for i = 1, #vCrvs - 1 do
      vSurfs[i] = EgtSurfTmRuled( nGrpTmp, vCrvs[i], vCrvs[i+1], GDB_RUL.MINDIST, s_dTol)
      if not vSurfs[i] or vSurfs[i] == GDB_ID.NULL then
         EgtErase( nGrpTmp)
         return nil
      end
   end
   
   -- creazione del mezzo disco iniziale
   vSurfs[#vCrvs] = CreateSpiralVaseCap( nSectId, - vtS, nSolidGrp)
   -- creazione del mezzo disco finale
   vSurfs[#vCrvs+1] = CreateSpiralVaseCap( nSectE, vtE, nSolidGrp)
   EgtInvertSurf( vSurfs[#vCrvs+1])

   local nSolidId = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
   
   -- cancello le curve usate per la costruzione
   EgtErase( nGrpTmp)

   return nSolidId
end

--------------------------------------------------------------------------------------
local function CreateSolid( nCrvId, nSolidGrp, LayerParams, dH, dStrand)
   if LayerParams.bSpiralVase then
      return CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams.vtSlicing, dH, dStrand)
   else
      return CreateStandardSolid( nCrvId, nSolidGrp, dH, dStrand)
   end
end

---------------------------------------------------------------------
local function CreateDirectionArrow( nCrvId, nSolidGrp, vtSlicing, dStrand, nSliceNbr)
   
   local ptS = EgtSP( nCrvId, GDB_RT.GLOB)
   local vtS = EgtSV( nCrvId, GDB_RT.GLOB)
   local dCrvLen = EgtCurveLength( nCrvId)
   if dCrvLen > 2 * dStrand then
      local dPar = EgtCurveParamAtLength( nCrvId, 4/5 * dStrand)
      ptS = EgtUP( nCrvId, dPar, GDB_RT.GLOB)
      vtS = EgtUV( nCrvId, dPar, -1, GDB_RT.GLOB)
   end
      
   local vt2 = Vector3d( vtS)
   vt2:rotate( vtSlicing, 90)
   local dLen = 4/5 * dStrand
   local pt1 = ptS + 0.5 * dLen * vt2
   local pt2 = ptS - 0.5 * dLen * vt2
   local pt3 = ptS + vtS * dLen
   local nCompo = EgtCurveCompoFromPoints( nSolidGrp, { pt1, pt2, pt3, pt1}, GDB_RT.GLOB)
   EgtMove( nCompo, 100 * GEO.EPS_SMALL * vtSlicing, GDB_RT.GLOB)
   local nSrf = EgtSurfFlatRegion( nSolidGrp, { nCompo})
   EgtErase( nCompo)
   EgtSetColor( nSrf, RED())
   EgtSetInfo( nSrf, KEY_SLICE_NBR, nSliceNbr)
   EgtSetStatus( nSrf, GDB_ST.OFF)
   EgtSetMode( nSrf, GDB_MD.HIDDEN)
   EgtSetName( nSrf, DIR_ARROW)
   
end

---------------------------------------------------------------------
local function CreateRecursiveSolid( nCrvId, vSurfs, nSolidGrp, LayerParams, dH, dStrand)

   -- tento la creazione del solido
   local nSurf = CreateSolid( nCrvId, nSolidGrp, LayerParams, dH, dStrand - 50 * GEO.EPS_SMALL)
   if nSurf then
      EgtErase( nCrvId)
      table.insert( vSurfs, nSurf)
      return true
   else
      -- se curva singola esco perchè non è possibile spezzare ulteriormente
      local _, dParE = EgtCurveDomain( nCrvId)
      if abs( dParE - 1) < GEO.EPS_SMALL then
         EgtErase( nCrvId)
         return false
      end
      -- se non si tratta di curva singola, spezzo a metà e tento sulle due sottocurve
      local dParSplit = floor( dParE / 2 + 0.5)
      local nCrvSplit = EgtSplitCurveAtParam( nCrvId, dParSplit)
      if not nCrvSplit then
         -- errore nello split
         EgtErase( nCrvId)
         return false
      end
      local bOk = CreateRecursiveSolid( nCrvId, vSurfs, nSolidGrp, LayerParams, dH, dStrand)
      bOk = bOk and CreateRecursiveSolid( nCrvSplit, vSurfs, nSolidGrp, LayerParams, dH, dStrand)
      return bOk
   end
end

---------------------------------------------------------------------
local function CalcSolidGuides( nCrvId, dStrand, nSolidGrp)
   
   -- suddivido la curva in modo opportuno
   local nCopyId = EgtCopyGlob( nCrvId, nSolidGrp)
   local nId
   local nParts = 1
   local LEN_REF = 100
   local bZigZagInfill = EgtGetInfo( nCopyId, KEY_ZIG_ZAG_INFILL, 'b') or false
   if bZigZagInfill then
      nId, nParts = EgtSplitCurveAtCorners( nCopyId, 80)
   else
      local nType = EgtGetInfo( nCrvId, KEY_TYPE, 'i')
      local dLen = EgtCurveLength( nCrvId)
      if dLen > LEN_REF and nType ~= TYPE.LINK and nType ~= TYPE.COASTING then
         nParts = EgtClamp( floor( dLen / LEN_REF), 1, 10)
      end
      nId = EgtSplitCurve( nCopyId, nParts)
   end
   
   if not nId then return end
   
   -- verifico in modo euristico se la curva torna indietro su se stessa come se fossero due shell collegate ( verifico se è presente un sottotratto di lunghezza 
   -- circa pari allo strand non in tangenza con i sottotratti vicini). Nel caso la spezzo per evitare problemi nel calcolo di solidi swept
   local vGuideIds = {}
   for nInd = 0, nParts - 1 do
      local nGuideId = nId + nInd
      table.insert( vGuideIds, nGuideId)
      if EgtGetType( nGuideId) == GDB_TY.CRV_COMPO then
         local _, dE = EgtCurveDomain( nGuideId)
         for dU = 1, dE - 2 do
            local dLen = EgtCurveCompoLength( nGuideId, dU)
            if abs( dLen - dStrand) < 500 * GEO.EPS_SMALL then
               -- verifico gli angoli
               local vtPrev = EgtUV( nGuideId, dU, -1, GDB_ID.ROOT)
               local vtCurrS = EgtUV( nGuideId, dU, 1, GDB_ID.ROOT)
               local vtCurrE = EgtUV( nGuideId, dU + 1, -1, GDB_ID.ROOT)
               local vtNext = EgtUV( nGuideId, dU + 1, 1, GDB_ID.ROOT)
               if vtPrev * vtCurrS < GEO.EPS_SMALL and vtCurrE * vtNext < GEO.EPS_SMALL then
                  local nNewId = EgtSplitCurveAtParam( nGuideId, dU + 0.5)
                  table.insert( vGuideIds, nNewId)
                  break
               end
            end
         end
      end
   end
   
   return vGuideIds
end

---------------------------------------------------------------------
local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nSliceNbr, dLayerH)
  
   local nType = EgtGetInfo( nCrvId, KEY_TYPE, 'i')
   if nType == TYPE.WIPE then return true end 
   -- scelta del colore
   local Color = EgtStdColor( 'GRAY')
   if nType == TYPE.OUTER_SHELL or nType == TYPE.EXTRA_OUTER_SHELL then 
      Color = EgtStdColor( 'TEAL')
   elseif nType == TYPE.INNER_SHELL or nType == TYPE.EXTRA_SHELL then
      Color = EgtStdColor( 'ORANGE')
   elseif nType == TYPE.LINK then
      Color = EgtStdColor( 'GRAY')
   elseif nType == TYPE.INFILL then
      Color = EgtStdColor( 'YELLOW')
   elseif nType == TYPE.COASTING then
      Color = EgtStdColor( 'BLUE')
   elseif nType == TYPE.RIB then
      Color = EgtStdColor( 'OLIVE')
   elseif nType == TYPE.AUX_SOLID then
      Color = EgtStdColor( 'AQUA')
   end
   
   if s_nSimplifiedSection == 1 and nSliceNbr % 2 == 0 then
      Color = Color3d( s_dColorFactor * Color:getRed(), s_dColorFactor * Color:getGreen(), s_dColorFactor * Color:getBlue())
   end
   
   -- parametri della passata
   local dStrand = EgtGetInfo( nCrvId, KEY_CRV_STRAND, 'd') or LayerParams.dStrand
   local dH = dLayerH or LayerParams.dLayHeight

   -- freccia direzionale
   local sName = EgtGetName( nCrvId)
   if nType ~= TYPE.COASTING and nType ~= TYPE.LINK and sName ~= LEAD_IN_CRV and sName ~= LEAD_OUT_CRV and sName ~= LINK_CRV then
      CreateDirectionArrow( nCrvId, nSolidGrp, LayerParams.vtSlicing, dStrand, nSliceNbr)
   end
   
   -- spezzo la curva guida in diversi sottotratti per i quali calcolare i solidi
   local vGuideIds = CalcSolidGuides( nCrvId, dStrand, nSolidGrp)
   if not vGuideIds then
      return false
   end

   local bOk = true
   for i = 1, #vGuideIds do
      local nSrfId = CreateSolid( vGuideIds[i], nSolidGrp, LayerParams, dH, dStrand - 5 * GEO.EPS_SMALL)
      if not nSrfId then
         EgtOutLog( 'Warning : CreateSolid failed '.. '(layer '..tostring( nSliceNbr)..', curve '..tostring( nCrvId)..')')
         -- ritento con strand più piccolo
         nSrfId = CreateSolid( vGuideIds[i], nSolidGrp, LayerParams, dH, dStrand - 50 * GEO.EPS_SMALL)
         
         if not nSrfId then
            EgtOutLog( 'Warning : CreateSolid_1 failed '.. '(layer '..tostring( nSliceNbr)..', curve '..tostring( nCrvId)..')')
            -- se non ultima, provo a spostare l'estremità finale
            if i < #vGuideIds then
               local nCopyId = EgtCopy( vGuideIds[i] + 1, vGuideIds[i], GDB_IN.AFTER)
               if nCopyId then
                  local LEN_TRIM = 10
                  local bOk1 = EgtTrimCurveEndAtLen( nCopyId, LEN_TRIM)
                  local bOk2 = EgtAddCurveCompoCurve( vGuideIds[i], nCopyId)
                  local bOk3 = EgtTrimCurveStartAtLen( vGuideIds[i] + 1, LEN_TRIM)
                  nSrfId = CreateSolid( vGuideIds[i], nSolidGrp, LayerParams, dH, dStrand - 5 * GEO.EPS_SMALL)
                  if not nSrfId then
                     nSrfId = CreateSolid( vGuideIds[i], nSolidGrp, LayerParams, dH, dStrand - 50 * GEO.EPS_SMALL)
                  end
               end
            end
         end
         
         -- ritento spezzando la curva in modo ricorsivo fino ad inidividuare delle sottocurve su cui è possibile calcolare il solido
         if not nSrfId then
            EgtOutLog( 'Warning : CreateSolid_2 failed')
            local nGrp = EgtGroup( nSolidGrp, Frame3d( ORIG(), LayerParams.vtSlicing), GDB_RT.GLOB)
            EgtRelocateGlob( vGuideIds[i], nGrp)
            EgtApproxCurve( vGuideIds[i], GDB_CA.LINES, 100 * GEO.EPS_SMALL)
            EgtRelocateGlob( vGuideIds[i], nSolidGrp)

            local vSurfs = {}
            local bOk = CreateRecursiveSolid( vGuideIds[i], vSurfs, nSolidGrp, LayerParams, dH, dStrand)
            if #vSurfs > 0 then
               nSrfId = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
            end
            if not nSrfId or bOk == false then
               EgtOutLog( 'Warning : CreateSolid_3 failed')
            end
            EgtErase( nGrp)
         end
      end

      if nSrfId then
         EgtSetColor( nSrfId, Color)
         EgtSetInfo( nSrfId, KEY_TYPE, nType)
         EgtSetInfo( nSrfId, KEY_SLICE_NBR, nSliceNbr)
      else
         bOk = false
         EgtOutLog( 'Warning : CreateSolid_Sewing failed')
      end
      EgtErase( vGuideIds[i])
   end
   
   return bOk
end

--------------------------------------------------------------------
------------------------- MULTIPLANAR ------------------------------
--------------------------------------------------------------------
local function CreateMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, nLayerId, bFirst)
   
   -- creo solidi standard con spessore massimo ammesso ( tranne nel primo layer che viene fatto ad altezza costante)
   local nSliceNbr = EgtGetInfo( nLayerId, KEY_SLICE_NBR, 'i')
   local dH = EgtIf( bFirst, LayerParams.dLayHeight, s_dMultiPlanarH)
   for i = 1, #vIds do
      CreateSolidFromCurve( vIds[i], nSolidGrpId, LayerParams, nSliceNbr, dH)
   end
   
   -- deformo i solidi per rispettare l'altezza reale della passata
   if not bFirst then
      local ptSlicing = EgtGetInfo( nLayerId, KEY_SLICE_POS, 'p') + LayerParams.vtSlicing * LayerParams.dLayHeight + LayerParams.vtCorr
      local nPrevLayerId = EgtGetPrev( nLayerId)
      local vtSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_DIR, 'v')
      local ptSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_POS, 'p') + vtSlicingPrev * LayerParams.dLayHeight + LayerParams.vtCorr
      local dCosAng = vtSlicingPrev * LayerParams.vtSlicing
      
      local vSolids = EgtGetAllInGroup( nSolidGrpId)
      for i = 1, #vSolids do
         local nVertexCnt = EgtSurfTmVertexCount( vSolids[i])
         for j = 0, nVertexCnt - 1 do
            local ptVertex = EgtSurfTmGetVertex( vSolids[i], j, GDB_RT.GLOB)
            -- distanza dal piano di slicing corrente e precedente lungo vtSlicing
            local dDistCurr = abs( ( ptVertex - ptSlicing) * LayerParams.vtSlicing)
            local dDistPrev = ( ptVertex - ptSlicingPrev) * vtSlicingPrev / dCosAng
            -- calcolo la nuova posizione sapendo che l'altezza dello strand passa da s_dMultiPlanarH a dNewH
            local dNewH = dDistCurr + dDistPrev
            local dDelta = dDistCurr - dDistCurr * dNewH / s_dMultiPlanarH
            local ptNew = ptVertex + dDelta * LayerParams.vtSlicing
            EgtSurfTmMoveVertex( vSolids[i], j, ptNew, GDB_RT.GLOB, ( j == nVertexCnt - 1))
         end
      end
   end
end

---------------------------------------------------------------------
local function CreatePartialSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, nLayerId, bFirst)
   
   -- 1) le prime curve sono solidi multiplanari standard
   for i = 1, #vIds - 1 do
      CreateMultiPlanarSolids( { vIds[i]}, nSolidGrpId, LayerParams, nLayerId, bFirst)
   end
   
   -- 2) l'ultima curva è il tratto che si alza fino al layer successivo
   local nGrpTmp = EgtGroup( nSolidGrpId)
   local dStrand = EgtGetInfo( vIds[#vIds], KEY_CRV_STRAND, 'd') or LayerParams.dStrand
   
   -- a) calcolo il solido
   -- appiattisco la curva ( proiezione obliqua sul piano corrente lungo vtSlicing del piano successivo)
   local nNextLayerId = EgtGetNext( nLayerId)
   local vtSlicingNext = EgtGetInfo( nNextLayerId, KEY_SLICE_DIR, 'v')
   local ptSlicing = EgtGetInfo( nLayerId, KEY_SLICE_POS, 'p') + LayerParams.dLayHeight * LayerParams.vtSlicing + LayerParams.vtCorr
   local nProjCrv = EgtCopyGlob( vIds[#vIds], nGrpTmp)
   local _, dE = EgtCurveDomain( nProjCrv)
   for dU = 0, dE do
      local ptCurr = EgtUP( nProjCrv, dU, GDB_ID.ROOT)
      local dDist = ( ptCurr - ptSlicing) * LayerParams.vtSlicing / ( vtSlicingNext * LayerParams.vtSlicing)
      EgtModifyCurveCompoJoint( nProjCrv, dU, ptCurr - dDist * vtSlicingNext, GDB_RT.GLOB)
   end
  
   -- calcolo la sezione iniziale
   local ptS = EgtSP( vIds[#vIds], GDB_ID.ROOT)
   local ptE = EgtEP( vIds[#vIds], GDB_ID.ROOT)
   local vtDir = EgtSV( nProjCrv, GDB_ID.ROOT)
   vtDir:rotate( LayerParams.vtSlicing, 90)
   local nSectId = CreateSection( ptS, vtDir, dStrand, s_dMultiPlanarH, LayerParams.vtSlicing, nGrpTmp)
   -- creo la sezione finale
   local vtDir2 = EgtEV( nProjCrv, GDB_ID.ROOT)
   vtDir2:rotate( LayerParams.vtSlicing, 90)
   local nSectE = CreateSection( ptE, vtDir2, dStrand, s_dMultiPlanarH, LayerParams.vtSlicing, nGrpTmp)
   
   -- creo le guide per il solido aperto ( tubo)
   local dMaxDist = ( EgtEP( vIds[#vIds], GDB_ID.ROOT) - ptSlicing) * LayerParams.vtSlicing / ( vtSlicingNext * LayerParams.vtSlicing)
   local vCrvs = {}
   local _, dParE = EgtCurveDomain( nSectId)
   for i = 0, dParE do
      local ptRef = EgtUP( nSectId, i, GDB_ID.ROOT)
      local dOffs = ( ptS - ptRef) * vtDir
      vCrvs[i+1] = EgtOffsetCurveAdv( nProjCrv, dOffs)
      if not vCrvs[i+1] or vCrvs[i+1] == GDB_ID.NULL then
         EgtErase( nGrpTmp)
         return false
      end

      -- proiezione obliqua "graduale"
      EgtApproxCurve( vCrvs[i+1], GDB_CA.SPECIAL_LINES, 0.01)
      local _, dE = EgtCurveDomain( vCrvs[i+1])
      local dLen = EgtCurveLength( vCrvs[i+1])
      local vDelta = {}
      for dU = 0, dE do
         local dCurrLen = EgtCurveLengthAtParam( vCrvs[i+1], dU) 
         vDelta[dU] = dMaxDist * dCurrLen / dLen
      end
      for dU = 0, dE do
         local ptCurr = EgtUP( vCrvs[i+1], dU, GDB_ID.ROOT)
         EgtModifyCurveCompoJoint( vCrvs[i+1], dU, ptCurr + vDelta[dU] * vtSlicingNext, GDB_RT.GLOB)
      end

      local dMove = ( ptRef - ptS) * LayerParams.vtSlicing
      EgtMove( vCrvs[i+1], LayerParams.vtSlicing * dMove, GDB_RT.GLOB)
   end
   -- creazione delle superfici del tubo
   local vSurfs = {}
   for i = 1, #vCrvs - 1 do
      vSurfs[i] = EgtSurfTmRuled( nGrpTmp, vCrvs[i], vCrvs[i+1], GDB_RUL.MINDIST, s_dTol)
      if not vSurfs[i] or vSurfs[i] == GDB_ID.NULL then
         EgtErase( nGrpTmp)
         return false
      end
   end
   -- creazione del mezzo disco iniziale e finale
   vSurfs[#vCrvs] = CreateSpiralVaseCap( nSectId, - EgtSV( vIds[#vIds], GDB_ID.ROOT), nSolidGrpId)
   vSurfs[#vCrvs + 1] = CreateSpiralVaseCap( nSectE, EgtEV( vIds[#vIds], GDB_ID.ROOT), nSolidGrpId)
   EgtInvertSurf( vSurfs[#vSurfs])
   local nSolidId = EgtSurfTmByTriangles( nSolidGrpId, vSurfs)

   -- b) deformo il solido per limitarlo al piano di slicing precedente
   local ptSlicingPrev
   local vtSlicingPrev
   local nSliceNbr = EgtGetInfo( nLayerId, KEY_SLICE_NBR, 'i')
   if nSliceNbr == 1 then
      vtSlicingPrev = LayerParams.vtSlicing
      ptSlicingPrev = EgtGetInfo( nLayerId, KEY_SLICE_POS, 'p') + LayerParams.vtCorr
   else
      local nPrevLayId = EgtGetPrev( nLayerId)
      vtSlicingPrev = EgtGetInfo( nPrevLayId, KEY_SLICE_DIR, 'v')
      ptSlicingPrev = EgtGetInfo( nPrevLayId, KEY_SLICE_POS, 'p') + vtSlicingPrev * LayerParams.dLayHeight + LayerParams.vtCorr
   end
   local dCosAng = vtSlicingPrev * LayerParams.vtSlicing
   
   -- estendo la curva proiettata per gestire correttamente la deformazione dei caps
   local nProjExtCrv = EgtCopyGlob( nProjCrv, nGrpTmp)
   EgtExtendCurveStartByLen( nProjExtCrv, dStrand)
   EgtExtendCurveEndByLen( nProjExtCrv, dStrand)
   local dLen = EgtCurveLength( nProjCrv)

   local nVertexCnt = EgtSurfTmVertexCount( nSolidId)
   for j = 0, nVertexCnt - 1 do
      
      local ptVertex = EgtSurfTmGetVertex( nSolidId, j, GDB_RT.GLOB)

      -- calcolo la distanza dal piano precedente lungo vtSlicing
      local dDistPrevPlane = ( ptVertex - ptSlicingPrev) * vtSlicingPrev / dCosAng
      -- calcolo la distanza approssimata dalla curva del toolpath
      local _, ptMinDist, dMinPar = EgtPointCurveDist( ptVertex, nProjExtCrv, GDB_ID.ROOT)
      local dCurrLen = EgtCurveLengthAtParam( nProjExtCrv, dMinPar) - dStrand
      local ptRef = ptMinDist + dMaxDist * dCurrLen / dLen * vtSlicingNext
      local dDistCrv = ( ptRef - ptVertex) * LayerParams.vtSlicing

      -- calcolo la nuova posizione sapendo che l'altezza dello strand passa da s_dMultiPlanarH a dNewH
      local dNewH = dDistCrv + dDistPrevPlane
      local dDelta = dDistCrv - dDistCrv * dNewH / s_dMultiPlanarH
      local ptNew = ptVertex + dDelta * LayerParams.vtSlicing
      EgtSurfTmMoveVertex( nSolidId, j, ptNew, GDB_RT.GLOB, ( j == nVertexCnt - 1))
   end
   
   local Color = EgtStdColor( 'TEAL')
   if s_nSimplifiedSection == 1 and nSliceNbr % 2 == 0 then
      Color = Color3d( s_dColorFactor * Color:getRed(), s_dColorFactor * Color:getGreen(), s_dColorFactor * Color:getBlue())
   end
   EgtSetColor( nSolidId, Color)
   
   EgtErase( nGrpTmp)
end

---------------------------------------------------------------------
local function CreateFullSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, nLayerId)
   
   local nSliceNbr = EgtGetInfo( nLayerId, KEY_SLICE_NBR, 'i')
   local ptSlicing = EgtGetInfo( nLayerId, KEY_SLICE_POS, 'p') + LayerParams.dLayHeight * LayerParams.vtSlicing + LayerParams.vtCorr
  
   -- recupero il piano precedente e il suo toolpath
   local nPrevLayerId = EgtGetPrev( nLayerId)
   local vtSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_DIR, 'v')
   local ptSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_POS, 'p') + LayerParams.dLayHeight * vtSlicingPrev + LayerParams.vtCorr
   local dCosAng = vtSlicingPrev * LayerParams.vtSlicing
   local nPrevCrvGrp = EgtGetFirstNameInGroup( nPrevLayerId, CONTOUR_GRP .. '*')
   local nPrevTPathGrp = EgtGetFirstNameInGroup( nPrevCrvGrp, TOOLPATH_GRP)
   local nPrevTPath = EgtGetFirstNameInGroup( nPrevTPathGrp, SHELL_CRV .. '*')
   
   -- gruppo temporaneo per conti
   local nGrpTmp = EgtGroup( nSolidGrpId)
      
   for i = 1, #vIds do
      local dStrand = EgtGetInfo( vIds[i], KEY_CRV_STRAND, 'd') or LayerParams.dStrand
      
      -- creo la freccia direzionale
      CreateDirectionArrow( vIds[i], nSolidGrpId, LayerParams.vtSlicing, dStrand, nSliceNbr)
      
      -- appiattisco la curva ( proiezione sul piano di slicing)
      local nProjCrv = EgtCopyGlob( vIds[i], nGrpTmp)
      EgtProjectCurveOnPlane( nProjCrv, ptSlicing, LayerParams.vtSlicing, GDB_RT.GLOB)
      local dLen = EgtCurveLength( nProjCrv)
     
      -- suddivido la curva piana
      local vGuideIds = CalcSolidGuides( nProjCrv, dStrand, nGrpTmp)
      local dCumLen = 0
      for k = 1, #vGuideIds do
         
         -- calcolo il solido sulla porzione della curva di proiezione
         local nSolidId = CreateStandardSolid( vGuideIds[k], nSolidGrpId, s_dMultiPlanarH, dStrand)
         
         -- estendo la guida per gestire al meglio i caps
         local nCrvRef = EgtCopyGlob( vGuideIds[k], nGrpTmp)
         EgtExtendCurveStartByLen( nCrvRef, dStrand)
         EgtExtendCurveEndByLen( nCrvRef, dStrand)
         
         -- recupero la curva precedente. Se estremi la limito per gestire al meglio la corrispondenza tra i toolpath
         local nPrevTPathRef = nPrevTPath
         if k == 1 then
            nPrevTPathRef = EgtCopyGlob( nPrevTPath, nGrpTmp)
            EgtTrimCurveEndAtLen( nPrevTPathRef, 0.5 * EgtCurveLength( nPrevTPathRef))
         elseif k == #vGuideIds then
            nPrevTPathRef = EgtCopyGlob( nPrevTPath, nGrpTmp)
            EgtTrimCurveStartAtLen( nPrevTPathRef, 0.5 * EgtCurveLength( nPrevTPathRef))
         end

         -- deformo i solidi :
         -- 1) traslazione dei vertici per portarli alla quota corretta del toolpath corrente
         -- 2) deformazione della sezione in base alla distanza dal toolpath precedente
         local nVertexCnt = EgtSurfTmVertexCount( nSolidId)
         for j = 0, nVertexCnt - 1 do
            local ptVertex = EgtSurfTmGetVertex( nSolidId, j, GDB_RT.GLOB)
               
            -- ricavo il punto di riferimento sulla proiezione del toolpath
            local _, ptMinDist, dParMinDist = EgtPointCurveDist( ptVertex, nCrvRef, GDB_ID.ROOT)
            local dCurrLen = EgtCurveLengthAtParam( nCrvRef, dParMinDist) - dStrand + dCumLen

            -- 1) proietto il punto sul piano corrente e calcolo la traslazione da applicare in base alla distanza dal piano precedente ( analogamente a CalcToolPath)
            local dDistCrv = ( ptSlicing - ptVertex) * LayerParams.vtSlicing
            local ptProj = ptVertex + dDistCrv * LayerParams.vtSlicing
            local dDistPlanePrev = ( ptProj - ptSlicingPrev) * vtSlicingPrev / dCosAng  
            local dDeltaPos
            if nSliceNbr == 2 and dCurrLen < 0.5 * dLen then
               dDeltaPos = 0.5 * dDistPlanePrev
            else
               dDeltaPos = dDistPlanePrev * ( dLen - dCurrLen) / dLen
            end
            
            -- 2) per calcolare la vera altezza del solido calcolo la distanza dal toolpath precedente guardando il punto di riferimento sul percorso corrente
            local dNewH 
            if nSliceNbr == 2 then
               -- il primo layer è ad altezza costante quindi è semplice distanza dal piano precedente lungo vtSlicing
               dNewH = ( ptProj - ptSlicingPrev) * vtSlicingPrev / dCosAng - dDeltaPos
            else
               local _, ptMinDistPrev = EgtPointCurveDist( ptMinDist, nPrevTPathRef, GDB_ID.ROOT)
               local dDistPlanePrev2 = ( ptMinDist - ptSlicingPrev) * vtSlicingPrev / dCosAng
               local dDeltaPos2
               if nSliceNbr == 2 and dCurrLen < 0.5 * dLen then
                  dDeltaPos2 = 0.5 * dDistPlanePrev2
               else
                  dDeltaPos2 = dDistPlanePrev2 * ( dLen - dCurrLen) / dLen
               end
               dNewH = ( ptMinDist - ptMinDistPrev) * LayerParams.vtSlicing - dDeltaPos2
               -- aggiungo un piccolo extra per tener conto che la distanza è stata calcolata sulle curve centrali del solido
               local dExtra = ( LayerParams.vtSlicing ^ vtSlicingPrev):len() / dCosAng * dStrand * 0.5
               dNewH = dNewH + dExtra
            end

            local dDelta = dDistCrv - dDistCrv * dNewH / s_dMultiPlanarH
            local ptNew = ptVertex + ( dDelta - dDeltaPos) * LayerParams.vtSlicing
            EgtSurfTmMoveVertex( nSolidId, j, ptNew, GDB_RT.GLOB, ( j == nVertexCnt - 1))
         end
      
         -- imposto colore
         local Color = EgtStdColor( 'TEAL')
         if s_nSimplifiedSection == 1 and nSliceNbr % 2 == 0 then
            Color = Color3d( s_dColorFactor * Color:getRed(), s_dColorFactor * Color:getGreen(), s_dColorFactor * Color:getBlue())
         end
         EgtSetColor( nSolidId, Color)
         
         dCumLen = dCumLen + EgtCurveLength( vGuideIds[i])
      end
   end
    
   EgtErase( nGrpTmp)
end

---------------------------------------------------------------------
local function CreateFullSpiralVaseMultiPlanarSolidsLastLayer( vIds, nSolidGrpId, LayerParams, nLayerId)
   -- le curve sono piane quindi i solidi possono essere calcolati nel modo classico
   -- i solidi della shell sono deformati in base alla distanza dalla curva precedente
   -- eventuali solidi di lead out e coasting sono calcolati con un valore di altezza costante pari all'ultimo valore di altezza dei solidi della shell
   
   local nSliceNbr = EgtGetInfo( nLayerId, KEY_SLICE_NBR, 'i')
   
   local nPrevLayerId = EgtGetPrev( EgtGetPrev( nLayerId))
   local vtSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_DIR, 'v')
   local ptSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_POS, 'p') + vtSlicingPrev * LayerParams.dLayHeight + LayerParams.vtCorr
   local ptSlicing = EgtGetInfo( nLayerId, KEY_SLICE_POS, 'p') + LayerParams.vtSlicing * LayerParams.dLayHeight + LayerParams.vtCorr
   local dCosAng = vtSlicingPrev * LayerParams.vtSlicing
   
   -- 1) curva shell
   local nGrpTmp = EgtGroup( nSolidGrpId)
   local dStrand = EgtGetInfo( vIds[1], KEY_CRV_STRAND, 'd') or LayerParams.dStrand
   local vShellGuides = CalcSolidGuides( vIds[1], dStrand, nGrpTmp)
   
   local dLen = EgtCurveLength( vIds[1])
   -- se non c'è lead out alla lunghezza totale della shell devo aggiungere anche quella del coasting
   if EgtGetInfo( s_nPartId, KEY_LEAD_OUT_TYPE, 'i') == LEAD_TYPE.NONE then
      dLen = dLen + EgtGetInfo( s_nPartId, KEY_COASTING_LEN, 'd')
   end
   local dCumLen = 0
   
   -- creo la freccia direzionale
   CreateDirectionArrow( vIds[1], nSolidGrpId, LayerParams.vtSlicing, dStrand, nSliceNbr)
      
   for i = 1, #vShellGuides do
     
      -- calcolo il solido associato
      local nSolidId = CreateStandardSolid( vShellGuides[i], nSolidGrpId, s_dMultiPlanarH, dStrand)
      
      -- estensione della guida per gestire meglio i caps
      local nCrvRef = EgtCopyGlob( vShellGuides[i], nGrpTmp)
      EgtExtendCurveStartByLen( nCrvRef, dStrand)
      EgtExtendCurveEndByLen( nCrvRef, dStrand)
      
      -- deformo in base alla distanza dalla curva precedente
      local nVertexCnt = EgtSurfTmVertexCount( nSolidId)
      for j = 0, nVertexCnt - 1 do
         local ptVertex = EgtSurfTmGetVertex( nSolidId, j, GDB_RT.GLOB)
         
         -- ricavo il punto di riferimento sulla guida
         local _, _, dParMinDist = EgtPointCurveDist( ptVertex, nCrvRef, GDB_ID.ROOT)
         local dCurrLen = EgtCurveLengthAtParam( nCrvRef, dParMinDist) - dStrand + dCumLen

         -- calcolo la nuova altezza del solido in base alla distanza dalla curva precedente
         local dDistCurr = ( ptSlicing - ptVertex) * LayerParams.vtSlicing
         local ptProj = ptVertex + dDistCurr * LayerParams.vtSlicing
         local dDistPrev = ( ptProj - ptSlicingPrev) * vtSlicingPrev / dCosAng
         local dNewH = dDistPrev * ( dLen - dCurrLen) / dLen
         dNewH = max( dNewH, 500 * GEO.EPS_SMALL)
         
         -- calcolo la nuova posizione sapendo che l'altezza dello strand passa da s_dMultiPlanarH a dNewH
         local dDelta = dDistCurr - dDistCurr * dNewH / s_dMultiPlanarH
         local ptNew = ptVertex + dDelta * LayerParams.vtSlicing
         EgtSurfTmMoveVertex( nSolidId, j, ptNew, GDB_RT.GLOB, ( j == nVertexCnt - 1))
      end

      dCumLen = dCumLen + EgtCurveLength( vShellGuides[i])
      
      -- imposto colore
      local Color = EgtStdColor( 'TEAL')
      if s_nSimplifiedSection == 1 and nSliceNbr % 2 == 0 then
         Color = Color3d( s_dColorFactor * Color:getRed(), s_dColorFactor * Color:getGreen(), s_dColorFactor * Color:getBlue())
      end
      EgtSetColor( nSolidId, Color)
   end
   
   -- 2) curve di uscita
   -- calcolo altezza finale del solido shell
   local ptE = EgtEP( vIds[1], GDB_ID.ROOT)
   local dH = ( ( ptE - ptSlicingPrev) * vtSlicingPrev / dCosAng) * ( dLen - EgtCurveLength( vIds[1])) / dLen
   dH = max( dH, 500 * GEO.EPS_SMALL)
   for i = 2, #vIds do
      CreateSolidFromCurve( vIds[i], nSolidGrpId, LayerParams, nSliceNbr, dH)
   end
   
   EgtErase( nGrpTmp)
end

---------------------------------------------------------------------
function RunCalcSolids.Exec()

   -- per determinare il tempo di calcolo
   EgtStartCounter()
   
   -- verifico se richiesta sezione semplificata ( rettangolare)
   local sIniFile = EgtGetIniFile()
   s_nSimplifiedSection = EgtGetNumberFromIni( 'Solids', 'SimplifiedSection', 0, sIniFile)

   local nPartIndex = 1
   local nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) or EgtGetFirstNameInGroup( GDB_ID.ROOT, PART)
   while nPartId do

      s_nPartId = nPartId
      if EgtGetInfo( nPartId, KEY_PART_ON_TABLE, 'b') then
         -- verifico se necessario calcolare il solido
         local bCalcSolid = EgtGetInfo( nPartId, KEY_CALC_SOLIDS, 'b') or false

         if bCalcSolid then

            -- recupero il suo frame
            local nFrameId = EgtGetFirstNameInGroup( EgtGetFirstNameInGroup( nPartId, 'Frame'), 'FramePart')
            local ptOrig = EgtSP( nFrameId or GDB_ID.NULL, GDB_ID.ROOT)
            EgtSetInfo( nPartId, KEY_ORIG_REF, ptOrig)
            
            -- recupero i suoi slice
            local vLayIds = EgtGetNameInGroup( nPartId, SLICE_LAYER .. '*')
            if not vLayIds or #vLayIds == 0 then
               EgtOutBox( 'No sliced part in this project!', 'Error', 'ERROR')
               return
            end

            EgtSetInfo( nPartId, KEY_HAS_SOLIDS, 1)
            local nSlicingType = EgtGetInfo( nPartId, KEY_SLICING_TYPE, 'i')

            -- recupero i parametri necessari al calcolo dei solidi 
            local LayerParams = GetLayerParamsForSolidCalc( nPartId)
            
            -- se slicing multiplanare considero come altezza standard quella massima ammessa
            if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
               local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
               local dMaxFactor = EgtGetNumberFromIni( '3dPrinting', KEY_MAX_STRANDH_FACTOR, 2, sMachIni)
               s_dMultiPlanarH = min( dMaxFactor, 5) * LayerParams.dLayHeight
            end

            local bFirst = true
            for nIdx = 1, #vLayIds do
               
               -- flag di interruzione perchè trovati solidi già ok
               local bSolidsOk = false
               -- indice layer ( per log)
               local nSliceNbr = EgtGetInfo( vLayIds[ nIdx], KEY_SLICE_NBR, 'i')
               -- scorro tutti i gruppi di contorni
               local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*") or GDB_ID.NULL
               while nCrvGrpId ~= GDB_ID.NULL do

                  -- recupero il gruppo dei percorsi utensile 
                  local nTPathGrpId = EgtGetFirstNameInGroup( nCrvGrpId, TOOLPATH_GRP) or GDB_ID.NULL
                  if nTPathGrpId == GDB_ID.NULL then
                     EgtOutBox( 'Error no tool paths', 'SolidCalc')
                     return
                  end

                  -- recupero il gruppo dei solidi 
                  local nSolidGrpId = EgtGetFirstNameInGroup( nCrvGrpId, SOLID_GRP) or GDB_ID.NULL
                  if nSolidGrpId == GDB_ID.NULL then
                     nSolidGrpId = EgtGroup( nCrvGrpId)
                     EgtSetName( nSolidGrpId, SOLID_GRP)
                     EgtSetLevel( nSolidGrpId, GDB_LV.TEMP)
                     
                     local vIds = EgtGetAllInGroup( nTPathGrpId)
                     
                     if #vIds > 0 then
                        -- slicing multiplanare
                        if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
                           LayerParams.vtSlicing = EgtGetInfo( vLayIds[nIdx], KEY_SLICE_DIR, 'v')
                           
                           if LayerParams.bSpiralVase then
                              local dTransitionLen = EgtGetInfo( nPartId, KEY_SPIRAL_VASE_LEN, 'd') or 0
                              -- a) spiral vase completo ( con transizione in altezza su tutto il layer)
                              if dTransitionLen < GEO.EPS_SMALL then
                                 if bFirst then
                                    -- il primo layer va gestito come uno spiral vase con transizione parziale ( curva a quota costante e ultimo tratto che si alza)
                                    CreatePartialSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx], bFirst)
                                 elseif nIdx == #vLayIds then
                                    -- gestione speciale per lead out e coasting
                                    CreateFullSpiralVaseMultiPlanarSolidsLastLayer( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx])
                                 else
                                    CreateFullSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx])
                                 end
                                 
                              -- b) spiral vase con transizione parziale
                              else
                                 if nIdx == #vLayIds then
                                    -- ultimo layer è un multiplanare standard perchè non ha tratto finale che si alza
                                    CreateMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx], false)
                                 else
                                    CreatePartialSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx], bFirst)
                                 end
                              end
                           -- c) multiplanare standard
                           else
                              CreateMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx], bFirst)
                           end
                           
                        -- slicing standard spiral vase
                        elseif LayerParams.bSpiralVase then
                           -- i tratti di ingresso, uscita e quelli a quota costante vanno gestiti singolarmente, quelli a quota variabile vanno concatenati
                           local vChainedIds = {}
                           local vTmpIds = {}
                           for i = 1, #vIds do
                              local sName = EgtGetName( vIds[i])
                              local dDelta = ( EgtEP( vIds[i], GDB_ID.ROOT) - EgtSP( vIds[i], GDB_ID.ROOT)) * LayerParams.vtSlicing
                              if abs( dDelta) < GEO.EPS_SMALL or sName == LEAD_IN_CRV or sName == LEAD_OUT_CRV or sName == COASTING_CRV or sName == WIPE_CRV then
                                 -- inserisco il gruppo di tratti da concatenare e lo resetto
                                 if #vTmpIds > 0 then 
                                    table.insert( vChainedIds, vTmpIds)
                                    vTmpIds = {}
                                 end
                                 -- inserisco la curva singola corrente
                                 table.insert( vChainedIds, { vIds[i]})
                              else
                                 table.insert( vTmpIds, vIds[i])
                              end
                           end
                           -- inserisco ultimo gruppo
                           if #vTmpIds > 0 then
                              table.insert( vChainedIds, vTmpIds)
                           end
                           
                           for i = 1, #vChainedIds do
                              if #vChainedIds[i] == 1 then
                                 CreateSolidFromCurve( vChainedIds[i][1], nSolidGrpId, LayerParams, nSliceNbr)
                              else
                                 local nNewCrv = EgtCurveCompo( nSolidGrpId, vChainedIds[i], false)
                                 local dStrand = EgtGetInfo( vChainedIds[i][1], KEY_CRV_STRAND, 'd') or LayerParams.dStrand
                                 EgtSetInfo( nNewCrv, KEY_CRV_STRAND, dStrand)
                                 EgtSetInfo( nNewCrv, KEY_TYPE, TYPE.OUTER_SHELL)
                                 CreateSolidFromCurve( nNewCrv, nSolidGrpId, LayerParams, nSliceNbr)
                                 EgtErase( nNewCrv)
                              end
                           end
                           
                        -- slicing standard
                        else
                           for i = 1, #vIds do
                              CreateSolidFromCurve( vIds[i], nSolidGrpId, LayerParams, nSliceNbr)
                           end
                        end
                        bFirst = false
                     end
                  else
                     bSolidsOk = true
                     break
                  end

                  --passo al gruppo di contorni successivo
                  nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*") or GDB_ID.NULL
               end
               if bSolidsOk then
                  break
               end
               local nStep = 10
               if nIdx > 400 then
                  nStep = 80
               elseif nIdx > 200 then
                  nStep = 40
               elseif nIdx > 100 then
                  nStep = 20
               end
               if ( nIdx % nStep) == 0 then
                  EgtDraw()
               end
               
               if EgtProcessEvents( EgtIf( PRINT, 400, 0) + nIdx / #vLayIds * 100, 0) == 1 then
                  -- se interrompo cancello i solidi realizzati
                  for i = 1, #vLayIds do
                     local vGrpId = EgtGetNameInGroup( vLayIds[i], CONTOUR_GRP .. '*') or {}
                     for j = 1, #vGrpId do
                        local nSolidId = EgtGetFirstNameInGroup( vGrpId[j], SOLID_GRP .. '*') or GDB_ID.NULL
                        EgtErase( nSolidId)
                     end
                  end
                  -- rimuovo info della presenza solidi
                  EgtSetInfo( nPartId, KEY_HAS_SOLIDS, false)
                  EgtDraw()
                  return
               end
            end

            -- eventuale aggiornamento delle ViewInfo
            local nViewId = EgtGetFirstNameInGroup( GDB_ID.ROOT, VIEWPARAMS)
            if nViewId then
               EgtSetInfo( nViewId, SOLID_GRP, true)
            end
         end
      end
      
      nPartIndex = nPartIndex + 1
      nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) or EgtGetNextName( nPartId, PART)
   end

   EgtDraw()

   -- report tempo di calcolo in log
   EgtOutLog( string.format( '  CalcSolidsTime = %.2f ms', EgtStopCounter()))

end

---------------------------------------------------------------------
return RunCalcSolids