carlo.baronchelli
671 lines
31 KiB
Lua
671 lines
31 KiB
Lua
-- 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
|
|
|
|
-- 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.5 -- angolo (semiangolo) di incremento per tagli inclinati
|
|
CMP.F_DeltaAng=0.5
|
|
-- 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 (Lay, BaseL, HeightL, sName)
|
|
local Pt = Point3d(0,0,0)
|
|
local l1 = EgtLinePDL( Lay, Pt, 0, BaseL)
|
|
--EgtSetName( l1, sName.." l1")
|
|
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")
|
|
return l1, l2, l3, l4
|
|
end
|
|
|
|
|
|
-- Scrittura info e etichetta con inclinazione dei lati dei rettangoli
|
|
local function SideAngSetInfo(SideId, Lay, Gamma, dOffset, dHLbl)
|
|
EgtSetInfo( SideId, "SideAng", Gamma) -- -F_Delta?
|
|
EgtSetInfo( SideId, "OrigSideAng", Gamma) -- -F_Delta?
|
|
local Lbl = EgtNumToString(Gamma,1)..'°'
|
|
LblL1 = AddLabelAl( Lay, SideId, dOffset*0.02, Lbl, dHLbl, -90, BLACK())
|
|
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*0.1
|
|
local dHLbl = CMP.HeightText*0.15
|
|
local dStdOffs = dDim*.5 -- vedi etichettatura lati inclinati
|
|
local dOffsR = dDim*.4 -- 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)
|
|
--Pz = EgtGetNext--- (Pz) ....
|
|
|
|
if not Pz then
|
|
CMP.ERR = 5
|
|
CMP.MSG = "Pezzo non trovato"
|
|
return
|
|
end
|
|
|
|
--[[ **COMMENTATO PER TEST**
|
|
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)
|
|
-- --------------------------------------------------------------------
|
|
--<<<<<<< HEAD
|
|
local SideTab = {}
|
|
-- -=======
|
|
-- SideTab = {}
|
|
-- >>>>>>> origin/HEAD
|
|
local CurrSide = EgtGetFirstInGroup( Lw)
|
|
local PrecSide = nil
|
|
while CurrSide ~= nil do
|
|
local SideRec = {}
|
|
local InfoAF = EgtGetInfo( CurrSide, "AF", 'i')
|
|
-- se primo lato
|
|
if SideNum == 1 then
|
|
-- |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.|
|
|
|
|
SideRec = {IdSd = CurrSide, IdPz = nil, InfoSd = InfoAF, RecPrv = 0, RecNxt = SideNum+1,
|
|
VectS = EgtSV(CurrSide), VectE = EgtEV(CurrSide) }
|
|
-- 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),
|
|
zPrvAng = Angv1v2 }
|
|
-- completo record precedente
|
|
SideTab[SideNum-1].zNxtAng = Angv1v2
|
|
end
|
|
|
|
-- (per visualizzazione in OmagCUT)
|
|
if InfoAF == 1 then
|
|
sMsg = sMsg ..EgtGetName(CurrSide).."=Alzatina "
|
|
EgtSetColor(CurrSide, 'RED')
|
|
elseif InfoAF == 2 then
|
|
sMsg = sMsg ..EgtGetName(CurrSide).."=Frontalino "
|
|
EgtSetColor(CurrSide, 'GREEN')
|
|
else
|
|
EgtSetColor(CurrSide, 'BLACK')
|
|
end
|
|
--
|
|
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)
|
|
-- |(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.|
|
|
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
|
|
-- restituisco un messaggio al programma OmagCUT
|
|
CMP.MSG = sMsg
|
|
|
|
-- **COSTRUZIONE DELLE FIGURE** (rettangoli) rappresentative di alzatine o frontalini
|
|
-- -------------------------------------------------------------------------------
|
|
for SideNum = 1 , #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.|
|
|
|
|
-- se è richiesto un'alzatina o un frontalino
|
|
if SideTab[SideNum].InfoSd > 0 then
|
|
--if SideTab[SideNum].InfoSd > 0 then
|
|
local Side = SideTab[SideNum].IdSd
|
|
local SVect = SideTab[SideNum].VectS
|
|
local EVect = SideTab[SideNum].VectE
|
|
local BaseL; local HeightL
|
|
local sName
|
|
--local Pt = EgtSP( Side) + VRotated( SVect*dDim, -90)
|
|
local Pt = EgtEP( Side) + VRotated( EVect*dOffsR, -90)
|
|
local Frame = Frame3d( Pt, -EVect, VRotated(EVect,-90), Vector3d(0,0,1))
|
|
local Pz = EgtGroup(GDB_ID.ROOT, Frame, GDB_RT.GLOB) -- nuova parte per alzatina o frontalino
|
|
EgtSetName(Pz,"Alz-Front")
|
|
|
|
SideTab[SideNum].IdPz = Pz
|
|
--local Lay = EgtGroup(Pz, Frame, GDB_RT.GLOB) -- layer della figura
|
|
local Lay = EgtGroup( Pz) -- layer della figura
|
|
EgtSetName(Lay,'OutLoop')
|
|
--EgtSetColor(Lay,RED(),100,true)
|
|
--local LayLbl = EgtGroup(Pz,GDB_RT.GLOB) -- layer delle etichette
|
|
local LayLbl = EgtGroup( Pz) -- layer delle etichette
|
|
EgtSetName(LayLbl,'Labels')
|
|
-- caso di alzatina
|
|
if SideTab[SideNum].InfoSd == 1 then
|
|
--Pz = EgtGroup(GDB_ID.ROOT,GDB_RT.GLOB) -- nuova parte per alzatina o frontalino
|
|
--Lay = EgtGroup(Pz,GDB_RT.GLOB) -- layer della figura
|
|
--EgtSetName(Lay,'OutLoop')
|
|
EgtSetColor(Lay,RED(),100,true)
|
|
--LayLbl = EgtGroup(Pz,GDB_RT.GLOB) -- layer delle etichette
|
|
--EgtSetColor(LayLbl,BLACK(),100,true)
|
|
BaseL = EgtCurveLength( Side)
|
|
--sName = "L"..SideNum.."-A-"
|
|
sName = "Side "..SideNum.." -A"
|
|
HeightL = AH --(=CMP.A_Heigth)
|
|
|
|
-- caso di frontalino
|
|
elseif SideTab[SideNum].InfoSd == 2 then
|
|
--Pz = EgtGroup(GDB_ID.ROOT,GDB_RT.GLOB) -- nuova parte per alzatina o frontalino
|
|
--Lay = EgtGroup(Pz,GDB_RT.GLOB) -- layer della figura
|
|
--EgtSetName(Lay,'OutLoop')
|
|
EgtSetColor(Lay,GREEN(),100,true) -- Ok=1
|
|
--LayLbl = EgtGroup(Pz,GDB_RT.GLOB) -- layer delle etichette
|
|
--EgtSetColor(LayLbl,BLACK(),100,true)
|
|
BaseL = EgtCurveLength( Side)
|
|
--sName = "L"..SideNum.."-F-"
|
|
sName = "Side "..SideNum.." -F"
|
|
HeightL = FH --(=CMP.F_Heigth)
|
|
|
|
SideTab[SideNum].Frame = Frame --**?????????????????***** anche QUI *??????????????<<<<<<
|
|
end
|
|
|
|
-- chiamo la funzione per il disegno (senso antiorario) dei lati del rettangolo 'allineato'
|
|
-- (Layer, Base, Altezza, prefisso per nome lati, )
|
|
local l1, l2, l3, l4 = DrawRectangle (Lay, BaseL, HeightL, sName)
|
|
EgtSetName( l1,sName.." -l1")
|
|
EgtSetName( l2,sName.." -l2")
|
|
EgtSetName( l3,sName.." -l3")
|
|
EgtSetName( l4,sName.." -l4")
|
|
local RectContour = EgtCurveCompo(Lay,{l1,l2,l3,l4},false)
|
|
|
|
-- 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
|
|
--SideTab[SideNum].RContour = RectContour
|
|
|
|
-- **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.|
|
|
|
|
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 Gamma -- angolo di taglio da calcolare
|
|
|
|
-- **ALZATINE**
|
|
if Tab[N].InfoSd == 1 then
|
|
|
|
-- CASI RIFERITI AL LATO PRECEDENTE
|
|
-- **1) Ap0.sx** = non continua da lato precedente, angolo 'a sx'
|
|
if (Tab[N].InfoSd ~= Tab[Tab[N].RecPrv].InfoSd) and Alphap > 0 then
|
|
Gamma = Betap-90
|
|
SideAngSetInfo ( l2, LayLbl, Gamma, dStdOffs, dHLbl)
|
|
-- (in caso **p0.sx.2** = Alphap <= 90, non si fa taglio inclinato)
|
|
-- **2) Ap0.dx** = non continua da lato precedente, angolo 'a dx'
|
|
elseif (Tab[N].InfoSd ~= Tab[Tab[N].RecPrv].InfoSd) and Alphap < 0 then
|
|
Gamma = 90 - Betap -- meno F_Delta ???????
|
|
SideAngSetInfo ( l2, LayLbl, Gamma, dStdOffs, dHLbl)
|
|
-- **3) Ap1.sx** = continua da lato precedente, angolo 'a sx'
|
|
elseif (Tab[N].InfoSd == Tab[Tab[N].RecPrv].InfoSd) and Alphap > 0 then
|
|
Gamma = -(90-Betap/2+F_Delta)
|
|
SideAngSetInfo ( l2, LayLbl, Gamma, dStdOffs, dHLbl)
|
|
-- **4) Ap1.dx** = continua da lato precedente, angolo 'a dx'
|
|
elseif (Tab[N].InfoSd == Tab[Tab[N].RecPrv].InfoSd) and Alphap < 0 then
|
|
Gamma = -(90-Betap/2-F_Delta)
|
|
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
|
|
Gamma = Betas-90 -- meno F_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
|
|
Gamma = 90-Betas -- meno F_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
|
|
Gamma = -(90-Betas/2+F_Delta)
|
|
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
|
|
Gamma = 90-Betas/2-F_Delta
|
|
SideAngSetInfo ( l4, LayLbl, Gamma, dStdOffs, dHLbl)
|
|
end
|
|
|
|
|
|
-- **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.|
|
|
|
|
-- 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
|
|
Gamma = -(90-Betap) -- meno F_Delta ????
|
|
SideAngSetInfo ( l2, LayLbl, Gamma, dStdOffs, dHLbl)
|
|
-- (in caso Alphap <= 90, non si fa taglio inclinato)
|
|
else
|
|
Gamma = 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
|
|
Gamma = 90-Betap -- meno F_Delta ????
|
|
SideAngSetInfo ( l2, LayLbl, Gamma, dStdOffs, dHLbl)
|
|
-- (in caso -Alphap <= 90, non si fa taglio inclinato)
|
|
else
|
|
Gamma = 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
|
|
Gamma = -(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
|
|
Gamma = 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.|
|
|
-- **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
|
|
Gamma = -(90-Betas) -- meno F_Delta ????
|
|
SideAngSetInfo ( l4, LayLbl, Gamma, dStdOffs, dHLbl)
|
|
-- (in caso Alphap <= 90, non si fa taglio inclinato)
|
|
else
|
|
Gamma = 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
|
|
Gamma = 90-Betas -- meno F_Delta ????
|
|
SideAngSetInfo ( l4, LayLbl, Gamma, dStdOffs, dHLbl)
|
|
-- (in caso -Alphap <= 90, non si fa taglio inclinato)
|
|
else
|
|
Gamma = 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
|
|
Gamma = -(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
|
|
Gamma = 90-Betas/2-F_Delta
|
|
SideAngSetInfo ( l4, LayLbl, Gamma, dStdOffs, dHLbl)
|
|
end
|
|
-- taglio inclinato a -(45+delta) del lato superiore del frontalino
|
|
Gamma = -(45+F_Delta)
|
|
SideAngSetInfo ( l1, LayLbl, Gamma, dStdOffs, dHLbl)
|
|
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 !!? <<<<<<<<<<<<<<<<<<<<<<<<<|
|
|
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( ) |