3dPrinting :

- correzione solidi spiral vase.

.gitlab-ci.yml

@@ -16,14 +16,14 @@ variables:
     $FileList = Get-ChildItem("*.lua")
     ForEach ($File in $FileList) {
       $FileName = Split-Path $File -leaf
-      lua54 -o bin\$FileName $FileName
-      echo "lua54 -o bin\$FileName $FileName"
+      lua54 -o bin\$FileName -s $FileName
+      echo "lua54 -o bin\$FileName -s $FileName"
     }
     $FileList = Get-ChildItem("LuaLibs\*.lua")
     ForEach ($File in $FileList) {
       $FileName = Split-Path $File -leaf
-      lua54 -o bin\LuaLibs\$FileName LuaLibs\$FileName
-      echo "lua54 -o bin\LuaLibs\$FileName LuaLibs\$FileName"
+      lua54 -o bin\LuaLibs\$FileName -s LuaLibs\$FileName
+      echo "lua54 -o bin\LuaLibs\$FileName -s LuaLibs\$FileName"
     }
 
 # helper copia SORGENTI verso cartella di rete R:\ dei SORGENTI

Compile.bat

@@ -1,19 +1,21 @@
 
-REM Compilazione degli script 3dPrinting Egaltech                         2023.01.11
+REM Compilazione degli script 3dPrinting Egaltech                         2024.03.27
 REM Per togliere info di debug aggiungere flag -s prima del nome del file di input
 
 REM Compilazione 32 e 64 bit
 
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\AddManData.lua                    LuaLibs\AddManData.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcPaths.lua                     LuaLibs\CalcPaths.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcSlices.lua                    LuaLibs\CalcSlices.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcToolPath.lua                  LuaLibs\CalcToolPath.lua
-\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\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\Slicing.lua                               Slicing.lua
-\EgtProg\Dll32\luac54 -o bin\Version.lua                               Version.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\AddManData.lua                  -s LuaLibs\AddManData.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcPaths.lua                   -s LuaLibs\CalcPaths.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcSlices.lua                  -s LuaLibs\CalcSlices.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcToolPath.lua                -s LuaLibs\CalcToolPath.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunCalcSolids.lua               -s LuaLibs\RunCalcSolids.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunGcodeGenerate.lua            -s LuaLibs\RunGcodeGenerate.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunMachParamFromSWCalc.lua      -s LuaLibs\RunMachParamFromSWCalc.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunPrepareExport.lua            -s LuaLibs\RunPrepareExport.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunSlicing.lua                  -s LuaLibs\RunSlicing.lua
+\EgtProg\Dll32\luac54 -o bin\CalcMachParamFromSW.lua                 -s CalcMachParamFromSW.lua
+\EgtProg\Dll32\luac54 -o bin\CalcSolids.lua                          -s CalcSolids.lua
+\EgtProg\Dll32\luac54 -o bin\GcodeGenerate.lua                       -s GcodeGenerate.lua
+\EgtProg\Dll32\luac54 -o bin\PrepareExport.lua                       -s PrepareExport.lua
+\EgtProg\Dll32\luac54 -o bin\Slicing.lua                             -s Slicing.lua
+\EgtProg\Dll32\luac54 -o bin\Version.lua                             -s 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
@@ -41,6 +45,8 @@ SEC_DEFAULT = "Default"
 KEY_PARAMS = "Params"
 KEY_CALC_SOLIDS = "CalcSolids"
 KEY_SPIRAL_VASE = "SpiralVase"
+KEY_SPIRAL_VASE_LEN = 'SpiralVaseLen'
+KEY_SPIRAL_VASE_INTERP_LEN = 'SpiralVaseInterpLen'
 KEY_SLICING_TYPE = "SlicingType"
 KEY_SLICING_DIR = "SlicingDir"
 KEY_SLICE_STEP = "StrandH"
@@ -107,6 +113,7 @@ KEY_RIBS_STRAND = "RibsStrandW"
 KEY_RIBS_TYPE = "RibsType"
 KEY_LIMIT_UNBDD_RIBS = "LimitUnboundedRibsWithSolid"
 KEY_RIBS_OVERLAP = "RibsOverlap"
+KEY_RIBS_STRAND_OVERLAP = 'RibsStrandOverlap'
 KEY_RIBS_SHELLS_NBR = "RibsStrandCount"
 KEY_RIBS_LINK = "RibsLink"
 KEY_RIBS_INVERT_DIR = "RibsInvertDirection"
@@ -134,6 +141,10 @@ 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"
+KEY_RIBS_LEAD_FILLET = "RibsLeadFillet"
+KEY_RIBS_LINK_FILLET = "RibsLinkFillet"
 
 -- Regioni con diverso numero di passate
 KEY_SHELL_NBR_DIFF = "ShellNbrDifference"
@@ -170,9 +181,13 @@ KEY_COEFF_X = "CoeffX"
 KEY_COEFF_Y = "CoeffY"
 KEY_SPEED_MIN = "SpeedMin"
 KEY_SPEED_MAX = "SpeedMax"
+KEY_FEED_MAX = 'FeedMax'
+KEY_LINEAR_APPROX = 'LinearApprox'
+KEY_LINEAR_TOL = 'LinearTol'
 
 -- Altre chiavi
 KEY_MAX_H = "SlicingHeight"
+KEY_MAX_SLICES_NBR = "MaxSlicesNumber"
 KEY_SLICE_NBR = "SliceNbr"
 KEY_SLICE_Z = "SliceZ"
 KEY_SLICE_DELTAZ = "DeltaZ"
@@ -196,8 +211,12 @@ KEY_PREV_CRV = "PrevCrv"
 KEY_NEXT_CRVS = "NextCrvs"
 KEY_CRV_STRAND = "CurveStrand"
 KEY_LAYER_CNT = "LayerCnt"
+KEY_CRV_OFFSET = "CurveOffset"
+KEY_ORIG_REF = "Orig"
+KEY_WIPE_ON_CRV = "WipeOnCrv"
+KEY_FEED_COEFF = 'FeedCoeff'
 
-SLICING_TYPE = {
+SLICING_TYPE = {   
    VERTICAL = 1,
    DEG45_X = 2,
    DEG45_Y = 3,
@@ -288,6 +307,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

@@ -27,11 +27,19 @@ local MIN_AREA = 25.0
 ---------------------------------------------------------------------
 local function ComputeZSlices( dSliceStep, dZmin, dDeltaZ, dZmax)
    
+   -- verifico se è impostato un numero massimo di slices
+   local nMaxSlicesNbr = EgtGetInfo( s_nPartId, KEY_MAX_SLICES_NBR, 'i') or 0
+   if nMaxSlicesNbr == 0 then
+      nMaxSlicesNbr = GEO.INFINITO   -- da gestire come caso illimitato
+   end
+   
+   local nCnt = 1
    local ptSlices = { dZmin + dDeltaZ}
    local dPosZ = dZmin + dSliceStep
-   while dPosZ < dZmax do
+   while dPosZ < dZmax and nCnt < nMaxSlicesNbr do
       table.insert( ptSlices, dPosZ)
       dPosZ = dPosZ + dSliceStep
+      nCnt = nCnt + 1
    end 
    return ptSlices
 end
@@ -117,10 +125,14 @@ local function GetRibParams( nId)
    ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE, 'd', 0, RibParam)
    ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd', 0, RibParam)
    ReadParam( nId, KEY_RIBS_OVERLAP, 'd', 0, RibParam)
+   ReadParam( nId, KEY_RIBS_STRAND_OVERLAP, 'd', 0, RibParam)
    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)
+   ReadParam( nId, KEY_RIBS_LEAD_FILLET, 'd', 0, RibParam)
+   ReadParam( nId, KEY_RIBS_LINK_FILLET, 'd', 0, RibParam)
+   
    return RibParam
 end
 
@@ -997,6 +1009,7 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
          
          if #vOpenId > 1 then
             EgtOutLog( 'Error : hole in solid (layer '.. EgtNumToString( nLayCnt) ..') - CalcSlices')
+            table.insert( s_vErr, nLayCnt)
          end
       else
          
@@ -1040,17 +1053,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
@@ -1140,8 +1153,6 @@ function CalcSlices.Exec( nPartId, nStmId)
    local dZmax = b3Box:getMax():getZ()
    local dMaxH = ComputeMaxH( vRefIds, frSlicing, dSliceStep)
    dZmax = min( dZmax, dMaxH)
-   --dZmin = 708
-   --dZmax = 712
    
    -- Eseguo slicing
    local nLayCnt = 1

LuaLibs/RunCalcSolids.lua

@@ -14,6 +14,7 @@ local AMD = require( 'AddManData')
 
 --------------------------------------------------------------------
 local s_dTol = 0.1
+local s_nSimplifiedSection = 0
 
 ---------------------------------------------------------------------
 local function GetLayerParamsForSolidCalc( nPartId)
@@ -21,51 +22,46 @@ 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
 
 ---------------------------------------------------------------------
 local function CalcSectionParams( dStrand, dH)
-   local dL = dStrand
-   local dLm = dStrand / 10
-   local dHm = dH / 6
-   local dD1 = 0.5 * dL - dLm
-   local dD2 = 0.5 * dL - dD1 
-   local dD3 = dHm
-   local dD4 = dH - 2 * dD3
-   return dD1, dD2, dD3, dD4
+   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, LayerParams, dStrand)
+
+   local dBevelX, dBevelY = CalcSectionParams( dStrand, LayerParams.dLayHeight)
+   local nSrfId = EgtSurfTmRectSwept( nSolidGrp, dStrand, LayerParams.dLayHeight, dBevelX, dBevelY, nCrvId, GDB_RSCT.BEVEL, s_dTol)
+   return nSrfId
 end
 
 ---------------------------------------------------------------------
 local function CreateSection( ptS, vtDir, dStrand, dH, vtSlicing, nSolidGrp)
 
-   local dD1, dD2, dD3, dD4 = CalcSectionParams( dStrand, dH)
-   local ptA = ptS - dH * vtSlicing + dD1 * vtDir
-   local ptB = ptA + dD2 * vtDir + dD3 *vtSlicing
-   local ptC = ptB + dD4 * vtSlicing
+   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 - 2 * dD1 * vtDir 
-   local ptF = ptC - 2 * ( dD1 + dD2) * vtDir
-   local ptG = ptB - 2 * ( dD1 + dD2) * vtDir
-   local ptH = ptA - 2 * dD1 * vtDir 
+   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 CreateHalfSection( ptS, vtDir, dStrand, dH, vtSlicing, nSolidGrp)
-
-   local dD1, dD2, dD3, dD4 = CalcSectionParams( dStrand, dH)
-   local ptA = ptS - dH * vtSlicing + dD1 * vtDir
-   local ptB = ptA + dD2 * vtDir + dD3 * vtSlicing
-   local ptC = ptB + dD4 * vtSlicing
-   local ptD = ptA + dH * vtSlicing
- 
-   local nId = EgtCurveCompoFromPoints( nSolidGrp, { ptS - dH * vtSlicing, ptA, ptB, ptC, ptD, ptS}, GDB_RT.GLOB)
-   
    return nId
 end
 
@@ -73,30 +69,48 @@ end
 local function CreateSpiralVaseCap( nSectId, vtDir, nSolidGrp)
    
    local vPt = {}
-   for i = 0, 7 do
+   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 = {}
-   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)
-   vCrvs[5] = EgtCurveCompo( nSolidGrp, {vCrvs[1]}, false, GDB_RT.GLOB)
-   EgtCloseCurveCompo( vCrvs[5])
-   vCrvs[6] = EgtCurveCompo( nSolidGrp, {vCrvs[4]}, false, GDB_RT.GLOB)
-   EgtCloseCurveCompo( vCrvs[6])
-   local nSurf1 = EgtSurfTmRuled( nSolidGrp, vCrvs[1], vCrvs[2], GDB_RUL.ISOPAR, s_dTol)
-   local nSurf2 = EgtSurfTmRuled( nSolidGrp, vCrvs[2], vCrvs[3], GDB_RUL.ISOPAR, s_dTol)
-   local nSurf3 = EgtSurfTmRuled( nSolidGrp, vCrvs[3], vCrvs[4], GDB_RUL.ISOPAR, s_dTol)
-   local nSurf4 = EgtSurfTmByRegion( nSolidGrp, vCrvs[5], s_dTol)
-   local nSurf5 = EgtSurfTmByRegion( nSolidGrp, vCrvs[6], s_dTol)
-   local nCapSrf = EgtSurfTmBySewing( nSolidGrp, {nSurf1, nSurf2, nSurf3, nSurf4, nSurf5})
-
+   -- 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
    for i = 1, #vCrvs do
       EgtErase( vCrvs[i])
    end
-
+   EgtErase( nCrvTop)
+   EgtErase( nCrvBottom)
+   
    return nCapSrf
 end
 
@@ -104,16 +118,27 @@ end
 local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
    
    -- gruppo temporaneo per conti 
-   local nGrpTmp = EgtGroup( nSolidGrp)
+   local nGrpTmp = EgtGroup( nSolidGrp, Frame3d( ORIG(), LayerParams.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) * LayerParams.vtSlicing
+   -- se non è vero spiral vase, chiamo funzione standard
+   if dDelta < GEO.EPS_SMALL then
+      EgtErase( nGrpTmp)
+      return CreateStandardSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
+   end
+   
    -- appiattisco la curva
    local nCrvCopy = EgtCopyGlob( nCrvId, nGrpTmp)
-   local dDelta = ( ptE - ptS) * LayerParams.vtSlicing
-   EgtSpiralizeCurveAlongExtrusion( nCrvCopy, - dDelta)
+   EgtModifyCurveExtrusion( nCrvCopy, LayerParams.vtSlicing, GDB_RT.GLOB)
+   EgtProjectCurveOnPlane( nCrvCopy, ptS, LayerParams.vtSlicing, GDB_RT.GLOB)
    EgtMergeCurvesInCurveCompo( nCrvCopy)
    EgtChangeClosedCurveStartPoint( nCrvCopy, ptS, GDB_RT.GLOB)
   
@@ -140,12 +165,19 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
       local dMove = ( ptRef - ptS) * LayerParams.vtSlicing
       EgtMove( vCrvs[i+1], LayerParams.vtSlicing * dMove, GDB_RT.GLOB)
       EgtSpiralizeCurveAlongExtrusion( vCrvs[i+1], dDelta)
-      
+
       -- modifico la curva per congiungerla ai caps
-      EgtAddCurveCompoLine( vCrvs[i+1], ptRef, false, GDB_RT.GLOB)
+      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)
-      EgtAddCurveCompoLine( vCrvs[i+1], ptRefEnd, true, GDB_RT.GLOB)
+      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)
@@ -154,7 +186,8 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
          return nil
       end
    end
-   local nSrfId = EgtSurfTmBySewing( nSolidGrp, vSurfs)
+
+   local nSrfId = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
   
    -- creazione del mezzo disco iniziale
    local nCap1 = CreateSpiralVaseCap( nSectId, - vtS, nSolidGrp)
@@ -165,15 +198,7 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
    -- cancello le curve usate per la costruzione
    EgtErase( nGrpTmp)
 
-   return EgtSurfTmBySewing( nSolidGrp, { nSrfId, nCap1, nCap2})
-end
-
-----------------------------------------------------------------------
-local function CreateStandardSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
-
-   local dD1, dD2, dD3, dD4 = CalcSectionParams( dStrand, LayerParams.dLayHeight)
-   local nSrfId = EgtSurfTmRectSwept( nSolidGrp, dStrand, LayerParams.dLayHeight, dD2, dD3, nCrvId, GDB_RSCT.BEVEL, s_dTol)
-   return nSrfId
+   return EgtSurfTmByTriangles( nSolidGrp, { nSrfId, nCap1, nCap2})
 end
 
 --------------------------------------------------------------------------------------
@@ -185,6 +210,66 @@ 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 CreateRecursiveSolid( nCrvId, vSurfs, nSolidGrp, LayerParams, dStrand)
+
+   -- tento la creazione del solido
+   local nSurf = CreateSolid( nCrvId, nSolidGrp, LayerParams, 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, dStrand)
+      bOk = bOk and CreateRecursiveSolid( nCrvSplit, vSurfs, nSolidGrp, LayerParams, dStrand)
+      return bOk
+   end
+end
+
 ---------------------------------------------------------------------
 local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
   
@@ -207,7 +292,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 +309,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
@@ -231,44 +322,42 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
       local nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 5 * GEO.EPS_SMALL)
       if not nSrfId then
          EgtOutLog( 'Warning : CreateSolid failed '.. '(layer '..tostring( nLayer)..', curve '..tostring( nCrvId)..')')
-         -- se non ultima, provo a spostare l'estremità finale
-         if nInd < nParts - 1 then
-            local nCopyId = EgtCopy( nGuideId + 1, nGuideId, GDB_IN.AFTER)
-            if nCopyId then
-               local LEN_TRIM = 10
-               local bOk1 = EgtTrimCurveEndAtLen( nCopyId, LEN_TRIM)
-               local bOk2 = EgtAddCurveCompoCurve( nGuideId, nCopyId)
-               local bOk3 = EgtTrimCurveStartAtLen( nGuideId + 1, LEN_TRIM)
-               nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 5 * GEO.EPS_SMALL)
-               if not nSrfId then
-                  nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
+         -- ritento con strand più piccolo
+         nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
+         
+         if not nSrfId then
+            EgtOutLog( 'Warning : CreateSolid_1 failed '.. '(layer '..tostring( nLayer)..', curve '..tostring( nCrvId)..')')
+            -- se non ultima, provo a spostare l'estremità finale
+            if nInd < nParts - 1 then
+               local nCopyId = EgtCopy( nGuideId + 1, nGuideId, GDB_IN.AFTER)
+               if nCopyId then
+                  local LEN_TRIM = 10
+                  local bOk1 = EgtTrimCurveEndAtLen( nCopyId, LEN_TRIM)
+                  local bOk2 = EgtAddCurveCompoCurve( nGuideId, nCopyId)
+                  local bOk3 = EgtTrimCurveStartAtLen( nGuideId + 1, LEN_TRIM)
+                  nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 5 * GEO.EPS_SMALL)
+                  if not nSrfId then
+                     nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
+                  end
                end
             end
          end
-         -- ritento spezzando la curva
+         
+         -- 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( nGuideId, nGrp)
             EgtApproxCurve( nGuideId, GDB_CA.LINES, 100 * GEO.EPS_SMALL)
             EgtRelocateGlob( nGuideId, nSolidGrp)
-            local nFirstCrv, nCrvNbr = EgtSplitCurveAtCorners( nGuideId, 30)
-            if nFirstCrv and nCrvNbr > 1 then
-               local nSrfIds = {}
-               for nInd2 = 0, nCrvNbr-1 do
-                  local nSrfId2 = CreateSolid( nFirstCrv + nInd2, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
-                  EgtErase( nFirstCrv + nInd2)
-                  if nSrfId2 then
-                     table.insert( nSrfIds, nSrfId2)
-                  end
-               end
-               if #nSrfIds == nCrvNbr then
-                  nSrfId = EgtSurfTmBySewing( nSolidGrp, nSrfIds)
-               else
-                  EgtOutLog( 'Warning : CreateSolid_3 failed')
-               end
-            else
-               EgtErase( nFirstCrv)
+
+            local vSurfs = {}
+            local bOk = CreateRecursiveSolid( nGuideId, vSurfs, nSolidGrp, LayerParams, 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
@@ -278,7 +367,7 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
          EgtSetColor( nSrfId, Color)
          EgtSetInfo( nSrfId, KEY_TYPE, nType)
          EgtSetInfo( nSrfId, KEY_SLICE_NBR, nLayer)
-      else 
+      else
          bOk = false
          EgtOutLog( 'Warning : CreateSolid_Sewing failed')
       end
@@ -293,6 +382,10 @@ 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)
@@ -304,9 +397,14 @@ 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
+            if not vLayIds or #vLayIds == 0 then
                EgtOutBox( 'No sliced part in this project!', 'Error', 'ERROR')
                return
             end
@@ -338,11 +436,51 @@ function RunCalcSolids.Exec()
                      nSolidGrpId = EgtGroup( nCrvGrpId)
                      EgtSetName( nSolidGrpId, SOLID_GRP)
                      EgtSetLevel( nSolidGrpId, GDB_LV.TEMP)
-                     -- scorro le curve del percorso utensile
-                     local nId = EgtGetFirstInGroup( nTPathGrpId) 
-                     while nId do
-                        local bOk = CreateSolidFromCurve( nId, nSolidGrpId, LayerParams, nLayer)
-                        nId = EgtGetNext( nId)
+                     local vIds = EgtGetAllInGroup( nTPathGrpId)
+                     
+                     -- spiral vase
+                     if 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, nLayer)
+                           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, nLayer)
+                              EgtErase( nNewCrv)
+                           end
+                        end
+                        
+                     -- caso standard
+                     else
+                        for i = 1, #vIds do
+                           CreateSolidFromCurve( vIds[i], nSolidGrpId, LayerParams, nLayer)
+                        end
                      end
                   else
                      bSolidsOk = true
@@ -372,7 +510,7 @@ function RunCalcSolids.Exec()
                   for i = 1, #vLayIds do
                      local vGrpId = EgtGetNameInGroup( vLayIds[i], CONTOUR_GRP .. '*') or {}
                      for j = 1, #vGrpId do
-                        local nSolidId = EgtGetNameInGroup( vGrpId[j], SOLID_GRP .. '*') or GDB_ID.NULL
+                        local nSolidId = EgtGetFirstNameInGroup( vGrpId[j], SOLID_GRP .. '*') or GDB_ID.NULL
                         EgtErase( nSolidId)
                      end
                   end
@@ -389,9 +527,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/RunGcodeGenerate.lua

@@ -36,7 +36,7 @@ function RunGcodeGenerate.Exec()
 
    -- Recupero i layer da processare
    local vLayIds = EgtGetNameInGroup( nPartId, SLICE_LAYER.."*") 
-   if not vLayIds then
+   if not vLayIds or #vLayIds == 0 then
    EgtOutBox( 'Error missing slices', 'GcodeGenerate')
       return 
    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
@@ -53,6 +53,8 @@ function RunMachParamFromSWCalc.Exec()
    local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
    local dSMin = tonumber( EgtGetStringFromIni( SEC_3DPRINTING, KEY_SPEED_MIN, 0, sMachIni))
    local dSMax = tonumber( EgtGetStringFromIni( SEC_3DPRINTING, KEY_SPEED_MAX, 50000, sMachIni))
+   -- recupero Feed massima dalla macchina
+   local dFLimit = tonumber( EgtGetStringFromIni( SEC_3DPRINTING, KEY_FEED_MAX, 10000, sMachIni))
    -- massa materiale utilizzato
    local dPrintMass = 0
    -- massimo indice di layer calcolato
@@ -126,44 +128,6 @@ function RunMachParamFromSWCalc.Exec()
             end
             nCrvId = EgtGetNextName( nCrvId, CONTOUR_GRP .. '*')
          end
-
-
-         -- -- rimuovo eventuale info precedente del tempo di attesa
-         -- EgtRemoveInfo( nLayerId, KEY_WAITING_TIME)
-         -- -- calcolo lunghezza totale del layer
-         -- local dTotLayerLength = 0
-         -- local dTotLayerLengthForMass = 0
-         -- local dTotLayerArea = 0
-         -- local nCrvId = EgtGetFirstNameInGroup( nLayerId, CONTOUR_GRP .. '*')
-         -- while nCrvId do
-         --    local nToolPathId = EgtGetFirstNameInGroup( nCrvId, TOOLPATH_GRP)
-         --    -- sommo lunghezze percorsi
-         --    local dTotCrvLength = 0
-         --    local dTotCrvLengthForMass = 0
-         --    local nShellId = EgtGetFirstInGroup( nToolPathId)
-         --    while nShellId do
-         --       dTotCrvLength = dTotCrvLength + EgtCurveLength( nShellId)
-         --       if EgtGetName( nShellId) ~= WIPE_CRV then
-         --          dTotCrvLengthForMass = dTotCrvLengthForMass + EgtCurveLength( nShellId)
-         --       end
-         --       nShellId = EgtGetNext( nShellId)
-         --    end
-         --    dTotLayerLength = dTotLayerLength + dTotCrvLength
-         --    dTotLayerLengthForMass = dTotLayerLengthForMass + dTotCrvLengthForMass
-         --    -- recupero area
-         --    local nOuterCrvId = EgtGetFirstNameInGroup( nCrvId, OUTER_CRV)
-         --    if nOuterCrvId and dStrandCount > 0.5 then
-         --       local _, _, dTotCrvArea = EgtCurveArea( nOuterCrvId)
-         --       local dOuterLength = EgtCurveLength( nOuterCrvId)
-         --       -- recupero offset del part per aggiungerlo all'area interna
-         --       local dOffset = EgtGetInfo( nPartId, KEY_OFFSET_SLICE, 'd')
-         --       dTotCrvArea = dTotCrvArea + ( dOffset * dOuterLength)
-         --       dTotLayerArea = dTotLayerArea + dTotCrvArea
-         --    end
-         --    nCrvId = EgtGetNextName( nCrvId, CONTOUR_GRP .. '*')
-         -- end
-
-
          -- recupero feed del layer
          local dLayerFeed = 0
          local dLayerWait = 0
@@ -192,12 +156,11 @@ function RunMachParamFromSWCalc.Exec()
          for nMeanIndex = 1, #LengthCrvList do
             dStrandMean = dStrandMean + LengthCrvList[nMeanIndex].Width * LengthCrvList[nMeanIndex].Length
          end
-         dStrandMean = dStrandMean / dTotLayerLength
+         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
@@ -216,9 +179,9 @@ function RunMachParamFromSWCalc.Exec()
          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 / dTMax * 60
-         local dFTrg = dTotLayerLength / dTTrg * 60
-         local dFMax = dTotLayerLength / dTMin * 60
+         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
@@ -226,8 +189,10 @@ function RunMachParamFromSWCalc.Exec()
             dLayerTime = dTotLayerLength / dLayerFeed * 60
          end
          dLayerWait = floor( dTMin + 0.5) - floor( dLayerTime + 0.5)
+         -- sezione dello strand
+         local dSect = max( ( dStrandMean - dSliceStep) * dSliceStep, 0) + pi * dSliceStep * dSliceStep / 4
          -- calcolo la portata
-         local Vf = dLayerFeed * ( ( dStrandMean - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2)) / 1000
+         local Vf = dLayerFeed * dSect / 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
@@ -241,8 +206,10 @@ 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 / ( ( dStrandMean - 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 / dSect
+               dLayerTime = dTotLayerLength / dLayerFeed * 60
+            end
             dLayerWait = floor( dTMin + 0.5) - floor( dLayerTime + 0.5)
          end
          -- calcolo massa dello strato
@@ -256,17 +223,29 @@ function RunMachParamFromSWCalc.Exec()
             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
+               local dNewFeed = CurrFeed
+               -- verifico se coefficiente moltiplicativo per feed
+               local dCoeff = EgtGetInfo( CurrWidth.IdList[nCurveIdIndex], KEY_FEED_COEFF, 'd')
+               if dCoeff then
+                  dNewFeed = dCoeff * CurrFeed
+                  if dNewFeed > dFLimit then
+                     local dNewSpeed = dSpeed * dFLimit / dNewFeed
+                     dNewSpeed = EgtClamp( dNewSpeed, dSMin, dSMax)
+                     dNewFeed = dFLimit
+                     EgtSetInfo( CurrWidth.IdList[nCurveIdIndex], KEY_SPEED, dNewSpeed)
+                  end
+               end
+               EgtSetInfo( CurrWidth.IdList[nCurveIdIndex], KEY_FEED, dNewFeed)
+               if dNewFeed > dFeedMax then
+                  dFeedMax = dNewFeed
+               end
             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
-            -- EgtSetInfo( nToolPathId, KEY_FEED, dLayerFeed)
+            EgtSetInfo( nToolPathId, KEY_FEED, dLayerFeed)
             EgtSetInfo( nToolPathId, KEY_SPEED, dSpeed)
             nCrvId = EgtGetNextName( nCrvId, CONTOUR_GRP .. '*')
          end
@@ -276,15 +255,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_FTRG, dFTrg)
          EgtSetInfo( nLayerResultId, KEY_FMAX, dFeedMax)
-         -- EgtSetInfo( nLayerResultId, KEY_FMIN, dFMin)
-         -- EgtSetInfo( nLayerResultId, KEY_FTRG, dFTrg)
-         -- EgtSetInfo( nLayerResultId, KEY_FMAX, dFMax)
          EgtSetInfo( nLayerResultId, KEY_TCUR, dLayerTime)
          EgtSetInfo( nLayerResultId, KEY_FCUR, dLayerFeed)
          EgtSetInfo( nLayerResultId, KEY_LENGTH, dTotLayerLength)
@@ -296,11 +271,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,209 @@
+-- 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 region 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 nSurf = EgtSurfFrFatCurve( nDestGrp, nCopy, 0.5 * dStrand, false)
+               -- se fallisce ritento con valore leggermente diverso
+               if not nSurf or nSurf == GDB_ID.NULL then
+                  nSurf = EgtSurfFrFatCurve( nDestGrp, nCopy, 0.5 * dStrand - 0.05, false)
+               end
+               EgtErase( nCopy)
+                 
+               if nSurf then
+                  local nChunks = EgtSurfFrChunkCount( nSurf)
+                  for k = 0, nChunks - 1 do
+                     -- estraggo i loop associati
+                     local nCrv, nCnt = EgtExtractSurfFrChunkLoops( nSurf, k, nDestGrp)
+                     -- eventuali aggiustamenti per creare un percorso unico
+                     if nCnt > 1 then
+                        for nLoopId = nCrv + 1, nCrv + nCnt - 1 do
+                           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( ptM2, nCrv)
+                           local _, _, dParRef2 = EgtPointCurveDist( ptM, nCrv)
+                           EgtTrimCurveStartEndAtParam( nCrv, dParRef2, dParRef1)
+                           EgtTrimCurveStartEndAtParam( nLoopId, dPar2, dPar1)
+                           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
+                  EgtErase( nSurf)
+               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
+         -- copio solo la prima freccia direzionale
+         local nArrow = EgtGetFirstNameInGroup( nSolidGrp, DIR_ARROW) or GDB_ID.NULL
+         EgtCopyGlob( nArrow, nDestGrp)
+         local vSolids = EgtGetAllInGroup( nSolidGrp)
+         for i = 1, #vSolids do
+            if EgtGetName( vSolids[i]) ~= DIR_ARROW then
+               EgtCopyGlob( vSolids[i], nDestGrp)
+            end
+         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
 
 ---------------------------------------------------------------------

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/08/28
+-- Version.lua by Egaltech s.r.l. 2025/09/12
 -- Gestione della versione di 3dPrinting
 
-VERSION = '2.5i1'
+VERSION = '3.1a1'