Egalware/EgtExchange
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
bc286fd2ed686d36ab59e65a5785dca11e3942e2
EgtExchange/ImportBtlxProc.cpp
T
Sara Perdoncin eb5a141e44 EgtExchange 2.3a6 : 
- in import BTLX gestione di shape
- in import BTLX correzione di errori nella lettura delle lavorazioni
- in import BTLX importazione di tutti i dati generici dei pezzi
- unificazione delle funzioni BTL e BTLX per aggiungere tenoni e mortase.
2021-01-25 08:32:37 +00:00

2808 lines
152 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
// 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 ;
}
Reference in New Issue View Git Blame Copy Permalink