//---------------------------------------------------------------------------- // 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 ( 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 += "
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 += "
" + ToString( i + 1) + "A" ; else sText += "
" ; 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 += "
" + ToString( i + 1) + "B" ; else sText += string( "
") + ( 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 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 ; }