Egalware/EgtGeomKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2a2c0065edcece624f22ee3320e37c81db87b9e9
EgtGeomKernel/GdbExecutor.cpp
T
Dario Sassi 2a2c0065ed EgtGeomKernel 1.5c1 : 
- aggiunta prima gestione attributi.
2014-03-06 08:17:26 +00:00

1416 lines
44 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
// EgalTech 2013-2014
//----------------------------------------------------------------------------
// File : GdbExecutor.cpp Data : 19.01.14 Versione : 1.5a6
// Contenuto : Implementazione della classe GdbExecutor.
//
//
//
// Modifiche : 27.03.13 DS Creazione modulo.
// 19.01.14 DS Agg. COUNTER.
// 18.02.14 DS Agg. NEW.
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "GdbExecutor.h"
#include "GdbIterator.h"
#include "GeomDB.h"
#include "DllMain.h"
#include "/EgtDev/Include/EgnStringUtils.h"
#include "/EgtDev/Include/EgnStringConverter.h"
#include "/EgtDev/Include/EgnCmdParser.h"
#include "/EgtDev/Include/EgkGeoPoint3d.h"
#include "/EgtDev/Include/EgkGeoVector3d.h"
#include "/EgtDev/Include/EgkGeoFrame3d.h"
#include "/EgtDev/Include/EgkCurveLine.h"
#include "/EgtDev/Include/EgkCurveArc.h"
#include "/EgtDev/Include/EgkCurveBezier.h"
#include "/EgtDev/Include/EgkCurveComposite.h"
#include "/EgtDev/Include/EgkDistPointCurve.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
using namespace std ;
//----------------------------------------------------------------------------
static const int ID_NO = -2 ;
static const int ID_ERROR = -3 ;
//----------------------------------------------------------------------------
IGdbExecutor*
CreateGdbExecutor( void)
{
return static_cast<IGdbExecutor*> ( new GdbExecutor) ;
}
//----------------------------------------------------------------------------
GdbExecutor::GdbExecutor( void)
{
m_pGDB = nullptr ;
m_pParser = nullptr ;
m_pOtherExec = nullptr ;
}
//----------------------------------------------------------------------------
GdbExecutor::~GdbExecutor( void)
{
}
//----------------------------------------------------------------------------
bool
GdbExecutor::SetCmdParser( ICmdParser* pParser)
{
// salvo e verifico
m_pParser = pParser ;
if ( m_pParser == nullptr)
return false ;
// imposto eventuale parser dipendente
if ( m_pOtherExec != nullptr)
m_pOtherExec->SetCmdParser( m_pParser) ;
// imposto variabili predefinite
m_pParser->AddVariable( "$ROOT", GDB_ID_ROOT) ;
m_pParser->AddVariable( "$NN", ID_NO) ;
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::AddExecutor( ICmdExecutor* pOtherExec)
{
m_pOtherExec = pOtherExec ;
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::SetGeomDB( IGeomDB* pGdb)
{
m_pGDB = pGdb ;
return ( m_pGDB != nullptr) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::Execute( const string& sCmd1, const string& sCmd2, const STRVECTOR& vsParams)
{
// verifico validita GeomDB
if ( m_pGDB == nullptr) {
LOG_ERROR( GetEGkLogger(), "Error : null GeomDb.")
return false ;
}
// verifico validità CmdParser
if ( m_pParser == nullptr) {
LOG_ERROR( GetEGkLogger(), "Error : null CmdParser.")
return false ;
}
// esecuzione comando
if ( sCmd1 == "GR" || sCmd1 == "GROUP")
return ExecuteGroup( sCmd2, vsParams) ;
else if ( sCmd1 == "P" || sCmd1 == "POINT")
return ExecutePoint( sCmd2, vsParams) ;
else if ( sCmd1 == "V" || sCmd1 == "VECTOR")
return ExecuteVector( sCmd2, vsParams) ;
else if ( sCmd1 == "FR" || sCmd1 == "FRAME")
return ExecuteFrame( 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 == "COL" || sCmd1 == "COLOR")
return ExecuteColor( sCmd2, vsParams) ;
else if ( sCmd1 == "COPY")
return ExecuteCopy( sCmd2, vsParams) ;
else if ( sCmd1 == "ERASE")
return ExecuteErase( vsParams) ;
else if ( sCmd1 == "MOV" || sCmd1 == "MOVE")
return ExecuteTranslate( sCmd2, vsParams) ;
else if ( sCmd1 == "ROT" || sCmd1 == "ROTATE")
return ExecuteRotate( sCmd2, vsParams) ;
else if ( sCmd1 == "SCA" || sCmd1 == "SCALE")
return ExecuteScale( sCmd2, vsParams) ;
else if ( sCmd1 == "MIR" || sCmd1 == "MIRROR")
return ExecuteMirror( sCmd2, vsParams) ;
else if ( sCmd1 == "INVC" || sCmd1 == "INVERTCURVE")
return ExecuteInvertCurve( vsParams) ;
else if ( sCmd1 == "TRC" || sCmd1 == "TRIMCURVE")
return ExecuteTrimCurve( sCmd2, vsParams) ;
else if ( sCmd1 == "NEW")
return ExecuteNew( vsParams) ;
else if ( sCmd1 == "LOAD")
return ExecuteLoad( vsParams) ;
else if ( sCmd1 == "SAVE")
return ExecuteSave( vsParams) ;
else if ( sCmd1 == "OUTSCL")
return ExecuteOutScl( sCmd2, vsParams) ;
else if ( sCmd1 == "COUNTER")
return ExecuteCounter( sCmd2, vsParams) ;
else if ( m_pOtherExec != nullptr)
return m_pOtherExec->Execute( sCmd1, sCmd2, vsParams) ;
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteGroup( const string& sCmd2, const STRVECTOR& vsParams)
{
Frame3d frFrame ;
// gruppo generico
if ( sCmd2 == "MAKE" || sCmd2 == "") {
Point3d ptOrig ;
Vector3d vtDirX ;
Vector3d vtDirY ;
Vector3d vtDirZ ;
// 6 parametri : Id, Id del padre, Orig, VersX, VersY, VersZ
if ( vsParams.size() != 6)
return false ;
// recupero i componenti
if ( ! GetPointParam( vsParams[2], ptOrig) ||
! GetVectorParam( vsParams[3], vtDirX) ||
! GetVectorParam( vsParams[4], vtDirY) ||
! GetVectorParam( vsParams[5], vtDirZ))
return false ;
// costruisco il riferimento
if ( ! frFrame.Set( ptOrig, vtDirX, vtDirY, vtDirZ))
return false ;
}
// gruppo orientato come il padre
else if ( sCmd2 == "PLANEXY" || sCmd2 == "XY") {
Point3d ptOrig ;
// 3 parametri : Id, Id del padre, Orig
if ( vsParams.size() != 3)
return false ;
// recupero i componenti
if ( ! GetPointParam( vsParams[2], ptOrig))
return false ;
// costruisco il riferimento
if ( ! frFrame.Set( ptOrig, Frame3d::TOP))
return false ;
}
else
return false ;
// creo il gruppo
int nIdDest = GetIdParam( vsParams[0], true) ;
int nIdNew = m_pGDB->AddGroup( nIdDest, GetIdParam( vsParams[1]), frFrame) ;
// se IdDest da calcolare, può essere una variabili a cui cambiare il valore
if ( nIdDest == GDB_ID_NULL)
m_pParser->SetVariable( vsParams[0], nIdNew) ;
return ( nIdNew != GDB_ID_NULL) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecutePoint( const string& sCmd2, const STRVECTOR& vsParams)
{
// analisi ed esecuzione dei comandi
if ( sCmd2 == "MAKE" || sCmd2 == "") {
Point3d Pnt ;
// 5 parametri : Id, IdParent e 3 coordinate
if ( vsParams.size() != 5)
return false ;
// recupero le tre coordinate
if ( ! FromString( vsParams[2], Pnt.x) ||
! FromString( vsParams[3], Pnt.y) ||
! FromString( vsParams[4], Pnt.z))
return false ;
// creo il punto
IGeoPoint3d* pGPnt = CreateGeoPoint3d() ;
if ( pGPnt == nullptr)
return false ;
pGPnt->Set( Pnt) ;
return AddGeoObj( vsParams[0], vsParams[1], pGPnt) ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteVector( const string& sCmd2, const STRVECTOR& vsParams)
{
// analisi ed esecuzione dei comandi
if ( sCmd2 == "MAKE" || sCmd2 == "") {
Vector3d Vect ;
// 5 parametri
if ( vsParams.size() != 5)
return false ;
// recupero i tre componenti
if ( ! FromString( vsParams[2], Vect.x) ||
! FromString( vsParams[3], Vect.y) ||
! FromString( vsParams[4], Vect.z))
return false ;
// creo il vettore
IGeoVector3d* pGVect = CreateGeoVector3d() ;
if ( pGVect == nullptr)
return false ;
pGVect->Set( Vect) ;
return AddGeoObj( vsParams[0], vsParams[1], pGVect) ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteFrame( const string& sCmd2, const STRVECTOR& vsParams)
{
// analisi ed esecuzione dei comandi
if ( sCmd2 == "MAKE" || sCmd2 == "") {
Point3d ptOrig ;
Vector3d vtDirX ;
Vector3d vtDirY ;
Vector3d vtDirZ ;
// 6 parametri
if ( vsParams.size() != 6)
return false ;
// recupero i componenti
if ( ! GetPointParam( vsParams[2], ptOrig) ||
! GetVectorParam( vsParams[3], vtDirX) ||
! GetVectorParam( vsParams[4], vtDirY) ||
! GetVectorParam( vsParams[5], vtDirZ))
return false ;
// creo il riferimento
IGeoFrame3d* pGFrame = CreateGeoFrame3d() ;
if ( pGFrame == nullptr)
return false ;
pGFrame->Set( ptOrig, vtDirX, vtDirY, vtDirZ) ;
return AddGeoObj( vsParams[0], vsParams[1], pGFrame) ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteCurveLine( const string& sCmd2, const STRVECTOR& vsParams)
{
// creo la linea
PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
if ( ! IsValid( pCrvLine))
return false ;
// creazione linea dando gli estremi
if ( sCmd2 == "MAKE" || sCmd2 == "") {
// 4 parametri
if ( vsParams.size() != 4)
return false ;
// recupero punto iniziale
Point3d ptStart ;
if ( ! GetPointParam( vsParams[2], ptStart))
return false ;
// recupero punto finale
Point3d ptEnd ;
if ( ! GetPointParam( vsParams[3], ptEnd))
return false ;
// setto la linea
if ( ! pCrvLine->Set( ptStart, ptEnd))
return false ;
}
// creazione linea di minima distanza tra punto e curva
else if ( sCmd2 == "MINPOINTCURVE" || sCmd2 == "MPC") {
// almeno 4 parametri
if ( vsParams.size() < 4)
return false ;
// recupero l'identificativo del gruppo destinazione
int nIdParent ;
if ( ( nIdParent = GetIdParam( vsParams[1])) == ID_ERROR)
return false ;
// recupero il riferimento del gruppo destinazione
Frame3d frPoint ;
if ( ! m_pGDB->GetGroupGlobFrame( nIdParent, frPoint))
return false ;
// recupero il punto
Point3d ptStart ;
if ( ! GetPointParam( vsParams[2], ptStart))
return false ;
// recupero l'identificativo della curva
int nId ;
if ( ( nId = GetIdParam( vsParams[3])) == ID_ERROR)
return false ;
// recupero il riferimento della curva
Frame3d frCurve ;
if ( ! m_pGDB->GetGlobFrame( nId, frCurve))
return false ;
// recupero la curva
const ICurve* pCurve = GetCurve( m_pGDB->GetGeoObj( nId)) ;
if ( pCurve == nullptr)
return false ;
// porto il punto nel riferimento della curva
Point3d ptSloc = ptStart ;
ptSloc.LocToLoc( frPoint, frCurve) ;
// recupero eventuale parametro per discriminare tra più soluzioni
double dNearParam ;
if ( vsParams.size() < 5 || ! FromString( vsParams[4], dNearParam))
dNearParam = 0 ;
// calcolo il punto a minima distanza
int nFlag ;
Point3d ptEnd ;
DistPointCurve dstPtCurve( ptSloc, *pCurve) ;
if ( ! dstPtCurve.GetMinDistPoint( dNearParam, ptEnd, nFlag))
return false ;
// porto il punto finale nel riferimento di creazione
ptEnd.LocToLoc( frCurve, frPoint) ;
// setto la linea
if ( ! pCrvLine->Set( ptStart, ptEnd))
return false ;
}
// altrimenti errore
else
return false ;
// inserisco la linea nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvLine)) ;
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteCurveArc( const string& sCmd2, const STRVECTOR& vsParams)
{
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( ! IsValid( pCrvArc))
return false ;
// arco generico
if ( sCmd2 == "MAKE" || sCmd2 == "") {
// 8 parametri
if ( vsParams.size() != 8)
return false ;
// centro
Point3d ptCen ;
if ( ! GetPointParam( vsParams[2], ptCen))
return false ;
// versore ortogonale al piano della circonferenza
Vector3d vtN ;
if ( ! GetVectorParam( vsParams[3], vtN))
return false ;
// raggio
double dRad ;
if ( ! FromString( vsParams[4], dRad))
return false ;
// versore iniziale
Vector3d vtS ;
if ( ! GetVectorParam( vsParams[5], vtS))
return false ;
// angolo al centro
double dAngCenDeg ;
if ( ! FromString( vsParams[6], dAngCenDeg))
return false ;
// deltaZ
double dDeltaZ ;
if ( ! FromString( vsParams[7], 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") {
// 7 parametri
if ( vsParams.size() != 7)
return false ;
// centro
Point3d ptCen ;
if ( ! GetPointParam( vsParams[2], ptCen))
return false ;
// raggio
double dRad ;
if ( ! FromString( vsParams[3], dRad))
return false ;
// angolo iniziale
double dAngIniDeg ;
if ( ! FromString( vsParams[4], dAngIniDeg))
return false ;
// angolo al centro
double dAngCenDeg ;
if ( ! FromString( vsParams[5], dAngCenDeg))
return false ;
// deltaZ
double dDeltaZ ;
if ( ! FromString( vsParams[6], dDeltaZ))
return false ;
// setto l'arco
if ( ! pCrvArc->Set( ptCen, dRad, dAngIniDeg, dAngCenDeg, dDeltaZ))
return false ;
}
// circonferenza nel piano XY
else if ( sCmd2 == "CIRCLEXY" || sCmd2 == "CXY") {
// 4 parametri
if ( vsParams.size() != 4)
return false ;
// centro
Point3d ptCen ;
if ( ! GetPointParam( vsParams[2], ptCen))
return false ;
// raggio
double dRad ;
if ( ! FromString( vsParams[3], dRad))
return false ;
// setto l'arco
if ( ! pCrvArc->Set( ptCen, dRad))
return false ;
}
// altrimenti errore
else
return false ;
// inserisco l'arco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteCurveBez( const string& sCmd2, const STRVECTOR& vsParams)
{
// creo la curva di Bezier
PtrOwner<ICurveBezier> pCrvBez( CreateCurveBezier()) ;
if ( ! IsValid( pCrvBez))
return false ;
// per cancellazione eventuale arco di origine
bool bErase = false ;
int nIdArc = ID_ERROR ;
// curva di Bezier intera (polinomiale)
if ( sCmd2 == "INTEG" || sCmd2 == "I") {
int i ;
int nDeg ;
Point3d ptP ;
// almeno 3 parametri
if ( vsParams.size() < 3)
return false ;
// recupero il grado
if ( ! FromString( vsParams[2], 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+3], 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 3 parametri
if ( vsParams.size() < 3)
return false ;
// recupero il grado
if ( ! FromString( vsParams[2], 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 ( ! GetPointWParam( vsParams[i+3], ptP, dW) ||
! pCrvBez->SetControlPoint( i, ptP, dW))
return false ;
}
}
// curva di Bezier ricavata da un arco
else if ( sCmd2 == "FROMARC" || sCmd2 == "A") {
// 3 o 4 parametri
switch ( vsParams.size()) {
case 3 : bErase = false ; break ;
case 4 : bErase = ( vsParams[3] != "0") ; break ;
default : return false ; break ;
}
// recupero l'arco
nIdArc = GetIdParam( vsParams[2]) ;
const ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( nIdArc)) ;
if ( pCrvArc == nullptr)
return false ;
// ne deduco la curva di Bezier
if ( ! pCrvBez->FromArc( *pCrvArc))
return false ;
// recupero il riferimento dell'arco
Frame3d frSou ;
if ( ! m_pGDB->GetGlobFrame( nIdArc, frSou))
return false ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// porto la curva di Bezier dal riferimento dell'arco a quello di inserimento
if ( ! AreSameFrame( frSou, frDest)) {
pCrvBez->ToGlob( frSou) ;
pCrvBez->ToLoc( frDest) ;
}
}
// altrimenti errore
else
return false ;
// inserisco la curva di Bezier nel DB
if ( AddGeoObj( vsParams[0], vsParams[1], Release( pCrvBez))) {
// se richiesto, cancello eventuale arco di origine
if ( bErase && ! m_pGDB->Erase( nIdArc))
return false ;
else
return true ;
}
else
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteCurveCompo( const string& sCmd2, const STRVECTOR& vsParams)
{
// creo la curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( ! IsValid( pCrvCompo))
return false ;
// per eventuale cancellazione curve di origine
bool bErase ;
STRVECTOR vsNames ;
STRVECTOR::iterator Iter ;
// curva composita generica
if ( sCmd2 == "MAKE" || sCmd2 == "") {
// 3 o 4 parametri
switch ( vsParams.size()) {
case 3 : bErase = false ; break ;
case 4 : bErase = ( vsParams[3] != "0") ; break ;
default : return false ; break ;
}
// recupero lista nomi
if ( ! GetNamesParam( vsParams[2], vsNames))
return false ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// esecuzione
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
// recupero la curva
int nIdCrv = GetIdParam( *Iter) ;
const ICurve* pCrv = GetCurve( m_pGDB->GetGeoObj( nIdCrv)) ;
if ( pCrv == nullptr)
return false ;
// recupero il riferimento della curva
Frame3d frSou ;
if ( ! m_pGDB->GetGlobFrame( nIdCrv, frSou))
return false ;
// se i riferimenti sono uguali
if ( AreSameFrame( frSou, frDest)) {
// aggiungo direttamente questa curva
if ( ! pCrvCompo->AddCurve( *pCrv))
return false ;
}
// altrimenti devo prima trasformare la curva
else {
// creo una copia della curva (da buttare alla fine)
PtrOwner<ICurve> pModCrv( GetCurve( pCrv->Clone())) ;
if ( ! IsValid( pModCrv))
return false ;
// eseguo la trasformazione
pModCrv->ToGlob( frSou) ;
pModCrv->ToLoc( frDest) ;
// aggiungo la curva modificata
if ( ! pCrvCompo->AddCurve( *pModCrv))
return false ;
}
}
}
// da split di curva semplice
else if ( sCmd2 == "FROMSPLIT" || sCmd2 == "S") {
// 4 o 5 parametri
switch ( vsParams.size()) {
case 4 : bErase = false ; break ;
case 5 : bErase = ( vsParams[4] != "0") ; break ;
default : return false ; break ;
}
// salvo nome curva originale per eventuale cancellazione
vsNames.push_back( vsParams[2]) ;
// recupero la curva
int nIdCrv = GetIdParam( vsParams[2]) ;
const ICurve* pCrv = GetCurve( m_pGDB->GetGeoObj( nIdCrv)) ;
if ( pCrv == nullptr)
return false ;
// recupero il numero delle parti in cui spezzare
int nParts ;
if ( ! FromString( vsParams[3], nParts))
return false ;
// ne deduco la curva composita
if ( ! pCrvCompo->FromSplit( *pCrv, nParts))
return false ;
// recupero il riferimento della curva
Frame3d frSou ;
if ( ! m_pGDB->GetGlobFrame( nIdCrv, frSou))
return false ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// porto la curva composita dal riferimento della sorgente a quello di inserimento
if ( ! AreSameFrame( frSou, frDest)) {
pCrvCompo->ToGlob( frSou) ;
pCrvCompo->ToLoc( frDest) ;
}
}
// altrimenti errore
else
return false ;
// inserisco la curva composita nel DB
if ( AddGeoObj( vsParams[0], vsParams[1], Release( pCrvCompo))) {
// se richiesto, cancello le curve originali
if ( bErase) {
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
if ( ! m_pGDB->Erase( GetIdParam(*Iter)))
return false ;
}
}
return true ;
}
else
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::AddGeoObj( const string& sId, const string& sIdParent, IGeoObj* pGeoObj)
{
// creo il gruppo
int nId = GetIdParam( sId, true) ;
int nIdNew = m_pGDB->AddGeoObj( nId, GetIdParam( sIdParent), pGeoObj) ;
// se IdDest da calcolare, può essere una variabili a cui cambiare il valore
if ( nId == GDB_ID_NULL)
m_pParser->SetVariable( sId, nIdNew) ;
return ( nIdNew != GDB_ID_NULL) ;
}
//----------------------------------------------------------------------------
int
GdbExecutor::GetIdParam( const std::string& sParam, bool bNewAllowed)
{
int nVal ;
// se nome di identificatore numerico
if ( sParam[0] == '$') {
// se variabile già definita, ne restituisco il valore
if ( m_pParser->GetVariable( sParam, nVal))
return nVal ;
// se ammessa nuova definizione, provo ad inserirlo
else if ( bNewAllowed &&
m_pParser->AddVariable( sParam, GDB_ID_NULL))
return GDB_ID_NULL ;
// altrimenti errore
else
return ID_ERROR ;
}
// se identificatore numerico
else if ( FromString( sParam, nVal))
return nVal ;
// altrimenti errore
else
return ID_ERROR ;
}
//----------------------------------------------------------------------------
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( GetIdParam( 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( GetIdParam( sParam)))) == nullptr)
return false ;
ptP = pPt->GetPoint() ;
return true ;
}
}
//----------------------------------------------------------------------------
bool
GdbExecutor::GetPointWParam( 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( GetIdParam( vsParams[0])))) == nullptr)
return false ;
ptP = pPt->GetPoint() ;
// recupero il peso
return FromString( vsParams[1], dW) ;
}
// altrimenti errore
else
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::GetFrameParam( const std::string& sParam, Frame3d& frF)
{
// se insieme di punto origine e tre versori
if ( sParam[0] == '(') {
Point3d ptOrig ;
Vector3d vtX ;
Vector3d vtY ;
Vector3d vtZ ;
string sTmp ;
STRVECTOR vsParams ;
STRVECTOR::iterator Iter ;
// elimino primo e ultimo carattere
sTmp = sParam.substr( 1, sParam.size()-2) ;
// divido in parti
Tokenize( sTmp, ",", "(", ")", vsParams) ;
// verifico siano 4 parti e le converto
if ( vsParams.size() != 4)
return false ;
if ( GetPointParam( vsParams[0], ptOrig) &&
GetVectorParam( vsParams[1], vtX) &&
GetVectorParam( vsParams[2], vtY) &&
GetVectorParam( vsParams[3], vtZ))
return frF.Set( ptOrig, vtX, vtY, vtZ) ;
else
return false ;
}
// altrimenti nome di frame già nel DB
else {
const IGeoFrame3d* pFr ;
if ( ( pFr = GetGeoFrame3d( m_pGDB->GetGeoObj( GetIdParam( sParam)))) == nullptr)
return false ;
frF = pFr->GetFrame() ;
return true ;
}
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteColor( const string& sCmd2, const STRVECTOR& vsParams)
{
// impostazione colore di default
if ( sCmd2 == "DEF" || sCmd2 == "DEFAULT") {
// 3 parametri ( Red, Green, Blue)
if ( vsParams.size() != 3)
return false ;
// recupero i colori
int nRed ;
int nGreen ;
int nBlue ;
if ( ! FromString( vsParams[0], nRed) ||
! FromString( vsParams[1], nGreen) ||
! FromString( vsParams[2], nBlue))
return false ;
Color cCol( nRed, nGreen, nBlue) ;
return m_pGDB->SetDefaultColor( cCol) ;
}
// impostazione colore su oggetto
else {
// 4 o 5 parametri ( Id, Red, Green, Blue, Alpha)
if ( vsParams.size() != 4 && vsParams.size() != 5)
return false ;
// recupero i colori
int nRed ;
int nGreen ;
int nBlue ;
if ( ! FromString( vsParams[1], nRed) ||
! FromString( vsParams[2], nGreen) ||
! FromString( vsParams[3], nBlue))
return false ;
int nAlpha = 100 ;
if ( vsParams.size() == 5 &&
! FromString( vsParams[4], nAlpha))
return false ;
Color cCol( nRed, nGreen, nBlue, nAlpha) ;
return m_pGDB->SetColor( GetIdParam( vsParams[0]), cCol) ;
}
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteCopy( const std::string& sCmd2, const STRVECTOR& vsParams)
{
// 3 parametri ( IdSou, IdDest, ParentIdDest)
if ( vsParams.size() != 3)
return false ;
// recupero flag per globale
bool bGlob = ( sCmd2 == "GLOB" || sCmd2 == "G") ;
// esecuzione copia
int nIdDest = GetIdParam( vsParams[1], true) ;
int nIdNew ;
if ( bGlob)
nIdNew = m_pGDB->CopyGlob( GetIdParam( vsParams[0]), nIdDest, GetIdParam( vsParams[2])) ;
else
nIdNew = m_pGDB->Copy( GetIdParam( vsParams[0]), nIdDest, GetIdParam( vsParams[2])) ;
// se IdDest da calcolare, può essere una variabili a cui cambiare il valore
if ( nIdDest == GDB_ID_NULL)
m_pParser->SetVariable( vsParams[1], nIdNew) ;
return ( nIdNew != GDB_ID_NULL) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteErase( const STRVECTOR& vsParams)
{
// 1 parametro ( Nome/i)
if ( vsParams.size() != 1)
return false ;
// recupero lista nomi
STRVECTOR vsNames ;
if ( ! GetNamesParam( vsParams[0], vsNames))
return false ;
// esecuzione cancellazioni
STRVECTOR::iterator Iter ;
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
if ( ! m_pGDB->Erase( GetIdParam( *Iter)))
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteTranslate( const std::string& sCmd2, const STRVECTOR& vsParams)
{
// 2 parametri ( Nome/i, Vettore)
if ( vsParams.size() != 2)
return false ;
// recupero lista nomi
STRVECTOR vsNames ;
if ( ! GetNamesParam( vsParams[0], vsNames))
return false ;
// recupero il vettore
Vector3d vtVN ;
if ( ! GetVectorParam( vsParams[1], vtVN))
return false ;
// recupero flag per globale
bool bGlob = ( sCmd2 == "GLOB" || sCmd2 == "G") ;
// esecuzione traslazioni
STRVECTOR::iterator Iter ;
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
if ( bGlob) {
if ( ! m_pGDB->TranslateGlob( GetIdParam( *Iter), vtVN))
return false ;
}
else {
if ( ! m_pGDB->Translate( GetIdParam( *Iter), vtVN))
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteRotate( const std::string& sCmd2, const STRVECTOR& vsParams)
{
// 4 parametri ( Nome, PtoAsse, VtAsse, AngDeg)
if ( vsParams.size() != 4)
return false ;
// recupero lista nomi
STRVECTOR vsNames ;
if ( ! GetNamesParam( vsParams[0], vsNames))
return false ;
// recupero il punto
Point3d ptPC ;
if ( ! GetPointParam( vsParams[1], ptPC))
return false ;
// recupero il vettore
Vector3d vtVN ;
if ( ! GetVectorParam( vsParams[2], vtVN))
return false ;
// recupero i coefficienti
double dAngDeg ;
if ( ! FromString( vsParams[3], dAngDeg))
return false ;
// recupero flag per globale
bool bGlob = ( sCmd2 == "GLOB" || sCmd2 == "G") ;
// esecuzione rotazioni
STRVECTOR::iterator Iter ;
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
if ( bGlob) {
if ( ! m_pGDB->RotateGlob( GetIdParam( *Iter), ptPC, vtVN, dAngDeg))
return false ;
}
else {
if ( ! m_pGDB->Rotate( GetIdParam( *Iter), ptPC, vtVN, dAngDeg))
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteScale( const std::string& sCmd2, const STRVECTOR& vsParams)
{
// 5 parametri ( Nome, Punto o Frame, CoeffX, CoeffY, CoeffZ)
if ( vsParams.size() != 5)
return false ;
// recupero lista nomi
STRVECTOR vsNames ;
if ( ! GetNamesParam( vsParams[0], vsNames))
return false ;
// provo a recuperare un punto
Point3d ptPC ;
Frame3d frRef ;
if ( GetPointParam( vsParams[1], ptPC))
frRef.Set( ptPC, Frame3d::TOP) ;
// provo a recuperare un frame
else if ( GetFrameParam( vsParams[1], frRef))
;
// altrimenti errore
else
return false ;
// recupero i coefficienti
double dCoeffX, dCoeffY, dCoeffZ ;
if ( ! FromString( vsParams[2], dCoeffX) ||
! FromString( vsParams[3], dCoeffY) ||
! FromString( vsParams[4], dCoeffZ))
return false ;
// recupero flag per globale
bool bGlob = ( sCmd2 == "GLOB" || sCmd2 == "G") ;
// esecuzione scalature
STRVECTOR::iterator Iter ;
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
if ( bGlob) {
if ( ! m_pGDB->ScaleGlob( GetIdParam( *Iter), frRef, dCoeffX, dCoeffY, dCoeffZ))
return false ;
}
else {
if ( ! m_pGDB->Scale( GetIdParam( *Iter), frRef, dCoeffX, dCoeffY, dCoeffZ))
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteMirror( const std::string& sCmd2, const STRVECTOR& vsParams)
{
// 3 parametri ( Nome, Punto, Vettore)
if ( vsParams.size() != 3)
return false ;
// recupero lista nomi
STRVECTOR vsNames ;
if ( ! GetNamesParam( vsParams[0], vsNames))
return false ;
// recupero il punto
Point3d ptPC ;
if ( ! GetPointParam( vsParams[1], ptPC))
return false ;
// recupero il vettore
Vector3d vtVN ;
if ( ! GetVectorParam( vsParams[2], vtVN))
return false ;
// recupero flag per globale
bool bGlob = ( sCmd2 == "GLOB" || sCmd2 == "G") ;
// esecuzione specchiature
STRVECTOR::iterator Iter ;
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
if ( bGlob) {
if ( ! m_pGDB->MirrorGlob( GetIdParam( *Iter), ptPC, vtVN))
return false ;
}
else {
if ( ! m_pGDB->Mirror( GetIdParam( *Iter), ptPC, vtVN))
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteInvertCurve( const STRVECTOR& vsParams)
{
// 1 parametro ( Nome/i)
if ( vsParams.size() != 1)
return false ;
// recupero lista nomi
STRVECTOR vsNames ;
if ( ! GetNamesParam( vsParams[0], vsNames))
return false ;
// esecuzione inversione curve
STRVECTOR::iterator Iter ;
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
ICurve* pCurve = GetCurve( m_pGDB->GetGeoObj( GetIdParam( *Iter))) ;
if ( pCurve == nullptr || ! pCurve->Invert())
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteTrimCurve( const std::string& sCmd2, const STRVECTOR& vsParams)
{
enum SeLp { SL, EL, SP, EP} ;
SeLp StEnLenPar ;
double dPar ;
STRVECTOR vsNames ;
STRVECTOR::iterator Iter ;
ICurve* pCurve ;
// 2 parametri ( Nome, parametro)
if ( vsParams.size() != 2)
return false ;
// recupero lista nomi
if ( ! GetNamesParam( vsParams[0], vsNames))
return false ;
// recupero i dati di inizio
if ( ! FromString( vsParams[1], dPar))
return false ;
// determino il tipo di trim
if ( sCmd2 == "STARTLEN" || sCmd2 == "SL")
StEnLenPar = SL ;
else if ( sCmd2 == "ENDLEN" || sCmd2 == "EL")
StEnLenPar = EL ;
else if ( sCmd2 == "STARTPAR" || sCmd2 == "SP")
StEnLenPar = SP ;
else if ( sCmd2 == "ENDPAR" || sCmd2 == "EP")
StEnLenPar = EP ;
else
return false ;
// esecuzione trim
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
if ( ( pCurve = GetCurve( m_pGDB->GetGeoObj( GetIdParam( *Iter)))) != nullptr) {
switch ( StEnLenPar) {
case SL :
if ( ! pCurve->TrimStartAtLen( dPar))
return false ;
break ;
case EL :
if ( ! pCurve->TrimEndAtLen( dPar))
return false ;
break ;
case SP :
if ( ! pCurve->TrimStartAtParam( dPar))
return false ;
break ;
case EP :
if ( ! pCurve->TrimEndAtParam( dPar))
return false ;
break ;
}
}
else
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteNew( const STRVECTOR& vsParams)
{
// nessun parametro
if ( vsParams.size() != 0)
return false ;
// pulizia e reinizializzazione del DB geometrico
m_pGDB->Clear() ;
m_pGDB->Init() ;
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 m_pGDB->Load( vsParams[0]) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteSave( const STRVECTOR& vsParams)
{
// 1 parametro ( NomeFile)
if ( vsParams.size() != 1)
return false ;
// esecuzione salvataggio
return m_pGDB->Save( 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( 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 gruppo
else if ( sCmd2 == "PUTGR") {
int nFlag ;
int nId ;
STRVECTOR vsNames ;
STRVECTOR::iterator Iter ;
// almeno un parametro
if ( vsParams.size() < 1)
return false ;
// se esiste il secondo
if ( vsParams.size() == 2)
FromString( vsParams[1], nFlag) ;
else
nFlag = 0 ;
// 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
nId = GetIdParam( *Iter) ;
if ( ! OutGroupScl( nId, nFlag))
return false ;
}
return true ;
}
// emetto oggetto geometrico
else if ( sCmd2 == "PUT") {
int nFlag ;
int nId ;
STRVECTOR vsNames ;
STRVECTOR::iterator Iter ;
// almeno un parametro
if ( vsParams.size() < 1)
return false ;
// se esiste il secondo
if ( vsParams.size() == 2)
FromString( vsParams[1], nFlag) ;
else
nFlag = 0 ;
// 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
nId = GetIdParam( *Iter) ;
if ( ! m_OutScl.PutGeoObj( m_pGDB->GetGeoObj( nId), nFlag))
return false ;
}
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::OutGroupScl( int nId, int nFlag)
{
bool bNext ;
int nParentId ;
int nGdbType ;
Frame3d frFrame ;
GdbIterator Iter ;
m_OutScl.Remark( "Start Group ---") ;
// emetto dati gruppo
if ( m_pGDB->GetGroupGlobFrame( nId, frFrame)) {
nParentId = m_pGDB->GetParentId( nId) ;
if ( nParentId > GDB_ID_ROOT) {
if ( ! m_OutScl.SetPartLayRef( ToString( nParentId), ToString( nId), frFrame))
return false ;
m_OutScl.PutCurrRef() ;
}
}
else
return false ;
// emetto eventuale box
if ( ( nFlag & 8) != 0) {
BBox3d b3Loc ;
if ( m_pGDB->GetLocalBBox( nId, b3Loc))
m_OutScl.PutBBox( b3Loc) ;
}
// emetto entità gruppo
m_OutScl.Remark( "Entities :") ;
Iter.SetGDB( m_pGDB) ;
bNext = Iter.GoToFirstInGroup( nId) ;
while ( bNext) {
nGdbType = Iter.GetGdbType() ;
if ( nGdbType == GDB_GEO) {
if ( ! m_OutScl.PutGeoObj( Iter.GetGeoObj(), nFlag))
return false ;
}
else if ( nGdbType == GDB_GROUP) {
if ( ! OutGroupScl( Iter.GetId(), nFlag))
return false ;
}
bNext = Iter.GoToNext() ;
}
m_OutScl.Remark( "End Group ---") ;
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteCounter( const string& sCmd2, const STRVECTOR& vsParams)
{
// avvio il counter
if ( sCmd2 == "START") {
m_Counter.Start() ;
}
// fermo il counter ed emetto i risultati
else if ( sCmd2 == "STOP") {
m_Counter.Stop() ;
string sOut = " " + ( ( vsParams.size() >= 1) ? vsParams[0] : "ExecTime =") ;
sOut += " " + ToString( m_Counter.GetTime(), 2) + " ms" ;
LOG_INFO( GetEGkLogger(), sOut.c_str())
}
return true ;
}
Reference in New Issue View Git Blame Copy Permalink