potok/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2026-07-21 19:33:03 +04:00
Code Packages Releases Wiki Activity

Merge pull request #29059 from ZNNAXLRQ:Project4_ZHUWanqi

Browse Source 
Improving Parallelism and Memory Access Efficiency for Hough Transform Accumulator #29059

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake

# [Optimization] Improving Parallelism and Memory Access Efficiency for Hough Transform Accumulator

## Overview / Motivation

The original implementation mainly rely on single‑threaded nested loops, which do not fully utilize the computational power of modern multi‑core CPUs. There is also room for improvement in memory access patterns and branch prediction. **Without altering any core mathematical logic or ensuring result consistency**, this work improves the execution efficiency of these two processes by introducing `cv::parallel_for_` and refactoring data access patterns.

---

## Detailed Changes

* **Original Code Analysis**: The original code uses a double loop – the outer loop scans the image for edge points (`if image[...] != 0`), and the inner loop iterates over all angles, computes the radius, and writes to the global `accum` array. This pattern is hard to parallelize directly because different threads writing to the same accumulator would cause **data races**. Moreover, the sparse conditional branch inside the loop is extremely unfriendly to CPU branch prediction.
* **Optimization Strategy (Sparse Extraction → Parallel over Angles)**:
  1. **Sparse Feature Extraction**: First, pre‑scan the image in a single thread, extract the coordinates (`x`, `y`) and values of all non‑zero pixels (edge points) into a contiguous `std::vector` (pre‑allocate 10% of the image size to reduce dynamic reallocation overhead).
  2. **Switch the Parallel Dimension**: Instead of splitting the image region, change the parallelization dimension to **angle (`numangle`)**. Use `cv::parallel_for_` to assign different angle ranges to different threads.
  3. **Conflict‑free Memory Writes**: Because the `accum` array is strictly partitioned by angle `n` in memory, threads assigned to different angles write to completely non‑overlapping memory blocks in the global `accum`.

---

## Correctness Testing
Correctness tests are based on the provided `opencv_test`. For the Hough tests, no failing test cases were observed.

---

## Performance Benchmarks
> The following tests were run on Intel(R) Core(TM) i9‑14900HX @ 2.2GHz / Windows 11 (WSL: Ubuntu) with GCC 13.3.0.
Using `opencv_perf` tests that include Hough, the results are as follows:

| Test Case | 1st mean | 5th mean | Diff |
|-----------|----------|----------|------|
| `PerfHoughCircles.Basic` | 4.75 | 4.91 | +3.4% |
| `PerfHoughCircles2.ManySmallCircles` | 56.76 | 59.37 | +4.6% |
| `PerfHoughCircles4f.Basic` | 4.14 | 4.03 | -2.7% |

#### II. `OCL_HoughLines` (Standard Hough Line, OCL wrapper, actually executed on CPU)

| Parameters (size, rho, theta) | 1st mean | 5th mean | Diff |
|-------------------------------|----------|----------|------|
| (640×480, 0.1, 0.01745) | 2.57 | 3.21 | +24.9% |
| (640×480, 1, 0.1)       | 0.18 | 0.21 | +16.7% |
| (1920×1080, 0.1, 0.01745)|12.27 |15.55 | +26.7% |
| (1920×1080, 1, 0.1)     | 0.69 | 0.99 | +43.5% |
| (3840×2160, 0.1, 0.01745)|28.43 |34.78 | +22.3% |
| (3840×2160, 1, 0.1)     | 2.15 | 3.51 | +63.3% |

#### III. `OCL_HoughLinesP` (Probabilistic Hough Line)

| Image and parameters (rho, theta) | 1st mean | 5th mean | Diff |
|------------------------------------|----------|----------|------|
| pic5.png, 0.1, 0.01745 | 1.20 | 1.22 | +1.7% |
| pic5.png, 1, 0.01745   | 1.03 | 0.92 | -10.7% |
| a1.png, 0.1, 0.01745   | 8.71 | 9.32 | +7.0% |
| a1.png, 1, 0.01745     | 6.29 | 6.68 | +6.2% |

#### IV. Standard Hough Line (CPU implementation, non‑OCL) `Image_RhoStep_ThetaStep_Threshold_HoughLines`

| Parameters (image, rho, theta, thresh) | 1st mean | 5th mean | Diff |
|-----------------------------------------|----------|----------|------|
| pic5.png, 1, 0.01, 0.5        | 2.19 | 0.82 | **-62.6%** |
| pic5.png, 10, 0.01, 0.5       | 2.08 | 0.53 | **-74.5%** |
| pic5.png, 1, 0.1, 0.5         | 0.24 | 0.15 | -37.5% |
| a1.png, 1, 0.01, 0.5          | 16.06 | 2.65 | **-83.5%** |
| a1.png, 10, 0.01, 0.5         | 17.05 | 1.92 | **-88.7%** |
| a1.png, 1, 0.1, 0.5           | 1.82 | 1.00 | -45.1% |

#### V. Floating‑Point Hough Line (`...HoughLines3f`)

| Parameters (image, rho, theta, thresh) | 1st mean | 5th mean | Diff |
|-----------------------------------------|----------|----------|------|
| pic5.png, 1, 0.01, 0.5        | 1.97 | 0.86 | **-56.3%** |
| pic5.png, 10, 0.01, 0.5       | 1.66 | 0.54 | **-67.5%** |
| a1.png, 1, 0.01, 0.5          | 18.52 | 2.59 | **-86.0%** |
| a1.png, 10, 0.01, 0.5         | 16.30 | 2.05 | **-87.4%** |
| a1.png, 1, 0.1, 0.5           | 1.72 | 0.97 | -43.6% |

### Conclusion

- **Circle detection, probabilistic Hough line**: Differences between the two runs are very small (within ±11%), indicating stable performance.
- **`OCL_HoughLines`**: The parallel test is generally 10%~63% slower than the serial one, but still within a reasonable fluctuation range. Special handling was attempted but did not bring significant improvement and slightly reduced the gains in the subsequent two groups, so it was left unchanged after comprehensive consideration.
- **CPU standard Hough line (non‑OCL)**: The parallel test is significantly faster than the serial one (up to 88% faster), demonstrating that parallel optimization can bring obvious improvements.

By the way at last, I am extremely grateful to the maintainers for helping me test the last PR. However, since I was unable to obtain the development board, I was unable to continue modifying the previous RVV optimization.
This commit is contained in:
ZNNAXLRQ
2026-06-12 01:59:32 +08:00
committed by GitHub
parent fa55ed2837
commit cadcb7e4e0
1 changed files with 74 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/imgproc/src/hough.cpp
+74 -23
View File
@@ -184,31 +184,82 @@ HoughLinesStandard( InputArray src, OutputArray lines, int type,
irho, tabSin, tabCos);
// stage 1. fill accumulator
if (use_edgeval) {
for( i = 0; i < height; i++ )
for( j = 0; j < width; j++ )
{
if( image[i * step + j] != 0 )
for(int n = 0; n < numangle; n++ )
{
int r = cvRound( j * tabCos[n] + i * tabSin[n] );
r += (numrho - 1) / 2;
accum[(n + 1) * (numrho + 2) + r + 1] += image[i * step + j];
}
}
// Use the serial implementation for small numangle values to avoid parallel overhead.
constexpr int kParallelAngleThreshold = 100;
if (numangle < kParallelAngleThreshold) {
if (use_edgeval) {
for( i = 0; i < height; i++ )
for( j = 0; j < width; j++ )
{
if( image[i * step + j] != 0 )
for(int n = 0; n < numangle; n++ )
{
int r = cvRound( j * tabCos[n] + i * tabSin[n] );
r += (numrho - 1) / 2;
accum[(n + 1) * (numrho + 2) + r + 1] += image[i * step + j];
}
}
} else {
for( i = 0; i < height; i++ )
for( j = 0; j < width; j++ )
{
if( image[i * step + j] != 0 )
for(int n = 0; n < numangle; n++ )
{
int r = cvRound( j * tabCos[n] + i * tabSin[n] );
r += (numrho - 1) / 2;
accum[(n + 1) * (numrho + 2) + r + 1]++;
}
}
}
} else {
for( i = 0; i < height; i++ )
for( j = 0; j < width; j++ )
{
if( image[i * step + j] != 0 )
for(int n = 0; n < numangle; n++ )
{
int r = cvRound( j * tabCos[n] + i * tabSin[n] );
r += (numrho - 1) / 2;
accum[(n + 1) * (numrho + 2) + r + 1]++;
}
// Extract the coordinates of all edge points
std::vector<int> x_coords, y_coords, edge_vals;
size_t estimated_edges = (size_t)width * (size_t)height / 10;
x_coords.reserve(estimated_edges);
y_coords.reserve(estimated_edges);
if (use_edgeval) {
edge_vals.reserve(estimated_edges);
}
for (int y = 0; y < height; y++) {
const uchar* row_ptr = image + y * step;
for (int x = 0; x < width; x++) {
int val = row_ptr[x];
if (val != 0) {
x_coords.push_back(x);
y_coords.push_back(y);
if (use_edgeval) edge_vals.push_back(val);
}
}
}
}
int num_edges = (int)x_coords.size();
// Perform multi-threaded segmentation according to the numangle
// Since accum is divided into blocks according to angles, the accum areas written by different threads will not overlap
auto process_hough_by_angle = [&](const cv::Range& range) {
for (int n = range.start; n < range.end; n++) {
float cos_n = tabCos[n];
float sin_n = tabSin[n];
int* accum_n = accum + (n + 1) * (numrho + 2) + 1 + (numrho - 1) / 2;
if (use_edgeval) {
for (int k = 0; k < num_edges; k++) {
int r = cvRound(x_coords[k] * cos_n + y_coords[k] * sin_n);
accum_n[r] += edge_vals[k];
}
} else {
for (int k = 0; k < num_edges; k++) {
int r = cvRound(x_coords[k] * cos_n + y_coords[k] * sin_n);
accum_n[r]++;
}
}
}
};
cv::parallel_for_(cv::Range(0, numangle), process_hough_by_angle);
}
// stage 2. find local maximums
findLocalMaximums( numrho, numangle, threshold, accum, _sort_buf );