NodeGraphManager.h

Go to the documentation of this file.

#ifndef NODE_GRAPH_MANAGER_H
#define NODE_GRAPH_MANAGER_H

#include <map>
#include <set>
#include <vector>

class Application;
class GraphNode;
class UIManager;
class Arrow;
class RegexPhraseMatcher;

namespace CEGUI
{
    class Window;
    class Colour;
}

typedef std::map<std::string, GraphNode*> WordGraphMap;
typedef std::set<std::string> StopWordSet;


class GraphNodeListEntry
{
public:
    GraphNodeListEntry();
    GraphNodeListEntry(const GraphNodeListEntry& other);
    bool operator< (const GraphNodeListEntry& compareNode);

    GraphNode*          m_graphNode;
    CEGUI::Window*      m_graphNodeWindow;

    float               m_highestNeighbourWeight;
};

struct float2
{
    float2()
        : x(0.f)
        , y(0.f)
    {
    }

    float x;
    float y;
};

struct GraphNodePair
{
    bool operator< (const GraphNodePair& otherPair) const;

    const GraphNodeListEntry*    m_graphNodeFirst;
    const GraphNodeListEntry*    m_graphNodeSecond;

    int                          m_firstToSecondConnections;
    int                          m_secondToFirstConnections;
};


typedef std::vector<GraphNodeListEntry> GraphNodeList;
typedef std::set<const GraphNodeListEntry*> GraphNodeSet;
typedef std::map<const GraphNode*, const GraphNodeListEntry*> GraphNodeListEntryMap;
 /* NodeGraphManager takes care of the creation of nodes during the processing of the documents. Documents are received from application as strings and nodes are built from them using the RegexPhraseMatcher class to split them into word connections. 
 RegexPhraseMatcher offers the functionality for matching of regular expessions and is owned by this class. Furthermore NodeGraphmanager positions the nodes without overlap using several class methods. */
class NodeGraphManager
{
public:
    NodeGraphManager(Application* application);
    ~NodeGraphManager();

    static void addNodeConnection(GraphNode* first, GraphNode* second);

    void createNewNodeGraphStructure();

    void retrieveMostFrequentNodeConnections(GraphNodeList &graphNodeList);

    void addHighestNeighbourEdgeWeights(GraphNodeList &graphNodeList);

    void createGraphWindows(GraphNodeList& mostFrequentGraphNodes, GraphNodeSet& graphNodeSet, UIManager* uiManager);



    void positionGraphNodes(GraphNodeList &graphNodes, const GraphNodeSet& graphNodeSet, const GraphNodeListEntryMap& graphNodeListEntryMap);

    void positionRelatedWindows(const GraphNodeListEntry* curListEntry, const GraphNodeListEntryMap& graphNodeListEntryMap, std::set<CEGUI::Window*>& positionedWindows, const GraphNodeSet& graphNodeSet, std::set<const CEGUI::Window*>& connectedWindows);

    void positionSubsequentWindows(const GraphNodeListEntry* curListEntry, const GraphNodeListEntryMap &graphNodeListEntryMap, std::set<CEGUI::Window*> &positionedWindows,
        const GraphNodeSet &graphNodeSet, float2 windowCenter, std::set<const CEGUI::Window*>& connectedWindows);
    void positionPreviousWindows(const GraphNodeListEntry* curListEntry, const GraphNodeListEntryMap &graphNodeListEntryMap, std::set<CEGUI::Window*> &positionedWindows,
        const GraphNodeSet &graphNodeSet, float2 windowCenter, std::set<const CEGUI::Window*>& connectedWindows);

    void findAndSetFreePosition(std::set<CEGUI::Window*> &positionedWindows, CEGUI::Window* currentWindow, std::set<const CEGUI::Window*>& connectedWindows,
        bool isInitialWindow, float2 startPos = float2(), CEGUI::Window* placeAroundWindow = 0);

    void createGraphNodeSetFromList(const GraphNodeList &mostFrequentGraphNodes, GraphNodeSet& graphNodeSet);

    void setMaxReturnedNodes(int maxReturnedNodes);
    int getMaxReturnedNodes() const;

    void createGraphNodeConnectionPairs(const GraphNodeList &mostFrequentGraphNodes, const GraphNodeListEntryMap& graphNodeListEntryMap, std::set<GraphNodePair>& graphNodePairs);
    void fillGraphNodeListEntryMap(const GraphNodeList &graphNodeListEntries, GraphNodeListEntryMap& graphNodeListEntryMap);

    void createNodeGraphArrows(const std::set<GraphNodePair>& graphNodePairs, std::vector<Arrow>& arrows);
    void setIsUsingStopWords(bool isUsingStopWords);

    GraphNode* getGraphNodeByWord(const std::string& word);

private:
    void destroyWordGraph();



    void retrieveWeightedGraphNodes(GraphNodeList& graphNodeList);
    void addWeightedGraphnodeToList(GraphNode* node, GraphNodeList& graphNodeList);

    void initStopWords();
    void addStopWord(const std::string& stopWord);
    bool isStopWord(const std::string& stopWord);

    void normaliseGraphNodeListIndicators(GraphNodeList &sortedGraphNodeList);
    bool areNodeWindowsOverlapping(const CEGUI::Window* window, const CEGUI::Window* otherWindow, const std::set<const CEGUI::Window*>& connectedWindows, bool windowIsInitialOne) const;
    bool areNodeWindowsOverlapping(const CEGUI::Window* window, const std::set<CEGUI::Window*>& otherWindows, const std::set<const CEGUI::Window*>& connectedWindows, bool windowIsInitialOne) const;

    float calculateOutgoingToTotalConnRatio(const GraphNodeListEntry& currentNode);

    void removeLowestTopNodesWithoutConnections(GraphNodeList &graphNodeList);

    float2 getRandomVector();

    Application*    m_application;
    WordGraphMap    m_wordToGraphNodeMap;

    unsigned int    m_maxReturnedNodes;

    StopWordSet     m_stopWords;

    float           m_randomPosMarginX;
    float           m_randomPosMarginY;

    bool            m_usingStopWords;

    RegexPhraseMatcher*     m_regexPhraseMatcher;
};

#endif