int main(int argc, char **argv)
{
int ret = 0;
catcierge_matcher_t *matcher = NULL;
char *img_paths[4096];
IplImage *imgs[4096];
size_t img_count = 0;
IplImage *img = NULL;
CvSize img_size;
CvScalar match_color;
int match_success = 0;
double match_res = 0;
int debug = 0;
int i;
int j;
int show = 0;
int save = 0;
char *output_path = "output";
double match_threshold = 0.8;
int success_count = 0;
int preload = 0;
int test_matchable = 0;
const char *matcher_str = NULL;
match_result_t result;
clock_t start;
clock_t end;
catcierge_template_matcher_args_t args;
catcierge_haar_matcher_args_t hargs;
char *key = NULL;
char *values[4096];
size_t value_count = 0;
memset(&args, 0, sizeof(args));
memset(&result, 0, sizeof(result));
fprintf(stderr, "Catcierge Image match Tester (C) Joakim Soderberg 2013-2014\n");
if (argc < 4)
{
fprintf(stderr, "Usage: %s\n"
" [--output [path]]\n"
" [--debug]\n"
" [--show]\n"
" [--match_flipped <0|1>]\n"
" [--threshold]\n"
" [--preload]\n"
" [--test_matchable]\n"
" [--snout <snout images for template matching>]\n"
" [--cascade <haar cascade xml>]\n"
" --images <input images>\n"
" --matcher <template|haar>\n", argv[0]);
return -1;
}
catcierge_haar_matcher_args_init(&hargs);
catcierge_template_matcher_args_init(&args);
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "--show"))
{
show = 1;
continue;
}
else if (!strcmp(argv[i], "--output"))
{
save = 1;
if ((i + 1) < argc)
{
if (strncmp(argv[i+1], "--", 2))
{
i++;
output_path = argv[i];
}
}
continue;
}
else if (!strcmp(argv[i], "--test_matchable")
|| !strcmp(argv[i], "--test_obstructed"))
{
test_matchable = 1;
preload = 1;
}
else if (!strcmp(argv[i], "--debug"))
{
debug = 1;
}
else if (!strcmp(argv[i], "--images"))
{
while (((i + 1) < argc)
&& strncmp(argv[i+1], "--", 2))
{
i++;
img_paths[img_count] = argv[i];
img_count++;
}
}
else if (!strcmp(argv[i], "--preload"))
{
if ((i + 1) < argc)
{
i++;
preload = 1;
continue;
}
}
else if (!strcmp(argv[i], "--matcher"))
{
if ((i + 1) < argc)
{
if (strncmp(argv[i+1], "--", 2))
{
i++;
matcher_str = argv[i];
if (strcmp(matcher_str, "template") && strcmp(matcher_str, "haar"))
{
fprintf(stderr, "Invalid matcher type \"%s\"\n", matcher_str);
return -1;
}
}
}
continue;
}
else if (!strncmp(argv[i], "--", 2))
{
int j = i + 1;
key = &argv[i][2];
memset(values, 0, value_count * sizeof(char *));
value_count = 0;
// Look for values for the option.
// Continue fetching values until we get another option
// or there are no more options.
while ((j < argc) && strncmp(argv[j], "--", 2))
{
values[value_count] = argv[j];
value_count++;
i++;
j = i + 1;
}
if ((ret = parse_arg(&args, &hargs, key, values, value_count)) < 0)
{
fprintf(stderr, "Failed to parse command line arguments for \"%s\"\n", key);
return ret;
}
}
else
{
fprintf(stderr, "Unknown command line argument \"%s\"\n", argv[i]);
return -1;
}
}
if (!matcher_str)
{
fprintf(stderr, "You must specify a matcher type\n");
return -1;
}
if (!strcmp(matcher_str, "template") && (args.snout_count == 0))
{
fprintf(stderr, "No snout image specified\n");
return -1;
}
if (!strcmp(matcher_str, "haar") && !hargs.cascade)
{
fprintf(stderr, "No haar cascade specified\n");
return -1;
}
if (img_count == 0)
{
fprintf(stderr, "No input image specified\n");
return -1;
}
// Create output directory.
if (save)
{
catcierge_make_path("%s", output_path);
}
args.super.type = MATCHER_TEMPLATE;
hargs.super.type = MATCHER_HAAR;
if (catcierge_matcher_init(&matcher,
(!strcmp(matcher_str, "template")
? (catcierge_matcher_args_t *)&args
: (catcierge_matcher_args_t *)&hargs)))
{
fprintf(stderr, "Failed to init %s matcher.\n", matcher_str);
return -1;
}
matcher->debug = debug;
if (!matcher->is_obstructed)
matcher->is_obstructed = catcierge_is_frame_obstructed;
//catcierge_set_binary_thresholds(&ctx, 90, 200);
// If we should preload the images or not
// (Don't let file IO screw with benchmark)
if (preload)
{
for (i = 0; i < (int)img_count; i++)
{
printf("Preload image %s\n", img_paths[i]);
if (!(imgs[i] = cvLoadImage(img_paths[i], 1)))
{
fprintf(stderr, "Failed to load match image: %s\n", img_paths[i]);
ret = -1;
goto fail;
}
}
}
start = clock();
if (test_matchable)
{
for (i = 0; i < (int)img_count; i++)
{
// This tests if an image frame is clear or not (matchable).
int frame_obstructed;
if ((frame_obstructed = matcher->is_obstructed(matcher, imgs[i])) < 0)
{
fprintf(stderr, "Failed to detect check for matchability frame\n");
return -1;
}
printf("%s: Frame obstructed = %d\n",
img_paths[i], frame_obstructed);
if (show)
{
cvShowImage("image", imgs[i]);
cvWaitKey(0);
}
}
}
else
{
for (i = 0; i < (int)img_count; i++)
{
match_success = 0;
printf("---------------------------------------------------\n");
printf("%s:\n", img_paths[i]);
if (preload)
{
img = imgs[i];
}
else
{
if (!(img = cvLoadImage(img_paths[i], 1)))
{
fprintf(stderr, "Failed to load match image: %s\n", img_paths[i]);
goto fail;
}
}
img_size = cvGetSize(img);
printf(" Image size: %dx%d\n", img_size.width, img_size.height);
if ((match_res = matcher->match(matcher, img, &result, 0)) < 0)
{
fprintf(stderr, "Something went wrong when matching image: %s\n", img_paths[i]);
catcierge_matcher_destroy(&matcher);
return -1;
}
match_success = (match_res >= match_threshold);
if (match_success)
{
printf(" Match (%s)! %f\n", catcierge_get_direction_str(result.direction), match_res);
match_color = CV_RGB(0, 255, 0);
success_count++;
}
else
{
printf(" No match! %f\n", match_res);
match_color = CV_RGB(255, 0, 0);
}
if (show || save)
{
for (j = 0; j < (int)result.rect_count; j++)
{
printf("x: %d\n", result.match_rects[j].x);
printf("y: %d\n", result.match_rects[j].y);
printf("w: %d\n", result.match_rects[j].width);
printf("h: %d\n", result.match_rects[j].height);
cvRectangleR(img, result.match_rects[j], match_color, 1, 8, 0);
}
if (show)
{
cvShowImage("image", img);
cvWaitKey(0);
}
if (save)
{
char out_file[PATH_MAX];
char tmp[PATH_MAX];
char *filename = tmp;
char *ext;
char *start;
// Get the extension.
strncpy(tmp, img_paths[i], sizeof(tmp));
ext = strrchr(tmp, '.');
*ext = '\0';
ext++;
// And filename.
filename = strrchr(tmp, '/');
start = strrchr(tmp, '\\');
if (start> filename)
filename = start;
filename++;
snprintf(out_file, sizeof(out_file) - 1, "%s/match_%s__%s.%s",
output_path, match_success ? "ok" : "fail", filename, ext);
printf("Saving image \"%s\"\n", out_file);
cvSaveImage(out_file, img, 0);
}
}
cvReleaseImage(&img);
}
}
end = clock();
if (!test_matchable)
{
printf("Note that this time isn't useful with --show\n");
printf("%d of %d successful! (%f seconds)\n",
success_count, (int)img_count, (float)(end - start) / CLOCKS_PER_SEC);
}
fail:
catcierge_matcher_destroy(&matcher);
cvDestroyAllWindows();
return ret;
}
double catcierge_haar_matcher_match(void *octx,
IplImage *img, match_result_t *result, int save_steps)
{
catcierge_haar_matcher_t *ctx = (catcierge_haar_matcher_t *)octx;
catcierge_haar_matcher_args_t *args = ctx->args;
double ret = HAAR_SUCCESS_NO_HEAD;
IplImage *img_eq = NULL;
IplImage *img_gray = NULL;
IplImage *tmp = NULL;
IplImage *thr_img = NULL;
CvSize max_size;
CvSize min_size;
int cat_head_found = 0;
assert(ctx);
assert(ctx->args);
assert(result);
min_size.width = args->min_width;
min_size.height = args->min_height;
max_size.width = 0;
max_size.height = 0;
result->step_img_count = 0;
result->description[0] = '\0';
// Make gray scale if needed.
if (img->nChannels != 1)
{
tmp = cvCreateImage(cvGetSize(img), 8, 1);
cvCvtColor(img, tmp, CV_BGR2GRAY);
img_gray = tmp;
}
else
{
img_gray = img;
}
if (result->direction)
{
result->direction = MATCH_DIR_UNKNOWN;
}
// Equalize histogram.
if (args->eq_histogram)
{
img_eq = cvCreateImage(cvGetSize(img), 8, 1);
cvEqualizeHist(img_gray, img_eq);
}
else
{
img_eq = img_gray;
}
catcierge_haar_matcher_save_step_image(ctx,
img_eq, result, "gray", "Grayscale original", save_steps);
result->rect_count = MAX_MATCH_RECTS;
if (cv2CascadeClassifier_detectMultiScale(ctx->cascade,
img_eq, result->match_rects, &result->rect_count,
1.1, 3, CV_HAAR_SCALE_IMAGE, &min_size, &max_size))
{
ret = -1.0;
goto fail;
}
if (ctx->super.debug) printf("Rect count: %d\n", (int)result->rect_count);
cat_head_found = (result->rect_count > 0);
// Even if we don't find a face we count it as a success.
// Only when a prey is found we consider it a fail.
// Unless args->no_match_is_fail is set.
if (args->no_match_is_fail)
{
// Any return value above 0.0 is considered
// a success. Just so we can distinguish the types of successes.
ret = cat_head_found ?
HAAR_SUCCESS_NO_HEAD_IS_FAIL : HAAR_FAIL;
}
if (cat_head_found)
{
int inverted;
int flags;
CvRect roi;
find_prey_f find_prey = NULL;
// Only use the lower part of the region of interest
// and extend it some towards the "outside" for better result.
// (We only use the first haar cascade match).
roi = result->match_rects[0];
// If we're saving steps, include the original haar cascade
// match rectangle image.
if (save_steps)
{
cvSetImageROI(img_eq, roi);
catcierge_haar_matcher_save_step_image(ctx,
img_eq, result, "haar_roi", "Haar match", save_steps);
}
catcierge_haar_matcher_calculate_roi(ctx, &roi);
cvSetImageROI(img_eq, roi);
catcierge_haar_matcher_save_step_image(ctx,
img_eq, result, "roi", "Cropped region of interest", save_steps);
if (args->prey_method == PREY_METHOD_ADAPTIVE)
{
inverted = 1;
flags = CV_THRESH_BINARY_INV | CV_THRESH_OTSU;
find_prey = catcierge_haar_matcher_find_prey_adaptive;
}
else
{
inverted = 0;
flags = CV_THRESH_BINARY | CV_THRESH_OTSU;
find_prey = catcierge_haar_matcher_find_prey;
}
// Both "find prey" and "guess direction" needs
// a thresholded image, so perform it before calling those.
thr_img = cvCreateImage(cvGetSize(img_eq), 8, 1);
cvThreshold(img_eq, thr_img, 0, 255, flags);
if (ctx->super.debug) cvShowImage("Haar image binary", thr_img);
catcierge_haar_matcher_save_step_image(ctx,
thr_img, result, "thresh", "Global thresholded binary image", save_steps);
result->direction = catcierge_haar_guess_direction(ctx, thr_img, inverted);
if (ctx->super.debug) printf("Direction: %s\n", catcierge_get_direction_str(result->direction));
// Don't bother looking for prey when the cat is going outside.
if ((result->direction) == MATCH_DIR_OUT)
{
if (ctx->super.debug) printf("Skipping prey detection!\n");
snprintf(result->description, sizeof(result->description) - 1,
"Skipped prey detection when going out");
goto done;
}
// Note that thr_img will be modified.
if (find_prey(ctx, img_eq, thr_img, result, save_steps))
{
if (ctx->super.debug) printf("Found prey!\n");
ret = HAAR_FAIL;
snprintf(result->description, sizeof(result->description) - 1,
"Prey detected");
}
else
{
ret = HAAR_SUCCESS;
snprintf(result->description, sizeof(result->description) - 1,
"No prey detected");
}
}
else
{
snprintf(result->description, sizeof(result->description) - 1,
"%sNo cat head detected",
(ret == HAAR_SUCCESS_NO_HEAD_IS_FAIL) ? "Fail ": "");
}
done:
fail:
cvResetImageROI(img);
if (args->eq_histogram)
{
cvReleaseImage(&img_eq);
}
if (tmp)
{
cvReleaseImage(&tmp);
}
if (thr_img)
{
cvReleaseImage(&thr_img);
}
result->result = ret;
result->success = (result->result > 0.0);
return ret;
}
int main(int argc, char **argv)
{
int ret = 0;
catcierge_matcher_t *matcher = NULL;
IplImage *img = NULL;
CvSize img_size;
CvScalar match_color;
int match_success = 0;
double match_res = 0;
int i;
int j;
int success_count = 0;
match_result_t result;
clock_t start;
clock_t end;
catcierge_args_t args;
memset(&args, 0, sizeof(args));
memset(&result, 0, sizeof(result));
fprintf(stderr, "Catcierge Image match Tester (C) Joakim Soderberg 2013-2016\n");
if (catcierge_args_init(&args, argv[0]))
{
fprintf(stderr, "Failed to init args\n");
return -1;
}
if (add_options(&args))
{
fprintf(stderr, "Failed to init tester args\n");
ret = -1; goto fail;
}
if (catcierge_args_parse(&args, argc, argv))
{
ret = -1; goto fail;
}
// Create output directory.
if (ctx.save)
{
catcierge_make_path("%s", ctx.output_path);
}
if (catcierge_matcher_init(&matcher, catcierge_get_matcher_args(&args)))
{
fprintf(stderr, "\n\nFailed to %s init matcher\n\n", matcher->name);
return -1;
}
matcher->debug = ctx.debug;
if (!(ctx.imgs = calloc(ctx.img_count, sizeof(IplImage *))))
{
fprintf(stderr, "Out of memory!\n");
ret = -1;
goto fail;
}
// TODO: Move to function
// If we should preload the images or not
// (Don't let file IO screw with benchmark)
if (ctx.preload)
{
for (i = 0; i < (int)ctx.img_count; i++)
{
printf("Preload image %s\n", ctx.img_paths[i]);
if (!(ctx.imgs[i] = cvLoadImage(ctx.img_paths[i], 1)))
{
fprintf(stderr, "Failed to load match image: %s\n", ctx.img_paths[i]);
ret = -1;
goto fail;
}
}
}
start = clock();
if (ctx.test_matchable)
{
for (i = 0; i < (int)ctx.img_count; i++)
{
// This tests if an image frame is clear or not (matchable).
int frame_obstructed;
if ((frame_obstructed = matcher->is_obstructed(matcher, ctx.imgs[i])) < 0)
{
fprintf(stderr, "Failed to detect check for matchability frame\n");
return -1;
}
printf("%s: Frame obstructed = %d\n",
ctx.img_paths[i], frame_obstructed);
if (ctx.show)
{
cvShowImage("image", ctx.imgs[i]);
cvWaitKey(0);
}
}
}
else
{
for (i = 0; i < (int)ctx.img_count; i++)
{
match_success = 0;
printf("---------------------------------------------------\n");
printf("%s:\n", ctx.img_paths[i]);
if (ctx.preload)
{
img = ctx.imgs[i];
}
else
{
if (!(img = cvLoadImage(ctx.img_paths[i], 1)))
{
fprintf(stderr, "Failed to load match image: %s\n", ctx.img_paths[i]);
goto fail;
}
}
img_size = cvGetSize(img);
printf(" Image size: %dx%d\n", img_size.width, img_size.height);
if ((match_res = matcher->match(matcher, img, &result, 0)) < 0)
{
fprintf(stderr, "Something went wrong when matching image: %s\n", ctx.img_paths[i]);
catcierge_matcher_destroy(&matcher);
return -1;
}
match_success = (match_res >= args.templ.match_threshold);
if (match_success)
{
printf(" Match (%s)! %f\n", catcierge_get_direction_str(result.direction), match_res);
match_color = CV_RGB(0, 255, 0);
success_count++;
}
else
{
printf(" No match! %f\n", match_res);
match_color = CV_RGB(255, 0, 0);
}
if (ctx.show || ctx.save)
{
for (j = 0; j < (int)result.rect_count; j++)
{
printf("x: %d\n", result.match_rects[j].x);
printf("y: %d\n", result.match_rects[j].y);
printf("w: %d\n", result.match_rects[j].width);
printf("h: %d\n", result.match_rects[j].height);
cvRectangleR(img, result.match_rects[j], match_color, 1, 8, 0);
}
if (ctx.show)
{
cvShowImage("image", img);
cvWaitKey(0);
}
if (ctx.save)
{
char out_file[PATH_MAX];
char tmp[PATH_MAX];
char *filename = tmp;
char *ext;
char *start;
// Get the extension.
strncpy(tmp, ctx.img_paths[i], sizeof(tmp));
ext = strrchr(tmp, '.');
*ext = '\0';
ext++;
// And filename.
filename = strrchr(tmp, '/');
start = strrchr(tmp, '\\');
if (start> filename)
filename = start;
filename++;
snprintf(out_file, sizeof(out_file) - 1, "%s/match_%s__%s.%s",
ctx.output_path, match_success ? "ok" : "fail", filename, ext);
printf("Saving image \"%s\"\n", out_file);
cvSaveImage(out_file, img, 0);
}
}
cvReleaseImage(&img);
}
}
end = clock();
if (!ctx.test_matchable)
{
if (ctx.show)
{
printf("Note that the duration is affected by using --show\n");
}
printf("%d of %d successful! (%f seconds)\n",
success_count, (int)ctx.img_count, (float)(end - start) / CLOCKS_PER_SEC);
}
fail:
catcierge_matcher_destroy(&matcher);
cvDestroyAllWindows();
return ret;
}
