void ccv_saturation(ccv_dense_matrix_t* a, ccv_dense_matrix_t** b, int type, double ds)
{
assert(CCV_GET_CHANNEL(a->type) == CCV_C3); // only works in RGB space
ccv_declare_derived_signature(sig, a->sig != 0, ccv_sign_with_format(64, "ccv_saturation(%la)", ds), a->sig, CCV_EOF_SIGN);
type = (type == 0) ? CCV_GET_DATA_TYPE(a->type) | CCV_GET_CHANNEL(a->type) : CCV_GET_DATA_TYPE(type) | CCV_GET_CHANNEL(a->type);
ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, a->rows, a->cols, CCV_ALL_DATA_TYPE | CCV_GET_CHANNEL(a->type), type, sig);
ccv_object_return_if_cached(, db);
int i, j;
unsigned char* aptr = a->data.u8;
unsigned char* bptr = db->data.u8;
#define for_block(_for_get, _for_set) \
for (i = 0; i < a->rows; i++) \
{ \
for (j = 0; j < a->cols; j++) \
{ \
double gs = _for_get(aptr, j * 3, 0) * 0.299 + _for_get(aptr, j * 3 + 1, 0) * 0.587 + _for_get(aptr, j * 3 + 2, 0) * 0.114; \
_for_set(bptr, j * 3, (_for_get(aptr, j * 3, 0) - gs) * ds + gs, 0); \
_for_set(bptr, j * 3 + 1, (_for_get(aptr, j * 3 + 1, 0) - gs) * ds + gs, 0); \
_for_set(bptr, j * 3 + 2, (_for_get(aptr, j * 3 + 2, 0) - gs) * ds + gs, 0); \
} \
aptr += a->step; \
bptr += db->step; \
}
ccv_matrix_getter(a->type, ccv_matrix_setter, db->type, for_block);
#undef for_block
}
void ccv_flatten(ccv_matrix_t* a, ccv_matrix_t** b, int type, int flag)
{
ccv_dense_matrix_t* da = ccv_get_dense_matrix(a);
ccv_declare_derived_signature(sig, da->sig != 0, ccv_sign_with_format(64, "ccv_flatten(%d)", flag), da->sig, CCV_EOF_SIGN);
int no_8u_type = (da->type & CCV_8U) ? CCV_32S : da->type;
type = (type == 0) ? CCV_GET_DATA_TYPE(no_8u_type) | CCV_C1 : CCV_GET_DATA_TYPE(type) | CCV_C1;
ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, da->rows, da->cols, CCV_ALL_DATA_TYPE | CCV_C1, type, sig);
ccv_object_return_if_cached(, db);
int i, j, k, ch = CCV_GET_CHANNEL(da->type);
unsigned char* aptr = da->data.u8;
unsigned char* bptr = db->data.u8;
#define for_block(_for_get, _for_type, _for_set) \
for (i = 0; i < da->rows; i++) \
{ \
for (j = 0; j < da->cols; j++) \
{ \
_for_type sum = 0; \
for (k = 0; k < ch; k++) \
sum += _for_get(aptr, j * ch + k, 0); \
_for_set(bptr, j, sum, 0); \
} \
aptr += da->step; \
bptr += db->step; \
}
ccv_matrix_getter(da->type, ccv_matrix_typeof_setter, db->type, for_block);
#undef for_block
}
void ccv_slice(ccv_matrix_t* a, ccv_matrix_t** b, int btype, int y, int x, int rows, int cols)
{
int type = *(int*)a;
if (type & CCV_MATRIX_DENSE)
{
ccv_dense_matrix_t* da = ccv_get_dense_matrix(a);
ccv_declare_derived_signature(sig, da->sig != 0, ccv_sign_with_format(128, "ccv_slice(%d,%d,%d,%d)", y, x, rows, cols), da->sig, CCV_EOF_SIGN);
btype = (btype == 0) ? CCV_GET_DATA_TYPE(da->type) | CCV_GET_CHANNEL(da->type) : CCV_GET_DATA_TYPE(btype) | CCV_GET_CHANNEL(da->type);
ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, rows, cols, CCV_ALL_DATA_TYPE | CCV_GET_CHANNEL(da->type), btype, sig);
ccv_object_return_if_cached(, db);
int i, j, ch = CCV_GET_CHANNEL(da->type);
int dx = 0, dy = 0;
if (!(y >= 0 && y + rows <= da->rows && x >= 0 && x + cols <= da->cols))
{
ccv_zero(db);
if (y < 0) { rows += y; dy = -y; y = 0; }
if (y + rows > da->rows) rows = da->rows - y;
if (x < 0) { cols += x; dx = -x; x = 0; }
if (x + cols > da->cols) cols = da->cols - x;
}
unsigned char* a_ptr = da->data.u8 + x * ch * CCV_GET_DATA_TYPE_SIZE(da->type) + y * da->step;
unsigned char* b_ptr = db->data.u8 + dx * ch * CCV_GET_DATA_TYPE_SIZE(db->type) + dy * db->step;
#define for_block(_for_set, _for_get) \
for (i = 0; i < rows; i++) \
{ \
for (j = 0; j < cols * ch; j++) \
{ \
_for_set(b_ptr, j, _for_get(a_ptr, j, 0), 0); \
} \
a_ptr += da->step; \
b_ptr += db->step; \
}
ccv_matrix_setter(db->type, ccv_matrix_getter, da->type, for_block);
#undef for_block
} else if (type & CCV_MATRIX_SPARSE) {
void ccv_resample(ccv_dense_matrix_t* a, ccv_dense_matrix_t** b, int btype, int rows, int cols, int type)
{
assert(rows > 0 && cols > 0);
ccv_declare_derived_signature(sig, a->sig != 0, ccv_sign_with_format(64, "ccv_resample(%d,%d,%d)", rows, cols, type), a->sig, CCV_EOF_SIGN);
btype = (btype == 0) ? CCV_GET_DATA_TYPE(a->type) | CCV_GET_CHANNEL(a->type) : CCV_GET_DATA_TYPE(btype) | CCV_GET_CHANNEL(a->type);
ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, rows, cols, CCV_ALL_DATA_TYPE | CCV_GET_CHANNEL(a->type), btype, sig);
ccv_object_return_if_cached(, db);
if (a->rows == db->rows && a->cols == db->cols)
{
if (CCV_GET_CHANNEL(a->type) == CCV_GET_CHANNEL(db->type) && CCV_GET_DATA_TYPE(db->type) == CCV_GET_DATA_TYPE(a->type))
memcpy(db->data.u8, a->data.u8, a->rows * a->step);
else {
ccv_shift(a, (ccv_matrix_t**)&db, 0, 0, 0);
}
return;
}
if ((type & CCV_INTER_AREA) && a->rows >= db->rows && a->cols >= db->cols)
{
/* using the fast alternative (fix point scale, 0x100 to avoid overflow) */
if (CCV_GET_DATA_TYPE(a->type) == CCV_8U && CCV_GET_DATA_TYPE(db->type) == CCV_8U && a->rows * a->cols / (db->rows * db->cols) < 0x100)
_ccv_resample_area_8u(a, db);
else
_ccv_resample_area(a, db);
} else if (type & CCV_INTER_CUBIC) {
if (CCV_GET_DATA_TYPE(db->type) == CCV_32F || CCV_GET_DATA_TYPE(db->type) == CCV_64F)
_ccv_resample_cubic_float_only(a, db);
else
_ccv_resample_cubic_integer_only(a, db);
} else if (type & CCV_INTER_LINEAR) {
assert(0 && "CCV_INTER_LINEAR is not implemented");
} else if (type & CCV_INTER_LINEAR) {
assert(0 && "CCV_INTER_LANCZOS is not implemented");
}
}
void ccv_gemm(ccv_matrix_t* a, ccv_matrix_t* b, double alpha, ccv_matrix_t* c, double beta, int transpose, ccv_matrix_t** d, int type)
{
ccv_dense_matrix_t* da = ccv_get_dense_matrix(a);
ccv_dense_matrix_t* db = ccv_get_dense_matrix(b);
ccv_dense_matrix_t* dc = (c == 0) ? 0 : ccv_get_dense_matrix(c);
assert(CCV_GET_DATA_TYPE(da->type) == CCV_GET_DATA_TYPE(db->type) && CCV_GET_CHANNEL(da->type) == 1 && CCV_GET_CHANNEL(db->type) == 1 && ((transpose & CCV_A_TRANSPOSE) ? da->rows : da->cols) == ((transpose & CCV_B_TRANSPOSE) ? db->cols : db->rows));
if (dc != 0)
assert(CCV_GET_DATA_TYPE(dc->type) == CCV_GET_DATA_TYPE(da->type) && CCV_GET_CHANNEL(dc->type) == 1 && ((transpose & CCV_A_TRANSPOSE) ? da->cols : da->rows) == dc->rows && ((transpose & CCV_B_TRANSPOSE) ? db->rows : db->cols) == dc->cols);
ccv_declare_derived_signature_case(sig, ccv_sign_with_format(20, "ccv_gemm(%d)", transpose), ccv_sign_if(dc == 0 && da->sig != 0 && db->sig != 0, da->sig, db->sig, CCV_EOF_SIGN), ccv_sign_if(dc != 0 && da->sig != 0 && db->sig != 0 && dc->sig != 0, da->sig, db->sig, dc->sig, CCV_EOF_SIGN));
type = CCV_GET_DATA_TYPE(da->type) | CCV_GET_CHANNEL(da->type);
ccv_dense_matrix_t* dd = *d = ccv_dense_matrix_renew(*d, (transpose & CCV_A_TRANSPOSE) ? da->cols : da->rows, (transpose & CCV_B_TRANSPOSE) ? db->rows : db->cols, type, type, sig);
ccv_object_return_if_cached(, dd);
if (dd != dc && dc != 0)
memcpy(dd->data.u8, dc->data.u8, dc->step * dc->rows);
else if (dc == 0) // clean up dd if dc is not provided
memset(dd->data.u8, 0, dd->step * dd->rows);
#if (defined HAVE_CBLAS || defined HAVE_ACCELERATE_FRAMEWORK)
switch (CCV_GET_DATA_TYPE(dd->type))
{
case CCV_32F:
cblas_sgemm(CblasRowMajor, (transpose & CCV_A_TRANSPOSE) ? CblasTrans : CblasNoTrans, (transpose & CCV_B_TRANSPOSE) ? CblasTrans : CblasNoTrans, dd->rows, dd->cols, (transpose & CCV_A_TRANSPOSE) ? da->rows : da->cols, alpha, da->data.f32, da->cols, db->data.f32, db->cols, beta, dd->data.f32, dd->cols);
break;
case CCV_64F:
cblas_dgemm(CblasRowMajor, (transpose & CCV_A_TRANSPOSE) ? CblasTrans : CblasNoTrans, (transpose & CCV_B_TRANSPOSE) ? CblasTrans : CblasNoTrans, dd->rows, dd->cols, (transpose & CCV_A_TRANSPOSE) ? da->rows : da->cols, alpha, da->data.f64, da->cols, db->data.f64, db->cols, beta, dd->data.f64, dd->cols);
break;
}
#else
assert(0 && "You need a BLAS compatible library for this function, e.g. libatlas.");
#endif
}
void ccv_resample(ccv_dense_matrix_t* a, ccv_dense_matrix_t** b, int btype, int rows, int cols, int type)
{
ccv_declare_matrix_signature(sig, a->sig != 0, ccv_sign_with_format(64, "ccv_resample(%d,%d,%d)", rows, cols, type), a->sig, 0);
btype = (btype == 0) ? CCV_GET_DATA_TYPE(a->type) | CCV_GET_CHANNEL(a->type) : CCV_GET_DATA_TYPE(btype) | CCV_GET_CHANNEL(a->type);
ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, rows, cols, CCV_ALL_DATA_TYPE | CCV_GET_CHANNEL(a->type), btype, sig);
ccv_matrix_return_if_cached(, db);
if (a->rows == db->rows && a->cols == db->cols)
{
if (CCV_GET_CHANNEL(a->type) == CCV_GET_CHANNEL(db->type) && CCV_GET_DATA_TYPE(db->type) == CCV_GET_DATA_TYPE(a->type))
memcpy(db->data.u8, a->data.u8, a->rows * a->step);
else {
ccv_shift(a, (ccv_matrix_t**)&db, 0, 0, 0);
}
return;
}
switch (type)
{
case CCV_INTER_AREA:
if (a->rows > db->rows && a->cols > db->cols)
{
/* using the fast alternative (fix point scale, 0x100 to avoid overflow) */
if (CCV_GET_DATA_TYPE(a->type) == CCV_8U && CCV_GET_DATA_TYPE(db->type) == CCV_8U && a->rows * a->cols / (db->rows * db->cols) < 0x100)
_ccv_resample_area_8u(a, db);
else
_ccv_resample_area(a, db);
break;
}
case CCV_INTER_LINEAR:
break;
case CCV_INTER_CUBIC:
break;
case CCV_INTER_LANCZOS:
break;
}
}
double ccv_normalize(ccv_matrix_t* a, ccv_matrix_t** b, int btype, int flag)
{
ccv_dense_matrix_t* da = ccv_get_dense_matrix(a);
assert(CCV_GET_CHANNEL(da->type) == CCV_C1);
ccv_declare_derived_signature(sig, da->sig != 0, ccv_sign_with_format(20, "ccv_normalize(%d)", flag), da->sig, CCV_EOF_SIGN);
btype = (btype == 0) ? CCV_GET_DATA_TYPE(da->type) | CCV_C1 : CCV_GET_DATA_TYPE(btype) | CCV_C1;
ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, da->rows, da->cols, CCV_ALL_DATA_TYPE | CCV_C1, btype, sig);
assert(db);
ccv_object_return_if_cached(db->tag.f64, db);
double sum = 0, inv;
int i, j;
unsigned char* a_ptr = da->data.u8;
unsigned char* b_ptr = db->data.u8;
switch (flag)
{
case CCV_L1_NORM:
#define for_block(_for_set, _for_get) \
for (i = 0; i < da->rows; i++) \
{ \
for (j = 0; j < da->cols; j++) \
sum += _for_get(a_ptr, j, 0); \
a_ptr += da->step; \
} \
inv = 1.0 / sum; \
a_ptr = da->data.u8; \
for (i = 0; i < da->rows; i++) \
{ \
for (j = 0; j < da->cols; j++) \
_for_set(b_ptr, j, _for_get(a_ptr, j, 0) * inv, 0); \
a_ptr += da->step; \
b_ptr += db->step; \
}
ccv_matrix_setter(db->type, ccv_matrix_getter, da->type, for_block);
#undef for_block
break;
case CCV_L2_NORM:
#define for_block(_for_set, _for_get) \
for (i = 0; i < da->rows; i++) \
{ \
for (j = 0; j < da->cols; j++) \
sum += _for_get(a_ptr, j, 0) * _for_get(a_ptr, j, 0); \
a_ptr += da->step; \
} \
sum = sqrt(sum); \
inv = 1.0 / sum; \
a_ptr = da->data.u8; \
for (i = 0; i < da->rows; i++) \
{ \
for (j = 0; j < da->cols; j++) \
_for_set(b_ptr, j, _for_get(a_ptr, j, 0) * inv, 0); \
a_ptr += da->step; \
b_ptr += db->step; \
}
ccv_matrix_setter(db->type, ccv_matrix_getter, da->type, for_block);
#undef for_block
break;
}
return db->tag.f64 = sum;
}
void ccv_sample_up(ccv_dense_matrix_t* a, ccv_dense_matrix_t** b, int type, int src_x, int src_y)
{
assert(src_x >= 0 && src_y >= 0);
ccv_declare_matrix_signature(sig, a->sig != 0, ccv_sign_with_format(64, "ccv_sample_up(%d,%d)", src_x, src_y), a->sig, 0);
type = (type == 0) ? CCV_GET_DATA_TYPE(a->type) | CCV_GET_CHANNEL(a->type) : CCV_GET_DATA_TYPE(type) | CCV_GET_CHANNEL(a->type);
ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, a->rows * 2, a->cols * 2, CCV_ALL_DATA_TYPE | CCV_GET_CHANNEL(a->type), type, sig);
ccv_matrix_return_if_cached(, db);
int ch = CCV_GET_CHANNEL(a->type);
int cols0 = a->cols - 1 - src_x;
int y, x, sy = -1 + src_y, sx = src_x * ch, k;
int* tab = (int*)alloca((a->cols + src_x + 2) * ch * sizeof(int));
for (x = 0; x < a->cols + src_x + 2; x++)
for (k = 0; k < ch; k++)
tab[x * ch + k] = ((x >= a->cols) ? a->cols * 2 - 1 - x : x) * ch + k;
unsigned char* buf = (unsigned char*)alloca(3 * db->cols * ch * ccv_max(CCV_GET_DATA_TYPE_SIZE(db->type), sizeof(int)));
int bufstep = db->cols * ch * ccv_max(CCV_GET_DATA_TYPE_SIZE(db->type), sizeof(int));
unsigned char* b_ptr = db->data.u8;
/* why src_y * 2: the same argument as in ccv_sample_down */
#define for_block(_for_get_a, _for_set, _for_get, _for_set_b) \
for (y = 0; y < a->rows; y++) \
{ \
for (; sy <= y + 1 + src_y; sy++) \
{ \
unsigned char* row = buf + ((sy + src_y * 2 + 1) % 3) * bufstep; \
int _sy = (sy < 0) ? -1 - sy : (sy >= a->rows) ? a->rows * 2 - 1 - sy : sy; \
unsigned char* a_ptr = a->data.u8 + a->step * _sy; \
if (a->cols == 1) \
{ \
for (k = 0; k < ch; k++) \
{ \
_for_set(row, k, _for_get_a(a_ptr, k, 0) * (G025 + G075 + G125), 0); \
_for_set(row, k + ch, _for_get_a(a_ptr, k, 0) * (G025 + G075 + G125), 0); \
} \
continue; \
} \
if (sx == 0) \
{ \
for (k = 0; k < ch; k++) \
{ \
_for_set(row, k, _for_get_a(a_ptr, k + sx, 0) * (G025 + G075) + _for_get_a(a_ptr, k + sx + ch, 0) * G125, 0); \
_for_set(row, k + ch, _for_get_a(a_ptr, k + sx, 0) * (G125 + G025) + _for_get_a(a_ptr, k + sx + ch, 0) * G075, 0); \
} \
} \
/* some serious flaw in computing Gaussian weighting in previous version
* specially, we are doing perfect upsampling (2x) so, it concerns a grid like:
* XXYY
* XXYY
* in this case, to upsampling, the weight should be from distance 0.25 and 1.25, and 0.25 and 0.75
* previously, it was mistakingly be 0.0 1.0, 0.5 0.5 (imperfect upsampling (2x - 1)) */ \
for (x = (sx == 0) ? ch : 0; x < cols0 * ch; x += ch) \
{ \
for (k = 0; k < ch; k++) \
{ \
_for_set(row, x * 2 + k, _for_get_a(a_ptr, x + sx - ch + k, 0) * G075 + _for_get_a(a_ptr, x + sx + k, 0) * G025 + _for_get_a(a_ptr, x + sx + ch + k, 0) * G125, 0); \
_for_set(row, x * 2 + ch + k, _for_get_a(a_ptr, x + sx - ch + k, 0) * G125 + _for_get_a(a_ptr, x + sx + k, 0) * G025 + _for_get_a(a_ptr, x + sx + ch + k, 0) * G075, 0); \
} \
} \
x_block(_for_get_a, _for_set, _for_get, _for_set_b); \
} \
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 ccv_sat(ccv_dense_matrix_t* a, ccv_dense_matrix_t** b, int type, int padding_pattern)
{
ccv_declare_derived_signature(sig, a->sig != 0, ccv_sign_with_format(20, "ccv_sat(%d)", padding_pattern), a->sig, CCV_EOF_SIGN);
int safe_type = (a->type & CCV_8U) ? ((a->rows * a->cols >= 0x808080) ? CCV_64S : CCV_32S) : ((a->type & CCV_32S) ? CCV_64S : a->type);
type = (type == 0) ? CCV_GET_DATA_TYPE(safe_type) | CCV_GET_CHANNEL(a->type) : CCV_GET_DATA_TYPE(type) | CCV_GET_CHANNEL(a->type);
int ch = CCV_GET_CHANNEL(a->type);
int i, j;
unsigned char* a_ptr = a->data.u8;
ccv_dense_matrix_t* db;
unsigned char* b_ptr;
switch (padding_pattern)
{
case CCV_NO_PADDING:
db = *b = ccv_dense_matrix_renew(*b, a->rows, a->cols, CCV_ALL_DATA_TYPE | CCV_GET_CHANNEL(a->type), type, sig);
ccv_object_return_if_cached(, db);
b_ptr = db->data.u8;
#define for_block(_for_set_b, _for_get_b, _for_get) \
for (j = 0; j < ch; j++) \
_for_set_b(b_ptr, j, _for_get(a_ptr, j, 0), 0); \
for (j = ch; j < a->cols * ch; j++) \
_for_set_b(b_ptr, j, _for_get_b(b_ptr, j - ch, 0) + _for_get(a_ptr, j, 0), 0); \
a_ptr += a->step; \
b_ptr += db->step; \
for (i = 1; i < a->rows; i++) \
{ \
for (j = 0; j < ch; j++) \
_for_set_b(b_ptr, j, _for_get_b(b_ptr - db->step, j, 0) + _for_get(a_ptr, j, 0), 0); \
for (j = ch; j < a->cols * ch; j++) \
_for_set_b(b_ptr, j, _for_get_b(b_ptr, j - ch, 0) - _for_get_b(b_ptr - db->step, j - ch, 0) + _for_get_b(b_ptr - db->step, j, 0) + _for_get(a_ptr, j, 0), 0); \
a_ptr += a->step; \
b_ptr += db->step; \
}
ccv_matrix_setter_getter(db->type, ccv_matrix_getter, a->type, for_block);
#undef for_block
break;
case CCV_PADDING_ZERO:
db = *b = ccv_dense_matrix_renew(*b, a->rows + 1, a->cols + 1, CCV_ALL_DATA_TYPE | CCV_GET_CHANNEL(a->type), type, sig);
ccv_object_return_if_cached(, db);
b_ptr = db->data.u8;
#define for_block(_for_set_b, _for_get_b, _for_get) \
for (j = 0; j < db->cols * ch; j++) \
_for_set_b(b_ptr, j, 0, 0); \
b_ptr += db->step; \
for (i = 0; i < a->rows; i++) \
{ \
for (j = 0; j < ch; j++) \
_for_set_b(b_ptr, j, 0, 0); \
for (j = ch; j < db->cols * ch; j++) \
_for_set_b(b_ptr, j, _for_get_b(b_ptr, j - ch, 0) - _for_get_b(b_ptr - db->step, j - ch, 0) + _for_get_b(b_ptr - db->step, j, 0) + _for_get(a_ptr, j - ch, 0), 0); \
a_ptr += a->step; \
b_ptr += db->step; \
}
ccv_matrix_setter_getter(db->type, ccv_matrix_getter, a->type, for_block);
#undef for_block
break;
}
}
void ccv_contrast(ccv_dense_matrix_t* a, ccv_dense_matrix_t** b, int type, double ds)
{
ccv_declare_derived_signature(sig, a->sig != 0, ccv_sign_with_format(64, "ccv_contrast(%la)", ds), a->sig, CCV_EOF_SIGN);
type = (type == 0) ? CCV_GET_DATA_TYPE(a->type) | CCV_GET_CHANNEL(a->type) : CCV_GET_DATA_TYPE(type) | CCV_GET_CHANNEL(a->type);
ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, a->rows, a->cols, CCV_ALL_DATA_TYPE | CCV_GET_CHANNEL(a->type), type, sig);
ccv_object_return_if_cached(, db);
int i, j, k, ch = CCV_GET_CHANNEL(a->type);
double* ms = (double*)malloc(sizeof(double) * ch);
memset(ms, 0, sizeof(double) * ch);
unsigned char* aptr = a->data.u8;
#define for_block(_, _for_get) \
for (i = 0; i < a->rows; i++) \
{ \
for (j = 0; j < a->cols; j++) \
for (k = 0; k < ch; k++) \
ms[k] += _for_get(aptr, j * ch + k, 0); \
aptr += a->step; \
}
ccv_matrix_getter(a->type, for_block);
#undef for_block
for (i = 0; i < ch; i++)
ms[i] = ms[i] / (a->rows * a->cols);
aptr = a->data.u8;
unsigned char* bptr = db->data.u8;
if (CCV_GET_DATA_TYPE(a->type) == CCV_8U && CCV_GET_DATA_TYPE(db->type) == CCV_8U) // specialize for 8U type
{
unsigned char* us = (unsigned char*)malloc(sizeof(unsigned char) * ch * 256);
for (i = 0; i < 256; i++)
for (j = 0; j < ch; j++)
us[i * ch + j] = ccv_clamp((i - ms[j]) * ds + ms[j], 0, 255);
for (i = 0; i < a->rows; i++)
{
for (j = 0; j < a->cols; j++)
for (k = 0; k < ch; k++)
bptr[j * ch + k] = us[(aptr[j * ch + k]) * ch + k];
aptr += a->step;
bptr += db->step;
}
free(us);
} else {
#define for_block(_for_get, _for_set) \
for (i = 0; i < a->rows; i++) \
{ \
for (j = 0; j < a->cols; j++) \
for (k = 0; k < ch; k++) \
_for_set(bptr, j * ch + k, (_for_get(aptr, j * ch + k, 0) - ms[k]) * ds + ms[k], 0); \
aptr += a->step; \
bptr += db->step; \
}
ccv_matrix_getter(a->type, ccv_matrix_setter, db->type, for_block);
#undef for_block
}
free(ms);
}
// this method is a merely baseline implementation and has no optimization effort ever put into it, if at all
void ccv_perspective_transform(ccv_dense_matrix_t* a, ccv_dense_matrix_t** b, int type, float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22)
{
ccv_declare_derived_signature(sig, a->sig != 0, ccv_sign_with_format(64, "ccv_perspective_transform(%a,%a,%a,%a,%a,%a,%a,%a,%a)", m00, m01, m02, m10, m11, m12, m20, m21, m22), a->sig, CCV_EOF_SIGN);
type = (type == 0) ? CCV_GET_DATA_TYPE(a->type) | CCV_GET_CHANNEL(a->type) : CCV_GET_DATA_TYPE(type) | CCV_GET_CHANNEL(a->type);
ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, a->rows, a->cols, CCV_ALL_DATA_TYPE | CCV_GET_CHANNEL(a->type), type, sig);
ccv_object_return_if_cached(, db);
// with default of bilinear interpolation
int i, j, k, ch = CCV_GET_CHANNEL(a->type);
unsigned char* a_ptr = a->data.u8;
unsigned char* b_ptr = db->data.u8;
// assume field of view is 60, modify the matrix value to reflect that
// (basically, apply x / ccv_max(a->rows, a->cols), y / ccv_max(a->rows, a->cols) before hand
m00 *= 1.0 / ccv_max(a->rows, a->cols);
m01 *= 1.0 / ccv_max(a->rows, a->cols);
m02 *= 1.0 / ccv_max(a->rows, a->cols);
m10 *= 1.0 / ccv_max(a->rows, a->cols);
m11 *= 1.0 / ccv_max(a->rows, a->cols);
m12 *= 1.0 / ccv_max(a->rows, a->cols);
m20 *= 1.0 / (ccv_max(a->rows, a->cols) * ccv_max(a->rows, a->cols));
m21 *= 1.0 / (ccv_max(a->rows, a->cols) * ccv_max(a->rows, a->cols));
m22 *= 1.0 / ccv_max(a->rows, a->cols);
#define for_block(_for_set, _for_get) \
for (i = 0; i < db->rows; i++) \
{ \
float cy = i - db->rows * 0.5; \
float crx = cy * m01 + m02; \
float cry = cy * m11 + m12; \
float crz = cy * m21 + m22; \
for (j = 0; j < db->cols; j++) \
{ \
float cx = j - db->cols * 0.5; \
float wz = 1.0 / (cx * m20 + crz); \
float wx = a->cols * 0.5 + (cx * m00 + crx) * wz; \
float wy = a->rows * 0.5 + (cx * m10 + cry) * wz; \
int iwx = (int)wx; \
int iwy = (int)wy; \
wx = wx - iwx; \
wy = wy - iwy; \
if (iwx >= 0 && iwx < a->cols - 1 && iwy >= 0 && iwy < a->rows - 1) \
for (k = 0; k < ch; k++) \
_for_set(b_ptr, j * ch + k, _for_get(a_ptr + iwy * a->step, iwx * ch + k, 0) * (1 - wx) * (1 - wy) + \
_for_get(a_ptr + iwy * a->step, iwx * ch + ch + k, 0) * wx * (1 - wy) + \
_for_get(a_ptr + iwy * a->step + a->step, iwx * ch + k, 0) * (1 - wx) * wy + \
_for_get(a_ptr + iwy * a->step + a->step, iwx * ch + ch + k, 0) * wx * wy, 0); \
else \
for (k = 0; k < ch; k++) \
_for_set(b_ptr, j * ch + k, 0, 0); \
} \
b_ptr += db->step; \
}
ccv_matrix_setter(db->type, ccv_matrix_getter, a->type, for_block);
#undef for_block
}
void ccv_color_transform(ccv_dense_matrix_t* a, ccv_dense_matrix_t** b, int type, int flag)
{
ccv_declare_derived_signature(sig, a->sig != 0, ccv_sign_with_format(64, "ccv_color_transform(%d)", flag), a->sig, CCV_EOF_SIGN);
assert(flag == CCV_RGB_TO_YUV);
switch (flag)
{
case CCV_RGB_TO_YUV:
assert(CCV_GET_CHANNEL(a->type) == CCV_C3);
type = (type == 0) ? CCV_GET_DATA_TYPE(a->type) | CCV_C3 : CCV_GET_DATA_TYPE(type) | CCV_C3;
break;
}
ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, a->rows, a->cols, CCV_ALL_DATA_TYPE | CCV_C3, type, sig);
ccv_object_return_if_cached(, db);
switch (flag)
{
case CCV_RGB_TO_YUV:
_ccv_rgb_to_yuv(a, db);
break;
}
}
void ccv_shift(ccv_matrix_t* a, ccv_matrix_t** b, int type, int lr, int rr)
{
ccv_dense_matrix_t* da = ccv_get_dense_matrix(a);
ccv_declare_derived_signature(sig, da->sig != 0, ccv_sign_with_format(64, "ccv_shift(%d,%d)", lr, rr), da->sig, CCV_EOF_SIGN);
type = (type == 0) ? CCV_GET_DATA_TYPE(da->type) | CCV_GET_CHANNEL(da->type) : CCV_GET_DATA_TYPE(type) | CCV_GET_CHANNEL(da->type);
ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, da->rows, da->cols, CCV_ALL_DATA_TYPE | CCV_GET_CHANNEL(da->type), type, sig);
ccv_object_return_if_cached(, db);
int i, j, ch = CCV_GET_CHANNEL(da->type);
unsigned char* aptr = da->data.u8;
unsigned char* bptr = db->data.u8;
#define for_block(_for_get, _for_set) \
for (i = 0; i < da->rows; i++) \
{ \
for (j = 0; j < da->cols * ch; j++) \
{ \
_for_set(bptr, j, _for_get(aptr, j, lr), rr); \
} \
aptr += da->step; \
bptr += db->step; \
}
ccv_matrix_getter(da->type, ccv_matrix_setter, db->type, for_block);
#undef for_block
}
/* sobel filter is fundamental to many other high-level algorithms,
* here includes 2 special case impl (for 1x3/3x1, 3x3) and one general impl */
void ccv_sobel(ccv_dense_matrix_t* a, ccv_dense_matrix_t** b, int type, int dx, int dy)
{
ccv_declare_derived_signature(sig, a->sig != 0, ccv_sign_with_format(64, "ccv_sobel(%d,%d)", dx, dy), a->sig, CCV_EOF_SIGN);
type = (type == 0) ? CCV_32S | CCV_GET_CHANNEL(a->type) : CCV_GET_DATA_TYPE(type) | CCV_GET_CHANNEL(a->type);
ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, a->rows, a->cols, CCV_GET_CHANNEL(a->type) | CCV_ALL_DATA_TYPE, type, sig);
ccv_object_return_if_cached(, db);
int i, j, k, c, ch = CCV_GET_CHANNEL(a->type);
unsigned char* a_ptr = a->data.u8;
unsigned char* b_ptr = db->data.u8;
if (dx == 1 || dy == 1)
{
/* special case 1: 1x3 or 3x1 window */
if (dx > dy)
{
#define for_block(_for_get, _for_set) \
for (i = 0; i < a->rows; i++) \
{ \
for (k = 0; k < ch; k++) \
_for_set(b_ptr, k, _for_get(a_ptr, ch + k, 0) - _for_get(a_ptr, k, 0), 0); \
for (j = 1; j < a->cols - 1; j++) \
for (k = 0; k < ch; k++) \
_for_set(b_ptr, j * ch + k, 2 * (_for_get(a_ptr, (j + 1) * ch + k, 0) - _for_get(a_ptr, (j - 1) * ch + k, 0)), 0); \
for (k = 0; k < ch; k++) \
_for_set(b_ptr, (a->cols - 1) * ch + k, _for_get(a_ptr, (a->cols - 1) * ch + k, 0) - _for_get(a_ptr, (a->cols - 2) * ch + k, 0), 0); \
b_ptr += db->step; \
a_ptr += a->step; \
}
ccv_matrix_getter(a->type, ccv_matrix_setter, db->type, for_block);
#undef for_block
} else {
#define for_block(_for_get, _for_set) \
for (j = 0; j < a->cols; j++) \
for (k = 0; k < ch; k++) \
_for_set(b_ptr, j * ch + k, _for_get(a_ptr + a->step, j * ch + k, 0) - _for_get(a_ptr, j * ch + k, 0), 0); \
a_ptr += a->step; \
b_ptr += db->step; \
for (i = 1; i < a->rows - 1; i++) \
{ \
for (j = 0; j < a->cols; j++) \
for (k = 0; k < ch; k++) \
_for_set(b_ptr, j * ch + k, 2 * (_for_get(a_ptr + a->step, j * ch + k, 0) - _for_get(a_ptr - a->step, j * ch + k, 0)), 0); \
a_ptr += a->step; \
b_ptr += db->step; \
} \
for (j = 0; j < a->cols; j++) \
for (k = 0; k < ch; k++) \
_for_set(b_ptr, j * ch + k, _for_get(a_ptr, j * ch + k, 0) - _for_get(a_ptr - a->step, j * ch + k, 0), 0);
ccv_matrix_getter(a->type, ccv_matrix_setter, db->type, for_block);
#undef for_block
}
} else if (dx > 3 || dy > 3) {
/* general case: in this case, I will generate a separable filter, and do the convolution */
int fsz = ccv_max(dx, dy);
assert(fsz % 2 == 1);
int hfz = fsz / 2;
unsigned char* df = (unsigned char*)alloca(sizeof(double) * fsz);
unsigned char* gf = (unsigned char*)alloca(sizeof(double) * fsz);
/* the sigma calculation is linear derviation of 3x3 - 0.85, 5x5 - 1.32 */
double sigma = ((fsz - 1) / 2) * 0.47 + 0.38;
double sigma2 = (2.0 * sigma * sigma);
/* 2.5 is the factor to make the kernel "visible" in integer setting */
double psigma3 = 2.5 / sqrt(sqrt(2 * CCV_PI) * sigma * sigma * sigma);
for (i = 0; i < fsz; i++)
{
((double*)df)[i] = (i - hfz) * exp(-((i - hfz) * (i - hfz)) / sigma2) * psigma3;
((double*)gf)[i] = exp(-((i - hfz) * (i - hfz)) / sigma2) * psigma3;
}
if (db->type & CCV_32S)
{
for (i = 0; i < fsz; i++)
{
// df could be negative, thus, (int)(x + 0.5) shortcut will not work
((int*)df)[i] = (int)round(((double*)df)[i] * 256.0);
((int*)gf)[i] = (int)(((double*)gf)[i] * 256.0 + 0.5);
}
} else {
for (i = 0; i < fsz; i++)
{
ccv_set_value(db->type, df, i, ((double*)df)[i], 0);
ccv_set_value(db->type, gf, i, ((double*)gf)[i], 0);
}
}
if (dx < dy)
{
unsigned char* tf = df;
df = gf;
gf = tf;
}
unsigned char* buf = (unsigned char*)alloca(sizeof(double) * ch * (fsz + ccv_max(a->rows, a->cols)));
#define for_block(_for_get, _for_type_b, _for_set_b, _for_get_b) \
for (i = 0; i < a->rows; i++) \
{ \
for (j = 0; j < hfz; j++) \
for (k = 0; k < ch; k++) \
_for_set_b(buf, j * ch + k, _for_get(a_ptr, k, 0), 0); \
for (j = 0; j < a->cols; j++) \
for (k = 0; k < ch; k++) \
_for_set_b(buf, (j + hfz) * ch + k, _for_get(a_ptr, j * ch + k, 0), 0); \
for (j = a->cols; j < a->cols + hfz; j++) \
for (k = 0; k < ch; k++) \
_for_set_b(buf, (j + hfz) * ch + k, _for_get(a_ptr, (a->cols - 1) * ch + k, 0), 0); \
for (j = 0; j < a->cols; j++) \
{ \
for (c = 0; c < ch; c++) \
{ \
_for_type_b sum = 0; \
for (k = 0; k < fsz; k++) \
sum += _for_get_b(buf, (j + k) * ch + c, 0) * _for_get_b(df, k, 0); \
_for_set_b(b_ptr, j * ch + c, sum, 8); \
} \
} \
a_ptr += a->step; \
b_ptr += db->step; \
} \
b_ptr = db->data.u8; \
for (i = 0; i < a->cols; i++) \
{ \
for (j = 0; j < hfz; j++) \
for (k = 0; k < ch; k++) \
_for_set_b(buf, j * ch + k, _for_get_b(b_ptr, i * ch + k, 0), 0); \
for (j = 0; j < a->rows; j++) \
for (k = 0; k < ch; k++) \
_for_set_b(buf, (j + hfz) * ch + k, _for_get_b(b_ptr + j * db->step, i * ch + k, 0), 0); \
for (j = a->rows; j < a->rows + hfz; j++) \
for (k = 0; k < ch; k++) \
_for_set_b(buf, (j + hfz) * ch + k, _for_get_b(b_ptr + (a->rows - 1) * db->step, i * ch + k, 0), 0); \
for (j = 0; j < a->rows; j++) \
{ \
for (c = 0; c < ch; c++) \
{ \
_for_type_b sum = 0; \
for (k = 0; k < fsz; k++) \
sum += _for_get_b(buf, (j + k) * ch + c, 0) * _for_get_b(gf, k, 0); \
_for_set_b(b_ptr + j * db->step, i * ch + c, sum, 8); \
} \
} \
}
ccv_matrix_getter(a->type, ccv_matrix_typeof_setter_getter, db->type, for_block);
#undef for_block
} else {
/* special case 2: 3x3 window, corresponding sigma = 0.85 */
unsigned char* buf = (unsigned char*)alloca(db->step);
if (dx > dy)
{
#define for_block(_for_get, _for_set_b, _for_get_b) \
for (j = 0; j < a->cols; j++) \
for (k = 0; k < ch; k++) \
_for_set_b(b_ptr, j * ch + k, _for_get(a_ptr + a->step, j * ch + k, 0) + 3 * _for_get(a_ptr, j * ch + k, 0), 0); \
a_ptr += a->step; \
b_ptr += db->step; \
for (i = 1; i < a->rows - 1; i++) \
{ \
for (j = 0; j < a->cols; j++) \
for (k = 0; k < ch; k++) \
_for_set_b(b_ptr, j * ch + k, _for_get(a_ptr + a->step, j * ch + k, 0) + 2 * _for_get(a_ptr, j * ch + k, 0) + _for_get(a_ptr - a->step, j * ch + k, 0), 0); \
a_ptr += a->step; \
b_ptr += db->step; \
} \
for (j = 0; j < a->cols; j++) \
for (k = 0; k < ch; k++) \
_for_set_b(b_ptr, j * ch + k, 3 * _for_get(a_ptr, j * ch + k, 0) + _for_get(a_ptr - a->step, j * ch + k, 0), 0); \
b_ptr = db->data.u8; \
for (i = 0; i < a->rows; i++) \
{ \
for (k = 0; k < ch; k++) \
_for_set_b(buf, k, _for_get_b(b_ptr, ch + k, 0) - _for_get_b(b_ptr, k, 0), 0); \
for (j = 1; j < a->cols - 1; j++) \
for (k = 0; k < ch; k++) \
_for_set_b(buf, j * ch + k, _for_get_b(b_ptr, (j + 1) * ch + k, 0) - _for_get_b(b_ptr, (j - 1) * ch + k, 0), 0); \
for (k = 0; k < ch; k++) \
_for_set_b(buf, (a->cols - 1) * ch + k, _for_get_b(b_ptr, (a->cols - 1) * ch + k, 0) - _for_get_b(b_ptr, (a->cols - 2) * ch + k, 0), 0); \
memcpy(b_ptr, buf, db->step); \
b_ptr += db->step; \
}
ccv_matrix_getter(a->type, ccv_matrix_setter_getter, db->type, for_block);
#undef for_block
} else {
#define for_block(_for_get, _for_set_b, _for_get_b) \
for (j = 0; j < a->cols; j++) \
for (k = 0; k < ch; k++) \
_for_set_b(b_ptr, j * ch + k, _for_get(a_ptr + a->step, j * ch + k, 0) - _for_get(a_ptr, j * ch + k, 0), 0); \
a_ptr += a->step; \
b_ptr += db->step; \
for (i = 1; i < a->rows - 1; i++) \
{ \
for (j = 0; j < a->cols; j++) \
for (k = 0; k < ch; k++) \
_for_set_b(b_ptr, j * ch + k, _for_get(a_ptr + a->step, j * ch + k, 0) - _for_get(a_ptr - a->step, j * ch + k, 0), 0); \
a_ptr += a->step; \
b_ptr += db->step; \
} \
for (j = 0; j < a->cols; j++) \
for (k = 0; k < ch; k++) \
_for_set_b(b_ptr, j * ch + k, _for_get(a_ptr, j * ch + k, 0) - _for_get(a_ptr - a->step, j * ch + k, 0), 0); \
b_ptr = db->data.u8; \
for (i = 0; i < a->rows; i++) \
{ \
for (k = 0; k < ch; k++) \
_for_set_b(buf, k, _for_get_b(b_ptr, ch + k, 0) + 3 * _for_get_b(b_ptr, k, 0), 0); \
for (j = 1; j < a->cols - 1; j++) \
for (k = 0; k < ch; k++) \
_for_set_b(buf, j * ch + k, _for_get_b(b_ptr, (j + 1) * ch + k, 0) + 2 * _for_get_b(b_ptr, j * ch + k, 0) + _for_get_b(b_ptr, (j - 1) * ch + k, 0), 0); \
for (k = 0; k < ch; k++) \
_for_set_b(buf, (a->cols - 1) * ch + k, _for_get_b(b_ptr, (a->cols - 2) * ch + k, 0) + 3 * _for_get_b(b_ptr, (a->cols - 1) * ch + k, 0), 0); \
memcpy(b_ptr, buf, db->step); \
b_ptr += db->step; \
}
ccv_matrix_getter(a->type, ccv_matrix_setter_getter, db->type, for_block);
#undef for_block
}
}
}
/* 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 */
}
}
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);
}
/* the following code is adopted from OpenCV cvPyrDown */
void ccv_sample_down(ccv_dense_matrix_t* a, ccv_dense_matrix_t** b, int type, int src_x, int src_y)
{
assert(src_x >= 0 && src_y >= 0);
ccv_declare_derived_signature(sig, a->sig != 0, ccv_sign_with_format(64, "ccv_sample_down(%d,%d)", src_x, src_y), a->sig, CCV_EOF_SIGN);
type = (type == 0) ? CCV_GET_DATA_TYPE(a->type) | CCV_GET_CHANNEL(a->type) : CCV_GET_DATA_TYPE(type) | CCV_GET_CHANNEL(a->type);
ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, a->rows / 2, a->cols / 2, CCV_ALL_DATA_TYPE | CCV_GET_CHANNEL(a->type), type, sig);
ccv_object_return_if_cached(, db);
int ch = CCV_GET_CHANNEL(a->type);
int cols0 = db->cols - 1 - src_x;
int dy, sy = -2 + src_y, sx = src_x * ch, dx, k;
int* tab = (int*)alloca((a->cols + src_x + 2) * ch * sizeof(int));
for (dx = 0; dx < a->cols + src_x + 2; dx++)
for (k = 0; k < ch; k++)
tab[dx * ch + k] = ((dx >= a->cols) ? a->cols * 2 - 1 - dx : dx) * ch + k;
unsigned char* buf = (unsigned char*)alloca(5 * db->cols * ch * ccv_max(CCV_GET_DATA_TYPE_SIZE(db->type), sizeof(int)));
int bufstep = db->cols * ch * ccv_max(CCV_GET_DATA_TYPE_SIZE(db->type), sizeof(int));
#ifdef __clang_analyzer__
memset(buf, 0, 5 * bufstep);
#endif
unsigned char* b_ptr = db->data.u8;
/* why is src_y * 4 in computing the offset of row?
* Essentially, it means sy - src_y but in a manner that doesn't result negative number.
* notice that we added src_y before when computing sy in the first place, however,
* it is not desirable to have that offset when we try to wrap it into our 5-row buffer (
* because in later rearrangement, we have no src_y to backup the arrangement). In
* such micro scope, we managed to stripe 5 addition into one shift and addition. */
#define for_block(_for_get_a, _for_set, _for_get, _for_set_b) \
for (dy = 0; dy < db->rows; dy++) \
{ \
for(; sy <= dy * 2 + 2 + src_y; sy++) \
{ \
unsigned char* row = buf + ((sy + src_y * 4 + 2) % 5) * bufstep; \
int _sy = (sy < 0) ? -1 - sy : (sy >= a->rows) ? a->rows * 2 - 1 - sy : sy; \
unsigned char* a_ptr = a->data.u8 + a->step * _sy; \
for (k = 0; k < ch; k++) \
_for_set(row, k, _for_get_a(a_ptr, sx + k, 0) * 10 + _for_get_a(a_ptr, ch + sx + k, 0) * 5 + _for_get_a(a_ptr, 2 * ch + sx + k, 0), 0); \
for(dx = ch; dx < cols0 * ch; dx += ch) \
for (k = 0; k < ch; k++) \
_for_set(row, dx + k, _for_get_a(a_ptr, dx * 2 + sx + k, 0) * 6 + (_for_get_a(a_ptr, dx * 2 + sx + k - ch, 0) + _for_get_a(a_ptr, dx * 2 + sx + k + ch, 0)) * 4 + _for_get_a(a_ptr, dx * 2 + sx + k - ch * 2, 0) + _for_get_a(a_ptr, dx * 2 + sx + k + ch * 2, 0), 0); \
x_block(_for_get_a, _for_set, _for_get, _for_set_b); \
} \
unsigned char* rows[5]; \
for(k = 0; k < 5; k++) \
rows[k] = buf + ((dy * 2 + k) % 5) * bufstep; \
for(dx = 0; dx < db->cols * ch; dx++) \
_for_set_b(b_ptr, dx, (_for_get(rows[2], dx, 0) * 6 + (_for_get(rows[1], dx, 0) + _for_get(rows[3], dx, 0)) * 4 + _for_get(rows[0], dx, 0) + _for_get(rows[4], dx, 0)) / 256, 0); \
b_ptr += db->step; \
}
int no_8u_type = (a->type & CCV_8U) ? CCV_32S : a->type;
if (src_x > 0)
{
#define x_block(_for_get_a, _for_set, _for_get, _for_set_b) \
for (dx = cols0 * ch; dx < db->cols * ch; dx += ch) \
for (k = 0; k < ch; k++) \
_for_set(row, dx + k, _for_get_a(a_ptr, tab[dx * 2 + sx + k], 0) * 6 + (_for_get_a(a_ptr, tab[dx * 2 + sx + k - ch], 0) + _for_get_a(a_ptr, tab[dx * 2 + sx + k + ch], 0)) * 4 + _for_get_a(a_ptr, tab[dx * 2 + sx + k - ch * 2], 0) + _for_get_a(a_ptr, tab[dx * 2 + sx + k + ch * 2], 0), 0);
ccv_matrix_getter_a(a->type, ccv_matrix_setter_getter, no_8u_type, ccv_matrix_setter_b, db->type, for_block);
#undef x_block
} else {
#define x_block(_for_get_a, _for_set, _for_get, _for_set_b) \
for (k = 0; k < ch; k++) \
_for_set(row, (db->cols - 1) * ch + k, _for_get_a(a_ptr, a->cols * ch + sx - ch + k, 0) * 10 + _for_get_a(a_ptr, (a->cols - 2) * ch + sx + k, 0) * 5 + _for_get_a(a_ptr, (a->cols - 3) * ch + sx + k, 0), 0);
ccv_matrix_getter_a(a->type, ccv_matrix_setter_getter, no_8u_type, ccv_matrix_setter_b, db->type, for_block);
#undef x_block
}
#undef for_block
}
/* 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);
}
void ccv_decimal_slice(ccv_dense_matrix_t* a, ccv_dense_matrix_t** b, int type, float y, float x, int rows, int cols)
{
ccv_declare_derived_signature(sig, a->sig != 0, ccv_sign_with_format(64, "ccv_decimal_slice(%a,%a,%d,%d)", y, x, rows, cols), a->sig, CCV_EOF_SIGN);
type = (type == 0) ? CCV_GET_DATA_TYPE(a->type) | CCV_GET_CHANNEL(a->type) : CCV_GET_DATA_TYPE(type) | CCV_GET_CHANNEL(a->type);
ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, rows, cols, CCV_ALL_DATA_TYPE | CCV_GET_CHANNEL(a->type), type, sig);
ccv_object_return_if_cached(, db);
int i, j, ch = CCV_GET_CHANNEL(a->type);
int ix = (int)x, iy = (int)y;
float xd = x - ix, yd = y - iy;
float w00 = (1 - xd) * (1 - yd);
float w01 = xd * (1 - yd);
float w10 = (1 - xd) * yd;
float w11 = xd * yd;
int dx = 0, dy = 0;
int rows_1 = 0, cols_1 = 0;
// it is going to be hard to deal with border efficiently, since this is used for tld, will ignore border for now
if (!(iy >= 0 && iy + rows < a->rows && ix >= 0 && ix + cols < a->cols))
{
ccv_zero(db);
if (iy < 0) { rows += iy; dy = -iy; iy = 0; }
if (iy + rows >= a->rows)
{
rows = a->rows - iy - 1;
if (iy + rows > a->rows)
rows_1 = 1; // we need to do our best to padding the last row
}
if (ix < 0) { cols += ix; dx = -ix; ix = 0; }
if (x + cols >= a->cols)
{
cols = a->cols - ix - 1;
if (x + cols > a->cols)
cols_1 = 1; // we need to do our best to padding the last col
}
}
unsigned char* a_ptr = (unsigned char*)ccv_get_dense_matrix_cell(a, iy, ix, 0);
unsigned char* b_ptr = (unsigned char*)ccv_get_dense_matrix_cell(db, dy, dx, 0);
#define for_block(_for_set, _for_get) \
for (i = 0; i < rows; i++) \
{ \
for (j = 0; j < cols * ch; j++) \
{ \
_for_set(b_ptr, j, (_for_get(a_ptr, j, 0) * G00 + _for_get(a_ptr, j + ch, 0) * G01 + _for_get(a_ptr + a->step, j, 0) * G10 + _for_get(a_ptr + a->step, j + ch, 0) * G11) / GALL, 0); \
} \
if (cols_1) \
_for_set(b_ptr, j, (_for_get(a_ptr, j, 0) * (G00 + G01) + _for_get(a_ptr + a->step, j, 0) * G10 + _for_get(a_ptr + a->step, j + ch, 0) * G11) / GALL, 0); \
a_ptr += a->step; \
b_ptr += db->step; \
} \
if (rows_1) \
{ \
for (j = 0; j < cols * ch; j++) \
{ \
_for_set(b_ptr, j, (_for_get(a_ptr, j, 0) * (G00 + G10) + _for_get(a_ptr, j + ch, 0) * (G01 + G11)) / GALL, 0); \
} \
if (cols_1) \
_for_set(b_ptr, j, _for_get(a_ptr, j, 0), 0); \
}
/* unswitch in the manual way so that we can use integer interpolation */
if ((a->type & CCV_8U) || (a->type & CCV_32S) || (a->type & CCV_64S))
{
const int W_BITS14 = 14;
int iw00 = (int)(w00 * (1 << W_BITS14) + 0.5);
int iw01 = (int)(w01 * (1 << W_BITS14) + 0.5);
int iw10 = (int)(w10 * (1 << W_BITS14) + 0.5);
int iw11 = (1 << W_BITS14) - iw00 - iw01 - iw10;
#define G00 (iw00)
#define G01 (iw01)
#define G10 (iw10)
#define G11 (iw11)
#define GCOM (1 << (W_BITS14 - 1))
#define GALL (1 << (W_BITS14))
ccv_matrix_setter(db->type, ccv_matrix_getter_integer_only, a->type, for_block);
#undef G00
#undef G01
#undef G10
#undef G11
#undef GCOM
#undef GALL
} else {
#define G00 (w00)
#define G01 (w01)
#define G10 (w10)
#define G11 (w11)
#define GCOM (0)
#define GALL (1)
ccv_matrix_setter(db->type, ccv_matrix_getter_float_only, a->type, for_block);
#undef G00
#undef G01
#undef G10
#undef G11
#undef GCOM
#undef GALL
}
#undef for_block
}
void ccv_blur(ccv_dense_matrix_t* a, ccv_dense_matrix_t** b, int type, double sigma)
{
ccv_declare_derived_signature(sig, a->sig != 0, ccv_sign_with_format(64, "ccv_blur(%la)", sigma), a->sig, CCV_EOF_SIGN);
type = (type == 0) ? CCV_GET_DATA_TYPE(a->type) | CCV_GET_CHANNEL(a->type) : CCV_GET_DATA_TYPE(type) | CCV_GET_CHANNEL(a->type);
ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, a->rows, a->cols, CCV_ALL_DATA_TYPE | CCV_GET_CHANNEL(a->type), type, sig);
ccv_object_return_if_cached(, db);
int fsz = ccv_max(1, (int)(4.0 * sigma + 1.0 - 1e-8)) * 2 + 1;
int hfz = fsz / 2;
unsigned char* buf = (unsigned char*)alloca(sizeof(double) * ccv_max(fsz + a->rows, (fsz + a->cols) * CCV_GET_CHANNEL(a->type)));
unsigned char* filter = (unsigned char*)alloca(sizeof(double) * fsz);
double tw = 0;
int i, j, k, ch = CCV_GET_CHANNEL(a->type);
for (i = 0; i < fsz; i++)
tw += ((double*)filter)[i] = exp(-((i - hfz) * (i - hfz)) / (2.0 * sigma * sigma));
int no_8u_type = (db->type & CCV_8U) ? CCV_32S : db->type;
if (no_8u_type & CCV_32S)
{
tw = 256.0 / tw;
for (i = 0; i < fsz; i++)
((int*)filter)[i] = (int)(((double*)filter)[i] * tw + 0.5);
} else {
tw = 1.0 / tw;
for (i = 0; i < fsz; i++)
ccv_set_value(db->type, filter, i, ((double*)filter)[i] * tw, 0);
}
/* horizontal */
unsigned char* a_ptr = a->data.u8;
unsigned char* b_ptr = db->data.u8;
#define for_block(_for_type, _for_set_b, _for_get_b, _for_set_a, _for_get_a) \
for (i = 0; i < a->rows; i++) \
{ \
for (j = 0; j < hfz; j++) \
for (k = 0; k < ch; k++) \
_for_set_b(buf, j * ch + k, _for_get_a(a_ptr, k, 0), 0); \
for (j = 0; j < a->cols * ch; j++) \
_for_set_b(buf, j + hfz * ch, _for_get_a(a_ptr, j, 0), 0); \
for (j = a->cols; j < hfz + a->cols; j++) \
for (k = 0; k < ch; k++) \
_for_set_b(buf, j * ch + hfz * ch + k, _for_get_a(a_ptr, (a->cols - 1) * ch + k, 0), 0); \
for (j = 0; j < a->cols * ch; j++) \
{ \
_for_type sum = 0; \
for (k = 0; k < fsz; k++) \
sum += _for_get_b(buf, k * ch + j, 0) * _for_get_b(filter, k, 0); \
_for_set_b(buf, j, sum, 8); \
} \
for (j = 0; j < a->cols * ch; j++) \
_for_set_a(b_ptr, j, _for_get_b(buf, j, 0), 0); \
a_ptr += a->step; \
b_ptr += db->step; \
}
ccv_matrix_typeof_setter_getter(no_8u_type, ccv_matrix_setter, db->type, ccv_matrix_getter, a->type, for_block);
#undef for_block
/* vertical */
b_ptr = db->data.u8;
#define for_block(_for_type, _for_set_b, _for_get_b, _for_set_a, _for_get_a) \
for (i = 0; i < a->cols * ch; i++) \
{ \
for (j = 0; j < hfz; j++) \
_for_set_b(buf, j, _for_get_a(b_ptr, i, 0), 0); \
for (j = 0; j < a->rows; j++) \
_for_set_b(buf, j + hfz, _for_get_a(b_ptr + j * db->step, i, 0), 0); \
for (j = a->rows; j < hfz + a->rows; j++) \
_for_set_b(buf, j + hfz, _for_get_a(b_ptr + (a->rows - 1) * db->step, i, 0), 0); \
for (j = 0; j < a->rows; j++) \
{ \
_for_type sum = 0; \
for (k = 0; k < fsz; k++) \
sum += _for_get_b(buf, k + j, 0) * _for_get_b(filter, k, 0); \
_for_set_b(buf, j, sum, 8); \
} \
for (j = 0; j < a->rows; j++) \
_for_set_a(b_ptr + j * db->step, i, _for_get_b(buf, j, 0), 0); \
}
ccv_matrix_typeof_setter_getter(no_8u_type, ccv_matrix_setter_getter, db->type, for_block);
#undef for_block
}