IntensityDataCanvas.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/View/Plot2D/IntensityDataCanvas.cpp
//! @brief     Implements class IntensityDataCanvas
//!
//! @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/View/Plot2D/IntensityDataCanvas.h"
#include "GUI/Model/Data/IntensityDataItem.h"
#include "GUI/Model/Data/RealDataItem.h"
#include "GUI/Model/Data/SessionData.h"
#include "GUI/Model/Project/ProjectDocument.h"
#include "GUI/Util/ComboProperty.h"
#include "GUI/View/Global/Globals.h"
#include "GUI/View/Info/MessageBox.h"
#include "GUI/View/PlotUtil/ColorMap.h"
#include "GUI/View/PlotUtil/ColorMapCanvas.h"
#include "GUI/View/PlotUtil/SavePlotAssistant.h"
#include <QAction>
#include <QMouseEvent>
#include <QSettings>
#include <QVBoxLayout>
 
namespace {
 
const QString SettingsGroup = "IntensityDataCanvas/";
 
const QString SettingsKeyGradient = SettingsGroup + "Gradient";
 
const QString SettingsKeyInterpolation = SettingsGroup + "Interpolation";
 
} // namespace
 
IntensityDataCanvas::IntensityDataCanvas(QWidget* parent)
    : SessionItemWidget(parent)
    , m_colorMap(new ColorMapCanvas)
    , m_resetViewAction(nullptr)
    , m_rotateDataAction(nullptr)
    , m_savePlotAction(nullptr)
{
    setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 
    auto* layout = new QVBoxLayout;
    layout->setMargin(0);
    layout->setSpacing(0);
    layout->addWidget(m_colorMap);
    setLayout(layout);
 
    m_colorMap->setStatusLabelEnabled(true);
 
    initActions();
 
    connect(m_colorMap->customPlot(), &QCustomPlot::mousePress, this,
            &IntensityDataCanvas::onMousePress, Qt::UniqueConnection);
}
 
void IntensityDataCanvas::setItem(SessionItem* intensityItem)
{
    SessionItemWidget::setItem(intensityItem);
    m_colorMap->setItem(intensityDataItem());
 
    applyPersistentSettings();
    if (!m_rotateDataAction)
        initRotation();
}
 
QSize IntensityDataCanvas::sizeHint() const
{
    return QSize(500, 400);
}
 
QSize IntensityDataCanvas::minimumSizeHint() const
{
    return QSize(128, 128);
}
 
QList<QAction*> IntensityDataCanvas::actionList()
{
    if (m_rotateDataAction)
        return {m_resetViewAction, m_rotateDataAction, m_savePlotAction};
    else
        return {m_resetViewAction, m_savePlotAction};
}
 
void IntensityDataCanvas::onResetViewAction()
{
    intensityDataItem()->resetView();
}
 
void IntensityDataCanvas::onSavePlotAction()
{
    QString dirname = gSessionData->projectDocument.value()->userExportDir();
    GUI::Plot::savePlot(dirname, m_colorMap->customPlot(), intensityDataItem()->getDatafield());
}
 
void IntensityDataCanvas::onMousePress(QMouseEvent* event)
{
    if (event->button() == Qt::RightButton)
        emit customContextMenuRequested(event->globalPos());
}
 
void IntensityDataCanvas::subscribeToItem()
{
    intensityDataItem()->mapper()->setOnPropertyChange(
        [this](const QString& name) { onPropertyChanged(name); }, this);
}
 
void IntensityDataCanvas::rotateData()
{
    auto* realDataItem = dynamic_cast<RealDataItem*>(intensityDataItem()->parentItem());
    if (!realDataItem || !realDataItem->isIntensityData())
        // should never happen because of action disabling => no
        // dialog necessary
        return;
 
    if (realDataItem->rotationAffectsSetup()) {
        const QString title("Rotate data");
        const QString message("Rotation will break the link between the data and the instrument. "
                              "Detector masks or projections, if they exist, will be removed.");
        if (!GUI::View::Helpers::question(GUI::Global::mainWindow, title, message,
                                          "Do you wish to rotate the data?", "Yes, please rotate",
                                          "No, cancel data rotation"))
            return;
    }
 
    QApplication::setOverrideCursor(Qt::WaitCursor);
    realDataItem->rotateData();
    QApplication::restoreOverrideCursor();
}
 
IntensityDataItem* IntensityDataCanvas::intensityDataItem()
{
    auto* result = dynamic_cast<IntensityDataItem*>(currentItem());
    ASSERT(result);
    return result;
}
 
void IntensityDataCanvas::initActions()
{
    m_resetViewAction = new QAction(this);
    m_resetViewAction->setText("Center view");
    m_resetViewAction->setIcon(QIcon(":/images/camera-metering-center.svg"));
    m_resetViewAction->setToolTip("Reset view\n"
                                  "x,y,z axes range will be set to default");
    connect(m_resetViewAction, &QAction::triggered, this, &IntensityDataCanvas::onResetViewAction);
 
    m_savePlotAction = new QAction(this);
    m_savePlotAction->setText("Save");
    m_savePlotAction->setIcon(QIcon(":/images/content-save-outline.svg"));
    m_savePlotAction->setToolTip("Save plot");
    connect(m_savePlotAction, &QAction::triggered, this, &IntensityDataCanvas::onSavePlotAction);
}
 
void IntensityDataCanvas::initRotation()
{
    if (dynamic_cast<RealDataItem*>(intensityDataItem()->parentItem())) {
        m_rotateDataAction = new QAction(this);
        m_rotateDataAction->setText("Rotate");
        m_rotateDataAction->setIcon(QIcon(":/images/rotate-left.svg"));
        m_rotateDataAction->setIconText("Rotate");
        m_rotateDataAction->setToolTip("Rotate intensity data by 90 deg counterclockwise");
        connect(m_rotateDataAction, &QAction::triggered, this, &IntensityDataCanvas::rotateData);
    }
}
 
//! Reads gradient/ interpolation settings from IntensityDataItem and writes to persistant
//! project settings.
 
void IntensityDataCanvas::onPropertyChanged(const QString& name)
{
    if (IntensityDataItem::isGradientPropertyName(name)) {
        QSettings settings;
        settings.setValue(SettingsKeyGradient, intensityDataItem()->getGradientValue());
    } else if (IntensityDataItem::isInterpolatedPropertyName(name)) {
        QSettings settings;
        settings.setValue(SettingsKeyInterpolation, intensityDataItem()->isInterpolated());
    }
}
 
//! Apply persistent settings (gradient, interpolation) to IntensityDataItem.
 
void IntensityDataCanvas::applyPersistentSettings()
{
    QSettings settings;
 
    if (settings.contains(SettingsKeyGradient)) {
        ComboProperty combo = intensityDataItem()->getGradient();
        QString persistentGradient = settings.value(SettingsKeyGradient).toString();
        if (combo.getValue() != persistentGradient) {
            combo.setValue(persistentGradient);
            intensityDataItem()->setGradient(combo);
        }
    }
 
    if (settings.contains(SettingsKeyInterpolation)) {
        bool value = settings.value(SettingsKeyInterpolation).toBool();
        intensityDataItem()->setInterpolated(value);
    }
}