Dario Sassi
1141 lines
35 KiB
C++
1141 lines
35 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2013-2013
|
|
//----------------------------------------------------------------------------
|
|
// File : GdbExecutor.cpp Data : 25.11.13 Versione : 1.3a5
|
|
// Contenuto : Implementazione della classe GdbExecutor.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 27.03.13 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "GdbExecutor.h"
|
|
#include "GdbIterator.h"
|
|
#include "DllMain.h"
|
|
#include "/EgtDev/Include/EgnStringUtils.h"
|
|
#include "/EgtDev/Include/EgnStringConverter.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 ;
|
|
// alias predefiniti
|
|
m_NameMap.insert( pair< string, int>( "$ROOT", GDB_ID_ROOT)) ;
|
|
m_NameMap.insert( pair< string, int>( "$NN", ID_NO)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
GdbExecutor::~GdbExecutor( void)
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::Init( IGeomDB* pGdb)
|
|
{
|
|
m_pGDB = pGdb ;
|
|
|
|
return ( m_pGDB != nullptr) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::Execute( const string& sCmd1, const string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
string sOut ;
|
|
STRVECTOR::const_iterator theConstIter ;
|
|
|
|
|
|
// output di debug
|
|
sOut = "Cmd = [" + sCmd1 + "][" + sCmd2 + "] Par = [" ;
|
|
for ( theConstIter = vsParams.begin() ; theConstIter != vsParams.end() ; ++theConstIter) {
|
|
if ( theConstIter != vsParams.begin())
|
|
sOut += "][" ;
|
|
sOut += *theConstIter ;
|
|
}
|
|
sOut += "]" ;
|
|
LOG_DBG_INFO( GetEGkLogger(), sOut.c_str())
|
|
|
|
// 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 == "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 == "INVERTCURVE" || sCmd1 == "INVC")
|
|
return ExecuteInvertCurve( vsParams) ;
|
|
else if ( sCmd1 == "TRIMCURVE" || sCmd1 == "TRC")
|
|
return ExecuteTrimCurve( sCmd2, 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::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 e indicato da Alias, ne cambio il valore
|
|
if ( nIdDest == GDB_ID_NULL && m_NameMap.find( vsParams[0]) != m_NameMap.end())
|
|
m_NameMap[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") {
|
|
// 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) ;
|
|
// calcolo il punto a minima distanza
|
|
Point3d ptEnd ;
|
|
DistPointCurve dstPtCurve( ptSloc, *pCurve) ;
|
|
if ( ! dstPtCurve.GetPointMinDist( ptEnd))
|
|
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 ;
|
|
|
|
// curva di Bezier intera (non razionale)
|
|
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 equivalente ad un arco
|
|
else if ( sCmd2 == "ARC" || sCmd2 == "A") {
|
|
Point3d ptCen ;
|
|
Vector3d vtN ;
|
|
double dRad ;
|
|
Vector3d vtS ;
|
|
double dAngCenDeg ;
|
|
double dDeltaZ ;
|
|
// 8 parametri
|
|
if ( vsParams.size() != 8)
|
|
return false ;
|
|
// centro
|
|
if ( ! GetPointParam( vsParams[2], ptCen))
|
|
return false ;
|
|
// versore ortogonale al piano della circonferenza
|
|
if ( ! GetVectorParam( vsParams[3], vtN))
|
|
return false ;
|
|
// raggio
|
|
if ( ! FromString( vsParams[4], dRad))
|
|
return false ;
|
|
// versore iniziale
|
|
if ( ! GetVectorParam( vsParams[5], vtS))
|
|
return false ;
|
|
// angolo al centro
|
|
if ( ! FromString( vsParams[6], dAngCenDeg))
|
|
return false ;
|
|
// deltaZ
|
|
if ( ! FromString( vsParams[7], dDeltaZ))
|
|
return false ;
|
|
// imposto l'arco
|
|
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
|
|
if ( ! IsValid( pCrvArc))
|
|
return false ;
|
|
if ( ! pCrvArc->Set( ptCen, vtN, dRad, vtS, dAngCenDeg, dDeltaZ))
|
|
return false ;
|
|
// ne deduco la curva di Bezier
|
|
if ( ! pCrvBez->SetFromArc( *pCrvArc))
|
|
return false ;
|
|
}
|
|
// altrimenti errore
|
|
else
|
|
return false ;
|
|
|
|
// inserisco la curva di Bezier nel DB
|
|
return AddGeoObj( vsParams[0], vsParams[1], 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 ;
|
|
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
|
|
if ( ! IsValid( pCrvCompo))
|
|
return false ;
|
|
// 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 ;
|
|
// esecuzione
|
|
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
|
|
// recupero la curva
|
|
pCrv = GetCurve( m_pGDB->GetGeoObj( GetIdParam( *Iter))) ;
|
|
if ( pCrv == nullptr)
|
|
return false ;
|
|
// aggiungo questa curva
|
|
if ( ! pCrvCompo->AddCurve( *pCrv))
|
|
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 ;
|
|
}
|
|
|
|
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 e indicato da Alias, ne cambio il valore
|
|
if ( nId == GDB_ID_NULL && m_NameMap.find( sId) != m_NameMap.end())
|
|
m_NameMap[sId] = nIdNew ;
|
|
|
|
return ( nIdNew != GDB_ID_NULL) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
GdbExecutor::GetIdParam( const std::string& sParam, bool bNewAllowed)
|
|
{
|
|
int nVal ;
|
|
NameMap::iterator Iter ;
|
|
|
|
|
|
// se nome di identificatore numerico
|
|
if ( sParam[0] == '$') {
|
|
// se gi� presente nella lista dei nomi, ne restituisco il valore
|
|
Iter = m_NameMap.find( sParam) ;
|
|
if ( Iter != m_NameMap.end())
|
|
return Iter->second ;
|
|
// se ammessa nuova definizione, provo ad inserirlo
|
|
else if ( bNewAllowed &&
|
|
m_NameMap.insert( pair< string, int>( sParam, GDB_ID_NULL)).second)
|
|
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::ExecuteCopy( const STRVECTOR& vsParams)
|
|
{
|
|
// 3 parametri ( IdSou, IdDest, ParentIdDest)
|
|
if ( vsParams.size() != 3)
|
|
return false ;
|
|
// esecuzione copia
|
|
int nIdDest = GetIdParam( vsParams[1], true) ;
|
|
int nIdNew = m_pGDB->Copy( GetIdParam( vsParams[0]), nIdDest, GetIdParam( vsParams[2])) ;
|
|
// se IdDest da calcolare e indicato da Alias, ne cambio il valore
|
|
if ( nIdDest == GDB_ID_NULL && m_NameMap.find( vsParams[1]) != m_NameMap.end())
|
|
m_NameMap[vsParams[1]] = nIdNew ;
|
|
|
|
return ( nIdNew != GDB_ID_NULL) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
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( GetIdParam( *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( GetIdParam( *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( GetIdParam( *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( GetIdParam( *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( GetIdParam( *Iter), ptPC, vtVN))
|
|
return false ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteInvertCurve( 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 inversione curve
|
|
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::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 nId ;
|
|
// un parametro
|
|
if ( vsParams.size() != 1)
|
|
return false ;
|
|
nId = GetIdParam( vsParams[0]) ;
|
|
// emetto gruppo e suoi sottoposti
|
|
return OutGroupScl( nId) ;
|
|
}
|
|
// 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.PutCurve( m_pGDB->GetGeoObj( nId), nFlag))
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::OutGroupScl( int nId)
|
|
{
|
|
bool bNext ;
|
|
int nParentId ;
|
|
int nGdbType ;
|
|
Frame3d frFrame ;
|
|
GdbIterator Iter ;
|
|
|
|
|
|
// 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 ;
|
|
}
|
|
}
|
|
else
|
|
return false ;
|
|
// emetto entit� gruppo
|
|
Iter.SetGDB( m_pGDB) ;
|
|
bNext = Iter.GoToFirstInGroup( nId) ;
|
|
while ( bNext) {
|
|
nGdbType = Iter.GetGdbType() ;
|
|
if ( nGdbType == GDB_GEO) {
|
|
if ( ! m_OutScl.PutCurve( Iter.GetGeoObj(), 0))
|
|
return false ;
|
|
}
|
|
else if ( nGdbType == GDB_GROUP) {
|
|
if ( ! OutGroupScl( Iter.GetId()))
|
|
return false ;
|
|
}
|
|
bNext = Iter.GoToNext() ;
|
|
}
|
|
|
|
return true ;
|
|
}
|