Optimizing Image Processing in OpenCV: Using cv::Mat with Reference Counting Mechanisms and C++ ref qualifiers

Question

I have questions regarding this code:

As the cv::Mat copy constructor involves only pointer copying due to the reference counting mechanism, in the Apply method I return by copy instead of explicitly using std::move. This is because I also wanted to avoid moving the data member from the class.

Also, in the getters, I chose not to return by copy since the client code could modify the internal data by having a pointer. Therefore, I used a const reference. Additionally, for getters, I used reference qualifiers because returning a reference from instances of the rvalue category could cause dangling in some situations.

Am I right? are designs accurate?

EDIT Regarding why not a stand-alone function:

I considered using a class to encapsulate everything instead of having separate functions. Does that make sense?

load an image Apply CLAHE

converted to grayscale.

apply Gaussian blur.

apply Canny edge detection.

apply Hough Line Transform

List if lines it finds Draw lines

// Header

 #ifndef GAUSSIANBLURFILTER_H #define GAUSSIANBLURFILTER_H #include <opencv2/opencv.hpp> #include <optional> class GaussianBlurFilter { public: GaussianBlurFilter(); // Disables copy and move constructors. GaussianBlurFilter(const GaussianBlurFilter&) = delete; cv::Mat getBlurredImage() && { return std::move(m_blurredImage); } const cv::Mat& getBlurredImage() const & { return m_blurredImage; } [[nodiscard]] std::optional<cv::Mat> Apply(const cv::Mat& src); private: constexpr static double SIGMA = 2.5; constexpr static int KERNEL_DIMENSION = 3; inline const static cv::Size KERNEL_SIZE = cv::Size(KERNEL_DIMENSION, KERNEL_DIMENSION); cv::Mat m_blurredImage; }; 

// source

 #include "gaussianblurfilter.h" GaussianBlurFilter::GaussianBlurFilter() : m_blurredImage() {} [[nodiscard]] std::optional<cv::Mat> GaussianBlurFilter::Apply(const cv::Mat& src) { if (src.empty()) { return std::nullopt; } cv::GaussianBlur(src, m_blurredImage, GaussianBlurFilter::KERNEL_SIZE, GaussianBlurFilter::SIGMA); return m_blurredImage; } 

Answer 1

The r-value qualified getBlurredImage() is not wrong, but there is a much simpler approach:

Why not create a stand-alone function?

Why is this a class to begin with? I would just make a stand-alone function that blurs an image:

cv::Mat guassianBlur(const cv::Mat& src) { constexpr static double SIGMA = 2.5; constexpr static int KERNEL_DIMENSION = 3; const static cv::Size KERNEL_SIZE = cv::Size(KERNEL_DIMENSION, KERNEL_DIMENSION); cv::Mat blurredImage; cv::GaussianBlur(src, blurredImage, KERNEL_SIZE, SIGMA); return blurredImage; } 

Now you don't need to worry about copying or moving at all; return value optimization will ensure there is only one image constructed, and nothing is moved or copied. So this is optimal, regardless of whether cv::Mat uses reference counting or not.

Other issues

• Instead of returning a std::optional<cv::Mat>, why not return an empty image if src.empty()?
• Why is Apply() marked [[nodiscard]] if the blurred image is kept stored in the GaussianBlurFilter and can be retrieved by getBlurredImage()? I would rather make both getBlurredImage() functions [[noexcept]].
• Why does Apply() start with an upper case letter, but getBlurredImage() with a lower case one? Be consistend with your naming conventions.
• Why delete the copy and move constructors? There doesn't seem anything wrong with keeping them.