graph_display.cpp

#include <tulip/PluginLoaderTxt.h>
#include <tulip/PluginLibraryLoader.h>
#include <tulip/GlMainWidget.h>
#include <tulip/MouseInteractors.h>
#include <tulip/TlpQtTools.h>
#include <tulip/LayoutProperty.h>
#include <tulip/SizeProperty.h>
#include <tulip/StringProperty.h>
#include <tulip/DoubleProperty.h>
#include <tulip/IntegerProperty.h>
#include <tulip/TulipViewSettings.h>
#include <tulip/GlGraphComposite.h>
#include <tulip/GlGraphRenderingParameters.h>
#include <tulip/ForEach.h>
#include <QApplication>
#include <QString>
#include <iostream>

#include <QEvent>
#include <QKeyEvent>

using namespace tlp;
using namespace std;

class InteractorPlugin : public MousePanNZoomNavigator {
    Graph *graph;
    GlMainWidget *mainWidget;
public:
    /*
    Basic constructor
    In this constructor we create a label to display information
    And a QGraphicsProxyWidget to show information in Tulip QGraphics system
    */
    InteractorPlugin(Graph *_g, GlMainWidget *_widget) : graph(_g), mainWidget(_widget), MousePanNZoomNavigator() 
    {

    }

    /*
    Most important function of an interactor component
    When an event arrive on your interactor : this function is call
    You have to process it and return true. If the event do nothing in your interactor : this function return false;
    */
    bool eventFilter(QObject *obj, QEvent* e) {
        bool apply_plugin = false;
        bool handled = false;

        float cluster_spacing = 0;
        graph->getAttribute("cluster_spacing", cluster_spacing);

        if (e->type() == QEvent::KeyPress) {
            QKeyEvent *ke = static_cast<QKeyEvent*>(e);
            int delta = (ke->isAutoRepeat() ? 3 : 1);

            switch (ke->key()) {
            case Qt::Key_A:
                cluster_spacing -= 0.01f;
                if (cluster_spacing < 0)
                    cluster_spacing = 0;
                apply_plugin = true;
                handled = true;
                break;
            case Qt::Key_S:
                cluster_spacing += 0.01f;
                apply_plugin = true;
                handled = true;
                break;
            }
        }

        if (apply_plugin)
        {
            graph->setAttribute("cluster_spacing", cluster_spacing);
            LayoutProperty *viewLayout = graph->getProperty<LayoutProperty>("viewLayout");
            std::string errMsg;
            graph->applyPropertyAlgorithm("SFCLayout", viewLayout, errMsg);
            cout << "SFCLayout errMsg: " << errMsg << endl;

            mainWidget->draw();
        }

        if (handled)
            return true;

        return MousePanNZoomNavigator::eventFilter(obj, e);
    }
};

void addChildren(Graph *graph, node root, int depth, int degree) {
    if (depth > 0) {
        for (int i = 0; i < degree; ++i) {
            node child = graph->addNode();
            graph->addEdge(root, child);
            addChildren(graph, child, depth - 1, degree);
        }
    }
}

Graph *createCompleteTree(int depth, int degree) {
    Graph *graph = newGraph();
    node root = graph->addNode();
    addChildren(graph, root, depth, degree);
    return graph;
}

void setVisualProperties(Graph *tree) {
    // Labels the node with their id
    StringProperty *viewLabel = tree->getProperty<StringProperty>("viewLabel");
    node n;
    forEach(n, tree->getNodes()) {
        viewLabel->setNodeValue(n, QString::number(n.id).toStdString());
    }
    // Add a border to the nodes, keep the default color who is black
    DoubleProperty *viewBorderWidth = tree->getProperty<DoubleProperty>("viewBorderWidth");
    viewBorderWidth->setAllNodeValue(1);
}

void setGraphRenderingParameters(GlGraphComposite *glGraphComposite) {
    GlGraphRenderingParameters *renderingParameters = glGraphComposite->getRenderingParametersPointer();
    // Activate the display of edge extremities (arrows by default)
    renderingParameters->setAntialiasing(true);

    renderingParameters->setDisplayNodes(true);

    renderingParameters->setLabelsDensity(100);

    renderingParameters->setViewArrow(false);
    // No color interpolation for the edges
    renderingParameters->setEdgeColorInterpolate(false);
    // Size interpolation for the edges
    renderingParameters->setEdgeSizeInterpolate(false);
    // Scale labels to node sizes
    renderingParameters->setLabelScaled(true);
}

int main(int argc, char** argv) {
    // A QApplication must always be declared at the beginning of the main function if you intend to use the tulip-gui library
    // This must be done before calling tlp::initTulipSoftware()
    QApplication app(argc, argv);

    // Initialize the library and load all plugins
tlp:PluginLoader * plugin_loader = new tlp::PluginLoaderTxt();
    tlp::initTulipSoftware(plugin_loader);
    Graph* g = NULL;

    if (QApplication::arguments().size() == 2) {
        // Load the file passed as first argument into a graph.
        // This method will select the default Tulip algorithm plugin (TLP)
        QString filename = QApplication::arguments()[1];
        if (!((filename.endsWith(".tlp")) || (filename.endsWith(".tlp.gz")))) {
            cout << "File " << filename.toStdString() << " not compatible. Use a tlp file or a tlp.gz file" << endl;
            exit(EXIT_FAILURE);
        }
        g = tlp::loadGraph(filename.toStdString());
    }
    else {
        // If no arguments were given to the command, create a complete tree of depth 5
        // and degree 6 for demo purpose
        g = createCompleteTree(5, 6);
        // Set some visual properties in order to visualize the tree
        //setTreeVisualProperties(g);
    }

    float cluster_spacing = 2;
    g->setAttribute("cluster_spacing", cluster_spacing);

    LayoutProperty *viewLayout = g->getProperty<LayoutProperty>("viewLayout");
    std::string errMsg;
    g->applyPropertyAlgorithm("SFCLayout", viewLayout, errMsg);
    cout << "SFCLayout errMsg: " << errMsg << endl;

    // Creates the main widget that will display our graph
    GlMainWidget* mainWidget = new GlMainWidget(NULL);
    // Adds a layer to the scene
    GlLayer* mainLayer = mainWidget->getScene()->createLayer("Main");

    // Adds the graph to this layer
    //mainLayer->addGraph(g,"graph");
    Graph * sg = g->getSubGraph("original");
    //Graph * sg = g->getSubGraph("clustering");
    setVisualProperties(sg);
    mainLayer->addGraph(sg, "graph");

    // Sets some rendering parameters on the graph to visualize
    setGraphRenderingParameters(mainWidget->getScene()->getGlGraphComposite());
    // Display the widget
    mainWidget->show();
    // Flush event loop in order to let paint events pass through in order for the scene to be initialized.
    QApplication::processEvents();
    // Center the camera and draw the graph
    mainWidget->centerScene();
    mainWidget->draw();
    // Adds Zoom and pan navigation to the widget
    mainWidget->installEventFilter(new MouseNKeysNavigator);
    //InteractorComposite * interactorPlugin = tlp::PluginLister::instance()->getPluginObject<InteractorComposite>("InteractorPlugin", 0);
    InteractorPlugin interactorPlugin(g, mainWidget);
    //InteractorPluginComponent interactorPlugin;
    //interactorPlugin.install(mainWidget);
    mainWidget->installEventFilter(&interactorPlugin);
    //mainWidget->setCurrentInteractor(interactorPlugin);
    return app.exec();
}