3dPrinting :

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

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,184 +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_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"
+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_MAX_SLICES_NBR = "MaxSlicesNumber"
-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_WIPE_ON_CRV = "WipeOnCrv"
+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 = {   
+SLICING_TYPE = {
    VERTICAL = 1,
    DEG45_X = 2,
    DEG45_Y = 3,
    HORIZONTAL = 4,
+   MULTIPLANAR = 5,
+   MULTIPLANAR_DEG45 = 6,
+   MULTIPLANAR_HOR = 7,
 }
 
 TYPE = {
@@ -292,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'
@@ -352,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

@@ -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)
@@ -708,51 +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
-         local bAdd2 = dist( ptE1, ptS2) < dStrand + 10 * GEO.EPS_SMALL
-         bAdd = bAdd1 or bAdd2
-         
-         if bAdd1 and bAdd2 then
-            -- da unire in setto chiuso
-            EgtAddCurveCompoLine( vIds[i-1], ptE2, false)
-            EgtAddCurveCompoLine( vIds[i-1], ptS2)
-            EgtAddCurveCompoCurve( vIds[i-1], vIds[i])
-            table.remove( vIds, i)   -- rimuovo il setto dalla tabella
-            
-         elseif bAdd2 then
-            -- unisco il secondo tratto al primo
-            EgtAddCurveCompoLine( vIds[i-1], ptS2)
-            EgtAddCurveCompoCurve( vIds[i-1], vIds[i])
-            table.remove( vIds, i)   -- rimuovo il setto dalla tabella
-            
-         elseif bAdd1 then
-            -- unisco il primo tratto al secondo
-            EgtAddCurveCompoLine( vIds[i], ptS1)
-            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
 
 --------------------------------------------------------------------
@@ -2040,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()
@@ -2372,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
@@ -2915,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)
@@ -3114,26 +3110,38 @@ end
 
 --------------------------------------------------------------------
 local function AdjustRibsMergedExtraShellLink( nLinkId, vExtraShells, nGrp)
-   
-   local frLoc = Frame3d( ORIG(), s_vtSlicing)
-   local nGrpLoc = EgtGroup( nGrp, frLoc)
+
    local vLinks = {}
    
-   -- 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)
-            EgtModifyCurveExtrusion( nId, s_vtSlicing, GDB_ID.ROOT)
-            table.insert( vLinks, nId)
+      
+      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
 
@@ -3362,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')
@@ -4328,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/RunCalcSolids.lua

@@ -15,14 +15,18 @@ local AMD = require( 'AddManData')
 --------------------------------------------------------------------
 local s_dTol = 0.1
 local s_nSimplifiedSection = 0
+local s_dMultiPlanarH = 0
+local s_dColorFactor = 0.9
+local s_nPartId
 
 ---------------------------------------------------------------------
 local function GetLayerParamsForSolidCalc( nPartId)
    local LayerParams = {}
    LayerParams.bSpiralVase = EgtGetInfo( nPartId, KEY_SPIRAL_VASE, 'b') or false
    LayerParams.dLayHeight = EgtGetInfo( nPartId, KEY_SLICE_STEP, 'd')
-   LayerParams.vtSlicing = EgtGetInfo( nPartId, KEY_SLICING_DIR, 'v')
+   LayerParams.vtSlicing = EgtGetInfo( nPartId, KEY_SLICE_DIR, 'v') or EgtGetInfo( nPartId, 'SlicingDir', 'v')
    LayerParams.dStrand = EgtGetInfo( nPartId, KEY_STRAND, 'd')
+   LayerParams.vtCorr = EgtGetInfo( nPartId, KEY_MOVED_PART2, 'v') or V_NULL()
    return LayerParams
 end
 
@@ -39,10 +43,10 @@ local function CalcSectionParams( dStrand, dH)
 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)
+local function CreateStandardSolid( nCrvId, nSolidGrp, dH, dStrand)
+   
+   local dBevelX, dBevelY = CalcSectionParams( dStrand, dH)
+   local nSrfId = EgtSurfTmRectSwept( nSolidGrp, dStrand, dH, dBevelX, dBevelY, nCrvId, GDB_RSCT.BEVEL, s_dTol)
    return nSrfId
 end
 
@@ -105,9 +109,7 @@ local function CreateSpiralVaseCap( nSectId, vtDir, nSolidGrp)
    local nCapSrf = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
    
    -- cancello curve di costruzione
-   for i = 1, #vCrvs do
-      EgtErase( vCrvs[i])
-   end
+   EgtErase( vCrvs)
    EgtErase( nCrvTop)
    EgtErase( nCrvBottom)
    
@@ -115,10 +117,10 @@ local function CreateSpiralVaseCap( nSectId, vtDir, nSolidGrp)
 end
 
 -------------------------------------------------------------------------------
-local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
+local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, vtSlicing, dH, dStrand)
    
    -- gruppo temporaneo per conti 
-   local nGrpTmp = EgtGroup( nSolidGrp, Frame3d( ORIG(), LayerParams.vtSlicing, GDB_RT.GLOB))
+   local nGrpTmp = EgtGroup( nSolidGrp, Frame3d( ORIG(), vtSlicing, GDB_RT.GLOB))
    
    -- accorcio leggermente la curva per evitare problemi di inconsistent orientation nel solido
    local dLen = EgtCurveLength( nCrvId)
@@ -128,27 +130,28 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
    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
+   local dDelta = ( ptE - ptS) * vtSlicing
    -- se non è vero spiral vase, chiamo funzione standard
    if dDelta < GEO.EPS_SMALL then
-      return CreateStandardSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
+      EgtErase( nGrpTmp)
+      return CreateStandardSolid( nCrvId, nSolidGrp, dH, dStrand)
    end
    
    -- appiattisco la curva
    local nCrvCopy = EgtCopyGlob( nCrvId, nGrpTmp)
-   EgtModifyCurveExtrusion( nCrvCopy, LayerParams.vtSlicing, GDB_RT.GLOB)
-   EgtProjectCurveOnPlane( nCrvCopy, ptS, LayerParams.vtSlicing, GDB_RT.GLOB)
+   EgtModifyCurveExtrusion( nCrvCopy, vtSlicing, GDB_RT.GLOB)
+   EgtProjectCurveOnPlane( nCrvCopy, ptS, vtSlicing, GDB_RT.GLOB)
    EgtMergeCurvesInCurveCompo( nCrvCopy)
    EgtChangeClosedCurveStartPoint( nCrvCopy, ptS, GDB_RT.GLOB)
   
    -- calcolo la sezione iniziale
    local vtDir = EgtSV( nCrvCopy, GDB_ID.ROOT)
-   vtDir:rotate( LayerParams.vtSlicing, 90)
-   local nSectId = CreateSection( ptS, vtDir, dStrand, LayerParams.dLayHeight, LayerParams.vtSlicing, nGrpTmp)
+   vtDir:rotate( vtSlicing, 90)
+   local nSectId = CreateSection( ptS, vtDir, dStrand, dH, vtSlicing, nGrpTmp)
    -- creo la sezione finale
    local vtDir2 = EgtEV( nCrvCopy, GDB_ID.ROOT)
-   vtDir2:rotate( LayerParams.vtSlicing, 90)
-   local nSectE = CreateSection( ptE, vtDir2, dStrand, LayerParams.dLayHeight, LayerParams.vtSlicing, nGrpTmp)
+   vtDir2:rotate( vtSlicing, 90)
+   local nSectE = CreateSection( ptE, vtDir2, dStrand, dH, vtSlicing, nGrpTmp)
    
    -- creo il solido aperto (tubo)
    local vCrvs = {}
@@ -161,8 +164,8 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
          EgtErase( nGrpTmp)
          return nil
       end
-      local dMove = ( ptRef - ptS) * LayerParams.vtSlicing
-      EgtMove( vCrvs[i+1], LayerParams.vtSlicing * dMove, GDB_RT.GLOB)
+      local dMove = ( ptRef - ptS) * vtSlicing
+      EgtMove( vCrvs[i+1], vtSlicing * dMove, GDB_RT.GLOB)
       EgtSpiralizeCurveAlongExtrusion( vCrvs[i+1], dDelta)
 
       -- modifico la curva per congiungerla ai caps
@@ -185,32 +188,32 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
          return nil
       end
    end
-
-   local nSrfId = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
-  
+   
    -- creazione del mezzo disco iniziale
-   local nCap1 = CreateSpiralVaseCap( nSectId, - vtS, nSolidGrp)
+   vSurfs[#vCrvs] = CreateSpiralVaseCap( nSectId, - vtS, nSolidGrp)
    -- creazione del mezzo disco finale
-   local nCap2 = CreateSpiralVaseCap( nSectE, vtE, nSolidGrp)
-   EgtInvertSurf( nCap2)
+   vSurfs[#vCrvs+1] = CreateSpiralVaseCap( nSectE, vtE, nSolidGrp)
+   EgtInvertSurf( vSurfs[#vCrvs+1])
 
+   local nSolidId = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
+   
    -- cancello le curve usate per la costruzione
    EgtErase( nGrpTmp)
 
-   return EgtSurfTmByTriangles( nSolidGrp, { nSrfId, nCap1, nCap2})
+   return nSolidId
 end
 
 --------------------------------------------------------------------------------------
-local function CreateSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
+local function CreateSolid( nCrvId, nSolidGrp, LayerParams, dH, dStrand)
    if LayerParams.bSpiralVase then
-      return CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
+      return CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams.vtSlicing, dH, dStrand)
    else
-      return CreateStandardSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
+      return CreateStandardSolid( nCrvId, nSolidGrp, dH, dStrand)
    end
 end
 
 ---------------------------------------------------------------------
-local function CreateDirectionArrow( nCrvId, nSolidGrp, vtSlicing, dStrand, nLayer)
+local function CreateDirectionArrow( nCrvId, nSolidGrp, vtSlicing, dStrand, nSliceNbr)
    
    local ptS = EgtSP( nCrvId, GDB_RT.GLOB)
    local vtS = EgtSV( nCrvId, GDB_RT.GLOB)
@@ -232,7 +235,7 @@ local function CreateDirectionArrow( nCrvId, nSolidGrp, vtSlicing, dStrand, nLay
    local nSrf = EgtSurfFlatRegion( nSolidGrp, { nCompo})
    EgtErase( nCompo)
    EgtSetColor( nSrf, RED())
-   EgtSetInfo( nSrf, KEY_SLICE_NBR, nLayer)
+   EgtSetInfo( nSrf, KEY_SLICE_NBR, nSliceNbr)
    EgtSetStatus( nSrf, GDB_ST.OFF)
    EgtSetMode( nSrf, GDB_MD.HIDDEN)
    EgtSetName( nSrf, DIR_ARROW)
@@ -240,10 +243,10 @@ local function CreateDirectionArrow( nCrvId, nSolidGrp, vtSlicing, dStrand, nLay
 end
 
 ---------------------------------------------------------------------
-local function CreateRecursiveSolid( nCrvId, vSurfs, nSolidGrp, LayerParams, dStrand)
+local function CreateRecursiveSolid( nCrvId, vSurfs, nSolidGrp, LayerParams, dH, dStrand)
 
    -- tento la creazione del solido
-   local nSurf = CreateSolid( nCrvId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
+   local nSurf = CreateSolid( nCrvId, nSolidGrp, LayerParams, dH, dStrand - 50 * GEO.EPS_SMALL)
    if nSurf then
       EgtErase( nCrvId)
       table.insert( vSurfs, nSurf)
@@ -263,16 +266,67 @@ local function CreateRecursiveSolid( nCrvId, vSurfs, nSolidGrp, LayerParams, dSt
          EgtErase( nCrvId)
          return false
       end
-      local bOk = CreateRecursiveSolid( nCrvId, vSurfs, nSolidGrp, LayerParams, dStrand)
-      bOk = bOk and CreateRecursiveSolid( nCrvSplit, vSurfs, nSolidGrp, LayerParams, dStrand)
+      local bOk = CreateRecursiveSolid( nCrvId, vSurfs, nSolidGrp, LayerParams, dH, dStrand)
+      bOk = bOk and CreateRecursiveSolid( nCrvSplit, vSurfs, nSolidGrp, LayerParams, dH, dStrand)
       return bOk
    end
 end
 
 ---------------------------------------------------------------------
-local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
+local function CalcSolidGuides( nCrvId, dStrand, nSolidGrp)
+   
+   -- suddivido la curva in modo opportuno
+   local nCopyId = EgtCopyGlob( nCrvId, nSolidGrp)
+   local nId
+   local nParts = 1
+   local LEN_REF = 100
+   local bZigZagInfill = EgtGetInfo( nCopyId, KEY_ZIG_ZAG_INFILL, 'b') or false
+   if bZigZagInfill then
+      nId, nParts = EgtSplitCurveAtCorners( nCopyId, 80)
+   else
+      local nType = EgtGetInfo( nCrvId, KEY_TYPE, 'i')
+      local dLen = EgtCurveLength( nCrvId)
+      if dLen > LEN_REF and nType ~= TYPE.LINK and nType ~= TYPE.COASTING then
+         nParts = EgtClamp( floor( dLen / LEN_REF), 1, 10)
+      end
+      nId = EgtSplitCurve( nCopyId, nParts)
+   end
+   
+   if not nId then return end
+   
+   -- verifico in modo euristico se la curva torna indietro su se stessa come se fossero due shell collegate ( verifico se è presente un sottotratto di lunghezza 
+   -- circa pari allo strand non in tangenza con i sottotratti vicini). Nel caso la spezzo per evitare problemi nel calcolo di solidi swept
+   local vGuideIds = {}
+   for nInd = 0, nParts - 1 do
+      local nGuideId = nId + nInd
+      table.insert( vGuideIds, nGuideId)
+      if EgtGetType( nGuideId) == GDB_TY.CRV_COMPO then
+         local _, dE = EgtCurveDomain( nGuideId)
+         for dU = 1, dE - 2 do
+            local dLen = EgtCurveCompoLength( nGuideId, dU)
+            if abs( dLen - dStrand) < 500 * GEO.EPS_SMALL then
+               -- verifico gli angoli
+               local vtPrev = EgtUV( nGuideId, dU, -1, GDB_ID.ROOT)
+               local vtCurrS = EgtUV( nGuideId, dU, 1, GDB_ID.ROOT)
+               local vtCurrE = EgtUV( nGuideId, dU + 1, -1, GDB_ID.ROOT)
+               local vtNext = EgtUV( nGuideId, dU + 1, 1, GDB_ID.ROOT)
+               if vtPrev * vtCurrS < GEO.EPS_SMALL and vtCurrE * vtNext < GEO.EPS_SMALL then
+                  local nNewId = EgtSplitCurveAtParam( nGuideId, dU + 0.5)
+                  table.insert( vGuideIds, nNewId)
+                  break
+               end
+            end
+         end
+      end
+   end
+   
+   return vGuideIds
+end
+
+---------------------------------------------------------------------
+local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nSliceNbr, dLayerH)
   
-   local nType = EgtGetInfo( nCrvId, KEY_TYPE, 'i')   
+   local nType = EgtGetInfo( nCrvId, KEY_TYPE, 'i')
    if nType == TYPE.WIPE then return true end 
    -- scelta del colore
    local Color = EgtStdColor( 'GRAY')
@@ -291,52 +345,48 @@ 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') or LayerParams.dStrand
    
-   local nCopyId = EgtCopyGlob( nCrvId, nSolidGrp)
-   local nId = GDB_ID.NULL
-   local nParts = 1
-   local LEN_REF = 100
-   local bZigZagInfill = EgtGetInfo( nCopyId, KEY_ZIG_ZAG_INFILL, 'b') or false
-   if bZigZagInfill then
-      nId, nParts = EgtSplitCurveAtCorners( nCopyId, 80)
-   else
-      local dLen = EgtCurveLength( nCrvId)
-      if dLen > LEN_REF and nType ~= TYPE.LINK and nType ~= TYPE.COASTING then
-         nParts = EgtClamp( floor( dLen / LEN_REF), 1, 10)
-      end
-      nId = EgtSplitCurve( nCopyId, nParts)
+   if s_nSimplifiedSection == 1 and nSliceNbr % 2 == 0 then
+      Color = Color3d( s_dColorFactor * Color:getRed(), s_dColorFactor * Color:getGreen(), s_dColorFactor * Color:getBlue())
    end
    
+   -- parametri della passata
+   local dStrand = EgtGetInfo( nCrvId, KEY_CRV_STRAND, 'd') or LayerParams.dStrand
+   local dH = dLayerH or LayerParams.dLayHeight
+
    -- freccia direzionale
    local sName = EgtGetName( nCrvId)
    if nType ~= TYPE.COASTING and nType ~= TYPE.LINK and sName ~= LEAD_IN_CRV and sName ~= LEAD_OUT_CRV and sName ~= LINK_CRV then
-      CreateDirectionArrow( nCrvId, nSolidGrp, LayerParams.vtSlicing, dStrand, nLayer)
+      CreateDirectionArrow( nCrvId, nSolidGrp, LayerParams.vtSlicing, dStrand, nSliceNbr)
    end
    
-   if nId == GDB_ID.NULL then return false end
+   -- spezzo la curva guida in diversi sottotratti per i quali calcolare i solidi
+   local vGuideIds = CalcSolidGuides( nCrvId, dStrand, nSolidGrp)
+   if not vGuideIds then
+      return false
+   end
+
    local bOk = true
-   for nInd = 0, nParts - 1 do
-      local nGuideId = nId + nInd
-      local nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 5 * GEO.EPS_SMALL)
+   for i = 1, #vGuideIds do
+      local nSrfId = CreateSolid( vGuideIds[i], nSolidGrp, LayerParams, dH, dStrand - 5 * GEO.EPS_SMALL)
       if not nSrfId then
-         EgtOutLog( 'Warning : CreateSolid failed '.. '(layer '..tostring( nLayer)..', curve '..tostring( nCrvId)..')')
+         EgtOutLog( 'Warning : CreateSolid failed '.. '(layer '..tostring( nSliceNbr)..', curve '..tostring( nCrvId)..')')
          -- ritento con strand più piccolo
-         nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)         
+         nSrfId = CreateSolid( vGuideIds[i], nSolidGrp, LayerParams, dH, dStrand - 50 * GEO.EPS_SMALL)
          
          if not nSrfId then
-            EgtOutLog( 'Warning : CreateSolid_1 failed '.. '(layer '..tostring( nLayer)..', curve '..tostring( nCrvId)..')')
+            EgtOutLog( 'Warning : CreateSolid_1 failed '.. '(layer '..tostring( nSliceNbr)..', 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 i < #vGuideIds then
+               local nCopyId = EgtCopy( vGuideIds[i] + 1, vGuideIds[i], GDB_IN.AFTER)
                if nCopyId then
                   local LEN_TRIM = 10
                   local bOk1 = EgtTrimCurveEndAtLen( nCopyId, LEN_TRIM)
-                  local bOk2 = EgtAddCurveCompoCurve( nGuideId, nCopyId)
-                  local bOk3 = EgtTrimCurveStartAtLen( nGuideId + 1, LEN_TRIM)
-                  nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 5 * GEO.EPS_SMALL)
+                  local bOk2 = EgtAddCurveCompoCurve( vGuideIds[i], nCopyId)
+                  local bOk3 = EgtTrimCurveStartAtLen( vGuideIds[i] + 1, LEN_TRIM)
+                  nSrfId = CreateSolid( vGuideIds[i], nSolidGrp, LayerParams, dH, dStrand - 5 * GEO.EPS_SMALL)
                   if not nSrfId then
-                     nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
+                     nSrfId = CreateSolid( vGuideIds[i], nSolidGrp, LayerParams, dH, dStrand - 50 * GEO.EPS_SMALL)
                   end
                end
             end
@@ -346,12 +396,12 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
          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)
+            EgtRelocateGlob( vGuideIds[i], nGrp)
+            EgtApproxCurve( vGuideIds[i], GDB_CA.LINES, 100 * GEO.EPS_SMALL)
+            EgtRelocateGlob( vGuideIds[i], nSolidGrp)
 
             local vSurfs = {}
-            local bOk = CreateRecursiveSolid( nGuideId, vSurfs, nSolidGrp, LayerParams, dStrand)
+            local bOk = CreateRecursiveSolid( vGuideIds[i], vSurfs, nSolidGrp, LayerParams, dH, dStrand)
             if #vSurfs > 0 then
                nSrfId = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
             end
@@ -365,17 +415,381 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
       if nSrfId then
          EgtSetColor( nSrfId, Color)
          EgtSetInfo( nSrfId, KEY_TYPE, nType)
-         EgtSetInfo( nSrfId, KEY_SLICE_NBR, nLayer)
+         EgtSetInfo( nSrfId, KEY_SLICE_NBR, nSliceNbr)
       else
          bOk = false
          EgtOutLog( 'Warning : CreateSolid_Sewing failed')
       end
-      EgtErase( nGuideId)
-   end 
-
+      EgtErase( vGuideIds[i])
+   end
+   
    return bOk
 end
 
+--------------------------------------------------------------------
+------------------------- MULTIPLANAR ------------------------------
+--------------------------------------------------------------------
+local function CreateMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, nLayerId, bFirst)
+   
+   -- creo solidi standard con spessore massimo ammesso ( tranne nel primo layer che viene fatto ad altezza costante)
+   local nSliceNbr = EgtGetInfo( nLayerId, KEY_SLICE_NBR, 'i')
+   local dH = EgtIf( bFirst, LayerParams.dLayHeight, s_dMultiPlanarH)
+   for i = 1, #vIds do
+      CreateSolidFromCurve( vIds[i], nSolidGrpId, LayerParams, nSliceNbr, dH)
+   end
+   
+   -- deformo i solidi per rispettare l'altezza reale della passata
+   if not bFirst then
+      local ptSlicing = EgtGetInfo( nLayerId, KEY_SLICE_POS, 'p') + LayerParams.vtSlicing * LayerParams.dLayHeight + LayerParams.vtCorr
+      local nPrevLayerId = EgtGetPrev( nLayerId)
+      local vtSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_DIR, 'v')
+      local ptSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_POS, 'p') + vtSlicingPrev * LayerParams.dLayHeight + LayerParams.vtCorr
+      local dCosAng = vtSlicingPrev * LayerParams.vtSlicing
+      
+      local vSolids = EgtGetAllInGroup( nSolidGrpId)
+      for i = 1, #vSolids do
+         local nVertexCnt = EgtSurfTmVertexCount( vSolids[i])
+         for j = 0, nVertexCnt - 1 do
+            local ptVertex = EgtSurfTmGetVertex( vSolids[i], j, GDB_RT.GLOB)
+            -- distanza dal piano di slicing corrente e precedente lungo vtSlicing
+            local dDistCurr = abs( ( ptVertex - ptSlicing) * LayerParams.vtSlicing)
+            local dDistPrev = ( ptVertex - ptSlicingPrev) * vtSlicingPrev / dCosAng
+            -- calcolo la nuova posizione sapendo che l'altezza dello strand passa da s_dMultiPlanarH a dNewH
+            local dNewH = dDistCurr + dDistPrev
+            local dDelta = dDistCurr - dDistCurr * dNewH / s_dMultiPlanarH
+            local ptNew = ptVertex + dDelta * LayerParams.vtSlicing
+            EgtSurfTmMoveVertex( vSolids[i], j, ptNew, GDB_RT.GLOB, ( j == nVertexCnt - 1))
+         end
+      end
+   end
+end
+
+---------------------------------------------------------------------
+local function CreatePartialSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, nLayerId, bFirst)
+   
+   -- 1) le prime curve sono solidi multiplanari standard
+   for i = 1, #vIds - 1 do
+      CreateMultiPlanarSolids( { vIds[i]}, nSolidGrpId, LayerParams, nLayerId, bFirst)
+   end
+   
+   -- 2) l'ultima curva è il tratto che si alza fino al layer successivo
+   local nGrpTmp = EgtGroup( nSolidGrpId)
+   local dStrand = EgtGetInfo( vIds[#vIds], KEY_CRV_STRAND, 'd') or LayerParams.dStrand
+   
+   -- a) calcolo il solido
+   -- appiattisco la curva ( proiezione obliqua sul piano corrente lungo vtSlicing del piano successivo)
+   local nNextLayerId = EgtGetNext( nLayerId)
+   local vtSlicingNext = EgtGetInfo( nNextLayerId, KEY_SLICE_DIR, 'v')
+   local ptSlicing = EgtGetInfo( nLayerId, KEY_SLICE_POS, 'p') + LayerParams.dLayHeight * LayerParams.vtSlicing + LayerParams.vtCorr
+   local nProjCrv = EgtCopyGlob( vIds[#vIds], nGrpTmp)
+   local _, dE = EgtCurveDomain( nProjCrv)
+   for dU = 0, dE do
+      local ptCurr = EgtUP( nProjCrv, dU, GDB_ID.ROOT)
+      local dDist = ( ptCurr - ptSlicing) * LayerParams.vtSlicing / ( vtSlicingNext * LayerParams.vtSlicing)
+      EgtModifyCurveCompoJoint( nProjCrv, dU, ptCurr - dDist * vtSlicingNext, GDB_RT.GLOB)
+   end
+  
+   -- calcolo la sezione iniziale
+   local ptS = EgtSP( vIds[#vIds], GDB_ID.ROOT)
+   local ptE = EgtEP( vIds[#vIds], GDB_ID.ROOT)
+   local vtDir = EgtSV( nProjCrv, GDB_ID.ROOT)
+   vtDir:rotate( LayerParams.vtSlicing, 90)
+   local nSectId = CreateSection( ptS, vtDir, dStrand, s_dMultiPlanarH, LayerParams.vtSlicing, nGrpTmp)
+   -- creo la sezione finale
+   local vtDir2 = EgtEV( nProjCrv, GDB_ID.ROOT)
+   vtDir2:rotate( LayerParams.vtSlicing, 90)
+   local nSectE = CreateSection( ptE, vtDir2, dStrand, s_dMultiPlanarH, LayerParams.vtSlicing, nGrpTmp)
+   
+   -- creo le guide per il solido aperto ( tubo)
+   local dMaxDist = ( EgtEP( vIds[#vIds], GDB_ID.ROOT) - ptSlicing) * LayerParams.vtSlicing / ( vtSlicingNext * LayerParams.vtSlicing)
+   local vCrvs = {}
+   local _, dParE = EgtCurveDomain( nSectId)
+   for i = 0, dParE do
+      local ptRef = EgtUP( nSectId, i, GDB_ID.ROOT)
+      local dOffs = ( ptS - ptRef) * vtDir
+      vCrvs[i+1] = EgtOffsetCurveAdv( nProjCrv, dOffs)
+      if not vCrvs[i+1] or vCrvs[i+1] == GDB_ID.NULL then
+         EgtErase( nGrpTmp)
+         return false
+      end
+
+      -- proiezione obliqua "graduale"
+      EgtApproxCurve( vCrvs[i+1], GDB_CA.SPECIAL_LINES, 0.01)
+      local _, dE = EgtCurveDomain( vCrvs[i+1])
+      local dLen = EgtCurveLength( vCrvs[i+1])
+      local vDelta = {}
+      for dU = 0, dE do
+         local dCurrLen = EgtCurveLengthAtParam( vCrvs[i+1], dU) 
+         vDelta[dU] = dMaxDist * dCurrLen / dLen
+      end
+      for dU = 0, dE do
+         local ptCurr = EgtUP( vCrvs[i+1], dU, GDB_ID.ROOT)
+         EgtModifyCurveCompoJoint( vCrvs[i+1], dU, ptCurr + vDelta[dU] * vtSlicingNext, GDB_RT.GLOB)
+      end
+
+      local dMove = ( ptRef - ptS) * LayerParams.vtSlicing
+      EgtMove( vCrvs[i+1], LayerParams.vtSlicing * dMove, GDB_RT.GLOB)
+   end
+   -- creazione delle superfici del tubo
+   local vSurfs = {}
+   for i = 1, #vCrvs - 1 do
+      vSurfs[i] = EgtSurfTmRuled( nGrpTmp, vCrvs[i], vCrvs[i+1], GDB_RUL.MINDIST, s_dTol)
+      if not vSurfs[i] or vSurfs[i] == GDB_ID.NULL then
+         EgtErase( nGrpTmp)
+         return false
+      end
+   end
+   -- creazione del mezzo disco iniziale e finale
+   vSurfs[#vCrvs] = CreateSpiralVaseCap( nSectId, - EgtSV( vIds[#vIds], GDB_ID.ROOT), nSolidGrpId)
+   vSurfs[#vCrvs + 1] = CreateSpiralVaseCap( nSectE, EgtEV( vIds[#vIds], GDB_ID.ROOT), nSolidGrpId)
+   EgtInvertSurf( vSurfs[#vSurfs])
+   local nSolidId = EgtSurfTmByTriangles( nSolidGrpId, vSurfs)
+
+   -- b) deformo il solido per limitarlo al piano di slicing precedente
+   local ptSlicingPrev
+   local vtSlicingPrev
+   local nSliceNbr = EgtGetInfo( nLayerId, KEY_SLICE_NBR, 'i')
+   if nSliceNbr == 1 then
+      vtSlicingPrev = LayerParams.vtSlicing
+      ptSlicingPrev = EgtGetInfo( nLayerId, KEY_SLICE_POS, 'p') + LayerParams.vtCorr
+   else
+      local nPrevLayId = EgtGetPrev( nLayerId)
+      vtSlicingPrev = EgtGetInfo( nPrevLayId, KEY_SLICE_DIR, 'v')
+      ptSlicingPrev = EgtGetInfo( nPrevLayId, KEY_SLICE_POS, 'p') + vtSlicingPrev * LayerParams.dLayHeight + LayerParams.vtCorr
+   end
+   local dCosAng = vtSlicingPrev * LayerParams.vtSlicing
+   
+   -- estendo la curva proiettata per gestire correttamente la deformazione dei caps
+   local nProjExtCrv = EgtCopyGlob( nProjCrv, nGrpTmp)
+   EgtExtendCurveStartByLen( nProjExtCrv, dStrand)
+   EgtExtendCurveEndByLen( nProjExtCrv, dStrand)
+   local dLen = EgtCurveLength( nProjCrv)
+
+   local nVertexCnt = EgtSurfTmVertexCount( nSolidId)
+   for j = 0, nVertexCnt - 1 do
+      
+      local ptVertex = EgtSurfTmGetVertex( nSolidId, j, GDB_RT.GLOB)
+
+      -- calcolo la distanza dal piano precedente lungo vtSlicing
+      local dDistPrevPlane = ( ptVertex - ptSlicingPrev) * vtSlicingPrev / dCosAng
+      -- calcolo la distanza approssimata dalla curva del toolpath
+      local _, ptMinDist, dMinPar = EgtPointCurveDist( ptVertex, nProjExtCrv, GDB_ID.ROOT)
+      local dCurrLen = EgtCurveLengthAtParam( nProjExtCrv, dMinPar) - dStrand
+      local ptRef = ptMinDist + dMaxDist * dCurrLen / dLen * vtSlicingNext
+      local dDistCrv = ( ptRef - ptVertex) * LayerParams.vtSlicing
+
+      -- calcolo la nuova posizione sapendo che l'altezza dello strand passa da s_dMultiPlanarH a dNewH
+      local dNewH = dDistCrv + dDistPrevPlane
+      local dDelta = dDistCrv - dDistCrv * dNewH / s_dMultiPlanarH
+      local ptNew = ptVertex + dDelta * LayerParams.vtSlicing
+      EgtSurfTmMoveVertex( nSolidId, j, ptNew, GDB_RT.GLOB, ( j == nVertexCnt - 1))
+   end
+   
+   local Color = EgtStdColor( 'TEAL')
+   if s_nSimplifiedSection == 1 and nSliceNbr % 2 == 0 then
+      Color = Color3d( s_dColorFactor * Color:getRed(), s_dColorFactor * Color:getGreen(), s_dColorFactor * Color:getBlue())
+   end
+   EgtSetColor( nSolidId, Color)
+   
+   EgtErase( nGrpTmp)
+end
+
+---------------------------------------------------------------------
+local function CreateFullSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, nLayerId)
+   
+   local nSliceNbr = EgtGetInfo( nLayerId, KEY_SLICE_NBR, 'i')
+   local ptSlicing = EgtGetInfo( nLayerId, KEY_SLICE_POS, 'p') + LayerParams.dLayHeight * LayerParams.vtSlicing + LayerParams.vtCorr
+  
+   -- recupero il piano precedente e il suo toolpath
+   local nPrevLayerId = EgtGetPrev( nLayerId)
+   local vtSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_DIR, 'v')
+   local ptSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_POS, 'p') + LayerParams.dLayHeight * vtSlicingPrev + LayerParams.vtCorr
+   local dCosAng = vtSlicingPrev * LayerParams.vtSlicing
+   local nPrevCrvGrp = EgtGetFirstNameInGroup( nPrevLayerId, CONTOUR_GRP .. '*')
+   local nPrevTPathGrp = EgtGetFirstNameInGroup( nPrevCrvGrp, TOOLPATH_GRP)
+   local nPrevTPath = EgtGetFirstNameInGroup( nPrevTPathGrp, SHELL_CRV .. '*')
+   
+   -- gruppo temporaneo per conti
+   local nGrpTmp = EgtGroup( nSolidGrpId)
+      
+   for i = 1, #vIds do
+      local dStrand = EgtGetInfo( vIds[i], KEY_CRV_STRAND, 'd') or LayerParams.dStrand
+      
+      -- creo la freccia direzionale
+      CreateDirectionArrow( vIds[i], nSolidGrpId, LayerParams.vtSlicing, dStrand, nSliceNbr)
+      
+      -- appiattisco la curva ( proiezione sul piano di slicing)
+      local nProjCrv = EgtCopyGlob( vIds[i], nGrpTmp)
+      EgtProjectCurveOnPlane( nProjCrv, ptSlicing, LayerParams.vtSlicing, GDB_RT.GLOB)
+      local dLen = EgtCurveLength( nProjCrv)
+     
+      -- suddivido la curva piana
+      local vGuideIds = CalcSolidGuides( nProjCrv, dStrand, nGrpTmp)
+      local dCumLen = 0
+      for k = 1, #vGuideIds do
+         
+         -- calcolo il solido sulla porzione della curva di proiezione
+         local nSolidId = CreateStandardSolid( vGuideIds[k], nSolidGrpId, s_dMultiPlanarH, dStrand)
+         
+         -- estendo la guida per gestire al meglio i caps
+         local nCrvRef = EgtCopyGlob( vGuideIds[k], nGrpTmp)
+         EgtExtendCurveStartByLen( nCrvRef, dStrand)
+         EgtExtendCurveEndByLen( nCrvRef, dStrand)
+         
+         -- recupero la curva precedente. Se estremi la limito per gestire al meglio la corrispondenza tra i toolpath
+         local nPrevTPathRef = nPrevTPath
+         if k == 1 then
+            nPrevTPathRef = EgtCopyGlob( nPrevTPath, nGrpTmp)
+            EgtTrimCurveEndAtLen( nPrevTPathRef, 0.5 * EgtCurveLength( nPrevTPathRef))
+         elseif k == #vGuideIds then
+            nPrevTPathRef = EgtCopyGlob( nPrevTPath, nGrpTmp)
+            EgtTrimCurveStartAtLen( nPrevTPathRef, 0.5 * EgtCurveLength( nPrevTPathRef))
+         end
+
+         -- deformo i solidi :
+         -- 1) traslazione dei vertici per portarli alla quota corretta del toolpath corrente
+         -- 2) deformazione della sezione in base alla distanza dal toolpath precedente
+         local nVertexCnt = EgtSurfTmVertexCount( nSolidId)
+         for j = 0, nVertexCnt - 1 do
+            local ptVertex = EgtSurfTmGetVertex( nSolidId, j, GDB_RT.GLOB)
+               
+            -- ricavo il punto di riferimento sulla proiezione del toolpath
+            local _, ptMinDist, dParMinDist = EgtPointCurveDist( ptVertex, nCrvRef, GDB_ID.ROOT)
+            local dCurrLen = EgtCurveLengthAtParam( nCrvRef, dParMinDist) - dStrand + dCumLen
+
+            -- 1) proietto il punto sul piano corrente e calcolo la traslazione da applicare in base alla distanza dal piano precedente ( analogamente a CalcToolPath)
+            local dDistCrv = ( ptSlicing - ptVertex) * LayerParams.vtSlicing
+            local ptProj = ptVertex + dDistCrv * LayerParams.vtSlicing
+            local dDistPlanePrev = ( ptProj - ptSlicingPrev) * vtSlicingPrev / dCosAng  
+            local dDeltaPos
+            if nSliceNbr == 2 and dCurrLen < 0.5 * dLen then
+               dDeltaPos = 0.5 * dDistPlanePrev
+            else
+               dDeltaPos = dDistPlanePrev * ( dLen - dCurrLen) / dLen
+            end
+            
+            -- 2) per calcolare la vera altezza del solido calcolo la distanza dal toolpath precedente guardando il punto di riferimento sul percorso corrente
+            local dNewH 
+            if nSliceNbr == 2 then
+               -- il primo layer è ad altezza costante quindi è semplice distanza dal piano precedente lungo vtSlicing
+               dNewH = ( ptProj - ptSlicingPrev) * vtSlicingPrev / dCosAng - dDeltaPos
+            else
+               local _, ptMinDistPrev = EgtPointCurveDist( ptMinDist, nPrevTPathRef, GDB_ID.ROOT)
+               local dDistPlanePrev2 = ( ptMinDist - ptSlicingPrev) * vtSlicingPrev / dCosAng
+               local dDeltaPos2
+               if nSliceNbr == 2 and dCurrLen < 0.5 * dLen then
+                  dDeltaPos2 = 0.5 * dDistPlanePrev2
+               else
+                  dDeltaPos2 = dDistPlanePrev2 * ( dLen - dCurrLen) / dLen
+               end
+               dNewH = ( ptMinDist - ptMinDistPrev) * LayerParams.vtSlicing - dDeltaPos2
+               -- aggiungo un piccolo extra per tener conto che la distanza è stata calcolata sulle curve centrali del solido
+               local dExtra = ( LayerParams.vtSlicing ^ vtSlicingPrev):len() / dCosAng * dStrand * 0.5
+               dNewH = dNewH + dExtra
+            end
+
+            local dDelta = dDistCrv - dDistCrv * dNewH / s_dMultiPlanarH
+            local ptNew = ptVertex + ( dDelta - dDeltaPos) * LayerParams.vtSlicing
+            EgtSurfTmMoveVertex( nSolidId, j, ptNew, GDB_RT.GLOB, ( j == nVertexCnt - 1))
+         end
+      
+         -- imposto colore
+         local Color = EgtStdColor( 'TEAL')
+         if s_nSimplifiedSection == 1 and nSliceNbr % 2 == 0 then
+            Color = Color3d( s_dColorFactor * Color:getRed(), s_dColorFactor * Color:getGreen(), s_dColorFactor * Color:getBlue())
+         end
+         EgtSetColor( nSolidId, Color)
+         
+         dCumLen = dCumLen + EgtCurveLength( vGuideIds[i])
+      end
+   end
+    
+   EgtErase( nGrpTmp)
+end
+
+---------------------------------------------------------------------
+local function CreateFullSpiralVaseMultiPlanarSolidsLastLayer( vIds, nSolidGrpId, LayerParams, nLayerId)
+   -- le curve sono piane quindi i solidi possono essere calcolati nel modo classico
+   -- i solidi della shell sono deformati in base alla distanza dalla curva precedente
+   -- eventuali solidi di lead out e coasting sono calcolati con un valore di altezza costante pari all'ultimo valore di altezza dei solidi della shell
+   
+   local nSliceNbr = EgtGetInfo( nLayerId, KEY_SLICE_NBR, 'i')
+   
+   local nPrevLayerId = EgtGetPrev( EgtGetPrev( nLayerId))
+   local vtSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_DIR, 'v')
+   local ptSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_POS, 'p') + vtSlicingPrev * LayerParams.dLayHeight + LayerParams.vtCorr
+   local ptSlicing = EgtGetInfo( nLayerId, KEY_SLICE_POS, 'p') + LayerParams.vtSlicing * LayerParams.dLayHeight + LayerParams.vtCorr
+   local dCosAng = vtSlicingPrev * LayerParams.vtSlicing
+   
+   -- 1) curva shell
+   local nGrpTmp = EgtGroup( nSolidGrpId)
+   local dStrand = EgtGetInfo( vIds[1], KEY_CRV_STRAND, 'd') or LayerParams.dStrand
+   local vShellGuides = CalcSolidGuides( vIds[1], dStrand, nGrpTmp)
+   
+   local dLen = EgtCurveLength( vIds[1])
+   -- se non c'è lead out alla lunghezza totale della shell devo aggiungere anche quella del coasting
+   if EgtGetInfo( s_nPartId, KEY_LEAD_OUT_TYPE, 'i') == LEAD_TYPE.NONE then
+      dLen = dLen + EgtGetInfo( s_nPartId, KEY_COASTING_LEN, 'd')
+   end
+   local dCumLen = 0
+   
+   -- creo la freccia direzionale
+   CreateDirectionArrow( vIds[1], nSolidGrpId, LayerParams.vtSlicing, dStrand, nSliceNbr)
+      
+   for i = 1, #vShellGuides do
+     
+      -- calcolo il solido associato
+      local nSolidId = CreateStandardSolid( vShellGuides[i], nSolidGrpId, s_dMultiPlanarH, dStrand)
+      
+      -- estensione della guida per gestire meglio i caps
+      local nCrvRef = EgtCopyGlob( vShellGuides[i], nGrpTmp)
+      EgtExtendCurveStartByLen( nCrvRef, dStrand)
+      EgtExtendCurveEndByLen( nCrvRef, dStrand)
+      
+      -- deformo in base alla distanza dalla curva precedente
+      local nVertexCnt = EgtSurfTmVertexCount( nSolidId)
+      for j = 0, nVertexCnt - 1 do
+         local ptVertex = EgtSurfTmGetVertex( nSolidId, j, GDB_RT.GLOB)
+         
+         -- ricavo il punto di riferimento sulla guida
+         local _, _, dParMinDist = EgtPointCurveDist( ptVertex, nCrvRef, GDB_ID.ROOT)
+         local dCurrLen = EgtCurveLengthAtParam( nCrvRef, dParMinDist) - dStrand + dCumLen
+
+         -- calcolo la nuova altezza del solido in base alla distanza dalla curva precedente
+         local dDistCurr = ( ptSlicing - ptVertex) * LayerParams.vtSlicing
+         local ptProj = ptVertex + dDistCurr * LayerParams.vtSlicing
+         local dDistPrev = ( ptProj - ptSlicingPrev) * vtSlicingPrev / dCosAng
+         local dNewH = dDistPrev * ( dLen - dCurrLen) / dLen
+         dNewH = max( dNewH, 500 * GEO.EPS_SMALL)
+         
+         -- calcolo la nuova posizione sapendo che l'altezza dello strand passa da s_dMultiPlanarH a dNewH
+         local dDelta = dDistCurr - dDistCurr * dNewH / s_dMultiPlanarH
+         local ptNew = ptVertex + dDelta * LayerParams.vtSlicing
+         EgtSurfTmMoveVertex( nSolidId, j, ptNew, GDB_RT.GLOB, ( j == nVertexCnt - 1))
+      end
+
+      dCumLen = dCumLen + EgtCurveLength( vShellGuides[i])
+      
+      -- imposto colore
+      local Color = EgtStdColor( 'TEAL')
+      if s_nSimplifiedSection == 1 and nSliceNbr % 2 == 0 then
+         Color = Color3d( s_dColorFactor * Color:getRed(), s_dColorFactor * Color:getGreen(), s_dColorFactor * Color:getBlue())
+      end
+      EgtSetColor( nSolidId, Color)
+   end
+   
+   -- 2) curve di uscita
+   -- calcolo altezza finale del solido shell
+   local ptE = EgtEP( vIds[1], GDB_ID.ROOT)
+   local dH = ( ( ptE - ptSlicingPrev) * vtSlicingPrev / dCosAng) * ( dLen - EgtCurveLength( vIds[1])) / dLen
+   dH = max( dH, 500 * GEO.EPS_SMALL)
+   for i = 2, #vIds do
+      CreateSolidFromCurve( vIds[i], nSolidGrpId, LayerParams, nSliceNbr, dH)
+   end
+   
+   EgtErase( nGrpTmp)
+end
+
 ---------------------------------------------------------------------
 function RunCalcSolids.Exec()
 
@@ -390,6 +804,7 @@ function RunCalcSolids.Exec()
    local nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) or EgtGetFirstNameInGroup( GDB_ID.ROOT, PART)
    while nPartId do
 
+      s_nPartId = nPartId
       if EgtGetInfo( nPartId, KEY_PART_ON_TABLE, 'b') then
          -- verifico se necessario calcolare il solido
          local bCalcSolid = EgtGetInfo( nPartId, KEY_CALC_SOLIDS, 'b') or false
@@ -409,15 +824,25 @@ function RunCalcSolids.Exec()
             end
 
             EgtSetInfo( nPartId, KEY_HAS_SOLIDS, 1)
+            local nSlicingType = EgtGetInfo( nPartId, KEY_SLICING_TYPE, 'i')
 
             -- recupero i parametri necessari al calcolo dei solidi 
             local LayerParams = GetLayerParamsForSolidCalc( nPartId)
+            
+            -- se slicing multiplanare considero come altezza standard quella massima ammessa
+            if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
+               local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
+               local dMaxFactor = EgtGetNumberFromIni( '3dPrinting', KEY_MAX_STRANDH_FACTOR, 2, sMachIni)
+               s_dMultiPlanarH = min( dMaxFactor, 5) * LayerParams.dLayHeight
+            end
 
+            local bFirst = true
             for nIdx = 1, #vLayIds do
+               
                -- flag di interruzione perchè trovati solidi già ok
                local bSolidsOk = false
-               -- indice layer (per log)
-               local nLayer = EgtGetInfo( vLayIds[ nIdx], KEY_SLICE_NBR, 'i')
+               -- indice layer ( per log)
+               local nSliceNbr = EgtGetInfo( vLayIds[ nIdx], KEY_SLICE_NBR, 'i')
                -- scorro tutti i gruppi di contorni
                local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*") or GDB_ID.NULL
                while nCrvGrpId ~= GDB_ID.NULL do
@@ -435,41 +860,88 @@ function RunCalcSolids.Exec()
                      nSolidGrpId = EgtGroup( nCrvGrpId)
                      EgtSetName( nSolidGrpId, SOLID_GRP)
                      EgtSetLevel( nSolidGrpId, GDB_LV.TEMP)
-                     -- scorro le curve del percorso utensile per creare i solidi
+                     
                      local vIds = EgtGetAllInGroup( nTPathGrpId)
                      
-                     if LayerParams.bSpiralVase and #vIds > 2 and EgtGetName( vIds[#vIds]) ~= WIPE_CRV then
-                         -- nel caso a spirale gestione speciale per unire i tratti dei primi layers che sono stati spezzati per feed variabile
-                        local bHasDelta = EgtExistsInfo( vIds[#vIds], KEY_FEED_COEFF)
-                        if bHasDelta then
-                           -- prima curva è a quota costante
-                           CreateSolidFromCurve( vIds[1], nSolidGrpId, LayerParams, nLayer)
-                           -- le rimanenti curve possono essere unite
-                           local vNewIds = EgtTableFill( vIds[2], #vIds-1)
-                           local nNewCrv = EgtCurveCompo( nSolidGrpId, vNewIds, false)
-                           local dStrand = EgtGetInfo( vIds[2], 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)
+                     if #vIds > 0 then
+                        -- slicing multiplanare
+                        if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
+                           LayerParams.vtSlicing = EgtGetInfo( vLayIds[nIdx], KEY_SLICE_DIR, 'v')
+                           
+                           if LayerParams.bSpiralVase then
+                              local dTransitionLen = EgtGetInfo( nPartId, KEY_SPIRAL_VASE_LEN, 'd') or 0
+                              -- a) spiral vase completo ( con transizione in altezza su tutto il layer)
+                              if dTransitionLen < GEO.EPS_SMALL then
+                                 if bFirst then
+                                    -- il primo layer va gestito come uno spiral vase con transizione parziale ( curva a quota costante e ultimo tratto che si alza)
+                                    CreatePartialSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx], bFirst)
+                                 elseif nIdx == #vLayIds then
+                                    -- gestione speciale per lead out e coasting
+                                    CreateFullSpiralVaseMultiPlanarSolidsLastLayer( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx])
+                                 else
+                                    CreateFullSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx])
+                                 end
+                                 
+                              -- b) spiral vase con transizione parziale
+                              else
+                                 if nIdx == #vLayIds then
+                                    -- ultimo layer è un multiplanare standard perchè non ha tratto finale che si alza
+                                    CreateMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx], false)
+                                 else
+                                    CreatePartialSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx], bFirst)
+                                 end
+                              end
+                           -- c) multiplanare standard
+                           else
+                              CreateMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx], bFirst)
+                           end
+                           
+                        -- slicing standard spiral vase
+                        elseif LayerParams.bSpiralVase then
+                           -- i tratti di ingresso, uscita e quelli a quota costante vanno gestiti singolarmente, quelli a quota variabile vanno concatenati
+                           local vChainedIds = {}
+                           local vTmpIds = {}
+                           for i = 1, #vIds do
+                              local sName = EgtGetName( vIds[i])
+                              local dDelta = ( EgtEP( vIds[i], GDB_ID.ROOT) - EgtSP( vIds[i], GDB_ID.ROOT)) * LayerParams.vtSlicing
+                              if abs( dDelta) < GEO.EPS_SMALL or sName == LEAD_IN_CRV or sName == LEAD_OUT_CRV or sName == COASTING_CRV or sName == WIPE_CRV then
+                                 -- inserisco il gruppo di tratti da concatenare e lo resetto
+                                 if #vTmpIds > 0 then 
+                                    table.insert( vChainedIds, vTmpIds)
+                                    vTmpIds = {}
+                                 end
+                                 -- inserisco la curva singola corrente
+                                 table.insert( vChainedIds, { vIds[i]})
+                              else
+                                 table.insert( vTmpIds, vIds[i])
+                              end
+                           end
+                           -- inserisco ultimo gruppo
+                           if #vTmpIds > 0 then
+                              table.insert( vChainedIds, vTmpIds)
+                           end
+                           
+                           for i = 1, #vChainedIds do
+                              if #vChainedIds[i] == 1 then
+                                 CreateSolidFromCurve( vChainedIds[i][1], nSolidGrpId, LayerParams, nSliceNbr)
+                              else
+                                 local nNewCrv = EgtCurveCompo( nSolidGrpId, vChainedIds[i], false)
+                                 local dStrand = EgtGetInfo( vChainedIds[i][1], KEY_CRV_STRAND, 'd') or LayerParams.dStrand
+                                 EgtSetInfo( nNewCrv, KEY_CRV_STRAND, dStrand)
+                                 EgtSetInfo( nNewCrv, KEY_TYPE, TYPE.OUTER_SHELL)
+                                 CreateSolidFromCurve( nNewCrv, nSolidGrpId, LayerParams, nSliceNbr)
+                                 EgtErase( nNewCrv)
+                              end
+                           end
+                           
+                        -- slicing standard
                         else
-                           local vNewIds = EgtTableFill( vIds[1], #vIds-1)
-                           local nNewCrv = EgtCurveCompo( nSolidGrpId, vNewIds, false)
-                           local dStrand = EgtGetInfo( vIds[2], 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)
-                           CreateSolidFromCurve( vIds[#vIds], nSolidGrpId, LayerParams, nLayer)
-                        end
-                        
-                     else
-                        -- caso standard
-                        for i = 1, #vIds do
-                           CreateSolidFromCurve( vIds[i], nSolidGrpId, LayerParams, nLayer)
+                           for i = 1, #vIds do
+                              CreateSolidFromCurve( vIds[i], nSolidGrpId, LayerParams, nSliceNbr)
+                           end
                         end
+                        bFirst = false
                      end
-                     
                   else
                      bSolidsOk = true
                      break

LuaLibs/RunGcodeGenerate.lua

@@ -33,6 +33,7 @@ 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.."*") 
@@ -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

@@ -189,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
@@ -205,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)

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
@@ -31,30 +31,40 @@ local function CalcCurves( nSliceId, nDestGrp, vtSlicing, 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)
+               local nSurf = EgtSurfFrFatCurve( nDestGrp, nCopy, 0.5 * dStrand + 0.01, 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)
+                           
+                           -- 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)
@@ -100,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 .. '*')
@@ -108,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
@@ -151,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
@@ -184,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/05/06
+-- Version.lua by Egaltech s.r.l. 2026/05/04
 -- Gestione della versione di 3dPrinting
 
-VERSION = '2.7i1'
+VERSION = '3.1e1'