Egalware/3dprinting
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

3dPrinting :

Browse Source 
- migliorata intersezione setti
- aggiunto ordine di realizzazione per tipologie setti.
This commit is contained in:
SaraP
2022-11-24 16:09:16 +01:00
parent 0a78833f61
commit 8622fc8919
3 changed files with 180 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files
LuaLibs/CalcPaths.lua
+169 -123
View File
@@ -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])