Added min_barrier_distance() and also a new overload of get_histogram().

dlib/image_transforms/equalize_histogram.h

@@ -14,6 +14,45 @@ namespace dlib
 
 // ---------------------------------------------------------------------------------------
 
+    template <
+        typename in_image_type,
+        long R,
+        long C,
+        typename MM
+        >
+    void get_histogram (
+        const in_image_type& in_img_,
+        matrix<unsigned long,R,C,MM>& hist,
+        size_t hist_size
+    )
+    {
+        typedef typename image_traits<in_image_type>::pixel_type pixel_type;
+        COMPILE_TIME_ASSERT( pixel_traits<pixel_type>::is_unsigned == true );
+
+        // make sure hist is the right size
+        if (R == 1)
+            hist.set_size(1,hist_size);
+        else
+            hist.set_size(hist_size,1);
+
+
+        set_all_elements(hist,0);
+
+        const_image_view<in_image_type> in_img(in_img_);
+        // compute the histogram 
+        for (long r = 0; r < in_img.nr(); ++r)
+        {
+            for (long c = 0; c < in_img.nc(); ++c)
+            {
+                auto p = get_pixel_intensity(in_img[r][c]);
+                if (p < hist_size)
+                    ++hist(p);
+            }
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
     template <
         typename in_image_type,
         long R,

dlib/image_transforms/equalize_histogram_abstract.h

@@ -70,7 +70,7 @@ namespace dlib
             - Let pixel_type denote the type of pixel in in_img, then we must have:
                 - pixel_traits<pixel_type>::is_unsigned == true 
                 - pixel_traits<pixel_type>::max() <= 65535 
-            - hist must be capable of representing a column vector of length 
+            - hist must be capable of representing a column or row vector of length 
               pixel_traits<typename in_image_type>::max(). I.e. if R and C are nonzero
               then they must be values that don't conflict with the previous sentence.
         ensures
@@ -82,6 +82,37 @@ namespace dlib
                   in in_img
     !*/
 
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename in_image_type,
+        long R,
+        long C,
+        typename MM
+        >
+    void get_histogram (
+        const in_image_type& in_img,
+        matrix<unsigned long,R,C,MM>& hist,
+        size_t hist_size
+    );
+    /*!
+        requires
+            - in_image_type == an image object that implements the interface defined in
+              dlib/image_processing/generic_image.h 
+            - Let pixel_type denote the type of pixel in in_img, then we must have:
+                - pixel_traits<pixel_type>::is_unsigned == true 
+            - hist must be capable of representing a column or row vector of length
+              hist_size. I.e. if R and C are nonzero then they must be values that don't
+              conflict with the previous sentence.
+        ensures
+            - #hist.size() == hist_size 
+            - #hist.nc() == 1 || #hist.nr() == 1 (i.e. hist is either a row or column vector)
+            - #hist == the histogram for in_img, except pixel values >= hist_size are
+              ignored.  I.e. it is the case that for all valid i:
+                - hist(i) == the number of times a pixel with intensity i appears
+                  in in_img
+    !*/
+
 // ---------------------------------------------------------------------------------------
 
 }

dlib/image_transforms/segment_image.h

@@ -8,6 +8,7 @@
 #include <vector>
 #include "../geometry.h"
 #include "../disjoint_subsets.h"
+#include "assign_image.h"
 #include "../set.h"
 
 namespace dlib
@@ -722,6 +723,245 @@ namespace dlib
         find_candidate_object_locations(in_img, rects, linspace(50, 200, 3));
     }
 
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+    namespace impl
+    {
+        template <typename T>
+        void mbd_raster_scan(
+            const T& img,
+            array2d<rgb_pixel>& dist,
+            array2d<rgb_pixel>& lower,
+            array2d<rgb_pixel>& upper,
+            bool do_left_right_scans
+        )
+        {
+            auto area = shrink_rect(get_rect(img),1);
+
+            auto check_neighbor = [&](long r, long c, long neighbor_r, long neighbor_c) 
+            {
+                auto l = std::min(lower[neighbor_r][neighbor_c].red, img[r][c].red);
+                auto u = std::max(upper[neighbor_r][neighbor_c].red, img[r][c].red);
+                auto d = u-l;
+                if (d < dist[r][c].red)
+                {
+                    lower[r][c].red = l;
+                    upper[r][c].red = u;
+                    dist[r][c].red = d;
+                }
+
+                l = std::min(lower[neighbor_r][neighbor_c].green, img[r][c].green);
+                u = std::max(upper[neighbor_r][neighbor_c].green, img[r][c].green);
+                d = u-l;
+                if (d < dist[r][c].green)
+                {
+                    lower[r][c].green = l;
+                    upper[r][c].green = u;
+                    dist[r][c].green = d;
+                }
+
+                l = std::min(lower[neighbor_r][neighbor_c].blue, img[r][c].blue);
+                u = std::max(upper[neighbor_r][neighbor_c].blue, img[r][c].blue);
+                d = u-l;
+                if (d < dist[r][c].blue)
+                {
+                    lower[r][c].blue = l;
+                    upper[r][c].blue = u;
+                    dist[r][c].blue = d;
+                }
+            };
+
+            // scan top to bottom
+            for (long r = area.top(); r <= area.bottom(); ++r)
+            {
+                for (long c = area.left(); c <= area.right(); ++c)
+                {
+                    check_neighbor(r,c, r-1,c);
+                    check_neighbor(r,c, r,c-1);
+                }
+            }
+
+            // scan bottom to top
+            for (long r = area.bottom(); r >= area.top(); --r)
+            {
+                for (long c = area.right(); c >= area.left(); --c)
+                {
+                    check_neighbor(r,c, r+1,c);
+                    check_neighbor(r,c, r,c+1);
+                }
+            }
+
+            if (do_left_right_scans)
+            {
+                // scan left to right 
+                for (long c = area.left(); c <= area.right(); ++c)
+                {
+                    for (long r = area.top(); r <= area.bottom(); ++r)
+                    {
+                        check_neighbor(r,c, r-1,c);
+                        check_neighbor(r,c, r,c-1);
+                    }
+                }
+
+                // scan right to left 
+                for (long c = area.right(); c >= area.left(); --c)
+                {
+                    for (long r = area.bottom(); r >= area.top(); --r)
+                    {
+                        check_neighbor(r,c, r+1,c);
+                        check_neighbor(r,c, r,c+1);
+                    }
+                }
+            }
+        }
+
+    // ------------------------------------------------------------------------------------
+
+        template <typename T, typename U, typename pixel_type>
+        void mbd_raster_scan(
+            const T& img,
+            U& dist,
+            array2d<pixel_type>& lower,
+            array2d<pixel_type>& upper,
+            bool do_left_right_scans
+        )
+        {
+            auto area = shrink_rect(get_rect(img),1);
+
+            auto check_neighbor = [&](long r, long c, long neighbor_r, long neighbor_c) 
+            {
+                auto l = std::min(lower[neighbor_r][neighbor_c], get_pixel_intensity(img[r][c]));
+                auto u = std::max(upper[neighbor_r][neighbor_c], get_pixel_intensity(img[r][c]));
+                auto d = u-l;
+                if (d < dist[r][c])
+                {
+                    lower[r][c] = l;
+                    upper[r][c] = u;
+                    dist[r][c] = d;
+                }
+            };
+
+            // scan top to bottom
+            for (long r = area.top(); r <= area.bottom(); ++r)
+            {
+                for (long c = area.left(); c <= area.right(); ++c)
+                {
+                    check_neighbor(r,c, r-1,c);
+                    check_neighbor(r,c, r,c-1);
+                }
+            }
+
+            // scan bottom to top
+            for (long r = area.bottom(); r >= area.top(); --r)
+            {
+                for (long c = area.right(); c >= area.left(); --c)
+                {
+                    check_neighbor(r,c, r+1,c);
+                    check_neighbor(r,c, r,c+1);
+                }
+            }
+
+            if (do_left_right_scans)
+            {
+                // scan left to right 
+                for (long c = area.left(); c <= area.right(); ++c)
+                {
+                    for (long r = area.top(); r <= area.bottom(); ++r)
+                    {
+                        check_neighbor(r,c, r-1,c);
+                        check_neighbor(r,c, r,c-1);
+                    }
+                }
+
+                // scan right to left 
+                for (long c = area.right(); c >= area.left(); --c)
+                {
+                    for (long r = area.bottom(); r >= area.top(); --r)
+                    {
+                        check_neighbor(r,c, r+1,c);
+                        check_neighbor(r,c, r,c+1);
+                    }
+                }
+            }
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename in_image_type,
+        typename out_image_type
+        >
+    typename disable_if_c<is_rgb_image<in_image_type>::value>::type min_barrier_distance(
+        const in_image_type& img_,
+        out_image_type& dist_,
+        size_t iterations = 10,
+        bool do_left_right_scans = true
+    )
+    {
+        DLIB_CASSERT(iterations > 0);
+
+        static_assert(pixel_traits<typename image_traits<out_image_type>::pixel_type>::grayscale, 
+            "min_barrier_distance() requires a grayscale output image.");
+
+        const_image_view<in_image_type> img(img_);
+        image_view<out_image_type> dist(dist_);
+
+        typedef typename image_traits<in_image_type>::pixel_type pixel_type;
+        typedef typename pixel_traits<pixel_type>::basic_pixel_type basic_pixel_type;
+
+
+        dist.set_size(img.nr(), img.nc());
+        array2d<basic_pixel_type> lower, upper;
+        assign_all_pixels(dist, pixel_traits<pixel_type>::max());
+        zero_border_pixels(dist,1,1);
+        assign_image(lower, img);
+        assign_image(upper, img);
+
+        for (size_t i = 0; i < iterations; ++i)
+            impl::mbd_raster_scan(img, dist, lower, upper, do_left_right_scans);
+
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename in_image_type,
+        typename out_image_type
+        >
+    typename enable_if_c<is_rgb_image<in_image_type>::value>::type min_barrier_distance(
+        const in_image_type& img_,
+        out_image_type& dist_,
+        size_t iterations = 10,
+        bool do_left_right_scans = true
+    )
+    {
+        DLIB_CASSERT(iterations > 0);
+
+        static_assert(pixel_traits<typename image_traits<out_image_type>::pixel_type>::grayscale, 
+            "min_barrier_distance() requires a grayscale output image.");
+
+        const_image_view<in_image_type> img(img_);
+        image_view<out_image_type> dist(dist_);
+
+        typedef typename image_traits<in_image_type>::pixel_type pixel_type;
+
+
+        array2d<rgb_pixel> temp_dist(img.nr(), img.nc());
+        array2d<rgb_pixel> lower, upper;
+        assign_all_pixels(temp_dist, pixel_traits<pixel_type>::max());
+        zero_border_pixels(temp_dist,1,1);
+        assign_image(lower, img);
+        assign_image(upper, img);
+
+        for (size_t i = 0; i < iterations; ++i)
+            impl::mbd_raster_scan(img, temp_dist, lower, upper, do_left_right_scans);
+
+        // convert to grayscale for output.
+        assign_image(dist,temp_dist);
+    }
+
 // ----------------------------------------------------------------------------------------
 
 }

dlib/image_transforms/segment_image_abstract.h

@@ -117,6 +117,44 @@ namespace dlib
               instances.
     !*/
 
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename in_image_type,
+        typename out_image_type
+        >
+    void min_barrier_distance(
+        const in_image_type& img,
+        out_image_type& dist,
+        size_t iterations = 10,
+        bool do_left_right_scans = true
+    );
+    /*!
+        requires
+            - in_image_type == an image object that implements the interface defined in
+              dlib/image_processing/generic_image.h 
+            - out_image_type == an image object that implements the interface defined in
+              dlib/image_processing/generic_image.h 
+            - pixel_traits<typename image_traits<out_image_type>::pixel_type>::grayscale == true
+              (i.e. dist must be a grayscale image)
+            - iterations > 0
+        ensures
+            - This function implements the salient object detection method described in the paper:
+                "Minimum barrier salient object detection at 80 fps" by Zhang, Jianming, et al. 
+              In particular, we compute the minimum barrier distance between the borders of
+              the image and all the other pixels.  The result is stored in dist.  Note that
+              the paper talks about a bunch of other things you could do beyond computing
+              the minimum barrier distance, but this function doesn't do any of that. It's
+              just the vanilla MBD.
+            - We will perform iterations iterations of MBD passes over the image.  Larger
+              values might give better results but run slower.
+            - During each MBD iteration we make raster scans over the image.  These pass
+              from top->bottom, bottom->top, left->right, and right->left.  If
+              do_left_right_scans==false then the left/right passes are not executed.
+              Skipping them makes the algorithm about 2x faster but might reduce the
+              quality of the output.
+    !*/
+
 // ----------------------------------------------------------------------------------------
 
 }