detectors/aare
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/aare.git synced 2025-06-14 08:17:13 +02:00
Code Issues Actions Packages Releases Activity

change image to NDArray

Browse Source
This commit is contained in:
Bechir
2024-03-21 16:17:00 +01:00
parent c7ee7f3af4
commit 4ff2e18c6a
7 changed files with 109 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
core/include/aare/Frame.hpp
View File

@ -1,5 +1,5 @@
#pragma once
#include "aare/Image.hpp"
#include "aare/NDArray.hpp"
#include "aare/defs.hpp"
#include <cstddef>
#include <cstdint>
@ -47,8 +47,8 @@ class Frame {
}
template <typename T>
Image<T> image() {
return Image<T>(this->view<T>());
NDArray<T> image() {
return NDArray<T>(this->view<T>());
}
~Frame() { delete[] m_data; }

168
core/include/aare/Image.hpp → core/include/aare/NDArray.hpp
View File

@ -7,7 +7,7 @@ memory.
TODO! Add expression templates for operators
*/
#include "aare/View.hpp"
#include "aare/NDView.hpp"
#include <algorithm>
#include <array>
@ -19,47 +19,47 @@ TODO! Add expression templates for operators
#include <numeric>
template <typename T, ssize_t Ndim = 2> class Image {
template <typename T, ssize_t Ndim = 2> class NDArray {
public:
Image()
NDArray()
: shape_(), strides_(c_strides<Ndim>(shape_)), size_(0),
data_(nullptr){};
explicit Image(std::array<ssize_t, Ndim> shape)
explicit NDArray(std::array<ssize_t, Ndim> shape)
: shape_(shape), strides_(c_strides<Ndim>(shape_)),
size_(std::accumulate(shape_.begin(), shape_.end(), 1,
std::multiplies<ssize_t>())),
data_(new T[size_]){};
Image(std::array<ssize_t, Ndim> shape, T value) : Image(shape) {
NDArray(std::array<ssize_t, Ndim> shape, T value) : NDArray(shape) {
this->operator=(value);
}
/* When constructing from a View we need to copy the data since
Image expect to own its data, and span is just a view*/
Image(View<T, Ndim> span):Image(span.shape()){
/* When constructing from a NDView we need to copy the data since
NDArray expect to own its data, and span is just a view*/
NDArray(NDView<T, Ndim> span):NDArray(span.shape()){
std::copy(span.begin(), span.end(), begin());
// fmt::print("Image(View<T, Ndim> span)\n");
// fmt::print("NDArray(NDView<T, Ndim> span)\n");
}
// Move constructor
Image(Image &&other)
NDArray(NDArray &&other)
: shape_(other.shape_), strides_(c_strides<Ndim>(shape_)),
size_(other.size_), data_(nullptr) {
data_ = other.data_;
other.reset();
// fmt::print("Image(Image &&other)\n");
// fmt::print("NDArray(NDArray &&other)\n");
}
// Copy constructor
Image(const Image &other)
NDArray(const NDArray &other)
: shape_(other.shape_), strides_(c_strides<Ndim>(shape_)),
size_(other.size_), data_(new T[size_]) {
std::copy(other.data_, other.data_ + size_, data_);
// fmt::print("Image(const Image &other)\n");
// fmt::print("NDArray(const NDArray &other)\n");
}
~Image() {
~NDArray() {
delete[] data_;
}
@ -68,19 +68,19 @@ template <typename T, ssize_t Ndim = 2> class Image {
using value_type = T;
Image &operator=(Image &&other); // Move assign
Image &operator=(const Image &other); // Copy assign
NDArray &operator=(NDArray &&other); // Move assign
NDArray &operator=(const NDArray &other); // Copy assign
Image operator+(const Image &other);
Image &operator+=(const Image &other);
Image operator-(const Image &other);
Image &operator-=(const Image &other);
Image operator*(const Image &other);
Image &operator*=(const Image &other);
Image operator/(const Image &other);
// Image& operator/=(const Image& other);
NDArray operator+(const NDArray &other);
NDArray &operator+=(const NDArray &other);
NDArray operator-(const NDArray &other);
NDArray &operator-=(const NDArray &other);
NDArray operator*(const NDArray &other);
NDArray &operator*=(const NDArray &other);
NDArray operator/(const NDArray &other);
// NDArray& operator/=(const NDArray& other);
template <typename V>
Image &operator/=(const Image<V, Ndim> &other) {
NDArray &operator/=(const NDArray<V, Ndim> &other) {
// check shape
if (shape_ == other.shape()) {
for (int i = 0; i < size_; ++i) {
@ -88,26 +88,26 @@ template <typename T, ssize_t Ndim = 2> class Image {
}
return *this;
} else {
throw(std::runtime_error("Shape of Image must match"));
throw(std::runtime_error("Shape of NDArray must match"));
}
}
Image<bool, Ndim> operator>(const Image &other);
NDArray<bool, Ndim> operator>(const NDArray &other);
bool operator==(const Image &other) const;
bool operator!=(const Image &other) const;
bool operator==(const NDArray &other) const;
bool operator!=(const NDArray &other) const;
Image &operator=(const T &);
Image &operator+=(const T &);
Image operator+(const T &);
Image &operator-=(const T &);
Image operator-(const T &);
Image &operator*=(const T &);
Image operator*(const T &);
Image &operator/=(const T &);
Image operator/(const T &);
NDArray &operator=(const T &);
NDArray &operator+=(const T &);
NDArray operator+(const T &);
NDArray &operator-=(const T &);
NDArray operator-(const T &);
NDArray &operator*=(const T &);
NDArray operator*(const T &);
NDArray &operator/=(const T &);
NDArray operator/(const T &);
Image &operator&=(const T &);
NDArray &operator&=(const T &);
void sqrt() {
for (int i = 0; i < size_; ++i) {
@ -115,7 +115,7 @@ template <typename T, ssize_t Ndim = 2> class Image {
}
}
Image &operator++(); // pre inc
NDArray &operator++(); // pre inc
template <typename... Ix>
typename std::enable_if<sizeof...(Ix) == Ndim, T &>::type
@ -153,7 +153,7 @@ template <typename T, ssize_t Ndim = 2> class Image {
// return strides_;
}
View<T, Ndim> span() const { return View<T, Ndim>{data_, shape_}; }
NDView<T, Ndim> span() const { return NDView<T, Ndim>{data_, shape_}; }
void Print();
void Print_all();
@ -175,7 +175,7 @@ template <typename T, ssize_t Ndim = 2> class Image {
// Move assign
template <typename T, ssize_t Ndim>
Image<T, Ndim> &Image<T, Ndim>::operator=(Image<T, Ndim> &&other) {
NDArray<T, Ndim> &NDArray<T, Ndim>::operator=(NDArray<T, Ndim> &&other) {
if (this != &other) {
delete[] data_;
data_ = other.data_;
@ -188,14 +188,14 @@ Image<T, Ndim> &Image<T, Ndim>::operator=(Image<T, Ndim> &&other) {
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> Image<T, Ndim>::operator+(const Image &other) {
Image result(*this);
NDArray<T, Ndim> NDArray<T, Ndim>::operator+(const NDArray &other) {
NDArray result(*this);
result += other;
return result;
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> &
Image<T, Ndim>::operator+=(const Image<T, Ndim> &other) {
NDArray<T, Ndim> &
NDArray<T, Ndim>::operator+=(const NDArray<T, Ndim> &other) {
// check shape
if (shape_ == other.shape_) {
for (int i = 0; i < size_; ++i) {
@ -208,15 +208,15 @@ Image<T, Ndim>::operator+=(const Image<T, Ndim> &other) {
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> Image<T, Ndim>::operator-(const Image &other) {
Image result{*this};
NDArray<T, Ndim> NDArray<T, Ndim>::operator-(const NDArray &other) {
NDArray result{*this};
result -= other;
return result;
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> &
Image<T, Ndim>::operator-=(const Image<T, Ndim> &other) {
NDArray<T, Ndim> &
NDArray<T, Ndim>::operator-=(const NDArray<T, Ndim> &other) {
// check shape
if (shape_ == other.shape_) {
for (int i = 0; i < size_; ++i) {
@ -228,15 +228,15 @@ Image<T, Ndim>::operator-=(const Image<T, Ndim> &other) {
}
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> Image<T, Ndim>::operator*(const Image &other) {
Image result = *this;
NDArray<T, Ndim> NDArray<T, Ndim>::operator*(const NDArray &other) {
NDArray result = *this;
result *= other;
return result;
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> &
Image<T, Ndim>::operator*=(const Image<T, Ndim> &other) {
NDArray<T, Ndim> &
NDArray<T, Ndim>::operator*=(const NDArray<T, Ndim> &other) {
// check shape
if (shape_ == other.shape_) {
for (int i = 0; i < size_; ++i) {
@ -249,21 +249,21 @@ Image<T, Ndim>::operator*=(const Image<T, Ndim> &other) {
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> Image<T, Ndim>::operator/(const Image &other) {
Image result = *this;
NDArray<T, Ndim> NDArray<T, Ndim>::operator/(const NDArray &other) {
NDArray result = *this;
result /= other;
return result;
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> &Image<T, Ndim>::operator&=(const T &mask) {
NDArray<T, Ndim> &NDArray<T, Ndim>::operator&=(const T &mask) {
for (auto it = begin(); it != end(); ++it)
*it &= mask;
return *this;
}
// template <typename T, ssize_t Ndim>
// Image<T, Ndim>& Image<T, Ndim>::operator/=(const Image<T, Ndim>&
// NDArray<T, Ndim>& NDArray<T, Ndim>::operator/=(const NDArray<T, Ndim>&
// other)
// {
// //check shape
@ -278,9 +278,9 @@ Image<T, Ndim> &Image<T, Ndim>::operator&=(const T &mask) {
// }
template <typename T, ssize_t Ndim>
Image<bool, Ndim> Image<T, Ndim>::operator>(const Image &other) {
NDArray<bool, Ndim> NDArray<T, Ndim>::operator>(const NDArray &other) {
if (shape_ == other.shape_) {
Image<bool> result{shape_};
NDArray<bool> result{shape_};
for (int i = 0; i < size_; ++i) {
result(i) = (data_[i] > other.data_[i]);
}
@ -291,8 +291,8 @@ Image<bool, Ndim> Image<T, Ndim>::operator>(const Image &other) {
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> &
Image<T, Ndim>::operator=(const Image<T, Ndim> &other) {
NDArray<T, Ndim> &
NDArray<T, Ndim>::operator=(const NDArray<T, Ndim> &other) {
if (this != &other) {
delete[] data_;
shape_ = other.shape_;
@ -305,7 +305,7 @@ Image<T, Ndim>::operator=(const Image<T, Ndim> &other) {
}
template <typename T, ssize_t Ndim>
bool Image<T, Ndim>::operator==(const Image<T, Ndim> &other) const {
bool NDArray<T, Ndim>::operator==(const NDArray<T, Ndim> &other) const {
if (shape_ != other.shape_)
return false;
@ -317,78 +317,78 @@ bool Image<T, Ndim>::operator==(const Image<T, Ndim> &other) const {
}
template <typename T, ssize_t Ndim>
bool Image<T, Ndim>::operator!=(const Image<T, Ndim> &other) const {
bool NDArray<T, Ndim>::operator!=(const NDArray<T, Ndim> &other) const {
return !((*this) == other);
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> &Image<T, Ndim>::operator++() {
NDArray<T, Ndim> &NDArray<T, Ndim>::operator++() {
for (int i = 0; i < size_; ++i)
data_[i] += 1;
return *this;
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> &Image<T, Ndim>::operator=(const T &value) {
NDArray<T, Ndim> &NDArray<T, Ndim>::operator=(const T &value) {
std::fill_n(data_, size_, value);
return *this;
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> &Image<T, Ndim>::operator+=(const T &value) {
NDArray<T, Ndim> &NDArray<T, Ndim>::operator+=(const T &value) {
for (int i = 0; i < size_; ++i)
data_[i] += value;
return *this;
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> Image<T, Ndim>::operator+(const T &value) {
Image result = *this;
NDArray<T, Ndim> NDArray<T, Ndim>::operator+(const T &value) {
NDArray result = *this;
result += value;
return result;
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> &Image<T, Ndim>::operator-=(const T &value) {
NDArray<T, Ndim> &NDArray<T, Ndim>::operator-=(const T &value) {
for (int i = 0; i < size_; ++i)
data_[i] -= value;
return *this;
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> Image<T, Ndim>::operator-(const T &value) {
Image result = *this;
NDArray<T, Ndim> NDArray<T, Ndim>::operator-(const T &value) {
NDArray result = *this;
result -= value;
return result;
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> &Image<T, Ndim>::operator/=(const T &value) {
NDArray<T, Ndim> &NDArray<T, Ndim>::operator/=(const T &value) {
for (int i = 0; i < size_; ++i)
data_[i] /= value;
return *this;
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> Image<T, Ndim>::operator/(const T &value) {
Image result = *this;
NDArray<T, Ndim> NDArray<T, Ndim>::operator/(const T &value) {
NDArray result = *this;
result /= value;
return result;
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> &Image<T, Ndim>::operator*=(const T &value) {
NDArray<T, Ndim> &NDArray<T, Ndim>::operator*=(const T &value) {
for (int i = 0; i < size_; ++i)
data_[i] *= value;
return *this;
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> Image<T, Ndim>::operator*(const T &value) {
Image result = *this;
NDArray<T, Ndim> NDArray<T, Ndim>::operator*(const T &value) {
NDArray result = *this;
result *= value;
return result;
}
template <typename T, ssize_t Ndim> void Image<T, Ndim>::Print() {
template <typename T, ssize_t Ndim> void NDArray<T, Ndim>::Print() {
if (shape_[0] < 20 && shape_[1] < 20)
Print_all();
else
Print_some();
}
template <typename T, ssize_t Ndim> void Image<T, Ndim>::Print_all() {
template <typename T, ssize_t Ndim> void NDArray<T, Ndim>::Print_all() {
for (auto row = 0; row < shape_[0]; ++row) {
for (auto col = 0; col < shape_[1]; ++col) {
std::cout << std::setw(3);
@ -397,7 +397,7 @@ template <typename T, ssize_t Ndim> void Image<T, Ndim>::Print_all() {
std::cout << "\n";
}
}
template <typename T, ssize_t Ndim> void Image<T, Ndim>::Print_some() {
template <typename T, ssize_t Ndim> void NDArray<T, Ndim>::Print_some() {
for (auto row = 0; row < 5; ++row) {
for (auto col = 0; col < 5; ++col) {
std::cout << std::setw(7);
@ -408,7 +408,7 @@ template <typename T, ssize_t Ndim> void Image<T, Ndim>::Print_some() {
}
template <typename T, ssize_t Ndim>
void save(Image<T, Ndim> &img, std::string pathname) {
void save(NDArray<T, Ndim> &img, std::string pathname) {
std::ofstream f;
f.open(pathname, std::ios::binary);
f.write(img.buffer(), img.size() * sizeof(T));
@ -416,9 +416,9 @@ void save(Image<T, Ndim> &img, std::string pathname) {
}
template <typename T, ssize_t Ndim>
Image<T, Ndim> load(const std::string &pathname,
NDArray<T, Ndim> load(const std::string &pathname,
std::array<ssize_t, Ndim> shape) {
Image<T, Ndim> img{shape};
NDArray<T, Ndim> img{shape};
std::ifstream f;
f.open(pathname, std::ios::binary);
f.read(img.buffer(), img.size() * sizeof(T));

10
core/include/aare/VariableSizeClusterFinder.hpp
View File

@ -6,7 +6,7 @@
#include <vector>
#include "aare/Image.hpp"
#include "aare/NDArray.hpp"
const int MAX_CLUSTER_SIZE = 200;
namespace pl {
@ -31,9 +31,9 @@ template <typename T> class ClusterFinder {
private:
const std::array<ssize_t, 2> shape_;
NDView<T, 2> original_;
Image<int, 2> labeled_;
Image<int, 2> peripheral_labeled_;
Image<bool, 2> binary_; // over threshold flag
NDArray<int, 2> labeled_;
NDArray<int, 2> peripheral_labeled_;
NDArray<bool, 2> binary_; // over threshold flag
T threshold_;
NDView<T, 2> noiseMap;
bool use_noise_map = false;
@ -56,7 +56,7 @@ template <typename T> class ClusterFinder {
hits.reserve(2000);
}
Image<int, 2> labeled() { return labeled_; }
NDArray<int, 2> labeled() { return labeled_; }
void set_noiseMap(NDView<T, 2> noise_map) { noiseMap = noise_map; use_noise_map = true; }
void set_peripheralThresholdFactor(int factor) { peripheralThresholdFactor_ = factor; }

28
core/test/wrappers.test.cpp
View File

@ -1,6 +1,6 @@
#include <aare/NDView.hpp>
#include <aare/Frame.hpp>
#include <aare/View.hpp>
#include <aare/NDView.hpp>
#include <catch2/catch_test_macros.hpp>
#include <cstdint>
@ -34,29 +34,29 @@ TEST_CASE("NDView") {
REQUIRE(ds(i / 10, i % 10) == data[i]);
}
}
// SECTION("from Frame") {
// Frame f(reinterpret_cast<std::byte *>(data), 10, 10, 16);
// View<uint16_t> ds = f.view<uint16_t>();
// for (int i = 0; i < 100; i++) {
// REQUIRE(ds(i / 10, i % 10) == data[i]);
// }
SECTION("from Frame") {
Frame f(reinterpret_cast<std::byte *>(data), 10, 10, 16);
NDView<uint16_t> ds = f.view<uint16_t>();
for (int i = 0; i < 100; i++) {
REQUIRE(ds(i / 10, i % 10) == data[i]);
}
// f.set(0, 0, (uint16_t)44);
// REQUIRE((uint16_t)*f.get(0, 0) == 44); // check that set worked
// REQUIRE(ds(0, 0) == 44); // check that ds is updated
// REQUIRE(data[0] == 0); // check that data is not updated
// }
f.set(0, 0, (uint16_t)44);
REQUIRE((uint16_t)*f.get(0, 0) == 44); // check that set worked
REQUIRE(ds(0, 0) == 44); // check that ds is updated
REQUIRE(data[0] == 0); // check that data is not updated
}
delete[] data;
}
TEST_CASE("Image") {
TEST_CASE("NDArray") {
auto data = new uint16_t[100];
for (int i = 0; i < 100; i++) {
data[i] = i;
}
SECTION("from Frame") {
Frame f(reinterpret_cast<std::byte *>(data), 10, 10, 16);
Image<uint16_t> img = f.image<uint16_t>();
NDArray<uint16_t> img = f.image<uint16_t>();
for (int i = 0; i < 100; i++) {
REQUIRE(img(i / 10, i % 10) == data[i]);
}

2
data/jungfrau_double_master_0.json
View File

@ -7,7 +7,7 @@
"x": 1,
"y": 2
},
"Image Size in bytes": 524288,
"NDArray Size in bytes": 524288,
"Pixels": {
"x": 1024,
"y": 256

2
data/jungfrau_single_master_0.json
View File

@ -7,7 +7,7 @@
"x": 1,
"y": 1
},
"Image Size in bytes": 1048576,
"NDArray Size in bytes": 1048576,
"Pixels": {
"x": 1024,
"y": 512

2
data/m3_master_0.json
View File

@ -7,7 +7,7 @@
"x": 1,
"y": 1
},
"Image Size in bytes": 15360,
"NDArray Size in bytes": 15360,
"Pixels": {
"x": 3840,
"y": 1