opencv
diff --git a/‎modules/dnn/include/opencv2/dnn/all_layers.hpp
Copy file name to clipboard
+10Lines changed: 10 additions & 0 deletions b/‎modules/dnn/include/opencv2/dnn/all_layers.hpp
Copy file name to clipboard
+10Lines changed: 10 additions & 0 deletions
diff --git a/‎modules/dnn/src/cuda4dnn/csl/tensor.hpp
Copy file name to clipboard
+12-17Lines changed: 12 additions & 17 deletions b/‎modules/dnn/src/cuda4dnn/csl/tensor.hpp
Copy file name to clipboard
+12-17Lines changed: 12 additions & 17 deletions
diff --git a/‎modules/dnn/src/cuda4dnn/primitives/depth_space_ops.hpp
Copy file name to clipboard
+76Lines changed: 76 additions & 0 deletions b/‎modules/dnn/src/cuda4dnn/primitives/depth_space_ops.hpp
Copy file name to clipboard
+76Lines changed: 76 additions & 0 deletions
diff --git a/‎modules/dnn/src/init.cpp
Copy file name to clipboard
+4Lines changed: 4 additions & 0 deletions b/‎modules/dnn/src/init.cpp
Copy file name to clipboard
+4Lines changed: 4 additions & 0 deletions
@@ -1188,6 +1188,16 @@ CV__DNN_INLINE_NS_BEGIN
         static Ptr<GroupNormLayer> create(const LayerParams &params);
     };
 
+    class CV_EXPORTS DepthToSpaceLayer : public Layer {
+    public:
+        static Ptr<DepthToSpaceLayer> create(const LayerParams &params);
+    };
+
+    class CV_EXPORTS SpaceToDepthLayer : public Layer {
+    public:
+        static Ptr<SpaceToDepthLayer> create(const LayerParams &params);
+    };
+
 //! @}
 //! @}
 CV__DNN_INLINE_NS_END
 
@@ -265,7 +265,6 @@ namespace cv { namespace dnn { namespace cuda4dnn { namespace csl {
         typename std::enable_if<cxx_utils::is_forward_iterator<ForwardItr>::value, void>
         ::type reshape(ForwardItr start, ForwardItr end) {
             CV_Assert(start != end);
-            CV_Assert(std::distance(start, end) <= rank());
 
             using ItrValueType = typename std::iterator_traits<ForwardItr>::value_type;
 
@@ -284,6 +283,7 @@ namespace cv { namespace dnn { namespace cuda4dnn { namespace csl {
             auto total = std::accumulate(start, end, 1, std::multiplies<ItrValueType>());
             if (total < 0) {
                 /* there is an unknown size */
+                CV_CheckEQ(size() % std::abs(total), static_cast<size_type>(0), "cannot be reshaped"); // must be divisible
                 if (std::abs(total) <= size()) {
                     unknown_size = size() / std::abs(total);
                     total = size();
@@ -298,11 +298,9 @@ namespace cv { namespace dnn { namespace cuda4dnn { namespace csl {
                 CV_Error(Error::StsBadArg, "new axes do not preserve the tensor element count");
             }
 
-            /* we assume the size of the unspecified axes to be one */
-            std::fill(std::begin(shape), std::end(shape), 1);
-            std::copy_backward(start, end, std::end(shape));
-
-            /* replace the unknown axis with the correct value */
+            /* copy shape from given iterator and reshape -1 with deduced value */
+            shape.resize(std::distance(start, end));
+            std::copy(start, end, shape.begin());
             std::replace(std::begin(shape), std::end(shape), size_type(-1), unknown_size);
         }
 
@@ -600,6 +598,7 @@ namespace cv { namespace dnn { namespace cuda4dnn { namespace csl {
             auto total = std::accumulate(start, end, 1, std::multiplies<ItrValueType>());
             if (total < 0) {
                 /* there is an unknown size */
+                CV_CheckEQ(size() % std::abs(total), static_cast<size_type>(0), "cannot be reshaped"); // must be divisible
                 if (std::abs(total) <= size()) {
                     unknown_size = size() / std::abs(total);
                     total = size();
@@ -614,11 +613,9 @@ namespace cv { namespace dnn { namespace cuda4dnn { namespace csl {
                CV_Error(Error::StsBadArg, "new axes do not preserve the tensor element count");
             }
 
-            /* we assume the size of the unspecified axes to be one */
-            std::fill(std::begin(shape), std::end(shape), 1);
-            std::copy_backward(start, end, std::end(shape));
-
-            /* replace the unknown axis with the correct value */
+            /* copy shape from given iterator and reshape -1 with deduced value */
+            shape.resize(std::distance(start, end));
+            std::copy(start, end, shape.begin());
             std::replace(std::begin(shape), std::end(shape), size_type(-1), unknown_size);
         }
 
@@ -946,7 +943,6 @@ namespace cv { namespace dnn { namespace cuda4dnn { namespace csl {
         typename std::enable_if<!std::is_integral<ForwardItr>::value, void>
         ::type reshape(ForwardItr start, ForwardItr end) {
             CV_Assert(start != end);
-            CV_Assert(std::distance(start, end) <= rank());
 
             using ItrValueType = typename std::iterator_traits<ForwardItr>::value_type;
 
@@ -965,6 +961,7 @@ namespace cv { namespace dnn { namespace cuda4dnn { namespace csl {
             auto total = std::accumulate(start, end, 1, std::multiplies<ItrValueType>());
             if (total < 0) {
                 /* there is an unknown size */
+                CV_CheckEQ(size() % std::abs(total), static_cast<size_type>(0), "cannot be reshaped"); // must be divisible
                 if (std::abs(total) <= size()) {
                     unknown_size = size() / std::abs(total);
                     total = size();
@@ -979,11 +976,9 @@ namespace cv { namespace dnn { namespace cuda4dnn { namespace csl {
                 CV_Error(Error::StsBadArg, "new axes do not preserve the tensor element count");
             }
 
-            /* we assume the size of the unspecified axes to be one */
-            std::fill(std::begin(shape), std::end(shape), 1);
-            std::copy_backward(start, end, std::end(shape));
-
-            /* replace the unknown axis with the correct value */
+            /* copy shape from given iterator and reshape -1 with deduced value */
+            shape.resize(std::distance(start, end));
+            std::copy(start, end, shape.begin());
             std::replace(std::begin(shape), std::end(shape), size_type(-1), unknown_size);
         }
 
 
@@ -0,0 +1,76 @@
+// 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 https://opencv.org/license.html.
+
+#ifndef OPENCV_DNN_SRC_CUDA4DNN_PRIMITIVES_DEPTH_SPACE_OPS_HPP
+#define OPENCV_DNN_SRC_CUDA4DNN_PRIMITIVES_DEPTH_SPACE_OPS_HPP
+
+#include "../../op_cuda.hpp"
+
+#include "../csl/stream.hpp"
+#include "../csl/tensor.hpp"
+#include "../csl/tensor_ops.hpp"
+#include "../csl/memory.hpp"
+#include "../kernels/permute.hpp"
+
+#include <utility>
+
+namespace cv { namespace dnn { namespace cuda4dnn {
+
+    template <class T>
+    class DepthSpaceOps final : public CUDABackendNode {
+    public:
+        using wrapper_type = GetCUDABackendWrapperType<T>;
+
+        DepthSpaceOps(csl::Stream stream_, const std::vector<int> &internal_shape_,
+                     const std::vector<size_t> &permutation_)
+            : stream(std::move(stream_)), internal_shape(internal_shape_),
+              permutation(permutation_)
+        {
+            transposed_internal_shape = std::vector<int>(internal_shape.size());
+            for (size_t i = 0; i < permutation.size(); i++) {
+                transposed_internal_shape[i] = internal_shape[permutation[i]];
+            }
+
+            size_t num_elements = std::accumulate(internal_shape.begin(), internal_shape.end(), 1, std::multiplies<size_t>());
+            csl::WorkspaceBuilder builder;
+            builder.require<T>(num_elements);
+            scratch_mem_in_bytes = builder.required_workspace_size();
+        }
+
+        void forward(const std::vector<cv::Ptr<BackendWrapper>> &inputs,
+                     const std::vector<cv::Ptr<BackendWrapper>> &outputs,
+                     csl::Workspace &workspace) override {
+            CV_CheckEQ(inputs.size(), size_t(1), "DepthSpaceOps: only one input is accepted");
+            CV_CheckEQ(outputs.size(), size_t(1), "DepthSpaceOps: only one output is accepted");
+
+            auto input_wrapper = inputs.front().dynamicCast<wrapper_type>();
+            auto input = input_wrapper->getView();
+            CV_CheckEQ(input.rank(), size_t(4), "DepthSpaceOps: input needs to be 4-dimensional [N, C, H, W]");
+            auto output_wrapper = outputs.front().dynamicCast<wrapper_type>();
+            auto output = output_wrapper->getSpan();
+            auto ws_allocator = csl::WorkspaceAllocator(workspace);
+            auto transposed_internal = ws_allocator.get_tensor_span<T>(transposed_internal_shape.begin(), transposed_internal_shape.end());
+
+            // Call reshape on input so that it has the correct shape for permutation
+            input.reshape(internal_shape.begin(), internal_shape.end());
+            kernels::permute(stream, transposed_internal, input, permutation);
+            // Only copying is needed as output already has the expected shape
+            auto t = csl::TensorView<T>(transposed_internal);
+            csl::memcpy(output.get(), t.get(), output.size(), stream);
+        }
+
+        std::size_t get_workspace_memory_in_bytes() const noexcept override { return scratch_mem_in_bytes; }
+
+    private:
+        csl::Stream stream;
+        std::vector<int> internal_shape;
+        std::vector<size_t> permutation;
+        std::vector<int> transposed_internal_shape;
+
+        std::size_t scratch_mem_in_bytes;
+    };
+
+}}} // namespace cv::dnn::cuda4dnn
+
+#endif // OPENCV_DNN_SRC_CUDA4DNN_PRIMITIVES_DEPTH_SPACE_OPS_HPP
@@ -164,6 +164,10 @@ void initializeLayerFactory()
     CV_DNN_REGISTER_LAYER_CLASS(InstanceNormalization, InstanceNormLayer);
     CV_DNN_REGISTER_LAYER_CLASS(Attention,      AttentionLayer);
     CV_DNN_REGISTER_LAYER_CLASS(GroupNormalization, GroupNormLayer);
+    CV_DNN_REGISTER_LAYER_CLASS(DepthToSpace,   DepthToSpaceLayer)
+    CV_DNN_REGISTER_LAYER_CLASS(SpaceToDepth,   SpaceToDepthLayer)
+    CV_DNN_REGISTER_LAYER_CLASS(DepthToSpaceInt8, DepthToSpaceLayer)
+    CV_DNN_REGISTER_LAYER_CLASS(SpaceToDepthInt8, SpaceToDepthLayer)
 
     CV_DNN_REGISTER_LAYER_CLASS(Crop,           CropLayer);
     CV_DNN_REGISTER_LAYER_CLASS(Eltwise,        EltwiseLayer);