diff --git a/LuaLibs/BeamLib.lua b/LuaLibs/BeamLib.lua index 5525af3..ac1d639 100644 --- a/LuaLibs/BeamLib.lua +++ b/LuaLibs/BeamLib.lua @@ -1,4 +1,4 @@ --- BeamLib.lua by Egaltech s.r.l. 2021/04/27 +-- BeamLib.lua by Egaltech s.r.l. 2021/06/27 -- Libreria globale per Travi -- 2020/07/28 Corretto calcolo attacchi e uscite di lame per non uscire dalla faccia sotto. -- 2020/08/18 Aggiunto a GetNearestParalOpposite e GetNearestOrthoOpposite parametro opzionale vtNorm. @@ -10,6 +10,7 @@ -- 2021/02/26 In taglio lama consento attacco anche da sotto (grazie a migliorie in MachKernel). -- 2021/03/22 Attacchi e uscite di tagli longitudinali da sotto con lama solo ortogonali. -- 2021/04/27 Migliorati controlli per attacchi e uscite Tg con lama. +-- 2021/06/27 Aggiunta funzione GetOtherFaceElevation. -- Tabella per definizione modulo local BeamLib = {} @@ -418,27 +419,55 @@ end --------------------------------------------------------------------- function BeamLib.GetFaceElevation( nSurfId, nFac, nPartId) + -- centro e normale della faccia local ptC, vtN = EgtSurfTmFacetCenter( nSurfId, nFac, GDB_ID.ROOT) if not ptC or not vtN then return 0 end + -- riferimento OCS della faccia per ricavare elevazione rispetto alla faccia della superficie local frOCS = Frame3d( ptC, vtN) ; local b3Box = EgtGetBBoxRef( nSurfId, GDB_BB.STANDARD, frOCS) local dElev = b3Box:getMax():getZ() + -- se definito identificativo di pezzo if nPartId then + -- se superficie con più facce if EgtSurfTmFacetCount( nSurfId) > 1 then + -- determino elevazione del centro faccia rispetto al box del pezzo local _, dCenElev = BeamLib.GetPointDirDepth( nPartId, ptC, vtN) if dCenElev and dCenElev > dElev then dElev = dCenElev end + -- altrimenti superficie ad una sola faccia else + -- determino elevazione box del pezzo rispetto alla faccia local b3Solid = EgtGetBBoxRef( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD, frOCS) - if b3Solid and b3Solid:getMax():getZ() > dElev then - dElev = b3Solid:getMax():getZ() + local dSolidElev = b3Solid:getMax():getZ() + if b3Solid and dSolidElev > dElev then + dElev = dSolidElev end end end return dElev end +--------------------------------------------------------------------- +function BeamLib.GetOtherFaceElevation( nSurfId, nOtherSurfId, nOtherFac, nPartId) + -- centro e normale della faccia + local ptC, vtN = EgtSurfTmFacetCenter( nOtherSurfId, nOtherFac, GDB_ID.ROOT) + if not ptC or not vtN then return 0 end + -- riferimento OCS della faccia per ricavare elevazione rispetto alla faccia della superficie + local frOCS = Frame3d( ptC, vtN) ; + local b3Box = EgtGetBBoxRef( nSurfId, GDB_BB.STANDARD, frOCS) + local dElev = b3Box:getMax():getZ() + -- se definito identificativo di pezzo + if nPartId then + -- determino elevazione del centro faccia rispetto al box del pezzo + local _, dCenElev = BeamLib.GetPointDirDepth( nPartId, ptC, vtN) + if dCenElev and dCenElev > dElev then + dElev = dCenElev + end + end + return dElev +end + --------------------------------------------------------------------- function BeamLib.GetFaceWithMostAdj( nSurfId, nPartId, bCompare3Fc, dCosSideAng) -- recupero il numero di facce diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 8088050..555e477 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -1,4 +1,4 @@ --- ProcessLapJoint.lua by Egaltech s.r.l. 2021/06/11 +-- ProcessLapJoint.lua by Egaltech s.r.l. 2021/06/21 -- Gestione calcolo mezzo-legno per Travi -- 2019/10/08 Agg. gestione OpenPocket. -- 2021/01/24 Con sega a catena ora sempre impostato asse A. @@ -15,7 +15,9 @@ -- 2021/04/27 Antischeggia solo se feature trasversali. -- 2021/05/12 Semplificata gestione diametro minimo utensile per svuotatura. -- 2021/06/04 Su U passante con faccia perpendicolare aggiunta si forza Pocket. --- 2021/06/11 Su U passante e profona se non bastano due svuotature su faccia ortogonale si fa anche la faccia di fondo per qaunto possibile. +-- 2021/06/11 Su U passante e profonda se non bastano due svuotature su faccia ortogonale si fa anche la faccia di fondo per quanto possibile. +-- 2021/06/21 Nel caso precedente si fa la terza svuotatura anche se è possibile fare una sola delle prime due (altra da sotto). +-- 2021/06/21 Gestione ripresa spigoli o contorno con fresa più piccola ( diametro < 3/4 utensile svuotatura) attivata da parametro Q. -- Tabella per definizione modulo local ProcessLapJoint = {} @@ -112,6 +114,9 @@ local function AssignQIdent( Proc) Q_DEPTH_CHAMFER = 'Q07' -- d elseif ( Proc.Grp == 3 or Proc.Grp == 4) and Proc.Prc == 32 then Q_SIDE_ROUGH_TOOL = 'Q01' -- i + Q_ANTISPLINT_TYPE = 'Q06' -- i + elseif ( Proc.Grp == 3 or Proc.Grp == 4) and Proc.Prc == 34 then + Q_ANTISPLINT_TYPE = 'Q06' -- i end -- le altre features gestite non hanno parametri Q end @@ -255,25 +260,32 @@ local function VerifyChainSaw( Proc, dMinDim, dMaxDim, vtOrtho) end --------------------------------------------------------------------- -local function VerifyIfPocket( Proc, dDiam, vtOrtho, sMchFindMaster) +local function VerifyIfPocket( Proc, dDiam, vtOrtho, dDepth, sMchFindMaster) -- tipo di svuotatura local sMchFind = EgtIf( sMchFindMaster and #sMchFindMaster > 0, sMchFindMaster, 'Pocket') -- ricerca della svuotatura - local sPocketing = ML.FindPocketing( sMchFind, dDiam) + local sPocketing + if dDepth then + sPocketing = ML.FindPocketing( sMchFind, dDiam, dDepth) or ML.FindPocketing( sMchFind, dDiam, 2/3 * dDepth) or ML.FindPocketing( sMchFind, dDiam) + else + sPocketing = ML.FindPocketing( sMchFind, dDiam) + end if not sPocketing then return false end -- recupero i dati dell'utensile local bUsePocketing = false local dMaxDepth = 0 + local dToolDiam = 0 if EgtMdbSetCurrMachining( sPocketing) then local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then + dToolDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dToolDiam dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth end bUsePocketing = true end - return bUsePocketing, sPocketing, dMaxDepth + return bUsePocketing, sPocketing, dMaxDepth, dToolDiam end --------------------------------------------------------------------- @@ -403,7 +415,7 @@ local function GetTunnelDimension( Proc, nPartId) end --------------------------------------------------------------------- -local function GetFaceAdj( Proc, nFacInd, dH, dV, bOutLog) +local function GetFaceAdj( Proc, nFacInd, dH, dV) -- Recupero le facce adiacenti alla principale local vAdj = EgtSurfTmFacetAdjacencies( Proc.Id, nFacInd)[1] @@ -411,9 +423,7 @@ local function GetFaceAdj( Proc, nFacInd, dH, dV, bOutLog) local sErr = 'Error : main face without adjacencies' return -1, sErr end - if bOutLog then - EgtOutLog( 'Adjac=' .. table.concat( vAdj, ','), 3) - end + EgtOutLog( 'Adjac=' .. table.concat( vAdj, ','), 4) -- Riordino le dimensioni per avere dH > dV if dH < dV then dH, dV = dV, dH @@ -426,9 +436,7 @@ local function GetFaceAdj( Proc, nFacInd, dH, dV, bOutLog) local dLen = dist( ptP1, ptP2) if dLen > 0.5 * dH then nFacAdj = vAdj[i] - if bOutLog then - EgtOutLog( string.format( 'Adjac=%d Len=%.3f H=%.3f V=%.3f', vAdj[i], dLen, dH, dV), 3) - end + EgtOutLog( string.format( 'Adjac=%d Len=%.3f H=%.3f V=%.3f', vAdj[i], dLen, dH, dV), 4) break end end @@ -974,7 +982,7 @@ end --------------------------------------------------------------------- local function MakeByMill( Proc, nPhase, nRawId, nPartId, nFacInd, rfFac, dH, dV, dElev, dCollSic, bSpecialApp, sMillMaster, nFacInd2, dFacElev2) -- Cerco una faccia adiacente alla principale sul lato lungo - local nFacAdj, sErr = GetFaceAdj( Proc, nFacInd, dH, dV, true) + local nFacAdj, sErr = GetFaceAdj( Proc, nFacInd, dH, dV) if nFacAdj < 0 then EgtOutLog( sErr) return false, sErr @@ -1038,7 +1046,7 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, nFacInd, rfFac, dH, dV end -- Se massimo materiale utensile è molto inferiore dell'elevazione non faccio la lavorazione e do un warning if dMaxMat > 0 and dMaxMat + 15 < dElev + dCollSic then - sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' ,skipped milling; elevation bigger than max tool depth' + sWarn = 'Warning : skipped milling; elevation bigger than max tool depth' return true, sWarn, dMaxMat end -- Calcolo uso faccia @@ -1103,8 +1111,9 @@ end --------------------------------------------------------------------- local function ChooseCorner( Proc, nFacInd) - -- Recupero le facce adiacenti alla principale + -- Recupero le adiacenze della faccia principale local vAdj = EgtSurfTmFacetAdjacencies( Proc.Id, nFacInd)[1] + -- Cerco i corner tra le facce adiacenti alla principale local tFacAdj = {} for i = 1, #vAdj do if vAdj[i] >= 0 then @@ -1119,7 +1128,7 @@ local function ChooseCorner( Proc, nFacInd) end end end - -- tra le linee prendo quella più lunga + -- Tra le linee dei corner determino la più lunga local dMaxLen = 0 local nIdLine for i = 1, #tFacAdj do @@ -1128,192 +1137,692 @@ local function ChooseCorner( Proc, nFacInd) dMaxLen = tFacAdj[i][3] end end - + return dMaxLen, nIdLine, tFacAdj end --------------------------------------------------------------------- -local function MakeContourCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, nAddGrpId, dDiam) +local function ChooseBlindContour( Proc, nFacInd) + -- Recupero le adiacenze della faccia principale + local vAdj = EgtSurfTmFacetAdjacencies( Proc.Id, nFacInd)[1] + -- Cerco le facce adiacenti con angolo convesso + local tFacAdjMain = {} + for i = 1, #vAdj do + if vAdj[i] >= 0 then + local _, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, nFacInd, vAdj[i], GDB_ID.ROOT) + if ptP1 and ptP2 and dAng < 0 then + local dLen = dist( ptP1, ptP2) + table.insert( tFacAdjMain, { vAdj[i], dLen, ptP1, ptP2, dAng}) + end + end + end - local sMyWarn = '' - local pAuxId = {} - local nAuxId - local AuxId - local ptApPoint - local sMilling - local dTrimDist - local dCollSic = BD.COLL_SIC + return tFacAdjMain +end + +--------------------------------------------------------------------- +local function CheckToInvert( AuxId, bPositive) + + -- recupero versore estrusione + local vtExtr = EgtCurveExtrusion( AuxId, GDB_ID.ROOT) + -- faccio una copia del percorso + local sParnt = EgtGetParent( AuxId) + local nNewEntId = EgtCopyGlob( AuxId, sParnt) + -- chiudo il percorso + if EgtCloseCurveCompo( nNewEntId) then + local vtMPlane, dDist, dArea = EgtCurveArea( nNewEntId) + -- cancello percorso copia + EgtErase( nNewEntId) + if dArea and abs(dArea) > 1 then + local frEnt = EgtGetGlobFrame( AuxId) + if vtMPlane then + vtMPlane:toGlob(frEnt) + if dArea and dArea * ( vtMPlane * vtExtr) < 0 then + if bPositive then + return true + end + elseif dArea and dArea * ( vtMPlane * vtExtr) > 0 then + if not bPositive then + return true + end + end + end + end + else + -- cancello percorso copia + EgtErase(nNewEntId) + end + + return false +end + +--------------------------------------------------------------------- +local function SetOpenSide( nPathInt, vtOrtho, b3Solid, nAddGrpId, nStartPoint) + + -- 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 + -- se asse Z orizzontale verifico se si avvicina piú a Y + elseif abs(vtOrtho:getZ()) < 0.001 then + if abs(vtOrtho:getY()) > 0.75 then + -- se corrisponde a Z + if ( 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 + -- se asse Y a 0 (fresa ne davanti ne dietro) verifico se si avvicina piú a Z+ + elseif abs(vtOrtho:getY()) < 0.001 then + if abs(vtOrtho:getZ()) > 0.75 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 + end + end + end + end + -- se devo cambiare il punto di partenza + if nStartPoint then + if pLastPIni and pLastPEnd then + -- calcolo il punto medio con gli ultimi punti utilizzati + local ptPs = ( pLastPIni + pLastPEnd) / 2 + EgtChangeClosedCurveStartPoint( nPathInt, ptPs, GDB_RT.GLOB) + -- se devo eliminare la parte open + if nStartPoint == 2 then + EgtRemoveCurveCompoCurve( nPathInt, true) + EgtRemoveCurveCompoCurve( nPathInt, false) + end + end + end + end +end + +--------------------------------------------------------------------- +local function MakeRoundCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, + nFacInd, nAddGrpId, dDiam) + + -- recupero la lavorazione senza considerare l'elevazione + local sMilling = ML.FindMilling( 'LongSmallCut') + if not sMilling then + local sMyWarn = 'Warning : clean corner milling/tool not found in library' + EgtOutLog( sMyWarn) + return true, sMyWarn + end + + -- recupero i dati dell'utensile + local dTDiam = 50 + local dTMaxDepth = 0 + if EgtMdbSetCurrMachining( sMilling) then + local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) + dTDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dTDiam + dTMaxDepth = EgtTdbGetCurrToolMaxDepth() or dTMaxDepth + end + + -- se il diametro trovato non è minore dei 3/4 del diametro utilizzato in precedenza, esco + if dTDiam > ( 0.75 * dDiam) then + local sMyWarn = 'Warning : tool diameter not enough small' + EgtOutLog( sMyWarn) + return true, sMyWarn + end -- ottengo gli angoli dove applicare il percorso con fresa più piccola local dMaxLen, nIdLine, tFacAdj = ChooseCorner( Proc, nFacInd) -- se non trovato nessun angolo interno valido esco if #tFacAdj == 0 then - return true, sMyWarn + return true end - -- prendo il primo versore - local _, vtN1 = EgtSurfTmFacetCenter( Proc.Id, nFacInd, GDB_ID.ROOT) - -- se direzione tende verso una delle alle 3 direzioni azzero l'altezza extra - if abs( vtN1:getX()) > 0.7 or abs( vtN1:getY()) > 0.7 or abs( vtN1:getZ()) > 0.7 then dCollSic = 0 end + -- recupero la normale della faccia di fondo + local vtN1 = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT) -- se fresatura da sotto salto la lavorazione - if vtN1:getZ() < BD.DRILL_VZ_MIN then + if vtN1:getZ() < BD.DRILL_VZ_MIN then local sErr = 'Error : milling from bottom ' EgtOutLog( sErr) return false, sErr end -- ciclo su tutti gli angoli trovati + local sMyWarn = '' for i = 1, #tFacAdj do - sMyWarn = '' - -- le 2 facce di contatto devono essere perpendicolari o non sottossquadra rispetto alla faccia di fondo + local pAuxId = {} + -- le 2 facce di contatto devono essere perpendicolari e non sottosquadra rispetto alla faccia di fondo local _, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, nFacInd, tFacAdj[i][1], GDB_ID.ROOT) local _, ptP1x, ptP2x, dAngx = EgtSurfTmFacetsContact( Proc.Id, nFacInd, tFacAdj[i][2], GDB_ID.ROOT) - if ( dAng < 0 and 180 + dAng >= 90 - 10 * GEO.EPS_SMALL) and ( dAngx < 0 and 180 + dAngx >= 90 - 10 * GEO.EPS_SMALL) then - -- prendo la lunghezza di adiacenza delle due linee - local dLen1 = dist( ptP1, ptP2) - local dLen2 = dist( ptP1x, ptP2x) - -- cerco il punto tra le 3 facce: nIdEndPoint - local nIdIniPoint - local nIdEndPoint - if ptP1 and ptP2 then - if ( dist( ptP1, tFacAdj[i][4]) < GEO.EPS_SMALL) or ( dist( ptP2, tFacAdj[i][4]) < GEO.EPS_SMALL) then - nIdEndPoint = 4 - nIdIniPoint = 5 - elseif ( dist( ptP1, tFacAdj[i][5]) < GEO.EPS_SMALL) or ( dist( ptP2, tFacAdj[i][5]) < GEO.EPS_SMALL) then - nIdEndPoint = 5 - nIdIniPoint = 4 - end - end - -- se ho il punto comune - if nIdEndPoint then - -- recupero la lavorazione con elevazione pari all'altezza trovata - sMilling = ML.FindMilling( 'LongSmallCut', tFacAdj[i][3] + dCollSic) - if sMilling then - -- recupero i dati dell'utensile - local dTDiam = 50 - local dMaxMat = 0 - if EgtMdbSetCurrMachining( sMilling) then - local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) - dTDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dTDiam - dMaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) or dMaxMat - end - -- se il diametro trovato è minore della metà del diametro utilizzato in precendenza - if dTDiam < ( dDiam / 2) then - -- calcolo lunghezza minima in base all'angolo tra le due pareti - local dMinDist = (( dDiam / 2) / tan( ( 180 + tFacAdj[i][6]) / 2)) + 2 - -- se entrambe le linee sono maggiori delle lunghezza minima proseguo - if dLen1 >= dMinDist and dLen2 >= dMinDist then - -- se il punto finale corrisponde con il punto utilizzato in precedenza, uso l'altro - if dist( tFacAdj[i][nIdEndPoint], ptP1) < 10 * GEO.EPS_SMALL then - ptApPoint = ptP2 - else - ptApPoint = ptP1 - end - -- prima linea - nAuxId = EgtLine( nAddGrpId, ptApPoint, tFacAdj[i][nIdEndPoint], GDB_RT.GLOB) - -- calcolo arretramento - dTrimDist = dLen1 - dMinDist - -- se arretramento valido - if dTrimDist > 100 * GEO.EPS_SMALL then - EgtTrimExtendCurveByLen( nAuxId , - dTrimDist, ptApPoint , GDB_RT.GLOB) - end - table.insert( pAuxId, nAuxId) - -- se il punto finale corrisponde con il punto comune, uso l'altro - if dist( tFacAdj[i][nIdEndPoint], ptP1x) < 10 * GEO.EPS_SMALL then - ptApPoint = ptP2x - else - ptApPoint = ptP1x - end - -- seconda linea - nAuxId = EgtLine( nAddGrpId, tFacAdj[i][nIdEndPoint], ptApPoint, GDB_RT.GLOB) - -- calcolo arretramento - dTrimDist = dLen2 - dMinDist - -- se arretramento valido - if dTrimDist > 100 * GEO.EPS_SMALL then - EgtTrimExtendCurveByLen( nAuxId , - dTrimDist, ptApPoint , GDB_RT.GLOB) - end - table.insert( pAuxId, nAuxId) - -- trasformo in percorso - if #pAuxId > 0 then - AuxId = EgtCurveCompo( nAddGrpId, pAuxId, true) - end - -- se c'è il percorso - if AuxId then - -- modifico versore direzione - EgtModifyCurveExtrusion( AuxId, vtN1, GDB_RT.GLOB) - -- inserisco la lavorazione - local sName = 'Clean_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) - local nMchId = EgtAddMachining( sName, sMilling) - if nMchId then - -- aggiungo geometria - EgtSetMachiningGeometry( {{ AuxId, -1}}) - -- imposto posizione braccio porta testa - local nSCC = MCH_SCC.ADIR_YM - if vtN1:getY() > 100 * GEO.EPS_ZERO then - 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 0mm - EgtSetMachiningParam( MCH_MP.STARTADDLEN, 0) - EgtSetMachiningParam( MCH_MP.ENDADDLEN, 0) - -- setto affondamento 0 - EgtSetMachiningParam( MCH_MP.DEPTH, 0) - -- setto non inversione del percorso - EgtSetMachiningParam( MCH_MP.INVERT, false) - -- Note utente con dichiarazione nessuna generazione sfridi per Vmill - local sUserNotes = 'VMRS=0;' - -- aggiungo alle note massima elevazione - sUserNotes = sUserNotes .. 'MaxElev=' .. EgtNumToString( tFacAdj[i][3], 1) .. ';' - EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes) - if EgtApplyMachining( true, false) then - _, sMyWarn = EgtGetMachMgrWarning( 0) - if EgtIsMachiningEmpty() then - EgtSetOperationMode( nMchId, false) - end - -- altrimenti lavorazione non applicata - else - _, sMyWarn = EgtGetLastMachMgrError() - EgtSetOperationMode( nMchId, false) - end - -- altrimenti non è ctata inserita lavorazione - else - sMyWarn = 'warning adding machining ' .. sName .. '-' .. sMilling - end - -- altrimenti non c'è il percorso - else - sMyWarn = 'warning in process ' .. tostring( Proc.Id) .. ' impossible make clean corner path' - end - -- altrimenti - else - sMyWarn = 'warning in process ' .. tostring( Proc.Id) .. ' impossible make clean corner path' - end - -- altrimenti diametro trovato è simile a quello già utilizzato --- else --- sMyWarn = 'warning in process ' .. tostring( Proc.Id) .. ' smaller tool not found' - end - -- altrimenti non è stata trovata lavorazione - else - sMyWarn = 'warning in process ' .. tostring( Proc.Id) .. ' clean corner milling/tool not found in library' - end - -- altrimenti non è stato trovato il punto comune --- else --- sMyWarn = 'warning in process ' .. tostring( Proc.Id) .. ' impossible make clean corner path' - end - -- altrimenti pareti sottosquadra o angolo aperto --- else --- sMyWarn = 'warning in process ' .. tostring( Proc.Id) .. ' impossible make clean corner path' + if dAng >= 0 or dAng < -90 - 10 * GEO.EPS_SMALL or dAngx >= 0 or dAngx < -90 - 10 * GEO.EPS_SMALL then + goto continue end - if #sMyWarn > 0 then - EgtOutLog( sMyWarn) + -- prendo la lunghezza di adiacenza delle due linee + local dLen1 = dist( ptP1, ptP2) + local dLen2 = dist( ptP1x, ptP2x) + -- cerco il punto tra le 3 facce: nIdEndPoint + local nIdIniPoint + local nIdEndPoint + if ptP1 and ptP2 then + if dist( ptP1, tFacAdj[i][4]) < GEO.EPS_SMALL or dist( ptP2, tFacAdj[i][4]) < GEO.EPS_SMALL then + nIdEndPoint = 4 + nIdIniPoint = 5 + elseif dist( ptP1, tFacAdj[i][5]) < GEO.EPS_SMALL or dist( ptP2, tFacAdj[i][5]) < GEO.EPS_SMALL then + nIdEndPoint = 5 + nIdIniPoint = 4 + end end + -- devo avere un punto comune + if not nIdEndPoint then + goto continue + end + -- calcolo lunghezza minima in base all'angolo tra le due pareti + local dMinDist = (( dDiam / 2) / tan( ( 180 + tFacAdj[i][6]) / 2)) + 2 + -- verifico che entrambe le linee siano maggiori delle lunghezza minima + if dLen1 <= dMinDist or dLen2 <= dMinDist then + sMyWarn = 'Warning : impossible make clean corner path' + goto continue + end + -- se il punto finale corrisponde con il punto utilizzato in precedenza, uso l'altro + local ptApPoint = EgtIf( dist( tFacAdj[i][nIdEndPoint], ptP1) < 10 * GEO.EPS_SMALL, ptP2, ptP1) + -- prima linea + local nAuxId = EgtLine( nAddGrpId, ptApPoint, tFacAdj[i][nIdEndPoint], GDB_RT.GLOB) + -- calcolo arretramento + local dTrimDist = dLen1 - dMinDist + -- se arretramento valido + if dTrimDist > 100 * GEO.EPS_SMALL then + EgtTrimExtendCurveByLen( nAuxId , -dTrimDist, ptApPoint , GDB_RT.GLOB) + end + table.insert( pAuxId, nAuxId) + -- se il punto finale corrisponde con il punto comune, uso l'altro + ptApPoint = EgtIf( dist( tFacAdj[i][nIdEndPoint], ptP1x) < 10 * GEO.EPS_SMALL, ptP2x, ptP1x) + -- seconda linea + nAuxId = EgtLine( nAddGrpId, tFacAdj[i][nIdEndPoint], ptApPoint, GDB_RT.GLOB) + -- calcolo arretramento + dTrimDist = dLen2 - dMinDist + -- se arretramento valido + if dTrimDist > 100 * GEO.EPS_SMALL then + EgtTrimExtendCurveByLen( nAuxId , -dTrimDist, ptApPoint , GDB_RT.GLOB) + end + table.insert( pAuxId, nAuxId) + -- trasformo in percorso + local AuxId + if #pAuxId > 0 then + AuxId = EgtCurveCompo( nAddGrpId, pAuxId, true) + end + -- deve esserci il percorso + if not AuxId then + sMyWarn = 'Warning : impossible make clean corner path' + goto continue + end + -- modifico versore direzione + EgtModifyCurveExtrusion( AuxId, vtN1, GDB_RT.GLOB) + -- inserisco la lavorazione + local sName = 'Clean_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) + local nMchId = EgtAddMachining( sName, sMilling) + if not nMchId then + sMyWarn = 'Warning : impossible add machining ' .. sName .. '-' .. sMilling + goto continue + end + -- aggiungo geometria + EgtSetMachiningGeometry( {{ AuxId, -1}}) + -- imposto posizione braccio porta testa + local nSCC = MCH_SCC.NONE + if not BD.C_SIMM then + if AreSameOrOppositeVectorApprox( vtN1, Z_AX()) then + nSCC = MCH_SCC.ADIR_YM + elseif abs( vtN1:getX()) < 0.1 then + nSCC = EgtIf( BL.IsPartFinalPhase( nPhase), MCH_SCC.ADIR_XM, MCH_SCC.ADIR_XP) + elseif vtN1:getY() < GEO.EPS_SMALL then + nSCC = EgtIf( bInvertMach, MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM) + else + nSCC = EgtIf( bInvertMach, MCH_SCC.ADIR_YM, MCH_SCC.ADIR_YP) + end + end + EgtSetMachiningParam( MCH_MP.SCC, nSCC) + -- tipo attacco e uscita + EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.NONE) + EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LO.AS_LI) + -- annullo allungamenti iniziale e finale + EgtSetMachiningParam( MCH_MP.STARTADDLEN, 0) + EgtSetMachiningParam( MCH_MP.ENDADDLEN, 0) + -- setto massimo affondamento possibile + local dDepth = 0 + if tFacAdj[i][3] > dTMaxDepth then + dDepth = dTMaxDepth - tFacAdj[i][3] + end + EgtSetMachiningParam( MCH_MP.DEPTH, dDepth) + -- setto se devo invertire il percorso + local bInvert = CheckToInvert( AuxId, true) + EgtSetMachiningParam( MCH_MP.INVERT, bInvert) + -- Note utente con dichiarazione nessuna generazione sfridi per Vmill e massima elevazione + local sUserNotes = 'VMRS=0;' + sUserNotes = sUserNotes .. 'MaxElev=' .. EgtNumToString( ( tFacAdj[i][3] + dDepth), 1) .. ';' + EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes) + -- eseguo + if EgtApplyMachining( true, false) then + _, sMyWarn = EgtGetMachMgrWarning( 0) + if EgtIsMachiningEmpty() then + EgtSetOperationMode( nMchId, false) + end + -- altrimenti lavorazione non applicata + else + _, sMyWarn = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchId, false) + end + ::continue:: end + if #sMyWarn > 0 then + EgtOutLog( sMyWarn) + end + return true, sMyWarn end --------------------------------------------------------------------- -local function MakeCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, nAddGrpId, dDiam) +local function MakeRoundCleanContour( Proc, nPhase, nRawId, nPartId, b3Raw, + nFacInd, nAddGrpId, dDiam, nFunction, bDoubleSide, + vtOrtho, nPathInt, nSurfInt, b3Solid, dDepth, + bOneShot) + + -- recupero la lavorazione senza considerare l'elevazione perché viene calcolata l'elevazione utile + local sMilling = ML.FindMilling( 'LongSmallCut') + if not sMilling then + local sMyWarn = 'Warning : clean corner milling/tool not found in library' + EgtOutLog( sMyWarn) + return true, sMyWarn + end + + -- recupero i dati dell'utensile + local dTDiam = 50 + local dTMaxDepth = 0 + if EgtMdbSetCurrMachining( sMilling) then + local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) + dTDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dTDiam + dTMaxDepth = EgtTdbGetCurrToolMaxDepth() or dTMaxDepth + end + + -- se il diametro trovato non è minore dei 3/4 del diametro utilizzato in precedenza, esco + if dTDiam > ( 0.75 * dDiam) then + local sMyWarn = 'Warning : tool diameter not enough small' + EgtOutLog( sMyWarn) + return true, sMyWarn + end + + local vtN1 + local nFirstId, nNumId + local dMaxElev + local dExtraDepth = 0 + local dCollSic = 0 + + -- se non ho la faccia aggiunta + if not nPathInt then + -- cerco gli angoli dove applicare il percorso con fresa piú piccola e i lati in comune + local tFacAdjMain = ChooseBlindContour( Proc, nFacInd) + -- se non trovato nessun angolo interno da pulire esco + if #tFacAdjMain == 0 then + return true + end + -- normale alla faccia di fondo + vtN1 = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT) + -- se fresatura da sotto salto la lavorazione + if vtN1:getZ() < BD.DRILL_VZ_MIN then + local sErr = 'Error : milling from bottom' + EgtOutLog( sErr) + return false, sErr + end + -- distanza di sicurezza per evitare collisioni + dCollSic = CalcCollisionSafety( vtN1) + -- elevazione massima della faccia + dMaxElev = BL.GetFaceElevation( Proc.Id, nFacInd, nPartId) + -- ciclo tutta la tabella + local tPaths = {} + local ptIniPath + local ptMidDist + local dMaxLen = 0 + for i = 1, #tFacAdjMain do + -- le 2 facce di contatto devono essere perpendicolari o non sottosquadra rispetto alla faccia di fondo + local ptP1, ptP2, dAng + ptP1 = tFacAdjMain[i][3] + ptP2 = tFacAdjMain[i][4] + dAng = tFacAdjMain[i][5] + if ( dAng < 0 and dAng >= -90 - 10 * GEO.EPS_SMALL) then + -- creo la linea da P1 a P2 + local nAuxId = EgtLine( nAddGrpId, ptP1, ptP2, GDB_RT.GLOB) + table.insert( tPaths, nAuxId) + -- prendo la lunghezza massima e il punto medio + if tFacAdjMain[i][2] > dMaxLen then + ptIniPath = ptP1 + dMaxLen = tFacAdjMain[i][2] + ptMidDist = ( ptP1 + ptP2) / 2 + end + end + end + -- costruisco il/i percorso/i + nFirstId, nNumId = EgtCurveCompoByReorder( nAddGrpId, tPaths, ptIniPath, true, GDB_RT.GLOB) + if nFirstId then + -- se un solo percorso e chiuso cambio il punto di inizio nell'entitá piú lunga + if nNumId == 1 and EgtCurveIsClosed( nFirstId) then + EgtChangeClosedCurveStartPoint( nFirstId, ptMidDist, GDB_RT.GLOB) + end + -- modifico versore direzione + for i = 1, nNumId do + EgtModifyCurveExtrusion( nFirstId + i - 1, vtN1, GDB_RT.GLOB) + end + end + + -- alrimenti ho la faccia aggiunta + else + -- assegno il percorso + nFirstId = EgtCopyGlob( nPathInt, nAddGrpId) + nNumId = 1 + -- distanza di sicurezza per evitare collisioni + dCollSic = CalcCollisionSafety( vtOrtho) + -- calcolo elevazione dalla faccia trasversale aggiunta + local dSurfIntElev = BL.GetOtherFaceElevation( Proc.Id, nSurfInt, 0) + if bDoubleSide then + dMaxElev = dSurfIntElev + else + dMaxElev = dDepth + -- se la precedente svuotatura è stata fatta completamente in una sola volta + if bOneShot then + -- se non è possibile contornare completamente da una sola parte + if dTMaxDepth <= ( dMaxElev + BD.CUT_EXTRA + dCollSic) then + bDoubleSide = true + dMaxElev = dSurfIntElev + else + dExtraDepth = dMaxElev - dSurfIntElev + end + -- altrimenti non è stata fatta completamente calcolo la distanza tra faccia aggiunta e profondità superficie + else + dExtraDepth = dMaxElev - dSurfIntElev + end + end + -- normale alla faccia aggiunta + vtN1 = Vector3d( vtOrtho) + -- imposto i lati aperti + SetOpenSide( nFirstId, vtOrtho, b3Solid, nAddGrpId, 2) + end + + -- se non trovato il percorso, esco + if not nFirstId then + local sMyWarn = 'Warning : impossible make clean corner path' + EgtOutLog( sMyWarn) + return true, sMyWarn + end + + -- assegno lavorazioni ad ogni percorso + local sMyWarn = '' + for i = 1, nNumId do + local nIdPath = nFirstId + i - 1 + local sName = 'Clean_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) + local nMchId = EgtAddMachining( sName, sMilling) + if not nMchId then + sMyWarn = 'Warning : impossible add machining ' .. sName .. '-' .. sMilling + goto continue + end + -- aggiungo geometria + EgtSetMachiningGeometry( {{ nIdPath, -1}}) + -- inversione direzione utensile + local bInvertMach = false + if nPathInt then + -- verifico se devo invertire direzione utensile (in caso di direzione verso la verticale) + if vtN1:getZ() < BD.NZ_MINA and abs(vtN1: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 vtN1:getY() > GEO.EPS_SMALL then + EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) + bInvertMach = true + end + end + -- imposto posizione braccio porta testa + local nSCC = MCH_SCC.NONE + if not BD.C_SIMM then + if AreSameOrOppositeVectorApprox( vtN1, Z_AX()) then + nSCC = MCH_SCC.ADIR_YM + elseif abs( vtN1:getX()) < 0.1 then + nSCC = EgtIf( BL.IsPartFinalPhase( nPhase), MCH_SCC.ADIR_XM, MCH_SCC.ADIR_XP) + elseif vtN1:getY() < GEO.EPS_SMALL then + nSCC = EgtIf( bInvertMach, MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM) + else + nSCC = EgtIf( bInvertMach, MCH_SCC.ADIR_YM, MCH_SCC.ADIR_YP) + end + end + EgtSetMachiningParam( MCH_MP.SCC, nSCC) + -- tipo attacco e uscita + EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.NONE) + EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LO.AS_LI) + -- allungo inizio e fine di 3/4 del diametro utensile + EgtSetMachiningParam( MCH_MP.STARTADDLEN, dTDiam * 0.75) + EgtSetMachiningParam( MCH_MP.ENDADDLEN, dTDiam * 0.75) + -- setto massimo affondamento possibile + local dMachDepth = 0 + if ( dMaxElev + BD.CUT_EXTRA + dCollSic) > dTMaxDepth then + dMachDepth = dTMaxDepth - ( dMaxElev + BD.CUT_EXTRA) + end + EgtSetMachiningParam( MCH_MP.DEPTH, (dMachDepth+dExtraDepth)) + -- setto se devo invertire il percorso + local bInvert = CheckToInvert( nIdPath, true) + EgtSetMachiningParam( MCH_MP.INVERT, EgtIf( bInvertMach, not bInvert, bInvert)) + -- Note utente con dichiarazione nessuna generazione sfridi per Vmill e massima elevazione + local sUserNotes = 'VMRS=0;' + sUserNotes = sUserNotes .. 'MaxElev=' .. EgtNumToString( ( dMaxElev + dMachDepth), 1) .. ';' + EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes) + -- eseguo + if EgtApplyMachining( true, false) then + _, sMyWarn = EgtGetMachMgrWarning( 0) + if EgtIsMachiningEmpty() then + EgtSetOperationMode( nMchId, false) + end + -- altrimenti lavorazione non applicata + else + _, sMyWarn = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchId, false) + end + -- se devo applicare la contornatura anche sul lato opposto + if bDoubleSide then + sName = 'CleanOppo_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) + nMchId = EgtAddMachining( sName, sMilling) + if not nMchId then + sMyWarn = 'Warning : impossible add machining ' .. sName .. '-' .. sMilling + goto continue + end + -- aggiungo geometria + EgtSetMachiningGeometry( {{ nIdPath, -1}}) + -- imposto direzione utensile opposta + EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) + -- imposto posizione braccio porta testa + local nSCC = MCH_SCC.NONE + if not BD.C_SIMM then + if AreSameVectorApprox( vtN1, Z_AX()) then + nSCC = MCH_SCC.ADIR_YM + elseif abs( vtN1:getX()) < 0.1 then + nSCC = EgtIf( BL.IsPartFinalPhase( nPhase), MCH_SCC.ADIR_XM, MCH_SCC.ADIR_XP) + elseif vtN1:getY() < GEO.EPS_SMALL then + nSCC = MCH_SCC.ADIR_YP + else + nSCC = MCH_SCC.ADIR_YM + end + end + EgtSetMachiningParam( MCH_MP.SCC, nSCC) + -- tipo attacco e uscita + EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.NONE) + EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LO.AS_LI) + -- allungo inizio e fine di 3/4 del diametro utensile + EgtSetMachiningParam( MCH_MP.STARTADDLEN, dTDiam * 0.75) + EgtSetMachiningParam( MCH_MP.ENDADDLEN, dTDiam * 0.75) + -- setto massimo affondamento possibile + local dMachDepth = 0 + if ( dMaxElev + BD.CUT_EXTRA + dCollSic) > dTMaxDepth then + dMachDepth = dTMaxDepth - ( dMaxElev + BD.CUT_EXTRA) + end + EgtSetMachiningParam( MCH_MP.DEPTH, dMachDepth) + -- setto se devo invertire il percorso + local bInvert = CheckToInvert( nIdPath, true) + EgtSetMachiningParam( MCH_MP.INVERT, not bInvert) + -- Note utente con dichiarazione nessuna generazione sfridi per Vmill e massima elevazione + local sUserNotes = 'VMRS=0;' + sUserNotes = sUserNotes .. 'MaxElev=' .. EgtNumToString( ( dMaxElev + dMachDepth), 1) .. ';' + EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes) + -- eseguo + if EgtApplyMachining( true, false) then + _, sMyWarn = EgtGetMachMgrWarning( 0) + if EgtIsMachiningEmpty() then + EgtSetOperationMode( nMchId, false) + end + -- altrimenti lavorazione non applicata + else + _, sMyWarn = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchId, false) + end + end + ::continue:: + end + if #sMyWarn > 0 then + EgtOutLog( sMyWarn) + end + + return true, sMyWarn +end + +--------------------------------------------------------------------- +local function MakeRoundCleanCornerOrContour( Proc, nPhase, nRawId, nPartId, b3Raw, + nFacInd, nAddGrpId, dDiam, nFunction, bDoubleSide, + vtOrtho, nPathInt, nSurfInt, b3Solid, dDepth, + bOneShot) + + -- se modalitá pulitura spigoli e lavorazione di lato forzo a fare il contorno + if nFunction == 2 and nPathInt then + nFunction = 1 + end + -- se richiesta pulitura del contorno + if nFunction == 1 then + return MakeRoundCleanContour( Proc, nPhase, nRawId, nPartId, b3Raw, + nFacInd, nAddGrpId, dDiam, nFunction, bDoubleSide, + vtOrtho, nPathInt, nSurfInt, b3Solid, dDepth, + bOneShot) + -- se richiesta pulitura dei soli corner + elseif nFunction == 2 then + return MakeRoundCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, + nFacInd, nAddGrpId, dDiam) + -- altri casi non previsti + else + return true + end +end + +--------------------------------------------------------------------- +local function MakeSharpCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, nAddGrpId, dDiam) local sMyWarn = '' local pAuxId = {} @@ -1324,25 +1833,24 @@ local function MakeCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, n local sMilling local dMaxDepth = 0 - -- ottengo l'angolo di riferimento dove applicare il percorso di pulitura + -- cerco l'angolo di riferimento dove applicare il percorso di pulitura, altrimenti esco local dMaxLen, nIdLine, tFacAdj = ChooseCorner( Proc, nFacInd) - -- se non trovato nessun angolo valido esco if #tFacAdj == 0 then - return true, sMyWarn + return true end -- prendo il primo versore - local _, vtN1 = EgtSurfTmFacetCenter( Proc.Id, nFacInd, GDB_ID.ROOT) - local _, vtN2 = EgtSurfTmFacetCenter( Proc.Id, tFacAdj[nIdLine][1], GDB_ID.ROOT) - local _, vtN3 = EgtSurfTmFacetCenter( Proc.Id, tFacAdj[nIdLine][2], GDB_ID.ROOT) + local vtN1 = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT) + local vtN2 = EgtSurfTmFacetNormVersor( Proc.Id, tFacAdj[nIdLine][1], GDB_ID.ROOT) + local vtN3 = EgtSurfTmFacetNormVersor( Proc.Id, tFacAdj[nIdLine][2], GDB_ID.ROOT) -- trovo il punto sulla superfice di riferimento - local _, ptLocP1, ptLocP2, _ = EgtSurfTmFacetsContact( Proc.Id, nFacInd, tFacAdj[nIdLine][1], GDB_ID.ROOT) + local _, ptLocP1, ptLocP2 = EgtSurfTmFacetsContact( Proc.Id, nFacInd, tFacAdj[nIdLine][1], GDB_ID.ROOT) local nIdIniPoint local nIdEndPoint if ptLocP1 and ptLocP2 then - if ( dist( ptLocP1, tFacAdj[nIdLine][4]) < GEO.EPS_SMALL) or ( dist( ptLocP2, tFacAdj[nIdLine][4]) < GEO.EPS_SMALL) then + if dist( ptLocP1, tFacAdj[nIdLine][4]) < GEO.EPS_SMALL or dist( ptLocP2, tFacAdj[nIdLine][4]) < GEO.EPS_SMALL then nIdEndPoint = 4 nIdIniPoint = 5 - elseif ( dist( ptLocP1, tFacAdj[nIdLine][5]) < GEO.EPS_SMALL) or ( dist( ptLocP2, tFacAdj[nIdLine][5]) < GEO.EPS_SMALL) then + elseif dist( ptLocP1, tFacAdj[nIdLine][5]) < GEO.EPS_SMALL or dist( ptLocP2, tFacAdj[nIdLine][5]) < GEO.EPS_SMALL then nIdEndPoint = 5 nIdIniPoint = 4 end @@ -1362,7 +1870,7 @@ local function MakeCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, n vtExtr = vtN1 + vtN2 + vtN3 vtExtr:normalize() -- recupero la lavorazione non calcolando l'elevazione - sMilling = ML.FindMilling( 'CleanCorner', (dDiam*0.5)) + sMilling = ML.FindMilling( 'CleanCorner', ( 0.5 * dDiam)) if not sMilling then local sErr = 'Error : CleanCorner not found in library' EgtOutLog( sErr) @@ -1375,7 +1883,7 @@ local function MakeCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, n end -- l'altezza di taglio del tagliente corrisponde al raggio del raccordo che si riesce a coprire -- quindi confronto l'elevazione con il raggio utensile utilizzato per la svuotatura - if dMaxDepth < (dDiam * 0.5) - 100 * GEO.EPS_SMALL then + if dMaxDepth < ( dDiam * 0.5) - 100 * GEO.EPS_SMALL then sMyWarn = 'Warning : skip clean corner (the cut heigth is smaller to machine the corner radius)' EgtOutLog( sMyWarn) return false, sMyWarn @@ -1403,7 +1911,7 @@ local function MakeCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, n end -- inserisco le ultime tre linee + uscita discostata rispetto all'ingresso -- trovo il secondo punto sulla superfice di riferimento - _, ptLocP1, ptLocP2, _ = EgtSurfTmFacetsContact( Proc.Id, nFacInd, tFacAdj[nIdLine][2], GDB_ID.ROOT) + _, ptLocP1, ptLocP2 = EgtSurfTmFacetsContact( Proc.Id, nFacInd, tFacAdj[nIdLine][2], GDB_ID.ROOT) if ptLocP1 and ptLocP2 then -- se il punto finale corrisponde con il punto utilizzato in precedenza, uso l'altro if dist( tFacAdj[nIdLine][nIdEndPoint], ptLocP1) < 10 * GEO.EPS_SMALL then @@ -1453,23 +1961,31 @@ local function MakeCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, n -- aggiungo geometria EgtSetMachiningGeometry( {{ AuxId, -1}}) -- imposto posizione braccio porta testa - local nSCC = MCH_SCC.ADIR_YM - if vtExtr:getY() > 100 * GEO.EPS_ZERO then - nSCC = MCH_SCC.ADIR_YP + local nSCC = MCH_SCC.NONE + if not BD.C_SIMM then + if AreSameVectorApprox( vtN1, Z_AX()) then + nSCC = MCH_SCC.ADIR_YM + elseif abs( vtN1:getX()) < 0.1 then + nSCC = EgtIf( BL.IsPartFinalPhase( nPhase), MCH_SCC.ADIR_XM, MCH_SCC.ADIR_XP) + elseif vtN1:getY() < GEO.EPS_SMALL then + nSCC = MCH_SCC.ADIR_YP + else + nSCC = MCH_SCC.ADIR_YM + end end EgtSetMachiningParam( MCH_MP.SCC, nSCC) - EgtSetMachiningParam( MCH_MP.LEADINTYPE, 0) - EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, 4) + -- tipo attacco e uscita + EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.NONE) + EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LO.AS_LI) -- 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;' - -- aggiungo alle note massima elevazione - sUserNotes = sUserNotes .. 'MaxElev=' .. EgtNumToString( dMaxDepth, 1) .. ';' + -- Note utente con dichiarazione nessuna generazione sfridi per Vmill e massima elevazione + local sUserNotes = 'VMRS=0;MaxElev=' .. EgtNumToString( dMaxDepth, 1) .. ';' EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes) + -- eseguo if not EgtApplyMachining( true, false) then local _, sErr = EgtGetLastMachMgrError() EgtSetOperationMode( nMchId, false) @@ -1866,7 +2382,7 @@ local function MakeChamfer( Proc, bIs3Faces, nAddGrpId, vtOrtho, b3Solid, nSurfI if bIs3Faces then -- nAuxId1, _ = EgtExtractSurfTmLoops( nSurfInt, nAddGrpId) -- EgtModifyCurveExtrusion( nAuxId1, vtOrtho, GDB_RT.GLOB) --- SetOpenSide( nAuxId1, vtOrtho, b3Solid, nAddGrpId, true) +-- SetOpenSide( nAuxId1, vtOrtho, b3Solid, nAddGrpId, 1) -- nNumIdAux = 2 -- estraggo i percorsi @@ -2329,7 +2845,7 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd, end --------------------------------------------------------------------- -local function MakeAntiSplintBySaw( Proc, nFacet, vtN, b3Raw) +local function MakeAntiSplintBySaw( Proc, nFacet, vtN, b3Raw, nFacInd, bReduceDepth) -- Recupero la lavorazione di lama local sCutting = ML.FindCutting( 'HeadSide') if not sCutting then @@ -2337,19 +2853,56 @@ local function MakeAntiSplintBySaw( Proc, nFacet, vtN, b3Raw) EgtOutLog( sErr) return false, sErr end + -- valuto l'angolo tra le due facce + local bAdj, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, nFacInd, nFacet, GDB_ID.ROOT) + local ptPm = (ptP1+ptP2)/2 + -- ottengo il boundingBox e prendo le dimensioni lungo la normale (Z locale) che rappresenta l'elevazione della faccia + -- laterale sul punto medio della linea in comune + local frFc = Frame3d( ptPm, vtN) ; + local bBoxLoc = EgtGetBBoxRef( Proc.Id, GDB_BB.STANDARD, frFc) + dDepth = bBoxLoc:getDimZ() or 0 -- recupero i dati dell'utensile local dSawDiam = 400 local dSawThick = 0 + local dMaxDepth = 0 if EgtMdbSetCurrMachining( sCutting) then local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then dSawDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam dSawThick = EgtTdbGetCurrToolParam( MCH_TP.THICK) or dSawThick + dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth + end + end + local dExtraOffs = 0 + -- se profondità superiore al massimo lama modifico elevazione + if dDepth > dMaxDepth then + dExtraOffs = dMaxDepth - dDepth + end + -- se devo ridurre l'affondamento + if bReduceDepth then + local dLimitDepth = 100 + -- se ho ridotto l'affondamento ne riduco ulteriormente l'affondamento (50mm) + if abs(dExtraOffs) > 0 then + if dMaxDepth > dLimitDepth then + dExtraOffs = dLimitDepth - dDepth + end + else + if dDepth > dLimitDepth then + dExtraOffs = dLimitDepth - dDepth + else + dExtraOffs = - (dDepth/2) + end end end -- eseguo il taglio - local bMadeASbyBld, sWarn, nIdMach = BL.MakeOneFaceBySaw( Proc.Id, nFacet, sCutting, dSawDiam, vtN, nil, -0.5, BD.CUT_SIC, 0, 0, 0, nil, b3Raw) - return bMadeASbyBld, sWarn, nIdMach, dSawThick + local bMadeASbyBld, sWarn, nIdMach = BL.MakeOneFaceBySaw( Proc.Id, nFacet, sCutting, dSawDiam, vtN, nil, ( -0.5 + dExtraOffs), BD.CUT_SIC, 0, 0, 0, nil, b3Raw) + if bMadeASbyBld then + sWarn = nil + if abs(dExtraOffs) > 0 then + sWarn = 'Warning : antisplint elevation is bigger than max tool depth' + end + end + return bMadeASbyBld, sWarn, nIdMach, dSawThick, dMaxDepth, bAdj, dAng, dExtraOffs end --------------------------------------------------------------------- @@ -2627,119 +3180,6 @@ local function MachineByMill( Proc, nPhase, nRawId, nPartId, b3Solid, tvtN, nBas 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 GetUShapeWidth( Proc, nFacInd) -- Recupero le facce adiacenti alla principale @@ -2799,6 +3239,7 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha if bOrthoFaces then -- ottengo le dimensioni del tunnel dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = GetTunnelDimension( Proc, nPartId) + local nPathInt -- se devo inserire il chamfer if nChamfer > 0 then local nOk, sErr = MakeChamfer( Proc, bIs3Faces, nAddGrpId, vtOrtho, b3Solid, nSurfInt, dDepthCham) @@ -2807,12 +3248,12 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha -- se smusso non è esclusivo if nChamfer < 2 then -- verifico se può essere fatto con svuotatura - local bMakePocket, sPocketing, dMaxDepth = VerifyIfPocket( Proc, dDimMin, vtOrtho, sMchFind) + local bMakePocket, sPocketing, dMaxDepth, dDiamTool = VerifyIfPocket( Proc, dDimMin, vtOrtho, dDepth / 2, 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) + 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 bIs3Faces then @@ -2822,12 +3263,15 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha local dMachDepth local dElev = 0 local bDoubleSide + local bOneShot + local bComplete = true -- imposto altezza aggiuntiva di elevazione local dCollSic = CalcCollisionSafety( vtOrtho) -- se possibile svuotare completamente da una sola parte if dMaxDepth > ( dDepth + BD.CUT_EXTRA + dCollSic) then dMachDepth = ( dDepth / 2) + BD.CUT_EXTRA dElev = dDepth + BD.CUT_EXTRA + bOneShot = true else -- se direzione verso la verticale setto max affondamento possibile ed -- emetto messaggio di warning perché non lavorabile interamente @@ -2836,6 +3280,7 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha dElev = dMaxDepth sWarn = 'Warning : elevation bigger than max tool depth' EgtOutLog( sWarn) + bComplete = false -- altrimenti setto il flag per fare la svuotatura da due parti else -- se l'altezza utensile riesce a lavorare completamente da due parti @@ -2925,7 +3370,6 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha if bDoubleSide then -- se anche lavorando dal lato opposto non riesco a svuotare completamente la fessura -- setto i parametri affondamento ed emetto warning - local bComplete = true if 2 * dMaxDepth < dDepth + 2 * BD.CUT_EXTRA + 2 * dCollSic then dMachDepth = dMaxDepth - (dDepth / 2) dElev = dMaxDepth @@ -2981,71 +3425,260 @@ local function MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCha return -1, sErr end end - -- se non completo e U, cerco di lavorare anche la faccia di fondo (con il massimo affondamento possibile) - if not bComplete and bIs3Faces then - -- recupero la faccia da lavorare - local nFacInd = BL.GetFaceWithMostAdj( Proc.Id, nPartId) - local vtN - local bPock3rd = false - if nFacInd then - vtN = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT) - bPock3rd = ( vtN and vtN:getZ() >= BD.NZ_MINA) + end + -- se non completo e U, cerco di lavorare anche la faccia di fondo (con il massimo affondamento possibile) + if not bComplete and bIs3Faces then + -- recupero la faccia da lavorare + local nFacInd = BL.GetFaceWithMostAdj( Proc.Id, nPartId) + local vtN + local bPock3rd = false + if nFacInd then + vtN = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT) + bPock3rd = ( vtN and vtN:getZ() >= BD.NZ_MINA) + end + if bPock3rd then + -- inserisco la lavorazione di svuotatura + local sName = EgtIf( bDoubleSide, 'Pock3rd_', 'Pock2nd_') .. ( 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 - if bPock3rd then - -- inserisco la lavorazione di svuotatura - local sName = 'Pock3rd_' .. ( 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 + -- aggiungo geometria + EgtSetMachiningGeometry( {{ Proc.Id, nFacInd}}) + -- imposto posizione braccio porta testa + local nSCC = MCH_SCC.NONE + if not BD.C_SIMM then + if AreSameOrOppositeVectorApprox( vtN, Z_AX()) then + nSCC = MCH_SCC.ADIR_YM + elseif abs( vtN:getX()) < 0.1 then + nSCC = EgtIf( BL.IsPartFinalPhase( nPhase), MCH_SCC.ADIR_XM, MCH_SCC.ADIR_XP) + elseif vtN:getY() < GEO.EPS_SMALL then + nSCC = MCH_SCC.ADIR_YM + else + nSCC = MCH_SCC.ADIR_YP end - -- aggiungo geometria - EgtSetMachiningGeometry( {{ Proc.Id, nFacInd}}) - -- imposto posizione braccio porta testa - local nSCC = MCH_SCC.NONE - if not BD.C_SIMM then - if AreSameOrOppositeVectorApprox( vtN, Z_AX()) then - nSCC = MCH_SCC.ADIR_YM - elseif abs( vtN:getX()) < 0.1 then - nSCC = EgtIf( BL.IsPartFinalPhase( nPhase), MCH_SCC.ADIR_XM, MCH_SCC.ADIR_XP) - elseif vtN:getY() < GEO.EPS_SMALL then - nSCC = MCH_SCC.ADIR_YM - else - nSCC = MCH_SCC.ADIR_YP - end - end - EgtSetMachiningParam( MCH_MP.SCC, nSCC) - -- 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, 0) - -- dichiaro non si generano sfridi per VMill - local sNotes = 'VMRS=0;' - EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) - -- eseguo + end + EgtSetMachiningParam( MCH_MP.SCC, nSCC) + -- 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, 0) + -- dichiaro non si generano sfridi per VMill + local 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 - -- 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 + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchFId, false) + return -1, sErr end end end end - return 1, sWarn, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace + return 1, sWarn, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, dDiamTool, bDoubleSide, nPathInt, nSurfInt, bOneShot end end end - return 0, sWarn, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, bOrthoFaces + return 0, sWarn, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, dDiamTool, bDoubleSide, nPathInt, nSurfInt, bOneShot, bOrthoFaces +end + +--------------------------------------------------------------------- +local function ManageAntiSplintBySaw( Proc, b3Raw, bIsU, vtN, nFacet, nFacInd, sWarn, bReduceDepth) + + local bMadeASbyBld = false + local nNumFac = EgtIf( bIsU, 2, 1) + local nPrefSide = 1 -- di preferenza il motore è meglio tenerlo sinistra + -- se a U cerco di ottimizzare il lato di lavoro della lama + if bIsU then + if abs( vtN:getY()) > 0.996 then + nPrefSide = 0 + elseif abs( vtN:getZ()) > 0.63 or abs( vtN:getY()) > 0.63 then +-- elseif abs( vtN:getZ()) > 0.7 or abs( vtN:getY()) > 0.7 then + -- se X è negativa allora devo tenere il motore a destra + if vtN:getX() < -(10 * GEO.EPS_SMALL) then + nPrefSide = 2 + end + end + end + -- va eseguito sulle facce diverse dalla principale + local nPrevSCC = nil + for nFacet = 0, nNumFac do + if nFacet ~= nFacInd then + -- lavoro + local dSawThick = 0 + local dMaxDepth = 200 + local bAdj, dAng, dExtraOffs, sWarn2, nIdMach + bMadeASbyBld, sWarn2, nIdMach, dSawThick, dMaxDepth, bAdj, dAng, dExtraOffs = MakeAntiSplintBySaw( Proc, nFacet, vtN, b3Raw, nFacInd, bReduceDepth) + if not bMadeASbyBld then return bMadeASbyBld, false, sWarn2 end + if sWarn2 then + if not sWarn then sWarn = '' end + sWarn = sWarn .. '\n' .. sWarn2 + end + -- se antischeggia veramente inserito perchè necessario + if nIdMach then + -- verifico se da invertire + local bInvertMach = false + local dDepth = 0 + if bIsU then + if abs(vtN:getZ()) > 0.63 or abs(vtN:getY()) > 0.63 then +-- if abs(vtN:getZ()) > 0.7 or abs(vtN:getY()) > 0.7 then + -- prendo il vettore normale alla faccia + local _, vtNFc = EgtSurfTmFacetCenter( Proc.Id, nFacet, GDB_ID.ROOT) + -- se superficie principale parallela al piano XZ + if nPrefSide == 0 then + -- se facce inclinate \\ allora mandrino a destra (per essere verso l'alto) + if vtNFc:getX() * vtNFc:getZ() > 0 then + nPrefSide = 2 + -- altrimenti facce inclinate // quindi mandrino a sinistra (per essere ancora verso l'alto) + else + nPrefSide = 1 + end + end + -- se faccia verso X+ e mandrino verso sinistra + if vtNFc:getX() > 0 and nPrefSide == 1 then + -- se angolo interno e circa -90 + if abs( dAng + 90) < 5 then + bInvertMach = true + end + -- se faccia verso X- e mandrino verso destra + elseif vtNFc:getX() < 0 and nPrefSide == 2 then + -- se angolo interno e circa -90 + if abs( dAng + 90) < 5 then + bInvertMach = true + end + end + end + end + -- eseguo inversione + if bInvertMach then + local bToolInvert = EgtGetMachiningParam( MCH_MP.TOOLINVERT) + local nWS = EgtGetMachiningParam( MCH_MP.WORKSIDE) + local nInvWS = EgtIf( nWS == MCH_MILL_WS.RIGHT, MCH_MILL_WS.LEFT, MCH_MILL_WS.RIGHT) + local nFaceUse = EgtGetMachiningParam( MCH_MP.FACEUSE) + local bOrtUp = ( nFaceUse >= MCH_MILL_FU.ORTUP_DOWN and nFaceUse <= MCH_MILL_FU.ORTUP_RIGHT) + if not bOrtUp then + -- assegno i parametri invertiti + EgtSetMachiningParam( MCH_MP.WORKSIDE, nInvWS) + EgtSetMachiningParam( MCH_MP.TOOLINVERT, not bToolInvert) + -- setto l'offset pari allo spessore lama + EgtSetMachiningParam( MCH_MP.OFFSL, -dSawThick) + end + end + -- posizione del braccio : se primo taglio la recupero, altrimenti la imposto + if not nPrevSCC then + nPrevSCC = EgtGetMachiningParam( MCH_MP.SCC) + else + EgtSetMachiningParam( MCH_MP.SCC, nPrevSCC) + end + -- rieseguo + if not EgtApplyMachining( true, false) then + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nIdMach, false) + return false, false, sErr + end + end + end + end + + return bMadeASbyBld, true, sWarn +end + +--------------------------------------------------------------------- +local function ManageAntiSplintByDrill( Proc, b3Raw, bIsU, vtN, vtN1, nFacet, nFacInd, sWarn) + + local bMadeASbyBld = false + local nNumFac = EgtIf( bIsU, 2, 1) + -- va eseguito sulle facce diverse dalla principale + local nPrevSCC = nil + for nFacet = 0, nNumFac do + if nFacet ~= nFacInd then + -- lavoro + local dSawThick = 0 + local dMaxDepth = 200 + local bAdj, dAng, dExtraOffs, sWarn2, nIdMach + bMadeASbyBld, sWarn2, nIdMach, dSawThick, dMaxDepth, bAdj, dAng, dExtraOffs = MakeAntiSplintBySaw( Proc, nFacet, vtN, b3Raw, nFacInd, bReduceDepth) + if not bMadeASbyBld then return bMadeASbyBld, false, sWarn2 end + if sWarn2 then + if not sWarn then sWarn = '' end + sWarn = sWarn .. '\n' .. sWarn2 + end + -- se antischeggia veramente inserito perchè necessario + if nIdMach then + -- verifico se da invertire + local bInvertMach = false + local dDepth = 0 + if bIsU then + if abs(vtN:getZ()) > 0.63 or abs(vtN:getY()) > 0.63 then +-- if abs(vtN:getZ()) > 0.7 or abs(vtN:getY()) > 0.7 then + -- prendo il vettore normale alla faccia + local _, vtNFc = EgtSurfTmFacetCenter( Proc.Id, nFacet, GDB_ID.ROOT) + -- se superficie principale parallela al piano XZ + if nPrefSide == 0 then + -- se facce inclinate \\ allora mandrino a destra (per essere verso l'alto) + if vtNFc:getX() * vtNFc:getZ() > 0 then + nPrefSide = 2 + -- altrimenti facce inclinate // quindi mandrino a sinistra (per essere ancora verso l'alto) + else + nPrefSide = 1 + end + end + -- se faccia verso X+ e mandrino verso sinistra + if vtNFc:getX() > 0 and nPrefSide == 1 then + -- se angolo interno e circa -90 + if abs( dAng + 90) < 5 then + bInvertMach = true + end + -- se faccia verso X- e mandrino verso destra + elseif vtNFc:getX() < 0 and nPrefSide == 2 then + -- se angolo interno e circa -90 + if abs( dAng + 90) < 5 then + bInvertMach = true + end + end + end + end + -- eseguo inversione + if bInvertMach then + local bToolInvert = EgtGetMachiningParam( MCH_MP.TOOLINVERT) + local nWS = EgtGetMachiningParam( MCH_MP.WORKSIDE) + local nInvWS = EgtIf( nWS == MCH_MILL_WS.RIGHT, MCH_MILL_WS.LEFT, MCH_MILL_WS.RIGHT) + local nFaceUse = EgtGetMachiningParam( MCH_MP.FACEUSE) + local bOrtUp = ( nFaceUse >= MCH_MILL_FU.ORTUP_DOWN and nFaceUse <= MCH_MILL_FU.ORTUP_RIGHT) + if not bOrtUp then + -- assegno i parametri invertiti + EgtSetMachiningParam( MCH_MP.WORKSIDE, nInvWS) + EgtSetMachiningParam( MCH_MP.TOOLINVERT, not bToolInvert) + -- setto l'offset pari allo spessore lama + EgtSetMachiningParam( MCH_MP.OFFSL, -dSawThick) + end + end + -- posizione del braccio : se primo taglio la recupero, altrimenti la imposto + if not nPrevSCC then + nPrevSCC = EgtGetMachiningParam( MCH_MP.SCC) + else + EgtSetMachiningParam( MCH_MP.SCC, nPrevSCC) + end + -- rieseguo + if not EgtApplyMachining( true, false) then + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nIdMach, false) + return false, false, sErr + end + end + end + end + + return bMadeASbyBld, true, sWarn end --------------------------------------------------------------------- @@ -3132,7 +3765,8 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa local bTryWithBlades = true -- lavoro fessura con svuotature (singola o doppia contrapposta) local sMyMchFind = 'Pocket' - local nOk, sErr, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace = MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCham, nAddGrpId, sMyMchFind, false, b3Solid, bClosedOrthoFaces) + local nOk, sErr, dDimMin, dDimMax, dDepth, vtOrtho, + nLundIdFace = MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCham, nAddGrpId, sMyMchFind, false, b3Solid, bClosedOrthoFaces) if nOk < 0 then return false, sErr elseif nOk > 0 then @@ -3432,7 +4066,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa -- altrimenti se abilitato dal parametro Q inserisco percorso di pulitura elseif EgtGetInfo( Proc.Id, Q_BORE_ON_CORNER, 'i') == 2 then local bOk - bOk, sWarn = MakeCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, 0, nAddGrpId, dDiamTool) + bOk, sWarn = MakeSharpCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, 0, nAddGrpId, dDiamTool) if not bOk then return false, sWarn end end end @@ -3600,7 +4234,8 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa if Proc.Fct == 3 and bIsU then -- lavoro con svuotature (singola o doppia contrapposta) local sMyMchFind = 'Pocket' - nOk, sErr, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, bOrthoFaces = MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCham, nAddGrpId, sMyMchFind, true, b3Solid) + nOk, sErr, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, _, _, _, _, _, + bOrthoFaces = MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCham, nAddGrpId, sMyMchFind, true, b3Solid) -- se lavorazione non idonee ( asse della feature troppo inclinato e impossibile lavorare completamente da due parti) if nOk == -2 then if not sMchFind then @@ -3652,13 +4287,26 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa return bOk, sWarn end else + -- se richiesti antischeggia con lama su U trasversale e smusso non esclusivo + -- rimane da gestire: se da eseguire con fresa o se richiesto lama ma impossibile utilizzarla, si utilizza fresa + -- 2021.04.27 esegue antischeggia di lama se forma U o L con feature passante in Y o Z + local bMadeASbyBld = false + local bPassThrou = ( Proc.Box:getDimY() > b3Raw:getDimY() - 1 or Proc.Box:getDimZ() > b3Raw:getDimZ() - 1) + if nChamfer < 2 and EgtGetInfo( Proc.Id, Q_ANTISPLINT_TYPE, 'i') == 1 and (( bIsU or bIsL) and bPassThrou) then + local bOk + bMadeASbyBld, bOk, sWarn = ManageAntiSplintBySaw( Proc, b3Raw, bIsU, vtN, nFacet, nFacInd, sWarn, true) + if not bOk then return false, sWarn end + end -- 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 -- lavoro con svuotature (singola o doppia contrapposta) local sMyMchFind = 'Pocket' - nOk, sErr, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, bOrthoFaces = MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCham, nAddGrpId, sMyMchFind, true, b3Solid) + local dDiamTool = 100 + local nPathInt, nSurfInt, bOneShot + nOk, sErr, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, dDiamTool, bDoubleSide, nPathInt, nSurfInt, bOneShot, + bOrthoFaces = MakeByPockets( Proc, nPhase, nRawId, nPartId, nChamfer, dDepthCham, nAddGrpId, sMyMchFind, true, b3Solid) if nOk == -2 then if not sMchFind then sMchFind = sMchFindBackUp @@ -3676,6 +4324,26 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa elseif nOk > 0 then bTryWithBlades = false sWarn = sErr + -- se ho antischeggia con fori le inserisco +-- if nChamfer < 2 and EgtGetInfo( Proc.Id, Q_ANTISPLINT_TYPE, 'i') == 2 and (( bIsU or bIsL) and bPassThrou) then +-- local bOk +-- bMadeASbyBld, bOk, sWarn = ManageAntiSplintByDrill( Proc, b3Raw, bIsU, vtOrtho, vtN, nFacet, nFacInd, sWarn) +-- if not bOk then return false, sWarn end +-- end + -- se abilitato dal parametro Q inserisco pulitura spigoli o contorno con fresa più piccola + local nContourSmallTool = EgtGetInfo( Proc.Id, Q_CONTOUR_SMALL_TOOL, 'i') or 0 + if nContourSmallTool > 0 then + local bOk, sWarn2 + bOk, sWarn2 = MakeRoundCleanCornerOrContour( Proc, nPhase, nRawId, nPartId, b3Raw, + nFacInd, nAddGrpId, dDiamTool, nContourSmallTool, bDoubleSide, + vtOrtho, nPathInt, nSurfInt, b3Solid, dDepth, + bOneShot) + if not bOk then return false, sWarn2 end + if sWarn2 then + if not sWarn then sWarn = '' end + sWarn = EgtIf( #sWarn > 0, sWarn .. '\n' .. sWarn2, sWarn2) + end + end end bOk = true end @@ -3708,6 +4376,18 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa return false, sErr2 end else + -- se abilitato dal parametro Q inserisco pulitura spigoli o contorno con fresa più piccola + local nContourSmallTool = EgtGetInfo( Proc.Id, Q_CONTOUR_SMALL_TOOL, 'i') or 0 + if nContourSmallTool > 0 then + local bOk, sWarn2 + bOk, sWarn2 = MakeRoundCleanCornerOrContour( Proc, nPhase, nRawId, nPartId, b3Raw, + nFacInd, nAddGrpId, 100, nContourSmallTool) + if not bOk then return false, sWarn2 end + if sWarn2 then + if not sWarn then sWarn = '' end + sWarn = EgtIf( #sWarn > 0, sWarn .. '\n' .. sWarn2, sWarn2) + end + end return bOk, sWarn end -- altrimenti verifico se ho già svuotato dal fianco, se si esco @@ -3734,94 +4414,9 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa local bMadeASbyBld = false local bPassThrou = ( Proc.Box:getDimY() > b3Raw:getDimY() - 1 or Proc.Box:getDimZ() > b3Raw:getDimZ() - 1) if nChamfer < 2 and EgtGetInfo( Proc.Id, Q_ANTISPLINT_TYPE, 'i') == 1 and (( bIsU or bIsL) and bPassThrou) then - local nNumFac = EgtIf( bIsU, 2, 1) - local nPrefSide = 1 -- di preferenza il motore è meglio tenerlo sinistra - -- se a U cerco di ottimizzare il lato di lavoro della lama - if bIsU then - if abs( vtN:getY()) > 0.996 then - nPrefSide = 0 - elseif abs( vtN:getZ()) > 0.63 or abs( vtN:getY()) > 0.63 then --- elseif abs( vtN:getZ()) > 0.7 or abs( vtN:getY()) > 0.7 then - -- se X è negativa allora devo tenere il motore a destra - if vtN:getX() < -(10 * GEO.EPS_SMALL) then - nPrefSide = 2 - end - end - end - -- va eseguito sulle facce diverse dalla principale - local nPrevSCC = nil - for nFacet = 0, nNumFac do - if nFacet ~= nFacInd then - -- lavoro - local dSawThick = 0 - bMadeASbyBld, sWarn, nIdMach, dSawThick = MakeAntiSplintBySaw( Proc, nFacet, vtN, b3Raw) - if not bMadeASbyBld then return false, sWarn end - -- se antischeggia veramente inserito perchè necessario - if nIdMach then - -- verifico se da invertire - local bInvertMach = false - if bIsU then - if abs(vtN:getZ()) > 0.63 or abs(vtN:getY()) > 0.63 then --- if abs(vtN:getZ()) > 0.7 or abs(vtN:getY()) > 0.7 then - -- prendo il vettore normale alla faccia - local _, vtNFc = EgtSurfTmFacetCenter( Proc.Id, nFacet, GDB_ID.ROOT) - -- valuto l'angolo tra le due facce - local bAdj, _, _, dAng = EgtSurfTmFacetsContact( Proc.Id, nFacInd, nFacet, GDB_ID.ROOT) - -- se superficie principale parallela al piano XZ - if nPrefSide == 0 then - -- se facce inclinate \\ allora mandrino a destra (per essere verso l'alto) - if vtNFc:getX() * vtNFc:getZ() > 0 then - nPrefSide = 2 - -- altrimenti facce inclinate // quindi mandrino a sinistra (per essere ancora verso l'alto) - else - nPrefSide = 1 - end - end - -- se faccia verso X+ e mandrino verso sinistra - if vtNFc:getX() > 0 and nPrefSide == 1 then - -- se angolo interno e circa -90 - if abs( dAng + 90) < 5 then - bInvertMach = true - end - -- se faccia verso X- e mandrino verso destra - elseif vtNFc:getX() < 0 and nPrefSide == 2 then - -- se angolo interno e circa -90 - if abs( dAng + 90) < 5 then - bInvertMach = true - end - end - end - end - -- eseguo inversione - if bInvertMach then - local bToolInvert = EgtGetMachiningParam( MCH_MP.TOOLINVERT) - local nWS = EgtGetMachiningParam( MCH_MP.WORKSIDE) - local nInvWS = EgtIf( nWS == MCH_MILL_WS.RIGHT, MCH_MILL_WS.LEFT, MCH_MILL_WS.RIGHT) - local nFaceUse = EgtGetMachiningParam( MCH_MP.FACEUSE) - local bOrtUp = ( nFaceUse >= MCH_MILL_FU.ORTUP_DOWN and nFaceUse <= MCH_MILL_FU.ORTUP_RIGHT) - if not bOrtUp then - -- assegno i parametri invertiti - EgtSetMachiningParam( MCH_MP.WORKSIDE, nInvWS) - EgtSetMachiningParam( MCH_MP.TOOLINVERT, not bToolInvert) - -- setto l'offset pari allo spessore lama - EgtSetMachiningParam( MCH_MP.OFFSL, -dSawThick) - end - end - -- posizione del braccio : se primo taglio la recupero, altrimenti la imposto - if not nPrevSCC then - nPrevSCC = EgtGetMachiningParam( MCH_MP.SCC) - else - EgtSetMachiningParam( MCH_MP.SCC, nPrevSCC) - end - -- rieseguo - if not EgtApplyMachining( true, false) then - local _, sErr = EgtGetLastMachMgrError() - EgtSetOperationMode( nIdMach, false) - return false, sErr - end - end - end - end + local bOk + bMadeASbyBld, bOk, sWarn = ManageAntiSplintBySaw( Proc, b3Raw, bIsU, vtN, nFacet, nFacInd, sWarn) + if not bOk then return false, sWarn end end -- se smusso non esclusivo @@ -3829,9 +4424,13 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa -- eseguo la svuotatura della faccia principale, mi restituisce id utensile, il diametro utensile per il foro opzionale local tvtNx = {} tvtNx[2] = vtN - local bOk - bOk, sWarn, sTuuidPk, dDiamTool = MakePocket( Proc, nPartId, ptC, tvtNx, nFacInd, sMchFind, nUseRoughTool, sPocketing, dFacElev + dCollSic) - if not bOk then return false, sWarn end + local bOk, sWarn2 + bOk, sWarn2, sTuuidPk, dDiamTool = MakePocket( Proc, nPartId, ptC, tvtNx, nFacInd, sMchFind, nUseRoughTool, sPocketing, dFacElev + dCollSic) + if not bOk then return false, sWarn2 end + if sWarn2 then + if not sWarn then sWarn = '' end + sWarn = EgtIf( #sWarn > 0, sWarn .. '\n' .. sWarn2, sWarn2) + end -- se ho più di 3 facce e non di forma ad u oppure ho 3 facce e 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 @@ -3857,29 +4456,50 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa _, tvtNx[2] = EgtSurfTmFacetCenter( Proc.Id, vAdj[i], GDB_ID.ROOT) tDimAndRef[2] = {dH2, dV2, rfFac2} local ptPs = ( ptP1 + ptP2) / 2 - local bOk - bOk, sWarn = MachineByMill( Proc, nPhase, nRawId, nPartId, b3Solid, tvtNx, nFacInd, vAdj[i], ptPs, tDimAndRef, - b3Raw, EgtIf( ( Proc.Fct == 3 and bIsU), 0, 2), nUseRoughTool, dAng, sPocketing, sTuuidPk, dFacElev) - if not bOk then return bOk, sWarn end + local bOk, sWarn2 + bOk, sWarn2 = MachineByMill( Proc, nPhase, nRawId, nPartId, b3Solid, tvtNx, nFacInd, vAdj[i], ptPs, tDimAndRef, + b3Raw, EgtIf( ( Proc.Fct == 3 and bIsU), 0, 2), nUseRoughTool, dAng, sPocketing, sTuuidPk, dFacElev) + if not bOk then return bOk, sWarn2 end + if sWarn2 then + if not sWarn then sWarn = '' end + sWarn = EgtIf( #sWarn > 0, sWarn .. '\n' .. sWarn2, sWarn2) + end end end end end + local nBoreOnCorner = EgtGetInfo( Proc.Id, Q_BORE_ON_CORNER, 'i') or 0 + local nContourSmallTool = EgtGetInfo( Proc.Id, Q_CONTOUR_SMALL_TOOL, 'i') or 0 -- se abilitato dal parametro Q inserisco foro sullo spigolo - if EgtGetInfo( Proc.Id, Q_BORE_ON_CORNER, 'i') == 1 then - local bOk - bOk, sWarn = MakeDrillOnCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, nAddGrpId, dDiamTool) - if not bOk then return false, sWarn end + if nBoreOnCorner == 1 then + local bOk, sWarn2 + bOk, sWarn2 = MakeDrillOnCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, nAddGrpId, dDiamTool) + if not bOk then return false, sWarn2 end + sWarn = sWarn .. '\n' .. sWarn2 + if sWarn2 then + if not sWarn then sWarn = '' end + sWarn = sWarn .. '\n' .. sWarn2 + sWarn = EgtIf( #sWarn > 0, sWarn .. '\n' .. sWarn2, sWarn2) + end -- altrimenti se abilitato dal parametro Q inserisco percorso di pulitura - elseif EgtGetInfo( Proc.Id, Q_BORE_ON_CORNER, 'i') == 2 then - local bOk - bOk, sWarn = MakeCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, nAddGrpId, dDiamTool) - if not bOk then return false, sWarn end - -- altrimenti se abilitato dal parametro Q inserisco contorno con fresa più piccola - elseif EgtGetInfo( Proc.Id, Q_CONTOUR_SMALL_TOOL, 'i') == 1 then - local bOk - bOk, sWarn = MakeContourCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, nAddGrpId, dDiamTool) - if not bOk then return false, sWarn end + elseif nBoreOnCorner == 2 then + local bOk, sWarn2 + bOk, sWarn2 = MakeSharpCleanCorner( Proc, nPhase, nRawId, nPartId, b3Raw, nFacInd, nAddGrpId, dDiamTool) + if not bOk then return false, sWarn2 end + if sWarn2 then + if not sWarn then sWarn = '' end + sWarn = EgtIf( #sWarn > 0, sWarn .. '\n' .. sWarn2, sWarn2) + end + -- altrimenti se abilitato dal parametro Q inserisco pulitura spigoli o contorno con fresa più piccola + elseif nContourSmallTool > 0 then + local bOk, sWarn2 + bOk, sWarn2 = MakeRoundCleanCornerOrContour( Proc, nPhase, nRawId, nPartId, b3Raw, + nFacInd, nAddGrpId, dDiamTool, nContourSmallTool) + if not bOk then return false, sWarn2 end + if sWarn2 then + if not sWarn then sWarn = '' end + sWarn = EgtIf( #sWarn > 0, sWarn .. '\n' .. sWarn2, sWarn2) + end end end end @@ -3947,12 +4567,29 @@ function ProcessLapJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead) -- se non forzate frese, uso la lama local bUseBlade = EgtGetInfo( Proc.Id, Q_USE_ROUGH_TOOL, 'i') ~= 1 and EgtGetInfo( Proc.Id, Q_USE_MILL, 'i') ~= 1 -- se ho attivo la lama e ho la feature 30, verifico i parametri Q propri della feature - if bUseBlade and Proc.Prc == 30 then - local nBladeAntisplint = EgtGetInfo( Proc.Id, Q_ANTISPLINT_TYPE, 'i') or 0 - local nUseRoughToolOnSide = EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'i') or 0 - -- se antischeggia di fresa o abilitato sgrossatore di fianco - if nBladeAntisplint == 2 or nUseRoughToolOnSide == 1 then - bUseBlade = false + if bUseBlade then + if Proc.Prc == 30 then + local nBladeAntisplint = EgtGetInfo( Proc.Id, Q_ANTISPLINT_TYPE, 'i') or 0 + local nUseRoughToolOnSide = EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'i') or 0 + -- se antischeggia di fresa o abilitato sgrossatore di fianco + if nBladeAntisplint == 2 or nUseRoughToolOnSide == 1 then + bUseBlade = false + end + -- se ho attivo la lama e ho la feature 32, verifico i parametri Q propri della feature + elseif Proc.Prc == 32 then + local nBladeAntisplint = EgtGetInfo( Proc.Id, Q_ANTISPLINT_TYPE, 'i') or 0 + local nUseRoughToolOnSide = EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'i') or 0 + -- se antischeggia di fresa o abilitato sgrossatore di fianco + if nBladeAntisplint == 2 or nUseRoughToolOnSide == 1 then + bUseBlade = false + end + -- se ho attivo la lama e ho la feature 34, verifico i parametri Q propri della feature + elseif Proc.Prc == 34 then + local nBladeAntisplint = EgtGetInfo( Proc.Id, Q_ANTISPLINT_TYPE, 'i') or 0 + -- se antischeggia di fresa o abilitato sgrossatore di fianco + if nBladeAntisplint == 2 then + bUseBlade = false + end end end -- se lunghezza richiede spezzatura