3dPrinting :

- ottimizzazioni nella fase di slicing
- migliorata la funzione che chiude buchi nei setti.

.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,21 +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\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
+\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

@@ -10,30 +10,30 @@ require( 'EgtBase')
 EgtOutLog( ' AddManData started', 1)
 
 ---------------------------------------------------------------------
-SLICE_LAYER = "Slice"
-CONTOUR_GRP = "Crv"
-OUTER_CRV = "OuterCrv"
-PATH_GRP = "Path"
-SOLID_GRP = "Solid"
-TOOLPATH_GRP = "ToolPath"
-LAYER_SRF = "LayerSurf"
-SHELL_CRV = "Shell"
-EXTRA_SHELL_CRV = "ExtraShell"
-INFILL_CRV = "Infill"
-COASTING_CRV = "Coasting"
-WIPE_CRV = "Wipe"
-LEAD_IN_CRV = "LeadIn"
-LEAD_OUT_CRV = "LeadOut"
-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"
+SLICE_LAYER = 'Slice'
+CONTOUR_GRP = 'Crv'
+OUTER_CRV = 'OuterCrv'
+PATH_GRP = 'Path'
+SOLID_GRP = 'Solid'
+TOOLPATH_GRP = 'ToolPath'
+LAYER_SRF = 'LayerSurf'
+SHELL_CRV = 'Shell'
+EXTRA_SHELL_CRV = 'ExtraShell'
+INFILL_CRV = 'Infill'
+COASTING_CRV = 'Coasting'
+WIPE_CRV = 'Wipe'
+LEAD_IN_CRV = 'LeadIn'
+LEAD_OUT_CRV = 'LeadOut'
+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,175 +41,195 @@ MIN_RIBS_LEN = 2
 MIN_INFILL_LEN = 2
 
 -- Parametri di lavorazione
-SEC_DEFAULT = "Default"
-KEY_PARAMS = "Params"
-KEY_CALC_SOLIDS = "CalcSolids"
-KEY_SPIRAL_VASE = "SpiralVase"
-KEY_SLICING_TYPE = "SlicingType"
-KEY_SLICING_DIR = "SlicingDir"
-KEY_SLICE_STEP = "StrandH"
-KEY_SHELLS_NBR = "StrandCount"
-KEY_STRAND = "StrandW"
-KEY_INNER_STRAND = "InnerStrandW"
-KEY_STRAND_OVERLAP = "StrandOverlap"
-KEY_OFFSET_SLICE = "Offset"
-KEY_SP_OFFSET_ON_SLICE = "StartPointOffsetOnSlice"
-KEY_STRAND_ORDER = "StrandOrder"
-KEY_PRINT_ORDER = "PrintOrder"
-KEY_PRINT_DIRECTION = "Direction"
-KEY_TYPE = "Type"
-KEY_LINK_TYPE = "LinkType"
-KEY_LINK_PARAM = "LinkParam"
-KEY_LINK_ZUP = "LinkZup"
-KEY_SPEED = "Speed"
-KEY_FEED = "Feed"
-KEY_EXT_FEED = "ExtFeed"
-KEY_INT_FEED = "IntFeed"
-KEY_INFILL_FEED = "InfillFeed"
-KEY_LEAD_IN_FEED = "LeadInFeed"
-KEY_LEAD_OUT_FEED = "LeadOutFeed"
-KEY_SUPPORT_FEED = "SupportFeed"
-KEY_G0_FEED = "G0Feed"
-KEY_MATERIAL = "Material"
-KEY_LEAD_IN_TYPE = "LeadIn"
-KEY_LEAD_IN_TANG_DIST = "LeadInTangDist"
-KEY_LEAD_IN_ORTHO_DIST = "LeadInOrthoDist"
-KEY_LEAD_OUT_TYPE = "LeadOut"
-KEY_LEAD_OUT_TANG_DIST= "LeadOutTangDist"
-KEY_LEAD_OUT_ORTHO_DIST= "LeadOutOrthoDist"
-KEY_OFFSET_LEAD_POINT = "OffsetLeadPoint"
-KEY_COASTING_LEN = "CoastingLen"
-KEY_COASTING_FEED = "CoastingFeed"
-KEY_WIPE_LEN = "WipeLen"
-KEY_WIPE_DIR = "WipeDir"
-KEY_WIPE_FEEDPU = "WipeFeedPu"
-KEY_TOOL_DIAM = "ToolDiam"
+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_SLICE_STEP = 'StrandH'
+KEY_SHELLS_NBR = 'StrandCount'
+KEY_STRAND = 'StrandW'
+KEY_INNER_STRAND = 'InnerStrandW'
+KEY_STRAND_OVERLAP = 'StrandOverlap'
+KEY_OFFSET_SLICE = 'Offset'
+KEY_SP_OFFSET_ON_SLICE = 'StartPointOffsetOnSlice'
+KEY_STRAND_ORDER = 'StrandOrder'
+KEY_PRINT_ORDER = 'PrintOrder'
+KEY_PRINT_DIRECTION = 'Direction'
+KEY_TYPE = 'Type'
+KEY_LINK_TYPE = 'LinkType'
+KEY_LINK_PARAM = 'LinkParam'
+KEY_LINK_ZUP = 'LinkZup'
+KEY_SPEED = 'Speed'
+KEY_FEED = 'Feed'
+KEY_EXT_FEED = 'ExtFeed'
+KEY_INT_FEED = 'IntFeed'
+KEY_INFILL_FEED = 'InfillFeed'
+KEY_LEAD_IN_FEED = 'LeadInFeed'
+KEY_LEAD_OUT_FEED = 'LeadOutFeed'
+KEY_SUPPORT_FEED = 'SupportFeed'
+KEY_G0_FEED = 'G0Feed'
+KEY_MATERIAL = 'Material'
+KEY_LEAD_IN_TYPE = 'LeadIn'
+KEY_LEAD_IN_TANG_DIST = 'LeadInTangDist'
+KEY_LEAD_IN_ORTHO_DIST = 'LeadInOrthoDist'
+KEY_SINGLE_LEAD_IN = 'SingleLeadIn'
+KEY_LEAD_OUT_TYPE = 'LeadOut'
+KEY_LEAD_OUT_TANG_DIST= 'LeadOutTangDist'
+KEY_LEAD_OUT_ORTHO_DIST= 'LeadOutOrthoDist'
+KEY_OFFSET_LEAD_POINT = 'OffsetLeadPoint'
+KEY_COASTING_LEN = 'CoastingLen'
+KEY_COASTING_FEED = 'CoastingFeed'
+KEY_WIPE_LEN = 'WipeLen'
+KEY_WIPE_DIR = 'WipeDir'
+KEY_WIPE_FEEDPU = 'WipeFeedPu'
+KEY_TOOL_DIAM = 'ToolDiam'
+KEY_MAX_STRANDH_FACTOR = 'MaxStrandHFactor'
+KEY_MIN_STRANDH_FACTOR = 'MinStrandHFactor'
 
 -- Solid Fill
-KEY_FLOOR_NBR = "FloorCount"
-KEY_FLOOR_TYPE = "FloorType"
-KEY_CEIL_NBR = "CeilCount"
-KEY_CEIL_TYPE = "CeilType"
-KEY_FILL_TYPE = "FillType"
+KEY_FLOOR_NBR = 'FloorCount'
+KEY_FLOOR_TYPE = 'FloorType'
+KEY_CEIL_NBR = 'CeilCount'
+KEY_CEIL_TYPE = 'CeilType'
+KEY_FILL_TYPE = 'FillType'
 
 -- Infill
-KEY_INFILL_STRAND = "InfillStrandW"
-KEY_INFILL_TYPE = "InfillType"
-KEY_INFILL_DENSITY = "InfillDensity"
-KEY_INFILL_LINK = "InfillLink"
-KEY_INFILL_OVERLAP = "InfillOverlap"
-KEY_INFILL_GRID_OVERLAP = "InfillGridOverlap"
-KEY_INFILL_DIR = "InfillDirection"
-KEY_INFILL_OFFSET_X = "InfillOffsetX"
-KEY_INFILL_OFFSET_Y = "InfillOffsetY"
-KEY_INFILL_COASTING = "InfillCoasting"
-KEY_INFILL_WIPE = "InfillWipe"
-KEY_INFILL_WIPE_DIR = "InfillWipeDir"
+KEY_INFILL_STRAND = 'InfillStrandW'
+KEY_INFILL_TYPE = 'InfillType'
+KEY_INFILL_DENSITY = 'InfillDensity'
+KEY_INFILL_LINK = 'InfillLink'
+KEY_INFILL_OVERLAP = 'InfillOverlap'
+KEY_INFILL_GRID_OVERLAP = 'InfillGridOverlap'
+KEY_INFILL_DIR = 'InfillDirection'
+KEY_INFILL_OFFSET_X = 'InfillOffsetX'
+KEY_INFILL_OFFSET_Y = 'InfillOffsetY'
+KEY_INFILL_COASTING = 'InfillCoasting'
+KEY_INFILL_WIPE = 'InfillWipe'
+KEY_INFILL_WIPE_DIR = 'InfillWipeDir'
 
 -- Ribs
-KEY_RIBS_STRAND = "RibsStrandW"
-KEY_RIBS_TYPE = "RibsType"
-KEY_LIMIT_UNBDD_RIBS = "LimitUnboundedRibsWithSolid"
-KEY_RIBS_OVERLAP = "RibsOverlap"
-KEY_RIBS_SHELLS_NBR = "RibsStrandCount"
-KEY_RIBS_LINK = "RibsLink"
-KEY_RIBS_INVERT_DIR = "RibsInvertDirection"
-KEY_RIBS_INVERT_ORDER = "RibsInvertOrder"
-KEY_RIBS_LEAD_IN_INVERT = "RibsLeadInInvert"
-KEY_RIBS_LEAD_IN_LEN = "RibsLeadInLen"
-KEY_RIBS_LEAD_OUT_INVERT = "RibsLeadOutInvert"
-KEY_RIBS_LEAD_OUT_LEN = "RibsLeadOutLen"
-KEY_RIBS_LEAD_OUT_COASTING = "RibsLeadOutCoasting"
-KEY_RIBS_LEAD_OUT_WIPE = "RibsLeadOutWipe"
-KEY_RIBS_LEAD_OUT_WIPE_DIR = "RibsLeadOutWipeDir"
-KEY_RIBS_INTERS = "RibsHaveIntersections"
-KEY_RIBS_SPECIAL_CASE = "RibsSpecialCase"
-KEY_SPLIT_ORDER = "SplitOrder"
-KEY_SPLIT_AFTER_TRIM = "RibsSplitAfterTrim"
-KEY_SPLIT_AFTER_TRIM_ORDER = "RibsSplitAfterTrimOrder"
-KEY_SPLIT_AFTER_TRIM_TOT = "RibsSplitAfterTrimTot"
-KEY_SPLIT_ID = "SplitId"
-KEY_START_RIB = "StartRib"
-KEY_ORIGINAL_RIB = "OriginalRib"
-KEY_LOOP_RIB = "LoopRib"
-KEY_RIBS_USER_LINK = "RibWithUserLink"
-KEY_RIBS_USER_LINK_SAME_SIDE = "RibUserLinkOnSameSide"
-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_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'
+KEY_RIBS_INVERT_ORDER = 'RibsInvertOrder'
+KEY_RIBS_LEAD_IN_INVERT = 'RibsLeadInInvert'
+KEY_RIBS_LEAD_IN_LEN = 'RibsLeadInLen'
+KEY_RIBS_LEAD_OUT_INVERT = 'RibsLeadOutInvert'
+KEY_RIBS_LEAD_OUT_LEN = 'RibsLeadOutLen'
+KEY_RIBS_LEAD_OUT_COASTING = 'RibsLeadOutCoasting'
+KEY_RIBS_LEAD_OUT_WIPE = 'RibsLeadOutWipe'
+KEY_RIBS_LEAD_OUT_WIPE_DIR = 'RibsLeadOutWipeDir'
+KEY_RIBS_INTERS = 'RibsHaveIntersections'
+KEY_RIBS_SPECIAL_CASE = 'RibsSpecialCase'
+KEY_SPLIT_ORDER = 'SplitOrder'
+KEY_SPLIT_AFTER_TRIM = 'RibsSplitAfterTrim'
+KEY_SPLIT_AFTER_TRIM_ORDER = 'RibsSplitAfterTrimOrder'
+KEY_SPLIT_AFTER_TRIM_TOT = 'RibsSplitAfterTrimTot'
+KEY_SPLIT_ID = 'SplitId'
+KEY_START_RIB = 'StartRib'
+KEY_ORIGINAL_RIB = 'OriginalRib'
+KEY_LOOP_RIB = 'LoopRib'
+KEY_RIBS_USER_LINK = 'RibWithUserLink'
+KEY_RIBS_USER_LINK_SAME_SIDE = 'RibUserLinkOnSameSide'
+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"
-KEY_SHELL_NBR_COASTING = "ShellNbrCoasting"
-KEY_SHELL_NBR_WIPE = "ShellNbrWipe"
-KEY_SHELL_NBR_WIPE_DIR = "ShellNbrWipeDir"
-KEY_EXTRA_SHELL_COASTING = "ExtraShellCoasting"
-KEY_EXTRA_SHELL_WIPE = "ExtraShellWipe"
-KEY_EXTRA_SHELL_WIPE_DIR = "ExtraShellWipeDir"
+KEY_SHELL_NBR_DIFF = 'ShellNbrDifference'
+KEY_SHELL_NBR_COASTING = 'ShellNbrCoasting'
+KEY_SHELL_NBR_WIPE = 'ShellNbrWipe'
+KEY_SHELL_NBR_WIPE_DIR = 'ShellNbrWipeDir'
+KEY_EXTRA_SHELL_COASTING = 'ExtraShellCoasting'
+KEY_EXTRA_SHELL_WIPE = 'ExtraShellWipe'
+KEY_EXTRA_SHELL_WIPE_DIR = 'ExtraShellWipeDir'
 
 -- Solidi ausiliari
-KEY_AUX_SOLIDS_STRAND = "AuxSolidsStrandW"
-KEY_AUX_SOLIDS_SHELLS_NBR = "AuxSolidsStrandCount"
-KEY_AUX_SOLIDS_OVERLAP = "AuxSolidsOverlap"
-KEY_AUX_SOLIDS_INFILL = "AuxSolidsInfill"
-KEY_AUX_SOLIDS_PRINT_ORDER = "AuxSolidsStrandOrder"
-KEY_AUX_SOLIDS_LINK_TYPE = "AuxSolidsLinkType"
-KEY_AUX_SOLIDS_LINK_PARAM = "AuxSolidsLinkParam"
-KEY_AUX_SOLIDS_SP_OFFSET = "AuxSolidsStartPointOffsetOnSlice"
-KEY_AUX_SOLIDS_LP_OFFSET = "AuxSolidsOffsetLeadPoint"
-KEY_AUX_SOLIDS_INFILL_LINK = "AuxSolidsInfillLink"
-KEY_AUX_SOLIDS_DENSITY = "AuxSolidsDensity"
-KEY_AUX_SOLIDS_DIR = "AuxSolidsDirection"
-KEY_AUX_SOLIDS_OFFSET_X = "AuxSolidsOffsetX"
-KEY_AUX_SOLIDS_OFFSET_Y = "AuxSolidsOffsetY"
-KEY_AUX_SOLIDS_GRID_OVERLAP = "AuxSolidsGridOverlap"
-KEY_AUX_SOLIDS_COASTING_LEN = "AuxSolidsCoastingLen"
-KEY_AUX_SOLIDS_WIPE_LEN = "AuxSolidsWipeLen"
-KEY_AUX_SOLIDS_WIPE_DIR = "AuxSolidsWipeDir"
+KEY_AUX_SOLIDS_STRAND = 'AuxSolidsStrandW'
+KEY_AUX_SOLIDS_SHELLS_NBR = 'AuxSolidsStrandCount'
+KEY_AUX_SOLIDS_OVERLAP = 'AuxSolidsOverlap'
+KEY_AUX_SOLIDS_INFILL = 'AuxSolidsInfill'
+KEY_AUX_SOLIDS_PRINT_ORDER = 'AuxSolidsStrandOrder'
+KEY_AUX_SOLIDS_LINK_TYPE = 'AuxSolidsLinkType'
+KEY_AUX_SOLIDS_LINK_PARAM = 'AuxSolidsLinkParam'
+KEY_AUX_SOLIDS_SP_OFFSET = 'AuxSolidsStartPointOffsetOnSlice'
+KEY_AUX_SOLIDS_LP_OFFSET = 'AuxSolidsOffsetLeadPoint'
+KEY_AUX_SOLIDS_INFILL_LINK = 'AuxSolidsInfillLink'
+KEY_AUX_SOLIDS_DENSITY = 'AuxSolidsDensity'
+KEY_AUX_SOLIDS_DIR = 'AuxSolidsDirection'
+KEY_AUX_SOLIDS_OFFSET_X = 'AuxSolidsOffsetX'
+KEY_AUX_SOLIDS_OFFSET_Y = 'AuxSolidsOffsetY'
+KEY_AUX_SOLIDS_GRID_OVERLAP = 'AuxSolidsGridOverlap'
+KEY_AUX_SOLIDS_COASTING_LEN = 'AuxSolidsCoastingLen'
+KEY_AUX_SOLIDS_WIPE_LEN = 'AuxSolidsWipeLen'
+KEY_AUX_SOLIDS_WIPE_DIR = 'AuxSolidsWipeDir'
 
 -- Parametri di macchina
-SEC_3DPRINTING = "3dPrinting"
-KEY_COEFF_X = "CoeffX"
-KEY_COEFF_Y = "CoeffY"
-KEY_SPEED_MIN = "SpeedMin"
-KEY_SPEED_MAX = "SpeedMax"
+SEC_3DPRINTING = '3dPrinting'
+KEY_HORIZ_EXTR = 'HorizExtrusion'
+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_SLICE_NBR = "SliceNbr"
-KEY_SLICE_Z = "SliceZ"
-KEY_SLICE_DELTAZ = "DeltaZ"
-KEY_SLICE_REAL_Z = "SliceRealZ"
-KEY_ZIG_ZAG_INFILL = "ZigZagInfill"
-KEY_ZIG_ZAG_DIR = "ZigZagDir"
-KEY_INVERTED_CRV = "InvertedCrv"
-KEY_CLOSED_CRV = "ClosedCrv"
-KEY_ASSOCIATED_SURF = "AssociatedSurf"
-KEY_ASSOCIATED_CRVS = "AssociatedCrvs"
-KEY_ORIGINAL_SURF = "OriginalSurf"
-KEY_HAS_SOLIDS = "Solids"
-KEY_BOX_MIN_Z = "PartBoxMinZ"
-KEY_ORIGINAL_START_POINT = "OriginalStartPoint"
-KEY_FIRST_SOLID_LAY = "FirstSolidLay"
-KEY_LAST_SOLID_LAY = "LastSolidLay"
-KEY_ASSOCIATED_TP_CRV = "AssociatedToolPathCrv"
-KEY_ASSOCIATED_P_CRV = "AssociatedPathCrv"
-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"
+KEY_MAX_H = 'SlicingHeight'
+KEY_MAX_SLICES_NBR = 'MaxSlicesNumber'
+KEY_SLICE_NBR = 'SliceNbr'
+KEY_SLICE_DIR = 'SliceDir'
+KEY_SLICE_POS = 'SlicePos'
+KEY_SLICE_DELTAZ = 'DeltaZ'
+KEY_ZIG_ZAG_INFILL = 'ZigZagInfill'
+KEY_ZIG_ZAG_DIR = 'ZigZagDir'
+KEY_INVERTED_CRV = 'InvertedCrv'
+KEY_CLOSED_CRV = 'ClosedCrv'
+KEY_ASSOCIATED_SURF = 'AssociatedSurf'
+KEY_ASSOCIATED_CRVS = 'AssociatedCrvs'
+KEY_ORIGINAL_SURF = 'OriginalSurf'
+KEY_HAS_SOLIDS = 'Solids'
+KEY_BOX_MIN_Z = 'PartBoxMinZ'
+KEY_ORIGINAL_START_POINT = 'OriginalStartPoint'
+KEY_FIRST_SOLID_LAY = 'FirstSolidLay'
+KEY_LAST_SOLID_LAY = 'LastSolidLay'
+KEY_ASSOCIATED_TP_CRV = 'AssociatedToolPathCrv'
+KEY_ASSOCIATED_P_CRV = 'AssociatedPathCrv'
+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'
+KEY_WIPE_ON_CRV = 'WipeOnCrv'
+KEY_FEED_COEFF = 'FeedCoeff'
+KEY_ENTITY_NAME = 'EntityName'
+KEY_MULTIPLANAR_MAX_H = 'MultiplanarMaxH'
+KEY_MULTIPLANAR_MIN_H = 'MultiplanarMinH'
 
 SLICING_TYPE = {
    VERTICAL = 1,
    DEG45_X = 2,
    DEG45_Y = 3,
    HORIZONTAL = 4,
+   MULTIPLANAR = 5,
+   MULTIPLANAR_DEG45 = 6,
+   MULTIPLANAR_HOR = 7,
 }
 
 TYPE = {
@@ -283,20 +303,21 @@ RIB_TYPE = {
 }
 
 ---------------------------------------------------------------------
-TABLE = "Table"
-PART = "Part"
-ORIGINAL_SOLID = "OriginalSolid"
-PRINT_SOLID = "PrintSolid"
-LAY_MACH_START = "MachStart"
-LAY_RIBS = "Ribs"
-LAY_AUX_SOLIDS = "AuxSolids"
-LAY_SHELL_NBR = "ShellNumber"
-LAY_AUX = "Aux"
-LAY_FRAME = "Frame"
+TABLE = 'Table'
+PART = 'Part'
+ORIGINAL_SOLID = 'OriginalSolid'
+PRINT_SOLID = 'PrintSolid'
+LAY_MACH_START = 'MachStart'
+LAY_RIBS = 'Ribs'
+LAY_AUX_SOLIDS = 'AuxSolids'
+LAY_SHELL_NBR = 'ShellNumber'
+LAY_AUX = 'Aux'
+SPINE_CURVE = 'Spine'
+LAY_FRAME = 'Frame'
 VIEWPARAMS = 'ViewParams'
 IMPORTED_SOLID = 'ImportedSolid'
 RESULT_READ_PROG = 'ResultReadProg'
-LAY_EXPORT = "ExportLayer"
+LAY_EXPORT = 'ExportLayer'
 
 KEY_PART_ON_TABLE = 'PartOnTable'
 KEY_RESULT = 'Result'
@@ -343,39 +364,39 @@ SLICE_ADV_TYPE = {
 }
 
 ---------------------------------------------------------------------
-RIBS_GRP = "Ribs"
-RIBS_CRV = "Rib"
-RIBS_LOOP_GRP = "RibsLoops"
+RIBS_GRP = 'Ribs'
+RIBS_CRV = 'Rib'
+RIBS_LOOP_GRP = 'RibsLoops'
 
-SHELL_NBR_GRP = "ShellNbrRegions"
-SHELL_NBR_CRV = "ShellNbrRegion"
-SHELL_NBR_SURF = "ShellNbrSurf"
+SHELL_NBR_GRP = 'ShellNbrRegions'
+SHELL_NBR_CRV = 'ShellNbrRegion'
+SHELL_NBR_SURF = 'ShellNbrSurf'
 
-AUX_SOLIDS_GRP = "AuxSolids"
-AUX_SOLIDS_INFILL_GRP = "InfillAuxSolids"
-AUX_SOLIDS_CRV = "AuxSolid"
-AUX_SOLIDS_INFILL_CRV = "InfillAuxSolid"
-AUX_SOLIDS_SRF = "SrfAuxSolid"
+AUX_SOLIDS_GRP = 'AuxSolids'
+AUX_SOLIDS_INFILL_GRP = 'InfillAuxSolids'
+AUX_SOLIDS_CRV = 'AuxSolid'
+AUX_SOLIDS_INFILL_CRV = 'InfillAuxSolid'
+AUX_SOLIDS_SRF = 'SrfAuxSolid'
 
-INFILL_GRP = "Infill"
-INFILL_CRV = "InfillCrv"
+INFILL_GRP = 'Infill'
+INFILL_CRV = 'InfillCrv'
 
 ---------------------------------------------------------------------
 -- parametri calcolo tempi, F ed S
-LAY_TFSCALC = "TFSCalc"
-KEY_TMIN = "TMin"
-KEY_TTRG = "TTrg"
-KEY_TMAX = "TMax"
-KEY_FMIN = "FMin"
-KEY_FTRG = "FTrg"
-KEY_FMAX = "FMax"
-KEY_TCUR = "TCur"
-KEY_FCUR = "FCur"
-KEY_LENGTH = "Length"
-KEY_SLICEID = "SliceId"
-KEY_MASS = "PrintMass"
-KEY_MF = "MF"
-KEY_TOTAREA = "TotArea"
+LAY_TFSCALC = 'TFSCalc'
+KEY_TMIN = 'TMin'
+KEY_TTRG = 'TTrg'
+KEY_TMAX = 'TMax'
+KEY_FMIN = 'FMin'
+KEY_FTRG = 'FTrg'
+KEY_FMAX = 'FMax'
+KEY_TCUR = 'TCur'
+KEY_FCUR = 'FCur'
+KEY_LENGTH = 'Length'
+KEY_SLICEID = 'SliceId'
+KEY_MASS = 'PrintMass'
+KEY_MF = 'MF'
+KEY_TOTAREA = 'TotArea'
 
 ---------------------------------------------------------------------
 return AddManData

LuaLibs/CalcPaths.lua

@@ -21,7 +21,7 @@ local s_vtSlicing
 local s_dOffsTol = 50 * GEO.EPS_SMALL
 
 ---------------------------------------------------------------------
-local function GetLayerParamsForPathCalc()   
+local function GetLayerParamsForPathCalc()
    local LayerParams = {}
    LayerParams.bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false
    LayerParams.nShellsNbr = EgtGetInfo( s_nPartId, KEY_SHELLS_NBR, 'i')
@@ -31,7 +31,7 @@ local function GetLayerParamsForPathCalc()
    LayerParams.dLayHeight = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd')
    LayerParams.dStrandOverlap = EgtGetInfo( s_nPartId, KEY_STRAND_OVERLAP, 'd') or 0
    LayerParams.dOffs = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd')
-   s_vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v')
+   s_vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICE_DIR, 'v')
    LayerParams.bPrintInvert = ( EgtGetInfo( s_nPartId, KEY_PRINT_DIRECTION, 'i') == PRINT_DIRECTION.CW)
    LayerParams.vPrintOrder = EgtGetInfo( s_nPartId, KEY_PRINT_ORDER, 'vi') or { 1, 2, 3, 4, 5, 6, 7, 8}
    -- parametri costolature
@@ -116,19 +116,13 @@ end
 
 ---------------------------------------------------------------------
 local function GetLayerStartPoint( nLayId)
-   
-   -- recupero quota layer
-   local dZ = EgtGetInfo( nLayId, KEY_SLICE_REAL_Z, 'd')
-   local dDeltaZ = EgtGetInfo( nLayId, KEY_SLICE_DELTAZ, 'd')
-   local frSlicing = Frame3d( ORIG(), s_vtSlicing)
-   local ptOn = Point3d( 0, 0, dZ + dDeltaZ)
-   ptOn:toGlob( frSlicing)
-   
+
    -- gruppo temporaneo dove salvo i risultati
    local nGrpTmp = EgtGroup( nLayId)
    
    local vPtStart = {}
    local nMachStartGrp = EgtGetFirstNameInGroup( s_nPartId, LAY_MACH_START)
+   local ptOn = EgtGetInfo( nLayId, KEY_SLICE_POS, 'p')
    local nStartId = EgtGetFirstInGroup( nMachStartGrp)
    while nStartId do
       local nType = EgtGetType( nStartId)
@@ -184,6 +178,7 @@ local function GetPathsFromSurf( nSrfId, sName, nType, nGrpId, vPtStart)
       for nInd = 0, nCrvCnt - 1 do
          EgtSetName( nCrvId + nInd, sName)
          EgtSetInfo( nCrvId + nInd, KEY_TYPE, nType)
+         EgtModifyCurveExtrusion( nCrvId + nInd, s_vtSlicing, GDB_ID.ROOT)
          
          -- se è loop interno lo inverto per averlo orientato in senso antiorario 
          if nInd > 0 then
@@ -450,7 +445,8 @@ end
 ---------------------------------------------------------------------------
 local function ReorderPath( vOldIds, vNewIds)
    
-   if not vNewIds or not vOldIds then return end
+   if not vNewIds or #vNewIds == 0 then return end
+   if not vOldIds or #vOldIds == 0 then return end
    
    -- suddivido in base alla tipologia di loop ( esterno o interno)
    local tOldIds = {{}, {}}
@@ -706,58 +702,50 @@ end
 --------------------------------------------------------------------
 local function VerifyRibsHoles( vIds)
    
+   -- raggruppo i setti per nome
+   local tabRibs = { { vIds[1]}}
    local sPrevName = EgtGetName( vIds[1])
-   local i = 2
-   while i <= #vIds do
-      
-      local bAdd = false
-      local sCurrName = EgtGetName( vIds[i])
-      -- se derivano dallo stesso setto verifico se possono essere uniti
-      if sCurrName == sPrevName then
-         local dStrand = EgtGetInfo( vIds[i], KEY_RIBS_STRAND, 'd')
-         local ptS1 = EgtSP( vIds[i-1])
-         local ptE1 = EgtEP( vIds[i-1])
-         local ptS2 = EgtSP( vIds[i])
-         local ptE2 = EgtEP( vIds[i])
-         
-         local bAdd1 = dist( ptS1, ptE2) < dStrand + 10 * GEO.EPS_SMALL or dist( ptS1, ptS2) < dStrand + 10 * GEO.EPS_SMALL
-         local bAdd2 = dist( ptE1, ptS2) < dStrand + 10 * GEO.EPS_SMALL or dist( ptE1, ptE2) < dStrand + 10 * GEO.EPS_SMALL
-         local bInvert = dist( ptE1, ptE2) < dStrand + 10 * GEO.EPS_SMALL or dist( ptS1, ptS2) < dStrand + 10 * GEO.EPS_SMALL
-         
-         if bInvert then
-            EgtInvertCurve( vIds[i])
-         end
-         
-         if bAdd1 and bAdd2 then
-            -- se da unire in setto chiuso
-            bAdd = true
-            EgtAddCurveCompoLine( vIds[i-1], EgtEP( vIds[i]), false)
-            EgtAddCurveCompoLine( vIds[i-1], EgtSP( vIds[i]))
-            EgtAddCurveCompoCurve( vIds[i-1], vIds[i])
-            table.remove( vIds, i)   -- rimuovo il setto dalla tabella
-            
-         elseif bAdd2 then
-            bAdd = true
-            -- unisco il secondo tratto al primo
-            EgtAddCurveCompoLine( vIds[i-1], EgtSP( vIds[i]))
-            EgtAddCurveCompoCurve( vIds[i-1], vIds[i])
-            table.remove( vIds, i)   -- rimuovo il setto dalla tabella
-            
-         elseif bAdd1 then
-            bAdd = true
-            -- unisco il primo tratto al secondo
-            EgtAddCurveCompoLine( vIds[i], EgtSP( vIds[i-1]))
-            EgtAddCurveCompoCurve( vIds[i], vIds[i-1])
-            table.remove( vIds, i-1)  -- rimuovo il setto dalla tabella
-         end
-      end
-      
-      -- aggiorno per iterazione successiva
-      sPrevName = sCurrName
-      if not bAdd then
-         i = i + 1
+   for i = 2, #vIds do
+      if sPrevName == EgtGetName( vIds[i]) then
+         table.insert( tabRibs[#tabRibs], vIds[i])
+      else
+         sPrevName = EgtGetName( vIds[i])
+         table.insert( tabRibs, { vIds[i]})
       end
    end
+   
+   -- verifico se posso concatenare le curve con lo stesso nome usando come tolleranza lo strand del setto ( se le passate si toccano non ha senso tenerle separate)
+   local nGrp = EgtGetParent( vIds[1])
+   for i = 1, #tabRibs do
+      if #tabRibs[i] > 1 then
+         local dStrand = EgtGetInfo( tabRibs[i][1], KEY_RIBS_STRAND, 'd')
+
+         -- gruppo temporaneo per il concatenamento
+         local nGrpTmp = EgtGroup( nGrp)
+         for j = 1, #tabRibs[i] do
+            EgtRelocateGlob( tabRibs[i][j], nGrpTmp)
+         end
+         EgtReorderCurvesInGroup( nGrpTmp, EgtSP( tabRibs[i][1], GDB_ID.ROOT), GDB_RT.GLOB, dStrand)
+         
+         -- recupero le curve e le concateno se possibile
+         local vNewIds = EgtGetAllInGroup( nGrpTmp)
+         local nCurrId = vNewIds[1]
+         EgtRelocateGlob( nCurrId, nGrp)
+         for j = 2, #vNewIds do
+            if dist( EgtEP( nCurrId, GDB_ID.ROOT), EgtSP( vNewIds[j], GDB_ID.ROOT)) < dStrand + GEO.EPS_SMALL then
+               EgtAddCurveCompoLine( nCurrId, EgtSP( vNewIds[j], GDB_ID.ROOT), GDB_RT.GLOB)
+               EgtAddCurveCompoCurve( nCurrId, vNewIds[j])
+            else
+               nCurrId = vNewIds[j]
+               EgtRelocateGlob( nCurrId, nGrp)
+            end
+         end
+         EgtErase( nGrpTmp)
+      end
+   end
+   
+   -- aggiorno gli id
+   return EgtGetAllInGroup( nGrp)
 end
 
 --------------------------------------------------------------------
@@ -979,7 +967,7 @@ end
 -------------------------------------------------------------------
 local function FindHoleCurve( pt, vLoopIds)
    -- trovo indice della curva di vLoopIds a cui appartiene pt ( in globale)
-   if not vLoopIds then return end
+   if not vLoopIds or #vLoopIds == 0 then return end
    for i = 1, #vLoopIds do
       local dPar = EgtCurveParamAtPoint( vLoopIds[i], pt, 100 * GEO.EPS_SMALL, GDB_RT.GLOB)
       if dPar then
@@ -1285,7 +1273,8 @@ local function ComputeRibsOrientedOffset( nRibsGrp)
          local bCCW = EgtGetInfo( vIds[i], KEY_RIBS_USER_LINK_CCW, 'b') or false
          local nLinkOrder = EgtGetInfo( vIds[i], KEY_RIBS_USER_LINK_ORDER, 'i') or 0
          local dStrand = EgtGetInfo( vIds[i], KEY_RIBS_STRAND, 'd')
-         local dOffs = ( nShellsNbr - 1) * dStrand / 2
+         local dStrandOverlap = EgtGetInfo( vIds[i], KEY_RIBS_STRAND_OVERLAP, 'd') or 0
+         local dOffs = ( nShellsNbr - 1) * ( 1 - dStrandOverlap / 100) * dStrand / 2
          
          -- ordine di realizzazione degli offset
          if not bUserLinked then
@@ -1301,7 +1290,7 @@ local function ComputeRibsOrientedOffset( nRibsGrp)
          
          local vOffsRib = {}
          for k = 0, nShellsNbr - 1 do
-            local dOffsCurr = dOffs - k * dStrand
+            local dOffsCurr = dOffs - k * ( 1 - dStrandOverlap / 100) * dStrand
             local nNewId
             if abs( dOffsCurr) < GEO.EPS_SMALL then
                nNewId = EgtCopyGlob( vIds[i], nOffsGrp)
@@ -1422,7 +1411,7 @@ local function ComputeTrimSurfWithOverlapsForRibs( vIds, nGrp, nSrfInt, nSrfExt,
             
          elseif nType == RIB_TYPE.EXTERNAL then
             if not nSrfExt then
-               -- il setto va cancellato
+               -- sono in un CrvGrp intermedio, il setto va cancellato
             elseif nSrfExt == GDB_ID.NULL then
                -- se la superficie non esiste il setto va conservato
                tSurfOffs[vIds[i]] = GDB_ID.NULL
@@ -1441,8 +1430,11 @@ local function ComputeTrimSurfWithOverlapsForRibs( vIds, nGrp, nSrfInt, nSrfExt,
             end
             
          else
-            -- se unbounded non va mai trimmato
-            tSurfOffs[vIds[i]] = GDB_ID.NULL
+            -- il setto unbounded deve comparire solo nell'ultimo CrvGrp senza alcun trim. Se nSrfExt non è definita sono in un CrvGrp intermedio e il setto va cancellato 
+            -- se nSrfExt è definita allora il setto non va trimmato
+            if nSrfExt then
+               tSurfOffs[vIds[i]] = GDB_ID.NULL
+            end
          end
          
          tOffs[vIds[i]] = dOffs
@@ -1605,10 +1597,11 @@ local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, nOffsGrp, nLoopGrp
    
    local nShells = EgtGetInfo( nCrv1, KEY_RIBS_SHELLS_NBR, 'i')
    local dStrand1 = EgtGetInfo( nCrv1, KEY_RIBS_STRAND, 'd')
+   local dStrandOverlap1 = EgtGetInfo( nCrv1, KEY_RIBS_STRAND_OVERLAP, 'd') or 0
    local dOverlap = EgtGetInfo( nCrv2, KEY_RIBS_OVERLAP, 'i')
    local dStrand2 = EgtGetInfo( nCrv2, KEY_RIBS_STRAND, 'd')
 
-   if dOverlap / 100 * dStrand2 > nShells * dStrand1 * 0.5 - GEO.EPS_SMALL then
+   if dOverlap / 100 * dStrand2 > ( nShells - 1) * ( 1 - dStrandOverlap1 / 100) * dStrand1 * 0.5 + dStrand1 * 0.5 - GEO.EPS_SMALL then
       -- non ha senso spezzare la curva, aggiorno solo split order dei suoi offset
       for i = 1, #vOffs2 do
          CopyInfo( nCrv2, vOffs2[i], KEY_SPLIT_ORDER, 'i')
@@ -1617,7 +1610,7 @@ local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, nOffsGrp, nLoopGrp
    end
    
    -- calcolo la superficie della curva principale ( nCrv1) da usare per trim
-   local dOffs = nShells * dStrand1 * 0.5 + dStrand2 * ( 0.5 - dOverlap / 100)
+   local dOffs = ( nShells - 1) * ( 1 - dStrandOverlap1 / 100) * dStrand1 * 0.5 + dStrand1 * 0.5 + dStrand2 * ( 0.5 - dOverlap / 100)
    local nSrf = EgtSurfFrFatCurve( nOffsGrp, nCrv1, dOffs, false, false, s_dOffsTol)
    if not nSrf then
       EgtOutLog( 'Error : ribs intersection failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
@@ -1676,9 +1669,11 @@ local function AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, nOffsGrp)
   
    -- costruisco le superfici da usare per trim
    local dStrand1 = EgtGetInfo( nCrv1, KEY_RIBS_STRAND, 'd')
-   local nSrf1 = EgtSurfFrFatCurve( nOffsGrp, nCrv1, dStrand1 * 0.5, false, false, s_dOffsTol)
+   local dStrandOverlap1 = EgtGetInfo( nCrv1, KEY_RIBS_STRAND_OVERLAP, 'd') or 0
+   local nSrf1 = EgtSurfFrFatCurve( nOffsGrp, nCrv1, ( 1 - dStrandOverlap1 / 100) * dStrand1 * 0.5, false, false, s_dOffsTol)
    local dStrand2 = EgtGetInfo( nCrv2, KEY_RIBS_STRAND, 'd')
-   local nSrf2 = EgtSurfFrFatCurve( nOffsGrp, nCrv2, dStrand2 * 0.5, false, false, s_dOffsTol)
+   local dStrandOverlap2 = EgtGetInfo( nCrv2, KEY_RIBS_STRAND_OVERLAP, 'd') or 0
+   local nSrf2 = EgtSurfFrFatCurve( nOffsGrp, nCrv2, ( 1 - dStrandOverlap2 / 100) * dStrand2 * 0.5, false, false, s_dOffsTol)
    
    -- trim degli offset di nCrv1
    local vOffs1 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv1)) or {}
@@ -1725,13 +1720,12 @@ end
 local function HandleRibsIntersections( nRibsGrp, nOffsGrp, nRibsPathGrp, nSrfInt, nSrfExt, bAllTwoStrands, vTypeSequence, nLoopGrp, tSurfOffs)
 
    local bSpecialCase = false
-   local vOffsIds = EgtGetNameInGroup( nRibsPathGrp, RIBS_CRV .. '*')   -- passate dei setti
    local vAllRibsIds = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*')    -- setti originali
    local vRibsIds = {}
    -- ignoro setti che non hanno passate corrispondenti
    for i = 1, #vAllRibsIds do
       local vOffs = EgtGetNameInGroup( nRibsPathGrp, EgtGetName( vAllRibsIds[i]))
-      if vOffs then table.insert( vRibsIds, vAllRibsIds[i]) end
+      if vOffs and #vOffs > 0 then table.insert( vRibsIds, vAllRibsIds[i]) end
    end
    
    -- creo un gruppo con frame locale per calcolare le intersezioni ( è il piano XY locale dove calcolare intersezioni)
@@ -2039,6 +2033,9 @@ local function ShortestPathForRibs( vRibs, nGrp, bInvertOrder)
    if #tabRibs == 1 then
       -- se un solo gruppo ordinamento banale
       vOrd = {1}
+   elseif #tabRibs == 2 then
+      -- se due gruppi fisso l'ordinamento per evitare inversioni tra i layers
+      vOrd = { 1, 2}
    else
       -- se più gruppi ordinamento con shortest path
       EgtSpInit()
@@ -2142,8 +2139,11 @@ local function ReassignInfo( nCrv, nCnt, vOrig)
                CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_IN_LEN, 'd')
                CopyInfo( vOrig[i], nId, KEY_ASSOCIATED_SURF, 'i')
                CopyInfo( vOrig[i], nId, KEY_RIBS_OVERLAP, 'd')
+               CopyInfo( vOrig[i], nId, KEY_RIBS_STRAND_OVERLAP, 'd')
                CopyInfo( vOrig[i], nId, KEY_RIBS_TYPE, 'i')
                CopyInfo( vOrig[i], nId, KEY_RIBS_LINK, 'b')
+               CopyInfo( vOrig[i], nId, KEY_RIBS_LINK_FILLET, 'd')
+               CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_FILLET, 'd')
                bStart = true
             end
             -- verifico se corrisponde al suo end
@@ -2368,7 +2368,7 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart, bIgnor
    end
    
    -- verifico se posso ignorare eventuali buchi nei setti
-   VerifyRibsHoles( vOrigRibs)
+   vOrigRibs = VerifyRibsHoles( vOrigRibs)
    
    local nTotSrfInt = GDB_ID.NULL
    local nTotSrfExt = GDB_ID.NULL
@@ -2391,7 +2391,7 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart, bIgnor
       local nSrfInt = EgtGetFirstNameInGroup( vCrvGrps[i], TOT_SHELL_TRIM_SURF) or GDB_ID.NULL
       if nTotSrfInt == GDB_ID.NULL and nSrfInt ~= GDB_ID.NULL then
          nTotSrfInt = EgtCopyGlob( nSrfInt, nRibsGrp)
-      elseif nTotSrfInt ~= GDB_ID.NULL then
+      elseif nTotSrfInt ~= GDB_ID.NULL and nSrfInt ~= GDB_ID.NULL then
          if not EgtSurfFrAdd( nTotSrfInt, nSrfInt) then
             EgtOutLog( 'Error : EgtSurfFrAdd for external ribs failed. Errors may occur with user-linked ribs (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
          end
@@ -2500,7 +2500,7 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart, bIgnor
                                                              bAllTwoStrands, vTypeSequence, nLoopGrp, tSurfOffs)
       EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_INTERS, bInters)
       EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_SPECIAL_CASE, bSpecialCase)
-      
+     
       -- riordino le costolature
       if bSpecialCase then
          -- gestione caso speciale di intersezione e 2 passate
@@ -2526,6 +2526,90 @@ end
 
 --------------------------------------------------------------------
 --------------------- RIBS-MERGED SHELLS ---------------------------
+--------------------------------------------------------------------
+local function CalcFillet( nCrv1, nCrv2, dFillet, nGrpId, nGrpTmp)
+
+   if dFillet < GEO.EPS_SMALL then return end
+   
+   -- creo il fillet
+   local dParRef1 = EgtCurveParamAtLength( nCrv1, EgtCurveLength( nCrv1) - 100 * GEO.EPS_SMALL)
+   local dParRef2 = EgtCurveParamAtLength( nCrv2, 100 * GEO.EPS_SMALL)
+   local nFillet = EgtCurveFillet( nGrpTmp, nCrv1, EgtUP( nCrv1, dParRef1, nGrpTmp), nCrv2, EgtUP( nCrv2, dParRef2, nGrpTmp), dFillet, true, GDB_RT.LOC)
+   if not nFillet then
+      -- ritento con valore di fillet leggermente inferiore
+      nFillet = EgtCurveFillet( nGrpTmp, nCrv1, EgtUP( nCrv1, dParRef1, nGrpTmp), nCrv2, EgtUP( nCrv2, dParRef2, nGrpTmp), dFillet - 50 * GEO.EPS_SMALL, true, GDB_RT.LOC)
+   end
+
+   -- spezzo a metà il fillet per assegnarlo alle due curve
+   if nFillet then
+      local nNewFillet = EgtSplitCurve( nFillet, 2)
+      
+      -- aggiungo a nCrv1
+      if EgtExistsObj( nCrv1) then
+         EgtAddCurveCompoArcTg( nCrv1, EgtEP( nNewFillet, GDB_ID.ROOT), true, GDB_RT.GLOB)
+         EgtErase( nNewFillet)
+      else
+         -- nCrv1 viene sostituita completamente dal fillet
+         local nNewCrv = EgtCurveCompo( nGrpId, {nNewFillet})
+         EgtChangeId( nNewCrv, nCrv1)
+      end
+      
+      -- aggiungo a nCrv2
+      if EgtExistsObj( nCrv2) then
+         EgtAddCurveCompoArcTg( nCrv2, EgtSP( nNewFillet + 1, GDB_ID.ROOT), false, GDB_RT.GLOB)
+         EgtErase( nNewFillet + 1)
+      else
+         -- nCrv2 viene sostituita completamente dal fillet
+         local nNewCrv = EgtCurveCompo( nGrpId, {nNewFillet + 1})
+         EgtChangeId( nNewCrv, nCrv2)
+      end
+   else
+      EgtOutLog( 'Warning : ribs-merged shells fillet not possible (layer '..tostring( s_nCurrIdx)..') - CalcPath')
+   end
+   
+   EgtRelocateGlob( nFillet or GDB_ID.NULL, nGrpId)
+end
+
+--------------------------------------------------------------------
+local function AddFillet( nRib1, vLinks, nRib2, nGrpId)
+   
+   local dFillet1 = EgtGetInfo( nRib1, KEY_RIBS_LINK_FILLET, 'd')
+   local dFillet2 = EgtGetInfo( nRib2, KEY_RIBS_LINK_FILLET, 'd')
+   -- verifico se necessaria correzione per passate dello stesso setto
+   local nOrig1 = EgtGetInfo( nRib1, KEY_ORIGINAL_RIB, 'i')
+   local nOrig2 = EgtGetInfo( nRib2, KEY_ORIGINAL_RIB, 'i')
+   local nSplit1 = EgtGetInfo( nRib1, KEY_SPLIT_ID, 'i') or 0
+   local nSplit2 = EgtGetInfo( nRib2, KEY_SPLIT_ID, 'i') or 0
+   if nOrig1 == nOrig2 and nSplit1 == nSplit2 then
+      local dStrand = EgtGetInfo( nRib1, KEY_RIBS_STRAND, 'd')
+      local dStrandOverlap = EgtGetInfo( nRib1, KEY_RIBS_STRAND_OVERLAP, 'd')
+      dFillet1 = min( dFillet1, 0.5 * ( 1 - dStrandOverlap / 100) * dStrand)
+      dFillet2 = dFillet1
+   end
+   
+   -- creo un gruppo con riferimento locale allo slicing per i conti del fillet
+   local nGrpTmp = EgtGroup( nGrpId, Frame3d( ORIG(), s_vtSlicing), GDB_RT.GLOB)
+   
+   -- calcolo il primo fillet
+   local ptRib1 = EgtEP( nRib1, GDB_ID.ROOT)
+   for i = 1, #vLinks do
+      if AreSamePointApprox( ptRib1, EgtSP( vLinks[i], GDB_ID.ROOT)) then
+         CalcFillet( nRib1, vLinks[i], dFillet1, nGrpId, nGrpTmp)
+         break
+      end
+   end
+   -- calcolo il secondo fillet
+   local ptRib2 = EgtSP( nRib2, GDB_ID.ROOT)
+   for i = 1, #vLinks do
+      if AreSamePointApprox( EgtEP( vLinks[i], GDB_ID.ROOT), ptRib2) then
+         CalcFillet( vLinks[i], nRib2, dFillet2, nGrpId, nGrpTmp)
+         break
+      end
+   end
+
+   EgtErase( nGrpTmp)
+end
+
 --------------------------------------------------------------------
 local function ComputeShortestLinkOnCurve( nCrv, dParS, dParE, nGrp)
    
@@ -2721,7 +2805,7 @@ local function HandleRibsIntersectionForRibsMergedShells( vOrigRibs, nRibsGrp, n
    -- ignoro setti che non hanno passate corrispondenti
    for i = 1, #vOrigRibs do
       local vOffs = EgtGetNameInGroup( nRibsGrp, EgtGetName( vOrigRibs[i]))
-      if vOffs then table.insert( vRibsIds, vOrigRibs[i]) end
+      if vOffs and #vOffs > 0 then table.insert( vRibsIds, vOrigRibs[i]) end
    end
    
    -- creo un gruppo con frame locale per calcolare le intersezioni ( è il piano XY locale dove calcolare intersezioni)
@@ -2747,9 +2831,18 @@ local function HandleRibsIntersectionForRibsMergedShells( vOrigRibs, nRibsGrp, n
                nCrv1, nCrv2 = nCrv2, nCrv1
             end
             
+            -- verifico che la curva secondaria abbia una sola passata
+            local nShells2 = EgtGetInfo( nCrv2, KEY_RIBS_SHELLS_NBR, 'i')
+            if nShells2 > 1 then
+               EgtOutLog( 'Error : shell-merged ribs intersect in a non valid way (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
+               table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in ribs-merged shells intersection')
+               return false
+            end
+            
             -- calcolo la superficie della curva principale ( nCrv1) da usare per trim
             local nShells = EgtGetInfo( nCrv1, KEY_RIBS_SHELLS_NBR, 'i')
-            local dOffs = (( nShells + 1) * 0.5 - dOverlap / 100) * dStrand
+            local dStrandOverlap = EgtGetInfo( nCrv1, KEY_RIBS_STRAND_OVERLAP, 'd')
+            local dOffs = (( nShells - 1) * ( 1 - dStrandOverlap / 100) * 0.5 + 1 - dOverlap / 100) * dStrand
             local nSrf = EgtSurfFrFatCurve( nGrpTmp, nCrv1, dOffs, false, false, s_dOffsTol)
             if not nSrf then
                EgtOutLog( 'Error : EgtSurfFrFatCurve for shell-merged ribs intersection failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
@@ -2776,6 +2869,8 @@ local function HandleRibsIntersectionForRibsMergedShells( vOrigRibs, nRibsGrp, n
                      if nLinkId then
                         local nRes = EgtCurveWithRegionClassify( nLinkId, nShellSrf)
                         if nRes == GDB_CRC.IN then
+                           -- fillet
+                           AddFillet( nCrv, {nLinkId}, nCrv + 1, nRibsGrp)
                            EgtAddCurveCompoCurve( nCrv + 1, nLinkId, true, false)
                            EgtAddCurveCompoCurve( nCrv + 1, nCrv, true, false)
                         else
@@ -2816,7 +2911,7 @@ end
 local function PrepareRibsForMergeWithShells( vOrigRibs, nGrp, dStrand, dOverlap, bInvertRibsOrder)
    
    -- verifico se sono presenti buchi che possono essere chiusi
-   VerifyRibsHoles( vOrigRibs)
+   vOrigRibs = VerifyRibsHoles( vOrigRibs)
    
    -- trim grossolano dei setti
    local nSrfCoarseTrim = EgtGetFirstNameInGroup( nGrp, COARSE_TRIM_SURF)
@@ -2881,6 +2976,7 @@ local function CreateRibsMergedShellLastLink( vShells, vRibs, nGrp, bInvert)
          if bInvert then
             -- conservo tratto dParS->dParE
             EgtTrimCurveStartEndAtParam( nLink, dParS, dParE)
+            EgtInvertCurve( nLink)
          else
             -- conservo tratto dParE->dParS
             EgtTrimCurveStartEndAtParam( nLink, dParE, dParS)
@@ -2923,6 +3019,8 @@ local function CreateRibsMergedShellLastLink( vShells, vRibs, nGrp, bInvert)
                            end
                         end
                         if nPartLink then
+                           -- fillet
+                           AddFillet( vRibs[i], {nPartLink}, nOtherPart, nGrp)
                            EgtAddCurveCompoCurve( vRibs[i], nPartLink)
                            EgtAddCurveCompoCurve( vRibs[i], nOtherPart)
                         end
@@ -3012,23 +3110,39 @@ end
 
 --------------------------------------------------------------------
 local function AdjustRibsMergedExtraShellLink( nLinkId, vExtraShells, nGrp)
+
+   local vLinks = {}
    
-   local frLoc = Frame3d( ORIG(), s_vtSlicing)
-   local nGrpLoc = EgtGroup( nGrp, frLoc)
-   
-   -- devo conservare solo le intersezioni fra link ed extra shell
+   -- devo conservare solo i tratti comuni fra link ed extra shell
    for i = 1, #vExtraShells do
-      local nRes, nPntCnt, nCrvCnt = EgtCurveCurveInters( nLinkId, vExtraShells[i], nGrpLoc)
-      if nRes then
-         for nId = nRes + nPntCnt, nRes + nPntCnt + nCrvCnt - 1 do
-            EgtRelocateGlob( nId, nGrp)
+      
+      local dParS = EgtCurveParamAtPoint( nLinkId, EgtSP( vExtraShells[i]), 100 * GEO.EPS_SMALL)
+      local dParE = EgtCurveParamAtPoint( nLinkId, EgtEP( vExtraShells[i]), 100 * GEO.EPS_SMALL)
+      if dParS or dParE then
+         local nCrv = EgtCopyGlob( nLinkId, nGrp)
+         if dParS and dParE then
+            EgtTrimCurveStartEndAtParam( nCrv, dParS, dParE)
+         elseif dParS then
+            EgtTrimCurveStartAtParam( nCrv, dParS)
+         elseif dParE then
+            EgtTrimCurveEndAtParam( nCrv, dParE)
+         end
+         EgtModifyCurveExtrusion( nCrv, s_vtSlicing, GDB_ID.ROOT)
+         table.insert( vLinks, nCrv)
+      else
+         
+         -- verifico se il link originale è già corretto
+         local dPar1 = EgtCurveParamAtPoint( vExtraShells[i], EgtSP( nLinkId), 100 * GEO.EPS_SMALL)
+         local dPar2 = EgtCurveParamAtPoint( vExtraShells[i], EgtEP( nLinkId), 100 * GEO.EPS_SMALL)
+         if dPar1 and dPar2 then
+            return { nLinkId}
          end
       end
    end
    
    -- cancello il link originale
    EgtErase( nLinkId)
-   EgtErase( nGrpLoc)
+   return vLinks
 end
 
 --------------------------------------------------------------------
@@ -3070,7 +3184,7 @@ local function CreateRibsMergedShellCurve( nGrp, nRibsGrp, vShells, vOrigShells,
       -- creo il link
       local nLinkId = CreateRibsMergedShellLink( nCurr, nNext, nGrp, EgtIf( bLinkOnShell, vLoopsShell, vLoopsTrim), nRibsGrp)
       if not nLinkId then
-         return false 
+         return false
       end
 
       -- se link fatto sulla shell verifico non si sovrapponga al last link 
@@ -3092,16 +3206,24 @@ local function CreateRibsMergedShellCurve( nGrp, nRibsGrp, vShells, vOrigShells,
       end
       
       -- verifico se necessari aggiustamenti per extra shell
+      local vLinks
       if bExtraShell and bLinkOnShell then
-         AdjustRibsMergedExtraShellLink( nLinkId, vOrigShells, nGrp)
+         vLinks = AdjustRibsMergedExtraShellLink( nLinkId, vOrigShells, nGrp)
       end
       
+      -- fillet
+      AddFillet( nCurr, vLinks or {nLinkId}, nNext, nGrp)
+      
    end
    
    -- eventuali aggiustamenti del last link per extra shell
+   local vLastLinks
    if bExtraShell then
-       AdjustRibsMergedExtraShellLink( nLastLink, vOrigShells, nGrp)
+      vLastLinks = AdjustRibsMergedExtraShellLink( nLastLink, vOrigShells, nGrp)
    end
+   
+   -- fillet sul last link
+   AddFillet( vRibs[#vRibs], vLastLinks or {nLastLink}, vRibs[1], nGrp)
 
    -- elimino le curve inutili e le superfici
    EgtErase( nRibsGrp)
@@ -3248,7 +3370,7 @@ local function CalcRibsMergedShells( nSlicedRibsGrp, nPathGrp, LayerParams, vPtS
       end
    end
    if #vOrigRibs == 0 then return true end
-   
+  
    -- recupero le shell da unire ai setti
    local nLast = EgtGetLastInGroup( nPathGrp) or GDB_ID.NULL
    local nShellType = EgtGetInfo( nLast, KEY_TYPE, 'i')
@@ -3649,7 +3771,7 @@ local function ReorderExtraShells( nPathGrp, vPtStart, LayerParams)
    end
    
    local vIds = EgtGetNameInGroup( nPathGrp, EXTRA_SHELL_CRV .. '*')
-   if not vIds then return end
+   if not vIds or #vIds == 0 then return end
    
    -- eventuale inversione di tutte le curve
    if LayerParams.bPrintInvert then
@@ -3998,7 +4120,7 @@ end
 local function AddExtraZigZag( nSrf, sName, dStrand, nGrp, nSrfTrim)
    
    local vIds = EgtGetNameInGroup( nGrp, sName)
-   if not vIds then return end
+   if not vIds or #vIds == 0 then return end
    local vtDir = EgtSV( vIds[1], GDB_ID.ROOT)
    local vtYLoc = s_vtSlicing ^ vtDir
    
@@ -4205,7 +4327,7 @@ function CalcPaths.Exec( nPartId)
    s_nPartId = nPartId
 
    local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*")
-   if not vLayIds then
+   if not vLayIds or #vLayIds == 0 then
       EgtOutBox( 'Error no slice', 'PathCalc')
       return true
    end
@@ -4214,12 +4336,17 @@ function CalcPaths.Exec( nPartId)
    local LayerParams = GetLayerParamsForPathCalc()
    local nFirstSolidLay = EgtGetInfo( s_nPartId, KEY_FIRST_SOLID_LAY, 'i') or -1
    local nLastSolidLay = EgtGetInfo( s_nPartId, KEY_LAST_SOLID_LAY, 'i') or -1
+   local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i')
 
    -- scorro tutti i suoi layer
    for nIdx = 1, #vLayIds do
        
       s_nCurrIdx = nIdx
-      
+
+      if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
+         s_vtSlicing = EgtGetInfo( vLayIds[nIdx], KEY_SLICE_DIR, 'v')
+      end
+
       local nRibsGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], RIBS_GRP)
       local bIgnoreMergedRibs = true
       local nAuxSolidsGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], AUX_SOLIDS_GRP)

LuaLibs/RunGcodeGenerate.lua

@@ -33,10 +33,11 @@ function RunGcodeGenerate.Exec()
       EgtOutBox( 'Error missing part', 'GcodeGenerate')
       return 
    end
+   local nSlicingType = EgtGetInfo( nPartId, KEY_SLICING_TYPE, 'i')
 
    -- 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
@@ -89,8 +90,15 @@ function RunGcodeGenerate.Exec()
    -- Rimuovo eventuali precedenti lavorazioni
    EgtRemoveAllOperations()
 
+   -- Determino lavorazione di libreria
+   local sExtrName = 'Extrusion'
+   if nSlicingType == SLICING_TYPE.HORIZONTAL or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
+      local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
+      sExtrName = EgtGetStringFromIni( SEC_3DPRINTING, KEY_HORIZ_EXTR, sExtrName, sMachIni)
+   end
+
    -- Aggiungo la lavorazione
-   local nMchId = EgtAddMachining( 'Extrusion 1', 'Extrusion')
+   local nMchId = EgtAddMachining( 'Extrusion 1', sExtrName)
    if not nMchId then
       EgtOutBox( 'Error adding Extrusion', 'GcodeGenerate')
       return

LuaLibs/RunMachParamFromSWCalc.lua

@@ -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
@@ -187,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
@@ -203,7 +207,7 @@ function RunMachParamFromSWCalc.Exec()
          end
          if not bSpeedOk then
             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))
+               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)
@@ -219,10 +223,22 @@ 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

LuaLibs/RunPrepareExport.lua

@@ -13,8 +13,8 @@ EgtOutLog( ' RunPreprareExport started', 1)
 local AMD = require( 'AddManData')
 
 ------------------------------------------------------------------
-local function CalcCurves( nSliceId, nDestGrp, vtSlicing, dStrandBase)
-   
+local function CalcCurves( nSliceId, nDestGrp, dStrandBase)
+  
    -- scorro tutti i gruppi di curve
    local vCrvs = EgtGetNameInGroup( nSliceId, CONTOUR_GRP .. '*')
    for j = 1, #vCrvs do
@@ -28,56 +28,67 @@ local function CalcCurves( nSliceId, nDestGrp, vtSlicing, dStrandBase)
             if nType ~= TYPE.WIPE then
                local dStrand = EgtGetInfo( nId, KEY_CRV_STRAND, 'd') or dStrandBase
                
-               -- TO DO : da sostituire con offset di Vroni che per curve aperte è la fat curve
+               -- 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 nCopyInv = EgtCopyGlob( nId, nDestGrp)
-               EgtInvertCurve( nCopyInv)
-               EgtAddCurveCompoCurve( nCopy, nCopyInv)
-               local nCrv, nCnt = EgtOffsetCurveAdv( nCopy, 0.5 * dStrand)
+               local nSurf = EgtSurfFrFatCurve( nDestGrp, nCopy, 0.5 * dStrand + 0.01, false)
                -- se fallisce ritento con valore leggermente diverso
-               if not nCrv or nCnt == 0 then
-                  nCrv, nCnt = EgtOffsetCurveAdv( nCopy, 0.5 * dStrand - 0.05)
+               if not nSurf or nSurf == GDB_ID.NULL then
+                  nSurf = EgtSurfFrFatCurve( nDestGrp, nCopy, 0.5 * dStrand - 0.05, false)
                end
-               
-               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)
+               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
+                           
+                           -- recupero la prima curva del loop interno che non sia di raccordo
+                           local vTempProps = EgtCurveCompoGetTempProp( nLoopId)
+                           local dU
+                           for i = 1, #vTempProps do
+                              if vTempProps[i] > 0 then
+                                 dU = i - 1
+                                 break
+                              end
+                           end
+                           -- taglio il loop interno
+                           EgtChangeClosedCurveStart( nLoopId, dU + 0.5)
+                           EgtTrimCurveStartAtLen( nLoopId, 5 * GEO.EPS_SMALL)
+                           -- taglio il loop esterno in corrispondenza del loop interno
+                           local _, _, dPar = EgtPointCurveDist( EgtSP( nLoopId), nCrv)
+                           EgtChangeClosedCurveStart( nCrv, dPar)
+                           EgtTrimCurveStartAtLen( nCrv, 5 * GEO.EPS_SMALL)
+                           -- unisco le curve
+                           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
-                  
-                  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
+                  EgtErase( nSurf)
                end
-               
-               EgtErase( nCopy)
             end
             
             nId = EgtGetNext( nId)
@@ -99,7 +110,7 @@ local function CalcCurves( nSliceId, nDestGrp, vtSlicing, dStrandBase)
 end
 
 ------------------------------------------------------------------
-local function CalcSpiralVase( nSliceId, nDestGrp)
+local function GetSolids( nSliceId, nDestGrp)
    
    -- scorro tutti i gruppi di curve
    local vCrvs = EgtGetNameInGroup( nSliceId, CONTOUR_GRP .. '*')
@@ -107,9 +118,14 @@ local function CalcSpiralVase( nSliceId, nDestGrp)
       -- 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
-            EgtCopyGlob( vSolids[i], nDestGrp)
+            if EgtGetName( vSolids[i]) ~= DIR_ARROW then
+               EgtCopyGlob( vSolids[i], nDestGrp)
+            end
          end
       end
    end
@@ -117,7 +133,7 @@ end
 
 ------------------------------------------------------------------
 function RunPrepareExport.Exec()
-   
+
    local nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. '*')
    if not nPartId then 
       EgtOutBox( 'Error : no part', 'Export')
@@ -150,10 +166,11 @@ function RunPrepareExport.Exec()
    -- 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 vtSlicing = EgtGetInfo( nPartId, KEY_SLICE_DIR, 'v') or EgtGetInfo( nPartId, "SlicingDir", 'v')
+   EgtSetInfo( nPnt, "SlicingDir", vtSlicing)
    local bSpiralVase = EgtGetInfo( nPartId, KEY_SPIRAL_VASE, 'b') or false
    EgtSetInfo( nPnt, KEY_SPIRAL_VASE, bSpiralVase)
+   local nSlicingType = EgtGetInfo( nPartId, KEY_SLICING_TYPE, 'i')
    
    -- recupero lo strand dai parametri generale nel caso non fosse definito sulle singole curve
    local dStrandBase = EgtGetInfo( nPartId, KEY_STRAND, 'd') or 0
@@ -183,19 +200,19 @@ function RunPrepareExport.Exec()
    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)
+      -- se multiplanare o spiral vase esporto direttamente i solidi altrimenti esporto le curve che verranno estruse nel visualizzatore
+      if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR or bSpiralVase then
+         GetSolids( vSlices[i], nDestGrp)
       else
-         CalcCurves( vSlices[i], nDestGrp, vtSlicing, dStrandBase)
+         CalcCurves( vSlices[i], nDestGrp, dStrandBase)
       end
    end
-   
+
    return nGrp
 end
 

Version.lua

@@ -1,4 +1,4 @@
--- Version.lua by Egaltech s.r.l. 2024/01/24
+-- Version.lua by Egaltech s.r.l. 2026/05/04
 -- Gestione della versione di 3dPrinting
 
-VERSION = '2.6a1'
+VERSION = '3.1e1'