threading is managed by context passed to functions

Author: RomanJuranek

src/autorectify.cpp

@@ -100,17 +100,20 @@ void draw_lines(II first, II last, Mat & image)
         else
         {
             clr = colors[(g)%12];
-            w = 3;
+            w = 1;
         }
         line(image, cv::Point(l.x1, l.y1), cv::Point(l.x2, l.y2), clr, w);
-        circle(image, cv::Point(l.x1, l.y1), 7, clr, -1);
-        circle(image, cv::Point(l.x2, l.y2), 7, clr, -1);
+        circle(image, cv::Point(l.x1, l.y1), 3, clr, -1);
+        circle(image, cv::Point(l.x2, l.y2), 3, clr, -1);
         ++first;
     }
 }
 
 // Wrapper for find_line_segment_groups accepting OpenCV images of any size
-LineSegment * detect_line_groups(const Mat & image, int max_size, bool refine, int * n_lines)
+LineSegment * detect_line_groups(
+    const Mat & image, int max_size, bool refine,
+    int num_threads,
+    int * n_lines)
 {
     Mat image_f = image;
     image.convertTo(image_f, CV_32F, 1/256.0);
@@ -124,7 +127,7 @@ LineSegment * detect_line_groups(const Mat & image, int max_size, bool refine, i
     int stride = w;
     int min_length = float(max(h,w)) / 100.0f;
 
-    LineSegment * lines = find_line_segment_groups(buffer, w, h, stride, min_length, refine, n_lines);
+    LineSegment * lines = find_line_segment_groups(buffer, w, h, stride, min_length, refine, num_threads, n_lines);
 
     // Scale lines back to the original image
     for (size_t i = 0; i < *n_lines; ++i)
@@ -322,14 +325,11 @@ int main(int argc, char ** argv)
 
     ///////////////////////////////////////////////////////////////////////////
 
-    // Set number of threads for parallelization
-    set_num_threads(opts.num_threads);
-
     // Detect lines in image
 
     std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now();
-    int n_lines = 0;
-    LineSegment * lines = detect_line_groups(image_8uc, opts.max_image_size, opts.refine_lines, &n_lines);
+   int n_lines = 0;
+    LineSegment * lines = detect_line_groups(image_8uc, opts.max_image_size, opts.refine_lines, opts.num_threads, &n_lines);
     // Now we have n_lines segments lines[0] .. lines[n_lines-1]
     // We can modify them, e.g. add user defined lines (remember to assign them to the correct group)
     std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();

src/filter.cpp

@@ -26,27 +26,33 @@ using namespace std;
 namespace librectify {
 
 
-void maximum_filter(const Image & image, Image & out, int size)
+void maximum_filter(
+    const Image & image, Image & out, int size,
+    const ThreadContext & ctx
+    )
 {
     int n = 2*size+1;
     out.resizeLike(image);
     out.setZero();
     #ifdef _OPENMP
-    #pragma omp parallel for num_threads(get_num_threads()) if (is_omp_enabled())
+    #pragma omp parallel for num_threads(ctx.get_num_threads()) if (ctx.enabled())
     #endif
     for (int i = 0; i < image.rows()-n+1; ++i)
         for (int j = 0; j < image.cols()-n+1; ++j)
             out(i+size,j+size) = image.block(i,j,n,n).maxCoeff();
 }
 
 
-void binary_dilate(const Mask & image, Mask & out)
+void binary_dilate(
+    const Mask & image, Mask & out,
+    const ThreadContext & ctx
+    )
 {
     int n = 3;
     out.resizeLike(image);
     out.setZero();
     #ifdef _OPENMP
-    #pragma omp parallel for num_threads(get_num_threads()) if (is_omp_enabled())
+    #pragma omp parallel for num_threads(ctx.get_num_threads()) if (ctx.enabled())
     #endif
     for (int i = 0; i < image.rows()-n+1; ++i)
         for (int j = 0; j < image.cols()-n+1; ++j)
@@ -72,7 +78,10 @@ ArrayXXf gauss_deriv_kernel(int size, float sigma, bool dir_x)
 }
 
 
-void conv_2d(const Image & image, const Image & kernel, Image & out)
+void conv_2d(
+    const Image & image, const Image & kernel, Image & out,
+    const ThreadContext & ctx
+    )
 {
     auto nr = kernel.rows();
     auto nc = kernel.cols();
@@ -81,7 +90,7 @@ void conv_2d(const Image & image, const Image & kernel, Image & out)
     out.setZero();
 
     #ifdef _OPENMP
-    #pragma omp parallel for num_threads(get_num_threads()) if (is_omp_enabled())
+    #pragma omp parallel for num_threads(ctx.get_num_threads()) if (ctx.enabled())
     #endif
     for (int i = 0; i < image.rows()-nr+1; ++i)
         for (int j = 0; j < image.cols()-nc+1; ++j)
@@ -149,17 +158,20 @@ struct PeakPoint {
     float v;
 };
 
-void find_peaks(const Image & image, int size, float min_value, MatrixX2i & loc)
+void find_peaks(
+    const Image & image, int size, float min_value, MatrixX2i & loc,
+    const ThreadContext & ctx
+    )
 {
     Image max_im;
-    maximum_filter(image, max_im, size);
+    maximum_filter(image, max_im, size, ctx);
     auto peaks = ((max_im == image) && (image > min_value)).eval();
 
     vector<PeakPoint> res;
     res.reserve(1024);
 
     #ifdef _OPENMP
-    #pragma omp parallel for num_threads(get_num_threads()) if (is_omp_enabled())
+    #pragma omp parallel for num_threads(ctx.get_num_threads()) if (ctx.enabled())
     #endif
     for (int i = 0; i < peaks.rows(); ++i)
         for (int j = 0; j < peaks.cols(); ++j)

src/filter.h

@@ -7,18 +7,19 @@
 #include <Eigen/Core>
 
 #include "image.h"
+#include "threading.h"
 
 namespace librectify {
 
 Eigen::ArrayXXf gauss_deriv_kernel(int size, float sigma, bool dir_x);
 
-void maximum_filter(const Image & image, Image & out, int size);
+void maximum_filter(const Image & image, Image & out, int size, const ThreadContext &);
 
-void binary_dilate(const Mask & image, Mask & out);
+void binary_dilate(const Mask & image, Mask & out, const ThreadContext &);
 
-void conv_2d(const Image & image, const Image & kernel, Image & out);
+void conv_2d(const Image & image, const Image & kernel, Image & out, const ThreadContext &);
 
-void find_peaks(const Image & image, int size, float min_value, Eigen::MatrixX2i & loc);
+void find_peaks(const Image & image, int size, float min_value, Eigen::MatrixX2i & loc, const ThreadContext &);
 
 void flood_init_mask(Mask & mask);
 

src/geometry.cpp

@@ -96,9 +96,9 @@ float length(const LineSegment & l)
 Vector4f bounding_box(const vector<LineSegment> & lines)
 {
     MatrixX2f coords(2*lines.size(), 2);
-    #ifdef _OPENMP
-    #pragma omp parallel for num_threads(get_num_threads()) if (is_omp_enabled())
-    #endif
+    // #ifdef _OPENMP
+    // #pragma omp parallel for num_threads(get_num_threads()) if (is_omp_enabled())
+    // #endif
     for (int i = 0; i < int(lines.size()); ++i)
     {
         const LineSegment & l = lines[i];
@@ -115,9 +115,9 @@ Vector4f bounding_box(const vector<LineSegment> & lines)
 MatrixX3f homogeneous(const vector<LineSegment> & lines)
 {
     MatrixX3f h(lines.size(), 3);
-    #ifdef _OPENMP
-    #pragma omp parallel for num_threads(get_num_threads()) if (is_omp_enabled())
-    #endif
+    // #ifdef _OPENMP
+    // #pragma omp parallel for num_threads(get_num_threads()) if (is_omp_enabled())
+    // #endif
     for (int i = 0; i < int(lines.size()); ++i)
     {
         h.row(i) = homogeneous(lines[i]);
@@ -129,9 +129,9 @@ MatrixX3f homogeneous(const vector<LineSegment> & lines)
 MatrixX2f anchor_point(const vector<LineSegment> & lines)
 {
     MatrixX2f h(lines.size(), 2);
-    #ifdef _OPENMP
-    #pragma omp parallel for num_threads(get_num_threads()) if (is_omp_enabled())
-    #endif
+    // #ifdef _OPENMP
+    // #pragma omp parallel for num_threads(get_num_threads()) if (is_omp_enabled())
+    // #endif
     for (int i = 0; i < int(lines.size()); ++i)
     {
         h.row(i) = anchor_point(lines[i]);
@@ -143,9 +143,9 @@ MatrixX2f anchor_point(const vector<LineSegment> & lines)
 MatrixX2f direction_vector(const vector<LineSegment> & lines)
 {
     MatrixX2f d(lines.size(), 2);
-    #ifdef _OPENMP
-    #pragma omp parallel for num_threads(get_num_threads()) if (is_omp_enabled())
-    #endif
+    // #ifdef _OPENMP
+    // #pragma omp parallel for num_threads(get_num_threads()) if (is_omp_enabled())
+    // #endif
     for (int i = 0; i < int(lines.size()); ++i)
     {
         d.row(i) = direction_vector(lines[i]);
@@ -157,9 +157,9 @@ MatrixX2f direction_vector(const vector<LineSegment> & lines)
 VectorXf reprojection_error(const vector<LineSegment> & lines)
 {
     VectorXf err(lines.size());
-    #ifdef _OPENMP
-    #pragma omp parallel for num_threads(get_num_threads()) if (is_omp_enabled())
-    #endif
+    // #ifdef _OPENMP
+    // #pragma omp parallel for num_threads(get_num_threads()) if (is_omp_enabled())
+    // #endif
     for (int i = 0; i < int(lines.size()); ++i)
     {
         err(i) = std::max(lines[i].err, 0.1f);
@@ -171,9 +171,9 @@ VectorXf reprojection_error(const vector<LineSegment> & lines)
 ArrayXi group_id(const vector<LineSegment> & lines)
 {
     ArrayXi group(lines.size());
-    #ifdef _OPENMP
-    #pragma omp parallel for num_threads(get_num_threads()) if (is_omp_enabled())
-    #endif
+    // #ifdef _OPENMP
+    // #pragma omp parallel for num_threads(get_num_threads()) if (is_omp_enabled())
+    // #endif
     for (int i = 0; i < int(lines.size()); ++i)
     {
         group(i) = lines[i].group_id;
@@ -185,9 +185,9 @@ ArrayXi group_id(const vector<LineSegment> & lines)
 VectorXf weigths(const vector<LineSegment> & lines)
 {
     VectorXf w(lines.size());
-    #ifdef _OPENMP
-    #pragma omp parallel for num_threads(get_num_threads()) if (is_omp_enabled())
-    #endif
+    // #ifdef _OPENMP
+    // #pragma omp parallel for num_threads(get_num_threads()) if (is_omp_enabled())
+    // #endif
     for (int i = 0; i < int(lines.size()); ++i)
     {
         w(i) = lines[i].weight;

src/interface.cpp

@@ -14,6 +14,7 @@
 #include "geometry.h"
 #include "transform.h"
 #include "utils.h"
+#include "threading.h"
 
 
 using namespace Eigen;
@@ -23,14 +24,6 @@ using namespace std;
 namespace librectify {
 
 
-static vector<LineSegment> _find_line_segment_on_buffer(InputPixelType * buffer, int width, int height, int stride)
-{
-    Image im = image_from_buffer(buffer, width, height, stride);
-    // Detect the lines
-    return find_line_segments(im, SEED_DIST, SEED_RATIO, TRACE_TOLERANCE);
-}
-
-
 template<class InputIterator, class OutputIterator>
 static void _filter_lines(InputIterator first, InputIterator last, OutputIterator dst, float min_length)
 {
@@ -44,22 +37,27 @@ LineSegment * find_line_segment_groups(
     InputPixelType * buffer, int width, int height, int stride,
     float min_length, // filtering
     bool refine,
+    int num_threads,
     int * n_lines 
     )
 {
+    ThreadContext ctx(num_threads);
+
     // Init image from buffer
-    auto lines = _find_line_segment_on_buffer(buffer, width, height, stride);
+    Image im = image_from_buffer(buffer, width, height, stride);
+    // Detect the lines
+    auto lines = find_line_segments(im, SEED_DIST, SEED_RATIO, TRACE_TOLERANCE, ctx);
 
     if (refine)
     {
-        lines = postprocess_lines_segments(lines);
+        lines = postprocess_lines_segments(lines, ctx);
     }
 
     vector<LineSegment> filtered;
     filtered.reserve(lines.size());
     _filter_lines(lines.begin(), lines.end(), back_inserter(filtered), min_length);
 
-    vector<LineSegment> groupped = group_lines(filtered);
+    vector<LineSegment> groupped = group_lines(filtered, ctx);
 
     // Construct resulting array and copy data
     LineSegment * res = new LineSegment[groupped.size()];

src/librectify.h

@@ -86,21 +86,6 @@ struct ImageTransform
 };
 
 
-/*
-Set number of threads to be used by the library.
-By default, the value set by OpenMP library is used. This behaviour
-can be restored by set_num_threads(0). When negative value is set,
-threading is disabled.
-*/
-extern "C" void DLL_PUBLIC set_num_threads(int t);
-
-
-/*
-Get the number of threads
-*/
-extern "C" int DLL_PUBLIC get_num_threads();
-
-
 /*
 Detect line segments in image.
 
@@ -124,6 +109,7 @@ extern "C" DLL_PUBLIC LineSegment * find_line_segment_groups(
     InputPixelType * buffer, int width, int height, int stride,
     float min_length,
     bool refine,
+    int num_threads,
     int * n_lines);