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

3dPrinting :

Browse Source 
- possibilità di assegnare parametri diversi a costolature diverse.
This commit is contained in:
SaraP
2022-08-02 14:45:44 +02:00
parent 4c90800319
commit 5ccbfd54ec
4 changed files with 296 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files
LuaLibs/AddManData.lua
+3
View File
@@ -68,6 +68,8 @@ KEY_COASTING_FEED = "CoastingFeed"
KEY_WIPE_LEN = "WipeLen"
KEY_WIPE_FEEDPU = "WipeFeedPu"
KEY_TOOL_DIAM = "ToolDiam"
-- Ribs
KEY_RIBS_OVERLAP = "RibsOverlap"
KEY_RIBS_SHELLS_NBR = "RibsStrandCount"
KEY_RIBS_LINK = "RibsLink"
@@ -82,6 +84,7 @@ KEY_RIBS_LEAD_OUT_WIPE = "RibsLeadOutWipe"
KEY_RIBS_LEAD_OUT_WIPE_DIR = "RibsLeadOutWipeDir"
KEY_RIBS_INTERS = "RibsHaveIntersections"
KEY_SPLIT_RIB = "SplitRib"
KEY_RIBS_TWO_STRANDS = "RibsHaveAll2Strands"
-- Parametri di macchina
SEC_3DPRINTING = "3dPrinting"
LuaLibs/CalcPaths.lua
+186 -107
View File
@@ -24,8 +24,6 @@ local function GetLayerParamsForPathCalc()
LayerParams.nFloorNbr = EgtGetInfo( s_nPartId, KEY_FLOOR_NBR, 'i')
LayerParams.vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v')
-- parametri costolature
LayerParams.dRibsOverlap = EgtGetInfo( s_nPartId, KEY_RIBS_OVERLAP, 'd')
LayerParams.nRibsShellsNbr = EgtGetInfo( s_nPartId, KEY_RIBS_SHELLS_NBR, 'i')
LayerParams.bRibsInvertOrder = EgtGetInfo( s_nPartId, KEY_RIBS_INVERT_ORDER, 'b')
return LayerParams
end
@@ -67,6 +65,21 @@ local function GetLayerStartPoint( nLayId, vtSlicing)
return vPtStart
end
----------------------------------------------------------------------
local function ComputeSurfOffset( nSrf, nGrpId, dOffs)
local nCopySrf = EgtCopy( nSrf, nGrpId)
local bOk = EgtSurfFrOffset( nCopySrf, dOffs)
local bExists = EgtSurfFrChunkCount( nCopySrf) > 0
if not bOk or not bExists then
EgtErase( nCopySrf)
nCopySrf = EgtCopyGlob( nSrf, nGrpId)
bOk = EgtSurfFrOffset( nCopySrf, dOffs + 0.05)
bExists = EgtSurfFrChunkCount( nCopySrf) > 0
end
return bOk, bExists, nCopySrf
end
---------------------------------------------------------------------
local function GetPathsFromSurf( nSrfId, sName, nType, nGrpId, vPtStart)
@@ -141,7 +154,7 @@ local function TrimRibsOffset( nCrv, nOffs1, nOffs2, nOffsGrp, bIn)
local ptInt2 = EgtIP( nCrv, nOffs2, ORIG())
local dPar1, dPar2
if ptInt1 then dPar1 = EgtCurveParamAtPoint( nCrv, ptInt1) end
if ptInt2 then dPar2 = EgtCurveParamAtPoint( nCrv, ptInt2) end
if ptInt2 then dPar2 = EgtCurveParamAtPoint( nCrv, ptInt2) end
if dPar1 and dPar2 then
-- la curva viene spezzata in tre parti
@@ -167,9 +180,13 @@ end
local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nOffsGrp, bIn)
-- calcolo gli offset della curva principale ( nCrv1) da usare per trim
local dOffs = ( LayerParams.nRibsShellsNbr - 1) * LayerParams.dStrand / 2
local nOffsM = EgtOffsetCurveAdv( nCrv1, - dOffs - ( 1 - LayerParams.dRibsOverlap / 100) * LayerParams.dStrand)
local nOffsP = EgtOffsetCurveAdv( nCrv1, dOffs + ( 1 - LayerParams.dRibsOverlap / 100) * LayerParams.dStrand)
local nShells = EgtGetInfo( nCrv1, KEY_RIBS_SHELLS_NBR, 'i')
local nOverlap1 = EgtGetInfo( nCrv1, KEY_RIBS_OVERLAP, 'i')
local nOverlap2 = EgtGetInfo( nCrv2, KEY_RIBS_OVERLAP, 'i')
local nOverlap = min( nOverlap1, nOverlap2)
local dOffs = ( nShells - 1) * LayerParams.dStrand / 2
local nOffsM = EgtOffsetCurveAdv( nCrv1, - dOffs - ( 1 - nOverlap / 100) * LayerParams.dStrand)
local nOffsP = EgtOffsetCurveAdv( nCrv1, dOffs + ( 1 - nOverlap / 100) * LayerParams.dStrand)
local vSplit = {}
-- recupero gli offset della curva secondaria ( nCrv2)
@@ -186,7 +203,7 @@ end
--------------------------------------------------------------------
-- Funzione che sistema le intersezioni fra costolature nel caso di 2 passate
local function AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nOffsGrp, bIn)
-- recupero gli offset delle due curve
local vOffs1 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv1))
local vOffs2 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv2))
@@ -215,7 +232,7 @@ local function AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams
local _, dParE = EgtCurveDomain( nCrv1)
bInCrv1 = abs( dParInt - dParE) < 100 * GEO.EPS_SMALL
end
TrimRibsOffset( vOffs1[i], vOffs2[vIds[1]], vOffs2[vIds[2]], nOffsGrp, bInCrv1)
TrimRibsOffset( vOffs1[i], vOffs2[vIds[1]], vOffs2[vIds[2]], nOffsGrp, bInCrv1)
end
end
@@ -230,17 +247,16 @@ local function AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams
if #vIds > 0 then
if #vIds == 1 then table.insert( vIds, EgtIf( vIds[1] == 1, 2, 1)) end
TrimRibsOffset( vOffs2[i], vCopy1[vIds[1]], vCopy1[vIds[2]], nOffsGrp, bIn)
end
end
end
for i = 1, #vCopy1 do
EgtErase( vCopy1[i])
end
end
--------------------------------------------------------------------
local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp)
local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, bAllTwoStrands)
local nCrvGrp = EgtGetParent( nRibsPathGrp)
local nSrf = EgtGetFirstInGroup( nCrvGrp)
@@ -261,7 +277,7 @@ local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPa
end
end
local bInters = false
local bInters = false
local vSplit = {}
for i = 1, #vRibsIds do
-- verifico se interseca uno dei setti successivi
@@ -282,7 +298,7 @@ local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPa
nCrv1, nCrv2 = nCrv2, nCrv1
end
if LayerParams.nRibsShellsNbr == 2 then
if bAllTwoStrands then
-- nel caso di 2 passate gestione speciale
AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nRibsPathGrp, bIn)
else
@@ -325,27 +341,30 @@ end
--------------------------------------------------------------------
-- Funzione che riordina le costolature nel caso generico
local function ReorderRibs( nGrp, bInvertOrder, nShells)
local function ReorderRibs( nGrp, bInvertOrder)
EgtSpInit()
local vIds = EgtGetNameInGroup( nGrp, RIBS_CRV .. '*')
local vSplitRibs = {}
local vSPRibs = {}
for i = 1, #vIds do
local nInfo = EgtGetInfo( vIds[i], KEY_SPLIT_RIB, 'i')
local nShells = EgtGetInfo( vIds[i], KEY_RIBS_SHELLS_NBR, 'i')
-- se è ottenuto dalla divisione di una costolatura non va considerato per il TSP ( viene aggiunto in seguito)
if nInfo and nShells == 1 then
table.insert( vSplitRibs, vIds[i])
else
local pt = EgtMP( vIds[i], GDB_RT.GLOB)
EgtSpAddPoint( pt:getX(), pt:getY(), pt:getZ(), 0, 0, pt:getX(), pt:getY(), pt:getZ(), 0, 0)
table.insert( vSPRibs, vIds[i])
end
end
local vOrd, dLen = EgtSpCalculate( SHP_TY.OPEN)
EgtSpTerminate()
EgtRelocateGlob( vIds[vOrd[1]], nGrp, EgtIf( bInvertOrder, GDB_IN.LAST, GDB_IN.FIRST))
EgtRelocateGlob( vSPRibs[vOrd[1]], nGrp, EgtIf( bInvertOrder, GDB_IN.LAST, GDB_IN.FIRST))
for i = 2, #vOrd do
EgtRelocateGlob( vIds[vOrd[i]], vIds[vOrd[i-1]], EgtIf( bInvertOrder, GDB_IN.BEFORE, GDB_IN.AFTER))
EgtRelocateGlob( vSPRibs[vOrd[i]], vSPRibs[vOrd[i-1]], EgtIf( bInvertOrder, GDB_IN.BEFORE, GDB_IN.AFTER))
end
-- aggiusto tutte le costolature divise
@@ -357,13 +376,70 @@ local function ReorderRibs( nGrp, bInvertOrder, nShells)
end
--------------------------------------------------------------------------------------------
local function CopyInfo( nSouId, nDestId, sInfo, sType)
local info = EgtGetInfo( nSouId, sInfo, sType)
EgtSetInfo( nDestId, sInfo, info)
end
--------------------------------------------------------------------------------------------
local function ReassignInfo( nCrv, nCnt, vOrig)
for nId = nCrv, nCrv + nCnt - 1 do
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)
local bStart = false
local bEnd = false
while not bStart and not bEnd do
-- scorro le curve originarie per capire da quali deriva
for i = 1, #vOrig do
local ptSOrig = EgtSP( vOrig[i])
local ptEOrig = EgtEP( vOrig[i])
-- 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')
bStart = true
end
-- verifico se corrisponde al suo end
if AreSamePointApprox( ptE, ptSOrig) or AreSamePointApprox( ptE, ptEOrig) then
CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_OUT_INVERT, 'b')
CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_OUT_LEN, 'd')
CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_OUT_COASTING, 'd')
CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_OUT_WIPE, 'd')
CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd')
bEnd = true
end
end
end
end
-- dopo aver salvato le info è inutile conservare le curve originali
for i = 1, #vOrig do
EgtErase( vOrig[i])
end
end
---------------------------------------------------------------------------------------------
-- Funzione che riordina le costolature nel caso di intersezioni e 2 passate
local function ReorderRibsInters2Shells( nOffsGrp, dStrand)
local vOffs = EgtGetNameInGroup( nOffsGrp, RIBS_CRV .. '*')
-- 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)
end
-- concateno le curve
local nCrv, nCnt = EgtCurveCompoByChain( nOffsGrp, vOffs, ORIG())
local nCrv, nCnt = EgtCurveCompoByChain( nOffsGrp, vOffs, ORIG())
local vIds = {}
for i = nCrv, nCrv + nCnt - 1 do
@@ -417,73 +493,127 @@ local function ReorderRibsInters2Shells( nOffsGrp, dStrand)
else
nCurrCrv = nil
end
end
end
end
end
-- Recupero le info dalle curve originali
ReassignInfo( nCrv, nCnt, vCopy)
end
--------------------------------------------------------------------
local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, nStmId)
local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, nStmId, nIdx)
-- calcolo gli offset
local dOffs = ( LayerParams.nRibsShellsNbr - 1) * LayerParams.dStrand / 2
local nOffsGrp = EgtGroup( nRibsGrp)
local vRibs = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*')
-- verifico se tutte le costolature vengono fatte con 2 passate
local bAllTwoStrands = true
for i = 1, #vRibs do
for k = 0, LayerParams.nRibsShellsNbr - 1 do
local nStrand = EgtGetInfo( vRibs[i], KEY_RIBS_SHELLS_NBR, 'i')
if nStrand ~= 2 then
bAllTwoStrands = false
break
end
end
-- calcolo gli offset
local nOffsGrp = EgtGroup( nRibsGrp)
for i = 1, #vRibs do
local nShellsNbr = EgtGetInfo( vRibs[i], KEY_RIBS_SHELLS_NBR, 'i')
local dOffs = ( nShellsNbr - 1) * LayerParams.dStrand / 2
for k = 0, nShellsNbr - 1 do
local nNewId = EgtOffsetCurveAdv( vRibs[i], - dOffs + k * LayerParams.dStrand)
EgtSetName( nNewId, EgtGetName( vRibs[i]))
EgtSetInfo( nNewId, KEY_TYPE, TYPE.RIB)
EgtRelocateGlob( nNewId, nOffsGrp)
end
end
-- scorro i gruppi di curve
local dOffs = 0.5 * LayerParams.dStrand - LayerParams.dOffs + ( LayerParams.nShellsNbr - 1) * LayerParams.dStrand
local nCrvGrp = EgtGetFirstNameInGroup( nSliceGrp, CONTOUR_GRP .. '*')
while nCrvGrp do
-- creo o svuoto il gruppo
local nRibsPathGrp = EgtGetFirstNameInGroup( nCrvGrp, RIBS_GRP)
local nSrf = EgtGetFirstNameInGroup( nRibsPathGrp, LAYER_SRF)
if nSrf then
if not nRibsPathGrp then
nRibsPathGrp = EgtGroup( nCrvGrp)
EgtSetName( nRibsPathGrp, RIBS_GRP)
EgtSetStatus( nRibsPathGrp, GDB_ST.OFF)
else
EgtEmptyGroup( nRibsPathGrp)
end
-- creo le superfici con cui fare i trim
local nSrf = EgtGetFirstNameInGroup( nCrvGrp, LAYER_SRF)
local bOk, bExists, nSrfBase = ComputeSurfOffset( nSrf, nRibsPathGrp, - dOffs)
if not bOk then
EgtOutLog( 'Error on Offset for Ribs (layer '..tostring( nIdx)..') - CalcPaths')
elseif not bExists then
EgtOutLog( 'Warning: Ribs not possibile (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 = ( 1 - nOverlap / 100) * LayerParams.dStrand
local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrfBase, nRibsPathGrp, - dNewOffs)
if bOk and bExists then
vSurfOffs[ nOverlap] = nSrfOffs
end
end
end
-- gestisco eventuali intersezioni fra costolature
local bInters = HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp)
local bInters = HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, bAllTwoStrands)
EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_INTERS, bInters)
EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_TWO_STRANDS, bAllTwoStrands)
-- riordino le costolature
if LayerParams.nRibsShellsNbr == 2 and bInters then
if bAllTwoStrands and bInters then
-- gestione caso speciale di intersezione e 2 passate
ReorderRibsInters2Shells( nRibsPathGrp, LayerParams.dStrand)
else
ReorderRibs( nRibsPathGrp, LayerParams.bRibsInvertOrder, LayerParams.nRibsShellsNbr)
ReorderRibs( nRibsPathGrp, LayerParams.bRibsInvertOrder)
end
-- eseguo il trim delle costole con la regione offsettata
local vErased = {}
local vOrderedRibs = EgtGetNameInGroup( nRibsPathGrp, RIBS_CRV .. '*')
for i = 1, #vOrderedRibs do
local nCrv, nCnt = EgtTrimCurveWithRegion( vOrderedRibs[i], nSrf, true, false)
if nCnt == 0 then
-- lo aggiungo nella tabella delle costolature eliminate
for i = 1, #vOrderedRibs do
-- trim con superficie opportuna
local nOverlap = EgtGetInfo( vOrderedRibs[i], KEY_RIBS_OVERLAP, 'i')
if not vSurfOffs[ nOverlap] then
-- la costolatura non è fattibile
EgtOutLog( 'Warning: Ribs not possibile (layer '..tostring( nIdx)..') - CalcPaths')
EgtErase( vOrderedRibs[i])
vErased[vOrderedRibs[i]] = 1
end
-- elimino tratti troppo corti
for nId = nCrv, nCrv + nCnt - 1 do
local dLen = EgtCurveLength( nId)
if dLen < 10 * MIN_LEN then
EgtErase( nId)
else
local nCrv, nCnt = EgtTrimCurveWithRegion( vOrderedRibs[i], vSurfOffs[nOverlap], true, false)
if nCnt == 0 then
-- lo aggiungo nella tabella delle costolature eliminate
vErased[vOrderedRibs[i]] = 1
else
local nInfo = EgtGetInfo( nId, KEY_SPLIT_RIB, 'i')
-- se la costolatura da cui deriva è stata eliminata, tolgo l'info che le associava
if nInfo and vErased[nInfo] then
EgtRemoveInfo( nId, KEY_SPLIT_RIB)
vErased[vOrderedRibs[i]] = 1
end
-- elimino tratti troppo corti
for nId = nCrv, nCrv + nCnt - 1 do
local dLen = EgtCurveLength( nId)
if dLen < 10 * MIN_LEN then
EgtErase( nId)
-- lo aggiungo nella tabella delle costolature eliminate
vErased[vOrderedRibs[i]] = 1
else
local nInfo = EgtGetInfo( nId, KEY_SPLIT_RIB, 'i')
-- se la costolatura da cui deriva è stata eliminata, tolgo l'info che le associava
if nInfo and vErased[nInfo] then
EgtRemoveInfo( nId, KEY_SPLIT_RIB)
end
end
end
end
end
end
if not EgtGetFirstNameInGroup( nRibsPathGrp, RIBS_CRV .. '*') then
EgtErase( nSrfBase)
if not EgtGetFirstNameInGroup( nRibsPathGrp, RIBS_CRV .. '*') then
EgtErase( nRibsPathGrp)
end
nCrvGrp = EgtGetNextName( nCrvGrp, CONTOUR_GRP .. '*')
@@ -532,86 +662,35 @@ function CalcPaths.Exec( nPartId, nStmId)
-- recupero la superficie ottenuta dallo slicing
local nSrf = EgtGetFirstNameInGroup( nCrvGrpId, LAYER_SRF)
if nSrf then
-- esterno
local nSrfId = EgtCopyGlob( nSrf, nCrvGrpId)
-- parete esterna
local dOffs = 0.5 * LayerParams.dStrand - LayerParams.dOffs
local bOk = EgtSurfFrOffset( nSrfId, -dOffs)
local bExists = EgtSurfFrChunkCount( nSrfId) > 0
if not bOk then
EgtErase( nSrfId)
nSrfId = EgtCopyGlob( nSrf, nCrvGrpId)
local dNewOffs = dOffs - 0.05
bOk = EgtSurfFrOffset( nSrfId, -dNewOffs)
bExists = EgtSurfFrChunkCount( nSrfId) > 0
end
-- se offset riuscito, estraggo i contorni (pareti esterne)
local bOk, bExists, nSrfId = ComputeSurfOffset( nSrf, nCrvGrpId, - dOffs)
if not bOk then
EgtOutLog( 'Error on ExtOffset (layer '..tostring( nIdx)..') - CalcPaths')
elseif not bExists then
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)
end
EgtErase( nSrfId)
-- calcolo pareti interne
-- pareti interne
for nInd2 = 1, LayerParams.nShellsNbr - 1 do
-- offset della superficie originale
local nSrfId = EgtCopy( nSrf, nGrpId)
local bOk = EgtSurfFrOffset( nSrfId, - dOffs - nInd2 * LayerParams.dStrand)
local bExists = EgtSurfFrChunkCount( nSrfId) > 0
if not bOk then
EgtErase( nSrfId)
nSrfId = EgtCopyGlob( nSrf, nCrvGrpId)
bOk = EgtSurfFrOffset( nSrfId, -dOffs + 0.05 - nInd2 * LayerParams.dStrand)
bExists = EgtSurfFrChunkCount( nSrfId) > 0
end
-- se offset riuscito, estraggo i contorni ( pareti interne)
local bOk, bExists, nSrfId = ComputeSurfOffset( nSrf, nCrvGrpId, - dOffs - nInd2 * LayerParams.dStrand)
if not bOk then
EgtOutLog( 'Error on IntOffset (layer '..tostring( nIdx)..') - CalcPaths')
elseif not bExists then
EgtOutLog( 'Warning : IntOffset not possible (layer '..tostring( nIdx)..') - CalcPaths')
else
-- se offset riuscito, estraggo i contorni ( pareti interne)
GetPathsFromSurf( nSrfId, SHELL_CRV..tostring( nInd2), TYPE.INNER_SHELL, nGrpId, vPtStart)
end
EgtErase( nSrfId)
end
-- costolature
if nRibsGrp then
-- creo o svuoto il gruppo per le costolature
local nRibsPathGrp = EgtGetFirstNameInGroup( nCrvGrpId, RIBS_GRP)
if not nRibsPathGrp then
nRibsPathGrp = EgtGroup( nCrvGrpId)
EgtSetName( nRibsPathGrp, RIBS_GRP)
EgtSetStatus( nRibsPathGrp, GDB_ST.OFF)
else
EgtEmptyGroup( nRibsPathGrp)
end
-- calcolo superficie di offset da usare per le costolature
local nSrfId = EgtCopy( nSrf, nRibsPathGrp)
local dOffs = 0.5 * LayerParams.dStrand - LayerParams.dOffs + ( LayerParams.nShellsNbr - 1) * LayerParams.dStrand + ( 1 - LayerParams.dRibsOverlap / 100) * LayerParams.dStrand
local bOk = EgtSurfFrOffset( nSrfId, - dOffs)
local bExists = ( bOk and EgtSurfFrChunkCount( nSrfId) > 0)
if not bOk then
EgtErase( nSrfId)
nSrfId = EgtCopyGlob( nSrf, nRibsPathGrp)
bOk = EgtSurfFrOffset( nSrfId, - dOffs + 0.05)
bExists = ( bOk and EgtSurfFrChunkCount( nSrfId) > 0)
end
-- se non ho una superficie errore ed elimino il gruppo delle costolature
if not bOk then
EgtErase( nRibsPathGrp)
EgtOutLog( 'Error on Offset (Ribs) (layer '..tostring( nIdx)..') - CalcPaths')
elseif not bExists then
EgtErase( nRibsPathGrp)
EgtOutLog( 'Warning : Ribs not possible (layer '..tostring( nIdx)..') - CalcPaths')
end
end
-- gestione eventuale floor
if nIdx <= LayerParams.nFloorNbr then
AddFloor( nSrf, nGrpId, LayerParams, nIdx)
@@ -624,7 +703,7 @@ function CalcPaths.Exec( nPartId, nStmId)
-- sistemo eventuali costolature
if nRibsGrp then
CalcRibsPaths( vLayIds[nIdx], nRibsGrp, LayerParams, nStmId)
CalcRibsPaths( vLayIds[nIdx], nRibsGrp, LayerParams, nStmId, nIdx)
end
if EgtProcessEvents( nIdx / #vLayIds * 100, 0) == 1 then
LuaLibs/CalcSlices.lua
+44 -1
View File
@@ -53,15 +53,48 @@ local function ComputeMaxH( nStmId, frSlicing, HMax)
return GEO.INFINITO
end
--------------------------------------------------------------------
local function ReadParam( nId, sKey, sType, table)
local info = EgtGetInfo( nId, sKey, sType) or EgtGetInfo( s_nPartId, sKey, sType)
table[sKey] = info
end
--------------------------------------------------------------------
local function GetRibParams( nId)
local RibParam = {}
ReadParam( nId, KEY_RIBS_SHELLS_NBR, 'i', RibParam)
ReadParam( nId, KEY_RIBS_INVERT_DIR, 'b', RibParam)
ReadParam( nId, KEY_RIBS_LEAD_IN_INVERT, 'b', RibParam)
ReadParam( nId, KEY_RIBS_LEAD_IN_LEN, 'd', RibParam)
ReadParam( nId, KEY_RIBS_LEAD_OUT_INVERT, 'b', RibParam)
ReadParam( nId, KEY_RIBS_LEAD_OUT_LEN, 'd', RibParam)
ReadParam( nId, KEY_RIBS_LEAD_OUT_COASTING, 'd', RibParam)
ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE, 'd', RibParam)
ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd', RibParam)
-- overlap può essere diverso tra le varie costolature solo se non sono collegate
local bLink = EgtGetInfo( s_nPartId, KEY_RIBS_LINK, 'b') or false
if bLink then
RibParam[ KEY_RIBS_OVERLAP] = EgtGetInfo( s_nPartId, KEY_RIBS_OVERLAP, 'i') -- parametro generico
else
ReadParam( nId, KEY_RIBS_OVERLAP, 'i', RibParam) -- parametro specifico della costolatura
end
return RibParam
end
--------------------------------------------------------------------
local function SlicingRibs( vtSlicing)
local nRibsShells = EgtGetInfo( s_nPartId, KEY_RIBS_SHELLS_NBR, 'i') or 0
if nRibsShells == 0 then return end
-- recupero le superfici che definiscono le nervature
local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS)
local vRibsIds = EgtGetAllInGroup( nRibsLay or GDB_ID.NULL)
if not vRibsIds or #vRibsIds == 0 then return end
-- sistemo la direzione normale dei piani
for i = 1, #vRibsIds do
if EgtGetType( vRibsIds[i]) == GDB_TY.SRF_MESH then
@@ -72,6 +105,13 @@ local function SlicingRibs( vtSlicing)
end
end
end
-- recupero i parametri di ogni costolatura
local tabParams = {}
for i = 1, #vRibsIds do
local vRibParams = GetRibParams( vRibsIds[i])
table.insert( tabParams, vRibParams)
end
local nLayId = EgtGetFirstNameInGroup( s_nPartId, SLICE_LAYER .. '*')
while nLayId do
@@ -92,10 +132,13 @@ local function SlicingRibs( vtSlicing)
for nId = nNewId, nNewId + nPntCnt -1 do
EgtErase( nId)
end
-- rinomino le curve e correggo di DeltaZ
-- rinomino le curve, correggo di DeltaZ e assegno parametri
for nId = nNewId + nPntCnt, nNewId + nPntCnt + nCrvCnt - 1 do
EgtSetName( nId, RIBS_CRV .. tostring( i))
EgtMove( nId, - dDeltaZ * vtSlicing)
for sKey, sVal in pairs( tabParams[i]) do
EgtSetInfo( nId, sKey, sVal)
end
end
-- rimuovo superfici
for nId = nNewId + nPntCnt + nCrvCnt, nNewId + nPntCnt + nCrvCnt + nSrfCnt -1 do
LuaLibs/CalcToolPath.lua
+63 -53
View File
@@ -38,17 +38,8 @@ local function GetLayerParamsForToolPathCalc()
LayerParams.vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v')
LayerParams.dTDiam = EgtGetInfo( s_nPartId, KEY_TOOL_DIAM, 'd')
-- Parametri costolature
LayerParams.nRibsShellsNbr = EgtGetInfo( s_nPartId, KEY_RIBS_SHELLS_NBR, 'i')
LayerParams.bRibsLink = EgtGetInfo( s_nPartId, KEY_RIBS_LINK, 'b')
LayerParams.bRibsInvert = EgtGetInfo( s_nPartId, KEY_RIBS_INVERT_DIR, 'b')
LayerParams.bRibsLIInvert = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_IN_INVERT, 'b')
LayerParams.dRibsLILen = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_IN_LEN, 'd')
LayerParams.bRibsLOInvert = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_OUT_INVERT, 'b')
LayerParams.dRibsLOLen = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_OUT_LEN, 'd')
LayerParams.dRibsLOCoasting = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_OUT_COASTING, 'd')
LayerParams.dRibsLOWipe = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_OUT_WIPE, 'd')
LayerParams.dRibsLOWipeAng = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd')
return LayerParams
end
@@ -153,7 +144,7 @@ local function AddRetraction( nCrvId, dCoastingLen, dWipeLen)
if dWipeLen > GEO.EPS_SMALL then
local nWipeId = EgtCopyGlob( nCopyId, nCoastingId or nCrvId, GDB_IN.AFTER)
EgtTrimCurveEndAtLen( nWipeId, dWipeLen)
EgtTrimCurveEndAtLen( nWipeId, dWipeLen)
EgtSetName( nWipeId, WIPE_CRV)
EgtSetInfo( nWipeId, KEY_TYPE, TYPE.WIPE)
EgtSetColor( nWipeId, EgtStdColor('TEAL'))
@@ -276,9 +267,12 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink)
end
--------------------------------------------------------------------
local function AddRibsLeadIn( nCrv, nLoopsGrp, LayerParams)
local function AddRibsLeadIn( nCrv, nLoopsGrp)
if LayerParams.dRibsLILen < GEO.EPS_SMALL then return end
local dLILen = EgtGetInfo( nCrv, KEY_RIBS_LEAD_IN_LEN, 'd')
local bLIInvert = EgtGetInfo( nCrv, KEY_RIBS_LEAD_IN_INVERT, 'b')
if dLILen < GEO.EPS_SMALL then return end
-- recupero la curva di offset su cui calcolare leadin
local ptS = EgtSP( nCrv)
@@ -304,10 +298,10 @@ local function AddRibsLeadIn( nCrv, nLoopsGrp, LayerParams)
local dLen1 = EgtCurveLength( nCrvId)
local dLen2 = EgtCurveLength( nNewId)
local bKeepFirst = LayerParams.bRibsLIInvert
if dLen1 > LayerParams.dRibsLILen - GEO.EPS_SMALL and dLen2 < LayerParams.dRibsLILen - GEO.EPS_SMALL then
local bKeepFirst = bLIInvert
if dLen1 > dLILen - GEO.EPS_SMALL and dLen2 < dLILen - GEO.EPS_SMALL then
bKeepFirst = true
elseif dLen1 < LayerParams.dRibsLILen - GEO.EPS_SMALL and dLen2 > LayerParams.dRibsLILen - GEO.EPS_SMALL then
elseif dLen1 < dLILen - GEO.EPS_SMALL and dLen2 > dLILen - GEO.EPS_SMALL then
bKeepFirst = false
end
@@ -320,7 +314,7 @@ local function AddRibsLeadIn( nCrv, nLoopsGrp, LayerParams)
end
end
EgtTrimCurveEndAtLen( nCrvId, LayerParams.dRibsLILen)
EgtTrimCurveEndAtLen( nCrvId, dLILen)
EgtInvertCurve( nCrvId)
EgtSetInfo( nCrvId, KEY_TYPE, TYPE.RIB)
EgtSetName( nCrvId, LEAD_IN_CRV)
@@ -332,11 +326,17 @@ local function AddRibsLeadIn( nCrv, nLoopsGrp, LayerParams)
end
--------------------------------------------------------------------
local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams)
local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing)
if abs( LayerParams.dRibsLOLen) < GEO.EPS_SMALL and
abs( LayerParams.dRibsLOCoasting) < GEO.EPS_SMALL and
abs( LayerParams.dRibsLOWipe) < GEO.EPS_SMALL then return end
local dRibsLOLen = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_LEN, 'd')
local dRibsLOCoasting = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_COASTING, 'd')
local dRibsLOWipe = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_WIPE, 'd')
local dRibsLOWipeAng = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd')
local bRibsLOInvert = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_INVERT, 'b')
if abs( dRibsLOLen) < GEO.EPS_SMALL and
abs( dRibsLOCoasting) < GEO.EPS_SMALL and
abs( dRibsLOWipe) < GEO.EPS_SMALL then return end
local ptE = EgtEP( nCrv)
-- recupero la curva di offset su cui calcolare lead out
@@ -368,10 +368,10 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams)
local nNewId = EgtSplitCurveAtParam( nCrvRef, dParE) or EgtCopyGlob( nCrvRef, nCrv, GDB_IN.AFTER)
local dLen1 = EgtCurveLength( nCrvRef)
local dLen2 = EgtCurveLength( nNewId)
bInvert = LayerParams.bRibsLOInvert
if dLen1 > LayerParams.dRibsLOLen + LayerParams.dRibsLOCoasting - GEO.EPS_SMALL and dLen2 < LayerParams.dRibsLOLen + LayerParams.dRibsLOCoasting - GEO.EPS_SMALL then
bInvert = bRibsLOInvert
if dLen1 > dRibsLOLen + dRibsLOCoasting - GEO.EPS_SMALL and dLen2 < dRibsLOLen + dRibsLOCoasting - GEO.EPS_SMALL then
bInvert = true
elseif dLen1 < LayerParams.dRibsLOLen + LayerParams.dRibsLOCoasting - GEO.EPS_SMALL and dLen2 > LayerParams.dRibsLOLen + LayerParams.dRibsLOCoasting - GEO.EPS_SMALL then
elseif dLen1 < dRibsLOLen + dRibsLOCoasting - GEO.EPS_SMALL and dLen2 > dRibsLOLen + dRibsLOCoasting - GEO.EPS_SMALL then
bInvert = false
end
@@ -386,13 +386,13 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams)
-- verifico se la curva ha lunghezza sufficiente
local dLen = EgtCurveLength( nCrvRef)
local bSkip = ( dLen - LayerParams.dRibsLOLen - LayerParams.dRibsLOCoasting < - GEO.EPS_SMALL)
local bSkip = ( dLen - dRibsLOLen - dRibsLOCoasting < - GEO.EPS_SMALL)
local vtE = EgtSV( nCrvRef)
-- primo tratto ( segue offset con flusso aperto)
if LayerParams.dRibsLOLen > GEO.EPS_SMALL and not bSkip then
if dRibsLOLen > GEO.EPS_SMALL and not bSkip then
nCrvLO = EgtCopyGlob( nCrvRef, nCrv, GDB_IN.AFTER)
EgtTrimCurveEndAtLen( nCrvLO, LayerParams.dRibsLOLen)
EgtTrimCurveEndAtLen( nCrvLO, dRibsLOLen)
EgtSetInfo( nCrvLO, KEY_TYPE, TYPE.RIB)
EgtSetName( nCrvLO, LEAD_OUT_CRV)
-- aggiorno ptE e vtE
@@ -401,10 +401,10 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams)
end
-- secondo tratto ( segue offset con flusso chiuso)
if LayerParams.dRibsLOCoasting > GEO.EPS_SMALL and not bSkip then
if dRibsLOCoasting > GEO.EPS_SMALL and not bSkip then
nCoasting = EgtCopyGlob( nCrvRef, nCrvLO or nCrv, GDB_IN.AFTER)
EgtTrimCurveStartAtLen( nCoasting, LayerParams.dRibsLOLen)
EgtTrimCurveEndAtLen( nCoasting, LayerParams.dRibsLOCoasting)
EgtTrimCurveStartAtLen( nCoasting, dRibsLOLen)
EgtTrimCurveEndAtLen( nCoasting, dRibsLOCoasting)
EgtSetName( nCoasting, COASTING_CRV)
EgtSetInfo( nCoasting, KEY_TYPE, TYPE.COASTING)
@@ -417,10 +417,10 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams)
EgtErase( nCrvRef)
-- terzo tratto ( diretto verso esterno con ugello chiuso)
if LayerParams.dRibsLOWipe > GEO.EPS_SMALL then
local dAng = EgtIf( bInvert, 90, - 90) + LayerParams.dRibsLOWipeAng
vtE:rotate( LayerParams.vtSlicing, dAng)
local ptFinal = ptE + vtE * LayerParams.dRibsLOWipe
if dRibsLOWipe > GEO.EPS_SMALL then
local dAng = EgtIf( bInvert, 90, - 90) + dRibsLOWipeAng
vtE:rotate( vtSlicing, dAng)
local ptFinal = ptE + vtE * dRibsLOWipe
nWipe = EgtCurveCompoFromPoints( nTPathGrp, { ptE, ptFinal})
EgtRelocateGlob( nWipe, nCoasting or nCrvLO or nCrv, GDB_IN.AFTER)
EgtSetName( nWipe, WIPE_CRV)
@@ -453,19 +453,22 @@ local function CalcRibsToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ)
EgtSetColor( nNewEntId, EgtStdColor('GRAY'))
end
-- estraggo i contorni della superficie di offset
-- estraggo i contorni di tutte le superfici di offset
local nLoopGrp = EgtGroup( nRibsGrp)
local nSrfId = EgtGetFirstNameInGroup( nRibsGrp, LAYER_SRF)
local nChunksNbr = EgtSurfFrChunkCount( nSrfId)
for i = 0, nChunksNbr do
local nRes, nCnt = EgtExtractSurfFrChunkLoops( nSrfId, i, nLoopGrp)
if nRes then
for j = nRes, nRes + nCnt - 1 do
EgtMove( j, dCorrZ * Z_AX(), GDB_RT.GLOB)
-- mi sposto dell'altezza layer
EgtMove( j, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
while nSrfId do
local nChunksNbr = EgtSurfFrChunkCount( nSrfId)
for i = 0, nChunksNbr do
local nRes, nCnt = EgtExtractSurfFrChunkLoops( nSrfId, i, nLoopGrp)
if nRes then
for j = nRes, nRes + nCnt - 1 do
EgtMove( j, dCorrZ * Z_AX(), GDB_RT.GLOB)
-- mi sposto dell'altezza layer
EgtMove( j, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
end
end
end
nSrfId = EgtGetNextName( nSrfId, LAYER_SRF)
end
-- recupero i gruppi delle costolature
@@ -479,21 +482,28 @@ local function CalcRibsToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ)
end
local bInters = EgtGetInfo( nRibsGrp, KEY_RIBS_INTERS, 'b') or false
local bSpecialCase = bInters and LayerParams.nRibsShellsNbr == 2
local bAllTwoStrands = EgtGetInfo( nRibsGrp, KEY_RIBS_TWO_STRANDS, 'b') or false
local bSpecialCase = bInters and bAllTwoStrands
local bSwap = false
-- orientamento delle curve
local bInvert = LayerParams.bRibsInvert
-- orientamento del primo gruppo di curve
local bInvert = EgtGetInfo( tabRibs[1][1], KEY_RIBS_INVERT_DIR, 'b')
if not bSpecialCase then
for i = 1, #tabRibs do
for i = 1, #tabRibs do
local nInfo = EgtGetInfo( tabRibs[i][1], KEY_SPLIT_RIB, 'i')
local nShellsNbr = EgtGetInfo( tabRibs[i][1], KEY_RIBS_SHELLS_NBR, 'i')
-- aggiorno bInvert per il gruppo di costolature analizzato
if i > 1 and not nInfo then
if LayerParams.bRibsLink and LayerParams.nRibsShellsNbr % 2 == 1 then
bInvert = not bInvert
if not LayerParams.bRibsLink then
bInvert = EgtGetInfo( tabRibs[i][1], KEY_RIBS_INVERT_DIR, 'b')
else
if i > 1 and not nInfo then
local nPrevShellsNbr = EgtGetInfo( tabRibs[i-1][1], KEY_RIBS_SHELLS_NBR, 'i')
if nPrevShellsNbr % 2 == 1 then
bInvert = not bInvert
end
end
end
if LayerParams.nRibsShellsNbr == 1 and nInfo and bInvert then
if nShellsNbr == 1 and nInfo and bInvert then
-- se inverto direzione di costolature divise allora devo invertirne anche l'ordine di realizzazione
bSwap = true
EgtRelocateGlob( tabRibs[i][1], tabRibs[i-1][1], GDB_IN.BEFORE)
@@ -550,12 +560,12 @@ local function CalcRibsToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ)
-- verifico se necessario lead in
local nPrev = EgtGetPrev( nCrvRib)
if not nPrev or EgtGetName( nPrev) then
AddRibsLeadIn( nCrvRib, nLoopGrp, LayerParams)
AddRibsLeadIn( nCrvRib, nLoopGrp)
end
-- verifico se necessario lead out
local nNext = EgtGetNext( nCrvRib)
if not nNext or EgtGetName( nNext) then
AddRibsLeadOut( nCrvRib, nTpathGrpId, nLoopGrp, LayerParams)
AddRibsLeadOut( nCrvRib, nTpathGrpId, nLoopGrp, LayerParams.vtSlicing)
end
nCrvRib = EgtGetNextName( nCrvRib, RIBS_CRV .. '*')
end