opencv-mark: add vision parity comparison mode (#20)

* opencv-mark: add vision parity comparison mode

Co-authored-by: Cursor <cursoragent@cursor.com>

* Bump openvx-mark version to 1.1.0

Co-authored-by: Cursor <cursoragent@cursor.com>

---------

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: kiritigowda

CHANGELOG.md

@@ -6,6 +6,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [1.1.0] — OpenCV parity comparisons
+
 ### Added — CI fairness, accuracy & timing audit
 
 A single PR that closes the headline credibility gap surfaced when

CMakeLists.txt

@@ -42,7 +42,7 @@ if(NOT DEFINED CMAKE_CXX_COMPILER AND EXISTS "${ROCM_PATH}/lib/llvm/bin/amdclang
     set(CMAKE_CXX_COMPILER ${ROCM_PATH}/lib/llvm/bin/amdclang++)
 endif()
 
-project(openvx-mark VERSION 1.0.0)
+project(openvx-mark VERSION 1.1.0)
 
 # Git commit SHA for version tracking
 execute_process(

include/benchmark_config.h

@@ -23,6 +23,29 @@ inline const std::map<std::string, Resolution>& getResolutionPresets() {
     return presets;
 }
 
+inline const std::vector<std::string>& getVisionParityKernels() {
+    static const std::vector<std::string> kernels = {
+        // Pixel-wise
+        "And", "Or", "Xor", "Not", "AbsDiff", "Add", "Subtract", "Multiply",
+        // Filters
+        "Box3x3", "Gaussian3x3", "Median3x3", "Erode3x3", "Dilate3x3",
+        "Sobel3x3", "CustomConvolution", "NonLinearFilter",
+        // Color
+        "ColorConvert_RGB2IYUV", "ChannelExtract", "ChannelCombine", "ConvertDepth",
+        // Geometric
+        "ScaleImage_Half", "WarpAffine", "WarpPerspective", "Remap",
+        // Statistical
+        "Histogram", "EqualizeHist", "MeanStdDev", "MinMaxLoc", "IntegralImage",
+        // Multi-scale
+        "GaussianPyramid", "LaplacianPyramid", "HalfScaleGaussian",
+        // Features
+        "CannyEdgeDetector", "HarrisCorners", "FastCorners", "OpticalFlowPyrLK",
+        // Misc
+        "Magnitude", "Phase", "TableLookup", "Threshold_Binary", "WeightedAverage",
+    };
+    return kernels;
+}
+
 struct BenchmarkConfig {
     // Resolutions to test
     std::vector<Resolution> resolutions = {

include/system_info.h

@@ -21,6 +21,7 @@ struct SystemInfo {
     std::string vx_extensions;
 
     // Benchmark version tracking
+    std::string benchmark_tool;     // e.g. "openvx-mark" or "opencv-mark"
     std::string benchmark_version;
     std::string benchmark_git_commit;
 

opencv-mark/CMakeLists.txt

@@ -46,7 +46,7 @@
 #
 ################################################################################
 
-find_package(OpenCV 4 QUIET COMPONENTS core imgproc features2d)
+find_package(OpenCV 4 QUIET COMPONENTS core imgproc features2d video)
 if(NOT OpenCV_FOUND)
     message(STATUS "opencv-mark: OpenCV 4 not found — skipping companion binary build.")
     message(STATUS "             Install opencv4 (e.g. apt install libopencv-dev / brew install opencv) to enable.")

opencv-mark/include/opencv_runner.h

@@ -50,6 +50,10 @@ struct CaseBuffers {
     cv::Mat input_extra;   // optional second input (e.g. warp matrix)
     cv::Mat output;
     cv::Mat output_extra;  // optional second output (e.g. Sobel dy)
+    std::vector<cv::Point2f> points_prev;  // optional feature tracks
+    std::vector<cv::Point2f> points_next;
+    std::vector<unsigned char> status;
+    std::vector<float> error;
 };
 
 struct OpenCVBenchmarkCase {

opencv-mark/src/benchmarks/cv_feature.cpp

@@ -20,10 +20,15 @@
 //     dominant cost is the per-pixel detector loop; output extraction
 //     is sub-dominant. We pass nonmaxSuppression=true to match
 //     openvx-mark's vxFastCornersNode default.
+//   * OpticalFlowPyrLK: cv::calcOpticalFlowPyrLK is timed with the same
+//     9x9 window, four pyramid levels, 5 iterations, and 0.01 epsilon
+//     used by openvx-mark's vxOpticalFlowPyrLKNode case.
 
+#include "benchmark_config.h"
 #include "opencv_runner.h"
 #include <opencv2/features2d.hpp>
 #include <opencv2/imgproc.hpp>
+#include <opencv2/video/tracking.hpp>
 #include <vector>
 
 namespace opencv_mark {
@@ -121,6 +126,54 @@ std::vector<OpenCVBenchmarkCase> registerCvFeatureBenchmarks() {
         cases.push_back(bc);
     }
 
+    // OpticalFlowPyrLK — U8 image pair with 100 tracked points.
+    {
+        OpenCVBenchmarkCase bc;
+        bc.name = "OpticalFlowPyrLK";
+        bc.category = "feature";
+        bc.feature_set = "vision";
+        bc.setup_fn = [](uint32_t w, uint32_t h, OpenCVTestData& gen, CaseBuffers& bufs) -> bool {
+            bufs.input = gen.makeU8(w, h);
+            bufs.input_extra = gen.makeU8(w, h);
+            bufs.points_prev.clear();
+            bufs.points_prev.reserve(100);
+            for (int i = 0; i < 100; ++i) {
+                bufs.points_prev.emplace_back(static_cast<float>((i % 10) * (w / 10)),
+                                              static_cast<float>((i / 10) * (h / 10)));
+            }
+            bufs.points_next.resize(bufs.points_prev.size());
+            bufs.status.resize(bufs.points_prev.size());
+            bufs.error.resize(bufs.points_prev.size());
+            return true;
+        };
+        bc.run_fn = [](CaseBuffers& bufs) {
+            cv::calcOpticalFlowPyrLK(
+                bufs.input, bufs.input_extra, bufs.points_prev, bufs.points_next,
+                bufs.status, bufs.error,
+                cv::Size(DEFAULT_OPTFLOW_WINSIZE, DEFAULT_OPTFLOW_WINSIZE),
+                DEFAULT_PYRAMID_LEVELS - 1,
+                cv::TermCriteria(cv::TermCriteria::COUNT | cv::TermCriteria::EPS, 5, 0.01));
+        };
+        bc.verify_fn = []() -> bool {
+            cv::Mat img1(64, 64, CV_8UC1, cv::Scalar(100));
+            cv::Mat img2(64, 64, CV_8UC1, cv::Scalar(100));
+            std::vector<cv::Point2f> prev;
+            for (int i = 0; i < 4; ++i) {
+                prev.emplace_back(static_cast<float>(16 + (i % 2) * 32),
+                                  static_cast<float>(16 + (i / 2) * 32));
+            }
+            std::vector<cv::Point2f> next;
+            std::vector<unsigned char> status;
+            std::vector<float> error;
+            cv::calcOpticalFlowPyrLK(
+                img1, img2, prev, next, status, error,
+                cv::Size(5, 5), 1,
+                cv::TermCriteria(cv::TermCriteria::COUNT | cv::TermCriteria::EPS, 5, 0.01));
+            return status.size() == prev.size();
+        };
+        cases.push_back(bc);
+    }
+
     return cases;
 }
 

opencv-mark/src/benchmarks/cv_filters.cpp

@@ -27,6 +27,10 @@
 //   * `cv::filter2D` for CustomConvolution uses a 3x3 CV_16S kernel
 //     identical to the one openvx-mark feeds vxConvolveNode, with
 //     ddepth=CV_8U, anchor at centre, delta=0, BORDER_REPLICATE.
+//   * `NonLinearFilter` is the OpenVX 1.1 median nonlinear-filter case
+//     with a 3x3 all-ones mask. OpenCV's direct equivalent is another
+//     `cv::medianBlur(..., ksize=3)` row, kept under the OpenVX kernel
+//     name so the 41-kernel parity preset has a one-to-one join target.
 
 #include "opencv_runner.h"
 #include "opencv_verify.h"
@@ -219,6 +223,29 @@ std::vector<OpenCVBenchmarkCase> registerCvFilterBenchmarks() {
         cases.push_back(bc);
     }
 
+    // NonLinearFilter — U8 in, U8 out, median mode with 3x3 all-ones mask.
+    {
+        OpenCVBenchmarkCase bc;
+        bc.name = "NonLinearFilter";
+        bc.category = "filters";
+        bc.feature_set = "vision";
+        bc.setup_fn = [](uint32_t w, uint32_t h, OpenCVTestData& gen, CaseBuffers& bufs) -> bool {
+            bufs.input = gen.makeU8(w, h);
+            bufs.output.create(static_cast<int>(h), static_cast<int>(w), CV_8UC1);
+            return true;
+        };
+        bc.run_fn = [](CaseBuffers& bufs) {
+            cv::medianBlur(bufs.input, bufs.output, /*ksize=*/3);
+        };
+        bc.verify_fn = []() -> bool {
+            cv::Mat in(64, 64, CV_8UC1, cv::Scalar(100));
+            cv::Mat out;
+            cv::medianBlur(in, out, 3);
+            return out.at<uint8_t>(32, 32) == 100;
+        };
+        cases.push_back(bc);
+    }
+
     return cases;
 }
 

opencv-mark/src/main.cpp

@@ -39,6 +39,8 @@ void printUsage(const char* prog) {
     printf("Linked against OpenCV %s\n\n", OPENCV_VERSION_STRING);
 
     printf("Benchmark Selection:\n");
+    printf("  --vision-parity               Run one apples-to-apples row for each of the\n");
+    printf("                                41 OpenVX vision kernels\n");
     printf("  --feature-set SET[,SET,...]   Currently only 'vision' is supported\n");
     printf("  --category CAT[,CAT,...]      Filter by category (filters,color,geometric,\n");
     printf("                                pixelwise,statistical,misc,multiscale,feature)\n");
@@ -103,6 +105,9 @@ bool parseArgs(int argc, char* argv[], BenchmarkConfig& config) {
             // parse failures (mapped to exit 1 by main).
             printUsage(argv[0]);
             std::exit(0);
+        } else if (arg == "--vision-parity") {
+            config.feature_sets = {"vision"};
+            config.kernels = getVisionParityKernels();
         } else if (arg == "--feature-set" && i + 1 < argc) {
             // PR1 only supports the "vision" feature set on the OpenCV
             // side; "framework" and "enhanced_vision" are intentionally
@@ -277,6 +282,7 @@ int main(int argc, char* argv[]) {
     sys_info.vx_vendor_id      = cv_ctx.vendorId();
     sys_info.vx_version        = cv_ctx.version();
     sys_info.vx_extensions     = cv_ctx.buildOptions();
+    sys_info.benchmark_tool = "opencv-mark";
     sys_info.benchmark_version = OPENCV_MARK_VERSION;
     sys_info.benchmark_git_commit = GIT_COMMIT_SHA;
     // Build + threading provenance. cv::getNumThreads() is captured AFTER

scripts/compare_reports.py

@@ -48,6 +48,16 @@ def get_impl_name(report, path='unknown'):
     return report.get('openvx', {}).get('implementation', os.path.basename(path))
 
 
+def get_benchmark_tool(report):
+    return report.get('benchmark', {}).get('tool', '')
+
+
+def is_opencv_report(report):
+    tool = get_benchmark_tool(report).lower()
+    impl = report.get('openvx', {}).get('implementation', '').lower()
+    return tool == 'opencv-mark' or 'opencv' in impl
+
+
 def build_result_map(report):
     """Build a dict keyed by (name, mode, resolution) -> result"""
     result_map = {}
@@ -89,6 +99,18 @@ def compare(reports, paths):
     return impl_names, result_maps, all_keys, system_infos
 
 
+def normalize_report_order(reports, paths):
+    """Use OpenCV as baseline when comparing exactly one OpenCV and one non-OpenCV report."""
+    if len(reports) != 2:
+        return reports, paths
+
+    first_is_opencv = is_opencv_report(reports[0])
+    second_is_opencv = is_opencv_report(reports[1])
+    if second_is_opencv and not first_is_opencv:
+        return [reports[1], reports[0]], [paths[1], paths[0]]
+    return reports, paths
+
+
 def write_markdown(impl_names, result_maps, all_keys, output_path, reports, system_infos=None):
     with open(output_path + '.md', 'w') as f:
         f.write('# OpenVX Benchmark Comparison\n\n')
@@ -562,6 +584,7 @@ def main():
             sys.exit(1)
         reports.append(load_report(path))
 
+    reports, args.reports = normalize_report_order(reports, args.reports)
     impl_names, result_maps, all_keys, system_infos = compare(reports, args.reports)
 
     write_markdown(impl_names, result_maps, all_keys, args.output, reports, system_infos)