MaskUnitsConverter.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Device/MaskUnitsConverter.cpp
//! @brief     Implements class MaskUnitsConverter
//!
//! @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/Device/MaskUnitsConverter.h"
#include "Base/Axis/FrameUtil.h"
#include "GUI/Model/Data/IntensityDataItem.h"
#include "GUI/Model/Data/ProjectionItems.h"
#include "GUI/Model/Device/MaskItems.h"
 
MaskUnitsConverter::MaskUnitsConverter()
    : m_data(nullptr)
    , m_direction(UNDEFINED)
{
}
 
//! Converts all masks on board of IntensityDataItem into bin-fraction coordinates.
 
void MaskUnitsConverter::convertToNbins(IntensityDataItem* intensityData)
{
    m_direction = TO_NBINS;
    convertIntensityDataItem(intensityData);
}
 
//! Converts all masks on board of IntensityDataItem from bin-fraction coordinates to coordinates
//! of axes currently defined in Datafield.
 
void MaskUnitsConverter::convertFromNbins(IntensityDataItem* intensityData)
{
    m_direction = FROM_NBINS;
    convertIntensityDataItem(intensityData);
}
 
//! Converts all masks on board of IntensityDataItem from/to bin-fraction coordinates
 
void MaskUnitsConverter::convertIntensityDataItem(IntensityDataItem* intensityData)
{
    if (!intensityData || !intensityData->getDatafield())
        return;
 
    m_data = intensityData->getDatafield();
 
    if (intensityData->maskContainerItem())
        for (auto* maskItem : intensityData->maskContainerItem()->maskItems())
            convertMask(maskItem);
 
    if (intensityData->projectionContainerItem())
        for (SessionItem* item : intensityData->projectionContainerItem()->getItems())
            if (auto* maskItem = dynamic_cast<MaskItem*>(item))
                convertMask(maskItem);
}
 
//! Converts single mask from/to bin-fraction coordinates
 
void MaskUnitsConverter::convertMask(MaskItem* maskItem)
{
    if (auto* rectItem = dynamic_cast<RectangleItem*>(maskItem)) {
        rectItem->setXLow(convert(rectItem->xLow(), Axis::X));
        rectItem->setYLow(convert(rectItem->yLow(), Axis::Y));
        rectItem->setXUp(convert(rectItem->xUp(), Axis::X));
        rectItem->setYUp(convert(rectItem->yUp(), Axis::Y));
    } else if (auto* poly = dynamic_cast<PolygonItem*>(maskItem)) {
        for (PolygonPointItem* pointItem : poly->points()) {
            pointItem->setPosX(convert(pointItem->posX(), Axis::X));
            pointItem->setPosY(convert(pointItem->posY(), Axis::Y));
        }
    } else if (auto* vlineItem = dynamic_cast<VerticalLineItem*>(maskItem)) {
        vlineItem->setPosX(convert(vlineItem->posX(), Axis::X));
    } else if (auto* hlineItem = dynamic_cast<HorizontalLineItem*>(maskItem)) {
        hlineItem->setPosY(convert(hlineItem->posY(), Axis::Y));
    } else if (auto* ellItem = dynamic_cast<EllipseItem*>(maskItem)) {
        double xc = ellItem->xCenter();
        double yc = ellItem->yCenter();
        double xR = ellItem->xRadius();
        double yR = ellItem->yRadius();
 
        double x2 = xc + xR;
        double y2 = yc + yR;
 
        if (m_direction == TO_NBINS) {
            FramUtil::coordinatesToBinf(xc, yc, m_data->frame());
            FramUtil::coordinatesToBinf(x2, y2, m_data->frame());
        } else {
            FramUtil::coordinatesFromBinf(xc, yc, m_data->frame());
            FramUtil::coordinatesFromBinf(x2, y2, m_data->frame());
        }
        ellItem->setXCenter(xc);
        ellItem->setYCenter(yc);
        ellItem->setXRadius(x2 - xc);
        ellItem->setYRadius(y2 - yc);
    }
}
 
//! Convert (x,y) coordinates registered as property (i.e. under P_XPOS, P_YPOS) from/to
//! bin-fraction coordinates. Result of operation are new values for registered properties.
 
void MaskUnitsConverter::convertCoordinate(SessionItem* maskItem, const QString& xname,
                                           const QString& yname)
{
    if (maskItem->isTag(xname)) {
        double x = convert(maskItem->getItemValue(xname).toDouble(), Axis::X);
        maskItem->setItemValue(xname, x);
    }
    if (maskItem->isTag(yname)) {
        double y = convert(maskItem->getItemValue(yname).toDouble(), Axis::Y);
        maskItem->setItemValue(yname, y);
    }
}
 
//! Convert value of axis from/to bin-fraction coordinates.
 
double MaskUnitsConverter::convert(double value, Axis axis)
{
    auto axis_index = static_cast<size_t>(axis);
 
    ASSERT(m_data);
    ASSERT(axis_index == 0 || axis_index == 1);
 
    if (m_direction == TO_NBINS)
        return FramUtil::coordinateToBinf(value, m_data->axis(axis_index));
    if (m_direction == FROM_NBINS)
        return FramUtil::coordinateFromBinf(value, m_data->axis(axis_index));
    ASSERT(0);
}