diff --git a/src/processing/CMakeLists.txt b/src/processing/CMakeLists.txt
index 689355a..2b62efc 100644
--- a/src/processing/CMakeLists.txt
+++ b/src/processing/CMakeLists.txt
@@ -1,5 +1,5 @@
 
-add_library(processing STATIC src/Pedestal.cpp)
+add_library(processing  ${CMAKE_CURRENT_SOURCE_DIR}/src/placeholder_processing.cpp)
 target_include_directories(processing PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
 target_link_libraries(processing PUBLIC core)
 
diff --git a/src/processing/include/aare/processing/Pedestal.hpp b/src/processing/include/aare/processing/Pedestal.hpp
index 8766c41..9b53ad1 100644
--- a/src/processing/include/aare/processing/Pedestal.hpp
+++ b/src/processing/include/aare/processing/Pedestal.hpp
@@ -8,9 +8,67 @@ namespace aare {
 
 template <typename SUM_TYPE = double> class Pedestal {
   public:
-    Pedestal(uint32_t rows, uint32_t cols, uint32_t n_samples = 1000);
-    ~Pedestal();
+    Pedestal(uint32_t rows, uint32_t cols, uint32_t n_samples = 1000)
+        : m_rows(rows), m_cols(cols), m_freeze(false), m_samples(n_samples),           m_cur_samples(NDArray<uint32_t, 2>({rows, cols}, 0)),m_sum(NDArray<SUM_TYPE, 2>({rows, cols})),
+ m_sum2(NDArray<SUM_TYPE, 2>({rows, cols})) {
+        assert(rows > 0 && cols > 0 && n_samples > 0);
+        m_sum = 0;
+        m_sum2 = 0;
+    }
+    ~Pedestal() = default;
 
+    NDArray<SUM_TYPE, 2> mean() {
+        NDArray<SUM_TYPE, 2> mean_array({m_rows, m_cols});
+        for (uint32_t i = 0; i < m_rows * m_cols; i++) {
+            mean_array(i / m_cols, i % m_cols) = mean(i / m_cols, i % m_cols);
+        }
+        return mean_array;
+    }
+
+    NDArray<SUM_TYPE, 2> variance() {
+        NDArray<SUM_TYPE, 2> variance_array({m_rows, m_cols});
+        for (uint32_t i = 0; i < m_rows * m_cols; i++) {
+            variance_array(i / m_cols, i % m_cols) = variance(i / m_cols, i % m_cols);
+        }
+        return variance_array;
+    }
+
+    NDArray<SUM_TYPE, 2> standard_deviation() {
+        NDArray<SUM_TYPE, 2> standard_deviation_array({m_rows, m_cols});
+        for (uint32_t i = 0; i < m_rows * m_cols; i++) {
+            standard_deviation_array(i / m_cols, i % m_cols) = standard_deviation(i / m_cols, i % m_cols);
+        }
+
+        return standard_deviation_array;
+    }
+    void clear() {
+        for (uint32_t i = 0; i < m_rows * m_cols; i++) {
+            clear(i / m_cols, i % m_cols);
+        }
+    }
+
+    /*
+     * index level operations
+     */
+    SUM_TYPE mean(const uint32_t row, const uint32_t col) const {
+        if (m_cur_samples(row, col) == 0) {
+            return 0.0;
+        }
+        return m_sum(row, col) / m_cur_samples(row, col);
+    }
+    SUM_TYPE variance(const uint32_t row, const uint32_t col) const {
+        if (m_cur_samples(row, col) == 0) {
+            return 0.0;
+        }
+        return m_sum2(row, col) / m_cur_samples(row, col) - mean(row, col) * mean(row, col);
+    }
+    SUM_TYPE standard_deviation(const uint32_t row, const uint32_t col) const { return std::sqrt(variance(row, col)); }
+
+    void clear(const uint32_t row, const uint32_t col) {
+        m_sum(row, col) = 0;
+        m_sum2(row, col) = 0;
+        m_cur_samples(row, col) = 0;
+    }
     // frame level operations
     template <typename T> void push(NDView<T, 2> frame) {
         assert(frame.size() == m_rows * m_cols);
@@ -23,39 +81,32 @@ template <typename SUM_TYPE = double> class Pedestal {
         assert(frame.rows() == static_cast<size_t>(m_rows) && frame.cols() == static_cast<size_t>(m_cols));
         push<T>(frame.view<T>());
     }
-    NDArray<SUM_TYPE> mean();
-    NDArray<SUM_TYPE> variance();
-    NDArray<SUM_TYPE> standard_deviation();
-    void clear();
 
     // getter functions
     inline uint32_t rows() const { return m_rows; }
     inline uint32_t cols() const { return m_cols; }
     inline uint32_t n_samples() const { return m_samples; }
-    inline uint32_t *cur_samples() const { return m_cur_samples; }
+    inline NDArray<uint32_t, 2> cur_samples() const { return m_cur_samples; }
     inline NDArray<SUM_TYPE, 2> get_sum() const { return m_sum; }
     inline NDArray<SUM_TYPE, 2> get_sum2() const { return m_sum2; }
 
     // pixel level operations (should be refactored to allow users to implement their own pixel level operations)
-    template <typename T> inline void push(const uint32_t row, const uint32_t col, const T val) {
+    template <typename T> inline void push(const uint32_t row, const uint32_t col, const T val_) {
         if (m_freeze) {
             return;
         }
+        SUM_TYPE val = static_cast<SUM_TYPE>(val_);
         const uint32_t idx = index(row, col);
-        if (m_cur_samples[idx] < m_samples) {
+        if (m_cur_samples(idx) < m_samples) {
             m_sum(idx) += val;
             m_sum2(idx) += val * val;
-            m_cur_samples[idx]++;
+            m_cur_samples(idx)++;
         } else {
-            m_sum(idx) += val - m_sum(idx) / m_cur_samples[idx];
-            m_sum2(idx) += val * val - m_sum2(idx) / m_cur_samples[idx];
+            m_sum(idx) += val - m_sum(idx) / m_cur_samples(idx);
+            m_sum2(idx) += val * val - m_sum2(idx) / m_cur_samples(idx);
         }
     }
-    SUM_TYPE mean(const uint32_t row, const uint32_t col) const;
-    SUM_TYPE variance(const uint32_t row, const uint32_t col) const;
-    SUM_TYPE standard_deviation(const uint32_t row, const uint32_t col) const;
     inline uint32_t index(const uint32_t row, const uint32_t col) const { return row * m_cols + col; };
-    void clear(const uint32_t row, const uint32_t col);
     void set_freeze(bool freeze) { m_freeze = freeze; }
 
   private:
@@ -63,7 +114,7 @@ template <typename SUM_TYPE = double> class Pedestal {
     uint32_t m_cols;
     bool m_freeze;
     uint32_t m_samples;
-    uint32_t *m_cur_samples{nullptr};
+    NDArray<uint32_t, 2> m_cur_samples;
     NDArray<SUM_TYPE, 2> m_sum;
     NDArray<SUM_TYPE, 2> m_sum2;
 };
diff --git a/src/processing/src/Pedestal.cpp b/src/processing/src/Pedestal.cpp
deleted file mode 100644
index 874ea8c..0000000
--- a/src/processing/src/Pedestal.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#include "aare/processing/Pedestal.hpp"
-#include <cmath>
-#include <cstddef>
-
-namespace aare {
-template <typename SUM_TYPE>
-Pedestal<SUM_TYPE>::Pedestal(uint32_t rows, uint32_t cols, uint32_t n_samples)
-    : m_freeze(false), m_rows(rows), m_cols(cols), m_samples(n_samples), m_sum(NDArray<SUM_TYPE, 2>({rows, cols})),
-      m_sum2(NDArray<SUM_TYPE, 2>({rows, cols})), m_cur_samples(new uint32_t[rows * cols]{}) {
-    assert(rows > 0 && cols > 0 && n_samples > 0);
-    m_sum = 0;
-    m_sum2 = 0;
-}
-
-template <typename SUM_TYPE> NDArray<SUM_TYPE, 2> Pedestal<SUM_TYPE>::mean() {
-    NDArray<SUM_TYPE, 2> mean_array({m_rows, m_cols});
-    for (uint32_t i = 0; i < m_rows * m_cols; i++) {
-        mean_array(i / m_cols, i % m_cols) = mean(i / m_cols, i % m_cols);
-    }
-    return mean_array;
-}
-
-template <typename SUM_TYPE> NDArray<SUM_TYPE, 2> Pedestal<SUM_TYPE>::variance() {
-    NDArray<SUM_TYPE, 2> variance_array({m_rows, m_cols});
-    for (uint32_t i = 0; i < m_rows * m_cols; i++) {
-        variance_array(i / m_cols, i % m_cols) = variance(i / m_cols, i % m_cols);
-    }
-    return variance_array;
-}
-
-template <typename SUM_TYPE> NDArray<SUM_TYPE, 2> Pedestal<SUM_TYPE>::standard_deviation() {
-    NDArray<SUM_TYPE, 2> standard_deviation_array({m_rows, m_cols});
-    for (uint32_t i = 0; i < m_rows * m_cols; i++) {
-        standard_deviation_array(i / m_cols, i % m_cols) = standard_deviation(i / m_cols, i % m_cols);
-    }
-
-    return standard_deviation_array;
-}
-template <typename SUM_TYPE> void Pedestal<SUM_TYPE>::clear() {
-    for (uint32_t i = 0; i < m_rows * m_cols; i++) {
-        clear(i / m_cols, i % m_cols);
-    }
-}
-
-/*
- * index level operations
- */
-template <typename SUM_TYPE> SUM_TYPE Pedestal<SUM_TYPE>::mean(const uint32_t row, const uint32_t col) const {
-    if (m_cur_samples[index(row, col)] == 0) {
-        return 0.0;
-    }
-    return m_sum(row, col) / m_cur_samples[index(row, col)];
-}
-template <typename SUM_TYPE> SUM_TYPE Pedestal<SUM_TYPE>::variance(const uint32_t row, const uint32_t col) const {
-    if (m_cur_samples[index(row, col)] == 0) {
-        return 0.0;
-    }
-    return m_sum2(row, col) / m_cur_samples[index(row, col)] - mean(row, col) * mean(row, col);
-}
-template <typename SUM_TYPE> SUM_TYPE Pedestal<SUM_TYPE>::standard_deviation(const uint32_t row, const uint32_t col) const {
-    return std::sqrt(variance(row, col));
-}
-
-template <typename SUM_TYPE> void Pedestal<SUM_TYPE>::clear(const uint32_t row, const uint32_t col) {
-    m_sum(row, col) = 0;
-    m_sum2(row, col) = 0;
-    m_cur_samples[index(row, col)] = 0;
-}
-
-template <typename SUM_TYPE> Pedestal<SUM_TYPE>::~Pedestal() { delete[] m_cur_samples; }
-
-template class Pedestal<double>;
-template class Pedestal<float>;
-template class Pedestal<long double>;
-
-} // namespace aare
\ No newline at end of file
diff --git a/src/processing/src/placeholder_processing.cpp b/src/processing/src/placeholder_processing.cpp
new file mode 100644
index 0000000..e69de29
diff --git a/src/processing/test/Pedestal.test.cpp b/src/processing/test/Pedestal.test.cpp
index 3981056..32d8ca8 100644
--- a/src/processing/test/Pedestal.test.cpp
+++ b/src/processing/test/Pedestal.test.cpp
@@ -10,12 +10,11 @@ TEST_CASE("test pedestal constructor") {
     REQUIRE(pedestal.rows() == 10);
     REQUIRE(pedestal.cols() == 10);
     REQUIRE(pedestal.n_samples() == 5);
-    REQUIRE(pedestal.cur_samples() != nullptr);
     for (int i = 0; i < 10; i++) {
         for (int j = 0; j < 10; j++) {
             REQUIRE(pedestal.get_sum()(i, j) == 0);
             REQUIRE(pedestal.get_sum2()(i, j) == 0);
-            REQUIRE(pedestal.cur_samples()[pedestal.index(i, j)] == 0);
+            REQUIRE(pedestal.cur_samples()(i, j) == 0);
         }
     }
 }
@@ -35,7 +34,7 @@ TEST_CASE("test pedestal push") {
         for (int j = 0; j < 10; j++) {
             REQUIRE(pedestal.get_sum()(i, j) == i + j);
             REQUIRE(pedestal.get_sum2()(i, j) == (i + j) * (i + j));
-            REQUIRE(pedestal.cur_samples()[pedestal.index(i, j)] == 1);
+            REQUIRE(pedestal.cur_samples()(i, j) == 1);
         }
     }
 
@@ -45,7 +44,7 @@ TEST_CASE("test pedestal push") {
         for (int j = 0; j < 10; j++) {
             REQUIRE(pedestal.get_sum()(i, j) == 0);
             REQUIRE(pedestal.get_sum2()(i, j) == 0);
-            REQUIRE(pedestal.cur_samples()[pedestal.index(i, j)] == 0);
+            REQUIRE(pedestal.cur_samples()(i, j) == 0);
         }
     }
 
@@ -55,11 +54,11 @@ TEST_CASE("test pedestal push") {
         for (uint32_t i = 0; i < 10; i++) {
             for (uint32_t j = 0; j < 10; j++) {
                 if (k < 5) {
-                    REQUIRE(pedestal.cur_samples()[pedestal.index(i, j)] == k + 1);
+                    REQUIRE(pedestal.cur_samples()(i, j) == k + 1);
                     REQUIRE(pedestal.get_sum()(i, j) == (k + 1) * (i + j));
                     REQUIRE(pedestal.get_sum2()(i, j) == (k + 1) * (i + j) * (i + j));
                 } else {
-                    REQUIRE(pedestal.cur_samples()[pedestal.index(i, j)] == 5);
+                    REQUIRE(pedestal.cur_samples()(i, j) == 5);
                     REQUIRE(pedestal.get_sum()(i, j) == 5 * (i + j));
                     REQUIRE(pedestal.get_sum2()(i, j) == 5 * (i + j) * (i + j));
                 }