opencv
diff --git a/‎CMakeLists.txt
Copy file name to clipboard
+15Lines changed: 15 additions & 0 deletions b/‎CMakeLists.txt
Copy file name to clipboard
+15Lines changed: 15 additions & 0 deletions
diff --git a/‎cmake/OpenCVFindCANN.cmake
Copy file name to clipboard
+109Lines changed: 109 additions & 0 deletions b/‎cmake/OpenCVFindCANN.cmake
Copy file name to clipboard
+109Lines changed: 109 additions & 0 deletions
diff --git a/‎cmake/checks/cann.cpp
Copy file name to clipboard
+20Lines changed: 20 additions & 0 deletions b/‎cmake/checks/cann.cpp
Copy file name to clipboard
+20Lines changed: 20 additions & 0 deletions
diff --git a/‎modules/dnn/CMakeLists.txt
Copy file name to clipboard
+16Lines changed: 16 additions & 0 deletions b/‎modules/dnn/CMakeLists.txt
Copy file name to clipboard
+16Lines changed: 16 additions & 0 deletions
diff --git a/‎modules/dnn/include/opencv2/dnn/dnn.hpp
Copy file name to clipboard
+10Lines changed: 10 additions & 0 deletions b/‎modules/dnn/include/opencv2/dnn/dnn.hpp
Copy file name to clipboard
+10Lines changed: 10 additions & 0 deletions
diff --git a/‎modules/dnn/src/layer.cpp
Copy file name to clipboard
+6Lines changed: 6 additions & 0 deletions b/‎modules/dnn/src/layer.cpp
Copy file name to clipboard
+6Lines changed: 6 additions & 0 deletions
diff --git a/‎modules/dnn/src/layers/batch_norm_layer.cpp
Copy file name to clipboard
+67-1Lines changed: 67 additions & 1 deletion b/‎modules/dnn/src/layers/batch_norm_layer.cpp
Copy file name to clipboard
+67-1Lines changed: 67 additions & 1 deletion
diff --git a/‎modules/dnn/src/layers/blank_layer.cpp
Copy file name to clipboard
+25-1Lines changed: 25 additions & 1 deletion b/‎modules/dnn/src/layers/blank_layer.cpp
Copy file name to clipboard
+25-1Lines changed: 25 additions & 1 deletion
@@ -468,6 +468,9 @@ OCV_OPTION(WITH_TIMVX "Include Tim-VX support" OFF
 OCV_OPTION(WITH_OBSENSOR "Include obsensor support (Orbbec RGB-D modules: Astra+/Femto)" ON
   VISIBLE_IF (WIN32 AND NOT ARM AND NOT WINRT) OR ( UNIX AND NOT APPLE AND NOT ANDROID)
   VERIFY HAVE_OBSENSOR)
+OCV_OPTION(WITH_CANN "Include CANN support" OFF
+  VISIBLE_IF TRUE
+  VERIFY HAVE_CANN)
 
 # OpenCV build components
 # ===================================================
@@ -753,6 +756,9 @@ endif()
 if(WITH_TIMVX)
   include(cmake/OpenCVFindTIMVX.cmake)
 endif()
+if(WITH_CANN)
+  include(cmake/OpenCVFindCANN.cmake)
+endif()
 
 # ----------------------------------------------------------------------------
 #  Detect other 3rd-party libraries/tools
@@ -1736,6 +1742,15 @@ if(WITH_ONNX OR HAVE_ONNX)
   endif()
 endif()
 
+if(WITH_CANN)
+  status("")
+  status("  CANN:"    HAVE_CANN THEN "YES" ELSE "NO")
+  if(HAVE_CANN)
+    status("    Include path"     CANN_INCLUDE_DIRS THEN "${CANN_INCLUDE_DIRS}" ELSE "NO")
+    status("    Link libraries:"  CANN_LIBRARIES    THEN "${CANN_LIBRARIES}"    ELSE "NO")
+  endif()
+endif()
+
 # ========================== python ==========================
 if(BUILD_opencv_python2)
   status("")
 
@@ -0,0 +1,109 @@
+ocv_check_environment_variables(CANN_INSTALL_DIR)
+
+if("cann${CANN_INSTALL_DIR}" STREQUAL "cann" AND DEFINED ENV{ASCEND_TOOLKIT_HOME})
+    set(CANN_INSTALL_DIR $ENV{ASCEND_TOOLKIT_HOME})
+    message(STATUS "CANN: updated CANN_INSTALL_DIR from ASCEND_TOOLKIT_HOME=$ENV{ASCEND_TOOLKIT_HOME}")
+endif()
+
+if(CANN_INSTALL_DIR)
+    # Supported platforms: x86-64, arm64
+    if(CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64")
+    elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64" OR CMAKE_SYSTEM_PROCESSOR STREQUAL "amd64")
+    else()
+        set(HAVE_CANN OFF)
+        message(STATUS "CANN: CANN toolkit supports x86-64 and arm64 but not ${CMAKE_SYSTEM_PROCESSOR}. Turning off HAVE_CANN")
+        return()
+    endif()
+
+    # Supported OS: linux (because of we need fork() to build models in child process)
+    # done via checks in cann.cpp
+    # FIXME: remove the check if a better model building solution is found
+
+    # include
+    set(incs_cann "${CANN_INSTALL_DIR}/include")
+    list(APPEND incs_cann "${CANN_INSTALL_DIR}/opp")
+
+    # libs
+    #  * libascendcl.so
+    set(lib_ascendcl "${CANN_INSTALL_DIR}/acllib/lib64")
+    find_library(found_lib_ascendcl NAMES ascendcl PATHS ${lib_ascendcl} NO_DEFAULT_PATH)
+    if(found_lib_ascendcl)
+        set(lib_ascendcl ${found_lib_ascendcl})
+        message(STATUS "CANN: libascendcl.so is found at ${lib_ascendcl}")
+    else()
+        message(STATUS "CANN: Missing libascendcl.so. Turning off HAVE_CANN")
+        set(HAVE_CANN OFF)
+        return()
+    endif()
+    #  * libgraph.so
+    set(lib_graph "${CANN_INSTALL_DIR}/compiler/lib64")
+    find_library(found_lib_graph NAMES graph PATHS ${lib_graph} NO_DEFAULT_PATH)
+    if(found_lib_graph)
+        set(lib_graph ${found_lib_graph})
+        message(STATUS "CANN: libgraph.so is found at ${lib_graph}")
+    else()
+        message(STATUS "CANN: Missing libgraph.so. Turning off HAVE_CANN")
+        set(HAVE_CANN OFF)
+        return()
+    endif()
+    #  * libge_compiler.so
+    set(lib_ge_compiler "${CANN_INSTALL_DIR}/compiler/lib64")
+    find_library(found_lib_ge_compiler NAMES ge_compiler PATHS ${lib_ge_compiler} NO_DEFAULT_PATH)
+    if(found_lib_ge_compiler)
+        set(lib_ge_compiler ${found_lib_ge_compiler})
+        message(STATUS "CANN: libge_compiler.so is found at ${lib_ge_compiler}")
+    else()
+        message(STATUS "CANN: Missing libge_compiler.so. Turning off HAVE_CANN")
+        set(HAVE_CANN OFF)
+        return()
+    endif()
+    #  * libopsproto.so
+    set(lib_opsproto "${CANN_INSTALL_DIR}/opp/op_proto/built-in")
+    find_library(found_lib_opsproto NAMES opsproto PATHS ${lib_opsproto} NO_DEFAULT_PATH)
+    if(found_lib_opsproto)
+        set(lib_opsproto ${found_lib_opsproto})
+        message(STATUS "CANN: libopsproto.so is found at ${lib_opsproto}")
+    else()
+        message(STATUS "CANN: Missing libopsproto.so. Turning off HAVE_CANN")
+        set(HAVE_CANN OFF)
+        return()
+    endif()
+
+
+    set(libs_cann "")
+    list(APPEND libs_cann ${lib_ascendcl})
+    list(APPEND libs_cann ${lib_opsproto})
+    list(APPEND libs_cann ${lib_graph})
+    list(APPEND libs_cann ${lib_ge_compiler})
+
+    try_compile(VALID_ASCENDCL
+        "${OpenCV_BINARY_DIR}"
+        "${OpenCV_SOURCE_DIR}/cmake/checks/cann.cpp"
+        CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${incs_cann}"
+                    "-DLINK_LIBRARIES:STRING=${libs_cann}"
+        OUTPUT_VARIABLE ASCEND_TRY_OUT)
+
+    if(NOT ${VALID_ASCENDCL})
+        message(WARNING "Cannot use CANN")
+        set(HAVE_CANN OFF)
+        return()
+    endif()
+
+    set(HAVE_CANN ON)
+endif()
+
+if(HAVE_CANN)
+    set(CANN_INCLUDE_DIRS ${incs_cann})
+    set(CANN_LIBRARIES ${libs_cann})
+    ocv_add_external_target(cann "${CANN_INCLUDE_DIRS}" "${CANN_LIBRARIES}" "HAVE_CANN")
+    ocv_warnings_disable(CMAKE_C_FLAGS -Wignored-qualifiers)
+    ocv_warnings_disable(CMAKE_CXX_FLAGS -Wignored-qualifiers)
+endif()
+
+MARK_AS_ADVANCED(
+    incs_cann
+    libs_cann
+    lib_ascendcl
+    lib_graph
+    lib_ge_compiler
+)
@@ -0,0 +1,20 @@
+#include <acl/acl.h>
+#include <unistd.h> // fork()
+#include <iostream>
+
+int main(int /*argc*/, char** /*argv*/)
+{
+    int ret = aclInit(NULL);
+    if (ret != 0)
+    {
+        std::cerr << "Failed to initialize Ascend, ret = " << ret;
+    }
+
+    ret = aclFinalize();
+    if (ret != 0)
+    {
+        std::cerr << "Failed to de-initialize Ascend, ret = " << ret;
+    }
+
+    return 0;
+}
@@ -31,6 +31,10 @@ if(HAVE_TIMVX)
   ocv_target_compile_definitions(${the_module} PRIVATE "HAVE_TIMVX=1")
 endif()
 
+if(HAVE_CANN)
+  ocv_target_compile_definitions(${the_module} PRIVATE "HAVE_CANN=1")
+endif()
+
 ocv_option(OPENCV_DNN_CUDA "Build with CUDA support"
     HAVE_CUDA
     AND HAVE_CUBLAS
@@ -162,6 +166,11 @@ if(HAVE_TIMVX)
     list(APPEND libs -Wl,--whole-archive ${TIMVX_LIBRARY} -Wl,--no-whole-archive)
 endif()
 
+if(HAVE_CANN)
+  list(APPEND include_dirs ${CANN_INCLUDE_DIRS})
+  list(APPEND libs -Wl,--whole-archive ${CANN_LIBRARIES} -Wl,--no-whole-archive)
+endif()
+
 set(webnn_srcs "")
 if(NOT EMSCRIPTEN)
   if(HAVE_WEBNN)
@@ -264,3 +273,10 @@ if(TARGET ocv.3rdparty.openvino AND OPENCV_TEST_DNN_OPENVINO)
     ocv_target_link_libraries(opencv_test_dnn ocv.3rdparty.openvino)
   endif()
 endif()
+
+ocv_option(OPENCV_TEST_DNN_CANN "Build test with CANN" (TARGET ocv.3rdparty.cann))
+if(TARGET ocv.3rdparty.cann AND OPENCV_TEST_DNN_CANN)
+  if(TARGET opencv_test_dnn)
+    ocv_target_link_libraries(opencv_test_dnn ocv.3rdparty.cann)
+  endif()
+endif()
@@ -81,6 +81,7 @@ CV__DNN_INLINE_NS_BEGIN
         DNN_BACKEND_CUDA,
         DNN_BACKEND_WEBNN,
         DNN_BACKEND_TIMVX,
+        DNN_BACKEND_CANN,
 #if defined(__OPENCV_BUILD) || defined(BUILD_PLUGIN)
 #if !defined(OPENCV_BINDING_PARSER)
         DNN_BACKEND_INFERENCE_ENGINE_NGRAPH = 1000000,     // internal - use DNN_BACKEND_INFERENCE_ENGINE + setInferenceEngineBackendType()
@@ -343,6 +344,15 @@ CV__DNN_INLINE_NS_BEGIN
                                            const std::vector<Ptr<BackendWrapper> > &outputsWrapper,
                                            bool isLast);
 
+        /**
+         * @brief Returns a CANN backend node
+         *
+         * @param   inputsWrapper   layer inputs
+         * @param   index           layer id for op name
+         * @param   nodes           inputs of this node
+         */
+        virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes);
+
        /**
         * @brief Automatic Halide scheduling based on layer hyper-parameters.
         * @param[in] node Backend node with Halide functions.
 
@@ -84,6 +84,12 @@ Ptr<BackendNode> Layer::initTimVX(void* timVxInfo,
     return Ptr<BackendNode>();
 }
 
+Ptr<BackendNode> Layer::initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes)
+{
+    CV_Error(Error::StsNotImplemented, "CANN pipeline of " + type + " layers is not defined.");
+    return Ptr<BackendNode>();
+}
+
 Ptr<BackendNode> Layer::tryAttach(const Ptr<BackendNode>& node)
 {
     return Ptr<BackendNode>();
 
@@ -16,6 +16,7 @@ Implementation of Batch Normalization layer.
 #include "../op_inf_engine.hpp"
 #include "../ie_ngraph.hpp"
 #include "../op_webnn.hpp"
+#include "../op_cann.hpp"
 
 #include <opencv2/dnn/shape_utils.hpp>
 
@@ -40,6 +41,7 @@ class BatchNormLayerImpl CV_FINAL : public BatchNormLayer
     Mat weights_, bias_;
     UMat umat_weight, umat_bias;
     mutable int dims;
+    float momentum;
 
 
     BatchNormLayerImpl(const LayerParams& params)
@@ -55,6 +57,9 @@ class BatchNormLayerImpl CV_FINAL : public BatchNormLayer
             hasWeights = hasBias = true;
         epsilon = params.get<float>("eps", 1E-5);
 
+        // std::cout << params.get<float>("momentum", 0.9) << std::endl;
+        momentum = params.get<float>("momentum", 0.9);
+
         size_t n = blobs[0].total();
         CV_Assert(blobs[1].total() == n &&
                   blobs[0].isContinuous() && blobs[1].isContinuous() &&
@@ -177,7 +182,8 @@ class BatchNormLayerImpl CV_FINAL : public BatchNormLayer
         return (backendId == DNN_BACKEND_OPENCV) ||
                backendId == DNN_BACKEND_CUDA ||
                (backendId == DNN_BACKEND_HALIDE && haveHalide()) ||
-               backendId == DNN_BACKEND_WEBNN;
+               backendId == DNN_BACKEND_WEBNN ||
+               backendId == DNN_BACKEND_CANN;
     }
 
 #ifdef HAVE_OPENCL
@@ -385,6 +391,66 @@ class BatchNormLayerImpl CV_FINAL : public BatchNormLayer
     }
 #endif  // HAVE_HALIDE
 
+#ifdef HAVE_CANN
+    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+    {
+        CV_Assert(nodes.size() == 1);
+        CV_Assert(blobs.size() == 4); // must have scale, offset, mean and variance
+
+        auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto channel = x->host->size[1];
+
+        // create operator
+        std::string op_name = cv::format("bn_%d", index);
+        auto op = std::make_shared<ge::op::BatchNorm>(op_name);
+
+        // set attributes
+        op->set_attr_epsilon(epsilon);
+        op->set_attr_data_format("NCHW");
+        op->set_attr_is_training(false);
+
+        // set inputs
+        // set inputs : x
+        auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
+        op->set_input_x_by_name(*op_x, "y");
+        auto x_desc = x->getTensorDesc();
+        op->update_input_desc_x(*x_desc);
+        // set inputs : scale (blobs[2])
+        std::vector<int> shape_{channel};
+        auto op_const_scale = std::make_shared<CannConstOp>(blobs[2].data, blobs[2].type(), shape_, cv::format("%s_scale", op_name.c_str()));
+        op->set_input_scale(*(op_const_scale->getOp()));
+        op->update_input_desc_scale(*(op_const_scale->getTensorDesc()));
+        // set inputs : offset (blobs[3])
+        auto op_const_offset = std::make_shared<CannConstOp>(blobs[3].data, blobs[3].type(), shape_, cv::format("%s_offset", op_name.c_str()));
+        op->set_input_offset(*(op_const_offset->getOp()));
+        op->update_input_desc_offset(*(op_const_offset->getTensorDesc()));
+        // set inputs : mean (blobs[0])
+        auto op_const_mean = std::make_shared<CannConstOp>(blobs[0].data, blobs[0].type(), shape_, cv::format("%s_mean", op_name.c_str()));
+        op->set_input_mean(*(op_const_mean->getOp()));
+        op->update_input_desc_mean(*(op_const_mean->getTensorDesc()));
+        // set inputs : variance (blobs[1])
+        auto op_const_var = std::make_shared<CannConstOp>(blobs[1].data, blobs[1].type(), shape_, cv::format("%s_var", op_name.c_str()));
+        op->set_input_variance(*(op_const_var->getOp()));
+        op->update_input_desc_variance(*(op_const_var->getTensorDesc()));
+
+        // set outputs
+        auto output_y_desc = std::make_shared<ge::TensorDesc>(ge::Shape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
+        op->update_output_desc_y(*output_y_desc);
+        auto output_bm_desc = std::make_shared<ge::TensorDesc>(ge::Shape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
+        op->update_output_desc_batch_mean(*output_bm_desc);
+        auto output_bv_desc = std::make_shared<ge::TensorDesc>(ge::Shape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
+        op->update_output_desc_batch_variance(*output_bv_desc);
+        auto output_rs1_desc = std::make_shared<ge::TensorDesc>(ge::Shape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
+        op->update_output_desc_reserve_space_1(*output_rs1_desc);
+        auto output_rs2_desc = std::make_shared<ge::TensorDesc>(ge::Shape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
+        op->update_output_desc_reserve_space_2(*output_rs2_desc);
+        auto output_rs3_desc = std::make_shared<ge::TensorDesc>(ge::Shape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
+        op->update_output_desc_reserve_space_3(*output_rs3_desc);
+
+        return Ptr<BackendNode>(new CannBackendNode(op));
+    }
+#endif // HAVE_CANN
+
 
 #ifdef HAVE_DNN_NGRAPH
     virtual Ptr<BackendNode> initNgraph(const std::vector<Ptr<BackendWrapper> >& inputs, const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
 
@@ -43,6 +43,7 @@
 #include "../op_cuda.hpp"
 #include "../op_inf_engine.hpp"
 #include "../ie_ngraph.hpp"
+#include "../op_cann.hpp"
 
 #ifdef HAVE_CUDA
 #include "../cuda4dnn/primitives/reshape.hpp"
@@ -68,7 +69,8 @@ class BlankLayerImpl CV_FINAL : public BlankLayer
             return true;
 #endif
         return backendId == DNN_BACKEND_OPENCV ||
-               backendId == DNN_BACKEND_CUDA;
+               backendId == DNN_BACKEND_CUDA ||
+               backendId == DNN_BACKEND_CANN;
     }
 
     bool getMemoryShapes(const std::vector<MatShape> &inputs,
@@ -118,6 +120,28 @@ class BlankLayerImpl CV_FINAL : public BlankLayer
                 inputs[i].copyTo(outputs[i]);
     }
 
+#ifdef HAVE_CANN
+    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+    {
+        auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
+        auto x_desc = x->getTensorDesc();
+        auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
+        auto output_desc = std::make_shared<ge::TensorDesc>(ge::Shape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
+
+        // create operator
+        std::string op_name = cv::format("identity_%d", index);
+        auto op = std::make_shared<ge::op::Identity>(op_name);
+
+        // set inputs
+        op->set_input_x_by_name(*op_x, "y");
+        op->update_input_desc_x(*x_desc);
+
+        // set output
+        op->update_output_desc_y(*output_desc);
+
+        return Ptr<BackendNode>(new CannBackendNode(op));
+    }
+#endif
 
 #ifdef HAVE_DNN_NGRAPH
     virtual Ptr<BackendNode> initNgraph(const std::vector<Ptr<BackendWrapper> >& inputs,
Original file line number	Diff line number	Diff line change
`@@ -84,6 +84,12 @@ Ptr<BackendNode> Layer::initTimVX(void* timVxInfo,`
`84`	`84`	`return Ptr<BackendNode>();`
`85`	`85`	`}`
`86`	`86`
	`87`	`+Ptr<BackendNode> Layer::initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes)`
	`88`	`+{`
	`89`	`+ CV_Error(Error::StsNotImplemented, "CANN pipeline of " + type + " layers is not defined.");`
	`90`	`+ return Ptr<BackendNode>();`
	`91`	`+}`
	`92`	`+`
`87`	`93`	`Ptr<BackendNode> Layer::tryAttach(const Ptr<BackendNode>& node)`
`88`	`94`	`{`
`89`	`95`	`return Ptr<BackendNode>();`