1 /** 2 * Copyright 2020-2021 Huawei Technologies Co., Ltd 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 #include <opencv2/opencv.hpp> 17 #include <opencv2/imgproc/types_c.h> 18 #include <fstream> 19 20 #include "common/common.h" 21 #include "lite_cv/lite_mat.h" 22 #include "lite_cv/image_process.h" 23 #include "minddata/dataset/kernels/image/resize_cubic_op.h" 24 25 using namespace mindspore::dataset; 26 class MindDataImageProcess : public UT::Common { 27 public: 28 MindDataImageProcess() {} 29 30 void SetUp() {} 31 }; 32 33 void CompareMat(cv::Mat cv_mat, LiteMat lite_mat) { 34 int cv_h = cv_mat.rows; 35 int cv_w = cv_mat.cols; 36 int cv_c = cv_mat.channels(); 37 int lite_h = lite_mat.height_; 38 int lite_w = lite_mat.width_; 39 int lite_c = lite_mat.channel_; 40 ASSERT_TRUE(cv_h == lite_h); 41 ASSERT_TRUE(cv_w == lite_w); 42 ASSERT_TRUE(cv_c == lite_c); 43 } 44 45 void Lite3CImageProcess(LiteMat &lite_mat_bgr, LiteMat &lite_norm_mat_cut) { 46 bool ret; 47 LiteMat lite_mat_resize; 48 ret = ResizeBilinear(lite_mat_bgr, lite_mat_resize, 256, 256); 49 ASSERT_TRUE(ret == true); 50 LiteMat lite_mat_convert_float; 51 ret = ConvertTo(lite_mat_resize, lite_mat_convert_float, 1.0); 52 ASSERT_TRUE(ret == true); 53 54 LiteMat lite_mat_crop; 55 ret = Crop(lite_mat_convert_float, lite_mat_crop, 16, 16, 224, 224); 56 ASSERT_TRUE(ret == true); 57 std::vector<float> means = {0.485, 0.456, 0.406}; 58 std::vector<float> stds = {0.229, 0.224, 0.225}; 59 SubStractMeanNormalize(lite_mat_crop, lite_norm_mat_cut, means, stds); 60 return; 61 } 62 63 cv::Mat cv3CImageProcess(cv::Mat &image) { 64 cv::Mat resize_256_image; 65 cv::resize(image, resize_256_image, cv::Size(256, 256), CV_INTER_LINEAR); 66 cv::Mat float_256_image; 67 resize_256_image.convertTo(float_256_image, CV_32FC3); 68 69 cv::Mat roi_224_image; 70 cv::Rect roi; 71 roi.x = 16; 72 roi.y = 16; 73 roi.width = 224; 74 roi.height = 224; 75 76 float_256_image(roi).copyTo(roi_224_image); 77 78 float meanR = 0.485; 79 float meanG = 0.456; 80 float meanB = 0.406; 81 float varR = 0.229; 82 float varG = 0.224; 83 float varB = 0.225; 84 cv::Scalar mean = cv::Scalar(meanR, meanG, meanB); 85 cv::Scalar var = cv::Scalar(varR, varG, varB); 86 87 cv::Mat imgMean(roi_224_image.size(), CV_32FC3, mean); 88 cv::Mat imgVar(roi_224_image.size(), CV_32FC3, var); 89 90 cv::Mat imgR1 = roi_224_image - imgMean; 91 cv::Mat imgR2 = imgR1 / imgVar; 92 return imgR2; 93 } 94 95 void AccuracyComparison(const std::vector<std::vector<double>> &expect, LiteMat &value) { 96 for (int i = 0; i < expect.size(); i++) { 97 for (int j = 0; j < expect[0].size(); j++) { 98 double middle = std::fabs(expect[i][j] - value.ptr<double>(i)[j]); 99 ASSERT_TRUE(middle <= 0.005); 100 } 101 } 102 } 103 104 TEST_F(MindDataImageProcess, testRGB) { 105 std::string filename = "data/dataset/apple.jpg"; 106 cv::Mat image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 107 108 cv::Mat rgba_mat; 109 cv::cvtColor(image, rgba_mat, CV_BGR2RGB); 110 111 bool ret = false; 112 LiteMat lite_mat_rgb; 113 ret = InitFromPixel(rgba_mat.data, LPixelType::RGB, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_rgb); 114 ASSERT_TRUE(ret == true); 115 116 cv::Mat dst_image(lite_mat_rgb.height_, lite_mat_rgb.width_, CV_8UC3, lite_mat_rgb.data_ptr_); 117 } 118 119 TEST_F(MindDataImageProcess, testLoadByMemPtr) { 120 std::string filename = "data/dataset/apple.jpg"; 121 cv::Mat image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 122 123 cv::Mat rgba_mat; 124 cv::cvtColor(image, rgba_mat, CV_BGR2RGB); 125 126 bool ret = false; 127 int width = rgba_mat.cols; 128 int height = rgba_mat.rows; 129 uchar *p_rgb = (uchar *)malloc(width * height * 3 * sizeof(uchar)); 130 for (int i = 0; i < height; i++) { 131 const uchar *current = rgba_mat.ptr<uchar>(i); 132 for (int j = 0; j < width; j++) { 133 p_rgb[i * width * 3 + 3 * j + 0] = current[3 * j + 0]; 134 p_rgb[i * width * 3 + 3 * j + 1] = current[3 * j + 1]; 135 p_rgb[i * width * 3 + 3 * j + 2] = current[3 * j + 2]; 136 } 137 } 138 139 LiteMat lite_mat_rgb(width, height, 3, (void *)p_rgb, LDataType::UINT8); 140 LiteMat lite_mat_resize; 141 ret = ResizeBilinear(lite_mat_rgb, lite_mat_resize, 256, 256); 142 ASSERT_TRUE(ret == true); 143 LiteMat lite_mat_convert_float; 144 ret = ConvertTo(lite_mat_resize, lite_mat_convert_float, 1.0); 145 ASSERT_TRUE(ret == true); 146 147 LiteMat lite_mat_crop; 148 ret = Crop(lite_mat_convert_float, lite_mat_crop, 16, 16, 224, 224); 149 ASSERT_TRUE(ret == true); 150 std::vector<float> means = {0.485, 0.456, 0.406}; 151 std::vector<float> stds = {0.229, 0.224, 0.225}; 152 LiteMat lite_norm_mat_cut; 153 ret = SubStractMeanNormalize(lite_mat_crop, lite_norm_mat_cut, means, stds); 154 155 int pad_width = lite_norm_mat_cut.width_ + 20; 156 int pad_height = lite_norm_mat_cut.height_ + 20; 157 float *p_rgb_pad = (float *)malloc(pad_width * pad_height * 3 * sizeof(float)); 158 159 LiteMat makeborder(pad_width, pad_height, 3, (void *)p_rgb_pad, LDataType::FLOAT32); 160 ret = Pad(lite_norm_mat_cut, makeborder, 10, 30, 40, 10, PaddBorderType::PADD_BORDER_CONSTANT, 255, 255, 255); 161 cv::Mat dst_image(pad_height, pad_width, CV_8UC3, p_rgb_pad); 162 free(p_rgb); 163 free(p_rgb_pad); 164 } 165 166 TEST_F(MindDataImageProcess, test3C) { 167 std::string filename = "data/dataset/apple.jpg"; 168 cv::Mat image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 169 cv::Mat cv_image = cv3CImageProcess(image); 170 171 // convert to RGBA for Android bitmap(rgba) 172 cv::Mat rgba_mat; 173 cv::cvtColor(image, rgba_mat, CV_BGR2RGBA); 174 175 bool ret = false; 176 LiteMat lite_mat_bgr; 177 ret = 178 InitFromPixel(rgba_mat.data, LPixelType::RGBA2BGR, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_bgr); 179 ASSERT_TRUE(ret == true); 180 LiteMat lite_norm_mat_cut; 181 Lite3CImageProcess(lite_mat_bgr, lite_norm_mat_cut); 182 183 cv::Mat dst_image(lite_norm_mat_cut.height_, lite_norm_mat_cut.width_, CV_32FC3, lite_norm_mat_cut.data_ptr_); 184 CompareMat(cv_image, lite_norm_mat_cut); 185 } 186 187 TEST_F(MindDataImageProcess, testCubic3C) { 188 std::string filename = "data/dataset/apple.jpg"; 189 cv::Mat image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 190 cv::Mat rgb_mat; 191 cv::cvtColor(image, rgb_mat, CV_BGR2RGB); 192 193 LiteMat imIn, imOut; 194 int32_t output_width = 24; 195 int32_t output_height = 24; 196 imIn.Init(rgb_mat.cols, rgb_mat.rows, rgb_mat.channels(), rgb_mat.data, LDataType::UINT8); 197 imOut.Init(output_width, output_height, 3, LDataType::UINT8); 198 199 bool ret = ResizeCubic(imIn, imOut, output_width, output_height); 200 201 ASSERT_TRUE(ret == true); 202 return; 203 } 204 205 bool ReadYUV(const char *filename, int w, int h, uint8_t **data) { 206 FILE *f = fopen(filename, "rb"); 207 if (f == nullptr) { 208 return false; 209 } 210 fseek(f, 0, SEEK_END); 211 int size = ftell(f); 212 int expect_size = w * h + 2 * ((w + 1) / 2) * ((h + 1) / 2); 213 if (size != expect_size) { 214 fclose(f); 215 return false; 216 } 217 fseek(f, 0, SEEK_SET); 218 *data = (uint8_t *)malloc(size); 219 size_t re = fread(*data, 1, size, f); 220 if (re != size) { 221 fclose(f); 222 return false; 223 } 224 fclose(f); 225 return true; 226 } 227 228 TEST_F(MindDataImageProcess, TestRGBA2GRAY) { 229 std::string filename = "data/dataset/apple.jpg"; 230 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 231 cv::Mat gray_image; 232 cv::cvtColor(src_image, gray_image, CV_BGR2GRAY); 233 234 cv::Mat rgba_mat; 235 cv::cvtColor(src_image, rgba_mat, CV_BGR2RGBA); 236 bool ret = false; 237 LiteMat lite_mat_gray; 238 ret = 239 InitFromPixel(rgba_mat.data, LPixelType::RGBA2GRAY, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_gray); 240 ASSERT_TRUE(ret == true); 241 242 double distance = 0.f; 243 int total_size = gray_image.cols * gray_image.rows * gray_image.channels(); 244 for (int i = 0; i < total_size; i++) { 245 distance += pow((uint8_t)gray_image.data[i] - ((uint8_t *)lite_mat_gray)[i], 2); 246 } 247 distance = sqrt(distance / total_size); 248 EXPECT_EQ(distance, 0.0f); 249 } 250 251 TEST_F(MindDataImageProcess, testNV21ToBGR) { 252 // ffmpeg -i ./data/dataset/apple.jpg -s 1024*800 -pix_fmt nv21 ./data/dataset/yuv/test_nv21.yuv 253 const char *filename = "data/dataset/yuv/test_nv21.yuv"; 254 int w = 1024; 255 int h = 800; 256 uint8_t *yuv_data = nullptr; 257 bool ret = ReadYUV(filename, w, h, &yuv_data); 258 ASSERT_TRUE(ret == true); 259 260 cv::Mat yuvimg(h * 3 / 2, w, CV_8UC1, yuv_data); 261 cv::Mat rgbimage; 262 263 cv::cvtColor(yuvimg, rgbimage, cv::COLOR_YUV2BGR_NV21); 264 265 LiteMat lite_mat_bgr; 266 267 ret = InitFromPixel(yuv_data, LPixelType::NV212BGR, LDataType::UINT8, w, h, lite_mat_bgr); 268 ASSERT_TRUE(ret == true); 269 cv::Mat dst_image(lite_mat_bgr.height_, lite_mat_bgr.width_, CV_8UC3, lite_mat_bgr.data_ptr_); 270 free(yuv_data); 271 } 272 273 TEST_F(MindDataImageProcess, testNV12ToBGR) { 274 // ffmpeg -i ./data/dataset/apple.jpg -s 1024*800 -pix_fmt nv12 ./data/dataset/yuv/test_nv12.yuv 275 const char *filename = "data/dataset/yuv/test_nv12.yuv"; 276 int w = 1024; 277 int h = 800; 278 uint8_t *yuv_data = nullptr; 279 bool ret = ReadYUV(filename, w, h, &yuv_data); 280 ASSERT_TRUE(ret == true); 281 282 cv::Mat yuvimg(h * 3 / 2, w, CV_8UC1); 283 memcpy(yuvimg.data, yuv_data, w * h * 3 / 2); 284 cv::Mat rgbimage; 285 286 cv::cvtColor(yuvimg, rgbimage, cv::COLOR_YUV2BGR_NV12); 287 LiteMat lite_mat_bgr; 288 ret = InitFromPixel(yuv_data, LPixelType::NV122BGR, LDataType::UINT8, w, h, lite_mat_bgr); 289 ASSERT_TRUE(ret == true); 290 cv::Mat dst_image(lite_mat_bgr.height_, lite_mat_bgr.width_, CV_8UC3, lite_mat_bgr.data_ptr_); 291 free(yuv_data); 292 } 293 294 TEST_F(MindDataImageProcess, testExtractChannel) { 295 std::string filename = "data/dataset/apple.jpg"; 296 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 297 cv::Mat dst_image; 298 cv::extractChannel(src_image, dst_image, 2); 299 // convert to RGBA for Android bitmap(rgba) 300 cv::Mat rgba_mat; 301 cv::cvtColor(src_image, rgba_mat, CV_BGR2RGBA); 302 303 bool ret = false; 304 LiteMat lite_mat_bgr; 305 ret = 306 InitFromPixel(rgba_mat.data, LPixelType::RGBA2BGR, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_bgr); 307 ASSERT_TRUE(ret == true); 308 309 LiteMat lite_B; 310 ret = ExtractChannel(lite_mat_bgr, lite_B, 0); 311 ASSERT_TRUE(ret == true); 312 313 LiteMat lite_R; 314 ret = ExtractChannel(lite_mat_bgr, lite_R, 2); 315 ASSERT_TRUE(ret == true); 316 cv::Mat dst_imageR(lite_R.height_, lite_R.width_, CV_8UC1, lite_R.data_ptr_); 317 // cv::imwrite("./test_lite_r.jpg", dst_imageR); 318 } 319 320 TEST_F(MindDataImageProcess, testSplit) { 321 std::string filename = "data/dataset/apple.jpg"; 322 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 323 std::vector<cv::Mat> dst_images; 324 cv::split(src_image, dst_images); 325 // convert to RGBA for Android bitmap(rgba) 326 cv::Mat rgba_mat; 327 cv::cvtColor(src_image, rgba_mat, CV_BGR2RGBA); 328 329 bool ret = false; 330 LiteMat lite_mat_bgr; 331 ret = 332 InitFromPixel(rgba_mat.data, LPixelType::RGBA2BGR, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_bgr); 333 ASSERT_TRUE(ret == true); 334 std::vector<LiteMat> lite_all; 335 ret = Split(lite_mat_bgr, lite_all); 336 ASSERT_TRUE(ret == true); 337 ASSERT_TRUE(lite_all.size() == 3); 338 LiteMat lite_r = lite_all[2]; 339 cv::Mat dst_imageR(lite_r.height_, lite_r.width_, CV_8UC1, lite_r.data_ptr_); 340 } 341 342 TEST_F(MindDataImageProcess, testMerge) { 343 std::string filename = "data/dataset/apple.jpg"; 344 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 345 std::vector<cv::Mat> dst_images; 346 cv::split(src_image, dst_images); 347 // convert to RGBA for Android bitmap(rgba) 348 cv::Mat rgba_mat; 349 cv::cvtColor(src_image, rgba_mat, CV_BGR2RGBA); 350 351 bool ret = false; 352 LiteMat lite_mat_bgr; 353 ret = 354 InitFromPixel(rgba_mat.data, LPixelType::RGBA2BGR, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_bgr); 355 ASSERT_TRUE(ret == true); 356 std::vector<LiteMat> lite_all; 357 ret = Split(lite_mat_bgr, lite_all); 358 ASSERT_TRUE(ret == true); 359 ASSERT_TRUE(lite_all.size() == 3); 360 LiteMat lite_r = lite_all[2]; 361 cv::Mat dst_imageR(lite_r.height_, lite_r.width_, CV_8UC1, lite_r.data_ptr_); 362 363 LiteMat merge_mat; 364 EXPECT_TRUE(Merge(lite_all, merge_mat)); 365 EXPECT_EQ(merge_mat.height_, lite_mat_bgr.height_); 366 EXPECT_EQ(merge_mat.width_, lite_mat_bgr.width_); 367 EXPECT_EQ(merge_mat.channel_, lite_mat_bgr.channel_); 368 } 369 370 void Lite1CImageProcess(LiteMat &lite_mat_bgr, LiteMat &lite_norm_mat_cut) { 371 LiteMat lite_mat_resize; 372 int ret = ResizeBilinear(lite_mat_bgr, lite_mat_resize, 256, 256); 373 ASSERT_TRUE(ret == true); 374 LiteMat lite_mat_convert_float; 375 ret = ConvertTo(lite_mat_resize, lite_mat_convert_float); 376 ASSERT_TRUE(ret == true); 377 LiteMat lite_mat_cut; 378 ret = Crop(lite_mat_convert_float, lite_mat_cut, 16, 16, 224, 224); 379 ASSERT_TRUE(ret == true); 380 std::vector<float> means = {0.485}; 381 std::vector<float> stds = {0.229}; 382 ret = SubStractMeanNormalize(lite_mat_cut, lite_norm_mat_cut, means, stds); 383 ASSERT_TRUE(ret == true); 384 return; 385 } 386 387 cv::Mat cv1CImageProcess(cv::Mat &image) { 388 cv::Mat gray_image; 389 cv::cvtColor(image, gray_image, CV_BGR2GRAY); 390 391 cv::Mat resize_256_image; 392 cv::resize(gray_image, resize_256_image, cv::Size(256, 256), CV_INTER_LINEAR); 393 cv::Mat float_256_image; 394 resize_256_image.convertTo(float_256_image, CV_32FC3); 395 396 cv::Mat roi_224_image; 397 cv::Rect roi; 398 roi.x = 16; 399 roi.y = 16; 400 roi.width = 224; 401 roi.height = 224; 402 403 float_256_image(roi).copyTo(roi_224_image); 404 405 float meanR = 0.485; 406 float varR = 0.229; 407 cv::Scalar mean = cv::Scalar(meanR); 408 cv::Scalar var = cv::Scalar(varR); 409 410 cv::Mat imgMean(roi_224_image.size(), CV_32FC1, mean); 411 cv::Mat imgVar(roi_224_image.size(), CV_32FC1, var); 412 413 cv::Mat imgR1 = roi_224_image - imgMean; 414 cv::Mat imgR2 = imgR1 / imgVar; 415 return imgR2; 416 } 417 418 TEST_F(MindDataImageProcess, test1C) { 419 std::string filename = "data/dataset/apple.jpg"; 420 cv::Mat image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 421 cv::Mat cv_image = cv1CImageProcess(image); 422 423 // convert to RGBA for Android bitmap(rgba) 424 cv::Mat rgba_mat; 425 cv::cvtColor(image, rgba_mat, CV_BGR2RGBA); 426 427 LiteMat lite_mat_bgr; 428 bool ret = 429 InitFromPixel(rgba_mat.data, LPixelType::RGBA2GRAY, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_bgr); 430 ASSERT_TRUE(ret == true); 431 LiteMat lite_norm_mat_cut; 432 Lite1CImageProcess(lite_mat_bgr, lite_norm_mat_cut); 433 cv::Mat dst_image(lite_norm_mat_cut.height_, lite_norm_mat_cut.width_, CV_32FC1, lite_norm_mat_cut.data_ptr_); 434 CompareMat(cv_image, lite_norm_mat_cut); 435 } 436 437 TEST_F(MindDataImageProcess, TestPadd) { 438 std::string filename = "data/dataset/apple.jpg"; 439 cv::Mat image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 440 441 int left = 10; 442 int right = 20; 443 int top = 30; 444 int bottom = 40; 445 cv::Mat b_image; 446 cv::Scalar color = cv::Scalar(255, 255, 255); 447 cv::copyMakeBorder(image, b_image, top, bottom, left, right, cv::BORDER_CONSTANT, color); 448 cv::Mat rgba_mat; 449 cv::cvtColor(image, rgba_mat, CV_BGR2RGBA); 450 451 LiteMat lite_mat_bgr; 452 bool ret = 453 InitFromPixel(rgba_mat.data, LPixelType::RGBA2BGR, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_bgr); 454 ASSERT_TRUE(ret == true); 455 LiteMat makeborder; 456 ret = Pad(lite_mat_bgr, makeborder, top, bottom, left, right, PaddBorderType::PADD_BORDER_CONSTANT, 255, 255, 255); 457 ASSERT_TRUE(ret == true); 458 size_t total_size = makeborder.height_ * makeborder.width_ * makeborder.channel_; 459 double distance = 0.0f; 460 for (size_t i = 0; i < total_size; i++) { 461 distance += pow((uint8_t)b_image.data[i] - ((uint8_t *)makeborder)[i], 2); 462 } 463 distance = sqrt(distance / total_size); 464 EXPECT_EQ(distance, 0.0f); 465 } 466 467 TEST_F(MindDataImageProcess, TestPadZero) { 468 std::string filename = "data/dataset/apple.jpg"; 469 cv::Mat image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 470 471 int left = 0; 472 int right = 0; 473 int top = 0; 474 int bottom = 0; 475 cv::Mat b_image; 476 cv::Scalar color = cv::Scalar(255, 255, 255); 477 cv::copyMakeBorder(image, b_image, top, bottom, left, right, cv::BORDER_CONSTANT, color); 478 cv::Mat rgba_mat; 479 cv::cvtColor(image, rgba_mat, CV_BGR2RGBA); 480 481 LiteMat lite_mat_bgr; 482 bool ret = 483 InitFromPixel(rgba_mat.data, LPixelType::RGBA2BGR, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_bgr); 484 ASSERT_TRUE(ret == true); 485 LiteMat makeborder; 486 ret = Pad(lite_mat_bgr, makeborder, top, bottom, left, right, PaddBorderType::PADD_BORDER_CONSTANT, 255, 255, 255); 487 ASSERT_TRUE(ret == true); 488 size_t total_size = makeborder.height_ * makeborder.width_ * makeborder.channel_; 489 double distance = 0.0f; 490 for (size_t i = 0; i < total_size; i++) { 491 distance += pow((uint8_t)b_image.data[i] - ((uint8_t *)makeborder)[i], 2); 492 } 493 distance = sqrt(distance / total_size); 494 EXPECT_EQ(distance, 0.0f); 495 } 496 497 TEST_F(MindDataImageProcess, TestPadReplicate) { 498 std::string filename = "data/dataset/apple.jpg"; 499 cv::Mat image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 500 501 int left = 20; 502 int right = 20; 503 int top = 20; 504 int bottom = 20; 505 cv::Mat b_image; 506 cv::copyMakeBorder(image, b_image, top, bottom, left, right, cv::BORDER_REPLICATE); 507 508 cv::Mat rgba_mat; 509 cv::cvtColor(image, rgba_mat, CV_BGR2RGBA); 510 LiteMat lite_mat_bgr; 511 bool ret = 512 InitFromPixel(rgba_mat.data, LPixelType::RGBA2BGR, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_bgr); 513 ASSERT_TRUE(ret == true); 514 515 LiteMat makeborder; 516 ret = Pad(lite_mat_bgr, makeborder, top, bottom, left, right, PaddBorderType::PADD_BORDER_REPLICATE); 517 ASSERT_TRUE(ret == true); 518 519 size_t total_size = makeborder.height_ * makeborder.width_ * makeborder.channel_; 520 double distance = 0.0f; 521 for (size_t i = 0; i < total_size; i++) { 522 distance += pow((uint8_t)b_image.data[i] - ((uint8_t *)makeborder)[i], 2); 523 } 524 distance = sqrt(distance / total_size); 525 EXPECT_EQ(distance, 0.0f); 526 } 527 528 TEST_F(MindDataImageProcess, TestPadReflect101) { 529 std::string filename = "data/dataset/apple.jpg"; 530 cv::Mat image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 531 532 int left = 20; 533 int right = 20; 534 int top = 20; 535 int bottom = 20; 536 cv::Mat b_image; 537 cv::copyMakeBorder(image, b_image, top, bottom, left, right, cv::BORDER_REFLECT_101); 538 539 cv::Mat rgba_mat; 540 cv::cvtColor(image, rgba_mat, CV_BGR2RGBA); 541 LiteMat lite_mat_bgr; 542 bool ret = 543 InitFromPixel(rgba_mat.data, LPixelType::RGBA2BGR, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_bgr); 544 ASSERT_TRUE(ret == true); 545 546 LiteMat makeborder; 547 ret = Pad(lite_mat_bgr, makeborder, top, bottom, left, right, PaddBorderType::PADD_BORDER_REFLECT_101); 548 ASSERT_TRUE(ret == true); 549 550 size_t total_size = makeborder.height_ * makeborder.width_ * makeborder.channel_; 551 double distance = 0.0f; 552 for (size_t i = 0; i < total_size; i++) { 553 distance += pow((uint8_t)b_image.data[i] - ((uint8_t *)makeborder)[i], 2); 554 } 555 distance = sqrt(distance / total_size); 556 EXPECT_EQ(distance, 0.0f); 557 } 558 559 TEST_F(MindDataImageProcess, TestGetDefaultBoxes) { 560 std::string benchmark = "data/dataset/testLite/default_boxes.bin"; 561 BoxesConfig config; 562 config.img_shape = {300, 300}; 563 config.num_default = {3, 6, 6, 6, 6, 6}; 564 config.feature_size = {19, 10, 5, 3, 2, 1}; 565 config.min_scale = 0.2; 566 config.max_scale = 0.95; 567 config.aspect_rations = {{2}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}}; 568 config.steps = {16, 32, 64, 100, 150, 300}; 569 config.prior_scaling = {0.1, 0.2}; 570 571 int rows = 1917; 572 int cols = 4; 573 std::vector<double> benchmark_boxes(rows * cols); 574 std::ifstream in(benchmark, std::ios::in | std::ios::binary); 575 in.read(reinterpret_cast<char *>(benchmark_boxes.data()), benchmark_boxes.size() * sizeof(double)); 576 in.close(); 577 578 std::vector<std::vector<float>> default_boxes = GetDefaultBoxes(config); 579 EXPECT_EQ(default_boxes.size(), rows); 580 EXPECT_EQ(default_boxes[0].size(), cols); 581 582 double distance = 0.0f; 583 for (int i = 0; i < rows; i++) { 584 for (int j = 0; j < cols; j++) { 585 distance += pow(default_boxes[i][j] - benchmark_boxes[i * cols + j], 2); 586 } 587 } 588 distance = sqrt(distance); 589 EXPECT_LT(distance, 1e-5); 590 } 591 592 TEST_F(MindDataImageProcess, TestApplyNms) { 593 std::vector<std::vector<float>> all_boxes = {{1, 1, 2, 2}, {3, 3, 4, 4}, {5, 5, 6, 6}, {5, 5, 6, 6}}; 594 std::vector<float> all_scores = {0.6, 0.5, 0.4, 0.9}; 595 std::vector<int> keep = ApplyNms(all_boxes, all_scores, 0.5, 10); 596 ASSERT_TRUE(keep[0] == 3); 597 ASSERT_TRUE(keep[1] == 0); 598 ASSERT_TRUE(keep[2] == 1); 599 } 600 601 TEST_F(MindDataImageProcess, TestAffineInput) { 602 LiteMat src(3, 3); 603 LiteMat dst; 604 double M[6] = {1}; 605 EXPECT_FALSE(Affine(src, dst, M, {}, UINT8_C1(0))); 606 EXPECT_FALSE(Affine(src, dst, M, {3}, UINT8_C1(0))); 607 EXPECT_FALSE(Affine(src, dst, M, {0, 0}, UINT8_C1(0))); 608 } 609 610 TEST_F(MindDataImageProcess, TestAffine) { 611 // The input matrix 612 // 0 0 1 0 0 613 // 0 0 1 0 0 614 // 2 2 3 2 2 615 // 0 0 1 0 0 616 // 0 0 1 0 0 617 size_t rows = 5; 618 size_t cols = 5; 619 LiteMat src(rows, cols); 620 for (size_t i = 0; i < rows; i++) { 621 for (size_t j = 0; j < cols; j++) { 622 if (i == 2 && j == 2) { 623 static_cast<UINT8_C1 *>(src.data_ptr_)[i * cols + j] = 3; 624 } else if (i == 2) { 625 static_cast<UINT8_C1 *>(src.data_ptr_)[i * cols + j] = 2; 626 } else if (j == 2) { 627 static_cast<UINT8_C1 *>(src.data_ptr_)[i * cols + j] = 1; 628 } else { 629 static_cast<UINT8_C1 *>(src.data_ptr_)[i * cols + j] = 0; 630 } 631 } 632 } 633 634 // Expect output matrix 635 // 0 0 2 0 0 636 // 0 0 2 0 0 637 // 1 1 3 1 1 638 // 0 0 2 0 0 639 // 0 0 2 0 0 640 LiteMat expect(rows, cols); 641 for (size_t i = 0; i < rows; i++) { 642 for (size_t j = 0; j < cols; j++) { 643 if (i == 2 && j == 2) { 644 static_cast<UINT8_C1 *>(expect.data_ptr_)[i * cols + j] = 3; 645 } else if (i == 2) { 646 static_cast<UINT8_C1 *>(expect.data_ptr_)[i * cols + j] = 1; 647 } else if (j == 2) { 648 static_cast<UINT8_C1 *>(expect.data_ptr_)[i * cols + j] = 2; 649 } else { 650 static_cast<UINT8_C1 *>(expect.data_ptr_)[i * cols + j] = 0; 651 } 652 } 653 } 654 655 double angle = 90.0f; 656 cv::Point2f center(rows / 2, cols / 2); 657 cv::Mat rotate_matrix = cv::getRotationMatrix2D(center, angle, 1.0); 658 double M[6]; 659 for (size_t i = 0; i < 6; i++) { 660 M[i] = rotate_matrix.at<double>(i); 661 } 662 LiteMat dst; 663 EXPECT_TRUE(Affine(src, dst, M, {rows, cols}, UINT8_C1(0))); 664 665 for (size_t i = 0; i < rows; i++) { 666 for (size_t j = 0; j < cols; j++) { 667 EXPECT_EQ(static_cast<UINT8_C1 *>(expect.data_ptr_)[i * cols + j].c1, 668 static_cast<UINT8_C1 *>(dst.data_ptr_)[i * cols + j].c1); 669 } 670 } 671 } 672 673 TEST_F(MindDataImageProcess, TestSubtractUint8) { 674 const size_t cols = 4; 675 // Test uint8 676 LiteMat src1_uint8(1, cols); 677 LiteMat src2_uint8(1, cols); 678 LiteMat expect_uint8(1, cols); 679 for (size_t i = 0; i < cols; i++) { 680 static_cast<UINT8_C1 *>(src1_uint8.data_ptr_)[i] = 3; 681 static_cast<UINT8_C1 *>(src2_uint8.data_ptr_)[i] = 2; 682 static_cast<UINT8_C1 *>(expect_uint8.data_ptr_)[i] = 1; 683 } 684 LiteMat dst_uint8; 685 EXPECT_TRUE(Subtract(src1_uint8, src2_uint8, &dst_uint8)); 686 for (size_t i = 0; i < cols; i++) { 687 EXPECT_EQ(static_cast<UINT8_C1 *>(expect_uint8.data_ptr_)[i].c1, 688 static_cast<UINT8_C1 *>(dst_uint8.data_ptr_)[i].c1); 689 } 690 } 691 692 TEST_F(MindDataImageProcess, TestSubtractInt8) { 693 const size_t cols = 4; 694 // Test int8 695 LiteMat src1_int8(1, cols, LDataType(LDataType::INT8)); 696 LiteMat src2_int8(1, cols, LDataType(LDataType::INT8)); 697 LiteMat expect_int8(1, cols, LDataType(LDataType::INT8)); 698 for (size_t i = 0; i < cols; i++) { 699 static_cast<INT8_C1 *>(src1_int8.data_ptr_)[i] = 2; 700 static_cast<INT8_C1 *>(src2_int8.data_ptr_)[i] = 3; 701 static_cast<INT8_C1 *>(expect_int8.data_ptr_)[i] = -1; 702 } 703 LiteMat dst_int8; 704 EXPECT_TRUE(Subtract(src1_int8, src2_int8, &dst_int8)); 705 for (size_t i = 0; i < cols; i++) { 706 EXPECT_EQ(static_cast<INT8_C1 *>(expect_int8.data_ptr_)[i].c1, static_cast<INT8_C1 *>(dst_int8.data_ptr_)[i].c1); 707 } 708 } 709 710 TEST_F(MindDataImageProcess, TestSubtractUInt16) { 711 const size_t cols = 4; 712 // Test uint16 713 LiteMat src1_uint16(1, cols, LDataType(LDataType::UINT16)); 714 LiteMat src2_uint16(1, cols, LDataType(LDataType::UINT16)); 715 LiteMat expect_uint16(1, cols, LDataType(LDataType::UINT16)); 716 for (size_t i = 0; i < cols; i++) { 717 static_cast<UINT16_C1 *>(src1_uint16.data_ptr_)[i] = 2; 718 static_cast<UINT16_C1 *>(src2_uint16.data_ptr_)[i] = 3; 719 static_cast<UINT16_C1 *>(expect_uint16.data_ptr_)[i] = 0; 720 } 721 LiteMat dst_uint16; 722 EXPECT_TRUE(Subtract(src1_uint16, src2_uint16, &dst_uint16)); 723 for (size_t i = 0; i < cols; i++) { 724 EXPECT_EQ(static_cast<UINT16_C1 *>(expect_uint16.data_ptr_)[i].c1, 725 static_cast<UINT16_C1 *>(dst_uint16.data_ptr_)[i].c1); 726 } 727 } 728 729 TEST_F(MindDataImageProcess, TestSubtractInt16) { 730 const size_t cols = 4; 731 // Test int16 732 LiteMat src1_int16(1, cols, LDataType(LDataType::INT16)); 733 LiteMat src2_int16(1, cols, LDataType(LDataType::INT16)); 734 LiteMat expect_int16(1, cols, LDataType(LDataType::INT16)); 735 for (size_t i = 0; i < cols; i++) { 736 static_cast<INT16_C1 *>(src1_int16.data_ptr_)[i] = 2; 737 static_cast<INT16_C1 *>(src2_int16.data_ptr_)[i] = 3; 738 static_cast<INT16_C1 *>(expect_int16.data_ptr_)[i] = -1; 739 } 740 LiteMat dst_int16; 741 EXPECT_TRUE(Subtract(src1_int16, src2_int16, &dst_int16)); 742 for (size_t i = 0; i < cols; i++) { 743 EXPECT_EQ(static_cast<INT16_C1 *>(expect_int16.data_ptr_)[i].c1, 744 static_cast<INT16_C1 *>(dst_int16.data_ptr_)[i].c1); 745 } 746 } 747 748 TEST_F(MindDataImageProcess, TestSubtractUInt32) { 749 const size_t cols = 4; 750 // Test uint16 751 LiteMat src1_uint32(1, cols, LDataType(LDataType::UINT32)); 752 LiteMat src2_uint32(1, cols, LDataType(LDataType::UINT32)); 753 LiteMat expect_uint32(1, cols, LDataType(LDataType::UINT32)); 754 for (size_t i = 0; i < cols; i++) { 755 static_cast<UINT32_C1 *>(src1_uint32.data_ptr_)[i] = 2; 756 static_cast<UINT32_C1 *>(src2_uint32.data_ptr_)[i] = 3; 757 static_cast<UINT32_C1 *>(expect_uint32.data_ptr_)[i] = 0; 758 } 759 LiteMat dst_uint32; 760 EXPECT_TRUE(Subtract(src1_uint32, src2_uint32, &dst_uint32)); 761 for (size_t i = 0; i < cols; i++) { 762 EXPECT_EQ(static_cast<UINT32_C1 *>(expect_uint32.data_ptr_)[i].c1, 763 static_cast<UINT32_C1 *>(dst_uint32.data_ptr_)[i].c1); 764 } 765 } 766 767 TEST_F(MindDataImageProcess, TestSubtractInt32) { 768 const size_t cols = 4; 769 // Test int32 770 LiteMat src1_int32(1, cols, LDataType(LDataType::INT32)); 771 LiteMat src2_int32(1, cols, LDataType(LDataType::INT32)); 772 LiteMat expect_int32(1, cols, LDataType(LDataType::INT32)); 773 for (size_t i = 0; i < cols; i++) { 774 static_cast<INT32_C1 *>(src1_int32.data_ptr_)[i] = 2; 775 static_cast<INT32_C1 *>(src2_int32.data_ptr_)[i] = 4; 776 static_cast<INT32_C1 *>(expect_int32.data_ptr_)[i] = -2; 777 } 778 LiteMat dst_int32; 779 EXPECT_TRUE(Subtract(src1_int32, src2_int32, &dst_int32)); 780 for (size_t i = 0; i < cols; i++) { 781 EXPECT_EQ(static_cast<INT32_C1 *>(expect_int32.data_ptr_)[i].c1, 782 static_cast<INT32_C1 *>(dst_int32.data_ptr_)[i].c1); 783 } 784 } 785 786 TEST_F(MindDataImageProcess, TestSubtractFloat) { 787 const size_t cols = 4; 788 // Test float 789 LiteMat src1_float(1, cols, LDataType(LDataType::FLOAT32)); 790 LiteMat src2_float(1, cols, LDataType(LDataType::FLOAT32)); 791 LiteMat expect_float(1, cols, LDataType(LDataType::FLOAT32)); 792 for (size_t i = 0; i < cols; i++) { 793 static_cast<FLOAT32_C1 *>(src1_float.data_ptr_)[i] = 3.4; 794 static_cast<FLOAT32_C1 *>(src2_float.data_ptr_)[i] = 5.7; 795 static_cast<FLOAT32_C1 *>(expect_float.data_ptr_)[i] = -2.3; 796 } 797 LiteMat dst_float; 798 EXPECT_TRUE(Subtract(src1_float, src2_float, &dst_float)); 799 for (size_t i = 0; i < cols; i++) { 800 EXPECT_FLOAT_EQ(static_cast<FLOAT32_C1 *>(expect_float.data_ptr_)[i].c1, 801 static_cast<FLOAT32_C1 *>(dst_float.data_ptr_)[i].c1); 802 } 803 } 804 805 TEST_F(MindDataImageProcess, TestDivideUint8) { 806 const size_t cols = 4; 807 // Test uint8 808 LiteMat src1_uint8(1, cols); 809 LiteMat src2_uint8(1, cols); 810 LiteMat expect_uint8(1, cols); 811 for (size_t i = 0; i < cols; i++) { 812 static_cast<UINT8_C1 *>(src1_uint8.data_ptr_)[i] = 8; 813 static_cast<UINT8_C1 *>(src2_uint8.data_ptr_)[i] = 4; 814 static_cast<UINT8_C1 *>(expect_uint8.data_ptr_)[i] = 2; 815 } 816 LiteMat dst_uint8; 817 EXPECT_TRUE(Divide(src1_uint8, src2_uint8, &dst_uint8)); 818 for (size_t i = 0; i < cols; i++) { 819 EXPECT_EQ(static_cast<UINT8_C1 *>(expect_uint8.data_ptr_)[i].c1, 820 static_cast<UINT8_C1 *>(dst_uint8.data_ptr_)[i].c1); 821 } 822 } 823 824 TEST_F(MindDataImageProcess, TestDivideInt8) { 825 const size_t cols = 4; 826 // Test int8 827 LiteMat src1_int8(1, cols, LDataType(LDataType::INT8)); 828 LiteMat src2_int8(1, cols, LDataType(LDataType::INT8)); 829 LiteMat expect_int8(1, cols, LDataType(LDataType::INT8)); 830 for (size_t i = 0; i < cols; i++) { 831 static_cast<INT8_C1 *>(src1_int8.data_ptr_)[i] = 8; 832 static_cast<INT8_C1 *>(src2_int8.data_ptr_)[i] = -4; 833 static_cast<INT8_C1 *>(expect_int8.data_ptr_)[i] = -2; 834 } 835 LiteMat dst_int8; 836 EXPECT_TRUE(Divide(src1_int8, src2_int8, &dst_int8)); 837 for (size_t i = 0; i < cols; i++) { 838 EXPECT_EQ(static_cast<INT8_C1 *>(expect_int8.data_ptr_)[i].c1, static_cast<INT8_C1 *>(dst_int8.data_ptr_)[i].c1); 839 } 840 } 841 842 TEST_F(MindDataImageProcess, TestDivideUInt16) { 843 const size_t cols = 4; 844 // Test uint16 845 LiteMat src1_uint16(1, cols, LDataType(LDataType::UINT16)); 846 LiteMat src2_uint16(1, cols, LDataType(LDataType::UINT16)); 847 LiteMat expect_uint16(1, cols, LDataType(LDataType::UINT16)); 848 for (size_t i = 0; i < cols; i++) { 849 static_cast<UINT16_C1 *>(src1_uint16.data_ptr_)[i] = 40000; 850 static_cast<UINT16_C1 *>(src2_uint16.data_ptr_)[i] = 20000; 851 static_cast<UINT16_C1 *>(expect_uint16.data_ptr_)[i] = 2; 852 } 853 LiteMat dst_uint16; 854 EXPECT_TRUE(Divide(src1_uint16, src2_uint16, &dst_uint16)); 855 for (size_t i = 0; i < cols; i++) { 856 EXPECT_EQ(static_cast<UINT16_C1 *>(expect_uint16.data_ptr_)[i].c1, 857 static_cast<UINT16_C1 *>(dst_uint16.data_ptr_)[i].c1); 858 } 859 } 860 861 TEST_F(MindDataImageProcess, TestDivideInt16) { 862 const size_t cols = 4; 863 // Test int16 864 LiteMat src1_int16(1, cols, LDataType(LDataType::INT16)); 865 LiteMat src2_int16(1, cols, LDataType(LDataType::INT16)); 866 LiteMat expect_int16(1, cols, LDataType(LDataType::INT16)); 867 for (size_t i = 0; i < cols; i++) { 868 static_cast<INT16_C1 *>(src1_int16.data_ptr_)[i] = 30000; 869 static_cast<INT16_C1 *>(src2_int16.data_ptr_)[i] = -3; 870 static_cast<INT16_C1 *>(expect_int16.data_ptr_)[i] = -10000; 871 } 872 LiteMat dst_int16; 873 EXPECT_TRUE(Divide(src1_int16, src2_int16, &dst_int16)); 874 for (size_t i = 0; i < cols; i++) { 875 EXPECT_EQ(static_cast<INT16_C1 *>(expect_int16.data_ptr_)[i].c1, 876 static_cast<INT16_C1 *>(dst_int16.data_ptr_)[i].c1); 877 } 878 } 879 880 TEST_F(MindDataImageProcess, TestDivideUInt32) { 881 const size_t cols = 4; 882 // Test uint16 883 LiteMat src1_uint32(1, cols, LDataType(LDataType::UINT32)); 884 LiteMat src2_uint32(1, cols, LDataType(LDataType::UINT32)); 885 LiteMat expect_uint32(1, cols, LDataType(LDataType::UINT32)); 886 for (size_t i = 0; i < cols; i++) { 887 static_cast<UINT32_C1 *>(src1_uint32.data_ptr_)[i] = 4000000000; 888 static_cast<UINT32_C1 *>(src2_uint32.data_ptr_)[i] = 4; 889 static_cast<UINT32_C1 *>(expect_uint32.data_ptr_)[i] = 1000000000; 890 } 891 LiteMat dst_uint32; 892 EXPECT_TRUE(Divide(src1_uint32, src2_uint32, &dst_uint32)); 893 for (size_t i = 0; i < cols; i++) { 894 EXPECT_EQ(static_cast<UINT32_C1 *>(expect_uint32.data_ptr_)[i].c1, 895 static_cast<UINT32_C1 *>(dst_uint32.data_ptr_)[i].c1); 896 } 897 } 898 899 TEST_F(MindDataImageProcess, TestDivideInt32) { 900 const size_t cols = 4; 901 // Test int32 902 LiteMat src1_int32(1, cols, LDataType(LDataType::INT32)); 903 LiteMat src2_int32(1, cols, LDataType(LDataType::INT32)); 904 LiteMat expect_int32(1, cols, LDataType(LDataType::INT32)); 905 for (size_t i = 0; i < cols; i++) { 906 static_cast<INT32_C1 *>(src1_int32.data_ptr_)[i] = 2000000000; 907 static_cast<INT32_C1 *>(src2_int32.data_ptr_)[i] = -2; 908 static_cast<INT32_C1 *>(expect_int32.data_ptr_)[i] = -1000000000; 909 } 910 LiteMat dst_int32; 911 EXPECT_TRUE(Divide(src1_int32, src2_int32, &dst_int32)); 912 for (size_t i = 0; i < cols; i++) { 913 EXPECT_EQ(static_cast<INT32_C1 *>(expect_int32.data_ptr_)[i].c1, 914 static_cast<INT32_C1 *>(dst_int32.data_ptr_)[i].c1); 915 } 916 } 917 918 TEST_F(MindDataImageProcess, TestDivideFloat) { 919 const size_t cols = 4; 920 // Test float 921 LiteMat src1_float(1, cols, LDataType(LDataType::FLOAT32)); 922 LiteMat src2_float(1, cols, LDataType(LDataType::FLOAT32)); 923 LiteMat expect_float(1, cols, LDataType(LDataType::FLOAT32)); 924 for (size_t i = 0; i < cols; i++) { 925 static_cast<FLOAT32_C1 *>(src1_float.data_ptr_)[i] = 12.34f; 926 static_cast<FLOAT32_C1 *>(src2_float.data_ptr_)[i] = -2.0f; 927 static_cast<FLOAT32_C1 *>(expect_float.data_ptr_)[i] = -6.17f; 928 } 929 LiteMat dst_float; 930 EXPECT_TRUE(Divide(src1_float, src2_float, &dst_float)); 931 for (size_t i = 0; i < cols; i++) { 932 EXPECT_FLOAT_EQ(static_cast<FLOAT32_C1 *>(expect_float.data_ptr_)[i].c1, 933 static_cast<FLOAT32_C1 *>(dst_float.data_ptr_)[i].c1); 934 } 935 } 936 937 TEST_F(MindDataImageProcess, TestMultiplyUint8) { 938 const size_t cols = 4; 939 // Test uint8 940 LiteMat src1_uint8(1, cols); 941 LiteMat src2_uint8(1, cols); 942 LiteMat expect_uint8(1, cols); 943 for (size_t i = 0; i < cols; i++) { 944 static_cast<UINT8_C1 *>(src1_uint8.data_ptr_)[i] = 8; 945 static_cast<UINT8_C1 *>(src2_uint8.data_ptr_)[i] = 4; 946 static_cast<UINT8_C1 *>(expect_uint8.data_ptr_)[i] = 32; 947 } 948 LiteMat dst_uint8; 949 EXPECT_TRUE(Multiply(src1_uint8, src2_uint8, &dst_uint8)); 950 for (size_t i = 0; i < cols; i++) { 951 EXPECT_EQ(static_cast<UINT8_C1 *>(expect_uint8.data_ptr_)[i].c1, 952 static_cast<UINT8_C1 *>(dst_uint8.data_ptr_)[i].c1); 953 } 954 } 955 956 TEST_F(MindDataImageProcess, TestMultiplyUInt16) { 957 const size_t cols = 4; 958 // Test int16 959 LiteMat src1_int16(1, cols, LDataType(LDataType::UINT16)); 960 LiteMat src2_int16(1, cols, LDataType(LDataType::UINT16)); 961 LiteMat expect_int16(1, cols, LDataType(LDataType::UINT16)); 962 for (size_t i = 0; i < cols; i++) { 963 static_cast<UINT16_C1 *>(src1_int16.data_ptr_)[i] = 60000; 964 static_cast<UINT16_C1 *>(src2_int16.data_ptr_)[i] = 2; 965 static_cast<UINT16_C1 *>(expect_int16.data_ptr_)[i] = 65535; 966 } 967 LiteMat dst_int16; 968 EXPECT_TRUE(Multiply(src1_int16, src2_int16, &dst_int16)); 969 for (size_t i = 0; i < cols; i++) { 970 EXPECT_EQ(static_cast<UINT16_C1 *>(expect_int16.data_ptr_)[i].c1, 971 static_cast<UINT16_C1 *>(dst_int16.data_ptr_)[i].c1); 972 } 973 } 974 975 TEST_F(MindDataImageProcess, TestMultiplyFloat) { 976 const size_t cols = 4; 977 // Test float 978 LiteMat src1_float(1, cols, LDataType(LDataType::FLOAT32)); 979 LiteMat src2_float(1, cols, LDataType(LDataType::FLOAT32)); 980 LiteMat expect_float(1, cols, LDataType(LDataType::FLOAT32)); 981 for (size_t i = 0; i < cols; i++) { 982 static_cast<FLOAT32_C1 *>(src1_float.data_ptr_)[i] = 30.0f; 983 static_cast<FLOAT32_C1 *>(src2_float.data_ptr_)[i] = -2.0f; 984 static_cast<FLOAT32_C1 *>(expect_float.data_ptr_)[i] = -60.0f; 985 } 986 LiteMat dst_float; 987 EXPECT_TRUE(Multiply(src1_float, src2_float, &dst_float)); 988 for (size_t i = 0; i < cols; i++) { 989 EXPECT_FLOAT_EQ(static_cast<FLOAT32_C1 *>(expect_float.data_ptr_)[i].c1, 990 static_cast<FLOAT32_C1 *>(dst_float.data_ptr_)[i].c1); 991 } 992 } 993 994 TEST_F(MindDataImageProcess, TestExtractChannel) { 995 LiteMat lite_single; 996 LiteMat lite_mat = LiteMat(1, 4, 3, LDataType::UINT16); 997 998 EXPECT_FALSE(ExtractChannel(lite_mat, lite_single, 0)); 999 EXPECT_TRUE(lite_single.IsEmpty()); 1000 } 1001 TEST_F(MindDataImageProcess, testROI3C) { 1002 std::string filename = "data/dataset/apple.jpg"; 1003 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1004 1005 cv::Mat cv_roi = cv::Mat(src_image, cv::Rect(500, 500, 3000, 1500)); 1006 1007 cv::imwrite("./cv_roi.jpg", cv_roi); 1008 1009 bool ret = false; 1010 LiteMat lite_mat_bgr; 1011 ret = InitFromPixel(src_image.data, LPixelType::BGR, LDataType::UINT8, src_image.cols, src_image.rows, lite_mat_bgr); 1012 EXPECT_TRUE(ret); 1013 LiteMat lite_roi; 1014 1015 ret = lite_mat_bgr.GetROI(500, 500, 3000, 1500, lite_roi); 1016 EXPECT_TRUE(ret); 1017 1018 LiteMat lite_roi_save(3000, 1500, lite_roi.channel_, LDataType::UINT8); 1019 1020 for (size_t i = 0; i < lite_roi.height_; i++) { 1021 const unsigned char *ptr = lite_roi.ptr<unsigned char>(i); 1022 size_t image_size = lite_roi.width_ * lite_roi.channel_ * sizeof(unsigned char); 1023 unsigned char *dst_ptr = (unsigned char *)lite_roi_save.data_ptr_ + image_size * i; 1024 (void)memcpy(dst_ptr, ptr, image_size); 1025 } 1026 1027 cv::Mat dst_imageR(lite_roi_save.height_, lite_roi_save.width_, CV_8UC3, lite_roi_save.data_ptr_); 1028 cv::imwrite("./lite_roi.jpg", dst_imageR); 1029 } 1030 1031 TEST_F(MindDataImageProcess, testROI3CFalse) { 1032 std::string filename = "data/dataset/apple.jpg"; 1033 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1034 1035 cv::Mat cv_roi = cv::Mat(src_image, cv::Rect(500, 500, 3000, 1500)); 1036 1037 cv::imwrite("./cv_roi.jpg", cv_roi); 1038 1039 bool ret = false; 1040 LiteMat lite_mat_bgr; 1041 ret = InitFromPixel(src_image.data, LPixelType::BGR, LDataType::UINT8, src_image.cols, src_image.rows, lite_mat_bgr); 1042 EXPECT_TRUE(ret); 1043 LiteMat lite_roi; 1044 1045 ret = lite_mat_bgr.GetROI(500, 500, 1200, -100, lite_roi); 1046 EXPECT_FALSE(ret); 1047 } 1048 1049 TEST_F(MindDataImageProcess, testROI1C) { 1050 std::string filename = "data/dataset/apple.jpg"; 1051 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1052 1053 cv::Mat gray_image; 1054 cv::cvtColor(src_image, gray_image, CV_BGR2GRAY); 1055 cv::Mat cv_roi_gray = cv::Mat(gray_image, cv::Rect(500, 500, 3000, 1500)); 1056 1057 cv::imwrite("./cv_roi_gray.jpg", cv_roi_gray); 1058 1059 cv::Mat rgba_mat; 1060 cv::cvtColor(src_image, rgba_mat, CV_BGR2RGBA); 1061 bool ret = false; 1062 LiteMat lite_mat_gray; 1063 ret = 1064 InitFromPixel(rgba_mat.data, LPixelType::RGBA2GRAY, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_gray); 1065 EXPECT_TRUE(ret); 1066 LiteMat lite_roi_gray; 1067 1068 ret = lite_mat_gray.GetROI(500, 500, 3000, 1500, lite_roi_gray); 1069 EXPECT_TRUE(ret); 1070 1071 LiteMat lite_roi_gray_save(3000, 1500, lite_roi_gray.channel_, LDataType::UINT8); 1072 1073 for (size_t i = 0; i < lite_roi_gray.height_; i++) { 1074 const unsigned char *ptr = lite_roi_gray.ptr<unsigned char>(i); 1075 size_t image_size = lite_roi_gray.width_ * lite_roi_gray.channel_ * sizeof(unsigned char); 1076 unsigned char *dst_ptr = (unsigned char *)lite_roi_gray_save.data_ptr_ + image_size * i; 1077 (void)memcpy(dst_ptr, ptr, image_size); 1078 } 1079 1080 cv::Mat dst_imageR(lite_roi_gray_save.height_, lite_roi_gray_save.width_, CV_8UC1, lite_roi_gray_save.data_ptr_); 1081 cv::imwrite("./lite_roi.jpg", dst_imageR); 1082 } 1083 1084 // warp 1085 TEST_F(MindDataImageProcess, testWarpAffineBGR) { 1086 std::string filename = "data/dataset/apple.jpg"; 1087 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1088 cv::Point2f srcTri[3]; 1089 cv::Point2f dstTri[3]; 1090 srcTri[0] = cv::Point2f(0, 0); 1091 srcTri[1] = cv::Point2f(src_image.cols - 1, 0); 1092 srcTri[2] = cv::Point2f(0, src_image.rows - 1); 1093 1094 dstTri[0] = cv::Point2f(src_image.cols * 0.0, src_image.rows * 0.33); 1095 dstTri[1] = cv::Point2f(src_image.cols * 0.85, src_image.rows * 0.25); 1096 dstTri[2] = cv::Point2f(src_image.cols * 0.15, src_image.rows * 0.7); 1097 1098 cv::Mat warp_mat = cv::getAffineTransform(srcTri, dstTri); 1099 ; 1100 cv::Mat warp_dstImage; 1101 cv::warpAffine(src_image, warp_dstImage, warp_mat, warp_dstImage.size()); 1102 cv::imwrite("./warpAffine_cv_bgr.png", warp_dstImage); 1103 1104 bool ret = false; 1105 LiteMat lite_mat_bgr; 1106 ret = InitFromPixel(src_image.data, LPixelType::BGR, LDataType::UINT8, src_image.cols, src_image.rows, lite_mat_bgr); 1107 EXPECT_TRUE(ret); 1108 double *mat_ptr = warp_mat.ptr<double>(0); 1109 LiteMat lite_M(3, 2, 1, mat_ptr, LDataType::DOUBLE); 1110 1111 LiteMat lite_warp; 1112 std::vector<uint8_t> borderValues; 1113 borderValues.push_back(0); 1114 borderValues.push_back(0); 1115 borderValues.push_back(0); 1116 ret = WarpAffineBilinear(lite_mat_bgr, lite_warp, lite_M, lite_mat_bgr.width_, lite_mat_bgr.height_, 1117 PADD_BORDER_CONSTANT, borderValues); 1118 EXPECT_TRUE(ret); 1119 1120 cv::Mat dst_imageR(lite_warp.height_, lite_warp.width_, CV_8UC3, lite_warp.data_ptr_); 1121 cv::imwrite("./warpAffine_lite_bgr.png", dst_imageR); 1122 } 1123 1124 TEST_F(MindDataImageProcess, testWarpAffineBGRScale) { 1125 std::string filename = "data/dataset/apple.jpg"; 1126 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1127 cv::Point2f srcTri[3]; 1128 cv::Point2f dstTri[3]; 1129 srcTri[0] = cv::Point2f(10, 20); 1130 srcTri[1] = cv::Point2f(src_image.cols - 1 - 100, 0); 1131 srcTri[2] = cv::Point2f(0, src_image.rows - 1 - 300); 1132 1133 dstTri[0] = cv::Point2f(src_image.cols * 0.22, src_image.rows * 0.33); 1134 dstTri[1] = cv::Point2f(src_image.cols * 0.87, src_image.rows * 0.75); 1135 dstTri[2] = cv::Point2f(src_image.cols * 0.35, src_image.rows * 0.37); 1136 1137 cv::Mat warp_mat = cv::getAffineTransform(srcTri, dstTri); 1138 ; 1139 cv::Mat warp_dstImage; 1140 cv::warpAffine(src_image, warp_dstImage, warp_mat, warp_dstImage.size()); 1141 cv::imwrite("./warpAffine_cv_bgr_scale.png", warp_dstImage); 1142 1143 bool ret = false; 1144 LiteMat lite_mat_bgr; 1145 ret = InitFromPixel(src_image.data, LPixelType::BGR, LDataType::UINT8, src_image.cols, src_image.rows, lite_mat_bgr); 1146 EXPECT_TRUE(ret); 1147 double *mat_ptr = warp_mat.ptr<double>(0); 1148 LiteMat lite_M(3, 2, 1, mat_ptr, LDataType::DOUBLE); 1149 1150 LiteMat lite_warp; 1151 std::vector<uint8_t> borderValues; 1152 borderValues.push_back(0); 1153 borderValues.push_back(0); 1154 borderValues.push_back(0); 1155 ret = WarpAffineBilinear(lite_mat_bgr, lite_warp, lite_M, lite_mat_bgr.width_, lite_mat_bgr.height_, 1156 PADD_BORDER_CONSTANT, borderValues); 1157 EXPECT_TRUE(ret); 1158 1159 cv::Mat dst_imageR(lite_warp.height_, lite_warp.width_, CV_8UC3, lite_warp.data_ptr_); 1160 cv::imwrite("./warpAffine_lite_bgr_scale.png", dst_imageR); 1161 } 1162 1163 TEST_F(MindDataImageProcess, testWarpAffineBGRResize) { 1164 std::string filename = "data/dataset/apple.jpg"; 1165 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1166 cv::Point2f srcTri[3]; 1167 cv::Point2f dstTri[3]; 1168 srcTri[0] = cv::Point2f(10, 20); 1169 srcTri[1] = cv::Point2f(src_image.cols - 1 - 100, 0); 1170 srcTri[2] = cv::Point2f(0, src_image.rows - 1 - 300); 1171 1172 dstTri[0] = cv::Point2f(src_image.cols * 0.22, src_image.rows * 0.33); 1173 dstTri[1] = cv::Point2f(src_image.cols * 0.87, src_image.rows * 0.75); 1174 dstTri[2] = cv::Point2f(src_image.cols * 0.35, src_image.rows * 0.37); 1175 1176 cv::Mat warp_mat = cv::getAffineTransform(srcTri, dstTri); 1177 ; 1178 cv::Mat warp_dstImage; 1179 cv::warpAffine(src_image, warp_dstImage, warp_mat, cv::Size(src_image.cols + 200, src_image.rows - 300)); 1180 cv::imwrite("./warpAffine_cv_bgr_resize.png", warp_dstImage); 1181 1182 bool ret = false; 1183 LiteMat lite_mat_bgr; 1184 ret = InitFromPixel(src_image.data, LPixelType::BGR, LDataType::UINT8, src_image.cols, src_image.rows, lite_mat_bgr); 1185 EXPECT_TRUE(ret); 1186 double *mat_ptr = warp_mat.ptr<double>(0); 1187 LiteMat lite_M(3, 2, 1, mat_ptr, LDataType::DOUBLE); 1188 1189 LiteMat lite_warp; 1190 std::vector<uint8_t> borderValues; 1191 borderValues.push_back(0); 1192 borderValues.push_back(0); 1193 borderValues.push_back(0); 1194 ret = WarpAffineBilinear(lite_mat_bgr, lite_warp, lite_M, lite_mat_bgr.width_ + 200, lite_mat_bgr.height_ - 300, 1195 PADD_BORDER_CONSTANT, borderValues); 1196 EXPECT_TRUE(ret); 1197 1198 cv::Mat dst_imageR(lite_warp.height_, lite_warp.width_, CV_8UC3, lite_warp.data_ptr_); 1199 cv::imwrite("./warpAffine_lite_bgr_resize.png", dst_imageR); 1200 } 1201 1202 TEST_F(MindDataImageProcess, testWarpAffineGray) { 1203 std::string filename = "data/dataset/apple.jpg"; 1204 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1205 1206 cv::Mat gray_image; 1207 cv::cvtColor(src_image, gray_image, CV_BGR2GRAY); 1208 1209 cv::Point2f srcTri[3]; 1210 cv::Point2f dstTri[3]; 1211 srcTri[0] = cv::Point2f(0, 0); 1212 srcTri[1] = cv::Point2f(src_image.cols - 1, 0); 1213 srcTri[2] = cv::Point2f(0, src_image.rows - 1); 1214 1215 dstTri[0] = cv::Point2f(src_image.cols * 0.0, src_image.rows * 0.33); 1216 dstTri[1] = cv::Point2f(src_image.cols * 0.85, src_image.rows * 0.25); 1217 dstTri[2] = cv::Point2f(src_image.cols * 0.15, src_image.rows * 0.7); 1218 1219 cv::Mat warp_mat = cv::getAffineTransform(srcTri, dstTri); 1220 ; 1221 cv::Mat warp_gray_dstImage; 1222 cv::warpAffine(gray_image, warp_gray_dstImage, warp_mat, cv::Size(src_image.cols + 200, src_image.rows - 300)); 1223 cv::imwrite("./warpAffine_cv_gray.png", warp_gray_dstImage); 1224 1225 cv::Mat rgba_mat; 1226 cv::cvtColor(src_image, rgba_mat, CV_BGR2RGBA); 1227 bool ret = false; 1228 LiteMat lite_mat_gray; 1229 ret = 1230 InitFromPixel(rgba_mat.data, LPixelType::RGBA2GRAY, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_gray); 1231 EXPECT_TRUE(ret); 1232 double *mat_ptr = warp_mat.ptr<double>(0); 1233 LiteMat lite_M(3, 2, 1, mat_ptr, LDataType::DOUBLE); 1234 1235 LiteMat lite_warp; 1236 std::vector<uint8_t> borderValues; 1237 borderValues.push_back(0); 1238 ret = WarpAffineBilinear(lite_mat_gray, lite_warp, lite_M, lite_mat_gray.width_ + 200, lite_mat_gray.height_ - 300, 1239 PADD_BORDER_CONSTANT, borderValues); 1240 EXPECT_TRUE(ret); 1241 1242 cv::Mat dst_imageR(lite_warp.height_, lite_warp.width_, CV_8UC1, lite_warp.data_ptr_); 1243 cv::imwrite("./warpAffine_lite_gray.png", dst_imageR); 1244 } 1245 1246 TEST_F(MindDataImageProcess, testWarpPerspectiveBGRResize) { 1247 std::string filename = "data/dataset/apple.jpg"; 1248 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1249 cv::Point2f srcQuad[4], dstQuad[4]; 1250 srcQuad[0].x = 0; 1251 srcQuad[0].y = 0; 1252 srcQuad[1].x = src_image.cols - 1.; 1253 srcQuad[1].y = 0; 1254 srcQuad[2].x = 0; 1255 srcQuad[2].y = src_image.rows - 1; 1256 srcQuad[3].x = src_image.cols - 1; 1257 srcQuad[3].y = src_image.rows - 1; 1258 1259 dstQuad[0].x = src_image.cols * 0.05; 1260 dstQuad[0].y = src_image.rows * 0.33; 1261 dstQuad[1].x = src_image.cols * 0.9; 1262 dstQuad[1].y = src_image.rows * 0.25; 1263 dstQuad[2].x = src_image.cols * 0.2; 1264 dstQuad[2].y = src_image.rows * 0.7; 1265 dstQuad[3].x = src_image.cols * 0.8; 1266 dstQuad[3].y = src_image.rows * 0.9; 1267 1268 cv::Mat ptran = cv::getPerspectiveTransform(srcQuad, dstQuad, cv::DECOMP_SVD); 1269 cv::Mat warp_dstImage; 1270 cv::warpPerspective(src_image, warp_dstImage, ptran, cv::Size(src_image.cols + 200, src_image.rows - 300)); 1271 cv::imwrite("./warpPerspective_cv_bgr.png", warp_dstImage); 1272 1273 bool ret = false; 1274 LiteMat lite_mat_bgr; 1275 ret = InitFromPixel(src_image.data, LPixelType::BGR, LDataType::UINT8, src_image.cols, src_image.rows, lite_mat_bgr); 1276 EXPECT_TRUE(ret); 1277 double *mat_ptr = ptran.ptr<double>(0); 1278 LiteMat lite_M(3, 3, 1, mat_ptr, LDataType::DOUBLE); 1279 1280 LiteMat lite_warp; 1281 std::vector<uint8_t> borderValues; 1282 borderValues.push_back(0); 1283 borderValues.push_back(0); 1284 borderValues.push_back(0); 1285 ret = WarpPerspectiveBilinear(lite_mat_bgr, lite_warp, lite_M, lite_mat_bgr.width_ + 200, lite_mat_bgr.height_ - 300, 1286 PADD_BORDER_CONSTANT, borderValues); 1287 EXPECT_TRUE(ret); 1288 1289 cv::Mat dst_imageR(lite_warp.height_, lite_warp.width_, CV_8UC3, lite_warp.data_ptr_); 1290 cv::imwrite("./warpPerspective_lite_bgr.png", dst_imageR); 1291 } 1292 1293 TEST_F(MindDataImageProcess, testWarpPerspectiveGrayResize) { 1294 std::string filename = "data/dataset/apple.jpg"; 1295 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1296 1297 cv::Mat gray_image; 1298 cv::cvtColor(src_image, gray_image, CV_BGR2GRAY); 1299 1300 cv::Point2f srcQuad[4], dstQuad[4]; 1301 srcQuad[0].x = 0; 1302 srcQuad[0].y = 0; 1303 srcQuad[1].x = src_image.cols - 1.; 1304 srcQuad[1].y = 0; 1305 srcQuad[2].x = 0; 1306 srcQuad[2].y = src_image.rows - 1; 1307 srcQuad[3].x = src_image.cols - 1; 1308 srcQuad[3].y = src_image.rows - 1; 1309 1310 dstQuad[0].x = src_image.cols * 0.05; 1311 dstQuad[0].y = src_image.rows * 0.33; 1312 dstQuad[1].x = src_image.cols * 0.9; 1313 dstQuad[1].y = src_image.rows * 0.25; 1314 dstQuad[2].x = src_image.cols * 0.2; 1315 dstQuad[2].y = src_image.rows * 0.7; 1316 dstQuad[3].x = src_image.cols * 0.8; 1317 dstQuad[3].y = src_image.rows * 0.9; 1318 1319 cv::Mat ptran = cv::getPerspectiveTransform(srcQuad, dstQuad, cv::DECOMP_SVD); 1320 cv::Mat warp_dstImage; 1321 cv::warpPerspective(gray_image, warp_dstImage, ptran, cv::Size(gray_image.cols + 200, gray_image.rows - 300)); 1322 cv::imwrite("./warpPerspective_cv_gray.png", warp_dstImage); 1323 1324 cv::Mat rgba_mat; 1325 cv::cvtColor(src_image, rgba_mat, CV_BGR2RGBA); 1326 bool ret = false; 1327 LiteMat lite_mat_gray; 1328 ret = 1329 InitFromPixel(rgba_mat.data, LPixelType::RGBA2GRAY, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_gray); 1330 EXPECT_TRUE(ret); 1331 double *mat_ptr = ptran.ptr<double>(0); 1332 LiteMat lite_M(3, 3, 1, mat_ptr, LDataType::DOUBLE); 1333 1334 LiteMat lite_warp; 1335 std::vector<uint8_t> borderValues; 1336 borderValues.push_back(0); 1337 ret = WarpPerspectiveBilinear(lite_mat_gray, lite_warp, lite_M, lite_mat_gray.width_ + 200, 1338 lite_mat_gray.height_ - 300, PADD_BORDER_CONSTANT, borderValues); 1339 EXPECT_TRUE(ret); 1340 1341 cv::Mat dst_imageR(lite_warp.height_, lite_warp.width_, CV_8UC1, lite_warp.data_ptr_); 1342 cv::imwrite("./warpPerspective_lite_gray.png", dst_imageR); 1343 } 1344 1345 TEST_F(MindDataImageProcess, testGetRotationMatrix2D) { 1346 std::vector<std::vector<double>> expect_matrix = {{0.250000, 0.433013, -0.116025}, {-0.433013, 0.250000, 1.933013}}; 1347 1348 double angle = 60.0; 1349 double scale = 0.5; 1350 1351 LiteMat M; 1352 bool ret = false; 1353 ret = GetRotationMatrix2D(1.0f, 2.0f, angle, scale, M); 1354 EXPECT_TRUE(ret); 1355 AccuracyComparison(expect_matrix, M); 1356 } 1357 1358 TEST_F(MindDataImageProcess, testGetPerspectiveTransform) { 1359 std::vector<std::vector<double>> expect_matrix = { 1360 {1.272113, 3.665216, -788.484287}, {-0.394146, 3.228247, -134.009780}, {-0.001460, 0.006414, 1}}; 1361 1362 std::vector<Point> src = {Point(165, 270), Point(835, 270), Point(360, 125), Point(615, 125)}; 1363 std::vector<Point> dst = {Point(165, 270), Point(835, 270), Point(100, 100), Point(500, 30)}; 1364 1365 LiteMat M; 1366 bool ret = false; 1367 ret = GetPerspectiveTransform(src, dst, M); 1368 EXPECT_TRUE(ret); 1369 AccuracyComparison(expect_matrix, M); 1370 } 1371 1372 TEST_F(MindDataImageProcess, testGetPerspectiveTransformFail) { 1373 std::vector<Point> src = {Point(165, 270), Point(835, 270), Point(360, 125), Point(615, 125)}; 1374 std::vector<Point> dst = {Point(100, 100), Point(500, 30)}; 1375 1376 LiteMat M; 1377 bool ret = GetPerspectiveTransform(src, dst, M); 1378 EXPECT_FALSE(ret); 1379 1380 std::vector<Point> src1 = {Point(360, 125), Point(615, 125)}; 1381 std::vector<Point> dst2 = {Point(165, 270), Point(835, 270), Point(100, 100), Point(500, 30)}; 1382 1383 LiteMat M1; 1384 bool ret1 = GetPerspectiveTransform(src, dst, M1); 1385 EXPECT_FALSE(ret1); 1386 } 1387 1388 TEST_F(MindDataImageProcess, testGetAffineTransform) { 1389 std::vector<std::vector<double>> expect_matrix = {{0.400000, 0.066667, 16.666667}, {0.000000, 0.333333, 23.333333}}; 1390 1391 std::vector<Point> src = {Point(50, 50), Point(200, 50), Point(50, 200)}; 1392 std::vector<Point> dst = {Point(40, 40), Point(100, 40), Point(50, 90)}; 1393 1394 LiteMat M; 1395 bool ret = false; 1396 ret = GetAffineTransform(src, dst, M); 1397 EXPECT_TRUE(ret); 1398 AccuracyComparison(expect_matrix, M); 1399 } 1400 1401 TEST_F(MindDataImageProcess, testGetAffineTransformFail) { 1402 std::vector<Point> src = {Point(50, 50), Point(200, 50)}; 1403 std::vector<Point> dst = {Point(40, 40), Point(100, 40), Point(50, 90)}; 1404 1405 LiteMat M; 1406 bool ret = GetAffineTransform(src, dst, M); 1407 EXPECT_FALSE(ret); 1408 1409 std::vector<Point> src1 = {Point(50, 50), Point(200, 50), Point(50, 200)}; 1410 std::vector<Point> dst1 = {Point(40, 40), Point(100, 40)}; 1411 1412 LiteMat M1; 1413 bool ret1 = GetAffineTransform(src1, dst1, M1); 1414 EXPECT_FALSE(ret1); 1415 } 1416 1417 TEST_F(MindDataImageProcess, TestConv2D8U) { 1418 LiteMat lite_mat_src; 1419 lite_mat_src.Init(3, 3, 1, LDataType::UINT8); 1420 uint8_t *src_ptr = lite_mat_src; 1421 for (int i = 0; i < 9; i++) { 1422 src_ptr[i] = i % 3; 1423 } 1424 LiteMat kernel; 1425 kernel.Init(3, 3, 1, LDataType::FLOAT32); 1426 float *kernel_ptr = kernel; 1427 for (int i = 0; i < 9; i++) { 1428 kernel_ptr[i] = i % 2; 1429 } 1430 LiteMat lite_mat_dst; 1431 bool ret = Conv2D(lite_mat_src, kernel, lite_mat_dst, LDataType::UINT8); 1432 ASSERT_TRUE(ret == true); 1433 1434 std::vector<uint8_t> expected_result = {2, 4, 6, 2, 4, 6, 2, 4, 6}; 1435 1436 size_t total_size = lite_mat_dst.height_ * lite_mat_dst.width_ * lite_mat_dst.channel_; 1437 float distance = 0.0f; 1438 for (size_t i = 0; i < total_size; i++) { 1439 distance += pow(((uint8_t *)lite_mat_dst)[i] - expected_result[i], 2); 1440 } 1441 distance = sqrt(distance / total_size); 1442 EXPECT_EQ(distance, 0.0f); 1443 } 1444 1445 TEST_F(MindDataImageProcess, TestConv2D32F) { 1446 LiteMat lite_mat_src; 1447 lite_mat_src.Init(2, 2, 1, LDataType::FLOAT32); 1448 float *src_ptr = lite_mat_src; 1449 for (int i = 0; i < 4; i++) { 1450 src_ptr[i] = static_cast<float>(i) / 2; 1451 } 1452 LiteMat kernel; 1453 kernel.Init(2, 2, 1, LDataType::FLOAT32); 1454 float *kernel_ptr = kernel; 1455 for (int i = 0; i < 4; i++) { 1456 kernel_ptr[i] = static_cast<float>(i); 1457 } 1458 LiteMat lite_mat_dst; 1459 bool ret = Conv2D(lite_mat_src, kernel, lite_mat_dst, LDataType::FLOAT32); 1460 ASSERT_TRUE(ret == true); 1461 1462 std::vector<float> expected_result = {2.f, 3.f, 6.f, 7.f}; 1463 1464 size_t total_size = lite_mat_dst.height_ * lite_mat_dst.width_ * lite_mat_dst.channel_; 1465 float distance = 0.0f; 1466 for (size_t i = 0; i < total_size; i++) { 1467 distance += pow(((float *)lite_mat_dst)[i] - expected_result[i], 2); 1468 } 1469 distance = sqrt(distance / total_size); 1470 EXPECT_EQ(distance, 0.0f); 1471 } 1472 1473 TEST_F(MindDataImageProcess, TestGaussianBlurSize35) { 1474 std::string filename = "data/dataset/apple.jpg"; 1475 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1476 1477 cv::Mat dst_image; 1478 cv::GaussianBlur(src_image, dst_image, cv::Size(3, 5), 3, 3); 1479 1480 cv::Mat rgba_mat; 1481 cv::cvtColor(src_image, rgba_mat, CV_BGR2RGBA); 1482 1483 LiteMat lite_mat_bgr; 1484 bool ret = 1485 InitFromPixel(rgba_mat.data, LPixelType::RGBA2BGR, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_bgr); 1486 ASSERT_TRUE(ret == true); 1487 1488 LiteMat lite_mat_dst; 1489 ret = GaussianBlur(lite_mat_bgr, lite_mat_dst, {3, 5}, 3, 3); 1490 ASSERT_TRUE(ret == true); 1491 1492 size_t total_size = lite_mat_dst.height_ * lite_mat_dst.width_ * lite_mat_dst.channel_; 1493 double distance = 0.0f; 1494 for (size_t i = 0; i < total_size; i++) { 1495 distance += pow((uint8_t)dst_image.data[i] - ((uint8_t *)lite_mat_dst)[i], 2); 1496 } 1497 distance = sqrt(distance / total_size); 1498 EXPECT_LE(distance, 1.0f); 1499 } 1500 1501 TEST_F(MindDataImageProcess, TestGaussianBlurSize13) { 1502 std::string filename = "data/dataset/apple.jpg"; 1503 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1504 1505 cv::Mat dst_image; 1506 cv::GaussianBlur(src_image, dst_image, cv::Size(1, 3), 3); 1507 1508 cv::Mat rgba_mat; 1509 cv::cvtColor(src_image, rgba_mat, CV_BGR2RGBA); 1510 1511 LiteMat lite_mat_bgr; 1512 bool ret = 1513 InitFromPixel(rgba_mat.data, LPixelType::RGBA2BGR, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_bgr); 1514 ASSERT_TRUE(ret == true); 1515 1516 LiteMat lite_mat_dst; 1517 ret = GaussianBlur(lite_mat_bgr, lite_mat_dst, {1, 3}, 3); 1518 ASSERT_TRUE(ret == true); 1519 1520 size_t total_size = lite_mat_dst.height_ * lite_mat_dst.width_ * lite_mat_dst.channel_; 1521 double distance = 0.0f; 1522 for (size_t i = 0; i < total_size; i++) { 1523 distance += pow((uint8_t)dst_image.data[i] - ((uint8_t *)lite_mat_dst)[i], 2); 1524 } 1525 distance = sqrt(distance / total_size); 1526 EXPECT_LE(distance, 1.0f); 1527 } 1528 1529 TEST_F(MindDataImageProcess, TestGaussianBlurInvalidParams) { 1530 std::string filename = "data/dataset/apple.jpg"; 1531 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1532 cv::Mat rgba_mat; 1533 cv::cvtColor(src_image, rgba_mat, CV_BGR2RGBA); 1534 1535 LiteMat lite_mat_bgr; 1536 bool ret = 1537 InitFromPixel(rgba_mat.data, LPixelType::RGBA2BGR, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_bgr); 1538 ASSERT_TRUE(ret == true); 1539 1540 LiteMat lite_mat_dst; 1541 1542 // even size 1543 ret = GaussianBlur(lite_mat_bgr, lite_mat_dst, {3, 4}, 3); 1544 ASSERT_TRUE(ret == false); 1545 1546 // ksize.size() != 2 1547 ret = GaussianBlur(lite_mat_bgr, lite_mat_dst, {3, 4, 5}, 3); 1548 ASSERT_TRUE(ret == false); 1549 1550 // size less or equal to 0 1551 ret = GaussianBlur(lite_mat_bgr, lite_mat_dst, {0, 3}, 3); 1552 ASSERT_TRUE(ret == false); 1553 1554 // sigmaX less or equal to 0 1555 ret = GaussianBlur(lite_mat_bgr, lite_mat_dst, {3, 3}, 0); 1556 ASSERT_TRUE(ret == false); 1557 } 1558 1559 TEST_F(MindDataImageProcess, TestCannySize3) { 1560 std::string filename = "data/dataset/apple.jpg"; 1561 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1562 cv::Mat gray_image; 1563 cv::cvtColor(src_image, gray_image, CV_BGR2GRAY); 1564 cv::Mat dst_image; 1565 cv::Canny(gray_image, dst_image, 100, 200, 3); 1566 1567 cv::Mat rgba_mat; 1568 cv::cvtColor(src_image, rgba_mat, CV_BGR2RGBA); 1569 bool ret = false; 1570 LiteMat lite_mat_gray; 1571 ret = 1572 InitFromPixel(rgba_mat.data, LPixelType::RGBA2GRAY, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_gray); 1573 ASSERT_TRUE(ret == true); 1574 1575 LiteMat lite_mat_dst; 1576 ret = Canny(lite_mat_gray, lite_mat_dst, 100, 200, 3); 1577 ASSERT_TRUE(ret == true); 1578 1579 int total_size = lite_mat_dst.height_ * lite_mat_dst.width_ * lite_mat_dst.channel_; 1580 double distance = 0.0f; 1581 for (int i = 0; i < total_size; i++) { 1582 distance += pow((uint8_t)dst_image.data[i] - ((uint8_t *)lite_mat_dst)[i], 2); 1583 } 1584 distance = sqrt(distance / total_size); 1585 EXPECT_EQ(distance, 0.0f); 1586 } 1587 1588 TEST_F(MindDataImageProcess, TestCannySize5) { 1589 std::string filename = "data/dataset/apple.jpg"; 1590 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1591 cv::Mat gray_image; 1592 cv::cvtColor(src_image, gray_image, CV_BGR2GRAY); 1593 cv::Mat dst_image; 1594 cv::Canny(gray_image, dst_image, 200, 300, 5); 1595 1596 cv::Mat rgba_mat; 1597 cv::cvtColor(src_image, rgba_mat, CV_BGR2RGBA); 1598 bool ret = false; 1599 LiteMat lite_mat_gray; 1600 ret = 1601 InitFromPixel(rgba_mat.data, LPixelType::RGBA2GRAY, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_gray); 1602 ASSERT_TRUE(ret == true); 1603 1604 LiteMat lite_mat_dst; 1605 ret = Canny(lite_mat_gray, lite_mat_dst, 200, 300, 5); 1606 ASSERT_TRUE(ret == true); 1607 1608 int total_size = lite_mat_dst.height_ * lite_mat_dst.width_ * lite_mat_dst.channel_; 1609 double distance = 0.0f; 1610 for (int i = 0; i < total_size; i++) { 1611 distance += pow((uint8_t)dst_image.data[i] - ((uint8_t *)lite_mat_dst)[i], 2); 1612 } 1613 distance = sqrt(distance / total_size); 1614 EXPECT_EQ(distance, 0.0f); 1615 } 1616 1617 TEST_F(MindDataImageProcess, TestCannySize7) { 1618 std::string filename = "data/dataset/apple.jpg"; 1619 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1620 cv::Mat gray_image; 1621 cv::cvtColor(src_image, gray_image, CV_BGR2GRAY); 1622 cv::Mat dst_image; 1623 cv::Canny(gray_image, dst_image, 110, 220, 7); 1624 1625 cv::Mat rgba_mat; 1626 cv::cvtColor(src_image, rgba_mat, CV_BGR2RGBA); 1627 bool ret = false; 1628 LiteMat lite_mat_gray; 1629 ret = 1630 InitFromPixel(rgba_mat.data, LPixelType::RGBA2GRAY, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_gray); 1631 ASSERT_TRUE(ret == true); 1632 1633 LiteMat lite_mat_dst; 1634 ret = Canny(lite_mat_gray, lite_mat_dst, 110, 220, 7); 1635 ASSERT_TRUE(ret == true); 1636 1637 int total_size = lite_mat_dst.height_ * lite_mat_dst.width_ * lite_mat_dst.channel_; 1638 double distance = 0.0f; 1639 for (int i = 0; i < total_size; i++) { 1640 distance += pow((uint8_t)dst_image.data[i] - ((uint8_t *)lite_mat_dst)[i], 2); 1641 } 1642 distance = sqrt(distance / total_size); 1643 EXPECT_EQ(distance, 0.0f); 1644 } 1645 1646 TEST_F(MindDataImageProcess, TestCannyL2) { 1647 std::string filename = "data/dataset/apple.jpg"; 1648 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1649 cv::Mat gray_image; 1650 cv::cvtColor(src_image, gray_image, CV_BGR2GRAY); 1651 cv::Mat dst_image; 1652 cv::Canny(gray_image, dst_image, 50, 150, 3, true); 1653 1654 cv::Mat rgba_mat; 1655 cv::cvtColor(src_image, rgba_mat, CV_BGR2RGBA); 1656 bool ret = false; 1657 LiteMat lite_mat_gray; 1658 ret = 1659 InitFromPixel(rgba_mat.data, LPixelType::RGBA2GRAY, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_gray); 1660 ASSERT_TRUE(ret == true); 1661 1662 LiteMat lite_mat_dst; 1663 ret = Canny(lite_mat_gray, lite_mat_dst, 50, 150, 3, true); 1664 ASSERT_TRUE(ret == true); 1665 1666 int total_size = lite_mat_dst.height_ * lite_mat_dst.width_ * lite_mat_dst.channel_; 1667 double distance = 0.0f; 1668 for (int i = 0; i < total_size; i++) { 1669 distance += pow((uint8_t)dst_image.data[i] - ((uint8_t *)lite_mat_dst)[i], 2); 1670 } 1671 1672 distance = sqrt(distance / total_size); 1673 EXPECT_EQ(distance, 0.0f); 1674 } 1675 1676 TEST_F(MindDataImageProcess, TestCannyInvalidParams) { 1677 std::string filename = "data/dataset/apple.jpg"; 1678 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1679 1680 cv::Mat rgba_mat; 1681 cv::cvtColor(src_image, rgba_mat, CV_BGR2RGBA); 1682 1683 bool ret = false; 1684 LiteMat lite_mat_bgr; 1685 ret = 1686 InitFromPixel(rgba_mat.data, LPixelType::RGBA2BGR, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_bgr); 1687 ASSERT_TRUE(ret == true); 1688 1689 // channel is not 1 1690 LiteMat lite_mat_dst; 1691 ret = Canny(lite_mat_bgr, lite_mat_dst, 70, 210, 3); 1692 ASSERT_TRUE(ret == false); 1693 1694 LiteMat lite_mat_gray; 1695 ret = 1696 InitFromPixel(rgba_mat.data, LPixelType::RGBA2GRAY, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_gray); 1697 ASSERT_TRUE(ret == true); 1698 1699 // low_thresh less than 0 1700 ret = Canny(lite_mat_gray, lite_mat_dst, -5, 230, 3); 1701 ASSERT_TRUE(ret == false); 1702 1703 // high_thresh less than low_thresh 1704 ret = Canny(lite_mat_gray, lite_mat_dst, 250, 130, 3); 1705 ASSERT_TRUE(ret == false); 1706 1707 // even size 1708 ret = Canny(lite_mat_gray, lite_mat_dst, 60, 180, 4); 1709 ASSERT_TRUE(ret == false); 1710 1711 // size less than 3 or large than 7 1712 ret = Canny(lite_mat_gray, lite_mat_dst, 10, 190, 9); 1713 ASSERT_TRUE(ret == false); 1714 } 1715 1716 TEST_F(MindDataImageProcess, TestSobel) { 1717 std::string filename = "data/dataset/apple.jpg"; 1718 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1719 cv::Mat gray_image; 1720 cv::cvtColor(src_image, gray_image, CV_BGR2GRAY); 1721 1722 cv::Mat sobel_image_x; 1723 cv::Mat sobel_image_y; 1724 cv::Sobel(gray_image, sobel_image_x, CV_32F, 1, 0, 3, 1, 0, cv::BORDER_REPLICATE); 1725 cv::Sobel(gray_image, sobel_image_y, CV_32F, 0, 1, 3, 1, 0, cv::BORDER_REPLICATE); 1726 1727 cv::Mat sobel_cv_x, sobel_cv_y; 1728 sobel_image_x.convertTo(sobel_cv_x, CV_8UC1); 1729 sobel_image_y.convertTo(sobel_cv_y, CV_8UC1); 1730 1731 cv::Mat rgba_mat; 1732 cv::cvtColor(src_image, rgba_mat, CV_BGR2RGBA); 1733 bool ret = false; 1734 LiteMat lite_mat_gray; 1735 ret = 1736 InitFromPixel(rgba_mat.data, LPixelType::RGBA2GRAY, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_gray); 1737 ASSERT_TRUE(ret == true); 1738 LiteMat lite_mat_x; 1739 LiteMat lite_mat_y; 1740 Sobel(lite_mat_gray, lite_mat_x, 1, 0, 3, 1, PaddBorderType::PADD_BORDER_REPLICATE); 1741 Sobel(lite_mat_gray, lite_mat_y, 0, 1, 3, 1, PaddBorderType::PADD_BORDER_REPLICATE); 1742 ASSERT_TRUE(ret == true); 1743 1744 cv::Mat dst_imageX(lite_mat_x.height_, lite_mat_x.width_, CV_32FC1, lite_mat_x.data_ptr_); 1745 cv::Mat dst_imageY(lite_mat_y.height_, lite_mat_y.width_, CV_32FC1, lite_mat_y.data_ptr_); 1746 cv::Mat sobel_ms_x, sobel_ms_y; 1747 dst_imageX.convertTo(sobel_ms_x, CV_8UC1); 1748 dst_imageY.convertTo(sobel_ms_y, CV_8UC1); 1749 1750 size_t total_size = lite_mat_x.height_ * lite_mat_x.width_ * lite_mat_x.channel_; 1751 float distance_x = 0.0f, distance_y = 0.0f; 1752 for (int i = 0; i < total_size; i++) { 1753 distance_x += pow((uint8_t)sobel_cv_x.data[i] - (uint8_t)sobel_ms_x.data[i], 2); 1754 distance_y += pow((uint8_t)sobel_cv_y.data[i] - (uint8_t)sobel_ms_y.data[i], 2); 1755 } 1756 distance_x = sqrt(distance_x / total_size); 1757 distance_y = sqrt(distance_y / total_size); 1758 EXPECT_EQ(distance_x, 0.0f); 1759 EXPECT_EQ(distance_y, 0.0f); 1760 } 1761 1762 TEST_F(MindDataImageProcess, TestSobelFlag) { 1763 std::string filename = "data/dataset/apple.jpg"; 1764 cv::Mat src_image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1765 cv::Mat gray_image; 1766 cv::cvtColor(src_image, gray_image, CV_BGR2GRAY); 1767 1768 cv::Mat sobel_image_x; 1769 cv::Sobel(gray_image, sobel_image_x, CV_32F, 3, 1, 5, 1, 0, cv::BORDER_REPLICATE); 1770 1771 cv::Mat sobel_cv_x; 1772 sobel_image_x.convertTo(sobel_cv_x, CV_8UC1); 1773 1774 cv::Mat rgba_mat; 1775 cv::cvtColor(src_image, rgba_mat, CV_BGR2RGBA); 1776 bool ret = false; 1777 LiteMat lite_mat_gray; 1778 ret = 1779 InitFromPixel(rgba_mat.data, LPixelType::RGBA2GRAY, LDataType::UINT8, rgba_mat.cols, rgba_mat.rows, lite_mat_gray); 1780 ASSERT_TRUE(ret == true); 1781 LiteMat lite_mat_x; 1782 Sobel(lite_mat_gray, lite_mat_x, 3, 1, 5, 1, PaddBorderType::PADD_BORDER_REPLICATE); 1783 ASSERT_TRUE(ret == true); 1784 1785 cv::Mat dst_imageX(lite_mat_x.height_, lite_mat_x.width_, CV_32FC1, lite_mat_x.data_ptr_); 1786 cv::Mat sobel_ms_x; 1787 dst_imageX.convertTo(sobel_ms_x, CV_8UC1); 1788 1789 size_t total_size = lite_mat_x.height_ * lite_mat_x.width_ * lite_mat_x.channel_; 1790 float distance_x = 0.0f; 1791 for (int i = 0; i < total_size; i++) { 1792 distance_x += pow((uint8_t)sobel_cv_x.data[i] - (uint8_t)sobel_ms_x.data[i], 2); 1793 } 1794 distance_x = sqrt(distance_x / total_size); 1795 EXPECT_EQ(distance_x, 0.0f); 1796 } 1797 1798 TEST_F(MindDataImageProcess, testConvertRgbToBgr) { 1799 std::string filename = "data/dataset/apple.jpg"; 1800 cv::Mat image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1801 cv::Mat rgb_mat1; 1802 1803 cv::cvtColor(image, rgb_mat1, CV_BGR2RGB); 1804 1805 LiteMat lite_mat_rgb; 1806 lite_mat_rgb.Init(rgb_mat1.cols, rgb_mat1.rows, rgb_mat1.channels(), rgb_mat1.data, LDataType::UINT8); 1807 LiteMat lite_mat_bgr; 1808 bool ret = ConvertRgbToBgr(lite_mat_rgb, LDataType::UINT8, image.cols, image.rows, lite_mat_bgr); 1809 ASSERT_TRUE(ret == true); 1810 1811 cv::Mat dst_image(lite_mat_bgr.height_, lite_mat_bgr.width_, CV_8UC1, lite_mat_bgr.data_ptr_); 1812 cv::imwrite("./mindspore_image.jpg", dst_image); 1813 CompareMat(image, lite_mat_bgr); 1814 } 1815 1816 TEST_F(MindDataImageProcess, testConvertRgbToBgrFail) { 1817 std::string filename = "data/dataset/apple.jpg"; 1818 cv::Mat image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1819 cv::Mat rgb_mat1; 1820 1821 cv::cvtColor(image, rgb_mat1, CV_BGR2RGB); 1822 1823 // The width and height of the output image is different from the original image. 1824 LiteMat lite_mat_rgb; 1825 lite_mat_rgb.Init(rgb_mat1.cols, rgb_mat1.rows, rgb_mat1.channels(), rgb_mat1.data, LDataType::UINT8); 1826 LiteMat lite_mat_bgr; 1827 bool ret = ConvertRgbToBgr(lite_mat_rgb, LDataType::UINT8, 1000, 1000, lite_mat_bgr); 1828 ASSERT_TRUE(ret == false); 1829 1830 // The input lite_mat_rgb object is null. 1831 LiteMat lite_mat_rgb1; 1832 LiteMat lite_mat_bgr1; 1833 bool ret1 = ConvertRgbToBgr(lite_mat_rgb1, LDataType::UINT8, image.cols, image.rows, lite_mat_bgr1); 1834 ASSERT_TRUE(ret1 == false); 1835 } 1836 1837 TEST_F(MindDataImageProcess, testConvertRgbToGray) { 1838 std::string filename = "data/dataset/apple.jpg"; 1839 cv::Mat image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1840 cv::Mat rgb_mat; 1841 cv::Mat rgb_mat1; 1842 1843 cv::cvtColor(image, rgb_mat, CV_BGR2GRAY); 1844 cv::imwrite("./opencv_image.jpg", rgb_mat); 1845 1846 cv::cvtColor(image, rgb_mat1, CV_BGR2RGB); 1847 1848 LiteMat lite_mat_rgb; 1849 lite_mat_rgb.Init(rgb_mat1.cols, rgb_mat1.rows, rgb_mat1.channels(), rgb_mat1.data, LDataType::UINT8); 1850 LiteMat lite_mat_gray; 1851 bool ret = ConvertRgbToGray(lite_mat_rgb, LDataType::UINT8, image.cols, image.rows, lite_mat_gray); 1852 ASSERT_TRUE(ret == true); 1853 1854 cv::Mat dst_image(lite_mat_gray.height_, lite_mat_gray.width_, CV_8UC1, lite_mat_gray.data_ptr_); 1855 cv::imwrite("./mindspore_image.jpg", dst_image); 1856 CompareMat(rgb_mat, lite_mat_gray); 1857 } 1858 1859 TEST_F(MindDataImageProcess, testConvertRgbToGrayFail) { 1860 std::string filename = "data/dataset/apple.jpg"; 1861 cv::Mat image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1862 cv::Mat rgb_mat; 1863 cv::Mat rgb_mat1; 1864 1865 cv::cvtColor(image, rgb_mat, CV_BGR2GRAY); 1866 cv::imwrite("./opencv_image.jpg", rgb_mat); 1867 1868 cv::cvtColor(image, rgb_mat1, CV_BGR2RGB); 1869 1870 // The width and height of the output image is different from the original image. 1871 LiteMat lite_mat_rgb; 1872 lite_mat_rgb.Init(rgb_mat1.cols, rgb_mat1.rows, rgb_mat1.channels(), rgb_mat1.data, LDataType::UINT8); 1873 LiteMat lite_mat_gray; 1874 bool ret = ConvertRgbToGray(lite_mat_rgb, LDataType::UINT8, 1000, 1000, lite_mat_gray); 1875 ASSERT_TRUE(ret == false); 1876 1877 // The input lite_mat_rgb object is null. 1878 LiteMat lite_mat_rgb1; 1879 LiteMat lite_mat_gray1; 1880 bool ret1 = ConvertRgbToGray(lite_mat_rgb1, LDataType::UINT8, image.cols, image.rows, lite_mat_gray1); 1881 ASSERT_TRUE(ret1 == false); 1882 1883 // The channel of output image object is not 1. 1884 LiteMat lite_mat_rgb2; 1885 lite_mat_rgb2.Init(rgb_mat1.cols, rgb_mat1.rows, rgb_mat1.channels(), rgb_mat1.data, LDataType::UINT8); 1886 LiteMat lite_mat_gray2; 1887 lite_mat_gray2.Init(rgb_mat1.cols, rgb_mat1.rows, rgb_mat1.channels(), rgb_mat1.data, LDataType::UINT8); 1888 bool ret2 = ConvertRgbToGray(lite_mat_rgb2, LDataType::UINT8, image.cols, image.rows, lite_mat_gray2); 1889 ASSERT_TRUE(ret2 == false); 1890 } 1891 1892 TEST_F(MindDataImageProcess, testResizePreserveARWithFillerv) { 1893 std::string filename = "data/dataset/apple.jpg"; 1894 cv::Mat image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1895 1896 LiteMat lite_mat_rgb; 1897 lite_mat_rgb.Init(image.cols, image.rows, image.channels(), image.data, LDataType::UINT8); 1898 LiteMat lite_mat_resize; 1899 float ratioShiftWShiftH[3] = {0}; 1900 float invM[2][3] = {{0, 0, 0}, {0, 0, 0}}; 1901 int h = 1000; 1902 int w = 1000; 1903 bool ret = ResizePreserveARWithFiller(lite_mat_rgb, lite_mat_resize, h, w, &ratioShiftWShiftH, &invM, 0); 1904 ASSERT_TRUE(ret == true); 1905 cv::Mat dst_image(lite_mat_resize.height_, lite_mat_resize.width_, CV_32FC3, lite_mat_resize.data_ptr_); 1906 cv::imwrite("./mindspore_image.jpg", dst_image); 1907 } 1908 1909 TEST_F(MindDataImageProcess, testResizePreserveARWithFillervFail) { 1910 std::string filename = "data/dataset/apple.jpg"; 1911 cv::Mat image = cv::imread(filename, cv::ImreadModes::IMREAD_COLOR); 1912 1913 // The input lite_mat_rgb object is null. 1914 LiteMat lite_mat_rgb; 1915 LiteMat lite_mat_resize; 1916 float ratioShiftWShiftH[3] = {0}; 1917 float invM[2][3] = {{0, 0, 0}, {0, 0, 0}}; 1918 int h = 1000; 1919 int w = 1000; 1920 bool ret = ResizePreserveARWithFiller(lite_mat_rgb, lite_mat_resize, h, w, &ratioShiftWShiftH, &invM, 0); 1921 ASSERT_TRUE(ret == false); 1922 1923 // The channel of input lite_mat_rgb object is not 3. 1924 LiteMat lite_mat_rgb1; 1925 lite_mat_rgb1.Init(image.cols, image.rows, 1, image.data, LDataType::UINT8); 1926 LiteMat lite_mat_resize1; 1927 float ratioShiftWShiftH1[3] = {0}; 1928 float invM1[2][3] = {{0, 0, 0}, {0, 0, 0}}; 1929 int h1 = 1000; 1930 int w1 = 1000; 1931 bool ret1 = ResizePreserveARWithFiller(lite_mat_rgb1, lite_mat_resize1, h1, w1, &ratioShiftWShiftH1, &invM1, 0); 1932 ASSERT_TRUE(ret1 == false); 1933 1934 // The ratioShiftWShiftH2 and invM2 is null. 1935 LiteMat lite_mat_rgb2; 1936 lite_mat_rgb2.Init(image.cols, image.rows, image.channels(), image.data, LDataType::UINT8); 1937 LiteMat lite_mat_resize2; 1938 int h2 = 1000; 1939 int w2 = 1000; 1940 bool ret2 = ResizePreserveARWithFiller(lite_mat_rgb2, lite_mat_resize2, h2, w2, nullptr, nullptr, 0); 1941 ASSERT_TRUE(ret2 == false); 1942 1943 // The width and height of the output image is less than or equal to 0. 1944 LiteMat lite_mat_rgb3; 1945 lite_mat_rgb3.Init(image.cols, image.rows, image.channels(), image.data, LDataType::UINT8); 1946 LiteMat lite_mat_resize3; 1947 float ratioShiftWShiftH3[3] = {0}; 1948 float invM3[2][3] = {{0, 0, 0}, {0, 0, 0}}; 1949 int h3 = -1000; 1950 int w3 = 1000; 1951 bool ret3 = ResizePreserveARWithFiller(lite_mat_rgb3, lite_mat_resize3, h3, w3, &ratioShiftWShiftH3, &invM3, 0); 1952 ASSERT_TRUE(ret3 == false); 1953 } 1954
