// Применение изменений по вращении колеса мыши
void QWheelZoomSvc::applyWheel(QEvent *event,bool ax,bool ay)
{
// приводим тип QEvent к QWheelEvent
QWheelEvent *wEvent = static_cast<QWheelEvent *>(event);
// если вращается вертикальное колесо мыши
if (wEvent->orientation() == Qt::Vertical)
{
// определяем угол поворота колеса мыши
// (значение 120 соответствует углу поворота 15°)
int wd = wEvent->delta();
// вычисляем масштабирующий множитель
// (во сколько раз будет увеличен/уменьшен график)
double kw = sfact*wd/120;
if (wd != 0) // если колесо вращалось, то
{
// фиксируем исходные границы графика (если этого еще не было сделано)
zoom->fixBounds();
// получаем указатель на график
QwtPlot *plt = zoom->plot();
if (ax) // если задано масштабирование по горизонтали
{
// получаем карту основной горизонтальной шкалы
QwtScaleMap sm = plt->canvasMap(zoom->masterH());
// определяем центр отображаемого на шкале x интервала
double mx = (sm.s1()+sm.s2())/2;
// и полуширину интервала
double dx = (sm.s2()-sm.s1())/2;
// в зависимости от знака угла поворота колеса мыши
// уменьшаем полуширину отображаемых интервалов в kw раз
if (wd > 0) dx /= kw;
// или увеличиваем полуширину отображаемых интервалов в -kw раз
else dx *= -kw;
// устанавливаем новые левую и правую границы шкалы для оси x
// (центр изображаемой части графика остается на месте,
// а границы удаляются от центра, т.о. изображение графика уменьшается)
zoom->isb_x->set(mx-dx,mx+dx);
}
if (ay) // если задано масштабирование по вертикали
{
// получаем карту основной вертикальной шкалы
QwtScaleMap sm = plt->canvasMap(zoom->masterV());
// определяем центр отображаемого на шкале y интервала
double my = (sm.s1()+sm.s2())/2;
// и полуширину интервала
double dy = (sm.s2()-sm.s1())/2;
// в зависимости от знака угла поворота колеса мыши
// уменьшаем полуширину отображаемых интервалов в kw раз
if (wd > 0) dy /= kw;
// увеличиваем полуширину отображаемых интервалов в -kw раз
else dy *= -kw;
// устанавливаем новые нижнюю и верхнюю границы вертикальной шкалы
// (центр изображаемой части графика остается на месте,
// а границы удаляются от центра, т.о. изображение графика уменьшается)
zoom->isb_y->set(my-dy,my+dy);
}
// перестраиваем график (синхронно с остальными)
plt->replot();
}
}
}
/*!
Redraw the canvas items.
\param painter Painter used for drawing
\param azimuthMap Maps azimuth values to values related to 0.0, M_2PI
\param radialMap Maps radius values into painter coordinates.
\param pole Position of the pole in painter coordinates
\param radius Radius of the complete plot area in painter coordinates
\param canvasRect Contents rect of the canvas in painter coordinates
*/
void QwtPolarPlot::drawItems( QPainter *painter,
const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,
const QPointF &pole, double radius,
const QRectF &canvasRect ) const
{
const QRectF pr = plotRect( canvasRect );
const QwtPolarItemList& itmList = itemList();
for ( QwtPolarItemIterator it = itmList.begin();
it != itmList.end(); ++it )
{
QwtPolarItem *item = *it;
if ( item && item->isVisible() )
{
painter->save();
// Unfortunately circular clipping slows down
// painting a lot. So we better try to avoid it.
bool doClipping = false;
if ( item->rtti() != QwtPolarItem::Rtti_PolarGrid )
{
const QwtInterval intv =
item->boundingInterval( QwtPolar::Radius );
if ( !intv.isValid() )
doClipping = true;
else
{
if ( radialMap.s1() < radialMap.s2() )
doClipping = intv.maxValue() > radialMap.s2();
else
doClipping = intv.minValue() < radialMap.s2();
}
}
if ( doClipping )
{
const int margin = item->marginHint();
const QRectF clipRect = pr.adjusted(
-margin, -margin, margin, margin );
if ( !clipRect.contains( canvasRect ) )
{
QRegion clipRegion( clipRect.toRect(), QRegion::Ellipse );
painter->setClipRegion( clipRegion, Qt::IntersectClip );
}
}
painter->setRenderHint( QPainter::Antialiasing,
item->testRenderHint( QwtPolarItem::RenderAntialiased ) );
item->draw( painter, azimuthMap, radialMap,
pole, radius, canvasRect );
painter->restore();
}
}
}
/// Draw curve in Steps style
void FunctionCurve::drawSteps(QPainter *painter,
const QwtScaleMap &xMap, const QwtScaleMap &yMap,
const QRect &canvasRect) const
{
const double start = xMap.s1();
const double end = xMap.s2();
const size_t n = m_x->size();
// find first point to draw which is 0 or the one before first visible
size_t istart = 0;
for(; istart < n; ++istart)
{
const double& x = (*m_x)[istart];
if ( x < start ) continue;
if ( x > end ) break;
if ( istart > 0 ) --istart;
break;
}
if ( istart >= n ) return;
size_t iend = n;
bool doDrawSymbols = m_symbol->style() != QwtSymbol::NoSymbol;
if ( doDrawSymbols && m_pointCoords.size() != n )
{
m_pointCoords.resize(n);
}
// draw the points
int x1 = xMap.transform((*m_x)[istart]);
int y1 = yMap.transform(m_y.getCalculated(istart));
if ( doDrawSymbols )
{
m_pointCoords[istart] = QPoint(x1,y1);
}
for(size_t i = istart + 1; i < n; ++i)
{
const double& x = (*m_x)[i];
if ( x > end )
{
iend = i;
break;
}
int x2 = xMap.transform(x);
int y2 = yMap.transform(m_y.getCalculated(i));
painter->drawLine(x1,y1,x2,y1);
painter->drawLine(x2,y1,x2,y2);
x1 = x2;
y1 = y2;
if ( doDrawSymbols )
{
m_pointCoords[i] = QPoint(x1,y1);
}
}
// draw the symbols
if ( doDrawSymbols )
{
drawSymbols(painter,istart,iend);
}
}
/*!
\brief Calculate the bounding rect of the plot area
The plot area depends on the zoom parameters.
\param canvasRect Rectangle of the canvas
\return Rectangle for displaying 100% of the plot
*/
QRectF QwtPolarPlot::plotRect( const QRectF &canvasRect ) const
{
const QwtScaleDiv *sd = scaleDiv( QwtPolar::Radius );
const QwtScaleEngine *se = scaleEngine( QwtPolar::Radius );
const int margin = plotMarginHint();
const QRectF cr = canvasRect;
const int radius = qMin( cr.width(), cr.height() ) / 2 - margin;
QwtScaleMap map;
map.setTransformation( se->transformation() );
map.setPaintInterval( 0.0, radius / d_data->zoomFactor );
map.setScaleInterval( sd->lowerBound(), sd->upperBound() );
double v = map.s1();
if ( map.s1() <= map.s2() )
v += d_data->zoomPos.radius();
else
v -= d_data->zoomPos.radius();
v = map.transform( v );
const QPointF off =
QwtPointPolar( d_data->zoomPos.azimuth(), v ).toPoint();
QPointF center( cr.center().x(), cr.top() + margin + radius );
center -= QPointF( off.x(), -off.y() );
QRectF rect( 0, 0, 2 * map.p2(), 2 * map.p2() );
rect.moveCenter( center );
return rect;
}
/// Reset the fitting range to the current limits on the x axis.
void PlotController::resetRange()
{
QwtScaleMap xMap = m_plot->canvasMap(QwtPlot::xBottom);
double startX = xMap.s1();
double endX = xMap.s2();
m_rangeSelector->setMinimum( startX );
m_rangeSelector->setMaximum( endX );
}
void PeakPickerTool::draw(QPainter *p, const QwtScaleMap &xMap,
const QwtScaleMap &yMap, const QRect &) const {
try {
MantidQt::MantidWidgets::PropertyHandler *h =
m_fitPropertyBrowser->getHandler();
if (!h)
return;
QList<MantidQt::MantidWidgets::PropertyHandler *> peaks = h->getPeakList();
foreach (MantidQt::MantidWidgets::PropertyHandler *peak, peaks) {
double c = peak->centre();
if (c >= xMap.s1() && c <= xMap.s2()) {
int ic = xMap.transform(c);
if (peak ==
m_fitPropertyBrowser->currentHandler()) { // draw current peak
double width = peak->fwhm();
QPen pen;
pen.setColor(QColor(255, 0, 0));
pen.setStyle(Qt::DashLine);
p->setPen(pen);
int x1 = xMap.transform(c - width / 2);
int x2 = xMap.transform(c + width / 2);
QwtPainter::drawLine(p, x1, int(yMap.p1()), x1, int(yMap.p2()));
QwtPainter::drawLine(p, x2, int(yMap.p1()), x2, int(yMap.p2()));
pen.setStyle(Qt::SolidLine);
p->setPen(pen);
int ih = yMap.transform(peak->height() + peak->base());
int ib = yMap.transform(peak->base());
QwtPainter::drawLine(p, ic, ib, ic, ih);
QwtPainter::drawLine(p, x1, ib, x2, ib);
} else {
p->setPen(QPen(QColor(200, 200, 200)));
QwtPainter::drawLine(p, ic, int(yMap.p1()), ic, int(yMap.p2()));
}
}
}
} catch (...) {
// Do nothing
}
QPen pen;
pen.setColor(QColor(0, 0, 255));
pen.setStyle(Qt::DashLine);
p->setPen(pen);
int x1 = xMap.transform(xMin());
int x2 = xMap.transform(xMax());
QwtPainter::drawLine(p, x1, int(yMap.p1()), x1, int(yMap.p2()));
QwtPainter::drawLine(p, x2, int(yMap.p1()), x2, int(yMap.p2()));
pen.setColor(QColor(0, 0, 255));
pen.setStyle(Qt::SolidLine);
p->setPen(pen);
QwtPainter::drawLine(p, x1, int(yMap.p1()), x1 + 3, int(yMap.p1()));
QwtPainter::drawLine(p, x1, int(yMap.p2()), x1 + 3, int(yMap.p2()));
QwtPainter::drawLine(p, x2, int(yMap.p1()), x2 - 3, int(yMap.p1()));
QwtPainter::drawLine(p, x2, int(yMap.p2()), x2 - 3, int(yMap.p2()));
}
QDebug operator<<( QDebug debug, const QwtScaleMap &map )
{
debug.nospace() << "QwtScaleMap("
<< static_cast<int>( map.transformation()->type() )
<< ", s:" << map.s1() << "->" << map.s2()
<< ", p:" << map.p1() << "->" << map.p2()
<< ")";
return debug.space();
}
void PeakPickerTool::resetRange() {
QwtScaleMap xMap = d_graph->plotWidget()->canvasMap(QwtPlot::xBottom);
double s1 = xMap.s1(), s2 = xMap.s2();
double ds = fabs(s2 - s1) * 0.05;
xMin(s1 + ds);
xMax(s2 - ds);
m_fitPropertyBrowser->setStartX(xMin());
m_fitPropertyBrowser->setEndX(xMax());
if (m_fitPropertyBrowser->isAutoBack()) {
m_fitPropertyBrowser->addAutoBackground();
}
d_graph->replot();
}
QRectF
Annotations::boundingRect( double x, double y, const QwtText& label, Qt::Alignment align ) const
{
QSizeF sz = label.textSize();
const QwtScaleMap xMap = plot_.canvasMap( QwtPlot::xBottom );
const QwtScaleMap yMap = plot_.canvasMap( QwtPlot::yLeft );
#if 0
double p1 = xMap.p1(); // device left
double p2 = xMap.p2(); // device right
double s1 = xMap.s1(); // axis left
double s2 = xMap.s2(); // axis right
#endif
QPointF pt( QwtScaleMap::transform( xMap, yMap, QPointF( x, y ) ) );
QRectF rc( QwtScaleMap::transform( xMap, yMap, QRectF( pt, sz ) ) );
adjust( rc, align );
return rc;
}
/*!
\brief Calculate the bounding rect of the plot area
The plot area depends on the zoom parameters.
\param canvasRect Rectangle of the canvas
\return Rectangle for displaying 100% of the plot
*/
QwtDoubleRect QwtPolarPlot::plotRect( const QRect &canvasRect ) const
{
const QwtScaleDiv *sd = scaleDiv( QwtPolar::Radius );
const QwtScaleEngine *se = scaleEngine( QwtPolar::Radius );
const int margin = plotMarginHint();
const QRect cr = canvasRect;
const int radius = qwtMin( cr.width(), cr.height() ) / 2 - margin;
QwtScaleMap map;
map.setTransformation( se->transformation() );
map.setPaintXInterval( 0.0, radius / d_data->zoomFactor );
#if QWT_VERSION < 0x050200
map.setScaleInterval( sd->lBound(), sd->hBound() );
#else
map.setScaleInterval( sd->lowerBound(), sd->upperBound() );
#endif
double v = map.s1();
if ( map.s1() <= map.s2() )
v += d_data->zoomPos.radius();
else
v -= d_data->zoomPos.radius();
v = map.xTransform( v );
const QwtDoublePoint off =
QwtPolarPoint( d_data->zoomPos.azimuth(), v ).toPoint();
QwtDoublePoint center( cr.center().x(), cr.top() + margin + radius );
center -= QwtDoublePoint( off.x(), -off.y() );
QwtDoubleRect rect( 0, 0, 2 * map.p2(), 2 * map.p2() );
rect.moveCenter( center );
return rect;
}
// Обработчик нажатия на кнопку мыши над шкалой
// (включение изменения масштаба шкалы)
void QAxisZoomSvc::startAxisZoom(QMouseEvent *mEvent,int ax)
{
// фиксируем исходные границы графика (если этого еще не было сделано)
zoom->fixBounds();
// если в данный момент еще не включен ни один из режимов
if (zoom->regim() == QwtChartZoom::ctNone)
{
// если нажата левая кнопка мыши, то
// включаем один из режимов масштабирования
if (mEvent->button() == Qt::LeftButton)
{
// получаем указатели на
QwtPlot *plt = zoom->plot(); // график
QwtScaleWidget *sw = plt->axisWidget(ax); // виджет шкалы
// получаем карту основной горизонтальной шкалы
QwtScaleMap sm = plt->canvasMap(zoom->masterH());
// для того чтобы фиксировать начальные левую и правую границы
scb_xl = sm.s1(); scb_xr = sm.s2(); scb_wx = sm.sDist();
// аналогично получаем карту основной вертикальной шкалы
sm = plt->canvasMap(zoom->masterV());
// для того чтобы фиксировать начальные нижнюю и верхнюю границы
scb_yb = sm.s1(); scb_yt = sm.s2(); scb_hy = sm.sDist();
// определяем (для удобства) геометрию
QRect gc = plt->canvas()->geometry(); // канвы графика
QRect gw = sw->geometry(); // и виджета шкалы
// текущее левое смещение графика (в пикселах относительно канвы)
scb_pxl = plt->transform(zoom->masterH(),scb_xl);
// текущая ширина графика (в пикселах)
scb_pw = plt->transform(zoom->masterH(),scb_xr) - scb_pxl;
// текущее левое смещение графика
// (в пикселах относительно виджета шкалы)
sab_pxl = scb_pxl + gc.x() - gw.x();
// текущее верхнее смещение графика (в пикселах относительно канвы)
scb_pyt = plt->transform(zoom->masterV(),scb_yt);
// текущая высота графика (в пикселах)
scb_ph = plt->transform(zoom->masterV(),scb_yb) - scb_pyt;
// текущее верхнее смещение графика
// (в пикселах относительно виджета шкалы)
sab_pyt = scb_pyt + gc.y() - gw.y();
// запоминаем текущее положение курсора относительно канвы
// (за вычетом смещений графика)
scp_x = mEvent->pos().x() - sab_pxl;
scp_y = mEvent->pos().y() - sab_pyt;
// если масштабируется горизонтальная шкала
if (ax == QwtPlot::xBottom ||
ax == QwtPlot::xTop)
{
// если левая граница меньше правой,
if (scb_wx > 0)
// если ширина канвы больше минимума,
if (scb_pw > 36)
{
// в зависимости от положения курсора
// (правее или левее середины шкалы)
// включаем соответствующий режим - изменение
if (scp_x >= floor((float)(scb_pw/2)))
zoom->setRegim(QwtChartZoom::ctAxisHR); // правой границы
else zoom->setRegim(QwtChartZoom::ctAxisHL); // или левой
}
}
else // иначе (масштабируется вертикальная шкала)
{
// если нижняя граница меньше верхней,
if (scb_hy > 0)
// если высота канвы больше минимума,
if (scb_ph > 18)
{
// в зависимости от положения курсора
// (ниже или выше середины шкалы)
// включаем соответствующий режим - изменение
if (scp_y >= floor((float)(scb_ph/2)))
zoom->setRegim(QwtChartZoom::ctAxisVB); // нижней границы
else zoom->setRegim(QwtChartZoom::ctAxisVT); // или верхней
}
}
// если один из режимов был включен
if (zoom->regim() != QwtChartZoom::ctNone)
{
// запоминаем текущий курсор
tCursor = sw->cursor();
// устанавливаем курсор PointingHand
sw->setCursor(Qt::PointingHandCursor);
// если легкий режим и включена индикация, то
if (light && indiAxZ)
{
// создаем виджет, индицирующий масштабирование шкалы
zwid = new QWidget(plt->axisWidget(ax));
// назначаем ему цвет
zwid->setStyleSheet(QString(
"background-color:rgb(%1,%2,%3);").arg(
awClr.red()).arg(awClr.green()).arg(awClr.blue()));
// и прорисовываем
showZoomWidget(mEvent->pos(),ax);
}
}
}
}
}
PeakPickerTool::PeakPickerTool(
Graph *graph,
MantidQt::MantidWidgets::FitPropertyBrowser *fitPropertyBrowser,
MantidUI *mantidUI, bool showFitPropertyBrowser)
: QwtPlotPicker(graph->plotWidget()->canvas()), PlotToolInterface(graph),
m_fitPropertyBrowser(fitPropertyBrowser), m_mantidUI(mantidUI),
m_wsName(), m_spec(), m_init(false), m_width_set(true), m_width(0),
m_addingPeak(false), m_resetting(false), m_xMin(0.), m_xMax(0.),
m_changingXMin(false), m_changingXMax(false),
m_shouldBeNormalised(false) {
d_graph->plotWidget()->canvas()->setCursor(Qt::PointingHandCursor);
addExistingFitsAndGuess(d_graph->curvesList());
if (d_graph->plotWidget()->curves().size() > 0) {
// Initialize from the first curve that will work
auto curvesMap = d_graph->plotWidget()->curves();
for (auto curveIter = curvesMap.begin(); curveIter != curvesMap.end();
++curveIter) {
auto curve = dynamic_cast<PlotCurve *>(curveIter.value());
if (initializeFromCurve(curve)) {
break;
}
}
} else {
return;
}
m_fitPropertyBrowser->normaliseData(m_shouldBeNormalised);
m_fitPropertyBrowser->getHandler()->removeAllPlots();
m_fitPropertyBrowser->setWorkspaceName(m_wsName);
m_fitPropertyBrowser->setWorkspaceIndex(m_spec);
connect(m_fitPropertyBrowser, SIGNAL(currentChanged()), this,
SLOT(currentChanged()));
connect(m_fitPropertyBrowser, SIGNAL(workspaceIndexChanged(int)), this,
SLOT(workspaceIndexChanged(int)));
connect(m_fitPropertyBrowser, SIGNAL(workspaceNameChanged(const QString &)),
this, SLOT(workspaceNameChanged(const QString &)));
connect(m_fitPropertyBrowser, SIGNAL(functionRemoved()), this,
SLOT(functionRemoved()));
connect(m_fitPropertyBrowser, SIGNAL(functionCleared()), this,
SLOT(functionCleared()));
connect(m_fitPropertyBrowser, SIGNAL(algorithmFinished(const QString &)),
this, SLOT(algorithmFinished(const QString &)));
connect(m_fitPropertyBrowser, SIGNAL(startXChanged(double)), this,
SLOT(startXChanged(double)));
connect(m_fitPropertyBrowser, SIGNAL(endXChanged(double)), this,
SLOT(endXChanged(double)));
connect(m_fitPropertyBrowser,
SIGNAL(parameterChanged(const Mantid::API::IFunction *)), this,
SLOT(parameterChanged(const Mantid::API::IFunction *)));
connect(m_fitPropertyBrowser, SIGNAL(plotGuess()), this, SLOT(plotGuess()));
connect(m_fitPropertyBrowser, SIGNAL(plotCurrentGuess()), this,
SLOT(plotCurrentGuess()));
connect(m_fitPropertyBrowser, SIGNAL(removeGuess()), this,
SLOT(removeGuess()));
connect(m_fitPropertyBrowser, SIGNAL(removeCurrentGuess()), this,
SLOT(removeCurrentGuess()));
connect(m_fitPropertyBrowser,
SIGNAL(removePlotSignal(MantidQt::MantidWidgets::PropertyHandler *)),
this, SLOT(removePlot(MantidQt::MantidWidgets::PropertyHandler *)));
connect(m_fitPropertyBrowser, SIGNAL(removeFitCurves()), this,
SLOT(removeFitCurves()));
// When fit browser destroyed, disable oneself in the parent graph
connect(m_fitPropertyBrowser, SIGNAL(destroyed()), graph,
SLOT(disableTools()));
// Show the fitPropertyBrowser if it isn't already.
if (showFitPropertyBrowser)
m_fitPropertyBrowser->show();
connect(this, SIGNAL(isOn(bool)), m_fitPropertyBrowser,
SLOT(setPeakToolOn(bool)));
emit isOn(true);
auto cf = m_fitPropertyBrowser->compositeFunction();
if (m_fitPropertyBrowser->count() == 0 ||
(m_fitPropertyBrowser->count() == 1 &&
m_fitPropertyBrowser->isAutoBack())) {
m_init = true;
QwtScaleMap xMap = d_graph->plotWidget()->canvasMap(QwtPlot::xBottom);
double s1 = xMap.s1(), s2 = xMap.s2();
double ds = fabs(s2 - s1) * 0.05;
xMin(s1 + ds);
xMax(s2 - ds);
m_changingXMin = false;
m_changingXMax = false;
m_fitPropertyBrowser->setStartX(xMin());
m_fitPropertyBrowser->setEndX(xMax());
if (m_fitPropertyBrowser->isAutoBack()) {
m_fitPropertyBrowser->addAutoBackground();
}
} else {
m_init = true;
xMin(m_fitPropertyBrowser->startX());
xMax(m_fitPropertyBrowser->endX());
m_changingXMin = false;
m_changingXMax = false;
for (size_t i = 0; i < cf->nFunctions(); i++) {
auto pf =
dynamic_cast<Mantid::API::IPeakFunction *>(cf->getFunction(i).get());
if (pf) {
m_width = pf->fwhm();
if (m_width != 0.)
break;
}
}
}
attach(d_graph->plotWidget());
d_graph->plotWidget()->replot();
connect(d_graph, SIGNAL(curveRemoved()), this, SLOT(curveRemoved()));
connect(d_graph, SIGNAL(modifiedGraph()), this, SLOT(modifiedGraph()));
try { // if it's a MatrixWorkspace in the ADS
m_ws = boost::dynamic_pointer_cast<Mantid::API::MatrixWorkspace>(
Mantid::API::AnalysisDataService::Instance().retrieve(
m_wsName.toStdString()));
} catch (...) { // or it can be a TableWorkspace
m_ws = boost::dynamic_pointer_cast<Mantid::API::MatrixWorkspace>(
m_fitPropertyBrowser->createMatrixFromTableWorkspace());
}
}
void PlotMagnifier::rescale( double factor, AxisMode axis )
{
factor = qAbs( 1.0/factor );
QwtPlot* plt = plot();
if ( plt == nullptr || factor == 1.0 ){
return;
}
bool doReplot = false;
const bool autoReplot = plt->autoReplot();
plt->setAutoReplot( false );
const int axis_list[2] = {QwtPlot::xBottom, QwtPlot::yLeft};
QRectF new_rect;
for ( int i = 0; i <2; i++ )
{
double temp_factor = factor;
if( i==1 && axis == X_AXIS)
{
temp_factor = 1.0;
}
if( i==0 && axis == Y_AXIS)
{
temp_factor = 1.0;
}
int axisId = axis_list[i];
if ( isAxisEnabled( axisId ) )
{
const QwtScaleMap scaleMap = plt->canvasMap( axisId );
double v1 = scaleMap.s1();
double v2 = scaleMap.s2();
double center = _mouse_position.x();
if( axisId == QwtPlot::yLeft){
center = _mouse_position.y();
}
if ( scaleMap.transformation() )
{
// the coordinate system of the paint device is always linear
v1 = scaleMap.transform( v1 ); // scaleMap.p1()
v2 = scaleMap.transform( v2 ); // scaleMap.p2()
}
const double width = ( v2 - v1 );
const double ratio = (v2-center)/ (width);
v1 = center - width*temp_factor*(1-ratio);
v2 = center + width*temp_factor*(ratio);
if( v1 > v2 ) std::swap( v1, v2 );
if ( scaleMap.transformation() )
{
v1 = scaleMap.invTransform( v1 );
v2 = scaleMap.invTransform( v2 );
}
if( v1 < _lower_bounds[axisId]) v1 = _lower_bounds[axisId];
if( v2 > _upper_bounds[axisId]) v2 = _upper_bounds[axisId];
plt->setAxisScale( axisId, v1, v2 );
if( axisId == QwtPlot::xBottom)
{
new_rect.setLeft( v1 );
new_rect.setRight( v2 );
}
else{
new_rect.setBottom( v1 );
new_rect.setTop( v2 );
}
doReplot = true;
}
}
plt->setAutoReplot( autoReplot );
if ( doReplot ){
emit rescaled( new_rect );
}
}