SaraP
737 lines
30 KiB
Lua
737 lines
30 KiB
Lua
-- CalcToolPath.lua by Egaltech s.r.l. 2022/04/19
|
|
-- Calcolo percorsi di lavoro per Stampa 3d
|
|
|
|
-- Tabella per definizione modulo
|
|
local CalcToolPath = {}
|
|
|
|
-- Intestazioni
|
|
require( 'EgtBase')
|
|
|
|
EgtOutLog( ' CalcToolPath started', 1)
|
|
|
|
-- Dati
|
|
local AMD = require( 'AddManData')
|
|
|
|
---------------------------------------------------------------------
|
|
local s_nPartId
|
|
|
|
---------------------------------------------------------------------
|
|
local function GetLayerParamsForToolPathCalc()
|
|
local LayerParams = {}
|
|
LayerParams.dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd')
|
|
LayerParams.dLayHeight = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd')
|
|
LayerParams.dOffs = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd')
|
|
LayerParams.bInvert = ( EgtGetInfo( s_nPartId, KEY_PRINT_DIRECTION, 'i') == PRINT_DIRECTION.CW)
|
|
LayerParams.nOrder = EgtGetInfo( s_nPartId, KEY_PRINT_ORDER, 'i')
|
|
LayerParams.nLinkType = EgtGetInfo( s_nPartId, KEY_LINK_TYPE, 'i')
|
|
LayerParams.dLinkParam = EgtGetInfo( s_nPartId, KEY_LINK_PARAM, 'd')
|
|
LayerParams.nLeadInType = EgtGetInfo( s_nPartId, KEY_LEAD_IN_TYPE, 'i')
|
|
LayerParams.dLeadInTangDist = EgtGetInfo( s_nPartId, KEY_LEAD_IN_TANG_DIST, 'd')
|
|
LayerParams.dLeadInOrthoDist = EgtGetInfo( s_nPartId, KEY_LEAD_IN_ORTHO_DIST, 'd')
|
|
LayerParams.nLeadOutType = EgtGetInfo( s_nPartId, KEY_LEAD_OUT_TYPE, 'i')
|
|
LayerParams.dLeadOutTangDist = EgtGetInfo( s_nPartId, KEY_LEAD_OUT_TANG_DIST, 'd')
|
|
LayerParams.dLeadOutOrthoDist = EgtGetInfo( s_nPartId, KEY_LEAD_OUT_ORTHO_DIST, 'd')
|
|
LayerParams.dOffsetLP = EgtGetInfo( s_nPartId, KEY_OFFSET_LEAD_POINT, 'd')
|
|
LayerParams.dSPOffs = EgtGetInfo( s_nPartId, KEY_SP_OFFSET_ON_SLICE, 'd')
|
|
LayerParams.dCoastingLen = EgtGetInfo( s_nPartId, KEY_COASTING_LEN, 'd')
|
|
LayerParams.dWipeLen = EgtGetInfo( s_nPartId, KEY_WIPE_LEN, 'd')
|
|
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
|
|
|
|
--------------------------------------------------------------------
|
|
local function ComputeZCorrection( LayerParams)
|
|
-- direzione dell'estrusore
|
|
local vtN = LayerParams.vtSlicing
|
|
local dNxy = sqrt( vtN:getX() * vtN:getX() + vtN:getY() * vtN:getY())
|
|
local dNz = vtN:getZ()
|
|
-- correzione per l'offset
|
|
local dCorr1 = LayerParams.dOffs * dNxy
|
|
-- correzione per il diametro dell'ugello
|
|
local dCorr2 = ( LayerParams.dOffs - LayerParams.dStrand / 2 + LayerParams.dTDiam / 2) * dNxy - LayerParams.dLayHeight * dNz
|
|
-- massimo tra le due
|
|
return max( dCorr1, dCorr2)
|
|
end
|
|
|
|
--------------------------------------------------------------------
|
|
local function AddLeadIn( nCrvId, LayerParams, nGrpId)
|
|
|
|
local ptE = EgtSP( nCrvId)
|
|
local vtTang = EgtSV( nCrvId)
|
|
local vtOrtho = Vector3d( vtTang)
|
|
local dAng = 90
|
|
if ( LayerParams.bInvert and LayerParams.nOrder == PRINT_ORDER.INF_INT_EXT) or
|
|
( not LayerParams.bInvert and LayerParams.nOrder == PRINT_ORDER.EXT_INT_INF) then
|
|
dAng = - 90
|
|
end
|
|
|
|
vtOrtho:rotate( LayerParams.vtSlicing, dAng)
|
|
local ptS = ptE - LayerParams.dLeadInTangDist * vtTang + LayerParams.dLeadInOrthoDist * vtOrtho
|
|
|
|
local nLeadInCrv = GDB_ID.NULL
|
|
if LayerParams.nLeadInType == LEAD_TYPE.LINEAR then
|
|
nLeadInCrv = EgtCurveCompoFromPoints( nGrpId, {ptS, ptE})
|
|
elseif LayerParams.nLeadInType == LEAD_TYPE.ARC then
|
|
nLeadInCrv = EgtArc2PV( nGrpId, ptE, ptS, -vtTang)
|
|
EgtInvertCurve( nLeadInCrv)
|
|
end
|
|
EgtRelocate( nLeadInCrv, nGrpId, GDB_IN.FIRST_SON)
|
|
EgtModifyCurveExtrusion( nLeadInCrv, LayerParams.vtSlicing, GDB_RT.GLOB)
|
|
EgtSetInfo( nLeadInCrv, KEY_TYPE, TYPE.LINK)
|
|
EgtSetName( nLeadInCrv, LEAD_IN_CRV)
|
|
end
|
|
|
|
--------------------------------------------------------------------
|
|
local function AddLeadOut( nCrvId, LayerParams, nGrpId)
|
|
|
|
local ptS = EgtEP( nCrvId)
|
|
local vtTang = EgtEV( nCrvId)
|
|
local vtOrtho = Vector3d( vtTang)
|
|
local dAng = - 90
|
|
if ( LayerParams.bInvert and LayerParams.nOrder == PRINT_ORDER.INF_INT_EXT) or
|
|
( not LayerParams.bInvert and LayerParams.nOrder == PRINT_ORDER.EXT_INT_INF) then
|
|
dAng = 90
|
|
end
|
|
|
|
vtOrtho:rotate( LayerParams.vtSlicing, dAng)
|
|
local ptE = ptS + LayerParams.dLeadOutTangDist * vtTang + LayerParams.dLeadOutOrthoDist * vtOrtho
|
|
|
|
local nLeadOutCrv = GDB_ID.NULL
|
|
if LayerParams.nLeadOutType == LEAD_TYPE.LINEAR then
|
|
nLeadOutCrv = EgtCurveCompoFromPoints( nGrpId, {ptS, ptE})
|
|
elseif LayerParams.nLeadOutType == LEAD_TYPE.ARC then
|
|
nLeadOutCrv = EgtArc2PV( nGrpId, ptS, ptE, vtTang)
|
|
end
|
|
EgtRelocate( nLeadOutCrv, nGrpId, GDB_IN.LAST_SON)
|
|
EgtModifyCurveExtrusion( nLeadOutCrv, LayerParams.vtSlicing, GDB_RT.GLOB)
|
|
EgtSetInfo( nLeadOutCrv, KEY_TYPE, TYPE.LINK)
|
|
EgtSetName( nLeadOutCrv, LEAD_OUT_CRV)
|
|
end
|
|
|
|
--------------------------------------------------------------------
|
|
local function AddRetraction( nCrvId, dCoastingLen, dWipeLen)
|
|
|
|
local nCoastingId
|
|
if dCoastingLen > GEO.EPS_SMALL then
|
|
nCoastingId = EgtCopyGlob( nCrvId, nCrvId, GDB_IN.AFTER)
|
|
local dPar = EgtCurveParamAtLength( nCoastingId, EgtCurveLength( nCoastingId) - dCoastingLen)
|
|
if not dPar then
|
|
EgtErase( nCoastingId)
|
|
return
|
|
end
|
|
EgtTrimCurveStartAtParam( nCoastingId, dPar)
|
|
-- aggiorno la curva originale
|
|
if dPar > GEO.EPS_SMALL then
|
|
EgtTrimCurveEndAtParam( nCrvId, dPar)
|
|
else
|
|
EgtErase( nCrvId)
|
|
end
|
|
EgtSetName( nCoastingId, COASTING_CRV)
|
|
EgtSetInfo( nCoastingId, KEY_TYPE, TYPE.COASTING)
|
|
EgtSetColor( nCoastingId, EgtStdColor('ORANGE'))
|
|
end
|
|
|
|
if dWipeLen > GEO.EPS_SMALL then
|
|
local nWipeId = EgtCopyGlob( nCrvId, EgtIf( nCoastingId, nCoastingId, nCrvId), GDB_IN.AFTER)
|
|
EgtTrimCurveEndAtLen( nWipeId, dWipeLen)
|
|
EgtSetName( nWipeId, WIPE_CRV)
|
|
EgtSetInfo( nWipeId, KEY_TYPE, TYPE.WIPE)
|
|
EgtSetColor( nWipeId, EgtStdColor('TEAL'))
|
|
end
|
|
|
|
return nCoastingId
|
|
end
|
|
|
|
--------------------------------------------------------------------
|
|
local function AddRetractionOnLastCrv( nTpathGrpId, LayerParams)
|
|
|
|
local nCrvId = EgtGetLastNameInGroup( nTpathGrpId, SHELL_CRV .. "*")
|
|
if LayerParams.nLeadOutType == LEAD_TYPE.NONE then
|
|
AddRetraction( nCrvId, LayerParams.dCoastingLen, LayerParams.dWipeLen)
|
|
else
|
|
local nLeadOutId = EgtGetLastInGroup( nTpathGrpId)
|
|
local dLen = EgtCurveLength( nLeadOutId)
|
|
if dLen > LayerParams.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, dNewCoastingLen, 0.0)
|
|
else
|
|
-- coinvolge parte dell'ultima shell crv
|
|
local dNewCoastingLen = LayerParams.dCoastingLen - dLen
|
|
local nCoastingId = AddRetraction( nCrvId, dNewCoastingLen, 0.0)
|
|
EgtAddCurveCompoCurve( nCoastingId, nLeadOutId)
|
|
end
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------
|
|
local function VerifyRibsLink( nLinkId, nCurr, nNext)
|
|
|
|
-- verifico se il link interseca una delle altre costolature
|
|
local nGrp = EgtGetParent( nCurr)
|
|
local vRibsIds = EgtGetNameInGroup( nGrp, RIBS_CRV .. '*')
|
|
for i = 1, #vRibsIds do
|
|
if vRibsIds[i] ~= nCurr and vRibsIds[i] ~= nNext then
|
|
local ptInt = EgtIP( nLinkId, vRibsIds[i], ORIG())
|
|
if ptInt then return false end
|
|
end
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
--------------------------------------------------------------------
|
|
local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink)
|
|
|
|
local ptS = EgtEP( nCurr)
|
|
local ptE = EgtSP( nNext)
|
|
|
|
local nCrvId = EgtGetFirstInGroup( nLoopGrp)
|
|
-- recupero la curva di offset su cui calcolare link
|
|
while nCrvId do
|
|
local dParS = EgtCurveParamAtPoint( nCrvId, ptS)
|
|
local dParE = EgtCurveParamAtPoint( nCrvId, ptE)
|
|
if dParS and dParE then
|
|
local bInvert = false
|
|
local bClosed = EgtCurveIsClosed( nCrvId)
|
|
if bClosed then
|
|
-- se la curva è chiusa verifico i due percorsi possibili dParS->dParE e dParE->dParS
|
|
local nCopyId1 = EgtCopyGlob( nCrvId, nCurr, GDB_IN.AFTER)
|
|
local nCopyId2 = EgtCopyGlob( nCrvId, nCurr, GDB_IN.AFTER)
|
|
EgtTrimCurveStartEndAtParam( nCopyId1, dParS, dParE)
|
|
EgtTrimCurveStartEndAtParam( nCopyId2, dParE, dParS)
|
|
EgtInvertCurve( nCopyId2)
|
|
|
|
local dLen1 = EgtCurveLength( nCopyId1)
|
|
local dLen2 = EgtCurveLength( nCopyId2)
|
|
if dLen1 > dLen2 then
|
|
bInvert = true
|
|
dParS, dParE = dParE, dParS
|
|
end
|
|
EgtErase( nCopyId1)
|
|
EgtErase( nCopyId2)
|
|
end
|
|
|
|
local nCopyId = EgtCopyGlob( nCrvId, nLoopGrp)
|
|
local nLinkId = EgtCopyGlob( nCrvId, nCurr, GDB_IN.AFTER)
|
|
|
|
if dParS > dParE and not bInvert then
|
|
bInvert = true
|
|
dParS, dParE = dParE, dParS
|
|
end
|
|
|
|
EgtTrimCurveStartEndAtParam( nLinkId, dParS, dParE)
|
|
EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB)
|
|
if bInvert then EgtInvertCurve( nLinkId) end
|
|
-- verifico se è valido
|
|
local bValid = VerifyRibsLink( nLinkId, nCurr, nNext)
|
|
if not bValid then
|
|
EgtErase( nLinkId)
|
|
EgtErase( nCopyId)
|
|
return
|
|
end
|
|
|
|
if bClosed then
|
|
EgtTrimCurveStartEndAtParam( nCrvId, dParE, dParS)
|
|
EgtErase( nCopyId)
|
|
else
|
|
EgtTrimCurveEndAtParam( nCrvId, dParS)
|
|
EgtTrimCurveStartAtParam( nCopyId, dParE)
|
|
end
|
|
|
|
return nLinkId
|
|
end
|
|
|
|
nCrvId = EgtGetNext( nCrvId)
|
|
end
|
|
|
|
-- 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)
|
|
end
|
|
|
|
end
|
|
|
|
--------------------------------------------------------------------
|
|
local function AddRibsLeadIn( nCrv, nLoopsGrp, LayerParams)
|
|
|
|
if LayerParams.dRibsLILen < GEO.EPS_SMALL then return end
|
|
|
|
-- recupero la curva di offset su cui calcolare leadin
|
|
local ptS = EgtSP( nCrv)
|
|
local nCrvOffs = EgtGetFirstInGroup( nLoopsGrp)
|
|
while nCrvOffs do
|
|
local dParS = EgtCurveParamAtPoint( nCrvOffs, ptS)
|
|
if dParS then
|
|
local nCrvId = EgtCopyGlob( nCrvOffs, nCrv, GDB_IN.BEFORE)
|
|
local bClosed = EgtCurveIsClosed( nCrvId)
|
|
if bClosed then
|
|
EgtChangeClosedCurveStart( nCrvId, dParS)
|
|
dParS = 0
|
|
end
|
|
|
|
-- scelgo il lato da cui fare ingresso
|
|
local _, dEndPar = EgtCurveDomain( nCrvId)
|
|
-- se ho solo un tratto possibile verifico se va invertito
|
|
if abs( dParS - dEndPar) < GEO.EPS_SMALL then
|
|
EgtInvertCurve( nCrvId)
|
|
elseif abs( dParS) > GEO.EPS_SMALL or bClosed then
|
|
-- se ho più tratti possibili scelgo in base al parametro RibsLIInvert o alle dimensioni
|
|
local nNewId = EgtSplitCurveAtParam( nCrvId, dParS) or EgtCopyGlob( nCrvId, nCrv, GDB_IN.BEFORE)
|
|
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
|
|
bKeepFirst = true
|
|
elseif dLen1 < LayerParams.dRibsLILen - GEO.EPS_SMALL and dLen2 > LayerParams.dRibsLILen - GEO.EPS_SMALL then
|
|
bKeepFirst = false
|
|
end
|
|
|
|
if bKeepFirst then
|
|
EgtInvertCurve( nCrvId)
|
|
EgtErase( nNewId)
|
|
else
|
|
EgtErase( nCrvId)
|
|
nCrvId = nNewId
|
|
end
|
|
end
|
|
|
|
EgtTrimCurveEndAtLen( nCrvId, LayerParams.dRibsLILen)
|
|
EgtInvertCurve( nCrvId)
|
|
EgtSetInfo( nCrvId, KEY_TYPE, TYPE.RIB)
|
|
EgtSetName( nCrvId, LEAD_IN_CRV)
|
|
return
|
|
end
|
|
|
|
nCrvOffs = EgtGetNext( nCrvOffs)
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------
|
|
local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams)
|
|
|
|
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 ptE = EgtEP( nCrv)
|
|
-- recupero la curva di offset su cui calcolare lead out
|
|
local nCrvOffs = EgtGetFirstInGroup( nLoopsGrp)
|
|
while nCrvOffs do
|
|
local dParE = EgtCurveParamAtPoint( nCrvOffs, ptE)
|
|
if dParE then
|
|
|
|
local nCrvLO
|
|
local nCoasting
|
|
local nWipe
|
|
local bInvert = false
|
|
|
|
local nCrvRef = EgtCopyGlob( nCrvOffs, nCrv, GDB_IN.AFTER)
|
|
local bClosed = EgtCurveIsClosed( nCrvRef)
|
|
if bClosed then
|
|
EgtChangeClosedCurveStart( nCrvRef, dParE)
|
|
dParE = 0
|
|
end
|
|
|
|
-- scelgo il lato da cui fare uscita
|
|
local _, dEndPar = EgtCurveDomain( nCrvRef)
|
|
-- se ho solo un tratto possibile verifico se va invertito
|
|
if abs( dParE - dEndPar) < GEO.EPS_SMALL then
|
|
EgtInvertCurve( nCrvRef)
|
|
bInvert = true
|
|
elseif abs( dParE) > GEO.EPS_SMALL or bClosed then
|
|
-- se ho più tratti possibili scelgo in base al parametro RibsLOInvert o alle dimensioni
|
|
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 = true
|
|
elseif dLen1 < LayerParams.dRibsLOLen + LayerParams.dRibsLOCoasting - GEO.EPS_SMALL and dLen2 > LayerParams.dRibsLOLen + LayerParams.dRibsLOCoasting - GEO.EPS_SMALL then
|
|
bInvert = false
|
|
end
|
|
|
|
if bInvert then
|
|
EgtInvertCurve( nCrvRef)
|
|
EgtErase( nNewId)
|
|
else
|
|
EgtErase( nCrvRef)
|
|
nCrvRef = nNewId
|
|
end
|
|
end
|
|
|
|
-- verifico se la curva ha lunghezza sufficiente
|
|
local dLen = EgtCurveLength( nCrvRef)
|
|
local bSkip = ( dLen - LayerParams.dRibsLOLen - LayerParams.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
|
|
nCrvLO = EgtCopyGlob( nCrvRef, nCrv, GDB_IN.AFTER)
|
|
EgtTrimCurveEndAtLen( nCrvLO, LayerParams.dRibsLOLen)
|
|
EgtSetInfo( nCrvLO, KEY_TYPE, TYPE.RIB)
|
|
EgtSetName( nCrvLO, LEAD_OUT_CRV)
|
|
-- aggiorno ptE e vtE
|
|
ptE = EgtEP( nCrvLO)
|
|
vtE = EgtEV( nCrvLO)
|
|
end
|
|
|
|
-- secondo tratto ( segue offset con flusso chiuso)
|
|
if LayerParams.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)
|
|
|
|
EgtSetName( nCoasting, COASTING_CRV)
|
|
EgtSetInfo( nCoasting, KEY_TYPE, TYPE.COASTING)
|
|
EgtSetColor( nCoasting, EgtStdColor('ORANGE'))
|
|
|
|
-- aggiorno ptE e vtE
|
|
ptE = EgtEP( nCoasting)
|
|
vtE = EgtEV( nCoasting)
|
|
end
|
|
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
|
|
nWipe = EgtCurveCompoFromPoints( nTPathGrp, { ptE, ptFinal})
|
|
EgtRelocateGlob( nWipe, nCoasting or nCrvLO or nCrv, GDB_IN.AFTER)
|
|
EgtSetName( nWipe, WIPE_CRV)
|
|
EgtSetInfo( nWipe, KEY_TYPE, TYPE.WIPE)
|
|
EgtSetColor( nWipe, EgtStdColor('TEAL'))
|
|
end
|
|
|
|
return
|
|
end
|
|
|
|
nCrvOffs = EgtGetNext( nCrvOffs)
|
|
end
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function CalcRibsToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ)
|
|
|
|
local nRibsGrp = EgtGetFirstNameInGroup( nCrvGrp, RIBS_GRP)
|
|
-- aggiungo le costolature nel toolpath
|
|
local vEntIds = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*')
|
|
for i = 1, #vEntIds do
|
|
-- copio entità nel gruppo toolpath
|
|
local nNewEntId = EgtCopyGlob( vEntIds[i], nTpathGrpId, GDB_IN.LAST_SON)
|
|
-- correggo posizione in Z ( per essere sicuri di appoggiare sul piano)
|
|
EgtMove( nNewEntId, dCorrZ * Z_AX(), GDB_RT.GLOB)
|
|
-- mi sposto dell'altezza layer
|
|
EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
|
|
EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB)
|
|
EgtSetColor( nNewEntId, EgtStdColor('GRAY'))
|
|
end
|
|
|
|
-- estraggo i contorni della superficie 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)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- recupero i gruppi delle costolature
|
|
local tabRibs = {}
|
|
local nFirst = EgtGetFirstNameInGroup( nTpathGrpId, RIBS_CRV .. '*')
|
|
while nFirst do
|
|
local sName = EgtGetName( nFirst)
|
|
local vIds = EgtGetNameInGroup( nTpathGrpId, sName)
|
|
table.insert( tabRibs, vIds)
|
|
nFirst = EgtGetNextName( vIds[#vIds], RIBS_CRV .. '*')
|
|
end
|
|
|
|
local bInters = EgtGetInfo( nRibsGrp, KEY_RIBS_INTERS, 'b') or false
|
|
local bSpecialCase = bInters and LayerParams.nRibsShellsNbr == 2
|
|
local bSwap = false
|
|
-- orientamento delle curve
|
|
local bInvert = LayerParams.bRibsInvert
|
|
if not bSpecialCase then
|
|
for i = 1, #tabRibs do
|
|
local nInfo = EgtGetInfo( tabRibs[i][1], KEY_SPLIT_RIB, '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
|
|
end
|
|
end
|
|
|
|
if LayerParams.nRibsShellsNbr == 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)
|
|
end
|
|
|
|
-- oriento tutte le passate relative ad una stessa costolatura
|
|
for j = 1, #tabRibs[i] do
|
|
if ( bInvert and j % 2 == 1) or ( not bInvert and j % 2 == 0) then
|
|
EgtInvertCurve( tabRibs[i][j])
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Link
|
|
-- se modifiche nell'ordine ricalcolo i gruppi di costolature
|
|
if bSwap then
|
|
tabRibs = {}
|
|
nFirst = EgtGetFirstNameInGroup( nTpathGrpId, RIBS_CRV .. '*')
|
|
while nFirst do
|
|
local sName = EgtGetName( nFirst)
|
|
local vIds = EgtGetNameInGroup( nTpathGrpId, sName)
|
|
table.insert( tabRibs, vIds)
|
|
nFirst = EgtGetNextName( vIds[#vIds], RIBS_CRV .. '*')
|
|
end
|
|
end
|
|
|
|
-- collego le passate di una stessa costolatura
|
|
for i = 1, #tabRibs do
|
|
for j = 1, #tabRibs[i] - 1 do
|
|
CalcRibsLink( tabRibs[i][j], tabRibs[i][j + 1], nLoopGrp, true)
|
|
if not bSpecialCase then
|
|
-- creo link fittizio per eliminare tratto corrispondente sulla curva di offset
|
|
local nFakeLink = CalcRibsLink( tabRibs[i][j + 1], tabRibs[i][j], nLoopGrp, false)
|
|
EgtErase( nFakeLink)
|
|
end
|
|
end
|
|
if bSpecialCase then
|
|
local nFakeLink = CalcRibsLink( tabRibs[i][#tabRibs[i]], tabRibs[i][1], nLoopGrp, false)
|
|
EgtErase( nFakeLink)
|
|
end
|
|
end
|
|
-- se necessario collego le diverse costolature
|
|
if LayerParams.bRibsLink then
|
|
for i = 1, #tabRibs - 1 do
|
|
local nCnt = #tabRibs[i]
|
|
CalcRibsLink( tabRibs[i][nCnt], tabRibs[i + 1][1], nLoopGrp, false)
|
|
end
|
|
end
|
|
|
|
-- leadin/leadout
|
|
local nCrvRib = EgtGetFirstNameInGroup( nTpathGrpId, RIBS_CRV .. '*')
|
|
while nCrvRib do
|
|
-- verifico se necessario lead in
|
|
local nPrev = EgtGetPrev( nCrvRib)
|
|
if not nPrev or EgtGetName( nPrev) then
|
|
AddRibsLeadIn( nCrvRib, nLoopGrp, LayerParams)
|
|
end
|
|
-- verifico se necessario lead out
|
|
local nNext = EgtGetNext( nCrvRib)
|
|
if not nNext or EgtGetName( nNext) then
|
|
AddRibsLeadOut( nCrvRib, nTpathGrpId, nLoopGrp, LayerParams)
|
|
end
|
|
nCrvRib = EgtGetNextName( nCrvRib, RIBS_CRV .. '*')
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function CalcToolPath.Exec( nPartId)
|
|
|
|
s_nPartId = nPartId
|
|
|
|
-- Verifico il pezzo
|
|
if not s_nPartId then
|
|
EgtOutBox( 'Error missing part', 'ToolPathCalc')
|
|
return
|
|
end
|
|
|
|
-- Recupero i layer da processare
|
|
local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*")
|
|
if not vLayIds then
|
|
EgtOutBox( 'Error missing slices', 'ToolPathCalc')
|
|
return
|
|
end
|
|
|
|
-- recupero i parametri per calcolo dei toolpath
|
|
local LayerParams = GetLayerParamsForToolPathCalc()
|
|
local dCorrZ = ComputeZCorrection( LayerParams)
|
|
|
|
-- se necessario sposto anche il solido di partenza
|
|
if dCorrZ > 10 * GEO.EPS_SMALL then
|
|
local vtMove = Vector3d( 0, 0, dCorrZ) + LayerParams.dLayHeight / 2 * LayerParams.vtSlicing
|
|
local SolidLayId = EgtGetFirstNameInGroup( s_nPartId, ORIGINAL_SOLID)
|
|
if SolidLayId then
|
|
EgtSetInfo( s_nPartId, KEY_MOVED_PART, vtMove)
|
|
local EntId = EgtGetFirstInGroup( SolidLayId)
|
|
while EntId do
|
|
EgtMove( EntId, vtMove)
|
|
EntId = EgtGetNext( EntId)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Ciclo sui layer
|
|
for nIdx = 1, #vLayIds do
|
|
|
|
-- scorro tutti i gruppi di contorni
|
|
local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*")
|
|
while nCrvGrpId do
|
|
-- recupero il gruppo dei percorsi
|
|
local nPathGrpId = EgtGetFirstNameInGroup( nCrvGrpId, PATH_GRP)
|
|
if not nPathGrpId then
|
|
EgtOutBox( 'Error missing paths', 'ToolPathCalc')
|
|
return
|
|
else
|
|
EgtSetStatus( nPathGrpId, GDB_ST.OFF)
|
|
end
|
|
-- recupero il gruppo dei percorsi utensile
|
|
local nTpathGrpId = EgtGetFirstNameInGroup( nCrvGrpId, TOOLPATH_GRP)
|
|
if not nTpathGrpId then
|
|
nTpathGrpId = EgtGroup( nCrvGrpId)
|
|
EgtSetName( nTpathGrpId, TOOLPATH_GRP)
|
|
else
|
|
EgtEmptyGroup( nTpathGrpId)
|
|
end
|
|
-- creo il percorso di lavoro :
|
|
-- copio le curve, le ordino, le oriento e le muovo in Z
|
|
local nEntId = EgtGetFirstInGroup( nPathGrpId)
|
|
while nEntId do
|
|
local nNewEntId = EgtCopyGlob( nEntId, nTpathGrpId, EgtIf( LayerParams.nOrder == PRINT_ORDER.INF_INT_EXT, GDB_IN.FIRST_SON, GDB_IN.LAST_SON))
|
|
-- correggo posizione in Z ( per essere sicuri di appoggiare sul piano)
|
|
EgtMove( nNewEntId, dCorrZ * Z_AX(), GDB_RT.GLOB)
|
|
-- mi sposto dell'altezza layer
|
|
EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
|
|
if LayerParams.bInvert then
|
|
EgtInvertCurve( nNewEntId)
|
|
end
|
|
EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB)
|
|
EgtSetColor( nNewEntId, EgtStdColor('GRAY'))
|
|
nEntId = EgtGetNext( nEntId)
|
|
end
|
|
|
|
-- aggiungo gli opportuni raccordi
|
|
local nPrevId = EgtGetFirstInGroup( nTpathGrpId)
|
|
local nCurrId = EgtGetNext( nPrevId or GDB_ID.NULL)
|
|
k = 0
|
|
local nPrevShellNbr
|
|
if nPrevId then nPrevShellNbr = tonumber( EgtGetName( nPrevId):sub(6)) end
|
|
while nCurrId do
|
|
|
|
local nCurrShellNbr = tonumber( EgtGetName( nCurrId):sub(6))
|
|
if nCurrShellNbr ~= nPrevShellNbr then k = k + 1 end
|
|
|
|
-- se nessun raccordo modifico solo lo start point della curva
|
|
if LayerParams.nLinkType == LINK_TYPE.NONE then
|
|
local dLen = k * LayerParams.dSPOffs
|
|
if LayerParams.dSPOffs < 0 then
|
|
dLen = EgtCurveLength( nCurrId) + dLen
|
|
end
|
|
local dPar = EgtCurveParamAtLength( nCurrId, dLen)
|
|
if dPar then EgtChangeClosedCurveStart( nCurrId, dPar) end
|
|
|
|
else
|
|
-- altrimenti verifico se ha senso creare raccordo
|
|
if abs( dist( EgtEP( nPrevId), EgtSP( nCurrId))) < LayerParams.dStrand + 10 then
|
|
local nLinkId
|
|
if k > 1 then
|
|
-- modifico lo start point
|
|
local dLen = EgtCurveLength( nPrevId) - abs( LayerParams.dSPOffs)
|
|
EgtTrimCurveEndAtLen( nPrevId, dLen)
|
|
EgtChangeClosedCurveStartPoint( nCurrId, EgtEP( nPrevId))
|
|
end
|
|
-- aggiungo il raccordo
|
|
EgtTrimCurveEndAtLen( nPrevId, EgtCurveLength( nPrevId) - LayerParams.dLinkParam / 2)
|
|
EgtTrimCurveStartAtLen( nCurrId, LayerParams.dLinkParam / 2)
|
|
if LayerParams.nLinkType == LINK_TYPE.LINEAR then
|
|
nLinkId = EgtCurveCompoFromPoints( nTpathGrpId, {EgtEP( nPrevId), EgtSP( nCurrId)})
|
|
elseif LayerParams.nLinkType == LINK_TYPE.BIARC then
|
|
local frLoc = Frame3d( ORIG(), LayerParams.vtSlicing)
|
|
local nGrpTmp = EgtGroup( nTpathGrpId, frLoc)
|
|
local _, _, dAngIni = SphericalFromVector( EgtEV( nPrevId, nGrpTmp))
|
|
local _, _, dAngFin = SphericalFromVector( EgtSV( nCurrId, nGrpTmp))
|
|
nLinkId = EgtBiArc( nGrpTmp, EgtEP( nPrevId, nGrpTmp), EgtSP( nCurrId, nGrpTmp), dAngIni, dAngFin, 0.5)
|
|
EgtRelocateGlob( nLinkId, nTpathGrpId, GDB_IN.LAST_SON)
|
|
EgtErase( nGrpTmp)
|
|
end
|
|
|
|
if nLinkId then
|
|
EgtRelocate( nLinkId, nCurrId, GDB_IN.BEFORE)
|
|
EgtModifyCurveExtrusion( nLinkId, LayerParams.vtSlicing, GDB_RT.GLOB)
|
|
EgtSetInfo( nLinkId, KEY_TYPE, TYPE.LINK)
|
|
end
|
|
end
|
|
end
|
|
|
|
nPrevShellNbr = nCurrShellNbr
|
|
nPrevId = nCurrId
|
|
nCurrId = EgtGetNext( nCurrId)
|
|
end
|
|
|
|
-- aggiungo leadin/leadout
|
|
local nFirstCurve = EgtGetFirstInGroup( nTpathGrpId)
|
|
if nFirstCurve and LayerParams.nLeadInType ~= LEAD_TYPE.NONE then
|
|
EgtTrimCurveStartAtLen( nFirstCurve, LayerParams.dOffsetLP)
|
|
AddLeadIn( nFirstCurve, LayerParams, nTpathGrpId)
|
|
end
|
|
local nLastCurve = EgtGetLastInGroup( nTpathGrpId)
|
|
if nLastCurve and LayerParams.nLeadOutType ~= LEAD_TYPE.NONE then
|
|
EgtTrimCurveEndAtLen( nLastCurve, EgtCurveLength( nLastCurve) - LayerParams.dOffsetLP)
|
|
AddLeadOut( nLastCurve, LayerParams, nTpathGrpId)
|
|
end
|
|
|
|
-- aggiungo coasting/wipe
|
|
local nId = EgtGetFirstNameInGroup( nTpathGrpId, SHELL_CRV .. "*")
|
|
local nFirstId = nId
|
|
local nLastId = EgtGetLastNameInGroup( nTpathGrpId, SHELL_CRV .. "*")
|
|
while nId do
|
|
if nId == nLastId then
|
|
AddRetractionOnLastCrv( nTpathGrpId, LayerParams)
|
|
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.dCoastingLen, dWipeLen)
|
|
else
|
|
AddRetraction( nId, LayerParams.dCoastingLen, LayerParams.dWipeLen)
|
|
end
|
|
end
|
|
end
|
|
nId = EgtGetNextName( nId, SHELL_CRV .. "*")
|
|
end
|
|
|
|
-- sistemo le costolature
|
|
local nRibsGrp = EgtGetFirstNameInGroup( nCrvGrpId, RIBS_GRP)
|
|
if nRibsGrp then
|
|
CalcRibsToolPath( nCrvGrpId, nTpathGrpId, LayerParams, dCorrZ)
|
|
end
|
|
|
|
--passo al gruppo di contorni successivo
|
|
nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*")
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
return CalcToolPath
|