source: orange/source/orangeqt/networkcurve.h @ 10924:b5b1c0b30806

Revision 10924:b5b1c0b30806, 7.3 KB checked in by mstajdohar, 22 months ago (diff)

Try FR with animation.

Line 
1/*
2    This file is part of the plot module for Orange
3    Copyright (C) 2011  Miha Čančula <miha@noughmad.eu>
4
5    This program is free software: you can redistribute it and/or modify
6    it under the terms of the GNU General Public License as published by
7    the Free Software Foundation, either version 3 of the License, or
8    (at your option) any later version.
9
10    This program is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13    GNU General Public License for more details.
14
15    You should have received a copy of the GNU General Public License
16    along with this program.  If not, see <http://www.gnu.org/licenses/>.
17*/
18
19#ifndef NETWORKCURVE_H
20#define NETWORKCURVE_H
21
22#include "curve.h"
23#include "point.h"
24#include "plot.h"
25#include <deque>
26#include <algorithm>
27
28class QueueVertex
29{
30public:
31    int ndx;
32    int position;
33    unsigned int unplacedNeighbours;
34    unsigned int placedNeighbours;
35    std::vector<int> neighbours;
36
37    bool hasNeighbour(int index)
38    {
39        std::vector<int>::iterator iter;
40
41        for (iter = neighbours.begin(); iter != neighbours.end(); iter++)
42            if (*iter == index)
43                return true;
44
45        return false;
46    }
47
48    friend std::ostream & operator<<(std::ostream &os, const QueueVertex &v)
49    {
50        os << "ndx: " << v.ndx << " unplaced: " << v.unplacedNeighbours << " placed: " << v.placedNeighbours << " neighbours: ";
51        int i;
52        for (i = 0; i < v.neighbours.size(); i++)
53            os << v.neighbours[i] << " ";
54
55        return (os);
56    }
57
58    QueueVertex(int index = -1, unsigned int neighbours = 0)
59    {
60        ndx = index;
61        unplacedNeighbours = neighbours;
62        placedNeighbours = 0;
63    }
64
65    bool operator () (const QueueVertex * a, const QueueVertex * b)
66    {
67        if (a->unplacedNeighbours < b->unplacedNeighbours)
68            return false;
69        else if (a->unplacedNeighbours > b->unplacedNeighbours)
70            return true;
71        else
72        {
73            return a->placedNeighbours < b->placedNeighbours;
74        }
75    }
76};
77
78class EdgeItem;
79
80class NodeItem : public Point
81{
82public:
83    enum {Type = Point::Type + 1};
84    NodeItem(int index, int symbol, QColor color, int size, QGraphicsItem* parent = 0);
85    virtual ~NodeItem();
86
87    virtual void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0);
88    virtual int type() const {return Type;}
89   
90    void set_coordinates(double x, double y);
91
92
93    void set_x(double x);
94    double x() const;
95
96    void set_y(double y);
97    double y() const;
98   
99    void set_image(QPixmap* im);
100
101    virtual void set_graph_transform(const QTransform& transform);
102    virtual QTransform graph_transform() const;
103   
104    void set_index(int index);
105    int index() const;
106
107    void set_tooltip(const QString& tooltip);
108
109    void set_uuid(int uuid);
110    int uuid() const;
111   
112    QList<NodeItem*> neighbors();
113
114    /**
115     * @brief Connect an edge to this node
116     *
117     * A connected edge is automatically updated whenever this node is moved
118     *
119     * @param edge the edge to be connected
120     **/
121    void add_connected_edge(EdgeItem* edge);
122    void remove_connected_edge(EdgeItem* edge);
123    QList<EdgeItem*> connected_edges();
124   
125    double m_size_value;
126
127protected:
128    QPixmap *image;
129
130private:
131    double m_x;
132    double m_y;
133   
134    int m_index;
135    int m_uuid;
136   
137    QList<EdgeItem*> m_connected_edges;
138    QTransform m_graph_transform;
139    void scale_axes();
140};
141
142class ModelItem : public NodeItem
143{
144public:
145    ModelItem(int index, int symbol, QColor color, int size, QGraphicsItem* parent = 0);
146
147    virtual void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0);
148
149    void set_representative(bool value);
150    bool is_representative() const;
151
152private:
153    bool representative;
154};
155
156struct ArrowData
157{
158    ArrowData(int size, const QColor& color) : size(size), color(color) {}
159
160    int size;
161    QColor color;
162};
163
164class EdgeItem : public QAbstractGraphicsShapeItem
165{
166public:
167    enum Arrow
168    {
169        ArrowU = 0x01,
170        ArrowV = 0x02
171    };
172    Q_DECLARE_FLAGS(Arrows, Arrow)
173   
174    EdgeItem(NodeItem* u, NodeItem* v, QGraphicsItem* parent = 0, QGraphicsScene* scene = 0);
175    virtual ~EdgeItem();
176
177    virtual void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0);
178    virtual QRectF boundingRect() const;
179    virtual QPainterPath shape() const;
180
181    void set_u(NodeItem* item);
182    NodeItem* u();
183    void set_v(NodeItem* item);
184    NodeItem* v();
185   
186    void set_label(const QString& label);
187    QString label() const;
188    void set_tooltip(const QString& tooltip);
189   
190    void set_links_index(int index);
191    int links_index() const;
192   
193    void set_weight(double weight);
194    double weight() const;
195   
196    void set_arrows(Arrows arrows);
197    void set_arrow(Arrow arrow, bool enable);
198    Arrows arrows();
199   
200    static QHash<ArrowData, QPixmap> arrow_cache;
201
202private:
203    Arrows m_arrows;
204    NodeItem* m_u;
205    NodeItem* m_v;
206    int m_links_index;
207    double m_weight;
208    QString m_label;
209};
210
211class NetworkCurve : public Curve
212{
213public:
214    enum CircularLayoutType
215    {
216        circular_original = 0x01,
217        circular_random = 0x02,
218        circular_crossing = 0x03
219    };
220
221    typedef QList<EdgeItem*> Edges;
222    typedef QMap<int, NodeItem*> Nodes;
223    typedef QMap<int, LabelItem*> Labels;
224
225    explicit NetworkCurve(QGraphicsItem* parent = 0);
226    virtual ~NetworkCurve();
227
228    virtual void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget);
229
230    virtual void update_properties();
231    virtual QRectF data_rect() const;
232    virtual void register_points();
233   
234    int random();
235    int circular(CircularLayoutType type);
236    int circular_crossing_reduction();
237    int fr(int steps, bool weighted, bool smooth_cooling);
238   
239    Nodes nodes() const;
240    void set_nodes(const Nodes& nodes);
241    void add_nodes(const Nodes& nodes);
242    void remove_node(int index);
243    void remove_nodes(const QList< int >& nodes);
244   
245    Edges edges() const;
246    void set_edges(const Edges& edges);
247    void add_edges(const Edges& edges);
248
249    Labels labels() const;
250    void set_labels(const Labels& labels);
251    void add_labels(const Labels& labels);
252    void remove_label(int index);
253    void remove_labels(const QList< int >& labels);
254
255    QList<QPair<int, int> > edge_indices();
256
257    void set_node_colors(const QMap<int, QColor>& colors);
258    void set_node_sizes(const QMap<int, double>& sizes, double min_size, double max_size);
259    void set_node_labels(const QMap<int, QString>& labels);
260
261    void set_node_tooltips(const QMap<int, QString>& tooltips);
262    void set_node_marks(const QMap<int, bool>& marks);
263    void clear_node_marks();
264    void set_node_coordinates(const QMap<int, QPair<double, double> >& coordinates);
265
266    void set_edge_colors(const QList<QColor>& colors);
267    void set_edge_sizes(double max_size);
268    void set_edge_labels(const QList<QString>& labels);
269
270    void set_min_node_size(double size);
271    double min_node_size() const;
272
273    void set_max_node_size(double size);
274    double max_node_size() const;
275
276    void set_use_animations(bool use_animations);
277    bool use_animations() const;
278
279    void set_show_component_distances(bool show_component_distances);
280
281    void stop_optimization();
282
283private:
284    Nodes m_nodes;
285    Edges m_edges;
286    Labels m_labels;
287
288    double m_min_node_size;
289    double m_max_node_size;
290    bool m_use_animations;
291    bool m_stop_optimization;
292    bool m_show_component_distances;
293};
294
295#endif // NETWORKCURVE_H
Note: See TracBrowser for help on using the repository browser.