IntensityDataItem.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Data/IntensityDataItem.cpp
//! @brief     Implements class IntensityDataItem
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "GUI/Model/Data/IntensityDataItem.h"
#include "Base/Axis/IAxis.h"
#include "GUI/Model/Data/JobItemUtils.h"
#include "GUI/Model/Data/ProjectionItems.h"
#include "GUI/Model/Device/AxesItems.h"
#include "GUI/Model/Device/MaskItems.h"
#include "GUI/Model/Device/MaskUnitsConverter.h"
#include "GUI/Support/IO/ImportDataInfo.h"
#include "GUI/Util/Error.h"
 
namespace {
 
ComboProperty gradientCombo()
{
    ComboProperty result;
    result << "Grayscale"
           << "Hot"
           << "Cold"
           << "Night"
           << "Candy"
           << "Geography"
           << "Ion"
           << "Thermal"
           << "Polar"
           << "Spectrum"
           << "Jet"
           << "Hues";
    result.setValue("Thermal");
    return result;
}
 
} // namespace
 
const QString x_axis_default_name = "X [nbins]";
const QString y_axis_default_name = "Y [nbins]";
 
IntensityDataItem::IntensityDataItem()
    : DataItem(M_TYPE)
{
    addProperty(P_TITLE, QString());
 
    addProperty(P_PROJECTIONS, false);
    addProperty(P_IS_INTERPOLATED, true);
    addProperty(P_GRADIENT, gradientCombo().variant());
    addProperty<BasicAxisItem>(P_XAXIS);
    addProperty<BasicAxisItem>(P_YAXIS);
    addProperty<AmplitudeAxisItem>(P_ZAXIS);
 
    setXaxisTitle(x_axis_default_name);
    setYaxisTitle(y_axis_default_name);
 
    registerTag(T_MASKS, 0, -1, {MaskContainerItem::M_TYPE});
    setDefaultTag(T_MASKS);
 
    registerTag(T_PROJECTIONS, 0, -1, {ProjectionContainerItem::M_TYPE});
}
 
void IntensityDataItem::setDatafield(Datafield* data)
{
    ASSERT(data && "Assertion failed in IntensityDataItem::setDatafield: nullptr data passed");
    if (data->rank() != 2)
        throw Error("Error in IntensityDataItem::setDatafield: cannot handle non-2D data");
    DataItem::setDatafield(data);
 
    updateAxesZoomLevel();
    updateAxesLabels();
    updateDataRange();
 
    emitDataChanged();
}
 
int IntensityDataItem::xSize() const
{
    return xAxisItem()->binCount();
}
 
int IntensityDataItem::ySize() const
{
    return yAxisItem()->binCount();
}
 
double IntensityDataItem::getLowerX() const
{
    return xAxisItem()->min();
}
 
double IntensityDataItem::getUpperX() const
{
    return xAxisItem()->max();
}
 
double IntensityDataItem::xMin() const
{
    const double defaultXmin(0.0);
    return m_data ? m_data->axis(0).min() : defaultXmin;
}
 
double IntensityDataItem::xMax() const
{
    const double defaultXmax(1.0);
    return m_data ? m_data->axis(0).max() : defaultXmax;
}
 
double IntensityDataItem::getLowerY() const
{
    return yAxisItem()->min();
}
 
double IntensityDataItem::getUpperY() const
{
    return yAxisItem()->max();
}
 
double IntensityDataItem::yMin() const
{
    const double defaultYmin(0.0);
    return m_data ? m_data->axis(1).min() : defaultYmin;
}
 
double IntensityDataItem::yMax() const
{
    const double defaultYmax(1.0);
    return m_data ? m_data->axis(1).max() : defaultYmax;
}
 
double IntensityDataItem::getLowerZ() const
{
    return zAxisItem()->min();
}
 
double IntensityDataItem::getUpperZ() const
{
    return zAxisItem()->max();
}
 
QString IntensityDataItem::getGradientValue() const
{
    return getGradient().getValue();
}
 
ComboProperty IntensityDataItem::getGradient() const
{
    return getItemValue(P_GRADIENT).value<ComboProperty>();
}
 
void IntensityDataItem::setGradient(const ComboProperty& gradient)
{
    setItemValue(P_GRADIENT, gradient.variant());
}
 
SelectionDescriptor<QString> IntensityDataItem::gradient() const
{
    return SelectionDescriptor<QString>(getItem(P_GRADIENT));
}
 
bool IntensityDataItem::isLogz() const
{
    return zAxisItem()->isLogScale();
}
 
bool IntensityDataItem::isInterpolated() const
{
    return getItemValue(P_IS_INTERPOLATED).toBool();
}
 
QString IntensityDataItem::getXaxisTitle() const
{
    return xAxisItem()->title();
}
 
QString IntensityDataItem::getYaxisTitle() const
{
    return yAxisItem()->title();
}
 
bool IntensityDataItem::isZAxisLocked() const
{
    return item<AmplitudeAxisItem>(P_ZAXIS)->isLocked();
}
 
void IntensityDataItem::setZAxisLocked(bool state)
{
    item<AmplitudeAxisItem>(P_ZAXIS)->setLocked(state);
}
 
void IntensityDataItem::setXaxisTitle(const QString& title)
{
    xAxisItem()->setTitle(title);
}
 
void IntensityDataItem::setYaxisTitle(const QString& title)
{
    yAxisItem()->setTitle(title);
}
 
//! set zoom range of x,y axes to axes of input data
void IntensityDataItem::setAxesRangeToData()
{
    setLowerX(xMin());
    setUpperX(xMax());
    setLowerY(yMin());
    setUpperY(yMax());
}
 
void IntensityDataItem::updateCoords(const InstrumentItem* instrument)
{
    MaskUnitsConverter converter;
    converter.convertToNbins(this);
 
    GUI::Model::JobItemUtils::updateDataAxes(this, instrument);
 
    converter.convertFromNbins(this);
}
 
std::vector<int> IntensityDataItem::shape() const
{
    return {xSize(), ySize()};
}
 
void IntensityDataItem::reset(ImportDataInfo data)
{
    ASSERT(data.unitsLabel() == "nbins");
    ComboProperty combo = ComboProperty() << data.unitsLabel();
    setAxesUnits(combo);
    setXaxisTitle(data.axisLabel(0));
    setYaxisTitle(data.axisLabel(1));
    MaskUnitsConverter converter;
    converter.convertToNbins(this);
    setDatafield(std::move(data).intensityData().release());
    setAxesRangeToData();
    converter.convertFromNbins(this);
}
 
bool IntensityDataItem::isInterpolatedPropertyName(const QString& name)
{
    return name == P_IS_INTERPOLATED;
}
 
bool IntensityDataItem::isGradientPropertyName(const QString& name)
{
    return name == P_GRADIENT;
}
 
bool IntensityDataItem::isXaxisPropertyName(const QString& name)
{
    return name == P_XAXIS;
}
 
bool IntensityDataItem::isYaxisPropertyName(const QString& name)
{
    return name == P_YAXIS;
}
 
bool IntensityDataItem::isZaxisPropertyName(const QString& name)
{
    return name == P_ZAXIS;
}
 
void IntensityDataItem::setLowerX(double value)
{
    xAxisItem()->setLowerBound(value);
}
 
void IntensityDataItem::setUpperX(double value)
{
    xAxisItem()->setUpperBound(value);
}
 
void IntensityDataItem::setLowerY(double value)
{
    yAxisItem()->setLowerBound(value);
}
 
void IntensityDataItem::setUpperY(double value)
{
    yAxisItem()->setUpperBound(value);
}
 
void IntensityDataItem::setLowerAndUpperZ(double zmin, double zmax)
{
    if (getLowerZ() != zmin)
        setLowerZ(zmin);
 
    if (getUpperZ() != zmax)
        setUpperZ(zmax);
}
 
void IntensityDataItem::setLowerZ(double zmin)
{
    zAxisItem()->setLowerBound(zmin);
}
 
void IntensityDataItem::setUpperZ(double zmax)
{
    zAxisItem()->setUpperBound(zmax);
}
 
void IntensityDataItem::setLogz(bool logz)
{
    zAxisItem()->setLogScale(logz);
}
 
void IntensityDataItem::setInterpolated(bool interp)
{
    setItemValue(P_IS_INTERPOLATED, interp);
}
 
//! Sets zoom range of X,Y axes, if it was not yet defined.
 
void IntensityDataItem::updateAxesZoomLevel()
{
    // set zoom range of x-axis to min, max values if it was not set already
    if (getUpperX() < getLowerX()) {
        setLowerX(xMin());
        setUpperX(xMax());
    }
 
    // set zoom range of y-axis to min, max values if it was not set already
    if (getUpperY() < getLowerY()) {
        setLowerY(yMin());
        setUpperY(yMax());
    }
 
    const int nx = static_cast<int>(m_data->axis(0).size());
    xAxisItem()->setBinCount(nx);
    const int ny = static_cast<int>(m_data->axis(1).size());
    yAxisItem()->setBinCount(ny);
}
 
//! Init axes labels, if it was not done already.
 
void IntensityDataItem::updateAxesLabels()
{
    if (getXaxisTitle().isEmpty())
        setXaxisTitle(QString::fromStdString(m_data->axis(0).axisName()));
 
    if (getYaxisTitle().isEmpty())
        setYaxisTitle(QString::fromStdString(m_data->axis(1).axisName()));
}
 
//! Sets min,max values for z-axis, if axes is not locked, and ranges are not yet set.
 
void IntensityDataItem::updateDataRange()
{
    if (isZAxisLocked())
        return;
 
    computeDataRange();
}
 
void IntensityDataItem::computeDataRange()
{
    QPair<double, double> minmax = dataRange();
    setLowerAndUpperZ(minmax.first, minmax.second);
}
 
//! Init zmin, zmax to match the intensity values range.
QPair<double, double> IntensityDataItem::dataRange() const
{
    const Datafield* data = getDatafield();
 
    const auto vec = data->flatVector();
    double min(*std::min_element(vec.cbegin(), vec.cend()));
    double max(*std::max_element(vec.cbegin(), vec.cend()));
    if (isLogz()) {
        if (max > 10000) {
            min = 1.0;
            max = max * 1.1;
        } else {
            min = max / 10000;
            max = max * 1.1;
        }
    } else {
        max = max * 1.1;
    }
 
    return QPair<double, double>(min, max);
}
 
const BasicAxisItem* IntensityDataItem::xAxisItem() const
{
    return item<BasicAxisItem>(P_XAXIS);
}
 
BasicAxisItem* IntensityDataItem::xAxisItem()
{
    return item<BasicAxisItem>(P_XAXIS);
}
 
const BasicAxisItem* IntensityDataItem::yAxisItem() const
{
    return item<BasicAxisItem>(P_YAXIS);
}
 
BasicAxisItem* IntensityDataItem::yAxisItem()
{
    return item<BasicAxisItem>(P_YAXIS);
}
 
const AmplitudeAxisItem* IntensityDataItem::zAxisItem() const
{
    return item<AmplitudeAxisItem>(P_ZAXIS);
}
 
AmplitudeAxisItem* IntensityDataItem::zAxisItem()
{
    return item<AmplitudeAxisItem>(P_ZAXIS);
}
 
//! Set axes viewport to original data.
 
void IntensityDataItem::resetView()
{
    if (!m_data)
        return;
 
    setAxesRangeToData();
    if (!isZAxisLocked())
        computeDataRange();
}
 
MaskContainerItem* IntensityDataItem::maskContainerItem()
{
    return dynamic_cast<MaskContainerItem*>(getItem(T_MASKS));
}
 
const MaskContainerItem* IntensityDataItem::maskContainerItem() const
{
    return dynamic_cast<MaskContainerItem*>(getItem(T_MASKS));
}
 
MaskContainerItem* IntensityDataItem::getOrCreateMaskContainerItem()
{
    MaskContainerItem* result = maskContainerItem();
    if (!result)
        result = model()->insertItem<MaskContainerItem>(this, -1, T_MASKS);
    return result;
}
 
ProjectionContainerItem* IntensityDataItem::projectionContainerItem()
{
    return dynamic_cast<ProjectionContainerItem*>(getItem(T_PROJECTIONS));
}
 
const ProjectionContainerItem* IntensityDataItem::projectionContainerItem() const
{
    return dynamic_cast<ProjectionContainerItem*>(getItem(T_PROJECTIONS));
}
 
ProjectionContainerItem* IntensityDataItem::getOrCreateProjectionContainerItem()
{
    ProjectionContainerItem* result = projectionContainerItem();
    if (!result)
        result = model()->insertItem<ProjectionContainerItem>(this, -1, T_PROJECTIONS);
    return result;
}
 
bool IntensityDataItem::hasMasks() const
{
    return (maskContainerItem() && !maskContainerItem()->maskItems().isEmpty());
}
 
bool IntensityDataItem::hasProjections() const
{
    return (projectionContainerItem() && projectionContainerItem()->hasChildren());
}