More generalized code.

MultiImageLayer and FlatLayer now use the same code for arranging nodes,
rather than then same logic twice.

src/FlatLayerVisualisation.cpp

@@ -83,32 +83,11 @@ void FlatLayerVisualisation::initializeNodePositions()
 {
     switch (ordering) {
         case Ordering::LINE:
-            computeNodePositionsLine();
+            initNodePositions<Ordering::LINE>(faceCount / 4, 2);
             break;
 
         case Ordering::SQUARE:
-            computeNodePositionsSquare();
+            initNodePositions<Ordering::SQUARE>(faceCount / 4, 2);
             break;
     }
 }
-
-void FlatLayerVisualisation::computeNodePositionsSquare()
-{
-    const auto nodes = static_cast<int>(faceCount / 4);
-    const auto columns = numCols(nodes);
-
-    for (auto i : Range(nodes)) {
-        nodePositions_[3 * i + 0] = 0;
-        nodePositions_[3 * i + 1] = 2 * (i / columns);
-        nodePositions_[3 * i + 2] = -2 * (i % columns);
-    }
-}
-
-void FlatLayerVisualisation::computeNodePositionsLine()
-{
-    for (auto i : Range(static_cast<int>(faceCount / 4))) {
-        nodePositions_[3 * i + 0] = 0;
-        nodePositions_[3 * i + 1] = 0;
-        nodePositions_[3 * i + 2] = -2.0f * i;
-    }
-}

src/FlatLayerVisualisation.hpp

@@ -10,11 +10,6 @@ namespace fmri
     class FlatLayerVisualisation : public LayerVisualisation
     {
     public:
-        enum class Ordering {
-            LINE,
-            SQUARE,
-        };
-
         explicit FlatLayerVisualisation(const LayerData &layer, Ordering ordering);
 
         void render() override;
@@ -43,7 +38,5 @@ namespace fmri
 
         // Various functions defining the way the nodes will be aligned.
         void initializeNodePositions();
-        void computeNodePositionsLine();
-        void computeNodePositionsSquare();
     };
 }

src/LayerVisualisation.cpp

@@ -1,4 +1,6 @@
 #include "LayerVisualisation.hpp"
+#include "Range.hpp"
+#include "utils.hpp"
 
 const std::vector<float> &fmri::LayerVisualisation::nodePositions() const
 {
@@ -9,3 +11,30 @@ fmri::LayerVisualisation::LayerVisualisation(size_t numNodes)
         : nodePositions_(numNodes * 3)
 {
 }
+
+template<>
+void fmri::LayerVisualisation::initNodePositions<fmri::LayerVisualisation::Ordering::LINE>(size_t n, float spacing)
+{
+    nodePositions_.clear();
+    nodePositions_.reserve(3 * n);
+
+    for (auto i : Range(n)) {
+        nodePositions_.push_back(0);
+        nodePositions_.push_back(0);
+        nodePositions_.push_back(-spacing * i);
+    }
+}
+
+template<>
+void fmri::LayerVisualisation::initNodePositions<fmri::LayerVisualisation::Ordering::SQUARE>(size_t n, float spacing)
+{
+    nodePositions_.clear();
+    nodePositions_.reserve(3 * n);
+    const auto columns = numCols(n);
+
+    for (auto i : Range(n)) {
+        nodePositions_.push_back(0);
+        nodePositions_.push_back(spacing * (i / columns));
+        nodePositions_.push_back(-spacing * (i % columns));
+    }
+}

src/LayerVisualisation.hpp

@@ -7,8 +7,13 @@ namespace fmri
     class LayerVisualisation
     {
     public:
+        enum class Ordering {
+            LINE,
+            SQUARE,
+        };
+
         LayerVisualisation() = default;
-        LayerVisualisation(size_t numNodes);
+        explicit LayerVisualisation(size_t numNodes);
         virtual ~LayerVisualisation() = default;
 
         virtual void render() = 0;
@@ -16,5 +21,8 @@ namespace fmri
 
     protected:
         std::vector<float> nodePositions_;
+
+        template<Ordering Order>
+        void initNodePositions(size_t n, float spacing);
     };
 }

src/MultiImageVisualisation.cpp

@@ -18,14 +18,8 @@ MultiImageVisualisation::MultiImageVisualisation(const fmri::LayerData &layer)
 
     CHECK_EQ(1, images) << "Only single input image is supported" << endl;
 
-    nodePositions_.resize(channels * 3);
-    const int columns = numCols(channels);
     texture = loadTexture(layer.data(), width, channels * height, channels);
-    for (auto i : Range(channels)) {
+    initNodePositions<Ordering::SQUARE>(channels, 3);
-        nodePositions_[3 * i + 0] = 0;
-        nodePositions_[3 * i + 1] = 3 * (i / columns);
-        nodePositions_[3 * i + 2] = -3 * (i % columns);
-    }
 
     vertexBuffer = std::make_unique<float[]>(channels * BASE_VERTICES.size());
     texCoordBuffer = std::make_unique<float[]>(channels * 2u * BASE_VERTICES.size() / 3);