Egalware/DataBeam
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- ottimizzazioni

Browse Source
This commit is contained in:
luca.bacis
2022-01-20 15:06:10 +01:00
parent 83d255e28f
commit 83502accaf
1 changed files with 69 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files
LuaLibs/ProcessLapJoint.lua
+69 -82
View File
@@ -99,7 +99,6 @@ end
---------------------------------------------------------------------
local function AssignQValues( Proc)
-- reset assegnazione parametri Q
Q_FORCE_BLADE = nil
Q_BLADE_ON_ALONG_FACE = 0
@@ -151,7 +150,6 @@ end
---------------------------------------------------------------------
local function EvaluateQParam()
local sErr
-- verifico che lo smusso sia richiesto
local nChamfer = 0
@@ -185,7 +183,6 @@ end
---------------------------------------------------------------------
local function InitGlob( Proc, nPhase, nRawId, nPartId, dOvmHead)
if not Proc then
return false, 'Error : Proc is missing'
end
@@ -274,7 +271,6 @@ end
local function GetFacetsData( nProcId)
local tFData = {}
local nFacInd, dFacElev, nFacInd2, dFacElev2 = BL.GetFaceWithMostAdj( nProcId, _nPartId)
if nFacInd then
tFData = UpdateFacet1Data( nProcId, tFData, nFacInd, dFacElev)
tFData = UpdateFacet2Data( nProcId, tFData, nFacInd2, dFacElev2)
@@ -302,10 +298,7 @@ end
---------------------------------------------------------------------
local function GetToolInfoForMachining( sMachiningName)
if EgtMdbSetCurrMachining( sMachiningName) then
local toolInfo = { sTuuid = nil, dLength = nil, dDiam = nil,
dThDiam = nil, dMaxMat = nil, dMaxDepth = nil,
dSideDepth = nil, dCornerRad = nil, dThick = nil }
local toolInfo = {}
toolInfo.sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( toolInfo.sTuuid) or '') then
toolInfo.dLength = EgtTdbGetCurrToolParam( MCH_TP.LEN)
@@ -462,7 +455,7 @@ local function GetChainSawInitAngs( vtN, vtO)
end
---------------------------------------------------------------------
local function VerifyChainSaw( Proc, dMinDim, dMaxDim)
local function VerifyChainSaw( dMinDim, dMaxDim)
local bUseChainSaw = false
local sMchFind = 'Sawing'
local sSawing = ML.FindSawing( sMchFind)
@@ -494,7 +487,7 @@ local function VerifyChainSaw( Proc, dMinDim, dMaxDim)
end
---------------------------------------------------------------------
local function VerifyPocket( Proc, dDiam, dDepth, dMaxTotLen, sMchFindMaster)
local function VerifyPocket( dDiam, dDepth, dMaxTotLen, sMchFindMaster)
-- tipo di svuotatura
local sMchFind = EgtIf( sMchFindMaster and #sMchFindMaster > 0, sMchFindMaster, 'Pocket')
-- ricerca della svuotatura
@@ -665,27 +658,26 @@ local function GetTunnelDimension( Proc)
end
---------------------------------------------------------------------
local function GetFaceAdj( Proc, nFacInd, dH, dV)
local function GetFaceAdj( Proc, tFData)
-- Recupero le facce adiacenti alla principale (solo quelle esistenti)
local vAdj = GetValidFacetAdjacencies( Proc.Id, nFacInd)
local vAdj = GetValidFacetAdjacencies( Proc.Id, tFData.nFacInd)
if not vAdj or #vAdj == 0 then
local sErr = 'Error : main face without adjacencies'
return -1, sErr
end
EgtOutLog( 'Adjac=' .. table.concat( vAdj, ','), 4)
-- Riordino le dimensioni per avere dH > dV
if dH < dV then
dH, dV = dV, dH
if tFData.dH < tFData.dV then
tFData.dH, tFData.dV = tFData.dV, tFData.dH
end
-- Cerco una faccia adiacente alla principale sul lato lungo
local nFacAdj
for i = 1, #vAdj do
local _, ptP1, ptP2, _ = EgtSurfTmFacetsContact( Proc.Id, nFacInd, vAdj[i], GDB_ID.ROOT)
local _, ptP1, ptP2, _ = EgtSurfTmFacetsContact( Proc.Id, tFData.nFacInd, vAdj[i], GDB_ID.ROOT)
local dLen = dist( ptP1, ptP2)
if dLen > 0.5 * dH then
if dLen > 0.5 * tFData.dH then
nFacAdj = vAdj[i]
EgtOutLog( string.format( 'Adjac=%d Len=%.3f H=%.3f V=%.3f', vAdj[i], dLen, dH, dV), 4)
EgtOutLog( string.format( 'Adjac=%d Len=%.3f H=%.3f V=%.3f', vAdj[i], dLen, tFData.dH, tFData.dV), 4)
break
end
end
@@ -886,9 +878,9 @@ function ProcessLapJoint.Classify( Proc, b3Raw)
local dDimMin, dDimMax, _, _, _, nSurfInt = GetTunnelDimension( Proc)
EgtErase( nSurfInt)
-- verifico se può essere fatto con svuotatura
if VerifyPocket( Proc, dDimMin) then
if VerifyPocket( dDimMin) then
return true, false
elseif VerifyChainSaw( Proc, dDimMin, dDimMax) then
elseif VerifyChainSaw( dDimMin, dDimMax) then
return true, false
else
return false
@@ -904,7 +896,7 @@ function ProcessLapJoint.Classify( Proc, b3Raw)
-- dati della faccia
local _, vtN = EgtSurfTmFacetCenter( Proc.Id, tFData.nFacInd, GDB_ID.ROOT)
-- cerco se c'è faccia adiacente sul lato più lungo
local nFaceAdj = GetFaceAdj( Proc, tFData.nFacInd, tFData.dH, tFData.dV) or -1
local nFaceAdj = GetFaceAdj( Proc, tFData) or -1
local _, bIsL = TestUL( Proc)
-- verifico se è lavorabile solo dal basso
local bDown = ( vtN:getZ() < BD.NZ_MINA and not BD.DOWN_HEAD)
@@ -1039,7 +1031,6 @@ end
---------------------------------------------------------------------
local function MakeTwoFacesByMill( Proc, bDownHead)
-- verifico il numero di facce della tacca
assert( ( Proc.Fct == 2), 'Error : MakeTwoFacesByMill in LapJoint with ' .. tostring( Proc.Fct) .. ' faces')
-- recupero la lavorazione
@@ -1168,7 +1159,7 @@ end
---------------------------------------------------------------------
local function MakeByMill( Proc, tFData, dCollSic, bSpecialApp, sMillMaster)
-- Cerco una faccia adiacente alla principale sul lato lungo
local nFacAdj, sErr = GetFaceAdj( Proc, tFData.nFacInd, tFData.dH, tFData.dV)
local nFacAdj, sErr = GetFaceAdj( Proc, tFData)
if nFacAdj < 0 then
EgtOutLog( sErr)
return false, sErr
@@ -2465,13 +2456,13 @@ local function ExtractExternalPaths( nPathInt, nNumIdAux, vtOrtho)
end
---------------------------------------------------------------------
local function MakeChamfer( Proc, bIs3Faces, vtOrtho, nSurfInt)
local function MakeChamfer( Proc, vtOrtho, nSurfInt)
-- Se variabile globale indica che lo smusso è già stato fatto, esco
if _bMadeChamfer then
return 0
end
_bMadeChamfer = true
local bIs3Faces = Proc.Fct == 3
-- recupero la lavorazione
local sMilling = ML.FindMilling( 'Mark')
if not sMilling then
@@ -2711,7 +2702,8 @@ local function MakeByMillAsSaw( Proc, tFData, nBottomFace, sMillingOnSide, dSawD
end
---------------------------------------------------------------------
local function DoHeadChainSaw( Proc, sName, sSawing, tFData, nFacAdj, vtNE, vtNS, dSawWidth, dSawThick, dDistToNextPiece, dMaxDepth, bOpenStart, bOpenEnd)
local function DoHeadChainSaw( Proc, sName, sSawing, tFData, nFacAdj, vtNE, vtNS, dSawWidth,
dSawThick, dDistToNextPiece, dMaxDepth, bOpenStart, bOpenEnd)
-- Calcolo uso faccia
local nFaceUse = BL.GetNearestParalOpposite( tFData.rfFac:getVersZ())
-- Calcolo normale faccia adiacente
@@ -2724,10 +2716,10 @@ local function DoHeadChainSaw( Proc, sName, sSawing, tFData, nFacAdj, vtNE, vtNS
end
for i = 1, nStep do
-- Applico la lavorazione con sega a catena a questa faccia
local sLoopName = sName .. '_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( i)
local nMchFId = EgtAddMachining( sLoopName, sSawing)
local sStepName = sName .. '_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( i)
local nMchFId = EgtAddMachining( sStepName, sSawing)
if not nMchFId then
local sErr = 'Error adding machining ' .. sLoopName .. '-' .. sSawing
local sErr = 'Error adding machining ' .. sStepName .. '-' .. sSawing
EgtOutLog( sErr)
return false, sErr
end
@@ -2801,7 +2793,8 @@ local function DoHeadChainSaw( Proc, sName, sSawing, tFData, nFacAdj, vtNE, vtNS
end
---------------------------------------------------------------------
local function DoSideChainSaw(Proc, sName, sSawing2, tFData, vtN, vtOrtho, dDimMin, dSawThick2, dMaxMat2, bOpenStart, bOpenEnd)
local function DoSideChainSaw( Proc, sName, sSawing2, tFData, vtN, vtOrtho,
dDimMin, dSawThick2, dMaxMat2, bOpenStart, bOpenEnd)
-- Verifico se necessarie più passate
local nStep = ceil( ( dDimMin - 10 * GEO.EPS_SMALL) / dSawThick2)
local dStep = 0
@@ -2810,10 +2803,10 @@ local function DoSideChainSaw(Proc, sName, sSawing2, tFData, vtN, vtOrtho, dDimM
end
for i = 1, nStep do
-- inserisco la lavorazione di sawing
local sLoopName = sName .. '_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( i)
local nMchFId = EgtAddMachining( sLoopName, sSawing2)
local sStepName = sName .. '_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( i)
local nMchFId = EgtAddMachining( sStepName, sSawing2)
if not nMchFId then
local sErr = 'Error adding machining ' .. sLoopName .. '-' .. sSawing2
local sErr = 'Error adding machining ' .. sStepName .. '-' .. sSawing2
EgtOutLog( sErr)
return false, sErr
end
@@ -2904,10 +2897,9 @@ local function DoSideChainSaw(Proc, sName, sSawing2, tFData, vtN, vtOrtho, dDimM
end
---------------------------------------------------------------------
local function MakeByChainOrSaw( Proc, tFData,
dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace,
bOrthoFacesMaster, nBottomFace,
nSurfInt, bIs3Faces)
local function MakeByChainOrSaw( Proc, tFData, dDimMin, dDimMax, vtOrtho,
bOrthoFacesMaster, nBottomFace, nSurfInt)
local bIs3Faces = Proc.Fct == 3
local bOrthoFaces
local sWarn
-- ottengo la distanza tra la fine del pezzo e il pezzo successivo
@@ -2930,11 +2922,11 @@ local function MakeByChainOrSaw( Proc, tFData,
if bOrthoFaces then
-- ottengo le dimensioni del tunnel
dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt = GetTunnelDimension( Proc)
dDimMin, dDimMax, _, vtOrtho, _, nSurfInt = GetTunnelDimension( Proc)
-- verifico la direzione
-- se devo inserire il chamfer
if _nChamfer > 0 then
local nOk, sErr = MakeChamfer( Proc, bIs3Faces, vtOrtho, nSurfInt)
local nOk, sErr = MakeChamfer( Proc, vtOrtho, nSurfInt)
if nOk < 0 then return false, sErr end
end
end
@@ -3098,7 +3090,7 @@ local function MakeByChainOrSaw( Proc, tFData,
-- altrimenti segacatena di fianco
else
-- verifico se posso farlo con la sega-catena
local bMakeChainSaw, sSawing2, dMaxMat2, dSawCornerRad2, dSawThick2 = VerifyChainSaw( Proc, dDimMin, dDimMax)
local bMakeChainSaw, sSawing2, dMaxMat2, dSawCornerRad2, dSawThick2 = VerifyChainSaw( dDimMin, dDimMax)
if bMakeChainSaw then
local bOk, sErr = DoSideChainSaw(Proc, sName, sSawing2, tFData, vtN, vtOrtho, dDimMin, dSawThick2, dMaxMat2, bOpenStart, bOpenEnd)
if not bOk then
@@ -3154,7 +3146,7 @@ local function MakeAntiSplintBySaw( Proc, nFacet, vtN, nFacInd, bReduceDepth, bM
if dDepth > dLimitDepth then
dExtraOffs = dLimitDepth - dDepth
else
dExtraOffs = - (dDepth/2)
dExtraOffs = -(dDepth / 2)
end
end
end
@@ -3170,7 +3162,8 @@ local function MakeAntiSplintBySaw( Proc, nFacet, vtN, nFacInd, bReduceDepth, bM
end
---------------------------------------------------------------------
local function MakePocket( Proc, ptPs, tvtN, nFaceRef, sMchFind, nUseRoughTool, sMasterPocket, dPrevFaceElev, tDimAndRef, dAng)
local function MakePocket( Proc, ptPs, tvtN, nFaceRef, sMchFind, nUseRoughTool,
sMasterPocket, dPrevFaceElev, tDimAndRef, dAng)
-- calcolo l'elevazione dal punto medio
local dElev
local dLenIn, dLedOut = BL.GetPointDirDepth( _nPartId, ptPs, tvtN[2])
@@ -3227,7 +3220,7 @@ local function MakePocket( Proc, ptPs, tvtN, nFaceRef, sMchFind, nUseRoughTool,
return false, sErr
end
-- aggiungo geometria
EgtSetMachiningGeometry( {{ Proc.Id, (nFaceRef)}})
EgtSetMachiningGeometry( {{ Proc.Id, nFaceRef}})
-- imposto uso faccia
EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.ORTHO_CONT)
-- imposto posizione braccio porta testa
@@ -3297,7 +3290,7 @@ local function DoHeadCut( Proc, nMchFId, sTuuidPk, dDiamTool, dElev, nSideFace,
-- aggiungo geometria
EgtSetMachiningGeometry( {{ Proc.Id, nSideFace}})
-- imposto uso faccia
local nFaceUse = BL.GetNearestOrthoOpposite(tvtN[1])
local nFaceUse = BL.GetNearestOrthoOpposite( tvtN[1])
-- aggiusto i parametri
EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
EgtSetMachiningParam( MCH_MP.DEPTH_STR, 'TH')
@@ -3529,13 +3522,15 @@ local function DoPocket( sName, sPocketing, sMchFind, vtN, nPathInt, nFaceIdx, d
end
---------------------------------------------------------------------
local function MakeByPockets( Proc, bIs3Faces, bOrthoFacesMaster, bMillDown)
local function MakeByPockets( Proc, bOrthoFacesMaster, bMillDown)
local nFirstMachId
local bOrthoFaces
local sWarn
local sMchFind = 'Pocket'
local dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, nSurfInt
local bBadMach = false
local bBadMach = false
local bIs3Faces = Proc.Fct == 3
if bIs3Faces then
-- recupero la faccia con il maggior numero di adiacenze e l'elevazione relativa
local nFacInd, _, nFacInd2, _ = BL.GetFaceWithMostAdj( Proc.Id, _nPartId, bIs3Faces)
@@ -3559,7 +3554,7 @@ local function MakeByPockets( Proc, bIs3Faces, bOrthoFacesMaster, bMillDown)
local nPathInt
-- se devo inserire il chamfer
if _nChamfer > 0 then
local nOk, sErr = MakeChamfer( Proc, bIs3Faces, vtOrtho, nSurfInt)
local nOk, sErr = MakeChamfer( Proc, vtOrtho, nSurfInt)
if nOk < 0 then return -1, sErr end
end
-- se smusso non è esclusivo
@@ -3567,10 +3562,10 @@ local function MakeByPockets( Proc, bIs3Faces, bOrthoFacesMaster, bMillDown)
-- ricalcolo se è lavorabile da sotto
bMillDown = ( BD.DOWN_HEAD == true)
-- verifico se può essere fatto con svuotatura
local bMakePocket, sPocketing, dMaxDepth, dDiamTool = VerifyPocket( Proc, dDimMin, dDepth / 2, nil, sMchFind)
local bMakePocket, sPocketing, dMaxDepth, dDiamTool = VerifyPocket( dDimMin, dDepth / 2, nil, sMchFind)
local bMakePocketDn, sPocketingDn, dMaxDepthDn
if bMillDown then
bMakePocketDn, sPocketingDn, dMaxDepthDn = VerifyPocket( Proc, dDimMin, dDepth / 2, nil, sMchFind..'_H2')
bMakePocketDn, sPocketingDn, dMaxDepthDn = VerifyPocket( dDimMin, dDepth / 2, nil, sMchFind .. '_H2')
-- se è negativo inverto il versore e la faccia
if vtOrtho:getZ() < 0 then
vtOrtho = -vtOrtho
@@ -3879,7 +3874,6 @@ local function MakeAntiSplintByMill( Proc, pPaths, nPathInt, vtN1,
-- assegno lavorazioni ad ogni percorso
for i = 1, #pPaths do
local nIdPath = pPaths[i][1]
local nSide = pPaths[i][2]
-- modifico versore direzione
@@ -4016,7 +4010,6 @@ end
local function ManageAntiSplintByMill( Proc, nFacInd, bMillDown, bDoubleSide,
vtOrtho, nPathInt, nSurfInt, dDepth,
bOneShot, nFirstMachId)
local sMyWarn = ''
local pPaths = {}
local nAuxId
@@ -4070,7 +4063,7 @@ local function ManageAntiSplintByMill( Proc, nFacInd, bMillDown, bDoubleSide,
-- se fresatura da sotto salto la lavorazione
if vtN1:getZ() < BD.DRILL_VZ_MIN and not bMillDown then
local sErr = 'Error : milling from bottom '
local sErr = 'Error : milling from bottom'
EgtOutLog( sErr)
return false, sErr
end
@@ -4317,7 +4310,6 @@ local function MakeSpecialThreeFaces( Proc, tFData)
local dCollSic2 = 2 * BD.COLL_SIC
if abs( tFData.vtN:getX()) > 0.7 or abs( tFData.vtN:getY()) > 0.7 or abs( tFData.vtN:getZ()) > 0.7 then dCollSic = 0 end
if abs( tFData.vtN2:getX()) > 0.7 or abs( tFData.vtN2:getY()) > 0.7 or abs( tFData.vtN2:getZ()) > 0.7 then dCollSic2 = 0 end
local sPocketing = ML.FindPocketing( sMchFind, dDiam2, tFData.dFacElev2 + dCollSic2)
local nPockFace = tFData.nFacInd2
-- se non trova una svuotatura adatta provo ad assegnarla all'altra faccia
@@ -4403,7 +4395,7 @@ end
---------------------------------------------------------------------
local function MakeByChainsaw( Proc, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace)
-- verifico se posso farlo con la sega-catena
local bMakeChainSaw, sSawing, dMaxMat, dSawCornerRad, dSawThick = VerifyChainSaw( Proc, dDimMin, dDimMax)
local bMakeChainSaw, sSawing, dMaxMat, dSawCornerRad, dSawThick = VerifyChainSaw( dDimMin, dDimMax)
if bMakeChainSaw then
-- Verifico se necessarie più passate
@@ -4479,7 +4471,7 @@ local function MakeSidePocketings( Proc, tFData, dCollSic, bSpecialMillOnSide,
nBottomFace, sMillingOnSide, dToolDiamOnSide, dThickMillOnSide,
bSinglePart, bIsU, bIsL, dDiam, bMillDown, bMillUp, sMchFind, sMchFindBackUp)
local bTryWithBlades = true
local nOk, bOk, sStat, sErr, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, bOrthoFaces, nSurfInt
local nOk, bOk, sStat, sErr, dDimMin, dDimMax, dDepth, vtOrtho, bOrthoFaces, nSurfInt
if bSpecialMillOnSide then
-- eseguo
bOk, sWarn = MakeByMillAsSaw( Proc, tFData, nBottomFace, sMillingOnSide, dToolDiamOnSide, dThickMillOnSide)
@@ -4496,17 +4488,15 @@ local function MakeSidePocketings( Proc, tFData, dCollSic, bSpecialMillOnSide,
tFData = SwapFacetsData( tFData)
end
-- eseguo (come 3 faces)
bOk, sWarn, sStat = MakeByChainOrSaw( Proc, tFData,
dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace,
bOrthoFaces, nBottomFace, nSurfInt, true)
bOk, sWarn, sStat = MakeByChainOrSaw( Proc, tFData, dDimMin, dDimMax, vtOrtho,
bOrthoFaces, nBottomFace, nSurfInt)
if not bOk then
-- 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 Proc.Fct == 3 and bIsU then
-- lavoro con svuotature (singola o doppia contrapposta)
nOk, sErr, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, _, _, _, _, _, _, _,
bOrthoFaces = MakeByPockets( Proc, true, nil, bMillDown)
nOk, sErr, dDimMin, dDimMax, dDepth, vtOrtho, _, _, _, _, _, _, _, _, bOrthoFaces = MakeByPockets( Proc, nil, bMillDown)
-- se lavorazione non idonee (asse della feature troppo inclinato e impossibile lavorare completamente da due parti)
if nOk == -2 then
if not sMchFind then
@@ -4551,7 +4541,7 @@ local function MakeSidePocketings( Proc, tFData, dCollSic, bSpecialMillOnSide,
if ( ( Proc.Fct == 3 and bIsU) or (Proc.Fct == 2 and bIsL)) and _nChamfer > 0 then
-- ottengo le dimensioni dello pseudotunnel
local _, _, _, vtOrtho, _, nSurfInt = GetTunnelDimension( Proc)
local nOk, sErr = MakeChamfer( Proc, true, vtOrtho, nSurfInt)
local nOk, sErr = MakeChamfer( Proc, vtOrtho, nSurfInt)
if nOk < 0 then return 1, false, sErr end
end
bOk = true
@@ -4580,7 +4570,7 @@ local function MakeSidePocketings( Proc, tFData, dCollSic, bSpecialMillOnSide,
local dDiamTool = 100
local nPathInt, nSurfInt, bOneShot, nFirstMachId, bDoubleSide
nOk, sErr, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace, dDiamTool,
bDoubleSide, nPathInt, nSurfInt, bOneShot, bMillDown, nFirstMachId, bOrthoFaces = MakeByPockets( Proc, true, nil, bMillDown)
bDoubleSide, nPathInt, nSurfInt, bOneShot, bMillDown, nFirstMachId, bOrthoFaces = MakeByPockets( Proc, nil, bMillDown)
if nOk == -2 then
if not sMchFind then
sMchFind = sMchFindBackUp
@@ -4608,8 +4598,7 @@ local function MakeSidePocketings( Proc, tFData, dCollSic, bSpecialMillOnSide,
-- se abilitato dal parametro Q inserisco pulitura spigoli o contorno con fresa più piccola
if Q_CONTOUR_SMALL_TOOL > 0 then
local bOk, sWarn2 = MakeRoundCleanCornerOrContour( Proc, tFData.nFacInd, dDiamTool, Q_CONTOUR_SMALL_TOOL, bMillDown,
bDoubleSide, vtOrtho, nPathInt, nSurfInt,
dDepth, bOneShotm)
bDoubleSide, vtOrtho, nPathInt, nSurfInt, dDepth, bOneShotm)
if not bOk then return 1, false, sWarn2 end
sWarn = FormatWarning( sWarn, sWarn2)
end
@@ -4628,10 +4617,9 @@ local function MakeSidePocketings( Proc, tFData, dCollSic, bSpecialMillOnSide,
tFData = SwapFacetsData( tFData)
end
-- eseguo (non 3 faces)
bOk, sWarn, sStat = MakeByChainOrSaw( Proc, tFData, dDimMin, dDimMax, dDepth, vtOrtho,
nLundIdFace, bOrthoFaces, nBottomFace, nSurfInt)
bOk, sWarn, sStat = MakeByChainOrSaw( Proc, tFData, dDimMin, dDimMax, vtOrtho, bOrthoFaces, nBottomFace, nSurfInt)
if not bOk and sStat == 'MNF' then
_, sPocketing = VerifyPocket( Proc, dDiam, tFData.dFacElev + dCollSic, nil, sMchFind)
_, sPocketing = VerifyPocket( dDiam, tFData.dFacElev + dCollSic, nil, sMchFind)
if sPocketing then
sWarn = ''
else
@@ -4688,7 +4676,7 @@ local function MakePocketingOrMilling( Proc, tFData, bSinglePart)
-- altrimenti cerco la faccia secondaria per adiacenza alla principale
else
-- Cerco una faccia adiacente alla principale sul lato lungo
local nFacAdj, sErr = GetFaceAdj( Proc, tFData.nFacInd, tFData.dH, tFData.dV)
local nFacAdj, sErr = GetFaceAdj( Proc, tFData)
if nFacAdj < 0 then
EgtOutLog( sErr)
return false, sErr
@@ -4765,9 +4753,9 @@ local function MakePocketingOrMilling( Proc, tFData, bSinglePart)
end
-- ricerca lavorazione
local sPocketing
local _, sMyPocketing, dMyTMaxDepth, _ = VerifyPocket( Proc, dDiam, tFData.dFacElev + dCollSic, dMaxTotLen, sMchFind .. EgtIf( bMillDown, '_H2', ''))
local _, sMyPocketing, dMyTMaxDepth, _ = VerifyPocket( dDiam, tFData.dFacElev + dCollSic, dMaxTotLen, sMchFind .. EgtIf( bMillDown, '_H2', ''))
if not sMyPocketing and bMillUp then
_, sMyPocketing, dMyTMaxDepth, _ = VerifyPocket( Proc, dDiam, tFData.dFacElev + dCollSic, dMaxTotLen, sMchFind)
_, sMyPocketing, dMyTMaxDepth, _ = VerifyPocket( dDiam, tFData.dFacElev + dCollSic, dMaxTotLen, sMchFind)
bMillDown = false
end
--local sMyPocketing, dMyTDiam, dMyTMaxDepth = ML.FindPocketing( sMchFind .. EgtIf( bMillDown, '_H2', ''), dDiam, dFacElev + dCollSic, dMaxTotLen)
@@ -4881,8 +4869,8 @@ local function MakePocketingOrMilling( Proc, tFData, bSinglePart)
end
-- altrimenti, in base alla forma, provo con svuotature di fianco o con la sega a catena o lama
else
local stat, bOk, sWarn = MakeSidePocketings( Proc, tFData, dCollSic, bSpecialMillOnSide,
nBottomFace, sMillingOnSide, dToolDiamOnSide, dThickMillOnSide, bSinglePart,
local stat, bOk, sWarn = MakeSidePocketings( Proc, tFData, dCollSic, bSpecialMillOnSide, nBottomFace,
sMillingOnSide, dToolDiamOnSide, dThickMillOnSide, bSinglePart,
bIsU, bIsL, dDiam, bMillDown, bMillUp, sMchFind, sMchFindBackUp)
if stat == 1 then
return bOk, sWarn
@@ -4890,10 +4878,10 @@ local function MakePocketingOrMilling( Proc, tFData, bSinglePart)
end
else
-- se devo inserire il chamfer
if ( ( Proc.Fct == 3 and bIsU) or (Proc.Fct == 2 and bIsL)) and _nChamfer > 0 then
if (( Proc.Fct == 3 and bIsU) or (Proc.Fct == 2 and bIsL)) and _nChamfer > 0 then
-- ottengo le dimensioni dello pseudotunnel
local _, _, _, vtOrtho, _, nSurfInt = GetTunnelDimension( Proc)
local nOk, sErr = MakeChamfer( Proc, true, vtOrtho, nSurfInt)
local nOk, sErr = MakeChamfer( Proc, vtOrtho, nSurfInt)
if nOk < 0 then return false, sErr end
end
end
@@ -4929,7 +4917,7 @@ local function MakePocketingOrMilling( Proc, tFData, bSinglePart)
-- 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
if ( ( Proc.Fct > 3 and not bIsU) or ( Proc.Fct == 3 and bIsU)) and not bMadeASbyBld then
if (( Proc.Fct > 3 and not bIsU) or ( Proc.Fct == 3 and bIsU)) and not bMadeASbyBld then
-- Recupero le facce adiacenti alla principale (solo quelle esistenti)
local vAdj = GetValidFacetAdjacencies( Proc.Id, tFData.nFacInd)
if not vAdj or #vAdj == 0 then
@@ -4950,7 +4938,7 @@ local function MakePocketingOrMilling( Proc, tFData, bSinglePart)
tDimAndRef[2] = { dH2, dV2, rfFac2}
local ptPs = ( ptP1 + ptP2) / 2
local bOk, sWarn2 = MachineByMill( Proc, tvtNx, tFData.nFacInd, vAdj[i], ptPs, tDimAndRef,
EgtIf( ( Proc.Fct == 3 and bIsU), 0, 2), nUseRoughTool, dAng, sPocketing, sTuuidPk, tFData.dFacElev)
EgtIf( Proc.Fct == 3 and bIsU, 0, 2), nUseRoughTool, dAng, sPocketing, sTuuidPk, tFData.dFacElev)
if not bOk then return bOk, sWarn2 end
sWarn = FormatWarning( sWarn, sWarn2)
end
@@ -5034,7 +5022,7 @@ local function MakeThreeFaces( Proc, bSinglePart, bPrevBhSideMill)
if bPrevBhSideMill == nil then
bPrevBhSideMill = bMakeBySideMill
end
--if bMakeBySideMill and ( dMaxMat <= dV + 15 * GEO.EPS_SMALL) then
--if bMakeBySideMill and ( dMaxMat <= tFData.dV + 15 * GEO.EPS_SMALL) then
if bMakeBySideMill and ( dMaxMat <= tFData.dH + 15 * GEO.EPS_SMALL) then
-- se smusso non è esclusivo
if _nChamfer < 2 then
@@ -5070,7 +5058,6 @@ end
---------------------------------------------------------------------
local function MakeMoreFaces( Proc, bSinglePart, bPrevBhSideMill)
local bClosedOrthoFaces
local nBottomFace
-- recupero la faccia con il maggior numero di adiacenze e l'elevazione relativa
local tFData = GetFacetsData( Proc.Id)
if not tFData.nFacInd or tFData.nFacInd < 0 then
@@ -5084,6 +5071,7 @@ local function MakeMoreFaces( Proc, bSinglePart, bPrevBhSideMill)
end
-- se è una feature scanalatura (con 5 facce) e non è stata riconosciuta come fessura, eseguo altre verifiche
if Proc.Prc == 16 and Proc.Fct == 5 and not bClosedOrthoFaces then
local nBottomFace
-- dalla copia della superfice, ciclo eliminando una faccia per volta per verificare se trova fessura
for i = 1, Proc.Fct do
local nNewProcId = EgtCopyGlob( Proc.Id, _nAddGrpId) or GDB_ID.NULL
@@ -5128,7 +5116,7 @@ local function MakeMoreFaces( Proc, bSinglePart, bPrevBhSideMill)
if bClosedOrthoFaces then
local bTryWithBlades = true
-- lavoro fessura con svuotature (singola o doppia contrapposta)
local nOk, sErr, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace = MakeByPockets( Proc, false, bClosedOrthoFaces)
local nOk, sErr, dDimMin, dDimMax, dDepth, vtOrtho, nLundIdFace = MakeByPockets( Proc, bClosedOrthoFaces)
if nOk < 0 then
return false, sErr
elseif nOk > 0 then
@@ -5153,7 +5141,6 @@ end
---------------------------------------------------------------------
local function MakeLongFaces( Proc, Func)
-- divido in parti lungo la X
local vAddId = {}
local nPart = max( ceil( Proc.Box:getDimX() / BD.LONGCUT_MAXLEN), 2)
@@ -5338,7 +5325,7 @@ function ProcessLapJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
local _, bIsL = TestUL( Proc)
if bIsL and _nChamfer > 0 then
local _, _, _, vtOrtho, _, nSurfInt = GetTunnelDimension( Proc)
local nOk, sErr = MakeChamfer( Proc, true, vtOrtho, _b3Solid, nSurfInt)
local nOk, sErr = MakeChamfer( Proc, vtOrtho, _b3Solid, nSurfInt)
if nOk < 0 then return false, sErr end
end
return Fbs.MakeTwo( Proc, _nPhase, _nRawId, _nPartId, _dOvmHead, 'HeadSide' .. EgtIf( bDownHead, '_H2', ''), true, bDownHead)
@@ -5355,4 +5342,4 @@ function ProcessLapJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
end
---------------------------------------------------------------------
return ProcessLapJoint
return ProcessLapJoint