static void _ccv_init_cubic_coeffs(int si, int sz, float s, ccv_cubic_coeffs_t* coeff)
{
const float A = -0.75f;
coeff->si[0] = ccv_max(si - 1, 0);
coeff->si[1] = si;
coeff->si[2] = ccv_min(si + 1, sz - 1);
coeff->si[3] = ccv_min(si + 2, sz - 1);
float x = s - si;
coeff->coeffs[0] = ((A * (x + 1) - 5 * A) * (x + 1) + 8 * A) * (x + 1) - 4 * A;
coeff->coeffs[1] = ((A + 2) * x - (A + 3)) * x * x + 1;
coeff->coeffs[2] = ((A + 2) * (1 - x) - (A + 3)) * (1 - x) * (1 - x) + 1;
coeff->coeffs[3] = 1.f - coeff->coeffs[0] - coeff->coeffs[1] - coeff->coeffs[2];
}
static void _ccv_init_cubic_integer_coeffs(int si, int sz, float s, ccv_cubic_integer_coeffs_t* coeff)
{
const float A = -0.75f;
coeff->si[0] = ccv_max(si - 1, 0);
coeff->si[1] = si;
coeff->si[2] = ccv_min(si + 1, sz - 1);
coeff->si[3] = ccv_min(si + 2, sz - 1);
float x = s - si;
const int W_BITS = 1 << 6;
coeff->coeffs[0] = (int)((((A * (x + 1) - 5 * A) * (x + 1) + 8 * A) * (x + 1) - 4 * A) * W_BITS + 0.5);
coeff->coeffs[1] = (int)((((A + 2) * x - (A + 3)) * x * x + 1) * W_BITS + 0.5);
coeff->coeffs[2] = (int)((((A + 2) * (1 - x) - (A + 3)) * (1 - x) * (1 - x) + 1) * W_BITS + 0.5);
coeff->coeffs[3] = W_BITS - coeff->coeffs[0] - coeff->coeffs[1] - coeff->coeffs[2];
}
static void _ccv_resample_area(ccv_dense_matrix_t* a, ccv_dense_matrix_t* b)
{
assert(a->cols > 0 && b->cols > 0);
ccv_area_alpha_t* xofs = (ccv_area_alpha_t*)alloca(sizeof(ccv_area_alpha_t) * a->cols * 2);
int ch = CCV_GET_CHANNEL(a->type);
double scale_x = (double)a->cols / b->cols;
double scale_y = (double)a->rows / b->rows;
double scale = 1.f / (scale_x * scale_y);
int dx, dy, sx, sy, i, k;
for (dx = 0, k = 0; dx < b->cols; dx++)
{
double fsx1 = dx * scale_x, fsx2 = fsx1 + scale_x;
int sx1 = (int)(fsx1 + 1.0 - 1e-6), sx2 = (int)(fsx2);
sx1 = ccv_min(sx1, a->cols - 1);
sx2 = ccv_min(sx2, a->cols - 1);
if (sx1 > fsx1)
{
xofs[k].di = dx * ch;
xofs[k].si = (sx1 - 1) * ch;
xofs[k++].alpha = (float)((sx1 - fsx1) * scale);
}
for (sx = sx1; sx < sx2; sx++)
{
xofs[k].di = dx * ch;
xofs[k].si = sx * ch;
xofs[k++].alpha = (float)scale;
}
if (fsx2 - sx2 > 1e-3)
{
xofs[k].di = dx * ch;
xofs[k].si = sx2 * ch;
xofs[k++].alpha = (float)((fsx2 - sx2) * scale);
}
}
int xofs_count = k;
float* buf = (float*)alloca(b->cols * ch * sizeof(float));
float* sum = (float*)alloca(b->cols * ch * sizeof(float));
for (dx = 0; dx < b->cols * ch; dx++)
buf[dx] = sum[dx] = 0;
dy = 0;
#define for_block(_for_get, _for_set) \
for (sy = 0; sy < a->rows; sy++) \
{ \
unsigned char* a_ptr = a->data.u8 + a->step * sy; \
for (k = 0; k < xofs_count; k++) \
{ \
int dxn = xofs[k].di; \
float alpha = xofs[k].alpha; \
for (i = 0; i < ch; i++) \
buf[dxn + i] += _for_get(a_ptr, xofs[k].si + i, 0) * alpha; \
} \
if ((dy + 1) * scale_y <= sy + 1 || sy == a->rows - 1) \
{ \
float beta = ccv_max(sy + 1 - (dy + 1) * scale_y, 0.f); \
float beta1 = 1 - beta; \
unsigned char* b_ptr = b->data.u8 + b->step * dy; \
if (fabs(beta) < 1e-3) \
{ \
for (dx = 0; dx < b->cols * ch; dx++) \
{ \
_for_set(b_ptr, dx, sum[dx] + buf[dx], 0); \
sum[dx] = buf[dx] = 0; \
} \
} else { \
for (dx = 0; dx < b->cols * ch; dx++) \
{ \
_for_set(b_ptr, dx, sum[dx] + buf[dx] * beta1, 0); \
sum[dx] = buf[dx] * beta; \
buf[dx] = 0; \
} \
} \
dy++; \
} \
else \
{ \
for(dx = 0; dx < b->cols * ch; dx++) \
{ \
sum[dx] += buf[dx]; \
buf[dx] = 0; \
} \
} \
}
ccv_matrix_getter(a->type, ccv_matrix_setter, b->type, for_block);
#undef for_block
}
static void _ccv_resample_area_8u(ccv_dense_matrix_t* a, ccv_dense_matrix_t* b)
{
assert(a->cols > 0 && b->cols > 0);
ccv_int_alpha* xofs = (ccv_int_alpha*)alloca(sizeof(ccv_int_alpha) * a->cols * 2);
int ch = ccv_clamp(CCV_GET_CHANNEL(a->type), 1, 4);
double scale_x = (double)a->cols / b->cols;
double scale_y = (double)a->rows / b->rows;
// double scale = 1.f / (scale_x * scale_y);
unsigned int inv_scale_256 = (int)(scale_x * scale_y * 0x10000);
int dx, dy, sx, sy, i, k;
for (dx = 0, k = 0; dx < b->cols; dx++)
{
double fsx1 = dx * scale_x, fsx2 = fsx1 + scale_x;
int sx1 = (int)(fsx1 + 1.0 - 1e-6), sx2 = (int)(fsx2);
sx1 = ccv_min(sx1, a->cols - 1);
sx2 = ccv_min(sx2, a->cols - 1);
if (sx1 > fsx1)
{
xofs[k].di = dx * ch;
xofs[k].si = (sx1 - 1) * ch;
xofs[k++].alpha = (unsigned int)((sx1 - fsx1) * 0x100);
}
for (sx = sx1; sx < sx2; sx++)
{
xofs[k].di = dx * ch;
xofs[k].si = sx * ch;
xofs[k++].alpha = 256;
}
if (fsx2 - sx2 > 1e-3)
{
xofs[k].di = dx * ch;
xofs[k].si = sx2 * ch;
xofs[k++].alpha = (unsigned int)((fsx2 - sx2) * 256);
}
}
int xofs_count = k;
unsigned int* buf = (unsigned int*)alloca(b->cols * ch * sizeof(unsigned int));
unsigned int* sum = (unsigned int*)alloca(b->cols * ch * sizeof(unsigned int));
for (dx = 0; dx < b->cols * ch; dx++)
buf[dx] = sum[dx] = 0;
dy = 0;
for (sy = 0; sy < a->rows; sy++)
{
unsigned char* a_ptr = a->data.u8 + a->step * sy;
for (k = 0; k < xofs_count; k++)
{
int dxn = xofs[k].di;
unsigned int alpha = xofs[k].alpha;
for (i = 0; i < ch; i++)
buf[dxn + i] += a_ptr[xofs[k].si + i] * alpha;
}
if ((dy + 1) * scale_y <= sy + 1 || sy == a->rows - 1)
{
unsigned int beta = (int)(ccv_max(sy + 1 - (dy + 1) * scale_y, 0.f) * 256);
unsigned int beta1 = 256 - beta;
unsigned char* b_ptr = b->data.u8 + b->step * dy;
if (beta <= 0)
{
for (dx = 0; dx < b->cols * ch; dx++)
{
b_ptr[dx] = ccv_clamp((sum[dx] + buf[dx] * 256) / inv_scale_256, 0, 255);
sum[dx] = buf[dx] = 0;
}
} else {
for (dx = 0; dx < b->cols * ch; dx++)
{
b_ptr[dx] = ccv_clamp((sum[dx] + buf[dx] * beta1) / inv_scale_256, 0, 255);
sum[dx] = buf[dx] * beta;
buf[dx] = 0;
}
}
dy++;
}
else
{
for(dx = 0; dx < b->cols * ch; dx++)
{
sum[dx] += buf[dx] * 256;
buf[dx] = 0;
}
}
}
}
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;
}
/* 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);
}
// compute harmonic mean of precision / recall of swt
static void _ccv_evaluate_wolf(ccv_array_t* words, ccv_array_t* truth, ccv_swt_param_t params, double* precision, double* recall)
{
if (words->rnum == 0 || truth->rnum == 0)
return;
int j, k;
double total_recall = 0, total_precision = 0;
int* cG = (int*)ccmalloc(sizeof(int) * truth->rnum);
int* cD = (int*)ccmalloc(sizeof(int) * words->rnum);
memset(cG, 0, sizeof(int) * truth->rnum);
memset(cD, 0, sizeof(int) * words->rnum);
double* mG = (double*)ccmalloc(sizeof(double) * truth->rnum * words->rnum);
double* mD = (double*)ccmalloc(sizeof(double) * truth->rnum * words->rnum);
memset(mG, 0, sizeof(double) * truth->rnum * words->rnum);
memset(mD, 0, sizeof(double) * truth->rnum * words->rnum);
for (j = 0; j < truth->rnum; j++)
{
ccv_rect_t* rect = (ccv_rect_t*)ccv_array_get(truth, j);
for (k = 0; k < words->rnum; k++)
{
ccv_rect_t* target = (ccv_rect_t*)ccv_array_get(words, k);
int match = ccv_max(ccv_min(target->x + target->width, rect->x + rect->width) - ccv_max(target->x, rect->x), 0) * ccv_max(ccv_min(target->y + target->height, rect->y + rect->height) - ccv_max(target->y, rect->y), 0);
if (match > 0)
{
mG[j * words->rnum + k] = (double)match / (double)(rect->width * rect->height);
mD[k * truth->rnum + j] = (double)match / (double)(target->width * target->height);
++cG[j];
++cD[k];
}
}
}
unsigned char* tG = (unsigned char*)ccmalloc(truth->rnum);
unsigned char* tD = (unsigned char*)ccmalloc(words->rnum);
memset(tG, 0, truth->rnum);
memset(tD, 0, words->rnum);
// one to one match
for (j = 0; j < truth->rnum; j++)
{
if (cG[j] != 1)
continue;
ccv_rect_t* rect = (ccv_rect_t*)ccv_array_get(truth, j);
for (k = 0; k < words->rnum; k++)
{
if (cD[k] != 1)
continue;
ccv_rect_t* target = (ccv_rect_t*)ccv_array_get(words, k);
if (mG[j * words->rnum + k] >= one_g && mD[k * truth->rnum + j] >= one_d)
{
double dx = (target->x + target->width * 0.5) - (rect->x + rect->width * 0.5);
double dy = (target->y + target->height * 0.5) - (rect->y + rect->height * 0.5);
double d = sqrt(dx * dx + dy * dy) * 2.0 / (sqrt(target->width * target->width + target->height * target->height) + sqrt(rect->width * rect->width + rect->height * rect->height));
if (d < center_diff_thr)
{
total_recall += 1.0;
total_precision += 1.0;
assert(tG[j] == 0);
assert(tD[k] == 0);
tG[j] = tD[k] = 1;
}
}
}
}
int* many = (int*)ccmalloc(sizeof(int) * ccv_max(words->rnum, truth->rnum));
// one to many match, starts with ground truth
for (j = 0; j < truth->rnum; j++)
{
if (tG[j] || cG[j] <= 1)
continue;
double one_sum = 0;
int no_many = 0;
for (k = 0; k < words->rnum; k++)
{
if (tD[k])
continue;
double many_single = mD[k * truth->rnum + j];
if (many_single >= one_d)
{
one_sum += mG[j * words->rnum + k];
many[no_many] = k;
++no_many;
}
}
if (no_many == 1)
{
// degrade to one to one match
if (mG[j * words->rnum + many[0]] >= one_g && mD[many[0] * truth->rnum + j] >= one_d)
{
total_recall += 1.0;
total_precision += 1.0;
tG[j] = tD[many[0]] = 1;
}
} else if (one_sum >= one_g) {
for (k = 0; k < no_many; k++)
tD[many[k]] = 1;
total_recall += om_one;
total_precision += om_one / (1 + log(no_many));
}
}
// one to many match, with estimate
for (k = 0; k < words->rnum; k++)
{
if (tD[k] || cD[k] <= 1)
continue;
double one_sum = 0;
int no_many = 0;
for (j = 0; j < truth->rnum; j++)
{
if (tG[j])
continue;
double many_single = mG[j * words->rnum + k];
if (many_single >= one_g)
{
one_sum += mD[k * truth->rnum + j];
many[no_many] = j;
++no_many;
}
}
if (no_many == 1)
{
// degrade to one to one match
if (mG[many[0] * words->rnum + k] >= one_g && mD[k * truth->rnum + many[0]] >= one_d)
{
total_recall += 1.0;
total_precision += 1.0;
tG[many[0]] = tD[k] = 1;
}
} else if (one_sum >= one_g) {
for (j = 0; j < no_many; j++)
tG[many[j]] = 1;
total_recall += om_one / (1 + log(no_many));
total_precision += om_one;
}
}
ccfree(many);
ccfree(tG);
ccfree(tD);
ccfree(cG);
ccfree(cD);
ccfree(mG);
ccfree(mD);
assert(total_precision < words->rnum + 0.1);
assert(total_recall < truth->rnum + 0.1);
if (precision)
*precision = total_precision;
if (recall)
*recall = total_recall;
}
int main(int argc, char** argv)
{
static struct option swt_options[] = {
/* help */
{"help", 0, 0, 0},
/* optional parameters */
{"size", 1, 0, 0},
{"low-thresh", 1, 0, 0},
{"high-thresh", 1, 0, 0},
{"max-height", 1, 0, 0},
{"min-height", 1, 0, 0},
{"min-area", 1, 0, 0},
{"aspect-ratio", 1, 0, 0},
{"std-ratio", 1, 0, 0},
{"thickness-ratio", 1, 0, 0},
{"height-ratio", 1, 0, 0},
{"intensity-thresh", 1, 0, 0},
{"letter-occlude-thresh", 1, 0, 0},
{"distance-ratio", 1, 0, 0},
{"intersect-ratio", 1, 0, 0},
{"letter-thresh", 1, 0, 0},
{"elongate-ratio", 1, 0, 0},
{"breakdown-ratio", 1, 0, 0},
{"breakdown", 1, 0, 0},
{"iterations", 1, 0, 0},
{"base-dir", 1, 0, 0},
{0, 0, 0, 0}
};
if (argc <= 1)
exit_with_help();
ccv_swt_param_t params = {
.interval = 1,
.same_word_thresh = { 0.2, 0.8 },
.min_neighbors = 1,
.scale_invariant = 0,
.size = 3,
.low_thresh = 78,
.high_thresh = 214,
.max_height = 300,
.min_height = 10,
.min_area = 75,
.letter_occlude_thresh = 2,
.aspect_ratio = 10,
.std_ratio = 0.5,
.thickness_ratio = 1.5,
.height_ratio = 2.0,
.intensity_thresh = 45,
.distance_ratio = 3.0,
.intersect_ratio = 2.0,
.letter_thresh = 3,
.elongate_ratio = 1.3,
.breakdown = 1,
.breakdown_ratio = 1.0,
};
ccv_swt_range_t size_range = {
.min_value = 1,
.max_value = 3,
.step = 2,
.enable = 1,
};
ccv_swt_range_t low_thresh_range = {
.min_value = 50,
.max_value = 150,
.step = 1,
.enable = 1,
};
ccv_swt_range_t high_thresh_range = {
.min_value = 200,
.max_value = 350,
.step = 1,
.enable = 1,
};
ccv_swt_range_t max_height_range = {
.min_value = 500,
.max_value = 500,
.step = 1,
.enable = 1,
};
ccv_swt_range_t min_height_range = {
.min_value = 5,
.max_value = 30,
.step = 1,
.enable = 1,
};
ccv_swt_range_t min_area_range = {
.min_value = 10,
.max_value = 100,
.step = 1,
.enable = 1,
};
ccv_swt_range_t letter_occlude_thresh_range = {
.min_value = 0,
.max_value = 5,
.step = 1,
.enable = 1,
};
ccv_swt_range_t aspect_ratio_range = {
.min_value = 5,
.max_value = 15,
.step = 1,
.enable = 1,
};
ccv_swt_range_t std_ratio_range = {
.min_value = 0.1,
.max_value = 1.0,
.step = 0.01,
.enable = 1,
};
ccv_swt_range_t thickness_ratio_range = {
.min_value = 1.0,
.max_value = 2.0,
.step = 0.1,
.enable = 1,
};
ccv_swt_range_t height_ratio_range = {
.min_value = 1.0,
.max_value = 3.0,
.step = 0.1,
.enable = 1,
};
ccv_swt_range_t intensity_thresh_range = {
.min_value = 1,
.max_value = 50,
.step = 1,
.enable = 1,
};
ccv_swt_range_t distance_ratio_range = {
.min_value = 1.0,
.max_value = 5.0,
.step = 0.1,
.enable = 1,
};
ccv_swt_range_t intersect_ratio_range = {
.min_value = 0.0,
.max_value = 5.0,
.step = 0.1,
.enable = 1,
};
ccv_swt_range_t letter_thresh_range = {
.min_value = 0,
.max_value = 5,
.step = 1,
.enable = 1,
};
ccv_swt_range_t elongate_ratio_range = {
.min_value = 0.1,
.max_value = 2.5,
.step = 0.1,
.enable = 1,
};
ccv_swt_range_t breakdown_ratio_range = {
.min_value = 0.5,
.max_value = 1.5,
.step = 0.01,
.enable = 1,
};
int i, j, k, iterations = 10;
while (getopt_long_only(argc - 1, argv + 1, "", swt_options, &k) != -1)
{
switch (k)
{
case 0:
exit_with_help();
case 1:
decode_range(optarg, &size_range);
break;
case 2:
decode_range(optarg, &low_thresh_range);
break;
case 3:
decode_range(optarg, &high_thresh_range);
break;
case 4:
decode_range(optarg, &max_height_range);
break;
case 5:
decode_range(optarg, &min_height_range);
break;
case 6:
decode_range(optarg, &min_area_range);
break;
case 7:
decode_range(optarg, &aspect_ratio_range);
break;
case 8:
decode_range(optarg, &std_ratio_range);
break;
case 9:
decode_range(optarg, &thickness_ratio_range);
break;
case 10:
decode_range(optarg, &height_ratio_range);
break;
case 11:
decode_range(optarg, &intensity_thresh_range);
break;
case 12:
decode_range(optarg, &letter_occlude_thresh_range);
break;
case 13:
decode_range(optarg, &distance_ratio_range);
break;
case 14:
decode_range(optarg, &intersect_ratio_range);
break;
case 15:
decode_range(optarg, &letter_thresh_range);
break;
case 16:
decode_range(optarg, &elongate_ratio_range);
break;
case 17:
decode_range(optarg, &breakdown_ratio_range);
break;
case 18:
params.breakdown = !!atoi(optarg);
break;
case 19:
iterations = atoi(optarg);
break;
case 20:
chdir(optarg);
break;
}
}
FILE* r = fopen(argv[1], "rt");
if (!r)
exit_with_help();
ccv_enable_cache(1024 * 1024 * 1024);
ccv_array_t* aof = ccv_array_new(sizeof(char*), 64, 0);
ccv_array_t* aow = ccv_array_new(sizeof(ccv_array_t*), 64, 0);
ccv_array_t* cw = 0;
char* file = (char*)malloc(1024);
size_t len = 1024;
ssize_t read;
while ((read = getline(&file, &len, r)) != -1)
{
while(read > 1 && isspace(file[read - 1]))
read--;
file[read] = 0;
double x, y, width, height;
int recognized = sscanf(file, "%lf %lf %lf %lf", &x, &y, &width, &height);
if (recognized == 4)
{
ccv_rect_t rect = {
.x = (int)(x + 0.5),
.y = (int)(y + 0.5),
.width = (int)(width + 0.5),
.height = (int)(height + 0.5)
};
ccv_array_push(cw, &rect);
} else {
char* name = (char*)malloc(ccv_min(1023, strlen(file)) + 1);
strncpy(name, file, ccv_min(1023, strlen(file)) + 1);
ccv_array_push(aof, &name);
cw = ccv_array_new(sizeof(ccv_rect_t), 1, 0);
ccv_array_push(aow, &cw);
}
}
free(file);
printf("loaded %d images for parameter search of:\n", aof->rnum);
if (size_range.enable)
printf(" - canny size from %d to %d, += %lg\n", (int)(size_range.min_value + 0.5), (int)(size_range.max_value + 0.5), size_range.step);
if (std_ratio_range.enable)
printf(" - std threshold ratio from %lg to %lg, += %lg\n", std_ratio_range.min_value, std_ratio_range.max_value, std_ratio_range.step);
if (max_height_range.enable)
printf(" - maximum height from %d to %d, += %lg\n", (int)(max_height_range.min_value + 0.5), (int)(max_height_range.max_value + 0.5), max_height_range.step);
if (min_height_range.enable)
printf(" - minimum height from %d to %d, += %lg\n", (int)(min_height_range.min_value + 0.5), (int)(min_height_range.max_value + 0.5), min_height_range.step);
if (min_area_range.enable)
printf(" - minimum area from %d to %d, += %lg\n", (int)(min_area_range.min_value + 0.5), (int)(min_area_range.max_value + 0.5), min_area_range.step);
if (letter_occlude_thresh_range.enable)
printf(" - letter occlude threshold from %d to %d, += %lg\n", (int)(letter_occlude_thresh_range.min_value + 0.5), (int)(letter_occlude_thresh_range.max_value + 0.5), letter_occlude_thresh_range.step);
if (aspect_ratio_range.enable)
printf(" - aspect ratio threshold from %lg to %lg, += %lg\n", aspect_ratio_range.min_value, aspect_ratio_range.max_value, aspect_ratio_range.step);
if (thickness_ratio_range.enable)
printf(" - thickness ratio threshold from %lg to %lg, += %lg\n", thickness_ratio_range.min_value, thickness_ratio_range.max_value, thickness_ratio_range.step);
if (height_ratio_range.enable)
printf(" - height ratio threshold from %lg to %lg, += %lg\n", height_ratio_range.min_value, height_ratio_range.max_value, height_ratio_range.step);
if (intensity_thresh_range.enable)
printf(" - intensity threshold from %d to %d, += %lg\n", (int)(intensity_thresh_range.min_value + 0.5), (int)(intensity_thresh_range.max_value + 0.5), intensity_thresh_range.step);
if (distance_ratio_range.enable)
printf(" - distance ratio threshold from %lg to %lg, += %lg\n", distance_ratio_range.min_value, distance_ratio_range.max_value, distance_ratio_range.step);
if (intersect_ratio_range.enable)
printf(" - intersect ratio threshold from %lg to %lg, += %lg\n", intersect_ratio_range.min_value, intersect_ratio_range.max_value, intersect_ratio_range.step);
if (letter_thresh_range.enable)
printf(" - minimum number of letters from %d to %d, += %lg\n", (int)(letter_thresh_range.min_value + 0.5), (int)(letter_thresh_range.max_value + 0.5), letter_thresh_range.step);
if (elongate_ratio_range.enable)
printf(" - elongate ratio threshold from %lg to %lg, += %lg\n", elongate_ratio_range.min_value, elongate_ratio_range.max_value, elongate_ratio_range.step);
if (breakdown_ratio_range.enable)
printf(" - breakdown ratio threshold from %lg to %lg, += %lg\n", breakdown_ratio_range.min_value, breakdown_ratio_range.max_value, breakdown_ratio_range.step);
if (low_thresh_range.enable)
printf(" - canny low threshold from %d to %d, += %lg\n", (int)(low_thresh_range.min_value + 0.5), (int)(low_thresh_range.max_value + 0.5), low_thresh_range.step);
if (high_thresh_range.enable)
printf(" - canny high threshold from %d to %d, += %lg\n", (int)(high_thresh_range.min_value + 0.5), (int)(high_thresh_range.max_value + 0.5), high_thresh_range.step);
double best_f = 0, best_precision = 0, best_recall = 0;
double a = 0.5;
double v;
ccv_swt_param_t best_params = params;
#define optimize(parameter, type, rounding) \
if (parameter##_range.enable) \
{ \
params = best_params; \
int total_iterations = 0; \
for (v = parameter##_range.min_value; v <= parameter##_range.max_value; v += parameter##_range.step) \
++total_iterations; \
double* precision = (double*)ccmalloc(sizeof(double) * total_iterations); \
double* recall = (double*)ccmalloc(sizeof(double) * total_iterations); \
double* total_words = (double*)ccmalloc(sizeof(double) * total_iterations); \
memset(precision, 0, sizeof(double) * total_iterations); \
memset(recall, 0, sizeof(double) * total_iterations); \
memset(total_words, 0, sizeof(double) * total_iterations); \
double total_truth = 0; \
for (j = 0; j < aof->rnum; j++) \
{ \
char* name = *(char**)ccv_array_get(aof, j); \
ccv_dense_matrix_t* image = 0; \
ccv_read(name, &image, CCV_IO_GRAY | CCV_IO_ANY_FILE); \
ccv_array_t* truth = *(ccv_array_t**)ccv_array_get(aow, j); \
total_truth += truth->rnum; \
for (v = parameter##_range.min_value, k = 0; v <= parameter##_range.max_value; v += parameter##_range.step, k++) \
{ \
params.parameter = (type)(v + rounding); \
ccv_array_t* words = ccv_swt_detect_words(image, params); \
double one_precision = 0, one_recall = 0; \
_ccv_evaluate_wolf(words, truth, params, &one_precision, &one_recall); \
assert(one_precision <= words->rnum + 0.1); \
precision[k] += one_precision; \
recall[k] += one_recall; \
total_words[k] += words->rnum; \
ccv_array_free(words); \
FLUSH("perform SWT on %s (%d / %d) for " #parameter " = (%lg <- [%lg, %lg])", name, j + 1, aof->rnum, v, parameter##_range.min_value, parameter##_range.max_value); \
} \
ccv_matrix_free(image); \
} \
for (v = parameter##_range.min_value, j = 0; v <= parameter##_range.max_value; v += parameter##_range.step, j++) \
{ \
params.parameter = (type)(v + rounding); \
double f, total_precision = precision[j], total_recall = recall[j]; \
total_precision /= total_words[j]; \
total_recall /= total_truth; \
f = 1.0 / (a / total_precision + (1.0 - a) / total_recall); \
if (f > best_f) \
{ \
best_params = params; \
best_f = f; \
best_precision = total_precision; \
best_recall = total_recall; \
} \
FLUSH("current harmonic mean : %.2lf%%, precision : %.2lf%%, recall : %.2lf%% ; best harmonic mean : %.2lf%%, precision : %.2lf%%, recall : %.2lf%% ; at " #parameter " = %lg (%lg <- [%lg, %lg])", f * 100, total_precision * 100, total_recall * 100, best_f * 100, best_precision * 100, best_recall * 100, (double)best_params.parameter, v, parameter##_range.min_value, parameter##_range.max_value); \
} \
printf("\n"); \
ccfree(precision); \
ccfree(recall); \
ccfree(total_words); \
}
for (i = 0; i < iterations; i++)
{
optimize(size, int, 0.5);
optimize(std_ratio, double, 0);
optimize(max_height, int, 0.5);
optimize(min_height, int, 0.5);
optimize(min_area, int, 0.5);
optimize(letter_occlude_thresh, int, 0.5);
optimize(aspect_ratio, double, 0);
optimize(thickness_ratio, double, 0);
optimize(height_ratio, double, 0);
optimize(intensity_thresh, int, 0.5);
optimize(distance_ratio, double, 0);
optimize(intersect_ratio, double, 0);
optimize(letter_thresh, int, 0.5);
optimize(elongate_ratio, double, 0);
optimize(breakdown_ratio, double, 0);
optimize(low_thresh, int, 0.5);
optimize(high_thresh, int, 0.5);
printf("At iteration %d(of %d) : best parameters for swt is:\n"
"\tsize = %d\n"
"\tlow_thresh = %d\n"
"\thigh_thresh = %d\n"
"\tmax_height = %d\n"
"\tmin_height = %d\n"
"\tmin_area = %d\n"
"\tletter_occlude_thresh = %d\n"
"\taspect_ratio = %lf\n"
"\tstd_ratio = %lf\n"
"\tthickness_ratio = %lf\n"
"\theight_ratio = %lf\n"
"\tintensity_thresh = %d\n"
"\tdistance_ratio = %lf\n"
"\tintersect_ratio = %lf\n"
"\tletter_thresh = %d\n"
"\telongate_ratio = %lf\n"
"\tbreakdown_ratio = %lf\n",
i + 1, iterations,
best_params.size,
best_params.low_thresh,
best_params.high_thresh,
best_params.max_height,
best_params.min_height,
best_params.min_area,
best_params.letter_occlude_thresh,
best_params.aspect_ratio,
best_params.std_ratio,
best_params.thickness_ratio,
best_params.height_ratio,
best_params.intensity_thresh,
best_params.distance_ratio,
best_params.intersect_ratio,
best_params.letter_thresh,
best_params.elongate_ratio,
best_params.breakdown_ratio);
}
#undef optimize
for (i = 0; i < aof->rnum; i++)
{
char* name = *(char**)ccv_array_get(aof, i);
free(name);
ccv_array_t* cw = *(ccv_array_t**)ccv_array_get(aow, i);
ccv_array_free(cw);
}
ccv_array_free(aof);
ccv_array_free(aow);
ccv_drain_cache();
return 0;
}
