In digital image processing, calculating the gradient of an image is a fundamental step for edge detection and sharpening. This process involves finding the intensity changes between neighboring pixels. Below are two methods to implement this using C++ and the OpenCV library: a manual pixel-iteration approach and a more optiimzed approach using the built-in Sobel operator.

Method 1: Manual Central Difference Implemnetation

This approach manually iterates through the pixel matrix to calculate the difference between adjacent pixels. We use a central difference approximation to estimate the horizontal gradient. For boundary pixels where neighbor are missing, the output is set to zero to avoid out-of-bounds errors.

#include <opencv2/opencv.hpp>
#include <iostream>

/**
 * Calculates the horizontal gradient using central difference.
 * Logic: G(x, y) = I(x + 1, y) - I(x - 1, y)
 */
cv::Mat computeManualGradient(const cv::Mat& inputFrame) {
    cv::Mat srcGray, gradResult;
    
    // Convert to grayscale for gradient calculation
    cv::cvtColor(inputFrame, srcGray, cv::COLOR_BGR2GRAY);
    gradResult = cv::Mat::zeros(srcGray.size(), srcGray.type());

    for (int r = 1; r < srcGray.rows - 1; ++r) {
        for (int c = 1; c < srcGray.cols - 1; ++c) {
            // Calculate difference between right and left neighbors
            int delta = srcGray.at<uchar>(r, c + 1) - srcGray.at<uchar>(r, c - 1);
            
            // Constrain the value between 0 and 255
            gradResult.at<uchar>(r, c) = cv::saturate_cast<uchar>(std::abs(delta));
        }
    }
    return gradResult;
}

int main() {
    cv::Mat image = cv::imread("source_image.jpg");
    if (image.empty()) {
        std::cerr << "Error: Could not load image." << std::endl;
        return -1;
    }

    cv::Mat edgeMap = computeManualGradient(image);
    
    cv::imshow("Original", image);
    cv::imshow("Horizontal Gradient", edgeMap);
    cv::waitKey(0);
    return 0;
}

Method 2: Bidirectional Gradient using the Sobel Operator

The Sobel operator is a more robust method that applies a specific kernel to compute gradients in both horizontal (X) and vertical (Y) directions. By calculating the magnitude of these combined vectors, we can detect edges at any orientation.

The cv::Sobel function utilizes the following parameters:

• ddepth: Output image depth. Using CV_16S prevents overflow during subtraction.
• dx / dy: The order of the derivative in the respective directions.
• ksize: The size of the extended Sobel kernel (e.g., 1, 3, 5, or 7).

#include <opencv2/opencv.hpp>
#include <iostream>
#include <cmath>

cv::Mat applySobelEdgeDetection(const cv::Mat& inputImage) {
    cv::Mat gray, gradX, gradY;
    cv::cvtColor(inputImage, gray, cv::COLOR_BGR2GRAY);

    // Compute gradients in X and Y directions
    // We use CV_16S to handle potential negative values and overflows
    cv::Sobel(gray, gradX, CV_16S, 1, 0, 3);
    cv::Sobel(gray, gradY, CV_16S, 0, 1, 3);

    cv::Mat magnitude = cv::Mat::zeros(gray.size(), gray.type());

    for (int i = 0; i < gray.rows; ++i) {
        for (int j = 0; j < gray.cols; ++j) {
            short valX = gradX.at<short>(i, j);
            short valY = gradY.at<short>(i, j);
            
            // Combine gradients: Mag = sqrt(dx^2 + dy^2)
            float combined = std::sqrt(static_cast<float>(valX * valX + valY * valY));
            magnitude.at<uchar>(i, j) = cv::saturate_cast<uchar>(combined);
        }
    }

    return magnitude;
}

int main() {
    cv::Mat source = cv::imread("source_image.jpg");
    if (source.empty()) return -1;

    cv::Mat result = applySobelEdgeDetection(source);

    cv::imshow("Sobel Magnitude", result);
    cv::waitKey(0);
    return 0;
}

The manual approach is useful for understanding the underlying math of spatial filtering, while the Sobel operator provides a more computationally efficient and noise-resistant result suitable for professional computer vision applications.