virtual QwtDoubleInterval range() const
{
if (m_raster) {
float min, max;
for (int i = 0; i < m_raster->width(); i++) {
for (int j = 0; j < m_raster->height(); j++) {
float v = m_raster->get(i, j, 0);
min = (i == 0) ? v : fmin(min, v);
max = (i == 0) ? v : fmax(max, v);
}
}
double dmin = min;
double dmax = max;
double del = max == min ? 1.0 : max - min;
if (!settings.autoRange) {
double minblend = settings.minSlider / (double) settings.precSlider;
double maxblend = settings.maxSlider / (double) settings.precSlider;
dmin = min + minblend * del;
dmax = min + maxblend * del;
}
return QwtDoubleInterval(dmin, dmax);
} else {
return QwtDoubleInterval(0, 0);
}
}
/**
* @param it :: IMDIterator of what to find
* @return the min/max range, or INFINITY if not found
*/
QwtDoubleInterval SignalRange::getRange(Mantid::API::IMDIterator *it) {
if ((it == nullptr) || (!it->valid()))
return QwtDoubleInterval(0., 1.0);
// Use the current normalization
it->setNormalization(m_normalization);
double minSignal = DBL_MAX;
double maxSignal = -DBL_MAX;
auto inf = std::numeric_limits<double>::infinity();
do {
double signal = it->getNormalizedSignal();
// Skip any 'infs' as it screws up the color scale
if (!std::isinf(signal)) {
if (signal < minSignal)
minSignal = signal;
if (signal > maxSignal)
maxSignal = signal;
}
} while (it->next());
if (minSignal == DBL_MAX) {
minSignal = inf;
maxSignal = inf;
}
return QwtDoubleInterval(minSignal, maxSignal);
}
void ColorMapEditor::setColorMap(const QwtLinearColorMap& map)
{
scaleColorsBox->setChecked(map.mode() == QwtLinearColorMap::ScaledColors);
QwtArray <double> colors = map.colorStops();
int rows = (int)colors.size();
table->setRowCount(rows);
table->blockSignals(true);
for (int i = 0; i < rows; i++)
{
QwtDoubleInterval range = QwtDoubleInterval(min_val, max_val);
double val = min_val + colors[i] * range.width();
QTableWidgetItem *it = new QTableWidgetItem(QString::number(val));
table->setItem(i, 0, it);
QColor c = QColor(map.rgb(QwtDoubleInterval(0, 1), colors[i]));
it = new QTableWidgetItem(c.name());
it->setFlags(Qt::ItemFlags(!Qt::ItemIsEditable));
it->setBackground(QBrush(c));
it->setForeground(QBrush(c));
table->setItem(i, 1, it);
}
table->blockSignals(false);
color_map = map;
}
void ColorMapEditor::insertLevel()
{
int row = table->currentRow();
QwtDoubleInterval range = QwtDoubleInterval(min_val, max_val);
double val = 0.5*(table->item(row, 0)->text().toDouble() + table->item(row - 1, 0)->text().toDouble());
double mapped_val = (val - min_val)/range.width();
QColor c = QColor(color_map.rgb(QwtDoubleInterval(0, 1), mapped_val));
table->blockSignals(true);
table->insertRow(row);
QTableWidgetItem *it = new QTableWidgetItem(QString::number(val));
table->setItem(row, 0, it);
it = new QTableWidgetItem(c.name());
it->setFlags(Qt::ItemFlags(!Qt::ItemIsEditable));
it->setBackground(QBrush(c));
it->setForeground(QBrush(c));
table->setItem(row, 1, it);
table->blockSignals(false);
enableButtons(table->currentRow(), 0);
updateColorMap();
}
/** Update the widget when the color map is changed */
void ColorBarWidget::updateColorMap()
{
// The color bar alway shows the same range. Doesn't matter since the ticks don't show up
QwtDoubleInterval range(1.0, 100.0);
m_colorBar->setColorBarEnabled(true);
m_colorBar->setColorMap( range, m_colorMap);
m_colorBar->setColorBarWidth(15);
m_colorBar->setEnabled(true);
// Try to limit the number of steps based on the height of the color bar
int maxMajorSteps = m_colorBar->height()/15; // 15 pixels per div looked about right
//std::cout << "maxMajorSteps" << maxMajorSteps << std::endl;
if (maxMajorSteps > 10) maxMajorSteps = 10;
// Show the scale on the right
double minValue = m_min;
double maxValue = m_max;
GraphOptions::ScaleType type = m_colorMap.getScaleType();
if( type == GraphOptions::Linear )
{
QwtLinearScaleEngine linScaler;
m_colorBar->setScaleDiv(linScaler.transformation(), linScaler.divideScale(minValue, maxValue, maxMajorSteps, 5));
m_colorBar->setColorMap(QwtDoubleInterval(minValue, maxValue),m_colorMap);
}
else
{
QwtLog10ScaleEngine logScaler;
m_colorBar->setScaleDiv(logScaler.transformation(), logScaler.divideScale(minValue, maxValue, maxMajorSteps, 5));
m_colorBar->setColorMap(QwtDoubleInterval(minValue, maxValue), m_colorMap);
}
}
/**
* Set the minimum and maximum of the workspace data. Code essentially copied from SignalRange.cpp
* @param workspace Rreference to an IMD workspace
* @returns The minimum and maximum value of the workspace dataset.
*/
QwtDoubleInterval MetaDataExtractorUtils::getMinAndMax(Mantid::API::IMDWorkspace_sptr workspace)
{
if (!workspace)
throw std::invalid_argument("The workspace is empty.");
auto iterators = workspace->createIterators(PARALLEL_GET_MAX_THREADS, 0);
std::vector<QwtDoubleInterval> intervals(iterators.size());
// cppcheck-suppress syntaxError
PRAGMA_OMP( parallel for schedule(dynamic, 1))
for (int i=0; i < int(iterators.size()); i++)
{
Mantid::API::IMDIterator * it = iterators[i];
QwtDoubleInterval range = this->getRange(it);
intervals[i] = range;
// don't delete iterator in parallel. MSVC doesn't like it
// when the iterator points to a mock object.
}
// Combine the overall min/max
double minSignal = DBL_MAX;
double maxSignal = -DBL_MAX;
auto inf = std::numeric_limits<double>::infinity();
for (size_t i=0; i < iterators.size(); i++)
{
delete iterators[i];
double signal;
signal = intervals[i].minValue();
if (signal != inf && signal < minSignal) minSignal = signal;
signal = intervals[i].maxValue();
if (signal != inf && signal > maxSignal) maxSignal = signal;
}
// Set the lowest element to the smallest non-zero element.
if (minSignal == DBL_MAX)
{
minSignal = defaultMin;
maxSignal = defaultMax;
}
QwtDoubleInterval minMaxContainer;
if (minSignal < maxSignal)
minMaxContainer = QwtDoubleInterval(minSignal, maxSignal);
else
{
if (minSignal != 0)
// Possibly only one value in range
minMaxContainer = QwtDoubleInterval(minSignal*0.5, minSignal*1.5);
else
// Other default value
minMaxContainer = QwtDoubleInterval(defaultMin, defaultMax);
}
return minMaxContainer;
}
/*!
Interval, that is necessary to display the item
This interval can be useful for operations like clipping or autoscaling
\param scaleId Scale index
\return bounding interval
\sa QwtData::boundingRect()
*/
QwtDoubleInterval QwtPolarCurve::boundingInterval( int scaleId ) const
{
const QwtDoubleRect boundingRect = d_points->boundingRect();
if ( scaleId == QwtPolar::ScaleAzimuth )
return QwtDoubleInterval( boundingRect.left(), boundingRect.right() );
else if ( scaleId == QwtPolar::ScaleRadius )
return QwtDoubleInterval( boundingRect.top(), boundingRect.bottom() );
return QwtDoubleInterval();
}
QwtDoubleInterval QwtScaleEngine::buildInterval(double v) const
{
#if 1
const double delta = (v == 0.0) ? 0.5 : qwtAbs(0.5 * v);
return QwtDoubleInterval(v - delta, v + delta);
#else
if ( v == 0.0 )
return QwtDoubleInterval(-0.5, 0.5);
return QwtDoubleInterval(0.5 * v, 1.5 * v);
#endif
}
/*!
Return interval of an axis
\param axis Axis index ( see QwtPlot::AxisId )
*/
QwtDoubleInterval QwtPlotRescaler::interval(int axis) const
{
if ( axis < 0 || axis >= QwtPlot::axisCnt )
return QwtDoubleInterval();
const QwtPlot *plt = plot();
const double v1 = plt->axisScaleDiv(axis)->lowerBound();
const double v2 = plt->axisScaleDiv(axis)->upperBound();
return QwtDoubleInterval(v1, v2).normalized();
}
QwtDoubleInterval QwtPlotRescaler::intervalHint(int axis) const
{
if ( axis >= 0 && axis < QwtPlot::axisCnt )
return d_data->axisData[axis].intervalHint;
return QwtDoubleInterval();
}
/*!
\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 ProbabilityScaleEngine::divideScale(double x1, double x2,
int, int, double stepSize) const
{
QwtDoubleInterval interval = QwtDoubleInterval(x1, x2).normalized();
interval = interval.limited(1e-4, 99.999);
if (interval.width() <= 0 )
return QwtScaleDiv();
stepSize = fabs(qRound(stepSize));
if ( stepSize == 0.0 )
stepSize = 1.0;
QwtScaleDiv scaleDiv;
if ( stepSize != 0.0 ){
QwtValueList ticks[QwtScaleDiv::NTickTypes];
buildTicks(interval, stepSize, ticks);
scaleDiv = QwtScaleDiv(interval, ticks);
}
if ( x1 > x2 )
scaleDiv.invert();
return scaleDiv;
}
QwtDoubleInterval Spectrogram::range()
{
if (d_impose_range)
return QwtDoubleInterval(d_min_value, d_max_value);
return data().range();
}
void QmitkHistogramWidget::SetHistogram(HistogramType::ConstPointer itkHistogram)
{
HistogramType::SizeType size = itkHistogram->GetSize();
HistogramType::IndexType index;
HistogramType::MeasurementVectorType currentMeasurementVector;
QwtArray<QwtDoubleInterval> xValues(size[0]);
QwtArray<double> yValues(size[0]);
for (unsigned int i = 0; i < size[0]; ++i)
{
index[0] = static_cast<HistogramType::IndexValueType> (i);
currentMeasurementVector = itkHistogram->GetMeasurementVector(index);
if (currentMeasurementVector[0] != 0.0)
{
xValues[i] = QwtDoubleInterval(Round(currentMeasurementVector[0]-1), Round(currentMeasurementVector[0]));
yValues[i] = static_cast<double> (itkHistogram->GetFrequency(index));
}
}
// rebuild the plot
m_Plot->clear();
m_Histogram = new QmitkHistogram();
m_Histogram->setColor(Qt::darkCyan);
m_Histogram->setData(QwtIntervalData(xValues, yValues));
m_Histogram->attach(m_Plot);
this->InitializeMarker();
this->InitializeZoomer();
m_Plot->replot();
}
LinearColorMap LinearColorMap::fromXmlStringList(const QStringList& lst)
{
QStringList::const_iterator line = lst.begin();
QString s = (*line).stripWhiteSpace();
int mode = s.remove("<Mode>").remove("</Mode>").stripWhiteSpace().toInt();
s = *(++line);
QColor color1 = QColor(s.remove("<MinColor>").remove("</MinColor>").stripWhiteSpace());
s = *(++line);
QColor color2 = QColor(s.remove("<MaxColor>").remove("</MaxColor>").stripWhiteSpace());
LinearColorMap colorMap = LinearColorMap(color1, color2);
colorMap.setMode((QwtLinearColorMap::Mode)mode);
s = *(++line);
if (s.contains("<Range>")){
QStringList l = QStringList::split("\t", s.trimmed().remove("<Range>").remove("</Range>"));
if (l.size() == 2)
colorMap.setIntensityRange(QwtDoubleInterval(l[0].toDouble(), l[1].toDouble()));
s = *(++line);
}
int stops = s.remove("<ColorStops>").remove("</ColorStops>").stripWhiteSpace().toInt();
for (int i = 0; i < stops; i++){
s = (*(++line)).stripWhiteSpace();
QStringList l = QStringList::split("\t", s.remove("<Stop>").remove("</Stop>"));
colorMap.addColorStop(l[0].toDouble(), QColor(l[1]));
}
return colorMap;
}
/*!
\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(), QwtScaleEngine::subDivide()
*/
QwtScaleDiv QwtLinearScaleEngine::divideScale(double x1, double x2,
int maxMajSteps, int maxMinSteps, double stepSize) const
{
QwtDoubleInterval interval = QwtDoubleInterval(x1, x2).normalized();
if (interval.width() <= 0 )
return QwtScaleDiv();
stepSize = qwtAbs(stepSize);
if ( stepSize == 0.0 )
{
if ( maxMajSteps < 1 )
maxMajSteps = 1;
stepSize = divideInterval(interval.width(), 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;
}
/**
* Set up a new colour map.
* @param colorMap :: Reference to the new colour map.
*/
void ColorMapWidget::setupColorBarScaling(const MantidColorMap& colorMap)
{
double minValue = m_minValueBox->displayText().toDouble();
double maxValue = m_maxValueBox->displayText().toDouble();
GraphOptions::ScaleType type = colorMap.getScaleType();
if( type == GraphOptions::Linear )
{
QwtLinearScaleEngine linScaler;
m_scaleWidget->setScaleDiv(linScaler.transformation(), linScaler.divideScale(minValue, maxValue, 20, 5));
m_scaleWidget->setColorMap(QwtDoubleInterval(minValue, maxValue),colorMap);
}
else if( type == GraphOptions::Power )
{
PowerScaleEngine powerScaler;
m_scaleWidget->setScaleDiv(powerScaler.transformation(), powerScaler.divideScale(minValue, maxValue, 20, 5));
m_scaleWidget->setColorMap(QwtDoubleInterval(minValue, maxValue),colorMap);
}
else
{
QwtLog10ScaleEngine logScaler;
double logmin(minValue);
if( logmin <= 0.0 )
{
logmin = m_minPositiveValue;
m_minValueBox->blockSignals(true);
setMinValue(logmin);
m_minValueBox->blockSignals(false);
}
if (maxValue <= 0)
{
maxValue = 10.;
m_maxValueBox->blockSignals(true);
setMaxValue(maxValue);
m_maxValueBox->blockSignals(false);
}
m_scaleWidget->setScaleDiv(logScaler.transformation(), logScaler.divideScale(logmin, maxValue, 20, 5));
m_scaleWidget->setColorMap(QwtDoubleInterval(logmin, maxValue), colorMap);
}
m_scaleOptions->blockSignals(true);
m_scaleOptions->setCurrentIndex(m_scaleOptions->findData(type));
m_dspnN->setEnabled(false);
if (m_scaleOptions->findData(type) == 2) {
m_dspnN->setEnabled(true);
}
m_scaleOptions->blockSignals(false);
}
void ColorMapEditor::insertLevel()
{
int row = table->currentRow();
DoubleSpinBox *sb = (DoubleSpinBox*)table->cellWidget(row, 0);
if (!sb)
return;
double current_value = sb->value();
double previous_value = min_val;
sb = (DoubleSpinBox*)table->cellWidget(row - 1, 0);
if (sb)
previous_value = sb->value();
double val = 0.5*(current_value + previous_value);
QwtDoubleInterval range = QwtDoubleInterval(min_val, max_val);
double mapped_val = (val - min_val)/range.width();
QColor c = QColor(color_map.rgb(QwtDoubleInterval(0, 1), mapped_val));
table->blockSignals(true);
table->insertRow(row);
sb = new DoubleSpinBox();
sb->setLocale(d_locale);
sb->setDecimals(d_precision);
sb->setValue(val);
sb->setRange(min_val, max_val);
connect(sb, SIGNAL(valueChanged(double)), this, SLOT(updateColorMap()));
connect(sb, SIGNAL(activated(DoubleSpinBox *)), this, SLOT(spinBoxActivated(DoubleSpinBox *)));
table->setCellWidget(row, 0, sb);
QTableWidgetItem *it = new QTableWidgetItem(c.name());
// Avoid compiler warning
//#ifdef Q_CC_MSVC
it->setFlags(it->flags() & (~Qt::ItemIsEditable));
//#else
// it->setFlags(!Qt::ItemIsEditable);
//#endif
it->setBackground(QBrush(c));
it->setForeground(QBrush(c));
table->setItem(row, 1, it);
table->blockSignals(false);
enableButtons(table->currentRow());
updateColorMap();
}
void FloodPlot::dataAutoRange()
{
m_dataRange = m_spectrogram->data().range();
if (m_dataRange.minValue() == m_dataRange.maxValue())
m_dataRange = QwtDoubleInterval(m_dataRange.minValue(), m_dataRange.minValue() + 1.0);
m_colorLevels=linspace(m_dataRange.minValue(), m_dataRange.maxValue(),m_colorMapLength);
}
/*!
\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));
}
/**
* Get the range of a workspace dataset for a single iterator. Code the same as in SignalRange.cpp
* @param it :: IMDIterator of what to find
* @returns the min/max range, or INFINITY if not found
*/
QwtDoubleInterval MetaDataExtractorUtils::getRange(Mantid::API::IMDIterator * it)
{
if (!it)
return QwtDoubleInterval(defaultMin, defaultMax);
if (!it->valid())
return QwtDoubleInterval(defaultMin, defaultMax);
// Use no normalization
it->setNormalization(Mantid::API::VolumeNormalization);
double minSignal = DBL_MAX;
double minSignalZeroCheck = DBL_MAX;
double maxSignal = -DBL_MAX;
auto inf = std::numeric_limits<double>::infinity();
do
{
double signal = it->getNormalizedSignal();
// Skip any 'infs' as it screws up the color scale
if (signal != inf)
{
if (signal == 0.0) minSignalZeroCheck = signal;
if (signal < minSignal && signal >0.0) minSignal = signal;
if (signal > maxSignal) maxSignal = signal;
}
} while (it->next());
if (minSignal == DBL_MAX)
{
if (minSignalZeroCheck != DBL_MAX)
{
minSignal = defaultMin;
maxSignal = defaultMax;
}
else
{
minSignal = inf;
maxSignal = inf;
}
}
return QwtDoubleInterval(minSignal, maxSignal);
}
/*!
\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));
}
void ColorMapEditor::setColorMap(const QwtLinearColorMap& map)
{
scaleColorsBox->setChecked(map.mode() == QwtLinearColorMap::ScaledColors);
QwtArray <double> colors = map.colorStops();
int rows = (int)colors.size();
table->setRowCount(rows);
table->blockSignals(true);
QwtDoubleInterval range = QwtDoubleInterval(min_val, max_val);
for (int i = 0; i < rows; i++){
DoubleSpinBox *sb = new DoubleSpinBox();
sb->setLocale(d_locale);
sb->setDecimals(d_precision);
sb->setValue(min_val + colors[i] * range.width());
if (i == 0)
sb->setRange(min_val, min_val);
else if (i == rows -1)
sb->setRange(max_val, max_val);
else
sb->setRange(min_val, max_val);
connect(sb, SIGNAL(valueChanged(double)), this, SLOT(updateColorMap()));
connect(sb, SIGNAL(activated(DoubleSpinBox *)), this, SLOT(spinBoxActivated(DoubleSpinBox *)));
table->setCellWidget(i, 0, sb);
QColor c = QColor(map.rgb(QwtDoubleInterval(0, 1), colors[i]));
QTableWidgetItem *it = new QTableWidgetItem(c.name());
// Avoid compiler warning
//#ifdef Q_CC_MSVC
it->setFlags(it->flags() & (~Qt::ItemIsEditable));
//#else
// it->setFlags(!Qt::ItemIsEditable);
//#endif
it->setBackground(QBrush(c));
it->setForeground(QBrush(c));
table->setItem(i, 1, it);
}
table->blockSignals(false);
color_map = map;
}
/*!
\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 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;
}
/*!
\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);
}
QwtArray<QwtDoubleInterval> QwtCircleClipper::clipCircle(
const QwtDoublePoint &pos, double radius) const
{
QList<QwtDoublePoint> points;
for ( int edge = 0; edge < NEdges; edge++ )
points += cuttingPoints((Edge)edge, pos, radius);
QwtArray<QwtDoubleInterval> intv;
if ( points.size() <= 0 )
{
QwtDoubleRect cRect(0, 0, 2 * radius, 2* radius);
cRect.moveCenter(pos);
if ( contains(cRect) )
intv += QwtDoubleInterval(0.0, 2 * M_PI);
}
else
{
QList<double> angles;
for ( int i = 0; i < points.size(); i++ )
angles += toAngle(pos, points[i]);
qSort(angles);
const int in = contains(qwtPolar2Pos(pos, radius,
angles[0] + (angles[1] - angles[0]) / 2));
if ( in )
{
for ( int i = 0; i < angles.size() - 1; i += 2)
intv += QwtDoubleInterval(angles[i], angles[i+1]);
}
else
{
for ( int i = 1; i < angles.size() - 1; i += 2)
intv += QwtDoubleInterval(angles[i], angles[i+1]);
intv += QwtDoubleInterval(angles.last(), angles.first());
}
}
return intv;
}
void FloodPlot::colorLevels(Vector& colorLevels)
{
// update color stops based on input vector
m_colorLevels = colorLevels;
FloodPlotColorMap colorMap = FloodPlotColorMap(m_colorLevels, m_colorMapType);
m_spectrogram->setColorMap(colorMap);
m_qwtPlot->setAxisScale(QwtPlot::yRight, minimum(colorLevels), maximum(colorLevels)); // legend numbers
m_rightAxis->setColorMap(QwtDoubleInterval(minimum(colorLevels), maximum(colorLevels)), m_spectrogram->colorMap()); // legend colors
m_qwtPlot->replot();
}
int main(int argc, char **argv)
{
QApplication a(argc, argv);
QwtPlot plot;
plot.setCanvasBackground(QColor(Qt::white));
plot.setTitle("Histogram");
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableXMin(true);
grid->enableYMin(true);
grid->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
grid->attach(&plot);
HistogramItem *histogram = new HistogramItem();
histogram->setColor(Qt::darkCyan);
const int numValues = 20;
QwtArray<QwtDoubleInterval> intervals(numValues);
QwtArray<double> values(numValues);
double pos = 0.0;
for ( int i = 0; i < (int)intervals.size(); i++ )
{
const int width = 5 + rand() % 15;
const int value = rand() % 100;
intervals[i] = QwtDoubleInterval(pos, pos + double(width));
values[i] = value;
pos += width;
}
histogram->setData(QwtIntervalData(intervals, values));
histogram->attach(&plot);
plot.setAxisScale(QwtPlot::yLeft, 0.0, 100.0);
plot.setAxisScale(QwtPlot::xBottom, 0.0, pos);
plot.replot();
#if QT_VERSION < 0x040000
a.setMainWidget(&plot);
#endif
plot.resize(600,400);
plot.show();
return a.exec();
}
void Matrix::save(const QString &fn, const QString &info, bool saveAsTemplate)
{
QFile f(fn);
if (!f.isOpen()){
if (!f.open(QIODevice::Append))
return;
}
bool notTemplate = !saveAsTemplate;
QTextStream t( &f );
t.setEncoding(QTextStream::UnicodeUTF8);
t << "<matrix>\n";
if (notTemplate)
t << QString(objectName()) + "\t";
t << QString::number(numRows())+"\t";
t << QString::number(numCols())+"\t";
if (notTemplate)
t << birthDate() + "\n";
t << info;
t << "ColWidth\t" + QString::number(d_column_width)+"\n";
t << "<formula>\n" + formula_str + "\n</formula>\n";
t << "TextFormat\t" + QString(txt_format) + "\t" + QString::number(num_precision) + "\n";
if (notTemplate)
t << "WindowLabel\t" + windowLabel() + "\t" + QString::number(captionPolicy()) + "\n";
t << "Coordinates\t" + QString::number(x_start,'g',15) + "\t" +QString::number(x_end,'g',15) + "\t";
t << QString::number(y_start,'g',15) + "\t" + QString::number(y_end,'g',15) + "\n";
t << "ViewType\t" + QString::number((int)d_view_type) + "\n";
t << "HeaderViewType\t" + QString::number((int)d_header_view_type) + "\n";
if (d_color_map_type != Custom)
t << "ColorPolicy\t" + QString::number(d_color_map_type) + "\n";
else {
t << "<ColorMap>\n";
t << "\t<Mode>" + QString::number(d_color_map.mode()) + "</Mode>\n";
t << "\t<MinColor>" + d_color_map.color1().name() + "</MinColor>\n";
t << "\t<MaxColor>" + d_color_map.color2().name() + "</MaxColor>\n";
QwtArray <double> colors = d_color_map.colorStops();
int stops = (int)colors.size();
t << "\t<ColorStops>" + QString::number(stops - 2) + "</ColorStops>\n";
for (int i = 1; i < stops - 1; i++){
t << "\t<Stop>" + QString::number(colors[i]) + "\t";
t << QColor(d_color_map.rgb(QwtDoubleInterval(0,1), colors[i])).name();
t << "</Stop>\n";
}
t << "</ColorMap>\n";
}
if (notTemplate)
t << d_matrix_model->saveToString();
t <<"</matrix>\n";
}
void FloodPlot::colorMapRange(double min, double max)
{
if (min >= max)
return;
if (!m_floodPlotData)
return;
QwtDoubleInterval colorMap = QwtDoubleInterval(min, max);
m_floodPlotData->colorMapRange(colorMap); // color range applied to plot data
m_spectrogram->setData(*m_floodPlotData);
m_qwtPlot->setAxisScale(QwtPlot::yRight, min, max); // legend numbers
m_rightAxis->setColorMap(colorMap, m_spectrogram->colorMap()); // legend colors
m_qwtPlot->replot();
}
