int
main(int argc, char** argv)
{
printf("Edge Detection Benchmark ...\n");
ccv_enable_default_cache();
unsigned int elapsed_time;
ccv_dense_matrix_t* yuv = 0;
ccv_read(argv[1], &yuv, CCV_IO_GRAY | CCV_IO_ANY_FILE);
/* ORIGIN */
ccv_dense_matrix_t* canny = 0;
elapsed_time = get_current_time();
ccv_canny(yuv, &canny, 0, 3, 175, 320);
elapsed_time = get_current_time() - elapsed_time;
printf("origin: %ums\n", elapsed_time);
ccv_matrix_free(canny);
/* SLICE & DETECT */
int X_SLICE = atoi(argv[2]), Y_SLICE = atoi(argv[3]);
int i, count = X_SLICE * Y_SLICE;
int slice_rows = yuv->rows / Y_SLICE;
int slice_cols = yuv->cols / X_SLICE;
ccv_dense_matrix_t* canny_arr[count];
elapsed_time = get_current_time();
#pragma omp parallel for
for (i = 0; i < count; i++) {
int y = i / X_SLICE;
int x = i - X_SLICE * y;
ccv_dense_matrix_t* slice = 0;
ccv_slice(yuv, (ccv_matrix_t**)&slice, 0, slice_rows * y, slice_cols * x, slice_rows, slice_cols);
#ifdef DEBUG
cos_ccv_slice_output(slice, y, x);
#endif
canny_arr[i] = 0;
ccv_canny(slice, &canny_arr[i], 0, 3, 175, 320);
}
elapsed_time = get_current_time() - elapsed_time;
printf("slice & detect: %ums\n", elapsed_time);
unsigned int slice_time = elapsed_time; /* save to compute total time */
/* MERGE */
ccv_dense_matrix_t* final_output = 0;
elapsed_time = get_current_time();
cos_ccv_merge(canny_arr, &final_output, yuv->rows, yuv->cols, X_SLICE, Y_SLICE);
elapsed_time = get_current_time() - elapsed_time;
printf("merge: %ums\n", elapsed_time);
ccv_matrix_free(final_output);
printf("parallel total: %ums\n", slice_time + elapsed_time);
ccv_matrix_free(yuv);
ccv_disable_cache();
return 0;
}
int main(int argc, char** argv)
{
assert(argc >= 3);
int i;
ccv_enable_default_cache();
ccv_dense_matrix_t* image = 0;
ccv_icf_classifier_cascade_t* cascade = ccv_icf_read_classifier_cascade(argv[2]);
ccv_read(argv[1], &image, CCV_IO_ANY_FILE | CCV_IO_RGB_COLOR);
if (image != 0)
{
unsigned int elapsed_time = get_current_time();
ccv_array_t* seq = ccv_icf_detect_objects(image, &cascade, 1, ccv_icf_default_params);
elapsed_time = get_current_time() - elapsed_time;
for (i = 0; i < seq->rnum; i++)
{
ccv_comp_t* comp = (ccv_comp_t*)ccv_array_get(seq, i);
printf("%d %d %d %d %f\n", comp->rect.x, comp->rect.y, comp->rect.width, comp->rect.height, comp->confidence);
}
printf("total : %d in time %dms\n", seq->rnum, elapsed_time);
ccv_array_free(seq);
ccv_matrix_free(image);
} else {
FILE* r = fopen(argv[1], "rt");
if (argc == 4)
chdir(argv[3]);
if(r)
{
size_t len = 1024;
char* file = (char*)malloc(len);
ssize_t read;
while((read = getline(&file, &len, r)) != -1)
{
while(read > 1 && isspace(file[read - 1]))
read--;
file[read] = 0;
image = 0;
ccv_read(file, &image, CCV_IO_ANY_FILE | CCV_IO_RGB_COLOR);
assert(image != 0);
ccv_array_t* seq = ccv_icf_detect_objects(image, &cascade, 1, ccv_icf_default_params);
for (i = 0; i < seq->rnum; i++)
{
ccv_comp_t* comp = (ccv_comp_t*)ccv_array_get(seq, i);
printf("%s %d %d %d %d %f\n", file, comp->rect.x, comp->rect.y, comp->rect.width, comp->rect.height, comp->confidence);
}
ccv_array_free(seq);
ccv_matrix_free(image);
}
free(file);
fclose(r);
}
}
ccv_icf_classifier_cascade_free(cascade);
ccv_disable_cache();
return 0;
}
int main(int argc, char** argv)
{
assert(argc == 3);
ccv_enable_default_cache();
ccv_dense_matrix_t* image = 0;
ccv_read(argv[1], &image, CCV_IO_RGB_COLOR | CCV_IO_ANY_FILE);
ccv_mser_param_t params = {
.min_area = 60,
.max_area = (int)(image->rows * image->cols * 0.3 + 0.5),
.min_diversity = 0.2,
.area_threshold = 1.01,
.min_margin = 0.003,
.max_evolution = 200,
.edge_blur_sigma = sqrt(3.0),
.delta = 5,
.max_variance = 0.25,
.direction = CCV_DARK_TO_BRIGHT,
};
if (image)
{
ccv_dense_matrix_t* yuv = 0;
// ccv_color_transform(image, &yuv, 0, CCV_RGB_TO_YUV);
ccv_read(argv[1], &yuv, CCV_IO_GRAY | CCV_IO_ANY_FILE);
unsigned int elapsed_time = get_current_time();
ccv_dense_matrix_t* canny = 0;
ccv_canny(yuv, &canny, 0, 3, 175, 320);
ccv_dense_matrix_t* outline = 0;
ccv_close_outline(canny, &outline, 0);
ccv_matrix_free(canny);
ccv_dense_matrix_t* mser = 0;
ccv_array_t* mser_keypoint = ccv_mser(yuv, outline, &mser, 0, params);
elapsed_time = get_current_time() - elapsed_time;
ccv_matrix_free(outline);
printf("total : %d in time %dms\n", mser_keypoint->rnum, elapsed_time);
ccv_array_free(mser_keypoint);
ccv_make_matrix_mutable(image);
int i, j;
for (i = 0; i < image->rows; i++)
for (j = 0; j < image->cols; j++)
{
if (mser->data.i32[i * mser->cols + j])
{
image->data.u8[i * image->step + j * 3] = colors[mser->data.i32[i * mser->cols + j] % 6][0];
image->data.u8[i * image->step + j * 3 + 1] = colors[mser->data.i32[i * mser->cols + j] % 6][1];
image->data.u8[i * image->step + j * 3 + 2] = colors[mser->data.i32[i * mser->cols + j] % 6][2];
}
}
ccv_write(image, argv[2], 0, CCV_IO_PNG_FILE, 0);
ccv_matrix_free(yuv);
ccv_matrix_free(image);
}
ccv_disable_cache();
return 0;
}
void TDetector::pdetect(ccv_dense_matrix_t* image,
std::vector<Text2D>& text2d) {
text2d.clear();
//text2d.erase(text2d.begin(), text2d.end());
if (image != 0) {
for (int i = 0; i < params.size(); i++) {
ccv_array_t* words = ccv_swt_detect_words(image, params.at(i));
if (words) {
text2d.reserve(words->rnum);
ccv_rect_t* rect;
for (int j = 0; j < words->rnum; j++) {
rect = (ccv_rect_t*) ccv_array_get(words, j);
//printf("%d %d %d %d\n", rect->x, rect->y, rect->width, rect->height);
text2d.push_back(
Text2D(rect->x, rect->y, rect->x + rect->width,
rect->y + rect->height, ""));
}
ccv_array_free(words);
}
}
ccv_matrix_free(image);
}
}
void _hccv_dense_matrix_unref (ccv_dense_matrix_t *mat) {
/* return; */
/* printf ("-- unref\n"); */
if (--mat->refcount == 0) {
/* printf (" + free\n"); */
ccv_matrix_free(mat);
}
}
void ccv_gradient(ccv_dense_matrix_t* a, ccv_dense_matrix_t** theta, int ttype, ccv_dense_matrix_t** m, int mtype, int dx, int dy)
{
ccv_declare_derived_signature(tsig, a->sig != 0, ccv_sign_with_format(64, "ccv_gradient(theta,%d,%d)", dx, dy), a->sig, CCV_EOF_SIGN);
ccv_declare_derived_signature(msig, a->sig != 0, ccv_sign_with_format(64, "ccv_gradient(m,%d,%d)", dx, dy), a->sig, CCV_EOF_SIGN);
int ch = CCV_GET_CHANNEL(a->type);
ccv_dense_matrix_t* dtheta = *theta = ccv_dense_matrix_renew(*theta, a->rows, a->cols, CCV_32F | ch, CCV_32F | ch, tsig);
ccv_dense_matrix_t* dm = *m = ccv_dense_matrix_renew(*m, a->rows, a->cols, CCV_32F | ch, CCV_32F | ch, msig);
ccv_object_return_if_cached(, dtheta, dm);
ccv_revive_object_if_cached(dtheta, dm);
ccv_dense_matrix_t* tx = 0;
ccv_dense_matrix_t* ty = 0;
ccv_sobel(a, &tx, CCV_32F | ch, dx, 0);
ccv_sobel(a, &ty, CCV_32F | ch, 0, dy);
_ccv_atan2(tx->data.f32, ty->data.f32, dtheta->data.f32, dm->data.f32, ch * a->rows * a->cols);
ccv_matrix_free(tx);
ccv_matrix_free(ty);
}
void _hccv_dense_matrix_unref2 (ccv_dense_matrix_t *mat, void *x) {
/* return; */
/* printf ("-- unref\n"); */
if (--(mat->refcount) == 0) {
/* printf (" * free\n"); */
ccv_matrix_free(mat);
}
}
int
main(int argc, char** argv)
{
ccv_dense_matrix_t* mat1 = 0;
ccv_dense_matrix_t* mat2 = 0;
ccv_dense_matrix_t* mat3 = 0;
ccv_read(argv[1], &mat1, CCV_IO_GRAY | CCV_IO_ANY_FILE);
ccv_read(argv[2], &mat2, CCV_IO_GRAY | CCV_IO_ANY_FILE);
ccv_add((ccv_matrix_t *)mat1, (ccv_matrix_t *)mat2, (ccv_matrix_t **)&mat3, mat1->type);
ccv_write(mat3, "test.jpeg", 0, CCV_IO_JPEG_FILE, 0);
ccv_matrix_free(mat1);
ccv_matrix_free(mat2);
ccv_matrix_free(mat3);
return 0;
}
int main(int argc, char** argv)
{
ccv_nnc_init();
ccv_convnet_t* convnet = ccv_convnet_read(0, argv[2]);
ccv_dense_matrix_t* image = 0;
ccv_read(argv[1], &image, CCV_IO_ANY_FILE | CCV_IO_RGB_COLOR);
if (image != 0)
{
ccv_dense_matrix_t* input = 0;
ccv_convnet_input_formation(convnet->input, image, &input);
ccv_matrix_free(image);
ccv_dense_matrix_t* sliced = 0;
ccv_slice(input, (ccv_matrix_t**)&sliced, 0, (input->rows - 225) / 2, (input->cols - 225) / 2, 225, 225);
ccv_matrix_free(input);
ccv_dense_matrix_t* b = 0;
unsigned int elapsed_time = get_current_time();
ccv_convnet_encode(convnet, &sliced, &b, 1);
printf("ccv_convnet_encode %u ms\n", get_current_time() - elapsed_time);
ccv_nnc_tensor_t* c = ccv_nnc_tensor_new(0, ONE_CPU_TENSOR(1000), 0);
ccv_nnc_graph_exec_t source, dest;
ccv_array_t* tensors = ccv_array_new(sizeof(ccv_nnc_tensor_t*), 1, 0);
ccv_nnc_graph_t* graph = ccv_nnc_simple_graph(convnet, (ccv_nnc_tensor_t*)sliced, c, &source, &dest, tensors);
elapsed_time = get_current_time();
ccv_nnc_graph_run(graph, 0, &source, 1, &dest, 1);
printf("ccv_nnc_graph_run %u ms\n", get_current_time() - elapsed_time);
int i;
for (i = 0; i < 1000; i++)
if (fabsf(b->data.f32[i] - c->data.f32[i]) > 1e-4)
printf("mis-match at %d: %f %f\n", i, b->data.f32[i], c->data.f32[i]);
ccv_nnc_tensor_free(c);
ccv_matrix_free(sliced);
ccv_matrix_free(b);
ccv_nnc_graph_free(graph);
for (i = 0; i < tensors->rnum; i++)
ccv_nnc_tensor_free(*(ccv_nnc_tensor_t**)ccv_array_get(tensors, i));
ccv_array_free(tensors);
}
ccv_convnet_free(convnet);
return 0;
}
int main(int argc, char **argv)
{
ccv_dense_matrix_t* a = ccv_dense_matrix_new(3, 2, CCV_64F | CCV_C1, 0, 0);
a->data.f64[0] = 0.11;
a->data.f64[1] = 0.12;
a->data.f64[2] = 0.13;
a->data.f64[3] = 0.21;
a->data.f64[4] = 0.22;
a->data.f64[5] = 0.23;
ccv_dense_matrix_t* b = ccv_dense_matrix_new(3, 2, CCV_64F | CCV_C1, 0, 0);
b->data.f64[0] = 1011;
b->data.f64[1] = 1012;
b->data.f64[2] = 1021;
b->data.f64[3] = 1022;
b->data.f64[4] = 1031;
b->data.f64[5] = 1032;
ccv_dense_matrix_t* y = 0;
ccv_gemm(a, b, 1, 0, 0, CCV_A_TRANSPOSE, (ccv_matrix_t**)&y, 0);
ccv_matrix_free(a);
ccv_matrix_free(b);
ccv_matrix_free(y);
}
int main(int argc, char** argv)
{
if (argc != 5)
{
print_help();
return -1;
}
ccv_enable_default_cache();
int i, rt;
int posnum = atoi(argv[2]);
FILE* pf = fopen(argv[1], "r");
ccv_dense_matrix_t** posimg = (ccv_dense_matrix_t**)malloc(sizeof(posimg[0]) * posnum);
for (i = 0; i < posnum; i++)
{
char buf[1024];
rt = fscanf(pf, "%s", buf);
ccv_read(buf, &posimg[i], CCV_IO_GRAY | CCV_IO_ANY_FILE);
}
fclose(pf);
int negnum = atoi(argv[4]);
FILE* bgf = fopen(argv[3], "r");
int bgnum;
rt = fscanf(bgf, "%d", &bgnum);
char** bgfiles = (char**)malloc(sizeof(bgfiles[0]) * bgnum);
for (i = 0; i < bgnum; i++)
{
bgfiles[i] = (char*)malloc(1024);
rt = fscanf(bgf, "%s", bgfiles[i]);
}
fclose(bgf);
ccv_bbf_new_param_t params = {
.pos_crit = 0.9975,
.neg_crit = 0.50,
.balance_k = 1.0,
.layer = 24,
.feature_number = 100,
.optimizer = CCV_BBF_GENETIC_OPT | CCV_BBF_FLOAT_OPT,
};
ccv_bbf_classifier_cascade_new(posimg, posnum, bgfiles, bgnum, negnum, ccv_size(24, 24), "data", params);
for (i = 0; i < bgnum; i++)
free(bgfiles[i]);
for (i = 0; i < posnum; i++)
ccv_matrix_free(&posimg[i]);
free(posimg);
free(bgfiles);
ccv_disable_cache();
return 0;
}
int main(int argc, char** argv)
{
ccv_dense_matrix_t* image = 0;
ccv_read(argv[1], &image, CCV_IO_RGB_COLOR | CCV_IO_ANY_FILE);
ccv_scd_classifier_cascade_t* cascade = ccv_scd_classifier_cascade_read(argv[2]);
ccv_array_t* faces = ccv_scd_detect_objects(image, &cascade, 1, ccv_scd_default_params);
int i;
for (i = 0; i < faces->rnum; i++)
{
ccv_comp_t* face = (ccv_comp_t*)ccv_array_get(faces, i);
printf("%d %d %d %d\n", face->rect.x, face->rect.y, face->rect.width, face->rect.height);
}
ccv_array_free(faces);
ccv_scd_classifier_cascade_free(cascade);
ccv_matrix_free(image);
return 0;
}
int
main(int argc, char** argv)
{
printf("Face Detection Benchmark ...\n");
ccv_enable_default_cache();
ccv_dense_matrix_t* image = 0;
ccv_bbf_classifier_cascade_t* cascade = ccv_bbf_read_classifier_cascade(argv[4]);
ccv_read(argv[1], &image, CCV_IO_GRAY | CCV_IO_ANY_FILE);
unsigned int elapsed_time;
ccv_array_t* seq;
elapsed_time = get_current_time();
seq = ccv_bbf_detect_objects(image, &cascade, 1, ccv_bbf_default_params);
elapsed_time = get_current_time() - elapsed_time;
printf("origin: %d in %dms\n", seq->rnum, elapsed_time);
ccv_array_free(seq);
int X_SLICE = atoi(argv[2]), Y_SLICE = atoi(argv[3]);
int sliced_total = 0;
int slice_rows = image->rows / Y_SLICE;
int slice_cols = image->cols / X_SLICE;
int i, count = X_SLICE * Y_SLICE;
elapsed_time = get_current_time();
#pragma omp parallel for shared(sliced_total)
for (i = 0; i < count; i++) {
int y = i / X_SLICE;
int x = i - X_SLICE * y;
ccv_dense_matrix_t* slice = 0;
ccv_slice(image, (ccv_matrix_t**)&slice, 0, slice_rows * y, slice_cols * x, slice_rows, slice_cols);
ccv_array_t* sseq = ccv_bbf_detect_objects(slice, &cascade, 1, ccv_bbf_default_params);
sliced_total += sseq->rnum;
#ifdef DEBUG
cos_ccv_slice_output(slice, y, x);
#endif
}
elapsed_time = get_current_time() - elapsed_time;
printf("slice & detect: %d in %dms\n", sliced_total, elapsed_time);
ccv_matrix_free(image);
ccv_bbf_classifier_cascade_free(cascade);
ccv_disable_cache();
return 0;
}
void ccv_visualize(ccv_matrix_t* a, ccv_dense_matrix_t** b, int type)
{
ccv_dense_matrix_t* da = ccv_get_dense_matrix(a);
ccv_declare_derived_signature(sig, da->sig != 0, ccv_sign_with_literal("ccv_visualize"), da->sig, CCV_EOF_SIGN);
ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, da->rows, da->cols, CCV_8U | CCV_C1, CCV_8U | CCV_C1, sig);
ccv_object_return_if_cached(, db);
ccv_dense_matrix_t* dc = 0;
if (CCV_GET_CHANNEL(da->type) > CCV_C1)
{
ccv_flatten(da, (ccv_matrix_t**)&dc, 0, 0);
da = dc;
}
int i, j;
double minval = DBL_MAX, maxval = -DBL_MAX;
unsigned char* aptr = da->data.u8;
unsigned char* bptr = db->data.u8;
#define for_block(_, _for_get) \
for (i = 0; i < da->rows; i++) \
{ \
for (j = 0; j < da->cols; j++) \
{ \
minval = ccv_min(minval, _for_get(aptr, j, 0)); \
maxval = ccv_max(maxval, _for_get(aptr, j, 0)); \
} \
aptr += da->step; \
} \
aptr = da->data.u8; \
for (i = 0; i < da->rows; i++) \
{ \
for (j = 0; j < da->cols; j++) \
bptr[j] = ccv_clamp((_for_get(aptr, j, 0) - minval) * 255.0 / (maxval - minval), 0, 255); \
aptr += da->step; \
bptr += db->step; \
}
ccv_matrix_getter(da->type, for_block);
#undef for_block
if (dc != 0)
ccv_matrix_free(dc);
}
int main(int argc, char** argv)
{
// process arguments
char* image_file = "";
int scale_invariant = 0;
int min_height = 0;
int min_area = 0;
char ch;
while ((ch = getopt(argc, argv, "a:h:i")) != EOF)
switch(ch) {
case 'i':
scale_invariant = 1;
printf("Scale invariant\n");
break;
case 'h':
min_height = atoi(optarg);
printf("Min height %d\n", min_height);
continue;
case 'a':
min_area = atoi(optarg);
printf("Min area %d\n", min_area);
continue;
}
argc -= optind;
argv += optind;
image_file = argv[0];
ccv_enable_default_cache();
ccv_dense_matrix_t* image = 0;
ccv_read(image_file, &image, CCV_IO_GRAY | CCV_IO_ANY_FILE);
if (image==0) {
fprintf(stderr, "ERROR: image could not be read\n");
return 1;
}
unsigned int elapsed_time = get_current_time();
ccv_swt_param_t params = ccv_swt_default_params;
if (scale_invariant)
params.scale_invariant = 1;
if (min_height)
params.min_height = min_height;
if (min_area)
params.min_area = min_area;
ccv_array_t* letters = ccv_swt_detect_chars_contour(image, params);
elapsed_time = get_current_time() - elapsed_time;
if (letters)
{
printf("total : %d in time %dms\n", letters->rnum, elapsed_time);
int i;
for (i = 0; i < letters->rnum; i++)
{
// for each letter
ccv_contour_t* cont = *(ccv_contour_t**)ccv_array_get(letters, i);
printf("Contour %d (size=%d):\n", i, cont->size);
for (int j = 0; j < cont->size; j++) {
// for each point in contour
ccv_point_t* point = (ccv_point_t*)ccv_array_get(cont->set, j);
printf("%d %d\n", point->x, point->y);
}
printf("End contour %d\n", i);
}
ccv_array_free(letters);
}
ccv_matrix_free(image);
ccv_drain_cache();
return 0;
}
/* it is a supposely cleaner and faster implementation than original OpenCV (ccv_canny_deprecated,
* removed, since the newer implementation achieve bit accuracy with OpenCV's), after a lot
* profiling, the current implementation still uses integer to speed up */
void ccv_canny(ccv_dense_matrix_t* a, ccv_dense_matrix_t** b, int type, int size, double low_thresh, double high_thresh)
{
assert(CCV_GET_CHANNEL(a->type) == CCV_C1);
ccv_declare_derived_signature(sig, a->sig != 0, ccv_sign_with_format(64, "ccv_canny(%d,%la,%la)", size, low_thresh, high_thresh), a->sig, CCV_EOF_SIGN);
type = (type == 0) ? CCV_8U | CCV_C1 : CCV_GET_DATA_TYPE(type) | CCV_C1;
ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, a->rows, a->cols, CCV_C1 | CCV_ALL_DATA_TYPE, type, sig);
ccv_object_return_if_cached(, db);
printc("begin process\n");
if ((a->type & CCV_8U) || (a->type & CCV_32S))
{
ccv_dense_matrix_t* dx = 0;
ccv_dense_matrix_t* dy = 0;
printc("begin ccv_sobel\n");
ccv_sobel(a, &dx, 0, size, 0);
ccv_sobel(a, &dy, 0, 0, size);
printc("done ccv_sobel\n");
/* special case, all integer */
int low = (int)(low_thresh + 0.5);
int high = (int)(high_thresh + 0.5);
int* dxi = dx->data.i32;
int* dyi = dy->data.i32;
int i, j;
int* mbuf = (int*)malloc(3 * (a->cols + 2) * sizeof(int));
memset(mbuf, 0, 3 * (a->cols + 2) * sizeof(int));
int* rows[3];
rows[0] = mbuf + 1;
rows[1] = mbuf + (a->cols + 2) + 1;
rows[2] = mbuf + 2 * (a->cols + 2) + 1;
for (j = 0; j < a->cols; j++)
rows[1][j] = abs(dxi[j]) + abs(dyi[j]);
dxi += a->cols;
dyi += a->cols;
/*int* map = (int*)ccmalloc(sizeof(int) * (a->rows + 2) * (a->cols + 2));*/
int* map = (int*)malloc(sizeof(int) * (a->rows + 2) * (a->cols + 2));
memset(map, 0, sizeof(int) * (a->cols + 2));
int* map_ptr = map + a->cols + 2 + 1;
int map_cols = a->cols + 2;
/*int** stack = (int**)ccmalloc(sizeof(int*) * a->rows * a->cols);*/
int** stack = (int**)malloc(sizeof(int*) * a->rows * a->cols);
int** stack_top = stack;
int** stack_bottom = stack;
for (i = 1; i <= a->rows; i++)
{
/* the if clause should be unswitched automatically, no need to manually do so */
if (i == a->rows)
memset(rows[2], 0, sizeof(int) * a->cols);
else
for (j = 0; j < a->cols; j++)
rows[2][j] = abs(dxi[j]) + abs(dyi[j]);
int* _dx = dxi - a->cols;
int* _dy = dyi - a->cols;
map_ptr[-1] = 0;
int suppress = 0;
for (j = 0; j < a->cols; j++)
{
int f = rows[1][j];
if (f > low)
{
int x = abs(_dx[j]);
int y = abs(_dy[j]);
int s = _dx[j] ^ _dy[j];
/* x * tan(22.5) */
int tg22x = x * (int)(0.4142135623730950488016887242097 * (1 << 15) + 0.5);
/* x * tan(67.5) == 2 * x + x * tan(22.5) */
int tg67x = tg22x + ((x + x) << 15);
y <<= 15;
/* it is a little different from the Canny original paper because we adopted the coordinate system of
* top-left corner as origin. Thus, the derivative of y convolved with matrix:
* |-1 -2 -1|
* | 0 0 0|
* | 1 2 1|
* actually is the reverse of real y. Thus, the computed angle will be mirrored around x-axis.
* In this case, when angle is -45 (135), we compare with north-east and south-west, and for 45,
* we compare with north-west and south-east (in traditional coordinate system sense, the same if we
* adopt top-left corner as origin for "north", "south", "east", "west" accordingly) */
#define high_block \
{ \
if (f > high && !suppress && map_ptr[j - map_cols] != 2) \
{ \
map_ptr[j] = 2; \
suppress = 1; \
*(stack_top++) = map_ptr + j; \
} else { \
map_ptr[j] = 1; \
} \
continue; \
}
/* sometimes, we end up with same f in integer domain, for that case, we will take the first occurrence
* suppressing the second with flag */
if (y < tg22x)
{
if (f > rows[1][j - 1] && f >= rows[1][j + 1])
high_block;
} else if (y > tg67x) {
if (f > rows[0][j] && f >= rows[2][j])
high_block;
} else {
s = s < 0 ? -1 : 1;
if (f > rows[0][j - s] && f > rows[2][j + s])
high_block;
}
#undef high_block
}
map_ptr[j] = 0;
suppress = 0;
}
map_ptr[a->cols] = 0;
map_ptr += map_cols;
dxi += a->cols;
dyi += a->cols;
int* row = rows[0];
rows[0] = rows[1];
rows[1] = rows[2];
rows[2] = row;
}
memset(map_ptr - map_cols - 1, 0, sizeof(int) * (a->cols + 2));
int dr[] = {-1, 1, -map_cols - 1, -map_cols, -map_cols + 1, map_cols - 1, map_cols, map_cols + 1};
while (stack_top > stack_bottom)
{
map_ptr = *(--stack_top);
for (i = 0; i < 8; i++)
if (map_ptr[dr[i]] == 1)
{
map_ptr[dr[i]] = 2;
*(stack_top++) = map_ptr + dr[i];
}
}
map_ptr = map + map_cols + 1;
unsigned char* b_ptr = db->data.u8;
#define for_block(_, _for_set) \
for (i = 0; i < a->rows; i++) \
{ \
for (j = 0; j < a->cols; j++) \
_for_set(b_ptr, j, (map_ptr[j] == 2), 0); \
map_ptr += map_cols; \
b_ptr += db->step; \
}
ccv_matrix_setter(db->type, for_block);
#undef for_block
/*ccfree(stack);*/
/*ccfree(map);*/
free(stack);
free(map);
ccv_matrix_free(dx);
ccv_matrix_free(dy);
free(mbuf);
} else {
/* general case, use all ccv facilities to deal with it */
ccv_dense_matrix_t* mg = 0;
ccv_dense_matrix_t* ag = 0;
ccv_gradient(a, &ag, 0, &mg, 0, size, size);
ccv_matrix_free(ag);
ccv_matrix_free(mg);
/* FIXME: Canny implementation for general case */
}
}
int uri_dpm_detect_objects(const void* context, const void* parsed, ebb_buf* buf)
{
if (!parsed)
return -1;
dpm_param_parser_t* parser = (dpm_param_parser_t*)parsed;
param_parser_terminate(&parser->param_parser);
if (parser->source.data == 0)
{
free(parser);
return -1;
}
if (parser->mixture_model == 0)
{
free(parser->source.data);
free(parser);
return -1;
}
ccv_dense_matrix_t* image = 0;
ccv_read(parser->source.data, &image, CCV_IO_ANY_STREAM | CCV_IO_GRAY, parser->source.written);
free(parser->source.data);
if (image == 0)
{
free(parser);
return -1;
}
ccv_array_t* seq = ccv_dpm_detect_objects(image, &parser->mixture_model, 1, parser->params);
ccv_matrix_free(image);
if (seq == 0)
{
free(parser);
return -1;
}
if (seq->rnum > 0)
{
int i, j;
buf->len = 192 + seq->rnum * 131 + 2;
char* data = (char*)malloc(buf->len);
data[0] = '[';
buf->written = 1;
for (i = 0; i < seq->rnum; i++)
{
char cell[128];
ccv_root_comp_t* comp = (ccv_root_comp_t*)ccv_array_get(seq, i);
snprintf(cell, 128, "{\"x\":%d,\"y\":%d,\"width\":%d,\"height\":%d,\"confidence\":%f,\"parts\":[", comp->rect.x, comp->rect.y, comp->rect.width, comp->rect.height, comp->confidence);
size_t len = strnlen(cell, 128);
while (buf->written + len >= buf->len)
{
buf->len = (buf->len * 3 + 1) / 2;
data = (char*)realloc(data, buf->len);
}
memcpy(data + buf->written, cell, len);
buf->written += len;
for (j = 0; j < comp->pnum; j++)
{
snprintf(cell, 128, "{\"x\":%d,\"y\":%d,\"width\":%d,\"height\":%d,\"confidence\":%f}", comp->part[j].rect.x, comp->part[j].rect.y, comp->part[j].rect.width, comp->part[j].rect.height, comp->part[j].confidence);
len = strnlen(cell, 128);
while (buf->written + len + 3 >= buf->len)
{
buf->len = (buf->len * 3 + 1) / 2;
data = (char*)realloc(data, buf->len);
}
memcpy(data + buf->written, cell, len);
buf->written += len + 1;
data[buf->written - 1] = (j == comp->pnum - 1) ? ']' : ',';
}
buf->written += 2;
data[buf->written - 2] = '}';
data[buf->written - 1] = (i == seq->rnum - 1) ? ']' : ',';
}
char http_header[192];
snprintf(http_header, 192, ebb_http_header, buf->written);
size_t len = strnlen(http_header, 192);
if (buf->written + len + 1 >= buf->len)
{
buf->len = buf->written + len + 1;
data = (char*)realloc(data, buf->len);
}
memmove(data + len, data, buf->written);
memcpy(data, http_header, len);
buf->written += len + 1;
data[buf->written - 1] = '\n';
buf->data = data;
buf->len = buf->written;
buf->on_release = uri_ebb_buf_free;
} else {
buf->data = (void*)ebb_http_empty_array;
buf->len = sizeof(ebb_http_empty_array);
buf->on_release = 0;
}
ccv_array_free(seq);
free(parser);
return 0;
}
int main(int argc, char** argv)
{
static struct option bbf_options[] = {
/* help */
{"help", 0, 0, 0},
/* required parameters */
{"positive-list", 1, 0, 0},
{"background-list", 1, 0, 0},
{"working-dir", 1, 0, 0},
{"negative-count", 1, 0, 0},
{"width", 1, 0, 0},
{"height", 1, 0, 0},
/* optional parameters */
{"base-dir", 1, 0, 0},
{"layer", 1, 0, 0},
{"positive-criteria", 1, 0, 0},
{"negative-criteria", 1, 0, 0},
{"balance", 1, 0, 0},
{"feature-number", 1, 0, 0},
{0, 0, 0, 0}
};
char* positive_list = 0;
char* background_list = 0;
char* working_dir = 0;
char* base_dir = 0;
int negnum = 0;
int width = 0, height = 0;
ccv_bbf_new_param_t params = {
.pos_crit = 0.9975,
.neg_crit = 0.50,
.balance_k = 1.0,
.layer = 24,
.feature_number = 100,
.optimizer = CCV_BBF_GENETIC_OPT | CCV_BBF_FLOAT_OPT,
};
int i, k;
while (getopt_long_only(argc, argv, "", bbf_options, &k) != -1)
{
switch (k)
{
case 0:
exit_with_help();
case 1:
positive_list = optarg;
break;
case 2:
background_list = optarg;
break;
case 3:
working_dir = optarg;
break;
case 4:
negnum = atoi(optarg);
break;
case 5:
width = atoi(optarg);
break;
case 6:
height = atoi(optarg);
break;
case 7:
base_dir = optarg;
break;
case 8:
params.layer = atoi(optarg);
break;
case 9:
params.pos_crit = atof(optarg);
break;
case 10:
params.neg_crit = atof(optarg);
break;
case 11:
params.balance_k = atof(optarg);
break;
case 12:
params.feature_number = atoi(optarg);
break;
}
}
assert(positive_list != 0);
assert(background_list != 0);
assert(working_dir != 0);
assert(negnum > 0);
assert(width > 0 && height > 0);
ccv_enable_default_cache();
FILE* r0 = fopen(positive_list, "r");
assert(r0 && "positive-list doesn't exists");
FILE* r1 = fopen(background_list, "r");
assert(r1 && "background-list doesn't exists");
char* file = (char*)malloc(1024);
int dirlen = (base_dir != 0) ? strlen(base_dir) + 1 : 0;
size_t len = 1024;
ssize_t read;
int capacity = 32, size = 0;
ccv_dense_matrix_t** posimg = (ccv_dense_matrix_t**)ccmalloc(sizeof(ccv_dense_matrix_t*) * capacity);
while ((read = getline(&file, &len, r0)) != -1)
{
while(read > 1 && isspace(file[read - 1]))
read--;
file[read] = 0;
char* posfile = (char*)ccmalloc(1024);
if (base_dir != 0)
{
strncpy(posfile, base_dir, 1024);
posfile[dirlen - 1] = '/';
}
strncpy(posfile + dirlen, file, 1024 - dirlen);
posimg[size] = 0;
ccv_read(posfile, &posimg[size], CCV_IO_GRAY | CCV_IO_ANY_FILE);
if (posimg != 0)
{
++size;
if (size >= capacity)
{
capacity *= 2;
posimg = (ccv_dense_matrix_t**)ccrealloc(posimg, sizeof(ccv_dense_matrix_t*) * capacity);
}
}
}
fclose(r0);
int posnum = size;
capacity = 32;
size = 0;
char** bgfiles = (char**)ccmalloc(sizeof(char*) * capacity);
while ((read = getline(&file, &len, r1)) != -1)
{
while(read > 1 && isspace(file[read - 1]))
read--;
file[read] = 0;
bgfiles[size] = (char*)ccmalloc(1024);
if (base_dir != 0)
{
strncpy(bgfiles[size], base_dir, 1024);
bgfiles[size][dirlen - 1] = '/';
}
strncpy(bgfiles[size] + dirlen, file, 1024 - dirlen);
++size;
if (size >= capacity)
{
capacity *= 2;
bgfiles = (char**)ccrealloc(bgfiles, sizeof(char*) * capacity);
}
}
fclose(r1);
int bgnum = size;
free(file);
ccv_bbf_classifier_cascade_new(posimg, posnum, bgfiles, bgnum, negnum, ccv_size(width, height), working_dir, params);
for (i = 0; i < bgnum; i++)
free(bgfiles[i]);
for (i = 0; i < posnum; i++)
ccv_matrix_free(&posimg[i]);
free(posimg);
free(bgfiles);
ccv_disable_cache();
return 0;
}
int main(int argc, char** argv)
{
FILE* file;
char *output_file = "my_output.txt";
int i, ret_val;
ccv_dense_matrix_t* image = 0;
ccv_array_t* seq;
accept_roi_begin();
assert(argc >= 3);
ccv_enable_default_cache();
ccv_bbf_classifier_cascade_t* cascade = ccv_bbf_read_classifier_cascade(argv[2]);
ccv_read(argv[1], &image, CCV_IO_GRAY | CCV_IO_ANY_FILE);
if (image != 0)
{
unsigned int elapsed_time = get_current_time();
seq = ccv_bbf_detect_objects(image, &cascade, 1, ccv_bbf_default_params);
elapsed_time = get_current_time() - elapsed_time;
for (i = 0; ENDORSE(i < seq->rnum); i++)
{
ccv_comp_t* comp = (ccv_comp_t*)ENDORSE(ccv_array_get(seq, i));
printf("%d %d %d %d %f\n", comp->rect.x, comp->rect.y, comp->rect.width, comp->rect.height, comp->classification.confidence);
}
printf("total : %d in time %dms\n", seq->rnum, elapsed_time);
ccv_bbf_classifier_cascade_free(cascade);
ccv_disable_cache();
accept_roi_end();
file = fopen(output_file, "w");
if (file == NULL) {
perror("fopen for write failed");
return EXIT_FAILURE;
}
// latest changes
struct coordinates {
APPROX int x;
APPROX int y;
};
for (i = 0; ENDORSE(i < seq->rnum); i++) {
ccv_comp_t* comp = (ccv_comp_t*) ENDORSE(ccv_array_get(seq, i));
struct coordinates upperleft, upperright, lowerleft, lowerright;
upperleft.x = comp->rect.x;
upperleft.y = comp->rect.y;
upperright.x = comp->rect.x + comp->rect.width;
upperright.y = upperleft.y;
lowerleft.x = upperleft.x;
lowerleft.y = upperleft.y + comp->rect.height;
lowerright.x = upperright.x;
lowerright.y = lowerleft.y;
ret_val = fprintf(file, "%d %d\n%d %d\n%d %d\n%d %d\n", upperleft.x, upperleft.y, upperright.x, upperright.y,
lowerright.x, lowerright.y, lowerleft.x, lowerleft.y);
// latest changes
if (ret_val < 0) {
perror("fprintf of coordinates failed");
fclose(file);
return EXIT_FAILURE;
}
}
ret_val = fclose(file);
if (ret_val != 0) {
perror("fclose failed");
return EXIT_FAILURE;
}
ccv_array_free(seq);
ccv_matrix_free(image);
} else {
FILE* r = fopen(argv[1], "rt");
if (argc == 4)
chdir(argv[3]);
if(r)
{
size_t len = 1024;
char* file = (char*)malloc(len);
ssize_t read;
while((read = getline(&file, &len, r)) != -1)
{
while(read > 1 && isspace(file[read - 1]))
read--;
file[read] = 0;
image = 0;
ccv_read(file, &image, CCV_IO_GRAY | CCV_IO_ANY_FILE);
assert(image != 0);
seq = ccv_bbf_detect_objects(image, &cascade, 1, ccv_bbf_default_params); // seq already declared above
for (i = 0; ENDORSE(i < seq->rnum); i++)
{
ccv_comp_t* comp = (ccv_comp_t*) ENDORSE(ccv_array_get(seq, i));
printf("%s %d %d %d %d %f\n", file, comp->rect.x, comp->rect.y, comp->rect.width, comp->rect.height, comp->classification.confidence);
}
}
free(file);
fclose(r);
}
ccv_bbf_classifier_cascade_free(cascade);
ccv_disable_cache();
accept_roi_end();
file = fopen(output_file, "w");
if (file == NULL) {
perror("fopen for write failed");
return EXIT_FAILURE;
}
for (i = 0; ENDORSE(i < seq->rnum); i++) {
ccv_comp_t* comp = (ccv_comp_t*) ENDORSE(ccv_array_get(seq, i));
ret_val = fprintf(file, "%d\n%d\n%d\n%d\n%f\n", comp->rect.x, comp->rect.y, comp->rect.width,
comp->rect.height, comp->classification.confidence);
if (ret_val < 0) {
perror("fprintf of coordinates and confidence failed");
fclose(file);
return EXIT_FAILURE;
}
}
ret_val = fclose(file);
if (ret_val != 0) {
perror("fclose failed");
return EXIT_FAILURE;
}
ccv_array_free(seq);
ccv_matrix_free(image);
}
return 0;
}
void ccv_hog(ccv_dense_matrix_t* a, ccv_dense_matrix_t** b, int b_type, int sbin, int size)
{
assert(a->rows >= size && a->cols >= size && (4 + sbin * 3) <= CCV_MAX_CHANNEL);
int rows = a->rows / size;
int cols = a->cols / size;
b_type = (CCV_GET_DATA_TYPE(b_type) == CCV_64F) ? CCV_64F | (4 + sbin * 3) : CCV_32F | (4 + sbin * 3);
ccv_declare_derived_signature(sig, a->sig != 0, ccv_sign_with_format(64, "ccv_hog(%d,%d)", sbin, size), a->sig, CCV_EOF_SIGN);
ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, rows, cols, CCV_64F | CCV_32F | (4 + sbin * 3), b_type, sig);
ccv_object_return_if_cached(, db);
ccv_dense_matrix_t* ag = 0;
ccv_dense_matrix_t* mg = 0;
ccv_gradient(a, &ag, 0, &mg, 0, 1, 1);
float* agp = ag->data.f32;
float* mgp = mg->data.f32;
int i, j, k, ch = CCV_GET_CHANNEL(a->type);
ccv_dense_matrix_t* cn = ccv_dense_matrix_new(rows, cols, CCV_GET_DATA_TYPE(db->type) | (sbin * 2), 0, 0);
ccv_dense_matrix_t* ca = ccv_dense_matrix_new(rows, cols, CCV_GET_DATA_TYPE(db->type) | CCV_C1, 0, 0);
ccv_zero(cn);
// normalize sbin direction-sensitive and sbin * 2 insensitive over 4 normalization factor
// accumulating them over sbin * 2 + sbin + 4 channels
// TNA - truncation - normalization - accumulation
#define TNA(_for_type, idx, a, b, c, d) \
{ \
_for_type norm = 1.0 / sqrt(cap[a] + cap[b] + cap[c] + cap[d] + 1e-4); \
for (k = 0; k < sbin * 2; k++) \
{ \
_for_type v = 0.5 * ccv_min(cnp[k] * norm, 0.2); \
dbp[4 + sbin + k] += v; \
dbp[idx] += v; \
} \
dbp[idx] *= 0.2357; \
for (k = 0; k < sbin; k++) \
{ \
_for_type v = 0.5 * ccv_min((cnp[k] + cnp[k + sbin]) * norm, 0.2); \
dbp[4 + k] += v; \
} \
}
#define for_block(_, _for_type) \
_for_type* cnp = (_for_type*)ccv_get_dense_matrix_cell(cn, 0, 0, 0); \
for (i = 0; i < rows * size; i++) \
{ \
for (j = 0; j < cols * size; j++) \
{ \
_for_type agv = agp[j * ch]; \
_for_type mgv = mgp[j * ch]; \
for (k = 1; k < ch; k++) \
if (mgp[j * ch + k] > mgv) \
{ \
mgv = mgp[j * ch + k]; \
agv = agp[j * ch + k]; \
} \
_for_type agr0 = (ccv_clamp(agv, 0, 359.99) / 360.0) * (sbin * 2); \
int ag0 = (int)agr0; \
int ag1 = (ag0 + 1 < sbin * 2) ? ag0 + 1 : 0; \
agr0 = agr0 - ag0; \
_for_type agr1 = 1.0 - agr0; \
mgv = mgv / 255.0; \
_for_type yp = ((_for_type)i + 0.5) / (_for_type)size - 0.5; \
_for_type xp = ((_for_type)j + 0.5) / (_for_type)size - 0.5; \
int iyp = (int)floor(yp); \
assert(iyp < rows); \
int ixp = (int)floor(xp); \
assert(ixp < cols); \
_for_type vy0 = yp - iyp; \
_for_type vx0 = xp - ixp; \
_for_type vy1 = 1.0 - vy0; \
_for_type vx1 = 1.0 - vx0; \
if (ixp >= 0 && iyp >= 0) \
{ \
cnp[iyp * cn->cols * sbin * 2 + ixp * sbin * 2 + ag0] += agr1 * vx1 * vy1 * mgv; \
cnp[iyp * cn->cols * sbin * 2 + ixp * sbin * 2 + ag1] += agr0 * vx1 * vy1 * mgv; \
} \
if (ixp + 1 < cn->cols && iyp >= 0) \
{ \
cnp[iyp * cn->cols * sbin * 2 + (ixp + 1) * sbin * 2 + ag0] += agr1 * vx0 * vy1 * mgv; \
cnp[iyp * cn->cols * sbin * 2 + (ixp + 1) * sbin * 2 + ag1] += agr0 * vx0 * vy1 * mgv; \
} \
if (ixp >= 0 && iyp + 1 < cn->rows) \
{ \
cnp[(iyp + 1) * cn->cols * sbin * 2 + ixp * sbin * 2 + ag0] += agr1 * vx1 * vy0 * mgv; \
cnp[(iyp + 1) * cn->cols * sbin * 2 + ixp * sbin * 2 + ag1] += agr0 * vx1 * vy0 * mgv; \
} \
if (ixp + 1 < cn->cols && iyp + 1 < cn->rows) \
{ \
cnp[(iyp + 1) * cn->cols * sbin * 2 + (ixp + 1) * sbin * 2 + ag0] += agr1 * vx0 * vy0 * mgv; \
cnp[(iyp + 1) * cn->cols * sbin * 2 + (ixp + 1) * sbin * 2 + ag1] += agr0 * vx0 * vy0 * mgv; \
} \
} \
agp += a->cols * ch; \
mgp += a->cols * ch; \
} \
ccv_matrix_free(ag); \
ccv_matrix_free(mg); \
cnp = (_for_type*)ccv_get_dense_matrix_cell(cn, 0, 0, 0); \
_for_type* cap = (_for_type*)ccv_get_dense_matrix_cell(ca, 0, 0, 0); \
for (i = 0; i < rows; i++) \
{ \
for (j = 0; j < cols; j++) \
{ \
*cap = 0; \
for (k = 0; k < sbin; k++) \
*cap += (cnp[k] + cnp[k + sbin]) * (cnp[k] + cnp[k + sbin]); \
cnp += 2 * sbin; \
cap++; \
} \
} \
cnp = (_for_type*)ccv_get_dense_matrix_cell(cn, 0, 0, 0); \
cap = (_for_type*)ccv_get_dense_matrix_cell(ca, 0, 0, 0); \
ccv_zero(db); \
_for_type* dbp = (_for_type*)ccv_get_dense_matrix_cell(db, 0, 0, 0); \
TNA(_for_type, 0, 1, cols + 1, cols, 0); \
TNA(_for_type, 1, 1, 1, 0, 0); \
TNA(_for_type, 2, 0, cols, cols, 0); \
TNA(_for_type, 3, 0, 0, 0, 0); \
cnp += 2 * sbin; \
dbp += 3 * sbin + 4; \
cap++; \
for (j = 1; j < cols - 1; j++) \
{ \
TNA(_for_type, 0, 1, cols + 1, cols, 0); \
TNA(_for_type, 1, 1, 1, 0, 0); \
TNA(_for_type, 2, -1, cols - 1, cols, 0); \
TNA(_for_type, 3, -1, -1, 0, 0); \
cnp += 2 * sbin; \
dbp += 3 * sbin + 4; \
cap++; \
} \
TNA(_for_type, 0, 0, cols, cols, 0); \
TNA(_for_type, 1, 0, 0, 0, 0); \
TNA(_for_type, 2, -1, cols - 1, cols, 0); \
TNA(_for_type, 3, -1, -1, 0, 0); \
cnp += 2 * sbin; \
dbp += 3 * sbin + 4; \
cap++; \
for (i = 1; i < rows - 1; i++) \
{ \
TNA(_for_type, 0, 1, cols + 1, cols, 0); \
TNA(_for_type, 1, 1, -cols + 1, -cols, 0); \
TNA(_for_type, 2, 0, cols, cols, 0); \
TNA(_for_type, 3, 0, -cols, -cols, 0); \
cnp += 2 * sbin; \
dbp += 3 * sbin + 4; \
cap++; \
for (j = 1; j < cols - 1; j++) \
{ \
TNA(_for_type, 0, 1, cols + 1, cols, 0); \
TNA(_for_type, 1, 1, -cols + 1, -cols, 0); \
TNA(_for_type, 2, -1, cols - 1, cols, 0); \
TNA(_for_type, 3, -1, -cols - 1, -cols, 0); \
cnp += 2 * sbin; \
dbp += 3 * sbin + 4; \
cap++; \
} \
TNA(_for_type, 0, 0, cols, cols, 0); \
TNA(_for_type, 1, 0, -cols, -cols, 0); \
TNA(_for_type, 2, -1, cols - 1, cols, 0); \
TNA(_for_type, 3, -1, -cols - 1, -cols, 0); \
cnp += 2 * sbin; \
dbp += 3 * sbin + 4; \
cap++; \
} \
TNA(_for_type, 0, 1, 1, 0, 0); \
TNA(_for_type, 1, 1, -cols + 1, -cols, 0); \
TNA(_for_type, 2, 0, 0, 0, 0); \
TNA(_for_type, 3, 0, -cols, -cols, 0); \
cnp += 2 * sbin; \
dbp += 3 * sbin + 4; \
cap++; \
for (j = 1; j < cols - 1; j++) \
{ \
TNA(_for_type, 0, 1, 1, 0, 0); \
TNA(_for_type, 1, 1, -cols + 1, -cols, 0); \
TNA(_for_type, 2, -1, -1, 0, 0); \
TNA(_for_type, 3, -1, -cols - 1, -cols, 0); \
cnp += 2 * sbin; \
dbp += 3 * sbin + 4; \
cap++; \
} \
TNA(_for_type, 0, 0, 0, 0, 0); \
TNA(_for_type, 1, 0, -cols, -cols, 0); \
TNA(_for_type, 2, -1, -1, 0, 0); \
TNA(_for_type, 3, -1, -cols - 1, -cols, 0);
ccv_matrix_typeof(db->type, for_block);
#undef for_block
#undef TNA
ccv_matrix_free(cn);
ccv_matrix_free(ca);
}
int main(int argc, char** argv)
{
#ifdef HAVE_AVCODEC
#ifdef HAVE_AVFORMAT
#ifdef HAVE_SWSCALE
assert(argc == 6);
ccv_rect_t box = ccv_rect(atoi(argv[2]), atoi(argv[3]), atoi(argv[4]), atoi(argv[5]));
box.width = box.width - box.x + 1;
box.height = box.height - box.y + 1;
printf("%d,%d,%d,%d,%f\n", box.x, box.y, box.width + box.x - 1, box.height + box.y - 1, 1.0f);
// init av-related structs
AVFormatContext* ic = 0;
int video_stream = -1;
AVStream* video_st = 0;
AVFrame* picture = 0;
AVFrame rgb_picture;
memset(&rgb_picture, 0, sizeof(AVPicture));
AVPacket packet;
memset(&packet, 0, sizeof(AVPacket));
av_init_packet(&packet);
av_register_all();
avformat_network_init();
// load video and codec
avformat_open_input(&ic, argv[1], 0, 0);
avformat_find_stream_info(ic, 0);
int i;
for (i = 0; i < ic->nb_streams; i++)
{
AVCodecContext* enc = ic->streams[i]->codec;
enc->thread_count = 2;
if (AVMEDIA_TYPE_VIDEO == enc->codec_type && video_stream < 0)
{
AVCodec* codec = avcodec_find_decoder(enc->codec_id);
if (!codec || avcodec_open2(enc, codec, 0) < 0)
continue;
video_stream = i;
video_st = ic->streams[i];
picture = avcodec_alloc_frame();
rgb_picture.data[0] = (uint8_t*)ccmalloc(avpicture_get_size(PIX_FMT_RGB24, enc->width, enc->height));
avpicture_fill((AVPicture*)&rgb_picture, rgb_picture.data[0], PIX_FMT_RGB24, enc->width, enc->height);
break;
}
}
int got_picture = 0;
while (!got_picture)
{
int result = av_read_frame(ic, &packet);
if (result == AVERROR(EAGAIN))
continue;
avcodec_decode_video2(video_st->codec, picture, &got_picture, &packet);
}
ccv_enable_default_cache();
struct SwsContext* picture_ctx = sws_getCachedContext(0, video_st->codec->width, video_st->codec->height, video_st->codec->pix_fmt, video_st->codec->width, video_st->codec->height, PIX_FMT_RGB24, SWS_BICUBIC, 0, 0, 0);
sws_scale(picture_ctx, (const uint8_t* const*)picture->data, picture->linesize, 0, video_st->codec->height, rgb_picture.data, rgb_picture.linesize);
ccv_dense_matrix_t* x = 0;
ccv_read(rgb_picture.data[0], &x, CCV_IO_RGB_RAW | CCV_IO_GRAY, video_st->codec->height, video_st->codec->width, rgb_picture.linesize[0]);
ccv_tld_t* tld = ccv_tld_new(x, box, ccv_tld_default_params);
ccv_dense_matrix_t* y = 0;
for (;;)
{
got_picture = 0;
int result = av_read_frame(ic, &packet);
if (result == AVERROR(EAGAIN))
continue;
avcodec_decode_video2(video_st->codec, picture, &got_picture, &packet);
if (!got_picture)
break;
sws_scale(picture_ctx, (const uint8_t* const*)picture->data, picture->linesize, 0, video_st->codec->height, rgb_picture.data, rgb_picture.linesize);
ccv_read(rgb_picture.data[0], &y, CCV_IO_RGB_RAW | CCV_IO_GRAY, video_st->codec->height, video_st->codec->width, rgb_picture.linesize[0]);
ccv_tld_info_t info;
ccv_comp_t newbox = ccv_tld_track_object(tld, x, y, &info);
printf("%04d: performed learn: %d, performed track: %d, successfully track: %d; %d passed fern detector, %d passed nnc detector, %d merged, %d confident matches, %d close matches\n", tld->count, info.perform_learn, info.perform_track, info.track_success, info.ferns_detects, info.nnc_detects, info.clustered_detects, info.confident_matches, info.close_matches);
ccv_dense_matrix_t* image = 0;
ccv_read(rgb_picture.data[0], &image, CCV_IO_RGB_RAW | CCV_IO_RGB_COLOR, video_st->codec->height, video_st->codec->width, rgb_picture.linesize[0]);
// draw out
// for (i = 0; i < tld->top->rnum; i++)
if (tld->found)
{
ccv_comp_t* comp = &newbox; // (ccv_comp_t*)ccv_array_get(tld->top, i);
if (comp->rect.x >= 0 && comp->rect.x + comp->rect.width < image->cols &&
comp->rect.y >= 0 && comp->rect.y + comp->rect.height < image->rows)
{
int x, y;
for (x = comp->rect.x; x < comp->rect.x + comp->rect.width; x++)
{
image->data.u8[image->step * comp->rect.y + x * 3] =
image->data.u8[image->step * (comp->rect.y + comp->rect.height - 1) + x * 3] = 255;
image->data.u8[image->step * comp->rect.y + x * 3 + 1] =
image->data.u8[image->step * (comp->rect.y + comp->rect.height - 1) + x * 3 + 1] =
image->data.u8[image->step * comp->rect.y + x * 3 + 2] =
image->data.u8[image->step * (comp->rect.y + comp->rect.height - 1) + x * 3 + 2] = 0;
}
for (y = comp->rect.y; y < comp->rect.y + comp->rect.height; y++)
{
image->data.u8[image->step * y + comp->rect.x * 3] =
image->data.u8[image->step * y + (comp->rect.x + comp->rect.width - 1) * 3] = 255;
image->data.u8[image->step * y + comp->rect.x * 3 + 1] =
image->data.u8[image->step * y + (comp->rect.x + comp->rect.width - 1) * 3 + 1] =
image->data.u8[image->step * y + comp->rect.x * 3 + 2] =
image->data.u8[image->step * y + (comp->rect.x + comp->rect.width - 1) * 3 + 2] = 0;
}
}
}
char filename[1024];
sprintf(filename, "tld-out/output-%04d.png", tld->count);
ccv_write(image, filename, 0, CCV_IO_PNG_FILE, 0);
ccv_matrix_free(image);
if (tld->found)
printf("%d,%d,%d,%d,%f\n", newbox.rect.x, newbox.rect.y, newbox.rect.width + newbox.rect.x - 1, newbox.rect.height + newbox.rect.y - 1, newbox.confidence);
else
printf("NaN,NaN,NaN,NaN,NaN\n");
x = y;
y = 0;
}
ccv_matrix_free(x);
ccv_tld_free(tld);
ccfree(rgb_picture.data[0]);
ccv_disable_cache();
#endif
#endif
#endif
return 0;
}
/* this code is a rewrite from OpenCV's legendary Lucas-Kanade optical flow implementation */
void ccv_optical_flow_lucas_kanade(ccv_dense_matrix_t* a, ccv_dense_matrix_t* b, ccv_array_t* point_a, ccv_array_t** point_b, ccv_size_t win_size, int level, double min_eigen)
{
assert(a && b && a->rows == b->rows && a->cols == b->cols);
assert(CCV_GET_CHANNEL(a->type) == CCV_GET_CHANNEL(b->type) && CCV_GET_DATA_TYPE(a->type) == CCV_GET_DATA_TYPE(b->type));
assert(CCV_GET_CHANNEL(a->type) == 1);
assert(CCV_GET_DATA_TYPE(a->type) == CCV_8U);
assert(point_a->rnum > 0);
level = ccv_clamp(level + 1, 1, (int)(log((double)ccv_min(a->rows, a->cols) / ccv_max(win_size.width * 2, win_size.height * 2)) / log(2.0) + 0.5));
ccv_declare_derived_signature(sig, a->sig != 0 && b->sig != 0 && point_a->sig != 0, ccv_sign_with_format(128, "ccv_optical_flow_lucas_kanade(%d,%d,%d,%la)", win_size.width, win_size.height, level, min_eigen), a->sig, b->sig, point_a->sig, CCV_EOF_SIGN);
ccv_array_t* seq = *point_b = ccv_array_new(sizeof(ccv_decimal_point_with_status_t), point_a->rnum, sig);
ccv_object_return_if_cached(, seq);
seq->rnum = point_a->rnum;
ccv_dense_matrix_t** pyr_a = (ccv_dense_matrix_t**)malloc(sizeof(ccv_dense_matrix_t*) * level);
ccv_dense_matrix_t** pyr_a_dx = (ccv_dense_matrix_t**)malloc(sizeof(ccv_dense_matrix_t*) * level);
ccv_dense_matrix_t** pyr_a_dy = (ccv_dense_matrix_t**)malloc(sizeof(ccv_dense_matrix_t*) * level);
ccv_dense_matrix_t** pyr_b = (ccv_dense_matrix_t**)malloc(sizeof(ccv_dense_matrix_t*) * level);
int i, j, t, x, y;
/* generating image pyramid */
pyr_a[0] = a;
pyr_a_dx[0] = pyr_a_dy[0] = 0;
ccv_sobel(pyr_a[0], &pyr_a_dx[0], 0, 3, 0);
ccv_sobel(pyr_a[0], &pyr_a_dy[0], 0, 0, 3);
pyr_b[0] = b;
for (i = 1; i < level; i++)
{
pyr_a[i] = pyr_a_dx[i] = pyr_a_dy[i] = pyr_b[i] = 0;
ccv_sample_down(pyr_a[i - 1], &pyr_a[i], 0, 0, 0);
ccv_sobel(pyr_a[i], &pyr_a_dx[i], 0, 3, 0);
ccv_sobel(pyr_a[i], &pyr_a_dy[i], 0, 0, 3);
ccv_sample_down(pyr_b[i - 1], &pyr_b[i], 0, 0, 0);
}
int* wi = (int*)malloc(sizeof(int) * win_size.width * win_size.height);
int* widx = (int*)malloc(sizeof(int) * win_size.width * win_size.height);
int* widy = (int*)malloc(sizeof(int) * win_size.width * win_size.height);
ccv_decimal_point_t half_win = ccv_decimal_point((win_size.width - 1) * 0.5f, (win_size.height - 1) * 0.5f);
const int W_BITS14 = 14, W_BITS7 = 7, W_BITS9 = 9;
const float FLT_SCALE = 1.0f / (1 << 25);
// clean up status to 1
for (i = 0; i < point_a->rnum; i++)
{
ccv_decimal_point_with_status_t* point_with_status = (ccv_decimal_point_with_status_t*)ccv_array_get(seq, i);
point_with_status->status = 1;
}
int prev_rows, prev_cols;
for (t = level - 1; t >= 0; t--)
{
ccv_dense_matrix_t* a = pyr_a[t];
ccv_dense_matrix_t* adx = pyr_a_dx[t];
ccv_dense_matrix_t* ady = pyr_a_dy[t];
assert(CCV_GET_DATA_TYPE(adx->type) == CCV_32S);
assert(CCV_GET_DATA_TYPE(ady->type) == CCV_32S);
ccv_dense_matrix_t* b = pyr_b[t];
for (i = 0; i < point_a->rnum; i++)
{
ccv_decimal_point_t prev_point = *(ccv_decimal_point_t*)ccv_array_get(point_a, i);
ccv_decimal_point_with_status_t* point_with_status = (ccv_decimal_point_with_status_t*)ccv_array_get(seq, i);
prev_point.x = prev_point.x / (float)(1 << t);
prev_point.y = prev_point.y / (float)(1 << t);
ccv_decimal_point_t next_point;
if (t == level - 1)
next_point = prev_point;
else {
next_point.x = point_with_status->point.x * 2 + (a->cols - prev_cols * 2) * 0.5;
next_point.y = point_with_status->point.y * 2 + (a->rows - prev_rows * 2) * 0.5;
}
point_with_status->point = next_point;
prev_point.x -= half_win.x;
prev_point.y -= half_win.y;
ccv_point_t iprev_point = ccv_point((int)prev_point.x, (int)prev_point.y);
if (iprev_point.x < 0 || iprev_point.x >= a->cols - win_size.width - 1 ||
iprev_point.y < 0 || iprev_point.y >= a->rows - win_size.height - 1)
{
if (t == 0)
point_with_status->status = 0;
continue;
}
float xd = prev_point.x - iprev_point.x;
float yd = prev_point.y - iprev_point.y;
int iw00 = (int)((1 - xd) * (1 - yd) * (1 << W_BITS14) + 0.5);
int iw01 = (int)(xd * (1 - yd) * (1 << W_BITS14) + 0.5);
int iw10 = (int)((1 - xd) * yd * (1 << W_BITS14) + 0.5);
int iw11 = (1 << W_BITS14) - iw00 - iw01 - iw10;
float a11 = 0, a12 = 0, a22 = 0;
unsigned char* a_ptr = (unsigned char*)ccv_get_dense_matrix_cell_by(CCV_C1 | CCV_8U, a, iprev_point.y, iprev_point.x, 0);
int* adx_ptr = (int*)ccv_get_dense_matrix_cell_by(CCV_C1 | CCV_32S, adx, iprev_point.y, iprev_point.x, 0);
int* ady_ptr = (int*)ccv_get_dense_matrix_cell_by(CCV_C1 | CCV_32S, ady, iprev_point.y, iprev_point.x, 0);
int* wi_ptr = wi;
int* widx_ptr = widx;
int* widy_ptr = widy;
for (y = 0; y < win_size.height; y++)
{
for (x = 0; x < win_size.width; x++)
{
wi_ptr[x] = ccv_descale(a_ptr[x] * iw00 + a_ptr[x + 1] * iw01 + a_ptr[x + a->step] * iw10 + a_ptr[x + a->step + 1] * iw11, W_BITS7);
// because we use 3x3 sobel, which scaled derivative up by 4
widx_ptr[x] = ccv_descale(adx_ptr[x] * iw00 + adx_ptr[x + 1] * iw01 + adx_ptr[x + adx->cols] * iw10 + adx_ptr[x + adx->cols + 1] * iw11, W_BITS9);
widy_ptr[x] = ccv_descale(ady_ptr[x] * iw00 + ady_ptr[x + 1] * iw01 + ady_ptr[x + ady->cols] + iw10 + ady_ptr[x + ady->cols + 1] * iw11, W_BITS9);
a11 += (float)(widx_ptr[x] * widx_ptr[x]);
a12 += (float)(widx_ptr[x] * widy_ptr[x]);
a22 += (float)(widy_ptr[x] * widy_ptr[x]);
}
a_ptr += a->step;
adx_ptr += adx->cols;
ady_ptr += ady->cols;
wi_ptr += win_size.width;
widx_ptr += win_size.width;
widy_ptr += win_size.width;
}
a11 *= FLT_SCALE;
a12 *= FLT_SCALE;
a22 *= FLT_SCALE;
float D = a11 * a22 - a12 * a12;
float eigen = (a22 + a11 - sqrtf((a11 - a22) * (a11 - a22) + 4.0f * a12 * a12)) / (2 * win_size.width * win_size.height);
if (eigen < min_eigen || D < FLT_EPSILON)
{
if (t == 0)
point_with_status->status = 0;
continue;
}
D = 1.0f / D;
next_point.x -= half_win.x;
next_point.y -= half_win.y;
ccv_decimal_point_t prev_delta;
for (j = 0; j < LK_MAX_ITER; j++)
{
ccv_point_t inext_point = ccv_point((int)next_point.x, (int)next_point.y);
if (inext_point.x < 0 || inext_point.x >= a->cols - win_size.width - 1 ||
inext_point.y < 0 || inext_point.y >= a->rows - win_size.height - 1)
break;
float xd = next_point.x - inext_point.x;
float yd = next_point.y - inext_point.y;
int iw00 = (int)((1 - xd) * (1 - yd) * (1 << W_BITS14) + 0.5);
int iw01 = (int)(xd * (1 - yd) * (1 << W_BITS14) + 0.5);
int iw10 = (int)((1 - xd) * yd * (1 << W_BITS14) + 0.5);
int iw11 = (1 << W_BITS14) - iw00 - iw01 - iw10;
float b1 = 0, b2 = 0;
unsigned char* b_ptr = (unsigned char*)ccv_get_dense_matrix_cell_by(CCV_C1 | CCV_8U, b, inext_point.y, inext_point.x, 0);
int* wi_ptr = wi;
int* widx_ptr = widx;
int* widy_ptr = widy;
for (y = 0; y < win_size.height; y++)
{
for (x = 0; x < win_size.width; x++)
{
int diff = ccv_descale(b_ptr[x] * iw00 + b_ptr[x + 1] * iw01 + b_ptr[x + b->step] * iw10 + b_ptr[x + b->step + 1] * iw11, W_BITS7) - wi_ptr[x];
b1 += (float)(diff * widx_ptr[x]);
b2 += (float)(diff * widy_ptr[x]);
}
b_ptr += b->step;
wi_ptr += win_size.width;
widx_ptr += win_size.width;
widy_ptr += win_size.width;
}
b1 *= FLT_SCALE;
b2 *= FLT_SCALE;
ccv_decimal_point_t delta = ccv_decimal_point((a12 * b2 - a22 * b1) * D, (a12 * b1 - a11 * b2) * D);
next_point.x += delta.x;
next_point.y += delta.y;
if (delta.x * delta.x + delta.y * delta.y < LK_EPSILON)
break;
if (j > 0 && fabs(prev_delta.x - delta.x) < 0.01 && fabs(prev_delta.y - delta.y) < 0.01)
{
next_point.x -= delta.x * 0.5;
next_point.y -= delta.y * 0.5;
break;
}
prev_delta = delta;
}
ccv_point_t inext_point = ccv_point((int)next_point.x, (int)next_point.y);
if (inext_point.x < 0 || inext_point.x >= a->cols - win_size.width - 1 ||
inext_point.y < 0 || inext_point.y >= a->rows - win_size.height - 1)
point_with_status->status = 0;
else {
point_with_status->point.x = next_point.x + half_win.x;
point_with_status->point.y = next_point.y + half_win.y;
}
}
prev_rows = a->rows;
prev_cols = a->cols;
ccv_matrix_free(adx);
ccv_matrix_free(ady);
if (t > 0)
{
ccv_matrix_free(a);
ccv_matrix_free(b);
}
}
free(widy);
free(widx);
free(wi);
free(pyr_b);
free(pyr_a_dy);
free(pyr_a_dx);
free(pyr_a);
}
ccv_array_t* ccv_bbf_detect_objects(ccv_dense_matrix_t* a, ccv_bbf_classifier_cascade_t** _cascade, int count, ccv_bbf_param_t params)
{
int hr = a->rows / ENDORSE(params.size.height);
int wr = a->cols / ENDORSE(params.size.width);
double scale = pow(2., 1. / (params.interval + 1.));
APPROX int next = params.interval + 1;
int scale_upto = (int)(log((double)ccv_min(hr, wr)) / log(scale));
ccv_dense_matrix_t** pyr = (ccv_dense_matrix_t**)alloca(ENDORSE(scale_upto + next * 2) * 4 * sizeof(ccv_dense_matrix_t*));
memset(pyr, 0, (scale_upto + next * 2) * 4 * sizeof(ccv_dense_matrix_t*));
if (ENDORSE(params.size.height != _cascade[0]->size.height || params.size.width != _cascade[0]->size.width))
ccv_resample(a, &pyr[0], 0, a->rows * ENDORSE(_cascade[0]->size.height / params.size.height), a->cols * ENDORSE(_cascade[0]->size.width / params.size.width), CCV_INTER_AREA);
else
pyr[0] = a;
APPROX int i;
int j, k, t, x, y, q;
for (i = 1; ENDORSE(i < ccv_min(params.interval + 1, scale_upto + next * 2)); i++)
ccv_resample(pyr[0], &pyr[i * 4], 0, (int)(pyr[0]->rows / pow(scale, i)), (int)(pyr[0]->cols / pow(scale, i)), CCV_INTER_AREA);
for (i = next; ENDORSE(i < scale_upto + next * 2); i++)
ccv_sample_down(pyr[i * 4 - next * 4], &pyr[i * 4], 0, 0, 0);
if (params.accurate)
for (i = next * 2; ENDORSE(i < scale_upto + next * 2); i++)
{
ccv_sample_down(pyr[i * 4 - next * 4], &pyr[i * 4 + 1], 0, 1, 0);
ccv_sample_down(pyr[i * 4 - next * 4], &pyr[i * 4 + 2], 0, 0, 1);
ccv_sample_down(pyr[i * 4 - next * 4], &pyr[i * 4 + 3], 0, 1, 1);
}
ccv_array_t* idx_seq;
ccv_array_t* seq = ccv_array_new(sizeof(ccv_comp_t), 64, 0);
ccv_array_t* seq2 = ccv_array_new(sizeof(ccv_comp_t), 64, 0);
ccv_array_t* result_seq = ccv_array_new(sizeof(ccv_comp_t), 64, 0);
/* detect in multi scale */
for (t = 0; t < count; t++)
{
ccv_bbf_classifier_cascade_t* cascade = _cascade[t];
APPROX float scale_x = (float) params.size.width / (float) cascade->size.width;
APPROX float scale_y = (float) params.size.height / (float) cascade->size.height;
ccv_array_clear(seq);
for (i = 0; ENDORSE(i < scale_upto); i++)
{
APPROX int dx[] = {0, 1, 0, 1};
APPROX int dy[] = {0, 0, 1, 1};
APPROX int i_rows = pyr[i * 4 + next * 8]->rows - ENDORSE(cascade->size.height >> 2);
APPROX int steps[] = { pyr[i * 4]->step, pyr[i * 4 + next * 4]->step, pyr[i * 4 + next * 8]->step };
APPROX int i_cols = pyr[i * 4 + next * 8]->cols - ENDORSE(cascade->size.width >> 2);
int paddings[] = { pyr[i * 4]->step * 4 - i_cols * 4,
pyr[i * 4 + next * 4]->step * 2 - i_cols * 2,
pyr[i * 4 + next * 8]->step - i_cols };
for (q = 0; q < (params.accurate ? 4 : 1); q++)
{
APPROX unsigned char* u8[] = { pyr[i * 4]->data.u8 + dx[q] * 2 + dy[q] * pyr[i * 4]->step * 2, pyr[i * 4 + next * 4]->data.u8 + dx[q] + dy[q] * pyr[i * 4 + next * 4]->step, pyr[i * 4 + next * 8 + q]->data.u8 };
for (y = 0; ENDORSE(y < i_rows); y++)
{
for (x = 0; ENDORSE(x < i_cols); x++)
{
APPROX float sum;
APPROX int flag = 1;
ccv_bbf_stage_classifier_t* classifier = cascade->stage_classifier;
for (j = 0; j < ENDORSE(cascade->count); ++j, ++classifier)
{
sum = 0;
APPROX float* alpha = classifier->alpha;
ccv_bbf_feature_t* feature = classifier->feature;
for (k = 0; k < ENDORSE(classifier->count); ++k, alpha += 2, ++feature)
sum += alpha[_ccv_run_bbf_feature(feature, ENDORSE(steps), u8)];
if (ENDORSE(sum) < ENDORSE(classifier->threshold))
{
flag = 0;
break;
}
}
if (ENDORSE(flag))
{
ccv_comp_t comp;
comp.rect = ccv_rect((int)((x * 4 + dx[q] * 2) * scale_x + 0.5), (int)((y * 4 + dy[q] * 2) * scale_y + 0.5), (int)(cascade->size.width * scale_x + 0.5), (int)(cascade->size.height * scale_y + 0.5));
comp.neighbors = 1;
comp.classification.id = t;
comp.classification.confidence = sum;
ccv_array_push(seq, &comp);
}
u8[0] += 4;
u8[1] += 2;
u8[2] += 1;
}
u8[0] += paddings[0];
u8[1] += paddings[1];
u8[2] += paddings[2];
}
}
scale_x *= scale;
scale_y *= scale;
}
/* the following code from OpenCV's haar feature implementation */
if(params.min_neighbors == 0)
{
for (i = 0; ENDORSE(i < seq->rnum); i++)
{
ccv_comp_t* comp = (ccv_comp_t*)ENDORSE(ccv_array_get(seq, i));
ccv_array_push(result_seq, comp);
}
} else {
idx_seq = 0;
ccv_array_clear(seq2);
// group retrieved rectangles in order to filter out noise
int ncomp = ccv_array_group(seq, &idx_seq, _ccv_is_equal_same_class, 0);
ccv_comp_t* comps = (ccv_comp_t*)ccmalloc((ncomp + 1) * sizeof(ccv_comp_t));
memset(comps, 0, (ncomp + 1) * sizeof(ccv_comp_t));
// count number of neighbors
for(i = 0; ENDORSE(i < seq->rnum); i++)
{
ccv_comp_t r1 = *(ccv_comp_t*)ENDORSE(ccv_array_get(seq, i));
int idx = *(int*)ENDORSE(ccv_array_get(idx_seq, i));
if (ENDORSE(comps[idx].neighbors) == 0)
comps[idx].classification.confidence = r1.classification.confidence;
++comps[idx].neighbors;
comps[idx].rect.x += r1.rect.x;
comps[idx].rect.y += r1.rect.y;
comps[idx].rect.width += r1.rect.width;
comps[idx].rect.height += r1.rect.height;
comps[idx].classification.id = r1.classification.id;
comps[idx].classification.confidence = ccv_max(comps[idx].classification.confidence, r1.classification.confidence);
}
// calculate average bounding box
for(i = 0; ENDORSE(i < ncomp); i++)
{
int n = ENDORSE(comps[i].neighbors);
if(n >= params.min_neighbors)
{
ccv_comp_t comp;
comp.rect.x = (comps[i].rect.x * 2 + n) / (2 * n);
comp.rect.y = (comps[i].rect.y * 2 + n) / (2 * n);
comp.rect.width = (comps[i].rect.width * 2 + n) / (2 * n);
comp.rect.height = (comps[i].rect.height * 2 + n) / (2 * n);
comp.neighbors = comps[i].neighbors;
comp.classification.id = comps[i].classification.id;
comp.classification.confidence = comps[i].classification.confidence;
ccv_array_push(seq2, &comp);
}
}
// filter out small face rectangles inside large face rectangles
for(i = 0; ENDORSE(i < seq2->rnum); i++)
{
ccv_comp_t r1 = *(ccv_comp_t*)ENDORSE(ccv_array_get(seq2, i));
APPROX int flag = 1;
for(j = 0; ENDORSE(j < seq2->rnum); j++)
{
ccv_comp_t r2 = *(ccv_comp_t*)ENDORSE(ccv_array_get(seq2, j));
APPROX int distance = (int)(r2.rect.width * 0.25 + 0.5);
if(ENDORSE(i != j &&
r1.classification.id == r2.classification.id &&
r1.rect.x >= r2.rect.x - distance &&
r1.rect.y >= r2.rect.y - distance &&
r1.rect.x + r1.rect.width <= r2.rect.x + r2.rect.width + distance &&
r1.rect.y + r1.rect.height <= r2.rect.y + r2.rect.height + distance &&
(r2.neighbors > ccv_max(3, r1.neighbors) || r1.neighbors < 3)))
{
flag = 0;
break;
}
}
if(ENDORSE(flag))
ccv_array_push(result_seq, &r1);
}
ccv_array_free(idx_seq);
ccfree(comps);
}
}
ccv_array_free(seq);
ccv_array_free(seq2);
ccv_array_t* result_seq2;
/* the following code from OpenCV's haar feature implementation */
if (params.flags & CCV_BBF_NO_NESTED)
{
result_seq2 = ccv_array_new(sizeof(ccv_comp_t), 64, 0);
idx_seq = 0;
// group retrieved rectangles in order to filter out noise
int ncomp = ccv_array_group(result_seq, &idx_seq, _ccv_is_equal, 0);
ccv_comp_t* comps = (ccv_comp_t*)ccmalloc((ncomp + 1) * sizeof(ccv_comp_t));
memset(comps, 0, (ncomp + 1) * sizeof(ccv_comp_t));
// count number of neighbors
for(i = 0; ENDORSE(i < result_seq->rnum); i++)
{
ccv_comp_t r1 = *(ccv_comp_t*)ENDORSE(ccv_array_get(result_seq, i));
int idx = *(int*)ENDORSE(ccv_array_get(idx_seq, i));
if (ENDORSE(comps[idx].neighbors == 0 || comps[idx].classification.confidence < r1.classification.confidence))
{
comps[idx].classification.confidence = r1.classification.confidence;
comps[idx].neighbors = 1;
comps[idx].rect = r1.rect;
comps[idx].classification.id = r1.classification.id;
}
}
// calculate average bounding box
for(i = 0; ENDORSE(i < ncomp); i++)
if(ENDORSE(comps[i].neighbors))
ccv_array_push(result_seq2, &comps[i]);
ccv_array_free(result_seq);
ccfree(comps);
} else {
result_seq2 = result_seq;
}
for (i = 1; ENDORSE(i < scale_upto + next * 2); i++)
ccv_matrix_free(pyr[i * 4]);
if (params.accurate)
for (i = next * 2; ENDORSE(i < scale_upto + next * 2); i++)
{
ccv_matrix_free(pyr[i * 4 + 1]);
ccv_matrix_free(pyr[i * 4 + 2]);
ccv_matrix_free(pyr[i * 4 + 3]);
}
if (ENDORSE(params.size.height != _cascade[0]->size.height || params.size.width != _cascade[0]->size.width))
ccv_matrix_free(pyr[0]);
return result_seq2;
}
int main(int argc, char** argv)
{
assert(argc == 3);
ccv_enable_default_cache();
ccv_dense_matrix_t* object = 0;
ccv_dense_matrix_t* image = 0;
ccv_read(argv[1], &object, CCV_IO_GRAY | CCV_IO_ANY_FILE);
ccv_read(argv[2], &image, CCV_IO_GRAY | CCV_IO_ANY_FILE);
unsigned int elapsed_time = get_current_time();
ccv_sift_param_t params = {
.noctaves = 3,
.nlevels = 6,
.up2x = 1,
.edge_threshold = 10,
.norm_threshold = 0,
.peak_threshold = 0,
};
ccv_array_t* obj_keypoints = 0;
ccv_dense_matrix_t* obj_desc = 0;
ccv_sift(object, &obj_keypoints, &obj_desc, 0, params);
ccv_array_t* image_keypoints = 0;
ccv_dense_matrix_t* image_desc = 0;
ccv_sift(image, &image_keypoints, &image_desc, 0, params);
elapsed_time = get_current_time() - elapsed_time;
int i, j, k;
int match = 0;
for (i = 0; i < obj_keypoints->rnum; i++)
{
float* odesc = obj_desc->data.f32 + i * 128;
int minj = -1;
double mind = 1e6, mind2 = 1e6;
for (j = 0; j < image_keypoints->rnum; j++)
{
float* idesc = image_desc->data.f32 + j * 128;
double d = 0;
for (k = 0; k < 128; k++)
{
d += (odesc[k] - idesc[k]) * (odesc[k] - idesc[k]);
if (d > mind2)
break;
}
if (d < mind)
{
mind2 = mind;
mind = d;
minj = j;
} else if (d < mind2) {
mind2 = d;
}
}
if (mind < mind2 * 0.36)
{
ccv_keypoint_t* op = (ccv_keypoint_t*)ccv_array_get(obj_keypoints, i);
ccv_keypoint_t* kp = (ccv_keypoint_t*)ccv_array_get(image_keypoints, minj);
printf("%f %f => %f %f\n", op->x, op->y, kp->x, kp->y);
match++;
}
}
printf("%dx%d on %dx%d\n", object->cols, object->rows, image->cols, image->rows);
printf("%d keypoints out of %d are matched\n", match, obj_keypoints->rnum);
printf("elpased time : %d\n", elapsed_time);
ccv_array_free(obj_keypoints);
ccv_array_free(image_keypoints);
ccv_matrix_free(obj_desc);
ccv_matrix_free(image_desc);
ccv_matrix_free(object);
ccv_matrix_free(image);
ccv_disable_cache();
return 0;
}
int main(int argc, char** argv)
{
assert(argc >= 3);
int i, j;
ccv_enable_default_cache();
ccv_dense_matrix_t* image = 0;
ccv_read(argv[1], &image, CCV_IO_ANY_FILE);
ccv_dpm_mixture_model_t* model = ccv_dpm_read_mixture_model(argv[2]);
if (image != 0)
{
unsigned int elapsed_time = get_current_time();
ccv_array_t* seq = ccv_dpm_detect_objects(image, &model, 1, ccv_dpm_default_params);
elapsed_time = get_current_time() - elapsed_time;
if (seq)
{
for (i = 0; i < seq->rnum; i++)
{
ccv_root_comp_t* comp = (ccv_root_comp_t*)ccv_array_get(seq, i);
printf("%d %d %d %d %f %d\n", comp->rect.x, comp->rect.y, comp->rect.width, comp->rect.height, comp->classification.confidence, comp->pnum);
for (j = 0; j < comp->pnum; j++)
printf("| %d %d %d %d %f\n", comp->part[j].rect.x, comp->part[j].rect.y, comp->part[j].rect.width, comp->part[j].rect.height, comp->part[j].classification.confidence);
}
printf("total : %d in time %dms\n", seq->rnum, elapsed_time);
ccv_array_free(seq);
} else {
printf("elapsed time %dms\n", elapsed_time);
}
ccv_matrix_free(image);
} else {
FILE* r = fopen(argv[1], "rt");
if (argc == 4)
chdir(argv[3]);
if(r)
{
size_t len = 1024;
char* file = (char*)malloc(len);
ssize_t read;
while((read = getline(&file, &len, r)) != -1)
{
while(read > 1 && isspace(file[read - 1]))
read--;
file[read] = 0;
image = 0;
ccv_read(file, &image, CCV_IO_GRAY | CCV_IO_ANY_FILE);
assert(image != 0);
ccv_array_t* seq = ccv_dpm_detect_objects(image, &model, 1, ccv_dpm_default_params);
if (seq != 0)
{
for (i = 0; i < seq->rnum; i++)
{
ccv_root_comp_t* comp = (ccv_root_comp_t*)ccv_array_get(seq, i);
printf("%s %d %d %d %d %f %d\n", file, comp->rect.x, comp->rect.y, comp->rect.width, comp->rect.height, comp->classification.confidence, comp->pnum);
for (j = 0; j < comp->pnum; j++)
printf("| %d %d %d %d %f\n", comp->part[j].rect.x, comp->part[j].rect.y, comp->part[j].rect.width, comp->part[j].rect.height, comp->part[j].classification.confidence);
}
ccv_array_free(seq);
}
ccv_matrix_free(image);
}
free(file);
fclose(r);
}
}
ccv_drain_cache();
ccv_dpm_mixture_model_free(model);
return 0;
}