# dlib C++ Library - random_cropper.h

    // Copyright (C) 2016  Davis E. King (davis@dlib.net)
    // License: Boost Software License   See LICENSE.txt for the full license.
    #ifndef DLIB_RaNDOM_CROPPER_H_
    #define DLIB_RaNDOM_CROPPER_H_

    #include "random_cropper_abstract.h"
    #include "../threads.h"
    #include <mutex>
    #include <vector>
    #include "interpolation.h"
    #include "../image_processing/full_object_detection.h"
    #include "../rand.h"

    namespace dlib
    {
        class random_cropper
        {
            chip_dims dims = chip_dims(300,300);
            bool randomly_flip = true;
            double max_rotation_degrees = 30;
            long min_object_length_long_dim = 75; // cropped object will be at least this many pixels along its longest edge.
            long min_object_length_short_dim = 30; // cropped object will be at least this many pixels along its shortest edge.
            double max_object_size = 0.7; // cropped object will be at most this fraction of the size of the image.
            double background_crops_fraction = 0.5;
            double translate_amount = 0.10;
            double min_object_coverage = 1.0;

            std::mutex rnd_mutex;
            dlib::rand rnd;
        public:

            void set_seed (
                time_t seed
            ) { rnd = dlib::rand(seed); }

            double get_translate_amount (
            ) const { return translate_amount; }

            void set_translate_amount (
                double value
            )
            {
                DLIB_CASSERT(0 <= value);
                translate_amount = value;
            }

            double get_background_crops_fraction (
            ) const { return background_crops_fraction; }

            void set_background_crops_fraction (
                double value
            )
            {
                DLIB_CASSERT(0 <= value && value <= 1);
                background_crops_fraction = value;
            }

            const chip_dims& get_chip_dims(
            ) const { return dims; }

            void set_chip_dims (
                const chip_dims& dims_
            ) { dims = dims_; }

            void set_chip_dims (
                unsigned long rows,
                unsigned long cols
            ) { set_chip_dims(chip_dims(rows,cols)); }

            bool get_randomly_flip (
            ) const { return randomly_flip; }

            void set_randomly_flip (
                bool value
            ) { randomly_flip = value; }

            double get_max_rotation_degrees (
            ) const { return max_rotation_degrees; }
            void set_max_rotation_degrees (
                double value
            ) { max_rotation_degrees = std::abs(value); }

            long get_min_object_length_long_dim (
            ) const { return min_object_length_long_dim; }
            long get_min_object_length_short_dim (
            ) const { return min_object_length_short_dim; }

            void set_min_object_size (
                long long_dim,
                long short_dim
            )
            {
                DLIB_CASSERT(0 < short_dim && short_dim <= long_dim);
                min_object_length_long_dim = long_dim;
                min_object_length_short_dim = short_dim;
            }

            double get_max_object_size (
            ) const { return max_object_size; }
            void set_max_object_size (
                double value
            )
            {
                DLIB_CASSERT(0 < value);
                max_object_size = value;
            }

            double get_min_object_coverage (
            ) const { return min_object_coverage; }
            void set_min_object_coverage (
                double value
            )
            {
                DLIB_CASSERT(0 < value && value <= 1);
                min_object_coverage = value;
            }

            template <
                typename array_type,
                typename rectangle_type
                >
            void operator() (
                size_t num_crops,
                const array_type& images,
                const std::vector<std::vector<rectangle_type>>& rects,
                array_type& crops,
                std::vector<std::vector<rectangle_type>>& crop_rects
            )
            {
                DLIB_CASSERT(images.size() == rects.size());
                crops.clear();
                crop_rects.clear();
                append(num_crops, images, rects, crops, crop_rects);
            }

            template <
                typename array_type,
                typename rectangle_type
                >
            void append (
                size_t num_crops,
                const array_type& images,
                const std::vector<std::vector<rectangle_type>>& rects,
                array_type& crops,
                std::vector<std::vector<rectangle_type>>& crop_rects
            )
            {
                DLIB_CASSERT(images.size() == rects.size());
                DLIB_CASSERT(crops.size() == crop_rects.size());
                auto original_size = crops.size();
                crops.resize(crops.size()+num_crops);
                crop_rects.resize(crop_rects.size()+num_crops);
                parallel_for(original_size, original_size+num_crops, [&](long i) {
                    (*this)(images, rects, crops[i], crop_rects[i]);
                });
            }

            template <
                typename array_type,
                typename image_type,
                typename rectangle_type
                >
            void operator() (
                const array_type& images,
                const std::vector<std::vector<rectangle_type>>& rects,
                image_type& crop,
                std::vector<rectangle_type>& crop_rects
            )
            {
                DLIB_CASSERT(images.size() == rects.size());
                size_t idx;
                { std::lock_guard<std::mutex> lock(rnd_mutex);
                    idx = rnd.get_integer(images.size());
                }
                (*this)(images[idx], rects[idx], crop, crop_rects);
            }

            template <
                typename image_type1,
                typename rectangle_type
                >
            image_type1 operator() (
                const image_type1& img
            )
            {
                image_type1 crop;
                std::vector<rectangle_type> junk1, junk2;
                (*this)(img, junk1, crop, junk2);
                return crop;
            }

            template <
                typename image_type1,
                typename image_type2,
                typename rectangle_type
                >
            void operator() (
                const image_type1& img,
                const std::vector<rectangle_type>& rects,
                image_type2& crop,
                std::vector<rectangle_type>& crop_rects
            )
            {
                DLIB_CASSERT(num_rows(img)*num_columns(img) != 0);
                chip_details crop_plan;
                bool should_flip_crop;
                make_crop_plan(img, rects, crop_plan, should_flip_crop);

                extract_image_chip(img, crop_plan, crop);
                const rectangle_transform tform = get_mapping_to_chip(crop_plan);

                // copy rects into crop_rects and set ones that are outside the crop to ignore or
                // drop entirely as appropriate.
                crop_rects.clear();
                for (auto rect : rects)
                {
                    // map to crop
                    rect.rect = tform(rect.rect);

                    const double intersection = get_rect(crop).intersect(rect.rect).area();

                    // if the rect is at least partly in the crop
                    if (intersection != 0)
                    {
                        // set to ignore if not totally in the crop or if too small.
                        if (intersection / rect.rect.area() < min_object_coverage ||
                            ((long)rect.rect.height() < min_object_length_long_dim  && (long)rect.rect.width() < min_object_length_long_dim) ||
                            ((long)rect.rect.height() < min_object_length_short_dim || (long)rect.rect.width() < min_object_length_short_dim))
                        {
                            rect.ignore = true;
                        }

                        crop_rects.push_back(rect);
                    }
                }

                // Also randomly flip the image
                if (should_flip_crop)
                {
                    image_type2 temp;
                    flip_image_left_right(crop, temp);
                    swap(crop,temp);
                    for (auto&& rect : crop_rects)
                        rect.rect = impl::flip_rect_left_right(rect.rect, get_rect(crop));
                }
            }

        private:

            template <
                typename image_type1,
                typename rectangle_type
                >
            void make_crop_plan (
                const image_type1& img,
                const std::vector<rectangle_type>& rects,
                chip_details& crop_plan,
                bool& should_flip_crop
            )
            {
                std::lock_guard<std::mutex> lock(rnd_mutex);
                rectangle crop_rect;
                if (has_non_ignored_box(rects) && rnd.get_random_double() >= background_crops_fraction)
                {
                    auto rect = rects[randomly_pick_rect(rects)].rect;

                    // perturb the location of the crop by a small fraction of the object's size.
                    const point rand_translate = dpoint(rnd.get_double_in_range(-translate_amount,translate_amount)*std::max(rect.height(),rect.width()),
                                                        rnd.get_double_in_range(-translate_amount,translate_amount)*std::max(rect.height(),rect.width()));

                    // We are going to grow rect into the cropping rect.  First, we grow it a
                    // little so that it has the desired minimum border around it.
                    drectangle drect = centered_drect(center(rect)+rand_translate, rect.width()/max_object_size, rect.height()/max_object_size);

                    // Now make rect have the same aspect ratio as dims so that there won't be
                    // any funny stretching when we crop it.  We do this by growing it along
                    // whichever dimension is too short.
                    const double target_aspect = dims.cols/(double)dims.rows;
                    if (drect.width()/drect.height() < target_aspect)
                        drect = centered_drect(drect, target_aspect*drect.height(), drect.height());
                    else
                        drect = centered_drect(drect, drect.width(), drect.width()/target_aspect);

                    // Now perturb the scale of the crop.  We do this by shrinking it, but not
                    // so much that it gets smaller than the min object sizes require.
                    double current_width = dims.cols*rect.width()/drect.width();
                    double current_height = dims.rows*rect.height()/drect.height();

                    // never make any dimension smaller than the short dim.
                    double min_scale1 = std::max(min_object_length_short_dim/current_width, min_object_length_short_dim/current_height);
                    // at least one dimension needs to be longer than the long dim.
                    double min_scale2 = std::min(min_object_length_long_dim/current_width, min_object_length_long_dim/current_height);
                    double min_scale = std::max(min_scale1, min_scale2);

                    const double rand_scale_perturb = 1.0/rnd.get_double_in_range(min_scale, 1);
                    crop_rect = centered_drect(drect, drect.width()*rand_scale_perturb, drect.height()*rand_scale_perturb);

                }
                else
                {
                    crop_rect = make_random_cropping_rect(img);
                }
                should_flip_crop = randomly_flip && rnd.get_random_double() > 0.5;
                const double angle = rnd.get_double_in_range(-max_rotation_degrees, max_rotation_degrees)*pi/180;
                crop_plan = chip_details(crop_rect, dims, angle);
            }

            template <typename rectangle_type>
            bool has_non_ignored_box (
                const std::vector<rectangle_type>& rects
            ) const
            {
                for (auto&& b : rects)
                {
                    if (!b.ignore)
                        return true;
                }
                return false;
            }

            template <typename rectangle_type>
            size_t randomly_pick_rect (
                const std::vector<rectangle_type>& rects
            )
            {
                DLIB_CASSERT(has_non_ignored_box(rects));
                size_t idx = rnd.get_integer(rects.size());
                while(rects[idx].ignore)
                    idx = rnd.get_integer(rects.size());
                return idx;
            }

            template <typename image_type>
            rectangle make_random_cropping_rect(
                const image_type& img_
            )
            {
                const_image_view<image_type> img(img_);
                // Figure out what rectangle we want to crop from the image.  We are going to
                // crop out an image of size this->dims, so we pick a random scale factor that
                // lets this random box be either as big as it can be while still fitting in
                // the image or as small as a 3x zoomed in box randomly somewhere in the image.
                double mins = 1.0/3.0, maxs = std::min(img.nr()/(double)dims.rows, img.nc()/(double)dims.cols);
                mins = std::min(mins, maxs);
                auto scale = rnd.get_double_in_range(mins, maxs);
                rectangle rect(scale*dims.cols, scale*dims.rows);
                // randomly shift the box around
                point offset(rnd.get_integer(1+img.nc()-rect.width()),
                             rnd.get_integer(1+img.nr()-rect.height()));
                return move_rect(rect, offset);
            }

        };

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

        inline std::ostream& operator<< (
            std::ostream& out,
            const random_cropper& item
        )
        {
            using std::endl;
            out << "random_cropper details: " << endl;
            out << "  chip_dims.rows:              " << item.get_chip_dims().rows << endl;
            out << "  chip_dims.cols:              " << item.get_chip_dims().cols << endl;
            out << "  randomly_flip:               " << std::boolalpha << item.get_randomly_flip() << endl;
            out << "  max_rotation_degrees:        " << item.get_max_rotation_degrees() << endl;
            out << "  min_object_length_long_dim:  " << item.get_min_object_length_long_dim() << endl;
            out << "  min_object_length_short_dim: " << item.get_min_object_length_short_dim() << endl;
            out << "  max_object_size:             " << item.get_max_object_size() << endl;
            out << "  background_crops_fraction:   " << item.get_background_crops_fraction() << endl;
            out << "  translate_amount:            " << item.get_translate_amount() << endl;
            return out;
        }

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

    }

    #endif // DLIB_RaNDOM_CROPPER_H_