-- 2024/11/22
-- Template per la creazione di un cabinet

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

-------------------------------------------------------------------------------------------------------------------------
-- FUNZIONI BASE PER GENERARE I COMPO SOLID               INIZIO
-------------------------------------------------------------------------------------------------------------------------

local TOOL = {}

_G.TOOL = TOOL

TOOL.nId = GDB_ID.NULL
TOOL.nLay = GDB_ID.NULL
TOOL.nEdgeId = GDB_ID.NULL
TOOL.tbInfo = {}
TOOL.nPrev = -1
TOOL.nNext = -1
TOOL.nJunctionType = -1
TOOL.bOnLoop = nil
TOOL.dAngBR = nil
TOOL.dSideAngR = nil
TOOL.dAngBL = nil
TOOL.dSideAngL = nil
TOOL.dLen = nil
TOOL.dH = nil
TOOL.dXOffset = nil
TOOL.dBeta1 = nil
TOOL.dBeta2 = nil

function TOOL.SaveMePlease()
   EgtSaveFile('D:\\Temp\\marmo\\Vein3D\\FOO.nge')
end

local function FindEdges(nLay)
   local tbId = {}
   local nId = EgtGetFirstInGroup(nLay)
   while nId do
      table.insert(tbId, nId)
      nId = EgtGetNext(nId)
   end
   return tbId
end

local function FillInfoTable()
   TOOL.tbInfo.nPrev = TOOL.nPrev
   TOOL.tbInfo.nNext = TOOL.nNext
   TOOL.tbInfo.nJunctionType = TOOL.nJunctionType
   TOOL.tbInfo.bOnLoop = TOOL.bOnLoop
   TOOL.tbInfo.dAngBR = TOOL.dAngBR
   TOOL.tbInfo.dSideAngR = TOOL.dSideAngR
   TOOL.tbInfo.dAngBL = TOOL.dAngBL
   TOOL.tbInfo.dSideAngL = TOOL.dSideAngL
   TOOL.tbInfo.dLen = TOOL.dLen
   TOOL.tbInfo.dH = TOOL.dH
   TOOL.tbInfo.dBeta1 = TOOL.dBeta1
   TOOL.tbInfo.dBeta2 = TOOL.dBeta2
end

function TOOL.WriteDataToChildPart(nParent, nPart, nEdge, dLen, dAngDx, dAngSx, dH, dTh, dBeta1, dBeta2)
   if not nPart then do return end end
   if nParent then EgtSetInfo(nParent,"A"..tostring(nEdge), nPart) end
   if nParent then EgtSetInfo(nPart, 'Parent', nParent) end
   if nEdge then EgtSetInfo(nPart, 'ParentEdge', nEdge) end
   if dLen then EgtSetInfo(nPart, 'Len', dLen) end
   if dAngDx then EgtSetInfo(nPart, 'dAngDx', dAngDx) end
   if dAgnSx then EgtSetInfo(nPart, 'dAngSx', dAngSx) end
   if dH then EgtSetInfo(nPart, 'dH', dH) end
   if dTh then EgtSetInfo(nPart, 'dTh', dTh) end
   if dBeta1 then EgtSetInfo(nPart, 'dBeta1', dBeta1) end
   if dBeta2 then EgtSetInfo(nPart, 'dBeta2', dBeta2) end
end

-- CREAZIONE dei Layer di un singolo Part
-- I nomi dei layer sono: OutLoop, Region, Ref, Labels, Aux
function TOOL.CreatePartLayer(PartName, sUNICode)
   -- Pezzo e Layer
   local Pz = EgtGroup(GDB_ID.ROOT,GDB_RT.LOC)    -- pezzo
   EgtSetName( Pz, sUNICode..PartName)
   local LOut = EgtGroup(Pz,GDB_RT.LOC)             -- layer della figura principale
   EgtSetName(LOut,'OutLoop')    
   local LReg = EgtGroup(Pz,GDB_RT.LOC)             -- layer regione
   EgtSetName(LReg,'Region')
   local LRef = EgtGroup(Pz,GDB_RT.LOC)             -- layer riferimenti
   EgtSetName(LRef,'Ref')
   EgtSetStatus( LRef, GDB_ST.OFF)
   local LLabel= EgtGroup(Pz,GDB_RT.LOC)             -- layer etichette
   EgtSetName(LLabel,'Labels')
   local LAux= EgtGroup(Pz,GDB_RT.LOC)             -- layer etichette
   EgtSetName(LAux,'Aux')
   EgtOutLog(' Creo Part: '..sUNICode..PartName)
   --SaveMePlease()
   return Pz
end
--

-- RESTITUISCE una tabella con gli Id dei layer costruiti nella funzione CreatePartLayer part,
-- Se il nome del Part non esiste restituice nil
function TOOL.FindLayers( IdPart)
   if not EgtIsPart( IdPart) then
      CMP.ERR = 1
      CMP.MSG = CMP.MSG.." In FindLayers 'IdPart' non è un Part"
      return nil 
   end
   local tbLayer = {}
   tbLayer['OutLoop'] = EgtGetFirstNameInGroup(IdPart, 'OutLoop')
   tbLayer['Region'] = EgtGetFirstNameInGroup(IdPart, 'Region')
   tbLayer['Ref'] = EgtGetFirstNameInGroup(IdPart, 'Ref')
   tbLayer['Labels'] = EgtGetFirstNameInGroup(IdPart, 'Labels')
   tbLayer['Aux'] = EgtGetFirstNameInGroup(IdPart, 'Aux')
   local nInLoopLay = EgtGetFirstNameInGroup(IdPart, 'InLoop')
   if nInLoopLay then
      tbLayer['InLoop'] = nInLoopLay
   end
   return tbLayer
end
-- 

-- ASSEGNO Info per conoscere le direzioni dei lati
function TOOL.SetMachiningInfo(Layer)
   local LayerName = EgtGetName( Layer)
   -- verifico che sia di tipo In o Out, altrimenti ricerco nel Part il layer
   if not LayerName == 'OutLoop' or not LayerName == 'InLoop' then 
      Layer = EgtGetFirstInGroup( Layer)
      CMP.ERR = 2
      CMP.MSG = CMP.MSG.." In SetMachiningInfo il Layer non è di tipo 'OutLoop' o 'InLoop'."
   end
   local nId = EgtGetFirstInGroup(Layer)
   local nPrevId = EgtGetLastInGroup(Layer)
   local nNextId = EgtGetNext(nId)
   local nFirstId = nId
   local nEdges = EgtGetGroupObjs(Layer)
   if nEdges == 1 then 
      EgtSetInfo(nId, 'PrevAng', 0)
      EgtSetInfo(nId, 'NextAng', 0)
      return
   end
   for i = 1, nEdges do
      -- recupero i dati
      local vtCurrS = EgtSV(nId, GDB_RT.GLOB)
      local vtPrevE = EgtEV(nPrevId, GDB_RT.GLOB)
	   local vtCurrE = EgtEV(nId, GDB_RT.GLOB)
      local vtNextS = EgtSV(nNextId, GDB_RT.GLOB)
	   local vtAx = Z_AX()
	   --if bInLoop then vtAx=-vtAx end
      local NextAng = GetRotation( vtCurrE, vtNextS, vtAx)
      local PrevAng = GetRotation( vtPrevE, vtCurrS, vtAx)
      -- scrivo le info
      EgtSetInfo(nId, 'PrevAng', PrevAng)
      EgtSetInfo(nId, 'NextAng', NextAng)
      -- aggiorno gli id
      nPrevId = nId
      nId = nNextId
      nNextId = EgtGetNext(nNextId)
      if nNextId == nil then
         nNextId = nFirstId
      end
   end
end
--

-- DEVO RICEVERE SOLO UN CONTORNO!! Da semplificare
-- Dato un contorno ricavo i lati nel Layer di appartenenza del contorno
-- altrimenti se Part ricavo i lati nel loop specificato (Default=OutLoop o InLoop)
function TOOL.ExplodeAndNameEdges( IdLoop, bInLoop)
   local sNameLayer = ''
   if bInLoop == nil then bInLoop = false end
   if bInLoop then
      sNameLayer = 'InLoop'
   else
      sNameLayer = 'OutLoop'
   end
   if not IdLoop or IdLoop == -1 then  end 
   -- Se l'Id è un Part
   if EgtIsPart( IdLoop) then 
      local tbLayer = TOOL.FindLayers( IdLoop)
      if tbLayer then IdLoop = EgtGetFirstInGroup( tbLayer[sNameLayer]) end
   end
   -- Se l'Id è un Layer
   if EgtIsLayer( IdLoop) then
      local LayerName = EgtGetName( IdLoop)
      -- verifico che sia di tipo In o Out, altrimenti ricerco nel Part il layer
      if LayerName == sNameLayer then 
         IdLoop = EgtGetFirstInGroup( IdLoop)
      else
         local tbLayer = TOOL.FindLayers( EgtGetParent(IdLoop))
         if tbLayer then IdLoop = EgtGetFirstInGroup( tbLayer[sNameLayer]) end
      end
   end
   local nLay = EgtGetParent(IdLoop)
   local nEdge, nTotEdges = EgtExplodeCurveCompo(IdLoop)
   local nCount = 1
   local tbIdLoop = {}
   while nEdge do
      local tbName = EgtNumToString(nCount)
      EgtSetName( nEdge, "A"..tbName)
      nCount = nCount + 1
	  table.insert( tbIdLoop, nEdge)
      nEdge = EgtGetNext(nEdge)
   end
   -- Ricavo info direzioni 
   TOOL.SetMachiningInfo(nLay)
   return tbIdLoop
end
--

-- CREAZIONE LAyer per le dimensioni
function TOOL.CreateDimensionLayer()
   local Pz = EgtGroup(GDB_ID.ROOT,GDB_RT.LOC)    -- layer dimensioni e etichette
   EgtSetName( Pz, 'Dimensions')
end
--

-- Per disporre i pezzi in piano non sovrappposti (in assemblaggio non serve)
local HorizontalOffset = 0

-- Creazione del part assegnato un contorno esploso:
--   tbLayer   : tabella dei layer (FindLayers dato il Part)
--   sName     : nome da assegnare in grafica
--   tbIdEntCrv: tabella delle entità che costituiscono il contorno (da ExplodeAndNameEdges)
--   dTh       : spessore pezzo
--   dOffset   : per messa in piano dei pezzi (0 se non si usa)
--   bInLoop   : tipo di contorno
function TOOL.CreatePart(tbLayer, sName, tbIdEntCrv, dTh, bInLoop)
   -- recupero il layer del contorno
   local IdCurrLayer = EgtGetParent( tbIdEntCrv[1])
   -- recupero l'Id del part
   local IdPart = EgtGetParent( IdCurrLayer)
   -- costruisco il contorno chiuso
   local IdLoop = EgtCurveCompoByChain( IdCurrLayer, tbIdEntCrv, EgtSP(tbIdEntCrv[1],GDB_RT.GLOB), false, GDB_RT.GLOB)
   -- Nel Layer Region definisco la regione piana
   local IdReg = EgtSurfFlatRegion(tbLayer['Region'],IdLoop)
   -- Se InLoop allora faccio la sottrazione con la regione OutRegion
   --local bInvertCurve = false
   if bInLoop then
      local IdOutRegion = EgtGetPrev(IdReg)
      local vtNorm1 = EgtSurfFrNormVersor(IdOutRegion)
      local vtNorm2 = EgtSurfFrNormVersor(IdReg)
      if AreOppositeVectorApprox( vtNorm1, vtNorm2) then
         EgtInvertSurf(IdReg)
         --bInvertCurve = true
      end
      if not EgtSurfFrSubtract( IdOutRegion,IdReg) then
	     CMP.ERR = 5
	     CMP.MSG = CMP.MSG.." Sottrazione tra superficie 'OutLoop' "..tostring(IdOutRegion).." e 'InLoop' "..tostring(IdReg).." non riuscita."
	  end
	  EgtErase(IdReg)
   end
   -- if bInLoop then EgtInvertCurve(IdLoop) end
   -- elimino il contorno chiuso
   EgtErase(IdLoop)
   
   -- Se sono InLoop non devo settare
   if bInLoop then
      --if bInvertCurve then
         -- for i = 1, #tbIdEntCrv do
         --    EgtInvertCurve(tbIdEntCrv[i])
         -- end
      --end
      return
   end

   -- definisco spessore pezzo
   if dTh then EgtSetInfo(IdPart, 'Th', dTh) end
   -- INFO NECESSARIA
   EgtSetInfo(IdPart, 'Paired',tostring(IdPart))
   
   -- inserisco le etichette del pezzo nel centro della superofocie
   local ptTop = EgtCP( IdReg, GDB_RT.GLOB)
   local ptBottom = Point3d( ptTop:getX(), -ptTop:getY(), dTh)
   EgtTextAdv(tbLayer['Labels'], ptTop,0,sName, '', 10, '', 15,1.5,0,GDB_TI.MC)
   if CMP.DrawSolid then
      EgtSetGridFrame(Frame3d(ORIG(),GDB_FR.BOTTOM))
      EgtTextAdv(tbLayer['Labels'], ptBottom,0,sName, '', 10, '', 15,1.5,0,GDB_TI.MC, GDB_RT.GRID)
      EgtSetGridFrame(Frame3d(ORIG(),GDB_FR.TOP))
   end
   -- dispongo il pezzo in piano
   local vtMove = Vector3d({HorizontalOffset,0,0})
   --EgtMove(IdPart,vtMove, GDB_RT.GLOB)
   HorizontalOffset = HorizontalOffset + ptTop:getX() + 10
end
--

-- Sposto l'etichetta del nome del Part nel Solido associato
function TOOL.RelocateLabels()
   local nPartId = EgtGetFirstPart()
   while nPartId do
      local nChild = EgtGetInfo(nPartId, 'Child','i')
      if nChild then
         local nLaySource = EgtGetFirstNameInGroup(nPartId, 'Labels')
         if nLaySource then EgtRelocateGlob( nLaySource, nChild) end
      end
      nPartId = EgtGetNext(nPartId)
   end
end
--

-- Crea una copia dello spigolo e lo salva nel layer Ref 
-- Nome del part (da tbName[1]), 
-- Nome del Layer (OutLoop o InLoop), 
-- Nome dello spigolo, 
-- Nome della copia riferimento
-- Info per spostamento Ref in funzione di una variabile
function TOOL.CreateReference( sUNICode, sNamePart, sNameLayer,sNameEdge, sNameRef, dVar, sDir)
   local IdPart = EgtGetFirstNameInGroup(GDB_ID.ROOT, sUNICode..sNamePart)
   local tbLayer = TOOL.FindLayers( IdPart)
   --accoppiamento di left su bottom
   local IdEnt = EgtGetFirstNameInGroup(tbLayer[sNameLayer], sNameEdge)
   if not IdEnt then 
      CMP.ERR=6
	  CMP.MSG= CMP.MSG..' Non esiste il lato '..sNameEdge..' nel layer '..sNameLayer..' del part '..sNamePart
      return 
   end
   -- creo la copia dello spigolo come riferimento 
   local IdRef = EgtCopy( IdEnt, tbLayer['Ref'])
   EgtSetName( IdRef, sNameRef)
   if dVar and sDir then
      EgtSetInfo(IdRef, 'Var', dVar)
      EgtSetInfo(IdRef, 'Dir', sDir)
   end
   return IdRef
end
--

-- Crea una copia dello del punto dello spigolo e lo salva nel layer Ref
-- Nome del part (da tbName[1]), 
-- Nome del Layer (OutLoop o InLoop), 
-- Nome dello spigolo, 
-- Nome della copia punto
-- Tipo di punto: 0/nil START, 1 END, 2 MID
function TOOL.CreatePointReference( sNamePart, sNameLayer,sNameEdge, sNameRef, nTypePt)
   local IdPart = EgtGetFirstNameInGroup(GDB_ID.ROOT, sUNICode..sNamePart)
   local tbLayer = TOOL.FindLayers( IdPart)
   --accoppiamento di left su bottom
   local IdEnt = EgtGetFirstNameInGroup(tbLayer[sNameLayer], sNameEdge)
   if not IdEnt then 
      CMP.ERR=6
	  CMP.MSG= CMP.MSG..' Non esiste il lato '..sNameEdge..' nel layer '..sNameLayer..' del part '..sNamePart
      return
   end
   local pt = EgtSP(IdEnt, GDB_RT.GLOB)
   if nTypePt == 1 then
      pt = EgtEP(IdEnt, GDB_RT.GLOB)
   elseif nTypePt == 2 then
      pt = EgtMP(IdEnt, GDB_RT.GLOB)
   end
   local IdPtRef = EgtPoint( tbLayer['Ref'], pt, GDB_RT.GLOB)
   EgtSetName(IdPtRef, sNameRef)
   return IdPtRef
end
--

-- Accoppia lato a riferimento
-- Nome del pezzo da accoppiare
-- Nome del riferimento da usare
-- Nome del pezzo destinatario dell'accoppiamento
-- Nome del riferimento da usare come destinatario dell'accoppiamento
-- Concordanza del verso dei due spigoli
-- Angolo relativo tra i due pezzi: porta la normale della regione del pezzo corrente a coincidere
-- con la normale della regione del pezzo destinatario; il segno è riferito al verso del riferimento del part destinatario
-- Modalità di accoppiamento tra gli spigoli (0: start-start, 1:start-end, 2: end-start, 3: end-end, 4: mid-mid)
function TOOL.SetPairInfo( sUNICode, sMyNamePart, sNameMyRef, sToNamePart, sNameToRef, nPairSpin, dPairAng, nPairMode)
   local nPart = EgtGetFirstNameInGroup(GDB_ID.ROOT, sUNICode..sMyNamePart)
   EgtSetInfo(nPart, "PairMyRef", sNameMyRef)
   EgtSetInfo(nPart, "PairToRef", sUNICode..sToNamePart.."_"..sNameToRef)
   EgtSetInfo(nPart, "PairSpin", nPairSpin)
   EgtSetInfo(nPart, "PairAng", dPairAng)
   if nPairMode then EgtSetInfo(nPart, "PairMode", nPairMode) end
end

-- Disegna la quota lineare
-- Nome del part in cui trovare il primo punto di riferimento
-- Nome del punto riferimento nel part indicato sopra
-- Nome del part in cui trovare il secondo punto di riferimento
-- Nome del punto riferimento nel part indicato sopra
-- Nome/valore stringa da scrivere nella dimensione
-- Frame del piano su cui disegnare la quotatura
-- Offset etichetta rispetto al punto medio 
local function DrawLinearDimension( sNamePart1, sNameRef1, sNamePart2, sNameRef2, sNameDimension, GridFrame, ptOffset)
   EgtSetGridFrame(GridFrame)
   local nDimLay = EgtGetFirstNameInGroup(GDB_ID.ROOT, 'Dimensions')
   local nBottomLay = EgtGetFirstNameInGroup(GDB_ID.ROOT, sUNICode..sNamePart1)
   local nRefBottom = EgtGetFirstNameInGroup(nBottomLay, 'Ref')
   local nRef = EgtGetFirstNameInGroup(nRefBottom, sNameRef1)
   local pt1 = EgtSP( nRef, GDB_RT.GRID)
   local nTopLay = EgtGetFirstNameInGroup(GDB_ID.ROOT, sUNICode..sNamePart2)
   local nRefTop = EgtGetFirstNameInGroup(nTopLay, 'Ref')
   nRef = EgtGetFirstNameInGroup(nRefTop, sNameRef2)
   local pt2 = EgtSP( nRef, GDB_RT.GRID)
   local ptMid = (pt1 + pt2) / 2 + ptOffset
   local nDim = EgtAlignedDimension( nDimLay, pt1, pt2, ptMid, sNameDimension, GDB_RT.GRID)
   EgtSetColor( nDim, EgtStdColor( 'YELLOW'))
   EgtRelocate(nDim, GDB_RT.GRID)
   EgtSetName(nDim, sNameDimension)
end
--
-------------------------------------------------------------------------------------------------------------------------
-- FUNZIONI BASE PER GENERARE I COMPO SOLID               FINE
-------------------------------------------------------------------------------------------------------------------------

-- -------------------------------------------------------------------------------------------------------------------------
-- -- CREAZIONE/IMPORTAZIONE Loop                INIZIO
-- -------------------------------------------------------------------------------------------------------------------------
-- -- Importa un contorno chiuso da file nge
-- function ImportOutLoop( tbLayer, sNameFileNGE)
--    local OutLayer = tbLayer['OutLoop']
--    if not EgtInsertFile(  sNameFileNGE) then
--       EgtOutLog(' IMPORTAZIONE FALLITA: '..sNameFileNGE)
--    end
--    -- recupero ultimo Part
--    local LastPart = EgtGetLastPart()
--    local FstLayerInLstPart = EgtGetFirstGroupInGroup( LastPart)
--    local IdLoop = EgtGetFirstInGroup( FstLayerInLstPart)
--    if not EgtRelocateGlob( IdLoop, OutLayer) then
--       EgtOutLog(' RELOCATE AFLLITA MISERAMENTE: '..tostring(IdLoop)..';'..tostring(OutLayer))
--    end
--    EgtErase(LastPart)
--    local tbIdLoop = ExplodeAndNameEdges( IdLoop)

--    EgtSetInfo(tbIdLoop[1],'AF',1)
--    EgtSetInfo(tbIdLoop[2],'AF',2)
--    EgtSetInfo(tbIdLoop[3],'AF',2)
--    EgtSetInfo(tbIdLoop[4],'AF',2)
--    EgtSetInfo(tbIdLoop[5],'AF',2)
--    EgtSetInfo(tbIdLoop[6],'AF',2)
--    EgtSetInfo(tbIdLoop[7],'AF',1)
--    --SaveMePlease()
--    -- definizione SideAng
--    -- EgtSetInfo( tbIdLoop[1], 'OrigSideAng', 45)
--    return tbIdLoop
-- end
-- --

function TOOL.AddLoopToLayer(nLay, tbIdLoop, dOffset, bInvert, bInLoop)
   -- local tbLoop = {}
   -- for i = 1, #tbIdLoop do
   --    local nNewId = EgtCopyGlob(tbIdLoop[i], nLay)
   --    if bInvert then EgtInvertCurve(nNewId) end
   --    table.insert(tbLoop, nNewId)
   -- end
   -- TOOL.SetMachiningInfo(nLay, bInLoop)
   --return tbLoop
   local nNewLoop = EgtCurveCompoByChain(nLay, tbIdLoop, EgtSP(tbIdLoop[1], GDB_RT.GLOB), false)
   if bInvert then EgtInvertCurve(nNewLoop) end
   if dOffset > 0 then EgtOffsetCurve(nNewLoop, dOffset, GDB_OT.EXTEND) end
   local tbNewLoop = TOOL.ExplodeAndNameEdges( nNewLoop, bInLoop)
   return tbNewLoop
end

-- -------------------------------------------------------------------------------------------------------------------------
-- -- CREAZIONE/IMPORTAZIONE Loop                FINE
-- -------------------------------------------------------------------------------------------------------------------------

-- -- Restituisce l'angolo precedente e successivo dell'aentità passata
local function GetPrevNextAng(IdEnt)
   local PrevAng = EgtGetInfo(IdEnt,'PrevAng','d') or 0
   local NextAng = EgtGetInfo(IdEnt,'NextAng','d') or 0
   return PrevAng, NextAng
end

-- Confronto i dati del file.dat con quelli letti da programma
function IsDataChanged()
   local bOk = false
   if not tbOrigVal.v1 then return true end
   if math.abs(CMP.V1 - tbOrigVal.v1) > 0.5 then bOk = bOk or true end
   if math.abs(CMP.V2 - tbOrigVal.v2) > 0.5 then bOk = bOk or true end
   if math.abs(CMP.V3 - tbOrigVal.v3) > 0.5 then bOk = bOk or true end
   if math.abs(CMP.V4 - tbOrigVal.v4) > 0.5 then bOk = bOk or true end
   if math.abs(CMP.V5 - tbOrigVal.v5) > 0.5 then bOk = bOk or true end
   if math.abs(CMP.V6 - tbOrigVal.v6) > 0.5 then bOk = bOk or true end
   if math.abs(CMP.V7 - tbOrigVal.v7) > 0.5 then bOk = bOk or true end
   if math.abs(CMP.V8 - tbOrigVal.v8) > 0.5 then bOk = bOk or true end
   return bOk
end

function CalcDraftAngle( vtDir1, vtDir2, dPairAng1, dPairAng2, dAngBetween)
   -- vengono restituiti il SideAng ( calcolato dall'angolo in 3d), i due nuovi angoli di forma per i due pezzi
   -- dBeta1 è riferito al pezzo 1 e dBeta2 è riferito al pezzo 2
   local dAngTilt1 = 180 - dPairAng1
   local dAngTilt2 = 180 - dPairAng2
   local vtN1 = Vector3d({0,0,100})
   local vtN2 = Vector3d({0,0,100})
   vtN1:rotate(vtDir1, dAngTilt1)
   vtN2:rotate(vtDir2, dAngTilt2)
   --vtN2:rotate(Z_AX(), dAngBetween)
   local vtPerp = vtN1 ^ vtN2
   local vtInters1 = vtN1 ^ vtPerp
   local vtInters2 = vtPerp ^ vtN2
   --local dAng3d = GetRotation(vtInters1, vtInters2, vtPerp)
   local dAng3d = GetAngle(vtInters1, vtInters2)
   local dBeta1 = GetAngle( vtDir1, vtPerp)
   if (dPairAng2 > 90 and dBeta1 > 90) or (dPairAng2 < 90 and dBeta1 < 90) then dBeta1 = 180 - dBeta1 end
   local dBeta2 = GetAngle( vtDir2, vtPerp)
   if (dPairAng1 > 90 and dBeta2 > 90) or (dPairAng1 < 90 and dBeta2 < 90) then dBeta2 = 180 - dBeta2 end
   local dSideAng = 0
   dSideAng = (180 - dAng3d) / 2

   --debug
   EgtOutLog(tostring(dSideAng)..'   '.. tostring(dBeta1).. '   '..tostring(dBeta2))
   --debug

   return dSideAng, dBeta1, dBeta2
end

function TJunction(dAngBetween, dTh1, dTh2, nType, dLen1, dLen2, bOnLoop)
   -- restituisce le lunghezze L1 e L2 adattate in base al tipo di giunzione
   -- nType == 1 -> TrimStart ( del Part2)
   -- nType == 2 -> TrimEnd ( del Part1)
   local dXOffset = 0
   if not bOnLoop then bOnLoop = false end
   if dAngBetween > 0 then
      if nType == 1 then
         -- trim start
         local dDeltaStart = - dTh1 / sin(dAngBetween)
         dLen2 = dLen2 + dDeltaStart
         dXOffset = dDeltaStart
         -- extend end
         dLen1 = dLen1 + dTh1 * tan(90- math.abs(dAngBetween))
      elseif nType == 2 then
         -- trim end
         dLen1 = dLen1 - dTh2 / sin(dAngBetween)
         -- extend start
         local dDeltaStart = dTh2 * tan(90- math.abs(dAngBetween))
         dLen2 = dLen2 + dDeltaStart
         dXOffset = dDeltaStart
      end
   else
      -- qui sto estendendo le lunghezze, infatti gli angoli sono nergativi e quindi anche il loro seno
      if nType == 1 then
         -- il trim start diventa un extend end
         local dDelta = - dTh2 / sin(dAngBetween)
         if not bOnLoop then dDelta = dDelta - dTh1 * tan(90 - math.abs(dAngBetween)) end
         dLen1 = dLen1 + dDelta
         -- accorcio lo start
         local dDeltaStart = - dTh2 * tan(90- math.abs(dAngBetween))
         dLen2 = dLen2 + dDeltaStart
         dXOffset = dDeltaStart
      elseif nType == 2 then
         -- il trim end diventa un extend start
         local dDeltaStart = - dTh1 / sin(dAngBetween)
         if not bOnLoop then dDeltaStart = dDeltaStart - dTh2 * tan(90 - math.abs(dAngBetween)) end
         dLen2 = dLen2 + dDeltaStart
         dXOffset = math.abs(dDeltaStart)
         -- accorcio l'end
         dLen1 = dLen1 - dTh1 * tan(90- math.abs(dAngBetween))
      end
   end
   return dLen1, dLen2, dXOffset
end

function AngleJunction(dAngBetween, dTh1, dTh2, dLen1, dLen2, bOnLoop)
   -- modifico la lughezza dei lati solo se ho un angolo convesso
   local dXOffest = 0
   if not bOnLoop then
      local dDelta1 = dTh2 / sin( dAngBetween)
      local dDelta2 = dTh1 / sin( dAngBetween)
      if dAngBetween > 0 then
         dLen1 = dLen1 - dDelta1
         dLen2 = dLen2 - dDelta2
      else
         dLen1 = dLen1 + dDelta1
         dLen2 = dLen2 + dDelta2
      end
   end
   return dLen1, dLen2, dXOffest
end

function ManageJunction(dAngBetween, dTh1, dTh2, nType, dLen1, dLen2, bOnLoop)
   --nJunctionType -- 1 TrimStart, 2 TrimEnd, 3Ang
   if nType == 1 or nType == 2 then
      return TJunction(dAngBetween, dTh1, dTh2, nType, dLen1, dLen2, bOnLoop)
   elseif nType == 3 then
      return AngleJunction(dAngBetween, dTh1, dTh2, dLen1, dLen2, bOnLoop)
   end
end

function TOOL.CreateAdjustedPart( nLayOutloop, dLen, dH, dBeta1, dBeta2)
   -- genero la regione piana del rettangolo deformato :
   -- dLen è la lunghezza del lato su cui si va ad agganciare il pezzo che sto creando, quindi è un dato fisso
   -- bisogna calcolare gli altri tre lati del quadrilatero
   --            dProj1                          dProj2 
   --            __|__ _______________________ __|__
   --            \                                 /        |
   --             \   beta1                beta2  /         |dH
   --              \ /___________dLen__________\ /          |
   --  beta 1 e beta 2 sono gli angoli alla base
   -- dLen1 e dLen2 sono le proiezioni delle diagonali sulla base maggiore
   -- beta 1 e beta 2 possono essere < 90 e quindi potrei avere anche un trapezio ribaltato, oppure un quasi parallelogramma
   
   -- recupero eventuali input mancanti dalla tabella generale
   if not dLen then dLen = TOOL.dLen end
   if not dH then dH = TOOL.dH end
   if not dBeta1 then dBeta1 = TOOL.dBeta1 end
   if not dBeta2 then dBeta2 = TOOL.dBeta2 end
   
   -- creo i lati del pezzo
   if dBeta1 == nil then dBeta1 = 90 end
   if dBeta2 == nil then dBeta2 = 90 end
   local dProj1 = dH * tan( dBeta1 - 90)
   local dProj2 = dH * tan( dBeta2 - 90)

   local pt1 = ORIG()
   local pt2 = Point3d(dLen,0,0)
   local nLine1 = EgtLine( nLayOutloop, pt1, pt2)
   EgtSetName(nLine1, "A1")
   local pt3 = Point3d(dLen + dProj2,dH,0)
   local nLine2 = EgtLine( nLayOutloop, pt2, pt3)
   EgtSetName(nLine2, "A2")
   local pt4 = Point3d( -dProj1,dH,0)
   local nLine3 = EgtLine( nLayOutloop, pt3, pt4)
   EgtSetName(nLine3, "A3")
   local nLine4 = EgtLine( nLayOutloop, pt4, pt1)
   EgtSetName(nLine4, "A4")
   TOOL.SetMachiningInfo(nLayOutloop)
   return {nLine1, nLine2, nLine3, nLine4}
end

function TOOL.SetSideAng(nLay, sEdgeName, dAng)
   local nEdge = EgtGetFirstNameInGroup( nLay, sEdgeName)
   EgtSetInfo( nEdge, 'SideAng', dAng)
   EgtSetInfo( nEdge, 'OrigSideAng', dAng)
end

-- ptCenter sono le coordinate del centro del foro rispetto all'angolo in basso a sinistra
function TOOL.CreateCircularHole(nPart, ptCenter, dDiam)
   local nInLoopLay = EgtGroup(nPart)
   EgtSetName(nInLoopLay, 'InLoop')
   local HoleId = EgtCircle( nInLoopLay, ptCenter, dDiam, GDB_RT.GLOB)
   TOOL.SetMachiningInfo(nInLoopLay)
   TOOL.CreatePart(TOOL.FindLayers(nPart),nil,{HoleId},nil,true)
end


--function TOOL.CreateParetina(i, tbIdLoopTC, tbInfo, dPairAngCorr)
function TOOL.CreateParetina(nEdgeId, tbInfo, dPairAngCorr)
   -- se non ho ricevuto input li recupero dalla tabella generale
   if not nEdgeId then nEdgeId = TOOL.nEdgeId end
   if not tbInfo then
      FillInfoTable()
      tbInfo = TOOL.tbInfo
   end

   local nLay = EgtGetParent(nEdgeId)
   local tbIdLoopTC = FindEdges(nLay) -- tabella che contiene gli id degli Edge del loop
   -- local nId = EgtGetFirstInGroup(nLay)
   local i = tbInfo.nEdge -- posizione del lato nel layer del loop

   if dPairAngCorr == nil then dPairAngCorr = 0 end
   local nPrev = i > 1 and i - 1 or #tbIdLoopTC
   local nNext = i < #tbIdLoopTC and i + 1 or 1
   local dPairAngPrev = (EgtGetInfo(tbInfo.nPrev, 'PairAng', 'd') or 0) + dPairAngCorr
   local dPairAngNext = (EgtGetInfo(tbInfo.nNext, 'PairAng', 'd') or 0) + dPairAngCorr
   local dPairAng = (EgtGetInfo(tbInfo.nId, 'PairAng', 'd') or 0) + dPairAngCorr
   local vtDirCurr = EgtSV( tbIdLoopTC[i], GDB_RT.GLOB)
   local vtDirNext = EgtSV( tbIdLoopTC[nNext], GDB_RT.GLOB)
   local vtDirPrev = EgtEV( tbIdLoopTC[nPrev], GDB_RT.GLOB)
   local dLen = EgtCurveLength(tbIdLoopTC[i])
   local dLenPrev = EgtCurveLength(tbIdLoopTC[#tbIdLoopTC])
   local dLenNext = EgtCurveLength(tbIdLoopTC[nNext])
   local PrevAng, NextAng = GetPrevNextAng(tbIdLoopTC[i])
   local dTh = EgtGetInfo(tbInfo.nId, 'dTh','d')

   -- calcolo l'angolo di sformo con il pezzo precedente
   local dXOffset = 0
   -- se i due pezzi hanno angoli di accoppiamento discordi allora uno sta sotto e uno sta sopra
   local bSameSide = dPairAng * dPairAngPrev > 0
   if bSameSide then
      if tbInfo.nJunctionType == 3 then
         local dSideAng_4, _, dBeta_DX = CalcDraftAngle( vtDirPrev, vtDirCurr,  dPairAngPrev, dPairAng, PrevAng)
         --tbInfo.dAngBR = 180 - dBeta_DX
         tbInfo.dAngBR = dBeta_DX
         if tbInfo.bOnLoop then dSideAng_4 = dSideAng_4 * (-1) end
         if PrevAng < 0 then dSideAng_4 = dSideAng_4 * (-1) end
         tbInfo.dSideAngR = dSideAng_4
         if not tbInfo.bOnLoop then
            dLenPrev, dLen, dXOffset = ManageJunction(PrevAng,dTh, dTh,tbInfo.nJunctionType, dLenPrev, dLen)
         end
      else
         -- se ho una giunzione a T allora devo aggiustare la lunghezza dei pezzi sia che la faccia sia On, sia che sia Off
         dLenPrev, dLen, dXOffset = ManageJunction(PrevAng,dTh, dTh,tbInfo.nJunctionType, dLenPrev, dLen)
         -- setto il sideang da giunzione a T
         -- setto il sideang da giunzione a T
         local dSideAng_4 = 90 - math.abs(PrevAng)
         if tbInfo.bOnLoop then dSideAng_4 = dSideAng_4 * (-1) end
         tbInfo.dSideAngR = dSideAng_4
      end
   else
      -- setto il sideAng da giunzione a T (che va bene anche se la giunzione è angolata ma senza pezzo precedente)
      local dSideAng = PrevAng < 0 and (90 + PrevAng) or 90-PrevAng
      if tbInfo.bOnLoop then dSideAng = dSideAng * (-1) end
      tbInfo.dSideAngR = dSideAng
      -- visto che il pezzo precedente non è dallo stesso lato allora corrego l'estensione del pezzo corrente (in funzione del suo spessore)
      if not tbInfo.bOnLoop then
         local dOffset = dTh * tan( 90 - PrevAng)
         dLen = dLen + dOffset
         if tbInfo.nJunctionType == 1 then dXOffset = dXOffset + dOffset end
      end
   end
   -- -- calcolo l'angolo di sformo con il pezzo successivo
   bSameSide = dPairAng * dPairAngNext > 0
   if bSameSide then
      if tbInfo.nJunctionType == 3 then
         local dSideAng_2, dBeta_SX, __ = CalcDraftAngle( vtDirCurr, vtDirNext, dPairAng, dPairAngNext, NextAng)
--         tbInfo.dAngBL = 180 - dBeta_SX
         tbInfo.dAngBL = dBeta_SX
         if tbInfo.bOnLoop then dSideAng_2 = dSideAng_2 * (-1) end
         if NextAng < 0 then dSideAng_2 = dSideAng_2 * (-1) end
         tbInfo.dSideAngL = dSideAng_2
         if not tbInfo.bOnLoop then
            dLen, dLenNext = ManageJunction(NextAng, dTh, dTh, tbInfo.nJunctionType, dLen, dLenNext)
         end
      else
         -- se ho una giunzione a T allora devo aggiustare la lunghezza dei pezzi sia che la faccia sia On, sia che sia Off
         dLen, dLenNext = ManageJunction(NextAng, dTh, dTh, tbInfo.nJunctionType, dLen, dLenNext)
         -- setto il sideang da giunzione a T
         local dSideAng_2 = 90 - math.abs(NextAng)
         if tbInfo.bOnLoop then dSideAng_2 = dSideAng_2 * (-1) end
         tbInfo.dSideAngL = dSideAng_2
      end
   else
      -- setto il sideAng da giunzione a T (che va bene anche se la giunzione è angolata ma senza pezzo successivo)
      local dSideAng = NextAng < 0 and (90 + NextAng) or 90-NextAng
      if tbInfo.bOnLoop then dSideAng = dSideAng * (-1) end
      tbInfo.dSideAngL = dSideAng
      -- visto che il pezzo successivo non è dallo stesso lato allora correggo l'estensione del pezzo corrente (in funzione del suo spessore)
      if not tbInfo.bOnLoop then
         local dOffset = dTh * tan( 90 - NextAng)
         dLen = dLen + dOffset
         if tbInfo.nJunctionType == 2 then dXOffset = dXOffset + dOffset end
      end
   end
   tbInfo.dLen = dLen
   tbInfo.dXOffset = dXOffset
end

function TOOL.CreateParetinaFull()
   -- devo modificare anche la paretina precedente e la successiva

   TOOL.CreateParetina()
end

return TOOL