Egalware/EgtGeomKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
6c14e51ef6c8c2b2d444aa863b8034efa00f60fc
EgtGeomKernel/GdbExecutor.cpp
T
Dario Sassi 6c14e51ef6 EgtGeomKernel 1.6c2 : 
- aggiunte funzioni per circonferenze e archi tangenti.
2015-03-16 07:38:43 +00:00

5511 lines
188 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/EgkStringUtils3d.h"
#include "/EgtDev/Include/EgkGeoPoint3d.h"
#include "/EgtDev/Include/EgkGeoVector3d.h"
#include "/EgtDev/Include/EgkGeoFrame3d.h"
#include "/EgtDev/Include/EgkCurveLine.h"
#include "/EgtDev/Include/EgkCurveAux.h"
#include "/EgtDev/Include/EgkLinePntTgCurve.h"
#include "/EgtDev/Include/EgkLineTgTwoCurves.h"
#include "/EgtDev/Include/EgkCurveArc.h"
#include "/EgtDev/Include/EgkCircleCenTgCurve.h"
#include "/EgtDev/Include/EgkArcPntDirTgCurve.h"
#include "/EgtDev/Include/EgkArcCenTgCurvePnt.h"
#include "/EgtDev/Include/EgkArcSpecial.h"
#include "/EgtDev/Include/EgkCurveBezier.h"
#include "/EgtDev/Include/EgkCurveComposite.h"
#include "/EgtDev/Include/EgkDistPointCurve.h"
#include "/EgtDev/Include/EgkIntersCurveCurve.h"
#include "/EgtDev/Include/EgkChainCurves.h"
#include "/EgtDev/Include/EgkBiArcs.h"
#include "/EgtDev/Include/EGkCurveByInterp.h"
#include "/EgtDev/Include/EgkSurfTriMesh.h"
#include "/EgtDev/Include/EgkExtText.h"
#include "/EgtDev/Include/EGkStmFromCurves.h"
#include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
#include "/EgtDev/Include/EGkCurveLocal.h"
#include "/EgtDev/Include/EgnStringConverter.h"
#include "/EgtDev/Include/EgnCmdParser.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
using namespace std ;
//----------------------------------------------------------------------------
// Per Id di entità
static const int ID_NO = -99 ;
// Per tipo di costruzione di poligono
static const int POLYG_INSCR = 1 ;
static const int POLYG_CIRC = 2 ;
static const int POLYG_SIDE = 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( "CI", &GdbExecutor::ExecuteCurveCircle) ;
m_ExecMgr.Insert( "CURVECIRCLE", &GdbExecutor::ExecuteCurveCircle) ;
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( "CMOD", &GdbExecutor::ExecuteCurveModify) ;
m_ExecMgr.Insert( "CURVEMODIFY", &GdbExecutor::ExecuteCurveModify) ;
m_ExecMgr.Insert( "CCOPY", &GdbExecutor::ExecuteCurveCopy) ;
m_ExecMgr.Insert( "CURVECOPY", &GdbExecutor::ExecuteCurveCopy) ;
m_ExecMgr.Insert( "SMOD", &GdbExecutor::ExecuteSurfModify) ;
m_ExecMgr.Insert( "SURFMODIFY", &GdbExecutor::ExecuteSurfModify) ;
m_ExecMgr.Insert( "NEW", &GdbExecutor::ExecuteNew) ;
m_ExecMgr.Insert( "LOAD", &GdbExecutor::ExecuteLoad) ;
m_ExecMgr.Insert( "SAVE", &GdbExecutor::ExecuteSave) ;
m_ExecMgr.Insert( "OUTTEXTICCI", &GdbExecutor::ExecuteOutTextIcci) ;
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", GDB_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)
{
// definizione diretta
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) ;
}
// definizione come somma di un punto e un vettore
else if ( sCmd2 == "S" || sCmd2 == "SUM") {
// 4 : Id, IdParent, ptP, vtV
if ( vsParams.size() != 4)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frPnt ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frPnt))
return false ;
// recupero il punto
Point3d ptP ;
if ( ! GetPointParam( vsParams[2], frPnt, ptP))
return false ;
// recupero il vettore
Vector3d vtV ;
if ( ! GetVectorParam( vsParams[3], frPnt, vtV))
return false ;
// creo il punto
IGeoPoint3d* pGPnt = CreateGeoPoint3d() ;
if ( pGPnt == nullptr)
return false ;
pGPnt->Set( ptP+ vtV) ;
return AddGeoObj( vsParams[0], vsParams[1], pGPnt) ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteVector( const string& sCmd2, const STRVECTOR& vsParams)
{
// definizione diretta
if ( sCmd2 == "" || sCmd2 == "MAKE") {
return VectorMake( vsParams) ;
}
// definizione sferica
else if ( sCmd2 == "SPHE" || sCmd2 == "FROMSPHERICAL") {
return VectorFromSpherical( vsParams) ;
}
// definizione come prodotto vettoriale di due vettori
else if ( sCmd2 == "CP" || sCmd2 == "CROSSPROD") {
return VectorCrossProduct( vsParams) ;
}
// definizione con punto base e vettore
else if ( sCmd2 == "BV" || sCmd2 == "BASEVECTOR") {
return VectorBaseVector( vsParams) ;
}
// definizione come differenza di due punti (il primo diventa base)
else if ( sCmd2 == "D" || sCmd2 == "DIFF") {
return VectorDifference( vsParams) ;
}
// impostazione del punto di base
else if ( sCmd2 == "B" || sCmd2 == "BASE") {
return VectorModifyBase( vsParams) ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::VectorMake( const STRVECTOR& vsParams)
{
// 3 o 4 parametri : Id, IdParent, Vettore [, ScaleFactor]
if ( vsParams.size() != 3 && vsParams.size() != 4)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frVect ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frVect))
return false ;
// recupero i tre componenti
Vector3d Vect ;
if ( ! GetVectorParam( vsParams[2], frVect, Vect))
return false ;
// recupero l'eventuale fattore di scala
double dScale = 1 ;
if ( vsParams.size() == 4 && ! FromString( vsParams[3], dScale))
return false ;
// creo il vettore
IGeoVector3d* pGVect = CreateGeoVector3d() ;
if ( pGVect == nullptr)
return false ;
pGVect->Set( Vect * dScale) ;
return AddGeoObj( vsParams[0], vsParams[1], pGVect) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::VectorFromSpherical( const STRVECTOR& vsParams)
{
// 5 parametri : Id, IdParent, dLen, dAngVertDeg, dAngOrizzDeg
if ( vsParams.size() != 5)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frVect ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frVect))
return false ;
// recupero la lunghezza
double dLen ;
if ( ! GetLengthParam( vsParams[2], dLen))
return false ;
// recupero l'angolo in verticale (non c'è metodo generale)
double dAngVertDeg ;
if ( ! FromString( vsParams[3], dAngVertDeg))
return false ;
// recupero l'angolo in orizzontale
double dAngOrizzDeg ;
if ( ! GetDirParam( vsParams[4], frVect, dAngOrizzDeg))
return false ;
// creo il vettore
IGeoVector3d* pGVect = CreateGeoVector3d() ;
if ( pGVect == nullptr)
return false ;
Vector3d vtV = FromSpherical( dLen, dAngVertDeg, dAngOrizzDeg) ;
pGVect->Set( vtV) ;
return AddGeoObj( vsParams[0], vsParams[1], pGVect) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::VectorCrossProduct( const STRVECTOR& vsParams)
{
// 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) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::VectorDifference( const STRVECTOR& vsParams)
{
// 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, ptP1) ;
return AddGeoObj( vsParams[0], vsParams[1], pGVect) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::VectorBaseVector( const STRVECTOR& vsParams)
{
// 4 o 5 parametri : Id, IdParent, PtBase, Vettore [, ScaleFactor]
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 punto base
Point3d ptBase ;
if ( ! GetPointParam( vsParams[2], frVect, ptBase))
return false ;
// recupero i tre componenti
Vector3d Vect ;
if ( ! GetVectorParam( vsParams[3], frVect, Vect))
return false ;
// recupero l'eventuale fattore di scala
double dScale = 1 ;
if ( vsParams.size() == 5 && ! FromString( vsParams[4], dScale))
return false ;
// creo il vettore
IGeoVector3d* pGVect = CreateGeoVector3d() ;
if ( pGVect == nullptr)
return false ;
pGVect->Set( Vect * dScale, ptBase) ;
return AddGeoObj( vsParams[0], vsParams[1], pGVect) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::VectorModifyBase( const STRVECTOR& vsParams)
{
// 2 parametri : Id, ptBase
if ( vsParams.size() != 2)
return false ;
// indice dell'oggetto
int nId = GetIdParam( vsParams[0]) ;
// recupero il riferimento in cui è immerso
Frame3d frVect ;
if ( ! m_pGDB->GetGlobFrame( nId, frVect))
return false ;
// recupero il punto di base
Point3d ptBase ;
if ( ! GetPointParam( vsParams[1], frVect, ptBase))
return false ;
// recupero l'oggetto
IGeoVector3d* pGVect = GetGeoVector3d( m_pGDB->GetGeoObj( nId)) ;
if ( pGVect == nullptr)
return false ;
// imposto il nuovo punto di base
return pGVect->ChangeBase( ptBase) ;
}
//----------------------------------------------------------------------------
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 da punto tangente a curva
else if ( sCmd2 == "PTGC" || sCmd2 == "POINTTGCURVE")
return CurveLinePointTgCurve( vsParams) ;
// creazione linea tangente a 2 archi
else if ( sCmd2 == "TG2A" || sCmd2 == "TG2ARCS")
return CurveLineTgTwoArcs( 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 ( IsNull( 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 ( IsNull( 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 ( IsNull( 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::CurveLinePointTgCurve( const STRVECTOR& vsParams)
{
// 5 parametri : Id, IdParent, ptP, IdCrv, ptNear
if ( vsParams.size() != 5)
return false ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// recupero il punto
Point3d ptStart ;
if ( ! GetPointParam( vsParams[2], frDest, 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( frDest, frCurve) ;
// recupero il punto vicino
Point3d ptNear ;
if ( ! GetPointParam( vsParams[4], frDest, ptNear))
return false ;
Point3d ptNloc = ptNear ;
ptNloc.LocToLoc( frDest, frCurve) ;
// calcolo la retta tangente alla curva
ICurveLine* pCrvLine = GetLinePointTgCurve( ptSloc, *pCurve, ptNloc) ;
if ( pCrvLine == nullptr)
return false ;
// porto la linea nel riferimento del gruppo destinazione
pCrvLine->LocToLoc( frCurve, frDest) ;
// inserisco la linea nel DB
return AddGeoObj( vsParams[0], vsParams[1], pCrvLine) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveLineTgTwoArcs( const STRVECTOR& vsParams)
{
// 6 parametri : Id, IdParent, IdCrv1, ptNear1, IdCrv2, ptNear2
if ( vsParams.size() != 6)
return false ;
// 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 nId1 ;
if ( ( nId1 = GetIdParam( vsParams[2])) == CMD_ID_ERROR)
return false ;
// recupero il riferimento della prima curva
Frame3d frCrv1 ;
if ( ! m_pGDB->GetGlobFrame( nId1, frCrv1))
return false ;
// recupero la prima curva
const ICurve* pCrv1 = GetCurve( m_pGDB->GetGeoObj( nId1)) ;
if ( pCrv1 == nullptr)
return false ;
// recupero il primo punto vicino e lo porto nel riferimento della prima curva
Point3d ptNear1 ;
if ( ! GetPointParam( vsParams[3], frDest, ptNear1))
return false ;
Point3d ptN1loc = ptNear1 ;
ptN1loc.LocToLoc( frDest, frCrv1) ;
// recupero l'identificativo della seconda curva
int nId2 ;
if ( ( nId2 = GetIdParam( vsParams[4])) == CMD_ID_ERROR)
return false ;
// recupero il riferimento della seconda curva
Frame3d frCrv2 ;
if ( ! m_pGDB->GetGlobFrame( nId2, frCrv2))
return false ;
// recupero la seconda curva
const ICurve* pCrv2 = GetCurve( m_pGDB->GetGeoObj( nId2)) ;
if ( pCrv2 == nullptr)
return false ;
// porto la seconda curva nel riferimento della prima
PtrOwner<ICurve> pCrv2Loc( pCrv2->Clone()) ;
if ( IsNull( pCrv2Loc))
return false ;
pCrv2Loc->LocToLoc( frCrv2, frCrv1) ;
// recupero il secondo punto vicino e lo porto nel riferimento della prima curva
Point3d ptNear2 ;
if ( ! GetPointParam( vsParams[5], frDest, ptNear2))
return false ;
Point3d ptN2loc = ptNear2 ;
ptN2loc.LocToLoc( frDest, frCrv1) ;
// calcolo la retta tangente alle due curve
ICurveLine* pCrvLine = GetLineTgTwoCurves( *pCrv1, ptN1loc, *pCrv2, ptN2loc) ;
if ( pCrvLine == nullptr)
return false ;
// porto la linea nel riferimento del gruppo destinazione
pCrvLine->LocToLoc( frCrv1, frDest) ;
// inserisco la linea nel DB
return AddGeoObj( vsParams[0], vsParams[1], 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 ( IsNull( 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::ExecuteCurveCircle( const string& sCmd2, const STRVECTOR& vsParams)
{
// creo circonferenza generica
if ( sCmd2 == "" || sCmd2 == "MAKE")
return CurveCircleMake( vsParams) ;
// creo circonferenza nel piano XY
else if ( sCmd2 == "XY" || sCmd2 == "PLANEXY")
return CurveCirclePlaneXY( vsParams) ;
// creo circonferenza passante per 3 punti
else if ( sCmd2 == "3P")
return CurveArcCircle3P( vsParams, true) ;
// creo circonferenza dato centro e tangente ad un arco
else if ( sCmd2 == "CTGA")
return CurveCircleCenterTgArc( vsParams) ;
// altrimenti errore
else
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteCurveArc( const string& sCmd2, const STRVECTOR& vsParams)
{
// creo arco generico
if ( sCmd2 == "" || sCmd2 == "MAKE")
return CurveArcMake( vsParams) ;
// creo arco nel piano XY
else if ( sCmd2 == "XY" || sCmd2 == "PLANEXY")
return CurveArcPlaneXY( vsParams) ;
// creo arco o circonferenza passante per 3 punti
else if ( sCmd2 == "3P")
return CurveArcCircle3P( vsParams, false) ;
// 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) ;
// creo arco dato centro, tangente ad un arco e punto vicino alla fine
else if ( sCmd2 == "CTGAP")
return CurveArcCenterTgArcP( vsParams) ;
// creo arco dato punto e direzione iniziali e tangente ad altro arco
else if ( sCmd2 == "PDTGA")
return CurveArcPDiTgArc( 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::CurveCircleMake( 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 ( IsNull( 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::CurveCirclePlaneXY( 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 ( IsNull( 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::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 ( IsNull( 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 ( IsNull( 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::CurveArcCircle3P( 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 ( IsNull( 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 ;
// calcolo l'arco (in casi particolari può essere una retta)
ICurve* pCurve = GetArc2PD( ptPi, ptPf, dDirI) ;
if ( pCurve == nullptr)
return false ;
// inserisco l'arco nel DB
return AddGeoObj( vsParams[0], vsParams[1], pCurve) ;
}
//----------------------------------------------------------------------------
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 ( IsNull( 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 ( IsNull( 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::CurveCircleCenterTgArc( const STRVECTOR& vsParams)
{
// 5 parametri : Id, ParentId, ptCen, IdArc, ptNear
if ( vsParams.size() != 5)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// centro
Point3d ptCen ;
if ( ! GetPointParam( vsParams[2], frDest, ptCen))
return false ;
// recupero l'identificativo dell'arco di tangenza
int nId ;
if ( ( nId = GetIdParam( vsParams[3])) == CMD_ID_ERROR)
return false ;
// recupero il riferimento dell'arco di tangenza
Frame3d frTgArc ;
if ( ! m_pGDB->GetGlobFrame( nId, frTgArc))
return false ;
// recupero l'arco di tangenza
const ICurveArc* pTgArc = GetCurveArc( m_pGDB->GetGeoObj( nId)) ;
if ( pTgArc == nullptr)
return false ;
// porto il centro nel riferimento dell'arco di tangenza
Point3d ptCloc = ptCen ;
ptCloc.LocToLoc( frDest, frTgArc) ;
// recupero il punto vicino
Point3d ptNear ;
if ( ! GetPointParam( vsParams[4], frDest, ptNear))
return false ;
Point3d ptNloc = ptNear ;
ptNloc.LocToLoc( frDest, frTgArc) ;
// calcolo la circonferenza tangente all'arco
ICurveArc* pNewArc = GetCircleCenTgCurve( ptCloc, pTgArc->GetNormVersor(), *pTgArc, ptNloc) ;
if ( pNewArc == nullptr)
return false ;
// porto il nuovo arco nel riferimento del gruppo destinazione
pNewArc->LocToLoc( frTgArc, frDest) ;
// inserisco la linea nel DB
return AddGeoObj( vsParams[0], vsParams[1], pNewArc) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveArcCenterTgArcP( const STRVECTOR& vsParams)
{
// 6 parametri : Id, ParentId, ptCen, IdArc, ptNearTg, ptNearEnd
if ( vsParams.size() != 6)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// centro
Point3d ptCen ;
if ( ! GetPointParam( vsParams[2], frDest, ptCen))
return false ;
// recupero l'identificativo dell'arco di tangenza
int nId ;
if ( ( nId = GetIdParam( vsParams[3])) == CMD_ID_ERROR)
return false ;
// recupero il riferimento dell'arco di tangenza
Frame3d frTgArc ;
if ( ! m_pGDB->GetGlobFrame( nId, frTgArc))
return false ;
// recupero l'arco di tangenza
const ICurveArc* pTgArc = GetCurveArc( m_pGDB->GetGeoObj( nId)) ;
if ( pTgArc == nullptr)
return false ;
// porto il centro nel riferimento dell'arco di tangenza
Point3d ptCloc = ptCen ;
ptCloc.LocToLoc( frDest, frTgArc) ;
// recupero il punto vicino alla tg
Point3d ptNear ;
if ( ! GetPointParam( vsParams[4], frDest, ptNear))
return false ;
Point3d ptNtloc = ptNear ;
ptNtloc.LocToLoc( frDest, frTgArc) ;
// recupero il punto vicino alla fine
Point3d ptNearEnd ;
if ( ! GetPointParam( vsParams[5], frDest, ptNear))
return false ;
Point3d ptNeloc = ptNear ;
ptNeloc.LocToLoc( frDest, frTgArc) ;
// calcolo la circonferenza tangente all'arco
ICurveArc* pNewArc = GetArcCenTgCurvePnt( ptCloc, *pTgArc, ptNtloc, ptNeloc, Z_AX) ;
if ( pNewArc == nullptr)
return false ;
// porto il nuovo arco nel riferimento del gruppo destinazione
pNewArc->LocToLoc( frTgArc, frDest) ;
// inserisco la linea nel DB
return AddGeoObj( vsParams[0], vsParams[1], pNewArc) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveArcPDiTgArc( const STRVECTOR& vsParams)
{
// 6 parametri : Id, ParentId, ptStart, dirStart, IdArc, ptNear
if ( vsParams.size() != 6)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// punto iniziale
Point3d ptStart ;
if ( ! GetPointParam( vsParams[2], frDest, ptStart))
return false ;
// direzione iniziale
double dDirI ;
if ( ! GetDirParam( vsParams[3], frDest, dDirI))
return false ;
// recupero l'identificativo dell'arco di tangenza
int nId ;
if ( ( nId = GetIdParam( vsParams[4])) == CMD_ID_ERROR)
return false ;
// recupero il riferimento dell'arco di tangenza
Frame3d frTgArc ;
if ( ! m_pGDB->GetGlobFrame( nId, frTgArc))
return false ;
// recupero l'arco di tangenza
const ICurveArc* pTgArc = GetCurveArc( m_pGDB->GetGeoObj( nId)) ;
if ( pTgArc == nullptr)
return false ;
// porto il punto di inizio nel riferimento dell'arco di tangenza
Point3d ptSloc = ptStart ;
ptSloc.LocToLoc( frDest, frTgArc) ;
// recupero il punto vicino alla tg
Point3d ptNear ;
if ( ! GetPointParam( vsParams[5], frDest, ptNear))
return false ;
Point3d ptNtloc = ptNear ;
ptNtloc.LocToLoc( frDest, frTgArc) ;
// calcolo l'arco (in casi particolari può essere una linea)
ICurve* pCurve = GetArcPntDirTgCurve( ptSloc, FromPolar( 1, dDirI), *pTgArc, ptNtloc, Z_AX) ;
if ( pCurve == nullptr)
return false ;
// porto il nuovo arco nel riferimento del gruppo destinazione
pCurve->LocToLoc( frTgArc, frDest) ;
// inserisco la linea nel DB
return AddGeoObj( vsParams[0], vsParams[1], pCurve) ;
}
//----------------------------------------------------------------------------
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 ( IsNull( 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 ;
// se curva nulla (ovvero ridotta a punto), errore
if ( pCrvBez->IsAPoint())
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 per interpolazione di punti
else if ( sCmd2 == "PINTERP" || sCmd2 == "FROMPOINTINTERPOLATION")
return CurveCompoFromPointInterpolation( vsParams) ;
// creazione per approssimazione di curva
else if ( sCmd2 == "CAPPROX" || sCmd2 == "FROMCURVEAPPROXIMATION")
return CurveCompoFromCurveApproximation( vsParams) ;
// creazione da split di curva semplice
else if ( sCmd2 == "S" || sCmd2 == "FROMSPLIT")
return CurveCompoFromSplit( vsParams) ;
// creazione come poligono inscritto
else if ( sCmd2 == "POLYGIN" || sCmd2 == "FROMPOLYGONINSCRIBED")
return CurveCompoFromPolygon( vsParams, POLYG_INSCR) ;
// creazione come poligono circoscritto
else if ( sCmd2 == "POLYGCIRC" || sCmd2 == "FROMPOLYGONCIRCUMSCRIBED")
return CurveCompoFromPolygon( vsParams, POLYG_CIRC) ;
// creazione come poligono dato il lato
else if ( sCmd2 == "POLYGSIDE" || sCmd2 == "FROMPOLYGONSIDE")
return CurveCompoFromPolygon( vsParams, POLYG_SIDE) ;
// creazione come biarco
else if ( sCmd2 == "BIARC" || sCmd2 == "FROMBIARC")
return CurveCompoFromBiarc( vsParams) ;
// modifica per aggiunta di una curva alla fine
else if ( sCmd2 == "AEC" || sCmd2 == "ADDENDCURVE")
return CurveCompoAddCurve( vsParams, true) ;
// modifica per aggiunta di una curva all'inizio
else if ( sCmd2 == "ASC" || sCmd2 == "ADDSTARTCURVE")
return CurveCompoAddCurve( vsParams, false) ;
// modifica per estrazione della curva finale
else if ( sCmd2 == "EEC" || sCmd2 == "EXTRACTENDCURVE")
return CurveCompoExtractCurve( vsParams, true) ;
// modifica per estrazione della curva iniziale
else if ( sCmd2 == "ESC" || sCmd2 == "EXTRACTSTARTCURVE")
return CurveCompoExtractCurve( vsParams, false) ;
// cambio punto di partenza (se chiusa)
else if ( sCmd2 == "CS" || sCmd2 == "CHANGESTART")
return CurveCompoChangeStart( vsParams) ;
// altrimenti errore
else
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveCompoMake( const STRVECTOR& vsParams)
{
// creo la curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( 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( pCrv->Clone()) ;
if ( IsNull( 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
PolyLine PL ;
if ( ! GetPointsParam( vsParams[2], frDest, PL))
return false ;
// creo la curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return false ;
// inserisco i segmenti che uniscono i punti
if ( ! pCrvCompo->FromPolyLine( PL))
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
PolyArc PA ;
if ( ! GetPointWsParam( vsParams[2], frDest, PA))
return false ;
// creo la curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return false ;
// inserisco i segmenti che uniscono i punti
if ( ! pCrvCompo->FromPolyArc( PA))
return false ;
// inserisco la curva composita nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvCompo)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveCompoFromPointInterpolation( const STRVECTOR& vsParams)
{
// 5 parametri : Id, ParentId, Points, Method, Type
if ( vsParams.size() != 5)
return false ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// recupero i punti
PolyLine PL ;
if ( ! GetPointsParam( vsParams[2], frDest, PL))
return false ;
// recupero il metodo di interpolazione
string sMethod = vsParams[3] ;
ToUpper( sMethod) ;
int nMethod = 0 ;
if ( sMethod == "BESSEL")
nMethod = CurveByInterp::BESSEL ;
else if ( sMethod == "AKIMA")
nMethod = CurveByInterp::AKIMA ;
else if ( sMethod == "AKIMA_CORNER")
nMethod = CurveByInterp::AKIMA_CORNER ;
// recupero il tipo di risultato di interpolazione
string sType = vsParams[4] ;
ToUpper( sType) ;
int nType = 0 ;
if ( sType == "BIARCS")
nType = CurveByInterp::BIARCS ;
else if ( sType == "CUBIC_BEZIERS")
nType = CurveByInterp::CUBIC_BEZIERS ;
// oggetto interpolatore
CurveByInterp crvByInterp ;
crvByInterp.Start() ;
Point3d ptP ;
for ( bool bFound = PL.GetFirstPoint( ptP) ;
bFound ;
bFound = PL.GetNextPoint( ptP))
crvByInterp.AddPoint( ptP) ;
crvByInterp.End() ;
PtrOwner<ICurve> pCrv( crvByInterp.GetCurve( nMethod, nType)) ;
if ( IsNull( pCrv))
return false ;
// inserisco la curva composita nel DB
return AddGeoObj( vsParams[0], vsParams[1], ::Release( pCrv)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveCompoFromCurveApproximation( const STRVECTOR& vsParams)
{
// 5 parametri : Id, ParentId, SouCrvId, Method, dLinTol5
if ( vsParams.size() != 5)
return false ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// recupero la curva in locale
int nSouId = GetIdParam( vsParams[2]) ;
CurveLocal CrvLoc( m_pGDB, nSouId, frDest) ;
if ( CrvLoc.Get() == nullptr)
return false ;
// recupero il tipo di approssimazione
string sType = vsParams[3] ;
ToUpper( sType) ;
int nType = 1 ;
if ( sType == "LINES")
nType = 1 ;
else if ( sType == "BIARCS")
nType = 2 ;
// recupero la tolleranza lineare
double dLinTol ;
if ( ! FromString( vsParams[4], dLinTol))
return false ;
// eseguo l'approssimazione
PtrOwner<ICurveComposite> pCC( CreateCurveComposite()) ;
if ( IsNull( pCC))
return false ;
if ( nType == 1) { // con linee
PolyLine PL ;
if ( ! CrvLoc.Get()->ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, PL) ||
! pCC->FromPolyLine( PL))
return false ;
}
else { // con bi-archi
PolyArc PA ;
if ( ! CrvLoc.Get()->ApproxWithArcs( dLinTol, ANG_TOL_STD_DEG, PA) ||
! pCC->FromPolyArc( PA))
return false ;
}
// inserisco la curva composita nel DB
return AddGeoObj( vsParams[0], vsParams[1], ::Release( pCC)) ;
}
//----------------------------------------------------------------------------
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 ( IsNull( 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->LocToLoc( frSou, 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::CurveCompoFromPolygon( const STRVECTOR& vsParams, int nType)
{
// 5 parametri : Id, IdParent, NumLati, ptP1, ptP2
if ( vsParams.size() != 5)
return false ;
// recupero il numero di lati
int nNumLati ;
if ( ! FromString( vsParams[2], nNumLati))
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// recupero punto P1
Point3d ptP1 ;
if ( ! GetPointParam( vsParams[3], frRef, ptP1))
return false ;
// recupero punto P2
Point3d ptP2 ;
if ( ! GetPointParam( vsParams[4], frRef, ptP2))
return false ;
// creo la curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return false ;
// costruisco il poligono
switch ( nType) {
case POLYG_INSCR :
if ( ! pCrvCompo->PolygonCenterCorner( nNumLati, ptP1, ptP2, Z_AX))
return false ;
break ;
case POLYG_CIRC :
if ( ! pCrvCompo->PolygonCenterMidSide( nNumLati, ptP1, ptP2, Z_AX))
return false ;
break ;
case POLYG_SIDE :
if ( ! pCrvCompo->PolygonSide( nNumLati, ptP1, ptP2, Z_AX))
return false ;
break ;
default :
return false ;
break ;
}
// inserisco la curva composita nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvCompo)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveCompoFromBiarc( const STRVECTOR& vsParams)
{
// 6 o 7 parametri : Id, IdParent, ptP1, Dir1, ptP2, Dir2 [, Par]
if ( vsParams.size() != 6 && vsParams.size() != 7)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// recupero punto P1
Point3d ptP1 ;
if ( ! GetPointParam( vsParams[2], frRef, ptP1))
return false ;
// recupero direzione Dir1
double dDir1 ;
if ( ! GetDirParam( vsParams[3], frRef, dDir1))
return false ;
// recupero punto P2
Point3d ptP2 ;
if ( ! GetPointParam( vsParams[4], frRef, ptP2))
return false ;
// recupero direzione Dir2
double dDir2 ;
if ( ! GetDirParam( vsParams[5], frRef, dDir2))
return false ;
// setto o recupero parametro
double dPar = 0.5 ;
if ( vsParams.size() >= 7 && ! FromString( vsParams[6], dPar))
return false ;
// costruisco il biarco
PtrOwner<ICurve> pBiArc( GetBiArc( ptP1, dDir1, ptP2, dDir2, dPar)) ;
if ( IsNull( pBiArc))
return false ;
// inserisco la curva nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pBiArc)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveCompoAddCurve( const STRVECTOR& vsParams, bool bEndOrStart)
{
// 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, bEndOrStart))
return false ;
// se richiesto, elimino la curva accodata
if ( bErase) {
if ( ! m_pGDB->Erase( nIdCrv))
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveCompoExtractCurve( const STRVECTOR& vsParams, bool bEndOrStart)
{
// 1 o 3 parametri : IdSou[, IdDest, IdParent]
if ( vsParams.size() != 1 && vsParams.size() != 3)
return false ;
// recupero la curva composita e il suo riferimento
int nIdCCompo = GetIdParam( vsParams[0]) ;
ICurveComposite* pCrvCompo = GetCurveComposite( m_pGDB->GetGeoObj( nIdCCompo)) ;
if ( pCrvCompo == nullptr)
return false ;
Frame3d frSou ;
if ( ! m_pGDB->GetGlobFrame( nIdCCompo, frSou))
return false ;
// estraggo la opportuna entità
PtrOwner<ICurve> pCrv( pCrvCompo->RemoveFirstOrLastCurve( bEndOrStart)) ;
// se 1 solo parametro -> cancellazione
if ( vsParams.size() == 1)
return true ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[2]), frDest))
return false ;
// porto la curva estratta dal riferimento della sorgente a quello di inserimento
if ( ! AreSameFrame( frSou, frDest))
pCrv->LocToLoc( frSou, frDest) ;
// inserisco la curva estratta nel DB
return AddGeoObj( vsParams[1], vsParams[2], ::Release( pCrv)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveCompoChangeStart( const STRVECTOR& vsParams)
{
// 2 parametri : Id, ParNewStart
if ( vsParams.size() != 2)
return false ;
// recupero la curva composita
ICurveComposite* pCrvComp = GetCurveComposite( m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) ;
if ( pCrvComp == nullptr)
return false ;
// recupero il parametro del nuovo inizio
double dParNewStart ;
if ( ! FromString( vsParams[1], dParNewStart))
return false ;
// eseguo il cambio di inizio
return pCrvComp->ChangeStartPoint( dParNewStart) ;
}
//----------------------------------------------------------------------------
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 SurfTriMeshByFlatContour( 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::SurfTriMeshByFlatContour( const STRVECTOR& vsParams)
{
// 3 o 4 parametri : Id, ParentId, IdCurve[, dLinTol]
if ( vsParams.size() != 3 && vsParams.size() != 4)
return false ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// recupero la curva in locale
int nCrvId = GetIdParam( vsParams[2]) ;
CurveLocal CrvLoc( m_pGDB, nCrvId, frDest) ;
if ( CrvLoc.Get() == nullptr)
return false ;
// recupero la tolleranza lineare
double dLinTol = LIN_TOL_STD ;
if ( vsParams.size() == 4)
FromString( vsParams[3], dLinTol) ;
// calcolo la superficie
ISurfTriMesh* pSTM = GetSurfTriMeshByFlatContour( CrvLoc.Get(), dLinTol) ;
if ( pSTM == nullptr)
return false ;
// inserisco la superficie trimesh nel DB
return AddGeoObj( vsParams[0], vsParams[1], 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 il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// recupero la curva in locale
int nCrvId = GetIdParam( vsParams[2]) ;
CurveLocal CrvLoc( m_pGDB, nCrvId, frDest) ;
if ( CrvLoc.Get() == nullptr)
return false ;
// recupero il vettore di estrusione (già in locale)
Vector3d vtExtr ;
if ( ! GetVectorParam( vsParams[3], frDest, vtExtr))
return false ;
// recupero la tolleranza lineare
double dLinTol = LIN_TOL_STD ;
if ( vsParams.size() == 5)
FromString( vsParams[4], dLinTol) ;
// calcolo la superficie
ISurfTriMesh* pSTM = GetSurfTriMeshByExtrusion( CrvLoc.Get(), vtExtr, false, dLinTol) ;
if ( pSTM == nullptr)
return false ;
// inserisco la superficie trimesh nel DB
return AddGeoObj( vsParams[0], vsParams[1], 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 il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// recupero la prima curva in locale
int nCrvId1 = GetIdParam( vsParams[2]) ;
CurveLocal CrvLoc1( m_pGDB, nCrvId1, frDest) ;
if ( CrvLoc1.Get() == nullptr)
return false ;
// recupero la seconda curva in locale
int nCrvId2 = GetIdParam( vsParams[3]) ;
CurveLocal CrvLoc2( m_pGDB, nCrvId2, frDest) ;
if ( CrvLoc2.Get() == nullptr)
return false ;
// recupero la tolleranza lineare
double dLinTol = LIN_TOL_STD ;
if ( vsParams.size() == 5)
FromString( vsParams[4], dLinTol) ;
// calcolo la superficie
ISurfTriMesh* pSTM = GetSurfTriMeshRuled( CrvLoc1.Get(), CrvLoc2.Get(), dLinTol) ;
if ( pSTM == nullptr)
return false ;
// inserisco la superficie trimesh nel DB
return AddGeoObj( vsParams[0], vsParams[1], 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 il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
return false ;
// recupero la curva in locale
int nCrvId = GetIdParam( vsParams[2]) ;
CurveLocal CrvLoc( m_pGDB, nCrvId, frDest) ;
if ( CrvLoc.Get() == nullptr)
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 la superficie
ISurfTriMesh* pSTM = GetSurfTriMeshByScrewing( CrvLoc.Get(), ptAx, vtAx, dAngRotDeg, dMove, dLinTol) ;
if ( pSTM == nullptr)
return false ;
// inserisco la superficie trimesh nel DB
return AddGeoObj( vsParams[0], vsParams[1], pSTM) ;
}
//----------------------------------------------------------------------------
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) ;
}
// modifica del testo
else if ( sCmd2 == "MT" || sCmd2 == "MODIFYTEXT") {
return TextModifyText( vsParams) ;
}
// cambio del font
else if ( sCmd2 == "CF" || sCmd2 == "CHANGEFONT") {
return TextChangeFont( 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) ;
}
// spezzatura in singole linee
else if ( sCmd2 == "SPLIT") {
return TextSplitOnLineBreak( 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 testo
string sText ;
if ( ! GetStringParam( vsParams[2], sText))
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 ( IsNull( pTXT))
return false ;
// lo riempio
if ( ! pTXT->Set( ptP, dAngRotDeg, sText, 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, PosIns
if ( vsParams.size() != 12)
return false ;
// recupero il riferimento in cui è immerso
Frame3d frRef ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
return false ;
// recupero il testo
string sText ;
if ( ! GetStringParam( vsParams[2], sText))
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 ;
// falg per posizione di inserimento
int nInsPos = ETXT_IPBL ;
string sInsPos = vsParams[11] ;
ToUpper( sInsPos) ;
if ( sInsPos == "TL")
nInsPos = ETXT_IPTL ;
else if ( sInsPos == "TC")
nInsPos = ETXT_IPTC ;
else if ( sInsPos == "TR")
nInsPos = ETXT_IPTR ;
else if ( sInsPos == "ML")
nInsPos = ETXT_IPML ;
else if ( sInsPos == "MC")
nInsPos = ETXT_IPMC ;
else if ( sInsPos == "MR")
nInsPos = ETXT_IPMR ;
else if ( sInsPos == "BL")
nInsPos = ETXT_IPBL ;
else if ( sInsPos == "BC")
nInsPos = ETXT_IPBC ;
else if ( sInsPos == "BR")
nInsPos = ETXT_IPBR ;
// creo il testo
PtrOwner<IExtText> pTXT( CreateExtText()) ;
if ( IsNull( pTXT))
return false ;
// lo riempio
if ( ! pTXT->Set( ptP, Z_AX, FromPolar( 1, dAngRotDeg), sText, vsParams[5], nW, bItl, dH, dRat, dAddAdv, nInsPos))
return false ;
// inserisco il testo nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pTXT)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::TextModifyText( const STRVECTOR& vsParams)
{
// 2 parametri : Id, NewText
if ( vsParams.size() != 2)
return false ;
// recupero il testo
string sText ;
if ( ! GetStringParam( vsParams[1], sText))
return false ;
// recupero il testo
IExtText* pTXT = GetExtText( m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) ;
if ( pTXT == nullptr)
return false ;
// eseguo l'operazione
return pTXT->ModifyText( sText) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::TextChangeFont( const STRVECTOR& vsParams)
{
// 2 parametri : Id, NewFont
if ( vsParams.size() != 2)
return false ;
// recupero il nome del font
string sFont ;
if ( ! GetStringParam( vsParams[1], sFont))
return false ;
// recupero il testo
IExtText* pTXT = GetExtText( m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) ;
if ( pTXT == nullptr)
return false ;
// eseguo l'operazione
return pTXT->ChangeFont( sFont) ;
}
//----------------------------------------------------------------------------
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 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 ;
// recupero l'outline del testo
ICURVEPLIST lstPCRV ;
pTXT->GetOutline( lstPCRV) ;
// 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)) == GDB_ID_NULL) {
delete (*iIter) ;
bOk = false ;
}
}
return bOk ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::TextSplitOnLineBreak( 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 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 ;
// recupero l'esplosione del testo in linee singole
IEXTTEXTPVECTOR vTxt ;
pTXT->SplitOnLineBreak( vTxt) ;
// inserisco i nuovi testi nel gruppo destinazione dopo aver sistemato il cambio di riferimento
bool bOk = true ;
for ( int i = 0 ; i < int( vTxt.size()) ; ++ i) {
vTxt[i]->LocToLoc( frTXT, frDest) ;
if ( m_pGDB->AddGeoObj( GDB_ID_NULL, nIdDest, vTxt[i]) == GDB_ID_NULL) {
delete vTxt[i] ;
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 nId da calcolare, può essere una variabile 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 != GDB_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()") ;
// se 2 parti, allora Z = 0
if ( vsParams.size() == 2) {
vtV.z = 0 ;
return ( FromString( vsParams[0], vtV.x) &&
FromString( vsParams[1], vtV.y)) ;
}
// se 3 parti
else if ( vsParams.size() == 3) {
return ( FromString( vsParams[0], vtV.x) &&
FromString( vsParams[1], vtV.y) &&
FromString( vsParams[2], vtV.z)) ;
}
// altrimenti errore
else
return false ;
}
// 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 Frame3d* pGrpF ;
if ( ( pGrpF = m_pGDB->GetGroupFrame( nIdEnt)) != nullptr) {
switch ( cType) {
case 'X' : // versore X
vtV = pGrpF->VersX() ;
return vtV.LocToLoc( frEnt, frVect) ;
case 'Y' : // versore Y
vtV = pGrpF->VersY() ;
return vtV.LocToLoc( frEnt, frVect) ;
case 'Z' : // versore Z
vtV = pGrpF->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 ;
}
}
// se testo
else if ( pGObj->GetType() == EXT_TEXT) {
// recupero il testo
const IExtText* pTxt = GetExtText( pGObj) ;
switch ( cType) {
case 'D' : // versore direzione longitudinale del testo
vtV = pTxt->GetDirVersor() ;
return vtV.LocToLoc( frEnt, frVect) ;
case 'H' : // versore direzione trasversale del testo
return ( pTxt->GetHeightVersor( vtV) &&
vtV.LocToLoc( frEnt, frVect)) ;
case 'O' : // versore ortogonale al piano del testo
vtV = pTxt->GetNormVersor() ;
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 Frame3d* pGrpF ;
if ( ( pGrpF = m_pGDB->GetGroupFrame( nIdEnt)) != nullptr) {
switch ( cType) {
case 'O' : // origine
ptP = pGrpF->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
{
// secondo parametro : altra curva
int nIdEnt2 = GetIdParam( vsParams[1]) ;
const IGeoObj* pGObj2 = m_pGDB->GetGeoObj( nIdEnt2) ;
if ( pGObj2 == nullptr)
return false ;
// deve essere una curva
const ICurve* pCrv2 = GetCurve( pGObj2) ;
if ( pCrv2 == nullptr)
return false ;
// recupero il riferimento in cui è immersa
Frame3d frEnt2 ;
if ( ! m_pGDB->GetGlobFrame( nIdEnt2, frEnt2))
return false ;
// se il riferimento è diverso da quello della prima entità, devo trasformarla
PtrOwner<ICurve> crvTrans( nullptr) ;
if ( ! AreSameFrame( frEnt, frEnt2)) {
crvTrans.Set( pCrv2->Clone()) ;
if ( IsNull( crvTrans))
return false ;
crvTrans->LocToLoc( frEnt2, frEnt) ;
pCrv2 = ::Get( crvTrans) ;
}
// eventuale terzo parametro : punto di riferimento
Point3d ptRef ;
if ( vsParams.size() >= 3 && ! GetPointParam( vsParams[2], frEnt, ptRef))
return false ;
// calcolo il punto di intersezione sulla prima curva più vicino al punto di riferimento
IntersCurveCurve intCC( *pCrv, *pCrv2, true) ;
if ( ! intCC.GetIntersPointNearTo( 0, ptRef, ptP))
return false ;
return ptP.LocToLoc( frEnt, frPnt) ;
}
}
}
// se vettore
else if ( pGObj->GetType() == GEO_VECT3D) {
// recupero il geo-vettore
const IGeoVector3d* pGV = GetGeoVector3d( pGObj) ;
switch ( cType) {
case 'B' : // base
ptP = pGV->GetBase() ;
return ptP.LocToLoc( frEnt, frPnt) ;
}
}
// 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 'T' : // punto sopra l'iniziale
if ( ! pTxt->GetOverStartPoint( ptP))
return false ;
return ptP.LocToLoc( frEnt, frPnt) ;
case 'E' : // punto finale
if ( ! pTxt->GetEndPoint( ptP))
return false ;
return ptP.LocToLoc( frEnt, frPnt) ;
case 'F' : // punto sopra il finale
if ( ! pTxt->GetOverEndPoint( 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, PolyLine& PL)
{
// divido in parti
STRVECTOR vsPoints ;
Tokenize( sParam.substr( 1, sParam.length()-2), ",", "(", ")", vsPoints) ;
// converto in punti
PL.Clear() ;
STRVECTOR::iterator Iter ;
for ( Iter = vsPoints.begin() ; Iter != vsPoints.end() ; ++Iter) {
Trim( (*Iter), " \t\r\n") ;
if ( GetIdParam( *Iter) == GDB_ID_SEL) {
int nId = m_pGDB->GetFirstSelectedObj() ;
while ( nId != GDB_ID_NULL) {
Point3d ptP ;
if ( ! GetPointParam( ToString( nId), frPnt, ptP) ||
! PL.AddUPoint( 0, ptP))
return false ;
nId = m_pGDB->GetNextSelectedObj() ;
}
}
else {
Point3d ptP ;
if ( ! GetPointParam( *Iter, frPnt, ptP) ||
! PL.AddUPoint( 0, ptP))
return false ;
}
}
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 3 parti, sono 2 coordinate e un peso
else if ( vsParams.size() == 3) {
ptP.z = 0 ;
return ( FromString( vsParams[0], ptP.x) &&
FromString( vsParams[1], ptP.y) &&
FromString( vsParams[2], 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, PolyArc& PA)
{
// divido in parti
STRVECTOR vsPointWs ;
Tokenize( sParam.substr( 1, sParam.length()-2), ",", "(", ")", vsPointWs) ;
// converto in punti
PA.Clear() ;
STRVECTOR::iterator Iter ;
for ( Iter = vsPointWs.begin() ; Iter != vsPointWs.end() ; ++Iter) {
Trim( (*Iter), " \t\r\n") ;
Point3d ptP ;
double dBulge ;
if ( ! GetPointWParam( *Iter, frPnt, ptP, dBulge) ||
! PA.AddUPoint( 0, ptP, dBulge))
return false ;
}
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' :
}
}
// altrimenti, se vettore
else if ( pGObj->GetType() == GEO_VECT3D) {
// recupero il vettore
const IGeoVector3d* pGVect = GetGeoVector3d( pGObj) ;
Vector3d vtDir = pGVect->GetVector() ;
vtDir.LocToLoc( frEnt, frDir) ;
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 ;
}
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 {
// identificativo
int nIdEnt = GetIdParam( sParam) ;
// recupero il riferimento in cui è immerso
Frame3d frEnt ;
if ( ! m_pGDB->GetGlobFrame( nIdEnt, frEnt))
return false ;
// se gruppo
if ( m_pGDB->GetGroupFrame( nIdEnt, frF)) {
return frF.LocToLoc( frEnt, frRef) ;
}
// altrimenti entità geometrica
else {
// verifico se riferimento
const IGeoFrame3d* pFr ;
if ( ( pFr = GetGeoFrame3d( m_pGDB->GetGeoObj( nIdEnt))) == nullptr)
return false ;
frF = pFr->GetFrame() ;
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 ;
}
// se altrimenti colore notevole
else if ( sParam[0] == 'C') {
// 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 un parametro
if ( vsParams.size() != 1)
return false ;
// recupero il colore dell'entità indicata dal parametro
bByParent = false ;
return m_pGDB->GetCalcMaterial( GetIdParam( vsParams[0]), cCol) ;
}
// 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::GetMaterialParam( const string& sParam, bool& bByParent, int& nMat)
{
// se materiale notevole
if ( sParam.size() > 2 && sParam[0] == 'M' && sParam[1] == '(') {
// 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 un parametro
if ( vsParams.size() != 1)
return false ;
// recupero il materiale dell'entità indicata dal parametro
bByParent = false ;
return ( m_pGDB->GetCalcMaterial( GetIdParam( vsParams[0]), nMat) && nMat != GDB_MT_COLOR) ;
}
// altrimenti
else {
// verifico se materiale dal padre
string sTemp = sParam ;
ToUpper( sTemp) ;
ReplaceString( sTemp, " ", "") ;
if ( sTemp == "BYPARENT") {
bByParent = true ;
return true ;
}
// altrimenti indice di materiale
bByParent = false ;
nMat = m_pGDB->FindMaterial( sParam) ;
return ( nMat != GDB_MT_NULL) ;
}
}
//----------------------------------------------------------------------------
bool
GdbExecutor::GetStringParam( const string& sParam, string& sString)
{
return m_pParser->GetStringParam( sParam, sString) ;
}
//----------------------------------------------------------------------------
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") {
// 1 o 2 parametri : Id/s [, Filter]
if ( vsParams.size() != 1 && vsParams.size() != 2)
return false ;
// recupero lista Id
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// recupero eventuale filtro
int nFilter = 0 ;
if ( vsParams.size() >= 2) {
string sFilter = vsParams[1] ;
ToUpper( sFilter) ;
if ( sFilter == "GR" || sFilter == "GROUP")
nFilter = GDB_TY_GROUP ;
if ( sFilter == "V" || sFilter == "VECTOR")
nFilter = GEO_VECT3D ;
else if ( sFilter == "P" || sFilter == "POINT")
nFilter = GEO_PNT3D ;
else if ( sFilter == "FR" || sFilter == "FRAME")
nFilter = GEO_FRAME3D ;
else if ( sFilter == "CL" || sFilter == "CURVELINE")
nFilter = CRV_LINE ;
else if ( sFilter == "CA" || sFilter == "CURVEARC")
nFilter = CRV_ARC ;
else if ( sFilter == "CB" || sFilter == "CURVEBEZIER")
nFilter = CRV_BEZ ;
else if ( sFilter == "CC" || sFilter == "CURVECOMPO")
nFilter = CRV_COMPO ;
else if ( sFilter == "STM" || sFilter == "SURFTRIMESH")
nFilter = SRF_TRIMESH ;
else if ( sFilter == "ZMAP")
nFilter = VOL_ZMAP ;
else if ( sFilter == "TEXT")
nFilter = EXT_TEXT ;
}
// 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, nFilter))
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") {
return MaterialColor( vsParams) ;
}
// assegnazione materiale di oggetto
else if ( sCmd2 == "MAT" || sCmd2 == "MATERIAL") {
return MaterialMaterial( vsParams) ;
}
// impostazione colore di default
else if ( sCmd2 == "DEF" || sCmd2 == "DEFAULT") {
return MaterialDefault( vsParams) ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::MaterialColor( const STRVECTOR& vsParams)
{
// 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 ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::MaterialMaterial( const STRVECTOR& vsParams)
{
// 2 parametri : Id, Materiale
if ( vsParams.size() != 2)
return false ;
// recupero lista Id
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// recupero il materiale
bool bByParent ;
int nMat ;
if ( ! GetMaterialParam( vsParams[1], bByParent, nMat))
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, nMat))
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::MaterialDefault( const STRVECTOR& vsParams)
{
// 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) ;
}
//----------------------------------------------------------------------------
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 ;
// recupero il nome
string sName ;
if ( ! GetStringParam( vsParams[1], sName))
return false ;
// eseguo assegnazione nome
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
if ( ! m_pGDB->SetName( *Iter, sName))
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 ;
// recupero Key
string sKey ;
if ( ! GetStringParam( vsParams[1], sKey))
return false ;
// recupero Info
string sInfo ;
if ( ! GetStringParam( vsParams[2], sInfo))
return false ;
// eseguo assegnazione Info di data Key
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
if ( ! m_pGDB->SetInfo( *Iter, sKey, sInfo))
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 ;
// recupero Key
string sKey ;
if ( ! GetStringParam( vsParams[1], sKey))
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, sKey))
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 variabile 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::ExecuteCurveModify( const string& sCmd2, const STRVECTOR& vsParams)
{
if ( sCmd2 == "INV" || sCmd2 == "INVERT")
return CurveModifyInvert( vsParams) ;
else if ( sCmd2 == "SP" || sCmd2 == "STARTPOINT")
return CurveModifyStartPoint( vsParams) ;
else if ( sCmd2 == "EP" || sCmd2 == "ENDPOINT")
return CurveModifyEndPoint( vsParams) ;
else if ( sCmd2 == "EXTR" || sCmd2 == "EXTRUSION")
return CurveModifyExtrusion( vsParams) ;
else if ( sCmd2 == "TH" || sCmd2 == "THICKNESS")
return CurveModifyThickness( vsParams) ;
if ( sCmd2 == "TRSL" || sCmd2 == "TRIMSTARTLEN")
return CurveModifyTrim( vsParams, SL) ;
else if ( sCmd2 == "TREL" || sCmd2 == "TRIMENDLEN")
return CurveModifyTrim( vsParams, EL) ;
else if ( sCmd2 == "TRSP" || sCmd2 == "TRIMSTARTPAR")
return CurveModifyTrim( vsParams, SP) ;
else if ( sCmd2 == "TREP" || sCmd2 == "TRIMENDPAR")
return CurveModifyTrim( vsParams, EP) ;
else if ( sCmd2 == "TRSEP" || sCmd2 == "TRIMSTARTENDPAR")
return CurveModifyTrim( vsParams, SEP) ;
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveModifyInvert( const STRVECTOR& vsParams)
{
// 1 parametro : Id/s
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::CurveModifyStartPoint( const STRVECTOR& vsParams)
{
// 2 parametri : Id, PtNewStart
if ( vsParams.size() != 2)
return false ;
// recupero la curva sorgente
int nIdCrv = GetIdParam( vsParams[0]) ;
ICurve* pCrv = GetCurve( m_pGDB->GetGeoObj( nIdCrv)) ;
if ( pCrv == nullptr)
return false ;
// recupero il suo riferimento
Frame3d frCrv ;
if ( ! m_pGDB->GetGlobFrame( nIdCrv, frCrv))
return false ;
// recupero il nuovo punto di inizio
Point3d ptNewStart ;
if ( ! GetPointParam( vsParams[1], frCrv, ptNewStart))
return false ;
// eseguo la modifica
return pCrv->ModifyStart( ptNewStart) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveModifyEndPoint( const STRVECTOR& vsParams)
{
// 2 parametri : Id, PtNewEnd
if ( vsParams.size() != 2)
return false ;
// recupero la curva sorgente
int nIdCrv = GetIdParam( vsParams[0]) ;
ICurve* pCrv = GetCurve( m_pGDB->GetGeoObj( nIdCrv)) ;
if ( pCrv == nullptr)
return false ;
// recupero il suo riferimento
Frame3d frCrv ;
if ( ! m_pGDB->GetGlobFrame( nIdCrv, frCrv))
return false ;
// recupero il nuovo punto di fine
Point3d ptNewEnd ;
if ( ! GetPointParam( vsParams[1], frCrv, ptNewEnd))
return false ;
// eseguo la modifica
return pCrv->ModifyEnd( ptNewEnd) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveModifyExtrusion( const STRVECTOR& vsParams)
{
// 2 parametri : Id, vtExtrusion
if ( vsParams.size() != 2)
return false ;
// recupero la curva sorgente
int nIdCrv = GetIdParam( vsParams[0]) ;
ICurve* pCrv = GetCurve( m_pGDB->GetGeoObj( nIdCrv)) ;
if ( pCrv == nullptr)
return false ;
// recupero il suo riferimento
Frame3d frCrv ;
if ( ! m_pGDB->GetGlobFrame( nIdCrv, frCrv))
return false ;
// recupero il vettore di estrusione
Vector3d vtExtr ;
if ( ! GetVectorParam( vsParams[1], frCrv, vtExtr))
return false ;
// eseguo la modifica
return pCrv->SetExtrusion( vtExtr) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveModifyThickness( const STRVECTOR& vsParams)
{
// 2 parametri : Id, dThick
if ( vsParams.size() != 2)
return false ;
// recupero la curva sorgente
int nIdCrv = GetIdParam( vsParams[0]) ;
ICurve* pCrv = GetCurve( m_pGDB->GetGeoObj( nIdCrv)) ;
if ( pCrv == nullptr)
return false ;
// recupero lo spessore
double dThick ;
if ( ! GetLengthParam( vsParams[1], dThick))
return false ;
// eseguo la modifica
return pCrv->SetThickness( dThick) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveModifyTrim( const STRVECTOR& vsParams, int nTrimType)
{
// almeno 2 parametri : Nome, parametro [, secondo 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 ;
// esecuzione trim
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
ICurve* pCurve ;
if ( ( pCurve = GetCurve( m_pGDB->GetGeoObj( *Iter))) != nullptr) {
switch ( nTrimType) {
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 ;
case SEP :
// ci deve essere un terzo parametro
double dPar2 ;
if ( vsParams.size() < 3 || ! FromString( vsParams[2], dPar2))
return false ;
if ( ! pCurve->TrimStartEndAtParam( dPar, dPar2))
return false ;
break ;
}
}
else
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteCurveCopy( const string& sCmd2, const STRVECTOR& vsParams)
{
if ( sCmd2 == "PR" || sCmd2 == "PARAMRANGE")
return CurveCopyByParamRange( vsParams) ;
else if ( sCmd2 == "SPC" || sCmd2 == "SPLITCLASS")
return CurveCopyBySplitClass( vsParams) ;
else if ( sCmd2 == "CHAIN")
return CurveCopyByChain( vsParams) ;
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveCopyByParamRange( const STRVECTOR& vsParams)
{
// 5 parametri : IdCrv, IdDest, IdGroupDest, StartPar, EndPar
if ( vsParams.size() != 5)
return false ;
// recupero la curva sorgente
int nIdCrv = GetIdParam( vsParams[0]) ;
const ICurve* pCrv = GetCurve( m_pGDB->GetGeoObj( nIdCrv)) ;
if ( pCrv == nullptr)
return false ;
// recupero il suo riferimento
Frame3d frCrv ;
if ( ! m_pGDB->GetGlobFrame( nIdCrv, frCrv))
return false ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[2]), frDest))
return false ;
// recupero i parametri del range
double dUStart, dUEnd ;
if ( ! FromString( vsParams[3], dUStart) ||
! FromString( vsParams[4], dUEnd))
return false ;
// copio la parte di curva che interessa e la porto nel riferimento del gruppo destinazione
PtrOwner<ICurve> pCopy( pCrv->CopyParamRange( dUStart, dUEnd)) ;
if ( IsNull( pCopy))
return false ;
pCopy->LocToLoc( frCrv, frDest) ;
// la inserisco nel gruppo
return AddGeoObj( vsParams[1], vsParams[2], ::Release( pCopy)) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveCopyBySplitClass( const STRVECTOR& vsParams)
{
// 6 parametri : IdCurve, IdClosedCurve, IdGroupIn, IdGroupOut, IdGroupOnP, IdGroupOnM
if ( vsParams.size() != 6)
return false ;
// recupero l'indice delle due curve
int nIdCrv = GetIdParam( vsParams[0]) ;
int nIdCloCrv = GetIdParam( vsParams[1]) ;
// verifico siano due curve
const ICurve* pCrv = GetCurve( m_pGDB->GetGeoObj( nIdCrv)) ;
if ( pCrv == nullptr)
return false ;
const ICurve* pCloCrv = GetCurve( m_pGDB->GetGeoObj( nIdCloCrv)) ;
if ( pCloCrv == nullptr)
return false ;
// verifico che la seconda sia chiusa
if ( ! pCloCrv->IsClosed())
return false ;
// recupero i riferimenti in cui sono immerse
Frame3d frCrv ;
if ( ! m_pGDB->GetGlobFrame( nIdCrv, frCrv))
return false ;
Frame3d frCloCrv ;
if ( ! m_pGDB->GetGlobFrame( nIdCloCrv, frCloCrv))
return false ;
// se i riferimenti sono diversi, porto la seconda curva nel riferimento della prima
PtrOwner<ICurve> crvTrans ;
if ( ! AreSameFrame( frCrv, frCloCrv)) {
crvTrans.Set( pCloCrv->Clone()) ;
if ( IsNull( crvTrans))
return false ;
crvTrans->LocToLoc( frCloCrv, frCrv) ;
pCloCrv = ::Get( crvTrans) ;
}
// calcolo le intersezioni tra le due curve
IntersCurveCurve intCC( *pCrv, *pCloCrv, true) ;
// recupero la classificazione della prima curva
CRVCVECTOR ccClass ;
if ( ! intCC.GetCurveClassification( 0, ccClass))
return false ;
// recupero gli indici dei gruppi destinazione e i loro riferimenti
const int N_GRP = 4 ;
int nIdGrp[N_GRP] ; // 0->IN, 1->OUT, 2->ON_P, 3->ON_M
Frame3d frGrp[N_GRP] ;
for ( int j = 0 ; j < N_GRP ; ++ j) {
nIdGrp[j] = GetIdParam( vsParams[j+2]) ;
if ( nIdGrp[j] >= GDB_ID_ROOT && ! m_pGDB->GetGroupGlobFrame( nIdGrp[j], frGrp[j]))
return false ;
}
// copio gli split nei diversi gruppi
for ( int i = 0 ; i < int( ccClass.size()) ; ++ i) {
// recupero indice di gruppo
int nGrp ;
switch ( ccClass[i].nClass) {
case CRVC_IN : nGrp = 0 ; break ;
case CRVC_OUT : nGrp = 1 ; break ;
case CRVC_ON_P : nGrp = 2 ; break ;
case CRVC_ON_M : nGrp = 3 ; break ;
default : return false ;
}
// se gruppo non richiesto, vado oltre
if ( nIdGrp[nGrp] < GDB_ID_ROOT)
continue ;
// se curva praticamente nulla, vado oltre
if ( fabs( ccClass[i].dParE - ccClass[i].dParS) < 10 * EPS_PARAM)
continue ;
// copio la parte di curva che interessa e la porto nel riferimento del gruppo
PtrOwner<ICurve> pSplit( pCrv->CopyParamRange( ccClass[i].dParS, ccClass[i].dParE)) ;
if ( IsNull( pSplit))
continue ;
pSplit->LocToLoc( frCrv, frGrp[nGrp]) ;
// la inserisco nel gruppo
if ( m_pGDB->AddGeoObj( GDB_ID_NULL, nIdGrp[nGrp], ::Release( pSplit)) == GDB_ID_NULL)
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::CurveCopyByChain( const STRVECTOR& vsParams)
{
// 3, 4 o 5 parametri : IdCurve/s, IdGroupDest, ptNearStart [, bAllowInvert [, dToler]]
if ( vsParams.size() < 3)
return false ;
// recupero lista Id
INTVECTOR vnNames ;
if ( ! GetNamesParam( vsParams[0], vnNames))
return false ;
// recupero il gruppo destinazione e il suo riferimento
int nIdDest = GetIdParam( vsParams[1]) ;
Frame3d frDest ;
if ( ! m_pGDB->GetGroupGlobFrame( nIdDest, frDest))
return false ;
// recupero il punto vicino alla partenza
Point3d ptNearStart ;
if ( ! GetPointParam( vsParams[2], frDest, ptNearStart))
return false ;
// recupero eventuale flag per consentire inversione di curve
bool bAllowInvert = true ;
if ( vsParams.size() >= 4 && ! FromString( vsParams[3], bAllowInvert))
return false ;
// recupero eventuale tolleranza
double dToler = EPS_SMALL ;
if ( vsParams.size() >= 5 && ! FromString( vsParams[4], dToler))
return false ;
// preparo i dati per il concatenamento
ChainCurves chainC ;
chainC.Init( bAllowInvert, dToler, int( vnNames.size())) ;
INTVECTOR::iterator Iter ;
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
// recupero la curva e il suo riferimento
ICurve* pCrv = GetCurve( m_pGDB->GetGeoObj( *Iter)) ;
if ( pCrv == nullptr)
return false ;
Frame3d frCrv ;
if ( ! m_pGDB->GetGlobFrame( *Iter, frCrv))
return false ;
// recupero i dati della curva necessari al concatenamento e li assegno
Point3d ptStart, ptEnd ;
Vector3d vtStart, vtEnd ;
if ( ! pCrv->GetStartPoint( ptStart) || ! pCrv->GetStartDir( vtStart) ||
! pCrv->GetEndPoint( ptEnd) || ! pCrv->GetEndDir( vtEnd))
return false ;
ptStart.LocToLoc( frCrv, frDest) ;
vtStart.LocToLoc( frCrv, frDest) ;
ptEnd.LocToLoc( frCrv, frDest) ;
vtEnd.LocToLoc( frCrv, frDest) ;
if ( ! chainC.AddCurve( *Iter, ptStart, vtStart, ptEnd, vtEnd))
return false ;
}
// recupero i percorsi concatenati
INTVECTOR vIds ;
while ( chainC.GetChainFromNear( ptNearStart, vIds)) {
// creo una curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return false ;
// recupero le curve semplici e le inserisco nella curva composita
INTVECTOR::iterator Iter ;
for ( Iter = vIds.begin() ; Iter != vIds.end() ; ++Iter) {
int nId = abs( *Iter) ;
bool bInvert = ( *Iter < 0) ;
// recupero la curva e il suo riferimento
ICurve* pCrv = GetCurve( m_pGDB->GetGeoObj( nId)) ;
if ( pCrv == nullptr)
return false ;
Frame3d frCrv ;
if ( ! m_pGDB->GetGlobFrame( nId, frCrv))
return false ;
// copio la curva
PtrOwner<ICurve> pCopCrv( pCrv->Clone()) ;
if ( IsNull( pCopCrv))
return false ;
// se necessario, la inverto
if ( bInvert)
pCopCrv->Invert() ;
// la sistemo per i riferimenti
pCopCrv->LocToLoc( frCrv, frDest) ;
// la aggiungo alla curva composta
if ( ! pCrvCompo->AddCurve( ::Release( pCopCrv), true, dToler))
return false ;
}
// aggiorno il nuovo punto vicino
if ( pCrvCompo->GetCurveNumber() > 0)
pCrvCompo->GetEndPoint( ptNearStart) ;
// inserisco la curva composita nel gruppo destinazione
if ( pCrvCompo->GetCurveNumber() > 0) {
if ( m_pGDB->AddGeoObj( GDB_ID_NULL, nIdDest, ::Release( pCrvCompo)) == GDB_ID_NULL)
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteSurfModify( const string& sCmd2, const STRVECTOR& vsParams)
{
if ( sCmd2 == "INV" || sCmd2 == "INVERT")
return SurfModifyInvert( vsParams) ;
return false ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::SurfModifyInvert( 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::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
int nFlag = GDB_SV_CMPTXT ;
if ( vsParams.size() == 2) {
string sFlag = vsParams[1] ;
ToUpper( sFlag) ;
if ( sFlag == "T" || sFlag == "TEXT")
nFlag = GDB_SV_TXT ;
else if ( sFlag == "B" || sFlag == "BINARY")
nFlag = GDB_SV_BIN ;
}
// esecuzione salvataggio
return m_pGDB->Save( sFile, nFlag) ;
}
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteOutTextIcci( const string& sCmd2, const STRVECTOR& vsParams)
{
// devono essere 6 parametri : IdText, IdGroup, IdEnt1, IdEnt2, ptText, hText
if ( vsParams.size() != 6)
return false ;
// recupero l'indice delle entità
int nIdEnt1 = GetIdParam( vsParams[2]) ;
int nIdEnt2 = GetIdParam( vsParams[3]) ;
// verifico siano due curve
const ICurve* pCrv1 = GetCurve( m_pGDB->GetGeoObj( nIdEnt1)) ;
if ( pCrv1 == nullptr)
return false ;
const ICurve* pCrv2 = GetCurve( m_pGDB->GetGeoObj( nIdEnt2)) ;
if ( pCrv2 == nullptr)
return false ;
// recupero i riferimenti in cui sono immerse
Frame3d frEnt1 ;
if ( ! m_pGDB->GetGlobFrame( nIdEnt1, frEnt1))
return false ;
Frame3d frEnt2 ;
if ( ! m_pGDB->GetGlobFrame( nIdEnt2, frEnt2))
return false ;
// se i riferimenti sono diversi, porto la seconda entità nel riferimento della prima
PtrOwner<ICurve> crvTrans ;
if ( ! AreSameFrame( frEnt1, frEnt2)) {
crvTrans.Set( pCrv2->Clone()) ;
if ( IsNull( crvTrans))
return false ;
crvTrans->LocToLoc( frEnt2, frEnt1) ;
pCrv2 = ::Get( crvTrans) ;
}
// calcolo le intersezioni tra le due curve
IntersCurveCurve intCC( *pCrv1, *pCrv2, true) ;
// preparo il testo con i risultati
string sText = "Inters CrvA=" + ToString( nIdEnt1) + " CrvB=" + ToString( nIdEnt2) ;
sText += "<br/>Nbr=" + ToString( intCC.GetNumInters()) ;
if ( intCC.GetOverlaps())
sText += " Overlaps" ;
for ( int i = 0 ; i < intCC.GetNumInters() ; ++ i) {
IntCrvCrvInfo aInfo ;
intCC.GetIntCrvCrvInfo( i, aInfo) ;
int nMax = ( aInfo.bOverlap ? 2 : 1) ;
for ( int j = 0 ; j < nMax ; ++ j) {
if ( j == 0)
sText += "<br/>" + ToString( i + 1) + "A" ;
else
sText += "<br/> " ;
sText += " U=" + ToString( aInfo.IciA[j].dU,7) + " P=(" + ToString( aInfo.IciA[j].ptI,4) + ")" ;
switch( aInfo.IciA[j].nPrevTy) {
case ICCT_NULL : sText += " ??-" ; break ;
case ICCT_IN : sText += " IN-" ; break ;
case ICCT_OUT : sText += " OUT-" ; break ;
case ICCT_ON : sText += " ON-" ; break ;
}
switch( aInfo.IciA[j].nNextTy) {
case ICCT_NULL : sText += "??" ; break ;
case ICCT_IN : sText += "IN" ; break ;
case ICCT_OUT : sText += "OUT" ; break ;
case ICCT_ON : sText += "ON" ; break ;
}
}
for ( int j = 0 ; j < nMax ; ++ j) {
if ( j == 0)
sText += "<br/>" + ToString( i + 1) + "B" ;
else
sText += string( "<br/>") + ( aInfo.bCBOverEq ? " + " : " - ") ;
sText += " U=" + ToString( aInfo.IciB[j].dU,7) + " P=(" + ToString( aInfo.IciB[j].ptI,4) + ")" ;
switch( aInfo.IciB[j].nPrevTy) {
case ICCT_NULL : sText += " ??-" ; break ;
case ICCT_IN : sText += " IN-" ; break ;
case ICCT_OUT : sText += " OUT-" ; break ;
case ICCT_ON : sText += " ON-" ; break ;
}
switch( aInfo.IciB[j].nNextTy) {
case ICCT_NULL : sText += "??" ; break ;
case ICCT_IN : sText += "IN" ; break ;
case ICCT_OUT : sText += "OUT" ; break ;
case ICCT_ON : sText += "ON" ; break ;
}
}
}
// recupero il riferimento in cui è immerso il testo
Frame3d frText ;
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frText))
return false ;
// recupero il punto di inserimento
Point3d ptText ;
if ( ! GetPointParam( vsParams[4], frText, ptText))
return false ;
// recupero l'altezza del carattere
double dH ;
if ( ! FromString( vsParams[5], dH))
return false ;
// creo il testo
PtrOwner<IExtText> pTXT( CreateExtText()) ;
if ( IsNull( pTXT))
return false ;
// lo riempio
if ( ! pTXT->Set( ptText, 0, sText, dH))
return false ;
// inserisco il testo nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pTXT)) ;
}
//----------------------------------------------------------------------------
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 ;
// eventuale conversione di token nel nome file
string sFile = vsParams[0] ;
m_pParser->DirReplace( sFile) ;
// apro il file e scrivo intestazione
return m_OutTsc.Open( sFile) ;
}
// 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