Dario Sassi
1537 lines
66 KiB
Lua
1537 lines
66 KiB
Lua
-- WProcessLapJoint.lua by Egaltech s.r.l. 2021/01/20
|
|
-- Gestione calcolo mezzo-legno per Pareti
|
|
|
|
-- Tabella per definizione modulo
|
|
local WPL = {}
|
|
|
|
-- Include
|
|
require( 'EgtBase')
|
|
local WL = require( 'WallLib')
|
|
local FreeContour = require( 'WProcessFreeContour')
|
|
|
|
EgtOutLog( ' WProcessLapJoint started', 1)
|
|
|
|
-- Dati
|
|
local WD = require( 'WallData')
|
|
local WM = require( 'WMachiningLib')
|
|
local WHISK_OFFS = 0.1
|
|
local WHISK_SAFE = 5
|
|
local MIN_LEN_CUT = 30
|
|
|
|
-- variabili assegnazione parametri Q
|
|
local sTypeCornerCut = 'Q05' -- i
|
|
-- variabile settaggio doppia lavorazione su angoo > 90
|
|
local bMakeTwinCut = true
|
|
-- angolo sottosquadra ammesso per fresa cono 30°
|
|
local dAngleSmall = 70
|
|
|
|
---------------------------------------------------------------------
|
|
-- Riconoscimento della feature
|
|
function WPL.Identify( Proc)
|
|
return ( ( Proc.Grp == 3 or Proc.Grp == 4) and Proc.Prc == 16) or
|
|
( ( Proc.Grp == 3 or Proc.Grp == 4) and Proc.Prc == 17) or
|
|
( ( Proc.Grp == 3 or Proc.Grp == 4) and Proc.Prc == 20) or
|
|
( ( Proc.Grp == 3 or Proc.Grp == 4) and Proc.Prc == 30) or
|
|
( ( Proc.Grp == 3 or Proc.Grp == 4) and Proc.Prc == 32) or
|
|
( ( Proc.Grp == 3 or Proc.Grp == 4) and Proc.Prc == 34) or
|
|
( ( Proc.Grp == 4) and Proc.Prc == 39)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- Classificazione della feature
|
|
function WPL.Classify( Proc, b3Raw)
|
|
-- se 1 faccia
|
|
if Proc.Fct == 1 then
|
|
-- dati della faccia
|
|
local vtN = EgtSurfTmFacetNormVersor( Proc.Id, 0, GDB_ID.ROOT)
|
|
-- verifico se è lavorabile da sopra
|
|
return vtN:getZ() >= WD.NZ_MINA
|
|
-- se 2 facce
|
|
elseif Proc.Fct == 2 then
|
|
-- dati delle facce
|
|
local vtN = {}
|
|
vtN[1] = EgtSurfTmFacetNormVersor( Proc.Id, 0, GDB_ID.ROOT)
|
|
vtN[2] = EgtSurfTmFacetNormVersor( Proc.Id, 1, GDB_ID.ROOT)
|
|
-- verifico se è lavorabile da sopra o di fianco
|
|
return ( vtN[1]:getZ() >= - 0.01 or vtN[2]:getZ() >= - 0.01)
|
|
-- se più di 2 facce
|
|
else
|
|
local nFacInd, dElev, nFacInd2, dElev2 = WL.GetFaceWithMostAdj( Proc.Id, Proc.PartId)
|
|
-- se trovata faccia di fondo
|
|
if nFacInd >= 0 then
|
|
-- determino componente Z della normale più diretta verso il basso
|
|
local dMinNz = 1
|
|
for i = 1, Proc.Fct do
|
|
local vtN = EgtSurfTmFacetNormVersor( Proc.Id, i - 1, GDB_ID.ROOT)
|
|
if vtN:getZ() < dMinNz then
|
|
dMinNz = vtN:getZ()
|
|
end
|
|
end
|
|
-- dati della faccia
|
|
local vtN = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT)
|
|
local _, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd, GDB_ID.ROOT)
|
|
-- verifico se la faccia è lavorabile da sopra o di fianco
|
|
if ( vtN:getZ() >= WD.NZ_MINA or ( dMinNz < -0.866 and Proc.Fct >= 3 and vtN:getZ() > - 0.01)) then
|
|
Proc.Stype = 1
|
|
return true
|
|
-- altrimenti verifico la eventuale seconda faccia
|
|
elseif nFacInd2 then
|
|
-- dati della faccia
|
|
local vtN2 = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd2, GDB_ID.ROOT)
|
|
local _, dH2, dV2 = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd2, GDB_ID.ROOT)
|
|
-- restituisco se faccia lavorabile
|
|
Proc.Stype = 2
|
|
return ( vtN2:getZ() >= WD.NZ_MINA or ( dMinNz < -0.866 and Proc.Fct >= 3 and vtN2:getZ() > - 0.01))
|
|
-- se tre facce
|
|
elseif Proc.Fct == 3 then
|
|
-- verifico se U da sopra
|
|
-- dati della faccia
|
|
local nFac2 = EgtIf( nFacInd == 0, 1, 0)
|
|
local vtN2 = EgtSurfTmFacetNormVersor( Proc.Id, nFac2, GDB_ID.ROOT)
|
|
Proc.Stype = 3
|
|
return ( abs( ( vtN ^ vtN2) * Z_AX()) >= WD.NZ_MINA)
|
|
-- altrimenti non lavorabile
|
|
else
|
|
return false
|
|
end
|
|
-- se altrimenti tunnel
|
|
elseif nFacInd == -1 then
|
|
-- dati delle prime tre facce
|
|
local vtN = {}
|
|
vtN[1] = EgtSurfTmFacetNormVersor( Proc.Id, 0, GDB_ID.ROOT)
|
|
vtN[2] = EgtSurfTmFacetNormVersor( Proc.Id, 1, GDB_ID.ROOT)
|
|
vtN[3] = EgtSurfTmFacetNormVersor( Proc.Id, 2, GDB_ID.ROOT)
|
|
-- verifico se è lavorabile da sopra
|
|
local vtAxN = vtN[1] ^ vtN[2]
|
|
if vtAxN:isSmall() then vtAxN = vtN[1] ^ vtN[3] end
|
|
Proc.Stype = 4
|
|
return ( abs( vtAxN:getZ()) >= WD.NZ_MINA)
|
|
-- altrimenti non lavorabile
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function TestElleShape3( nIdGeom, nNumFacet)
|
|
-- valida solo nel caso di tre facce
|
|
if nNumFacet ~= 3 then return false end
|
|
-- determino se L con una faccia terminale o U con tre facce
|
|
local bIsL = true
|
|
for i = 1, 3 do
|
|
local vFacAdj = EgtSurfTmFacetAdjacencies( nIdGeom, i - 1)[1]
|
|
-- le conto
|
|
local nCount = 0
|
|
for j = 1, #vFacAdj do
|
|
if vFacAdj[j] >= 0 then
|
|
nCount = nCount + 1
|
|
end
|
|
end
|
|
if nCount == 1 then
|
|
bIsL = false
|
|
break
|
|
end
|
|
end
|
|
return bIsL
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function TestElleShape4( nIdGeom, nNumFacet)
|
|
-- valida solo nel caso di quattro facce
|
|
if nNumFacet ~= 4 then return false end
|
|
-- determino se L con due facce terminali o O
|
|
local nFac3Adj = 0
|
|
local dMinArea3 = GEO.INFINITO * GEO.INFINITO
|
|
local dMaxArea2 = 0
|
|
for i = 1, 4 do
|
|
local vFacAdj = EgtSurfTmFacetAdjacencies( nIdGeom, i - 1)[1]
|
|
-- le conto
|
|
local nCount = 0
|
|
for j = 1, #vFacAdj do
|
|
if vFacAdj[j] >= 0 then
|
|
nCount = nCount + 1
|
|
end
|
|
end
|
|
local _, dH, dV = EgtSurfTmFacetMinAreaRectangle( nIdGeom, i - 1, GDB_ID.ROOT)
|
|
local dArea = dH * dV
|
|
if nCount == 2 then
|
|
dMaxArea2 = max( dMaxArea2, dArea)
|
|
elseif nCount == 3 then
|
|
dMinArea3 = min( dMinArea3, dArea)
|
|
nFac3Adj = nFac3Adj + 1
|
|
end
|
|
end
|
|
if nFac3Adj ~= 2 then return false end
|
|
-- verifico se L profonda oppure lunga
|
|
if dMinArea3 < dMaxArea2 then
|
|
return 1
|
|
else
|
|
return 2
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function VerifyCornerType( Proc)
|
|
|
|
local nConeCut = 0
|
|
-- verifico il tipo di lavorazione su angolo. 0 : nessuna ripresa corner; 1: ripresa corner con pausa;
|
|
-- 2: ripresa corner senza pausa; 3: scarico corner
|
|
local nParamValue = EgtGetInfo( Proc.Id, sTypeCornerCut, 'i') or nConeCut
|
|
-- se tipo di lavorazione con fesa conica 60° con pausa
|
|
nConeCut = nParamValue
|
|
return nConeCut
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function GetOtherRegions( nPartId)
|
|
local vOthers = {}
|
|
local nOtherId = EgtGetFirstPartInRawPart( EgtGetFirstRawPart() or GDB_ID.NULL)
|
|
while nOtherId do
|
|
local nRegId = EgtGetFirstInGroup( EgtGetFirstNameInGroup( nOtherId, 'Outline') or GDB_ID.NULL)
|
|
while nRegId do
|
|
local vtN = EgtSurfFrNormVersor( nRegId, GDB_ID.ROOT)
|
|
if EgtExistsInfo( nRegId, 'REGION') and vtN and AreSameVectorApprox( vtN, Z_AX()) then
|
|
local b3Reg = EgtGetBBoxGlob( nRegId, GDB_BB.STANDARD)
|
|
if b3Reg then
|
|
table.insert( vOthers, { PartId = nOtherId, RegId = nRegId, Box = b3Reg})
|
|
end
|
|
end
|
|
nRegId = EgtGetNext( nRegId)
|
|
end
|
|
nOtherId = EgtGetNextPartInRawPart( nOtherId)
|
|
end
|
|
return vOthers
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function ReorderFaces( nIdSurf, nNumFacet)
|
|
local vAdj = {}
|
|
for i = 1, nNumFacet do
|
|
local vFacAdj = EgtSurfTmFacetAdjacencies( nIdSurf, i - 1)[1]
|
|
-- le conto
|
|
local nCount = 0
|
|
for j = 1, #vFacAdj do
|
|
if vFacAdj[j] >= 0 then
|
|
nCount = nCount + 1
|
|
end
|
|
end
|
|
vAdj[i] = nCount
|
|
end
|
|
local nIdFace
|
|
local nAdjMin = 1000
|
|
for i = #vAdj, 1, -1 do
|
|
if vAdj[i] <= nAdjMin then
|
|
nAdjMin = vAdj[i]
|
|
nIdFace = i
|
|
end
|
|
end
|
|
-- se il numero faccia minore con minori adiacenze è <> 1 faccio lo scambio
|
|
if nIdFace and nIdFace ~= 1 then
|
|
EgtSurfTmSwapFacets( nIdSurf, nIdFace-1, 0)
|
|
end
|
|
-- ordino il numero di facce in modo da avere una sequenza di facce concatenate
|
|
for i = 1, (nNumFacet-1) do
|
|
-- recupero l'angolo con la faccia precedente
|
|
local bAdj, _, _, _ = EgtSurfTmFacetsContact( nIdSurf, i-1, i, GDB_ID.ROOT)
|
|
-- se non ho adiacenza
|
|
if not bAdj then
|
|
for j = i+1, nNumFacet do
|
|
bAdj, _, _, _ = EgtSurfTmFacetsContact( nIdSurf, i-1, j-1, GDB_ID.ROOT)
|
|
-- se ho adiacenza scambio le facce
|
|
if bAdj then
|
|
EgtSurfTmSwapFacets( nIdSurf, i, (j-1))
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return nIdSurf
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function RemoveBottomFaceAndReorder( Proc, nAddGrpId, nFaceToDel)
|
|
|
|
-- copio la superfice nel gruppo ausiliario
|
|
local nNewProc = EgtCopyGlob( Proc.Id, nAddGrpId) or GDB_ID.NULL
|
|
EgtSurfTmRemoveFacet( nNewProc, nFaceToDel)
|
|
local nNumFacet = EgtSurfTmFacetCount( nNewProc)
|
|
nNewProc = ReorderFaces( nNewProc, nNumFacet)
|
|
--[[
|
|
-- ordino il numero di facce in modo da avere una sequenza di facce concatenate
|
|
for i = 1, (nNumFacet-1) do
|
|
-- recupero l'angolo con la faccia precedente
|
|
local bAdj, _, _, _ = EgtSurfTmFacetsContact( nNewProc, i-1, i, GDB_ID.ROOT)
|
|
-- se non ho adiacenza
|
|
if not bAdj then
|
|
for j = i+1, nNumFacet do
|
|
bAdj, _, _, _ = EgtSurfTmFacetsContact( nNewProc, i-1, j-1, GDB_ID.ROOT)
|
|
-- se ho adiacenza scambio le facce
|
|
if bAdj then
|
|
EgtSurfTmSwapFacets( nNewProc, i, (j-1))
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
]]--
|
|
return nNewProc, nNumFacet
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function GetFacesData( nNewProc, bOpposite, bCalclForBlade, dToolDiam, dToolMaxDepth, dToolThick, nAddGrpId, nPartId)
|
|
|
|
local nNumFacet = EgtSurfTmFacetCount( nNewProc)
|
|
local vFace = {}
|
|
-- recupero i dati di tutte le facce
|
|
for i = 1, nNumFacet do
|
|
-- indice faccia corrente e precedente
|
|
local nFac = EgtIf( bOpposite, nNumFacet - i, i - 1)
|
|
local nPrecFac
|
|
if bOpposite then
|
|
nPrecFac = EgtIf( i == 1, 0, nFac + 1)
|
|
else
|
|
nPrecFac = EgtIf( i == 1, nNumFacet - 1, i - 2)
|
|
end
|
|
-- recupero centro e normale della faccia
|
|
local ptCen, vtN = EgtSurfTmFacetCenter( nNewProc, nFac, GDB_ID.ROOT)
|
|
-- recupero le dimensioni della faccia
|
|
local _, dLen, dWidth = WL.GetFaceHvRefDim( nNewProc, nFac)
|
|
-- recupero l'angolo con la faccia precedente
|
|
local bAdj, _, _, dAng = EgtSurfTmFacetsContact( nNewProc, nPrecFac, nFac, GDB_ID.ROOT)
|
|
-- salvo i dati
|
|
vFace[i] = { Fac = nFac, Cen = ptCen, Norm = vtN, Len = dLen, Width = dWidth, AngPrev = EgtIf( bAdj, dAng, 0)}
|
|
if bAdj then
|
|
if ptLocP1:getZ() < ptLocP2:getZ() then
|
|
vFace[i].PPrev = ptLocP1
|
|
else
|
|
vFace[i].PPrev = ptLocP2
|
|
end
|
|
end
|
|
end
|
|
-- analizzo le facce
|
|
local dMaxWidth = 0
|
|
for i = 1, #vFace do
|
|
-- aggiorno la massima larghezza
|
|
if vFace[i].Width > dMaxWidth then
|
|
dMaxWidth = vFace[i].Width
|
|
end
|
|
-- verifico l'affondamento
|
|
local dDepth = WD.CUT_EXTRA
|
|
if vFace[i].Width + WD.CUT_EXTRA > dToolMaxDepth then
|
|
dDepth = dToolMaxDepth - vFace[i].Width
|
|
end
|
|
-- lunghezza baffo
|
|
local dElev = vFace[i].Width + dDepth
|
|
local dWhisk = EgtIf( bCalclForBlade, ( dElev * sqrt( dToolDiam / dElev - 1) + WHISK_SAFE) , (dToolDiam/2) + WHISK_SAFE)
|
|
-- determino la lunghezza del taglio passante e il tipo di attacco e uscita
|
|
local dLen = vFace[i].Len
|
|
local nType = 0
|
|
if vFace[i].AngPrev < -0.1 then
|
|
dLen = dLen - EgtIf( bCalclForBlade, dWhisk, 0)
|
|
nType = nType + 1
|
|
end
|
|
if vFace[EgtIf( i < nNumFacet, i + 1, 1)].AngPrev < -0.1 then
|
|
dLen = dLen - EgtIf( bCalclForBlade, dWhisk, 0)
|
|
nType = nType + 2
|
|
end
|
|
-- se lunghezza non significativa, non va inserito il taglio
|
|
if dLen < MIN_LEN_CUT then
|
|
nType = 4
|
|
end
|
|
vFace[i].Depth = dDepth
|
|
vFace[i].Whisk = dWhisk
|
|
vFace[i].Type = nType
|
|
end
|
|
-- recupero le regioni degli altri pezzi
|
|
local vOthers = GetOtherRegions( nPartId)
|
|
-- verifico i baffi sporgenti dei tagli rispetto alle altre regioni
|
|
for i = 1, #vFace do
|
|
-- verifico il baffo iniziale
|
|
if vFace[i].Type ~= 4 and ( vFace[i].Type & 1) == 0 then
|
|
-- creo il rettangolo del baffo
|
|
local vtOrt = Vector3d( vFace[i].Norm:getX(), vFace[i].Norm:getY(), 0) ; vtOrt:normalize()
|
|
local vtDir = Vector3d( vtOrt) ; vtDir:rotate( Z_AX(), -90)
|
|
local vtUp = Vector3d( vtDir) ; vtUp:rotate( vFace[i].Norm, -90)
|
|
local ptIni = vFace[i].Cen + vFace[i].Width / 2 * vtUp + ( vFace[i].Len / 2 + WHISK_OFFS) * vtDir + WHISK_OFFS * vtOrt
|
|
local ptDir = ptIni + ( vFace[i].Whisk - WHISK_OFFS) * vtDir
|
|
local ptCross = ptDir + ( dToolThick - WHISK_OFFS) * vtOrt
|
|
local WhId = EgtSurfFrRectangle3P( nAddGrpId, ptIni, ptCross, ptDir, GDB_RT.GLOB)
|
|
local b3Wh = EgtGetBBoxGlob( WhId or GDB_ID.NULL, GDB_BB.STANDARD)
|
|
-- verifico se interferisce con gli altri pezzi
|
|
for j = 1, #vOthers do
|
|
if OverlapsXY( b3Wh, vOthers[j].Box) then
|
|
local nClass = EgtSurfFrChunkSimpleClassify( WhId, 0, vOthers[j].RegId, 0)
|
|
if nClass ~= GDB_RC.OUT then
|
|
local dLen = vFace[i].Len - vFace[i].Whisk + EgtIf( ( vFace[i].Type & 2) ~= 0, -vFace[i].Whisk, 0)
|
|
if dLen >= MIN_LEN_CUT then
|
|
vFace[i].Type = vFace[i].Type + 1
|
|
else
|
|
vFace[i].Type = 4
|
|
end
|
|
break
|
|
end
|
|
end
|
|
end
|
|
EgtErase( WhId)
|
|
end
|
|
-- verifico il baffo finale
|
|
if vFace[i].Type ~= 4 and ( vFace[i].Type & 2) == 0 then
|
|
-- creo il rettangolo del baffo
|
|
local vtOrt = Vector3d( vFace[i].Norm:getX(), vFace[i].Norm:getY(), 0) ; vtOrt:normalize()
|
|
local vtDir = Vector3d( vtOrt) ; vtDir:rotate( Z_AX(), 90)
|
|
local vtUp = Vector3d( vtDir) ; vtUp:rotate( vFace[i].Norm, 90)
|
|
local ptIni = vFace[i].Cen + vFace[i].Width / 2 * vtUp + ( vFace[i].Len / 2 + WHISK_OFFS) * vtDir + WHISK_OFFS * vtOrt
|
|
local ptDir = ptIni + ( vFace[i].Whisk - WHISK_OFFS) * vtDir
|
|
local ptCross = ptDir + ( dToolThick - WHISK_OFFS) * vtOrt
|
|
local WhId = EgtSurfFrRectangle3P( nAddGrpId, ptIni, ptCross, ptDir, GDB_RT.GLOB)
|
|
local b3Wh = EgtGetBBoxGlob( WhId or GDB_ID.NULL, GDB_BB.STANDARD)
|
|
-- verifico se interferisce con gli altri pezzi
|
|
for j = 1, #vOthers do
|
|
if OverlapsXY( b3Wh, vOthers[j].Box) then
|
|
local nClass = EgtSurfFrChunkSimpleClassify( WhId, 0, vOthers[j].RegId, 0)
|
|
if nClass ~= GDB_RC.OUT then
|
|
local dLen = vFace[i].Len - vFace[i].Whisk + EgtIf( ( vFace[i].Type & 1) ~= 0, -vFace[i].Whisk, 0)
|
|
if dLen >= MIN_LEN_CUT then
|
|
vFace[i].Type = vFace[i].Type + 2
|
|
else
|
|
vFace[i].Type = 4
|
|
end
|
|
break
|
|
end
|
|
end
|
|
end
|
|
EgtErase( WhId)
|
|
end
|
|
end
|
|
-- eventuali stampe
|
|
for i = 1, #vFace do
|
|
local Face = vFace[i]
|
|
local sOut = 'Face '..tostring( Face.Fac)..' C'..tostring( Face.Cen)..' N'..tostring( Face.Norm)..
|
|
' L='..EgtNumToString( Face.Len, 1)..' W='..EgtNumToString( Face.Width, 1)..' Ap='..EgtNumToString( Face.AngPrev, 1)..
|
|
' D='..EgtNumToString( Face.Depth, 1)..' B='..EgtNumToString( Face.Whisk, 1)..' T='..tostring( Face.Type)
|
|
EgtOutLog( sOut)
|
|
end
|
|
|
|
return vFace, dMaxWidth, nNewProc
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function GetTunnelDimension( nId, nPartId, nAddGrpId)
|
|
-- ottengo i versori delle 4 facce e ottengo l'orientamento del tunnel
|
|
-- recupero il numero di facce
|
|
local nFacCnt = EgtSurfTmFacetCount( nId)
|
|
-- recupero l'ingombro della trave
|
|
local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
|
|
-- variabili dimensioni fessura e id faccia lunga
|
|
local dDimMin
|
|
local dDimMax
|
|
local nLongIdFace = 0
|
|
local bNegFace
|
|
local bOppoFace = false
|
|
-- ottengo il versore ortogonale
|
|
local ptN1, vtN1 = EgtSurfTmFacetCenter( nId, 0, GDB_ID.ROOT)
|
|
local _, vtN2 = EgtSurfTmFacetCenter( nId, 1, GDB_ID.ROOT)
|
|
local vtOrtho = vtN1 ^ vtN2
|
|
if vtOrtho:isSmall() then
|
|
_, vtN2 = EgtSurfTmFacetCenter( nId, 2, GDB_ID.ROOT)
|
|
vtOrtho = vtN1 ^ vtN2
|
|
bOppoFace = true
|
|
end
|
|
if vtOrtho:getZ() < -0.5 then
|
|
vtOrtho = -vtOrtho
|
|
bNegFace = true
|
|
end
|
|
-- ottengo il boundingBox e prendo le dimensioni lungo la normale (Z locale) che rappresenta la profondità della fessura
|
|
local frFc = Frame3d( ptN1, vtOrtho) ;
|
|
local bBoxLoc = EgtGetBBoxRef( nId, GDB_BB.STANDARD, frFc)
|
|
local dDepth = bBoxLoc:getDimZ()
|
|
-- mi assicuro che la Z del punto utilizzato per creare la superficie sia alla Z inferiore del bounding box locale
|
|
local ptN2 = Point3d(ptN1)
|
|
ptN2:toLoc(frFc)
|
|
ptN2 = Point3d( ptN2:getX(), ptN2:getY(), bBoxLoc:getMin():getZ() + 2*GEO.EPS_SMALL)
|
|
ptN2:toGlob(frFc)
|
|
-- creo superficie intermedia
|
|
local nSurfInt = EgtSurfTmPlaneInBBox( nAddGrpId, ptN2, vtOrtho, b3Solid, GDB_ID.ROOT)
|
|
-- ritaglio la superficie con le facce della fessura
|
|
for i = 1, nFacCnt do
|
|
local ptN, vtN = EgtSurfTmFacetCenter( nId, i - 1, GDB_ID.ROOT)
|
|
EgtCutSurfTmPlane( nSurfInt, ptN, -vtN, false, GDB_ID.ROOT)
|
|
end
|
|
-- sposto la geometria trovata sulla Z minima (era su di 2 * GEO.EPS_SMALL)
|
|
EgtMove( nSurfInt, Point3d(0,0,-2*GEO.EPS_SMALL) - ORIG(), GDB_RT.GLOB)
|
|
-- mi faccio dare il contorno della superfice e la ricreo in modo più corretto
|
|
local nIdCont, nIdNum = EgtExtractSurfTmLoops( nSurfInt, nAddGrpId)
|
|
-- elimino le entità allineate dello stesso tipo
|
|
EgtMergeCurvesInCurveCompo( nIdCont, 2*GEO.EPS_SMALL)
|
|
EgtErase(nSurfInt)
|
|
nSurfInt = EgtSurfTmByFlatContour( nAddGrpId, nIdCont, 2*GEO.EPS_SMALL)
|
|
-- elimino il contorno
|
|
EgtErase(nIdCont)
|
|
-- se normale negativa inverto
|
|
_, vtN1 = EgtSurfTmFacetCenter( nSurfInt, 0, GDB_ID.ROOT)
|
|
if vtN1:getZ() < -0.5 then EgtInvertSurf( nSurfInt) end
|
|
local _, DimH, DimV = EgtSurfTmFacetMinAreaRectangle( nSurfInt, 0, GDB_ID.ROOT)
|
|
dDimMin = min( DimH, DimV)
|
|
dDimMax = max( DimH, DimV)
|
|
_, DimH, DimV = EgtSurfTmFacetMinAreaRectangle( nId, nFacCnt-1, GDB_ID.ROOT)
|
|
-- se faccia pari alla larghezza fessura
|
|
if abs(DimH - dDimMax) < GEO.EPS_SMALL or abs(DimV - dDimMax) < GEO.EPS_SMALL then
|
|
nLongIdFace = nFacCnt-1
|
|
-- altrimenti verifico anche con la faccia precedente
|
|
else
|
|
local nFaceToCheck = EgtIf( bOppoFace, nFacCnt-3, nFacCnt-2)
|
|
-- prendo le dimensioni della faccia e poi confronto con il minimo
|
|
_, DimH, DimV = EgtSurfTmFacetMinAreaRectangle( nId, nFaceToCheck, GDB_ID.ROOT)
|
|
-- se trovato con il minimo, questa seconda faccia non è la più lunga
|
|
if abs(DimH - dDimMin) < GEO.EPS_SMALL or abs(DimV - dDimMin) < GEO.EPS_SMALL then
|
|
nLongIdFace = nFacCnt-1
|
|
else
|
|
nLongIdFace = nFaceToCheck
|
|
end
|
|
end
|
|
if not dDimMax then
|
|
return dDimMin, dDimMax, dDepth, nil, nil
|
|
end
|
|
return dDimMin, dDimMax, dDepth, vtOrtho, nLongIdFace, nSurfInt
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function ReorderFacesFromTab( nIdSurf, vFace)
|
|
|
|
local nFacCnt = EgtSurfTmFacetCount( nIdSurf)
|
|
for i = 1, #vFace do
|
|
for j = 1, nFacCnt do
|
|
-- ottengo punto iniziale e versore della faccia
|
|
local ptC, vtN = EgtSurfTmFacetCenter( nIdSurf, (j-1), GDB_ID.ROOT)
|
|
-- se versore e posizione coincidono e non corrispondono al numero faccia, faccio lo swap
|
|
if AreSameVectorExact( vFace[i].Norm, vtN) and AreSamePointEpsilon( vFace[i].Cen, ptC, 50*GEO.EPS_SMALL) then
|
|
if (j-1) ~= vFace[i].Fac then
|
|
EgtSurfTmSwapFacets( nIdSurf, vFace[i].Fac, (j-1))
|
|
end
|
|
break
|
|
end
|
|
end
|
|
end
|
|
return nIdSurf
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function CalcInterference( nNewProc, vtExtr, ptCentr, dDiam1, dDiam2,
|
|
dTall1, dTall2, dDiam3, dTall3)
|
|
|
|
local ptCentrGrid1 = ptCentr + ( vtExtr * 0.01)
|
|
local frOriTool = Frame3d( ptCentrGrid1, vtExtr)
|
|
local bColl1 = EgtCDeConeSolid( frOriTool, dDiam1/2, dDiam2/2, dTall1, nNewProc, 0, GDB_RT.GLOB)
|
|
if bColl1 then return true end
|
|
local ptCentrGrid2 = ptCentr + ( vtExtr * ( dTall1 + 0.01))
|
|
frOriTool = Frame3d( ptCentrGrid2, vtExtr)
|
|
local bColl2 = EgtCDeCylSolid( frOriTool, dDiam2/2, (dTall2-dTall1), nNewProc, 0, GDB_RT.GLOB)
|
|
if bColl2 then return true end
|
|
local ptCentrGrid3 = ptCentr + ( vtExtr * ( dTall2 + 0.01))
|
|
frOriTool = Frame3d( ptCentrGrid3, vtExtr)
|
|
local bColl3 = EgtCDeCylSolid( frOriTool, dDiam3/2, (dTall3-dTall2), nNewProc, 0, GDB_RT.GLOB)
|
|
if bColl3 then return true end
|
|
-- restituisco risultato controllo collisioni
|
|
return false
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function MakeLocalSurf( ptP1, ptP2, ptP3, nAddGrpId)
|
|
|
|
if not ptP1 or not ptP2 or not ptP3 then
|
|
return nil
|
|
end
|
|
|
|
local pAuxId = {}
|
|
local nAuxId, AuxId
|
|
nAuxId = EgtLine( nAddGrpId, ptP1, ptP2, GDB_RT.GLOB)
|
|
table.insert( pAuxId, nAuxId)
|
|
nAuxId = EgtLine( nAddGrpId, ptP2, ptP3, GDB_RT.GLOB)
|
|
table.insert( pAuxId, nAuxId)
|
|
nAuxId = EgtLine( nAddGrpId, ptP3, ptP1, GDB_RT.GLOB)
|
|
table.insert( pAuxId, nAuxId)
|
|
-- trasformo in percorso
|
|
if #pAuxId ~= 3 then
|
|
return nil
|
|
end
|
|
AuxId = EgtCurveCompo( nAddGrpId, pAuxId, true)
|
|
-- se non c'é il percorso esco
|
|
if not AuxId then
|
|
return nil
|
|
end
|
|
-- creo la superfice piana
|
|
local nidFace = EgtSurfTmByFlatContour( nAddGrpId, AuxId, 0.01)
|
|
if not nidFace then
|
|
EgtErase(AuxId)
|
|
return nil
|
|
end
|
|
-- se normale negativa inverto
|
|
local _, vtN1 = EgtSurfTmFacetCenter( nidFace, 0, GDB_ID.ROOT)
|
|
if vtN1:getZ() < -0.5 then EgtInvertSurf( nidFace) end
|
|
|
|
EgtErase(AuxId)
|
|
return nidFace
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function AddMillCornerMachining( nNewProc, nFacInd, tFacAdj, nTypeConeCut, nAddGrpId,
|
|
dToolDiam, dThick, sMilling, dOffsAng, dDepthMach,
|
|
bThruThick, dThSurf, dDiam1, dDiam2, dTall1,
|
|
dTall2, dDiam3, dTall3, bMakeLocSurf, vFace)
|
|
-- variabili costruzione geometria
|
|
local pAuxId = {}
|
|
local nAuxId
|
|
local ptApPoint
|
|
local AuxId
|
|
local nNewProcLoc
|
|
-- se devo creare superfice locale
|
|
if bMakeLocSurf then
|
|
-- creo superfice locale o esco
|
|
local nSurfToAdd = MakeLocalSurf( tFacAdj[1][7], tFacAdj[1][8], tFacAdj[1][9], nAddGrpId)
|
|
if nSurfToAdd then
|
|
local nFacCntPre = EgtSurfTmFacetCount( nNewProc)
|
|
-- creo copia del percorso principale e gli aggiungo la nuova faccia
|
|
nNewProcLoc = EgtCopyGlob( nNewProc, nAddGrpId)
|
|
nNewProcLoc = EgtSurfTmBySewing( nAddGrpId, {nNewProcLoc,nSurfToAdd} , true)
|
|
-- riordino le facce
|
|
nNewProcLoc = ReorderFacesFromTab( nNewProcLoc, vFace)
|
|
-- acquisisco il numero della faccia
|
|
nFacCnt = EgtSurfTmFacetCount( nNewProcLoc)
|
|
nFacInd = nFacCnt - 1
|
|
else
|
|
return true, ''
|
|
end
|
|
else
|
|
nNewProcLoc = nNewProc
|
|
end
|
|
-- prendo il primo versore
|
|
local _, vtN1 = EgtSurfTmFacetCenter( nNewProcLoc, nFacInd, GDB_ID.ROOT)
|
|
local _, vtN2 = EgtSurfTmFacetCenter( nNewProcLoc, tFacAdj[1][1], GDB_ID.ROOT)
|
|
local _, vtN3 = EgtSurfTmFacetCenter( nNewProcLoc, tFacAdj[1][2], GDB_ID.ROOT)
|
|
-- trovo il punto sulla superfice di riferimento
|
|
local _, ptLocP1, ptLocP2, _ = EgtSurfTmFacetsContact( nNewProcLoc, nFacInd, tFacAdj[1][1], GDB_ID.ROOT)
|
|
local _, ptLocP3, ptLocP4, _ = EgtSurfTmFacetsContact( nNewProcLoc, nFacInd, tFacAdj[1][2], GDB_ID.ROOT)
|
|
-- se ho creato faccia locale su copia superficie, calcella la copia
|
|
if bMakeLocSurf then
|
|
EgtErase( nNewProcLoc)
|
|
end
|
|
local nIdIniPoint
|
|
local nIdEndPoint
|
|
if ptLocP1 and ptLocP2 then
|
|
if ( dist( ptLocP1, tFacAdj[1][4]) < GEO.EPS_SMALL) or ( dist( ptLocP2, tFacAdj[1][4]) < GEO.EPS_SMALL) then
|
|
nIdEndPoint = 4
|
|
nIdIniPoint = 5
|
|
elseif ( dist( ptLocP1, tFacAdj[1][5]) < GEO.EPS_SMALL) or ( dist( ptLocP2, tFacAdj[1][5]) < GEO.EPS_SMALL) then
|
|
nIdEndPoint = 5
|
|
nIdIniPoint = 4
|
|
end
|
|
end
|
|
-- versore direzione
|
|
local vtExtr = tFacAdj[1][nIdIniPoint] - tFacAdj[1][nIdEndPoint]
|
|
vtExtr:normalize()
|
|
-- versore direzione di uscita
|
|
local vtExtrExit
|
|
-- inserisco le prime tre linee
|
|
if nIdIniPoint and nIdEndPoint then
|
|
-- se fresatura da sotto salto la lavorazione
|
|
if vtExtr:getZ() < WD.DRILL_VZ_MIN then
|
|
local sErr = 'Error : clean corner milling from bottom impossible'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- sommo i tre versori per avere una direzione media
|
|
vtExtrExit = vtN2 + vtN3
|
|
vtExtrExit:normalize()
|
|
-- se tipo 1 calcolo angolo tilt di 45°
|
|
if nTypeConeCut == 1 then
|
|
vtExtr = vtExtrExit + Z_AX()
|
|
-- altrimenti tipo 2, calcolo angolo tilt di 33° (dalla verticale)
|
|
else
|
|
vtExtr = vtExtrExit + Vector3d(0,0,1.539865)
|
|
end
|
|
vtExtr:normalize()
|
|
local vtCheck = Vector3d(vtExtr)
|
|
-- se ho un offset angolare ruoto il percorso
|
|
if abs(dOffsAng) > 100 * GEO.EPS_SMALL then
|
|
vtCheck:rotate( Z_AX(), dOffsAng)
|
|
end
|
|
-- controllo se c'è collisione con le facce della superfice
|
|
if nTypeConeCut == 1 and CalcInterference( nNewProc, vtCheck, tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), dDiam1, dDiam2,
|
|
dTall1, dTall2, dDiam3, dTall3) then
|
|
return true, ''
|
|
end
|
|
nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdIniPoint], tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
|
|
table.insert( pAuxId, nAuxId)
|
|
-- se uso utensile cono 60°
|
|
if nTypeConeCut == 1 then
|
|
-- se offset angolare valido e/o negativo creo il baffo precedente
|
|
if dOffsAng < ( 100 * GEO.EPS_SMALL) then
|
|
-- se il punto finale corrisponde con il punto utilizzato in precedenza, uso l'altro
|
|
if dist( tFacAdj[1][nIdEndPoint], ptLocP1) < 10 * GEO.EPS_SMALL then
|
|
ptApPoint = ptLocP2
|
|
else
|
|
ptApPoint = ptLocP1
|
|
end
|
|
nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
|
|
local dLenTrimExt = dist( tFacAdj[1][nIdEndPoint], ptApPoint) - (( dToolDiam/2) + 2)
|
|
-- se la distanza dei due punti della linea è maggiore dal raggio fresa + delta, trimmo al raggio fresa + delta
|
|
if dLenTrimExt > 10 * GEO.EPS_SMALL then
|
|
EgtTrimExtendCurveByLen( nAuxId , -dLenTrimExt, ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
|
|
-- se ho l'offset angolare ruoto la linea per compensare la rotazione che verrà applicata
|
|
if abs(dOffsAng) > 100 * GEO.EPS_SMALL then
|
|
EgtRotate( nAuxId, tFacAdj[1][nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
|
|
end
|
|
-- prendo il nuovo punto finale
|
|
ptApPoint = EgtEP( nAuxId, GDB_RT.GLOB) + Point3d( 0, 0, dDepthMach)
|
|
else
|
|
-- se ho l'offset angolare ruoto la linea per compensare la rotazione che verrà applicata
|
|
if abs(dOffsAng) > 100 * GEO.EPS_SMALL then
|
|
EgtRotate( nAuxId, tFacAdj[1][nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
|
|
end
|
|
end
|
|
table.insert( pAuxId, nAuxId)
|
|
-- creo linea di ritorno
|
|
nAuxId = EgtLine( nAddGrpId, ptApPoint + Point3d( 0, 0, -dDepthMach), tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
|
|
table.insert( pAuxId, nAuxId)
|
|
end
|
|
end
|
|
end
|
|
-- inserisco le ultime tre linee
|
|
-- trovo il secondo punto sulla superfice di riferimento
|
|
ptLocP1, ptLocP2 = ptLocP3, ptLocP4
|
|
if ptLocP1 and ptLocP2 then
|
|
-- se il punto finale corrisponde con il punto utilizzato in precedenza, uso l'altro
|
|
if dist( tFacAdj[1][nIdEndPoint], ptLocP1) < 10 * GEO.EPS_SMALL then
|
|
ptApPoint = ptLocP2
|
|
else
|
|
ptApPoint = ptLocP1
|
|
end
|
|
-- se uso utensile cono 60°
|
|
if nTypeConeCut == 1 then
|
|
-- se offset angolare valido e/o negativo creo il baffo precedente
|
|
if dOffsAng > -( 100 * GEO.EPS_SMALL) then
|
|
nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
|
|
local dLenTrimExt = dist( tFacAdj[1][nIdEndPoint], ptApPoint) - (( dToolDiam/2) + 2)
|
|
-- se la distanza dei due punti della linea è maggiore dal raggio fresa + delta, trimmo al raggio fresa + delta
|
|
if dLenTrimExt > 10 * GEO.EPS_SMALL then
|
|
EgtTrimExtendCurveByLen( nAuxId , -dLenTrimExt, ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
|
|
-- se ho l'offset angolare ruoto la linea per compensare la rotazione che verrà applicata
|
|
if abs(dOffsAng) > 100 * GEO.EPS_SMALL then
|
|
EgtRotate( nAuxId, tFacAdj[1][nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
|
|
end
|
|
-- prendo il nuovo punto finale
|
|
ptApPoint = EgtEP( nAuxId, GDB_RT.GLOB) + Point3d( 0, 0, dDepthMach)
|
|
else
|
|
-- se ho l'offset angolare ruoto la linea per compensare la rotazione che verrà applicata
|
|
if abs(dOffsAng) > 100 * GEO.EPS_SMALL then
|
|
EgtRotate( nAuxId, tFacAdj[1][nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB)
|
|
end
|
|
end
|
|
table.insert( pAuxId, nAuxId)
|
|
-- creo linea di ritorno
|
|
nAuxId = EgtLine( nAddGrpId, ptApPoint + Point3d( 0, 0, -dDepthMach), tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB)
|
|
table.insert( pAuxId, nAuxId)
|
|
end
|
|
-- ultima linea di distacco (5mm in direzione utensile)
|
|
local pEnd = tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach) + ( 5 * vtExtr)
|
|
nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), pEnd, GDB_RT.GLOB)
|
|
table.insert( pAuxId, nAuxId)
|
|
else
|
|
-- linea di distacco (2mm in direzione utensile)
|
|
local pEnd = tFacAdj[1][nIdEndPoint] + ( 2 * vtExtr)
|
|
nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdEndPoint], pEnd, GDB_RT.GLOB)
|
|
table.insert( pAuxId, nAuxId)
|
|
-- ultima linea di risalita in Z
|
|
local pIni = pEnd
|
|
pEnd = pIni + ( dThick * Z_AX())
|
|
nAuxId = EgtLine( nAddGrpId, pIni, pEnd, GDB_RT.GLOB)
|
|
table.insert( pAuxId, nAuxId)
|
|
end
|
|
end
|
|
-- trasformo in percorso
|
|
if #pAuxId > 0 then
|
|
AuxId = EgtCurveCompo( nAddGrpId, pAuxId, true)
|
|
end
|
|
-- se non c'é il percorso do errore
|
|
if not AuxId then
|
|
local sErr = 'Error : impossible make clean corner path'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- modifico versore direzione
|
|
EgtModifyCurveExtrusion( AuxId, vtExtr, GDB_RT.GLOB)
|
|
-- se ho un offset angolare ruoto il percorso
|
|
if abs(dOffsAng) > 100 * GEO.EPS_SMALL then
|
|
EgtRotate( AuxId, tFacAdj[1][nIdEndPoint], Z_AX(), dOffsAng, GDB_RT.GLOB)
|
|
end
|
|
-- inserisco la lavorazione
|
|
local sName = 'Clean_' .. ( EgtGetName( nNewProc) or tostring( nNewProc))
|
|
local nMchId = EgtAddMachining( sName, sMilling)
|
|
if not nMchId then
|
|
local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- se flag lavorazione spessore passante setto la nota per spostarla dopo i tagli di lama
|
|
if bThruThick and nTypeConeCut == 1 then
|
|
EgtSetInfo( nMchId, 'MOVE_AFTER', 1)
|
|
end
|
|
-- 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
|
|
end
|
|
EgtSetMachiningParam( MCH_MP.SCC, nSCC)
|
|
EgtSetMachiningParam( MCH_MP.LEADINTYPE, 0)
|
|
EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, 4)
|
|
-- allungo inizio e fine di 10mm
|
|
EgtSetMachiningParam( MCH_MP.STARTADDLEN, 10)
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, 10)
|
|
-- setto affondamento 0
|
|
EgtSetMachiningParam( MCH_MP.DEPTH, 0)
|
|
-- Note utente con dichiarazione nessuna generazione sfridi per Vmill
|
|
local sUserNotes = 'VMRS=0;'
|
|
-- aggiungo alle note massima elevazione
|
|
-- sUserNotes = sUserNotes .. 'MaxElev=' .. EgtNumToString( dMaxDepth, 1) .. ';'
|
|
sUserNotes = sUserNotes .. 'MaxElev=' .. EgtNumToString( 0.0, 1) .. ';'
|
|
EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
|
|
if not EgtApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtSetOperationMode( nMchId, false)
|
|
return false, sErr
|
|
else
|
|
local _, sWarn = EgtGetMachMgrWarning( 0)
|
|
if EgtIsMachiningEmpty() then
|
|
EgtSetOperationMode( nMchId, false)
|
|
return false, sWarn
|
|
end
|
|
end
|
|
|
|
return true, ''
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw,
|
|
dToolDiam, nAddGrpId, dThick, nMasterNewProc, dDepthMach,
|
|
bThruThick)
|
|
|
|
local sMilling, dMaxDepth
|
|
-- se ripresa angolo con fresa cono 60° con ripresa
|
|
if nTypeConeCut == 1 then
|
|
-- recupero la lavorazione di fresatura
|
|
sMilling, dMaxDepth = WM.FindMilling( 'CleanCorner60')
|
|
if not sMilling then
|
|
local sErr = 'Error : CleanCorner 60 not found in library'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- se ripresa angolo con fresa cono piccola senza ripresa
|
|
else
|
|
sMilling, dMaxDepth = WM.FindMilling( 'CleanCorner30')
|
|
if not sMilling then
|
|
local sErr = 'Error : CleanCorner 30 not found in library'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
end
|
|
-- recupero i dati dell'utensile
|
|
local dMillDiam = 20
|
|
local dMillTotDiam = 20
|
|
local dMillDiamTh = 20
|
|
local dToolLength = 20
|
|
local dThickTool = 20
|
|
local dSideAng = 0
|
|
if EgtMdbSetCurrMachining( sMilling) then
|
|
local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
|
|
if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
|
|
dMillDiamTh = EgtTdbGetCurrToolThDiam() or dMillDiamTh
|
|
dMillTotDiam = EgtTdbGetCurrToolParam( MCH_TP.TOTDIAM) or dMillTotDiam
|
|
dSideAng = EgtTdbGetCurrToolParam( MCH_TP.SIDEANG) or dSideAng
|
|
dMillDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dMillDiam
|
|
dThickTool = EgtTdbGetCurrToolParam( MCH_TP.THICK) or dThickTool
|
|
dToolLength = EgtTdbGetCurrToolParam( MCH_TP.LEN) or dToolLength
|
|
dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
|
|
-- calcolo il secondo diametro del cono
|
|
dMillTotDiam = dMillDiam + ( abs(dThickTool) * tan(dSideAng)) * 2
|
|
end
|
|
end
|
|
-- copio la feature nel layer di appoggio
|
|
local nNewProc
|
|
if nMasterNewProc then
|
|
nNewProc = nMasterNewProc
|
|
else
|
|
nNewProc = EgtCopyGlob( Proc.Id, nAddGrpId) or GDB_ID.NULL
|
|
end
|
|
local nFacCnt = EgtSurfTmFacetCount( nNewProc)
|
|
local nFacInd, dDimMin, dDimMax, dDepth, nSurfInt
|
|
local bMakeLocSurf
|
|
if nFacCnt <= 4 then
|
|
-- ottengo le dimensioni apertura, la normale e la faccia inferiore
|
|
dDimMin, dDimMax, dDepth, _, _, nSurfInt = GetTunnelDimension( nNewProc, Proc.PartId, nAddGrpId)
|
|
if nSurfInt then
|
|
-- uso la dimensione minima anche nel caso che la cava sborda perchè la lavorazione potrebbe collidere con un pezzo limitrofo
|
|
local dMinWidth = dDimMin
|
|
nNewProc = EgtSurfTmBySewing( nAddGrpId, {nNewProc,nSurfInt} , true)
|
|
-- riordino le facce
|
|
nNewProc = ReorderFacesFromTab( nNewProc, vFace)
|
|
-- acquisisco il numero della faccia
|
|
nFacCnt = EgtSurfTmFacetCount( nNewProc)
|
|
nFacInd = nFacCnt - 1
|
|
else
|
|
local sErr = 'Error : cannot create base surface'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
else
|
|
bMakeLocSurf = true
|
|
end
|
|
-- verifico se ciclo chiuso
|
|
local bClosed = ( abs( vFace[1].AngPrev) > 0.1)
|
|
-- ciclo di inserimento delle fresate sulle facce del contorno in esame
|
|
local i = 1
|
|
-- se faccia finale con fine non lavorato, forzo partenza da prima faccia non tutta saltata (tipo 4)
|
|
if bClosed and ( vFace[#vFace].Type == 4 or ( vFace[#vFace].Type & 2) ~= 0) then
|
|
while i <= #vFace and vFace[i].Type == 4 do
|
|
i = i + 1
|
|
end
|
|
end
|
|
-- se facce tutte da saltare, parto dall'inizio
|
|
local bAllType4 = ( i > #vFace)
|
|
if bAllType4 then i = 1 end
|
|
while i <= #vFace do
|
|
-- se tutta la faccia o la sua fine senza taglio, inserisco una fresatura
|
|
if ( vFace[i].Type & 2) ~= 0 or vFace[i].Type == 4 then
|
|
-- variabili costruzione geometria
|
|
local tFacAdj = {}
|
|
local nFace1 = vFace[i].Fac
|
|
local nFace2
|
|
-- ricavo i tre punti per eventuale superficie locale
|
|
local ptLoc1, ptLoc2, ptLoc3
|
|
-- punto precedente (punto precedente della faccia [i])
|
|
ptLoc3 = vFace[i].PPrev
|
|
-- aggiungo geometria
|
|
i = i + 1
|
|
local j = EgtIf( i <= #vFace, i, EgtIf( bAllType4, nil, 1))
|
|
nFace2 = vFace[j].Fac
|
|
-- punto in comune tra le due facce (punto precedente della faccia [j])
|
|
ptLoc1 = vFace[j].PPrev
|
|
-- punto successivo ( precedente della faccia successiva)
|
|
j = j + 1
|
|
local k = EgtIf( j <= #vFace, j, EgtIf( bAllType4, nil, 1))
|
|
ptLoc2 = vFace[k].PPrev
|
|
-- ricavo i punti e l'angolo interno
|
|
local _, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( nNewProc, nFace1, nFace2, GDB_ID.ROOT)
|
|
-- se punti validi e angolo è interno e >= 90 creo istanza
|
|
if ptP1 and ptP2 and dAng < 0 and dAng > EgtIf( nTypeConeCut == 1, -(90 + 10 * GEO.EPS_SMALL), -(180-dAngleSmall + 10 * GEO.EPS_SMALL)) then
|
|
local dLen = dist( ptP1, ptP2)
|
|
table.insert( tFacAdj, { nFace1, nFace2, dLen, ptP1, ptP2, dAng, ptLoc1, ptLoc2, ptLoc3})
|
|
end
|
|
-- se ho un elemento creo percorso o percorsi in base al tipo di cono e all'apertura dall'angolo rispetto ai 90°
|
|
-- con una tolleranza di 2 gradi
|
|
if #tFacAdj > 0 then
|
|
if nTypeConeCut == 1 and bMakeTwinCut and (dAng + 90) > 2 then
|
|
local dAngOffs = (dAng + 90) / 2
|
|
-- primo taglio
|
|
local bOk, sErr = AddMillCornerMachining( nNewProc, nFacInd, tFacAdj, nTypeConeCut, nAddGrpId,
|
|
dToolDiam, dThick, sMilling, -dAngOffs, dDepthMach,
|
|
bThruThick, dDepth, dMillDiam, dMillTotDiam, abs(dThickTool),
|
|
dMaxDepth, dMillDiamTh, dToolLength, bMakeLocSurf, vFace)
|
|
if not bOk then return bOk, sErr end
|
|
-- secondo taglio
|
|
bOk, sErr = AddMillCornerMachining( nNewProc, nFacInd, tFacAdj, nTypeConeCut, nAddGrpId,
|
|
dToolDiam, dThick, sMilling, dAngOffs, dDepthMach,
|
|
bThruThick, dDepth, dMillDiam, dMillTotDiam, abs(dThickTool),
|
|
dMaxDepth, dMillDiamTh, dToolLength, bMakeLocSurf, vFace)
|
|
if not bOk then return bOk, sErr end
|
|
-- altrimenti ho un solo percorso
|
|
else
|
|
local bOk, sErr = AddMillCornerMachining( nNewProc, nFacInd, tFacAdj, nTypeConeCut, nAddGrpId,
|
|
dToolDiam, dThick, sMilling, 0, dDepthMach,
|
|
bThruThick, dDepth, dMillDiam, dMillTotDiam, abs(dThickTool),
|
|
dMaxDepth, dMillDiamTh, dToolLength, bMakeLocSurf, vFace)
|
|
if not bOk then return bOk, sErr end
|
|
end
|
|
end
|
|
else
|
|
i = i + 1
|
|
end
|
|
end
|
|
-- cancello la copia della superfice
|
|
if nNewProc then
|
|
EgtErase(nNewProc)
|
|
end
|
|
return true
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function MakeByChainSaw( Proc, nFacet, nRawId, b3Raw, dElev, dH, dV)
|
|
local sWarn
|
|
-- dati della faccia
|
|
local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, nFacet, GDB_ID.ROOT)
|
|
-- Recupero le facce adiacenti alla principale
|
|
local vAdj = EgtSurfTmFacetAdjacencies( Proc.Id, nFacet)[1]
|
|
if not vAdj or #vAdj == 0 then
|
|
local sErr = 'Error : main face without adjacencies'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
EgtOutLog( 'Adjac=' .. table.concat( vAdj, ','), 3)
|
|
-- Cerco una faccia adiacente alla principale sul lato più lungo
|
|
local nFacAdj
|
|
local dMaxLen = 0
|
|
for i = 1, #vAdj do
|
|
if vAdj[i] >= 0 then
|
|
local _, ptP1, ptP2, _ = EgtSurfTmFacetsContact( Proc.Id, nFacet, vAdj[i], GDB_ID.ROOT)
|
|
local dLen = dist( ptP1, ptP2)
|
|
local vtAdjN = EgtSurfTmFacetNormVersor( Proc.Id, vAdj[i], GDB_ID.ROOT)
|
|
if dLen > dMaxLen - 1 and vtAdjN:getZ() > -0.1 then
|
|
nFacAdj = vAdj[i]
|
|
dMaxLen = dLen
|
|
EgtOutLog( string.format( 'Adjac=%d Len=%.3f H=%.3f V=%.3f', vAdj[i], dLen, dH, dV), 3)
|
|
end
|
|
end
|
|
end
|
|
if not nFacAdj then
|
|
local sErr = 'Error : long adjacent face not found'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- Recupero la lavorazione
|
|
local sSawing = WM.FindSawing( 'Sawing')
|
|
if not sSawing then
|
|
local sErr = 'Error : chainsawing not found in library'
|
|
EgtOutLog( sErr)
|
|
return false, sErr, 'MNF'
|
|
end
|
|
-- Recupero i dati dell'utensile
|
|
local dSawWidth = 75
|
|
local dSawThick = 8
|
|
local dMaxDepth = 200
|
|
if EgtMdbSetCurrMachining( sSawing) then
|
|
local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
|
|
if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
|
|
dSawWidth = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawWidth
|
|
dSawThick = EgtTdbGetCurrToolParam( MCH_TP.THICK) or dSawThick
|
|
dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
|
|
end
|
|
end
|
|
if dSawThick > dV + 10 * GEO.EPS_SMALL then
|
|
local sErr = 'Error : chainsaw too thick'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- Calcolo uso faccia
|
|
local nFaceUse = WL.GetNearestParalOpposite( vtN)
|
|
-- Calcolo angolo 3° asse rot (da direz. utensile)
|
|
local d3RotAng = 180
|
|
-- Lati chiusi
|
|
local bOpenStart = false
|
|
local bOpenEnd = false
|
|
-- Verifico se necessarie più passate
|
|
local nStep = ceil( ( dV - 10 * GEO.EPS_SMALL) / dSawThick)
|
|
local dStep = 0
|
|
if nStep > 1 then
|
|
dStep = ( dV - dSawThick) / ( nStep - 1)
|
|
end
|
|
for i = 1, nStep do
|
|
-- Applico la lavorazione con sega a catena a questa faccia
|
|
local sName = 'Csaw_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( i)
|
|
local nMchFId = EgtAddMachining( sName, sSawing)
|
|
if not nMchFId then
|
|
local sErr = 'Error adding machining ' .. sName .. '-' .. sSawing
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- aggiungo geometria
|
|
EgtSetMachiningGeometry( {{ Proc.Id, nFacAdj}})
|
|
-- imposto uso faccia
|
|
EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
|
|
-- imposto accorciamento iniziale/finale per estremi aperti/chiusi
|
|
EgtSetMachiningParam( MCH_MP.STARTADDLEN, EgtIf( bOpenStart, 0, - dSawWidth / 2))
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, EgtIf( bOpenEnd, 0, - dSawWidth / 2))
|
|
-- imposto angolo 3° asse rot
|
|
EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, 'A1=' .. EgtNumToString( d3RotAng))
|
|
-- imposto offset radiale
|
|
local dOffs = ( i - 1) * dStep
|
|
EgtSetMachiningParam( MCH_MP.OFFSR, dOffs)
|
|
-- se necessario, limito l'affondamento
|
|
if dElev > dMaxDepth + 10 * GEO.EPS_SMALL then
|
|
sWarn = 'Warning in LapJoint : elevation (' .. EgtNumToString( dElev, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
|
|
dDepth = dMaxDepth - dElev
|
|
EgtOutLog( sWarn)
|
|
EgtSetMachiningParam( MCH_MP.DEPTH_STR, 'TH '..EgtNumToString( dDepth, 1))
|
|
end
|
|
-- imposto elevazione
|
|
local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 2) .. ';'
|
|
EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
|
|
-- eseguo
|
|
if not EgtApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtSetOperationMode( nMchFId, false)
|
|
return false, sErr
|
|
elseif EgtIsMachiningEmpty() then
|
|
_, sWarn = EgtGetMachMgrWarning( 0)
|
|
EgtSetOperationMode( nMchFId, false)
|
|
return false, sWarn
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function MakeByMill( Proc, nFacet, nOthFac, nRawId, b3Raw)
|
|
-- dati della faccia e dell'altra
|
|
local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, nFacet, GDB_ID.ROOT)
|
|
local dElev = WL.GetFaceElevation( Proc.Id, nFacet, nRawId)
|
|
local _, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacet, GDB_ID.ROOT)
|
|
local dDiam = min( dH, dV)
|
|
local _, vtRef = EgtSurfTmFacetCenter( Proc.Id, nOthFac, GDB_ID.ROOT)
|
|
-- recupero la lavorazione
|
|
local sMilling = WM.FindMilling( 'Side')
|
|
if not sMilling then return false end
|
|
-- recupero i dati dell'utensile
|
|
local dMillDiam = 20
|
|
local dMillLen = 10
|
|
local dMillTotLen = 30
|
|
local dMaxDepth = 0
|
|
local dThDiam = 100
|
|
if EgtMdbSetCurrMachining( sMilling) then
|
|
local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
|
|
if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
|
|
dMillDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dMillDiam
|
|
dMillLen = EgtTdbGetCurrToolParam( MCH_TP.LEN) or dMillLen
|
|
dMillTotLen = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) or dMillTotLen
|
|
dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
|
|
dThDiam = EgtTdbGetCurrToolThDiam() or dThDiam
|
|
end
|
|
end
|
|
if dMillDiam < dDiam or dMaxDepth < dElev then
|
|
local sErr = 'Error : Side Elevation too big'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
local dMillExtra = dMillTotLen - dMillLen
|
|
if Proc.Box:getMin():getZ() - dMillExtra < b3Raw:getMin():getZ() - 10 * GEO.EPS_SMALL then
|
|
local sErr = 'Error : Tool collide with table'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- inserisco la lavorazione di contornatura
|
|
local sName = 'Mill_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
|
|
local nMchFId = EgtAddMachining( sName, sMilling)
|
|
if not nMchFId then
|
|
local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- aggiungo geometria
|
|
EgtSetMachiningGeometry( {{ Proc.Id, nFacet}})
|
|
-- imposto posizione braccio porta testa
|
|
local nSCC = MCH_SCC.ADIR_ZP
|
|
if AreSameVectorApprox( vtN, Z_AX()) then
|
|
nSCC = EgtIf( Proc.Box:getDimX() >= Proc.Box:getDimY(), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_XP)
|
|
end
|
|
EgtSetMachiningParam( MCH_MP.SCC, nSCC)
|
|
-- imposto modo di lavorare la faccia
|
|
local nFaceUse = WL.GetNearestOrthoOpposite( vtRef, vtN)
|
|
EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
|
|
-- eseguo
|
|
if not EgtApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtRemoveOperation( nMchFId)
|
|
return false, sErr
|
|
end
|
|
return true
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw)
|
|
-- dati della faccia
|
|
local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, nFacet, GDB_ID.ROOT)
|
|
local dElev = WL.GetFaceElevation( Proc.Id, nFacet, nRawId)
|
|
local _, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacet, GDB_ID.ROOT)
|
|
local dThick = min( dH, dV)
|
|
-- recupero la lavorazione
|
|
local sMilling = WM.FindMilling( 'SideGroove')
|
|
if not sMilling then
|
|
local sErr = 'Error : SideGroove not found in library'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- recupero i dati dell'utensile
|
|
local dMillDiam = 20
|
|
local dMillLen = 10
|
|
local dMillTotLen = 30
|
|
local dMaxMat = 0
|
|
if EgtMdbSetCurrMachining( sMilling) then
|
|
local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
|
|
if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
|
|
dMillDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dMillDiam
|
|
dMillLen = EgtTdbGetCurrToolParam( MCH_TP.LEN) or dMillLen
|
|
dMillTotLen = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) or dMillTotLen
|
|
dMaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) or dMaxMat
|
|
end
|
|
end
|
|
if dElev > dMillDiam / 2 - 30 then
|
|
local sErr = 'Error : Side Elevation too big'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
local dMillExtra = dMillTotLen - dMillLen
|
|
if Proc.Box:getMin():getZ() - dMillExtra < b3Raw:getMin():getZ() - 10 * GEO.EPS_SMALL then
|
|
local sErr = 'Error : Tool collide with table'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- inserisco la lavorazione di contornatura
|
|
local sName = 'Mill_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
|
|
local nMchFId = EgtAddMachining( sName, sMilling)
|
|
if not nMchFId then
|
|
local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- aggiungo geometria
|
|
EgtSetMachiningGeometry( {{ Proc.Id, nFacet}})
|
|
-- imposto posizione braccio porta testa
|
|
local nSCC = MCH_SCC.ADIR_ZP
|
|
if AreSameVectorApprox( vtN, Z_AX()) then
|
|
nSCC = EgtIf( Proc.Box:getDimX() >= Proc.Box:getDimY(), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_XP)
|
|
end
|
|
EgtSetMachiningParam( MCH_MP.SCC, nSCC)
|
|
-- imposto modo di lavorare la faccia
|
|
local nFaceUse = WL.GetNearestParalOpposite( Z_AX(), vtN)
|
|
EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
|
|
-- imposto elevazione e step
|
|
local dStep = EgtGetMachiningParam( MCH_MP.STEP)
|
|
if dStep < GEO.EPS_SMALL then dStep = dMaxMat end
|
|
local nStep = ceil( ( dThick - dMaxMat) / dStep)
|
|
dStep = ( dThick - dMaxMat) / nStep
|
|
local dMaxElev = ( nStep + 1) * dStep - GEO.EPS_SMALL
|
|
EgtSetMachiningParam( MCH_MP.STEP, dStep)
|
|
EgtSetMachiningParam( MCH_MP.USERNOTES, 'MaxElev=' .. EgtNumToString( dMaxElev, 3) .. ';')
|
|
-- eseguo
|
|
if not EgtApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtRemoveOperation( nMchFId)
|
|
return false, sErr
|
|
end
|
|
return true
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function MakeByPocketing( Proc, nFacet, nRawId, b3Raw, bCheckQPar)
|
|
-- dati della faccia
|
|
local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, nFacet, GDB_ID.ROOT)
|
|
local dElev = WL.GetFaceElevation( Proc.Id, nFacet, nRawId)
|
|
local _, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacet, GDB_ID.ROOT)
|
|
local dDiam = min( dH, dV)
|
|
-- gruppo ausiliario
|
|
local nAddGrpId = WL.GetAddGroup( Proc.PartId)
|
|
local nNewProc, nNumFacet = RemoveBottomFaceAndReorder( Proc, nAddGrpId, nFacet)
|
|
-- se ho forma a L
|
|
local bIsL = ( nNumFacet == 2 or TestElleShape3( nNewProc, nNumFacet) or TestElleShape4( nNewProc, nNumFacet) == 2)
|
|
-- verifico se U
|
|
local bIsU = ( nNumFacet == 3 and not TestElleShape3( nNewProc, nNumFacet))
|
|
local dMiddleFacetLength = 0
|
|
if bIsU then
|
|
local _, dH2, dV2 = EgtSurfTmFacetMinAreaRectangle( nNewProc, 1, GDB_ID.ROOT)
|
|
-- prendo la linea di base
|
|
if abs( dElev - dH2) < 1 and abs ( dElev - dV2) > 1 then
|
|
dMiddleFacetLength = dV2
|
|
elseif abs( dElev - dV2) < 1 and abs ( dElev - dH2) > 1 then
|
|
dMiddleFacetLength = dH2
|
|
end
|
|
end
|
|
if Proc.Fct < 5 and (( bIsL and not bIsU) or ( bIsU and dMiddleFacetLength > dDiam * 2)) then dDiam = dDiam * 2 end
|
|
-- recupero la lavorazione
|
|
local sPocketing = WM.FindPocketing( 'Pocket', dDiam, dElev)
|
|
if not sPocketing then
|
|
sPocketing = WM.FindPocketing( 'Pocket', dDiam)
|
|
if not sPocketing then
|
|
local sErr = 'Error : pocketing not found in library'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
end
|
|
-- recupero i dati dell'utensile
|
|
local dMillDiam = 20
|
|
local dMaxDepth = 0
|
|
local dThDiam = 100
|
|
if EgtMdbSetCurrMachining( sPocketing) then
|
|
local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
|
|
if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
|
|
dMillDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dMillDiam
|
|
dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
|
|
dThDiam = EgtTdbGetCurrToolThDiam() or dThDiam
|
|
end
|
|
end
|
|
-- inserisco la lavorazione di svuotatura
|
|
local sName = 'Pock_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
|
|
local nMchFId = EgtAddMachining( sName, sPocketing)
|
|
if not nMchFId then
|
|
local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- aggiungo geometria
|
|
EgtSetMachiningGeometry( {{ Proc.Id, nFacet}})
|
|
-- imposto posizione braccio porta testa
|
|
local nSCC = MCH_SCC.ADIR_ZP
|
|
if AreSameVectorApprox( vtN, Z_AX()) then
|
|
nSCC = EgtIf( Proc.Box:getDimX() >= Proc.Box:getDimY(), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_XP)
|
|
end
|
|
EgtSetMachiningParam( MCH_MP.SCC, nSCC)
|
|
-- se elevazione superiore a massimo affondamento della fresa, riduco opportunamente
|
|
local dThElev = dThDiam / 2 * sqrt( vtN:getX() * vtN:getX() + vtN:getY() * vtN:getY())
|
|
local dDepth = 0
|
|
local sWarn = ''
|
|
if dElev + dThElev > dMaxDepth + 10 * GEO.EPS_SMALL then
|
|
dDepth = dMaxDepth - dElev - dThElev
|
|
sWarn = 'Warning : elevation bigger than max tool depth'
|
|
EgtOutLog( sWarn)
|
|
end
|
|
EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
|
|
-- imposto elevazione
|
|
EgtSetMachiningParam( MCH_MP.USERNOTES, 'MaxElev=' .. EgtNumToString( min( dElev, dMaxDepth), 1) .. ';')
|
|
-- eseguo
|
|
if not EgtApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtSetOperationMode( nMchFId, false)
|
|
return false, sErr
|
|
end
|
|
-- verifica parametro Q per pulitura spigoli
|
|
if bCheckQPar then
|
|
-- lettura parametri (probabile/i parametro/i Q)
|
|
local nConeCut = VerifyCornerType( Proc)
|
|
-- recupero i dati di tutte le facce
|
|
local vFace, dMaxWidth = GetFacesData( nNewProc, false, false, dMillDiam, dMaxDepth, (dMillDiam/2), nAddGrpId, Proc.PartId)
|
|
-- se abilitata la lavorazione corner con stop macchina e lavorazione precedente passante
|
|
if nConeCut == 1 then
|
|
local bMcok, sMcErr = AddMillCorner( nConeCut, vFace, Proc, nRawId, b3Raw,
|
|
dMillDiam, nAddGrpId, dMaxWidth, nNewProc, dDepth)
|
|
if not bMcok then return bMcok, sMcErr end
|
|
else
|
|
EgtErase( nNewProc)
|
|
end
|
|
else
|
|
EgtErase( nNewProc)
|
|
end
|
|
return true, sWarn
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function MakeOneFace( Proc, nRawId, b3Raw)
|
|
-- dati della faccia
|
|
local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
|
|
-- dimensioni della faccia
|
|
local _, dDimH, dDimV = WL.GetFaceHvRefDim( Proc.Id, 0)
|
|
-- recupero la lavorazione di taglio con lama e i suoi parametri
|
|
local sCutting, dSawDiam, dSawThick, dSawMaxDepth = WM.FindCutting( 'Standard')
|
|
-- se non inclinata o capacità di taglio non sufficiente, provo con svuotatura
|
|
if not sCutting or vtN:getZ() > 0.95 or dSawMaxDepth < dDimV + WD.CUT_SIC then
|
|
-- faccio con svuotatura
|
|
local nFacet = 0
|
|
return MakeByPocketing( Proc, nFacet, nRawId, b3Raw)
|
|
end
|
|
-- eseguo il taglio di lama
|
|
local sName = 'Cut_' .. ( EgtGetName( Proc.PartId) or tostring( Proc.PartId)) .. '_' .. tostring( Proc.Id)
|
|
local nMchId = EgtAddMachining( sName, sCutting)
|
|
if not nMchId then
|
|
local sErr = 'Error adding machining ' .. sName .. '-' .. sCutting
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- aggiungo geometria
|
|
EgtSetMachiningGeometry( { { Proc.Id, 0}})
|
|
-- percorso da non invertire
|
|
EgtSetMachiningParam( MCH_MP.INVERT, false)
|
|
-- assegno affondamento
|
|
EgtSetMachiningParam( MCH_MP.DEPTH, 0)
|
|
-- assegno il lato di lavoro
|
|
EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
|
|
-- assegno l'attacco e l'uscita
|
|
EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_SAW_LI.CENT)
|
|
EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_SAW_LO.CENT)
|
|
-- nessun criterio per il braccio è necessario
|
|
EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.NONE)
|
|
-- eseguo
|
|
if not EgtApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtSetOperationMode( nMchId, false)
|
|
return false, sErr
|
|
end
|
|
return true
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function MakeTwoFaces( Proc, nRawId, b3Raw)
|
|
-- dati delle facce
|
|
local ptC = {}
|
|
local vtN = {}
|
|
ptC[1], vtN[1] = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
|
|
ptC[2], vtN[2] = EgtSurfTmFacetCenter( Proc.Id, 1, GDB_ID.ROOT)
|
|
-- determino l'intersezione tra le due facce
|
|
local bAdj, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, 0, 1, GDB_ID.ROOT)
|
|
if not bAdj then
|
|
return false, 'Feature with two faces not adjacentes'
|
|
end
|
|
-- versore della linea di intersezione
|
|
local vtX = ptP2 - ptP1 ; vtX:normalize()
|
|
-- larghezza delle facce ortogonalmente all'intersezione
|
|
local dDimY = {}
|
|
for i = 1, 2 do
|
|
local vtY = vtN[i] ^ vtX ; vtY:normalize()
|
|
local frRef = Frame3d( ptC[i], ptC[i] + 100 * vtX, ptC[i] + 100 * vtY)
|
|
local b3Ref = EgtSurfTmGetFacetBBoxRef( Proc.Id, i - 1, GDB_BB.STANDARD, frRef)
|
|
dDimY[i] = b3Ref:getDimY()
|
|
end
|
|
-- recupero la lavorazione di taglio con lama e i suoi parametri
|
|
local sCutting, dSawDiam, dSawThick, dSawMaxDepth = WM.FindCutting( 'Standard')
|
|
-- se di fianco in basso
|
|
if vtN[1]:getZ() < -0.95 or vtN[2]:getZ() < -0.95 then
|
|
-- cerco la faccia orizzontale
|
|
local nFacet = EgtIf( abs( vtN[1]:getZ()) < 0.1, 0, 1)
|
|
-- se vicino al bordo del grezzo e non troppo larga, provo con fresatura di fianco
|
|
local ptMid = ( ptP1 + ptP2) / 2
|
|
if abs( ptMid:getX() - b3Raw:getMin():getX()) < 300 or abs( ptMid:getX() - b3Raw:getMax():getX()) < 300 or
|
|
abs( ptMid:getY() - b3Raw:getMin():getY()) < 300 or abs( ptMid:getY() - b3Raw:getMax():getY()) < 300 then
|
|
return MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw)
|
|
end
|
|
-- se altrimenti di fianco in alto
|
|
elseif vtN[1]:getZ() > 0.95 or vtN[2]:getZ() > 0.95 then
|
|
-- cerco la faccia con il maggior numero di adiacenze (e minor elevazione)
|
|
local nFacInd, _, nFacInd2 = WL.GetFaceWithMostAdj( Proc.Id, Proc.PartId)
|
|
local vtN = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT)
|
|
local nFacet = EgtIf( vtN:getZ() >= WD.NZ_MINA, nFacInd, nFacInd2)
|
|
-- se vicino al bordo del grezzo e non troppo larga, provo con fresatura di fianco
|
|
local ptMid = ( ptP1 + ptP2) / 2
|
|
if abs( ptMid:getX() - b3Raw:getMin():getX()) < 300 or abs( ptMid:getX() - b3Raw:getMax():getX()) < 300 or
|
|
abs( ptMid:getY() - b3Raw:getMin():getY()) < 300 or abs( ptMid:getY() - b3Raw:getMax():getY()) < 300 then
|
|
if MakeByMill( Proc, nFacet, 1 - nFacet, nRawId, b3Raw) then
|
|
return true
|
|
end
|
|
end
|
|
-- se non inclinate o capacità di taglio non sufficiente, provo con contornatura o svuotatura
|
|
if not sCutting or dSawMaxDepth < dDimY[1] + WD.CUT_SIC or dSawMaxDepth < dDimY[2] + WD.CUT_SIC then
|
|
-- eseguo la svuotatura
|
|
return MakeByPocketing( Proc, nFacet, nRawId, b3Raw)
|
|
end
|
|
end
|
|
-- ordino i tagli per fare prima quello meno inclinato
|
|
local nOrd = { 0, 1}
|
|
if vtN[2]:getZ() > vtN[1]:getZ() then
|
|
nOrd = { 1, 0}
|
|
end
|
|
-- eseguo i tagli di lama
|
|
for i = 1, 2 do
|
|
-- inserisco la lavorazione
|
|
local sName = 'Cut_' .. ( EgtGetName( Proc.PartId) or tostring( Proc.PartId)) .. '_' .. tostring( Proc.Id) .. '_' .. tostring( i)
|
|
local nMchId = EgtAddMachining( sName, sCutting)
|
|
if not nMchId then
|
|
local sErr = 'Error adding machining ' .. sName .. '-' .. sCutting
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- aggiungo geometria
|
|
EgtSetMachiningGeometry( { { Proc.Id, nOrd[i]}})
|
|
-- percorso da non invertire
|
|
EgtSetMachiningParam( MCH_MP.INVERT, false)
|
|
-- assegno affondamento
|
|
EgtSetMachiningParam( MCH_MP.DEPTH, 0)
|
|
-- assegno il lato di lavoro
|
|
EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
|
|
-- assegno l'attacco e l'uscita
|
|
EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_SAW_LI.CENT)
|
|
EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_SAW_LO.CENT)
|
|
-- nessun criterio per il braccio è necessario
|
|
EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.NONE)
|
|
-- eseguo
|
|
if not EgtApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtSetOperationMode( nMchId, false)
|
|
return false, sErr
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function MakeMoreFaces( Proc, nRawId, b3Raw)
|
|
-- con una faccia di fondo valida
|
|
if Proc.Stype == 1 or Proc.Stype == 2 then
|
|
-- cerco la faccia con il maggior numero di adiacenze
|
|
local nFacInd, dElev, nFacInd2, dElev2 = WL.GetFaceWithMostAdj( Proc.Id, Proc.PartId)
|
|
-- se necessario scambio le facce
|
|
if Proc.Stype == 2 then
|
|
nFacInd, dElev, nFacInd2, dElev2 = nFacInd2, dElev2, nFacInd, dElev
|
|
end
|
|
local vtN = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT)
|
|
local _, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd, GDB_ID.ROOT)
|
|
-- se di fianco
|
|
if Proc.Fct >= 3 and vtN:getZ() < WD.NZ_MINA then
|
|
-- fresatura
|
|
if dElev < 200 then
|
|
return MakeSideGrooveByMill( Proc, nFacInd, nRawId, b3Raw)
|
|
-- altrimenti sega a catena
|
|
else
|
|
return MakeByChainSaw( Proc, nFacInd, nRawId, b3Raw, dElev, dH, dV)
|
|
end
|
|
end
|
|
local nFacet = EgtIf( vtN:getZ() >= WD.NZ_MINA, nFacInd, nFacInd2)
|
|
-- eseguo la svuotatura
|
|
return MakeByPocketing( Proc, nFacet, nRawId, b3Raw, true)
|
|
-- fessura verticale
|
|
elseif Proc.Stype == 3 then
|
|
-- riordino le facce come contorno libero da lavorare a destra (sono una U)
|
|
-- porto la faccia centrale in seconda posizione (indice 1)
|
|
local nFacInd = WL.GetFaceWithMostAdj( Proc.Id, Proc.PartId)
|
|
if nFacInd ~= 1 then
|
|
EgtSurfTmSwapFacets( Proc.Id, 1, nFacInd)
|
|
end
|
|
-- verifico se la prima (indice 0) la deve precedere o seguire
|
|
local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
|
|
local bAdj, ptAdj, _, _ = EgtSurfTmFacetsContact( Proc.Id, 0, 1, GDB_ID.ROOT)
|
|
if bAdj and ( vtN ^ ( ptAdj - ptC)) * Z_AX() < 0 then
|
|
EgtSurfTmSwapFacets( Proc.Id, 0, 2)
|
|
end
|
|
-- applico lavorazione di contorno libero
|
|
return FreeContour.Make( Proc, nRawId, b3Raw)
|
|
-- tunnel
|
|
elseif Proc.Stype == 4 then
|
|
-- riordino le facce come contorno libero da lavorare a destra (formano un anello chiuso e quindi posso partire da una qualunque)
|
|
for i = 1, Proc.Fct - 2 do
|
|
local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, i - 1, GDB_ID.ROOT)
|
|
for j = i + 1, Proc.Fct do
|
|
local bAdj, ptAdj, _, _ = EgtSurfTmFacetsContact( Proc.Id, i - 1, j - 1, GDB_ID.ROOT)
|
|
if bAdj and ( vtN ^ ( ptAdj - ptC)) * Z_AX() > 0 then
|
|
if i ~= j - 1 then
|
|
EgtSurfTmSwapFacets( Proc.Id, i, j - 1)
|
|
end
|
|
break
|
|
end
|
|
end
|
|
end
|
|
-- applico lavorazione di contorno libero
|
|
return FreeContour.Make( Proc, nRawId, b3Raw)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- Applicazione della lavorazione
|
|
function WPL.Make( Proc, nRawId, b3Raw)
|
|
if Proc.Fct == 1 then
|
|
return MakeOneFace( Proc, nRawId, b3Raw)
|
|
elseif Proc.Fct == 2 then
|
|
return MakeTwoFaces( Proc, nRawId, b3Raw)
|
|
else
|
|
return MakeMoreFaces( Proc, nRawId, b3Raw)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
return WPL
|