Daniele Bariletti
cb1f1ab08b
- utilizzati solo nomi per salvare le info - aggiunta la possibilità di avere fino a due paretine sullo stesso lato - possibilità fare paretine sui loop interni - correzione nella gestione degli offset - possiiblità di avere più loop interni.
1115 lines
48 KiB
Lua
1115 lines
48 KiB
Lua
-- 2024/11/22
|
|
-- Template per la creazione di un cabinet
|
|
|
|
-- Intestazioni
|
|
require( 'EgtBase')
|
|
_ENV = EgtProtectGlobal()
|
|
EgtEnableDebug( false)
|
|
|
|
-------------------------------------------------------------------------------------------------------------------------
|
|
-- FUNZIONI BASE PER GENERARE I COMPO SOLID INIZIO
|
|
-------------------------------------------------------------------------------------------------------------------------
|
|
|
|
local TOOL = {}
|
|
|
|
_G.TOOL = TOOL
|
|
|
|
TOOL.nId = nil -- id del part della paretina che si sta costruendo
|
|
TOOL.nLayLoopParent = nil -- layer contenente il loop da cui si sta creando la paretina (appartenente al parent)
|
|
TOOL.nLayLoop = nil -- layer dell'outloop del nuovo part in creazione
|
|
TOOL.nEdgeId = nil -- indice dell'edge che si sta usando per creare la paretina
|
|
TOOL.nEdge = nil -- numero ordinale (1-based, per poterlo usare direttamente per trovare il lato "A1") per l'edge nel layer del loop
|
|
TOOL.tbInfo = {} -- tabella contenente tutte le informazioni del part corrente
|
|
TOOL.nParent = nil -- id del parent
|
|
TOOL.nPrevId = nil -- id della paretina precedente alla corrente
|
|
TOOL.nNextId = nil -- id della paretina successiva alla corrente
|
|
TOOL.nPrev = nil -- numero ordinale della paretina precedente alla corrente
|
|
TOOL.nNext = nil -- numero ordinale della paretina successiva alla corrente
|
|
TOOL.dPairAng = nil -- angolo di accoppiamento
|
|
TOOL.nJunctionType = nil -- tipo di giunzione tra paretine: 1 trim start, 2 trim end, 3 giunzione angolata
|
|
TOOL.bOnLoop = nil -- flag che indica se la faccia buona è adiacente al lato del parent generatore della paretina corrente
|
|
TOOL.dAngBR = nil -- angolo BottomRight della faccia buona della paretina corrente
|
|
TOOL.dSideAngR = nil -- SideAng del lato Right(A2) (il primo lato è il bottom e si procede CCW)
|
|
TOOL.dAngBL = nil -- angolo BottomLeft della faccia buona della paretina corrente
|
|
TOOL.dSideAngL = nil -- SideAng del lato Left(A4) (il primo lato è il bottom e si procede CCW)
|
|
TOOL.dLen = nil -- lunghezza del lato del parent generatore della paretina corrente
|
|
TOOL.dH = nil -- altezza della faccia buona della paretina corrente
|
|
TOOL.dTh = nil -- spessore del part corrente
|
|
TOOL.dThParent = nil -- spessore del parent
|
|
TOOL.dXOffset = nil -- offset del riferimento
|
|
-- TOOL.dBeta1 = nil
|
|
-- TOOL.dBeta2 = nil
|
|
TOOL.sName = nil -- nome del part corrente, incluso il codice univoco(es: sUNICode.."PartA1")
|
|
TOOL.bPrev = nil -- booleano che indica se modificare anche la paretina successiva, in conseguenza delle modifica a quella corrente
|
|
TOOL.bNext = nil -- booleano che indica se modificare anche la paretina precedente, in conseguenza delle modifica a quella corrente
|
|
|
|
|
|
-- info addizionali che potrebbero esserci nella tbInfo
|
|
TOOL.tbInfo.nIn = nil -- intero che esiste solo se il part è stato costruito a partire da un edge di un InLoop e indica a quale degli InLoop(da contare in ordine all'interno del Parent, 1-based)
|
|
TOOL.tbInfo.bOutLoop = nil -- booleano che indica se l'edge su cui è stato costruito il part appartiene all'outloop o ad un inloop del Parent
|
|
|
|
TOOL.tbIdLoop = {} -- tabella con gli id del loop su cui sta venendo costruita la paretina
|
|
|
|
---- creo il codice univoco per l'identificazione dei part
|
|
--TOOL.sUNICode = os.date( '%y%m%d%H%M%S', os.time()).."_"
|
|
|
|
--local sUNICode = TOOL.sUNICode
|
|
|
|
function TOOL.SaveMePlease()
|
|
EgtSaveFile('D:\\Temp\\marmo\\Vein3D\\FOO.nge')
|
|
end
|
|
|
|
local function FindEdges(nLay, tbInfo)
|
|
-- crea una tabella con gli indici degli elementi nel Layer passato (nLay) e
|
|
-- trova l'indice del lato tbInfo.nEdgeId, 1 based, restituito in tbInfo.nEdge
|
|
local tbId = {}
|
|
local nId = EgtGetFirstInGroup(nLay)
|
|
local c = 1
|
|
while nId do
|
|
if tbInfo and tbInfo.nEdgeId ~= GDB_ID.NULL and tbInfo.nEdgeId then
|
|
if nId == tbInfo.nEdgeId then tbInfo.nEdge = c end
|
|
end
|
|
table.insert(tbId, nId)
|
|
nId = EgtGetNext(nId)
|
|
c = c + 1
|
|
end
|
|
return tbId
|
|
end
|
|
|
|
local function FillInfoTable()
|
|
if TOOL.nId then TOOL.tbInfo.nId = TOOL.nId end
|
|
if TOOL.nEdgeId then TOOL.tbInfo.nEdgeId = TOOL.nEdgeId end
|
|
if TOOL.nLayLoopParent and TOOL.nLayLoopParent ~= GDB_ID.NULL then TOOL.tbInfo.nLayLoopParent = TOOL.nLayLoopParent end
|
|
if (not TOOL.tbInfo.nLayLoopParent or TOOL.tbInfo.nLayLoopParent == GDB_ID.NULL) and TOOL.nEdgeId and TOOL.nEdgeId ~= GDB_ID.NULL then EgtGetParent( TOOL.nEdgeId) end
|
|
if TOOL.nParent then TOOL.tbInfo.nParent = TOOL.nParent end
|
|
if (not TOOL.tbInfo.nParent or TOOL.tbInfo.nParent == GDB_ID.NULL) and TOOL.nEdgeId and TOOL.nEdgeId ~= GDB_ID.NULL then EgtGetParent(EgtGetParent( TOOL.nEdgeId)) end
|
|
if TOOL.nPrevId then TOOL.tbInfo.nPrevId = TOOL.nPrevId end
|
|
if TOOL.nNextId then TOOL.tbInfo.nNextId = TOOL.nNextId end
|
|
if TOOL.nJunctionType then TOOL.tbInfo.nJunctionType = TOOL.nJunctionType end
|
|
if TOOL.bOnLoop ~= nil then TOOL.tbInfo.bOnLoop = TOOL.bOnLoop end
|
|
if TOOL.dAngBR then TOOL.tbInfo.dAngBR = TOOL.dAngBR end
|
|
if TOOL.dSideAngR then TOOL.tbInfo.dSideAngR = TOOL.dSideAngR end
|
|
if TOOL.dAngBL then TOOL.tbInfo.dAngBL = TOOL.dAngBL end
|
|
if TOOL.dSideAngL then TOOL.tbInfo.dSideAngL = TOOL.dSideAngL end
|
|
if TOOL.dLen then TOOL.tbInfo.dLen = TOOL.dLen end
|
|
if TOOL.dTh then TOOL.tbInfo.dTh = TOOL.dTh end
|
|
if TOOL.dH then TOOL.tbInfo.dH = TOOL.dH end
|
|
if TOOL.dPairAng then TOOL.tbInfo.dPairAng = TOOL.dPairAng end
|
|
if TOOL.bOnLoop then TOOL.tbInfo.bOnLoop = TOOL.bOnLoop end
|
|
if TOOL.sName then TOOL.tbInfo.sName = TOOL.sName end
|
|
end
|
|
|
|
local function FillInfoTableFromPart(nPartId)
|
|
if not nPartId or nPartId == GDB_ID.NULL then return end
|
|
TOOL.tbInfo.nId = nPartId
|
|
TOOL.tbInfo.nPrevId = EgtGetInfo(nPartId,"Prev", "i")
|
|
TOOL.tbInfo.nNextId = EgtGetInfo(nPartId,"Next", "i")
|
|
TOOL.tbInfo.nJunctionType = EgtGetInfo(nPartId,"JunctionType", "i")
|
|
TOOL.tbInfo.dPairAng = EgtGetInfo(nPartId, "PairAng", "d")
|
|
TOOL.tbInfo.bOnLoop = EgtGetInfo(nPartId,"OnLoop", "b")
|
|
TOOL.tbInfo.dAngBR = EgtGetInfo(nPartId,"AngBR", "d")
|
|
TOOL.tbInfo.dSideAngR = EgtGetInfo(nPartId,"SideAngR", "d")
|
|
TOOL.tbInfo.dAngBL = EgtGetInfo(nPartId,"AngBL", "d")
|
|
TOOL.tbInfo.dSideAngL = EgtGetInfo(nPartId,"SideAngL", "d")
|
|
TOOL.tbInfo.dLen = EgtGetInfo(nPartId,"Len", "d")
|
|
TOOL.tbInfo.dH = EgtGetInfo(nPartId,"H", "d")
|
|
TOOL.tbInfo.dTh = EgtGetInfo(nPartId,"Th", "d")
|
|
TOOL.tbInfo.nEdge = EgtGetInfo(nPartId, "ParentEdge", "i")
|
|
TOOL.tbInfo.bOutLoop = EgtGetInfo(nPartId, "FromOutLoop", "b")
|
|
TOOL.tbInfo.nParent = EgtGetInfo(nPartId, "Parent","i")
|
|
if TOOL.nLayLoopParent then
|
|
TOOL.tbInfo.nLayLoopParent = TOOL.nLayLoopParent
|
|
else
|
|
if TOOL.tbInfo.bOutLoop then
|
|
TOOL.tbInfo.nLayLoopParent = EgtGetFirstNameInGroup(TOOL.tbInfo.nParent, "OutLoop")
|
|
else
|
|
TOOL.tbInfo.nIn = EgtGetInfo(nPartId,"nInLoop", "i")
|
|
local nLay = EgtGetFirstNameInGroup(nPartId, "InLoop")
|
|
if TOOL.tbInfo.nIn then
|
|
local c = 1
|
|
if TOOL.tbInfo.nIn ~=1 then
|
|
while c ~= TOOL.tbInfo.nIn do
|
|
nLay = EgtGetNextName(nLay)
|
|
c = c + 1
|
|
end
|
|
end
|
|
end
|
|
TOOL.tbInfo.nLayLoopParent = nLay
|
|
end
|
|
end
|
|
TOOL.tbInfo.nEdgeId = EgtGetFirstNameInGroup(TOOL.tbInfo.nLayLoopParent, "A"..TOOL.tbInfo.nEdge)
|
|
end
|
|
|
|
function TOOL.WriteDataToChildPart(tbInfo)
|
|
if not tbInfo or not tbInfo.nId then do return end end
|
|
if tbInfo.nParent then EgtSetInfo(tbInfo.nId, 'Parent', tbInfo.nParent) end
|
|
if tbInfo.nEdge then EgtSetInfo(tbInfo.nId, 'ParentEdge', tbInfo.nEdge) end
|
|
if tbInfo.dLen then EgtSetInfo(tbInfo.nId, 'Len', tbInfo.dLen) end
|
|
if tbInfo.dAngDx then EgtSetInfo(tbInfo.nId, 'AngDx', tbInfo.dAngDx) end
|
|
if tbInfo.dAgnSx then EgtSetInfo(tbInfo.nId, 'AngSx', tbInfo.dAngSx) end
|
|
if tbInfo.bOnLoop ~= nil then EgtSetInfo(tbInfo.nId, "OnLoop", tbInfo.bOnLoop) end
|
|
if tbInfo.dH then EgtSetInfo(tbInfo.nId, 'H', tbInfo.dH) end
|
|
if tbInfo.dTh then EgtSetInfo(tbInfo.nId, 'Th', tbInfo.dTh) end
|
|
if tbInfo.nJunctionType then EgtSetInfo(tbInfo.nId, 'JunctionType', tbInfo.nJunctionType) end
|
|
if tbInfo.bOutLoop ~= nil then EgtSetInfo(tbInfo.nId, "FromOutLoop", tbInfo.bOutLoop) end
|
|
if tbInfo.nIn then EgtSetInfo(tbInfo.nId, "nInLoop", tbInfo.nIn) end
|
|
end
|
|
|
|
-- CREAZIONE dei Layer di un singolo Part
|
|
-- I nomi dei layer sono: OutLoop, Region, Ref, Labels, Aux
|
|
function TOOL.CreatePartLayer(PartName)
|
|
-- Pezzo e Layer
|
|
local sUNICode = EgtGetUUID().."_"
|
|
local Pz = EgtGroup(GDB_ID.ROOT,GDB_RT.LOC) -- pezzo
|
|
EgtSetName( Pz, sUNICode..PartName)
|
|
local LOut = EgtGroup(Pz,GDB_RT.LOC) -- layer della figura principale
|
|
EgtSetName(LOut,'OutLoop')
|
|
local LReg = EgtGroup(Pz,GDB_RT.LOC) -- layer regione
|
|
EgtSetName(LReg,'Region')
|
|
local LRef = EgtGroup(Pz,GDB_RT.LOC) -- layer riferimenti
|
|
EgtSetName(LRef,'Ref')
|
|
EgtSetStatus( LRef, GDB_ST.OFF)
|
|
local LLabel= EgtGroup(Pz,GDB_RT.LOC) -- layer etichette
|
|
EgtSetName(LLabel,'Labels')
|
|
local LAux= EgtGroup(Pz,GDB_RT.LOC) -- layer etichette
|
|
EgtSetName(LAux,'Aux')
|
|
EgtOutLog(' Creo Part: '..sUNICode..PartName)
|
|
--SaveMePlease()
|
|
return Pz
|
|
end
|
|
--
|
|
|
|
-- RESTITUISCE una tabella con gli Id dei layer costruiti nella funzione CreatePartLayer part,
|
|
-- Se il nome del Part non esiste restituice nil
|
|
function TOOL.FindLayers( IdPart)
|
|
if not EgtIsPart( IdPart) then
|
|
CMP.ERR = 1
|
|
CMP.MSG = CMP.MSG.." In FindLayers "..tostring(IdPart).." non è un Part"
|
|
return nil
|
|
end
|
|
local tbLayer = {}
|
|
tbLayer['OutLoop'] = EgtGetFirstNameInGroup(IdPart, 'OutLoop')
|
|
tbLayer['Region'] = EgtGetFirstNameInGroup(IdPart, 'Region')
|
|
tbLayer['Ref'] = EgtGetFirstNameInGroup(IdPart, 'Ref')
|
|
tbLayer['Labels'] = EgtGetFirstNameInGroup(IdPart, 'Labels')
|
|
tbLayer['Aux'] = EgtGetFirstNameInGroup(IdPart, 'Aux')
|
|
local nInLoopLay = EgtGetFirstNameInGroup(IdPart, 'InLoop')
|
|
if nInLoopLay then
|
|
tbLayer['InLoop'] = nInLoopLay
|
|
end
|
|
return tbLayer
|
|
end
|
|
--
|
|
|
|
-- ASSEGNO Info per conoscere le direzioni dei lati
|
|
function TOOL.SetMachiningInfo(Layer)
|
|
local LayerName = EgtGetName( Layer)
|
|
-- verifico che sia di tipo In o Out, altrimenti ricerco nel Part il layer
|
|
if not LayerName == 'OutLoop' or not LayerName == 'InLoop' then
|
|
Layer = EgtGetFirstInGroup( Layer)
|
|
CMP.ERR = 2
|
|
CMP.MSG = CMP.MSG.." In SetMachiningInfo il Layer non è di tipo 'OutLoop' o 'InLoop'."
|
|
end
|
|
local nId = EgtGetFirstInGroup(Layer)
|
|
local nPrevId = EgtGetLastInGroup(Layer)
|
|
local nNextId = EgtGetNext(nId)
|
|
local nFirstId = nId
|
|
local nEdges = EgtGetGroupObjs(Layer)
|
|
if nEdges == 1 then
|
|
EgtSetInfo(nId, 'PrevAng', 0)
|
|
EgtSetInfo(nId, 'NextAng', 0)
|
|
return
|
|
end
|
|
for i = 1, nEdges do
|
|
-- recupero i dati
|
|
local vtCurrS = EgtSV(nId, GDB_RT.GLOB)
|
|
local vtPrevE = EgtEV(nPrevId, GDB_RT.GLOB)
|
|
local vtCurrE = EgtEV(nId, GDB_RT.GLOB)
|
|
local vtNextS = EgtSV(nNextId, GDB_RT.GLOB)
|
|
local vtAx = Z_AX()
|
|
--if bInLoop then vtAx=-vtAx end
|
|
local NextAng = GetRotation( vtCurrE, vtNextS, vtAx)
|
|
local PrevAng = GetRotation( vtPrevE, vtCurrS, vtAx)
|
|
-- scrivo le info
|
|
EgtSetInfo(nId, 'PrevAng', PrevAng)
|
|
EgtSetInfo(nId, 'NextAng', NextAng)
|
|
-- aggiorno gli id
|
|
nPrevId = nId
|
|
nId = nNextId
|
|
nNextId = EgtGetNext(nNextId)
|
|
if nNextId == nil then
|
|
nNextId = nFirstId
|
|
end
|
|
end
|
|
end
|
|
--
|
|
|
|
-- DEVO RICEVERE SOLO UN CONTORNO!! Da semplificare
|
|
-- Dato un contorno ricavo i lati nel Layer di appartenenza del contorno
|
|
-- altrimenti se Part ricavo i lati nel loop specificato (Default=OutLoop o InLoop)
|
|
function TOOL.ExplodeAndNameEdges( IdLoop, bInLoop)
|
|
local sNameLayer = ''
|
|
if bInLoop == nil then bInLoop = false end
|
|
if bInLoop then
|
|
sNameLayer = 'InLoop'
|
|
else
|
|
sNameLayer = 'OutLoop'
|
|
end
|
|
if not IdLoop or IdLoop == -1 then end
|
|
-- Se l'Id è un Part
|
|
if EgtIsPart( IdLoop) then
|
|
local tbLayer = TOOL.FindLayers( IdLoop)
|
|
if tbLayer then IdLoop = EgtGetFirstInGroup( tbLayer[sNameLayer]) end
|
|
end
|
|
-- Se l'Id è un Layer
|
|
if EgtIsLayer( IdLoop) then
|
|
local LayerName = EgtGetName( IdLoop)
|
|
-- verifico che sia di tipo In o Out, altrimenti ricerco nel Part il layer
|
|
if LayerName == sNameLayer then
|
|
IdLoop = EgtGetFirstInGroup( IdLoop)
|
|
else
|
|
local tbLayer = TOOL.FindLayers( EgtGetParent(IdLoop))
|
|
if tbLayer then IdLoop = EgtGetFirstInGroup( tbLayer[sNameLayer]) end
|
|
end
|
|
end
|
|
local nLay = EgtGetParent(IdLoop)
|
|
local nEdge, nTotEdges = EgtExplodeCurveCompo(IdLoop)
|
|
local nCount = 1
|
|
local tbIdLoop = {}
|
|
while nEdge do
|
|
local tbName = EgtNumToString(nCount)
|
|
EgtSetName( nEdge, "A"..tbName)
|
|
nCount = nCount + 1
|
|
table.insert( tbIdLoop, nEdge)
|
|
nEdge = EgtGetNext(nEdge)
|
|
end
|
|
-- Ricavo info direzioni
|
|
TOOL.SetMachiningInfo(nLay)
|
|
return tbIdLoop
|
|
end
|
|
--
|
|
|
|
-- CREAZIONE Layer per le dimensioni
|
|
function TOOL.CreateDimensionLayer()
|
|
local Pz = EgtGroup(GDB_ID.ROOT,GDB_RT.LOC) -- layer dimensioni e etichette
|
|
EgtSetName( Pz, 'Dimensions')
|
|
end
|
|
--
|
|
|
|
function TOOL.AddInLoopToPart(nLayLoop)
|
|
-- nLay è il layer contenente il loop da inserire
|
|
-- recupero l'Id del part
|
|
local tbIdEntCrv = FindEdges(nLayLoop)
|
|
local IdPart = EgtGetParent( nLayLoop)
|
|
local tbLayer = TOOL.FindLayers(IdPart)
|
|
-- costruisco il contorno chiuso
|
|
local IdLoop = EgtCurveCompoByChain( nLayLoop, tbIdEntCrv, EgtSP(tbIdEntCrv[1],GDB_RT.GLOB), false, GDB_RT.GLOB)
|
|
-- Nel Layer Region definisco la regione piana
|
|
local IdReg = EgtSurfFlatRegion(tbLayer['Region'],IdLoop)
|
|
-- Se InLoop allora faccio la sottrazione con la regione OutRegion
|
|
|
|
if bInLoop then
|
|
local IdOutRegion = EgtGetPrev(IdReg)
|
|
local vtNorm1 = EgtSurfFrNormVersor(IdOutRegion)
|
|
local vtNorm2 = EgtSurfFrNormVersor(IdReg)
|
|
if AreOppositeVectorApprox( vtNorm1, vtNorm2) then
|
|
EgtInvertSurf(IdReg)
|
|
end
|
|
if not EgtSurfFrSubtract( IdOutRegion,IdReg) then
|
|
CMP.ERR = 5
|
|
CMP.MSG = CMP.MSG.." Sottrazione tra superficie 'OutLoop' "..tostring(IdOutRegion).." e 'InLoop' "..tostring(IdReg).." non riuscita."
|
|
end
|
|
EgtErase(IdReg)
|
|
end
|
|
|
|
-- elimino il contorno chiuso
|
|
EgtErase(IdLoop)
|
|
end
|
|
|
|
-- Per disporre i pezzi in piano non sovrappposti (in assemblaggio non serve)
|
|
local HorizontalOffset = 0
|
|
|
|
-- Creazione del part assegnato un contorno esploso:
|
|
-- tbLayer : tabella dei layer (FindLayers dato il Part)
|
|
-- sName : nome da assegnare in grafica
|
|
-- tbIdEntCrv: tabella delle entità che costituiscono il contorno (da ExplodeAndNameEdges)
|
|
-- dTh : spessore pezzo
|
|
-- dOffset : per messa in piano dei pezzi (0 se non si usa)
|
|
-- bInLoop : tipo di contorno
|
|
function TOOL.CreatePart(nLayLoop, tbPart, bIsPlanar)
|
|
if bIsPlanar == nil then bIsPlanar = false end
|
|
-- se mancano le variabili di input le recupero dalla tabella generale
|
|
if not nLayLoop then
|
|
if TOOL.nLayLoopParent then nLayLoop = TOOL.nLayLoopParent end
|
|
if TOOL.tbInfo.nLayLoop then nLayLoop = TOOL.tbInfo.nLayLoop end
|
|
end
|
|
if not tbPart then tbPart = TOOL.tbInfo end
|
|
|
|
-- recupero l'Id del part
|
|
local tbIdEntCrv = FindEdges(nLayLoop)
|
|
local IdPart = EgtGetParent( nLayLoop)
|
|
local tbLayer = TOOL.FindLayers(IdPart)
|
|
-- local sPartName = EgtGetName(IdPart)
|
|
-- local tbPartName = EgtSplitString(sPartName,"_")
|
|
-- local sName = tbPartName[2]
|
|
|
|
-- costruisco il contorno chiuso
|
|
local IdLoop = EgtCurveCompoByChain( nLayLoop, tbIdEntCrv, EgtSP(tbIdEntCrv[1],GDB_RT.GLOB), false, GDB_RT.GLOB)
|
|
-- Nel Layer Region definisco la regione piana
|
|
local IdReg = EgtSurfFlatRegion(tbLayer['Region'],IdLoop)
|
|
-- elimino il contorno chiuso
|
|
EgtErase(IdLoop)
|
|
|
|
-- scrivo nel part le informazioni di costruzione
|
|
TOOL.WriteDataToChildPart(tbPart)
|
|
-- INFO NECESSARIA
|
|
EgtSetInfo(IdPart, 'Paired',tostring(IdPart))
|
|
|
|
-- inserisco le etichette del pezzo nel centro della superofocie
|
|
local ptTop = EgtCP( IdReg, GDB_RT.GLOB)
|
|
local ptBottom = Point3d( ptTop:getX(), -ptTop:getY(), tbPart.dTh)
|
|
local tbNamePart = EgtSplitString(tbPart.sName, "_")
|
|
-- al nome del part tolgo il codice univoco
|
|
local sNamePart = tbNamePart[2]
|
|
EgtTextAdv(tbLayer['Labels'], ptTop,0,sNamePart, '', 10, '', 15,1.5,0,GDB_TI.MC)
|
|
if not bIsPlanar then
|
|
EgtSetGridFrame(Frame3d(ORIG(),GDB_FR.BOTTOM))
|
|
EgtTextAdv(tbLayer['Labels'], ptBottom,0,sNamePart, '', 10, '', 15,1.5,0,GDB_TI.MC, GDB_RT.GRID)
|
|
EgtSetGridFrame(Frame3d(ORIG(),GDB_FR.TOP))
|
|
end
|
|
-- dispongo il pezzo in piano
|
|
local vtMove = Vector3d({HorizontalOffset,0,0})
|
|
--EgtMove(IdPart,vtMove, GDB_RT.GLOB)
|
|
HorizontalOffset = HorizontalOffset + ptTop:getX() + 10
|
|
end
|
|
--
|
|
|
|
-- Sposto l'etichetta del nome del Part nel Solido associato
|
|
function TOOL.RelocateLabels()
|
|
local nPartId = EgtGetFirstPart()
|
|
while nPartId do
|
|
local nChild = EgtGetInfo(nPartId, 'Child','i')
|
|
if nChild then
|
|
local nLaySource = EgtGetFirstNameInGroup(nPartId, 'Labels')
|
|
if nLaySource then EgtRelocateGlob( nLaySource, nChild) end
|
|
end
|
|
nPartId = EgtGetNext(nPartId)
|
|
end
|
|
end
|
|
--
|
|
|
|
-- Crea una copia dello spigolo e lo salva nel layer Ref
|
|
-- Nome del Layer (OutLoop o InLoop),
|
|
-- Nome dello spigolo,
|
|
-- Nome della copia riferimento
|
|
-- Info per spostamento Ref in funzione di una variabile
|
|
function TOOL.CreateReference( IdPart, sNameLayer,sNameEdge, nIn, dVar, sDir, sPartPairingName)
|
|
local tbLayer = TOOL.FindLayers( IdPart)
|
|
--accoppiamento di left su bottom
|
|
local IdEnt = EgtGetFirstNameInGroup(tbLayer[sNameLayer], sNameEdge)
|
|
-- se l'edge è in un Inloop e sono presenti più inloop nel Parent allora uso l'indice nIn per scorrere fino all'Inloop giusto
|
|
if nIn and nIn ~= 1 then
|
|
local nLay = EgtGetFirstNameInGroup(IdPart, sNameLayer)
|
|
for i = 1, nIn do
|
|
nLay = EgtGetNextName(nLay)
|
|
end
|
|
IdEnt = EgtGetFirstNameInGroup(nLay, sNameEdge)
|
|
end
|
|
if not IdEnt then
|
|
CMP.ERR=6
|
|
CMP.MSG= CMP.MSG..' Non esiste il lato '..sNameEdge..' nel layer '..sNameLayer..' del part '..sNamePart
|
|
return
|
|
end
|
|
-- creo la copia dello spigolo come riferimento
|
|
local IdRef = EgtCopy( IdEnt, tbLayer['Ref'])
|
|
EgtSetInfo(IdRef, "OrigEdge", IdEnt)
|
|
local nNumRef = EgtGetGroupObjs(tbLayer['Ref']) + 1
|
|
local sNameRef = "R"..tostring(nNumRef)
|
|
-- verifico che non esista già un altro ref con questo nome
|
|
local nIdRefDb= EgtGetFirstNameInGroup( tbLayer['Ref'], sNameRef)
|
|
while nIdRefDb do
|
|
nNumRef = nNumRef + 1
|
|
sNameRef = "R"..tostring(nNumRef)
|
|
nIdRefDb= EgtGetFirstNameInGroup( tbLayer['Ref'], sNameRef)
|
|
end
|
|
EgtSetName( IdRef, sNameRef)
|
|
if dVar and sDir then
|
|
EgtSetInfo(IdRef, 'Var', dVar)
|
|
EgtSetInfo(IdRef, 'Dir', sDir)
|
|
end
|
|
-- salvo nel riferimento il nome dell'edge da cui discende: A1 se da un outloop, A1_I1 se dal primo Inloop
|
|
if nIn then sNameEdge = sNameEdge.."_"..tostring(nIn) end
|
|
EgtSetInfo(IdRef, "Orig", sNameEdge)
|
|
-- salvo nel riferimento il nome del part che lo userà per associarsi ad IdPart (questa operazione la faccio solo per il riferimento del part destinatario)
|
|
if sPartPairingName then EgtSetInfo(IdRef,"PartPairing", sPartPairingName) end
|
|
-- devo controllare se il part a cui sto aggiungendo il riferimento ha già il solido allora devo applicare l'offset al riferimento!
|
|
-- (che altrimenti verrebbe fatto alla creazione del solido)
|
|
local nChild = EgtGetInfo(IdPart, "Child", "i")
|
|
if nChild then
|
|
SLD.CurrId = IdPart
|
|
SLD.CorrectReference()
|
|
end
|
|
|
|
return IdRef
|
|
end
|
|
--
|
|
|
|
-- Crea una copia dello del punto dello spigolo e lo salva nel layer Ref
|
|
-- Nome del part (da tbName[1]),
|
|
-- Nome del Layer (OutLoop o InLoop),
|
|
-- Nome dello spigolo,
|
|
-- Nome della copia punto
|
|
-- Tipo di punto: 0/nil START, 1 END, 2 MID
|
|
function TOOL.CreatePointReference( sNamePart, sNameLayer,sNameEdge, sNameRef, nTypePt)
|
|
local IdPart = EgtGetFirstNameInGroup(GDB_ID.ROOT, sNamePart)
|
|
local tbLayer = TOOL.FindLayers( IdPart)
|
|
--accoppiamento di left su bottom
|
|
local IdEnt = EgtGetFirstNameInGroup(tbLayer[sNameLayer], sNameEdge)
|
|
if not IdEnt then
|
|
CMP.ERR=6
|
|
CMP.MSG= CMP.MSG..' Non esiste il lato '..sNameEdge..' nel layer '..sNameLayer..' del part '..sNamePart
|
|
return
|
|
end
|
|
local pt = EgtSP(IdEnt, GDB_RT.GLOB)
|
|
if nTypePt == 1 then
|
|
pt = EgtEP(IdEnt, GDB_RT.GLOB)
|
|
elseif nTypePt == 2 then
|
|
pt = EgtMP(IdEnt, GDB_RT.GLOB)
|
|
end
|
|
local IdPtRef = EgtPoint( tbLayer['Ref'], pt, GDB_RT.GLOB)
|
|
EgtSetName(IdPtRef, sNameRef)
|
|
return IdPtRef
|
|
end
|
|
--
|
|
|
|
-- Accoppia lato a riferimento
|
|
-- Nome del pezzo da accoppiare
|
|
-- Nome del riferimento da usare
|
|
-- Nome del pezzo destinatario dell'accoppiamento
|
|
-- Nome del riferimento da usare come destinatario dell'accoppiamento
|
|
-- Concordanza del verso dei due spigoli
|
|
-- Angolo relativo tra i due pezzi: porta la normale della regione del pezzo corrente a coincidere
|
|
-- con la normale della regione del pezzo destinatario; il segno è riferito al verso del riferimento del part destinatario
|
|
-- Modalità di accoppiamento tra gli spigoli (0: start-start, 1:start-end, 2: end-start, 3: end-end, 4: mid-mid)
|
|
function TOOL.SetPairInfo( tbInfo, nIdMyRef, sToNamePart, nIdRefDest, nPairSpin)
|
|
local nPart = tbInfo.nId
|
|
local sNameMyRef = EgtGetName(nIdMyRef)
|
|
EgtSetInfo(nPart, "PairMyRef", sNameMyRef)
|
|
local sNameRefDest = EgtGetName(nIdRefDest)
|
|
EgtSetInfo(nPart, "PairToRef", sToNamePart.."_"..sNameRefDest)
|
|
EgtSetInfo(nPart, "PairSpin", nPairSpin)
|
|
EgtSetInfo(nPart, "PairAng", tbInfo.dPairAng)
|
|
EgtSetInfo(nPart, "PairMode", tbInfo.nPairMode)
|
|
end
|
|
|
|
-- Disegna la quota lineare
|
|
-- Nome del part in cui trovare il primo punto di riferimento
|
|
-- Nome del punto riferimento nel part indicato sopra
|
|
-- Nome del part in cui trovare il secondo punto di riferimento
|
|
-- Nome del punto riferimento nel part indicato sopra
|
|
-- Nome/valore stringa da scrivere nella dimensione
|
|
-- Frame del piano su cui disegnare la quotatura
|
|
-- Offset etichetta rispetto al punto medio
|
|
local function DrawLinearDimension( sNamePart1, sNameRef1, sNamePart2, sNameRef2, sNameDimension, GridFrame, ptOffset)
|
|
EgtSetGridFrame(GridFrame)
|
|
local nDimLay = EgtGetFirstNameInGroup(GDB_ID.ROOT, 'Dimensions')
|
|
local nBottomLay = EgtGetFirstNameInGroup(GDB_ID.ROOT, sNamePart1)
|
|
local nRefBottom = EgtGetFirstNameInGroup(nBottomLay, 'Ref')
|
|
local nRef = EgtGetFirstNameInGroup(nRefBottom, sNameRef1)
|
|
local pt1 = EgtSP( nRef, GDB_RT.GRID)
|
|
local nTopLay = EgtGetFirstNameInGroup(GDB_ID.ROOT, sNamePart2)
|
|
local nRefTop = EgtGetFirstNameInGroup(nTopLay, 'Ref')
|
|
nRef = EgtGetFirstNameInGroup(nRefTop, sNameRef2)
|
|
local pt2 = EgtSP( nRef, GDB_RT.GRID)
|
|
local ptMid = (pt1 + pt2) / 2 + ptOffset
|
|
local nDim = EgtAlignedDimension( nDimLay, pt1, pt2, ptMid, sNameDimension, GDB_RT.GRID)
|
|
EgtSetColor( nDim, EgtStdColor( 'YELLOW'))
|
|
EgtRelocate(nDim, GDB_RT.GRID)
|
|
EgtSetName(nDim, sNameDimension)
|
|
end
|
|
--
|
|
-------------------------------------------------------------------------------------------------------------------------
|
|
-- FUNZIONI BASE PER GENERARE I COMPO SOLID FINE
|
|
-------------------------------------------------------------------------------------------------------------------------
|
|
|
|
-- -------------------------------------------------------------------------------------------------------------------------
|
|
-- -- CREAZIONE/IMPORTAZIONE Loop INIZIO
|
|
-- -------------------------------------------------------------------------------------------------------------------------
|
|
-- -- Importa un contorno chiuso da file nge
|
|
-- function ImportOutLoop( tbLayer, sNameFileNGE)
|
|
-- local OutLayer = tbLayer['OutLoop']
|
|
-- if not EgtInsertFile( sNameFileNGE) then
|
|
-- EgtOutLog(' IMPORTAZIONE FALLITA: '..sNameFileNGE)
|
|
-- end
|
|
-- -- recupero ultimo Part
|
|
-- local LastPart = EgtGetLastPart()
|
|
-- local FstLayerInLstPart = EgtGetFirstGroupInGroup( LastPart)
|
|
-- local IdLoop = EgtGetFirstInGroup( FstLayerInLstPart)
|
|
-- if not EgtRelocateGlob( IdLoop, OutLayer) then
|
|
-- EgtOutLog(' RELOCATE AFLLITA MISERAMENTE: '..tostring(IdLoop)..';'..tostring(OutLayer))
|
|
-- end
|
|
-- EgtErase(LastPart)
|
|
-- local tbIdLoop = ExplodeAndNameEdges( IdLoop)
|
|
|
|
-- EgtSetInfo(tbIdLoop[1],'AF',1)
|
|
-- EgtSetInfo(tbIdLoop[2],'AF',2)
|
|
-- EgtSetInfo(tbIdLoop[3],'AF',2)
|
|
-- EgtSetInfo(tbIdLoop[4],'AF',2)
|
|
-- EgtSetInfo(tbIdLoop[5],'AF',2)
|
|
-- EgtSetInfo(tbIdLoop[6],'AF',2)
|
|
-- EgtSetInfo(tbIdLoop[7],'AF',1)
|
|
-- --SaveMePlease()
|
|
-- -- definizione SideAng
|
|
-- -- EgtSetInfo( tbIdLoop[1], 'OrigSideAng', 45)
|
|
-- return tbIdLoop
|
|
-- end
|
|
-- --
|
|
|
|
function TOOL.AddLoopToLayer(nLay, tbIdLoop, dOffset, bInvert, bInLoop)
|
|
-- local tbLoop = {}
|
|
-- for i = 1, #tbIdLoop do
|
|
-- local nNewId = EgtCopyGlob(tbIdLoop[i], nLay)
|
|
-- if bInvert then EgtInvertCurve(nNewId) end
|
|
-- table.insert(tbLoop, nNewId)
|
|
-- end
|
|
-- TOOL.SetMachiningInfo(nLay, bInLoop)
|
|
--return tbLoop
|
|
local nNewLoop = EgtCurveCompoByChain(nLay, tbIdLoop, EgtSP(tbIdLoop[1], GDB_RT.GLOB), false)
|
|
if bInvert then EgtInvertCurve(nNewLoop) end
|
|
if dOffset > 0 then EgtOffsetCurve(nNewLoop, dOffset, GDB_OT.EXTEND) end
|
|
local tbNewLoop = TOOL.ExplodeAndNameEdges( nNewLoop, bInLoop)
|
|
return tbNewLoop
|
|
end
|
|
|
|
-- -------------------------------------------------------------------------------------------------------------------------
|
|
-- -- CREAZIONE/IMPORTAZIONE Loop FINE
|
|
-- -------------------------------------------------------------------------------------------------------------------------
|
|
|
|
-- -- Restituisce l'angolo precedente e successivo dell'aentità passata
|
|
local function GetPrevNextAng(IdEnt)
|
|
local PrevAng = EgtGetInfo(IdEnt,'PrevAng','d') or 0
|
|
local NextAng = EgtGetInfo(IdEnt,'NextAng','d') or 0
|
|
return PrevAng, NextAng
|
|
end
|
|
|
|
-- Confronto i dati del file.dat con quelli letti da programma
|
|
function IsDataChanged()
|
|
local bOk = false
|
|
if not tbOrigVal.v1 then return true end
|
|
if math.abs(CMP.V1 - tbOrigVal.v1) > 0.5 then bOk = bOk or true end
|
|
if math.abs(CMP.V2 - tbOrigVal.v2) > 0.5 then bOk = bOk or true end
|
|
if math.abs(CMP.V3 - tbOrigVal.v3) > 0.5 then bOk = bOk or true end
|
|
if math.abs(CMP.V4 - tbOrigVal.v4) > 0.5 then bOk = bOk or true end
|
|
if math.abs(CMP.V5 - tbOrigVal.v5) > 0.5 then bOk = bOk or true end
|
|
if math.abs(CMP.V6 - tbOrigVal.v6) > 0.5 then bOk = bOk or true end
|
|
if math.abs(CMP.V7 - tbOrigVal.v7) > 0.5 then bOk = bOk or true end
|
|
if math.abs(CMP.V8 - tbOrigVal.v8) > 0.5 then bOk = bOk or true end
|
|
return bOk
|
|
end
|
|
|
|
function CalcDraftAngle( vtDir1, vtDir2, dPairAng1, dPairAng2, dAngBetween)
|
|
-- vengono restituiti il SideAng ( calcolato dall'angolo in 3d), i due nuovi angoli di forma per i due pezzi
|
|
-- dBeta1 è riferito al pezzo 1 e dBeta2 è riferito al pezzo 2
|
|
local dAngTilt1 = 180 - dPairAng1
|
|
local dAngTilt2 = 180 - dPairAng2
|
|
local vtN1 = Vector3d({0,0,100})
|
|
local vtN2 = Vector3d({0,0,100})
|
|
vtN1:rotate(vtDir1, dAngTilt1)
|
|
vtN2:rotate(vtDir2, dAngTilt2)
|
|
--vtN2:rotate(Z_AX(), dAngBetween)
|
|
local vtPerp = vtN1 ^ vtN2
|
|
local vtInters1 = vtN1 ^ vtPerp
|
|
local vtInters2 = vtPerp ^ vtN2
|
|
--local dAng3d = GetRotation(vtInters1, vtInters2, vtPerp)
|
|
local dAng3d = GetAngle(vtInters1, vtInters2)
|
|
local dBeta1 = GetAngle( vtDir1, vtPerp)
|
|
if (dPairAng2 > 90 and dBeta1 > 90) or (dPairAng2 < 90 and dBeta1 < 90) then dBeta1 = 180 - dBeta1 end
|
|
local dBeta2 = GetAngle( vtDir2, vtPerp)
|
|
if (dPairAng1 > 90 and dBeta2 > 90) or (dPairAng1 < 90 and dBeta2 < 90) then dBeta2 = 180 - dBeta2 end
|
|
local dSideAng = 0
|
|
dSideAng = (180 - dAng3d) / 2
|
|
|
|
--debug
|
|
EgtOutLog(tostring(dSideAng)..' '.. tostring(dBeta1).. ' '..tostring(dBeta2))
|
|
--debug
|
|
|
|
return dSideAng, dBeta1, dBeta2
|
|
end
|
|
|
|
function TJunction(dAngBetween, dTh1, dTh2, nType, dLen1, dLen2, bOnLoop)
|
|
-- restituisce le lunghezze L1 e L2 adattate in base al tipo di giunzione
|
|
-- nType == 1 -> TrimStart ( del Part2)
|
|
-- nType == 2 -> TrimEnd ( del Part1)
|
|
local dXOffset1 = 0
|
|
local dXOffset2 = 0
|
|
if not bOnLoop then bOnLoop = false end
|
|
if dAngBetween > 0 then
|
|
if nType == 1 then
|
|
-- trim start
|
|
local dDeltaStart = - dTh1 / sin(dAngBetween)
|
|
dLen2 = dLen2 + dDeltaStart
|
|
dXOffset2 = dDeltaStart
|
|
-- extend end
|
|
local dDeltaEnd = dTh1 * tan(90- math.abs(dAngBetween))
|
|
dLen1 = dLen1 + dDeltaEnd
|
|
dXOffset1 = dDeltaEnd
|
|
elseif nType == 2 then
|
|
-- trim end
|
|
local dDeltaEnd = - dTh2 / sin(dAngBetween)
|
|
dLen1 = dLen1 + dDeltaEnd
|
|
dXOffset1 = dDeltaEnd
|
|
-- extend start
|
|
local dDeltaStart = dTh2 * tan(90- math.abs(dAngBetween))
|
|
dLen2 = dLen2 + dDeltaStart
|
|
dXOffset2 = dDeltaStart
|
|
end
|
|
else
|
|
-- qui sto estendendo le lunghezze, infatti gli angoli sono nergativi e quindi anche il loro seno
|
|
if nType == 1 then
|
|
-- il trim start diventa un extend end
|
|
local dDelta = - dTh2 / sin(dAngBetween)
|
|
if not bOnLoop then dDelta = dDelta - dTh1 * tan(90 - math.abs(dAngBetween)) end
|
|
dLen1 = dLen1 + dDelta
|
|
dXOffset1 = dDelta
|
|
-- accorcio lo start
|
|
local dDeltaStart = - dTh2 * tan(90- math.abs(dAngBetween))
|
|
dLen2 = dLen2 + dDeltaStart
|
|
dXOffset2 = dDeltaStart
|
|
elseif nType == 2 then
|
|
-- il trim end diventa un extend start
|
|
local dDeltaStart = dTh1 / sin(dAngBetween)
|
|
if not bOnLoop then dDeltaStart = dDeltaStart + dTh2 * tan(90 - math.abs(dAngBetween)) end
|
|
dLen2 = dLen2 - dDeltaStart
|
|
dXOffset2 = dDeltaStart
|
|
-- accorcio l'end
|
|
local dDeltaEnd = - dTh1 * tan(90- math.abs(dAngBetween))
|
|
dLen1 = dLen1 + dDeltaEnd
|
|
dXOffset1 = dDeltaEnd
|
|
end
|
|
end
|
|
return dLen1, dLen2, dXOffset1, dXOffset2
|
|
end
|
|
|
|
function AngleJunction(dAngBetween, dTh1, dTh2, dLen1, dLen2, bOnLoop)
|
|
-- modifico la lughezza dei lati solo se ho un angolo convesso
|
|
local dXOffset = 0
|
|
if not bOnLoop then
|
|
local dDelta1 = dTh2 / sin( dAngBetween)
|
|
local dDelta2 = dTh1 / sin( dAngBetween)
|
|
if dAngBetween > 0 then
|
|
dLen1 = dLen1 - dDelta1
|
|
dLen2 = dLen2 - dDelta2
|
|
else
|
|
dLen1 = dLen1 + dDelta1
|
|
dLen2 = dLen2 + dDelta2
|
|
end
|
|
end
|
|
return dLen1, dLen2, dXOffset, dXOffset
|
|
end
|
|
|
|
function ManageJunction(dAngBetween, dTh1, dTh2, nType, dLen1, dLen2, bOnLoop)
|
|
--nJunctionType -- 1 TrimStart, 2 TrimEnd, 3Ang
|
|
if nType == 1 or nType == 2 then
|
|
return TJunction(dAngBetween, dTh1, dTh2, nType, dLen1, dLen2, bOnLoop)
|
|
elseif nType == 3 then
|
|
return AngleJunction(dAngBetween, dTh1, dTh2, dLen1, dLen2, bOnLoop)
|
|
end
|
|
end
|
|
|
|
function TOOL.CreateAdjustedPart( nLayOutloop, dLen, dH, dBeta1, dBeta2)
|
|
-- genero la regione piana del rettangolo deformato :
|
|
-- dLen è la lunghezza del lato su cui si va ad agganciare il pezzo che sto creando, quindi è un dato fisso
|
|
-- bisogna calcolare gli altri tre lati del quadrilatero
|
|
-- dProj1 dProj2
|
|
-- __|__ _______________________ __|__
|
|
-- \ / |
|
|
-- \ beta1 beta2 / |dH
|
|
-- \ /___________dLen__________\ / |
|
|
-- beta 1 e beta 2 sono gli angoli alla base
|
|
-- dLen1 e dLen2 sono le proiezioni delle diagonali sulla base maggiore
|
|
-- beta 1 e beta 2 possono essere < 90 e quindi potrei avere anche un trapezio ribaltato, oppure un quasi parallelogramma
|
|
|
|
-- recupero eventuali input mancanti dalla tabella generale
|
|
if not dLen then dLen = TOOL.tbInfo.dLen end
|
|
if not dH then dH = TOOL.tbInfo.dH end
|
|
if not dBeta1 then dBeta1 = TOOL.tbInfo.dAngBL end
|
|
if not dBeta2 then dBeta2 = TOOL.tbInfo.dAngBR end
|
|
if not nLayOutloop then nLayOutloop = TOOL.tbInfo.nLayLoop end
|
|
|
|
-- creo i lati del pezzo
|
|
local dProj1 = dH * tan( dBeta1 - 90)
|
|
local dProj2 = dH * tan( dBeta2 - 90)
|
|
|
|
local pt1 = ORIG()
|
|
local pt2 = Point3d(dLen,0,0)
|
|
local nLine1 = EgtLine( nLayOutloop, pt1, pt2)
|
|
EgtSetName(nLine1, "A1")
|
|
local pt3 = Point3d(dLen + dProj2,dH,0)
|
|
local nLine2 = EgtLine( nLayOutloop, pt2, pt3)
|
|
EgtSetName(nLine2, "A2")
|
|
local pt4 = Point3d( -dProj1,dH,0)
|
|
local nLine3 = EgtLine( nLayOutloop, pt3, pt4)
|
|
EgtSetName(nLine3, "A3")
|
|
local nLine4 = EgtLine( nLayOutloop, pt4, pt1)
|
|
EgtSetName(nLine4, "A4")
|
|
TOOL.SetMachiningInfo(nLayOutloop)
|
|
return {nLine1, nLine2, nLine3, nLine4}
|
|
end
|
|
|
|
function TOOL.SetSideAng(nLay, sEdgeName, dAng)
|
|
local nEdge = EgtGetFirstNameInGroup( nLay, sEdgeName)
|
|
EgtSetInfo( nEdge, 'SideAng', dAng)
|
|
EgtSetInfo( nEdge, 'OrigSideAng', dAng)
|
|
end
|
|
|
|
-- ptCenter sono le coordinate del centro del foro rispetto all'angolo in basso a sinistra
|
|
function TOOL.CreateCircularHole(nPart, ptCenter, dDiam)
|
|
local nInLoopLay = EgtGroup(nPart)
|
|
EgtSetName(nInLoopLay, 'InLoop')
|
|
local HoleId = EgtCircle( nInLoopLay, ptCenter, dDiam, GDB_RT.GLOB)
|
|
TOOL.SetMachiningInfo(nInLoopLay)
|
|
TOOL.AddInLoopToPart(nInLoopLay)
|
|
end
|
|
|
|
|
|
--function TOOL.CreateParetina(i, tbIdLoopTC, tbInfo, dPairAngCorr)
|
|
function TOOL.CreateParetina(nEdgeId, tbInfo, dPairAngCorr)
|
|
local tbIdLoopTC = {}
|
|
if not tbInfo then
|
|
tbInfo = TOOL.tbInfo
|
|
tbIdLoopTC = TOOL.tbIdLoop
|
|
end
|
|
if not tbInfo.nEdge and nEdgeId then
|
|
tbIdLoopTC = FindEdges(EgtGetParent(nEdgeId), tbInfo)
|
|
end
|
|
if #tbIdLoopTC == 0 then return end
|
|
local i = tbInfo.nEdge -- posizione del lato nel layer del loop
|
|
if dPairAngCorr == nil then dPairAngCorr = 0 end
|
|
local nPrev = i > 1 and i - 1 or #tbIdLoopTC
|
|
local nNext = i < #tbIdLoopTC and i + 1 or 1
|
|
if not tbInfo.nPrevId then tbInfo.nPrevId = GDB_ID.NULL end
|
|
local dPairAngPrev = (EgtGetInfo(tbInfo.nPrevId, 'PairAng', 'd') or 0) + dPairAngCorr
|
|
if not tbInfo.nNextId then tbInfo.nNextId = GDB_ID.NULL end
|
|
local dPairAngNext = (EgtGetInfo(tbInfo.nNextId, 'PairAng', 'd') or 0) + dPairAngCorr
|
|
local dPairAng = (tbInfo.dPairAng or 0) + dPairAngCorr
|
|
local vtDirCurr = EgtSV( tbIdLoopTC[i], GDB_RT.GLOB)
|
|
local vtDirNext = EgtSV( tbIdLoopTC[nNext], GDB_RT.GLOB)
|
|
local vtDirPrev = EgtEV( tbIdLoopTC[nPrev], GDB_RT.GLOB)
|
|
local dLen = EgtCurveLength(tbIdLoopTC[i])
|
|
local dLenPrev = EgtCurveLength(tbIdLoopTC[nPrev])
|
|
local dLenNext = EgtCurveLength(tbIdLoopTC[nNext])
|
|
local PrevAng, NextAng = GetPrevNextAng(tbIdLoopTC[i])
|
|
local dTh = tbInfo.dTh and tbInfo.dTh or EgtGetInfo(tbInfo.nId, 'Th','d')
|
|
local dThPrev = EgtGetInfo(tbInfo.nPrevId, 'Th','d') or 0
|
|
local dThNext = EgtGetInfo(tbInfo.nNextId, 'Th','d') or 0
|
|
|
|
-- calcolo l'angolo di sformo con il pezzo precedente
|
|
local dXOffset = 0
|
|
|
|
-- se i due pezzi hanno angoli di accoppiamento discordi allora uno sta sotto e uno sta sopra
|
|
local bSameSide = dPairAng * dPairAngPrev > 0
|
|
if bSameSide then
|
|
local dOffset = 0
|
|
if tbInfo.nJunctionType == 3 then
|
|
local dSideAngDx, _, dBeta_DX = CalcDraftAngle( vtDirPrev, vtDirCurr, dPairAngPrev, dPairAng, PrevAng)
|
|
--tbInfo.dAngBR = 180 - dBeta_DX
|
|
tbInfo.dAngBR = dBeta_DX
|
|
if tbInfo.bOnLoop then dSideAngDx = dSideAngDx * (-1) end
|
|
if PrevAng < 0 then dSideAngDx = dSideAngDx * (-1) end
|
|
tbInfo.dSideAngR = dSideAngDx
|
|
if not tbInfo.bOnLoop then
|
|
dLenPrev, dLen, _, dOffset = ManageJunction(PrevAng,dThPrev, dTh,tbInfo.nJunctionType, dLenPrev, dLen)
|
|
if tbInfo.nPairMode == 2 then dXOffset = dXOffset + dOffset end
|
|
end
|
|
else
|
|
-- se ho una giunzione a T allora devo aggiustare la lunghezza dei pezzi sia che la faccia sia On, sia che sia Off
|
|
dLenPrev, dLen, _, dOffset = ManageJunction(PrevAng,dThPrev, dTh,tbInfo.nJunctionType, dLenPrev, dLen)
|
|
-- setto il sideang da giunzione a T
|
|
local dSideAngDx = 90 - math.abs(PrevAng)
|
|
if tbInfo.bOnLoop then dSideAngDx = dSideAngDx * (-1) end
|
|
tbInfo.dSideAngR = dSideAngDx
|
|
tbInfo.dAngBR = 90
|
|
if tbInfo.nPairMode == 2 then dXOffset = dXOffset + dOffset end
|
|
end
|
|
else
|
|
-- setto il sideAng da giunzione a T (che va bene anche se la giunzione è angolata ma senza pezzo precedente)
|
|
local dSideAng = PrevAng < 0 and (90 + PrevAng) or 90-PrevAng
|
|
if tbInfo.bOnLoop then dSideAng = dSideAng * (-1) end
|
|
tbInfo.dSideAngR = dSideAng
|
|
tbInfo.dAngBR = 90
|
|
-- visto che il pezzo precedente non è dallo stesso lato allora corrego l'estensione del pezzo corrente (in funzione del suo spessore)
|
|
if not tbInfo.bOnLoop then
|
|
local dOffset = dTh * tan( 90 - PrevAng)
|
|
dLen = dLen + dOffset
|
|
--if tbInfo.nJunctionType == 2 then dXOffset = dXOffset + dOffset end
|
|
if tbInfo.nPairMode == 2 then dXOffset = dXOffset + dOffset end
|
|
end
|
|
end
|
|
-- -- calcolo l'angolo di sformo con il pezzo successivo
|
|
bSameSide = dPairAng * dPairAngNext > 0
|
|
if bSameSide then
|
|
local dOffset = 0
|
|
if tbInfo.nJunctionType == 3 then
|
|
local dSideAngSx, dBeta_SX, _ = CalcDraftAngle( vtDirCurr, vtDirNext, dPairAng, dPairAngNext, NextAng)
|
|
-- tbInfo.dAngBL = 180 - dBeta_SX
|
|
tbInfo.dAngBL = dBeta_SX
|
|
if tbInfo.bOnLoop then dSideAngSx = dSideAngSx * (-1) end
|
|
if NextAng < 0 then dSideAngSx = dSideAngSx * (-1) end
|
|
tbInfo.dSideAngL = dSideAngSx
|
|
if not tbInfo.bOnLoop then
|
|
dLen, dLenNext, dXOffset, _ = ManageJunction(NextAng, dTh, dThNext, tbInfo.nJunctionType, dLen, dLenNext)
|
|
if tbInfo.nPairMode == 1 then dXOffset = dXOffset + dOffset end
|
|
end
|
|
else
|
|
-- se ho una giunzione a T allora devo aggiustare la lunghezza dei pezzi sia che la faccia sia On, sia che sia Off
|
|
dLen, dLenNext, dXOffset, _ = ManageJunction(NextAng, dTh, dThNext, tbInfo.nJunctionType, dLen, dLenNext)
|
|
-- setto il sideang da giunzione a T
|
|
local dSideAngSx = 90 - math.abs(NextAng)
|
|
if tbInfo.bOnLoop then dSideAngSx = dSideAngSx * (-1) end
|
|
tbInfo.dSideAngL = dSideAngSx
|
|
tbInfo.dAngBL = 90
|
|
if tbInfo.nPairMode == 1 then dXOffset = dXOffset + dOffset end
|
|
end
|
|
else
|
|
-- setto il sideAng da giunzione a T (che va bene anche se la giunzione è angolata ma senza pezzo successivo)
|
|
local dSideAng = NextAng < 0 and (90 + NextAng) or 90-NextAng
|
|
if tbInfo.bOnLoop then dSideAng = dSideAng * (-1) end
|
|
tbInfo.dSideAngL = dSideAng
|
|
tbInfo.dAngBL = 90
|
|
-- visto che il pezzo successivo non è dallo stesso lato allora correggo l'estensione del pezzo corrente (in funzione del suo spessore)
|
|
if not tbInfo.bOnLoop then
|
|
local dOffset = dTh * tan( 90 - NextAng)
|
|
dLen = dLen + dOffset
|
|
--if tbInfo.nJunctionType == 1 then dXOffset = dXOffset + dOffset end
|
|
if tbInfo.nPairMode == 1 then dXOffset = dXOffset + dOffset end
|
|
end
|
|
end
|
|
tbInfo.dLen = dLen
|
|
tbInfo.dXOffset = dXOffset
|
|
end
|
|
|
|
local function ClearPart(nPartId)
|
|
local tbLayer = TOOL.FindLayers(nPartId)
|
|
-- svuoto i layer con gli elementi principali
|
|
EgtEmptyGroup(tbLayer["OutLoop"])
|
|
EgtEmptyGroup(tbLayer["Region"])
|
|
EgtEmptyGroup(tbLayer["Ref"])
|
|
EgtEmptyGroup(tbLayer["Labels"])
|
|
-- rimetto il frame del part nell'origine
|
|
EgtChangeGroupFrame(nPartId, GLOB_FRM())
|
|
-- resetto il gruppo di accoppiati
|
|
ASS.bActiveHistory = false
|
|
ASS.nPartId = nPartId
|
|
ASS.Unpair()
|
|
ASS.bActiveHistory = true
|
|
-- cancello il solido
|
|
local PartSolid = EgtGetInfo(TOOL.tbInfo.nId, "Child")
|
|
EgtErase(PartSolid)
|
|
-- resetto l'id del part del solido
|
|
EgtSetInfo(nPartId, "Child", "")
|
|
end
|
|
|
|
local function CountInLoops(nEdgeId)
|
|
local nLay = EgtGetParent(nEdgeId)
|
|
local nParent = EgtGetParent(nLay)
|
|
local nNextLay = EgtGetFirstNameInGroup(nParent, "InLoop")
|
|
local c = 1
|
|
while nNextLay ~= nLay do
|
|
nNextLay = EgtGetNextName(nNextLay)
|
|
c = c + 1
|
|
end
|
|
return c
|
|
end
|
|
|
|
local function UpdateNeighInfo()
|
|
if not TOOL.nLayLoopParent or TOOL.nLayLoopParent == GDB_ID.NULL then TOOL.nLayLoopParent = EgtGetParent(TOOL.nEdgeId) end
|
|
local nEdges = EgtGetGroupObjs(TOOL.nLayLoopParent)
|
|
-- controllo il prev
|
|
local nPrev = TOOL.tbInfo.nEdge > 1 and TOOL.tbInfo.nEdge - 1 or nEdges -- numero ordinale della paretina precedente alla corrente
|
|
local sNamePrev = "A"..tostring(nPrev)
|
|
-- correggo il nome in caso l'edge appartenga ad un inloop
|
|
if not TOOL.tbInfo.bOutLoop then sNamePrev = sNamePrev.."_I"..tostring(TOOL.tbInfo.nIn) end
|
|
-- in nPrevId salvo già la paretina dello stesso tipo della corrente(alzatina o frontalino)
|
|
local tbPrev = EgtGetInfo(TOOL.tbInfo.nParent, sNamePrev, "vs")
|
|
local bSameSide = false
|
|
if tbPrev then
|
|
for _, NamePrev in pairs(tbPrev) do
|
|
sNamePrev = NamePrev
|
|
TOOL.tbInfo.nPrevId = EgtGetFirstNameInGroup( GDB_ID.ROOT, NamePrev)
|
|
local dPairAngPrev = EgtGetInfo(TOOL.tbInfo.nPrevId, "PairAng", "d")
|
|
if dPairAngPrev then bSameSide = TOOL.tbInfo.dPairAng * dPairAngPrev > 0 end
|
|
if bSameSide then break end
|
|
end
|
|
end
|
|
if not bSameSide then TOOL.tbInfo.nPrevId = GDB_ID.NULL end
|
|
-- al precedente setto il curr come Next
|
|
-- al corrente setto il prev
|
|
if TOOL.tbInfo.nPrevId and TOOL.tbInfo.nPrevId ~= GDB_ID.NULL then
|
|
EgtSetInfo(TOOL.tbInfo.nPrevId, "Next", TOOL.tbInfo.sName)
|
|
EgtSetInfo(TOOL.tbInfo.nId, "Prev", sNamePrev)
|
|
end
|
|
-- controllo il next
|
|
local nNext = TOOL.tbInfo.nEdge == nEdges and 1 or (TOOL.tbInfo.nEdge + 1)
|
|
local sNameNext = "A"..tostring(nNext)
|
|
-- correggo il nome in caso l'edge appartenga ad un inloop
|
|
if not TOOL.tbInfo.bOutLoop then sNameNext = sNameNext.."_I"..tostring(TOOL.tbInfo.nIn) end
|
|
-- in nNextId salvo già la paretina dello stesso tipo della corrente(alzatina o frontalino)
|
|
local tbNext = EgtGetInfo(TOOL.tbInfo.nParent, sNameNext, "vs")
|
|
bSameSide = false
|
|
if tbNext then
|
|
for _, NameNext in pairs(tbNext) do
|
|
sNameNext = NameNext
|
|
TOOL.tbInfo.nNextId = EgtGetFirstNameInGroup( GDB_ID.ROOT, NameNext)
|
|
local dPairAngNext = EgtGetInfo(TOOL.tbInfo.nNextId, "PairAng", "d")
|
|
if dPairAngNext then bSameSide = TOOL.tbInfo.dPairAng * dPairAngNext > 0 end
|
|
if bSameSide then break end
|
|
end
|
|
end
|
|
if not bSameSide then TOOL.tbInfo.nNextId = GDB_ID.NULL end
|
|
-- al successivo setto il curr come Prev
|
|
-- al corrente setto il next
|
|
if TOOL.tbInfo.nNextId and TOOL.tbInfo.nNextId ~= GDB_ID.NULL then
|
|
EgtSetInfo(TOOL.tbInfo.nNextId, "Prev", TOOL.tbInfo.sName)
|
|
EgtSetInfo(TOOL.tbInfo.nId, "Next", sNameNext)
|
|
end
|
|
end
|
|
|
|
function TOOL.CreateParetinaFull(bPrev, bNext, bRecurs)
|
|
if bPrev == nil then bPrev = TOOL.bPrev end
|
|
if bNext == nil then bNext = TOOL.bNext end
|
|
if bRecurs == nil then bRecurs = false end
|
|
|
|
-- se non ho ricevuto input li recupero dalla tabella generale
|
|
if not TOOL.nEdgeId then return end
|
|
if not TOOL.tbInfo.nId or not bRecurs then
|
|
-- recupero tutte le info che mi servono (che vengono messe in TOOL.tbInfo)
|
|
FillInfoTable()
|
|
local nPairMode = 4
|
|
if TOOL.tbInfo.nJunctionType == 1 then
|
|
nPairMode = 1
|
|
elseif TOOL.tbInfo.nJunctionType == 2 then
|
|
nPairMode = 2
|
|
end
|
|
TOOL.tbInfo.nPairMode = nPairMode
|
|
end
|
|
TOOL.tbInfo.nLayLoopParent= EgtGetParent(TOOL.tbInfo.nEdgeId)
|
|
TOOL.tbIdLoop = FindEdges(TOOL.tbInfo.nLayLoopParent, TOOL.tbInfo) -- tabella che contiene gli id degli Edge del loop
|
|
-- determino se il l'edge è di un inloop o di un outloop
|
|
TOOL.tbInfo.bOutLoop = EgtGetName(EgtGetParent(TOOL.tbInfo.nEdgeId)) == "OutLoop"
|
|
if not TOOL.tbInfo.bOutLoop then TOOL.tbInfo.nIn = CountInLoops(TOOL.tbInfo.nEdgeId) end
|
|
|
|
-- controllo nelle info del parent se era già stato creato il part associato a quel lato
|
|
local sEdgeName = EgtGetName(TOOL.tbInfo.nEdgeId)
|
|
-- se inloop correggo il nome dell'info da A1 a A1_I1, dove I1 indica il primo Inloop
|
|
if not TOOL.tbInfo.bOutLoop then sEdgeName = sEdgeName.."_I"..tostring(TOOL.tbInfo.nIn) end
|
|
if not TOOL.tbInfo.nParent or TOOL.tbInfo.nParent == GDB_ID.NULL then TOOL.tbInfo.nParent = EgtGetParent(EgtGetParent(TOOL.tbInfo.nEdgeId))end
|
|
local tbChildName = EgtGetInfo(TOOL.tbInfo.nParent, sEdgeName, "vs")
|
|
local nChildPart = nil
|
|
local dPairAng = 0
|
|
|
|
local bFound = false
|
|
if tbChildName then
|
|
for _, sChildName in pairs(tbChildName) do
|
|
nChildPart = EgtGetFirstNameInGroup(GDB_ID.ROOT, sChildName)
|
|
if nChildPart then dPairAng = EgtGetInfo(nChildPart, "PairAng", "d") or 0 end
|
|
if math.abs(dPairAng - TOOL.tbInfo.dPairAng) < 0.001 then
|
|
bFound = true
|
|
break
|
|
end
|
|
end
|
|
end
|
|
if not bFound then
|
|
nChildPart = nil
|
|
dPairAng = 0
|
|
end
|
|
|
|
if not nChildPart or math.abs(dPairAng - TOOL.tbInfo.dPairAng) > 0.001 then
|
|
-- se il part non esiste, lo creo
|
|
local sPrefix = "Part"
|
|
local sPartname = sPrefix..sEdgeName
|
|
TOOL.tbInfo.nId = TOOL.CreatePartLayer(sPartname)
|
|
sPartname = EgtGetName(TOOL.tbInfo.nId)
|
|
TOOL.tbInfo.sName = sPartname
|
|
UpdateNeighInfo()
|
|
|
|
--aggiorno le info dei child nel part parent
|
|
-- cerco se esiste già un altro part creato su quel lato (CONSIDERO CHE AL PIù SU UN LATO POSSANO COESISTERE UN'ALZATINA E UN FRONTALINO)
|
|
local sChildFromEdge = EgtGetInfo(TOOL.tbInfo.nParent, sEdgeName)
|
|
if sChildFromEdge then
|
|
sChildFromEdge = sChildFromEdge..","..sPartname
|
|
else
|
|
sChildFromEdge = sPartname
|
|
end
|
|
if TOOL.tbInfo.nParent then EgtSetInfo(TOOL.tbInfo.nParent, sEdgeName, sChildFromEdge) end
|
|
else
|
|
-- se esisteva già ripulisco i layer della regione e del loop ed elimino il solido
|
|
ClearPart(nChildPart)
|
|
TOOL.tbInfo.nId = nChildPart
|
|
TOOL.tbInfo.sName = EgtGetName(TOOL.tbInfo.nId)
|
|
-- recupero l'id di eventuali vicini
|
|
TOOL.tbInfo.nPrevId = EgtGetFirstNameInGroup(GDB_ID.ROOT, EgtGetInfo(TOOL.tbInfo.nId, "Prev")) or GDB_ID.NULL
|
|
TOOL.tbInfo.nNextId = EgtGetFirstNameInGroup(GDB_ID.ROOT, EgtGetInfo(TOOL.tbInfo.nId, "Next")) or GDB_ID.NULL
|
|
end
|
|
local tbLayers = TOOL.FindLayers(TOOL.tbInfo.nId)
|
|
TOOL.tbInfo.nLayLoop = tbLayers["OutLoop"]
|
|
|
|
TOOL.CreateParetina()
|
|
TOOL.CreateAdjustedPart()
|
|
TOOL.CreatePart()
|
|
-- setto i sideAng
|
|
if TOOL.tbInfo.dSideAngL then TOOL.SetSideAng(tbLayers['OutLoop'], 'A2', TOOL.tbInfo.dSideAngR) end
|
|
if TOOL.tbInfo.dSideAngR then TOOL.SetSideAng(tbLayers['OutLoop'], 'A4', TOOL.tbInfo.dSideAngL) end
|
|
-- creo i riferimenti e salvo i parametri del part
|
|
local sNamePartDest = EgtGetName(TOOL.tbInfo.nParent)
|
|
local sEdgeDest = EgtGetName(TOOL.tbInfo.nEdgeId)
|
|
local sLayEdgeDest = EgtGetName(EgtGetParent(TOOL.tbInfo.nEdgeId))
|
|
if TOOL.tbInfo.bOnLoop then
|
|
-- waterfall
|
|
TOOL.tbInfo.dSideAngT = TOOL.dPairAng + 90
|
|
TOOL.tbInfo.dYOffset = TOOL.tbInfo.dTh * tan(TOOL.tbInfo.dSideAngT)
|
|
TOOL.tbInfo.sDestRefOff = '0,0,-x'
|
|
TOOL.tbInfo.sRefOff = '0,'..tostring(TOOL.tbInfo.dYOffset)..',0'
|
|
else
|
|
-- splashtop
|
|
TOOL.tbInfo.dSideAngT = TOOL.dPairAng - 90
|
|
TOOL.tbInfo.dYOffset = TOOL.tbInfo.dTh * tan(TOOL.tbInfo.dSideAngT)
|
|
TOOL.tbInfo.sDestRefOff = '0,0,0'
|
|
TOOL.tbInfo.sRefOff = tostring(TOOL.tbInfo.dXOffset)..','..tostring(TOOL.tbInfo.dYOffset)..',-x'
|
|
end
|
|
TOOL.tbInfo.dThParent = EgtGetInfo(TOOL.tbInfo.nParent, "Th", "d")
|
|
local nIdRefDest = TOOL.CreateReference( TOOL.tbInfo.nParent, sLayEdgeDest, sEdgeDest, TOOL.tbInfo.nIn, TOOL.tbInfo.dThParent, TOOL.tbInfo.sDestRefOff, TOOL.tbInfo.sName)
|
|
local nIdMyRef = TOOL.CreateReference( TOOL.tbInfo.nId, 'OutLoop', 'A1', nil,TOOL.tbInfo.dTh, TOOL.tbInfo.sRefOff)
|
|
TOOL.SetPairInfo( TOOL.tbInfo, nIdMyRef, sNamePartDest, nIdRefDest, -1)
|
|
|
|
-- devo modificare anche la paretina precedente e la successiva
|
|
-- modifico anche la paretina precedente(se esiste)
|
|
-- creo il solido e lo accoppio
|
|
if SLD then
|
|
SLD.CurrId = TOOL.tbInfo.nId
|
|
SLD.Main()
|
|
end
|
|
|
|
if ASS then
|
|
ASS.nVeinCtx = EgtGetContext()
|
|
ASS.nPartId = TOOL.tbInfo.nId
|
|
ASS.PairSingle()
|
|
end
|
|
|
|
local nNextId = TOOL.tbInfo.nNextId
|
|
if bPrev and TOOL.tbInfo.nPrevId and TOOL.tbInfo.nPrevId ~= GDB_ID.NULL then
|
|
FillInfoTableFromPart(TOOL.tbInfo.nPrevId)
|
|
TOOL.CreateParetinaFull(false, false, true)
|
|
end
|
|
-- modifico anche la paretina successiva(se esiste)
|
|
if bNext and nNextId and nNextId ~= GDB_ID.NULL then
|
|
FillInfoTableFromPart(nNextId)
|
|
TOOL.CreateParetinaFull(false, false, true)
|
|
end
|
|
|
|
TOOL.SaveMePlease()
|
|
-- pulisco la tabella con i dati
|
|
TOOL.tbInfo = {}
|
|
end
|
|
|
|
return TOOL
|