These templates ostensibly allowed a user to supply their own version of the

test_box_overlap object.  However, one place in the code assumed the
test_box_overlap object was used and so this feature has actually been broken
for some time.  Moreover, it's probably just confusing and excessively complex
to have this level of user modifiability so I removed the option and hard coded
everything to use the test_box_overlap object.  This makes the code
significantly clearer.

dlib/image_processing/object_detector.h

@@ -15,8 +15,7 @@ namespace dlib
 // ----------------------------------------------------------------------------------------
 
     template <
-        typename image_scanner_type,
-        typename overlap_tester_type = test_box_overlap
+        typename image_scanner_type
         >
     class object_detector
     {
@@ -32,14 +31,14 @@ namespace dlib
 
         object_detector (
             const image_scanner_type& scanner_, 
-            const overlap_tester_type& overlap_tester_,
+            const test_box_overlap& overlap_tester_,
             const feature_vector_type& w_ 
         );
 
         const feature_vector_type& get_w (
         ) const { return w; }
 
-        const overlap_tester_type& get_overlap_tester (
+        const test_box_overlap& get_overlap_tester (
         ) const;
 
         const image_scanner_type& get_scanner (
@@ -83,15 +82,15 @@ namespace dlib
             double adjust_threshold = 0
         );
 
-        template <typename T, typename U>
+        template <typename T>
         friend void serialize (
-            const object_detector<T,U>& item,
+            const object_detector<T>& item,
             std::ostream& out
         );
 
-        template <typename T, typename U>
+        template <typename T>
         friend void deserialize (
-            object_detector<T,U>& item,
+            object_detector<T>& item,
             std::istream& in 
         );
 
@@ -123,16 +122,16 @@ namespace dlib
             return false;
         }
 
-        overlap_tester_type boxes_overlap;
+        test_box_overlap boxes_overlap;
         feature_vector_type w;
         image_scanner_type scanner;
     };
 
 // ----------------------------------------------------------------------------------------
 
-    template <typename T, typename U>
+    template <typename T>
     void serialize (
-        const object_detector<T,U>& item,
+        const object_detector<T>& item,
         std::ostream& out
     )
     {
@@ -148,9 +147,9 @@ namespace dlib
 
 // ----------------------------------------------------------------------------------------
 
-    template <typename T, typename U>
+    template <typename T>
     void deserialize (
-        object_detector<T,U>& item,
+        object_detector<T>& item,
         std::istream& in 
     )
     {
@@ -171,10 +170,9 @@ namespace dlib
 // ----------------------------------------------------------------------------------------
 
     template <
-        typename image_scanner_type,
-        typename overlap_tester_type
+        typename image_scanner_type
         >
-    object_detector<image_scanner_type,overlap_tester_type>::
+    object_detector<image_scanner_type>::
     object_detector (
     )
     {
@@ -183,10 +181,9 @@ namespace dlib
 // ----------------------------------------------------------------------------------------
 
     template <
-        typename image_scanner_type,
-        typename overlap_tester_type
+        typename image_scanner_type
         >
-    object_detector<image_scanner_type,overlap_tester_type>::
+    object_detector<image_scanner_type>::
     object_detector (
         const object_detector& item 
     )
@@ -199,13 +196,12 @@ namespace dlib
 // ----------------------------------------------------------------------------------------
 
     template <
-        typename image_scanner_type,
-        typename overlap_tester_type
+        typename image_scanner_type
         >
-    object_detector<image_scanner_type,overlap_tester_type>::
+    object_detector<image_scanner_type>::
     object_detector (
         const image_scanner_type& scanner_, 
-        const overlap_tester_type& overlap_tester,
+        const test_box_overlap& overlap_tester,
         const feature_vector_type& w_ 
     ) :
         boxes_overlap(overlap_tester),
@@ -228,10 +224,9 @@ namespace dlib
 // ----------------------------------------------------------------------------------------
 
     template <
-        typename image_scanner_type,
-        typename overlap_tester_type
+        typename image_scanner_type
         >
-    object_detector<image_scanner_type,overlap_tester_type>& object_detector<image_scanner_type,overlap_tester_type>::
+    object_detector<image_scanner_type>& object_detector<image_scanner_type>::
     operator= (
         const object_detector& item 
     )
@@ -248,13 +243,12 @@ namespace dlib
 // ----------------------------------------------------------------------------------------
 
     template <
-        typename image_scanner_type,
-        typename overlap_tester_type
+        typename image_scanner_type
         >
     template <
         typename image_type
         >
-    std::vector<rectangle> object_detector<image_scanner_type,overlap_tester_type>::
+    std::vector<rectangle> object_detector<image_scanner_type>::
     operator() (
         const image_type& img
     ) 
@@ -283,13 +277,12 @@ namespace dlib
 // ----------------------------------------------------------------------------------------
 
     template <
-        typename image_scanner_type,
-        typename overlap_tester_type
+        typename image_scanner_type
         >
     template <
         typename image_type
         >
-    void object_detector<image_scanner_type,overlap_tester_type>::
+    void object_detector<image_scanner_type>::
     operator() (
         const image_type& img,
         std::vector<std::pair<double, rectangle> >& final_dets,
@@ -319,13 +312,12 @@ namespace dlib
 // ----------------------------------------------------------------------------------------
 
     template <
-        typename image_scanner_type,
-        typename overlap_tester_type
+        typename image_scanner_type
         >
     template <
         typename image_type
         >
-    void object_detector<image_scanner_type,overlap_tester_type>::
+    void object_detector<image_scanner_type>::
     operator() (
         const image_type& img,
         std::vector<std::pair<double, full_object_detection> >& final_dets,
@@ -349,13 +341,12 @@ namespace dlib
 // ----------------------------------------------------------------------------------------
 
     template <
-        typename image_scanner_type,
-        typename overlap_tester_type
+        typename image_scanner_type
         >
     template <
         typename image_type
         >
-    void object_detector<image_scanner_type,overlap_tester_type>::
+    void object_detector<image_scanner_type>::
     operator() (
         const image_type& img,
         std::vector<full_object_detection>& final_dets,
@@ -378,10 +369,9 @@ namespace dlib
 // ----------------------------------------------------------------------------------------
 
     template <
-        typename image_scanner_type,
-        typename overlap_tester_type
+        typename image_scanner_type
         >
-    const overlap_tester_type& object_detector<image_scanner_type,overlap_tester_type>::
+    const test_box_overlap& object_detector<image_scanner_type>::
     get_overlap_tester (
     ) const
     {
@@ -391,10 +381,9 @@ namespace dlib
 // ----------------------------------------------------------------------------------------
 
     template <
-        typename image_scanner_type,
-        typename overlap_tester_type
+        typename image_scanner_type
         >
-    const image_scanner_type& object_detector<image_scanner_type,overlap_tester_type>::
+    const image_scanner_type& object_detector<image_scanner_type>::
     get_scanner (
     ) const
     {

dlib/image_processing/object_detector_abstract.h

@@ -14,16 +14,11 @@ namespace dlib
 // ----------------------------------------------------------------------------------------
 
     template <
-        typename image_scanner_type,
-        typename overlap_tester_type = test_box_overlap
+        typename image_scanner_type
         >
     class object_detector
     {
         /*!
-            REQUIREMENTS ON overlap_tester_type
-                overlap_tester_type must be an implementation of the test_box_overlap
-                object defined in dlib/image_processing/box_overlap_testing_abstract.h.
-
             REQUIREMENTS ON image_scanner_type
                 image_scanner_type must be an implementation of 
                 dlib/image_processing/scan_image_pyramid_abstract.h
@@ -60,7 +55,7 @@ namespace dlib
 
         object_detector (
             const image_scanner_type& scanner, 
-            const overlap_tester_type& overlap_tester,
+            const test_box_overlap& overlap_tester,
             const feature_vector_type& w 
         );
         /*!
@@ -90,7 +85,7 @@ namespace dlib
                 - returns the weight vector used by this object
         !*/
 
-        const overlap_tester_type& get_overlap_tester (
+        const test_box_overlap& get_overlap_tester (
         ) const;
         /*!
             ensures
@@ -209,9 +204,9 @@ namespace dlib
 
 // ----------------------------------------------------------------------------------------
 
-    template <typename T, typename U>
+    template <typename T>
     void serialize (
-        const object_detector<T,U>& item,
+        const object_detector<T>& item,
         std::ostream& out
     );
     /*!
@@ -220,9 +215,9 @@ namespace dlib
 
 // ----------------------------------------------------------------------------------------
 
-    template <typename T, typename U>
+    template <typename T>
     void deserialize (
-        object_detector<T,U>& item,
+        object_detector<T>& item,
         std::istream& in 
     );
     /*!

dlib/svm/structural_object_detection_trainer.h

@@ -18,8 +18,7 @@ namespace dlib
 // ----------------------------------------------------------------------------------------
 
     template <
-        typename image_scanner_type,
-        typename overlap_tester_type = test_box_overlap
+        typename image_scanner_type
         >
     class structural_object_detection_trainer : noncopyable
     {
@@ -27,7 +26,7 @@ namespace dlib
     public:
         typedef double scalar_type;
         typedef default_memory_manager mem_manager_type;
-        typedef object_detector<image_scanner_type,overlap_tester_type> trained_function_type;
+        typedef object_detector<image_scanner_type> trained_function_type;
 
 
         explicit structural_object_detection_trainer (
@@ -52,7 +51,7 @@ namespace dlib
 
             scanner.copy_configuration(scanner_);
 
-            auto_overlap_tester = is_same_type<overlap_tester_type,test_box_overlap>::value;
+            auto_overlap_tester = true;
         }
 
         const image_scanner_type& get_scanner (
@@ -68,19 +67,19 @@ namespace dlib
         }
 
         void set_overlap_tester (
-            const overlap_tester_type& tester
+            const test_box_overlap& tester
         )
         {
             overlap_tester = tester;
             auto_overlap_tester = false;
         }
 
-        overlap_tester_type get_overlap_tester (
+        test_box_overlap get_overlap_tester (
         ) const
         {
             // make sure requires clause is not broken
             DLIB_ASSERT(auto_set_overlap_tester() == false,
-                "\t overlap_tester_type structural_object_detection_trainer::get_overlap_tester()"
+                "\t test_box_overlap structural_object_detection_trainer::get_overlap_tester()"
                 << "\n\t You can't call this function if the overlap tester is generated dynamically."
                 << "\n\t this: " << this
                 );
@@ -276,7 +275,7 @@ namespace dlib
             }
 #endif
 
-            overlap_tester_type local_overlap_tester;
+            test_box_overlap local_overlap_tester;
 
             if (auto_overlap_tester)
             {
@@ -297,7 +296,7 @@ namespace dlib
                 local_overlap_tester = overlap_tester;
             }
 
-            structural_svm_object_detection_problem<image_scanner_type,overlap_tester_type,image_array_type > 
+            structural_svm_object_detection_problem<image_scanner_type,image_array_type > 
                 svm_prob(scanner, local_overlap_tester, images, truth_object_detections, num_threads);
 
             if (verbose)
@@ -315,7 +314,7 @@ namespace dlib
             solver(svm_prob,w);
 
             // report the results of the training.
-            return object_detector<image_scanner_type,overlap_tester_type>(scanner, local_overlap_tester, w);
+            return object_detector<image_scanner_type>(scanner, local_overlap_tester, w);
         }
 
         template <
@@ -341,7 +340,7 @@ namespace dlib
     private:
 
         image_scanner_type scanner;
-        overlap_tester_type overlap_tester;
+        test_box_overlap overlap_tester;
 
         double C;
         oca solver;

dlib/svm/structural_object_detection_trainer_abstract.h

@@ -15,8 +15,7 @@ namespace dlib
 // ----------------------------------------------------------------------------------------
 
     template <
-        typename image_scanner_type,
-        typename overlap_tester_type = test_box_overlap
+        typename image_scanner_type
         >
     class structural_object_detection_trainer : noncopyable
     {
@@ -25,10 +24,6 @@ namespace dlib
                 image_scanner_type must be an implementation of 
                 dlib/image_processing/scan_image_pyramid_abstract.h
 
-            REQUIREMENTS ON overlap_tester_type
-                overlap_tester_type must be an implementation of the test_box_overlap
-                object defined in dlib/image_processing/box_overlap_testing_abstract.h.
-
             WHAT THIS OBJECT REPRESENTS
                 This object is a tool for learning to detect objects in images based on a 
                 set of labeled images. The training procedure produces an object_detector 
@@ -41,7 +36,7 @@ namespace dlib
     public:
         typedef double scalar_type;
         typedef default_memory_manager mem_manager_type;
-        typedef object_detector<image_scanner_type,overlap_tester_type> trained_function_type;
+        typedef object_detector<image_scanner_type> trained_function_type;
 
 
         explicit structural_object_detection_trainer (
@@ -64,10 +59,7 @@ namespace dlib
                 - #get_scanner() == scanner
                   (note that only the "configuration" of scanner is copied.
                   I.e. the copy is done using copy_configuration())
-                - if (overlap_tester_type == test_box_overlap) then
-                    - #auto_set_overlap_tester() == true
-                - else
-                    - #auto_set_overlap_tester() == false
+                - #auto_set_overlap_tester() == true
         !*/
 
         const image_scanner_type& get_scanner (
@@ -92,7 +84,7 @@ namespace dlib
         !*/
 
         void set_overlap_tester (
-            const overlap_tester_type& tester
+            const test_box_overlap& tester
         );
         /*!
             ensures
@@ -100,7 +92,7 @@ namespace dlib
                 - #auto_set_overlap_tester() == false
         !*/
 
-        overlap_tester_type get_overlap_tester (
+        test_box_overlap get_overlap_tester (
         ) const;
         /*!
             requires

dlib/svm/structural_svm_object_detection_problem.h

@@ -10,6 +10,7 @@
 #include "../string.h"
 #include "../array.h"
 #include "../image_processing/full_object_detection.h"
+#include "../image_processing/box_overlap_testing.h"
 
 namespace dlib
 {
@@ -26,7 +27,6 @@ namespace dlib
 
     template <
         typename image_scanner_type,
-        typename overlap_tester_type,
         typename image_array_type 
         >
     class structural_svm_object_detection_problem : public structural_svm_problem_threaded<matrix<double,0,1> >,
@@ -36,7 +36,7 @@ namespace dlib
 
         structural_svm_object_detection_problem(
             const image_scanner_type& scanner,
-            const overlap_tester_type& overlap_tester,
+            const test_box_overlap& overlap_tester,
             const image_array_type& images_,
             const std::vector<std::vector<full_object_detection> >& truth_object_detections_,
             unsigned long num_threads = 2
@@ -201,9 +201,9 @@ namespace dlib
                         ostringstream sout;
                         sout << "An impossible set of object labels was detected. This is happening because ";
                         sout << "the truth labels for an image contain rectangles which overlap according to the ";
-                        sout << "overlap_tester_type supplied for non-max suppression.  To resolve this, you either need to ";
-                        sout << "relax the overlap tester so it doesn't mark these rectangles as overlapping ";
-                        sout << "or adjust the truth rectangles. ";
+                        sout << "test_box_overlap object supplied for non-max suppression.  To resolve this, you ";
+                        sout << "either need to relax the test_box_overlap object so it doesn't mark these rectangles as ";
+                        sout << "overlapping or adjust the truth rectangles. ";
 
                         // make sure the above string fits nicely into a command prompt window.
                         string temp = sout.str();
@@ -447,7 +447,7 @@ namespace dlib
         }
 
 
-        overlap_tester_type boxes_overlap;
+        test_box_overlap boxes_overlap;
 
         mutable array<image_scanner_type> scanners;
 

dlib/svm/structural_svm_object_detection_problem_abstract.h

@@ -7,6 +7,7 @@
 #include "structural_svm_problem_threaded_abstract.h"
 #include <sstream>
 #include "../image_processing/full_object_detection_abstract.h"
+#include "../image_processing/box_overlap_testing.h"
 
 namespace dlib
 {
@@ -21,9 +22,9 @@ namespace dlib
                 when it detects that the image_scanner_type it is working with is incapable
                 of representing the truth rectangles it has been asked to predict.  
 
-                This kind of problem can happen when the overlap_tester_type indicates that
-                two ground truth rectangles overlap and are therefore not allowed to both
-                be output at the same time.  Or alternatively, if there are not enough
+                This kind of problem can happen when the test_box_overlap object indicates
+                that two ground truth rectangles overlap and are therefore not allowed to
+                both be output at the same time.  Or alternatively, if there are not enough
                 detection templates to cover the variety of truth rectangle shapes.
         !*/
     };
@@ -32,7 +33,6 @@ namespace dlib
 
     template <
         typename image_scanner_type,
-        typename overlap_tester_type,
         typename image_array_type 
         >
     class structural_svm_object_detection_problem : public structural_svm_problem_threaded<matrix<double,0,1> >,
@@ -43,10 +43,6 @@ namespace dlib
                 image_scanner_type must be an implementation of 
                 dlib/image_processing/scan_image_pyramid_abstract.h
 
-            REQUIREMENTS ON overlap_tester_type
-                overlap_tester_type must be an implementation of the test_box_overlap
-                object defined in dlib/image_processing/box_overlap_testing_abstract.h.
-
             REQUIREMENTS ON image_array_type
                 image_array_type must be an implementation of dlib/array/array_kernel_abstract.h 
                 and it must contain objects which can be accepted by image_scanner_type::load().
@@ -80,7 +76,7 @@ namespace dlib
 
         structural_svm_object_detection_problem(
             const image_scanner_type& scanner,
-            const overlap_tester_type& overlap_tester,
+            const test_box_overlap& overlap_tester,
             const image_array_type& images,
             const std::vector<std::vector<full_object_detection> >& truth_object_detections,
             unsigned long num_threads = 2
@@ -99,7 +95,7 @@ namespace dlib
                   attempts to learn to predict truth_object_detections[i] based on
                   images[i].  Or in other words, this object can be used to learn a
                   parameter vector, w, such that an object_detector declared as:
-                    object_detector<image_scanner_type,overlap_tester_type> detector(scanner,overlap_tester,w)
+                    object_detector<image_scanner_type> detector(scanner,overlap_tester,w)
                   results in a detector object which attempts to compute the locations of
                   all the objects in truth_object_detections.  So if you called
                   detector(images[i]) you would hopefully get a list of rectangles back