Need guidelines to handle the duo curve legend selection

Hello,

Like it's possible to do easily in QCustomPlot, I need some guidelines that will allow me to select a curve and highlight it, by changing its color and highlight its legend item (QwtPlotLegendItem).

I need also to do that in reverse : by selecting the legend, I highlight it and its corresponding curve.

Thank you.

You can change the color of a curve and you can click legend items - what type of guideline do you expect ?

Uwe

Hi Uwe,

When I click on a curve point/line (or near them), I catch that event (BTW, I installed an event filter, an external object, on the QwtPlot object) and then how can I get a pointer to the "selected" item (the QwtPlotCurve) ?

Speaking of clicking on the QwtPlotLegendItem, I tried also to show a context menu by right clicking inside the legend box, but it's not accurate (read the comment I added in the code) :

NB: pos is fed from QMouseEvent::pos method that is executed inside the event filter installed on QwtPlot object.

Code:

---

void MyQwtPlotManager::contextMenuRequest(const QPoint& pos)
{
   QMenu*const menuContext = new QMenu(m_pParent);
   menuContext->setAttribute(Qt::WA_DeleteOnClose);
 
   /*QRect legRec = m_legendItem->geometry(m_pChart->canvas()->rect());
   std::cout << "[debug] legend rect LTRB = "
             << legRec.left() << ","
             << legRec.top() << ","
             << legRec.right() << ","
             << legRec.bottom() << std::endl;
   std::cout << "[debug] mouse pos xy = " << pos.x() << "," << pos.y() << std::endl;*/
 
   // NB: mouse is inside the legend but I got these values :
   // mouse : (997, 46)
   // legend left,top,right,bottom : 880, 10, 1317, 36
 
   if (m_legendItem && m_legendItem->geometry(m_pQwtPlot->canvas()->rect()).contains(pos))
   {
       // add actions related to the legend.
       ....
       ....
   }
}

---

Then, if I succeed in selecting a curve legend among the others, I don't know how to retrieve the associated curve !

Meanwhile, I will have a look to the "event_filter" example.

Thanks.

Quote:

---

Speaking of clicking on the QwtPlotLegendItem, I tried also to show a context menu by right clicking inside the legend box, but it's not accurate (read the comment I added in the code) :
NB: pos is fed from QMouseEvent::pos method that is executed inside the event filter installed on QwtPlot object.

---

QwtPlot is a a composite widget and you are in the coordinate system of the plot canvas.
You have to set up an event filter for the plot canvas ( recommended ) instead or you have to translate the position. F.e. see QWidget::mapTo/mapFrom or in this simple case: pos -= canvas().pos();

Uwe

Hello Uwe,

Hope you're doing well.

By order of priority :

* There's QwtPlotCurve::closestPoint that can allow me to check that the mouse pointer is closer to a point of the curve. But it doesn't take in account the line joining 2 points of the curve : like I said above, I want to highlight the curve by clicking on it : usually the click location is a line... is there an easy way to do it ? I don't know if closestPoint can be used with some simple Trigonometry to check that the mouse cursor is closer to a curve line :confused:

* Qt question : can you tell me please, why in the implementation below, line 65, when I return "true", the replot() I did it before it, doesn't refresh the curve with the new pen width ?

* I didn't find a "proper" way to modify the font of an already existing legend (look at highlightSelectedLegend below), it is not important for now, but can you propose a strategy ? is it impossible ?

I post my code below (an event filter class), it works fine to highlight/deselect a single curve by clicking on a point on it/elsewhere or by clicking on its legend (select/deselect), it doesn't affect panning.

If you have improvements, I'm really interested.

Header :

Code:

---

#ifndef CANVASPICKER_H
#define CANVASPICKER_H
 
#include <QObject>
#include <QPoint>
 
class QwtPlot;
class QwtPlotCurve;
class QwtPlotLegendItem;
 
class CanvasPicker: public QObject
{
    Q_OBJECT
public:
    CanvasPicker(QwtPlot* plot);
    bool eventFilter(QObject*, QEvent*) override;
 
    QwtPlotCurve* selectedCurve()
    {
        return isCurveStillAlive(m_lastSelectedCurve) ? m_lastSelectedCurve : nullptr;
    }
 
protected:
    void select(const QPoint&); // curve/legend selection
 
    QwtPlot* plot();
    const QwtPlot* plot() const;
 
protected:
    QPoint m_mousePressPosition;
 
private:
    void highlightSelectedCurve(QwtPlotCurve* curve);
    bool deselectLastSelectedCurve();
    // Not easy to code.
    //void highlightSelectedLegend(QwtPlotLegendItem* legend, QwtPlotCurve* curve);
 
    // Sadly, we can't use weak pointers on QwtPlotCurve.
    // Will be used to deselect the last selected curve.
    bool isCurveStillAlive(QwtPlotCurve*) const;
 
private:
    QwtPlotCurve* m_lastSelectedCurve;
 
};
 
#endif

---

Implementation :

Code:

---

#include <QMouseEvent>
 
#include <qwt_plot.h>
#include <qwt_plot_canvas.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_legenditem.h>
 
#include "CanvasPicker.h"
 
CanvasPicker::CanvasPicker(QwtPlot* plot) :
    QObject(plot),
    m_lastSelectedCurve(nullptr)
{
    QwtPlotCanvas* canvas = qobject_cast<QwtPlotCanvas*>(plot->canvas());
    canvas->installEventFilter(this);
 
    // We want the focus, but no focus rect. The
    // selected point will be highlighted instead.
    canvas->setFocusPolicy(Qt::StrongFocus);
#ifndef QT_NO_CURSOR
    canvas->setCursor(Qt::PointingHandCursor);
#endif
    canvas->setFocusIndicator(QwtPlotCanvas::ItemFocusIndicator);
    canvas->setFocus();
}
 
QwtPlot* CanvasPicker::plot()
{
    return qobject_cast<QwtPlot*>(parent());
}
 
const QwtPlot* CanvasPicker::plot() const
{
    return qobject_cast<const QwtPlot*>(parent());
}
 
bool CanvasPicker::eventFilter(QObject* object, QEvent* event)
{
    if (plot() == nullptr || object != plot()->canvas())
    {
        return false;
    }
 
    switch (event->type())
    {
        case QEvent::MouseButtonPress:
        {
            const QMouseEvent* const mouseEvent = static_cast<QMouseEvent*>(event);
            if (mouseEvent->button() & Qt::LeftButton)
            {
                m_mousePressPosition = mouseEvent->pos();
            }
            break;
        }
 
        case QEvent::MouseButtonRelease:
        {
            const QMouseEvent* const mouseEvent = static_cast<QMouseEvent*>(event);
            const QPoint mouseReleasePosition = mouseEvent->pos();
            if (mouseEvent->button() & Qt::LeftButton)
            {
                if (m_mousePressPosition == mouseReleasePosition)
                {
                    select(mouseEvent->pos());
                    //return true; // blocks painting ??!!??
                }
            }
            break;
        }
 
        default:
            break;
    }
 
    return QObject::eventFilter(object, event);
}
 
void CanvasPicker::select(const QPoint& pos)
{
    // 1. check if the legend has been clicked on
    QwtPlotItemList curveList = plot()->itemList(QwtPlotItem::Rtti_PlotCurve);
    if (curveList.isEmpty())
    {
        return;
    }
 
    // we only have one legend item
    QwtPlotItemList legendList = plot()->itemList(QwtPlotItem::Rtti_PlotLegend);
    QwtPlotLegendItem* legendItem = (legendList.size() > 0) ? \
                static_cast<QwtPlotLegendItem*>(legendList[0]) : nullptr;
    QVector<QList<QRect>> curveLegendGeometries;
    if (legendItem &&
        legendItem->geometry(plot()->canvas()->rect()).contains(pos))
    {
        for (auto curveItem : curveList)
        {
            //QwtPlotCurve* curve = static_cast<QwtPlotCurve*>(curveItem);
            curveLegendGeometries.push_back(legendItem->legendGeometries(curveItem));
        }
    }
 
    if (!curveLegendGeometries.isEmpty())
    {
        auto it = std::find_if(curveLegendGeometries.begin(), curveLegendGeometries.end(),
                               [&pos](const QList<QRect>& listRect) -> bool
                               {
                                   for (const auto& rect : listRect)
                                   {
                                       if (rect.contains(pos))
                                       {
                                           return true;
                                       }
                                   }
                                   return false;
                               });
        if (it != curveLegendGeometries.end())
        {
            // or a simple substraction...
            auto curveIndex = std::distance(curveLegendGeometries.begin(), it);
            if (curveIndex < curveList.size())
            {
                QwtPlotCurve* legendCurve = static_cast<QwtPlotCurve*>(curveList[int(curveIndex)]);
                if (m_lastSelectedCurve == legendCurve)
                {
                    deselectLastSelectedCurve();
                }
                else
                {
                    highlightSelectedCurve(legendCurve);
                }
 
                //highlightSelectedLegend(legendItem, legendCurve);
 
                // Immediate paint doesn't work !
                //QwtPlotCanvas* plotCanvas = qobject_cast<QwtPlotCanvas*>(plot()->canvas());
                //plotCanvas->setPaintAttribute(QwtPlotCanvas::ImmediatePaint, true);
                plot()->replot();
                //plotCanvas->setPaintAttribute(QwtPlotCanvas::ImmediatePaint, false);
            }
 
            return;
        }
        else
        {
            if (deselectLastSelectedCurve())
            {
                plot()->replot();
            }
        }
    }
 
    // 2. check if a curve has been selected
    QwtPlotCurve* closestCurve = nullptr;
    double minDistance = 10e10;
    {
        double tmp;
        for (const auto curve : curveList)
        {
            QwtPlotCurve* const c = static_cast<QwtPlotCurve*>(curve);
            c->closestPoint(pos, &tmp);
            if (tmp < minDistance)
            {
                closestCurve = c;
                minDistance = tmp;
            }
        }
    }
 
    if (closestCurve && minDistance < 10) // 10 pixels tolerance
    {
        if (m_lastSelectedCurve == closestCurve)
        {
            deselectLastSelectedCurve();
        }
        else
        {
            highlightSelectedCurve(closestCurve);
        }
 
        //QwtPlotCanvas* plotCanvas = qobject_cast<QwtPlotCanvas*>(plot()->canvas());
        //plotCanvas->setPaintAttribute(QwtPlotCanvas::ImmediatePaint, true);
        plot()->replot();
        //plotCanvas->setPaintAttribute(QwtPlotCanvas::ImmediatePaint, false);
    }
    else
    {
        if (deselectLastSelectedCurve())
        {
            plot()->replot();
        }
    }
}
 
bool CanvasPicker::isCurveStillAlive(QwtPlotCurve* curve) const
{
    if (!curve)
    {
        return false;
    }
    const QwtPlotItemList& curveList = plot()->itemList();
    return (std::find(curveList.begin(), curveList.end(), static_cast<QwtPlotItem*>(curve))
            != curveList.end());
}
 
void CanvasPicker::highlightSelectedCurve(QwtPlotCurve* curve)
{
    // Deselect last selected curve !
    deselectLastSelectedCurve();
 
    QPen originalPen = curve->pen();
    originalPen.setWidth(originalPen.width() + 1);
    curve->setPen(originalPen);
    m_lastSelectedCurve = curve;
}
 
bool CanvasPicker::deselectLastSelectedCurve()
{
    if (m_lastSelectedCurve != nullptr && isCurveStillAlive(m_lastSelectedCurve))
    {
        QPen originalPen = m_lastSelectedCurve->pen();
        originalPen.setWidth(originalPen.width() - 1);
        m_lastSelectedCurve->setPen(originalPen);
 
        m_lastSelectedCurve = nullptr;
 
        return true;
    }
    return false;
}
 
#if 0
// The API is not very friendly, let's just only highlight the curve, it's sufficient for now :(
void CanvasPicker::highlightSelectedLegend(QwtPlotLegendItem* legend, QwtPlotCurve* curve)
{
    // legendData: The default implementation returns one entry with the title()
    // of the item and the legendIcon().
    QList<QwtLegendData> originalLegData = curve->legendData();
    if (originalLegData.size() > 0)
    {
        originalLegData[0].value(QwtLegendData::TitleRole);
        //............
    }
 
    legend->updateLegend(curve, originalLegData);
}
#endif

---

For those who are interested, I wrote a function version of closestPoint that takes in account the line between 2 points, I was inspired by the code of Qcp. It works pretty well !

Code:

---

// Finds the shortest squared distance of point to the line segment defined by lineStart and
// lineEnd.
double squaredDistanceToLine(const QPointF& lineStart, const QPointF& lineEnd, const QPointF& point)
{
    QVector2D a(lineStart);
    QVector2D b(lineEnd);
    QVector2D p(point);
    QVector2D v(b - a);
 
    double vLengthSqr = double(v.lengthSquared());
    if (!qFuzzyIsNull(vLengthSqr))
    {
        double mu = double(QVector2D::dotProduct(p - a, v)) / vLengthSqr;
        if (mu < 0)
        {
            return double((a - p).lengthSquared());
        }
        else if (mu > 1)
        {
            return double((b - p).lengthSquared());
        }
        else
        {
            return double(((a + float(mu) * v) - p).lengthSquared());
        }
    }
 
    return double((a - p).lengthSquared());
}
 
// modified method to take in account the line joining 2 points
// if
/*!
  Find the closest curve point for a specific position
 
  \param curve, Curve
  \param pos Position, where to look for the closest curve point
  \param dist If dist != NULL, closestPoint() returns the distance between
              the position and the closest curve point
  \return Index of the closest curve point, or -1 if none can be found
          ( f.e when the curve has no points )
  \note closestPoint() implements a dumb algorithm, that iterates
        over all points
*/
int closestPoint(QwtPlotCurve* curve, const QPoint& pos, double* dist)
{
    const size_t numSamples = curve->dataSize();
 
    if (curve->plot() == nullptr || numSamples == 0)
    {
        // no data available in view to calculate distance to
        return -1;
    }
 
    const QwtSeriesData<QPointF>* series = curve->data();
 
    const QwtScaleMap xMap = curve->plot()->canvasMap( curve->xAxis() );
    const QwtScaleMap yMap = curve->plot()->canvasMap( curve->yAxis() );
 
    int index = -1;
    double dmin = 1.0e10; // or std::numeric_limits<double>::max();
 
    if (curve->style() != QwtPlotCurve::Lines || numSamples == 1)
    {
        // there's no lines joining points or there's only a single data point
        for (uint i = 0; i < numSamples; i++)
        {
            const QPointF sample = series->sample( i );
 
            const double cx = xMap.transform(sample.x()) - pos.x();
            const double cy = yMap.transform(sample.y()) - pos.y();
 
            const double f = qwtSqr(cx) + qwtSqr(cy);
            if (f < dmin)
            {
                index = int(i);
                dmin = f;
            }
        }
    }
    else
    {
        // if we are here, there's at least one line segment.
        // calculate distance to line segments.
        for (uint i = 0; i < numSamples - 1; i++)
        {
            const QPointF sample  = series->sample(i);
            const QPointF sample2 = series->sample(i + 1);
 
            const QPointF lineStart(xMap.transform(sample.x()), yMap.transform(sample.y()));
            const QPointF lineEnd(xMap.transform(sample2.x()), yMap.transform(sample2.y()));
 
            const double f = squaredDistanceToLine(lineStart, lineEnd, pos);
            if (f < dmin)
            {
                index = int(i);
                dmin = f;
            }
        }
    }
 
    if (dist)
    {
        *dist = qSqrt(dmin);
    }
 
    return index;
}

---

In case your points are sorted in x or y direction you can find much more efficient implementations - like in CurveTracker::curveLineAt in the curvetracker example.
Implementations like QwtPlotCurve::closestPoint - or your adaption - are slow as they are iterating over all points and you often find better solutions using the characteristics of the data or by introducing extra data structures like an R-Tree ( https://www.boost.org/doc/libs/1_63_...roduction.html ).

Not sure, why you are using floats ( QVector2D instead of QLineF ) - but finding the distance between a point and a line is basic school maths and absolutely no reason to violate the GPL by copying trivialities into the source code of your commercial project !

Uwe

Hi Uwe,

I didn't see the CurveTracker example as it's placed in "playground" dir...

Quote:

---

Not sure, why you are using floats ( QVector2D instead of QLineF ) - but finding the distance between a point and a line is basic school maths and absolutely no reason to violate the GPL by copying trivialities into the source code of your commercial project !

---

How the GPL is violated in my case ? by using QVector2D or because I copied a method from Qcp (I will change it anyway - the method in question uses QVector2D). I will change it !

Quote:

---

is basic school maths

---

Not so basic (not like the Pythagorean theorem for example), and I didn't remember I was taught this thing in school like a basic stuff (anyway, the educational system of the country where I was born sucks so hard (and the country too ;) ) ).

Thanks.

Quote:

---

Originally Posted by embeddedmz

How the GPL is violated in my case ? by using QVector2D or because I copied a method from Qcp

---

Copying code from another project comes with obligations for what you have to do with your code then - what those exactly are depends on the license.
Note that I recently changed the license of the Qwt examples to a BSD license ( >= Qwt 6.2 ).

Uwe