diff --git a/LuaLibs/AddManData.lua b/LuaLibs/AddManData.lua index 0d9df5a..116aac4 100644 --- a/LuaLibs/AddManData.lua +++ b/LuaLibs/AddManData.lua @@ -1,4 +1,4 @@ --- AddManData.lua by Egaltech s.r.l. 2022/04/12 +-- AddManData.lua by Egaltech s.r.l. 2022/07/03 -- Raccolta costanti generali per Stampa 3d -- Tabella per definizione modulo @@ -31,6 +31,7 @@ MIN_AREA = 0.01 -- Parametri di lavorazione SEC_DEFAULT = "Default" +KEY_PARAMS = "Params" KEY_SLICING_45 = "Slicing45" KEY_SLICING_DIR="SlicingDir" KEY_SLICE_STEP = "StrandH" @@ -67,18 +68,18 @@ KEY_COASTING_FEED = "CoastingFeed" KEY_WIPE_LEN = "WipeLen" KEY_WIPE_FEEDPU = "WipeFeedPu" KEY_TOOL_DIAM = "ToolDiam" -KEY_SETTI_OVERLAP = "SettiOverlap" -KEY_SETTI_SHELLS_NBR = "SettiStrandCount" -KEY_SETTI_LINK = "SettiLink" -KEY_SETTI_INVERT_DIR = "SettiInvertDirection" -KEY_SETTI_INVERT_ORDER = "SettiInvertOrder" -KEY_SETTI_LEAD_IN_INVERT = "SettiLeadInInvert" -KEY_SETTI_LEAD_IN_LEN = "SettiLeadInLen" -KEY_SETTI_LEAD_OUT_INVERT = "SettiLeadOutInvert" -KEY_SETTI_LEAD_OUT_LEN = "SettiLeadOutLen" -KEY_SETTI_LEAD_OUT_WIPE1 = "SettiLeadOutWipeTang" -KEY_SETTI_LEAD_OUT_WIPE2 = "SettiLeadOutWipe" -KEY_SETTI_LEAD_OUT_WIPE_DIR = "SettiLeadOutWipeDir" +KEY_RIBS_OVERLAP = "RibsOverlap" +KEY_RIBS_SHELLS_NBR = "RibsStrandCount" +KEY_RIBS_LINK = "RibsLink" +KEY_RIBS_INVERT_DIR = "RibsInvertDirection" +KEY_RIBS_INVERT_ORDER = "RibsInvertOrder" +KEY_RIBS_LEAD_IN_INVERT = "RibsLeadInInvert" +KEY_RIBS_LEAD_IN_LEN = "RibsLeadInLen" +KEY_RIBS_LEAD_OUT_INVERT = "RibsLeadOutInvert" +KEY_RIBS_LEAD_OUT_LEN = "RibsLeadOutLen" +KEY_RIBS_LEAD_OUT_WIPE1 = "RibsLeadOutWipeTang" +KEY_RIBS_LEAD_OUT_WIPE2 = "RibsLeadOutWipe" +KEY_RIBS_LEAD_OUT_WIPE_DIR = "RibsLeadOutWipeDir" -- Parametri di macchina SEC_3DPRINTING = "3dPrinting" @@ -99,7 +100,7 @@ TYPE = { LINK = 4, COASTING = 5, WIPE = 6, - SETTO = 7, + RIB = 7, } PRINT_ORDER = { @@ -126,14 +127,11 @@ LEAD_TYPE = { --------------------------------------------------------------------- - TABLE = "Table" -TABLE_OUTLINE = "Outline" -TABLE_SURFACE = "Surface" PART = "Part" ORIGINAL_SOLID = "OriginalSolid" LAY_AUX = "Aux" -LAY_WALLS = "Walls" +LAY_RIBS = "Ribs" VIEWPARAMS = 'ViewParams' IMPORTED_SOLID = 'ImportedSolid' RESULT_READ_PROG = 'ResultReadProg' @@ -148,6 +146,8 @@ KEY_SEL_LAYER = 'SelLayer' KEY_SLICE_ADV_MODE = 'SliceAdvMode' KEY_SLICE_ADV_PERC = 'SliceAdvPerc' +KEY_MOVED_PART ='MovedPart' + RESULT = { OK = 1, KO_MINUS = 2, @@ -163,6 +163,7 @@ LAYER_VIEW_TYPE = { ALL = 1, TILL_SEL = 2, ONLY_SEL = 3, + FROM_SEL = 4, } SHELL_VIEW_TYPE = { ALL = 1, @@ -178,8 +179,8 @@ SLICE_ADV_TYPE = { } --------------------------------------------------------------------- -SETTI_GRP="Setti" -SETTI_CRV="Setto" +RIBS_GRP="Ribs" +RIBS_CRV="Rib" --------------------------------------------------------------------- diff --git a/LuaLibs/CalcPaths.lua b/LuaLibs/CalcPaths.lua index 3bfa644..8a10be6 100644 --- a/LuaLibs/CalcPaths.lua +++ b/LuaLibs/CalcPaths.lua @@ -23,10 +23,10 @@ local function GetLayerParamsForPathCalc() LayerParams.dOffs = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd') LayerParams.nFloorNbr = EgtGetInfo( s_nPartId, KEY_FLOOR_NBR, 'i') LayerParams.vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v') - -- parametri setti - LayerParams.dSettiOverlap = EgtGetInfo( s_nPartId, KEY_SETTI_OVERLAP, 'd') - LayerParams.nSettiShellsNbr = EgtGetInfo( s_nPartId, KEY_SETTI_SHELLS_NBR, 'i') - LayerParams.bSettiInvertOrder = EgtGetInfo( s_nPartId, KEY_SETTI_INVERT_ORDER, 'b') + -- parametri costolature + LayerParams.dRibsOverlap = EgtGetInfo( s_nPartId, KEY_RIBS_OVERLAP, 'd') + LayerParams.nRibsShellsNbr = EgtGetInfo( s_nPartId, KEY_RIBS_SHELLS_NBR, 'i') + LayerParams.bRibsInvertOrder = EgtGetInfo( s_nPartId, KEY_RIBS_INVERT_ORDER, 'b') return LayerParams end @@ -102,10 +102,10 @@ local function AddFloor( nSrfId, nGrpId, LayerParams, nFloorNbr) end -------------------------------------------------------------------- -local function ReorderSetti( nGrp, bInvertOrder) +local function ReorderRibs( nGrp, bInvertOrder) EgtSpInit() - local vIds = EgtGetNameInGroup( nGrp, SETTI_CRV .. '*') + local vIds = EgtGetNameInGroup( nGrp, RIBS_CRV .. '*') for i = 1, #vIds do local pt = EgtMP( vIds[i], GDB_RT.GLOB) EgtSpAddPoint( pt:getX(), pt:getY(), pt:getZ(), 0, 0, pt:getX(), pt:getY(), pt:getZ(), 0, 0) @@ -113,47 +113,47 @@ local function ReorderSetti( nGrp, bInvertOrder) local vOrd, dLen = EgtSpCalculate( SHP_TY.OPEN) EgtSpTerminate() - local vOrderedSetti = {} + local vOrderedRibs = {} if bInvertOrder then for i = #vOrd, 1, -1 do - table.insert( vOrderedSetti, vIds[vOrd[i]]) + table.insert( vOrderedRibs, vIds[vOrd[i]]) end else for i = 1, #vOrd do - table.insert( vOrderedSetti, vIds[vOrd[i]]) + table.insert( vOrderedRibs, vIds[vOrd[i]]) end end - return vOrderedSetti + return vOrderedRibs end -------------------------------------------------------------------- -local function CalcSettiPaths( nSliceGrp, nSettiGrp, LayerParams, nStmId) +local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, nStmId) -- calcolo gli offset - local dOffs = ( LayerParams.nSettiShellsNbr - 1) * LayerParams.dStrand / 2 - local nOffsGrp = EgtGroup( nSettiGrp) - local vSetti = EgtGetNameInGroup( nSettiGrp, SETTI_CRV .. '*') - for i = 1, #vSetti do - for k = 0, LayerParams.nSettiShellsNbr - 1 do - local nNewId = EgtOffsetCurveAdv( vSetti[i], - dOffs + k * LayerParams.dStrand) - EgtSetName( nNewId, EgtGetName( vSetti[i])) - EgtSetInfo( nNewId, KEY_TYPE, TYPE.SETTO) + local dOffs = ( LayerParams.nRibsShellsNbr - 1) * LayerParams.dStrand / 2 + local nOffsGrp = EgtGroup( nRibsGrp) + local vRibs = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') + for i = 1, #vRibs do + for k = 0, LayerParams.nRibsShellsNbr - 1 do + local nNewId = EgtOffsetCurveAdv( vRibs[i], - dOffs + k * LayerParams.dStrand) + EgtSetName( nNewId, EgtGetName( vRibs[i])) + EgtSetInfo( nNewId, KEY_TYPE, TYPE.RIB) EgtRelocateGlob( nNewId, nOffsGrp) end end - -- riordino setti - local vOrderedSetti = ReorderSetti( nOffsGrp, LayerParams.bSettiInvertOrder) + -- riordino costolature + local vOrderedRibs = ReorderRibs( nOffsGrp, LayerParams.bRibsInvertOrder) -- scorro i gruppi di curve local nCrvGrp = EgtGetFirstNameInGroup( nSliceGrp, CONTOUR_GRP .. '*') while nCrvGrp do - local nSettiPathGrp = EgtGetFirstNameInGroup( nCrvGrp, SETTI_GRP) - local nSrf = EgtGetFirstNameInGroup( nSettiPathGrp, LAYER_SRF) + local nRibsPathGrp = EgtGetFirstNameInGroup( nCrvGrp, RIBS_GRP) + local nSrf = EgtGetFirstNameInGroup( nRibsPathGrp, LAYER_SRF) if nSrf then - for i = 1, #vOrderedSetti do - local nNewId = EgtCopyGlob( vOrderedSetti[i], nSettiPathGrp) - -- trim dei setti con la regione offsettata + for i = 1, #vOrderedRibs do + local nNewId = EgtCopyGlob( vOrderedRibs[i], nRibsPathGrp) + -- trim delle costole con la regione offsettata local nCrv, nCnt = EgtTrimCurveWithRegion( nNewId, nSrf, true, false) -- elimino tratti troppo corti for nId = nCrv, nCrv + nCnt - 1 do @@ -165,8 +165,8 @@ local function CalcSettiPaths( nSliceGrp, nSettiGrp, LayerParams, nStmId) end end - if not EgtGetFirstNameInGroup( nSettiPathGrp, SETTI_CRV .. '*') then - EgtErase( nSettiPathGrp) + if not EgtGetFirstNameInGroup( nRibsPathGrp, RIBS_CRV .. '*') then + EgtErase( nRibsPathGrp) end nCrvGrp = EgtGetNextName( nCrvGrp, CONTOUR_GRP .. '*') end @@ -188,7 +188,7 @@ function CalcPaths.Exec( nPartId, nStmId) -- scorro tutti i suoi layer for nIdx = 1, #vLayIds do - local nSettiGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], SETTI_GRP) + local nRibsGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], RIBS_GRP) -- scorro tutti i gruppi di contorni local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[nIdx], CONTOUR_GRP.."*") or GDB_ID.NULL @@ -218,7 +218,8 @@ function CalcPaths.Exec( nPartId, nStmId) if not bOk then EgtErase( nSrfId) nSrfId = EgtCopyGlob( nSrf, nCrvGrpId) - bOk = ( EgtSurfFrOffset( nSrfId, -dOffs + 0.05) and EgtSurfFrChunkCount( nSrfId) > 0) + local dNewOffs = dOffs - 0.05 + bOk = ( EgtSurfFrOffset( nSrfId, -dNewOffs) and EgtSurfFrChunkCount( nSrfId) > 0) end -- se offset riuscito, estraggo i contorni (pareti esterne) if bOk then @@ -247,32 +248,32 @@ function CalcPaths.Exec( nPartId, nStmId) EgtErase( nSrfId) end - -- setti - if nSettiGrp then + -- costolature + if nRibsGrp then - -- creo o svuoto il gruppo per i setti - local nSettiPathGrp = EgtGetFirstNameInGroup( nCrvGrpId, SETTI_GRP) - if not nSettiPathGrp then - nSettiPathGrp = EgtGroup( nCrvGrpId) - EgtSetName( nSettiPathGrp, SETTI_GRP) - EgtSetStatus( nSettiPathGrp, GDB_ST.OFF) + -- creo o svuoto il gruppo per le costolature + local nRibsPathGrp = EgtGetFirstNameInGroup( nCrvGrpId, RIBS_GRP) + if not nRibsPathGrp then + nRibsPathGrp = EgtGroup( nCrvGrpId) + EgtSetName( nRibsPathGrp, RIBS_GRP) + EgtSetStatus( nRibsPathGrp, GDB_ST.OFF) else - EgtEmptyGroup( nSettiPathGrp) + EgtEmptyGroup( nRibsPathGrp) end - -- calcolo superficie di offset da usare per i setti - local nSrfId = EgtCopy( nSrf, nSettiPathGrp) - local dOffs = 0.5 * LayerParams.dStrand - LayerParams.dOffs + ( LayerParams.nShellsNbr - 1) * LayerParams.dStrand + ( 1 - LayerParams.dSettiOverlap / 100) * LayerParams.dStrand + -- calcolo superficie di offset da usare per le costolature + local nSrfId = EgtCopy( nSrf, nRibsPathGrp) + local dOffs = 0.5 * LayerParams.dStrand - LayerParams.dOffs + ( LayerParams.nShellsNbr - 1) * LayerParams.dStrand + ( 1 - LayerParams.dRibsOverlap / 100) * LayerParams.dStrand local bOk = ( EgtSurfFrOffset( nSrfId, - dOffs) and EgtSurfFrChunkCount( nSrfId) > 0) if not bOk then EgtErase( nSrfId) - nSrfId = EgtCopyGlob( nSrf, nSettiPathGrp) + nSrfId = EgtCopyGlob( nSrf, nRibsPathGrp) bOk = ( EgtSurfFrOffset( nSrfId, - dOffs + 0.05) and EgtSurfFrChunkCount( nSrfId) > 0) end - -- se non ho una superficie errore ed elimino il gruppo dei setti + -- se non ho una superficie errore ed elimino il gruppo delle costolature if not bOk then - EgtErase( nSettiPathGrp) - EgtOutLog( 'Error on Offset (Setti) (layer '..tostring( nIdx)..') - CalcPaths') + EgtErase( nRibsPathGrp) + EgtOutLog( 'Error on Offset (Ribs) (layer '..tostring( nIdx)..') - CalcPaths') end end @@ -287,9 +288,9 @@ function CalcPaths.Exec( nPartId, nStmId) nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*") or GDB_ID.NULL end - -- sistemo eventuali setti - if nSettiGrp then - CalcSettiPaths( vLayIds[nIdx], nSettiGrp, LayerParams, nStmId) + -- sistemo eventuali costolature + if nRibsGrp then + CalcRibsPaths( vLayIds[nIdx], nRibsGrp, LayerParams, nStmId) end if EgtProcessEvents( nIdx / #vLayIds * 100, 0) == 1 then diff --git a/LuaLibs/CalcSlices.lua b/LuaLibs/CalcSlices.lua index 0dc9611..527e350 100644 --- a/LuaLibs/CalcSlices.lua +++ b/LuaLibs/CalcSlices.lua @@ -54,21 +54,21 @@ local function ComputeMaxH( nStmId, frSlicing, HMax) end -------------------------------------------------------------------- -local function SlicingSetti( vtSlicing, dZmin) +local function SlicingRibs( vtSlicing, dZmin) - local nSettiShells = EgtGetInfo( s_nPartId, KEY_SETTI_SHELLS_NBR, 'i') or 0 - if nSettiShells == 0 then return end - -- recupero le superfici che definiscono i setti - local nWallsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_WALLS) - local vSettiIds = EgtGetAllInGroup( nWallsLay or GDB_ID.NULL) - if not vSettiIds or #vSettiIds == 0 then return end + local nRibsShells = EgtGetInfo( s_nPartId, KEY_RIBS_SHELLS_NBR, 'i') or 0 + if nRibsShells == 0 then return end + -- recupero le superfici che definiscono le nervature + local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS) + local vRibsIds = EgtGetAllInGroup( nRibsLay or GDB_ID.NULL) + if not vRibsIds or #vRibsIds == 0 then return end -- sistemo la direzione normale dei piani - for i = 1, #vSettiIds do - if EgtGetType( vSettiIds[i]) == GDB_TY.SRF_MESH then - local vtN = EgtSurfTmFacetNormVersor( vSettiIds[i], 0) + for i = 1, #vRibsIds do + if EgtGetType( vRibsIds[i]) == GDB_TY.SRF_MESH then + local vtN = EgtSurfTmFacetNormVersor( vRibsIds[i], 0) local dVal = EgtIf( abs( vtN:getX()) > abs( vtN:getY()) - GEO.EPS_SMALL, vtN:getX(), vtN:getY()) if dVal < - GEO.EPS_SMALL then - EgtInvertSurf( vSettiIds[i]) + EgtInvertSurf( vRibsIds[i]) end end end @@ -78,15 +78,15 @@ local function SlicingSetti( vtSlicing, dZmin) -- recupero quota per slicing local dZ = EgtGetInfo( nLayId, KEY_SLICE_Z, 'd') local dDeltaZ = EgtGetInfo( nLayId, KEY_SLICE_DELTAZ, 'd') - -- creo gruppo per i setti + -- creo gruppo per le costolature local nGrp = EgtGroup( nLayId) - EgtSetName( nGrp, SETTI_GRP) + EgtSetName( nGrp, RIBS_GRP) EgtSetStatus( nGrp, GDB_ST.OFF) - for i = 1, #vSettiIds do - if EgtGetType( vSettiIds[i]) == GDB_TY.SRF_MESH then - -- slicing setto - local nNewId, nPntCnt, nCrvCnt, nSrfCnt = EgtPlaneSurfTmInters( ORIG() + ( dZmin + dZ + dDeltaZ) * vtSlicing, vtSlicing, vSettiIds[i], nGrp, GDB_RT.GLOB, TOLER) + for i = 1, #vRibsIds do + if EgtGetType( vRibsIds[i]) == GDB_TY.SRF_MESH then + -- slicing costolatura + local nNewId, nPntCnt, nCrvCnt, nSrfCnt = EgtPlaneSurfTmInters( ORIG() + ( dZmin + dZ + dDeltaZ) * vtSlicing, vtSlicing, vRibsIds[i], nGrp, GDB_RT.GLOB, TOLER) if nNewId then -- rimuovo punti for nId = nNewId, nNewId + nPntCnt -1 do @@ -94,7 +94,7 @@ local function SlicingSetti( vtSlicing, dZmin) end -- rinomino le curve e correggo di DeltaZ for nId = nNewId + nPntCnt, nNewId + nPntCnt + nCrvCnt - 1 do - EgtSetName( nId, SETTI_CRV .. tostring( i)) + EgtSetName( nId, RIBS_CRV .. tostring( i)) EgtMove( nId, - dDeltaZ * vtSlicing) end -- rimuovo superfici @@ -152,16 +152,6 @@ function CalcSlices.Exec( nPartId, nStmId, HMax) --dZmin = 1022 --dZmax = 1023 - -- se slicing già presente lo cancello - for i = 1, 2 do - local sFind = EgtIf( i == 1, '', '__') .. SLICE_LAYER .. "*" - local nOldSliceId = EgtGetFirstNameInGroup( s_nPartId, sFind) - while nOldSliceId do - EgtErase( nOldSliceId) - nOldSliceId = EgtGetFirstNameInGroup( s_nPartId, sFind) - end - end - -- Eseguo slicing local nLayCnt = 1 local nRecalc = 0 @@ -200,7 +190,7 @@ function CalcSlices.Exec( nPartId, nStmId, HMax) -- eseguo il ricalcolo solo a quella quota EgtPlaneSurfTmInters( ORIG() + ( dPosZ + dDeltaZ) * vtSlicing, vtSlicing, nStmId, nLayId, GDB_RT.GLOB, TOLER) end - EgtSetInfo( nLayId, 'DeltaZ', dDeltaZ) + EgtSetInfo( nLayId, KEY_SLICE_DELTAZ, dDeltaZ) -- salvo i risultati nel layer local vClosedId = {} @@ -316,8 +306,8 @@ function CalcSlices.Exec( nPartId, nStmId, HMax) nLayId = EgtGetNext( nLayId) end - -- setti - SlicingSetti( vtSlicing, dZmin) + -- costolature + SlicingRibs( vtSlicing, dZmin) -- eventuale segnalazione errori if #vErr > 0 then diff --git a/LuaLibs/CalcSolids.lua b/LuaLibs/CalcSolids.lua index dfb67ca..03fecc4 100644 --- a/LuaLibs/CalcSolids.lua +++ b/LuaLibs/CalcSolids.lua @@ -134,7 +134,7 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams) Color = EgtStdColor( 'BLUE') elseif nType == TYPE.WIPE then Color = EgtStdColor( 'LIME') - elseif nType == TYPE.SETTO then + elseif nType == TYPE.RIB then Color = EgtStdColor( 'OLIVE') end diff --git a/LuaLibs/CalcToolPath.lua b/LuaLibs/CalcToolPath.lua index cd090b0..92a7ccc 100644 --- a/LuaLibs/CalcToolPath.lua +++ b/LuaLibs/CalcToolPath.lua @@ -37,29 +37,33 @@ local function GetLayerParamsForToolPathCalc() LayerParams.dWipeLen = EgtGetInfo( s_nPartId, KEY_WIPE_LEN, 'd') LayerParams.vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v') LayerParams.dTDiam = EgtGetInfo( s_nPartId, KEY_TOOL_DIAM, 'd') - -- Parametri setti - LayerParams.nSettiShellsNbr = EgtGetInfo( s_nPartId, KEY_SETTI_SHELLS_NBR, 'i') - LayerParams.bSettiLink = EgtGetInfo( s_nPartId, KEY_SETTI_LINK, 'b') - LayerParams.bSettiInvert = EgtGetInfo( s_nPartId, KEY_SETTI_INVERT_DIR, 'b') - LayerParams.bSettiLIInvert = EgtGetInfo( s_nPartId, KEY_SETTI_LEAD_IN_INVERT, 'b') - LayerParams.dSettiLILen = EgtGetInfo( s_nPartId, KEY_SETTI_LEAD_IN_LEN, 'd') - LayerParams.bSettiLOInvert = EgtGetInfo( s_nPartId, KEY_SETTI_LEAD_OUT_INVERT, 'b') - LayerParams.dSettiLOLen = EgtGetInfo( s_nPartId, KEY_SETTI_LEAD_OUT_LEN, 'd') - LayerParams.dSettiLOWipeTang = EgtGetInfo( s_nPartId, KEY_SETTI_LEAD_OUT_WIPE1, 'd') - LayerParams.dSettiLOWipe = EgtGetInfo( s_nPartId, KEY_SETTI_LEAD_OUT_WIPE2, 'd') - LayerParams.dSettiLOWipeAng = EgtGetInfo( s_nPartId, KEY_SETTI_LEAD_OUT_WIPE_DIR, 'd') + -- Parametri costolature + LayerParams.nRibsShellsNbr = EgtGetInfo( s_nPartId, KEY_RIBS_SHELLS_NBR, 'i') + LayerParams.bRibsLink = EgtGetInfo( s_nPartId, KEY_RIBS_LINK, 'b') + LayerParams.bRibsInvert = EgtGetInfo( s_nPartId, KEY_RIBS_INVERT_DIR, 'b') + LayerParams.bRibsLIInvert = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_IN_INVERT, 'b') + LayerParams.dRibsLILen = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_IN_LEN, 'd') + LayerParams.bRibsLOInvert = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_OUT_INVERT, 'b') + LayerParams.dRibsLOLen = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_OUT_LEN, 'd') + LayerParams.dRibsLOWipeTang = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_OUT_WIPE1, 'd') + LayerParams.dRibsLOWipe = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_OUT_WIPE2, 'd') + LayerParams.dRibsLOWipeAng = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd') return LayerParams end -------------------------------------------------------------------- local function ComputeZCorrection( LayerParams) - local _, dAng, _ = SphericalFromVector( LayerParams.vtSlicing) + -- direzione dell'estrusore + local vtN = LayerParams.vtSlicing + local dNxy = sqrt( vtN:getX() * vtN:getX() + vtN:getY() * vtN:getY()) + local dNz = vtN:getZ() -- correzione per l'offset - local dCorr1 = LayerParams.dOffs * sin( dAng) - -- eventuale correzione per il diametro ugello - local dCorr2 = max( LayerParams.dTDiam * 0.5 * sin( dAng) - LayerParams.dLayHeight * cos( dAng) - LayerParams.dStrand * 0.5 * sin( dAng) + 10 * GEO.EPS_SMALL, 0.0) - return dCorr1 + dCorr2 + local dCorr1 = LayerParams.dOffs * dNxy + -- correzione per il diametro dell'ugello + local dCorr2 = ( LayerParams.dOffs - LayerParams.dStrand / 2 + LayerParams.dTDiam / 2) * dNxy - LayerParams.dLayHeight * dNz + -- massimo tra le due + return max( dCorr1, dCorr2) end -------------------------------------------------------------------- @@ -174,7 +178,7 @@ local function AddRetractionOnLastCrv( nTpathGrpId, LayerParams) end -------------------------------------------------------------------- -local function CalcSettiLink( ptS, ptE, nCurr, nLoopGrp, bForceLink) +local function CalcRibsLink( ptS, ptE, nCurr, nLoopGrp, bForceLink) local nCrvId = EgtGetFirstInGroup( nLoopGrp) -- recupero la curva di offset su cui calcolare link @@ -211,7 +215,7 @@ local function CalcSettiLink( ptS, ptE, nCurr, nLoopGrp, bForceLink) end EgtTrimCurveStartEndAtParam( nLinkId, dParS, dParE) - EgtSetInfo( nLinkId, KEY_TYPE, TYPE.SETTO) + EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB) if bInvert then EgtInvertCurve( nLinkId) end if bClosed then @@ -231,16 +235,16 @@ local function CalcSettiLink( ptS, ptE, nCurr, nLoopGrp, bForceLink) -- se non ho trovato un collegamento sul bordo, creo una linea tra ptS e ptE if bForceLink then local nLinkId = EgtCurveCompoFromPoints( EgtGetParent( nCurr), {ptS, ptE}) - EgtSetInfo( nLinkId, KEY_TYPE, TYPE.SETTO) + EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB) EgtRelocateGlob( nLinkId, nCurr, GDB_IN.AFTER) end end -------------------------------------------------------------------- -local function AddSettiLeadIn( nCrv, nLoopsGrp, LayerParams) +local function AddRibsLeadIn( nCrv, nLoopsGrp, LayerParams) - if LayerParams.dSettiLILen < GEO.EPS_SMALL then return end + if LayerParams.dRibsLILen < GEO.EPS_SMALL then return end -- recupero la curva di offset su cui calcolare leadin local ptS = EgtSP( nCrv) @@ -261,9 +265,9 @@ local function AddSettiLeadIn( nCrv, nLoopsGrp, LayerParams) if abs( dParS - dEndPar) < GEO.EPS_SMALL then EgtInvertCurve( nCrvId) elseif abs( dParS) > GEO.EPS_SMALL or bClosed then - -- se ho più tratti possibili scelgo in base al parametro SettiLIInvert + -- se ho più tratti possibili scelgo in base al parametro RibsLIInvert local nNewId = EgtSplitCurveAtParam( nCrvId, dParS) or EgtCopyGlob( nCrvId, nCrv, GDB_IN.BEFORE) - if LayerParams.bSettiLIInvert then + if LayerParams.bRibsLIInvert then EgtInvertCurve( nCrvId) EgtErase( nNewId) else @@ -272,9 +276,9 @@ local function AddSettiLeadIn( nCrv, nLoopsGrp, LayerParams) end end - EgtTrimCurveEndAtLen( nCrvId, LayerParams.dSettiLILen) + EgtTrimCurveEndAtLen( nCrvId, LayerParams.dRibsLILen) EgtInvertCurve( nCrvId) - EgtSetInfo( nCrvId, KEY_TYPE, TYPE.SETTO) + EgtSetInfo( nCrvId, KEY_TYPE, TYPE.RIB) EgtSetName( nCrvId, LEAD_IN_CRV) return end @@ -284,11 +288,11 @@ local function AddSettiLeadIn( nCrv, nLoopsGrp, LayerParams) end -------------------------------------------------------------------- -local function AddSettiLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams) +local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams) - if abs( LayerParams.dSettiLOLen) < GEO.EPS_SMALL and - abs( LayerParams.dSettiLOWipeTang) < GEO.EPS_SMALL and - abs( LayerParams.dSettiLOWipe) < GEO.EPS_SMALL then return end + if abs( LayerParams.dRibsLOLen) < GEO.EPS_SMALL and + abs( LayerParams.dRibsLOWipeTang) < GEO.EPS_SMALL and + abs( LayerParams.dRibsLOWipe) < GEO.EPS_SMALL then return end local ptE = EgtEP( nCrv) -- recupero la curva di offset su cui calcolare lead out @@ -315,8 +319,8 @@ local function AddSettiLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams) EgtInvertCurve( nCrvRef) bInvert = true elseif abs( dParE) > GEO.EPS_SMALL or bClosed then - -- se ho più tratti possibili scelgo in base al parametro SettiLOInvert - bInvert = LayerParams.bSettiLOInvert + -- se ho più tratti possibili scelgo in base al parametro RibsLOInvert + bInvert = LayerParams.bRibsLOInvert local nNewId = EgtSplitCurveAtParam( nCrvRef, dParE) or EgtCopyGlob( nCrvRef, nCrv, GDB_IN.AFTER) if bInvert then EgtInvertCurve( nCrvRef) @@ -330,10 +334,10 @@ local function AddSettiLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams) local vtE = EgtSV( nCrvRef) -- primo tratto ( segue offset con flusso aperto) - if LayerParams.dSettiLOLen > GEO.EPS_SMALL then + if LayerParams.dRibsLOLen > GEO.EPS_SMALL then nCrvLO = EgtCopyGlob( nCrvRef, nCrv, GDB_IN.AFTER) - EgtTrimCurveEndAtLen( nCrvLO, LayerParams.dSettiLOLen) - EgtSetInfo( nCrvLO, KEY_TYPE, TYPE.SETTO) + EgtTrimCurveEndAtLen( nCrvLO, LayerParams.dRibsLOLen) + EgtSetInfo( nCrvLO, KEY_TYPE, TYPE.RIB) EgtSetName( nCrvLO, LEAD_OUT_CRV) -- aggiorno ptE e vtE ptE = EgtEP( nCrvLO) @@ -341,10 +345,10 @@ local function AddSettiLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams) end -- secondo tratto ( segue offset con flusso chiuso) - if LayerParams.dSettiLOWipeTang > GEO.EPS_SMALL then + if LayerParams.dRibsLOWipeTang > GEO.EPS_SMALL then nWipe = EgtCopyGlob( nCrvRef, nCrvLO or nCrv, GDB_IN.AFTER) - EgtTrimCurveStartAtLen( nWipe, LayerParams.dSettiLOLen) - EgtTrimCurveEndAtLen( nWipe, LayerParams.dSettiLOWipeTang) + EgtTrimCurveStartAtLen( nWipe, LayerParams.dRibsLOLen) + EgtTrimCurveEndAtLen( nWipe, LayerParams.dRibsLOWipeTang) -- aggiorno ptE e vtE ptE = EgtEP( nWipe) vtE = EgtEV( nWipe) @@ -352,10 +356,10 @@ local function AddSettiLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams) EgtErase( nCrvRef) -- terzo tratto ( diretto verso esterno con ugello chiuso) - if LayerParams.dSettiLOWipe > GEO.EPS_SMALL then - local dAng = EgtIf( bInvert, 90, - 90) + LayerParams.dSettiLOWipeAng + if LayerParams.dRibsLOWipe > GEO.EPS_SMALL then + local dAng = EgtIf( bInvert, 90, - 90) + LayerParams.dRibsLOWipeAng vtE:rotate( LayerParams.vtSlicing, dAng) - local ptFinal = ptE + vtE * LayerParams.dSettiLOWipe + local ptFinal = ptE + vtE * LayerParams.dRibsLOWipe if nWipe then -- unisco al secondo tratto così da averne uno solo per il wiping EgtAddCurveCompoLine( nWipe, ptFinal) @@ -379,11 +383,11 @@ local function AddSettiLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams) end --------------------------------------------------------------------- -local function CalcSettiToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ) +local function CalcRibsToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ) - local nSettiGrp = EgtGetFirstNameInGroup( nCrvGrp, SETTI_GRP) - -- aggiungo i setti nel toolpath - local vEntIds = EgtGetNameInGroup( nSettiGrp, SETTI_CRV .. '*') + local nRibsGrp = EgtGetFirstNameInGroup( nCrvGrp, RIBS_GRP) + -- aggiungo le costolature nel toolpath + local vEntIds = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') for i = 1, #vEntIds do -- copio entità nel gruppo toolpath local nNewEntId = EgtCopyGlob( vEntIds[i], nTpathGrpId, GDB_IN.LAST_SON) @@ -396,8 +400,8 @@ local function CalcSettiToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ) end -- estraggo i contorni della superficie di offset - local nLoopGrp = EgtGroup( nSettiGrp) - local nSrfId = EgtGetFirstNameInGroup( nSettiGrp, LAYER_SRF) + local nLoopGrp = EgtGroup( nRibsGrp) + local nSrfId = EgtGetFirstNameInGroup( nRibsGrp, LAYER_SRF) local nChunksNbr = EgtSurfFrChunkCount( nSrfId) for i = 0, nChunksNbr do local nRes, nCnt = EgtExtractSurfFrChunkLoops( nSrfId, i, nLoopGrp) @@ -410,67 +414,67 @@ local function CalcSettiToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ) end end - -- recupero i gruppi di setti - local tabSetti = {} - local nFirst = EgtGetFirstNameInGroup( nTpathGrpId, SETTI_CRV .. '*') + -- recupero i gruppi delle costolature + local tabRibs = {} + local nFirst = EgtGetFirstNameInGroup( nTpathGrpId, RIBS_CRV .. '*') while nFirst do local sName = EgtGetName( nFirst) local vIds = EgtGetNameInGroup( nTpathGrpId, sName) - table.insert( tabSetti, vIds) - nFirst = EgtGetNextName( vIds[#vIds], SETTI_CRV .. '*') + table.insert( tabRibs, vIds) + nFirst = EgtGetNextName( vIds[#vIds], RIBS_CRV .. '*') end -- orientamento delle curve - local bInvert = LayerParams.bSettiInvert - for i = 1, #tabSetti do - -- oriento tutte le passate relative ad uno stesso setto - for j = 1, #tabSetti[i] do + local bInvert = LayerParams.bRibsInvert + for i = 1, #tabRibs do + -- oriento tutte le passate relative ad una stessa costolatura + for j = 1, #tabRibs[i] do if ( bInvert and j % 2 == 1) or ( not bInvert and j % 2 == 0) then - EgtInvertCurve( tabSetti[i][j]) + EgtInvertCurve( tabRibs[i][j]) end end - -- aggiorno bInvert per il gruppo di setti successivo - if LayerParams.bSettiLink and LayerParams.nSettiShellsNbr % 2 == 1 then + -- aggiorno bInvert per il gruppo di costolature successivo + if LayerParams.bRibsLink and LayerParams.nRibsShellsNbr % 2 == 1 then bInvert = not bInvert end end -- Link - -- collego le passate di uno stesso setto - for i = 1, #tabSetti do - for j = 1, #tabSetti[i] - 1 do - local ptS = EgtEP( tabSetti[i][j]) - local ptE = EgtSP( tabSetti[i][j + 1]) - CalcSettiLink( ptS, ptE, tabSetti[i][j], nLoopGrp, true) + -- collego le passate di una stessa costolatura + for i = 1, #tabRibs do + for j = 1, #tabRibs[i] - 1 do + local ptS = EgtEP( tabRibs[i][j]) + local ptE = EgtSP( tabRibs[i][j + 1]) + CalcRibsLink( ptS, ptE, tabRibs[i][j], nLoopGrp, true) -- creo link fittizio per eliminare tratto corrispondente sulla curva di offset - local nFakeLink = CalcSettiLink( EgtSP( tabSetti[i][j]), EgtEP( tabSetti[i][j + 1]), tabSetti[i][j], nLoopGrp, false) + local nFakeLink = CalcRibsLink( EgtSP( tabRibs[i][j]), EgtEP( tabRibs[i][j + 1]), tabRibs[i][j], nLoopGrp, false) EgtErase( nFakeLink) end end - -- se necessario collego i diversi setti - if LayerParams.bSettiLink then - for i = 1, #tabSetti - 1 do - local nCnt = #tabSetti[i] - local ptS = EgtEP( tabSetti[i][nCnt]) - local ptE = EgtSP( tabSetti[i + 1][1]) - CalcSettiLink( ptS, ptE, tabSetti[i][nCnt], nLoopGrp, false) + -- se necessario collego le diverse costolature + if LayerParams.bRibsLink then + for i = 1, #tabRibs - 1 do + local nCnt = #tabRibs[i] + local ptS = EgtEP( tabRibs[i][nCnt]) + local ptE = EgtSP( tabRibs[i + 1][1]) + CalcRibsLink( ptS, ptE, tabRibs[i][nCnt], nLoopGrp, false) end end -- leadin/leadout - local nCrvSetto = EgtGetFirstNameInGroup( nTpathGrpId, SETTI_CRV .. '*') - while nCrvSetto do + local nCrvRib = EgtGetFirstNameInGroup( nTpathGrpId, RIBS_CRV .. '*') + while nCrvRib do -- verifico se necessario lead in - local nPrev = EgtGetPrev( nCrvSetto) + local nPrev = EgtGetPrev( nCrvRib) if not nPrev or EgtGetName( nPrev) then - AddSettiLeadIn( nCrvSetto, nLoopGrp, LayerParams) + AddRibsLeadIn( nCrvRib, nLoopGrp, LayerParams) end -- verifico se necessario lead out - local nNext = EgtGetNext( nCrvSetto) + local nNext = EgtGetNext( nCrvRib) if not nNext or EgtGetName( nNext) then - AddSettiLeadOut( nCrvSetto, nTpathGrpId, nLoopGrp, LayerParams) + AddRibsLeadOut( nCrvRib, nTpathGrpId, nLoopGrp, LayerParams) end - nCrvSetto = EgtGetNextName( nCrvSetto, SETTI_CRV .. '*') + nCrvRib = EgtGetNextName( nCrvRib, RIBS_CRV .. '*') end end @@ -495,7 +499,21 @@ 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) + LayerParams.dLayHeight / 2 * LayerParams.vtSlicing + local SolidLayId = EgtGetFirstNameInGroup( s_nPartId, ORIGINAL_SOLID) + if SolidLayId then + EgtSetInfo( s_nPartId, KEY_MOVED_PART, vtMove) + local EntId = EgtGetFirstInGroup( SolidLayId) + while EntId do + EgtMove( EntId, vtMove) + EntId = EgtGetNext( EntId) + end + end + end + -- Ciclo sui layer for nIdx = 1, #vLayIds do @@ -627,10 +645,10 @@ function CalcToolPath.Exec( nPartId) nId = EgtGetNextName( nId, SHELL_CRV .. "*") end - -- sistemo i setti - local nSettiGrp = EgtGetFirstNameInGroup( nCrvGrpId, SETTI_GRP) - if nSettiGrp then - CalcSettiToolPath( nCrvGrpId, nTpathGrpId, LayerParams, dCorrZ) + -- sistemo le costolature + local nRibsGrp = EgtGetFirstNameInGroup( nCrvGrpId, RIBS_GRP) + if nRibsGrp then + CalcRibsToolPath( nCrvGrpId, nTpathGrpId, LayerParams, dCorrZ) end --passo al gruppo di contorni successivo diff --git a/LuaLibs/RunMachiningParamEdit.lua b/LuaLibs/RunMachiningParamEdit.lua index 79e32da..2cf8f29 100644 --- a/LuaLibs/RunMachiningParamEdit.lua +++ b/LuaLibs/RunMachiningParamEdit.lua @@ -12,6 +12,7 @@ EgtOutLog( ' RunMachiningParamEdit started', 1) -- Costanti generali local AMD = require( 'AddManData') +--------------------------------------------------------------------- function RunMachiningParamEdit.Exec() -- recupero cartella delle lavorazioni local sCalcBaseDir = EgtGetStringFromIni( '3dPrinting', 'BaseDir', 'C:\\ProgramData\\Egaltech\\EgtCam5\\3dPrinting', EgtGetIniFile()) diff --git a/LuaLibs/RunMaterialParamEdit.lua b/LuaLibs/RunMaterialParamEdit.lua index 885db86..eb8ad75 100644 --- a/LuaLibs/RunMaterialParamEdit.lua +++ b/LuaLibs/RunMaterialParamEdit.lua @@ -12,6 +12,7 @@ EgtOutLog( ' RunMaterialParamEdit started', 1) -- Costanti generali local AMD = require( 'AddManData') +--------------------------------------------------------------------- function RunMaterialParamEdit.Exec() -- recupero cartella dei materiali local sCalcBaseDir = EgtGetStringFromIni( '3dPrinting', 'BaseDir', 'C:\\ProgramData\\Egaltech\\EgtCam5\\3dPrinting', EgtGetIniFile()) diff --git a/LuaLibs/RunPartPositioning.lua b/LuaLibs/RunPartPositioning.lua index 83e0236..ea0d57a 100644 --- a/LuaLibs/RunPartPositioning.lua +++ b/LuaLibs/RunPartPositioning.lua @@ -13,6 +13,7 @@ EgtOutLog( ' RunPartPositioning started', 1) -- Costanti generali local AMD = require( 'AddManData') +--------------------------------------------------------------------- function RunPartPositioning.Exec() -- Verifico che la macchina corrente sia adatta alla stampa 3d local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini' @@ -34,7 +35,7 @@ function RunPartPositioning.Exec() return end local sLayer = EgtGetName( nLayerId) - if sLayer == LAY_WALLS then + if sLayer == LAY_RIBS then EgtOutBox( 'No selected solid. Please select a solid before moving it on the table.', 'Warning', 'WARNING') return end @@ -121,9 +122,7 @@ function RunPartPositioning.Exec() local nTabLayer = EgtGroup( nTabPart) EgtSetName( nTabLayer, TABLE) local nTabOutlineId = EgtRectangle2P( nTabLayer, Point3d( 0, 0, 0), Point3d( dTabX, dTabY, 0)) - EgtSetName( nTabOutlineId, TABLE_OUTLINE) local nTabSurfId = EgtSurfFlatRegion( nTabLayer, nTabOutlineId) - EgtSetName( nTabSurfId, TABLE_SURFACE) EgtSetColor( nTabSurfId, 'GRAY') EgtSetAlpha( nTabSurfId, 70) end diff --git a/LuaLibs/RunShowManager.lua b/LuaLibs/RunShowManager.lua index a743f89..46addff 100644 --- a/LuaLibs/RunShowManager.lua +++ b/LuaLibs/RunShowManager.lua @@ -1,4 +1,4 @@ --- RunShowManager.lua by Egaltech s.r.l. 2022/06/28 +-- RunShowManager.lua by Egaltech s.r.l. 2022/07/03 -- Gestione visualizzazione per Stampa 3d -- Tabella per definizione modulo @@ -12,13 +12,15 @@ EgtOutLog( ' RunShowManager started', 1) -- Costanti generali local AMD = require( 'AddManData') +--------------------------------------------------------------------- local function ShowImportedSolid( nPartId, bShow) local nSolidLayId = EgtGetFirstNameInGroup( nPartId, ORIGINAL_SOLID) EgtSetStatus( nSolidLayId or GDB_ID.NULL, EgtIf( bShow, GDB_ST.ON, GDB_ST.OFF)) - local nWallsLayId = EgtGetFirstNameInGroup( nPartId, LAY_WALLS) - EgtSetStatus( nWallsLayId or GDB_ID.NULL, EgtIf( bShow, GDB_ST.ON, GDB_ST.OFF)) + local nRibsLayId = EgtGetFirstNameInGroup( nPartId, LAY_RIBS) + EgtSetStatus( nRibsLayId or GDB_ID.NULL, EgtIf( bShow, GDB_ST.ON, GDB_ST.OFF)) end +--------------------------------------------------------------------- function RunShowManager.Exec() -- Verifico esistenza gruppo stato visualizzazione progetto local nViewId = EgtGetFirstNameInGroup( GDB_ID.ROOT, VIEWPARAMS) @@ -38,20 +40,34 @@ function RunShowManager.Exec() bSolid = EgtGetInfo( nViewId, SOLID_GRP, 'b') bToolPath = EgtGetInfo( nViewId, TOOLPATH_GRP, 'b') end - - ViewValues = EgtDialogBox( 'Show Manager', { 'Imported Solid', 'CK:' .. EgtIf( bImportedSolid, '1', '0')}, - { 'OuterCrv', 'CK:' .. EgtIf( bOuterCrv, '1', '0')}, - { 'Path', 'CK:' .. EgtIf( bPath, '1', '0')}, - { 'Solid', 'CK:' .. EgtIf( bSolid, '1', '0')}, - { 'ToolPath', 'CK:' .. EgtIf( bToolPath, '1', '0')}) - if not ViewValues or #ViewValues < 5 then return end - -- dis/attivo solidi originali - local bCurrImportedSolid = ( ViewValues[1] == '1') - local bCurrOuterCrv = ( ViewValues[2] == '1') - local bCurrPath = ( ViewValues[3] == '1') - local bCurrSolid = ( ViewValues[4] == '1') - local bCurrToolPath = ( ViewValues[5] == '1') + local bCurrImportedSolid = bImportedSolid + local bCurrOuterCrv = bOuterCrv + local bCurrPath = bPath + local bCurrSolid = bSolid + local bCurrToolPath = bToolPath + + if EgtGetUserLevel() == 1 then + local ViewValues = EgtDialogBox( 'Show Manager', { 'Imported Solid', 'CK:' .. EgtIf( bImportedSolid, '1', '0')}, + { 'Solid', 'CK:' .. EgtIf( bSolid, '1', '0')}, + { 'ToolPath', 'CK:' .. EgtIf( bToolPath, '1', '0')}) + if not ViewValues or #ViewValues < 3 then return end + bCurrImportedSolid = ( ViewValues[1] == '1') + bCurrSolid = ( ViewValues[2] == '1') + bCurrToolPath = ( ViewValues[3] == '1') + else + local ViewValues = EgtDialogBox( 'Show Manager', { 'Imported Solid', 'CK:' .. EgtIf( bImportedSolid, '1', '0')}, + { 'OuterCrv', 'CK:' .. EgtIf( bOuterCrv, '1', '0')}, + { 'Path', 'CK:' .. EgtIf( bPath, '1', '0')}, + { 'Solid', 'CK:' .. EgtIf( bSolid, '1', '0')}, + { 'ToolPath', 'CK:' .. EgtIf( bToolPath, '1', '0')}) + if not ViewValues or #ViewValues < 5 then return end + bCurrImportedSolid = ( ViewValues[1] == '1') + bCurrOuterCrv = ( ViewValues[2] == '1') + bCurrPath = ( ViewValues[3] == '1') + bCurrSolid = ( ViewValues[4] == '1') + bCurrToolPath = ( ViewValues[5] == '1') + end -- ciclo sui pezzi local nPartIndex = 1 diff --git a/LuaLibs/RunSliceAdvancement.lua b/LuaLibs/RunSliceAdvancement.lua index 37e0ca5..626d2b4 100644 --- a/LuaLibs/RunSliceAdvancement.lua +++ b/LuaLibs/RunSliceAdvancement.lua @@ -24,6 +24,18 @@ local function ManageSegmentVisibility( SegmentList, nLastActiveIndex, ToHideLis end end +--------------------------------------------------------------------- +local function CalcType( nEntId, nOldType) + local nType = EgtGetInfo( nEntId, KEY_TYPE, 'i') + if not nType or nType == TYPE.LINK or nType == TYPE.COASTING or nType == TYPE.WIPE then + nType = nOldType + end + if nType == TYPE.RIB then + nType = TYPE.INFILL + end + return nType +end + --------------------------------------------------------------------- function RunSliceAdvancement.Exec() -- verifico ci sia almeno uno slice @@ -87,9 +99,7 @@ function RunSliceAdvancement.Exec() local nSurfId = EgtGetFirstInGroup( nSolidId) local nOldType = TYPE.OUTER_SHELL while nSurfId do - local nType = EgtGetInfo( nSurfId, KEY_TYPE, 'i') - if not nType or nType == TYPE.LINK or nType == TYPE.COASTING or nType == TYPE.WIPE then nType = nOldType end - if nType == TYPE.SETTO then nType = TYPE.INFILL end + local nType = CalcType( nSurfId, nOldType) nOldType = nType table.insert( ShellList[nType], nSurfId) nSurfId = EgtGetNext( nSurfId) diff --git a/LuaLibs/RunSlicePalette.lua b/LuaLibs/RunSlicePalette.lua index a0f9be4..03a65c9 100644 --- a/LuaLibs/RunSlicePalette.lua +++ b/LuaLibs/RunSlicePalette.lua @@ -31,7 +31,7 @@ function RunSlicePalette.UpdateColors( nPaletteType) local Color = EgtStdColor( 'GRAY') if nPaletteType == PALETTE_TYPE.IN_OUT then local nType = EgtGetInfo( nSurfId, KEY_TYPE, 'i') - if not nType or nType < TYPE.OUTER_SHELL or nType > TYPE.SETTO then nType = nOldType end + if not nType or nType < TYPE.OUTER_SHELL or nType > TYPE.RIB then nType = nOldType end nOldType = nType -- scelta del colore if nType == TYPE.OUTER_SHELL then @@ -46,7 +46,7 @@ function RunSlicePalette.UpdateColors( nPaletteType) Color = EgtStdColor( 'BLUE') elseif nType == TYPE.WIPE then Color = EgtStdColor( 'LIME') - elseif nType == TYPE.SETTO then + elseif nType == TYPE.RIB then Color = EgtStdColor( 'OLIVE') end else diff --git a/LuaLibs/RunSlicing.lua b/LuaLibs/RunSlicing.lua index 5da3d8a..359cc60 100644 --- a/LuaLibs/RunSlicing.lua +++ b/LuaLibs/RunSlicing.lua @@ -32,6 +32,8 @@ end --------------------------------------------------------------------- local function LoadParams( sFile, nPartId) + EgtSetInfo( nPartId, KEY_PARAMS, sFile) + 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') @@ -113,19 +115,65 @@ local function LoadParams( sFile, nPartId) end EgtSetInfo( nPartId, KEY_START_POINT, ptStart) - -- parametri per setti - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_OVERLAP, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_SHELLS_NBR, '0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_INVERT_DIR, '0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_INVERT_ORDER, '0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_LINK, '0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_LEAD_IN_INVERT, '0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_LEAD_IN_LEN, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_LEAD_OUT_INVERT, '0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_LEAD_OUT_LEN, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_LEAD_OUT_WIPE1, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_LEAD_OUT_WIPE2, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_LEAD_OUT_WIPE_DIR, '0.0') + -- parametri per costolature + SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_OVERLAP, '0.0') + SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_SHELLS_NBR, '0') + SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_INVERT_DIR, '0') + SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_INVERT_ORDER, '0') + SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_LINK, '0') + SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_LEAD_IN_INVERT, '0') + SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_LEAD_IN_LEN, '0.0') + SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_LEAD_OUT_INVERT, '0') + SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_LEAD_OUT_LEN, '0.0') + SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_LEAD_OUT_WIPE1, '0.0') + SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_LEAD_OUT_WIPE2, '0.0') + SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_LEAD_OUT_WIPE_DIR, '0.0') +end + +--------------------------------------------------------------------- +local function RestoreSolidPosition( nPartId) + if not nPartId then return end + -- recupero vecchio movimento + local vtMove = EgtGetInfo( nPartId, KEY_MOVED_PART, 'v') + if vtMove then + vtMove = -vtMove + EgtRemoveInfo( nPartId, KEY_MOVED_PART) + local SolidLayId = EgtGetFirstNameInGroup( nPartId, ORIGINAL_SOLID) + if SolidLayId then + local EntId = EgtGetFirstInGroup( SolidLayId) + while EntId do + EgtMove( EntId, vtMove) + EntId = EgtGetNext( EntId) + end + end + end +end + +--------------------------------------------------------------------- +local function RemoveOldSlices( nPartId) + if not nPartId then return end + -- se slicing già presente lo cancello + for i = 1, 2 do + local sFind = EgtIf( i == 1, '', '__') .. SLICE_LAYER .. "*" + local vOldSliceId = EgtGetNameInGroup( nPartId, sFind) + for i = 1, #( vOldSliceId or {}) do + EgtErase( vOldSliceId[i]) + end + end +end + +--------------------------------------------------------------------- +local function SetViewInfo() + local nViewId = EgtGetFirstNameInGroup( GDB_ID.ROOT, VIEWPARAMS) + if not nViewId then + nViewId = EgtGroup( GDB_ID.ROOT) + EgtSetName( nViewId, VIEWPARAMS) + end + EgtSetInfo( nViewId, IMPORTED_SOLID, false) + EgtSetInfo( nViewId, OUTER_CRV, false) + EgtSetInfo( nViewId, PATH_GRP, false) + EgtSetInfo( nViewId, SOLID_GRP, true) + EgtSetInfo( nViewId, TOOLPATH_GRP, true) end --------------------------------------------------------------------- @@ -156,14 +204,18 @@ function RunSlicing.Exec() EgtOutBox( "Part without surface!", 'Warning', 'WARNING') return end - local nWallsLayId = EgtGetFirstNameInGroup( nPartId, LAY_WALLS) + local nRibsLayId = EgtGetFirstNameInGroup( nPartId, LAY_RIBS) -- Scelta del file dei parametri - local sLastParamFile = EgtGetStringFromIni( '3dPrinting', 'ParamFile', 'C:\\ProgramData\\Egaltech\\EgtCam5\\3dPrinting\\Machinings\\aaa.ini', EgtGetIniFile()) - local sDir = EgtSplitPath( sLastParamFile) - local sParamFile = EgtFileDialog( true, sDir..'*.ini', '*.ini||') + local sPrevParamFile = EgtGetInfo( nPartId, KEY_PARAMS) + if not sPrevParamFile or not EgtExistsFile( sPrevParamFile) then + local sLastParamFile = EgtGetStringFromIni( '3dPrinting', 'ParamFile', '', EgtGetIniFile()) + local sDir = EgtSplitPath( sLastParamFile) + sPrevParamFile = sDir..'*.ini' + end + local sParamFile = EgtFileDialog( true, sPrevParamFile, 'Param Files (*.ini)|*.ini||') if not sParamFile then - EgtOutBox('Error no file', '') + EgtOutBox( 'No param file selected', 'Warning', 'WARNING') return end EgtWriteStringToIni( '3dPrinting', 'ParamFile', sParamFile, EgtGetIniFile()) @@ -178,7 +230,13 @@ function RunSlicing.Exec() -- Lettura dati macchina local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini' local HMax = tonumber( EgtGetStringFromIni( '3dPrinting', 'HMax', 500, sMachIni)) - + + -- Eventuale ripristino posizione solido + RestoreSolidPosition( nPartId) + + -- Rimozione vecchi conti + RemoveOldSlices( nPartId) + -- Calcolo delle fette CSLICES.Exec( nPartId, nStmId, HMax) EgtDraw() @@ -194,20 +252,11 @@ function RunSlicing.Exec() -- Calcolo dei solidi degli strand a partire dai percorsi di lavoro CSOLIDS.Exec( nPartId) EgtSetStatus( nSolidLayId, GDB_ST.OFF) - EgtSetStatus( nWallsLayId or GDB_ID.NULL, GDB_ST.OFF) + EgtSetStatus( nRibsLayId or GDB_ID.NULL, GDB_ST.OFF) EgtDraw() -- Aggiorno impostazioni di visibilita' per ShowManager - local nViewId = EgtGetFirstNameInGroup( GDB_ID.ROOT, VIEWPARAMS) - if not nViewId then - nViewId = EgtGroup( GDB_ID.ROOT) - EgtSetName( nViewId, VIEWPARAMS) - end - EgtSetInfo( nViewId, IMPORTED_SOLID, false) - EgtSetInfo( nViewId, OUTER_CRV, false) - EgtSetInfo( nViewId, PATH_GRP, false) - EgtSetInfo( nViewId, SOLID_GRP, true) - EgtSetInfo( nViewId, TOOLPATH_GRP, true) + SetViewInfo() end diff --git a/LuaLibs/RunViewManager.lua b/LuaLibs/RunViewManager.lua index 516139d..9eb9cb5 100644 --- a/LuaLibs/RunViewManager.lua +++ b/LuaLibs/RunViewManager.lua @@ -1,4 +1,4 @@ --- RunViewManager.lua by Egaltech s.r.l. 2022/04/05 +-- RunViewManager.lua by Egaltech s.r.l. 2022/07/03 -- Gestione visualizzazione per Stampa 3d -- Tabella per definizione modulo @@ -12,9 +12,35 @@ EgtOutLog( ' RunViewManager started', 1) -- Costanti generali local AMD = require( 'AddManData') +--------------------------------------------------------------------- +local function CalcShow( nShellView, nType) + if nShellView == SHELL_VIEW_TYPE.OUTER then + return ( nType == TYPE.OUTER_SHELL) + elseif nShellView == SHELL_VIEW_TYPE.INNER then + return ( nType == TYPE.INNER_SHELL) + elseif nShellView == SHELL_VIEW_TYPE.INFILL then + return ( nType == TYPE.INFILL) + else --nShellView == SHELL_VIEW_TYPE.ALL + return true + end +end + +--------------------------------------------------------------------- +local function CalcType( nEntId, nOldType) + local nType = EgtGetInfo( nEntId, KEY_TYPE, 'i') + if not nType or nType == TYPE.LINK or nType == TYPE.COASTING or nType == TYPE.WIPE then + nType = nOldType + end + if nType == TYPE.RIB then + nType = TYPE.INFILL + end + return nType +end + +--------------------------------------------------------------------- function RunViewManager.Exec() - local nVisibilityMode = LAYER_VIEW_TYPE.ALL -- 1 = All, 2 = Till Selected, 3 = Only Selected - local nShellType = SHELL_VIEW_TYPE.ALL -- 1 = All, 2 = Outer, 3 = Inner, 4 = infill + local nVisibilityMode = LAYER_VIEW_TYPE.ALL -- 1 = All, 2 = Till Selected, 3 = Only Selected, 4 = From Selected + local nShellType = SHELL_VIEW_TYPE.ALL -- 1 = All, 2 = Outer, 3 = Inner, 4 = infill local nOldSelLayerId = GDB_ID.NULL -- leggo ultimi valori @@ -26,11 +52,13 @@ function RunViewManager.Exec() end local sLayerViewCombo = '' if nVisibilityMode == LAYER_VIEW_TYPE.TILL_SEL then - sLayerViewCombo = 'CB:All,*Till Selected,Only Selected' + sLayerViewCombo = 'CB:All,*Till Selected,Only Selected,From Selected' elseif nVisibilityMode == LAYER_VIEW_TYPE.ONLY_SEL then - sLayerViewCombo = 'CB:All,Till Selected,*Only Selected' + sLayerViewCombo = 'CB:All,Till Selected,*Only Selected,From Selected' + elseif nVisibilityMode == LAYER_VIEW_TYPE.FROM_SEL then + sLayerViewCombo = 'CB:All,Till Selected,Only Selected,*From Selected' else - sLayerViewCombo = 'CB:*All,Till Selected,Only Selected' + sLayerViewCombo = 'CB:*All,Till Selected,Only Selected,From Selected' end local sShellViewCombo = '' if nShellType == SHELL_VIEW_TYPE.OUTER then @@ -53,6 +81,8 @@ function RunViewManager.Exec() nVisibilityMode = LAYER_VIEW_TYPE.TILL_SEL elseif ViewValues[1] == 'Only Selected' then nVisibilityMode = LAYER_VIEW_TYPE.ONLY_SEL + elseif ViewValues[1] == 'From Selected' then + nVisibilityMode = LAYER_VIEW_TYPE.FROM_SEL end if ViewValues[2] == 'All' then nShellType = SHELL_VIEW_TYPE.ALL @@ -105,28 +135,39 @@ function RunViewManager.Exec() EgtSetStatus( nLayerId, EgtIf( nLayerId <= nSelLayerId, GDB_ST.ON, GDB_ST.OFF)) elseif nVisibilityMode == LAYER_VIEW_TYPE.ONLY_SEL then EgtSetStatus( nLayerId, EgtIf( nLayerId == nSelLayerId, GDB_ST.ON, GDB_ST.OFF)) + elseif nVisibilityMode == LAYER_VIEW_TYPE.FROM_SEL then + EgtSetStatus( nLayerId, EgtIf( nLayerId >= nSelLayerId, GDB_ST.ON, GDB_ST.OFF)) end local nCrvId = EgtGetFirstGroupInGroup( nLayerId) while nCrvId do + ---- + local nOldType = TYPE.OUTER_SHELL local nPathId = EgtGetFirstNameInGroup( nCrvId, PATH_GRP) local nShellId = EgtGetFirstInGroup( nPathId) while nShellId do - local nType = EgtGetInfo( nShellId, KEY_TYPE, 'i') - EgtSetStatus( nShellId, EgtIf( nShellType == SHELL_VIEW_TYPE.ALL or ( nShellType == SHELL_VIEW_TYPE.OUTER and nType == TYPE.OUTER_SHELL) or (nShellType == SHELL_VIEW_TYPE.INNER and nType == TYPE.INNER_SHELL), GDB_ST.ON, GDB_ST.OFF)) + local nType = CalcType( nShellId, nOldType) + nOldType = nType + EgtSetStatus( nShellId, EgtIf( CalcShow( nShellType, nType), GDB_ST.ON, GDB_ST.OFF)) nShellId = EgtGetNext( nShellId) end + ---- + nOldType = TYPE.OUTER_SHELL local nSolidId = EgtGetFirstNameInGroup( nCrvId, SOLID_GRP) local nSurfId = EgtGetFirstInGroup( nSolidId) while nSurfId do - local nType = EgtGetInfo( nSurfId, KEY_TYPE, 'i') - EgtSetStatus( nSurfId, EgtIf( nShellType == SHELL_VIEW_TYPE.ALL or ( nShellType == SHELL_VIEW_TYPE.OUTER and nType == TYPE.OUTER_SHELL) or (nShellType == SHELL_VIEW_TYPE.INNER and nType == TYPE.INNER_SHELL), GDB_ST.ON, GDB_ST.OFF)) + local nType = CalcType( nSurfId, nOldType) + nOldType = nType + EgtSetStatus( nSurfId, EgtIf( CalcShow( nShellType, nType), GDB_ST.ON, GDB_ST.OFF)) nSurfId = EgtGetNext( nSurfId) end + ---- + nOldType = TYPE.OUTER_SHELL local nToolPathId = EgtGetFirstNameInGroup( nCrvId, TOOLPATH_GRP) nShellId = EgtGetFirstInGroup( nToolPathId) while nShellId do - local nType = EgtGetInfo( nShellId, KEY_TYPE, 'i') - EgtSetStatus( nShellId, EgtIf( nType and ( nShellType == SHELL_VIEW_TYPE.ALL or ( nShellType == SHELL_VIEW_TYPE.OUTER and nType == TYPE.OUTER_SHELL) or (nShellType == SHELL_VIEW_TYPE.INNER and nType == TYPE.INNER_SHELL)), GDB_ST.ON, GDB_ST.OFF)) + local nType = CalcType( nShellId, nOldType) + nOldType = nType + EgtSetStatus( nShellId, EgtIf( CalcShow( nShellType, nType), GDB_ST.ON, GDB_ST.OFF)) nShellId = EgtGetNext( nShellId) end nCrvId = EgtGetNext( nCrvId)