From fb9ecc811dc2d41a8ba9594d3e301654cdb3116d Mon Sep 17 00:00:00 2001 From: SaraP Date: Fri, 2 Dec 2022 11:36:09 +0100 Subject: [PATCH] 3dPrinting : - migliorata organizzazione calcolo toolpath. --- LuaLibs/AddManData.lua | 4 +- LuaLibs/CalcToolPath.lua | 424 +++++++++++++++++--------------- LuaLibs/RunSliceAdvancement.lua | 2 +- LuaLibs/RunSlicing.lua | 8 +- 4 files changed, 237 insertions(+), 201 deletions(-) diff --git a/LuaLibs/AddManData.lua b/LuaLibs/AddManData.lua index 6e3c77f..a5e8b35 100644 --- a/LuaLibs/AddManData.lua +++ b/LuaLibs/AddManData.lua @@ -162,8 +162,8 @@ TYPE = { } PRINT_ORDER = { - EXT_INT_INF = 1, - INF_INT_EXT = 2, + EXT_INT = 1, + INT_EXT = 2, } PRINT_DIRECTION = { diff --git a/LuaLibs/CalcToolPath.lua b/LuaLibs/CalcToolPath.lua index 29549e6..7e02323 100644 --- a/LuaLibs/CalcToolPath.lua +++ b/LuaLibs/CalcToolPath.lua @@ -61,6 +61,46 @@ local function ComputeZCorrection( LayerParams) return max( dCorr1, dCorr2) end +------------------------------------------------------------------- +local function AddCurvesToToolPath( vEntIds, nTpathGrpId, nOrder, bInvert, vtSlicing, dLayHeight, dCorrZ) + + local vIds = {} -- vettore con gli id ordinati delle curve nel gruppo dei ToolPath + + local nStart = EgtIf( nOrder == PRINT_ORDER.EXT_INT, 1, #vEntIds) + local nEnd = EgtIf( nOrder == PRINT_ORDER.EXT_INT, #vEntIds, 1) + local nStep = EgtIf( nOrder == PRINT_ORDER.EXT_INT, 1, -1) + local nIdx = 1 + for i = nStart, nEnd, nStep do + -- copio nel gruppo toolpath + if i == nStart then + vIds[nIdx] = EgtCopyGlob( vEntIds[i], nTpathGrpId, GDB_IN.LAST_SON) + else + vIds[nIdx] = EgtCopyGlob( vEntIds[i], vIds[nIdx-1], GDB_IN.AFTER) + end + + -- correggo posizione in Z ( per essere sicuri di appoggiare sul piano) + EgtMove( vIds[nIdx], dCorrZ * Z_AX(), GDB_RT.GLOB) + -- mi sposto dell'altezza layer + EgtMove( vIds[nIdx], dLayHeight * vtSlicing, GDB_RT.GLOB) + + if EgtCurveIsClosed( vIds[nIdx]) then + EgtSetInfo( vIds[nIdx], KEY_CLOSED_CRV, 1) + -- eventuale inversione + if bInvert then + EgtInvertCurve( vIds[nIdx]) + EgtSetInfo( vIds[nIdx], KEY_INVERTED_CRV, 1) + end + end + + EgtModifyCurveExtrusion( vIds[nIdx], vtSlicing, GDB_RT.GLOB) + EgtSetColor( vIds[nIdx], EgtStdColor('GRAY')) + EgtSetStatus( vIds[nIdx], GDB_ST.ON) + nIdx = nIdx + 1 + end + + return vIds +end + ------------------------------------------------------------------- local function AddLink( vCrv, nTpathGrpId, nLinkType, dLinkParam, dSPOffs, dStrand, vtSlicing) @@ -135,8 +175,8 @@ local function AddLeadIn( nCrvId, LayerParams, nGrpId) local vtTang = EgtSV( nCrvId, GDB_ID.ROOT) 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 + if ( LayerParams.bInvert and LayerParams.nOrder == PRINT_ORDER.INT_EXT) or + ( not LayerParams.bInvert and LayerParams.nOrder == PRINT_ORDER.EXT_INT) then dAng = - 90 end @@ -154,7 +194,7 @@ local function AddLeadIn( nCrvId, LayerParams, nGrpId) end if nLeadInCrv then - EgtRelocate( nLeadInCrv, nGrpId, GDB_IN.FIRST_SON) + EgtRelocate( nLeadInCrv, nCrvId, GDB_IN.BEFORE) EgtModifyCurveExtrusion( nLeadInCrv, LayerParams.vtSlicing, GDB_RT.GLOB) EgtSetInfo( nLeadInCrv, KEY_TYPE, TYPE.LINK) EgtSetName( nLeadInCrv, LEAD_IN_CRV) @@ -168,8 +208,8 @@ local function AddLeadOut( nCrvId, LayerParams, nGrpId) local vtTang = EgtEV( nCrvId, GDB_ID.ROOT) 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 + if ( LayerParams.bInvert and LayerParams.nOrder == PRINT_ORDER.INT_EXT) or + ( not LayerParams.bInvert and LayerParams.nOrder == PRINT_ORDER.EXT_INT) then dAng = 90 end @@ -184,7 +224,7 @@ local function AddLeadOut( nCrvId, LayerParams, nGrpId) end if nLeadOutCrv then - EgtRelocate( nLeadOutCrv, nGrpId, GDB_IN.LAST_SON) + EgtRelocate( nLeadOutCrv, nCrvId, GDB_IN.AFTER) EgtModifyCurveExtrusion( nLeadOutCrv, LayerParams.vtSlicing, GDB_RT.GLOB) EgtSetInfo( nLeadOutCrv, KEY_TYPE, TYPE.LINK) EgtSetName( nLeadOutCrv, LEAD_OUT_CRV) @@ -297,6 +337,161 @@ local function AddRetractionOnLastCrv( nCrvId, nTpathGrpId, LayerParams, dCoasti end end +--------------------------------------------------------------------- +local function CalcShellsToolPath( vEntIds, nTpathGrpId, LayerParams, dCorrZ) + + if not vEntIds then return end + -- aggiungo le curve nel toolpath + local vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, LayerParams.nOrder, LayerParams.bInvert, LayerParams.vtSlicing, LayerParams.dLayHeight, dCorrZ) + + -- aggiungo gli opportuni raccordi + AddLink( vIds, nTpathGrpId, LayerParams.nLinkType, LayerParams.dLinkParam, LayerParams.dSPOffs, LayerParams.dStrand, LayerParams.vtSlicing) + + -- aggiungo leadin/leadout + if LayerParams.nLeadInType ~= LEAD_TYPE.NONE then + EgtTrimCurveStartAtLen( vIds[1], LayerParams.dOffsetLP) + AddLeadIn( vIds[1], LayerParams, nTpathGrpId) + end + if LayerParams.nLeadOutType ~= LEAD_TYPE.NONE then + EgtTrimCurveEndAtLen( vIds[#vIds], EgtCurveLength( vIds[#vIds]) - LayerParams.dOffsetLP) + AddLeadOut( vIds[#vIds], LayerParams, nTpathGrpId) + end + + -- aggiungo coasting/wipe + for i = 1, #vIds - 1 do + local nNextId = EgtGetNext( vIds[i]) + if EgtGetInfo( nNextId, KEY_TYPE, 'i') ~= TYPE.LINK then + -- aggiungo retrazione + AddRetraction( vIds[i], LayerParams.vtSlicing, LayerParams.dCoastingLen, LayerParams.dWipeLen, LayerParams.dWipeDir) + end + end + -- sull'ultima curva gestione speciale per eventuale lead out + AddRetractionOnLastCrv( vIds[#vIds], nTpathGrpId, LayerParams, LayerParams.dCoastingLen, LayerParams.dWipeLen, LayerParams.dWipeDir) + +end + +--------------------------------------------------------------------- +local function CalcExtraShellToolPath( vEntIds, nTpathGrpId, LayerParams, dCorrZ) + + if not vEntIds then return end + -- aggiungo le curve nel toolpath + local vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, LayerParams.nOrder, false, LayerParams.vtSlicing, LayerParams.dLayHeight, dCorrZ) + + -- aggiungo gli opportuni raccordi + local sPrevName = EgtGetName( vIds[1]) + for i = 2, #vIds do + local sCurrName = EgtGetName( vIds[i]) + -- se hanno lo stesso nome vanno collegate + if sCurrName == sPrevName then + local ptS = EgtEP( vIds[i-1]) + local ptE = EgtSP( vIds[i]) + local nLinkId = EgtCurveCompoFromPoints( nTpathGrpId, {ptS, ptE}) + if nLinkId then + EgtRelocateGlob( nLinkId, vIds[i], GDB_IN.BEFORE) + EgtModifyCurveExtrusion( nLinkId, LayerParams.vtSlicing, GDB_RT.GLOB) + EgtSetInfo( nLinkId, KEY_TYPE, TYPE.LINK) + EgtSetName( nLinkId, LINK_CRV) + end + end + sPrevName = sCurrName + end + + -- aggiungo coasting/wipe + for i = 1, #vIds do + -- verifico non sia collegato al successivo tramite link + local nNextId = EgtGetNext( vIds[i]) + if not nNextId or EgtGetInfo( nNextId, KEY_TYPE, 'i') ~= TYPE.LINK then + -- recupero i parametri + local dCoastingLen, dWipeLen, dWipeDir + local bClosed = EgtGetInfo( vIds[i], KEY_CLOSED_CRV, 'b') or false + if not bClosed then + local bInverted = EgtGetInfo( vIds[i], KEY_INVERTED_CRV, 'b') or false + local vCoastLen = EgtGetInfo( vIds[i], KEY_EXTRA_SHELL_COASTING, 'vd') + local vWipeLen = EgtGetInfo( vIds[i], KEY_EXTRA_SHELL_WIPE, 'vd') + local vWipeDir = EgtGetInfo( vIds[i], KEY_EXTRA_SHELL_WIPE_DIR, 'vd') + -- se curva è stata invertita devo prendere le info legate a quello che era il suo punto di inizio, altrimenti prendo le info legate al punto finale + dCoastingLen = EgtIf( bInverted, vCoastLen[1], vCoastLen[2]) + dWipeLen = EgtIf( bInverted, vWipeLen[1], vWipeLen[2]) + dWipeDir = EgtIf( bInverted, vWipeDir[1], vWipeDir[2]) + else + -- se chiusa considero i parametri delle shell complete + dCoastingLen = LayerParams.dCoastingLen + dWipeLen = LayerParams.dWipeLen + dWipeDir = LayerParams.dWipeDir + end + + AddRetraction( vIds[i], LayerParams.vtSlicing, dCoastingLen, dWipeLen, dWipeDir) + end + end +end + +--------------------------------------------------------------------- +local function CalcInfillToolPath( vEntIds, nTpathGrpId, LayerParams, dCorrZ) + + if not vEntIds then return end + -- aggiungo le curve nel toolpath + local vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, LayerParams.nOrder, LayerParams.bInvert, LayerParams.vtSlicing, LayerParams.dLayHeight, dCorrZ) + + -- aggiungo eventuali link + AddLink( vIds, nTpathGrpId, LayerParams.nLinkType, LayerParams.dLinkParam, LayerParams.dSPOffs, LayerParams.dStrand, LayerParams.vtSlicing) + + -- aggiungo coasting/wipe + for i = 1, #vIds do + local nNextId = EgtGetNext( vIds[i]) + if not nNextId or EgtGetInfo( nNextId, KEY_TYPE, 'i') ~= TYPE.LINK then + AddRetraction( vIds[i], LayerParams.vtSlicing, LayerParams.dCoastingLen, LayerParams.dWipeLen, LayerParams.dWipeDir) + end + end +end + +--------------------------------------------------------------------- +local function CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGrpId, LayerParams, dCorrZ) + + if not nAuxSolidsGrp or not nAuxSolidsPathGrp then return end + + -- 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 vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, nOrder, LayerParams.bInvert, LayerParams.vtSlicing, LayerParams.dLayHeight, dCorrZ) + + -- aggiungo link + AddLink( vIds, nTpathGrpId, nLinkType, dLinkParam, dSPOffset, LayerParams.dStrand, LayerParams.vtSlicing) + + -- coasting e wipe + for i = 1, #vIds do + local nNextId = EgtGetNext( vIds[i]) + if not nNextId or EgtGetInfo( nNextId, KEY_TYPE, 'i') ~= TYPE.LINK then + AddRetraction( vIds[i], LayerParams.vtSlicing, dCoastingLen, dWipeLen, dWipeDir) + end + end + end + end + sPrevName = sName + nSolidId = EgtGetNextName( nSolidId, AUX_SOLIDS_CRV .. '*') + end +end + +------------------------------------------------------------------- +--------------------------- RIBS ----------------------------------- -------------------------------------------------------------------- local function VerifyRibsLink( nLinkId, nCurr, nNext, dStrand, nGrpTmp) @@ -719,13 +914,14 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing, dStrand, n end --------------------------------------------------------------------- -local function CalcRibsToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ) +local function CalcRibsToolPath( nRibsGrp, nTpathGrpId, LayerParams, dCorrZ) + if not nRibsGrp then return end + -- gruppo temporaneo con sistema di riferimento locale per conti local frLoc = Frame3d( ORIG(), LayerParams.vtSlicing) - local nGrpTmp = EgtGroup( nCrvGrp, frLoc, GDB_RT.GLOB) + local nGrpTmp = EgtGroup( nRibsGrp, frLoc, GDB_RT.GLOB) - local nRibsGrp = EgtGetFirstNameInGroup( nCrvGrp, RIBS_GRP) -- aggiungo le costolature nel toolpath local vEntIds = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') for i = 1, #vEntIds do @@ -870,73 +1066,9 @@ local function CalcRibsToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ) 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.vtSlicing, dCoastingLen, dWipeLen, dWipeDir) - end - end - end - end - sPrevName = sName - nSolidId = EgtGetNextName( nSolidId, AUX_SOLIDS_CRV .. '*') - end -end - ---------------------------------------------------------------------- +------------------------------------------------------------------- +------------------------- SPIRAL VASE ------------------------------ +-------------------------------------------------------------------- local function AddSpiralVaseLeadOut( nOldId, LayerParams) if LayerParams.nLeadOutType ~= LEAD_TYPE.NONE then @@ -1124,8 +1256,6 @@ 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 @@ -1133,7 +1263,7 @@ function CalcToolPath.Exec( nPartId) local nPathGrpId = EgtGetFirstNameInGroup( nCrvGrpId, PATH_GRP) if not nPathGrpId then EgtOutBox( 'Error missing paths', 'ToolPathCalc') - return + return else EgtSetStatus( nPathGrpId, GDB_ST.OFF) end @@ -1145,126 +1275,32 @@ function CalcToolPath.Exec( nPartId) 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) - -- eventuale inversione - local nType = EgtGetInfo( nNewEntId, KEY_TYPE, 'i') - 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')) - EgtSetStatus( nNewEntId, GDB_ST.ON) - nEntId = EgtGetNext( nEntId) + + -- shells + local vShellIds = EgtGetNameInGroup( nPathGrpId, SHELL_CRV .. '*') + local vExtraShellIds = EgtGetNameInGroup( nPathGrpId, EXTRA_SHELL_CRV .. '*') + local vInfillIds = EgtGetNameInGroup( nPathGrpId, INFILL_CRV .. '*') + + if LayerParams.nOrder == PRINT_ORDER.EXT_INT then + CalcShellsToolPath( vShellIds, nTpathGrpId, LayerParams, dCorrZ) + CalcExtraShellToolPath( vExtraShellIds, nTpathGrpId, LayerParams, dCorrZ) + CalcInfillToolPath( vInfillIds, nTpathGrpId, LayerParams, dCorrZ) + else + CalcInfillToolPath( vInfillIds, nTpathGrpId, LayerParams, dCorrZ) + CalcExtraShellToolPath( vExtraShellIds, nTpathGrpId, LayerParams, dCorrZ) + CalcShellsToolPath( vShellIds, nTpathGrpId, LayerParams, dCorrZ) end - -- aggiungo gli opportuni raccordi sulle shell complete - local vIds = EgtGetAllInGroup( nTpathGrpId) - AddLink( vIds, nTpathGrpId, LayerParams.nLinkType, LayerParams.dLinkParam, LayerParams.dSPOffs, LayerParams.dStrand, LayerParams.vtSlicing) - - -- 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 .. '*') - while nCurr do - local sCurrName = EgtGetName( nCurr) - if sCurrName == sPrevName then - local ptS = EgtEP( nPrev) - local ptE = EgtSP( nCurr) - local nLinkId = EgtCurveCompoFromPoints( nTpathGrpId, {ptS, ptE}) - if nLinkId then - EgtRelocateGlob( nLinkId, nCurr, GDB_IN.BEFORE) - EgtModifyCurveExtrusion( nLinkId, LayerParams.vtSlicing, GDB_RT.GLOB) - EgtSetInfo( nLinkId, KEY_TYPE, TYPE.LINK) - EgtSetName( nLinkId, LINK_CRV) - end - end - sPrevName = sCurrName - nPrev = nCurr - nCurr = EgtGetNextName( nCurr, EXTRA_SHELL_CRV .. '*') - 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 = EgtGetFirstInGroup( nTpathGrpId) - if EgtGetName( nId or GDB_ID.NULL) == LEAD_IN_CRV then nId = EgtGetNext( nId) end - local nFirstId = nId - 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 dCoastingLen, dWipeLen, dWipeDir - local nType = EgtGetInfo( nId, KEY_TYPE, 'i') - local bClosed = EgtGetInfo( nId, KEY_CLOSED_CRV, 'b') or false - if ( nType == TYPE.EXTRA_SHELL or nType == TYPE.EXTRA_OUTER_SHELL) and not bClosed then - local bInverted = EgtGetInfo( nId, KEY_INVERTED_CRV, 'b') or false - local vCoastLen = EgtGetInfo( nId, KEY_EXTRA_SHELL_COASTING, 'vd') - local vWipeLen = EgtGetInfo( nId, KEY_EXTRA_SHELL_WIPE, 'vd') - local vWipeDir = EgtGetInfo( nId, KEY_EXTRA_SHELL_WIPE_DIR, 'vd') - -- se curva è stata invertita devo prendere le info legate a quello che era il suo punto di inizio, altrimenti prendo le info legate al punto finale - dCoastingLen = EgtIf( bInverted, vCoastLen[1], vCoastLen[2]) - dWipeLen = EgtIf( bInverted, vWipeLen[1], vWipeLen[2]) - dWipeDir = EgtIf( bInverted, vWipeDir[1], vWipeDir[2]) - else - dCoastingLen = LayerParams.dCoastingLen - dWipeLen = LayerParams.dWipeLen - dWipeDir = LayerParams.dWipeDir - end - - if nId == nLastId then - 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 - AddRetraction( nId, LayerParams.vtSlicing, dCoastingLen, EgtIf( LayerParams.nLeadInType == LEAD_TYPE.NONE, dWipeLen, 0), dWipeDir) - else - AddRetraction( nId, LayerParams.vtSlicing, dCoastingLen, dWipeLen, dWipeDir) - end - end - end - nId = EgtGetNextName( nId, SHELL_CRV .. "*") or EgtGetNextName( nId, EXTRA_SHELL_CRV .. "*") or EgtGetNextName( nId, INFILL_CRV .. '') - end - - -- sistemo i solid ausiliari + -- solidi ausiliari + local nAuxSolidsGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], AUX_SOLIDS_GRP) local nAuxSolidsPathGrp = EgtGetFirstNameInGroup( nCrvGrpId, AUX_SOLIDS_GRP) - if nAuxSolidsGrp then - CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGrpId, LayerParams, dCorrZ) - end - -- sistemo le costolature + CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGrpId, LayerParams, dCorrZ) + + -- costolature local nRibsGrp = EgtGetFirstNameInGroup( nCrvGrpId, RIBS_GRP) - if nRibsGrp then - CalcRibsToolPath( nCrvGrpId, nTpathGrpId, LayerParams, dCorrZ) - end + CalcRibsToolPath( nRibsGrp, nTpathGrpId, LayerParams, dCorrZ) - --passo al gruppo di contorni successivo + -- passo al gruppo di contorni successivo nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*") end diff --git a/LuaLibs/RunSliceAdvancement.lua b/LuaLibs/RunSliceAdvancement.lua index b172f97..f013ae2 100644 --- a/LuaLibs/RunSliceAdvancement.lua +++ b/LuaLibs/RunSliceAdvancement.lua @@ -124,7 +124,7 @@ function RunSliceAdvancement.Exec() local ToHideList if nAdvancementType == SLICE_ADV_TYPE.ALL then nSegmentQty = #ShellList[1] + #ShellList[2] + #ShellList[3] - if nPrintOrder == PRINT_ORDER.EXT_INT_INF then + if nPrintOrder == PRINT_ORDER.EXT_INT then SegmentList = ShellList[1] for i = 1, #ShellList[2] do SegmentList[#SegmentList + 1] = ShellList[2][i] diff --git a/LuaLibs/RunSlicing.lua b/LuaLibs/RunSlicing.lua index 6f07362..51c090a 100644 --- a/LuaLibs/RunSlicing.lua +++ b/LuaLibs/RunSlicing.lua @@ -58,9 +58,9 @@ local function LoadParams( sFile, nPartId) local sStrandOrder = EgtGetStringFromIni( SEC_DEFAULT, KEY_PRINT_ORDER, 'InToOut', sFile) if sStrandOrder == 'OutToIn' then - EgtSetInfo( nPartId, KEY_PRINT_ORDER, PRINT_ORDER.EXT_INT_INF) + EgtSetInfo( nPartId, KEY_PRINT_ORDER, PRINT_ORDER.EXT_INT) else -- 'InToOut' - EgtSetInfo( nPartId, KEY_PRINT_ORDER, PRINT_ORDER.INF_INT_EXT) + EgtSetInfo( nPartId, KEY_PRINT_ORDER, PRINT_ORDER.INT_EXT) end local sStrandDirection = EgtGetStringFromIni( SEC_DEFAULT, KEY_PRINT_DIRECTION, 'CCW', sFile) @@ -183,9 +183,9 @@ local function LoadParams( sFile, nPartId) local sAuxSolidsStrandOrder = EgtGetStringFromIni( SEC_DEFAULT, KEY_AUX_SOLIDS_PRINT_ORDER, 'InToOut', sFile) if sAuxSolidsStrandOrder == 'OutToIn' then - EgtSetInfo( nPartId, KEY_AUX_SOLIDS_PRINT_ORDER, PRINT_ORDER.EXT_INT_INF) + EgtSetInfo( nPartId, KEY_AUX_SOLIDS_PRINT_ORDER, PRINT_ORDER.EXT_INT) else -- 'InToOut' - EgtSetInfo( nPartId, KEY_AUX_SOLIDS_PRINT_ORDER, PRINT_ORDER.INF_INT_EXT) + EgtSetInfo( nPartId, KEY_AUX_SOLIDS_PRINT_ORDER, PRINT_ORDER.INT_EXT) end local sAuxSolidsLinkType = EgtGetStringFromIni( SEC_DEFAULT, KEY_AUX_SOLIDS_LINK_TYPE, 'None', sFile)