feat: adding code for release v0.8.0 of CV-CUDA

Author: dlesage-nvidia

.pre-commit-config.yaml

@@ -23,7 +23,7 @@ endif()
 
 project(cvcuda
         LANGUAGES C CXX
-        VERSION 0.7.0
+        VERSION 0.8.0
         DESCRIPTION "CUDA-accelerated Computer Vision algorithms"
 )
 

CMakeLists.txt

@@ -16,7 +16,7 @@
 
 # Contributing to CV-CUDA
 
-**As of release v0.7.0-beta, CV-CUDA is not accepting outside contribution.**
+**Currently, CV-CUDA is not accepting outside contributions.**
 
 Contributions to CV-CUDA fall into the following categories:
 
@@ -28,8 +28,8 @@ Contributions to CV-CUDA fall into the following categories:
 1. To propose a new feature, please file a new feature request
    [issue](https://github.com/CVCUDA/CV-CUDA/issues/new/choose). Describe the
    intended feature and discuss the design and implementation with the team and
-   community. NOTE: Currently, as of release v0.7.0-beta, CV-CUDA is not accepting
-   outside contribution.
+   community. NOTE: Currently, CV-CUDA is not accepting
+   outside contributions.
 1. To ask a general question, please sumbit a question
    [issue](https://github.com/CVCUDA/CV-CUDA/issues/new/choose). If you need
    more context on a particular issue, please ask in a comment.

CONTRIBUTING.md

@@ -80,6 +80,7 @@ CV-CUDA includes:
 | Reformat | Converts a planar image into non-planar and vice versa |
 | Remap | Maps pixels in an image with one projection to another projection in a new image. |
 | Resize | Changes the size and scale of an image |
+| ResizeCropConvertReformat | Performs fused Resize-Crop-Convert-Reformat sequence with optional channel reordering |
 | Rotate | Rotates a 2D array in multiples of 90 degrees |
 | SIFT | Identifies and describes features in images that are invariant to scale rotation and affine distortion. |
 | Thresholding | Chooses a global threshold value that is the same for all pixels across the image. |

DEVELOPER_GUIDE.md

@@ -18,7 +18,7 @@
 
 [![License](https://img.shields.io/badge/License-Apache_2.0-yellogreen.svg)](https://opensource.org/licenses/Apache-2.0)
 
-![Version](https://img.shields.io/badge/Version-v0.7.0--beta-blue)
+![Version](https://img.shields.io/badge/Version-v0.8.0--beta-blue)
 
 ![Platform](https://img.shields.io/badge/Platform-linux--64_%7C_win--64_wsl2%7C_aarch64-gray)
 
@@ -76,10 +76,10 @@ Choose the installation method that meets your environment needs.
 
 Download the appropriate .whl file for your computer architecture, Python and CUDA version from the release assets of current CV-CUDA release. Release information of all CV-CUDA releases can be found [here][CV-CUDA GitHub Releases]. Once downloaded, execute the `pip install` command to install the Python wheel. For example:
    ```shell
-   pip install cvcuda_<cu_ver>-0.7.0b0-cp<py_ver>-cp<py_ver>-linux_<arch>.whl
+   pip install cvcuda_<cu_ver>-<x.x.x>-cp<py_ver>-cp<py_ver>-linux_<arch>.whl
    ```
 
-where `<cu_ver>` is the desired CUDA version, `<py_ver>` is the desired Python version and `<arch>` is the desired architecture.
+where `<cu_ver>` is the desired CUDA version, `<x.x.x>` is the CV-CUDA release version, `<py_ver>` is the desired Python version and `<arch>` is the desired architecture.
 
 Please note that the Python wheels are standalone, they include both the C++/CUDA libraries and the Python bindings.
 
@@ -185,8 +185,8 @@ Install the dependencies required to  build the documentation:
 
 On Ubuntu, install the following packages using `apt` and `pip`:
 ```shell
-apt install -y doxygen graphviz python3 python3-pip
-python3 -m pip install sphinx==4.5.0 breathe exhale recommonmark graphviz sphinx-rtd-theme
+apt install -y doxygen graphviz python3 python3-pip sphinx
+python3 -m pip install breathe exhale recommonmark graphviz sphinx-rtd-theme
 ```
 
 Build the documentation:
@@ -249,7 +249,7 @@ pip install cvcuda_cu12-<x.x.x>-cp310-cp310-linux_x86_64.whl
 
 CV-CUDA is an open source project. As part of the Open Source Community, we are
 committed to the cycle of learning, improving, and updating that makes this
-community thrive. However, as of release v0.7.0-beta, CV-CUDA is not yet ready
+community thrive. However, CV-CUDA is not yet ready
 for external contributions.
 
 To understand the process for contributing the CV-CUDA, see our

README.md

@@ -0,0 +1,124 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "BenchUtils.hpp"
+
+#include <cvcuda/OpResizeCropConvertReformat.hpp>
+#include <nvcv/cuda/TypeTraits.hpp>
+
+#include <nvbench/nvbench.cuh>
+
+template<typename T>
+inline void ResizeCropConvertReformat(nvbench::state &state, nvbench::type_list<T>)
+try
+{
+    long3 srcShape = benchutils::GetShape<3>(state.get_string("shape"));
+    long  varShape = state.get_int64("varShape");
+
+    NVCVInterpolationType interpType = benchutils::GetInterpolationType(state.get_string("interpolation"));
+
+    int2 cropPos{1, 1};
+
+    NVCVSize2D resize;
+
+    if (state.get_string("resizeType") == "EXPAND")
+    {
+        resize = NVCVSize2D{(int)(srcShape.y * 2), (int)(srcShape.z * 2)};
+    }
+    else if (state.get_string("resizeType") == "CONTRACT")
+    {
+        resize = NVCVSize2D{(int)(srcShape.y / 2), (int)(srcShape.z / 2)};
+    }
+    else
+    {
+        throw std::invalid_argument("Invalid resizeType = " + state.get_string("resizeType"));
+    }
+
+    NVCVChannelManip manip;
+
+    if (state.get_string("manip") == "NO_OP")
+    {
+        manip = NVCV_CHANNEL_NO_OP;
+    }
+    else if (state.get_string("manip") == "REVERSE")
+    {
+        manip = NVCV_CHANNEL_REVERSE;
+    }
+    else
+    {
+        throw std::invalid_argument("Invalid channel manipulation = " + state.get_string("manip"));
+    }
+
+    using BT = nvcv::cuda::BaseType<T>;
+    long nc  = nvcv::cuda::NumElements<T>;
+
+    long3 dstShape{srcShape.x, resize.h - cropPos.y, resize.w - cropPos.x};
+
+    if (dstShape.y <= 0 || dstShape.z <= 0)
+    {
+        throw std::invalid_argument("Invalid shape and resizeType");
+    }
+
+    state.add_global_memory_reads(srcShape.x * srcShape.y * srcShape.z * sizeof(T));
+    state.add_global_memory_writes(dstShape.x * dstShape.y * dstShape.z * sizeof(T));
+
+    cvcuda::ResizeCropConvertReformat op;
+
+    // clang-format off
+
+    if (varShape < 0) // negative var shape means use Tensor
+    {
+        nvcv::Tensor src({{srcShape.x, srcShape.y, srcShape.z, nc}, "NHWC"}, benchutils::GetDataType<BT>());
+        nvcv::Tensor dst({{dstShape.x, dstShape.y, dstShape.z, nc}, "NHWC"}, benchutils::GetDataType<BT>());
+
+        benchutils::FillTensor<T>(src, benchutils::RandomValues<T>());
+
+        state.exec(nvbench::exec_tag::sync, [&op, &src, &dst, &resize, &interpType, &cropPos, &manip](nvbench::launch &launch)
+        {
+            op(launch.get_stream(), src, dst, resize, interpType, cropPos, manip);
+        });
+    }
+    else // zero and positive var shape means use ImageBatchVarShape
+    {
+        nvcv::ImageBatchVarShape src(srcShape.x);
+        nvcv::Tensor dst({{dstShape.x, dstShape.y, dstShape.z, nc}, "NHWC"}, benchutils::GetDataType<BT>());
+
+        benchutils::FillImageBatch<T>(src, long2{srcShape.z, srcShape.y}, long2{varShape, varShape},
+                                      benchutils::RandomValues<T>());
+
+        state.exec(nvbench::exec_tag::sync, [&op, &src, &dst, &resize, &interpType, &cropPos, &manip](nvbench::launch &launch)
+        {
+            op(launch.get_stream(), src, dst, resize, interpType, cropPos, manip);
+        });
+    }
+}
+catch (const std::exception &err)
+{
+    state.skip(err.what());
+}
+
+// clang-format on
+
+using ResizeCropConvertReformatTypes = nvbench::type_list<uchar3>;
+
+NVBENCH_BENCH_TYPES(ResizeCropConvertReformat, NVBENCH_TYPE_AXES(ResizeCropConvertReformatTypes))
+    .set_type_axes_names({"InOutDataType"})
+    .add_string_axis("shape", {"1x1080x1920"})
+    .add_int64_axis("varShape", {-1, 0})
+    .add_string_axis("resizeType", {"EXPAND"})
+    .add_string_axis("manip", {"NO_OP"})
+    .add_string_axis("interpolation", {"LINEAR"});

bench/BenchResizeCropConvertReformat.cpp

@@ -51,6 +51,7 @@ set(bench_sources
     BenchConvertTo.cpp
     BenchCopyMakeBorder.cpp
     BenchCropFlipNormalizeReformat.cpp
+    BenchResizeCropConvertReformat.cpp
     BenchCustomCrop.cpp
     BenchErase.cpp
     BenchGammaContrast.cpp

bench/CMakeLists.txt

@@ -0,0 +1,38 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import nvcv
+
+# NOTE: One must import PyCuda driver first, before CVCUDA or VPF otherwise
+# things may throw unexpected errors.
+import pycuda.driver as cuda  # noqa: F401
+from bench_utils import AbstractOpBase
+
+
+class OpAsImageFromNVCVImage(AbstractOpBase):
+    def setup(self, input):
+        # dummy run that does not use cache
+        img = nvcv.Image((128, 128), nvcv.Format.RGBA8)
+
+        self.imglist = []
+        for _ in range(10):
+            img = nvcv.Image((128, 128), nvcv.Format.RGBA8)
+            self.imglist.append(img.cuda())
+        self.cycle = 0
+
+    def run(self, input):
+        nvcv.as_image(self.imglist[self.cycle % len(self.imglist)])
+        self.cycle += 1
+        return

bench/python/all_ops/op_as_image.py

@@ -0,0 +1,42 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import nvcv
+
+# NOTE: One must import PyCuda driver first, before CVCUDA or VPF otherwise
+# things may throw unexpected errors.
+import pycuda.driver as cuda  # noqa: F401
+from bench_utils import AbstractOpBase
+
+
+class OpAsImagesFromNVCVImage(AbstractOpBase):
+    def setup(self, input):
+        # dummy run that does not use cache
+        nvcv.ImageBatchVarShape(100)
+        img = nvcv.Image((128, 128), nvcv.Format.RGBA8)
+
+        self.imglists = []
+        for _ in range(10):
+            imglist = []
+            for _ in range(100):
+                img = nvcv.Image((128, 128), nvcv.Format.RGBA8)
+                imglist.append(img.cuda())
+            self.imglists.append(imglist)
+        self.cycle = 0
+
+    def run(self, input):
+        nvcv.as_images(self.imglists[self.cycle % len(self.imglists)])
+        self.cycle += 1
+        return