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