Added remove_unobtainable_rectangles() for the scan_image_custom scanner.

dlib/image_processing/remove_unobtainable_rectangles.h

@@ -6,6 +6,7 @@
 #include "remove_unobtainable_rectangles_abstract.h"
 #include "scan_image_pyramid.h"
 #include "scan_image_boxes.h"
+#include "scan_image_custom.h"
 #include "../svm/structural_object_detection_trainer.h"
 #include "../geometry.h"
 
@@ -137,90 +138,143 @@ namespace dlib
 
 // ----------------------------------------------------------------------------------------
 
-    template <
-        typename image_array_type,
-        typename feature_extractor, 
-        typename box_generator
-        >
-    std::vector<std::vector<rectangle> > remove_unobtainable_rectangles (
-        const structural_object_detection_trainer<scan_image_boxes<feature_extractor, box_generator> >& trainer,
-        const image_array_type& images,
-        std::vector<std::vector<rectangle> >& object_locations
-    )
+    namespace impl
     {
-        using namespace dlib::impl;
-        // make sure requires clause is not broken
-        DLIB_ASSERT(images.size() == object_locations.size(),
-            "\t std::vector<std::vector<rectangle>> remove_unobtainable_rectangles()"
-            << "\n\t Invalid inputs were given to this function."
+        template <
+            typename image_array_type,
+            typename scanner_type, 
+            typename get_boxes_functor
+            >
+        std::vector<std::vector<rectangle> > remove_unobtainable_rectangles (
+            get_boxes_functor& bg,
+            const structural_object_detection_trainer<scanner_type>& trainer,
+            const image_array_type& images,
+            std::vector<std::vector<rectangle> >& object_locations
+        )
+        {
+            using namespace dlib::impl;
+            // make sure requires clause is not broken
+            DLIB_ASSERT(images.size() == object_locations.size(),
+                "\t std::vector<std::vector<rectangle>> remove_unobtainable_rectangles()"
+                << "\n\t Invalid inputs were given to this function."
             );
 
-        box_generator bg = trainer.get_scanner().get_box_generator();
-        std::vector<rectangle> rects;
+            std::vector<rectangle> rects;
 
-        std::vector<std::vector<rectangle> > rejects(images.size());
+            std::vector<std::vector<rectangle> > rejects(images.size());
 
-        // If the trainer is setup to automatically fit the overlap tester to the data then
-        // we should use the loosest possible overlap tester here.  Otherwise we should use
-        // the tester the trainer will use.
-        test_box_overlap boxes_overlap(0.9999999,1); 
-        if (!trainer.auto_set_overlap_tester())
-            boxes_overlap = trainer.get_overlap_tester();
+            // If the trainer is setup to automatically fit the overlap tester to the data then
+            // we should use the loosest possible overlap tester here.  Otherwise we should use
+            // the tester the trainer will use.
+            test_box_overlap boxes_overlap(0.9999999,1); 
+            if (!trainer.auto_set_overlap_tester())
+                boxes_overlap = trainer.get_overlap_tester();
 
-        for (unsigned long k = 0; k < images.size(); ++k)
-        {
-            std::vector<rectangle> objs = object_locations[k];
-            // Don't even bother computing the candidate rectangles if there aren't any
-            // object locations for this image since there isn't anything to do anyway.
-            if (objs.size() == 0)
-                continue;
+            for (unsigned long k = 0; k < images.size(); ++k)
+            {
+                std::vector<rectangle> objs = object_locations[k];
+                // Don't even bother computing the candidate rectangles if there aren't any
+                // object locations for this image since there isn't anything to do anyway.
+                if (objs.size() == 0)
+                    continue;
 
-            bg(images[k], rects);
+                bg(images[k], rects);
 
 
-            // First remove things that don't have any matches with the candidate object
-            // locations.
-            std::vector<rectangle> good_rects;
-            for (unsigned long j = 0; j < objs.size(); ++j)
-            {
-                if (matches_rect(rects, objs[j], trainer.get_match_eps()))
-                    good_rects.push_back(objs[j]);
-                else
-                    rejects[k].push_back(objs[j]);
-            }
-            object_locations[k] = good_rects;
+                // First remove things that don't have any matches with the candidate object
+                // locations.
+                std::vector<rectangle> good_rects;
+                for (unsigned long j = 0; j < objs.size(); ++j)
+                {
+                    if (matches_rect(rects, objs[j], trainer.get_match_eps()))
+                        good_rects.push_back(objs[j]);
+                    else
+                        rejects[k].push_back(objs[j]);
+                }
+                object_locations[k] = good_rects;
 
 
-            // Remap these rectangles to the ones that can come out of the scanner.  That
-            // way when we compare them to each other in the following loop we will know if
-            // any distinct truth rectangles get mapped to overlapping boxes.
-            objs.resize(good_rects.size());
-            for (unsigned long i = 0; i < good_rects.size(); ++i)
-                objs[i] = get_best_matching_rect(rects, good_rects[i]);
+                // Remap these rectangles to the ones that can come out of the scanner.  That
+                // way when we compare them to each other in the following loop we will know if
+                // any distinct truth rectangles get mapped to overlapping boxes.
+                objs.resize(good_rects.size());
+                for (unsigned long i = 0; i < good_rects.size(); ++i)
+                    objs[i] = get_best_matching_rect(rects, good_rects[i]);
 
-            good_rects.clear();
-            // now check for truth rects that are too close together.
-            for (unsigned long i = 0; i < objs.size(); ++i)
-            {
-                // check if objs[i] hits another box
-                bool hit_box = false;
-                for (unsigned long j = i+1; j < objs.size(); ++j)
+                good_rects.clear();
+                // now check for truth rects that are too close together.
+                for (unsigned long i = 0; i < objs.size(); ++i)
                 {
-                    if (boxes_overlap(objs[i], objs[j]))
+                    // check if objs[i] hits another box
+                    bool hit_box = false;
+                    for (unsigned long j = i+1; j < objs.size(); ++j)
                     {
-                        hit_box = true;
-                        break;
+                        if (boxes_overlap(objs[i], objs[j]))
+                        {
+                            hit_box = true;
+                            break;
+                        }
                     }
+                    if (hit_box)
+                        rejects[k].push_back(object_locations[k][i]);
+                    else
+                        good_rects.push_back(object_locations[k][i]);
                 }
-                if (hit_box)
-                    rejects[k].push_back(object_locations[k][i]);
-                else
-                    good_rects.push_back(object_locations[k][i]);
+                object_locations[k] = good_rects;
             }
-            object_locations[k] = good_rects;
+
+            return rejects;
         }
 
-        return rejects;
+    // ----------------------------------------------------------------------------------------
+
+        template <typename T>
+        struct load_to_functor
+        {
+            load_to_functor(T& obj_) : obj(obj_) {}
+            T& obj;
+
+            template <typename U, typename V>
+            void operator()(const U& u, V& v) 
+            {
+                obj.load(u,v);
+            }
+        };
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename image_array_type,
+        typename feature_extractor, 
+        typename box_generator
+        >
+    std::vector<std::vector<rectangle> > remove_unobtainable_rectangles (
+        const structural_object_detection_trainer<scan_image_boxes<feature_extractor, box_generator> >& trainer,
+        const image_array_type& images,
+        std::vector<std::vector<rectangle> >& object_locations
+    )
+    {
+        box_generator bg = trainer.get_scanner().get_box_generator();
+        return impl::remove_unobtainable_rectangles(bg, trainer, images, object_locations);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename image_array_type,
+        typename feature_extractor
+        >
+    std::vector<std::vector<rectangle> > remove_unobtainable_rectangles (
+        const structural_object_detection_trainer<scan_image_custom<feature_extractor> >& trainer,
+        const image_array_type& images,
+        std::vector<std::vector<rectangle> >& object_locations
+    )
+    {
+        feature_extractor fe;
+        fe.copy_configuration(trainer.get_scanner().get_feature_extractor());
+        impl::load_to_functor<feature_extractor> bg(fe);
+        return impl::remove_unobtainable_rectangles(bg, trainer, images, object_locations);
     }
 
 // ----------------------------------------------------------------------------------------

dlib/image_processing/remove_unobtainable_rectangles_abstract.h

@@ -5,6 +5,7 @@
 
 #include "scan_image_pyramid_abstract.h"
 #include "scan_image_boxes_abstract.h"
+#include "scan_image_custom_abstract.h"
 #include "../svm/structural_object_detection_trainer_abstract.h"
 #include "../geometry.h"
 
@@ -76,6 +77,37 @@ namespace dlib
                     - V[i] == the set of rectangles removed from object_locations[i]
     !*/
 
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename image_array_type,
+        typename feature_extractor
+        >
+    std::vector<std::vector<rectangle> > remove_unobtainable_rectangles (
+        const structural_object_detection_trainer<scan_image_custom<feature_extractor> >& trainer,
+        const image_array_type& images,
+        std::vector<std::vector<rectangle> >& object_locations
+    );
+    /*!
+        requires
+            - images.size() == object_locations.size()
+        ensures
+            - Recall that the scan_image_custom object can't produce all possible rectangles
+              as object detections since it only considers a limited subset of all possible
+              object positions.  Moreover, the structural_object_detection_trainer requires
+              its input training data to not contain any object positions which are unobtainable
+              by its scanner object.  Therefore, remove_unobtainable_rectangles() is a tool
+              to filter out these unobtainable rectangles from the training data before giving
+              it to a structural_object_detection_trainer.
+            - This function interprets object_locations[i] as the set of object positions for
+              image[i], for all valid i.
+            - In particular, this function removes unobtainable rectangles from object_locations
+              and also returns a vector V such that:
+                - V.size() == object_locations.size()
+                - for all valid i:
+                    - V[i] == the set of rectangles removed from object_locations[i]
+    !*/
+
 // ----------------------------------------------------------------------------------------
 
 }