detectors/aare
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/aare.git synced 2025-06-05 12:30:39 +02:00
Code Issues Actions Packages Releases Activity

change pedestal types (#79)

Browse Source 
Co-authored-by: Bechir <bechir.brahem420@gmail.com>
This commit is contained in:
Bechir Braham 2024-07-09 20:53:11 +02:00 committed by GitHub
parent 4f184ddf40
commit 4760648d87
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
5 changed files with 74 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/processing/CMakeLists.txt
View File

@ -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)

85
src/processing/include/aare/processing/Pedestal.hpp
View File

@ -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;
};

76
src/processing/src/Pedestal.cpp
View File

@ -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

0
src/processing/src/placeholder_processing.cpp Normal file
View File

11
src/processing/test/Pedestal.test.cpp
View File

@ -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));
}