3dPrinting :
- prima gestione solidi ausiliari ( solo riempimenti pieni) - gestione floor/ceil - modifiche progress bar.
This commit is contained in:
SaraP
+538
-140
@@ -23,6 +23,9 @@ local function GetLayerParamsForPathCalc()
|
||||
LayerParams.dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd')
|
||||
LayerParams.dOffs = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd')
|
||||
LayerParams.nFloorNbr = EgtGetInfo( s_nPartId, KEY_FLOOR_NBR, 'i')
|
||||
LayerParams.nFloorType = EgtGetInfo( s_nPartId, KEY_FLOOR_TYPE, 'i')
|
||||
LayerParams.nCeilNbr = EgtGetInfo( s_nPartId, KEY_CEIL_NBR, 'i')
|
||||
LayerParams.nCeilType = EgtGetInfo( s_nPartId, KEY_CEIL_TYPE, 'i')
|
||||
LayerParams.vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v')
|
||||
LayerParams.bPrintInvert = ( EgtGetInfo( s_nPartId, KEY_PRINT_DIRECTION, 'i') == PRINT_DIRECTION.CW)
|
||||
-- parametri costolature
|
||||
@@ -97,15 +100,13 @@ local function ModifyStartPoint( nCrvId, vPtStart)
|
||||
end
|
||||
end
|
||||
EgtChangeClosedCurveStartPoint( nCrvId, vPtStart[nMinIdx])
|
||||
else
|
||||
-- se non ci sono start point disponibili prendo l'origine
|
||||
EgtChangeClosedCurveStartPoint( nCrvId, Point3d( 0, 0, 0), GDB_RT.GLOB)
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
local function GetPathsFromSurf( nSrfId, sName, nType, nGrpId, vPtStart)
|
||||
|
||||
local vIds = {}
|
||||
local nChunks = EgtSurfFrChunkCount( nSrfId)
|
||||
for nC = 0, nChunks - 1 do
|
||||
-- estraggo i contorni
|
||||
@@ -127,38 +128,263 @@ local function GetPathsFromSurf( nSrfId, sName, nType, nGrpId, vPtStart)
|
||||
return
|
||||
end
|
||||
|
||||
table.insert( vIds, nCrvId + nInd)
|
||||
ModifyStartPoint( nCrvId + nInd, vPtStart)
|
||||
end
|
||||
end
|
||||
|
||||
return vIds
|
||||
end
|
||||
|
||||
----------------------------------------------------------------------
|
||||
local function VerifyPath( nCrvId, dStrand, vtSlicing, nGrp)
|
||||
|
||||
local _, _, dArea = EgtCurveArea( nCrvId)
|
||||
|
||||
-- verifico se esiste l'offset (permetto una piccola sovrapposizione)
|
||||
local dAllowedOverlap = 1
|
||||
local nRes, nCnt = EgtOffsetCurveAdv( nCrvId, - dStrand / 2 + dAllowedOverlap)
|
||||
-- se errore ritento con valore leggermente modificato
|
||||
if not nRes then
|
||||
nRes, nCnt = EgtOffsetCurveAdv( nCrvId, - dStrand / 2 + 0.05)
|
||||
if not nRes then return false end
|
||||
end
|
||||
for j = nRes, nRes + nCnt - 1 do
|
||||
EgtErase( j)
|
||||
end
|
||||
|
||||
if nRes == GDB_ID.NULL or not dArea or dArea < GEO.EPS_SMALL then
|
||||
-- verifico se fattibile con una sola passata
|
||||
-- TODO da sistemare con medial axis per curva generica
|
||||
local bSingleStrand = false
|
||||
if EgtCurveIsClosed( nCrvId) then
|
||||
local nGrpTmp = EgtGroup( nGrp, Frame3d( ORIG(), vtSlicing))
|
||||
EgtRelocateGlob( nCrvId, nGrpTmp)
|
||||
local frLoc, dDimX, dDimY = EgtCurveMinAreaRectangleXY( nCrvId)
|
||||
if dDimY < 0.5 then
|
||||
-- TODO curva generica
|
||||
local dZ = EgtSP( nCrvId):getZ()
|
||||
-- creo la curva che corrisponde alla sigola passata
|
||||
local ptS = frLoc:getOrigin() - dDimX / 2 * frLoc:getVersX() + dZ * Z_AX()
|
||||
local ptE = frLoc:getOrigin() + dDimX / 2 * frLoc:getVersX() + dZ * Z_AX()
|
||||
if dist( ptS, ptE) > 5 then
|
||||
local nId = EgtCurveCompoFromPoints( nGrpTmp, { ptS, ptE})
|
||||
local sName = EgtGetName( nCrvId)
|
||||
if sName then EgtSetName( nId, sName) end
|
||||
local nType = EgtGetInfo( nCrvId, KEY_TYPE, 'i')
|
||||
if nType then EgtSetInfo( nId, KEY_TYPE, nType) end
|
||||
EgtErase( nCrvId)
|
||||
EgtChangeId( nId, nCrvId)
|
||||
bSingleStrand = true
|
||||
end
|
||||
end
|
||||
EgtRelocateGlob( nCrvId, nGrp, GDB_IN.LAST_SON)
|
||||
EgtErase( nGrpTmp)
|
||||
end
|
||||
-- se non è fattibile con unica passata lo cancello
|
||||
if not bSingleStrand then
|
||||
EgtErase( nCrvId)
|
||||
return false
|
||||
end
|
||||
end
|
||||
|
||||
return true
|
||||
end
|
||||
|
||||
-------------------------------------------------------------------
|
||||
local function ComputeTrimSurfWithOverlaps( vIds, nSrfBase, sKeyOverlap, dStrand, nGrp)
|
||||
|
||||
-- per ogni overlap creo le superfici con cui fare i trim
|
||||
local vSurfOffs = {}
|
||||
for i = 1, #vIds do
|
||||
local nOverlap = EgtGetInfo( vIds[i], sKeyOverlap, 'i')
|
||||
if not vSurfOffs[nOverlap] then
|
||||
local dNewOffs = nOverlap / 100 * dStrand
|
||||
local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrfBase, nGrp, dNewOffs)
|
||||
if bOk then
|
||||
vSurfOffs[nOverlap] = nSrfOffs
|
||||
end
|
||||
end
|
||||
end
|
||||
return vSurfOffs
|
||||
end
|
||||
|
||||
--------------------------------------------------------------------
|
||||
--------------------- RIEMPIMENTI PIENI ----------------------------
|
||||
--------------------------------------------------------------------
|
||||
local function ReorderPath( vOldIds, vNewIds)
|
||||
|
||||
if not vNewIds then return end
|
||||
if #vOldIds == 1 and #vNewIds == 1 then
|
||||
EgtRelocateGlob( vNewIds[1], vOldIds[1], GDB_IN.AFTER)
|
||||
return
|
||||
end
|
||||
|
||||
-- associo ad ogni elemento di vOldIds gli elementi di vNewIds che contiene
|
||||
local vOrdered = {}
|
||||
if #vOldIds == 1 then
|
||||
vOrdered[vOldIds[1]] = vNewIds
|
||||
else
|
||||
local nGrp = EgtGetParent( vOldIds[1])
|
||||
-- creo le superifici a partire dalle curve in vOldIds
|
||||
local vOldSurf = {}
|
||||
for i = 1, #vOldIds do
|
||||
local nSrf = EgtSurfFlatRegion( nGrp, {vOldIds[i]})
|
||||
table.insert( vOldSurf, EgtIf( nSrf, nSrf, GDB_ID.NULL))
|
||||
end
|
||||
|
||||
for i = 1, #vNewIds do
|
||||
for j = 1, #vOldSurf do
|
||||
if vOldSurf[j] ~= GDB_ID.NULL then
|
||||
if not EgtSurfFrTestExternal( vOldSurf[j], vNewIds[i]) then
|
||||
if vOrdered[vOldIds[j]] then
|
||||
table.insert( vOrdered[vOldIds[j]], vNewIds[i])
|
||||
else
|
||||
vOrdered[vOldIds[j]] = {vNewIds[i]}
|
||||
end
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
for i = 1, #vOldSurf do
|
||||
EgtErase( vOldSurf[i])
|
||||
end
|
||||
end
|
||||
|
||||
-- riordino
|
||||
for nParentIdx, vChildren in pairs( vOrdered) do
|
||||
if #vChildren == 1 then
|
||||
-- se racchiude solo una curva
|
||||
EgtRelocateGlob( vChildren[1], nParentIdx, GDB_IN.AFTER)
|
||||
else
|
||||
EgtSpInit()
|
||||
-- se racchiude più curve uso shortest path per ordinarle
|
||||
for j = 1, #vChildren do
|
||||
local pt = EgtCP( vChildren[j])
|
||||
EgtSpAddPoint( pt:getX(), pt:getY(), pt:getZ(), 0, 0, pt:getX(), pt:getY(), pt:getZ(), 0, 0)
|
||||
end
|
||||
local ptS = EgtSP( nParentIdx)
|
||||
EgtSpSetOpenBound( true, SHP_OB.NEAR_PNT, ptS:getX(), ptS:getY(), ptS:getZ(), 0, 0)
|
||||
local vOrd, _ = EgtSpCalculate( SHP_TY.OPEN)
|
||||
EgtSpTerminate()
|
||||
|
||||
for j = #vOrd, 1, -1 do
|
||||
EgtRelocateGlob( vChildren[vOrd[j]], nParentIdx, GDB_IN.AFTER)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
--------------------------------------------------------------------
|
||||
local function AddFloor( nSrfId, nGrpId, LayerParams, nFloorNbr)
|
||||
---------------------------------------------------------------------------
|
||||
local function ComputeOffsetInfill( nSrf, dStrand, vtSlicing, sName, nType, vPtStart, nGrp)
|
||||
|
||||
-- local nSrfCopy = EgtCopyGlob( nSrfId, nGrpId)
|
||||
-- local dOffs = 0.5 * LayerParams.dStrand - LayerParams.dOffs + LayerParams.nShellsNbr * LayerParams.dStrand
|
||||
-- local dAng = 0
|
||||
--
|
||||
-- if EgtSurfFrOffset( nSrfCopy, - dOffs) and EgtSurfFrChunkCount( nSrfCopy) > 0 then
|
||||
-- local nCrvId, nCnt = EgtGetSurfFrZigZagInfill( nSrfCopy, nGrpId, LayerParams.dStrand + 10 * GEO.EPS_SMALL, dAng, false, false)
|
||||
-- for nInd = 0, nCnt - 1 do
|
||||
-- local dLen = EgtCurveLength( nCrvId + nInd)
|
||||
-- if dLen < MIN_LEN then
|
||||
-- EgtErase( nCrvId + nInd)
|
||||
-- else
|
||||
-- EgtSetName( nCrvId + nInd, INFILL_CRV)
|
||||
-- EgtSetInfo( nCrvId + nInd, KEY_TYPE, TYPE.INFILL)
|
||||
-- end
|
||||
-- end
|
||||
-- EgtErase( nSrfCopy)
|
||||
-- end
|
||||
local nChunk = EgtSurfFrChunkCount( nSrf)
|
||||
if nChunk == 0 then return end
|
||||
|
||||
-- estraggo i contorni della superficie
|
||||
local vOldIds = GetPathsFromSurf( nSrf, sName, nType, nGrp, vPtStart)
|
||||
local dOffs = - dStrand
|
||||
local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrf, nGrp, dOffs)
|
||||
while bOk and bExists do
|
||||
-- estraggo i contorni
|
||||
local vNewIds = GetPathsFromSurf( nSrfOffs, sName, nType, nGrp, vPtStart)
|
||||
if vNewIds then
|
||||
-- riordino
|
||||
ReorderPath( vOldIds, vNewIds)
|
||||
-- verifico fattibilità
|
||||
local k = 1
|
||||
while k <= #vNewIds do
|
||||
if VerifyPath( vNewIds[k], dStrand, vtSlicing, nGrp) then
|
||||
k = k + 1
|
||||
else
|
||||
-- se non è fattibile lo rimuovo dalla table per non ritrovarlo nello step successivo
|
||||
table.remove( vNewIds, k)
|
||||
end
|
||||
end
|
||||
vOldIds = vNewIds
|
||||
end
|
||||
|
||||
EgtErase( nSrfOffs)
|
||||
-- offset successivo
|
||||
dOffs = dOffs - dStrand
|
||||
bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrf, nGrp, dOffs)
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
-------------------------------------------------------------------
|
||||
--------------------------- RIBS -----------------------------------
|
||||
--------------------------------------------------------------------
|
||||
--------------------------------------------------------------------------------
|
||||
local function ComputeZigZagInfill( nSrf, dStrand, vtSlicing, sName, nType, vPtStart, nGrp)
|
||||
|
||||
local nChunk = EgtSurfFrChunkCount( nSrf)
|
||||
if nChunk == 0 then return end
|
||||
|
||||
local nCopySrf = EgtCopyGlob( nSrf, nGrp)
|
||||
if EgtSurfFrChunkCount( nSrf) == 0 then return end
|
||||
|
||||
local nFirst, nCnt = EgtExplodeSurf( nCopySrf)
|
||||
local frLoc = Frame3d( ORIG(), vtSlicing)
|
||||
local vIds = {}
|
||||
for nId = nFirst, nFirst + nCnt - 1 do
|
||||
local nGrpTmp = EgtGroup( nGrp, frLoc)
|
||||
|
||||
-- recupero outer curve
|
||||
local nCrvGrpId = EgtGetParent( nGrp)
|
||||
local nOuterCrv = EgtGetFirstNameInGroup( nCrvGrpId, OUTER_CRV)
|
||||
local nCopyOuterCrv = EgtCopyGlob( nOuterCrv, nGrpTmp)
|
||||
|
||||
-- cerco il lato più lungo
|
||||
local vCrvIds = GetPathsFromSurf( nId, 'Tmp', nType, nGrpTmp)
|
||||
local dMaxLen = - GEO.INFINITO
|
||||
local dDist = GEO.INFINITO
|
||||
local vtDir
|
||||
|
||||
for j = 1, #vCrvIds do
|
||||
local nId, nCnt = EgtExplodeCurveCompo( vCrvIds[j])
|
||||
|
||||
-- cerco il lato più lungo
|
||||
for k = nId, nId + nCnt - 1 do
|
||||
local dCurrLen = EgtCurveLength( k)
|
||||
if dCurrLen > dMaxLen + GEO.EPS_SMALL then
|
||||
dMaxLen = dCurrLen
|
||||
end
|
||||
end
|
||||
-- tra i lati più lunghi scelgo quello più vicino al bordo
|
||||
for k = nId, nId + nCnt - 1 do
|
||||
local dCurrLen = EgtCurveLength( k)
|
||||
if abs( dMaxLen - dCurrLen) < 10 then
|
||||
local dCurrDist = EgtPointCurveDist( EgtMP( k), nCopyOuterCrv)
|
||||
if dCurrDist < dDist + 10 * GEO.EPS_SMALL then
|
||||
vtDir = EgtSV( k)
|
||||
dDist = dCurrDist
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
EgtErase( nGrpTmp)
|
||||
|
||||
local _, _, dAng = SphericalFromVector( vtDir)
|
||||
vtDir:toGlob( frLoc)
|
||||
|
||||
local nInd, nCnt = EgtGetSurfFrZigZagInfill( nId, nGrp, dStrand, dAng, false, false)
|
||||
if not nInd then return end
|
||||
for j = nInd, nInd + nCnt - 1 do
|
||||
EgtSetName( j, sName)
|
||||
EgtSetInfo( j, KEY_TYPE, nType)
|
||||
EgtSetInfo( j, KEY_ZIG_ZAG_DIR, vtDir)
|
||||
EgtSetInfo( j, KEY_ZIG_ZAG_INFILL, 1)
|
||||
EgtModifyCurveExtrusion( j, vtSlicing)
|
||||
table.insert( vIds, j)
|
||||
end
|
||||
local vtS = EgtSV( nInd)
|
||||
EgtErase( nId)
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
-------------------------------------------------------------------
|
||||
--------------------------- RIBS -----------------------------------
|
||||
--------------------------------------------------------------------
|
||||
local function TrimRibsOffset( nCrv, nOffs1, nOffs2, nOffsGrp, bIn)
|
||||
|
||||
@@ -269,26 +495,22 @@ end
|
||||
|
||||
--------------------------------------------------------------------
|
||||
local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, bAllTwoStrands)
|
||||
|
||||
|
||||
local nCrvGrp = EgtGetParent( nRibsPathGrp)
|
||||
local nSrf = EgtGetFirstInGroup( nCrvGrp)
|
||||
|
||||
local vRibsIds = {}
|
||||
local vOrigRibs = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*')
|
||||
local nTrimmedRibsGrp = EgtGroup( nRibsPathGrp)
|
||||
for i = 1, #vOrigRibs do
|
||||
local nCopyId = EgtCopyGlob( vOrigRibs[i], nTrimmedRibsGrp)
|
||||
local nCrv, nCnt = EgtTrimCurveWithRegion( nCopyId, nSrf, true, false)
|
||||
for j = nCrv, nCrv + nCnt - 1 do
|
||||
table.insert( vRibsIds, j)
|
||||
end
|
||||
-- copio i suoi offset nel RibsPathGrp
|
||||
local vOffsRib = EgtGetNameInGroup( nOffsGrp, EgtGetName( vOrigRibs[i]))
|
||||
for i = 1, #vOffsRib do
|
||||
EgtCopyGlob( vOffsRib[i], nRibsPathGrp)
|
||||
end
|
||||
-- copio gli offset delle costolature nel RibsPathGrp
|
||||
local vOffsRib = EgtGetAllInGroup( nOffsGrp)
|
||||
for i = 1, #vOffsRib do
|
||||
EgtCopyGlob( vOffsRib[i], nRibsPathGrp)
|
||||
end
|
||||
|
||||
-- calcolo la regione nella quale ha senso considerare l'intersezione
|
||||
local nSrf = EgtGetFirstNameInGroup( nCrvGrp, TOT_SHELL_TRIM_SURF)
|
||||
local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrf, nCrvGrp, 2 * LayerParams.dStrand)
|
||||
if not bOk or not bExists then
|
||||
nSrfOffs = EgtCopyGlob( nSrf, nCrvGrp)
|
||||
end
|
||||
|
||||
local vRibsIds = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*')
|
||||
local bInters = false
|
||||
local vSplit = {}
|
||||
for i = 1, #vRibsIds do
|
||||
@@ -296,32 +518,38 @@ local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPa
|
||||
for j = i + 1, #vRibsIds do
|
||||
local ptInt = EgtIP( vRibsIds[i], vRibsIds[j], ORIG())
|
||||
if ptInt 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 bIn = abs( dPar1 - dParE1) < 50 * GEO.EPS_SMALL or abs( dPar2 - dParE2) < 50 * GEO.EPS_SMALL
|
||||
local nCrv1 = vRibsIds[i] -- curva principale che non viene tagliata
|
||||
local nCrv2 = vRibsIds[j] -- curve secondaria da modificare
|
||||
if dPar1 < 50 * GEO.EPS_SMALL or abs( dPar1 - dParE1) < 50 * GEO.EPS_SMALL then
|
||||
nCrv1, nCrv2 = nCrv2, nCrv1
|
||||
end
|
||||
|
||||
if bAllTwoStrands then
|
||||
-- nel caso di 2 passate gestione speciale
|
||||
AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nRibsPathGrp, bIn)
|
||||
else
|
||||
AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nRibsPathGrp, bIn)
|
||||
-- verifico se l'interserzione si trova nella regione dello slice
|
||||
local nPtId = EgtPoint( nRibsPathGrp, ptInt)
|
||||
if not EgtSurfFrTestExternal( nSrfOffs, nPtId) 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 bIn = abs( dPar1 - dParE1) < 50 * GEO.EPS_SMALL or abs( dPar2 - dParE2) < 50 * GEO.EPS_SMALL
|
||||
local nCrv1 = vRibsIds[i] -- curva principale che non viene tagliata
|
||||
local nCrv2 = vRibsIds[j] -- curve secondaria da modificare
|
||||
if dPar1 < 50 * GEO.EPS_SMALL or abs( dPar1 - dParE1) < 50 * GEO.EPS_SMALL then
|
||||
nCrv1, nCrv2 = nCrv2, nCrv1
|
||||
end
|
||||
|
||||
if bAllTwoStrands then
|
||||
-- nel caso di 2 passate gestione speciale
|
||||
AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nRibsPathGrp, bIn)
|
||||
else
|
||||
AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nRibsPathGrp, bIn)
|
||||
end
|
||||
end
|
||||
EgtErase( nPtId)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
EgtErase( nTrimmedRibsGrp)
|
||||
|
||||
EgtErase( nSrfOffs)
|
||||
|
||||
return bInters
|
||||
end
|
||||
|
||||
@@ -355,13 +583,6 @@ local function ReorderRibs( nGrp, bInvertOrder, dStrand, nMaxNbr)
|
||||
EgtRelocateGlob( vSPRibs[vOrd[i]], vSPRibs[vOrd[i-1]], EgtIf( bInvertOrder, GDB_IN.BEFORE, GDB_IN.AFTER))
|
||||
end
|
||||
|
||||
-- aggiusto tutte le costolature divise
|
||||
for i = 1, #vSplitRibs do
|
||||
local nPrevId = EgtGetInfo( vSplitRibs[i], KEY_SPLIT_RIB, 'i')
|
||||
-- aggiungo come successiva alla costolatura da cui si è generata
|
||||
EgtRelocateGlob( vSplitRibs[i], nPrevId, GDB_IN.AFTER)
|
||||
end
|
||||
|
||||
-- sistemo nomi
|
||||
local kMax = nMaxNbr + 1
|
||||
for i = 1, nMaxNbr do
|
||||
@@ -379,7 +600,21 @@ local function ReorderRibs( nGrp, bInvertOrder, dStrand, nMaxNbr)
|
||||
kMax = kMax + 1
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- aggiusto tutte le costolature divise
|
||||
for i = 1, #vSplitRibs do
|
||||
local nPrevId = EgtGetInfo( vSplitRibs[i], KEY_SPLIT_RIB, 'i')
|
||||
local bInverted = EgtGetInfo( vSplitRibs[i], KEY_INVERTED_CRV, 'b') or false
|
||||
-- aggiungo come successiva alla costolatura da cui si è generata
|
||||
EgtRelocateGlob( vSplitRibs[i], nPrevId, EgtIf( bInverted, GDB_IN.BEFORE, GDB_IN.AFTER))
|
||||
-- correggo le info per gestire correttamente nel calcolo toolpath
|
||||
if bInverted then
|
||||
EgtRemoveInfo( vSplitRibs[i], KEY_SPLIT_RIB)
|
||||
EgtSetInfo( nPrevId, KEY_SPLIT_RIB, vSplitRibs[i])
|
||||
end
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
--------------------------------------------------------------------------------------------
|
||||
@@ -410,7 +645,8 @@ local function ReassignInfo( nCrv, nCnt, vOrig)
|
||||
-- verifico se corrisponde al suo start
|
||||
if AreSamePointApprox( ptS, ptSOrig) or AreSamePointApprox( ptS, ptEOrig) then
|
||||
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_RIBS_LEAD_IN_LEN, 'd')
|
||||
CopyInfo( vOrig[i], nId, KEY_ASSOCIATED_SURF, 'i')
|
||||
bStart = true
|
||||
end
|
||||
-- verifico se corrisponde al suo end
|
||||
@@ -593,18 +829,8 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, nIdx, nMaxStrand
|
||||
local nSrfBase = EgtGetFirstNameInGroup( nCrvGrp, TOT_SHELL_TRIM_SURF)
|
||||
if not nSrfBase then
|
||||
EgtOutLog( 'Warning : Ribs not possible (layer '..tostring( nIdx)..') - CalcPaths')
|
||||
else
|
||||
local vSurfOffs = {}
|
||||
for i = 1, #vRibs do
|
||||
local nOverlap = EgtGetInfo( vRibs[i], KEY_RIBS_OVERLAP, 'i')
|
||||
if not vSurfOffs[nOverlap] then
|
||||
local dNewOffs = nOverlap / 100 * LayerParams.dStrand
|
||||
local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrfBase, nRibsPathGrp, dNewOffs)
|
||||
if bOk then
|
||||
vSurfOffs[nOverlap] = nSrfOffs
|
||||
end
|
||||
end
|
||||
end
|
||||
else
|
||||
local vSurfOffs = ComputeTrimSurfWithOverlaps( vRibs, nSrfBase, KEY_RIBS_OVERLAP, LayerParams.dStrand, nRibsPathGrp)
|
||||
|
||||
-- gestisco eventuali intersezioni fra costolature
|
||||
local bInters = HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, bAllTwoStrands)
|
||||
@@ -624,7 +850,7 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, nIdx, nMaxStrand
|
||||
else
|
||||
local nCrv, nCnt = EgtTrimCurveWithRegion( vOrderedRibs[i], vSurfOffs[nOverlap], true, false)
|
||||
tOldNewIds[ vOrderedRibs[i]] = {}
|
||||
|
||||
|
||||
-- elimino tratti troppo corti
|
||||
for nInd = 0, nCnt - 1 do
|
||||
local dLen = EgtCurveLength( nCrv + nInd)
|
||||
@@ -638,8 +864,12 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, nIdx, nMaxStrand
|
||||
local dVal = EgtIf( abs( vtDir:getX()) > abs( vtDir:getY()) - GEO.EPS_SMALL, vtDir:getX(), vtDir:getY())
|
||||
if dVal < - GEO.EPS_SMALL then
|
||||
EgtInvertCurve( nCrv + nInd)
|
||||
EgtSetInfo( nCrv + nInd, KEY_INVERTED_CRV, 1)
|
||||
end
|
||||
|
||||
|
||||
-- salvo info della superficie di trim associata
|
||||
EgtSetInfo( nCrv + nInd, KEY_ASSOCIATED_SURF, vSurfOffs[nOverlap])
|
||||
|
||||
if nInd == 0 then
|
||||
-- aggiorno la info
|
||||
local nInfo = EgtGetInfo( nCrv + nInd, KEY_SPLIT_RIB, 'i')
|
||||
@@ -658,7 +888,7 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, nIdx, nMaxStrand
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
-- riordino le costolature
|
||||
if bAllTwoStrands and bInters then
|
||||
-- gestione caso speciale di intersezione e 2 passate
|
||||
@@ -793,7 +1023,7 @@ local function ReorderExtraShells( nPathGrp, dStrand, vPtStart, bPrintInvert)
|
||||
if bPrintInvert then
|
||||
for i = 1, #vIds do
|
||||
EgtInvertCurve( vIds[i])
|
||||
EgtSetInfo( vIds[i], KEY_INVERTED_CURVE, 1)
|
||||
EgtSetInfo( vIds[i], KEY_INVERTED_CRV, 1)
|
||||
end
|
||||
end
|
||||
|
||||
@@ -812,7 +1042,6 @@ local function ReorderExtraShells( nPathGrp, dStrand, vPtStart, bPrintInvert)
|
||||
-- se curva è chiusa
|
||||
if EgtCurveIsClosed( nCurrCrv) then
|
||||
ModifyStartPoint( nCurrCrv, vPtStart)
|
||||
EgtSetInfo( nCurrCrv, KEY_CLOSED_EXTRA_SHELL, 1)
|
||||
-- setto a nil per ripartire subito con curva successiva
|
||||
nCurrCrv = nil
|
||||
end
|
||||
@@ -840,12 +1069,12 @@ local function ReorderExtraShells( nPathGrp, dStrand, vPtStart, bPrintInvert)
|
||||
if dist( ptE, ptECurr) < 1.5 * dStrand then
|
||||
-- congiungo end-end
|
||||
EgtInvertCurve( vIds[j])
|
||||
EgtSetInfo( vIds[j], KEY_INVERTED_CURVE, EgtIf( bPrintInvert, 0, 1))
|
||||
EgtSetInfo( vIds[j], KEY_INVERTED_CRV, EgtIf( bPrintInvert, 0, 1))
|
||||
bLink = true
|
||||
elseif nCnt == 0 and dist( ptS, ptSCurr) < 1.5 * dStrand then
|
||||
-- congiungo start-start
|
||||
EgtInvertCurve( nCurrCrv)
|
||||
EgtSetInfo( nCurrCrv, KEY_INVERTED_CURVE, EgtIf( bPrintInvert, 0, 1))
|
||||
EgtSetInfo( nCurrCrv, KEY_INVERTED_CRV, EgtIf( bPrintInvert, 0, 1))
|
||||
bLink = true
|
||||
end
|
||||
|
||||
@@ -872,45 +1101,6 @@ local function ReorderExtraShells( nPathGrp, dStrand, vPtStart, bPrintInvert)
|
||||
end
|
||||
end
|
||||
|
||||
--------------------------------------------------------------------
|
||||
local function VerifyExtraShellPath( nCrv, nGrpId, vtSlicing, dStrand)
|
||||
|
||||
-- verifico se è fattibile controllando se esiste offset
|
||||
local nOffs, nCnt = EgtOffsetCurveAdv( nCrv, - 0.5 * dStrand)
|
||||
if not nOffs or nOffs == GDB_ID.NULL then
|
||||
return false
|
||||
end
|
||||
for i = nOffs, nOffs + nCnt - 1 do
|
||||
EgtErase( i)
|
||||
end
|
||||
|
||||
-- controllo se è fattibile con una sola passata
|
||||
if EgtCurveIsClosed( nCrv) then
|
||||
local nGrpTmp = EgtGroup( nGrpId, Frame3d( ORIG(), vtSlicing))
|
||||
EgtRelocateGlob( nCrv, nGrpTmp)
|
||||
local dArea = EgtCurveAreaXY( nCrv)
|
||||
if dArea < 10 * GEO.EPS_SMALL then
|
||||
-- TODO curva generica
|
||||
local frLoc, dDimX, dDimY = EgtCurveMinAreaRectangleXY( nCrv)
|
||||
if dDimY < 10 * GEO.EPS_SMALL then
|
||||
local dZ = EgtSP( nCrv):getZ()
|
||||
-- creo la curva che corrisponde alla sigola passata
|
||||
local ptS = frLoc:getOrigin() - dDimX / 2 * frLoc:getVersX() + dZ * Z_AX()
|
||||
local ptE = frLoc:getOrigin() + dDimX / 2 * frLoc:getVersX() + dZ * Z_AX()
|
||||
if dist( ptS, ptE) > 5 then
|
||||
local nId = EgtCurveCompoFromPoints( nGrpTmp, { ptS, ptE})
|
||||
EgtErase( nCrv)
|
||||
EgtChangeId( nId, nCrv)
|
||||
end
|
||||
end
|
||||
end
|
||||
EgtRelocateGlob( nCrv, nGrpId, GDB_IN.LAST_SON)
|
||||
EgtErase( nGrpTmp)
|
||||
end
|
||||
|
||||
return true
|
||||
end
|
||||
|
||||
--------------------------------------------------------------------
|
||||
local function CalcExtraShellsPath( nMaxShellNbrDiff, nShellNbrGrp, nCrvGrpId, dOffs, LayerParams, nIdx, vPtStart)
|
||||
|
||||
@@ -951,9 +1141,12 @@ local function CalcExtraShellsPath( nMaxShellNbrDiff, nShellNbrGrp, nCrvGrpId, d
|
||||
if nCrv and nCnt ~= 0 then
|
||||
for nId = nCrv, nCrv + nCnt - 1 do
|
||||
local dLen = EgtCurveLength( nId)
|
||||
local bValid = VerifyExtraShellPath( nId, nGrpId, LayerParams.vtSlicing, LayerParams.dStrand)
|
||||
local bValid = true
|
||||
if EgtCurveIsClosed( nId) then
|
||||
bValid = VerifyPath( nId, LayerParams.dStrand, LayerParams.vtSlicing, nGrpId)
|
||||
end
|
||||
-- verifico se soddisfa vincolo sulla lunghezza
|
||||
if dLen > MIN_LEN and bValid then
|
||||
if dLen > MIN_LEN and bValid then
|
||||
EgtModifyCurveExtrusion( nId, LayerParams.vtSlicing)
|
||||
EgtSetName( nId, EXTRA_SHELL_CRV .. tostring( nMaxShellNbrDiff - nInd + 1))
|
||||
EgtSetInfo( nId, KEY_TYPE, TYPE.EXTRA_SHELL)
|
||||
@@ -987,6 +1180,187 @@ local function CalcExtraShellsPath( nMaxShellNbrDiff, nShellNbrGrp, nCrvGrpId, d
|
||||
|
||||
end
|
||||
|
||||
--------------------------------------------------------------------
|
||||
------------------ AUX SOLIDS -------------------------------------
|
||||
--------------------------------------------------------------------
|
||||
local function UpdateTrimSurfWithAuxSolidsOffset( nSrfSolid, nSrfBase, dStrand, nCrvGrp)
|
||||
|
||||
-- offset della superifice del solido
|
||||
local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrfSolid, nCrvGrp, dStrand)
|
||||
if nSrfOffs then
|
||||
EgtSurfFrSubtract( nSrfBase, nSrfOffs)
|
||||
EgtErase( nSrfOffs)
|
||||
end
|
||||
end
|
||||
|
||||
--------------------------------------------------------------------
|
||||
local function UpdateTrimSurfWithAuxSolidsZigZag( nAuxSolidsGrp, sName, nSrfBase, dStrand, nSrf)
|
||||
|
||||
local nGrpTmp = EgtGroup( nAuxSolidsGrp) -- gruppo temporaneo per conti
|
||||
|
||||
-- recupero le curve associate
|
||||
local vCrvs = EgtGetNameInGroup( nAuxSolidsGrp, sName)
|
||||
for i = 1, #vCrvs do
|
||||
|
||||
local vtDir = EgtSV( vCrvs[i])
|
||||
-- costruisco percorso associato
|
||||
local nCopyCrv = EgtCopyGlob( vCrvs[i], nGrpTmp)
|
||||
local nCopy2 = EgtCopyGlob( vCrvs[i], nGrpTmp)
|
||||
EgtInvertCurve( nCopy2)
|
||||
EgtAddCurveCompoCurve( nCopyCrv, nCopy2)
|
||||
local nOffsP = EgtOffsetCurveAdv( nCopyCrv, dStrand, GDB_OT.FILLET)
|
||||
local nFirst, nCnt = EgtExplodeCurveCompo( nOffsP, nGrpTmp)
|
||||
|
||||
-- cerco tratti lineari orientati ortogonalmente alla direzione di svuotatura
|
||||
local nRes = EgtCurveCompo( nGrpTmp, {nFirst})
|
||||
local nInd = nFirst + 1
|
||||
while nInd < nFirst + nCnt do
|
||||
local vtCurrDir = EgtSV( nInd)
|
||||
local nType = EgtGetType( nInd)
|
||||
|
||||
-- se è linea ortognale alla direzione della svuotatura la approssimo
|
||||
if nType == GDB_TY.CRV_LINE and abs( vtDir * vtCurrDir) < 10 * GEO.EPS_SMALL then
|
||||
-- cerco ultima curva con lo stesso orientamento
|
||||
local nLastValidId = nInd
|
||||
local nInd2 = nInd + 1
|
||||
while nInd2 < nFirst + nCnt do
|
||||
nType = EgtGetType( nInd2)
|
||||
if nType == GDB_TY.CRV_LINE then
|
||||
if AreSameVectorApprox( EgtSV( nInd2), vtCurrDir) then
|
||||
nLastValidId = nInd2
|
||||
else
|
||||
break
|
||||
end
|
||||
end
|
||||
nInd2 = nInd2 + 1
|
||||
end
|
||||
|
||||
-- aggiungo l'approssimazione lineare
|
||||
EgtAddCurveCompoLine( nRes, EgtEP( nLastValidId))
|
||||
-- setto l'indice per ripartire correttamente dopo l'approssimazione
|
||||
nInd = nLastValidId
|
||||
|
||||
else
|
||||
-- se arco o linea inclinata, aggiungo direttamente al percorso
|
||||
EgtAddCurveCompoCurve( nRes, nInd)
|
||||
end
|
||||
|
||||
nInd = nInd + 1
|
||||
end
|
||||
|
||||
-- utilizzo la curva per creare superficie
|
||||
local nSrfZigZag = EgtSurfFlatRegion( nGrpTmp, {nRes})
|
||||
if nSrfZigZag then
|
||||
EgtSurfFrSubtract( nSrfBase, nSrfZigZag)
|
||||
else
|
||||
EgtSurfFrSubtract( nSrfBase, nSrf)
|
||||
end
|
||||
|
||||
end
|
||||
EgtErase( nGrpTmp)
|
||||
|
||||
end
|
||||
|
||||
-------------------------------------------------------------------
|
||||
local function AddExtraZigZag( nSrf, sName, dStrand, vtSlicing, nGrp, nSrfTrim)
|
||||
|
||||
local vIds = EgtGetNameInGroup( nGrp, sName)
|
||||
local vtDir = EgtSV( vIds[1])
|
||||
local vtYLoc = vtSlicing ^ vtDir
|
||||
|
||||
local nOuterLoop = EgtExtractSurfFrChunkLoops( nSrf, 0, nGrp)
|
||||
|
||||
for i = 1, #vIds do
|
||||
local _, dParE = EgtCurveDomain( vIds[i])
|
||||
local ptS = EgtUP( vIds[i], dParE - 1) + dStrand * vtYLoc
|
||||
local ptE = EgtEP( vIds[i]) + dStrand * vtYLoc
|
||||
local nExtraCrv = EgtLine( nGrp, ptS, ptE)
|
||||
-- verifico se la linea aggiuntiva serve
|
||||
local dDist = EgtPointCurveDist( EgtMP( nExtraCrv), nOuterLoop)
|
||||
if dDist < dStrand - 1 then
|
||||
-- verifico se si trova nella regione ammissibile
|
||||
if EgtCurveWithRegionClassify( nExtraCrv, nSrfTrim) == GDB_CRC.IN then
|
||||
EgtInvertCurve( nExtraCrv)
|
||||
EgtAddCurveCompoLine( vIds[i], ptE)
|
||||
EgtAddCurveCompoCurve( vIds[i], nExtraCrv)
|
||||
end
|
||||
end
|
||||
EgtErase( nExtraCrv)
|
||||
end
|
||||
|
||||
EgtErase( nOuterLoop)
|
||||
end
|
||||
|
||||
--------------------------------------------------------------------
|
||||
local function CalcAuxSolidsPaths( nSliceGrp, nSolidGrp, LayerParams, vPtStart)
|
||||
|
||||
-- recupero i solidi ausiliari
|
||||
local vSolidIds = EgtGetAllInGroup( nSolidGrp)
|
||||
|
||||
-- scorro i gruppi di curve
|
||||
local nCrvGrp = EgtGetFirstNameInGroup( nSliceGrp, CONTOUR_GRP .. '*')
|
||||
while nCrvGrp do
|
||||
|
||||
-- creo o svuoto il gruppo per i solidi ausiliari
|
||||
local nSolidPathGrp = EgtGetFirstNameInGroup( nCrvGrp, AUX_SOLIDS_GRP)
|
||||
if not nSolidPathGrp then
|
||||
nSolidPathGrp = EgtGroup( nCrvGrp)
|
||||
EgtSetName( nSolidPathGrp, AUX_SOLIDS_GRP)
|
||||
EgtSetStatus( nSolidPathGrp, GDB_ST.OFF)
|
||||
else
|
||||
EgtEmptyGroup( nSolidPathGrp)
|
||||
end
|
||||
|
||||
-- creo le superfici con cui fare i trim
|
||||
local nSrfBase = EgtGetFirstNameInGroup( nCrvGrp, TOT_SHELL_TRIM_SURF)
|
||||
if not nSrfBase then
|
||||
EgtOutLog( 'Warning : AuxSolids not possible (layer '..tostring( nIdx)..') - CalcPaths')
|
||||
else
|
||||
local vSurfOffs = ComputeTrimSurfWithOverlaps( vSolidIds, nSrfBase, KEY_AUX_SOLIDS_OVERLAP, LayerParams.dStrand, nSolidPathGrp)
|
||||
|
||||
for i = 1, #vSolidIds do
|
||||
-- creo la flat region corrispondente al solido ausiliario
|
||||
local sName = EgtGetName( vSolidIds[i])
|
||||
local nOverlap = EgtGetInfo( vSolidIds[i], KEY_AUX_SOLIDS_OVERLAP, 'i')
|
||||
local nSrfId = EgtSurfFlatRegion( nSolidPathGrp, vSolidIds[i])
|
||||
EgtSetName( nSrfId, AUX_SOLIDS_SRF)
|
||||
-- trim con la superficie di offset
|
||||
EgtSurfFrIntersect( nSrfId, vSurfOffs[nOverlap])
|
||||
|
||||
local nFirst, nCnt = EgtExplodeSurf( nSrfId)
|
||||
for j = 0, nCnt - 1 do
|
||||
local sNewName = sName .. EgtIf( j == 0, '', '_' .. tostring( j))
|
||||
local nInfillType = EgtGetInfo( vSolidIds[i], KEY_AUX_SOLIDS_INFILL, 'i')
|
||||
if nInfillType == INFILL_TYPE.OFFSET then
|
||||
ComputeOffsetInfill( nFirst + j, LayerParams.dStrand, LayerParams.vtSlicing, sNewName, TYPE.AUX_SOLID, vPtStart, nSolidPathGrp)
|
||||
-- aggiorno la trim surf
|
||||
UpdateTrimSurfWithAuxSolidsOffset( nFirst + j, nSrfBase, LayerParams.dStrand, nSolidPathGrp)
|
||||
else
|
||||
ComputeZigZagInfill( nFirst + j, LayerParams.dStrand, LayerParams.vtSlicing, sNewName, TYPE.AUX_SOLID, vPtStart, nSolidPathGrp)
|
||||
-- aggiungo eventuale passata extra
|
||||
AddExtraZigZag( nFirst + j, sNewName, LayerParams.dStrand, LayerParams.vtSlicing, nSolidPathGrp, vSurfOffs[nOverlap])
|
||||
-- aggiorno la trim surf
|
||||
UpdateTrimSurfWithAuxSolidsZigZag( nSolidPathGrp, sNewName, nSrfBase, LayerParams.dStrand, nFirst + j)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- elimino le superfici utilizzate per il trim
|
||||
for k, v in pairs( vSurfOffs) do
|
||||
EgtErase( v)
|
||||
end
|
||||
end
|
||||
|
||||
-- verifico se il gruppo contine qualcosa
|
||||
if not EgtGetFirstNameInGroup( nSolidPathGrp, AUX_SOLIDS_CRV .. '*') then
|
||||
EgtErase( nSolidPathGrp)
|
||||
end
|
||||
|
||||
-- passo al gruppo di contorni successivo
|
||||
nCrvGrp = EgtGetNextName( nCrvGrp, CONTOUR_GRP .. '*')
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function CalcPaths.Exec( nPartId)
|
||||
|
||||
@@ -1004,6 +1378,7 @@ function CalcPaths.Exec( nPartId)
|
||||
for nIdx = 1, #vLayIds do
|
||||
|
||||
local nRibsGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], RIBS_GRP)
|
||||
local nAuxSolidsGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], AUX_SOLIDS_GRP)
|
||||
|
||||
-- regioni con diverso numero di passate
|
||||
local nShellNbrGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], SHELL_NBR_GRP)
|
||||
@@ -1032,7 +1407,7 @@ function CalcPaths.Exec( nPartId)
|
||||
end
|
||||
|
||||
-- recupero la superficie ottenuta dallo slicing
|
||||
local nSrf = EgtGetFirstNameInGroup( nCrvGrpId, LAYER_SRF)
|
||||
local nSrf = EgtGetFirstNameInGroup( nCrvGrpId, LAYER_SRF)
|
||||
if nSrf then
|
||||
|
||||
-- parete esterna
|
||||
@@ -1044,10 +1419,15 @@ function CalcPaths.Exec( nPartId)
|
||||
EgtOutLog( 'Warning : ExtOffset not possible (layer '..tostring( nIdx)..') - CalcPaths')
|
||||
else
|
||||
-- se offset riuscito, estraggo i contorni (pareti esterne)
|
||||
GetPathsFromSurf( nSrfId, SHELL_CRV..'0', TYPE.OUTER_SHELL, nGrpId, vPtStart)
|
||||
GetPathsFromSurf( nSrfId, SHELL_CRV ..'0', TYPE.OUTER_SHELL, nGrpId, vPtStart)
|
||||
end
|
||||
EgtErase( nSrfId)
|
||||
|
||||
local vPtInnerStart = {}
|
||||
local vOuterShell = EgtGetNameInGroup( nGrpId, SHELL_CRV .. '0') or {}
|
||||
for i = 1, #vOuterShell do
|
||||
table.insert( vPtInnerStart, EgtSP( vOuterShell[i]))
|
||||
end
|
||||
-- pareti interne complete
|
||||
local nMaxShellNbrDiff = ComputeMaxShellNbrDiff( nSrf, nShellNbrSurfGrp)
|
||||
for nInd = 1, LayerParams.nShellsNbr - 1 - nMaxShellNbrDiff do
|
||||
@@ -1060,7 +1440,7 @@ function CalcPaths.Exec( nPartId)
|
||||
EgtOutLog( 'Warning : IntOffset not possible (layer '..tostring( nIdx)..') - CalcPaths')
|
||||
else
|
||||
-- se offset riuscito, estraggo i contorni ( pareti interne)
|
||||
GetPathsFromSurf( nSrfId, SHELL_CRV..tostring( nInd), TYPE.INNER_SHELL, nGrpId, vPtStart)
|
||||
GetPathsFromSurf( nSrfId, SHELL_CRV..tostring( nInd), TYPE.INNER_SHELL, nGrpId, vPtInnerStart)
|
||||
end
|
||||
EgtErase( nSrfId)
|
||||
end
|
||||
@@ -1076,25 +1456,43 @@ function CalcPaths.Exec( nPartId)
|
||||
|
||||
-- eventuali pareti interne coinvolte dal diverso numero di passate
|
||||
if nMaxShellNbrDiff > 0 then
|
||||
CalcExtraShellsPath( nMaxShellNbrDiff, nShellNbrSurfGrp, nCrvGrpId, dOffs, LayerParams, nIdx, vPtStart)
|
||||
CalcExtraShellsPath( nMaxShellNbrDiff, nShellNbrSurfGrp, nCrvGrpId, dOffs, LayerParams, nIdx, vPtInnerStart)
|
||||
end
|
||||
|
||||
-- gestione eventuale floor
|
||||
-- gestione eventuale floor/ceil
|
||||
if nIdx <= LayerParams.nFloorNbr then
|
||||
AddFloor( nSrf, nGrpId, LayerParams, nIdx)
|
||||
if LayerParams.nFloorType == INFILL_TYPE.OFFSET then
|
||||
ComputeOffsetInfill( nSrfTrim, LayerParams.dStrand, LayerParams.vtSlicing, INFILL_CRV, TYPE.INFILL, vPtStart, nGrpId)
|
||||
elseif LayerParams.nFloorType == INFILL_TYPE.ZIGZAG then
|
||||
ComputeZigZagInfill( nSrfTrim, LayerParams.dStrand, LayerParams.vtSlicing, INFILL_CRV, TYPE.INFILL, vPtStart, nGrpId)
|
||||
end
|
||||
elseif nIdx > #vLayIds - LayerParams.nCeilNbr then
|
||||
if LayerParams.nCeilType == INFILL_TYPE.OFFSET then
|
||||
ComputeOffsetInfill( nSrfTrim, LayerParams.dStrand, LayerParams.vtSlicing, INFILL_CRV, TYPE.INFILL, vPtStart, nGrpId)
|
||||
elseif LayerParams.nCeilType == INFILL_TYPE.ZIGZAG then
|
||||
ComputeZigZagInfill( nSrfTrim, LayerParams.dStrand, LayerParams.vtSlicing, INFILL_CRV, TYPE.INFILL, vPtStart, nGrpId)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- passo al gruppo di contorni successivo
|
||||
nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*") or GDB_ID.NULL
|
||||
end
|
||||
|
||||
if nIdx > LayerParams.nFloorNbr and nIdx <= #vLayIds - LayerParams.nCeilNbr then
|
||||
|
||||
-- sistemo eventuali solidi ausiliari
|
||||
if nAuxSolidsGrp then
|
||||
CalcAuxSolidsPaths( vLayIds[nIdx], nAuxSolidsGrp, LayerParams, vPtStart)
|
||||
end
|
||||
|
||||
-- sistemo eventuali costolature
|
||||
if nRibsGrp then
|
||||
CalcRibsPaths( vLayIds[nIdx], nRibsGrp, LayerParams, nIdx, nMaxStrandDiff)
|
||||
-- sistemo eventuali costolature
|
||||
if nRibsGrp then
|
||||
CalcRibsPaths( vLayIds[nIdx], nRibsGrp, LayerParams, nIdx, nMaxStrandDiff)
|
||||
end
|
||||
end
|
||||
|
||||
if EgtProcessEvents( nIdx / #vLayIds * 100, 0) == 1 then
|
||||
if EgtProcessEvents( EgtIf( PRINT, 100, 0) + nIdx / #vLayIds * 100, 0) == 1 then
|
||||
EgtDraw()
|
||||
return
|
||||
end
|
||||
|
||||
Reference in New Issue
Block a user