//----------------------------------------------------------------------------
//  EgalTech 2020-2020
//----------------------------------------------------------------------------
// File : ImportBtlx.cpp       Data : 14.12.20         Versione : 2.3a6
// Contenuto : Implementazione della classe per l'importazione BTLx.
// 
// 
// 
// Modifiche : 14.12.20 DS Creazione modulo.
// 
// 
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "pugixml.hpp"
#include "ImportBtlx.h"
#include "DllMain.h"
#include "/EgtDev/Include/EExDllMain.h"
#include "/EgtDev/Include/EgtKeyCodes.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EgtNumUtils.h"

using namespace std ;

// -----------------------------------------------------------------------------------------------------------------------------
// -------------------------------- FUNZIONI CHE LEGGONO I PARAMETRI DEI PROCESSI  -------------------------------------------
// -----------------------------------------------------------------------------------------------------------------------------
int 
ImportBtlx::ComputeP04( STRVECTOR values)
{
   if ( values.size() > 6  ||  values.empty()) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: P04 is not valid") ; 
      return -2 ;    
   }

   int result = 0 ;
   for ( size_t i = 0 ; i < values.size() ; i ++) {
      if ( values[i] == "no")
         result += static_cast<int>( pow( 2, i)) ;
      else if ( values[i] != "yes") {
         LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: MachiningLimit value is not valid") ; 
         return -2 ; 
      }
   }

   return result ;
}

//  -----------------------------------------------------------------------------------------------------------------------------
int 
ImportBtlx::ComputeP04( pugi::xml_node MachiningLimits)
{
   string FaceLimitedStart = "yes" ; 
   if ( MachiningLimits.attribute( "FaceLimitedStart") != nullptr) 
      FaceLimitedStart = MachiningLimits.attribute( "FaceLimitedStart").value() ;

   string FaceLimitedEnd = "yes" ; 
   if ( MachiningLimits.attribute( "FaceLimitedEnd") != nullptr) 
      FaceLimitedEnd = MachiningLimits.attribute( "FaceLimitedEnd").value() ;

   string FaceLimitedFront = "yes" ; 
   if ( MachiningLimits.attribute( "FaceLimitedFront") != nullptr) 
      FaceLimitedFront = MachiningLimits.attribute( "FaceLimitedFront").value() ;

   string FaceLimitedBack = "yes" ; 
   if ( MachiningLimits.attribute( "FaceLimitedBack") != nullptr) 
      FaceLimitedBack = MachiningLimits.attribute( "FaceLimitedBack").value() ;

   string FaceLimitedBottom = "yes" ; 
   if ( MachiningLimits.attribute( "FaceLimitedBottom") != nullptr) 
      FaceLimitedBottom = MachiningLimits.attribute( "FaceLimitedBottom").value() ;

   string FaceLimitedTop = "no" ; 
   if ( MachiningLimits.attribute( "FaceLimitedTop") != nullptr) 
      FaceLimitedTop = MachiningLimits.attribute( "FaceLimitedTop").value() ;

   int result = 0 ;
   if ( FaceLimitedStart == "no")
      result += 1 ;
   else if ( FaceLimitedStart != "yes") {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: MachiningLimit is not valid") ;
      return -2 ;     
   }

   if ( FaceLimitedEnd == "no")
      result += 2 ;
   else if ( FaceLimitedEnd != "yes") {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: MachiningLimit is not valid") ; 
      return -2 ;     
   }

   if ( FaceLimitedFront == "no")
      result += 4 ;
   else if ( FaceLimitedFront != "yes") {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: MachiningLimit is not valid") ;
      return -2 ;     
   }

   if ( FaceLimitedBack == "no")
      result += 8 ;
   else if ( FaceLimitedBack != "yes") {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: MachiningLimit is not valid") ;
      return -2 ;     
   }

   if ( FaceLimitedBottom == "no")
      result += 16 ;
   else if ( FaceLimitedBottom != "yes"){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: MachiningLimit is not valid") ;
      return -2 ;     
   }

   if ( FaceLimitedTop == "no")
      result += 32 ;
   else if ( FaceLimitedTop != "yes"){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: MachiningLimit is not valid") ;
      return -2 ;     
   }

   return result ;
}

//-------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadJackRafterCutParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                     INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{  
  // Identifico il processo con sigle usate nel btl
   nProc = 10 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;

   if ( process.child( "Orientation") == nullptr ){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: JackRafterCut orientation missing") ;
      return false ;
   }
   string sOrientation = process.child( "Orientation").text().get() ;
   if ( sOrientation == "start")
      nGroup = 2 ;
   else if ( sOrientation == "end")
      nGroup = 1 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: JackRafterCut Orientation is not valid") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 5) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: JackRafterCut number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")              // P02 
      vdPar[1] = Clamp( std::stod( process.child( "StartY").text().get()), 0.0, 50000.0) ;
   if ( process.child( "StartDepth") != nullptr && process.child( "StartDepth").text().get() != "")      // P03
      vdPar[2] = Clamp( std::stod( process.child( "StartDepth").text().get()), 0.0, 50000.0) ;
   if ( process.child( "Angle") != nullptr && process.child( "Angle").text().get() != "")                // P06
      vdPar[3] = std::stod( process.child( "Angle").text().get()) ;
   if ( process.child( "Inclination") != nullptr && process.child( "Inclination").text().get() != "")    // P07
      vdPar[4] = std::stod( process.child( "Inclination").text().get()) ;

   return true ;
}

//-------------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadLongitudinalCutParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                       INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 10 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   if (process.attribute( "ToolPosition") == nullptr) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: LongitudinalCut Tool position missing") ;
      return false ;
   }
   string sToolPosition = process.attribute( "ToolPosition").value() ;
   if ( sToolPosition == "center")
      nGroup = 0 ;
   else if ( sToolPosition == "right")
      nGroup = 3 ;
   else if ( sToolPosition == "left")
      nGroup = 4 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: LongitudinalCut Tool position not valid") ;
      return false ; 
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 8) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: LongitudinalCut number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                  // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                  // P02   
      vdPar[1] = Clamp( std::stod( process.child( "StartY").text().get()), 0.0, 50000.0) ;
   if ( process.child( "Inclination") != nullptr && process.child( "Inclination").text().get() != "")        // P07
      vdPar[3] = std::stod( process.child( "Inclination").text().get()) ;
   if ( process.child( "Depth") != nullptr && process.child( "Depth").text().get() != "")                    // P11
      vdPar[4] = Clamp( std::stod( process.child( "Depth").text().get()), 0.0, 50000.0) ;
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                  // P12
      vdPar[5] = Clamp( std::stod( process.child( "Length").text().get()), 0.0, 100000.0) ;
   if ( process.child( "AngleStart") != nullptr && process.child( "AngleStart").text().get() != "")          // P13
      vdPar[6] = Clamp( std::stod( process.child( "AngleStart").text().get()), 0.1, 179.9) ;
   if ( process.child( "AngleEnd") != nullptr && process.child( "AngleEnd").text().get() != "")              // P14
      vdPar[7] = Clamp( std::stod( process.child( "AngleEnd").text().get()), 0.1, 179.9) ;    

   string sStartLimited =  process.child( "StartLimited") == nullptr ? "no" : process.child( "StartLimited").text().get() ;   // P04
   string sEndLimited =  process.child( "EndLimited") == nullptr ? "no" : process.child( "EndLimited").text().get()  ;
   vdPar[2] = ComputeP04( { "no", sStartLimited, sEndLimited}) ;
   if ( vdPar[2] == -2)
      return false ;

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadDoubleCutParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                 INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 11 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;

   if ( process.child( "Orientation") == nullptr) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: DoubleCut orientation missing") ;
      return false ;
   }
   string sOrientation = process.child( "Orientation").text().get() ;
   if ( sOrientation == "end")
      nGroup = 1 ;
   else if ( sOrientation == "start")
      nGroup = 2 ;      
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: DoubleCut orientation unknown") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 6) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: DoubleCut number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                  // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                  // P02   
      vdPar[1] = Clamp( std::stod( process.child( "StartY").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "Angle1") != nullptr && process.child( "Angle1").text().get() != "")                  // P06
      vdPar[2] = std::stod( process.child( "Angle1").text().get()) ;
   if ( process.child( "Inclination1") != nullptr && process.child( "Inclination1").text().get() != "")      // P07
      vdPar[3] = std::stod( process.child( "Inclination1").text().get()) ;
   if ( process.child( "Angle2") != nullptr && process.child( "Angle2").text().get() != "")                  // P08
      vdPar[4] = std::stod( process.child( "Angle2").text().get()) ;
   if ( process.child( "Inclination2") != nullptr && process.child( "Inclination2").text().get() != "")      // P09
      vdPar[5] = std::stod( process.child( "Inclination2").text().get()) ;

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadRidgeValleyCutParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                      INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 12 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   nGroup = 0 ;

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 11) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: RidgeValleyCut number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                              // P02   
      vdPar[1] = Clamp( std::stod( process.child( "StartY").text().get()), 0.0, 50000.0) ;
   if ( process.child( "InclinationRefSide") != nullptr && process.child( "InclinationRefSide").text().get() != "")      // P07
      vdPar[3] = std::stod( process.child( "InclinationRefSide").text().get()) ;
   if ( process.child( "InclinationOppSide") != nullptr && process.child( "InclinationOppSide").text().get() != "")      // P09
      vdPar[4] = std::stod( process.child( "InclinationOppSide").text().get()) ;
   if ( process.child( "StartDepth") != nullptr && process.child( "StartDepth").text().get() != "")                      // P11
      vdPar[5] = Clamp( std::stod( process.child( "StartDepth").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                              // P12
      vdPar[6] = Clamp( std::stod( process.child( "Length").text().get()), 0.0, 100000.0) ;
   if ( process.child( "AngleRefStart") != nullptr && process.child( "AngleRefStart").text().get() != "")                // P13
      vdPar[7] = Clamp( std::stod( process.child( "AngleRefStart").text().get()), 0.1, 179.9) ;
   if ( process.child( "AngleRefEnd") != nullptr && process.child( "AngleRefEnd").text().get() != "")                    // P14
      vdPar[8] = Clamp( std::stod( process.child( "AngleRefEnd").text().get()), 0.1, 179.9) ;
   if ( process.child( "AngleOppStart") != nullptr && process.child( "AngleOppStart").text().get() != "")                // P15
      vdPar[9] = Clamp( std::stod( process.child( "AngleOppStart").text().get()), 0.1, 179.9) ;
   if ( process.child( "AngleOppEnd") != nullptr && process.child( "AngleOppEnd").text().get() != "")                    // P16
      vdPar[10] = Clamp( std::stod( process.child( "AngleOppEnd").text().get()), 0.1, 179.9) ;

   string sStartLimited =  process.child( "StartLimited") == nullptr ? "no" : process.child( "StartLimited").text().get() ;   // P04
   string sEndLimited =  process.child( "EndLimited") == nullptr ? "no" : process.child( "EndLimited").text().get() ;   
   vdPar[2] = ComputeP04( { "no", sStartLimited, sEndLimited}) ;
   if ( vdPar[2] == -2)
      return false ;

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadSawCutParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                              INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 13 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;

   if (process.attribute( "ToolPosition") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: SawCut toolposition missing") ;
      return false ;
   }

   string sToolPosition = process.attribute( "ToolPosition").value() ;
   if ( sToolPosition == "center")
      nGroup = 0 ;
   else if ( sToolPosition == "right")
      nGroup = 3 ;
   else if ( sToolPosition == "left")
      nGroup = 4 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: SawCut tool position unknown") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 8) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: SawCut number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                              // P02   
      vdPar[1] = Clamp( std::stod( process.child( "StartY").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "StartDepth") != nullptr && process.child( "StartDepth").text().get() != "")                      // P03
      vdPar[2] = Clamp( std::stod( process.child( "StartDepth").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "Angle") != nullptr && process.child( "Angle").text().get() != "")                                // P06
      vdPar[3] = Clamp( std::stod( process.child( "Angle").text().get()), 0.0, 180.0) ;
   if ( process.child( "Inclination") != nullptr && process.child( "Inclination").text().get() != "")                    // P07
      vdPar[4] = std::stod( process.child( "Inclination").text().get()) ;
   if ( process.child( "Bevel") != nullptr && process.child( "Bevel").text().get() != "")                                // P08
      vdPar[5] = std::stod( process.child( "Bevel").text().get()) ;
   if ( process.child( "Depth") != nullptr && process.child( "Depth").text().get() != "")                                // P11
      vdPar[6] = std::stod( process.child( "AngleRefStart").text().get()) ;
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                              // P12
      vdPar[7] = std::stod( process.child( "Length").text().get()) ;
   else 
      vdPar[7] = 0.0 ;

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadSlotParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                            INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 16 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   if ( process.child( "Orientation") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Slot orientation missing") ;
      return false ;
   }
   string sOrientation = process.child( "Orientation").text().get() ;
   if ( sOrientation == "end")
      nGroup = 3 ;
   else if ( sOrientation == "start")
      nGroup = 4 ;      
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Slot orientation unknown") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 14) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Slot number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                              // P02   
      vdPar[1] = Clamp( std::stod( process.child( "StartY").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "StartDepth") != nullptr && process.child( "StartDepth").text().get() != "")                      // P03
      vdPar[2] = Clamp( std::stod( process.child( "StartDepth").text().get()), 0.0, 50000.0) ;
   if ( process.child( "MachiningLimits") != nullptr ) {                                                                 // P04
      vdPar[3] = ComputeP04( process.child( "MachiningLimits")) ;
      if ( vdPar[3] == -2)
         return false ;
   }
   if ( process.child( "Angle") != nullptr && process.child( "Angle").text().get() != "")                                // P06
      vdPar[4] = std::stod( process.child( "Angle").text().get()) ;
   if ( process.child( "Inclination") != nullptr && process.child( "Inclination").text().get() != "")                    // P07
      vdPar[5] = std::stod( process.child( "Inclination").text().get()) ;
   if ( process.child( "AngleRefPoint") != nullptr && process.child( "AngleRefPoint").text().get() != "")                // P08
      vdPar[6] = std::stod( process.child( "AngleRefPoint").text().get()) ;
   if ( process.child( "AngleOppPoint") != nullptr && process.child( "AngleOppPoint").text().get() != "")                // P09
      vdPar[7] = std::stod( process.child( "AngleOppPoint").text().get()) ;
   if ( process.child( "AddAngleOppPoint") != nullptr && process.child( "AddAngleOppPoint").text().get() != "")          // P10
      vdPar[8] = Clamp( std::stod( process.child( "AddAngleOppPoint").text().get()), -179.9, 179.9) ;
   if ( process.child( "Depth") != nullptr && process.child( "Depth").text().get() != "")                                // P11
      vdPar[9] = std::stod( process.child( "Depth").text().get()) ;
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                              // P12
      vdPar[10] = std::stod( process.child( "Length").text().get()) ;
   if ( process.child( "Thickness") != nullptr && process.child( "Thickness").text().get() != "")                        // P13
      vdPar[11] = std::stod( process.child( "Thickness").text().get()) ;

   // P14 P15 non vengono usati 

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadBirdsMouthParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                  INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 20 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;

   if ( process.child( "Orientation") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BirdsMouth orientation missing") ;
      return false ;
   }
   string sOrientation = process.child( "Orientation").text().get() ;
   if ( sOrientation == "end")
      nGroup = 3 ;
   else if ( sOrientation == "start")
      nGroup = 4 ;      
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BirdsMouth orientation unknwon") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 13) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BirdsMouth number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                         // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;                    
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                         // P02   
      vdPar[1] = Clamp( std::stod( process.child( "StartY").text().get()), -50000.0, 50000.0) ;                      
   // P04 ?
   if ( process.child( "Angle") != nullptr && process.child( "Angle").text().get() != "")                           // P06
      vdPar[3] = std::stod( process.child( "Angle").text().get()) ;
   if ( process.child( "Inclination1") != nullptr && process.child( "Inclination1").text().get() != "")             // P07
      vdPar[4] = std::stod( process.child( "Inclination1").text().get()) ;
   if ( process.child( "Inclination2") != nullptr && process.child( "Inclination2").text().get() != "")             // P08
      vdPar[5] = std::stod( process.child( "Inclination2").text().get()) ;
   
   string sLeadAnglePar = process.child( "LeadAngleParallel").text().get() ;                                        // P09
   if ( sLeadAnglePar == "yes" || sLeadAnglePar == "")
      vdPar[6] = 0.0 ;
   else if ( sLeadAnglePar == "no"){
      if ( process.child( "LeadAngle") != nullptr && process.child( "LeadAngle").text().get() != "")                   
         vdPar[6] = std::stod( process.child( "LeadAngle").text().get()) ;  
      else 
         vdPar[6] = 90.0 ;
   }
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : LeadAngleParallel unknown") ;
      return false ;  
   }

   string sLeadInclPar = process.child( "LeadInclinationParallel").text().get() ;                                  // P10
   if ( sLeadInclPar == "yes" || sLeadInclPar == "")
      vdPar[7] = 0.0 ;
   else if ( sLeadInclPar == "no" ){
      if ( process.child( "LeadInclination") != nullptr && process.child( "LeadInclination").text().get() != "")       
         vdPar[7] = std::stod( process.child( "LeadInclination").text().get()) ;  
      else
         vdPar[7] = 90.0 ;
   }
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : LeadInclinationParallel unknown") ;
      return false ;  
   }

   if ( process.child( "StartDepth") != nullptr && process.child( "StartDepth").text().get() != "")                 // P11
      vdPar[8] = std::stod( process.child( "StartDepth").text().get()) ;
   if ( process.child( "Depth") != nullptr && process.child( "Depth").text().get() != "")                           // P12
      vdPar[9] = std::stod( process.child( "Depth").text().get()) ;
   if ( process.child( "Width") != nullptr && process.child( "Width").text().get() != "")                           // P13
      vdPar[10] = std::stod( process.child( "Width").text().get()) ;

   string sHCPLimited = process.child( "HeightCounterPartLimited").text().get() ;                                   // P14
   if ( sHCPLimited == "no" || sHCPLimited == "")
      vdPar[11] = 0.0 ;
   else if ( sHCPLimited == "yes"){
      if ( process.child( "HeightCounterPart") != nullptr && process.child( "HeightCounterPart").text().get() != "")   
         vdPar[11] = std::stod( process.child( "HeightCounterPart").text().get()) ;
   }
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : HeightCounterPartLimited unknown") ;
      return false ; 
   }

   string sWCPLimited = process.child( "WidthCounterPartLimited").text().get() ;                                   // P15
   if ( sWCPLimited == "no" || sWCPLimited == "")
      vdPar[12] = 0.0 ;
   else if ( sWCPLimited == "yes"){
      if ( process.child( "WidthCounterPart") != nullptr && process.child( "WidthCounterPart").text().get() != "")    
         vdPar[12] = std::stod( process.child( "WidthCounterPart").text().get()) ;
   }
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : WidthCounterPartLimited unknown") ;
      return false ; 
   }
   if ( process.child( "RafterNailHole") != nullptr && process.child( "RafterNailHole").text().get() != ""){        // P05
      string sRafterNailHole = process.child( "RafterNailHole").text().get() ;                                       
      if ( sRafterNailHole == "yes")
         vdPar[2] = 1 ;
      else if ( sRafterNailHole == "no")
         vdPar[2] = 0 ;
      else {
         LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : RafterNailHole invalid paramater") ;
         return false ;
      }
   }      

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadHipValleyRafterNotchParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                            INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 25 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;

   if ( process.child( "Orientation") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: HipValleyRafterNotch orientation missing") ;
      return false ;
   }
   string sOrientation = process.child( "Orientation").text().get() ;
   if ( sOrientation == "end")
      nGroup = 3 ;
   else if ( sOrientation == "start")
      nGroup = 4 ;      
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: HipValleyRafterNotch orientation unknwon") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 9) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: HipValleyRafterNotch number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = std::stod( process.child( "StartX").text().get()) ;
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                              // P02   
      vdPar[1] = std::stod( process.child( "StartY").text().get()) ;   
   if ( process.child( "AngleRefEdge") != nullptr && process.child( "AngleRefEdge").text().get() != "")                  // P06
      vdPar[3] = std::stod( process.child( "AngleRefEdge").text().get()) ;
   if ( process.child( "AngleOppEdge") != nullptr && process.child( "AngleOppEdge").text().get() != "")                  // P07
      vdPar[4] = std::stod( process.child( "AngleOppEdge").text().get()) ;
   if ( process.child( "Inclination") != nullptr && process.child( "Inclination").text().get() != "")                    // P08
      vdPar[5] = std::stod( process.child( "Inclination").text().get()) ;
   if ( process.child( "StartDepth") != nullptr && process.child( "StartDepth").text().get() != "")                      // P11
      vdPar[6] = std::stod( process.child( "StartDepth").text().get()) ;
   
   string sWCPRefEdgeLimited = process.child( "WidthCounterPartRefEdgeLimited").text().get() ;                           // P14
   if ( sWCPRefEdgeLimited == "no" || sWCPRefEdgeLimited == "")     
      vdPar[7] = 0.0 ;
   else if ( sWCPRefEdgeLimited == "yes"){  
      if ( process.child( "WidthCounterPartRefEdge") != nullptr && process.child( "WidthCounterPartRefEdge").text().get() != "")   
         vdPar[7] = std::stod( process.child( "WidthCounterPartRefEdge").text().get()) ;
   }
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : WidthCounterPartRefEdgeLimited unknown") ;
      return false ;  
   }

   string sWCPOppEdgeLimited = process.child( "WidthCounterPartOppEdgeLimited").text().get() ;                           // P15
   if ( sWCPOppEdgeLimited == "no" || sWCPOppEdgeLimited == "")     
      vdPar[8] = 0.0 ;
   else if ( sWCPOppEdgeLimited == "yes"){
      if ( process.child( "WidthCounterPartOppEdge") != nullptr && process.child( "WidthCounterPartOppEdge").text().get() != "")   
         vdPar[8] = std::stod( process.child( "WidthCounterPartOppEdge").text().get()) ;
   }
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : WidthCounterPartOppEdgeLimited unknown") ;
      return false ;
   }

   if ( vdPar[7] < EPS_SMALL && vdPar[8] < EPS_SMALL){
      LOG_ERROR( GetEExLogger(), "  Warning reading Part Processing : P14 = P15 = 0") ;
      vdPar[7] = 1000.0 ;
      vdPar[8] = 1000.0 ;
   }

   if ( process.child( "RafterNailHole") != nullptr && process.child( "RafterNailHole").text().get() != ""){             // P05
      string sRafterNailHole = process.child( "RafterNailHole").text().get() ;
      if ( sRafterNailHole == "yes")
         vdPar[2] = 1 ;
      else if ( sRafterNailHole == "no" || sRafterNailHole == "")
         vdPar[2] = 0 ;
      else {
         LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : RafterNailHole invalid paramater") ;
         return false ;
      }
   }      
   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadLapParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                           INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 30 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;

   if ( process.child( "Orientation") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: HipValleyRafterNotch orientation missing") ;
      return false ;
   }
   string sOrientation = process.child( "Orientation").text().get() ;
   if ( sOrientation == "end")
      nGroup = 3 ;
   else if ( sOrientation == "start")
      nGroup = 4 ;      
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: HipValleyRafterNotch orientation unknwon") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 13) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: HipValleyRafterNotch number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                     // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                     // P02   
      vdPar[1] = Clamp( std::stod( process.child( "StartY").text().get()), -50000.0, 50000.0) ;
   // vdPar[2] = ? Non c'è StartDepth
   if ( process.child( "MachiningLimits") != nullptr ) {                                                        // P04
      vdPar[3] = ComputeP04( process.child( "MachiningLimits")) ;
      if ( vdPar[3] == -2)
         return false ;
   }
   if ( process.child( "Angle") != nullptr && process.child( "Angle").text().get() != "")                       // P06
      vdPar[4] = std::stod( process.child( "Angle").text().get()) ;
   if ( process.child( "Inclination") != nullptr && process.child( "Inclination").text().get() != "")           // P07
      vdPar[5] = std::stod( process.child( "Inclination").text().get()) ;
   if ( process.child( "Slope") != nullptr && process.child( "Slope").text().get() != "")                       // P08
      vdPar[6] = std::stod( process.child( "Slope").text().get()) ;

   string sLeadAngPar = process.child( "LeadAngleParallel").text().get() ;                                     // P09
   if ( sLeadAngPar == "yes" || sLeadAngPar == "")
      vdPar[7] = 0.0 ;
   else if ( sLeadAngPar == "no" ){
      if ( process.child( "LeadAngle") != nullptr && process.child( "LeadAngle").text().get() != "")              
         vdPar[7] = Clamp( std::stod( process.child( "LeadAngle").text().get()), 0.1, 179.9) ;
      else
         vdPar[7] = 90.0 ;
   }
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: LeadAngle unknown") ;
      return false ;
   }

   string sLeadInclPar = process.child( "LeadInclinationParallel").text().get() ;                               // P10
   if ( sLeadInclPar == "yes" || sLeadInclPar == "")
      vdPar[8] = 0.0 ;
   else if ( sLeadInclPar == "no"){
      if ( process.child( "LeadInclination") != nullptr && process.child( "LeadInclination").text().get() != "") 
         vdPar[8] = Clamp( std::stod( process.child( "LeadInclination").text().get()), 0.1, 179.9) ;
      else 
         vdPar[8] = 90.0 ;
   }
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: LeadInclinationParllel unknown") ;
      return false ;
   }

   if ( process.child( "Depth") != nullptr && process.child( "Depth").text().get() != "")                       // P11
      vdPar[9] = Clamp( std::stod( process.child( "Depth").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                     // P12
      vdPar[10] = std::stod( process.child( "Length").text().get()) ;
   // vdPar[11] = ? 
   if ( process.child( "Width") != nullptr && process.child( "Width").text().get() != "")                       // P14
      vdPar[12] = Clamp( std::stod( process.child( "Width").text().get()), 0.0, 50000.0) ; 

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadLogHouseHalfLapParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                       INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 33 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;

   if ( process.child( "Orientation") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: LogHouseHalfLap orientation missing") ;
      return false ;
   }
   string sOrientation = process.child( "Orientation").text().get() ;
   if ( sOrientation == "end")
      nGroup = 3 ;
   else if ( sOrientation == "start")
      nGroup = 4 ;      
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: LogHouseHalfLap orientation unknwon") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 5) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: LogHouseHalfLap number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "Angle") != nullptr && process.child( "Angle").text().get() != "")                                // P06
      vdPar[1] = std::stod( process.child( "Angle").text().get()) ;
   if ( process.child( "DepthRefSide") != nullptr && process.child( "DepthRefSide").text().get() != "")                  // P11
      vdPar[2] = Clamp( std::stod( process.child( "DepthRefSide").text().get()), 0.0, 50000.0) ;
   if ( process.child( "DepthOppSide") != nullptr && process.child( "DepthOppSide").text().get() != "")                  // P12
      vdPar[3] = Clamp( std::stod( process.child( "DepthOppSide").text().get()), 0.0, 50000.0) ;
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                              // P13
      vdPar[4] = std::stod( process.child( "Length").text().get()) ;

   return true ;
}


//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadFrenchRidgeLapParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                      INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 33 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   if ( process.child( "Orientation") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: FrenchRidgeLap orientation missing") ;
      return false ;
   }
   string sOrientation = process.child( "Orientation").text().get() ;
   if ( sOrientation == "end")
      nGroup = 1 ;
   else if ( sOrientation == "start")
      nGroup = 2 ;      
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: FrenchRidgeLap orientation unknwon") ;
      return false ;
   }


  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 4) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: FrenchRidgeLap number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "RefPosition") != nullptr){                                                                       // P02
      string sRefPosition = process.child( "RefPosition").text().get() ;
      if ( sRefPosition == "refedge" || sRefPosition == "")
         vdPar[1] = 0 ;
      else if ( sRefPosition == "oppedge")
         vdPar[1] = 1 ;
      else {
         LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: FrenchRidgeLap RefPosition unknown") ;
         return false ;
      }
   }
   if ( process.child( "Angle") != nullptr && process.child( "Angle").text().get() != "")                                // P06
      vdPar[2] = std::stod( process.child( "Angle").text().get()) ;
   if ( process.child( "DrillholeDiam") != nullptr && process.child( "DrillholeDiam").text().get() != "")                // P13
      vdPar[3] = std::stod( process.child( "DrillholeDiam").text().get()) ;

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadChamferParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
   INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 36 ;  
   nSide = 3 ;   // Chamfer non ha un reference plane
   nGroup = 4 ;  // Chamfer non ha orientation ( prendo start)


  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 5) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Chamfer number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;

   string sCamferEdge12 = process.child( "ChamferEdge12") == nullptr ? "yes" : process.child( "ChamferEdge12").text().get() ;   // P04
   string sCamferEdge23 = process.child( "ChamferEdge23") == nullptr ? "yes" : process.child( "ChamferEdge23").text().get() ;  
   string sCamferEdge34 = process.child( "ChamferEdge34") == nullptr ? "yes" : process.child( "ChamferEdge34").text().get() ;  
   string sCamferEdge41 = process.child( "ChamferEdge34") == nullptr ? "yes" : process.child( "ChamferEdge41").text().get() ; 
   STRVECTOR values = { sCamferEdge12, sCamferEdge23, sCamferEdge34, sCamferEdge41} ;
   vdPar[1] = 0.0 ;
   for ( size_t i = 0 ; i < values.size() ; i++){
      if ( values[i] == "yes")
         vdPar[1] += pow( 2, i) ;
      else if ( values[i] != "no"){
         LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: ChamferEdge value is not valid")  ;
         return false ; 
      }
   }

   if ( process.child( "Depth") != nullptr && process.child( "Depth").text().get() != "")                                // P11
      vdPar[2] = std::stod( process.child( "Depth").text().get()) ;
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                              // P12
      vdPar[3] = std::stod( process.child( "Length").text().get()) ;

   string sChamferExit = process.child( "ChamferExit").text().get() ;                                                    // P15
   if ( sChamferExit == "orthogonal" || sChamferExit == "")
      vdPar[4] = 0 ;
   else if ( sChamferExit == "angular")
      vdPar[4] = 1 ;
   else if ( sChamferExit == "round")
      vdPar[4] = 2 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Chamfer ExitType unknown") ;
      return false ;
   }   

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadLogHouseJointParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                     INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 37 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   nGroup = 4 ;

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 15) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: LogHouseJoint number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                            // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;                      
   if ( process.child( "DepthSideLaps") != nullptr && process.child( "DepthSideLaps").text().get() != "")              // P03
      vdPar[1] = std::stod( process.child( "DepthSideLaps").text().get()) ;                                            
   if ( process.child( "DepthRefSide") != nullptr && process.child( "DepthRefSide").text().get() != "")                // P08
      vdPar[4] = std::stod( process.child( "DepthRefSide").text().get()) ;
   if ( process.child( "LengthRefSide") != nullptr && process.child( "LengthRefSide").text().get() != "")              // P09
      vdPar[5] = std::stod( process.child( "LengthRefSide").text().get()) ;
   if ( process.child( "DepthOppSide") != nullptr && process.child( "DepthOppSide").text().get() != "")                // P10
      vdPar[6] =std::stod( process.child( "DepthOppSide").text().get()) ;
   if ( process.child( "LengthOppSide") != nullptr && process.child( "LengthOppSide").text().get() != "")              // P11
      vdPar[7] = std::stod( process.child( "LengthOppSide").text().get()) ;
   if ( process.child( "DepthRefEdge") != nullptr && process.child( "DepthRefEdge").text().get() != "")                // P12
      vdPar[8] = std::stod( process.child( "DepthRefEdge").text().get()) ;
   if ( process.child( "LengthRefEdge") != nullptr && process.child( "LengthRefEdge").text().get() != "")              // P13
      vdPar[9] = std::stod( process.child( "LengthRefEdge").text().get()) ;
   if ( process.child( "DepthOppEdge") != nullptr && process.child( "DepthOppEdge").text().get() != "")                // P14
      vdPar[10] = std::stod( process.child( "DepthOppEdge").text().get()) ;
   if ( process.child( "LengthOppEdge") != nullptr && process.child( "LengthOppEdge").text().get() != "")              // P15
      vdPar[11] = std::stod( process.child( "LengthOppEdge").text().get()) ;
   if ( process.child( "ArcDepth") != nullptr && process.child( "ArcDepth").text().get() != "")                        // P16
      vdPar[12] = Clamp( std::stod( process.child( "ArcDepth").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "ArcRadius") != nullptr && process.child( "ArcRadius").text().get() != "")                      // P17
      vdPar[13] = Clamp( std::stod( process.child( "ArcRadius").text().get()), 0.0, 50000.0) ;
   if ( process.child( "ArcCenter") != nullptr && process.child( "ArcCenter").text().get() != "")                      // P18
      vdPar[14] = Clamp( std::stod( process.child( "ArcCenter").text().get()), 0.0, 50000.0) ;

   string  sLapPosition = process.child( "LapPosition").text().get() ;                                                 // P04
   if ( sLapPosition == "symmetric" || sLapPosition == "")
      vdPar[2] = 0 ;
   else if ( sLapPosition == "forward")
      vdPar[2] = 1 ;
   else if ( sLapPosition == "backward")
      vdPar[2] = 2 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: LogHouseJoint LapPosition unknown") ;
      return false ;
   }

   string sDrillHole = process.child( "DrillHole").text().get() ;                                                      // P05
   if ( sDrillHole == "no" || sDrillHole == "")
      vdPar[3] = 0 ;
   else if ( sDrillHole == "yes")
      vdPar[3] = 1 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: LogHouseJoint DrillHole unknown") ;
      return false ;
   }

   string sArcRefEdgeStart = process.child( "ArcRefEdgeStart") == nullptr ? "no" : process.child( "ArcRefEdgeStart").text().get() ;  
   string sArcOppEdgeStart = process.child( "ArcOppEdgeStart") == nullptr ? "no" : process.child( "ArcOppEdgeStart").text().get() ;  
   string sArcRefEdgeEnd = process.child( "ArcRefEdgeEnd") == nullptr ? "no" : process.child( "ArcRefEdgeEnd").text().get() ;  
   string sArcOppEdgeEnd = process.child( "ArcOppEdgeEnd") == nullptr ? "no" : process.child( "ArcOppEdgeEnd").text().get() ;  
   vdPar[15] = ComputeP04( { sArcOppEdgeEnd, sArcOppEdgeStart, sArcRefEdgeEnd, sArcRefEdgeStart}) ;                    // P19
   if ( vdPar[15] == -2)
      return false ; 

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadLogHouseFrontParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                     INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 38 ;
   if ( process.attribute("ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;

   if ( process.child( "Orientation") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: LogHouseFront orientation missing") ;
      return false ;
   }
   string sOrientation = process.child( "Orientation").text().get() ;
   if ( sOrientation == "end")
      nGroup = 3 ;
   else if ( sOrientation == "start")
      nGroup = 4 ;      
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: LogHouseFront orientation unknwon") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 7) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: LogHouseFront number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                          // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "Angle") != nullptr && process.child( "Angle").text().get() != "")                            // P06
      vdPar[2] = std::stod( process.child( "Angle").text().get()) ;
   if ( process.child( "StartDepth") != nullptr && process.child( "StartDepth").text().get() != "")                  // P11
      vdPar[3] = Clamp( std::stod( process.child( "StartDepth").text().get()), 0.0, 50000.0) ;
   if ( process.child( "DepthOppEdge") != nullptr && process.child( "DepthOppEdge").text().get() != "")              // P12
      vdPar[4] = Clamp( std::stod( process.child( "DepthOppEdge").text().get()), 0.0, 50000.0) ;
   if ( process.child( "DepthRefEdge") != nullptr && process.child( "DepthRefEdge").text().get() != "")              // P13
      vdPar[5] = Clamp( std::stod( process.child( "DepthRefEdge").text().get()), 0.0, 50000.0) ; 
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                          // P15
      vdPar[6] = Clamp( std::stod( process.child( "Length").text().get()), 0.0, 50000.0) ;

   string sRefSideOnly = process.child( "RefSideOnly").text().get() ;                                                // P04
   if ( sRefSideOnly == "yes")
      vdPar[1] = 0 ;
   else if ( sRefSideOnly == "no" || sRefSideOnly == "")
      vdPar[1] = 1 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: LogHouseFront RefSideOnly unknown") ;
      return false ;
   }

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadPocketParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                              INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 39 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   nGroup = 4 ;

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 9) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Pocket number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                            // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                            // P02
      vdPar[1] = Clamp( std::stod( process.child( "StartY").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "MachiningLimits") != nullptr ) {                                                               // P04
      vdPar[2] = ComputeP04( process.child( "MachiningLimits")) ;
      if ( vdPar[2] == -2)
         return false ;         
   }
   if ( process.child( "Angle") != nullptr && process.child( "Angle").text().get() != "")                              // P06
      vdPar[3] = std::stod( process.child( "Angle").text().get()) ;
   if ( process.child( "Inclination") != nullptr && process.child( "Inclination").text().get() != "")                  // P07
      vdPar[4] = std::stod( process.child( "Inclination").text().get()) ;
   if ( process.child( "Slope") != nullptr && process.child( "Slope").text().get() != "")                              // P08
      vdPar[5] = std::stod( process.child( "Slope").text().get()) ;
   if ( process.child( "InternalAngle") != nullptr && process.child( "InternalAngle").text().get() != "")              // P10
      vdPar[6] = std::stod( process.child( "InternalAngle").text().get()) ;
   if ( process.child( "StartDepth") != nullptr && process.child( "StartDepth").text().get() != "")                    // P11
      vdPar[7] = Clamp( std::stod( process.child( "StartDepth").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                            // P12
      vdPar[8] = std::stod( process.child( "Length").text().get()) ;
   if ( process.child( "Width") != nullptr && process.child( "Width").text().get() != "")                              // P13
      vdPar[9] = std::stod( process.child( "Width").text().get()) ;

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadDrillingParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 40 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   nGroup = 4 ;

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 7) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Drilling number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                              // P02
      vdPar[1] = Clamp( std::stod( process.child( "StartY").text().get()), -50000.0, 50000.0) ;
   //  vdPar[2] = ?                                                                                                      // P03
   if ( process.child( "Angle") != nullptr && process.child( "Angle").text().get() != "")                                // P06
      vdPar[3] = Clamp( std::stod( process.child( "Angle").text().get()), 0.0, 360.0) ;
   if ( process.child( "Inclination") != nullptr && process.child( "Inclination").text().get() != "")                    // P07
      vdPar[4] = std::stod( process.child( "Inclination").text().get()) ;
   if ( process.child( "Depth") != nullptr && process.child( "Depth").text().get() != "")                                // P11
      vdPar[5] = Clamp( std::stod( process.child( "Depth").text().get()), 0.0, 50000.0) ;
   if ( process.child( "Diameter") != nullptr && process.child( "Diameter").text().get() != "")                          // P12
      vdPar[6] = Clamp( std::stod( process.child( "Diameter").text().get()), 0.0, 50000.0) ;

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadTenonParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                             INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 50 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   if ( process.child( "Orientation") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: FrenchRidgeLap orientation missing") ;
      return false ;
   }
   string sOrientation = process.child( "Orientation").text().get() ;
   if ( sOrientation == "end")
      nGroup = 1 ;
   else if ( sOrientation == "start")
      nGroup = 2 ;      
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Tenon orientation unknwon") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 12) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Tenon number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // ~P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                              // ~P02
      vdPar[1] = Clamp( std::stod( process.child( "StartY").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "Angle") != nullptr && process.child( "Angle").text().get() != "")                                // P06
      vdPar[4] = Clamp( std::stod( process.child( "Angle").text().get()), 0.1, 179.9) ;
   if ( process.child( "Inclination") != nullptr && process.child( "Inclination").text().get() != "")                    // P07
      vdPar[5] = Clamp( std::stod( process.child( "Inclination").text().get()), 0.1, 179.9) ;
   if ( process.child( "Rotation") != nullptr && process.child( "Rotation").text().get() != "")                          // P08
      vdPar[6] = std::stod( process.child( "Rotation").text().get()) ;
   if ( process.child( "ShapeRadius") != nullptr && process.child( "ShapeRadius").text().get() != "")                    // P10
      vdPar[7] = Clamp( std::stod( process.child( "ShapeRadius").text().get()), 0.0, 1000.0) ;
   if ( process.child( "Height") != nullptr && process.child( "Height").text().get() != "")                              // P11
      vdPar[8] = Clamp( std::stod( process.child( "Height").text().get()), 0.0, 1000.0) ;
   if ( process.child( "Width") != nullptr && process.child( "Width").text().get() != "")                                // P12
      vdPar[9] = Clamp( std::stod( process.child( "Width").text().get()), 0.0, 1000.0) ;
   if ( process.child( "StartDepth") != nullptr && process.child( "StartDepth").text().get() != "")                      // ~P14
      vdPar[10] = Clamp( std::stod( process.child( "StartDepth").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                              // ~P15
      vdPar[11] = Clamp( std::stod( process.child( "Length").text().get()), 0.0, 50000.0) ;

   string sShape = process.child( "Shape").text().get() ;                                                                // P04
   if ( sShape == "automatic" || sShape == "")
      vdPar[2] = 0 ;
   else if ( sShape == "square")
      vdPar[2] = 1;
   else if ( sShape == "round")
      vdPar[2] = 2;
   else if ( sShape == "rounded")
      vdPar[2] = 3;
   else if ( sShape == "radius")
      vdPar[2] = 4;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Tenon Shape is unknown") ;
      return false ;
   }

   string sChamfer = process.child( "Chamfer").text().get() ;                                                            // P05
   if ( sChamfer == "no")
      vdPar[3] = 0 ;
   else if ( sShape == "yes")
      vdPar[3] = 1 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Tenon Chamfer is unknown") ;
      return false ;
   }                                                                                      

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadMortiseParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                               INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 50 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   nGroup = 4 ;     


  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 14) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Mortise number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                              // P02
      vdPar[1] = Clamp( std::stod( process.child( "StartY").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "StartDepth") != nullptr && process.child( "StartDepth").text().get() != "")                      // P03
      vdPar[2] = Clamp( std::stod( process.child( "StartDepth").text().get()), 0.0, 50000.0) ;
   if ( process.child( "Angle") != nullptr && process.child( "Angle").text().get() != "")                                // P06
      vdPar[4] = Clamp( std::stod( process.child( "Angle").text().get()), -180.0, 180.0) ;
   if ( process.child( "Inclination") != nullptr && process.child( "Inclination").text().get() != "")                    // P08
      vdPar[6] = Clamp( std::stod( process.child( "Inclination").text().get()), 0.1, 179.9) ;
   if ( process.child( "ShapeRadius") != nullptr && process.child( "ShapeRadius").text().get() != "")                    // P10
      vdPar[7] = Clamp( std::stod( process.child( "ShapeRadius").text().get()), 0.0, 1000.0) ;
   if ( process.child( "Depth") != nullptr && process.child( "Depth").text().get() != "")                                // P11
      vdPar[8] = Clamp( std::stod( process.child( "Depth").text().get()), 0.0, 1000.0) ;
   if ( process.child( "Width") != nullptr && process.child( "Width").text().get() != "")                                // P12
      vdPar[9] = Clamp( std::stod( process.child( "Width").text().get()), 0.0, 1000.0) ;
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                              // P13
      vdPar[10] = Clamp( std::stod( process.child( "Length").text().get()), 0.0, 50000.0) ;   
   else
      vdPar[10] = 80.0 ;        // valore default
   if ( process.child( "Slope") != nullptr && process.child( "Slope").text().get() != "")                                // P16
      vdPar[13] = Clamp( std::stod( process.child( "Slope").text().get()), 0.1, 179.9) ;

   string sShape = process.child( "Shape").text().get() ;                                                                // P04
   if ( sShape == "automatic" || sShape == "")
      vdPar[3] = 0 ;
   else if ( sShape == "square")
      vdPar[3] = 1;
   else if ( sShape == "round")
      vdPar[3] = 2;
   else if ( sShape == "rounded")
      vdPar[3] = 3;
   else if ( sShape == "radius")
      vdPar[3] = 4;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Tenon Shape is unknown") ;
      return false ;
   }

   vdPar[11] = 0.0 ;
   vdPar[12] = 0.0 ;   
   vdPar[5] = ANG_RIGHT ;

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadDovetailTenonParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                     INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 55 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;

   string sOrientation = process.child( "Orientation").text().get() ;
   if ( sOrientation == "start")
      nGroup = 2 ;
   else if ( sOrientation == "end")
      nGroup = 1 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Orientation unknown") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 12) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Mortise number of parameters is wrong") ;
      return false ;
   }

   double dWidth = 40.0 ;
  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // ~P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                              // ~P02
      vdPar[1] = Clamp( std::stod( process.child( "StartY").text().get()), -50000.0, 50000.0) ;   
   if ( process.child( "Angle") != nullptr && process.child( "Angle").text().get() != "")                                // P06
      vdPar[3] = Clamp( std::stod( process.child( "Angle").text().get()), 0.1, 179.9) ;
   if ( process.child( "Inclination") != nullptr && process.child( "Inclination").text().get() != "")                    // P07
      vdPar[4] = Clamp( std::stod( process.child( "Inclination").text().get()), 0.1, 179.9) ;
   if ( process.child( "Rotation") != nullptr && process.child( "Rotation").text().get() != "")                          // P08
      vdPar[5] = Clamp( std::stod( process.child( "Rotation").text().get()), 0.1, 179.9) ;
   if ( process.child( "Width") != nullptr && process.child( "Width").text().get() != "")                                // P09
      dWidth = Clamp( std::stod( process.child( "Width").text().get()), 0.0, 1000.0) ;
   if ( process.child( "ConeAngle") != nullptr && process.child( "ConeAngle").text().get() != "")                        // P10
      vdPar[7] = Clamp( std::stod( process.child( "ConeAngle").text().get()), 0.0, 30.0) ;
   if ( process.child( "Height") != nullptr && process.child( "Height").text().get() != "")                              // P11
      vdPar[8] = Clamp( std::stod( process.child( "Height").text().get()), 0.0, 1000.0) ;
   if ( process.child( "ShapeRadius") != nullptr && process.child( "ShapeRadius").text().get() != "")                    // P12
      vdPar[9] = Clamp( std::stod( process.child( "ShapeRadius").text().get()), 0.0, 1000.0) ;
   if ( process.child( "StartDepth") != nullptr && process.child( "StartDepth").text().get() != "")                      // ~P14
      vdPar[10] = Clamp( std::stod( process.child( "StartDepth").text().get()), 0.0, 50000.0) ;
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                              // ~P15
      vdPar[11] = Clamp( std::stod( process.child( "Length").text().get()), 0.0, 50000.0) ;
   //  if ( process.child( "FlankAngle") != nullptr && process.child( "FlankAngle").text().get() != "")                  
   //     vdPar[] = Clamp( std::stod( process.child( "FlankAngle").text().get()), 5.0, 35.0) ;


   string sShape = process.child( "Shape").text().get() ;                                                                // ~P04
   if ( sShape == "round"){
      vdPar[6] = 0.0 ;                                                                                                   // P09
      vdPar[9] = dWidth * cos( vdPar[7] * DEGTORAD) / ( 1 - sin( vdPar[7] * DEGTORAD)) ;                                 // P12
   }
   else if ( sShape == "radius"){
      vdPar[9] *= 2 ;                                                                                                    // P12
      vdPar[6] = dWidth - vdPar[9] * ( 1 - sin( vdPar[7] * DEGTORAD)) / cos( vdPar[7] * DEGTORAD) ;                      // P09
      if ( vdPar[6] < 0 )   {
         LOG_ERROR( GetEExLogger(), "  Error : Dovetail tenon width")
            return false ;
      }
   }
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Tenon Shape is unknown") ;
      return false ;
   }

   string sLimitedBottom = process.child( "LengthLimitedBottom").text().get() ;
   if ( sLimitedBottom == "no")
      vdPar[2] = 1 ;
   else if ( sLimitedBottom == "yes")
      vdPar[2] = 0 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: LengthLimitedBottom is unknown")
   }

   // Parametri vengono poi sistemati nella funzione AddDovetailTenonBTLX

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadDovetailMortiseParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                       INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 55 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   nGroup = 4 ;  

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 14) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Dovetail Mortise number of parameters is wrong") ;
      return false ;
   }

   double dWidth = 40.0 ;
  //  Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                              // P02
      vdPar[1] = Clamp( std::stod( process.child( "StartY").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "StartDepth") != nullptr && process.child( "StartDepth").text().get() != "")                      // P03
      vdPar[2] = Clamp( std::stod( process.child( "StartDepth").text().get()), 0.0, 50000.0) ;
   if ( process.child( "Angle") != nullptr && process.child( "Angle").text().get() != "")                                // P06
      vdPar[5] = Clamp( std::stod( process.child( "Angle").text().get()), -180.0, 180.0) ;
   if ( process.child( "Width") != nullptr && process.child( "Width").text().get() != "")                                
      dWidth = Clamp( std::stod( process.child( "Width").text().get()), 0.0, 1000.0) ;
   if ( process.child( "ConeAngle") != nullptr && process.child( "ConeAngle").text().get() != "")                        // P16
      vdPar[8] = Clamp( std::stod( process.child( "ConeAngle").text().get()), 0.1, 179.9) ;
   if ( process.child( "Depth") != nullptr && process.child( "Depth").text().get() != "")                                // P11
      vdPar[9] = Clamp( std::stod( process.child( "Depth").text().get()), 0.0, 1000.0) ;
   if ( process.child( "ShapeRadius") != nullptr && process.child( "ShapeRadius").text().get() != "")                    // P10
      vdPar[10] = Clamp( std::stod( process.child( "ShapeRadius").text().get()), 0.0, 1000.0) ; 
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                              // P13
      vdPar[11] = Clamp( std::stod( process.child( "Length").text().get()), 0.0, 50000.0) ;

   string sLimitedBottom = process.child( "LengthLimitedBottom").text().get() ;                                          // P04
   if ( sLimitedBottom == "yes")
      vdPar[3] = 0 ;
   else if ( sLimitedBottom == "no")
      vdPar[3] = 1 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Dovetail Mortise LengthLimitedBottom unkown") ;
      return false ;
   }

   string sLimitationTop = process.child( "LimitationTop").text().get() ;                                                // P05
   if ( sLimitationTop == "unlimited")
      vdPar[4] = 0 ;
   else if ( sLimitationTop == "pocket")
      vdPar[4] = 1 ;
   else if ( sLimitationTop != "limited") {  
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Dovetail Mortise LimitationTop unkown") ;
      return false ;
   }

   string sShape = process.child( "Shape").text().get() ;
   if ( sShape == "round"){
      vdPar[7] = 0 ;                                                                                                     // P09
      vdPar[10] = dWidth * cos( vdPar[8] * DEGTORAD) / ( 1 - sin( vdPar[8] * DEGTORAD)) ;                                // P12   
   }                                                                                                                     
   else if ( sShape == "radius"){                                                                                        
      vdPar[10] *= 2 ;                                                                                                   // P12
      vdPar[7] = dWidth - vdPar[10] * ( 1 - sin( vdPar[8] * DEGTORAD)) / cos( vdPar[8] * DEGTORAD) ;                     // P09
      if ( vdPar[7] < 0 )   {
         LOG_ERROR( GetEExLogger(), "  Error : Dovetail mortise width") ;
         return false ;
      }     
   }
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Mortise Shape is unknown") ;
      return false ;
   }

   vdPar[6] = ANG_RIGHT ;                                                                                                 // P07
   vdPar[12] = 0.0 ;                                                                                                      // P14
   vdPar[13] = 0.0 ;                                                                                                      // P15

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadMarkingParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                               INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 60 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   nGroup = 4 ;

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 8) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Text number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                              // P02
      vdPar[1] = Clamp( std::stod( process.child( "StartY").text().get()), -50000.0, 50000.0) ;
   vdPar[2] = 0 ;     // no text                                                                                         // P04
   if ( process.child( "Angle") != nullptr && process.child( "Angle").text().get() != "")                                // P06
     //uso il range del BTL
      vdPar[3] = Clamp( std::stod( process.child( "Angle").text().get()), 1.0, 180.0) ;
   if ( process.child( "InteriorAngle") != nullptr && process.child( "InteriorAngle").text().get() != "")                // P13
      vdPar[4] = Clamp( std::stod( process.child( "InteriorAngle").text().get()), 0.0, 50000.0) ;
   string sStyle = process.child( "Style").text().get() ;
   
   double dWidth = Clamp( std::stod( process.child( "Width").text().get()), 0.0, 50000.0) ; 
   double dLength = Clamp( std::stod( process.child( "Length").text().get()), 0.0, 50000.0) ;

  // Linea orizzontale
   if ( abs( vdPar[3] - 180.0) < EPS_SMALL){
      vdPar[6] = dLength ;
      return true ;
   }

   string sLimited = process.child( "LengthLimited").text().get() ;                                                      // P12
   Vector3d vtD = FromPolar( 1, vdPar[3]) ;
   if ( nGroup == 4)
      vtD.Mirror( X_AX) ;
   if ( sLimited == "no" || sLimited == "")
      vdPar[6] = 0.0 ;     // la funzione AddMarking sistemerà il valore in base alla lunghezza del lato
   else if ( sLimited == "yes")
      if ( abs( vdPar[3]) < EPS_SMALL)
         vdPar[6] = dLength ;
      else
         vdPar[6] = dLength * vtD.y ;    
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: LengthLimited unknown") ;
      return false ;
   }

  
   if ( sStyle == "single" || sStyle == ""){                                                                             // P11
     // Condizioni che identificano il caso della singola linea 
      vdPar[4] = 0.0 ;
      vdPar[5] = 0.0 ;   
   }
   else if ( sStyle == "double"){
      vdPar[5] = dWidth * sin( vdPar[4] * DEGTORAD) / sin( vdPar[3] * DEGTORAD) ;     
     //Condizione che identifica il caso di linea doppia
      vdPar[4] = 0.0 ;   
   }
   else if ( sStyle == "square"){
      Vector3d vtE = vtD ;
      vtE.Rotate( Z_AX, ( ( nGroup == 3) ? vdPar[4] : - vdPar[4])) ;
      vdPar[5] = dWidth * abs( vtE.x) ;   
   }
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: MarkingStyle unknown") ;
      return false ;
   }

   nSPar = 1 ;
   sPar = "" ;                                                                                                           // P15    

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadTextParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                            INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 61 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   nGroup = 4 ;

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 8) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Text number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                              // P02
      vdPar[1] = Clamp( std::stod( process.child( "StartY").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "Angle") != nullptr && process.child( "Angle").text().get() != "")                                // P06
      vdPar[2] = Clamp( std::stod( process.child( "Angle").text().get()), -180.0, 180.0) ;
   if ( process.child( "TextHeight") != nullptr && process.child( "TextHeight").text().get() != "")                      // P13
      vdPar[7] = Clamp( std::stod( process.child( "TextHeight").text().get()), 0.0, 50000.0) ;

   nSPar = 1 ;
   sPar = process.child( "Text").text().get() ;                                                                          // P15

   string sVAlignment = process.child( "AlignmentVertical").text().get() ;                                               // P09
   if ( sVAlignment == "bottom" || sVAlignment == "")
      vdPar[3] = 0 ;
   else if ( sVAlignment == "middle")
      vdPar[3] = 1;
   else if ( sVAlignment == "top")
      vdPar[3] = 2;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Text Vertical Alignment is unknown") ;
      return false ;
   }

   string sHAlignment = process.child( "AlignmentHorizontal").text().get() ;                                             // P10
   if ( sHAlignment == "left" || sHAlignment == "")
      vdPar[4] = 0 ;
   else if ( sHAlignment == "middle")
      vdPar[4] = 1 ;
   else if ( sHAlignment == "right")
      vdPar[4] = 2 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Text Horizontal Alignment is unknown") ;
      return false ;
   }

   string sMAlignment = process.child( "AlignmentMultiline").text().get() ;                                             // P11
   if ( sMAlignment == "left" || sMAlignment == "")
      vdPar[5] = 0 ;
   else if ( sMAlignment == "middle")
      vdPar[5] = 1 ;
   else if ( sMAlignment == "right")
      vdPar[5] = 2 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Text Multiline Alignment is unknown") ;
      return false ;
   }

   string sStackedMarking = process.child( "StackedMarking").text().get() ;                                             // P12
   if ( sStackedMarking == "no")
      vdPar[6] = 0 ;
   else if ( sStackedMarking == "yes")
      vdPar[6] = 1 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Text StackedMarking is unknown") ;
      return false ;
   }                                                                                      

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadSimpleScarfParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                   INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 70 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;

   string sOrientation = process.child( "Orientation").text().get() ;
   if ( sOrientation == "end")
      nGroup = 1 ;
   else if ( sOrientation == "start")
      nGroup = 2 ;      
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Tenon orientation unknwon") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 6) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: SimpleScarf number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "DepthRefSide") != nullptr && process.child( "DepthRefSide").text().get() != "")                  // P11
      vdPar[1] = std::stod( process.child( "DepthRefSide").text().get()) ;
   if ( process.child( "DepthOppSide") != nullptr && process.child( "DepthOppSide").text().get() != "")                  // P12
      vdPar[2] = std::stod( process.child( "DepthOppSide").text().get()) ;
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                              // P13
      vdPar[3] = std::stod( process.child( "Length").text().get()) ;
   if ( process.child( "DrillHoleDiam1") != nullptr && process.child( "DrillHoleDiam1").text().get() != "")              // P14
      vdPar[4] = std::stod( process.child( "DrillHoleDiam1").text().get()) ;
   if ( process.child( "DrillHoleDiam2") != nullptr && process.child( "DrillHoleDiam2").text().get() != "")              // P15
      vdPar[5] = std::stod( process.child( "DrillHoleDiam2").text().get()) ;

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadScarfJointParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide,
                                  INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 71 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;

   string sOrientation = process.child( "Orientation").text().get() ;
   if ( sOrientation == "end")
      nGroup = 1 ;
   else if ( sOrientation == "start")
      nGroup = 2 ;      
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Tenon orientation unknwon") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 9) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: ScarfJoint number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "Inclination") != nullptr && process.child( "Inclination").text().get() != "")                    // P07
      vdPar[1] = std::stod( process.child( "Inclination").text().get()) ;  
   if ( process.child( "LapLength") != nullptr && process.child( "LapLength").text().get() != "")                        // P10
      vdPar[3] = std::stod( process.child( "LapLength").text().get()) ;
   if ( process.child( "LapDepth") != nullptr && process.child( "LapDepth").text().get() != "")                          // P11
      vdPar[4] = std::stod( process.child( "LapDepth").text().get()) ;                                                   
   if ( process.child( "DepthOppSide") != nullptr && process.child( "DepthOppSide").text().get() != "")                  // P12
      vdPar[5] = std::stod( process.child( "DepthOppSide").text().get()) ; 
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                              // P13
      vdPar[6] = std::stod( process.child( "Length").text().get()) ;                                                     
   if ( process.child( "DrillHoleDiam1") != nullptr && process.child( "DrillHoleDiam1").text().get() != "")              // P14
      vdPar[7] = std::stod( process.child( "DrillHoleDiam1").text().get()) ; 
   if ( process.child( "DrillHoleDiam2") != nullptr && process.child( "DrillHoleDiam2").text().get() != "")              // P15
      vdPar[8] = std::stod( process.child( "DrillHoleDiam2").text().get()) ; 

   string sScarfShape = process.child( "ScarfShape").text().get() ;                                                      // P09
   if ( sScarfShape == "classic")
      vdPar[2] = 0 ;
   else if ( sScarfShape == "refside" || sScarfShape == "")    // se non esiste metto il valore di default
      vdPar[2] = 1 ;
   else if ( sScarfShape == "baseside")
      vdPar[2] = -1 ;
   else  {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: ScarfJoint ScarfShape is unknown") ;
      return false ;
   }

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadStepJointParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                 INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 80 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   string sOrientation = process.child( "Orientation").text().get() ;
   if ( sOrientation == "end")
      nGroup = 1 ;
   else if ( sOrientation == "start")
      nGroup = 2 ;      
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Step Joint orientation unknwon") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 7) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: StepJoint number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                          // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "StrutInclination") != nullptr && process.child( "StrutInclination").text().get() != "")      // P07
      vdPar[2] = std::stod( process.child( "StrutInclination").text().get()) ;
   if ( process.child( "StepDepth") != nullptr && process.child( "StepDepth").text().get() != "")                    // P11
      vdPar[3] = std::stod( process.child( "StepDepth").text().get()) ;
   if ( process.child( "HeelDepth") != nullptr && process.child( "HeelDepth").text().get() != "")                    // P12
      vdPar[4] = std::stod( process.child( "HeelDepth").text().get()) ;
   if ( process.child( "TenonHeight") != nullptr && process.child( "TenonHeight").text().get() != "")                // P14
      vdPar[5] = std::stod( process.child( "TenonHeight").text().get()) ;
   if ( process.child( "TenonWidth") != nullptr && process.child( "TenonWidth").text().get() != "")                  // P15
      vdPar[6] = std::stod( process.child( "TenonWidth").text().get()) ;

   string sStepShape = process.child( "StepShape").text().get() ;                                                    // P09
   if ( sStepShape == "double" || sStepShape == "")
      vdPar[1] = 0 ;
   else if ( sStepShape == "step")
      vdPar[1] = 1 ;
   else if ( sStepShape == "heel")
      vdPar[1] = -1 ;
   else  {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: StepJointNotch StepShape is unknown") ;
      return false ;
   }

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadStepJointNotchParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                      INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 80 ;
   if ( process.attribute( "ReferencePlaneID") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing : missing reference plane") ;
      return false ;
   }
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   string sOrientation = process.child( "Orientation").text().get() ;
   if ( sOrientation == "end")
      nGroup = 3 ;
   else if ( sOrientation == "start")
      nGroup = 4 ;      
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Step Joint Notch orientation unknwon") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 10) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: StepJoint number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                           // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                           // P02
      vdPar[1] = Clamp( std::stod( process.child( "StartY").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "StrutInclination") != nullptr && process.child( "StrutInclination").text().get() != "")       // P07
      vdPar[3] = std::stod( process.child( "StrutInclination").text().get()) ;
   if ( process.child( "NotchWidth") != nullptr && process.child( "NotchWidth").text().get() != "")                   // P10
      vdPar[4] = std::stod( process.child( "NotchWidth").text().get()) ;
   if ( process.child( "StepDepth") != nullptr && process.child( "StepDepth").text().get() != "")                     // P11
      vdPar[5] = std::stod( process.child( "StepDepth").text().get()) ;
   if ( process.child( "HeelDepth") != nullptr && process.child( "HeelDepth").text().get() != "")                     // P12
      vdPar[6] = std::stod( process.child( "HeelDepth").text().get()) ;
   if ( process.child( "StrutHeight") != nullptr && process.child( "StrutHeight").text().get() != "")                 // P13
      vdPar[7] = std::stod( process.child( "StrutHeight").text().get()) ;
   if ( process.child( "MortiseHeight") != nullptr && process.child( "MortiseHeight").text().get() != "")             // P14
      vdPar[8] = std::stod( process.child( "MortiseHeight").text().get()) ;
   if ( process.child( "MortiseWidth") != nullptr && process.child( "MortiseWidth").text().get() != "")               // P15
      vdPar[9] =std::stod( process.child( "MortiseWidth").text().get()) ;

   string sStepShape = process.child( "StepShape").text().get() ;                                                     // P09
   if ( sStepShape == "double" || sStepShape == ""){
   }
   else if ( sStepShape == "step"){
      vdPar[6] = 0.0 ;                 // P12 
   }
   else if ( sStepShape == "heel"){
      vdPar[5] = 0.0 ;                 // P11
   }
   else  {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: StepJointNotch StepShape is unknown") ;
      return false ;
   }

   // P04 = vdPar[2] = ?
   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadPlaningParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                               INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 90 ;
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   nGroup = 4 ;

   // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 4) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Text number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;

   string PlaneSide1 = process.child( "PlaneSide1") == nullptr ? "yes" : process.child( "PlaneSide1").text().get() ;     // P04
   string PlaneSide2 = process.child( "PlaneSide2") == nullptr ? "yes" : process.child( "PlaneSide2").text().get() ;
   string PlaneSide3 = process.child( "PlaneSide3") == nullptr ? "yes" : process.child( "PlaneSide3").text().get() ;
   string PlaneSide4 = process.child( "PlaneSide4") == nullptr ? "yes" : process.child( "PlaneSide4").text().get() ;
   vdPar[1] = ComputeP04( { PlaneSide1, PlaneSide2, PlaneSide3, PlaneSide4}) ;
   if ( vdPar[1] == -2)
      return false ;

   if ( process.child( "Depth") != nullptr && process.child( "Depth").text().get() != "")                                // P11
      vdPar[2] = Clamp( std::stod( process.child( "Depth").text().get()), 0.0, 50.0) ;
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                              // P12
      vdPar[3] = Clamp( std::stod( process.child( "Length").text().get()), 0.0, 100000.0) ;

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadProfileFrontParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                    INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, string& sPar) 
{
  //  Identifico il processo con sigle usate nel btl
   nProc = 100 ;
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   string sOrientation = process.child( "Orientation").text().get() ;
   if ( sOrientation == "end")
      nGroup = 3 ;
   else if ( sOrientation == "start")
      nGroup = 4 ;      
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: ProfileFront orientation unknwon") ;
      return false ;
   }
  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 7) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: ProfileFront number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "Depth") != nullptr && process.child( "Depth").text().get() != "")                                // P03
      vdPar[1] = Clamp( std::stod( process.child( "Depth").text().get()), 0.0, 1000.0) ; 
   if ( process.child( "Rotation1") != nullptr && process.child( "Rotation1").text().get() != "")                        // P06
      vdPar[2] = std::stod( process.child( "Rotation1").text().get()) ;
   if ( process.child( "Rotation2") != nullptr && process.child( "Rotation2").text().get() != "")                        // P07
      vdPar[3] = std::stod( process.child( "Rotation2").text().get()) ;
   if ( process.child( "StartRotation") != nullptr && process.child( "StartRotation").text().get() != "")                // P08
      vdPar[4] = Clamp( std::stod( process.child( "StartRotation").text().get()), -90.0, 90.0) ;                                                                
   if ( process.child( "Radius1") != nullptr && process.child( "Radius1").text().get() != "")                            // P11
      vdPar[5] = Clamp( std::stod( process.child( "Radius1").text().get()), 0.0, 1000.0) ; 
   if ( process.child( "Radius2") != nullptr && process.child( "Radius2").text().get() != "")                            // P12
      vdPar[6] = Clamp( std::stod( process.child( "Radius2").text().get()), 0.0, 1000.0) ; 

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadProfileCamberedParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                       INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 103 ;

   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   string sOrientation = process.child( "Orientation").text().get() ;
   if ( sOrientation == "end")
      nGroup = 3 ;
   else if ( sOrientation == "start")
      nGroup = 4 ;      
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: ProfileCambered orientation unknwon") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 7) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: ProfileCambered number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;  
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                              // P10
      vdPar[1] = Clamp( std::stod( process.child( "Length").text().get()), 0.0, 100000.0) ;
   if ( process.child( "StartDepth") != nullptr && process.child( "StartDepth").text().get() != "")                      // P11
      vdPar[2] = Clamp( std::stod( process.child( "StartDepth").text().get()), 0.0, 1000.0) ;  
   if ( process.child( "MaxDepth") != nullptr && process.child( "MaxDepth").text().get() != "")                          // P12
      vdPar[3] = Clamp( std::stod( process.child( "MaxDepth").text().get()), 0.0, 1000.0) ;
   if ( process.child( "MinDepth") != nullptr && process.child( "MinDepth").text().get() != "")                          // P13
      vdPar[4] = Clamp( std::stod( process.child( "MinDepth").text().get()), 0.0, 1000.0) ; 
   if ( process.child( "EndDepth") != nullptr && process.child( "EndDepth").text().get() != "")                          // P14
      vdPar[5] = Clamp( std::stod( process.child( "EndDepth").text().get()), 0.0, 1000.0) ; 

   string sPremill = process.child( "Premill").text().get() ;                                                            // P15
   if ( sPremill == "round")
      vdPar[6] = 0 ;
   else if ( sPremill == "angular" || sPremill == "")
      vdPar[6] = 1 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: ProfileCambered Premill unknown") ;
      return false ;
   }  

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadRoundArchParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                 INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 104 ;
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   nGroup = 4 ;

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 3) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: RoundARch number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "Camber") != nullptr && process.child( "Camber").text().get() != "")                              // P11
      vdPar[1] = Clamp( std::stod( process.child( "Camber").text().get()), 0.0, 1000.0) ; 
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                              // P12
      vdPar[2] = std::stod( process.child( "Length").text().get()) ;

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadProfileHeadParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                   INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 106 ;
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   string sOrientation = process.child( "Orientation").text().get() ;
   if ( sOrientation == "end")
      nGroup = 3 ;
   else if ( sOrientation == "start")
      nGroup = 4 ;      
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: ProfileHead orientation unknwon") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 16) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: ProfileHead number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr  &&  process.child( "StartX").text().get() != "")                     // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;

  // Tipologia archi                                                                                              // P04
   string sArc1Shape = process.child( "Arc1").attribute( "ArcShape").value() ;
   string sArc2Shape = process.child( "Arc2").attribute( "ArcShape").value() ;
   vdPar[1] = 0 ;
   if ( sArc1Shape != "concave")
      vdPar[1] += 1 ;
   if ( sArc2Shape != "concave")
      vdPar[1] += 2 ;

   if ( process.child( "LapLength") != nullptr && process.child( "LapLength").text().get() != "")                 // P09
      vdPar[2] =std::stod( process.child( "LapLength").text().get()) ; 
   if ( process.child( "LapHeight") != nullptr && process.child( "LapHeight").text().get() != "")                 // P10
      vdPar[3] = std::stod( process.child( "LapHeight").text().get()) ;

  // Arc 1
   if ( process.child( "Arc1") != nullptr && process.child( "Arc1").attribute( "Displacement") != nullptr)        // P11
      vdPar[4] = process.child( "Arc1").attribute( "Displacement").as_double() ;
   if ( process.child( "Arc1") != nullptr && process.child( "Arc1").attribute( "LapLength") != nullptr)           // P15
      vdPar[8] = process.child( "Arc1").attribute( "LapLength").as_double() ;
   if ( process.child( "Arc1") != nullptr && process.child( "Arc1").attribute( "LapHeight") != nullptr)           // P16
      vdPar[9] = process.child( "Arc1").attribute( "LapHeight").as_double() ;

   if ( process.child( "Arc1").child( "QuarterArc") != nullptr){
      vdPar[5] = process.child( "Arc1").child( "QuarterArc").attribute( "Radius").as_double() ;                   // P12
      vdPar[6] = 0.0 ;                                                                                            // P13
      vdPar[7] = 0.0 ;                                                                                            // P14
   }
   else if ( process.child( "Arc1").child( "Segment") != nullptr){
      vdPar[5] = process.child( "Arc1").child( "Segment").attribute( "Length").as_double() ;                      // P12
      vdPar[6] = process.child( "Arc1").child( "Segment").attribute( "Height").as_double() ;                      // P13                                                     // P13
      vdPar[7] = process.child( "Arc1").child( "Segment").attribute( "Camber").as_double() ;                      // P14                                                                                            // P14
   }
   else  { // se non ci fosse metto i parametri a zero (non ai valori di default)
      vdPar[5] = 0.0 ; 
      vdPar[6] = 0.0 ;
      vdPar[7] = 0.0 ;   
   }

  // Arc2
   if ( process.child ( "Arc2") == nullptr){   
      vdPar[10] = 0.0 ;
      vdPar[11] = 0.0 ;
      vdPar[12] = 0.0 ;
      vdPar[13] = 0.0 ;
      vdPar[14] = 0.0 ;
      vdPar[15] = 0.0 ;   
   }

   if ( process.child( "Arc2") != nullptr && process.child( "Arc2").attribute( "Displacement") != nullptr)        // P17
      vdPar[10] = process.child( "Arc2").attribute( "Displacement").as_double() ;
   if ( process.child( "Arc2") != nullptr && process.child( "Arc2").attribute( "LapLength") != nullptr)           // P21
      vdPar[14] = process.child( "Arc2").attribute( "LapLength").as_double() ;
   if ( process.child( "Arc2") != nullptr && process.child( "Arc2").attribute( "LapHeight") != nullptr)           // P22
      vdPar[15] = process.child( "Arc2").attribute( "LapHeight").as_double() ;

   if ( process.child( "Arc2").child( "QuarterArc") != nullptr){
      vdPar[11] = process.child( "Arc2").child( "QuarterArc").attribute( "Radius").as_double() ;                  // P18
      vdPar[12] = 0.0 ;                                                                                           // P19
      vdPar[13] = 0.0 ;                                                                                           // P20
   }
   else if ( process.child( "Arc2").child( "Segment") != nullptr){
      vdPar[11] = process.child( "Arc2").child( "Segment").attribute( "Length").as_double() ;                     // P18
      vdPar[12] = process.child( "Arc2").child( "Segment").attribute( "Height").as_double() ;                     // P19                                                     // P13
      vdPar[13] = process.child( "Arc2").child( "Segment").attribute( "Camber").as_double() ;                     // P20                                                                                            // P14
   }

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadSphereParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                              INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 107 ;
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   std::string orientation = process.child( "Orientation").text().get() ;
   if ( orientation == "end")
      nGroup = 3 ;
   else if ( orientation == "start")
      nGroup = 4 ;      
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Sphere orientation unknwon") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 6) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Sphere number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                              // P02
      vdPar[1] = Clamp( std::stod( process.child( "StartY").text().get()), -50000.0, 50000.0) ; 
   if ( process.child( "StartDepth") != nullptr && process.child( "StartDepth").text().get() != "")                      // P03
      vdPar[2] = Clamp( std::stod( process.child( "StartDepth").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "Radius") != nullptr && process.child( "Radius").text().get() != "")                              // P11
      vdPar[3] = Clamp( std::stod( process.child( "Radius").text().get()), 0.0, 50000.0) ;
   if ( process.child( "StartOffset") != nullptr && process.child( "StartOffset").text().get() != "")                    // P12
      vdPar[4] = Clamp( std::stod( process.child( "StartOffset").text().get()), 0.0, 50000.0) ;
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                              // P13
      vdPar[5] = Clamp( std::stod( process.child( "Length").text().get()), 0.0, 50000.0) ;

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadTriangleCutParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                   INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 120 ;
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   nGroup = 4 ;      

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 9) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: TriangleCut number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                              // P01
      vdPar[0] = Clamp( std::stod( process.child( "StartX").text().get()), -100000.0, 100000.0) ;   
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                              // P02
      vdPar[1] = Clamp( std::stod( process.child( "StartY").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "StartDepth") != nullptr && process.child( "StartDepth").text().get() != "")                      // P03
      vdPar[2] = Clamp( std::stod( process.child( "StartDepth").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "Normal1X") != nullptr && process.child( "Normal1X").text().get() != "")                          // P10
      vdPar[3] = Clamp( std::stod( process.child( "Normal1X").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "Normal1Y") != nullptr && process.child( "Normal1Y").text().get() != "")                          // P11
      vdPar[4] = Clamp( std::stod( process.child( "Normal1Y").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "Normal1Z") != nullptr && process.child( "Normal1Z").text().get() != "")                          // P12
      vdPar[5] = Clamp( std::stod( process.child( "Normal1Z").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "Normal2X") != nullptr && process.child( "Normal2X").text().get() != "")                          // P13
      vdPar[6] = Clamp( std::stod( process.child( "Normal2X").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "Normal2Y") != nullptr && process.child( "Normal2Y").text().get() != "")                          // P14
      vdPar[7] = Clamp( std::stod( process.child( "Normal2Y").text().get()), -50000.0, 50000.0) ;
   if ( process.child( "Normal2Z") != nullptr && process.child( "Normal2Z").text().get() != "")                          // P15
      vdPar[8] = Clamp( std::stod( process.child( "Normal2Z").text().get()), -50000.0, 50000.0) ;

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadTyroleanDovetailParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                        INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 136 ;
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   string sOrientation = process.child( "Orientation").text().get() ;      
   string sCutOff = process.child( "CutOff").text().get() ;
   if ( sCutOff == "")
      sCutOff = "no" ; // se non ci fosse, valore di default

   if( sOrientation == "end" && sCutOff == "yes")
      nGroup = 1 ;
   else if (sOrientation == "start" && sCutOff == "yes")
      nGroup = 2 ;
   else if (sOrientation == "end" && sCutOff == "no")
      nGroup = 3 ;
   else if (sOrientation == "start" && sCutOff == "yes")
      nGroup = 4 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Tyrolean Dovetail group not defined") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 15) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: TriangleCut number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr && process.child( "StartX").text().get() != "")                                 // P01
      vdPar[0] = std::stod( process.child( "StartX").text().get()) ;                                                        
   if ( process.child( "StartY") != nullptr && process.child( "StartY").text().get() != "")                                 // P02
      vdPar[1] = std::stod( process.child( "StartY").text().get()) ;                                                        
   if ( process.child( "StartDepth") != nullptr && process.child( "StartDepth").text().get() != "")                         // P03
      vdPar[2] = std::stod( process.child( "StartDepth").text().get()) ;                                                    
   if ( process.child( "Angle") != nullptr && process.child( "Angle").text().get() != "")                                   // P06
      vdPar[5] = std::stod( process.child( "Angle").text().get()) ;                                                         
   if ( process.child( "Frosh").child("Width") != nullptr && process.child( "Frosh").child("Width").text().get() != "")     // P07
      vdPar[6] = Clamp( std::stod( process.child( "Frosh").child("Width").text().get()), 0.0, 50000.0) ;                    
   if ( process.child( "Frosh").child("Depth") != nullptr && process.child( "Frosh").child("Depth").text().get() != "")     // P08
      vdPar[7] = Clamp( std::stod( process.child( "Frosh").child("Depth").text().get()), 0.0, 50000.0) ;                    
   if ( process.child( "Slope") != nullptr && process.child( "Slope").text().get() != "")                                   // P09
      vdPar[8] = std::stod( process.child( "Slope").text().get()) ;                                                         
   if ( process.child( "Height") != nullptr && process.child( "Height").text().get() != "")                                 // P11
      vdPar[9] = std::stod( process.child( "Height").text().get()) ;
   if ( process.child("Klingschrot").child("Radius") != nullptr && process.child("Klingschrot").child("Radius").text().get() != "")         // P12
      vdPar[10] = Clamp( std::stod( process.child("Klingschrot").child("Radius").text().get()), 0.0, 50000.0) ;
   if ( process.child("Klingschrot").child("ArcLength") != nullptr && process.child("Klingschrot").child("ArcLength").text().get() != "")   // P13
      vdPar[11] = Clamp( std::stod( process.child("Klingschrot").child("ArcLength").text().get()), 0.0, 50000.0) ;
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                                 // P15
      vdPar[13] = Clamp( std::stod( process.child( "Length").text().get()), 0.0, 50000.0) ;   

   string sLapPosition = process.child( "LapPosition").text().get() ;                                                       // P04
   if ( sLapPosition == "refedge" || sLapPosition == "")   
      vdPar[3] = 1 ;
   else if ( sLapPosition == "oppedge")
      vdPar[3] = 0 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Tyrolean Dovetail LapPosition unknown") ;
      return false ;
   }

   string sLapExit = process.child( "LapExit").text().get() ;                                                               // P05
   if ( sLapExit == "none")                                                                                                 
      vdPar[4] = 0 ;                                                                                                        
   else if ( sLapExit == "mitre" || sLapExit == "")                                                                         
      vdPar[4] = -1 ;                                                                                                       
   else if ( sLapExit == "rebate") {                                                                                        
      if ( process.child( "RebateLength") != nullptr)                                                                       
         vdPar[4] = std::stod( process.child( "RebateLength").text().get()) ;                                               
      else                                                                                                                  
         vdPar[4] = 10.0 ; // valore di default                                                                              
   }                                                                                                                        
   else {                                                                                                                   
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Tyrolean Dovetail LapExit unknown") ;                    
      return false ;                                                                                                        
   }                                                                                                                        

   string sShape = process.child( "Shape").text().get() ;                                                                   // P14
   if ( sShape == "straigth")                                                                                               
      vdPar[12] = 1 ;                                                                                                       
   else if ( sShape == "angular" || sShape == "")                                                                           
      vdPar[12] = 0 ;                                                                                                       
   else {                                                                                                                   
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Tyrolean Dovetail Shape unknown") ;                      
      return false ;                                                                                                        
   }                                                                                                                  

   string sProcessSide = process.child( "ProcessSide").text().get() ;                                                       // P16
   if ( sProcessSide == "both" || sProcessSide == "")                                                                       
      vdPar[14] = 0 ;                                                                                                       
   else if ( sProcessSide == "refside")                                                                                     
      vdPar[14] = 1 ;                                                                                                       
   else if ( sProcessSide == "oppside")
      vdPar[14] = 2 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Tyrolean Dovetail Shape unknown") ;
      return false ;
   }

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadDovetailParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 138 ;
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   string sOrientation = process.child( "Orientation").text().get() ;      
   string sCutOff = process.child( "CutOff").text().get() ;
   if ( sCutOff == "")
      sCutOff = "no" ; // se non ci fosse, valore di default

   if( sOrientation == "end" && sCutOff == "yes")
      nGroup = 1 ;
   else if (sOrientation == "start" && sCutOff == "yes")
      nGroup = 2 ;
   else if (sOrientation == "end" && sCutOff == "no")
      nGroup = 3 ;
   else if (sOrientation == "start" && sCutOff == "yes")
      nGroup = 4 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Dovetail group not defined") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
   if ( ! bParamsInfoOk){
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
      return false ;
   }
   if ( vdPar.size() != 11) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Dovetail number of parameters is wrong") ;
      return false ;
   }

  // Riempio i vettori dei parametri vdPar, se qualche valore non ci fosse lascio quello di default
   if ( process.child( "StartX") != nullptr  &&  process.child( "StartX").text().get() != "")                         // P01
      vdPar[0] = std::stod( process.child( "StartX").text().get()) ;
   if ( process.child( "StartY") != nullptr  &&  process.child( "StartY").text().get() != "")                         // P02
      vdPar[1] = std::stod( process.child( "StartY").text().get()) ; 
   if ( process.child( "StartDepth") != nullptr  &&  process.child( "StartDepth").text().get() != "")                 // P03
      vdPar[2] = std::stod( process.child( "StartDepth").text().get()) ;
   if ( process.child( "Slope") != nullptr && process.child( "Slope").text().get() != "")                             // P09
      vdPar[5] = std::stod( process.child( "Slope").text().get()) ;
   if ( process.child( "HeightRefSide") != nullptr && process.child( "HeightRefSide").text().get() != "")             // P11
      vdPar[6] = std::stod( process.child( "HeightRefSide").text().get()) ;
   if ( process.child( "HeightOppSide") != nullptr && process.child( "HeightOppSide").text().get() != "")             // P12
      vdPar[7] = std::stod( process.child( "HeightOppSide").text().get()) ;
   if ( process.child( "Length") != nullptr && process.child( "Length").text().get() != "")                           // P09
      vdPar[9] = std::stod( process.child( "Length").text().get()) ;

   string sShape = process.child( "Shape").text().get() ;                                                             // P14
   if ( sShape == "european" || sShape == "")   
      vdPar[8] = 0 ;
   else if ( sShape == "american")
      vdPar[8] = 1 ;  
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Tyrolean Dovetail Shape unknown") ;
      return false ;
   }

   string sLapPosition = process.child( "LapPosition").text().get() ;
   if ( sLapPosition == "refedge" || sLapPosition == "")   
      vdPar[3] = 1 ;
   else if ( sLapPosition == "oppedge")
      vdPar[3] = 0 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Dovetail LapPosition unknown") ;
      return false ;
   }

   string sLapExit = process.child( "LapExit").text().get() ;                                                         // P05
   if ( sLapExit == "none")   
      vdPar[4] = 0 ;
   else if ( sLapExit == "mitre" || sLapExit == "")
      vdPar[4] = -1 ;
   else if ( sLapExit == "rebate") {
      if ( process.child( "RebateLength") != nullptr)
         vdPar[4] = std::stod( process.child( "RebateLength").text().get()) ;
      else 
         vdPar[4] = 10.0 ; // valore di default
   }
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Tyrolean Dovetail LapExit unknown") ;
      return false ;
   }

   string sProcessSide = process.child( "ProcessSide").text().get() ;                                                 // P16
   if ( sProcessSide == "both" || sProcessSide == "")   
      vdPar[10] = 0 ;
   else if ( sProcessSide == "refside")
      vdPar[10] = 1 ;
   else if ( sProcessSide == "oppside")
      vdPar[10] = 2 ;
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Tyrolean Dovetail Shape unknown") ;
      return false ;
   }     

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadFreeContourParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                   INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar, int& curve_counter) 
{
  // Identifico il processo con sigle usate nel btl
   nProc = 250 ;
   nSide = process.attribute( "ReferencePlaneID").as_int() ;
   string sToolPosition = process.attribute( "ToolPosition").value() ;      

   if ( sToolPosition == "left")
      nGroup = 3 ;
   else if (sToolPosition == "center")
      nGroup = 0 ;
   else if (sToolPosition == "right")
      nGroup = 4 ;  
   else {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: Free Contour group not defined") ;
      return false ;
   }

  // Inizializzo i vettori dei parametri
   for ( pugi::xml_node_iterator it = process.begin() ; it != process.end() ; it ++ ){

     // Reinizializzo i contenitori dei parametri
      vnDPar.clear() ; nSPar = 0 ; vdPar.clear() ; sPar.clear() ;
      bool bParamsInfoOk = m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ;
      if ( ! bParamsInfoOk) {
         LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: BtlGeom.GetProcessParamInfos") ;
         return false ;
      }
      if ( vdPar.size() != 11) {
         LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: FreeContour number of parameters is wrong") ;
         return false ;
      }

      string sCounterSink = process.attribute( "CounterSink").value() ;
      if ( sCounterSink == "yes")
         vdPar[5] = 1 ;
      else if ( sCounterSink == "no")
         vdPar[5] = 0 ;
      else {
         LOG_ERROR( GetEExLogger(), "  Error reading Part Processing: FreeContour CounterSink is wrong") ;
         return false ;      
      }

     // Studio i nodi 
      string itName = it->name() ;
      bool bContOk = true ;
      if ( itName == "Contour") {
         bContOk = ReadSContourParams( *it, 0, 0, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar, curve_counter) ;
         if ( ! bContOk) 
            return false ;        
      }
      else if ( itName == "DualContour") {
         bContOk = ReadDContourParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar, curve_counter) ;
         if ( ! bContOk) 
            return false ;
      }
      else {
         LOG_ERROR ( GetEExLogger(), "  Error reading Part Processing: FreeContour type is wrong") ;
         return false ;
      }
   }

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadSContourParams( pugi::xml_node process, int nType, int nOtherId, int& nGroup, int& nProc, int& nSide,
                                INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, string& sPar, int& curve_counter) 
{
  // Parametri propri del contour che non cambiano 
   string sDepthBounded = process.attribute( "DepthBounded").value() ;
   if ( sDepthBounded == "no")
      vdPar[3] = 0 ;
   else 
      vdPar[3] = process.attribute( "Depth").as_double() ;

   int contour_counter = 0 ;
   for ( pugi::xml_node_iterator it = process.begin() ; it != process.end() ; it++)
      contour_counter ++ ;

   int i = 0 ;

   for ( pugi::xml_node_iterator it = process.begin() ; it != process.end() ; it++) {

     // Reinizializzo i parametri 
      vdPar[0] = 0.0 ; vdPar[1] = 0.0 ; vdPar[2] = 0.0 ; vdPar[6] = 0.0 ; vdPar[8] = 0.0 ; vdPar[9] = 0.0 ; vdPar[10] = 0.0 ;
      vdPar[4] = process.attribute( "Inclination").as_double() ;

      i++ ;
      if ( i != contour_counter)
         vdPar[7] = curve_counter + 1 ;
      else
         vdPar[7] = 0 ;

      string sName = it->name() ;

     // START POINT
      if ( sName == "StartPoint") {
         vdPar[6] = nType ;

         if ( nType == 100  ||  nType == 101) {      // salvo id del contour associato
            vdPar[4] = nOtherId ;
         }

         if ( it->attribute( "X") == nullptr || it->attribute( "Y") == nullptr || it->attribute( "Z") == nullptr){
            LOG_ERROR( GetEExLogger(), "  Error reading Part Process: FreeContour Contour StartPoint component missing") ;
            return false ;
         }
         vdPar[0] = it->attribute( "X").as_double() ;
         vdPar[1] = it->attribute( "Y").as_double() ;
         vdPar[2] = it->attribute( "Z").as_double() ;              
      }

     // LINE
      else if ( sName == "Line") {
         vdPar[6] = 1 ;

         if ( it->child( "EndPoint") == nullptr){
            LOG_ERROR( GetEExLogger(), "  Error reading Part Process: FreeContour Contour Line EndPoint missing") ;
            return false ;
         }
         if ( it->child( "EndPoint").attribute( "X") == nullptr ||it->child( "EndPoint").attribute( "Y") == nullptr || 
            it->child( "EndPoint").attribute( "Z") == nullptr){
            LOG_ERROR( GetEExLogger(), "  Error reading Part Process: FreeContour Contour Line EndPoint component missing") ;
            return false ;
         }
         vdPar[0] = it->child( "EndPoint").attribute( "X").as_double() ;
         vdPar[1] = it->child( "EndPoint").attribute( "Y").as_double() ;
         vdPar[2] = it->child( "EndPoint").attribute( "Z").as_double() ;
      }

     // ARC
      else if ( sName == "Arc") {
         vdPar[6] = 2 ;

         if ( it->child( "EndPoint") == nullptr  ||  it->child( "PointOnArc") == nullptr) {
            LOG_ERROR( GetEExLogger(), "  Error reading Part Process: FreeContour Contour Arc EndPoint missing") ;
            return false ;
         }
         if ( it->child( "EndPoint").attribute( "X") == nullptr  ||
            it->child( "EndPoint").attribute( "Y") == nullptr  || 
            it->child( "EndPoint").attribute( "Z") == nullptr) {
            LOG_ERROR( GetEExLogger(), "  Error reading Part Process: FreeContour Contour Arc end point component missing") ;
            return false ;
         }
         vdPar[0] = it->child( "EndPoint").attribute( "X").as_double() ;
         vdPar[1] = it->child( "EndPoint").attribute( "Y").as_double() ;
         vdPar[2] = it->child( "EndPoint").attribute( "Z").as_double() ;

         if ( it->child( "PointOnArc").attribute( "X") == nullptr ||
            it->child( "PointOnArc").attribute( "Y") == nullptr || 
            it->child( "PointOnArc").attribute( "Z") == nullptr) {
            LOG_ERROR( GetEExLogger(), "  Error reading Part Process: FreeContour Contour Arc component missing") ;
            return false ;
         }
         vdPar[8] = it->child( "PointOnArc").attribute( "X").as_double() ;
         vdPar[9] = it->child( "PointOnArc").attribute( "Y").as_double() ;
         vdPar[10] = it->child( "PointOnArc").attribute( "Z").as_double() ;

      }
      else {
         LOG_ERROR ( GetEExLogger(), "  Error reading Part Process: FreeContour Contour element unknown") ;
         return false ;
      }

      Frame3d frRef ;
     // Se riferimento non è una delle facce, lo cerco fra UserReferencePlanes
      if ( nSide < BTL_SIDE_FRONT  ||  nSide > BTL_SIDE_RIGHT) {
        // se non esiste, errore
         if ( MapURefPlanes.find( nSide) == MapURefPlanes.end()) {
            LOG_ERROR( GetEExLogger(), "  Error reading Part Process: FreeContour Contour Reference Plane unknown") ;
            return false ;
         }
         frRef = MapURefPlanes[nSide] ;      
      }

      string sDes ;
      STRVECTOR vsUAtt ;

      bool bProcessOk = m_BtlGeom.AddProcess( nGroup, nProc, nSide, sDes, curve_counter, frRef, vnDPar, nSPar, vdPar, sPar, vsUAtt, 0) ;
      if ( ! bProcessOk) {
         LOG_ERROR( GetEExLogger(), "  Error reading Part Process: BtlGeom.AddProcess error") ;
         return false ;
      }
      curve_counter ++ ;
   }

   return true ;
}

//---------------------------------------------------------------------------------------------------------------------------
bool 
ImportBtlx::ReadDContourParams( pugi::xml_node process, int& nGroup, int& nProc, int& nSide, 
                                INTVECTOR& vnDPar, int& nSPar, DBLVECTOR& vdPar, std::string& sPar, int& curve_counter) 
{
   if ( process.child( "PrincipalContour") == nullptr  ||  process.child( "AssociatedContour") == nullptr) {
      LOG_ERROR( GetEExLogger(), "  Error reading Part Process: DualContour contour missing") ;
      return false ;
   }

  // Principal Contour
   int nPrincipalId = curve_counter + 1 ;
   int nPrincipalContCurves = 0 ;

  // conto il numero di curve nel PrincipalContour
   for ( pugi::xml_node_iterator it = process.child( "PrincipalContour").child( "Contour").begin() ;
      it != process.child( "PrincipalContour").child( "Contour").end() ; it ++)
      nPrincipalContCurves ++ ;

   bool bContourOk = ReadSContourParams( process.child( "PrincipalContour"), 100, curve_counter + nPrincipalContCurves,
      nGroup, nProc, nSide, vnDPar, nSPar,vdPar, sPar, curve_counter) ;
   if ( ! bContourOk)
      return false ;      

  // Associated Contour   
   bContourOk = ReadSContourParams( process.child( "AssociatedContour"), 101, nPrincipalId,
      nGroup, nProc, nSide, vnDPar, nSPar,vdPar, sPar, curve_counter) ;
   if ( ! bContourOk)
      return false ;

   return true ;
}