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

    #include "box_overlap_testing_abstract.h"
    #include "../geometry.h"
    #include <vector>

    namespace dlib
    {

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

        inline double box_intersection_over_union (
            const drectangle& a,
            const drectangle& b
        )
        {
            const double inner = a.intersect(b).area();
            if (inner == 0)
                return 0;
            const double outer = a.area() + b.area() - inner;
            return inner / outer;
        }

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

        inline double box_intersection_over_union (
            const rectangle& a,
            const rectangle& b
        )
        {
            return box_intersection_over_union(drectangle(a),drectangle(b));
        }

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

        inline double box_percent_covered (
            const drectangle& a,
            const drectangle& b
        )
        {
            const double inner = a.intersect(b).area();
            if (inner == 0)
                return 0;
            return std::max(inner/a.area(), inner/b.area());
        }

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

        inline double box_percent_covered (
            const rectangle& a,
            const rectangle& b
        )
        {
            return box_percent_covered(drectangle(a), drectangle(b));
        }

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

        class test_box_overlap
        {
        public:
            test_box_overlap (
            ) : iou_thresh(0.5), percent_covered_thresh(1.0)
            {}

            explicit test_box_overlap (
                double iou_thresh_,
                double percent_covered_thresh_ = 1.0
            ) : iou_thresh(iou_thresh_), percent_covered_thresh(percent_covered_thresh_)
            {
                // make sure requires clause is not broken
                DLIB_ASSERT(0 <= iou_thresh && iou_thresh <= 1  &&
                            0 <= percent_covered_thresh && percent_covered_thresh <= 1,
                    "\t test_box_overlap::test_box_overlap(iou_thresh, percent_covered_thresh)"
                    << "\n\t Invalid inputs were given to this function "
                    << "\n\t iou_thresh:   " << iou_thresh
                    << "\n\t percent_covered_thresh: " << percent_covered_thresh
                    << "\n\t this: " << this
                    );

            }

            bool operator() (
                const dlib::rectangle& a,
                const dlib::rectangle& b
            ) const
            {
                const double inner = a.intersect(b).area();
                if (inner == 0)
                    return false;

                const double outer = (a+b).area();
                if (inner/outer > iou_thresh ||
                    inner/a.area() > percent_covered_thresh ||
                    inner/b.area() > percent_covered_thresh)
                    return true;
                else
                    return false;
            }

            double get_percent_covered_thresh (
            ) const
            {
                return percent_covered_thresh;
            }

            double get_iou_thresh (
            ) const
            {
                return iou_thresh;
            }

        private:
            double iou_thresh;
            double percent_covered_thresh;
        };

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

        inline void serialize (
            const test_box_overlap& item,
            std::ostream& out
        )
        {
            serialize(item.get_iou_thresh(), out);
            serialize(item.get_percent_covered_thresh(), out);
        }

        inline void deserialize (
            test_box_overlap& item,
            std::istream& in
        )
        {
            double percent_covered_thresh, iou_thresh;
            deserialize(iou_thresh, in);
            deserialize(percent_covered_thresh, in);
            item = test_box_overlap(iou_thresh, percent_covered_thresh);
        }

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

        inline test_box_overlap find_tight_overlap_tester (
            const std::vector<std::vector<rectangle> >& rects
        )
        {
            double max_pcov = 0;
            double max_iou_score = 0;
            for (unsigned long i = 0; i < rects.size(); ++i)
            {
                for (unsigned long j = 0; j < rects[i].size(); ++j)
                {
                    for (unsigned long k = j+1; k < rects[i].size(); ++k)
                    {
                        const rectangle a = rects[i][j];
                        const rectangle b = rects[i][k];
                        const double iou_score = (a.intersect(b)).area()/(double)(a+b).area();
                        const double pcov_a   = (a.intersect(b)).area()/(double)(a).area();
                        const double pcov_b   = (a.intersect(b)).area()/(double)(b).area();

                        if (iou_score > max_iou_score)
                            max_iou_score = iou_score;

                        if (pcov_a > max_pcov)
                            max_pcov = pcov_a;
                        if (pcov_b > max_pcov)
                            max_pcov = pcov_b;
                    }
                }
            }

            // Relax these thresholds very slightly.  We do this because on some systems the
            // boxes that generated the max values erroneously trigger a box overlap iou even
            // though their percent covered and iou values are *equal* to the thresholds but
            // not greater.  That is, sometimes when double values get moved around they change
            // their values slightly, so this avoids the problems that can create.
            max_iou_score = std::min(1.0000001*max_iou_score, 1.0);
            max_pcov     = std::min(1.0000001*max_pcov,     1.0);
            return test_box_overlap(max_iou_score, max_pcov);
        }

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

        inline bool overlaps_any_box (
            const test_box_overlap& tester,
            const std::vector<rectangle>& rects,
            const rectangle& rect
        )
        {
            for (unsigned long i = 0; i < rects.size(); ++i)
            {
                if (tester(rects[i],rect))
                    return true;
            }
            return false;
        }

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

        inline bool overlaps_any_box (
            const std::vector<rectangle>& rects,
            const rectangle& rect
        )
        {
            return overlaps_any_box(test_box_overlap(),rects,rect);
        }

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

    }

    #endif // DLIB_BOX_OVERlAP_TESTING_Hh_