Changeset 8613:94bb79b0383c in orange


Ignore:
Timestamp:
08/05/11 12:17:46 (3 years ago)
Author:
Noughmad <Noughmad@…>
Branch:
default
Convert:
a24d3a23b0b61af6e0b1f16d31552e493b158e1e
Message:

Simplify tooltips in LinProj, move more zoom functionality to C++, move the DataPoint struct to point.h

Files:
15 edited

Legend:

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

    r8612 r8613  
    7070         
    7171        self._extra_curves = [] 
     72        self.current_tooltip_point = None 
     73        self.point_hovered.connect(self.draw_tooltips) 
    7274 
    7375    def setData(self, data, subsetData = None, **args): 
     
    381383    # this will enable to show tooltips faster and to make selection of examples available 
    382384    def addTooltipKey(self, x, y, color, index, extraString = None): 
    383         dictValue = "%.1f-%.1f"%(x, y) 
    384         if not self.dataMap.has_key(dictValue): self.dataMap[dictValue] = [] 
    385         self.dataMap[dictValue].append((x, y, color, index, extraString)) 
    386  
     385        dictValue = (x, y) 
     386        self.dataMap[dictValue] = (x, y, color, index, extraString) 
    387387 
    388388    def addValueLineCurve(self, x, y, color, exampleIndex, attrIndices): 
     
    427427            OWPlot.mouseReleaseEvent(self, e) 
    428428 
     429    def mouseMoveEvent(self, e): 
     430        if self._pressed_mouse_button and self.manualPositioning and self.selectedAnchorIndex != None: 
     431            if self.selectedAnchorIndex != None: 
     432                if self.widget.freeVizDlg.restrain == 1: 
     433                    rad = sqrt(xFloat**2 + yFloat**2) 
     434                    xFloat /= rad 
     435                    yFloat /= rad 
     436                elif self.widget.freeVizDlg.restrain == 2: 
     437                    rad = sqrt(xFloat**2 + yFloat**2) 
     438                    phi = 2 * self.selectedAnchorIndex * math.pi / len(self.anchorData) 
     439                    xFloat = rad * cos(phi) 
     440                    yFloat = rad * sin(phi) 
     441                self.anchorData[self.selectedAnchorIndex] = (xFloat, yFloat, self.anchorData[self.selectedAnchorIndex][2]) 
     442                self.updateData(self.shownAttributes) 
     443                self.replot() 
     444                #self.widget.recomputeEnergy() 
     445        else: 
     446            OWPlot.mouseMoveEvent(self, e) 
     447     
     448 
    429449    # ############################################################## 
    430     # draw tooltips 
    431     def mouseMoveEvent(self, e): 
    432         redraw = (self.tooltipCurves != [] or self.tooltipMarkers != []) 
    433  
     450    # draw tooltips         
     451    def draw_tooltips(self, point): 
     452        if point is self.current_tooltip_point: 
     453            return 
     454             
    434455        for curve in self.tooltipCurves:  curve.detach() 
    435456        for marker in self.tooltipMarkers: marker.detach() 
    436457        self.tooltipCurves = [] 
    437458        self.tooltipMarkers = [] 
    438  
    439         xFloat, yFloat = self.map_from_graph(self.mapToScene(e.pos()), zoom=True) 
    440  
    441         # in case we are drawing a rectangle, we don't draw enhanced tooltips 
    442         # because it would then fail to draw the rectangle 
    443         if self._pressed_mouse_button: 
    444             if not self.manualPositioning: 
    445                 OWPlot.mouseMoveEvent(self, e) 
    446                 if redraw: self.replot() 
    447             else: 
    448                 if self.selectedAnchorIndex != None: 
    449                     if self.widget.freeVizDlg.restrain == 1: 
    450                         rad = sqrt(xFloat**2 + yFloat**2) 
    451                         xFloat /= rad 
    452                         yFloat /= rad 
    453                     elif self.widget.freeVizDlg.restrain == 2: 
    454                         rad = sqrt(xFloat**2 + yFloat**2) 
    455                         phi = 2 * self.selectedAnchorIndex * math.pi / len(self.anchorData) 
    456                         xFloat = rad * cos(phi) 
    457                         yFloat = rad * sin(phi) 
    458                     self.anchorData[self.selectedAnchorIndex] = (xFloat, yFloat, self.anchorData[self.selectedAnchorIndex][2]) 
    459                     self.updateData(self.shownAttributes) 
    460                     self.replot() 
    461                     #self.widget.recomputeEnergy() 
     459         
     460        if not point: 
    462461            return 
    463462 
    464         dictValue = "%.1f-%.1f"%(xFloat, yFloat) 
     463        xFloat, yFloat = point.coordinates() 
     464 
     465        dictValue = (xFloat, yFloat) 
    465466        if self.dataMap.has_key(dictValue): 
    466             points = self.dataMap[dictValue] 
    467             bestDist = 100.0 
    468             for (x_i, y_i, color, index, extraString) in points: 
    469                 currDist = sqrt((xFloat-x_i)*(xFloat-x_i) + (yFloat-y_i)*(yFloat-y_i)) 
    470                 if currDist < bestDist: 
    471                     bestDist = currDist 
    472                     nearestPoint = (x_i, y_i, color, index, extraString) 
    473  
    474             (x_i, y_i, color, index, extraString) = nearestPoint 
     467            (x_i, y_i, color, index, extraString) = self.dataMap[dictValue] 
    475468            intX = self.transform(xBottom, x_i) 
    476469            intY = self.transform(yLeft, y_i) 
    477470 
    478             if self.tooltipKind == LINE_TOOLTIPS and bestDist < 0.05: 
     471            if self.tooltipKind == LINE_TOOLTIPS: 
    479472                shownAnchorData = filter(lambda p, r=self.hideRadius**2/100: p[0]**2+p[1]**2>r, self.anchorData) 
    480473                if not self.normalizeExamples: 
     
    512505                    text += "<hr>" + extraString 
    513506                self.showTip(intX, intY, text) 
    514  
    515         OWPlot.mouseMoveEvent(self, e) 
    516         self.replot() 
    517  
    518507 
    519508    # send 2 example tables. in first is the data that is inside selected rects (polygons), in the second is unselected data 
  • orange/OrangeWidgets/Prototypes/OWNxCanvasQt.py

    r8610 r8613  
    556556        if hasattr(self, 'networkCurve') and self.networkCurve is not None: 
    557557            self.networkCurve.update() 
    558              
    559     def mouseMoveEvent(self, event): 
    560         self.point_hovered.emit(self.nearest_point(self.mapToScene(event.pos()))) 
    561         OWPlot.mouseMoveEvent(self, event) 
  • orange/OrangeWidgets/plot/owcurve.py

    r8547 r8613  
    4646    def __init__(self, xData=[], yData=[], x_axis_key=xBottom, y_axis_key=yLeft, tooltip=None, parent=None, scene=None): 
    4747        orangeplot.Curve.__init__(self, xData, yData, parent, scene) 
    48         self.set_auto_update(False) 
    4948        self.set_axes(x_axis_key, y_axis_key) 
    5049        if tooltip: 
  • orange/OrangeWidgets/plot/owplot.py

    r8612 r8613  
    460460        if hasattr(curve, 'tooltip'): 
    461461            curve.setToolTip(curve.tooltip) 
    462         curve.set_auto_update(True) 
     462        x,y = curve.axes() 
     463        curve.set_graph_transform(self.transform_for_axes(x,y)) 
    463464        curve.update_properties() 
    464465        return curve 
     
    492493        c.set_point_size(size) 
    493494        c.set_data(xData,  yData) 
    494         c.set_graph_transform(self.transform_for_axes(x_axis_key, y_axis_key)) 
    495495         
    496496        c.set_auto_scale(autoScale) 
     
    542542    def add_marker(self, name, x, y, alignment = -1, bold = 0, color = None, brushColor = None, size=None, antiAlias = None,  
    543543                    x_axis_key = xBottom, y_axis_key = yLeft): 
     544        qDebug('Adding marker %s at pas %f,%f' % (name,x,y)) 
    544545        m = Marker(name, x, y, alignment, bold, color, brushColor) 
    545546        self._marker_items.append((m, x, y, x_axis_key, y_axis_key)) 
    546         m.attach(self) 
     547        self.add_custom_curve(m) 
    547548         
    548549        return m 
     
    557558            Axes and the grid are not removed 
    558559        ''' 
     560        qDebug(' == OWPlot.clear() == ') 
    559561        for i in self.plot_items(): 
    560562            if i is not self.grid_curve: 
     
    791793            event.accept() 
    792794            return 
     795             
    793796        if event.buttons() and (self._pressed_mouse_pos - event.pos()).manhattanLength() > qApp.startDragDistance(): 
    794797            self.static_click = False 
     
    798801         
    799802        point = self.mapToScene(event.pos()) 
     803        if not self._pressed_mouse_button: 
     804            self.point_hovered.emit(self.nearest_point(point)) 
    800805         
    801806        ## We implement a workaround here, because sometimes mouseMoveEvents are not fast enough 
     
    805810            return 
    806811         
    807         if self._pressed_mouse_button == Qt.LeftButton: 
     812        if self._pressed_mouse_button == Qt.LeftButton and not self.static_click: 
    808813            if self.state in [ZOOMING, SELECT] and self.graph_area.contains(point): 
    809814                if not self._current_rs_item: 
    810                     self._selection_start_point = self.mapToScene(event.pos()) 
     815                    self._selection_start_point = self.mapToScene(self._pressed_mouse_pos) 
    811816                    self._current_rs_item = QGraphicsRectItem(scene=self.scene()) 
    812817                    self._current_rs_item.setPen(SelectionPen) 
     
    815820                self._current_rs_item.setRect(QRectF(self._selection_start_point, point).normalized()) 
    816821            elif self.state == PANNING: 
    817                 if self._last_pan_pos: 
    818                     self.pan(point - self._last_pan_pos) 
     822                if not self._last_pan_pos: 
     823                    self._last_pan_pos = self.mapToScene(self._pressed_mouse_pos) 
     824                self.pan(point - self._last_pan_pos) 
    819825                self._last_pan_pos = point 
    820826        elif not self._pressed_mouse_button and self.state == SELECT_POLYGON and self._current_ps_item: 
  • source/orangeplot/curve.cpp

    r8597 r8613  
    1212Curve::Curve(const QList< double >& x_data, const QList< double >& y_data, QGraphicsItem* parent, QGraphicsScene* scene): PlotItem(parent, scene) 
    1313{ 
     14    m_autoUpdate = true; 
    1415    m_style = NoCurve; 
    1516    m_continuous = false; 
     
    2223Curve::Curve(QGraphicsItem* parent, QGraphicsScene* scene): PlotItem(parent, scene) 
    2324{ 
     25    m_autoUpdate = true; 
    2426    m_style = NoCurve; 
    2527    m_lineItem = 0; 
     
    102104    for (int i = 0; i < n; ++i) 
    103105    { 
    104       p = QPointF(m_data[i].x, m_data[i].y); 
    105       m_pointItems[i]->setPos(m_graphTransform.map(p)); 
    106     } 
     106      m_pointItems[i]->set_coordinates(m_data[i]); 
     107    } 
     108    update_items(m_pointItems, PointPosUpdater(m_graphTransform), UpdatePosition); 
    107109  }  
    108110   
    109111  if (m_needsUpdate & (UpdateZoom | UpdateBrush | UpdatePen | UpdateSize | UpdateSymbol) ) 
    110112  { 
     113      qDebug() << "Updating zoom"; 
    111114    update_items(m_pointItems, PointUpdater(m_symbol, m_color, m_pointSize, Point::DisplayPath, point_transform()), UpdateSymbol); 
    112115  } 
     
    307310    m_lineItem = 0; 
    308311  } 
     312  register_points(); 
    309313} 
    310314 
     
    317321void Curve::set_zoom_transform(const QTransform& transform) 
    318322{ 
     323    qDebug() << "Curve: Setting zoom transform to" << transform; 
    319324    m_zoom_transform = transform; 
    320325    m_needsUpdate |= UpdateZoom; 
  • source/orangeplot/curve.h

    r8612 r8613  
    99 
    1010#include <QtCore/QtConcurrentMap> 
    11  
    12 struct DataPoint 
    13 { 
    14   double x; 
    15   double y; 
    16 }; 
    1711 
    1812struct ZoomUpdater 
  • source/orangeplot/curve.sip

    r8570 r8613  
    1 // DataPoint is implemented as a Python 2-element tuple. 
    2 %MappedType DataPoint /DocType="tuple-of-float-float"/ 
    3 { 
    4 %TypeHeaderCode 
    5 #include "curve.h" 
    6 %End 
    7  
    8 %ConvertFromTypeCode 
    9     // Create the tuple. 
    10     return Py_BuildValue((char *)"dd", sipCpp->x, sipCpp->y); 
    11 %End 
    12  
    13 %ConvertToTypeCode 
    14     // Check the type if that is all that is required. 
    15     if (sipIsErr == NULL) 
    16         return (PyTuple_Size(sipPy) == 2); 
    17      
    18     DataPoint* qp = new DataPoint(); 
    19  
    20     PyArg_ParseTuple(sipPy, "dd", &qp->x, &qp->y); 
    21     *sipCppPtr = qp; 
    22      
    23     return sipGetState(sipTransferObj); 
    24 %End 
    25 }; 
    26  
    27  
    281struct Updater 
    292{ 
     
    9366  void set_data(const QList<qreal>& x_data, const QList<qreal>& y_data); 
    9467 
    95   QTransform graph_transform() const; 
    96   void set_graph_transform(const QTransform& transform); 
     68  virtual QTransform graph_transform() const; 
     69  virtual void set_graph_transform(const QTransform& transform); 
    9770 
    9871  int style() const; 
    9972  void set_style(int style); 
    10073  
    101   QTransform zoom_transform(); 
    102   void set_zoom_transform(const QTransform& transform); 
     74  virtual QTransform zoom_transform(); 
     75  virtual void set_zoom_transform(const QTransform& transform); 
    10376 
    10477  bool auto_update() const; 
  • source/orangeplot/networkcurve.h

    r8607 r8613  
    2626    double y() const; 
    2727     
    28     void set_graph_transform(const QTransform& transform); 
    29     QTransform graph_transform() const; 
     28    virtual void set_graph_transform(const QTransform& transform); 
     29    virtual QTransform graph_transform() const; 
    3030     
    3131    void set_index(int index); 
  • source/orangeplot/plot.cpp

    r8612 r8613  
    8484    m_items << item; 
    8585    item->register_points(); 
     86    item->update_properties(); 
    8687} 
    8788 
     
    298299    foreach (PlotItem* item, plot_items()) 
    299300    { 
     301        Q_ASSERT(m_point_set[item].toList() == m_point_hash[item].keys()); 
    300302        if (!m_point_set.contains(item)) 
    301303        { 
     
    353355    if (m_point_set.contains(parent)) 
    354356    { 
    355         m_point_set[parent].clear(); 
    356         m_point_hash[parent].clear(); 
     357        m_point_set.remove(parent); 
     358        m_point_hash.remove(parent); 
    357359    } 
    358360} 
  • source/orangeplot/plotitem.cpp

    r8612 r8613  
    8888} 
    8989 
     90void PlotItem::update_properties() 
     91{ 
     92 
     93} 
     94 
    9095QRectF PlotItem::rect_from_data(const QList< double >& x_data, const QList< double >& y_data) 
    9196{ 
  • source/orangeplot/plotitem.h

    r8612 r8613  
    2424    virtual void set_zoom_transform(const QTransform& zoom); 
    2525    virtual QTransform zoom_transform() const; 
     26     
     27    virtual void update_properties(); 
    2628     
    2729    void attach(Plot* graph); 
  • source/orangeplot/plotitem.sip

    r8612 r8613  
    2020    virtual void set_zoom_transform(const QTransform& zoom); 
    2121    virtual QTransform zoom_transform() const; 
     22 
     23    virtual void update_properties(); 
    2224     
    2325    void attach(Plot* graph /TransferThis/); 
  • source/orangeplot/point.cpp

    r8608 r8613  
    333333} 
    334334 
     335DataPoint Point::coordinates() const 
     336{ 
     337    return m_coordinates; 
     338} 
     339 
     340void Point::set_coordinates(const DataPoint& data_point) 
     341{ 
     342    m_coordinates = data_point; 
     343} 
     344 
    335345void Point::clear_cache() 
    336346{ 
  • source/orangeplot/point.h

    r8608 r8613  
    33 
    44#include <QtGui/QGraphicsItem> 
     5 
     6 
     7struct DataPoint 
     8{ 
     9  double x; 
     10  double y; 
     11}; 
    512 
    613struct PointData 
     
    104111    void set_transparent(bool transparent); 
    105112     
     113    DataPoint coordinates() const; 
     114    void set_coordinates(const DataPoint& data_point); 
     115     
    106116    /** 
    107117    * Creates a path from a symbol and a size 
     
    131141    State m_state; 
    132142    bool m_transparent; 
     143     
     144    DataPoint m_coordinates; 
     145}; 
     146 
     147struct PointPosUpdater 
     148{ 
     149  PointPosUpdater(QTransform t) : t(t) {} 
     150  void operator()(Point* point) 
     151  { 
     152    point->setPos(t.map(QPointF(point->coordinates().x, point->coordinates().y))); 
     153  } 
     154   
     155private: 
     156    QTransform t; 
    133157}; 
    134158 
  • source/orangeplot/point.sip

    r8605 r8613  
     1// DataPoint is implemented as a Python 2-element tuple. 
     2%MappedType DataPoint /DocType="tuple-of-float-float"/ 
     3{ 
     4%TypeHeaderCode 
     5#include "point.h" 
     6%End 
     7 
     8%ConvertFromTypeCode 
     9    // Create the tuple. 
     10    return Py_BuildValue((char *)"dd", sipCpp->x, sipCpp->y); 
     11%End 
     12 
     13%ConvertToTypeCode 
     14    // Check the type if that is all that is required. 
     15    if (sipIsErr == NULL) 
     16        return (PyTuple_Size(sipPy) == 2); 
     17     
     18    DataPoint* qp = new DataPoint(); 
     19 
     20    PyArg_ParseTuple(sipPy, "dd", &qp->x, &qp->y); 
     21    *sipCppPtr = qp; 
     22     
     23    return sipGetState(sipTransferObj); 
     24%End 
     25}; 
     26 
    127class Point : QGraphicsItem 
    228{ 
     
    74100    bool is_transparent(); 
    75101    void set_transparent(bool transparent); 
     102     
     103    DataPoint coordinates() const; 
     104    void set_coordinates(const DataPoint& data_point); 
    76105 
    77106    /** 
Note: See TracChangeset for help on using the changeset viewer.