/*!
\brief Complete a polygon to be a closed polygon
including the area between the original polygon
and the baseline.
\param xMap X map
\param yMap Y map
\param pa Polygon to be completed
*/
void QwtPlotCurve::closePolyline(
const QwtScaleMap &xMap, const QwtScaleMap &yMap,
QwtPolygon &pa) const
{
const int sz = pa.size();
if ( sz < 2 )
return;
pa.resize(sz + 2);
if ( d_data->curveType == QwtPlotCurve::Xfy )
{
pa.setPoint(sz,
xMap.transform(d_data->reference), pa.point(sz - 1).y());
pa.setPoint(sz + 1,
xMap.transform(d_data->reference), pa.point(0).y());
}
else
{
pa.setPoint(sz,
pa.point(sz - 1).x(), yMap.transform(d_data->reference));
pa.setPoint(pa.size() - 1,
pa.point(0).x(), yMap.transform(d_data->reference));
}
}
void QwtPolygonClipper::clipEdge(Edge edge,
const QwtPolygon &pa, QwtPolygon &cpa) const
{
if ( pa.count() == 0 )
{
cpa.resize(0);
return;
}
unsigned int count = 0;
QPoint p1 = pa.point(0);
if ( insideEdge(p1, edge) )
addPoint(cpa, count++, p1);
const uint nPoints = pa.size();
for ( uint i = 1; i < nPoints; i++ )
{
const QPoint p2 = pa.point(i);
if ( insideEdge(p2, edge) )
{
if ( insideEdge(p1, edge) )
addPoint(cpa, count++, p2);
else
{
addPoint(cpa, count++, intersectEdge(p1, p2, edge));
addPoint(cpa, count++, p2);
}
}
else
{
if ( insideEdge(p1, edge) )
addPoint(cpa, count++, intersectEdge(p1, p2, edge));
}
p1 = p2;
}
cpa.resize(count);
}
/**
* When y-axis is clicked, the pixel coordinates are converted to graph coordinates, and displayed in a pop-up menu.
* @param &y :: A reference to a click on the y-axis.
*/
void LabelTool::yAxisClicked(const QwtPolygon &y)
{
populateMantidCurves();
// Obtains the x value of the pixel coordinate.
QPoint yy = y.point(0);
int yPosition = yy.y();
// Obtains the origins of the graph area and of the axis.
QPoint canvasOrigin = d_graph->plotWidget()->canvas()->pos();
int canvasOriginY = canvasOrigin.y();
QPoint yOrigin = d_graph->plotWidget()->axisWidget(QwtPlot::yLeft)->pos();
int yAxisOriginYValue = yOrigin.y();
/**
* The difference in the origins is calculated then taken into account when converting the pixel coordinates of the
* axis into graph coordinates.
*/
int deltaOrigins = canvasOriginY - yAxisOriginYValue;
int yPositionCorrected = yPosition - deltaOrigins;
double yPos = d_graph->plotWidget()->invTransform(QwtPlot::yLeft, yPositionCorrected);
if( yPos < 0)
{
return;
}
std::stringstream precisionValue;
precisionValue.precision(6);
precisionValue << yPos;
m_yPosSigFigs = precisionValue.str();
QMenu * clickMenu = new QMenu(d_graph);
QAction * addYAxisLabel = new QAction(tr(QString::fromStdString(m_yPosSigFigs.c_str())), this);
clickMenu->addAction(addYAxisLabel);
connect(addYAxisLabel,SIGNAL(triggered()), this, SLOT(insertYCoord()));
clickMenu->insertSeparator();
clickMenu->exec(QCursor::pos());
}
/**
* When x-axis is clicked, the pixel coordinates are converted to graph
* coordinates, and displayed in a pop-up menu.
* @param &x :: A reference to a click on the x-axis.
*/
void LabelTool::xAxisClicked(const QwtPolygon &x) {
populateMantidCurves();
// Obtains the x value of the pixel coordinate.
QPoint xx = x.point(0);
int xPosition = xx.x();
// Obtains the origins of the graph area and of the axis.
QPoint canvasOrigin = d_graph->plotWidget()->canvas()->pos();
int canvasOriginX = canvasOrigin.x();
QPoint xOrigin = d_graph->plotWidget()->axisWidget(QwtPlot::xBottom)->pos();
int xAxisOriginXValue = xOrigin.x();
/**
* The difference in the origins is calculated then taken into account when
* converting the pixel coordinates of the
* axis into graph coordinates.
*/
int deltaOrigins = canvasOriginX - xAxisOriginXValue;
int xPositionCorrected = xPosition - deltaOrigins;
double xPos =
d_graph->plotWidget()->invTransform(QwtPlot::xBottom, xPositionCorrected);
if (xPos < 0) {
return;
}
m_xPosSigFigs.setNum(xPos, 'f', 6);
QMenu *clickMenu = new QMenu(d_graph);
QAction *addXAxisLabel = new QAction(m_xPosSigFigs, this);
clickMenu->addAction(addXAxisLabel);
connect(addXAxisLabel, SIGNAL(triggered()), this, SLOT(insertXCoord()));
clickMenu->exec(QCursor::pos());
}
/**
* When the graph area is clicked, pixel coordinates are found and used to
* determine graph coordinates.
* Determines the number of MMCs from the list in populateMantidCurves().
* For each MMC, determines whether a click on the graph area is within close
* proximity to a data point.
* If it is, the coordinates of the data point are stored for display.
* @param &c :: A reference to a click on the graph area; it is bound by the x
* and y-axis.
*/
void LabelTool::graphAreaClicked(const QwtPolygon &c) {
populateMantidCurves();
m_dataCoords.clear();
QPoint cc = c.point(0);
int xPosition = cc.x();
int yPosition = cc.y();
// std::cout << "xPosition: " << xPosition << " " << "yPosition: " <<
// yPosition << '\n';
m_xPos = d_graph->plotWidget()->invTransform(QwtPlot::xBottom, xPosition);
m_yPos = d_graph->plotWidget()->invTransform(QwtPlot::yLeft, yPosition);
// Sets the tolerance value, in pixels, for the range in which to search for a
// data point.
int tolerance = 7;
foreach (MantidMatrixCurve *mantidMatrixCurve, m_mantidMatrixCurves) {
// Sets the upper and lower limits in pixel coordinates for the x and
// y-axes.
int upperLimitX = xPosition + tolerance;
int lowerLimitX = xPosition - tolerance;
int upperLimitY = yPosition + tolerance;
int lowerLimitY = yPosition - tolerance;
/*
// Gets the workspace name for which the curve belongs to.
QString workspaceNameOfCurve = mantidMatrixCurve->workspaceName();
*/
// Gets the number of data points on the curve.
auto *mwd = mantidMatrixCurve->mantidData();
size_t numberOfDataPoints = mwd->size();
/**
* Gets the pixel value of the x-coordinate value of each data point within
* range.
* Of the data points within range along x-axis, finds out if the pixel
* values of their y-coordinates are within range.
* If they are, their position within the iteration - i - is stored in a set.
*/
QSet<size_t> pointsWithinRange;
for (size_t i = 0; i < numberOfDataPoints; ++i) {
// The pixel values of the x and y coordinates of the data points.
int iPixelValueX =
d_graph->plotWidget()->transform(QwtPlot::xBottom, mwd->x(i));
int iPixelvalueY =
d_graph->plotWidget()->transform(QwtPlot::yLeft, mwd->y(i));
// Comparing the point of clicking with the positioning of the data
// points.
if (((iPixelValueX <= upperLimitX) && (iPixelValueX >= lowerLimitX)) &&
((iPixelvalueY <= upperLimitY) && (iPixelvalueY >= lowerLimitY))) {
pointsWithinRange.insert(i);
}
}
// If there are points within the specified ranges.
if (!pointsWithinRange.isEmpty()) {
/**
* Uses Pythagoras' theorem to calculate the distance between the position
* of a click and
* the surrounding data points that lie within both the x and y ranges.
*/
QMap<double, size_t> map;
foreach (size_t i, pointsWithinRange) {
double deltaX = m_xPos - mwd->x(i);
double deltaY = m_yPos - mwd->y(i);
double deltaXSquared = deltaX * deltaX;
double deltaYSquared = deltaY * deltaY;
double distance = sqrt(deltaXSquared + deltaYSquared);
map[distance] = i;
}