From 3f9628121c5555d64cfa80a62730709ce29d04c1 Mon Sep 17 00:00:00 2001 From: SaraP Date: Tue, 17 Oct 2023 14:38:52 +0200 Subject: [PATCH] =?UTF-8?q?3dPrinting=202.5j2=20:=20-=20aggiunta=20possibi?= =?UTF-8?q?lit=C3=A0=20di=20unire=20i=20setti=20alla=20shell=20interna=20-?= =?UTF-8?q?=20migliorie=20varie.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- LuaLibs/AddManData.lua | 8 + LuaLibs/CalcPaths.lua | 1222 ++++++++++++++++++++++++++++++++------ LuaLibs/CalcSlices.lua | 13 +- LuaLibs/CalcToolPath.lua | 119 ++-- Version.lua | 2 +- 5 files changed, 1132 insertions(+), 232 deletions(-) diff --git a/LuaLibs/AddManData.lua b/LuaLibs/AddManData.lua index 8d05844..8172c13 100644 --- a/LuaLibs/AddManData.lua +++ b/LuaLibs/AddManData.lua @@ -28,8 +28,12 @@ LINK_CRV = "Link" FRAME_PART = "FramePart" START_GEOM = "Start" TOT_SHELL_TRIM_SURF = "TotalShellSurfForTrim" +SHELL_SURF = "ShellSurf" +COARSE_TRIM_SURF = "CoarseTrimSurf" TRIM_SURF_LOOP = "TrimSurfLoop" SURF_LOOP = "SurfLoop" +LOOP_GRP = "LoopGrp" +DIR_ARROW = "Arrow" MIN_LEN = 0.1 MIN_AREA = 0.01 @@ -134,6 +138,8 @@ KEY_RIBS_USER_LINK_CCW = "RibUserLinkCCW" KEY_RIBS_USER_LINK_ORDER = "RibUserLinkOrder" KEY_RIBS_USER_LINK_TOT = "RibsUserLinkParts" KEY_RIBS_INVERT_STRAND_ORDER = "RibsInvertStrandOrder" +KEY_RIBS_MERGE_WITH_SHELLS = "RibsMergeWithShell" +KEY_INVERT_RIBS_MERGED_SHELL_LINK = "InvertRibsMergedShellMainLink" -- Regioni con diverso numero di passate KEY_SHELL_NBR_DIFF = "ShellNbrDifference" @@ -196,6 +202,8 @@ KEY_PREV_CRV = "PrevCrv" KEY_NEXT_CRVS = "NextCrvs" KEY_CRV_STRAND = "CurveStrand" KEY_LAYER_CNT = "LayerCnt" +KEY_CRV_OFFSET = "CurveOffset" +KEY_ORIG_REF = "Orig" SLICING_TYPE = { VERTICAL = 1, diff --git a/LuaLibs/CalcPaths.lua b/LuaLibs/CalcPaths.lua index a435180..e6df65a 100644 --- a/LuaLibs/CalcPaths.lua +++ b/LuaLibs/CalcPaths.lua @@ -17,6 +17,7 @@ local s_nPartId local s_dOffsCorr = 10 * GEO.EPS_SMALL local s_vErr = {} local s_nCurrIdx +local s_vtSlicing --------------------------------------------------------------------- local function GetLayerParamsForPathCalc() @@ -29,11 +30,12 @@ local function GetLayerParamsForPathCalc() LayerParams.dLayHeight = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd') LayerParams.dStrandOverlap = EgtGetInfo( s_nPartId, KEY_STRAND_OVERLAP, 'd') or 0 LayerParams.dOffs = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd') - LayerParams.vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v') + s_vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v') LayerParams.bPrintInvert = ( EgtGetInfo( s_nPartId, KEY_PRINT_DIRECTION, 'i') == PRINT_DIRECTION.CW) LayerParams.vPrintOrder = EgtGetInfo( s_nPartId, KEY_PRINT_ORDER, 'vi') or { 1, 2, 3, 4, 5, 6, 7, 8} -- parametri costolature - LayerParams.bRibsInvertOrder = EgtGetInfo( s_nPartId, KEY_RIBS_INVERT_ORDER, 'b') + LayerParams.bRibsInvertOrder = EgtGetInfo( s_nPartId, KEY_RIBS_INVERT_ORDER, 'b') or false + LayerParams.bInvertRibsMergedShellLink = EgtGetInfo( s_nPartId, KEY_INVERT_RIBS_MERGED_SHELL_LINK, 'b') or false -- parametri regioni con diverse passate LayerParams.dShellNbrCoasting = EgtGetInfo( s_nPartId, KEY_SHELL_NBR_COASTING, 'd') LayerParams.dShellNbrWipe = EgtGetInfo( s_nPartId, KEY_SHELL_NBR_WIPE, 'd') @@ -52,7 +54,6 @@ local function GetLayerParamsForPathCalc() -- eventuale modifica dei parametri per gestire correttamente il caso spiral vase if LayerParams.bSpiralVase then - LayerParams.nShellsNbr = 1 LayerParams.nFloorNbr = 0 LayerParams.nCeilNbr = 0 end @@ -103,6 +104,29 @@ local function ComputeSurfOffset( nSrf, nGrpId, dOffs) end end +-------------------------------------------------------------------- +local function ComputeCurvePortion( nCrv, dParS, dParE, nGrp, bShortest) + + -- costruisco percorso dParS->dParE + local nCrv1 = EgtCopyGlob( nCrv, nGrp) + EgtTrimCurveStartEndAtParam( nCrv1, dParS, dParE) + -- costruisco percorso dParE->dParS + local nCrv2 = EgtCopyGlob( nCrv, nGrp) + EgtTrimCurveStartEndAtParam( nCrv2, dParE, dParS) + EgtInvertCurve( nCrv2) + + -- considero il tratto con la lunghezza richiesta + local dLen1 = EgtCurveLength( nCrv1) + local dLen2 = EgtCurveLength( nCrv2) + if ( dLen1 > dLen2 - GEO.EPS_SMALL and not bShortest) or ( dLen1 < dLen2 + GEO.EPS_SMALL and bShortest) then + EgtErase( nCrv2) + return nCrv1 + else + EgtErase( nCrv1) + return nCrv2 + end +end + -------------------------------------------------------------------- local function ComputeTrimSurf( nSrf, nGrpId, dStrand, dOverlap) @@ -121,12 +145,12 @@ local function ComputeTrimSurf( nSrf, nGrpId, dStrand, dOverlap) end --------------------------------------------------------------------- -local function GetLayerStartPoint( nLayId, vtSlicing) +local function GetLayerStartPoint( nLayId) -- recupero quota layer local dZ = EgtGetInfo( nLayId, KEY_SLICE_REAL_Z, 'd') local dDeltaZ = EgtGetInfo( nLayId, KEY_SLICE_DELTAZ, 'd') - local frSlicing = Frame3d( ORIG(), vtSlicing) + local frSlicing = Frame3d( ORIG(), s_vtSlicing) local ptOn = Point3d( 0, 0, dZ + dDeltaZ) ptOn:toGlob( frSlicing) @@ -143,7 +167,7 @@ local function GetLayerStartPoint( nLayId, vtSlicing) table.insert( vPtStart, EgtSP( nStartId)) else -- se curva interseco con il piano - local nId, nCnt = EgtPlaneCurveInters( ptOn, vtSlicing, nStartId, nGrpTmp, GDB_RT.GLOB) + local nId, nCnt = EgtPlaneCurveInters( ptOn, s_vtSlicing, nStartId, nGrpTmp, GDB_RT.GLOB) if nId then for i = nId, nId + nCnt - 1 do table.insert( vPtStart, EgtSP( i)) @@ -214,7 +238,7 @@ local function GetPathsFromSurf( nSrfId, sName, nType, nGrpId, vPtStart) end ---------------------------------------------------------------------- -local function VerifyPath( nCrvId, dStrand, vtSlicing, nGrp) +local function VerifyPath( nCrvId, dStrand, nGrp) local _, _, dArea = EgtCurveArea( nCrvId) @@ -236,7 +260,7 @@ local function VerifyPath( nCrvId, dStrand, vtSlicing, nGrp) -- TODO da sistemare con medial axis per curva generica local bSingleStrand = false if EgtCurveIsClosed( nCrvId) then - local nGrpTmp = EgtGroup( nGrp, Frame3d( ORIG(), vtSlicing), GDB_RT.GLOB) + local nGrpTmp = EgtGroup( nGrp, Frame3d( ORIG(), s_vtSlicing), GDB_RT.GLOB) EgtRelocateGlob( nCrvId, nGrpTmp) local frLoc, dDimX, dDimY = EgtCurveMinAreaRectangleXY( nCrvId) if dDimY < 0.5 then @@ -284,6 +308,58 @@ local function VerifyPath( nCrvId, dStrand, vtSlicing, nGrp) return true end +--------------------------------------------------------------------- +local function AdjustTrimSurfExtraAngleChunks( nTrimSurf, dOffs, dStrand) + + if EgtSurfFrChunkCount( nTrimSurf) == 0 then + return + end + + -- calcolo la superficie occupata dalle shell se non ci fossero shell particolari ( extra shells o ribs-merged shells) + local nLaySurf = EgtGetFirstNameInGroup( EgtGetParent( nTrimSurf), LAYER_SRF) + dOffs = dOffs + dStrand * 0.5 + 50 * GEO.EPS_SMALL + local nBaseSurf = ComputeSurfOffset( nLaySurf, EgtGetParent( nTrimSurf), - dOffs) + if not nBaseSurf then + EgtOutLog( 'Warning : AdjustTrimSurfExtraAngleChunks base surf computation failed. TrimSurf may be inaccurate (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + return + elseif nBaseSurf == GDB_ID.NULL then + EgtOutLog( 'Warning : AdjustTrimSurfExtraAngleChunks base surf does not exist. TrimSurf may be inaccurate (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + return + end + local nChunks = EgtSurfFrChunkCount( nBaseSurf) + + -- individuo i chunk della TrimSurf da conservare + local vValidChunks = {} + local nFirstId, nCnt = EgtExplodeSurf( nTrimSurf) + for nId = nFirstId, nFirstId + nCnt - 1 do + -- verifico se è esterno a tutti i chunks di nBaseSurf ( quindi è porzione non riempita tra le shell da eliminare) + local bIsOut = true + for i = 0, nChunks - 1 do + local nRes = EgtSurfFrChunkSimpleClassify( nId, 0, nBaseSurf, i) + if nRes ~= GDB_RC.OUT then + bIsOut = false + break + end + end + + if bIsOut then + EgtErase( nId) + else + -- se compreso nella superficie base va conservato + table.insert( vValidChunks, nId) + end + end + + -- unisco tutti i chunk validi in un'unica superficie + for i = 2, #vValidChunks do + EgtSurfFrAdd( vValidChunks[1], vValidChunks[i]) + EgtErase( vValidChunks[i]) + end + + EgtErase( nBaseSurf) + +end + -------------------------------------------------------------------- ------------------------- INFILL ----------------------------------- -------------------------------------------------------------------- @@ -316,7 +392,7 @@ local function CalcInfillPaths( nLayId, nInfillGrp, LayerParams) if not nTrimSrf then -- errore EgtOutLog( 'Error : creation of Infill region failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of Infill region failed') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of Infill region failed') elseif nTrimSrf == GDB_ID.NULL then EgtOutLog( 'Warning : Infill not possibile (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') else @@ -343,7 +419,7 @@ local function CalcInfillPaths( nLayId, nInfillGrp, LayerParams) EgtSetName( nId, INFILL_CRV) EgtSetInfo( nId, KEY_TYPE, TYPE.INFILL) EgtSetInfo( nId, KEY_ASSOCIATED_SURF, nTrimSrf) - EgtModifyCurveExtrusion( nId, LayerParams.vtSlicing, GDB_RT.GLOB) + EgtModifyCurveExtrusion( nId, s_vtSlicing, GDB_RT.GLOB) end end end @@ -444,7 +520,7 @@ local function ReorderPath( vOldIds, vNewIds) end --------------------------------------------------------------------------- -local function ComputeOffsetShells( nSrf, dStrand, vtSlicing, sName, nType, nGrp, vPtStart, vOldIds, nMaxShells) +local function ComputeOffsetShells( nSrf, dStrand, sName, nType, nGrp, vPtStart, vOldIds, nMaxShells) if nSrf == GDB_ID.NULL then return true end if not nMaxShells then nMaxShells = GEO.INFINITO end @@ -565,12 +641,12 @@ local function FindOptimalZigZagDirection( nSrfId, nBorderSurf, dStrand, nGrp, f end -------------------------------------------------------------------- -local function ComputeZigZagSolidFill( nSrf, dStrand, vtSlicing, sName, nType, nGrp, nBorderSurf) +local function ComputeZigZagSolidFill( nSrf, dStrand, sName, nType, nGrp, nBorderSurf) if nSrf == GDB_ID.NULL then return end local nCopySrf = EgtCopyGlob( nSrf, nGrp) - local frLoc = Frame3d( ORIG(), vtSlicing) + local frLoc = Frame3d( ORIG(), s_vtSlicing) -- analizzo tutti i chunk della superficie da riempire local nFirst, nSrfCnt = EgtExplodeSurf( nCopySrf) @@ -589,7 +665,7 @@ local function ComputeZigZagSolidFill( nSrf, dStrand, vtSlicing, sName, nType, n EgtSetInfo( j, KEY_TYPE, nType) EgtSetInfo( j, KEY_ZIG_ZAG_DIR, vtDir) EgtSetInfo( j, KEY_ZIG_ZAG_INFILL, true) - EgtModifyCurveExtrusion( j, vtSlicing, GDB_RT.GLOB) + EgtModifyCurveExtrusion( j, s_vtSlicing, GDB_RT.GLOB) table.insert( vIds, j) end end @@ -621,7 +697,7 @@ local function CalcSolidFillPath( nLayId, LayerParams, vPtStart, nFillType) if not nSrfToFill then -- errore EgtOutLog( 'Error : creation of SolidFill region failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of SolidFill region failed') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of SolidFill region failed') elseif nSrfToFill == GDB_ID.NULL then EgtOutLog( 'Warning : SolidFill not possibile (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') else @@ -637,12 +713,12 @@ local function CalcSolidFillPath( nLayId, LayerParams, vPtStart, nFillType) local nPathGrp = EgtGetFirstNameInGroup( vCrvGrps[i], PATH_GRP) local nLast = EgtGetLastNameInGroup( nPathGrp, SHELL_CRV .. '*') or EgtGetLastNameInGroup( nPathGrp, EXTRA_SHELL_CRV .. '*') local vOldIds = EgtGetNameInGroup( nPathGrp, EgtGetName( nLast)) - if not ComputeOffsetShells( nSrfToFill, dDist, LayerParams.vtSlicing, INFILL_CRV, TYPE.INFILL, nInfillPathGrp, vPtStart, vOldIds) then + if not ComputeOffsetShells( nSrfToFill, dDist, INFILL_CRV, TYPE.INFILL, nInfillPathGrp, vPtStart, vOldIds) then EgtOutLog( 'Error : creation of SolidFill failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of SolidFill failed') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of SolidFill failed') end elseif nFillType == FILL_TYPE.ZIGZAG then - ComputeZigZagSolidFill( nSrfToFill, dDist, LayerParams.vtSlicing, INFILL_CRV, TYPE.INFILL, nInfillPathGrp) + ComputeZigZagSolidFill( nSrfToFill, dDist, INFILL_CRV, TYPE.INFILL, nInfillPathGrp) end -- avendo riempito la regione, la TotShellTrimSurf non deve esistere @@ -717,7 +793,7 @@ local function VerifyRibsHoles( vIds) end -------------------------------------------------------------------- -local function FindRibsUserLinkDirection( nCrv1, nCrv2, vtSlicing) +local function FindRibsUserLinkDirection( nCrv1, nCrv2) -- stabilisco l'orientamento del link local bCCW = false @@ -737,7 +813,7 @@ local function FindRibsUserLinkDirection( nCrv1, nCrv2, vtSlicing) end -- verifico direzione della normale local vtN = EgtSurfFrNormVersor( nSurf, GDB_ID.ROOT) - if AreSameVectorApprox( vtN, vtSlicing) then + if AreSameVectorApprox( vtN, s_vtSlicing) then bCCW = true end @@ -833,7 +909,7 @@ local function AssignUserLinkInfo( tabUserLink, bCCW, bLoopRib, bSameSide, sName end ------------------------------------------------------------------------ -local function AdjustUserLinkRibs( tUserLink, vRibs, vtSlicing, nSrfInt, nSrfExt, nGrp) +local function AdjustUserLinkRibs( tUserLink, vRibs, nSrfInt, nSrfExt, nGrp) local nGrpTmp = EgtGroup( nGrp) -- gruppo temporaneo per conti local vUsed = {} -- setti di vRibs utilizzati per UserLink @@ -893,7 +969,7 @@ local function AdjustUserLinkRibs( tUserLink, vRibs, vtSlicing, nSrfInt, nSrfExt AssignUserLinkInfo( tabUserLink, bCCW, bLoopRib, bSameSide, sName) -- correggo orientamento del link - bCCW = FindRibsUserLinkDirection( tabUserLink[1].nId, tabUserLink[2].nId, vtSlicing) + bCCW = FindRibsUserLinkDirection( tabUserLink[1].nId, tabUserLink[2].nId) for i = 1, #tabUserLink do local nId = tabUserLink[i].nId EgtSetInfo( nId, KEY_RIBS_USER_LINK_CCW, bCCW) @@ -998,13 +1074,29 @@ local function ReorderHoledRibs( vRibs, tHoles, bInvertOrder) end ------------------------------------------------------------------- -local function AdjustHoledRibs( nTrimmedRibsGrp) +local function AdjustHoledRibs( nTrimmedRibsGrp, nSrfInt, nSrfExt) local vRibs = EgtGetAllInGroup( nTrimmedRibsGrp) if not vRibs then return end -- recupero i loop della superficie del setto local nLoopGrp = EgtGetFirstNameInGroup( s_nPartId, RIBS_LOOP_GRP) + -- estraggo eventuali loop interni dalle superfici di trim + local vLoopInt = {} + local vLoopExt = {} + local vSurfs = { nSrfInt, nSrfExt} + for i = 1, 2 do + if vSurfs[i] then + local nChunk = EgtSurfFrChunkCount( vSurfs[i]) + for nC = 0, nChunk - 1 do + local nRes, nCnt = EgtExtractSurfFrChunkLoops( vSurfs[i], nC, nTrimmedRibsGrp) + if nCnt > 1 then + EgtTableAdd( EgtIf( i == 1, vLoopInt, vLoopExt), nRes + 1, nCnt - 1) + end + EgtErase( nRes) + end + end + end -- individuo catena di setti che è stata interrotta dagli holes partendo dai setti con user link local bHoles = false @@ -1022,10 +1114,18 @@ local function AdjustHoledRibs( nTrimmedRibsGrp) end if not nRefRib then break end local sName = EgtGetName( nRefRib) - - -- verifico se è limitato da un hole + + -- recupero eventuali loop interessati dal setto local nOrigSrfId = EgtGetInfo( nRefRib, KEY_ORIGINAL_SURF, 'i') + local nType = EgtGetInfo( nRefRib, KEY_RIBS_TYPE, 'i') local vLoopIds = EgtGetNameInGroup( nLoopGrp, SURF_LOOP .. tostring( nOrigSrfId)) + if nType == RIB_TYPE.INTERNAL then + EgtJoinTables( vLoopIds, vLoopInt) + elseif nType == RIB_TYPE.EXTERNAL then + EgtJoinTables( vLoopIds, vLoopExt) + end + + -- verifico se è limitato da un hole local ptS = EgtSP( nRefRib, GDB_ID.ROOT) local ptE = EgtEP( nRefRib, GDB_ID.ROOT) local nIdx = FindHoleCurve( ptS, vLoopIds) @@ -1043,7 +1143,7 @@ local function AdjustHoledRibs( nTrimmedRibsGrp) local nCurrRib = vRibs[nAssIdx] local ptRef = EgtIf( bStart, EgtEP( nCurrRib, GDB_ID.ROOT), EgtSP( nCurrRib, GDB_ID.ROOT)) - local bUserLink = EgtGetInfo( nCurrRib, KEY_RIBS_USER_LINK, 'b') or false + local bUserLink = EgtGetInfo( nCurrRib, KEY_RIBS_USER_LINK, 'b') or false if not bUserLink then -- se non è coinvolto in altro user link assegno lo stesso orientamento e lo stesso nome if bStartOrig == bStart then @@ -1107,10 +1207,19 @@ local function AdjustHoledRibs( nTrimmedRibsGrp) end end end + + -- elimino loop dello slice utilizzati + for i = 1, #vLoopInt do + EgtErase( vLoopInt[i]) + end + for i = 1, #vLoopExt do + EgtErase( vLoopExt[i]) + end + end ------------------------------------------------------------------- -local function TrimRibs( vRibs, nRibsGrp, nSrfTrimInt, nSrfTrimExt, vtSlicing) +local function TrimRibs( vRibs, nRibsGrp, nSrfTrimInt, nSrfTrimExt) -- trim dei setti local nTrimmedRibsGrp = EgtGroup( nRibsGrp) @@ -1155,7 +1264,7 @@ local function TrimRibs( vRibs, nRibsGrp, nSrfTrimInt, nSrfTrimExt, vtSlicing) else -- UserLink tUserLink[vRibs[i]] = {} - local bCCW = FindRibsUserLinkDirection( nCrv, nCrv + 1, vtSlicing) + local bCCW = FindRibsUserLinkDirection( nCrv, nCrv + 1) -- sistemo le info for j = 0, nCnt - 1 do EgtSetInfo( nCrv + j, KEY_START_RIB, vRibs[i]) @@ -1174,10 +1283,10 @@ local function TrimRibs( vRibs, nRibsGrp, nSrfTrimInt, nSrfTrimExt, vtSlicing) end -- verifico e sistemo UserLink - AdjustUserLinkRibs( tUserLink, vSingleRibs, vtSlicing, nSrfTrimInt, nSrfTrimExt, nRibsGrp) + AdjustUserLinkRibs( tUserLink, vSingleRibs, nSrfTrimInt, nSrfTrimExt, nRibsGrp) -- verifico se necessari aggiustamenti per holes - AdjustHoledRibs( nTrimmedRibsGrp) + AdjustHoledRibs( nTrimmedRibsGrp, nSrfTrimInt, nSrfTrimExt) return nTrimmedRibsGrp end @@ -1331,7 +1440,7 @@ local function ComputeTrimSurfWithOverlapsForRibs( vIds, nGrp, nSrfInt, nSrfExt, local nTrimSurf, bNoOverlap = ComputeTrimSurf( nSrfInt, nGrp, dStrand, dOverlap) if not nTrimSurf then EgtOutLog( 'Error : creation of trim region for internal rib failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of trim region for rib failed') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of trim region for rib failed') elseif nTrimSurf == GDB_ID.NULL then EgtOutLog( 'Warning : rib not possibile (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') else @@ -1353,7 +1462,7 @@ local function ComputeTrimSurfWithOverlapsForRibs( vIds, nGrp, nSrfInt, nSrfExt, local nTrimSurf, bNoOverlap = ComputeTrimSurf( nSrfExt, nGrp, - dStrand, dOverlap) if not nTrimSurf then EgtOutLog( 'Error : creation of trim region for external rib failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of trim region for external rib failed') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of trim region for external rib failed') else if bNoOverlap then EgtOutLog( 'Warning : external rib without correct overlap (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') @@ -1544,7 +1653,7 @@ local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, nOffsGrp, nLoopGrp local nSrf = EgtSurfFrFatCurve( nOffsGrp, nCrv1, dOffs, false) if not nSrf then EgtOutLog( 'Error : ribs intersection failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing ribs intersection') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing ribs intersection') return end for i = 1, #vOffs2 do @@ -1645,7 +1754,7 @@ local function UpdateSplitOrder( nCrv, tInters, nOffsGrp) end ------------------------------------------------------------------ -local function HandleRibsIntersections( nRibsGrp, nOffsGrp, nRibsPathGrp, vtSlicing, nSrfInt, nSrfExt, bAllTwoStrands, vTypeSequence, nLoopGrp, tSurfOffs) +local function HandleRibsIntersections( nRibsGrp, nOffsGrp, nRibsPathGrp, nSrfInt, nSrfExt, bAllTwoStrands, vTypeSequence, nLoopGrp, tSurfOffs) local bSpecialCase = false local vOffsIds = EgtGetNameInGroup( nRibsPathGrp, RIBS_CRV .. '*') -- passate dei setti @@ -1658,7 +1767,7 @@ local function HandleRibsIntersections( nRibsGrp, nOffsGrp, nRibsPathGrp, vtSlic end -- creo un gruppo con frame locale per calcolare le intersezioni ( è il piano XY locale dove calcolare intersezioni) - local frLoc = Frame3d( ORIG(), vtSlicing) + local frLoc = Frame3d( ORIG(), s_vtSlicing) local nGrpTmp = EgtGroup( nRibsGrp, frLoc, GDB_RT.GLOB) local bInters = false @@ -2245,7 +2354,24 @@ local function ReorderRibsInters2Shells( nOffsGrp, bInvertOrder) end ------------------------------------------------------------------- -local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart) +local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart, bIgnoreMergedRibs) + + -- recupero i setti + local vAllRibs = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') + local vOrigRibs = {} + if bIgnoreMergedRibs then + -- escludo i setti che sono stati già uniti nel percorso delle shell + for i = 1, #vAllRibs do + local nType = EgtGetInfo( vAllRibs[i], KEY_RIBS_TYPE, 'i') + local bMergeWithShells = EgtGetInfo( vAllRibs[i], KEY_RIBS_MERGE_WITH_SHELLS, 'b') or false + if not ( nType == RIB_TYPE.INTERNAL and bMergeWithShells) then + table.insert( vOrigRibs, vAllRibs[i]) + end + end + else + vOrigRibs = vAllRibs + end + if #vOrigRibs == 0 then return end -- stabilisco ordine di realizzazione delle varie tipologie local vTypeSequence = {} @@ -2260,8 +2386,6 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart) vTypeSequence[RIB_TYPE.SUPPORT] = i end end - - local vOrigRibs = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') -- verifico se tutte le costolature vengono fatte con 2 passate e con lo stesso strand local bAllTwoStrands = true @@ -2311,7 +2435,7 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart) nSrfExt = ComputeSurfOffset( nSrfLay, vCrvGrps[i], LayerParams.dOffs) if not nSrfExt then EgtOutLog( 'Error : creation of trim region for external ribs failed. Errors may occur also with internal user-linked ribs (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing trim region for external ribs') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing trim region for external ribs') nTotSrfExt = nil else if nTotSrfExt == GDB_ID.NULL then @@ -2320,14 +2444,14 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart) if not EgtSurfFrAdd( nTotSrfExt, nSrfExt) then nTotSrfExt = nil EgtOutLog( 'Error : creation of trim region for external ribs failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing trim region for external ribs') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing trim region for external ribs') end end end end -- trim grossolano dei setti - local nTrimGrp = TrimRibs( vOrigRibs, nRibsGrp, nSrfExt, EgtIf( i == #vCrvGrps, nTotSrfInt, GDB_ID.NULL), LayerParams.vtSlicing) + local nTrimGrp = TrimRibs( vOrigRibs, nRibsGrp, nSrfExt, EgtIf( i == #vCrvGrps, nTotSrfInt, GDB_ID.NULL)) -- calcolo offset orientati local nOffsGrp = ComputeRibsOrientedOffset( nTrimGrp) @@ -2404,7 +2528,7 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart) end -- gestisco eventuali intersezioni fra costolature - local bInters, bSpecialCase = HandleRibsIntersections( nRibsGrp, nOffsGrp, nRibsPathGrp, LayerParams.vtSlicing, nSrfInt, EgtIf( i == #vCrvGrps, nTotSrfExt, nil), + local bInters, bSpecialCase = HandleRibsIntersections( nRibsGrp, nOffsGrp, nRibsPathGrp, nSrfInt, EgtIf( i == #vCrvGrps, nTotSrfExt, nil), bAllTwoStrands, vTypeSequence, nLoopGrp, tSurfOffs) EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_INTERS, bInters) EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_SPECIAL_CASE, bSpecialCase) @@ -2420,7 +2544,7 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart) -- sistemo le quote dei loop per CalcToolPath local vLoopIds = EgtGetAllInGroup( nLoopGrp) or {} for i = 1, #vLoopIds do - EgtMove( vLoopIds[i], LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) + EgtMove( vLoopIds[i], LayerParams.dLayHeight * s_vtSlicing, GDB_RT.GLOB) end -- elimino superficie per check @@ -2432,6 +2556,792 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart) end end +-------------------------------------------------------------------- +--------------------- RIBS-MERGED SHELLS --------------------------- +-------------------------------------------------------------------- +local function PrepareShells( vOrigShells, bExtraShell) + + if #vOrigShells == 0 then + return vOrigShells + end + + local vIds = vOrigShells + -- se sono extra shells calcolo le curve chiuse da cui si sono generate + if bExtraShell then + local nGrp = EgtGetParent( vOrigShells[1]) + local dOffs = EgtGetInfo( vOrigShells[1], KEY_CRV_OFFSET, 'd') + local nLaySrf = EgtGetFirstNameInGroup( EgtGetParent( nGrp), LAYER_SRF) + local nSrf = ComputeSurfOffset( nLaySrf, EgtGetParent( vOrigShells[1]), - dOffs) + if not nSrf or nSrf == GDB_ID.NULL then + EgtOutLog( 'Error : error in computing complete shell for shell-merged ribs (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in ribs-merged shells') + return + end + -- estraggo i loop + vIds = GetPathsFromSurf( nSrf, '', TYPE.EXTRA_SHELL, EgtGetParent( vOrigShells[1])) + EgtErase( nSrf) + end + + -- associo loop esterni ai loop interni + local tShells = {} + if #vIds == 1 then + tShells = {{vIds[1]}} + else + -- individuo i loop esterni e i loop interni + local vExt = {} + local vInt = {} + for i = 1, #vIds do + local bInternalLoop = EgtGetInfo( vIds[i], KEY_INTERNAL_SRF_LOOP, 'b') or false + table.insert( EgtIf( bInternalLoop, vInt, vExt), vIds[i]) + end + + if #vInt == 0 then + -- se solo loop esterni + for i = 1, #vExt do + table.insert( tShells, {vExt[i]}) + end + elseif #vExt == 1 then + -- se un solo loop esterno, tutti i loop interni sono riferiti ad esso + local vCrvs = { vExt[1]} + for i = 1, #vInt do + table.insert( vCrvs, vInt[i]) + end + tShells = { vCrvs} + else + -- associo ad ogni loop esterno, gli interni corrispondenti + local vUsed = {} -- per tenere traccia se il loop è già stato associato ad un esterno + for i = 1, #vInt do + vUsed[i] = false + end + for i = 1, #vExt do + local vCrvs = { vExt[i]} + local nSrfTmp = EgtSurfFlatRegion( EgtGetParent( vOrigShells[1]), vExt[i]) + for j = 1, #vInt do + if not vUsed[j] then + local nRes = EgtCurveWithRegionClassify( vInt[j], nSrfTmp) + if nRes == GDB_CRC.IN then + table.insert( vCrvs, vInt[j]) + vUsed[j] = true + end + end + end + table.insert( tShells, vCrvs) + EgtErase( nSrfTmp) + end + end + end + + return tShells +end + +-------------------------------------------------------------------- +local function PrepareAuxSurfsForRibsMerge( nGrp, vShells, dStrand, LayerParams) + + -- superficie definita dalla shell + local nSrfShell = EgtSurfFlatRegion( nGrp, vShells) + if not nSrfShell then + EgtOutLog( 'Error : error in computing shell region for shell-merged ribs (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing ribs-merged shells') + return false + end + EgtSetName( nSrfShell, SHELL_SURF) + + -- superficie per trim grossolano dei setti + local nCrvGrp = EgtGetParent( EgtGetParent( nGrp)) + local nSrfCoarseTrim = GDB_ID.NULL + local nSrfLay = EgtGetFirstNameInGroup( nCrvGrp, LAYER_SRF) + if nSrfLay then + nSrfCoarseTrim = ComputeSurfOffset( nSrfLay, nGrp, LayerParams.dOffs) + if not nSrfCoarseTrim then + EgtOutLog( 'Error : error in computing coarse trim region for shell-merged ribs (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing ribs-merged shells') + return false + end + EgtSetName( nSrfCoarseTrim, COARSE_TRIM_SURF) + else + return false + end + + -- superficie per trim corretto dei setti + local nTotShellTrimSurf = EgtGetFirstNameInGroup( nCrvGrp, TOT_SHELL_TRIM_SURF) + if not nTotShellTrimSurf then + EgtOutLog( 'Warning : not enough space for merging ribs with shells (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + return false + end + local nTrimSurf = ComputeSurfOffset( nTotShellTrimSurf, nGrp, - ( 0.5 - LayerParams.dStrandOverlap / 100) * dStrand) + if not nTrimSurf then + -- errore nel calcolo + EgtOutLog( 'Error : error in computing trim region for shell-merged ribs (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing ribs-merged shells') + return false + elseif nTrimSurf == GDB_ID.NULL then + -- non c'è spazio per creare ribs-merged shell, realizzo solo la shell + EgtOutLog( 'Warning : not enough space for merging ribs with shells (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + return false + end + + -- creo il gruppo con i loop delle superfici + local nLoopGrp = EgtGroup( nGrp) + EgtSetName( nLoopGrp, LOOP_GRP) + for i = 1, #vShells do + local nSrfLoop = EgtCopyGlob( vShells[i], nLoopGrp) + EgtSetName( nSrfLoop, SURF_LOOP) + end + GetPathsFromSurf( nTrimSurf, TRIM_SURF_LOOP, nil, nLoopGrp) + + return true +end + +-------------------------------------------------------------------- +local function HandleRibsIntersectionForMergedRibs( vOrigRibs, nOffsGrp, nRibsGrp, nLoopGrp, dStrand, dOverlap) + + local vRibsIds = {} + -- ignoro setti che non hanno passate corrispondenti + for i = 1, #vOrigRibs do + local vOffs = EgtGetNameInGroup( nRibsGrp, EgtGetName( vOrigRibs[i])) + if vOffs then table.insert( vRibsIds, vOrigRibs[i]) end + end + + -- creo un gruppo con frame locale per calcolare le intersezioni ( è il piano XY locale dove calcolare intersezioni) + local frLoc = Frame3d( ORIG(), s_vtSlicing) + local nGrpTmp = EgtGroup( nRibsGrp, frLoc, GDB_RT.GLOB) + + local nShellSrf = EgtGetFirstNameInGroup( EgtGetParent( nRibsGrp), SHELL_SURF) + local nTrimSrf = EgtGetFirstNameInGroup( EgtGetParent( nRibsGrp), TOT_SHELL_TRIM_SURF) + local nShellSrfInters = EgtCopyGlob( nShellSrf, nLoopGrp) + local nTrimSrfInters = EgtCopyGlob( nTrimSrf, nLoopGrp) + + local bIntersection = false + for i = 1, #vRibsIds do + -- verifico se interseca uno dei setti successivi + for j = i + 1, #vRibsIds do + + local bInters, bForceCutOnCrv1 = VerifyRibsIntersection( vRibsIds[i], vRibsIds[j], RIB_TYPE.INTERNAL, RIB_TYPE.INTERNAL, nShellSrf, nil, nGrpTmp, nOffsGrp) + if bInters then + bIntersection = true + local nCrv1 = vRibsIds[i] -- curva principale che non viene tagliata + local nCrv2 = vRibsIds[j] -- curve secondaria da modificare + if bForceCutOnCrv1 then + nCrv1, nCrv2 = nCrv2, nCrv1 + end + + -- calcolo la superficie della curva principale ( nCrv1) da usare per trim + local nShells = EgtGetInfo( nCrv1, KEY_RIBS_SHELLS_NBR, 'i') + local dOffs = (( nShells + 1) * 0.5 - dOverlap / 100) * dStrand + local nSrf = EgtSurfFrFatCurve( nGrpTmp, nCrv1, dOffs, false) + if not nSrf then + EgtOutLog( 'Error : EgtSurfFrFatCurve for shell-merged ribs intersection failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in ribs-merged shells intersection') + return false + end + -- estraggo il loop + local nLoop, nCnt = EgtExtractSurfFrChunkLoops( nSrf, 0, nGrpTmp) + + -- taglio il setto secondario ( nCrv2) + local vOffs2 = EgtGetNameInGroup( nRibsGrp, EgtGetName( nCrv2)) or {} + for i = 1, #vOffs2 do + + local nId, nCnt = EgtTrimCurveWithRegion( vOffs2[i], nSrf, false, true) + if nCnt == 0 then + -- il setto scompare + EgtErase( nId) + elseif nCnt > 1 then + -- verifico se posso ricollegare i tratti ottenuti per formare un setto unico + for nCrv = nId, nId + nCnt - 2 do + local dParS = EgtCurveParamAtPoint( nLoop, EgtEP( nCrv, GDB_ID.ROOT), 100 * GEO.EPS_SMALL, GDB_RT.GLOB) + local dParE = EgtCurveParamAtPoint( nLoop, EgtSP( nCrv + 1, GDB_ID.ROOT), 100 * GEO.EPS_SMALL, GDB_RT.GLOB) + local nLinkId = ComputeCurvePortion( nLoop, dParS, dParE, nRibsGrp, true) + if nLinkId then + local nRes = EgtCurveWithRegionClassify( nLinkId, nShellSrf) + if nRes == GDB_CRC.IN then + EgtAddCurveCompoCurve( nCrv + 1, nLinkId, true, false) + EgtAddCurveCompoCurve( nCrv + 1, nCrv, true, false) + else + -- tipo di intersezione non permessa + EgtOutLog( 'Error : shell-merged ribs intersect in a non valid way (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in ribs-merged shells intersection') + return false + end + end + end + end + end + + -- aggiorno le superfici da utilizzare per creare collegamenti + if not EgtSurfFrSubtract( nShellSrfInters, nSrf) or not EgtSurfFrSubtract( nTrimSrfInters, nSrf) then + EgtOutLog( 'Error : EgtSurfFrSubtract with shell-merged ribs intersection failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in ribs-merged shells intersection') + return false + end + EgtErase( nSrf) + end + end + end + + -- se ho trovato intersezioni estraggo i loop delle superfici ausiliarie + if bIntersection then + GetPathsFromSurf( nShellSrfInters, SURF_LOOP, nil, nLoopGrp) + GetPathsFromSurf( nTrimSrfInters, TRIM_SURF_LOOP, nil, nLoopGrp) + end + EgtErase( nShellSrfInters) + EgtErase( nTrimSrfInters) + EgtErase( nGrpTmp) + + return true +end + +-------------------------------------------------------------------- +local function PrepareRibsForMerge( vOrigRibs, nGrp, dStrand, dOverlap, bInvertRibsOrder) + + -- verifico se sono presenti buchi che possono essere chiusi + VerifyRibsHoles( vOrigRibs) + + -- trim grossolano dei setti + local nSrfCoarseTrim = EgtGetFirstNameInGroup( nGrp, COARSE_TRIM_SURF) + local nTrimGrp = TrimRibs( vOrigRibs, nGrp, nSrfCoarseTrim, GDB_ID.NULL) + + -- calcolo offset orientati + local nOffsGrp = ComputeRibsOrientedOffset( nTrimGrp) + + -- trim con la regione della shell + local nRibsGrp = EgtGroup( nGrp) + local nSrfShell = EgtGetFirstNameInGroup( nGrp, SHELL_SURF) + local nSrfTrim = EgtGetFirstNameInGroup( nGrp, TOT_SHELL_TRIM_SURF) + local vRibs = EgtGetAllInGroup( nOffsGrp) + for i = 1, #vRibs do + -- copio i setti nel gruppo dei conti + local nCopy = EgtCopyGlob( vRibs[i], nRibsGrp) + -- trim + local nRes, nCnt = EgtTrimCurveWithRegion( nCopy, nSrfShell, true, true) + if nCnt == 0 then + EgtErase( nRes) + end + for nId = nRes, nRes + nCnt - 1 do + -- verifico se si trova nella regione di trim + local nClassif = EgtCurveWithRegionClassify( nId, nSrfTrim) + if nClassif ~= GDB_CRC.INTERS and nClassif ~= GDB_CRC.IN then + EgtErase( nId) + end + end + end + local vIds = EgtGetAllInGroup( nRibsGrp) or {} + if #vIds == 0 then return end + + -- gestione delle intersezioni + local nLoopGrp = EgtGetFirstNameInGroup( nGrp, LOOP_GRP) + if not HandleRibsIntersectionForMergedRibs( vOrigRibs, nOffsGrp, nRibsGrp, nLoopGrp, dStrand, dOverlap) then + return + end + + -- ordinamento + vIds = EgtGetAllInGroup( nRibsGrp) + ShortestPathForRibs( vIds, nRibsGrp, bInvertRibsOrder) + + -- elimino elementi superflui per passaggi successivi + EgtErase( nTrimGrp) + EgtErase( nOffsGrp) + EgtErase( nSrfCoarseTrim) + EgtErase( nSrfShell) + + return nRibsGrp +end + +-------------------------------------------------------------------- +local function CreateRibsMergedShellLink( nGrp, vLoops, nCurr, nNext, nCheckGrp) + + for i = 1, #vLoops do + local dParS = EgtCurveParamAtPoint( vLoops[i], EgtEP( nCurr, GDB_ID.ROOT), 100 * GEO.EPS_SMALL, GDB_RT.GLOB) + local dParE = EgtCurveParamAtPoint( vLoops[i], EgtSP( nNext, GDB_ID.ROOT), 100 * GEO.EPS_SMALL, GDB_RT.GLOB) + if dParS and dParE then + + -- cerco il più corto fra i percorsi dParS->dParE e dParE->dParS + local nLinkId = ComputeCurvePortion( vLoops[i], dParS, dParE, nGrp, true) + + -- verifico sia sensato : + if nCheckGrp then + local nCurrCheck = EgtGetInfo( nCurr, KEY_ASSOCIATED_CRVS, 'i') + local nNextCheck = EgtGetInfo( nNext, KEY_ASSOCIATED_CRVS, 'i') + local frLoc = Frame3d( ORIG(), s_vtSlicing) + local nGrpLoc = EgtGroup( nGrp, frLoc, GDB_RT.GLOB) + + -- a) verifico direzione + -- verifico se interseca uno dei due setti in un altro punto oltre all'estremo interessato dal collegamento + local nRes1, nPntCnt1, nCrvCnt1 = EgtCurveCurveInters( nCurrCheck, nLinkId, nGrpLoc) + local nRes2, nPntCnt2, nCrvCnt2 = EgtCurveCurveInters( nNextCheck, nLinkId, nGrpLoc) + if nPntCnt1 > 1 or nPntCnt2 > 1 then + EgtOutLog( 'Error : creation of ribs-merged shells failed for inconsistent ribs directions (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in ribs-merged shells (inconsistent ribs direction)') + EgtErase( nLinkId) + EgtErase( nGrpLoc) + return + end + + -- b) verifico ordinamento + -- verifico se interseca uno degli altri setti + local vCheckIds = EgtGetAllInGroup( nCheckGrp) or {} + for i = 1, #vCheckIds do + if vCheckIds[i] ~= nCurrCheck and vCheckIds[i] ~= nNextCheck then + local nRes, nPntCnt, nCrvCnt = EgtCurveCurveInters( vCheckIds[i], nLinkId, nGrpLoc) + if nPntCnt > 0 or nCrvCnt > 0 then + EgtOutLog( 'Error : creation of ribs-merged shells failed for inconsistent ribs order (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in ribs-merged shells (inconsistent ribs order)') + EgtErase( nLinkId) + EgtErase( nGrpLoc) + return + end + end + end + EgtErase( nGrpLoc) + end + + return nLinkId + end + end + + -- se sono passate relative allo stesso setto potrei collegarle con tratto lineare anche se non poggiano sulle curve di bordo + local nOrig1 = EgtGetInfo( nCurr, KEY_ORIGINAL_RIB, 'i') + local nOrig2 = EgtGetInfo( nNext, KEY_ORIGINAL_RIB, 'i') + local nSplit1 = EgtGetInfo( nCurr, KEY_SPLIT_ID, 'i') or 0 + local nSplit2 = EgtGetInfo( nNext, KEY_SPLIT_ID, 'i') or 0 + if nOrig1 == nOrig2 and nSplit1 == nSplit2 then + local nLinkId = EgtCurveCompoFromPoints( nGrp, {EgtEP( nCurr, GDB_ID.ROOT), EgtSP( nNext, GDB_ID.ROOT)}, GDB_RT.GLOB) + return nLinkId + end + + -- se non ho creato il link errore + EgtOutLog( 'Error : creation of ribs-merged shells link failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in ribs-merged shells (ribs link not possible)') + return +end + +-------------------------------------------------------------------- +local function CreateRibsMergedShellLastLink( vShells, vRibs, nGrp, bInvert) + + for i = 1, #vShells do + + local dParS = EgtCurveParamAtPoint( vShells[i], EgtSP( vRibs[1], GDB_ID.ROOT), 100 * GEO.EPS_SMALL, GDB_RT.GLOB) + local dParE = EgtCurveParamAtPoint( vShells[i], EgtEP( vRibs[#vRibs], GDB_ID.ROOT), 100 * GEO.EPS_SMALL, GDB_RT.GLOB) + if dParS and dParE then + + local nLink = EgtCopyGlob( vShells[i], nGrp) + if bInvert then + -- conservo tratto dParS->dParE + EgtTrimCurveStartEndAtParam( nLink, dParS, dParE) + else + -- conservo tratto dParE->dParS + EgtTrimCurveStartEndAtParam( nLink, dParE, dParS) + end + + -- sistemo i setti che hanno tratti nella regione occupata dal last link + local nTrimSurf = EgtGetFirstNameInGroup( nGrp, TOT_SHELL_TRIM_SURF) + local dStrand = EgtGetInfo( vRibs[1], KEY_RIBS_STRAND, 'd') + local nLoopGrp = EgtGetFirstNameInGroup( nGrp, LOOP_GRP) + local vLoops = EgtGetNameInGroup( nLoopGrp, TRIM_SURF_LOOP) + local nLinkSrf = EgtSurfFrFatCurve( nGrp, nLink, dStrand, false) + for i = 1, #vRibs do + -- individuo i tratti del setto esterni alla superficie di trim + local nCopyCrv = EgtCopyGlob( vRibs[i], nGrp) + local nCrv, nCnt = EgtTrimCurveWithRegion( nCopyCrv, nTrimSurf, false, false) + if nCrv then + for nId = nCrv, nCrv + nCnt - 1 do + -- ignoro i tratti esterni che corrispondono allo start e all'end della curva + if not AreSamePointApprox( EgtSP( nId), EgtSP( vRibs[i])) and not AreSamePointApprox( EgtEP( nId), EgtEP( vRibs[i])) then + -- verifico se giace nella regione occupata dal last link + local nRes = EgtCurveWithRegionClassify( nId, nLinkSrf) + if nRes ~= GDB_CRC.OUT then + local nOtherPart = EgtCopyGlob( vRibs[i], nGrp) + local dPar1 = EgtCurveParamAtPoint( vRibs[i], EgtSP( nId, GDB_ID.ROOT), 100 * GEO.EPS_SMALL, GDB_RT.GLOB) + local dPar2 = EgtCurveParamAtPoint( vRibs[i], EgtEP( nId, GDB_ID.ROOT), 100 * GEO.EPS_SMALL, GDB_RT.GLOB) + EgtTrimCurveEndAtParam( vRibs[i], dPar1) + EgtTrimCurveStartAtParam( nOtherPart, dPar2) + local nPartLink = CreateRibsMergedShellLink( nGrp, vLoops, vRibs[i], nOtherPart) + EgtAddCurveCompoCurve( vRibs[i], nPartLink) + EgtAddCurveCompoCurve( vRibs[i], nOtherPart) + end + end + EgtErase( nId) + end + end + end + EgtErase( nLinkSrf) + return nLink + end + end + + -- se non ho trovato curva per il link segnalo errore + EgtOutLog( 'Error : creation of ribs-merged shells main link failed. Ribs not ending on same shell (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing ribs-merged shells (ribs link not possible)') + +end + +-------------------------------------------------------------------- +local function TrimCurveExtremity( nCrv, nTrimSrf, bStartOrEnd, nGrp) + + local nCopyCrv = EgtCopyGlob( nCrv, nGrp) + local nRes, nCnt = EgtTrimCurveWithRegion( nCopyCrv, nTrimSrf, true, false) + + if nRes then + -- recupero estremi di interesse + local nResCrv = EgtIf( bStartOrEnd, nRes, nRes + nCnt - 1) + local ptRefRes = EgtIf( bStartOrEnd, EgtSP( nResCrv, GDB_ID.ROOT), EgtEP( nResCrv, GDB_ID.ROOT)) + local ptRefCrv = EgtIf( bStartOrEnd, EgtSP( nCrv, GDB_ID.ROOT), EgtEP( nCrv, GDB_ID.ROOT)) + -- se estremi coincidenti significa che il trim era relativo all'altro estremo + if not AreSamePointApprox( ptRefRes, ptRefCrv) then + -- trim della curva + local dPar = EgtCurveParamAtPoint( nCrv, ptRefRes, 100 * GEO.EPS_SMALL, GDB_RT.GLOB) + if not dPar then return false end + if bStartOrEnd then + EgtTrimCurveStartAtParam( nCrv, dPar) + else + EgtTrimCurveEndAtParam( nCrv, dPar) + end + end + end + + EgtErase( nCopyCrv) + for nId = nRes, nRes + nCnt - 1 do + EgtErase( nId) + end +end + +-------------------------------------------------------------------- +local function AdjustRibsMergedExtraShellLink( nLinkId, vExtraShells, nGrp) + + local frLoc = Frame3d( ORIG(), s_vtSlicing) + local nGrpLoc = EgtGroup( nGrp, frLoc) + + for i = 1, #vExtraShells do + -- devo conservare solo le intersezioni fra link e extra shell + local nRes, nPntCnt, nCrvCnt = EgtCurveCurveInters( nLinkId, vExtraShells[i], nGrpLoc) + if nRes then + for nId = nRes + nPntCnt, nRes + nPntCnt + nCrvCnt - 1 do + EgtRelocateGlob( nId, nGrp) + end + end + end + + -- cancello il link originale + EgtErase( nLinkId) + EgtErase( nGrpLoc) +end + +-------------------------------------------------------------------- +local function CreateRibsMergedShellCurve( nGrp, nRibsGrp, vShells, vOrigShells, dStrand, LayerParams, bExtraShell) + + local vOrigRibs = EgtGetAllInGroup( nRibsGrp) + local vRibs = {} + for i = 1, #vOrigRibs do + local nCopy = EgtCopyGlob( vOrigRibs[i], nGrp) + EgtSetInfo( nCopy, KEY_ASSOCIATED_CRVS, vOrigRibs[i]) + table.insert( vRibs, nCopy) + end + + local nLoopGrp = EgtGetFirstNameInGroup( nGrp, LOOP_GRP) + local nTrimSurf = EgtGetFirstNameInGroup( nGrp, TOT_SHELL_TRIM_SURF) + + -- creo ultimo link + local nLastLink = CreateRibsMergedShellLastLink( vShells, vRibs, nGrp, LayerParams.bInvertRibsMergedShellLink) + if not nLastLink then return false end + + -- creo collegamenti interni + for i = 1, #vRibs - 1 do + local nCurr = vRibs[i] + local nNext = vRibs[i+1] + + -- verifico se posso collegare sulla shell + local dPar1 = EgtCurveParamAtPoint( nLastLink, EgtEP( nCurr, GDB_ID.ROOT), 100 * GEO.EPS_SMALL, GDB_RT.GLOB) + local dPar2 = EgtCurveParamAtPoint( nLastLink, EgtSP( nNext, GDB_ID.ROOT), 100 * GEO.EPS_SMALL, GDB_RT.GLOB) + local vLoops + local bLinkOnShell = false + if dPar1 or dPar2 then + -- il collegamento sulla shell non è fattibile, quindi trimmo opportunamente i setti in modo che finiscano sulla curva di trim + TrimCurveExtremity( nCurr, nTrimSurf, false, nGrp) + TrimCurveExtremity( nNext, nTrimSurf, true, nGrp) + vLoops = EgtGetNameInGroup( nLoopGrp, TRIM_SURF_LOOP) + else + bLinkOnShell = true + vLoops = EgtGetNameInGroup( nLoopGrp, SURF_LOOP) + end + + -- creo il link + local nLinkId = CreateRibsMergedShellLink( nGrp, vLoops, nCurr, nNext, nRibsGrp) + if not nLinkId then + return false + else + -- se fatto sulla shell verifico non si sovrapponga al last link ( caso di setti che terminano su intersezione con altro setto) + if bLinkOnShell then + + local frLoc = Frame3d( ORIG(), s_vtSlicing) + local nGrpLoc = EgtGroup( nGrp, frLoc, GDB_RT.GLOB) + local nRes = EgtCurveCurveInters( nLinkId, nLastLink, nGrpLoc) + if nRes then + -- se si sovrappone tento con link sul trim + EgtErase( nLinkId) + vLoops = EgtGetNameInGroup( nLoopGrp, TRIM_SURF_LOOP) + nLinkId = CreateRibsMergedShellLink( nGrp, vLoops, nCurr, nNext, nRibsGrp) + if not nLinkId then + return false + end + bLinkOnShell = false + end + EgtErase( nGrpLoc) + end + + -- verifico se necessari aggiustamenti per extra shell + if bExtraShell and bLinkOnShell then + AdjustRibsMergedExtraShellLink( nLinkId, vOrigShells, nGrp) + end + end + end + + if bExtraShell then + AdjustRibsMergedExtraShellLink( nLastLink, vOrigShells, nGrp) + end + + -- elimino le curve inutili e le superfici + EgtErase( nRibsGrp) + EgtErase( nTrimSurf) + EgtErase( nLoopGrp) + + return true +end + +-------------------------------------------------------------------- +local function AssignRibsMergedExtraShellsLeadOutInfo( nCrv, vShells, LayerParams) + + local vCoastLen = { LayerParams.dShellNbrCoasting, LayerParams.dShellNbrCoasting} + local vWipeLen = { LayerParams.dShellNbrWipe, LayerParams.dShellNbrWipe} + local vWipeDir = { LayerParams.dShellNbrWipeDir, LayerParams.dShellNbrWipeDir} + + local bFoundS = false + local bFoundE = false + local ptS = EgtSP( nCrv, GDB_ID.ROOT) + local ptE = EgtEP( nCrv, GDB_ID.ROOT) + + for i = 1, #vShells do + -- recupero le info della shell attuale + local vShellCoastLen = EgtGetInfo( vShells[i], KEY_EXTRA_SHELL_COASTING, 'vd') + local vShellWipeLen = EgtGetInfo( vShells[i], KEY_EXTRA_SHELL_WIPE, 'vd') + local vShellWipeDir = EgtGetInfo( vShells[i], KEY_EXTRA_SHELL_WIPE_DIR, 'vd') + + -- verifico se posso usarle per settare info per lo start point + if not bFoundS then + if AreSamePointApprox( ptS, EgtSP( vShells[i], GDB_ID.ROOT)) then + bFoundS = true + vCoastLen[1] = vShellCoastLen[1] + vWipeLen[1] = vShellWipeLen[1] + vWipeDir[1] = vShellWipeDir[1] + elseif AreSamePointApprox( ptS, EgtEP( vShells[i], GDB_ID.ROOT)) then + bFoundS = true + vCoastLen[1] = vShellCoastLen[2] + vWipeLen[1] = vShellWipeLen[2] + vWipeDir[1] = vShellWipeDir[2] + end + end + + -- verifico se posso usarle per settare info per l'end point + if not bFoundE then + if AreSamePointApprox( ptE, EgtSP( vShells[i], GDB_ID.ROOT)) then + bFoundE = true + vCoastLen[2] = vShellCoastLen[1] + vWipeLen[2] = vShellWipeLen[1] + vWipeDir[2] = vShellWipeDir[1] + elseif AreSamePointApprox( ptE, EgtEP( vShells[i], GDB_ID.ROOT)) then + bFoundE = true + vCoastLen[2] = vShellCoastLen[2] + vWipeLen[2] = vShellWipeLen[2] + vWipeDir[2] = vShellWipeDir[2] + end + end + + -- se ho trovato sia start sia end termino la ricerca + if bFoundS and bFoundE then + break + end + end + + -- setto le info alla nuova shell + EgtSetInfo( nCrv, KEY_EXTRA_SHELL_COASTING, vCoastLen) + EgtSetInfo( nCrv, KEY_EXTRA_SHELL_WIPE, vWipeLen) + EgtSetInfo( nCrv, KEY_EXTRA_SHELL_WIPE_DIR, vWipeDir) +end + +-------------------------------------------------------------------- +local function UpdateTrimSurfWithRibsMergedShell( nPathGrp, sName, dStrand, LayerParams) + + local nCrvGrp = EgtGetParent( nPathGrp) + local nOldTrimSurf = EgtGetFirstNameInGroup( nCrvGrp, TOT_SHELL_TRIM_SURF) + + -- calcolo la nuova superficie di trim come la regione occupata dall'ultima shell che conservo + local nFirstShell = EgtGetFirstNameInGroup( nPathGrp, sName) + local nPrevShell = EgtGetPrev( nFirstShell) + local dOffs + if nPrevShell then + dOffs = EgtGetInfo( nPrevShell, KEY_CRV_OFFSET, 'd') + local nType = EgtGetInfo( nPrevShell, KEY_TYPE, 'i') + local dPrevStrand = EgtIf( nType == TYPE.OUTER_SHELL, LayerParams.dStrand, LayerParams.dInnerStrand) + dOffs = dOffs + 0.5 * dPrevStrand + else + dOffs = EgtGetInfo( nFirstShell, KEY_CRV_OFFSET, 'd') + dOffs = dOffs - 0.5 * dStrand + end + local nLaySurf = EgtGetFirstNameInGroup( nCrvGrp, LAYER_SRF) + local nNewTrimSurf = ComputeSurfOffset( nLaySurf, nCrvGrp, - dOffs) + if not nNewTrimSurf then + EgtOutLog( 'Error : ComputeSurfOffset with ribs-merged shell for TotTrimSurfRegion failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements') + return false + end + EgtSetName( nNewTrimSurf, TOT_SHELL_TRIM_SURF) + + -- aggiorno con le nuove shell appena modificate + local vNewShells = EgtGetNameInGroup( nPathGrp, sName) or {} + local bOk = true + for i = 1, #vNewShells do + -- calcolo la regione occupata dalla nuova shell + local nSrfShell = EgtSurfFrFatCurve( nCrvGrp, vNewShells[i], dStrand * 0.5 + s_dOffsCorr, false) + if nSrfShell then + if not EgtSurfFrSubtract( nNewTrimSurf, nSrfShell) then + EgtOutLog( 'Error : EgtSurfFrSubtract with ribs-merged shell for TotTrimSurfRegion failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + bOk = false + end + EgtErase( nSrfShell) + else + EgtOutLog( 'Error : EgtSurfFrFatCurve with ribs-merged shell for TotTrimSurfRegion failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + bOk = false + end + end + if not bOk then + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements') + end + + -- aggiorno la trim surf eliminando piccole zone non riempite tra le shell + local dCurrOffs = EgtGetInfo( nFirstShell, KEY_CRV_OFFSET, 'd') + AdjustTrimSurfExtraAngleChunks( nNewTrimSurf, dCurrOffs, dStrand) + + -- elimino la vecchia superficie di trim + EgtErase( nOldTrimSurf) + +end + +-------------------------------------------------------------------- +local function CalcRibsMergedShells( nRibsGrp, nPathGrp, LayerParams, vPtStart) + + if not nRibsGrp then return true end + + -- recupero i setti interni da collegare alla shell + local vAllRibs = EgtGetAllInGroup( nRibsGrp) + local vOrigRibs = {} + for i = 1, #vAllRibs do + local nType = EgtGetInfo( vAllRibs[i], KEY_RIBS_TYPE, 'i') + local bMergeWithShell = EgtGetInfo( vAllRibs[i], KEY_RIBS_MERGE_WITH_SHELLS, 'b') or false + if nType == RIB_TYPE.INTERNAL and bMergeWithShell then + table.insert( vOrigRibs, vAllRibs[i]) + end + end + if #vOrigRibs == 0 then return true end + + -- recupero le shell con cui unire i setti + local nLast = EgtGetLastInGroup( nPathGrp) or GDB_ID.NULL + local nShellType = EgtGetInfo( nLast, KEY_TYPE, 'i') + local bExtraShell = ( nShellType == TYPE.EXTRA_OUTER_SHELL or nShellType == TYPE.EXTRA_SHELL) + local sLastName = EgtGetName( nLast) + local vOrigShells = EgtGetNameInGroup( nPathGrp, sLastName) or {} + local tShells = PrepareShells( vOrigShells, bExtraShell) + if not tShells then return false end + if #tShells == 0 then return true end + + -- sistemo gli strand per adattarmi alla shell + local dStrand = EgtIf( nShellType == TYPE.OUTER_SHELL or nShellType == TYPE.EXTRA_OUTER_SHELL, LayerParams.dStrand, LayerParams.dInnerStrand) + for i = 1, #vOrigRibs do + EgtSetInfo( vOrigRibs[i], KEY_RIBS_STRAND, dStrand) + end + local dShellOffs = EgtGetInfo( vOrigShells[1], KEY_CRV_OFFSET, 'd') + + -- per ogni shell preparo il nuovo percorso + local bOk = true + for i = 1, #tShells do + + -- gruppo per conti + local nGrp = EgtGroup( nPathGrp) + local bShellOk = false + + -- preparo le superfici ausiliarie per la creazione delle shell + if PrepareAuxSurfsForRibsMerge( nGrp, tShells[i], dStrand, LayerParams) then + + -- preparazione dei setti + local nRibsGrp = PrepareRibsForMerge( vOrigRibs, nGrp, dStrand, LayerParams.dStrandOverlap, LayerParams.bRibsInvertOrder) + if nRibsGrp then + -- combino i setti con le shell per creare il nuovo percorso + if CreateRibsMergedShellCurve( nGrp, nRibsGrp, tShells[i], vOrigShells, dStrand, LayerParams, bExtraShell) then + -- creo le nuove curve di shell + local nCrv, nCnt = EgtCurveCompoByChain( nGrp, EgtGetAllInGroup( nGrp), ORIG()) + if nCrv and nCnt > 0 then + for nId = nCrv, nCrv + nCnt - 1 do + EgtRelocateGlob( nId, nPathGrp) + -- assegno info + EgtSetName( nId, sLastName) + EgtSetInfo( nId, KEY_TYPE, nShellType) + ModifyStartPoint( nId, vPtStart) + EgtModifyCurveExtrusion( nId, s_vtSlicing, GDB_RT.GLOB) + EgtSetInfo( nId, KEY_CRV_OFFSET, dShellOffs) + -- ripristino orientamento originale + if EgtCurveIsClosed( nId) then + local vtCrv = EgtCurveArea( nId) + if AreOppositeVectorApprox( vtCrv, s_vtSlicing) then + EgtInvertCurve( nId) + end + end + -- riassegno le info di lead out se extra shell + if bExtraShell then + AssignRibsMergedExtraShellsLeadOutInfo( nId, vOrigShells, LayerParams) + end + end + + -- cancello le shell e le shell originarie associati + for j = 1, #vOrigShells do + local ptRef = EgtMP( vOrigShells[j], GDB_ID.ROOT) + if ptRef then + for k = 1, #tShells[i] do + if EgtCurveParamAtPoint( tShells[i][k], ptRef, 100 * GEO.EPS_SMALL, GDB_RT.GLOB) then + EgtErase( vOrigShells[j]) + vOrigShells[j] = GDB_ID.NULL + break + end + end + end + end + for j = 1, #tShells[i] do + EgtErase( tShells[i][j]) + end + + bShellOk = true + end + end + end + end + if not bShellOk then bOk = false end + EgtErase( nGrp) + end + + -- riordino rispetto alle shell precedenti + if not bExtraShell then + local nFirstShell = EgtGetFirstNameInGroup( nPathGrp, sLastName) + local nPrevShell = EgtGetPrev( nFirstShell) + if nPrevShell then + local vOldIds = EgtGetNameInGroup( nPathGrp, EgtGetName( nPrevShell)) + local vNewIds = EgtGetNameInGroup( nPathGrp, sLastName) + ReorderPath( vOldIds, vNewIds) + end + end + + -- aggiorno la superficie di trim con la nuova shell + UpdateTrimSurfWithRibsMergedShell( nPathGrp, EgtIf( bExtraShell, EXTRA_SHELL_CRV .. '*', sLastName), dStrand, LayerParams) + + -- se ho fallito in qualche merge i setti saranno considerati anche per la realizzazione standard + return bOk +end + -------------------------------------------------------------------- ----------------- REGIONI CON DIVERSE PASSATE ---------------------- -------------------------------------------------------------------- @@ -2462,7 +3372,7 @@ local function CreateShellNbrSurfaces( nGrp, nShellsNbr) end else EgtOutLog( 'Error : ReducedShellNumber is not closed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : ReducedShellNumber is not closed') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : ReducedShellNumber is not closed') end nCrvId = EgtGetNextName( nCrvId, SHELL_NBR_CRV .. '*') @@ -2500,7 +3410,7 @@ local function CreateShellNbrSurfaces( nGrp, nShellsNbr) end if not bOk then EgtOutLog( 'Error : ReducedShellNumber is not considered (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : ReducedShellNumber is not considered') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : ReducedShellNumber is not considered') end end if nSrfId then @@ -2580,7 +3490,7 @@ local function TrimOuterCurveForExtraShellCalc( nOuterCrv, nSrfDiff, nGrpId, vPt for nId = nCrv, nCrv + nCnt - 1 do -- assegno estrusione - EgtModifyCurveExtrusion( nCrv, LayerParams.vtSlicing, GDB_RT.GLOB) + EgtModifyCurveExtrusion( nCrv, s_vtSlicing, GDB_RT.GLOB) -- assegno le info per leadout local ptS = EgtSP( nId) local dCoastingS, dWipeS, dWipeDirS = FindExtraShellRetractionParams( ptS, vShellNbrCrvs, LayerParams) @@ -2603,62 +3513,15 @@ local function UpdateTrimSurfWithExtraShell( nSrf, nCrv, dStrand, nGrpId) if nSrfExtraShell then if not EgtSurfFrSubtract( nSrf, nSrfExtraShell) then EgtOutLog( 'Error : EgtSurfFrSubtract with ExtraShell for TotTrimSurfRegion failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements') - else - EgtErase( nSrfExtraShell) + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements') end + EgtErase( nSrfExtraShell) else EgtOutLog( 'Error : creation of ExtraShell region for TotTrimSurfRegion failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements') end end ---------------------------------------------------------------------- -local function AdjustTrimSurfWithExtraShells( nTrimSurf, dOffs, dStrand, nGrpTmp) - - -- calcolo la superficie occupata dalle shell se non ci fossero ReducedShellNumber - local nLaySurf = EgtGetFirstNameInGroup( EgtGetParent( nTrimSurf), LAYER_SRF) - dOffs = dOffs + dStrand * 0.5 + 50 * GEO.EPS_SMALL - local nBaseSurf = ComputeSurfOffset( nLaySurf, nGrpTmp, - dOffs) - if not nBaseSurf then - EgtOutLog( 'Warning : AdjustTrimSurfWithExtraShell base surf computation failed. TrimSurf may be inaccurate (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - return - elseif nBaseSurf == GDB_ID.NULL then - EgtOutLog( 'Warning : AdjustTrimSurfWithExtraShell base surf does not exist. TrimSurf may be inaccurate (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - return - end - local nChunks = EgtSurfFrChunkCount( nBaseSurf) - - -- individuo i chunk della TrimSurf da conservare - local vValidChunks = {} - local nFirstId, nCnt = EgtExplodeSurf( nTrimSurf) - for nId = nFirstId, nFirstId + nCnt - 1 do - -- verifico se è esterno a tutti i chunks di nBaseSurf ( quindi è porzione non riempita tra le shell da eliminare) - local bIsOut = true - for i = 0, nChunks - 1 do - local nRes = EgtSurfFrChunkSimpleClassify( nId, 0, nBaseSurf, i) - if nRes ~= GDB_RC.OUT then - bIsOut = false - break - end - end - - if bIsOut then - EgtErase( nId) - else - -- se compreso nella superficie base va conservato - table.insert( vValidChunks, nId) - end - end - - -- unisco tutti i chunk validi in un'unica superficie - for i = 2, #vValidChunks do - EgtSurfFrAdd( vValidChunks[1], vValidChunks[i]) - EgtErase( vValidChunks[i]) - end - -end - --------------------------------------------------------------------- local function ReorderExtraShells( nPathGrp, vPtStart, LayerParams) @@ -2666,28 +3529,44 @@ local function ReorderExtraShells( nPathGrp, vPtStart, LayerParams) -- verifico se posso unire due tratti consecutivi della stessa shell local nFirst = EgtGetFirstNameInGroup( nPathGrp, EXTRA_SHELL_CRV .. '*') + if not nFirst then return end + while nFirst do -- recupero tratti appartenenti alla stessa shell local sName = EgtGetName( nFirst) local vShells = EgtGetNameInGroup( nPathGrp, sName) + -- inserisco la prima shell anche in fondo alla tabella per garantire anche il confronto fra l'ultima e la prima + table.insert( vShells, vShells[1]) local nType = EgtGetInfo( nFirst, KEY_TYPE, 'i') local dStrand = EgtIf( nType == TYPE.EXTRA_OUTER_SHELL, LayerParams.dStrand, LayerParams.dInnerStrand) local nCurr = vShells[1] for i = 2, #vShells do - if dist( EgtEP( nCurr), EgtSP( vShells[i])) < dAlpha * dStrand + GEO.EPS_SMALL then - -- unisco le curve + if nCurr == vShells[i] then + -- nell'ultimo confronto ( ultima e prima extra shell) potresti confrontare una curva con se stessa + break + end + if dist( EgtSP( nCurr), EgtSP( vShells[i])) < dAlpha * dStrand + GEO.EPS_SMALL then + -- start- start + EgtAddCurveCompoLine( nCurr, EgtSP( vShells[i]), false) + EgtInvertCurve( vShells[i]) + EgtAddCurveCompoCurve( nCurr, vShells[i], true, false) + elseif dist( EgtSP( nCurr), EgtEP( vShells[i])) < dAlpha * dStrand + GEO.EPS_SMALL then + -- start - end + EgtAddCurveCompoLine( nCurr, EgtEP( vShells[i]), false) + EgtAddCurveCompoCurve( nCurr, vShells[i], true, false) + elseif dist( EgtEP( nCurr), EgtSP( vShells[i])) < dAlpha * dStrand + GEO.EPS_SMALL then + -- end - start EgtAddCurveCompoLine( nCurr, EgtSP( vShells[i])) EgtAddCurveCompoCurve( nCurr, vShells[i]) + elseif dist( EgtEP( nCurr), EgtEP( vShells[i])) < dAlpha * dStrand + GEO.EPS_SMALL then + -- end - end + EgtAddCurveCompoLine( nCurr, EgtEP( vShells[i])) + EgtInvertCurve( vShells[i]) + EgtAddCurveCompoCurve( nCurr, vShells[i]) else nCurr = vShells[i] end end - -- check su prima e ultima curva - if nCurr ~= nFirst and dist( EgtEP( nCurr), EgtSP( nFirst)) < dAlpha * dStrand + GEO.EPS_SMALL then - -- unisco le curve - EgtAddCurveCompoLine( nCurr, EgtSP( nFirst)) - EgtAddCurveCompoCurve( nCurr, nFirst) - end -- verifico se le curve si possono chiudere vShells = EgtGetNameInGroup( nPathGrp, sName) @@ -2695,11 +3574,18 @@ local function ReorderExtraShells( nPathGrp, vPtStart, LayerParams) if not EgtCurveIsClosed( vShells[i]) then if dist( EgtSP( vShells[i]), EgtEP( vShells[i])) < dAlpha * dStrand + GEO.EPS_SMALL then EgtCloseCurveCompo( vShells[i]) + -- ripristino orientamento originale + local vtCrv = EgtCurveArea( vShells[i]) + if AreOppositeVectorApprox( vtCrv, s_vtSlicing) then + EgtInvertCurve( vShells[i]) + UpdateInvertInfo( vShells[i]) + end end end end - nFirst = EgtGetNextName( nCurr, EXTRA_SHELL_CRV .. '*') + -- passo al gruppo di extra shell successivo + nFirst = EgtGetNextName( vShells[#vShells], EXTRA_SHELL_CRV .. '*') end local vIds = EgtGetNameInGroup( nPathGrp, EXTRA_SHELL_CRV .. '*') @@ -2801,6 +3687,12 @@ local function ReorderExtraShells( nPathGrp, vPtStart, LayerParams) ModifyStartPoint( vLinkedShells[1], vPtStart) EgtSetInfo( vLinkedShells[1], KEY_CLOSED_CRV, true) + -- ripristino orientamento desiderato + local vtCrv = EgtCurveArea( vLinkedShells[1]) + if ( not LayerParams.bPrintInvert and AreOppositeVectorApprox( vtCrv, s_vtSlicing)) or ( LayerParams.bPrintInvert and AreSameVectorApprox( vtCrv, s_vtSlicing)) then + EgtInvertCurve( vLinkedShells[1]) + UpdateInvertInfo( vLinkedShells[1]) + end end -- cerco il prossimo da cui partire @@ -2815,23 +3707,10 @@ local function ReorderExtraShells( nPathGrp, vPtStart, LayerParams) end end end - end -------------------------------------------------------------------- -local function FinalizeExtraShellPath( nPathGrp, vPtStart, nTotShellTrim, dOffs, dStrand, LayerParams, nGrpTmp) - - -- riordino shell per creare link - ReorderExtraShells( nPathGrp, vPtStart, LayerParams) - -- aggiorno la trim surf eliminando piccole zone non riempite tra le shell - AdjustTrimSurfWithExtraShells( nTotShellTrim, dOffs, dStrand, nGrpTmp) - -- elimino il gruppo temporaneo usato per i conti - EgtErase( nGrpTmp) - -end - --------------------------------------------------------------------- -local function CalcExtraShellsPath( nMaxShellNbrDiff, nShellNbrGrp, nCrvGrpId, dOffs, LayerParams, vPtStart) +local function CalcExtraShellsPath( nMaxShellNbrDiff, nShellNbrGrp, nCrvGrpId, dOffs, LayerParams, vPtStart, nRibsGrp) local nGrpId = EgtGetFirstNameInGroup( nCrvGrpId, PATH_GRP) local nGrpTmp = EgtGroup( nGrpId) -- gruppo temporaneo per conti @@ -2859,12 +3738,15 @@ local function CalcExtraShellsPath( nMaxShellNbrDiff, nShellNbrGrp, nCrvGrpId, d dCurrStrand = EgtIf( nInd == LayerParams.nShellsNbr, LayerParams.dStrand, LayerParams.dInnerStrand) local nSrfDiff = EgtGetFirstNameInGroup( nShellNbrGrp, SHELL_NBR_SURF .. tostring( nInd)) + local bOk = true local nOuterCrv = EgtGetFirstNameInGroup( nCrvGrpId, OUTER_CRV) - while nOuterCrv do + if not bOk then break end + -- trim della outer curve con la superficie local nTrimCrv, nTrimCnt = TrimOuterCurveForExtraShellCalc( nOuterCrv, nSrfDiff, nGrpTmp, vPtStart, LayerParams) for nCrvT = nTrimCrv, nTrimCrv + nTrimCnt - 1 do + if not bOk then break end -- calcolo offset della curva ( è il percorso della shell) local nOffs, nOffsCnt = EgtOffsetCurveAdv( nCrvT, - dOffs) @@ -2875,16 +3757,14 @@ local function CalcExtraShellsPath( nMaxShellNbrDiff, nShellNbrGrp, nCrvGrpId, d if not nTrimSurf then -- errore nel calcolo della superficie di trim EgtOutLog( 'Error : creation of ExtraShell failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing extra shell') - -- aggiustamenti finali alle extra shell calcolate in precedenza - FinalizeExtraShellPath( nGrpId, vPtStart, nTotShellTrim, dOffs, dCurrStrand, LayerParams, nGrpTmp) - return + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing extra shell') + bOk = false + break elseif nTrimSurf == GDB_ID.NULL then -- non c'è più spazio per realizzare le extra shell EgtOutLog( 'Warning : ExtraInnerShells not possible (layer '..tostring( s_nCurrIdx)..') - CalcPaths') - -- aggiustamenti finali alle extra shell calcolate in precedenza - FinalizeExtraShellPath( nGrpId, vPtStart, nTotShellTrim, dOffs, dCurrStrand, LayerParams, nGrpTmp) - return + bOk = false + break else if bNoOverlap then EgtOutLog( 'Warning : ExtraShell without correct overlap (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') @@ -2904,15 +3784,16 @@ local function CalcExtraShellsPath( nMaxShellNbrDiff, nShellNbrGrp, nCrvGrpId, d local dLen = EgtCurveLength( nId) local bValid = true if EgtCurveIsClosed( nId) then - bValid = VerifyPath( nId, LayerParams.dStrand, LayerParams.vtSlicing, nGrpId) + bValid = VerifyPath( nId, LayerParams.dStrand, nGrpId) end -- verifico se soddisfa vincolo sulla lunghezza if dLen > MIN_LEN and bValid then -- sposto nel path EgtRelocateGlob( nId, nGrpId) EgtSetStatus( nId, GDB_ST.ON) - EgtModifyCurveExtrusion( nId, LayerParams.vtSlicing, GDB_RT.GLOB) + EgtModifyCurveExtrusion( nId, s_vtSlicing, GDB_RT.GLOB) EgtSetName( nId, EXTRA_SHELL_CRV .. tostring( nMaxShellNbrDiff - nInd + 1)) + EgtSetInfo( nId, KEY_CRV_OFFSET, dOffs) if nInd == LayerParams.nShellsNbr then EgtSetInfo( nId, KEY_TYPE, TYPE.EXTRA_OUTER_SHELL) else @@ -2940,8 +3821,9 @@ local function CalcExtraShellsPath( nMaxShellNbrDiff, nShellNbrGrp, nCrvGrpId, d end end - -- ultimi aggiustamenti alle extra shell - FinalizeExtraShellPath( nGrpId, vPtStart, nTotShellTrim, dOffs, dCurrStrand, LayerParams, nGrpTmp) + -- ultimi aggiustamenti alla superifice di trim + AdjustTrimSurfExtraAngleChunks( nTotShellTrim, dOffs, dCurrStrand, nGrpTmp) + EgtErase( nGrpTmp) end @@ -2954,11 +3836,11 @@ local function UpdateTrimSurfWithAuxSolidsOffset( nSrfSolid, nSrfBase, dStrand, local nSrfOffs = ComputeSurfOffset( nSrfSolid, nCrvGrp, dStrand * 0.5) if not nSrfOffs then EgtOutLog( 'Error : creation of AuxSolid region for TotTrimSurfRegion failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements') else if not EgtSurfFrSubtract( nSrfBase, nSrfOffs) then EgtOutLog( 'Error : EgtSurfFrSubtract with AuxSolid for TotTrimSurfRegion failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements') end EgtErase( nSrfOffs) end @@ -3025,7 +3907,7 @@ local function UpdateTrimSurfWithAuxSolidsZigZag( nAuxSolidsGrp, sName, nSrfBase -- aggiorno la TotShellSurfForTrim if not EgtSurfFrSubtract( nSrfBase, nSrfZigZag) then EgtOutLog( 'Error : EgtSurfFrSubtract with AuxSolid for TotTrimSurfRegion failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements') end end EgtErase( nGrpTmp) @@ -3033,12 +3915,12 @@ local function UpdateTrimSurfWithAuxSolidsZigZag( nAuxSolidsGrp, sName, nSrfBase end ------------------------------------------------------------------- -local function AddExtraZigZag( nSrf, sName, dStrand, vtSlicing, nGrp, nSrfTrim) +local function AddExtraZigZag( nSrf, sName, dStrand, nGrp, nSrfTrim) local vIds = EgtGetNameInGroup( nGrp, sName) if not vIds then return end local vtDir = EgtSV( vIds[1], GDB_ID.ROOT) - local vtYLoc = vtSlicing ^ vtDir + local vtYLoc = s_vtSlicing ^ vtDir local nOuterLoop, nCnt = EgtExtractSurfFrChunkLoops( nSrf, 0, nGrp) @@ -3067,7 +3949,7 @@ local function AddExtraZigZag( nSrf, sName, dStrand, vtSlicing, nGrp, nSrfTrim) end ------------------------------------------------------------------- -local function ComputeAuxSolidsGenericInfill( nSrf, dStrand, vtSlicing, sName, nPathGrp, vPtStart, nOrigSurf, dOverlap, nAuxSolidsGrp, bLink) +local function ComputeAuxSolidsGenericInfill( nSrf, dStrand, sName, nPathGrp, vPtStart, nOrigSurf, dOverlap, nAuxSolidsGrp, bLink) if nSrf == GDB_ID.NULL then return end @@ -3094,7 +3976,7 @@ local function ComputeAuxSolidsGenericInfill( nSrf, dStrand, vtSlicing, sName, n EgtSetName( nId, sName) EgtSetInfo( nId, KEY_TYPE, TYPE.INFILL) EgtSetInfo( nId, KEY_ASSOCIATED_SURF, nSrf) - EgtModifyCurveExtrusion( nId, vtSlicing, GDB_RT.GLOB) + EgtModifyCurveExtrusion( nId, s_vtSlicing, GDB_RT.GLOB) end end end @@ -3154,7 +4036,7 @@ local function CalcAuxSolidsPaths( nSliceGrp, nSolidGrp, LayerParams, vPtStart) local nTrimSurf, bNoOverlap = ComputeTrimSurf( nSrfBase, nSolidPathGrp, dStrand, dOverlap) if not nTrimSurf then EgtOutLog( 'Error : creation of AuxSolid region failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of AuxSolid region failed') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of AuxSolid region failed') elseif nTrimSurf == GDB_ID.NULL then EgtOutLog( 'Warning : AuxSolids not possible (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') else @@ -3170,9 +4052,9 @@ local function CalcAuxSolidsPaths( nSliceGrp, nSolidGrp, LayerParams, vPtStart) local sNewName = sName .. EgtIf( j == 0, '', '_' .. tostring( j)) -- calcolo shells - if not ComputeOffsetShells( nFirst + j, dStrand, LayerParams.vtSlicing, sNewName, TYPE.AUX_SOLID, nSolidPathGrp, vPtStart, nil, nShells) then + if not ComputeOffsetShells( nFirst + j, dStrand, sNewName, TYPE.AUX_SOLID, nSolidPathGrp, vPtStart, nil, nShells) then EgtOutLog( 'Error : creation of AuxSolid shells failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of AuxSolid shells failed') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of AuxSolid shells failed') end -- calcolo la superficie per il riempimento @@ -3182,7 +4064,7 @@ local function CalcAuxSolidsPaths( nSliceGrp, nSolidGrp, LayerParams, vPtStart) nSrfFill = ComputeSurfOffset( nFirst + j, nSolidPathGrp, - dOffs) if not nSrfFill then EgtOutLog( 'Error : creation of AuxSolid infill region failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of AuxSolid infill region failed') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of AuxSolid infill region failed') elseif nSrfFill == GDB_ID.NULL then EgtOutLog( 'Warning : AuxSolids infill not possible (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') end @@ -3194,18 +4076,18 @@ local function CalcAuxSolidsPaths( nSliceGrp, nSolidGrp, LayerParams, vPtStart) -- riempimento if nInfillType == FILL_TYPE.OFFSET then -- recupero le shells - if not ComputeOffsetShells( nSrfFill, dStrand, LayerParams.vtSlicing, sNewName, TYPE.AUX_SOLID, nSolidPathGrp, vPtStart) then + if not ComputeOffsetShells( nSrfFill, dStrand, sNewName, TYPE.AUX_SOLID, nSolidPathGrp, vPtStart) then EgtOutLog( 'Error : creation of AuxSolid offset infill failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of AuxSolid offset infill failed') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of AuxSolid offset infill failed') end elseif nInfillType == FILL_TYPE.ZIGZAG then - ComputeZigZagSolidFill( nSrfFill, dStrand, LayerParams.vtSlicing, sNewName, TYPE.AUX_SOLID, nSolidPathGrp, EgtIf( nShells == 0, nTrimSurf, nil)) + ComputeZigZagSolidFill( nSrfFill, dStrand, sNewName, TYPE.AUX_SOLID, nSolidPathGrp, EgtIf( nShells == 0, nTrimSurf, nil)) if nShells == 0 then -- aggiungo eventuale passata extra - AddExtraZigZag( nSrfFill, sNewName, dStrand, LayerParams.vtSlicing, nSolidPathGrp, nTrimSurf) + AddExtraZigZag( nSrfFill, sNewName, dStrand, nSolidPathGrp, nTrimSurf) end elseif nInfillType ~= FILL_TYPE.NONE then - ComputeAuxSolidsGenericInfill( nSrfFill, dStrand, LayerParams.vtSlicing, sNewName, nSolidPathGrp, vPtStart, nOrigSurf, dOverlap, nSolidGrp, bInfillLink) + ComputeAuxSolidsGenericInfill( nSrfFill, dStrand, sNewName, nSolidPathGrp, vPtStart, nOrigSurf, dOverlap, nSolidGrp, bInfillLink) end -- aggiorno la superficie di trim con il solido ausiliario @@ -3220,7 +4102,7 @@ local function CalcAuxSolidsPaths( nSliceGrp, nSolidGrp, LayerParams, vPtStart) end else EgtOutLog( 'Error : creation of AuxSolid region failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of AuxSolid region failed') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of AuxSolid region failed') end end end @@ -3253,10 +4135,11 @@ function CalcPaths.Exec( nPartId) -- scorro tutti i suoi layer for nIdx = 1, #vLayIds do - + s_nCurrIdx = nIdx local nRibsGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], RIBS_GRP) + local bIgnoreMergedRibs = true local nAuxSolidsGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], AUX_SOLIDS_GRP) local nInfillGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], INFILL_GRP) @@ -3265,7 +4148,7 @@ function CalcPaths.Exec( nPartId) local nShellNbrSurfGrp = CreateShellNbrSurfaces( nShellNbrGrp, LayerParams.nShellsNbr) -- recupero gli start point per il layer - local vPtStart = GetLayerStartPoint( vLayIds[nIdx], LayerParams.vtSlicing) + local vPtStart = GetLayerStartPoint( vLayIds[nIdx]) -- scorro tutti i gruppi di contorni local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[nIdx], CONTOUR_GRP.."*") or GDB_ID.NULL @@ -3299,24 +4182,20 @@ function CalcPaths.Exec( nPartId) local nSrfId = ComputeSurfOffset( nSrf, nCrvGrpId, - dOffs) if not nSrfId then EgtOutLog( 'Error : ExtOffset failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of OuterShell failed') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of OuterShell failed') elseif nSrfId == GDB_ID.NULL then EgtOutLog( 'Warning : ExtOffset not possible (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') else -- se offset riuscito, estraggo i contorni (pareti esterne) vOldIds = GetPathsFromSurf( nSrfId, SHELL_CRV ..'0', TYPE.OUTER_SHELL, nGrpId, vPtStart) + for i = 1, #vOldIds do + EgtSetInfo( vOldIds[i], KEY_CRV_OFFSET, dOffs) + end end bPrevExists = ( nSrfId ~= GDB_ID.NULL) EgtErase( nSrfId) end - local vPtInnerStart = {} - local vOuterShell = EgtGetNameInGroup( nGrpId, SHELL_CRV .. '0') or {} - for i = 1, #vOuterShell do - table.insert( vPtInnerStart, EgtSP( vOuterShell[i])) - end - if #vPtInnerStart == 0 then vPtInnerStart = vPtStart end - -- pareti interne complete for nInd = 1, LayerParams.nShellsNbr - 1 - nMaxShellNbrDiff do dLastStrand = LayerParams.dInnerStrand @@ -3329,20 +4208,23 @@ function CalcPaths.Exec( nPartId) local nSrfId = ComputeSurfOffset( nSrf, nCrvGrpId, - dOffs) if not nSrfId then EgtOutLog( 'Error : IntOffset failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of InnerShell failed') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of InnerShell failed') elseif nSrfId == GDB_ID.NULL then EgtOutLog( 'Warning : IntOffset ' .. EgtNumToString( nInd) .. ' not possible (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') else -- se offset riuscito, estraggo i contorni ( pareti interne) - local vNewIds = GetPathsFromSurf( nSrfId, SHELL_CRV..tostring( nInd), TYPE.INNER_SHELL, nGrpId, vPtInnerStart) + local vNewIds = GetPathsFromSurf( nSrfId, SHELL_CRV..tostring( nInd), TYPE.INNER_SHELL, nGrpId, vPtStart) ReorderPath( vOldIds, vNewIds) + for i = 1, #vNewIds do + EgtSetInfo( vNewIds[i], KEY_CRV_OFFSET, dOffs) + end vOldIds = vNewIds -- se questo offset esiste ma il precedente no, allora il precedente è un errore da segnalare if not bPrevExists then local sElement = EgtIf( nInd > 1, 'IntOffset ' .. EgtNumToString( nInd - 1), 'ExtOffset') EgtOutLog( 'Error :' .. sElement .. ' failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of ' .. EgtIf( nInd > 1, 'InnerShell', 'OuterShell') .. ' failed') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of ' .. EgtIf( nInd > 1, 'InnerShell', 'OuterShell') .. ' failed') end end @@ -3355,7 +4237,7 @@ function CalcPaths.Exec( nPartId) local nSrfTrim = ComputeSurfOffset( nSrf, nCrvGrpId, - dSurfTrimOffs) if not nSrfTrim then EgtOutLog( 'Error : offset for TotTrimSurfRegion failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements') elseif nSrfTrim ~= GDB_ID.NULL then EgtSetName( nSrfTrim, TOT_SHELL_TRIM_SURF) EgtSetStatus( nSrfTrim, GDB_ST.OFF) @@ -3363,14 +4245,20 @@ function CalcPaths.Exec( nPartId) -- se questo offset esiste ma il precedente no, allora il precedente è un errore da segnalare if not bPrevExists then EgtOutLog( 'Error : IntOffset' .. EgtNumToString( LayerParams.nShellsNbr - 1 - nMaxShellNbrDiff) .. ' failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of InnerShell failed') + table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of InnerShell failed') end end - - -- eventuali pareti interne coinvolte dal diverso numero di passate + + -- pareti coinvolte dal diverso numero di passate if nMaxShellNbrDiff > 0 then - CalcExtraShellsPath( nMaxShellNbrDiff, nShellNbrSurfGrp, nCrvGrpId, dOffs, LayerParams, vPtInnerStart) + CalcExtraShellsPath( nMaxShellNbrDiff, nShellNbrSurfGrp, nCrvGrpId, dOffs, LayerParams, vPtStart, nRibsGrp) end + + -- ribs-merged shells + bIgnoreMergedRibs = CalcRibsMergedShells( nRibsGrp, nGrpId, LayerParams, vPtStart) + + -- riordino extra shells + ReorderExtraShells( nGrpId, vPtStart, LayerParams) end -- passo al gruppo di contorni successivo @@ -3398,7 +4286,7 @@ function CalcPaths.Exec( nPartId) -- gestione costolature if nRibsGrp then - CalcRibsPaths( vLayIds[nIdx], nRibsGrp, LayerParams, vPtStart) + CalcRibsPaths( vLayIds[nIdx], nRibsGrp, LayerParams, vPtStart, bIgnoreMergedRibs) end if EgtProcessEvents( EgtIf( PRINT, 200, 0) + nIdx / #vLayIds * 100, 0) == 1 then diff --git a/LuaLibs/CalcSlices.lua b/LuaLibs/CalcSlices.lua index 5d9e249..6aa0e2f 100644 --- a/LuaLibs/CalcSlices.lua +++ b/LuaLibs/CalcSlices.lua @@ -120,6 +120,7 @@ local function GetRibParams( nId) ReadParam( nId, KEY_RIBS_LINK, 'b', false, RibParam) ReadParam( nId, KEY_RIBS_TYPE, 'i', RIB_TYPE.INTERNAL, RibParam) ReadParam( nId, KEY_RIBS_INVERT_STRAND_ORDER, 'b', false, RibParam) + ReadParam( nId, KEY_RIBS_MERGE_WITH_SHELLS, 'b', false, RibParam) return RibParam end @@ -1040,17 +1041,17 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin nLayId = EgtGetNext( nLayId) end + -- costolature + local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS) + ExtractRibsLoops( nRibsLay, nStmId) + SlicingExtraObjects( nRibsLay, vtSlicing, TYPE.RIB, RIBS_CRV, RIBS_GRP, nStmId) + if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 3) / nCounterTot * 100, 0) == 1 then return false end + local bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false if not bSpiralVase then -- infill PrepareInfill( nStmId, vtSlicing) - if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 3) / nCounterTot * 100, 0) == 1 then return false end - - -- costolature - local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS) - ExtractRibsLoops( nRibsLay, nStmId) - SlicingExtraObjects( nRibsLay, vtSlicing, TYPE.RIB, RIBS_CRV, RIBS_GRP, nStmId) if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 6) / nCounterTot * 100, 0) == 1 then return false end -- solidi per regioni con diverso numero di passate diff --git a/LuaLibs/CalcToolPath.lua b/LuaLibs/CalcToolPath.lua index 722920a..2b21cf8 100644 --- a/LuaLibs/CalcToolPath.lua +++ b/LuaLibs/CalcToolPath.lua @@ -1872,7 +1872,8 @@ local function SpiralVase( vLayIds, LayerParams) local vCrvGrpIds = EgtGetNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*") if #vCrvGrpIds > 1 then -- se più di un gruppo di curve warning - EgtOutLog( 'Warning : in spiral vase mode more than one curve (layer '..tostring( nIdx)..') - CalcToolPath') + EgtOutBox( 'Error in spiral vase : layer ' .. tostring( nIdx) .. ' has more than one toolpath', 'ToolPathCalc') + return false end for i = 1, #vCrvGrpIds do @@ -1895,65 +1896,67 @@ local function SpiralVase( vLayIds, LayerParams) end -- creo il percorso di lavoro : - local nEntId = EgtGetFirstInGroup( nPathGrpId) - while nEntId do - local nNewEntId = EgtCopyGlob( nEntId, nTpathGrpId, GDB_IN.LAST_SON) - - local vtMove = V_NULL() - -- eventuale spostamento dell'altezza layer - if nSlicingType == SLICING_TYPE.DEG45_X or nSlicingType == SLICING_TYPE.DEG45_Y then - vtMove = LayerParams.dLayHeight * LayerParams.vtSlicing - EgtMove( nNewEntId, vtMove, GDB_RT.GLOB) - end - - EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB) - EgtSetInfo( nNewEntId, KEY_CRV_STRAND, LayerParams.dStrand) - - -- eventuale inversione - if LayerParams.bInvert then - EgtInvertCurve( nNewEntId) - EgtSetInfo( nNewEntId, KEY_INVERTED_CRV, 1) - end - EgtSetColor( nNewEntId, EgtStdColor('GRAY')) - - -- se primo layer - if bFirst and nNewEntId then - -- mi sposto dell'altezza layer - EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) - -- eventuale lead in - if LayerParams.nLeadInType ~= LEAD_TYPE.NONE then - EgtTrimCurveStartAtLen( nNewEntId, LayerParams.dOffsetLP) - AddLeadIn( nNewEntId, LayerParams, nTpathGrpId) - end - bFirst = false - else - local ptOld = EgtEP( nOldId, GDB_ID.ROOT) - local ptNew = EgtSP( nNewEntId, GDB_ID.ROOT) - if dist( ptNew, ptOld) < LayerParams.dStrand then - -- se i punti sono vicini ma non coincidenti modifico la curva per avere transizione più uniforme - if not AreSamePointApprox( ptOld, ptNew) then - -- recupero la curva da usare come guida - local nGuideId = EgtCopyGlob( nOldPathId, nTpathGrpId) - -- la porto alla stessa quota del toolpath - EgtMove( nGuideId, vtMove + LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) - EgtChangeClosedCurveStartPoint( nGuideId, ptOld, GDB_RT.GLOB) - - EgtSpiralizeCurveAlongGuide( nNewEntId, nGuideId) - EgtErase( nGuideId) - end - else - EgtOutLog( 'Warning : in spiral vase mode no link betweeen toolpaths (layer '..tostring( nIdx)..') - CalcToolPath') - -- aggiungo uscita, coasting e wipe sulla curva precedente - AddSpiralVaseLeadOut( nOldId, LayerParams) - end - EgtSpiralizeCurveAlongExtrusion( nNewEntId, LayerParams.dLayHeight) - end - - nOldPathId = nEntId - nOldId = nNewEntId - nEntId = EgtGetNext( nEntId) + local vEntIds = EgtGetAllInGroup( nPathGrpId) + if #vEntIds > 1 then + EgtOutBox( 'Error in spiral vase : layer ' .. tostring( nIdx) .. ' has more than one toolpath', 'ToolPathCalc') + return false end + local nNewEntId = EgtCopyGlob( vEntIds[1], nTpathGrpId, GDB_IN.LAST_SON) + + local vtMove = V_NULL() + -- eventuale spostamento dell'altezza layer + if nSlicingType == SLICING_TYPE.DEG45_X or nSlicingType == SLICING_TYPE.DEG45_Y then + vtMove = LayerParams.dLayHeight * LayerParams.vtSlicing + EgtMove( nNewEntId, vtMove, GDB_RT.GLOB) + end + + EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB) + EgtSetInfo( nNewEntId, KEY_CRV_STRAND, LayerParams.dStrand) + + -- eventuale inversione + if LayerParams.bInvert then + EgtInvertCurve( nNewEntId) + EgtSetInfo( nNewEntId, KEY_INVERTED_CRV, 1) + end + EgtSetColor( nNewEntId, EgtStdColor('GRAY')) + + -- se primo layer + if bFirst and nNewEntId then + -- mi sposto dell'altezza layer + EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) + -- eventuale lead in + if LayerParams.nLeadInType ~= LEAD_TYPE.NONE then + EgtTrimCurveStartAtLen( nNewEntId, LayerParams.dOffsetLP) + AddLeadIn( nNewEntId, LayerParams, nTpathGrpId) + end + bFirst = false + else + local ptOld = EgtEP( nOldId, GDB_ID.ROOT) + local ptNew = EgtSP( nNewEntId, GDB_ID.ROOT) + if dist( ptNew, ptOld) < LayerParams.dStrand then + -- se i punti sono vicini ma non coincidenti modifico la curva per avere transizione più uniforme + if not AreSamePointApprox( ptOld, ptNew) then + -- recupero la curva da usare come guida + local nGuideId = EgtCopyGlob( nOldPathId, nTpathGrpId) + -- la porto alla stessa quota del toolpath + EgtMove( nGuideId, vtMove + LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) + EgtChangeClosedCurveStartPoint( nGuideId, ptOld, GDB_RT.GLOB) + + EgtSpiralizeCurveAlongGuide( nNewEntId, nGuideId) + EgtErase( nGuideId) + end + else + EgtOutLog( 'Warning : in spiral vase mode no link betweeen toolpaths (layer '..tostring( nIdx)..') - CalcToolPath') + -- aggiungo uscita, coasting e wipe sulla curva precedente + AddSpiralVaseLeadOut( nOldId, LayerParams) + end + EgtSpiralizeCurveAlongExtrusion( nNewEntId, LayerParams.dLayHeight) + end + + nOldPathId = vEntIds[1] + nOldId = nNewEntId + -- aggiorno il box dei toolpath local b3Box = ComputeToolPathBox( nTpathGrpId) b3Tot:Add( b3Box) diff --git a/Version.lua b/Version.lua index a15bcaf..f8c3d60 100644 --- a/Version.lua +++ b/Version.lua @@ -1,4 +1,4 @@ -- Version.lua by Egaltech s.r.l. 2023/10/02 -- Gestione della versione di 3dPrinting -VERSION = '2.5j1' \ No newline at end of file +VERSION = '2.5j2' \ No newline at end of file