Dario Sassi
651 lines
16 KiB
C++
651 lines
16 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2013-2013
|
|
//----------------------------------------------------------------------------
|
|
// File : GeomDB.cpp Data : 08.04.13 Versione : 1.1c1
|
|
// Contenuto : Implementazione della classe GeomDB.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 22.01.13 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include <iostream>
|
|
#include <new>
|
|
#include "GeoConst.h"
|
|
#include "GeomDB.h"
|
|
#include "GdbObjFactory.h"
|
|
#include "GeoObjTypeFun.h"
|
|
#include "Scan.h"
|
|
#include "StringUtils.h"
|
|
|
|
using namespace std ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
// GeomDB
|
|
//----------------------------------------------------------------------------
|
|
GeomDB::GeomDB( void)
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
GeomDB::~GeomDB( void)
|
|
{
|
|
Clear() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::Init( void)
|
|
{
|
|
// imposto numero minimo buckets di m_GdbNameMap
|
|
m_GdbNameMap.rehash( 128) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::Clear( void)
|
|
{
|
|
PGDBO_LIST::iterator Iter ;
|
|
|
|
|
|
// ciclo di pulizia
|
|
for ( Iter = m_GeomDB.begin() ; Iter != m_GeomDB.end() ; Iter++)
|
|
delete (*Iter) ;
|
|
|
|
m_GeomDB.clear() ;
|
|
m_GdbNameMap.clear() ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::Load( std::ifstream& osIn)
|
|
{
|
|
bool bOk ;
|
|
bool bEnd ;
|
|
CScan TheScanner ;
|
|
|
|
|
|
// inizializzo lo scanner
|
|
if ( ! TheScanner.Initialize( osIn)) {
|
|
cout << "GeomDbLoad : Error on Init " << endl ;
|
|
return false ;
|
|
}
|
|
|
|
// leggo l'intestazione
|
|
if ( ! LoadStart( TheScanner)) {
|
|
cout << "GeomDbLoad : Error on line " << TheScanner.GetCurrLineNbr() << endl ;
|
|
return false ;
|
|
}
|
|
|
|
// ciclo di lettura degli oggetti
|
|
bOk = true ;
|
|
do {
|
|
if ( ! LoadOneObject( TheScanner, bEnd)) {
|
|
bOk = false ;
|
|
cout << "GeomDbLoad : Error on line " << TheScanner.GetCurrLineNbr() << endl ;
|
|
}
|
|
} while ( ! bEnd) ;
|
|
|
|
return bOk ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::LoadStart( CScan& TheScanner)
|
|
{
|
|
string sLine ;
|
|
|
|
|
|
// recupero la prima linea
|
|
if ( ! TheScanner.GetLine( sLine))
|
|
return false ;
|
|
|
|
// deve essere l'intestazione
|
|
if ( sLine != "START")
|
|
return false ;
|
|
|
|
// recupero la riga successiva
|
|
if ( ! TheScanner.GetLine( sLine))
|
|
return false ;
|
|
|
|
// leggo i parametri
|
|
// TODO
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::LoadOneObject( CScan& TheScanner, bool& bEnd)
|
|
{
|
|
string sLine ;
|
|
GdbObj* pGObj ;
|
|
|
|
|
|
// recupero la prossima linea (con il tipo di oggetto)
|
|
if ( ! TheScanner.GetLine( sLine)) {
|
|
bEnd = true ;
|
|
return false ;
|
|
}
|
|
|
|
// se fine
|
|
if ( sLine == "END") {
|
|
bEnd = true ;
|
|
}
|
|
// altrimenti oggetto
|
|
else {
|
|
bEnd = false ;
|
|
// creo l'oggetto
|
|
pGObj = GDBOBJ_CREATE( sLine) ;
|
|
if ( pGObj == nullptr)
|
|
return false ;
|
|
// ne leggo i dati e lo inserisco nel DB
|
|
if ( ! pGObj->Load( TheScanner) ||
|
|
! AddToGeomDB( pGObj)) {
|
|
delete pGObj ;
|
|
return false ;
|
|
}
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::Save( std::ofstream& osOut)
|
|
{
|
|
bool bOk ;
|
|
PGDBO_LIST::iterator Iter ;
|
|
|
|
|
|
bOk = true ;
|
|
// intestazione
|
|
osOut << "START" << endl ;
|
|
osOut << "GeomDB,1.2a3" << endl ;
|
|
// ciclo di scrittura degli oggetti
|
|
for ( Iter = m_GeomDB.begin() ; Iter != m_GeomDB.end() ; ++Iter) {
|
|
// oggetto geometrico
|
|
if ( ! (*Iter)->Save( osOut))
|
|
bOk = false ;
|
|
}
|
|
// terminazione
|
|
osOut << "END" << endl ;
|
|
|
|
return bOk ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::ExistsGdbObj( const std::string& sName)
|
|
{
|
|
STRPGDBO_UMAP::const_iterator Iter ;
|
|
|
|
|
|
Iter = m_GdbNameMap.find( sName) ;
|
|
return ( Iter != m_GdbNameMap.end()) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
GdbObj*
|
|
GeomDB::GetGdbObj( const std::string& sName)
|
|
{
|
|
STRPGDBO_UMAP::const_iterator Iter ;
|
|
|
|
|
|
Iter = m_GdbNameMap.find( sName) ;
|
|
if ( Iter != m_GdbNameMap.end())
|
|
return Iter->second ;
|
|
else
|
|
return nullptr ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::AddToGeomDB( GdbObj* pGObj)
|
|
{
|
|
// verifico validità oggetto puntato
|
|
if ( pGObj == nullptr)
|
|
return false ;
|
|
|
|
// verifica validità e unicità del nome
|
|
if ( pGObj->m_sName.length() == 0 || ExistsGdbObj( pGObj->m_sName))
|
|
return false ;
|
|
|
|
// inserisco in lista principale
|
|
m_GeomDB.push_back( pGObj) ;
|
|
|
|
// inserisco in mappa nomi
|
|
m_GdbNameMap[ pGObj->m_sName] = pGObj ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::AddVector( const string& sName, const Vector3d& Vect)
|
|
{
|
|
GdbVector3d* pGVect ;
|
|
|
|
|
|
// verifico validità nome
|
|
if ( sName.length() == 0)
|
|
return false ;
|
|
// alloco oggetto
|
|
pGVect = new(nothrow) GdbVector3d ;
|
|
if ( pGVect == nullptr)
|
|
return false ;
|
|
// assegno nome
|
|
pGVect->m_sName = sName ;
|
|
// assegno dati
|
|
pGVect->m_gvV.Set( Vect) ;
|
|
// inserisco nel DB
|
|
if ( ! AddToGeomDB( pGVect)) {
|
|
delete pGVect ;
|
|
return false ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::AddPoint( const string& sName, const Point3d& Pnt)
|
|
{
|
|
GdbPoint3d* pGPnt ;
|
|
|
|
|
|
// verifico validità nome
|
|
if ( sName.length() == 0)
|
|
return false ;
|
|
// alloco oggetto
|
|
pGPnt = new(nothrow) GdbPoint3d ;
|
|
if ( pGPnt == nullptr)
|
|
return false ;
|
|
// assegno nome
|
|
pGPnt->m_sName = sName ;
|
|
// assegno dati
|
|
pGPnt->m_gpP.Set( Pnt) ;
|
|
// inserisco nel DB
|
|
if ( ! AddToGeomDB( pGPnt)) {
|
|
delete pGPnt ;
|
|
return false ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::AddCurveLine( const string& sName, const CurveLine& CrvLine)
|
|
{
|
|
GdbCurveLine* pGdbCL ;
|
|
|
|
|
|
// verifico validità nome
|
|
if ( sName.length() == 0)
|
|
return false ;
|
|
// verifico validità dati geometrici
|
|
if ( ! CrvLine.IsValid())
|
|
return false ;
|
|
// allocazione oggetto
|
|
pGdbCL = new(nothrow) GdbCurveLine ;
|
|
if ( pGdbCL == nullptr)
|
|
return false ;
|
|
// assegnazione nome
|
|
pGdbCL->m_sName = sName ;
|
|
// assegnazione dati
|
|
pGdbCL->m_ln = CrvLine ;
|
|
// inserimento nel DB
|
|
if ( ! AddToGeomDB( pGdbCL)) {
|
|
delete pGdbCL ;
|
|
return false ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::AddCurveArc( const string& sName, const CurveArc& CrvArc)
|
|
{
|
|
GdbCurveArc* pGdbCA ;
|
|
|
|
|
|
// verifico validità nome
|
|
if ( sName.length() == 0)
|
|
return false ;
|
|
// verifico validità dati geometrici
|
|
if ( ! CrvArc.IsValid())
|
|
return false ;
|
|
// alloco oggetto
|
|
pGdbCA = new(nothrow) GdbCurveArc ;
|
|
if ( pGdbCA == nullptr)
|
|
return false ;
|
|
// assegno nome
|
|
pGdbCA->m_sName = sName ;
|
|
// assegno dati
|
|
pGdbCA->m_ar = CrvArc ;
|
|
// inserisco nel DB
|
|
if ( ! AddToGeomDB( pGdbCA)) {
|
|
delete pGdbCA ;
|
|
return false ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::AddCurveBez( const string& sName, const CurveBezier& CrvBez)
|
|
{
|
|
GdbCurveBezier* pGdbCB ;
|
|
|
|
|
|
// verifico validità nome
|
|
if ( sName.length() == 0)
|
|
return false ;
|
|
// verifico validità dati geometrici
|
|
if ( ! CrvBez.IsValid())
|
|
return false ;
|
|
// allocazione oggetto
|
|
pGdbCB = new(nothrow) GdbCurveBezier ;
|
|
if ( pGdbCB == nullptr)
|
|
return false ;
|
|
// assegnazione nome
|
|
pGdbCB->m_sName = sName ;
|
|
// assegnamento dati
|
|
pGdbCB->m_bz = CrvBez ;
|
|
// inserimento nel DB
|
|
if ( ! AddToGeomDB( pGdbCB)) {
|
|
delete pGdbCB ;
|
|
return false ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::AddCurveCompo( const string& sName, const CurveComposite& CrvCompo)
|
|
{
|
|
GdbCurveComposite* pGdbCC ;
|
|
|
|
|
|
// verifico validità nome
|
|
if ( sName.length() == 0)
|
|
return false ;
|
|
// verifico validità dati geometrici
|
|
if ( ! CrvCompo.IsValid())
|
|
return false ;
|
|
// allocazione oggetto
|
|
pGdbCC = new(nothrow) GdbCurveComposite ;
|
|
if ( pGdbCC == nullptr)
|
|
return false ;
|
|
// assegnazione nome
|
|
pGdbCC->m_sName = sName ;
|
|
// assegnamento dati
|
|
pGdbCC->m_cc = CrvCompo ;
|
|
// inserimento nel DB
|
|
if ( ! AddToGeomDB( pGdbCC)) {
|
|
delete pGdbCC ;
|
|
return false ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
GeoObjType
|
|
GeomDB::GetObjType( const std::string& sName)
|
|
{
|
|
const GdbObj* pGObj ;
|
|
|
|
|
|
// recupero l'oggetto
|
|
if ( ( pGObj = GetGdbObj( sName)) == nullptr)
|
|
return GEO_NONE ;
|
|
// ne identifico il tipo
|
|
return pGObj->GetType() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const GeoVector3d*
|
|
GeomDB::GetGeoVector3d( const string& sName)
|
|
{
|
|
const GdbObj* pGObj ;
|
|
|
|
|
|
// recupero l'oggetto e ne verifico il tipo
|
|
if ( ( pGObj = GetGdbObj( sName)) == nullptr || pGObj->GetType() != GEO_VECT3D)
|
|
return nullptr ;
|
|
|
|
// assegno il vettore per riferimento
|
|
return &(static_cast<const GdbVector3d*>(pGObj))->m_gvV ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const Vector3d*
|
|
GeomDB::GetVector( const string& sName)
|
|
{
|
|
return &( GetGeoVector3d( sName)->m_vtV) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const GeoPoint3d*
|
|
GeomDB::GetGeoPoint3d( const string& sName)
|
|
{
|
|
const GdbObj* pGObj ;
|
|
|
|
|
|
// recupero l'oggetto e ne verifico il tipo
|
|
if ( ( pGObj = GetGdbObj( sName)) == nullptr || pGObj->GetType() != GEO_PNT3D)
|
|
return nullptr ;
|
|
|
|
// assegno il punto per riferimento
|
|
return &(static_cast<const GdbPoint3d*>(pGObj))->m_gpP ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const Point3d*
|
|
GeomDB::GetPoint( const string& sName)
|
|
{
|
|
return &( GetGeoPoint3d( sName)->m_ptP) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const CurveLine*
|
|
GeomDB::GetCurveLine( const string& sName)
|
|
{
|
|
const GdbObj* pGObj ;
|
|
|
|
|
|
// recupero l'oggetto e ne verifico il tipo
|
|
if ( ( pGObj = GetGdbObj( sName)) == nullptr || pGObj->GetType() != CRV_LINE)
|
|
return nullptr ;
|
|
|
|
// assegno la linea per riferimento
|
|
return &(static_cast<const GdbCurveLine*>(pGObj))->m_ln ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const CurveArc*
|
|
GeomDB::GetCurveArc( const string& sName)
|
|
{
|
|
const GdbObj* pGObj ;
|
|
|
|
|
|
// recupero l'oggetto e ne verifico il tipo
|
|
if ( ( pGObj = GetGdbObj( sName)) == nullptr || pGObj->GetType() != CRV_ARC)
|
|
return nullptr ;
|
|
|
|
// assegno l'arco per riferimento
|
|
return &(static_cast<const GdbCurveArc*>(pGObj))->m_ar ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const CurveBezier*
|
|
GeomDB::GetCurveBez( const string& sName)
|
|
{
|
|
const GdbObj* pGObj ;
|
|
|
|
|
|
// recupero l'oggetto e ne verifico il tipo
|
|
if ( ( pGObj = GetGdbObj( sName)) == nullptr || pGObj->GetType() != CRV_BEZ)
|
|
return nullptr ;
|
|
|
|
// assegno la curva di Bezier per riferimento
|
|
return &(static_cast<const GdbCurveBezier*>(pGObj))->m_bz ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const CurveComposite*
|
|
GeomDB::GetCurveCompo( const std::string& sName)
|
|
{
|
|
const GdbObj* pGObj ;
|
|
|
|
|
|
// recupero l'oggetto e ne verifico il tipo
|
|
if ( ( pGObj = GetGdbObj( sName)) == nullptr || pGObj->GetType() != CRV_COMPO)
|
|
return nullptr ;
|
|
|
|
// assegno la curva di Bezier per riferimento
|
|
return &(static_cast<const GdbCurveComposite*>(pGObj))->m_cc ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const Curve*
|
|
GeomDB::GetCurve( const string& sName)
|
|
{
|
|
const GdbObj* pGObj ;
|
|
|
|
|
|
// recupero l'oggetto
|
|
if ( ( pGObj = GetGdbObj( sName)) == nullptr)
|
|
return nullptr ;
|
|
|
|
// ritorno il puntatore alla curva (oppure nullptr se non è una curva)
|
|
return ::GetCurve( pGObj->GetGeoObj()) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::Copy( const string& sNameSou, const string& sNameDest)
|
|
{
|
|
GdbObj* pGdoSou ;
|
|
GdbObj* pGdoDest ;
|
|
|
|
|
|
// verifico esistenza del sorgente
|
|
if ( ( pGdoSou = GetGdbObj( sNameSou)) == nullptr)
|
|
return false ;
|
|
|
|
// eseguo la copia
|
|
if ( ( pGdoDest = pGdoSou->Clone()) == nullptr)
|
|
return false ;
|
|
|
|
// assegno il nuovo nome
|
|
pGdoDest->m_sName = sNameDest ;
|
|
|
|
// inserisco nel DB
|
|
if ( ! AddToGeomDB( pGdoDest)) {
|
|
delete pGdoDest ;
|
|
return false ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::Erase( const string& sName)
|
|
{
|
|
PGDBO_LIST::iterator Iter ;
|
|
|
|
|
|
// elimino da mappa dei nomi
|
|
m_GdbNameMap.erase( sName) ;
|
|
|
|
// elimino da lista principale
|
|
for ( Iter = m_GeomDB.begin() ; Iter != m_GeomDB.end() ; Iter++) {
|
|
// se oggetto cercato
|
|
if ( (*Iter)->m_sName == sName) {
|
|
// lo disalloco (distruttore virtuale)
|
|
delete( (*Iter)) ;
|
|
// lo tolgo dalla lista
|
|
m_GeomDB.erase( Iter) ;
|
|
// esco
|
|
return true ;
|
|
}
|
|
}
|
|
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::Translate( const string& sName, const Vector3d& vtMove)
|
|
{
|
|
GdbObj* pGObj ;
|
|
|
|
|
|
// recupero l'oggetto
|
|
if ( ( pGObj = GetGdbObj( sName)) == nullptr)
|
|
return false ;
|
|
|
|
// eseguo l'operazione
|
|
return pGObj->Translate( vtMove) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::Rotate( const string& sName, const Point3d& ptAx, const Vector3d& vtAx, double dAngDeg)
|
|
{
|
|
GdbObj* pGObj ;
|
|
|
|
|
|
// recupero l'oggetto
|
|
if ( ( pGObj = GetGdbObj( sName)) == nullptr)
|
|
return false ;
|
|
|
|
// eseguo l'operazione
|
|
return pGObj->Rotate( ptAx, vtAx, dAngDeg * DEGTORAD) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::Scale( const string& sName, const Point3d& ptCen, double dCoeffX, double dCoeffY, double dCoeffZ)
|
|
{
|
|
GdbObj* pGObj ;
|
|
|
|
|
|
// recupero l'oggetto
|
|
if ( ( pGObj = GetGdbObj( sName)) == nullptr)
|
|
return false ;
|
|
|
|
// eseguo l'operazione
|
|
return pGObj->Scale( ptCen, dCoeffX, dCoeffY, dCoeffZ) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GeomDB::Mirror( const string& sName, const Point3d& ptOn, const Vector3d& vtNorm)
|
|
{
|
|
GdbObj* pGObj ;
|
|
|
|
|
|
// recupero l'oggetto
|
|
if ( ( pGObj = GetGdbObj( sName)) == nullptr)
|
|
return false ;
|
|
|
|
// eseguo l'operazione
|
|
return pGObj->Mirror( ptOn, vtNorm) ;
|
|
}
|