- rinominate le variabili per i layer
- 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.
This commit is contained in:
Daniele Bariletti
+244
-103
@@ -15,8 +15,8 @@ local TOOL = {}
|
||||
_G.TOOL = TOOL
|
||||
|
||||
TOOL.nId = nil -- id del part della paretina che si sta costruendo
|
||||
TOOL.nOutLayParent = nil -- layer contenente il loop da cui si sta creando la paretina (appartenente al parent)
|
||||
TOOL.nOutLay = nil -- layer dell'outloop del nuovo part in creazione
|
||||
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
|
||||
@@ -43,11 +43,17 @@ TOOL.sName = nil -- nome del part corrente, incluso il codice univoco(
|
||||
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
|
||||
---- 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')
|
||||
@@ -73,8 +79,8 @@ 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.nOutLayParent and TOOL.nOutLayParent ~= GDB_ID.NULL then TOOL.tbInfo.nOutLayParent = TOOL.nOutLayParent end
|
||||
if (not TOOL.tbInfo.nOutLayParent or TOOL.tbInfo.nOutLayParent == GDB_ID.NULL) and TOOL.nEdgeId and TOOL.nEdgeId ~= GDB_ID.NULL then EgtGetParent( 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
|
||||
@@ -90,8 +96,6 @@ local function FillInfoTable()
|
||||
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.dBeta1 then TOOL.tbInfo.dBeta1 = TOOL.dBeta1 end
|
||||
-- if TOOL.dBeta2 then TOOL.tbInfo.dBeta2 = TOOL.dBeta2 end
|
||||
if TOOL.sName then TOOL.tbInfo.sName = TOOL.sName end
|
||||
end
|
||||
|
||||
@@ -101,6 +105,7 @@ local function FillInfoTableFromPart(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")
|
||||
@@ -108,18 +113,35 @@ local function FillInfoTableFromPart(nPartId)
|
||||
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")
|
||||
TOOL.nOutLayParent = EgtGetFirstNameInGroup(TOOL.tbInfo.nParent, "OutLoop")
|
||||
if TOOL.nOutLayParent then TOOL.tbInfo.nOutLayParent = TOOL.nOutLayParent end
|
||||
TOOL.tbInfo.nEdgeId = EgtGetFirstNameInGroup(TOOL.tbInfo.nOutLayParent, "A"..TOOL.tbInfo.nEdge)
|
||||
-- TOOL.tbInfo.dBeta1 = EgtGetInfo(nPartId,"Beta1", "d")
|
||||
-- TOOL.tbInfo.dBeta2 = EgtGetInfo(nPartId,"Beta2", "d")
|
||||
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.nParent,"A"..tostring(tbInfo.nEdge), tbInfo.nId) 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
|
||||
@@ -128,15 +150,16 @@ function TOOL.WriteDataToChildPart(tbInfo)
|
||||
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.dBeta1 then EgtSetInfo(tbInfo.nId, 'Beta1', tbInfo.dBeta1) end
|
||||
-- if tbInfo.dBeta2 then EgtSetInfo(tbInfo.nId, 'Beta2', tbInfo.dBeta2) 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
|
||||
@@ -317,8 +340,8 @@ 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.nLay then nLayLoop = TOOL.nLay end
|
||||
if TOOL.tbInfo.nOutLay then nLayLoop = TOOL.tbInfo.nOutLay end
|
||||
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
|
||||
|
||||
@@ -380,25 +403,53 @@ end
|
||||
-- Nome dello spigolo,
|
||||
-- Nome della copia riferimento
|
||||
-- Info per spostamento Ref in funzione di una variabile
|
||||
function TOOL.CreateReference( IdPart, sNameLayer,sNameEdge, dVar, sDir)
|
||||
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)
|
||||
if not IdEnt then
|
||||
-- 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
|
||||
return
|
||||
end
|
||||
-- creo la copia dello spigolo come riferimento
|
||||
local IdRef = EgtCopy( IdEnt, tbLayer['Ref'])
|
||||
EgtSetInfo(IdRef, "OrigEdge", IdEnt)
|
||||
local nNumRef = EgtGetGroupObjs(tbLayer['Ref'])
|
||||
local sNameRef = "R"..tostring(nNumRef+ 1)
|
||||
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
|
||||
--
|
||||
@@ -448,13 +499,7 @@ function TOOL.SetPairInfo( tbInfo, nIdMyRef, sToNamePart, nIdRefDest, nPairSpin)
|
||||
EgtSetInfo(nPart, "PairToRef", sToNamePart.."_"..sNameRefDest)
|
||||
EgtSetInfo(nPart, "PairSpin", nPairSpin)
|
||||
EgtSetInfo(nPart, "PairAng", tbInfo.dPairAng)
|
||||
local nPairMode = 4
|
||||
if tbInfo.nJunctionType == 1 then
|
||||
nPairMode = 1
|
||||
elseif tbInfo.nJunctionType == 2 then
|
||||
nPairMode = 2
|
||||
end
|
||||
EgtSetInfo(nPart, "PairMode", nPairMode)
|
||||
EgtSetInfo(nPart, "PairMode", tbInfo.nPairMode)
|
||||
end
|
||||
|
||||
-- Disegna la quota lineare
|
||||
@@ -595,23 +640,28 @@ 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 dXOffset = 0
|
||||
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
|
||||
dXOffset = dDeltaStart
|
||||
dXOffset2 = dDeltaStart
|
||||
-- extend end
|
||||
dLen1 = dLen1 + dTh1 * tan(90- math.abs(dAngBetween))
|
||||
local dDeltaEnd = dTh1 * tan(90- math.abs(dAngBetween))
|
||||
dLen1 = dLen1 + dDeltaEnd
|
||||
dXOffset1 = dDeltaEnd
|
||||
elseif nType == 2 then
|
||||
-- trim end
|
||||
dLen1 = dLen1 - dTh2 / sin(dAngBetween)
|
||||
local dDeltaEnd = - dTh2 / sin(dAngBetween)
|
||||
dLen1 = dLen1 + dDeltaEnd
|
||||
dXOffset1 = dDeltaEnd
|
||||
-- extend start
|
||||
local dDeltaStart = dTh2 * tan(90- math.abs(dAngBetween))
|
||||
dLen2 = dLen2 + dDeltaStart
|
||||
dXOffset = dDeltaStart
|
||||
dXOffset2 = dDeltaStart
|
||||
end
|
||||
else
|
||||
-- qui sto estendendo le lunghezze, infatti gli angoli sono nergativi e quindi anche il loro seno
|
||||
@@ -620,26 +670,29 @@ function TJunction(dAngBetween, dTh1, dTh2, nType, dLen1, dLen2, bOnLoop)
|
||||
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
|
||||
dXOffset = 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
|
||||
dXOffset = dDeltaStart
|
||||
dXOffset2 = dDeltaStart
|
||||
-- accorcio l'end
|
||||
dLen1 = dLen1 - dTh1 * tan(90- math.abs(dAngBetween))
|
||||
local dDeltaEnd = - dTh1 * tan(90- math.abs(dAngBetween))
|
||||
dLen1 = dLen1 + dDeltaEnd
|
||||
dXOffset1 = dDeltaEnd
|
||||
end
|
||||
end
|
||||
return dLen1, dLen2, dXOffset
|
||||
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 dXOffest = 0
|
||||
local dXOffset = 0
|
||||
if not bOnLoop then
|
||||
local dDelta1 = dTh2 / sin( dAngBetween)
|
||||
local dDelta2 = dTh1 / sin( dAngBetween)
|
||||
@@ -651,7 +704,7 @@ function AngleJunction(dAngBetween, dTh1, dTh2, dLen1, dLen2, bOnLoop)
|
||||
dLen2 = dLen2 + dDelta2
|
||||
end
|
||||
end
|
||||
return dLen1, dLen2, dXOffest
|
||||
return dLen1, dLen2, dXOffset, dXOffset
|
||||
end
|
||||
|
||||
function ManageJunction(dAngBetween, dTh1, dTh2, nType, dLen1, dLen2, bOnLoop)
|
||||
@@ -681,7 +734,7 @@ function TOOL.CreateAdjustedPart( nLayOutloop, dLen, dH, dBeta1, dBeta2)
|
||||
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.nOutLay end
|
||||
if not nLayOutloop then nLayOutloop = TOOL.tbInfo.nLayLoop end
|
||||
|
||||
-- creo i lati del pezzo
|
||||
local dProj1 = dH * tan( dBeta1 - 90)
|
||||
@@ -746,13 +799,17 @@ function TOOL.CreateParetina(nEdgeId, tbInfo, dPairAngCorr)
|
||||
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, 'dTh','d')
|
||||
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
|
||||
@@ -761,16 +818,18 @@ function TOOL.CreateParetina(nEdgeId, tbInfo, dPairAngCorr)
|
||||
if PrevAng < 0 then dSideAngDx = dSideAngDx * (-1) end
|
||||
tbInfo.dSideAngR = dSideAngDx
|
||||
if not tbInfo.bOnLoop then
|
||||
dLenPrev, dLen, _ = ManageJunction(PrevAng,dTh, dTh,tbInfo.nJunctionType, dLenPrev, dLen)
|
||||
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, _ = ManageJunction(PrevAng,dTh, dTh,tbInfo.nJunctionType, dLenPrev, dLen)
|
||||
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)
|
||||
@@ -782,30 +841,34 @@ function TOOL.CreateParetina(nEdgeId, tbInfo, dPairAngCorr)
|
||||
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.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)
|
||||
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, _ = ManageJunction(NextAng, dTh, dTh, tbInfo.nJunctionType, dLen, dLenNext)
|
||||
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, _ = ManageJunction(NextAng, dTh, dTh, tbInfo.nJunctionType, dLen, dLenNext)
|
||||
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)
|
||||
@@ -817,7 +880,8 @@ function TOOL.CreateParetina(nEdgeId, tbInfo, dPairAngCorr)
|
||||
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.nJunctionType == 1 then dXOffset = dXOffset + dOffset end
|
||||
if tbInfo.nPairMode == 1 then dXOffset = dXOffset + dOffset end
|
||||
end
|
||||
end
|
||||
tbInfo.dLen = dLen
|
||||
@@ -829,6 +893,8 @@ local function ClearPart(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
|
||||
@@ -843,72 +909,149 @@ local function ClearPart(nPartId)
|
||||
EgtSetInfo(nPartId, "Child", "")
|
||||
end
|
||||
|
||||
-- local function AdaptNeighbour(nPartNeigh)
|
||||
-- TOOL.tbInfo = {}
|
||||
-- FillInfoTableFromPart(nPartNeigh)
|
||||
|
||||
-- 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.nLay or TOOL.nLay == GDB_ID.NULL then TOOL.nLay = EgtGetParent(TOOL.nEdgeId) end
|
||||
local nEdges = EgtGetGroupObjs(TOOL.nLay)
|
||||
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
|
||||
local sNamePrev = "A"..tostring(nPrev)
|
||||
TOOL.tbInfo.nPrevId = EgtGetInfo(TOOL.tbInfo.nParent, sNamePrev, "i")
|
||||
if TOOL.tbInfo.nPrevId then
|
||||
EgtSetInfo(TOOL.tbInfo.nPrevId, "Next", TOOL.tbInfo.nId)
|
||||
EgtSetInfo(TOOL.tbInfo.nId, "Prev", TOOL.tbInfo.nPrevId)
|
||||
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
|
||||
local nNext = TOOL.tbInfo.nEdge == nEdges and 1 or TOOL.tbInfo.nEdge + 1
|
||||
local sNameNext = "A"..tostring(nNext)
|
||||
TOOL.tbInfo.nNextId = EgtGetInfo(TOOL.tbInfo.nParent, sNameNext, "i")
|
||||
if TOOL.tbInfo.nNextId then
|
||||
EgtSetInfo(TOOL.tbInfo.nNextId, "Prev", TOOL.tbInfo.nId)
|
||||
EgtSetInfo(TOOL.tbInfo.nId, "Next", TOOL.tbInfo.nNextId)
|
||||
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)
|
||||
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 then
|
||||
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.nLay = EgtGetParent(TOOL.tbInfo.nEdgeId)
|
||||
TOOL.tbIdLoop = FindEdges(TOOL.tbInfo.nLay, TOOL.tbInfo) -- tabella che contiene gli id degli Edge del loop
|
||||
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 se nelle info del parent se era già stato creato il part associato a quel lato
|
||||
-- controllo nelle info del parent se era già stato creato il part associato a quel lato
|
||||
local sEdgeName = EgtGetName(TOOL.tbInfo.nEdgeId)
|
||||
local nEdge = tonumber(string.sub(sEdgeName, 2))
|
||||
-- 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 nChildPart = EgtGetInfo(TOOL.tbInfo.nParent, sEdgeName, "i")
|
||||
local tbChildName = EgtGetInfo(TOOL.tbInfo.nParent, sEdgeName, "vs")
|
||||
local nChildPart = nil
|
||||
local dPairAng = 0
|
||||
|
||||
if not nChildPart then
|
||||
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 = EgtGetName(EgtGetParent(TOOL.tbInfo.nEdgeId)) == "OutLoop" and "Part" or "InPart"
|
||||
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 = EgtGetInfo(TOOL.tbInfo.nId, "Prev", "i") or GDB_ID.NULL
|
||||
TOOL.tbInfo.nNextId = EgtGetInfo(TOOL.tbInfo.nId, "Next", "i") or GDB_ID.NULL
|
||||
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
|
||||
TOOL.tbInfo.sName = EgtGetName(TOOL.tbInfo.nId)
|
||||
local tbLayers = TOOL.FindLayers(TOOL.tbInfo.nId)
|
||||
TOOL.tbInfo.nOutLay = tbLayers["OutLoop"]
|
||||
TOOL.tbInfo.nLayLoop = tbLayers["OutLoop"]
|
||||
|
||||
TOOL.CreateParetina()
|
||||
TOOL.CreateAdjustedPart()
|
||||
@@ -919,7 +1062,6 @@ function TOOL.CreateParetinaFull(bPrev, bNext)
|
||||
-- creo i riferimenti e salvo i parametri del part
|
||||
local sNamePartDest = EgtGetName(TOOL.tbInfo.nParent)
|
||||
local sEdgeDest = EgtGetName(TOOL.tbInfo.nEdgeId)
|
||||
local sRefDest = "R"..string.sub(sEdgeDest, 2)
|
||||
local sLayEdgeDest = EgtGetName(EgtGetParent(TOOL.tbInfo.nEdgeId))
|
||||
if TOOL.tbInfo.bOnLoop then
|
||||
-- waterfall
|
||||
@@ -935,36 +1077,35 @@ function TOOL.CreateParetinaFull(bPrev, bNext)
|
||||
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.dThParent, TOOL.tbInfo.sDestRefOff)
|
||||
local nIdMyRef = TOOL.CreateReference( TOOL.tbInfo.nId, 'OutLoop', 'A1', TOOL.tbInfo.dTh, TOOL.tbInfo.sRefOff)
|
||||
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)
|
||||
-- local nNextId = TOOL.tbInfo.nNextId
|
||||
-- local nCurr = TOOL.tbInfo.nId
|
||||
-- if bPrev and TOOL.tbInfo.nPrevId and TOOL.tbInfo.nPrevId ~= GDB_ID.NULL then
|
||||
-- FillInfoTableFromPart(TOOL.tbInfo.nPrevId)
|
||||
-- TOOL.CreateParetinaFull(false, false)
|
||||
-- end
|
||||
-- -- modifico anche la paretina successiva(se esiste)
|
||||
-- if bNext and nNextId and nNextId ~= GDB_ID.NULL then
|
||||
-- FillInfoTableFromPart(nNextId)
|
||||
-- TOOL.CreateParetinaFull(false, false)
|
||||
-- end
|
||||
|
||||
-- devo modificare anche la paretina precedente e la successiva
|
||||
-- modifico anche la paretina precedente(se esiste)
|
||||
-- creo il solido e lo accoppio
|
||||
--local nCurr = TOOL.tbInfo.nId -- debug -- SARà DA TOGLIERE quando scommento la parte di aggiornamento prev e next
|
||||
if SLD then
|
||||
SLD.CurrId = nCurr
|
||||
SLD.CurrId = TOOL.tbInfo.nId
|
||||
SLD.Main()
|
||||
end
|
||||
|
||||
if ASS then
|
||||
ASS.nVeinCtx = EgtGetContext()
|
||||
ASS.nPartId = nCurr
|
||||
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 = {}
|
||||
|
||||
Reference in New Issue
Block a user