Dario Sassi
ccfdbec1ee
- in import BTL aggiunto flag per sort travi secondo il numero di serie (SINGLEMEMBERNUMBER) - in import BTL aggiunto controllo creazione facce di feature che non siano praticamente insignificanti.
858 lines
27 KiB
C++
858 lines
27 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/EgtKeyCodes.h"
|
|
#include "/EgtDev/Include/EgtStringEncoder.h"
|
|
#include "/EgtDev/Include/EgtPointerOwner.h"
|
|
|
|
using namespace std ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Sezioni
|
|
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
|
|
static const std::string KEY_BUILD = "BUILD" ;
|
|
static const std::string KEY_SCALEUNIT = "SCALEUNIT" ;
|
|
static const std::string KEY_SINGLEMEMBERNUMBER = "SINGLEMEMBERNUMBER" ;
|
|
static const std::string KEY_DESIGNATION = "DESIGNATION" ;
|
|
static const std::string KEY_COUNT = "COUNT" ;
|
|
static const std::string KEY_LENGTH = "LENGTH" ;
|
|
static const std::string KEY_HEIGHT = "HEIGHT" ;
|
|
static const std::string KEY_WIDTH = "WIDTH" ;
|
|
static const std::string KEY_UID = "UID" ;
|
|
static const std::string KEY_TRANSFORMATION = "TRANSFORMATION" ;
|
|
static const std::string KEY_OUTLINE = "OUTLINE" ;
|
|
static const std::string KEY_APERTURE = "APERTURE" ;
|
|
static const std::string KEY_PROCESSKEY = "PROCESSKEY" ;
|
|
static const std::string KEY_REFERENCEPLANE = "REFERENCEPLANE" ;
|
|
static const std::string KEY_PROCESSPARAMETERS = "PROCESSPARAMETERS" ;
|
|
static const std::string KEY_PROCESSIDENT = "PROCESSIDENT" ;
|
|
static const std::string KEY_PROCESS = "PROCESS" ;
|
|
static const std::string KEY_USERATTRIBUTE = "USERATTRIBUTE" ;
|
|
static const std::string KEY_COMMENT = "COMMENT" ;
|
|
// Parametri
|
|
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_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 false ;
|
|
// 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) ;
|
|
if ( ! m_BtlGeom.Init( pGDB, nFlatVertPos, bSpecialTrim)) {
|
|
LOG_ERROR( GetEExLogger(), " Error on BtlGeom.Init")
|
|
return false ;
|
|
}
|
|
|
|
// 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 == 1) ;
|
|
}
|
|
// spezzo la linea
|
|
string sKey, sVal ;
|
|
SplitFirst( sLine, ":", sKey, sVal) ;
|
|
// se numero di versione
|
|
if ( sKey == KEY_BUILD) {
|
|
Trim( sVal, " \t\r\n\"") ;
|
|
if ( FromString( sVal, m_nBuild))
|
|
++ nRead ;
|
|
}
|
|
}
|
|
|
|
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 == 1) ;
|
|
}
|
|
// spezzo la linea
|
|
string sKey, sVal ;
|
|
SplitFirst( sLine, ":", sKey, sVal) ;
|
|
// se numero di decimali
|
|
if ( sKey == KEY_SCALEUNIT) {
|
|
int nUnit ;
|
|
if ( FromString( sVal, nUnit)) {
|
|
m_dScale = pow( 10, - nUnit) ;
|
|
++ nRead ;
|
|
}
|
|
}
|
|
// se attributo utente
|
|
else if ( sKey == KEY_USERATTRIBUTE) {
|
|
m_BtlGeom.SetUserAttribute( UATD_INFO, sVal) ;
|
|
}
|
|
}
|
|
|
|
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 ;
|
|
bool bOutline = false ;
|
|
int nUID = 0 ;
|
|
while ( m_theScanner.GetLine( sLine)) {
|
|
// se cambio sezione
|
|
if ( sLine[0] == '[') {
|
|
m_theScanner.UngetLine( sLine) ;
|
|
bEnd = false ;
|
|
return true ;
|
|
}
|
|
// spezzo la linea
|
|
string sKey, sVal ;
|
|
SplitFirst( sLine, ":", sKey, sVal) ;
|
|
// identificativo di produzione
|
|
if ( sKey == KEY_SINGLEMEMBERNUMBER) {
|
|
int nProdNbr = 0 ;
|
|
if ( FromString( sVal, nProdNbr))
|
|
m_BtlGeom.SetPartProdNbr( nProdNbr) ;
|
|
}
|
|
// nome
|
|
else if ( sKey == KEY_DESIGNATION) {
|
|
Trim( sVal, " \t\r\n\"") ;
|
|
if ( ! IsTextUtf8( sVal.c_str()))
|
|
sVal = LPSTR( WtoA( LPWSTR( AtoW( sVal.c_str(), 1252)))) ;
|
|
m_BtlGeom.SetPartName( sVal) ;
|
|
}
|
|
// numero di pezzi da produrre
|
|
else if ( sKey == KEY_COUNT) {
|
|
int nCount = 0 ;
|
|
if ( FromString( sVal, nCount))
|
|
m_BtlGeom.SetPartCount( nCount) ;
|
|
}
|
|
// lunghezza (dimensione in X)
|
|
else if ( sKey == KEY_LENGTH) {
|
|
if ( FromString( sVal, dLength)) {
|
|
dLength *= m_dScale ;
|
|
bLength = true ;
|
|
}
|
|
if ( bLength && bHeight && bWidth) {
|
|
if ( m_BtlGeom.AddPartBox( dLength, dHeight, dWidth))
|
|
bBox = true ;
|
|
}
|
|
}
|
|
// altezza (dimensione in Y)
|
|
else if ( sKey == KEY_HEIGHT) {
|
|
if ( FromString( sVal, dHeight)) {
|
|
dHeight *= m_dScale ;
|
|
bHeight = true ;
|
|
}
|
|
if ( bLength && bHeight && bWidth) {
|
|
if ( m_BtlGeom.AddPartBox( dLength, dHeight, dWidth))
|
|
bBox = true ;
|
|
}
|
|
}
|
|
// larghezza (dimensione in Z)
|
|
else if ( sKey == KEY_WIDTH) {
|
|
if ( FromString( sVal, dWidth)) {
|
|
dWidth *= m_dScale ;
|
|
bWidth = true ;
|
|
}
|
|
if ( bLength && bHeight && bWidth) {
|
|
if ( m_BtlGeom.AddPartBox( dLength, dHeight, dWidth))
|
|
bBox = true ;
|
|
}
|
|
}
|
|
// UID istanza pezzo nella struttura
|
|
else if ( sKey == KEY_UID) {
|
|
FromString( sVal, nUID) ;
|
|
}
|
|
// matrice di trasformazione istanza pezzo nella struttura
|
|
else if ( sKey == KEY_TRANSFORMATION) {
|
|
Frame3d frRef ;
|
|
if ( ReadTransformation( sVal, frRef))
|
|
m_BtlGeom.AddPartTransformation( nUID, frRef) ;
|
|
}
|
|
// contorno
|
|
else if ( sKey == KEY_OUTLINE) {
|
|
// 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 ;
|
|
}
|
|
bOutline = true ;
|
|
}
|
|
// apertura
|
|
else if ( sKey == KEY_APERTURE) {
|
|
// 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 ;
|
|
}
|
|
}
|
|
// lavorazione
|
|
else if ( sKey == KEY_PROCESSKEY) {
|
|
m_theScanner.UngetLine( sLine) ;
|
|
break ;
|
|
}
|
|
// se attributo utente
|
|
else if ( sKey == KEY_USERATTRIBUTE) {
|
|
m_BtlGeom.SetUserAttribute( UATD_PART, sVal) ;
|
|
}
|
|
}
|
|
// 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 ;
|
|
}
|
|
// se non trovato l'outline lo aggiungo
|
|
if ( ! bOutline) {
|
|
if ( ! m_BtlGeom.AddPartStdOutline()) {
|
|
string sOut = " Error (AddPartStdOutline) 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 ;
|
|
}
|
|
}
|
|
|
|
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)
|
|
{
|
|
int nSide = BTL_SIDE_NONE ;
|
|
FCEDEQUE dqFce ;
|
|
// ciclo sulle linee
|
|
string sLine ;
|
|
while ( m_theScanner.GetLine( sLine)) {
|
|
// spezzo la linea
|
|
string sKey, sVal ;
|
|
SplitFirst( sLine, ":", sKey, sVal) ;
|
|
// se cambio tipologia, concludo
|
|
if ( sKey != KEY_OUTLINE) {
|
|
m_theScanner.UngetLine( sLine) ;
|
|
break ;
|
|
}
|
|
// leggo i dati
|
|
// tipo
|
|
int nFlag ;
|
|
GetParamP( sVal, 8, nFlag) ;
|
|
// 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) ;
|
|
}
|
|
// aggiungo i dati alla deque
|
|
dqFce.emplace_back( nFlag, ptP, ptM, 0, 0, 0) ;
|
|
}
|
|
// inserimento del contorno nel pezzo
|
|
return m_BtlGeom.AddPartOutline( nSide, dqFce) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ImportBtl::ReadAperture( void)
|
|
{
|
|
int nSide = BTL_SIDE_NONE ;
|
|
FCEDEQUE dqFce ;
|
|
// ciclo sulle linee
|
|
string sLine ;
|
|
while ( m_theScanner.GetLine( sLine)) {
|
|
// spezzo la linea
|
|
string sKey, sVal ;
|
|
SplitFirst( sLine, ":", sKey, sVal) ;
|
|
// se cambio tipologia, concludo
|
|
if ( sKey != KEY_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))
|
|
return false ;
|
|
nSide = BTL_SIDE_NONE ;
|
|
dqFce.clear() ;
|
|
}
|
|
// 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) ;
|
|
}
|
|
// aggiungo i dati alla deque
|
|
dqFce.emplace_back( nFlag, ptP, ptM, 0, 0, 0) ;
|
|
}
|
|
// inserimento dell'ultima apertura nel pezzo
|
|
return m_BtlGeom.AddPartAperture( nSide, dqFce) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
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( KEY_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) ;
|
|
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( KEY_PROCESSKEY) != string::npos) {
|
|
m_theScanner.UngetLine( sLine) ;
|
|
bProcEnd = false ;
|
|
break ;
|
|
}
|
|
// spezzo la linea
|
|
string sKey, sVal ;
|
|
SplitFirst( sLine, ":", sKey, sVal) ;
|
|
// se riferimento
|
|
if ( sKey == KEY_REFERENCEPLANE) {
|
|
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 ;
|
|
}
|
|
}
|
|
// se parametri
|
|
else if ( sKey == KEY_PROCESSPARAMETERS) {
|
|
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 ;
|
|
}
|
|
// se identificativo
|
|
else if ( sKey == KEY_PROCESSIDENT) {
|
|
FromString( sVal, nProcId) ;
|
|
}
|
|
// se indicazione di produzione
|
|
else if (sKey == KEY_PROCESS) {
|
|
Trim( sVal) ;
|
|
if ( sVal != "YES")
|
|
vsUAtt.emplace_back( "DO:0") ;
|
|
}
|
|
// se attributo utente
|
|
else if ( sKey == KEY_USERATTRIBUTE) {
|
|
vsUAtt.emplace_back( sVal) ;
|
|
}
|
|
}
|
|
// 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( KEY_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, int& nVal)
|
|
{
|
|
// 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") ;
|
|
nVal = 0 ;
|
|
FromString( sVal, nVal) ;
|
|
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) ;
|
|
if ( nPosI == string::npos)
|
|
return false ;
|
|
size_t nPosF = sText.find( "\"", nPosI + 1) ;
|
|
if ( nPosF == string::npos)
|
|
return false ;
|
|
// estraggo la stringa
|
|
sVal = sText.substr( nPosI + 1, nPosF - nPosI - 1) ;
|
|
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) ;
|
|
}
|