//---------------------------------------------------------------------------- // EgalTech 2015-2015 //---------------------------------------------------------------------------- // File : ImportBtl.cpp Data : 22.08.15 Versione : 1.6h5 // Contenuto : Implementazione della classe per l'importazione BTL. // // // // Modifiche : 22.08.15 DS Creazione modulo. // // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "ImportBtl.h" #include "DllMain.h" #include "/EgtDev/Include/EExDllMain.h" #include "/EgtDev/Include/EGkStmStandard.h" #include "/EgtDev/Include/EGkStringUtils3d.h" #include "/EgtDev/Include/EgtKeyCodes.h" #include "/EgtDev/Include/EgtStringEncoder.h" #include "/EgtDev/Include/EgtPointerOwner.h" using namespace std ; //---------------------------------------------------------------------------- // Commento static const std::string KEY_COMMENT = "COMMENT" ; // Sezioni // HEADER non ha intestazione static const std::string SEC_GENERAL = "[GENERAL]" ; static const std::string SEC_RAWPART = "[RAWPART]" ; static const std::string SEC_PART = "[PART]" ; static const std::string SEC_COMPOSITE = "[COMPOSITE]" ; // Chiavi HEADER static const std::string KEY_VERSION = "VERSION" ; static const std::string KEY_BUILD = "BUILD" ; static const std::string KEY_EDITION = "EDITION" ; //--- Chiavi GENERAL --------------------------------------------------------- enum nGeneKey { KEY_GENE_ARCHITECT = 0, KEY_GENE_COMPUTERNAME, KEY_GENE_CUSTOMER, KEY_GENE_DELIVERYDATE, KEY_GENE_EDITOR, KEY_GENE_EXPORTDATE, KEY_GENE_EXPORTFILE, KEY_GENE_EXPORTRELEASE, KEY_GENE_EXPORTTIME, KEY_GENE_LANGUAGE, KEY_GENE_LISTNAME, KEY_GENE_PROCESSINGQUALITY, KEY_GENE_PROJECTGUID, KEY_GENE_PROJECTNAME, KEY_GENE_PROJECTNUMBER, KEY_GENE_PROJECTPART, KEY_GENE_RANGE, KEY_GENE_RECESS, KEY_GENE_SCALEUNIT, KEY_GENE_SOURCEFILE, KEY_GENE_USER, KEY_GENE_USERATTRIBUTE, KEY_GENE_ZZZ } ; static const array sGeneKey = { "ARCHITECT", "COMPUTERNAME", "CUSTOMER", "DELIVERYDATE", "EDITOR", "EXPORTDATE", "EXPORTFILE", "EXPORTRELEASE", "EXPORTTIME", "LANGUAGE", "LISTNAME", "PROCESSINGQUALITY", "PROJECTGUID", "PROJECTNAME", "PROJECTNUMBER", "PROJECTPART", "RANGE", "RECESS", "SCALEUNIT", "SOURCEFILE", "USER", "USERATTRIBUTE" } ; static int FindGeneralKey( const string& sKey) { auto TheRange = equal_range( sGeneKey.cbegin(), sGeneKey.cend(), sKey) ; if ( TheRange.first == TheRange.second) return - 1 ; return int( TheRange.first - sGeneKey.cbegin()) ; } //--- Chiavi RAWPART --------------------------------------------------------- enum nRawpKey { KEY_RAWP_PROCESSKEY = 0, KEY_RAWP_PROCESSPARAMETERS, KEY_RAWP_REFERENCEPLANE, KEY_RAWP_ZZZ } ; static const array sRawpKey = { "PROCESSKEY", "PROCESSPARAMETERS", "REFERENCEPLANE" } ; static int FindRawPartKey( const string& sKey) { auto TheRange = equal_range( sRawpKey.cbegin(), sRawpKey.cend(), sKey) ; if ( TheRange.first == TheRange.second) return - 1 ; return int( TheRange.first - sRawpKey.cbegin()) ; } //--- Chiavi PART ------------------------------------------------------------ enum nPartKey { KEY_PART_ALIGNMENT = 0, KEY_PART_ANNOTATION, KEY_PART_APERTURE, KEY_PART_ASSEMBLYNUMBER, KEY_PART_CAMBER, KEY_PART_COLOUR, KEY_PART_COUNT, KEY_PART_DESIGNATION, KEY_PART_ELEMENTNUMBER, KEY_PART_ENDOFFSET, KEY_PART_GRAINDIRECTION, KEY_PART_GROUP, KEY_PART_HEIGHT, KEY_PART_LAYER, KEY_PART_LENGTH, KEY_PART_MATERIAL, KEY_PART_MATERIALTYPE, KEY_PART_MODULENUMBER, KEY_PART_ORDERNUMBER, KEY_PART_OUTLINE, KEY_PART_PACKAGE, KEY_PART_PARTOFFSET, KEY_PART_PLANINGLENGTH, KEY_PART_PROCESSINGQUALITY, KEY_PART_QUALITYGRADE, KEY_PART_RECESS, KEY_PART_REFERENCEPLANE, KEY_PART_REFERENCESIDE, KEY_PART_SINGLEMEMBERNUMBER, KEY_PART_STARTOFFSET, KEY_PART_STOREY, KEY_PART_STOREYTYPE, KEY_PART_TIMBERGRADE, KEY_PART_TRANSFORMATION, KEY_PART_UID, KEY_PART_USERATTRIBUTE, KEY_PART_WIDTH, KEY_PART_ZZZ } ; static const array sPartKey = { "ALIGNMENT", "ANNOTATION", "APERTURE", "ASSEMBLYNUMBER", "CAMBER", "COLOUR", "COUNT", "DESIGNATION", "ELEMENTNUMBER", "ENDOFFSET", "GRAINDIRECTION", "GROUP", "HEIGHT", "LAYER", "LENGTH", "MATERIAL", "MATERIALTYPE", "MODULENUMBER", "ORDERNUMBER", "OUTLINE", "PACKAGE", "PARTOFFSET", "PLANINGLENGTH", "PROCESSINGQUALITY", "QUALITYGRADE", "RECESS", "REFERENCEPLANE", "REFERENCESIDE", "SINGLEMEMBERNUMBER", "STARTOFFSET", "STOREY", "STOREYTYPE", "TIMBERGRADE", "TRANSFORMATION", "UID", "USERATTRIBUTE", "WIDTH" } ; static int FindPartKey( const string& sKey) { auto TheRange = equal_range( sPartKey.cbegin(), sPartKey.cend(), sKey) ; if ( TheRange.first == TheRange.second) return - 1 ; return int( TheRange.first - sPartKey.cbegin()) ; } //--- Chiavi PROCESS --------------------------------------------------------- enum nProcKey { KEY_PROC_PRIORITY = 0, KEY_PROC_PROCESS, KEY_PROC_PROCESSIDENT, KEY_PROC_PROCESSINGQUALITY, KEY_PROC_PROCESSKEY, KEY_PROC_PROCESSPARAMETERS, KEY_PROC_RECESS, KEY_PROC_REFERENCEPLANE, KEY_PROC_USERATTRIBUTE, KEY_PROC_ZZZ } ; static const array sProcKey = { "PRIORITY", "PROCESS", "PROCESSIDENT", "PROCESSINGQUALITY", "PROCESSKEY", "PROCESSPARAMETERS", "RECESS", "REFERENCEPLANE", "USERATTRIBUTE" } ; static int FindProcessKey( const string& sKey) { auto TheRange = equal_range( sProcKey.cbegin(), sProcKey.cend(), sKey) ; if ( TheRange.first == TheRange.second) return - 1 ; return int( TheRange.first - sProcKey.cbegin()) ; } // Parametri static const std::string PAR_R = "R" ; static const std::string PAR_G = "G" ; static const std::string PAR_B = "B" ; static const std::string PAR_A = "A" ; static const std::string PAR_X = "X" ; static const std::string PAR_Y = "Y" ; static const std::string PAR_Z = "Z" ; static const std::string PAR_ALIGN = "ALIGN" ; static const std::string PAR_OX = "OX" ; static const std::string PAR_OY = "OY" ; static const std::string PAR_OZ = "OZ" ; static const std::string PAR_XX = "XX" ; static const std::string PAR_XY = "XY" ; static const std::string PAR_XZ = "XZ" ; static const std::string PAR_YX = "YX" ; static const std::string PAR_YY = "YY" ; static const std::string PAR_YZ = "YZ" ; static const std::string PAR_PROCESS = "PROCESS" ; static const std::string PAR_SIDE = "SIDE" ; static const std::string PAR_P = "P" ; //---------------------------------------------------------------------------- IImportBtl* CreateImportBtl( void) { // verifico la chiave e le opzioni if ( ! TestKeyForEEx( GetEExKey(), KEYOPT_EEX_INPADV, GetEExLogger())) return nullptr ; // creo l'oggetto return static_cast ( new(nothrow) ImportBtl) ; } //---------------------------------------------------------------------------- ImportBtl::ImportBtl( void) { m_nBuild = 10000 ; m_dScale = 1 ; } //---------------------------------------------------------------------------- bool ImportBtl::Import( const string& sFile, IGeomDB* pGDB, int nFlag) { // log di informazioni LOG_INFO( GetEExLogger(), ( "ImportBtl : " + sFile).c_str()) // inizializzo lo scanner if ( ! m_theScanner.Init( sFile, KEY_COMMENT.c_str())) { LOG_ERROR( GetEExLogger(), " Error on Init") return false ; } // inizializzo il gestore geometria pezzi Btl int nFlatVertPos = 0 ; 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 bUseUAttr = (( nFlag & EIBFLAG_USEUATTR) != 0) ; if ( ! m_BtlGeom.Init( pGDB, nFlatVertPos, bSpecialTrim, 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) ; // lettura intestazione if ( ! ReadHeader()) { string sOut = " Error (ReadHeader) on line " + ToString( m_theScanner.GetCurrLineNbr()) ; LOG_ERROR( GetEExLogger(), sOut.c_str()) return false ; } // lettura generalità if ( ! ReadGeneral()) { string sOut = " Error (ReadGeneral) on line " + ToString( m_theScanner.GetCurrLineNbr()) ; LOG_ERROR( GetEExLogger(), sOut.c_str()) return false ; } // ciclo sui grezzi bool bOk = true ; for ( bool bEnd = false ; ! bEnd ;) { if ( ! ReadRawPart( bEnd)) { string sOut = " Error (ReadRawPart) on line " + ToString( m_theScanner.GetCurrLineNbr()) ; LOG_ERROR( GetEExLogger(), sOut.c_str()) bOk = false ; } } // ciclo sui pezzi for ( bool bEnd = false ; ! bEnd ;) { if ( ! ReadPart( bEnd)) { // i log di errore sono già gestiti nella funzione chiamata bOk = false ; } } // ciclo sui compositi for ( bool bEnd = false ; ! bEnd ;) { if ( ! ReadComposite( bEnd)) { string sOut = " Error on line " + ToString( m_theScanner.GetCurrLineNbr()) ; LOG_ERROR( GetEExLogger(), sOut.c_str()) bOk = false ; } } // eventuale ordinamento dei pezzi secondo SN bool bSort = (( nFlag & EIBFLAG_SORT) != 0) ; if ( bSort) m_BtlGeom.SortParts() ; return bOk ; } //---------------------------------------------------------------------------- bool ImportBtl::ReadHeader( void) { // conteggio campi utili letti int nRead = 0 ; // ciclo sulle linee string sLine ; while ( m_theScanner.GetLine( sLine)) { // se cambio sezione if ( sLine[0] == '[') { m_theScanner.UngetLine( sLine) ; return ( nRead > 0) ; } // spezzo la linea string sKey, sVal ; SplitFirst( sLine, ":", sKey, sVal) ; // se numero di versione if ( sKey == KEY_VERSION) { Trim( sVal, " \t\r\n\"") ; m_sVersion = sVal ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, m_sVersion) ; } // se numero di build else if ( sKey == KEY_BUILD) { Trim( sVal, " \t\r\n\"") ; if ( FromString( sVal, m_nBuild)) ++ nRead ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; } // se edizione else if ( sKey == KEY_EDITION) { Trim( sVal, " \t\r\n\"") ; if ( sVal == "PREFABRICATION") m_nEdition = 1 ; else m_nEdition = 0 ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; } } return false ; } //---------------------------------------------------------------------------- bool ImportBtl::ReadGeneral( void) { // conteggio campi utili letti int nRead = 0 ; // leggo la prossima linea e verifico sia la sezione GENERAL string sLine ; if ( ! m_theScanner.GetLine( sLine) || sLine != SEC_GENERAL) return false ; // ciclo sulle linee while ( m_theScanner.GetLine( sLine)) { // se cambio sezione if ( sLine[0] == '[') { m_theScanner.UngetLine( sLine) ; return ( nRead > 0) ; } // spezzo la linea string sKey, sVal ; SplitFirst( sLine, ":", sKey, sVal) ; switch ( FindGeneralKey( sKey)) { case KEY_GENE_PROJECTNUMBER : // numero di progetto Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_PROJECTNAME : // nome di progetto Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_PROJECTPART : // parte di progetto Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_PROJECTGUID : // identificativo globale unico di progetto Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_LISTNAME : // nome lista Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_CUSTOMER : // cliente Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_ARCHITECT : // architetto Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_EDITOR : // autore Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_DELIVERYDATE : // data di consegna Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_EXPORTDATE : // data di esportazione Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_EXPORTTIME : // ora di esportazione Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_EXPORTRELEASE : // programma di esportazione Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_LANGUAGE : // lingua Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_RANGE : // range dei parametri Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_SCALEUNIT : // numero di decimali { Trim( sVal, " \t\r\n\"") ; int nUnit ; if ( FromString( sVal, nUnit)) { m_dScale = pow( 10, - nUnit) ; ++ nRead ; } m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; } break ; case KEY_GENE_PROCESSINGQUALITY : // qualità di lavorazione Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_COMPUTERNAME : // nome computer Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_USER : // nome utente Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_SOURCEFILE : // file sorgente Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_EXPORTFILE : // file di esportazione Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_RECESS : // finitura angoli interni Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ; break ; case KEY_GENE_USERATTRIBUTE : // attributo utente m_BtlGeom.SetUserAttribute( UATD_INFO, sVal) ; break ; } } return false ; } //---------------------------------------------------------------------------- bool ImportBtl::ReadRawPart( bool& bEnd) { string sLine ; // leggo la prossima linea e verifico sia la sezione RAWPART if ( ! m_theScanner.GetLine( sLine)) { bEnd = true ; return true ; } // verifico sia la sezione RAWPART if ( sLine != SEC_RAWPART) { m_theScanner.UngetLine( sLine) ; bEnd = true ; return true ; } // ciclo sulle linee while ( m_theScanner.GetLine( sLine)) { // se cambio sezione if ( sLine[0] == '[') { m_theScanner.UngetLine( sLine) ; bEnd = false ; return true ; } // ignoro tutto } bEnd = true ; return true ; } //---------------------------------------------------------------------------- bool ImportBtl::ReadPart( bool& bEnd) { string sLine ; // leggo la prossima linea if ( ! m_theScanner.GetLine( sLine)) { bEnd = true ; return true ; } // verifico sia la sezione PART if ( sLine != SEC_PART) { m_theScanner.UngetLine( sLine) ; bEnd = true ; return true ; } // creo il pezzo if ( ! m_BtlGeom.CreatePart()) { string sOut = " Error (CreatePart) on line " + ToString( m_theScanner.GetCurrLineNbr()) ; LOG_ERROR( GetEExLogger(), sOut.c_str()) SkipCurrSection() ; bEnd = false ; return false ; } // ciclo sulle linee con i dati generali del pezzo double dLength = 0, dHeight = 0, dWidth = 0 ; bool bLength = false, bHeight = false, bWidth = false, bBox = false ; int nUID = 0 ; while ( m_theScanner.GetLine( sLine)) { // se cambio sezione if ( sLine[0] == '[') { m_theScanner.UngetLine( sLine) ; bEnd = false ; // aggiorno outline return m_BtlGeom.UpdateOutLine() ; } // spezzo la linea string sKey, sVal ; SplitFirst( sLine, ":", sKey, sVal) ; switch ( FindPartKey( sKey)) { case KEY_PART_SINGLEMEMBERNUMBER : // identificativo di produzione { int nProdNbr = 0 ; if ( FromString( sVal, nProdNbr)) m_BtlGeom.SetPartProdNbr( nProdNbr) ; } break ; case KEY_PART_ASSEMBLYNUMBER : // numero di lista nell'assemblato Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; case KEY_PART_ORDERNUMBER : // numero di lista nell'ordine Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; case KEY_PART_DESIGNATION : // nome Trim( sVal, " \t\r\n\"") ; if ( ! IsTextUtf8( sVal.c_str())) sVal = LPSTR( WtoA( LPWSTR( AtoW( sVal.c_str(), 1252)))) ; m_BtlGeom.SetPartName( sVal) ; break ; case KEY_PART_ANNOTATION : // annotazione Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; case KEY_PART_STOREY : // sottogruppo Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; case KEY_PART_GROUP : // gruppo Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; case KEY_PART_PACKAGE : // pacco di spedizione Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; case KEY_PART_MATERIAL : // materiale Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; case KEY_PART_TIMBERGRADE : // qualità legname Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; case KEY_PART_QUALITYGRADE : // qualità Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; case KEY_PART_COUNT : // quantità { int nCount = 0 ; if ( FromString( sVal, nCount)) m_BtlGeom.SetPartCount( nCount) ; } break ; case KEY_PART_LENGTH : // lunghezza (dimensione in X) if ( FromString( sVal, dLength)) { dLength *= m_dScale ; bLength = true ; } if ( bLength && bHeight && bWidth) { if ( m_BtlGeom.AddPartBox( dLength, dHeight, dWidth)) bBox = true ; } break ; case KEY_PART_HEIGHT : // altezza (dimensione in Y) if ( FromString( sVal, dHeight)) { dHeight *= m_dScale ; bHeight = true ; } if ( bLength && bHeight && bWidth) { if ( m_BtlGeom.AddPartBox( dLength, dHeight, dWidth)) bBox = true ; } break ; case KEY_PART_WIDTH : // larghezza (dimensione in Z) if ( FromString( sVal, dWidth)) { dWidth *= m_dScale ; bWidth = true ; } if ( bLength && bHeight && bWidth) { if ( m_BtlGeom.AddPartBox( dLength, dHeight, dWidth)) bBox = true ; } break ; case KEY_PART_COLOUR : // colore { Trim( sVal, " \t\r\n\"") ; Color colRes ; if ( ReadColor( sVal, colRes)) m_BtlGeom.SetUserAttribute( UATD_PART, sKey, ToString( colRes)) ; } break ; case KEY_PART_PLANINGLENGTH : // lunghezza spianatura { Trim( sVal, " \t\r\n\"") ; double dVal ; if ( GetParam( sVal, dVal)) m_BtlGeom.SetUserAttribute( UATD_PART, sKey, ToString( dVal, 3)) ; } break ; case KEY_PART_STARTOFFSET : // offset iniziale { Trim( sVal, " \t\r\n\"") ; double dVal ; if ( GetParam( sVal, dVal)) m_BtlGeom.SetUserAttribute( UATD_PART, sKey, ToString( dVal, 3)) ; } break ; case KEY_PART_ENDOFFSET : // offset finale { Trim( sVal, " \t\r\n\"") ; double dVal ; if ( GetParam( sVal, dVal)) m_BtlGeom.SetUserAttribute( UATD_PART, sKey, ToString( dVal, 3)) ; } break ; case KEY_PART_UID : // UID istanza pezzo nella struttura FromString( sVal, nUID) ; break ; case KEY_PART_TRANSFORMATION : // matrice di trasformazione istanza pezzo nella struttura { Frame3d frRef ; if ( ReadTransformation( sVal, frRef)) m_BtlGeom.AddPartTransformation( nUID, frRef) ; } break ; case KEY_PART_CAMBER : // incurvamento Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; case KEY_PART_PARTOFFSET : // offset pezzo Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; case KEY_PART_PROCESSINGQUALITY : // qualità di lavorazione Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; case KEY_PART_OUTLINE : // contorno // interpreto l'outline m_theScanner.UngetLine( sLine) ; if ( ! ReadOutline()) { string sOut = " Error (ReadOutline) on line " + ToString( m_theScanner.GetCurrLineNbr()) ; LOG_ERROR( GetEExLogger(), sOut.c_str()) SkipCurrSection() ; m_BtlGeom.ErasePart() ; bEnd = false ; return false ; } break ; case KEY_PART_APERTURE : // apertura // interpreto l'apertura m_theScanner.UngetLine( sLine) ; if ( ! ReadAperture()) { string sOut = " Error (ReadAperture) on line " + ToString( m_theScanner.GetCurrLineNbr()) ; LOG_ERROR( GetEExLogger(), sOut.c_str()) SkipCurrSection() ; m_BtlGeom.ErasePart() ; bEnd = false ; return false ; } break ; case KEY_PART_RECESS : // finitura angoli interni Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; case KEY_PART_STOREYTYPE : // tipo di piano Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; case KEY_PART_ELEMENTNUMBER : // numero elemento Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; case KEY_PART_LAYER : // layer Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; case KEY_PART_MODULENUMBER : // numero modulo Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; case KEY_PART_USERATTRIBUTE : // attributo utente m_BtlGeom.SetUserAttribute( UATD_PART, sVal) ; break ; case KEY_PART_GRAINDIRECTION : // direzione venatura { Trim( sVal, " \t\r\n\"") ; Vector3d vtDir ; bool bAlign ; if ( ReadGrainDirection( sVal, vtDir, bAlign)) m_BtlGeom.SetUserAttribute( UATD_PART, sKey, ToString( vtDir) + ";" + ( bAlign ? "1" : "0")) ; } break ; case KEY_PART_REFERENCESIDE : // lato di riferimento Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; case KEY_PART_ALIGNMENT : // allineamento Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; case KEY_PART_MATERIALTYPE : // tipo di materiale Trim( sVal, " \t\r\n\"") ; m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ; break ; } // se lavorazione, esco dal ciclo if ( sKey == sProcKey[KEY_PROC_PROCESSKEY]) { m_theScanner.UngetLine( sLine) ; break ; } } // verifico sia stato definito il contorno del pezzo if ( ! bBox) { string sOut = " Error (AddPartBox) on line " + ToString( m_theScanner.GetCurrLineNbr()) ; LOG_ERROR( GetEExLogger(), sOut.c_str()) SkipCurrSection() ; m_BtlGeom.ErasePart() ; bEnd = false ; return false ; } // interpreto le lavorazioni (processing) bool bOk = true ; for ( bool bProcEnd = false ; ! bProcEnd ;) { if ( ! ReadProcess( bProcEnd)) { // i log di errore sono già gestiti nella funzione chiamata bOk = false ; } } // inserisco eventuali contorni liberi if ( ! m_BtlGeom.CreateFreeContours()) bOk = false ; // aggiorno outline if ( ! m_BtlGeom.UpdateOutLine()) { string sOut = " Error (UpdateOutLine) on line " + ToString( m_theScanner.GetCurrLineNbr()) ; LOG_ERROR( GetEExLogger(), sOut.c_str()) m_BtlGeom.ErasePart() ; } bEnd = false ; return bOk ; } //---------------------------------------------------------------------------- bool ImportBtl::ReadComposite( bool& bEnd) { string sLine ; // leggo la prossima linea if ( ! m_theScanner.GetLine( sLine)) { bEnd = true ; return true ; } // verifico sia la sezione COMPOSITE if ( sLine != SEC_COMPOSITE) { bEnd = true ; return true ; } // ciclo sulle linee while ( m_theScanner.GetLine( sLine)) { // se cambio sezione if ( sLine[0] == '[') { m_theScanner.UngetLine( sLine) ; bEnd = false ; return true ; } // ignoro tutto } bEnd = true ; return true ; } //---------------------------------------------------------------------------- bool ImportBtl::ReadTransformation( const string& sVal, Frame3d& frRef) { // leggo i valori Point3d ptO ; GetParam( sVal, PAR_OX, ptO.x) ; GetParam( sVal, PAR_OY, ptO.y) ; GetParam( sVal, PAR_OZ, ptO.z) ; Vector3d vtX ; GetParam( sVal, PAR_XX, vtX.x) ; GetParam( sVal, PAR_XY, vtX.y) ; GetParam( sVal, PAR_XZ, vtX.z) ; Vector3d vtY ; GetParam( sVal, PAR_YX, vtY.x) ; GetParam( sVal, PAR_YY, vtY.y) ; GetParam( sVal, PAR_YZ, vtY.z) ; // calcolo il riferimento return frRef.Set( ptO, ptO + vtX, ptO + vtY) ; } //---------------------------------------------------------------------------- bool ImportBtl::ReadOutline( void) { bool bProcFound = false ; int nSide = BTL_SIDE_NONE ; FCEDEQUE dqFce ; STRVECTOR vsUAtt ; // ciclo sulle linee string sLine ; while ( m_theScanner.GetLine( sLine)) { // spezzo la linea string sKey, sVal ; SplitFirst( sLine, ":", sKey, sVal) ; // se attributo utente if ( sKey == sPartKey[KEY_PART_USERATTRIBUTE]) { vsUAtt.emplace_back( sVal) ; continue ; } // se cambio tipologia, concludo else if ( sKey != sPartKey[KEY_PART_OUTLINE]) { m_theScanner.UngetLine( sLine) ; break ; } // leggo i dati // tipo int nFlag ; GetParamP( sVal, 8, nFlag) ; // se non ancora assegnato, leggo se da lavorare if ( ! bProcFound) { string sToDo ; if ( GetInfo( sVal, PAR_PROCESS, sToDo)) { if ( sToDo.find( "YES") != 0) vsUAtt.emplace_back( "DO:0") ; bProcFound = true ; } } // se non ancora assegnata, leggo faccia di riferimento if ( nSide == BTL_SIDE_NONE) GetInfo( sVal, PAR_SIDE, nSide) ; // punto principale Point3d ptP ; GetParamP( sVal, 1, ptP.x) ; GetParamP( sVal, 2, ptP.y) ; GetParamP( sVal, 3, ptP.z) ; // se arco leggo il punto intermedio Point3d ptM ; if ( nFlag == FreeContourEnt::ARC) { GetParamP( sVal, 10, ptM.x) ; GetParamP( sVal, 11, ptM.y) ; GetParamP( sVal, 12, ptM.z) ; } // angolo di fianco double dAng = ( nFlag == FreeContourEnt::START ? FC_SIDEANG_DEF : FC_SIDEANG_NONE) ; GetParamP( sVal, 6, dAng) ; // aggiungo i dati alla deque dqFce.emplace_back( nFlag, ptP, ptM, dAng, 0, 0) ; } // inserimento del contorno nel pezzo return m_BtlGeom.AddPartOutline( nSide, dqFce, vsUAtt) ; } //---------------------------------------------------------------------------- bool ImportBtl::ReadAperture( void) { bool bProcFound = false ; int nSide = BTL_SIDE_NONE ; FCEDEQUE dqFce ; STRVECTOR vsUAtt ; // ciclo sulle linee string sLine ; while ( m_theScanner.GetLine( sLine)) { // spezzo la linea string sKey, sVal ; SplitFirst( sLine, ":", sKey, sVal) ; // se attributo utente if ( sKey == sPartKey[KEY_PART_USERATTRIBUTE]) { vsUAtt.emplace_back( sVal) ; continue ; } // se cambio tipologia, concludo else if ( sKey != sPartKey[KEY_PART_APERTURE]) { m_theScanner.UngetLine( sLine) ; break ; } // leggo i dati // tipo int nFlag ; GetParamP( sVal, 8, nFlag) ; // se tipo start ed esistono precedenti entità, ne derivo una apertura if ( nFlag == FreeContourEnt::START && dqFce.size() > 0) { if ( ! m_BtlGeom.AddPartAperture( nSide, dqFce, vsUAtt)) return false ; nSide = BTL_SIDE_NONE ; bProcFound = false ; dqFce.clear() ; vsUAtt.clear() ; } // se non ancora assegnato, leggo se da lavorare if ( ! bProcFound) { string sToDo ; if ( GetInfo( sVal, PAR_PROCESS, sToDo)) { if ( sToDo.find( "YES") != 0) vsUAtt.emplace_back( "DO:0") ; bProcFound = true ; } } // se non ancora assegnata, leggo faccia di riferimento if ( nSide == BTL_SIDE_NONE) GetInfo( sVal, PAR_SIDE, nSide) ; // punto principale Point3d ptP ; GetParamP( sVal, 1, ptP.x) ; GetParamP( sVal, 2, ptP.y) ; GetParamP( sVal, 3, ptP.z) ; // se arco leggo il punto intermedio Point3d ptM ; if ( nFlag == FreeContourEnt::ARC) { GetParamP( sVal, 10, ptM.x) ; GetParamP( sVal, 11, ptM.y) ; GetParamP( sVal, 12, ptM.z) ; } // angolo di fianco double dAng = ( nFlag == FreeContourEnt::START ? FC_SIDEANG_DEF : FC_SIDEANG_NONE) ; GetParamP( sVal, 6, dAng) ; // aggiungo i dati alla deque dqFce.emplace_back( nFlag, ptP, ptM, dAng, 0, 0) ; } // inserimento dell'ultima apertura nel pezzo return m_BtlGeom.AddPartAperture( nSide, dqFce, vsUAtt) ; } //---------------------------------------------------------------------------- bool ImportBtl::ReadColor( const string& sVal, Color& colRes) { // leggo i valori string sRes ; GetParam( sVal, PAR_R, sRes) ; int nRed ; FromString( sRes, nRed) ; GetParam( sVal, PAR_G, sRes) ; int nGreen ; FromString( sRes, nGreen) ; GetParam( sVal, PAR_B, sRes) ; int nBlue ; FromString( sRes, nBlue) ; GetParam( sVal, PAR_A, sRes) ; int nAlpha ; FromString( sRes, nAlpha) ; nAlpha = nAlpha * 100 / 255 ; colRes.Set( nRed, nGreen, nBlue, nAlpha) ; return true ; } //---------------------------------------------------------------------------- bool ImportBtl::ReadGrainDirection( const string& sVal, Vector3d& vtDir, bool& bAlign) { // leggo i valori GetParam( sVal, PAR_X, vtDir.x) ; GetParam( sVal, PAR_Y, vtDir.y) ; GetParam( sVal, PAR_Z, vtDir.z) ; string sRes ; GetParam( sVal, PAR_ALIGN, sRes) ; bAlign = ( sRes == "YES") ; // ritorno return ( vtDir.Normalize()) ; } //---------------------------------------------------------------------------- bool ImportBtl::ReadProcess( bool& bProcEnd) { bProcEnd = false ; string sLine ; // leggo la prossima linea if ( ! m_theScanner.GetLine( sLine)) { bProcEnd = true ; return true ; } // verifico sia l'istruzione PROCESSKEY if ( sLine.find( sProcKey[KEY_PROC_PROCESSKEY]) == string::npos) { m_theScanner.UngetLine( sLine) ; bProcEnd = true ; return true ; } // recupero i parametri string sKey, sVal ; SplitFirst( sLine, ":", sKey, sVal) ; TrimLeft( sVal) ; string sType, sDes ; SplitFirst( sVal, " ", sType, sDes) ; Trim( sDes) ; STRVECTOR vsItem ; Tokenize( sType, "-", vsItem) ; if ( vsItem.size() < 3) { string sOut = " Error in ProcessType(" + sType + ") on line " + ToString( m_theScanner.GetCurrLineNbr()) ; LOG_ERROR( GetEExLogger(), sOut.c_str()) SkipCurrProcess() ; bProcEnd = false ; return false ; } int nGroup = 0 ; FromString( vsItem[0], nGroup) ; int nProc = 0 ; FromString( vsItem[1], nProc) ; int nSide = 0 ; FromString( vsItem[2], nSide) ; if ( nSide < BTL_SIDE_FRONT || nSide > BTL_SIDE_TOP) nSide = BTL_SIDE_FRONT ; bool bParams = false ; INTVECTOR vnDPar ; int nSPar ; DBLVECTOR vdPar ; string sPar ; int nProcId = 0 ; Frame3d frRef ; STRVECTOR vsUAtt ; // ciclo sulle linee while ( true) { // se fine file, concludo if ( ! m_theScanner.GetLine( sLine)) { bProcEnd = true ; break ; } // se cambio sezione, concludo if ( sLine[0] == '[') { m_theScanner.UngetLine( sLine) ; bProcEnd = true ; break ; } // se nuova lavorazione, concludo if ( sLine.find( sProcKey[KEY_PROC_PROCESSKEY]) != string::npos) { m_theScanner.UngetLine( sLine) ; bProcEnd = false ; break ; } // spezzo la linea string sKey, sVal ; SplitFirst( sLine, ":", sKey, sVal) ; switch ( FindProcessKey( sKey)) { case KEY_PROC_REFERENCEPLANE : // riferimento if ( ! ReadTransformation( sVal, frRef)) { string sOut = " Error : unable to read ReferencePlane (" + sType + ") on line " + ToString( m_theScanner.GetCurrLineNbr()) ; LOG_ERROR( GetEExLogger(), sOut.c_str()) SkipCurrProcess() ; bProcEnd = false ; return false ; } break ; case KEY_PROC_PROCESSPARAMETERS : // parametri if ( ! m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar)) { string sOut = " Error : Unknown Process (" + sType + ") on line " + ToString( m_theScanner.GetCurrLineNbr()) ; LOG_ERROR( GetEExLogger(), sOut.c_str()) SkipCurrProcess() ; bProcEnd = false ; return true ; } else if ( ! GetProcessParams( sVal, sType, vnDPar, nSPar, vdPar, sPar)) { string sOut = " Error in GetProcessParams (" + sType + ") on line " + ToString( m_theScanner.GetCurrLineNbr()) ; LOG_ERROR( GetEExLogger(), sOut.c_str()) SkipCurrProcess() ; bProcEnd = false ; return false ; } bParams = true ; break ; case KEY_PROC_PROCESSIDENT : // identificativo FromString( sVal, nProcId) ; break ; case KEY_PROC_PROCESSINGQUALITY : // qualità di lavorazione Trim( sVal, " \t\r\n\"") ; vsUAtt.emplace_back( sKey + ":" + sVal) ; break ; case KEY_PROC_USERATTRIBUTE : // attributo utente vsUAtt.emplace_back( sVal) ; break ; case KEY_PROC_PRIORITY : // priorità di lavorazione Trim( sVal, " \t\r\n\"") ; vsUAtt.emplace_back( sKey + ":" + sVal) ; break ; case KEY_PROC_RECESS : // tipo angolo interno Trim( sVal, " \t\r\n\"") ; vsUAtt.emplace_back( sKey + ":" + sVal) ; break ; case KEY_PROC_PROCESS : // indicazione di produzione Trim( sVal) ; if ( sVal != "YES") vsUAtt.emplace_back( "DO:0") ; break ; } } // inserimento della lavorazione nel pezzo if ( ! bParams || ! m_BtlGeom.AddProcess( nGroup, nProc, nSide, sDes, nProcId, frRef, vnDPar, nSPar, vdPar, sPar, vsUAtt, m_theScanner.GetCurrLineNbr())) { string sOut = " Error in AddProcess (" + sType + ") to Part " + m_BtlGeom.GetPartName() + " on line " + ToString( m_theScanner.GetCurrLineNbr()) ; LOG_ERROR( GetEExLogger(), sOut.c_str()) bProcEnd = false ; return false ; } bProcEnd = false ; return true ; } //---------------------------------------------------------------------------- bool ImportBtl::SkipCurrSection( void) { // ciclo sulle linee string sLine ; while ( true) { // se fine file, concludo if ( ! m_theScanner.GetLine( sLine)) { break ; } // se cambio sezione, concludo if ( sLine[0] == '[') { m_theScanner.UngetLine( sLine) ; break ; } } return true ; } //---------------------------------------------------------------------------- bool ImportBtl::SkipCurrProcess( void) { // ciclo sulle linee string sLine ; while ( true) { // se fine file, concludo if ( ! m_theScanner.GetLine( sLine)) { break ; } // se cambio sezione, concludo if ( sLine[0] == '[') { m_theScanner.UngetLine( sLine) ; break ; } // se nuova lavorazione, concludo if ( sLine.find( sProcKey[KEY_PROC_PROCESSKEY]) != string::npos) { m_theScanner.UngetLine( sLine) ; break ; } } return true ; } //---------------------------------------------------------------------------- bool ImportBtl::GetProcessParams( const string& sText, const string& sProcType, const INTVECTOR& vnDPar, int nSPar, DBLVECTOR& vdPar, string& sPar) { // verifico corrispondenza numero definizioni - numero parametri numerici if ( vnDPar.size() != vdPar.size()) return false ; // leggo i parametri numerici for ( int i = 0 ; i < int( vnDPar.size()) ; ++ i) { if ( ! GetParamP( sText, vnDPar[i], vdPar[i])) { string sOut = " Info : P" + ToString( vnDPar[i], 2) + " missing in Process (" + sProcType + ") on line " + ToString( m_theScanner.GetCurrLineNbr()) ; LOG_DBG_INFO( GetEExLogger(), sOut.c_str()) } } // leggo l'eventuale parametro stringa if ( nSPar != 0) { if ( ! GetParamP( sText, nSPar, sPar)) { string sOut = " Info : P" + ToString( nSPar, 2) + " missing in Process (" + sProcType + ") on line " + ToString( m_theScanner.GetCurrLineNbr()) ; LOG_DBG_INFO( GetEExLogger(), sOut.c_str()) } } return true ; } //---------------------------------------------------------------------------- bool ImportBtl::GetInfo( const string& sText, const string& sPar, string& sVal) { // cerco l'identificativo del parametro size_t nPos = sText.find( sPar + ":") ; if ( nPos == string::npos) return false ; // recupero la stringa successiva const int SVAL_LEN = 6 ; sVal = sText.substr( nPos + sPar.length() + 1, SVAL_LEN) ; Trim( sVal, " \t\r\n0") ; return true ; } //---------------------------------------------------------------------------- bool ImportBtl::GetInfo( const string& sText, const string& sPar, int& nVal) { string sVal ; if ( ! GetInfo( sText, sPar, sVal)) return false ; nVal = 0 ; FromString( sVal, nVal) ; return true ; } //---------------------------------------------------------------------------- bool ImportBtl::GetParam( const string& sPar, double& dVal) { string sVal = sPar ; TrimLeft( sVal, " \t\r\n0") ; dVal = 0 ; FromString( sVal, dVal) ; dVal *= m_dScale ; return true ; } //---------------------------------------------------------------------------- bool ImportBtl::GetParam( const string& sText, const string& sPar, double& dVal) { // cerco l'identificativo del parametro size_t nPos = sText.find( sPar + ":") ; if ( nPos == string::npos) return false ; // recupero la stringa successiva const int SVAL_LEN = 14 ; string sVal = sText.substr( nPos + sPar.length() + 1, SVAL_LEN) ; TrimLeft( sVal, " \t\r\n0") ; dVal = 0 ; FromString( sVal, dVal) ; dVal *= m_dScale ; return true ; } //---------------------------------------------------------------------------- bool ImportBtl::GetParam( const string& sText, const string& sPar, string& sVal) { // cerco l'identificativo del parametro size_t nPos = sText.find( sPar + ":") ; if ( nPos == string::npos) return false ; // cerco i delimitatori della stringa " size_t nPosI = sText.find( "\"", nPos + sPar.length() + 1) ; size_t nPosF = sText.find( "\"", nPosI + 1) ; if ( nPosI != string::npos && nPosF != string::npos) { sVal = sText.substr( nPosI + 1, nPosF - nPosI - 1) ; return true ; } else { sVal = sText.substr( nPos + sPar.length() + 1) ; Trim( sVal, " \t\r\n\"") ; return true ; } } //---------------------------------------------------------------------------- bool ImportBtl::GetParamP( const string& sText, int nInd, int& nVal) { // creo l'identificativo string sPar = PAR_P + ToString( nInd, 2) ; // leggo il parametro double dVal ; bool bOk = GetParam( sText, sPar, dVal) ; nVal = lround( dVal) ; return bOk ; } //---------------------------------------------------------------------------- bool ImportBtl::GetParamP( const string& sText, int nInd, double& dVal) { // creo l'identificativo string sPar = PAR_P + ToString( nInd, 2) ; // leggo il parametro return GetParam( sText, sPar, dVal) ; } //---------------------------------------------------------------------------- bool ImportBtl::GetParamP( const string& sText, int nInd, string& sVal) { // creo l'identificativo string sPar = PAR_P + ToString( nInd, 2) ; // leggo il parametro return GetParam( sText, sPar, sVal) ; }