MaskItems.h

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Device/MaskItems.h
//! @brief     Defines 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)
//
//  ************************************************************************************************
 
#ifndef BORNAGAIN_GUI_MODEL_DEVICE_MASKITEMS_H
#define BORNAGAIN_GUI_MODEL_DEVICE_MASKITEMS_H
 
#include "GUI/Model/BaseItem/SessionItem.h"
#include "GUI/Model/Descriptor/DoubleDescriptor.h"
#include "GUI/Model/Model/SessionModel.h"
 
class IShape2D;
class Streamer;
 
//! A base class for all mask items
 
class MaskItem : public SessionItem {
protected:
    static constexpr auto P_MASK_VALUE{"Mask value"};
    static constexpr auto P_IS_VISIBLE{"Visibility"};
 
public:
    virtual std::unique_ptr<IShape2D> createShape(double scale) const = 0;
 
    QString maskName() const;
    void setMaskName(const QString& name);
 
    bool maskValue() const;
    void setMaskValue(bool mask_value);
    static bool isMaskValuePropertyName(const QString& name);
 
    bool isVisibleValue() const;
    void setIsVisibleValue(bool visible);
    static bool isIsVisiblePropertyName(const QString& name);
 
    virtual void serialize(Streamer& s) = 0;
 
protected:
    explicit MaskItem(const QString& name);
    SessionItem* maskValueItem() const;
};
 
class RectangleItem : public MaskItem {
private:
    static constexpr auto P_XLOW{"xlow"};
    static constexpr auto P_YLOW{"ylow"};
    static constexpr auto P_XUP{"xup"};
    static constexpr auto P_YUP{"yup"};
 
public:
    static constexpr auto M_TYPE{"RectangleMask"};
 
    explicit RectangleItem();
    std::unique_ptr<IShape2D> createShape(double scale) const override;
 
    DoubleDescriptor xLow() const;
    void setXLow(double x_low);
    DoubleDescriptor yLow() const;
    void setYLow(double y_low);
    DoubleDescriptor xUp() const;
    void setXUp(double x_up);
    DoubleDescriptor yUp() const;
    void setYUp(double y_up);
 
    void serialize(Streamer& s) override;
 
protected:
    explicit RectangleItem(const QString& modelType);
};
 
class RegionOfInterestItem : public RectangleItem {
public:
    static constexpr auto M_TYPE{"RegionOfInterest"};
 
    RegionOfInterestItem();
    std::unique_ptr<IShape2D> createShape(double scale) const override;
};
 
class PolygonPointItem : public SessionItem {
private:
    static constexpr auto P_POSX{"X position"};
    static constexpr auto P_POSY{"Y position"};
 
public:
    static constexpr auto M_TYPE{"PolygonPoint"};
 
    PolygonPointItem();
 
    double posX() const;
    void setPosX(double pos_x);
    double posY() const;
    void setPosY(double pos_y);
 
    void serialize(Streamer& s);
};
 
class PolygonItem : public MaskItem {
private:
    static constexpr auto P_ISCLOSED{"Is closed"};
 
public:
    static constexpr auto M_TYPE{"PolygonMask"};
 
    PolygonItem();
    std::unique_ptr<IShape2D> createShape(double scale) const override;
 
    bool isClosed() const;
    void setIsClosed(bool closed);
 
    QVector<PolygonPointItem*> points() const;
    void addPoint(double x, double y);
 
    void serialize(Streamer& s) override;
};
 
class VerticalLineItem : public MaskItem {
private:
    static constexpr auto P_POSX{"X position"};
 
public:
    static constexpr auto M_TYPE{"VerticalLineMask"};
 
    VerticalLineItem();
    std::unique_ptr<IShape2D> createShape(double scale) const override;
 
    DoubleDescriptor posX() const;
    void setPosX(double pos_x);
 
    void serialize(Streamer& s) override;
};
 
class HorizontalLineItem : public MaskItem {
private:
    static constexpr auto P_POSY{"Y position"};
 
public:
    static constexpr auto M_TYPE{"HorizontalLineMask"};
 
    HorizontalLineItem();
    std::unique_ptr<IShape2D> createShape(double scale) const override;
 
    DoubleDescriptor posY() const;
    void setPosY(double pos_y);
 
    void serialize(Streamer& s) override;
};
 
class EllipseItem : public MaskItem {
private:
    static constexpr auto P_XCENTER{"X position"};
    static constexpr auto P_YCENTER{"Y position"};
    static constexpr auto P_XRADIUS{"X radius"};
    static constexpr auto P_YRADIUS{"Y radius"};
    static constexpr auto P_ANGLE{"Angle"};
 
public:
    static constexpr auto M_TYPE{"EllipseMask"};
 
    EllipseItem();
    std::unique_ptr<IShape2D> createShape(double scale) const override;
 
    DoubleDescriptor xCenter() const;
    void setXCenter(double x_center);
 
    DoubleDescriptor yCenter() const;
    void setYCenter(double y_center);
 
    DoubleDescriptor xRadius() const;
    void setXRadius(double x_radius);
 
    DoubleDescriptor yRadius() const;
    void setYRadius(double y_radius);
 
    DoubleDescriptor angle() const;
    void setAngle(double angle);
 
    void serialize(Streamer& s) override;
};
 
class MaskAllItem : public MaskItem {
public:
    static constexpr auto M_TYPE{"MaskAllMask"};
 
    MaskAllItem();
    std::unique_ptr<IShape2D> createShape(double scale) const override;
 
    void serialize(Streamer& s) override;
};
 
//! Container holding various masks as children
 
class MaskContainerItem : public SessionItem {
public:
    static constexpr auto M_TYPE{"MaskContainer"};
 
    MaskContainerItem();
 
    QVector<MaskItem*> maskItems() const;
 
    //! Insert mask at given row.
    void insertMask(int row, MaskItem* maskItem);
 
    void addMask(MaskItem* maskItem);
 
    //! Can be nullptr.
    RegionOfInterestItem* regionOfInterestItem() const;
 
    //! Remove all masks
    void clear();
};
 
 
//! List of MaskItems
//!
//! Makes it possible to keep a list of MaskItems in a class which itself is *not* using
//! SessionModel and which is *not* derived from SessionItem.
//!
//! This class is only for migration away from SessionModel. To keep a list of items which are
//! derived from SessionItem, right now a containing SessionModel is necessary. Once MaskItem is not
//! derived from SessionItem any more, this class can be replaced by e.g. a simple
//! QVector<MaskItem*>
class MaskItems : protected SessionModel {
public:
    MaskItems();
 
    //! Takes ownership of \a maskItem
    void insertMask(int index, MaskItem* maskItem);
 
    QVector<MaskItem*> maskItems() const;
 
    //! Copy the mask items stored in the given maskContainer.
    //!
    //! maskContainer can be nullptr.
    void copy(const MaskContainerItem* maskContainer);
 
    //! Removes all maskItems
    void clear();
 
    void serialize(Streamer& s);
 
private:
    MaskContainerItem* m_maskContainer;
};
 
#endif // BORNAGAIN_GUI_MODEL_DEVICE_MASKITEMS_H