3dPrinting :
- ottimizzazioni nella fase di slicing - migliorata la funzione che chiude buchi nei setti.
This commit is contained in:
SaraP
+44
-45
@@ -702,51 +702,50 @@ end
|
||||
--------------------------------------------------------------------
|
||||
local function VerifyRibsHoles( vIds)
|
||||
|
||||
-- raggruppo i setti per nome
|
||||
local tabRibs = { { vIds[1]}}
|
||||
local sPrevName = EgtGetName( vIds[1])
|
||||
local i = 2
|
||||
while i <= #vIds do
|
||||
|
||||
local bAdd = false
|
||||
local sCurrName = EgtGetName( vIds[i])
|
||||
-- se derivano dallo stesso setto verifico se possono essere uniti
|
||||
if sCurrName == sPrevName then
|
||||
local dStrand = EgtGetInfo( vIds[i], KEY_RIBS_STRAND, 'd')
|
||||
local ptS1 = EgtSP( vIds[i-1])
|
||||
local ptE1 = EgtEP( vIds[i-1])
|
||||
local ptS2 = EgtSP( vIds[i])
|
||||
local ptE2 = EgtEP( vIds[i])
|
||||
|
||||
local bAdd1 = dist( ptS1, ptE2) < dStrand + 10 * GEO.EPS_SMALL
|
||||
local bAdd2 = dist( ptE1, ptS2) < dStrand + 10 * GEO.EPS_SMALL
|
||||
bAdd = bAdd1 or bAdd2
|
||||
|
||||
if bAdd1 and bAdd2 then
|
||||
-- da unire in setto chiuso
|
||||
EgtAddCurveCompoLine( vIds[i-1], ptE2, false)
|
||||
EgtAddCurveCompoLine( vIds[i-1], ptS2)
|
||||
EgtAddCurveCompoCurve( vIds[i-1], vIds[i])
|
||||
table.remove( vIds, i) -- rimuovo il setto dalla tabella
|
||||
|
||||
elseif bAdd2 then
|
||||
-- unisco il secondo tratto al primo
|
||||
EgtAddCurveCompoLine( vIds[i-1], ptS2)
|
||||
EgtAddCurveCompoCurve( vIds[i-1], vIds[i])
|
||||
table.remove( vIds, i) -- rimuovo il setto dalla tabella
|
||||
|
||||
elseif bAdd1 then
|
||||
-- unisco il primo tratto al secondo
|
||||
EgtAddCurveCompoLine( vIds[i], ptS1)
|
||||
EgtAddCurveCompoCurve( vIds[i], vIds[i-1])
|
||||
table.remove( vIds, i-1) -- rimuovo il setto dalla tabella
|
||||
end
|
||||
end
|
||||
|
||||
-- aggiorno per iterazione successiva
|
||||
sPrevName = sCurrName
|
||||
if not bAdd then
|
||||
i = i + 1
|
||||
for i = 2, #vIds do
|
||||
if sPrevName == EgtGetName( vIds[i]) then
|
||||
table.insert( tabRibs[#tabRibs], vIds[i])
|
||||
else
|
||||
sPrevName = EgtGetName( vIds[i])
|
||||
table.insert( tabRibs, { vIds[i]})
|
||||
end
|
||||
end
|
||||
|
||||
-- verifico se posso concatenare le curve con lo stesso nome usando come tolleranza lo strand del setto ( se le passate si toccano non ha senso tenerle separate)
|
||||
local nGrp = EgtGetParent( vIds[1])
|
||||
for i = 1, #tabRibs do
|
||||
if #tabRibs[i] > 1 then
|
||||
local dStrand = EgtGetInfo( tabRibs[i][1], KEY_RIBS_STRAND, 'd')
|
||||
|
||||
-- gruppo temporaneo per il concatenamento
|
||||
local nGrpTmp = EgtGroup( nGrp)
|
||||
for j = 1, #tabRibs[i] do
|
||||
EgtRelocateGlob( tabRibs[i][j], nGrpTmp)
|
||||
end
|
||||
EgtReorderCurvesInGroup( nGrpTmp, EgtSP( tabRibs[i][1], GDB_ID.ROOT), GDB_RT.GLOB, dStrand)
|
||||
|
||||
-- recupero le curve e le concateno se possibile
|
||||
local vNewIds = EgtGetAllInGroup( nGrpTmp)
|
||||
local nCurrId = vNewIds[1]
|
||||
EgtRelocateGlob( nCurrId, nGrp)
|
||||
for j = 2, #vNewIds do
|
||||
if dist( EgtEP( nCurrId, GDB_ID.ROOT), EgtSP( vNewIds[j], GDB_ID.ROOT)) < dStrand + GEO.EPS_SMALL then
|
||||
EgtAddCurveCompoLine( nCurrId, EgtSP( vNewIds[j], GDB_ID.ROOT), GDB_RT.GLOB)
|
||||
EgtAddCurveCompoCurve( nCurrId, vNewIds[j])
|
||||
else
|
||||
nCurrId = vNewIds[j]
|
||||
EgtRelocateGlob( nCurrId, nGrp)
|
||||
end
|
||||
end
|
||||
EgtErase( nGrpTmp)
|
||||
end
|
||||
end
|
||||
|
||||
-- aggiorno gli id
|
||||
return EgtGetAllInGroup( nGrp)
|
||||
end
|
||||
|
||||
--------------------------------------------------------------------
|
||||
@@ -2369,7 +2368,7 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart, bIgnor
|
||||
end
|
||||
|
||||
-- verifico se posso ignorare eventuali buchi nei setti
|
||||
VerifyRibsHoles( vOrigRibs)
|
||||
vOrigRibs = VerifyRibsHoles( vOrigRibs)
|
||||
|
||||
local nTotSrfInt = GDB_ID.NULL
|
||||
local nTotSrfExt = GDB_ID.NULL
|
||||
@@ -2912,7 +2911,7 @@ end
|
||||
local function PrepareRibsForMergeWithShells( vOrigRibs, nGrp, dStrand, dOverlap, bInvertRibsOrder)
|
||||
|
||||
-- verifico se sono presenti buchi che possono essere chiusi
|
||||
VerifyRibsHoles( vOrigRibs)
|
||||
vOrigRibs = VerifyRibsHoles( vOrigRibs)
|
||||
|
||||
-- trim grossolano dei setti
|
||||
local nSrfCoarseTrim = EgtGetFirstNameInGroup( nGrp, COARSE_TRIM_SURF)
|
||||
@@ -3371,7 +3370,7 @@ local function CalcRibsMergedShells( nSlicedRibsGrp, nPathGrp, LayerParams, vPtS
|
||||
end
|
||||
end
|
||||
if #vOrigRibs == 0 then return true end
|
||||
|
||||
|
||||
-- recupero le shell da unire ai setti
|
||||
local nLast = EgtGetLastInGroup( nPathGrp) or GDB_ID.NULL
|
||||
local nShellType = EgtGetInfo( nLast, KEY_TYPE, 'i')
|
||||
|
||||
+262
-239
@@ -257,110 +257,7 @@ local function GetAuxSolidsParams( nId)
|
||||
end
|
||||
|
||||
--------------------------------------------------------------------
|
||||
local function SliceStm( vIds, nLayId, vtSlicing, ptSlicing, nType, sName, sNameGrp, tabParams)
|
||||
|
||||
if not vIds or #vIds == 0 then return end
|
||||
|
||||
local nLayCnt = EgtGetInfo( nLayId, KEY_SLICE_NBR, 'i')
|
||||
-- recupero il gruppo dove salvare lo slicing degli oggetti
|
||||
local nGrp = EgtGetFirstNameInGroup( nLayId, sNameGrp)
|
||||
if not nGrp then
|
||||
-- se gruppo non esiste lo creo
|
||||
nGrp = EgtGroup( nLayId)
|
||||
EgtSetName( nGrp, sNameGrp)
|
||||
EgtSetStatus( nGrp, GDB_ST.OFF)
|
||||
end
|
||||
|
||||
-- recupero quota per slicing
|
||||
local dDeltaZ = EgtGetInfo( nLayId, KEY_SLICE_DELTAZ, 'd')
|
||||
local ptOn = ptSlicing + dDeltaZ * vtSlicing
|
||||
|
||||
for i = 1, #vIds do
|
||||
-- verifico che oggetto sia trimesh
|
||||
local nTypeObj = EgtGetType( vIds[i])
|
||||
if nTypeObj == GDB_TY.SRF_MESH then
|
||||
-- slicing oggetto
|
||||
local nNewId, nPntCnt, nCrvCnt, nSrfCnt = EgtPlaneSurfTmInters( ptOn, vtSlicing, vIds[i], nGrp, GDB_RT.GLOB, TOLER)
|
||||
|
||||
-- verifico se necessario ricalcolo
|
||||
local dCorr = 0
|
||||
local bOpen = false
|
||||
if nType ~= TYPE.RIB and nType ~= TYPE.INFILL and nNewId then
|
||||
for nId = nNewId + nPntCnt, nNewId + nPntCnt + nCrvCnt - 1 do
|
||||
if not EgtCurveIsClosed( nId) then
|
||||
bOpen = true
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
-- eventuale ricalcolo ( se superfici o curve aperte)
|
||||
if nSrfCnt > 0 or bOpen then
|
||||
EgtOutLog( 'Warning : recalc at layer '.. EgtNumToString( nLayCnt) .. ' (object)')
|
||||
-- elimino vecchio risultato
|
||||
for j = nNewId, nNewId + nPntCnt + nCrvCnt + nSrfCnt - 1 do
|
||||
EgtErase( j)
|
||||
end
|
||||
dCorr = 0.01
|
||||
nNewId, nPntCnt, nCrvCnt, nSrfCnt = EgtPlaneSurfTmInters( ptOn + dCorr * vtSlicing, vtSlicing, vIds[i], nGrp, GDB_RT.GLOB, TOLER)
|
||||
end
|
||||
|
||||
if nNewId then
|
||||
|
||||
-- rimuovo punti
|
||||
for nId = nNewId, nNewId + nPntCnt -1 do
|
||||
EgtErase( nId)
|
||||
end
|
||||
|
||||
-- concateno le curve
|
||||
local vChain = {}
|
||||
for nId = nNewId + nPntCnt, nNewId + nPntCnt + nCrvCnt - 1 do
|
||||
table.insert( vChain, nId)
|
||||
end
|
||||
local nChainId, nCnt = EgtCurveCompoByChain( nGrp, vChain, ORIG(), true, GDB_RT.LOC, TOLER)
|
||||
if not nChainId then
|
||||
-- se fallisce riprendo le curve originali
|
||||
nChainId = nNewId + nPntCnt
|
||||
nCnt = nCrvCnt
|
||||
end
|
||||
-- rinomino le curve, correggo di DeltaZ e assegno parametri
|
||||
for nId = nChainId, nChainId + nCnt - 1 do
|
||||
EgtSetName( nId, sName .. EgtNumToString( i))
|
||||
EgtMove( nId, - ( dDeltaZ + dCorr) * vtSlicing)
|
||||
EgtSetInfo( nId, KEY_ORIGINAL_SURF, vIds[i])
|
||||
if tabParams then
|
||||
for sKey, sVal in pairs( tabParams[i]) do
|
||||
EgtSetInfo( nId, sKey, sVal)
|
||||
end
|
||||
end
|
||||
EgtModifyCurveExtrusion( nId, vtSlicing, GDB_RT.GLOB)
|
||||
EgtApproxCurve( nId, GDB_CA.ARCS, MID_TOLER)
|
||||
|
||||
-- se ho ancora curve aperte, segnalo errore
|
||||
if nType ~= TYPE.RIB and nType ~= TYPE.INFILL and not EgtCurveIsClosed( nId) then
|
||||
EgtOutLog( 'Error : hole in object (layer '.. EgtNumToString( nLayCnt) ..') - CalcSlices')
|
||||
table.insert( s_vErr, nLayCnt)
|
||||
end
|
||||
end
|
||||
|
||||
-- rimuovo superfici
|
||||
for nId = nNewId + nPntCnt + nCrvCnt, nNewId + nPntCnt + nCrvCnt + nSrfCnt - 1 do
|
||||
EgtErase( nId)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- verifico che il gruppo non sia vuoto
|
||||
if not EgtGetFirstInGroup( nGrp) then
|
||||
EgtErase( nGrp)
|
||||
nGrp = nil
|
||||
end
|
||||
|
||||
return nGrp
|
||||
end
|
||||
|
||||
--------------------------------------------------------------------
|
||||
local function SlicingExtraObjects( nLay, nType, sName, sNameGrp, nStmId)
|
||||
local function SlicingExtraObjects( nLay, vSlicingDir, vSlicingVal, nSlicingType, nType, sName, sNameGrp, nStmId)
|
||||
|
||||
if not nLay then return end
|
||||
|
||||
@@ -395,30 +292,128 @@ local function SlicingExtraObjects( nLay, nType, sName, sNameGrp, nStmId)
|
||||
end
|
||||
|
||||
-- taglio i setti unbounded e limitati con il solido
|
||||
local bLimitUnbddRibs = EgtGetInfo( s_nPartId, KEY_LIMIT_UNBDD_RIBS, 'b') or false
|
||||
local vEraseIds = {}
|
||||
if nType == TYPE.RIB and bLimitUnbddRibs then
|
||||
for i = 1, #vSliceIds do
|
||||
if tabParams[i][KEY_RIBS_TYPE] == RIB_TYPE.UNBOUNDED then
|
||||
-- creo copia e la taglio con solido
|
||||
local nCopy = EgtCopyGlob( vSliceIds[i], EgtGetParent( vSliceIds[i]))
|
||||
EgtSurfTmCut( nCopy, nStmId, true, true)
|
||||
-- lo slicing va fatto sulla copia
|
||||
vSliceIds[i] = nCopy
|
||||
table.insert( vEraseIds, nCopy)
|
||||
if nStmId then
|
||||
local bLimitUnbddRibs = EgtGetInfo( s_nPartId, KEY_LIMIT_UNBDD_RIBS, 'b') or false
|
||||
if nType == TYPE.RIB and bLimitUnbddRibs then
|
||||
for i = 1, #vSliceIds do
|
||||
if tabParams[i][KEY_RIBS_TYPE] == RIB_TYPE.UNBOUNDED then
|
||||
-- creo copia e la taglio con solido
|
||||
local nCopy = EgtCopyGlob( vSliceIds[i], EgtGetParent( vSliceIds[i]))
|
||||
EgtSurfTmCut( nCopy, nStmId, true, true)
|
||||
-- lo slicing va fatto sulla copia
|
||||
vSliceIds[i] = nCopy
|
||||
table.insert( vEraseIds, nCopy)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- per ogni layer calcolo lo slicing degli oggetti
|
||||
local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER .. '*')
|
||||
for i = 1, #vLayIds do
|
||||
-- ricavo piano di slicing
|
||||
local ptSlicing = EgtGetInfo( vLayIds[i], KEY_SLICE_POS, 'p')
|
||||
local vtSlicing = EgtGetInfo( vLayIds[i], KEY_SLICE_DIR, 'v')
|
||||
SliceStm( vSliceIds, vLayIds[i], vtSlicing, ptSlicing, nType, sName, sNameGrp, tabParams)
|
||||
end
|
||||
|
||||
for i = 1, #vSliceIds do
|
||||
-- effettuo lo slicing in layer separati ( analogamente a quanto avviene con il solido)
|
||||
local nResId
|
||||
if nSlicingType ~= SLICING_TYPE.MULTIPLANAR and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_DEG45 and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_HOR then
|
||||
nResId = EgtParPlanesSurfTmInters( ORIG(), vSlicingDir[1], vSlicingVal, vSliceIds[i], s_nPartId, GDB_RT.GLOB, TOLER)
|
||||
else
|
||||
for j = 1, #vSlicingVal do
|
||||
local vtN = vSlicingDir[j]
|
||||
local ptOn = vSlicingVal[j]
|
||||
if j == 1 then
|
||||
ptOn = ptOn + DELTAZ * vtN
|
||||
end
|
||||
|
||||
local nGrpId = EgtGroup( s_nPartId)
|
||||
if not nResId then
|
||||
nResId = nGrpId
|
||||
end
|
||||
EgtPlaneSurfTmInters( ptOn, vtN, vSliceIds[i], nGrpId, GDB_RT.GLOB, TOLER)
|
||||
end
|
||||
end
|
||||
|
||||
-- recupero i risultati e li sposto nei layers opportuni
|
||||
local j = 1
|
||||
while nResId do
|
||||
local vtSlicing = vSlicingDir[j] or vSlicingDir[1]
|
||||
|
||||
-- recupero il gruppo nel layer dove salvare lo slicing degli oggetti o lo creo se non esiste
|
||||
local nGrp = EgtGetFirstNameInGroup( vLayIds[j], sNameGrp)
|
||||
if not nGrp then
|
||||
nGrp = EgtGroup( vLayIds[j])
|
||||
EgtSetName( nGrp, sNameGrp)
|
||||
EgtSetStatus( nGrp, GDB_ST.OFF)
|
||||
end
|
||||
|
||||
-- verifico se necessario ricalcolo
|
||||
local nId = EgtGetLastInGroup( nResId)
|
||||
local bRecalc = false
|
||||
local vtRecalc
|
||||
while nId and not bRecalc do
|
||||
local nGeoType = EgtGetType( nId)
|
||||
if nGeoType == GDB_TY.SRF_MESH then
|
||||
bRecalc = true
|
||||
vtRecalc = EgtSurfTmFacetNormVersor( nId, 0)
|
||||
elseif nGeoType == GDB_TY.GEO_POINT then
|
||||
bRecalc = true
|
||||
elseif nType ~= TYPE.RIB and nType ~= TYPE.INFILL and not EgtCurveIsClosed( nId) then
|
||||
bRecalc = true
|
||||
end
|
||||
nId = EgtGetPrev( nId)
|
||||
end
|
||||
|
||||
-- eseguo eventuale ricalcolo
|
||||
local dDeltaZ = EgtIf( j == 1, DELTAZ, 0)
|
||||
if bRecalc then
|
||||
EgtEmptyGroup( nResId)
|
||||
dDeltaZ = dDeltaZ + EgtIf( vtRecalc and vtRecalc:getZ() > 0, - DELTAZ, DELTAZ)
|
||||
-- eseguo il ricalcolo solo a quella quota
|
||||
local ptSlicing = EgtGetInfo( vLayIds[j], KEY_SLICE_POS, 'p')
|
||||
local ptOn = ptSlicing + dDeltaZ * vtSlicing
|
||||
EgtPlaneSurfTmInters( ptOn, vtSlicing, vSliceIds[i], nResId, GDB_RT.GLOB, TOLER)
|
||||
EgtOutLog( 'Warning : recalc at layer '.. EgtNumToString( j))
|
||||
end
|
||||
|
||||
-- recupero tutte le curve
|
||||
local vAllIds = EgtGetAllInGroup( nResId)
|
||||
local vCrvIds = {}
|
||||
for k = 1, #vAllIds do
|
||||
local nGeoType = EgtGetType( nId)
|
||||
if nGeoType ~= GDB_TY.SRF_MESH and nGeoType ~= GDB_TY.GEO_POINT then
|
||||
table.insert( vCrvIds, vAllIds[k])
|
||||
end
|
||||
end
|
||||
|
||||
if #vCrvIds > 0 then
|
||||
-- concateno le curve, le rinomino, correggo di DeltaZ e assegno i parametri
|
||||
local nChainId, nCnt = EgtCurveCompoByChain( nGrp, vCrvIds, ORIG(), true, GDB_RT.LOC, TOLER)
|
||||
for nId = nChainId, nChainId + nCnt - 1 do
|
||||
EgtSetName( nId, sName .. EgtNumToString( i))
|
||||
EgtMove( nId, - dDeltaZ * vtSlicing)
|
||||
EgtSetInfo( nId, KEY_ORIGINAL_SURF, vSliceIds[i])
|
||||
if tabParams then
|
||||
for sKey, sVal in pairs( tabParams[i]) do
|
||||
EgtSetInfo( nId, sKey, sVal)
|
||||
end
|
||||
end
|
||||
EgtModifyCurveExtrusion( nId, vtSlicing, GDB_RT.GLOB)
|
||||
EgtApproxCurve( nId, GDB_CA.ARCS, MID_TOLER)
|
||||
|
||||
-- se ho ancora curve aperte, segnalo errore
|
||||
if nType ~= TYPE.RIB and nType ~= TYPE.INFILL and not EgtCurveIsClosed( nId) then
|
||||
EgtOutLog( 'Error : hole in object (layer '.. EgtNumToString( j) ..') - CalcSlices')
|
||||
table.insert( s_vErr, j)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
local nOldId = nResId
|
||||
nResId = EgtGetNext( nResId)
|
||||
j = j + 1
|
||||
EgtErase( nOldId)
|
||||
end
|
||||
end
|
||||
|
||||
-- rimuovo eventuali oggetti creati per lo slicing
|
||||
EgtErase( vEraseIds)
|
||||
|
||||
@@ -446,17 +441,54 @@ local function SlicingInfill( nLay, sName, sNameGrp)
|
||||
-- recupero i dati di slicing
|
||||
local ptSlicing = EgtGetInfo( vLayIds[i], KEY_SLICE_POS, 'p')
|
||||
local vtSlicing = EgtGetInfo( vLayIds[i], KEY_SLICE_DIR, 'v')
|
||||
local nResultLay = SliceStm( tIds[nGrpIdx], vLayIds[i], vtSlicing, ptSlicing, TYPE.INFILL, sName, sNameGrp)
|
||||
-- sistemo i nomi delle curve
|
||||
local vInfillCrvs = EgtGetAllInGroup( nResultLay)
|
||||
for j = 1, #vInfillCrvs do
|
||||
EgtSetName( vInfillCrvs[j], sName .. EgtNumToString(j))
|
||||
|
||||
local nGrp = EgtGetFirstNameInGroup( vLayIds[i], sNameGrp)
|
||||
if not nGrp then
|
||||
-- se gruppo non esiste lo creo
|
||||
nGrp = EgtGroup( vLayIds[i])
|
||||
EgtSetName( nGrp, sNameGrp)
|
||||
EgtSetStatus( nGrp, GDB_ST.OFF)
|
||||
end
|
||||
|
||||
local vInfillIds = tIds[nGrpIdx]
|
||||
for j = 1, #vInfillIds do
|
||||
-- verifico che oggetto sia trimesh
|
||||
local nTypeObj = EgtGetType( vInfillIds[j])
|
||||
if nTypeObj == GDB_TY.SRF_MESH then
|
||||
-- slicing
|
||||
local nNewId, nPntCnt, nCrvCnt, nSrfCnt = EgtPlaneSurfTmInters( ptSlicing, vtSlicing, vInfillIds[j], nGrp, GDB_RT.GLOB, TOLER)
|
||||
|
||||
-- rimuovo punti
|
||||
for nId = nNewId, nNewId + nPntCnt -1 do
|
||||
EgtErase( nId)
|
||||
end
|
||||
|
||||
-- concateno le curve
|
||||
local vChain = {}
|
||||
for nId = nNewId + nPntCnt, nNewId + nPntCnt + nCrvCnt - 1 do
|
||||
table.insert( vChain, nId)
|
||||
end
|
||||
local nChainId, nCnt = EgtCurveCompoByChain( nGrp, vChain, ORIG(), true, GDB_RT.LOC, TOLER)
|
||||
-- sistemo le curve
|
||||
for nId = nChainId, nChainId + nCnt - 1 do
|
||||
EgtSetName( nId, sName .. EgtNumToString(j))
|
||||
EgtSetInfo( nId, KEY_ORIGINAL_SURF, vInfillIds[j])
|
||||
EgtModifyCurveExtrusion( nId, vtSlicing, GDB_RT.GLOB)
|
||||
EgtApproxCurve( nId, GDB_CA.ARCS, MID_TOLER)
|
||||
end
|
||||
|
||||
-- rimuovo superfici
|
||||
for nId = nNewId + nPntCnt + nCrvCnt, nNewId + nPntCnt + nCrvCnt + nSrfCnt - 1 do
|
||||
EgtErase( nId)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return true
|
||||
end
|
||||
|
||||
|
||||
----------------------------------------------------------------------
|
||||
----------------------------- INFILL ---------------------------------
|
||||
----------------------------------------------------------------------
|
||||
@@ -633,7 +665,7 @@ local function CalcGridFromPattern( nInfillGrp, nStmId, dOffsStm, frRef, vtOffs,
|
||||
b3Loc2:expand( dOffsStm)
|
||||
local ptMin2 = b3Loc2:getMin()
|
||||
local ptMax2 = b3Loc2:getMax()
|
||||
|
||||
|
||||
-- creo curva base ruotando la curva base della direzione principale
|
||||
local nCrvBase2 = EgtCopyGlob( nCrvBase, nMainGrp)
|
||||
EgtRotate( nCrvBase2, ptCen, Z_AX(), vSlicesAng[i] - vSlicesAng[1])
|
||||
@@ -700,7 +732,7 @@ local function CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, dG
|
||||
local ptLast = EgtGetInfo( nLastLay, KEY_SLICE_POS, 'p')
|
||||
local dZ = ( ptLast - ORIG()) * vtSlicing
|
||||
for i = 1, #vCrvs do
|
||||
EgtSurfTmByExtrusion( EgtGetParent( vCrvs[i]), vCrvs[i], ( dZ + 100) * vtSlicing, GDB_RT.GLOB)
|
||||
EgtSurfTmByExtrusion( EgtGetParent( vCrvs[i]), vCrvs[i], ( dZ + 100) * vtSlicing, 0.05, GDB_RT.GLOB)
|
||||
end
|
||||
EgtErase( vCrvs)
|
||||
|
||||
@@ -792,14 +824,9 @@ local function ExtractRibsLoops( nRibsGrp, nStmId)
|
||||
-- recupero tutti i setti
|
||||
local vIds = EgtGetAllInGroup( nRibsGrp)
|
||||
for i = 1, #vIds do
|
||||
-- se trimesh
|
||||
-- se trimesh estraggo i contorni
|
||||
if EgtGetType( vIds[i]) == GDB_TY.SRF_MESH then
|
||||
-- trim con il solido
|
||||
local nCopy = EgtCopyGlob( vIds[i], nLoopGrp)
|
||||
local nType = ReadParam( vIds[i], KEY_RIBS_TYPE, 'i', RIB_TYPE.INTERNAL)
|
||||
EgtSurfTmCut( nCopy, nStmId, nType ~= RIB_TYPE.EXTERNAL, false)
|
||||
-- estraggo i contorni
|
||||
local nCrv, nCnt = EgtExtractSurfTmLoops( nCopy, nLoopGrp)
|
||||
local nCrv, nCnt = EgtExtractSurfTmLoops( vIds[i], nLoopGrp)
|
||||
if nCrv then
|
||||
-- assegno nome che permetta di ricondurli alla superficie da cui derivano
|
||||
for nId = nCrv, nCrv + nCnt - 1 do
|
||||
@@ -820,107 +847,6 @@ local function ValueInArray( vArr, nValue)
|
||||
return false
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
local function SlicingNoSolid( nRibsLay, nSlicingType, dMaxH, dSliceStep, vSlicingVal, vSlicingDir)
|
||||
|
||||
-- contatore per il calcolo delle intersezioni
|
||||
if EgtProcessEvents( 100, 0) == 1 then return false end
|
||||
|
||||
-- recupero i setti di cui fare lo slicing e i parametri associati
|
||||
local vRibIds = EgtGetAllInGroup( nRibsLay)
|
||||
local tabParams = {}
|
||||
local vIds = {}
|
||||
for i = 1, #vRibIds do
|
||||
if EgtGetType( vRibIds[i]) == GDB_TY.SRF_MESH then
|
||||
local vParams = GetRibParams( vRibIds[i])
|
||||
if vParams[KEY_RIBS_SHELLS_NBR] > 0 then
|
||||
table.insert( tabParams, vParams)
|
||||
table.insert( vIds, vRibIds[i])
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- creo i layer dello slicing
|
||||
for i = 1, #vSlicingVal do
|
||||
-- creo layer e gruppo dei contorni
|
||||
local nLayId = EgtGroup( s_nPartId)
|
||||
EgtSetName( nLayId, SLICE_LAYER .. EgtNumToString( i))
|
||||
EgtSetInfo( nLayId, KEY_SLICE_NBR, i)
|
||||
local nCrvLayId = EgtGroup( nLayId)
|
||||
EgtSetName( nCrvLayId, CONTOUR_GRP .. EgtNumToString( 0))
|
||||
|
||||
-- recupero i dati del piano di slicing
|
||||
local dDeltaZ = EgtIf( i == 1, DELTAZ, 0)
|
||||
local ptSlicing
|
||||
local vtSlicing
|
||||
if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
|
||||
vtSlicing = vtSlicing[i]
|
||||
ptSlicing = vSlicingVal[i]
|
||||
else
|
||||
vtSlicing = vSlicingDir[1]
|
||||
ptSlicing = ORIG() + ( vSlicingVal[i] - dDeltaZ) * vtSlicing
|
||||
end
|
||||
EgtSetInfo( nLayId, KEY_SLICE_POS, ptSlicing)
|
||||
EgtSetInfo( nLayId, KEY_SLICE_DIR, vtSlicing)
|
||||
EgtSetInfo( nLayId, KEY_SLICE_DELTAZ, dDeltaZ)
|
||||
|
||||
-- slicing dei setti
|
||||
local nResultLay = SliceStm( vIds, nLayId, vtSlicing, ptSlicing, TYPE.RIB, RIBS_CRV, RIBS_GRP, tabParams)
|
||||
|
||||
-- se slicing multplanare verifico altezza massima
|
||||
if ( nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR) and dMaxH < GEO.INFINITO then
|
||||
local b3Box = EgtGetBBoxGlob( nResultLay, GDB_BB.STANDARD)
|
||||
local ptMax = b3Box:getMax() + dSliceStep * vtSlicing
|
||||
if ptMax:getZ() > dMaxH + GEO.EPS_SMALL then
|
||||
EgtErase( nLayId)
|
||||
break
|
||||
end
|
||||
end
|
||||
|
||||
if EgtProcessEvents( EgtIf( PRINT, 100, 0) + i / #vSlicingVal * 100, 0) == 1 then return false end
|
||||
end
|
||||
|
||||
return true
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
local function MultiPlanarSlicing( nStmId, dMaxH, vSlicingDir, vSlicingPnt)
|
||||
|
||||
local dSliceStep = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd')
|
||||
-- ciclo sui piani di slicing calcolati
|
||||
local nFirstGrpId
|
||||
local nCnt = 0
|
||||
for i = 1, #vSlicingPnt do
|
||||
local vtN = vSlicingDir[i]
|
||||
local ptOn = vSlicingPnt[i]
|
||||
-- correzione per layer iniziale
|
||||
if i == 1 then
|
||||
ptOn = ptOn + DELTAZ * vtN
|
||||
end
|
||||
|
||||
local nGrpId = EgtGroup( s_nPartId)
|
||||
if not nFirstGrpId then
|
||||
nFirstGrpId = nGrpId
|
||||
end
|
||||
local nEntId = EgtPlaneSurfTmInters( ptOn, vtN, nStmId, nGrpId, GDB_RT.GLOB, TOLER)
|
||||
-- eventuale verifica con altezza massima
|
||||
if dMaxH < GEO.INFINITO then
|
||||
local b3Box = EgtGetBBoxGlob( nGrpId, GDB_BB.STANDARD)
|
||||
local ptMax = b3Box:getMax() + dSliceStep * vtN
|
||||
if ptMax:getZ() > dMaxH + GEO.EPS_SMALL then
|
||||
EgtErase( nGrpId)
|
||||
break
|
||||
end
|
||||
end
|
||||
nCnt = i + 1
|
||||
-- aggiornamento progress ( per riconoscimento corretto della fase dal programma deve partire da 1)
|
||||
if EgtProcessEvents( max( 1, 100 * i / #vSlicingPnt), 0) == 1 then
|
||||
return nFirstGrpId, -1
|
||||
end
|
||||
end
|
||||
return nFirstGrpId, nCnt
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
local function VerifyMultiPlanarStrand()
|
||||
|
||||
@@ -1022,6 +948,103 @@ local function VerifyMultiPlanarStrand()
|
||||
return true
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
local function SlicingNoSolid( nRibsLay, nSlicingType, dMaxH, dSliceStep, vSlicingVal, vSlicingDir)
|
||||
|
||||
-- contatore per il calcolo delle intersezioni
|
||||
if EgtProcessEvents( 100, 0) == 1 then return false end
|
||||
|
||||
-- creo i layer dello slicing
|
||||
for i = 1, #vSlicingVal do
|
||||
-- creo layer e gruppo dei contorni
|
||||
local nLayId = EgtGroup( s_nPartId)
|
||||
EgtSetName( nLayId, SLICE_LAYER .. EgtNumToString( i))
|
||||
EgtSetInfo( nLayId, KEY_SLICE_NBR, i)
|
||||
local nCrvLayId = EgtGroup( nLayId)
|
||||
EgtSetName( nCrvLayId, CONTOUR_GRP .. EgtNumToString( 0))
|
||||
|
||||
-- recupero i dati del piano di slicing
|
||||
local dDeltaZ = EgtIf( i == 1, DELTAZ, 0)
|
||||
local ptSlicing
|
||||
local vtSlicing
|
||||
if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
|
||||
vtSlicing = vSlicingDir[i]
|
||||
ptSlicing = vSlicingVal[i]
|
||||
else
|
||||
vtSlicing = vSlicingDir[1]
|
||||
ptSlicing = ORIG() + ( vSlicingVal[i] - dDeltaZ) * vtSlicing
|
||||
end
|
||||
EgtSetInfo( nLayId, KEY_SLICE_POS, ptSlicing)
|
||||
EgtSetInfo( nLayId, KEY_SLICE_DIR, vtSlicing)
|
||||
EgtSetInfo( nLayId, KEY_SLICE_DELTAZ, dDeltaZ)
|
||||
|
||||
if EgtProcessEvents( EgtIf( PRINT, 100, 0) + i / #vSlicingVal * 100, 0) == 1 then return false end
|
||||
end
|
||||
|
||||
-- slicing dei setti
|
||||
SlicingExtraObjects( nRibsLay, vSlicingDir, vSlicingVal, nSlicingType, TYPE.RIB, RIBS_CRV, RIBS_GRP)
|
||||
|
||||
-- se slicing multplanare verifico altezza massima e strand
|
||||
if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
|
||||
if dMaxH < GEO.INFINITO then
|
||||
local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER .. '*')
|
||||
for i = 1, #vLayIds do
|
||||
local nCurrRibsLay = EgtGetFirstNameInGroup( vLayIds[i], RIBS_GRP)
|
||||
local b3Box = EgtGetBBoxGlob( nCurrRibsLay, GDB_BB.STANDARD)
|
||||
local ptMax = b3Box:getMax() + dSliceStep * vSlicingDir[i]
|
||||
if ptMax:getZ() > dMaxH + GEO.EPS_SMALL then
|
||||
-- elimino tutti i layer da questo punto
|
||||
for j = i, #vLayIds do
|
||||
EgtErase( vLayIds[j])
|
||||
end
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
VerifyMultiPlanarStrand()
|
||||
end
|
||||
|
||||
return true
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
local function MultiPlanarSlicing( nStmId, dMaxH, vSlicingDir, vSlicingPnt)
|
||||
|
||||
local dSliceStep = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd')
|
||||
-- ciclo sui piani di slicing calcolati
|
||||
local nFirstGrpId
|
||||
local nCnt = 0
|
||||
for i = 1, #vSlicingPnt do
|
||||
local vtN = vSlicingDir[i]
|
||||
local ptOn = vSlicingPnt[i]
|
||||
-- correzione per layer iniziale
|
||||
if i == 1 then
|
||||
ptOn = ptOn + DELTAZ * vtN
|
||||
end
|
||||
|
||||
local nGrpId = EgtGroup( s_nPartId)
|
||||
if not nFirstGrpId then
|
||||
nFirstGrpId = nGrpId
|
||||
end
|
||||
local nEntId = EgtPlaneSurfTmInters( ptOn, vtN, nStmId, nGrpId, GDB_RT.GLOB, TOLER)
|
||||
-- eventuale verifica con altezza massima
|
||||
if dMaxH < GEO.INFINITO then
|
||||
local b3Box = EgtGetBBoxGlob( nGrpId, GDB_BB.STANDARD)
|
||||
local ptMax = b3Box:getMax() + dSliceStep * vtN
|
||||
if ptMax:getZ() > dMaxH + GEO.EPS_SMALL then
|
||||
EgtErase( nGrpId)
|
||||
break
|
||||
end
|
||||
end
|
||||
nCnt = i + 1
|
||||
-- aggiornamento progress ( per riconoscimento corretto della fase dal programma deve partire da 1)
|
||||
if EgtProcessEvents( max( 1, 100 * i / #vSlicingPnt), 0) == 1 then
|
||||
return nFirstGrpId, -1
|
||||
end
|
||||
end
|
||||
return nFirstGrpId, nCnt
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
local function SlicingWithSolid( nStmId, nSlicingType, dMaxH, vSlicingVal, vSlicingDir)
|
||||
|
||||
@@ -1319,7 +1342,7 @@ local function SlicingWithSolid( nStmId, nSlicingType, dMaxH, vSlicingVal, vSlic
|
||||
-- costolature
|
||||
local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS)
|
||||
ExtractRibsLoops( nRibsLay, nStmId)
|
||||
SlicingExtraObjects( nRibsLay, TYPE.RIB, RIBS_CRV, RIBS_GRP, nStmId)
|
||||
SlicingExtraObjects( nRibsLay, vSlicingDir, vSlicingVal, nSlicingType, TYPE.RIB, RIBS_CRV, RIBS_GRP, nStmId)
|
||||
if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( nCnt + 3) / nCounterTot * 100, 0) == 1 then return false end
|
||||
|
||||
local bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false
|
||||
@@ -1332,12 +1355,12 @@ local function SlicingWithSolid( nStmId, nSlicingType, dMaxH, vSlicingVal, vSlic
|
||||
|
||||
-- solidi per regioni con diverso numero di passate
|
||||
local nShellNbrLay = EgtGetFirstNameInGroup( s_nPartId, LAY_SHELL_NBR)
|
||||
SlicingExtraObjects( nShellNbrLay, TYPE.EXTRA_SHELL, SHELL_NBR_CRV, SHELL_NBR_GRP)
|
||||
SlicingExtraObjects( nShellNbrLay, vSlicingDir, vSlicingVal, nSlicingType, TYPE.EXTRA_SHELL, SHELL_NBR_CRV, SHELL_NBR_GRP)
|
||||
if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( nCnt + 9) / nCounterTot * 100, 0) == 1 then return false end
|
||||
|
||||
-- solidi ausiliari
|
||||
local nAuxSolidsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_AUX_SOLIDS)
|
||||
SlicingExtraObjects( nAuxSolidsLay, TYPE.AUX_SOLID, AUX_SOLIDS_CRV, AUX_SOLIDS_GRP)
|
||||
SlicingExtraObjects( nAuxSolidsLay, vSlicingDir, vSlicingVal, nSlicingType, TYPE.AUX_SOLID, AUX_SOLIDS_CRV, AUX_SOLIDS_GRP)
|
||||
if nSlicingType ~= SLICING_TYPE.MULTIPLANAR and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_DEG45 and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_HOR then
|
||||
PrepareAuxSolidsInfill( nAuxSolidsLay, vSlicingDir[1])
|
||||
end
|
||||
|
||||
Reference in New Issue
Block a user