-- 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'

-- 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
CMP.F_Height=30
CMP.A_DeltaAng=0.5
CMP.F_DeltaAng=0.5
-- parametri passati da OmagCut
CMP.BBoxRad = 1000
CMP.HeightText = 100
--
_G.CMP = CMP

-- 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')
   -- 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/7.5
   local dStdOffs = dDim/2
   --
   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 LATI DEL COMPONENTE**
   --<<<<<<< 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 per campi di SideTab - SUPERATA**
            -- .**a = SideId; .b = SideInfo-A/F; c= PrecSideInfo, .d = ProxSideInfo;**
            -- **.l1---.l4 = Rectangle sides**
            -- **.u = SideStartVector; .v = SideEndVector;**
            -- **.g = PrecSideEndvector; .h = ProxSideStartVector;**
            -- **.y = PrecSide-Side_Angle; .z = Side-ProxSide_Angle.**     ]]
            
         -- |LEGENDA per campi di SideTab|
            -- |.a = SideId; .b = SideInfo-A/F; c= PrevRec, .d = NextRec;|
            -- |.l1---.l4 = Rectangle sides|
            -- |.u = Side Start Vector; .v = Side End Vector;|
            -- |.y = PrecSide-Side_Angle; .z = Side-ProxSide_Angle.|
            
         SideRec = {a = CurrSide, b = InfoAF, c = 0, d = SideNum+1, 
                    u = EgtSV(CurrSide), v = EgtEV(CurrSide) }
      -- se lato successivo al primo           
      else
         local v1 = SideTab[SideNum-1].v
         local v2 = EgtSV(CurrSide)
         local angv1v2 = atan2( (v1^v2)*Z_AX(),v1*v2)
         SideRec = {a=CurrSide, b=InfoAF, c = SideNum-1, d = SideNum+1,
                    u = EgtSV(CurrSide),  v = EgtEV(CurrSide),
                    y = angv1v2, z = nil }
         -- completo record precedente
         --SideTab[SideNum-1].d = SideRec.b 
         SideTab[SideNum-1].z = 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 per campi di SideTab)||
            -- |.a = SideId; .b = SideInfo-A/F; c= PrevRec, .d = NextRec;|
            -- |.l1---.l4 = Rectangle sides|
            -- |.u = Side Start Vector; .v = Side End Vector;|
            -- |.y = PrecSide-Side_Angle; .z = Side-ProxSide_Angle.|
   if #SideTab > 1 then
      --SideTab[1].c = SideTab[#SideTab].b
      --SideTab[1].g = SideTab[#SideTab].f
      local v1 = SideTab[#SideTab].v
      local v2 = SideTab[1].u 
      local angv1v2 = atan2( (v1^v2)*Z_AX(),v1*v2)
      SideTab[#SideTab].d = 1
      SideTab[1].c = #SideTab
      SideTab[#SideTab].z = angv1v2
      SideTab[1].y = angv1v2
   end
   -- restituisco un messaggio al programma OMAG-Cut
   CMP.MSG = sMsg
   -- ------------------------------------------------------------------
   -- **COSTRUZIONE DELLE FIGURE** (rettangoli) rappresentative di alzatine
   for SideNum = 1 , #SideTab do
         -- |(ripeti LEGENDA per campi di SideTab)||
            -- |.a = SideId; .b = SideInfo-A/F; c= PrevRec, .d = NextRec;|
            -- |.l1---.l4 = Rectangle sides|
            -- |.u = Side Start Vector; .v = Side End Vector;|
            -- |.y = PrecSide-Side_Angle; .z = Side-ProxSide_Angle.|
      -- se è richiesto un'alzatina o un frontalino
      if (SideTab[SideNum].b ~= 0 and SideTab[SideNum].b ~= nil) then
         local Side = SideTab[SideNum].a
         local SVect = SideTab[SideNum].u
         local EVect = SideTab[SideNum].v
         local Pz; local Lay; local LayLbl; local BaseL; local HeightL
         local sName
         -- caso di alzatina
         if SideTab[SideNum].b == 1 then
            --Pz  = EgtGroup(GDB_ID.ROOT,GDB_RT.LOC)    -- nuova parte per alzatina o frontalino
            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-"
            HeightL = AH --(=CMP.A_Heigth)
         -- caso di frontalino
         elseif SideTab[SideNum].b == 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-"
            HeightL = FH --(=CMP.F_Heigth)
         end
         local Pt = EgtSP( Side) + VRotated( SVect*dDim, -90)
         -- chiamo la funzione per il disegno del rettangolo (Lay, Pt, Base, Altezza, Vettore direz. iniziale, prefisso per nome lati)
         local l1, l2, l3, l4 = DrawRect (Lay, Pt, BaseL, HeightL, SVect, sName)
         -- 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**
         local Tab = SideTab
         local N = SideNum
         local Alphap = Tab[N].y; 
         local Betap
         -- angoli tra lato precedente e attuale
         if Alphap >= 0 then
            Betap = 180-Alphap
         else
            Betap = (180+Alphap)
         end
         -- angoli tra lato attuale e successivo
         local Alphas = Tab[N].z;
         if Alphas >= 0 then
            Betas = 180-Alphas
         else
            Betas = (180+Alphas)
         end
         local Gamma -- angolo di taglio da calcolare
         -- **ALZATINE**
         if Tab[N].b == 1 then
         -- CASI RIFERITI AL LATO PRECEDENTE
            -- |(ripeti LEGENDA per campi di SideTab)||
             -- |.a = SideId; .b = SideInfo-A/F; c= PrevRec, .d = NextRec;|
             -- |.l1---.l4 = Rectangle sides|
             -- |.u = Side Start Vector; .v = Side End Vector;|
             -- |.y = PrecSide-Side_Angle; .z = Side-ProxSide_Angle.|
             
            -- **1) Ap0.sx** = non continua da lato precedente, angolo 'a sx'
            if (Tab[N].b ~= Tab[Tab[N].c].b) and Alphap > 0 then 
               Gamma = Betap-90
               SideAngSetInfo ( l1, 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].b ~= Tab[Tab[N].c].b) and Alphap < 0 then
               Gamma = 90 - Betap -- meno F_Delta ???????
               SideAngSetInfo ( l1, LayLbl, Gamma, dStdOffs, dHLbl)
            -- **3) Ap1.sx** = continua da lato precedente, angolo 'a sx'
            elseif (Tab[N].b == Tab[Tab[N].c].b) and Alphap > 0 then
               Gamma = -(90-Betap/2+F_Delta)
               SideAngSetInfo ( l1, LayLbl, Gamma, dStdOffs, dHLbl)
            -- **4) Ap1.dx** = continua da lato precedente, angolo 'a dx'
            elseif (Tab[N].b == Tab[Tab[N].c].b) and Alphap < 0 then
               Gamma = -(90-Betap/2-F_Delta)
               SideAngSetInfo ( l1, LayLbl, Gamma, dStdOffs, dHLbl)
            end
         -- CASI RIFERITI AL LATO SUCCESSIVO
            -- **1) As0.sx** = non continua al lato successivo, angolo 'a sx'
            if (Tab[N].b ~= Tab[Tab[N].d].b) and Alphas > 0 then
               Gamma = Betas-90  -- meno F_Delta ???
               SideAngSetInfo ( l3, LayLbl, Gamma, dStdOffs, dHLbl)
            -- **2) As0.dx** = non continua al lato successivo, angolo 'a dx'
            elseif (Tab[N].b ~= Tab[Tab[N].d].b) and Alphas < 0 then
               Gamma = 90-Betas  -- meno F_Delta ???
               SideAngSetInfo ( l3, LayLbl, Gamma, dStdOffs, dHLbl)
            -- **3) As1.sx** = continua al lato successivo, angolo 'a sx'
            elseif (Tab[N].b == Tab[Tab[N].d].b) and Alphas > 0 then
               Gamma = -(90-Betas/2+F_Delta)
               SideAngSetInfo ( l3, LayLbl, Gamma, dStdOffs, dHLbl)
            -- **4) As1.dx** = continua al lato successivo, angolo 'a dx'
            elseif (Tab[N].b == Tab[Tab[N].d].b) and Alphas < 0 then
               Gamma = 90-Betas/2-F_Delta
               SideAngSetInfo ( l3, LayLbl, Gamma, dStdOffs, dHLbl) 
            end
            
         -- **FRONTALINI**   
         elseif Tab[N].b == 2 then
            -- |(ripeti LEGENDA per campi di SideTab)||
             -- |.a = SideId; .b = SideInfo-A/F; c= PrevRec, .d = NextRec;|
             -- |.l1---.l4 = Rectangle sides|
             -- |.u = Side Start Vector; .v = Side End Vector;|
             -- |.y = PrecSide-Side_Angle; .z = Side-ProxSide_Angle.|
             -- **1) Ap0.sx** = non continua da lato precedente, angolo 'a sx'
             
            -- **1) Fp0.sx** = non continua da lato precedente, angolo 'a sx'
            if (Tab[N].b ~= Tab[Tab[N].c].b) and Alphap > 0 then
               if Alphap > 90 then
                  Gamma = -(90-Betap)  -- meno F_Delta ????
                  SideAngSetInfo ( l1, LayLbl, Gamma, dStdOffs, dHLbl)
               -- (in caso Alphap <= 90, non si fa taglio inclinato)             |>>>>   indicare comunque angolo pari a 'zero'?  <<<<<<|
               end
            -- **2) Fp0.dx** = non continua da lato precedente, angolo 'a dx'
            elseif (Tab[N].b ~= Tab[Tab[N].c].b) and Alphap < 0 then
               if -Alphap > 90 then
                  Gamma = 90-Betap  -- meno F_Delta ????
                  SideAngSetInfo ( l1, LayLbl, Gamma, dStdOffs, dHLbl)
               -- (in caso -Alphap <= 90, non si fa taglio inclinato)             |>>>>   indicare comunque angolo pari a 'zero'?   <<<<<<<<<|
               end
            -- **3) Fp1.sx** = continua da lato precedente, angolo 'a sx'
            elseif (Tab[N].b == Tab[Tab[N].c].b) and Alphap > 0 then
               Gamma = -(90-Betap/2+F_Delta)
               SideAngSetInfo ( l1, LayLbl, Gamma, dStdOffs, dHLbl)
            -- **4) Fp1.dx** = continua da lato precedente, angolo 'a dx'
            elseif (Tab[N].b == Tab[Tab[N].c].b) and Alphap < 0 then
               Gamma = 90-Betap/2-F_Delta
               SideAngSetInfo ( l1, LayLbl, Gamma, dStdOffs, dHLbl)
            end 
            -- CASI RIFERITI AL LATO SUCCESSIVO
            -- |(ripeti LEGENDA per campi di SideTab)||
             -- |.a = SideId; .b = SideInfo-A/F; c= PrevRec, .d = NextRec;|
             -- |.l1---.l4 = Rectangle sides|
             -- |.u = Side Start Vector; .v = Side End Vector;|
             -- |.y = PrecSide-Side_Angle; .z = Side-ProxSide_Angle.|
            -- **1) Fs0.sx** = non continua al lato successivo, angolo 'a sx'
            if (Tab[N].b ~= Tab[Tab[N].d].b) and Alphas > 0 then
               if Alphas > 90 then
                  Gamma = -(90-Betas)  -- meno F_Delta ????
                  SideAngSetInfo ( l3, LayLbl, Gamma, dStdOffs, dHLbl)
               -- (in caso Alphas <= 90, non si fa taglio inclinato)     |<<<<<<<<<<<< indicare comunque angolo pari a 'zero'?|
               end
            -- **2) Fs0.dx** = non continua al lato successivo, angolo 'a dx'
            elseif (Tab[N].b ~= Tab[Tab[N].d].b) and Alphas < 0 then
               -- **Fs0.dx.1**
               if -Alphas > 90 then
                  Gamma = 90-Betas  -- meno F_Delta ????
                  SideAngSetInfo ( l3, LayLbl, Gamma, dStdOffs, dHLbl)
               -- (in caso -Alphas <= 90, non si fa taglio inclinato)   |<<<<<<<<<<<< indicare comunque angolo pari a 'zero'?|
               end
            -- **3) Fs1.sx** = continua al lato successivo, angolo 'a sx'
            elseif (Tab[N].b == Tab[Tab[N].d].b) and Alphas > 0 then
               Gamma = -(90-Betas/2*F_Delta)
               SideAngSetInfo ( l3, LayLbl, Gamma, dStdOffs, dHLbl)
            -- **4) Fs1.dx** = continua al lato successivo, angolo 'a dx'
            elseif (Tab[N].b == Tab[Tab[N].d].b) and Alphas < 0 then
               Gamma = 90-Betas/2-F_Delta
               SideAngSetInfo ( l3, LayLbl, Gamma, dStdOffs, dHLbl)
            end
            -- taglio inclinato a -(45+delta) del lato superiore del frontalino
            Gamma = -(45+F_Delta)
            SideAngSetInfo ( l4, 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 alto del componente
            EgtSetInfo( l4, "RifSideId", Tab[N].a) -- |<<<<<<<<<<<<<<<<<< bisogna mettere il nome del lato !!? <<<<<<<<<<<<<<<<<<<<<<<<<|
            
            
      end     -- richiesta alzatina o frontalini
   end --for COSTRUZIONE DELLE FIGURE (rettangoli) 
         --
   -- ------------------------------------------------------------------
         -- verifica delle **INTERSEZIONI TRA RETTANGOLI** e definizione degli eventuali **SPOSTAMENTI**
   for SideNum = 1 , 3 do        --#SideTab do
         -- |(ripeti LEGENDA per campi di SideTab)|
            -- |.a = SideId; .b = SideInfo-A/F; c= PrevRec, .d = NextRec;|
            -- |.l1---.l4 = Rectangle sides|
            -- |.u = Side Start Vector; .v = Side End Vector;|
            -- |.y = PrecSide-Side_Angle; .z = Side-ProxSide_Angle.|
         
         
         
         -- >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  
         
         local Tab = SideTab
         local N = SideNum
         
         -- a) intersezione tra un rettangolo e il successivo 
         local PtInt12 = EgtIP( Tab[N].l2, Tab[Tab[N].d].l2, EgtEP( Tab[N].l2), GDB_ID.ROOT)
         -- b) intersezione tra il rettangolo successivo e il secondo successivo
         local PtInt23 = EgtIP( Tab[Tab[N].d].l2, Tab[Tab[Tab[N].d].d].l2, EgtEP( Tab[Tab[N].d].l2), GDB_ID.ROOT)
         -- c) intersezione tra un rettangolo e il secondo successivo 
         local PtInt13 = EgtIP( Tab[N].l2, Tab[Tab[Tab[N].d].d].l2, EgtEP( Tab[N].l2), GDB_ID.ROOT)
         
         
         -- |ATTENZIONE POSSONO INTERSECARSI ANCHE I LATI 1 E 4 DEI RETTANGOLI !!!|
         -- calcolo degli spostamenti (lungo i propri lati di riferimento)
         -- 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
         -- 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
         -- 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 ??
         
         
         
         
         
         -- <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<    <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
         
         
         
         
         
         -- PROVA
         if PtInt12 then
            EgtLinePDL( 2, PtInt12, 30, 100, GDB_RT.GLOB)
            local text = "Pt12"
            EgtText( 2 , PtInt12, text, 15, GDB_RT.GLOB)
            -- int EgtText( int nParentId, Point3d PtIni, string Text, num dH [, int nRefType = GDB_RT.LOC]) 
         end
         if PtInt13 then
            local text = "Pt13"
            EgtText( 2 , PtInt13, text, 15, GDB_RT.GLOB)
            EgtLinePDL( 2, PtInt13, 30, 100, GDB_RT.GLOB)
         end
         if PtInt23 then
            local text = "Pt23"
            EgtText( 2 , PtInt23, text, 15, GDB_RT.GLOB)
            EgtLinePDL( 2, PtInt23, 30, 100, GDB_RT.GLOB)
         end
            
      end -- for VERIFICA INTERSEZIONI ...
            --[[
            l1 = EgtLinePDL( 2, {0,100,0}, 0, 1000)
            l2 = EgtLinePDL( 2, {0.,500,0}, -45, 1000)
            Pt = EgtIP( l1, l2, {0,500,0})
            if Pt then
               EgtLine( 2, Pt, {0,0,0})
            ]]
            
            
            
         
         
         
         
         
         
         
         
         
         
         
         
   
   --[==[
    -- Lati
   local stdoffset = 1  
   local LblL1 = AddLabel(Ll,l1,stdoffset,CMP.N3,dim,-90,RED())
                   -- EgtSetInfo(LblL1,"Var",1)
   local LblL4 = AddLabel(Ll,l4,stdoffset,CMP.N4,dim,-90,RED())
                   --EgtSetInfo(LblL2,"Var",2)
    -- Etichetta del centro della figura ( = PUNTO DI INSERIMENTO )
   local ln01 = EgtLinePDL(Ll,ptXY0-Vector3d(dim*.25,0,0),0,dim*.5)
   local ln02 = EgtLinePDL(Ll,ptXY0-Vector3d(0,dim*.25,0),90,dim*.5)
   local ln1 = EgtLinePDL(Ll,ptXY0,45,dim) pt1 = EgtEP(ln1)
   local ln2 = EgtLinePDL(Ll,pt1,0,dim)
   local lblXY = AddLabel(Ll,ln2,stdoffset,"("..CMP.N1..";"..CMP.N2..")",dim,90,RED())
   EgtErase(ln2)
   ]==]
   
end --function CMP_Draw(bPreview)

_G.CMP_Draw = CMP_Draw
            CMP_Draw(true)
            EgtZoom(SCE_ZM.ALL)
            --EgtSaveFile( )