-- 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
-- 27/10/2021  - etichettatura dimensione oggetti
-- 05/11/2021  - etichettatura di tutti i lati del piano cucina, incluso eventuali angoli di taglo inclinati già definiti 
-- .. 16/11/2021  - correzioni a spostamenti
-- 17/11/2021  - taratura e sistemazione 'definitiva' delle etichettature dei lati con indicazione degli angoli di taglio

-- Intestazioni 
require( 'EgtBase')
_ENV = EgtProtectGlobal()
EgtEnableDebug( false)

EgtAddToPackagePath(EgtGetSourceDir() .. 'LuaLibs\\?.lua')
require( 'EgtCompo')

-- Parametri : dichiarazione e valori standard  
--.T (tipo) : 0=null, 1=bool, 2=int, 3=len, 4=num, 5=string
local CMP = {}

-- parametri passati da interfaccia del programma OMAG-Cut
CMP.A_Height = 50     -- altezza delle alzatine
CMP.F_Height = 50     -- altezza dei frontalini
CMP.A_DeltaAng = 1     -- angolo di incremento per tagli inclinati
CMP.F_DeltaAng = 1
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, LayR, BaseL, HeightL, sText, sReference, Delta1, Delta2)
   -- insrisco un commento nel pezzo per descriverlo 
   EgtSetInfo( Pz, "CMP", "AlzFront")
   -- 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, sText.." l1")
              EgtSetInfo( l1, "RefAF", sReference)
   local l2 = EgtLinePDL( Lay, EgtEP( l1), 90, HeightL)
              EgtSetName( l2, sText.." -l2")
   local l3 = EgtLinePDL( Lay, EgtEP( l2), 180, BaseL)
              EgtSetName( l3, sText.." -l3")
   local l4 = EgtLine( Lay, EgtEP( l3), EgtSP( l1))
              EgtSetName( l4,sText.." -l4")
   local RectContour = EgtCurveCompo(Lay,{l1,l2,l3,l4},false)
   local s1 = EgtSurfFlatRegion(LayR,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

local function StringColorConversion( sColor)
   if sColor == 'Green' then
      return GREEN()
   elseif sColor== 'Red' then
      return RED()
   elseif sColor =='Blue' then
      return BLUE()
   end
end

-- Scrittura info e apposizione etichetta con inclinazione del taglio dei lati dei rettangoli A/F
local function SideSetInfoAF( SideId, Lay, Gamma, dOff, dH, GammaMin, GammaMax, sCol)
   EgtSetInfo( SideId, "SideAng", Gamma)  -- -F_Delta?
   EgtSetInfo( SideId, "OrigSideAng", Gamma) -- -F_Delta
   if abs( Gamma) < GammaMin then
      Gamma = 0
   elseif abs( Gamma) > GammaMax then
      Gamma = 0 
      CMP.ERR = 1
      CMP.MSG = Msg[150]..GammaMax..'°' -- < Non sono ammessi angoli tra i lati maggiori di GammaMax >
   end
   local Lbl
   local sLbl = EgtNumToString(Gamma,1)..'°'
   local dIncl = atan2( EgtMV( SideId, GDB_ID.ROOT ):getY(), EgtMV( SideId, GDB_ID.ROOT):getX())
   if dIncl >= -75 and dIncl <= 115 then
      -- etichetta allineata
      Lbl = AddLabelAl2( Lay, SideId, dOff, sLbl, dH, -90, StringColorConversion( sCol), true)
   else
      -- etichetta allineata ribaltata
      Lbl = AddLabelAl2( Lay, SideId, dOff, sLbl, dH, -90, StringColorConversion( sCol), false)
   end
end
   
-- Scrittura info e apposizione etichetta con inclinazione del taglio dei lati del componente principale
local function SideSetInfoC( SideId, Lay, Gamma, dOff, dH, GammaMin, GammaMax, Text)
   --if sOpz == 'F' then
      EgtSetInfo( SideId, "SideAng", Gamma)  -- -F_Delta?
      EgtSetInfo( SideId, "OrigSideAng", Gamma) -- -F_Delta
   --end
   local Lbl
   local sLbl = Text..EgtNumToString(Gamma,1)..'°'
   local dIncl = atan2( EgtMV( SideId):getY(), EgtMV( SideId):getX())
   if dIncl >= -75 and dIncl <= 115 then
      -- etichetta allineata
      Lbl = AddLabelAl2( Lay, SideId, dOff, sLbl, dH, -90, BLACK(), true)
   else
      -- etichetta allineata ribaltata
      Lbl = AddLabelAl2( Lay, SideId, dOff, sLbl, dH, -90, BLACK(), false)
   end
end
   
-- Calcolo dello spostamento 'indietro' (positivo in coord. locali) per A/F isolato
-- Caso di intersezione con lato N+1
local function Spostamento10( dOffsR, dOffsC, dH1, Beta)
   local dSpX
   local dSpXa = (dOffsR+dH1) * tan( 90-Beta)
   -- per angolo compreso tra i due lati acuto
   if Beta <= 90 then
      dSpX = dSpXa + dOffsC
   -- per angolo ottuso
   else
      dSpX = dOffsC
   end 
   return dSpX
 end  
 
-- Calcolo dello spostamento 'in avanti' (negativo in coord. locali) per A/F isolato
-- Caso di intersezione con lato N-1
 local function Spostamento20( dOffsR, dOffsC, dH2, Beta)
   local dSpX
   local dSpXa = -(dOffsR+dH2) * tan( 90-Beta)
   -- per angolo compreso tra i due lati acuto
   if Beta <= 90 then
      dSpX = dSpXa - dOffsC
   -- per angolo ottuso
   else
      dSpX = - dOffsC
   end
   return dSpX
 end

-- Calcolo dello spostamento 'indietro' (positivo in coord. locali) per A/F seguito da altro A/F
-- Caso di intersezione con A/F in latio N+1
 local function Spostamento11( dOffsR, dOffsC, dH1, dH2, Beta)
   local dSpX, dSpXa, dSpXb
   if Beta <= 90 then
      dSpXa = (dOffsR+dH1) * tan( 90-Beta)
   else
      dSpXa = dOffsR * tan( 90-Beta)
   end
   dSpXb = (dOffsR+dH2) / cos( 90-Beta)
   dSpX = dSpXa + dSpXb -- + dOffsC
   if dSpX > -0.01 then
      dSpX = dSpX + dOffsC
   else
      dSpX = dOffsC
   end
   return dSpX
end

-- Calcolo dello spostamento 'in avanti' (negativo in coord. locali) per A/F preceduto da altro A/F
-- Caso di intersezione con A/F in lato N-1
 local function Spostamento21( dOffsR, dOffsC, dH1, dH2, Beta)
   local dSpX, dSpXa, dSpXb
   if Beta <= 90 then
      dSpXa = - (dOffsR+dH2) * tan( 90-Beta)
   else
      dSpXa = - dOffsR * tan( 90-Beta)
   end
   dSpXb = - (dOffsR+dH1) / cos( 90-Beta)
   dSpX = dSpXa + dSpXb -- - dOffsC
   if dSpX < 0.01 then
      dSpX = dSpX - dOffsC
   else
      dSpX = - dOffsC 
   end
   return dSpX
end

-- Calcolo di spostamento 'indietro' (positivo in coord. locali)
-- Caso di intersezione con lato N+2
local function Spostamento30( Len, dOffsR, dOffsC, dH1, Alpha1, Alpha2)
   local dSpX, dSpXa, dSpXc
   local Beta = 180 + Alpha1 + Alpha2
   if Beta <= 90 then
      --(in ipotesi Beta 1 > 90)
      dSpXa = (dOffsR+dH1) * tan( 90-Beta)
      dSpXc = Len * (cos( Alpha1) + sin( -Alpha1) / tan( Beta))
      dSpX = dSpXa - dSpXc + dOffsC
   else
      dSpX = dOffsC
   end 
   return dSpX
 end

-- Calcolo di spostamento 'indietro' (positivo in coord. locali)
-- Caso di intersezione con A/F in lato N+2
local function Spostamento31( Len, dOffsR, dOffsC, dH1, dH3, Alpha1, Alpha2)
   local dSpX, dSpXa, dSpXb, dSpXb1, dSpXb2, dSpXc
   local Beta = 180 + Alpha1 + Alpha2
   if Beta <= 90 then
      --(in ipotesi Beta 1 > 90)
      dSpXa = (dOffsR + dH1) * tan( 90-Beta)
      dSpXc = Len * (cos( Alpha1) + sin( -Alpha1) / tan( Beta))
      dSpX = dSpXa - dSpXc
   else
      dSpX = 0
   end 
   dSpXb1 = (dOffsR + dH3) * cos( 90-Beta)
   dSpXb2 = Len * cos( Alpha1)
   dSpXb = dSpXb1 - dSpXb2
   dSpX = dSpX + dSpXb
   if dSpX > 0 then
      dSpX = dSpX + dOffsC
   else
      dSpX = dOffsC
   end
   return dSpX
 end

-- Calcolo di spostamento 'avanti' (negativo in coord. locali)
-- Caso di intersezione con lato N-2
local function Spostamento40( Len, dOffsR, dOffsC, dH3, Alpha1, Alpha2)
   local dSpX, dSpXa, dSpXc
   local Beta = 180 + Alpha1 + Alpha2
   if Beta <= 90 then
      --(in ipotesi Beta 1 > 90)
      dSpXa = -(dOffsR+dH3) * tan( 90-Beta)
      dSpXc = Len * (cos( Alpha2) + sin( -Alpha2) / tan( Beta))
      dSpX = dSpXa + dSpXc - dOffsC
   else
      dSpX = -dOffsC
   end 
   return dSpX
 end

-- Calcolo di spostamento 'avanti' (negativo in coord. locali)
-- Caso di intersezione con A/F in lato N-2
local function Spostamento41( Len, dOffsR, dOffsC, dH1, dH3, Alpha1, Alpha2)
   local dSpX, dSpXa, dSpXb, dSpXb1, dSpXb2, dSpXc
   local Beta = 180 + Alpha1 + Alpha2
   if Beta <= 90 then
      --(in ipotesi Beta 1 > 90)
      dSpXa = -(dOffsR + dH3) * tan( 90-Beta)
      dSpXc = Len * (cos( Alpha2) + sin( -Alpha2) / tan( Beta))
      dSpX = dSpXa + dSpXc
   else
      dSpX = 0
   end 
   dSpXb1 = -(dOffsR+dH1) / cos( 90-Beta)
   dSpXb2 = Len * sin( -Alpha2) / tan( Beta)
   dSpXb = dSpXb1 + dSpXb2
   dSpX = dSpX + dSpXb
   if dSpX < 0 then
      dSpX = dSpX - dOffsC
   else
      dSpX = - dOffsC
   end
   return dSpX
 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, 'BLUE')
         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 -- function LoadData
 --

-- elimino tutti i pezzi "Alz-Front" ((a partire dal primo pezzo (il piano cucina)))
local function ResetDraw( Pz)
   local TabOfPart = {}
   --local CurrPz = EgtGetNextPart( Pz)
   local CurrPz = Pz
   while CurrPz ~= nil do
      local InfoCMP = ""
      if "Alz-Front" == EgtGetName( CurrPz) then
         table.insert( TabOfPart, CurrPz)
      else
         -- *********************************** by NICOLA MODIFICA **************************************************
         local TabLayers = EgtGetNameInGroup( CurrPz, "Etichette")
         EgtErase(TabLayers)         
         EgtSetName( EgtGroup( CurrPz, GDB_RT.LOC), "Etichette")
      end
      CurrPz = EgtGetNextPart( CurrPz)
   end
   EgtErase( TabOfPart)
end
--

-- Costruzione del pezzo accessorio (Alzatina o Frontralino)
local function CMP_Draw(bPreview)
   -- Carico i messaggi
   local Msg = require('EgtCompoMsg')
   CMP.ERR = 0
   CMP.MSG = ''   

   -- Valori limite
   local GammaMin = 1  -- angolo di inclinazione taglio minimo (in valore assoluto) da considerare
   local GammaMax = 75 -- angolo di inclinazione taglio massimo (in valore assoluto) da considerare
   local MinThick = 10 -- spessore minimo 'standard' del grezzo

   -- Assegno l'angolo di incremento per i tagli inclinati 
   local F_Delta = CMP.F_DeltaAng
   local A_Delta = CMP.A_DeltaAng
   -- Assegno altezze AF/
   local FH = CMP.F_Height
   local AH = CMP.A_Height 
   
   -- ++++++ PROVVISORIO +++++
   -- Assegno spessore lastra
   local Thick
   if CMP.ThicknessRaw then
      if CMP.ThicknessRaw >= MinThick then
         Thick = CMP.TThicknessRaw
      else
         Thick = MinThick
      end
   else
      Thick = MinThick
   end
   -- ++++++ PROVVISORIO +++++
   
   -- Assegno la dimensione di riferimento (=1/100 del 'raggio' della figura)
   local dDim = CMP.BBoxRad / 1000
   local dHLbl = CMP.HeightText
   local dOffs =  dDim * 2     -- distanziamento normale testi per etichettatura angoli di lavorazione
   local dOffs2 = dDim * 4     -- distanziamento normale testi per etichettatura lati piano
   local dOffsR = dDim * 50    -- distanziamento dei rettangoli dai lati del componente
   local dOffsC = dDim * 40    -- 'costante' aggiuntiva per spostamenti
   --
   CMP.ERR = 0
   CMP.MSG = ''     
   -- Pezzo e Layer già definiti
   local Pz = EgtGetFirstGroupInGroup( GDB_ID.ROOT)
   -- salva info spessore nominale pezzi in Pz
   EgtSetInfo( Pz, "RawTN", Thick)
   
   -- ripulisco il disegno
   ResetDraw( Pz)
   
   if not Pz then
      CMP.ERR = 5
       CMP.MSG = Msg[160] -- <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")
   
   if not Ls then
      Ls = EgtGroup( Pz, GDB_RT.LOC)
           EgtSetName( Ls, "SelectRegion")
   end
   
   if not La or not Lo or not Lw or not Le or not Lq then
       CMP.ERR = 6
       CMP.MSG = Msg[161] -- <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
   
   -- 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"  => al lato non devono essere associati alzatina o frontalino
       "AF=1"  => al lato deve essere associata 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 è usata 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 Vector; .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** rappresentative di alzatine o frontalini
   -- -------------------------------------------------------------------------------
   for SideNum = 1 , #SideTab do
      local SideId = SideTab[SideNum].IdSd
      local sSideName = EgtGetInfo( SideId, "N", 's')
      local sSideLbl
      local dCutAngle = EgtGetInfo( SideId, "SideAng", 'd')
      if dCutAngle then
         sSideLbl = sSideName..'/='..dCutAngle..'°'
      else
         sSideLbl = sSideName
      end
      local sText
      local l1, l2, l3, l4
      
      -- 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 Delta1; local Delta2
         
         -- Costruisco il **SISTEMA DI RIFERIMENTO** per il rettangolo
         local Pt = EgtEP( SideId) + 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")
         local LayR = EgtGroup( Pz)
                        EgtSetName( LayR, "Region")

         -- **ALZATINA**
         if SideTab[SideNum].InfoSd == 1 then
            EgtSetColor(Lay,RED(),100,true)
            BaseL = EgtCurveLength( SideId)
            sText = sSideName..'-Alz.-'
            HeightL = AH
            
         -- **FRONTALINO**
         elseif SideTab[SideNum].InfoSd == 2 then
            EgtSetColor(Lay,BLUE(),100,true)
            BaseL = EgtCurveLength( SideId)
            sText = sSideName..'-Fr.-'
            HeightL = FH
            SideTab[SideNum].Frame = Frame 
         end
      
         -- **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 Vector; .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
         Delta1 = 0
         Delta2 = 0
         
         -- **ALZATINE**
         if Tab[N].InfoSd == 1 then
            
         -- ALZATINE: 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, dOffs, 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, dOffs, 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, dOffs, 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, dOffs, dHLbl)
            end
            
         -- ALZATINE: 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, dOffs, 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, dOffs, 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, dOffs, dHLbl)
            -- **4) As1.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) - A_Delta/2 
               -- **************************************
               --SideAngSetInfo ( l4, LayLbl, Gamma, dOffs, dHLbl, GammaMin, GammaMax)) 
            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, LayR, BaseL + Delta1 + Delta2 , HeightL, sText, RefToAF, Delta1, Delta2) 
            l1, l2, l3, l4 = DrawRectangle (Pz, Lay, LayR, BaseL + Delta1 + Delta2 , HeightL, sText, 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
            -- aggiungo info e etichette per i tagli inclinati
            SideSetInfoAF ( l2, LayLbl, Gamma1, dOffs, dHLbl*0.25, GammaMin, GammaMax, 'Red')
            SideSetInfoAF ( l4, LayLbl, Gamma2, dOffs, dHLbl*0.25, GammaMin, GammaMax, 'Red')
            -- aggiungo etichetta con nome del lato del piano ed angolo di taglio (pari a 0, in quanto 
            -- non è prevista la possibilità di Alz./Fr. su lati con angolo di taglio già impsostato diverso da 0)
            Gamma = 0
            SideSetInfoC ( SideId, Le, Gamma, dOffs2, dHLbl*0.5, GammaMin, GammaMax, sSideName..'/')
            
         -- **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 Vector; .VectE = Side End Vector;|
            -- |.zPrvAng = PrecSide-Side_Angle; .zNxtAng = Side-ProxSide_Angle|
            -- |.RefAF = GUID Reference.|

            -- FRONTALINI: 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, dOffs, dHLbl)
               -- (in caso Alphap <= 90, non si fa taglio inclinato)
               else 
                  Gamma1 = 0
                  --SideAngSetInfo ( l2, LayLbl, Gamma, dOffs, 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, dOffs, dHLbl)
               -- (in caso -Alphap <= 90, non si fa taglio inclinato)
               else
                  Gamma1 = 0
                  --SideAngSetInfo ( l2, LayLbl, Gamma, dOffs, 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/2
               --SideAngSetInfo ( l2, LayLbl, Gamma, dOffs, 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/2
               --SideAngSetInfo ( l2, LayLbl, Gamma, dOffs, dHLbl)
            end 
            
            -- FRONTALINI: CASI RIFERITI AL LATO SUCCESSIVO
            
            -- **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, dOffs, dHLbl)
               -- (in caso Alphap <= 90, non si fa taglio inclinato)
               else 
                  Gamma2 = 0
                  --SideAngSetInfo ( l4, LayLbl, Gamma, dOffs, 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, dOffs, dHLbl)
               -- (in caso -Alphap <= 90, non si fa taglio inclinato)
               else
                  Gamma2 = 0
                  --SideAngSetInfo ( l4, LayLbl, Gamma, dOffs, 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/2
               --SideAngSetInfo ( l4, LayLbl, Gamma, dOffs, 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/2
               --SideAngSetInfo ( l4, LayLbl, Gamma, dOffs, dHLbl)
            end
            
            -- chiamo la funzione per il disegno (senso antiorario) dei lati del rettangolo 'allineato' 
            --local l1, l2, l3, l4 = DrawRectangle (Pz, Lay, LayR, BaseL + Delta1 + Delta2 , HeightL, sText, RefToAF, Delta1, Delta2) 
            l1, l2, l3, l4 = DrawRectangle (Pz, Lay, LayR, BaseL + Delta1 + Delta2 , HeightL, sText, 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
            -- aggiungo info e etichette per i tagli inclinati
            SideSetInfoAF ( l2, LayLbl, Gamma1, dOffs, dHLbl*0.25, GammaMin, GammaMax, 'Blue')
            SideSetInfoAF ( l4, LayLbl, Gamma2, dOffs, dHLbl*0.25, GammaMin, GammaMax, 'Blue')
            -- aggiungo taglio inclinato a -(45+delta) del lato superiore del frontalino
            -- e corrispondente lato del piano cucina
            Gamma = -(45+F_Delta)
            SideSetInfoAF ( l1, LayLbl, Gamma, dOffs, dHLbl*0.25, GammaMin, GammaMax, 'Blue')
            --SideAngSetInfo ( Tab[N].IdSd, Le, Gamma, dOffs, dHLbl, GammaMin, GammaMax, sSideName..'/')
            SideSetInfoC ( SideId, Le, Gamma, dOffs2, dHLbl*0.5, GammaMin, GammaMax, sSideName..'/')
            
          --LabelPntLOC( LayR, ptP, sDim, dTextH, dRot, BLACK())
         --   
         end --AlZATINE/FRONTALINI  
      
         -- aggiungo **DIMENSIONI SULL'OGGETTO**
         local ptP = 0.5 * (EgtSP( l1) + EgtEP( l2))
         local sDim = EgtNumToString( BaseL+Delta1+Delta2)..' '..'x'..' '..EgtNumToString(HeightL)
         local dRot
         local dTextH = dHLbl * 0.45         --****************
         local dIncl -- inclinazione del lato del piano cucina
         dIncl = atan2( EVect:getY(),EVect:getX())
         if dIncl >= -75 and dIncl <= 115 then
            dRot = 180
         else
            dRot = 0
         end
         local DimLbl = AddLabelPntLOC( LayR, ptP, sDim, dTextH*0.75, dRot, BLACK())
            -- ???? prevedere caso di errore (info ~= da 1 e da 2 e non nulla ??????
         EgtDeselectAll() 
      else
         -- se per il lato del piano non è richiesta né alzatina né frontalino      
         -- aggiungo etichetta con nome del lato del piano ed eventuale angolo di taglio definito a priori
         if dCutAngle then
            Gamma = dCutAngle
         else
            Gamma = 0
         end
         SideSetInfoC ( SideId, Le, Gamma, dOffs2, dHLbl*0.5, GammaMin, GammaMax, sSideName..'/', 'NA')
      end  -- richiesta di 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 acuto |o nessuno, perlomeno se con lati N, N+1 e N+2 interessati.. ?|
   -- |?| 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 Vector; .VectE = Side End Vector;|
         -- |.zPrvAng = PrecSide-Side_Angle; .zNxtAng = Side-ProxSide_Angle.|
      -- |DEF.:| con angoli Alpha tra lati 'a dx', gli angoli Beta come più sotto calcolati sono gli angoli (positivi) estrerni
      --       tra due lati consecutivi
      -- |LEGENDA 2: CLASSIFICAZIONE INTERSEZIONI|  
         -- a) un solo angolo consecutivo a dx (alpha < 0+eps) 
         --  a.r1) un solo rettangolo con il lato compo successivo   FATTO
         --  a.r2) un solo rettangolo con il lato compo precedente   FATTO
         --  a.r1r2) due rettangoli                                  FATTO
         -- b) due angoli successivi a dx (alpha1 e alpha 2 < 0°)    FATTO
         --  b1) |ip: Beta1 e Beta2 entrambi > 90° (angoli tra i lati ottusi)|    
         --       ?? altrimenti r1 e/o r2 andrebbero verificati rispetto anche rispetto ai lati e r2 potrebbe doversi muovere lungo il prorio asse y ??
         --    b1.r1r2r3) =  |r2 resta fermo (r2 non interferisc né con lato N né con lato N+2| per ipotesi)|
         --    b1.r1r2) si muove solo r1
         --    b1.r2r3) si muove solo r3
         
         
         -- DA FARE (TEORICAMENTE) :
         --    |ip: c.s. Alpha1 e Alpha2 entrambi > 90°| (= 'a dx')
         --    b1.r1)   r1 non deve interferire con lato N+2
         --    b2.r3)   r3 non deve interferire con lato N1
         --    b1.r2)   r2 resta fermo, quindi non gestito perché non c'è spostamento
         --    b1.r1r3) 
         
         
         --  b2)  |se Beta1 o Beta 2 <= 90° (acuto|)
         --
      
      
      local Tab = SideTab 
      local N = SideNum
      local epsilon = 0.1 -- costante
      --local dOffsR = CMP.BBoxRad*0.1 -- distanza dei rettangoli dal lato corrispondente
      -- spostamenti (nel verso x+ del proprio sist. di rif.) del rettangolo 
               --local dSpX1a, dSpX1b, dSPX2a, dSpX2b, 
               --local dSpX1, dSpX2
      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
         
         -- **[a.r1]:** solo il lato N interessato da A/F
         if  Tab[N].InfoSd > 0 and Tab[Tab[N].RecNxt].InfoSd == 0 then
            local dSpX1 = Spostamento10( dOffsR, dOffsC, dH1, Beta1)
            EgtMoveGroup( Tab[N].IdPz, {dSpX1, 0, 0})
            
         -- **[a.r2]:** solo il lato N+1 interessato da A/F, angolo successivo acuto
         elseif Tab[N].InfoSd == 0 and Tab[Tab[N].RecNxt].InfoSd > 0 then
            local dSpX2 = Spostamento20( dOffsR, dOffsC, dH1, Beta1)
            EgtMoveGroup( Tab[Tab[N].RecNxt].IdPz, {dSpX2, 0, 0}) -- si può mettre in fondo a tutti i casi
            
         -- **[a.r1r2]**: entrambi i lati N e N+1 interessati da A/F
         elseif Tab[N].InfoSd > 0 and Tab[Tab[N].RecNxt].InfoSd > 0 then
            -- spostamento rettangolo 1 (lato N)
            local dSpX1 = Spostamento11( dOffsR, dOffsC, dH1, dH2, Beta1)
            EgtMoveGroup( Tab[N].IdPz, {dSpX1, 0, 0})
            -- spostamento rettangolo 2 (lato N+1)
            local dSpX2 = Spostamento21( dOffsR, dOffsC, dH1, dH2, Beta1)
            EgtMoveGroup( Tab[Tab[N].RecNxt].IdPz, {dSpX2, 0, 0})
            
         end  --[a] 
         SideNum = SideNum + 2 
         
      -- **[b]** due angoli consecutivi a dx; tre lati, N, N+1, N+2 interesssati da A/F
      -- la somma dei due angoli Alpha1 e Alpha2 è ipotizzata < 180°
      -- inoltre i due angoli compresi Beta1 e Beta2 sono ipotizzati > 90°
      elseif Alpha1 < 0 and Alpha2 < 0 then
         local dSLength = Tab[Tab[N].RecNxt].IdSd
         -- **[b1.r1r2r3]** = tre lati consecutivi N, N+1, N+2 interessati da A/F
         if (Tab[N].InfoSd > 0 and Tab[Tab[N].RecNxt].InfoSd > 0 and Tab[Tab[Tab[N].RecNxt].RecNxt].InfoSd > 0 ) then
            -- calcolo spostamento rettangolo 1 (lato N) per intersezione con r2
            local dSpX1r2 = Spostamento11( dOffsR, dOffsC, dH1, dH2, Beta1)
            -- calcolo spostamento rettangolo 1 (lato N) per intersezione con r3
            local dSpX1r3 = Spostamento31( dSLength, dOffsR, dOffsC, dH1, dH3, Alpha1, Alpha2)
            -- spostamento rettangolo 1
            EgtMoveGroup( Tab[N].IdPz, {max( dSpX1r2, dSpX1r3), 0, 0})
            -- calcolo spostamento rettangolo 3 (lato N+2) per intersezione con r2
            local dSpX3r2 = Spostamento21( dOffsR, dOffsC, dH2, dH3, Beta2)
            -- calcolo spostamento rettangolo 3 (lato N+2) per intersezione con r1
            local dSpX3r1 = Spostamento41( dSLength, dOffsR, dOffsC, dH1, dH3, Alpha1, Alpha2)
            -- spostamento rettangolo 3
            EgtMoveGroup( Tab[Tab[Tab[N].RecNxt].RecNxt].IdPz, {min( dSpX3r2,dSpX3r1), 0, 0})
            
         -- **[b1.r1r3]** = lati N, e N+2 interessati da A/F
         --             i due angoli compresi sempre ipotizzati ottusi
         elseif (Tab[N].InfoSd > 0 and Tab[Tab[Tab[N].RecNxt].RecNxt].InfoSd > 0 ) then
            --local SLength = Tab[Tab[N].RecNxt].IdSd
            -- spostamento rettangolo 1 (lato N)
            local dSpX1 = Spostamento31( dSLength, dOffsR, dOffsC, dH1, dH3, Alpha1, Alpha2)
            EgtMoveGroup( Tab[N].IdPz, {dSpX1, 0, 0})
            -- spostamento rettangolo 3 (lato N+2)
            local dSpX3 = Spostamento41( dSLength, dOffsR, dOffsC, dH1, dH3, Alpha1, Alpha2)
            EgtMoveGroup( Tab[Tab[Tab[N].RecNxt].RecNxt].IdPz, {dSpX3, 0, 0})
            
         -- **[b1.r1r2]** = solo lati N e N+1 interessati da A/F
         elseif (Tab[N].InfoSd > 0 and Tab[Tab[N].RecNxt].InfoSd > 0 and Tab[Tab[Tab[N].RecNxt].RecNxt].InfoSd == 0 ) then
            -- spostamento rettangolo 1 (lato N)
            local dSpX1 = Spostamento11( dOffsR, dOffsC, dH1, dH2, Beta1)
            EgtMoveGroup( Tab[N].IdPz, {dSpX1, 0, 0})
            
         -- **[b1.r2r3]** = solo lati N+1 e N+2 interessati da A/F
         elseif (Tab[N].InfoSd == 0 and Tab[Tab[N].RecNxt].InfoSd > 0 and Tab[Tab[Tab[N].RecNxt].RecNxt].InfoSd > 0 ) then
            -- spostamento rettangolo 3 (lato N+2)
            local dSpX3 = Spostamento21( dOffsR, dOffsC, dH2, dH3, Beta2)
            EgtMoveGroup( Tab[Tab[Tab[N].RecNxt].RecNxt].IdPz, {dSpX3, 0, 0})
            
         -- **[b1.r1]** = solo lato N interessato da A/F
         elseif (Tab[N].InfoSd > 0 and Tab[Tab[N].RecNxt].InfoSd == 0 and Tab[Tab[Tab[N].RecNxt].RecNxt].InfoSd == 0 ) then
            local SLength = Tab[Tab[N].RecNxt].IdSd
            local dSpX1 = Spostamento30( SLength, dOffsR, dOffsC, dH1, Alpha1, Alpha2)
            EgtMoveGroup( Tab[N].IdPz, {dSpX1, 0, 0})

         -- **[b1.r3]** = solo lato N+2 interessato da A/F
         elseif (Tab[N].InfoSd == 0 and Tab[Tab[N].RecNxt].InfoSd == 0 and Tab[Tab[Tab[N].RecNxt].RecNxt].InfoSd > 0 ) then
            local SLength = Tab[Tab[N].RecNxt].IdSd
            local dSpX3 = Spostamento40( SLength, dOffsR, dOffsC, dH3, Alpha1, Alpha2)
            EgtMoveGroup( Tab[Tab[Tab[N].RecNxt].RecNxt].IdPz, {dSpX3, 0, 0})
            
         end -- casi [b1. ...]
         
      -- ++++++++++++++++++++++++++++ TO DO ++++++++++++++++++++++++++++++++++++++++++++
      -- **[b2] DA FARE**   
      -- ++++++++++++++++++++++++++++ TO DO ++++++++++++++++++++++++++++++++++++++++++++
   
         
      SideNum = SideNum + 3 
      else
         SideNum = SideNum + 1 
      end -- [a, b  ]
      
      
   end -- while /verifica intersezioni)
         
   
      
end --function CMP_Draw(bPreview)

_G.CMP_Draw = CMP_Draw
            CMP_Draw(true) -- solo per da egtCAM5
            EgtZoom(SCE_ZM.ALL)
            --EgtSaveFile( )