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_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) {
// 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_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 }
/* 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 */ } }