simplify FromCore getMasksSet

GUI/Model/FromCore/ItemizeSimulation.cpp

@@ -54,68 +54,54 @@ MasksSet* getMasksSet(const IDetector& detector)
 {
     auto* result = new MasksSet;
     const MaskStack* maskStack = detector.detectorMask();
-    for (size_t i_mask = 0; i_mask < maskStack->numberOfMasks(); ++i_mask) {
-        const auto [shape, mask_value] = maskStack->patternAt(i_mask);
+    for (size_t i = 0; i < maskStack->numberOfMasks(); ++i) {
+        const auto [shape, mask_value] = maskStack->patternAt(i);
 
+        MaskItem* mask_item = nullptr;
         if (const auto* ellipse = dynamic_cast<const Ellipse*>(shape)) {
-            auto* ellipseItem = new EllipseItem();
-            ellipseItem->setXCenter(ellipse->getCenterX());
-            ellipseItem->setYCenter(ellipse->getCenterY());
-            ellipseItem->setXRadius(ellipse->radiusX());
-            ellipseItem->setYRadius(ellipse->radiusY());
-            ellipseItem->setAngle(ellipse->getTheta());
-            ellipseItem->setMaskValue(mask_value);
-            // TODO: why prepend the mask, instead of appending it?
-            result->add_item(ellipseItem);
+            auto* m = new EllipseItem();
+            m->setXCenter(ellipse->getCenterX());
+            m->setYCenter(ellipse->getCenterY());
+            m->setXRadius(ellipse->radiusX());
+            m->setYRadius(ellipse->radiusY());
+            m->setAngle(ellipse->getTheta());
+            mask_item = m;
         }
 
         else if (const auto* rectangle = dynamic_cast<const Rectangle*>(shape)) {
-            auto* rectangleItem = new RectangleItem();
-            rectangleItem->setXLow(rectangle->getXlow());
-            rectangleItem->setYLow(rectangle->getYlow());
-            rectangleItem->setXHig(rectangle->getXup());
-            rectangleItem->setYHig(rectangle->getYup());
-            rectangleItem->setMaskValue(mask_value);
-            // TODO: why prepend the mask, instead of appending it?
-            result->add_item(rectangleItem);
+            auto* m = new RectangleItem();
+            m->setXLow(rectangle->getXlow());
+            m->setYLow(rectangle->getYlow());
+            m->setXHig(rectangle->getXup());
+            m->setYHig(rectangle->getYup());
+            mask_item = m;
         }
 
         else if (const auto* polygon = dynamic_cast<const Polygon*>(shape)) {
-            auto* polygonItem = new PolygonItem();
+            auto* m = new PolygonItem();
             std::vector<double> xpos, ypos;
             polygon->getPoints(xpos, ypos);
-            for (size_t i_point = 0; i_point < xpos.size(); ++i_point)
-                polygonItem->addPoint(xpos[i_point], ypos[i_point]);
-
-            polygonItem->setMaskValue(mask_value);
-            polygonItem->setIsClosed(true);
-            // TODO: why prepend the mask, instead of appending it?
-            result->add_item(polygonItem);
+            for (size_t ii = 0; ii < xpos.size(); ++ii)
+                m->addPoint(xpos[ii], ypos[ii]);
+            m->setIsClosed(true);
+            mask_item = m;
         }
 
-        else if (const auto* vline = dynamic_cast<const VerticalLine*>(shape)) {
-            auto* lineItem = new VerticalLineItem(vline->getXpos());
-            lineItem->setMaskValue(mask_value);
-            // TODO: why prepend the mask, instead of appending it?
-            result->add_item(lineItem);
-        }
+        else if (const auto* vline = dynamic_cast<const VerticalLine*>(shape))
+            mask_item = new VerticalLineItem(vline->getXpos());
 
-        else if (const auto* hline = dynamic_cast<const HorizontalLine*>(shape)) {
-            auto* lineItem = new HorizontalLineItem(hline->getYpos());
-            lineItem->setMaskValue(mask_value);
-            // TODO: why prepend the mask, instead of appending it?
-            result->add_item(lineItem);
-        }
+        else if (const auto* hline = dynamic_cast<const HorizontalLine*>(shape))
+            mask_item = new HorizontalLineItem(hline->getYpos());
 
-        else if (const auto* plane = dynamic_cast<const InfinitePlane*>(shape)) {
-            Q_UNUSED(plane);
-            auto* planeItem = new FullframeItem();
-            planeItem->setMaskValue(mask_value);
-            result->add_item(planeItem);
-        }
+        else if (dynamic_cast<const InfinitePlane*>(shape))
+            mask_item = new FullframeItem();
 
         else
             ASSERT_NEVER;
+
+        ASSERT(mask_item);
+        mask_item->setMaskValue(mask_value);
+        result->add_item(mask_item);
     }
 
     if (detector.hasExplicitRegionOfInterest()) {