OpenCV VersionLens: Building a Performance Benchmarking Dashboard for Computer Vision
After building projects around machine learning dashboards, cloud deployment, and trend analytics, I wanted to work on something closer to computer vision and performance engineering.
That idea led me to build OpenCV VersionLens, a benchmarking project designed to compare how different OpenCV versions perform on common image processing operations.
In this version, I focused on building the benchmarking pipeline, collecting the OpenCV 4.x baseline, and creating a dashboard that can support OpenCV 5.x comparison once Python package support is available in the environment.
The goal was simple: instead of just using OpenCV as a library, I wanted to understand how performance changes across versions and how those differences can be measured, visualized, and explained.
Why I Built OpenCV VersionLens
OpenCV is one of the most widely used libraries in computer vision. It is used for image processing, video analysis, object detection, feature extraction, and many other vision tasks.
But when building real-world computer vision systems, performance matters. A small difference in processing time can become important when handling large image datasets, video streams, or real-time applications.
I built OpenCV VersionLens to answer a practical question:
How can OpenCV performance be benchmarked today and compared across versions as new version support becomes available?
Instead of assuming every version behaves the same, I wanted to benchmark operations, collect timing results, and present those results through a dashboard.
Project Overview
OpenCV VersionLens is a benchmarking dashboard designed to compare OpenCV performance across versions using common computer vision tasks such as grayscale conversion, Gaussian blur, Canny edge detection, resizing, thresholding, and contour detection.
The project includes:
Benchmark scripts for OpenCV operations
Baseline results for OpenCV 4.x
Version comparison logic
Performance metrics collection
Streamlit dashboard for visualizing benchmark results
GitHub commits showing the project evolution step by step
The main idea was to turn raw benchmark results into a readable dashboard that makes performance differences easier to understand.
In this version, I built the benchmarking pipeline and collected the OpenCV 4.x baseline. The dashboard is structured to support OpenCV 5.x comparison once Python package support is available in the environment.
OpenCV VersionLens dashboard showing benchmark results, tested operations, total runs, and performance comparison chart.
Tech Stack
The project was built using:
Python for benchmark scripting
OpenCV for image processing operations
NumPy for numerical processing
Pandas for organizing benchmark results
Streamlit for the interactive dashboard
Matplotlib/visualizations for performance comparison
Git and GitHub for version control and project tracking
How the Benchmarking Works
The project runs selected OpenCV operations and measures how long each operation takes to execute.
These operations can include common image processing tasks such as:
Image loading and resizing
Color conversion
Blurring or filtering
Edge detection
Basic transformation operations
Each benchmark captures execution time so that results can be compared across versions.
Instead of looking only at one result, the project stores benchmark outputs in a structured format. This makes it easier to compare, analyze, and visualize performance differences.
Building the Version Comparison
One of the most important parts of the project was building comparison logic.
I started by creating a benchmark runner and collecting a reliable OpenCV 4.x benchmark baseline across common computer vision operations. Since OpenCV 5.x Python support was not available in my current environment, I designed the dashboard so future OpenCV 5.x benchmark results can be added and compared once support becomes available.
This helped me understand that benchmarking is not only about running code once. It also requires consistency, repeatability, and clear result organization.
A benchmark is useful only when the results are easy to reproduce and interpret.
Streamlit Dashboard
To make the benchmark results easier to understand, I built a Streamlit dashboard.
The dashboard presents benchmark results visually instead of leaving them inside raw files or terminal output. This makes it easier to see which operations are faster, slower, or more performance-sensitive.
The dashboard helps answer questions like:
Which OpenCV operation takes the most time?
Which operation is faster in one version compared to another?
How do benchmark results change across versions?
Which tasks may become bottlenecks in a computer vision pipeline?
This made the project feel more complete because the benchmark results became easier to explore and explain.
Preview outputs showing grayscale conversion, Canny edge detection, and Gaussian blur results generated through OpenCV operations.
Challenges I Faced
One challenge was thinking about how to measure performance fairly. Benchmarking can be affected by many factors such as system load, hardware, package versions, and how many times the operation is repeated.
Another challenge was organizing the results in a way that made comparison simple. Raw timing values are useful, but they become much more meaningful when presented through charts and summaries.
I also learned how important it is to structure a project cleanly so that scripts, results, and dashboard files are easy to understand.
What I Learned
OpenCV VersionLens helped me learn more about computer vision from an engineering perspective.
Some of my biggest takeaways were:
How to benchmark OpenCV operations
How to measure execution time for image processing tasks
How to compare performance across versions or runs
How to organize benchmark results using structured data
How to build a Streamlit dashboard for performance visualization
How to think about optimization and bottlenecks in computer vision systems
This project helped me understand that computer vision is not only about algorithms. It is also about performance, speed, reliability, and making results easy to analyze.
Why This Project Matters
In real-world computer vision systems, performance can directly affect user experience.
For example, a video analytics system, object detection pipeline, or image processing service may need to process many frames quickly. If one operation becomes slow, the entire pipeline can become inefficient.
OpenCV VersionLens gave me a practical way to study these performance differences and think about how computer vision systems behave beyond just correctness.
What’s Next
There are several improvements I would like to add to this project:
Add benchmarks for more OpenCV operations
Compare multiple OpenCV versions side by side
Add repeated trials and average execution time
Include CPU and memory usage metrics
Add support for video-based benchmarks
Deploy the Streamlit dashboard publicly
Conclusion
OpenCV VersionLens was a practical project that helped me explore computer vision performance benchmarking.
By building benchmark scripts, collecting results, comparing performance, and visualizing everything through a Streamlit dashboard, I learned how to think about OpenCV from both a developer and performance engineering perspective.
This project helped me move beyond simply using OpenCV and understand how to evaluate its behavior in a more structured way.
Project Links
GitHub Repository: OpenCV VersionLens
Live Demo: Coming Soon
