PolygonMaskItem transformed from domain

Core/Geometry/inc/Polygon.h

@@ -55,6 +55,8 @@ public:
 
     double getArea() const;
 
+    void getPoints(std::vector<double> &xpos, std::vector<double> &ypos) const;
+
 protected:
     virtual void print(std::ostream &ostr) const;
 

Core/Geometry/inc/Rectangle.h

@@ -44,6 +44,11 @@ public:
 
     double getArea() const;
 
+    double getXlow() const;
+    double getYlow() const;
+    double getXup() const;
+    double getYup() const;
+
 private:
     Rectangle(const Rectangle& other);
     double m_xlow, m_ylow, m_xup, m_yup;

Core/Geometry/src/Polygon.cpp

@@ -34,6 +34,8 @@ public:
     typedef model::polygon<point_t> polygon_t;
     polygon_t polygon;
     void init_from(const std::vector<double> &x, const std::vector<double> &y);
+    void get_points(std::vector<double> &xpos, std::vector<double> &ypos);
+
 };
 
 
@@ -53,6 +55,19 @@ void PolygonPrivate::init_from(const std::vector<double> &x, const std::vector<d
     correct(polygon);
 }
 
+void PolygonPrivate::get_points(std::vector<double> &xpos, std::vector<double> &ypos)
+{
+    xpos.clear();
+    ypos.clear();
+    for(auto it = polygon.outer().begin(); it != polygon.outer().end(); ++it )
+    {
+         // for vectors of x and y, extract the x/y from the point
+         xpos.push_back( boost::geometry::get<0>( *it ) );
+         ypos.push_back( boost::geometry::get<1>( *it ) );
+    }
+}
+
+
 
 // IMPORTANT Input parameters are not "const reference" to be able to work from python
 // (auto convertion of python list to vector<double>).
@@ -110,6 +125,11 @@ double Polygon::getArea() const
     return area(m_d->polygon);
 }
 
+void Polygon::getPoints(std::vector<double> &xpos, std::vector<double> &ypos) const
+{
+    m_d->get_points(xpos, ypos);
+}
+
 void Polygon::print(std::ostream &ostr) const
 {
     ostr << wkt<PolygonPrivate::polygon_t>(m_d->polygon);

Core/Geometry/src/Rectangle.cpp

@@ -59,6 +59,26 @@ double Rectangle::getArea() const
     return (m_xup-m_xlow)*(m_yup-m_ylow);
 }
 
+double Rectangle::getXlow() const
+{
+    return m_xlow;
+}
+
+double Rectangle::getYlow() const
+{
+    return m_xup;
+}
+
+double Rectangle::getXup() const
+{
+    return m_ylow;
+}
+
+double Rectangle::getYup() const
+{
+    return m_yup;
+}
+
 Rectangle::Rectangle(const Rectangle &other)
     : m_xlow(other.m_xlow)
     , m_ylow(other.m_ylow)

Core/StandardSamples/StandardSimulations.cpp

@@ -105,8 +105,14 @@ GISASSimulation *StandardSimulations::MiniGISASWithMasks()
             0.0*Units::degree);
     result->setBeamIntensity(1e-06);
 //    result->maskAll();
-    result->addMask(Geometry::Ellipse(0.0*Units::deg, 1.0*Units::deg,
-                                      0.5*Units::deg, 0.5*Units::deg), true);
+//    result->addMask(Geometry::Ellipse(0.0*Units::deg, 1.0*Units::deg,
+//                                      0.5*Units::deg, 0.5*Units::deg), true);
+
+    std::vector<double> x = {Units::deg2rad(0.5), Units::deg2rad(-0.5), Units::deg2rad(0.5), Units::deg2rad(-0.5), Units::deg2rad(0.5)};
+    std::vector<double> y = {Units::deg2rad(1.8), Units::deg2rad(1.8), Units::deg2rad(0.1), Units::deg2rad(0.1), Units::deg2rad(1.8)};
+    result->addMask(Geometry::Polygon(x, y), true);
+
+
 
     return result;
 }

GUI/coregui/Models/TransformFromDomain.cpp

@@ -519,9 +519,41 @@ void TransformFromDomain::setDetectorMasks(DetectorItem *detectorItem, const GIS
                 ellipseItem->setRegisteredProperty(EllipseItem::P_WIDTH, Units::rad2deg(ellipse->getRadiusX()));
                 ellipseItem->setRegisteredProperty(EllipseItem::P_HEIGHT, Units::rad2deg(ellipse->getRadiusY()));
                 ellipseItem->setRegisteredProperty(EllipseItem::P_ANGLE, Units::rad2deg(ellipse->getTheta()));
+                ellipseItem->setRegisteredProperty(MaskItem::P_MASK_VALUE, mask_value);
                 containerItem->insertChildItem(0, ellipseItem);
 
             }
+
+            else if(const Geometry::Rectangle *rectangle = dynamic_cast<const Geometry::Rectangle *>(shape)) {
+                RectangleItem *rectangleItem = new RectangleItem();
+                rectangleItem->setRegisteredProperty(RectangleItem::P_XLOW, Units::rad2deg(rectangle->getXlow()));
+                rectangleItem->setRegisteredProperty(RectangleItem::P_YLOW, Units::rad2deg(rectangle->getYlow()));
+                rectangleItem->setRegisteredProperty(RectangleItem::P_XUP, Units::rad2deg(rectangle->getXup()));
+                rectangleItem->setRegisteredProperty(RectangleItem::P_YUP, Units::rad2deg(rectangle->getYup()));
+                rectangleItem->setRegisteredProperty(MaskItem::P_MASK_VALUE, mask_value);
+                containerItem->insertChildItem(0, rectangleItem);
+
+            }
+
+            else if(const Geometry::Polygon *polygon = dynamic_cast<const Geometry::Polygon *>(shape)) {
+                PolygonItem *polygonItem = new PolygonItem();
+                std::vector<double> xpos, ypos;
+                polygon->getPoints(xpos, ypos);
+                for(size_t i_point=0; i_point<xpos.size(); ++i_point) {
+                    PolygonPointItem *pointItem = new PolygonPointItem();
+                    pointItem->setRegisteredProperty(PolygonPointItem::P_POSX, Units::rad2deg(xpos[i_point]));
+                    pointItem->setRegisteredProperty(PolygonPointItem::P_POSY, Units::rad2deg(ypos[i_point]));
+                    polygonItem->insertChildItem(-1, pointItem);
+                }
+
+                polygonItem->setRegisteredProperty(MaskItem::P_MASK_VALUE, mask_value);
+                polygonItem->setRegisteredProperty(PolygonItem::P_ISCLOSED, true);
+
+                containerItem->insertChildItem(0, polygonItem);
+
+            }
+
+
             else {
                 throw GUIHelpers::Error("TransformFromDomain::setDetectorMasks() -> Error. "
                                         "Unknown shape");

GUI/coregui/Views/MaskWidgets/MaskEditor.cpp

@@ -109,26 +109,13 @@ void MaskEditor::init_test_model()
     Q_ASSERT(container);
 
     RectangleItem *rect = new RectangleItem();
-//    rect->setRegisteredProperty(RectangleItem::P_POSX, 0.6);
-//    rect->setRegisteredProperty(RectangleItem::P_POSY, 1.5);
-//    rect->setRegisteredProperty(RectangleItem::P_WIDTH, 0.3);
-//    rect->setRegisteredProperty(RectangleItem::P_HEIGHT, 0.2);
     rect->setRegisteredProperty(RectangleItem::P_XLOW, 0.6);
     rect->setRegisteredProperty(RectangleItem::P_YLOW, 1.3);
     rect->setRegisteredProperty(RectangleItem::P_XUP, 0.9);
     rect->setRegisteredProperty(RectangleItem::P_YUP, 1.5);
-
     container->insertChildItem(-1, rect);
 
 
-
-//    RectangleItem *rect = dynamic_cast<RectangleItem *>(m_maskModel->insertNewItem(Constants::RectangleMaskType, m_maskModel->indexOfItem(item)));
-//    Q_ASSERT(rect);
-//    rect->setRegisteredProperty(RectangleItem::P_POSX, 0.6);
-//    rect->setRegisteredProperty(RectangleItem::P_POSY, 1.5);
-//    rect->setRegisteredProperty(RectangleItem::P_WIDTH, 0.3);
-//    rect->setRegisteredProperty(RectangleItem::P_HEIGHT, 0.2);
-
     // Polygon
 //    ParameterizedItem *poly = m_maskModel->insertNewItem(Constants::PolygonMaskType, m_maskModel->indexOfItem(item));
 

Tests/UnitTests/TestCore/PolygonTest.h

@@ -121,4 +121,21 @@ TEST_F(PolygonTest, ConstructFrom2DArray)
     EXPECT_FALSE(polygon.contains(4.0, -2.01));
 }
 
+//TEST_F(PolygonTest, GetPoints)
+//{
+//    std::vector<double> xpos;
+//    std::vector<double> ypos;
+
+//    std::vector<double> x = {4.0, -4.0, -4.0, 4.0, 4.0};
+//    std::vector<double> y = {2.0, 2.0, -2.0, -2.0, 2.0};
+//    Geometry::Polygon polygon(x, y);
+
+//    polygon.getPoints(xpos, ypos);
+//    for(size_t i=0; i<xpos.size(); ++i) {
+//        std::cout << xpos[i] << " " << ypos[i] << std::endl;
+//    }
+
+//}
+
+
 #endif