Dario Sassi
1447 lines
47 KiB
C++
1447 lines
47 KiB
C++
//----------------------------------------------------------------------------
|
|
// 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<string,KEY_GENE_ZZZ> 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<string,KEY_RAWP_ZZZ> 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<string,KEY_PART_ZZZ> 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<string,KEY_PROC_ZZZ> 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<IImportBtl*> ( 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 nTrasfCount = 0, 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)) {
|
|
++ nTrasfCount ;
|
|
m_BtlGeom.AddPartTransformation( ToString( nUID), frRef) ;
|
|
string sUIDKey = sPartKey[KEY_PART_UID] + ToString( nTrasfCount) ;
|
|
m_BtlGeom.SetUserAttribute( UATD_PART, sUIDKey, ToString( nUID)) ;
|
|
string sTRFKey = sPartKey[KEY_PART_TRANSFORMATION] + ToString( nTrasfCount) ;
|
|
m_BtlGeom.SetUserAttribute( UATD_PART, sTRFKey, ToString( 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\"") ;
|
|
int nSide ;
|
|
bool bAlign ;
|
|
if ( ReadReferenceSide( sVal, nSide, bAlign))
|
|
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, ToString( nSide) + ";" + ( bAlign ? "1" : "0")) ;
|
|
}
|
|
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\"") ;
|
|
string sVal1, sVal2 ;
|
|
Split( sVal, ":", true, sVal1, sVal2) ;
|
|
Trim( sVal2, " \t\r\n\"") ;
|
|
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal1 + ": " + sVal2) ;
|
|
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 (possono essere su più linee consecutive)
|
|
GetParam( sVal, PAR_X, vtDir.x) ;
|
|
if ( ! GetParam( sVal, PAR_Y, vtDir.y)) {
|
|
string sLine ;
|
|
m_theScanner.GetLine( sLine) ;
|
|
if ( ! GetParam( sLine, PAR_Y, vtDir.y)) {
|
|
m_theScanner.UngetLine( sLine) ;
|
|
return false ;
|
|
}
|
|
}
|
|
if ( ! GetParam( sVal, PAR_Z, vtDir.z)) {
|
|
string sLine ;
|
|
m_theScanner.GetLine( sLine) ;
|
|
if ( ! GetParam( sLine, PAR_Z, vtDir.z)) {
|
|
m_theScanner.UngetLine( sLine) ;
|
|
return false ;
|
|
}
|
|
}
|
|
string sRes ;
|
|
if ( ! GetParam( sVal, PAR_ALIGN, sRes)) {
|
|
string sLine ;
|
|
m_theScanner.GetLine( sLine) ;
|
|
if ( ! GetParam( sLine, PAR_ALIGN, sRes)) {
|
|
m_theScanner.UngetLine( sLine) ;
|
|
return false ;
|
|
}
|
|
}
|
|
bAlign = ( sRes == "YES") ;
|
|
// ritorno
|
|
return ( vtDir.Normalize()) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ImportBtl::ReadReferenceSide( const string& sVal, int& nSide, bool& bAlign)
|
|
{
|
|
// leggo i valori (possono essere su più linee consecutive)
|
|
GetParam( sVal, PAR_SIDE, nSide) ;
|
|
string sRes ;
|
|
if ( ! GetParam( sVal, PAR_ALIGN, sRes)) {
|
|
string sLine ;
|
|
m_theScanner.GetLine( sLine) ;
|
|
if ( ! GetParam( sLine, PAR_ALIGN, sRes)) {
|
|
m_theScanner.UngetLine( sLine) ;
|
|
return false ;
|
|
}
|
|
}
|
|
bAlign = ( sRes == "YES") ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
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, int& nVal)
|
|
{
|
|
// leggo il parametro
|
|
double dVal ;
|
|
bool bOk = GetParam( sText, sPar, dVal) ;
|
|
nVal = lround( dVal / m_dScale) ;
|
|
return bOk ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
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) ;
|
|
}
|