/// the out integral channel will be resized to the required dimensions
void get_integral_channels(const integral_channels_t &in,
const point_t &modelWindowSize, const point_t &dataOffset, const int resizing_factor,
integral_channels_t &out)
{
get_integral_channels(in,
dataOffset.x(), dataOffset.y(),
modelWindowSize.x(), modelWindowSize.y(),
resizing_factor,
out);
return;
}
bool Polygon::within_n(const point_t &p, double d2) const
{
if (_in_mbr(p)) {
for (size_t i = 0; i < outer_.size(); ++i)
if (outer_[i].contains(p))
return outer_[i].within_n(p, d2);
for (size_t i = 0; i < inner_.size(); ++i)
if (inner_[i].contains(p))
return inner_[i].within_n(p, d2);
return true;
} else {
if (p.y() >= mbr_[0]) return _within_n(p, d2, 0);
if (p.x() <= mbr_[1]) return _within_n(p, d2, 1);
if (p.y() <= mbr_[2]) return _within_n(p, d2, 2);
if (p.x() >= mbr_[3]) return _within_n(p, d2, 3);
}
// not reachable
return true;
}
void TrainingData::addPositiveSamples(const std::vector<std::string> &filenamesPositives,
const point_t &modelWindowSize, const point_t &dataOffset)
{
const size_t
initialNumberOfTrainingSamples = getNumExamples(), // yl images number have been added to the training set
finalNumberOfTrainingSamples = initialNumberOfTrainingSamples + filenamesPositives.size();
if(finalNumberOfTrainingSamples > getMaxNumExamples())
{
throw std::runtime_error("TrainingData::addPositiveSamples is trying to add more data than initially specified");
}
printf("\nCollecting %zi positive samples\n", filenamesPositives.size());
boost::progress_display progress_indicator(filenamesPositives.size());
meta_datum_t metaDatum;
integral_channels_t sampleIntegralChannels;
// integralChannelsComputer is already multithreaded, so no benefit on paralelizing this for loop
for (size_t filenameIndex = 0; filenameIndex < filenamesPositives.size(); filenameIndex +=1)
{
gil::rgb8_image_t image;
gil::rgb8c_view_t image_view = doppia::open_image(filenamesPositives[filenameIndex].c_str(), image);
_integralChannelsComputer.set_image(image_view);
_integralChannelsComputer.compute();
get_integral_channels(_integralChannelsComputer.get_integral_channels(),
modelWindowSize, dataOffset, _integralChannelsComputer.get_shrinking_factor(),// shrinking factor = 4
sampleIntegralChannels);
metaDatum.filename = filenamesPositives[filenameIndex];
metaDatum.imageClass = 1;//classes[k];
metaDatum.x = dataOffset.x();
metaDatum.y = dataOffset.y();
setDatum(initialNumberOfTrainingSamples + filenameIndex,
metaDatum, sampleIntegralChannels);
++progress_indicator;
} // end of "for each filename"
return;
}
void ModelIO::initWrite(const std::string datasetName,
const DetectorModel::DetectorTypes type,
const std::string detectorName,
const point_t modelWindow,
const rectangle_t objectWindow)
{
doppia_protobuf::Point2d *model_window = _model.mutable_model_window_size();
model_window->set_x(modelWindow.x());
model_window->set_y(modelWindow.y());
doppia_protobuf::Box *b = _model.mutable_object_window();
b->mutable_min_corner()->set_x(objectWindow.min_corner().x());
b->mutable_min_corner()->set_y(objectWindow.min_corner().y());
b->mutable_max_corner()->set_x(objectWindow.max_corner().x());
b->mutable_max_corner()->set_y(objectWindow.max_corner().y());
_model.set_training_dataset_name(datasetName.c_str());
_model.set_detector_type(type);
_model.set_detector_name(detectorName);
return;
}
bool operator ==(const point_t& a, const point_t& b)
{
return QuasiEqual(a.x(), b.x(), margin) && QuasiEqual(a.y(), b.y(), margin) && QuasiEqual(a.z(), b.z(), margin);
}
void TrainingData::addNegativeSamples(const std::vector<std::string> &filenamesBackground,
const point_t &modelWindowSize, const point_t &dataOffset,
const size_t numNegativeSamplesToAdd)
{
int feature_extraction_time = 0, image_loading_time = 0, tmp_time;
const size_t
initialNumberOfTrainingSamples = get_num_examples(),
finalNumberOfTrainingSamples = initialNumberOfTrainingSamples + numNegativeSamplesToAdd;
if(finalNumberOfTrainingSamples > getMaxNumExamples())
{
throw std::runtime_error("TrainingData::addNegativeSamples is trying to add more data than initially specified");
}
printf("\nCollecting %zi random negative samples\n", numNegativeSamplesToAdd);
doppia::progress_display_with_eta progress_indicator(numNegativeSamplesToAdd);
meta_datum_t metaDatum;
integral_channels_t sampleIntegralChannels;
#if defined(DEBUG)
srand(1);
#else
srand(time(NULL));
#endif
srand(1);
const int samplesPerImage = std::max<int>(1, numNegativeSamplesToAdd / filenamesBackground.size());
// FIXME no idea what the +1 does
const int
minWidth = (modelWindowSize.x()+1 + 2*dataOffset.x()),
minHeight = (modelWindowSize.y()+1 + 2*dataOffset.y());
const float maxSkippedFraction = 0.25;
size_t numNegativesSamplesAdded = 0, numSkippedImages = 0, filenameIndex = 0;
// integralChannelsComputer is already multithreaded, so no benefit on paralelizing this for loop
while (numNegativesSamplesAdded < numNegativeSamplesToAdd)
{
if (filenameIndex >= filenamesBackground.size())
{
// force to loop until we have reached the desired number of samples
filenameIndex = 0;
}
const string &background_image_path = filenamesBackground[filenameIndex];
filenameIndex +=1;
gil::rgb8c_view_t imageView;
gil::rgb8_image_t image;
//tmp_time = (int)round(omp_get_wtime());
imageView = doppia::open_image(background_image_path.c_str(), image);
//image_loading_time += (int)round(omp_get_wtime()) - tmp_time;
if ((imageView.width() < minWidth) or (imageView.height() < minHeight))
{
// if input image is too small, we skip it
//printf("Skipping negative sample %s, because it is too small\n", filename.c_str());
numSkippedImages += 1;
const float skippedFraction = static_cast<float>(numSkippedImages) / filenamesBackground.size();
if (skippedFraction > maxSkippedFraction)
{
printf("Skipped %zi images (out of %zi, %.3f%%) because they where too small (or too big to process)\n",
numSkippedImages, filenamesBackground.size(), skippedFraction*100);
throw std::runtime_error("Too many negatives images where skipped. Dataset needs to be fixed");
}
continue;
}
const int
maxRandomX = (imageView.width() - modelWindowSize.x()+1 - 2*dataOffset.x()),
maxRandomY = (imageView.height() - modelWindowSize.y()+1 - 2*dataOffset.y());
try
{
// FIXME harcoded values
const size_t
expected_channels_size = imageView.size()*10,
max_texture_size = 134217728; // 2**27 for CUDA capability 2.x
if(expected_channels_size > max_texture_size)
{
throw std::invalid_argument("The image is monstruously big!");
}
const boost::filesystem::path file_path = background_image_path;
#if BOOST_VERSION <= 104400
const std::string filename = file_path.filename();
#else
const std::string filename = file_path.filename().string();
#endif
tmp_time = (int)round(omp_get_wtime());
_integralChannelsComputer->set_image(imageView, filename);
image_loading_time += (int)round(omp_get_wtime()) - tmp_time;
tmp_time = (int)round(omp_get_wtime());
_integralChannelsComputer->compute();
feature_extraction_time += (int)round(omp_get_wtime()) - tmp_time;
}
catch(std::exception &e)
{
printf("Computing integral channels of image %s \033[1;31mfailed\033[0m (size %zix%zi). Skipping it. Error was:\n%s\n",
background_image_path.c_str(),
imageView.width(), imageView.height(),
e.what());
numSkippedImages += 1;
continue; // we skip this image
}
catch(...)
{
printf("Computing integral channels of %s \033[1;31mfailed\033[0m (size %zix%zi). Skipping it. Received unknown error.\n",
background_image_path.c_str(),
imageView.width(), imageView.height());
numSkippedImages += 1;
continue; // we skip this image
}
metaDatum.filename = background_image_path;
metaDatum.imageClass = _backgroundClassLabel;
size_t numSamplesForImage = std::min<size_t>(samplesPerImage,
(numNegativeSamplesToAdd - numNegativesSamplesAdded));
numSamplesForImage = 1;
for (size_t randomSampleIndex = 0; randomSampleIndex < numSamplesForImage; randomSampleIndex += 1)
{
//const point_t::coordinate_t
size_t
x = dataOffset.x() + rand() % maxRandomX,
y = dataOffset.y() + rand() % maxRandomY;
//printf("random x,y == %i, %i\n", x,y);
const point_t randomOffset(x,y);
metaDatum.x = randomOffset.x(); metaDatum.y = randomOffset.y();
//tmp_time = (int)round(omp_get_wtime());
get_integral_channels(_integralChannelsComputer->get_integral_channels(),
modelWindowSize, randomOffset, doppia::IntegralChannelsForPedestrians::get_shrinking_factor(),
sampleIntegralChannels);
//image_loading_time += (int)round(omp_get_wtime()) - tmp_time;
setDatum(initialNumberOfTrainingSamples + numNegativesSamplesAdded,
metaDatum, sampleIntegralChannels);
numNegativesSamplesAdded += 1;
++progress_indicator;
}
} // end of "for each background image"
if (numSkippedImages > 0)
{
const float skippedFraction = static_cast<float>(numSkippedImages) / filenamesBackground.size();
printf("Skipped %zi images (out of %zi, %.3f%%) because they where too small (or too big to process)\n",
numSkippedImages, filenamesBackground.size(), skippedFraction*100);
}
printf("Time elapsed while loading negative images: %02d:%02d:%02d\n",
image_loading_time/3600, (image_loading_time%3600)/60, image_loading_time%60);
printf("Time elapsed while extracting features from negative images: %02d:%02d:%02d\n",
feature_extraction_time/3600, (feature_extraction_time%3600)/60, feature_extraction_time%60);
return;
}
void TrainingData::addHardNegativeSamples(const std::vector<std::string> &filenamesHardNegatives,
const point_t &modelWindowSize, const point_t &dataOffset)
{
int feature_extraction_time = 0, image_loading_time = 0, tmp_time;
const size_t
initialNumberOfTrainingSamples = get_num_examples(),
finalNumberOfTrainingSamples = initialNumberOfTrainingSamples + filenamesHardNegatives.size();
if(finalNumberOfTrainingSamples > getMaxNumExamples())
{
throw std::runtime_error("TrainingData::addHardNegativeSamples "
"is trying to add more data than initially specified");
}
printf("\nCollecting %zi hard negative samples\n", filenamesHardNegatives.size());
doppia::progress_display_with_eta progress_indicator(filenamesHardNegatives.size());
meta_datum_t metaDatum;
integral_channels_t sampleIntegralChannels;
// integralChannelsComputer is already multithreaded, so no benefit on paralelizing this for loop
for (size_t filenameIndex = 0; filenameIndex < filenamesHardNegatives.size(); filenameIndex +=1)
{
tmp_time = (int)round(omp_get_wtime());
gil::rgb8_image_t image;
gil::rgb8c_view_t image_view = doppia::open_image(filenamesHardNegatives[filenameIndex].c_str(), image);
const boost::filesystem::path file_path = filenamesHardNegatives[filenameIndex];
#if BOOST_VERSION <= 104400
const std::string filename = file_path.filename();
#else
const std::string filename = file_path.filename().string();
#endif
_integralChannelsComputer->set_image(image_view, filename);
image_loading_time += (int)round(omp_get_wtime()) - tmp_time;
tmp_time = (int)round(omp_get_wtime());
_integralChannelsComputer->compute();
feature_extraction_time += (int)round(omp_get_wtime()) - tmp_time;
get_integral_channels(_integralChannelsComputer->get_integral_channels(),
modelWindowSize, dataOffset, doppia::IntegralChannelsForPedestrians::get_shrinking_factor(),
sampleIntegralChannels);
metaDatum.filename = filenamesHardNegatives[filenameIndex];
metaDatum.imageClass = _backgroundClassLabel;
metaDatum.x = dataOffset.x();
metaDatum.y = dataOffset.y();
setDatum(initialNumberOfTrainingSamples + filenameIndex, metaDatum, sampleIntegralChannels);
++progress_indicator;
} // end of "for each filename"
printf("Time elapsed while loading images for hard negatives extraction: %02d:%02d:%02d\n",
image_loading_time/3600, (image_loading_time%3600)/60, image_loading_time%60);
printf("Time elapsed while extracting features from hard negatives: %02d:%02d:%02d\n",
feature_extraction_time/3600, (feature_extraction_time%3600)/60, feature_extraction_time%60);
return;
}
void TrainingData::addNegativeSamples(const std::vector<std::string> &filenamesBackground,
const point_t &modelWindowSize, const point_t &dataOffset,
const size_t numNegativeSamplesToAdd)
{
const size_t
initialNumberOfTrainingSamples = getNumExamples(),
finalNumberOfTrainingSamples = initialNumberOfTrainingSamples + numNegativeSamplesToAdd;
if(finalNumberOfTrainingSamples > getMaxNumExamples())
{
throw std::runtime_error("TrainingData::addNegativeSamples is trying to add more data than initially specified");
}
printf("\nCollecting %zi random negative samples\n", numNegativeSamplesToAdd);
boost::progress_display progress_indicator(numNegativeSamplesToAdd);
meta_datum_t metaDatum;
integral_channels_t sampleIntegralChannels;
#if defined(DEBUG)
srand(1);
#else
srand(time(NULL));
#endif
srand(1);
const int samplesPerImage = std::max<int>(1, numNegativeSamplesToAdd / filenamesBackground.size());
// FIXME no idea what the +1 does
const int
minWidth = (modelWindowSize.x()+1 + 2*dataOffset.x()),
minHeight = (modelWindowSize.y()+1 + 2*dataOffset.y());
const float maxSkippedFraction = 0.25;
size_t numNegativesSamplesAdded = 0, numSkippedImages = 0, filenameIndex = 0;
// integralChannelsComputer is already multithreaded, so no benefit on paralelizing this for loop
while (numNegativesSamplesAdded < numNegativeSamplesToAdd)
{
if (filenameIndex >= filenamesBackground.size())
{
// force to loop until we have reached the desired number of samples
filenameIndex = 0;
}
const string &filename = filenamesBackground[filenameIndex];
filenameIndex +=1;
gil::rgb8c_view_t imageView;
gil::rgb8_image_t image;
imageView = doppia::open_image(filename.c_str(), image);
if ((imageView.width() < minWidth) or (imageView.height() < minHeight))
{
// if input image is too small, we skip it
//printf("Skipping negative sample %s, because it is too small\n", filename.c_str());
numSkippedImages += 1;
const float skippedFraction = static_cast<float>(numSkippedImages) / filenamesBackground.size();
if (skippedFraction > maxSkippedFraction)
{
printf("Skipped %i images (out of %zi, %.3f%%) because they where too small\n",
numSkippedImages, filenamesBackground.size(), skippedFraction*100);
throw std::runtime_error("Too many negatives images where skipped. Dataset needs to be fixed");
}
continue;
}
const int
maxRandomX = (imageView.width() - modelWindowSize.x()+1 - 2*dataOffset.x()),
maxRandomY = (imageView.height() - modelWindowSize.y()+1 - 2*dataOffset.y());
_integralChannelsComputer.set_image(imageView);
_integralChannelsComputer.compute();
metaDatum.filename = filename;
metaDatum.imageClass = _backgroundClassLabel;
size_t numSamplesForImage = std::min<size_t>(samplesPerImage,
(numNegativeSamplesToAdd - numNegativesSamplesAdded));
numSamplesForImage = 1;
for (size_t randomSampleIndex = 0; randomSampleIndex < numSamplesForImage; randomSampleIndex += 1)
{
//const point_t::coordinate_t
size_t
x = dataOffset.x() + rand() % maxRandomX,
y = dataOffset.y() + rand() % maxRandomY;
//printf("random x,y == %i, %i\n", x,y);
const point_t randomOffset(x,y);
metaDatum.x = randomOffset.x(); metaDatum.y = randomOffset.y();
get_integral_channels(_integralChannelsComputer.get_integral_channels(),
modelWindowSize, randomOffset, _integralChannelsComputer.get_shrinking_factor(),
sampleIntegralChannels);
setDatum(initialNumberOfTrainingSamples + numNegativesSamplesAdded,
metaDatum, sampleIntegralChannels);
numNegativesSamplesAdded += 1;
++progress_indicator;
}
} // end of "for each background image"
if (numSkippedImages > 0)
{
const float skippedFraction = static_cast<float>(numSkippedImages) / filenamesBackground.size();
printf("Skipped %zi images (out of %zi, %.3f%%) because they where too small\n",
numSkippedImages, filenamesBackground.size(), skippedFraction*100);
}
return;
}
inline bool operator<( point_t<Origin> const& lhs, point_t<Origin> const& rhs ) noexcept
{
return lhs.x() * lhs.x() + lhs.y() * lhs.y() < rhs.x() * rhs.x() + rhs.y() * rhs.y();
}
inline bool operator==( point_t<origin_type::client> const& lhs, point_t<origin_type::client> const& rhs ) noexcept
{
return lhs.window_handle() == rhs.window_handle() && lhs.x() == rhs.x() && lhs.y() == rhs.y();
}
inline bool operator==( point_t<origin_type::screen> const& lhs, point_t<origin_type::screen> const& rhs ) noexcept
{
return lhs.x() == rhs.x() && lhs.y() == rhs.y();
}