diff --git a/LuaLibs/AddManData.lua b/LuaLibs/AddManData.lua index 2b96f3b..fa21986 100644 --- a/LuaLibs/AddManData.lua +++ b/LuaLibs/AddManData.lua @@ -37,6 +37,7 @@ MIN_RIBS_LEN = 2 SEC_DEFAULT = "Default" KEY_PARAMS = "Params" KEY_CALC_SOLIDS = "CalcSolids" +KEY_SPIRAL_VASE = "SpiralVase" KEY_SLICING_45 = "Slicing45" KEY_SLICING_DIR="SlicingDir" KEY_SLICE_STEP = "StrandH" @@ -75,6 +76,7 @@ KEY_OFFSET_LEAD_POINT = "OffsetLeadPoint" KEY_COASTING_LEN = "CoastingLen" KEY_COASTING_FEED = "CoastingFeed" KEY_WIPE_LEN = "WipeLen" +KEY_WIPE_DIR = "WipeDir" KEY_WIPE_FEEDPU = "WipeFeedPu" KEY_TOOL_DIAM = "ToolDiam" diff --git a/LuaLibs/CalcPaths.lua b/LuaLibs/CalcPaths.lua index fc35c94..dbf3aaa 100644 --- a/LuaLibs/CalcPaths.lua +++ b/LuaLibs/CalcPaths.lua @@ -18,7 +18,8 @@ local s_dOffsCorr = 10 * GEO.EPS_SMALL --------------------------------------------------------------------- local function GetLayerParamsForPathCalc() - local LayerParams = {} + local LayerParams = {} + LayerParams.bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false LayerParams.nShellsNbr = EgtGetInfo( s_nPartId, KEY_SHELLS_NBR, 'i') LayerParams.dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd') LayerParams.nStrandOverlap = EgtGetInfo( s_nPartId, KEY_STRAND_OVERLAP, 'i') or 0 @@ -31,6 +32,14 @@ local function GetLayerParamsForPathCalc() LayerParams.bPrintInvert = ( EgtGetInfo( s_nPartId, KEY_PRINT_DIRECTION, 'i') == PRINT_DIRECTION.CW) -- parametri costolature LayerParams.bRibsInvertOrder = EgtGetInfo( s_nPartId, KEY_RIBS_INVERT_ORDER, 'b') + + -- eventuale modifica dei parametri per gestire correttamente il caso spiral vase + if LayerParams.bSpiralVase then + LayerParams.nShellsNbr = 1 + LayerParams.nFloorNbr = 0 + LayerParams.nCeilNbr = 0 + end + return LayerParams end @@ -1362,7 +1371,7 @@ local function CalcAuxSolidsPaths( nSliceGrp, nSolidGrp, LayerParams, vPtStart) -- verifico se il gruppo contine qualcosa if not EgtGetFirstNameInGroup( nSolidPathGrp, AUX_SOLIDS_CRV .. '*') then - EgtErase( nSolidPathGrp) + EgtErase( nSolidPathGrp) end -- passo al gruppo di contorni successivo @@ -1402,7 +1411,7 @@ function CalcPaths.Exec( nPartId) 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 + -- verifico se il path è già stato calcolato local nGrpId = EgtGetFirstNameInGroup( nCrvGrpId, PATH_GRP) or GDB_ID.NULL if nGrpId == GDB_ID.NULL then nGrpId = EgtGroup( nCrvGrpId) @@ -1411,10 +1420,6 @@ function CalcPaths.Exec( nPartId) 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) diff --git a/LuaLibs/CalcSlices.lua b/LuaLibs/CalcSlices.lua index b9c07da..f659ad2 100644 --- a/LuaLibs/CalcSlices.lua +++ b/LuaLibs/CalcSlices.lua @@ -572,28 +572,31 @@ function CalcSlices.Exec( nPartId, nStmId, HMax) nLayCnt = nLayCnt + 1 nLayId = EgtGetNext( nLayId) end - - -- costolature - local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS) - if nRibsLay then - SlicingExtraObjects( vtSlicing, nRibsLay, TYPE.RIB, RIBS_GRP, RIBS_CRV) + + local bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false + if not bSpiralVase then + -- costolature + local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS) + if nRibsLay then + SlicingExtraObjects( vtSlicing, nRibsLay, TYPE.RIB, RIBS_GRP, RIBS_CRV) + end + if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 1) / ( #vZSlices + 3) * 100, 0) == 1 then return end + + -- solidi per regioni con diverso numero di passate + local nShellNbrLay = EgtGetFirstNameInGroup( s_nPartId, LAY_SHELL_NBR) + if nShellNbrLay then + SlicingExtraObjects( vtSlicing, nShellNbrLay, TYPE.EXTRA_SHELL, SHELL_NBR_GRP, SHELL_NBR_CRV) + end + if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 2) / ( #vZSlices + 3) * 100, 0) == 1 then return end + + -- solidi ausiliari + local nAuxSolidsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_AUX_SOLIDS) + if nAuxSolidsLay then + AdjustAuxSolids( nAuxSolidsLay) + SlicingExtraObjects( vtSlicing, nAuxSolidsLay, TYPE.AUX_SOLID, AUX_SOLIDS_GRP, AUX_SOLIDS_CRV) + end + if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 3) / ( #vZSlices + 3) * 100, 0) == 1 then return end end - if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 1) / ( #vZSlices + 3) * 100, 0) == 1 then return end - - -- solidi per regioni con diverso numero di passate - local nShellNbrLay = EgtGetFirstNameInGroup( s_nPartId, LAY_SHELL_NBR) - if nShellNbrLay then - SlicingExtraObjects( vtSlicing, nShellNbrLay, TYPE.EXTRA_SHELL, SHELL_NBR_GRP, SHELL_NBR_CRV) - end - if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 2) / ( #vZSlices + 3) * 100, 0) == 1 then return end - - -- solidi ausiliari - local nAuxSolidsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_AUX_SOLIDS) - if nAuxSolidsLay then - AdjustAuxSolids( nAuxSolidsLay) - SlicingExtraObjects( vtSlicing, nAuxSolidsLay, TYPE.AUX_SOLID, AUX_SOLIDS_GRP, AUX_SOLIDS_CRV) - end - if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 3) / ( #vZSlices + 3) * 100, 0) == 1 then return end -- eventuale segnalazione errori if #vErr > 0 then diff --git a/LuaLibs/CalcToolPath.lua b/LuaLibs/CalcToolPath.lua index df34eea..8de55bb 100644 --- a/LuaLibs/CalcToolPath.lua +++ b/LuaLibs/CalcToolPath.lua @@ -19,6 +19,7 @@ local s_nDefaultWipeAng = -90 -- angolo = 0° per wipe significa che esce orto --------------------------------------------------------------------- local function GetLayerParamsForToolPathCalc() local LayerParams = {} + LayerParams.bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false 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') @@ -36,6 +37,7 @@ local function GetLayerParamsForToolPathCalc() 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.dWipeDir = EgtGetInfo( s_nPartId, KEY_WIPE_DIR, 'd') or 0.0 LayerParams.vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v') LayerParams.dTDiam = EgtGetInfo( s_nPartId, KEY_TOOL_DIAM, 'd') -- Parametri costolature @@ -143,18 +145,23 @@ local function AddLeadIn( nCrvId, LayerParams, nGrpId) vtOrtho:rotate( LayerParams.vtSlicing, dAng) local ptS = ptE - LayerParams.dLeadInTangDist * vtTang + LayerParams.dLeadInOrthoDist * vtOrtho + -- verifico che non affondi nella tavola + if ptS:getZ() < GEO.EPS_SMALL then return end - local nLeadInCrv = GDB_ID.NULL + local nLeadInCrv 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 + + if nLeadIn then + 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 end -------------------------------------------------------------------- @@ -172,16 +179,20 @@ local function AddLeadOut( nCrvId, LayerParams, nGrpId) vtOrtho:rotate( LayerParams.vtSlicing, dAng) local ptE = ptS + LayerParams.dLeadOutTangDist * vtTang + LayerParams.dLeadOutOrthoDist * vtOrtho - local nLeadOutCrv = GDB_ID.NULL + local nLeadOutCrv 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) + 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) + + if nLeadOutCrv then + 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 + return nLeadOutCrv end -------------------------------------------------------------------- @@ -228,17 +239,17 @@ local function AddRetraction( nCrvId, LayerParams, dCoastingLen, dWipeLen, dWipe EgtTrimCurveEndAtLen( nWipeId, dWipeLen) else - -- se extra shell o infill a zigzag + -- se extra shell, infill a zigzag o spiral vase local vtDir = EgtEV( nCoastingId or nCrvId) 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 + if nType == TYPE.INFILL then local vtS = EgtGetInfo( nCrvId, KEY_ZIG_ZAG_DIR, 'v') local bSameDir = AreSameVectorApprox( vtS, vtDir) - bChangeSign = ( bInverted == bSameDir) + bChangeSign = ( bInverted == bSameDir) + else + bChangeSign = bInverted end vtDir:rotate( LayerParams.vtSlicing, EgtIf( bChangeSign, - dAng, dAng)) local ptS = EgtEP( nCoastingId or nCrvId) @@ -277,12 +288,14 @@ local function AddRetractionOnLastCrv( nCrvId, nTpathGrpId, LayerParams, dCoasti if dLen > dCoastingLen - 500 * GEO.EPS_SMALL then -- coinvolge solo la curva di lead out local dNewCoastingLen = EgtIf( abs( dCoastingLen - dLen) < 500 * GEO.EPS_SMALL, dLen, dCoastingLen) -- verifico se interamente coinvolta - AddRetraction( nLeadOutId, LayerParams, dNewCoastingLen, 0.0, dWipeDir) + AddRetraction( nLeadOutId, LayerParams, dNewCoastingLen, dWipeLen, dWipeDir) else -- coinvolge parte dell'ultima shell crv local dNewCoastingLen = dCoastingLen - dLen local nCoastingId = AddRetraction( nCrvId, LayerParams, dNewCoastingLen, 0.0, dWipeDir) EgtAddCurveCompoCurve( nCoastingId, nLeadOutId) + -- wipe + AddRetraction( nCoastingId, LayerParams, 0, dWipeLen, dWipeDir) end end end @@ -600,7 +613,7 @@ local function AddRibsLeadIn( nCrv, nLoopsGrp, dStrand, vtSlicing) end -------------------------------------------------------------------- -local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing, dStrand) +local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing, dStrand, dTDiam) local dRibsLOLen = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_LEN, 'd') local dRibsLOCoasting = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_COASTING, 'd') @@ -618,7 +631,7 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing, dStrand) -- recupero la curva di offset su cui calcolare lead out local nCrvOffs = EgtGetFirstInGroup( nLoopsGrp) while nCrvOffs do - local dParE = EgtCurveParamAtPoint( nCrvOffs, ptE) + local dParE = EgtCurveParamAtPoint( nCrvOffs, ptE) if dParE then local nCrvLO @@ -668,6 +681,15 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing, dStrand) local dAng = dRibsLOWipeAng + s_nDefaultWipeAng vtE:rotate( vtSlicing, EgtIf( bInvert, - dAng, dAng)) local ptFinal = ptE + vtE * dRibsLOWipe + -- verifico soddisfi altezza minima per dimensioni utensile + local dHMin = 0.5 * dTDiam * sqrt( vtSlicing:getX() * vtSlicing:getX() + vtSlicing:getY() * vtSlicing:getY()) + local k = 1 + while ptFinal:getZ() < dHMin + GEO.EPS_SMALL and k < 36 do + vtE:rotate( vtSlicing, EgtIf( bInvert, - 10, 10)) + ptFinal = ptE + vtE * dRibsLOWipe + k = k + 1 + end + nWipe = EgtCurveCompoFromPoints( nTPathGrp, { ptE, ptFinal}) EgtModifyCurveExtrusion( nWipe, vtSlicing, GDB_RT.GLOB) EgtRelocateGlob( nWipe, nCoasting or nCrvLO or nCrv, GDB_IN.AFTER) @@ -676,7 +698,7 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing, dStrand) EgtSetColor( nWipe, EgtStdColor('AQUA')) end - return + return end nCrvOffs = EgtGetNext( nCrvOffs) @@ -807,7 +829,7 @@ local function CalcRibsToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ) -- verifico se necessario lead out local nNext = EgtGetNext( nCrvRib) if not nNext or EgtGetName( nNext) then - AddRibsLeadOut( nCrvRib, nTpathGrpId, nLoopGrp, LayerParams.vtSlicing, LayerParams.dStrand) + AddRibsLeadOut( nCrvRib, nTpathGrpId, nLoopGrp, LayerParams.vtSlicing, LayerParams.dStrand, LayerParams.dTDiam) end nCrvRib = EgtGetNextName( nCrvRib, RIBS_CRV .. '*') end @@ -837,14 +859,14 @@ local function CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGr 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 + -- 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) + EgtMove( nNewEnt, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) EgtModifyCurveExtrusion( nNewEnt, LayerParams.vtSlicing, GDB_RT.GLOB) EgtSetInfo( nNewEnt, KEY_TYPE, TYPE.AUX_SOLID) @@ -879,6 +901,118 @@ local function CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGr end end +--------------------------------------------------------------------- +local function AddSpiralVaseLeadOut( nOldId, LayerParams) + + if LayerParams.nLeadOutType ~= LEAD_TYPE.NONE then + EgtTrimCurveEndAtLen( nOldId, EgtCurveLength( nOldId) - LayerParams.dOffsetLP) + local nLeadOut = AddLeadOut( nOldId, LayerParams, EgtGetParent( nOldId)) + if nLeadOut then + local dDelta = LayerParams.dLayHeight / EgtCurveLength( nOldId) * EgtCurveLength( nLeadOut) + EgtSpiralizeCurve( nLeadOut, dDelta) + end + AddRetractionOnLastCrv( nOldId, EgtGetParent( nOldId), LayerParams, LayerParams.dCoastingLen, LayerParams.dWipeLen, LayerParams.dWipeDir) + else + AddRetraction( nOldId, LayerParams, LayerParams.dCoastingLen, LayerParams.dWipeLen, LayerParams.dWipeDir) + end + +end + +--------------------------------------------------------------------- +local function SpiralVase( vLayIds, dCorrZ, LayerParams) + + local nOldId + local bFirst = true + + -- ciclo sui layer + for nIdx = 1, #vLayIds do + + -- cerco i gruppi di contorni + local vCrvGrpIds = EgtGetNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*") + if #vCrvGrpIds > 1 then + -- se più di un gruppo di curve warning + EgtOutLog( 'Warning : in spiral vase mode more than one curve (layer '..tostring( nIdx)..') - CalcToolPath') + end + + for i = 1, #vCrvGrpIds do + -- recupero il gruppo dei percorsi + local nPathGrpId = EgtGetFirstNameInGroup( vCrvGrpIds[i], 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( vCrvGrpIds[i], TOOLPATH_GRP) + if not nTpathGrpId then + nTpathGrpId = EgtGroup( vCrvGrpIds[i]) + 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, 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) + -- eventuale inversione + if LayerParams.bInvert then + EgtInvertCurve( nNewEntId) + EgtSetInfo( nNewEntId, KEY_INVERTED_CRV, 1) + end + EgtSetColor( nNewEntId, EgtStdColor('GRAY')) + + -- se primo layer devo farne copia + if bFirst and nNewEntId then + local nFirstCrv = EgtCopyGlob( nNewEntId, nTpathGrpId, GDB_IN.FIRST_SON) + EgtModifyCurveExtrusion( nFirstCrv, LayerParams.vtSlicing, GDB_RT.GLOB) + -- eventuale lead in + if LayerParams.nLeadInType ~= LEAD_TYPE.NONE then + EgtTrimCurveStartAtLen( nFirstCrv, LayerParams.dOffsetLP) + AddLeadIn( nFirstCrv, LayerParams, nTpathGrpId) + end + nOldId = nNewEntId + bFirst = false + end + + -- modifico lo start point per collegarlo alla curva precedente + local ptOld = EgtEP( nOldId) + if dist( EgtSP( nNewEntId), ptOld) < LayerParams.dStrand + 10 then + EgtChangeClosedCurveStartPoint( nNewEntId, ptOld) + EgtModifyCurveStartPoint( nNewEntId, ptOld) + else + EgtOutLog( 'Warning : in spiral vase mode no link betweeen toolpaths (layer '..tostring( nIdx)..') - CalcToolPath') + -- aggiungo uscita, coasting e wipe sulla curva precedente + AddSpiralVaseLeadOut( nOldId, LayerParams) + end + + nOldId = nNewEntId + EgtSpiralizeCurve( nNewEntId, LayerParams.dLayHeight) + nEntId = EgtGetNext( nEntId) + end + end + + if EgtProcessEvents( EgtIf( PRINT, 300, 0) + nIdx / #vLayIds * 100, 0) == 1 then + EgtDraw() + return + end + end + + -- aggiungo uscita, coasting e wipe su ultima curva + AddSpiralVaseLeadOut( nOldId, LayerParams) + +end + --------------------------------------------------------------------- function CalcToolPath.Exec( nPartId) @@ -887,11 +1021,11 @@ function CalcToolPath.Exec( nPartId) -- Verifico il pezzo if not s_nPartId then EgtOutBox( 'Error missing part', 'ToolPathCalc') - return + return end -- Recupero i layer da processare - local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*") + local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*") if not vLayIds then EgtOutBox( 'Error missing slices', 'ToolPathCalc') return @@ -910,10 +1044,16 @@ function CalcToolPath.Exec( nPartId) local EntId = EgtGetFirstInGroup( SolidLayId) while EntId do EgtMove( EntId, vtMove) - EntId = EgtGetNext( EntId) + EntId = EgtGetNext( EntId) end end end + + -- caso spiral vase + if LayerParams.bSpiralVase then + SpiralVase( vLayIds, dCorrZ, LayerParams) + return + end -- Ciclo sui layer for nIdx = 1, #vLayIds do @@ -950,7 +1090,7 @@ function CalcToolPath.Exec( nPartId) EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) -- eventuale inversione local nType = EgtGetInfo( nNewEntId, KEY_TYPE, 'i') - if LayerParams.bInvert then + 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) @@ -1042,7 +1182,7 @@ function CalcToolPath.Exec( nPartId) end -- sistemo le costolature local nRibsGrp = EgtGetFirstNameInGroup( nCrvGrpId, RIBS_GRP) - if nRibsGrp then + if nRibsGrp then CalcRibsToolPath( nCrvGrpId, nTpathGrpId, LayerParams, dCorrZ) end @@ -1052,9 +1192,9 @@ function CalcToolPath.Exec( nPartId) if EgtProcessEvents( EgtIf( PRINT, 300, 0) + nIdx / #vLayIds * 100, 0) == 1 then EgtDraw() - return + return end - end + end end --------------------------------------------------------------------- diff --git a/LuaLibs/RunCalcSolids.lua b/LuaLibs/RunCalcSolids.lua index 785c189..4c37269 100644 --- a/LuaLibs/RunCalcSolids.lua +++ b/LuaLibs/RunCalcSolids.lua @@ -12,13 +12,15 @@ EgtOutLog( ' RunCalcSolids started', 1) -- Dati local AMD = require( 'AddManData') +-------------------------------------------------------------------- +s_dTol = 0.1 + --------------------------------------------------------------------- local function GetLayerParamsForSolidCalc( nPartId) - local LayerParams = {} - LayerParams.bInvert = EgtGetInfo( nPartId, KEY_PRINT_DIRECTION, 'b') + local LayerParams = {} + LayerParams.bSpiralVase = EgtGetInfo( nPartId, KEY_SPIRAL_VASE, 'b') or false LayerParams.dLayHeight = EgtGetInfo( nPartId, KEY_SLICE_STEP, 'd') LayerParams.dStrand = EgtGetInfo( nPartId, KEY_STRAND, 'd') - LayerParams.nOrder = EgtGetInfo( nPartId, KEY_PRINT_ORDER, 'i') LayerParams.vtSlicing = EgtGetInfo( nPartId, KEY_SLICING_DIR, 'v') return LayerParams end @@ -63,7 +65,7 @@ local function CreateSection( ptS, vtDir, dStrand, dH, vtSlicing, nSolidGrp) local ptF = ptC - 2 * ( dD1 + dD2) * vtDir local ptG = ptB - 2 * ( dD1 + dD2) * vtDir local ptH = ptA - 2 * dD1 * vtDir - + local nId = EgtCurveCompoFromPoints( nSolidGrp, {ptA, ptB, ptC, ptD, ptE, ptF, ptG, ptH, ptA}) EgtInvertCurve( nId) @@ -84,34 +86,135 @@ local function CreateHalfSection( ptS, vtDir, dStrand, dH, vtSlicing, nSolidGrp) return nId end --------------------------------------------------------------------- -local function CreateSolid( nCrvId, nSolidGrp, dStrand, dH, vtSlicing) - -- punti e direzioni all'inizio e fine della curva guida - local ptS = EgtSP( nCrvId) +------------------------------------------------------------------------------ +local function CreateSpiralVaseCap( nSectId, vtDir, nSolidGrp) + + local vPt = {} + for i = 0, 7 do + vPt[i + 1] = EgtUP( nSectId, i) + end + + local vCrvs = {} + vCrvs[1] = EgtArc2PV( nSolidGrp, vPt[1], vPt[2], vtDir) + vCrvs[2] = EgtArc2PV( nSolidGrp, vPt[8], vPt[3], vtDir) + vCrvs[3] = EgtArc2PV( nSolidGrp, vPt[7], vPt[4], vtDir) + vCrvs[4] = EgtArc2PV( nSolidGrp, vPt[6], vPt[5], vtDir) + vCrvs[5] = EgtCurveCompo( nSolidGrp, {vCrvs[1]}, false) + EgtCloseCurveCompo( vCrvs[5]) + vCrvs[6] = EgtCurveCompo( nSolidGrp, {vCrvs[4]}, false) + EgtCloseCurveCompo( vCrvs[6]) + local nSurf1 = EgtSurfTmRuled( nSolidGrp, vCrvs[1], vCrvs[2], GDB_RUL.ISOPAR, s_dTol) + local nSurf2 = EgtSurfTmRuled( nSolidGrp, vCrvs[2], vCrvs[3], GDB_RUL.ISOPAR, s_dTol) + local nSurf3 = EgtSurfTmRuled( nSolidGrp, vCrvs[3], vCrvs[4], GDB_RUL.ISOPAR, s_dTol) + local nSurf4 = EgtSurfTmByRegion( nSolidGrp, vCrvs[5], s_dTol) + local nSurf5 = EgtSurfTmByRegion( nSolidGrp, vCrvs[6], s_dTol) + local nCapSrf = EgtSurfTmBySewing( nSolidGrp, {nSurf1, nSurf2, nSurf3, nSurf4, nSurf5}) + + for i = 1, #vCrvs do + EgtErase( vCrvs[i]) + end + + return nCapSrf +end + +------------------------------------------------------------------------------- +local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand) + + -- gruppo temporaneo per conti + local nGrpTmp = EgtGroup( nSolidGrp) + + local ptS = EgtSP( nCrvId) local vtS = EgtSV( nCrvId) - vtS:rotate( vtSlicing, 90) - local ptE = EgtEP( nCrvId) + local ptE = EgtEP( nCrvId) local vtE = EgtEV( nCrvId) - vtE:rotate( vtSlicing, -90) + -- appiattisco la curva + local nCrvCopy = EgtCopyGlob( nCrvId, nGrpTmp) + local dDelta = ( ptE - ptS) * LayerParams.vtSlicing + EgtSpiralizeCurve( nCrvCopy, - dDelta) + + -- calcolo la sezione + local vtDir = EgtSV( nCrvCopy) + vtDir:rotate( LayerParams.vtSlicing, 90) + local nSectId = CreateSection( ptS, vtDir, dStrand, LayerParams.dLayHeight, LayerParams.vtSlicing, nGrpTmp) + + -- creo il solido aperto (tubo) + local vCrvs = {} + local _, dParE = EgtCurveDomain( nSectId) + for i = 0, dParE do + local ptRef = EgtUP( nSectId, i) + local dOffs = ( ptRef - ptS) * vtDir + vCrvs[i+1] = EgtOffsetCurveAdv( nCrvCopy, dOffs) + if not vCrvs[i+1] or vCrvs[i+1] == GDB_ID.NULL then + EgtErase( nGrpTmp) + return nil + end + local dMove = ( ptRef - ptS) * LayerParams.vtSlicing + EgtMove( vCrvs[i+1], LayerParams.vtSlicing * dMove) + EgtSpiralizeCurve( vCrvs[i+1], dDelta) + end + local vSurfs = {} + for i = 1, #vCrvs - 1 do + vSurfs[i] = EgtSurfTmRuled( nGrpTmp, vCrvs[i], vCrvs[i+1], GDB_RUL.MINDIST, s_dTol) + if not vSurfs[i] or vSurfs[i] == GDB_ID.NULL then + EgtErase( nGrpTmp) + return nil + end + end + local nSrfId = EgtSurfTmBySewing( nSolidGrp, vSurfs) + EgtInvertSurf( nSrfId) + + -- creazione del mezzo disco iniziale + local nCap1 = CreateSpiralVaseCap( nSectId, - vtS, nSolidGrp) + -- creazione del mezzo disco finale + local vtDir2 = EgtEV( nCrvCopy) + vtDir2:rotate( LayerParams.vtSlicing, 90) + local nSectE = CreateSection( ptE, vtDir2, dStrand, LayerParams.dLayHeight, LayerParams.vtSlicing, nGrpTmp) + local nCap2 = CreateSpiralVaseCap( nSectE, vtE, nSolidGrp) + EgtInvertSurf( nCap2) + + -- cancello le curve usate per la costruzione + EgtErase( nGrpTmp) + + return EgtSurfTmBySewing( nSolidGrp, { nSrfId, nCap1, nCap2}) +end + +---------------------------------------------------------------------- +local function CreateStandardSolid( nCrvId, nSolidGrp, LayerParams, dStrand) + + local ptS = EgtSP( nCrvId) + local vtS = EgtSV( nCrvId) + vtS:rotate( LayerParams.vtSlicing, 90) + local ptE = EgtEP( nCrvId) + local vtE = EgtEV( nCrvId) + vtE:rotate( LayerParams.vtSlicing, -90) -- creazione del solido aperto (tubo) - local nSectId = CreateSection( ptS, vtS, dStrand, dH, vtSlicing, nSolidGrp) - local nSrfId = EgtSurfTmSwept( nSolidGrp, nSectId, nCrvId, false, 0.1) + local nSectId = CreateSection( ptS, vtS, dStrand, LayerParams.dLayHeight, LayerParams.vtSlicing, nSolidGrp) + local nSrfId = EgtSurfTmSwept( nSolidGrp, nSectId, nCrvId, false, s_dTol) EgtErase( nSectId) if not nSrfId then return nil end -- creazione del mezzo disco iniziale - local nSectS = CreateHalfSection( ptS, vtS, dStrand, dH, vtSlicing, nSolidGrp) - local nSrfS = EgtSurfTmByScrewing( nSolidGrp, nSectS, ptS, vtSlicing, 180, 0, false, 0.1) + local nSectS = CreateHalfSection( ptS, vtS, dStrand, LayerParams.dLayHeight, LayerParams.vtSlicing, nSolidGrp) + local nSrfS = EgtSurfTmByScrewing( nSolidGrp, nSectS, ptS, LayerParams.vtSlicing, 180, 0, false, s_dTol) EgtErase( nSectS) if not nSrfS then return nil end -- creazione del mezzo disco finale - local nSectE = CreateHalfSection( ptE, vtE, dStrand, dH, vtSlicing, nSolidGrp) - local nSrfE = EgtSurfTmByScrewing( nSolidGrp, nSectE, ptE, vtSlicing, 180, 0, false, 0.1) + local nSectE = CreateHalfSection( ptE, vtE, dStrand, LayerParams.dLayHeight, LayerParams.vtSlicing, nSolidGrp) + local nSrfE = EgtSurfTmByScrewing( nSolidGrp, nSectE, ptE, LayerParams.vtSlicing, 180, 0, false, s_dTol) EgtErase( nSectE) if not nSrfE then return nil end -- unione delle tre superfici return EgtSurfTmBySewing( nSolidGrp, { nSrfId, nSrfS, nSrfE}) end +-------------------------------------------------------------------------------------- +local function CreateSolid( nCrvId, nSolidGrp, LayerParams, dStrand) + if LayerParams.bSpiralVase then + return CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand) + else + return CreateStandardSolid( nCrvId, nSolidGrp, LayerParams, dStrand) + end +end + --------------------------------------------------------------------- local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams) @@ -134,17 +237,17 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams) elseif nType == TYPE.RIB then Color = EgtStdColor( 'OLIVE') elseif nType == TYPE.AUX_SOLID then - Color = EgtStdColor( 'AQUA') + Color = EgtStdColor( 'AQUA') end - local nCopyId = EgtCopyGlob( nCrvId, nSolidGrp) + local nCopyId = EgtCopyGlob( nCrvId, nSolidGrp) local nId = GDB_ID.NULL local nParts = 1 local LEN_REF = 100 local bZigZagInfill = EgtGetInfo( nCopyId, KEY_ZIG_ZAG_INFILL, 'b') or false if bZigZagInfill then nId, nParts = EgtSplitCurveAtCorners( nCopyId, 80) - else + else local dLen = EgtCurveLength( nCrvId) if dLen > LEN_REF and nType ~= TYPE.LINK and nType ~= TYPE.COASTING then nParts = EgtClamp( floor( dLen / LEN_REF), 1, 10) @@ -155,34 +258,37 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams) if nId == GDB_ID.NULL then return false end local bOk = true for nInd = 0, nParts - 1 do - local nGuideId = nId + nInd - local nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams.dStrand - 2 * GEO.EPS_SMALL, LayerParams.dLayHeight, LayerParams.vtSlicing) + local nGuideId = nId + nInd + local nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, LayerParams.dStrand - 2 * GEO.EPS_SMALL) if not nSrfId then - -- ritento con sezione leggermente modificata - nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams.dStrand - 100 * GEO.EPS_SMALL, LayerParams.dLayHeight, LayerParams.vtSlicing) + -- ritento con sezione leggermente modificata + nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, LayerParams.dStrand - 100 * GEO.EPS_SMALL) if not nSrfId then - nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams.dStrand + 100 * GEO.EPS_SMALL, LayerParams.dLayHeight, LayerParams.vtSlicing) - if not nSrfId then + nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, LayerParams.dStrand + 100 * GEO.EPS_SMALL) + if not nSrfId then -- ritento spezzando la curva local nGrp = EgtGroup( nSolidGrp, Frame3d( ORIG(), LayerParams.vtSlicing)) EgtRelocateGlob( nGuideId, nGrp) EgtApproxCurve( nGuideId, GDB_CA.LINES, 100 * GEO.EPS_SMALL) EgtRelocateGlob( nGuideId, nSolidGrp) local nFirstCrv, nCrvNbr = EgtSplitCurveAtCorners( nGuideId, 30) - if nFirstCrv and nCrvNbr > 1 then + if nFirstCrv and nCrvNbr > 1 then local nSrfIds = {} for nInd2 = 0, nCrvNbr-1 do - local nSrfId2 = CreateSolid( nFirstCrv + nInd2, nSolidGrp, LayerParams.dStrand - 100 * GEO.EPS_SMALL, LayerParams.dLayHeight, LayerParams.vtSlicing) + local nSrfId2 = CreateSolid( nFirstCrv + nInd2, nSolidGrp, LayerParams, LayerParams.dStrand - 100 * GEO.EPS_SMALL) EgtErase( nFirstCrv + nInd2) if nSrfId2 then table.insert( nSrfIds, nSrfId2) - end + end end - if #nSrfIds == nCrvNbr then - nSrfId = EgtSurfTmBySewing( nSolidGrp, nSrfIds) + if #nSrfIds == nCrvNbr then + nSrfId = EgtSurfTmBySewing( nSolidGrp, nSrfIds) end + else + EgtErase( nFirstCrv) end + EgtErase( nGrp) end end end @@ -192,7 +298,7 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams) EgtSetInfo( nSrfId, KEY_TYPE, nType) else bOk = false - end + end EgtErase( nGuideId) end @@ -278,10 +384,6 @@ function RunCalcSolids.Exec() end -- eventuale segnalazione errori - -- if #vErr > 0 then - -- EgtOutBox( 'Error on layers :\n' .. table.concat( vErr, ','), 'SolidCalc') - -- end - for i = 1, #vErr do EgtOutLog( 'Error on solid creation (layer ' .. vErr[i] .. ') - SolidCalc') end diff --git a/LuaLibs/RunSlicing.lua b/LuaLibs/RunSlicing.lua index 6afb327..d50f48a 100644 --- a/LuaLibs/RunSlicing.lua +++ b/LuaLibs/RunSlicing.lua @@ -37,6 +37,7 @@ local function LoadParams( sFile, nPartId) EgtSetInfo( nPartId, KEY_PARAMS, sFile) SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_CALC_SOLIDS, '0') + SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SPIRAL_VASE, '0') SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SLICING_45, '0') SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SLICE_STEP, '1.0') SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_STRAND, '6.0') @@ -123,6 +124,7 @@ local function LoadParams( sFile, nPartId) SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_COASTING_LEN, '0.0') SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_COASTING_FEED, '20000.0') SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_WIPE_LEN, '0.0') + SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_WIPE_DIR, '0.0') SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_WIPE_FEEDPU, '0.9') -- parametri per costolature