// Mahalanobis distance float nv_mahalanobis(const nv_cov_t *cov, const nv_matrix_t *x, int xm) { int n; nv_matrix_t *y = nv_matrix_alloc(x->n, 1); nv_matrix_t *x2 = nv_matrix_alloc(x->n, 1); float distance; float delta2 = 0.0f; nv_matrix_zero(y); nv_matrix_zero(x2); for (n = 0; n < x2->n; ++n) { NV_MAT_V(x2, 0, n) = NV_MAT_V(x, xm, n) - NV_MAT_V(cov->u, 0, n); } nv_gemv(y, 0, NV_MAT_TR, cov->eigen_vec, x2, xm); for (n = 0; n < x->n; ++n) { float ev = NV_MAT_V(cov->eigen_val, n, 0); float xv = NV_MAT_V(y, 0, n); delta2 += (xv * xv) / ev; } distance = sqrtf(delta2); nv_matrix_free(&x2); nv_matrix_free(&y); return distance; }
void nv_mlp_predict_vector(const nv_mlp_t *mlp, nv_matrix_t *p, int p_j, const nv_matrix_t *x, int x_j) { int m; float y; nv_matrix_t *input_y = nv_matrix_alloc(mlp->hidden, 1); nv_matrix_t *hidden_y = nv_matrix_alloc(mlp->output, 1); float dropout_scale = 1.0f - mlp->dropout; float noise_scale = 1.0f - mlp->noise; #ifdef _OPENMP #pragma omp parallel for private(y) #endif for (m = 0; m < mlp->hidden; ++m) { y = NV_MAT_V(mlp->input_bias, m, 0) * NV_MLP_BIAS; y += nv_vector_dot(x, x_j, mlp->input_w, m) * noise_scale; NV_MAT_V(input_y, 0, m) = nv_mlp_sigmoid(y) * dropout_scale; } for (m = 0; m < mlp->output; ++m) { y = NV_MAT_V(mlp->hidden_bias, m, 0) * NV_MLP_BIAS; y += nv_vector_dot(input_y, 0, mlp->hidden_w, m); NV_MAT_V(hidden_y, 0, m) = nv_mlp_sigmoid(y); } nv_mlp_softmax(p, p_j, hidden_y, 0); nv_matrix_free(&input_y); nv_matrix_free(&hidden_y); }
/* 回帰 */ void nv_mlp_regression(const nv_mlp_t *mlp, const nv_matrix_t *x, int xm, nv_matrix_t *out, int om) { int m; float y; nv_matrix_t *input_y = nv_matrix_alloc(mlp->input_w->m, 1); nv_matrix_t *hidden_y = nv_matrix_alloc(mlp->hidden_w->m, 1); #ifdef _OPENMP #pragma omp parallel for private(y) #endif for (m = 0; m < mlp->input_w->m; ++m) { y = NV_MAT_V(mlp->input_bias, m, 0) * NV_MLP_BIAS; y += nv_vector_dot(x, xm, mlp->input_w, m); NV_MAT_V(input_y, 0, m) = nv_mlp_sigmoid(y); } for (m = 0; m < mlp->hidden_w->m; ++m) { y = NV_MAT_V(mlp->hidden_bias, m, 0) * NV_MLP_BIAS; y += nv_vector_dot(input_y, 0, mlp->hidden_w, m); NV_MAT_V(hidden_y, 0, m) = y; } nv_vector_copy(out, om, hidden_y, 0); nv_matrix_free(&input_y); nv_matrix_free(&hidden_y); }
static nv_matrix_t * conv_image2vec(const nv_bgseg_t *bg, const nv_matrix_t *image) { nv_matrix_t *vec; nv_matrix_t *smooth; nv_matrix_t *resize = NULL, *gray = NULL; int i; float scale = (float)bg->size / (float)NV_MAX(image->rows, image->cols); if (scale != 1.0f) { resize = nv_matrix3d_alloc(image->n, NV_ROUND_INT(image->rows * scale), NV_ROUND_INT(image->cols * scale)); nv_resize(resize, image); image = resize; } if (image->n != 1) { gray = nv_matrix3d_alloc(1, image->rows, image->cols); nv_gray(gray, image); image = gray; } vec = nv_matrix_alloc(image->rows * image->cols, 1); smooth = nv_matrix_clone(image); nv_gaussian5x5(smooth, 0, image, 0); for (i = 0; i < image->m; ++i) { NV_MAT_V(vec, 0, i) = NV_MAT_V(smooth, i, 0); } nv_matrix_free(&smooth); nv_matrix_free(&gray); nv_matrix_free(&resize); return vec; }
float nv_mlp_predict(const nv_mlp_t *mlp, const nv_matrix_t *x, int xm, int cls) { int m; float y; nv_matrix_t *input_y = nv_matrix_alloc(mlp->input_w->m, 1); nv_matrix_t *hidden_y = nv_matrix_alloc(mlp->output, 1); nv_matrix_t *output_y = nv_matrix_alloc(mlp->output, 1); float p; double dropout_scale = 1.0 - mlp->dropout; float noise_scale = 1.0f - mlp->noise; #ifdef _OPENMP #pragma omp parallel for private(y) #endif for (m = 0; m < mlp->hidden; ++m) { y = NV_MAT_V(mlp->input_bias, m, 0) * NV_MLP_BIAS; y += nv_vector_dot(x, xm, mlp->input_w, m) * noise_scale; NV_MAT_V(input_y, 0, m) = nv_mlp_sigmoid(y) * dropout_scale; } for (m = 0; m < mlp->output; ++m) { y = NV_MAT_V(mlp->hidden_bias, m, 0) * NV_MLP_BIAS; y += nv_vector_dot(input_y, 0, mlp->hidden_w, m); NV_MAT_V(hidden_y, 0, m) = nv_mlp_sigmoid(y); } nv_mlp_softmax(output_y, 0, hidden_y, 0); p = NV_MAT_V(output_y, 0, cls); nv_matrix_free(&input_y); nv_matrix_free(&hidden_y); nv_matrix_free(&output_y); return p; }
void nv_matrix_sort(nv_matrix_t *mat, int sort_column_n, nv_sort_dir_e dir) { nv_matrix_t *sort_data = nv_matrix_alloc(2, mat->m); nv_matrix_t *tmp = nv_matrix_alloc(mat->n, mat->m); int m; for (m = 0; m < mat->m; ++m) { NV_MAT_V(sort_data, m, 0) = NV_MAT_V(mat, m, sort_column_n); NV_MAT_V(sort_data, m, 1) = (float)m; } if (dir == NV_SORT_DIR_ASC) { qsort(sort_data->v, sort_data->m, sort_data->step * sizeof(float), nv_column_cmp_asc); } else { qsort(sort_data->v, sort_data->m, sort_data->step * sizeof(float), nv_column_cmp_desc); } for (m = 0; m < mat->m; ++m) { nv_vector_copy(tmp, m, mat, (int)NV_MAT_V(sort_data, m, 1)); } nv_matrix_copy(mat, 0, tmp, 0, mat->m); nv_matrix_free(&sort_data); nv_matrix_free(&tmp); }
int main(void) { nv_matrix_t *data = nv_matrix_alloc(PATCH_SIZE * PATCH_SIZE * 3, SAMPLES); nv_matrix_t *centroids = nv_matrix_alloc(data->n, CENTROIDS); nv_matrix_t *zca_u = nv_matrix_alloc(data->n, data->n); nv_matrix_t *zca_m = nv_matrix_alloc(data->n, 1); std::vector<fileinfo_t> list; fileinfo_read(list, TRAIN_FILE); printf("read file list %d\n", (int)list.size()); patch_sampling(data, list); printf("end patch sampling\n"); nv_standardize_local_all(data, 10.0f); nv_zca_train(zca_m, 0, zca_u, data, 0.1f); nv_zca_whitening_all(data, zca_m, 0, zca_u); printf("end whitening\n"); kmeans(centroids, data); nv_save_matrix_bin("zca_u.mat", zca_u); nv_save_matrix_bin("zca_m.mat", zca_m); nv_save_matrix_bin("centroids.mat", centroids); nv_matrix_free(&data); nv_matrix_free(&zca_u); nv_matrix_free(&zca_m); nv_matrix_free(¢roids); return 0; }
void nv_test_knn_lmca(const nv_matrix_t *train_data, const nv_matrix_t *train_labels, const nv_matrix_t *test_data, const nv_matrix_t *test_labels) { nv_matrix_t *train_data_lmca = nv_matrix_alloc(DIM, train_data->m); nv_matrix_t *vec = nv_matrix_alloc(DIM, 1); nv_matrix_t *l = nv_matrix_alloc(train_data->n, DIM); int i, ok; nv_knn_result_t results[KNN_K]; long t; NV_TEST_NAME; nv_lmca_progress(1); printf("train: %d, test: %d, %ddim -> %ddim\n", train_data->m, test_data->m, train_data->n, DIM ); t = nv_clock(); nv_lmca(l, train_data, train_labels, NK, MK, MARGIN, PUSH_RATIO, DELTA, EPOCH); printf("-- %ldms\n", nv_clock() - t); nv_lmca_projection_all(train_data_lmca, l, train_data); ok = 0; for (i = 0; i < test_data->m; ++i) { int knn[NV_TEST_DATA_K] = {0}; int j, n, max_v, max_i; nv_lmca_projection(vec, 0, l, test_data, i); n = nv_knn(results, KNN_K, train_data_lmca, vec, 0); for (j = 0; j < n; ++j) { ++knn[NV_MAT_VI(train_labels, results[j].index, 0)]; } max_v = max_i= 0; for (j = 0; j < NV_TEST_DATA_K; ++j) { if (max_v < knn[j]) { max_v = knn[j]; max_i = j; } } if (max_i == NV_MAT_VI(test_labels, i, 0)) { ++ok; } } printf("Accuracy = %f%% (%d/%d)\n", (float)ok / test_data->m * 100.0f, ok, test_data->m); nv_matrix_free(&train_data_lmca); nv_matrix_free(&vec); nv_matrix_free(&l); fflush(stdout); }
void nv_bgseg_free(nv_bgseg_t **bg) { if (bg && *bg) { nv_matrix_free(&(*bg)->av); nv_matrix_free(&(*bg)->sgm); nv_free(*bg); *bg = NULL; } }
void nv_arow_free(nv_arow_t **arow) { if (arow && *arow) { nv_matrix_free(&(*arow)->w); nv_matrix_free(&(*arow)->bias); nv_free(*arow); *arow = NULL; } }
void nv_shapecontext_free(nv_shapecontext_t **sctx) { if (*sctx) { nv_matrix_free(&(*sctx)->sctx); nv_matrix_free(&(*sctx)->tan_angle); nv_matrix_free(&(*sctx)->coodinate); nv_matrix_free(&(*sctx)->radius); nv_free(*sctx); *sctx = NULL; } }
void nv_mlp_free(nv_mlp_t **mlp) { if (*mlp) { nv_matrix_free(&(*mlp)->input_w); nv_matrix_free(&(*mlp)->input_bias); nv_matrix_free(&(*mlp)->hidden_w); nv_matrix_free(&(*mlp)->hidden_bias); nv_free(*mlp); *mlp = NULL; } }
void nv_plsi_free(nv_plsi_t **p) { if (*p) { nv_matrix_free(&(*p)->z); nv_matrix_free(&(*p)->dz); nv_matrix_free(&(*p)->wz); nv_free(*p); *p = NULL; } }
void nv_pstable_free(nv_pstable_t **ps) { if (ps != NULL && *ps != NULL) { nv_matrix_free(&(*ps)->a); nv_matrix_free(&(*ps)->b); nv_matrix_free(&(*ps)->r1); nv_matrix_free(&(*ps)->r2); nv_free(*ps); *ps = NULL; } }
void clear_vq_table(void) { if (m_vq_table[0]) { nv_matrix_free(&m_vq_table[0]); m_vq_table[0] = NULL; } if (m_vq_table[1]) { nv_matrix_free(&m_vq_table[1]); m_vq_table[1] = NULL; } }
void extract_dense(nv_matrix_t *vlad, int j, const nv_matrix_t *image, nv_keypoint_dense_t *dense, int ndense ) { NV_ASSERT(vlad->n == DIM); int desc_m; nv_matrix_t *key_vec; nv_matrix_t *desc_vec; nv_matrix_t *resize, *gray, *smooth; int i; int km = 0; if (m_fit_area == 0) { float scale = IMG_SIZE() / (float)NV_MAX(image->rows, image->cols); resize = nv_matrix3d_alloc(3, (int)(image->rows * scale), (int)(image->cols * scale)); } else { float axis_ratio = (float)image->rows / image->cols; int new_cols = (int)sqrtf(m_fit_area / axis_ratio); int new_rows = (int)((float)m_fit_area / new_cols); resize = nv_matrix3d_alloc(3, new_rows, new_cols); } gray = nv_matrix3d_alloc(1, resize->rows, resize->cols); smooth = nv_matrix3d_alloc(1, resize->rows, resize->cols); for (i = 0; i < ndense; ++i) { km += dense[i].rows * dense[i].cols; } km *= 2; key_vec = nv_matrix_alloc(NV_KEYPOINT_KEYPOINT_N, km); desc_vec = nv_matrix_alloc(NV_KEYPOINT_DESC_N, km); nv_resize(resize, image); nv_gray(gray, resize); nv_gaussian5x5(smooth, 0, gray, 0); nv_matrix_zero(desc_vec); nv_matrix_zero(key_vec); desc_m = nv_keypoint_dense_ex(m_ctx, key_vec, desc_vec, smooth, 0, dense, ndense); feature_vector(vlad, j, key_vec, desc_vec, desc_m); nv_matrix_free(&gray); nv_matrix_free(&resize); nv_matrix_free(&smooth); nv_matrix_free(&key_vec); nv_matrix_free(&desc_vec); }
int main(void) { nv_matrix_t *data = nv_load_matrix_bin("train_data.mat"); nv_matrix_t *labels = nv_load_matrix_bin("train_labels.mat"); nv_matrix_t *test_data = nv_load_matrix_bin("test_data.mat"); nv_matrix_t *test_labels = nv_load_matrix_bin("test_labels.mat"); int i, ok; int k = 0; nv_lr_t *lr; printf("train: %d, %ddim\ntest: %d\n", data->m, data->n, test_data->m ); ok = 0; for (i = 0; i < labels->m; ++i) { k = NV_MAX(k, NV_MAT_VI(labels, i, 0)); } k += 1; lr = nv_lr_alloc(data->n, k); nv_lr_progress(1); nv_lr_init(lr, data); nv_lr_train(lr, data, labels, NV_LR_PARAM(300, 0.0001f, NV_LR_REG_L2, 0.01f, 0)); //NV_LR_PARAM(100, 0.1e-10f, NV_LR_REG_L2, 0.01, 0)); ok = 0; for (i = 0; i < test_data->m; ++i) { if (nv_lr_predict_label(lr, test_data, i) == NV_MAT_VI(test_labels, i, 0)) { ++ok; } } printf("Accuracy = %f%% (%d/%d)\n", (float)ok / test_data->m * 100.0f, ok, test_data->m); nv_matrix_free(&data); nv_matrix_free(&labels); nv_matrix_free(&test_data); nv_matrix_free(&test_labels); nv_lr_free(&lr); fflush(stdout); return 0; }
int nv_mlp_predict_label(const nv_mlp_t *mlp, const nv_matrix_t *x, int xm) { int m; int label = -1; float max_output = -FLT_MAX; nv_matrix_t *input_y = nv_matrix_alloc(mlp->input_w->m, 1); float dropout_scale = 1.0f - mlp->dropout; float noise_scale = 1.0f - mlp->noise; #ifdef _OPENMP #pragma omp parallel for #endif for (m = 0; m < mlp->hidden; ++m) { float y = NV_MAT_V(mlp->input_bias, m, 0) * NV_MLP_BIAS; y += nv_vector_dot(x, xm, mlp->input_w, m) * noise_scale; NV_MAT_V(input_y, 0, m) = nv_mlp_sigmoid(y) * dropout_scale; } for (m = 0; m < mlp->output; ++m) { float y = NV_MAT_V(mlp->hidden_bias, m, 0) * NV_MLP_BIAS; y += nv_vector_dot(input_y, 0, mlp->hidden_w, m); if (max_output < y) { label = m; max_output = y; } } nv_matrix_free(&input_y); return label; }
float nv_gaussian_log_predict(int npca, const nv_cov_t *cov, const nv_matrix_t *x, int xm) { static const float LOG_PI_0_5_NEGA = -0.5723649f; nv_matrix_t *y = nv_matrix_alloc(x->n, 1); int n; float p; NV_ASSERT(npca <= x->n); if (npca == 0) { npca = (int)(x->n * 0.4f); } p = LOG_PI_0_5_NEGA * npca; nv_vector_sub(y, 0, x, xm, cov->u, 0); for (n = 0; n < npca; ++n) { float xv = nv_vector_dot(cov->eigen_vec, n, y, 0); float ev = NV_MAT_V(cov->eigen_val, n, 0) * 2.0f; p += -(0.5f * logf(ev)) - (xv * xv) / (ev); } nv_matrix_free(&y); return p; }
/* この関数は次元が高いと確率が小さくなりすぎて数値計算できないので * 次元が高い場合は, この関数値の対数であるnv_gaussian_log_predictを使うこと. */ float nv_gaussian_predict(const nv_cov_t *cov, const nv_matrix_t *x, int xm) { int n; nv_matrix_t *y = nv_matrix_alloc(x->n, 2); float p = 1.0f; float d = (float)x->n; float delta2 = 0.0f; float lambda = 1.0f; nv_vector_sub(y, 0, x, xm, cov->u, 0); nv_matrix_mulv(y, 1, cov->eigen_vec, NV_MAT_TR, y, 0); for (n = 0; n < x->n; ++n) { float ev = NV_MAT_V(cov->eigen_val, n, 0); float xv = NV_MAT_V(y, 1, n); if (ev > 0.0f) { delta2 += (xv * xv) / ev; lambda *= sqrtf(ev); } } p = (1.0f / powf(2.0f * NV_PI, d / 2.0f)) * (1.0f / lambda) * expf(-0.5f * delta2); nv_matrix_free(&y); return p; }
static void nv_test_klr_tree_inherit(const nv_matrix_t *data,const nv_matrix_t *labels, nv_klr_tree_t *tree, const nv_klr_tree_t *base) { nv_matrix_t *cluster_labels = nv_matrix_alloc(1, data->m); float purity; int i; NV_TEST_NAME; printf("tree: "); for (i = 0; i < tree->height; ++i) { if (i != 0) { printf(", "); } printf("%d", tree->dim[i]); } printf("\n"); if (base == NULL) { nv_klr_tree_train(tree, data, NV_LR_PARAM(4, 0.1f, NV_LR_REG_L1, 0.0001f, 1), 100); } else { nv_klr_tree_inherit_train(tree, base, data, NV_LR_PARAM(4, 0.1f, NV_LR_REG_L1, 0.0001f, 1), 100); } for (i = 0; i < data->m; ++i) { NV_MAT_V(cluster_labels, i, 0) = (float)nv_klr_tree_predict_label(tree, data, i); } purity = nv_purity(K, NV_TEST_DATA_K, cluster_labels, labels); printf("purity: %f\n", purity); NV_ASSERT(purity > 0.5f); nv_matrix_free(&cluster_labels); }
static void nv_test_klr_tree_ex(const nv_matrix_t *data, const nv_matrix_t *labels, int *width, int height) { nv_matrix_t *cluster_labels = nv_matrix_alloc(1, data->m); nv_klr_tree_t *tree = nv_klr_tree_alloc(data->n, width, height); float purity; int i; NV_TEST_NAME; printf("tree: "); for (i = 0; i < height; ++i) { if (i != 0) { printf(", "); } printf("%d", width[i]); } printf("\n"); nv_klr_tree_train(tree, data, NV_LR_PARAM(4, 0.1f, NV_LR_REG_L1, 0.0001f, 1), 100); for (i = 0; i < data->m; ++i) { NV_MAT_V(cluster_labels, i, 0) = (float)nv_klr_tree_predict_label(tree, data, i); } purity = nv_purity(K, NV_TEST_DATA_K, cluster_labels, labels); printf("purity: %f\n", purity); NV_ASSERT(purity > 0.5f); nv_klr_tree_free(&tree); nv_matrix_free(&cluster_labels); }
void kmeans(nv_matrix_t *centroids, const nv_matrix_t *data) { nv_matrix_t *cluster_labels = nv_matrix_alloc(1, data->m); nv_matrix_t *count = nv_matrix_alloc(1, CENTROIDS); nv_matrix_zero(count); nv_matrix_zero(centroids); nv_matrix_zero(cluster_labels); nv_kmeans_progress(1); nv_kmeans(centroids, count, cluster_labels, data, CENTROIDS, 50); nv_matrix_free(&cluster_labels); nv_matrix_free(&count); }
void nv_pa_free(nv_pa_t **pa) { if (pa && *pa) { nv_matrix_free(&(*pa)->w); nv_free(*pa); *pa = NULL; } }
void otama_image_free(otama_image_t **image) { if (image && *image) { nv_matrix_free(&(*image)->image); nv_free(*image); *image = NULL; } }
void nv_lr_free(nv_lr_t **lr) { if (*lr) { nv_matrix_free(&(*lr)->w); nv_free(*lr); *lr = NULL; } }
/* * 45°回転したIntegral Image */ void nv_integral_tilted(nv_matrix_t *integral, const nv_matrix_t *img, int channel) { int row, col, scol, srow; int erow = img->rows + 1; int ecol = img->cols + 1; nv_matrix_t *prev_tilted = nv_matrix_alloc(img->cols + 1, 1); NV_ASSERT( integral->rows - 1 == img->rows && integral->cols - 1 == img->cols ); nv_matrix_zero(prev_tilted); nv_matrix_zero(integral); for (scol = img->cols; scol > 0; --scol) { float tilted_sum = 0.0f; for (row = 1, col = scol; row < erow && col < ecol; ++row, ++col) { float tilted_val = NV_MAT3D_V(img, row - 1, col - 1, channel); if (col + 1 == ecol) { NV_MAT3D_V(integral, row, col, 0) = NV_MAT3D_V(integral, row - 1, col, 0) + tilted_sum + tilted_val; } else { NV_MAT3D_V(integral, row, col, 0) = NV_MAT3D_V(integral, row - 1, col + 1, 0) + NV_MAT_V(prev_tilted, 0, col) + tilted_sum + tilted_val; } tilted_sum += tilted_val; NV_MAT_V(prev_tilted, 0, col) = tilted_sum; } } for (srow = 2; srow < erow; ++srow) { float tilted_sum = 0.0f; for (row = srow, col = 1; row < erow && col < ecol; ++row, ++col) { float tilted_val = NV_MAT3D_V(img, row - 1, col - 1, channel); if (col + 1 == ecol) { NV_MAT3D_V(integral, row, col, 0) = NV_MAT3D_V(integral, row - 1, col, 0) + tilted_sum + tilted_val; } else { NV_MAT3D_V(integral, row, col, 0) = NV_MAT3D_V(integral, row - 1, col + 1, 0) + NV_MAT_V(prev_tilted, 0, col) + tilted_sum + tilted_val; } tilted_sum += tilted_val; NV_MAT_V(prev_tilted, 0, col) = tilted_sum; } } nv_matrix_free(&prev_tilted); }
void patch_sampling(nv_matrix_t *samples, std::vector<fileinfo_t> &list) { nv_matrix_t *data = nv_matrix_alloc(PATCH_SIZE * PATCH_SIZE * 3, (int)((IMG_SIZE-PATCH_SIZE) * (IMG_SIZE-PATCH_SIZE) * list.size())); int data_index = 0; int i; nv_matrix_zero(data); #ifdef _OPENMP #pragma omp parallel for schedule(dynamic, 1) #endif for (i = 0; i < (int)list.size(); ++i) { nv_matrix_t *src; nv_matrix_t *patches; src = nv_load_image(list[i].file.c_str()); if (!src) { fprintf(stderr, "open filed: %s\n", list[i].file.c_str()); exit(-1); } patches = nv_patch_matrix_alloc(src, PATCH_SIZE); nv_patch_extract(patches, src, PATCH_SIZE); #ifdef _OPENMP #pragma omp critical (patch_sampling) #endif { int j; for (j = 0; j < patches->m; ++j) { nv_vector_copy(data, data_index, patches, j); data_index += 1; } } nv_matrix_free(&src); nv_matrix_free(&patches); } nv_vector_shuffle(data); nv_matrix_m(data, NV_MIN(samples->m, data_index)); nv_matrix_copy_all(samples, data); nv_matrix_free(&data); }
void nv_bgseg_update(nv_bgseg_t *bg, nv_matrix_t *mask, const nv_matrix_t *frame) { nv_matrix_t *tmp, *tmp2, *mask_vec, *lower, *upper; NV_ASSERT(bg->init_2nd_finished == 1); tmp = conv_image2vec(bg, frame); lower = nv_matrix_clone(tmp); upper = nv_matrix_clone(tmp); mask_vec = nv_matrix_clone(tmp); tmp2 = nv_matrix_dup(tmp); // range nv_vector_sub(lower, 0, bg->av, 0, bg->sgm, 0); nv_vector_subs(lower, 0, lower, 0, bg->zeta); nv_vector_add(upper, 0, bg->av, 0, bg->sgm, 0); nv_vector_adds(upper, 0, upper, 0, bg->zeta); nv_vector_in_range10(mask_vec, 0, lower, 0, upper, 0, tmp, 0); // update amplitude nv_vector_sub(tmp, 0, tmp, 0, bg->av, 0); nv_vector_mul(tmp, 0, tmp, 0, tmp, 0); nv_vector_muls(tmp, 0, tmp, 0, 2.0f); nv_vector_sqrt(tmp, 0, tmp, 0); // update background running_avg(bg->av, tmp2, bg->bg_v, mask_vec, 1.0f); running_avg(bg->sgm, tmp, bg->bg_v, mask_vec, 1.0f); // update foreground running_avg(bg->sgm, tmp, bg->fg_v, mask_vec, 0.0f); conv_mask(bg, mask, mask_vec); nv_matrix_free(&tmp); nv_matrix_free(&mask_vec); nv_matrix_free(&tmp2); nv_matrix_free(&upper); nv_matrix_free(&lower); }
inline char * serialize(const nv_matrix_t *vlad, int j) { nv_matrix_t *mat = nv_matrix_alloc(vlad->n, 1); char *s; nv_vector_copy(mat, 0, vlad, j); s = nv_serialize_matrix(mat); nv_matrix_free(&mat); return s; }