ClassifierInformation RecognitionController::load_classifier_from_file(const char* classifier_file_name)
{
if (classifier_file_name == nullptr)
throw RecognitionException("Argument 'classifier_file_name' cannot be null");
return this->load_classifier_from_file(std::string(classifier_file_name));
}
ClassifierInformation RecognitionController::load_classifier(const char* classifier_xml)
{
if (classifier_xml == nullptr)
throw RecognitionException("Argument 'classifier_xml' cannot be null");
return this->load_classifier(std::string(classifier_xml));
}
RecognitionResult RecognitionController::perform_recognition(const PattCutLib::Image& image, const std::vector<int>& classifier_ids, int min_object_size, int max_object_size, double scale_factor, double step_factor) const
{
if (scale_factor >= 0 && scale_factor <= 1.0)
throw RecognitionException("Argument 'scale_factor' should be greater than 1.0 (or less than 0 to use as default value)");
MultiClassViolaJonesController* controller = (MultiClassViolaJonesController*)_multi_class_viola_jones_controller;
::Image* image_ptr = extract_image_ptr(image);
try
{
if (image_ptr == nullptr)
return RecognitionResult();
auto rec_result = controller->recognize(*image_ptr, classifier_ids, min_object_size, max_object_size, scale_factor, step_factor);
return transform_results(rec_result);
}
catch (LibraryException& l_exc)
{
throw RecognitionException(std::string("Library exception: ") + l_exc.what());
}
}
RecognitionResult RecognitionController::perform_recognition(const std::string& image_file_name, const std::vector<int>& classifier_ids, int min_object_size, int max_object_size, double scale_factor, double step_factor) const
{
if (scale_factor >= 0 && scale_factor <= 1.0)
throw RecognitionException("Argument 'scale_factor' should be greater than 1.0 (or less than 0 to use as default value)");
MultiClassViolaJonesController* controller = (MultiClassViolaJonesController*)_multi_class_viola_jones_controller;
try
{
auto image = ImageLoader::load(image_file_name);
auto rec_result = controller->recognize(image, classifier_ids, min_object_size, max_object_size, scale_factor, step_factor);
return transform_results(rec_result);
}
catch (ImageLoadingException& il_exc)
{
throw RecognitionException(std::string("Image loading exception: ") + il_exc.what());
}
catch (LibraryException& l_exc)
{
throw RecognitionException(std::string("Library exception: ") + l_exc.what());
}
}
RecognitionResult RecognitionController::perform_recognition(const char* image_file_name, const int* classifier_ids, size_t classifier_ids_length, int min_object_size, int max_object_size, double scale_factor, double step_factor) const
{
if (image_file_name == nullptr)
throw RecognitionException("Argument 'image_file_name' cannot be null");
if (classifier_ids == nullptr || classifier_ids_length == 0)
return this->perform_recognition(std::string(image_file_name), std::vector<int>(), min_object_size, max_object_size, scale_factor, step_factor);
std::vector<int> ids(classifier_ids_length);
for (size_t i = 0; i < classifier_ids_length; i++)
ids[i] = classifier_ids[i];
return this->perform_recognition(std::string(image_file_name), ids, min_object_size, max_object_size, scale_factor, step_factor);
}
ClassifierInformation RecognitionController::load_classifier_from_file(const std::string& classifier_file_name)
{
MultiClassViolaJonesController* controller = (MultiClassViolaJonesController*)_multi_class_viola_jones_controller;
int my_id = _last_classifier_id++;
try
{
auto classifier = ClassifierLoader::load_from_file(classifier_file_name, ClassificationTag(my_id), ClassificationTag(0));
int wnd_width = classifier.get_wnd_width();
int wnd_height = classifier.get_wnd_height();
controller->add_recognizer(my_id, std::move(classifier));
return ClassifierInformation(my_id, wnd_width, wnd_height);
}
catch (ClassifierLoadingException& cl_exc)
{
throw RecognitionException(std::string("Classifier loading exception: ") + cl_exc.what());
}
catch (LibraryException& l_exc)
{
throw RecognitionException(std::string("Library exception: ") + l_exc.what());
}
}
void list() {
bool failed = false;
auto startTokenIndex = index();
if (isSpeculating() && alreadyParsedRule(list_memo))
return;
try { _list(); }
catch (RecognitionException re) {
failed = true;
if (isSpeculating())
memoize(list_memo, startTokenIndex, failed);
throw RecognitionException();
}
if (isSpeculating())
memoize(list_memo, startTokenIndex, failed);
}
