diff --git a/LuaLibs/AddManData.lua b/LuaLibs/AddManData.lua index 20e2e12..629201b 100644 --- a/LuaLibs/AddManData.lua +++ b/LuaLibs/AddManData.lua @@ -244,6 +244,7 @@ KEY_SLICE_ADV_MODE = 'SliceAdvMode' KEY_SLICE_ADV_PERC = 'SliceAdvPerc' KEY_MOVED_PART ='MovedPart' +KEY_MOVED_PART2 ='MovedPart2' RESULT = { OK = 1, diff --git a/LuaLibs/CalcPaths.lua b/LuaLibs/CalcPaths.lua index 235d159..7ba16ae 100644 --- a/LuaLibs/CalcPaths.lua +++ b/LuaLibs/CalcPaths.lua @@ -511,8 +511,8 @@ end local function TrimRibs( vRibs, nRibsGrp, nSrf, dSrfOffs, vtSlicing) -- costruisco le superfici con cui fare il trim grossolano dei setti - local nSrfInt = EgtCopyGlob( nSrf, nRibsGrp) - local nSrfExt = EgtCopyGlob( nSrf, nRibsGrp) + local nSrfInt = EgtCopyGlob( nSrf, nRibsGrp) or GDB_ID.NULL + local nSrfExt = EgtCopyGlob( nSrf, nRibsGrp) or GDB_ID.NULL EgtSurfFrOffset( nSrfInt, dSrfOffs) EgtSurfFrOffset( nSrfExt, - dSrfOffs) @@ -525,15 +525,31 @@ local function TrimRibs( vRibs, nRibsGrp, nSrf, dSrfOffs, vtSlicing) EgtSetInfo( nCopyRib, KEY_ORIGINAL_RIB_CLOSED, 1) end - local nCrv = nCopyRib - local nCnt = 1 + local nCrv, nCnt if nType == RIB_TYPE.INTERNAL or nType == RIB_TYPE.SUPPORT then - nCrv, nCnt = EgtTrimCurveWithRegion( nCopyRib, nSrfInt, true, true) + if EgtSurfFrChunkCount( nSrfInt) == 0 then + -- se la superficie non esiste, il setto deve essere cancellato + EgtErase( nCopyRib) + nCrv = GDB_ID.NULL + nCnt = 0 + else + nCrv, nCnt = EgtTrimCurveWithRegion( nCopyRib, nSrfInt, true, true) + end elseif nType == RIB_TYPE.EXTERNAL then - nCrv, nCnt = EgtTrimCurveWithRegion( nCopyRib, nSrfExt, false, true) + if EgtSurfFrChunkCount( nSrfExt) == 0 then + -- se la superficie non esiste il setto è valido + nCrv = nCopyRib + nCnt = 1 + else + nCrv, nCnt = EgtTrimCurveWithRegion( nCopyRib, nSrfExt, false, true) + end + else + -- setto unbounded non va tagliato + nCrv = nCopyRib + nCnt = 1 end - -- se errore nel calcolare trim riprendo il setto originario + -- se errore nel calcolare trim ( nCrv = nil) riprendo il setto originario if not nCrv then nCrv = nCopyRib nCnt = 1 @@ -552,7 +568,7 @@ end -------------------------------------------------------------------- local function ComputeRibsOrientedOffset( nRibsGrp, dStrand) - + local nOffsGrp = EgtGroup( EgtGetParent( nRibsGrp)) local nCurrRib = EgtGetFirstNameInGroup( nRibsGrp, RIBS_CRV .. '*') @@ -568,7 +584,7 @@ local function ComputeRibsOrientedOffset( nRibsGrp, dStrand) local nShellsNbr = EgtGetInfo( nCurrRib, KEY_RIBS_SHELLS_NBR, 'i') local dOffs = ( nShellsNbr - 1) * dStrand / 2 - + -- offset di ogni tratto del setto local vOffs = {} local bPlusToMinus = false @@ -667,7 +683,7 @@ local function ComputeTrimSurfWithOverlapsForRibs( vIds, nSrfBase, nSrfExt, dOff local nType = EgtGetInfo( vIds[i], KEY_RIBS_TYPE, 'i') if not tSurfOffs[nType][nOverlap] then if nType == RIB_TYPE.INTERNAL or nType == RIB_TYPE.SUPPORT then - if nSrfBase then + if nSrfBase ~= GDB_ID.NULL then local dNewOffs = nOverlap / 100 * dStrand local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrfBase, nGrp, dNewOffs, vtSlicing) if bOk then @@ -676,13 +692,16 @@ local function ComputeTrimSurfWithOverlapsForRibs( vIds, nSrfBase, nSrfExt, dOff end end elseif nType == RIB_TYPE.EXTERNAL then - if nSrfExt then + if nSrfExt ~= GDB_ID.NULL then local dNewOffs = dOffs + ( 0.5 - nOverlap / 100) * dStrand local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrfExt, nGrp, dNewOffs, vtSlicing) if bOk then tSurfOffs[nType][nOverlap] = nSrfOffs EgtSetName( nSrfOffs, TOT_SHELL_TRIM_SURF) end + else + -- se la superficie non esiste, il setto è sicuramente esterno (è analogo ad unbounded) + tSurfOffs[nType][nOverlap] = GDB_ID.NULL end else tSurfOffs[nType][nOverlap] = GDB_ID.NULL @@ -724,8 +743,13 @@ local function VerifyRibsIntersection( nRib1, nRib2, nType1, nType2, nSrf1, nSrf -- nel caso unbounded l'intersezione può essere ovunque bInters = true elseif nType1 == RIB_TYPE.EXTERNAL or nType2 == RIB_TYPE.EXTERNAL then - -- l'intersezione deve essere esterna - if nSrf2 and EgtSurfFrTestExternal( nSrf2, nPtId) then bInters = true end + if nSrf2 then + -- l'intersezione deve essere esterna + if EgtSurfFrTestExternal( nSrf2, nPtId) then bInters = true end + else + -- se la surf non esiste l'intersezione è sicuramente esterna + bInters = true + end else -- se uno dei due è interno o supporto l'intersezione deve essere interna if nSrf1 and not EgtSurfFrTestExternal( nSrf1, nPtId) then bInters = true end @@ -905,15 +929,15 @@ local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPa -- calcolo le regioni nella quali ha senso considerare l'intersezione local nSrfOffs1, nSrfOffs2 local bOk, bExists - local nSrf1 = EgtGetFirstNameInGroup( nCrvGrp, TOT_SHELL_TRIM_SURF) - if nSrf1 then + local nSrf1 = EgtGetFirstNameInGroup( nCrvGrp, TOT_SHELL_TRIM_SURF) or GDB_ID.NULL + if nSrf1 ~= GDB_ID.NULL then bOk, bExists, nSrfOffs1 = ComputeSurfOffset( nSrf1, nCrvGrp, 2 * LayerParams.dStrand, LayerParams.vtSlicing) if not bOk or not bExists then nSrfOffs1 = EgtCopyGlob( nSrf1, nCrvGrp) end end - local nSrf2 = EgtGetFirstNameInGroup( nCrvGrp, LAYER_SRF) - if nSrf2 then + local nSrf2 = EgtGetFirstNameInGroup( nCrvGrp, LAYER_SRF) or GDB_ID.NULL + if nSrf2 ~= GDB_ID.NULL then bOk, bExists, nSrfOffs2 = ComputeSurfOffset( nSrf2, nCrvGrp, - 2 * LayerParams.dStrand, LayerParams.vtSlicing) if not bOk or not bExists then nSrfOffs2 = EgtCopyGlob( nSrf2, nCrvGrp) @@ -1473,11 +1497,11 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, nIdx, vPtStart) end -- recupero le superfici - local nSrfBase = EgtGetFirstNameInGroup( nCrvGrp, TOT_SHELL_TRIM_SURF) - local nSrfExt = EgtGetFirstNameInGroup( nCrvGrp, LAYER_SRF) + local nSrfBase = EgtGetFirstNameInGroup( nCrvGrp, TOT_SHELL_TRIM_SURF) or GDB_ID.NULL + local nSrfExt = EgtGetFirstNameInGroup( nCrvGrp, LAYER_SRF) or GDB_ID.NULL -- trim grossolano dei setti - local nTrimGrp = TrimRibs( vOrigRibs, nRibsGrp, nSrfExt, LayerParams.dOffs, LayerParams.vtSlicing) + local nTrimGrp = TrimRibs( vOrigRibs, nRibsGrp, nSrfExt, LayerParams.dOffs + LayerParams.dStrand, LayerParams.vtSlicing) -- calcolo offset orientati local nOffsGrp = ComputeRibsOrientedOffset( nTrimGrp, LayerParams.dStrand) @@ -1518,7 +1542,7 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, nIdx, vPtStart) else local nCrv, nCnt if tSurfOffs[nType][nOverlap] == GDB_ID.NULL then - -- caso unbounded + -- caso unbounded o esterno in assenza di solido nCrv = nCrvId nCnt = 1 else @@ -1560,7 +1584,6 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, nIdx, vPtStart) EgtSetInfo( nCrv + nInd, KEY_SPLIT_AFTER_TRIM_TOT, nCnt) end end - end end end @@ -2108,7 +2131,7 @@ function CalcPaths.Exec( nPartId) local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*") if not vLayIds then EgtOutBox( 'Error no slice', 'PathCalc') - return + return end -- recupero i parametri per calcolo dei path diff --git a/LuaLibs/CalcSlices.lua b/LuaLibs/CalcSlices.lua index 049d8df..60c4195 100644 --- a/LuaLibs/CalcSlices.lua +++ b/LuaLibs/CalcSlices.lua @@ -16,12 +16,8 @@ local AMD = require( 'AddManData') local s_nPartId --------------------------------------------------------------------- -local function ComputeZSlices( dZmin, dDeltaZ, dZmax) - local dSliceStep = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd') or 10000 - if dSliceStep < GEO.EPS_SMALL then - EgtOutLog( 'Warning : SliceStep is 0') - return - end +local function ComputeZSlices( dSliceStep, dZmin, dDeltaZ, dZmax) + local ptSlices = { dZmin + dDeltaZ} local dPosZ = dZmin + dSliceStep while dPosZ < dZmax do @@ -32,9 +28,15 @@ local function ComputeZSlices( dZmin, dDeltaZ, dZmax) end -------------------------------------------------------------------- -local function ComputeMaxH( nStmId, frSlicing, HMax) +local function ComputeMaxH( vIds, frSlicing, HMax, dSliceStep) + + -- calcolo il box globale + local b3BoxGlob = BBox3d() + for i = 1, #vIds do + local b3Box = EgtGetBBoxGlob( vIds[i], GDB_BB.STANDARD) + b3BoxGlob:Add( b3Box) + end - local b3BoxGlob = EgtGetBBoxGlob( nStmId, GDB_BB.STANDARD) if b3BoxGlob:getMax():getZ() < b3BoxGlob:getMin():getZ() + HMax + GEO.EPS_SMALL then return GEO.INFINITO end @@ -43,17 +45,27 @@ local function ComputeMaxH( nStmId, frSlicing, HMax) return HMax else -- se slicing inclinato - local nGrpTmp = EgtGroup( EgtGetParent( nStmId)) - local nNewId, nPnt, nCrv, nSrf = EgtPlaneSurfTmInters( Point3d( 0, 0, HMax), Z_AX(), nStmId, nGrpTmp) - if not nNewId then - return GEO.INFINITO + local nGrpTmp = EgtGroup( s_nPartId) + for i = 1, #vIds do + EgtPlaneSurfTmInters( Point3d( 0, 0, HMax), Z_AX(), vIds[i], nGrpTmp, GDB_RT.GLOB) end local b3Box = EgtGetBBoxGlob( nGrpTmp, GDB_BB.STANDARD) EgtErase( nGrpTmp) + if not b3Box then + return GEO.INFINITO + end local ptMin = b3Box:getMin() + local ptMax = b3Box:getMax() + -- la quota dell'ultimo slice è più bassa di dSliceStep rispetto alla quota dell'ultimo toolpath + -- ( andrebbe anche considerata dCorrZ) + ptMin = ptMin - dSliceStep * frSlicing:getVersZ() + ptMax = ptMax - dSliceStep * frSlicing:getVersZ() ptMin:toLoc( frSlicing) - return ptMin:getZ() + ptMax:toLoc( frSlicing) + + return min( ptMin:getZ(), ptMax:getZ()) end + return GEO.INFINITO end @@ -93,31 +105,38 @@ local function AdjustAuxSolids( nSolidsLay) end -------------------------------------------------------------------- -local function ReadParam( nId, sKey, sType, table, defVal) +local function ReadParam( nId, sKey, sType, defVal, table) + -- verifico se info nell'oggetto specifico local info = EgtGetInfo( nId, sKey, sType) + -- altrimenti recupero info dai parametri generali if info == nil then info = EgtGetInfo( s_nPartId, sKey, sType) end + -- o assegno valore di default if info == nil then info = defVal end - table[sKey] = info + + -- se presente, inserisco l'info nella tabella + if table then table[sKey] = info end + + return info end -------------------------------------------------------------------- local function GetRibParams( nId) local RibParam = {} - ReadParam( nId, KEY_RIBS_SHELLS_NBR, 'i', RibParam) - ReadParam( nId, KEY_RIBS_INVERT_DIR, 'b', RibParam) - ReadParam( nId, KEY_RIBS_LEAD_IN_INVERT, 'b', RibParam) - ReadParam( nId, KEY_RIBS_LEAD_IN_LEN, 'd', RibParam) - ReadParam( nId, KEY_RIBS_LEAD_OUT_INVERT, 'b', RibParam) - ReadParam( nId, KEY_RIBS_LEAD_OUT_LEN, 'd', RibParam) - ReadParam( nId, KEY_RIBS_LEAD_OUT_COASTING, 'd', RibParam) - ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE, 'd', RibParam) - ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd', RibParam) - ReadParam( nId, KEY_RIBS_OVERLAP, 'i', RibParam) - ReadParam( nId, KEY_RIBS_LINK, 'b', RibParam) - ReadParam( nId, KEY_RIBS_TYPE, 'i', RibParam, RIB_TYPE.INTERNAL) - ReadParam( nId, KEY_RIBS_INVERT_STRAND_ORDER, 'b', RibParam) - + ReadParam( nId, KEY_RIBS_SHELLS_NBR, 'i', 0, RibParam) + ReadParam( nId, KEY_RIBS_INVERT_DIR, 'b', false, RibParam) + ReadParam( nId, KEY_RIBS_LEAD_IN_INVERT, 'b', false, RibParam) + ReadParam( nId, KEY_RIBS_LEAD_IN_LEN, 'd', 0, RibParam) + ReadParam( nId, KEY_RIBS_LEAD_OUT_INVERT, 'b', false, RibParam) + ReadParam( nId, KEY_RIBS_LEAD_OUT_LEN, 'd', 0, RibParam) + ReadParam( nId, KEY_RIBS_LEAD_OUT_COASTING, 'd', 0, RibParam) + ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE, 'd', 0, RibParam) + ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd', 0, RibParam) + ReadParam( nId, KEY_RIBS_OVERLAP, 'i', 0, RibParam) + ReadParam( nId, KEY_RIBS_LINK, 'b', false, RibParam) + ReadParam( nId, KEY_RIBS_TYPE, 'i', RIB_TYPE.INTERNAL, RibParam) + ReadParam( nId, KEY_RIBS_INVERT_STRAND_ORDER, 'b', false, RibParam) + return RibParam end @@ -125,10 +144,10 @@ end local function GetShellNumberParams( nId) local ShellNumberParam = {} - ReadParam( nId, KEY_SHELL_NBR_DIFF, 'i', ShellNumberParam) - ReadParam( nId, KEY_SHELL_NBR_COASTING, 'd', ShellNumberParam) - ReadParam( nId, KEY_SHELL_NBR_WIPE, 'd', ShellNumberParam) - ReadParam( nId, KEY_SHELL_NBR_WIPE_DIR, 'd', ShellNumberParam) + ReadParam( nId, KEY_SHELL_NBR_DIFF, 'i', 0, ShellNumberParam) + ReadParam( nId, KEY_SHELL_NBR_COASTING, 'd', 0, ShellNumberParam) + ReadParam( nId, KEY_SHELL_NBR_WIPE, 'd', 0, ShellNumberParam) + ReadParam( nId, KEY_SHELL_NBR_WIPE_DIR, 'd', 0, ShellNumberParam) return ShellNumberParam end @@ -137,16 +156,15 @@ end local function GetAuxSolidsParams( nId) local AuxSolidsParam = {} - ReadParam( nId, KEY_AUX_SOLIDS_OVERLAP, 'i', AuxSolidsParam) - ReadParam( nId, KEY_AUX_SOLIDS_LINK_PARAM, 'd', AuxSolidsParam) - ReadParam( nId, KEY_AUX_SOLIDS_SP_OFFSET, 'd', AuxSolidsParam) - ReadParam( nId, KEY_AUX_SOLIDS_COASTING_LEN, 'd', AuxSolidsParam) - ReadParam( nId, KEY_AUX_SOLIDS_WIPE_LEN, 'd', AuxSolidsParam) - ReadParam( nId, KEY_AUX_SOLIDS_WIPE_DIR, 'd', AuxSolidsParam) - - ReadParam( nId, KEY_AUX_SOLIDS_INFILL, 'i', AuxSolidsParam) - ReadParam( nId, KEY_AUX_SOLIDS_PRINT_ORDER, 'i', AuxSolidsParam) - ReadParam( nId, KEY_AUX_SOLIDS_LINK_TYPE, 'i', AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_OVERLAP, 'i', 0, AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_LINK_PARAM, 'd', 0, AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_SP_OFFSET, 'd', 0, AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_COASTING_LEN, 'd', 0, AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_WIPE_LEN, 'd', 0, AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_WIPE_DIR, 'd', 0, AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_INFILL, 'i', INFILL_TYPE.NONE, AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_PRINT_ORDER, 'i', PRINT_ORDER.EXT_INT, AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_LINK_TYPE, 'i', LINK_TYPE.NONE, AuxSolidsParam) return AuxSolidsParam end @@ -253,7 +271,7 @@ local function SlicingExtraObjects( vtSlicing, nLay, nType, sNameGrp, sName) end nLayId = EgtGetNextName( nLayId, SLICE_LAYER .. '*') end - + return true end @@ -268,88 +286,88 @@ local function ValueInArray( vArr, nValue) end --------------------------------------------------------------------- -function CalcSlices.Exec( nPartId, nStmId, HMax) +local function SlicingNoSolid( nRibsLay, vZSlices, dDeltaZStart, dZmin, frSlicing) + + local vErr = {} + local vtSlicing = frSlicing:getVersZ() + + -- contatore per il calcolo delle intersezioni + if EgtProcessEvents( 100, 0) == 1 then return end + -- creo i layer dello slicing + for i = 1, #vZSlices do + local nLayGrp = EgtGroup( s_nPartId) + EgtSetName( nLayGrp, SLICE_LAYER .. tostring( i)) + + local dDeltaZ = EgtIf( i == 1, dDeltaZStart, 0) + local dPosZ = vZSlices[i]- dDeltaZ + EgtSetInfo( nLayGrp, KEY_SLICE_Z, dPosZ - dZmin) + EgtSetInfo( nLayGrp, KEY_SLICE_REAL_Z, dPosZ) + EgtSetInfo( nLayGrp, KEY_SLICE_DELTAZ, dDeltaZ) + EgtSetInfo( nLayGrp, KEY_SLICE_NBR, i) + + local nGrpCrv = EgtGroup( nLayGrp) + EgtSetName( nGrpCrv, CONTOUR_GRP .. EgtNumToString( 0)) + end + if EgtProcessEvents( EgtIf( PRINT, 100, 0) + 20, 0) == 1 then return end + + -- slicing dei setti + SlicingExtraObjects( vtSlicing, nRibsLay, TYPE.RIB, RIBS_GRP, RIBS_CRV) + if EgtProcessEvents( EgtIf( PRINT, 100, 0) + 100, 0) == 1 then return end + + return vErr +end + +--------------------------------------------------------------------- +local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicing) + -- costanti local TOLER = 0.05 local MID_TOLER = 0.1 local BIG_TOLER = 2.0 local MIN_LEN = 20.0 local MIN_AREA = 25.0 - - s_nPartId = nPartId - - -- recupero la direzione dello slicing - local vtSlicing = Z_AX() - local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i') - if nSlicingType == SLICING_TYPE.DEG45_X then - vtSlicing = VectorFromSpherical( 1, 45, 0) - elseif nSlicingType == SLICING_TYPE.DEG45_Y then - vtSlicing = VectorFromSpherical( 1, 45, -90) - elseif nSlicingType == SLICING_TYPE.HORIZONTAL then - vtSlicing = X_AX() - end - - EgtSetInfo( s_nPartId, KEY_SLICING_DIR, vtSlicing) - local frSlicing = Frame3d( ORIG(), vtSlicing) - - -- recupero il box della superficie - local b3Box = EgtGetBBoxRef( nStmId, GDB_BB.STANDARD, frSlicing) - if not b3Box or b3Box:isEmpty() then - EgtOutText( 'La superficie selezionata è vuota') - EgtPause( 1000) - return - end - - -- Parametri di slicing - local dZmin = b3Box:getMin():getZ() - local dZmax = b3Box:getMax():getZ() - local dMaxH = ComputeMaxH( nStmId, frSlicing, HMax) - dZmax = min( dZmax, dMaxH) - --dZmin = 708 - --dZmax = 712 - - -- Eseguo slicing - local nLayCnt = 1 - local nRecalc = 0 - local dDeltaZStart = 0.2 - --dDeltaZStart = 0 - - local vZSlices = ComputeZSlices( dZmin, dDeltaZStart, dZmax) - if EgtProcessEvents( 1, 0) == 1 then return end - local nLayId = EgtParPlanesSurfTmInters( ORIG(), vtSlicing, vZSlices, nStmId, nPartId, GDB_RT.GLOB, TOLER) - if EgtProcessEvents( 100, 0) == 1 then return end local vErr = {} + local vtSlicing = frSlicing:getVersZ() + + -- calcolo delle intersezioni + if EgtProcessEvents( 1, 0) == 1 then return end + local nLayId = EgtParPlanesSurfTmInters( ORIG(), vtSlicing, vZSlices, nStmId, s_nPartId, GDB_RT.GLOB, TOLER) + if EgtProcessEvents( 100, 0) == 1 then return end + local vPrevCen = {} + local nLayCnt = 1 + -- scorro i risultati dello slicing while nLayId do - local dDeltaZ = EgtIf( nLayCnt == 1, dDeltaZStart, 0) + local dDeltaZ = EgtIf( nLayCnt == 1, dDeltaZStart, 0) local dPosZ = vZSlices[nLayCnt]- dDeltaZ EgtSetInfo( nLayId, KEY_SLICE_Z, dPosZ - dZmin) EgtSetInfo( nLayId, KEY_SLICE_REAL_Z, dPosZ) EgtSetInfo( nLayId, KEY_SLICE_NBR, nLayCnt) - -- verifico se necessario ricalcolo - local nId = EgtGetLastInGroup( nLayId) - local bRecalc = not nId + -- verifico se necessario ricalcolo + local nId = EgtGetLastInGroup( nLayId) + local bRecalc = not nId local vtRecalc + local nRecalc = 0 while nId and not bRecalc do local nType = EgtGetType( nId) if nType == GDB_TY.SRF_MESH then - bRecalc = true + bRecalc = true vtRecalc = EgtSurfTmFacetNormVersor( nId, 0) elseif nType == GDB_TY.GEO_POINT then - bRecalc = true + bRecalc = true end nId = EgtGetPrev( nId) end - -- eseguo eventuale ricalcolo + -- eseguo eventuale ricalcolo ::RECALC:: if bRecalc then nRecalc = nRecalc + 1 - EgtEmptyGroup( nLayId) + EgtEmptyGroup( nLayId) dDeltaZ = dDeltaZ + EgtIf( vtRecalc and vtRecalc:getZ() > 0, -0.01, 0.01) -- eseguo il ricalcolo solo a quella quota EgtPlaneSurfTmInters( ORIG() + ( dPosZ + dDeltaZ) * vtSlicing, vtSlicing, nStmId, nLayId, GDB_RT.GLOB, TOLER) @@ -369,7 +387,7 @@ function CalcSlices.Exec( nPartId, nStmId, HMax) -- correggo eventuali spostamenti in Z if abs( dDeltaZ) > GEO.EPS_SMALL then EgtMove( nId, - dDeltaZ * vtSlicing) - end + end -- verifico presenza contorni aperti if EgtCurveIsClosed( nId) then table.insert( vClosedId, nId) @@ -419,19 +437,19 @@ function CalcSlices.Exec( nPartId, nStmId, HMax) table.remove( vClosedId, i) end end - + -- se necessario e possibile, torno a ricalcolo if not bAllClosed and nRecalc < 2 then bRecalc = true goto RECALC end - + -- imposto dati ausiliari EgtSetName( nLayId, EgtIf( bAllClosed, '', '__') .. SLICE_LAYER .. EgtNumToString( nLayCnt)) EgtSetInfo( nLayId, 'CrvCnt', #vClosedId + #vOpenId) EgtSetColor( vClosedId or {}, 'TEAL') EgtSetColor( vOpenId or {}, 'RED') - + -- creo flat region a partire dalle curve chiuse ottenute con lo slicing local nGrp = EgtGroup( nLayId, frSlicing, GDB_RT.GLOB) for i = 1, #vClosedId do @@ -441,7 +459,7 @@ function CalcSlices.Exec( nPartId, nStmId, HMax) end EgtErase( nGrp) local nSurfFR, nSrfNbr = EgtSurfFlatRegion( nLayId, vClosedId) - + if nSurfFR then -- verifico orientamento della normale local vtN = EgtSurfFrNormVersor( nSurfFR, GDB_ID.ROOT) @@ -530,9 +548,10 @@ function CalcSlices.Exec( nPartId, nStmId, HMax) end end else + local bErr = true -- se nessuna curva - if #vClosedId == 0 then + if #vClosedId == 0 and #vOpenId == 0 then bErr = false -- se una sola curva, ne verifico larghezza media elseif #vClosedId == 1 then @@ -540,29 +559,34 @@ function CalcSlices.Exec( nPartId, nStmId, HMax) local _, _, dArea = EgtCurveArea( vClosedId[1]) if not dArea or dArea / dLen < MID_TOLER then bErr = false end end - -- cambio nome al layer - EgtSetName( nLayId, '__' .. SLICE_LAYER .. EgtNumToString( nLayCnt)) + -- se vero errore lo segnalo if bErr then table.insert( vErr, nLayCnt) + -- cambio nome al layer + EgtSetName( nLayId, '__' .. SLICE_LAYER .. EgtNumToString( nLayCnt)) + else + -- altrimenti creo il CrvGrp da utilizzare nel CalcPath + local nGrpCrv = EgtGroup( nLayId) + EgtSetName( nGrpCrv, CONTOUR_GRP .. EgtNumToString( 1)) end - end - + end + -- passo al layer successivo if EgtProcessEvents( EgtIf( PRINT, 100, 0) + nLayCnt / ( #vZSlices + 3) * 100, 0) == 1 then EgtDraw() - return + return end - nLayCnt = nLayCnt + 1 + nLayCnt = nLayCnt + 1 nLayId = EgtGetNext( nLayId) end - + 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) + 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 @@ -582,10 +606,87 @@ function CalcSlices.Exec( nPartId, nStmId, HMax) if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 3) / ( #vZSlices + 3) * 100, 0) == 1 then return end end - -- eventuale segnalazione errori - if #vErr > 0 then - EgtOutBox( 'Slicing Error on layers :\n' .. table.concat( vErr, ','), 'SlicingCalc') + return vErr +end + +--------------------------------------------------------------------- +function CalcSlices.Exec( nPartId, nStmId, HMax) + + s_nPartId = nPartId + + -- recupero la direzione dello slicing + local vtSlicing = Z_AX() + local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i') + if nSlicingType == SLICING_TYPE.DEG45_X then + vtSlicing = VectorFromSpherical( 1, 45, 0) + elseif nSlicingType == SLICING_TYPE.DEG45_Y then + vtSlicing = VectorFromSpherical( 1, 45, -90) + elseif nSlicingType == SLICING_TYPE.HORIZONTAL then + vtSlicing = X_AX() end + + EgtSetInfo( s_nPartId, KEY_SLICING_DIR, vtSlicing) + local frSlicing = Frame3d( ORIG(), vtSlicing) + + -- recupero la superficie ed eventuali setti esterni/unbounded da usare come riferimenti per quote slicing + local vRefIds = {} + if nStmId then table.insert( vRefIds, nStmId) end + local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS) + local vRibsIds = EgtGetAllInGroup( nRibsLay) + for i = 1, #vRibsIds do + if EgtGetType( vRibsIds[i]) == GDB_TY.SRF_MESH then + local nType = ReadParam( vRibsIds[i], KEY_RIBS_TYPE, 'i', RIB_TYPE.INTERNAL) + if nType == RIB_TYPE.EXTERNAL or nType == RIB_TYPE.UNBOUNDED then + table.insert( vRefIds, vRibsIds[i]) + end + end + end + + -- recupero il box + local b3Box = BBox3d() + for i = 1, #vRefIds do + local b3Tmp = EgtGetBBoxRef( vRefIds[i], GDB_BB.STANDARD, frSlicing) + b3Box:Add( b3Tmp) + end + if not b3Box or b3Box:isEmpty() then + EgtOutBox( "No part to be sliced!", 'Error', 'ERROR') + return + end + + -- Parametri di slicing + local dSliceStep = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd') or 10000 + if dSliceStep < GEO.EPS_SMALL then + EgtOutLog( 'Warning : SliceStep is 0') + return + end + + local dZmin = b3Box:getMin():getZ() + local dZmax = b3Box:getMax():getZ() + local dMaxH = ComputeMaxH( vRefIds, frSlicing, HMax, dSliceStep) + dZmax = min( dZmax, dMaxH) + --dZmin = 708 + --dZmax = 712 + + -- Eseguo slicing + local nLayCnt = 1 + local nRecalc = 0 + local dDeltaZStart = 0.2 + + local vZSlices = ComputeZSlices( dSliceStep, dZmin, dDeltaZStart, dZmax) + + local vErr + if not nStmId then + -- caso senza solido e solo setti + vErr = SlicingNoSolid( nRibsLay, vZSlices, dDeltaZStart, dZmin, frSlicing) + else + -- caso con solido + vErr = SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicing) + end + + -- eventuale segnalazione errori + if vErr and #vErr > 0 then + EgtOutBox( 'Slicing Error on layers :\n' .. table.concat( vErr, ','), 'SlicingCalc') + end end --------------------------------------------------------------------- diff --git a/LuaLibs/CalcToolPath.lua b/LuaLibs/CalcToolPath.lua index eade0d3..15811ae 100644 --- a/LuaLibs/CalcToolPath.lua +++ b/LuaLibs/CalcToolPath.lua @@ -46,24 +46,49 @@ local function GetLayerParamsForToolPathCalc() 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() - -- altezza necessaria per ugello - s_dHMin = LayerParams.dTDiam / 2 * dNxy - -- 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) +------------------------------------------------------------------ +local function ComputeToolPathBox( nTpathGrpId) + + -- calcolo il box del toolpath (escludendo i wipe) + local b3Box = BBox3d() + local nEntId = EgtGetFirstInGroup( nTpathGrpId) + while nEntId do + if EgtGetInfo( nEntId, KEY_TYPE, 'i') ~= TYPE.WIPE then + local b3Ent = EgtGetBBoxGlob( nEntId, GDB_BB.STANDARD) + b3Box:Add( b3Ent) + end + nEntId = EgtGetNext( nEntId) + end + + return b3Box +end + +------------------------------------------------------------------ +local function AddZCorrection( b3Box, LayerParams) + + local dNxy = sqrt( LayerParams.vtSlicing:getX() * LayerParams.vtSlicing:getX() + LayerParams.vtSlicing:getY() * LayerParams.vtSlicing:getY()) + local dNz = LayerParams.vtSlicing:getZ() + -- altezza necessaria per lo strand + local dHStrand = 0.5 * LayerParams.dStrand * dNxy + LayerParams.dLayHeight * dNz + -- altezza necessaria per il tool + local dHTool = s_dHMin + -- altezza disponibile + local dHDisp = b3Box:getMin():getZ() + + local dCorrZ = max( 0, max( dHStrand, dHTool) - dHDisp) + + -- applico la correzione al pezzo + local vtMove = dCorrZ * Z_AX() + EgtMove( s_nPartId, vtMove, GDB_RT.GLOB) + EgtSetInfo( s_nPartId, KEY_MOVED_PART2, vtMove) + -- correggo la posizione del riferimento + local nFrameId = EgtGetFirstNameInGroup( s_nPartId, LAY_FRAME) + EgtMove( nFrameId, - vtMove, GDB_RT.GLOB) + end ------------------------------------------------------------------- -local function AddCurvesToToolPath( vEntIds, nTpathGrpId, nOrder, bInvert, vtSlicing, dLayHeight, dCorrZ) +local function AddCurvesToToolPath( vEntIds, nTpathGrpId, nOrder, bInvert, vtSlicing, dLayHeight) local vIds = {} -- vettore con gli id ordinati delle curve nel gruppo dei ToolPath @@ -79,8 +104,6 @@ local function AddCurvesToToolPath( vEntIds, nTpathGrpId, nOrder, bInvert, vtSli 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) @@ -371,12 +394,12 @@ local function AddRetractionOnLastCrv( nCrvId, nTpathGrpId, LayerParams, dCoasti end --------------------------------------------------------------------- -local function CalcShellsToolPath( vEntIds, nTpathGrpId, LayerParams, dCorrZ) +local function CalcShellsToolPath( vEntIds, nTpathGrpId, LayerParams) 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) + local vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, LayerParams.nOrder, LayerParams.bInvert, LayerParams.vtSlicing, LayerParams.dLayHeight) local nFirstCopy = EgtCopyGlob( vIds[1], nTpathGrpId) -- necessaria per corretto offset lead point sulla shell esterna -- aggiungo gli opportuni raccordi @@ -407,11 +430,11 @@ local function CalcShellsToolPath( vEntIds, nTpathGrpId, LayerParams, dCorrZ) end --------------------------------------------------------------------- -local function CalcExtraShellToolPath( vEntIds, nTpathGrpId, LayerParams, dCorrZ) +local function CalcExtraShellToolPath( vEntIds, nTpathGrpId, LayerParams) if not vEntIds then return end -- aggiungo le curve nel toolpath - local vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, PRINT_ORDER.EXT_INT, false, LayerParams.vtSlicing, LayerParams.dLayHeight, dCorrZ) + local vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, PRINT_ORDER.EXT_INT, false, LayerParams.vtSlicing, LayerParams.dLayHeight) -- aggiungo gli opportuni raccordi local sPrevName = EgtGetName( vIds[1]) @@ -462,11 +485,11 @@ local function CalcExtraShellToolPath( vEntIds, nTpathGrpId, LayerParams, dCorrZ end --------------------------------------------------------------------- -local function CalcInfillToolPath( vEntIds, nTpathGrpId, LayerParams, dCorrZ) +local function CalcInfillToolPath( vEntIds, nTpathGrpId, LayerParams) 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) + local vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, LayerParams.nOrder, LayerParams.bInvert, LayerParams.vtSlicing, LayerParams.dLayHeight) -- aggiungo eventuali link AddLink( vIds, nTpathGrpId, LayerParams.nLinkType, LayerParams.dLinkParam, LayerParams.dSPOffs, LayerParams.dStrand, LayerParams.vtSlicing) @@ -481,7 +504,7 @@ local function CalcInfillToolPath( vEntIds, nTpathGrpId, LayerParams, dCorrZ) end --------------------------------------------------------------------- -local function CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGrpId, LayerParams, dCorrZ) +local function CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGrpId, LayerParams) if not nAuxSolidsGrp or not nAuxSolidsPathGrp then return end @@ -507,7 +530,7 @@ local function CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGr 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) + local vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, nOrder, LayerParams.bInvert, LayerParams.vtSlicing, LayerParams.dLayHeight) -- aggiungo link AddLink( vIds, nTpathGrpId, nLinkType, dLinkParam, dSPOffset, LayerParams.dStrand, LayerParams.vtSlicing) @@ -580,8 +603,8 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, dStrand, bForceLink, vtSlic local nCrvId = EgtGetFirstNameInGroup( nLoopGrp, TRIM_SURF_LOOP) -- recupero la curva di offset su cui calcolare link while nCrvId do - local dParS = EgtCurveParamAtPoint( nCrvId, ptS) - local dParE = EgtCurveParamAtPoint( nCrvId, ptE) + local dParS = EgtCurveParamAtPoint( nCrvId, ptS, 10 * GEO.EPS_SMALL) + local dParE = EgtCurveParamAtPoint( nCrvId, ptE, 10 * GEO.EPS_SMALL) if dParS and dParE then local bInvert = false local bClosed = EgtCurveIsClosed( nCrvId) @@ -966,7 +989,7 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing, dStrand, n end --------------------------------------------------------------------- -local function CalcRibsToolPath( nRibsGrp, nTpathGrpId, LayerParams, dCorrZ) +local function CalcRibsToolPath( nRibsGrp, nTpathGrpId, LayerParams) if not nRibsGrp then return end @@ -979,8 +1002,6 @@ local function CalcRibsToolPath( nRibsGrp, nTpathGrpId, LayerParams, dCorrZ) 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) @@ -991,14 +1012,12 @@ local function CalcRibsToolPath( nRibsGrp, nTpathGrpId, LayerParams, dCorrZ) local nLoopGrp = EgtGetFirstGroupInGroup( nRibsGrp) local vLoopIds = EgtGetAllInGroup( nLoopGrp) for i = 1, #vLoopIds do - EgtMove( vLoopIds[i], dCorrZ * Z_AX(), GDB_RT.GLOB) EgtMove( vLoopIds[i], LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) end -- posizono alla quota corretta le superfici usate per i trim local vSrfIds = EgtGetNameInGroup( nRibsGrp, TOT_SHELL_TRIM_SURF) or {} for i = 1, #vSrfIds do - EgtMove( vSrfIds[i], dCorrZ * Z_AX(), GDB_RT.GLOB) EgtMove( vSrfIds[i], LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) end @@ -1100,7 +1119,7 @@ local function AddSpiralVaseLeadOut( nOldId, LayerParams) end --------------------------------------------------------------------- -local function SpiralVase( vLayIds, dCorrZ, LayerParams) +local function SpiralVase( vLayIds, LayerParams) local nOldId, nOldPathId local bFirst = true @@ -1120,6 +1139,7 @@ local function SpiralVase( vLayIds, dCorrZ, LayerParams) EgtSetInfo( nNewLay, KEY_SLICE_Z, dZOld + LayerParams.dLayHeight) end + local b3Tot = BBox3d() -- ciclo sui layer for nIdx = 1, #vLayIds do @@ -1153,15 +1173,14 @@ local function SpiralVase( vLayIds, dCorrZ, LayerParams) local nEntId = EgtGetFirstInGroup( nPathGrpId) while nEntId do local nNewEntId = EgtCopyGlob( nEntId, nTpathGrpId, GDB_IN.LAST_SON) - - -- correggo la posizione del toolpath - local vtMove = dCorrZ * Z_AX() - if nSlicingType == SLICING_TYPE.DEG45_X or nSlicingType == SLICING_TYPE.DEG45_Y then - -- eventuale spostamento dell'altezza layer - vtMove = vtMove + LayerParams.dLayHeight * LayerParams.vtSlicing - end - EgtMove( nNewEntId, vtMove, GDB_RT.GLOB) + local vtMove = V_NULL() + -- eventuale spostamento dell'altezza layer + if nSlicingType == SLICING_TYPE.DEG45_X or nSlicingType == SLICING_TYPE.DEG45_Y then + vtMove = LayerParams.dLayHeight * LayerParams.vtSlicing + EgtMove( nNewEntId, vtMove, GDB_RT.GLOB) + end + EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB) -- eventuale inversione if LayerParams.bInvert then @@ -1207,6 +1226,11 @@ local function SpiralVase( vLayIds, dCorrZ, LayerParams) nOldId = nNewEntId nEntId = EgtGetNext( nEntId) end + + -- aggiorno il box dei toolpath + local b3Box = ComputeToolPathBox( nTpathGrpId) + b3Tot:Add( b3Box) + end if EgtProcessEvents( EgtIf( PRINT, 300, 0) + nIdx / #vLayIds * 100, 0) == 1 then @@ -1218,6 +1242,9 @@ local function SpiralVase( vLayIds, dCorrZ, LayerParams) -- aggiungo uscita, coasting e wipe su ultima curva AddSpiralVaseLeadOut( nOldId, LayerParams) + -- correzione in z + AddZCorrection( b3Tot, LayerParams) + end --------------------------------------------------------------------- @@ -1240,36 +1267,22 @@ function CalcToolPath.Exec( nPartId) -- 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) - -- se slicing a 45° aggiungo correzione anche in direzione dello slicing - local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i') or 1 - if nSlicingType == SLICING_TYPE.DEG45_X or nSlicingType == SLICING_TYPE.DEG45_Y then - vtMove = vtMove + LayerParams.dLayHeight / 2 * LayerParams.vtSlicing - end - local SolidLayId = EgtGetFirstNameInGroup( s_nPartId, PRINT_SOLID) - if SolidLayId then - EgtSetInfo( s_nPartId, KEY_MOVED_PART, vtMove) - local EntId = EgtGetFirstInGroup( SolidLayId) - while EntId do - EgtMove( EntId, vtMove, GDB_RT.GLOB) - EntId = EgtGetNext( EntId) - end - end - end + + -- altezza necessaria per ugello ( per correzione wipe) + local dNxy = sqrt( LayerParams.vtSlicing:getX() * LayerParams.vtSlicing:getX() + LayerParams.vtSlicing:getY() * LayerParams.vtSlicing:getY()) + s_dHMin = LayerParams.dTDiam / 2 * dNxy -- caso spiral vase if LayerParams.bSpiralVase then - SpiralVase( vLayIds, dCorrZ, LayerParams) + SpiralVase( vLayIds, LayerParams) return end + local b3Tot = BBox3d() -- box dei toolpath + -- Ciclo sui layer for nIdx = 1, #vLayIds do - + -- scorro tutti i gruppi di contorni local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*") while nCrvGrpId do @@ -1296,28 +1309,32 @@ function CalcToolPath.Exec( nPartId) if LayerParams.vPrintOrder[j] == PRINT_ELEMENT.SHELL then -- shell local vShellIds = EgtGetNameInGroup( nPathGrpId, SHELL_CRV .. '*') - CalcShellsToolPath( vShellIds, nTpathGrpId, LayerParams, dCorrZ) + CalcShellsToolPath( vShellIds, nTpathGrpId, LayerParams) elseif LayerParams.vPrintOrder[j] == PRINT_ELEMENT.EXTRA_SHELL then -- extra shell local vExtraShellIds = EgtGetNameInGroup( nPathGrpId, EXTRA_SHELL_CRV .. '*') - CalcExtraShellToolPath( vExtraShellIds, nTpathGrpId, LayerParams, dCorrZ) + CalcExtraShellToolPath( vExtraShellIds, nTpathGrpId, LayerParams) elseif LayerParams.vPrintOrder[j] == PRINT_ELEMENT.INFILL then -- infill local vInfillIds = EgtGetNameInGroup( nPathGrpId, INFILL_CRV .. '*') - CalcInfillToolPath( vInfillIds, nTpathGrpId, LayerParams, dCorrZ) + CalcInfillToolPath( vInfillIds, nTpathGrpId, LayerParams) elseif LayerParams.vPrintOrder[j] == PRINT_ELEMENT.AUX_SOLID then -- solidi ausiliari local nAuxSolidsGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], AUX_SOLIDS_GRP) local nAuxSolidsPathGrp = EgtGetFirstNameInGroup( nCrvGrpId, AUX_SOLIDS_GRP) - CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGrpId, LayerParams, dCorrZ) + CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGrpId, LayerParams) else -- costolature local nRibsGrp = EgtGetFirstNameInGroup( nCrvGrpId, RIBS_GRP) - CalcRibsToolPath( nRibsGrp, nTpathGrpId, LayerParams, dCorrZ) + CalcRibsToolPath( nRibsGrp, nTpathGrpId, LayerParams) end end + -- aggiorno il box dei toolpath + local b3Box = ComputeToolPathBox( nTpathGrpId) + b3Tot:Add( b3Box) + -- passo al gruppo di contorni successivo nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*") end @@ -1327,6 +1344,10 @@ function CalcToolPath.Exec( nPartId) return end end + + -- correzione in z + AddZCorrection( b3Tot, LayerParams) + end --------------------------------------------------------------------- diff --git a/LuaLibs/RunSlicing.lua b/LuaLibs/RunSlicing.lua index caeaf47..161ebfd 100644 --- a/LuaLibs/RunSlicing.lua +++ b/LuaLibs/RunSlicing.lua @@ -208,22 +208,33 @@ local function LoadParams( sFile, nPartId) end --------------------------------------------------------------------- -local function RestoreSolidPosition( nPartId) +local function RestoreOriginalPosition( nPartId) if not nPartId then return end - -- recupero vecchio movimento - local vtMove = EgtGetInfo( nPartId, KEY_MOVED_PART, 'v') - if vtMove then - vtMove = -vtMove + + -- correzione solo del solido ( progetti vecchi) + local vtMove1 = EgtGetInfo( nPartId, KEY_MOVED_PART, 'v') + if vtMove1 then + vtMove1 = - vtMove1 EgtRemoveInfo( nPartId, KEY_MOVED_PART) local SolidLayId = EgtGetFirstNameInGroup( nPartId, PRINT_SOLID) if SolidLayId then local EntId = EgtGetFirstInGroup( SolidLayId) while EntId do - EgtMove( EntId, vtMove, GDB_RT.GLOB) + EgtMove( EntId, vtMove1, GDB_RT.GLOB) EntId = EgtGetNext( EntId) end end end + + -- correzione dell'intero pezzo + local vtMove = EgtGetInfo( nPartId, KEY_MOVED_PART2, 'v') + if vtMove then + EgtRemoveInfo( nPartId, KEY_MOVED_PART2) + EgtMove( nPartId, - vtMove, GDB_RT.GLOB) + -- sistemo il riferimento + local nFrameId = EgtGetFirstNameInGroup( nPartId, LAY_FRAME) + EgtMove( nFrameId, vtMove, GDB_RT.GLOB) + end end --------------------------------------------------------------------- @@ -301,9 +312,9 @@ function RunSlicing.Exec() end local nSolidLayId = EgtGetFirstNameInGroup( nPartId, PRINT_SOLID) local nStmId = EgtGetFirstInGroup( nSolidLayId or GDB_ID.NULL) - if not nStmId or EgtGetType( nStmId) ~= GDB_TY.SRF_MESH then - EgtOutBox( "Part without surface!", 'Warning', 'WARNING') - return + if nStmId and EgtGetType( nStmId) ~= GDB_TY.SRF_MESH then + EgtOutBox( "Part without surface!", 'Warning', 'WARNING') + return end local nRibsLayId = EgtGetFirstNameInGroup( nPartId, LAY_RIBS) local nShellNbrLay = EgtGetFirstNameInGroup( nPartId, LAY_SHELL_NBR) @@ -346,8 +357,8 @@ function RunSlicing.Exec() local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini' local HMax = tonumber( EgtGetStringFromIni( '3dPrinting', 'HMax', 500, sMachIni)) - -- Eventuale ripristino posizione solido - RestoreSolidPosition( nPartId) + -- Eventuale ripristino posizione originaria + RestoreOriginalPosition( nPartId) -- Rimozione vecchi conti RemoveOldSlices( nPartId) @@ -360,7 +371,7 @@ function RunSlicing.Exec() EgtDraw() -- Calcolo dei percorsi sul centro strand in basso - CPATHS.Exec( nPartId, nStmId) + CPATHS.Exec( nPartId) EgtDraw() -- Calcolo dei percorsi di lavoro