Changeset 8690:90b58e07b9e0 in orange


Ignore:
Timestamp:
08/13/11 12:09:58 (3 years ago)
Author:
Noughmad <Noughmad@…>
Branch:
default
Convert:
f77d2952e173b075a1e3cca8802ba9754bd6a7c7
Message:

Support for threaded OR animated changing of all Point's properties, used in MultiCurve

Files:
11 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeWidgets/Prototypes/OWDiscretizeQt.py

    r8423 r8690  
    1919class DiscGraph(OWPlot): 
    2020    def __init__(self, master, *args): 
    21         OWPlot.__init__(self, *args) 
     21        OWPlot.__init__(self, *args, widget=master) 
    2222        self.master=master 
    2323 
  • orange/OrangeWidgets/Prototypes/OWLinProjGraphQt.py

    r8667 r8690  
    2727class OWLinProjGraph(OWPlot, orngScaleLinProjData): 
    2828    def __init__(self, widget, parent = None, name = "None"): 
    29         OWPlot.__init__(self, parent, name, axes=[]) 
     29        OWPlot.__init__(self, parent, name, axes=[], widget=widget) 
    3030        orngScaleLinProjData.__init__(self) 
    3131 
  • orange/OrangeWidgets/Prototypes/OWPolyvizGraphQt.py

    r8667 r8690  
    7171    def __init__(self, polyvizWidget, parent = None, name = None): 
    7272        "Constructs the graph" 
    73         OWPlot.__init__(self, parent, name, axes = []) 
     73        OWPlot.__init__(self, parent, name, axes = [], widget=polyvizWidget) 
    7474        orngScalePolyvizData.__init__(self) 
    7575        self.enableGridXB(0) 
  • orange/OrangeWidgets/Prototypes/OWScatterPlotGraphQt.py

    r8680 r8690  
    2323class OWScatterPlotGraphQt(OWPlot, orngScaleScatterPlotData): 
    2424    def __init__(self, scatterWidget, parent = None, name = "None"): 
    25         OWPlot.__init__(self, parent, name) 
     25        OWPlot.__init__(self, parent, name, widget = scatterWidget) 
    2626        orngScaleScatterPlotData.__init__(self) 
    2727 
  • orange/OrangeWidgets/plot/owplot.py

    r8681 r8690  
    270270     
    271271    """ 
    272     def __init__(self, parent = None,  name = "None",  show_legend = 1, axes = [xBottom, yLeft] ): 
     272    def __init__(self, parent = None,  name = "None",  show_legend = 1, axes = [xBottom, yLeft], widget = None ): 
    273273        """ 
    274274            Creates a new graph 
     
    279279        """ 
    280280        orangeqt.Plot.__init__(self, parent) 
     281        self.widget = widget 
    281282        self.parent_name = name 
    282283        self.show_legend = show_legend 
     
    807808            It does not update the curve or the other plot items.  
    808809        ''' 
     810        if not self.isVisible(): 
     811            # No point in updating the graph if it's still hidden 
     812            return 
    809813        graph_rect = QRectF(self.contentsRect()) 
    810814        self.centerOn(graph_rect.center()) 
     
    14511455                self.animate_plot = False 
    14521456                self.antialias_lines = False 
     1457            else: 
     1458                self.animate_points = True 
     1459                self.animate_plot = True 
     1460                self.antialias_lines = True 
    14531461         
    14541462    def animate(self, target, prop_name, end_val, duration = None): 
     
    15541562        if self.main_curve: 
    15551563            self.main_curve.shuffle_points() 
     1564             
     1565    def set_progress(self, done, total): 
     1566        if not self.widget: 
     1567            return 
     1568             
     1569        if done == total: 
     1570            self.widget.progressBarFinished() 
     1571        else: 
     1572            self.widget.progressBarSet(100.0 * done / total) 
     1573         
     1574    def start_progress(self): 
     1575        if self.widget: 
     1576            self.widget.progressBarInit() 
     1577             
     1578    def end_progress(self): 
     1579        if self.widget: 
     1580            self.widget.progressBarFinished() 
  • source/orangeqt/curve.cpp

    r8681 r8690  
    2929#include "point.h" 
    3030#include "plot.h" 
     31 
    3132#include <QtCore/QParallelAnimationGroup> 
     33#include <QtCore/QCoreApplication> 
    3234 
    3335Curve::Curve(const QList< double >& x_data, const QList< double >& y_data, QGraphicsItem* parent): PlotItem(parent) 
     
    7173  } 
    7274  int n = m_data.size(); 
    73   if (m_pointItems.size() > n) 
     75  int m = m_pointItems.size(); 
     76  if (m > n) 
    7477  { 
    7578    qDeleteAll(m_pointItems.constBegin() + n, m_pointItems.constEnd()); 
    7679    m_pointItems.erase(m_pointItems.begin() + n, m_pointItems.end()); 
    7780  } 
    78   int m = n - m_pointItems.size(); 
    79   for (int i = 0; i < m; ++i) 
    80   { 
    81     m_pointItems << new Point(m_symbol, m_color, m_pointSize, this); 
     81  else if (m < n) 
     82  {   
     83    Plot* p = plot(); 
     84    int delta = n - m; 
     85    if (p && delta > 500) 
     86    { 
     87        int update_every = qMax(5, delta / 100); 
     88        p->start_progress(); 
     89        for (int i = 0; i < delta; ++i) 
     90        { 
     91            m_pointItems << new Point(m_symbol, m_color, m_pointSize, this); 
     92         
     93            if (i % update_every == 0) 
     94            { 
     95                qApp->processEvents(); 
     96                p->set_progress(i, delta); 
     97            } 
     98        } 
     99        p->end_progress(); 
     100        qApp->processEvents(); 
     101    } 
     102    else 
     103    { 
     104      for (int i = 0; i < delta; ++i) 
     105      { 
     106        m_pointItems << new Point(m_symbol, m_color, m_pointSize, this); 
     107      } 
     108    } 
    82109  } 
    83110  Q_ASSERT(m_pointItems.size() == m_data.size()); 
     
    440467void Curve::pointMapFinished() 
    441468{ 
     469    if (m_pointItems.size() != m_watcher.future().results().size()) 
     470    { 
     471        // The calculation that just finished is already out of date, ignore it 
     472        return; 
     473    } 
    442474    QParallelAnimationGroup* group = new QParallelAnimationGroup; 
    443475    int n = m_pointItems.size(); 
     
    451483} 
    452484 
     485bool Curve::use_animations() 
     486{ 
     487    return plot() && plot()->animate_points; 
     488} 
     489void Curve::update_point_properties_same(const QByteArray& property, const QVariant& value) { 
     490    int n = m_pointItems.size(); 
     491 
     492    if (use_animations()) 
     493    { 
     494        QParallelAnimationGroup* group = new QParallelAnimationGroup(this); 
     495        for (int i = 0; i < n; ++i) 
     496        { 
     497            QPropertyAnimation* a = new QPropertyAnimation(m_pointItems[i], property, m_pointItems[i]); 
     498            a->setEndValue(value); 
     499            group->addAnimation(a); 
     500        } 
     501        group->start(QAbstractAnimation::DeleteWhenStopped); 
     502    } 
     503    else 
     504    { 
     505        QtConcurrent::map(m_pointItems, PointPropertyUpdater(property, value)); 
     506    } 
     507} 
     508 
     509 
    453510 
    454511 
  • source/orangeqt/curve.h

    r8680 r8690  
    2727#include <QtCore/QtConcurrentMap> 
    2828#include <QtCore/QFutureWatcher> 
     29#include <QtCore/QParallelAnimationGroup> 
     30#include <QtCore/QtConcurrentRun> 
    2931 
    3032struct PointPosMapper{ 
     
    213215  void update_point_positions(); 
    214216   
     217  template <class T> 
     218  void update_point_properties(const QByteArray& property, const QList< T >& values, bool animate = true); 
     219 
     220  template <class T> 
     221  void update_point_properties_threaded(const QByteArray& property, const QList<T>& values); 
     222   
     223  void update_point_properties_same(const QByteArray& property, const QVariant& value); 
     224 
    215225  void set_points(const QList<Point*>& points); 
    216226  QList<Point*> points(); 
     
    225235  void updateNumberOfItems(); 
    226236  void changeContinuous(); 
     237   
     238  bool use_animations(); 
    227239   
    228240private slots: 
     
    262274} 
    263275 
     276template < class T > 
     277void Curve::update_point_properties(const QByteArray& property, const QList< T >& values, bool animate) 
     278{ 
     279    int n = m_pointItems.size(); 
     280    if (n != values.size()) 
     281    { 
     282        if (values.isEmpty()) 
     283        { 
     284            update_point_properties_same(property, T()); 
     285        } 
     286        else 
     287        { 
     288            update_point_properties_same(property, values.first()); 
     289        } 
     290         
     291        return; 
     292    } 
     293     
     294    if (animate && use_animations()) 
     295    { 
     296        QParallelAnimationGroup* group = new QParallelAnimationGroup(this); 
     297        for (int i = 0; i < n; ++i) 
     298        { 
     299            QPropertyAnimation* a = new QPropertyAnimation(m_pointItems[i], property, m_pointItems[i]); 
     300            a->setEndValue(values[i]); 
     301            group->addAnimation(a); 
     302        } 
     303        group->start(QAbstractAnimation::DeleteWhenStopped); 
     304    } 
     305    else 
     306    { 
     307        QtConcurrent::run(this, &Curve::update_point_properties_threaded<T>, property, values); 
     308    } 
     309} 
     310 
     311template < class T > 
     312void Curve::update_point_properties_threaded(const QByteArray& property, const QList< T >& values) 
     313{ 
     314    const int n = values.size(); 
     315    for (int i = 0; i < n; ++i) 
     316    { 
     317        m_pointItems[i]->setProperty(property, values[i]); 
     318    } 
     319} 
     320 
    264321Q_DECLARE_OPERATORS_FOR_FLAGS(Curve::UpdateFlags) 
    265322 
  • source/orangeqt/multicurve.cpp

    r8680 r8690  
    3535{ 
    3636    updateNumberOfItems(); 
    37     const QList<Point*> p = points(); 
    38     int n = p.size(); 
    39     if (colors.size() == n) 
    40     { 
    41         for (int i = 0; i < n; ++i) 
    42         { 
    43             p[i]->set_color(colors[i]); 
    44         } 
    45     } 
    46     else 
    47     { 
    48         for (int i = 0; i < n; ++i) 
    49         { 
    50             p[i]->set_color(Qt::black); 
    51         } 
    52     } 
     37    update_point_properties("color", colors); 
    5338} 
    5439 
     
    5641{ 
    5742    updateNumberOfItems(); 
    58     const QList<Point*> p = points(); 
    59     int n = p.size(); 
    60     if (labels.size() == n) 
    61     { 
    62         for (int i = 0; i < n; ++i) 
    63         { 
    64             p[i]->set_label(labels[i]); 
    65         } 
    66     } 
    67     else 
    68     { 
    69         for (int i = 0; i < n; ++i) 
    70         { 
    71             p[i]->set_label(QString()); 
    72         } 
    73     } 
     43    update_point_properties("label", labels, false); 
    7444} 
    7545 
     
    7747{ 
    7848    updateNumberOfItems(); 
    79     const QList<Point*> p = points(); 
    80     int n = p.size(); 
    81     if (sizes.size() == n) 
    82     { 
    83         for (int i = 0; i < n; ++i) 
    84         { 
    85             p[i]->set_size(sizes[i]); 
    86         } 
    87     } 
    88     else if (!sizes.isEmpty()) 
    89     { 
    90         for (int i = 0; i < n; ++i) 
    91         { 
    92             p[i]->set_size(sizes.first()); 
    93         } 
    94     } 
     49    update_point_properties("size", sizes); 
    9550} 
    9651 
     
    9853{ 
    9954    updateNumberOfItems(); 
    100     const QList<Point*> p = points(); 
    101     int n = p.size(); 
    102     if (symbols.size() == n) 
    103     { 
    104         for (int i = 0; i < n; ++i) 
    105         { 
    106             p[i]->set_symbol(symbols[i]); 
    107         } 
    108     } 
    109     else 
    110     { 
    111         for (int i = 0; i < n; ++i) 
    112         { 
    113             p[i]->set_symbol(Point::Ellipse); 
    114         } 
    115     } 
     55    update_point_properties("symbol", symbols, false); 
    11656} 
    11757 
  • source/orangeqt/plot.h

    r8681 r8690  
    4949     
    5050    virtual void replot() = 0; 
     51    virtual void start_progress() = 0; 
     52    virtual void set_progress(int done, int total) = 0; 
     53    virtual void end_progress() = 0; 
    5154     
    5255    void add_item(PlotItem* item); 
  • source/orangeqt/plot.sip

    r8681 r8690  
    4444     
    4545    virtual void replot() = 0; 
     46    virtual void start_progress() = 0; 
     47    virtual void set_progress(int done, int total) = 0; 
     48    virtual void end_progress() = 0; 
    4649     
    4750    void add_item(PlotItem* item /Transfer/); 
  • source/orangeqt/point.h

    r8680 r8690  
    4949{ 
    5050    Q_OBJECT 
     51    Q_PROPERTY(QColor color READ color WRITE set_color) 
     52    Q_PROPERTY(int symbol READ symbol WRITE set_symbol) 
     53    Q_PROPERTY(int size READ size WRITE set_size) 
     54    Q_PROPERTY(QString label READ label WRITE set_label) 
     55     
    5156     
    5257public: 
     
    204209}; 
    205210 
     211struct PointPropertyUpdater 
     212{ 
     213    PointPropertyUpdater(const QByteArray& property, const QVariant& value) : property(property), value(value) {} 
     214    void operator()(Point* point) 
     215    { 
     216        point->setProperty(property, value); 
     217    } 
     218     
     219private: 
     220    QByteArray property; 
     221    QVariant value; 
     222}; 
     223 
    206224#endif // POINT_H 
Note: See TracChangeset for help on using the changeset viewer.