Egalware/frontalini
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
e5a366ced153bf2066c7d395ae41ed3192425a6b
frontalini/Frontalini_ecc/CompoAF/Alz&Front.lua
T
Carlo Baronchelli e5a366ced1 Come precedente
2021-10-19 16:53:22 +02:00

750 lines
34 KiB
Lua
Raw Blame History

-- 2021/06/__
-- (exRettangolo interno dati base e altezza)
-- 21/06/2021 Nicola Pievani: creazione del file Alz&Front
-- 05/07/2021 Nicola Pievani: Inserisco commenti
-- 08/07/2021 CB: inizio disegno dei 'rettangoli esterni'
-- 00b 10/07/2020 CB: costruzione della tabella "MyTab"
-- 00c 13/07/2021 CB: introduzone record "SideREc" e tabella "SideTab"
-- 00d 15/07/2021 CB: introduzione funzione per disegno rettangoli
-- 00e 16/07/2021
-- 00f 20/07/2021
-- 21/07/2021 - aggiornato progetto in GIT
-- 26/07/2021 - 'chiuso' i rettangoli, noiminati i rispettivi lati
-- - studio casi per inserimento InfoAF per tagli inclinati
-- 28/07/2021 - semplificazione di SideTab e aggiunta angoli tra lati consecutivi
-- 29/07/2021 - inserimento InfoAF per tagli inclinati
-- 30/07/2021 - separazione dei casi tra frontalini e alzatine
-- 1/08/e segg - funzione SideAngSetInfo con anche prova etichette inclinazione
-- 3/08/2021 - inserimento info con riferimento al lato del
-- - inizio studio per 'spostamenti'
-- 9/08/2021 - aggiunto PzId in SideRec ('spostando' tutti gli altri campi !)
-- 20/08/2021 - prova calcolo intersezioni con 'pseudorette' dei lati dei rettangoli
-- 23/08/2021 - inizio calcolo spostamenti con trigonometria
-- 30/08/2021 - caso [b(r1r2r3
-- 06/10/2021 - da Sara 00a con modifiche by Nicola + correzioni
-- 19/10/2021 - etichettatura lati inclinati ... o completamento casi mancanti ...?
-- |TO DO : Imporre una soglia minima per angolo di inclinazione tagli|
-- Intestazioni
require( 'EgtBase')
_ENV = EgtProtectGlobal()
EgtEnableDebug( true)
EgtAddToPackagePath(EgtGetSourceDir() .. 'LuaLibs\\?.lua')
require( 'EgtCompo')
-- Valori limite
local LgMin = 10
local RMin = 5
-- Parametri : dichiarazione e valori standard
--.T (tipo) : 0=null, 1=bool, 2=int, 3=len, 4=num, 5=string
local CMP = {}
-- elenco dei parametri visualizzati nell'interfaccia del programma OMAG-Cut
CMP.A_Height=30 -- altezza delle alzatine
CMP.F_Height=30 -- altezza dei frontalini
CMP.A_DeltaAng=0 -- angolo (semiangolo) di incremento per tagli inclinati
CMP.F_DeltaAng=0.5
CMP.ThicknessRaw=10 -- spessore del grezzo
-- parametri passati da OmagCut
CMP.BBoxRad = 1000
CMP.HeightText = 100
--
_G.CMP = CMP
-- 2021/08
-- Disegna i lati di un rattangolo dati layer, Punto, base, altezza;
-- 'allineato al sistema di riferimento' =: base parallela al sistema di riferimento dato
-- sarebbe superata dall'uso diretto della funzione di disegno Rettangolo
-- se non servissse distinguare i singoli lati
local function DrawRectangle (Pz, Lay, BaseL, HeightL, sName, sReference, Delta1, Delta2)
-- insrisco un commento nel pezzo per descriverlo
EgtSetInfo( Pz, "CMP", "AlzFront")
local Lr = EgtGroup( Pz, GDB_RT.LOC)
EgtSetName( Lr, "Region")
-- sul prim lato della figura copio l'identificatico univoco presente nel lato della cucina a cui è associato
local Pt = Point3d( -Delta1,0,0)
local l1 = EgtLinePDL( Lay, Pt, 0, BaseL)
EgtSetName( l1, sName.." l1")
EgtSetInfo( l1, "RefAF", sReference)
local l2 = EgtLinePDL( Lay, EgtEP( l1), 90, HeightL)
EgtSetName( l2, sName.." -l2")
local l3 = EgtLinePDL( Lay, EgtEP( l2), 180, BaseL)
EgtSetName( l3, sName.." -l3")
local l4 = EgtLine( Lay, EgtEP( l3), EgtSP( l1))
EgtSetName( l4,sName.." -l4")
local RectContour = EgtCurveCompo(Lay,{l1,l2,l3,l4},false)
local s1 = EgtSurfFlatRegion(Lr,RectContour)
if CMP.ERR == 0 then
EgtSetColor(s1,AQUA())
else
EgtSetColor(s1,ORANGE())
end
EgtSetAlpha(s1,25)
EgtErase( RectContour)
return l1, l2, l3, l4
end
--
-- Scrittura info e etichetta con inclinazione dei lati dei rettangoli
local function SideAngSetInfo(SideId, Lay, Gamma, dOffset, dHLbl, Text)
EgtSetInfo( SideId, "SideAng", Gamma) -- -F_Delta?
EgtSetInfo( SideId, "OrigSideAng", Gamma) -- -F_Delta
local Lbl
if Text == nil then
Lbl = EgtNumToString(Gamma,1)..'°'
--LblL1 = AddLabelAl( Lay, SideId, dOffset*0.02, Lbl, dHLbl, -90, BLACK())
LblL1 = AddLabel( Lay, SideId, dOffset*0.02, Lbl, dHLbl/1.5, -90, BLACK())
else
Lbl = Text..EgtNumToString(Gamma,1)..'°'
--LblL1 = AddLabelAl( Lay, SideId, dOffset*0.02, Lbl, dHLbl, -90, BLACK())
LblL1 = AddLabel( Lay, SideId, dOffset*0.02, Lbl, dHLbl, -90, BLACK())
end
end
--
-- rimuove l'informazione del taglio inclinato dal lato indicato del piano cucina
local function ResetSideAng( CurrSide) -- IsModify
if EgtGetInfo( CurrSide, "IsModify", 'i') == 0 then
return
end
if EgtExistsInfo( CurrSide, "SideAng") then
EgtRemoveInfo( CurrSide, "SideAng")
EgtRemoveInfo( CurrSide, "OrigSideAng")
end
end
--
-- costruisco la teballe che contiene le informazioni prese dal piano cucina
-- |LEGENDA 1: campi di SideTab|
-- |.IdSd = Side_Id; .IdPz = Pz_Id; .Frame = Ref_Id; .InfoSd = SideInfo(Alz/Front);|
-- |.l1---.l4 = Rectangle sides|; |.RContour = contorno del rettengolo|
-- |.RecPrv = Previous Record; RecNxt = Next Record|
-- |.VectS = Side Start Vector; .VectE = Side End Vector;|
-- |.zPrvAng = PrecSide-Side_Angle; .zNxtAng = Side-ProxSide_Angle.|
-- |.RefAF = GUID Reference.|
local function LoadData( SideTab, Lw, Le, dOffset, dHLbl)
-- contatore usato per conoscere il numero di lati inserito
local SideNum =1
-- ricerco nel layer OutLoop tutti i lati del piano cucina
local CurrSide = EgtGetFirstInGroup( Lw)
local PrecSide = nil
while CurrSide ~= nil do
local SideRec = {}
-- recupero informazione sul tipo di rettangolo da costruire (Alzatina o Frontalino)
local InfoAF = EgtGetInfo( CurrSide, "AF", 'i')
-- recupero informazione del riferimento univoco generato in OmagCUT (deve esistere)
local InfoRefGUID = EgtGetInfo( CurrSide, "RefAF", 's')
-- se non esite nessuna informazione allora inizializzo a 0
if InfoAF == nil then
InfoAF = 0
end
-- se primo lato
if SideNum == 1 then
SideRec = {IdSd = CurrSide, IdPz = nil, InfoSd = InfoAF, RecPrv = 0, RecNxt = SideNum+1,
VectS = EgtSV(CurrSide), VectE = EgtEV(CurrSide), RefAF = InfoRefGUID}
-- se lato successivo al primo
else
local v1 = SideTab[SideNum-1].VectE
local v2 = EgtSV(CurrSide)
local Angv1v2 = atan2( (v1^v2)*Z_AX(),v1*v2)
SideRec = { IdSd = CurrSide, IdPz = nil, InfoSd = InfoAF, RecPrv = SideNum-1, RecNxt = SideNum+1,
VectS = EgtSV(CurrSide), VectE = EgtEV(CurrSide), RefAF = InfoRefGUID,
zPrvAng = Angv1v2 }
-- Assegno la lato precedente (SideNum-1) l'informazione del lato corrente (SideNum)
SideTab[SideNum-1].zNxtAng = Angv1v2
end
-- (per visualizzazione in OmagCUT)
if InfoAF == 1 then
EgtSetColor(CurrSide, 'RED')
elseif InfoAF == 2 then
EgtSetColor(CurrSide, 'GREEN')
else
-- elimino eventuali angoli di taglio inseriti dovuti a precedenti frontalini
ResetSideAng( CurrSide)
EgtSetColor(CurrSide, 'BLACK')
end
-- Inserico nella tabella la tabella costruita temporaneamente per salvare i dati
table.insert(SideTab, SideRec)
-- passo al lato successivo
PrecSide = CurrSide
CurrSide = EgtGetNext( CurrSide)
SideNum = SideNum + 1
end --while
-- completo la tabella con i riferimenti tra ultimo lato e primo (in quanto successivo all'ultimo)
if #SideTab > 1 then
local v1 = SideTab[#SideTab].VectE
local v2 = SideTab[1].VectS
local Angv1v2 = atan2( (v1^v2)*Z_AX(),v1*v2)
SideTab[#SideTab].RecNxt = 1
SideTab[1].RecPrv = #SideTab
SideTab[#SideTab].zNxtAng = Angv1v2
SideTab[1].zPrvAng = Angv1v2
end
end
--
-- a partire dal primo pezzo (il piano cucina) elimino tutti i pezzi "Alz-Front"
local function ResetDraw( Pz)
local TabOfPart = {}
local CurrPz = EgtGetNextPart( Pz)
while CurrPz ~= nil do
if "Alz-Front" == EgtGetName( CurrPz) then
table.insert( TabOfPart, CurrPz)
end
CurrPz = EgtGetNextPart( CurrPz)
end
EgtErase( TabOfPart)
end
--
-- Funzione di disegno
local function CMP_Draw(bPreview)
-- Carico i messaggi
local Msg = require('EgtCompoMsg')
CMP.ERR = 0
CMP.MSG = ''
-- Assegno l'angolo di incremento per i tagli inclinati
local F_Delta = CMP.F_DeltaAng
local A_Delta = CMP.A_DeltaAng
-- Assegno l'altezza
local FH = CMP.F_Height
local AH = CMP.A_Height
-- Assegno la dimensione di riferimento (=1/10 del 'raggio' della figura)
local dDim = CMP.BBoxRad
local dHLbl = CMP.HeightText
local dStdOffs = dDim*.05 -- vedi etichettatura lati inclinati
local dOffsR = dDim*.2 -- distanziamento dei rettangoli dai lati del componente
local dOffsC = dDim*.25 -- 'costante' aggiuntiva per spostamenti
--
CMP.ERR = 0
CMP.MSG = ''
-- Pezzo e Layer già definiti
local Pz = EgtGetFirstGroupInGroup( GDB_ID.ROOT)
-- ripulisco il disegno
ResetDraw( Pz)
if not Pz then
CMP.ERR = 5
CMP.MSG = "Pezzo non trovato"
return
end
local La = EgtGetFirstNameInGroup( Pz, "LayAux")
local Le = EgtGetFirstNameInGroup( Pz, "Etichette")
local Lq = EgtGetFirstNameInGroup( Pz, "Quotature")
local Lo = EgtGetFirstNameInGroup( Pz, "Region")
local Lw = EgtGetFirstNameInGroup( Pz, "OutLoop")
local Ls = EgtGetFirstNameInGroup( Pz, "SelectRegion")
--local PzAF = EgtGroup(GDB_ID.ROOT,GDB_RT.LOC) -- ??? nuova part: alzatine e frontalini ???????
--local LyA = EgtGroup(PzAF,GDB_RT.LOC) -- layer alzatine
--EgtSetName(LyA,'Alzatine')
--local LyF = EgtGroup(PzAF,GDB_RT.LOC) -- layer frontalini
--EgtSetName(LyF,'Frontalini')
--local LyAe = EgtGroup(PzAF,GDB_RT.LOC) -- layer etichette alzatine
--EgtSetName(LyAe,'Etich_Alzatine')
--local LyFe = EgtGroup(PzAF,GDB_RT.LOC) -- layer etichette frontalini
--EgtSetName(LyFe,'Etich_Frontalini')
if not Ls then
Ls = EgtGroup( Pz, GDB_RT.LOC)
EgtSetName( Ls, "SelectRegion")
end
--[[ **COMMENTATO PER TEST**
if not La or not Lo or not Lw or not Le or not Lq then
CMP.ERR = 6
CMP.MSG = "Layer non trovato"
return
end
]]
local Lr = EgtGetFirstNameInGroup( Pz, "ErrorLay")
if Lr then
EgtEmptyGroup(Lr)
else
Lr = EgtGroup( Pz, GDB_RT.LOC)
EgtSetName( Lr, "ErrorLay")
end
--[[ **COMMENTATO PER TEST**
-- spengo i layer Aux e Quotature
EgtSetStatus( La, GDB_ST.OFF)
EgtSetStatus( Lq, GDB_ST.OFF)
]]
local sInd = nil
--[[ faccio scorrere tutti gli elementi del layer OutLoop e di ognuno leggo se contiente nelle Info "AF=x"
"AF=0" ( o nil) => al lato non deve essere associatu nulla
"AF=1" => al lato deve essere associto un'alzatina
"AF=2" => al lato deve essere associato un frontalino
nel ciclo while che segue carico una tabella contenente tutti i lati e i riferimenti ai lati successivi,
oltre a informazioni sulle direzioni iniziali/finali dei lati cghe seguono/precedono.
(In questa fase possono essere aggiunte altre informazioni...)
La variabile sMsg è usta dal programma per verificare che i lati letti dalla tabella siano gli stessi
passati dal programma
]]
local sMsg = " "
local SideNum =1
-- **COSTRUZIONE DELLA TABELLA DEI LATI DEL COMPONENTE** (es. piano cucina)
-- --------------------------------------------------------------------
local SideTab = {}
-- |LEGENDA 1: campi di SideTab|
-- |.IdSd = Side_Id; .IdPz = Pz_Id; .Frame = Ref_Id; .InfoSd = SideInfo(Alz/Front);|
-- |.l1---.l4 = Rectangle sides|; |.RContour = contorno del rettengolo|
-- |.RecPrv = Previous Record; RecNxt = Next Record|
-- |.VectS = Side Start; ; .VectE = Side End Vector;|
-- |.zPrvAng = PrecSide-Side_Angle; .zNxtAng = Side-ProxSide_Angle.|
-- |.RefAF = GUID Reference.|
LoadData( SideTab, Lw)
-- restituisco un messaggio al programma OmagCUT
CMP.MSG = sMsg
-- **COSTRUZIONE DELLE FIGURE** (rettangoli) rappresentative di alzatine o frontalini
-- -------------------------------------------------------------------------------
for SideNum = 1 , #SideTab do
-- se è richiesto un'alzatina o un frontalino (InfoSd=1 oppure InfoSd=2)
if SideTab[SideNum].InfoSd > 0 then
-- recupero le informazioni dalla tabella
local Side = SideTab[SideNum].IdSd
local SVect = SideTab[SideNum].VectS
local EVect = SideTab[SideNum].VectE
local RefToAF = SideTab[SideNum].RefAF
local BaseL; local HeightL
local sName
-- Costruisco il sistema di riferimento per il rettangolo
local Pt = EgtEP( Side) + VRotated( EVect*dOffsR, -90)
local Frame = Frame3d( Pt, -EVect, VRotated(EVect,-90), Vector3d(0,0,1))
-- nuova parte per alzatina o frontalino
local Pz = EgtGroup(GDB_ID.ROOT, Frame, GDB_RT.GLOB)
EgtSetName(Pz,"Alz-Front")
-- assegno alla tabella l'Id del pezzo appena creato
SideTab[SideNum].IdPz = Pz
-- creo Layer per il pezzo appena creato
local Lay = EgtGroup( Pz)
EgtSetName(Lay,"OutLoop")
local LayLbl = EgtGroup( Pz)
EgtSetName(LayLbl,"Etichette")
-- |ALZATINA|
if SideTab[SideNum].InfoSd == 1 then
EgtSetColor(Lay,RED(),100,true)
BaseL = EgtCurveLength( Side)
sName = "Side "..SideNum.." -A"
HeightL = AH
-- |FRONTALINO|
elseif SideTab[SideNum].InfoSd == 2 then
EgtSetColor(Lay,GREEN(),100,true)
BaseL = EgtCurveLength( Side)
sName = "Side "..SideNum.." -F"
HeightL = FH
SideTab[SideNum].Frame = Frame --**?????????????????***** anche QUI *??????????????<<<<<<
end
-- chiamo la funzione per il disegno (senso antiorario) dei lati del rettangolo 'allineato'
--local l1, l2, l3, l4 = DrawRectangle (Pz, Lay, BaseL, HeightL, sName, RefToAF)
-- inserisco gli Id dei lati del rettangolo nel Side_Record in SideTab
--SideTab[SideNum].l1 = l1; SideTab[SideNum].l2 = l2; SideTab[SideNum].l3 = l3; SideTab[SideNum].l4 = l4
-- **INFO PER TAGLI INCLINATI**
-- --------------------------
-- |ripeti LEGENDA 1: campi di SideTab)|
-- |.IdSd = Side_Id; .IdPz = Pz_Id; .Frame = Ref_Id; .InfoSd = SideInfo(Alz/Front);|
-- |.l1---.l4 = Rectangle sides|; |.RContour = contorno del rettengolo|
-- |.RecPrv = Previous Record; RecNxt = Next Record|
-- |.VectS = Side Start; ; .VectE = Side End Vector;|
-- |.zPrvAng = PrecSide-Side_Angle; .zNxtAng = Side-ProxSide_Angle|
-- |.RefAF = GUID Reference.|
local Tab = SideTab
local N = SideNum
local Alphap; local Alphas
local Betap; local Betas
-- angoli tra lato precedente e attuale
Alphap = Tab[N].zPrvAng;
if Alphap >= 0 then
Betap = 180-Alphap
else
Betap = (180+Alphap)
end
-- angoli tra lato attuale e successivo
Alphas = Tab[N].zNxtAng;
if Alphas >= 0 then
Betas = 180-Alphas
else
Betas = (180+Alphas)
end
local Gamma1 -- angolo di taglio su lato l2
local Gamma2 -- angolo di taglio su lato l4
local Delta1=0
local Delta2=0
-- **ALZATINE**
if Tab[N].InfoSd == 1 then
-- CASI RIFERITI AL LATO PRECEDENTE
-- **Ap0.sx** = non continua da lato precedente, angolo 'a sx'
if (Tab[N].InfoSd ~= Tab[Tab[N].RecPrv].InfoSd) and Alphap > 0 then
Gamma1 = 90 - Betap -- - A_Delta
--SideAngSetInfo ( l2, LayLbl, Gamma, dStdOffs, dHLbl)
-- (in caso **p0.sx.2** = Alphap <= 90, non si fa taglio inclinato)
-- **Ap0.dx** = non continua da lato precedente, angolo 'a dx'
elseif (Tab[N].InfoSd ~= Tab[Tab[N].RecPrv].InfoSd) and Alphap < 0 then
Gamma1 = 90 - Betap -- - A_Delta
--SideAngSetInfo ( l2, LayLbl, Gamma, dStdOffs, dHLbl)
-- **Ap1.sx** = continua da lato precedente, angolo 'a sx'
elseif (Tab[N].InfoSd == Tab[Tab[N].RecPrv].InfoSd) and Alphap > 0 then
Gamma1 = (90 - Betap/2) -- - A_Delta/2)
--SideAngSetInfo ( l2, LayLbl, Gamma, dStdOffs, dHLbl)
-- **Ap1.dx** = continua da lato precedente, angolo 'a dx'
elseif (Tab[N].InfoSd == Tab[Tab[N].RecPrv].InfoSd) and Alphap < 0 then
-- ************************************* togliere il meno ?
Gamma1 = -(90 - Betap/2) -- - A_Delta/2)
-- **************************************
--SideAngSetInfo ( l2, LayLbl, Gamma, dStdOffs, dHLbl)
end
-- CASI RIFERITI AL LATO SUCCESSIVO
-- **1) As0.sx** = non continua al lato successivo, angolo 'a sx'
if (Tab[N].InfoSd ~= Tab[Tab[N].RecNxt].InfoSd) and Alphas > 0 then
Gamma2 = 90 - Betas -- - A_Delta
--SideAngSetInfo ( l4, LayLbl, Gamma, dStdOffs, dHLbl)
-- **2) As0.dx** = non continua al lato successivo, angolo 'a dx'
elseif (Tab[N].InfoSd ~= Tab[Tab[N].RecNxt].InfoSd) and Alphas < 0 then
Gamma2 = 90 - Betas -- - A_Delta
--SideAngSetInfo ( l4, LayLbl, Gamma, dStdOffs, dHLbl)
-- **3) As1.sx** = continua al lato successivo, angolo 'a sx'
elseif (Tab[N].InfoSd == Tab[Tab[N].RecNxt].InfoSd) and Alphas > 0 then
Gamma2 = (90 - Betas/2) -- -A_Delta/2)
--SideAngSetInfo ( l4, LayLbl, Gamma, dStdOffs, dHLbl)
-- **4) As1.dx** = continua al lato successivo, angolo 'a dx'
elseif (Tab[N].InfoSd == Tab[Tab[N].RecNxt].InfoSd) and Alphas < 0 then
-- ************************************* togliere il meno ?
Gamma2 = - (90-Betas/2) -- -A_Delta/2)
-- **************************************
--SideAngSetInfo ( l4, LayLbl, Gamma, dStdOffs, dHLbl)
end
Delta1 = -tan( Gamma1)*CMP.ThicknessRaw
Delta2 = -tan( Gamma2)*CMP.ThicknessRaw
-- chiamo la funzione per il disegno (senso antiorario) dei lati del rettangolo 'allineato'
local l1, l2, l3, l4 = DrawRectangle (Pz, Lay, BaseL + Delta1 + Delta2 , HeightL, sName, RefToAF, Delta1, Delta2)
-- inserisco gli Id dei lati del rettangolo nel Side_Record in SideTab
SideTab[SideNum].l1 = l1; SideTab[SideNum].l2 = l2; SideTab[SideNum].l3 = l3; SideTab[SideNum].l4 = l4
SideAngSetInfo ( l2, LayLbl, Gamma1, dStdOffs, dHLbl)
SideAngSetInfo ( l4, LayLbl, Gamma2, dStdOffs, dHLbl)
-- **FRONTALINI**
elseif Tab[N].InfoSd == 2 then
-- |ripeti LEGENDA 1: campi di SideTab)|
-- |.IdSd = Side_Id; .IdPz = Pz_Id; .Frame = Ref_Id; .InfoSd = SideInfo(Alz/Front);|
-- |.l1---.l4 = Rectangle sides|
-- |.RecPrv = Previous Record; RecNxt = Next Record|
-- |.VectS = Side Start; ; .VectE = Side End Vector;|
-- |.zPrvAng = PrecSide-Side_Angle; .zNxtAng = Side-ProxSide_Angle|
-- |.RefAF = GUID Reference.|
-- CASI RIFERITI AL LATO PRECEDENTE
-- **1) Fp0.sx** = non continua da lato precedente, angolo 'a sx'
if (Tab[N].InfoSd ~= Tab[Tab[N].RecPrv].InfoSd) and Alphap > 0 then
if Alphap > 90 then
Gamma1 = Betap - 90 -- meno F_Delta ????
--SideAngSetInfo ( l2, LayLbl, Gamma, dStdOffs, dHLbl)
-- (in caso Alphap <= 90, non si fa taglio inclinato)
else
Gamma1 = 0
--SideAngSetInfo ( l2, LayLbl, Gamma, dStdOffs, dHLbl)
end
-- **2) Fp0.dx** = non continua da lato precedente, angolo 'a dx'
elseif (Tab[N].InfoSd ~= Tab[Tab[N].RecPrv].InfoSd) and Alphap < 0 then
if -Alphap > 90 then
Gamma1 = 90 - Betap -- meno F_Delta ????
--SideAngSetInfo ( l2, LayLbl, Gamma, dStdOffs, dHLbl)
-- (in caso -Alphap <= 90, non si fa taglio inclinato)
else
Gamma1 = 0
--SideAngSetInfo ( l2, LayLbl, Gamma, dStdOffs, dHLbl)
end
-- **3) Fp1.sx** = continua da lato precedente, angolo 'a sx'
elseif (Tab[N].InfoSd == Tab[Tab[N].RecPrv].InfoSd) and Alphap > 0 then
Gamma1 = -(90-Betap/2+F_Delta)
--SideAngSetInfo ( l2, LayLbl, Gamma, dStdOffs, dHLbl)
-- **4) Fp1.dx** = continua da lato precedente, angolo 'a dx'
elseif (Tab[N].InfoSd == Tab[Tab[N].RecPrv].InfoSd) and Alphap < 0 then
Gamma1 = 90-Betap/2-F_Delta
--SideAngSetInfo ( l2, LayLbl, Gamma, dStdOffs, dHLbl)
end
-- CASI RIFERITI AL LATO SUCCESSIVO
-- |ripeti LEGENDA 1: campi di SideTab)|
-- |.IdSd = Side_Id; .IdPz = Pz_Id; .Frame = Ref_Id; .InfoSd = SideInfo(Alz/Front);|
-- |.l1---.l4 = Rectangle sides|; |.RContour = contorno del rettengolo|
-- |.RecPrv = Previous Record; RecNxt = Next Record|
-- |.VectS = Side Start; ; .VectE = Side End Vector;|
-- |.zPrvAng = PrecSide-Side_Angle; .zNxtAng = Side-ProxSide_Angle|
-- |.RefAF = GUID Reference.|
-- **1) Fs0.sx** = non continua al lato successivo, angolo 'a sx'
if (Tab[N].InfoSd ~= Tab[Tab[N].RecNxt].InfoSd) and Alphas > 0 then
if Alphas > 90 then
Gamma2 = Betas - 90 -- meno F_Delta ????
--SideAngSetInfo ( l4, LayLbl, Gamma, dStdOffs, dHLbl)
-- (in caso Alphap <= 90, non si fa taglio inclinato)
else
Gamma2 = 0
--SideAngSetInfo ( l4, LayLbl, Gamma, dStdOffs, dHLbl)
end
-- **2) Fs0.dx** = non continua al lato successivo, angolo 'a dx'
elseif (Tab[N].InfoSd ~= Tab[Tab[N].RecNxt].InfoSd) and Alphas < 0 then
-- **Fs0.dx.1**
if -Alphas > 90 then
Gamma2 = 90 - Betas -- meno F_Delta ????
--SideAngSetInfo ( l4, LayLbl, Gamma, dStdOffs, dHLbl)
-- (in caso -Alphap <= 90, non si fa taglio inclinato)
else
Gamma2 = 0
--SideAngSetInfo ( l4, LayLbl, Gamma, dStdOffs, dHLbl)
end
-- **3) Fs1.sx** = continua al lato successivo, angolo 'a sx'
elseif (Tab[N].InfoSd == Tab[Tab[N].RecNxt].InfoSd) and Alphas > 0 then
Gamma2 = - (90-Betas/2+F_Delta)
--SideAngSetInfo ( l4, LayLbl, Gamma, dStdOffs, dHLbl)
-- **4) Fs1.dx** = continua al lato successivo, angolo 'a dx'
elseif (Tab[N].InfoSd == Tab[Tab[N].RecNxt].InfoSd) and Alphas < 0 then
Gamma2 = 90-Betas/2-F_Delta
--SideAngSetInfo ( l4, LayLbl, Gamma, dStdOffs, dHLbl)
end
-- chiamo la funzione per il disegno (senso antiorario) dei lati del rettangolo 'allineato'
local l1, l2, l3, l4 = DrawRectangle (Pz, Lay, BaseL + Delta1 + Delta2 , HeightL, sName, RefToAF, Delta1, Delta2)
-- inserisco gli Id dei lati del rettangolo nel Side_Record in SideTab
SideTab[SideNum].l1 = l1; SideTab[SideNum].l2 = l2; SideTab[SideNum].l3 = l3; SideTab[SideNum].l4 = l4
-- Scrivo le INFO per taglio inclinato nei componenti (lati) del disegno
SideAngSetInfo ( l2, LayLbl, Gamma1, dStdOffs, dHLbl)
SideAngSetInfo ( l4, LayLbl, Gamma2, dStdOffs, dHLbl)
-- taglio inclinato a -(45+delta) del lato superiore del frontalino
Gamma = -(45+F_Delta)
SideAngSetInfo ( l1, LayLbl, Gamma, dStdOffs, dHLbl)
SideAngSetInfo ( Tab[N].IdSd, LayLbl, Gamma, dStdOffs, dHLbl, 'A'..EgtNumToString(N)..'=')
-- |TO DO: bisogna cancellare il nome del lato del piano cucina|
-- || oppure concatenare a quest'ultimo l'angolo Gamma e eliminare l'ultima istruzione sopra|
end --AlZATINE/FRONTALINI
-- ???? prevedere caso di errore (info ~= da 1 e da 2 e non nulla ??????
EgtDeselectAll()
-- inserisco info con riferimento al lato del componente
-- EgtSetInfo( l1, "RifSideId", Tab[N].IdSd) -- |<<<<<<<<<<<<<<<<<< bisogna mettere il nome del lato !!? NICOLA: ho creato un ideintificaticativo univoco <<<<<<<<<<<<<<<<<<<<<<<<<|
end -- richiesta alzatina o frontalini
end --for COSTRUZIONE DELLE FIGURE (rettangoli)
-- **CALCOLO DEGLI SPOSTAMENTI PER EVENTUALI INTERSEZIONI DEI RETTANGOLI RAPPRESENTATIVI DI A/F**
-- ------------------------------------------------------------------------------------
-- |Ipotesi 1|: Non più di due angoli 'a destra' consecutivi
-- |Ipotesi 2|: Nel caso di cui sopra, un solo angolo 'chiuso'
-- |ATTENZIONE| un rettangolo già mosso o che non si può muovere 'indietro' deve essere identificato ??!
SideNum = 1
-- for SideNum = 1 , #SideTab do --#SideTab do
while SideNum <= #SideTab do
-- |ripeti LEGENDA 1: campi di SideTab)|
-- |.IdSd = Side_Id; .IdPz = Pz_Id; .Frame = Ref_Id; .InfoSd = SideInfo(Alz/Front);|
-- |.l1---.l4 = Rectangle sides|; |.RContour = contorno del rettengolo|
-- |.RecPrv = Previous Record; RecNxt = Next Record|
-- |.VectS = Side Start; ; .VectE = Side End Vector;|
-- |.zPrvAng = PrecSide-Side_Angle; .zNxtAng = Side-ProxSide_Angle.|
-- |LEGENDA 2: INTERSEZIONI|
-- a) un solo angolo consecutivo a dx (alpha < 0+eps)
-- a.r) due rettangoli
-- a.r1) un solo rettangolo con il lato compo successivo
-- a.r2) un solo rettangolo con il alto compo precedente
-- b) due angoli successivi a dx (alpha1 e alpha 2 < 0°+eps);
-- (|alpha1 |+|alpha2 |>90°, <<180°)
-- solo rettangoli rN e rN+2
-- b.r1r3) si intersecano i due rettangoli
-- b.r1) rN interseca il lato N+2
-- b.r3) rN+2 nterseca il lato N
-- c) come (b) ma con anche il rettangolo rN+1
-- (rN+1 resta fermo a mano che |alpha1 | o |alpha2 |>90° <= | se si ammette questo caso ?????????|
-- bisogna verificare alpha1 e alpha2 se acuti => caso (a) per rN+1; quindi 'sfilare' rN da RN+1 e rN+2 da rN+1
local Tab = SideTab
local N = SideNum
local epsilon = 0.1 -- costante
--local dOffsR = CMP.BBoxRad*0.1 -- distanza dei rettangoli dal lato corrispondente
local dsp1x -- spostamento (nel verso x+ del proprio sist. di rif.) del rettangolo
local dH1, dH2, dH3 -- altezze dei rettangoli N, N+1, N+2 rispettivamente a seconda se alzatine o frontalini
if Tab[N].InfoSd == 1 then dH1 = AH else dH1 = FH end
if Tab[Tab[N].RecNxt].InfoSd == 1 then dH2 = AH else dH2 = FH end
if Tab[Tab[Tab[N].RecNxt].RecNxt].InfoSd == 1 then dH3 = AH else dH3 = FH end
local Alpha1 = Tab[N].zNxtAng
local Beta1 = 180 + Alpha1
local Alpha2 = Tab[Tab[N].RecNxt].zNxtAng
local Beta2 = 180 + Alpha2
-- **[a]: un solo angolo consecutivo a dx**
if Alpha1 < 0 and Alpha2 > 0 then
local dSp1xa, dSp1xb, dSP2xa, dSp2xb
local dSp1x, dSp2x
-- **[a.r1r2]**: entrambi i lati N e N+1 iunteressati da A/F
if Tab[N].InfoSd > 0 and Tab[Tab[N].RecNxt].InfoSd > 0 then
--calcolo degli spostamenti per rettangolo 1 (lato N)
dSp1xa = -(dOffsR+dH2)/sin(Alpha1)
if abs( Alpha1) >= 90 then
--dSP1xb = -(dOffsR+dH1)*tan(90+Alpha1) + dOffsC*tan(90+Alpha1)
dSP1xb = -(dOffsR+dH1)*tan(90+Alpha1) -- - dOffsC*tan(90+Alpha1)
else
dSP1xb = dOffsR*tan(90+Alpha1) -- + dOffsC*tan(90+Alpha1)
end
if abs( Alpha1) >= 90 then
dSp1x = dSp1xa + dSP1xb + dOffsC
else
dSp1x = dSp1xa - dSP1xb + dOffsC
end
-- calcolo degli spostamenti per rettangolo 2 (lato N+1)
dSp2xb = -(dOffsR+dH1)/sin(Beta1) -- - dOffsR/sin(Beta1)
if abs( Alpha1) >= 90 then
dSp2xa = (dOffsR+dH2)*tan(90+Alpha1) -- + dOffsC*tan(90+Alpha1)
else
dSp2xa = -dOffsR*tan(90+Alpha1) -- - dOffsC*tan(90+Alpha1)
end
local Opz = 1 -- <<<<<<<<<<<<<< OPZIONE PROVA <<<<<<<<<<<<<<<<<<<
-- opzione 1 (massima) per spostamento R2
if Opz == 1 then
if abs( Alpha1) >= 90 then
dSp2x = (dSp2xb + dSp2xa) - dOffsC
else
dSp2x = (dSp2xb - dSp2xa) - dOffsC
end
-- opzione 2 (minima) per spostamento R2
else
if abs( Alpha1) >= 90 then
dSp2x = dSp2xa + dOffsC
else
dSp2x = 0
end
end
if dSp1x ~= 0 then
EgtMoveGroup( Tab[N].IdPz, {dSp1x, 0, 0})
end
if dSP2x ~= 0 then
EgtMoveGroup( Tab[Tab[N].RecNxt].IdPz, {dSp2x, 0, 0})
end
-- **[a.r1]:** solo il lato N interessato da A/F, angolo tra i lati acuto
elseif Tab[N].InfoSd > 0 and Tab[Tab[N].RecNxt].InfoSd == 0
and abs( Alpha1) >= 90 then
dSp1x = -(dOffsR+dH1)*tan(90+Alpha1) + dOffsC
if dSp1x ~= 0 then
EgtMoveGroup( Tab[N].IdPz, {dSp1x, 0, 0})
end
-- **[a.r2]:** solo il lato N+1 interessato da A/F
elseif Tab[N].InfoSd == 0 and Tab[Tab[N].RecNxt].InfoSd > 0
and abs( Alpha1) >= 90 then
dSp2x = (dOffsR+dH2)*tan(90+Alpha1) - dOffsC
if dSP2x ~= 0 then
EgtMoveGroup( Tab[Tab[N].RecNxt].IdPz, {dSp2x, 0, 0})
end
end
SideNum = SideNum + 2
-- **[c]=[b.r1r2r3]:** due angoli consecutivi a dx; tre lati, N, N+1, N+2 interesssati da A/F
-- la somma dei due angoli interni deve essere >= 180°
elseif Alpha1 < 0 and Alpha2 < 0 and
(Tab[N].InfoSd > 0 and Tab[Tab[N].RecNxt].InfoSd > 0 and Tab[Tab[Tab[N].RecNxt].RecNxt].InfoSd > 0 ) then
local dSp1xa, dSp1xb, dSP3xa, dSp3xb
local dSp1x, dSp3x
--calcolo degli spostamenti per rettangolo 1 (lato N)
if abs( Alpha1) <= 90 and abs( Alpha2) <= 90 then
--<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< QUI <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
dSp1xa = -(dOffsR+dH2)/sin(Alpha1)
dSP1xb = dOffsR*tan(90+Alpha1)
dSp1x = dSp1xa - dSP1xb + dOffsC
dSp3xb = -(dOffsR+dH2)/sin(Beta2) -- - dOffsR/sin(Beta1)
dSp3xa = -dOffsR*tan(90+Alpha1) -- - dOffsC*tan(90+Alpha1)
dSp3x = (dSp3xb - dSp3xa) - dOffsC
if dSp1x ~= 0 then
EgtMoveGroup( Tab[N].IdPz, {dSp1x, 0, 0})
end
if dSP3x ~= 0 then
EgtMoveGroup( Tab[Tab[Tab[N].RecNxt].RecNxt].IdPz, {dSp3x, 0, 0})
end
elseif abs( Alpha1) >= 90 and abs( Alpha3) <= 90 then
CMP.ERR = 1
CMP.MSG = Msg[370].. "da prevedere?"
elseif abs( Alpha1) <= 90 and abs( Alpha3) >= 90 then
CMP.ERR = 2
CMP.MSG = Msg[370].. "da prevedere?"
else
CMP.ERR = 3
CMP.MSG = Msg[370].. "da prevedere?"
end
SideNum = SideNum + 3
else
SideNum = SideNum + 1
end -- [c] = due angoli consecutivi a dx
end -- while /verifica intersezioni)
--[==[ MOVIMENTI
-- calcolo degli spostamenti (lungo i propri lati di riferimento)
-- a) > if a & b & c
-- di r1 rispetto a r2 e a r3 > prendo il maggiore
-- di r3 rispetto a r1 e a r2 > prendo il maggiore
-- poi posso saltare due lati (?) sì se vale l'ipotesi di massimo due angoli a dx
-- b) elseif a & c & not b
-- di r1 rispetto a r3 e ... viceversa (?)
-- poi posso saltare due lati (?) sì se vale l'ipotesi di massimo due angoli a dx
-- c) else if a & not b & not c
-- di r1 rispetto a r2 e ... viceversa (?)
-- ma att.ne !!! potrei comprometere situazioni successive !!!!!!!!!!!!!!
-- else if : potrebbe esserci intersezione del singolo rettangolo con il lato successivo
-- o precedente !!
-- end ??
-- in caso di intersezione (a), devo verificare se R1 può muoversi 'indietro' o meno
-- in caso negativo, dovrà muoversi R2
Alphas = Tab[N].zNxtAng;
-- **[a)dx.ch.] = caso di interferenza con angolo succcessivo 'a dx', 'chiuso'**
if (Tab[N].InfoSd ~= nil and Tab[Tab[N].RecNxt].InfoSd ~= nil) then
-- if angolo precedente 'aperto' then
-- muovo il rettangolo 1
--and Alphas <= -90 then
EgtMove( Tab[N].IdPz, EgtEP(Tab[N].l3))
-- Point3d EgtIP( int nId1, int nId2, Point3d ptNear [, int RefId = nId])
-- bool EgtMove( int nId/s, Vector3d vtMove [, int nRefType = GDB_RT.LOC])
-- else ( angolo precedente 'chiuso
=> devo spostare il rettangolo 2
end
--else if veriifcare interferenza con i lati del compo principale, se c'è un solo rettangolo
]==]
end --function CMP_Draw(bPreview)
_G.CMP_Draw = CMP_Draw
CMP_Draw(true) -- solo per da egtCAM5
EgtZoom(SCE_ZM.ALL)
--EgtSaveFile( )
Reference in New Issue View Git Blame Copy Permalink