    // Copyright (C) 2012  Davis E. King (davis@dlib.net)
    // License: Boost Software License   See LICENSE.txt for the full license.
    #undef DLIB_INTERPOlATION_ABSTRACT_
    #ifdef DLIB_INTERPOlATION_ABSTRACT_

    #include "../pixel.h"
    #include "../image_processing/full_object_detection_abstract.h"

    namespace dlib
    {

    // ----------------------------------------------------------------------------------------

        class interpolate_nearest_neighbor
        {
            /*!
                WHAT THIS OBJECT REPRESENTS
                    This object is a tool for performing nearest neighbor interpolation
                    on an image.
            !*/

        public:

            template <
                typename image_type,
                typename pixel_type
                >
            bool operator() (
                const image_type& img,
                const dlib::point& p,
                pixel_type& result
            ) const;
            /*!
                requires
                    - image_type == is an implementation of array2d/array2d_kernel_abstract.h
                    - pixel_traits<typename image_type::type>::has_alpha == false
                    - pixel_traits<pixel_type> is defined
                ensures
                    - if (p is located inside img) then
                        - #result == img[p.y()][p.x()]
                          (This assignment is done using assign_pixel(#result, img[p.y()][p.x()]),
                          therefore any necessary color space conversion will be performed)
                        - returns true
                    - else
                        - returns false
            !*/

        };

    // ----------------------------------------------------------------------------------------

        class interpolate_bilinear
        {

            /*!
                WHAT THIS OBJECT REPRESENTS
                    This object is a tool for performing bilinear interpolation
                    on an image.  This is performed by looking at the 4 pixels
                    nearest to a point and deriving an interpolated value from them.
            !*/

        public:

            template <
                typename T,
                typename image_type,
                typename pixel_type
                >
            bool operator() (
                const image_type& img,
                const dlib::vector<T,2>& p,
                pixel_type& result
            ) const;
            /*!
                requires
                    - image_type == is an implementation of array2d/array2d_kernel_abstract.h
                    - pixel_traits<typename image_type::type>::has_alpha == false
                    - pixel_traits<pixel_type> is defined
                ensures
                    - if (there is an interpolatable image location at point p in img) then
                        - #result == the interpolated pixel value from img at point p.
                        - assign_pixel() will be used to write to #result, therefore any
                          necessary color space conversion will be performed.
                        - returns true
                        - if img contains RGB pixels then the interpolation will be in color.
                          Otherwise, the interpolation will be performed in a grayscale mode.
                    - else
                        - returns false
            !*/
        };

    // ----------------------------------------------------------------------------------------

        class interpolate_quadratic
        {
            /*!
                WHAT THIS OBJECT REPRESENTS
                    This object is a tool for performing quadratic interpolation
                    on an image.  This is performed by looking at the 9 pixels
                    nearest to a point and deriving an interpolated value from them.
            !*/

        public:

            template <
                typename T,
                typename image_type,
                typename pixel_type
                >
            bool operator() (
                const image_type& img,
                const dlib::vector<T,2>& p,
                pixel_type& result
            ) const;
            /*!
                requires
                    - image_type == is an implementation of array2d/array2d_kernel_abstract.h
                    - pixel_traits<typename image_type::type>::has_alpha == false
                    - pixel_traits<pixel_type> is defined
                ensures
                    - if (there is an interpolatable image location at point p in img) then
                        - #result == the interpolated pixel value from img at point p
                        - assign_pixel() will be used to write to #result, therefore any
                          necessary color space conversion will be performed.
                        - returns true
                        - if img contains RGB pixels then the interpolation will be in color.
                          Otherwise, the interpolation will be performed in a grayscale mode.
                    - else
                        - returns false
            !*/
        };

    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------

        class black_background
        {
            /*!
                WHAT THIS OBJECT REPRESENTS
                    This is a function object which simply sets a pixel
                    to have a black value.
            !*/

        public:
            template <typename pixel_type>
            void operator() ( pixel_type& p) const { assign_pixel(p, 0); }
        };

    // ----------------------------------------------------------------------------------------

        class white_background
        {
            /*!
                WHAT THIS OBJECT REPRESENTS
                    This is a function object which simply sets a pixel
                    to have a white value.
            !*/

        public:
            template <typename pixel_type>
            void operator() ( pixel_type& p) const { assign_pixel(p, 255); }
        };

    // ----------------------------------------------------------------------------------------

        class no_background
        {
            /*!
                WHAT THIS OBJECT REPRESENTS
                    This is a function object which does nothing.  It is useful
                    when used with the transform_image() routine defined below
                    if no modification of uninterpolated output pixels is desired.
            !*/
        public:
            template <typename pixel_type>
            void operator() ( pixel_type& ) const { }
        };

    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------

        template <
            typename image_type1,
            typename image_type2,
            typename interpolation_type,
            typename point_mapping_type,
            typename background_type
            >
        void transform_image (
            const image_type1& in_img,
            image_type2& out_img,
            const interpolation_type& interp,
            const point_mapping_type& map_point,
            const background_type& set_background,
            const rectangle& area
        );
        /*!
            requires
                - image_type1 == is an implementation of array2d/array2d_kernel_abstract.h
                - image_type2 == is an implementation of array2d/array2d_kernel_abstract.h
                - interpolation_type == interpolate_nearest_neighbor, interpolate_bilinear,
                  interpolate_quadratic, or a type with a compatible interface.
                - map_point should be a function which takes dlib::vector<T,2> objects and
                  returns dlib::vector<T,2> objects.  An example is point_transform_affine.
                - set_background should be a function which can take a single argument of
                  type image_type2::type.  Examples are black_background, white_background,
                  and no_background.
                - get_rect(out_img).contains(area) == true
                - is_same_object(in_img, out_img) == false
            ensures
                - The map_point function defines a mapping from pixels in out_img to pixels
                  in in_img.  transform_image() uses this mapping, along with the supplied
                  interpolation routine interp, to fill the region of out_img defined by
                  area with an interpolated copy of in_img.
                - This function does not change the size of out_img.
                - Only pixels inside the region defined by area in out_img are modified.
                - For all locations r and c such that area.contains(c,r) but have no corresponding
                  locations in in_img:
                    - set_background(out_img[r][c]) is invoked
                      (i.e. some parts of out_img might correspond to areas outside in_img and
                      therefore can't supply interpolated values.  In these cases, these
                      pixels can be assigned a value by the supplied set_background() routine)
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type1,
            typename image_type2,
            typename interpolation_type,
            typename point_mapping_type,
            typename background_type
            >
        void transform_image (
            const image_type1& in_img,
            image_type2& out_img,
            const interpolation_type& interp,
            const point_mapping_type& map_point,
            const background_type& set_background
        );
        /*!
            requires
                - image_type1 == is an implementation of array2d/array2d_kernel_abstract.h
                - image_type2 == is an implementation of array2d/array2d_kernel_abstract.h
                - interpolation_type == interpolate_nearest_neighbor, interpolate_bilinear,
                  interpolate_quadratic, or a type with a compatible interface.
                - map_point should be a function which takes dlib::vector<T,2> objects and
                  returns dlib::vector<T,2> objects.  An example is point_transform_affine.
                - set_background should be a function which can take a single argument of
                  type image_type2::type.  Examples are black_background, white_background,
                  and no_background.
                - is_same_object(in_img, out_img) == false
            ensures
                - performs:
                  transform_image(in_img, out_img, interp, map_point, set_background, get_rect(out_img));
                  (i.e. runs transform_image() on the entire out_img)
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type1,
            typename image_type2,
            typename interpolation_type,
            typename point_mapping_type
            >
        void transform_image (
            const image_type1& in_img,
            image_type2& out_img,
            const interpolation_type& interp,
            const point_mapping_type& map_point
        );
        /*!
            requires
                - image_type1 == is an implementation of array2d/array2d_kernel_abstract.h
                - image_type2 == is an implementation of array2d/array2d_kernel_abstract.h
                - interpolation_type == interpolate_nearest_neighbor, interpolate_bilinear,
                  interpolate_quadratic, or a type with a compatible interface.
                - map_point should be a function which takes dlib::vector<T,2> objects and
                  returns dlib::vector<T,2> objects.  An example is point_transform_affine.
                - is_same_object(in_img, out_img) == false
            ensures
                - performs:
                  transform_image(in_img, out_img, interp, map_point, black_background(), get_rect(out_img));
                  (i.e. runs transform_image() on the entire out_img and sets non-interpolated
                  pixels to black)
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type1,
            typename image_type2,
            typename interpolation_type
            >
        point_transform_affine rotate_image (
            const image_type1& in_img,
            image_type2& out_img,
            double angle,
            const interpolation_type& interp
        );
        /*!
            requires
                - image_type1 == is an implementation of array2d/array2d_kernel_abstract.h
                - image_type2 == is an implementation of array2d/array2d_kernel_abstract.h
                - interpolation_type == interpolate_nearest_neighbor, interpolate_bilinear,
                  interpolate_quadratic, or a type with a compatible interface.
                - is_same_object(in_img, out_img) == false
            ensures
                - #out_img == a copy of in_img which has been rotated angle radians counter clockwise.
                  The rotation is performed with respect to the center of the image.
                - Parts of #out_img which have no corresponding locations in in_img are set to black.
                - uses the supplied interpolation routine interp to perform the necessary
                  pixel interpolation.
                - returns a transformation object that maps points in in_img into their corresponding
                  location in #out_img.
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type1,
            typename image_type2
            >
        point_transform_affine rotate_image (
            const image_type1& in_img,
            image_type2& out_img,
            double angle
        );
        /*!
            requires
                - image_type1 == is an implementation of array2d/array2d_kernel_abstract.h
                - image_type2 == is an implementation of array2d/array2d_kernel_abstract.h
                - pixel_traits<typename image_type1::type>::has_alpha == false
                - pixel_traits<typename image_type2::type> is defined
                - is_same_object(in_img, out_img) == false
            ensures
                - #out_img == a copy of in_img which has been rotated angle radians counter clockwise.
                  The rotation is performed with respect to the center of the image.
                - Parts of #out_img which have no corresponding locations in in_img are set to black.
                - uses the interpolate_quadratic object to perform the necessary pixel interpolation.
                - returns a transformation object that maps points in in_img into their corresponding
                  location in #out_img.
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type1,
            typename image_type2,
            typename interpolation_type
            >
        void resize_image (
            const image_type1& in_img,
            image_type2& out_img,
            const interpolation_type& interp
        );
        /*!
            requires
                - image_type1 == is an implementation of array2d/array2d_kernel_abstract.h
                - image_type2 == is an implementation of array2d/array2d_kernel_abstract.h
                - interpolation_type == interpolate_nearest_neighbor, interpolate_bilinear,
                  interpolate_quadratic, or a type with a compatible interface.
                - is_same_object(in_img, out_img) == false
            ensures
                - #out_img == A copy of in_img which has been stretched so that it
                  fits exactly into out_img.
                - The size of out_img is not modified.  I.e.
                    - #out_img.nr() == out_img.nr()
                    - #out_img.nc() == out_img.nc()
                - uses the supplied interpolation routine interp to perform the necessary
                  pixel interpolation.
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type1,
            typename image_type2
            >
        void resize_image (
            const image_type1& in_img,
            image_type2& out_img
        );
        /*!
            requires
                - image_type1 == is an implementation of array2d/array2d_kernel_abstract.h
                - image_type2 == is an implementation of array2d/array2d_kernel_abstract.h
                - pixel_traits<typename image_type1::type>::has_alpha == false
                - pixel_traits<typename image_type2::type> is defined
                - is_same_object(in_img, out_img) == false
            ensures
                - #out_img == A copy of in_img which has been stretched so that it
                  fits exactly into out_img.
                - The size of out_img is not modified.  I.e.
                    - #out_img.nr() == out_img.nr()
                    - #out_img.nc() == out_img.nc()
                - Uses the bilinear interpolation to perform the necessary pixel interpolation.
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type1,
            typename image_type2
            >
        point_transform_affine flip_image_left_right (
            const image_type1& in_img,
            image_type2& out_img
        );
        /*!
            requires
                - image_type1 == is an implementation of array2d/array2d_kernel_abstract.h
                - image_type2 == is an implementation of array2d/array2d_kernel_abstract.h
                - pixel_traits<typename image_type1::type> is defined
                - pixel_traits<typename image_type2::type> is defined
                - is_same_object(in_img, out_img) == false
            ensures
                - #out_img.nr() == in_img.nr()
                - #out_img.nc() == in_img.nc()
                - #out_img == a copy of in_img which has been flipped from left to right.
                  (i.e. it is flipped as if viewed though a mirror)
                - returns a transformation object that maps points in in_img into their
                  corresponding location in #out_img.
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type,
            typename T
            >
        void add_image_left_right_flips (
            dlib::array<image_type>& images,
            std::vector<std::vector<T> >& objects
        );
        /*!
            requires
                - image_type == is an implementation of array2d/array2d_kernel_abstract.h
                - pixel_traits<typename image_type::type> is defined
                - T == rectangle or full_object_detection
                - images.size() == objects.size()
            ensures
                - This function computes all the left/right flips of the contents of images and
                  then appends them onto the end of the images array.  It also finds the
                  left/right flips of the rectangles in objects and similarly appends them into
                  objects.  That is, we assume objects[i] is the set of bounding boxes in
                  images[i] and we flip the bounding boxes so that they still bound the same
                  objects in the new flipped images.
                - #images.size() == images.size()*2
                - #objects.size() == objects.size()*2
                - All the original elements of images and objects are left unmodified.  That
                  is, this function only appends new elements to each of these containers.
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type,
            typename T,
            typename U
            >
        void add_image_left_right_flips (
            dlib::array<image_type>& images,
            std::vector<std::vector<T> >& objects,
            std::vector<std::vector<U> >& objects2
        );
        /*!
            requires
                - image_type == is an implementation of array2d/array2d_kernel_abstract.h
                - pixel_traits<typename image_type::type> is defined
                - images.size() == objects.size()
                - images.size() == objects2.size()
                - T == rectangle or full_object_detection
                - U == rectangle or full_object_detection
            ensures
                - This function computes all the left/right flips of the contents of images and
                  then appends them onto the end of the images array.  It also finds the
                  left/right flips of the rectangles in objects and objects2 and similarly
                  appends them into objects and objects2 respectively.  That is, we assume
                  objects[i] is the set of bounding boxes in images[i] and we flip the bounding
                  boxes so that they still bound the same objects in the new flipped images.
                  We similarly flip the boxes in objects2.
                - #images.size()   == images.size()*2
                - #objects.size()  == objects.size()*2
                - #objects2.size() == objects2.size()*2
                - All the original elements of images, objects, and objects2 are left unmodified.
                  That is, this function only appends new elements to each of these containers.
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type,
            typename EXP,
            typename T,
            typename U
            >
        void add_image_rotations (
            const matrix_exp<EXP>& angles,
            dlib::array<image_type>& images,
            std::vector<std::vector<T> >& objects,
            std::vector<std::vector<U> >& objects2
        );
        /*!
            requires
                - is_vector(angles) == true
                - angles.size() > 0
                - image_type == is an implementation of array2d/array2d_kernel_abstract.h
                - pixel_traits<typename image_type::type> is defined
                - images.size() == objects.size()
                - images.size() == objects2.size()
                - T == rectangle or full_object_detection
                - U == rectangle or full_object_detection
            ensures
                - This function computes angles.size() different rotations of all the given
                  images and then replaces the contents of images with those rotations of the
                  input dataset.  We will also adjust the rectangles inside objects and
                  objects2 so that they still bound the same objects in the new rotated images.
                  That is, we assume objects[i] and objects2[i] are bounding boxes for things
                  in images[i].  So we will adjust the positions of the boxes in objects and
                  objects2 accordingly.
                - The elements of angles are interpreted as angles in radians and we will
                  rotate the images around their center using the values in angles.  Moreover,
                  the rotation is done counter clockwise.
                - #images.size()   == images.size()*angles.size()
                - #objects.size()  == objects.size()*angles.size()
                - #objects2.size() == objects2.size()*angles.size()
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type,
            typename EXP,
            typename T
            >
        void add_image_rotations (
            const matrix_exp<EXP>& angles,
            dlib::array<image_type>& images,
            std::vector<std::vector<T> >& objects
        );
        /*!
            requires
                - is_vector(angles) == true
                - angles.size() > 0
                - image_type == is an implementation of array2d/array2d_kernel_abstract.h
                - pixel_traits<typename image_type::type> is defined
                - images.size() == objects.size()
                - T == rectangle or full_object_detection
            ensures
                - This function is identical to the add_image_rotations() define above except
                  that it doesn't have objects2 as an argument.
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type
            >
        void flip_image_dataset_left_right (
            dlib::array<image_type>& images,
            std::vector<std::vector<rectangle> >& objects
        );
        /*!
            requires
                - image_type == is an implementation of array2d/array2d_kernel_abstract.h
                - pixel_traits<typename image_type::type> is defined
                - images.size() == objects.size()
            ensures
                - This function replaces each image in images with the left/right flipped
                  version of the image.  Therefore, #images[i] will contain the left/right
                  flipped version of images[i].  It also flips all the rectangles in objects so
                  that they still bound the same visual objects in each image.
                - #images.size() == image.size()
                - #objects.size() == objects.size()
                - for all valid i:
                    #objects[i].size() == objects[i].size()
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type
            >
        void flip_image_dataset_left_right (
            dlib::array<image_type>& images,
            std::vector<std::vector<rectangle> >& objects,
            std::vector<std::vector<rectangle> >& objects2
        );
        /*!
            requires
                - image_type == is an implementation of array2d/array2d_kernel_abstract.h
                - pixel_traits<typename image_type::type> is defined
                - images.size() == objects.size()
                - images.size() == objects2.size()
            ensures
                - This function replaces each image in images with the left/right flipped
                  version of the image.  Therefore, #images[i] will contain the left/right
                  flipped version of images[i].  It also flips all the rectangles in objects
                  and objects2 so that they still bound the same visual objects in each image.
                - #images.size() == image.size()
                - #objects.size() == objects.size()
                - #objects2.size() == objects2.size()
                - for all valid i:
                    #objects[i].size() == objects[i].size()
                - for all valid i:
                    #objects2[i].size() == objects2[i].size()
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename pyramid_type,
            typename image_type
            >
        void upsample_image_dataset (
            dlib::array<image_type>& images,
            std::vector<std::vector<rectangle> >& objects
        );
        /*!
            requires
                - image_type == is an implementation of array2d/array2d_kernel_abstract.h
                - pixel_traits<typename image_type::type> is defined
                - images.size() == objects.size()
            ensures
                - This function replaces each image in images with an upsampled version of that
                  image.  Each image is upsampled using pyramid_up() and the given
                  pyramid_type.  Therefore, #images[i] will contain the larger upsampled
                  version of images[i].  It also adjusts all the rectangles in objects so that
                  they still bound the same visual objects in each image.
                - #images.size() == image.size()
                - #objects.size() == objects.size()
                - for all valid i:
                    #objects[i].size() == objects[i].size()
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename pyramid_type,
            typename image_type
            >
        void upsample_image_dataset (
            dlib::array<image_type>& images,
            std::vector<std::vector<rectangle> >& objects,
            std::vector<std::vector<rectangle> >& objects2
        );
        /*!
            requires
                - image_type == is an implementation of array2d/array2d_kernel_abstract.h
                - pixel_traits<typename image_type::type> is defined
                - images.size() == objects.size()
                - images.size() == objects2.size()
            ensures
                - This function replaces each image in images with an upsampled version of that
                  image.  Each image is upsampled using pyramid_up() and the given
                  pyramid_type.  Therefore, #images[i] will contain the larger upsampled
                  version of images[i].  It also adjusts all the rectangles in objects and
                  objects2 so that they still bound the same visual objects in each image.
                - #images.size() == image.size()
                - #objects.size() == objects.size()
                - #objects2.size() == objects2.size()
                - for all valid i:
                    #objects[i].size() == objects[i].size()
                - for all valid i:
                    #objects2[i].size() == objects2[i].size()
        !*/

    // ----------------------------------------------------------------------------------------

        template <typename image_type>
        void rotate_image_dataset (
            double angle,
            dlib::array<image_type>& images,
            std::vector<std::vector<rectangle> >& objects
        );
        /*!
            requires
                - image_type == is an implementation of array2d/array2d_kernel_abstract.h
                - pixel_traits<typename image_type::type> is defined
                - images.size() == objects.size()
            ensures
                - This function replaces each image in images with a rotated version of that
                  image.  In particular, each image is rotated using
                  rotate_image(original,rotated,angle).  Therefore, the images are rotated
                  angle radians counter clockwise around their centers. That is, #images[i]
                  will contain the rotated version of images[i].  It also adjusts all
                  the rectangles in objects so that they still bound the same visual objects in
                  each image.
                - All the rectangles will still have the same sizes and aspect ratios after
                  rotation.  They will simply have had their positions adjusted so they still
                  fall on the same objects.
                - #images.size() == image.size()
                - #objects.size() == objects.size()
                - for all valid i:
                    #objects[i].size() == objects[i].size()
        !*/

    // ----------------------------------------------------------------------------------------

        template <typename image_type>
        void rotate_image_dataset (
            double angle,
            dlib::array<image_type>& images,
            std::vector<std::vector<rectangle> >& objects,
            std::vector<std::vector<rectangle> >& objects2
        );
        /*!
            requires
                - image_type == is an implementation of array2d/array2d_kernel_abstract.h
                - pixel_traits<typename image_type::type> is defined
                - images.size() == objects.size()
                - images.size() == objects2.size()
            ensures
                - This function replaces each image in images with a rotated version of that
                  image.  In particular, each image is rotated using
                  rotate_image(original,rotated,angle).  Therefore, the images are rotated
                  angle radians counter clockwise around their centers. That is, #images[i]
                  will contain the rotated version of images[i].  It also adjusts all
                  the rectangles in objects and objects2 so that they still bound the same
                  visual objects in each image.
                - All the rectangles will still have the same sizes and aspect ratios after
                  rotation.  They will simply have had their positions adjusted so they still
                  fall on the same objects.
                - #images.size() == image.size()
                - #objects.size() == objects.size()
                - #objects2.size() == objects2.size()
                - for all valid i:
                    #objects[i].size() == objects[i].size()
                - for all valid i:
                    #objects2[i].size() == objects2[i].size()
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type1,
            typename image_type2
            >
        void flip_image_up_down (
            const image_type1& in_img,
            image_type2& out_img
        );
        /*!
            requires
                - image_type1 == is an implementation of array2d/array2d_kernel_abstract.h
                - image_type2 == is an implementation of array2d/array2d_kernel_abstract.h
                - pixel_traits<typename image_type1::type> is defined
                - pixel_traits<typename image_type2::type> is defined
                - is_same_object(in_img, out_img) == false
            ensures
                - #out_img.nr() == in_img.nr()
                - #out_img.nc() == in_img.nc()
                - #out_img == a copy of in_img which has been flipped upside down.
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type1,
            typename image_type2,
            typename pyramid_type,
            typename interpolation_type
            >
        void pyramid_up (
            const image_type1& in_img,
            image_type2& out_img,
            const pyramid_type& pyr,
            const interpolation_type& interp
        );
        /*!
            requires
                - image_type1 == is an implementation of array2d/array2d_kernel_abstract.h
                - image_type2 == is an implementation of array2d/array2d_kernel_abstract.h
                - pyramid_type == a type compatible with the image pyramid objects defined
                  in dlib/image_transforms/image_pyramid_abstract.h
                - interpolation_type == interpolate_nearest_neighbor, interpolate_bilinear,
                  interpolate_quadratic, or a type with a compatible interface.
                - is_same_object(in_img, out_img) == false
            ensures
                - This function inverts the downsampling transformation performed by pyr().
                  In particular, it attempts to make an image, out_img, which would result
                  in in_img when downsampled with pyr().
                - #out_img == An upsampled copy of in_img.  In particular, downsampling
                  #out_img 1 time with pyr() should result in a final image which looks like
                  in_img.
                - Uses the supplied interpolation routine interp to perform the necessary
                  pixel interpolation.
                - Note that downsampling an image with pyr() and then upsampling it with
                  pyramid_up() will not necessarily result in a final image which is
                  the same size as the original.  This is because the exact size of the
                  original image cannot be determined based on the downsampled image.
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type1,
            typename image_type2,
            typename pyramid_type
            >
        void pyramid_up (
            const image_type1& in_img,
            image_type2& out_img,
            const pyramid_type& pyr
        );
        /*!
            requires
                - image_type1 == is an implementation of array2d/array2d_kernel_abstract.h
                - image_type2 == is an implementation of array2d/array2d_kernel_abstract.h
                - pyramid_type == a type compatible with the image pyramid objects defined
                  in dlib/image_transforms/image_pyramid_abstract.h
                - is_same_object(in_img, out_img) == false
            ensures
                - performs: pyramid_up(in_img, out_img, pyr, interpolate_bilinear());
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type,
            typename pyramid_type
            >
        void pyramid_up (
            image_type& img,
            const pyramid_type& pyr
        );
        /*!
            requires
                - image_type == is an implementation of array2d/array2d_kernel_abstract.h
                - pyramid_type == a type compatible with the image pyramid objects defined
                  in dlib/image_transforms/image_pyramid_abstract.h
            ensures
                - Performs an in-place version of pyramid_up() on the given image.  In
                  particular, this function is equivalent to:
                    pyramid_up(img, temp, pyr);
                    temp.swap(img);
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type
            >
        void pyramid_up (
            image_type& img
        );
        /*!
            requires
                - image_type == is an implementation of array2d/array2d_kernel_abstract.h
            ensures
                - performs: pyramid_up(img, pyramid_down<2>());
                  (i.e. it upsamples the given image and doubles it in size.)
        !*/

    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------

        struct chip_dims
        {
            /*!
                WHAT THIS OBJECT REPRESENTS
                    This is a simple tool for passing in a pair of row and column values to the
                    chip_details constructor.
            !*/

            chip_dims (
                unsigned long rows_,
                unsigned long cols_
            ) : rows(rows_), cols(cols_) { }

            unsigned long rows;
            unsigned long cols;
        };

    // ----------------------------------------------------------------------------------------

        struct chip_details
        {
            /*!
                WHAT THIS OBJECT REPRESENTS
                    This object describes where an image chip is to be extracted from within
                    another image.  In particular, it specifies that the image chip is
                    contained within the rectangle this->rect and that prior to extraction the
                    image should be rotated counter-clockwise by this->angle radians.  Finally,
                    the extracted chip should have this->rows rows and this->cols columns in it
                    regardless of the shape of this->rect.

            !*/

            chip_details(
            );
            /*!
                ensures
                    - #rect.is_empty() == true
                    - #size() == 0
                    - #angle == 0
                    - #rows == 0
                    - #cols == 0
            !*/

            chip_details(
                const rectangle& rect_,
                unsigned long size_
            );
            /*!
                ensures
                    - #rect == rect_
                    - #size() == size_
                    - #angle == 0
                    - #rows and #cols is set such that the total size of the chip is as close
                      to size_ as possible but still matches the aspect ratio of rect_.
                    - As long as size_ and the aspect ratio of of rect_ stays constant then
                      #rows and #cols will always have the same values.  This means that, for
                      example, if you want all your chips to have the same dimensions then
                      ensure that size_ is always the same and also that rect_ always has the
                      same aspect ratio.  Otherwise the calculated values of #rows and #cols
                      may be different for different chips.  Alternatively, you can use the
                      chip_details constructor below that lets you specify the exact values for
                      rows and cols.
            !*/

            chip_details(
                const rectangle& rect_,
                unsigned long size_,
                double angle_
            );
            /*!
                ensures
                    - #rect == rect_
                    - #size() == size_
                    - #angle == angle_
                    - #rows and #cols is set such that the total size of the chip is as close
                      to size_ as possible but still matches the aspect ratio of rect_.
                    - As long as size_ and the aspect ratio of of rect_ stays constant then
                      #rows and #cols will always have the same values.  This means that, for
                      example, if you want all your chips to have the same dimensions then
                      ensure that size_ is always the same and also that rect_ always has the
                      same aspect ratio.  Otherwise the calculated values of #rows and #cols
                      may be different for different chips.  Alternatively, you can use the
                      chip_details constructor below that lets you specify the exact values for
                      rows and cols.
            !*/

            chip_details(
                const rectangle& rect_,
                const chip_dims& dims
            );
            /*!
                ensures
                    - #rect == rect_
                    - #size() == dims.rows*dims.cols
                    - #angle == 0
                    - #rows == dims.rows
                    - #cols == dims.cols
            !*/

            chip_details(
                const rectangle& rect_,
                const chip_dims& dims,
                double angle_
            );
            /*!
                ensures
                    - #rect == rect_
                    - #size() == dims.rows*dims.cols
                    - #angle == angle_
                    - #rows == dims.rows
                    - #cols == dims.cols
            !*/

            inline unsigned long size() const { return rows*cols; }
            /*!
                ensures
                    - returns the number of pixels in this chip.  This is just rows*cols.
            !*/

            rectangle rect;
            double angle;
            unsigned long rows;
            unsigned long cols;
        };

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type1,
            typename image_type2
            >
        void extract_image_chips (
            const image_type1& img,
            const std::vector<chip_details>& chip_locations,
            dlib::array<image_type2>& chips
        );
        /*!
            requires
                - image_type1 == is an implementation of array2d/array2d_kernel_abstract.h
                - image_type2 == is an implementation of array2d/array2d_kernel_abstract.h
                - pixel_traits<typename image_type1::type>::has_alpha == false
                - pixel_traits<typename image_type2::type> is defined
                - for all valid i:
                    - chip_locations[i].rect.is_empty() == false
                    - chip_locations[i].size != 0
            ensures
                - This function extracts "chips" from an image.  That is, it takes a list of
                  rectangular sub-windows (i.e. chips) within an image and extracts those
                  sub-windows, storing each into its own image.  It also scales and rotates the
                  image chips according to the instructions inside each chip_details object.
                - #chips == the extracted image chips
                - #chips.size() == chip_locations.size()
                - for all valid i:
                    - #chips[i] == The image chip extracted from the position
                      chip_locations[i].rect in img.
                    - #chips[i].nr() == chip_locations[i].rows
                    - #chips[i].nc() == chip_locations[i].cols
                    - The image will have been rotated counter-clockwise by
                      chip_locations[i].angle radians, around the center of
                      chip_locations[i].rect, before the chip was extracted.
                - Any pixels in an image chip that go outside img are set to 0 (i.e. black).
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type1,
            typename image_type2
            >
        void extract_image_chip (
            const image_type1& img,
            const chip_details& chip_location,
            image_type2& chip
        );
        /*!
            ensures
                - This function simply calls extract_image_chips() with a single chip location
                  and stores the single output chip into #chip.
        !*/

    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------

    }

    #endif // DLIB_INTERPOlATION_ABSTRACT_