MaskItems.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Device/MaskItems.cpp
//! @brief     Implements MaskItems classes
//!
//! @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/MaskItems.h"
#include "Device/Mask/Ellipse.h"
#include "Device/Mask/InfinitePlane.h"
#include "Device/Mask/Line.h"
#include "Device/Mask/Polygon.h"
#include "Device/Mask/Rectangle.h"
#include "GUI/Model/CatDevice/MaskItemCatalog.h"
#include "GUI/Model/Descriptor/DoubleDescriptor.h"
#include "GUI/Model/Model/SessionModel.h"
#include "GUI/Support/XML/Serialize.h"
 
MaskContainerItem::MaskContainerItem()
    : SessionItem(M_TYPE)
{
    const QString T_MASKS = "Mask Tag";
    static const QStringList allowedMasks = {RectangleItem::M_TYPE,       PolygonItem::M_TYPE,
                                             EllipseItem::M_TYPE,         VerticalLineItem::M_TYPE,
                                             HorizontalLineItem::M_TYPE,  MaskAllItem::M_TYPE,
                                             RegionOfInterestItem::M_TYPE};
    registerTag(T_MASKS, 0, -1, allowedMasks);
    setDefaultTag(T_MASKS);
}
 
QVector<MaskItem*> MaskContainerItem::maskItems() const
{
    QVector<MaskItem*> result;
    for (auto* child : children())
        if (auto* mask = dynamic_cast<MaskItem*>(child))
            result.append(mask);
 
    return result;
}
 
void MaskContainerItem::insertMask(int row, MaskItem* maskItem)
{
    insertChild(row, maskItem);
}
 
void MaskContainerItem::addMask(MaskItem* maskItem)
{
    insertChild(-1, maskItem);
}
 
RegionOfInterestItem* MaskContainerItem::regionOfInterestItem() const
{
    return firstChildOfType<RegionOfInterestItem>();
}
 
void MaskContainerItem::clear()
{
    model()->removeRows(0, numberOfChildren(), index());
}
 
QString MaskItem::maskName() const
{
    return itemName();
}
 
void MaskItem::setMaskName(const QString& name)
{
    setItemName(name);
}
 
/* ------------------------------------------------------------------------- */
 
bool MaskItem::maskValue() const
{
    return getItemValue(P_MASK_VALUE).toBool();
}
 
void MaskItem::setMaskValue(const bool mask_value)
{
    setItemValue(P_MASK_VALUE, mask_value);
}
 
bool MaskItem::isMaskValuePropertyName(const QString& name)
{
    return name == P_MASK_VALUE;
}
 
bool MaskItem::isVisibleValue() const
{
    return getItemValue(P_IS_VISIBLE).toBool();
}
 
void MaskItem::setIsVisibleValue(const bool visible)
{
    setItemValue(P_IS_VISIBLE, visible);
}
 
bool MaskItem::isIsVisiblePropertyName(const QString& name)
{
    return name == P_IS_VISIBLE;
}
 
MaskItem::MaskItem(const QString& name)
    : SessionItem(name)
{
    addProperty(P_MASK_VALUE, true);
    addProperty(P_IS_VISIBLE, true);
}
 
SessionItem* MaskItem::maskValueItem() const
{
    return getItem(P_MASK_VALUE);
}
 
/* ------------------------------------------------------------------------- */
 
RectangleItem::RectangleItem()
    : RectangleItem(M_TYPE)
{
}
 
RectangleItem::RectangleItem(const QString& modelType)
    : MaskItem(modelType)
{
    setItemName(modelType);
    addProperty(P_XLOW, 0.0)->setLimits(RealLimits::limitless());
    addProperty(P_YLOW, 0.0)->setLimits(RealLimits::limitless());
    addProperty(P_XUP, 0.0)->setLimits(RealLimits::limitless());
    addProperty(P_YUP, 0.0)->setLimits(RealLimits::limitless());
}
 
std::unique_ptr<IShape2D> RectangleItem::createShape(double scale) const
{
    double xlow = scale * getItemValue(P_XLOW).toDouble();
    double ylow = scale * getItemValue(P_YLOW).toDouble();
    double xup = scale * getItemValue(P_XUP).toDouble();
    double yup = scale * getItemValue(P_YUP).toDouble();
    return std::make_unique<Rectangle>(xlow, ylow, xup, yup);
}
 
DoubleDescriptor RectangleItem::xLow() const
{
    return DoubleDescriptor(getItem(P_XLOW), Unit::other);
}
 
void RectangleItem::setXLow(const double x_low)
{
    setItemValue(P_XLOW, x_low);
}
 
DoubleDescriptor RectangleItem::yLow() const
{
    return DoubleDescriptor(getItem(P_YLOW), Unit::other);
}
 
void RectangleItem::setYLow(const double y_low)
{
    setItemValue(P_YLOW, y_low);
}
 
DoubleDescriptor RectangleItem::xUp() const
{
    return DoubleDescriptor(getItem(P_XUP), Unit::other);
}
 
void RectangleItem::setXUp(const double x_up)
{
    setItemValue(P_XUP, x_up);
}
 
DoubleDescriptor RectangleItem::yUp() const
{
    return DoubleDescriptor(getItem(P_YUP), Unit::other);
}
 
void RectangleItem::setYUp(const double y_up)
{
    setItemValue(P_YUP, y_up);
}
 
void RectangleItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwSessionItem<bool>(s, "maskValue", getItem(P_MASK_VALUE));
    Serialize::rwSessionItem<bool>(s, "visible", getItem(P_IS_VISIBLE));
    Serialize::rwSessionItem<double>(s, "xlow", getItem(P_XLOW));
    Serialize::rwSessionItem<double>(s, "ylow", getItem(P_YLOW));
    Serialize::rwSessionItem<double>(s, "xup", getItem(P_XUP));
    Serialize::rwSessionItem<double>(s, "yup", getItem(P_YUP));
}
 
/* ------------------------------------------------------------------------- */
 
RegionOfInterestItem::RegionOfInterestItem()
    : RectangleItem(M_TYPE)
{
    setMaskValue(false);
}
 
std::unique_ptr<IShape2D> RegionOfInterestItem::createShape(double scale) const
{
    auto shape = RectangleItem::createShape(scale);
    dynamic_cast<Rectangle*>(shape.get())->setInverted(true);
    return shape;
}
 
/* ------------------------------------------------------------------------- */
 
PolygonPointItem::PolygonPointItem()
    : SessionItem(M_TYPE)
{
    setItemName(M_TYPE);
    addProperty(P_POSX, 0.0)->setLimits(RealLimits::limitless());
    addProperty(P_POSY, 0.0)->setLimits(RealLimits::limitless());
}
 
double PolygonPointItem::posX() const
{
    return getItemValue(P_POSX).toDouble();
}
 
void PolygonPointItem::setPosX(const double pos_x)
{
    setItemValue(P_POSX, pos_x);
}
 
double PolygonPointItem::posY() const
{
    return getItemValue(P_POSY).toDouble();
}
 
void PolygonPointItem::setPosY(const double pos_y)
{
    setItemValue(P_POSY, pos_y);
}
 
void PolygonPointItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwSessionItem<double>(s, "x", getItem(P_POSX));
    Serialize::rwSessionItem<double>(s, "y", getItem(P_POSY));
}
 
/* ------------------------------------------------------------------------- */
 
PolygonItem::PolygonItem()
    : MaskItem(M_TYPE)
{
    setItemName(M_TYPE);
    const QString T_POINTS = "Point tag";
    registerTag(T_POINTS, 0, -1, {PolygonPointItem::M_TYPE});
    setDefaultTag(T_POINTS);
    addProperty(P_ISCLOSED, false);
}
 
std::unique_ptr<IShape2D> PolygonItem::createShape(double scale) const
{
    std::vector<double> x, y;
    for (auto* item : this->childrenOfType<PolygonPointItem>()) {
        x.push_back(scale * item->posX());
        y.push_back(scale * item->posY());
    }
    return std::make_unique<Polygon>(x, y);
}
 
bool PolygonItem::isClosed() const
{
    return getItemValue(P_ISCLOSED).toBool();
}
 
void PolygonItem::setIsClosed(bool closed)
{
    setItemValue(P_ISCLOSED, closed);
}
 
 
QVector<PolygonPointItem*> PolygonItem::points() const
{
    return childrenOfType<PolygonPointItem>();
}
 
void PolygonItem::addPoint(double x, double y)
{
    auto* pointItem = new PolygonPointItem();
    pointItem->setPosX(x);
    pointItem->setPosY(y);
    insertChild(-1, pointItem);
}
 
void PolygonItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwSessionItem<bool>(s, "maskValue", getItem(P_MASK_VALUE));
    Serialize::rwSessionItem<bool>(s, "visible", getItem(P_IS_VISIBLE));
    Serialize::rwSessionItem<bool>(s, "closed", getItem(P_ISCLOSED));
 
    if (s.xmlReader()) {
        QVector<PolygonPointItem*> pts;
        Serialize::rwVector(s, "points", pts);
        for (const auto* point : pts)
            addPoint(point->posX(), point->posY());
        qDeleteAll(pts);
    } else {
        auto p = points();
        Serialize::rwVector(s, "points", p);
    }
}
 
/* ------------------------------------------------------------------------- */
 
VerticalLineItem::VerticalLineItem()
    : MaskItem(M_TYPE)
{
    setItemName(M_TYPE);
    addProperty(P_POSX, 0.0)->setLimits(RealLimits::limitless());
}
 
std::unique_ptr<IShape2D> VerticalLineItem::createShape(double scale) const
{
    return std::make_unique<VerticalLine>(scale
                                          * getItemValue(VerticalLineItem::P_POSX).toDouble());
}
 
DoubleDescriptor VerticalLineItem::posX() const
{
    return DoubleDescriptor(getItem(P_POSX), Unit::other);
}
 
void VerticalLineItem::setPosX(double pos_x)
{
    setItemValue(P_POSX, pos_x);
}
 
void VerticalLineItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwSessionItem<bool>(s, "maskValue", getItem(P_MASK_VALUE));
    Serialize::rwSessionItem<bool>(s, "visible", getItem(P_IS_VISIBLE));
    Serialize::rwSessionItem<double>(s, "x", getItem(P_POSX));
}
 
/* ------------------------------------------------------------------------- */
 
HorizontalLineItem::HorizontalLineItem()
    : MaskItem(M_TYPE)
{
    setItemName(M_TYPE);
    addProperty(P_POSY, 0.0)->setLimits(RealLimits::limitless());
}
 
std::unique_ptr<IShape2D> HorizontalLineItem::createShape(double scale) const
{
    return std::make_unique<HorizontalLine>(scale
                                            * getItemValue(HorizontalLineItem::P_POSY).toDouble());
}
 
DoubleDescriptor HorizontalLineItem::posY() const
{
    return DoubleDescriptor(getItem(P_POSY), Unit::other);
}
 
void HorizontalLineItem::setPosY(double pos_y)
{
    setItemValue(P_POSY, pos_y);
}
 
void HorizontalLineItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwSessionItem<bool>(s, "maskValue", getItem(P_MASK_VALUE));
    Serialize::rwSessionItem<bool>(s, "visible", getItem(P_IS_VISIBLE));
    Serialize::rwSessionItem<double>(s, "y", getItem(P_POSY));
}
 
/* ------------------------------------------------------------------------- */
 
EllipseItem::EllipseItem()
    : MaskItem(M_TYPE)
{
    setItemName(M_TYPE);
    addProperty(P_XCENTER, 0.0)->setLimits(RealLimits::limitless());
    addProperty(P_YCENTER, 0.0)->setLimits(RealLimits::limitless());
    addProperty(P_XRADIUS, 0.0);
    addProperty(P_YRADIUS, 0.0);
    addProperty(P_ANGLE, 0.0)->setLimits(RealLimits::limitless());
}
 
std::unique_ptr<IShape2D> EllipseItem::createShape(double scale) const
{
    double xcenter = scale * getItemValue(EllipseItem::P_XCENTER).toDouble();
    double ycenter = scale * getItemValue(EllipseItem::P_YCENTER).toDouble();
    double xradius = scale * getItemValue(EllipseItem::P_XRADIUS).toDouble();
    double yradius = scale * getItemValue(EllipseItem::P_YRADIUS).toDouble();
    double angle = scale * getItemValue(EllipseItem::P_ANGLE).toDouble();
 
    return std::make_unique<Ellipse>(xcenter, ycenter, xradius, yradius, angle);
}
 
DoubleDescriptor EllipseItem::xCenter() const
{
    return DoubleDescriptor(getItem(P_XCENTER), Unit::other);
}
 
void EllipseItem::setXCenter(const double x_center)
{
    setItemValue(P_XCENTER, x_center);
}
 
DoubleDescriptor EllipseItem::yCenter() const
{
    return DoubleDescriptor(getItem(P_YCENTER), Unit::other);
}
 
void EllipseItem::setYCenter(const double y_center)
{
    setItemValue(P_YCENTER, y_center);
}
 
DoubleDescriptor EllipseItem::xRadius() const
{
    return DoubleDescriptor(getItem(P_XRADIUS), Unit::other);
}
 
void EllipseItem::setXRadius(const double x_radius)
{
    setItemValue(P_XRADIUS, x_radius);
}
 
DoubleDescriptor EllipseItem::yRadius() const
{
    return DoubleDescriptor(getItem(P_YRADIUS), Unit::other);
}
 
void EllipseItem::setYRadius(const double y_radius)
{
    setItemValue(P_YRADIUS, y_radius);
}
 
DoubleDescriptor EllipseItem::angle() const
{
    return DoubleDescriptor(getItem(P_ANGLE), Unit::degree);
}
 
void EllipseItem::setAngle(const double angle)
{
    setItemValue(P_ANGLE, angle);
}
 
void EllipseItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwSessionItem<bool>(s, "maskValue", getItem(P_MASK_VALUE));
    Serialize::rwSessionItem<bool>(s, "visible", getItem(P_IS_VISIBLE));
    Serialize::rwSessionItem<double>(s, "x", getItem(P_XCENTER));
    Serialize::rwSessionItem<double>(s, "y", getItem(P_YCENTER));
    Serialize::rwSessionItem<double>(s, "xr", getItem(P_XRADIUS));
    Serialize::rwSessionItem<double>(s, "yr", getItem(P_YRADIUS));
    Serialize::rwSessionItem<double>(s, "angle", getItem(P_ANGLE));
}
 
/* ------------------------------------------------------------------------- */
 
MaskAllItem::MaskAllItem()
    : MaskItem(M_TYPE)
{
    setItemName(M_TYPE);
    maskValueItem()->setEnabled(false);
}
 
std::unique_ptr<IShape2D> MaskAllItem::createShape(double) const
{
    return std::make_unique<InfinitePlane>();
}
 
void MaskAllItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwSessionItem<bool>(s, "maskValue", getItem(P_MASK_VALUE));
    Serialize::rwSessionItem<bool>(s, "visible", getItem(P_IS_VISIBLE));
}
 
/* ------------------------------------------------------------------------- */
 
MaskItems::MaskItems()
    : SessionModel("MaskItems")
{
    m_maskContainer = insertItem<MaskContainerItem>();
}
 
void MaskItems::insertMask(int index, MaskItem* maskItem)
{
    m_maskContainer->insertChild(index, maskItem);
}
 
QVector<MaskItem*> MaskItems::maskItems() const
{
    return m_maskContainer->maskItems();
}
 
void MaskItems::copy(const MaskContainerItem* maskContainer)
{
    m_maskContainer->clear();
    if (maskContainer)
        for (auto mask : maskContainer->maskItems())
            copyItem(mask, m_maskContainer);
}
 
void MaskItems::clear()
{
    SessionModel::clear();
    m_maskContainer = insertItem<MaskContainerItem>();
}
 
void MaskItems::serialize(Streamer& s)
{
    QVector<MaskItem*> items;
    if (!s.xmlReader())
        items = maskItems();
 
    s.assertVersion(0);
    Serialize::rwCatalogized<MaskItemCatalog>(s, "maskItems", items);
 
    if (s.xmlReader())
        for (auto m : items)
            m_maskContainer->addMask(m);
}