Egalware/EgtGeomKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
41a38fef3b70247a6bcc29423ff5d20eb7d7fd6c
EgtGeomKernel/GdbExecutor.cpp
T
Dario Sassi 41a38fef3b EgtGeomKernel 1.5f1 : 
- aggiunta entità testo (con font Nfe e di sistema)
- in tutte le rotate ora l'angolo è in gradi
- aggiunta trasformazione Shear (scorrimento)
- aggiunta trsformazione LocToLoc
- Set/GetInfo specializzate per i diversi tipi di informazioni
- Copy e Relocate con possibilità di indicare l'entità di riferimento rispetto a cui inserire
- aggiunte trasformazioni a PolyLine.
2014-06-03 13:19:54 +00:00

4032 lines
135 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
// EgalTech 2013-2014
//----------------------------------------------------------------------------
// File : GdbExecutor.cpp Data : 24.04.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 "GeoConst.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/EgkSurfTriMesh.h"
#include "/EgtDev/Include/EgkExtText.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
#include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
using namespace std ;
//----------------------------------------------------------------------------
static const int ID_SEL = -2 ;
static const int ID_NO = -3 ;
//----------------------------------------------------------------------------
IGdbExecutor*
CreateGdbExecutor( void)
{
return static_cast<IGdbExecutor*> ( new GdbExecutor) ;
}
//----------------------------------------------------------------------------
GdbExecutor::GdbExecutor( void)
{
m_pGDB = nullptr ;
m_pParser = nullptr ;
m_pGeoObj = nullptr ;
// assegno chiavi a funzioni di esecuzione
m_ExecMgr.Init( 128) ;
m_ExecMgr.Insert( "GR", &GdbExecutor::ExecuteGroup) ;
m_ExecMgr.Insert( "GROUP", &GdbExecutor::ExecuteGroup) ;
m_ExecMgr.Insert( "P", &GdbExecutor::ExecutePoint) ;
m_ExecMgr.Insert( "POINT", &GdbExecutor::ExecutePoint) ;
m_ExecMgr.Insert( "V", &GdbExecutor::ExecuteVector) ;
m_ExecMgr.Insert( "VECTOR", &GdbExecutor::ExecuteVector) ;
m_ExecMgr.Insert( "FR", &GdbExecutor::ExecuteFrame) ;
m_ExecMgr.Insert( "FRAME", &GdbExecutor::ExecuteFrame) ;
m_ExecMgr.Insert( "CL", &GdbExecutor::ExecuteCurveLine) ;
m_ExecMgr.Insert( "CURVELINE", &GdbExecutor::ExecuteCurveLine) ;
m_ExecMgr.Insert( "CA", &GdbExecutor::ExecuteCurveArc) ;
m_ExecMgr.Insert( "CURVEARC", &GdbExecutor::ExecuteCurveArc) ;
m_ExecMgr.Insert( "CB", &GdbExecutor::ExecuteCurveBez) ;
m_ExecMgr.Insert( "CURVEBEZIER", &GdbExecutor::ExecuteCurveBez) ;
m_ExecMgr.Insert( "CC", &GdbExecutor::ExecuteCurveCompo) ;
m_ExecMgr.Insert( "CURVECOMPO", &GdbExecutor::ExecuteCurveCompo) ;
m_ExecMgr.Insert( "STM", &GdbExecutor::ExecuteSurfTriMesh) ;
m_ExecMgr.Insert( "SURFTRIMESH", &GdbExecutor::ExecuteSurfTriMesh) ;
m_ExecMgr.Insert( "TEXT", &GdbExecutor::ExecuteText) ;
m_ExecMgr.Insert( "LEV", &GdbExecutor::ExecuteLevel) ;
m_ExecMgr.Insert( "LEVEL", &GdbExecutor::ExecuteLevel) ;
m_ExecMgr.Insert( "MOD", &GdbExecutor::ExecuteMode) ;
m_ExecMgr.Insert( "MODE", &GdbExecutor::ExecuteMode) ;
m_ExecMgr.Insert( "STA", &GdbExecutor::ExecuteStatus) ;
m_ExecMgr.Insert( "STATUS", &GdbExecutor::ExecuteStatus) ;
m_ExecMgr.Insert( "SEL", &GdbExecutor::ExecuteSelect) ;
m_ExecMgr.Insert( "SELECT", &GdbExecutor::ExecuteSelect) ;
m_ExecMgr.Insert( "DESEL", &GdbExecutor::ExecuteDeselect) ;
m_ExecMgr.Insert( "DESELECT", &GdbExecutor::ExecuteDeselect) ;
m_ExecMgr.Insert( "MAT", &GdbExecutor::ExecuteMaterial) ;
m_ExecMgr.Insert( "MATERIAL", &GdbExecutor::ExecuteMaterial) ;
m_ExecMgr.Insert( "NAM", &GdbExecutor::ExecuteName) ;
m_ExecMgr.Insert( "NAME", &GdbExecutor::ExecuteName) ;
m_ExecMgr.Insert( "INF", &GdbExecutor::ExecuteInfo) ;
m_ExecMgr.Insert( "INFO", &GdbExecutor::ExecuteInfo) ;
m_ExecMgr.Insert( "MATLIBRARY", &GdbExecutor::ExecuteMatLibrary) ;
m_ExecMgr.Insert( "MATLIB", &GdbExecutor::ExecuteMatLibrary) ;
m_ExecMgr.Insert( "COPY", &GdbExecutor::ExecuteCopy) ;
m_ExecMgr.Insert( "REL", &GdbExecutor::ExecuteRelocate) ;
m_ExecMgr.Insert( "RELOCATE", &GdbExecutor::ExecuteRelocate) ;
m_ExecMgr.Insert( "ERASE", &GdbExecutor::ExecuteErase) ;
m_ExecMgr.Insert( "MOV", &GdbExecutor::ExecuteTranslate) ;
m_ExecMgr.Insert( "MOVE", &GdbExecutor::ExecuteTranslate) ;
m_ExecMgr.Insert( "ROT", &GdbExecutor::ExecuteRotate) ;
m_ExecMgr.Insert( "ROTATE", &GdbExecutor::ExecuteRotate) ;
m_ExecMgr.Insert( "SCA", &GdbExecutor::ExecuteScale) ;
m_ExecMgr.Insert( "SCALE", &GdbExecutor::ExecuteScale) ;
m_ExecMgr.Insert( "MIR", &GdbExecutor::ExecuteMirror) ;
m_ExecMgr.Insert( "MIRROR", &GdbExecutor::ExecuteMirror) ;
m_ExecMgr.Insert( "SHEAR", &GdbExecutor::ExecuteShear) ;
m_ExecMgr.Insert( "INVC", &GdbExecutor::ExecuteInvertCurve) ;
m_ExecMgr.Insert( "INVERTCURVE", &GdbExecutor::ExecuteInvertCurve) ;
m_ExecMgr.Insert( "INVS", &GdbExecutor::ExecuteInvertSurf) ;
m_ExecMgr.Insert( "INVERTSURF", &GdbExecutor::ExecuteInvertSurf) ;
m_ExecMgr.Insert( "TRC", &GdbExecutor::ExecuteTrimCurve) ;
m_ExecMgr.Insert( "TRIMCURVE", &GdbExecutor::ExecuteTrimCurve) ;
m_ExecMgr.Insert( "NEW", &GdbExecutor::ExecuteNew) ;
m_ExecMgr.Insert( "LOAD", &GdbExecutor::ExecuteLoad) ;
m_ExecMgr.Insert( "SAVE", &GdbExecutor::ExecuteSave) ;
m_ExecMgr.Insert( "OUTTSC", &GdbExecutor::ExecuteOutTsc) ;
}
//----------------------------------------------------------------------------
GdbExecutor::~GdbExecutor( void)
{
if ( m_pGeoObj != nullptr)
delete m_pGeoObj ;
m_pGeoObj = nullptr ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::SetCmdParser( ICmdParser* pParser)
{
m_pParser = pParser ;
return ( m_pParser != nullptr) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::AddStandardVariables( void)
{
// dovrebbe sempre essere chiamato dallo stesso parser, ma...
if ( m_pParser == nullptr)
return false ;
// imposto variabili predefinite
m_pParser->AddVariable( "$ROOT", GDB_ID_ROOT) ;
m_pParser->AddVariable( "$SEL", ID_SEL) ;
m_pParser->AddVariable( "$NN", ID_NO) ;
// verifico la corrispondenza tra GDB_ID_NULL e CMD_ID_NULL
return ( GDB_ID_NULL == CMD_ID_NULL) ;
}
//----------------------------------------------------------------------------
int
GdbExecutor::Execute( const string& sCmd1, const string& sCmd2, const STRVECTOR& vsParams)
{
// verifico validita GeomDB
if ( m_pGDB == nullptr) {
LOG_ERROR( GetEGkLogger(), "Error : null GeomDb in GdbExecutor.")
return ER_ERR ;
}
// verifico validità CmdParser
if ( m_pParser == nullptr) {
LOG_ERROR( GetEGkLogger(), "Error : null CmdParser in GdbExecutor.")
return ER_ERR ;
}
// esecuzione comando
return m_ExecMgr.Execute( *this, sCmd1, sCmd2, vsParams) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::SetGeomDB( IGeomDB* pGdb)
{
m_pGDB = pGdb ;
return ( m_pGDB != nullptr) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteGroup( const string& sCmd2, const STRVECTOR& vsParams)
{
Frame3d frFrame ;
// gruppo generico
if ( sCmd2 == "" || sCmd2 == "MAKE") {
// 2 o 3 parametri : Id, Id del padre[, Frame]
if ( vsParams.size() != 2 && vsParams.size() != 3)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// recupero il riferimento
if ( vsParams.size() >= 3) {
if ( ! GetFrameParam( vsParams[2], frRef, frFrame))
return false ;
}
else
frFrame = GLOB_FRM ;
}
// gruppo orientato come il padre
else if ( sCmd2 == "XY" || sCmd2 == "PLANEXY") {
Point3d ptOrig ;
// 3 parametri : Id, Id del padre, Orig
if ( vsParams.size() != 3)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// recupero i componenti
if ( ! GetPointParam( vsParams[2], frRef, 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 == "" || sCmd2 == "MAKE") {
Point3d Pnt ;
// 3 parametri : Id, IdParent e punto
if ( vsParams.size() != 3)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frPnt ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frPnt))
return false ;
// recupero il punto
if ( ! GetPointParam( vsParams[2], frPnt, Pnt))
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)
{
// definizione diretta
if ( sCmd2 == "" || sCmd2 == "MAKE") {
Vector3d Vect ;
// 3 parametri : Id, IdParent e vettore
if ( vsParams.size() != 3)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frVect ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frVect))
return false ;
// recupero i tre componenti
if ( ! GetVectorParam( vsParams[2], frVect, Vect))
return false ;
// creo il vettore
IGeoVector3d* pGVect = CreateGeoVector3d() ;
if ( pGVect == nullptr)
return false ;
pGVect->Set( Vect) ;
return AddGeoObj( vsParams[0], vsParams[1], pGVect) ;
}
// definizione come differenza di due punti
else if ( sCmd2 == "D" || sCmd2 == "DIFF") {
// 4 o 5 parametri : Id, IdParent, ptP1, ptP2 [, bNorm]
if ( vsParams.size() != 4 && vsParams.size() != 5)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frVect ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frVect))
return false ;
// recupero il primo punto
Point3d ptP1 ;
if ( ! GetPointParam( vsParams[2], frVect, ptP1))
return false ;
// recupero il secondo punto
Point3d ptP2 ;
if ( ! GetPointParam( vsParams[3], frVect, ptP2))
return false ;
// flag di normalizzazione
bool bNorm = false ;
if ( vsParams.size() >= 5)
bNorm = ( vsParams[4] == "N") ;
// creo il vettore
IGeoVector3d* pGVect = CreateGeoVector3d() ;
if ( pGVect == nullptr)
return false ;
Vector3d vtV = ptP2 - ptP1 ;
if ( bNorm)
vtV.Normalize() ;
pGVect->Set( vtV) ;
return AddGeoObj( vsParams[0], vsParams[1], pGVect) ;
}
// definizione come prodotto vettoriale di due vettori
else if ( sCmd2 == "CP" || sCmd2 == "CROSSPROD") {
// 4 o 5 parametri : Id, IdParent, vtV1, vtV2 [, bNorm]
if ( vsParams.size() != 4 && vsParams.size() != 5)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frVect ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frVect))
return false ;
// recupero il primo vettore
Vector3d vtV1 ;
if ( ! GetVectorParam( vsParams[2], frVect, vtV1))
return false ;
// recupero il secondo vettore
Vector3d vtV2 ;
if ( ! GetVectorParam( vsParams[3], frVect, vtV2))
return false ;
// flag di normalizzazione
bool bNorm = false ;
if ( vsParams.size() >= 5)
bNorm = ( vsParams[4] == "N") ;
// creo il vettore
IGeoVector3d* pGVect = CreateGeoVector3d() ;
if ( pGVect == nullptr)
return false ;
Vector3d vtCross = vtV1 ^ vtV2 ;
if ( bNorm)
vtCross.Normalize() ;
pGVect->Set( vtCross) ;
return AddGeoObj( vsParams[0], vsParams[1], pGVect) ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteFrame( const string& sCmd2, const STRVECTOR& vsParams)
{
// riferimento generico
if ( sCmd2 == "" || sCmd2 == "MAKE") {
// 3 parametri : Id, ParentId, Frame
if ( vsParams.size() != 3)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// recupero il riferimento
Frame3d frFrame ;
if ( ! GetFrameParam( vsParams[2], frRef, frFrame))
return false ;
// creo il riferimento
IGeoFrame3d* pGFrame = CreateGeoFrame3d() ;
if ( pGFrame == nullptr)
return false ;
pGFrame->Set( frFrame) ;
return AddGeoObj( vsParams[0], vsParams[1], pGFrame) ;
}
// riferimento da 3 punti
else if ( sCmd2 == "3P") {
// 5 parametri : Id, ParentId, ptOrig, ptOnX, ptNearY
if ( vsParams.size() != 5)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// recupero i componenti
Point3d ptOrig, ptOnX, ptNearY ;
if ( ! GetPointParam( vsParams[2], frRef, ptOrig) ||
! GetPointParam( vsParams[3], frRef, ptOnX) ||
! GetPointParam( vsParams[4], frRef, ptNearY))
return false ;
// creo il riferimento
IGeoFrame3d* pGFrame = CreateGeoFrame3d() ;
if ( pGFrame == nullptr)
return false ;
pGFrame->Set( ptOrig, ptOnX, ptNearY) ;
return AddGeoObj( vsParams[0], vsParams[1], pGFrame) ;
}
// riferimento OCS
else if ( sCmd2 == "OCS") {
// 4 parametri
if ( vsParams.size() != 4)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// recupero i componenti
Point3d ptOrig ;
Vector3d vtDirZ ;
if ( ! GetPointParam( vsParams[2], frRef, ptOrig) ||
! GetVectorParam( vsParams[3], frRef, vtDirZ))
return false ;
// creo il riferimento
IGeoFrame3d* pGFrame = CreateGeoFrame3d() ;
if ( pGFrame == nullptr)
return false ;
pGFrame->Set( ptOrig, vtDirZ) ;
return AddGeoObj( vsParams[0], vsParams[1], pGFrame) ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteCurveLine( const string& sCmd2, const STRVECTOR& vsParams)
{
// creazione linea da : ptStart, ptEnd
if ( sCmd2 == "" || sCmd2 == "MAKE")
return CurveLineMake( vsParams) ;
// creazione linea da : ptStart, vtDir, dLen
else if ( sCmd2 == "VL" || sCmd2 == "VersorLength")
return CurveLineVersorLength( vsParams) ;
// creazione linea da : ptStart, dDirAngDeg, dLen
else if ( sCmd2 == "DL" || sCmd2 == "DirLength")
return CurveLineDirLength( vsParams) ;
// creazione linea di minima distanza tra punto e curva
else if ( sCmd2 == "MPC" || sCmd2 == "MINPOINTCURVE")
return CurveLineMinPointCurve( vsParams) ;
// altrimenti errore
else
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveLineMake( const STRVECTOR& vsParams)
{
// 4 parametri : Id, IdParent, ptStart, ptEnd
if ( vsParams.size() != 4)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// recupero punto iniziale
Point3d ptStart ;
if ( ! GetPointParam( vsParams[2], frRef, ptStart))
return false ;
// recupero punto finale
Point3d ptEnd ;
if ( ! GetPointParam( vsParams[3], frRef, ptEnd))
return false ;
// creo la linea
PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
if ( ! IsValid( pCrvLine))
return false ;
// setto la linea
if ( ! pCrvLine->Set( ptStart, ptEnd))
return false ;
// inserisco la linea nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvLine)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveLineVersorLength( const STRVECTOR& vsParams)
{
// 5 parametri : Id, IdParent, ptStart, vtDir, dLen
if ( vsParams.size() != 5)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// recupero punto iniziale
Point3d ptStart ;
if ( ! GetPointParam( vsParams[2], frRef, ptStart))
return false ;
// recupero vettore direzione
Vector3d vtDir ;
if ( ! GetVectorParam( vsParams[3], frRef, vtDir))
return false ;
// recupero lunghezza
double dLen ;
if ( ! GetLengthParam( vsParams[4], dLen))
return false ;
// creo la linea
PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
if ( ! IsValid( pCrvLine))
return false ;
// setto la linea
if ( ! pCrvLine->SetPVL( ptStart, vtDir, dLen))
return false ;
// inserisco la linea nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvLine)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveLineDirLength( const STRVECTOR& vsParams)
{
// 5 parametri : Id, IdParent, ptStart, dAngDeg, dLen
if ( vsParams.size() != 5)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// recupero punto iniziale
Point3d ptStart ;
if ( ! GetPointParam( vsParams[2], frRef, ptStart))
return false ;
// recupero direzione in gradi
double dDirAngDeg ;
if ( ! GetDirParam( vsParams[3], frRef, dDirAngDeg))
return false ;
// recupero lunghezza
double dLen ;
if ( ! GetLengthParam( vsParams[4], dLen))
return false ;
// creo la linea
PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
if ( ! IsValid( pCrvLine))
return false ;
// setto la linea
if ( ! pCrvLine->SetPDL( ptStart, dDirAngDeg, dLen))
return false ;
// inserisco la linea nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvLine)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveLineMinPointCurve( const STRVECTOR& vsParams)
{
// almeno 4 parametri : Id, IdParent, ptP, IdCrv[, NearParam]
if ( vsParams.size() < 4)
return false ;
// recupero il riferimento del gruppo destinazione
Frame3d frPoint ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frPoint))
return false ;
// recupero il punto
Point3d ptStart ;
if ( ! GetPointParam( vsParams[2], frPoint, ptStart))
return false ;
// recupero l'identificativo della curva
int nId ;
if ( ( nId = GetIdParam( vsParams[3])) == CMD_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) ;
// creo la linea
PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
if ( ! IsValid( pCrvLine))
return false ;
// setto la linea
if ( ! pCrvLine->Set( ptStart, ptEnd))
return false ;
// inserisco la linea nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvLine)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteCurveArc( const string& sCmd2, const STRVECTOR& vsParams)
{
// creo arco generico
if ( sCmd2 == "" || sCmd2 == "MAKE")
return CurveArcMake( vsParams) ;
// creo circonferenza
else if ( sCmd2 == "C" || sCmd2 == "CIRCLE")
return CurveArcCircle( vsParams) ;
// creo arco nel piano XY
else if ( sCmd2 == "XY" || sCmd2 == "PLANEXY")
return CurveArcPlaneXY( vsParams) ;
// creo circonferenza nel piano XY
else if ( sCmd2 == "CXY" || sCmd2 == "CIRCLEXY")
return CurveArcCircleXY( vsParams) ;
// creo arco o circonferenza passante per 3 punti
else if ( sCmd2 == "3P" || sCmd2 == "C3P")
return CurveArc3P( vsParams, ( sCmd2 == "C3P")) ;
// creo arco per 2 punti e direzione iniziale
else if ( sCmd2 == "2PDI")
return CurveArc2PDi( vsParams) ;
// creo arco per 2 punti, raggio e senso di rotazione
else if ( sCmd2 == "2PRS")
return CurveArc2PRS( vsParams) ;
// creo arco dato centro, per primo punto e vicino al secondo
else if ( sCmd2 == "C2P")
return CurveArcC2P( vsParams) ;
// inversione della normale
else if ( sCmd2 == "INVN" || sCmd2 == "INVERTNORMAL")
return CurveArcInvertNormal( vsParams) ;
// cambio del raggio
else if ( sCmd2 == "CHR" || sCmd2 == "CHANGERADIUS")
return CurveArcChangeRadius( vsParams) ;
// cambio del deltaN
else if ( sCmd2 == "CHDN" || sCmd2 == "CHANGEDELTAN")
return CurveArcChangeDeltaN( vsParams) ;
// trasformazione nell'arco complementare
else if ( sCmd2 == "TA" || sCmd2 == "TOADDITIONAL")
return CurveArcToAdditional( vsParams) ;
// flip dell'arco
else if ( sCmd2 == "F" || sCmd2 == "FLIP")
return CurveArcFlip( vsParams) ;
// altrimenti errore
else
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveArcMake( const STRVECTOR& vsParams)
{
// 8 parametri
if ( vsParams.size() != 8)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// centro
Point3d ptCen ;
if ( ! GetPointParam( vsParams[2], frRef, ptCen))
return false ;
// versore ortogonale al piano della circonferenza
Vector3d vtN ;
if ( ! GetVectorParam( vsParams[3], frRef, vtN))
return false ;
// raggio
double dRad ;
if ( ! GetLengthParam( vsParams[4], dRad))
return false ;
// versore iniziale
Vector3d vtS ;
if ( ! GetVectorParam( vsParams[5], frRef, vtS))
return false ;
// angolo al centro
double dAngCenDeg ;
if ( ! FromString( vsParams[6], dAngCenDeg))
return false ;
// deltaZ
double dDeltaZ ;
if ( ! GetLengthParam( vsParams[7], dDeltaZ))
return false ;
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( ! IsValid( pCrvArc))
return false ;
// setto l'arco
if ( ! pCrvArc->Set( ptCen, vtN, dRad, vtS, dAngCenDeg, dDeltaZ))
return false ;
// inserisco l'arco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveArcPlaneXY( const STRVECTOR& vsParams)
{
// 7 parametri
if ( vsParams.size() != 7)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// centro
Point3d ptCen ;
if ( ! GetPointParam( vsParams[2], frRef, ptCen))
return false ;
// raggio
double dRad ;
if ( ! GetLengthParam( vsParams[3], dRad))
return false ;
// angolo iniziale
double dAngIniDeg ;
if ( ! GetDirParam( vsParams[4], frRef, dAngIniDeg))
return false ;
// angolo al centro
double dAngCenDeg ;
if ( ! FromString( vsParams[5], dAngCenDeg))
return false ;
// deltaZ
double dDeltaZ ;
if ( ! GetLengthParam( vsParams[6], dDeltaZ))
return false ;
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( ! IsValid( pCrvArc))
return false ;
// setto l'arco
if ( ! pCrvArc->SetXY( ptCen, dRad, dAngIniDeg, dAngCenDeg, dDeltaZ))
return false ;
// inserisco l'arco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveArcCircle( const STRVECTOR& vsParams)
{
// 5 parametri
if ( vsParams.size() != 5)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// centro
Point3d ptCen ;
if ( ! GetPointParam( vsParams[2], frRef, ptCen))
return false ;
// versore ortogonale al piano della circonferenza
Vector3d vtN ;
if ( ! GetVectorParam( vsParams[3], frRef, vtN))
return false ;
// raggio
double dRad ;
if ( ! GetLengthParam( vsParams[4], dRad))
return false ;
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( ! IsValid( pCrvArc))
return false ;
// setto l'arco
if ( ! pCrvArc->Set( ptCen, vtN, dRad))
return false ;
// inserisco l'arco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveArcCircleXY( const STRVECTOR& vsParams)
{
// 4 parametri
if ( vsParams.size() != 4)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// centro
Point3d ptCen ;
if ( ! GetPointParam( vsParams[2], frRef, ptCen))
return false ;
// raggio
double dRad ;
if ( ! GetLengthParam( vsParams[3], dRad))
return false ;
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( ! IsValid( pCrvArc))
return false ;
// setto l'arco
if ( ! pCrvArc->SetXY( ptCen, dRad))
return false ;
// inserisco l'arco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveArc3P( const STRVECTOR& vsParams, bool bCirc)
{
// 5 parametri : Id, ParentId, ptP0, ptP1, ptP2
if ( vsParams.size() != 5)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// primo punto
Point3d ptP0 ;
if ( ! GetPointParam( vsParams[2], frRef, ptP0))
return false ;
// secondo punto
Point3d ptP1 ;
if ( ! GetPointParam( vsParams[3], frRef, ptP1))
return false ;
// terzo punto
Point3d ptP2 ;
if ( ! GetPointParam( vsParams[4], frRef, ptP2))
return false ;
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( ! IsValid( pCrvArc))
return false ;
// setto l'arco
if ( ! pCrvArc->Set3P( ptP0, ptP1, ptP2, bCirc))
return false ;
// inserisco l'arco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveArc2PDi( const STRVECTOR& vsParams)
{
// 5 parametri : Id, ParentId, ptPi, ptPf, dDiri
if ( vsParams.size() != 5)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// punto iniziale
Point3d ptPi ;
if ( ! GetPointParam( vsParams[2], frRef, ptPi))
return false ;
// punto finale
Point3d ptPf ;
if ( ! GetPointParam( vsParams[3], frRef, ptPf))
return false ;
// direzione iniziale
double dDirI ;
if ( ! GetDirParam( vsParams[4], frRef, dDirI))
return false ;
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( ! IsValid( pCrvArc))
return false ;
// setto l'arco
if ( ! pCrvArc->Set2PD( ptPi, ptPf, dDirI))
return false ;
// inserisco l'arco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveArc2PRS( const STRVECTOR& vsParams)
{
// 5 o 6 parametri : Id, ParentId, ptPi, ptPf, dRad[, CCW/CW]
if ( vsParams.size() != 5 && vsParams.size() != 6)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// punto iniziale
Point3d ptPi ;
if ( ! GetPointParam( vsParams[2], frRef, ptPi))
return false ;
// punto finale
Point3d ptPf ;
if ( ! GetPointParam( vsParams[3], frRef, ptPf))
return false ;
// raggio
double dRad ;
if ( ! GetLengthParam( vsParams[4], dRad))
return false ;
// senso di rotazione
bool bCCW = true ;
if ( vsParams.size() >= 6 && vsParams[5] == "CW")
bCCW = false ;
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( ! IsValid( pCrvArc))
return false ;
// setto l'arco
if ( ! pCrvArc->Set2PRS( ptPi, ptPf, dRad, bCCW))
return false ;
// inserisco l'arco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveArcC2P( const STRVECTOR& vsParams)
{
// 5 parametri : Id, ParentId, ptCen, ptPi, ptNearPf
if ( vsParams.size() != 5)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// centro
Point3d ptCen ;
if ( ! GetPointParam( vsParams[2], frRef, ptCen))
return false ;
// punto iniziale
Point3d ptPi ;
if ( ! GetPointParam( vsParams[3], frRef, ptPi))
return false ;
// punto vicino al finale (direzione da centro esatta)
Point3d ptNearPf ;
if ( ! GetPointParam( vsParams[4], frRef, ptNearPf))
return false ;
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( ! IsValid( pCrvArc))
return false ;
// setto l'arco
if ( ! pCrvArc->SetC2P( ptCen, ptPi, ptNearPf))
return false ;
// inserisco l'arco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveArcInvertNormal( const STRVECTOR& vsParams)
{
// 1 parametro : Id
if ( vsParams.size() != 1)
return false ;
// recupero l'arco
ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) ;
if ( pCrvArc == nullptr)
return false ;
// eseguo l'operazione
return pCrvArc->InvertN() ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveArcChangeRadius( const STRVECTOR& vsParams)
{
// 2 parametrio : Id, dNewRad
if ( vsParams.size() != 2)
return false ;
// recupero lista Id
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// leggo il nuovo raggio
double dNewRad ;
if ( ! GetLengthParam( vsParams[1], dNewRad))
return false ;
// esecuzione
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
// recupero l'arco
ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( *Iter)) ;
if ( pCrvArc == nullptr)
return false ;
// eseguo l'operazione
if ( ! pCrvArc->ChangeRadius( dNewRad))
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveArcChangeDeltaN( const STRVECTOR& vsParams)
{
// 2 parametro : Id, dNewDeltaN
if ( vsParams.size() != 2)
return false ;
// recupero lista Id
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// leggo il nuovo delta
double dNewDeltaN ;
if ( ! GetLengthParam( vsParams[1], dNewDeltaN))
return false ;
// esecuzione
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
// recupero l'arco
ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( *Iter)) ;
if ( pCrvArc == nullptr)
return false ;
// eseguo l'operazione
if ( ! pCrvArc->ChangeDeltaN( dNewDeltaN))
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveArcToAdditional( const STRVECTOR& vsParams)
{
// 1 parametro : Id
if ( vsParams.size() != 1)
return false ;
// recupero l'arco
ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) ;
if ( pCrvArc == nullptr)
return false ;
// eseguo l'operazione
return pCrvArc->ToAdditional() ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveArcFlip( const STRVECTOR& vsParams)
{
// 1 parametro : Id
if ( vsParams.size() != 1)
return false ;
// recupero l'arco
ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) ;
if ( pCrvArc == nullptr)
return false ;
// eseguo l'operazione
return pCrvArc->Flip() ;
}
//----------------------------------------------------------------------------
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 = CMD_ID_ERROR ;
// curva di Bezier intera (polinomiale)
if ( sCmd2 == "I" || sCmd2 == "INTEG") {
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 il riferimento in cui è immersa
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// recupero e setto punti di controllo
for ( i = 0 ; i <= nDeg ; ++ i) {
if ( ! GetPointParam( vsParams[i+3], frRef, ptP) ||
! pCrvBez->SetControlPoint( i, ptP))
return false ;
}
}
// curva di Bezier razionale
else if ( sCmd2 == "R" || sCmd2 == "RATIO") {
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 il riferimento in cui è immersa
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// recupero e setto punti di controllo
for ( i = 0 ; i <= nDeg ; ++ i) {
if ( ! GetPointWParam( vsParams[i+3], frRef, ptP, dW) ||
! pCrvBez->SetControlPoint( i, ptP, dW))
return false ;
}
}
// curva di Bezier ricavata da un arco
else if ( sCmd2 == "A" || sCmd2 == "FROMARC") {
// 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)
{
// creazione generica
if ( sCmd2 == "" || sCmd2 == "MAKE")
return CurveCompoMake( vsParams) ;
// creazione per congiunzione di punti (segmenti di retta)
else if ( sCmd2 == "P" || sCmd2 == "FROMPOINTS")
return CurveCompoFromPoints( vsParams) ;
// creazione per congiunzione di punti con bulge (segmenti di retta e arco)
else if ( sCmd2 == "PB" || sCmd2 == "FROMPOINTBULGES")
return CurveCompoFromPointBulges( vsParams) ;
// creazione da split di curva semplice
else if ( sCmd2 == "S" || sCmd2 == "FROMSPLIT")
return CurveCompoFromSplit( vsParams) ;
// modifica per aggiunta di una curva
else if ( sCmd2 == "ADD" || sCmd2 == "ADDCURVE")
return CurveCompoAddCurve( vsParams) ;
// altrimenti errore
else
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveCompoMake( const STRVECTOR& vsParams)
{
// creo la curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( ! IsValid( pCrvCompo))
return false ;
// 3 o 4 parametri
bool bErase ;
switch ( vsParams.size()) {
case 3 : bErase = false ; break ;
case 4 : bErase = ( vsParams[3] != "0") ; break ;
default : return false ; break ;
}
// recupero lista nomi
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[2], vnNames))
return false ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// esecuzione
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
// recupero la curva
int nIdCrv = *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 ;
}
}
// inserisco la curva composita nel DB
if ( AddGeoObj( vsParams[0], vsParams[1], Release( pCrvCompo))) {
// se richiesto, cancello le curve originali
if ( bErase) {
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
if ( ! m_pGDB->Erase( *Iter))
return false ;
}
}
return true ;
}
else
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveCompoFromPoints( const STRVECTOR& vsParams)
{
// 3 parametri : Id, ParentId, Points
if ( vsParams.size() != 3)
return false ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// recupero i punti
PNTVECTOR vPoints ;
if ( ! GetPointsParam( vsParams[2], frDest, vPoints))
return false ;
// creo la curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( ! IsValid( pCrvCompo))
return false ;
// inserisco i segmenti che uniscono i punti
if ( ! pCrvCompo->FromPointVector( vPoints))
return false ;
// inserisco la curva composita nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvCompo)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveCompoFromPointBulges( const STRVECTOR& vsParams)
{
// 3 parametri : Id, ParentId, PointWs
if ( vsParams.size() != 3)
return false ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// recupero i punti
UPNTVECTOR vPointWs ;
if ( ! GetPointWsParam( vsParams[2], frDest, vPointWs))
return false ;
// creo la curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( ! IsValid( pCrvCompo))
return false ;
// inserisco i segmenti che uniscono i punti
if ( ! pCrvCompo->FromPointBulgeVector( vPointWs, Z_AX))
return false ;
// inserisco la curva composita nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvCompo)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveCompoFromSplit( const STRVECTOR& vsParams)
{
// per eventuale cancellazione curva di origine
bool bErase ;
// 4 o 5 parametri
switch ( vsParams.size()) {
case 4 : bErase = false ; break ;
case 5 : bErase = ( vsParams[4] != "0") ; break ;
default : return false ; break ;
}
// creo la curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( ! IsValid( pCrvCompo))
return false ;
// salvo nome curva originale per eventuale cancellazione
int nIdCrv = GetIdParam( vsParams[2]) ;
// recupero la curva
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) ;
}
// inserisco la curva composita nel DB
if ( AddGeoObj( vsParams[0], vsParams[1], Release( pCrvCompo))) {
// se richiesto, cancello la curva originale
if ( bErase) {
if ( ! m_pGDB->Erase( nIdCrv))
return false ;
}
return true ;
}
else
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveCompoAddCurve( const STRVECTOR& vsParams)
{
// per eventuale cancellazione curva da accodare
bool bErase ;
// 2 o 3 parametri ( IdCurveCompo, IdCurveToAdd[, bEraseCurveToAdd])
switch ( vsParams.size()) {
case 2 : bErase = false ; break ;
case 3 : bErase = ( vsParams[2] != "0") ; break ;
default : return false ; break ;
}
// recupero la curva composita
ICurveComposite* pCrvComp = GetCurveComposite( m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) ;
if ( pCrvComp == nullptr)
return false ;
// salvo nome curva da accodare per eventuale cancellazione
int nIdCrv = GetIdParam( vsParams[1]) ;
// recupero la curva
const ICurve* pCrvToAdd = GetCurve( m_pGDB->GetGeoObj( nIdCrv)) ;
if ( pCrvToAdd == nullptr)
return false ;
// eseguo l'accodamento
if ( ! pCrvComp->AddCurve( *pCrvToAdd))
return false ;
// se richiesto, elimino la curva accodata
if ( bErase) {
if ( ! m_pGDB->Erase( nIdCrv))
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteSurfTriMesh( const string& sCmd2, const STRVECTOR& vsParams)
{
// se inizio creazione con componenti elementari
if ( sCmd2 == "BEGIN") {
return SurfTriMeshBegin( vsParams) ;
}
// se nuovo vertice
else if ( sCmd2 == "VERT" || sCmd2 == "ADDVERTEX") {
return SurfTriMeshAddVertex( vsParams) ;
}
// se nuovo triangolo
else if ( sCmd2 == "TRIA" || sCmd2 == "ADDTRIANGLE") {
return SurfTriMeshAddTriangle( vsParams) ;
}
// se fine creazione
else if ( sCmd2 == "END") {
return SurfTriMeshEnd( vsParams) ;
}
// se creazione da zuppa di triangoli
else if ( sCmd2 == "TRIAS" || sCmd2 == "BYTRIANGLESOUP") {
return SurfTriMeshByTriangleSoup( vsParams) ;
}
// se creazione per triangolazione di un contorno chiuso e piano
else if ( sCmd2 == "CONT" || sCmd2 == "BYCONTOUR") {
return SurfTriMeshByContour( vsParams) ;
}
// se creazione per estrusione
else if ( sCmd2 == "EXTR" || sCmd2 == "BYEXTRUSION") {
return SurfTriMeshByExtrusion( vsParams) ;
}
// se creazione da 2 percorsi
else if ( sCmd2 == "2P" || sCmd2 == "BY2PATHS") {
return SurfTriMeshByTwoPaths( vsParams) ;
}
// se creazione per rivoluzione
else if ( sCmd2 == "REV" || sCmd2 == "BYREVOLUTION") {
return SurfTriMeshByScrewing( false, vsParams) ;
}
// se creazione per rotoavvitamento
else if ( sCmd2 == "SCR" || sCmd2 == "BYSCREWING") {
return SurfTriMeshByScrewing( true, vsParams) ;
}
// imposto angolo limite per mediare normali in un vertice
else if ( sCmd2 == "SMA" || sCmd2 == "SMOOTHANG") {
return SurfTriMeshChangeSmoothAng( vsParams) ;
}
// compattazione per unione di vertici con posizioni coincidenti
else if ( sCmd2 == "COMP" || sCmd2 == "DOCOMPACTING") {
return SurfTriMeshDoCompacting( vsParams) ;
}
// se unione di due o più superfici per cucitura
else if ( sCmd2 == "SEW" || sCmd2 == "DOSEWING") {
return SurfTriMeshDoSewing( vsParams) ;
}
else
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::SurfTriMeshBegin( const STRVECTOR& vsParams)
{
// 4 parametri (2 opzionali) : Id, ParentId[, numero vertici e numero triangoli]
if ( vsParams.size() < 2)
return false ;
// recupero Id e ParentId
m_sId = vsParams[0] ;
m_sParentId = vsParams[1] ;
// recupero i parametri opzionali
int nNumVert = 3 ;
if ( vsParams.size() >= 3)
FromString( vsParams[2], nNumVert) ;
int nNumTria = 1 ;
if ( vsParams.size() >= 4)
FromString( vsParams[3], nNumTria) ;
// creo la superficie
ISurfTriMesh* pSTM = CreateSurfTriMesh() ;
if ( pSTM == nullptr)
return false ;
// la inizializzo
if ( ! pSTM->Init( nNumVert, nNumTria))
return false ;
// salvo il puntatore
if ( m_pGeoObj != nullptr)
delete m_pGeoObj ;
m_pGeoObj = pSTM ;
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::SurfTriMeshAddVertex( const STRVECTOR& vsParams)
{
// 1 parametro : punto
if ( vsParams.size() != 1)
return false ;
// recupero il riferimento in cui va inserito
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( m_sParentId), frRef))
return false ;
// recupero il punto
Point3d ptP ;
if ( ! GetPointParam( vsParams[0], frRef, ptP))
return false ;
// recupero la superficie
ISurfTriMesh* pSTM = GetSurfTriMesh( m_pGeoObj) ;
if ( pSTM == nullptr)
return false ;
// aggiungo il vertice
return ( pSTM->AddVertex( ptP) != -1) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::SurfTriMeshAddTriangle( const STRVECTOR& vsParams)
{
// 3 parametri : IdV1, IdV2, IdV3
if ( vsParams.size() != 3)
return false ;
// recupero gli indici dei 3 vertici
int nIdVert[3] ;
if ( ! FromString( vsParams[0], nIdVert[0]) ||
! FromString( vsParams[1], nIdVert[1]) ||
! FromString( vsParams[2], nIdVert[2]))
return false ;
// recupero la superficie
ISurfTriMesh* pSTM = GetSurfTriMesh( m_pGeoObj) ;
if ( pSTM == nullptr)
return false ;
// aggiungo il triangolo definito con gli indici dei 3 vertici
return ( pSTM->AddTriangle( nIdVert) != -1) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::SurfTriMeshEnd( const STRVECTOR& vsParams)
{
// nessun parametro
if ( vsParams.size() != 0)
return false ;
// recupero la superficie
ISurfTriMesh* pSTM = GetSurfTriMesh( m_pGeoObj) ;
if ( pSTM == nullptr)
return false ;
// valido la superficie e calcolo le adiacenze
if ( ! pSTM->AdjustTopology())
return false ;
// inserisco la superficie trimesh nel DB
m_pGeoObj = nullptr ;
bool bOk = AddGeoObj( m_sId, m_sParentId, pSTM) ;
m_sId.clear() ;
m_sParentId.clear() ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::SurfTriMeshByTriangleSoup( const STRVECTOR& vsParams)
{
// 3 o 4 parametri : Id, ParentId, IdStm/s[, bErase]
if ( vsParams.size() != 3 && vsParams.size() != 4)
return false ;
// flag per cancellazione superfici originali
bool bErase = ( vsParams.size() >= 4 && vsParams[3] == "1") ;
// recupero lista nomi
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[2], vnNames))
return false ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// Costruttore di trimesh da insieme disordinato di triangoli
StmFromTriangleSoup StmFts ;
if ( ! StmFts.Start())
return false ;
// Recupero tutti i triangoli delle superfici sorgenti e li inserisco nella nuova
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
// recupero la superficie sorgente
const ISurfTriMesh* pStmS = GetSurfTriMesh( m_pGDB->GetGeoObj( *Iter)) ;
if ( pStmS == nullptr)
return false ;
// recupero il riferimento della superficie sorgente
Frame3d frSou ;
if ( ! m_pGDB->GetGlobFrame( *Iter, frSou))
return false ;
// recupero tutti i triangoli
Triangle3d Tria ;
int nId = pStmS->GetFirstTriangle( Tria) ;
while ( nId != SVT_NULL) {
// aggiusto per i sistemi di riferimento
Tria.LocToLoc( frSou, frDest) ;
// inserisco il triangolo nella nuova superficie
if ( ! StmFts.AddTriangle( Tria))
return false ;
// passo al triangolo successivo
nId = pStmS->GetNextTriangle( nId, Tria) ;
}
}
// valido la superficie e calcolo le adiacenze
if ( ! StmFts.End())
return false ;
// inserisco la superficie trimesh nel DB
ISurfTriMesh* pSTM = StmFts.GetSurf() ;
if ( AddGeoObj( vsParams[0], vsParams[1], pSTM)) {
// se richiesto, cancello le curve originali
if ( bErase) {
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
if ( ! m_pGDB->Erase( *Iter))
return false ;
}
}
return true ;
}
else
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::SurfTriMeshByContour( const STRVECTOR& vsParams)
{
// 3 o 4 parametri : Id, ParentId, IdCurve[, dLinTol]
if ( vsParams.size() != 3 && vsParams.size() != 4)
return false ;
// recupero la tolleranza lineare
double dLinTol = LIN_TOL_STD ;
if ( vsParams.size() == 4)
FromString( vsParams[3], dLinTol) ;
// recupero l'identificativo della curva
int nIdCrv = GetIdParam( vsParams[2]) ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// calcolo la polilinea che approssima la curva
PolyLine PL ;
if ( ! GetPolylineFromCurve( nIdCrv, frDest, dLinTol, PL))
return false ;
// creo la superficie
PtrOwner<ISurfTriMesh> pSTM( CreateSurfTriMesh()) ;
if ( ! IsValid( pSTM))
return false ;
// costruisco la triangolazione
if ( ! pSTM->CreateByFlatContour( PL))
return false ;
// inserisco la superficie trimesh nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pSTM)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::SurfTriMeshByExtrusion( const STRVECTOR& vsParams)
{
// 4 o 5 parametri : Id, ParentId, IdCurve, vtExtr[, dLinTol]
if ( vsParams.size() != 4 && vsParams.size() != 5)
return false ;
// recupero la tolleranza lineare
double dLinTol = LIN_TOL_STD ;
if ( vsParams.size() == 5)
FromString( vsParams[4], dLinTol) ;
// recupero la curva
int nIdCrv = GetIdParam( vsParams[2]) ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// calcolo la polilinea che approssima la curva
PolyLine PL ;
if ( ! GetPolylineFromCurve( nIdCrv, frDest, dLinTol, PL))
return false ;
// recupero il vettore di estrusione
Vector3d vtExtr ;
if ( ! GetVectorParam( vsParams[3], frDest, vtExtr))
return false ;
// creo la superficie
PtrOwner<ISurfTriMesh> pSTM( CreateSurfTriMesh()) ;
if ( ! IsValid( pSTM))
return false ;
// costruisco l'estrusione
if ( ! pSTM->CreateByExtrusion( PL, vtExtr))
return false ;
// inserisco la superficie trimesh nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pSTM)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::SurfTriMeshByTwoPaths( const STRVECTOR& vsParams)
{
// 4 o 5 parametri : Id, ParentId, IdCurve1, IdCurve2[, dLinTol]
if ( vsParams.size() != 4 && vsParams.size() != 5)
return false ;
// recupero la tolleranza lineare
double dLinTol = LIN_TOL_STD ;
if ( vsParams.size() == 5)
FromString( vsParams[4], dLinTol) ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// recupero l'identificativo della prima curva
int nIdCrv1 = GetIdParam( vsParams[2]) ;
// calcolo la polilinea che approssima la prima curva
PolyLine PL1 ;
if ( ! GetPolylineFromCurve( nIdCrv1, frDest, dLinTol, PL1))
return false ;
// recupero l'identificativo della seconda curva
int nIdCrv2 = GetIdParam( vsParams[3]) ;
// calcolo la polilinea che approssima la seconda curva
PolyLine PL2 ;
if ( ! GetPolylineFromCurve( nIdCrv2, frDest, dLinTol, PL2))
return false ;
// creo la superficie
PtrOwner<ISurfTriMesh> pSTM( CreateSurfTriMesh()) ;
if ( ! IsValid( pSTM))
return false ;
// costruisco la rigata tra le due curve
if ( ! pSTM->CreateByTwoCurves( PL1, PL2))
return false ;
// inserisco la superficie trimesh nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pSTM)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::SurfTriMeshByScrewing( bool bMove, const STRVECTOR& vsParams)
{
// default per tolleranza lineare e movimento lungo l'asse
double dLinTol = LIN_TOL_STD ;
double dMove = 0 ;
// se previsto movimento
if ( bMove) {
// 7 o 8 parametri : Id, ParentId, IdCurve, ptRev, vtRev, dAngRot, dMove[, dLinTol]
if ( vsParams.size() != 7 && vsParams.size() != 8)
return false ;
// recupero la tolleranza lineare
if ( vsParams.size() == 8)
FromString( vsParams[7], dLinTol) ;
// recupero il movimento lungo l'asse
if ( ! FromString( vsParams[6], dMove))
return false ;
}
// altrimenti con sola rotazione
else {
// 6 o 7 parametri : Id, ParentId, IdCurve, ptRev, vtRev, dAngRot[, dLinTol]
if ( vsParams.size() != 6 && vsParams.size() != 7)
return false ;
// recupero la tolleranza lineare
if ( vsParams.size() == 7)
FromString( vsParams[6], dLinTol) ;
// non c'é movimento lungo l'asse
}
// recupero l'identificativo della curva
int nIdCrv = GetIdParam( vsParams[2]) ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// calcolo la polilinea che approssima la curva
PolyLine PL ;
if ( ! GetPolylineFromCurve( nIdCrv, frDest, dLinTol, PL))
return false ;
// recupero il punto dell'asse di rivoluzione
Point3d ptAx ;
if ( ! GetPointParam( vsParams[3], frDest, ptAx))
return false ;
// recupero il vettore dell'asse di rivoluzione
Vector3d vtAx ;
if ( ! GetVectorParam( vsParams[4], frDest, vtAx))
return false ;
// recupero l'angolo di rotazione
double dAngRotDeg ;
if ( ! FromString( vsParams[5], dAngRotDeg))
return false ;
// calcolo lo step di rotazione
double dMaxRad = 0 ;
PL.GetMaxDistanceFromLine( dMaxRad, ptAx, vtAx, 1, false) ;
if ( dMaxRad < EPS_SMALL)
return false ;
double dStepRotDeg = sqrt( 8 * dLinTol / dMaxRad) * RADTODEG ;
// creo la superficie
PtrOwner<ISurfTriMesh> pSTM( CreateSurfTriMesh()) ;
if ( ! IsValid( pSTM))
return false ;
// costruisco la rivoluzione
if ( ! pSTM->CreateByScrewing( PL, ptAx, vtAx, dAngRotDeg, dStepRotDeg, dMove))
return false ;
// inserisco la superficie trimesh nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pSTM)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::GetPolylineFromCurve( int nId, const Frame3d& frDest, double dLinTol, PolyLine& PL)
{
// recupero la curva
const ICurve* pCrv = GetCurve( m_pGDB->GetGeoObj( nId)) ;
if ( pCrv == nullptr)
return false ;
// recupero il riferimento della curva
Frame3d frCrv ;
if ( ! m_pGDB->GetGlobFrame( nId, frCrv))
return false ;
// calcolo la polilinea che approssima la curva
// se i riferimenti sono uguali
if ( AreSameFrame( frCrv, frDest)) {
// ricavo l'approssimazione
if ( ! pCrv->ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, PL))
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( frCrv) ;
pModCrv->ToLoc( frDest) ;
// ricavo l'approssimazione
if ( ! pModCrv->ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, PL))
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::SurfTriMeshChangeSmoothAng( const STRVECTOR& vsParams)
{
// 2 parametri : Id, dSmoothAngDeg
if ( vsParams.size() != 2)
return false ;
// recupero la superficie
ISurfTriMesh* pStm = GetSurfTriMesh( m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) ;
if ( pStm == nullptr)
return false ;
// recupero il valore dell'angolo
double dSmoothAng ;
if ( ! FromString( vsParams[1], dSmoothAng))
return false ;
// imposto l'angolo
pStm->SetSmoothAngle( dSmoothAng) ;
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::SurfTriMeshDoCompacting( const STRVECTOR& vsParams)
{
// 1 parametro : Id
if ( vsParams.size() != 1)
return false ;
// recupero lista nomi superfici
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// opero sui diversi oggetti
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
// recupero la superficie
ISurfTriMesh* pStm = GetSurfTriMesh( m_pGDB->GetGeoObj( *Iter)) ;
if ( pStm == nullptr)
return false ;
// eseguo la compattazione
if ( ! pStm->DoCompacting())
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::SurfTriMeshDoSewing( const STRVECTOR& vsParams)
{
// 2 o 3 parametri : Id, IdOther[, bErase]
if ( vsParams.size() != 2 && vsParams.size() != 3)
return false ;
// eventuale flag per cancellazione delle superfici cucite alla prima
bool bErase = false ;
if ( vsParams.size() >= 3 && vsParams[2] != "0")
bErase = true ;
// recupero la prima superficie
int nIdStm = GetIdParam( vsParams[0]) ;
ISurfTriMesh* pStm = GetSurfTriMesh( m_pGDB->GetGeoObj( nIdStm)) ;
if ( pStm == nullptr)
return false ;
// ne recupero il riferimento
Frame3d frStm ;
if ( ! m_pGDB->GetGlobFrame( nIdStm, frStm))
return false ;
// recupero lista nomi delle altre superfici
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[1], vnNames))
return false ;
// esecuzione
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
// recupero la superficie da cucire
const ISurfTriMesh* pStmS = GetSurfTriMesh( m_pGDB->GetGeoObj( *Iter)) ;
if ( pStmS == nullptr)
return false ;
// recupero il riferimento
Frame3d frStmS ;
if ( ! m_pGDB->GetGlobFrame( *Iter, frStmS))
return false ;
// lo esprimo rispetto a quello della prima superficie
frStmS.ToLoc( frStm) ;
// eseguo la cucitura
if ( ! pStm->DoSewing( *pStmS, frStm))
return false ;
}
// se richiesto, cancello le superfici cucite alla prima
if ( bErase) {
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter)
m_pGDB->Erase( *Iter) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteText( const string& sCmd2, const STRVECTOR& vsParams)
{
// testo nel piano locale
if ( sCmd2 == "XY" || sCmd2 == "PLANEXY") {
if ( vsParams.size() == 6)
return TextSimple( vsParams) ;
else
return TextComplete( vsParams) ;
}
// flip del testo
else if ( sCmd2 == "FLIP") {
return TextFlip( vsParams) ;
}
// auto-mirror del testo
else if ( sCmd2 == "MIR") {
return TextMir( vsParams) ;
}
// estrazione dei contorni
else if ( sCmd2 == "OUTLINE")
return TextOutline( vsParams) ;
else
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::TextSimple( const STRVECTOR& vsParams)
{
// parametri : Id, ParentId, Text, Point, AngDeg, H
if ( vsParams.size() != 6)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// recupero il punto di inserimento
Point3d ptP ;
if ( ! GetPointParam( vsParams[3], frRef, ptP))
return false ;
// recupero l'angolo di rotazione
double dAngRotDeg ;
if ( ! FromString( vsParams[4], dAngRotDeg))
return false ;
// recupero l'altezza del carattere
double dH ;
if ( ! FromString( vsParams[5], dH))
return false ;
// creo il testo
PtrOwner<IExtText> pTXT( CreateExtText()) ;
if ( ! IsValid( pTXT))
return false ;
// lo riempio
if ( ! pTXT->Set( vsParams[2], ptP, dAngRotDeg, dH))
return false ;
// inserisco il testo nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pTXT)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::TextComplete( const STRVECTOR& vsParams)
{
// parametri : Id, ParentId, Text, Point, AngDeg, Font, W, Italic, H, Rat, AddAdv
if ( vsParams.size() != 11)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// recupero il punto di inserimento
Point3d ptP ;
if ( ! GetPointParam( vsParams[3], frRef, ptP))
return false ;
// recupero l'angolo di rotazione
double dAngRotDeg ;
if ( ! FromString( vsParams[4], dAngRotDeg))
return false ;
// font
// recupero il peso (larghezza del filamento)
int nW ;
if ( ! FromString( vsParams[6], nW))
return false ;
// recupero il flag di italico
bool bItl = ( vsParams[7] == "I" || vsParams[7] == "i") ;
// recupero l'altezza del carattere
double dH ;
if ( ! FromString( vsParams[8], dH))
return false ;
// rapporto larghezza/altezza del carattere
double dRat ;
if ( ! FromString( vsParams[9], dRat))
return false ;
// avanzamento aggiuntivo
double dAddAdv ;
if ( ! FromString( vsParams[10], dAddAdv))
return false ;
// creo il testo
PtrOwner<IExtText> pTXT( CreateExtText()) ;
if ( ! IsValid( pTXT))
return false ;
// lo riempio
if ( ! pTXT->Set( vsParams[2], ptP, dAngRotDeg, vsParams[5], nW, bItl, dH, dRat, dAddAdv))
return false ;
// inserisco il testo nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pTXT)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::TextFlip( const STRVECTOR& vsParams)
{
// 1 parametro : Id
if ( vsParams.size() != 1)
return false ;
// recupero il testo
IExtText* pTXT = GetExtText( m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) ;
if ( pTXT == nullptr)
return false ;
// eseguo l'operazione
return pTXT->Flip() ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::TextMir( const STRVECTOR& vsParams)
{
// 1 o 2 parametri : Id [, LorH]
if ( vsParams.size() != 1 && vsParams.size() != 2)
return false ;
// calcolo il flag
bool bOnL = true ;
if ( vsParams.size() == 2)
bOnL = ( vsParams[1] != "H" && vsParams[1] != "h") ;
// recupero il testo
IExtText* pTXT = GetExtText( m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) ;
if ( pTXT == nullptr)
return false ;
// eseguo l'operazione
return pTXT->Mir( bOnL) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::TextOutline( const STRVECTOR& vsParams)
{
// 2 parametri : Id , IdDest
if ( vsParams.size() != 2)
return false ;
// recupero il testo
int nIdTXT = GetIdParam( vsParams[0]) ;
IExtText* pTXT = GetExtText( m_pGDB->GetGeoObj( nIdTXT)) ;
if ( pTXT == nullptr)
return false ;
// recupero il suo outline
ICURVEPLIST lstPCRV ;
pTXT->GetOutline( lstPCRV) ;
// recupero il riferimento del testo
Frame3d frTXT ;
if ( ! m_pGDB->GetGlobFrame( nIdTXT, frTXT))
return false ;
// recupero il riferimento del gruppo destinazione
int nIdDest = GetIdParam( vsParams[1]) ;
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( nIdDest, frDest))
return false ;
// inserisco le curve nel gruppo destinazione dopo aver sistemato il cambio di riferimento
bool bOk = true ;
ICURVEPLIST::iterator iIter ;
for ( iIter = lstPCRV.begin() ; iIter != lstPCRV.end() ; ++ iIter) {
(*iIter)->LocToLoc( frTXT, frDest) ;
if ( ! m_pGDB->AddGeoObj( GDB_ID_NULL, nIdDest, (*iIter))) {
delete (*iIter) ;
bOk = false ;
}
}
return bOk ;
}
//----------------------------------------------------------------------------
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 string& sParam, bool bNewAllowed)
{
return m_pParser->GetIdParam( sParam, bNewAllowed) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::GetNamesParam( const string& sParam, INTVECTOR& vnNames)
{
// divido in parti
STRVECTOR vsNames ;
Tokenize( sParam, ",", vsNames) ;
// converto in interi
vnNames.clear() ;
vnNames.reserve( vsNames.size()) ;
STRVECTOR::iterator Iter ;
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
Trim( (*Iter), " \t\r\n()") ;
int nId = GetIdParam( *Iter) ;
if ( nId != ID_SEL) {
vnNames.push_back( nId) ;
}
else {
nId = m_pGDB->GetFirstSelectedObj() ;
while ( nId != GDB_ID_NULL) {
vnNames.push_back( nId) ;
nId = m_pGDB->GetNextSelectedObj() ;
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::GetVectorParam( const string& sParam, const Frame3d& frVect, Vector3d& vtV)
{
// se insieme di tre componenti
if ( sParam[0] == '(') {
// divido in parti
STRVECTOR vsParams ;
Tokenize( sParam, ",", vsParams) ;
STRVECTOR::iterator Iter ;
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)) ;
}
// se altrimenti vettore predefinito X_AX
else if ( sParam == "X_AX") {
vtV = X_AX ;
return true ;
}
// se altrimenti vettore predefinito -X_AX
else if ( sParam == "-X_AX") {
vtV = - X_AX ;
return true ;
}
// se altrimenti vettore predefinito Y_AX
else if ( sParam == "Y_AX") {
vtV = Y_AX ;
return true ;
}
// se altrimenti vettore predefinito -Y_AX
else if ( sParam == "-Y_AX") {
vtV = - Y_AX ;
return true ;
}
// se altrimenti vettore predefinito Z_AX
else if ( sParam == "Z_AX") {
vtV = Z_AX ;
return true ;
}
// se altrimenti vettore predefinito -Z_AX
else if ( sParam == "-Z_AX") {
vtV = - Z_AX ;
return true ;
}
// se altrimenti vettore notevole
else if ( sParam[0] == 'V') {
// recupero il tipo di vettore notevole
const char cType = sParam[1] ;
// recupero i parametri associati
STRVECTOR vsParams ;
Tokenize( sParam.substr( 3, sParam.length()-4), ",", "(", ")", vsParams) ;
STRVECTOR::iterator Iter ;
for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
Trim( (*Iter), " \t\r\n") ;
// ci deve essere almeno un parametro
if ( vsParams.size() < 1)
return false ;
// recupero l'indice dell'entità indicata dal primo parametro
int nIdEnt = GetIdParam( vsParams[0]) ;
// recupero il riferimento in cui è immersa
Frame3d frEnt ;
if ( ! m_pGDB->GetGlobFrame( nIdEnt, frEnt))
return false ;
// se gruppo
const IGeoFrame3d* pGF ;
if ( ( pGF = m_pGDB->GetGeoFrame( nIdEnt)) != nullptr) {
switch ( cType) {
case 'X' : // versore X
vtV = pGF->GetFrame().VersX() ;
return vtV.LocToLoc( frEnt, frVect) ;
case 'Y' : // versore Y
vtV = pGF->GetFrame().VersY() ;
return vtV.LocToLoc( frEnt, frVect) ;
case 'Z' : // versore Z
vtV = pGF->GetFrame().VersZ() ;
return vtV.LocToLoc( frEnt, frVect) ;
default :
return false ;
}
}
// se entità geometrica
const IGeoObj* pGObj ;
if ( ( pGObj = m_pGDB->GetGeoObj( nIdEnt)) != nullptr) {
// se curva
if ( ( pGObj->GetType() & GEO_CURVE) != 0) {
// recupero la curva
const ICurve* pCrv = GetCurve( pGObj) ;
switch ( cType) {
case 'S' : // versore direzione iniziale
if ( ! pCrv->GetStartDir( vtV))
return false ;
return vtV.LocToLoc( frEnt, frVect) ;
case 'E' : // versore direzione finale
if ( ! pCrv->GetEndDir( vtV))
return false ;
return vtV.LocToLoc( frEnt, frVect) ;
case 'M' : // versore direzione media
if ( ! pCrv->GetMidDir( vtV))
return false ;
return vtV.LocToLoc( frEnt, frVect) ;
case 'U' : // versore direzione posizione parametrica
{
// secondo parametro : U
double dU = 0 ;
if ( vsParams.size() < 2 || ! FromString( vsParams[1], dU))
return false ;
// terzo parametro opzionale : direzione di calcolo (+ o -)
ICurve::Side nSide = ICurve::FROM_MINUS ;
if ( vsParams.size() >= 3 && vsParams[2] == "+")
nSide = ICurve::FROM_PLUS ;
// recupero la direzione
Point3d ptP ;
if ( ! pCrv->GetPointTang( dU, nSide, ptP, vtV))
return false ;
return vtV.LocToLoc( frEnt, frVect) ;
}
case 'N' : // versore direzione nel punto più vicino a punto dato
{
// secondo parametro : punto di riferimento
Point3d ptRef ;
if ( vsParams.size() < 2 || ! GetPointParam( vsParams[1], frEnt, ptRef))
return false ;
// terzo parametro opzionale : direzione di calcolo (+ o -)
ICurve::Side nSide = ICurve::FROM_MINUS ;
if ( vsParams.size() >= 3 && vsParams[2] == "+")
nSide = ICurve::FROM_PLUS ;
// calcolo il parametro del punto della curva più vicino al punto di riferimento
DistPointCurve dstPC( ptRef, *pCrv) ;
int nFlag ;
double dU ;
if ( ! dstPC.GetParamAtMinDistPoint( 0, dU, nFlag))
return false ;
// recupero la direzione
Point3d ptP ;
if ( ! pCrv->GetPointTang( dU, nSide, ptP, vtV))
return false ;
return vtV.LocToLoc( frEnt, frVect) ;
}
//case 'I' : // versore direzione nel punto di intersezione con un'altra curva
}
}
// se frame
else if ( pGObj->GetType() == GEO_FRAME3D) {
// recupero il frame
const IGeoFrame3d* pGF = GetGeoFrame3d( pGObj) ;
switch ( cType) {
case 'X' : // versore X
vtV = pGF->GetFrame().VersX() ;
return vtV.LocToLoc( frEnt, frVect) ;
case 'Y' : // versore Y
vtV = pGF->GetFrame().VersY() ;
return vtV.LocToLoc( frEnt, frVect) ;
case 'Z' : // versore Z
vtV = pGF->GetFrame().VersZ() ;
return vtV.LocToLoc( frEnt, frVect) ;
default :
return false ;
}
}
}
return false ;
}
// altrimenti nome di vettore già nel DB
else {
int nIdEnt = GetIdParam( sParam) ;
const IGeoVector3d* pV ;
if ( ( pV = GetGeoVector3d( m_pGDB->GetGeoObj( nIdEnt))) == nullptr)
return false ;
vtV = pV->GetVector() ;
// recupero il riferimento del punto
Frame3d frEnt ;
if ( ! m_pGDB->GetGlobFrame( nIdEnt, frEnt))
return false ;
return vtV.LocToLoc( frEnt, frVect) ;
}
}
//----------------------------------------------------------------------------
bool
GdbExecutor::GetPointParam( const string& sParam, const Frame3d& frPnt, Point3d& ptP)
{
// se insieme di 2 o 3 coordinate (considerate già nel riferimento frPnt)
if ( sParam[0] == '(') {
// divido in parti
STRVECTOR vsParams ;
Tokenize( sParam, ",", vsParams) ;
STRVECTOR::iterator Iter ;
for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
Trim( (*Iter), " \t\r\n()") ;
// se 2 parti, allora Z = 0
if ( vsParams.size() == 2) {
ptP.z = 0 ;
return ( FromString( vsParams[0], ptP.x) &&
FromString( vsParams[1], ptP.y)) ;
}
// se 3 parti
else if ( vsParams.size() == 3) {
return ( FromString( vsParams[0], ptP.x) &&
FromString( vsParams[1], ptP.y) &&
FromString( vsParams[2], ptP.z)) ;
}
// altrimenti errore
else
return false ;
}
// se altrimenti punto predefinito ORIG (considerato già nel riferimento frPnt)
else if ( sParam == "ORIG") {
ptP = ORIG ;
return true ;
}
// se altrimenti punto notevole
else if ( sParam[0] == 'P') {
// recupero il tipo di punto notevole
const char cType = sParam[1] ;
// recupero i parametri associati
STRVECTOR vsParams ;
Tokenize( sParam.substr( 3, sParam.length()-4), ",", "(", ")", vsParams) ;
STRVECTOR::iterator Iter ;
for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
Trim( (*Iter), " \t\r\n") ;
// ci deve essere almeno un parametro
if ( vsParams.size() < 1)
return false ;
// recupero l'indice dell'entità indicata dal primo parametro
int nIdEnt = GetIdParam( vsParams[0]) ;
// recupero il riferimento in cui è immersa
Frame3d frEnt ;
if ( ! m_pGDB->GetGlobFrame( nIdEnt, frEnt))
return false ;
// se gruppo
const IGeoFrame3d* pGF ;
if ( ( pGF = m_pGDB->GetGeoFrame( nIdEnt)) != nullptr) {
switch ( cType) {
case 'O' : // origine
ptP = pGF->GetFrame().Orig() ;
return ptP.LocToLoc( frEnt, frPnt) ;
default :
return false ;
}
}
// se entità geometrica
const IGeoObj* pGObj ;
if ( ( pGObj = m_pGDB->GetGeoObj( nIdEnt)) != nullptr) {
// se curva
if ( ( pGObj->GetType() & GEO_CURVE) != 0) {
// recupero la curva
const ICurve* pCrv = GetCurve( pGObj) ;
switch ( cType) {
case 'S' : // punto iniziale
if ( ! pCrv->GetStartPoint( ptP))
return false ;
return ptP.LocToLoc( frEnt, frPnt) ;
case 'E' : // punto finale
if ( ! pCrv->GetEndPoint( ptP))
return false ;
return ptP.LocToLoc( frEnt, frPnt) ;
case 'M' : // punto medio
if ( ! pCrv->GetMidPoint( ptP))
return false ;
return ptP.LocToLoc( frEnt, frPnt) ;
case 'C' : // centro
if ( ! pCrv->GetCenterPoint( ptP))
return false ;
return ptP.LocToLoc( frEnt, frPnt) ;
case 'U' : // posizione parametrica
{
double dU = 0 ;
Vector3d vtTg ;
if ( vsParams.size() < 2 || ! FromString( vsParams[1], dU))
return false ;
if ( ! pCrv->GetPointTang( dU, ICurve::FROM_MINUS, ptP, vtTg))
return false ;
return ptP.LocToLoc( frEnt, frPnt) ;
}
case 'N' : // punto più vicino a punto dato
{
// secondo parametro : punto di riferimento
Point3d ptRef ;
if ( vsParams.size() < 2 || ! GetPointParam( vsParams[1], frEnt, ptRef))
return false ;
// calcolo il punto della curva più vicino al punto di riferimento
DistPointCurve dstPC( ptRef, *pCrv) ;
int nFlag ;
if ( ! dstPC.GetMinDistPoint( 0, ptP, nFlag))
return false ;
return ptP.LocToLoc( frEnt, frPnt) ;
}
//case 'I' : // punto di intersezione con un'altra curva
}
}
// se frame
else if ( pGObj->GetType() == GEO_FRAME3D) {
// recupero il frame
const IGeoFrame3d* pGF = GetGeoFrame3d( pGObj) ;
switch ( cType) {
case 'O' : // origine
ptP = pGF->GetFrame().Orig() ;
return ptP.LocToLoc( frEnt, frPnt) ;
}
}
// se testo
else if ( pGObj->GetType() == EXT_TEXT) {
// recupero il testo
const IExtText* pTxt = GetExtText( pGObj) ;
switch ( cType) {
case 'S' : // punto iniziale
if ( ! pTxt->GetStartPoint( ptP))
return false ;
return ptP.LocToLoc( frEnt, frPnt) ;
case 'E' : // punto finale
if ( ! pTxt->GetEndPoint( ptP))
return false ;
return ptP.LocToLoc( frEnt, frPnt) ;
case 'M' : // punto medio
if ( ! pTxt->GetMidPoint( ptP))
return false ;
return ptP.LocToLoc( frEnt, frPnt) ;
case 'C' : // centro
if ( ! pTxt->GetCenterPoint( ptP))
return false ;
return ptP.LocToLoc( frEnt, frPnt) ;
}
}
}
return false ;
}
// altrimenti nome di punto già nel DB
else {
int nIdEnt = GetIdParam( sParam) ;
const IGeoPoint3d* pPt ;
if ( ( pPt = GetGeoPoint3d( m_pGDB->GetGeoObj( nIdEnt))) == nullptr)
return false ;
ptP = pPt->GetPoint() ;
// recupero il riferimento del punto
Frame3d frEnt ;
if ( ! m_pGDB->GetGlobFrame( nIdEnt, frEnt))
return false ;
return ptP.LocToLoc( frEnt, frPnt) ;
}
}
//----------------------------------------------------------------------------
bool
GdbExecutor::GetPointsParam( const string& sParam, const Frame3d& frPnt, PNTVECTOR& vPoints)
{
// divido in parti
STRVECTOR vsPoints ;
Tokenize( sParam.substr( 1, sParam.length()-2), ",", "(", ")", vsPoints) ;
// converto in punti
vPoints.clear() ;
vPoints.reserve( vsPoints.size()) ;
STRVECTOR::iterator Iter ;
for ( Iter = vsPoints.begin() ; Iter != vsPoints.end() ; ++Iter) {
Trim( (*Iter), " \t\r\n") ;
Point3d ptP ;
if ( ! GetPointParam( *Iter, frPnt, ptP))
return false ;
vPoints.push_back( ptP) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::GetPointWParam( const string& sParam, const Frame3d& frPnt, Point3d& ptP, double& dW)
{
// deve essere insieme di dati
if ( sParam[0] != '(')
return false ;
// divido in parti
STRVECTOR vsParams ;
Tokenize( sParam.substr( 1, sParam.length()-2), ",", "(", ")", vsParams) ;
STRVECTOR::iterator Iter ;
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 predefinito, punto notevole o già nel DB e un peso
else if ( vsParams.size() == 2) {
// recupero il punto
if ( ! GetPointParam( vsParams[0], frPnt, ptP))
return false ;
// recupero il peso
return FromString( vsParams[1], dW) ;
}
// altrimenti errore
else
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::GetPointWsParam( const string& sParam, const Frame3d& frPnt, UPNTVECTOR& vPointWs)
{
// divido in parti
STRVECTOR vsPointWs ;
Tokenize( sParam.substr( 1, sParam.length()-2), ",", "(", ")", vsPointWs) ;
// converto in punti
vPointWs.clear() ;
vPointWs.reserve( vsPointWs.size()) ;
STRVECTOR::iterator Iter ;
for ( Iter = vsPointWs.begin() ; Iter != vsPointWs.end() ; ++Iter) {
Trim( (*Iter), " \t\r\n") ;
UPOINT ptPW ;
if ( ! GetPointWParam( *Iter, frPnt, ptPW.second, ptPW.first))
return false ;
vPointWs.push_back( ptPW) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::GetLengthParam( const string& sParam, double& dLen)
{
// se lunghezza notevole
if ( sParam[0] == 'L') {
// recupero i parametri associati
STRVECTOR vsParams ;
Tokenize( sParam.substr( 1), ",", vsParams) ;
STRVECTOR::iterator Iter ;
for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
Trim( (*Iter), " \t\r\n()") ;
// ci deve essere almeno un parametro
if ( vsParams.size() < 1)
return false ;
// recupero l'entità indicata dal primo parametro
const IGeoObj* pGObj ;
if ( ( pGObj = m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) == nullptr)
return false ;
// se curva
if ( ( pGObj->GetType() & GEO_CURVE) != 0) {
// recupero la curva
const ICurve* pCrv = GetCurve( pGObj) ;
return pCrv->GetLength( dLen) ;
}
return false ;
}
// se raggio notevole
else if ( sParam[0] == 'R') {
// recupero i parametri associati
STRVECTOR vsParams ;
Tokenize( sParam.substr( 1), ",", vsParams) ;
STRVECTOR::iterator Iter ;
for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
Trim( (*Iter), " \t\r\n()") ;
// ci deve essere almeno un parametro
if ( vsParams.size() < 1)
return false ;
// recupero l'entità indicata dal primo parametro
const IGeoObj* pGObj ;
if ( ( pGObj = m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) == nullptr)
return false ;
// se arco
if ( pGObj->GetType() == CRV_ARC) {
// recupero l'arco
const ICurveArc* pCrvArc = GetCurveArc( pGObj) ;
dLen = pCrvArc->GetRadius() ;
return true ;
}
return false ;
}
// altrimenti valore numerico
else {
return FromString( sParam, dLen) ;
}
}
//----------------------------------------------------------------------------
bool
GdbExecutor::GetDirParam( const string& sParam, const Frame3d& frDir, double& dDir)
{
// se direzione notevole
if ( sParam[0] == 'D') {
// recupero il tipo di direzione notevole
const char cType = sParam[1] ;
// recupero i parametri associati
STRVECTOR vsParams ;
Tokenize( sParam.substr( 3, sParam.length()-4), ",", "(", ")", vsParams) ;
STRVECTOR::iterator Iter ;
for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
Trim( (*Iter), " \t\r\n") ;
// ci deve essere almeno un parametro
if ( vsParams.size() < 1)
return false ;
// recupero l'entità indicata dal primo parametro
int nIdEnt = GetIdParam( vsParams[0]) ;
const IGeoObj* pGObj ;
if ( ( pGObj = m_pGDB->GetGeoObj( nIdEnt)) == nullptr)
return false ;
// recupero il riferimento in cui è immersa
Frame3d frEnt ;
if ( ! m_pGDB->GetGlobFrame( nIdEnt, frEnt))
return false ;
// se curva
if ( ( pGObj->GetType() & GEO_CURVE) != 0) {
// recupero la curva
const ICurve* pCrv = GetCurve( pGObj) ;
Vector3d vtDir ;
switch ( cType) {
case 'S' : // direzione iniziale
if ( ! pCrv->GetStartDir( vtDir) || ! vtDir.LocToLoc( frEnt, frDir))
return false ;
vtDir.ToSpherical( nullptr, nullptr, &dDir) ;
// se esiste un secondo parametro è un offset di rotazione
if ( vsParams.size() >= 2) {
double dOffsetDeg = 0 ;
FromString( vsParams[1], dOffsetDeg) ;
dDir += dOffsetDeg ;
}
return true ;
case 'E' : // direzione finale
if ( ! pCrv->GetEndDir( vtDir) || ! vtDir.LocToLoc( frEnt, frDir))
return false ;
vtDir.ToSpherical( nullptr, nullptr, &dDir) ;
// se esiste un secondo parametro è un offset di rotazione
if ( vsParams.size() >= 2) {
double dOffsetDeg = 0 ;
FromString( vsParams[1], dOffsetDeg) ;
dDir += dOffsetDeg ;
}
return true ;
case 'M' : // direzione media
if ( ! pCrv->GetMidDir( vtDir) || ! vtDir.LocToLoc( frEnt, frDir))
return false ;
vtDir.ToSpherical( nullptr, nullptr, &dDir) ;
// se esiste un secondo parametro è un offset di rotazione
if ( vsParams.size() >= 2) {
double dOffsetDeg = 0 ;
FromString( vsParams[1], dOffsetDeg) ;
dDir += dOffsetDeg ;
}
return true ;
case 'U' : // direzione parametrica
{
// secondo parametro : U
double dU = 0 ;
if ( vsParams.size() < 2 || ! FromString( vsParams[1], dU))
return false ;
// terzo parametro opzionale : direzione di calcolo (+ o -)
ICurve::Side nSide = ICurve::FROM_MINUS ;
if ( vsParams.size() >= 3 && vsParams[2] == "+")
nSide = ICurve::FROM_PLUS ;
// recupero la direzione
Point3d ptP ;
if ( ! pCrv->GetPointTang( dU, nSide, ptP, vtDir) ||
! vtDir.LocToLoc( frEnt, frDir))
return false ;
vtDir.ToSpherical( nullptr, nullptr, &dDir) ;
// quarto parametro opzionale : offset di rotazione
if ( vsParams.size() >= 4) {
double dOffsetDeg = 0 ;
FromString( vsParams[3], dOffsetDeg) ;
dDir += dOffsetDeg ;
}
return true ;
}
case 'N' : // versore direzione nel punto più vicino a punto dato
{
// secondo parametro : punto di riferimento
Point3d ptRef ;
if ( vsParams.size() < 2 || ! GetPointParam( vsParams[1], frEnt, ptRef))
return false ;
// terzo parametro opzionale : direzione di calcolo (+ o -)
ICurve::Side nSide = ICurve::FROM_MINUS ;
if ( vsParams.size() >= 3 && vsParams[2] == "+")
nSide = ICurve::FROM_PLUS ;
// calcolo il parametro del punto della curva più vicino al punto di riferimento
DistPointCurve dstPC( ptRef, *pCrv) ;
int nFlag ;
double dU ;
if ( ! dstPC.GetParamAtMinDistPoint( 0, dU, nFlag))
return false ;
// recupero la direzione
Point3d ptP ;
if ( ! pCrv->GetPointTang( dU, nSide, ptP, vtDir) ||
! vtDir.LocToLoc( frEnt, frDir))
return false ;
vtDir.ToSpherical( nullptr, nullptr, &dDir) ;
// quarto parametro opzionale : offset di rotazione
if ( vsParams.size() >= 4) {
double dOffsetDeg = 0 ;
FromString( vsParams[3], dOffsetDeg) ;
dDir += dOffsetDeg ;
}
return true ;
}
//case 'I' :
}
}
return false ;
}
// altrimenti valore numerico
else {
return FromString( sParam, dDir) ;
}
}
//----------------------------------------------------------------------------
bool
GdbExecutor::GetFrameParam( const string& sParam, const Frame3d& frRef, Frame3d& frF)
{
// se insieme di punto origine e tre versori
if ( sParam[0] == '(') {
// elimino primo e ultimo carattere
string sTmp = sParam.substr( 1, sParam.size() - 2) ;
// divido in parti ed elimino spazi iniziali/finali
STRVECTOR vsParams ;
Tokenize( sTmp, ",", "(", ")", vsParams) ;
STRVECTOR::iterator Iter ;
for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
Trim( (*Iter), " \t\r\n") ;
// verifico siano 4 parti e le converto
if ( vsParams.size() != 4)
return false ;
Point3d ptOrig ;
Vector3d vtX, vtY, vtZ ;
if ( GetPointParam( vsParams[0], frRef, ptOrig) &&
GetVectorParam( vsParams[1], frRef, vtX) &&
GetVectorParam( vsParams[2], frRef, vtY) &&
GetVectorParam( vsParams[3], frRef, vtZ))
return frF.Set( ptOrig, vtX, vtY, vtZ) ;
else
return false ;
}
// se altrimenti riferimento predefinito
else if ( sParam[0] == 'R') {
// recupero il tipo di riferimento notevole
const char cType = sParam[1] ;
// recupero i parametri associati
// elimino primi 3 e ultimo caratteri
string sTmp ;
if ( sParam.size() > 4)
sTmp = sParam.substr( 3, sParam.size() - 4) ;
// divido in parti ed elimino spazi iniziali/finali
STRVECTOR vsParams ;
Tokenize( sTmp, ",", "(", ")", vsParams) ;
STRVECTOR::iterator Iter ;
for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
Trim( (*Iter), " \t\r\n") ;
// se c'è un parametro è l'origine
Point3d ptOrig ;
if ( vsParams.size() >= 1) {
if ( ! GetPointParam( vsParams[0], frRef, ptOrig))
return false ;
}
// costruisco il riferimento a seconda del tipo
switch ( cType) {
case 'T' : // top
frF.Set( ptOrig, Frame3d::TOP) ;
break ;
case 'U' : // bottom (under)
frF.Set( ptOrig, Frame3d::BOTTOM) ;
break ;
case 'F' : // front
frF.Set( ptOrig, Frame3d::FRONT) ;
break ;
case 'B' : // back
frF.Set( ptOrig, Frame3d::BACK) ;
break ;
case 'L' : // left
frF.Set( ptOrig, Frame3d::LEFT) ;
break ;
case 'R' : // right
frF.Set( ptOrig, Frame3d::RIGHT) ;
break ;
default :
return false ;
}
return true ;
}
// altrimenti nome di gruppo o di frame già nel DB
else {
int nIdEnt = GetIdParam( sParam) ;
const IGeoFrame3d* pFr ;
if ( ( pFr = m_pGDB->GetGeoFrame( nIdEnt)) == nullptr &&
( pFr = GetGeoFrame3d( m_pGDB->GetGeoObj( nIdEnt))) == nullptr)
return false ;
frF = pFr->GetFrame() ;
// recupero il riferimento del frame
Frame3d frEnt ;
if ( ! m_pGDB->GetGlobFrame( nIdEnt, frEnt))
return false ;
return frF.LocToLoc( frEnt, frRef) ;
}
}
//----------------------------------------------------------------------------
bool
GdbExecutor::GetColorParam( const string& sParam, bool& bByParent, Color& cCol)
{
// se insieme di tre o quattro valori
if ( sParam[0] == '(') {
// divido in parti
STRVECTOR vsParams ;
Tokenize( sParam, ",", vsParams) ;
STRVECTOR::iterator Iter ;
for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
Trim( (*Iter), " \t\r\n()") ;
// devono essere 3 o 4 parametri ( Red, Green, Blue [, Alpha])
if ( vsParams.size() != 3 && vsParams.size() != 4)
return false ;
int nRed, nGreen, nBlue ;
if ( ! FromString( vsParams[0], nRed) ||
! FromString( vsParams[1], nGreen) ||
! FromString( vsParams[2], nBlue))
return false ;
int nAlpha = 100 ;
if ( vsParams.size() == 4 &&
! FromString( vsParams[3], nAlpha))
return false ;
bByParent = false ;
cCol.Set( nRed, nGreen, nBlue, nAlpha) ;
return true ;
}
// se colore predefinito
else if ( GetStdColor( sParam, cCol)) {
bByParent = false ;
return true ;
}
// altrimenti
else {
// verifico se colore dal padre
string sTemp = sParam ;
ToUpper( sTemp) ;
ReplaceString( sTemp, " ", "") ;
if ( sTemp == "BYPARENT") {
bByParent = true ;
return true ;
}
}
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteLevel( const string& sCmd2, const STRVECTOR& vsParams)
{
// devono essere 2 parametri ( Id, Livello)
if ( vsParams.size() != 2)
return false ;
// recupero lista Id
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// recupero livello
string sLevel = vsParams[1] ;
ToUpper( sLevel) ;
int nLevel ;
if ( sLevel == "USER")
nLevel = GDB_LV_USER ;
else if ( sLevel == "SYSTEM")
nLevel = GDB_LV_SYSTEM ;
else if ( sLevel == "TEMP")
nLevel = GDB_LV_TEMP ;
else
return false ;
// esecuzione impostazione livello
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
if ( ! m_pGDB->SetLevel( *Iter, nLevel))
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteMode( const string& sCmd2, const STRVECTOR& vsParams)
{
// devono essere 2 parametri ( Id, Modo)
if ( vsParams.size() != 2)
return false ;
// recupero lista Id
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// recupero modo
string sMode = vsParams[1] ;
ToUpper( sMode) ;
int nMode ;
if ( sMode == "STD")
nMode = GDB_MD_STD ;
else if ( sMode == "LOCKED")
nMode = GDB_MD_LOCKED ;
else if ( sMode == "HIDDEN")
nMode = GDB_MD_HIDDEN ;
else
return false ;
// esecuzione impostazione modo
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
if ( ! m_pGDB->SetMode( *Iter, nMode))
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteStatus( const string& sCmd2, const STRVECTOR& vsParams)
{
// devono essere 2 parametri ( Id, Stato)
if ( vsParams.size() != 2)
return false ;
// recupero lista Id
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// recupero stato
string sStat = vsParams[1] ;
ToUpper( sStat) ;
int nStat ;
if ( sStat == "ON")
nStat = GDB_ST_ON ;
else if ( sStat == "SEL")
nStat = GDB_ST_SEL ;
else if ( sStat == "OFF")
nStat = GDB_ST_OFF ;
else
return false ;
// esecuzione impostazione stato
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
if ( ! m_pGDB->SetStatus( *Iter, nStat))
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteSelect( const string& sCmd2, const STRVECTOR& vsParams)
{
// selezione di un oggetto
if ( sCmd2.empty()) {
// deve essere 1 parametro ( Id)
if ( vsParams.size() != 1)
return false ;
// recupero lista Id
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// esecuzione selezione
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
if ( ! m_pGDB->SelectObj( *Iter))
return false ;
}
return true ;
}
// selezione di tutti gli oggetti di un gruppo
else if ( sCmd2 == "GOBJS") {
// deve essere 1 parametro ( Id)
if ( vsParams.size() != 1)
return false ;
// recupero lista Id
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// esecuzione selezione di tutti gli oggetti di ogni gruppo
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
if ( ! m_pGDB->SelectGroupObjs( *Iter))
return false ;
}
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteDeselect( const string& sCmd2, const STRVECTOR& vsParams)
{
// deselezione di un oggetto
if ( sCmd2.empty()) {
// deve essere 1 parametro ( Id)
if ( vsParams.size() != 1)
return false ;
// recupero lista Id
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// esecuzione deselezione
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
if ( ! m_pGDB->DeselectObj( *Iter))
return false ;
}
return true ;
}
// deselezione di tutti gli oggetti di un gruppo
else if ( sCmd2 == "GOBJS") {
// deve essere 1 parametro ( Id)
if ( vsParams.size() != 1)
return false ;
// recupero lista Id
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// esecuzione deselezione di tutti gli oggetti di ogni gruppo
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
if ( ! m_pGDB->DeselectGroupObjs( *Iter))
return false ;
}
return true ;
}
// deselezione di tutto
else if ( sCmd2 == "ALL") {
// nessun parametro
if ( vsParams.size() != 0)
return false ;
// cancello selezione oggetti
if ( ! m_pGDB->ClearSelection())
return false ;
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteMaterial( const string& sCmd2, const STRVECTOR& vsParams)
{
// assegnazione materiale di oggetto tramite colore
if ( sCmd2.empty() || sCmd2 == "COLOR") {
// devono essere 2 parametri ( Id, Colore)
if ( vsParams.size() != 2)
return false ;
// recupero lista Id
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// recupero il colore
bool bByParent ;
Color cCol ;
if ( ! GetColorParam( vsParams[1], bByParent, cCol))
return false ;
// esecuzione impostazione colore
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
if ( bByParent) {
if ( ! m_pGDB->SetMaterial( *Iter, GDB_MT_PARENT))
return false ;
}
else {
if ( ! m_pGDB->SetMaterial( *Iter, cCol))
return false ;
}
}
return true ;
}
// assegnazione materiale di oggetto
else if ( sCmd2 == "MAT" || sCmd2 == "MATERIAL") {
// devono essere 2 parametri ( Id, Materiale)
if ( vsParams.size() != 2)
return false ;
// recupero lista Id
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// verifico se da padre
string sMat = vsParams[1] ;
bool bByParent = ( sMat == "BYPARENT") ;
// esecuzione impostazione colore
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
if ( bByParent) {
if ( ! m_pGDB->SetMaterial( *Iter, GDB_MT_PARENT))
return false ;
}
else {
if ( ! m_pGDB->SetMaterial( *Iter, vsParams[1]))
return false ;
}
}
return true ;
}
// impostazione colore di default
else if ( sCmd2 == "DEF" || sCmd2 == "DEFAULT") {
// 1 parametro ( Colore)
if ( vsParams.size() != 1)
return false ;
// recupero il colore (deve essere concreto)
bool bByParent ;
Color cCol ;
if ( ! GetColorParam( vsParams[0], bByParent, cCol) || bByParent)
return false ;
// imposto il colore di default
return m_pGDB->SetDefaultMaterial( cCol) ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteName( const string& sCmd2, const STRVECTOR& vsParams)
{
// assegnazione nome
if ( sCmd2.empty()) {
// 2 parametri ( Id, Nome)
if ( vsParams.size() != 2)
return false ;
// recupero lista Id
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// eseguo assegnazione nome
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
if ( ! m_pGDB->SetName( *Iter, vsParams[1]))
return false ;
}
return true ;
}
// rimozione nome
else if ( sCmd2 == "REM" || sCmd2 == "REMOVE") {
// 1 parametro ( Id)
if ( vsParams.size() != 1)
return false ;
// recupero lista Id
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// eseguo rimozione nome
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
if ( ! m_pGDB->RemoveName( *Iter))
return false ;
}
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteInfo( const string& sCmd2, const STRVECTOR& vsParams)
{
// assegnazione informazione
if ( sCmd2.empty()) {
// 3 parametri ( Id, Key, Info)
if ( vsParams.size() != 3)
return false ;
// recupero lista Id
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// eseguo assegnazione Info di data Key
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
if ( ! m_pGDB->SetInfo( *Iter, vsParams[1], vsParams[2]))
return false ;
}
return true ;
}
// rimozione informazione
else if ( sCmd2 == "REM" || sCmd2 == "REMOVE") {
// 2 parametri ( Id, Key)
if ( vsParams.size() != 2)
return false ;
// recupero lista Id
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// eseguo rimozione nome Info di data Key
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
if ( ! m_pGDB->RemoveInfo( *Iter, vsParams[1]))
return false ;
}
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteMatLibrary( const string& sCmd2, const STRVECTOR& vsParams)
{
if ( sCmd2 == "ADD") {
// 5 parametri ( Nome, colAmb, colDiff, colSpec, Shininess)
if ( vsParams.size() != 5)
return false ;
// colore ambiente
bool bByParent ;
Color colAmb ;
if ( ! GetColorParam( vsParams[1], bByParent, colAmb) || bByParent)
return false ;
// colore diffuso
Color colDiff ;
if ( ! GetColorParam( vsParams[2], bByParent, colDiff) || bByParent)
return false ;
// colore speculare
Color colSpec ;
if ( ! GetColorParam( vsParams[3], bByParent, colSpec) || bByParent)
return false ;
// lucentezza
double dShin ;
if ( ! FromString( vsParams[4], dShin))
return false ;
// creo il materiale
Material matM( colAmb, colDiff, colSpec, dShin) ;
// inserisco il materiale in libreria
return ( m_pGDB->AddMaterial( vsParams[0], matM) != GDB_MT_NULL) ;
}
else if ( sCmd2 == "REMOVE") {
// 1 parametro ( Nome)
if ( vsParams.size() != 1)
return false ;
// elimino il materiale
int nMat ;
if ( ( nMat = m_pGDB->FindMaterial( vsParams[0])) == GDB_MT_NULL)
return false ;
bool bInUse ;
return m_pGDB->EraseMaterial( nMat, bInUse) ;
}
else if ( sCmd2 == "MODIFY") {
// 5 parametri ( Nome, colAmb, colDiff, colSpec, Shininess)
if ( vsParams.size() != 5)
return false ;
// colore ambiente
bool bByParent ;
Color colAmb ;
if ( ! GetColorParam( vsParams[1], bByParent, colAmb) || bByParent)
return false ;
// colore diffuso
Color colDiff ;
if ( ! GetColorParam( vsParams[2], bByParent, colDiff) || bByParent)
return false ;
// colore speculare
Color colSpec ;
if ( ! GetColorParam( vsParams[3], bByParent, colSpec) || bByParent)
return false ;
// lucentezza
double dShin ;
if ( ! FromString( vsParams[4], dShin))
return false ;
// creo il materiale
Material matM( colAmb, colDiff, colSpec, dShin) ;
// modifico i dati del materiale in libreria
int nMat ;
if ( ( nMat = m_pGDB->FindMaterial( vsParams[0])) == GDB_MT_NULL)
return false ;
return m_pGDB->ModifyMaterialData( nMat, matM) ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteCopy( const string& sCmd2, const STRVECTOR& vsParams)
{
// 3 o 4 parametri : IdSou, IdDest, RefIdDest [, SonBeforeAfter]
if ( vsParams.size() != 3 && vsParams.size() != 4)
return false ;
// recupero tipo di inserimento della copia
int nSonBeforeAfter = GDB_SON ;
if ( vsParams.size() == 4) {
string sFlag = vsParams[3] ;
ToUpper( sFlag) ;
if ( sFlag == "BEFORE")
nSonBeforeAfter = GDB_BEFORE ;
else if ( sFlag == "AFTER")
nSonBeforeAfter = GDB_AFTER ;
}
// 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]), nSonBeforeAfter) ;
else
nIdNew = m_pGDB->Copy( GetIdParam( vsParams[0]), nIdDest, GetIdParam( vsParams[2]), nSonBeforeAfter) ;
// 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::ExecuteRelocate( const string& sCmd2, const STRVECTOR& vsParams)
{
// 2 o 3 parametri : Id, NewRefId [, SonBeforeAfter]
if ( vsParams.size() != 2 && vsParams.size() != 3)
return false ;
// recupero lista nomi
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// recupero tipo di inserimento
int nSonBeforeAfter = GDB_SON ;
if ( vsParams.size() == 3) {
string sFlag = vsParams[2] ;
ToUpper( sFlag) ;
if ( sFlag == "BEFORE")
nSonBeforeAfter = GDB_BEFORE ;
else if ( sFlag == "AFTER")
nSonBeforeAfter = GDB_AFTER ;
}
// recupero flag per globale
bool bGlob = ( sCmd2 == "GLOB" || sCmd2 == "G") ;
// esecuzione rilocazioni
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
if ( bGlob) {
if ( ! m_pGDB->RelocateGlob( *Iter, GetIdParam( vsParams[1]), nSonBeforeAfter))
return false ;
}
else {
if ( ! m_pGDB->Relocate( *Iter, GetIdParam( vsParams[1]), nSonBeforeAfter))
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteErase( const string& sCmd2, const STRVECTOR& vsParams)
{
// 1 parametro ( Nome/i)
if ( vsParams.size() != 1)
return false ;
// recupero lista nomi
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// esecuzione cancellazioni
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
if ( ! m_pGDB->Erase( *Iter))
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteTranslate( const string& sCmd2, const STRVECTOR& vsParams)
{
// 2 parametri ( Nome/i, Vettore)
if ( vsParams.size() != 2)
return false ;
// recupero lista nomi
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// recupero flag per locale/globale/gruppo
enum { TRA_LOC = 0, TRA_GLOB = 1, TRA_GROUP = 2} ;
int nTraType ;
Frame3d frRef ;
if ( sCmd2 == "GLOB" || sCmd2 == "G") {
nTraType = TRA_GLOB ;
frRef = GLOB_FRM ;
}
else if ( sCmd2 == "GROUP" || sCmd2 == "GR") {
nTraType = TRA_GROUP ;
if ( ! m_pGDB->GetGroupGlobFrame( vnNames[0], frRef))
return false ;
}
else {
nTraType = TRA_LOC ;
if ( ! m_pGDB->GetGlobFrame( vnNames[0], frRef))
return false ;
}
// recupero il vettore
Vector3d vtVN ;
if ( ! GetVectorParam( vsParams[1], frRef, vtVN))
return false ;
// esecuzione traslazioni
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
switch ( nTraType) {
case TRA_LOC :
if ( ! m_pGDB->Translate( *Iter, vtVN))
return false ;
break ;
case TRA_GLOB :
if ( ! m_pGDB->TranslateGlob( *Iter, vtVN))
return false ;
break ;
case TRA_GROUP :
if ( ! m_pGDB->TranslateGroup( *Iter, vtVN))
return false ;
break ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteRotate( const string& sCmd2, const STRVECTOR& vsParams)
{
// 4 parametri ( Nome, PtoAsse, VtAsse, AngDeg)
if ( vsParams.size() != 4)
return false ;
// recupero lista nomi
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
if ( vnNames.empty())
return true ;
// recupero flag e riferimento per globale/gruppo/locale
enum { ROT_LOC = 0, ROT_GLOB = 1, ROT_GROUP = 2} ;
int nRotType ;
Frame3d frRef ;
if ( sCmd2 == "GLOB" || sCmd2 == "G") {
nRotType = ROT_GLOB ;
frRef = GLOB_FRM ;
}
else if ( sCmd2 == "GROUP" || sCmd2 == "GR") {
nRotType = ROT_GROUP ;
if ( ! m_pGDB->GetGroupGlobFrame( vnNames[0], frRef))
return false ;
}
else {
nRotType = ROT_LOC ;
if ( ! m_pGDB->GetGlobFrame( vnNames[0], frRef))
return false ;
}
// recupero il punto
Point3d ptPC ;
if ( ! GetPointParam( vsParams[1], frRef, ptPC))
return false ;
// recupero il vettore
Vector3d vtVN ;
if ( ! GetVectorParam( vsParams[2], frRef, vtVN))
return false ;
// recupero i coefficienti
double dAngDeg ;
if ( ! FromString( vsParams[3], dAngDeg))
return false ;
// esecuzione rotazioni
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
switch ( nRotType) {
case ROT_LOC :
if ( ! m_pGDB->Rotate( *Iter, ptPC, vtVN, dAngDeg))
return false ;
break ;
case ROT_GLOB :
if ( ! m_pGDB->RotateGlob( *Iter, ptPC, vtVN, dAngDeg))
return false ;
break ;
case ROT_GROUP :
if ( ! m_pGDB->RotateGroup( *Iter, ptPC, vtVN, dAngDeg))
return false ;
break ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteScale( const string& sCmd2, const STRVECTOR& vsParams)
{
// 5 parametri ( Nome, Punto o Frame, CoeffX, CoeffY, CoeffZ)
if ( vsParams.size() != 5)
return false ;
// recupero lista nomi
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
if ( vnNames.empty())
return true ;
// recupero flag e riferimento per globale/gruppo/locale
enum { SCA_LOC = 0, SCA_GLOB = 1, SCA_GROUP = 2} ;
int nScaType ;
Frame3d frRef ;
if ( sCmd2 == "GLOB" || sCmd2 == "G") {
nScaType = SCA_GLOB ;
frRef = GLOB_FRM ;
}
else if ( sCmd2 == "GROUP" || sCmd2 == "GR") {
nScaType = SCA_GROUP ;
if ( ! m_pGDB->GetGroupGlobFrame( vnNames[0], frRef))
return false ;
}
else {
nScaType = SCA_LOC ;
if ( ! m_pGDB->GetGlobFrame( vnNames[0], frRef))
return false ;
}
// provo a recuperare un punto
Point3d ptPC ;
Frame3d frFrame ;
if ( GetPointParam( vsParams[1], frRef, ptPC))
frFrame.Set( ptPC, Frame3d::TOP) ;
// provo a recuperare un frame
else if ( GetFrameParam( vsParams[1], frRef, frFrame))
;
// 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 ;
// esecuzione scalature
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
switch ( nScaType) {
case SCA_LOC :
if ( ! m_pGDB->Scale( *Iter, frFrame, dCoeffX, dCoeffY, dCoeffZ))
return false ;
break ;
case SCA_GLOB :
if ( ! m_pGDB->ScaleGlob( *Iter, frFrame, dCoeffX, dCoeffY, dCoeffZ))
return false ;
break ;
case SCA_GROUP :
if ( ! m_pGDB->ScaleGroup( *Iter, frFrame, dCoeffX, dCoeffY, dCoeffZ))
return false ;
break ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteMirror( const string& sCmd2, const STRVECTOR& vsParams)
{
// 3 parametri ( Nome, Punto, Vettore)
if ( vsParams.size() != 3)
return false ;
// recupero lista nomi
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// recupero flag e riferimento per globale/gruppo/locale
enum { MIR_LOC = 0, MIR_GLOB = 1, MIR_GROUP = 2} ;
int nMirType ;
Frame3d frRef ;
if ( sCmd2 == "GLOB" || sCmd2 == "G") {
nMirType = MIR_GLOB ;
frRef = GLOB_FRM ;
}
else if ( sCmd2 == "GROUP" || sCmd2 == "GR") {
nMirType = MIR_GROUP ;
if ( ! m_pGDB->GetGroupGlobFrame( vnNames[0], frRef))
return false ;
}
else {
nMirType = MIR_LOC ;
if ( ! m_pGDB->GetGlobFrame( vnNames[0], frRef))
return false ;
}
// recupero il punto
Point3d ptPC ;
if ( ! GetPointParam( vsParams[1], frRef, ptPC))
return false ;
// recupero il vettore
Vector3d vtVN ;
if ( ! GetVectorParam( vsParams[2], frRef, vtVN))
return false ;
// esecuzione specchiature
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
switch ( nMirType) {
case MIR_LOC :
if ( ! m_pGDB->Mirror( *Iter, ptPC, vtVN))
return false ;
break ;
case MIR_GLOB :
if ( ! m_pGDB->MirrorGlob( *Iter, ptPC, vtVN))
return false ;
break ;
case MIR_GROUP :
if ( ! m_pGDB->MirrorGroup( *Iter, ptPC, vtVN))
return false ;
break ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteShear( const string& sCmd2, const STRVECTOR& vsParams)
{
// 5 parametri ( Nome, Punto, VettNorm, VettDir, Coeff)
if ( vsParams.size() != 5)
return false ;
// recupero lista nomi
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// recupero flag e riferimento per globale/gruppo/locale
enum { MIR_LOC = 0, MIR_GLOB = 1, MIR_GROUP = 2} ;
int nMirType ;
Frame3d frRef ;
if ( sCmd2 == "GLOB" || sCmd2 == "G") {
nMirType = MIR_GLOB ;
frRef = GLOB_FRM ;
}
else if ( sCmd2 == "GROUP" || sCmd2 == "GR") {
nMirType = MIR_GROUP ;
if ( ! m_pGDB->GetGroupGlobFrame( vnNames[0], frRef))
return false ;
}
else {
nMirType = MIR_LOC ;
if ( ! m_pGDB->GetGlobFrame( vnNames[0], frRef))
return false ;
}
// recupero il punto
Point3d ptPC ;
if ( ! GetPointParam( vsParams[1], frRef, ptPC))
return false ;
// recupero il versore normale
Vector3d vtNorm ;
if ( ! GetVectorParam( vsParams[2], frRef, vtNorm))
return false ;
// recupero il versore direzione
Vector3d vtDir ;
if ( ! GetVectorParam( vsParams[3], frRef, vtDir))
return false ;
// recupero il coefficiente
double dCoeff ;
if ( ! FromString( vsParams[4], dCoeff))
return false ;
// esecuzione scorrimenti
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
switch ( nMirType) {
case MIR_LOC :
if ( ! m_pGDB->Shear( *Iter, ptPC, vtNorm, vtDir, dCoeff))
return false ;
break ;
case MIR_GLOB :
if ( ! m_pGDB->ShearGlob( *Iter, ptPC, vtNorm, vtDir, dCoeff))
return false ;
break ;
case MIR_GROUP :
if ( ! m_pGDB->ShearGroup( *Iter, ptPC, vtNorm, vtDir, dCoeff))
return false ;
break ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteInvertCurve( const string& sCmd2, const STRVECTOR& vsParams)
{
// 1 parametro ( Nome/i)
if ( vsParams.size() != 1)
return false ;
// recupero lista nomi
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// esecuzione inversione curve
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
ICurve* pCurve = GetCurve( m_pGDB->GetGeoObj( *Iter)) ;
if ( pCurve == nullptr || ! pCurve->Invert())
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteInvertSurf( const string& sCmd2, const STRVECTOR& vsParams)
{
// 1 parametro ( Nome/i)
if ( vsParams.size() != 1)
return false ;
// recupero lista nomi
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// esecuzione inversione normale superficie
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
ISurf* pSurf = GetSurf( m_pGDB->GetGeoObj( *Iter)) ;
if ( pSurf == nullptr || ! pSurf->Invert())
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteTrimCurve( const string& sCmd2, const STRVECTOR& vsParams)
{
enum SeLp { SL, EL, SP, EP} ;
// 2 parametri ( Nome, parametro)
if ( vsParams.size() != 2)
return false ;
// recupero lista nomi
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// recupero i dati di inizio
double dPar ;
if ( ! FromString( vsParams[1], dPar))
return false ;
// determino il tipo di trim
SeLp StEnLenPar ;
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
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
ICurve* pCurve ;
if ( ( pCurve = GetCurve( m_pGDB->GetGeoObj( *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 string& sCmd2, 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 string& sCmd2, const STRVECTOR& vsParams)
{
// 1 parametro ( NomeFile)
if ( vsParams.size() != 1)
return false ;
// eventuale conversione di token nel nome file
string sFile = vsParams[0] ;
m_pParser->DirReplace( sFile) ;
// pulizia e reinizializzazione del DB geometrico
m_pGDB->Clear() ;
m_pGDB->Init() ;
// esecuzione caricamento
return m_pGDB->Load( sFile) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteSave( const string& sCmd2, const STRVECTOR& vsParams)
{
// almeno 1 parametro ( NomeFile)
if ( vsParams.size() < 1)
return false ;
// eventuale conversione di token nel nome file
string sFile = vsParams[0] ;
m_pParser->DirReplace( sFile) ;
// il secondo parametro, opzionale, indica il formato del file
bool bBinary = false ;
if ( vsParams.size() == 2) {
string sBinary = vsParams[1] ;
ToUpper( sBinary) ;
bBinary = ( sBinary == "B" || sBinary == "BINARY") ;
}
// esecuzione salvataggio
return m_pGDB->Save( sFile, bBinary) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteOutTsc( const string& sCmd2, const STRVECTOR& vsParams)
{
// apro il file di uscita Tsc
if ( sCmd2 == "OPEN") {
// 1 parametro
if ( vsParams.size() != 1)
return false ;
// apro il file e scrivo intestazione
return m_OutTsc.Open( vsParams[0]) ;
}
// chiudo il file di uscita Tsc
else if ( sCmd2 == "CLOSE") {
// nessun parametro
if ( vsParams.size() != 0)
return false ;
// scrivo terminazioni e chiudo il file
return m_OutTsc.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_OutTsc.SetMaterial( dRed, dGreen, dBlue) ;
}
// imposto nuovo gruppo
else if ( sCmd2 == "SETGR") {
Frame3d frF ;
// nessun parametro
if ( vsParams.size() == 0)
frF.Reset() ;
// un parametro ( Id del gruppo)
else if ( vsParams.size() == 1) {
// recupero l'indice del gruppo
int nId = GetIdParam( vsParams[0]) ;
// recupero il riferimento del gruppo
if ( ! m_pGDB->GetGroupGlobFrame( nId, frF))
return false ;
}
// altrimenti, errore
else
return false ;
// eseguo
return m_OutTsc.NewGroupRef( frF, 0) ;
}
// emetto gruppo con tutto il suo contenuto
else if ( sCmd2 == "PUTGR") {
// almeno un parametro
if ( vsParams.size() < 1)
return false ;
// se esiste il secondo
int nFlag ;
if ( vsParams.size() == 2)
FromString( vsParams[1], nFlag) ;
else
nFlag = 0 ;
// recupero lista nomi
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// esecuzione
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
// recupero l'oggetto ed eseguo l'output
if ( ! OutGroupTsc( *Iter, nFlag))
return false ;
}
return true ;
}
// emetto oggetto geometrico
else if ( sCmd2 == "PUT") {
// almeno un parametro
if ( vsParams.size() < 1)
return false ;
// se esiste il secondo
int nFlag ;
if ( vsParams.size() == 2)
FromString( vsParams[1], nFlag) ;
else
nFlag = 0 ;
// recupero lista nomi
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// esecuzione
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
// recupero l'oggetto ed eseguo l'output
if ( ! m_OutTsc.PutGeoObj( m_pGDB->GetGeoObj( *Iter), nFlag))
return false ;
}
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::OutGroupTsc( int nId, int nFlag, int nLev)
{
m_OutTsc.Remark( "Start Group ---") ;
// emetto dati gruppo ( se non è radice)
if ( nId > GDB_ID_ROOT) {
Frame3d frFrame ;
if ( ( nLev == 0 && m_pGDB->GetGroupGlobFrame( nId, frFrame)) ||
( nLev > 0 && m_pGDB->GetGroupFrame( nId, frFrame))) {
if ( ! m_OutTsc.NewGroupRef( frFrame, nLev))
return false ;
m_OutTsc.PutCurrRef() ;
}
else
return false ;
// emetto eventuale box
if ( ( nFlag & 8) != 0) {
BBox3d b3Loc ;
if ( m_pGDB->GetLocalBBox( nId, b3Loc)) {
m_OutTsc.PushGroup() ;
if ( ! m_OutTsc.NewGroup( nLev))
return false ;
m_OutTsc.PutBBox( b3Loc) ;
m_OutTsc.PopGroup() ;
}
}
}
// emetto entità gruppo
m_OutTsc.Remark( "Entities :") ;
GdbIterator Iter( m_pGDB) ;
bool bNext = Iter.GoToFirstInGroup( nId) ;
while ( bNext) {
int nGdbType = Iter.GetGdbType() ;
if ( nGdbType == GDB_TY_GEO) {
if ( ! m_OutTsc.PutGeoObj( Iter.GetGeoObj(), nFlag))
return false ;
}
else if ( nGdbType == GDB_TY_GROUP) {
m_OutTsc.PushGroup() ;
if ( ! OutGroupTsc( Iter.GetId(), nFlag, nLev + 1))
return false ;
m_OutTsc.PopGroup() ;
}
bNext = Iter.GoToNext() ;
}
m_OutTsc.Remark( "End Group ---") ;
return true ;
}
Reference in New Issue View Git Blame Copy Permalink