diff --git a/LuaLibs/AddManData.lua b/LuaLibs/AddManData.lua index 438c9a7..ea5492a 100644 --- a/LuaLibs/AddManData.lua +++ b/LuaLibs/AddManData.lua @@ -34,6 +34,7 @@ LAYER_SECTION = "" KEY_SLICING_45 = "Slicing45" KEY_SLICING_DIR="SlicingDir" KEY_SLICE_Z = "SliceZ" +KEY_SLICE_DELTAZ = "DeltaZ" KEY_SLICE_NBR = "SliceNbr" KEY_SLICE_STEP = "StrandH" KEY_SHELLS_NBR = "StrandCount" @@ -80,6 +81,7 @@ TYPE = { LINK = 4, COASTING = 5, WIPE = 6, + SETTO = 7, } PRINT_ORDER = { @@ -154,5 +156,21 @@ SLICE_ADV_TYPE = { INFILL = 4, } +--------------------------------------------------------------------- +SETTI_GRP="Setti" +SETTI_CRV="Setto" + +KEY_SETTI_OVERLAP = "SettiOverlap" +KEY_SETTI_SHELLS_NBR = "SettiStrandCount" +KEY_SETTI_LINK = "SettiLink" +KEY_SETTI_INVERT = "SettiInvert" +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" + --------------------------------------------------------------------- return AddManData diff --git a/LuaLibs/CalcPaths.lua b/LuaLibs/CalcPaths.lua index c1d4ddf..78fa96f 100644 --- a/LuaLibs/CalcPaths.lua +++ b/LuaLibs/CalcPaths.lua @@ -20,11 +20,15 @@ local function GetLayerParamsForPathCalc() LayerParams.dStrand = EgtGetInfo( nParamsGrp, KEY_STRAND, 'd') LayerParams.dOffs = EgtGetInfo( nParamsGrp, KEY_OFFSET_SLICE, 'd') LayerParams.nFloorNbr = EgtGetInfo( nParamsGrp, KEY_FLOOR_NBR, 'i') + LayerParams.vtSlicing = EgtGetInfo( nParamsGrp, KEY_SLICING_DIR, 'v') + -- parametri setti + LayerParams.dSettiOverlap = EgtGetInfo( nParamsGrp, KEY_SETTI_OVERLAP, 'd') + LayerParams.nSettiShellsNbr = EgtGetInfo( nParamsGrp, KEY_SETTI_SHELLS_NBR, 'i') return LayerParams end --------------------------------------------------------------------- -local function GetLayerStartPoint( nLayId) +local function GetLayerStartPoint( nLayId) local ptStart -- recupero il punto di partenza usato nel layer precedente @@ -42,7 +46,7 @@ local function GetLayerStartPoint( nLayId) end --------------------------------------------------------------------- -local function GetPathsFromSurf( nSrfId, sName, nType, nGrpId, nLayId, dStrand) +local function GetPathsFromSurf( nSrfId, sName, nType, nGrpId, nLayId) local nChunks = EgtSurfFrChunkCount( nSrfId) for nC = 0, nChunks - 1 do @@ -96,8 +100,98 @@ local function AddFloor( nSrfId, nGrpId, LayerParams, nFloorNbr) end +-------------------------------------------------------------------- +local function MySortSetti( a, b) + + if abs( a.pt:getX() - b.pt:getX()) < GEO.EPS_SMALL then + -- confronto le y + if abs( a.pt:getY() - b.pt:getY()) < GEO.EPS_SMALL then + return false + elseif a.pt:getY() < b.pt:getY() + GEO.EPS_SMALL then + return true + else + return false + end + elseif a.pt:getX() < b.pt:getX() + GEO.EPS_SMALL then + return true + else + return false + end +end + +-------------------------------------------------------------------- +local function ReorderSetti( nGrp, vtSlicing, nStmId) + + -- box del pezzo + local frLoc = Frame3d( ORIG(), vtSlicing) + local b3Box = EgtGetBBoxRef( nStmId, GDB_BB.STANDARD, frLoc) + local ptMin = b3Box:getMin() + ptMin:toGlob( frLoc) + local vtDiag = b3Box:getMax() - b3Box:getMin() + + local tab = {} + local vIds = EgtGetAllInGroup( nGrp) + for i = 1, #vIds do + EgtExtendCurveStartByLen( vIds[i], 500) + EgtExtendCurveEndByLen( vIds[i], 500) + -- trim con il box del pezzo + local nNewId, nCnt = EgtTrimFlatCurveWithBox( vIds[i], Frame3d( ptMin, vtSlicing), vtDiag, true, true, GDB_RT.GLOB) + if nCnt > 0 then + table.insert( tab, { Id = nNewId, pt = EgtSP( nNewId)}) + end + end + + table.sort( tab, MySortSetti) + return tab +end + +-------------------------------------------------------------------- +local function CalcSettiPaths( nSliceGrp, nSettiGrp, LayerParams, nStmId) + + -- calcolo gli offset + local dOffs = ( LayerParams.nSettiShellsNbr - 1) * LayerParams.dStrand / 2 + local nOffsGrp = EgtGroup( nSettiGrp) + local vCrvIds = EgtGetNameInGroup( nSettiGrp, SETTI_CRV .. '*') + for i = 1, #vCrvIds do + for k = 0, LayerParams.nSettiShellsNbr - 1 do + local nNewId = EgtOffsetCurveAdv( vCrvIds[i], - dOffs + k * LayerParams.dStrand) + EgtSetName( nNewId, EgtGetName( vCrvIds[i])) + EgtSetInfo( nNewId, KEY_TYPE, TYPE.SETTO) + EgtRelocateGlob( nNewId, nOffsGrp) + end + end + + -- calcolo l'ordine di realizzazione dei setti + local OrderedSetti = ReorderSetti( nOffsGrp, LayerParams.vtSlicing, nStmId) + -- scorro i gruppi di curve + local nCrvGrp = EgtGetFirstNameInGroup( nSliceGrp, CONTOUR_GRP .. '*') + while nCrvGrp do + local nSettiPathGrp = EgtGetFirstNameInGroup( nCrvGrp, SETTI_GRP) + local nSrf = EgtGetFirstNameInGroup( nSettiPathGrp, LAYER_SRF) + if nSrf then + for i = 1, #OrderedSetti do + local nNewId = EgtCopyGlob( OrderedSetti[i].Id, nSettiPathGrp) + -- trim dei setti con la regione offsettata + local nCrv, nCnt = EgtTrimCurveWithRegion( nNewId, nSrf, true, false) + -- elimino tratti troppo corti + for nId = nCrv, nCrv + nCnt - 1 do + local dLen = EgtCurveLength( nId) + if dLen < MIN_LEN then + EgtErase( nId) + end + end + end + end + + if not EgtGetFirstNameInGroup( nSettiPathGrp, SETTI_CRV .. '*') then + EgtErase( nSettiPathGrp) + end + nCrvGrp = EgtGetNextName( nCrvGrp, CONTOUR_GRP .. '*') + end +end + --------------------------------------------------------------------- -function CalcPaths.Exec( nPartId) +function CalcPaths.Exec( nPartId, nStmId) local vLayIds = EgtGetNameInGroup( nPartId, SLICE_LAYER.."*") if not vLayIds then @@ -107,10 +201,11 @@ function CalcPaths.Exec( nPartId) -- recupero i parametri per calcolo dei path local LayerParams = GetLayerParamsForPathCalc() + -- scorro tutti i suoi layer + for nIdx = 1, #vLayIds do - -- scorro tutti i suoi layer - for nIdx = 1, #vLayIds do - + local nSettiGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], SETTI_GRP) + -- scorro tutti i gruppi di contorni local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[nIdx], CONTOUR_GRP.."*") or GDB_ID.NULL while nCrvGrpId ~= GDB_ID.NULL do @@ -127,8 +222,8 @@ function CalcPaths.Exec( nPartId) local nSolidGrpId = EgtGetFirstNameInGroup( nCrvGrpId, SOLID_GRP) or GDB_ID.NULL if nSolidGrpId ~= GDB_ID.NULL then EgtErase( nSolidGrpId) - end - + end + -- recupero la superficie ottenuta dallo slicing local nSrf = EgtGetFirstNameInGroup( nCrvGrpId, LAYER_SRF) if nSrf then @@ -143,7 +238,7 @@ function CalcPaths.Exec( nPartId) end -- se offset riuscito, estraggo i contorni (pareti esterne) if bOk then - GetPathsFromSurf( nSrfId, SHELL_CRV..'0', TYPE.OUTER_SHELL, nGrpId, vLayIds[nIdx], LayerParams.dStrand) + GetPathsFromSurf( nSrfId, SHELL_CRV..'0', TYPE.OUTER_SHELL, nGrpId, vLayIds[nIdx]) else EgtOutLog( 'Error on ExtOffset (layer '..tostring( nIdx)..') - CalcPaths') end @@ -161,29 +256,62 @@ function CalcPaths.Exec( nPartId) end -- se offset riuscito, estraggo i contorni ( pareti interne) if bOk then - GetPathsFromSurf( nSrfId, SHELL_CRV..tostring( nInd2), TYPE.INNER_SHELL, nGrpId, vLayIds[nIdx], LayerParams.dStrand) + GetPathsFromSurf( nSrfId, SHELL_CRV..tostring( nInd2), TYPE.INNER_SHELL, nGrpId, vLayIds[nIdx]) else EgtOutLog( 'Error on IntOffset (layer '..tostring( nIdx)..') - CalcPaths') end EgtErase( nSrfId) - end + end + + -- setti + if nSettiGrp then + + -- creo o svuoto il gruppo per i setti + local nSettiPathGrp = EgtGetFirstNameInGroup( nCrvGrpId, SETTI_GRP) + if not nSettiPathGrp then + nSettiPathGrp = EgtGroup( nCrvGrpId) + EgtSetName( nSettiPathGrp, SETTI_GRP) + EgtSetStatus( nSettiPathGrp, GDB_ST.OFF) + else + EgtEmptyGroup( nSettiPathGrp) + end + + -- calcolo superficie di offset da usare per i setti + local nSrfId = EgtCopy( nSrf, nSettiPathGrp) + local dOffs = 0.5 * LayerParams.dStrand - LayerParams.dOffs + ( LayerParams.nShellsNbr - 1) * LayerParams.dStrand + ( 1 - LayerParams.dSettiOverlap / 100) * LayerParams.dStrand + local bOk = ( EgtSurfFrOffset( nSrfId, - dOffs) and EgtSurfFrChunkCount( nSrfId) > 0) + if not bOk then + EgtErase( nSrfId) + nSrfId = EgtCopyGlob( nSrf, nSettiPathGrp) + bOk = ( EgtSurfFrOffset( nSrfId, - dOffs + 0.05) and EgtSurfFrChunkCount( nSrfId) > 0) + end + -- se non ho una superficie errore ed elimino il gruppo dei setti + if not bOk then + EgtErase( nSettiPathGrp) + EgtOutLog( 'Error on Offset (Setti) (layer '..tostring( nIdx)..') - CalcPaths') + end + + end -- gestione eventuale floor if nIdx <= LayerParams.nFloorNbr then AddFloor( nSrf, nGrpId, LayerParams, nIdx) end - end - --passo al gruppo di contorni successivo + -- passo al gruppo di contorni successivo nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*") or GDB_ID.NULL end + -- sistemo eventuali setti + if nSettiGrp then + CalcSettiPaths( vLayIds[nIdx], nSettiGrp, LayerParams, nStmId) + end + if EgtProcessEvents( nIdx / #vLayIds * 100, 0) == 1 then EgtDraw() return end - end end diff --git a/LuaLibs/CalcSlices.lua b/LuaLibs/CalcSlices.lua index fa9d0a2..1eb7e36 100644 --- a/LuaLibs/CalcSlices.lua +++ b/LuaLibs/CalcSlices.lua @@ -57,6 +57,67 @@ local function ComputeMaxH( nStmId, frSlicing, HMax) return GEO.INFINITO end +-------------------------------------------------------------------- +local function SlicingSetti( nPartId, vtSlicing, dZmin) + + -- recupero le superfici che definiscono i setti + local nSettiPart = EgtGetFirstNameInGroup( GDB_ID.ROOT, SETTI_GRP) + if not nSettiPart then return end + EgtSetStatus( nSettiPart, GDB_ST.OFF) + local vSettiIds = EgtGetAllInGroup( EgtGetFirstLayer( nSettiPart)) + -- 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) + 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]) + end + end + end + + local nLayId = EgtGetFirstNameInGroup( nPartId, SLICE_LAYER .. '*') + while nLayId do + -- 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 + local nGrp = EgtGroup( nLayId) + EgtSetName( nGrp, SETTI_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) + if nNewId then + -- rimuovo punti + for nId = nNewId, nNewId + nPntCnt -1 do + EgtErase( nId) + end + -- rinomino le curve e correggo di DeltaZ + for nId = nNewId + nPntCnt, nNewId + nPntCnt + nCrvCnt - 1 do + EgtSetName( nId, SETTI_CRV .. tostring( i)) + EgtMove( nId, - dDeltaZ * vtSlicing) + end + -- rimuovo superfici + for nId = nNewId + nPntCnt + nCrvCnt, nNewId + nPntCnt + nCrvCnt + nSrfCnt -1 do + EgtErase( nId) + end + end + end + end + + -- verifico che il gruppo non sia vuoto + if not EgtGetFirstInGroup( nGrp) then + EgtErase( nGrp) + end + nLayId = EgtGetNextName( nLayId, SLICE_LAYER .. '*') + end + + return true +end + --------------------------------------------------------------------- function CalcSlices.Exec( nPartId, nStmId, HMax) @@ -141,7 +202,8 @@ 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) + -- salvo i risultati nel layer local vClosedId = {} local vOpenId = {} @@ -163,7 +225,7 @@ function CalcSlices.Exec( nPartId, nStmId, HMax) end end - nId = EgtGetNext( nId) + nId = EgtGetNext( nId) end -- se presenti percorsi aperti, provo a concatenarli @@ -256,6 +318,9 @@ function CalcSlices.Exec( nPartId, nStmId, HMax) nLayId = EgtGetNext( nLayId) end + -- setti + SlicingSetti( nPartId, vtSlicing, dZmin) + -- eventuale segnalazione errori if #vErr > 0 then EgtOutBox( 'Slicing Error on layers :\n' .. table.concat( vErr, ','), 'SlicingCalc') diff --git a/LuaLibs/CalcToolPath.lua b/LuaLibs/CalcToolPath.lua index c225f7e..14d1865 100644 --- a/LuaLibs/CalcToolPath.lua +++ b/LuaLibs/CalcToolPath.lua @@ -35,7 +35,18 @@ local function GetLayerParamsForToolPathCalc() LayerParams.dWipeLen = EgtGetInfo( nParamsGrp, KEY_WIPE_LEN, 'd') LayerParams.vtSlicing = EgtGetInfo( nParamsGrp, KEY_SLICING_DIR, 'v') LayerParams.dTDiam = EgtGetInfo( nParamsGrp, KEY_TOOL_DIAM, 'd') - + -- Parametri setti + LayerParams.nSettiShellsNbr = EgtGetInfo( nParamsGrp, KEY_SETTI_SHELLS_NBR, 'i') + LayerParams.bSettiLink = EgtGetInfo( nParamsGrp, KEY_SETTI_LINK, 'b') + LayerParams.bSettiInvert = EgtGetInfo( nParamsGrp, KEY_SETTI_INVERT, 'b') + LayerParams.bSettiLIInvert = EgtGetInfo( nParamsGrp, KEY_SETTI_LEAD_IN_INVERT, 'b') + LayerParams.dSettiLILen = EgtGetInfo( nParamsGrp, KEY_SETTI_LEAD_IN_LEN, 'd') + LayerParams.bSettiLOInvert = EgtGetInfo( nParamsGrp, KEY_SETTI_LEAD_OUT_INVERT, 'b') + LayerParams.dSettiLOLen = EgtGetInfo( nParamsGrp, KEY_SETTI_LEAD_OUT_LEN, 'd') + LayerParams.dSettiLOWipeTang = EgtGetInfo( nParamsGrp, KEY_SETTI_LEAD_OUT_WIPE1, 'd') + LayerParams.dSettiLOWipe = EgtGetInfo( nParamsGrp, KEY_SETTI_LEAD_OUT_WIPE2, 'd') + LayerParams.dSettiLOWipeAng = EgtGetInfo( nParamsGrp, KEY_SETTI_LEAD_OUT_WIPE_DIR, 'd') + return LayerParams end @@ -158,6 +169,194 @@ local function AddRetractionOnLastCrv( nTpathGrpId, LayerParams) end end +-------------------------------------------------------------------- +local function CalcSettiLink( nSettiGrp, nLoopGrp, LayerParams, nTpathGrpId) + + local nCrvId = EgtGetFirstInGroup( nLoopGrp) + local nCurr = EgtGetFirstNameInGroup( nTpathGrpId, SETTI_CRV .. '*') + while nCurr do + local nNext = EgtGetNextName( nCurr, SETTI_CRV .. '*') + if nNext then + + local ptS = EgtEP( nCurr) + local ptE = EgtSP( nNext) + local dParS = EgtCurveParamAtPoint( nCrvId, ptS) + local dParE = EgtCurveParamAtPoint( nCrvId, ptE) + + if dParE then + -- verifico i due percorsi ( dParS->dParE e dParE->dParS) + local nCopyId1 = EgtCopyGlob( nCrvId, nCurr, GDB_IN.AFTER) + local nCopyId2 = EgtCopyGlob( nCrvId, nCurr, GDB_IN.AFTER) + EgtTrimCurveStartEndAtParam( nCopyId1, dParS, dParE) + EgtTrimCurveStartEndAtParam( nCopyId2, dParE, dParS) + EgtInvertCurve( nCopyId2) + + local dLen1 = EgtCurveLength( nCopyId1) + local dLen2 = EgtCurveLength( nCopyId2) + if dLen1 < dLen2 then + EgtErase( nCopyId2) + EgtSetInfo( nCopyId1, KEY_TYPE, TYPE.SETTO) + else + EgtErase( nCopyId1) + EgtSetInfo( nCopyId2, KEY_TYPE, TYPE.SETTO) + end + end + end + -- passo alla successiva + nCurr = nNext + end +end + +-------------------------------------------------------------------- +local function AddSettiLeadIn( nCrv, nLoopsGrp, dLeadInLen, bInvert) + + if dLeadInLen < GEO.EPS_SMALL then return end + + -- recupero la curva di offset + local nCrvOffs = EgtGetFirstInGroup( nLoopsGrp) + local nCopyOffs = EgtCopyGlob( nCrvOffs, nCrv, GDB_IN.BEFORE) + + local ptS = EgtSP( nCrv) + EgtChangeClosedCurveStartPoint( nCopyOffs, ptS) + if bInvert then + EgtInvertCurve( nCopyOffs) + end + EgtTrimCurveEndAtLen( nCopyOffs, dLeadInLen) + EgtInvertCurve( nCopyOffs) + EgtSetInfo( nCopyOffs, KEY_TYPE, TYPE.SETTO) + +end + +-------------------------------------------------------------------- +local function AddSettiLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams, bInvert) + + -- recupero la curva di offset + local nCrvOffs = EgtGetFirstInGroup( nLoopsGrp) + local ptE = EgtEP( nCrv) + local vtE = EgtUV( nCrvOffs, EgtCurveParamAtPoint( nCrvOffs, ptE), 1) + if bInvert then vtE = - vtE end + local nCrvLO + local nWipe + + -- primo tratto ( segue offset con flusso aperto) + if LayerParams.dSettiLOLen > GEO.EPS_SMALL then + nCrvLO = EgtCopyGlob( nCrvOffs, nCrv, GDB_IN.AFTER) + EgtChangeClosedCurveStartPoint( nCrvLO, ptE) + if bInvert then + EgtInvertCurve( nCrvLO) + end + EgtTrimCurveEndAtLen( nCrvLO, LayerParams.dSettiLOLen) + EgtSetInfo( nCrvLO, KEY_TYPE, TYPE.SETTO) + -- aggiorno ptE e vtE + ptE = EgtEP( nCrvLO) + vtE = EgtEV( nCrvLO) + end + + -- secondo tratto ( segue offset con flusso chiuso) + if LayerParams.dSettiLOWipeTang > GEO.EPS_SMALL then + nWipe = EgtCopyGlob( nCrvOffs, nCrvLO or nCrv, GDB_IN.AFTER) + EgtChangeClosedCurveStartPoint( nWipe, ptE) + if bInvert then + EgtInvertCurve( nWipe) + end + EgtTrimCurveEndAtLen( nWipe, LayerParams.dSettiLOWipeTang) + -- aggiorno ptE e vtE + ptE = EgtEP( nWipe) + vtE = EgtEV( nWipe) + end + + -- terzo tratto ( diretto verso esterno con ugello chiuso) + if LayerParams.dSettiLOWipe > GEO.EPS_SMALL then + local dAng = EgtIf( bInvert, 90, - 90) + LayerParams.dSettiLOWipeAng + vtE:rotate( LayerParams.vtSlicing, dAng) + local ptFinal = ptE + vtE * LayerParams.dSettiLOWipe + if nWipe then + -- unisco al secondo tratto così da averne uno solo per il wiping + EgtAddCurveCompoLine( nWipe, ptFinal) + else + nWipe = EgtCurveCompoFromPoints( nTPathGrp, { ptE, ptFinal}) + EgtRelocateGlob( nWipe, nCrvLO or nCrv, GDB_IN.AFTER) + end + end + + if nWipe then + EgtSetName( nWipe, WIPE_CRV) + EgtSetInfo( nWipe, KEY_TYPE, TYPE.WIPE) + EgtSetColor( nWipe, EgtStdColor('TEAL')) + end + +end + +--------------------------------------------------------------------- +local function CalcSettiToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ) + + local nSettiGrp = EgtGetFirstNameInGroup( nCrvGrp, SETTI_GRP) + -- aggiungo i setti nel toolpath + local vEntIds = EgtGetNameInGroup( nSettiGrp, SETTI_CRV .. '*') + 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) + EgtSetColor( nNewEntId, EgtStdColor('GRAY')) + + -- eventuale inversione delle curva + if LayerParams.bSettiLink then + -- se link le curve devono avere direzioni alternate + if ( LayerParams.bSettiInvert and i % 2 == 1) or + ( not LayerParams.bSettiInvert and i % 2 == 0) then + EgtInvertCurve( nNewEntId) + end + else + if LayerParams.bSettiInvert then + EgtInvertCurve( nNewEntId) + end + end + end + + -- estraggo i contorni delle superfici di offset + local nLoopGrp = EgtGroup( nSettiGrp) + local nSrfId = EgtGetFirstNameInGroup( nSettiGrp, LAYER_SRF) + local nChunksNbr = EgtSurfFrChunkCount( nSrfId) + for i = 0, nChunksNbr do + local nRes, nCnt = EgtExtractSurfFrChunkLoops( nSrfId, i, nLoopGrp) + if nRes then + for j = nRes, nRes + nCnt - 1 do + EgtMove( j, dCorrZ * Z_AX(), GDB_RT.GLOB) + -- mi sposto dell'altezza layer + EgtMove( j, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) + end + end + end + + -- collegamenti e leadin/leadout + if LayerParams.bSettiLink then + -- collego i setti + CalcSettiLink( nSettiGrp, nLoopGrp, LayerParams, nTpathGrpId) + -- aggiungo ingresso e uscita solo sul primo e sull'ultimo setto + local nFirst = EgtGetFirstNameInGroup( nTpathGrpId, SETTI_CRV .. '*') + local bInvertLI = EgtIf( LayerParams.nSettiShellsNbr == 1, LayerParams.bSettiLIInvert, not LayerParams.bSettiInvert) + if nFirst then AddSettiLeadIn( nFirst, nLoopGrp, LayerParams.dSettiLILen, bInvertLI) end + local nLast = EgtGetLastNameInGroup( nTpathGrpId, SETTI_CRV .. '*') + local bInvertLO = LayerParams.bSettiLOInvert + if LayerParams.nSettiShellsNbr > 1 then + bInvertLO = EgtIf( #vEntIds % 2 == 0, not bInvertLI, bInvertLI) + end + if nLast then AddSettiLeadOut( nLast, nTpathGrpId, nLoopGrp, LayerParams, bInvertLO) end + + elseif LayerParams.nSettiShellsNbr == 1 then + local vNewEntIds = EgtGetNameInGroup( nTpathGrpId, SETTI_CRV .. '*') + for i = 1, #vNewEntIds do + AddSettiLeadIn( vNewEntIds[i], nLoopGrp, LayerParams.dSettiLILen, LayerParams.bSettiLIInvert) + AddSettiLeadOut( vNewEntIds[i], nTpathGrpId, nLoopGrp, LayerParams, LayerParams.bSettiLOInvert) + end + end + +end + --------------------------------------------------------------------- function CalcToolPath.Exec( nPartId) @@ -176,7 +375,8 @@ function CalcToolPath.Exec( nPartId) -- recupero i parametri per calcolo dei toolpath local LayerParams = GetLayerParamsForToolPathCalc() - + local dCorrZ = ComputeZCorrection( LayerParams) + -- Ciclo sui layer for nIdx = 1, #vLayIds do @@ -204,14 +404,13 @@ function CalcToolPath.Exec( nPartId) local nEntId = EgtGetFirstInGroup( nPathGrpId) while nEntId do local nNewEntId = EgtCopyGlob( nEntId, nTpathGrpId, EgtIf( LayerParams.nOrder == PRINT_ORDER.INF_INT_EXT, GDB_IN.FIRST_SON, GDB_IN.LAST_SON)) - -- correggo posizione in Z ( per essere sicuri di appoggiare sul piano) - local dCorr = ComputeZCorrection( LayerParams) - EgtMove( nNewEntId, dCorr * Z_AX(), GDB_RT.GLOB) + -- 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) if LayerParams.bInvert then EgtInvertCurve( nNewEntId) - end + end EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB) EgtSetColor( nNewEntId, EgtStdColor('GRAY')) nEntId = EgtGetNext( nEntId) @@ -309,10 +508,16 @@ 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) + end + --passo al gruppo di contorni successivo nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*") end - end + end end --------------------------------------------------------------------- diff --git a/LuaLibs/RunMachiningParamCalc.lua b/LuaLibs/RunMachiningParamCalc.lua index c7dffb0..a7dedb4 100644 --- a/LuaLibs/RunMachiningParamCalc.lua +++ b/LuaLibs/RunMachiningParamCalc.lua @@ -120,12 +120,12 @@ function RunMachiningParamCalc.Exec() -- calcolo speed local dSpeed = ((( dLayerFeed * dSliceStep * dStrand ) / 60) - dCoeffX) / dCoeffY -- scrivo info feed e speed in group toolpath - nCrvId = EgtGetFirstGroupInGroup( nLayerId) + nCrvId = EgtGetFirstNameInGroup( nLayerId, CONTOUR_GRP .. '*') while nCrvId do local nToolPathId = EgtGetFirstNameInGroup( nCrvId, TOOLPATH_GRP) EgtSetInfo( nToolPathId, KEY_FEED, dLayerFeed) EgtSetInfo( nToolPathId, KEY_SPEED, dSpeed) - nCrvId = EgtGetNext( nCrvId) + nCrvId = EgtGetNextName( nCrvId, CONTOUR_GRP .. '*') end -- salvo e riporto valori calcolati in tabella per csv local sStatus = '' diff --git a/LuaLibs/RunPartPositioning.lua b/LuaLibs/RunPartPositioning.lua index 4f4472e..6a73583 100644 --- a/LuaLibs/RunPartPositioning.lua +++ b/LuaLibs/RunPartPositioning.lua @@ -105,6 +105,12 @@ function RunPartPositioning.Exec() EgtMove( nPartId, vtMove) b3Part:move( vtMove) + -- Posiziono eventuali setti + local nSettiPart = EgtGetFirstNameInGroup( GDB_ID.ROOT, SETTI_GRP) + if nSettiPart then + EgtMove( nSettiPart, vtMove) + end + -- Creo il frame del pezzo local frPart = Frame3d( b3Part:getCenter() - 0.5 * b3Part:getDimZ() * Z_AX(), Z_AX()) nFrameId = EgtFrame( nPartId, frPart, GDB_RT.GLOB) diff --git a/LuaLibs/RunSlicing.lua b/LuaLibs/RunSlicing.lua index 7191006..7656a69 100644 --- a/LuaLibs/RunSlicing.lua +++ b/LuaLibs/RunSlicing.lua @@ -121,6 +121,19 @@ local function LoadParams( sFile, nPartId) ptStart = EgtSP( nPtStartId, GDB_ID.ROOT) end EgtSetInfo( nParamsGrp, KEY_START_POINT, ptStart) + + -- parametri per setti + SetParamInfo( sFile, nParamsGrp, DEFAULT_SECTION, KEY_SETTI_OVERLAP, '0.0') + SetParamInfo( sFile, nParamsGrp, DEFAULT_SECTION, KEY_SETTI_SHELLS_NBR, '1') + SetParamInfo( sFile, nParamsGrp, DEFAULT_SECTION, KEY_SETTI_INVERT, '0') + SetParamInfo( sFile, nParamsGrp, DEFAULT_SECTION, KEY_SETTI_LINK, '0') + SetParamInfo( sFile, nParamsGrp, DEFAULT_SECTION, KEY_SETTI_LEAD_IN_INVERT, '0') + SetParamInfo( sFile, nParamsGrp, DEFAULT_SECTION, KEY_SETTI_LEAD_IN_LEN, '0.0') + SetParamInfo( sFile, nParamsGrp, DEFAULT_SECTION, KEY_SETTI_LEAD_OUT_INVERT, '0') + SetParamInfo( sFile, nParamsGrp, DEFAULT_SECTION, KEY_SETTI_LEAD_OUT_LEN, '0.0') + SetParamInfo( sFile, nParamsGrp, DEFAULT_SECTION, KEY_SETTI_LEAD_OUT_WIPE1, '0.0') + SetParamInfo( sFile, nParamsGrp, DEFAULT_SECTION, KEY_SETTI_LEAD_OUT_WIPE2, '0.0') + SetParamInfo( sFile, nParamsGrp, DEFAULT_SECTION, KEY_SETTI_LEAD_OUT_WIPE_DIR, '0.0') end @@ -173,7 +186,7 @@ function RunSlicing.Exec() EgtDraw() -- Calcolo dei percorsi sul centro strand in basso - CPATHS.Exec( nPartId) + CPATHS.Exec( nPartId, nStmId) EgtDraw() -- Calcolo dei percorsi di lavoro