|| || || || || || || ||

---

LabeledGraph.h

Go to the documentation of this file.

#include "OglGui/Graph.h"

#include <string>
#include <map>
#include <vector>

#include "Tag.h"

using namespace OglGui;
using namespace std;

class LabeledGraph : public Graph {
public:
        LabeledGraph(Window* parent, int w, int h, int drawShape=0, strconst txt="") : Graph(parent, w, h, drawShape, txt) {}

        void addNodes(map<string, vector<string> > labels) {
                map<string, vector<string> >::iterator iter;
                for(iter = labels.begin(); iter != labels.end(); iter++) {
                        string label = iter->first;
                        if(nodes.count(label) == 0) addNode(label);
                        for(uint i = 0; i < iter->second.size(); i++) {
                                string related = iter->second[i];
                                if(nodes.count(related) == 0) addNode(related);
                                this->ConnectNode(nodes[label], nodes[related]);
                        }
                }
        }

    virtual void DisplayFunc()
    {
        if(!layoutDone) layoutDone = doLayout();
        Graph::DisplayFunc();
    }

    virtual void OnLayoutChange()
    {
                layoutDone = false;
        Graph::OnLayoutChange();
    }

private:
        void addNode(string label) {
                int width, height;
                this->GetDimensions(width, height);
                int x  = ABSRND(width-20);
                int y  = ABSRND(height-20);

                nodes[label] = new Graph(this,x,y,75,20,1);
                nodes[label]->ShapeBg(ARGB2COLOR(196,255,0,0));
                nodes[label]->SetBorderType(0);
                nodes[label]->SetText(label);
                nodes[label]->ActOnModifier(0);
                nodes[label]->SetAllowSizeDirections(AllDir, false);

                this->AddNode(nodes[label]);
        }

        bool doLayout() {
                return doForceDirectedLayout();
                return doRadialLayout();
        }

        bool doRadialLayout() {
                int x, y, w, h;
                mNodes[0].nodeVector[0]->GetDimensions(x, y, w, h);
                uint cx = (W()-w)/2, cy = (H()-h)/2;
                mNodes[0].nodeVector[0]->SetDimensions(cx, cy, w, h);
                uint count = mNodes[0].nodeVector.size()-1;
                float count_2_pi = count/(M_PI*2);
                float rx = 1.0-0.5*w/W(), ry = 1.0-0.5*h/H();
                for(float i=1; i <= count; i++) {
                        mNodes[0].nodeVector[i]->GetDimensions(x, y, w, h);
                        x = cx * (1 + rx*sin(i/count_2_pi));
                        y = cy * (1 + ry*cos(i/count_2_pi));
                        mNodes[0].nodeVector[i]->SetDimensions(x, y, w, h);
                }
                return true;
        }

        bool doForceDirectedLayout() {
                int x, y, w, h;
                mNodes[0].nodeVector[0]->GetDimensions(x, y, w, h);
                uint cx = (W()-w)/2, cy = (H()-h)/2;
                mNodes[0].nodeVector[0]->SetDimensions(cx, cy, w, h);

                float energy = 0;
                float alpha = 0.01;
                for(uint i = 0; i < mNodes.size(); i++) {
                        mNodes[i].nodeVector[0]->GetDimensions(x, y, w, h);

                        int nX, nY, nW, nH;
                        // Move away nodes that are too close
                        for(uint j = 0; j < mNodes.size(); j++) {
                                if(i==j) continue;
                                mNodes[j].nodeVector[0]->GetDimensions(nX, nY, nW, nH);
                                int distX = nX-x, distY = nY-y;
                                /*if(ABSRND(20) == 1) {
                                        nX = (distX > 0) ? nX + 1 : nX - 1;
                                        nY = (distY > 0) ? nY + 1 : nY - 1;
                                }*/
                                int pX = nX, pY = nY;
                                if((abs(distX) < (nW)) && (abs(distY) < (nH))) {
                                        nX += (distX > 0) ? nW: -nW;
                                        nY += (distY > 0) ? nH : -nH;
                                }
                                nX = cap(nX, 0, W()-nW);
                                nY = cap(nY, 0, H()-nH);
                                float delta = sqrt(pow(nX-pX, 2.0) + pow(nY-pY, 2.0));
                                if(delta > 0) {
                                        energy += delta;
                                        mNodes[j].nodeVector[0]->SetDimensions(nX, nY, nW, nH);
                                }
                        }
                        for(uint j = 1; j < mNodes[i].nodeVector.size(); j++){
                                mNodes[i].nodeVector[j]->GetDimensions(nX, nY, nW, nH);
                                //if(sqrt(pow(nX-x, 2) + pow(nY-y, 2)) < 2*nW) continue;
                                mNodes[i].nodeVector[0]->SetDimensions(nX*alpha+x*(1-alpha), nY*alpha+y*(1-alpha), w, h);
                                mNodes[i].nodeVector[j]->SetDimensions(x*alpha+nX*(1-alpha), y*alpha+nY*(1-alpha), nW, nH);
                        }
                }
                return(energy == 0);
        }

    float cap(float v, float min, float max) {
        if(v < min) return min;
        if(v > max) return max;
        return v;
    }

    map<string, Graph* > nodes;

    bool layoutDone;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(LabeledGraph, Impala.Application.TagsLife);

---