GPM_PortGraph.h

Go to the documentation of this file.

#ifndef GPM_PortGraph_H
#define GPM_PortGraph_H

#include "GPM_Graph.h"

#include "CORE_Out.h"

#include "GPM_Port.h"

DEFINE_SPTR(GPM_PatternFunction)
DEFINE_SVPTR(GPM_PatternFunction)

// boost include
DEFINE_SPTR(GPM_PortGraph);


class GPM_PortGraph : public GPM_Graph{
SP_OBJECT(GPM_PortGraph);  
// ATTRIBUTES

public:
    static const tFlag SEGMENT;
    static const tFlag TRIANGLE;
    static const tFlag TETRAHEDRON;
    static const tFlag PYRAMID;
    static const tFlag WEDGE;
    static const tFlag HEXAHEDRON;

  
    
private:

  
  
    tString mPath;
    tString mPrefix;
    unsigned int mIterations;
    unsigned int mIterationsMaxNumber;
    
    
    SV::GPM_PatternFunction mPatternFunctions;
    SP::GPM_PatternFunction mF;

 
    
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    GPM_PortGraph(void);
  
  
  
    // DESTRUCTORS 
  
  
    virtual ~GPM_PortGraph(void);   
  
  
public:

    // NEW methods
    
    static inline SP::GPM_PortGraph New() {
        SP::GPM_PortGraph p(new GPM_PortGraph(),GPM_PortGraph::Delete());
        p->setThis(p);
        return p;
    }
   
    //SET & GET methods
    // ----------------
    inline void setPath(const tString& path) {
        mPath=path;
    }
    inline tString getPath() const  {
        return mPath;
    }
    inline void setPrefix(const tString& v) {
        mPrefix=v;
    }
    inline tString getPrefix() const  {
        return mPrefix;
    }

protected:
    inline void setIteration(const int& v) {
        mIterations=v;
    }
public:
    inline int getIteration() const  {
        return mIterations;
    }
    inline void setIterationsMaxNumber(const int& v) {
        mIterationsMaxNumber=v;
    }
public:
    inline int getIterationsMaxNumber() const  {
        return mIterationsMaxNumber;
    }

    
    virtual SP::GPM_GraphElement newInstance(const tString& className) const;
    virtual SP::GPM_Port newPort() const {
        return GPM_Port::New();
    }
   
    
    inline tVertexIID addPort(const int& id) {
        SP::GPM_Port port=newPort();
        port->setId(id);
        return GPM_Graph::addVertex(port);
    }
   
    inline tVertexIID addPort() {
        SP::GPM_Port port=newPort();
        port->setId(generateVertexId());
        return GPM_Graph::addVertex(port);
    }
    inline tVertexIID addPort(SP::GPM_Port port) {
        return GPM_Graph::addVertex(port);
    }
    

    tBoolean addPortEdgeFromIds(const int& from,const int& to,
                                const int& fromPortId,const int& toPortId,
                                tVertexIID& fromPortIID,tVertexIID& toPortIID);
    inline tBoolean addPortEdgeFromIds(const int& fromId,const int& toId,const int& fromPortId,const int& toPortId) {
        tVertexIID fromPortIID,toPortIID;
        return addPortEdgeFromIds(fromId,toId,fromPortId,toPortId,fromPortIID,toPortIID);
    }
   

 

public:
    void updateGraphElementsEnvironment(const map<tString,SP::GPM_Variable>& nodeEnvironment,
                                        const map<tString,SP::GPM_Variable>& portEnvironment,
                                        const map<tString,SP::GPM_Variable>& edgeEnvironment);
    
    void buildEnvironments(map<tString,SP::GPM_Variable>& nodeEnvironment,
                           map<tString,SP::GPM_Variable>& portEnvironment,
                           map<tString,SP::GPM_Variable>& edgeEnvironment) const;
    
public:
    void getConnectedNodesToPort(const tVertexIID& portIID,tVertexIID& sourceNode,tVertexIID& targetNode) const;
    
    void initGroupNames(const vector<tString>& nodeIds,const vector<tString>& portIds);
    void initGroupNames() {
        vector<tString> nodeIds,portIds;
        initGroupNames(nodeIds,portIds);   
    }
    
    inline void clearPatternFunctions() {
        mPatternFunctions.clear();
    }
    inline void addPatternFunction(SP::GPM_PatternFunction f) {
        mPatternFunctions.add(f);
    }

    inline SV::GPM_PatternFunction&  getPatternFunctions() {
        return mPatternFunctions;
    }
 
    // Graph creation method
    //======================

    void generateQuadGraph(const int& nTriangles,const tBoolean& withMiddle,const int& n,const int& m,const tReal& w,const tReal& h,const tReal& xmin,const tReal& ymin);
    
    // Graph properties method
    //---------------------------
    virtual tBoolean isValid() const;
    virtual tString isEdgeValid(const GPM_Vertex& source,
                                const GPM_Vertex& target,
                                tBoolean& isValid) const;
    
    virtual tBoolean isMappingValid(const SV::GPM_Vertex& smallGraphVertices,
                                    const vector<tVertexIID>& mapping,
                                    CORE_Out& io) const;
    
    virtual tBoolean reduce(int& nReductions,CORE_Out& io);

    // primitive geometries to find
    // ---------------------------
    void findMesh(const vector<tFlag>& meshTypes,vector<vector<tVertexIID> >& geometries) const {
        for (size_t i=0;i<meshTypes.size();i++)
            findMesh(meshTypes[i],geometries);
    }
    void findMesh(const tFlag& meshType,vector<vector<tVertexIID> >& geometries) const;
    
    void findSegments(vector<vector<tVertexIID> >& geometry) const;
    

    
    // IO methods
    // -----------
public:
    virtual tBoolean exportToCurveFile(const tString& fileName,
                                       const tString& title,
                                       const tString& XLabel,
                                       const tString& YLabel) const;
     // Re-Writing
    // ---------
private:
    tBoolean rewrite(SV::GPM_PatternFunction& patternFunction,int& nReductions,CORE_Out& io);

public:
    inline tBoolean rewrite(int& nReductions,CORE_Out& io) {
        return rewrite(mPatternFunctions,nReductions,io);
    }

protected:
    virtual void patternsMappingSignalEmit(const SVC::GPM_PatternFunction patternFunction,
                                           const vector<vector<vector<tVertexIID> > >& fmappings) const{
    };
    
private:
    tBoolean makeOneReduction(tBoolean& mergingAllowed,CORE_Out& io);

    // RUNNER
    // ======
public:
    tBoolean run(CORE_Out& io);
    tBoolean run(const tString& path,const tString& prefix,const int& nMaxIterations,CORE_Out& io) {
        setPath(path);
        setPrefix(prefix);
        setIterationsMaxNumber(nMaxIterations);
        return run(io);
    }
    
public:
   
   
    
    virtual tBoolean saveGraph(const tString& path,const tString& prefix,const int& nDigits,const int& iterations,tString& fn) const;
    virtual tBoolean loadGraph(const tString& path,const tString& prefix,const int& nDigits,const int& iterations,CORE_Out& io,tString& fn);
};

#endif