EgtGeomKernel : completata gestione DB geometrico di base.
Aggiunto esecutore di comandi per script.
This commit is contained in:
Dario Sassi
+804
@@ -0,0 +1,804 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2013-2013
|
||||
//----------------------------------------------------------------------------
|
||||
// File : GdbExecutor.cpp Data : 25.11.13 Versione : 1.3a1
|
||||
// Contenuto : Implementazione della classe GdbExecutor.
|
||||
//
|
||||
//
|
||||
//
|
||||
// Modifiche : 27.03.13 DS Creazione modulo.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
//--------------------------- Include ----------------------------------------
|
||||
#include "stdafx.h"
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#include "/EgtDev/Include/EgnStringUtils.h"
|
||||
#include "/EgtDev/Include/EgnStringConverter.h"
|
||||
#include "/EgtDev/Include/EgkGeoPoint3d.h"
|
||||
#include "/EgtDev/Include/EgkGeoVector3d.h"
|
||||
#include "/EgtDev/Include/EgkCurveLine.h"
|
||||
#include "/EgtDev/Include/EgkCurveArc.h"
|
||||
#include "/EgtDev/Include/EgkCurveBezier.h"
|
||||
#include "/EgtDev/Include/EgkCurveComposite.h"
|
||||
#include "/EgtDev/Include/EgtReleasePointer.h"
|
||||
#include "GdbExecutor.h"
|
||||
|
||||
using namespace std ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
IGdbExecutor*
|
||||
CreateGdbExecutor( void)
|
||||
{
|
||||
return static_cast<IGdbExecutor*> ( new GdbExecutor) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
GdbExecutor::GdbExecutor( void)
|
||||
{
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
GdbExecutor::~GdbExecutor( void)
|
||||
{
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::Set( IGeomDB* pGdb)
|
||||
{
|
||||
m_pGDB = pGdb ;
|
||||
|
||||
return ( m_pGDB != nullptr) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::Load( const wstring& sFile)
|
||||
{
|
||||
bool bOk ;
|
||||
ifstream ifLoad ;
|
||||
|
||||
|
||||
ifLoad.open( sFile) ;
|
||||
if ( ifLoad.good()) {
|
||||
bOk = m_pGDB->Load( ifLoad) ;
|
||||
ifLoad.close() ;
|
||||
}
|
||||
else
|
||||
bOk = false ;
|
||||
|
||||
return bOk ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::Save( const wstring& sFile)
|
||||
{
|
||||
bool bOk ;
|
||||
ofstream ofSave ;
|
||||
|
||||
|
||||
ofSave.open( sFile) ;
|
||||
if ( ofSave.good()) {
|
||||
bOk = m_pGDB->Save( ofSave) ;
|
||||
ofSave.close() ;
|
||||
}
|
||||
else
|
||||
bOk = false ;
|
||||
|
||||
return bOk ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::Execute( const string& sCmd1, const string& sCmd2, const STRVECTOR& vsParams)
|
||||
{
|
||||
STRVECTOR::const_iterator theConstIter ;
|
||||
|
||||
|
||||
// output di debug
|
||||
cout << "Cmd = [" << sCmd1 << "/" << sCmd2 << "]" ;
|
||||
cout << " Par = [" ;
|
||||
for ( theConstIter = vsParams.begin() ; theConstIter != vsParams.end() ; theConstIter ++) {
|
||||
if ( theConstIter != vsParams.begin())
|
||||
cout << "/" ;
|
||||
cout << *theConstIter ;
|
||||
}
|
||||
cout << "]" << endl ;
|
||||
|
||||
// esecuzione comando
|
||||
if ( sCmd1 == "P" || sCmd1 == "POINT")
|
||||
return ExecutePoint( sCmd2, vsParams) ;
|
||||
else if ( sCmd1 == "V" || sCmd1 == "VECTOR")
|
||||
return ExecuteVector( sCmd2, vsParams) ;
|
||||
else if ( sCmd1 == "CL" || sCmd1 == "CURVELINE")
|
||||
return ExecuteCurveLine( sCmd2, vsParams) ;
|
||||
else if ( sCmd1 == "CA" || sCmd1 == "CURVEARC")
|
||||
return ExecuteCurveArc( sCmd2, vsParams) ;
|
||||
else if ( sCmd1 == "CB" || sCmd1 == "CURVEBEZIER")
|
||||
return ExecuteCurveBez( sCmd2, vsParams) ;
|
||||
else if ( sCmd1 == "CC" || sCmd1 == "CURVECOMPO")
|
||||
return ExecuteCurveCompo( sCmd2, vsParams) ;
|
||||
else if ( sCmd1 == "COPY")
|
||||
return ExecuteCopy( vsParams) ;
|
||||
else if ( sCmd1 == "ERASE")
|
||||
return ExecuteErase( vsParams) ;
|
||||
else if ( sCmd1 == "MOVE" || sCmd1 == "TRANSLATE")
|
||||
return ExecuteTranslate( vsParams) ;
|
||||
else if ( sCmd1 == "ROTATE")
|
||||
return ExecuteRotate( vsParams) ;
|
||||
else if ( sCmd1 == "SCALE")
|
||||
return ExecuteScale( vsParams) ;
|
||||
else if ( sCmd1 == "MIRROR")
|
||||
return ExecuteMirror( vsParams) ;
|
||||
else if ( sCmd1 == "LOAD")
|
||||
return ExecuteLoad( vsParams) ;
|
||||
else if ( sCmd1 == "SAVE")
|
||||
return ExecuteSave( vsParams) ;
|
||||
else if ( sCmd1 == "OUTSCL")
|
||||
return ExecuteOutScl( sCmd2, vsParams) ;
|
||||
|
||||
return false ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::ExecutePoint( const string& sCmd2, const STRVECTOR& vsParams)
|
||||
{
|
||||
// analisi ed esecuzione dei comandi
|
||||
if ( sCmd2 == "MAKE" || sCmd2 == "") {
|
||||
Point3d Pnt ;
|
||||
// 4 parametri : un nome e 3 coordinate
|
||||
if ( vsParams.size() != 4)
|
||||
return false ;
|
||||
// recupero le tre coordinate
|
||||
if ( ! FromString( vsParams[1], Pnt.x) ||
|
||||
! FromString( vsParams[2], Pnt.y) ||
|
||||
! FromString( vsParams[3], Pnt.z))
|
||||
return false ;
|
||||
// creo il punto
|
||||
IGeoPoint3d* pGPnt = CreateGeoPoint3d() ;
|
||||
if ( pGPnt == nullptr)
|
||||
return false ;
|
||||
pGPnt->Set( Pnt) ;
|
||||
return m_pGDB->AddGeoObj( vsParams[0], pGPnt) ;
|
||||
}
|
||||
|
||||
return false ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::ExecuteVector( const string& sCmd2, const STRVECTOR& vsParams)
|
||||
{
|
||||
// analisi ed esecuzione dei comandi
|
||||
if ( sCmd2 == "MAKE" || sCmd2 == "") {
|
||||
Vector3d Vect ;
|
||||
// 4 parametri
|
||||
if ( vsParams.size() != 4)
|
||||
return false ;
|
||||
// recupero i tre componenti
|
||||
if ( ! FromString( vsParams[1], Vect.x) ||
|
||||
! FromString( vsParams[2], Vect.y) ||
|
||||
! FromString( vsParams[3], Vect.z))
|
||||
return false ;
|
||||
// creo il vettore
|
||||
IGeoVector3d* pGVect = CreateGeoVector3d() ;
|
||||
if ( pGVect == nullptr)
|
||||
return false ;
|
||||
pGVect->Set( Vect) ;
|
||||
return m_pGDB->AddGeoObj( vsParams[0], pGVect) ;
|
||||
}
|
||||
|
||||
return false ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::ExecuteCurveLine( const string& sCmd2, const STRVECTOR& vsParams)
|
||||
{
|
||||
// analisi ed esecuzione dei comandi
|
||||
if ( sCmd2 == "MAKE" || sCmd2 == "") {
|
||||
Point3d ptStart ;
|
||||
Point3d ptEnd ;
|
||||
// 3 parametri
|
||||
if ( vsParams.size() != 3)
|
||||
return false ;
|
||||
// recupero e setto punti iniziale e finale
|
||||
if ( ! GetPointParam( vsParams[1], ptStart) ||
|
||||
! GetPointParam( vsParams[2], ptEnd))
|
||||
return false ;
|
||||
// creo la linea
|
||||
ReleasePtr<ICurveLine> pCrvLine( CreateCurveLine()) ;
|
||||
if ( ! IsValid( pCrvLine) || ! pCrvLine->Set( ptStart, ptEnd))
|
||||
return false ;
|
||||
return m_pGDB->AddGeoObj( vsParams[0], Release( pCrvLine)) ;
|
||||
}
|
||||
|
||||
return false ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::ExecuteCurveArc( const string& sCmd2, const STRVECTOR& vsParams)
|
||||
{
|
||||
// creo l'arco
|
||||
ReleasePtr<ICurveArc> pCrvArc( CreateCurveArc()) ;
|
||||
if ( ! IsValid( pCrvArc))
|
||||
return false ;
|
||||
|
||||
// arco generico
|
||||
if ( sCmd2 == "MAKE" || sCmd2 == "") {
|
||||
Point3d ptCen ;
|
||||
Vector3d vtN ;
|
||||
double dRad ;
|
||||
Vector3d vtS ;
|
||||
double dAngCenDeg ;
|
||||
double dDeltaZ ;
|
||||
// 7 parametri
|
||||
if ( vsParams.size() != 7)
|
||||
return false ;
|
||||
// centro
|
||||
if ( ! GetPointParam( vsParams[1], ptCen))
|
||||
return false ;
|
||||
// versore ortogonale al piano della circonferenza
|
||||
if ( ! GetVectorParam( vsParams[2], vtN))
|
||||
return false ;
|
||||
// raggio
|
||||
if ( ! FromString( vsParams[3], dRad))
|
||||
return false ;
|
||||
// versore iniziale
|
||||
if ( ! GetVectorParam( vsParams[4], vtS))
|
||||
return false ;
|
||||
// angolo al centro
|
||||
if ( ! FromString( vsParams[5], dAngCenDeg))
|
||||
return false ;
|
||||
// deltaZ
|
||||
if ( ! FromString( vsParams[6], dDeltaZ))
|
||||
return false ;
|
||||
// setto l'arco
|
||||
if ( ! pCrvArc->Set( ptCen, vtN, dRad, vtS, dAngCenDeg, dDeltaZ))
|
||||
return false ;
|
||||
}
|
||||
// arco nel piano XY
|
||||
else if ( sCmd2 == "PLANEXY" || sCmd2 == "XY") {
|
||||
Point3d ptCen ;
|
||||
double dRad ;
|
||||
double dAngIniDeg ;
|
||||
double dAngCenDeg ;
|
||||
double dDeltaZ ;
|
||||
// 6 parametri
|
||||
if ( vsParams.size() != 6)
|
||||
return false ;
|
||||
// centro
|
||||
if ( ! GetPointParam( vsParams[1], ptCen))
|
||||
return false ;
|
||||
// raggio
|
||||
if ( ! FromString( vsParams[2], dRad))
|
||||
return false ;
|
||||
// angolo iniziale
|
||||
if ( ! FromString( vsParams[3], dAngIniDeg))
|
||||
return false ;
|
||||
// angolo al centro
|
||||
if ( ! FromString( vsParams[4], dAngCenDeg))
|
||||
return false ;
|
||||
// deltaZ
|
||||
if ( ! FromString( vsParams[5], dDeltaZ))
|
||||
return false ;
|
||||
// setto l'arco
|
||||
if ( ! pCrvArc->Set( ptCen, dRad, dAngIniDeg, dAngCenDeg, dDeltaZ))
|
||||
return false ;
|
||||
}
|
||||
// altrimenti errore
|
||||
else
|
||||
return false ;
|
||||
|
||||
// inserisco l'arco nel DB
|
||||
return m_pGDB->AddGeoObj( vsParams[0], Release( pCrvArc)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::ExecuteCurveBez( const string& sCmd2, const STRVECTOR& vsParams)
|
||||
{
|
||||
// creo la curva di Bezier
|
||||
ReleasePtr<ICurveBezier> pCrvBez( CreateCurveBezier()) ;
|
||||
if ( ! IsValid( pCrvBez))
|
||||
return false ;
|
||||
|
||||
// curva di Bezier intera (non razionale)
|
||||
if ( sCmd2 == "INTEG" || sCmd2 == "I") {
|
||||
int i ;
|
||||
int nDeg ;
|
||||
Point3d ptP ;
|
||||
// almeno 2 parametri
|
||||
if ( vsParams.size() < 2)
|
||||
return false ;
|
||||
// recupero il grado
|
||||
if ( ! FromString( vsParams[1], nDeg))
|
||||
return false ;
|
||||
// inizializzo la curva di Bezier
|
||||
if ( ! pCrvBez->Init( nDeg, false))
|
||||
return false ;
|
||||
// recupero e setto punti di controllo
|
||||
for ( i = 0 ; i <= nDeg ; i ++) {
|
||||
if ( ! GetPointParam( vsParams[i+2], ptP) ||
|
||||
! pCrvBez->SetControlPoint( i, ptP))
|
||||
return false ;
|
||||
}
|
||||
}
|
||||
// curva di Bezier razionale
|
||||
else if ( sCmd2 == "RATIO" || sCmd2 == "R") {
|
||||
int i ;
|
||||
int nDeg ;
|
||||
double dW ;
|
||||
Point3d ptP ;
|
||||
// almeno 2 parametri
|
||||
if ( vsParams.size() < 2)
|
||||
return false ;
|
||||
// recupero il grado
|
||||
if ( ! FromString( vsParams[1], nDeg))
|
||||
return false ;
|
||||
// inizializzo la curva di Bezier
|
||||
if ( ! pCrvBez->Init( nDeg, true))
|
||||
return false ;
|
||||
// recupero e setto punti di controllo
|
||||
for ( i = 0 ; i <= nDeg ; i ++) {
|
||||
if ( ! GetPointWeParam( vsParams[i+2], ptP, dW) ||
|
||||
! pCrvBez->SetControlPoint( i, ptP, dW))
|
||||
return false ;
|
||||
}
|
||||
}
|
||||
// altrimenti errore
|
||||
else
|
||||
return false ;
|
||||
|
||||
// inserisco la curva di Bezier nel DB
|
||||
return m_pGDB->AddGeoObj( vsParams[0], Release( pCrvBez)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::ExecuteCurveCompo( const string& sCmd2, const STRVECTOR& vsParams)
|
||||
{
|
||||
// curva composita generica
|
||||
if ( sCmd2 == "MAKE" || sCmd2 == "") {
|
||||
bool bErase ;
|
||||
STRVECTOR vsNames ;
|
||||
STRVECTOR::iterator Iter ;
|
||||
const ICurve* pCrv ;
|
||||
ReleasePtr<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
|
||||
if ( ! IsValid( pCrvCompo))
|
||||
return false ;
|
||||
// 2 o 3 parametri
|
||||
switch ( vsParams.size()) {
|
||||
case 2 : bErase = false ; break ;
|
||||
case 3 : bErase = ( vsParams[2] != "0") ; break ;
|
||||
default : return false ; break ;
|
||||
}
|
||||
// recupero lista nomi
|
||||
if ( ! GetNamesParam( vsParams[1], vsNames))
|
||||
return false ;
|
||||
// esecuzione
|
||||
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; Iter++) {
|
||||
// recupero la curva
|
||||
pCrv = GetCurve( m_pGDB->GetGeoObj( *Iter)) ;
|
||||
if ( pCrv == nullptr)
|
||||
return false ;
|
||||
// aggiungo questa curva
|
||||
if ( ! pCrvCompo->AddCurve( *pCrv))
|
||||
return false ;
|
||||
}
|
||||
// inserisco la curva composita nel DB
|
||||
if ( m_pGDB->AddGeoObj( vsParams[0], Release( pCrvCompo))) {
|
||||
// se richiesto, cancello le curve originali
|
||||
if ( bErase) {
|
||||
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; Iter++) {
|
||||
if ( ! m_pGDB->Erase( (*Iter)))
|
||||
return false ;
|
||||
}
|
||||
}
|
||||
return true ;
|
||||
}
|
||||
else
|
||||
return false ;
|
||||
}
|
||||
|
||||
return false ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::GetNamesParam( const std::string& sParam, STRVECTOR& vsNames)
|
||||
{
|
||||
STRVECTOR::iterator Iter ;
|
||||
|
||||
|
||||
// divido in parti
|
||||
Tokenize( sParam, ",", vsNames) ;
|
||||
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; Iter++)
|
||||
Trim( (*Iter), " \t\r\n()") ;
|
||||
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::GetVectorParam( const std::string& sParam, Vector3d& vtV)
|
||||
{
|
||||
// se insieme di tre componenti
|
||||
if ( sParam[0] == '(') {
|
||||
STRVECTOR vsParams ;
|
||||
STRVECTOR::iterator Iter ;
|
||||
// divido in parti
|
||||
Tokenize( sParam, ",", vsParams) ;
|
||||
for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; Iter++)
|
||||
Trim( (*Iter), " \t\r\n()") ;
|
||||
// verifico siano 3 parti e le converto
|
||||
if ( vsParams.size() != 3)
|
||||
return false ;
|
||||
return ( FromString( vsParams[0], vtV.x) &&
|
||||
FromString( vsParams[1], vtV.y) &&
|
||||
FromString( vsParams[2], vtV.z)) ;
|
||||
}
|
||||
// altrimenti nome di vettore già nel DB
|
||||
else {
|
||||
const IGeoVector3d* pV ;
|
||||
if ( ( pV = GetGeoVector3d( m_pGDB->GetGeoObj( sParam))) == nullptr)
|
||||
return false ;
|
||||
vtV = pV->GetVector() ;
|
||||
return true ;
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::GetPointParam( const std::string& sParam, Point3d& ptP)
|
||||
{
|
||||
// se insieme di tre coordinate
|
||||
if ( sParam[0] == '(') {
|
||||
STRVECTOR vsParams ;
|
||||
STRVECTOR::iterator Iter ;
|
||||
// divido in parti
|
||||
Tokenize( sParam, ",", vsParams) ;
|
||||
for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; Iter++)
|
||||
Trim( (*Iter), " \t\r\n()") ;
|
||||
// verifico siano 3 parti e le converto
|
||||
if ( vsParams.size() != 3)
|
||||
return false ;
|
||||
return ( FromString( vsParams[0], ptP.x) &&
|
||||
FromString( vsParams[1], ptP.y) &&
|
||||
FromString( vsParams[2], ptP.z)) ;
|
||||
}
|
||||
// altrimenti nome di punto già nel DB
|
||||
else {
|
||||
const IGeoPoint3d* pPt ;
|
||||
if ( ( pPt = GetGeoPoint3d( m_pGDB->GetGeoObj( sParam))) == nullptr)
|
||||
return false ;
|
||||
ptP = pPt->GetPoint() ;
|
||||
return true ;
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::GetPointWeParam( const std::string& sParam, Point3d& ptP, double& dW)
|
||||
{
|
||||
STRVECTOR vsParams ;
|
||||
STRVECTOR::iterator Iter ;
|
||||
|
||||
|
||||
// deve essere insieme di dati
|
||||
if ( sParam[0] != '(')
|
||||
return false ;
|
||||
|
||||
// divido in parti
|
||||
Tokenize( sParam, ",", vsParams) ;
|
||||
for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; Iter++)
|
||||
Trim( (*Iter), " \t\r\n()") ;
|
||||
|
||||
// se 4 parti, sono 3 coordinate e un peso
|
||||
if ( vsParams.size() == 4) {
|
||||
return ( FromString( vsParams[0], ptP.x) &&
|
||||
FromString( vsParams[1], ptP.y) &&
|
||||
FromString( vsParams[2], ptP.z) &&
|
||||
FromString( vsParams[3], dW)) ;
|
||||
}
|
||||
// se 2 parti, nome di punto già nel DB e un peso
|
||||
else if ( vsParams.size() == 2) {
|
||||
const IGeoPoint3d* pPt ;
|
||||
// recupero il punto
|
||||
if ( ( pPt = GetGeoPoint3d( m_pGDB->GetGeoObj( vsParams[0]))) == nullptr)
|
||||
return false ;
|
||||
ptP = pPt->GetPoint() ;
|
||||
// recupero il peso
|
||||
return FromString( vsParams[1], dW) ;
|
||||
}
|
||||
// altrimenti errore
|
||||
else
|
||||
return false ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::ExecuteCopy( const STRVECTOR& vsParams)
|
||||
{
|
||||
// 2 parametri ( NomeSou, NomeDest)
|
||||
if ( vsParams.size() != 2)
|
||||
return false ;
|
||||
// esecuzione copia
|
||||
return m_pGDB->Copy( vsParams[0], vsParams[1]) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::ExecuteErase( const STRVECTOR& vsParams)
|
||||
{
|
||||
STRVECTOR vsNames ;
|
||||
STRVECTOR::iterator Iter ;
|
||||
|
||||
|
||||
// 1 parametro ( Nome/i)
|
||||
if ( vsParams.size() != 1)
|
||||
return false ;
|
||||
// recupero lista nomi
|
||||
if ( ! GetNamesParam( vsParams[0], vsNames))
|
||||
return false ;
|
||||
// esecuzione cancellazioni
|
||||
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; Iter++) {
|
||||
if ( ! m_pGDB->Erase( (*Iter)))
|
||||
return false ;
|
||||
}
|
||||
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::ExecuteTranslate( const STRVECTOR& vsParams)
|
||||
{
|
||||
STRVECTOR vsNames ;
|
||||
STRVECTOR::iterator Iter ;
|
||||
Vector3d vtVN ;
|
||||
|
||||
|
||||
// 2 parametri ( Nome/i, Vettore)
|
||||
if ( vsParams.size() != 2)
|
||||
return false ;
|
||||
// recupero lista nomi
|
||||
if ( ! GetNamesParam( vsParams[0], vsNames))
|
||||
return false ;
|
||||
// recupero il vettore
|
||||
if ( ! GetVectorParam( vsParams[1], vtVN))
|
||||
return false ;
|
||||
// esecuzione traslazioni
|
||||
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; Iter++) {
|
||||
if ( ! m_pGDB->Translate( (*Iter), vtVN))
|
||||
return false ;
|
||||
}
|
||||
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::ExecuteRotate( const STRVECTOR& vsParams)
|
||||
{
|
||||
STRVECTOR vsNames ;
|
||||
STRVECTOR::iterator Iter ;
|
||||
Point3d ptPC ;
|
||||
Vector3d vtVN ;
|
||||
double dAngDeg ;
|
||||
|
||||
|
||||
// 4 parametri ( Nome, PtoAsse, VtAsse, AngDeg)
|
||||
if ( vsParams.size() != 4)
|
||||
return false ;
|
||||
// recupero lista nomi
|
||||
if ( ! GetNamesParam( vsParams[0], vsNames))
|
||||
return false ;
|
||||
// recupero il punto
|
||||
if ( ! GetPointParam( vsParams[1], ptPC))
|
||||
return false ;
|
||||
// recupero il vettore
|
||||
if ( ! GetVectorParam( vsParams[2], vtVN))
|
||||
return false ;
|
||||
// recupero i coefficienti
|
||||
if ( ! FromString( vsParams[3], dAngDeg))
|
||||
return false ;
|
||||
// esecuzione rotazioni
|
||||
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; Iter++) {
|
||||
if ( ! m_pGDB->Rotate( (*Iter), ptPC, vtVN, dAngDeg))
|
||||
return false ;
|
||||
}
|
||||
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::ExecuteScale( const STRVECTOR& vsParams)
|
||||
{
|
||||
STRVECTOR vsNames ;
|
||||
STRVECTOR::iterator Iter ;
|
||||
Point3d ptPC ;
|
||||
double dCoeffX ;
|
||||
double dCoeffY ;
|
||||
double dCoeffZ ;
|
||||
|
||||
|
||||
// 5 parametri ( Nome, Punto, CoeffX, CoeffY, CoeffZ)
|
||||
if ( vsParams.size() != 5)
|
||||
return false ;
|
||||
// recupero lista nomi
|
||||
if ( ! GetNamesParam( vsParams[0], vsNames))
|
||||
return false ;
|
||||
// recupero il punto
|
||||
if ( ! GetPointParam( vsParams[1], ptPC))
|
||||
return false ;
|
||||
// recupero i coefficienti
|
||||
if ( ! FromString( vsParams[2], dCoeffX) ||
|
||||
! FromString( vsParams[3], dCoeffY) ||
|
||||
! FromString( vsParams[4], dCoeffZ))
|
||||
return false ;
|
||||
// esecuzione scalature
|
||||
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; Iter++) {
|
||||
if ( ! m_pGDB->Scale( (*Iter), ptPC, dCoeffX, dCoeffY, dCoeffZ))
|
||||
return false ;
|
||||
}
|
||||
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::ExecuteMirror( const STRVECTOR& vsParams)
|
||||
{
|
||||
STRVECTOR vsNames ;
|
||||
STRVECTOR::iterator Iter ;
|
||||
Point3d ptPC ;
|
||||
Vector3d vtVN ;
|
||||
|
||||
|
||||
// 3 parametri ( Nome, Punto, Vettore)
|
||||
if ( vsParams.size() != 3)
|
||||
return false ;
|
||||
// recupero lista nomi
|
||||
if ( ! GetNamesParam( vsParams[0], vsNames))
|
||||
return false ;
|
||||
// recupero il punto
|
||||
if ( ! GetPointParam( vsParams[1], ptPC))
|
||||
return false ;
|
||||
// recupero il vettore
|
||||
if ( ! GetVectorParam( vsParams[2], vtVN))
|
||||
return false ;
|
||||
// esecuzione specchiature
|
||||
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; Iter++) {
|
||||
if ( ! m_pGDB->Mirror( (*Iter), ptPC, vtVN))
|
||||
return false ;
|
||||
}
|
||||
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::ExecuteLoad( const STRVECTOR& vsParams)
|
||||
{
|
||||
// 1 parametro ( NomeFile)
|
||||
if ( vsParams.size() != 1)
|
||||
return false ;
|
||||
// pulizia e reinizializzazione del DB geometrico
|
||||
m_pGDB->Clear() ;
|
||||
m_pGDB->Init() ;
|
||||
// esecuzione caricamento
|
||||
return Load( stringtoW( vsParams[0])) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::ExecuteSave( const STRVECTOR& vsParams)
|
||||
{
|
||||
// 1 parametro ( NomeFile)
|
||||
if ( vsParams.size() != 1)
|
||||
return false ;
|
||||
// esecuzione salvataggio
|
||||
return Save( stringtoW( vsParams[0])) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::ExecuteOutScl( const string& sCmd2, const STRVECTOR& vsParams)
|
||||
{
|
||||
// apro il file di uscita Scl
|
||||
if ( sCmd2 == "OPEN") {
|
||||
// 1 parametro
|
||||
if ( vsParams.size() != 1)
|
||||
return false ;
|
||||
// apro il file e scrivo intestazione
|
||||
return m_OutScl.Open( stringtoW( vsParams[0])) ;
|
||||
}
|
||||
// chiudo il file di uscita Scl
|
||||
else if ( sCmd2 == "CLOSE") {
|
||||
// nessun parametro
|
||||
if ( vsParams.size() != 0)
|
||||
return false ;
|
||||
// scrivo terminazioni e chiudo il file
|
||||
return m_OutScl.Close() ;
|
||||
}
|
||||
// imposto materiale corrente
|
||||
else if ( sCmd2 == "SETRGB") {
|
||||
double dRed, dGreen, dBlue ;
|
||||
// 3 parametri
|
||||
if ( vsParams.size() != 3)
|
||||
return false ;
|
||||
// recupero i 3 colori
|
||||
if ( ! FromString( vsParams[0], dRed) ||
|
||||
! FromString( vsParams[1], dGreen) ||
|
||||
! FromString( vsParams[2], dBlue))
|
||||
return false ;
|
||||
// definisco il materiale opportuno
|
||||
return m_OutScl.SetMaterial( dRed, dGreen, dBlue) ;
|
||||
}
|
||||
// imposto pezzo e layer correnti
|
||||
else if ( sCmd2 == "SETPL") {
|
||||
// 2 parametri
|
||||
if ( vsParams.size() != 2)
|
||||
return false ;
|
||||
// eseguo
|
||||
return m_OutScl.SetPartLay( vsParams[0], vsParams[1]) ;
|
||||
}
|
||||
// emetto entità
|
||||
else if ( sCmd2 == "PUT") {
|
||||
bool bCrvVsPolyg ;
|
||||
STRVECTOR vsNames ;
|
||||
STRVECTOR::iterator Iter ;
|
||||
// almeno un parametro
|
||||
if ( vsParams.size() < 1)
|
||||
return false ;
|
||||
// se esiste il secondo
|
||||
if ( vsParams.size() == 2)
|
||||
bCrvVsPolyg = ( vsParams[1] != "CPS") ;
|
||||
else
|
||||
bCrvVsPolyg = TRUE ;
|
||||
// recupero lista nomi
|
||||
if ( ! GetNamesParam( vsParams[0], vsNames))
|
||||
return false ;
|
||||
// esecuzione
|
||||
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; Iter++) {
|
||||
// recupero l'oggetto ed eseguo l'output
|
||||
switch ( m_pGDB->GetObjType( *Iter)) {
|
||||
case CRV_LINE :
|
||||
if ( ! m_OutScl.PutCurveLine( *GetCurveLine( m_pGDB->GetGeoObj(*Iter))))
|
||||
return false ;
|
||||
break ;
|
||||
case CRV_ARC :
|
||||
if ( ! m_OutScl.PutCurveArc( *GetCurveArc( m_pGDB->GetGeoObj(*Iter))))
|
||||
return false ;
|
||||
break ;
|
||||
case CRV_BEZ :
|
||||
if ( bCrvVsPolyg) {
|
||||
if ( ! m_OutScl.PutCurveBez( *GetCurveBezier( m_pGDB->GetGeoObj(*Iter))))
|
||||
return false ;
|
||||
}
|
||||
else {
|
||||
if ( ! m_OutScl.PutPolygBez( *GetCurveBezier( m_pGDB->GetGeoObj(*Iter))))
|
||||
return false ;
|
||||
}
|
||||
break ;
|
||||
case CRV_COMPO :
|
||||
if ( ! m_OutScl.PutCurveCompo( *GetCurveComposite( m_pGDB->GetGeoObj(*Iter))))
|
||||
return false ;
|
||||
break ;
|
||||
default :
|
||||
return false ;
|
||||
}
|
||||
}
|
||||
return true ;
|
||||
}
|
||||
|
||||
return false ;
|
||||
}
|
||||
Reference in New Issue
Block a user