Skip to content

Commit

Permalink
[Container] Add OpenCV test for ImageContainer (#303)
Browse files Browse the repository at this point in the history
  • Loading branch information
@markram1729
markram1729 authored Oct 22, 2024
1 parent 49f4410 commit b91e064
Show file tree
Hide file tree
Showing 2 changed files with 197 additions and 17 deletions.
8 changes: 6 additions & 2 deletions frontend/Interfaces/buddy/DIP/ImageContainer.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -141,6 +141,7 @@ Img<T, N>::Img(T *data, intptr_t sizes[N]) : MemRef<T, N>(data, sizes) {}

#ifdef BUDDY_ENABLE_OPENCV
// Image Constructor from OpenCV Mat.

template <typename T, size_t N>
Img<T, N>::Img(cv::Mat image, intptr_t sizes[N], bool norm) : MemRef<T, N>() {
if (image.channels() == 1) {
Expand Down Expand Up @@ -189,14 +190,16 @@ Img<T, N>::Img(cv::Mat image, intptr_t sizes[N], bool norm) : MemRef<T, N>() {
this->allocated = new T[size];
this->aligned = this->allocated;
size_t k = 0;
//NCHW Layout
for (int batch = 0; batch < this->sizes[0]; batch++) {
for (int channel = 0; channel < this->sizes[1]; channel++) {
T *chandata = image.ptr<T>(batch, channel);
for (int row = 0; row < this->sizes[2]; row++) {
for (int col = 0; col < this->sizes[3]; col++) {
if (norm) {
this->aligned[k] = (T)image.at<uchar>(row, col) / 255;
this->aligned[k] = chandata[row * this->sizes[3] + col] / 255;
} else {
this->aligned[k] = (T)image.at<uchar>(row, col);
this->aligned[k] = chandata[row * this->sizes[3] + col];
}
k++;
}
Expand All @@ -205,6 +208,7 @@ Img<T, N>::Img(cv::Mat image, intptr_t sizes[N], bool norm) : MemRef<T, N>() {
}
}
}

#endif

template <typename T, size_t N> int Img<T, N>::channels() {
Expand Down
206 changes: 191 additions & 15 deletions tests/Interface/core/ImageContainerTest.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,6 +24,54 @@
#include <buddy/Core/Container.h>
#include <buddy/DIP/ImageContainer.h>

bool compare_flt(float a, float b) { return (std::abs(a - b) < FLT_EPSILON); }

template <typename T, size_t N>
bool testImgcvnorm(cv::Mat testImgcv, Img<T, N> testImg, bool norm = false,
intptr_t sizes[N] = nullptr) {
int cvn = testImgcv.dims;
if (cvn != N)
return false;
for (size_t i = 0; i < N; ++i) {
if (testImgcv.size[i] != testImg.getSizes()[i])
return false;
}
T *data = testImg.getData();
if (N == 2) {
size_t k = 0;
for (int i = 0; i < testImg.getSizes()[0]; ++i) {
for (int j = 0; j < testImg.getSizes()[1]; ++j) {
if (norm ? !compare_flt(data[k], (T)testImgcv.at<T>(i, j))
: !compare_flt(data[k], (T)testImgcv.at<uchar>(i, j)))
return false;

++k;
}
}
return true;
} else if (N == 4) {
if (sizes == nullptr) {
return false;
}
size_t k = 0;
// NCHW layout
for (size_t batch = 0; batch < sizes[0]; ++batch) {
for (size_t channel = 0; channel < sizes[1]; ++channel) {
T *chandata = testImgcv.ptr<T>(batch, channel);
for (size_t row = 0; row < sizes[2]; ++row) {
for (size_t col = 0; col < sizes[3]; ++col) {
if (!compare_flt(data[k], chandata[row * sizes[3] + col]))
return false;

++k;
}
}
}
}
return true;
}
}

int main() {
// The original test image is a gray scale image, and the pixel values are as
// follows:
Expand All @@ -33,7 +81,7 @@ int main() {
// 195.0, 210.0, 225.0, 240.0
// The test running directory is in <build dir>/tests/Interface/core, so the
// `imread` function uses the following relative path.

//===--------------------------------------------------------------------===//
// Test bmp format image.
//===--------------------------------------------------------------------===//
Expand Down Expand Up @@ -75,12 +123,10 @@ int main() {
fprintf(stderr, "%ld\n", testCopyConstructor2.getSize());
// CHECK: 60.0
fprintf(stderr, "%f\n", testCopyConstructor2[3]);
Img<float, 2> testCopyConstructor3 =
Img<float, 2>(grayimage_bmp);
Img<float, 2> testCopyConstructor3 = Img<float, 2>(grayimage_bmp);
// CHECK: 15.0
fprintf(stderr, "%f\n", testCopyConstructor3[0]);
Img<float, 2> *testCopyConstructor4 =
new Img<float, 2>(grayimage_bmp);
Img<float, 2> *testCopyConstructor4 = new Img<float, 2>(grayimage_bmp);
// CHECK: 15.0
fprintf(stderr, "%f\n", testCopyConstructor4->getData()[0]);
delete testCopyConstructor4;
Expand Down Expand Up @@ -132,7 +178,50 @@ int main() {
const Img<float, 2> testBracketOperator2(grayimage_bmp);
// CHECK: 240.0
fprintf(stderr, "%f\n", testBracketOperator2[15]);
//===--------------------------------------------------------------------===//
// Test Opencv Image without norm
//===--------------------------------------------------------------------===//
cv::Mat testImgcvbmp =
cv::imread("../../../../tests/Interface/core/TestGrayImage.bmp",
cv::IMREAD_GRAYSCALE);
Img<float, 2> testImgbmp(testImgcvbmp);
bool testbmp = testImgcvnorm<float, 2>(testImgcvbmp, testImgbmp);
// CHECK: 1
fprintf(stderr, "%d \n", testbmp);
//===--------------------------------------------------------------------===//
// Test Opencv Image with norm
//===--------------------------------------------------------------------===//
Img<float, 2> testImgbmpnorm(testImgcvbmp, nullptr, true);
cv::Mat checkimgbmp(testImgcvbmp.rows, testImgcvbmp.cols, CV_32FC1);
testImgcvbmp.convertTo(checkimgbmp, CV_32FC1, 1.f / 255);
bool testbmp1 = testImgcvnorm<float, 2>(checkimgbmp, testImgbmpnorm, true);
// CHECK: 1
fprintf(stderr, "%d \n", testbmp1);

//===--------------------------------------------------------------------===//
// Test Opencv blob Image (batched images) without norm (NCHW)
//===--------------------------------------------------------------------===//
std::vector<cv::Mat> testbmpvec = {testImgcvbmp, testImgcvbmp};
cv::Mat testcvbmpblob = cv::dnn::blobFromImages(
testbmpvec, 1.0, cv::Size(testImgcvbmp.rows, testImgcvbmp.cols));
intptr_t sizesbmp[4] = {testcvbmpblob.size[0], testcvbmpblob.size[1],
testcvbmpblob.size[2], testcvbmpblob.size[3]};
Img<float, 4> testImgbmpblob(testcvbmpblob, sizesbmp, false);
bool testbmpN4 =
testImgcvnorm<float, 4>(testcvbmpblob, testImgbmpblob, false, sizesbmp);
// CHECK: 1
fprintf(stderr, "%d \n", testbmpN4);

//===--------------------------------------------------------------------===//
// Test Opencv blob Image (batched images) with norm (NCHW)
//===--------------------------------------------------------------------===//
cv::Mat testcvbmpblob2 = cv::dnn::blobFromImages(
testbmpvec, 1.0f / 255.0, cv::Size(testImgcvbmp.rows, testImgcvbmp.cols));
Img<float, 4> testImgbmpblobnorm(testcvbmpblob, sizesbmp, true);
bool testbmpN4norm = testImgcvnorm<float, 4>(
testcvbmpblob2, testImgbmpblobnorm, true, sizesbmp);
// CHECK: 1
fprintf(stderr, "%d \n", testbmpN4norm);

//===--------------------------------------------------------------------===//
// Test jpeg format image.
Expand Down Expand Up @@ -175,12 +264,10 @@ int main() {
fprintf(stderr, "%ld\n", testCopyConstructor6.getSize());
// CHECK: 60.0
fprintf(stderr, "%f\n", testCopyConstructor6[3]);
Img<float, 2> testCopyConstructor7 =
Img<float, 2>(grayimage_jpg);
Img<float, 2> testCopyConstructor7 = Img<float, 2>(grayimage_jpg);
// CHECK: 15.0
fprintf(stderr, "%f\n", testCopyConstructor7[0]);
Img<float, 2> *testCopyConstructor8 =
new Img<float, 2>(grayimage_jpg);
Img<float, 2> *testCopyConstructor8 = new Img<float, 2>(grayimage_jpg);
// CHECK: 15.0
fprintf(stderr, "%f\n", testCopyConstructor8->getData()[0]);
delete testCopyConstructor8;
Expand Down Expand Up @@ -233,6 +320,51 @@ int main() {
// CHECK: 240.0
fprintf(stderr, "%f\n", testBracketOperator4[15]);

//===--------------------------------------------------------------------===//
// Test Opencv Image without norm
//===--------------------------------------------------------------------===//
cv::Mat testImgcvjpg =
cv::imread("../../../../tests/Interface/core/TestGrayImage.jpg",
cv::IMREAD_GRAYSCALE);
Img<float, 2> testImgjpg(testImgcvjpg);
bool testjpg = testImgcvnorm<float, 2>(testImgcvjpg, testImgjpg);
// CHECK: 1
fprintf(stderr, "%d \n", testjpg);

//===--------------------------------------------------------------------===//
// Test Opencv Image with norm
//===--------------------------------------------------------------------===//
Img<float, 2> testImgjpgnorm(testImgcvjpg, nullptr, true);
cv::Mat checkimgjpg(testImgcvjpg.rows, testImgcvjpg.cols, CV_32FC1);
testImgcvjpg.convertTo(checkimgjpg, CV_32FC1, 1.f / 255);
bool testjpg1 = testImgcvnorm<float, 2>(checkimgjpg, testImgjpgnorm, true);
// CHECK: 1
fprintf(stderr, "%d \n", testjpg1);

//===--------------------------------------------------------------------===//
// Test Opencv blob Image (batched images) without norm (NCHW)
//===--------------------------------------------------------------------===//
std::vector<cv::Mat> testjpgvec = {testImgcvjpg, testImgcvjpg};
cv::Mat testcvjpgblob = cv::dnn::blobFromImages(
testjpgvec, 1.0, cv::Size(testImgcvjpg.rows, testImgcvjpg.cols));
intptr_t sizesjpg[4] = {testcvjpgblob.size[0], testcvjpgblob.size[1],
testcvjpgblob.size[2], testcvjpgblob.size[3]};
Img<float, 4> testImgjpgblob(testcvjpgblob, sizesjpg, false);
bool testjpgN4 =
testImgcvnorm<float, 4>(testcvjpgblob, testImgjpgblob, false, sizesjpg);
// CHECK: 1
fprintf(stderr, "%d \n", testjpgN4);

//===--------------------------------------------------------------------===//
// Test Opencv blob Image (batched images) with norm (NCHW)
//===--------------------------------------------------------------------===//
cv::Mat testcvjpgblob2 = cv::dnn::blobFromImages(
testjpgvec, 1.0f / 255.0, cv::Size(testImgcvjpg.rows, testImgcvjpg.cols));
Img<float, 4> testImgjpgblobnorm(testcvjpgblob, sizesjpg, true);
bool testjpgN4norm = testImgcvnorm<float, 4>(
testcvjpgblob2, testImgjpgblobnorm, true, sizesjpg);
// CHECK: 1
fprintf(stderr, "%d \n", testjpgN4norm);

//===--------------------------------------------------------------------===//
// Test png format image.
Expand Down Expand Up @@ -275,12 +407,10 @@ int main() {
fprintf(stderr, "%ld\n", testCopyConstructor10.getSize());
// CHECK: 60.0
fprintf(stderr, "%f\n", testCopyConstructor10[3]);
Img<float, 2> testCopyConstructor11 =
Img<float, 2>(grayimage_png);
Img<float, 2> testCopyConstructor11 = Img<float, 2>(grayimage_png);
// CHECK: 15.0
fprintf(stderr, "%f\n", testCopyConstructor11[0]);
Img<float, 2> *testCopyConstructor12 =
new Img<float, 2>(grayimage_png);
Img<float, 2> *testCopyConstructor12 = new Img<float, 2>(grayimage_png);
// CHECK: 15.0
fprintf(stderr, "%f\n", testCopyConstructor12->getData()[0]);
delete testCopyConstructor12;
Expand Down Expand Up @@ -332,6 +462,52 @@ int main() {
const Img<float, 2> testBracketOperator6(grayimage_png);
// CHECK: 240.0
fprintf(stderr, "%f\n", testBracketOperator6[15]);


//===--------------------------------------------------------------------===//
// Test Opencv Image without norm
//===--------------------------------------------------------------------===//
cv::Mat testImgcvpng =
cv::imread("../../../../tests/Interface/core/TestGrayImage.png",
cv::IMREAD_GRAYSCALE);
Img<float, 2> testImgpng(testImgcvpng);
bool testpng = testImgcvnorm<float, 2>(testImgcvpng, testImgpng);
/// CHECK: 1
fprintf(stderr, "%d \n", testpng);

//===--------------------------------------------------------------------===//
// Test Opencv Image with norm
//===--------------------------------------------------------------------===//
Img<float, 2> testImgpngnorm(testImgcvpng, nullptr, true);
cv::Mat checkimgpng(testImgcvpng.rows, testImgcvpng.cols, CV_32FC1);
testImgcvpng.convertTo(checkimgpng, CV_32FC1, 1.f / 255);
bool testpng1 = testImgcvnorm<float, 2>(checkimgpng, testImgpngnorm, true);
// CHECK: 1
fprintf(stderr, "%d \n", testpng1);

///===--------------------------------------------------------------------===//
// Test Opencv blob Image (batched images) without norm (NCHW)
//===--------------------------------------------------------------------===//
std::vector<cv::Mat> testpngvec = {testImgcvpng, testImgcvpng};
cv::Mat testcvpngblob = cv::dnn::blobFromImages(
testpngvec, 1.0, cv::Size(testImgcvpng.rows, testImgcvpng.cols));
intptr_t sizespng[4] = {testcvpngblob.size[0], testcvpngblob.size[1],
testcvpngblob.size[2], testcvpngblob.size[3]};
Img<float, 4> testImgpngblob(testcvpngblob, sizespng, false);
bool testpngN4 =
testImgcvnorm<float, 4>(testcvpngblob, testImgpngblob, false, sizespng);
// CHECK: 1
fprintf(stderr, "%d \n", testpngN4);

//===--------------------------------------------------------------------===//
// Test Opencv blob Image (batched images) with norm (NCHW)
//===--------------------------------------------------------------------===//
cv::Mat testcvpngblob2 = cv::dnn::blobFromImages(
testpngvec, 1.0f / 255.0, cv::Size(testImgcvpng.rows, testImgcvpng.cols));
Img<float, 4> testImgpngblobnorm(testcvpngblob, sizespng, true);
bool testpngN4norm = testImgcvnorm<float, 4>(
testcvpngblob2, testImgpngblobnorm, true, sizespng);
// CHECK: 1
fprintf(stderr, "%d \n", testpngN4norm);

return 0;
}
}

0 comments on commit b91e064

Please sign in to comment.