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

3dPrinting :

Browse Source 
- prima gestione solidi ausiliari ( solo riempimenti pieni)
- gestione floor/ceil
- modifiche progress bar.
This commit is contained in:
SaraP
2022-09-06 09:59:35 +02:00
parent 56b05c0eeb
commit 7b8ee800c0
8 changed files with 970 additions and 245 deletions
Download Patch File Download Diff File Expand all files Collapse all files
LuaLibs/CalcToolPath.lua
+181 -64
View File
@@ -14,6 +14,7 @@ local AMD = require( 'AddManData')
---------------------------------------------------------------------
local s_nPartId
local s_nDefaultWipeAng = -90 -- angolo = 0° per wipe significa che esce ortogonalmente alla direzione del movimento
---------------------------------------------------------------------
local function GetLayerParamsForToolPathCalc()
@@ -64,32 +65,36 @@ end
-------------------------------------------------------------------
local function AddLink( vCrv, nTpathGrpId, nLinkType, dLinkParam, dSPOffs, dStrand, vtSlicing)
if not vCrv or #vCrv == 0 then return end
if not vCrv or #vCrv == 0 then return end
local k = 0
local bPrevClosed = EgtGetInfo( vCrv[1], KEY_CLOSED_CRV, 'b') or false
for i = 2, #vCrv do
-- link ha senso solo se la curva corrente è chiusa (eviti extra shell aperte)
if EgtCurveIsClosed( vCrv[i]) then
-- il link ha senso solo su curve chiuse
local bCurrClosed = EgtCurveIsClosed( vCrv[i])
if bCurrClosed and bPrevClosed then
-- aggiorno k per calcolo dell'offset
local sPrevName = EgtGetName( vCrv[i-1])
local sCurrName = EgtGetName( vCrv[i])
if sPrevName ~= sCurrName then k = k + 1 end
local nType = EgtGetInfo( vCrv[i], KEY_TYPE, 'i')
if sPrevName ~= sCurrName or nType == TYPE.INFILL or nType == TYPE.AUX_SOLID then
k = k + 1
end
-- se nessun raccordo modifico solo lo start point della curva
if nLinkType == LINK_TYPE.NONE then
local dLen = k * dSPOffs
local dLen = k * dSPOffs
if dSPOffs < 0 then
dLen = EgtCurveLength( vCrv[i]) + dLen
end
local dPar = EgtCurveParamAtLength( vCrv[i], dLen)
if dPar then EgtChangeClosedCurveStart( vCrv[i], dPar) end
else
-- altrimenti verifico se ha senso creare raccordo
local dDist = dist( EgtEP( vCrv[i-1]), EgtSP( vCrv[i]))
if dDist < dStrand + 10 then
-- local dDist = dist( EgtEP( vCrv[i-1]), EgtSP( vCrv[i]))
local dDist = EgtPointCurveDist( EgtEP( vCrv[i-1]), vCrv[i])
if dDist < dStrand + 2 then
local nLinkId
if k > 1 then
-- modifico lo start point
@@ -111,7 +116,7 @@ local function AddLink( vCrv, nTpathGrpId, nLinkType, dLinkParam, dSPOffs, dStra
EgtRelocateGlob( nLinkId, nTpathGrpId, GDB_IN.LAST_SON)
EgtErase( nGrpTmp)
end
if nLinkId then
EgtRelocate( nLinkId, vCrv[i], GDB_IN.BEFORE)
EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB)
@@ -120,6 +125,7 @@ local function AddLink( vCrv, nTpathGrpId, nLinkType, dLinkParam, dSPOffs, dStra
end
end
end
bPrevClosed = bCurrClosed
end
end
@@ -179,16 +185,12 @@ local function AddLeadOut( nCrvId, LayerParams, nGrpId)
end
--------------------------------------------------------------------
local function AddRetraction( nCrvId, LayerParams, dCoastingLen, dWipeLen)
local function AddRetraction( nCrvId, LayerParams, dCoastingLen, dWipeLen, dWipeDir)
-- recupero i parametri per retrazione
local nType = EgtGetInfo( nCrvId, KEY_TYPE, 'i')
local bClosedExtraShell = EgtGetInfo( nCrvId, KEY_CLOSED_EXTRA_SHELL, 'b') or false
local dWipeDir = EgtIf( nType == TYPE.EXTRA_SHELL, LayerParams.dShellNbrWipeDir, 0)
if nType == TYPE.EXTRA_SHELL and not bClosedExtraShell then
dWipeLen = LayerParams.dShellNbrWipe
dCoastingLen = LayerParams.dShellNbrCoasting
end
local bClosed = EgtGetInfo( nCrvId, KEY_CLOSED_CRV, 'b') or false
local bInverted = EgtGetInfo( nCrvId, KEY_INVERTED_CRV, 'b') or false
-- curva ausiliaria per generare correttamente wipe
local nCopyId = EgtCopyGlob( nCrvId, nCrvId, GDB_IN.AFTER)
@@ -200,7 +202,7 @@ local function AddRetraction( nCrvId, LayerParams, dCoastingLen, dWipeLen)
if dCoastingLen > GEO.EPS_SMALL then
nCoastingId = EgtCopyGlob( nCrvId, nCrvId, GDB_IN.AFTER)
local dPar = EgtCurveParamAtLength( nCoastingId, EgtCurveLength( nCoastingId) - dCoastingLen)
if not dPar then
if not dPar then
EgtErase( nCoastingId)
nCoastingId = nil
else
@@ -218,18 +220,26 @@ local function AddRetraction( nCrvId, LayerParams, dCoastingLen, dWipeLen)
end
if dWipeLen > GEO.EPS_SMALL then
-- se shell
local nWipeId
if nType == TYPE.OUTER_SHELL or nType == TYPE.INNER_SHELL or bClosedExtraShell then
-- se shell o extra shell chiusa
local nWipeId
if bClosed then
-- se era chiusa ( quindi analogo alle shell)
nWipeId = EgtCopyGlob( nCopyId, nCoastingId or nCrvId, GDB_IN.AFTER)
EgtTrimCurveEndAtLen( nWipeId, dWipeLen)
else
-- se extra shell
local bInverted = EgtGetInfo( nCrvId, KEY_INVERTED_CURVE, 'b') or false
-- se extra shell o infill a zigzag
local vtDir = EgtEV( nCoastingId or nCrvId)
local dAng = dWipeDir - 90
vtDir:rotate( LayerParams.vtSlicing, EgtIf( bInverted, - dAng, dAng))
local dAng = dWipeDir + s_nDefaultWipeAng
-- verifico se necessario cambiare il segno all'angolo
local bChangeSign = false
if nType == TYPE.EXTRA_SHELL then
bChangeSign = bInverted
else
local vtS = EgtGetInfo( nCrvId, KEY_ZIG_ZAG_DIR, 'v')
local bSameDir = AreSameVectorApprox( vtS, vtDir)
bChangeSign = ( bInverted == bSameDir)
end
vtDir:rotate( LayerParams.vtSlicing, EgtIf( bChangeSign, - dAng, dAng))
local ptS = EgtEP( nCoastingId or nCrvId)
local ptE = ptS + vtDir * dWipeLen
nWipeId = EgtCurveCompoFromPoints( EgtGetParent( nCrvId), {ptS, ptE})
@@ -246,21 +256,21 @@ local function AddRetraction( nCrvId, LayerParams, dCoastingLen, dWipeLen)
end
--------------------------------------------------------------------
local function AddRetractionOnLastCrv( nCrvId, nTpathGrpId, LayerParams)
local function AddRetractionOnLastCrv( nCrvId, nTpathGrpId, LayerParams, dCoastingLen, dWipeLen, dWipeDir)
if LayerParams.nLeadOutType == LEAD_TYPE.NONE then
AddRetraction( nCrvId, LayerParams, LayerParams.dCoastingLen, LayerParams.dWipeLen)
AddRetraction( nCrvId, LayerParams, dCoastingLen, dWipeLen, dWipeDir)
else
local nLeadOutId = EgtGetLastInGroup( nTpathGrpId)
local dLen = EgtCurveLength( nLeadOutId)
if dLen > LayerParams.dCoastingLen - 500 * GEO.EPS_SMALL then
if dLen > dCoastingLen - 500 * GEO.EPS_SMALL then
-- coinvolge solo la curva di lead out
local dNewCoastingLen = EgtIf( abs( LayerParams.dCoastingLen - dLen) < 500 * GEO.EPS_SMALL, dLen, LayerParams.dCoastingLen) -- verifico se interamente coinvolta
AddRetraction( nLeadOutId, LayerParams, dNewCoastingLen, 0.0)
local dNewCoastingLen = EgtIf( abs( dCoastingLen - dLen) < 500 * GEO.EPS_SMALL, dLen, dCoastingLen) -- verifico se interamente coinvolta
AddRetraction( nLeadOutId, LayerParams, dNewCoastingLen, 0.0, dWipeDir)
else
-- coinvolge parte dell'ultima shell crv
local dNewCoastingLen = LayerParams.dCoastingLen - dLen
local nCoastingId = AddRetraction( nCrvId, LayerParams, dNewCoastingLen, 0.0)
local dNewCoastingLen = dCoastingLen - dLen
local nCoastingId = AddRetraction( nCrvId, LayerParams, dNewCoastingLen, 0.0, dWipeDir)
EgtAddCurveCompoCurve( nCoastingId, nLeadOutId)
end
end
@@ -271,6 +281,22 @@ local function VerifyRibsLink( nLinkId, nCurr, nNext, dStrand)
local nGrp = EgtGetParent( nCurr)
-- verifico se il link interseca le due curve nell'altro estremo
local ptS = EgtSP( nCurr)
local ptE = EgtEP( nNext)
local dParS = EgtCurveParamAtPoint( nLinkId, ptS)
local dParE = EgtCurveParamAtPoint( nLinkId, ptE)
if dParS or dParE then
return false
end
-- verifico se si trova nella regione ammissibile
local nSurfId = EgtGetInfo( nCurr, KEY_ASSOCIATED_SURF, 'i')
local nRes = EgtCurveWithRegionClassify( nLinkId, nSurfId)
if nRes == GDB_CRC.OUT or nRes == GDB_CRC.INTERS then
return false
end
-- regione occupata dal link
local nTotLink = EgtCopyGlob( nLinkId, nGrp)
local nCopy = EgtCopyGlob( nLinkId, nGrp)
@@ -280,8 +306,8 @@ local function VerifyRibsLink( nLinkId, nCurr, nNext, dStrand)
if not nOffs or nOffs == GDB_ID.NULL then
nOffs = nTotLink
end
-- verifico se il link interseca una delle altre costolature
-- verifico se il link interseca una delle altre costolature
local vRibsIds = EgtGetNameInGroup( nGrp, RIBS_CRV .. '*')
for i = 1, #vRibsIds do
if vRibsIds[i] ~= nCurr and vRibsIds[i] ~= nNext then
@@ -368,8 +394,13 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, dStrand, bForceLink)
-- se non ho trovato un collegamento sul bordo, creo una linea tra ptS e ptE
if bForceLink then
local nLinkId = EgtCurveCompoFromPoints( EgtGetParent( nCurr), {ptS, ptE})
EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB)
EgtRelocateGlob( nLinkId, nCurr, GDB_IN.AFTER)
local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, dStrand)
if bValid then
EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB)
EgtRelocateGlob( nLinkId, nCurr, GDB_IN.AFTER)
else
EgtErase( nLinkId)
end
end
end
@@ -526,7 +557,7 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing)
-- terzo tratto ( diretto verso esterno con ugello chiuso)
if dRibsLOWipe > GEO.EPS_SMALL then
local dAng = dRibsLOWipeAng - 90
local dAng = dRibsLOWipeAng + s_nDefaultWipeAng
vtE:rotate( vtSlicing, EgtIf( bInvert, - dAng, dAng))
local ptFinal = ptE + vtE * dRibsLOWipe
nWipe = EgtCurveCompoFromPoints( nTPathGrp, { ptE, ptFinal})
@@ -564,17 +595,13 @@ local function CalcRibsToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ)
-- estraggo i contorni di tutte le superfici di offset
local nLoopGrp = EgtGroup( nRibsGrp)
local nSrfId = EgtGetFirstNameInGroup( nRibsGrp, TOT_SHELL_TRIM_SURF)
while nSrfId do
while nSrfId do
EgtMove( nSrfId, dCorrZ * Z_AX(), GDB_RT.GLOB)
-- mi sposto dell'altezza layer
EgtMove( nSrfId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
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
local nRes, nCnt = EgtExtractSurfFrChunkLoops( nSrfId, i, nLoopGrp)
end
nSrfId = EgtGetNextName( nSrfId, TOT_SHELL_TRIM_SURF)
end
@@ -679,6 +706,72 @@ local function CalcRibsToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ)
end
end
---------------------------------------------------------------------
local function CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGrpId, LayerParams, dCorrZ)
-- recupero le curve relative al primo solido ausiliario
local sPrevName = AUX_SOLID_CRV
local nSolidId = EgtGetFirstNameInGroup( nAuxSolidsGrp, AUX_SOLIDS_CRV .. '*')
while nSolidId do
local sName = EgtGetName( nSolidId)
if sName ~= sPrevName then
-- recupero tutti i percorsi relativi a quel solido
local vEntIds = EgtGetNameInGroup( nAuxSolidsPathGrp, sName .. '*')
if vEntIds then
-- recupero i parametri relativi al solido
local nOrder = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_PRINT_ORDER, 'i')
local nLinkType = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_LINK_TYPE, 'i')
local dLinkParam = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_LINK_PARAM, 'd')
local dSPOffset = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_SP_OFFSET, 'd')
local dCoastingLen = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_COASTING_LEN, 'd')
local dWipeLen = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_WIPE_LEN, 'd')
local dWipeDir = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_WIPE_DIR, 'd')
-- copio i percorsi nel gruppo toolpath
local nPrev = EgtGetLastInGroup( nTpathGrpId)
for i = 1, #vEntIds do
local nNewEnt = EgtCopyGlob( vEntIds[i], nPrev, EgtIf( i == 1 or nOrder == PRINT_ORDER.EXT_INT_INF, GDB_IN.AFTER, GDB_IN.BEFORE))
-- correggo posizione
EgtMove( nNewEnt, dCorrZ * Z_AX(), GDB_RT.GLOB)
EgtMove( nNewEnt, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
EgtModifyCurveExtrusion( nNewEnt, LayerParams.vtSlicing, GDB_RT.GLOB)
EgtSetInfo( nNewEnt, KEY_TYPE, TYPE.AUX_SOLID)
if EgtCurveIsClosed( nNewEnt) then
EgtSetInfo( nNewEnt, KEY_CLOSED_CRV, 1)
-- eventuale inversione curva
if LayerParams.bInvert then
EgtInvertCurve( nNewEnt)
end
end
nPrev = nNewEnt
end
local vNewEntIds = EgtGetNameInGroup( nTpathGrpId, sName .. '*')
-- Aggiungo link
AddLink( vNewEntIds, nTpathGrpId, nLinkType, dLinkParam, dSPOffset, LayerParams.dStrand, LayerParams.vtSlicing)
-- Coasting e wipe
for i = 1, #vNewEntIds do
local nNextId = EgtGetNext( vNewEntIds[i]) or GDB_ID.NULL
local nType = EgtGetInfo( nNextId, KEY_TYPE, 'i')
if nType ~= TYPE.LINK then
AddRetraction( vNewEntIds[i], LayerParams, dCoastingLen, dWipeLen, dWipeDir)
end
end
end
end
sPrevName = sName
nSolidId = EgtGetNextName( nSolidId, AUX_SOLIDS_CRV .. '*')
end
end
---------------------------------------------------------------------
function CalcToolPath.Exec( nPartId)
@@ -718,6 +811,8 @@ function CalcToolPath.Exec( nPartId)
-- Ciclo sui layer
for nIdx = 1, #vLayIds do
-- recupero eventuale gruppo di solidi ausiliari
nAuxSolidsGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], AUX_SOLIDS_GRP)
-- scorro tutti i gruppi di contorni
local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*")
while nCrvGrpId do
@@ -748,23 +843,27 @@ function CalcToolPath.Exec( nPartId)
EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
-- eventuale inversione
local nType = EgtGetInfo( nNewEntId, KEY_TYPE, 'i')
if nType ~= TYPE.EXTRA_SHELL and LayerParams.bInvert then
EgtInvertCurve( nNewEntId)
if LayerParams.bInvert then
if nType == TYPE.OUTER_SHELL or nType == TYPE.INNER_SHELL or ( nType == TYPE.INFILL and EgtCurveIsClosed( nNewEntId)) then
EgtInvertCurve( nNewEntId)
EgtSetInfo( nNewEntId, KEY_INVERTED_CRV, 1)
end
end
if EgtCurveIsClosed( nNewEntId) then
EgtSetInfo( nNewEntId, KEY_CLOSED_CRV, 1)
end
EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB)
EgtSetColor( nNewEntId, EgtStdColor('GRAY'))
nEntId = EgtGetNext( nEntId)
end
-- aggiungo gli opportuni raccordi sulle shell complete
local vIds = EgtGetNameInGroup( nTpathGrpId, SHELL_CRV .. '*')
local vIdsExtra = EgtGetNameInGroup( nTpathGrpId, EXTRA_SHELL_CRV .. '*') or {}
for i = 1, #vIdsExtra do
table.insert( vIds, vIdsExtra[i])
end
local vIds = EgtGetAllInGroup( nTpathGrpId)
AddLink( vIds, nTpathGrpId, LayerParams.nLinkType, LayerParams.dLinkParam, LayerParams.dSPOffs, LayerParams.dStrand, LayerParams.vtSlicing)
-- aggiungo gli opportuni raccondi sulle shell con numero diverso di passate
-- aggiungo gli opportuni raccordi sulle shell con numero diverso di passate
local nPrev = EgtGetFirstNameInGroup( nTpathGrpId, EXTRA_SHELL_CRV .. '*')
local sPrevName = EgtGetName( nPrev or GDB_ID.NULL)
local nCurr = EgtGetNextName( nPrev or GDB_ID.NULL, EXTRA_SHELL_CRV .. '*')
@@ -795,27 +894,40 @@ function CalcToolPath.Exec( nPartId)
end
-- aggiungo coasting/wipe
local nId = EgtGetFirstNameInGroup( nTpathGrpId, SHELL_CRV .. "*")
local nId = EgtGetFirstInGroup( nTpathGrpId)
if EgtGetName( nId or GDB_ID.NULL) == LEAD_IN_CRV then nId = EgtGetNext( nId) end
local nFirstId = nId
local nLastId = EgtGetLastNameInGroup( nTpathGrpId, EXTRA_SHELL_CRV .. "*") or EgtGetLastNameInGroup( nTpathGrpId, SHELL_CRV .. "*")
local nLastId = EgtGetLastInGroup( nTpathGrpId)
if EgtGetName( nLastId or GDB_ID.NULL) == LEAD_OUT_CRV then nLastId = EgtGetPrev( nLastId) end
while nId do
-- recupero i parametri
local nType = EgtGetInfo( nId, KEY_TYPE, 'i')
local bClosed = EgtGetInfo( nId, KEY_CLOSED_CRV, 'b') or false
local dCoastingLen = EgtIf( nType == TYPE.EXTRA_SHELL and not bClosed, LayerParams.dShellNbrCoasting, LayerParams.dCoastingLen)
local dWipeLen = EgtIf( nType == TYPE.EXTRA_SHELL and not bClosed, LayerParams.dShellNbrWipe, LayerParams.dWipeLen)
local dWipeDir = EgtIf( nType == TYPE.EXTRA_SHELL and not bClosed, LayerParams.dShellNbrWipeDir, 0)
if nId == nLastId then
AddRetractionOnLastCrv( nId, nTpathGrpId, LayerParams)
AddRetractionOnLastCrv( nId, nTpathGrpId, LayerParams, dCoastingLen, dWipeLen, dWipeDir)
else
local nNextId = EgtGetNext( nId)
if EgtGetInfo( nNextId, KEY_TYPE, 'i') ~= TYPE.LINK then
-- aggiungo retrazione
if nId == nFirstId then
local dWipeLen = EgtIf( LayerParams.nLeadInType == LEAD_TYPE.NONE, LayerParams.dWipeLen, 0)
AddRetraction( nId, LayerParams, LayerParams.dCoastingLen, dWipeLen)
AddRetraction( nId, LayerParams, dCoastingLen, EgtIf( LayerParams.nLeadInType == LEAD_TYPE.NONE, dWipeLen, 0), dWipeDir)
else
AddRetraction( nId, LayerParams, LayerParams.dCoastingLen, LayerParams.dWipeLen)
AddRetraction( nId, LayerParams, dCoastingLen, dWipeLen, dWipeDir)
end
end
end
nId = EgtGetNextName( nId, SHELL_CRV .. "*") or EgtGetNextName( nId, EXTRA_SHELL_CRV .. "*")
nId = EgtGetNextName( nId, SHELL_CRV .. "*") or EgtGetNextName( nId, EXTRA_SHELL_CRV .. "*") or EgtGetNextName( nId, INFILL_CRV .. '')
end
-- sistemo i solid ausiliari
local nAuxSolidsPathGrp = EgtGetFirstNameInGroup( nCrvGrpId, AUX_SOLIDS_GRP)
if nAuxSolidsGrp then
CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGrpId, LayerParams, dCorrZ)
end
-- sistemo le costolature
local nRibsGrp = EgtGetFirstNameInGroup( nCrvGrpId, RIBS_GRP)
if nRibsGrp then
@@ -825,6 +937,11 @@ function CalcToolPath.Exec( nPartId)
--passo al gruppo di contorni successivo
nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*")
end
if EgtProcessEvents( EgtIf( PRINT, 200, 0) + nIdx / #vLayIds * 100, 0) == 1 then
EgtDraw()
return
end
end
end