SaraP
321 lines
12 KiB
Lua
321 lines
12 KiB
Lua
-- CalcPaths.lua by Egaltech s.r.l. 2022/04/13
|
|
-- Calcolo percorsi di lavoro per Stampa 3d
|
|
|
|
-- Tabella per definizione modulo
|
|
local CalcPaths = {}
|
|
|
|
-- Intestazioni
|
|
require( 'EgtBase')
|
|
|
|
EgtOutLog( ' CalcPaths started', 1)
|
|
|
|
-- Dati
|
|
local AMD = require( 'AddManData')
|
|
|
|
---------------------------------------------------------------------
|
|
local function GetLayerParamsForPathCalc()
|
|
local nParamsGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, PARAMS_GRP)
|
|
local LayerParams = {}
|
|
LayerParams.nShellsNbr = EgtGetInfo( nParamsGrp, KEY_SHELLS_NBR, 'i')
|
|
LayerParams.dStrand = EgtGetInfo( nParamsGrp, KEY_STRAND, 'd')
|
|
LayerParams.dOffs = EgtGetInfo( nParamsGrp, KEY_OFFSET_SLICE, 'd')
|
|
LayerParams.nFloorNbr = EgtGetInfo( nParamsGrp, KEY_FLOOR_NBR, 'i')
|
|
LayerParams.vtSlicing = EgtGetInfo( nParamsGrp, KEY_SLICING_DIR, 'v')
|
|
-- parametri setti
|
|
LayerParams.dSettiOverlap = EgtGetInfo( nParamsGrp, KEY_SETTI_OVERLAP, 'd')
|
|
LayerParams.nSettiShellsNbr = EgtGetInfo( nParamsGrp, KEY_SETTI_SHELLS_NBR, 'i')
|
|
return LayerParams
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function GetLayerStartPoint( nLayId)
|
|
|
|
local ptStart
|
|
-- recupero il punto di partenza usato nel layer precedente
|
|
local nPrev = EgtGetPrev( nLayId)
|
|
local nCrvGrp = EgtGetFirstNameInGroup( nPrev, CONTOUR_GRP..'*')
|
|
local nPathGrp = EgtGetFirstNameInGroup( nCrvGrp, PATH_GRP)
|
|
local nCrv = EgtGetFirstInGroup( nPathGrp)
|
|
if nCrv then
|
|
ptStart = EgtSP( nCrv, GDB_ID.ROOT)
|
|
else
|
|
local nParamsGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, PARAMS_GRP)
|
|
ptStart = EgtGetInfo( nParamsGrp, KEY_START_POINT, 'p')
|
|
end
|
|
return ptStart
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function GetPathsFromSurf( nSrfId, sName, nType, nGrpId, nLayId)
|
|
|
|
local nChunks = EgtSurfFrChunkCount( nSrfId)
|
|
for nC = 0, nChunks - 1 do
|
|
-- estraggo i contorni
|
|
local nCrvId, nCrvCnt = EgtExtractSurfFrChunkLoops( nSrfId, nC, nGrpId)
|
|
for nInd = 0, nCrvCnt - 1 do
|
|
EgtSetName( nCrvId + nInd, sName)
|
|
EgtSetInfo( nCrvId + nInd, KEY_TYPE, nType)
|
|
|
|
-- se è loop interno lo inverto per averlo orientato in senso antiorario
|
|
if nInd > 0 then
|
|
EgtInvertCurve( nCrvId + nInd)
|
|
end
|
|
|
|
-- verifico soddisfi i requisiti (lunghezza e area)
|
|
local dLen = EgtCurveLength( nCrvId + nInd)
|
|
local _ , _ , dArea = EgtCurveArea( nCrvId + nInd)
|
|
if dLen < MIN_LEN or dArea < MIN_AREA then
|
|
EgtErase( nCrvId + nInd)
|
|
return
|
|
end
|
|
|
|
-- scelta start point
|
|
local ptStart = GetLayerStartPoint( nLayId)
|
|
EgtChangeClosedCurveStartPoint( nCrvId + nInd, ptStart, GDB_RT.GLOB)
|
|
end
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------
|
|
local function AddFloor( nSrfId, nGrpId, LayerParams, nFloorNbr)
|
|
|
|
-- 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
|
|
|
|
|
|
end
|
|
|
|
--------------------------------------------------------------------
|
|
local function MySortSetti( a, b)
|
|
|
|
if abs( a.pt:getX() - b.pt:getX()) < GEO.EPS_SMALL then
|
|
-- confronto le y
|
|
if abs( a.pt:getY() - b.pt:getY()) < GEO.EPS_SMALL then
|
|
return false
|
|
elseif a.pt:getY() < b.pt:getY() + GEO.EPS_SMALL then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
elseif a.pt:getX() < b.pt:getX() + GEO.EPS_SMALL then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------
|
|
local function ReorderSetti( nGrp, vtSlicing, nStmId)
|
|
|
|
-- box del pezzo
|
|
local frLoc = Frame3d( ORIG(), vtSlicing)
|
|
local b3Box = EgtGetBBoxRef( nStmId, GDB_BB.STANDARD, frLoc)
|
|
local ptMin = b3Box:getMin()
|
|
ptMin:toGlob( frLoc)
|
|
local vtDiag = b3Box:getMax() - b3Box:getMin()
|
|
|
|
local tab = {}
|
|
local vIds = EgtGetAllInGroup( nGrp)
|
|
for i = 1, #vIds do
|
|
EgtExtendCurveStartByLen( vIds[i], 500)
|
|
EgtExtendCurveEndByLen( vIds[i], 500)
|
|
-- trim con il box del pezzo
|
|
local nNewId, nCnt = EgtTrimFlatCurveWithBox( vIds[i], Frame3d( ptMin, vtSlicing), vtDiag, true, true, GDB_RT.GLOB)
|
|
if nCnt > 0 then
|
|
table.insert( tab, { Id = nNewId, pt = EgtSP( nNewId)})
|
|
end
|
|
end
|
|
|
|
table.sort( tab, MySortSetti)
|
|
return tab
|
|
end
|
|
|
|
--------------------------------------------------------------------
|
|
local function CalcSettiPaths( nSliceGrp, nSettiGrp, LayerParams, nStmId)
|
|
|
|
-- calcolo gli offset
|
|
local dOffs = ( LayerParams.nSettiShellsNbr - 1) * LayerParams.dStrand / 2
|
|
local nOffsGrp = EgtGroup( nSettiGrp)
|
|
local vCrvIds = EgtGetNameInGroup( nSettiGrp, SETTI_CRV .. '*')
|
|
for i = 1, #vCrvIds do
|
|
for k = 0, LayerParams.nSettiShellsNbr - 1 do
|
|
local nNewId = EgtOffsetCurveAdv( vCrvIds[i], - dOffs + k * LayerParams.dStrand)
|
|
EgtSetName( nNewId, EgtGetName( vCrvIds[i]))
|
|
EgtSetInfo( nNewId, KEY_TYPE, TYPE.SETTO)
|
|
EgtRelocateGlob( nNewId, nOffsGrp)
|
|
end
|
|
end
|
|
|
|
-- calcolo l'ordine di realizzazione dei setti
|
|
local OrderedSetti = ReorderSetti( nOffsGrp, LayerParams.vtSlicing, nStmId)
|
|
-- scorro i gruppi di curve
|
|
local nCrvGrp = EgtGetFirstNameInGroup( nSliceGrp, CONTOUR_GRP .. '*')
|
|
while nCrvGrp do
|
|
local nSettiPathGrp = EgtGetFirstNameInGroup( nCrvGrp, SETTI_GRP)
|
|
local nSrf = EgtGetFirstNameInGroup( nSettiPathGrp, LAYER_SRF)
|
|
if nSrf then
|
|
for i = 1, #OrderedSetti do
|
|
local nNewId = EgtCopyGlob( OrderedSetti[i].Id, nSettiPathGrp)
|
|
-- trim dei setti con la regione offsettata
|
|
local nCrv, nCnt = EgtTrimCurveWithRegion( nNewId, nSrf, true, false)
|
|
-- elimino tratti troppo corti
|
|
for nId = nCrv, nCrv + nCnt - 1 do
|
|
local dLen = EgtCurveLength( nId)
|
|
if dLen < MIN_LEN then
|
|
EgtErase( nId)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if not EgtGetFirstNameInGroup( nSettiPathGrp, SETTI_CRV .. '*') then
|
|
EgtErase( nSettiPathGrp)
|
|
end
|
|
nCrvGrp = EgtGetNextName( nCrvGrp, CONTOUR_GRP .. '*')
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function CalcPaths.Exec( nPartId, nStmId)
|
|
|
|
local vLayIds = EgtGetNameInGroup( nPartId, SLICE_LAYER.."*")
|
|
if not vLayIds then
|
|
EgtOutBox( 'Error no slice', 'PathCalc')
|
|
return
|
|
end
|
|
|
|
-- recupero i parametri per calcolo dei path
|
|
local LayerParams = GetLayerParamsForPathCalc()
|
|
-- scorro tutti i suoi layer
|
|
for nIdx = 1, #vLayIds do
|
|
|
|
local nSettiGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], SETTI_GRP)
|
|
|
|
-- scorro tutti i gruppi di contorni
|
|
local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[nIdx], CONTOUR_GRP.."*") or GDB_ID.NULL
|
|
while nCrvGrpId ~= GDB_ID.NULL do
|
|
|
|
-- verifico se il path e il solido sono già stati calcolati
|
|
local nGrpId = EgtGetFirstNameInGroup( nCrvGrpId, PATH_GRP) or GDB_ID.NULL
|
|
if nGrpId == GDB_ID.NULL then
|
|
nGrpId = EgtGroup( nCrvGrpId)
|
|
EgtSetName( nGrpId, PATH_GRP)
|
|
else
|
|
EgtEmptyGroup( nGrpId)
|
|
EgtSetStatus( nGrpId, GDB_ST.ON)
|
|
end
|
|
local nSolidGrpId = EgtGetFirstNameInGroup( nCrvGrpId, SOLID_GRP) or GDB_ID.NULL
|
|
if nSolidGrpId ~= GDB_ID.NULL then
|
|
EgtErase( nSolidGrpId)
|
|
end
|
|
|
|
-- recupero la superficie ottenuta dallo slicing
|
|
local nSrf = EgtGetFirstNameInGroup( nCrvGrpId, LAYER_SRF)
|
|
if nSrf then
|
|
-- esterno
|
|
local nSrfId = EgtCopyGlob( nSrf, nCrvGrpId)
|
|
local dOffs = 0.5 * LayerParams.dStrand - LayerParams.dOffs
|
|
local bOk = ( EgtSurfFrOffset( nSrfId, -dOffs) and EgtSurfFrChunkCount( nSrfId) > 0)
|
|
if not bOk then
|
|
EgtErase( nSrfId)
|
|
nSrfId = EgtCopyGlob( nSrf, nCrvGrpId)
|
|
bOk = ( EgtSurfFrOffset( nSrfId, -dOffs + 0.05) and EgtSurfFrChunkCount( nSrfId) > 0)
|
|
end
|
|
-- se offset riuscito, estraggo i contorni (pareti esterne)
|
|
if bOk then
|
|
GetPathsFromSurf( nSrfId, SHELL_CRV..'0', TYPE.OUTER_SHELL, nGrpId, vLayIds[nIdx])
|
|
else
|
|
EgtOutLog( 'Error on ExtOffset (layer '..tostring( nIdx)..') - CalcPaths')
|
|
end
|
|
EgtErase( nSrfId)
|
|
|
|
-- calcolo 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) and EgtSurfFrChunkCount( nSrfId) > 0)
|
|
if not bOk then
|
|
EgtErase( nSrfId)
|
|
nSrfId = EgtCopyGlob( nSrf, nCrvGrpId)
|
|
bOk = ( EgtSurfFrOffset( nSrfId, -dOffs + 0.05 - nInd2 * LayerParams.dStrand) and EgtSurfFrChunkCount( nSrfId) > 0)
|
|
end
|
|
-- se offset riuscito, estraggo i contorni ( pareti interne)
|
|
if bOk then
|
|
GetPathsFromSurf( nSrfId, SHELL_CRV..tostring( nInd2), TYPE.INNER_SHELL, nGrpId, vLayIds[nIdx])
|
|
else
|
|
EgtOutLog( 'Error on IntOffset (layer '..tostring( nIdx)..') - CalcPaths')
|
|
end
|
|
EgtErase( nSrfId)
|
|
end
|
|
|
|
-- setti
|
|
if nSettiGrp then
|
|
|
|
-- creo o svuoto il gruppo per i setti
|
|
local nSettiPathGrp = EgtGetFirstNameInGroup( nCrvGrpId, SETTI_GRP)
|
|
if not nSettiPathGrp then
|
|
nSettiPathGrp = EgtGroup( nCrvGrpId)
|
|
EgtSetName( nSettiPathGrp, SETTI_GRP)
|
|
EgtSetStatus( nSettiPathGrp, GDB_ST.OFF)
|
|
else
|
|
EgtEmptyGroup( nSettiPathGrp)
|
|
end
|
|
|
|
-- calcolo superficie di offset da usare per i setti
|
|
local nSrfId = EgtCopy( nSrf, nSettiPathGrp)
|
|
local dOffs = 0.5 * LayerParams.dStrand - LayerParams.dOffs + ( LayerParams.nShellsNbr - 1) * LayerParams.dStrand + ( 1 - LayerParams.dSettiOverlap / 100) * LayerParams.dStrand
|
|
local bOk = ( EgtSurfFrOffset( nSrfId, - dOffs) and EgtSurfFrChunkCount( nSrfId) > 0)
|
|
if not bOk then
|
|
EgtErase( nSrfId)
|
|
nSrfId = EgtCopyGlob( nSrf, nSettiPathGrp)
|
|
bOk = ( EgtSurfFrOffset( nSrfId, - dOffs + 0.05) and EgtSurfFrChunkCount( nSrfId) > 0)
|
|
end
|
|
-- se non ho una superficie errore ed elimino il gruppo dei setti
|
|
if not bOk then
|
|
EgtErase( nSettiPathGrp)
|
|
EgtOutLog( 'Error on Offset (Setti) (layer '..tostring( nIdx)..') - CalcPaths')
|
|
end
|
|
|
|
end
|
|
|
|
-- gestione eventuale floor
|
|
if nIdx <= LayerParams.nFloorNbr then
|
|
AddFloor( nSrf, nGrpId, LayerParams, nIdx)
|
|
end
|
|
end
|
|
|
|
-- passo al gruppo di contorni successivo
|
|
nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*") or GDB_ID.NULL
|
|
end
|
|
|
|
-- sistemo eventuali setti
|
|
if nSettiGrp then
|
|
CalcSettiPaths( vLayIds[nIdx], nSettiGrp, LayerParams, nStmId)
|
|
end
|
|
|
|
if EgtProcessEvents( nIdx / #vLayIds * 100, 0) == 1 then
|
|
EgtDraw()
|
|
return
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
---------------------------------------------------------------------
|
|
return CalcPaths
|