From 516a56c8b593a41eb03434304995a4ce11fe8286 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Mon, 29 Aug 2022 13:25:07 +0200 Subject: [PATCH] BugFix/DoubleCutCollision: update commenti --- LuaLibs/ProcessDoubleCut.lua | 418 +++++++++++++++++------------------ 1 file changed, 208 insertions(+), 210 deletions(-) diff --git a/LuaLibs/ProcessDoubleCut.lua b/LuaLibs/ProcessDoubleCut.lua index d1efb0b..e2d2b3c 100644 --- a/LuaLibs/ProcessDoubleCut.lua +++ b/LuaLibs/ProcessDoubleCut.lua @@ -1,5 +1,6 @@ -- ProcessDoubleCut.lua by Egaltech s.r.l. 2022/07/11 -- Gestione calcolo doppi tagli di lama per Travi +-- 2022/08/29 Implementata la fresatura dal lato per tagli problematici per PF -- Tabella per definizione modulo local ProcessDoubleCut = {} @@ -329,225 +330,222 @@ end --------------------------------------------------------------------- local function MakeBySidePocket( Proc, nPhase, nRawId, nPartId, nAddGrpId, b3Solid) --- nOk, sErr, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, dDiamTool, bDoubleSide, nPathInt, nSurfInt, bOneShot, bMillDown, nFirstMachId, --- bOrthoFaces = MakeByPockets( Proc, nPhase, nRawId, nPartId, NO nChamfer, NO dDepthCham, nAddGrpId, NO sMyMchFind, NO bIs3Faces, b3Solid, NO bOrthoFacesMaster, NO bMillDown, NO bSetOpenBorders) - local nFirstMachId local sWarn local sMchFind = 'OpenPocket' local dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt local bBadMach = false - - -- ottengo le dimensioni del tunnel - dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = GetTunnelDimension( Proc, nPartId) - -- posso utilizzare utensile con diametro doppio della dimensione minima - dDimMin = min( 2 * dDimMin, BD.MAXDIAM_POCK_CORNER) - local nPathInt - -- calcolo se è lavorabile da sotto - bMillDown = ( BD.DOWN_HEAD == true and abs( vtOrtho:getZ()) >= 0.707) - -- verifico se può essere fatto con svuotatura - local bMakePocket, sPocketing, dMaxDepth, dDiamTool = VerifyPocket( Proc, dDimMin, dDepth / 2, nil, sMchFind) - local bMakePocketDn, sPocketingDn, dMaxDepthDn, dDiamToolDn - if bMillDown then - bMakePocketDn, sPocketingDn, dMaxDepthDn, dDiamToolDn = VerifyPocket( Proc, dDimMin, dDepth / 2, nil, sMchFind, true) - -- se è negativo inverto il versore e la faccia - if vtOrtho:getZ() < 0 then - vtOrtho = -vtOrtho - EgtInvertSurf( nSurfInt) - end - end - 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 - nPathInt = EgtExtractSurfTmLoops( nSurfInt, nAddGrpId) - EgtModifyCurveExtrusion( nPathInt, vtOrtho, GDB_RT.GLOB) - SetOpenSide( nPathInt, vtOrtho, b3Solid, nAddGrpId) - -- variabili per parametri lavorazione - 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 + -- ottengo le dimensioni del tunnel + dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = GetTunnelDimension( Proc, nPartId) + -- posso utilizzare utensile con diametro doppio della dimensione minima + dDimMin = min( 2 * dDimMin, BD.MAXDIAM_POCK_CORNER) + local nPathInt + -- verifico se è presente la testa da sotto e se è necessario usarla + bMillDown = ( BD.DOWN_HEAD == true and abs( vtOrtho:getZ()) >= 0.707) + -- cerco l'utensile di svuotatura per la testa sopra + local bMakePocket, sPocketing, dMaxDepth, dDiamTool = VerifyPocket( Proc, dDimMin, dDepth / 2, nil, sMchFind) + local bMakePocketDn, sPocketingDn, dMaxDepthDn, dDiamToolDn + -- cerco anche l'utensile per la testa sotto, nel caso servisse + if bMillDown then + bMakePocketDn, sPocketingDn, dMaxDepthDn, dDiamToolDn = VerifyPocket( Proc, dDimMin, dDepth / 2, nil, sMchFind, true) + -- se è negativo inverto il versore e la faccia + if vtOrtho:getZ() < 0 then + vtOrtho = -vtOrtho + EgtInvertSurf( nSurfInt) + end + end + 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 + nPathInt = EgtExtractSurfTmLoops( nSurfInt, nAddGrpId) + EgtModifyCurveExtrusion( nPathInt, vtOrtho, GDB_RT.GLOB) + SetOpenSide( nPathInt, vtOrtho, b3Solid, nAddGrpId) + -- variabili per parametri lavorazione + 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 + if abs( vtOrtho:getZ()) >= 0.707 and not BD.DOWN_HEAD then + dMachDepth = dMaxDepth - ( dDepth / 2) - dCollSic + 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 + if dMaxDepth > ( dDepth / 2) + dCollSic + BD.CUT_EXTRA_MIN then + dMachDepth = BD.CUT_EXTRA_MIN + dElev = ( dDepth / 2) + BD.CUT_EXTRA_MIN + -- altrimenti non si riesce in due passate, limito la profondità e setto l'elevazione 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 and not BD.DOWN_HEAD then - dMachDepth = dMaxDepth - ( dDepth / 2) - dCollSic - 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 - if dMaxDepth > ( dDepth / 2) + dCollSic + BD.CUT_EXTRA_MIN then - dMachDepth = BD.CUT_EXTRA_MIN - dElev = ( dDepth / 2) + BD.CUT_EXTRA_MIN - -- altrimenti non si riesce in due passate, limito la profondità e setto l'elevazione - else - dMachDepth = dMaxDepth - ( dDepth / 2) - dCollSic - dElev = dMaxDepth - -- se molto inclinato rispetto alla normale della faccia di riferimento, lavorazione non idonea per probabili collisioni - local vtRef = Y_AX() - if abs( vtOrtho:getX()) > abs( vtOrtho:getY()) and abs( vtOrtho:getX()) > abs( vtOrtho:getZ()) then - vtRef = X_AX() - elseif abs( vtOrtho:getZ()) > abs( vtOrtho:getX()) and abs( vtOrtho:getZ()) > abs( vtOrtho:getY()) then - vtRef = Z_AX() - end - if abs( vtOrtho * vtRef) < 0.5 then - bBadMach = true - end - end - bDoubleSide = true + dMachDepth = dMaxDepth - ( dDepth / 2) - dCollSic + dElev = dMaxDepth + -- se molto inclinato rispetto alla normale della faccia di riferimento, lavorazione non idonea per probabili collisioni + local vtRef = Y_AX() + if abs( vtOrtho:getX()) > abs( vtOrtho:getY()) and abs( vtOrtho:getX()) > abs( vtOrtho:getZ()) then + vtRef = X_AX() + elseif abs( vtOrtho:getZ()) > abs( vtOrtho:getX()) and abs( vtOrtho:getZ()) > abs( vtOrtho:getY()) then + vtRef = Z_AX() + end + if abs( vtOrtho * vtRef) < 0.5 then + bBadMach = 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) + 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 + -- prendo l'id della prima lavorazione inserita + if not nFirstMachId then + nFirstMachId = nMchFId + 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 and not BD.DOWN_HEAD 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 and not ( -(vtOrtho:getZ()) < BD.NZ_MINA) then + EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) + bInvertMach = true + end + -- imposto posizione braccio porta testa + local nSCC = MCH_SCC.NONE + if not BD.C_SIMM then + if AreSameOrOppositeVectorApprox( vtOrtho, Z_AX()) then + nSCC = MCH_SCC.ADIR_YM + elseif abs( vtOrtho:getX()) < 0.1 then + nSCC = EgtIf( BL.IsPartFinalPhase( nPhase), MCH_SCC.ADIR_XM, MCH_SCC.ADIR_XP) + elseif vtOrtho: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) + EgtSetMachiningParam( MCH_MP.SUBTYPE, MCH_POCK_SUB.SPIRALIN) + -- 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 ML.ApplyMachining( true, false) then + -- provo ad allargare leggermente la tasca + EgtSetMachiningParam( MCH_MP.OFFSR, -0.1) + if not ML.ApplyMachining( 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 ho la lavorazione da sotto ricalcolo in base a questa lavorazione + if bMakePocketDn then + -- sPocketing = sPocketingDn + -- dMaxDepth = dMaxDepthDn + -- dDiamTool = dDiamToolDn + -- se l'altezza utensile riesce a lavorare completamente da due parti + if dMaxDepthDn > ( dDepth / 2) + dCollSic + BD.CUT_EXTRA_MIN then + dMachDepth = BD.CUT_EXTRA_MIN + dElev = ( dDepth / 2) + BD.CUT_EXTRA_MIN + -- altrimenti non si riesce in due passate, limito la profondità e setto l'elevazione + else + dMachDepth = dMaxDepthDn - ( dDepth / 2) - dCollSic + dElev = dMaxDepthDn + bComplete = false + sWarn = 'Warning : elevation bigger than max tool depth' + EgtOutLog( sWarn) + end + else + -- se anche lavorando dal lato opposto non riesco a svuotare completamente la fessura + -- setto i parametri affondamento ed emetto warning + if dMaxDepth < ( dDepth / 2) + BD.CUT_EXTRA + dCollSic then + dMachDepth = dMaxDepth - (dDepth / 2) - dCollSic + dElev = dMaxDepth + bComplete = false + sWarn = 'Warning : elevation bigger than max tool depth' + EgtOutLog( sWarn) + end + end + -- inserisco la lavorazione di svuotatura + local sName = 'PockOppo_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) + local nMchFId = EgtAddMachining( sName, EgtIf( bMakePocketDn, sPocketingDn, sPocketing)) + if not nMchFId then + local sErr = 'Error adding machining ' .. sName .. '-' .. EgtIf( bMakePocketDn, sPocketingDn, sPocketing) + EgtOutLog( sErr) + return -1, sErr + end + -- prendo l'id della prima lavorazione inserita + if not nFirstMachId then + nFirstMachId = nMchFId + end + -- aggiungo geometria + EgtSetMachiningGeometry( {{ nPathInt, -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( vtOrtho, Z_AX()) then + nSCC = MCH_SCC.ADIR_YM + elseif abs( vtOrtho:getX()) < 0.1 then + nSCC = EgtIf( BL.IsPartFinalPhase( nPhase), MCH_SCC.ADIR_XM, MCH_SCC.ADIR_XP) + elseif vtOrtho: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.SUBTYPE, MCH_POCK_SUB.SPIRALIN) + -- 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 ML.ApplyMachining( true, false) then + -- provo ad allargare leggermente la tasca + EgtSetMachiningParam( MCH_MP.OFFSR, -0.1) + if not ML.ApplyMachining( true, false) then + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchFId, false) return -1, sErr end - -- prendo l'id della prima lavorazione inserita - if not nFirstMachId then - nFirstMachId = nMchFId - 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 and not BD.DOWN_HEAD 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 and not ( -(vtOrtho:getZ()) < BD.NZ_MINA) then - EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) - bInvertMach = true - end - -- imposto posizione braccio porta testa - local nSCC = MCH_SCC.NONE - if not BD.C_SIMM then - if AreSameOrOppositeVectorApprox( vtOrtho, Z_AX()) then - nSCC = MCH_SCC.ADIR_YM - elseif abs( vtOrtho:getX()) < 0.1 then - nSCC = EgtIf( BL.IsPartFinalPhase( nPhase), MCH_SCC.ADIR_XM, MCH_SCC.ADIR_XP) - elseif vtOrtho: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) - EgtSetMachiningParam( MCH_MP.SUBTYPE, MCH_POCK_SUB.SPIRALIN) - -- 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 ML.ApplyMachining( true, false) then - -- provo ad allargare leggermente la tasca - EgtSetMachiningParam( MCH_MP.OFFSR, -0.1) - if not ML.ApplyMachining( 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 ho la lavorazione da sotto ricalcolo in base a questa lavorazione - if bMakePocketDn then - -- sPocketing = sPocketingDn - -- dMaxDepth = dMaxDepthDn - -- dDiamTool = dDiamToolDn - -- se l'altezza utensile riesce a lavorare completamente da due parti - if dMaxDepthDn > ( dDepth / 2) + dCollSic + BD.CUT_EXTRA_MIN then - dMachDepth = BD.CUT_EXTRA_MIN - dElev = ( dDepth / 2) + BD.CUT_EXTRA_MIN - -- altrimenti non si riesce in due passate, limito la profondità e setto l'elevazione - else - dMachDepth = dMaxDepthDn - ( dDepth / 2) - dCollSic - dElev = dMaxDepthDn - bComplete = false - sWarn = 'Warning : elevation bigger than max tool depth' - EgtOutLog( sWarn) - end - else - -- se anche lavorando dal lato opposto non riesco a svuotare completamente la fessura - -- setto i parametri affondamento ed emetto warning - if dMaxDepth < ( dDepth / 2) + BD.CUT_EXTRA + dCollSic then - dMachDepth = dMaxDepth - (dDepth / 2) - dCollSic - dElev = dMaxDepth - bComplete = false - sWarn = 'Warning : elevation bigger than max tool depth' - EgtOutLog( sWarn) - end - end - -- inserisco la lavorazione di svuotatura - local sName = 'PockOppo_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) - local nMchFId = EgtAddMachining( sName, EgtIf( bMakePocketDn, sPocketingDn, sPocketing)) - if not nMchFId then - local sErr = 'Error adding machining ' .. sName .. '-' .. EgtIf( bMakePocketDn, sPocketingDn, sPocketing) - EgtOutLog( sErr) - return -1, sErr - end - -- prendo l'id della prima lavorazione inserita - if not nFirstMachId then - nFirstMachId = nMchFId - end - -- aggiungo geometria - EgtSetMachiningGeometry( {{ nPathInt, -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( vtOrtho, Z_AX()) then - nSCC = MCH_SCC.ADIR_YM - elseif abs( vtOrtho:getX()) < 0.1 then - nSCC = EgtIf( BL.IsPartFinalPhase( nPhase), MCH_SCC.ADIR_XM, MCH_SCC.ADIR_XP) - elseif vtOrtho: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.SUBTYPE, MCH_POCK_SUB.SPIRALIN) - -- 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 ML.ApplyMachining( true, false) then - -- provo ad allargare leggermente la tasca - EgtSetMachiningParam( MCH_MP.OFFSR, -0.1) - if not ML.ApplyMachining( true, false) then - local _, sErr = EgtGetLastMachMgrError() - EgtSetOperationMode( nMchFId, false) - return -1, sErr - end - end - end - return 1, sWarn, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, dDiamTool, bDoubleSide, nPathInt, nSurfInt, bOneShot, bMillDown, nFirstMachId end + end + return 1, sWarn, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, dDiamTool, bDoubleSide, nPathInt, nSurfInt, bOneShot, bMillDown, nFirstMachId + end return 0, sWarn, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, dDiamTool, bDoubleSide, nPathInt, nSurfInt, bOneShot, bMillDown, nFirstMachId, bOrthoFaces end @@ -636,7 +634,8 @@ function ProcessDoubleCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead) -- eseguo local sCutType = EgtIf( bHead, 'HeadSide', 'TailSide') local bDownHead = ( BD.DOWN_HEAD and vtNm:getZ() < BD.NZ_MINB) - + -- per tutte le macchine tranne la Fast, controllo se ci sono tagli troppo inclinati e troppo profondi per la lama + -- in tal caso richiamo la lavorazione con fresa dal lato if BD.C_SIMM and not bDownHead then local sCutting = ML.FindCutting( sCutType, nil, bDownHead) if not sCutting then @@ -660,7 +659,6 @@ function ProcessDoubleCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead) return bOk, sErr end end - local bOk, sErr = Fbs.MakeTwo( Proc, nPhase, nRawId, nPartId, dOvmHead, sCutType, false, bDownHead) if not bOk then return bOk, sErr end -- segnalazione ingombro di testa o coda