From 2d78f4d3487eeef68270fd2f87f00ca9e41e9c7b Mon Sep 17 00:00:00 2001 From: SaraP Date: Tue, 12 May 2026 15:09:52 +0200 Subject: [PATCH] 3dPrinting : - ottimizzazioni nella fase di slicing - migliorata la funzione che chiude buchi nei setti. --- LuaLibs/CalcPaths.lua | 89 ++++---- LuaLibs/CalcSlices.lua | 501 +++++++++++++++++++++-------------------- 2 files changed, 306 insertions(+), 284 deletions(-) diff --git a/LuaLibs/CalcPaths.lua b/LuaLibs/CalcPaths.lua index 778231f..0417107 100644 --- a/LuaLibs/CalcPaths.lua +++ b/LuaLibs/CalcPaths.lua @@ -702,51 +702,50 @@ end -------------------------------------------------------------------- local function VerifyRibsHoles( vIds) + -- raggruppo i setti per nome + local tabRibs = { { vIds[1]}} local sPrevName = EgtGetName( vIds[1]) - local i = 2 - while i <= #vIds do - - local bAdd = false - local sCurrName = EgtGetName( vIds[i]) - -- se derivano dallo stesso setto verifico se possono essere uniti - if sCurrName == sPrevName then - local dStrand = EgtGetInfo( vIds[i], KEY_RIBS_STRAND, 'd') - local ptS1 = EgtSP( vIds[i-1]) - local ptE1 = EgtEP( vIds[i-1]) - local ptS2 = EgtSP( vIds[i]) - local ptE2 = EgtEP( vIds[i]) - - local bAdd1 = dist( ptS1, ptE2) < dStrand + 10 * GEO.EPS_SMALL - local bAdd2 = dist( ptE1, ptS2) < dStrand + 10 * GEO.EPS_SMALL - bAdd = bAdd1 or bAdd2 - - if bAdd1 and bAdd2 then - -- da unire in setto chiuso - EgtAddCurveCompoLine( vIds[i-1], ptE2, false) - EgtAddCurveCompoLine( vIds[i-1], ptS2) - EgtAddCurveCompoCurve( vIds[i-1], vIds[i]) - table.remove( vIds, i) -- rimuovo il setto dalla tabella - - elseif bAdd2 then - -- unisco il secondo tratto al primo - EgtAddCurveCompoLine( vIds[i-1], ptS2) - EgtAddCurveCompoCurve( vIds[i-1], vIds[i]) - table.remove( vIds, i) -- rimuovo il setto dalla tabella - - elseif bAdd1 then - -- unisco il primo tratto al secondo - EgtAddCurveCompoLine( vIds[i], ptS1) - EgtAddCurveCompoCurve( vIds[i], vIds[i-1]) - table.remove( vIds, i-1) -- rimuovo il setto dalla tabella - end - end - - -- aggiorno per iterazione successiva - sPrevName = sCurrName - if not bAdd then - i = i + 1 + for i = 2, #vIds do + if sPrevName == EgtGetName( vIds[i]) then + table.insert( tabRibs[#tabRibs], vIds[i]) + else + sPrevName = EgtGetName( vIds[i]) + table.insert( tabRibs, { vIds[i]}) end end + + -- verifico se posso concatenare le curve con lo stesso nome usando come tolleranza lo strand del setto ( se le passate si toccano non ha senso tenerle separate) + local nGrp = EgtGetParent( vIds[1]) + for i = 1, #tabRibs do + if #tabRibs[i] > 1 then + local dStrand = EgtGetInfo( tabRibs[i][1], KEY_RIBS_STRAND, 'd') + + -- gruppo temporaneo per il concatenamento + local nGrpTmp = EgtGroup( nGrp) + for j = 1, #tabRibs[i] do + EgtRelocateGlob( tabRibs[i][j], nGrpTmp) + end + EgtReorderCurvesInGroup( nGrpTmp, EgtSP( tabRibs[i][1], GDB_ID.ROOT), GDB_RT.GLOB, dStrand) + + -- recupero le curve e le concateno se possibile + local vNewIds = EgtGetAllInGroup( nGrpTmp) + local nCurrId = vNewIds[1] + EgtRelocateGlob( nCurrId, nGrp) + for j = 2, #vNewIds do + if dist( EgtEP( nCurrId, GDB_ID.ROOT), EgtSP( vNewIds[j], GDB_ID.ROOT)) < dStrand + GEO.EPS_SMALL then + EgtAddCurveCompoLine( nCurrId, EgtSP( vNewIds[j], GDB_ID.ROOT), GDB_RT.GLOB) + EgtAddCurveCompoCurve( nCurrId, vNewIds[j]) + else + nCurrId = vNewIds[j] + EgtRelocateGlob( nCurrId, nGrp) + end + end + EgtErase( nGrpTmp) + end + end + + -- aggiorno gli id + return EgtGetAllInGroup( nGrp) end -------------------------------------------------------------------- @@ -2369,7 +2368,7 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart, bIgnor end -- verifico se posso ignorare eventuali buchi nei setti - VerifyRibsHoles( vOrigRibs) + vOrigRibs = VerifyRibsHoles( vOrigRibs) local nTotSrfInt = GDB_ID.NULL local nTotSrfExt = GDB_ID.NULL @@ -2912,7 +2911,7 @@ end local function PrepareRibsForMergeWithShells( vOrigRibs, nGrp, dStrand, dOverlap, bInvertRibsOrder) -- verifico se sono presenti buchi che possono essere chiusi - VerifyRibsHoles( vOrigRibs) + vOrigRibs = VerifyRibsHoles( vOrigRibs) -- trim grossolano dei setti local nSrfCoarseTrim = EgtGetFirstNameInGroup( nGrp, COARSE_TRIM_SURF) @@ -3371,7 +3370,7 @@ local function CalcRibsMergedShells( nSlicedRibsGrp, nPathGrp, LayerParams, vPtS end end if #vOrigRibs == 0 then return true end - + -- recupero le shell da unire ai setti local nLast = EgtGetLastInGroup( nPathGrp) or GDB_ID.NULL local nShellType = EgtGetInfo( nLast, KEY_TYPE, 'i') diff --git a/LuaLibs/CalcSlices.lua b/LuaLibs/CalcSlices.lua index 0b42ce5..4a699d0 100644 --- a/LuaLibs/CalcSlices.lua +++ b/LuaLibs/CalcSlices.lua @@ -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