From b6cbab67ec0632b476277ad3e010938791ae4463 Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Wed, 18 Mar 2020 08:19:44 +0000 Subject: [PATCH] DataBeam : - correzioni varie - gestione scassi a C passanti e grandi con fresature sui due lati - miglioria a contorni liberi chiusi per posizione di attacco - correzioni a feature 3/4-020-X caso particolare Olaf. --- LuaLibs/BeamLib.lua | 35 +- LuaLibs/ProcessCut.lua | 4 +- LuaLibs/ProcessFreeContour.lua | 2 + LuaLibs/ProcessLapJoint.lua | 1408 +++++++++++++++++++++-------- LuaLibs/ProcessSimpleScarf.lua | 89 ++ LuaLibs/ProcessStepJointNotch.lua | 490 +++++++--- 6 files changed, 1530 insertions(+), 498 deletions(-) diff --git a/LuaLibs/BeamLib.lua b/LuaLibs/BeamLib.lua index d176cf0..1d18f37 100644 --- a/LuaLibs/BeamLib.lua +++ b/LuaLibs/BeamLib.lua @@ -122,6 +122,30 @@ function BeamLib.PutStartOnTop( nCrvId) return true end +------------------------------------------------------------------------------------------------------------- +function BeamLib.PutStartOnLonger( nCrvId) + -- verifico che la curva sia chiusa + if not EgtCurveIsClosed( nCrvId) then return false end + -- cerco l'entità più lunga e la imposto come inizio + local dUmax = 0 + local dLmax = - GEO.INFINITO + local dUi, dUf = EgtCurveDomain( nCrvId) + for dU = dUi, dUf - 1 do + local ptP1 = EgtUP( nCrvId, dU, GDB_ID.ROOT) + local ptP2 = EgtUP( nCrvId, dU + 0.5, GDB_ID.ROOT) + local ptP3 = EgtUP( nCrvId, dU + 1.0, GDB_ID.ROOT) + local dL = dist( ptP1, ptP2) + dist( ptP2, ptP3) + if dL > dLmax + GEO.EPS_SMALL then + dLmax = dL + dUmax = dU + end + end + if abs( dUmax - dUi) > GEO.EPS_ZERO then + EgtChangeClosedCurveStart( nCrvId, dUmax) + end + return true +end + ------------------------------------------------------------------------------------------------------------- function BeamLib.PutStartNearestToEdge( nCrvId, b3Raw) -- verifico che la curva sia chiusa @@ -319,7 +343,7 @@ function BeamLib.GetBoxFaceNorm( b3Box, ptP, vtV) end --------------------------------------------------------------------- -function BeamLib.GetFaceWithMostAdj( nSurfId, nPartId) +function BeamLib.GetFaceWithMostAdj( nSurfId, nPartId, bCompare3Fc) -- recupero il numero di facce local nFacCnt = EgtSurfTmFacetCount( nSurfId) -- recupero le normali delle facce @@ -371,6 +395,15 @@ function BeamLib.GetFaceWithMostAdj( nSurfId, nPartId) end end end + if bCompare3Fc and nFacCnt == 3 then + if vAdj[1] == 2 and vAdj[2] == 1 and vAdj[3] == 1 then + if vOrtho[1] == true and vOrtho[2] == true and vOrtho[3] == true then + return -1, GEO.INFINITO, true + else + return -1, GEO.INFINITO + end + end + end -- recupero le facce non in sottosquadra e con il maggior numero di adiacenze local nFacInd = {} local nMaxAdj = -1 diff --git a/LuaLibs/ProcessCut.lua b/LuaLibs/ProcessCut.lua index a3457a4..81a108d 100644 --- a/LuaLibs/ProcessCut.lua +++ b/LuaLibs/ProcessCut.lua @@ -1,4 +1,4 @@ --- ProcessCut.lua by Egaltech s.r.l. 2020/02/29 +-- ProcessCut.lua by Egaltech s.r.l. 2020/03/16 -- Gestione calcolo singoli tagli di lama per Travi -- Tabella per definizione modulo @@ -176,6 +176,8 @@ function ProcessCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom) else vtOrthoO = -Y_AX() end + -- tagli molto di lato e inclinati sono permessi fino a -45deg + if abs( vtN:getX()) < 0.5 then dNzLimDwnUp = -0.707 end local bOk, sErr = BL.MakeOneFaceBySaw( Proc.Id, 0, sCutting, dSawDiam, vtOrthoO, dNzLimDwnUp, BD.CUT_EXTRA, BD.CUT_SIC, 0, 0, nil, b3Raw) if not bOk then return bOk, sErr diff --git a/LuaLibs/ProcessFreeContour.lua b/LuaLibs/ProcessFreeContour.lua index d14925b..560d7f7 100644 --- a/LuaLibs/ProcessFreeContour.lua +++ b/LuaLibs/ProcessFreeContour.lua @@ -159,6 +159,8 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) dStep = dCrvLen / nStep EgtOutLog( string.format( 'CrvLen=%.1f StepNbr=%d StepLen=%.1f', dCrvLen, nStep, dStep), 3) end + -- eventuale spezzatura sul tratto più lungo se curva chiusa + BL.PutStartOnLonger( AuxId) -- verifiche per affondamento ( possibili lavorazioni in doppio) local bCross = false if abs( vtExtr:getY()) > 0.707 then diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 1dd95d1..8ca3289 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -1,4 +1,4 @@ --- ProcessLapJoint.lua by Egaltech s.r.l. 2020/03/06 +-- ProcessLapJoint.lua by Egaltech s.r.l. 2020/03/17 -- Gestione calcolo mezzo-legno per Travi -- 2019/10/08 Agg. gestione OpenPocket. @@ -34,6 +34,9 @@ local sMakeOnlyContourOrFullPocket = '' -- i local sMakeBySideRoughTool = '' -- i local sAntisplintMode = '' -- i +-- Settaggi interni +local bTrySidePocketAtFirst = true + --------------------------------------------------------------------- -- Riconoscimento della feature function ProcessLapJoint.Identify( Proc) @@ -168,9 +171,12 @@ local function VerifySawChain( Proc, dMinDim, dMaxDim, vtOrtho) end --------------------------------------------------------------------- -local function VerifyIfPocket( Proc, dDiam, vtOrtho) +local function VerifyIfPocket( Proc, dDiam, vtOrtho, sMchFindMaster) local bUsePocketing = false local sMchFind = 'Pocket' + if sMchFindMaster and #sMchFindMaster > 0 then + sMchFind = sMchFindMaster + end -- local dCollSic = 2 * BD.COLL_SIC -- if abs( vtOrtho:getX()) > 0.996 or abs( vtOrtho:getY()) > 0.996 or abs( vtOrtho:getZ()) > 0.996 then dCollSic = BD.COLL_SIC end local sPocketing = ML.FindPocketing( sMchFind, dDiam) @@ -197,6 +203,11 @@ local function VerifyIfByBHSideMill( Proc) local bHead = true local sMilling local dMaxMat = 10 + -- se non abilitato parametro Q per lavorarlo di fianco esco + local nUseSideTol = EgtGetInfo( Proc.Id, sMakeBySideRoughTool, 'i') or 0 + if nUseSideTol == 0 then + return false + end -- verifico se U local bIsU = ( Proc.Fct == 3 and not TestElleShape3( Proc)) -- se U e lunghezza non richiede spezzatura @@ -341,6 +352,8 @@ function ProcessLapJoint.IsTailFeature( Proc, b3Raw) return true end end + -- in base al tipo di feature attribuisco il significato dei parametri Q + AssignQValues( Proc) -- se può essere fatto con utensile tipo lama local bUseBHSideMill, bHead = VerifyIfByBHSideMill( Proc) if bUseBHSideMill then @@ -433,7 +446,7 @@ function ProcessLapJoint.Classify( Proc) -- se può essere fatto con utensile tipo lama local bUseBHSideMill, _, _, dMaxMat = VerifyIfByBHSideMill( Proc) if bUseBHSideMill and ( dMaxMat <= dV) then - return true, false + return true, false -- altrimenti controllo se deve essere ruotato con le altre lavorazioni else -- dati della faccia @@ -676,7 +689,7 @@ local function MakePreCuts( Proc, nPhase, nRawId, nPartId, b3Raw) end --------------------------------------------------------------------- -local function MakeByMill( Proc, nPhase, nRawId, nPartId, nFacInd, rfFac, dH, dV, dElev) +local function MakeByMill( Proc, nPhase, nRawId, nPartId, nFacInd, rfFac, dH, dV, dElev, bSpecialApp, sMillMaster, nFacInd2, dFacElev2) -- Recupero le facce adiacenti alla principale local vAdj = EgtSurfTmFacetAdjacencies( Proc.Id, nFacInd)[1] if not vAdj or #vAdj == 0 then @@ -702,11 +715,17 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, nFacInd, rfFac, dH, dV end end end - -- Determino se estremi aperti o chiusi + -- Determino se estremi aperti o chiusi e faccia adiacente da aggiungere alla lavorazione local bOpenStart = false local bOpenEnd = false local vAdj2 = EgtSurfTmFacetAdjacencies( Proc.Id, nFacAdj)[1] EgtOutLog( 'Adj2=' .. table.concat( vAdj2, ' ,')) + local _, dH2, dV2 = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacAdj, GDB_ID.ROOT) + -- Riordino le dimensioni per avere dH > dV + if dH2 < dV2 then + dH2, dV2 = dV2, dH2 + end + local nFacAdj2 for j = 1, #vAdj2 do if vAdj2[j] == nFacInd then -- Se non esiste faccia adiacente a lato precedente -> inizio aperto @@ -722,13 +741,26 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, nFacInd, rfFac, dH, dV end bOpenEnd = ( vAdj2[k] < 0) end + -- decommentare questa parte per concatenare due facce + --if bSpecialApp and vAdj2[j] >= 0 then + -- local _, ptP1, ptP2, _ = EgtSurfTmFacetsContact( Proc.Id, nFacAdj, vAdj2[j], GDB_ID.ROOT) + -- local dLen = dist( ptP1, ptP2) + -- if abs( dLen - dV2) < 10 * GEO.EPS_SMALL then + -- nFacAdj2 = vAdj2[j] + -- end + --end end -- Recupero la lavorazione di fresa - local sMilling = ML.FindMilling( 'LongSmallCut') - if not sMilling then - local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' milling not found in library' - EgtOutLog( sErr) - return false, sErr + local sMilling + if bSpecialApp then + sMilling = sMillMaster + else + sMilling = ML.FindMilling( 'LongSmallCut') + if not sMilling then + local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' milling not found in library' + EgtOutLog( sErr) + return false, sErr + end end -- recupero i dati dell'utensile local dTDiam = 50 @@ -749,19 +781,47 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, nFacInd, rfFac, dH, dV return false, sErr end -- aggiungo geometria - EgtSetMachiningGeometry( {{ Proc.Id, nFacAdj}}) + if nFacAdj2 then + EgtSetMachiningGeometry( {{ Proc.Id, nFacAdj},{ Proc.Id, nFacAdj2}}) + else + EgtSetMachiningGeometry( {{ Proc.Id, nFacAdj}}) + end -- imposto uso faccia EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse) -- imposto accorciamento iniziale/finale per estremi aperti/chiusi - EgtSetMachiningParam( MCH_MP.STARTADDLEN, EgtIf( bOpenEnd, 0, - dTDiam / 2)) - EgtSetMachiningParam( MCH_MP.ENDADDLEN, EgtIf( bOpenStart, 0, - dTDiam / 2)) + if bSpecialApp then + -- applico gli allungamenti o accorciamenti considerando che la lavorazione è invertita + if nFacAdj2 then + EgtSetMachiningParam( MCH_MP.STARTADDLEN, dTDiam / 2) + EgtSetMachiningParam( MCH_MP.ENDADDLEN, dTDiam / 2) + else + EgtSetMachiningParam( MCH_MP.STARTADDLEN, EgtIf( bOpenEnd, dTDiam / 2, - dTDiam / 2)) + EgtSetMachiningParam( MCH_MP.ENDADDLEN, EgtIf( bOpenStart, dTDiam / 2, - dTDiam / 2)) + -- confronto la faccia applicata nella lavorazione(faccia adiacente) con la seconda faccia passata nella funzione + -- se corrispondono allora aggiungo una estensione nei lati chiusi pari all'elevazione della stessa faccia corrispondente + if nFacAdj == nFacInd2 then + if not bOpenStart then + EgtSetMachiningParam( MCH_MP.LOPERP, dFacElev2) + end + if not bOpenEnd then + EgtSetMachiningParam( MCH_MP.LIPERP, dFacElev2) + end + end + end + -- applico elevazione + local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';' + EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) + else + EgtSetMachiningParam( MCH_MP.STARTADDLEN, EgtIf( bOpenEnd, 0, - dTDiam / 2)) + EgtSetMachiningParam( MCH_MP.ENDADDLEN, EgtIf( bOpenStart, 0, - dTDiam / 2)) + end -- eseguo if not EgtApplyMachining( true, false) then local _, sErr = EgtGetLastMachMgrError() EgtSetOperationMode( nMchFId, false) return false, sErr end - return true + return true, '', dTDiam end --------------------------------------------------------------------- @@ -944,6 +1004,12 @@ local function MakeCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, n nSCC = MCH_SCC.ADIR_YP end EgtSetMachiningParam( MCH_MP.SCC, nSCC) + EgtSetMachiningParam( MCH_MP.LEADINTYPE, 0) + EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, 4) + -- allungo inizio e fine di 10mm + EgtSetMachiningParam( MCH_MP.STARTADDLEN, 10) + EgtSetMachiningParam( MCH_MP.ENDADDLEN, 10) + -- setto affondamento 0 EgtSetMachiningParam( MCH_MP.DEPTH, 0) -- Note utente con dichiarazione nessuna generazione sfridi per Vmill local sUserNotes = 'VMRS=0;' @@ -957,7 +1023,7 @@ local function MakeCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, n else local _, sWarn = EgtGetMachMgrWarning( 0) if EgtIsMachiningEmpty() then - EgtSetOperationMode( nMchFId, false) + EgtSetOperationMode( nMchId, false) return false, sWarn else return true, ( sMyWarn or sWarn) @@ -967,7 +1033,7 @@ local function MakeCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, n return true, sMyWarn end --------------------------------------------------------------------- -local function MakeDrillOnCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, nAddGrpId, dDiam) +local function MakeDrillOnCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, nAddGrpId, dDiam, bSpecialMach) local sMyWarn -- ottengo l'angolo dove applicare il foro local dMaxLen, nIdLine, tFacAdj = ChoseCorner( Proc, nFacInd) @@ -991,8 +1057,16 @@ local function MakeDrillOnCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, end -- inserisco foro if nIdIniPoint and nIdEndPoint then - -- versore direzione - local vtExtr = tFacAdj[nIdLine][nIdIniPoint] - tFacAdj[nIdLine][nIdEndPoint] + local vtExtr + if bSpecialMach then + local _, vtN0 = EgtSurfTmFacetCenter( Proc.Id, nFacInd, GDB_ID.ROOT) + local _, vtN1 = EgtSurfTmFacetCenter( Proc.Id, tFacAdj[nIdLine][1], GDB_ID.ROOT) + local _, vtN2 = EgtSurfTmFacetCenter( Proc.Id, tFacAdj[nIdLine][2], GDB_ID.ROOT) + vtExtr = vtN0 + vtN1 + vtN2 + else + -- versore direzione + vtExtr = tFacAdj[nIdLine][nIdIniPoint] - tFacAdj[nIdLine][nIdEndPoint] + end vtExtr:normalize() -- se foratura da sotto salto la lavorazione if vtExtr:getZ() < BD.DRILL_VZ_MIN then @@ -1034,12 +1108,29 @@ local function MakeDrillOnCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, dMaxDepth = 0 end -- setto griglia - EgtSetGridFrame( Frame3d( tFacAdj[nIdLine][nIdIniPoint], vtExtr)) + if bSpecialMach then + EgtSetGridFrame( Frame3d( tFacAdj[nIdLine][nIdEndPoint], vtExtr)) + else + EgtSetGridFrame( Frame3d( tFacAdj[nIdLine][nIdIniPoint], vtExtr)) + end -- creo geometria local AuxId = EgtCircle( nAddGrpId, {0,0,0}, EgtIf( bIsDrilling, dDiamTool/2, ( dDiamTool/2) + 0.1), GDB_RT.GRID) - EgtModifyCurveThickness( AuxId, -dMaxLen) -- riporto la griglia a globale - EgtSetGridFrame() + EgtSetGridFrame() + -- calcolo spessore + local dDepthBore = dMaxLen + if bSpecialMach then + -- calcolo l'elevazione + local dLenIn, dLedOut = BL.GetPointDirDepth( nPartId, tFacAdj[nIdLine][nIdEndPoint], vtExtr) + if dLenIn > 0 then + dDepthBore = dLenIn + elseif dLedOut then + dDepthBore = dLedOut + end + EgtModifyCurveThickness( AuxId, dDepthBore) + else + EgtModifyCurveThickness( AuxId, -dMaxLen) + end -- inserisco la lavorazione local sName = 'Drill_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) local nMchId = EgtAddMachining( sName, sDrilling) @@ -1057,11 +1148,16 @@ local function MakeDrillOnCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, end EgtSetMachiningParam( MCH_MP.SCC, nSCC) -- aggiusto l'affondamento - local dDepth = dMaxLen - if dDepth > dMaxDepth + 10 * GEO.EPS_SMALL then - sMyWarn = 'Warning in drill : depth (' .. EgtNumToString( dDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')' - dDepth = dMaxDepth - EgtOutLog( sMyWarn .. ' (process ' .. tostring( Proc.Id) .. ')') + local dDepth + if bSpecialMach then + dDepth = dDepthBore + else + dDepth = dMaxLen + if dDepth > dMaxDepth + 10 * GEO.EPS_SMALL then + sMyWarn = 'Warning in drill : depth (' .. EgtNumToString( dDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')' + dDepth = dMaxDepth + EgtOutLog( sMyWarn .. ' (process ' .. tostring( Proc.Id) .. ')') + end end EgtSetMachiningParam( MCH_MP.DEPTH, dDepth) -- Note utente con dichiarazione nessuna generazione sfridi per Vmill @@ -1076,7 +1172,7 @@ local function MakeDrillOnCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, else local _, sWarn = EgtGetMachMgrWarning( 0) if EgtIsMachiningEmpty() then - EgtSetOperationMode( nMchFId, false) + EgtSetOperationMode( nMchId, false) return false, sWarn else return true, ( sMyWarn or sWarn) @@ -1154,8 +1250,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd, rfFac, end end -- Se entrambi gli estremi sono aperti e possibile, lavoro con la lama --- if ( ( bOpenStart and bOpenEnd) or bForceUseBlade) and dElev < dSawMaxDepth + 10 * GEO.EPS_SMALL then - if bOpenStart and bOpenEnd and dElev < dSawMaxDepth + 10 * GEO.EPS_SMALL then + if bOpenStart and bOpenEnd and bForceUseBlade and dElev < dSawMaxDepth + 10 * GEO.EPS_SMALL then -- Recupero la lavorazione di lama local sCutting = ML.FindCutting( 'HeadSide') if not sCutting then @@ -1329,6 +1424,547 @@ local function EvaluateQParam( Proc, nRawId, bMakeVertCham, sDephtCham, sOnlyCha return nChamfer, dDepth, sErr, bForceUseBlade end +--------------------------------------------------------------------- +local function MakePocket( Proc, nPartId, ptPs, vtN, nFaceRef, nDiffWidth, sMchFind, nUseRoughTool, tBHx, sMasterPocket) + + -- calcolo il elevazione dal punto medio + local dElev + local dLenIn, dLedOut = BL.GetPointDirDepth( nPartId, ptPs, vtN[2]) + if dLenIn > 0 then + dElev = dLenIn + elseif dLedOut then + dElev = dLedOut + end + local dCollSic = 2 * BD.COLL_SIC + -- calcolo il diametro utensile + local dDiamTool + if nUseRoughTool == 1 then + dDiamTool = max( 80, min( tBHx[2][1], tBHx[2][2])) + else + -- se non uso truciolatore prendo il valore dalle dimensioni minime delle facce + dDiamTool = min( tBHx[2][1], tBHx[2][2]) + end + local sPocketing + if sMasterPocket then + sPocketing = sMasterPocket + else + sPocketing = ML.FindPocketing( sMchFind, dDiamTool, dElev + dCollSic) + end + if not sPocketing then + local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' pocketing not found in library' + EgtOutLog( sErr) + return false, sErr + end + -- inserisco la lavorazione di svuotatura + local sName = 'Pock_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. 'F' .. tostring( nFaceRef) + local nMchFId = EgtAddMachining( sName, sPocketing) + if not nMchFId then + local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing + EgtOutLog( sErr) + return false, sErr + end + -- aggiungo geometria + EgtSetMachiningGeometry( {{ Proc.Id, (nFaceRef)}}) + -- imposto uso faccia + EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.ORTHO_CONT) + -- imposto posizione braccio porta testa + if vtN[2]:getY() < GEO.EPS_SMALL then + EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM) + else + EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP) + end + -- se tasca aperta e non lavorata col truciolatore, imposto opportuno attacco + if sMchFind == 'OpenPocket' and nUseRoughTool == 0 then + EgtSetMachiningParam( MCH_MP.SUBTYPE, MCH_POCK_SUB.SPIRALIN) + end + -- imposto elevazione + local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';' + EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) + if not EgtApplyMachining( true, false) then + -- provo ad allargare leggermente la tasca + EgtSetMachiningParam( MCH_MP.OFFSR, -0.1) + if not EgtApplyMachining( true, false) then + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchFId, false) + return false, sErr + end + end + return true +end + +--------------------------------------------------------------------- +local function MachineByMill( Proc, nPhase, nRawId, nPartId, b3Solid, ptC, vtN, nBaseFace, nSideFace, ptPs, tBHx, b3Raw, nDiffWidth, nUseRoughTool, dAng, sPocketing) + + local sMchFind = 'Pocket' + -- se feature non larga come trave provo a verificare se sborda da un lato o è completamente dentro la faccia del trave + if nDiffWidth ~= 1 then sMchFind = 'OpenPocket' end + -- se feature non passante disabilito eventuale sgrossatore + if nDiffWidth ~= 0 then nUseRoughTool = 0 end + + -- se angolo tra le facce maggiore di 90, inserisco la contornatura o svuotatura del lato più corto + if ( 180 + dAng) > 90.1 then + -- se la normale della faccia corta si discosta dalla trave di più di 45° utilizzo la svutatura altrimenti la contornatura + if abs( vtN[2]:getX()) < 0.707 then -- se si discosta di più di 45° applico svuotatura + -- applico la svuotatura + local bOk, sErr = MakePocket( Proc, nPartId, ptPs, vtN, nSideFace, nDiffWidth, sMchFind, nUseRoughTool, tBHx, sPocketing) + if not bOk then + return bOk, sErr + end + -- altrimenti contornatura + else + local bOpenStart = false + local bOpenEnd = false + if nDiffWidth == 0 then + bOpenStart = true + bOpenEnd = true + else + local vAdj2 = EgtSurfTmFacetAdjacencies( Proc.Id, (nBaseFace))[1] + for j = 1, #vAdj2 do + if vAdj2[j] == (nSideFace) then + -- Se non esiste faccia adiacente a lato precedente -> inizio aperto + local i = EgtIf( j > 1, j - 1, #vAdj2) + while vAdj2[i] == (nSideFace) do + i = EgtIf( i > 1, i - 1, #vAdj2) + end + bOpenStart = ( vAdj2[i] < 0) + -- Se non esiste faccia adiacente a lato successivo -> fine aperto + local k = EgtIf( j < #vAdj2, j + 1, 1) + while vAdj2[k] == (nSideFace) do + k = EgtIf( k < #vAdj2, k + 1, 1) + end + bOpenEnd = ( vAdj2[k] < 0) + end + end + end + local sMilling = ML.FindMilling( 'LongSmallCut') + if not sMilling then + local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' milling not found in library' + EgtOutLog( sErr) + return false, sErr + end + -- recupero i dati dell'utensile + local dTDiam = 50 + if EgtMdbSetCurrMachining( sMilling) then + local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) + if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then + dTDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dTDiam + end + end + -- Calcolo uso faccia + local nFaceUse = BL.GetNearestParalOpposite( tBHx[1][3]:getVersZ()) + -- inserisco la lavorazione di fresatura + local sName = 'Mill_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) + local nMchFId = EgtAddMachining( sName, sMilling) + if not nMchFId then + local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling + EgtOutLog( sErr) + return false, sErr + end + -- aggiungo geometria + EgtSetMachiningGeometry( {{ Proc.Id, (nSideFace)}}) + -- imposto uso faccia + EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse) + -- applico gli allungamenti o accorciamenti considerando che la lavorazione è invertita + EgtSetMachiningParam( MCH_MP.STARTADDLEN, EgtIf( bOpenStart, dTDiam / 2, - dTDiam / 2)) + EgtSetMachiningParam( MCH_MP.ENDADDLEN, EgtIf( bOpenEnd, dTDiam / 2, - dTDiam / 2)) + -- eseguo + if not EgtApplyMachining( true, false) then + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchFId, false) + return false, sErr + end + end + end + return true +end + +--------------------------------------------------------------------- +local function SetOpenSide( nPathInt, vtOrtho, b3Solid, nAddGrpId, bStartPoint) + + -- fondo tra loro le curve compatibili + EgtMergeCurvesInCurveCompo( nPathInt) + local nStartIdEnt, nNumEnt = EgtCurveDomain( nPathInt) + local pLastPIni, pLastPEnd + + -- faccio una copia della curva e la esplodo + if nStartIdEnt then + -- prendo i punti + for i = 1, nNumEnt do + local pPini = EgtUP( nPathInt, (i-1), GDB_RT.GLOB) + local pPend = EgtUP( nPathInt, EgtIf( i == nNumEnt, 0, i), GDB_RT.GLOB) + -- Se normale lungo la Z considero il box in X e Y + if abs(vtOrtho:getZ()) > 0.999 then + -- se corrisponde a X + if ( abs( pPini:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL) or + ( abs( pPini:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL) then + -- setto l'entità open + local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or '' + if #sActInfo > 0 then + EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1)) + else + EgtSetInfo( nPathInt, 'OPEN', (i-1)) + end + -- prendo i punti per eventuale modifica del punto di inizio percorso + pLastPIni = pPini + pLastPEnd = pPend + -- altrimenti se corrisponde a Y + elseif ( abs( pPini:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL) or + ( abs( pPini:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL) then + -- setto l'entità open + local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or '' + if #sActInfo > 0 then + EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1)) + else + EgtSetInfo( nPathInt, 'OPEN', (i-1)) + end + -- prendo i punti per eventuale modifica del punto di inizio percorso + pLastPIni = pPini + pLastPEnd = pPend + end + -- altrimenti se normale lungo la Y considero il box in X e Z + elseif abs(vtOrtho:getZ()) < 0.001 and abs(vtOrtho:getY()) > 0.999 then + -- se corrisponde a X + if ( abs( pPini:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL) or + ( abs( pPini:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL and abs( pPend:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL) then + -- setto l'entità open + local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or '' + if #sActInfo > 0 then + EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1)) + else + EgtSetInfo( nPathInt, 'OPEN', (i-1)) + end + -- prendo i punti per eventuale modifica del punto di inizio percorso + pLastPIni = pPini + pLastPEnd = pPend + -- altrimenti se corrisponde a Z + elseif ( abs( pPini:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL) or + ( abs( pPini:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL) then + -- setto l'entità open + local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or '' + if #sActInfo > 0 then + EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1)) + else + EgtSetInfo( nPathInt, 'OPEN', (i-1)) + end + -- prendo i punti per eventuale modifica del punto di inizio percorso + pLastPIni = pPini + pLastPEnd = pPend + end + -- caso che non dovrebbe mai capitare ma gestito per completezza + -- altrimenti se normale lungo la X considero il box in Y e Z + elseif abs(vtOrtho:getZ()) < 0.001 and abs(vtOrtho:getX()) > 0.999 then + -- se corrisponde a Y + if ( abs( pPini:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMax():getY()) < 10 * GEO.EPS_SMALL) or + ( abs( pPini:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL and abs( pPend:getY() - b3Solid:getMin():getY()) < 10 * GEO.EPS_SMALL) then + -- setto l'entità open + local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or '' + if #sActInfo > 0 then + EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1)) + else + EgtSetInfo( nPathInt, 'OPEN', (i-1)) + end + -- prendo i punti per eventuale modifica del punto di inizio percorso + pLastPIni = pPini + pLastPEnd = pPend + -- altrimenti se corrisponde a Z + elseif ( abs( pPini:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMax():getZ()) < 10 * GEO.EPS_SMALL) or + ( abs( pPini:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL and abs( pPend:getZ() - b3Solid:getMin():getZ()) < 10 * GEO.EPS_SMALL) then + -- setto l'entità open + local sActInfo = EgtGetInfo( nPathInt, 'OPEN', 's') or '' + if #sActInfo > 0 then + EgtSetInfo( nPathInt, 'OPEN', sActInfo .. ',' .. (i-1)) + else + EgtSetInfo( nPathInt, 'OPEN', (i-1)) + end + -- prendo i punti per eventuale modifica del punto di inizio percorso + pLastPIni = pPini + pLastPEnd = pPend + end + end + end + -- se devo cambiare il punto di partenza + if bStartPoint and pLastPIni and pLastPEnd then + -- calcolo il punto medio con gli ultimi punti utilizzati + local ptPs = ( pLastPIni + pLastPEnd) / 2 + EgtChangeClosedCurveStartPoint( nPathInt, ptPs, GDB_RT.GLOB) + end + end +end + +--------------------------------------------------------------------- +local function MakeByPocket( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCham, nAddGrpId, sMchFindMaster, b3FacesUsed, b3Solid, bOrthoFacesMaster) + + local bOrthoFaces + local sWarn + local sMchFind = 'Pocket' + local dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt + if sMchFindMaster and #sMchFindMaster > 0 then + sMchFind = sMchFindMaster + end + if b3FacesUsed then + -- recupero la faccia con il maggior numero di adiacenze e l'elevazione relativa + local nFacInd, dFacElev, nFacInd2, dFacElev2 = BL.GetFaceWithMostAdj( Proc.Id, nPartId, b3FacesUsed) + if not nFacInd or nFacInd < 0 then + if nFacInd == -1 then + bOrthoFaces = nFacInd2 + else + local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' MakeByPocket could not find reference face' + EgtOutLog( sErr) + return -1, sErr + end + end + else + bOrthoFaces = bOrthoFacesMaster + end + + -- se è un tunnel provo a vedere se è possibile lavorarlo di con la svuotatura o con la sega catena + if bOrthoFaces then + -- ottengo le dimensioni del tunnel + dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = GetTunnelDimension( Proc, nPartId) + -- verifico la direzione + -- se devo inserire il chamfer + if nChamfer > 0 then + -- recupero la lavorazione + local sMilling = ML.FindMilling( 'Mark') + if not sMilling then + local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' chamfer not found in library' + EgtOutLog( sErr) + return -1, sErr + end + -- ottengo le curve di contorno libero + local nAuxId1, nNumIdAux + if b3FacesUsed then + nAuxId1, _ = EgtExtractSurfTmLoops( nSurfInt, nAddGrpId) + EgtModifyCurveExtrusion( nAuxId1, vtOrtho, GDB_RT.GLOB) + SetOpenSide( nAuxId1, vtOrtho, b3Solid, nAddGrpId, true) + nNumIdAux = 2 + else + nAuxId1, nNumIdAux = EgtExtractSurfTmLoops( Proc.Id, nAddGrpId) + end + if nAuxId1 then + local dExtra = 2 + for i = 1, nNumIdAux do + local AuxId + if b3FacesUsed then + if i == 1 then + AuxId = nAuxId1 + else + -- faccio la copia del percorso + AuxId = EgtCopyGlob( nAuxId1, nAddGrpId) + end + else + AuxId = nAuxId1 + i - 1 + end + local vtExtr, _, _ = EgtCurveArea( AuxId) + local fFrCurve = EgtGetGlobFrame( AuxId) + if vtExtr then + vtExtr:toGlob( fFrCurve) + if b3FacesUsed and i == nNumIdAux then + vtExtr = -vtExtr + end + if vtExtr:getZ() > -0.707 and ( abs(vtOrtho:getX()) > 0.99 or abs(vtOrtho:getY()) > 0.99 or abs(vtOrtho:getZ()) > 0.99) then + -- inserisco la lavorazione + local sNameCh = 'Cham_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( i) + local nMchId = EgtAddMachining( sNameCh, sMilling) + if not nMchId then + local sErr = 'Error adding machining ' .. sNameCh .. '-' .. sMilling + EgtOutLog( sErr) + return -1, sErr + end + -- modifico estrusione percorso + EgtModifyCurveExtrusion( AuxId, vtExtr, GDB_RT.GLOB) + -- aggiungo geometria + EgtSetMachiningGeometry( {{ AuxId, -1}}) + -- imposto posizione braccio porta testa + if vtExtr:getY() < GEO.EPS_SMALL then + EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM) + else + EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP) + end + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) + -- assegno affondamento e offset radiale + EgtSetMachiningParam( MCH_MP.DEPTH, dDepthCham + dExtra - EgtIf( b3FacesUsed, (dDepth / 2), 0)) + EgtSetMachiningParam( MCH_MP.OFFSR, dExtra) + -- se opero su 3 facce e sono al secondo e ultimo percorso inverto la lavorazione + if b3FacesUsed and i == nNumIdAux then + EgtSetMachiningParam( MCH_MP.INVERT, true) + end + -- eseguo + if not EgtApplyMachining( true, false) then + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchId, false) + return -1, sErr + end + -- se non perpendicolare emetto un warning + -- else + -- sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' : chamfer skipped because not perpendicular to face or from bottom' + -- EgtOutLog( sWarn) + end + --emetto un warning + -- else + -- sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' : chamfer skipped because not perpendicular to face' + -- EgtOutLog( sWarn) + end + end + end + end + -- se smusso non è esclusivo + if nChamfer < 2 then + -- verifico se può essere fatto con svuotatura + local bMakePocket, sPocketing, dMaxMat = VerifyIfPocket( Proc, dDimMin, vtOrtho, sMchFind) + if bMakePocket then + -- gestione svuotatura da un solo lato o anche dal lato opposto (se non verticale) + -- estraggo il contorno dalla superfice per evitare i problemi con la svuotatura + -- e assegno l'estrusione + local nPathInt, _ = EgtExtractSurfTmLoops( nSurfInt, nAddGrpId) + EgtModifyCurveExtrusion( nPathInt, vtOrtho, GDB_RT.GLOB) + -- se ho 3 facce, ciclo sulle entià del percorso per segnare quelle che sono aperte + if b3FacesUsed then + SetOpenSide( nPathInt, vtOrtho, b3Solid, nAddGrpId) + end + -- variabili per parametri lavorazione + local dMachDepth + local dElev = 0 + local bDoubleSide + -- se possibile svuotare completamente da una sola parte + if dMaxMat > ( dDepth + 2) then + dMachDepth = (dDepth / 2) + 2 + dElev = dDepth + else + -- se direzione verso la verticale setto max affondamento possibile ed + -- emetto messaggio di warning perché non lavorabile interamente + if abs(vtOrtho:getZ()) >= 0.707 then + dMachDepth = dMaxMat - (dDepth / 2) + dElev = dMaxMat + sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' : elevation bigger than max tool depth' + EgtOutLog( sWarn) + -- altrimenti setto il flag per fare la svuotatura da due parti + else + if dMaxMat > (dDepth / 2) then + dMachDepth = 1 + dElev = (dDepth / 2) + 1 + else + dMachDepth = dMaxMat - (dDepth / 2) + dElev = dMaxMat + end + bDoubleSide = true + end + end + -- inserisco la lavorazione di svuotatura + local sName = 'Pock_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) + local nMchFId = EgtAddMachining( sName, sPocketing) + if not nMchFId then + local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing + EgtOutLog( sErr) + return -1, sErr + end + -- aggiungo geometria + EgtSetMachiningGeometry( {{ nPathInt, -1}}) + -- verifico se devo invertire direzione utensile (in caso di direzione verso la verticale) + local bInvertMach + if vtOrtho:getZ() < BD.NZ_MINA and abs(vtOrtho:getZ()) >= 0.707 then + EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) + bInvertMach = true + -- altrimenti se da fare in una sola volta e direzionato verso Y+ lo inverto per lavorarlo davanti + elseif not bDoubleSide and vtOrtho:getY() > GEO.EPS_SMALL then + EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) + bInvertMach = true + end + -- imposto posizione braccio porta testa + if vtOrtho:getY() < GEO.EPS_SMALL then + if bInvertMach then + EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP) + else + EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM) + end + else + if bInvertMach then + EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM) + else + EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP) + end + end + -- se tasca aperta, imposto opportuno attacco + if sMchFind == 'OpenPocket' then + EgtSetMachiningParam( MCH_MP.SUBTYPE, MCH_POCK_SUB.SPIRALIN) + end + -- inverto il percorso di lavorazione per lavorare sinistro + EgtSetMachiningParam( MCH_MP.INVERT, true) + -- imposto affondamento + EgtSetMachiningParam( MCH_MP.DEPTH, dMachDepth) + -- imposto elevazione e dichiaro non si generano sfridi per VMill + local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';' + sNotes = sNotes .. 'VMRS=0;' + EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) + -- eseguo + if not EgtApplyMachining( true, false) then + -- provo ad allargare leggermente la tasca + EgtSetMachiningParam( MCH_MP.OFFSR, -0.1) + if not EgtApplyMachining( true, false) then + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchFId, false) + return -1, sErr + end + end + -- se posso applicare la svuotatura sul lato opposto + if bDoubleSide then + -- se anche lavorando dal lato opposto non riesco a svuotare completamente la fessura + -- setto i parametri affondamento ed emetto warning + if dMaxMat*2 < dDepth then + dMachDepth = dMaxMat - (dDepth / 2) + dElev = dMaxMat + sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' : elevation bigger than max tool depth' + EgtOutLog( sWarn) + end + -- inserisco la lavorazione di svuotatura + local sName = 'PockOppo_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) + local nMchFId = EgtAddMachining( sName, sPocketing) + if not nMchFId then + local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing + EgtOutLog( sErr) + return -1, sErr + end + -- aggiungo geometria + EgtSetMachiningGeometry( {{ nPathInt, -1}}) + -- imposto direzione utensile opposta + EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) + -- imposto posizione braccio porta testa + if vtOrtho:getY() < GEO.EPS_SMALL then + EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP) + else + EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM) + end + -- se tasca aperta, imposto opportuno attacco + if sMchFind == 'OpenPocket' then + EgtSetMachiningParam( MCH_MP.SUBTYPE, MCH_POCK_SUB.SPIRALIN) + end + -- inverto il percorso di lavorazione per lavorare sinistro + EgtSetMachiningParam( MCH_MP.INVERT, true) + -- imposo affondamento + EgtSetMachiningParam( MCH_MP.DEPTH, dMachDepth) + -- imposto elevazione e dichiaro non si generano sfridi per VMill + local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';' + sNotes = sNotes .. 'VMRS=0;' + EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) + -- eseguo + if not EgtApplyMachining( true, false) then + -- provo ad allargare leggermente la tasca + EgtSetMachiningParam( MCH_MP.OFFSR, -0.1) + if not EgtApplyMachining( true, false) then + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchFId, false) + return -1, sErr + end + end + end + return 1, sWarn, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace + end + end + end + + return 0, sWarn, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace +end + --------------------------------------------------------------------- local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId) local sWarn @@ -1368,276 +2004,88 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId) if nChamfer < 0 then return false, sErrCham end - if bClosedOrthoFaces then -- se tunnel provo a vedere se è possibile lavorarlo di con la svuotatura o con la sega catena - -- ottengo le dimensioni del tunnel - local dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = GetTunnelDimension( Proc, nPartId) - -- se devo inserire il chamfer - if nChamfer > 0 then - -- recupero la lavorazione - local sMilling = ML.FindMilling( 'Mark') - if not sMilling then - local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' chamfer not found in library' - EgtOutLog( sErr) - return false, sErr - end - -- ottengo le curve di contorno libero - local nAuxId1, nNumIdAux = EgtExtractSurfTmLoops( Proc.Id, nAddGrpId) - if nAuxId1 then - local dExtra = 2 - for i = 1, nNumIdAux do - local AuxId = nAuxId1 + i - 1 - local vtExtr, _, _ = EgtCurveArea( AuxId) - local fFrCurve = EgtGetGlobFrame( AuxId) - if vtExtr then - vtExtr:toGlob( fFrCurve) - if vtExtr:getZ() > -0.707 and ( abs(vtOrtho:getX()) > 0.99 or abs(vtOrtho:getY()) > 0.99 or abs(vtOrtho:getZ()) > 0.99) then - -- inserisco la lavorazione - local sNameCh = 'Cham_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( i) - local nMchId = EgtAddMachining( sNameCh, sMilling) - if not nMchId then - local sErr = 'Error adding machining ' .. sNameCh .. '-' .. sMilling - EgtOutLog( sErr) - return false, sErr - end - -- modifico estrusione percorso - EgtModifyCurveExtrusion( AuxId, vtExtr, GDB_RT.GLOB) - -- aggiungo geometria - EgtSetMachiningGeometry( {{ AuxId, -1}}) - -- imposto posizione braccio porta testa - if vtExtr:getY() < GEO.EPS_SMALL then - EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM) - else - EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP) - end - EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) - -- assegno affondamento e offset radiale - EgtSetMachiningParam( MCH_MP.DEPTH, dDepthCham + dExtra) - EgtSetMachiningParam( MCH_MP.OFFSR, dExtra) - -- eseguo - if not EgtApplyMachining( true, false) then - local _, sErr = EgtGetLastMachMgrError() - EgtSetOperationMode( nMchId, false) - return false, sErr - end - -- se non perpendicolare emetto un warning - -- else - -- sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' : chamfer skipped because not perpendicular to face or from bottom' - -- EgtOutLog( sWarn) - end - --emetto un warning - -- else - -- sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' : chamfer skipped because not perpendicular to face' - -- EgtOutLog( sWarn) - end - end - end + -- se è un tunnel provo a vedere se è possibile lavorarlo di con la svuotatura o con la sega catena + if bClosedOrthoFaces then + local bTryWithBlades = true + -- lavoro fessura con svuotatura + local nOk, sErr, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace = MakeByPocket( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCham, nAddGrpId, 'Pocket', false, b3Solid, bClosedOrthoFaces) + if nOk < 0 then + return false, sErr + elseif nOk > 0 then + bTryWithBlades = false end - -- se smusso non è esclusivo - if nChamfer < 2 then - -- verifico se può essere fatto con svuotatura - local bMakePocket, sPocketing, dMaxMat = VerifyIfPocket( Proc, dDimMin, vtOrtho) - if bMakePocket then - -- gestione svuotatura da un solo lato o anche dal lato opposto (se non verticale) - -- estraggo il contorno dalla superfice per evitare i problemi con la svuotatura - -- e assegno l'estrusione - local nPathInt, _ = EgtExtractSurfTmLoops( nSurfInt, nAddGrpId) - EgtModifyCurveExtrusion( nPathInt, vtOrtho, GDB_RT.GLOB) - -- variabili per parametri lavorazione - local dMachDepth - local dElev = 0 - local bDoubleSide - -- se possibile svuotare completamente da una sola parte - if dMaxMat > ( dDepth + 2) then - dMachDepth = (dDepth / 2) + 2 - dElev = dDepth - else - -- se direzione verso la verticale setto max affondamento possibile ed - -- emetto messaggio di warning perché non lavorabile interamente - if abs(vtOrtho:getZ()) >= 0.707 then - dMachDepth = dMaxMat - (dDepth / 2) - dElev = dMaxMat - sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' : elevation bigger than max tool depth' - EgtOutLog( sWarn) - -- altrimenti setto il flag per fare la svuotatura da due parti - else - if dMaxMat > (dDepth / 2) then - dMachDepth = 1 - dElev = (dDepth / 2) + 1 - else - dMachDepth = dMaxMat - (dDepth / 2) - dElev = dMaxMat - end - bDoubleSide = true - end + -- Se la svuotatura precedente non è stata fatta e chamfer non è mutuamente esclusivo provo con la sega-catena + if bTryWithBlades and nChamfer < 2 then + -- verifico se posso farlo con la sega-catena + local bMakeChainSaw, sSawing, dMaxMat, dSawCornerRad, dSawThick = VerifySawChain( Proc, dDimMin, dDimMax, vtOrtho) + if bMakeChainSaw then + -- Verifico se necessarie più passate + local nStep = ceil( ( dDimMin - 10 * GEO.EPS_SMALL) / dSawThick) + local dStep = 0 + if nStep > 1 then + dStep = ( dDimMin - dSawThick) / ( nStep - 1) end - -- inserisco la lavorazione di svuotatura - local sName = 'Pock_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) - local nMchFId = EgtAddMachining( sName, sPocketing) - if not nMchFId then - local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing - EgtOutLog( sErr) - return false, sErr - end - -- aggiungo geometria - EgtSetMachiningGeometry( {{ nPathInt, -1}}) - -- verifico se devo invertire direzione utensile (in caso di direzione verso la verticale) - local bInvertMach - if vtOrtho:getZ() < BD.NZ_MINA and abs(vtOrtho:getZ()) >= 0.707 then - EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) - bInvertMach = true - -- altrimenti se da fare in una sola volta e direzionato verso Y+ lo inverto per lavorarlo davanti - elseif not bDoubleSide and vtOrtho:getY() > GEO.EPS_SMALL then - EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) - bInvertMach = true - end - -- imposto posizione braccio porta testa - if vtOrtho:getY() < GEO.EPS_SMALL then - if bInvertMach then - EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP) - else - EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM) - end - else - if bInvertMach then - EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM) - else - EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP) - end - end - -- inverto il percorso di lavorazione per lavorare sinistro - EgtSetMachiningParam( MCH_MP.INVERT, true) - -- imposto affondamento - EgtSetMachiningParam( MCH_MP.DEPTH, dMachDepth) - -- imposto elevazione e dichiaro non si generano sfridi per VMill - local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';' - sNotes = sNotes .. 'VMRS=0;' - EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) - -- eseguo - if not EgtApplyMachining( true, false) then - -- provo ad allargare leggermente la tasca - EgtSetMachiningParam( MCH_MP.OFFSR, -0.1) - if not EgtApplyMachining( true, false) then - local _, sErr = EgtGetLastMachMgrError() - EgtSetOperationMode( nMchFId, false) - return false, sErr - end - end - -- se posso applicare la svuotatura sul lato opposto - if bDoubleSide then - -- se anche lavorando dal lato opposto non riesco a svuotare completamente la fessura - -- setto i parametri affondamento ed emetto warning - if dMaxMat*2 < dDepth then - dMachDepth = dMaxMat - (dDepth / 2) - dElev = dMaxMat - sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' : elevation bigger than max tool depth' - EgtOutLog( sWarn) - end - -- inserisco la lavorazione di svuotatura - local sName = 'PockOppo_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) - local nMchFId = EgtAddMachining( sName, sPocketing) + for i = 1, nStep do + -- inserisco la lavorazione di sawing + local sName = 'Csaw_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( i) + local nMchFId = EgtAddMachining( sName, sSawing) if not nMchFId then - local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing + local sErr = 'Error adding machining ' .. sName .. '-' .. sSawing EgtOutLog( sErr) return false, sErr end -- aggiungo geometria - EgtSetMachiningGeometry( {{ nPathInt, -1}}) - -- imposto direzione utensile opposta - EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) - -- imposto posizione braccio porta testa - if vtOrtho:getY() < GEO.EPS_SMALL then - EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP) + EgtSetMachiningGeometry( {{ Proc.Id, nLundIdFace}}) + -- imposto uso del lato faccia + -- al momento, dato che la fessura è passante da parte a parte, gestisco solo la lavorazione + -- dall'alto e di fronte (da dietro è disabilitata perchè ho exracorsa con la FAST). + -- Questa feature non è applicata su facce di testa e quindi non controllo l'entrata in X + if abs(vtOrtho:getZ()) >= 0.707 then + EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.PARAL_DOWN) + --elseif abs(vtOrtho:getZ()) < 0.707 and abs(vtOrtho:getY()) > 0.707 then else - EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM) + EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.PARAL_BACK) + --elseif abs(vtOrtho:getZ()) <= 0.707 and vtOrtho:getY() < -0.707 then + -- EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.PARAL_FRONT) + --elseif abs(vtOrtho:getZ()) < 0.707 and vtOrtho:getX() > 0.707 then + -- EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.PARAL_LEFT) + --else + -- EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.PARAL_RIGHT) + end + -- imposto offset radiale + local dOffs = ( i - 1) * dStep + EgtSetMachiningParam( MCH_MP.OFFSR, dOffs) + -- se possibile aumento l'affondamento pari al raggio corner + 1 + if dMaxMat > (dDepth + dSawCornerRad + 1) then + EgtSetMachiningParam( MCH_MP.DEPTH, (dDepth + dSawCornerRad + 1)) + -- se massimo affondamento utensile inferiore fessura, setto affondamento ed emetto warning + elseif dMaxMat < dDepth then + EgtSetMachiningParam( MCH_MP.DEPTH, dMaxMat) + sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' : elevation bigger than max tool depth' + EgtOutLog( sWarn) end - -- inverto il percorso di lavorazione per lavorare sinistro - EgtSetMachiningParam( MCH_MP.INVERT, true) - -- imposo affondamento - EgtSetMachiningParam( MCH_MP.DEPTH, dMachDepth) - -- imposto elevazione e dichiaro non si generano sfridi per VMill - local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';' - sNotes = sNotes .. 'VMRS=0;' - EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) -- eseguo if not EgtApplyMachining( true, false) then - -- provo ad allargare leggermente la tasca - EgtSetMachiningParam( MCH_MP.OFFSR, -0.1) - if not EgtApplyMachining( true, false) then - local _, sErr = EgtGetLastMachMgrError() - EgtSetOperationMode( nMchFId, false) - return false, sErr - end - end - end - -- altrimenti provo con la sega-catena - else - local bMakeChainSaw, sSawing, dMaxMat, dSawCornerRad, dSawThick = VerifySawChain( Proc, dDimMin, dDimMax, vtOrtho) - if bMakeChainSaw then - -- Verifico se necessarie più passate - local nStep = ceil( ( dDimMin - 10 * GEO.EPS_SMALL) / dSawThick) - local dStep = 0 - if nStep > 1 then - dStep = ( dDimMin - dSawThick) / ( nStep - 1) - end - for i = 1, nStep do - -- inserisco la lavorazione di sawing - local sName = 'Csaw_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( i) - local nMchFId = EgtAddMachining( sName, sSawing) - if not nMchFId then - local sErr = 'Error adding machining ' .. sName .. '-' .. sSawing - EgtOutLog( sErr) - return false, sErr - end - -- aggiungo geometria - EgtSetMachiningGeometry( {{ Proc.Id, nLundIdFace}}) - -- imposto uso del lato faccia - -- al momento, dato che la fessura è passante da parte a parte, gestisco solo la lavorazione - -- dall'alto e di fronte (da dietro è disabilitata perchè ho exracorsa con la FAST). - -- Questa feature non è applicata su facce di testa e quindi non controllo l'entrata in X - if abs(vtOrtho:getZ()) >= 0.707 then - EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.PARAL_DOWN) - --elseif abs(vtOrtho:getZ()) < 0.707 and abs(vtOrtho:getY()) > 0.707 then - else - EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.PARAL_BACK) - --elseif abs(vtOrtho:getZ()) <= 0.707 and vtOrtho:getY() < -0.707 then - -- EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.PARAL_FRONT) - --elseif abs(vtOrtho:getZ()) < 0.707 and vtOrtho:getX() > 0.707 then - -- EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.PARAL_LEFT) - --else - -- EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.PARAL_RIGHT) - end - -- imposto offset radiale - local dOffs = ( i - 1) * dStep - EgtSetMachiningParam( MCH_MP.OFFSR, dOffs) - -- se possibile aumento l'affondamento pari al raggio corner + 1 - if dMaxMat > (dDepth + dSawCornerRad + 1) then - EgtSetMachiningParam( MCH_MP.DEPTH, (dDepth + dSawCornerRad + 1)) - -- se massimo affondamento utensile inferiore fessura, setto affondamento ed emetto warning - elseif dMaxMat < dDepth then - EgtSetMachiningParam( MCH_MP.DEPTH, dMaxMat) - sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' : elevation bigger than max tool depth' - EgtOutLog( sWarn) - end - -- eseguo - if not EgtApplyMachining( true, false) then - local _, sErr = EgtGetLastMachMgrError() - EgtSetOperationMode( nMchFId, false) - return false, sErr - elseif EgtIsMachiningEmpty() then - _, sWarn = EgtGetMachMgrWarning( 0) - EgtSetOperationMode( nMchFId, false) - return false, sWarn - end + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchFId, false) + return false, sErr + elseif EgtIsMachiningEmpty() then + _, sWarn = EgtGetMachMgrWarning( 0) + EgtSetOperationMode( nMchFId, false) + return false, sWarn end end end end + -- altrimenti non è una fessura else -- dati della faccia local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, nFacInd, GDB_ID.ROOT) local rfFac, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd, GDB_ID.ROOT) -- verifico se U local bIsU = ( Proc.Fct == 3 and not TestElleShape3( Proc)) + -- verifico se due facce o L con una o due facce di terminazione + local bIsL = ( Proc.Fct == 2 or TestElleShape3( Proc) or TestElleShape4( Proc) == 2) -- se fattibile con fresa BH di fianco e spessore utensile inferiore alla larghezza faccia local bMakeBySideMill, bHead, sMilling, dMaxMat = VerifyIfByBHSideMill( Proc) if bMakeBySideMill and ( dMaxMat <= dV) then @@ -1676,127 +2124,297 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId) else -- se smusso non è esclusivo if nChamfer < 2 then - -- se orientata verso il basso, verifico l'alternativa - if vtN:getZ() < BD.NZ_MINA and nFacInd2 then - ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, nFacInd2, GDB_ID.ROOT) - nFacInd, nFacInd2 = nFacInd2, nFacInd - dFacElev, dFacElev2 = dFacElev2, dFacElev - end - rfFac, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd, GDB_ID.ROOT) - -- verifico non sia orientata verso il basso - local bFaceOk = ( vtN:getZ() >= BD.NZ_MINA) - if not bFaceOk then - local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' LapJoint from bottom impossible' - EgtOutLog( sErr) - return false, sErr - end - -- eventuali tagli preliminari - do - local bOk, sErr = MakePreCuts( Proc, nPhase, nRawId, nPartId, b3Raw) - if not bOk then return false, sErr end - end - -- recupero la lavorazione - local sMchFind = 'Pocket' - if Proc.Fct < 3 or bIsU then sMchFind = 'OpenPocket' end - local dDiam = min( dH, dV) - local dCollSic = 2 * BD.COLL_SIC - if abs( vtN:getX()) > 0.996 or abs( vtN:getY()) > 0.996 or abs( vtN:getZ()) > 0.996 then dCollSic = 0 end - --EgtOutLog( 'Mortise Find Diam =' .. EgtNumToString( dDiam)) - local sPocketing = ML.FindPocketing( sMchFind, dDiam, dFacElev + dCollSic) - -- se non trova una svuotatura adatta - if not sPocketing then - -- verifico se due facce o L con una o due facce di terminazione - local bIsL = ( Proc.Fct == 2 or TestElleShape3( Proc) or TestElleShape4( Proc) == 2) - -- provo con contornatura - if bIsL then - return MakeByMill( Proc, nPhase, nRawId, nPartId, nFacInd, rfFac, dH, dV, dFacElev) - -- altrimenti provo con la sega a catena o lama - else - local bOk, sErr, sStat = MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd, rfFac, dH, dV, dFacElev, bForceUseBlade) - if not bOk and sStat == 'MNF' then - sPocketing = ML.FindPocketing( sMchFind, dDiam) - if not sPocketing then - local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' pocketing not found in library' - EgtOutLog( sErr) - return false, sErr - end - else - return bOk, sErr - end + local bSpecial3faces = false + -- verifico se sono nel caso in cui la faccia esclusa ha elevazione più alta + if not bIsU and bIsL and Proc.Fct <= 3 and nFacInd ~= 0 and nFacInd2 ~= 0 then + -- verifico se l'elevazione della faccia 0 è maggiore dell'elevazione delle altre due facce + local rfFac0 = EgtSurfTmFacetMinAreaRectangle( Proc.Id, 0, GDB_ID.ROOT) + -- ottengo il box con la normale della faccia 0 + local bBoxF0 = EgtGetBBoxRef( Proc.Id, GDB_BB.STANDARD, rfFac0) + local dElevF0 = bBoxF0:getDimZ() + if dElevF0 > dFacElev and dElevF0 > dFacElev2 then + bSpecial3faces = true end end - -- se richiesti antischeggia con lama su U trasversale - -- rimane da gestire: se da eseguire con fresa o se richiesto lama ma impossibile utilizzarla, si utilizza fresa - if EgtGetInfo( Proc.Id, sAntisplintMode, 'i') == 1 and bIsU and - ( Proc.Box:getDimY() > b3Raw:getDimY() - 1 or Proc.Box:getDimZ() > b3Raw:getDimZ() - 1) then - -- va eseguito sulle facce diverse dalla principale - for nFacet = 0, 2 do - if nFacet ~= nFacInd then - local bOk, sErr = MakeAntiSplintBySaw( Proc, nFacet, vtN, b3Raw) - if not bOk then return false, sErr end - end - end - end - -- recupero i dati dell'utensile: utilizzo il diametro utensile per il foro opzionale - local dMaxDepth = 0 - local dDiamTool = 20 - if EgtMdbSetCurrMachining( sPocketing) then - local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) - if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then - dMaxDepth = ( EgtTdbGetCurrToolMaxDepth() or dMaxDepth) - dDiamTool = EgtTdbGetCurrToolParam( MCH_TP.DIAM) - end - end - -- inserisco la lavorazione di svuotatura - local sName = 'Pock_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) - local nMchFId = EgtAddMachining( sName, sPocketing) - if not nMchFId then - local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing - EgtOutLog( sErr) - return false, sErr - end - -- aggiungo geometria - EgtSetMachiningGeometry( {{ Proc.Id, nFacInd}}) - -- imposto uso faccia - EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.ORTHO_CONT) - -- imposto posizione braccio porta testa - if vtN:getY() < GEO.EPS_SMALL then - EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM) - else - EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP) - end - -- se tasca aperta, imposto opportuno attacco - if sMchFind == 'OpenPocket' then - EgtSetMachiningParam( MCH_MP.SUBTYPE, MCH_POCK_SUB.SPIRALIN) - end - -- se elevazione superiore a massimo affondamento della fresa, riduco opportunamente - if dFacElev > dMaxDepth + 10 * GEO.EPS_SMALL then - EgtSetMachiningParam( MCH_MP.DEPTH, dMaxDepth - dFacElev) - dFacElev = dMaxDepth - sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' : elevation bigger than max tool depth' - EgtOutLog( sWarn) - end - -- imposto elevazione e dichiaro non si generano sfridi per VMill - local sNotes = 'MaxElev=' .. EgtNumToString( dFacElev, 1) .. ';' - sNotes = sNotes .. 'VMRS=0;' - EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) - -- eseguo - if not EgtApplyMachining( true, false) then - -- provo ad allargare leggermente la tasca - EgtSetMachiningParam( MCH_MP.OFFSR, -0.1) - if not EgtApplyMachining( true, false) then - local _, sErr = EgtGetLastMachMgrError() - EgtSetOperationMode( nMchFId, false) + -- se lavorazioni di svuotatura e contornatura + if bSpecial3faces then + -- entrambe le facce non devono essere orientate verso il basso + local _, vtN2 = EgtSurfTmFacetCenter( Proc.Id, nFacInd2, GDB_ID.ROOT) + -- se orientata verso il basso, verifico l'alternativa + if vtN:getZ() < BD.NZ_MINA and vtN2:getZ() < BD.NZ_MINA then + local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' special LapJoint from bottom impossible' + EgtOutLog( sErr) return false, sErr end - end - -- se abilitato dal parametro Q inserisco foro sullo spigolo - if EgtGetInfo( Proc.Id, sInsertBoreOnCorner, 'i') == 1 then - local bOk, sWarn = MakeDrillOnCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, nAddGrpId, dDiamTool) - if not bOk then return false, sWarn end - elseif EgtGetInfo( Proc.Id, sInsertBoreOnCorner, 'i') == 2 then - local bOk, sWarn = MakeCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, nAddGrpId, dDiamTool) - if not bOk then return false, sWarn end + rfFac, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd, GDB_ID.ROOT) + rfFac2, dH2, dV2 = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd2, GDB_ID.ROOT) + -- eventuali tagli preliminari + do + local bOk, sErr = MakePreCuts( Proc, nPhase, nRawId, nPartId, b3Raw) + if not bOk then return false, sErr end + end + -- Recupero la lavorazione di fresa + local sMilling = ML.FindMilling( 'LongSmallCut') + if not sMilling then + local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' milling not found in library' + EgtOutLog( sErr) + return false, sErr + end + -- Recupero la lavorazione di svuotatura + local sMchFind = 'OpenPocket' + local dDiam = min( dH, dV) + local dDiam2 = min( dH2, dV2) + local dCollSic = 2 * BD.COLL_SIC + local dCollSic2 = 2 * BD.COLL_SIC + if abs( vtN:getX()) > 0.7 or abs( vtN:getY()) > 0.7 or abs( vtN:getZ()) > 0.7 then dCollSic = 0 end + if abs( vtN2:getX()) > 0.7 or abs( vtN2:getY()) > 0.7 or abs( vtN2:getZ()) > 0.7 then dCollSic2 = 0 end + local sPocketing = ML.FindPocketing( sMchFind, dDiam2, dFacElev2 + dCollSic2) + -- se non trova una svuotatura adatta provo ad assegnarla all'altra faccia + if not sPocketing then + dDiam, dDiam2 = dDiam2, dDiam + dCollSic, dCollSic2 = dCollSic2, dCollSic + nFacInd, nFacInd2 = nFacInd2, nFacInd + dH, dH2 = dH2, dH + dV, dV2 = dV2, dV + dFacElev, dFacElev2 = dFacElev2, dFacElev + rfFac, rfFac2 = rfFac2, rfFac + vtN, vtN2 = vtN2, vtN + sPocketing = ML.FindPocketing( sMchFind, dDiam2, dFacElev2 + dCollSic2) + if not sPocketing then + local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' pocketing not found in library' + EgtOutLog( sErr) + return false, sErr + end + end + -- provo con contornatura + local dDiamTool = 20 + if bIsL then + local bOk, sErr + bOk, sErr, dDiamTool = MakeByMill( Proc, nPhase, nRawId, nPartId, nFacInd, rfFac, dH, dV, dFacElev, true, sMilling, nFacInd2, dFacElev2) + if not bOk then return bOk, sErr end + else + local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' Impossible mill special LapJoint' + EgtOutLog( sErr) + return false, sErr + end + -- inserisco la lavorazione di svuotatura + local sName = 'Pock_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) + local nMchFId = EgtAddMachining( sName, sPocketing) + if not nMchFId then + local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing + EgtOutLog( sErr) + return false, sErr + end + -- aggiungo geometria + EgtSetMachiningGeometry( {{ Proc.Id, nFacInd2}}) + -- imposto uso faccia + EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.ORTHO_CONT) + -- imposto posizione braccio porta testa + if vtN:getY() < GEO.EPS_SMALL then + EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM) + else + EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP) + end + -- se tasca aperta, imposto opportuno attacco + if sMchFind == 'OpenPocket' then + EgtSetMachiningParam( MCH_MP.SUBTYPE, MCH_POCK_SUB.SPIRALIN) + end + -- imposto elevazione + local sNotes = 'MaxElev=' .. EgtNumToString( dFacElev2, 1) .. ';' + EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) + -- eseguo + if not EgtApplyMachining( true, false) then + -- provo ad allargare leggermente la tasca + EgtSetMachiningParam( MCH_MP.OFFSR, -0.1) + if not EgtApplyMachining( true, false) then + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchFId, false) + return false, sErr + end + end + -- se abilitato dal parametro Q inserisco foro sullo spigolo + if EgtGetInfo( Proc.Id, sInsertBoreOnCorner, 'i') == 1 then + local bOk, sWarn = MakeDrillOnCorner( Proc, nPhase, nRawId, nPartId, b3Raw, 0, nAddGrpId, dDiamTool, true) + if not bOk then return false, sWarn end + end + -- altrimenti lavorazione di svuotatura o contornatura + else + -- se orientata verso il basso, verifico l'alternativa + if vtN:getZ() < BD.NZ_MINA and nFacInd2 then + ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, nFacInd2, GDB_ID.ROOT) + nFacInd, nFacInd2 = nFacInd2, nFacInd + dFacElev, dFacElev2 = dFacElev2, dFacElev + end + rfFac, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd, GDB_ID.ROOT) + -- verifico non sia orientata verso il basso + local bFaceOk = ( vtN:getZ() >= BD.NZ_MINA) + if not bFaceOk then + local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' LapJoint from bottom impossible' + EgtOutLog( sErr) + return false, sErr + end + -- eventuali tagli preliminari + do + local bOk, sErr = MakePreCuts( Proc, nPhase, nRawId, nPartId, b3Raw) + if not bOk then return false, sErr end + end + -- recupero la lavorazione + local sMchFind = 'Pocket' + if Proc.Fct < 3 or bIsU then sMchFind = 'OpenPocket' end + local dDiam = min( dH, dV) + local dCollSic = 2 * BD.COLL_SIC + if abs( vtN:getX()) > 0.996 or abs( vtN:getY()) > 0.996 or abs( vtN:getZ()) > 0.996 then dCollSic = 0 end + --EgtOutLog( 'Mortise Find Diam =' .. EgtNumToString( dDiam)) + local sPocketing = ML.FindPocketing( sMchFind, dDiam, dFacElev + dCollSic) + -- se non trova una svuotatura adatta + if not sPocketing then + -- provo con contornatura + if bIsL then + return MakeByMill( Proc, nPhase, nRawId, nPartId, nFacInd, rfFac, dH, dV, dFacElev) + -- altrimenti provo con la sega a catena o lama + else + local bTryWithBlades = true + local nOk, bOk, sErr, sStat + -- in base al flag interno e al numero di facce e se ha forma ad U: provo prima la svuotatura sul fianco e + -- se non è possibile allora provo in seguito con lama o segacatena + -- o passare subito dalla lavorazione con lama/sega catena + if bTrySidePocketAtFirst and Proc.Fct == 3 and bIsU then + nOk, sErr = MakeByPocket( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCham, nAddGrpId, 'OpenPocket', true, b3Solid) + if nOk < 0 then + return false, sErr + elseif nOk > 0 then + bTryWithBlades = false + end + bOk = true + end + -- Se la svuotatura precedente non è stata fatta provo con le lame + if bTryWithBlades then + bOk, sErr, sStat = MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd, rfFac, dH, dV, dFacElev, bForceUseBlade) + if not bOk and sStat == 'MNF' then + sPocketing = ML.FindPocketing( sMchFind, dDiam) + if not sPocketing then + local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' pocketing not found in library' + EgtOutLog( sErr) + return false, sErr + end + else + return bOk, sErr + end + -- altrimenti ho già svuotato dal fianco, esco + else + return bOk, sErr + end + end + end + -- se richiesti antischeggia con lama su U trasversale + -- rimane da gestire: se da eseguire con fresa o se richiesto lama ma impossibile utilizzarla, si utilizza fresa + local bMadeASbyBld = false + if EgtGetInfo( Proc.Id, sAntisplintMode, 'i') == 1 and bIsU and + ( Proc.Box:getDimY() > b3Raw:getDimY() - 1 or Proc.Box:getDimZ() > b3Raw:getDimZ() - 1) then + -- va eseguito sulle facce diverse dalla principale + for nFacet = 0, 2 do + if nFacet ~= nFacInd then + local sErr + bMadeASbyBld, sErr = MakeAntiSplintBySaw( Proc, nFacet, vtN, b3Raw) + if not bMadeASbyBld then return false, sErr end + end + end + end + -- recupero i dati dell'utensile: utilizzo il diametro utensile per il foro opzionale + local dMaxDepth = 0 + local dDiamTool = 20 + if EgtMdbSetCurrMachining( sPocketing) then + local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) + if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then + dMaxDepth = ( EgtTdbGetCurrToolMaxDepth() or dMaxDepth) + dDiamTool = EgtTdbGetCurrToolParam( MCH_TP.DIAM) + end + end + -- inserisco la lavorazione di svuotatura + local sName = 'Pock_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) + local nMchFId = EgtAddMachining( sName, sPocketing) + if not nMchFId then + local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing + EgtOutLog( sErr) + return false, sErr + end + -- aggiungo geometria + EgtSetMachiningGeometry( {{ Proc.Id, nFacInd}}) + -- imposto uso faccia + EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.ORTHO_CONT) + -- imposto posizione braccio porta testa + if vtN:getY() < GEO.EPS_SMALL then + EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM) + else + EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP) + end + -- se tasca aperta, imposto opportuno attacco + if sMchFind == 'OpenPocket' then + EgtSetMachiningParam( MCH_MP.SUBTYPE, MCH_POCK_SUB.SPIRALIN) + end + -- se elevazione superiore a massimo affondamento della fresa, riduco opportunamente + if dFacElev > dMaxDepth + 10 * GEO.EPS_SMALL then + EgtSetMachiningParam( MCH_MP.DEPTH, dMaxDepth - dFacElev) + dFacElev = dMaxDepth + sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' : elevation bigger than max tool depth' + EgtOutLog( sWarn) + end + -- imposto elevazione e dichiaro non si generano sfridi per VMill + local sNotes = 'MaxElev=' .. EgtNumToString( dFacElev, 1) .. ';' + sNotes = sNotes .. 'VMRS=0;' + EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) + -- eseguo + if not EgtApplyMachining( true, false) then + -- provo ad allargare leggermente la tasca + EgtSetMachiningParam( MCH_MP.OFFSR, -0.1) + if not EgtApplyMachining( true, false) then + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchFId, false) + return false, sErr + end + end + -- se ho più di 3 facce e non di forma ad u e non sono stati inseriti antischeggia di lama + -- controllo se c'è una faccia non ortogonale alla principale e la lavoro con una contornatura o svuotatura + if ( ( Proc.Fct > 3 and not bIsU) or ( Proc.Fct == 3 and bIsU)) and not bMadeASbyBld then + -- Recupero le facce adiacenti alla principale + local vAdj = EgtSurfTmFacetAdjacencies( Proc.Id, nFacInd)[1] + if not vAdj or #vAdj == 0 then + local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' main face without adjacencies' + EgtOutLog( sErr) + return false, sErr + end + -- Cerco una faccia adiacente alla principale con angolo > 90 + local nFacAdj + local tBHx = {} + local ptCx = {} + local vtNx = {} + ptCx[1], vtNx[1] = ptC, vtN + tBHx[1] = {dH, dV, rfFac} + for i = 1, #vAdj do + if vAdj[i] >= 0 then + local bAdj, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, nFacInd, vAdj[i], GDB_ID.ROOT) + if bAdj and dAng < 0 and 180 + dAng > 90.1 then + local rfFac2, dH2, dV2 = EgtSurfTmFacetMinAreaRectangle( Proc.Id, vAdj[i], GDB_ID.ROOT) + local ptC2, vtN2 = EgtSurfTmFacetCenter( Proc.Id, vAdj[i], GDB_ID.ROOT) + ptCx[2], vtNx[2] = ptC2, vtN2 + tBHx[2] = {dH2, dV2, rfFac2} + local ptPs = ( ptP1 + ptP2) / 2 + local bOk, sErr = MachineByMill( Proc, nPhase, nRawId, nPartId, b3Solid, ptCx, vtNx, nFacInd, vAdj[i], ptPs, tBHx, b3Raw, 2, 0, dAng, sPocketing) + if not bOk then + return bOk, sErr + end + end + end + end + end + -- se abilitato dal parametro Q inserisco foro sullo spigolo + if EgtGetInfo( Proc.Id, sInsertBoreOnCorner, 'i') == 1 then + local bOk, sWarn = MakeDrillOnCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, nAddGrpId, dDiamTool) + if not bOk then return false, sWarn end + elseif EgtGetInfo( Proc.Id, sInsertBoreOnCorner, 'i') == 2 then + local bOk, sWarn = MakeCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, nAddGrpId, dDiamTool) + if not bOk then return false, sWarn end + end end end end diff --git a/LuaLibs/ProcessSimpleScarf.lua b/LuaLibs/ProcessSimpleScarf.lua index 4a45266..7f794a9 100644 --- a/LuaLibs/ProcessSimpleScarf.lua +++ b/LuaLibs/ProcessSimpleScarf.lua @@ -35,6 +35,92 @@ function ProcessSimpleScarf.Classify( Proc) return true, false end +--------------------------------------------------------------------- +-- lavorazione smussi +local function MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead) + -- verifico che lo smusso sia richiesto + local dDepth = EgtGetInfo( Proc.Id, 'Q01', 'd') or 0 + if dDepth < 0.1 then return true end + -- ingombro del grezzo + local b3Raw = EgtGetRawPartBBox( nRawId) + -- recupero e verifico l'entità curva associata + local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i') or 0 + if AuxId then AuxId = AuxId + Proc.Id end + if not AuxId or ( EgtGetType( AuxId) & GDB_FY.GEO_CURVE) == 0 then + local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' missing profile geometry' + EgtOutLog( sErr) + return false, sErr + end + -- recupero i dati della curva e del profilo + local dWidth = abs( EgtCurveThickness( AuxId)) + local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB) + -- eseguo lo smusso solo se direzione orizzontale + if abs( vtExtr:getZ()) > 0.1 then + local sWarn = 'Warning on process ' .. tostring( Proc.Id) .. ' skipped not horizontale chamfer' + EgtOutLog( sWarn) + return true + end + -- eseguo lo smusso solo se feature larga come la trave + if dWidth < b3Raw:getDimY() - 1 then + local sWarn = 'Warning on process ' .. tostring( Proc.Id) .. ' skipped chamfer (feature smaller than beam)' + EgtOutLog( sWarn) + return true + end + local dExtra = 2 + -- recupero la lavorazione + local sMilling = ML.FindMilling( 'Mark') + if not sMilling then + local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' milling not found in library' + EgtOutLog( sErr) + return false, sErr + end + -- Inserisco la lavorazione del lato standard + local sName1 = 'SJN_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) + local nMch1Id = EgtAddMachining( sName1, sMilling) + if not nMch1Id then + local sErr = 'Error adding machining ' .. sName1 .. '-' .. sMilling + EgtOutLog( sErr) + return false, sErr + end + -- aggiungo geometria + EgtSetMachiningGeometry( {{ AuxId, -1}}) + -- assegno affondamento e offset radiale + EgtSetMachiningParam( MCH_MP.DEPTH, dDepth + dExtra) + EgtSetMachiningParam( MCH_MP.OFFSR, dExtra) + -- assegno lato di lavoro + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT) + -- eseguo + if not EgtApplyMachining( true, false) then + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchId, false) + return false, sErr + end + -- Inserisco la lavorazione del lato opposto + local sName2 = 'SJN_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) + local nMch2Id = EgtAddMachining( sName2, sMilling) + if not nMch2Id then + local sErr = 'Error adding machining ' .. sName2 .. '-' .. sMilling + EgtOutLog( sErr) + return false, sErr + end + -- aggiungo geometria + EgtSetMachiningGeometry( {{ AuxId, -1}}) + -- inverto direzione utensile + EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) + -- assegno affondamento e offset radiale + EgtSetMachiningParam( MCH_MP.DEPTH, dDepth + dExtra) + EgtSetMachiningParam( MCH_MP.OFFSR, dExtra) + -- assegno lato di lavoro + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) + -- eseguo + if not EgtApplyMachining( true, false) then + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchId, false) + return false, sErr + end + return true +end + --------------------------------------------------------------------- -- Applicazione della lavorazione function ProcessSimpleScarf.Make( Proc, nPhase, nRawId, nPartId, dOvmHead) @@ -128,6 +214,9 @@ function ProcessSimpleScarf.Make( Proc, nPhase, nRawId, nPartId, dOvmHead) if not bOk then return bOk, sNameOrErr end end end + -- inserimento smussi +-- local bOkc, sErrC = MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead) +-- if not bOkc then return bOkc, sErrC end -- se esistono faccia interna ed intermedia, verifico se richiedono taglio a cubetti local vCuts = {} if vFaceOrd[2] ~= 0 and vFaceOrd[3] ~= 0 then diff --git a/LuaLibs/ProcessStepJointNotch.lua b/LuaLibs/ProcessStepJointNotch.lua index d1900fd..dfaa151 100644 --- a/LuaLibs/ProcessStepJointNotch.lua +++ b/LuaLibs/ProcessStepJointNotch.lua @@ -1,4 +1,4 @@ --- ProcessStepJointNotch.lua by Egaltech s.r.l. 2020/02/11 +-- ProcessStepJointNotch.lua by Egaltech s.r.l. 2020/03/17 -- Gestione calcolo tacca a gradino per Travi -- Tabella per definizione modulo @@ -29,17 +29,17 @@ function ProcessStepJointNotch.Classify( Proc) -- numero delle facce local nFacetCnt = EgtSurfTmFacetCount( Proc.Id) -- gestisco solo 2 o 4 facce - if nFacetCnt ~= 2 and nFacetCnt ~= 4 then + if nFacetCnt ~= 2 and nFacetCnt ~= 4 and nFacetCnt ~= 6 and nFacetCnt ~= 8 then return false, false end -- verifico le normali delle facce local bDown = false for i = 1, nFacetCnt do local vtN = EgtSurfTmFacetNormVersor( Proc.Id, i-1, GDB_ID.ROOT) - -- se faccia limite + -- se faccia limite la salto if AreSameOrOppositeVectorApprox( vtN, Y_AX()) or AreSameOrOppositeVectorApprox( vtN, Z_AX()) then -- attualmente non gestita - return false, false +-- return false, false -- altrimenti faccia principale elseif vtN:getZ() < -0.1 then bDown = true @@ -49,41 +49,8 @@ function ProcessStepJointNotch.Classify( Proc) end --------------------------------------------------------------------- --- Lavorazione di due facce -local function MakeTwoFaces( Proc, nPhase, nRawId, nPartId, dOvmHead) - -- ingombro del grezzo - local b3Raw = EgtGetRawPartBBox( nRawId) - -- ingombro del pezzo - local Ls = EgtGetFirstNameInGroup( nPartId, 'Box') - local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD) - if not b3Solid then - local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' part box not found' - EgtOutLog( sErr) - return false, sErr - end - -- dati delle facce - local ptC = {} - local vtN = {} - ptC[1], vtN[1] = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT) - ptC[2], vtN[2] = EgtSurfTmFacetCenter( Proc.Id, 1, GDB_ID.ROOT) - -- normale media per capire se taglio di testa o di coda - local vtNm = ( vtN[1] + vtN[2]) ; vtNm:normalize() - local bHead = ( vtNm:getX() > 0) - -- angolo diedro - local bAdj, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, 0, 1, GDB_ID.ROOT) - local bOnY = true - local ptPs = ( ptC[1] + ptC[2]) / 2 - if bAdj then - local vtDir = ptP1 - ptP2 ; vtDir:normalize() - bOnY = abs( vtDir:getZ()) > 0.5 and ( abs( vtDir:getZ()) + abs( vtDir:getX()) > abs( vtDir:getY())) - ptPs = ( ptP1 + ptP2) / 2 - bConvex = ( dAng > 0) - end - -- determino quale faccia è più grande - local _, dB1, dH1 = EgtSurfTmFacetMinAreaRectangle( Proc.Id, 0) - local _, dB2, dH2 = EgtSurfTmFacetMinAreaRectangle( Proc.Id, 1) - local nBigInd = EgtIf( dB1 * dH1 >= dB2 * dH2, 1, 2) - local nSmaInd = 3 - nBigInd +local function MachineByBlade( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Solid, ptC, vtN, nBigInd, nSmaInd, bOnY, ptPs, b3Raw) + -- recupero la lavorazione local sCutting = ML.FindCutting( 'HeadSide') if not sCutting then @@ -150,14 +117,237 @@ local function MakeTwoFaces( Proc, nPhase, nRawId, nPartId, dOvmHead) return bOk, sErr end end + + return true +end + +--------------------------------------------------------------------- +local function MakePocket( Proc, nPartId, ptPs, vtN, nFaceRef, nDiffWidth, sMchFind, nUseRoughTool, tBHx) + + -- calcolo il elevazione dal punto medio + local dElev + local dLenIn, dLedOut = BL.GetPointDirDepth( nPartId, ptPs, vtN[nFaceRef]) + if dLenIn > 0 then + dElev = dLenIn + elseif dLedOut then + dElev = dLedOut + end + local dCollSic = 2 * BD.COLL_SIC + -- calcolo il diametro utensile + local dDiamTool + if nUseRoughTool == 1 then + dDiamTool = max( 80, min( tBHx[nFaceRef][1], tBHx[nFaceRef][2])) + else + -- se non uso truciolatore prendo il valore dalle dimensioni minime delle facce + dDiamTool = min( tBHx[nFaceRef][1], tBHx[nFaceRef][2]) + end + local sPocketing = ML.FindPocketing( sMchFind, dDiamTool, dElev + dCollSic) + if not sPocketing then + local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' pocketing not found in library' + EgtOutLog( sErr) + return false, sErr + end + -- inserisco la lavorazione di svuotatura + local sName = 'Pock_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. 'F' .. tostring( nFaceRef - 1) + local nMchFId = EgtAddMachining( sName, sPocketing) + if not nMchFId then + local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing + EgtOutLog( sErr) + return false, sErr + end + -- aggiungo geometria + EgtSetMachiningGeometry( {{ Proc.Id, (nFaceRef-1)}}) + -- imposto uso faccia + EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.ORTHO_CONT) + -- imposto posizione braccio porta testa + if vtN[nFaceRef]:getY() < GEO.EPS_SMALL then + EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM) + else + EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP) + end + -- se tasca aperta e non lavorata col truciolatore, imposto opportuno attacco + if sMchFind == 'OpenPocket' and nUseRoughTool == 0 then + EgtSetMachiningParam( MCH_MP.SUBTYPE, MCH_POCK_SUB.SPIRALIN) + end + -- imposto elevazione + local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 1) .. ';' + EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) + if not EgtApplyMachining( true, false) then + -- provo ad allargare leggermente la tasca + EgtSetMachiningParam( MCH_MP.OFFSR, -0.1) + if not EgtApplyMachining( true, false) then + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchFId, false) + return false, sErr + end + end + return true +end + +--------------------------------------------------------------------- +local function MachineByMill( Proc, nPhase, nRawId, nPartId, b3Solid, ptC, vtN, nBigInd, nSmaInd, ptPs, tBHx, b3Raw, nDiffWidth, nUseRoughTool, dAng) + + local sMchFind = 'Pocket' + -- se feature non larga come trave provo a verificare se sborda da un lato o è completamente dentro la faccia del trave + if nDiffWidth ~= 1 then sMchFind = 'OpenPocket' end + -- se feature non passante disabilito eventuale sgrossatore + if nDiffWidth ~= 0 then nUseRoughTool = 0 end + + -- applico la svuotatura + local bOk, sErr = MakePocket( Proc, nPartId, ptPs, vtN, nBigInd, nDiffWidth, sMchFind, nUseRoughTool, tBHx) + if not bOk then + return bOk, sErr + end + + -- se angolo tra le facce maggiore di 90, inserisco la contornatura o svuotatura del lato più corto + if ( 180 + dAng) > 90.1 then + -- se la normale della faccia corta si discosta dalla trave di più di 30 gradi utilizzo la svutatura altrimenti la contornatura + if abs( vtN[nSmaInd]:getX()) < 0.866 then -- se si discosta di più di 30° applico svuotatura + -- applico la svuotatura + local bOk, sErr = MakePocket( Proc, nPartId, ptPs, vtN, nSmaInd, nDiffWidth, sMchFind, nUseRoughTool, tBHx) + if not bOk then + return bOk, sErr + end + -- altrimenti contornatura + else + local bOpenStart = false + local bOpenEnd = false + if nDiffWidth == 0 then + bOpenStart = true + bOpenEnd = true + else + local vAdj2 = EgtSurfTmFacetAdjacencies( Proc.Id, (nBigInd-1))[1] + for j = 1, #vAdj2 do + if vAdj2[j] == (nSmaInd-1) then + -- Se non esiste faccia adiacente a lato precedente -> inizio aperto + local i = EgtIf( j > 1, j - 1, #vAdj2) + while vAdj2[i] == (nSmaInd-1) do + i = EgtIf( i > 1, i - 1, #vAdj2) + end + bOpenStart = ( vAdj2[i] < 0) + -- Se non esiste faccia adiacente a lato successivo -> fine aperto + local k = EgtIf( j < #vAdj2, j + 1, 1) + while vAdj2[k] == (nSmaInd-1) do + k = EgtIf( k < #vAdj2, k + 1, 1) + end + bOpenEnd = ( vAdj2[k] < 0) + end + end + end + local sMilling = ML.FindMilling( 'LongSmallCut') + if not sMilling then + local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' milling not found in library' + EgtOutLog( sErr) + return false, sErr + end + -- recupero i dati dell'utensile + local dTDiam = 50 + if EgtMdbSetCurrMachining( sMilling) then + local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) + if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then + dTDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dTDiam + end + end + -- Calcolo uso faccia + local nFaceUse = BL.GetNearestParalOpposite( tBHx[nBigInd][3]:getVersZ()) + -- inserisco la lavorazione di fresatura + local sName = 'Mill_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) + local nMchFId = EgtAddMachining( sName, sMilling) + if not nMchFId then + local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling + EgtOutLog( sErr) + return false, sErr + end + -- aggiungo geometria + EgtSetMachiningGeometry( {{ Proc.Id, (nSmaInd-1)}}) + -- imposto uso faccia + EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse) + -- applico gli allungamenti o accorciamenti considerando che la lavorazione è invertita + EgtSetMachiningParam( MCH_MP.STARTADDLEN, EgtIf( bOpenStart, dTDiam / 2, - dTDiam / 2)) + EgtSetMachiningParam( MCH_MP.ENDADDLEN, EgtIf( bOpenEnd, dTDiam / 2, - dTDiam / 2)) + -- eseguo + if not EgtApplyMachining( true, false) then + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchFId, false) + return false, sErr + end + end + end return true end --------------------------------------------------------------------- -- Lavorazione di due facce -local function MakeFourFaces( Proc, nPhase, nRawId, nPartId, dOvmHead) +local function MakeTwoFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, nDiffWidth) + -- ingombro del grezzo + local b3Raw = EgtGetRawPartBBox( nRawId) + -- ingombro del pezzo + local Ls = EgtGetFirstNameInGroup( nPartId, 'Box') + local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD) + if not b3Solid then + local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' part box not found' + EgtOutLog( sErr) + return false, sErr + end + -- dati delle facce + local tBHx = {} + local ptC = {} + local vtN = {} + ptC[1], vtN[1] = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT) + ptC[2], vtN[2] = EgtSurfTmFacetCenter( Proc.Id, 1, GDB_ID.ROOT) + -- normale media per capire se taglio di testa o di coda + local vtNm = ( vtN[1] + vtN[2]) ; vtNm:normalize() + local bHead = ( vtNm:getX() > 0) + -- angolo diedro + local bAdj, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, 0, 1, GDB_ID.ROOT) + local bOnY = true + local ptPs = ( ptC[1] + ptC[2]) / 2 + local bConvex + if bAdj then + local vtDir = ptP1 - ptP2 ; vtDir:normalize() + bOnY = abs( vtDir:getZ()) > 0.5 and ( abs( vtDir:getZ()) + abs( vtDir:getX()) > abs( vtDir:getY())) + ptPs = ( ptP1 + ptP2) / 2 + bConvex = ( dAng > 0) + end + -- determino quale faccia è più grande + local rfFac1, dH1, dV1 = EgtSurfTmFacetMinAreaRectangle( Proc.Id, 0, GDB_ID.ROOT) + local rfFac2, dH2, dV2 = EgtSurfTmFacetMinAreaRectangle( Proc.Id, 1, GDB_ID.ROOT) + local nBigInd = EgtIf( dV1 * dH1 >= dV2 * dH2, 1, 2) + local nSmaInd = 3 - nBigInd + tBHx[1] = {dH1, dV1, rfFac1} + tBHx[2] = {dH2, dV2, rfFac2} + -- verifico parametro Q per stabilire se deve essere lavorato con truciolatore + -- o se larghezza inferiore del trave, utilizzare una svuotatura + local nUseRoughTool = EgtGetInfo( Proc.Id, 'Q02', 'i') or 0 + -- se feature non è larga come trave o è selezionato l'utilizzo del truciolatore utilizzo svuotatura + if nDiffWidth > 0 or nUseRoughTool == 1 then + -- se angolo compreso è >= di 90° applico svuotatura con fresa + if not bConvex and ( 180 + dAng) >= 90 then + local bOk, sErr = MachineByMill( Proc, nPhase, nRawId, nPartId, b3Solid, ptC, vtN, nBigInd, nSmaInd, ptPs, tBHx, b3Raw, nDiffWidth, nUseRoughTool, dAng) + if not bOk then + return bOk, sErr + end + else + local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' internal angle less than square angle' + EgtOutLog( sErr) + return false, sErr + end + -- altrimenti provo a lavorare con la lama + else + local bOk, sErr = MachineByBlade( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Solid, ptC, vtN, nBigInd, nSmaInd, bOnY, ptPs, b3Raw) + if not bOk then + return bOk, sErr + end + end + + return true +end + +--------------------------------------------------------------------- +-- Lavorazione di due facce +local function MakeFourFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, nDiffWidth) -- Prime due facce - local bOk, sErr = MakeTwoFaces( Proc, nPhase, nRawId, nPartId, dOvmHead) + local bOk, sErr = MakeTwoFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, nDiffWidth) if not bOk then return bOk, sErr end -- Seconde due facce -- recupero gruppo per geometria addizionale @@ -175,7 +365,7 @@ local function MakeFourFaces( Proc, nPhase, nRawId, nPartId, dOvmHead) EgtSetName( AddId, 'AddCut_' .. tostring( Proc.Id)) -- applico lavorazione local NewProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg} - local bOk, sErr = MakeTwoFaces( NewProc, nPhase, nRawId, nPartId, dOvmHead) + local bOk, sErr = MakeTwoFaces( NewProc, nPhase, nRawId, nPartId, dOvmHead, nDiffWidth) if not bOk then return bOk, sErr end end return true @@ -184,9 +374,6 @@ end --------------------------------------------------------------------- -- lavorazione smussi local function MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead) - -- verifico che lo smusso sia richiesto - local dDepth = EgtGetInfo( Proc.Id, 'Q01', 'd') or 0 - if dDepth < 0.1 then return true end -- ingombro del grezzo local b3Raw = EgtGetRawPartBBox( nRawId) -- recupero e verifico l'entità curva associata @@ -200,18 +387,100 @@ local function MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead) -- recupero i dati della curva e del profilo local dWidth = abs( EgtCurveThickness( AuxId)) local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB) - -- eseguo lo smusso solo se direzione orizzontale - if abs( vtExtr:getZ()) > 0.1 then - local sWarn = 'Warning on process ' .. tostring( Proc.Id) .. ' skipped not horizontale chamfer' - EgtOutLog( sWarn) - return true + -- prendo il boundig box della feature + local bBoxExtr = EgtGetBBoxGlob( AuxId, GDB_BB.STANDARD ) + local nTypePos = 0 + -- determino se sborda da un lato + if abs( vtExtr:getZ()) < 0.1 then -- se orizzontale + -- se altezza percorso inferiore della larghezza trave + if dWidth < b3Raw:getDimY() - 1 then + nTypePos = 1 + -- verifico se sborda verso y+ + if abs( bBoxExtr:getMax():getY() - b3Raw:getMax():getY()) < 0.1 then + nTypePos = 2 + -- se sborda verso y- + elseif abs( bBoxExtr:getMin():getY() - b3Raw:getMin():getY()) < 0.1 then + nTypePos = 3 + end + end + elseif abs( vtExtr:getZ()) > 0.9 then -- se verticale + -- se altezza percorso inferiore della larghezza trave + if dWidth < b3Raw:getDimZ() - 1 then + nTypePos = 1 + -- verifico se sborda verso z+ + if abs( bBoxExtr:getMax():getZ() - b3Raw:getMax():getZ()) < 0.1 then + nTypePos = 4 + -- se sborda verso z- + elseif abs( bBoxExtr:getMin():getZ() - b3Raw:getMin():getZ()) < 0.1 then + nTypePos = 5 + end + end + else -- altrimenti se altra direzione setto per non fare smussi + nTypePos = 6 end - -- eseguo lo smusso solo se feature larga come la trave - if dWidth < b3Raw:getDimY() - 1 then + + -- verifico che lo smusso sia richiesto + local dDepth = EgtGetInfo( Proc.Id, 'Q01', 'd') or 0 + if dDepth < 0.1 then return true, '', nTypePos end + + -- disabilito smusso se feature non sborda dalla trave almeno da un lato + if nTypePos == 1 then local sWarn = 'Warning on process ' .. tostring( Proc.Id) .. ' skipped chamfer (feature smaller than beam)' EgtOutLog( sWarn) - return true + return true, sWarn , nTypePos end + -- salto lo smusso se sborda dal lato in Z- o una direzione diversa da Y e Z + if nTypePos >= 5 then + local sWarn = 'Warning on process ' .. tostring( Proc.Id) .. ' skipped chamfer (wrong side to apply)' + EgtOutLog( sWarn) + return true, sWarn, nTypePos + end + local bExeNormal = true + local bExeOpposite = true + -- controllo le lavorazioni quando la feature è orizzontale + if abs( vtExtr:getY()) > 0.99 then + -- se diretta verso Y+ + if vtExtr:getY() > 0 then + -- se sborda verso Y+ abilito solo la lavorazione della parte normale + if nTypePos == 2 then + bExeOpposite = false + -- se sborda verso Y- abilito solo la lavorazione della parte opposta + elseif nTypePos == 3 then + bExeNormal = false + end + -- altrimenti diretta verso Y- + else + -- se sborda verso Y+ abilito solo la lavorazione della parte opposta + if nTypePos == 2 then + bExeNormal = false + -- se sborda verso Y- abilito solo la lavorazione della parte normale + elseif nTypePos == 3 then + bExeOpposite = false + end + end + -- se diretta verso Z + elseif abs( vtExtr:getZ()) > 0.99 then + -- se diretta verso Z+ + if vtExtr:getZ() > 0 then + -- se sborda verso Z+ abilito solo la lavorazione della parte normale + if nTypePos == 4 or nTypePos == 0 then + bExeOpposite = false + else -- altrimenti disabilito entrambe + bExeNormal = false + bExeOpposite = false + end + -- altrimenti diretta verso Z- + else + -- se sborda verso Z+ abilito solo la lavorazione della parte opposta + if nTypePos == 4 or nTypePos == 0 then + bExeNormal = false + else -- altrimenti disabilito entrambe + bExeNormal = false + bExeOpposite = false + end + end + end + local dExtra = 2 -- recupero la lavorazione local sMilling = ML.FindMilling( 'Mark') @@ -220,66 +489,85 @@ local function MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead) EgtOutLog( sErr) return false, sErr end - -- Inserisco la lavorazione del lato standard - local sName1 = 'SJN_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) - local nMch1Id = EgtAddMachining( sName1, sMilling) - if not nMch1Id then - local sErr = 'Error adding machining ' .. sName1 .. '-' .. sMilling - EgtOutLog( sErr) - return false, sErr + if bExeNormal then + -- Inserisco la lavorazione del lato standard + local sName1 = 'SJN_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) + local nMch1Id = EgtAddMachining( sName1, sMilling) + if not nMch1Id then + local sErr = 'Error adding machining ' .. sName1 .. '-' .. sMilling + EgtOutLog( sErr) + return false, sErr + end + -- aggiungo geometria + EgtSetMachiningGeometry( {{ AuxId, -1}}) + -- assegno affondamento e offset radiale + EgtSetMachiningParam( MCH_MP.DEPTH, dDepth + dExtra) + EgtSetMachiningParam( MCH_MP.OFFSR, dExtra) + -- assegno lato di lavoro + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT) + -- eseguo + if not EgtApplyMachining( true, false) then + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchId, false) + return false, sErr + end end - -- aggiungo geometria - EgtSetMachiningGeometry( {{ AuxId, -1}}) - -- assegno affondamento e offset radiale - EgtSetMachiningParam( MCH_MP.DEPTH, dDepth + dExtra) - EgtSetMachiningParam( MCH_MP.OFFSR, dExtra) - -- assegno lato di lavoro - EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT) - -- eseguo - if not EgtApplyMachining( true, false) then - local _, sErr = EgtGetLastMachMgrError() - EgtSetOperationMode( nMchId, false) - return false, sErr + if bExeOpposite then + -- Inserisco la lavorazione del lato opposto + local sName2 = 'SJN_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) + local nMch2Id = EgtAddMachining( sName2, sMilling) + if not nMch2Id then + local sErr = 'Error adding machining ' .. sName2 .. '-' .. sMilling + EgtOutLog( sErr) + return false, sErr + end + -- aggiungo geometria + EgtSetMachiningGeometry( {{ AuxId, -1}}) + -- inverto direzione utensile + EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) + -- assegno affondamento e offset radiale + EgtSetMachiningParam( MCH_MP.DEPTH, dDepth + dExtra) + EgtSetMachiningParam( MCH_MP.OFFSR, dExtra) + -- assegno lato di lavoro + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) + -- eseguo + if not EgtApplyMachining( true, false) then + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchId, false) + return false, sErr + end end - -- Inserisco la lavorazione del lato opposto - local sName2 = 'SJN_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) - local nMch2Id = EgtAddMachining( sName2, sMilling) - if not nMch2Id then - local sErr = 'Error adding machining ' .. sName2 .. '-' .. sMilling - EgtOutLog( sErr) - return false, sErr - end - -- aggiungo geometria - EgtSetMachiningGeometry( {{ AuxId, -1}}) - -- inverto direzione utensile - EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) - -- assegno affondamento e offset radiale - EgtSetMachiningParam( MCH_MP.DEPTH, dDepth + dExtra) - EgtSetMachiningParam( MCH_MP.OFFSR, dExtra) - -- assegno lato di lavoro - EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) - -- eseguo - if not EgtApplyMachining( true, false) then - local _, sErr = EgtGetLastMachMgrError() - EgtSetOperationMode( nMchId, false) - return false, sErr - end - return true + return true, '', nTypePos end --------------------------------------------------------------------- -- Applicazione della lavorazione function ProcessStepJointNotch.Make( Proc, nPhase, nRawId, nPartId, dOvmHead) -- esecuzione eventuale smusso - local bOkc, sErrC = MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead) + -- ottengo anche il flag che indica che la feature è larga come la trave + local bOkc, sErrC, nDiffWidth = MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead) if not bOkc then return bOkc, sErrC end + -- come fatto nella classify, conto solo le facce che non sono dirette in Y o Z + local nFacetCnt = EgtSurfTmFacetCount( Proc.Id) + local nUsableFaces = 0 + + for i = 1, nFacetCnt do + local vtN = EgtSurfTmFacetNormVersor( Proc.Id, i-1, GDB_ID.ROOT) + -- se faccia limite la salto + if AreSameOrOppositeVectorApprox( vtN, Y_AX()) or AreSameOrOppositeVectorApprox( vtN, Z_AX()) then + -- altrimenti faccia principale + else + nUsableFaces = nUsableFaces + 1 + end + end + -- se due facce - if Proc.Fct == 2 then - local bOk, sErr = MakeTwoFaces( Proc, nPhase, nRawId, nPartId, dOvmHead) + if nUsableFaces == 2 then + local bOk, sErr = MakeTwoFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, nDiffWidth) if not bOk then return bOk, sErr end -- se quattro facce - elseif Proc.Fct == 4 then - local bOk, sErr = MakeFourFaces( Proc, nPhase, nRawId, nPartId, dOvmHead) + elseif nUsableFaces == 4 then + local bOk, sErr = MakeFourFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, nDiffWidth) if not bOk then return bOk, sErr end -- altrimenti errore else