Added a more complete set of functions for converting between image space and the downsampled hog

grid.  So now you can convert from image to hog instead of just hog to image.  Also added some
related unit tests.

dlib/image_keypoint/hog.h

@@ -152,6 +152,55 @@ namespace dlib
             return rectangle(col, row, col+cell_size*block_size-1, row+cell_size*block_size-1);
         }
 
+        const point image_to_feat_space (
+            const point& p
+        ) const
+        {
+
+            const long half_block = block_size/2;
+            if ((block_size%2) == 0)
+            {
+                return point(((p.x()-1)/(long)cell_size - half_block)/(long)cell_stride,
+                             ((p.y()-1)/(long)cell_size - half_block)/(long)cell_stride);
+            }
+            else
+            {
+                return point(((p.x()-1-(long)cell_size/2)/(long)cell_size - half_block)/(long)cell_stride,
+                             ((p.y()-1-(long)cell_size/2)/(long)cell_size - half_block)/(long)cell_stride);
+            }
+        }
+
+        const rectangle image_to_feat_space (
+            const rectangle& rect
+        ) const
+        {
+            return rectangle(image_to_feat_space(rect.tl_corner()), image_to_feat_space(rect.br_corner()));
+        }
+
+        const point feat_to_image_space (
+            const point& p
+        ) const
+        {
+            const long half_block = block_size/2;
+            if ((block_size%2) == 0)
+            {
+                return point((p.x()*cell_stride + half_block)*cell_size + 1,
+                             (p.y()*cell_stride + half_block)*cell_size + 1);
+            }
+            else
+            {
+                return point((p.x()*cell_stride + half_block)*cell_size + 1 + cell_size/2,
+                             (p.y()*cell_stride + half_block)*cell_size + 1 + cell_size/2);
+            }
+        }
+
+        const rectangle feat_to_image_space (
+            const rectangle& rect
+        ) const
+        {
+            return rectangle(feat_to_image_space(rect.tl_corner()), feat_to_image_space(rect.br_corner()));
+        }
+
     private:
 
         template <

dlib/image_keypoint/hog_abstract.h

@@ -189,6 +189,53 @@ namespace dlib
                   with a particular HOG block.
                 - The returned rectangle will be cell_size*block_size pixels wide and tall.
         !*/
+
+        const point image_to_feat_space (
+            const point& p
+        ) const;
+        /*!
+            ensures
+                - Each local feature is extracted from a certain point in the input image.
+                  This function returns the identity of the local feature corresponding
+                  to any particular image location p.  Or in other words, 
+                  let P == image_to_feat_space(p), then (*this)(P.y(),P.x()) == the local
+                  feature closest to, or centered at, the point p in the input image.  Note
+                  that some image points might not have corresponding feature locations.  
+                  E.g. border points or points outside the image.  In these cases the returned
+                  point will be outside get_rect(*this).
+        !*/
+
+        const rectangle image_to_feat_space (
+            const rectangle& rect
+        ) const;
+        /*!
+            ensures
+                - returns rectangle(image_to_feat_space(rect.tl_corner()), image_to_feat_space(rect.br_corner()));
+                  (i.e. maps a rectangle from image space to feature space)
+        !*/
+
+        const point feat_to_image_space (
+            const point& p
+        ) const;
+        /*!
+            ensures
+                - returns the location in the input image space corresponding to the center
+                  of the local feature at point p.  In other words, this function computes
+                  the inverse of image_to_feat_space().  Note that it may only do so approximately, 
+                  since more than one image location might correspond to the same local feature.  
+                  That is, image_to_feat_space() might not be invertible so this function gives 
+                  the closest possible result.
+        !*/
+
+        const rectangle feat_to_image_space (
+            const rectangle& rect
+        ) const;
+        /*!
+            ensures
+                - return rectangle(feat_to_image_space(rect.tl_corner()), feat_to_image_space(rect.br_corner()));
+                  (i.e. maps a rectangle from feature space to image space)
+        !*/
+
     };
 
 // ----------------------------------------------------------------------------------------

dlib/test/CMakeLists.txt

@@ -44,6 +44,7 @@ set (tests
    hash_map.cpp
    hash_set.cpp
    hash_table.cpp
+   hog_image.cpp
    image.cpp
    is_same_object.cpp
    kcentroid.cpp

dlib/test/hog_image.cpp

+// Copyright (C) 2011  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#include <sstream>
+#include <string>
+#include <cstdlib>
+#include <ctime>
+#include <dlib/image_keypoint.h>
+#include <dlib/array2d.h>
+#include <dlib/rand.h>
+#include <dlib/pixel.h>
+#include <dlib/image_transforms.h>
+
+#include "tester.h"
+
+namespace  
+{
+    using namespace test;
+    using namespace dlib;
+    using namespace std;
+
+    logger dlog("test.hog_image");
+
+// ----------------------------------------------------------------------------------------
+
+    class test_hog_image : public tester
+    {
+    public:
+        test_hog_image (
+        ) :
+            tester ("test_hog_image",
+                    "Runs tests on the hog_image object.")
+        {}
+
+        void perform_test (
+        )
+        {
+            print_spinner();
+            array2d<unsigned char> img;
+            img.set_size(200,200);
+
+            assign_all_pixels(img, 0);
+
+            hog_image<3,3,1,4,hog_signed_gradient,hog_full_interpolation> hog1;    
+            hog_image<4,4,2,4,hog_signed_gradient,hog_full_interpolation> hog2;    
+
+            hog1.load(img);
+            hog2.load(img);
+
+
+            // Just test all the coordinate mapping functions.
+
+            DLIB_TEST(hog1.get_block_rect(0,0).width() == 3*3);
+            DLIB_TEST(hog1.get_block_rect(0,0).height() == 3*3);
+            DLIB_TEST(hog2.get_block_rect(0,0).width() == 4*4);
+            DLIB_TEST(hog2.get_block_rect(0,0).height() == 4*4);
+
+            DLIB_TEST(get_rect(img).contains(hog1.get_block_rect(0,0)));
+            DLIB_TEST(get_rect(img).contains(hog1.get_block_rect(hog1.nr()-1,hog1.nc()-1)));
+            DLIB_TEST(get_rect(img).contains(hog2.get_block_rect(0,0)));
+            DLIB_TEST(get_rect(img).contains(hog2.get_block_rect(hog2.nr()-1,hog2.nc()-1)));
+
+            dlib::rand rnd;
+            for (int i = 0; i < 20000; ++i)
+            {
+                point p(rnd.get_random_16bit_number(), rnd.get_random_16bit_number());
+                p.x() -= 20000;
+                p.y() -= 20000;
+
+                DLIB_TEST((hog1.feat_to_image_space(hog1.image_to_feat_space(p)) - p).length() <= 3);
+                DLIB_TEST((hog2.feat_to_image_space(hog2.image_to_feat_space(p)) - p).length() <= 10);
+
+                DLIB_TEST_MSG((hog1.image_to_feat_space(hog1.feat_to_image_space(p)) - p).length() <= 3,
+                              p << "   " << hog1.feat_to_image_space(p) << "   " << hog1.image_to_feat_space(hog1.feat_to_image_space(p)) );
+                DLIB_TEST((hog2.image_to_feat_space(hog2.feat_to_image_space(p)) - p).length() <= 10);
+            }
+
+
+            DLIB_TEST(hog1.feat_to_image_space(point(0,0)) == point(5,5));
+            DLIB_TEST(hog2.feat_to_image_space(point(0,0)) == point(9,9));
+
+            DLIB_TEST(hog1.image_to_feat_space(hog1.feat_to_image_space(point(0,0))) == point(0,0));
+            DLIB_TEST(hog2.image_to_feat_space(hog2.feat_to_image_space(point(0,0))) == point(0,0));
+        }
+    } a;
+
+}
+
+
+
+

dlib/test/makefile

@@ -59,6 +59,7 @@ SRC += hash.cpp
 SRC += hash_map.cpp
 SRC += hash_set.cpp
 SRC += hash_table.cpp
+SRC += hog_image.cpp
 SRC += image.cpp
 SRC += is_same_object.cpp
 SRC += kcentroid.cpp