opencv
diff --git a/‎modules/dnn/include/opencv2/dnn/dnn.hpp
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions b/‎modules/dnn/include/opencv2/dnn/dnn.hpp
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions
diff --git a/‎modules/dnn/src/layer.cpp
Copy file name to clipboard
+2-1Lines changed: 2 additions & 1 deletion b/‎modules/dnn/src/layer.cpp
Copy file name to clipboard
+2-1Lines changed: 2 additions & 1 deletion
diff --git a/‎modules/dnn/src/layers/batch_norm_layer.cpp
Copy file name to clipboard
+8-8Lines changed: 8 additions & 8 deletions b/‎modules/dnn/src/layers/batch_norm_layer.cpp
Copy file name to clipboard
+8-8Lines changed: 8 additions & 8 deletions
diff --git a/‎modules/dnn/src/layers/blank_layer.cpp
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions b/‎modules/dnn/src/layers/blank_layer.cpp
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions
diff --git a/‎modules/dnn/src/layers/concat_layer.cpp
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions b/‎modules/dnn/src/layers/concat_layer.cpp
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions
diff --git a/‎modules/dnn/src/layers/const_layer.cpp
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions b/‎modules/dnn/src/layers/const_layer.cpp
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions
diff --git a/‎modules/dnn/src/layers/convolution_layer.cpp
Copy file name to clipboard
+26-8Lines changed: 26 additions & 8 deletions b/‎modules/dnn/src/layers/convolution_layer.cpp
Copy file name to clipboard
+26-8Lines changed: 26 additions & 8 deletions
@@ -347,11 +347,11 @@ CV__DNN_INLINE_NS_BEGIN
         /**
          * @brief Returns a CANN backend node
          *
-         * @param   inputsWrapper   layer inputs
-         * @param   index           layer id for op name
-         * @param   nodes           inputs of this node
+         * @param   inputsWrapper   input tensors of this CANN operator
+         * @param   nodes           nodes of input tensors
          */
-        virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes);
+        virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper,
+                                          const std::vector<Ptr<BackendNode> >& nodes);
 
        /**
         * @brief Automatic Halide scheduling based on layer hyper-parameters.
 
@@ -84,7 +84,8 @@ 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)
+Ptr<BackendNode> Layer::initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper,
+                                 const std::vector<Ptr<BackendNode> >& nodes)
 {
     CV_Error(Error::StsNotImplemented, "CANN pipeline of " + type + " layers is not defined.");
     return Ptr<BackendNode>();
 
@@ -392,7 +392,8 @@ 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
+    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper,
+                                      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
@@ -401,8 +402,7 @@ class BatchNormLayerImpl CV_FINAL : public BatchNormLayer
         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);
+        auto op = std::make_shared<ge::op::BatchNorm>(name);
 
         // set attributes
         op->set_attr_epsilon(epsilon);
@@ -412,24 +412,24 @@ class BatchNormLayerImpl CV_FINAL : public BatchNormLayer
         // set inputs
         // set inputs : x
         auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         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()));
+        auto op_const_scale = std::make_shared<CannConstOp>(blobs[2].data, blobs[2].type(), shape_, cv::format("%s_scale", 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()));
+        auto op_const_offset = std::make_shared<CannConstOp>(blobs[3].data, blobs[3].type(), shape_, cv::format("%s_offset", 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()));
+        auto op_const_mean = std::make_shared<CannConstOp>(blobs[0].data, blobs[0].type(), shape_, cv::format("%s_mean", 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()));
+        auto op_const_var = std::make_shared<CannConstOp>(blobs[1].data, blobs[1].type(), shape_, cv::format("%s_var", name.c_str()));
         op->set_input_variance(*(op_const_var->getOp()));
         op->update_input_desc_variance(*(op_const_var->getTensorDesc()));
 
 
@@ -121,19 +121,19 @@ class BlankLayerImpl CV_FINAL : public BlankLayer
     }
 
 #ifdef HAVE_CANN
-    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper,
+                                      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);
+        auto op = std::make_shared<ge::op::Identity>(name);
 
         // set inputs
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         op->update_input_desc_x(*x_desc);
 
         // set output
 
@@ -367,13 +367,13 @@ class ConcatLayerImpl CV_FINAL : public ConcatLayer
     }
 
 #ifdef HAVE_CANN
-    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper,
+                                      const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
     {
         CV_Assert(inputsWrapper.size() == nodes.size());
 
         // create operator
-        std::string op_name = cv::format("concat_%d", index);
-        auto op = std::make_shared<ge::op::ConcatD>(op_name);
+        auto op = std::make_shared<ge::op::ConcatD>(name);
 
         // set attributes
         int N = inputsWrapper.size();
@@ -387,7 +387,7 @@ class ConcatLayerImpl CV_FINAL : public ConcatLayer
             auto x_i = inputsWrapper[i].dynamicCast<CannBackendWrapper>();
             auto x_i_desc = x_i->getTensorDesc();
             auto op_x_i = nodes[i].dynamicCast<CannBackendNode>()->getOp();
-            op->set_dynamic_input_x(i, *op_x_i, "y");
+            op->set_dynamic_input_x(i, *op_x_i, x_i->name.c_str());
             op->update_dynamic_input_desc_x(i, *x_i_desc);
         }
 
 
@@ -84,7 +84,8 @@ class ConstLayerImpl CV_FINAL : public ConstLayer
     }
 
 #ifdef HAVE_CANN
-    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper,
+                                      const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
     {
         auto mat_shape = shape(blobs[0]);
         std::vector<int64_t> mat_shape_{mat_shape.begin(), mat_shape.end()};
@@ -110,8 +111,7 @@ class ConstLayerImpl CV_FINAL : public ConstLayer
         ge_tensor->SetTensorDesc(*desc);
         ge_tensor->SetData(blobs[0].data, ge_shape.GetShapeSize() * size_of_type);
 
-        std::string op_name = cv::format("const_%d", index);
-        auto op = std::make_shared<ge::op::Const>(op_name);
+        auto op = std::make_shared<ge::op::Const>(name);
         op->set_attr_value(*ge_tensor);
 
         return Ptr<BackendNode>(new CannBackendNode(op));
 
@@ -782,7 +782,8 @@ class ConvolutionLayerImpl CV_FINAL : public BaseConvolutionLayerImpl
     }
 
 #ifdef HAVE_CANN
-    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper, const int index, const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
+    virtual Ptr<BackendNode> initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper,
+                                      const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE
     {
         CV_Assert(!blobs.empty());
         CV_Assert(inputsWrapper.size() == 1);
@@ -791,18 +792,35 @@ class ConvolutionLayerImpl CV_FINAL : public BaseConvolutionLayerImpl
         bool has_bias = hasBias() || fusedBias;
 
         auto x = inputsWrapper[0].dynamicCast<CannBackendWrapper>();
-        const int x_in_channel = x->host->size[1];
+        const auto shape_x = x->host->size; // [b, c, h, w]
         const int filter_out_channel = blobs[0].size[1];
-        const int groups = x_in_channel / filter_out_channel;
+        const int groups = shape_x[1] / filter_out_channel;
 
         // create operator
-        std::string op_name = cv::format("conv2d_%d", index);
-        auto op = std::make_shared<ge::op::Conv2D>(op_name);
+        auto op = std::make_shared<ge::op::Conv2D>(name);
 
         // set attributes
         op->set_attr_strides(ge::Operator::OpListInt(
             {1, 1, (int64_t)strides[0], (int64_t)strides[1]}
         ));
+        // recalculate pads in case of "SAME" padMode with odd pads
+        // since in 'getConvPoolPaddings' pads are divided equally
+        // leading to the loss of one pad
+        if (padMode == "SAME")
+        {
+            for (int i = 0; i < pads_begin.size(); i++) {
+                if (strides[i] <= kernel_size[i])
+                {
+                    int pads_at_i = kernel_size[i] - 1 - (shape_x[i+2] - 1 + strides[i]) % strides[i];
+                    pads_begin[i] = pads_at_i / 2;
+                    // if odd, add extra padding to the end for SAME_UPPER
+                    // or to the beginning for SAME_LOWER. Since here we cannot
+                    // identity SAME_UPPER and SAME_LOWER, extra padding is always
+                    // added to the end.
+                    pads_end[i] = pads_at_i - pads_begin[i];
+                }
+            }
+        }
         op->set_attr_pads(ge::Operator::OpListInt(
             {(int64_t)pads_begin[1], (int64_t)pads_end[1], (int64_t)pads_begin[0], (int64_t)pads_end[0]}
         ));
@@ -815,12 +833,12 @@ class ConvolutionLayerImpl CV_FINAL : public BaseConvolutionLayerImpl
         // set inputs
         // set inputs : x
         auto op_x = nodes[0].dynamicCast<CannBackendNode>()->getOp();
-        op->set_input_x_by_name(*op_x, "y");
+        op->set_input_x_by_name(*op_x, x->name.c_str());
         auto x_desc = x->getTensorDesc();
         op->update_input_desc_x(*x_desc);
         // set inputs : weight
         const Mat& w_mat = blobs[0];
-        auto op_const_weight = std::make_shared<CannConstOp>(w_mat.data, w_mat.type(), shape(w_mat), cv::format("%s_w", op_name.c_str()));
+        auto op_const_weight = std::make_shared<CannConstOp>(w_mat.data, w_mat.type(), shape(w_mat), cv::format("%s_w", name.c_str()));
         op->set_input_filter(*(op_const_weight->getOp()));
         op->update_input_desc_filter(*(op_const_weight->getTensorDesc()));
         // set inputs : bias
@@ -830,7 +848,7 @@ class ConvolutionLayerImpl CV_FINAL : public BaseConvolutionLayerImpl
             Mat b_mat({out_channel}, CV_32F, &biasvec[0]);
 
             std::vector<int> bias_shape{out_channel};
-            auto op_const_bias = std::make_shared<CannConstOp>(b_mat.data, b_mat.type(), bias_shape, cv::format("%s_b", op_name.c_str()));
+            auto op_const_bias = std::make_shared<CannConstOp>(b_mat.data, b_mat.type(), bias_shape, cv::format("%s_b", name.c_str()));
             op->set_input_bias(*(op_const_bias->getOp()));
             op->update_input_desc_bias(*(op_const_bias->getTensorDesc()));
         }
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,8 @@ 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)`
	`87`	`+Ptr<BackendNode> Layer::initCann(const std::vector<Ptr<BackendWrapper> > &inputsWrapper,`
	`88`	`+ const std::vector<Ptr<BackendNode> >& nodes)`
`88`	`89`	`{`
`89`	`90`	`CV_Error(Error::StsNotImplemented, "CANN pipeline of " + type + " layers is not defined.");`
`90`	`91`	`return Ptr<BackendNode>();`