Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

opencv test draft for ImageContainer #303

Merged
merged 10 commits into from
Oct 22, 2024
Merged

opencv test draft for ImageContainer #303

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
10 commits
Select commit Hold shift + click to select a range
ed17a19
opencv test draft for ImageContainer
markram1729 May 15, 2024
c2f35da
test other image format without norm
markram1729 May 21, 2024
33a5e94
test images with norm
markram1729 May 25, 2024
c42eeca
ternary operator to imgcv
markram1729 May 27, 2024
954f82d
changed function name
markram1729 May 28, 2024
24b43b9
added tests for norm at jpg,png
markram1729 May 30, 2024
eb0f5c4
applied clang format
markram1729 Jun 4, 2024
71f369b
NCHW Support for testcv
markram1729 Jul 4, 2024
5d9b4f6
applied clang format
markram1729 Sep 12, 2024
40f16c9
Added Comment for Tests
markram1729 Sep 12, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 6 additions & 2 deletions frontend/Interfaces/buddy/DIP/ImageContainer.h
View file
Open in desktop
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
Open in desktop
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) {
markram1729 marked this conversation as resolved.
Show resolved Hide resolved
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]);


//===--------------------------------------------------------------------===//
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

These tests are testing the same thing which was tested by above tests? If not, please add a comment explaining that.

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

yes , above tests checks only on single images , here i have batched two images into a blob that is the only difference

and i have added few required segments in ImageContainer.h for batched images

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