-- WProcessLapJoint.lua by Egaltech s.r.l. 2020/11/18
-- Gestione calcolo mezzo-legno per Pareti

-- Tabella per definizione modulo
local WPL = {}

-- Include
require( 'EgtBase')
local WL = require( 'WallLib')
local FreeContour = require( 'WProcessFreeContour')

EgtOutLog( ' WProcessLapJoint started', 1)

-- Dati
local WD = require( 'WallData')
local WM = require( 'WMachiningLib')

---------------------------------------------------------------------
-- Riconoscimento della feature
function WPL.Identify( Proc)
   return ( ( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 16) or
          ( ( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 17) or
          ( ( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 20) or
          ( ( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 30) or
          ( ( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 32) or
          ( ( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 34) or
          ( ( Proc.Grp == 4)  and  Proc.Prc == 39)
end

---------------------------------------------------------------------
-- Classificazione della feature
function WPL.Classify( Proc, b3Raw)
   -- se 1 faccia
   if Proc.Fct == 1 then
      -- dati della faccia
      local vtN = EgtSurfTmFacetNormVersor( Proc.Id, 0, GDB_ID.ROOT)
      -- verifico se è lavorabile da sopra
      return vtN:getZ() >= WD.NZ_MINA
   -- se 2 facce
   elseif Proc.Fct == 2 then
      -- dati delle facce
      local vtN = {}
      vtN[1] = EgtSurfTmFacetNormVersor( Proc.Id, 0, GDB_ID.ROOT)
      vtN[2] = EgtSurfTmFacetNormVersor( Proc.Id, 1, GDB_ID.ROOT)
      -- verifico se è lavorabile da sopra o di fianco
      return ( vtN[1]:getZ() >= - 0.01 or vtN[2]:getZ() >= - 0.01) 
   -- se più di 2 facce
   else
      local nFacInd, dElev, nFacInd2, dElev2 = WL.GetFaceWithMostAdj( Proc.Id, Proc.PartId)
      -- se trovata faccia di fondo
      if nFacInd >= 0 then
         -- determino componente Z della normale più diretta verso il basso
         local dMinNz = 1
         for i = 1, Proc.Fct do
            local vtN = EgtSurfTmFacetNormVersor( Proc.Id, i - 1, GDB_ID.ROOT)
            if vtN:getZ() < dMinNz then
               dMinNz = vtN:getZ()
            end
         end
         -- dati della faccia
         local vtN = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT)
         local _, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd, GDB_ID.ROOT)
         -- verifico se la faccia è lavorabile da sopra o di fianco
         if ( vtN:getZ() >= WD.NZ_MINA or ( dMinNz < -0.866 and Proc.Fct >= 3 and vtN:getZ() > - 0.01)) then
            Proc.Stype = 1
            return true
         -- altrimenti verifico la eventuale seconda faccia
         elseif nFacInd2 then
            -- dati della faccia
            local vtN2 = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd2, GDB_ID.ROOT)
            local _, dH2, dV2 = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd2, GDB_ID.ROOT)
            -- restituisco se faccia lavorabile
            Proc.Stype = 2
            return ( vtN2:getZ() >= WD.NZ_MINA or ( dMinNz < -0.866 and Proc.Fct >= 3 and vtN2:getZ() > - 0.01))
         -- se tre facce
         elseif Proc.Fct == 3 then
            -- verifico se U da sopra
            -- dati della faccia
            local nFac2 = EgtIf( nFacInd == 0, 1, 0)
            local vtN2 = EgtSurfTmFacetNormVersor( Proc.Id, nFac2, GDB_ID.ROOT)
            Proc.Stype = 3
            return ( abs( ( vtN ^ vtN2) * Z_AX()) >= WD.NZ_MINA)
         -- altrimenti non lavorabile
         else
            return false
         end
      -- se altrimenti tunnel
      elseif nFacInd == -1 then
         -- dati delle prime tre facce
         local vtN = {}
         vtN[1] = EgtSurfTmFacetNormVersor( Proc.Id, 0, GDB_ID.ROOT)
         vtN[2] = EgtSurfTmFacetNormVersor( Proc.Id, 1, GDB_ID.ROOT)
         vtN[3] = EgtSurfTmFacetNormVersor( Proc.Id, 2, GDB_ID.ROOT)
         -- verifico se è lavorabile da sopra
         local vtAxN = vtN[1] ^ vtN[2]
         if vtAxN:isSmall() then vtAxN = vtN[1] ^ vtN[3] end
         Proc.Stype = 4
         return ( abs( vtAxN:getZ()) >= WD.NZ_MINA)
      -- altrimenti non lavorabile
      else
         return false
      end
   end 
end

---------------------------------------------------------------------
local function MakeByChainSaw( Proc, nFacet, nRawId, b3Raw, dElev, dH, dV)
   local sWarn
   -- dati della faccia
   local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, nFacet, GDB_ID.ROOT)
   -- Recupero le facce adiacenti alla principale
   local vAdj = EgtSurfTmFacetAdjacencies( Proc.Id, nFacet)[1]
   if not vAdj or #vAdj == 0 then
      local sErr = 'Error : main face without adjacencies'
      EgtOutLog( sErr)
      return false, sErr
   end
   EgtOutLog( 'Adjac=' .. table.concat( vAdj, ','), 3)
   -- Cerco una faccia adiacente alla principale sul lato più lungo
   local nFacAdj
   local dMaxLen = 0
   for i = 1, #vAdj do
      if vAdj[i] >= 0 then
         local _, ptP1, ptP2, _ = EgtSurfTmFacetsContact( Proc.Id, nFacet, vAdj[i], GDB_ID.ROOT)
         local dLen = dist( ptP1, ptP2)
         local vtAdjN = EgtSurfTmFacetNormVersor( Proc.Id, vAdj[i], GDB_ID.ROOT)
         if dLen > dMaxLen - 1 and vtAdjN:getZ() > -0.1 then
            nFacAdj = vAdj[i]
            dMaxLen = dLen
            EgtOutLog( string.format( 'Adjac=%d Len=%.3f H=%.3f V=%.3f', vAdj[i], dLen, dH, dV), 3)
         end
      end
   end
   if not nFacAdj then
      local sErr = 'Error : long adjacent face not found'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- Recupero la lavorazione
   local sSawing = WM.FindSawing( 'Sawing')
   if not sSawing then
      local sErr = 'Error : chainsawing not found in library'
      EgtOutLog( sErr)
      return false, sErr, 'MNF'
   end
   -- Recupero i dati dell'utensile
   local dSawWidth = 75
   local dSawThick = 8
   local dMaxDepth = 200 
   if EgtMdbSetCurrMachining( sSawing) then
      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
         dSawWidth = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawWidth
         dSawThick = EgtTdbGetCurrToolParam( MCH_TP.THICK) or dSawThick
         dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
      end
   end
   if dSawThick > dV + 10 * GEO.EPS_SMALL then
      local sErr = 'Error : chainsaw too thick'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- Calcolo uso faccia
   local nFaceUse = WL.GetNearestParalOpposite( vtN)
   -- Calcolo angolo 3° asse rot (da direz. utensile)
   local d3RotAng = 180
   -- Lati chiusi
   local bOpenStart = false
   local bOpenEnd = false
   -- Verifico se necessarie più passate
   local nStep = ceil( ( dV - 10 * GEO.EPS_SMALL) / dSawThick)
   local dStep = 0
   if nStep > 1 then
      dStep = ( dV - dSawThick) / ( nStep - 1)
   end
   for i = 1, nStep do
      -- Applico la lavorazione con sega a catena a questa faccia
      local sName = 'Csaw_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( i)
      local nMchFId = EgtAddMachining( sName, sSawing)
      if not nMchFId then
         local sErr = 'Error adding machining ' .. sName .. '-' .. sSawing
         EgtOutLog( sErr)
         return false, sErr
      end
      -- aggiungo geometria
      EgtSetMachiningGeometry( {{ Proc.Id, nFacAdj}})
      -- imposto uso faccia
      EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
      -- imposto accorciamento iniziale/finale per estremi aperti/chiusi
      EgtSetMachiningParam( MCH_MP.STARTADDLEN, EgtIf( bOpenStart, 0, - dSawWidth / 2))
      EgtSetMachiningParam( MCH_MP.ENDADDLEN, EgtIf( bOpenEnd, 0, - dSawWidth / 2))
      -- imposto angolo 3° asse rot
      EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, 'A1=' .. EgtNumToString( d3RotAng))
      -- imposto offset radiale
      local dOffs = ( i - 1) * dStep
      EgtSetMachiningParam( MCH_MP.OFFSR, dOffs)
      -- se necessario, limito l'affondamento
      if dElev > dMaxDepth + 10 * GEO.EPS_SMALL then
         sWarn = 'Warning in LapJoint : elevation (' .. EgtNumToString( dElev, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')'
         dDepth = dMaxDepth - dElev
         EgtOutLog( sWarn)
         EgtSetMachiningParam( MCH_MP.DEPTH_STR, 'TH '..EgtNumToString( dDepth, 1))
      end
      -- imposto elevazione
      local sNotes = 'MaxElev=' .. EgtNumToString( dElev, 2) .. ';'
      EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
      -- eseguo
      if not EgtApplyMachining( true, false) then
         local _, sErr = EgtGetLastMachMgrError()
         EgtSetOperationMode( nMchFId, false)
         return false, sErr
      elseif EgtIsMachiningEmpty() then
         _, sWarn = EgtGetMachMgrWarning( 0)
         EgtSetOperationMode( nMchFId, false)
         return false, sWarn
      end
   end
   return true
end

---------------------------------------------------------------------
local function MakeByMill( Proc, nFacet, nOthFac, nRawId, b3Raw)
   -- dati della faccia e dell'altra
   local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, nFacet, GDB_ID.ROOT)
   local dElev = WL.GetFaceElevation( Proc.Id, nFacet, nRawId)
   local _, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacet, GDB_ID.ROOT)
   local dDiam = min( dH, dV)
   local _, vtRef = EgtSurfTmFacetCenter( Proc.Id, nOthFac, GDB_ID.ROOT)
   -- recupero la lavorazione
   local sMilling = WM.FindMilling( 'Side')
   if not sMilling then return false end
   -- recupero i dati dell'utensile
   local dMillDiam = 20
   local dMillLen = 10
   local dMillTotLen = 30
   local dMaxDepth = 0
   local dThDiam = 100
   if EgtMdbSetCurrMachining( sMilling) then
      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
         dMillDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dMillDiam
         dMillLen = EgtTdbGetCurrToolParam( MCH_TP.LEN) or dMillLen
         dMillTotLen = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) or dMillTotLen
         dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
         dThDiam = EgtTdbGetCurrToolThDiam() or dThDiam
      end
   end
   if dMillDiam < dDiam or dMaxDepth < dElev then
      local sErr = 'Error : Side Elevation too big'
      EgtOutLog( sErr)
      return false, sErr
   end
   local dMillExtra = dMillTotLen - dMillLen
   if Proc.Box:getMin():getZ() - dMillExtra < b3Raw:getMin():getZ() - 10 * GEO.EPS_SMALL then
      local sErr = 'Error : Tool collide with table'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- inserisco la lavorazione di contornatura
   local sName = 'Mill_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
   local nMchFId = EgtAddMachining( sName, sMilling)
   if not nMchFId then
      local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
      EgtOutLog( sErr)
      return false, sErr
   end
   -- aggiungo geometria
   EgtSetMachiningGeometry( {{ Proc.Id, nFacet}})
   -- imposto posizione braccio porta testa
   local nSCC = MCH_SCC.ADIR_ZP
   if AreSameVectorApprox( vtN, Z_AX()) then
      nSCC = EgtIf( Proc.Box:getDimX() >= Proc.Box:getDimY(), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_XP)
   end
   EgtSetMachiningParam( MCH_MP.SCC, nSCC)
   -- imposto modo di lavorare la faccia
   local nFaceUse = WL.GetNearestOrthoOpposite( vtRef, vtN)
   EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
   -- eseguo
   if not EgtApplyMachining( true, false) then
      local _, sErr = EgtGetLastMachMgrError()
      EgtRemoveOperation( nMchFId)
      return false, sErr
   end
   return true
end

---------------------------------------------------------------------
local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw)
   -- dati della faccia
   local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, nFacet, GDB_ID.ROOT)
   local dElev = WL.GetFaceElevation( Proc.Id, nFacet, nRawId)
   local _, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacet, GDB_ID.ROOT)
   local dThick = min( dH, dV)
   -- recupero la lavorazione
   local sMilling = WM.FindMilling( 'SideGroove')
   if not sMilling then
      local sErr = 'Error : SideGroove not found in library'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- recupero i dati dell'utensile
   local dMillDiam = 20
   local dMillLen = 10
   local dMillTotLen = 30
   local dMaxMat = 0
   if EgtMdbSetCurrMachining( sMilling) then
      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
         dMillDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dMillDiam
         dMillLen = EgtTdbGetCurrToolParam( MCH_TP.LEN) or dMillLen
         dMillTotLen = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) or dMillTotLen
         dMaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) or dMaxMat
      end
   end
   if dElev > dMillDiam / 2 - 30 then
      local sErr = 'Error : Side Elevation too big'
      EgtOutLog( sErr)
      return false, sErr
   end
   local dMillExtra = dMillTotLen - dMillLen
   if Proc.Box:getMin():getZ() - dMillExtra < b3Raw:getMin():getZ() - 10 * GEO.EPS_SMALL then
      local sErr = 'Error : Tool collide with table'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- inserisco la lavorazione di contornatura
   local sName = 'Mill_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
   local nMchFId = EgtAddMachining( sName, sMilling)
   if not nMchFId then
      local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
      EgtOutLog( sErr)
      return false, sErr
   end
   -- aggiungo geometria
   EgtSetMachiningGeometry( {{ Proc.Id, nFacet}})
   -- imposto posizione braccio porta testa
   local nSCC = MCH_SCC.ADIR_ZP
   if AreSameVectorApprox( vtN, Z_AX()) then
      nSCC = EgtIf( Proc.Box:getDimX() >= Proc.Box:getDimY(), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_XP)
   end
   EgtSetMachiningParam( MCH_MP.SCC, nSCC)
   -- imposto modo di lavorare la faccia
   local nFaceUse = WL.GetNearestParalOpposite( Z_AX(), vtN)
   EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
   -- imposto elevazione e step
   local dStep = EgtGetMachiningParam( MCH_MP.STEP)
   if dStep < GEO.EPS_SMALL then dStep = dMaxMat end
   local nStep = ceil( ( dThick - dMaxMat) / dStep)
   dStep = ( dThick - dMaxMat) / nStep
   local dMaxElev = ( nStep + 1) * dStep - GEO.EPS_SMALL
   EgtSetMachiningParam( MCH_MP.STEP, dStep)
   EgtSetMachiningParam( MCH_MP.USERNOTES, 'MaxElev=' .. EgtNumToString( dMaxElev, 3) .. ';')
   -- eseguo
   if not EgtApplyMachining( true, false) then
      local _, sErr = EgtGetLastMachMgrError()
      EgtRemoveOperation( nMchFId)
      return false, sErr
   end
   return true
end

---------------------------------------------------------------------
local function MakeByPocketing( Proc, nFacet, nRawId, b3Raw)
   -- dati della faccia
   local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, nFacet, GDB_ID.ROOT)
   local dElev = WL.GetFaceElevation( Proc.Id, nFacet, nRawId)
   local _, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacet, GDB_ID.ROOT)
   local dDiam = min( dH, dV)
   if Proc.Fct < 5 then dDiam = dDiam * 2 end
   -- recupero la lavorazione
   local sPocketing = WM.FindPocketing( 'Pocket', dDiam, dElev)
   if not sPocketing then
      sPocketing = WM.FindPocketing( 'Pocket', dDiam)
      if not sPocketing then
         local sErr = 'Error : pocketing not found in library'
         EgtOutLog( sErr)
         return false, sErr
      end
   end
   -- recupero i dati dell'utensile
   local dMillDiam = 20
   local dMaxDepth = 0
   local dThDiam = 100
   if EgtMdbSetCurrMachining( sPocketing) then
      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
         dMillDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dMillDiam
         dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
         dThDiam = EgtTdbGetCurrToolThDiam() or dThDiam
      end
   end
   -- inserisco la lavorazione di svuotatura
   local sName = 'Pock_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
   local nMchFId = EgtAddMachining( sName, sPocketing)
   if not nMchFId then
      local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing
      EgtOutLog( sErr)
      return false, sErr
   end
   -- aggiungo geometria
   EgtSetMachiningGeometry( {{ Proc.Id, nFacet}})
   -- imposto posizione braccio porta testa
   local nSCC = MCH_SCC.ADIR_ZP
   if AreSameVectorApprox( vtN, Z_AX()) then
      nSCC = EgtIf( Proc.Box:getDimX() >= Proc.Box:getDimY(), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_XP)
   end
   EgtSetMachiningParam( MCH_MP.SCC, nSCC)
   -- se elevazione superiore a massimo affondamento della fresa, riduco opportunamente
   local dThElev = dThDiam / 2 * sqrt( vtN:getX() * vtN:getX() + vtN:getY() * vtN:getY())
   local dDepth = 0
   if dElev + dThElev > dMaxDepth + 10 * GEO.EPS_SMALL then
      dDepth = dMaxDepth - dElev - dThElev
      local sWarn = 'Warning : elevation bigger than max tool depth'
      EgtOutLog( sWarn)
   end
   EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
   -- imposto elevazione
   EgtSetMachiningParam( MCH_MP.USERNOTES, 'MaxElev=' .. EgtNumToString( min( dElev, dMaxDepth), 1) .. ';')
   -- eseguo
   if not EgtApplyMachining( true, false) then
      local _, sErr = EgtGetLastMachMgrError()
      EgtSetOperationMode( nMchFId, false)
      return false, sErr
   end
   return true
end

---------------------------------------------------------------------
local function MakeOneFace( Proc, nRawId, b3Raw)
    -- dati della faccia
    local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
    -- dimensioni della faccia
    local _, dDimH, dDimV = WL.GetFaceHvRefDim( Proc.Id, 0)
   -- recupero la lavorazione di taglio con lama e i suoi parametri  
   local sCutting, dSawDiam, dSawThick, dSawMaxDepth = WM.FindCutting( 'Standard')
   -- se non inclinata o capacità di taglio non sufficiente, provo con svuotatura
   if not sCutting or vtN:getZ() > 0.95 or dSawMaxDepth < dDimV + WD.CUT_SIC then
      -- faccio con svuotatura
      local nFacet = 0
      return MakeByPocketing( Proc, nFacet, nRawId, b3Raw)
   end
   -- eseguo il taglio di lama
   local sName = 'Cut_' .. ( EgtGetName( Proc.PartId) or tostring( Proc.PartId)) .. '_' .. tostring( Proc.Id) 
   local nMchId = EgtAddMachining( sName, sCutting)
   if not nMchId then
      local sErr = 'Error adding machining ' .. sName .. '-' .. sCutting
      EgtOutLog( sErr)
      return false, sErr
   end
   -- aggiungo geometria
   EgtSetMachiningGeometry( { { Proc.Id, 0}})
   -- percorso da non invertire
   EgtSetMachiningParam( MCH_MP.INVERT, false)
   -- assegno affondamento
   EgtSetMachiningParam( MCH_MP.DEPTH, 0)
   -- assegno il lato di lavoro
   EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
   -- assegno l'attacco e l'uscita
   EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_SAW_LI.CENT)
   EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_SAW_LO.CENT)
   -- nessun criterio per il braccio è necessario
   EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.NONE)
   -- eseguo
   if not EgtApplyMachining( true, false) then
      local _, sErr = EgtGetLastMachMgrError()
      EgtSetOperationMode( nMchId, false)
      return false, sErr
   end
   return true
end

---------------------------------------------------------------------
local function MakeTwoFaces( Proc, nRawId, b3Raw)
   -- dati delle facce
   local ptC = {}
   local vtN = {}
   ptC[1], vtN[1] = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
   ptC[2], vtN[2] = EgtSurfTmFacetCenter( Proc.Id, 1, GDB_ID.ROOT)
   -- determino l'intersezione tra le due facce
   local bAdj, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, 0, 1, GDB_ID.ROOT)
   if not bAdj then
      return false, 'Feature with two faces not adjacentes'
   end
   -- versore della linea di intersezione
   local vtX = ptP2 - ptP1 ; vtX:normalize()
   -- larghezza delle facce ortogonalmente all'intersezione
   local dDimY = {}
   for i = 1, 2 do
      local vtY = vtN[i] ^ vtX ; vtY:normalize()
      local frRef = Frame3d( ptC[i], ptC[i] + 100 * vtX, ptC[i] + 100 * vtY)
      local b3Ref = EgtSurfTmGetFacetBBoxRef( Proc.Id, i - 1, GDB_BB.STANDARD, frRef)
      dDimY[i] = b3Ref:getDimY()
   end
   -- recupero la lavorazione di taglio con lama e i suoi parametri  
   local sCutting, dSawDiam, dSawThick, dSawMaxDepth = WM.FindCutting( 'Standard')
   -- se di fianco in basso
   if vtN[1]:getZ() < -0.95 or vtN[2]:getZ() < -0.95 then
      -- cerco la faccia orizzontale
      local nFacet = EgtIf( abs( vtN[1]:getZ()) < 0.1, 0, 1)
      -- se vicino al bordo del grezzo e non troppo larga, provo con fresatura di fianco
      local ptMid = ( ptP1 + ptP2) / 2
      if abs( ptMid:getX() - b3Raw:getMin():getX()) < 300 or abs( ptMid:getX() - b3Raw:getMax():getX()) < 300 or
         abs( ptMid:getY() - b3Raw:getMin():getY()) < 300 or abs( ptMid:getY() - b3Raw:getMax():getY()) < 300 then
         return MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw)
      end
   -- se altrimenti di fianco in alto
   elseif vtN[1]:getZ() > 0.95 or vtN[2]:getZ() > 0.95 then
      -- cerco la faccia con il maggior numero di adiacenze (e minor elevazione)
      local nFacInd, _, nFacInd2 = WL.GetFaceWithMostAdj( Proc.Id, Proc.PartId)
      local vtN = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT)
      local nFacet = EgtIf( vtN:getZ() >= WD.NZ_MINA, nFacInd, nFacInd2)
      -- se vicino al bordo del grezzo e non troppo larga, provo con fresatura di fianco
      local ptMid = ( ptP1 + ptP2) / 2
      if abs( ptMid:getX() - b3Raw:getMin():getX()) < 300 or abs( ptMid:getX() - b3Raw:getMax():getX()) < 300 or
         abs( ptMid:getY() - b3Raw:getMin():getY()) < 300 or abs( ptMid:getY() - b3Raw:getMax():getY()) < 300 then
         if MakeByMill( Proc, nFacet, 1 - nFacet, nRawId, b3Raw) then
            return true
         end
      end
      -- se non inclinate o capacità di taglio non sufficiente, provo con contornatura o svuotatura
      if not sCutting or dSawMaxDepth < dDimY[1] + WD.CUT_SIC or dSawMaxDepth < dDimY[2] + WD.CUT_SIC then
         -- eseguo la svuotatura
         return MakeByPocketing( Proc, nFacet, nRawId, b3Raw)
      end
   end
   -- ordino i tagli per fare prima quello meno inclinato
   local nOrd = { 0, 1}
   if vtN[2]:getZ() > vtN[1]:getZ() then
      nOrd = { 1, 0}
   end
   -- eseguo i tagli di lama
   for i = 1, 2 do
      -- inserisco la lavorazione
      local sName = 'Cut_' .. ( EgtGetName( Proc.PartId) or tostring( Proc.PartId)) .. '_' .. tostring( Proc.Id) .. '_' .. tostring( i) 
      local nMchId = EgtAddMachining( sName, sCutting)
      if not nMchId then
         local sErr = 'Error adding machining ' .. sName .. '-' .. sCutting
         EgtOutLog( sErr)
         return false, sErr
      end
      -- aggiungo geometria
      EgtSetMachiningGeometry( { { Proc.Id, nOrd[i]}})
      -- percorso da non invertire
      EgtSetMachiningParam( MCH_MP.INVERT, false)
      -- assegno affondamento
      EgtSetMachiningParam( MCH_MP.DEPTH, 0)
      -- assegno il lato di lavoro
      EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
      -- assegno l'attacco e l'uscita
      EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_SAW_LI.CENT)
      EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_SAW_LO.CENT)
      -- nessun criterio per il braccio è necessario
      EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.NONE)
      -- eseguo
      if not EgtApplyMachining( true, false) then
         local _, sErr = EgtGetLastMachMgrError()
         EgtSetOperationMode( nMchId, false)
         return false, sErr
      end
   end
   return true
end

---------------------------------------------------------------------
local function MakeMoreFaces( Proc, nRawId, b3Raw)
   -- con una faccia di fondo valida
   if Proc.Stype == 1 or Proc.Stype == 2 then
      -- cerco la faccia con il maggior numero di adiacenze
      local nFacInd, dElev, nFacInd2, dElev2 = WL.GetFaceWithMostAdj( Proc.Id, Proc.PartId)
      -- se necessario scambio le facce
      if Proc.Stype == 2 then
         nFacInd, dElev, nFacInd2, dElev2 = nFacInd2, dElev2, nFacInd, dElev
      end
      local vtN = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT)
      local _, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd, GDB_ID.ROOT)
      -- se di fianco
      if Proc.Fct >= 3 and vtN:getZ() < WD.NZ_MINA then
         -- fresatura
         if dElev < 200 then
            return MakeSideGrooveByMill( Proc, nFacInd, nRawId, b3Raw)
         -- altrimenti sega a catena
         else
            return MakeByChainSaw( Proc, nFacInd, nRawId, b3Raw, dElev, dH, dV)
         end
      end
      local nFacet = EgtIf( vtN:getZ() >= WD.NZ_MINA, nFacInd, nFacInd2)
      -- eseguo la svuotatura
      return MakeByPocketing( Proc, nFacet, nRawId, b3Raw)
   -- fessura verticale
   elseif Proc.Stype == 3 then
      -- riordino le facce come contorno libero da lavorare a destra (sono una U)
      -- porto la faccia centrale in seconda posizione (indice 1)
      local nFacInd = WL.GetFaceWithMostAdj( Proc.Id, Proc.PartId)
      if nFacInd ~= 1 then
         EgtSurfTmSwapFacets( Proc.Id, 1, nFacInd)
      end
      -- verifico se la prima (indice 0) la deve precedere o seguire
      local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
      local bAdj, ptAdj, _, _ = EgtSurfTmFacetsContact( Proc.Id, 0, 1, GDB_ID.ROOT)
      if bAdj and ( vtN ^ ( ptAdj - ptC)) * Z_AX() < 0 then
         EgtSurfTmSwapFacets( Proc.Id, 0, 2)
      end
      -- applico lavorazione di contorno libero
      return FreeContour.Make( Proc, nRawId, b3Raw)
   -- tunnel
   elseif Proc.Stype == 4 then
      -- riordino le facce come contorno libero da lavorare a destra (formano un anello chiuso e quindi posso partire da una qualunque)
      for i = 1, Proc.Fct - 2 do
         local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, i - 1, GDB_ID.ROOT)
         for j = i + 1, Proc.Fct do
            local bAdj, ptAdj, _, _ = EgtSurfTmFacetsContact( Proc.Id, i - 1, j - 1, GDB_ID.ROOT)
            if bAdj and ( vtN ^ ( ptAdj - ptC)) * Z_AX() > 0 then
               if i ~= j - 1 then
                  EgtSurfTmSwapFacets( Proc.Id, i, j - 1)
               end
               break
            end
         end
      end
      -- applico lavorazione di contorno libero
      return FreeContour.Make( Proc, nRawId, b3Raw)
   end
end

---------------------------------------------------------------------
-- Applicazione della lavorazione
function WPL.Make( Proc, nRawId, b3Raw)
   if Proc.Fct == 1 then
      return MakeOneFace( Proc, nRawId, b3Raw)
   elseif Proc.Fct == 2 then
      return MakeTwoFaces( Proc, nRawId, b3Raw)
   else
      return MakeMoreFaces( Proc, nRawId, b3Raw)
   end
end

---------------------------------------------------------------------
return WPL