/**
* Normalize the value to the range[0,1]
* @param interval :: The data range
* @param value :: The data value
* @returns The fraction along the given interval using the current scale type
*/
double MantidColorMap::normalize(const QwtDoubleInterval &interval,
double value) const {
// nan numbers have the property that nan != nan, treat nan as being invalid
if (interval.isNull() || m_num_colors == 0 || boost::math::isnan(value))
return m_nan;
const double width = interval.width();
if (width <= 0.0 || value <= interval.minValue())
return 0.0;
if (value >= interval.maxValue())
return 1.0;
double ratio(0.0);
if (m_scale_type == GraphOptions::Linear) {
ratio = (value - interval.minValue()) / width;
} else if (m_scale_type == GraphOptions::Power) {
ratio = (pow(value, m_nth_power) - pow(interval.minValue(), m_nth_power)) /
(pow(interval.maxValue(), m_nth_power) -
pow(interval.minValue(), m_nth_power));
} else {
// Assume log10 type
// Have to deal with the possibility that a user has entered 0 as a minimum
double minValue = interval.minValue();
if (minValue < LOG_ZERO_CUTOFF) {
minValue = 1.0;
}
ratio = std::log10(value / minValue) /
std::log10(interval.maxValue() / minValue);
}
return ratio;
}
/*!
\brief Align an interval to a step size
The limits of an interval are aligned that both are integer
multiples of the step size.
\param interval Interval
\param stepSize Step size
\return Aligned interval
*/
QwtDoubleInterval QwtLinearScaleEngine::align(
const QwtDoubleInterval &interval, double stepSize) const
{
double x1 = QwtScaleArithmetic::floorEps(interval.minValue(), stepSize);
if ( QwtScaleArithmetic::compareEps(interval.minValue(), x1, stepSize) == 0 )
x1 = interval.minValue();
double x2 = QwtScaleArithmetic::ceilEps(interval.maxValue(), stepSize);
if ( QwtScaleArithmetic::compareEps(interval.maxValue(), x2, stepSize) == 0 )
x2 = interval.maxValue();
return QwtDoubleInterval(x1, x2);
}
/**
Executes any meta-data loading required.
*/
void MDHWInMemoryLoadingPresenter::executeLoadMetadata() {
using namespace Mantid::API;
Workspace_sptr ws = m_repository->fetchWorkspace(m_wsName);
IMDHistoWorkspace_sptr histoWs =
boost::dynamic_pointer_cast<Mantid::API::IMDHistoWorkspace>(ws);
m_wsTypeName = histoWs->id();
m_specialCoords = histoWs->getSpecialCoordinateSystem();
MDHWLoadingPresenter::transposeWs(histoWs, m_cachedVisualHistoWs);
// Set the minimum and maximum of the workspace data.
QwtDoubleInterval minMaxContainer =
m_metaDataExtractor->getMinAndMax(histoWs);
m_metadataJsonManager->setMinValue(minMaxContainer.minValue());
m_metadataJsonManager->setMaxValue(minMaxContainer.maxValue());
// Set the instrument which is associated with the workspace.
m_metadataJsonManager->setInstrument(
m_metaDataExtractor->extractInstrument(m_cachedVisualHistoWs));
// Set the special coordinates
m_metadataJsonManager->setSpecialCoordinates(m_specialCoords);
// Call base-class extraction method.
this->extractMetadata(m_cachedVisualHistoWs);
}
/*!
\brief Align an interval to a step size
The limits of an interval are aligned that both are integer
multiples of the step size.
\param interval Interval
\param stepSize Step size
\return Aligned interval
*/
QwtDoubleInterval QwtLinearScaleEngine::align(
const QwtDoubleInterval &interval, double stepSize) const
{
const double x1 =
QwtScaleArithmetic::floorEps(interval.minValue(), stepSize);
const double x2 =
QwtScaleArithmetic::ceilEps(interval.maxValue(), stepSize);
return QwtDoubleInterval(x1, x2);
}
/*!
\brief Align an interval to a step size
The limits of an interval are aligned that both are integer
multiples of the step size.
\param interval Interval
\param stepSize Step size
\return Aligned interval
*/
QwtDoubleInterval QwtLog10ScaleEngine::align(
const QwtDoubleInterval &interval, double stepSize) const
{
const QwtDoubleInterval intv = log10(interval);
const double x1 = QwtScaleArithmetic::floorEps(intv.minValue(), stepSize);
const double x2 = QwtScaleArithmetic::ceilEps(intv.maxValue(), stepSize);
return pow10(QwtDoubleInterval(x1, x2));
}
/*!
Construct QwtScaleDiv instance.
\param interval Interval
\param ticks List of major, medium and minor ticks
*/
QwtScaleDiv::QwtScaleDiv(
const QwtDoubleInterval &interval,
QwtTickList ticks[NTickTypes]):
d_lBound(interval.minValue()),
d_hBound(interval.maxValue()),
d_isValid(true)
{
for ( int i = 0; i < NTickTypes; i++ )
d_ticks[i] = ticks[i];
}
/*!
\brief Align an interval to a step size
The limits of an interval are aligned that both are integer
multiples of the step size.
\param interval Interval
\param stepSize Step size
\return Aligned interval
*/
QwtDoubleInterval Log2ScaleEngine::align(
const QwtDoubleInterval &interval, double stepSize) const
{
const QwtDoubleInterval intv = log2(interval);
const double x1 = QwtScaleArithmetic::floorEps(intv.minValue(), stepSize);
const double x2 = QwtScaleArithmetic::ceilEps(intv.maxValue(), stepSize);
return QwtDoubleInterval(pow(2, x1), pow(2, x2));
}
QwtDoubleRect QwtIntervalData::boundingRect() const
{
double minX, maxX, minY, maxY;
minX = maxX = minY = maxY = 0.0;
bool isValid = false;
const size_t sz = size();
for ( size_t i = 0; i < sz; i++ )
{
const QwtDoubleInterval intv = interval(i);
if ( !intv.isValid() )
continue;
const double v = value(i);
if ( !isValid )
{
minX = intv.minValue();
maxX = intv.maxValue();
minY = maxY = v;
isValid = true;
}
else
{
if ( intv.minValue() < minX )
minX = intv.minValue();
if ( intv.maxValue() > maxX )
maxX = intv.maxValue();
if ( v < minY )
minY = v;
if ( v > maxY )
maxY = v;
}
}
if ( !isValid )
return QwtDoubleRect(1.0, 1.0, -2.0, -2.0); // invalid
return QwtDoubleRect(minX, minY, maxX - minX, maxY - minY);
}
void EditColorMap::SetData (
const QwtIntervalData& intervalData, double maxValue,
const ColorBarModel& colorBarModel, bool gridEnabled)
{
m_colorMap = colorBarModel;
setCombos (m_colorMap.GetPalette ());
widgetHistogram->SetDataAllBinsSelected (
intervalData, maxValue,
m_colorMap.GetTitle ().c_str ());
widgetHistogram->SetColorTransferFunction (
m_colorMap.GetInterval (), m_colorMap.GetQwtColorMap ());
widgetHistogram->SetGridEnabled (gridEnabled);
QwtDoubleInterval interval = m_colorMap.GetInterval ();
QwtDoubleInterval clampValues = m_colorMap.GetClampInterval ();
if (clampValues.minValue () > interval.minValue ())
widgetHistogram->SetItemsSelectionLow (false, clampValues.minValue ());
if (clampValues.maxValue () < interval.maxValue ())
widgetHistogram->SetItemsSelectionHigh (false, clampValues.maxValue ());
setHighlightColors ();
}
/*!
\brief Calculate a scale division
\param x1 First interval limit
\param x2 Second interval limit
\param maxMajSteps Maximum for the number of major steps
\param maxMinSteps Maximum number of minor steps
\param stepSize Step size. If stepSize == 0, the scaleEngine
calculates one.
\sa QwtScaleEngine::stepSize, LogTimeScaleEngine::subDivide
*/
QwtScaleDiv LogTimeScaleEngine::divideScale(double x1, double x2,
int maxMajSteps, int maxMinSteps, double stepSize) const
{
QwtDoubleInterval interval = QwtDoubleInterval(x1, x2).normalized();
interval = interval.limited(LOG_MIN, LOG_MAX);
if (interval.width() <= 0 )
return QwtScaleDiv();
if (interval.maxValue() / interval.minValue() < 10.0)
{
// scale width is less than one decade -> build linear scale
QwtLinearScaleEngine linearScaler;
linearScaler.setAttributes(attributes());
linearScaler.setReference(reference());
linearScaler.setMargins(
#if (QWT_VERSION >= 0x050200)
lowerMargin(), upperMargin()
#else
loMargin(), hiMargin()
#endif
);
return linearScaler.divideScale(x1, x2,
maxMajSteps, maxMinSteps, stepSize);
}
stepSize = qwtAbs(stepSize);
if ( stepSize == 0.0 )
{
if ( maxMajSteps < 1 )
maxMajSteps = 1;
stepSize = divideInterval(log10(interval).width(), maxMajSteps);
if ( stepSize < 1.0 )
stepSize = 1.0; // major step must be >= 1 decade
}
QwtScaleDiv scaleDiv;
if ( stepSize != 0.0 )
{
QwtValueList ticks[QwtScaleDiv::NTickTypes];
buildTicks(interval, stepSize, maxMinSteps, ticks);
scaleDiv = QwtScaleDiv(interval, ticks);
}
if ( x1 > x2 )
scaleDiv.invert();
return scaleDiv;
}
void ContourLinesEditor::insertLevel()
{
if (!d_spectrogram)
return;
int row = table->currentRow();
DoubleSpinBox *sb = (DoubleSpinBox*)table->cellWidget(row, 0);
if (!sb)
return;
QwtDoubleInterval range = d_spectrogram->data().range();
double current_value = sb->value();
double previous_value = range.minValue ();
sb = (DoubleSpinBox*)table->cellWidget(row - 1, 0);
if (sb)
previous_value = sb->value();
double val = 0.5*(current_value + previous_value);
table->blockSignals(true);
table->insertRow(row);
sb = new DoubleSpinBox();
sb->setLocale(d_locale);
sb->setDecimals(d_precision);
sb->setValue(val);
sb->setRange(range.minValue (), range.maxValue ());
connect(sb, SIGNAL(activated(DoubleSpinBox *)), this, SLOT(spinBoxActivated(DoubleSpinBox *)));
table->setCellWidget(row, 0, sb);
QPen pen = d_spectrogram->defaultContourPen();
if (pen.style() == Qt::NoPen)
pen = d_spectrogram->contourPen (val);
int width = 80;
int height = 20;
QPixmap pix(width, height);
pix.fill(Qt::white);
QPainter paint(&pix);
paint.setRenderHint(QPainter::Antialiasing);
paint.setPen(pen);
paint.drawLine(0, height/2, width, height/2);
paint.end();
QLabel *lbl = new QLabel();
lbl->setPixmap(pix);
table->setCellWidget(row, 1, lbl);
table->blockSignals(false);
enableButtons(table->currentRow());
d_pen_list.insert(row, pen);
}
QwtValueList Log2ScaleEngine::buildMajorTicks(
const QwtDoubleInterval &interval, double stepSize) const
{
double width = log2(interval).width();
int numTicks = qRound(width / stepSize) + 1;
if ( numTicks > 10000 )
numTicks = 10000;
const double lxmin = ::log2(interval.minValue());
const double lxmax = ::log2(interval.maxValue());
const double lstep = (lxmax - lxmin) / double(numTicks - 1);
QwtValueList ticks;
ticks += interval.minValue();
for (int i = 1; i < numTicks; i++)
ticks += pow(2, lxmin + double(i) * lstep);
ticks += interval.maxValue();
return ticks;
}
void QwtPolarPlot::updateScale( int scaleId )
{
if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount )
return;
ScaleData &d = d_data->scaleData[scaleId];
double minValue = d.minValue;
double maxValue = d.maxValue;
double stepSize = d.stepSize;
if ( scaleId == QwtPolar::ScaleRadius && d.doAutoScale )
{
QwtDoubleInterval interval;
const QwtPolarItemList& itmList = itemList();
for ( QwtPolarItemIterator it = itmList.begin();
it != itmList.end(); ++it )
{
const QwtPolarItem *item = *it;
if ( item->testItemAttribute( QwtPolarItem::AutoScale ) )
interval |= item->boundingInterval( scaleId );
}
minValue = interval.minValue();
maxValue = interval.maxValue();
d.scaleEngine->autoScale( d.maxMajor,
minValue, maxValue, stepSize );
d.scaleDiv.invalidate();
}
if ( !d.scaleDiv.isValid() )
{
d.scaleDiv = d.scaleEngine->divideScale(
minValue, maxValue,
d.maxMajor, d.maxMinor, stepSize );
}
const QwtDoubleInterval interval = visibleInterval();
const QwtPolarItemList& itmList = itemList();
for ( QwtPolarItemIterator it = itmList.begin();
it != itmList.end(); ++it )
{
QwtPolarItem *item = *it;
item->updateScaleDiv( *scaleDiv( QwtPolar::Azimuth ),
*scaleDiv( QwtPolar::Radius ), interval );
}
}
QwtValueList QwtLinearScaleEngine::buildMajorTicks(
const QwtDoubleInterval &interval, double stepSize) const
{
int numTicks = qRound(interval.width() / stepSize) + 1;
if ( numTicks > 10000 )
numTicks = 10000;
QwtValueList ticks;
ticks += interval.minValue();
for (int i = 1; i < numTicks - 1; i++)
ticks += interval.minValue() + i * stepSize;
ticks += interval.maxValue();
return ticks;
}
void ContourLinesEditor::updateContents()
{
if (!d_spectrogram)
return;
QwtValueList levels = d_spectrogram->contourLevels ();
int rows = (int)levels.size();
table->setRowCount(rows);
table->blockSignals(true);
QwtDoubleInterval range = d_spectrogram->data().range();
for (int i = 0; i < rows; i++){
DoubleSpinBox *sb = new DoubleSpinBox();
sb->setLocale(d_locale);
sb->setDecimals(d_precision);
sb->setValue(levels[i]);
sb->setRange(range.minValue (), range.maxValue ());
connect(sb, SIGNAL(activated(DoubleSpinBox *)), this, SLOT(spinBoxActivated(DoubleSpinBox *)));
table->setCellWidget(i, 0, sb);
QPen pen = d_spectrogram->defaultContourPen();
if (pen.style() == Qt::NoPen)
pen = d_spectrogram->contourPen (levels[i]);
int width = 80;
int height = 20;
QPixmap pix(width, height);
pix.fill(Qt::white);
QPainter paint(&pix);
paint.setRenderHint(QPainter::Antialiasing);
paint.setPen(pen);
paint.drawLine(0, height/2, width, height/2);
paint.end();
QLabel *lbl = new QLabel();
lbl->setPixmap(pix);
table->setCellWidget(i, 1, lbl);
d_pen_list << pen;
}
table->blockSignals(false);
}
/*!
Check if an interval "contains" a value
\param interval Interval
\param value Value
\sa QwtScaleArithmetic::compareEps()
*/
bool QwtScaleEngine::contains(
const QwtDoubleInterval &interval, double value) const
{
if (!interval.isValid() )
return false;
if ( QwtScaleArithmetic::compareEps(value,
interval.minValue(), interval.width()) < 0 )
{
return false;
}
if ( QwtScaleArithmetic::compareEps(value,
interval.maxValue(), interval.width()) > 0 )
{
return false;
}
return true;
}
/*!
Map a value of a given interval into a color index, between 0 and 255
\param interval Range for all values
\param value Value to map into a color index
*/
unsigned char QwtLinearColorMap::colorIndex(
const QwtDoubleInterval &interval, double value) const
{
const double width = interval.width();
if ( width <= 0.0 || value <= interval.minValue() )
return 0;
if ( value >= interval.maxValue() )
return (unsigned char)255;
const double ratio = (value - interval.minValue()) / width;
unsigned char index;
if ( d_data->mode == FixedColors )
index = (unsigned char)(ratio * 255); // always floor
else
index = (unsigned char)qRound(ratio * 255);
return index;
}
/*!
\brief Calculate a scale division
\param x1 First interval limit
\param x2 Second interval limit
\param maxMajSteps Maximum for the number of major steps
\param maxMinSteps Maximum number of minor steps
\param stepSize Step size. If stepSize == 0, the scaleEngine
calculates one.
*/
QwtScaleDiv Log2ScaleEngine::divideScale(double x1, double x2,
int maxMajSteps, int maxMinSteps, double stepSize) const
{
QwtDoubleInterval interval = QwtDoubleInterval(x1, x2).normalized();
interval = interval.limited(LOG_MIN, LOG_MAX);
if (interval.width() <= 0 )
return QwtScaleDiv();
if (interval.maxValue() / interval.minValue() < 2){
// scale width is less than 2 -> build linear scale
QwtLinearScaleEngine linearScaler;
linearScaler.setAttributes(attributes());
linearScaler.setReference(reference());
linearScaler.setMargins(lowerMargin(), upperMargin());
return linearScaler.divideScale(x1, x2,
maxMajSteps, maxMinSteps, stepSize);
}
stepSize = qwtAbs(stepSize);
if ( stepSize == 0.0 ){
if ( maxMajSteps < 1 )
maxMajSteps = 1;
stepSize = ceil(log2(interval).width()/double(maxMajSteps));
}
QwtScaleDiv scaleDiv;
if ( stepSize != 0.0 ){
QwtValueList ticks[QwtScaleDiv::NTickTypes];
buildTicks(interval, stepSize, maxMinSteps, ticks);
scaleDiv = QwtScaleDiv(interval, ticks);
}
if ( x1 > x2 )
scaleDiv.invert();
return scaleDiv;
}
//! Adjust the plot axes scales
void QwtPlotRescaler::rescale() const
{
#if 0
const int axis = referenceAxis();
if ( axis < 0 || axis >= QwtPlot::axisCnt )
return;
const QwtDoubleInterval hint = intervalHint(axis);
if ( !hint.isNull() )
{
QwtPlot *plt = (QwtPlot *)plot();
const bool doReplot = plt->autoReplot();
plt->setAutoReplot(false);
plt->setAxisScale(axis, hint.minValue(), hint.maxValue());
plt->setAutoReplot(doReplot);
plt->updateAxes();
}
#endif
const QSize size = canvas()->contentsRect().size();
rescale(size, size);
}
/*!
Expand the interval
\param interval Interval to be expanded
\param width Distance to be added to the interval
\param direction Direction of the expand operation
\return Expanded interval
*/
QwtDoubleInterval QwtPlotRescaler::expandInterval(
const QwtDoubleInterval &interval, double width,
ExpandingDirection direction) const
{
QwtDoubleInterval expanded = interval;
switch(direction)
{
case ExpandUp:
expanded.setMinValue(interval.minValue());
expanded.setMaxValue(interval.minValue() + width);
break;
case ExpandDown:
expanded.setMaxValue(interval.maxValue());
expanded.setMinValue(interval.maxValue() - width);
break;
case ExpandBoth:
default:
expanded.setMinValue(interval.minValue() +
interval.width() / 2.0 - width / 2.0);
expanded.setMaxValue(expanded.minValue() + width);
}
return expanded;
}
void ColorBarWidget::setViewRange(QwtDoubleInterval range)
{
this->setViewRange(range.minValue(), range.maxValue());
}
/*!
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 QwtDoublePoint &pole, double radius,
const QwtDoubleRect &canvasRect ) const
{
const QwtDoubleRect pr = plotRect( canvasRect.toRect() );
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 QwtDoubleInterval 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 QwtDoubleRect clipRect( pr.x() - margin, pr.y() - margin,
pr.width() + 2 * margin, pr.height() + 2 * margin );
if ( !clipRect.contains( canvasRect ) )
{
QRegion clipRegion( clipRect.toRect(), QRegion::Ellipse );
#if QT_VERSION >= 0x040000
painter->setClipRegion( clipRegion, Qt::IntersectClip );
#else
if ( painter->hasClipping() )
clipRegion &= painter->clipRegion();
painter->setClipRegion( clipRegion );
#endif
}
}
#if QT_VERSION >= 0x040000
painter->setRenderHint( QPainter::Antialiasing,
item->testRenderHint( QwtPolarItem::RenderAntialiased ) );
#endif
item->draw( painter, azimuthMap, radialMap,
pole, radius, canvasRect );
painter->restore();
}
}
}
void QwtPolarGrid::updateScaleDiv( const QwtScaleDiv &azimuthScaleDiv,
const QwtScaleDiv &radialScaleDiv, const QwtDoubleInterval &interval )
{
GridData &radialGrid = d_data->gridData[QwtPolar::Radius];
const QwtPolarPlot *plt = plot();
if ( plt && testGridAttribute( AutoScaling ) )
{
const QwtScaleEngine *se = plt->scaleEngine( QwtPolar::Radius );
radialGrid.scaleDiv = se->divideScale(
interval.minValue(), interval.maxValue(),
plt->scaleMaxMajor( QwtPolar::Radius ),
plt->scaleMaxMinor( QwtPolar::Radius ), 0 );
}
else
{
if ( radialGrid.scaleDiv != radialScaleDiv )
radialGrid.scaleDiv = radialScaleDiv;
}
GridData &azimuthGrid = d_data->gridData[QwtPolar::Azimuth];
if ( azimuthGrid.scaleDiv != azimuthScaleDiv )
{
azimuthGrid.scaleDiv = azimuthScaleDiv;
}
bool hasOrigin = false;
for ( int axisId = 0; axisId < QwtPolar::AxesCount; axisId++ )
{
AxisData &axis = d_data->axisData[axisId];
if ( axis.isVisible && axis.scaleDraw )
{
if ( axisId == QwtPolar::AxisAzimuth )
{
axis.scaleDraw->setScaleDiv( azimuthGrid.scaleDiv );
if ( testDisplayFlag( SmartScaleDraw ) )
{
axis.scaleDraw->enableComponent(
QwtAbstractScaleDraw::Ticks, !azimuthGrid.isVisible );
}
}
else
{
QwtScaleDiv sd = radialGrid.scaleDiv;
QwtValueList &ticks =
( QwtValueList & )sd.ticks( QwtScaleDiv::MajorTick );
if ( testDisplayFlag( SmartOriginLabel ) )
{
bool skipOrigin = hasOrigin;
if ( !skipOrigin )
{
if ( axisId == QwtPolar::AxisLeft
|| axisId == QwtPolar::AxisRight )
{
if ( d_data->axisData[QwtPolar::AxisBottom].isVisible )
skipOrigin = true;
}
else
{
if ( d_data->axisData[QwtPolar::AxisLeft].isVisible )
skipOrigin = true;
}
}
#if QWT_VERSION < 0x050200
if ( ticks.size() > 0 && ticks.first() == sd.lBound() )
#else
if ( ticks.size() > 0 && ticks.first() == sd.lowerBound() )
#endif
{
if ( skipOrigin )
{
#if QT_VERSION < 0x040000
ticks.pop_front();
#else
ticks.removeFirst();
#endif
}
else
hasOrigin = true;
}
}
if ( testDisplayFlag( HideMaxRadiusLabel ) )
{
#if QWT_VERSION < 0x050200
if ( ticks.size() > 0 && ticks.last() == sd.hBound() )
#else
if ( ticks.size() > 0 && ticks.last() == sd.upperBound() )
#endif
#if QT_VERSION < 0x040000
ticks.pop_back();
#else
ticks.removeLast();
#endif
}
axis.scaleDraw->setScaleDiv( sd );
if ( testDisplayFlag( SmartScaleDraw ) )
{
axis.scaleDraw->enableComponent(
QwtAbstractScaleDraw::Ticks, !radialGrid.isVisible );
}
}
}
}
}
/*!
Update the axis scale draw geometries
\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
\sa updateScaleDiv()
*/
void QwtPolarGrid::updateScaleDraws(
const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,
const QwtDoublePoint &pole, double radius ) const
{
const QPoint p = pole.toPoint();
const QwtDoubleInterval interval =
d_data->gridData[QwtPolar::ScaleRadius].scaleDiv.interval();
const int min = radialMap.transform( interval.minValue() );
const int max = radialMap.transform( interval.maxValue() );
const int l = max - min;
for ( int axisId = 0; axisId < QwtPolar::AxesCount; axisId++ )
{
AxisData &axis = d_data->axisData[axisId];
if ( axisId == QwtPolar::AxisAzimuth )
{
QwtRoundScaleDraw *scaleDraw = ( QwtRoundScaleDraw * )axis.scaleDraw;
scaleDraw->setRadius( qRound( radius ) );
scaleDraw->moveCenter( p );
double from = ::fmod( 90.0 - azimuthMap.p1() * 180.0 / M_PI, 360.0 );
if ( from < 0.0 )
from += 360.0;
scaleDraw->setAngleRange( from, from - 360.0 );
scaleDraw->setTransformation( azimuthMap.transformation()->copy() );
}
else
{
QwtScaleDraw *scaleDraw = ( QwtScaleDraw * )axis.scaleDraw;
switch ( axisId )
{
case QwtPolar::AxisLeft:
{
scaleDraw->move( p.x() - min, p.y() );
scaleDraw->setLength( -l );
break;
}
case QwtPolar::AxisRight:
{
scaleDraw->move( p.x() + min, p.y() );
scaleDraw->setLength( l );
break;
}
case QwtPolar::AxisTop:
{
scaleDraw->move( p.x(), p.y() - max );
scaleDraw->setLength( l );
break;
}
case QwtPolar::AxisBottom:
{
scaleDraw->move( p.x(), p.y() + max );
scaleDraw->setLength( -l );
break;
}
}
scaleDraw->setTransformation( radialMap.transformation()->copy() );
}
}
}
/*!
\brief Specify a scale.
Disable autoscaling and define a scale by an interval and a step size
\param interval Interval
\param stepSize major step size
\sa setAutoScale()
*/
void QwtAbstractScale::setScale(const QwtDoubleInterval &interval,
double stepSize)
{
setScale(interval.minValue(), interval.maxValue(), stepSize);
}
/*!
Return the interval [pow10(interval.minValue(), pow10(interval.maxValue]
*/
QwtDoubleInterval QwtLog10ScaleEngine::pow10(
const QwtDoubleInterval &interval) const
{
return QwtDoubleInterval(pow(10.0, interval.minValue()),
pow(10.0, interval.maxValue()));
}
QwtDoubleInterval Log2ScaleEngine::log2(
const QwtDoubleInterval &interval) const
{
return QwtDoubleInterval(::log2(interval.minValue()),
::log2(interval.maxValue()));
}
/*!
Draw circles
\param painter Painter
\param canvasRect Contents rect of the canvas in painter coordinates
\param pole Position of the pole in painter coordinates
\param radialMap Maps radius values into painter coordinates.
\param values Radial values, indicating the distances from the pole
*/
void QwtPolarGrid::drawCircles(
QPainter *painter, const QwtDoubleRect &canvasRect,
const QwtDoublePoint &pole, const QwtScaleMap &radialMap,
const QwtValueList &values ) const
{
for ( int i = 0; i < int( values.size() ); i++ )
{
const double val = values[i];
const GridData &gridData =
d_data->gridData[QwtPolar::Radius];
bool skipLine = false;
if ( testDisplayFlag( SmartScaleDraw ) )
{
const AxisData &axis = d_data->axisData[QwtPolar::AxisAzimuth];
if ( axis.isVisible &&
axis.scaleDraw->hasComponent( QwtAbstractScaleDraw::Backbone ) )
{
#if QWT_VERSION < 0x050200
if ( isClose( val, gridData.scaleDiv.hBound() ) )
#else
if ( isClose( val, gridData.scaleDiv.upperBound() ) )
#endif
skipLine = true;
}
}
#if QWT_VERSION < 0x050200
if ( isClose( val, gridData.scaleDiv.lBound() ) )
#else
if ( isClose( val, gridData.scaleDiv.lowerBound() ) )
#endif
skipLine = true;
if ( !skipLine )
{
const double radius = radialMap.transform( val );
QwtDoubleRect outerRect( 0, 0, 2 * radius, 2 * radius );
outerRect.moveCenter( pole );
#if QT_VERSION < 0x040000
QwtPainter::drawEllipse( painter, outerRect.toRect() );
#else
if ( testDisplayFlag( ClipGridLines ) )
{
/*
Qt4 is horrible slow, when painting primitives,
with coordinates far outside the visible area.
We need to clip.
*/
const QwtArray<QwtDoubleInterval> angles =
QwtClipper::clipCircle( canvasRect, pole, radius );
for ( int i = 0; i < angles.size(); i++ )
{
const QwtDoubleInterval intv = angles[i];
if ( intv.minValue() == 0 && intv.maxValue() == 2 * M_PI )
QwtPainter::drawEllipse( painter, outerRect.toRect() );
else
{
const double from = intv.minValue() / M_PI * 180;
const double to = intv.maxValue() / M_PI * 180;
double span = to - from;
if ( span < 0.0 )
span += 360.0;
const QwtMetricsMap &mm = QwtPainter::metricsMap();
const QRect r = outerRect.toRect();
painter->drawArc( mm.layoutToDevice( r, painter ),
qRound( from * 16 ), qRound( span * 16 ) );
}
}
}
else
{
QwtPainter::drawEllipse( painter, outerRect.toRect() );
}
#endif
}
}
}
/*!
Change the interval
\interval Interval
*/
void QwtScaleDiv::setInterval(const QwtDoubleInterval &interval)
{
setInterval(interval.minValue(), interval.maxValue());
}
void MatrixViewer::Init (const QString &title, MatrixRaster* data[2]) {
try {
ui=new Ui::ui_MatrixViewer;
}
catch (...)
{
ui=NULL;
return;
}
try {
ui->setupUi(this);
}
catch (...)
{
delete ui;
ui=NULL;
return;
}
this->setWindowTitle(title);
this->setFocusPolicy(Qt::ClickFocus);
ui->Plot->setAxisScale(QwtPlot::yLeft,data[0]->GetRows(),0.0);
ui->Plot->setAxisScale(QwtPlot::xBottom,0.0,data[0]->GetCols());
ui->Plot->enableAxis(QwtPlot::xTop,false);
ui->Plot->enableAxis(QwtPlot::xBottom,false);
ui->Plot->enableAxis(QwtPlot::yLeft,false);
ui->Plot->enableAxis(QwtPlot::yRight,false);
//QwtColorMap *c_map=_cntrl->AllocMainCMap(ui->S_Left->minValue(),ui->S_Right->maxValue());
QwtColorMap *c_map=_cntrl->AllocMainCMap(0.0,1.0);
QwtPlotSpectrogram *dt=new QwtPlotSpectrogram;
dt->setData(*(data[0]));
dt->attach(ui->Plot);
dt->setColorMap(*c_map);
_cntrl->FreeMainCMap(c_map);
_data[0]=dt;
dt->show();
const QwtDoubleInterval tmp_range=_data[0]->data().range();
ui->S_Left->setRange(tmp_range.minValue(),tmp_range.maxValue());
ui->S_Left->setValue(ui->S_Left->minValue());
ui->S_Right->setRange(ui->S_Left->minValue(),ui->S_Left->maxValue());
ui->S_Right->setValue(ui->S_Right->maxValue());
if (data[1]!=NULL)
{
// then _cntrl->AllocAuxCMap()!=NULL too
dt=new QwtPlotSpectrogram;
dt->setData(*(data[1]));
dt->attach(ui->Plot);
c_map=_cntrl->AllocAuxCMap();
dt->setColorMap(*c_map);
_cntrl->FreeAuxCMap(c_map);
_data[1]=dt;
dt->show();
}
else _data[1]=NULL;
QPen pen;
/* a pen for cursor and selection rectangle */
pen.setColor((_cntrl->GetType()==2)/*comparator*/? Qt::green : Qt::cyan);
pen.setWidth(1);
/* cursor on the widget with matrices (looks like '+') */
const double data_x[]={0.5,0.5,0.5,0.0,1.0};
const double data_y[]={0.0,1.0,0.5,0.5,0.5};
cursor=new QwtPlotCurve;
cursor->setPen(pen);
cursor->setData(data_x,data_y,5);
cursor->attach(ui->Plot);
cursor->show();
selection_rect=new QwtPlotCurve;
selection_rect->show();
selection_rect->setPen(pen);
selection_rect->attach(ui->Plot);
zoomer=new QwtPlotPicker(ui->Plot->canvas());
zoomer->setSelectionFlags(QwtPicker::RectSelection | QwtPicker::CornerToCorner | QwtPicker::DragSelection);
zoomer->setRubberBand(QwtPicker::RectRubberBand);
zoomer->setRubberBandPen(QPen(pen.color(),1,Qt::DashLine));
zoomer->setEnabled(true);
connect(ui->S_Left,SIGNAL(valueChanged(double)),this,SLOT(SetRightSldrMinVal(const double)));
connect(ui->S_Right,SIGNAL(valueChanged(double)),this,SLOT(SetLeftSldrMaxVal(const double)));
connect(ui->tB_showInfo,SIGNAL(clicked()),this,SLOT(ShowInfo()));
connect(ui->SB_xFrom,SIGNAL(valueChanged(int)),this,SLOT(SetAim()));
connect(ui->SB_yFrom,SIGNAL(valueChanged(int)),this,SLOT(SetAim()));
connect(zoomer,SIGNAL(selected(const QwtDoubleRect&)),this,SLOT(RectSelected(const QwtDoubleRect&)));
connect(ui->SB_xFrom,SIGNAL(valueChanged(int)),this,SLOT(DrawSelectionRect()));
connect(ui->SB_yFrom,SIGNAL(valueChanged(int)),this,SLOT(DrawSelectionRect()));
connect(ui->SB_xTo,SIGNAL(valueChanged(int)),this,SLOT(DrawSelectionRect()));
connect(ui->SB_yTo,SIGNAL(valueChanged(int)),this,SLOT(DrawSelectionRect()));
connect(ui->B_zoom,SIGNAL(clicked()),this,SLOT(ShowZoom()));
connect(ui->SB_yFrom,SIGNAL(valueChanged(int)),this,SIGNAL(RowChng(int))); // 'y' means 'row'!
connect(ui->SB_xFrom,SIGNAL(valueChanged(int)),this,SIGNAL(ColChng(int))); // 'x' means 'column'!
ShowInfo();
DrawSelectionRect();
}
