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,189 +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"
+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_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_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_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_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 = {
@@ -297,21 +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"
-SPINE_CURVE = "Spine"
-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'
@@ -358,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

@@ -702,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
 
 --------------------------------------------------------------------
@@ -2369,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
@@ -2912,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)
@@ -3371,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')
@@ -4344,7 +4343,7 @@ function CalcPaths.Exec( nPartId)
        
       s_nCurrIdx = nIdx
 
-      if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+      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
 

LuaLibs/CalcSlices.lua

@@ -56,7 +56,7 @@ local function ComputeSlicingData( vIds, vtSlicing, dSliceStep, dMaxH, nMaxSlice
 end
 
 ---------------------------------------------------------------------
-local function ComputeMultiplanarSlicingData( dSliceStep, nMaxSlicesNbr)
+local function ComputeMultiplanarSlicingData( dSliceStep, nMaxSlicesNbr, nSlicingType)
    -- le direzioni e i valori di slicing sono le normali e i punti che definiscono i piani di slicing e vengono calcolati sulla curva "Spine"
    
    -- recupero la curva guida ( è la prima nel gruppo aux con info NameEntity = Spine oppure quella con nome Spine)
@@ -76,24 +76,29 @@ local function ComputeMultiplanarSlicingData( dSliceStep, nMaxSlicesNbr)
       EgtOutBox( "No spine for multiplanar slicing", 'Error', 'ERROR')
       return nil
    end
-   
-   -- verifico che la spina parta nell'origine con direzione Z_AX
-   local ptS = EgtSP( nSpineId, GDB_ID.ROOT)
-   local vtS = EgtSV( nSpineId, GDB_ID.ROOT)
-   if abs( ptS:getZ()) > GEO.EPS_SMALL then
-      EgtOutLog( 'Error : spine does not start on table')
-      EgtOutBox( "Spine not valid for multiplanar slicing", 'Error', 'ERROR')
-      return nil
-   elseif not AreSameVectorApprox( vtS, Z_AX()) then
-      EgtOutLog( 'Error : spine start direction is not vertical')
-      EgtOutBox( "Spine not valid for multiplanar slicing", 'Error', 'ERROR')
-      return nil
+
+   if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+      -- verifico che la spina parta nell'origine con direzione Z_AX
+      local ptS = EgtSP( nSpineId, GDB_ID.ROOT)
+      local vtS = EgtSV( nSpineId, GDB_ID.ROOT)
+      if abs( ptS:getZ()) > GEO.EPS_SMALL then
+         EgtOutLog( 'Error : spine does not start on table')
+         EgtOutBox( "Spine not valid for multiplanar slicing", 'Error', 'ERROR')
+         return nil
+      elseif not AreSameVectorApprox( vtS, Z_AX()) then
+         EgtOutLog( 'Error : spine start direction is not vertical')
+         EgtOutBox( "Spine not valid for multiplanar slicing", 'Error', 'ERROR')
+         return nil
+      end
    end
    
    local vSlicingDir = {}
    local vSlicingPnt = {}
+   if nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 then
+      dSliceStep = dSliceStep / ( sqrt( 2) / 2)
+   end
+   
    -- ciclo sulla curva
-   local nCnt = 0
    local dCrvLen = EgtCurveLength( nSpineId)
    for i = 0, nMaxSlicesNbr - 1 do
       local dCurrLen = i * dSliceStep
@@ -101,12 +106,18 @@ local function ComputeMultiplanarSlicingData( dSliceStep, nMaxSlicesNbr)
          break
       end
       local dU = EgtCurveParamAtLength( nSpineId, dCurrLen)
-      vSlicingDir[i+1] = EgtUV( nSpineId, dU, -1, GDB_ID.ROOT)
+      local vtTang = EgtUV( nSpineId, dU, -1, GDB_ID.ROOT)
+      if nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 then
+         local vtOrth = VectorFromRotated( vtTang, Z_AX(), -90)
+         vtTang:rotate( vtOrth, 45)
+      end
+      vSlicingDir[i+1] = vtTang
       vSlicingPnt[i+1] = EgtUP( nSpineId, dU, GDB_ID.ROOT)
    end
    
    return vSlicingPnt, vSlicingDir
 end
+
 --------------------------------------------------------------------
 local function ComputeMaxH( vIds, vtSlicing, dSliceStep)
    
@@ -246,110 +257,7 @@ local function GetAuxSolidsParams( nId)
 end
 
 --------------------------------------------------------------------
-local function SliceStm( vIds, nLayId, vtSlicing, ptSlicing, nType, sName, sNameGrp, tabParams)
-   
-   if not vIds or #vIds == 0 then return end
-   
-   local nLayCnt = EgtGetInfo( nLayId, KEY_SLICE_NBR, 'i')
-   -- recupero il gruppo dove salvare lo slicing degli oggetti
-   local nGrp = EgtGetFirstNameInGroup( nLayId, sNameGrp)
-   if not nGrp then
-      -- se gruppo non esiste lo creo
-      nGrp = EgtGroup( nLayId)
-      EgtSetName( nGrp, sNameGrp)
-      EgtSetStatus( nGrp, GDB_ST.OFF)
-   end
-
-   -- recupero quota per slicing
-   local dDeltaZ = EgtGetInfo( nLayId, KEY_SLICE_DELTAZ, 'd')
-   local ptOn = ptSlicing + dDeltaZ * vtSlicing
-
-   for i = 1, #vIds do
-      -- verifico che oggetto sia trimesh
-      local nTypeObj = EgtGetType( vIds[i])
-      if nTypeObj == GDB_TY.SRF_MESH then
-         -- slicing oggetto
-         local nNewId, nPntCnt, nCrvCnt, nSrfCnt = EgtPlaneSurfTmInters( ptOn, vtSlicing, vIds[i], nGrp, GDB_RT.GLOB, TOLER)
-   
-         -- verifico se necessario ricalcolo
-         local dCorr = 0
-         local bOpen = false
-         if nType ~= TYPE.RIB and nType ~= TYPE.INFILL and nNewId then
-            for nId = nNewId + nPntCnt, nNewId + nPntCnt + nCrvCnt - 1 do
-               if not EgtCurveIsClosed( nId) then
-                  bOpen = true
-                  break
-               end
-            end
-         end
-         -- eventuale ricalcolo ( se superfici o curve aperte)
-         if nSrfCnt > 0 or bOpen then
-            EgtOutLog( 'Warning : recalc at layer '.. EgtNumToString( nLayCnt) .. ' (object)')
-            -- elimino vecchio risultato
-            for j = nNewId, nNewId + nPntCnt + nCrvCnt + nSrfCnt - 1 do
-               EgtErase( j)
-            end
-            dCorr = 0.01
-            nNewId, nPntCnt, nCrvCnt, nSrfCnt = EgtPlaneSurfTmInters( ptOn + dCorr * vtSlicing, vtSlicing, vIds[i], nGrp, GDB_RT.GLOB, TOLER)
-         end
-            
-         if nNewId then
-
-            -- rimuovo punti
-            for nId = nNewId, nNewId + nPntCnt -1 do
-               EgtErase( nId)
-            end
-            
-            -- concateno le curve
-            local vChain = {}
-            for nId = nNewId + nPntCnt, nNewId + nPntCnt + nCrvCnt - 1 do
-               table.insert( vChain, nId)
-            end
-            local nChainId, nCnt = EgtCurveCompoByChain( nGrp, vChain, ORIG(), true, GDB_RT.LOC, TOLER)
-            if not nChainId then
-               -- se fallisce riprendo le curve originali
-               nChainId = nNewId + nPntCnt
-               nCnt = nCrvCnt
-            end
-            -- rinomino le curve, correggo di DeltaZ e assegno parametri
-            for nId = nChainId, nChainId + nCnt - 1 do
-               EgtSetName( nId, sName .. EgtNumToString( i))
-               EgtMove( nId, - ( dDeltaZ + dCorr) * vtSlicing)
-               EgtSetInfo( nId, KEY_ORIGINAL_SURF, vIds[i])
-               if tabParams then
-                  for sKey, sVal in pairs( tabParams[i]) do
-                     EgtSetInfo( nId, sKey, sVal)
-                  end
-               end
-               EgtModifyCurveExtrusion( nId, vtSlicing, GDB_RT.GLOB)
-               EgtApproxCurve( nId, GDB_CA.ARCS, MID_TOLER)
-             
-               -- se ho ancora curve aperte, segnalo errore
-               if nType ~= TYPE.RIB and nType ~= TYPE.INFILL and not EgtCurveIsClosed( nId) then
-                  EgtOutLog( 'Error : hole in object (layer '.. EgtNumToString( nLayCnt) ..') - CalcSlices')
-                  table.insert( s_vErr, nLayCnt)
-               end
-            end
-            
-            -- rimuovo superfici
-            for nId = nNewId + nPntCnt + nCrvCnt, nNewId + nPntCnt + nCrvCnt + nSrfCnt - 1 do
-               EgtErase( nId)
-            end
-         end
-      end
-   end
-
-   -- verifico che il gruppo non sia vuoto
-   if not EgtGetFirstInGroup( nGrp) then
-      EgtErase( nGrp)
-      nGrp = nil
-   end
-   
-   return nGrp
-end
-
---------------------------------------------------------------------
-local function SlicingExtraObjects( nLay, nType, sName, sNameGrp, nStmId)
+local function SlicingExtraObjects( nLay, vSlicingDir, vSlicingVal, nSlicingType, nType, sName, sNameGrp, nStmId)
    
    if not nLay then return end
    
@@ -384,30 +292,128 @@ local function SlicingExtraObjects( nLay, nType, sName, sNameGrp, nStmId)
    end
 
    -- taglio i setti unbounded e limitati con il solido
-   local bLimitUnbddRibs = EgtGetInfo( s_nPartId, KEY_LIMIT_UNBDD_RIBS, 'b') or false
    local vEraseIds = {}
-   if nType == TYPE.RIB and bLimitUnbddRibs then
-      for i = 1, #vSliceIds do
-         if tabParams[i][KEY_RIBS_TYPE] == RIB_TYPE.UNBOUNDED then
-            -- creo copia e la taglio con solido
-            local nCopy = EgtCopyGlob( vSliceIds[i], EgtGetParent( vSliceIds[i]))
-            EgtSurfTmCut( nCopy, nStmId, true, true)
-            -- lo slicing va fatto sulla copia
-            vSliceIds[i] = nCopy
-            table.insert( vEraseIds, nCopy)
+   if nStmId then
+      local bLimitUnbddRibs = EgtGetInfo( s_nPartId, KEY_LIMIT_UNBDD_RIBS, 'b') or false
+      if nType == TYPE.RIB and bLimitUnbddRibs then
+         for i = 1, #vSliceIds do
+            if tabParams[i][KEY_RIBS_TYPE] == RIB_TYPE.UNBOUNDED then
+               -- creo copia e la taglio con solido
+               local nCopy = EgtCopyGlob( vSliceIds[i], EgtGetParent( vSliceIds[i]))
+               EgtSurfTmCut( nCopy, nStmId, true, true)
+               -- lo slicing va fatto sulla copia
+               vSliceIds[i] = nCopy
+               table.insert( vEraseIds, nCopy)
+            end
          end
       end
    end
    
-   -- per ogni layer calcolo lo slicing degli oggetti
    local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER .. '*')
-   for i = 1, #vLayIds do
-      -- ricavo piano di slicing
-      local ptSlicing = EgtGetInfo( vLayIds[i], KEY_SLICE_POS, 'p')
-      local vtSlicing = EgtGetInfo( vLayIds[i], KEY_SLICE_DIR, 'v')
-      SliceStm( vSliceIds, vLayIds[i], vtSlicing, ptSlicing, nType, sName, sNameGrp, tabParams)
-   end
 
+   for i = 1, #vSliceIds do
+      -- effettuo lo slicing in layer separati ( analogamente a quanto avviene con il solido)
+      local nResId
+      if nSlicingType ~= SLICING_TYPE.MULTIPLANAR and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_DEG45 and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_HOR then
+         nResId = EgtParPlanesSurfTmInters( ORIG(), vSlicingDir[1], vSlicingVal, vSliceIds[i], s_nPartId, GDB_RT.GLOB, TOLER)
+      else
+         for j = 1, #vSlicingVal do
+            local vtN = vSlicingDir[j]
+            local ptOn = vSlicingVal[j]
+            if j == 1 then
+               ptOn = ptOn + DELTAZ * vtN
+            end
+      
+            local nGrpId = EgtGroup( s_nPartId)
+            if not nResId then
+               nResId = nGrpId
+            end
+            EgtPlaneSurfTmInters( ptOn, vtN, vSliceIds[i], nGrpId, GDB_RT.GLOB, TOLER)
+         end
+      end
+
+      -- recupero i risultati e li sposto nei layers opportuni
+      local j = 1
+      while nResId do
+         local vtSlicing = vSlicingDir[j] or vSlicingDir[1]
+         
+         -- recupero il gruppo nel layer dove salvare lo slicing degli oggetti o lo creo se non esiste
+         local nGrp = EgtGetFirstNameInGroup( vLayIds[j], sNameGrp)
+         if not nGrp then
+            nGrp = EgtGroup( vLayIds[j])
+            EgtSetName( nGrp, sNameGrp)
+            EgtSetStatus( nGrp, GDB_ST.OFF)
+         end
+         
+         -- verifico se necessario ricalcolo
+         local nId = EgtGetLastInGroup( nResId)
+         local bRecalc = false
+         local vtRecalc
+         while nId and not bRecalc do
+            local nGeoType = EgtGetType( nId)
+            if nGeoType == GDB_TY.SRF_MESH then
+               bRecalc = true
+               vtRecalc = EgtSurfTmFacetNormVersor( nId, 0)
+            elseif nGeoType == GDB_TY.GEO_POINT then
+               bRecalc = true
+            elseif nType ~= TYPE.RIB and nType ~= TYPE.INFILL and not EgtCurveIsClosed( nId) then
+               bRecalc = true
+            end
+            nId = EgtGetPrev( nId)
+         end
+         
+         -- eseguo eventuale ricalcolo
+         local dDeltaZ = EgtIf( j == 1, DELTAZ, 0)
+         if bRecalc then
+            EgtEmptyGroup( nResId)
+            dDeltaZ =  dDeltaZ + EgtIf( vtRecalc and vtRecalc:getZ() > 0, - DELTAZ, DELTAZ)
+            -- eseguo il ricalcolo solo a quella quota
+            local ptSlicing = EgtGetInfo( vLayIds[j], KEY_SLICE_POS, 'p')
+            local ptOn = ptSlicing + dDeltaZ * vtSlicing
+            EgtPlaneSurfTmInters( ptOn, vtSlicing, vSliceIds[i], nResId, GDB_RT.GLOB, TOLER)
+            EgtOutLog( 'Warning : recalc at layer '.. EgtNumToString( j))
+         end
+         
+         -- recupero tutte le curve
+         local vAllIds = EgtGetAllInGroup( nResId)
+         local vCrvIds = {}
+         for k = 1, #vAllIds do
+            local nGeoType = EgtGetType( nId)
+            if nGeoType ~= GDB_TY.SRF_MESH and nGeoType ~= GDB_TY.GEO_POINT then
+               table.insert( vCrvIds, vAllIds[k])
+            end
+         end
+         
+         if #vCrvIds > 0 then
+            -- concateno le curve, le rinomino, correggo di DeltaZ e assegno i parametri
+            local nChainId, nCnt = EgtCurveCompoByChain( nGrp, vCrvIds, ORIG(), true, GDB_RT.LOC, TOLER)
+            for nId = nChainId, nChainId + nCnt - 1 do
+               EgtSetName( nId, sName .. EgtNumToString( i))
+               EgtMove( nId, - dDeltaZ * vtSlicing)
+               EgtSetInfo( nId, KEY_ORIGINAL_SURF, vSliceIds[i])
+               if tabParams then
+                  for sKey, sVal in pairs( tabParams[i]) do
+                     EgtSetInfo( nId, sKey, sVal)
+                  end
+               end
+               EgtModifyCurveExtrusion( nId, vtSlicing, GDB_RT.GLOB)
+               EgtApproxCurve( nId, GDB_CA.ARCS, MID_TOLER)
+            
+               -- se ho ancora curve aperte, segnalo errore
+               if nType ~= TYPE.RIB and nType ~= TYPE.INFILL and not EgtCurveIsClosed( nId) then
+                  EgtOutLog( 'Error : hole in object (layer '.. EgtNumToString( j) ..') - CalcSlices')
+                  table.insert( s_vErr, j)
+               end
+            end
+         end
+         
+         local nOldId = nResId
+         nResId = EgtGetNext( nResId)
+         j = j + 1
+         EgtErase( nOldId)
+      end
+   end
+   
    -- rimuovo eventuali oggetti creati per lo slicing
    EgtErase( vEraseIds)
    
@@ -435,17 +441,54 @@ local function SlicingInfill( nLay, sName, sNameGrp)
       -- recupero i dati di slicing
       local ptSlicing = EgtGetInfo( vLayIds[i], KEY_SLICE_POS, 'p')
       local vtSlicing = EgtGetInfo( vLayIds[i], KEY_SLICE_DIR, 'v')
-      local nResultLay = SliceStm( tIds[nGrpIdx], vLayIds[i], vtSlicing, ptSlicing, TYPE.INFILL, sName, sNameGrp)
-      -- sistemo i nomi delle curve
-      local vInfillCrvs = EgtGetAllInGroup( nResultLay)
-      for j = 1, #vInfillCrvs do
-         EgtSetName( vInfillCrvs[j], sName .. EgtNumToString(j))
+      
+      local nGrp = EgtGetFirstNameInGroup( vLayIds[i], sNameGrp)
+      if not nGrp then
+         -- se gruppo non esiste lo creo
+         nGrp = EgtGroup( vLayIds[i])
+         EgtSetName( nGrp, sNameGrp)
+         EgtSetStatus( nGrp, GDB_ST.OFF)
+      end
+      
+      local vInfillIds = tIds[nGrpIdx]
+      for j = 1, #vInfillIds do
+         -- verifico che oggetto sia trimesh
+         local nTypeObj = EgtGetType( vInfillIds[j])
+         if nTypeObj == GDB_TY.SRF_MESH then
+            -- slicing
+            local nNewId, nPntCnt, nCrvCnt, nSrfCnt = EgtPlaneSurfTmInters( ptSlicing, vtSlicing, vInfillIds[j], nGrp, GDB_RT.GLOB, TOLER)
+
+            -- rimuovo punti
+            for nId = nNewId, nNewId + nPntCnt -1 do
+               EgtErase( nId)
+            end
+            
+            -- concateno le curve
+            local vChain = {}
+            for nId = nNewId + nPntCnt, nNewId + nPntCnt + nCrvCnt - 1 do
+               table.insert( vChain, nId)
+            end
+            local nChainId, nCnt = EgtCurveCompoByChain( nGrp, vChain, ORIG(), true, GDB_RT.LOC, TOLER)
+            -- sistemo le curve
+            for nId = nChainId, nChainId + nCnt - 1 do
+               EgtSetName( nId, sName .. EgtNumToString(j))
+               EgtSetInfo( nId, KEY_ORIGINAL_SURF, vInfillIds[j])
+               EgtModifyCurveExtrusion( nId, vtSlicing, GDB_RT.GLOB)
+               EgtApproxCurve( nId, GDB_CA.ARCS, MID_TOLER)
+            end
+            
+            -- rimuovo superfici
+            for nId = nNewId + nPntCnt + nCrvCnt, nNewId + nPntCnt + nCrvCnt + nSrfCnt - 1 do
+               EgtErase( nId)
+            end
+         end
       end
    end
 
    return true
 end
 
+
 ----------------------------------------------------------------------
 ----------------------------- INFILL ---------------------------------
 ----------------------------------------------------------------------
@@ -622,7 +665,7 @@ local function CalcGridFromPattern( nInfillGrp, nStmId, dOffsStm, frRef, vtOffs,
       b3Loc2:expand( dOffsStm)
       local ptMin2 = b3Loc2:getMin()
       local ptMax2 = b3Loc2:getMax()
-      
+
       -- creo curva base ruotando la curva base della direzione principale
       local nCrvBase2 = EgtCopyGlob( nCrvBase, nMainGrp)
       EgtRotate( nCrvBase2, ptCen, Z_AX(), vSlicesAng[i] - vSlicesAng[1])
@@ -689,7 +732,7 @@ local function CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, dG
    local ptLast = EgtGetInfo( nLastLay, KEY_SLICE_POS, 'p')
    local dZ = ( ptLast - ORIG()) * vtSlicing
    for i = 1, #vCrvs do
-      EgtSurfTmByExtrusion( EgtGetParent( vCrvs[i]), vCrvs[i], ( dZ + 100) * vtSlicing, GDB_RT.GLOB) 
+      EgtSurfTmByExtrusion( EgtGetParent( vCrvs[i]), vCrvs[i], ( dZ + 100) * vtSlicing, 0.05, GDB_RT.GLOB)
    end
    EgtErase( vCrvs)
    
@@ -781,14 +824,9 @@ local function ExtractRibsLoops( nRibsGrp, nStmId)
    -- recupero tutti i setti
    local vIds = EgtGetAllInGroup( nRibsGrp)
    for i = 1, #vIds do
-      -- se trimesh
+      -- se trimesh estraggo i contorni
       if EgtGetType( vIds[i]) == GDB_TY.SRF_MESH then
-         -- trim con il solido
-         local nCopy = EgtCopyGlob( vIds[i], nLoopGrp)
-         local nType = ReadParam( vIds[i], KEY_RIBS_TYPE, 'i', RIB_TYPE.INTERNAL)
-         EgtSurfTmCut( nCopy, nStmId, nType ~= RIB_TYPE.EXTERNAL, false)
-         -- estraggo i contorni
-         local nCrv, nCnt = EgtExtractSurfTmLoops( nCopy, nLoopGrp)
+         local nCrv, nCnt = EgtExtractSurfTmLoops(  vIds[i], nLoopGrp)
          if nCrv then
             -- assegno nome che permetta di ricondurli alla superficie da cui derivano
             for nId = nCrv, nCrv + nCnt - 1 do
@@ -809,26 +847,113 @@ local function ValueInArray( vArr, nValue)
    return false
 end
 
+---------------------------------------------------------------------
+local function VerifyMultiPlanarStrand()
+   
+   local vLayers = EgtGetNameInGroup( s_nPartId, SLICE_LAYER .. '*')
+   -- recupero i valori di strand massimo e minimo dal file ini
+   local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
+   local dMaxStrandFactor = EgtGetNumberFromIni( '3dPrinting', KEY_MAX_STRANDH_FACTOR, 2, sMachIni)
+   local dMinStrandFactor = EgtGetNumberFromIni( '3dPrinting', KEY_MIN_STRANDH_FACTOR, 0.5, sMachIni)
+   local dSliceStep = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd')
+   local dMaxStrand = dMaxStrandFactor * dSliceStep
+   local dMinStrand = dMinStrandFactor * dSliceStep
+   
+   if dMaxStrand < dMinStrand + GEO.EPS_SMALL then
+      EgtOutBox( 'Max strand height is less than min strand height', 'Error', 'ERROR')
+      return false
+   end
+   
+   -- ciclo sui piani di slicing calcolati
+   local vtSlicePrev = V_NULL()
+   local ptSlicePrev = ORIG()
+   local bFirst = true
+   local dTotMaxDist = dSliceStep
+   local dTotMinDist = dSliceStep
+   local nLayMin = 1
+   local nLayMax = 1
+   for i = 1, #vLayers do
+      
+      -- recupero il piano corrente
+      local vtSlice = EgtGetInfo( vLayers[i], KEY_SLICE_DIR, 'v')
+      local ptSlice = EgtGetInfo( vLayers[i], KEY_SLICE_POS, 'p') + dSliceStep * vtSlice
+      local dCosAng = vtSlicePrev * vtSlice
+      
+      -- recupero tutte le curve da verificare :
+      local vCrvs = {}
+      -- solido
+      local vCrvGrps = EgtGetNameInGroup( vLayers[i], CONTOUR_GRP .. '*')
+      for j = 1, #vCrvGrps do
+         local vSolidCrvs = EgtGetNameInGroup( vCrvGrps[j], OUTER_CRV)
+         EgtJoinTables( vCrvs, vSolidCrvs)
+      end
+      -- setti
+      local nRibsGrp = EgtGetFirstNameInGroup( vLayers[i], RIBS_GRP) or GDB_ID.NULL
+      local vRibsCrv = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') or {}
+      EgtJoinTables( vCrvs, vRibsCrv)
+      -- AuxSolids
+      local nAuxSolidsGrp = EgtGetFirstNameInGroup( vLayers[i], AUX_SOLIDS_GRP) or GDB_ID.NULL
+      local vAuxSolidsCrv = EgtGetNameInGroup( nAuxSolidsGrp, AUX_SOLIDS_CRV .. '*') or {}
+      EgtJoinTables( vCrvs, vAuxSolidsCrv)
+      
+      if #vCrvs > 0 and not bFirst then
+         -- verifico la distanza dal piano precedente lungo vtSlice
+         local dMinDist = GEO.INFINITO
+         local dMaxDist = - GEO.INFINITO
+         for j = 1, #vCrvs do
+            local _, dE = EgtCurveDomain( vCrvs[j])
+            for dU = 0, dE do
+               local ptCurr = EgtUP( vCrvs[j], dU, GDB_ID.ROOT) + dSliceStep * vtSlice
+               local dDist = ( ptCurr - ptSlicePrev) * vtSlicePrev / dCosAng
+               if dDist < dMinStrand - GEO.EPS_SMALL or dDist > dMaxStrand + GEO.EPS_SMALL then
+                  EgtOutLog( 'Error on layer ' .. EgtNumToString( i) .. ' : strand height (' .. EgtNumToString( dDist) .. ') outside valid range (' .. EgtNumToString( dMinStrand) .. 
+                              ' - ' .. EgtNumToString( dMaxStrand) .. ')')
+                  EgtOutBox( 'Strand height value ' .. EgtNumToString( dDist) .. ' in layer ' .. EgtNumToString( i) .. ' is outside valid range (' .. EgtNumToString( dMinStrand) .. 
+                              ' - ' .. EgtNumToString( dMaxStrand) .. ')', 'Error', 'ERROR')
+                  return false
+               end
+               
+               if dDist < dMinDist then
+                  dMinDist = dDist
+               end
+               if dDist > dMaxDist then
+                  dMaxDist = dDist
+               end
+            end
+         end
+         EgtSetInfo( vLayers[i], KEY_MULTIPLANAR_MAX_H, dMaxDist)
+         EgtSetInfo( vLayers[i], KEY_MULTIPLANAR_MIN_H, dMinDist)
+         
+         if dMinDist < dTotMinDist then
+            dTotMinDist = dMinDist
+            nLayMin = i
+         end
+         if dMaxDist > dTotMaxDist then
+            dTotMaxDist = dMaxDist
+            nLayMax = i
+         end
+      end
+      
+      -- aggiorno per layer successivo
+      vtSlicePrev = vtSlice
+      ptSlicePrev = ptSlice
+      if #vCrvs > 0 then
+         bFirst = false
+      end
+   end
+   
+   EgtOutLog( 'MinStrandH = ' .. EgtNumToString( dTotMinDist) .. ' (layer ' .. EgtNumToString( nLayMin) .. ')')
+   EgtOutLog( 'MaxStrandH = ' .. EgtNumToString( dTotMaxDist) .. ' (layer ' .. EgtNumToString( nLayMax) .. ')')
+
+   return true
+end
+
 ---------------------------------------------------------------------
 local function SlicingNoSolid( nRibsLay, nSlicingType, dMaxH, dSliceStep, vSlicingVal, vSlicingDir)
 
    -- contatore per il calcolo delle intersezioni
    if EgtProcessEvents( 100, 0) == 1 then return false end
 
-   -- recupero i setti di cui fare lo slicing e i parametri associati
-   local vRibIds = EgtGetAllInGroup( nRibsLay)
-   local tabParams = {}
-   local vIds = {}
-   for i = 1, #vRibIds do
-      if EgtGetType( vRibIds[i]) == GDB_TY.SRF_MESH then
-         local vParams = GetRibParams( vRibIds[i])
-         if vParams[KEY_RIBS_SHELLS_NBR] > 0 then
-            table.insert( tabParams, vParams)
-            table.insert( vIds, vRibIds[i])
-         end
-      end
-   end
-
    -- creo i layer dello slicing
    for i = 1, #vSlicingVal do
       -- creo layer e gruppo dei contorni
@@ -842,8 +967,8 @@ local function SlicingNoSolid( nRibsLay, nSlicingType, dMaxH, dSliceStep, vSlici
       local dDeltaZ = EgtIf( i == 1, DELTAZ, 0)
       local ptSlicing
       local vtSlicing
-      if nSlicingType == SLICING_TYPE.MULTIPLANAR then
-         vtSlicing = vtSlicing[i]
+      if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
+         vtSlicing = vSlicingDir[i]
          ptSlicing = vSlicingVal[i]
       else
          vtSlicing = vSlicingDir[1]
@@ -852,23 +977,33 @@ local function SlicingNoSolid( nRibsLay, nSlicingType, dMaxH, dSliceStep, vSlici
       EgtSetInfo( nLayId, KEY_SLICE_POS, ptSlicing)
       EgtSetInfo( nLayId, KEY_SLICE_DIR, vtSlicing)
       EgtSetInfo( nLayId, KEY_SLICE_DELTAZ, dDeltaZ)
-      
-      -- slicing dei setti
-      local nResultLay = SliceStm( vIds, nLayId, vtSlicing, ptSlicing, TYPE.RIB, RIBS_CRV, RIBS_GRP, tabParams)
-      
-      -- se slicing multplanare verifico altezza massima
-      if nSlicingType == SLICING_TYPE.MULTIPLANAR and dMaxH < GEO.INFINITO then
-         local b3Box = EgtGetBBoxGlob( nResultLay, GDB_BB.STANDARD)
-         local ptMax = b3Box:getMax() + dSliceStep * vtSlicing
-         if ptMax:getZ() > dMaxH + GEO.EPS_SMALL then
-            EgtErase( nLayId)
-            break
-         end
-      end
 
       if EgtProcessEvents( EgtIf( PRINT, 100, 0) + i / #vSlicingVal * 100, 0) == 1 then return false end
    end
    
+   -- slicing dei setti
+   SlicingExtraObjects( nRibsLay, vSlicingDir, vSlicingVal, nSlicingType, TYPE.RIB, RIBS_CRV, RIBS_GRP)
+
+   -- se slicing multplanare verifico altezza massima e strand
+   if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
+      if dMaxH < GEO.INFINITO then
+         local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER .. '*')
+         for i = 1, #vLayIds do
+            local nCurrRibsLay = EgtGetFirstNameInGroup( vLayIds[i], RIBS_GRP)
+            local b3Box = EgtGetBBoxGlob( nCurrRibsLay, GDB_BB.STANDARD)
+            local ptMax = b3Box:getMax() + dSliceStep * vSlicingDir[i]
+            if ptMax:getZ() > dMaxH + GEO.EPS_SMALL then
+               -- elimino tutti i layer da questo punto
+               for j = i, #vLayIds do
+                  EgtErase( vLayIds[j])
+               end
+               break
+            end
+         end
+      end
+      VerifyMultiPlanarStrand()
+   end
+   
    return true
 end
 
@@ -910,80 +1045,12 @@ local function MultiPlanarSlicing( nStmId, dMaxH, vSlicingDir, vSlicingPnt)
    return nFirstGrpId, nCnt
 end
 
----------------------------------------------------------------------
-local function VerifyMultiPlanarStrand()
-   
-   local vLayers = EgtGetNameInGroup( s_nPartId, SLICE_LAYER .. '*')
-   -- recupero i valori di strand massimo e minimo dal file ini
-   local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
-   local dMaxStrandFactor = EgtGetNumberFromIni( '3dPrinting', KEY_MAX_STRANDH_FACTOR, 2, sMachIni)
-   local dMinStrandFactor = EgtGetNumberFromIni( '3dPrinting', KEY_MIN_STRANDH_FACTOR, 0.5, sMachIni)
-   local dSliceStep = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd')
-   local dMaxStrand = dMaxStrandFactor * dSliceStep
-   local dMinStrand = dMinStrandFactor * dSliceStep
-   
-   if dMaxStrand < dMinStrand + GEO.EPS_SMALL then
-      EgtOutBox( 'Max strand height is less than min strand height', 'Error', 'ERROR')
-      return false
-   end
-   
-   -- ciclo sui piani di slicing calcolati
-   local vtSlicePrev = EgtGetInfo( vLayers[1], KEY_SLICE_DIR, 'v')
-   local ptSlicePrev = EgtGetInfo( vLayers[1], KEY_SLICE_POS, 'p') + dSliceStep * vtSlicePrev
-   for i = 2, #vLayers do
-      
-      -- recupero il piano corrente
-      local vtSlice = EgtGetInfo( vLayers[i], KEY_SLICE_DIR, 'v')
-      local ptSlice = EgtGetInfo( vLayers[i], KEY_SLICE_POS, 'p') + dSliceStep * vtSlice
-      local dCosAng = vtSlicePrev * vtSlice
-      
-      -- recupero tutte le curve da verificare :
-      local vCrvs = {}
-      -- solido
-      local vCrvGrps = EgtGetNameInGroup( vLayers[i], CONTOUR_GRP .. '*')
-      for j = 1, #vCrvGrps do
-         local vSolidCrvs = EgtGetNameInGroup( vCrvGrps[j], OUTER_CRV)
-         EgtJoinTables( vCrvs, vSolidCrvs)
-      end
-      -- setti
-      local nRibsGrp = EgtGetFirstNameInGroup( vLayers[i], RIBS_GRP) or GDB_ID.NULL
-      local vRibsCrv = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') or {}
-      EgtJoinTables( vCrvs, vRibsCrv)
-      -- AuxSolids
-      local nAuxSolidsGrp = EgtGetFirstNameInGroup( vLayers[i], AUX_SOLIDS_GRP) or GDB_ID.NULL
-      local vAuxSolidsCrv = EgtGetNameInGroup( nAuxSolidsGrp, AUX_SOLIDS_CRV .. '*') or {}
-      EgtJoinTables( vCrvs, vAuxSolidsCrv)
-      
-      -- verifico la distanza dal piano precedente lungo vtSlice
-      for j = 1, #vCrvs do
-         local _, dE = EgtCurveDomain( vCrvs[j])
-         for dU = 0, dE do
-            local ptCurr = EgtUP( vCrvs[j], dU, GDB_ID.ROOT) + dSliceStep * vtSlice
-            local dDist = ( ptCurr - ptSlicePrev) * vtSlicePrev / dCosAng
-            if dDist < dMinStrand - GEO.EPS_SMALL or dDist > dMaxStrand + GEO.EPS_SMALL then
-               EgtOutLog( 'Error on layer ' .. EgtNumToString( i) .. ' : strand height (' .. EgtNumToString( dDist) .. ') outside valid range (' .. EgtNumToString( dMinStrand) .. 
-                           ' - ' .. EgtNumToString( dMaxStrand) .. ')')
-               EgtOutBox( 'Strand height value ' .. EgtNumToString( dDist) .. ' in layer ' .. EgtNumToString( i) .. ' is outside valid range (' .. EgtNumToString( dMinStrand) .. 
-                           ' - ' .. EgtNumToString( dMaxStrand) .. ')', 'Error', 'ERROR')
-               return false
-            end
-         end
-      end
-      
-      -- aggiorno per layer successivo
-      vtSlicePrev = vtSlice
-      ptSlicePrev = ptSlice
-   end
-   
-   return true
-end
-
 ---------------------------------------------------------------------
 local function SlicingWithSolid( nStmId, nSlicingType, dMaxH, vSlicingVal, vSlicingDir)
 
    -- calcolo delle intersezioni
    local nLayId, nCnt
-   if nSlicingType ~= SLICING_TYPE.MULTIPLANAR then
+   if nSlicingType ~= SLICING_TYPE.MULTIPLANAR and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_DEG45 and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_HOR then
       if EgtProcessEvents( 1, 0) == 1 then return false end
       nLayId, nCnt = EgtParPlanesSurfTmInters( ORIG(), vSlicingDir[1], vSlicingVal, nStmId, s_nPartId, GDB_RT.GLOB, TOLER)
       if EgtProcessEvents( 100, 0) == 1 then return false end
@@ -1008,7 +1075,7 @@ local function SlicingWithSolid( nStmId, nSlicingType, dMaxH, vSlicingVal, vSlic
       local dDeltaZ = EgtIf( nLayCnt == 1, DELTAZ, 0)
       local ptSlicing
       local vtSlicing
-      if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+      if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
          -- nel caso multiplanare sono i dati di slicing
          vtSlicing = vSlicingDir[nLayCnt]
          ptSlicing = vSlicingVal[nLayCnt]
@@ -1053,12 +1120,6 @@ local function SlicingWithSolid( nStmId, nSlicingType, dMaxH, vSlicingVal, vSlic
       local vClosedId = {}
       local vOpenId = {}
       nId = EgtGetFirstInGroup( nLayId)
-      
-      -- se slicing del solido aggiorno i valori dei layer estremi che lo contengono
-      if nId then
-         if not nFirstSolidLay then nFirstSolidLay = nLayCnt end
-         nLastSolidLay = nLayCnt
-      end
 
       while nId do 
          if EgtGetType( nId) == GDB_TY.GEO_POINT or EgtGetType( nId) == GDB_TY.SRF_MESH then
@@ -1139,6 +1200,11 @@ local function SlicingWithSolid( nStmId, nSlicingType, dMaxH, vSlicingVal, vSlic
       local nSurfFR, nSrfNbr = EgtSurfFlatRegion( nLayId, vClosedId)
    
       if nSurfFR then
+         
+         -- se slicing del solido valido aggiorno i valori dei layer estremi che lo contengono
+         if not nFirstSolidLay then nFirstSolidLay = nLayCnt end
+         nLastSolidLay = nLayCnt
+         
          -- verifico orientamento della normale
          local vtN = EgtSurfFrNormVersor( nSurfFR, GDB_ID.ROOT)
          if AreOppositeVectorApprox( vtN, vtSlicing) then
@@ -1230,6 +1296,7 @@ local function SlicingWithSolid( nStmId, nSlicingType, dMaxH, vSlicingVal, vSlic
             EgtOutLog( 'Error : hole in solid (layer '.. EgtNumToString( nLayCnt) ..') - CalcSlices')
             table.insert( s_vErr, nLayCnt)
          end
+         
       else
          
          local bErr = true
@@ -1275,26 +1342,26 @@ local function SlicingWithSolid( nStmId, nSlicingType, dMaxH, vSlicingVal, vSlic
    -- costolature
    local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS)
    ExtractRibsLoops( nRibsLay, nStmId)
-   SlicingExtraObjects( nRibsLay, TYPE.RIB, RIBS_CRV, RIBS_GRP, nStmId)
+   SlicingExtraObjects( nRibsLay, vSlicingDir, vSlicingVal, nSlicingType, TYPE.RIB, RIBS_CRV, RIBS_GRP, nStmId)
    if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( nCnt + 3) / nCounterTot * 100, 0) == 1 then return false end
    
    local bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false
    if not bSpiralVase then
       -- infill
-      if nSlicingType ~= SLICING_TYPE.MULTIPLANAR then
+      if nSlicingType ~= SLICING_TYPE.MULTIPLANAR and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_DEG45 and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_HOR then
          PrepareInfill( nStmId, vSlicingDir[1])
       end
       if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( nCnt + 6) / nCounterTot * 100, 0) == 1 then return false end
       
       -- solidi per regioni con diverso numero di passate
       local nShellNbrLay = EgtGetFirstNameInGroup( s_nPartId, LAY_SHELL_NBR)
-      SlicingExtraObjects( nShellNbrLay, TYPE.EXTRA_SHELL, SHELL_NBR_CRV, SHELL_NBR_GRP)
+      SlicingExtraObjects( nShellNbrLay, vSlicingDir, vSlicingVal, nSlicingType, TYPE.EXTRA_SHELL, SHELL_NBR_CRV, SHELL_NBR_GRP)
       if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( nCnt + 9) / nCounterTot * 100, 0) == 1 then return false end
       
       -- solidi ausiliari
       local nAuxSolidsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_AUX_SOLIDS)
-      SlicingExtraObjects( nAuxSolidsLay, TYPE.AUX_SOLID, AUX_SOLIDS_CRV, AUX_SOLIDS_GRP)
-      if nSlicingType ~= SLICING_TYPE.MULTIPLANAR then
+      SlicingExtraObjects( nAuxSolidsLay, vSlicingDir, vSlicingVal, nSlicingType, TYPE.AUX_SOLID, AUX_SOLIDS_CRV, AUX_SOLIDS_GRP)
+      if nSlicingType ~= SLICING_TYPE.MULTIPLANAR and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_DEG45 and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_HOR then
          PrepareAuxSolidsInfill( nAuxSolidsLay, vSlicingDir[1])
       end
       if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( nCnt + 12) / nCounterTot * 100, 0) == 1 then return false end
@@ -1332,7 +1399,7 @@ local function SlicingWithSolid( nStmId, nSlicingType, dMaxH, vSlicingVal, vSlic
    end
    
    -- se multiplanare verifico strand massimo e minimo
-   if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+   if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
       if not VerifyMultiPlanarStrand() then
          return false
       end
@@ -1361,12 +1428,14 @@ function CalcSlices.Exec( nPartId, nStmId)
       vtSlicing = VectorFromSpherical( 1, 45, dHorAng)
    elseif nSlicingType == SLICING_TYPE.HORIZONTAL then
       vtSlicing = X_AX()
-   elseif nSlicingType == SLICING_TYPE.MULTIPLANAR then
+   elseif nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
       -- la direzione può cambiare da un piano all'altro
       vtSlicing = Z_AX()
    end
 
    EgtSetInfo( s_nPartId, KEY_SLICE_DIR, vtSlicing)
+   -- per compatibilità con vecchie macchine
+   EgtSetInfo( s_nPartId, 'SlicingDir', vtSlicing)
    
    -- recupero parametri di slicing
    local dSliceStep = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd') or 10000
@@ -1407,8 +1476,8 @@ function CalcSlices.Exec( nPartId, nStmId)
    local dMaxH = ComputeMaxH( vRefIds, vtSlicing, dSliceStep)
    local vSlicingVal = {}
    local vSlicingDir = {}
-   if nSlicingType == SLICING_TYPE.MULTIPLANAR then
-      vSlicingVal, vSlicingDir = ComputeMultiplanarSlicingData( dSliceStep, nMaxSlicesNbr)
+   if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
+      vSlicingVal, vSlicingDir = ComputeMultiplanarSlicingData( dSliceStep, nMaxSlicesNbr, nSlicingType)
    else
       vSlicingVal, vSlicingDir = ComputeSlicingData( vRefIds, vtSlicing, dSliceStep, dMaxH, nMaxSlicesNbr)
    end

LuaLibs/CalcToolPath.lua

@@ -37,6 +37,7 @@ local function GetLayerParamsForToolPathCalc()
    LayerParams.nLinkType = EgtGetInfo( s_nPartId, KEY_LINK_TYPE, 'i')
    LayerParams.dLinkParam = EgtGetInfo( s_nPartId, KEY_LINK_PARAM, 'd')
    LayerParams.nLeadInType = EgtGetInfo( s_nPartId, KEY_LEAD_IN_TYPE, 'i')
+   LayerParams.bSingleLeadIn = EgtGetInfo( s_nPartId, KEY_SINGLE_LEAD_IN, 'b') or false
    LayerParams.dLeadInTangDist = EgtGetInfo( s_nPartId, KEY_LEAD_IN_TANG_DIST, 'd')
    LayerParams.dLeadInOrthoDist = EgtGetInfo( s_nPartId, KEY_LEAD_IN_ORTHO_DIST, 'd')
    LayerParams.nLeadOutType = EgtGetInfo( s_nPartId, KEY_LEAD_OUT_TYPE, 'i')
@@ -65,7 +66,7 @@ local function GetLayerParamsForToolPathCalc()
    -- parametri da file ini del programma
    local sIniFile = EgtGetIniFile()
    LayerParams.dSpiralVaseInterpLen = EgtGetNumberFromIni( '3dPrinting', KEY_SPIRAL_VASE_INTERP_LEN, 100.0, sIniFile)
-   
+
    return LayerParams
 end
 
@@ -96,25 +97,35 @@ local function AddZCorrection( LayerParams)
    local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i')
    
    -- 1) correzione per il pezzo
-   local dHBox = EgtGetInfo( s_nPartId, KEY_BOX_MIN_Z, 'i') or 0
+   local dHBox = EgtGetInfo( s_nPartId, KEY_BOX_MIN_Z, 'd') or 0
    local dCorrZ = 0
    
    -- se slicing multiplanare vtSlicing cambia ad ogni layer quindi la correzione deve essere calcolata sul singolo layer
-   if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+   if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
+      
       for i = 1, #vLayIds do
          -- calcolo i valori legati a vtSlicing per il layer corrente
          local vtSlicing = EgtGetInfo( vLayIds[i], KEY_SLICE_DIR, 'v')
          local dNxy = sqrt( vtSlicing:getX() * vtSlicing:getX() + vtSlicing:getY() * vtSlicing:getY())
          local dNz = vtSlicing:getZ()
-         -- altezza necessaria per lo strand non serve perchè l'altezza viene adattata lungo il percorso
-         -- altezza necessaria per il tool
-         local dHTool = LayerParams.dTDiam / 2 * dNxy
-         -- altezza disponibile
          local b3Layer = ComputeToolPathBox( vLayIds[i])
-         local dHDisp = b3Layer:getMin():getZ() - max( dHBox, 0)
-
-         local dCurrCorrZ = max( 0, dHTool - dHDisp)
-         dCorrZ = max( dCorrZ, dCurrCorrZ)
+         if not b3Layer:isEmpty() then
+            -- altezza necessaria per lo strand
+            local dHStrand = 0
+            -- nel caso multiplanar con partenza verticale l'altezza necessaria per lo strand non serve perchè l'altezza viene adattata lungo il percorso
+            if nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 then
+               -- nel caso multiplanar 45° si considera come altezza strand quella settata nei parametri visto che varia lungo il percorso ( euristico)
+               dHStrand = 0.5 * LayerParams.dStrand * dNxy + LayerParams.dLayHeight * dNz
+            elseif nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
+               dHStrand = 0.5 * LayerParams.dStrand
+            end
+            -- altezza necessaria per il tool
+            local dHTool = LayerParams.dTDiam / 2 * dNxy
+            -- altezza disponibile
+            local dHDisp = b3Layer:getMin():getZ() - max( dHBox, 0)
+            local dCurrCorrZ = max( 0, max( dHStrand, dHTool) - dHDisp)
+            dCorrZ = max( dCorrZ, dCurrCorrZ)
+         end
       end
 
    -- se slicing standard la correzione può essere calcolata sull'intero pezzo
@@ -150,13 +161,13 @@ local function AddZCorrection( LayerParams)
    -- 2) correzione per i wipe
    -- altezza minima necessaria per i wipe. Se slicing multiplanare l'altezza minima per il wipe cambia ad ogni layer, altrimenti è un valore comune
    local dHMinWipe
-   if nSlicingType ~= SLICING_TYPE.MULTIPLANAR then
+   if nSlicingType ~= SLICING_TYPE.MULTIPLANAR and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_DEG45 and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_HOR then
       local dNxy = sqrt( LayerParams.vtSlicing:getX() * LayerParams.vtSlicing:getX() + LayerParams.vtSlicing:getY() * LayerParams.vtSlicing:getY())
       dHMinWipe = LayerParams.dTDiam / 2 * dNxy + max( dHBox, 0) + s_dHSafeWipe
    end
    
    for i = 1, #vLayIds do
-      if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+      if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
          local vtSlicing = EgtGetInfo( vLayIds[i], KEY_SLICE_DIR, 'v')
          local dNxy = sqrt( vtSlicing:getX() * vtSlicing:getX() + vtSlicing:getY() * vtSlicing:getY())
          dHMinWipe = LayerParams.dTDiam / 2 * dNxy + max( dHBox, 0) + s_dHSafeWipe
@@ -600,7 +611,7 @@ local function AddRetractionOnLastCrv( nCrvId, nTpathGrpId, LayerParams, dCoasti
 end
 
 ---------------------------------------------------------------------
-local function CalcShellsToolPath( vEntIds, nTpathGrpId, LayerParams)
+local function CalcShellsToolPath( vEntIds, nTpathGrpId, bFirst, LayerParams)
    
    if not vEntIds or #vEntIds == 0 then return end
    
@@ -628,7 +639,9 @@ local function CalcShellsToolPath( vEntIds, nTpathGrpId, LayerParams)
    
    -- aggiungo leadin/leadout
    if LayerParams.nLeadInType ~= LEAD_TYPE.NONE then
-      AddLeadIn( vIds[1], LayerParams, nTpathGrpId)
+      if bFirst or not LayerParams.bSingleLeadIn then
+         AddLeadIn( vIds[1], LayerParams, nTpathGrpId)
+      end
    end
    if LayerParams.nLeadOutType ~= LEAD_TYPE.NONE then
       EgtTrimCurveEndAtLen( vIds[#vIds], EgtCurveLength( vIds[#vIds]) - LayerParams.dOffsetLP)
@@ -1530,9 +1543,10 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
    local dOverlap = max( dShellOverlap, dStrandOverlap)
    local nOrigRib = EgtGetInfo( nRibId, KEY_ORIGINAL_RIB, 'i')
    local dLen = EgtCurveLength( nId)
+   local nParentId = EgtGetParent( nId)
    
    -- porto il lead nel gruppo locale
-   local nLeadLoc = EgtCopyGlob( nId, nGrpTmp)
+   EgtRelocateGlob( nId, nGrpTmp)
    
    -- 1) verifico se interseca altri setti, lead in, lead out o collegamenti
    -- recupero gli id degli elementi da controllare
@@ -1558,9 +1572,12 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
                   table.insert( vCheckIds, nCurrId)
                end
             else
-               local nCurrOrigRib = EgtGetInfo( nCurrId, KEY_ORIGINAL_RIB, 'i')
-               if nOrigRib ~= nCurrOrigRib then
-                  table.insert( vCheckIds, nCurrId)
+               local nRibType = EgtGetInfo( nCurrId, KEY_RIBS_TYPE, 'i')
+               if nRibType ~= RIB_TYPE.UNBOUNDED then
+                  local nCurrOrigRib = EgtGetInfo( nCurrId, KEY_ORIGINAL_RIB, 'i')
+                  if nOrigRib ~= nCurrOrigRib then
+                     table.insert( vCheckIds, nCurrId)
+                  end
                end
             end
          end
@@ -1578,44 +1595,80 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
          table.insert( vCheckIds, vRibsPaths[i])
       end
    end
-   -- controllo se intersezione
+   
+   -- creo la superficie occupata dagli id da controllare
+   local nSrf
    for i = 1, #vCheckIds do
       local dCurrStrand = EgtGetInfo( vCheckIds[i], KEY_CRV_STRAND, 'd') or EgtGetInfo( vCheckIds[i], KEY_RIBS_STRAND, 'd')
       local dCurrOffs = dCurrStrand * 0.5 + ( 0.5 - dOverlap / 100) * dStrand - 50 * GEO.EPS_SMALL
       if dCurrOffs > GEO.EPS_SMALL then
          local nSrfCurr = EgtSurfFrFatCurve( nGrpTmp, vCheckIds[i], dCurrOffs, false)
-         if nSrfCurr then
-            -- EgtSetStatus( nSrfCurr, GDB_ST.OFF)
-            local nRes = EgtCurveWithRegionClassify( nLeadLoc, nSrfCurr)
-            if nRes ~= GDB_CRC.OUT then
-               return false
+         if not nSrf then
+            nSrf = nSrfCurr
+         else
+            EgtSurfFrAdd( nSrf, nSrfCurr)
+         end
+      end
+   end
+   
+   -- verifico di avere un tratto esterno consecutivo al setto
+   if nSrf then
+      local nOrigLead = EgtCopyGlob( nId, nGrpTmp)
+      local nRes, nCnt = EgtTrimCurveWithRegion( nId, nSrf, false, false)
+      if not nRes or nCnt == 0 then
+         return false
+      end
+      -- la curva di interesse è la prima se lead out o l'ultima se lead in
+      local nNewCrv = EgtIf( bInVsOut, nRes + nCnt - 1, nRes)
+      local ptRes = EgtIf( bInVsOut, EgtEP( nNewCrv, GDB_ID.ROOT), EgtSP( nNewCrv, GDB_ID.ROOT))
+      local ptRib = EgtIf( bInVsOut, EgtSP( nRibId, GDB_ID.ROOT), EgtEP( nRibId, GDB_ID.ROOT))
+      if not AreSamePointApprox( ptRes, ptRib) then
+         return false
+      end
+      EgtChangeId( nNewCrv, nId)
+   end
+
+   -- 2) verifiche con il setto corrente
+   -- verifico non passi da altro estremo
+   local dParTest = EgtCurveParamAtPoint( nId, EgtIf( bInVsOut, EgtEP( nRibId, GDB_ID.ROOT), EgtSP( nRibId, GDB_ID.ROOT)), 100 * GEO.EPS_SMALL, GDB_RT.GLOB)
+   if dParTest then
+      return false
+   end
+   -- verifico se interrompere in corrispondenza di tratti lineari paralleli al setto che non sono sufficientemente lontani
+   local _, dParE = EgtCurveDomain( nId)
+   local nRibLoc = EgtCopyGlob( nRibId, nGrpTmp)
+   local vtDir = EgtMV( nRibLoc)
+   local dParRef = -1
+   local dParCrv = 1
+   for dParCrv = 0, dParE - 1 do
+      local vtS = EgtUV( nId, dParCrv, 1)
+      local vtE = EgtUV( nId, dParCrv + 1, -1)
+      local dLenCrv = EgtCurveCompoLength( nId, dParCrv)
+      if AreSameVectorApprox( vtS, vtE) and vtS * vtDir < - 1 + GEO.EPS_SMALL and dLenCrv > dStrand + GEO.EPS_SMALL then
+         local vtDist = EgtUP( nId, dParCrv + 0.5) - EgtMP( nRibLoc)
+         local vtOrthoDist = vtDist - ( vtDist * vtDir) * vtDir
+         local dDist = vtOrthoDist:len()
+         if dDist < dStrand + GEO.EPS_SMALL then
+            dParRef = dParCrv
+            if not bInVsOut then
+               break
             end
          end
       end
    end
-  
-   -- 2) verifiche con il setto corrente
-   -- verifico non passi da altro estremo
-   local dParTest = EgtCurveParamAtPoint( nLeadLoc, EgtIf( bInVsOut, EgtEP( nRibId, GDB_ID.ROOT), EgtSP( nRibId, GDB_ID.ROOT)), 100 * GEO.EPS_SMALL, GDB_RT.GLOB)
-   if dParTest then
-      return false
-   end
-   -- verifico se tratti lineari paralleli al setto sono sufficientemente lontani
-   local _, dParE = EgtCurveDomain( nLeadLoc)
-   local nRibLoc = EgtCopyGlob( nRibId, nGrpTmp)
-   local vtDir = EgtMV( nRibLoc)
-   local dParCrv = 1
-   for dParCrv = 1, dParE do
-      local vtS = EgtUV( nLeadLoc, dParCrv - 1, 1)
-      local vtE = EgtUV( nLeadLoc, dParCrv, -1)
-      local dLenCrv = EgtCurveCompoLength( nLeadLoc, dParCrv - 1)
-      if AreSameVectorApprox( vtS, vtE) and vtS * vtDir < - 1 + GEO.EPS_SMALL and dLenCrv > dStrand + GEO.EPS_SMALL then
-         local vtDist = EgtUP( nLeadLoc, dParCrv - 0.5) - EgtMP( nRibLoc)
-         local vtOrthoDist = vtDist - ( vtDist * vtDir) * vtDir
-         local dDist = vtOrthoDist:len()
-         if dDist < dStrand + GEO.EPS_SMALL then
+   
+   if dParRef > - GEO.EPS_SMALL then
+      if bInVsOut then
+         local _, dE = EgtCurveDomain( nId)
+         if abs( dParRef + 1 - dE) < GEO.EPS_SMALL then    -- la curva si cancella completamente
             return false
          end
+         EgtTrimCurveStartAtParam( nId, dParRef + 1)
+      else
+         if dParRef < GEO.EPS_SMALL then   -- la curva si cancella completamente
+            return false
+         end
+         EgtTrimCurveEndAtParam( nId, dParRef)
       end
    end
    
@@ -1625,7 +1678,7 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
       if nCurrLI and EgtGetName( nCurrLI) == LEAD_IN_CRV then
          local nLeadInLoc = EgtCopyGlob( nCurrLI, nGrpTmp)
          -- verifico se intersezione fra curve
-         local _, nPnt, nCrv = EgtCurveCurveInters( nLeadLoc, nLeadInLoc, nGrpTmp)
+         local _, nPnt, nCrv = EgtCurveCurveInters( nId, nLeadInLoc, nGrpTmp)
          if nPnt ~= 0 or nCrv ~= 0 then
             return false
          end
@@ -1648,14 +1701,24 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
          end
       end
    end
-
+   
+   local dNewLen = EgtCurveLength( nId)
+   if dNewLen < 100 * GEO.EPS_SMALL then
+      return false
+   end
+   if abs( dLen - dNewLen) > GEO.EPS_SMALL then
+      EgtOutLog( 'Warning : ' .. EgtGetName( nRibId) .. ' Lead' .. EgtIf( bInVsOut, 'In', 'Out') .. ' is shortened. Len = ' .. EgtNumToString( dNewLen) .. 
+                  ', SetLen = ' .. EgtNumToString( dLen) .. ' ( layer '.. tostring( s_nCurrIdx)..') - CalcToolPath' )
+   end
+   
+   EgtRelocateGlob( nId, nParentId)
    return true
 end
 
 ---------------------------------------------------------------------------------
 local function PrepareRibLead( nCrvOffs, nRib, bInvert, bInVsOut, dPar, dLeadLen)
    
-   local nLeadId = EgtCopyGlob( nCrvOffs, nRib, EgtIf( bInVsOut, GDB_IN.BEFORE, GDB_IN.AFTER))
+   local nLeadId = EgtCopyGlob( nCrvOffs, nRib, GDB_IN.AFTER)
    EgtChangeClosedCurveStart( nLeadId, dPar)
    -- oriento in modo che la curva parta da nRib
    if bInvert then
@@ -1673,6 +1736,10 @@ end
 ---------------------------------------------------------------------------------
 local function FindCorrectRibLead( dPar, nRib, nCrvOffs, bLeadInvert, dLeadLen, bInVsOut, nGrpTmp, bSpecialCase)
    
+   if dLeadLen < GEO.EPS_SMALL then
+      return
+   end
+   
    local nLeadId
    local bInvert = bLeadInvert    -- valore di default è quello dei parametri
    local bOnlyOneSide = false
@@ -1745,6 +1812,7 @@ local function FindCorrectRibLead( dPar, nRib, nCrvOffs, bLeadInvert, dLeadLen,
       end
    end
    
+   EgtRelocateGlob( nLeadId, nRib, EgtIf( bInVsOut, GDB_IN.BEFORE, GDB_IN.AFTER))
    return nLeadId, bInvert
 end
 
@@ -2333,7 +2401,7 @@ local function SpiralVaseFull( vLayIds, LayerParams)
    -- gestione speciale dei primi layers per gestione dell'altezza e feed
    
    local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i')
-   if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+   if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
       return SpiralVaseFullMultiPlanar( vLayIds, LayerParams)
    end
    
@@ -2630,8 +2698,8 @@ local function SpiralVasePartialMultiPlanar( vLayIds, LayerParams)
             local ptSOld = EgtSP( nOldId, GDB_ID.ROOT)
             local ptEOld = EgtEP( nOldId, GDB_ID.ROOT)
             -- proiezione ortogonale dei punti sul piano di slicing corrente
-            local ptSProj = ptSOld + ( ( ptSOld - ptSlicing) * vtSlicing) * vtSlicing
-            local ptEProj = ptEOld + ( ( ptEOld - ptSlicing) * vtSlicing) * vtSlicing
+            local ptSProj = ptSOld - ( ( ptSOld - ptSlicing) * vtSlicing) * vtSlicing
+            local ptEProj = ptEOld - ( ( ptEOld - ptSlicing) * vtSlicing) * vtSlicing
 
             -- a) continuità tra i layers 
             -- modifico il punto iniziale corrente per avvicinarmi il più possibile alla fine del percorso precedente
@@ -2749,7 +2817,7 @@ local function SpiralVasePartial( vLayIds, LayerParams)
    -- la continuità tra i layers viene risolta sul tratto finale del layer percedente
    
    local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i')
-   if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+   if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
       return SpiralVasePartialMultiPlanar( vLayIds, LayerParams)
    end
    
@@ -2948,6 +3016,7 @@ function CalcToolPath.Exec( nPartId)
    -- recupero i parametri per calcolo dei toolpath
    local LayerParams = GetLayerParamsForToolPathCalc()
    local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i')
+   local bFirst = true
    
    -- caso spiral vase
    if LayerParams.bSpiralVase then
@@ -2960,7 +3029,7 @@ function CalcToolPath.Exec( nPartId)
       
       s_nCurrIdx = nIdx
 
-      if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+      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')
       end
 
@@ -3008,8 +3077,8 @@ function CalcToolPath.Exec( nPartId)
 
             -- shell
             if LayerParams.vPrintOrder[j] == PRINT_ELEMENT.SHELL then
-               CalcShellsToolPath( vShellIds, nTpathGrpId, LayerParams)
-            
+               CalcShellsToolPath( vShellIds, nTpathGrpId, bFirst, LayerParams)
+               
             -- extra shell
             elseif LayerParams.vPrintOrder[j] == PRINT_ELEMENT.EXTRA_SHELL then
                CalcExtraShellToolPath( vExtraShellIds, nTpathGrpId, LayerParams)
@@ -3053,6 +3122,10 @@ function CalcToolPath.Exec( nPartId)
             end
          end
          
+         if bFirst and EgtGetGroupObjs( nTpathGrpId) > 0 then
+            bFirst = false
+         end
+         
          -- passo al gruppo di contorni successivo
          nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*")
       end

LuaLibs/RunCalcSolids.lua

@@ -24,8 +24,9 @@ local function GetLayerParamsForSolidCalc( nPartId)
    local LayerParams = {}
    LayerParams.bSpiralVase = EgtGetInfo( nPartId, KEY_SPIRAL_VASE, 'b') or false
    LayerParams.dLayHeight = EgtGetInfo( nPartId, KEY_SLICE_STEP, 'd')
-   LayerParams.vtSlicing = EgtGetInfo( nPartId, KEY_SLICE_DIR, 'v')
+   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
 
@@ -283,6 +284,7 @@ local function CalcSolidGuides( nCrvId, dStrand, nSolidGrp)
    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)
@@ -308,7 +310,7 @@ local function CalcSolidGuides( nCrvId, dStrand, nSolidGrp)
                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 or vtCurrE * vtNext < GEO.EPS_SMALL then
+               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
@@ -427,21 +429,21 @@ end
 --------------------------------------------------------------------
 ------------------------- MULTIPLANAR ------------------------------
 --------------------------------------------------------------------
-local function CreateMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, nLayerId)
+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( nSliceNbr == 1, LayerParams.dLayHeight, s_dMultiPlanarH)
+   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 nSliceNbr > 1 then
-      local ptSlicing = EgtGetInfo( nLayerId, KEY_SLICE_POS, 'p') + LayerParams.vtSlicing * LayerParams.dLayHeight
+   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
+      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)
@@ -463,11 +465,11 @@ local function CreateMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, nLayerId
 end
 
 ---------------------------------------------------------------------
-local function CreatePartialSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, nLayerId)
+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)
+      CreateMultiPlanarSolids( { vIds[i]}, nSolidGrpId, LayerParams, nLayerId, bFirst)
    end
    
    -- 2) l'ultima curva è il tratto che si alza fino al layer successivo
@@ -478,7 +480,7 @@ local function CreatePartialSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, Laye
    -- 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
+   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
@@ -549,11 +551,11 @@ local function CreatePartialSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, Laye
    local nSliceNbr = EgtGetInfo( nLayerId, KEY_SLICE_NBR, 'i')
    if nSliceNbr == 1 then
       vtSlicingPrev = LayerParams.vtSlicing
-      ptSlicingPrev = ptSlicing - LayerParams.dLayHeight * 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
+      ptSlicingPrev = EgtGetInfo( nPrevLayId, KEY_SLICE_POS, 'p') + vtSlicingPrev * LayerParams.dLayHeight + LayerParams.vtCorr
    end
    local dCosAng = vtSlicingPrev * LayerParams.vtSlicing
    
@@ -596,12 +598,12 @@ 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
+   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
+   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)
@@ -715,8 +717,8 @@ local function CreateFullSpiralVaseMultiPlanarSolidsLastLayer( vIds, nSolidGrpId
    
    local nPrevLayerId = EgtGetPrev( EgtGetPrev( nLayerId))
    local vtSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_DIR, 'v')
-   local ptSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_POS, 'p') + vtSlicingPrev * LayerParams.dLayHeight
-   local ptSlicing = EgtGetInfo( nLayerId, KEY_SLICE_POS, 'p') + LayerParams.vtSlicing * LayerParams.dLayHeight
+   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
@@ -828,12 +830,13 @@ function RunCalcSolids.Exec()
             local LayerParams = GetLayerParamsForSolidCalc( nPartId)
             
             -- se slicing multiplanare considero come altezza standard quella massima ammessa
-            if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+            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
@@ -860,81 +863,84 @@ function RunCalcSolids.Exec()
                      
                      local vIds = EgtGetAllInGroup( nTPathGrpId)
                      
-                     -- slicing multiplanare
-                     if nSlicingType == SLICING_TYPE.MULTIPLANAR 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 nIdx == 1 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])
-                              elseif nIdx == #vLayIds then
-                                 -- gestione speciale per lead out e coasting
-                                 CreateFullSpiralVaseMultiPlanarSolidsLastLayer( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx])
+                     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
-                                 CreateFullSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx])
+                                 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
-                              
-                           -- b) spiral vase con transizione parziale
+                           -- c) multiplanare standard
                            else
-                              if nIdx == #vLayIds then
-                                 -- ultimo layer è un multiplanare standard perchè non ha tratto finale che si alza
-                                 CreateMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx])
+                              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
-                                 CreatePartialSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx])
+                                 table.insert( vTmpIds, vIds[i])
                               end
                            end
-                        -- c) multiplanare standard
+                           -- 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
-                           CreateMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx])
-                        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])
+                           for i = 1, #vIds do
+                              CreateSolidFromCurve( vIds[i], nSolidGrpId, LayerParams, nSliceNbr)
                            end
                         end
-                        -- inserisco ultimo gruppo
-                        if #vTmpIds > 0 then
-                           table.insert( vChainedIds, vTmpIds)
-                        end
-                        
-                        for i = 1, #vChainedIds do
-                           if #vChainedIds[i] == 1 then
-                              CreateSolidFromCurve( vChainedIds[i][1], nSolidGrpId, LayerParams, nSliceNbr)
-                           else
-                              local nNewCrv = EgtCurveCompo( nSolidGrpId, vChainedIds[i], false)
-                              local dStrand = EgtGetInfo( vChainedIds[i][1], KEY_CRV_STRAND, 'd') or LayerParams.dStrand
-                              EgtSetInfo( nNewCrv, KEY_CRV_STRAND, dStrand)
-                              EgtSetInfo( nNewCrv, KEY_TYPE, TYPE.OUTER_SHELL)
-                              CreateSolidFromCurve( nNewCrv, nSolidGrpId, LayerParams, nSliceNbr)
-                              EgtErase( nNewCrv)
-                           end
-                        end
-                        
-                     -- slicing standard
-                     else
-                        for i = 1, #vIds do
-                           CreateSolidFromCurve( vIds[i], nSolidGrpId, LayerParams, nSliceNbr)
-                        end
+                        bFirst = false
                      end
                   else
                      bSolidsOk = true

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/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)
@@ -156,7 +166,7 @@ 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_SLICE_DIR, 'v')
+   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)
@@ -190,20 +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)
       
       -- se multiplanare o spiral vase esporto direttamente i solidi altrimenti esporto le curve che verranno estruse nel visualizzatore
-      if nSlicingType == SLICING_TYPE.MULTIPLANAR or bSpiralVase then
+      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. 2026/03/04
+-- Version.lua by Egaltech s.r.l. 2026/05/04
 -- Gestione della versione di 3dPrinting
 
-VERSION = '3.1c1'
+VERSION = '3.1e1'