adapt Roughness handling; minor changes

GUI/Model/From/FromDomain.cpp

@@ -373,14 +373,15 @@ void GUI::Transform::FromDomain::setLayerItem(LayerItem* layerItem, const Layer*
                                               const LayerInterface* top_interface)
 {
     layerItem->thickness().set(layer->thickness());
-    layerItem->setRoughnessType<LayerZeroRoughnessItem>();
+    layerItem->clearRoughness();
     layerItem->numSlices().set(layer->numberOfSlices());
 
     if (top_interface) {
         const LayerRoughness* roughness = top_interface->roughness();
         if (GUI::Transform::FromDomain::isValidRoughness(roughness)) {
-            auto* roughnessItem = layerItem->setRoughnessType<LayerBasicRoughnessItem>();
-            GUI::Transform::FromDomain::setRoughnessItem(roughnessItem, *roughness);
+            layerItem->setBasicRoughness();
+            GUI::Transform::FromDomain::setRoughnessItem(layerItem->roughness().currentItem(),
+                                                         *roughness);
         }
     }
 }

GUI/Model/Sample/MultiLayerItem.cpp

@@ -28,7 +28,6 @@ const QString Name("Name");
 const QString Uid("Uid");
 } // namespace Tags
 
-
 } // namespace
 
 MultiLayerItem::MultiLayerItem()

GUI/Model/Session/SessionXML.h

@@ -17,10 +17,10 @@
 
 #include "GUI/Model/Types/DoubleDescriptor.h"
 #include <QVariant>
+#include <QXmlStreamWriter> // used in every including file
 #include <heinz/Complex.h>
 #include <heinz/Vectors3D.h>
 
-class QXmlStreamWriter;
 class QXmlStreamReader;
 class SessionItem;
 class MessageService;

GUI/Model/To/ToDomain.cpp

@@ -49,8 +49,9 @@ std::unique_ptr<MultiLayer> createMultiLayer(const MultiLayerItem& item)
     return P_multilayer;
 }
 
-std::unique_ptr<Layer> createLayer(const LayerItem& item, bool isFirstOrLastLayer)
+std::unique_ptr<Layer> createLayer(const LayerItem& item)
 {
+    const bool isFirstOrLastLayer = item.isTopLayer() || item.isBottomLayer();
     auto P_layer = std::make_unique<Layer>(*item.materialItem()->createMaterial(),
                                            isFirstOrLastLayer ? 0.0 : item.thickness());
     P_layer->setNumberOfSlices(item.numSlices());
@@ -109,9 +110,9 @@ std::unique_ptr<ParticleLayout> buildParticleLayout(const ParticleLayoutItem& it
     return P_layout;
 }
 
-std::unique_ptr<Layer> buildLayer(const LayerItem& item, bool isFirstOrLastLayer)
+std::unique_ptr<Layer> buildLayer(const LayerItem& item)
 {
-    auto P_layer = createLayer(item, isFirstOrLastLayer);
+    auto P_layer = createLayer(item);
     for (ParticleLayoutItem* layout : item.layouts()) {
         auto P_layout = buildParticleLayout(*layout);
         if (P_layout)
@@ -122,18 +123,13 @@ std::unique_ptr<Layer> buildLayer(const LayerItem& item, bool isFirstOrLastLayer
 
 } // namespace
 
-std::unique_ptr<LayerRoughness> GUI::Transform::ToDomain::createLayerRoughness(
-    const std::variant<LayerZeroRoughnessItem*, LayerBasicRoughnessItem*>& roughness)
+std::unique_ptr<LayerRoughness>
+GUI::Transform::ToDomain::createLayerRoughness(LayerBasicRoughnessItem* roughness)
 {
-    if (std::holds_alternative<LayerZeroRoughnessItem*>(roughness))
+    if (!roughness)
         return nullptr;
-    if (std::holds_alternative<LayerBasicRoughnessItem*>(roughness)) {
-        const auto& basicRoughnessItem = *std::get<LayerBasicRoughnessItem*>(roughness);
-        return std::make_unique<LayerRoughness>(basicRoughnessItem.sigma(),
-                                                basicRoughnessItem.hurst(),
-                                                basicRoughnessItem.lateralCorrelationLength());
-    }
-    ASSERT(0);
+    return std::make_unique<LayerRoughness>(roughness->sigma(), roughness->hurst(),
+                                            roughness->lateralCorrelationLength());
 }
 
 std::unique_ptr<MultiLayer>
@@ -141,17 +137,14 @@ GUI::Transform::ToDomain::buildMultiLayer(const MultiLayerItem& multiLayerItem)
 {
     auto P_multilayer = createMultiLayer(multiLayerItem);
     for (auto* layerItem : multiLayerItem.layers()) {
-        const bool isFirstLayer = layerItem == multiLayerItem.layers().first();
-        const bool isLastLayer = layerItem == multiLayerItem.layers().last();
-        auto P_layer = buildLayer(*layerItem, isFirstLayer || isLastLayer);
-        if (P_layer) {
-            const auto roughness = layerItem->roughness().currentItem();
-            auto P_roughness = createLayerRoughness(roughness);
-            if (P_roughness && !isFirstLayer)
-                P_multilayer->addLayerWithTopRoughness(*P_layer, *P_roughness);
-            else
-                P_multilayer->addLayer(*P_layer);
-        }
+        auto P_layer = buildLayer(*layerItem);
+        ASSERT(P_layer);
+        const auto roughness = layerItem->roughness().currentItem();
+        auto P_roughness = createLayerRoughness(roughness);
+        if (P_roughness && !layerItem->isTopLayer())
+            P_multilayer->addLayerWithTopRoughness(*P_layer, *P_roughness);
+        else
+            P_multilayer->addLayer(*P_layer);
     }
     return P_multilayer;
 }

GUI/Model/To/ToDomain.h

@@ -21,14 +21,12 @@
 class LayerItem;
 class MultiLayerItem;
 class MultiLayer;
-class LayerZeroRoughnessItem;
 class LayerBasicRoughnessItem;
 class LayerRoughness;
 
 namespace GUI::Transform::ToDomain {
 
-std::unique_ptr<LayerRoughness> createLayerRoughness(
-    const std::variant<LayerZeroRoughnessItem*, LayerBasicRoughnessItem*>& roughness);
+std::unique_ptr<LayerRoughness> createLayerRoughness(LayerBasicRoughnessItem* roughness);
 
 std::unique_ptr<MultiLayer> buildMultiLayer(const MultiLayerItem& item);