GPMG_Project.h

Go to the documentation of this file.

#ifndef GPMG_Project_H
#define GPMG_Project_H

#include "UI_Object.h"
#include "UI_Class.h"

#include "CORE_Out.h"

#include "GPM_ModelGraph.h"
#include "GPM_ModelFunction.h"
#include "GPM_ModelClassFactory.h"

class GPMG_MovieGraphWindow;

DEFINE_SPTR( GPMG_Project);
class GPMG_Project : public UI_Object {
    SP_OBJECT(GPMG_Project);

    // ATTRIBUTES
public:
    static const tFlag NODE_ENVIRONMENT;
    static const tFlag EDGE_ENVIRONMENT;
    static const tFlag PORT_ENVIRONMENT;
    static const tFlag GLOBAL_ENVIRONMENT;
    static const tFlag N_ENVIRONMENTS;

    static const tFlag PATTERN_GRAPH;
    static const tFlag TRANSFORMER_GRAPH;
    static const tFlag PT_CONNECTION;
    static const tFlag INIT_GRAPH;
    static const tFlag RESULT_GRAPH;
    static const tFlag UNKNOWN_GRAPH;

    static const tFlag EXPR;
    static const tFlag EXPRTK;
    
    
private:
   //default environment
    map<tString,SP::GPM_Variable> mEnvironments[4];
    SV::GPM_CompositorFunction mFunctions;
    
    tFlag mExpressionType;
    
    int mRulesNumber;
    int mIterationsNumber;

    vector<tString> mResultGraphFiles;

    // min &max points for the graph
    tReal mMinPoint[3],mMaxPoint[3];
    // min & max values for variables
    // variable Name{"@Node",@PORT","@EDGE} --> {minValue,maxValue}
    map<tString,tReal*> mBoundsValue;
    int mIterations;


    
    // ASSOCIATIONS
  
    // graphs load from graph files
    SP::GPM_ModelGraph mInitGraph;

    // rules load from rules files
    SV::GPM_ModelFunction mRules;

    // gpm class fatory
    SP::GPM_ModelClassFactory mClassFactory;
    
    
  
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    GPMG_Project(void);
    
  
  
    // DESTRUCTORS 
  
  
    virtual ~GPMG_Project(void);
  
  
public:

    // NEW
    inline static SP::GPMG_Project New() {
        SP::GPMG_Project p(new GPMG_Project,GPMG_Project::Delete());
        p->setThis(p);
        return p;
    }
    
    // SET methods 
public:
 
    tBoolean loadData(const tString& projectFile);
    tBoolean saveData(const tString& projectFile);


    // Environments
    
    inline void setClassFactory(SP::GPM_ModelClassFactory cf) {
        mClassFactory=cf;
    }
    inline const GPM_ModelClassFactory&  getClassFactory() const {
        return *mClassFactory.get();
    }

    //void setExpressionType(const tFlag& expr);
    
     
    void clearEnvironment(const tFlag& index);
    
    inline void addToEnvironment(const tFlag& index,
                                  const tString& name,
                                  const tFlag type,
                                  const int& card,
                                  const double *value) {
        SP::GPM_Variable var=GPM_Variable::New();
        var->setValue(card,value,type);
      
        addToEnvironment(index,name,var);
    }
    inline void addToEnvironment(const tFlag& index,
                                  const tString& name,
                                  const double &value) {
        SP::GPM_Variable var=GPM_Variable::New();
        var->setValue(value);
      
        addToEnvironment(index,name,var);
    }
    inline void addToEnvironment(const tFlag& index,
                                 const tString& name,
                                  const tString &value) {
        SP::GPM_Variable var=GPM_Variable::New();
        var->setValue(value);
       
        addToEnvironment(index,name,var);
    }
    
    inline void addToEnvironment(const tFlag& index,
                                  const tString& name,
                                  const int& n,
                                  const double *value) {
        SP::GPM_Variable var=GPM_Variable::New();
        var->setValue(n,value);
        addToEnvironment(index,name,var);
    }
    
    void addToEnvironment(const tFlag& index,
                          const tString& name,
                          SP::GPM_Variable var) ;

  
    inline void setIterationsNumber(const int& n) {
        mIterationsNumber=n;
    }
   

    void getVertexVariableNames(vector<tString>& vars) const;
    
    // GET methods
public:
    tFlag getExpressionType() {
        return mExpressionType;
    }
    
  
    inline int getIterationsNumber() const{
        return mIterationsNumber;
    }
    inline int getIterationsDone() const{
        return mIterations;
    }

    inline const tReal* getMinPoint() const {
        return mMinPoint;
    }
    inline const tReal* getMaxPoint() const {
        return mMaxPoint;
    }
    inline const map<tString,tReal*>& getBoundsValue() const {
        return mBoundsValue;
    }
    
    const map<tString,SP::GPM_Variable>& getEnvironment(const tFlag& index) const;
    
    const map<tString,SP::GPM_Variable>& getGlobalVariables() const {
        return mEnvironments[GLOBAL_ENVIRONMENT];
    }
    
public:
   
    inline GPM_ModelGraph* getInitGraph() {
        return mInitGraph.get();
    }
    inline const GPM_ModelGraph* getInitGraph() const {
        return mInitGraph.get();
    }

    inline tBoolean loadInitGraph(const tString& fn,CORE_Out& io) {
        mInitGraph=GPM_ModelGraph::New();
        tBoolean succeeds=mInitGraph->loadFromFile(fn,io);
        if (mInitGraph!=null) mInitGraph->buildEnvironments(mEnvironments[NODE_ENVIRONMENT],
                                                            mEnvironments[PORT_ENVIRONMENT],
                                                            mEnvironments[EDGE_ENVIRONMENT]);
            
        return succeeds;
    }
    inline tBoolean saveInitGraph(const tString& fn) const {
        return mInitGraph->saveToFile(fn);
    }

    void clearInitGraph();

    void generateQuadInitGraph(const int& nTriangles,const tBoolean& withMiddle,
                               const int& n,const int& m,const tReal& w,const tReal& h,const tReal& xmin,const tReal& ymin);

    inline void updateGraphsEnvironments()  {
        if (mInitGraph.get()!=null) mInitGraph->updateGraphElementsEnvironment(mEnvironments[NODE_ENVIRONMENT],
                                                                               mEnvironments[PORT_ENVIRONMENT],
                                                                               mEnvironments[EDGE_ENVIRONMENT]);
        
        int nRules=mRules.getSize();
        for (int  i=0;i<nRules;i++) {
            GPM_ModelFunction *rule=mRules.get(i);
            if (rule!=null) {
                rule->setGlobalVariables(mEnvironments[GLOBAL_ENVIRONMENT]);
                rule->setGlobalFunctions(mFunctions);
                GPM_PortGraph &pgraph=rule->getPatternGraph();
                pgraph.updateGraphElementsEnvironment(mEnvironments[NODE_ENVIRONMENT],
                                                      mEnvironments[PORT_ENVIRONMENT],
                                                      mEnvironments[EDGE_ENVIRONMENT]);
                GPM_PortGraph &tgraph=rule->getTransformerGraph();
                tgraph.updateGraphElementsEnvironment(mEnvironments[NODE_ENVIRONMENT],
                                                      mEnvironments[PORT_ENVIRONMENT],
                                                      mEnvironments[EDGE_ENVIRONMENT]);
            }
        }
    }
    
    


    const SV::GPM_ModelFunction& getRules() const {
        return mRules;
    }
    SV::GPM_ModelFunction& getRules()  {
        return mRules;
    }

    void clearRule(const int& index);

    // RUN the project
    tBoolean canBeRun() const;

    void setResultGraphFiles(const vector<tString>& files);
    
    const vector<tString>& getResultGraphFiles() const {
        return mResultGraphFiles;
    }
    
    int run(const tString& projectFile,const int& iter0,const int& iterationsNumber,CORE_Out& io,GPMG_MovieGraphWindow* visualizer,tString&errorMessage,tBoolean& succeeds);
    
    // UI Class saver & loader
    virtual void saveToUIClass(UI_Class& mclass) const;
    virtual void loadFromUIClass(const UI_Class& mclass);
private:
    
    void clearScales(); 
    void updateScales(const GPM_ModelGraph& graph);

    void saveClass(const tString& key,const GPM_Variable& var,UI_Class& mclass) const;
    
    void loadClass(const tString& key,GPM_Variable& var,const UI_Class& mclass) const;

public:
    int  getGlobalFunctionsNumber() const {
        return mFunctions.getSize();
    }
    
    inline const GPM_CompositorFunction* getGlobalFunction(const int& i) const {
        if ((i>=0) && (i<mFunctions.getSize())) return mFunctions.get(i);
        return null;
    };
    inline GPM_CompositorFunction* getGlobalFunction(const int& i) {
        if ((i>=0) && (i<mFunctions.getSize())) return mFunctions.get(i);
        return null;
    };
    
    SV::GPM_CompositorFunction& getGlobalFunctions();  
    const SV::GPM_CompositorFunction& getGlobalFunctions() const;
  
    
    void setGlobalFunctions(SV::GPM_CompositorFunction fs) ;
    
    tBoolean areCompositorFunctionsAvailabled() { 
        return (mClassFactory->newFunction().get()!=null);
    }

};
    
#endif