Changeset 8657:38afa1a6e25e in orange


Ignore:
Timestamp:
08/11/11 08:04:22 (3 years ago)
Author:
Noughmad <Noughmad@…>
Branch:
default
Convert:
d3f683f10030b0f970fcff1a182cc085e34ba635
Message:

Make point selection work properly even if more than one point has the same coordinates.

Files:
7 edited

Legend:

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

    r8653 r8657  
    12311231        t = 1.13850193174e-008 * (self.graph.number_of_nodes()**2 + self.graph.number_of_edges()) 
    12321232        self.frSteps = int(2.0 / t) 
    1233         if self.frSteps <   1: self.frSteps = 1; 
    1234         if self.frSteps > 100: self.frSteps = 100; 
     1233        if self.frSteps <   1: self.frSteps = 1 
     1234        if self.frSteps > 100: self.frSteps = 100 
    12351235#         
    12361236#        if self.frSteps < 10: 
     
    12601260         
    12611261         
    1262     def set_graph_none(): 
     1262    def set_graph_none(self): 
    12631263        self.graph = None 
    12641264        self.graph_base = None 
     
    12751275         
    12761276        if graph is None: 
    1277             self.set_graph_none(); 
     1277            self.set_graph_none() 
    12781278            return 
    12791279         
     
    12881288        # it is too big to visualize! 
    12891289        if self.graph.number_of_nodes() + self.graph.number_of_edges() > 50000: 
    1290             self.set_graph_none(); 
     1290            self.set_graph_none() 
    12911291            self.error('Graph is too big to visualize. Try using one of the network views.') 
    12921292            return 
     
    13351335        t = 1.13850193174e-008 * (self.graph.number_of_nodes()**2 + self.graph.number_of_edges()) 
    13361336        self.frSteps = int(2.0 / t) 
    1337         if self.frSteps <   1: self.frSteps = 1; 
    1338         if self.frSteps > 100: self.frSteps = 100; 
     1337        if self.frSteps <   1: self.frSteps = 1 
     1338        if self.frSteps > 100: self.frSteps = 100 
    13391339         
    13401340        # if graph is large, set random layout, min vertex size, min edge size 
     
    15161516            self.graph_layout_fr_radial() 
    15171517        elif self.optMethod == 5: 
    1518             self.networkCanvas.networkCurve.circular(NetworkCurve.circular_crossing); 
     1518            self.networkCanvas.networkCurve.circular(NetworkCurve.circular_crossing) 
    15191519        elif self.optMethod == 6: 
    1520             self.networkCanvas.networkCurve.circular(NetworkCurve.circular_original); 
     1520            self.networkCanvas.networkCurve.circular(NetworkCurve.circular_original) 
    15211521        elif self.optMethod == 7: 
    1522             self.networkCanvas.networkCurve.circular(NetworkCurve.circular_random); 
     1522            self.networkCanvas.networkCurve.circular(NetworkCurve.circular_random) 
    15231523        elif self.optMethod == 8: 
    15241524            self.graph_layout_pivot_mds() 
     
    15691569        if not self.optButton.isChecked(): 
    15701570            print 'stop opt' 
    1571             self.networkCanvas.networkCurve.stop_optimization(); 
     1571            self.networkCanvas.networkCurve.stop_optimization() 
    15721572            self.optButton.setChecked(False) 
    15731573            self.optButton.setText("Optimize layout") 
     
    15901590#        t = k * nodes * nodes 
    15911591#        refreshRate = int(5.0 / t) 
    1592 #        if refreshRate <    1: refreshRate = 1; 
    1593 #        if refreshRate > 1500: refreshRate = 1500; 
     1592#        if refreshRate <    1: refreshRate = 1 
     1593#        if refreshRate > 1500: refreshRate = 1500 
    15941594#        #print "refreshRate: " + str(refreshRate) 
    15951595#         
  • source/orangeplot/curve.cpp

    r8639 r8657  
    361361    { 
    362362        p->remove_all_points(this); 
    363         p->add_points(m_data, m_pointItems, this); 
     363        p->add_points(m_pointItems, this); 
    364364    } 
    365365} 
  • source/orangeplot/networkcurve.cpp

    r8648 r8657  
    4747    m_x = x; 
    4848    m_y = y; 
     49     
     50    DataPoint p; 
     51    p.x = m_x; 
     52    p.y = m_y; 
     53    Point::set_coordinates(p); 
     54     
    4955    setPos(QPointF(m_x, m_y) * m_graph_transform); 
    5056} 
     
    380386        if (type == NetworkCurve::circular_original) 
    381387        { 
    382             m_nodes[vertices[i]]->set_x(r * cos(fi) + xCenter); 
    383             m_nodes[vertices[i]]->set_y(r * sin(fi) + yCenter); 
     388            m_nodes[vertices[i]]->set_coordinates(r * cos(fi) + xCenter, r * sin(fi) + yCenter); 
    384389        } 
    385390        else if (type == NetworkCurve::circular_random) 
    386391        { 
    387392            int ndx = rand() % vertices.size(); 
    388             m_nodes[vertices[ndx]]->set_x(r * cos(fi) + xCenter); 
    389             m_nodes[vertices[ndx]]->set_y(r * sin(fi) + yCenter); 
     393                        m_nodes[vertices[ndx]]->set_coordinates(r * cos(fi) + xCenter, r * sin(fi) + yCenter); 
    390394            vertices.erase(vertices.begin() + ndx); 
    391395        } 
    392396        fi = fi - step; 
    393397    } 
     398    register_points(); 
    394399    return 0; 
    395400} 
     
    556561    vertices.clear(); 
    557562    qvertices.clear(); 
     563         
     564        register_points(); 
     565         
    558566    return 0; 
    559567} 
     
    575583    foreach (const NodeItem*   node, m_nodes) 
    576584    { 
    577         DataPoint point; 
    578         point.x = 0; 
    579         point.y = 0; 
    580         disp[node->index()] = point; 
     585        disp[node->index()] = node->coordinates(); 
    581586 
    582587        double x = node->x(); 
     
    734739        if (m_stop_optimization) 
    735740        { 
    736             return 0; 
     741            break; 
    737742        } 
    738743        if (floor(temperature) > cooling_switch) 
     
    746751    } 
    747752 
    748     return 0; 
     753        register_points(); 
     754        return 0; 
    749755} 
    750756 
     
    815821    if (p) 
    816822    { 
    817         DataPoint d; 
    818         d.x = node->x(); 
    819         d.y = node->y(); 
    820         p->remove_point(d, this); 
     823        p->remove_point(node, this); 
    821824    } 
    822825     
     
    10171020        node->set_y(it.value().second); 
    10181021    } 
     1022    register_points(); 
    10191023} 
    10201024 
     
    10591063        foreach (NodeItem* node, m_nodes) 
    10601064        { 
    1061             DataPoint d; 
    1062             d.x = node->x(); 
    1063             d.y = node->y(); 
    1064             p->add_point(d, node, this); 
     1065            p->add_point(node, this); 
    10651066        } 
    10661067    } 
  • source/orangeplot/plot.cpp

    r8654 r8657  
    295295    foreach (PlotItem* item, plot_items()) 
    296296    { 
    297         if (m_point_set.contains(item) && m_point_set[item].contains(pos) && m_point_hash[item][pos]->is_selected()) 
    298         { 
    299             return m_point_hash[item][pos]; 
     297        if (m_point_set.contains(item) && m_point_set[item].contains(pos)) 
     298        { 
     299            foreach (Point* p, m_point_hash[item].values(pos)) 
     300            { 
     301                if (p->is_selected()) 
     302                { 
     303                    return p; 
     304                } 
     305            } 
    300306        } 
    301307    } 
     
    309315        if (m_point_set.contains(item) && m_point_set[item].contains(pos)) 
    310316        { 
    311             return m_point_hash[item][pos]; 
    312         } 
    313     } 
     317            qDebug() << "Found a point at" << pos; 
     318            return m_point_hash[item].values(pos).first(); 
     319        } 
     320    } 
     321    qDebug() << "No point at" << pos; 
    314322    return 0; 
    315323} 
     
    317325Point* Plot::nearest_point(const QPointF& pos) 
    318326{ 
    319     QPair<double, DataPoint> closest_point = qMakePair( std::numeric_limits<double>::max(), DataPoint() ); 
     327    QPair<double, Point*> closest_point; 
     328    closest_point.first = std::numeric_limits<double>::max(); 
     329    closest_point.second = 0; 
     330     
    320331    foreach (PlotItem* item, plot_items()) 
    321332    { 
    322         Q_ASSERT(m_point_set[item].toList() == m_point_hash[item].keys()); 
    323333        if (!m_point_set.contains(item)) 
    324334        { 
    325335            continue; 
    326336        } 
    327         PointSet::ConstIterator it = m_point_set[item].constBegin(); 
    328         PointSet::ConstIterator end = m_point_set[item].constEnd(); 
    329         for (it; it != end; ++it) 
    330         { 
    331             const double d = distance(m_point_hash[item][*it]->pos(), pos); 
     337        foreach (Point* p, m_point_hash[item]) 
     338        { 
     339            const double d = distance(p->pos(), pos); 
    332340            if (d < closest_point.first) 
    333341            { 
    334342                closest_point.first = d; 
    335                 closest_point.second = *it; 
    336             } 
    337         } 
    338     } 
    339     Point* point = point_at(closest_point.second); 
    340     if(point && distance(point->pos(), pos) <= point->size()) 
    341     { 
    342         return point; 
     343                closest_point.second = p; 
     344            } 
     345        } 
     346    } 
     347    if(closest_point.second && closest_point.first <= closest_point.second->size()) 
     348    { 
     349        return closest_point.second; 
    343350    } 
    344351    else 
     
    348355} 
    349356 
    350 void Plot::add_point(const DataPoint& pos, Point* item, PlotItem* parent) 
    351 { 
     357void Plot::add_point(Point* point, PlotItem* parent) 
     358{ 
     359    const DataPoint pos = point->coordinates(); 
    352360    m_point_set[parent].insert(pos); 
    353     m_point_hash[parent].insert(pos, item); 
    354 } 
    355  
    356 void Plot::add_points(const Data& data, const QList< Point* >& items, PlotItem* parent) 
    357 { 
    358     const int n = qMin(data.size(), items.size()); 
    359     for (int i = 0; i < n; ++i) 
    360     { 
    361         add_point(data[i], items[i], parent); 
    362     } 
    363 } 
    364  
    365 void Plot::remove_point(const DataPoint& pos, PlotItem* parent) 
    366 { 
     361    m_point_hash[parent].insert(pos, point); 
     362} 
     363 
     364void Plot::add_points(const QList< Point* >& items, PlotItem* parent) 
     365{ 
     366    foreach (Point* p, items) 
     367    { 
     368        add_point(p, parent); 
     369    } 
     370} 
     371 
     372void Plot::remove_point(Point* point, PlotItem* parent) 
     373{ 
     374    const DataPoint pos = point->coordinates(); 
    367375    if (m_point_set.contains(parent) && m_point_set[parent].contains(pos)) 
    368376    { 
    369377        m_point_set[parent].remove(pos); 
    370         m_point_hash[parent].remove(pos); 
     378        m_point_hash[parent].remove(pos, point); 
    371379    } 
    372380} 
     
    374382void Plot::remove_all_points(PlotItem* parent) 
    375383{ 
    376     if (m_point_set.contains(parent)) 
    377     { 
    378         m_point_set.remove(parent); 
    379         m_point_hash.remove(parent); 
    380     } 
     384    m_point_set.remove(parent); 
     385    m_point_hash.remove(parent); 
    381386} 
    382387 
  • source/orangeplot/plot.h

    r8654 r8657  
    2424     
    2525    typedef QSet<DataPoint> PointSet; 
    26     typedef QHash<DataPoint, Point*> PointHash; 
     26    typedef QMultiHash<DataPoint, Point*> PointHash; 
    2727 
    2828     
     
    6767    Point* selected_point_at(const DataPoint& pos); 
    6868     
    69     void add_point(const DataPoint& pos, Point* item, PlotItem* parent); 
    70     void add_points(const Data& data, const QList<Point*>& items, PlotItem* parent); 
    71     void remove_point(const DataPoint& pos, PlotItem* parent); 
     69    void add_point(Point* point, PlotItem* parent); 
     70    void add_points(const QList<Point*>& items, PlotItem* parent); 
     71    void remove_point(Point* point, PlotItem* parent); 
    7272    void remove_all_points(PlotItem* parent); 
    7373     
  • source/orangeplot/point.cpp

    r8635 r8657  
    2828} 
    2929 
     30QDebug& operator<<(QDebug& stream, const DataPoint& point) 
     31{ 
     32    stream.maybeSpace() << "DataPoint(" << point.x << ','<< point.y << ')'; 
     33} 
     34 
     35bool operator==(const DataPoint& one, const DataPoint& other) 
     36{ 
     37    return one.x == other.x && one.y == other.y; 
     38} 
    3039 
    3140Point::Point(int symbol, QColor color, int size, QGraphicsItem* parent): QGraphicsItem(parent), 
  • source/orangeplot/point.h

    r8633 r8657  
    33 
    44#include <QtGui/QGraphicsItem> 
     5#include <QtCore/QDebug> 
    56 
    67 
     
    1011  double y; 
    1112}; 
     13 
     14QDebug& operator<<(QDebug& stream, const DataPoint& point); 
     15bool operator==(const DataPoint& one, const DataPoint& other); 
    1216 
    1317struct PointData 
     
    2024    bool transparent; 
    2125}; 
    22  
    23 uint qHash(const PointData& data); 
    24 bool operator==(const PointData& one, const PointData& other); 
    2526 
    2627class Point : public QGraphicsItem 
Note: See TracChangeset for help on using the changeset viewer.