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

DataBeam :

Browse Source 
- primo rilascio.
This commit is contained in:
Dario Sassi
2019-04-01 15:18:51 +00:00
parent ab6345a4ba
commit 6eaba8a577
51 changed files with 7856 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
LuaLibs/DiceCut.lua
+501
View File
@@ -0,0 +1,501 @@
-- DiceCut.lua by Egaltech s.r.l. 2018/11/26
-- Gestione dei piano paralleli nei tagli lunghi
-- Tabella per definizione modulo
local DiceCut = {}
-- Include
require( 'EgtBase')
EgtOutLog( ' DiceCut started', 1)
-- Dati
local BD = require( 'BeamData')
----------------------------------------------------------------------------------------------------------------------------------------------------
-- creo i piani paralleli
-- GetParallelPlanes: restituisce un vettore con gli indici delle superfici
-- nParent: il layer
-- BBoxRawPart: il grezzo della barra
-- ptC: il punto centrale del piano della feature
-- vtN: il versore normale del piano della feature
-- nCopyPlane: 0 => genera una copia del piano passato, 1=> non genera una copia del piano passato
-- dOffset: offset dei piani paralleli
-- nStep: numero massimo di step
-- Color: colre del fascio di piani
-- dTolerance*: distanza tra i piani paralleli e i piani di taglio (se non esistono altre superfici può essere omesso)
-- bNoTolOnFirstCut*: elimina la tolleranza per il primo piano del fascio (se non esistono altre superfici può essere omesso)
-- ptCCut*: il punto centrale della superfice limitante (se non esistono altre superfici può essere omesso)
-- vtNCut*: il punto centrale della superfice limitante (se non esistono altre superfici può essere omesso)
-- ptCCut1*: il punto centrale della superfice limitante (se non esistono altre superfici può essere omesso)
-- vtNCut1*: il punto centrale della superfice limitante (se non esistono altre superfici può essere omesso)
local function GetParallelPlanes( nParent, BBoxRawPart, ptC, vtN, nCopyPlane, dOffset, nStep, Color, dTolerance, bNoTolOnFirstCut, ptCCut, vtNCut, ptCCut1, vtNCut1 )
local ptMyCCut
if ptCCut and vtNCut then
ptMyCCut = Point3d( ptCCut + dTolerance * vtNCut)
end
local ptMyCCut1
if ptCCut1 and vtNCut1 then
ptMyCCut1 = Point3d( ptCCut1 + 0 * vtNCut1)
end
local TabellaTmSurfParallel = {}
local i = nCopyPlane
while i < nStep do
local SurfId = EgtSurfTmPlaneInBBox( nParent, ptC + ( i * dOffset) * vtN, vtN, BBoxRawPart, GDB_RT.GLOB)
local nFacet = EgtSurfTmFacetCount( SurfId or GDB_ID.NULL)
if nFacet > 0 and vtNCut and ptMyCCut then
if i == nCopyPlane and bNoTolOnFirstCut then
EgtCutSurfTmPlane( SurfId, ptCCut, -vtNCut, false, GDB_RT.GLOB)
else
EgtCutSurfTmPlane( SurfId, ptMyCCut, -vtNCut, false, GDB_RT.GLOB)
end
nFacet = EgtSurfTmFacetCount( SurfId)
end
if nFacet > 0 and vtNCut1 and ptMyCCut1 then
if i == nCopyPlane and bNoTolOnFirstCut then
EgtCutSurfTmPlane( SurfId, ptCCut1, -vtNCut1, false, GDB_RT.GLOB)
else
EgtCutSurfTmPlane( SurfId, ptMyCCut1, -vtNCut1, false, GDB_RT.GLOB)
end
nFacet = EgtSurfTmFacetCount( SurfId)
end
if nFacet > 0 then
table.insert( TabellaTmSurfParallel, SurfId)
EgtSetColor( SurfId, Color)
else
EgtErase( SurfId)
break
end
i = i + 1
end
return TabellaTmSurfParallel
end
----------------------------------------------------------------------------------------------------------------------------------------------------
-- GetOrderedCutTable:
-- nParent: il layer
-- TabParallelPlanes: tabella delle superfici dei piani paralleli
-- TabOrtoPlanes: tabella delle superfici dei piani ortogonali
-- stampo l'ordine dei piani di taglio (prima tagli ortogonali piu' esterni poi taglio parallelo collettivo)
local function GetOrderedCutTable( nParent, TabParallelPlanes, TabOrtoPlanes)
local StepParallel = #TabParallelPlanes
local StepOrto = #TabOrtoPlanes
local TabellaOrderParallelCut1 = {}
for IndexTmP=1, StepParallel do
TabellaOrderParallelCut1[IndexTmP] = {}
for IndexOrto=1, StepOrto do
local ptOrtoN, vtNOrtoN = EgtSurfTmFacetCenter( TabOrtoPlanes[IndexOrto ], 0, GDB_ID.ROOT)
local Copy1Id = EgtCopySurfTmFacet( TabParallelPlanes[IndexTmP], 0, nParent)
local Copy2Id = EgtCopySurfTmFacet( TabParallelPlanes[IndexTmP], 0, nParent)
if Copy1Id and ptOrtoN then
EgtCutSurfTmPlane( Copy1Id, ptOrtoN, -vtNOrtoN, false, GDB_RT.GLOB)
EgtCutSurfTmPlane( Copy2Id, ptOrtoN, vtNOrtoN, false, GDB_RT.GLOB)
local nFacet1 = EgtSurfTmFacetCount( Copy1Id)
local nFacet2 = EgtSurfTmFacetCount( Copy2Id)
if nFacet1 < 1 then
EgtErase( Copy1Id)
EgtErase( Copy2Id)
EgtCutSurfTmPlane( TabParallelPlanes[IndexTmP], ptOrtoN, vtNOrtoN, false, GDB_RT.GLOB)
elseif nFacet2 < 1 then
EgtErase( Copy1Id)
EgtErase( Copy2Id)
break
else
table.insert( TabellaOrderParallelCut1[IndexTmP], Copy1Id)
EgtErase( Copy2Id)
EgtCutSurfTmPlane( TabParallelPlanes[IndexTmP], ptOrtoN, vtNOrtoN, false, GDB_RT.GLOB)
end
end
end
table.insert(TabellaOrderParallelCut1[IndexTmP], TabParallelPlanes[IndexTmP])
end
return TabellaOrderParallelCut1
end
----------------------------------------------------------------------------------------------------------------------------------------------------
-- GetOrtoCutCenter:
-- idFacet: l'id della faccia
-- ptC: il punto centrale della faccia
-- vtN: il versore normale della faccia
-- vtO: il versore dei piani ortogonali
-- dOffsetEff: offset della distanza dal punto centrale
-- Verifica se l'asse X del box costruito sopra la superficie è più grande di un certo offset
local function GetOrtoCutCenter( FacetId, ptC, vtN, vtO, dOffsetEff)
-- riferimento intrinseco
local asseX = vtO
local asseY = asseX ^ vtN
local Frame = Frame3d( ptC, ptC + asseX, ptC + asseY)
-- ingombro della faccia secondo questo riferimento
local Box = EgtGetBBoxRef( FacetId, GDB_BB.STANDARD, Frame)
local dLen = Box:getDimX()
local dWidth = Box:getDimY()
if dLen < dOffsetEff + 1.0 or dWidth < dOffsetEff + 1.0 then
return nil, nil, nil
end
local N = ceil( dLen / dOffsetEff)
local dOffsetRel = dLen / N
local dCopyPlane
local dCenOffs = ( Box:getMax():getX() + Box:getMin():getX()) / 2
if dLen <= dOffsetRel then
dOffsetRel = 0
dCopyPlane = 1
elseif dLen <= 2 * dOffsetRel then
dOffsetRel = 0
dCopyPlane = 0
else
if N % 2 == 0 then
dCopyPlane = 0
elseif N % 2 == 1 then
dCopyPlane = 0.5
end
end
return dOffsetRel, dCopyPlane, dCenOffs
end
----------------------------------------------------------------------------------------------------------------------------------------------------
-- TableMesh:
-- TableOrto: tabella delle superfici dei piani ortogonali
-- TableParallel: tabella delle superfici dei piani paralleli
-- Forma una tabella unica delle superfici di taglio inserendo strati di tagli ortogonali alternati da strati di taglio parallelo
local function TableMesh( TableOrto, TableParallel)
local TableUnited = {}
for i=1, #TableOrto do
table.insert( TableUnited, TableOrto[i])
table.insert( TableUnited, TableParallel[i])
end
return TableUnited
end
----------------------------------------------------------------------------------------------------------------------------------------------------
-- FindValue:
-- tab: tabella da scansionare
-- val: valore da cercare
-- Verifica se tab contiene val, a supporto della funzione SortOrtoCutsByNormalMethod
local function FindValue( tab, val)
for index, value in ipairs( tab) do
if value == val then
return true
end
end
return false
end
----------------------------------------------------------------------------------------------------------------------------------------------------
-- SortOrtoCutsByNormalMethod:
-- TabParallelPlanes: tabella delle superfici dei piani paralleli
-- TabOrtoPlanes: tabella delle superfici dei piani ortogonali
-- stampo l'ordine dei piani di taglio sfruttando il prodotto dei versori normali (prima tagli ortogonali piu' esterni poi taglio parallelo collettivo)
local function SortOrtoCutsByNormalMethod( TabParallelPlanes, TabOrtoPlanes)
-- tabella dei tagli ordinati
local TabOrderOrtoCut = {}
-- tabella ausiliaria dei dati inseriti nell'ordine
local TabAux = {}
-- ciclo di ordinamento
local StepParallel = #TabParallelPlanes
local StepOrto = #TabOrtoPlanes
for IndexTmP=1, StepParallel do
TabOrderOrtoCut[IndexTmP] = {}
local ptParalN, vtNParalN = EgtSurfTmFacetCenter( TabParallelPlanes[IndexTmP][1], 0, GDB_ID.ROOT)
for IndexOrto=1, StepOrto do
for i=1, #TabOrtoPlanes[IndexOrto] do
-- identificativo del taglio
local OrtoPlaneId = TabOrtoPlanes[IndexOrto][i]
-- controlla che l'elemento da valutare non sia gia' stato inserito nella tabella
if not FindValue( TabAux, OrtoPlaneId) then
local ptOrtoN, vtNOrtoN = EgtSurfTmFacetCenter( OrtoPlaneId, 0, GDB_ID.ROOT)
local scalarProduct = ( ptOrtoN - ptParalN) * vtNParalN
if scalarProduct > 0 then
table.insert( TabOrderOrtoCut[IndexTmP], OrtoPlaneId)
table.insert( TabAux, OrtoPlaneId)
end
end
end
end
end
-- cancello dal DB geometrico i tagli non inseriti
for IndexOrto=1, StepOrto do
for i=1, #TabOrtoPlanes[IndexOrto] do
-- identificativo del taglio
local OrtoPlaneId = TabOrtoPlanes[IndexOrto][i]
-- ricerco il taglio tra gli inseriti
if not FindValue( TabAux, OrtoPlaneId) then
EgtErase( OrtoPlaneId)
end
end
end
return TabOrderOrtoCut
end
----------------------------------------------------------------------------------------------------------------------------------------------------
-- GetSurfSum:
-- CutTable: tabella dei tagli
-- OffsetP: offset della distanza dal punto centrale
-- BBoxRawPart: il grezzo della barra
-- Verifica se l'asse X del box costruito sopra le 2 facce è più piccolo di un certo offset e quindi la faccia 12 è superflua
local function GetSurfSum( CutTable, OffsetP, BBoxRawPart)
if not CutTable[1] or not CutTable[2] then return end
local Cut1Id = CutTable[2][1]
local Cut2Id = CutTable[2][2]
local Cut12Id = CutTable[1][1]
if Cut1Id and Cut2Id and Cut12Id then
local ptC1, vtN1 = EgtSurfTmFacetCenter( Cut1Id, 0, GDB_ID.ROOT)
local _, vtO = EgtSurfTmFacetCenter( Cut12Id, 0, GDB_ID.ROOT)
vtO = vtO - vtO * vtN1 * vtN1 ; vtO:normalize()
local asseX1 = vtO
local asseY1 = vtN1 ^ asseX1
local Frame1 = Frame3d( ptC1, ptC1+asseX1, ptC1+asseY1)
local Box1 = EgtGetBBoxRef( Cut1Id, GDB_BB.STANDARD, Frame1)
local x1 = Box1:getDimX()
local ptC2, vtN2 = EgtSurfTmFacetCenter( Cut2Id, 0, GDB_ID.ROOT)
local asseX2 = vtO
local asseY2 = vtN2 ^ asseX2
local Frame2 = Frame3d( ptC2, ptC2+asseX2, ptC2+asseY2)
local Box2 = EgtGetBBoxRef( Cut2Id, GDB_BB.STANDARD, Frame2)
local x2 = Box2:getDimX()
local dLongSize = x1 + x2
if dLongSize <= OffsetP + 1.0 then
local nParent = EgtGetParent( Cut1Id)
local SurfId = EgtSurfTmBySewing( nParent, { Cut1Id, Cut2Id})
EgtSetColor( SurfId, Color3d( FUCHSIA(), 60))
EgtErase( Cut12Id)
table.remove( CutTable[1], 1)
table.remove( CutTable[2], 1)
table.remove( CutTable[2], 1)
table.insert( CutTable[2], 1, SurfId)
end
end
end
----------------------------------------------------------------------------------------------------------------------------------------------------
-- DiceCut.GetDice :
-- nParent: il layer
-- BBoxRawPart: il grezzo della barra
-- ptCPlanes: il punto centrale del piano della feature
-- vtNPlanes: il versore normale del piano della feature
-- bGetOrtoPlanes*: se voglio calcolare i piani ortogonali al piano passato (se non esistono altre superfici può essere omesso)
-- ptCBond*: il punto centrale della superfice limitante (se non esistono altre superfici può essere omesso)
-- vtNBond*: il versore normale della superfice limitante (se non esistono altre superfici può essere omesso)
----------------------------------------------------------------------------------------------------------------------------------------------------
function DiceCut.GetDice( nParent, BBoxRawPart, ptCPlanes, vtNPlanes, bGetOrtoPlanes, ptCBond, vtNBond)
local dTolerance = 0 -- distanza di sicurezza per i tagli ortogonali
local OffsetP = BD.MAX_DIM_DICE -- distanza tra i piani paralleli
local StepP = 10 -- numero massimo di piani paralleli da generare
local OffsetO = BD.MAX_DIM_DICE -- distanza tra i piani ortogonali
local StepO = 10 -- numero massimo di piani ortogonali da generare
-- se normali senza componenti in Y, uso per offset i limiti dei tagli di testa e coda
if abs( vtNPlanes:getY()) < 0.1 and ( not vtNBond or abs( vtNBond:getY()) < 0.1) then
OffsetP = BD.MAX_DIM_HTCUT
OffsetO = BD.MAX_DIM_HTCUT
end
-- aggiungo piccolo extra agli offset
OffsetP = OffsetP + 10 * GEO.EPS_SMALL
OffsetO = OffsetO + 10 * GEO.EPS_SMALL
-- se seconda faccia non definita, forzo calcolo piani ortogonali
if not ptCBond or not vtNBond then
bGetOrtoPlanes = true
end
-- se piani non ortogonali, diminuisco la distanza di offset opportunamente
local originalOffsetP = OffsetP
if not bGetOrtoPlanes then
local dCoeff = ( vtNPlanes ^ vtNBond):len()
OffsetP = OffsetP * dCoeff
OffsetO = OffsetO * dCoeff
end
-- elenco di tutte le superfici generate dai tagli
local TabFUCHSIA = {}
local TabGREEN = {}
-- PIANI PARALLELI alla faccia di taglio
local TabellaTmSurfP = {}
local TabFromIn = GetParallelPlanes( nParent, BBoxRawPart, ptCPlanes, vtNPlanes, 0, OffsetP, StepP, Color3d( FUCHSIA(), 60), dTolerance, true, ptCBond, vtNBond)
for i = #TabFromIn, 1, -1 do
table.insert( TabellaTmSurfP, TabFromIn[i])
end
-- PIANI ORTOGONALI alla faccia di taglio
-- orientamento definito da seconda faccia
if not bGetOrtoPlanes then
local TabellaTmSurfOrto = {}
local TabFromIn = GetParallelPlanes( nParent, BBoxRawPart, ptCBond, vtNBond, 0, OffsetO, StepO, Color3d( GREEN(), 60), dTolerance, false, ptCPlanes, vtNPlanes)
for i = #TabFromIn, 1, -1 do
table.insert( TabellaTmSurfOrto, TabFromIn[i])
end
local TabellaOrderParallelCut = GetOrderedCutTable( nParent, TabellaTmSurfP, TabellaTmSurfOrto) -- Ottiene la tabella dei tagli paralleli ordinati
local TabellaOrderOrtoCut = GetOrderedCutTable( nParent, TabellaTmSurfOrto, TabellaTmSurfP) -- Ottiene la tabella dei tagli ortogonali da riordinare per strato
TabGREEN = SortOrtoCutsByNormalMethod( TabellaOrderParallelCut, TabellaOrderOrtoCut) -- I tagli ortogonali vengono ordinati per strato
TabFUCHSIA = TabellaOrderParallelCut -- I tagli paralleli sono già ordinati
-- orientamento da definire
else
for PlnInd = 1, #TabellaTmSurfP do
-- piano interno
local ptCInner, vtNInner = EgtSurfTmFacetCenter( TabellaTmSurfP[PlnInd], 0, GDB_ID.ROOT)
-- eventuale piano esterno
local ptCOuter, vtNOuter = nil, nil
if PlnInd > 1 then
ptCOuter, vtNOuter = EgtSurfTmFacetCenter( TabellaTmSurfP[PlnInd-1], 0, GDB_ID.ROOT)
vtNOuter = -vtNOuter
end
-- calcolo la direzione dei piano ortogonali
local vtO = VectorFromUprightOrtho( vtNInner)
vtO:rotate( vtNInner, 90)
-- calcolo le dimensioni dell'offset e se dove posizionare la prima faccia:
-- CopyPlane: 0 => crea la prima faccia direttamente sul punto passato
-- CopyPlane: 1 => crea la prima faccia e tutte le altre con l'offset passato
-- CopyPlane: 0.5 => crea la prima faccia a metà offset e tutte le altre con l'offest intero
local OffsetRel, CopyPlane, dCenOffs = GetOrtoCutCenter( TabellaTmSurfP[PlnInd], ptCInner, vtNInner, vtO, OffsetO)
if OffsetRel and CopyPlane and dCenOffs then
ptCInner = ptCInner + dCenOffs * vtO
local TabRight = GetParallelPlanes( nParent, BBoxRawPart, ptCInner, vtO, CopyPlane, -OffsetO, StepO, Color3d( GREEN(), 60),
dTolerance, false, ptCInner, vtNInner, ptCOuter, vtNOuter)
if CopyPlane == 0 then
CopyPlane = 1
end
local TabLeft = GetParallelPlanes( nParent, BBoxRawPart, ptCInner, vtO, CopyPlane, OffsetO, StepO, Color3d( GREEN(), 60),
dTolerance, false, ptCInner, vtNInner, ptCOuter, vtNOuter)
-- carico la tabella con gli indici riordinati
local TempOrtoTab = {}
for i = #TabLeft, 1, -1 do
table.insert( TempOrtoTab, TabLeft[i])
end
for i = 1, #TabRight do
table.insert( TempOrtoTab, TabRight[i])
end
-- creo una tabella per ogni piano per generare i tagli sulla Inner
local TempParTab = GetOrderedCutTable( nParent, {TabellaTmSurfP[PlnInd]}, TempOrtoTab)
for i = 1, #TempParTab do
table.insert( TabFUCHSIA, TempParTab[i])
end
table.insert( TabGREEN, TempOrtoTab)
else
table.insert( TabFUCHSIA, {TabellaTmSurfP[PlnInd]})
table.insert( TabGREEN, {})
end
end
end
-- Se sono state costruite non più di una faccia parallela e una faccia perpendicolare, allora non servono e tengo le originali
if #TabGREEN == 1 and #TabGREEN[1] <= 1 and #TabFUCHSIA == 1 and #TabFUCHSIA[1] <= 1 then
if #TabGREEN[1] == 1 then
EgtErase( TabGREEN[1][1])
end
TabGREEN = {}
if #TabFUCHSIA[1] == 1 then
EgtErase( TabFUCHSIA[1][1])
end
TabFUCHSIA = {}
end
-- Si uniscono le tabelle dei tagli ortogonali e paralleli in una sola tabella
local UltimateTable = TableMesh( TabGREEN, TabFUCHSIA)
-- Se esiste la superficie limitante (nFacet == 2) verifica se il taglio più esterno è superfluo e quindi viene eliminato
if not bGetOrtoPlanes then
GetSurfSum( UltimateTable, originalOffsetP, BBoxRawPart)
end
return UltimateTable
end
----------------------------------------------------------------------------------------------------------------------------------------------------
-- PrintOrderCut:
-- TabellaOrderCut: tabella delle superfici di taglio
-- stampo l'ordine dei piani di taglio ricevendo una tabella con gli strati parallelo/ortogonali già ordinati
function DiceCut.PrintOrderCut( TabellaOrderCut)
local Step = #TabellaOrderCut
if Step > 0 then
EgtOutLog( " L'ordine delle superfici da tagliare è il seguente:")
else
EgtOutLog( ' Non sono necessarie superfici aggiuntive di taglio.')
end
for i = 1, Step do
if i % 2 == 1 then
EgtOutLog( ' *** Strato di taglio ' .. EgtNumToString( ( i + 1) / 2, 0))
if #TabellaOrderCut[i] > 0 then
EgtOutLog( ' Tagli ortogonali: ')
else
EgtOutLog( ' Tagli ortogonali assenti')
end
else
if #TabellaOrderCut[i] > 0 then
EgtOutLog( ' Tagli paralleli: ')
else
EgtOutLog( ' Tagli paralleli assenti')
end
end
for j=1, #TabellaOrderCut[i] do
EgtOutLog( ' Indice faccia ' .. (TabellaOrderCut[i][j] or 0))
end
end
end
----------------------------------------------------------------------------------------------------------------------------------------------------
local function DiceCutTest()
-- salvo l'indice del layer Trimesh selezionato
local SelectedIndex = EgtGetFirstSelectedObj()
-- verifico che sia selezionato un elemento
if not SelectedIndex then return end
-- salvo l'indice del layer Processing
local nParent = EgtGetParent( SelectedIndex)
-- salvo l'indice del layer Part
local nRawPart = EgtGetParent( nParent)
local nBox = EgtGetFirstNameInGroup( nRawPart, 'Box')
-- carico il bounding box della trave
-- local BBoxRawPart = EgtGetBBoxGlob( nRawPart, GDB_BB.STANDARD )
local BBoxRawPart = EgtGetBBoxGlob( nBox, GDB_BB.STANDARD )
-- seleziono il Part e il Layer di destinazione
EgtSetCurrPartLayer( nRawPart, nParent)
-- conto il numero di facce da processare
local nFacet = EgtSurfTmFacetCount( SelectedIndex)
EgtOutLog( ' Numero facce ' .. nFacet, 1)
-- salvo
local TabPlanesFeatures = {}
for i = 1, nFacet do
local ptC, vtN = EgtSurfTmFacetCenter( SelectedIndex, i - 1, GDB_ID.ROOT)
table.insert( TabPlanesFeatures, { ptC = ptC, vtN = vtN})
end
local ptC1 = Point3d( TabPlanesFeatures[1].ptC)
local vtN1 = Vector3d( TabPlanesFeatures[1].vtN)
local CutTable = {}
if nFacet == 1 then
CutTable = DiceCut.GetDice( nParent, BBoxRawPart, ptC1, vtN1, true)
elseif nFacet == 2 then
CutTable = DiceCut.GetDice( nParent, BBoxRawPart, ptC1, vtN1, false, TabPlanesFeatures[2].ptC, TabPlanesFeatures[2].vtN)
end
if EgtGetDebugLevel() > 1 then
DiceCut.PrintOrderCut( CutTable)
end
EgtDeselectAll()
EgtDraw()
end
----------------------------------------------------------------------------------------------------------------------------------------------------
--DiceCutTest()
return DiceCut