3dPrinting 2.6b1 :

- aggiornata versione.

.vscode/settings.json

@@ -0,0 +1,34 @@
+{
+    "Lua.diagnostics.globals": [
+        "MATERIAL",
+        "EgtGetFirstNameInGroup",
+        "GDB_ID",
+        "EgtGroup",
+        "EgtSetLevel",
+        "EgtSetName",
+        "GDB_LV",
+        "EgtGetCurrMachineDir",
+        "EgtGetCurrMachineName",
+        "EgtGetStringFromIni",
+        "EgtGetFirstPart",
+        "EgtGetInfo",
+        "EgtGetNextPart",
+        "EgtGetLastNameInGroup",
+        "EgtRemoveInfo",
+        "EgtGetFirstInGroup",
+        "EgtGetName",
+        "EgtCurveLength",
+        "EgtGetNext",
+        "EgtCurveArea",
+        "EgtGetNextName",
+        "EgtSetInfo",
+        "floor",
+        "pi",
+        "pow",
+        "EgtProcessEvents",
+        "EgtEmptyGroup",
+        "EgtOutLog",
+        "EgtIf",
+        "EgtProtectGlobal"
+    ]
+}

Compile.bat

@@ -11,9 +11,11 @@ REM Compilazione 32 e 64 bit
 \EgtProg\Dll32\luac54 -o bin\LuaLibs\RunCalcSolids.lua                 LuaLibs\RunCalcSolids.lua
 \EgtProg\Dll32\luac54 -o bin\LuaLibs\RunGcodeGenerate.lua              LuaLibs\RunGcodeGenerate.lua
 \EgtProg\Dll32\luac54 -o bin\LuaLibs\RunMachParamFromSWCalc.lua        LuaLibs\RunMachParamFromSWCalc.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunPrepareExport.lua              LuaLibs\RunPrepareExport.lua
 \EgtProg\Dll32\luac54 -o bin\LuaLibs\RunSlicing.lua                    LuaLibs\RunSlicing.lua
 \EgtProg\Dll32\luac54 -o bin\CalcMachParamFromSW.lua                   CalcMachParamFromSW.lua
 \EgtProg\Dll32\luac54 -o bin\CalcSolids.lua                            CalcSolids.lua
 \EgtProg\Dll32\luac54 -o bin\GcodeGenerate.lua                         GcodeGenerate.lua
+\EgtProg\Dll32\luac54 -o bin\PrepareExport.lua                         PrepareExport.lua
 \EgtProg\Dll32\luac54 -o bin\Slicing.lua                               Slicing.lua
 \EgtProg\Dll32\luac54 -o bin\Version.lua                               Version.lua

LuaLibs/AddManData.lua

@@ -28,8 +28,12 @@ LINK_CRV = "Link"
 FRAME_PART = "FramePart"
 START_GEOM = "Start"
 TOT_SHELL_TRIM_SURF = "TotalShellSurfForTrim"
+SHELL_SURF = "ShellSurf"
+COARSE_TRIM_SURF = "CoarseTrimSurf"
 TRIM_SURF_LOOP = "TrimSurfLoop"
 SURF_LOOP = "SurfLoop"
+LOOP_GRP = "LoopGrp"
+DIR_ARROW = "Arrow"
 
 MIN_LEN = 0.1
 MIN_AREA = 0.01
@@ -134,6 +138,8 @@ KEY_RIBS_USER_LINK_CCW = "RibUserLinkCCW"
 KEY_RIBS_USER_LINK_ORDER = "RibUserLinkOrder"
 KEY_RIBS_USER_LINK_TOT = "RibsUserLinkParts"
 KEY_RIBS_INVERT_STRAND_ORDER = "RibsInvertStrandOrder"
+KEY_RIBS_MERGE_WITH_SHELLS = "RibsMergeWithShell"
+KEY_INVERT_RIBS_MERGED_SHELL_LINK = "InvertRibsMergedShellMainLink"
 
 -- Regioni con diverso numero di passate
 KEY_SHELL_NBR_DIFF = "ShellNbrDifference"
@@ -172,6 +178,7 @@ KEY_SPEED_MIN = "SpeedMin"
 KEY_SPEED_MAX = "SpeedMax"
 
 -- Altre chiavi
+KEY_MAX_H = "SlicingHeight"
 KEY_SLICE_NBR = "SliceNbr"
 KEY_SLICE_Z = "SliceZ"
 KEY_SLICE_DELTAZ = "DeltaZ"
@@ -194,6 +201,9 @@ KEY_INTERNAL_SRF_LOOP = "InternalSrfLoop"
 KEY_PREV_CRV = "PrevCrv"
 KEY_NEXT_CRVS = "NextCrvs"
 KEY_CRV_STRAND = "CurveStrand"
+KEY_LAYER_CNT = "LayerCnt"
+KEY_CRV_OFFSET = "CurveOffset"
+KEY_ORIG_REF = "Orig"
 
 SLICING_TYPE = {
    VERTICAL = 1,
@@ -286,6 +296,7 @@ LAY_FRAME = "Frame"
 VIEWPARAMS = 'ViewParams'
 IMPORTED_SOLID = 'ImportedSolid'
 RESULT_READ_PROG = 'ResultReadProg'
+LAY_EXPORT = "ExportLayer"
 
 KEY_PART_ON_TABLE = 'PartOnTable'
 KEY_RESULT = 'Result'

LuaLibs/CalcSlices.lua

@@ -1,4 +1,4 @@
--- CalcSlices.lua by Egaltech s.r.l. 2022/10/12
+-- CalcSlices.lua by Egaltech s.r.l. 2023/08/28
 -- Calcolo percorsi di lavoro per Stampa 3d
 
 -- Tabella per definizione modulo
@@ -37,7 +37,12 @@ local function ComputeZSlices( dSliceStep, dZmin, dDeltaZ, dZmax)
 end
 
 --------------------------------------------------------------------
-local function ComputeMaxH( vIds, frSlicing, HMax, dSliceStep)
+local function ComputeMaxH( vIds, frSlicing, dSliceStep)
+   
+   local HMax = EgtGetInfo( s_nPartId, KEY_MAX_H, 'd') or GEO.INFINITO
+   if HMax < GEO.EPS_SMALL then
+      HMax = GEO.INFINITO
+   end
    
    -- calcolo il box globale
    local b3BoxGlob = BBox3d()
@@ -99,6 +104,9 @@ local function GetRibParams( nId)
 
    local RibParam = {}
    ReadParam( nId, KEY_RIBS_STRAND, 'd', s_dStrand, RibParam)
+   if RibParam[KEY_RIBS_STRAND] < GEO.EPS_SMALL then
+      RibParam[KEY_RIBS_STRAND] = s_dStrand
+   end
    ReadParam( nId, KEY_RIBS_SHELLS_NBR, 'i', 0, RibParam)
    ReadParam( nId, KEY_RIBS_INVERT_DIR, 'b', false, RibParam)
    ReadParam( nId, KEY_RIBS_LEAD_IN_INVERT, 'b', false, RibParam)
@@ -112,6 +120,7 @@ local function GetRibParams( nId)
    ReadParam( nId, KEY_RIBS_LINK, 'b', false, RibParam)
    ReadParam( nId, KEY_RIBS_TYPE, 'i', RIB_TYPE.INTERNAL, RibParam)
    ReadParam( nId, KEY_RIBS_INVERT_STRAND_ORDER, 'b', false, RibParam)
+   ReadParam( nId, KEY_RIBS_MERGE_WITH_SHELLS, 'b', false, RibParam)
   
    return RibParam
 end
@@ -133,6 +142,9 @@ local function GetAuxSolidsParams( nId)
    
    local AuxSolidsParam = {}
    ReadParam( nId, KEY_AUX_SOLIDS_STRAND, 'd', s_dStrand, AuxSolidsParam)
+   if AuxSolidsParam[KEY_AUX_SOLIDS_STRAND] < GEO.EPS_SMALL then
+      AuxSolidsParam[KEY_AUX_SOLIDS_STRAND] = s_dStrand
+   end
    ReadParam( nId, KEY_AUX_SOLIDS_SHELLS_NBR, 'i', 0, AuxSolidsParam)
    ReadParam( nId, KEY_AUX_SOLIDS_OVERLAP, 'd', 0, AuxSolidsParam)
    ReadParam( nId, KEY_AUX_SOLIDS_INFILL, 'i', FILL_TYPE.NONE, AuxSolidsParam)
@@ -624,6 +636,9 @@ local function PrepareInfill( nStmId, vtSlicing)
    local dGridOverlap = EgtGetInfo( s_nPartId, KEY_INFILL_GRID_OVERLAP, 'd') or 0
    local dOffsStm = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd')
    local dStrand = EgtGetInfo( s_nPartId, KEY_INFILL_STRAND, 'd') or s_dStrand
+   if dStrand < GEO.EPS_SMALL then
+      dStrand = s_dStrand
+   end
    
    -- creo gruppo per infill
    local nInfillGrp = EgtGroup( s_nPartId)
@@ -657,6 +672,9 @@ local function PrepareAuxSolidsInfill( nSolidsLay, vtSlicing)
                local dOffsY = ReadParam( vIds[i], KEY_AUX_SOLIDS_OFFSET_Y, 'd', 0)
                local dGridOverlap = ReadParam( vIds[i], KEY_AUX_SOLIDS_GRID_OVERLAP, 'd', 0)
                local dStrand = ReadParam( vIds[i], KEY_AUX_SOLIDS_STRAND, 'd', s_dStrand)
+               if dStrand < GEO.EPS_SMALL then
+                  dStrand = s_dStrand
+               end
                
                -- creo gruppo associato
                local nInfillGrp = EgtGroup( s_nPartId)
@@ -1023,17 +1041,17 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
       nLayId = EgtGetNext( nLayId)
    end
 
+   -- costolature
+   local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS)
+   ExtractRibsLoops( nRibsLay, nStmId)
+   SlicingExtraObjects( nRibsLay, vtSlicing, TYPE.RIB, RIBS_CRV, RIBS_GRP, nStmId)
+   if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 3) / nCounterTot * 100, 0) == 1 then return false end
+   
    local bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false
    if not bSpiralVase then
       
       -- infill
       PrepareInfill( nStmId, vtSlicing)
-      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 3) / nCounterTot * 100, 0) == 1 then return false end
-
-      -- costolature
-      local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS)
-      ExtractRibsLoops( nRibsLay, nStmId)
-      SlicingExtraObjects( nRibsLay, vtSlicing, TYPE.RIB, RIBS_CRV, RIBS_GRP, nStmId)
       if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 6) / nCounterTot * 100, 0) == 1 then return false end
       
       -- solidi per regioni con diverso numero di passate
@@ -1056,17 +1074,23 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
 end
 
 ---------------------------------------------------------------------
-function CalcSlices.Exec( nPartId, nStmId, HMax)
+function CalcSlices.Exec( nPartId, nStmId)
 
    s_nPartId = nPartId
 
+   local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
+
    -- recupero la direzione dello slicing
    local vtSlicing = Z_AX()
    local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i')
    if nSlicingType == SLICING_TYPE.DEG45_X then
-      vtSlicing =  VectorFromSpherical( 1, 45, 0)
+      local nDir = EgtGetNumberFromIni( '3dPrinting', 'Dir45degX', 0, sMachIni)
+      local dHorAng = EgtIf( nDir == -1, 180, 0)
+      vtSlicing =  VectorFromSpherical( 1, 45, dHorAng)
    elseif nSlicingType == SLICING_TYPE.DEG45_Y then
-      vtSlicing = VectorFromSpherical( 1, 45, -90)
+      local nDir = EgtGetNumberFromIni( '3dPrinting', 'Dir45degY', 0, sMachIni)
+      local dHorAng = EgtIf( nDir == 2, 90, -90)
+      vtSlicing = VectorFromSpherical( 1, 45, dHorAng)
    elseif nSlicingType == SLICING_TYPE.HORIZONTAL then
       vtSlicing = X_AX()
    end
@@ -1115,7 +1139,7 @@ function CalcSlices.Exec( nPartId, nStmId, HMax)
 
    local dZmin = b3Box:getMin():getZ()
    local dZmax = b3Box:getMax():getZ()
-   local dMaxH = ComputeMaxH( vRefIds, frSlicing, HMax, dSliceStep)
+   local dMaxH = ComputeMaxH( vRefIds, frSlicing, dSliceStep)
    dZmax = min( dZmax, dMaxH)
    --dZmin = 708
    --dZmax = 712

LuaLibs/CalcToolPath.lua

@@ -15,7 +15,7 @@ local AMD = require( 'AddManData')
 ---------------------------------------------------------------------
 local s_nPartId
 local s_nDefaultWipeAng = -90   -- angolo = 0° per wipe significa che esce ortogonalmente alla direzione del movimento
-local s_dHMin
+local s_dApproxTol = 0.1
 
 ---------------------------------------------------------------------
 local function GetLayerParamsForToolPathCalc()
@@ -23,6 +23,7 @@ local function GetLayerParamsForToolPathCalc()
    LayerParams.bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false
    LayerParams.dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd')
    LayerParams.dInnerStrand = EgtGetInfo( s_nPartId, KEY_INNER_STRAND, 'd') or LayerParams.dStrand
+   if LayerParams.dInnerStrand < GEO.EPS_SMALL then LayerParams.dInnerStrand = LayerParams.dStrand end
    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)
@@ -45,6 +46,7 @@ local function GetLayerParamsForToolPathCalc()
    LayerParams.dTDiam = EgtGetInfo( s_nPartId, KEY_TOOL_DIAM, 'd')
    -- parametri infill
    LayerParams.dInfillStrand = EgtGetInfo( s_nPartId, KEY_INFILL_STRAND, 'd') or LayerParams.dStrand
+   if LayerParams.dInfillStrand < GEO.EPS_SMALL then LayerParams.dInfillStrand = LayerParams.dStrand end
    LayerParams.bInfillLink = EgtGetInfo( s_nPartId, KEY_INFILL_LINK, 'b') or false
    LayerParams.dInfillCoasting = EgtGetInfo( s_nPartId, KEY_INFILL_COASTING, 'd') or 0
    LayerParams.dInfillWipe = EgtGetInfo( s_nPartId, KEY_INFILL_WIPE, 'd') or 0
@@ -81,7 +83,7 @@ local function AddZCorrection( b3Box, LayerParams)
    local dHTool = LayerParams.dTDiam / 2 * dNxy
    -- altezza disponibile
    local dHBox = EgtGetInfo( s_nPartId, KEY_BOX_MIN_Z, 'i') or 0
-   local dHDisp = b3Box:getMin():getZ() - dHBox
+   local dHDisp = b3Box:getMin():getZ() - max( dHBox, 0)
    
    local dCorrZ = max( 0, max( dHStrand, dHTool) - dHDisp)
    
@@ -93,21 +95,32 @@ local function AddZCorrection( b3Box, LayerParams)
    local nFrameId = EgtGetFirstNameInGroup( s_nPartId, LAY_FRAME)
    EgtMove( nFrameId, - vtMove, GDB_RT.GLOB)
    
-end
-
-------------------------------------------------------------------
-local function FindWipeEndPoint( ptS, vtDir, dLen, vtSlicing)
-   
-   local ptE = ptS + vtDir * dLen
-   -- verifico soddisfi altezza minima per non entrare nella tavola
-   local k = 1
-   while ptE:getZ() < s_dHMin + GEO.EPS_SMALL and k < 36 do
-      vtDir:rotate( vtSlicing, 10)
-      ptE = ptS + vtDir * dLen
-      k = k + 1
+   -- correzione per i wipe
+   -- altezza minima necessaria per i wipe
+   local dHMinWipe = LayerParams.dTDiam / 2 * dNxy + max( dHBox, 0)
+   local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*")
+   for i = 1, #vLayIds do
+      local vCrvGrps = EgtGetNameInGroup( vLayIds[i], CONTOUR_GRP.."*")
+      for j = 1, #vCrvGrps do
+         local nTPath = EgtGetFirstNameInGroup( vCrvGrps[j], TOOLPATH_GRP)
+         if nTPath then
+            local vIds = EgtGetAllInGroup( nTPath)
+            for k = 1, #vIds do
+               -- se wipe verifico se ha lunghezza sensata per non finire nella tavola
+               if EgtGetInfo( vIds[k], KEY_TYPE, 'i') == TYPE.WIPE then
+                  local dLen = EgtCurveLength( vIds[k])
+                  local vtDir = EgtSV( vIds[k], GDB_ID.ROOT)
+                  local ptE = EgtEP( vIds[k], GDB_ID.ROOT)
+                  if ptE:getZ() < dHMinWipe then
+                     -- modifico la lunghezza per non finire nella tavola
+                     local dDiffLen = ( dHMinWipe - ptE:getZ()) / vtDir:getZ()
+                     EgtTrimCurveEndAtLen( vIds[k], dLen - abs( dDiffLen))
+                  end
+               end
+            end
+         end
+      end
    end
-   
-   return ptE
 end
 
 -------------------------------------------------------------------
@@ -129,7 +142,7 @@ local function AddCurvesToToolPath( vEntIds, nTpathGrpId, nOrder, bInvert, vtSli
       
       -- mi sposto dell'altezza layer
       EgtMove( vIds[nIdx], dLayHeight * vtSlicing, GDB_RT.GLOB)
-      
+     
       if EgtCurveIsClosed( vIds[nIdx]) then
          EgtSetInfo( vIds[nIdx], KEY_CLOSED_CRV, 1)
          -- eventuale inversione
@@ -138,6 +151,13 @@ local function AddCurvesToToolPath( vEntIds, nTpathGrpId, nOrder, bInvert, vtSli
             EgtSetInfo( vIds[nIdx], KEY_INVERTED_CRV, 1)
          end
       end
+      
+      -- approssimo la curva e ne risetto il punto iniziale
+      local ptS = EgtSP( vIds[nIdx], GDB_ID.ROOT)
+      EgtApproxCurve( vIds[nIdx], GDB_CA.ARCS, s_dApproxTol)
+      if EgtCurveIsClosed( vIds[nIdx]) then
+         EgtChangeClosedCurveStartPoint( vIds[nIdx], ptS, GDB_RT.GLOB)
+      end
 
       EgtSetInfo( vEntIds[i], KEY_ASSOCIATED_TP_CRV, vIds[nIdx])
       EgtSetInfo( vIds[nIdx], KEY_ASSOCIATED_P_CRV, vEntIds[i])
@@ -295,8 +315,6 @@ local function AddLeadIn( nCrvId, LayerParams, nGrpId)
 
    vtOrtho:rotate( LayerParams.vtSlicing, dAng)
    local ptS = ptE - LayerParams.dLeadInTangDist * vtTang + LayerParams.dLeadInOrthoDist * vtOrtho
-   -- verifico che non affondi nella tavola
-   if ptS:getZ() < s_dHMin + GEO.EPS_SMALL then return end
 
    local nLeadInCrv
    if LayerParams.nLeadInType == LEAD_TYPE.LINEAR then
@@ -356,7 +374,8 @@ local function AddRetraction( nCrvId, vtSlicing, dCoastingLen, dWipeLen, dWipeDi
    local nType = EgtGetInfo( nCrvId, KEY_TYPE, 'i')
    local bClosed = EgtGetInfo( nCrvId, KEY_CLOSED_CRV, 'b') or false
    local bInverted = EgtGetInfo( nCrvId, KEY_INVERTED_CRV, 'b') or false
-
+   local dStrand = EgtGetInfo( nCrvId, KEY_CRV_STRAND, 'd')
+   
    -- curva ausiliaria per generare correttamente wipe
    local nCopyId = EgtCopyGlob( nCrvId, nCrvId, GDB_IN.AFTER)
    if not EgtCurveIsClosed( nCopyId) then
@@ -449,7 +468,7 @@ local function AddRetraction( nCrvId, vtSlicing, dCoastingLen, dWipeLen, dWipeDi
          end
          
          vtDir:rotate( vtSlicing, EgtIf( bChangeSign, - dAng, dAng))
-         local ptE = FindWipeEndPoint( ptS, vtDir, dWipeLen, vtSlicing)
+         local ptE = ptS + vtDir * dWipeLen
          nWipeId = EgtCurveCompoFromPoints( EgtGetParent( nCoastingId or nCrvId), {ptS, ptE}, GDB_RT.GLOB)
          EgtModifyCurveExtrusion( nWipeId, vtSlicing, GDB_RT.GLOB)
          EgtRelocateGlob( nWipeId, nCoastingId or nCrvId, GDB_IN.AFTER)
@@ -458,7 +477,7 @@ local function AddRetraction( nCrvId, vtSlicing, dCoastingLen, dWipeLen, dWipeDi
       if nWipeId then
          EgtSetName( nWipeId, WIPE_CRV)
          EgtSetInfo( nWipeId, KEY_TYPE, TYPE.WIPE)
-         EgtSetInfo( nWipeId, KEY_CRV_STRAND, 0)
+         EgtSetInfo( nWipeId, KEY_CRV_STRAND, dStrand)
          EgtSetColor( nWipeId, EgtStdColor('AQUA'))
       end
    end
@@ -582,7 +601,15 @@ local function CalcExtraShellToolPath( vEntIds, nTpathGrpId, LayerParams)
       end
       sPrevName = sCurrName
    end
-
+   
+   -- aggiungo offset lead point sulle extra shell chiuse
+   for i = 1, #vIds do
+      if EgtCurveIsClosed( vIds[i]) then
+         local nCopy = EgtCopyGlob( nTpathGrpId, vIds[i])
+         AddOffsetLeadPoint( {vIds[i]}, nCopy, LayerParams.dOffsetLP, LINK_TYPE.NONE)
+      end
+   end
+   
    -- aggiungo coasting/wipe
    for i = 1, #vIds do
       -- verifico non sia collegato al successivo tramite link
@@ -702,8 +729,8 @@ local function VerifyInfillLink( nLinkId, nCurr, nNext, vIds, dStrand, nGrpTmp)
             -- se tratto lineare allineato come curva corrente
             if AreSameVectorApprox( vtS, vtE) and vtS * vtDirCurr < - 1 + GEO.EPS_SMALL then
                -- verifico distanza
-               local nCrvTest = EgtCurveCompoFromPoints( nGrpTmp, { EgtUP( nCurrLoc, dPar), EgtUP( nCurrLoc, dPar + 1)})
-               local dDist = EgtPointCurveDist( EgtUP( nLinkLoc, dParCrv - 0.5), nNextLoc)
+               local nCrvTest = EgtCurveCompoFromPoints( nGrpTmp, { EgtUP( nNextLoc, dPar), EgtUP( nNextLoc, dPar + 1)})
+               local dDist = EgtPointCurveDist( EgtUP( nLinkLoc, dParCrv - 0.5), nCrvTest)
                if dDist < dMinDist + GEO.EPS_SMALL then 
                   return false 
                end
@@ -1014,18 +1041,57 @@ end
 --------------------------------------------------------------------
 --------------------------- RIBS -----------------------------------
 --------------------------------------------------------------------
-local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, bCheckLinked)
+local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand)
 
-   local dStrand = EgtGetInfo( nLinkId, KEY_CRV_STRAND, 'd')
    local dOverlap1 = EgtGetInfo( nCurr, KEY_RIBS_OVERLAP, 'd')
    local dOverlap2 = EgtGetInfo( nNext, KEY_RIBS_OVERLAP, 'd')
    local dOverlap = max( dOverlap1, dOverlap2)
    local dLen = EgtCurveLength( nLinkId)
    
-   -- porto il link nel gruppo locale
-   local nLinkLoc = EgtCopyGlob( nLinkId, nGrpTmp)
+   -- 1) verifico che non entri nella tavola
+   local b3Box = EgtGetBBoxGlob( nLinkId, GDB_BB.STANDARD)
+   if b3Box:getMin():getZ() < - GEO.EPS_SMALL then
+      return false
+   end
    
-   -- verifico se interseca altri setti ( considerando anche le tipologie del PathGrp non ancora realizzate)
+   -- 2) verifica con setti coinvolti dal link
+   if nCurr ~= nNext then
+      -- verifico non passi per estremo errato
+      local dParTest1 = EgtCurveParamAtPoint( nLinkId, EgtSP( nCurr, GDB_ID.ROOT), 100 * GEO.EPS_SMALL, GDB_RT.GLOB)
+      local dParTest2 = EgtCurveParamAtPoint( nLinkId, EgtEP( nNext, GDB_ID.ROOT), 100 * GEO.EPS_SMALL, GDB_RT.GLOB)
+      if dParTest1 or dParTest2 then
+         return false
+      end
+      
+      -- verifico non intersechi i setti in altri punti oltre agli estremi
+      local nCurrLoc = EgtCopyGlob( nCurr, nGrpTmp)
+      local nNextLoc = EgtCopyGlob( nNext, nGrpTmp)
+      local nLinkLoc = EgtCopyGlob( nLinkId, nGrpTmp)
+      EgtTrimCurveEndAtLen( nLinkLoc, EgtCurveLength( nLinkLoc) - 100 * GEO.EPS_SMALL)
+      EgtTrimCurveStartAtLen( nLinkLoc, 100 * GEO.EPS_SMALL)
+      if EgtIP( nLinkLoc, nCurrLoc, ORIG()) or EgtIP( nLinkLoc, nNextLoc, ORIG()) then
+         return false
+      end
+      
+      -- se collegamento non ottimale verifico che abbia una parte esterna alla regione occupata dai setti abbsatanza lunga ( > 20% della lunghezza totale)
+      if dist( EgtEP( nCurr, GDB_ID.ROOT), EgtSP( nNext, GDB_ID.ROOT)) > dist( EgtEP( nCurr, GDB_ID.ROOT), EgtEP( nNext, GDB_ID.ROOT)) + GEO.EPS_SMALL then
+         local nSrfRibs = EgtSurfFrFatCurve( nGrpTmp, nCurr, dStrand, false) or GDB_ID.NULL
+         local nSrfRibs2 = EgtSurfFrFatCurve( nGrpTmp, nNext, dStrand, false) or GDB_ID.NULL
+         EgtSurfFrAdd( nSrfRibs, nSrfRibs2)
+         -- EgtSetStatus( nSrfRibs, GDB_ST.OFF)
+         -- EgtSetStatus( nSrfRibs2, GDB_ST.OFF)
+         local nLinkLoc = EgtCopyGlob( nLinkId, nGrpTmp)
+         local nRes, nCnt = EgtTrimCurveWithRegion( nLinkLoc, nSrfRibs, false, false)
+         if nCnt == 0 then return false end
+         local dResLen = EgtCurveLength( nRes)
+         if dResLen < 0.2 * dLen - GEO.EPS_SMALL then
+            return false
+         end
+      end
+   end
+   
+   -- 3) verifiche con altri setti ( considerando anche le tipologie del PathGrp non ancora realizzate)
+   local nLinkLoc = EgtCopyGlob( nLinkId, nGrpTmp)
    local nOrigCurr = EgtGetInfo( nCurr, KEY_ORIGINAL_RIB, 'i')
    local nOrigNext = EgtGetInfo( nNext, KEY_ORIGINAL_RIB, 'i')
    local vRibsIds = EgtGetNameInGroup( EgtGetParent( nCurr), RIBS_CRV .. '*')
@@ -1041,61 +1107,39 @@ local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, bCheckLinked)
    
    for i = 1, #vRibsIds do
       if vRibsIds[i] ~= nCurr and vRibsIds[i] ~= nNext then
+         -- verifico se sovrapposizione tra le passate
          local dCurrStrand = EgtGetInfo( vRibsIds[i], KEY_RIBS_STRAND, 'd')
          local nOrigId = EgtGetInfo( vRibsIds[i], KEY_ORIGINAL_RIB, 'i')
+         local dOffs
          if nOrigId == nOrigCurr or nOrigId == nOrigNext then
-            -- se passate relative ad un setto coinvolto verifico se sovrapposizione con la curva
-            local ptS = EgtSP( vRibsIds[i], GDB_ID.ROOT)
-            local dParS = EgtCurveParamAtPoint( nLinkLoc, ptS, dCurrStrand * 0.5, GDB_RT.GLOB)
-            if dParS then return false end
-            local ptE = EgtEP( vRibsIds[i], GDB_ID.ROOT)
-            local dParE = EgtCurveParamAtPoint( nLinkLoc, ptE, dCurrStrand * 0.5, GDB_RT.GLOB)
-            if dParE then return false end
+            -- se passata relativa ad un setto coinvolto nel link verifico soltanto che il percorso del link non entri nella regione occupata dal setto
+            dOffs = dCurrStrand * 0.5
          else
-            -- verifico se sovrapposizione con la passata
-            local dOffs = dCurrStrand * 0.5 + ( 0.5 - dOverlap / 100) * dStrand - 10 * GEO.EPS_SMALL
-            if dOffs > GEO.EPS_SMALL then
-               local nSrfCurr = EgtSurfFrFatCurve( nGrpTmp, vRibsIds[i], dOffs, false)
-               if nSrfCurr then
-                  local nRes = EgtCurveWithRegionClassify( nLinkLoc, nSrfCurr)
-                  if nRes ~= GDB_CRC.OUT then
-                     return false
-                  end
+            -- altrimenti verifico che le regioni del link e del setto non si sovrappongono ( a meno dell'overlap fissato)
+            dOffs = dCurrStrand * 0.5 + ( 0.5 - dOverlap / 100) * dStrand - 10 * GEO.EPS_SMALL
+         end
+         
+         if dOffs > GEO.EPS_SMALL then
+            local nSrfCurr = EgtSurfFrFatCurve( nGrpTmp, vRibsIds[i], dOffs, false)
+            if nSrfCurr then
+               -- EgtSetStatus( nSrfCurr, GDB_ST.OFF)
+               local nRes = EgtCurveWithRegionClassify( nLinkLoc, nSrfCurr)
+               if nRes ~= GDB_CRC.OUT then
+                  return false
                end
             end
          end
       end
    end
    
-   -- eventuale verifica con setti coinvolti dal link ( da fare solo se collegamento fra passate di setti diversi)
-   if bCheckLinked and dLen > 3 * dStrand then
-      -- regione occupata dai setti
-      local nSrfRibs = EgtSurfFrFatCurve( nGrpTmp, nCurr, dStrand, false) or GDB_ID.NULL
-      local nSrfRibs2 = EgtSurfFrFatCurve( nGrpTmp, nNext, dStrand, false) or GDB_ID.NULL
-      EgtSurfFrAdd( nSrfRibs, nSrfRibs2)
-      -- verifico che i tratti fuori abbiano lunghezza maggiore di quelli dentro
-      local nRes, nCnt = EgtTrimCurveWithRegion( nLinkLoc, nSrfRibs, false, false)
-      if nCnt == 0 then return false end
-      local dResLen = EgtCurveLength( nRes)
-      if dResLen < ( dLen - dResLen) - GEO.EPS_SMALL then
-         return false
-      end
-      
-      -- verifico non passi per estremo errato
-      local dParTest1 = EgtCurveParamAtPoint( nLinkId, EgtSP( nCurr, GDB_ID.ROOT), 100 * GEO.EPS_SMALL, GDB_RT.GLOB) 
-      local dParTest2 = EgtCurveParamAtPoint( nLinkId, EgtEP( nNext, GDB_ID.ROOT), 100 * GEO.EPS_SMALL, GDB_RT.GLOB) 
-      if dParTest1 or dParTest2 then
-         return false
-      end
-   end
-   
-   -- verifico se si trova almeno in una regione ammissibile ( per caso ForcedLink)
+   -- 4) verifico se si trova in almeno una regione ammissibile ( per caso ForcedLink)
    local nType = EgtGetInfo( nCurr, KEY_RIBS_TYPE, 'i')
    local nOut = 0
    for i = 1, 2 do
       local nSurfId = EgtGetInfo( EgtIf( i == 1, nCurr, nNext), KEY_ASSOCIATED_SURF, 'i')
       if nSurfId and nSurfId ~= -1 then
          local nSrfLoc = EgtCopyGlob( nSurfId, nGrpTmp)
+         -- EgtSetStatus( nSrfLoc, GDB_ST.OFF)
          local nRes = EgtCurveWithRegionClassify( nLinkId, nSrfLoc)
          if ( ( nType == RIB_TYPE.INTERNAL or nType == RIB_TYPE.SUPPORT) and ( nRes == GDB_CRC.OUT or nRes == GDB_CRC.INTERS)) or 
             ( nType == RIB_TYPE.EXTERNAL and ( nRes == GDB_CRC.IN or nRes == GDB_CRC.INTERS)) then
@@ -1117,29 +1161,79 @@ local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, bCheckLinked)
 end
 
 --------------------------------------------------------------------
-local function ComputeRibsLinkOnDiffCrvs( nCrvS, nCrvE, dParS, dParE)
+local function ComputeRibsLinkOnSameCrv( nCrvId, dParS, dParE, nCurr, nNext, nGrpTmp, dStrand)
    
-   -- recupero il tratto interessato sulla curva1
-   local _, _, dParFinal = EgtPointCurveDist( EgtUP( nCrvE, dParE, GDB_ID.ROOT), nCrvS, GDB_ID.ROOT) 
-   local nCrv1 = ComputeShortestCrv( nCrvS, dParS, dParFinal)
+   local nParentId = EgtGetParent( nCrvId)
+
+   local nShortest = EgtCopyGlob( nCrvId, nParentId, GDB_IN.AFTER)
+   local nLongest = EgtCopyGlob( nCrvId, nParentId, GDB_IN.AFTER)
+   EgtTrimCurveStartEndAtParam( nShortest, dParS, dParE)
+   EgtTrimCurveStartEndAtParam( nLongest, dParE, dParS)
+   EgtInvertCurve( nLongest)
+   if EgtCurveLength( nShortest) > EgtCurveLength( nLongest) + GEO.EPS_SMALL then
+      nShortest, nLongest = nLongest, nShortest
+   end
    
-   -- recupero il tratto interessato sulla cruva2
-   local _, _, dParStart = EgtPointCurveDist( EgtUP( nCrvS, dParS, GDB_ID.ROOT), nCrvE, GDB_ID.ROOT) 
-   local nCrv2 = ComputeShortestCrv( nCrvE, dParStart, dParE)
-   
-   -- modifico nCrv2 per avere una transizione uniforme da nCrv1
-   if EgtSpiralizeCurveAlongGuide( nCrv2, nCrv1) then
-      EgtErase( nCrv1)
-      return nCrv2
+   -- verifico il percorso più corto
+   if VerifyRibsLink( nShortest, nCurr, nNext, nGrpTmp, dStrand) then
+      EgtErase( nLongest)
+      return nShortest
    else
-      EgtErase( nCrv1)
-      EgtErase( nCrv2)
-      return nil
+      -- se non valido tento con il percorso più lungo
+      EgtErase( nShortest)
+      if VerifyRibsLink( nLongest, nCurr, nNext, nGrpTmp, dStrand) then
+         return nLongest
+      else
+         EgtErase( nLongest)
+         return
+      end
    end
 end
 
 --------------------------------------------------------------------
-local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, bCheckLinked, vtSlicing, nGrpTmp)
+local function ComputeRibsLinkOnDiffCrvs( nCrvS, nCrvE, dParS, dParE, nCurr, nNext, nGrpTmp, dStrand)
+   
+   local nParentId = EgtGetParent( nCrvS)
+   
+   local _, _, dParFinal = EgtPointCurveDist( EgtUP( nCrvE, dParE, GDB_ID.ROOT), nCrvS, GDB_ID.ROOT)
+   local _, _, dParStart = EgtPointCurveDist( EgtUP( nCrvS, dParS, GDB_ID.ROOT), nCrvE, GDB_ID.ROOT)
+   
+   -- tento con il tratto dParS->dParE
+   -- recupero il tratto interessato sulla curva1
+   local nCrv1 = EgtCopyGlob( nCrvS, nParentId, GDB_IN.AFTER)
+   EgtTrimCurveStartEndAtParam( nCrv1, dParS, dParFinal)
+   -- recupero il tratto interessato sulla curva2  
+   local nCrv2 = EgtCopyGlob( nCrvE, nParentId, GDB_IN.AFTER)
+   EgtTrimCurveStartEndAtParam( nCrv2, dParStart, dParE)
+   -- modifico nCrv2 per avere una transizione uniforme da nCrv1
+   EgtSpiralizeCurveAlongGuide( nCrv2, nCrv1)
+   EgtErase( nCrv1)
+   -- verifico se valida
+   if VerifyRibsLink( nCrv2, nCurr, nNext, nGrpTmp, dStrand) then
+      return nCrv2
+      
+   else
+      -- tento con il tratto dParE->dParS
+      EgtErase( nCrv2)
+      nCrv1 = EgtCopyGlob( nCrvS, nParentId, GDB_IN.AFTER)   -- tratto interessato sulla curva1
+      EgtTrimCurveStartEndAtParam( nCrv1, dParFinal, dParS)
+      EgtInvertCurve( nCrv1)
+      nCrv2 = EgtCopyGlob( nCrvE, nParentId, GDB_IN.AFTER)   -- tratto interessato sulla curva2
+      EgtTrimCurveStartEndAtParam( nCrv2, dParE, dParStart)
+      EgtInvertCurve( nCrv2)
+      EgtSpiralizeCurveAlongGuide( nCrv2, nCrv1) -- transizione uniforme da nCrv1
+      EgtErase( nCrv1)
+      if VerifyRibsLink( nCrv2, nCurr, nNext, nGrpTmp, dStrand) then
+         return nCrv2
+      else
+         EgtErase( nCrv2)
+         return
+      end
+   end
+end
+
+--------------------------------------------------------------------
+local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrpTmp)
    
    local ptS = EgtEP( nCurr)
    local ptE = EgtSP( nNext)
@@ -1172,10 +1266,10 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, bCheckLinked, v
          local nLinkId
          if vIdsS[i] == vIdsE[j] then
             -- link su una sola curva
-            nLinkId = ComputeShortestCrv( vCrvIds[vIdsS[i]], vParS[i], vParE[j])
+            nLinkId = ComputeRibsLinkOnSameCrv( vCrvIds[vIdsS[i]], vParS[i], vParE[j], nCurr, nNext, nGrpTmp, dStrand)
          else
             -- link tra due curve distinte
-            nLinkId = ComputeRibsLinkOnDiffCrvs( vCrvIds[vIdsS[i]], vCrvIds[vIdsE[j]], vParS[i], vParE[j])
+            nLinkId = ComputeRibsLinkOnDiffCrvs( vCrvIds[vIdsS[i]], vCrvIds[vIdsE[j]], vParS[i], vParE[j], nCurr, nNext, nGrpTmp, dStrand)
          end
          
          if nLinkId then
@@ -1184,13 +1278,7 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, bCheckLinked, v
             EgtSetName( nLinkId, LINK_CRV)
             EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB)
             EgtSetInfo( nLinkId, KEY_CRV_STRAND, dStrand)
-            -- verifico se valido
-            local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, bCheckLinked)
-            if bValid then
-               return nLinkId
-            else
-               EgtErase( nLinkId)
-            end
+            return nLinkId
          end
       end
    end
@@ -1203,7 +1291,7 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, bCheckLinked, v
       EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB)
       EgtRelocateGlob( nLinkId, nCurr, GDB_IN.AFTER)
       EgtSetInfo( nLinkId, KEY_CRV_STRAND, dStrand)
-      local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, bCheckLinked)
+      local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand)
       if bValid then
          return nLinkId
       else
@@ -1215,6 +1303,38 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, bCheckLinked, v
    return
 end
 
+--------------------------------------------------------------------
+local function CalcLoopRibLink( nCurr, nNext, nLoopGrp, vtSlicing, nGrpTmp)
+   
+   local ptS = EgtEP( nCurr)
+   local ptE = EgtSP( nNext)
+   if AreSamePointApprox( ptS, ptE) then return end
+   local dStrand = EgtGetInfo( nCurr, KEY_CRV_STRAND, 'd')
+   
+   local vCrvIds = EgtGetAllInGroup( nLoopGrp)
+   -- scorro le curve di bordo e verifico se posso creare il link
+   for i = 1, #vCrvIds do
+      local dParS = EgtCurveParamAtPoint( vCrvIds[i], ptS, 10 * GEO.EPS_SMALL)
+      local dParE = EgtCurveParamAtPoint( vCrvIds[i], ptE, 10 * GEO.EPS_SMALL)
+      if dParS and dParE then
+         local nLinkId = ComputeShortestCrv( vCrvIds[i], dParS, dParE)
+         if nLinkId then
+            EgtRelocateGlob( nLinkId, nCurr, GDB_IN.AFTER)
+            EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB)
+            EgtSetName( nLinkId, LINK_CRV)
+            EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB)
+            EgtSetInfo( nLinkId, KEY_CRV_STRAND, dStrand)
+            if VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand) then
+               return nLinkId
+            else
+               EgtErase( nLinkId)
+            end
+         end
+      end
+   end
+   return
+end
+
 --------------------------------------------------------------------
 local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
 
@@ -1228,7 +1348,19 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
    -- individuo eventuale lead in o link relativo al setto corrente ( solo se collega due passate dello stesso setto)
    local nCurrLI
    local nCurrLink
-   if not bInVsOut then
+   if bInVsOut then
+      -- se è lead in devo solo verificare se seguito da un link
+      local nNext = EgtGetNext( nRibId)
+      if nNext and EgtGetName( nNext) == LINK_CRV then
+         local nNextRib = EgtGetNext( nNext)
+         local nOrigRib = EgtGetInfo( nRibId, KEY_ORIGINAL_RIB, 'i') or -1
+         local nOrigRibPrev = EgtGetInfo( nNextRib, KEY_ORIGINAL_RIB, 'i') or -1
+         if nOrigRib == nOrigRibPrev then
+            nCurrLink = nNext
+         end
+      end
+   else
+      -- se è lead out devo verificare se preceduto da lead in o da link
       local nPrev = EgtGetPrev( nRibId)
       if nPrev and EgtGetName( nPrev) == LEAD_IN_CRV then
          nCurrLI = nPrev
@@ -1242,17 +1374,18 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
       end
    end
    
-   -- verifico se interseca altri setti, lead in, lead out o collegamenti
+   -- 1) verifico se interseca altri setti, lead in, lead out o collegamenti
    -- recupero gli id degli elementi da controllare
    local vCheckIds = {}
-   local nCurrId = EgtGetFirstNameInGroup( EgtGetParent( nRibId), RIBS_CRV .. '*')
-   -- verifico se il primo setto ha lead in da controllare
-   local nPrevId = EgtGetPrev( nCurrId)
-   if nPrevId and EgtGetName( nPrevId) == LEAD_IN_CRV then nCurrId = nPrevId end
+   local nCurrId = EgtGetFirstInGroup( EgtGetParent( nRibId))
    while nCurrId do
-      -- salto i i wipe ( non sono materiale depositato) e i tratti relativi al setto corrente
-      if not EgtStartsWith( EgtGetName( nCurrId), WIPE_CRV) and nCurrId ~= nCurrLI and nCurrId ~= nRibId and nCurrId ~= nId and nCurrId ~= nCurrLink then
-         table.insert( vCheckIds, nCurrId)
+      -- considero solo i setti e gli elementi a loro associati ( tranne i wipe perchè non corrispondono a materiale depositato)
+      local nType = EgtGetInfo( nCurrId, KEY_TYPE, 'i')
+      if nType == TYPE.RIB or ( nType == TYPE.COASTING and EgtGetInfo( EgtGetPrev( nCurrId), KEY_TYPE, 'i') == TYPE.RIB) then
+         -- verifico non sia un tratto relativo al setto corrente
+         if nCurrId ~= nCurrLI and nCurrId ~= nRibId and nCurrId ~= nId and nCurrId ~= nCurrLink then
+            table.insert( vCheckIds, nCurrId)
+         end
       end
       nCurrId = EgtGetNext( nCurrId)
    end
@@ -1273,6 +1406,7 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
       if dCurrOffs > GEO.EPS_SMALL then
          local nSrfCurr = EgtSurfFrFatCurve( nGrpTmp, vCheckIds[i], dCurrOffs, false)
          if nSrfCurr then
+            -- EgtSetStatus( nSrfCurr, GDB_ST.OFF)
             local nRes = EgtCurveWithRegionClassify( nLeadLoc, nSrfCurr)
             if nRes ~= GDB_CRC.OUT then
                return false
@@ -1281,7 +1415,7 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
       end
    end
   
-   -- verifiche con il setto corrente
+   -- 2) verifiche con il setto corrente
    -- verifico non passi da altro estremo
    local dParTest = EgtCurveParamAtPoint( nLeadLoc, EgtIf( bInVsOut, EgtEP( nRibId, GDB_ID.ROOT), EgtSP( nRibId, GDB_ID.ROOT)), 100 * GEO.EPS_SMALL, GDB_RT.GLOB)
    if dParTest then
@@ -1292,12 +1426,11 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
    local nRibLoc = EgtCopyGlob( nRibId, nGrpTmp)
    local vtDir = EgtMV( nRibLoc)
    local dParCrv = 1
-   local dTol = 10 * GEO.EPS_SMALL
    for dParCrv = 1, dParE do
       local vtS = EgtUV( nLeadLoc, dParCrv - 1, 1)
       local vtE = EgtUV( nLeadLoc, dParCrv, -1)
-      local dTol = 10 * GEO.EPS_SMALL
-      if AreSameVectorApprox( vtS, vtE) and vtS * vtDir < - 1 + GEO.EPS_SMALL then
+      local dLenCrv = EgtCurveCompoLength( nLeadLoc, dParCrv - 1)
+      if AreSameVectorApprox( vtS, vtE) and vtS * vtDir < - 1 + GEO.EPS_SMALL and dLenCrv > dStrand + GEO.EPS_SMALL then
          local dDist = EgtPointCurveDist( EgtUP( nLeadLoc, dParCrv - 0.5), nRibLoc)
          EgtCopyGlob( nLeadLoc, nGrpTmp)
          if dDist < dStrand + GEO.EPS_SMALL then
@@ -1306,7 +1439,7 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
       end
    end
    
-   -- verifiche con eventuale lead in
+   -- 3) verifiche con eventuale lead in
    if nCurrLI then
       local nLeadInLoc = EgtCopyGlob( nCurrLI, nGrpTmp)
       -- verifico se intersezione fra curve
@@ -1318,6 +1451,7 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
       if dLeadInLen > dStrand + GEO.EPS_SMALL then
          local nSrfLeadIn = EgtSurfFrFatCurve( nGrpTmp, nId, dStrand * ( 1 - dOverlap / 100), false)
          if nSrfLeadIn then
+            -- EgtSetStatus( nSrfLeadIn, GDB_ST.OFF)
             -- verifico di avere un solo tratto esterno di lunghezza sufficiente
             local nRes, nCnt = EgtTrimCurveWithRegion( nLeadInLoc, nSrfLeadIn, false, false)
             if nCnt ~= 1 then
@@ -1378,7 +1512,9 @@ local function FindCorrectRibLead( dPar, nRib, nCrvOffs, bLeadInvert, dLeadLen,
          nOtherRib = EgtIf( bInVsOut, EgtGetNext( nLinkId), EgtGetPrev( nLinkId))
          local nOrigRib1 = EgtGetInfo( nRib, KEY_ORIGINAL_RIB, 'i')
          local nOrigRib2 = EgtGetInfo( nOtherRib, KEY_ORIGINAL_RIB, 'i')
-         if nOrigRib1 ~= nOrigRib2 then
+         local nSplitId1 = EgtGetInfo( nRib, KEY_SPLIT_ID, 'i') or 0
+         local nSplitId2 = EgtGetInfo( nOtherRib, KEY_SPLIT_ID, 'i') or 0
+         if nOrigRib1 ~= nOrigRib2 or ( nOrigRib1 == nOrigRib2 and nSplitId1 ~= nSplitId2) then
             nOtherRib = nil
          end
       end
@@ -1448,7 +1584,7 @@ local function AddRibsLeadIn( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSolid
    end
    
    for i = 1, #vCrvOffs do
-      local dParS = EgtCurveParamAtPoint( vCrvOffs[i], ptS)
+      local dParS = EgtCurveParamAtPoint( vCrvOffs[i], ptS, 100 * GEO.EPS_SMALL)
       if dParS then
          local nLeadIn = FindCorrectRibLead( dParS, nCrv, vCrvOffs[i], bLIInvert, dLILen, true, nGrpTmp, bSpecialCase)
          -- se lead in possibile
@@ -1543,14 +1679,14 @@ local function AddRibsLeadOut( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSoli
                local nType = EgtGetInfo( nCrv, KEY_RIBS_TYPE, 'i')
                if nType == RIB_TYPE.EXTERNAL then dAng = - dAng end
                vtE:rotate( vtSlicing, EgtIf( bInvert, - dAng, dAng))
-               local ptFinal = FindWipeEndPoint( ptE, vtE, dRibsLOWipe, vtSlicing)
+               local ptFinal = ptE + vtE * dRibsLOWipe
                nWipe = EgtCurveCompoFromPoints( EgtGetParent( nCrv), { ptE, ptFinal}, GDB_RT.GLOB)
                if nWipe then
                   EgtModifyCurveExtrusion( nWipe, vtSlicing, GDB_RT.GLOB)
                   EgtRelocateGlob( nWipe, nCoasting or nCrvLO or nCrv, GDB_IN.AFTER)
                   EgtSetName( nWipe, WIPE_CRV)
                   EgtSetInfo( nWipe, KEY_TYPE, TYPE.WIPE)
-                  EgtSetInfo( nWipe, KEY_CRV_STRAND, 0)
+                  EgtSetInfo( nWipe, KEY_CRV_STRAND, dStrand)
                   EgtSetColor( nWipe, EgtStdColor('AQUA'))
                end
             end
@@ -1581,6 +1717,14 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
       local nNewEntId = EgtCopyGlob( vEntIds[i], nTpathGrpId, GDB_IN.LAST_SON)
       -- mi sposto dell'altezza layer
       EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
+      
+      -- approssimo la curva e ne risetto punto iniziale (se chiusa)
+      local ptS = EgtSP( nNewEntId, GDB_ID.ROOT)
+      EgtApproxCurve( nNewEntId, GDB_CA.ARCS, s_dApproxTol)
+      if EgtCurveIsClosed( nNewEntId) then
+         EgtChangeClosedCurveStartPoint( nNewEntId, ptS, GDB_RT.GLOB)
+      end
+      
       EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB)
       EgtSetColor( nNewEntId, EgtStdColor('MAROON'))
       
@@ -1615,21 +1759,25 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
          local bLoopRib = EgtGetInfo( tabRibs[i][1], KEY_LOOP_RIB, 'b') or false
          for j = 1, #tabRibs[i] - 1 do
             local bUserLink = ( EgtGetInfo( tabRibs[i][j], KEY_RIBS_USER_LINK, 'b') or false) and ( EgtGetInfo( tabRibs[i][j+1], KEY_RIBS_USER_LINK, 'b') or false)
+            local bSplitAfterTrim = ( EgtGetInfo( tabRibs[i][j], KEY_SPLIT_AFTER_TRIM, 'b') or false) and ( EgtGetInfo( tabRibs[i][j+1], KEY_SPLIT_AFTER_TRIM, 'b') or false)
             local nOrig1 = EgtGetInfo( tabRibs[i][j], KEY_ORIGINAL_RIB, 'i') or 0
             local nOrig2 = EgtGetInfo( tabRibs[i][j + 1], KEY_ORIGINAL_RIB, 'i') or 0
             local nSplitId1 = EgtGetInfo( tabRibs[i][j], KEY_SPLIT_ID, 'i') or 0
             local nSplitId2 = EgtGetInfo( tabRibs[i][j + 1], KEY_SPLIT_ID, 'i') or 0
             local bForceLink = ( nOrig1 == nOrig2 and nSplitId1 == nSplitId2)
-            local bCheckLinkedRibs = not bForceLink and not bUserLink
             
-            if ( nOrig1 ~= nOrig2 and bUserLink) or ( nSplitId1 == nSplitId2 and nOrig1 == nOrig2) then
-               local nLinkId = CalcRibsLink( tabRibs[i][j], tabRibs[i][j + 1], nLoopGrp, bForceLink, bCheckLinkedRibs, LayerParams.vtSlicing, nGrpTmp)
-              
-               -- se LoopRib congiungo i setti in unico percorso
-               if bLoopRib and nLinkId then
-                  EgtAddCurveCompoCurve( tabRibs[i][j], nLinkId)
-                  EgtAddCurveCompoCurve( tabRibs[i][j], tabRibs[i][j + 1])
-                  tabRibs[i][j+1] = tabRibs[i][j] -- aggiorno id nel vettore dei setti per gestire correttamente la curva allo step successivo
+            -- creo collegamento se userlink, passate dello stesso setto o passate divise dopo trim
+            if ( nOrig1 ~= nOrig2 and bUserLink) or ( nSplitId1 == nSplitId2 and nOrig1 == nOrig2) or ( nOrig1 == nOrig2 and bSplitAfterTrim) then
+               if not bLoopRib then
+                  CalcRibsLink( tabRibs[i][j], tabRibs[i][j + 1], nLoopGrp, bForceLink, LayerParams.vtSlicing, nGrpTmp)
+               else
+                  local nLinkId = CalcLoopRibLink( tabRibs[i][j], tabRibs[i][j + 1], nLoopGrp, LayerParams.vtSlicing, nGrpTmp)
+                  -- se collegamento congiungo i setti in unico percorso
+                  if nLinkId then
+                     EgtAddCurveCompoCurve( tabRibs[i][j], nLinkId)
+                     EgtAddCurveCompoCurve( tabRibs[i][j], tabRibs[i][j + 1])
+                     tabRibs[i][j+1] = tabRibs[i][j] -- aggiorno id nel vettore dei setti per gestire correttamente la curva allo step successivo
+                  end
                end
             end
          end
@@ -1637,7 +1785,7 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
          -- se LoopRib aggiungo collegamento tra primo e ultimo setto del gruppo
          if bLoopRib then
             local nTotCrv = #tabRibs[i]
-            local nLinkId = CalcRibsLink( tabRibs[i][nTotCrv], tabRibs[i][1], nLoopGrp, false, false, LayerParams.vtSlicing, nGrpTmp)
+            local nLinkId = CalcLoopRibLink( tabRibs[i][nTotCrv], tabRibs[i][1], nLoopGrp, LayerParams.vtSlicing, nGrpTmp)
             if nLinkId then
                -- se curva unica
                if tabRibs[i][nTotCrv] == tabRibs[i][1] then
@@ -1668,9 +1816,11 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
    for i = 1, #tabRibs - 1 do
       local bLink1 = EgtGetInfo( tabRibs[i][1], KEY_RIBS_LINK, 'b')
       local bLink2 = EgtGetInfo( tabRibs[i + 1][1], KEY_RIBS_LINK, 'b')
-      if bLink1 and bLink2 then
+      local bLoop1 = EgtGetInfo( tabRibs[i][1], KEY_LOOP_RIB, 'b') or false
+      local bLoop2 = EgtGetInfo( tabRibs[i + 1][1], KEY_LOOP_RIB, 'b') or false
+      if bLink1 and bLink2 and not bLoop1 and not bLoop2 then
          local nCnt = #tabRibs[i]
-         CalcRibsLink( tabRibs[i][nCnt], tabRibs[i + 1][1], nLoopGrp, false, true, LayerParams.vtSlicing, nGrpTmp)
+         CalcRibsLink( tabRibs[i][nCnt], tabRibs[i + 1][1], nLoopGrp, false, LayerParams.vtSlicing, nGrpTmp)
       end
    end
    
@@ -1746,7 +1896,8 @@ local function SpiralVase( vLayIds, LayerParams)
       local vCrvGrpIds = EgtGetNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*")
       if #vCrvGrpIds > 1 then
          -- se più di un gruppo di curve warning
-         EgtOutLog( 'Warning : in spiral vase mode more than one curve (layer '..tostring( nIdx)..') - CalcToolPath')
+         EgtOutBox( 'Error in spiral vase : layer ' .. tostring( nIdx) .. ' has more than one toolpath', 'ToolPathCalc')
+         return false
       end
       
       for i = 1, #vCrvGrpIds do
@@ -1769,9 +1920,15 @@ local function SpiralVase( vLayIds, LayerParams)
          end
 
          -- creo il percorso di lavoro :
-         local nEntId = EgtGetFirstInGroup( nPathGrpId)
-         while nEntId do
-            local nNewEntId = EgtCopyGlob( nEntId, nTpathGrpId, GDB_IN.LAST_SON)
+         local vEntIds = EgtGetAllInGroup( nPathGrpId)
+         if #vEntIds > 1 then
+            EgtOutBox( 'Error in spiral vase : layer ' .. tostring( nIdx) .. ' has more than one toolpath', 'ToolPathCalc')
+            return false
+         end
+         
+         local nNewEntId = EgtCopyGlob( vEntIds[1] or GDB_ID.NULL, nTpathGrpId, GDB_IN.LAST_SON)
+         
+         if nNewEntId then
             
             local vtMove = V_NULL()
             -- eventuale spostamento dell'altezza layer
@@ -1779,7 +1936,7 @@ local function SpiralVase( vLayIds, LayerParams)
                vtMove = LayerParams.dLayHeight * LayerParams.vtSlicing
                EgtMove( nNewEntId, vtMove, GDB_RT.GLOB)
             end
-
+      
             EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB)
             EgtSetInfo( nNewEntId, KEY_CRV_STRAND, LayerParams.dStrand)
             
@@ -1791,7 +1948,7 @@ local function SpiralVase( vLayIds, LayerParams)
             EgtSetColor( nNewEntId, EgtStdColor('GRAY'))
             
             -- se primo layer
-            if bFirst and nNewEntId then
+            if bFirst then
                -- mi sposto dell'altezza layer
                EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
                -- eventuale lead in
@@ -1823,15 +1980,23 @@ local function SpiralVase( vLayIds, LayerParams)
                EgtSpiralizeCurveAlongExtrusion( nNewEntId, LayerParams.dLayHeight)
             end
             
-            nOldPathId = nEntId
+            -- approssimo la curva
+            if nNewEntId then
+               local ptS = EgtSP( nNewEntId, GDB_ID.ROOT)
+               EgtApproxCurve( nNewEntId, GDB_CA.ARCS, s_dApproxTol)
+               if EgtCurveIsClosed( nNewEntId) then
+                  EgtChangeClosedCurveStartPoint( nNewEntId, ptS, GDB_RT.GLOB)
+               end
+            end
+            
+            nOldPathId = vEntIds[1]
             nOldId = nNewEntId
-            nEntId = EgtGetNext( nEntId)
          end
-         
+
          -- aggiorno il box dei toolpath
          local b3Box = ComputeToolPathBox( nTpathGrpId)
          b3Tot:Add( b3Box)
-         
+
       end
       
       if EgtProcessEvents( EgtIf( PRINT, 300, 0) + nIdx / #vLayIds * 100, 0) == 1 then
@@ -1864,18 +2029,13 @@ function CalcToolPath.Exec( nPartId)
    -- recupero i parametri per calcolo dei toolpath
    local LayerParams = GetLayerParamsForToolPathCalc()
    
-   -- altezza necessaria per correzione wipe
-   local dNxy = sqrt( LayerParams.vtSlicing:getX() * LayerParams.vtSlicing:getX() + LayerParams.vtSlicing:getY() * LayerParams.vtSlicing:getY())
-   local dHBox = EgtGetInfo( s_nPartId, KEY_BOX_MIN_Z, 'i') or 0
-   s_dHMin = LayerParams.dTDiam / 2 * dNxy + dHBox
-   
    -- caso spiral vase
    if LayerParams.bSpiralVase then
       return SpiralVase( vLayIds, LayerParams)
    end
 
    local b3Tot = BBox3d() -- box dei toolpath
-   
+   local nLayCnt = 1
    -- Ciclo sui layer
    for nIdx = 1, #vLayIds do
       
@@ -1958,6 +2118,11 @@ function CalcToolPath.Exec( nPartId)
          local b3Box = ComputeToolPathBox( nTpathGrpId)
          b3Tot:Add( b3Box)
          
+         -- verifico non sia vuoto per aggiornare il numero di layers
+         if EgtGetFirstInGroup( nTpathGrpId) then
+            nLayCnt = nIdx
+         end
+         
          -- passo al gruppo di contorni successivo
          nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*")
       end
@@ -1971,6 +2136,9 @@ function CalcToolPath.Exec( nPartId)
    -- correzione in z
    AddZCorrection( b3Tot, LayerParams)
    
+   -- setto info con numero di layers effettivi
+   EgtSetInfo( nPartId, KEY_LAYER_CNT, nLayCnt)
+      
    return true
 end
 

LuaLibs/RunCalcSolids.lua

@@ -21,6 +21,7 @@ local function GetLayerParamsForSolidCalc( nPartId)
    LayerParams.bSpiralVase = EgtGetInfo( nPartId, KEY_SPIRAL_VASE, 'b') or false
    LayerParams.dLayHeight = EgtGetInfo( nPartId, KEY_SLICE_STEP, 'd')
    LayerParams.vtSlicing = EgtGetInfo( nPartId, KEY_SLICING_DIR, 'v')
+   LayerParams.dStrand = EgtGetInfo( nPartId, KEY_STRAND, 'd')
    return LayerParams
 end
 
@@ -154,7 +155,11 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
          return nil
       end
    end
+
    local nSrfId = EgtSurfTmBySewing( nSolidGrp, vSurfs)
+   if not nSrfId then
+     nSrfId = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
+   end
   
    -- creazione del mezzo disco iniziale
    local nCap1 = CreateSpiralVaseCap( nSectId, - vtS, nSolidGrp)
@@ -165,7 +170,7 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
    -- cancello le curve usate per la costruzione
    EgtErase( nGrpTmp)
 
-   return EgtSurfTmBySewing( nSolidGrp, { nSrfId, nCap1, nCap2})
+   return EgtSurfTmBySewing( nSolidGrp, { nSrfId, nCap1, nCap2}) or EgtSurfTmByTriangles( nSolidGrp, { nSrfId, nCap1, nCap2})
 end
 
 ----------------------------------------------------------------------
@@ -185,6 +190,36 @@ local function CreateSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
    end
 end
 
+---------------------------------------------------------------------
+local function CreateDirectionArrow( nCrvId, nSolidGrp, vtSlicing, dStrand, nLayer)
+   
+   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, nLayer)
+   EgtSetStatus( nSrf, GDB_ST.OFF)
+   EgtSetMode( nSrf, GDB_MD.HIDDEN)
+   EgtSetName( nSrf, DIR_ARROW)
+   
+end
+
 ---------------------------------------------------------------------
 local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
   
@@ -207,7 +242,7 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
    elseif nType == TYPE.AUX_SOLID then
       Color = EgtStdColor( 'AQUA')
    end
-   local dStrand = EgtGetInfo( nCrvId, KEY_CRV_STRAND, 'd')
+   local dStrand = EgtGetInfo( nCrvId, KEY_CRV_STRAND, 'd') or LayerParams.dStrand
    
    local nCopyId = EgtCopyGlob( nCrvId, nSolidGrp)
    local nId = GDB_ID.NULL
@@ -224,6 +259,12 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
       nId = EgtSplitCurve( nCopyId, nParts)
    end
    
+   -- 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, nLayer)
+   end
+   
    if nId == GDB_ID.NULL then return false end
    local bOk = true
    for nInd = 0, nParts - 1 do
@@ -304,6 +345,11 @@ function RunCalcSolids.Exec()
 
          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 then
@@ -339,7 +385,7 @@ function RunCalcSolids.Exec()
                      EgtSetName( nSolidGrpId, SOLID_GRP)
                      EgtSetLevel( nSolidGrpId, GDB_LV.TEMP)
                      -- scorro le curve del percorso utensile
-                     local nId = EgtGetFirstInGroup( nTPathGrpId) 
+                     local nId = EgtGetFirstInGroup( nTPathGrpId)
                      while nId do
                         local bOk = CreateSolidFromCurve( nId, nSolidGrpId, LayerParams, nLayer)
                         nId = EgtGetNext( nId)
@@ -389,9 +435,8 @@ function RunCalcSolids.Exec()
                EgtSetInfo( nViewId, SOLID_GRP, true)
             end
          end
-
       end
-
+      
       nPartIndex = nPartIndex + 1
       nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) or EgtGetNextName( nPartId, PART)
    end

LuaLibs/RunMachParamFromSWCalc.lua

@@ -1,4 +1,4 @@
--- RunMachParamFromSWCalc.lua by Egaltech s.r.l. 2022/12/28
+-- RunMachParamFromSWCalc.lua by Egaltech s.r.l. 2024/01/30
 -- Calcolo dei parametri di stampa
 
 -- Tabella per definizione modulo
@@ -62,7 +62,7 @@ function RunMachParamFromSWCalc.Exec()
    while nPartId do
       if not EgtGetInfo( nPartId, KEY_PART_ON_TABLE, 'b') then
          nPartId = EgtGetNextPart( nPartId)
-         goto continue 
+         goto continue
       end
       -- recupero i parametri di lavorazione del pezzo
       local dSliceStep = EgtGetInfo( nPartId, KEY_SLICE_STEP, 'd')
@@ -77,6 +77,8 @@ function RunMachParamFromSWCalc.Exec()
       while nLayerId do
          -- rimuovo eventuale info precedente del tempo di attesa
          EgtRemoveInfo( nLayerId, KEY_WAITING_TIME)
+         -- divido curve in base alla larghezza strand
+         local LengthCrvList = {}
          -- calcolo lunghezza totale del layer
          local dTotLayerLength = 0
          local dTotLayerLengthForMass = 0
@@ -84,14 +86,29 @@ function RunMachParamFromSWCalc.Exec()
          local nCrvId = EgtGetFirstNameInGroup( nLayerId, CONTOUR_GRP .. '*')
          while nCrvId do
             local nToolPathId = EgtGetFirstNameInGroup( nCrvId, TOOLPATH_GRP)
-            -- sommo lunghezze percorsi
+            -- recupero lunghezze percorsi
             local dTotCrvLength = 0
             local dTotCrvLengthForMass = 0
-            nShellId = EgtGetFirstInGroup( nToolPathId)
+            local nShellId = EgtGetFirstInGroup( nToolPathId)
             while nShellId do
-               dTotCrvLength = dTotCrvLength + EgtCurveLength( nShellId)
+               local dShellWidth = EgtGetInfo( nShellId, KEY_CRV_STRAND, "d")
+               local dShellLength = EgtCurveLength( nShellId)
+               local bFound = false
+               for LengthIndex = 1, #LengthCrvList do
+                  if LengthCrvList[LengthIndex].Width == dShellWidth then
+                     table.insert( LengthCrvList[LengthIndex].IdList, nShellId) 
+                     LengthCrvList[LengthIndex].Length = LengthCrvList[LengthIndex].Length + dShellLength
+                     bFound = true
+                     break
+                  end
+               end
+               if not bFound then
+                  table.insert( LengthCrvList, { Width = dShellWidth, IdList = { nShellId}, Length = dShellLength})
+               end
+               -- sommo per lunghezza totale
+               dTotCrvLength = dTotCrvLength + dShellLength
                if EgtGetName( nShellId) ~= WIPE_CRV then
-                  dTotCrvLengthForMass = dTotCrvLengthForMass + EgtCurveLength( nShellId)
+                  dTotCrvLengthForMass = dTotCrvLengthForMass + dShellLength
                end
                nShellId = EgtGetNext( nShellId)
             end
@@ -132,11 +149,17 @@ function RunMachParamFromSWCalc.Exec()
             table.insert( nOrigLayers, nLayerId)
          end
          EgtSetInfo( nLayerResultId, KEY_SLICEID, nOrigLayers)
+         -- calcolo strand medio (media ponderata sulla lunghezza)
+         local dStrandMean = 0
+         for nMeanIndex = 1, #LengthCrvList do
+            dStrandMean = dStrandMean + LengthCrvList[nMeanIndex].Width * LengthCrvList[nMeanIndex].Length
+         end
+         dStrandMean = dStrandMean / EgtIf( dTotLayerLength > 0.1, dTotLayerLength, 1)
          -- calcolo costante MF
          local dMF = 1
          local dSC = 1
          if dTotLayerArea > 1 then
-            dMF = dTotLayerLength * dStrand / dTotLayerArea * 100
+            dMF = dTotLayerLength * dStrandMean / dTotLayerArea * 100
             dSC = dStrandCount
          else
             dMF = 100
@@ -151,12 +174,12 @@ function RunMachParamFromSWCalc.Exec()
             end
          end
          -- calcolo tempi stimati del layer
-         local dTMin = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMin) / MATERIAL.BMin * pow( 0.25 * dStrand, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
-         local dTTrg = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.ATrg) / MATERIAL.BTrg * pow( 0.25 * dStrand, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
-         local dTMax = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMax) / MATERIAL.BMax * pow( 0.25 * dStrand, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
-         local dFMin = dTotLayerLength / dTMax * 60
-         local dFTrg = dTotLayerLength / dTTrg * 60
-         local dFMax = dTotLayerLength / dTMin * 60
+         local dTMin = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMin) / MATERIAL.BMin * pow( 0.25 * dStrandMean, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
+         local dTTrg = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.ATrg) / MATERIAL.BTrg * pow( 0.25 * dStrandMean, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
+         local dTMax = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMax) / MATERIAL.BMax * pow( 0.25 * dStrandMean, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
+         local dFMin = dTotLayerLength / EgtIf( dTMax > 0.1, dTMax, 1) * 60
+         local dFTrg = dTotLayerLength / EgtIf( dTTrg > 0.1, dTTrg, 1) * 60
+         local dFMax = dTotLayerLength / EgtIf( dTMin > 0.1, dTMin, 1) * 60
          local dLayerTime = dTTrg
          if dLayerFeed == 0 then
             dLayerFeed = dFTrg
@@ -165,7 +188,7 @@ function RunMachParamFromSWCalc.Exec()
          end
          dLayerWait = floor( dTMin + 0.5) - floor( dLayerTime + 0.5)
          -- calcolo la portata
-         local Vf = dLayerFeed * ( ( dStrand - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2)) / 1000
+         local Vf = dLayerFeed * ( ( dStrandMean - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2)) / 1000
          -- calcolo speed
          local dSpeed = ( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0) * pow( Vf / MATERIAL.C1, 1 / MATERIAL.C2)
          -- verifico se speed esce da minimo e massimo della macchina
@@ -179,16 +202,30 @@ function RunMachParamFromSWCalc.Exec()
             dSpeed = dSMax
          end
          if not bSpeedOk then
-            dLayerFeed = ( MATERIAL.C1 * pow( ( dSpeed / (( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0))), MATERIAL.C2)) * 1000 / ( ( dStrand - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2))
-            dLayerTime = dTotLayerLength / dLayerFeed * 60
+            if dTotLayerLength > 0.1 then
+               dLayerFeed = ( MATERIAL.C1 * pow( ( dSpeed / (( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0))), MATERIAL.C2)) * 1000 / ( ( dStrandMean - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2))
+               dLayerTime = dTotLayerLength / dLayerFeed * 60
+            end
             dLayerWait = floor( dTMin + 0.5) - floor( dLayerTime + 0.5)
          end
          -- calcolo massa dello strato
-         local dLayerMass = dTotLayerLengthForMass * dSliceStep * dStrand * MATERIAL.Density * 1e-6
+         local dLayerMass = dTotLayerLengthForMass * dSliceStep * dStrandMean * MATERIAL.Density * 1e-6
          if dLayerMass and dLayerMass > 0 then
             dPrintMass = dPrintMass + dLayerMass
          end
-         -- scrivo info feed e speed in group toolpath
+         -- scrivo info feed su tutti i tratti
+         local dFeedMax = 0
+         for nWidthIndex = 1, #LengthCrvList do
+            local CurrWidth = LengthCrvList[nWidthIndex]
+            local CurrFeed = EgtIf( CurrWidth.Width > 0, dLayerFeed * dStrandMean / CurrWidth.Width, dLayerFeed) 
+            for nCurveIdIndex = 1, #CurrWidth.IdList do
+               EgtSetInfo( CurrWidth.IdList[nCurveIdIndex], KEY_FEED, CurrFeed)               
+            end
+            if CurrFeed > dFeedMax then
+               dFeedMax = CurrFeed
+            end
+         end
+         -- scrivo info speed in group toolpath
          nCrvId = EgtGetFirstNameInGroup( nLayerId, CONTOUR_GRP .. '*')
          while nCrvId do
             local nToolPathId = EgtGetFirstNameInGroup( nCrvId, TOOLPATH_GRP) or GDB_ID.NULL
@@ -202,13 +239,11 @@ function RunMachParamFromSWCalc.Exec()
             EgtSetInfo( nLayerResultId, KEY_WAITING_TIME, dLayerWait)
          end
          -- scrivo valori in struttura dati
-         --local nLayerResultId = EgtGetFirstNameInGroup( nResultLayerId, nLayerIndex)
          EgtSetInfo( nLayerResultId, KEY_TMIN, dTMin)
          EgtSetInfo( nLayerResultId, KEY_TTRG, dTTrg)
          EgtSetInfo( nLayerResultId, KEY_TMAX, dTMax)
-         EgtSetInfo( nLayerResultId, KEY_FMIN, dFMin)
          EgtSetInfo( nLayerResultId, KEY_FTRG, dFTrg)
-         EgtSetInfo( nLayerResultId, KEY_FMAX, dFMax)
+         EgtSetInfo( nLayerResultId, KEY_FMAX, dFeedMax)
          EgtSetInfo( nLayerResultId, KEY_TCUR, dLayerTime)
          EgtSetInfo( nLayerResultId, KEY_FCUR, dLayerFeed)
          EgtSetInfo( nLayerResultId, KEY_LENGTH, dTotLayerLength)
@@ -220,11 +255,12 @@ function RunMachParamFromSWCalc.Exec()
             EgtEmptyGroup( nResultLayerId)
             return
          end
-         
+         -- passo al layer successivo
          nLayerIndex = nLayerIndex + 1
          nLayerId = EgtGetFirstNameInGroup( nPartId, SLICE_LAYER .. nLayerIndex) or EgtGetFirstNameInGroup( nPartId, "__" .. SLICE_LAYER .. nLayerIndex)
       end
       if nMaxIndex < nLayerIndex then nMaxIndex = nLayerIndex end
+      -- passo al pezzo successivo
       nPartId = EgtGetNextPart( nPartId)
       ::continue::
    end

LuaLibs/RunPrepareExport.lua

@@ -0,0 +1,200 @@
+-- RunPrepareExport.lua by Egaltech s.r.l. 2023/10/19
+-- Creo le geometrie da esportare con 3dm
+
+-- Tabella per definizione modulo
+local RunPrepareExport = {}
+
+-- Intestazioni
+require( 'EgtBase')
+
+EgtOutLog( ' RunPreprareExport started', 1)
+
+-- Dati
+local AMD = require( 'AddManData')
+
+------------------------------------------------------------------
+local function CalcCurves( nSliceId, nDestGrp, vtSlicing, dStrandBase)
+   
+   -- scorro tutti i gruppi di curve
+   local vCrvs = EgtGetNameInGroup( nSliceId, CONTOUR_GRP .. '*')
+   for j = 1, #vCrvs do
+      -- cerco il gruppo del toolpath
+      local nTPath = EgtGetFirstNameInGroup( vCrvs[j], TOOLPATH_GRP)
+      if nTPath then
+         local nId = EgtGetFirstInGroup( nTPath)
+         while nId do
+            -- se non è wipe creo la fat curve da estrudere per creare il solido
+            local nType = EgtGetInfo( nId, KEY_TYPE, 'i')
+            if nType ~= TYPE.WIPE then
+               local dStrand = EgtGetInfo( nId, KEY_CRV_STRAND, 'd') or dStrandBase
+               
+               -- calcolo fat curve a partire da una copia della curva ( in questo modo nel DB geometrico non restano
+               -- salvati i diagrammi di Voronoi che non servono per conti futuri)
+               local nCopy = EgtCopyGlob( nId, nDestGrp)
+               local nCrv, nCnt = EgtCurveGetFatCurve( nCopy, nDestGrp, 0.5 * dStrand, false)
+               -- se fallisce ritento con valore leggermente diverso
+               if not nCrv or nCnt == 0 then
+                  nCrv, nCnt = EgtCurveGetFatCurve( nCopy, nDestGrp, 0.5 * dStrand - 0.05, false)
+               end
+               EgtErase( nCopy)
+                 
+               if nCrv and nCnt > 0 then
+                  -- se sono curve chiuse piccoli aggistamenti per creare un percorso unico
+                  if nCnt > 1 then
+                     for nLoopId = nCrv + 1, nCrv + nCnt - 1 do
+                        EgtInvertCurve( nLoopId)
+                        local dLen = EgtCurveLength( nLoopId)
+                        local dPar1 = EgtCurveParamAtLength( nLoopId, dLen * 0.5)
+                        local dPar2 = EgtCurveParamAtLength( nLoopId, dLen * 0.5 + 2 * GEO.EPS_SMALL)
+                        local ptM = EgtUP( nLoopId, dPar1)
+                        local ptM2 = EgtUP( nLoopId, dPar2)
+                        local _, _, dParRef1 = EgtPointCurveDist( ptM, nCrv)
+                        local _, _, dParRef2 = EgtPointCurveDist( ptM, nCrv)
+                        EgtTrimCurveStartEndAtParam( nCrv, dParRef2, dParRef1)
+                        EgtTrimCurveStartEndAtParam( nLoopId, dPar2, dPar1)
+                        EgtInvertCurve( nLoopId)
+                        EgtAddCurveCompoLine( nCrv, EgtSP( nLoopId))
+                        EgtAddCurveCompoCurve( nCrv, nLoopId)
+                        EgtCloseCurveCompo( nCrv)
+                     end
+                  end
+                  
+                  if nType == TYPE.OUTER_SHELL or nType == TYPE.EXTRA_OUTER_SHELL then 
+                     EgtSetColor( nCrv, EgtStdColor( 'TEAL'))
+                  elseif nType == TYPE.INNER_SHELL or nType == TYPE.EXTRA_SHELL then
+                     EgtSetColor( nCrv, EgtStdColor( 'ORANGE'))
+                  elseif nType == TYPE.LINK then
+                     EgtSetColor( nCrv, EgtStdColor( 'GRAY'))
+                  elseif nType == TYPE.INFILL then
+                     EgtSetColor( nCrv, EgtStdColor( 'YELLOW'))
+                  elseif nType == TYPE.COASTING then
+                     EgtSetColor( nCrv, EgtStdColor( 'BLUE'))
+                  elseif nType == TYPE.RIB then
+                     EgtSetColor( nCrv, EgtStdColor( 'OLIVE'))
+                  elseif nType == TYPE.AUX_SOLID then
+                     EgtSetColor( nCrv, EgtStdColor( 'AQUA'))
+                  end
+               end
+            end
+            
+            nId = EgtGetNext( nId)
+         end
+      end
+
+      -- copio le frecce direzione dal gruppo dei solidi
+      local nSolidGrp = EgtGetFirstNameInGroup( vCrvs[j], SOLID_GRP)
+      if nSolidGrp then
+         local nId = EgtGetFirstNameInGroup( nSolidGrp, DIR_ARROW)
+         while nId do
+            local nCopy = EgtCopyGlob( nId, nDestGrp)
+            EgtSetMode( nCopy, GDB_MD.STD)
+            EgtSetStatus( nCopy, GDB_ST.ON)
+            nId = EgtGetNextName( nId, DIR_ARROW)
+         end
+      end
+   end
+end
+
+------------------------------------------------------------------
+local function CalcSpiralVase( nSliceId, nDestGrp)
+   
+   -- scorro tutti i gruppi di curve
+   local vCrvs = EgtGetNameInGroup( nSliceId, CONTOUR_GRP .. '*')
+   for j = 1, #vCrvs do
+      -- recupero il solido dal gruppo
+      local nSolidGrp = EgtGetFirstNameInGroup( vCrvs[j], SOLID_GRP)
+      if nSolidGrp then
+         local vSolids = EgtGetAllInGroup( nSolidGrp)
+         for i = 1, #vSolids do
+            EgtCopyGlob( vSolids[i], nDestGrp)
+         end
+      end
+   end
+end
+
+------------------------------------------------------------------
+function RunPrepareExport.Exec()
+
+   local nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. '*')
+   if not nPartId then 
+      EgtOutBox( 'Error : no part', 'Export')
+      return GDB_ID.NULL
+   end
+   
+   -- creo o recupero il gruppo per l'esportazione
+   local nGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, LAY_EXPORT)
+   if not nGrp then
+      -- se non esiste creo il gruppo
+      nGrp = EgtGroup( GDB_ID.ROOT)
+      EgtSetName( nGrp, LAY_EXPORT)
+      EgtSetStatus( nGrp, GDB_ST.OFF)
+      EgtSetLevel( nGrp, GDB_LV.TEMP)
+   else
+      -- se il gruppo esiste già non devo fare nulla
+      return nGrp
+   end
+   
+   -- creo il punto di origine del riferimento
+   local ptRef = EgtGetInfo( nPartId, KEY_ORIG_REF, 'p')
+   if not ptRef then
+      local nFrameId = EgtGetFirstNameInGroup( EgtGetFirstNameInGroup( nPartId, LAY_FRAME), FRAME_PART)
+      ptRef = EgtSP( nFrameId or GDB_ID.NULL, GDB_ID.ROOT)
+   end
+   local nPnt = EgtPoint( nGrp, ptRef, GDB_RT.GLOB)
+   EgtSetName( nPnt, KEY_ORIG_REF)
+   EgtSetStatus( nPnt, GDB_ST.OFF)
+   
+   -- recupero alcune info utili e le assegno al punto per poterle leggere da ThreeJS
+   local dH = EgtGetInfo( nPartId, KEY_SLICE_STEP, 'd')
+   EgtSetInfo( nPnt, KEY_SLICE_STEP, dH)
+   local vtSlicing = EgtGetInfo( nPartId, KEY_SLICING_DIR, 'v')
+   EgtSetInfo( nPnt, KEY_SLICING_DIR, vtSlicing)
+   local bSpiralVase = EgtGetInfo( nPartId, KEY_SPIRAL_VASE, 'b') or false
+   EgtSetInfo( nPnt, KEY_SPIRAL_VASE, bSpiralVase)
+   
+   -- recupero lo strand dai parametri generale nel caso non fosse definito sulle singole curve
+   local dStrandBase = EgtGetInfo( nPartId, KEY_STRAND, 'd') or 0
+   
+   -- recupero gli slices
+   local vSlices = EgtGetNameInGroup( nPartId, SLICE_LAYER .. '*') or {}
+   if #vSlices == 0 then
+      EgtOutBox( 'Error : no slices', 'Export')
+      return GDB_ID.NULL
+   end
+   
+   -- verifico che nel primo slice siano presenti sia i toolpath sia i solidi
+   local nCrvGrp = EgtGetFirstNameInGroup( vSlices[1], CONTOUR_GRP .. '*')
+   if not nCrvGrp then
+      EgtOutBox( 'Error : no toolpaths', 'Export')
+      return GDB_ID.NULL
+   end
+   local nTPath = EgtGetFirstNameInGroup( nCrvGrp, TOOLPATH_GRP)
+   if not nTPath then
+      EgtOutBox( 'Error : no toolpaths', 'Export')
+      return GDB_ID.NULL
+   end
+   local nSolid = EgtGetFirstNameInGroup( nCrvGrp, SOLID_GRP)
+   if not nSolid then
+       EgtOutBox( 'Error : no solids', 'Export')
+      return GDB_ID.NULL
+   end
+
+   for i = 1, #vSlices do
+     
+      -- creo il gruppo corrispondente
+      local nDestGrp = EgtGroup( nGrp)
+      EgtSetName( nDestGrp, EgtGetName( vSlices[i]))
+      EgtSetStatus( nDestGrp, GDB_ST.OFF)
+      
+      if bSpiralVase then
+         CalcSpiralVase( vSlices[i], nDestGrp)
+      else
+         CalcCurves( vSlices[i], nDestGrp, vtSlicing, dStrandBase)
+      end
+   end
+   
+   return nGrp
+end
+
+---------------------------------------------------------------------
+return RunPrepareExport

LuaLibs/RunSlicing.lua

@@ -79,6 +79,13 @@ local function RemoveOldSlices( nPartId)
       EgtErase( nInfillId)
       nInfillId = EgtGetFirstNameInGroup( nPartId, INFILL_GRP .. '*')
    end
+   
+   -- rimuovo gruppo per export
+   local nExportGrpId = EgtGetFirstNameInGroup( GDB_ID.ROOT, LAY_EXPORT)
+   if nExportGrpId then
+      EgtErase( nExportGrpId)
+   end
+   
 end
 
 ---------------------------------------------------------------------
@@ -157,10 +164,6 @@ function RunSlicing.Exec()
    EgtRemoveAllOperations()
    EgtResetCurrMachGroup()
 
-   -- Lettura dati macchina
-   local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
-   local HMax = tonumber( EgtGetStringFromIni( '3dPrinting', 'HMax', 500, sMachIni))
-
    -- Eventuale ripristino posizione originaria
    RestoreOriginalPosition( nPartId)
    
@@ -171,7 +174,7 @@ function RunSlicing.Exec()
    RemoveOldTFS()
   
    -- Calcolo delle fette
-   local bOk = CSLICES.Exec( nPartId, nStmId, HMax)
+   local bOk = CSLICES.Exec( nPartId, nStmId)
    EgtDraw()
 
    -- Calcolo dei percorsi sul centro strand in basso

PrepareExport.lua

@@ -0,0 +1,17 @@
+-- PrepareExport.lua by Egaltech s.r.l. 2023/10/19
+-- Creo le geometrie da esportare con 3dm
+
+-- Intestazioni
+require( 'EgtBase')
+_ENV = EgtProtectGlobal()
+EgtEnableDebug( false)
+
+-- Imposto direttorio libreria specializzata per Stampa 3d
+EgtAddToPackagePath( PRINT.BASEDIR .. '\\LuaLibs\\?.lua')
+
+-- Librerie
+_G.package.loaded.RunPrepareExport = nil
+local RPE = require( 'RunPrepareExport')
+
+-- Calcolo
+PRINT.EXPORTLAYER = RPE.Exec()

Version.lua

@@ -1,4 +1,4 @@
--- Version.lua by Egaltech s.r.l. 2023/02/28
+-- Version.lua by Egaltech s.r.l. 2024/02/13
 -- Gestione della versione di 3dPrinting
 
-VERSION = '2.5g1'
+VERSION = '2.6b1'