//--------------------------------------------------------------------------- // 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" #include "/EgtDev/Include/EgtStringConverter.h" using namespace std ; //--------------------------------------------------------- STRVECTOR ProjectAttributes = { "Architect", "Comment", "Customer", "DeliveryDate", "Editor", "ListName", "Name", "Number", "Section", "SourceFile"} ; STRVECTOR ProjectAttributes_other = { "GUID", "ProcessingQuality", "Recess"} ; STRVECTOR PartAttributes = { "Annotation", "AssemblyNumber", "Comment", "ElementNumber", "EndOffset", "Group", "Layer", "Material", "ModuleNumber", "OrderNumber", "Package", "PlaningLength", "QualityGrade", "StartOffset", "Storey", "TimberGrade", "Weight"} ; STRVECTOR PartAttributes_other = { "Count", "Designation", "Height", "Length", "ProcessingQuality", "Recess", "SingleMemberNumber", "StoreyType", "Width"} ; STRVECTOR svMaterials{ "batten", "cladding", "massiveTimber", "membrane", "gypsumBoard", "gypsumFibre", "insulation", "sheetComponent", "facadePanel", "profiledPanel", "plaster"} ; //---------------------------------------------------------------------------- IImportBtlx* CreateImportBtlx( void) { // verifico la chiave e le opzioni if ( ! VerifyKey( KEYOPT_EEX_INPADV)) return nullptr ; // creo l'oggetto return static_cast ( new(nothrow) ImportBtlx) ; } //---------------------------------------------------------------------------- ImportBtlx::ImportBtlx( void) { } //---------------------------------------------------------------------------- bool ImportBtlx::Import( const string& sFile, IGeomDB* pGDB, int nFlag) { // log di informazioni LOG_INFO( GetEExLogger(), ( "ImportBtlx : " + sFile).c_str()) ; // inizializzo il gestore geometria pezzi Btl int nFlatVertPos = 0 ; if (( nFlag & EIBFLAG_OUTL_FLAT_POS) != 0) nFlatVertPos = 4 ; else if (( nFlag & EIBFLAG_TS3_POS) != 0) nFlatVertPos = 3 ; else if (( nFlag & EIBFLAG_FLAT_POS) != 0) nFlatVertPos = 1 ; else if (( nFlag & EIBFLAG_VERT_POS) != 0) nFlatVertPos = 2 ; bool bSpecialTrim = (( nFlag & EIBFLAG_SPECIAL_TRIM) != 0) ; bool bTrimWithOutline = (( nFlag & EIBFLAG_TRIM_WITH_OUTLINE) != 0) ; bool bUseUAttr = (( nFlag & EIBFLAG_USEUATTR) != 0) ; if ( ! m_BtlGeom.Init( pGDB, nFlatVertPos, bSpecialTrim, bTrimWithOutline, bUseUAttr)) { LOG_ERROR( GetEExLogger(), " Error on BtlGeom.Init") ; return false ; } // scrivo nel progetto path del file m_BtlGeom.SetUserAttribute( UATD_INFO, IKEY_BTL_PATH + ":" + sFile) ; // inizializzo il documento pugi::xml_document doc ; pugi::xml_parse_result ParseResult = doc.load_file( stringtoW( sFile)) ; if ( ! ParseResult) { string sError = " Error parsing file : " ; sError += ParseResult.description() ; LOG_ERROR( GetEExLogger(), sError.c_str()) ; return false ; } // ------------- Nodo BTLX --------------------------------- pugi::xml_node rootNode = doc.first_child() ; string sLanguage = rootNode.attribute( "Language").value() ; if ( sLanguage != "") m_BtlGeom.SetUserAttribute( UATD_INFO, "Language", rootNode.attribute( "Language").value()) ; if ( rootNode.attribute( "Version") == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading BTLX : unknown version of BTLX") ; return false ; } m_sVersion = rootNode.attribute( "Version").value() ; // ---------- Nodo FileHistory -------------------------------- pugi::xml_node fileHistory = rootNode.child( "FileHistory") ; if ( fileHistory != nullptr) if ( ! ReadFileHistory( fileHistory)) return false ; // ----------- Nodo Project ---------------------------------------- pugi::xml_node projectNode = rootNode.child( "Project") ; if ( projectNode == nullptr) { LOG_ERROR( GetEExLogger(), "Error Reading BTLX: no Project") ; return false ; } // Lettura attributes if ( ! ReadProjectAttributes( projectNode.first_attribute())) return false ; // Analisi dei sottonodi int counter_parts = 0 ; // conto i pezzi del progetto for ( pugi::xml_node_iterator itProject = projectNode.begin() ; itProject != projectNode.end() ; ++itProject) { std::string child_name = itProject->name() ; bool bReadOk = true ; if ( child_name == "Parts") { for ( pugi::xml_node_iterator itParts = itProject->begin() ; itParts != itProject->end() ; ++itParts) { counter_parts ++ ; bReadOk = ReadPart( *itParts) ; if ( ! bReadOk) return false ; } } else if ( child_name == "UserAttributes") { bReadOk = ReadUserAttributes( *itProject, 0) ; if ( ! bReadOk) return false ; } else if ( child_name == "Rawparts") { ///////// } else if ( child_name == "Composites") { ////////// } else { LOG_ERROR( GetEExLogger(), " Error Reading Project : unknown node") ; } } if ( counter_parts == 0){ LOG_ERROR( GetEExLogger(), " Error Reading Project: no Parts") ; return false ; } return true ; } //----------------------------------------------------------------- bool ImportBtlx::ReadFileHistory( pugi::xml_node node) { // Scorro tutti i sottonodi for ( pugi::xml_node_iterator it = node.begin() ; it != node.end() ; it ++) { string sName, sName2, sValue ; string sNodeName = it->name() ; // salvo gli attributes for ( pugi::xml_attribute attr = it->first_attribute() ; attr ; attr = attr.next_attribute()) { sName = attr.name() ; sValue = attr.value() ; if ( sName != "" && sValue != "") { if ( sNodeName == "InitialExportProgram") sName2 = "InitialExport - " + sName ; else if (sNodeName == "EditingProgram") sName2 = "Editing - " + sName ; else { LOG_ERROR( GetEExLogger(), " Error Reading File History: unknown node") ; return false ; } bool bAddOk = m_BtlGeom.SetUserAttribute( UATD_INFO, sName2, sValue) ; if ( ! bAddOk){ LOG_ERROR( GetEExLogger(), " Error Reading File History: m_BtlGeom.SetUserAttribute error") ; return false ; } } } } return true ; } //----------------------------------------------------------------- bool ImportBtlx::ReadProjectAttributes( pugi::xml_attribute attr) { // Scorro tutti gli attributes while ( attr) { bool bAddOk = true ; string sName = attr.name() ; string sValue = attr.value() ; if ( find( ProjectAttributes.begin(), ProjectAttributes.end(), sName) != ProjectAttributes.end()) { if ( sValue != "") // aggiungo solo se non è vuoto bAddOk = m_BtlGeom.SetUserAttribute( UATD_INFO, attr.name(), attr.value()) ; } // Tratto gli attributes che necessitano di check sui valori : else if ( find( ProjectAttributes_other.begin(), ProjectAttributes_other.end(), sName) != ProjectAttributes_other.end()) { if ( sName == "GUID") { if ( CheckGuid( attr.value())) bAddOk = m_BtlGeom.SetUserAttribute( UATD_INFO, attr.name(), attr.value()) ; else LOG_ERROR( GetEExLogger(), " Error reading Project : GUID wrong") ; } else if ( sName == "ProcessingQuality") { if ( sValue == "automatic" || sValue == "fast" || sValue == "visible") bAddOk = m_BtlGeom.SetUserAttribute( UATD_INFO, attr.name(), attr.value()) ; else { LOG_ERROR( GetEExLogger(), " Error reading Project : unknown ProcessingQuality attribute value") ; return false ; } } else if ( sName == "Recess") { if ( sValue == "automatic" || sValue == "manual") bAddOk = m_BtlGeom.SetUserAttribute( UATD_INFO, attr.name(), attr.value()) ; else { LOG_ERROR( GetEExLogger(), " Error reading Project : unknown Recess attribute value") ; return false ; } } } else { string error = " Warning reading Project : " + sName + " attribute is unknown" ; LOG_ERROR( GetEExLogger(), error.c_str()) ; } if ( ! bAddOk){ LOG_ERROR( GetEExLogger(), " Error reading Project : BtlGeom.SetUserAttribute error") ; return false ; } attr = attr.next_attribute() ; } return true ; } //----------------------------------------------------------- bool ImportBtlx::ReadUserAttributes(pugi::xml_node node, int caller, std::vector * pvsAttr) { bool bAddOk = true ; for ( pugi::xml_node_iterator it = node.begin() ; it != node.end() ; it ++){ // verifico che abbia i due attributi richiesti if ( it->attribute( "Name") == nullptr || it->attribute( "Value") == nullptr) LOG_ERROR( GetEExLogger(), " Error reading UserAttribute : missing required attribute") ; string sName = it->attribute( "Name").value() ; string sValue = it->attribute( "Value").value() ; if ( sName == "" || sValue == ""){ LOG_ERROR( GetEExLogger(), " Error reading UserAttribute : attribute is empty") ; return false ; } if ( caller == 0) // chiamata dal nodo project bAddOk = m_BtlGeom.SetUserAttribute( UATD_INFO, sName, sValue) ; else if ( caller == 1) // chiamata dal nodo part bAddOk = m_BtlGeom.SetUserAttribute( UATD_PART, sName, sValue) ; else if ( caller == 2) { // chiamata da processing if ( pvsAttr == nullptr) LOG_ERROR( GetEExLogger(), " Error reading UserAttribute : missing UserAttribute vector") else pvsAttr->emplace_back( sName + ":" + sValue) ; } if ( ! bAddOk) LOG_ERROR( GetEExLogger(), " Error reading UserAttribute : BtlGeom.SetUserAttribute error" ) ; } return true ; } //------------------------------------------------------------------------------------ bool ImportBtlx::ReadPart( pugi::xml_node node) { // Creo la parte nel BTLGeom if ( ! m_BtlGeom.CreatePart()) { LOG_ERROR( GetEExLogger(), " Error reading Part : m_BtlGeom.CreatePart error") ; return false ; } // Analisi Attributes bool bAttrOk = ReadPartAttributes( node.first_attribute()) ; if ( ! bAttrOk){ return false ; } // Analisi nodi for ( pugi::xml_node_iterator it = node.begin() ; it != node.end() ; it ++) { std::string name = it->name() ; // Camber if ( name == "Camber") { bool bCamberOk = ReadCamber( *it) ; if ( ! bCamberOk) return false ; } // Alignment else if ( name == "Alignment") { bool bAlignmentOk = ReadAlignment( *it) ; if ( ! bAlignmentOk) return false ; } // PartOffset else if ( name == "PartOffset") { bool bPartOffsetOk = ReadPartOffset( *it) ; if ( ! bPartOffsetOk) return false ; } // UserAttributes else if ( name == "UserAttributes") { bool bUserAttrOk = ReadUserAttributes( *it, 1) ; if ( ! bUserAttrOk) return false ; } // Processings else if ( name == "Processings") { bool bProcOk = ReadProcessings( *it) ; if ( ! bProcOk) return false ; } // Colour else if ( name == "Colour") { Color colRes ; // Controllo ci siano tutti i required attributes if ( it->attribute( "Red") == nullptr || it->attribute( "Green") == nullptr || it->attribute( "Blue") == nullptr || it->attribute( "Transparency") == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part Color: attribute missing") ; return false ; } int nRed = Clamp( it->attribute( "Red").as_int(), 0, 255) ; int nGreen = Clamp( it->attribute( "Green").as_int(), 0, 255) ; int nBlue = Clamp( it->attribute( "Blue").as_int(), 0, 255) ; int nAlpha = Clamp( it->attribute( "Transparency").as_int(), 0, 255) ; nAlpha = nAlpha * 100 / 255 ; // va scalato su 100 non su 255 colRes.Set( nRed, nGreen, nBlue, nAlpha) ; bool bAddOk = m_BtlGeom.SetUserAttribute( UATD_PART, name, ToString( colRes)) ; if ( ! bAddOk){ LOG_ERROR( GetEExLogger(), " Error reading Part Color : m_BtlGeom.SetUserAttribute error") ; return false ; } } // Transformations else if ( name == "Transformations") { // Leggo tutte le trasformazioni for ( pugi::xml_node_iterator itTransf = it->begin() ; itTransf != it->end() ; itTransf ++) { string sNameTransf = itTransf->name() ; if ( sNameTransf != "Transformation") { LOG_ERROR( GetEExLogger(), " Error reading Part Transformation : unknown transformation child") ; return false ; } bool bTransfOk = ReadTransformation( *itTransf) ; if ( ! bTransfOk) return false ; } } // Outlines else if ( name == "Outlines") { int outline_counter = 0 ; string sOutlineName ; // Analizzo tutti gli outlines for ( pugi::xml_node_iterator itOutline = it->begin() ; itOutline != it->end() ; itOutline++) { if ( outline_counter > 3) { // possono essere massimo 3 LOG_ERROR( GetEExLogger(), " Error reading Part Outline: more than 3 outlines") ; return false ; } sOutlineName = itOutline->name() ; if ( sOutlineName != "Outline") { LOG_ERROR( GetEExLogger(), " Error reading Part Outline: unknown child") ; return false ; } bool bOutlineOk = ReadOutline( *itOutline) ; if ( ! bOutlineOk) return false ; outline_counter ++ ; } } // UserReferencePlane else if ( name == "UserReferencePlanes") { for ( pugi::xml_node_iterator itURefPlanes = it->begin() ; itURefPlanes != it->end() ; itURefPlanes ++ ) { string nameURefPlanes = itURefPlanes->name() ; if ( nameURefPlanes != "UserReferencePlane") { LOG_ERROR( GetEExLogger(), " Error reading Part : unknown UserPlane child") ; return false ; } bool bRefPlane = ReadUserReferencePlane( *itURefPlanes) ; if ( ! bRefPlane) return false ; } } // GrainDirection else if ( name == "GrainDirection") { Vector3d vtDir ; if ( it->attribute( "X") == nullptr || it->attribute( "Y") == nullptr || it->attribute( "Z") == nullptr || it->attribute( "Align") == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part : GrainDirection attribute missing") ; return false ; } vtDir.x = it->attribute( "X").as_double() ; vtDir.y = it->attribute( "Y").as_double() ; vtDir.z = it->attribute( "Z").as_double() ; string sAlign = it->attribute( "Align").value() ; if ( sAlign == "yes") sAlign = "1" ; else if ( sAlign == "no") sAlign = "0" ; else { LOG_ERROR( GetEExLogger(), " Error reading Part : GrainDirection align is unknown") ; return false ; } bool bAddOk = m_BtlGeom.SetUserAttribute( UATD_PART, "GRAINDIRECTION", ToString( vtDir) + ";" + sAlign) ; if ( ! bAddOk){ LOG_ERROR( GetEExLogger(), " Error reading Part GrainDirection : m_BtlGeom.SetUserAttribute error") ; return false ; } } // MaterialClass else if ( name == "MaterialClass") { string sMaterial = it->attribute( "Group").value() ; string sSpecification = it ->attribute( "Specification").value() ; if ( find( svMaterials.begin(), svMaterials.end(), sMaterial) == svMaterials.end()) { LOG_ERROR( GetEExLogger(), " Error reading Part : MaterialClass group is unknown") ; return false ; } bool bAddOk = false ; if ( sSpecification != "") bAddOk = m_BtlGeom.SetUserAttribute( UATD_PART, "MATERIALTYPE", sMaterial + ": " + sSpecification) ; else bAddOk = m_BtlGeom.SetUserAttribute( UATD_PART, "MATERIALTYPE", sMaterial) ; if ( ! bAddOk){ LOG_ERROR( GetEExLogger(), " Error reading Part : m_BtlGeom.SetUserAttribute error") ; return false ; } } // UserAttribute else if ( name == "UserAttribute") { if ( it->attribute( "Name") == nullptr || it->attribute( "")== nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part : UserAttribute attribute missing") ; return false ; } string sName = it->attribute( "Name").value() ; string sValue = it ->attribute( "Value").value() ; bool bAddOk = true ; if ( sName != "" && sValue != "") bAddOk = m_BtlGeom.SetUserAttribute( UATD_PART, sName, sValue) ; if ( ! bAddOk){ LOG_ERROR( GetEExLogger(), " Error reading Part : m_BtlGeom.SetUserAttribute error") ; return false ; } } // ReferenceSide else if ( name == "ReferenceSide") { // Controllo ci siano i required attributes if ( it->attribute( "Side") == nullptr || it->attribute( "Align") == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part : ReferenceSide attribute missing") ; return false ; } // Controllo che i valori siano sensati int nSide = it->attribute( "Side").as_int() ; if ( nSide < 1 || nSide > 4){ LOG_ERROR( GetEExLogger(), " Error reading Part : ReferenceSide Side not valid") ; return false ; } string sAlign = it->attribute( "Align").value() ; if ( sAlign == "yes" ) sAlign = "1" ; else if ( sAlign == "no") sAlign = "0" ; else { LOG_ERROR( GetEExLogger(), " Error reading Part : ReferenceSide Align not valid") ; return false ; } bool bAddOk = m_BtlGeom.SetUserAttribute( UATD_PART, "REFERENCESIDE", to_string( nSide) + ";" + sAlign) ; if ( ! bAddOk) { LOG_ERROR( GetEExLogger(), " Error reading Part : m_BtlGeom.SetUserAttribute error") ; return false ; } } // Shape else if ( name == "Shape") { if ( ! ReadShape( *it)) return false ; } } // inserisco eventuali contorni liberi if ( ! m_BtlGeom.CreateFreeContours()) { LOG_ERROR ( GetEExLogger(), " Error reading Part : BtlGeom.CreateFreeContours()") ; return false ; } // Outline bool bOutLineOk = m_BtlGeom.UpdateOutLine() ; if ( ! bOutLineOk ){ LOG_ERROR( GetEExLogger(), " Error reading Part : BtlGeom.UpdateOutLine error") ; m_BtlGeom.ErasePart() ; return false ; } return true ; } //----------------------------------------------------------------------------- bool ImportBtlx::ReadPartAttributes( pugi::xml_attribute attr) { bool bLength = false, bWidth = false, bHeight = false ; double dLength, dWidth, dHeight ; // scorro tutti gli attributes while ( attr) { bool bAddOk = true ; string name = attr.name() ; string value = attr.value() ; if ( find( PartAttributes.begin(), PartAttributes.end(), name) != PartAttributes.end()) { if ( value != "") // aggiungo solo se non è vuoto bAddOk = m_BtlGeom.SetUserAttribute( UATD_PART, attr.name(), attr.value()) ; } else if ( find( PartAttributes_other.begin(), PartAttributes_other.end(), name) != PartAttributes_other.end()) { if ( name == "Count") m_BtlGeom.SetPartCount( attr.as_int()) ; else if ( name == "Designation") m_BtlGeom.SetPartName( value) ; else if ( name == "SingleMemberNumber") m_BtlGeom.SetPartProdNbr( attr.as_int()) ; else if ( name == "Length") { dLength = attr.as_double() ; bLength = true ; } else if ( name == "Width") { dWidth = attr.as_double() ; bWidth = true ; } else if ( name == "Height") { dHeight = attr.as_double() ; bHeight = true ; } else if ( name == "ProcessingQuality") { if ( value == "automatic" || value == "fast" || value == "visible") bAddOk = m_BtlGeom.SetUserAttribute( UATD_PART, attr.name(), attr.value()) ; else { LOG_ERROR( GetEExLogger(), " Error reading Part : unknown ProcessingQuality attribute value") ; return false ; } } else if ( name == "Recess") { if ( value == "automatic" || value == "manual") bAddOk = m_BtlGeom.SetUserAttribute( UATD_PART, attr.name(), attr.value()) ; else { LOG_ERROR( GetEExLogger(), " Error reading Part : unknown Recess attribute value") ; return false ; } } else if ( name == "StoreyType") { if ( value == "" || value == "ceiling" || value == "roof" || value == "wall") bAddOk = m_BtlGeom.SetUserAttribute( UATD_PART, attr.name(), attr.value()) ; else { LOG_ERROR( GetEExLogger(), " Error reading Part : unknown StoreyType attribute value") ; return false ; } } } else { LOG_ERROR( GetEExLogger(), " Error reading Part : unknown attribute") ; } if ( ! bAddOk){ LOG_ERROR( GetEExLogger(), " Error reading Part : BtlGeom.SetUserAttribute error") ; return false ; } attr = attr.next_attribute() ; } // Creo il box if ( bLength && bWidth && bHeight) { if ( ! m_BtlGeom.AddPartBox( dLength, dHeight, dWidth)) { LOG_ERROR( GetEExLogger(), " Error reading Part : BtlGeom.AddPartBox error") ; return false ; } } else { LOG_ERROR( GetEExLogger(), " Error reading Part : no box") ; m_BtlGeom.ErasePart() ; return false ; } return true ; } //-------------------------------------------------------------------- bool ImportBtlx::ReadCamber( pugi::xml_node node) { bool bAddOk = false ; string sValue, sVal ; sVal = node.attribute( "ReferencePlaneID").value() ; if ( sVal == "") { LOG_ERROR( GetEExLogger(), " Error reading Part camber : Reference Plane missing") ; return false ; } sValue = "SIDE:" + sVal ; sVal = node.attribute( "StartingPoint").value() ; if ( sVal == "") { LOG_ERROR( GetEExLogger(), " Error reading Part camber : StartingPoint missing") ; return false ; } sValue += " P01:" + sVal ; sVal = node.attribute( "EndPoint").value() ; if ( sVal == "") { LOG_ERROR( GetEExLogger(), " Error reading Part camber : EndPoint missing") ; return false ; } sValue += " P02:" + sVal ; sVal = node.attribute( "CamberPoint").value() ; if ( sVal == "") { LOG_ERROR( GetEExLogger(), " Error reading Part camber : CamberPoint missing") ; return false ; } sValue += " P03:" + sVal ; sVal = node.attribute( "Camber").value() ; if ( sVal == "") { LOG_ERROR( GetEExLogger(), " Error reading Part camber : Camber missing") ; return false ; } sValue += " P04:" + sVal ; bAddOk = m_BtlGeom.SetUserAttribute( UATD_PART, "CAMBER", sValue) ; if ( ! bAddOk) { LOG_ERROR( GetEExLogger(), " Error reading Part camber : m_BtlGeom.SetUserAttribute error") ; return false ; } return true ; } //-------------------------------------------------------------------- bool ImportBtlx::ReadAlignment( pugi::xml_node node) { // Controllo che ci siano tutti gli attributes string sValue ; string sLocation = node.attribute( "Location").value() ; string sEndType = node.attribute( "Endtype").value() ; // Location Type if ( sLocation == "") { LOG_ERROR( GetEExLogger(), " Error reading Part Alignment: LocationType missing") ; return false ; } else if ( sLocation == "bottomRail") sValue = "BR: " ; else if ( sLocation == "topRail") sValue = "TR: " ; else if ( sLocation == "bottomRailAngled") sValue = "BA: " ; else if ( sLocation == "topRailAngled") sValue = "TA: " ; else if ( sLocation == "horizontalComponent") sValue = "HC: " ; else if ( sLocation == "verticalComponent") sValue = "VC: " ; else if ( sLocation == "angledComponent") sValue = "AC: " ; else { LOG_ERROR( GetEExLogger(), " Error reading Part Alignment: LocationType unknown") ; return false ; } // EndType if ( sEndType == "") { LOG_ERROR( GetEExLogger(), " Error reading Part Alignment: EndType missing") ; return false ; } else if ( sEndType == "rectangularCut") sValue += "R" ; else if ( sEndType == "angledCut") sValue += "A" ; else if ( sEndType == "doubleCut") sValue += "D" ; else { LOG_ERROR( GetEExLogger(), " Error reading Part Alignment: Endtype unknown") ; return false ; } bool bAddOk = m_BtlGeom.SetUserAttribute( UATD_PART, "ALIGNMENT", sValue) ; if ( ! bAddOk) { LOG_ERROR( GetEExLogger(), " Error reading Part camber : m_BtlGeom.SetUserAttribute error") ; return false ; } return true ; } //------------------------------------------------------------------- bool ImportBtlx::ReadPartOffset( pugi::xml_node node) { string sValue ; // controllo ci siano i required attributes: if ( node.attribute( "FlushSide") == nullptr ) { LOG_ERROR( GetEExLogger(), " Error reading Part PartOffset : flush side missing") ; return false ; } // Controllo sui valori : if ( node.attribute( "FlushSide").as_int() > 4 || node.attribute( "FlushSide").as_int() < 1) { LOG_ERROR( GetEExLogger(), " Error reading Part PartOffset : flush side value is wrong") ; return false ; } sValue = "P04:" + to_string( node.attribute( "FlushSide").as_int()) ; sValue += " P11:" + to_string( node.attribute( "OffsetSide1").as_double()) ; sValue += " P12:" + to_string( node.attribute( "OffsetSide2").as_double()) ; sValue += " P13:" + to_string( node.attribute( "OffsetSide3").as_double()) ; sValue += " P14:" + to_string( node.attribute( "OffsetSide4").as_double()) ; bool bAddOk = m_BtlGeom.SetUserAttribute( UATD_PART, "PARTOFFSET", sValue) ; if ( ! bAddOk){ LOG_ERROR( GetEExLogger(), " Error reading Part Color : m_BtlGeom.SetUserAttribute error") ; return false ; } return true ; } //-------------------------------------------------------------------- bool ImportBtlx::ReadTransformation( pugi::xml_node node) { Frame3d frRef; string guid ; // ID if (node.attribute( "GUID") == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part Transformation : GUID missing") ; return false ; } if ( CheckGuid (node.attribute( "GUID").value())) guid = node.attribute( "GUID").value() ; else { LOG_ERROR( GetEExLogger(), " Error reading Part Transformation : GUID wrong") ; return false ; } // Origine pugi::xml_node origin = node.child( "Position").child( "ReferencePoint") ; if ( origin == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part Transformation : Origin missing") ; return false ; } if ( origin.attribute( "X") == nullptr || origin.attribute( "Y") == nullptr || origin.attribute( "Z") == nullptr){ LOG_ERROR( GetEExLogger(), " Error reading Part Transformation : Origin component missing") ; return false ; } Point3d ptO( origin.attribute( "X").as_double(), origin.attribute( "Y").as_double(), origin.attribute( "Z").as_double()) ; // Asse X pugi::xml_node axisX = node.child( "Position").child( "XVector") ; if ( axisX == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part Transformation : X axis missing") ; return false ; } if ( axisX.attribute( "X") == nullptr || axisX.attribute( "Y") == nullptr || axisX.attribute( "Z") == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part Transformation : X axis component missing") ; return false ; } Vector3d vtX( axisX.attribute( "X").as_double(), axisX.attribute( "Y").as_double(), axisX.attribute( "Z").as_double()) ; // Asse Y pugi::xml_node axisY = node.child( "Position").child( "YVector") ; if ( axisY == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part Transformation : Y axis missing") ; return false ; } if ( axisY.attribute( "X") == nullptr || axisY.attribute( "Y") == nullptr || axisY.attribute( "Z") == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part Transformation : Y axis component missing") ; return false ; } Vector3d vtY( axisY.attribute( "X").as_double(), axisY.attribute( "Y").as_double(), axisY.attribute( "Z").as_double()) ; frRef.Set( ptO, ptO + vtX, ptO + vtY) ; bool bTransfOk = m_BtlGeom.AddPartTransformation( guid, frRef) ; if ( ! bTransfOk) { LOG_ERROR( GetEExLogger(), " Error reading Part Transformation : BtlGeom.AddPartTransformation error") ; return false ; } return true ; } //----------------------------------------------------------------------------- bool ImportBtlx::CheckGuid ( std::string s) { vector range = {'a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'} ; if ( s[0] != '{' || s[37] != '}') return false ; for ( size_t i = 1 ; i < 37 ; i++) { if ( i == 9 || i == 14 || i == 19 || i == 24) { if ( s[i] != '-') return false ; } else if ( find( range.begin(), range.end(), s[i]) == range.end()) return false ; } return true ; } //-------------------------------------------------------------------- bool ImportBtlx::ReadOutline( pugi::xml_node node) { FCEDEQUE dqFce ; STRVECTOR vsUAtt , vsUAttAperture ; if ( node.attribute( "ReferencePlaneID") == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part Outline : missing reference plane") ; return false ; } int nSide = node.attribute( "ReferencePlaneID").as_int() ; if ( node.attribute( "Process") != nullptr) { string Process = node.attribute("Process").value() ; if ( Process == "no") vsUAtt.emplace_back( "DO:0") ; } if ( node.child( "Contour") == nullptr && node.child( "DualContour") == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part Outline : no contour is defined") ; return false ; } for ( pugi::xml_node_iterator it = node.begin() ; it != node.end() ; it ++) { string name = it->name() ; if ( name == "Contour" ){ dqFce.clear() ; bool bContourOk = ReadContour( *it, dqFce, FreeContourEnt::START) ; if ( ! bContourOk) return false ; bContourOk = m_BtlGeom.AddPartOutline( nSide, dqFce, 0, 0, 0.0, vsUAtt) ; if ( ! bContourOk){ LOG_ERROR( GetEExLogger(), " Error reading Part Outline : BtlGeom.AddPartOutline error") ; return false ; } } else if ( name == "DualContour") { dqFce.clear() ; bool bDualContourOk = ReadDualContour( *it, dqFce) ; if ( ! bDualContourOk) return false ; bDualContourOk = m_BtlGeom.AddPartOutline( nSide, dqFce, 0, 0, 0.0, vsUAtt) ; if ( ! bDualContourOk){ LOG_ERROR( GetEExLogger(), " Error reading Part Outline : BtlGeom.AddPartOutline error") ; return false ; } } else if ( name == "Apertures") { // analizzo tutti i sottonodi di tipo "Aperture" for ( pugi::xml_node_iterator itAperture = it->begin() ; itAperture != it->end() ; itAperture++) { string nameAperture = itAperture->name() ; if ( nameAperture != "Aperture"){ LOG_ERROR( GetEExLogger(), " Error reading Part Outline : Apertures unknown child") ; return false ; } bool bApertureOk = ReadAperture( *itAperture, nSide) ; if ( ! bApertureOk) return false ; } } else { LOG_ERROR( GetEExLogger(), " Error reading Part Outline : unknown child") ; return false ; } } return true ; } //--------------------------------------------------------------------------- bool ImportBtlx::ReadContour( pugi::xml_node node, FCEDEQUE& dqFce, FreeContourEnt::TYPE type) { Point3d PtP, PtM ; double dAng = 0.0 ; if ( node.child( "StartPoint") == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part Outline Contour: StartPoint Missing") ; return false ; } for ( pugi::xml_node_iterator it = node.begin() ; it != node.end() ; it ++) { string name = it->name() ; // Punto di inizio if ( name == "StartPoint") { if ( it->attribute( "X") == nullptr || it->attribute( "Y") == nullptr || it->attribute( "Z") == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part Outline Contour: StartPoint component missing") ; return false ; } PtP.x = node.child( "StartPoint").attribute( "X").as_double() ; PtP.y = node.child( "StartPoint").attribute( "Y").as_double() ; PtP.z = node.child( "StartPoint").attribute( "Z").as_double() ; dqFce.emplace_back( type, PtP, Point3d(), 0.0, 0, 0) ; } // Line else if ( name == "Line") { if ( it->attribute( "Inclination") == nullptr) dAng = 0.0 ; else dAng = Clamp( it->attribute( "Inclination").as_double(), -89.9, 89.9) ; if ( it->child( "EndPoint") == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part Outline 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 Outline Contour: Line component missing") ; return false ; } PtP.x = it->child( "EndPoint").attribute( "X").as_double() ; PtP.y = it->child( "EndPoint").attribute( "Y").as_double() ; PtP.z = it->child( "EndPoint").attribute( "Z").as_double() ; dqFce.emplace_back( FreeContourEnt::LINE, PtP, Point3d(), dAng, 0, 0) ; } // Arc else if ( name == "Arc") { if ( it->attribute( "Inclination") == nullptr) dAng = 0.0 ; else dAng = Clamp( it->attribute( "Inclination").as_double(), -89.9, 89.9) ; if ( it->child( "EndPoint") == nullptr || it->child( "PointOnArc") == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part Outline Contour: Arc Point 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 Outline Contour: Arc component missing") ; return false ; } PtP.x = it->child( "EndPoint").attribute( "X").as_double() ; PtP.y = it->child( "EndPoint").attribute( "Y").as_double() ; PtP.z = 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 Outline Contour: Arc component missing") ; return false ; } PtM.x = it->child( "PointOnArc").attribute( "X").as_double() ; PtM.y = it->child( "PointOnArc").attribute( "Y").as_double() ; PtM.z = it->child( "PointOnArc").attribute( "Z").as_double() ; dqFce.emplace_back( FreeContourEnt::LINE, PtP, PtM, dAng, 0, 0) ; } // Altrimenti errore else { LOG_ERROR( GetEExLogger(), " Error reading Part Outline Contour: unknown child") ; return false ; } } return true ; } //--------------------------------------------------------------------------- bool ImportBtlx::ReadDualContour( pugi::xml_node node, FCEDEQUE& dqFce) { // I due contour riempiono lo stesso vettore dqFace if ( node.child( "PrincipalContour") == nullptr || node.child( "AssociatedContour") == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part Outline : DualContour contours missing") ; return false ; } // Principal Contour bool bContourOk = ReadContour( node.child( "PrincipalContour"), dqFce, FreeContourEnt::START_CNT0) ; if ( ! bContourOk) return false ; // Associated Contour bContourOk = ReadContour( node.child( "AssociatedContour"), dqFce, FreeContourEnt::START_CNT1) ; if ( ! bContourOk) return false ; return true ; } //--------------------------------------------------------------------------- bool ImportBtlx::ReadAperture( pugi::xml_node node, int nSide) { // Attribute Aperture STRVECTOR vsUAttAperture ; if ( node.attribute( "Process") != nullptr) { string Process = node.attribute( "Process").value() ; if ( Process == "no") vsUAttAperture.emplace_back( "DO:0") ; } // ChildAperture sono i contour for ( pugi::xml_node_iterator it = node.begin() ; it != node.end() ; it++) { string name = it->name() ; if ( name == "Contour") { FCEDEQUE dqFce ; bool bContourOk = ReadContour( *it, dqFce, FreeContourEnt::START) ; if ( ! bContourOk) return false ; bContourOk = m_BtlGeom.AddPartAperture( nSide, dqFce, 0, 0, 0.0, vsUAttAperture) ; if ( ! bContourOk){ LOG_ERROR( GetEExLogger(), " Error reading Part Outline : BtlGeom.AddPartAperture error") ; return false ; } } else if ( name == "DualContour") { FCEDEQUE dqFce ; bool bDualContourOk = ReadDualContour( *it, dqFce) ; if ( ! bDualContourOk) return false ; bDualContourOk = m_BtlGeom.AddPartAperture( nSide, dqFce, 0, 0, 0.0, vsUAttAperture) ; if ( ! bDualContourOk) { LOG_ERROR( GetEExLogger(), " Error reading Part Outline : BtlGeom.AddPartAperture error") ; return false ; } } else { LOG_ERROR( GetEExLogger(), " Error reading Part Outline : Aperture child unknown") ; return false ; } } return true ; } //----------------------------------------------------------------------------- bool ImportBtlx::ReadUserReferencePlane( pugi::xml_node node) { if ( node.attribute( "ID") == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part ReferencePlane : ID missing") ; return false ; } int nId = node.attribute( "ID").as_int() ; if ( node.child( "Position") == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part ReferencePlane : Position missing") ; return false ; } Point3d ptOrig ; Vector3d vX, vY ; // Origin if ( node.child( "Position").child( "ReferencePoint") == nullptr || node.child( "Position").child( "ReferencePoint").attribute( "X") == nullptr || node.child( "Position").child( "ReferencePoint").attribute( "Y") == nullptr || node.child( "Position").child( "ReferencePoint").attribute( "Z") == nullptr ) { LOG_ERROR( GetEExLogger(), " Error reading Part ReferencePlane : ReferencePoint error") ; return false ; } ptOrig.x = node.child( "Position").child( "ReferencePoint").attribute( "X").as_double() ; ptOrig.y = node.child( "Position").child( "ReferencePoint").attribute( "Y").as_double() ; ptOrig.z = node.child( "Position").child( "ReferencePoint").attribute( "Z").as_double() ; // VectX if ( node.child( "Position").child( "XVector") == nullptr || node.child( "Position").child( "XVector").attribute( "X") == nullptr || node.child( "Position").child( "XVector").attribute( "Y") == nullptr || node.child( "Position").child( "XVector").attribute( "Z") == nullptr ) { LOG_ERROR( GetEExLogger(), " Error reading Part ReferencePlane : VectorX error") ; return false ; } vX.x = node.child( "Position").child( "XVector").attribute( "X").as_double() ; vX.y = node.child( "Position").child( "XVector").attribute( "Y").as_double() ; vX.z = node.child( "Position").child( "XVector").attribute( "Z").as_double() ; // VectY if ( node.child( "Position").child( "YVector") == nullptr || node.child( "Position").child( "YVector").attribute( "X") == nullptr || node.child( "Position").child( "YVector").attribute( "Y") == nullptr || node.child( "Position").child( "YVector").attribute( "Z") == nullptr ) { LOG_ERROR( GetEExLogger(), " Error reading Part ReferencePlane : VectorY error") ; return false ; } vY.x = node.child( "Position").child( "YVector").attribute( "X").as_double() ; vY.y = node.child( "Position").child( "YVector").attribute( "Y").as_double() ; vY.z = node.child( "Position").child( "YVector").attribute( "Z").as_double() ; Point3d ptOnX = ptOrig + 100 * vX ; Point3d ptOnY = ptOrig + 100 * vY ; Frame3d frRef ; frRef.Set( ptOrig, ptOnX, ptOnY) ; if ( ! frRef.IsValid()) { LOG_ERROR( GetEExLogger(), ( " Error reading Part Process: User Reference Plane " + to_string( nId) + " is not valid").c_str()) ; return false ; } m_mapRefPlanes.emplace( nId, frRef) ; return true ; } //------------------------------------------------------------------------ bool ImportBtlx::ReadProcessings( pugi::xml_node node) { int nProcId = 0 ; // conto le lavorazioni // Scorro tutte le lavorazioni for ( pugi::xml_node_iterator it = node.begin() ; it != node.end() ; it ++) { string sProcessName = it->name() ; int nGroup = 0 ; int nProc = 0 ; int nSide = 0 ; INTVECTOR vnDPar ; int nSPar ; DBLVECTOR vdPar ; string sPar ; Frame3d frRef ; STRVECTOR vsUAtt ; string sDes ; bool bProcessOk = false ; bool bAdd = true ; // Controllo che ci siano elementi required del tipo dei processi if ( it->attribute( "Name") == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part Processing : missing name") ; return false ; } sDes = it->attribute( "Name").value() ; // Attributi comuni a tutti i processi: for ( pugi::xml_attribute attr = it->first_attribute() ; attr ; attr = attr.next_attribute()) { string attrName = attr.name() ; string attrValue = attr.value() ; if ( attrName == "ProcessingQuality") { if ( attrValue == "automatic" || attrValue == "fast" || attrValue == "visible") vsUAtt.emplace_back( attrName + ":" + attrValue) ; else { LOG_ERROR( GetEExLogger(), " Error reading Part Processing: unknown ProcessingQuality attribute value") ; return false ; } } else if ( attrName == "Recess") { if ( attrValue == "automatic" || attrValue == "manual") vsUAtt.emplace_back( attrName + ":" + attrValue) ; else { LOG_ERROR( GetEExLogger(), " Error reading Part Procesing: unknown Recess attribute value") ; return false ; } } else if ( attrName == "Process" && attrValue != "yes") vsUAtt.emplace_back( "DO:0") ; else if (attrName == "Priority") vsUAtt.emplace_back( attrName + ":" + attrValue) ; } // Analizzo i sottonodi if ( sProcessName == "UserAttributes") { bool bReadAttrOk = ReadUserAttributes( *it, 3, &vsUAtt) ; if ( ! bReadAttrOk) return false ; } // JackRafterCut else if ( sProcessName == "JackRafterCut") bProcessOk = ReadJackRafterCutParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // LongitudinalCut else if ( sProcessName == "LongitudinalCut") bProcessOk = ReadLongitudinalCutParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // DoubleCut else if ( sProcessName == "DoubleCut") bProcessOk = ReadDoubleCutParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // RidgeValleyCut else if ( sProcessName == "RidgeValleyCut") bProcessOk = ReadRidgeValleyCutParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // SawCut else if ( sProcessName == "SawCut") bProcessOk = ReadSawCutParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // Slot else if ( sProcessName == "Slot") bProcessOk = ReadSlotParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // BirdsMouth else if ( sProcessName == "BirdsMouth") bProcessOk = ReadBirdsMouthParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // HipValleyRafterNotch else if ( sProcessName == "HipValleyRafterNotch") bProcessOk = ReadHipValleyRafterNotchParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // Lap else if ( sProcessName == "Lap") bProcessOk = ReadLapParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // LogHouseHalfLap else if ( sProcessName == "LogHouseHalfLap") bProcessOk = ReadLogHouseHalfLapParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // FrenchRidgeLap else if ( sProcessName == "FrenchRidgeLap") bProcessOk = ReadFrenchRidgeLapParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // Chamfer else if ( sProcessName == "Chamfer") bProcessOk = ReadChamferParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // LogHouseJoint else if ( sProcessName == "LogHouseJoint") bProcessOk = ReadLogHouseJointParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // LogHouseFront else if ( sProcessName == "LogHouseFront") bProcessOk = ReadLogHouseFrontParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // Pocket else if ( sProcessName == "Pocket") bProcessOk = ReadPocketParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // Drilling else if ( sProcessName == "Drilling") bProcessOk = ReadDrillingParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // Tenon else if ( sProcessName == "Tenon") { bProcessOk = ReadTenonParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; if ( ! bProcessOk) return false ; bProcessOk = m_BtlGeom.AddTenonBTLX( nGroup, nProc, nSide, sDes, nProcId, vnDPar, vdPar, vsUAtt) ; bAdd = false ; // non devo aggiungere il processo una volta terminati questi if if ( ! bProcessOk) { LOG_ERROR( GetEExLogger(), " Error reading Part Process: BtlGeom.AddTenonBTLX error") ; return false ; } } // Moritse else if ( sProcessName == "Mortise") bProcessOk = ReadMortiseParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // House else if ( sProcessName == "House") { // I parametri sono quasi gli stessi di Tenon, quindi chiamo la stessa funzione bProcessOk = ReadTenonParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; if ( ! bProcessOk) return false ; // Sovrascrivo i parametri di Tenon con le modifiche proprie di House nProc = 52 ; bProcessOk = m_BtlGeom.AddTenonBTLX( nGroup, nProc, nSide, sDes, nProcId, vnDPar, vdPar, vsUAtt) ; bAdd = false ; if ( ! bProcessOk) { LOG_ERROR( GetEExLogger(), " Error reading Part Process: BtlGeom.AddHouseBTLX error") ; return false ; } nProcId ++ ; // House contiene un tenon o un dovetailtenon : pugi::xml_node housetenon = it->child( "Tenon") ; pugi::xml_node housedtenon = it->child( "DovetailTenon") ; if ( housetenon != nullptr) { // Con GetProcessParamInfos viene fatto emplace_back sul vettore dei parametri quindi devono essere vuoti vnDPar.clear() ; vdPar.clear() ; nSPar = 0 ; sPar.clear() ; vsUAtt.clear() ; bProcessOk = ReadTenonParams( housetenon, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; if ( ! bProcessOk) return false ; bProcessOk = m_BtlGeom.AddTenonBTLX( nGroup, nProc, nSide, "Tenon", nProcId, vnDPar, vdPar, vsUAtt) ; if ( ! bProcessOk ) { LOG_ERROR( GetEExLogger(), " Error reading Part Process: BtlGeom.AddHouseBTLX error") ; return false ; } } if ( housedtenon != nullptr) { vnDPar.clear() ; vdPar.clear() ; nSPar = 0 ; sPar.clear() ; vsUAtt.clear() ; bProcessOk = ReadDovetailTenonParams( housedtenon, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; if ( ! bProcessOk) return false ; bProcessOk = m_BtlGeom.AddDovetailTenonBTLX( nGroup, nProc, nSide, "DovetailTenon", nProcId, vnDPar, vdPar, vsUAtt) ; if ( ! bProcessOk) { LOG_ERROR( GetEExLogger(), " Error reading Part Process: BtlGeom.AddHouseBTLX error") ; return false ; } } } // HouseMortise else if ( sProcessName == "HouseMortise") { // I parametri sono quasi gli stessi di Mortise, quindi chiamo la stessa funzione bProcessOk = ReadMortiseParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; if ( ! bProcessOk) return false ; // Sovrascrivo i parametri di Mortise con le modifiche proprie di House nProc = 53 ; bProcessOk = m_BtlGeom.AddProcess( nGroup, nProc, nSide, sDes, nProcId, frRef, vnDPar, nSPar, vdPar, sPar, vsUAtt, 0) ; bAdd = false ; if ( ! bProcessOk) { LOG_ERROR( GetEExLogger(), " Error reading Part Process: BtlGeom.AddMortiseBTLX error") ; return false ; } nProcId ++ ; // House contiene una mortise/dovetailmortise : pugi::xml_node housemortise = it->child( "Mortise") ; pugi::xml_node housedtmortise = it->child( "DovetailMortise") ; if ( housemortise != nullptr) { vnDPar.clear() ; vdPar.clear() ; nSPar = 0 ; sPar.clear() ; vsUAtt.clear() ; bProcessOk = ReadMortiseParams( housemortise, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; if ( ! bProcessOk) return false ; bProcessOk = m_BtlGeom.AddProcess( nGroup, nProc, nSide, "Mortise", nProcId, frRef, vnDPar, nSPar, vdPar, sPar, vsUAtt, 0) ; if ( ! bProcessOk ){ LOG_ERROR( GetEExLogger(), " Error reading Part Process: BtlGeom.AddMortiseBTLX error") return false ; } } if ( housedtmortise != nullptr) { vnDPar.clear() ; vdPar.clear() ; nSPar = 0 ; sPar.clear() ; vsUAtt.clear() ; bProcessOk = ReadDovetailMortiseParams( housedtmortise, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; if ( ! bProcessOk) return false ; bProcessOk = m_BtlGeom.AddProcess( nGroup, nProc, nSide, "DovetailMortise", nProcId, frRef, vnDPar, nSPar, vdPar, sPar, vsUAtt, 0) ; if ( ! bProcessOk) { LOG_ERROR( GetEExLogger(), " Error reading Part Process: BtlGeom.AddMortiseBTLX error") ; return false ; } } } // DovetailTenon else if ( sProcessName == "DovetailTenon") { bProcessOk = ReadDovetailTenonParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; if ( ! bProcessOk) return false ; bProcessOk = m_BtlGeom.AddDovetailTenonBTLX( nGroup, nProc, nSide, sDes, nProcId, vnDPar, vdPar, vsUAtt) ; bAdd = false ; // non devo aggiungere il processo una volta terminati questi if if ( ! bProcessOk ){ LOG_ERROR( GetEExLogger(), " Error reading Part Process: BtlGeom.AddDovetailTenonBTLX error") ; return false ; } } // DovetailMortise else if ( sProcessName == "DovetailMortise") bProcessOk = ReadDovetailMortiseParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // Marking else if ( sProcessName == "Marking") bProcessOk = ReadMarkingParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // Text else if ( sProcessName == "Text") bProcessOk = ReadTextParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // SimpleScarf else if ( sProcessName == "SimpleScarf") bProcessOk = ReadSimpleScarfParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // ScarfJoint else if ( sProcessName == "ScarfJoint") bProcessOk = ReadScarfJointParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // StepJoint else if ( sProcessName == "StepJoint") bProcessOk = ReadStepJointParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // StepJointNotch else if ( sProcessName == "StepJointNotch") bProcessOk = ReadStepJointNotchParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // Planing else if ( sProcessName == "Planing") { LOG_ERROR( GetEExLogger(), " Warning reading Part Process: Planing ignored") ; //bProcessOk = ReadPlaningParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; } // ProfileFront else if ( sProcessName == "ProfileFront") bProcessOk = ReadProfileFrontParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // ProfileCambered else if ( sProcessName == "ProfileCambered") bProcessOk = ReadProfileCamberedParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // RoundArch else if ( sProcessName == "RoundArch") bProcessOk = ReadRoundArchParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // ProfileHead else if ( sProcessName == "ProfileHead") bProcessOk = ReadProfileHeadParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // Sphere else if ( sProcessName == "Sphere") { LOG_ERROR( GetEExLogger(), " Warning reading Part Process: Sphere ignored") ; // bProcessOk = ReadSphereParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; } // TriangleCut else if ( sProcessName == "TriangleCut") bProcessOk = ReadTriangleCutParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // TyroleanDovetail else if ( sProcessName == "TyroleanDovetail") bProcessOk = ReadTyroleanDovetailParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // Dovetail else if ( sProcessName == "Dovetail") bProcessOk = ReadDovetailParams( *it, nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar) ; // FreeContour else if ( sProcessName == "FreeContour") { bProcessOk = ReadFreeContourParams( *it, vsUAtt) ; bAdd = false ; } if ( ! bProcessOk) return false ; // aggiungo il processo if ( bAdd) { // se riferimento non è una delle facce, lo recupero da UserReferencePlanes if ( nSide < BTL_SIDE_FRONT || nSide > BTL_SIDE_RIGHT) { // se non esiste, errore if ( m_mapRefPlanes.find( nSide) == m_mapRefPlanes.end()) { LOG_ERROR( GetEExLogger(), " Error reading Part Process: Reference Plane unknown") ; return false ; } frRef = m_mapRefPlanes[nSide] ; } bProcessOk = m_BtlGeom.AddProcess( nGroup, nProc, nSide, sDes, nProcId, frRef, vnDPar, nSPar, vdPar, sPar, vsUAtt, 0) ; if ( ! bProcessOk) { LOG_ERROR( GetEExLogger(), " Error reading Part Process: BtlGeom.AddProcess error") ; return false ; } } nProcId ++ ; } // end sui sottonodi di Processings return true ; } //-------------------------------------------------------------------- bool ImportBtlx::ReadShape( pugi::xml_node node) { pugi::xml_node FaceSet = node.child( "IndexedFaceSet") ; if ( FaceSet == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part Shape: Indexed Face Set missing") ; return false ; } string sFacesVertices = FaceSet.attribute( "coordIndex").value() ; if ( sFacesVertices == "") { LOG_ERROR( GetEExLogger(), " Error reading Part Shape: Indexed Face Set missing") ; return false ; } if ( FaceSet.child( "Coordinate") == nullptr) { LOG_ERROR( GetEExLogger(), " Error reading Part Shape: Coordinates missing") ; return false ; } string sCoordPoints = FaceSet.child( "Coordinate").attribute( "point").value() ; if ( sCoordPoints == "") { LOG_ERROR( GetEExLogger(), " Error reading Part Shape: Coordinates missing") ; return false ; } INTMATRIX vFacesVertices ; PNTVECTOR vPoints ; size_t str_start = 0 ; size_t str_end ; // Vertici delle facce INTVECTOR vAux ; // vettore per salvare i vertici di una faccia if ( sFacesVertices.back() != ' ') sFacesVertices += " " ; while ( ( str_end = sFacesVertices.find( " ", str_start)) != string::npos ) { int val = std::stoi( sFacesVertices.substr( str_start, str_end - str_start)) ; str_start = str_end + 1 ; if ( val == -1) { // delimiter -1 indica che una faccia è terminata vFacesVertices.push_back( vAux) ; vAux.clear() ; } else { vAux.push_back( val) ; } } // Coordinate dei vertici str_start = 0 ; DBLVECTOR vAux2 ; // vettore per salvare le coordinate di un punto if ( sCoordPoints.back() != ' ') sCoordPoints += " " ; while( ( str_end = sCoordPoints.find( " ", str_start)) != string::npos ) { double val = std::stod( sCoordPoints.substr( str_start, str_end - str_start)) ; str_start = str_end + 1 ; vAux2.push_back( val) ; if ( vAux2.size() == 3) { // hai letto 3 coordinate quindi hai un punto vPoints.push_back( Point3d( vAux2[0], vAux2[1], vAux2[2])) ; vAux2.clear() ; } } // se termino senza aver svuotato vAux2 significa che ho un punto con coordinate incomplete if ( vAux2.size() != 0) { LOG_ERROR( GetEExLogger(), " Error reading Part Shape: Coordinates not defining a point") ; return false ; } return m_BtlGeom.AddShapeBTLX( vFacesVertices, vPoints) ; }