vendor: OpenCV 5.0.0 snapshot at 755e50675d97db9b7d449d8bd6b09888646f6c6e

modules/cannops/test/test_core.cpp

@@ -0,0 +1,339 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+#include <vector>
+
+namespace opencv_test
+{
+namespace
+{
+TEST(CORE, MERGE)
+{
+    Mat m1 = (Mat_<uchar>(2, 2) << 1, 4, 7, 10);
+    Mat m2 = (Mat_<uchar>(2, 2) << 2, 5, 8, 11);
+    Mat m3 = (Mat_<uchar>(2, 2) << 3, 6, 9, 12);
+    Mat channels[3] = {m1, m2, m3};
+    Mat m;
+    cv::merge(channels, 3, m);
+
+    cv::cann::setDevice(0);
+
+    AscendMat a1, a2, a3;
+    a1.upload(m1);
+    a2.upload(m2);
+    a3.upload(m3);
+    AscendMat aclChannels[3] = {a1, a2, a3};
+    std::vector<AscendMat> aclChannelsVector;
+    aclChannelsVector.push_back(a1);
+    aclChannelsVector.push_back(a2);
+    aclChannelsVector.push_back(a3);
+
+    Mat checker1, checker2;
+    cv::cann::merge(aclChannels, 3, checker1);
+    cv::cann::merge(aclChannelsVector, checker2);
+
+    EXPECT_MAT_NEAR(m, checker1, 0.0);
+    EXPECT_MAT_NEAR(m, checker2, 0.0);
+
+    cv::cann::resetDevice();
+}
+
+TEST(CORE, SPLIT)
+{
+    char d[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+    Mat m(2, 2, CV_8UC3, d);
+    Mat channels[3];
+    cv::split(m, channels);
+
+    cv::cann::setDevice(0);
+
+    AscendMat aclChannels[3];
+    std::vector<AscendMat> aclChannelsVector;
+
+    cv::cann::split(m, aclChannels);
+    cv::cann::split(m, aclChannelsVector);
+
+    Mat checker1[3], checker2[3];
+    aclChannels[0].download(checker1[0]);
+    aclChannels[1].download(checker1[1]);
+    aclChannels[2].download(checker1[2]);
+
+    aclChannelsVector[0].download(checker2[0]);
+    aclChannelsVector[1].download(checker2[1]);
+    aclChannelsVector[2].download(checker2[2]);
+
+    EXPECT_MAT_NEAR(channels[0], checker1[0], 0.0);
+    EXPECT_MAT_NEAR(channels[1], checker1[1], 0.0);
+    EXPECT_MAT_NEAR(channels[2], checker1[2], 0.0);
+
+    EXPECT_MAT_NEAR(channels[0], checker2[0], 0.0);
+    EXPECT_MAT_NEAR(channels[1], checker2[1], 0.0);
+    EXPECT_MAT_NEAR(channels[2], checker2[2], 0.0);
+
+    AscendMat npuM;
+    npuM.upload(m);
+    cv::cann::split(npuM, aclChannels);
+    cv::cann::split(npuM, aclChannelsVector);
+
+    aclChannels[0].download(checker1[0]);
+    aclChannels[1].download(checker1[1]);
+    aclChannels[2].download(checker1[2]);
+
+    aclChannelsVector[0].download(checker2[0]);
+    aclChannelsVector[1].download(checker2[1]);
+    aclChannelsVector[2].download(checker2[2]);
+
+    EXPECT_MAT_NEAR(channels[0], checker1[0], 0.0);
+    EXPECT_MAT_NEAR(channels[1], checker1[1], 0.0);
+    EXPECT_MAT_NEAR(channels[2], checker1[2], 0.0);
+
+    EXPECT_MAT_NEAR(channels[0], checker2[0], 0.0);
+    EXPECT_MAT_NEAR(channels[1], checker2[1], 0.0);
+    EXPECT_MAT_NEAR(channels[2], checker2[2], 0.0);
+    cv::cann::resetDevice();
+}
+
+TEST(CORE, TRANSPOSE)
+{
+    Mat cpuMat = randomMat(10, 10, CV_32SC3), cpuRetMat, checker;
+    cv::transpose(cpuMat, cpuRetMat);
+    cv::cann::transpose(cpuMat, checker);
+    EXPECT_MAT_NEAR(cpuRetMat, checker, 0.0);
+
+    AscendMat npuMat, npuChecker;
+    npuMat.upload(cpuMat);
+    cv::cann::transpose(npuMat, npuChecker);
+    npuChecker.download(checker);
+    EXPECT_MAT_NEAR(cpuRetMat, checker, 0.0);
+}
+
+TEST(CORE, FLIP)
+{
+    Mat cpuMat = randomMat(10, 10, CV_32SC3), cpuRetMat, checker;
+
+    int flipMode;
+
+    for (flipMode = -1; flipMode < 2; flipMode++)
+    {
+        cv::flip(cpuMat, cpuRetMat, flipMode);
+        cv::cann::flip(cpuMat, checker, flipMode);
+        EXPECT_MAT_NEAR(cpuRetMat, checker, 0.0);
+    }
+
+    AscendMat npuMat, npuChecker;
+    npuMat.upload(cpuMat);
+    for (flipMode = -1; flipMode < 2; flipMode++)
+    {
+        cv::flip(cpuMat, cpuRetMat, flipMode);
+        cv::cann::flip(npuMat, npuChecker, flipMode);
+        npuChecker.download(checker);
+        EXPECT_MAT_NEAR(cpuRetMat, checker, 0.0);
+    }
+}
+
+TEST(CORE, ROTATE)
+{
+    Mat cpuRetMat, checker, cpuMat = randomMat(3, 5, CV_16S, 0.0, 255.0);
+
+    int rotateMode;
+    for (rotateMode = 0; rotateMode < 3; rotateMode++)
+    {
+        cv::rotate(cpuMat, cpuRetMat, rotateMode);
+        cv::cann::rotate(cpuMat, checker, rotateMode);
+        EXPECT_MAT_NEAR(cpuRetMat, checker, 0.0);
+    }
+
+    AscendMat npuMat, npuChecker;
+    npuMat.upload(cpuMat);
+    for (rotateMode = 0; rotateMode < 3; rotateMode++)
+    {
+        cv::rotate(cpuMat, cpuRetMat, rotateMode);
+        cv::cann::rotate(npuMat, npuChecker, rotateMode);
+        npuChecker.download(checker);
+        EXPECT_MAT_NEAR(cpuRetMat, checker, 0.0);
+    }
+}
+
+TEST(CORE, CROP)
+{
+    Mat cpuOpRet, checker, cpuMat = randomMat(6, 6, CV_32SC3, 0.0, 255.0);
+    Rect b(1, 2, 4, 4);
+    Mat cropped_cv(cpuMat, b);
+    AscendMat cropped_cann(cpuMat, b);
+    cropped_cann.download(checker);
+    EXPECT_MAT_NEAR(cropped_cv, checker, 1e-10);
+}
+
+TEST(CORE, CROP_OVERLOAD)
+{
+    Mat cpuOpRet, checker, cpuMat = randomMat(6, 6, CV_16SC3, 0.0, 255.0);
+    const Rect b(1, 2, 4, 4);
+    Mat cropped_cv = cpuMat(b);
+    AscendMat cropped_cann = cv::cann::crop(cpuMat, b);
+    cropped_cann.download(checker);
+    EXPECT_MAT_NEAR(cropped_cv, checker, 1e-10);
+
+    AscendMat npuMat;
+    npuMat.upload(cpuMat);
+    cropped_cann = cv::cann::crop(npuMat, b);
+    cropped_cann.download(checker);
+    EXPECT_MAT_NEAR(cropped_cv, checker, 1e-10);
+}
+
+TEST(CORE, RESIZE)
+{
+    Mat resized_cv, checker, cpuMat = randomMat(10, 10, CV_32F, 100.0, 255.0);
+    Size dsize = Size(6, 6);
+    // only support {2 INTER_CUBIC} and {3 INTER_AREA}
+    // only the resize result of INTER_AREA is close to CV's.
+    int flags = 3;
+    cv::cann::setDevice(0);
+    cv::resize(cpuMat, resized_cv, dsize, 0, 0, flags);
+    cv::cann::resize(cpuMat, checker, dsize, 0, 0, flags);
+    EXPECT_MAT_NEAR(resized_cv, checker, 1e-4);
+
+    cv::resize(cpuMat, resized_cv, Size(), 0.5, 0.5, flags);
+    cv::cann::resize(cpuMat, checker, Size(), 0.5, 0.5, flags);
+    EXPECT_MAT_NEAR(resized_cv, checker, 1e-4);
+
+    AscendMat npuMat, npuChecker;
+    npuMat.upload(cpuMat);
+    cv::resize(cpuMat, resized_cv, dsize, 0, 0, flags);
+    cv::cann::resize(npuMat, npuChecker, dsize, 0, 0, flags);
+    npuChecker.download(checker);
+    EXPECT_MAT_NEAR(resized_cv, checker, 1e-4);
+
+    cv::resize(cpuMat, resized_cv, Size(), 0.5, 0.5, flags);
+    cv::cann::resize(npuMat, npuChecker, Size(), 0.5, 0.5, flags);
+    npuChecker.download(checker);
+    EXPECT_MAT_NEAR(resized_cv, checker, 1e-4);
+    cv::cann::resetDevice();
+}
+
+TEST(CORE, RESIZE_NEW)
+{
+    Mat resized_cv, checker;
+    Mat cpuMat = randomMat(1280, 1706, CV_8UC3, 100.0, 255.0);
+    Size dsize = Size(768, 832);
+    // add support for {0 INTER_NEAREST} and {1 INTER_LINEAR}
+    // only the resize result of INTER_LINEAR is close to CV's.
+    int interpolation = 1;
+    cv::resize(cpuMat, resized_cv, dsize, 0, 0, interpolation);
+    cv::cann::resize(cpuMat, checker, dsize, 0, 0, interpolation);
+    EXPECT_MAT_NEAR(resized_cv, checker, 1);
+
+    cv::resize(cpuMat, resized_cv, Size(), 0.5, 0.5, interpolation);
+    cv::cann::resize(cpuMat, checker, Size(), 0.5, 0.5, interpolation);
+    EXPECT_MAT_NEAR(resized_cv, checker, 1);
+
+    AscendMat npuMat, npuChecker;
+    npuMat.upload(cpuMat);
+    cv::resize(cpuMat, resized_cv, dsize, 0, 0, interpolation);
+    cv::cann::resize(npuMat, npuChecker, dsize, 0, 0, interpolation);
+    npuChecker.download(checker);
+    EXPECT_MAT_NEAR(resized_cv, checker, 1);
+
+    cv::resize(cpuMat, resized_cv, Size(), 0.5, 0.5, interpolation);
+    cv::cann::resize(npuMat, npuChecker, Size(), 0.5, 0.5, interpolation);
+    npuChecker.download(checker);
+    EXPECT_MAT_NEAR(resized_cv, checker, 1);
+}
+
+TEST(CORE, CROP_RESIZE)
+{
+    Mat cpuMat = randomMat(1280, 1706, CV_8UC1, 100.0, 255.0);
+    Mat resized_cv, checker, cpuOpRet;
+    Size dsize = Size(496, 512);
+    const Rect b(300, 500, 224, 256);
+
+    cv::cann::cropResize(cpuMat, checker, b, dsize, 0, 0, 1);
+    Mat cropped_cv(cpuMat, b);
+    cv::resize(cropped_cv, cpuOpRet, dsize, 0, 0, 1);
+    EXPECT_MAT_NEAR(checker, cpuOpRet, 1);
+
+    AscendMat npuMat, npuChecker;
+    npuMat.upload(cpuMat);
+    cv::cann::cropResize(npuMat, npuChecker, b, dsize, 0, 0, 1);
+    npuChecker.download(checker);
+    EXPECT_MAT_NEAR(cpuOpRet, checker, 1);
+}
+TEST(CORE, CROP_RESIZE_MAKE_BORDER)
+{
+    Mat cpuMat = randomMat(1024, 896, CV_8UC1, 100.0, 255.0);
+
+    Mat resized_cv, checker, cpuOpRet;
+    Size dsize = Size(320, 256);
+    const Rect b(300, 500, 496, 512);
+    RNG rng(12345);
+    float scalarV[3] = {0, 0, 255};
+    int top, bottom, left, right;
+    top = 54;
+    bottom = 0;
+    left = 32;
+    right = 0;
+    int interpolation = 1;
+
+    Scalar value = {scalarV[0], scalarV[1], scalarV[2], 0};
+    for (int borderType = 0; borderType < 2; borderType++)
+    {
+        cv::cann::cropResizeMakeBorder(cpuMat, checker, b, dsize, 0, 0, interpolation, top, left,
+                                       borderType, value);
+        Mat cropped_cv(cpuMat, b);
+        cv::resize(cropped_cv, resized_cv, dsize, 0, 0, interpolation);
+        cv::copyMakeBorder(resized_cv, cpuOpRet, top, bottom, left, right, borderType, value);
+        EXPECT_MAT_NEAR(checker, cpuOpRet, 1e-10);
+    }
+    AscendMat npuMat, npuChecker;
+    npuMat.upload(cpuMat);
+    for (int borderType = 0; borderType < 2; borderType++)
+    {
+        cv::cann::cropResizeMakeBorder(npuMat, npuChecker, b, dsize, 0, 0, interpolation, top, left,
+                                       borderType, value);
+        npuChecker.download(checker);
+        Mat cropped_cv(cpuMat, b);
+        cv::resize(cropped_cv, resized_cv, dsize, 0, 0, interpolation);
+        cv::copyMakeBorder(resized_cv, cpuOpRet, top, bottom, left, right, borderType, value);
+        EXPECT_MAT_NEAR(checker, cpuOpRet, 1e-10);
+    }
+}
+
+TEST(CORE, COPY_MAKE_BORDER)
+{
+    Mat cpuMat = randomMat(1280, 1706, CV_8UC3, 100, 255);
+
+    Mat cpuOpRet, checker;
+    RNG rng(12345);
+    Scalar value = {static_cast<double>(rng.uniform(0, 255)),
+                    static_cast<double>(rng.uniform(0, 255)),
+                    static_cast<double>(rng.uniform(0, 255))};
+    int top, bottom, left, right;
+    top = 20;
+    bottom = 30;
+    left = 30;
+    right = 20;
+
+    int borderType = 0;
+    for (borderType = 0; borderType < 2; borderType++)
+    {
+        cv::cann::copyMakeBorder(cpuMat, checker, top, bottom, left, right, borderType, value);
+
+        cv::copyMakeBorder(cpuMat, cpuOpRet, top, bottom, left, right, borderType, value);
+        EXPECT_MAT_NEAR(checker, cpuOpRet, 1e-10);
+    }
+
+    AscendMat npuMat, npuChecker;
+    npuMat.upload(cpuMat);
+    for (borderType = 0; borderType < 2; borderType++)
+    {
+        cv::cann::copyMakeBorder(npuMat, npuChecker, top, bottom, left, right, borderType, value);
+        npuChecker.download(checker);
+
+        cv::copyMakeBorder(cpuMat, cpuOpRet, top, bottom, left, right, borderType, value);
+        EXPECT_MAT_NEAR(checker, cpuOpRet, 1e-10);
+    }
+}
+
+} // namespace
+} // namespace opencv_test

modules/cannops/test/test_cvtcolor.cpp

@@ -0,0 +1,89 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+namespace opencv_test
+{
+namespace
+{
+
+void cvtColorTest(int code, int cn, int dcn = 3, float diff = 0.0f)
+{
+    cv::cann::setDevice(DEVICE_ID);
+    Mat cpuRet, npuRet;
+
+    Mat img8U = randomMat(512, 512, CV_MAKETYPE(CV_8U, cn), 0.0f, 255.0f);
+    Mat img16U = randomMat(512, 512, CV_MAKETYPE(CV_16U, cn), 0.0f, 65535.0f);
+    Mat img32F = randomMat(512, 512, CV_MAKETYPE(CV_32F, cn), 0.0f, 65535.0f);
+
+    cv::cvtColor(img8U, cpuRet, code, dcn);
+    cv::cann::cvtColor(img8U, npuRet, code, dcn);
+    EXPECT_MAT_NEAR(cpuRet, npuRet, diff);
+
+    cv::cvtColor(img16U, cpuRet, code, dcn);
+    cv::cann::cvtColor(img16U, npuRet, code, dcn);
+    EXPECT_MAT_NEAR(cpuRet, npuRet, diff);
+
+    cv::cvtColor(img32F, cpuRet, code, dcn);
+    cv::cann::cvtColor(img32F, npuRet, code, dcn);
+    EXPECT_MAT_NEAR(cpuRet, npuRet, diff);
+    cv::cann::resetDevice();
+}
+
+TEST(CVT_COLOR, BGR2BGRA) { cvtColorTest(COLOR_BGR2BGRA, 3, 4); }
+TEST(CVT_COLOR, BGRA2BGR) { cvtColorTest(COLOR_BGRA2BGR, 4); }
+TEST(CVT_COLOR, BGR2RGBA) { cvtColorTest(COLOR_BGR2RGBA, 3, 4); }
+TEST(CVT_COLOR, RGBA2BGR) { cvtColorTest(COLOR_RGBA2BGR, 4); }
+TEST(CVT_COLOR, BGR2RGB) { cvtColorTest(COLOR_BGR2RGB, 3); }
+TEST(CVT_COLOR, BGRA2RGBA) { cvtColorTest(COLOR_BGRA2RGBA, 4, 4); }
+
+// Due to parameter accuracy issues, the calculation results have certain accuracy differences.
+TEST(CVT_COLOR, BGR2GRAY) { cvtColorTest(COLOR_BGR2GRAY, 3, 1, 10.0f); }
+TEST(CVT_COLOR, RGB2GRAY) { cvtColorTest(COLOR_BGR2GRAY, 3, 1, 10.0f); }
+TEST(CVT_COLOR, GRAY2BGR) { cvtColorTest(COLOR_GRAY2BGR, 1); }
+TEST(CVT_COLOR, GRAY2BGRA) { cvtColorTest(COLOR_GRAY2BGRA, 1, 4); }
+TEST(CVT_COLOR, BGRA2GRAY) { cvtColorTest(COLOR_BGRA2GRAY, 4, 1, 10.0f); }
+TEST(CVT_COLOR, RGBA2GRAY) { cvtColorTest(COLOR_RGBA2GRAY, 4, 1, 10.0f); }
+
+TEST(CVT_COLOR, RGB2XYZ) { cvtColorTest(COLOR_RGB2XYZ, 3, 3, 50.0f); }
+TEST(CVT_COLOR, BGR2XYZ) { cvtColorTest(COLOR_BGR2XYZ, 3, 3, 50.0f); }
+TEST(CVT_COLOR, XYZ2BGR) { cvtColorTest(COLOR_XYZ2BGR, 3, 3, 150.0f); }
+TEST(CVT_COLOR, XYZ2RGB) { cvtColorTest(COLOR_XYZ2RGB, 3, 3, 150.0f); }
+TEST(CVT_COLOR, XYZ2BGR_DC4) { cvtColorTest(COLOR_XYZ2BGR, 3, 4, 150.0f); }
+TEST(CVT_COLOR, XYZ2RGB_DC4) { cvtColorTest(COLOR_XYZ2RGB, 3, 4, 150.0f); }
+
+TEST(CVT_COLOR, BGR2YCrCb) { cvtColorTest(COLOR_BGR2YCrCb, 3, 3, 10.0f); }
+TEST(CVT_COLOR, RGB2YCrCb) { cvtColorTest(COLOR_RGB2YCrCb, 3, 3, 10.0f); }
+TEST(CVT_COLOR, YCrCb2BGR) { cvtColorTest(COLOR_YCrCb2BGR, 3, 3, 10.0f); }
+TEST(CVT_COLOR, YCrCb2RGB) { cvtColorTest(COLOR_YCrCb2RGB, 3, 3, 10.0f); }
+TEST(CVT_COLOR, YCrCb2BGR_DC4) { cvtColorTest(COLOR_YCrCb2BGR, 3, 4, 10.0f); }
+TEST(CVT_COLOR, YCrCb2RGB_DC4) { cvtColorTest(COLOR_YCrCb2RGB, 3, 4, 10.0f); }
+
+TEST(CVT_COLOR, BGR2YUV) { cvtColorTest(COLOR_BGR2YUV, 3, 3, 10.0f); }
+TEST(CVT_COLOR, RGB2YUV) { cvtColorTest(COLOR_RGB2YUV, 3, 3, 10.0f); }
+TEST(CVT_COLOR, YUV2BGR) { cvtColorTest(COLOR_YUV2BGR, 3, 3, 10.0f); }
+TEST(CVT_COLOR, YUV2RGB) { cvtColorTest(COLOR_YUV2RGB, 3, 3, 10.0f); }
+TEST(CVT_COLOR, YUV2BGR_DC4) { cvtColorTest(COLOR_YUV2BGR, 3, 4, 10.0f); }
+TEST(CVT_COLOR, YUV2RGB_DC4) { cvtColorTest(COLOR_YUV2RGB, 3, 4, 10.0f); }
+
+// Test of AscendMat. Since the logic is the same, only interface test is needed.
+TEST(CVT_COLOR, COLOR_BGR2BGRA_ASCENDMAT)
+{
+    cv::cann::setDevice(DEVICE_ID);
+    Mat cpuRet, npuRet;
+
+    Mat img8U = randomMat(512, 512, CV_8UC3, 0.0f, 255.0f);
+    cv::cvtColor(img8U, cpuRet, COLOR_BGR2BGRA, 4);
+
+    AscendMat npuImg8U, npuChecker;
+    npuImg8U.upload(img8U);
+    cv::cann::cvtColor(npuImg8U, npuChecker, COLOR_BGR2BGRA, 4);
+    npuChecker.download(npuRet);
+    EXPECT_MAT_NEAR(cpuRet, npuRet, 10.0f);
+    cv::cann::resetDevice();
+}
+
+} // namespace
+} // namespace opencv_test

modules/cannops/test/test_element_operations.cpp

@@ -0,0 +1,728 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+#include <iostream>
+
+namespace opencv_test
+{
+namespace
+{
+template <typename FCV, typename FCANN, typename... PARAMS>
+void testMatOpMat(FCV cvFunc, FCANN cannFunc, PARAMS... param)
+{
+    cv::cann::setDevice(DEVICE_ID);
+    Mat mat1 = randomMat(10, 10, CV_32SC3);
+    Mat mat2 = randomMat(10, 10, CV_32SC3);
+    Mat cpuDst, check;
+
+    cvFunc(mat1, mat2, cpuDst, param...);
+    cannFunc(mat1, mat2, check, param..., AscendStream::Null());
+    EXPECT_MAT_NEAR(cpuDst, check, 1.0);
+
+    AscendStream stream;
+    cannFunc(mat1, mat2, check, param..., stream);
+    stream.waitForCompletion();
+    EXPECT_MAT_NEAR(cpuDst, check, 1.0);
+
+    cv::cann::resetDevice();
+}
+
+template <typename FCV, typename FCANN, typename DTMASK, typename... PARAMS>
+void testAscendMatOpAscendMatMask(FCV cvFunc, FCANN cannFunc, DTMASK mask = AscendMat(),
+                                  PARAMS... param)
+{
+    cv::cann::setDevice(DEVICE_ID);
+    Mat mat1 = randomMat(10, 10, CV_32SC3);
+    Mat mat2 = randomMat(10, 10, CV_32SC3);
+    Mat cpuDst, check, cpuMask;
+    AscendMat npuMat1, npuMat2, npuCheck;
+    npuMat1.upload(mat1);
+    npuMat2.upload(mat2);
+    if (mask.empty())
+    {
+        cvFunc(mat1, mat2, cpuDst, noArray(), param...);
+    }
+    else
+    {
+        mask.download(cpuMask);
+        cvFunc(mat1, mat2, cpuDst, cpuMask, param...);
+    }
+
+    cannFunc(npuMat1, npuMat2, npuCheck, mask, param..., AscendStream::Null());
+    npuCheck.download(check);
+    EXPECT_MAT_NEAR(cpuDst, check, 1.0);
+
+    AscendStream stream;
+    cannFunc(npuMat1, npuMat2, npuCheck, mask, param..., stream);
+    npuCheck.download(check);
+    stream.waitForCompletion();
+    EXPECT_MAT_NEAR(cpuDst, check, 1.0);
+
+    cv::cann::resetDevice();
+}
+
+template <typename FCV, typename FCANN, typename... PARAMS>
+void testAscendMatOpAscendMat(FCV cvFunc, FCANN cannFunc, PARAMS... param)
+{
+    cv::cann::setDevice(DEVICE_ID);
+    Mat mat1 = randomMat(10, 10, CV_32SC3);
+    Mat mat2 = randomMat(10, 10, CV_32SC3);
+    Mat cpuDst, check;
+    AscendMat npuMat1, npuMat2, npuCheck;
+    npuMat1.upload(mat1);
+    npuMat2.upload(mat2);
+    cvFunc(mat1, mat2, cpuDst, param...);
+    cannFunc(npuMat1, npuMat2, npuCheck, param..., AscendStream::Null());
+    npuCheck.download(check);
+    EXPECT_MAT_NEAR(cpuDst, check, 1.0);
+
+    AscendStream stream;
+    cannFunc(npuMat1, npuMat2, npuCheck, param..., stream);
+    npuCheck.download(check);
+    stream.waitForCompletion();
+    EXPECT_MAT_NEAR(cpuDst, check, 1.0);
+
+    cv::cann::resetDevice();
+}
+
+TEST(ELEMENTWISE_OP, MAT_ADD_MAT)
+{
+    testMatOpMat(
+        cv::add,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           int dtype, AscendStream& stream)
+        { cv::cann::add(src1, src2, dst, mask, dtype, stream); },
+        noArray(), -1);
+    testAscendMatOpAscendMatMask(
+        cv::add,
+        [](const AscendMat& src1, const AscendMat& src2, AscendMat& dst, const AscendMat& mask,
+           int dtype, AscendStream& stream)
+        { cv::cann::add(src1, src2, dst, mask, dtype, stream); },
+        AscendMat(), -1);
+}
+
+TEST(ELEMENTWISE_OP, MAT_SUB_MAT)
+{
+    testMatOpMat(
+        cv::subtract,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           int dtype, AscendStream& stream)
+        { cv::cann::subtract(src1, src2, dst, mask, dtype, stream); },
+        noArray(), -1);
+    testAscendMatOpAscendMatMask(
+        cv::subtract,
+        [](const AscendMat& src1, const AscendMat& src2, AscendMat& dst, const AscendMat& mask,
+           int dtype, AscendStream& stream)
+        { cv::cann::subtract(src1, src2, dst, mask, dtype, stream); },
+        AscendMat(), -1);
+}
+
+TEST(ELEMENTWISE_OP, MAT_MUL_MAT)
+{
+    testMatOpMat(
+        cv::multiply,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, float scale, int dtype,
+           AscendStream& stream) { cv::cann::multiply(src1, src2, dst, scale, dtype, stream); },
+        1, -1);
+    testAscendMatOpAscendMat(
+        cv::multiply,
+        [](const AscendMat& src1, const AscendMat& src2, AscendMat& dst, float scale, int dtype,
+           AscendStream& stream) { cv::cann::multiply(src1, src2, dst, scale, dtype, stream); },
+        1, -1);
+}
+
+TEST(ELEMENTWISE_OP, MAT_DIV_MAT)
+{
+    testMatOpMat([](const cv::Mat& src1, const cv::Mat& src2, cv::Mat& dst, double scale, int dtype)
+                 { cv::divide(src1, src2, dst, scale, dtype); },
+                 [](const InputArray src1, const InputArray src2, OutputArray dst, float scale,
+                    int dtype, AscendStream& stream)
+                 { cv::cann::divide(src1, src2, dst, scale, dtype, stream); },
+                 1, -1);
+    testAscendMatOpAscendMat(
+        [](const cv::Mat& src1, const cv::Mat& src2, cv::Mat& dst, double scale, int dtype)
+        { cv::divide(src1, src2, dst, scale, dtype); },
+        [](const AscendMat& src1, const AscendMat& src2, AscendMat& dst, float scale, int dtype,
+           AscendStream& stream) { cv::cann::divide(src1, src2, dst, scale, dtype, stream); },
+        1, -1);
+}
+
+TEST(ELEMENTWISE_OP, MAT_BITWISE_AND_MAT)
+{
+    testMatOpMat(
+        cv::bitwise_and,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           AscendStream& stream) { cv::cann::bitwise_and(src1, src2, dst, mask, stream); },
+        noArray());
+    testAscendMatOpAscendMatMask(
+        cv::bitwise_and,
+        [](const AscendMat& src1, const AscendMat& src2, AscendMat& dst, const AscendMat& mask,
+           AscendStream& stream) { cv::cann::bitwise_and(src1, src2, dst, mask, stream); },
+        AscendMat());
+}
+
+TEST(ELEMENTWISE_OP, MAT_BITWISE_OR_MAT)
+{
+    testMatOpMat(
+        cv::bitwise_or,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           AscendStream& stream) { cv::cann::bitwise_or(src1, src2, dst, mask, stream); },
+        noArray());
+    testAscendMatOpAscendMatMask(
+        cv::bitwise_or,
+        [](const AscendMat& src1, const AscendMat& src2, AscendMat& dst, const AscendMat& mask,
+           AscendStream& stream) { cv::cann::bitwise_or(src1, src2, dst, mask, stream); },
+        AscendMat());
+}
+
+TEST(ELEMENTWISE_OP, MAT_BITWISE_XOR_MAT)
+{
+    testMatOpMat(
+        cv::bitwise_xor,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           AscendStream& stream) { cv::cann::bitwise_xor(src1, src2, dst, mask, stream); },
+        noArray());
+    testAscendMatOpAscendMatMask(
+        cv::bitwise_xor,
+        [](const AscendMat& src1, const AscendMat& src2, AscendMat& dst, const AscendMat& mask,
+           AscendStream& stream) { cv::cann::bitwise_xor(src1, src2, dst, mask, stream); },
+        AscendMat());
+}
+
+TEST(ELEMENTWISE_OP, MAT_ADD_MAT_WITH_MASK_AND_DTYPE)
+{
+    testMatOpMat(
+        cv::add,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           int dtype, AscendStream& stream)
+        { cv::cann::add(src1, src2, dst, mask, dtype, stream); },
+        genMask(), CV_32SC3);
+    testAscendMatOpAscendMatMask(
+        cv::add,
+        [](const AscendMat& src1, const AscendMat& src2, AscendMat& dst, const AscendMat& mask,
+           int dtype, AscendStream& stream)
+        { cv::cann::add(src1, src2, dst, mask, dtype, stream); },
+        AscendMat(), CV_32SC3);
+}
+
+TEST(ELEMENTWISE_OP, MAT_SUB_MAT_WITH_MASK_AND_DTYPE)
+{
+    testMatOpMat(
+        cv::subtract,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           int dtype, AscendStream& stream)
+        { cv::cann::subtract(src1, src2, dst, mask, dtype, stream); },
+        genMask(), CV_32SC3);
+    testAscendMatOpAscendMatMask(
+        cv::subtract,
+        [](const AscendMat& src1, const AscendMat& src2, AscendMat& dst, const AscendMat& mask,
+           int dtype, AscendStream& stream)
+        { cv::cann::subtract(src1, src2, dst, mask, dtype, stream); },
+        AscendMat(), CV_32SC3);
+}
+
+TEST(ELEMENTWISE_OP, MAT_BITWISE_AND_MAT_WITH_MASK)
+{
+    testMatOpMat(
+        cv::bitwise_and,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           AscendStream& stream) { cv::cann::bitwise_and(src1, src2, dst, mask, stream); },
+        genMask());
+    testAscendMatOpAscendMatMask(
+        cv::bitwise_and,
+        [](const AscendMat& src1, const AscendMat& src2, AscendMat& dst, const AscendMat& mask,
+           AscendStream& stream) { cv::cann::bitwise_and(src1, src2, dst, mask, stream); },
+        genNpuMask());
+}
+
+TEST(ELEMENTWISE_OP, MAT_BITWISE_OR_MAT_WITH_MASK)
+{
+    testMatOpMat(
+        cv::bitwise_or,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           AscendStream& stream) { cv::cann::bitwise_or(src1, src2, dst, mask, stream); },
+        genMask());
+    testAscendMatOpAscendMatMask(
+        cv::bitwise_or,
+        [](const AscendMat& src1, const AscendMat& src2, AscendMat& dst, const AscendMat& mask,
+           AscendStream& stream) { cv::cann::bitwise_or(src1, src2, dst, mask, stream); },
+        genNpuMask());
+}
+
+TEST(ELEMENTWISE_OP, MAT_BITWISE_XOR_MAT_WITH_MASK)
+{
+    testMatOpMat(
+        cv::bitwise_xor,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           AscendStream& stream) { cv::cann::bitwise_xor(src1, src2, dst, mask, stream); },
+        genMask());
+    testAscendMatOpAscendMatMask(
+        cv::bitwise_xor,
+        [](const AscendMat& src1, const AscendMat& src2, AscendMat& dst, const AscendMat& mask,
+           AscendStream& stream) { cv::cann::bitwise_xor(src1, src2, dst, mask, stream); },
+        genNpuMask());
+}
+
+float randomScale = randomNum();
+TEST(ELEMENTWISE_OP, MAT_MUL_MAT_WITH_SCALE)
+{
+    testMatOpMat(
+        cv::multiply,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, float scale, int dtype,
+           AscendStream& stream) { cv::cann::multiply(src1, src2, dst, scale, dtype, stream); },
+        randomScale, -1);
+    testAscendMatOpAscendMat(
+        cv::multiply,
+        [](const AscendMat& src1, const AscendMat& src2, AscendMat& dst, float scale, int dtype,
+           AscendStream& stream) { cv::cann::multiply(src1, src2, dst, scale, dtype, stream); },
+        randomScale, -1);
+}
+
+TEST(ELEMENTWISE_OP, MAT_DIV_MAT_WITH_SCALE)
+{
+    testMatOpMat([](const cv::Mat& src1, const cv::Mat& src2, cv::Mat& dst, double scale, int dtype)
+                 { cv::divide(src1, src2, dst, scale, dtype); },
+                 [](const InputArray src1, const InputArray src2, OutputArray dst, float scale,
+                    int dtype, AscendStream& stream)
+                 { cv::cann::divide(src1, src2, dst, scale, dtype, stream); },
+                 randomScale, -1);
+    testAscendMatOpAscendMat(
+        [](const cv::Mat& src1, const cv::Mat& src2, cv::Mat& dst, double scale, int dtype)
+        { cv::divide(src1, src2, dst, scale, dtype); },
+        [](const AscendMat& src1, const AscendMat& src2, AscendMat& dst, float scale, int dtype,
+           AscendStream& stream) { cv::cann::divide(src1, src2, dst, scale, dtype, stream); },
+        randomScale, -1);
+}
+
+template <typename FCV, typename FCANN, typename... PARAMS>
+void testMatOpScalar(FCV cvFunc, FCANN cannFunc, PARAMS... param)
+{
+    Scalar scalar = randomScalar();
+    Mat mat(10, 10, CV_32SC3, randomScalar());
+    Mat cpuDst1, cpuDst2, checker1, checker2;
+
+    cvFunc(Mat(10, 10, CV_32SC3, scalar), mat, cpuDst1, param...);
+    cvFunc(mat, Mat(10, 10, CV_32SC3, scalar), cpuDst2, param...);
+    cv::cann::setDevice(DEVICE_ID);
+
+    cannFunc(scalar, mat, checker1, param..., AscendStream::Null());
+    cannFunc(mat, scalar, checker2, param..., AscendStream::Null());
+
+    EXPECT_MAT_NEAR(cpuDst1, checker1, 1.0);
+    EXPECT_MAT_NEAR(cpuDst2, checker2, 1.0);
+
+    AscendStream stream;
+    cannFunc(scalar, mat, checker1, param..., stream);
+    cannFunc(mat, scalar, checker2, param..., stream);
+    stream.waitForCompletion();
+    EXPECT_MAT_NEAR(cpuDst1, checker1, 1.0);
+    EXPECT_MAT_NEAR(cpuDst2, checker2, 1.0);
+
+    cv::cann::resetDevice();
+}
+
+template <typename FCV, typename FCANN, typename DTMASK, typename... PARAMS>
+void testAscendMatOpScalarMask(FCV cvFunc, FCANN cannFunc, DTMASK mask, PARAMS... param)
+{
+    Scalar scalar = randomScalar();
+    Mat mat(10, 10, CV_32SC3, randomScalar());
+    Mat cpuDst, checker, cpuMask;
+    AscendMat npuMat, npuChecker;
+    npuMat.upload(mat);
+    if (mask.empty())
+    {
+        cvFunc(mat, Mat(10, 10, CV_32SC3, scalar), cpuDst, noArray(), param...);
+    }
+    else
+    {
+        mask.download(cpuMask);
+        cvFunc(mat, Mat(10, 10, CV_32SC3, scalar), cpuDst, cpuMask, param...);
+    }
+    cv::cann::setDevice(DEVICE_ID);
+
+    cannFunc(npuMat, scalar, npuChecker, mask, param..., AscendStream::Null());
+    npuChecker.download(checker);
+    EXPECT_MAT_NEAR(cpuDst, checker, 1.0);
+
+    AscendStream stream;
+    cannFunc(npuMat, scalar, npuChecker, mask, param..., stream);
+    stream.waitForCompletion();
+    npuChecker.download(checker);
+    EXPECT_MAT_NEAR(cpuDst, checker, 1.0);
+
+    cv::cann::resetDevice();
+}
+template <typename FCV, typename FCANN, typename DTMASK, typename... PARAMS>
+void testScalarOpAscendMatMask(FCV cvFunc, FCANN cannFunc, DTMASK mask, PARAMS... param)
+{
+    Scalar scalar = randomScalar();
+    Mat mat(10, 10, CV_32SC3, randomScalar());
+    Mat cpuDst, checker, cpuMask;
+    AscendMat npuMat, npuChecker;
+    npuMat.upload(mat);
+    if (mask.empty())
+    {
+        cvFunc(Mat(10, 10, CV_32SC3, scalar), mat, cpuDst, noArray(), param...);
+    }
+    else
+    {
+        mask.download(cpuMask);
+        cvFunc(Mat(10, 10, CV_32SC3, scalar), mat, cpuDst, cpuMask, param...);
+    }
+    cv::cann::setDevice(DEVICE_ID);
+
+    cannFunc(scalar, npuMat, npuChecker, mask, param..., AscendStream::Null());
+    npuChecker.download(checker);
+    EXPECT_MAT_NEAR(cpuDst, checker, 1.0);
+
+    AscendStream stream;
+    cannFunc(scalar, npuMat, npuChecker, mask, param..., stream);
+    stream.waitForCompletion();
+    npuChecker.download(checker);
+    EXPECT_MAT_NEAR(cpuDst, checker, 1.0);
+
+    cv::cann::resetDevice();
+}
+template <typename FCV, typename FCANN, typename... PARAMS>
+void testAscendMatOpScalar(FCV cvFunc, FCANN cannFunc, PARAMS... param)
+{
+    Scalar scalar = randomScalar();
+    Mat mat(10, 10, CV_32SC3, randomScalar());
+    Mat cpuDst, checker;
+    AscendMat npuMat, npuChecker;
+    npuMat.upload(mat);
+
+    cvFunc(mat, Mat(10, 10, CV_32SC3, scalar), cpuDst, param...);
+    cv::cann::setDevice(DEVICE_ID);
+
+    cannFunc(npuMat, scalar, npuChecker, param..., AscendStream::Null());
+    npuChecker.download(checker);
+    EXPECT_MAT_NEAR(cpuDst, checker, 1.0);
+
+    AscendStream stream;
+    cannFunc(npuMat, scalar, npuChecker, param..., stream);
+    stream.waitForCompletion();
+    npuChecker.download(checker);
+
+    cv::cann::resetDevice();
+}
+
+TEST(ELEMENTWISE_OP, MAT_ADD_SCALAR)
+{
+    testMatOpScalar(
+        cv::add,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           int dtype, AscendStream& stream)
+        { cv::cann::add(src1, src2, dst, mask, dtype, stream); },
+        noArray(), -1);
+    testAscendMatOpScalarMask(
+        cv::add,
+        [](const AscendMat& src1, const Scalar& src2, AscendMat& dst, const AscendMat& mask,
+           int dtype, AscendStream& stream)
+        { cv::cann::add(src1, src2, dst, mask, dtype, stream); },
+        AscendMat(), -1);
+    testScalarOpAscendMatMask(
+        cv::add,
+        [](const Scalar& src1, const AscendMat& src2, AscendMat& dst, const AscendMat& mask,
+           int dtype, AscendStream& stream)
+        { cv::cann::add(src1, src2, dst, mask, dtype, stream); },
+        AscendMat(), -1);
+}
+
+TEST(ELEMENTWISE_OP, MAT_SUB_SCALAR)
+{
+    testMatOpScalar(
+        cv::subtract,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           int dtype, AscendStream& stream)
+        { cv::cann::subtract(src1, src2, dst, mask, dtype, stream); },
+        noArray(), -1);
+    testAscendMatOpScalarMask(
+        cv::subtract,
+        [](const AscendMat& src1, const Scalar& src2, AscendMat& dst, const AscendMat& mask,
+           int dtype, AscendStream& stream)
+        { cv::cann::subtract(src1, src2, dst, mask, dtype, stream); },
+        AscendMat(), -1);
+}
+
+TEST(ELEMENTWISE_OP, MAT_MUL_SCALAR)
+{
+    testMatOpScalar(
+        cv::multiply,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, float scale, int dtype,
+           AscendStream& stream) { cv::cann::multiply(src1, src2, dst, scale, dtype, stream); },
+        1, -1);
+    testAscendMatOpScalar(
+        cv::multiply,
+        [](const AscendMat& src1, const Scalar& src2, AscendMat& dst, float scale, int dtype,
+           AscendStream& stream) { cv::cann::multiply(src1, src2, dst, scale, dtype, stream); },
+        1, -1);
+}
+
+TEST(ELEMENTWISE_OP, MAT_DIV_SCALAR)
+{
+    testMatOpScalar(
+        [](const cv::Mat& src1, const cv::Mat& src2, cv::Mat& dst, double scale, int dtype)
+        { cv::divide(src1, src2, dst, scale, dtype); },
+        [](const InputArray src1, const InputArray src2, OutputArray dst, float scale, int dtype,
+           AscendStream& stream) { cv::cann::divide(src1, src2, dst, scale, dtype, stream); },
+        1, -1);
+    testAscendMatOpScalar(
+        [](const cv::Mat& src1, const cv::Mat& src2, cv::Mat& dst, double scale, int dtype)
+        { cv::divide(src1, src2, dst, scale, dtype); },
+        [](const AscendMat& src1, const Scalar& src2, AscendMat& dst, float scale, int dtype,
+           AscendStream& stream) { cv::cann::divide(src1, src2, dst, scale, dtype, stream); },
+        1, -1);
+}
+
+TEST(ELEMENTWISE_OP, MAT_BITWISE_AND_SCALAR)
+{
+    testMatOpScalar(
+        cv::bitwise_and,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           AscendStream& stream) { cv::cann::bitwise_and(src1, src2, dst, mask, stream); },
+        noArray());
+    testAscendMatOpScalarMask(
+        cv::bitwise_and,
+        [](const AscendMat& src1, const Scalar& src2, AscendMat& dst, const AscendMat& mask,
+           AscendStream& stream) { cv::cann::bitwise_and(src1, src2, dst, mask, stream); },
+        AscendMat());
+}
+
+TEST(ELEMENTWISE_OP, MAT_BITWISE_OR_SCALAR)
+{
+    testMatOpScalar(
+        cv::bitwise_or,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           AscendStream& stream) { cv::cann::bitwise_or(src1, src2, dst, mask, stream); },
+        noArray());
+    testAscendMatOpScalarMask(
+        cv::bitwise_or,
+        [](const AscendMat& src1, const Scalar& src2, AscendMat& dst, const AscendMat& mask,
+           AscendStream& stream) { cv::cann::bitwise_or(src1, src2, dst, mask, stream); },
+        AscendMat());
+}
+
+TEST(ELEMENTWISE_OP, MAT_BITWISE_XOR_SCALAR)
+{
+    testMatOpScalar(
+        cv::bitwise_xor,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           AscendStream& stream) { cv::cann::bitwise_xor(src1, src2, dst, mask, stream); },
+        noArray());
+    testAscendMatOpScalarMask(
+        cv::bitwise_xor,
+        [](const AscendMat& src1, const Scalar& src2, AscendMat& dst, const AscendMat& mask,
+           AscendStream& stream) { cv::cann::bitwise_xor(src1, src2, dst, mask, stream); },
+        AscendMat());
+}
+
+TEST(ELEMENTWISE_OP, MAT_ADD_SCALAR_WITH_MASK_AND_DETYPE)
+{
+    testMatOpScalar(
+        cv::add,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           int dtype, AscendStream& stream)
+        { cv::cann::add(src1, src2, dst, mask, dtype, stream); },
+        genMask(), CV_32SC3);
+    testAscendMatOpScalarMask(
+        cv::add,
+        [](const AscendMat& src1, const Scalar& src2, AscendMat& dst, const AscendMat& mask,
+           int dtype, AscendStream& stream)
+        { cv::cann::add(src1, src2, dst, mask, dtype, stream); },
+        genNpuMask(), CV_32SC3);
+}
+
+TEST(ELEMENTWISE_OP, MAT_SUB_SCALAR_WITH_MASK_AND_DETYPE)
+{
+    testMatOpScalar(
+        cv::subtract,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           int dtype, AscendStream& stream)
+        { cv::cann::subtract(src1, src2, dst, mask, dtype, stream); },
+        genMask(), CV_32SC3);
+    testAscendMatOpScalarMask(
+        cv::subtract,
+        [](const AscendMat& src1, const Scalar& src2, AscendMat& dst, const AscendMat& mask,
+           int dtype, AscendStream& stream)
+        { cv::cann::subtract(src1, src2, dst, mask, dtype, stream); },
+        genNpuMask(), CV_32SC3);
+}
+
+TEST(ELEMENTWISE_OP, MAT_BITWISE_AND_SCALAR_WITH_MASK)
+{
+    testMatOpScalar(
+        cv::bitwise_and,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           AscendStream& stream) { cv::cann::bitwise_and(src1, src2, dst, mask, stream); },
+        genMask());
+    testAscendMatOpScalarMask(
+        cv::bitwise_and,
+        [](const AscendMat& src1, const Scalar& src2, AscendMat& dst, const AscendMat& mask,
+           AscendStream& stream) { cv::cann::bitwise_and(src1, src2, dst, mask, stream); },
+        genNpuMask());
+}
+
+TEST(ELEMENTWISE_OP, MAT_BITWISE_OR_SCALAR_WITH_MASK)
+{
+    testMatOpScalar(
+        cv::bitwise_or,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           AscendStream& stream) { cv::cann::bitwise_or(src1, src2, dst, mask, stream); },
+        genMask());
+    testAscendMatOpScalarMask(
+        cv::bitwise_or,
+        [](const AscendMat& src1, const Scalar& src2, AscendMat& dst, const AscendMat& mask,
+           AscendStream& stream) { cv::cann::bitwise_or(src1, src2, dst, mask, stream); },
+        genNpuMask());
+}
+
+TEST(ELEMENTWISE_OP, MAT_BITWISE_XOR_SCALAR_WITH_MASK)
+{
+    testMatOpScalar(
+        cv::bitwise_xor,
+        [](const InputArray src1, const InputArray src2, OutputArray dst, const InputArray mask,
+           AscendStream& stream) { cv::cann::bitwise_xor(src1, src2, dst, mask, stream); },
+        genMask());
+    testAscendMatOpScalarMask(
+        cv::bitwise_xor,
+        [](const AscendMat& src1, const Scalar& src2, AscendMat& dst, const AscendMat& mask,
+           AscendStream& stream) { cv::cann::bitwise_xor(src1, src2, dst, mask, stream); },
+        genNpuMask());
+}
+
+// TODO: I think the cv result is wrong, which has truncated middle result.
+// Disable these two test case bacause it't not stable.
+// TEST(ELEMENTWISE_OP, MAT_MUL_SCALAR_WITH_SCALE)
+// {
+//     testMatOpScalar(
+//         cv::multiply,
+//         [](const InputArray src1, const InputArray src2, OutputArray dst, float scale, int dtype,
+//            AscendStream& stream) { cv::cann::multiply(src1, src2, dst, scale, dtype, stream); },
+//         randomScale, CV_32SC3);
+//     testAscendMatOpScalar(
+//         [](const cv::Mat& src1, const cv::Mat& src2, cv::Mat& dst, double scale, int dtype)
+//         { cv::divide(src1, src2, dst, scale, dtype); },
+//         [](const AscendMat& src1, const Scalar& src2, AscendMat& dst, float scale, int dtype,
+//            AscendStream& stream) { cv::cann::divide(src1, src2, dst, scale, dtype, stream); },
+//         randomScale, -1);
+// }
+
+// TEST(ELEMENTWISE_OP, MAT_DIV_SCALAR_WITH_SCALE)
+// {
+//     testMatOpScalar(
+//         [](const cv::Mat& src1, const cv::Mat& src2, cv::Mat& dst, double scale, int dtype)
+//         { cv::divide(src1, src2, dst, scale, dtype); },
+//         [](const InputArray src1, const InputArray src2, OutputArray dst, float scale, int dtype,
+//            AscendStream& stream) { cv::cann::divide(src1, src2, dst, scale, dtype, stream); },
+//         randomScale, -1);
+//     testAscendMatOpScalar(
+//         [](const cv::Mat& src1, const cv::Mat& src2, cv::Mat& dst, double scale, int dtype)
+//         { cv::divide(src1, src2, dst, scale, dtype); },
+//         [](const AscendMat& src1, const Scalar& src2, AscendMat& dst, float scale, int dtype,
+//            AscendStream& stream) { cv::cann::divide(src1, src2, dst, scale, dtype, stream); },
+//         randomScale, -1);
+// }
+
+TEST(ELEMENTWISE_OP, MAT_BITWISE_NOT)
+{
+    Mat cpuOpRet, checker, cpuMat = randomMat(10, 10, CV_32SC3);
+    cv::cann::setDevice(DEVICE_ID);
+    cv::bitwise_not(cpuMat, cpuOpRet);
+    cv::cann::bitwise_not(cpuMat, checker);
+    EXPECT_MAT_NEAR(cpuOpRet, checker, 0.0);
+
+    AscendMat npuMat, npuOpRet;
+    npuMat.upload(cpuMat);
+    cv::cann::bitwise_not(npuMat, npuOpRet);
+    npuOpRet.download(checker);
+    EXPECT_MAT_NEAR(cpuOpRet, checker, 0.0);
+
+    cv::cann::resetDevice();
+}
+
+// TODO random test matrix
+TEST(ELEMENTWISE_OP, MAT_ADD_WEIGHTED)
+{
+    Mat cpuOpRet, checker, cpuMat1 = Mat::ones(5, 5, CV_32S), cpuMat2 = Mat::ones(5, 5, CV_32S);
+
+    cv::cann::setDevice(DEVICE_ID);
+    cv::addWeighted(cpuMat1, 2, cpuMat2, 3, 5, cpuOpRet);
+    cv::cann::addWeighted(cpuMat1, 2, cpuMat2, 3, 5, checker);
+    EXPECT_MAT_NEAR(cpuOpRet, checker, 0.0);
+
+    AscendMat npuOpRet, npuMat1, npuMat2;
+    npuMat1.upload(cpuMat1);
+    npuMat2.upload(cpuMat2);
+    cv::cann::addWeighted(npuMat1, 2, npuMat2, 3, 5, npuOpRet);
+    npuOpRet.download(checker);
+    EXPECT_MAT_NEAR(cpuOpRet, checker, 0.0);
+
+    cv::cann::resetDevice();
+}
+
+TEST(ELEMENTWISE_OP, MAT_THRESHOLD)
+{
+    Mat cpuOpRet, checker, cpuMat = randomMat(10, 10, CV_16SC3, 0.0, 255.0);
+
+    AscendMat ascendMat, ascendMat16F, aclOpRet, aclOpRet16S;
+    cv::cann::setDevice(DEVICE_ID);
+    ascendMat.upload(cpuMat);
+    ascendMat.convertTo(ascendMat16F, CV_16F);
+
+    Mat cpuMat16F, checker16F;
+    cpuMat.convertTo(cpuMat16F, CV_16F);
+
+    for (int i = 0; i <= 4; i++)
+    {
+        cv::threshold(cpuMat, cpuOpRet, 128, 250, i);
+        cv::cann::threshold(ascendMat16F, aclOpRet, 128, 250, i);
+        aclOpRet.convertTo(aclOpRet16S, CV_16S);
+        aclOpRet16S.download(checker);
+
+        EXPECT_MAT_NEAR(cpuOpRet, checker, 1e-10);
+
+        cv::cann::threshold(cpuMat16F, checker16F, 128, 250, i);
+        checker16F.convertTo(checker, CV_16S);
+        EXPECT_MAT_NEAR(cpuOpRet, checker, 1e-10);
+    }
+
+    cv::cann::resetDevice();
+}
+
+TEST(ELEMENTWISE_OP, MAT_THRESHOLD_ASCENDC)
+{
+    cv::cann::setDevice(DEVICE_ID);
+    Mat cpuRet, npuRet;
+    AscendMat npuImg, npuTmpMat;
+
+    // opencv do not support CV_8S, CV_32S, CV_16F
+    // ascend do not support CV_16U, CV_64F
+    uint8_t dtypes[] = {CV_8U, CV_16S, CV_32F};
+
+    for (uint i = 0; i <= 4; i++)
+    {
+        for (uint j = 0; j < sizeof(dtypes) / sizeof(dtypes[0]); j++)
+        {
+            double thresh = 90.5;
+            double maxVal = 85.2;
+
+            Mat img = randomMat(10, 10, CV_MAKETYPE(dtypes[j], 3), 0.0f, 128.0f);
+            npuImg.upload(img);
+            npuTmpMat.create(npuImg.rows, npuImg.cols, npuImg.type());
+
+            cv::threshold(img, cpuRet, thresh, maxVal, i);
+            cv::cann::threshold(npuImg, npuTmpMat, thresh, maxVal, i);
+
+            npuTmpMat.download(npuRet);
+            EXPECT_MAT_NEAR(cpuRet, npuRet, 10.0f);
+        }
+    }
+
+    cv::cann::resetDevice();
+}
+
+} // namespace
+} // namespace opencv_test

modules/cannops/test/test_kernel.cpp

@@ -0,0 +1,51 @@
+#include "test_precomp.hpp"
+#include "opencv2/cann_call.hpp"
+
+namespace opencv_test
+{
+namespace
+{
+
+TEST(ASCENDC_KERNEL, THRESHOLD)
+{
+    cv::cann::setDevice(DEVICE_ID);
+    Mat cpuRet, npuRet;
+    AscendMat npuImg, npuTmpMat;
+
+    // opencv do not support CV_8S, CV_32S, CV_16F
+    // ascend do not support CV_16U, CV_64F
+    uint8_t dtypes[] = {CV_8U, CV_16S, CV_32F};
+
+    for (uint i = 0; i <= 4; i++)
+    {
+        for (uint j = 0; j < sizeof(dtypes) / sizeof(dtypes[0]); j++)
+        {
+            double thresh = 90.5;
+            double maxVal = 85.2;
+
+            Mat img = randomMat(10, 10, CV_MAKETYPE(dtypes[j], 3), 0.0f, 128.0f);
+            npuImg.upload(img);
+            npuTmpMat.create(npuImg.rows, npuImg.cols, npuImg.type());
+
+            cv::threshold(img, cpuRet, thresh, maxVal, i);
+            ThresholdOpencvTilingData tiling;
+            tiling.maxVal = maxVal;
+            tiling.thresh = thresh;
+            size_t totalBytes = img.rows * img.cols * img.channels();
+            // AscendMat memory will be align to 32B, it's safe to set totalLengh a little bigger.
+            tiling.totalLength = ((totalBytes + 32) & ~31);
+            tiling.threshType = i;
+            tiling.dtype = dtypes[j];
+            kernel_launch(aclrtlaunch_threshold_opencv, AscendStream::Null(), tiling,
+                          npuImg.data.get(), npuTmpMat.data.get());
+
+            npuTmpMat.download(npuRet);
+            EXPECT_MAT_NEAR(cpuRet, npuRet, 10.0f);
+        }
+    }
+
+    cv::cann::resetDevice();
+}
+
+} // namespace
+} // namespace opencv_test

modules/cannops/test/test_main.cpp

@@ -0,0 +1,31 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+class CannEnvironment : public ::testing::Environment
+{
+public:
+    virtual ~CannEnvironment() = default;
+    virtual void SetUp() CV_OVERRIDE
+    {
+        initAcl();
+        cv::cann::setDevice(DEVICE_ID);
+        initDvpp();
+    }
+    virtual void TearDown() CV_OVERRIDE
+    {
+        finalizeAcl();
+        cv::cann::resetDevice();
+        finalizeDvpp();
+    }
+};
+
+static void initTests()
+{
+    CannEnvironment* cannEnv = new CannEnvironment();
+    ::testing::AddGlobalTestEnvironment(cannEnv);
+}
+
+CV_TEST_MAIN("cannops", initTests());

modules/cannops/test/test_npumat.cpp

@@ -0,0 +1,146 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+namespace opencv_test
+{
+namespace
+{
+
+class DummyAllocator : public AscendMat::Allocator
+{
+public:
+    std::shared_ptr<uchar> allocate(size_t size) CV_OVERRIDE
+    {
+        CV_UNUSED(size);
+        return std::shared_ptr<uchar>();
+    }
+    bool allocate(cv::cann::AscendMat* mat, int rows, int cols, size_t elemSize) CV_OVERRIDE
+    {
+        CV_UNUSED(rows);
+        CV_UNUSED(cols);
+        CV_UNUSED(elemSize);
+        mat->data = std::shared_ptr<uchar>((uchar*)0x12345, [](void* ptr) { CV_UNUSED(ptr); });
+        return true;
+    }
+};
+
+TEST(AscendMat, Construct)
+{
+    cv::cann::setDevice(0);
+    // 1 Default constructor.
+    AscendMat defaultAscendMat;
+    AscendMat::Allocator* defaultAllocator = AscendMat::defaultAllocator();
+    ASSERT_EQ(defaultAscendMat.allocator, defaultAllocator);
+
+    // 2 get & set allocator.
+    DummyAllocator dummyAllocator;
+    AscendMat::setDefaultAllocator(&dummyAllocator);
+    ASSERT_EQ(defaultAscendMat.defaultAllocator(), &dummyAllocator);
+    AscendMat::setDefaultAllocator(defaultAllocator);
+
+    // 3 constructs AscendMat of the specified size and type
+    AscendMat specifiedSizeAscendMat1(5, 6, CV_8UC3);
+    AscendMat specifiedSizeAscendMat2(Size(300, 200), CV_64F);
+
+    ASSERT_EQ(specifiedSizeAscendMat1.rows, 5);
+    ASSERT_EQ(specifiedSizeAscendMat1.cols, 6);
+    ASSERT_EQ(specifiedSizeAscendMat1.depth(), CV_8U);
+    ASSERT_EQ(specifiedSizeAscendMat1.channels(), 3);
+
+    ASSERT_EQ(specifiedSizeAscendMat2.cols, 300);
+    ASSERT_EQ(specifiedSizeAscendMat2.rows, 200);
+    ASSERT_EQ(specifiedSizeAscendMat2.depth(), CV_64F);
+    ASSERT_EQ(specifiedSizeAscendMat2.channels(), 1);
+
+    // 4 constructs AscendMat and fills it with the specified value s
+    srand((unsigned int)(time(NULL)));
+    Scalar sc(rand() % 256, rand() % 256, rand() % 256, rand() % 256);
+
+    Mat scalarToMat(7, 8, CV_8UC3, sc);
+    AscendMat scalarToAscendMat1(7, 8, CV_8UC3, sc);
+    Mat scalarToMatChecker;
+    scalarToAscendMat1.download(scalarToMatChecker);
+
+    EXPECT_MAT_NEAR(scalarToMat, scalarToMatChecker, 0.0);
+
+    AscendMat scalarToAscendMat2(Size(123, 345), CV_32S);
+
+    ASSERT_EQ(scalarToAscendMat1.rows, 7);
+    ASSERT_EQ(scalarToAscendMat1.cols, 8);
+    ASSERT_EQ(scalarToAscendMat1.depth(), CV_8U);
+    ASSERT_EQ(scalarToAscendMat1.channels(), 3);
+
+    ASSERT_EQ(scalarToAscendMat2.cols, 123);
+    ASSERT_EQ(scalarToAscendMat2.rows, 345);
+    ASSERT_EQ(scalarToAscendMat2.depth(), CV_32S);
+    ASSERT_EQ(scalarToAscendMat2.channels(), 1);
+
+    // 6 builds AscendMat from host memory
+    Scalar sc2(rand() % 256, rand() % 256, rand() % 256, rand() % 256);
+    Mat randomMat(7, 8, CV_8UC3, sc2);
+    InputArray arr = randomMat;
+
+    AscendMat fromInputArray(arr, AscendStream::Null());
+    Mat randomMatChecker;
+    fromInputArray.download(randomMatChecker);
+    EXPECT_MAT_NEAR(randomMat, randomMatChecker, 0.0);
+
+    cv::cann::resetDevice();
+}
+
+TEST(AscendMat, Assignment)
+{
+    DummyAllocator dummyAllocator;
+    AscendMat mat1;
+    AscendMat mat2(3, 4, CV_8SC1, &dummyAllocator);
+    mat1 = mat2;
+
+    ASSERT_EQ(mat1.rows, 3);
+    ASSERT_EQ(mat1.cols, 4);
+    ASSERT_EQ(mat1.depth(), CV_8S);
+    ASSERT_EQ(mat1.channels(), 1);
+    ASSERT_EQ(mat1.data.get(), (uchar*)0x12345);
+}
+
+TEST(AscendMat, SetTo)
+{
+    cv::cann::setDevice(0);
+
+    srand((unsigned int)(time(NULL)));
+    Scalar sc(rand() % 256, rand() % 256, rand() % 256, rand() % 256);
+
+    AscendMat ascendMat(2, 2, CV_8UC4);
+    ascendMat.setTo(sc);
+    Mat mat(2, 2, CV_8UC4, sc);
+    Mat checker;
+    ascendMat.download(checker);
+
+    EXPECT_MAT_NEAR(mat, checker, 0.0);
+
+    cv::cann::resetDevice();
+}
+
+TEST(AscendMat, ConvertTo)
+{
+    cv::cann::setDevice(0);
+
+    srand((unsigned int)(time(NULL)));
+    Scalar sc(rand() % 256, rand() % 256, rand() % 256, rand() % 256);
+
+    AscendMat ascendMat(2, 2, CV_8UC4, sc);
+    AscendMat convertedAscendMat;
+    ascendMat.convertTo(convertedAscendMat, CV_16S);
+    Mat mat(2, 2, CV_16SC4, sc);
+    Mat checker;
+    convertedAscendMat.download(checker);
+
+    EXPECT_MAT_NEAR(mat, checker, 0.0);
+
+    cv::cann::resetDevice();
+}
+
+} // namespace
+} // namespace opencv_test

modules/cannops/test/test_precomp.hpp

@@ -0,0 +1,29 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef __OPENCV_TEST_PRECOMP_HPP__
+#define __OPENCV_TEST_PRECOMP_HPP__
+
+#include "opencv2/ts.hpp"
+#include "opencv2/cann.hpp"
+#include "opencv2/ts/cuda_test.hpp"
+#include "opencv2/cann_interface.hpp"
+#include "opencv2/ascendc_kernels.hpp"
+
+using namespace cv;
+using namespace cv::cann;
+#undef EXPECT_MAT_NEAR
+#define EXPECT_MAT_NEAR(m1, m2, eps) EXPECT_PRED_FORMAT3(cvtest::assertMatNear, m1, m2, eps)
+#define ASSERT_MAT_NEAR(m1, m2, eps) ASSERT_PRED_FORMAT3(cvtest::assertMatNear, m1, m2, eps)
+
+#define DEVICE_ID 0
+
+Mat randomMat(int w, int h, int dtype, float min = 1.0f, float max = 10.0f);
+Scalar randomScalar();
+float randomNum();
+int randomInterger();
+Mat genMask();
+AscendMat genNpuMask();
+
+#endif //__OPENCV_TEST_PRECOMP_HPP__

modules/cannops/test/test_utils.cpp

@@ -0,0 +1,49 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+// Random Generator
+Mat randomMat(int w, int h, int dtype, float min, float max)
+{
+    Mat rnMat(w, h, dtype);
+    RNG rng(getTickCount());
+    rng.fill(rnMat, RNG::UNIFORM, min, max);
+    return rnMat;
+}
+Scalar randomScalar()
+{
+    RNG rng(getTickCount());
+    Scalar sc;
+    rng.fill(sc, RNG::UNIFORM, 1.0, 5.0);
+    return sc;
+}
+float randomNum()
+{
+    RNG rng(getTickCount());
+    float rdnNum = float(rng.uniform(1.0, 5.0));
+    return rdnNum;
+}
+
+int randomInterger()
+{
+    RNG rng(getTickCount());
+    float rdnNum = float(rng.uniform(1, 5));
+    return rdnNum;
+}
+
+Mat genMask()
+{
+    Mat mask = Mat::zeros(Size(10, 10), CV_8UC1);
+    rectangle(mask, cv::Rect(5, 5, 3, 3), Scalar(255), -1);
+    return mask;
+}
+
+AscendMat genNpuMask()
+{
+    cv::Mat mask = genMask();
+    cv::cann::AscendMat npuMask;
+    npuMask.upload(mask);
+    return npuMask;
+}