StoneSolidGen/CreateSOLID_FromPartsInPark.lua

-- 2023/05/__
-- |ultima modifica:|
-- |aggiunta gestione di più loop interni|
--ERR == -1 valore di default
--ERR == 1  SLD.CurrId non è valido ( == -1)
--ERR == 0  eseguito senza problemi

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


-- Dati raccolti direttamente dal programma
local SLD = {}
--input
SLD.THICK = 40
SLD.CurrId = -1
-- output
SLD.CurrPartSolid = -1
SLD.CurrSrfTmId = -1
SLD.ERR = -1

----- mi preparo a ricevere argomenti
local arg = ...
local bAutoRun = false
if arg then
   bAutoRun = arg.AutoRun
end

_G.SLD = SLD

local ColorSTD = 'AQUA'
local ColocERR = 'ORANGE'

-- Id del primo Part del progetto
local IdP_FirstPart = -1
-- Id del layer "OutLoop"
local IdL_OutLoop = -1
-- Id del layer "InLoop"
local IdL_InLoop = -1
-- Id del layer "OnPath"
local IdL_OnPath = -1
-- Id del layer "Pocket"
local IdL_Pocket = -1
-- Id del layer "FiloTop"
local IdL_FiloTop = -1
-- Id del Part "SOLID"
local IdP_SOLID = -1
-- Id dei layer apprtenenti a "SOLID"
local IdL_Temp = -1
local IdL_Solid = -1
local IdL_Bound = -1
local IdL_Faces = -1

--[[ 
tabella contenente: IdSurf → superificie di taglio,
                    ptS    → punto in basso a sinistra dalla superificie
                    vtS    → direzioned del lato basso della superficie
                    Ang    → inclinazione rispetto alla verticale
                    Hill   → tallone
                    NAng   → direzione agolo orizzontale lato successivo
]]--
local tbId_RectSurf = {}
-- tabella contenente i lati del layer OutLoop: IdS → lato del contorno
local tbId_OutLoop = {}
-- tabella contenente le tabelle dei layer degli InLoop: IdI → lato del contorno
local tbId_InLoop = {}
-- tabella contenente le tabelle delle curve composte del layer OnPath: IdI → 
local tbId_OnPath = {}
-- tabella contenente le tabelle dei lati del layer Pocket: IdI → 
local tbId_Pocket = {}
-- tabella contenente la tabella delle curve composte del layer FiloTop: IdI → 
local tbId_FiloTop = {}
-- Id del solido generato
local IdEnt_Part = -1
-- Id del solido da sottrarre
local IdEnt_SubPart = -1
-- Id della facce come Flat Region
local tbId_Faces = {}

-- Spessore grezzo (Ddefault)
local RTh = 30
local bAlwaysOnTop = true
--local nIdTrimOut = -1
--local nIdTrimIn = -1
local tbTrimTot = {}
-- Estensioni delle regioni di taglio per SideAngle
--NB: lo spessore dei pezzi è limitato a 100(o meno, se ci sono dei sideAng), quindi per spessori importanti bisognerebbe modificare il valore di questa dimensione
local DefaultDim = 100
-- valore di tolleranza minimo per estrarre i contorni da una regione
local TollY = 1
local m_bArc = false

----------------------------------------------------------------------------
-- **Preparo ambiente** Part+Layer
----------------------------------------------------------------------------
-- Reimposto a vuoto il valore delle tabelle, resetto gli Id
local function ResetAllTabAndVar()
   tbId_RectSurf = {}
   -- tabella contenente i lati del layer OutLoop: IdS → lato del contorno
   tbId_OutLoop = {}
   -- tabella contenente i lati del layer InLoop: IdI → lato del contorno
   tbId_InLoop = {}
   -- tabella delle superfici laterali ( facce adiacenti già mergiate in un'unica superficie), la prima è quella out, le successive sono quelle in
   tbId_SurfLat = {}
   -- tabella contenente le curve composte del layer OnPath: IdI → 
   tbId_OnPath = {}
   -- tabella contenente i lati del layer Pocket: IdI → 
   tbId_Pocket = {}
   -- tabella contenente le curve composte del layer FiloTop: IdI → 
   tbId_FiloTop = {}
   -- Id del solido generato 
   IdEnt_Part = -1
   -- Id del solido da sottrarre
   IdEnt_SubPart = -1
--   -- Id della superficie interna del solido
--   nIdTrimIn = -1
--   -- Id dalla superficie esterna del solido
--   nIdTrimOut = -1
   -- tabella delle superfici per costruire il solido
   tbTrimTot = {}
   -- tabella delle superfici laterali
   tbId_SurfLat = {}
   -- Id della facce come Flat Region
   tbId_Faces = {}
   m_bArc = false
end

-- Elimino il layer solid del Part selezionato
local function ClearCurrIdSOLID()
   IdP_SOLID = EgtGetFirstPart()
   while IdP_SOLID do
      local IdP_SOLID_Next = EgtGetNext( IdP_SOLID)
      local nIdParent = EgtGetInfo(IdP_SOLID, "Parent", 'i')
      if EgtGetName( IdP_SOLID) == "SOLID" and nIdParent ~= nil and IdFP == nIdParent then
         EgtErase( IdP_SOLID)
         break
      end
      IdP_SOLID = IdP_SOLID_Next
   end
end
--

--[[
Creazione di un nuovo Part: IdP_SOLID      → part "SOLID"
                            IdL_Temp       → Layer di destinazione delle superfici di taglio
                            IdL_Solid      → Layer di destinazione del solido
                            IdL_Bound      → Layer di destinazione delle linee di contorno del solido

]]--
local function CreatePartSOLID()
   ResetAllTabAndVar()
   IdP_SOLID = EgtGroup(GDB_ID.ROOT,GDB_RT.LOC)
   EgtSetName( IdP_SOLID, "SOLID")
   EgtSetInfo(IdP_SOLID, "Parent", IdFP)
   EgtSetInfo(IdFP, "Child", IdP_SOLID)
   EgtSetInfo( IdP_SOLID, "Th", RTh)
   IdL_Temp  = EgtGroup(IdP_SOLID,GDB_RT.LOC)
   EgtSetName( IdL_Temp, "Temp")
   IdL_Solid = EgtGroup(IdP_SOLID,GDB_RT.LOC)
   EgtSetName( IdL_Solid, "Surface")
   IdL_Bound = EgtGroup(IdP_SOLID,GDB_RT.LOC)
   EgtSetName( IdL_Bound, "Boundary")
   IdL_Faces = EgtGroup(IdP_SOLID,GDB_RT.LOC)
   EgtSetName( IdL_Faces, "Faces")
end
--

----------------------------------------------------------------------------
-- **Recupero info dei pezzi** SideAng:Ang, Heel; FiloTop:Depth
----------------------------------------------------------------------------
-- restituisce le info sui lati inclinati
local function GetAngHill( nInd)
   if nInd then
      local A = EgtGetInfo( nInd, 'OrigSideAng', 'd')
      local H = EgtGetInfo( nInd, 'Heel', 'd')
      if A and H then
         return A, H
      elseif A and not H then
         return A, 0
      end
   end   
   return 0,0
end
--

-- restituisce l'affondamento del profilo FiloTop
local function GetDepth( nInd)
   if nInd then
      local D = EgtGetInfo( nInd, 'Depth', 'd')
      if D then
         return D
      end
   end
   return 0
end
--

-- restituisce l'affondamento del profilo FiloTop
local function GetDepthOnPath( nInd)
   if nInd then
      D = EgtGetInfo( nInd, 'Depth', 'd')
      if not D then
         D = EgtGetInfo( nInd, 'Th', 'd')
      end
      if D then
         return D
      end
   end
   return 5
end
--

-- restituisce il valore dell'angolo successivo (se <0 angolo concavo)
local function GetnNextAng( nInd)
   local A = EgtGetInfo( nInd, 'NextAng', 'd')
   return A   
end
--

-- restituisce il valore dell'angolo precedente (se <0 angolo concavo)
local function GetnPrevAng( nInd)
   local A = EgtGetInfo( nInd, 'PrevAng', 'd')
   return A   
end
--

----------------------------------------------------------------------------
-- **Carico tabelle** IdL_OutLoop, IdL_InLoop, tbId_OnPath, tbId_Pocket, tbId_FiloTop
----------------------------------------------------------------------------
-- riceve la tablella e il nome del Layer, riempie la tabella e restituisce l'ID del layer
local function GetIdFromLay( myTab, sLay)
   RTh = SLD.THICK
   --IdFP = EgtGetFirstPart()
   local IdLay = EgtGetFirstNameInGroup( IdFP, sLay)
   local tbIdLayTemp = {}
   -- salvo l'id solo del primo layer con nome sLay
   local IdFirstLay = IdLay
   -- questo while su IdLay serve se ho più gruppi con questo nome
   while IdLay do
      local IdS = EgtGetFirstInGroup( IdLay)
      while IdS do
         if EgtGetType( IdS) == GDB_TY.CRV_LINE or EgtGetType( IdS) == GDB_TY.CRV_ARC or EgtGetType( IdS) == GDB_TY.CRV_COMPO then
            if sLay == 'OutLoop' then
               table.insert( myTab, IdS)
            elseif sLay == 'InLoop' or sLay == 'Pocket' or sLay == 'FiloTop' or sLay == 'OnPath' then
               table.insert( tbIdLayTemp, IdS)
            end
         end
         IdS = EgtGetNext( IdS)
      end
      if sLay == 'InLoop' or sLay == 'Pocket' or sLay == 'FiloTop' or sLay == 'OnPath' then
         table.insert( myTab, tbIdLayTemp)
         tbIdLayTemp = {}
      end

      IdLay = EgtGetNextName( IdLay, sLay)
   end
   return IdFirstLay
end
--

----------------------------------------------------------------------------
-- **Solido di riferimento** IdEnt_Part
----------------------------------------------------------------------------
-- dato il contorno del pezzo 
local function  CreateSolid()

   local nLoopOut, nCountOut = EgtExtractSurfTmLoops( tbId_SurfLat[1], IdL_Bound)
   local tbLoop1 ={nLoopOut}
   local tbLoop2 ={nLoopOut + 1}
   --local ptSBottom = EgtSP( nLoopOut + 1)

   local nLoopIn = -1
   local nCountIn = 0
   if #tbId_SurfLat > 1 then
      for k = 2, #tbId_SurfLat, 1 do
         nLoopIn, nCountIn = EgtExtractSurfTmLoops( tbId_SurfLat[k], IdL_Bound)
         for p=0, nCountIn - 1, 1 do
            if math.abs(EgtSP( nLoopIn + p):getZ() - EgtSP( nLoopOut):getZ()) < 0.01 then
               table.insert(tbLoop1, nLoopIn + p)
            else --math.abs(EgtSP( nLoopIn + p):getZ() - EgtSP( nLoopOut + 1):getZ()) < EPS_SMALL then
               table.insert(tbLoop2, nLoopIn + p)
            end
         end
      end
   end

   -- creo le SurfTm delle facce sopra e sotto
   local nIdSurf1 = EgtSurfTmByRegion( IdL_Solid, tbLoop1)
   local nIdSurf2 = EgtSurfTmByRegion( IdL_Solid, tbLoop2)
   for i = 1, #tbLoop1, 1 do
      EgtErase( tbLoop1[i])
   end
   for i = 1, #tbLoop2, 1 do
      EgtErase( tbLoop2[i])
   end
   EgtInvertSurf( {nIdSurf1, nIdSurf2})

   tbTrimTot = {nIdSurf1, nIdSurf2}
   for k = 1, #tbId_SurfLat, 1 do
      table.insert( tbTrimTot, tbId_SurfLat[k])
   end

   local nIdTrimTot = EgtSurfTmByTriangles( IdL_Solid, tbTrimTot, false)
   EgtSetColor( nIdTrimTot, ColorSTD)
   EgtErase( tbTrimTot)
   tbTrimTot = {nIdTrimTot}
   IdEnt_Part = nIdTrimTot
   SLD.CurrPartSolid = IdP_SOLID
   SLD.CurrSrfTmId = nIdTrimTot
end
--

----------------------------------------------------------------------------
-- **Pocket** 
----------------------------------------------------------------------------
local function PocketSolid()
   -- se sono presenti dei ribassi provvedo a disegnarli
   if #tbId_Pocket > 0 then
      for i = 1, #tbId_Pocket do
         local IdCompo_Pocket, nCrv = EgtCurveCompoByChain( IdL_Solid, tbId_Pocket[i], EgtSP( tbId_Pocket[i][1]), false)
         local IdEnt_Pocket = EgtSurfTmByRegionExtrusion( IdL_Solid, {IdCompo_Pocket}, Z_AX()*(2* RTh))
         EgtSurfTmSubtract( IdEnt_Part, IdEnt_Pocket)
         EgtErase( {IdEnt_Pocket})
         EgtErase( {IdCompo_Pocket})
         local a = 0
      end
   end
end

----------------------------------------------------------------------------
-- **OnPath** 
----------------------------------------------------------------------------
local function Engraves( nId)
   -- se non restituisce nulla allora utlizzo direttamente la copia
   local vtExtr
   local vtO

   nNbr = 1
   vtO = EgtSV( nId)
   vtExtr = Vector3d( vtO[3]/vtO[1], 0, 1)
   vtExtr:normalize()
   local D = 10
   EgtMove( {nId}, vtExtr*(D))

   if D > 0 or not vt then
      local nEntCopy_1 = EgtCopy( nId, IdL_Temp)
      local nEntCopy_2 = EgtCopy( nId, IdL_Temp)
      EgtMove( {nEntCopy_2}, vtExtr*(- D))
      local nLine_1 = EgtLine( IdL_Temp, EgtSP( nEntCopy_1, GDB_ID.ROOT ), EgtSP( nEntCopy_2, GDB_ID.ROOT ))
      local nLine_2 = EgtLine( IdL_Temp, EgtEP( nEntCopy_1, GDB_ID.ROOT ), EgtEP( nEntCopy_2, GDB_ID.ROOT ))
      local nCompo = EgtCurveCompoByChain( IdL_Solid, {nEntCopy_1,nLine_1,nEntCopy_2,nLine_2}, EgtSP( nLine_1), false)
      vtExtr:rotate( vtO, 90)
      local IdSubSolid = EgtSurfTmByRegionExtrusion( IdL_Solid, {nCompo}, vtExtr*(2))
      EgtSurfTmSubtract( IdEnt_Part, IdSubSolid)
      EgtErase( {nEntCopy_1,nLine_1,nEntCopy_2,nLine_2, nCompo, IdSubSolid, nId})
   end 
end
--

-- genero i tagli singoli
local function OnPathSolid()
   for i=1, #tbId_OnPath, 1 do
      for j=1, #tbId_OnPath[i], 1 do
         local nInd = tbId_OnPath[i][j]
         local D = GetDepthOnPath( nInd)
         if D > RTh then
            SLD.ERR = 1
            EgtSetColor( {IdEnt_Part}, ColocERR)
         end
         -- creo una copia nel Layer "Temp"
         local nEntCopy = EgtCopy( nInd, IdL_Temp)
         local nId, nNbr = EgtExplodeCurveCompo( nEntCopy)
         -- definisco il vettore di spostamento verticale del solido da sottrarre
         local vtV = Z_AX()
         if nId ~= nil then
            for j=0 , nNbr-1, 1 do
               local nTempId = nId + j
               local vt = EgtSV( nTempId)
               vt:rotate(vtV, 90)
               if D > 0 or not vt then
                  local nEntCopy_1 = EgtCopy( nTempId, IdL_Temp)
                  local nEntCopy_2 = EgtCopy( nTempId, IdL_Temp)
                  EgtMove( {nEntCopy_2}, vtV*(- D))
                  local nLine_1 = EgtLine( IdL_Temp, EgtSP( nEntCopy_1, GDB_ID.ROOT ), EgtSP( nEntCopy_2, GDB_ID.ROOT ))
                  local nLine_2 = EgtLine( IdL_Temp, EgtEP( nEntCopy_1, GDB_ID.ROOT ), EgtEP( nEntCopy_2, GDB_ID.ROOT ))
                  local nCompo = EgtCurveCompoByChain( IdL_Solid, {nEntCopy_1,nLine_1,nEntCopy_2,nLine_2}, EgtSP( nLine_1), false)
                  local IdSubSolid = EgtSurfTmByRegionExtrusion( IdL_Solid, {nCompo}, vt*(2))
                  EgtSurfTmSubtract( IdEnt_Part, IdSubSolid)
                  EgtErase( {nEntCopy_1,nLine_1,nEntCopy_2,nLine_2, nCompo, IdSubSolid, nTempId})
               end 
            end
         else
            Engraves( nEntCopy)
         end
      end
   end
end
--


----------------------------------------------------------------------------
-- **Filo Top** 
----------------------------------------------------------------------------
-- sottraggo al solido il contorno FiloTop
local function FiloTopSolid()
   local nLay = EgtGetFirstNameInGroup( IdFP, "FiloTop")
   for i = 1, #tbId_FiloTop do
      local D = GetDepth( nLay)
      if D < 0.1 then 
         return
      end
      local IdEnt_SurfFiloTop = EgtSurfTmByRegionExtrusion( IdL_Solid, tbId_FiloTop[i], Z_AX()*(- D -1))
      EgtMove( {IdEnt_SurfFiloTop}, Z_AX()*1)
      EgtSurfTmSubtract( IdEnt_Part, IdEnt_SurfFiloTop)
      EgtErase( {IdEnt_SurfFiloTop})
      nLay = EgtGetNextName( nLay, "FiloTop")
   end
end
--

----------------------------------------------------------------------------
-- HillPlane D
----------------------------------------------------------------------------
local function PlaneShift( nId, Hill)
   if bAlwaysOnTop then
      Hill = Hill * (-1)
   end
   local vtTrasl = Z_AX() * Hill
   EgtMove( nId, vtTrasl)
end
--

----------------------------------------------------------------------------
-- HillPlane C
----------------------------------------------------------------------------
local function PlaneNoShift( nId)
   PlaneShift( nId, 0)
end
--

----------------------------------------------------------------------------
-- HillPlane A
----------------------------------------------------------------------------
local function HillPlaneAng( nId, ptS, vtS, Ang, Hill)
   local nIdHill = EgtCopy( nId, IdL_Solid)
   EgtRotate( nIdHill, ptS, vtS, Ang, GDB_ID.ROOT)
   local dTrasl
   if bAlwaysOnTop then
      if Ang > 0 then
         dTrasl = ( RTh - Hill) * math.tan( Ang * math.pi / 180)
      else
         dTrasl = 0
      end
   else
      if Ang > 0 then
         dTrasl = 0
      else
         dTrasl = ( RTh - Hill) * math.tan( -Ang * math.pi / 180)
      end
   end
   local vtTrasl = ( vtS ^ Z_AX()) * dTrasl
   EgtMove( nIdHill, vtTrasl)
   if bAlwaysOnTop then
      if Ang < 0 then
         PlaneShift( nId, Hill)
      end
   else
      if Ang > 0 then
         PlaneShift( nId, Hill)
      end
   end
   local pt_a, vn_a = EgtSurfTmFacetCenter( nId, 0)
   local pt_h, vn_h = EgtSurfTmFacetCenter( nIdHill, 0)
   EgtCutSurfTmPlane( nIdHill, pt_a, vn_a, false)
   EgtCutSurfTmPlane( nId, pt_h, vn_h, false)
   PlaneNoShift( nId)
   return nIdHill, vtTrasl
end
--

------------------------------------------------------------------------------
---- HillPlane B
------------------------------------------------------------------------------
--local function HillPlaneNegAng( nId, ptS, vtS, Ang, Hill)
--   local nIdHill, vtTrasl = HillPlanePosAng( nId, ptS, vtS, Ang, Hill, true)
--   return nIdHill, vtTrasl
--end
----

----------------------------------------------------------------------------
-- **Side Ang**
----------------------------------------------------------------------------
local function SideAngSolid( tbLoop, bInLoop)
   
   local tbIdR = {}
   local IdS
   local Ang = 0
   local Hill = 0
   local NAng = 0
   m_bArc = false

   local tbArc = {}
   local tbLimited = {}
   for i=1, #tbLoop, 1 do
      IdS = tbLoop[i]
      -- recupero i dati SideAng per ogni lato
      Ang, Hill = GetAngHill( IdS)
      NAng = GetnNextAng( IdS)
      if math.abs(NAng) <= 2 then NAng = 0 end

      -- verifico che il lato presenti un angolo inclinato
      if EgtGetType( IdS) == GDB_TY.CRV_ARC then
         m_bArc = true
         table.insert(tbArc, true)
         local ptStart = EgtSP(IdS, GDB_ID.ROOT)
         local vtStart = EgtSV( IdS, GDB_ID.ROOT)
         local vtEnd = EgtEV( IdS, GDB_ID.ROOT)
         if Ang == 0 then
            local vtExtr = Z_AX() * RTh
            if bAlwaysOnTop then
               vtExtr = vtExtr * (-1)
            end
            local nSurfId = EgtSurfTmByExtrusion(IdL_Solid, IdS, vtExtr)
            if bAlwaysOnTop then
               EgtInvertSurf( nSurfId)
            end
            local tbInfoRot = { nSurfId, ptStart, vtStart, Ang, Hill, NAng, vtEnd}
            table.insert(tbIdR,tbInfoRot)
            table.insert(tbLimited, false)
         else
            -- costruisco la superficie laterale generata dall'arco con una swept lungo l'arco stesso
            -- la sezione di cui effetturare lo sweep viene creata trovando il punto di partenza del secondo arco che delimita questa superficie
            local dLatMove = RTh * math.tan( math.abs(Ang) * pi / 180)
            local vtLatMove = (Z_AX() ^ vtStart)
            local vtVertMove = Z_AX() * RTh
            if not bInLoop then vtLatMove = vtLatMove * (-1) end
            -- devo controllare se il side ang e lo spessore della lastra sono abbastanza da far collassare l'arco in un punto ed eventualmente andare oltre
            -- verifico quindi se devo limitare la superficie della sezione di cono
            local dRad = EgtArcRadius( IdS)
            local bLimited = false
            local dArcAng = EgtArcAngCenter( IdS)
            local bCheckLimit = (dArcAng > 0 and Ang < 0 ) or ( dArcAng < 0 and Ang > 0)
            if bCheckLimit then
                if dRad < math.abs(dLatMove) + 0.01 then
                  vtLatMove = vtLatMove * dRad
                  vtVertMove = Z_AX() * dRad / math.tan( math.abs(Ang) * pi / 180)
                  bLimited = true
               end
            else
               vtLatMove = vtLatMove * dLatMove
            end
            table.insert(tbLimited, bLimited)
            
            if (Ang > 0 and bAlwaysOnTop) or ( Ang < 0 and not bAlwaysOnTop) then
               vtLatMove = vtLatMove * ( -1)
            end
            if bAlwaysOnTop then
               vtVertMove = vtVertMove * (-1)
            end
            local ptSecondArcStart = ptStart + ( vtVertMove + vtLatMove)
            local nIdLine = EgtLine(IdL_Temp,ptStart,ptSecondArcStart,GDB_ID.ROOT)
            local nPointId = EgtPoint( IdL_Temp, ptSecondArcStart)
            local nSurfId = 0
            if not bLimited then
               nSurfId = EgtSurfTmSwept(IdL_Solid,nIdLine,IdS,Z_AX(),false,0.01,GDB_ID.ROOT)
               EgtInvertSurf( nSurfId)
            else
               local vtAx = Z_AX()
               if not bAlwaysOnTop then
                  vtAx = vtAx * (-1)
               end
               nSurfId = EgtSurfTmRuled( IdL_Solid, nPointId, IdS)
               EgtInvertSurf( nSurfId)
--               nSurfId = EgtSurfTmCone(IdL_Solid,ptSecondArcStart, vtAx, dRad, RTh)
            end
            EgtErase( nIdLine)
            EgtErase( nPointId)
            local tbInfoRot = { nSurfId, ptStart, vtStart, Ang, Hill, NAng, vtEnd}
            table.insert(tbIdR,tbInfoRot)
         end
      elseif EgtGetType( IdS) ~= GDB_TY.CRV_COMPO then
         table.insert(tbArc, false)
         local ptS = EgtSP( IdS, GDB_ID.ROOT)     
         local vtS = EgtSV( IdS, GDB_ID.ROOT)
         local vtE = EgtEV( IdS, GDB_ID.ROOT)
         local IdRect = EgtCurveGetFatCurve( IdS, IdL_Temp, DefaultDim, true)
         local IdSurf = EgtSurfTmByRegion( IdL_Solid, IdRect)
         EgtErase( IdRect)

         local tbInfoRot = { IdSurf, ptS, vtS, Ang, Hill, NAng, vtE}
         table.insert( tbIdR, tbInfoRot)
         table.insert(tbLimited, false)
      end
   end

   -- posiziono i piani calcolati in precedenza e creo i piani di Hill
   for i=1, #tbIdR, 1 do
      local dTempAng = 90
      if not tbArc[i] then
         EgtRotate( tbIdR[i][1], tbIdR[i][2], tbIdR[i][3], -tbIdR[i][4] + dTempAng, GDB_ID.ROOT)
      end
      -- se ho l'hill lo creo e lo aggiungo alle caratteristiche della faccia
      if tbIdR[i][4] ~= 0 and tbIdR[i][5] > 0 then
         if not tbArc[i] then
            local nIdHill
            nIdHill, tbIdR[i][8] = HillPlaneAng( tbIdR[i][1], tbIdR[i][2], tbIdR[i][3], tbIdR[i][4], tbIdR[i][5])
            -- aggiungo l'hill come elemento separato della faccia di taglio
            tbIdR[i][9] = { nIdHill, tbIdR[i][2] + tbIdR[i][8], tbIdR[i][3], tbIdR[i][4], tbIdR[i][5], tbIdR[i][6], tbIdR[i][8]}
         else
            --- hill da gestire per il caso del lato che è un arco
         end
      else
         tbIdR[i][8] = Vector3d({0,0,0})
      end
   end

   -- **NANG** corrego la dimenione dei piani in funzione dell'angolo che descrivono con il pezzo successivo 
   for i=1, #tbIdR, 1 do
      local Ind_Curr = i
      local Ind_Nex = i + 1
      if i == #tbIdR then
         Ind_Nex = 1
      end
      -- se ho solo una faccia laterale termino ( è un foro descritto da un unico loop circolare)
      if Ind_Curr == Ind_Nex then break end
      
      local pt_n, vn_n = EgtSurfTmFacetCenter( tbIdR[Ind_Nex][1], 0)
      local pt_c, vn_c = EgtSurfTmFacetCenter( tbIdR[Ind_Curr][1], 0)
      if tbArc[Ind_Nex] then
         pt_n = tbIdR[Ind_Nex][2]  -- prendo startPoint
         vn_n = tbIdR[Ind_Nex][3]  -- prendo vtStart
         if math.abs( tbIdR[Ind_Curr][6]) > 90 then
            vn_n = vn_n * (-1)
         elseif math.abs( tbIdR[Ind_Curr][6]) > 90 then
            vn_n = EgtEV( tbLoop[Ind_Curr], GDB_ID.ROOT)  -- prendo l'end del segmento precedente all'arco
         end
      end
      if tbArc[Ind_Curr] then
         pt_c = EgtEP( tbLoop[Ind_Curr], GDB_ID.ROOT)  -- prendo endPoint
         vn_c = tbIdR[Ind_Curr][7] -- prendo vtEnd
         if math.abs( tbIdR[Ind_Curr][6]) < 90 then
            vn_c = vn_c * (-1)
         elseif math.abs( tbIdR[Ind_Curr][6]) > 90 then
            vn_c = tbIdR[Ind_Nex][3] -- prendo lo start del segmento  successivo all'arco
         end
      end

      if (not tbArc[Ind_Nex]) and (not tbArc[Ind_Curr]) then
         if ( tbIdR[Ind_Curr][6] < 0) then
            vn_n = vn_n * (-1)
            vn_c = vn_c * (-1)
         end
      end
      -- devo tagliare le superfici di taglio con le superfici di taglio
      -- gli archi li taglio usando i suoi vettori a inizio e fine curva
      if tbArc[Ind_Curr] then
         EgtCutSurfTmPlane( tbIdR[Ind_Curr][1], tbIdR[Ind_Curr][2], - tbIdR[Ind_Curr][3], false)
         EgtCutSurfTmPlane( tbIdR[Ind_Curr][1], EgtEP(tbLoop[Ind_Curr], GDB_ID.ROOT), tbIdR[Ind_Curr][7], false)
      else
         EgtCutSurfTmPlane( tbIdR[Ind_Curr][1], pt_n, vn_n, false)
      end
      if not tbArc[Ind_Nex] then
         EgtCutSurfTmPlane( tbIdR[Ind_Nex][1], pt_c, vn_c, false)
      end

      -- nel caso in cui la superficie generata dall'arco è limitata devo tagliare tra loro anche le superfici precedente e successiva all'arco--------------------------------------------------
      if tbLimited[Ind_Curr] then
         local Ind_Pre = Ind_Curr > 1 and (Ind_Curr - 1) or #tbLoop
         local pt_p, vn_p = EgtSurfTmFacetCenter( tbIdR[Ind_Pre][1], 0)
         pt_n, vn_n = EgtSurfTmFacetCenter( tbIdR[Ind_Nex][1], 0)
         -- calcolo l'angolo tra le due facce
         local dArcAng = EgtArcAngCenter( tbLoop[Ind_Curr])
         local dAngSkip = tbIdR[Ind_Pre][6] + tbIdR[Ind_Nex][6] + dArcAng
         if dAngSkip < 0 then
            vn_p = vn_p * (-1)
            vn_n = vn_n * (-1)
         end
         EgtCutSurfTmPlane( tbIdR[Ind_Pre][1], pt_n, vn_n, false)
         EgtCutSurfTmPlane( tbIdR[Ind_Nex][1], pt_p, vn_p, false)
      end

      --taglio i piani dei talloni con i piani dei talloni ( se non ho un altro tallone allora taglio con la sup di taglio)
      local pt_nH, vn_nH
      local pt_cH, vn_cH
      if tbIdR[Ind_Curr][5] > 0 then
         pt_cH, vn_cH = EgtSurfTmFacetCenter( tbIdR[Ind_Curr][9][1], 0)
         if ( tbIdR[Ind_Curr][6] < 0) then
            vn_cH = vn_cH * (-1)
         end
      end
      if tbIdR[Ind_Nex][5] > 0 then
         pt_nH, vn_nH = EgtSurfTmFacetCenter( tbIdR[Ind_Nex][9][1], 0)
         if ( tbIdR[Ind_Curr][6] < 0) then
            vn_nH = vn_nH * (-1)
         end
         if tbIdR[Ind_Curr][5] > 0 then
            EgtCutSurfTmPlane( tbIdR[Ind_Curr][9][1], tbIdR[Ind_Nex][9][2], vn_nH, false)
            EgtCutSurfTmPlane( tbIdR[Ind_Nex][9][1], tbIdR[Ind_Curr][9][2], vn_cH, false)
            -- se l'angolo con il prossimo lato è positivo, entrambi hanno un hill e gli Ang sono discordi, allora devo anche tagliare gli hill con i piani di taglio e viceversa
            --if tbIdR[Ind_Curr][6] > 0  and  tbIdR[Ind_Curr][4] * tbIdR[Ind_Nex][4] < 0 then  
            if tbIdR[Ind_Curr][6] > 0 then  -- ho tolto la condizione che gli angoli debbano essere discordi!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
               EgtCutSurfTmPlane( tbIdR[Ind_Nex][9][1], pt_c, vn_c, false)
               EgtCutSurfTmPlane( tbIdR[Ind_Curr][9][1], pt_n, vn_n, false)
               EgtCutSurfTmPlane( tbIdR[Ind_Curr][1], tbIdR[Ind_Nex][9][2], vn_nH, false)
               EgtCutSurfTmPlane( tbIdR[Ind_Nex][1], tbIdR[Ind_Curr][9][2], vn_cH, false)
            end
         else
            EgtCutSurfTmPlane( tbIdR[Ind_Nex][9][1], pt_c, vn_c, false)
            EgtCutSurfTmPlane( tbIdR[Ind_Curr][1], tbIdR[Ind_Nex][9][2], vn_nH, false)
         end
      else
         if tbIdR[Ind_Curr][5] > 0 then
            EgtCutSurfTmPlane( tbIdR[Ind_Curr][9][1], pt_n, vn_n, false)
            EgtCutSurfTmPlane( tbIdR[Ind_Nex][1], tbIdR[Ind_Curr][9][2], vn_cH, false)
         end
      end
   end
   

   -- unisco tutte le superfici laterali
   local tbIdTrim = {}
   for i=1, #tbIdR, 1 do
      if tbIdR[i][1] > -1 then
         table.insert( tbIdTrim, tbIdR[i][1])
         if tbIdR[i][5] > 0 then
            table.insert( tbIdTrim, tbIdR[i][9][1])
         end
      end
   end

   if #tbIdR > 0 then
      local nIdTrim = EgtSurfTmByTriangles( IdL_Solid, tbIdTrim, true)
      table.insert( tbId_SurfLat, nIdTrim)

      -- le trimmo con la superficie superiore e con quella inferiore
      local ptOrig_t
      local ptOrig_b
      if bAlwaysOnTop then
         ptOrig_t = tbIdR[1][2]
         ptOrig_b = ptOrig_t + Point3d({0,0,-RTh})
      else
         ptOrig_b = tbIdR[1][2]
         ptOrig_t = ptOrig_b + Point3d({0,0,RTh})
      end

      EgtCutSurfTmPlane( nIdTrim, ptOrig_b, {0,0,-1}, false, GDB_RT.GLOB)
      EgtCutSurfTmPlane( nIdTrim, ptOrig_t, {0,0,1}, false, GDB_RT.GLOB)

   end

end
--

local function CorrectReference()
   local sName = EgtGetName( IdFP)
   if sName ~= "SOLID" then
      local nLayRef = EgtGetFirstNameInGroup( IdFP, "Ref")
      local nRef = EgtGetFirstInGroup(nLayRef)
      while nRef do
         local var = EgtGetInfo(nRef, "Var")
         if var == "Th" then
            var = RTh
         else
            var = EgtGetInfo(nRef, "Var", "i")
         end
         local dir = EgtGetInfo(nRef, "Dir")
         if dir then
            local tbDir = EgtSplitString(dir,",")
            local vtDir = {}
            for _,sDir in pairs(tbDir) do
               sDir = sDir:gsub("x", EgtNumToString(var))
               table.insert(vtDir, EgtEvalNumExpr(sDir))
            end
            vtDir = Vector3d(vtDir)
            EgtMove(nRef,vtDir, GDB_RT.GLOB)
         end
         nRef = EgtGetNext(nRef)
      end
   end
end

local function GetThickness()
   local val = EgtGetInfo( IdFP,"Th","d")
   if val then
      SLD.THICK = val
   end
end

----------------------------------------------------------------------------
-- **Wire Frame** 
----------------------------------------------------------------------------
local function ExplodSurf( nId)
   local IdFac, Nbr = EgtExplodeSurf(nId)
   local i = 0
   while IdFac and Nbr > 1 and i < Nbr do
      ExplodSurf( IdFac)      
      IdFac = IdFac + 1
      i = i+1
   end
   return IdFac, Nbr
end
--

-- estraggo il contorno delle superfici del solido
local function ExtractBoundaryAndFaces()
   local nSurfCopy = EgtCopy( tbTrimTot[1], IdL_Temp)
   local IdFac, Nbr = ExplodSurf( nSurfCopy)

   local IdS = EgtGetFirstInGroup( IdL_Temp)
   local nCount = 0
   while IdS ~= nil do
      ------------------------ gestione archi
--      local tabMergSurf = {}
--      local _, dX, dY = EgtSurfTmFacetMinAreaRectangle( IdS, 0)
--      if dY~=nil and dY > TollY then
--         local TempIdSmall = EgtExtractSurfTmFacetLoops( IdS, 0, IdL_Bound)
--      else
--         table.insert( tabMergSurf, IdS)
--      end
--      EgtSurfTmByTriangles( IdL_Temp, tabMergSurf)
--      EgtErase( tabMergSurf)
--      IdS = EgtGetNext( IdS)

      ------------------------ gestione archi
      ----------- gestione archi che non vengono esplosi----------------
      nCount = nCount + 1
      local bExplode = false

      ----------- gestione archi che non vengono esplosi----------------
      ---
      local nLoop, nLoopCount = EgtExtractSurfTmFacetLoops( IdS, 0, IdL_Bound)
      local ColorApply = 'BLACK'
      local tbLoopFlatRegion = {}
      for l=nLoop, nLoop + (nLoopCount-1), 1 do
         -- coloro il loop e lo aggiungo alla tabella per ricreare la flat region
         EgtSetColor( l, ColorApply)
         table.insert(tbLoopFlatRegion, l)
      end
      -- ricreo la faccia laterale come flat region e la metto con trasparenza massima
      local nIdFace = EgtSurfFlatRegion( IdL_Faces, tbLoopFlatRegion)
      EgtSetAlpha(nIdFace,1)
      table.insert( tbId_Faces, nIdFace)
      for l=nLoop, nLoop + (nLoopCount-1), 1 do
         -- esplodo i loop
         EgtExplodeCurveCompo( l)
      end
      local nIdCurr = IdS
      IdS = EgtGetNext( IdS)
      -- cancello la superficie
      EgtErase( nIdCurr)
   end

   -- cancello le linee doppie sugli edge
   local IdL = EgtGetFirstInGroup(IdL_Bound)

   while IdL ~= nil do
      local ptStart = EgtSP( IdL)
      local ptEnd = EgtEP( IdL)
      IdL_b = EgtGetFirstInGroup(IdL_Bound)
      while IdL_b ~= nil do
         local ptStart_b = EgtSP( IdL_b)
         local ptEnd_b = EgtEP( IdL_b)
         if IdL_b ~= IdL and
         (AreSamePointApprox(ptStart, ptStart_b) and  AreSamePointApprox(ptEnd, ptEnd_b))  or
         (AreSamePointApprox(ptStart, ptEnd_b) and  AreSamePointApprox(ptEnd, ptStart_b)) then
            local IdL_bNext = IdL_b
            EgtErase( IdL_b)
            IdL_b = EgtGetNext( IdL_bNext)
         else
            IdL_b = EgtGetNext( IdL_b)
         end
      end
      IdL = EgtGetNext( IdL)
   end
end
--

----------------------------------------------------------------------------
-- |ESEGUO FUNZIONI|
----------------------------------------------------------------------------
-- funzione che si occupa di creare il solido finale
local function Draw(bPreview)
   CreatePartSOLID()
   -- SOLID
   IdL_OutLoop = GetIdFromLay( tbId_OutLoop, 'OutLoop')
   IdL_InLoop = GetIdFromLay( tbId_InLoop, 'InLoop')
   IdL_OnPath = GetIdFromLay( tbId_OnPath, 'OnPath')
   IdL_Pocket = GetIdFromLay( tbId_Pocket, 'Pocket')
   IdL_FiloTop = GetIdFromLay( tbId_FiloTop, 'FiloTop')

   -- SIDEANG
   SideAngSolid( tbId_OutLoop, false)
   for i = 1, #tbId_InLoop, 1 do
      SideAngSolid( tbId_InLoop[i], true)
   end

  CreateSolid()


   ---- POCKET
   PocketSolid()
   ---- FILO TOP
   FiloTopSolid()
   -- -- ONPATH
   OnPathSolid()
   -- WIREFRAME
   ---- Correzione dei riferimenti
   CorrectReference()


   ExtractBoundaryAndFaces()
end
-- 


 --per uso nell' |omagOFFICE|
 function SLD.Main()
   IdFP = SLD.CurrId
   ClearCurrIdSOLID()
   if IdFP == -1 then
      SLD.ERR = 1
      return
   end
   RTh = SLD.THICK
   if RTh == 0 then
      return
   end
   GetThickness()
   Draw( true)
   EgtSetStatus( IdFP, GDB_ST.OFF)
   EgtDraw()
   SLD.ERR = 0
 end

--per uso nell' |omagOFFICE|

--per uso nel |CAM5|  (bAutoRun da settare a true)
bAutoRun = true -- debug
if bAutoRun then
   ClearCurrIdSOLID()
   RTh = SLD.THICK
   IdFP = EgtGetFirstPart()
   local sName = ""
   --IdFP = 49389
   while IdFP ~= nil and sName ~= "SOLID" do
      -- procedo a costruire il solido solo se sono in un part con un OutLoop
      local nLay = EgtGetFirstNameInGroup(IdFP, "OutLoop")
      if nLay then
         GetThickness()
         Draw( true)
         EgtSetStatus( IdFP, GDB_ST.OFF)
      end
      IdFP = EgtGetNextPart(IdFP)
      sName = EgtGetName(IdFP)
      --break
   end
   --EgtSaveFile('c:\\EgtData\\OmagOFFICE\\Temp\\buche_sottili_SOLID.nge')
   EgtDraw()
   --SLD.ERR = 0
end
-----per uso nel |CAM5|

--_G.SLD_Main = SLD_Main