From 8622fc89197490a27d3cbccb61466db5e8e84c5a Mon Sep 17 00:00:00 2001 From: SaraP Date: Thu, 24 Nov 2022 16:09:16 +0100 Subject: [PATCH] 3dPrinting : - migliorata intersezione setti - aggiunto ordine di realizzazione per tipologie setti. --- LuaLibs/AddManData.lua | 10 ++ LuaLibs/CalcPaths.lua | 292 ++++++++++++++++++++++++----------------- LuaLibs/RunSlicing.lua | 1 + 3 files changed, 180 insertions(+), 123 deletions(-) diff --git a/LuaLibs/AddManData.lua b/LuaLibs/AddManData.lua index 4f14bc7..b8f9032 100644 --- a/LuaLibs/AddManData.lua +++ b/LuaLibs/AddManData.lua @@ -99,6 +99,7 @@ KEY_RIBS_INTERS = "RibsHaveIntersections" KEY_SPLIT_ORDER = "SplitOrder" KEY_SPLIT_RIB = "SplitRib" KEY_RIBS_TWO_STRANDS = "RibsHaveAll2Strands" +KEY_RIBS_PRINT_ORDER = "RibsPrintOrder" -- Regioni con diverso numero di passate KEY_SHELL_NBR_DIFF = "ShellNbrDifference" @@ -193,6 +194,15 @@ RIB_TYPE = { UNBOUNDED = 3, } +RIB_PRINT_ORDER = { + INT_EXT_UNBDD = 1, + INT_UNBDD_EXT = 2, + EXT_INT_UNBDD = 3, + EXT_UNBDD_INT = 4, + UNBDD_INT_EXT = 5, + UNBDD_EXT_INT = 6, +} + --------------------------------------------------------------------- TABLE = "Table" PART = "Part" diff --git a/LuaLibs/CalcPaths.lua b/LuaLibs/CalcPaths.lua index 1c1db1d..1e410b6 100644 --- a/LuaLibs/CalcPaths.lua +++ b/LuaLibs/CalcPaths.lua @@ -33,6 +33,7 @@ local function GetLayerParamsForPathCalc() -- parametri costolature LayerParams.bRibsInvertOrder = EgtGetInfo( s_nPartId, KEY_RIBS_INVERT_ORDER, 'b') LayerParams.bRibsDoLinkFirst = EgtGetInfo( s_nPartId, KEY_RIBS_DO_LINK_FIRST, 'b') or false + LayerParams.nRibsPrintOrder = EgtGetInfo( s_nPartId, KEY_RIBS_PRINT_ORDER, 'i') or 1 -- 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') @@ -464,22 +465,62 @@ local function ComputeTrimSurfWithOverlapsForRibs( vIds, nSrfBase, nSrfExt, dOff end -------------------------------------------------------------------- -local function VerifyRibsIntersection( ptInt, nType1, nType2, nSrf1, nSrf2, nGrp) +local function VerifyRibsIntersection( nRib1, nRib2, nType1, nType2, nSrf1, nSrf2, nGrp, nOffsGrp) - local bValid = false - local nPtId = EgtPoint( nGrp, ptInt) - - if nType1 == RIB_TYPE.INTERNAL or nType2 == RIB_TYPE.INTERNAL then - -- l'intersezione deve essere interna - if nSrf1 and not EgtSurfFrTestExternal( nSrf1, nPtId) then bValid = true end - elseif nType1 == RIB_TYPE.EXTERNAL or nType2 == RIB_TYPE.EXTERNAL then - -- l'intersezione deve essere esterna - if nSrf2 and EgtSurfFrTestExternal( nSrf2, nPtId) then bValid = true end - else - bValid = true + -- setti interni ed esterni non si possono intersecare per definizione + if ( nType1 == RIB_TYPE.INTERNAL and nType2 == RIB_TYPE.EXTERNAL) or ( nType1 == RIB_TYPE.EXTERNAL and nType2 == RIB_TYPE.INTERNAL) then + return false + end + -- se hanno lo stesso nome derivano dalla stessa costolatura quindi non ha senso controllare intersezione + if EgtGetName( nRib1) == EgtGetName( nRib2) then + return false end - return bValid + local bInters = false + local ptInt + + -- porto le curve nel gruppo locale + local nCrv1 = EgtCopyGlob( nRib1, nGrp) + local nCrv2 = EgtCopyGlob( nRib2, nGrp) + -- verifico se si intersecano + ptInt = EgtIP( nCrv1, nCrv2, ORIG(), GDB_ID.ROOT) + + -- se non si intersecano, verifico se si intersecano i loro offset + if not ptInt then + local bFound = false + local vOffs1 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv1)) + local vOffs2 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv2)) + for i = 1, #vOffs1 do + local nOffs1 = EgtCopyGlob( vOffs1[i], nGrp) + for j = 1, #vOffs2 do + -- porto nel gruppo locale e verifico se intersezione + local nOffs2 = EgtCopyGlob( vOffs2[j], nGrp) + ptInt = EgtIP( nOffs1, nOffs2, ORIG(), GDB_ID.ROOT) + if ptInt then + bFound = true + break + end + end + if bFound then break end + end + end + + -- se intersezione verifico se valida + if ptInt then + local nPtId = EgtPoint( nGrp, ptInt, GDB_RT.GLOB) + if nType1 == RIB_TYPE.INTERNAL or nType2 == RIB_TYPE.INTERNAL then + -- l'intersezione deve essere interna + if nSrf1 and not EgtSurfFrTestExternal( nSrf1, nPtId) then bInters = true end + elseif nType1 == RIB_TYPE.EXTERNAL or nType2 == RIB_TYPE.EXTERNAL then + -- l'intersezione deve essere esterna + if nSrf2 and EgtSurfFrTestExternal( nSrf2, nPtId) then bInters = true end + else + -- nel caso unbounded l'intersezione può essere ovunque + bInters = true + end + end + + return bInters, ptInt end --------------------------------------------------------------------------------- @@ -492,11 +533,11 @@ local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nOffs local nOverlap2 = EgtGetInfo( nCrv2, KEY_RIBS_OVERLAP, 'i') local nOverlap = min( nOverlap1, nOverlap2) local dOffs = ( nShells - 1) * LayerParams.dStrand / 2 - local nSrf = EgtSurfFrFatCurve( nOffsGrp, nCrv1, dOffs + ( 1 - nOverlap / 100) * LayerParams.dStrand, false) + local nSrf = EgtSurfFrFatCurve( nOffsGrp, nCrv1, dOffs + ( 1 - nOverlap / 100) * LayerParams.dStrand, false) if not nSrf then return end -- trim degli offset della curva secondaria ( nCrv2) - local vOffs2 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv2)) + local vOffs2 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv2)) or {} for i = 1, #vOffs2 do local nId, nCnt = EgtTrimCurveWithRegion( vOffs2[i], nSrf, false, true) EgtChangeId( nId, vOffs2[i]) @@ -513,7 +554,7 @@ local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nOffs end -------------------------------------------------------------------- --- Funzione che sistema le intersezioni fra costolature nel caso di 2 passate +-- Funzione che sistema le intersezioni fra costolature nel caso di 2 passate local function AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nOffsGrp) -- costruisco le superfici da usare per trim @@ -536,7 +577,7 @@ local function AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams end -- trim degli offset di nCrv2 - local vOffs2 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv2)) + local vOffs2 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv2)) for i = 1, #vOffs2 do local nId, nCnt = EgtTrimCurveWithRegion( vOffs2[i], nSrf1, false, true) end @@ -567,28 +608,23 @@ local function UpdateSplitOrder( nCrv, tInters, nOffsGrp) end end end - end -------------------------------------------------------------------- local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, bAllTwoStrands) - local nCrvGrp = EgtGetParent( nRibsPathGrp) + local vRibsIds = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') -- copio gli offset delle costolature nel RibsPathGrp + local nCrvGrp = EgtGetParent( nRibsPathGrp) local vOffsRib = EgtGetAllInGroup( nOffsGrp) for i = 1, #vOffsRib do EgtCopyGlob( vOffsRib[i], nRibsPathGrp) end - -- copio i setti in un gruppo con frame locale per calcolare le intersezioni + -- creo un gruppo con frame locale per calcolare le intersezioni local frLoc = Frame3d( ORIG(), LayerParams.vtSlicing) local nGrpTmp = EgtGroup( nRibsGrp, frLoc, GDB_RT.GLOB) - local vOrigRibsIds = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') - local vRibsIds = {} - for i = 1, #vOrigRibsIds do - table.insert( vRibsIds, EgtCopyGlob( vOrigRibsIds[i], nGrpTmp)) - end - + -- calcolo le regioni nella quali ha senso considerare l'intersezione local nSrfOffs1, nSrfOffs2 local bOk, bExists @@ -611,62 +647,56 @@ local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPa local vSplit = {} local tInters = {} -- tabella che tiene traccia delle intersezioni trovate for i = 1, #vRibsIds do - local nType1 = EgtGetInfo( vRibsIds[i], KEY_RIBS_TYPE, 'i') + -- verifico se interseca uno dei setti successivi for j = i + 1, #vRibsIds do - -- verifico se i due setti possono intersecarsi in base alla loro tipologia local nType2 = EgtGetInfo( vRibsIds[j], KEY_RIBS_TYPE, 'i') - if not ( ( nType1 == RIB_TYPE.INTERNAL and nType2 == RIB_TYPE.EXTERNAL) or ( nType1 == RIB_TYPE.EXTERNAL and nType2 == RIB_TYPE.INTERNAL)) then + + local bRibInters, ptInt = VerifyRibsIntersection( vRibsIds[i], vRibsIds[j], nType1, nType2, nSrfOffs1, nSrfOffs2, nGrpTmp, nOffsGrp) + if bRibInters then + bInters = true - local ptInt = EgtIP( vRibsIds[i], vRibsIds[j], ORIG()) - if ptInt then - - -- verifico se l'interserzione è valida - if VerifyRibsIntersection( ptInt, nType1, nType2, nSrfOffs1, nSrfOffs2, nGrpTmp) then - bInters = true - - local dPar1 = EgtCurveParamAtPoint( vRibsIds[i], ptInt) - local dPar2 = EgtCurveParamAtPoint( vRibsIds[j], ptInt) - local _, dParE1 = EgtCurveDomain( vRibsIds[i]) - local _, dParE2 = EgtCurveDomain( vRibsIds[j]) - - local nCrv1 = vOrigRibsIds[i] -- curva principale che non viene tagliata - local nCrv2 = vOrigRibsIds[j] -- curve secondaria da modificare - local nSplitOrder1 = EgtGetInfo( nCrv1, KEY_SPLIT_ORDER, 'i') or 0 - local nSplitOrder2 = EgtGetInfo( nCrv2, KEY_SPLIT_ORDER, 'i') or 0 - if dPar1 < 10 * GEO.EPS_SMALL or abs( dPar1 - dParE1) < 10 * GEO.EPS_SMALL then - nCrv1, nCrv2 = nCrv2, nCrv1 - nSplitOrder1, nSplitOrder2 = nSplitOrder2, nSplitOrder1 - else - -- prediligo setto già splittato più volte - if nSplitOrder1 > nSplitOrder2 then - nCrv1, nCrv2 = nCrv2, nCrv1 - nSplitOrder1, nSplitOrder2 = nSplitOrder2, nSplitOrder1 - end - end - - -- aggiorno tabella delle intersezioni - if tInters[nCrv1] then - table.insert( tInters[nCrv1], nCrv2) - else - tInters[nCrv1] = {nCrv2} - end - - -- aggiorno ordine di split - if nSplitOrder2 < nSplitOrder1 + 1 then - EgtSetInfo( nCrv2, KEY_SPLIT_ORDER, nSplitOrder1 + 1) - UpdateSplitOrder( nCrv2, tInters, nRibsPathGrp) - end - - if bAllTwoStrands then - -- nel caso di 2 passate gestione speciale - AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nRibsPathGrp) - else - AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nRibsPathGrp) - end + local dPar1 = EgtCurveParamAtPoint( vRibsIds[i], ptInt, GEO.EPS_SMALL, GDB_RT.GLOB) + local dPar2 = EgtCurveParamAtPoint( vRibsIds[j], ptInt, GEO.EPS_SMALL, GDB_RT.GLOB) + local _, dParE1 = EgtCurveDomain( vRibsIds[i]) + local _, dParE2 = EgtCurveDomain( vRibsIds[j]) + + local nCrv1 = vRibsIds[i] -- curva principale che non viene tagliata + local nCrv2 = vRibsIds[j] -- curve secondaria da modificare + local nSplitOrder1 = EgtGetInfo( nCrv1, KEY_SPLIT_ORDER, 'i') or 0 + local nSplitOrder2 = EgtGetInfo( nCrv2, KEY_SPLIT_ORDER, 'i') or 0 + local bCrv1OnExtr = dPar1 and ( dPar1 < 10 * GEO.EPS_SMALL or abs( dPar1 - dParE1) < 10 * GEO.EPS_SMALL) + local bCrv2OnExtr = dPar2 and ( dPar2 < 10 * GEO.EPS_SMALL or abs( dPar2 - dParE2) < 10 * GEO.EPS_SMALL) + if ( dPar1 and not dPar2) or ( bCrv1OnExtr and not bCrv2OnExtr) then + nCrv1, nCrv2 = nCrv2, nCrv1 + nSplitOrder1, nSplitOrder2 = nSplitOrder2, nSplitOrder1 + else + -- prediligo setto già splittato più volte + if nSplitOrder1 > nSplitOrder2 then + nCrv1, nCrv2 = nCrv2, nCrv1 + nSplitOrder1, nSplitOrder2 = nSplitOrder2, nSplitOrder1 end - EgtErase( nPtId) + end + + -- aggiorno tabella delle intersezioni + if tInters[nCrv1] then + table.insert( tInters[nCrv1], nCrv2) + else + tInters[nCrv1] = {nCrv2} + end + + -- aggiorno ordine di split + if nSplitOrder2 < nSplitOrder1 + 1 then + EgtSetInfo( nCrv2, KEY_SPLIT_ORDER, nSplitOrder1 + 1) + UpdateSplitOrder( nCrv2, tInters, nRibsPathGrp) + end + + if bAllTwoStrands and ( nType1 == nType2) then + -- nel caso di 2 passate e stessa tipologia gestione speciale per creare unico percorso + AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nRibsPathGrp) + else + AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nRibsPathGrp) end end end @@ -711,12 +741,13 @@ end --------------------------------------------------------------------- -- Funzione che riordina le costolature nel caso generico -local function ReorderRibs( nGrp, bInvertOrder, bDoLinkFirst, dStrand, nMaxNbr) +local function ReorderRibs( nGrp, bInvertOrder, bDoLinkFirst, dStrand, nMaxNbr, vTypeSequence) + + local vIds = EgtGetNameInGroup( nGrp, RIBS_CRV .. '*') + if not vIds or #vIds == 0 then return end -- raggruppo per tipologia local tRibs = {{}, {}, {}} - local vIds = EgtGetNameInGroup( nGrp, RIBS_CRV .. '*') - if not vIds or #vIds == 0 then return end for i = 1, #vIds do local nType = EgtGetInfo( vIds[i], KEY_RIBS_TYPE, 'i') table.insert( tRibs[nType], vIds[i]) @@ -725,28 +756,29 @@ local function ReorderRibs( nGrp, bInvertOrder, bDoLinkFirst, dStrand, nMaxNbr) -- riordino ogni tipologia con shortest path local vSplitRibs = {} for i = 1, 3 do + local nCurrType = vTypeSequence[i] local tSplitOrder = {} local nMax = -1 -- raggruppo i ribs - for j = 1, #tRibs[i] do - local nInfoSplit = EgtGetInfo( tRibs[i][j], KEY_SPLIT_RIB, 'i') - local nShells = EgtGetInfo( tRibs[i][j], KEY_RIBS_SHELLS_NBR, 'i') + for j = 1, #tRibs[nCurrType] do + local nInfoSplit = EgtGetInfo( tRibs[nCurrType][j], KEY_SPLIT_RIB, 'i') + local nShells = EgtGetInfo( tRibs[nCurrType][j], KEY_RIBS_SHELLS_NBR, 'i') if nInfoSplit and nShells == 1 then -- se è ottenuto dalla divisione di una costolatura - table.insert( vSplitRibs, tRibs[i][j]) + table.insert( vSplitRibs, tRibs[nCurrType][j]) else -- classifico in base all'ordine di split e al link - local nSplitOrder = EgtGetInfo( tRibs[i][j], KEY_SPLIT_ORDER, 'i') or 0 - local bLink = EgtGetInfo( tRibs[i][j], KEY_RIBS_LINK, 'b') or false + local nSplitOrder = EgtGetInfo( tRibs[nCurrType][j], KEY_SPLIT_ORDER, 'i') or 0 + local bLink = EgtGetInfo( tRibs[nCurrType][j], KEY_RIBS_LINK, 'b') or false if nSplitOrder > nMax then nMax = nSplitOrder end if not tSplitOrder[nSplitOrder] then tSplitOrder[nSplitOrder]= {{}, {}} end if bLink then - table.insert( tSplitOrder[nSplitOrder][2], tRibs[i][j]) + table.insert( tSplitOrder[nSplitOrder][2], tRibs[nCurrType][j]) else - table.insert( tSplitOrder[nSplitOrder][1], tRibs[i][j]) + table.insert( tSplitOrder[nSplitOrder][1], tRibs[nCurrType][j]) end end end @@ -754,11 +786,13 @@ local function ReorderRibs( nGrp, bInvertOrder, bDoLinkFirst, dStrand, nMaxNbr) local bLinkFirst = bDoLinkFirst -- riordino ogni ordine di split for k = 0, nMax do - ShortestPathForRibs( EgtIf( bLinkFirst, tSplitOrder[k][2], tSplitOrder[k][1]), nGrp, bInvertOrder) - ShortestPathForRibs( EgtIf( bLinkFirst, tSplitOrder[k][1], tSplitOrder[k][2]), nGrp, bInvertOrder) - -- eventuale aggiornamento di bLinkFirst per l'ordine successivo - if not ( ( not bLinkFirst and #tSplitOrder[k][2] == 0) or ( bLinkFirst and #tSplitOrder[k][1] == 0)) then - bLinkFirst = not bLinkFirst + if tSplitOrder[k] then + ShortestPathForRibs( EgtIf( bLinkFirst, tSplitOrder[k][2], tSplitOrder[k][1]), nGrp, bInvertOrder) + ShortestPathForRibs( EgtIf( bLinkFirst, tSplitOrder[k][1], tSplitOrder[k][2]), nGrp, bInvertOrder) + -- eventuale aggiornamento di bLinkFirst per l'ordine successivo + if not ( ( not bLinkFirst and #tSplitOrder[k][2] == 0) or ( bLinkFirst and #tSplitOrder[k][1] == 0)) then + bLinkFirst = not bLinkFirst + end end end end @@ -811,9 +845,7 @@ local function ReassignInfo( nCrv, nCnt, vOrig) local ptS = EgtSP( nId) local ptE = EgtEP( nId) - -- info overlap - local nOverlap = EgtGetInfo( s_nPartId, KEY_RIBS_OVERLAP, 'i') - EgtSetInfo( nId, KEY_RIBS_OVERLAP, nOverlap) + EgtSetInfo( nId, KEY_TYPE, TYPE.RIB) local bStart = false local bEnd = false @@ -828,6 +860,7 @@ local function ReassignInfo( nCrv, nCnt, vOrig) CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_IN_INVERT, 'b') CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_IN_LEN, 'd') CopyInfo( vOrig[i], nId, KEY_ASSOCIATED_SURF, 'i') + CopyInfo( vOrig[i], nId, KEY_RIBS_OVERLAP, 'i') CopyInfo( vOrig[i], nId, KEY_RIBS_TYPE, 'i') bStart = true end @@ -852,29 +885,24 @@ end --------------------------------------------------------------------------------------------- -- Funzione che riordina le costolature nel caso di intersezioni e 2 passate -local function ReorderRibsInters2Shells( nOffsGrp, dStrand) +local function ReorderRibsInters2Shells( nOffsGrp, dStrand, vTypeSequence) local vOffs = EgtGetNameInGroup( nOffsGrp, RIBS_CRV .. '*') - local bUnboundedRib = false -- copio le curve originali ( per recuperarne le info) local vCopy = {} for i = 1, #vOffs do local nNewId = EgtCopy( vOffs[i], nOffsGrp) table.insert( vCopy, nNewId) - local nType = EgtGetInfo( nNewId, KEY_RIBS_TYPE, 'i') - if nType == RIB_TYPE.UNBOUNDED then - bUnboundedRib = true - end end -- concateno le curve local nCrv, nCnt = EgtCurveCompoByChain( nOffsGrp, vOffs, ORIG()) - local vIds = {} for i = nCrv, nCrv + nCnt - 1 do - EgtSetInfo( i, KEY_TYPE, TYPE.RIB) table.insert( vIds, i) end + -- recupero le info dalle curve originali + ReassignInfo( nCrv, nCnt, vCopy) local k = 0 -- indice da utilizzare per i nomi while #vIds > 0 do @@ -888,9 +916,12 @@ local function ReorderRibsInters2Shells( nOffsGrp, dStrand) local nCnt = 0 -- scorro alla ricerca di una curva che posso collegare alla corrente while nCurrCrv do + local nCurrType = EgtGetInfo( nCurrCrv, KEY_RIBS_TYPE, 'i') local bFound = false for j = 1, #vIds do - if vIds[j] ~= nCrv and not EgtCurveIsClosed(vIds[j]) then + local nType = EgtGetInfo( vIds[j], KEY_RIBS_TYPE, 'i') + + if vIds[j] ~= nCrv and not EgtCurveIsClosed(vIds[j]) and nCurrType == nType then -- verifico se il collegamento è possibile local bAdd = false @@ -917,7 +948,7 @@ local function ReorderRibsInters2Shells( nOffsGrp, dStrand) if dParE - dParMinDist < 500 * GEO.EPS_SMALL then bAdd = true -- altrimenti può essere vicino allo start - elseif dParMinDist < 500 * GEO.EPS_SMALL and nCnt == 0 then + elseif dParMinDist < 500 * GEO.EPS_SMALL and nCnt == 0 then bAdd = true EgtInvertCurve( nCurrCrv) end @@ -937,7 +968,7 @@ local function ReorderRibsInters2Shells( nOffsGrp, dStrand) end end - if bAdd then + if bAdd then bFound = true nCnt = nCnt + 1 EgtRelocateGlob( vIds[j], nCurrCrv, GDB_IN.AFTER) @@ -967,20 +998,21 @@ local function ReorderRibsInters2Shells( nOffsGrp, dStrand) end end - -- Recupero le info dalle curve originali - ReassignInfo( nCrv, nCnt, vCopy) - - -- riordino per tipologia ( prima iterni poi esterni) nel caso senza unbounded - if not bUnboundedRib then - local vCrvs = EgtGetNameInGroup( nOffsGrp, RIBS_CRV .. '*') - for nId = 1, #vCrvs do - local nType = EgtGetInfo( vCrvs[nId], KEY_RIBS_TYPE, 'i') - if nType == RIB_TYPE.EXTERNAL then - EgtRelocateGlob( vCrvs[nId], EgtGetParent( nCrv), GDB_IN.LAST_SON) - end + -- classifico in base alla tipologia + local vCrvs = EgtGetNameInGroup( nOffsGrp, RIBS_CRV .. '*') + local tRibs = {{}, {}, {}} + for nId = 1, #vCrvs do + local nType = EgtGetInfo( vCrvs[nId], KEY_RIBS_TYPE, 'i') + table.insert( tRibs[nType], vCrvs[nId]) + end + -- riordino per tipologia + for i = 1, 3 do + nCurrType = vTypeSequence[i] + for j = 1, #tRibs[nCurrType] do + EgtRelocateGlob( tRibs[nCurrType][j], nOffsGrp, GDB_IN.LAST_SON) end end - + end ------------------------------------------------------------------- @@ -1131,15 +1163,29 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, nIdx) -- aggiorno le info di split con i nuovi id UpdateRibSplitInfo( nRibsPathGrp, tOldNewIds, tRemoved) - + + -- stabilisco ordine di realizzazione delle varie tipologie + local vTypeSequence = {RIB_TYPE.INTERNAL, RIB_TYPE.EXTERNAL, RIB_TYPE.UNBOUNDED} + if LayerParams.nRibsPrintOrder == RIB_PRINT_ORDER.INT_UNBDD_EXT then + vTypeSequence = {RIB_TYPE.INTERNAL, RIB_TYPE.UNBOUNDED, RIB_TYPE.EXTERNAL} + elseif LayerParams.nRibsPrintOrder == RIB_PRINT_ORDER.EXT_INT_UNBDD then + vTypeSequence = {RIB_TYPE.EXTERNAL, RIB_TYPE.INTERNAL, RIB_TYPE.UNBOUNDED} + elseif LayerParams.nRibsPrintOrder == RIB_PRINT_ORDER.EXT_UNBDD_INT then + vTypeSequence = {RIB_TYPE.EXTERNAL, RIB_TYPE.UNBOUNDED, RIB_TYPE.INTERNAL} + elseif LayerParams.nRibsPrintOrder == RIB_PRINT_ORDER.UNBDD_INT_EXT then + vTypeSequence = {RIB_TYPE.UNBOUNDED, RIB_TYPE.INTERNAL, RIB_TYPE.EXTERNAL} + elseif LayerParams.nRibsPrintOrder == RIB_PRINT_ORDER.UNBDD_EXT_INT then + vTypeSequence = {RIB_TYPE.UNBOUNDED, RIB_TYPE.EXTERNAL, RIB_TYPE.INTERNAL} + end + -- riordino le costolature if bAllTwoStrands and bInters then -- gestione caso speciale di intersezione e 2 passate - ReorderRibsInters2Shells( nRibsPathGrp, LayerParams.dStrand) + ReorderRibsInters2Shells( nRibsPathGrp, LayerParams.dStrand, vTypeSequence) else - ReorderRibs( nRibsPathGrp, LayerParams.bRibsInvertOrder, LayerParams.bRibsDoLinkFirst, LayerParams.dStrand, nMaxNbr) + ReorderRibs( nRibsPathGrp, LayerParams.bRibsInvertOrder, LayerParams.bRibsDoLinkFirst, LayerParams.dStrand, nMaxNbr, vTypeSequence) end - + if not EgtGetFirstNameInGroup( nRibsPathGrp, RIBS_CRV .. '*') then EgtErase( nRibsPathGrp) end @@ -1361,7 +1407,7 @@ local function ReorderExtraShells( nPathGrp, dStrand, vPtStart, bPrintInvert) local bFound = false for j = 1, #vIds do - if not EgtCurveIsClosed( vIds[j]) then + if not EgtCurveIsClosed( vIds[j]) then local ptS = EgtSP( vIds[j]) local ptE = EgtEP( vIds[j]) diff --git a/LuaLibs/RunSlicing.lua b/LuaLibs/RunSlicing.lua index 4e2e44d..05113a8 100644 --- a/LuaLibs/RunSlicing.lua +++ b/LuaLibs/RunSlicing.lua @@ -147,6 +147,7 @@ local function LoadParams( sFile, nPartId) end SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_OVERLAP, '0.0') + SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_PRINT_ORDER, '1') SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_SHELLS_NBR, '0') SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_INVERT_DIR, '0') SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_INVERT_ORDER, '0')