Commit 2f6419cd authored by Davis King's avatar Davis King

Added remove_unobtainable_rectangles() for the scan_image_custom scanner.

parent 7da29fb9
......@@ -6,6 +6,7 @@
#include "remove_unobtainable_rectangles_abstract.h"
#include "scan_image_pyramid.h"
#include "scan_image_boxes.h"
#include "scan_image_custom.h"
#include "../svm/structural_object_detection_trainer.h"
#include "../geometry.h"
......@@ -137,90 +138,143 @@ namespace dlib
// ----------------------------------------------------------------------------------------
template <
typename image_array_type,
typename feature_extractor,
typename box_generator
>
std::vector<std::vector<rectangle> > remove_unobtainable_rectangles (
const structural_object_detection_trainer<scan_image_boxes<feature_extractor, box_generator> >& trainer,
const image_array_type& images,
std::vector<std::vector<rectangle> >& object_locations
)
namespace impl
{
using namespace dlib::impl;
// make sure requires clause is not broken
DLIB_ASSERT(images.size() == object_locations.size(),
"\t std::vector<std::vector<rectangle>> remove_unobtainable_rectangles()"
<< "\n\t Invalid inputs were given to this function."
template <
typename image_array_type,
typename scanner_type,
typename get_boxes_functor
>
std::vector<std::vector<rectangle> > remove_unobtainable_rectangles (
get_boxes_functor& bg,
const structural_object_detection_trainer<scanner_type>& trainer,
const image_array_type& images,
std::vector<std::vector<rectangle> >& object_locations
)
{
using namespace dlib::impl;
// make sure requires clause is not broken
DLIB_ASSERT(images.size() == object_locations.size(),
"\t std::vector<std::vector<rectangle>> remove_unobtainable_rectangles()"
<< "\n\t Invalid inputs were given to this function."
);
box_generator bg = trainer.get_scanner().get_box_generator();
std::vector<rectangle> rects;
std::vector<rectangle> rects;
std::vector<std::vector<rectangle> > rejects(images.size());
std::vector<std::vector<rectangle> > rejects(images.size());
// If the trainer is setup to automatically fit the overlap tester to the data then
// we should use the loosest possible overlap tester here. Otherwise we should use
// the tester the trainer will use.
test_box_overlap boxes_overlap(0.9999999,1);
if (!trainer.auto_set_overlap_tester())
boxes_overlap = trainer.get_overlap_tester();
// If the trainer is setup to automatically fit the overlap tester to the data then
// we should use the loosest possible overlap tester here. Otherwise we should use
// the tester the trainer will use.
test_box_overlap boxes_overlap(0.9999999,1);
if (!trainer.auto_set_overlap_tester())
boxes_overlap = trainer.get_overlap_tester();
for (unsigned long k = 0; k < images.size(); ++k)
{
std::vector<rectangle> objs = object_locations[k];
// Don't even bother computing the candidate rectangles if there aren't any
// object locations for this image since there isn't anything to do anyway.
if (objs.size() == 0)
continue;
for (unsigned long k = 0; k < images.size(); ++k)
{
std::vector<rectangle> objs = object_locations[k];
// Don't even bother computing the candidate rectangles if there aren't any
// object locations for this image since there isn't anything to do anyway.
if (objs.size() == 0)
continue;
bg(images[k], rects);
bg(images[k], rects);
// First remove things that don't have any matches with the candidate object
// locations.
std::vector<rectangle> good_rects;
for (unsigned long j = 0; j < objs.size(); ++j)
{
if (matches_rect(rects, objs[j], trainer.get_match_eps()))
good_rects.push_back(objs[j]);
else
rejects[k].push_back(objs[j]);
}
object_locations[k] = good_rects;
// First remove things that don't have any matches with the candidate object
// locations.
std::vector<rectangle> good_rects;
for (unsigned long j = 0; j < objs.size(); ++j)
{
if (matches_rect(rects, objs[j], trainer.get_match_eps()))
good_rects.push_back(objs[j]);
else
rejects[k].push_back(objs[j]);
}
object_locations[k] = good_rects;
// Remap these rectangles to the ones that can come out of the scanner. That
// way when we compare them to each other in the following loop we will know if
// any distinct truth rectangles get mapped to overlapping boxes.
objs.resize(good_rects.size());
for (unsigned long i = 0; i < good_rects.size(); ++i)
objs[i] = get_best_matching_rect(rects, good_rects[i]);
// Remap these rectangles to the ones that can come out of the scanner. That
// way when we compare them to each other in the following loop we will know if
// any distinct truth rectangles get mapped to overlapping boxes.
objs.resize(good_rects.size());
for (unsigned long i = 0; i < good_rects.size(); ++i)
objs[i] = get_best_matching_rect(rects, good_rects[i]);
good_rects.clear();
// now check for truth rects that are too close together.
for (unsigned long i = 0; i < objs.size(); ++i)
{
// check if objs[i] hits another box
bool hit_box = false;
for (unsigned long j = i+1; j < objs.size(); ++j)
good_rects.clear();
// now check for truth rects that are too close together.
for (unsigned long i = 0; i < objs.size(); ++i)
{
if (boxes_overlap(objs[i], objs[j]))
// check if objs[i] hits another box
bool hit_box = false;
for (unsigned long j = i+1; j < objs.size(); ++j)
{
hit_box = true;
break;
if (boxes_overlap(objs[i], objs[j]))
{
hit_box = true;
break;
}
}
if (hit_box)
rejects[k].push_back(object_locations[k][i]);
else
good_rects.push_back(object_locations[k][i]);
}
if (hit_box)
rejects[k].push_back(object_locations[k][i]);
else
good_rects.push_back(object_locations[k][i]);
object_locations[k] = good_rects;
}
object_locations[k] = good_rects;
return rejects;
}
return rejects;
// ----------------------------------------------------------------------------------------
template <typename T>
struct load_to_functor
{
load_to_functor(T& obj_) : obj(obj_) {}
T& obj;
template <typename U, typename V>
void operator()(const U& u, V& v)
{
obj.load(u,v);
}
};
}
// ----------------------------------------------------------------------------------------
template <
typename image_array_type,
typename feature_extractor,
typename box_generator
>
std::vector<std::vector<rectangle> > remove_unobtainable_rectangles (
const structural_object_detection_trainer<scan_image_boxes<feature_extractor, box_generator> >& trainer,
const image_array_type& images,
std::vector<std::vector<rectangle> >& object_locations
)
{
box_generator bg = trainer.get_scanner().get_box_generator();
return impl::remove_unobtainable_rectangles(bg, trainer, images, object_locations);
}
// ----------------------------------------------------------------------------------------
template <
typename image_array_type,
typename feature_extractor
>
std::vector<std::vector<rectangle> > remove_unobtainable_rectangles (
const structural_object_detection_trainer<scan_image_custom<feature_extractor> >& trainer,
const image_array_type& images,
std::vector<std::vector<rectangle> >& object_locations
)
{
feature_extractor fe;
fe.copy_configuration(trainer.get_scanner().get_feature_extractor());
impl::load_to_functor<feature_extractor> bg(fe);
return impl::remove_unobtainable_rectangles(bg, trainer, images, object_locations);
}
// ----------------------------------------------------------------------------------------
......
......@@ -5,6 +5,7 @@
#include "scan_image_pyramid_abstract.h"
#include "scan_image_boxes_abstract.h"
#include "scan_image_custom_abstract.h"
#include "../svm/structural_object_detection_trainer_abstract.h"
#include "../geometry.h"
......@@ -76,6 +77,37 @@ namespace dlib
- V[i] == the set of rectangles removed from object_locations[i]
!*/
// ----------------------------------------------------------------------------------------
template <
typename image_array_type,
typename feature_extractor
>
std::vector<std::vector<rectangle> > remove_unobtainable_rectangles (
const structural_object_detection_trainer<scan_image_custom<feature_extractor> >& trainer,
const image_array_type& images,
std::vector<std::vector<rectangle> >& object_locations
);
/*!
requires
- images.size() == object_locations.size()
ensures
- Recall that the scan_image_custom object can't produce all possible rectangles
as object detections since it only considers a limited subset of all possible
object positions. Moreover, the structural_object_detection_trainer requires
its input training data to not contain any object positions which are unobtainable
by its scanner object. Therefore, remove_unobtainable_rectangles() is a tool
to filter out these unobtainable rectangles from the training data before giving
it to a structural_object_detection_trainer.
- This function interprets object_locations[i] as the set of object positions for
image[i], for all valid i.
- In particular, this function removes unobtainable rectangles from object_locations
and also returns a vector V such that:
- V.size() == object_locations.size()
- for all valid i:
- V[i] == the set of rectangles removed from object_locations[i]
!*/
// ----------------------------------------------------------------------------------------
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment