File: | ccv_dpm.c |
Warning: | line 1764, column 10 Although the value stored to 't' is used in the enclosing expression, the value is never actually read from 't' |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | #include "ccv.h" |
2 | #include "ccv_internal.h" |
3 | #include <sys/time.h> |
4 | #ifdef HAVE_GSL1 |
5 | #include <gsl/gsl_rng.h> |
6 | #include <gsl/gsl_multifit.h> |
7 | #include <gsl/gsl_randist.h> |
8 | #endif |
9 | #ifdef USE_OPENMP |
10 | #include <omp.h> |
11 | #endif |
12 | #ifdef HAVE_LIBLINEAR1 |
13 | #include <linear.h> |
14 | #endif |
15 | |
16 | const ccv_dpm_param_t ccv_dpm_default_params = { |
17 | .interval = 8, |
18 | .min_neighbors = 1, |
19 | .flags = 0, |
20 | .threshold = 0.6, // 0.8 |
21 | }; |
22 | |
23 | #define CCV_DPM_WINDOW_SIZE(8) (8) |
24 | |
25 | static int _ccv_dpm_scale_upto(ccv_dense_matrix_t* a, ccv_dpm_mixture_model_t** _model, int count, int interval) |
26 | { |
27 | int c, i; |
28 | ccv_size_t size = ccv_size(a->cols, a->rows); |
29 | for (c = 0; c < count; c++) |
30 | { |
31 | ccv_dpm_mixture_model_t* model = _model[c]; |
32 | for (i = 0; i < model->count; i++) |
33 | { |
34 | size.width = ccv_min(model->root[i].root.w->cols * CCV_DPM_WINDOW_SIZE, size.width)({ typeof (model->root[i].root.w->cols * (8)) _a = (model ->root[i].root.w->cols * (8)); typeof (size.width) _b = (size.width); (_a < _b) ? _a : _b; }); |
35 | size.height = ccv_min(model->root[i].root.w->rows * CCV_DPM_WINDOW_SIZE, size.height)({ typeof (model->root[i].root.w->rows * (8)) _a = (model ->root[i].root.w->rows * (8)); typeof (size.height) _b = (size.height); (_a < _b) ? _a : _b; }); |
36 | } |
37 | } |
38 | int hr = a->rows / size.height; |
39 | int wr = a->cols / size.width; |
40 | double scale = pow(2.0, 1.0 / (interval + 1.0)); |
41 | int next = interval + 1; |
42 | return (int)(log((double)ccv_min(hr, wr)({ typeof (hr) _a = (hr); typeof (wr) _b = (wr); (_a < _b) ? _a : _b; })) / log(scale)) - next; |
43 | } |
44 | |
45 | static void _ccv_dpm_feature_pyramid(ccv_dense_matrix_t* a, ccv_dense_matrix_t** pyr, int scale_upto, int interval) |
46 | { |
47 | int next = interval + 1; |
48 | double scale = pow(2.0, 1.0 / (interval + 1.0)); |
49 | memset(pyr, 0, (scale_upto + next * 2) * sizeof(ccv_dense_matrix_t*)); |
50 | pyr[next] = a; |
51 | int i; |
52 | for (i = 1; i <= interval; i++) |
53 | ccv_resample(pyr[next], &pyr[next + i], 0, (double)(int)(pyr[next]->rows / pow(scale, i)) / (double)pyr[next]->rows, (double)(int)(pyr[next]->cols / pow(scale, i)) / (double)pyr[next]->cols, CCV_INTER_AREA); |
54 | for (i = next; i < scale_upto + next; i++) |
55 | ccv_sample_down(pyr[i], &pyr[i + next], 0, 0, 0); |
56 | ccv_dense_matrix_t* hog; |
57 | /* a more efficient way to generate up-scaled hog (using smaller size) */ |
58 | for (i = 0; i < next; i++) |
59 | { |
60 | hog = 0; |
61 | ccv_hog(pyr[i + next], &hog, 0, 9, CCV_DPM_WINDOW_SIZE(8) / 2 /* this is */); |
62 | pyr[i] = hog; |
63 | } |
64 | hog = 0; |
65 | ccv_hog(pyr[next], &hog, 0, 9, CCV_DPM_WINDOW_SIZE(8)); |
66 | pyr[next] = hog; |
67 | for (i = next + 1; i < scale_upto + next * 2; i++) |
68 | { |
69 | hog = 0; |
70 | ccv_hog(pyr[i], &hog, 0, 9, CCV_DPM_WINDOW_SIZE(8)); |
71 | ccv_matrix_free(pyr[i]); |
72 | pyr[i] = hog; |
73 | } |
74 | } |
75 | |
76 | static void _ccv_dpm_compute_score(ccv_dpm_root_classifier_t* root_classifier, ccv_dense_matrix_t* hog, ccv_dense_matrix_t* hog2x, ccv_dense_matrix_t** _response, ccv_dense_matrix_t** part_feature, ccv_dense_matrix_t** dx, ccv_dense_matrix_t** dy) |
77 | { |
78 | ccv_dense_matrix_t* response = 0; |
79 | ccv_filter(hog, root_classifier->root.w, &response, 0, CCV_NO_PADDING); |
80 | ccv_dense_matrix_t* root_feature = 0; |
81 | ccv_flatten(response, (ccv_matrix_t**)&root_feature, 0, 0); |
82 | ccv_matrix_free(response); |
83 | *_response = root_feature; |
84 | if (hog2x == 0) |
85 | return; |
86 | ccv_make_matrix_mutable(root_feature); |
87 | int rwh = (root_classifier->root.w->rows - 1) / 2, rww = (root_classifier->root.w->cols - 1) / 2; |
88 | int rwh_1 = root_classifier->root.w->rows / 2, rww_1 = root_classifier->root.w->cols / 2; |
89 | int i, x, y; |
90 | for (i = 0; i < root_classifier->count; i++) |
91 | { |
92 | ccv_dpm_part_classifier_t* part = root_classifier->part + i; |
93 | ccv_dense_matrix_t* response = 0; |
94 | ccv_filter(hog2x, part->w, &response, 0, CCV_NO_PADDING); |
95 | ccv_dense_matrix_t* feature = 0; |
96 | ccv_flatten(response, (ccv_matrix_t**)&feature, 0, 0); |
97 | ccv_matrix_free(response); |
98 | part_feature[i] = dx[i] = dy[i] = 0; |
99 | ccv_distance_transform(feature, &part_feature[i], 0, &dx[i], 0, &dy[i], 0, part->dx, part->dy, part->dxx, part->dyy, CCV_NEGATIVE | CCV_GSEDT); |
100 | ccv_matrix_free(feature); |
101 | int pwh = (part->w->rows - 1) / 2, pww = (part->w->cols - 1) / 2; |
102 | int offy = part->y + pwh - rwh * 2; |
103 | int miny = pwh, maxy = part_feature[i]->rows - part->w->rows + pwh; |
104 | int offx = part->x + pww - rww * 2; |
105 | int minx = pww, maxx = part_feature[i]->cols - part->w->cols + pww; |
106 | float* f_ptr = (float*)ccv_get_dense_matrix_cell_by(CCV_32F | CCV_C1, root_feature, rwh, 0, 0)(((CCV_32F | CCV_C1) & CCV_32S) ? (void*)((root_feature)-> data.i32 + ((rwh) * (root_feature)->cols + (0)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)) : (((CCV_32F | CCV_C1) & CCV_32F ) ? (void*)((root_feature)->data.f32+ ((rwh) * (root_feature )->cols + (0)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)) : (((CCV_32F | CCV_C1) & CCV_64S) ? (void*)((root_feature) ->data.i64+ ((rwh) * (root_feature)->cols + (0)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)) : (((CCV_32F | CCV_C1) & CCV_64F ) ? (void*)((root_feature)->data.f64 + ((rwh) * (root_feature )->cols + (0)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)) : (void*)((root_feature)->data.u8 + (rwh) * (root_feature)-> step + (0) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)))))); |
107 | for (y = rwh; y < root_feature->rows - rwh_1; y++) |
108 | { |
109 | int iy = ccv_clamp(y * 2 + offy, miny, maxy)({ typeof (miny) _a = (miny); typeof (maxy) _b = (maxy); typeof (y * 2 + offy) _x = (y * 2 + offy); (_x < _a) ? _a : ((_x > _b) ? _b : _x); }); |
110 | for (x = rww; x < root_feature->cols - rww_1; x++) |
111 | { |
112 | int ix = ccv_clamp(x * 2 + offx, minx, maxx)({ typeof (minx) _a = (minx); typeof (maxx) _b = (maxx); typeof (x * 2 + offx) _x = (x * 2 + offx); (_x < _a) ? _a : ((_x > _b) ? _b : _x); }); |
113 | f_ptr[x] -= ccv_get_dense_matrix_cell_value_by(CCV_32F | CCV_C1, part_feature[i], iy, ix, 0)(((CCV_32F | CCV_C1) & CCV_32S) ? (part_feature[i])->data .i32[((iy) * (part_feature[i])->cols + (ix)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)] : (((CCV_32F | CCV_C1) & CCV_32F ) ? (part_feature[i])->data.f32[((iy) * (part_feature[i])-> cols + (ix)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)] : (((CCV_32F | CCV_C1) & CCV_64S) ? (part_feature[i])->data.i64[(( iy) * (part_feature[i])->cols + (ix)) * ((CCV_32F | CCV_C1 ) & 0xFFF) + (0)] : (((CCV_32F | CCV_C1) & CCV_64F) ? (part_feature[i])->data.f64[((iy) * (part_feature[i])-> cols + (ix)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)] : (part_feature [i])->data.u8[(iy) * (part_feature[i])->step + (ix) * ( (CCV_32F | CCV_C1) & 0xFFF) + (0)])))); |
114 | } |
115 | f_ptr += root_feature->cols; |
116 | } |
117 | } |
118 | } |
119 | |
120 | #ifdef HAVE_LIBLINEAR1 |
121 | #ifdef HAVE_GSL1 |
122 | |
123 | static uint64_t _ccv_dpm_time_measure() |
124 | { |
125 | struct timeval tv; |
126 | gettimeofday(&tv, 0); |
127 | return tv.tv_sec * 1000000 + tv.tv_usec; |
128 | } |
129 | |
130 | #define less_than(fn1, fn2, aux) ((fn1).value >= (fn2).value) |
131 | static CCV_IMPLEMENT_QSORT(_ccv_dpm_aspect_qsort, struct feature_node, less_than)void _ccv_dpm_aspect_qsort(struct feature_node *array, size_t total, int aux) { int isort_thresh = 7; struct feature_node t ; int sp = 0; struct { struct feature_node *lb; struct feature_node *ub; } stack[48]; if( total <= 1 ) return; stack[0].lb = array ; stack[0].ub = array + (total - 1); while( sp >= 0 ) { struct feature_node* left = stack[sp].lb; struct feature_node* right = stack[sp--].ub; for(;;) { int i, n = (int)(right - left) + 1, m; struct feature_node* ptr; struct feature_node* ptr2; if ( n <= isort_thresh ) { insert_sort: for( ptr = left + 1; ptr <= right; ptr++ ) { for( ptr2 = ptr; ptr2 > left && less_than(ptr2[0],ptr2[-1], aux); ptr2--) (((t)) = ((ptr2[0] )), ((ptr2[0])) = ((ptr2[-1])), ((ptr2[-1])) = ((t))); } break ; } else { struct feature_node* left0; struct feature_node* left1 ; struct feature_node* right0; struct feature_node* right1; struct feature_node* pivot; struct feature_node* a; struct feature_node * b; struct feature_node* c; int swap_cnt = 0; left0 = left; right0 = right; pivot = left + (n/2); if( n > 40 ) { int d = n / 8; a = left, b = left + d, c = left + 2*d; left = less_than( *a, *b, aux) ? (less_than(*b, *c, aux) ? b : (less_than(*a, * c, aux) ? c : a)) : (less_than(*c, *b, aux) ? b : (less_than( *a, *c, aux) ? a : c)); a = pivot - d, b = pivot, c = pivot + d; pivot = less_than(*a, *b, aux) ? (less_than(*b, *c, aux) ? b : (less_than(*a, *c, aux) ? c : a)) : (less_than(*c, *b, aux ) ? b : (less_than(*a, *c, aux) ? a : c)); a = right - 2*d, b = right - d, c = right; right = less_than(*a, *b, aux) ? (less_than (*b, *c, aux) ? b : (less_than(*a, *c, aux) ? c : a)) : (less_than (*c, *b, aux) ? b : (less_than(*a, *c, aux) ? a : c)); } a = left , b = pivot, c = right; pivot = less_than(*a, *b, aux) ? (less_than (*b, *c, aux) ? b : (less_than(*a, *c, aux) ? c : a)) : (less_than (*c, *b, aux) ? b : (less_than(*a, *c, aux) ? a : c)); if( pivot != left0 ) { (((t)) = ((*pivot)), ((*pivot)) = ((*left0)), ( (*left0)) = ((t))); pivot = left0; } left = left1 = left0 + 1 ; right = right1 = right0; for(;;) { while( left <= right && !less_than(*pivot, *left, aux) ) { if( !less_than(*left, *pivot , aux) ) { if( left > left1 ) (((t)) = ((*left1)), ((*left1 )) = ((*left)), ((*left)) = ((t))); swap_cnt = 1; left1++; } left ++; } while( left <= right && !less_than(*right, * pivot, aux) ) { if( !less_than(*pivot, *right, aux) ) { if( right < right1 ) (((t)) = ((*right1)), ((*right1)) = ((*right)) , ((*right)) = ((t))); swap_cnt = 1; right1--; } right--; } if ( left > right ) break; (((t)) = ((*left)), ((*left)) = (( *right)), ((*right)) = ((t))); swap_cnt = 1; left++; right--; } if( swap_cnt == 0 ) { left = left0, right = right0; goto insert_sort ; } n = ({ typeof ((int)(left1 - left0)) _a = ((int)(left1 - left0 )); typeof ((int)(left - left1)) _b = ((int)(left - left1)); ( _a < _b) ? _a : _b; }); for( i = 0; i < n; i++ ) (((t)) = ((left0[i])), ((left0[i])) = ((left[i-n])), ((left[i-n])) = ((t))); n = ({ typeof ((int)(right0 - right1)) _a = ((int)(right0 - right1)); typeof ((int)(right1 - right)) _b = ((int)(right1 - right)); (_a < _b) ? _a : _b; }); for( i = 0; i < n; i++ ) (((t)) = ((left[i])), ((left[i])) = ((right0[i-n+1])), ((right0[i-n+1])) = ((t))); n = (int)(left - left1); m = (int )(right1 - right); if( n > 1 ) { if( m > 1 ) { if( n > m ) { stack[++sp].lb = left0; stack[sp].ub = left0 + n - 1; left = right0 - m + 1, right = right0; } else { stack[++sp].lb = right0 - m + 1; stack[sp].ub = right0; left = left0, right = left0 + n - 1; } } else left = left0, right = left0 + n - 1; } else if ( m > 1 ) left = right0 - m + 1, right = right0; else break ; } } } } |
132 | #undef less_than |
133 | |
134 | #define less_than(a1, a2, aux) ((a1) < (a2)) |
135 | static CCV_IMPLEMENT_QSORT(_ccv_dpm_area_qsort, int, less_than)void _ccv_dpm_area_qsort(int *array, size_t total, int aux) { int isort_thresh = 7; int t; int sp = 0; struct { int *lb; int *ub; } stack[48]; if( total <= 1 ) return; stack[0].lb = array ; stack[0].ub = array + (total - 1); while( sp >= 0 ) { int * left = stack[sp].lb; int* right = stack[sp--].ub; for(;;) { int i, n = (int)(right - left) + 1, m; int* ptr; int* ptr2; if ( n <= isort_thresh ) { insert_sort: for( ptr = left + 1; ptr <= right; ptr++ ) { for( ptr2 = ptr; ptr2 > left && less_than(ptr2[0],ptr2[-1], aux); ptr2--) (((t)) = ((ptr2[0] )), ((ptr2[0])) = ((ptr2[-1])), ((ptr2[-1])) = ((t))); } break ; } else { int* left0; int* left1; int* right0; int* right1; int * pivot; int* a; int* b; int* c; int swap_cnt = 0; left0 = left ; right0 = right; pivot = left + (n/2); if( n > 40 ) { int d = n / 8; a = left, b = left + d, c = left + 2*d; left = less_than (*a, *b, aux) ? (less_than(*b, *c, aux) ? b : (less_than(*a, * c, aux) ? c : a)) : (less_than(*c, *b, aux) ? b : (less_than( *a, *c, aux) ? a : c)); a = pivot - d, b = pivot, c = pivot + d; pivot = less_than(*a, *b, aux) ? (less_than(*b, *c, aux) ? b : (less_than(*a, *c, aux) ? c : a)) : (less_than(*c, *b, aux ) ? b : (less_than(*a, *c, aux) ? a : c)); a = right - 2*d, b = right - d, c = right; right = less_than(*a, *b, aux) ? (less_than (*b, *c, aux) ? b : (less_than(*a, *c, aux) ? c : a)) : (less_than (*c, *b, aux) ? b : (less_than(*a, *c, aux) ? a : c)); } a = left , b = pivot, c = right; pivot = less_than(*a, *b, aux) ? (less_than (*b, *c, aux) ? b : (less_than(*a, *c, aux) ? c : a)) : (less_than (*c, *b, aux) ? b : (less_than(*a, *c, aux) ? a : c)); if( pivot != left0 ) { (((t)) = ((*pivot)), ((*pivot)) = ((*left0)), ( (*left0)) = ((t))); pivot = left0; } left = left1 = left0 + 1 ; right = right1 = right0; for(;;) { while( left <= right && !less_than(*pivot, *left, aux) ) { if( !less_than(*left, *pivot , aux) ) { if( left > left1 ) (((t)) = ((*left1)), ((*left1 )) = ((*left)), ((*left)) = ((t))); swap_cnt = 1; left1++; } left ++; } while( left <= right && !less_than(*right, * pivot, aux) ) { if( !less_than(*pivot, *right, aux) ) { if( right < right1 ) (((t)) = ((*right1)), ((*right1)) = ((*right)) , ((*right)) = ((t))); swap_cnt = 1; right1--; } right--; } if ( left > right ) break; (((t)) = ((*left)), ((*left)) = (( *right)), ((*right)) = ((t))); swap_cnt = 1; left++; right--; } if( swap_cnt == 0 ) { left = left0, right = right0; goto insert_sort ; } n = ({ typeof ((int)(left1 - left0)) _a = ((int)(left1 - left0 )); typeof ((int)(left - left1)) _b = ((int)(left - left1)); ( _a < _b) ? _a : _b; }); for( i = 0; i < n; i++ ) (((t)) = ((left0[i])), ((left0[i])) = ((left[i-n])), ((left[i-n])) = ((t))); n = ({ typeof ((int)(right0 - right1)) _a = ((int)(right0 - right1)); typeof ((int)(right1 - right)) _b = ((int)(right1 - right)); (_a < _b) ? _a : _b; }); for( i = 0; i < n; i++ ) (((t)) = ((left[i])), ((left[i])) = ((right0[i-n+1])), ((right0[i-n+1])) = ((t))); n = (int)(left - left1); m = (int )(right1 - right); if( n > 1 ) { if( m > 1 ) { if( n > m ) { stack[++sp].lb = left0; stack[sp].ub = left0 + n - 1; left = right0 - m + 1, right = right0; } else { stack[++sp].lb = right0 - m + 1; stack[sp].ub = right0; left = left0, right = left0 + n - 1; } } else left = left0, right = left0 + n - 1; } else if ( m > 1 ) left = right0 - m + 1, right = right0; else break ; } } } } |
136 | #undef less_than |
137 | |
138 | #define less_than(s1, s2, aux) ((s1) < (s2)) |
139 | static CCV_IMPLEMENT_QSORT(_ccv_dpm_score_qsort, double, less_than)void _ccv_dpm_score_qsort(double *array, size_t total, int aux ) { int isort_thresh = 7; double t; int sp = 0; struct { double *lb; double *ub; } stack[48]; if( total <= 1 ) return; stack [0].lb = array; stack[0].ub = array + (total - 1); while( sp >= 0 ) { double* left = stack[sp].lb; double* right = stack[sp-- ].ub; for(;;) { int i, n = (int)(right - left) + 1, m; double * ptr; double* ptr2; if( n <= isort_thresh ) { insert_sort : for( ptr = left + 1; ptr <= right; ptr++ ) { for( ptr2 = ptr; ptr2 > left && less_than(ptr2[0],ptr2[-1], aux ); ptr2--) (((t)) = ((ptr2[0])), ((ptr2[0])) = ((ptr2[-1])), ( (ptr2[-1])) = ((t))); } break; } else { double* left0; double * left1; double* right0; double* right1; double* pivot; double * a; double* b; double* c; int swap_cnt = 0; left0 = left; right0 = right; pivot = left + (n/2); if( n > 40 ) { int d = n / 8; a = left, b = left + d, c = left + 2*d; left = less_than( *a, *b, aux) ? (less_than(*b, *c, aux) ? b : (less_than(*a, * c, aux) ? c : a)) : (less_than(*c, *b, aux) ? b : (less_than( *a, *c, aux) ? a : c)); a = pivot - d, b = pivot, c = pivot + d; pivot = less_than(*a, *b, aux) ? (less_than(*b, *c, aux) ? b : (less_than(*a, *c, aux) ? c : a)) : (less_than(*c, *b, aux ) ? b : (less_than(*a, *c, aux) ? a : c)); a = right - 2*d, b = right - d, c = right; right = less_than(*a, *b, aux) ? (less_than (*b, *c, aux) ? b : (less_than(*a, *c, aux) ? c : a)) : (less_than (*c, *b, aux) ? b : (less_than(*a, *c, aux) ? a : c)); } a = left , b = pivot, c = right; pivot = less_than(*a, *b, aux) ? (less_than (*b, *c, aux) ? b : (less_than(*a, *c, aux) ? c : a)) : (less_than (*c, *b, aux) ? b : (less_than(*a, *c, aux) ? a : c)); if( pivot != left0 ) { (((t)) = ((*pivot)), ((*pivot)) = ((*left0)), ( (*left0)) = ((t))); pivot = left0; } left = left1 = left0 + 1 ; right = right1 = right0; for(;;) { while( left <= right && !less_than(*pivot, *left, aux) ) { if( !less_than(*left, *pivot , aux) ) { if( left > left1 ) (((t)) = ((*left1)), ((*left1 )) = ((*left)), ((*left)) = ((t))); swap_cnt = 1; left1++; } left ++; } while( left <= right && !less_than(*right, * pivot, aux) ) { if( !less_than(*pivot, *right, aux) ) { if( right < right1 ) (((t)) = ((*right1)), ((*right1)) = ((*right)) , ((*right)) = ((t))); swap_cnt = 1; right1--; } right--; } if ( left > right ) break; (((t)) = ((*left)), ((*left)) = (( *right)), ((*right)) = ((t))); swap_cnt = 1; left++; right--; } if( swap_cnt == 0 ) { left = left0, right = right0; goto insert_sort ; } n = ({ typeof ((int)(left1 - left0)) _a = ((int)(left1 - left0 )); typeof ((int)(left - left1)) _b = ((int)(left - left1)); ( _a < _b) ? _a : _b; }); for( i = 0; i < n; i++ ) (((t)) = ((left0[i])), ((left0[i])) = ((left[i-n])), ((left[i-n])) = ((t))); n = ({ typeof ((int)(right0 - right1)) _a = ((int)(right0 - right1)); typeof ((int)(right1 - right)) _b = ((int)(right1 - right)); (_a < _b) ? _a : _b; }); for( i = 0; i < n; i++ ) (((t)) = ((left[i])), ((left[i])) = ((right0[i-n+1])), ((right0[i-n+1])) = ((t))); n = (int)(left - left1); m = (int )(right1 - right); if( n > 1 ) { if( m > 1 ) { if( n > m ) { stack[++sp].lb = left0; stack[sp].ub = left0 + n - 1; left = right0 - m + 1, right = right0; } else { stack[++sp].lb = right0 - m + 1; stack[sp].ub = right0; left = left0, right = left0 + n - 1; } } else left = left0, right = left0 + n - 1; } else if ( m > 1 ) left = right0 - m + 1, right = right0; else break ; } } } } |
140 | #undef less_than |
141 | |
142 | static ccv_dpm_mixture_model_t* _ccv_dpm_model_copy(ccv_dpm_mixture_model_t* _model) |
143 | { |
144 | ccv_dpm_mixture_model_t* model = (ccv_dpm_mixture_model_t*)ccmallocmalloc(sizeof(ccv_dpm_mixture_model_t)); |
145 | model->count = _model->count; |
146 | model->root = (ccv_dpm_root_classifier_t*)ccmallocmalloc(sizeof(ccv_dpm_root_classifier_t) * model->count); |
147 | int i, j; |
148 | memcpy(model->root, _model->root, sizeof(ccv_dpm_root_classifier_t) * model->count); |
149 | for (i = 0; i < model->count; i++) |
150 | { |
151 | ccv_dpm_root_classifier_t* _root = _model->root + i; |
152 | ccv_dpm_root_classifier_t* root = model->root + i; |
153 | root->root.w = ccv_dense_matrix_new(_root->root.w->rows, _root->root.w->cols, CCV_32F | 31, 0, 0); |
154 | memcpy(root->root.w->data.u8, _root->root.w->data.u8, _root->root.w->rows * _root->root.w->step); |
155 | ccv_make_matrix_immutable(root->root.w); |
156 | ccv_dpm_part_classifier_t* _part = _root->part; |
157 | ccv_dpm_part_classifier_t* part = root->part = (ccv_dpm_part_classifier_t*)ccmallocmalloc(sizeof(ccv_dpm_part_classifier_t) * root->count); |
158 | memcpy(part, _part, sizeof(ccv_dpm_part_classifier_t) * root->count); |
159 | for (j = 0; j < root->count; j++) |
160 | { |
161 | part[j].w = ccv_dense_matrix_new(_part[j].w->rows, _part[j].w->cols, CCV_32F | 31, 0, 0); |
162 | memcpy(part[j].w->data.u8, _part[j].w->data.u8, _part[j].w->rows * _part[j].w->step); |
163 | ccv_make_matrix_immutable(part[j].w); |
164 | } |
165 | } |
166 | return model; |
167 | } |
168 | |
169 | static void _ccv_dpm_write_checkpoint(ccv_dpm_mixture_model_t* model, int done, const char* dir) |
170 | { |
171 | char swpfile[1024]; |
172 | sprintf(swpfile, "%s.swp", dir); |
173 | FILE* w = fopen(swpfile, "w+"); |
174 | if (!w) |
175 | return; |
176 | if (done) |
177 | fprintf(w, ".\n"); |
178 | else |
179 | fprintf(w, ",\n"); |
180 | int i, j, x, y, ch, count = 0; |
181 | for (i = 0; i < model->count; i++) |
182 | { |
183 | if (model->root[i].root.w == 0) |
184 | break; |
185 | count++; |
186 | } |
187 | if (done) |
188 | fprintf(w, "%d\n", model->count); |
189 | else |
190 | fprintf(w, "%d %d\n", model->count, count); |
191 | for (i = 0; i < count; i++) |
192 | { |
193 | ccv_dpm_root_classifier_t* root_classifier = model->root + i; |
194 | fprintf(w, "%d %d\n", root_classifier->root.w->rows, root_classifier->root.w->cols); |
195 | fprintf(w, "%a %a %a %a\n", root_classifier->beta, root_classifier->alpha[0], root_classifier->alpha[1], root_classifier->alpha[2]); |
196 | ch = CCV_GET_CHANNEL(root_classifier->root.w->type)((root_classifier->root.w->type) & 0xFFF); |
197 | for (y = 0; y < root_classifier->root.w->rows; y++) |
198 | { |
199 | for (x = 0; x < root_classifier->root.w->cols * ch; x++) |
200 | fprintf(w, "%a ", root_classifier->root.w->data.f32[y * root_classifier->root.w->cols * ch + x]); |
201 | fprintf(w, "\n"); |
202 | } |
203 | fprintf(w, "%d\n", root_classifier->count); |
204 | for (j = 0; j < root_classifier->count; j++) |
205 | { |
206 | ccv_dpm_part_classifier_t* part_classifier = root_classifier->part + j; |
207 | fprintf(w, "%d %d %d\n", part_classifier->x, part_classifier->y, part_classifier->z); |
208 | fprintf(w, "%la %la %la %la\n", part_classifier->dx, part_classifier->dy, part_classifier->dxx, part_classifier->dyy); |
209 | fprintf(w, "%a %a %a %a %a %a\n", part_classifier->alpha[0], part_classifier->alpha[1], part_classifier->alpha[2], part_classifier->alpha[3], part_classifier->alpha[4], part_classifier->alpha[5]); |
210 | fprintf(w, "%d %d %d\n", part_classifier->w->rows, part_classifier->w->cols, part_classifier->counterpart); |
211 | ch = CCV_GET_CHANNEL(part_classifier->w->type)((part_classifier->w->type) & 0xFFF); |
212 | for (y = 0; y < part_classifier->w->rows; y++) |
213 | { |
214 | for (x = 0; x < part_classifier->w->cols * ch; x++) |
215 | fprintf(w, "%a ", part_classifier->w->data.f32[y * part_classifier->w->cols * ch + x]); |
216 | fprintf(w, "\n"); |
217 | } |
218 | } |
219 | } |
220 | fclose(w); |
221 | rename(swpfile, dir); |
222 | } |
223 | |
224 | static void _ccv_dpm_read_checkpoint(ccv_dpm_mixture_model_t* model, const char* dir) |
225 | { |
226 | FILE* r = fopen(dir, "r"); |
227 | if (!r) |
228 | return; |
229 | int count; |
230 | char flag; |
231 | fscanf(r, "%c", &flag); |
232 | assert(flag == ',')((void) sizeof ((flag == ',') ? 1 : 0), __extension__ ({ if ( flag == ',') ; else __assert_fail ("flag == ','", "ccv_dpm.c" , 232, __extension__ __PRETTY_FUNCTION__); })); |
233 | fscanf(r, "%d %d", &model->count, &count); |
234 | ccv_dpm_root_classifier_t* root_classifier = (ccv_dpm_root_classifier_t*)ccmallocmalloc(sizeof(ccv_dpm_root_classifier_t) * count); |
235 | memset(root_classifier, 0, sizeof(ccv_dpm_root_classifier_t) * count); |
236 | int i, j, k; |
237 | for (i = 0; i < count; i++) |
238 | { |
239 | int rows, cols; |
240 | fscanf(r, "%d %d", &rows, &cols); |
241 | fscanf(r, "%f %f %f %f", &root_classifier[i].beta, &root_classifier[i].alpha[0], &root_classifier[i].alpha[1], &root_classifier[i].alpha[2]); |
242 | root_classifier[i].root.w = ccv_dense_matrix_new(rows, cols, CCV_32F | 31, 0, 0); |
243 | for (j = 0; j < rows * cols * 31; j++) |
244 | fscanf(r, "%f", &root_classifier[i].root.w->data.f32[j]); |
245 | ccv_make_matrix_immutable(root_classifier[i].root.w); |
246 | fscanf(r, "%d", &root_classifier[i].count); |
247 | if (root_classifier[i].count <= 0) |
248 | { |
249 | root_classifier[i].part = 0; |
250 | continue; |
251 | } |
252 | ccv_dpm_part_classifier_t* part_classifier = (ccv_dpm_part_classifier_t*)ccmallocmalloc(sizeof(ccv_dpm_part_classifier_t) * root_classifier[i].count); |
253 | for (j = 0; j < root_classifier[i].count; j++) |
254 | { |
255 | fscanf(r, "%d %d %d", &part_classifier[j].x, &part_classifier[j].y, &part_classifier[j].z); |
256 | fscanf(r, "%lf %lf %lf %lf", &part_classifier[j].dx, &part_classifier[j].dy, &part_classifier[j].dxx, &part_classifier[j].dyy); |
257 | fscanf(r, "%f %f %f %f %f %f", &part_classifier[j].alpha[0], &part_classifier[j].alpha[1], &part_classifier[j].alpha[2], &part_classifier[j].alpha[3], &part_classifier[j].alpha[4], &part_classifier[j].alpha[5]); |
258 | fscanf(r, "%d %d %d", &rows, &cols, &part_classifier[j].counterpart); |
259 | part_classifier[j].w = ccv_dense_matrix_new(rows, cols, CCV_32F | 31, 0, 0); |
260 | for (k = 0; k < rows * cols * 31; k++) |
261 | fscanf(r, "%f", &part_classifier[j].w->data.f32[k]); |
262 | ccv_make_matrix_immutable(part_classifier[j].w); |
263 | } |
264 | root_classifier[i].part = part_classifier; |
265 | } |
266 | model->root = root_classifier; |
267 | fclose(r); |
268 | } |
269 | |
270 | static void _ccv_dpm_mixture_model_cleanup(ccv_dpm_mixture_model_t* model) |
271 | { |
272 | /* this is different because it doesn't compress to a continuous memory region */ |
273 | int i, j; |
274 | for (i = 0; i < model->count; i++) |
275 | { |
276 | ccv_dpm_root_classifier_t* root_classifier = model->root + i; |
277 | for (j = 0; j < root_classifier->count; j++) |
278 | { |
279 | ccv_dpm_part_classifier_t* part_classifier = root_classifier->part + j; |
280 | ccv_matrix_free(part_classifier->w); |
281 | } |
282 | if (root_classifier->count > 0) |
283 | ccfreefree(root_classifier->part); |
284 | if (root_classifier->root.w != 0) |
285 | ccv_matrix_free(root_classifier->root.w); |
286 | } |
287 | ccfreefree(model->root); |
288 | model->count = 0; |
289 | model->root = 0; |
290 | } |
291 | |
292 | static const int _ccv_dpm_sym_lut[] = { 2, 3, 0, 1, |
293 | 4 + 0, 4 + 8, 4 + 7, 4 + 6, 4 + 5, 4 + 4, 4 + 3, 4 + 2, 4 + 1, |
294 | 13 + 9, 13 + 8, 13 + 7, 13 + 6, 13 + 5, 13 + 4, 13 + 3, 13 + 2, 13 + 1, 13, 13 + 17, 13 + 16, 13 + 15, 13 + 14, 13 + 13, 13 + 12, 13 + 11, 13 + 10 }; |
295 | |
296 | static void _ccv_dpm_check_root_classifier_symmetry(ccv_dense_matrix_t* w) |
297 | { |
298 | assert(CCV_GET_CHANNEL(w->type) == 31 && CCV_GET_DATA_TYPE(w->type) == CCV_32F)((void) sizeof ((((w->type) & 0xFFF) == 31 && ( (w->type) & 0xFF000) == CCV_32F) ? 1 : 0), __extension__ ({ if (((w->type) & 0xFFF) == 31 && ((w->type ) & 0xFF000) == CCV_32F) ; else __assert_fail ("CCV_GET_CHANNEL(w->type) == 31 && CCV_GET_DATA_TYPE(w->type) == CCV_32F" , "ccv_dpm.c", 298, __extension__ __PRETTY_FUNCTION__); })); |
299 | float *w_ptr = w->data.f32; |
300 | int i, j, k; |
301 | for (i = 0; i < w->rows; i++) |
302 | { |
303 | for (j = 0; j < w->cols; j++) |
304 | { |
305 | for (k = 0; k < 31; k++) |
306 | { |
307 | double v = fabs(w_ptr[j * 31 + k] - w_ptr[(w->cols - 1 - j) * 31 + _ccv_dpm_sym_lut[k]]); |
308 | if (v > 0.002) |
309 | PRINT(CCV_CLI_INFO, "symmetric violation at (%d, %d, %d), off by: %f\n", i, j, k, v)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("symmetric violation at (%d, %d, %d), off by: %f\n", i, j, k , v); fflush(stdout); } } while (0); |
310 | } |
311 | } |
312 | w_ptr += w->cols * 31; |
313 | } |
314 | } |
315 | |
316 | typedef struct { |
317 | int id; |
318 | int count; |
319 | float score; |
320 | int x, y; |
321 | float scale_x, scale_y; |
322 | ccv_dpm_part_classifier_t root; |
323 | ccv_dpm_part_classifier_t* part; |
324 | } ccv_dpm_feature_vector_t; |
325 | |
326 | static void _ccv_dpm_collect_examples_randomly(gsl_rng* rng, ccv_array_t** negex, char** bgfiles, int bgnum, int negnum, int components, int* rows, int* cols, int grayscale) |
327 | { |
328 | int i, j; |
329 | for (i = 0; i < components; i++) |
330 | negex[i] = ccv_array_new(sizeof(ccv_dpm_feature_vector_t), negnum, 0); |
331 | int mrows = rows[0], mcols = cols[0]; |
332 | for (i = 1; i < components; i++) |
333 | { |
334 | mrows = ccv_max(mrows, rows[i])({ typeof (mrows) _a = (mrows); typeof (rows[i]) _b = (rows[i ]); (_a > _b) ? _a : _b; }); |
335 | mcols = ccv_max(mcols, cols[i])({ typeof (mcols) _a = (mcols); typeof (cols[i]) _b = (cols[i ]); (_a > _b) ? _a : _b; }); |
336 | } |
337 | FLUSH(CCV_CLI_INFO, " - generating negative examples for all models : 0 / %d", negnum)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf("\b"); for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf(" "); for ( _CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP ++) printf("\b"); _CCV_PRINT_COUNT = printf(" - generating negative examples for all models : 0 / %d" , negnum); fflush(stdout); } } while (0); |
338 | while (negex[0]->rnum < negnum) |
339 | { |
340 | double p = (double)negnum / (double)bgnum; |
341 | for (i = 0; i < bgnum; i++) |
342 | if (gsl_rng_uniform(rng) < p) |
343 | { |
344 | ccv_dense_matrix_t* image = 0; |
345 | ccv_read(bgfiles[i], &image, (grayscale ? CCV_IO_GRAY : 0) | CCV_IO_ANY_FILE)ccv_read_impl(bgfiles[i], &image, (grayscale ? CCV_IO_GRAY : 0) | CCV_IO_ANY_FILE, 0, 0, 0); |
346 | assert(image != 0)((void) sizeof ((image != 0) ? 1 : 0), __extension__ ({ if (image != 0) ; else __assert_fail ("image != 0", "ccv_dpm.c", 346, __extension__ __PRETTY_FUNCTION__); })); |
347 | if (image->rows - mrows * CCV_DPM_WINDOW_SIZE(8) < 0 || |
348 | image->cols - mcols * CCV_DPM_WINDOW_SIZE(8) < 0) |
349 | { |
350 | ccv_matrix_free(image); |
351 | continue; |
352 | } |
353 | int y = gsl_rng_uniform_int(rng, image->rows - mrows * CCV_DPM_WINDOW_SIZE(8) + 1); |
354 | int x = gsl_rng_uniform_int(rng, image->cols - mcols * CCV_DPM_WINDOW_SIZE(8) + 1); |
355 | for (j = 0; j < components; j++) |
356 | { |
357 | ccv_dense_matrix_t* slice = 0; |
358 | ccv_slice(image, (ccv_matrix_t**)&slice, 0, y + ((mrows - rows[j]) * CCV_DPM_WINDOW_SIZE(8) + 1) / 2, x + ((mcols - cols[j]) * CCV_DPM_WINDOW_SIZE(8) + 1) / 2, rows[j] * CCV_DPM_WINDOW_SIZE(8), cols[j] * CCV_DPM_WINDOW_SIZE(8)); |
359 | assert(y + ((mrows - rows[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 >= 0 &&((void) sizeof ((y + ((mrows - rows[j]) * (8) + 1) / 2 >= 0 && y + ((mrows - rows[j]) * (8) + 1) / 2 + rows[j] * (8) <= image->rows && x + ((mcols - cols[j]) * (8) + 1) / 2 >= 0 && x + ((mcols - cols[j]) * (8) + 1) / 2 + cols[j] * (8) <= image->cols) ? 1 : 0), __extension__ ({ if (y + ((mrows - rows[j]) * (8) + 1) / 2 >= 0 && y + ((mrows - rows[j]) * (8) + 1) / 2 + rows[j] * (8) <= image ->rows && x + ((mcols - cols[j]) * (8) + 1) / 2 >= 0 && x + ((mcols - cols[j]) * (8) + 1) / 2 + cols[j] * (8) <= image->cols) ; else __assert_fail ("y + ((mrows - rows[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 >= 0 && y + ((mrows - rows[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 + rows[j] * CCV_DPM_WINDOW_SIZE <= image->rows && x + ((mcols - cols[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 >= 0 && x + ((mcols - cols[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 + cols[j] * CCV_DPM_WINDOW_SIZE <= image->cols" , "ccv_dpm.c", 362, __extension__ __PRETTY_FUNCTION__); })) |
360 | y + ((mrows - rows[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 + rows[j] * CCV_DPM_WINDOW_SIZE <= image->rows &&((void) sizeof ((y + ((mrows - rows[j]) * (8) + 1) / 2 >= 0 && y + ((mrows - rows[j]) * (8) + 1) / 2 + rows[j] * (8) <= image->rows && x + ((mcols - cols[j]) * (8) + 1) / 2 >= 0 && x + ((mcols - cols[j]) * (8) + 1) / 2 + cols[j] * (8) <= image->cols) ? 1 : 0), __extension__ ({ if (y + ((mrows - rows[j]) * (8) + 1) / 2 >= 0 && y + ((mrows - rows[j]) * (8) + 1) / 2 + rows[j] * (8) <= image ->rows && x + ((mcols - cols[j]) * (8) + 1) / 2 >= 0 && x + ((mcols - cols[j]) * (8) + 1) / 2 + cols[j] * (8) <= image->cols) ; else __assert_fail ("y + ((mrows - rows[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 >= 0 && y + ((mrows - rows[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 + rows[j] * CCV_DPM_WINDOW_SIZE <= image->rows && x + ((mcols - cols[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 >= 0 && x + ((mcols - cols[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 + cols[j] * CCV_DPM_WINDOW_SIZE <= image->cols" , "ccv_dpm.c", 362, __extension__ __PRETTY_FUNCTION__); })) |
361 | x + ((mcols - cols[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 >= 0 &&((void) sizeof ((y + ((mrows - rows[j]) * (8) + 1) / 2 >= 0 && y + ((mrows - rows[j]) * (8) + 1) / 2 + rows[j] * (8) <= image->rows && x + ((mcols - cols[j]) * (8) + 1) / 2 >= 0 && x + ((mcols - cols[j]) * (8) + 1) / 2 + cols[j] * (8) <= image->cols) ? 1 : 0), __extension__ ({ if (y + ((mrows - rows[j]) * (8) + 1) / 2 >= 0 && y + ((mrows - rows[j]) * (8) + 1) / 2 + rows[j] * (8) <= image ->rows && x + ((mcols - cols[j]) * (8) + 1) / 2 >= 0 && x + ((mcols - cols[j]) * (8) + 1) / 2 + cols[j] * (8) <= image->cols) ; else __assert_fail ("y + ((mrows - rows[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 >= 0 && y + ((mrows - rows[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 + rows[j] * CCV_DPM_WINDOW_SIZE <= image->rows && x + ((mcols - cols[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 >= 0 && x + ((mcols - cols[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 + cols[j] * CCV_DPM_WINDOW_SIZE <= image->cols" , "ccv_dpm.c", 362, __extension__ __PRETTY_FUNCTION__); })) |
362 | x + ((mcols - cols[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 + cols[j] * CCV_DPM_WINDOW_SIZE <= image->cols)((void) sizeof ((y + ((mrows - rows[j]) * (8) + 1) / 2 >= 0 && y + ((mrows - rows[j]) * (8) + 1) / 2 + rows[j] * (8) <= image->rows && x + ((mcols - cols[j]) * (8) + 1) / 2 >= 0 && x + ((mcols - cols[j]) * (8) + 1) / 2 + cols[j] * (8) <= image->cols) ? 1 : 0), __extension__ ({ if (y + ((mrows - rows[j]) * (8) + 1) / 2 >= 0 && y + ((mrows - rows[j]) * (8) + 1) / 2 + rows[j] * (8) <= image ->rows && x + ((mcols - cols[j]) * (8) + 1) / 2 >= 0 && x + ((mcols - cols[j]) * (8) + 1) / 2 + cols[j] * (8) <= image->cols) ; else __assert_fail ("y + ((mrows - rows[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 >= 0 && y + ((mrows - rows[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 + rows[j] * CCV_DPM_WINDOW_SIZE <= image->rows && x + ((mcols - cols[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 >= 0 && x + ((mcols - cols[j]) * CCV_DPM_WINDOW_SIZE + 1) / 2 + cols[j] * CCV_DPM_WINDOW_SIZE <= image->cols" , "ccv_dpm.c", 362, __extension__ __PRETTY_FUNCTION__); })); |
363 | ccv_dense_matrix_t* hog = 0; |
364 | ccv_hog(slice, &hog, 0, 9, CCV_DPM_WINDOW_SIZE(8)); |
365 | ccv_matrix_free(slice); |
366 | ccv_dpm_feature_vector_t vector = { |
367 | .id = j, |
368 | .count = 0, |
369 | .part = 0, |
370 | }; |
371 | ccv_make_matrix_mutable(hog); |
372 | assert(hog->rows == rows[j] && hog->cols == cols[j] && CCV_GET_CHANNEL(hog->type) == 31 && CCV_GET_DATA_TYPE(hog->type) == CCV_32F)((void) sizeof ((hog->rows == rows[j] && hog->cols == cols[j] && ((hog->type) & 0xFFF) == 31 && ((hog->type) & 0xFF000) == CCV_32F) ? 1 : 0), __extension__ ({ if (hog->rows == rows[j] && hog->cols == cols [j] && ((hog->type) & 0xFFF) == 31 && ( (hog->type) & 0xFF000) == CCV_32F) ; else __assert_fail ("hog->rows == rows[j] && hog->cols == cols[j] && CCV_GET_CHANNEL(hog->type) == 31 && CCV_GET_DATA_TYPE(hog->type) == CCV_32F" , "ccv_dpm.c", 372, __extension__ __PRETTY_FUNCTION__); })); |
373 | vector.root.w = hog; |
374 | ccv_array_push(negex[j], &vector); |
375 | } |
376 | ccv_matrix_free(image); |
377 | FLUSH(CCV_CLI_INFO, " - generating negative examples for all models : %d / %d", negex[0]->rnum, negnum)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf("\b"); for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf(" "); for ( _CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP ++) printf("\b"); _CCV_PRINT_COUNT = printf(" - generating negative examples for all models : %d / %d" , negex[0]->rnum, negnum); fflush(stdout); } } while (0); |
378 | if (negex[0]->rnum >= negnum) |
379 | break; |
380 | } |
381 | } |
382 | } |
383 | |
384 | static ccv_array_t* _ccv_dpm_summon_examples_by_rectangle(char** posfiles, ccv_rect_t* bboxes, int posnum, int id, int rows, int cols, int grayscale) |
385 | { |
386 | int i; |
387 | FLUSH(CCV_CLI_INFO, " - generating positive examples for model %d : 0 / %d", id, posnum)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf("\b"); for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf(" "); for ( _CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP ++) printf("\b"); _CCV_PRINT_COUNT = printf(" - generating positive examples for model %d : 0 / %d" , id, posnum); fflush(stdout); } } while (0); |
388 | ccv_array_t* posv = ccv_array_new(sizeof(ccv_dpm_feature_vector_t), posnum, 0); |
389 | for (i = 0; i < posnum; i++) |
390 | { |
391 | ccv_rect_t bbox = bboxes[i]; |
392 | int mcols = (int)(sqrtf(bbox.width * bbox.height * cols / (float)rows) + 0.5); |
393 | int mrows = (int)(sqrtf(bbox.width * bbox.height * rows / (float)cols) + 0.5); |
394 | bbox.x = bbox.x + (bbox.width - mcols) / 2; |
395 | bbox.y = bbox.y + (bbox.height - mrows) / 2; |
396 | bbox.width = mcols; |
397 | bbox.height = mrows; |
398 | ccv_dpm_feature_vector_t vector = { |
399 | .id = id, |
400 | .count = 0, |
401 | .part = 0, |
402 | }; |
403 | // resolution is too low to be useful |
404 | if (mcols * 2 < cols * CCV_DPM_WINDOW_SIZE(8) || mrows * 2 < rows * CCV_DPM_WINDOW_SIZE(8)) |
405 | { |
406 | vector.root.w = 0; |
407 | ccv_array_push(posv, &vector); |
408 | continue; |
409 | } |
410 | ccv_dense_matrix_t* image = 0; |
411 | ccv_read(posfiles[i], &image, (grayscale ? CCV_IO_GRAY : 0) | CCV_IO_ANY_FILE)ccv_read_impl(posfiles[i], &image, (grayscale ? CCV_IO_GRAY : 0) | CCV_IO_ANY_FILE, 0, 0, 0); |
412 | assert(image != 0)((void) sizeof ((image != 0) ? 1 : 0), __extension__ ({ if (image != 0) ; else __assert_fail ("image != 0", "ccv_dpm.c", 412, __extension__ __PRETTY_FUNCTION__); })); |
413 | ccv_dense_matrix_t* up2x = 0; |
414 | ccv_sample_up(image, &up2x, 0, 0, 0); |
415 | ccv_matrix_free(image); |
416 | ccv_dense_matrix_t* slice = 0; |
417 | ccv_slice(up2x, (ccv_matrix_t**)&slice, 0, bbox.y * 2, bbox.x * 2, bbox.height * 2, bbox.width * 2); |
418 | ccv_matrix_free(up2x); |
419 | ccv_dense_matrix_t* resize = 0; |
420 | ccv_resample(slice, &resize, 0, (double)(rows * CCV_DPM_WINDOW_SIZE(8)) / (double)slice->rows, (double)(cols * CCV_DPM_WINDOW_SIZE(8)) / (double)slice->cols, CCV_INTER_AREA); |
421 | ccv_matrix_free(slice); |
422 | ccv_dense_matrix_t* hog = 0; |
423 | ccv_hog(resize, &hog, 0, 9, CCV_DPM_WINDOW_SIZE(8)); |
424 | ccv_matrix_free(resize); |
425 | ccv_make_matrix_mutable(hog); |
426 | assert(hog->rows == rows && hog->cols == cols && CCV_GET_CHANNEL(hog->type) == 31 && CCV_GET_DATA_TYPE(hog->type) == CCV_32F)((void) sizeof ((hog->rows == rows && hog->cols == cols && ((hog->type) & 0xFFF) == 31 && ((hog->type) & 0xFF000) == CCV_32F) ? 1 : 0), __extension__ ({ if (hog->rows == rows && hog->cols == cols && ((hog->type) & 0xFFF) == 31 && ((hog->type ) & 0xFF000) == CCV_32F) ; else __assert_fail ("hog->rows == rows && hog->cols == cols && CCV_GET_CHANNEL(hog->type) == 31 && CCV_GET_DATA_TYPE(hog->type) == CCV_32F" , "ccv_dpm.c", 426, __extension__ __PRETTY_FUNCTION__); })); |
427 | vector.root.w = hog; |
428 | ccv_array_push(posv, &vector); |
429 | FLUSH(CCV_CLI_INFO, " - generating positive examples for model %d : %d / %d", id, i + 1, posnum)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf("\b"); for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf(" "); for ( _CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP ++) printf("\b"); _CCV_PRINT_COUNT = printf(" - generating positive examples for model %d : %d / %d" , id, i + 1, posnum); fflush(stdout); } } while (0); |
430 | } |
431 | return posv; |
432 | } |
433 | |
434 | static void _ccv_dpm_initialize_root_classifier(gsl_rng* rng, ccv_dpm_root_classifier_t* root_classifier, int label, int cnum, int* poslabels, ccv_array_t* posex, int* neglabels, ccv_array_t* negex, double C, int symmetric, int grayscale) |
435 | { |
436 | int i, j, x, y, k, l; |
437 | int cols = root_classifier->root.w->cols; |
438 | int cols2c = (cols + 1) / 2; |
439 | int rows = root_classifier->root.w->rows; |
440 | PRINT(CCV_CLI_INFO, " - creating initial model %d at %dx%d\n", label + 1, cols, rows)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (" - creating initial model %d at %dx%d\n", label + 1, cols, rows ); fflush(stdout); } } while (0); |
441 | struct problem prob; |
442 | prob.n = symmetric ? 31 * cols2c * rows + 1 : 31 * cols * rows + 1; |
443 | prob.bias = symmetric ? 0.5 : 1.0; // for symmetric, since we only pass half features in, need to set bias to be half too |
444 | // new version (1.91) of liblinear uses double instead of int (1.8) for prob.y, cannot cast for that. |
445 | prob.y = malloc(sizeof(prob.y[0]) * (cnum + negex->rnum) * (!!symmetric + 1)); |
446 | prob.x = (struct feature_node**)malloc(sizeof(struct feature_node*) * (cnum + negex->rnum) * (!!symmetric + 1)); |
447 | FLUSH(CCV_CLI_INFO, " - converting examples to liblinear format: %d / %d", 0, (cnum + negex->rnum) * (!!symmetric + 1))do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf("\b"); for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf(" "); for ( _CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP ++) printf("\b"); _CCV_PRINT_COUNT = printf(" - converting examples to liblinear format: %d / %d" , 0, (cnum + negex->rnum) * (!!symmetric + 1)); fflush(stdout ); } } while (0); |
448 | l = 0; |
449 | for (i = 0; i < posex->rnum; i++) |
450 | if (poslabels[i] == label) |
451 | { |
452 | ccv_dense_matrix_t* hog = ((ccv_dpm_feature_vector_t*)ccv_array_get(posex, i)((void*)(((char*)((posex)->data)) + (size_t)(posex)->rsize * (size_t)(i))))->root.w; |
453 | if (!hog) |
454 | continue; |
455 | struct feature_node* features; |
456 | if (symmetric) |
457 | { |
458 | features = (struct feature_node*)malloc(sizeof(struct feature_node) * (31 * cols2c * rows + 2)); |
459 | float* hptr = hog->data.f32; |
460 | j = 0; |
461 | for (y = 0; y < rows; y++) |
462 | { |
463 | for (x = 0; x < cols2c; x++) |
464 | for (k = 0; k < 31; k++) |
465 | { |
466 | features[j].index = j + 1; |
467 | features[j].value = hptr[x * 31 + k]; |
468 | ++j; |
469 | } |
470 | hptr += hog->cols * 31; |
471 | } |
472 | features[j].index = j + 1; |
473 | features[j].value = prob.bias; |
474 | features[j + 1].index = -1; |
475 | prob.x[l] = features; |
476 | prob.y[l] = 1; |
477 | ++l; |
478 | features = (struct feature_node*)malloc(sizeof(struct feature_node) * (31 * cols2c * rows + 2)); |
479 | hptr = hog->data.f32; |
480 | j = 0; |
481 | for (y = 0; y < rows; y++) |
482 | { |
483 | for (x = 0; x < cols2c; x++) |
484 | for (k = 0; k < 31; k++) |
485 | { |
486 | features[j].index = j + 1; |
487 | features[j].value = hptr[(cols - 1 - x) * 31 + _ccv_dpm_sym_lut[k]]; |
488 | ++j; |
489 | } |
490 | hptr += hog->cols * 31; |
491 | } |
492 | features[j].index = j + 1; |
493 | features[j].value = prob.bias; |
494 | features[j + 1].index = -1; |
495 | prob.x[l] = features; |
496 | prob.y[l] = 1; |
497 | ++l; |
498 | } else { |
499 | features = (struct feature_node*)malloc(sizeof(struct feature_node) * (31 * cols * rows + 2)); |
500 | for (j = 0; j < rows * cols * 31; j++) |
501 | { |
502 | features[j].index = j + 1; |
503 | features[j].value = hog->data.f32[j]; |
504 | } |
505 | features[31 * rows * cols].index = 31 * rows * cols + 1; |
506 | features[31 * rows * cols].value = prob.bias; |
507 | features[31 * rows * cols + 1].index = -1; |
508 | prob.x[l] = features; |
509 | prob.y[l] = 1; |
510 | ++l; |
511 | } |
512 | FLUSH(CCV_CLI_INFO, " - converting examples to liblinear format: %d / %d", l, (cnum + negex->rnum) * (!!symmetric + 1))do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf("\b"); for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf(" "); for ( _CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP ++) printf("\b"); _CCV_PRINT_COUNT = printf(" - converting examples to liblinear format: %d / %d" , l, (cnum + negex->rnum) * (!!symmetric + 1)); fflush(stdout ); } } while (0); |
513 | } |
514 | for (i = 0; i < negex->rnum; i++) |
515 | if (neglabels[i] == label) |
516 | { |
517 | ccv_dense_matrix_t* hog = ((ccv_dpm_feature_vector_t*)ccv_array_get(negex, i)((void*)(((char*)((negex)->data)) + (size_t)(negex)->rsize * (size_t)(i))))->root.w; |
518 | struct feature_node* features; |
519 | if (symmetric) |
520 | { |
521 | features = (struct feature_node*)malloc(sizeof(struct feature_node) * (31 * cols2c * rows + 2)); |
522 | float* hptr = hog->data.f32; |
523 | j = 0; |
524 | for (y = 0; y < rows; y++) |
525 | { |
526 | for (x = 0; x < cols2c; x++) |
527 | for (k = 0; k < 31; k++) |
528 | { |
529 | features[j].index = j + 1; |
530 | features[j].value = hptr[x * 31 + k]; |
531 | ++j; |
532 | } |
533 | hptr += hog->cols * 31; |
534 | } |
535 | features[j].index = j + 1; |
536 | features[j].value = prob.bias; |
537 | features[j + 1].index = -1; |
538 | prob.x[l] = features; |
539 | prob.y[l] = -1; |
540 | ++l; |
541 | features = (struct feature_node*)malloc(sizeof(struct feature_node) * (31 * cols2c * rows + 2)); |
542 | hptr = hog->data.f32; |
543 | j = 0; |
544 | for (y = 0; y < rows; y++) |
545 | { |
546 | for (x = 0; x < cols2c; x++) |
547 | for (k = 0; k < 31; k++) |
548 | { |
549 | features[j].index = j + 1; |
550 | features[j].value = hptr[(cols - 1 - x) * 31 + _ccv_dpm_sym_lut[k]]; |
551 | ++j; |
552 | } |
553 | hptr += hog->cols * 31; |
554 | } |
555 | features[j].index = j + 1; |
556 | features[j].value = prob.bias; |
557 | features[j + 1].index = -1; |
558 | prob.x[l] = features; |
559 | prob.y[l] = -1; |
560 | ++l; |
561 | } else { |
562 | features = (struct feature_node*)malloc(sizeof(struct feature_node) * (31 * cols * rows + 2)); |
563 | for (j = 0; j < 31 * rows * cols; j++) |
564 | { |
565 | features[j].index = j + 1; |
566 | features[j].value = hog->data.f32[j]; |
567 | } |
568 | features[31 * rows * cols].index = 31 * rows * cols + 1; |
569 | features[31 * rows * cols].value = prob.bias; |
570 | features[31 * rows * cols + 1].index = -1; |
571 | prob.x[l] = features; |
572 | prob.y[l] = -1; |
573 | ++l; |
574 | } |
575 | FLUSH(CCV_CLI_INFO, " - converting examples to liblinear format: %d / %d", l, (cnum + negex->rnum) * (!!symmetric + 1))do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf("\b"); for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf(" "); for ( _CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP ++) printf("\b"); _CCV_PRINT_COUNT = printf(" - converting examples to liblinear format: %d / %d" , l, (cnum + negex->rnum) * (!!symmetric + 1)); fflush(stdout ); } } while (0); |
576 | } |
577 | prob.l = l; |
578 | PRINT(CCV_CLI_INFO, "\n - generated %d examples with %d dimensions each\n"do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("\n - generated %d examples with %d dimensions each\n" " - running liblinear for initial linear SVM model (L2-regularized, L1-loss)\n" , prob.l, prob.n); fflush(stdout); } } while (0) |
579 | " - running liblinear for initial linear SVM model (L2-regularized, L1-loss)\n", prob.l, prob.n)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("\n - generated %d examples with %d dimensions each\n" " - running liblinear for initial linear SVM model (L2-regularized, L1-loss)\n" , prob.l, prob.n); fflush(stdout); } } while (0); |
580 | struct parameter linear_parameters = { .solver_type = L2R_L1LOSS_SVC_DUAL, |
581 | .eps = 1e-1, |
582 | .C = C, |
583 | .nr_weight = 0, |
584 | .weight_label = 0, |
585 | .weight = 0 }; |
586 | const char* err = check_parameter(&prob, &linear_parameters); |
587 | if (err) |
588 | { |
589 | PRINT(CCV_CLI_ERROR, " - ERROR: cannot pass check parameter: %s\n", err)do { if ((CCV_CLI_ERROR & ccv_cli_get_output_levels())) { printf(" - ERROR: cannot pass check parameter: %s\n", err); fflush (stdout); } } while (0); |
590 | exit(-1); |
591 | } |
592 | struct model* linear = train(&prob, &linear_parameters); |
593 | assert(linear != 0)((void) sizeof ((linear != 0) ? 1 : 0), __extension__ ({ if ( linear != 0) ; else __assert_fail ("linear != 0", "ccv_dpm.c" , 593, __extension__ __PRETTY_FUNCTION__); })); |
594 | PRINT(CCV_CLI_INFO, " - model->label[0]: %d, model->nr_class: %d, model->nr_feature: %d\n", linear->label[0], linear->nr_class, linear->nr_feature)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (" - model->label[0]: %d, model->nr_class: %d, model->nr_feature: %d\n" , linear->label[0], linear->nr_class, linear->nr_feature ); fflush(stdout); } } while (0); |
595 | if (symmetric) |
596 | { |
597 | float* wptr = root_classifier->root.w->data.f32; |
598 | for (y = 0; y < rows; y++) |
599 | { |
600 | for (x = 0; x < cols2c; x++) |
601 | for (k = 0; k < 31; k++) |
602 | wptr[(cols - 1 - x) * 31 + _ccv_dpm_sym_lut[k]] = wptr[x * 31 + k] = linear->w[(y * cols2c + x) * 31 + k]; |
603 | wptr += cols * 31; |
604 | } |
605 | // since for symmetric, lsvm only computed half features, to compensate that, we doubled the constant. |
606 | root_classifier->beta = linear->w[31 * rows * cols2c] * 2.0; |
607 | } else { |
608 | for (j = 0; j < 31 * rows * cols; j++) |
609 | root_classifier->root.w->data.f32[j] = linear->w[j]; |
610 | root_classifier->beta = linear->w[31 * rows * cols]; |
611 | } |
612 | free_and_destroy_model(&linear); |
613 | free(prob.y); |
614 | for (j = 0; j < prob.l; j++) |
615 | free(prob.x[j]); |
616 | free(prob.x); |
617 | ccv_make_matrix_immutable(root_classifier->root.w); |
618 | } |
619 | |
620 | static void _ccv_dpm_initialize_part_classifiers(ccv_dpm_root_classifier_t* root_classifier, int parts, int symmetric) |
621 | { |
622 | int i, j, k, x, y; |
623 | ccv_dense_matrix_t* w = 0; |
624 | ccv_sample_up(root_classifier->root.w, &w, 0, 0, 0); |
625 | ccv_make_matrix_mutable(w); |
626 | root_classifier->count = parts; |
627 | root_classifier->part = (ccv_dpm_part_classifier_t*)ccmallocmalloc(sizeof(ccv_dpm_part_classifier_t) * parts); |
628 | memset(root_classifier->part, 0, sizeof(ccv_dpm_part_classifier_t) * parts); |
629 | double area = w->rows * w->cols / (double)parts; |
630 | for (i = 0; i < parts;) |
631 | { |
632 | ccv_dpm_part_classifier_t* part_classifier = root_classifier->part + i; |
633 | int dx = 0, dy = 0, dw = 0, dh = 0, sym = 0; |
634 | double dsum = -1.0; // absolute value, thus, -1.0 is enough |
635 | #define slice_and_update_if_needed(y, x, l, n, s){ ccv_dense_matrix_t* slice = 0; ccv_slice(w, (ccv_matrix_t** )&slice, 0, y, x, l, n); double sum = ccv_sum(slice, CCV_UNSIGNED ) / (double)(l * n); if (sum > dsum) { dsum = sum; dx = x; dy = y; dw = n; dh = l; sym = s; } ccv_matrix_free(slice); } \ |
636 | { \ |
637 | ccv_dense_matrix_t* slice = 0; \ |
638 | ccv_slice(w, (ccv_matrix_t**)&slice, 0, y, x, l, n); \ |
639 | double sum = ccv_sum(slice, CCV_UNSIGNED) / (double)(l * n); \ |
640 | if (sum > dsum) \ |
641 | { \ |
642 | dsum = sum; \ |
643 | dx = x; \ |
644 | dy = y; \ |
645 | dw = n; \ |
646 | dh = l; \ |
647 | sym = s; \ |
648 | } \ |
649 | ccv_matrix_free(slice); \ |
650 | } |
651 | for (j = 1; (j < area + 1) && (j * 3 <= w->rows * 2); j++) |
652 | { |
653 | k = (int)(area / j + 0.5); |
654 | if (k < 1 || k * 3 > w->cols * 2) |
655 | continue; |
656 | if (j > k * 2 || k > j * 2) |
657 | continue; |
658 | if (symmetric) |
659 | { |
660 | if (k % 2 == w->cols % 2) // can be symmetric in horizontal center |
661 | { |
662 | x = (w->cols - k) / 2; |
663 | for (y = 0; y < w->rows - j + 1; y++) |
664 | slice_and_update_if_needed(y, x, j, k, 0){ ccv_dense_matrix_t* slice = 0; ccv_slice(w, (ccv_matrix_t** )&slice, 0, y, x, j, k); double sum = ccv_sum(slice, CCV_UNSIGNED ) / (double)(j * k); if (sum > dsum) { dsum = sum; dx = x; dy = y; dw = k; dh = j; sym = 0; } ccv_matrix_free(slice); }; |
665 | } |
666 | if (i < parts - 1) // have 2 locations |
667 | { |
668 | for (y = 0; y < w->rows - j + 1; y++) |
669 | for (x = 0; x <= w->cols / 2 - k /* to avoid overlapping */; x++) |
670 | slice_and_update_if_needed(y, x, j, k, 1){ ccv_dense_matrix_t* slice = 0; ccv_slice(w, (ccv_matrix_t** )&slice, 0, y, x, j, k); double sum = ccv_sum(slice, CCV_UNSIGNED ) / (double)(j * k); if (sum > dsum) { dsum = sum; dx = x; dy = y; dw = k; dh = j; sym = 1; } ccv_matrix_free(slice); }; |
671 | } |
672 | } else { |
673 | for (y = 0; y < w->rows - j + 1; y++) |
674 | for (x = 0; x < w->cols - k + 1; x++) |
675 | slice_and_update_if_needed(y, x, j, k, 0){ ccv_dense_matrix_t* slice = 0; ccv_slice(w, (ccv_matrix_t** )&slice, 0, y, x, j, k); double sum = ccv_sum(slice, CCV_UNSIGNED ) / (double)(j * k); if (sum > dsum) { dsum = sum; dx = x; dy = y; dw = k; dh = j; sym = 0; } ccv_matrix_free(slice); }; |
676 | } |
677 | } |
678 | PRINT(CCV_CLI_INFO, " ---- part %d(%d) %dx%d at (%d,%d), entropy: %lf\n", i + 1, parts, dw, dh, dx, dy, dsum)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (" ---- part %d(%d) %dx%d at (%d,%d), entropy: %lf\n", i + 1, parts, dw, dh, dx, dy, dsum); fflush(stdout); } } while (0); |
679 | part_classifier->dx = 0; |
680 | part_classifier->dy = 0; |
681 | part_classifier->dxx = 0.1f; |
682 | part_classifier->dyy = 0.1f; |
683 | part_classifier->x = dx; |
684 | part_classifier->y = dy; |
685 | part_classifier->z = 1; |
686 | part_classifier->w = 0; |
687 | ccv_slice(w, (ccv_matrix_t**)&part_classifier->w, 0, dy, dx, dh, dw); |
688 | ccv_make_matrix_immutable(part_classifier->w); |
689 | /* clean up the region we selected */ |
690 | float* w_ptr = (float*)ccv_get_dense_matrix_cell_by(CCV_32F | 31, w, dy, dx, 0)(((CCV_32F | 31) & CCV_32S) ? (void*)((w)->data.i32 + ( (dy) * (w)->cols + (dx)) * ((CCV_32F | 31) & 0xFFF) + ( 0)) : (((CCV_32F | 31) & CCV_32F) ? (void*)((w)->data. f32+ ((dy) * (w)->cols + (dx)) * ((CCV_32F | 31) & 0xFFF ) + (0)) : (((CCV_32F | 31) & CCV_64S) ? (void*)((w)-> data.i64+ ((dy) * (w)->cols + (dx)) * ((CCV_32F | 31) & 0xFFF) + (0)) : (((CCV_32F | 31) & CCV_64F) ? (void*)((w )->data.f64 + ((dy) * (w)->cols + (dx)) * ((CCV_32F | 31 ) & 0xFFF) + (0)) : (void*)((w)->data.u8 + (dy) * (w)-> step + (dx) * ((CCV_32F | 31) & 0xFFF) + (0)))))); |
691 | for (y = 0; y < dh; y++) |
692 | { |
693 | for (x = 0; x < dw * 31; x++) |
694 | w_ptr[x] = 0; |
695 | w_ptr += w->cols * 31; |
696 | } |
697 | i++; |
698 | if (symmetric && sym) // add counter-part |
699 | { |
700 | dx = w->cols - (dx + dw); |
701 | PRINT(CCV_CLI_INFO, " ---- part %d(%d) %dx%d at (%d,%d), entropy: %lf\n", i + 1, parts, dw, dh, dx, dy, dsum)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (" ---- part %d(%d) %dx%d at (%d,%d), entropy: %lf\n", i + 1, parts, dw, dh, dx, dy, dsum); fflush(stdout); } } while (0); |
702 | part_classifier[1].dx = 0; |
703 | part_classifier[1].dy = 0; |
704 | part_classifier[1].dxx = 0.1f; |
705 | part_classifier[1].dyy = 0.1f; |
706 | part_classifier[1].x = dx; |
707 | part_classifier[1].y = dy; |
708 | part_classifier[1].z = 1; |
709 | part_classifier[1].w = 0; |
710 | ccv_slice(w, (ccv_matrix_t**)&part_classifier[1].w, 0, dy, dx, dh, dw); |
711 | ccv_make_matrix_immutable(part_classifier[1].w); |
712 | /* clean up the region we selected */ |
713 | float* w_ptr = (float*)ccv_get_dense_matrix_cell_by(CCV_32F | 31, w, dy, dx, 0)(((CCV_32F | 31) & CCV_32S) ? (void*)((w)->data.i32 + ( (dy) * (w)->cols + (dx)) * ((CCV_32F | 31) & 0xFFF) + ( 0)) : (((CCV_32F | 31) & CCV_32F) ? (void*)((w)->data. f32+ ((dy) * (w)->cols + (dx)) * ((CCV_32F | 31) & 0xFFF ) + (0)) : (((CCV_32F | 31) & CCV_64S) ? (void*)((w)-> data.i64+ ((dy) * (w)->cols + (dx)) * ((CCV_32F | 31) & 0xFFF) + (0)) : (((CCV_32F | 31) & CCV_64F) ? (void*)((w )->data.f64 + ((dy) * (w)->cols + (dx)) * ((CCV_32F | 31 ) & 0xFFF) + (0)) : (void*)((w)->data.u8 + (dy) * (w)-> step + (dx) * ((CCV_32F | 31) & 0xFFF) + (0)))))); |
714 | for (y = 0; y < dh; y++) |
715 | { |
716 | for (x = 0; x < dw * 31; x++) |
717 | w_ptr[x] = 0; |
718 | w_ptr += w->cols * 31; |
719 | } |
720 | part_classifier[0].counterpart = i; |
721 | part_classifier[1].counterpart = i - 1; |
722 | i++; |
723 | } else { |
724 | part_classifier->counterpart = -1; |
725 | } |
726 | } |
727 | ccv_matrix_free(w); |
728 | } |
729 | |
730 | static void _ccv_dpm_initialize_feature_vector_on_pattern(ccv_dpm_feature_vector_t* vector, ccv_dpm_root_classifier_t* root, int id) |
731 | { |
732 | int i; |
733 | vector->id = id; |
734 | vector->count = root->count; |
735 | vector->part = (ccv_dpm_part_classifier_t*)ccmallocmalloc(sizeof(ccv_dpm_part_classifier_t) * root->count); |
736 | vector->root.w = ccv_dense_matrix_new(root->root.w->rows, root->root.w->cols, CCV_32F | 31, 0, 0); |
737 | for (i = 0; i < vector->count; i++) |
738 | { |
739 | vector->part[i].x = root->part[i].x; |
740 | vector->part[i].y = root->part[i].y; |
741 | vector->part[i].z = root->part[i].z; |
742 | vector->part[i].w = ccv_dense_matrix_new(root->part[i].w->rows, root->part[i].w->cols, CCV_32F | 31, 0, 0); |
743 | } |
744 | } |
745 | |
746 | static void _ccv_dpm_feature_vector_cleanup(ccv_dpm_feature_vector_t* vector) |
747 | { |
748 | int i; |
749 | if (vector->root.w) |
750 | ccv_matrix_free(vector->root.w); |
751 | for (i = 0; i < vector->count; i++) |
752 | ccv_matrix_free(vector->part[i].w); |
753 | if (vector->part) |
754 | ccfreefree(vector->part); |
755 | } |
756 | |
757 | static void _ccv_dpm_feature_vector_free(ccv_dpm_feature_vector_t* vector) |
758 | { |
759 | _ccv_dpm_feature_vector_cleanup(vector); |
760 | ccfreefree(vector); |
761 | } |
762 | |
763 | static double _ccv_dpm_vector_score(ccv_dpm_mixture_model_t* model, ccv_dpm_feature_vector_t* v) |
764 | { |
765 | if (v->id < 0 || v->id >= model->count) |
766 | return 0; |
767 | ccv_dpm_root_classifier_t* root_classifier = model->root + v->id; |
768 | double score = root_classifier->beta; |
769 | int i, k, ch = CCV_GET_CHANNEL(v->root.w->type)((v->root.w->type) & 0xFFF); |
770 | assert(ch == 31)((void) sizeof ((ch == 31) ? 1 : 0), __extension__ ({ if (ch == 31) ; else __assert_fail ("ch == 31", "ccv_dpm.c", 770, __extension__ __PRETTY_FUNCTION__); })); |
771 | float *vptr = v->root.w->data.f32; |
772 | float *wptr = root_classifier->root.w->data.f32; |
773 | for (i = 0; i < v->root.w->rows * v->root.w->cols * ch; i++) |
774 | score += wptr[i] * vptr[i]; |
775 | assert(v->count == root_classifier->count || (v->count == 0 && v->part == 0))((void) sizeof ((v->count == root_classifier->count || ( v->count == 0 && v->part == 0)) ? 1 : 0), __extension__ ({ if (v->count == root_classifier->count || (v->count == 0 && v->part == 0)) ; else __assert_fail ("v->count == root_classifier->count || (v->count == 0 && v->part == 0)" , "ccv_dpm.c", 775, __extension__ __PRETTY_FUNCTION__); })); |
776 | for (k = 0; k < v->count; k++) |
777 | { |
778 | ccv_dpm_part_classifier_t* part_classifier = root_classifier->part + k; |
779 | ccv_dpm_part_classifier_t* part_vector = v->part + k; |
780 | score -= part_classifier->dx * part_vector->dx; |
781 | score -= part_classifier->dxx * part_vector->dxx; |
782 | score -= part_classifier->dy * part_vector->dy; |
783 | score -= part_classifier->dyy * part_vector->dyy; |
784 | vptr = part_vector->w->data.f32; |
785 | wptr = part_classifier->w->data.f32; |
786 | for (i = 0; i < part_vector->w->rows * part_vector->w->cols * ch; i++) |
787 | score += wptr[i] * vptr[i]; |
788 | } |
789 | return score; |
790 | } |
791 | |
792 | static void _ccv_dpm_collect_feature_vector(ccv_dpm_feature_vector_t* v, float score, int x, int y, ccv_dense_matrix_t* pyr, ccv_dense_matrix_t* detail, ccv_dense_matrix_t** dx, ccv_dense_matrix_t** dy) |
793 | { |
794 | v->score = score; |
795 | v->x = x; |
796 | v->y = y; |
797 | ccv_zero(v->root.w); |
798 | int rwh = (v->root.w->rows - 1) / 2, rww = (v->root.w->cols - 1) / 2; |
799 | int i, ix, iy, ch = CCV_GET_CHANNEL(v->root.w->type)((v->root.w->type) & 0xFFF); |
800 | float* h_ptr = (float*)ccv_get_dense_matrix_cell_by(CCV_32F | ch, pyr, y - rwh, x - rww, 0)(((CCV_32F | ch) & CCV_32S) ? (void*)((pyr)->data.i32 + ((y - rwh) * (pyr)->cols + (x - rww)) * ((CCV_32F | ch) & 0xFFF) + (0)) : (((CCV_32F | ch) & CCV_32F) ? (void*)((pyr )->data.f32+ ((y - rwh) * (pyr)->cols + (x - rww)) * (( CCV_32F | ch) & 0xFFF) + (0)) : (((CCV_32F | ch) & CCV_64S ) ? (void*)((pyr)->data.i64+ ((y - rwh) * (pyr)->cols + (x - rww)) * ((CCV_32F | ch) & 0xFFF) + (0)) : (((CCV_32F | ch) & CCV_64F) ? (void*)((pyr)->data.f64 + ((y - rwh ) * (pyr)->cols + (x - rww)) * ((CCV_32F | ch) & 0xFFF ) + (0)) : (void*)((pyr)->data.u8 + (y - rwh) * (pyr)-> step + (x - rww) * ((CCV_32F | ch) & 0xFFF) + (0)))))); |
801 | float* w_ptr = v->root.w->data.f32; |
802 | for (iy = 0; iy < v->root.w->rows; iy++) |
803 | { |
804 | memcpy(w_ptr, h_ptr, v->root.w->cols * ch * sizeof(float)); |
805 | h_ptr += pyr->cols * ch; |
806 | w_ptr += v->root.w->cols * ch; |
807 | } |
808 | for (i = 0; i < v->count; i++) |
809 | { |
810 | ccv_dpm_part_classifier_t* part = v->part + i; |
811 | int pww = (part->w->cols - 1) / 2, pwh = (part->w->rows - 1) / 2; |
812 | int offy = part->y + pwh - rwh * 2; |
813 | int offx = part->x + pww - rww * 2; |
814 | iy = ccv_clamp(y * 2 + offy, pwh, detail->rows - part->w->rows + pwh)({ typeof (pwh) _a = (pwh); typeof (detail->rows - part-> w->rows + pwh) _b = (detail->rows - part->w->rows + pwh); typeof (y * 2 + offy) _x = (y * 2 + offy); (_x < _a ) ? _a : ((_x > _b) ? _b : _x); }); |
815 | ix = ccv_clamp(x * 2 + offx, pww, detail->cols - part->w->cols + pww)({ typeof (pww) _a = (pww); typeof (detail->cols - part-> w->cols + pww) _b = (detail->cols - part->w->cols + pww); typeof (x * 2 + offx) _x = (x * 2 + offx); (_x < _a ) ? _a : ((_x > _b) ? _b : _x); }); |
816 | int ry = ccv_get_dense_matrix_cell_value_by(CCV_32S | CCV_C1, dy[i], iy, ix, 0)(((CCV_32S | CCV_C1) & CCV_32S) ? (dy[i])->data.i32[(( iy) * (dy[i])->cols + (ix)) * ((CCV_32S | CCV_C1) & 0xFFF ) + (0)] : (((CCV_32S | CCV_C1) & CCV_32F) ? (dy[i])-> data.f32[((iy) * (dy[i])->cols + (ix)) * ((CCV_32S | CCV_C1 ) & 0xFFF) + (0)] : (((CCV_32S | CCV_C1) & CCV_64S) ? (dy[i])->data.i64[((iy) * (dy[i])->cols + (ix)) * ((CCV_32S | CCV_C1) & 0xFFF) + (0)] : (((CCV_32S | CCV_C1) & CCV_64F ) ? (dy[i])->data.f64[((iy) * (dy[i])->cols + (ix)) * ( (CCV_32S | CCV_C1) & 0xFFF) + (0)] : (dy[i])->data.u8[ (iy) * (dy[i])->step + (ix) * ((CCV_32S | CCV_C1) & 0xFFF ) + (0)])))); |
817 | int rx = ccv_get_dense_matrix_cell_value_by(CCV_32S | CCV_C1, dx[i], iy, ix, 0)(((CCV_32S | CCV_C1) & CCV_32S) ? (dx[i])->data.i32[(( iy) * (dx[i])->cols + (ix)) * ((CCV_32S | CCV_C1) & 0xFFF ) + (0)] : (((CCV_32S | CCV_C1) & CCV_32F) ? (dx[i])-> data.f32[((iy) * (dx[i])->cols + (ix)) * ((CCV_32S | CCV_C1 ) & 0xFFF) + (0)] : (((CCV_32S | CCV_C1) & CCV_64S) ? (dx[i])->data.i64[((iy) * (dx[i])->cols + (ix)) * ((CCV_32S | CCV_C1) & 0xFFF) + (0)] : (((CCV_32S | CCV_C1) & CCV_64F ) ? (dx[i])->data.f64[((iy) * (dx[i])->cols + (ix)) * ( (CCV_32S | CCV_C1) & 0xFFF) + (0)] : (dx[i])->data.u8[ (iy) * (dx[i])->step + (ix) * ((CCV_32S | CCV_C1) & 0xFFF ) + (0)])))); |
818 | part->dx = rx; // I am not sure if I need to flip the sign or not (confirmed, it should be this way) |
819 | part->dy = ry; |
820 | part->dxx = rx * rx; |
821 | part->dyy = ry * ry; |
822 | // deal with out-of-bound error |
823 | int start_y = ccv_max(0, iy - ry - pwh)({ typeof (0) _a = (0); typeof (iy - ry - pwh) _b = (iy - ry - pwh); (_a > _b) ? _a : _b; }); |
824 | assert(start_y < detail->rows)((void) sizeof ((start_y < detail->rows) ? 1 : 0), __extension__ ({ if (start_y < detail->rows) ; else __assert_fail ("start_y < detail->rows" , "ccv_dpm.c", 824, __extension__ __PRETTY_FUNCTION__); })); |
825 | int start_x = ccv_max(0, ix - rx - pww)({ typeof (0) _a = (0); typeof (ix - rx - pww) _b = (ix - rx - pww); (_a > _b) ? _a : _b; }); |
826 | assert(start_x < detail->cols)((void) sizeof ((start_x < detail->cols) ? 1 : 0), __extension__ ({ if (start_x < detail->cols) ; else __assert_fail ("start_x < detail->cols" , "ccv_dpm.c", 826, __extension__ __PRETTY_FUNCTION__); })); |
827 | int end_y = ccv_min(detail->rows, iy - ry - pwh + part->w->rows)({ typeof (detail->rows) _a = (detail->rows); typeof (iy - ry - pwh + part->w->rows) _b = (iy - ry - pwh + part ->w->rows); (_a < _b) ? _a : _b; }); |
828 | assert(end_y >= 0)((void) sizeof ((end_y >= 0) ? 1 : 0), __extension__ ({ if (end_y >= 0) ; else __assert_fail ("end_y >= 0", "ccv_dpm.c" , 828, __extension__ __PRETTY_FUNCTION__); })); |
829 | int end_x = ccv_min(detail->cols, ix - rx - pww + part->w->cols)({ typeof (detail->cols) _a = (detail->cols); typeof (ix - rx - pww + part->w->cols) _b = (ix - rx - pww + part ->w->cols); (_a < _b) ? _a : _b; }); |
830 | assert(end_x >= 0)((void) sizeof ((end_x >= 0) ? 1 : 0), __extension__ ({ if (end_x >= 0) ; else __assert_fail ("end_x >= 0", "ccv_dpm.c" , 830, __extension__ __PRETTY_FUNCTION__); })); |
831 | h_ptr = (float*)ccv_get_dense_matrix_cell_by(CCV_32F | ch, detail, start_y, start_x, 0)(((CCV_32F | ch) & CCV_32S) ? (void*)((detail)->data.i32 + ((start_y) * (detail)->cols + (start_x)) * ((CCV_32F | ch ) & 0xFFF) + (0)) : (((CCV_32F | ch) & CCV_32F) ? (void *)((detail)->data.f32+ ((start_y) * (detail)->cols + (start_x )) * ((CCV_32F | ch) & 0xFFF) + (0)) : (((CCV_32F | ch) & CCV_64S) ? (void*)((detail)->data.i64+ ((start_y) * (detail )->cols + (start_x)) * ((CCV_32F | ch) & 0xFFF) + (0)) : (((CCV_32F | ch) & CCV_64F) ? (void*)((detail)->data .f64 + ((start_y) * (detail)->cols + (start_x)) * ((CCV_32F | ch) & 0xFFF) + (0)) : (void*)((detail)->data.u8 + ( start_y) * (detail)->step + (start_x) * ((CCV_32F | ch) & 0xFFF) + (0)))))); |
832 | ccv_zero(v->part[i].w); |
833 | w_ptr = (float*)ccv_get_dense_matrix_cell_by(CCV_32F | ch, part->w, start_y - (iy - ry - pwh), start_x - (ix - rx - pww), 0)(((CCV_32F | ch) & CCV_32S) ? (void*)((part->w)->data .i32 + ((start_y - (iy - ry - pwh)) * (part->w)->cols + (start_x - (ix - rx - pww))) * ((CCV_32F | ch) & 0xFFF) + (0)) : (((CCV_32F | ch) & CCV_32F) ? (void*)((part->w )->data.f32+ ((start_y - (iy - ry - pwh)) * (part->w)-> cols + (start_x - (ix - rx - pww))) * ((CCV_32F | ch) & 0xFFF ) + (0)) : (((CCV_32F | ch) & CCV_64S) ? (void*)((part-> w)->data.i64+ ((start_y - (iy - ry - pwh)) * (part->w)-> cols + (start_x - (ix - rx - pww))) * ((CCV_32F | ch) & 0xFFF ) + (0)) : (((CCV_32F | ch) & CCV_64F) ? (void*)((part-> w)->data.f64 + ((start_y - (iy - ry - pwh)) * (part->w) ->cols + (start_x - (ix - rx - pww))) * ((CCV_32F | ch) & 0xFFF) + (0)) : (void*)((part->w)->data.u8 + (start_y - (iy - ry - pwh)) * (part->w)->step + (start_x - (ix - rx - pww)) * ((CCV_32F | ch) & 0xFFF) + (0)))))); |
834 | for (iy = start_y; iy < end_y; iy++) |
835 | { |
836 | memcpy(w_ptr, h_ptr, (end_x - start_x) * ch * sizeof(float)); |
837 | h_ptr += detail->cols * ch; |
838 | w_ptr += part->w->cols * ch; |
839 | } |
840 | } |
841 | } |
842 | |
843 | static ccv_dpm_feature_vector_t* _ccv_dpm_collect_best(ccv_dense_matrix_t* image, ccv_dpm_mixture_model_t* model, ccv_rect_t bbox, double overlap, ccv_dpm_param_t params) |
844 | { |
845 | int i, j, k, x, y; |
846 | double scale = pow(2.0, 1.0 / (params.interval + 1.0)); |
847 | int next = params.interval + 1; |
848 | int scale_upto = _ccv_dpm_scale_upto(image, &model, 1, params.interval); |
849 | if (scale_upto < 0) |
850 | return 0; |
851 | ccv_dense_matrix_t** pyr = (ccv_dense_matrix_t**)alloca((scale_upto + next * 2) * sizeof(ccv_dense_matrix_t*))__builtin_alloca ((scale_upto + next * 2) * sizeof(ccv_dense_matrix_t *)); |
852 | _ccv_dpm_feature_pyramid(image, pyr, scale_upto, params.interval); |
853 | float best = -FLT_MAX3.40282347e+38F; |
854 | ccv_dpm_feature_vector_t* v = 0; |
855 | for (i = 0; i < model->count; i++) |
856 | { |
857 | ccv_dpm_root_classifier_t* root_classifier = model->root + i; |
858 | double scale_x = 1.0; |
859 | double scale_y = 1.0; |
860 | for (j = next; j < scale_upto + next * 2; j++) |
861 | { |
862 | ccv_size_t size = ccv_size((int)(root_classifier->root.w->cols * CCV_DPM_WINDOW_SIZE(8) * scale_x + 0.5), (int)(root_classifier->root.w->rows * CCV_DPM_WINDOW_SIZE(8) * scale_y + 0.5)); |
863 | if (ccv_min((double)(size.width * size.height), (double)(bbox.width * bbox.height))({ typeof ((double)(size.width * size.height)) _a = ((double) (size.width * size.height)); typeof ((double)(bbox.width * bbox .height)) _b = ((double)(bbox.width * bbox.height)); (_a < _b) ? _a : _b; }) / |
864 | ccv_max((double)(bbox.width * bbox.height), (double)(size.width * size.height))({ typeof ((double)(bbox.width * bbox.height)) _a = ((double) (bbox.width * bbox.height)); typeof ((double)(size.width * size .height)) _b = ((double)(size.width * size.height)); (_a > _b) ? _a : _b; }) < overlap) |
865 | { |
866 | scale_x *= scale; |
867 | scale_y *= scale; |
868 | continue; |
869 | } |
870 | ccv_dense_matrix_t* root_feature = 0; |
871 | ccv_dense_matrix_t* part_feature[CCV_DPM_PART_MAX(10)]; |
872 | ccv_dense_matrix_t* dx[CCV_DPM_PART_MAX(10)]; |
873 | ccv_dense_matrix_t* dy[CCV_DPM_PART_MAX(10)]; |
874 | _ccv_dpm_compute_score(root_classifier, pyr[j], pyr[j - next], &root_feature, part_feature, dx, dy); |
875 | int rwh = (root_classifier->root.w->rows - 1) / 2, rww = (root_classifier->root.w->cols - 1) / 2; |
876 | int rwh_1 = root_classifier->root.w->rows / 2, rww_1 = root_classifier->root.w->cols / 2; |
877 | float* f_ptr = (float*)ccv_get_dense_matrix_cell_by(CCV_32F | CCV_C1, root_feature, rwh, 0, 0)(((CCV_32F | CCV_C1) & CCV_32S) ? (void*)((root_feature)-> data.i32 + ((rwh) * (root_feature)->cols + (0)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)) : (((CCV_32F | CCV_C1) & CCV_32F ) ? (void*)((root_feature)->data.f32+ ((rwh) * (root_feature )->cols + (0)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)) : (((CCV_32F | CCV_C1) & CCV_64S) ? (void*)((root_feature) ->data.i64+ ((rwh) * (root_feature)->cols + (0)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)) : (((CCV_32F | CCV_C1) & CCV_64F ) ? (void*)((root_feature)->data.f64 + ((rwh) * (root_feature )->cols + (0)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)) : (void*)((root_feature)->data.u8 + (rwh) * (root_feature)-> step + (0) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)))))); |
878 | for (y = rwh; y < root_feature->rows - rwh_1; y++) |
879 | { |
880 | for (x = rww; x < root_feature->cols - rww_1; x++) |
881 | { |
882 | ccv_rect_t rect = ccv_rect((int)((x - rww) * CCV_DPM_WINDOW_SIZE(8) * scale_x + 0.5), (int)((y - rwh) * CCV_DPM_WINDOW_SIZE(8) * scale_y + 0.5), (int)(root_classifier->root.w->cols * CCV_DPM_WINDOW_SIZE(8) * scale_x + 0.5), (int)(root_classifier->root.w->rows * CCV_DPM_WINDOW_SIZE(8) * scale_y + 0.5)); |
883 | if ((double)(ccv_max(0, ccv_min(rect.x + rect.width, bbox.x + bbox.width) - ccv_max(rect.x, bbox.x))({ typeof (0) _a = (0); typeof (({ typeof (rect.x + rect.width ) _a = (rect.x + rect.width); typeof (bbox.x + bbox.width) _b = (bbox.x + bbox.width); (_a < _b) ? _a : _b; }) - ({ typeof (rect.x) _a = (rect.x); typeof (bbox.x) _b = (bbox.x); (_a > _b) ? _a : _b; })) _b = (({ typeof (rect.x + rect.width) _a = (rect.x + rect.width); typeof (bbox.x + bbox.width) _b = (bbox .x + bbox.width); (_a < _b) ? _a : _b; }) - ({ typeof (rect .x) _a = (rect.x); typeof (bbox.x) _b = (bbox.x); (_a > _b ) ? _a : _b; })); (_a > _b) ? _a : _b; }) * |
884 | ccv_max(0, ccv_min(rect.y + rect.height, bbox.y + bbox.height) - ccv_max(rect.y, bbox.y))({ typeof (0) _a = (0); typeof (({ typeof (rect.y + rect.height ) _a = (rect.y + rect.height); typeof (bbox.y + bbox.height) _b = (bbox.y + bbox.height); (_a < _b) ? _a : _b; }) - ({ typeof (rect.y) _a = (rect.y); typeof (bbox.y) _b = (bbox.y); (_a > _b) ? _a : _b; })) _b = (({ typeof (rect.y + rect.height) _a = (rect.y + rect.height); typeof (bbox.y + bbox.height) _b = (bbox.y + bbox.height); (_a < _b) ? _a : _b; }) - ({ typeof (rect.y) _a = (rect.y); typeof (bbox.y) _b = (bbox.y); (_a > _b) ? _a : _b; })); (_a > _b) ? _a : _b; })) / |
885 | (double)ccv_max(rect.width * rect.height, bbox.width * bbox.height)({ typeof (rect.width * rect.height) _a = (rect.width * rect. height); typeof (bbox.width * bbox.height) _b = (bbox.width * bbox.height); (_a > _b) ? _a : _b; }) >= overlap && f_ptr[x] > best) |
886 | { |
887 | // initialize v |
888 | if (v == 0) |
889 | { |
890 | v = (ccv_dpm_feature_vector_t*)ccmallocmalloc(sizeof(ccv_dpm_feature_vector_t)); |
891 | _ccv_dpm_initialize_feature_vector_on_pattern(v, root_classifier, i); |
892 | } |
893 | // if it is another kind, cleanup and reinitialize |
894 | if (v->id != i) |
895 | { |
896 | _ccv_dpm_feature_vector_cleanup(v); |
897 | _ccv_dpm_initialize_feature_vector_on_pattern(v, root_classifier, i); |
898 | } |
899 | _ccv_dpm_collect_feature_vector(v, f_ptr[x] + root_classifier->beta, x, y, pyr[j], pyr[j - next], dx, dy); |
900 | v->scale_x = scale_x; |
901 | v->scale_y = scale_y; |
902 | best = f_ptr[x]; |
903 | } |
904 | } |
905 | f_ptr += root_feature->cols; |
906 | } |
907 | for (k = 0; k < root_classifier->count; k++) |
908 | { |
909 | ccv_matrix_free(part_feature[k]); |
910 | ccv_matrix_free(dx[k]); |
911 | ccv_matrix_free(dy[k]); |
912 | } |
913 | ccv_matrix_free(root_feature); |
914 | scale_x *= scale; |
915 | scale_y *= scale; |
916 | } |
917 | } |
918 | for (i = 0; i < scale_upto + next * 2; i++) |
919 | ccv_matrix_free(pyr[i]); |
920 | return v; |
921 | } |
922 | |
923 | static ccv_array_t* _ccv_dpm_collect_all(gsl_rng* rng, ccv_dense_matrix_t* image, ccv_dpm_mixture_model_t* model, ccv_dpm_param_t params, float threshold) |
924 | { |
925 | int i, j, k, x, y; |
926 | double scale = pow(2.0, 1.0 / (params.interval + 1.0)); |
927 | int next = params.interval + 1; |
928 | int scale_upto = _ccv_dpm_scale_upto(image, &model, 1, params.interval); |
929 | if (scale_upto < 0) |
930 | return 0; |
931 | ccv_dense_matrix_t** pyr = (ccv_dense_matrix_t**)alloca((scale_upto + next * 2) * sizeof(ccv_dense_matrix_t*))__builtin_alloca ((scale_upto + next * 2) * sizeof(ccv_dense_matrix_t *)); |
932 | _ccv_dpm_feature_pyramid(image, pyr, scale_upto, params.interval); |
933 | ccv_array_t* av = ccv_array_new(sizeof(ccv_dpm_feature_vector_t*), 64, 0); |
934 | int enough = 64 / model->count; |
935 | int* order = (int*)alloca(sizeof(int) * model->count)__builtin_alloca (sizeof(int) * model->count); |
936 | for (i = 0; i < model->count; i++) |
937 | order[i] = i; |
938 | gsl_ran_shuffle(rng, order, model->count, sizeof(int)); |
939 | for (i = 0; i < model->count; i++) |
940 | { |
941 | ccv_dpm_root_classifier_t* root_classifier = model->root + order[i]; |
942 | double scale_x = 1.0; |
943 | double scale_y = 1.0; |
944 | for (j = next; j < scale_upto + next * 2; j++) |
945 | { |
946 | ccv_dense_matrix_t* root_feature = 0; |
947 | ccv_dense_matrix_t* part_feature[CCV_DPM_PART_MAX(10)]; |
948 | ccv_dense_matrix_t* dx[CCV_DPM_PART_MAX(10)]; |
949 | ccv_dense_matrix_t* dy[CCV_DPM_PART_MAX(10)]; |
950 | _ccv_dpm_compute_score(root_classifier, pyr[j], pyr[j - next], &root_feature, part_feature, dx, dy); |
951 | int rwh = (root_classifier->root.w->rows - 1) / 2, rww = (root_classifier->root.w->cols - 1) / 2; |
952 | int rwh_1 = root_classifier->root.w->rows / 2, rww_1 = root_classifier->root.w->cols / 2; |
953 | float* f_ptr = (float*)ccv_get_dense_matrix_cell_by(CCV_32F | CCV_C1, root_feature, rwh, 0, 0)(((CCV_32F | CCV_C1) & CCV_32S) ? (void*)((root_feature)-> data.i32 + ((rwh) * (root_feature)->cols + (0)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)) : (((CCV_32F | CCV_C1) & CCV_32F ) ? (void*)((root_feature)->data.f32+ ((rwh) * (root_feature )->cols + (0)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)) : (((CCV_32F | CCV_C1) & CCV_64S) ? (void*)((root_feature) ->data.i64+ ((rwh) * (root_feature)->cols + (0)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)) : (((CCV_32F | CCV_C1) & CCV_64F ) ? (void*)((root_feature)->data.f64 + ((rwh) * (root_feature )->cols + (0)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)) : (void*)((root_feature)->data.u8 + (rwh) * (root_feature)-> step + (0) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)))))); |
954 | for (y = rwh; y < root_feature->rows - rwh_1; y++) |
955 | { |
956 | for (x = rww; x < root_feature->cols - rww_1; x++) |
957 | if (f_ptr[x] + root_classifier->beta > threshold) |
958 | { |
959 | // initialize v |
960 | ccv_dpm_feature_vector_t* v = (ccv_dpm_feature_vector_t*)ccmallocmalloc(sizeof(ccv_dpm_feature_vector_t)); |
961 | _ccv_dpm_initialize_feature_vector_on_pattern(v, root_classifier, order[i]); |
962 | _ccv_dpm_collect_feature_vector(v, f_ptr[x] + root_classifier->beta, x, y, pyr[j], pyr[j - next], dx, dy); |
963 | v->scale_x = scale_x; |
964 | v->scale_y = scale_y; |
965 | ccv_array_push(av, &v); |
966 | if (av->rnum >= enough * (i + 1)) |
967 | break; |
968 | } |
969 | f_ptr += root_feature->cols; |
970 | if (av->rnum >= enough * (i + 1)) |
971 | break; |
972 | } |
973 | for (k = 0; k < root_classifier->count; k++) |
974 | { |
975 | ccv_matrix_free(part_feature[k]); |
976 | ccv_matrix_free(dx[k]); |
977 | ccv_matrix_free(dy[k]); |
978 | } |
979 | ccv_matrix_free(root_feature); |
980 | scale_x *= scale; |
981 | scale_y *= scale; |
982 | if (av->rnum >= enough * (i + 1)) |
983 | break; |
984 | } |
985 | } |
986 | for (i = 0; i < scale_upto + next * 2; i++) |
987 | ccv_matrix_free(pyr[i]); |
988 | return av; |
989 | } |
990 | |
991 | static void _ccv_dpm_collect_from_background(ccv_array_t* av, gsl_rng* rng, char** bgfiles, int bgnum, ccv_dpm_mixture_model_t* model, ccv_dpm_new_param_t params, float threshold) |
992 | { |
993 | int i, j; |
994 | int* order = (int*)ccmallocmalloc(sizeof(int) * bgnum); |
995 | for (i = 0; i < bgnum; i++) |
996 | order[i] = i; |
997 | gsl_ran_shuffle(rng, order, bgnum, sizeof(int)); |
998 | for (i = 0; i < bgnum; i++) |
999 | { |
1000 | FLUSH(CCV_CLI_INFO, " - collecting negative examples -- (%d%%)", av->rnum * 100 / params.negative_cache_size)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf("\b"); for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf(" "); for ( _CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP ++) printf("\b"); _CCV_PRINT_COUNT = printf(" - collecting negative examples -- (%d%%)" , av->rnum * 100 / params.negative_cache_size); fflush(stdout ); } } while (0); |
1001 | ccv_dense_matrix_t* image = 0; |
1002 | ccv_read(bgfiles[order[i]], &image, (params.grayscale ? CCV_IO_GRAY : 0) | CCV_IO_ANY_FILE)ccv_read_impl(bgfiles[order[i]], &image, (params.grayscale ? CCV_IO_GRAY : 0) | CCV_IO_ANY_FILE, 0, 0, 0); |
1003 | ccv_array_t* at = _ccv_dpm_collect_all(rng, image, model, params.detector, threshold); |
1004 | if (at) |
1005 | { |
1006 | for (j = 0; j < at->rnum; j++) |
1007 | ccv_array_push(av, ccv_array_get(at, j)((void*)(((char*)((at)->data)) + (size_t)(at)->rsize * ( size_t)(j)))); |
1008 | ccv_array_free(at); |
1009 | } |
1010 | ccv_matrix_free(image); |
1011 | if (av->rnum >= params.negative_cache_size) |
1012 | break; |
1013 | } |
1014 | ccfreefree(order); |
1015 | } |
1016 | |
1017 | static void _ccv_dpm_initialize_root_rectangle_estimator(ccv_dpm_mixture_model_t* model, char** posfiles, ccv_rect_t* bboxes, int posnum, ccv_dpm_new_param_t params) |
1018 | { |
1019 | int i, j, k, c; |
1020 | ccv_dpm_feature_vector_t** posv = (ccv_dpm_feature_vector_t**)ccmallocmalloc(sizeof(ccv_dpm_feature_vector_t*) * posnum); |
1021 | int* num_per_model = (int*)alloca(sizeof(int) * model->count)__builtin_alloca (sizeof(int) * model->count); |
1022 | memset(num_per_model, 0, sizeof(int) * model->count); |
1023 | FLUSH(CCV_CLI_INFO, " - collecting responses from positive examples : 0%%")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf("\b"); for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf(" "); for ( _CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP ++) printf("\b"); _CCV_PRINT_COUNT = printf(" - collecting responses from positive examples : 0%%" ); fflush(stdout); } } while (0); |
1024 | for (i = 0; i < posnum; i++) |
1025 | { |
1026 | FLUSH(CCV_CLI_INFO, " - collecting responses from positive examples : %d%%", i * 100 / posnum)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf("\b"); for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf(" "); for ( _CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP ++) printf("\b"); _CCV_PRINT_COUNT = printf(" - collecting responses from positive examples : %d%%" , i * 100 / posnum); fflush(stdout); } } while (0); |
1027 | ccv_dense_matrix_t* image = 0; |
1028 | ccv_read(posfiles[i], &image, (params.grayscale ? CCV_IO_GRAY : 0) | CCV_IO_ANY_FILE)ccv_read_impl(posfiles[i], &image, (params.grayscale ? CCV_IO_GRAY : 0) | CCV_IO_ANY_FILE, 0, 0, 0); |
1029 | posv[i] = _ccv_dpm_collect_best(image, model, bboxes[i], params.include_overlap, params.detector); |
1030 | if (posv[i]) |
1031 | ++num_per_model[posv[i]->id]; |
1032 | ccv_matrix_free(image); |
1033 | } |
1034 | // this will estimate new x, y, and scale |
1035 | PRINT(CCV_CLI_INFO, "\n - linear regression for x, y, and scale drifting\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("\n - linear regression for x, y, and scale drifting\n"); fflush (stdout); } } while (0); |
1036 | for (i = 0; i < model->count; i++) |
1037 | { |
1038 | ccv_dpm_root_classifier_t* root_classifier = model->root + i; |
1039 | gsl_matrix* X = gsl_matrix_alloc(num_per_model[i], root_classifier->count * 2 + 1); |
1040 | gsl_vector* y[3]; |
1041 | y[0] = gsl_vector_alloc(num_per_model[i]); |
1042 | y[1] = gsl_vector_alloc(num_per_model[i]); |
1043 | y[2] = gsl_vector_alloc(num_per_model[i]); |
1044 | gsl_vector* z = gsl_vector_alloc(root_classifier->count * 2 + 1); |
1045 | gsl_matrix* cov = gsl_matrix_alloc(root_classifier->count * 2 + 1, root_classifier->count * 2 + 1);; |
1046 | c = 0; |
1047 | for (j = 0; j < posnum; j++) |
1048 | { |
1049 | ccv_dpm_feature_vector_t* v = posv[j]; |
1050 | if (v && v->id == i) |
1051 | { |
1052 | gsl_matrix_set(X, c, 0, 1.0); |
1053 | for (k = 0; k < v->count; k++) |
1054 | { |
1055 | gsl_matrix_set(X, c, k * 2 + 1, v->part[k].dx); |
1056 | gsl_matrix_set(X, c, k * 2 + 2, v->part[k].dy); |
1057 | } |
1058 | ccv_rect_t bbox = bboxes[j]; |
1059 | gsl_vector_set(y[0], c, (bbox.x + bbox.width * 0.5) / (v->scale_x * CCV_DPM_WINDOW_SIZE(8)) - v->x); |
1060 | gsl_vector_set(y[1], c, (bbox.y + bbox.height * 0.5) / (v->scale_y * CCV_DPM_WINDOW_SIZE(8)) - v->y); |
1061 | gsl_vector_set(y[2], c, sqrt((bbox.width * bbox.height) / (root_classifier->root.w->rows * v->scale_x * CCV_DPM_WINDOW_SIZE(8) * root_classifier->root.w->cols * v->scale_y * CCV_DPM_WINDOW_SIZE(8))) - 1.0); |
1062 | ++c; |
1063 | } |
1064 | } |
1065 | gsl_multifit_linear_workspace* workspace = gsl_multifit_linear_alloc(num_per_model[i], root_classifier->count * 2 + 1); |
1066 | double chisq; |
1067 | for (j = 0; j < 3; j++) |
1068 | { |
1069 | gsl_multifit_linear(X, y[j], z, cov, &chisq, workspace); |
1070 | root_classifier->alpha[j] = params.discard_estimating_constant ? 0 : gsl_vector_get(z, 0); |
1071 | for (k = 0; k < root_classifier->count; k++) |
1072 | { |
1073 | ccv_dpm_part_classifier_t* part_classifier = root_classifier->part + k; |
1074 | part_classifier->alpha[j * 2] = gsl_vector_get(z, k * 2 + 1); |
1075 | part_classifier->alpha[j * 2 + 1] = gsl_vector_get(z, k * 2 + 2); |
1076 | } |
1077 | } |
1078 | gsl_multifit_linear_free(workspace); |
1079 | gsl_matrix_free(cov); |
1080 | gsl_vector_free(z); |
1081 | gsl_vector_free(y[0]); |
1082 | gsl_vector_free(y[1]); |
1083 | gsl_vector_free(y[2]); |
1084 | gsl_matrix_free(X); |
1085 | } |
1086 | for (i = 0; i < posnum; i++) |
1087 | if (posv[i]) |
1088 | _ccv_dpm_feature_vector_free(posv[i]); |
1089 | ccfreefree(posv); |
1090 | } |
1091 | |
1092 | static void _ccv_dpm_regularize_mixture_model(ccv_dpm_mixture_model_t* model, int i, double regz) |
1093 | { |
1094 | int k; |
1095 | ccv_dpm_root_classifier_t* root_classifier = model->root + i; |
1096 | int ch = CCV_GET_CHANNEL(root_classifier->root.w->type)((root_classifier->root.w->type) & 0xFFF); |
1097 | ccv_make_matrix_mutable(root_classifier->root.w); |
1098 | float *wptr = root_classifier->root.w->data.f32; |
1099 | for (i = 0; i < root_classifier->root.w->rows * root_classifier->root.w->cols * ch; i++) |
1100 | wptr[i] -= regz * wptr[i]; |
1101 | ccv_make_matrix_immutable(root_classifier->root.w); |
1102 | root_classifier->beta -= regz * root_classifier->beta; |
1103 | for (k = 0; k < root_classifier->count; k++) |
1104 | { |
1105 | ccv_dpm_part_classifier_t* part_classifier = root_classifier->part + k; |
1106 | ccv_make_matrix_mutable(part_classifier->w); |
1107 | wptr = part_classifier->w->data.f32; |
1108 | for (i = 0; i < part_classifier->w->rows * part_classifier->w->cols * ch; i++) |
1109 | wptr[i] -= regz * wptr[i]; |
1110 | ccv_make_matrix_immutable(part_classifier->w); |
1111 | part_classifier->dx -= regz * part_classifier->dx; |
1112 | part_classifier->dxx -= regz * part_classifier->dxx; |
1113 | part_classifier->dy -= regz * part_classifier->dy; |
1114 | part_classifier->dyy -= regz * part_classifier->dyy; |
1115 | part_classifier->dxx = ccv_max(0.01, part_classifier->dxx)({ typeof (0.01) _a = (0.01); typeof (part_classifier->dxx ) _b = (part_classifier->dxx); (_a > _b) ? _a : _b; }); |
1116 | part_classifier->dyy = ccv_max(0.01, part_classifier->dyy)({ typeof (0.01) _a = (0.01); typeof (part_classifier->dyy ) _b = (part_classifier->dyy); (_a > _b) ? _a : _b; }); |
1117 | } |
1118 | } |
1119 | |
1120 | static void _ccv_dpm_stochastic_gradient_descent(ccv_dpm_mixture_model_t* model, ccv_dpm_feature_vector_t* v, double y, double alpha, double Cn, int symmetric) |
1121 | { |
1122 | if (v->id < 0 || v->id >= model->count) |
1123 | return; |
1124 | ccv_dpm_root_classifier_t* root_classifier = model->root + v->id; |
1125 | int i, j, k, c, ch = CCV_GET_CHANNEL(v->root.w->type)((v->root.w->type) & 0xFFF); |
1126 | assert(ch == 31)((void) sizeof ((ch == 31) ? 1 : 0), __extension__ ({ if (ch == 31) ; else __assert_fail ("ch == 31", "ccv_dpm.c", 1126, __extension__ __PRETTY_FUNCTION__); })); |
1127 | assert(v->root.w->rows == root_classifier->root.w->rows && v->root.w->cols == root_classifier->root.w->cols)((void) sizeof ((v->root.w->rows == root_classifier-> root.w->rows && v->root.w->cols == root_classifier ->root.w->cols) ? 1 : 0), __extension__ ({ if (v->root .w->rows == root_classifier->root.w->rows && v->root.w->cols == root_classifier->root.w->cols ) ; else __assert_fail ("v->root.w->rows == root_classifier->root.w->rows && v->root.w->cols == root_classifier->root.w->cols" , "ccv_dpm.c", 1127, __extension__ __PRETTY_FUNCTION__); })); |
1128 | float *vptr = v->root.w->data.f32; |
1129 | ccv_make_matrix_mutable(root_classifier->root.w); |
1130 | float *wptr = root_classifier->root.w->data.f32; |
1131 | if (symmetric) |
1132 | { |
1133 | for (i = 0; i < v->root.w->rows; i++) |
1134 | { |
1135 | for (j = 0; j < v->root.w->cols; j++) |
1136 | for (c = 0; c < ch; c++) |
1137 | { |
1138 | wptr[j * ch + c] += alpha * y * Cn * vptr[j * ch + c]; |
1139 | wptr[j * ch + c] += alpha * y * Cn * vptr[(v->root.w->cols - 1 - j) * ch + _ccv_dpm_sym_lut[c]]; |
1140 | } |
1141 | vptr += v->root.w->cols * ch; |
1142 | wptr += root_classifier->root.w->cols * ch; |
1143 | } |
1144 | root_classifier->beta += alpha * y * Cn * 2.0; |
1145 | } else { |
1146 | for (i = 0; i < v->root.w->rows * v->root.w->cols * ch; i++) |
1147 | wptr[i] += alpha * y * Cn * vptr[i]; |
1148 | root_classifier->beta += alpha * y * Cn; |
1149 | } |
1150 | ccv_make_matrix_immutable(root_classifier->root.w); |
1151 | assert(v->count == root_classifier->count)((void) sizeof ((v->count == root_classifier->count) ? 1 : 0), __extension__ ({ if (v->count == root_classifier-> count) ; else __assert_fail ("v->count == root_classifier->count" , "ccv_dpm.c", 1151, __extension__ __PRETTY_FUNCTION__); })); |
1152 | for (k = 0; k < v->count; k++) |
1153 | { |
1154 | ccv_dpm_part_classifier_t* part_classifier = root_classifier->part + k; |
1155 | ccv_make_matrix_mutable(part_classifier->w); |
1156 | ccv_dpm_part_classifier_t* part_vector = v->part + k; |
1157 | assert(part_vector->w->rows == part_classifier->w->rows && part_vector->w->cols == part_classifier->w->cols)((void) sizeof ((part_vector->w->rows == part_classifier ->w->rows && part_vector->w->cols == part_classifier ->w->cols) ? 1 : 0), __extension__ ({ if (part_vector-> w->rows == part_classifier->w->rows && part_vector ->w->cols == part_classifier->w->cols) ; else __assert_fail ("part_vector->w->rows == part_classifier->w->rows && part_vector->w->cols == part_classifier->w->cols" , "ccv_dpm.c", 1157, __extension__ __PRETTY_FUNCTION__); })); |
1158 | part_classifier->dx -= alpha * y * Cn * part_vector->dx; |
1159 | part_classifier->dxx -= alpha * y * Cn * part_vector->dxx; |
1160 | part_classifier->dxx = ccv_max(part_classifier->dxx, 0.01)({ typeof (part_classifier->dxx) _a = (part_classifier-> dxx); typeof (0.01) _b = (0.01); (_a > _b) ? _a : _b; }); |
1161 | part_classifier->dy -= alpha * y * Cn * part_vector->dy; |
1162 | part_classifier->dyy -= alpha * y * Cn * part_vector->dyy; |
1163 | part_classifier->dyy = ccv_max(part_classifier->dyy, 0.01)({ typeof (part_classifier->dyy) _a = (part_classifier-> dyy); typeof (0.01) _b = (0.01); (_a > _b) ? _a : _b; }); |
1164 | vptr = part_vector->w->data.f32; |
1165 | wptr = part_classifier->w->data.f32; |
1166 | if (symmetric) |
1167 | { |
1168 | // 2x converge on everything for symmetric feature |
1169 | if (part_classifier->counterpart == -1) |
1170 | { |
1171 | part_classifier->dx += /* flip the sign on x-axis (symmetric) */ alpha * y * Cn * part_vector->dx; |
1172 | part_classifier->dxx -= alpha * y * Cn * part_vector->dxx; |
1173 | part_classifier->dxx = ccv_max(part_classifier->dxx, 0.01)({ typeof (part_classifier->dxx) _a = (part_classifier-> dxx); typeof (0.01) _b = (0.01); (_a > _b) ? _a : _b; }); |
1174 | part_classifier->dy -= alpha * y * Cn * part_vector->dy; |
1175 | part_classifier->dyy -= alpha * y * Cn * part_vector->dyy; |
1176 | part_classifier->dyy = ccv_max(part_classifier->dyy, 0.01)({ typeof (part_classifier->dyy) _a = (part_classifier-> dyy); typeof (0.01) _b = (0.01); (_a > _b) ? _a : _b; }); |
1177 | for (i = 0; i < part_vector->w->rows; i++) |
1178 | { |
1179 | for (j = 0; j < part_vector->w->cols; j++) |
1180 | for (c = 0; c < ch; c++) |
1181 | { |
1182 | wptr[j * ch + c] += alpha * y * Cn * vptr[j * ch + c]; |
1183 | wptr[j * ch + c] += alpha * y * Cn * vptr[(part_vector->w->cols - 1 - j) * ch + _ccv_dpm_sym_lut[c]]; |
1184 | } |
1185 | vptr += part_vector->w->cols * ch; |
1186 | wptr += part_classifier->w->cols * ch; |
1187 | } |
1188 | } else { |
1189 | ccv_dpm_part_classifier_t* other_part_classifier = root_classifier->part + part_classifier->counterpart; |
1190 | assert(part_vector->w->rows == other_part_classifier->w->rows && part_vector->w->cols == other_part_classifier->w->cols)((void) sizeof ((part_vector->w->rows == other_part_classifier ->w->rows && part_vector->w->cols == other_part_classifier ->w->cols) ? 1 : 0), __extension__ ({ if (part_vector-> w->rows == other_part_classifier->w->rows && part_vector->w->cols == other_part_classifier->w-> cols) ; else __assert_fail ("part_vector->w->rows == other_part_classifier->w->rows && part_vector->w->cols == other_part_classifier->w->cols" , "ccv_dpm.c", 1190, __extension__ __PRETTY_FUNCTION__); })); |
1191 | other_part_classifier->dx += /* flip the sign on x-axis (symmetric) */ alpha * y * Cn * part_vector->dx; |
1192 | other_part_classifier->dxx -= alpha * y * Cn * part_vector->dxx; |
1193 | other_part_classifier->dxx = ccv_max(other_part_classifier->dxx, 0.01)({ typeof (other_part_classifier->dxx) _a = (other_part_classifier ->dxx); typeof (0.01) _b = (0.01); (_a > _b) ? _a : _b; }); |
1194 | other_part_classifier->dy -= alpha * y * Cn * part_vector->dy; |
1195 | other_part_classifier->dyy -= alpha * y * Cn * part_vector->dyy; |
1196 | other_part_classifier->dyy = ccv_max(other_part_classifier->dyy, 0.01)({ typeof (other_part_classifier->dyy) _a = (other_part_classifier ->dyy); typeof (0.01) _b = (0.01); (_a > _b) ? _a : _b; }); |
1197 | for (i = 0; i < part_vector->w->rows; i++) |
1198 | { |
1199 | for (j = 0; j < part_vector->w->cols * ch; j++) |
1200 | wptr[j] += alpha * y * Cn * vptr[j]; |
1201 | vptr += part_vector->w->cols * ch; |
1202 | wptr += part_classifier->w->cols * ch; |
1203 | } |
1204 | vptr = part_vector->w->data.f32; |
1205 | wptr = other_part_classifier->w->data.f32; |
1206 | for (i = 0; i < part_vector->w->rows; i++) |
1207 | { |
1208 | for (j = 0; j < part_vector->w->cols; j++) |
1209 | for (c = 0; c < ch; c++) |
1210 | wptr[j * ch + c] += alpha * y * Cn * vptr[(part_vector->w->cols - 1 - j) * ch + _ccv_dpm_sym_lut[c]]; |
1211 | vptr += part_vector->w->cols * ch; |
1212 | wptr += other_part_classifier->w->cols * ch; |
1213 | } |
1214 | } |
1215 | } else { |
1216 | for (i = 0; i < part_vector->w->rows * part_vector->w->cols * ch; i++) |
1217 | wptr[i] += alpha * y * Cn * vptr[i]; |
1218 | } |
1219 | ccv_make_matrix_immutable(part_classifier->w); |
1220 | } |
1221 | } |
1222 | |
1223 | static void _ccv_dpm_write_gradient_descent_progress(int i, int j, const char* dir) |
1224 | { |
1225 | char swpfile[1024]; |
1226 | sprintf(swpfile, "%s.swp", dir); |
1227 | FILE* w = fopen(swpfile, "w+"); |
1228 | if (!w) |
1229 | return; |
1230 | fprintf(w, "%d %d\n", i, j); |
1231 | fclose(w); |
1232 | rename(swpfile, dir); |
1233 | } |
1234 | |
1235 | static void _ccv_dpm_read_gradient_descent_progress(int* i, int* j, const char* dir) |
1236 | { |
1237 | FILE* r = fopen(dir, "r"); |
1238 | if (!r) |
1239 | return; |
1240 | fscanf(r, "%d %d", i, j); |
1241 | fclose(r); |
1242 | } |
1243 | |
1244 | static void _ccv_dpm_write_feature_vector(FILE* w, ccv_dpm_feature_vector_t* v) |
1245 | { |
1246 | int j, x, y, ch; |
1247 | if (v) |
1248 | { |
1249 | fprintf(w, "%d %d %d\n", v->id, v->root.w->rows, v->root.w->cols); |
1250 | ch = CCV_GET_CHANNEL(v->root.w->type)((v->root.w->type) & 0xFFF); |
1251 | for (y = 0; y < v->root.w->rows; y++) |
1252 | { |
1253 | for (x = 0; x < v->root.w->cols * ch; x++) |
1254 | fprintf(w, "%a ", v->root.w->data.f32[y * v->root.w->cols * ch + x]); |
1255 | fprintf(w, "\n"); |
1256 | } |
1257 | fprintf(w, "%d %a\n", v->count, v->score); |
1258 | for (j = 0; j < v->count; j++) |
1259 | { |
1260 | ccv_dpm_part_classifier_t* part_classifier = v->part + j; |
1261 | fprintf(w, "%la %la %la %la\n", part_classifier->dx, part_classifier->dy, part_classifier->dxx, part_classifier->dyy); |
1262 | fprintf(w, "%d %d %d\n", part_classifier->x, part_classifier->y, part_classifier->z); |
1263 | fprintf(w, "%d %d\n", part_classifier->w->rows, part_classifier->w->cols); |
1264 | ch = CCV_GET_CHANNEL(part_classifier->w->type)((part_classifier->w->type) & 0xFFF); |
1265 | for (y = 0; y < part_classifier->w->rows; y++) |
1266 | { |
1267 | for (x = 0; x < part_classifier->w->cols * ch; x++) |
1268 | fprintf(w, "%a ", part_classifier->w->data.f32[y * part_classifier->w->cols * ch + x]); |
1269 | fprintf(w, "\n"); |
1270 | } |
1271 | } |
1272 | } else { |
1273 | fprintf(w, "0 0 0\n"); |
1274 | } |
1275 | } |
1276 | |
1277 | static ccv_dpm_feature_vector_t* _ccv_dpm_read_feature_vector(FILE* r) |
1278 | { |
1279 | int id, rows, cols, j, k; |
1280 | fscanf(r, "%d %d %d", &id, &rows, &cols); |
1281 | if (rows == 0 && cols == 0) |
1282 | return 0; |
1283 | ccv_dpm_feature_vector_t* v = (ccv_dpm_feature_vector_t*)ccmallocmalloc(sizeof(ccv_dpm_feature_vector_t)); |
1284 | v->id = id; |
1285 | v->root.w = ccv_dense_matrix_new(rows, cols, CCV_32F | 31, 0, 0); |
1286 | for (j = 0; j < rows * cols * 31; j++) |
1287 | fscanf(r, "%f", &v->root.w->data.f32[j]); |
1288 | fscanf(r, "%d %f", &v->count, &v->score); |
1289 | v->part = (ccv_dpm_part_classifier_t*)ccmallocmalloc(sizeof(ccv_dpm_part_classifier_t) * v->count); |
1290 | for (j = 0; j < v->count; j++) |
1291 | { |
1292 | ccv_dpm_part_classifier_t* part_classifier = v->part + j; |
1293 | fscanf(r, "%lf %lf %lf %lf", &part_classifier->dx, &part_classifier->dy, &part_classifier->dxx, &part_classifier->dyy); |
1294 | fscanf(r, "%d %d %d", &part_classifier->x, &part_classifier->y, &part_classifier->z); |
1295 | fscanf(r, "%d %d", &rows, &cols); |
1296 | part_classifier->w = ccv_dense_matrix_new(rows, cols, CCV_32F | 31, 0, 0); |
1297 | for (k = 0; k < rows * cols * 31; k++) |
1298 | fscanf(r, "%f", &part_classifier->w->data.f32[k]); |
1299 | } |
1300 | return v; |
1301 | } |
1302 | |
1303 | static void _ccv_dpm_write_positive_feature_vectors(ccv_dpm_feature_vector_t** vs, int n, const char* dir) |
1304 | { |
1305 | FILE* w = fopen(dir, "w+"); |
1306 | if (!w) |
1307 | return; |
1308 | fprintf(w, "%d\n", n); |
1309 | int i; |
1310 | for (i = 0; i < n; i++) |
1311 | _ccv_dpm_write_feature_vector(w, vs[i]); |
1312 | fclose(w); |
1313 | } |
1314 | |
1315 | static int _ccv_dpm_read_positive_feature_vectors(ccv_dpm_feature_vector_t** vs, int _n, const char* dir) |
1316 | { |
1317 | FILE* r = fopen(dir, "r"); |
1318 | if (!r) |
1319 | return -1; |
1320 | int n; |
1321 | fscanf(r, "%d", &n); |
1322 | assert(n == _n)((void) sizeof ((n == _n) ? 1 : 0), __extension__ ({ if (n == _n) ; else __assert_fail ("n == _n", "ccv_dpm.c", 1322, __extension__ __PRETTY_FUNCTION__); })); |
1323 | int i; |
1324 | for (i = 0; i < n; i++) |
1325 | vs[i] = _ccv_dpm_read_feature_vector(r); |
1326 | fclose(r); |
1327 | return 0; |
1328 | } |
1329 | |
1330 | static void _ccv_dpm_write_negative_feature_vectors(ccv_array_t* negv, int negative_cache_size, const char* dir) |
1331 | { |
1332 | FILE* w = fopen(dir, "w+"); |
1333 | if (!w) |
1334 | return; |
1335 | fprintf(w, "%d %d\n", negative_cache_size, negv->rnum); |
1336 | int i; |
1337 | for (i = 0; i < negv->rnum; i++) |
1338 | { |
1339 | ccv_dpm_feature_vector_t* v = *(ccv_dpm_feature_vector_t**)ccv_array_get(negv, i)((void*)(((char*)((negv)->data)) + (size_t)(negv)->rsize * (size_t)(i))); |
1340 | _ccv_dpm_write_feature_vector(w, v); |
1341 | } |
1342 | fclose(w); |
1343 | } |
1344 | |
1345 | static int _ccv_dpm_read_negative_feature_vectors(ccv_array_t** _negv, int _negative_cache_size, const char* dir) |
1346 | { |
1347 | FILE* r = fopen(dir, "r"); |
1348 | if (!r) |
1349 | return -1; |
1350 | int negative_cache_size, negnum; |
1351 | fscanf(r, "%d %d", &negative_cache_size, &negnum); |
1352 | assert(negative_cache_size == _negative_cache_size)((void) sizeof ((negative_cache_size == _negative_cache_size) ? 1 : 0), __extension__ ({ if (negative_cache_size == _negative_cache_size ) ; else __assert_fail ("negative_cache_size == _negative_cache_size" , "ccv_dpm.c", 1352, __extension__ __PRETTY_FUNCTION__); })); |
1353 | ccv_array_t* negv = *_negv = ccv_array_new(sizeof(ccv_dpm_feature_vector_t*), negnum, 0); |
1354 | int i; |
1355 | for (i = 0; i < negnum; i++) |
1356 | { |
1357 | ccv_dpm_feature_vector_t* v = _ccv_dpm_read_feature_vector(r); |
1358 | assert(v)((void) sizeof ((v) ? 1 : 0), __extension__ ({ if (v) ; else __assert_fail ("v", "ccv_dpm.c", 1358, __extension__ __PRETTY_FUNCTION__); })); |
1359 | ccv_array_push(negv, &v); |
1360 | } |
1361 | fclose(r); |
1362 | return 0; |
1363 | } |
1364 | |
1365 | static void _ccv_dpm_adjust_model_constant(ccv_dpm_mixture_model_t* model, int k, ccv_dpm_feature_vector_t** posv, int posnum, double percentile) |
1366 | { |
1367 | int i, j; |
1368 | double* scores = (double*)ccmallocmalloc(posnum * sizeof(double)); |
1369 | j = 0; |
1370 | for (i = 0; i < posnum; i++) |
1371 | if (posv[i] && posv[i]->id == k) |
1372 | { |
1373 | scores[j] = _ccv_dpm_vector_score(model, posv[i]); |
1374 | j++; |
1375 | } |
1376 | _ccv_dpm_score_qsort(scores, j, 0); |
1377 | float adjust = scores[ccv_clamp((int)(percentile * j), 0, j - 1)({ typeof (0) _a = (0); typeof (j - 1) _b = (j - 1); typeof ( (int)(percentile * j)) _x = ((int)(percentile * j)); (_x < _a) ? _a : ((_x > _b) ? _b : _x); })]; |
1378 | // adjust to percentile |
1379 | model->root[k].beta -= adjust; |
1380 | PRINT(CCV_CLI_INFO, " - tune model %d constant for %f\n", k + 1, -adjust)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (" - tune model %d constant for %f\n", k + 1, -adjust); fflush (stdout); } } while (0); |
1381 | ccfreefree(scores); |
1382 | } |
1383 | |
1384 | static void _ccv_dpm_check_params(ccv_dpm_new_param_t params) |
1385 | { |
1386 | assert(params.components > 0)((void) sizeof ((params.components > 0) ? 1 : 0), __extension__ ({ if (params.components > 0) ; else __assert_fail ("params.components > 0" , "ccv_dpm.c", 1386, __extension__ __PRETTY_FUNCTION__); })); |
1387 | assert(params.parts > 0)((void) sizeof ((params.parts > 0) ? 1 : 0), __extension__ ({ if (params.parts > 0) ; else __assert_fail ("params.parts > 0" , "ccv_dpm.c", 1387, __extension__ __PRETTY_FUNCTION__); })); |
1388 | assert(params.grayscale == 0 || params.grayscale == 1)((void) sizeof ((params.grayscale == 0 || params.grayscale == 1) ? 1 : 0), __extension__ ({ if (params.grayscale == 0 || params .grayscale == 1) ; else __assert_fail ("params.grayscale == 0 || params.grayscale == 1" , "ccv_dpm.c", 1388, __extension__ __PRETTY_FUNCTION__); })); |
1389 | assert(params.symmetric == 0 || params.symmetric == 1)((void) sizeof ((params.symmetric == 0 || params.symmetric == 1) ? 1 : 0), __extension__ ({ if (params.symmetric == 0 || params .symmetric == 1) ; else __assert_fail ("params.symmetric == 0 || params.symmetric == 1" , "ccv_dpm.c", 1389, __extension__ __PRETTY_FUNCTION__); })); |
1390 | assert(params.min_area > 100)((void) sizeof ((params.min_area > 100) ? 1 : 0), __extension__ ({ if (params.min_area > 100) ; else __assert_fail ("params.min_area > 100" , "ccv_dpm.c", 1390, __extension__ __PRETTY_FUNCTION__); })); |
1391 | assert(params.max_area > params.min_area)((void) sizeof ((params.max_area > params.min_area) ? 1 : 0 ), __extension__ ({ if (params.max_area > params.min_area) ; else __assert_fail ("params.max_area > params.min_area" , "ccv_dpm.c", 1391, __extension__ __PRETTY_FUNCTION__); })); |
1392 | assert(params.iterations >= 0)((void) sizeof ((params.iterations >= 0) ? 1 : 0), __extension__ ({ if (params.iterations >= 0) ; else __assert_fail ("params.iterations >= 0" , "ccv_dpm.c", 1392, __extension__ __PRETTY_FUNCTION__); })); |
1393 | assert(params.data_minings >= 0)((void) sizeof ((params.data_minings >= 0) ? 1 : 0), __extension__ ({ if (params.data_minings >= 0) ; else __assert_fail ("params.data_minings >= 0" , "ccv_dpm.c", 1393, __extension__ __PRETTY_FUNCTION__); })); |
1394 | assert(params.relabels >= 0)((void) sizeof ((params.relabels >= 0) ? 1 : 0), __extension__ ({ if (params.relabels >= 0) ; else __assert_fail ("params.relabels >= 0" , "ccv_dpm.c", 1394, __extension__ __PRETTY_FUNCTION__); })); |
1395 | assert(params.negative_cache_size > 0)((void) sizeof ((params.negative_cache_size > 0) ? 1 : 0), __extension__ ({ if (params.negative_cache_size > 0) ; else __assert_fail ("params.negative_cache_size > 0", "ccv_dpm.c" , 1395, __extension__ __PRETTY_FUNCTION__); })); |
1396 | assert(params.include_overlap > 0.1)((void) sizeof ((params.include_overlap > 0.1) ? 1 : 0), __extension__ ({ if (params.include_overlap > 0.1) ; else __assert_fail ("params.include_overlap > 0.1", "ccv_dpm.c", 1396, __extension__ __PRETTY_FUNCTION__); })); |
1397 | assert(params.alpha > 0 && params.alpha < 1)((void) sizeof ((params.alpha > 0 && params.alpha < 1) ? 1 : 0), __extension__ ({ if (params.alpha > 0 && params.alpha < 1) ; else __assert_fail ("params.alpha > 0 && params.alpha < 1" , "ccv_dpm.c", 1397, __extension__ __PRETTY_FUNCTION__); })); |
1398 | assert(params.alpha_ratio > 0 && params.alpha_ratio < 1)((void) sizeof ((params.alpha_ratio > 0 && params. alpha_ratio < 1) ? 1 : 0), __extension__ ({ if (params.alpha_ratio > 0 && params.alpha_ratio < 1) ; else __assert_fail ("params.alpha_ratio > 0 && params.alpha_ratio < 1" , "ccv_dpm.c", 1398, __extension__ __PRETTY_FUNCTION__); })); |
1399 | assert(params.C > 0)((void) sizeof ((params.C > 0) ? 1 : 0), __extension__ ({ if (params.C > 0) ; else __assert_fail ("params.C > 0", "ccv_dpm.c" , 1399, __extension__ __PRETTY_FUNCTION__); })); |
1400 | assert(params.balance > 0)((void) sizeof ((params.balance > 0) ? 1 : 0), __extension__ ({ if (params.balance > 0) ; else __assert_fail ("params.balance > 0" , "ccv_dpm.c", 1400, __extension__ __PRETTY_FUNCTION__); })); |
1401 | assert(params.percentile_breakdown > 0 && params.percentile_breakdown <= 1)((void) sizeof ((params.percentile_breakdown > 0 && params.percentile_breakdown <= 1) ? 1 : 0), __extension__ ({ if (params.percentile_breakdown > 0 && params. percentile_breakdown <= 1) ; else __assert_fail ("params.percentile_breakdown > 0 && params.percentile_breakdown <= 1" , "ccv_dpm.c", 1401, __extension__ __PRETTY_FUNCTION__); })); |
1402 | assert(params.detector.interval > 0)((void) sizeof ((params.detector.interval > 0) ? 1 : 0), __extension__ ({ if (params.detector.interval > 0) ; else __assert_fail ("params.detector.interval > 0", "ccv_dpm.c", 1402, __extension__ __PRETTY_FUNCTION__); })); |
1403 | } |
1404 | |
1405 | #define MINI_BATCH(10) (10) |
1406 | #define REGQ(100) (100) |
1407 | |
1408 | static ccv_dpm_mixture_model_t* _ccv_dpm_optimize_root_mixture_model(gsl_rng* rng, ccv_dpm_mixture_model_t* model, ccv_array_t** posex, ccv_array_t** negex, int relabels, double balance, double C, double previous_alpha, double alpha_ratio, int iterations, int symmetric) |
1409 | { |
1410 | int i, j, k, t, c; |
1411 | for (i = 0; i < model->count - 1; i++) |
1412 | assert(posex[i]->rnum == posex[i + 1]->rnum && negex[i]->rnum == negex[i + 1]->rnum)((void) sizeof ((posex[i]->rnum == posex[i + 1]->rnum && negex[i]->rnum == negex[i + 1]->rnum) ? 1 : 0), __extension__ ({ if (posex[i]->rnum == posex[i + 1]->rnum && negex[i]->rnum == negex[i + 1]->rnum) ; else __assert_fail ("posex[i]->rnum == posex[i + 1]->rnum && negex[i]->rnum == negex[i + 1]->rnum" , "ccv_dpm.c", 1412, __extension__ __PRETTY_FUNCTION__); })); |
1413 | int posnum = posex[0]->rnum; |
1414 | int negnum = negex[0]->rnum; |
1415 | int* label = (int*)ccmallocmalloc(sizeof(int) * (posnum + negnum)); |
1416 | int* order = (int*)ccmallocmalloc(sizeof(int) * (posnum + negnum)); |
1417 | double previous_positive_loss = 0, previous_negative_loss = 0, positive_loss = 0, negative_loss = 0, loss = 0; |
1418 | double regz_rate = C; |
1419 | for (c = 0; c < relabels; c++) |
1420 | { |
1421 | int* pos_prog = (int*)alloca(sizeof(int) * model->count)__builtin_alloca (sizeof(int) * model->count); |
1422 | memset(pos_prog, 0, sizeof(int) * model->count); |
1423 | for (i = 0; i < posnum; i++) |
1424 | { |
1425 | int best = -1; |
1426 | double best_score = -DBL_MAX1.7976931348623157e+308; |
1427 | for (k = 0; k < model->count; k++) |
1428 | { |
1429 | ccv_dpm_feature_vector_t* v = (ccv_dpm_feature_vector_t*)ccv_array_get(posex[k], i)((void*)(((char*)((posex[k])->data)) + (size_t)(posex[k])-> rsize * (size_t)(i))); |
1430 | if (v->root.w == 0) |
1431 | continue; |
1432 | double score = _ccv_dpm_vector_score(model, v); // the loss for mini-batch method (computed on model) |
1433 | if (score > best_score) |
1434 | { |
1435 | best = k; |
1436 | best_score = score; |
1437 | } |
1438 | } |
1439 | label[i] = best; |
1440 | if (best >= 0) |
1441 | ++pos_prog[best]; |
1442 | } |
1443 | PRINT(CCV_CLI_INFO, " - positive examples divided by components for root model optimizing : %d", pos_prog[0])do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (" - positive examples divided by components for root model optimizing : %d" , pos_prog[0]); fflush(stdout); } } while (0); |
1444 | for (i = 1; i < model->count; i++) |
1445 | PRINT(CCV_CLI_INFO, ", %d", pos_prog[i])do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (", %d", pos_prog[i]); fflush(stdout); } } while (0); |
1446 | PRINT(CCV_CLI_INFO, "\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("\n"); fflush(stdout); } } while (0); |
1447 | int* neg_prog = (int*)alloca(sizeof(int) * model->count)__builtin_alloca (sizeof(int) * model->count); |
1448 | memset(neg_prog, 0, sizeof(int) * model->count); |
1449 | for (i = 0; i < negnum; i++) |
1450 | { |
1451 | int best = gsl_rng_uniform_int(rng, model->count); |
1452 | label[i + posnum] = best; |
1453 | ++neg_prog[best]; |
1454 | } |
1455 | PRINT(CCV_CLI_INFO, " - negative examples divided by components for root model optimizing : %d", neg_prog[0])do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (" - negative examples divided by components for root model optimizing : %d" , neg_prog[0]); fflush(stdout); } } while (0); |
1456 | for (i = 1; i < model->count; i++) |
1457 | PRINT(CCV_CLI_INFO, ", %d", neg_prog[i])do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (", %d", neg_prog[i]); fflush(stdout); } } while (0); |
1458 | PRINT(CCV_CLI_INFO, "\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("\n"); fflush(stdout); } } while (0); |
1459 | ccv_dpm_mixture_model_t* _model; |
1460 | double alpha = previous_alpha; |
1461 | previous_positive_loss = previous_negative_loss = 0; |
1462 | for (t = 0; t < iterations; t++) |
1463 | { |
1464 | for (i = 0; i < posnum + negnum; i++) |
1465 | order[i] = i; |
1466 | gsl_ran_shuffle(rng, order, posnum + negnum, sizeof(int)); |
1467 | for (j = 0; j < model->count; j++) |
1468 | { |
1469 | double pos_weight = sqrt((double)neg_prog[j] / pos_prog[j] * balance); // positive weight |
1470 | double neg_weight = sqrt((double)pos_prog[j] / neg_prog[j] / balance); // negative weight |
1471 | _model = _ccv_dpm_model_copy(model); |
1472 | int l = 0; |
1473 | for (i = 0; i < posnum + negnum; i++) |
1474 | { |
1475 | k = order[i]; |
1476 | if (label[k] == j) |
1477 | { |
1478 | assert(label[k] < model->count)((void) sizeof ((label[k] < model->count) ? 1 : 0), __extension__ ({ if (label[k] < model->count) ; else __assert_fail ( "label[k] < model->count", "ccv_dpm.c", 1478, __extension__ __PRETTY_FUNCTION__); })); |
1479 | if (k < posnum) |
1480 | { |
1481 | ccv_dpm_feature_vector_t* v = (ccv_dpm_feature_vector_t*)ccv_array_get(posex[label[k]], k)((void*)(((char*)((posex[label[k]])->data)) + (size_t)(posex [label[k]])->rsize * (size_t)(k))); |
1482 | assert(v->root.w)((void) sizeof ((v->root.w) ? 1 : 0), __extension__ ({ if ( v->root.w) ; else __assert_fail ("v->root.w", "ccv_dpm.c" , 1482, __extension__ __PRETTY_FUNCTION__); })); |
1483 | double score = _ccv_dpm_vector_score(model, v); // the loss for mini-batch method (computed on model) |
1484 | assert(!isnan(score))((void) sizeof ((!__builtin_isnan (score)) ? 1 : 0), __extension__ ({ if (!__builtin_isnan (score)) ; else __assert_fail ("!isnan(score)" , "ccv_dpm.c", 1484, __extension__ __PRETTY_FUNCTION__); })); |
1485 | assert(v->id == j)((void) sizeof ((v->id == j) ? 1 : 0), __extension__ ({ if (v->id == j) ; else __assert_fail ("v->id == j", "ccv_dpm.c" , 1485, __extension__ __PRETTY_FUNCTION__); })); |
1486 | if (score <= 1) |
1487 | _ccv_dpm_stochastic_gradient_descent(_model, v, 1, alpha * pos_weight, regz_rate, symmetric); |
1488 | } else { |
1489 | ccv_dpm_feature_vector_t* v = (ccv_dpm_feature_vector_t*)ccv_array_get(negex[label[k]], k - posnum)((void*)(((char*)((negex[label[k]])->data)) + (size_t)(negex [label[k]])->rsize * (size_t)(k - posnum))); |
1490 | double score = _ccv_dpm_vector_score(model, v); |
1491 | assert(!isnan(score))((void) sizeof ((!__builtin_isnan (score)) ? 1 : 0), __extension__ ({ if (!__builtin_isnan (score)) ; else __assert_fail ("!isnan(score)" , "ccv_dpm.c", 1491, __extension__ __PRETTY_FUNCTION__); })); |
1492 | assert(v->id == j)((void) sizeof ((v->id == j) ? 1 : 0), __extension__ ({ if (v->id == j) ; else __assert_fail ("v->id == j", "ccv_dpm.c" , 1492, __extension__ __PRETTY_FUNCTION__); })); |
1493 | if (score >= -1) |
1494 | _ccv_dpm_stochastic_gradient_descent(_model, v, -1, alpha * neg_weight, regz_rate, symmetric); |
1495 | } |
1496 | ++l; |
1497 | if (l % REGQ(100) == REGQ(100) - 1) |
1498 | _ccv_dpm_regularize_mixture_model(_model, j, 1.0 - pow(1.0 - alpha / (double)((pos_prog[j] + neg_prog[j]) * (!!symmetric + 1)), REGQ(100))); |
1499 | if (l % MINI_BATCH(10) == MINI_BATCH(10) - 1) |
1500 | { |
1501 | // mimicking mini-batch way of doing things |
1502 | _ccv_dpm_mixture_model_cleanup(model); |
1503 | ccfreefree(model); |
1504 | model = _model; |
1505 | _model = _ccv_dpm_model_copy(model); |
1506 | } |
1507 | } |
1508 | } |
1509 | _ccv_dpm_regularize_mixture_model(_model, j, 1.0 - pow(1.0 - alpha / (double)((pos_prog[j] + neg_prog[j]) * (!!symmetric + 1)), (((pos_prog[j] + neg_prog[j]) % REGQ(100)) + 1) % (REGQ(100) + 1))); |
1510 | _ccv_dpm_mixture_model_cleanup(model); |
1511 | ccfreefree(model); |
1512 | model = _model; |
1513 | } |
1514 | // compute the loss |
1515 | positive_loss = negative_loss = loss = 0; |
1516 | int posvn = 0; |
1517 | for (i = 0; i < posnum; i++) |
1518 | { |
1519 | if (label[i] < 0) |
1520 | continue; |
1521 | assert(label[i] < model->count)((void) sizeof ((label[i] < model->count) ? 1 : 0), __extension__ ({ if (label[i] < model->count) ; else __assert_fail ( "label[i] < model->count", "ccv_dpm.c", 1521, __extension__ __PRETTY_FUNCTION__); })); |
1522 | ccv_dpm_feature_vector_t* v = (ccv_dpm_feature_vector_t*)ccv_array_get(posex[label[i]], i)((void*)(((char*)((posex[label[i]])->data)) + (size_t)(posex [label[i]])->rsize * (size_t)(i))); |
1523 | if (v->root.w) |
1524 | { |
1525 | double score = _ccv_dpm_vector_score(model, v); |
1526 | assert(!isnan(score))((void) sizeof ((!__builtin_isnan (score)) ? 1 : 0), __extension__ ({ if (!__builtin_isnan (score)) ; else __assert_fail ("!isnan(score)" , "ccv_dpm.c", 1526, __extension__ __PRETTY_FUNCTION__); })); |
1527 | double hinge_loss = ccv_max(0, 1.0 - score)({ typeof (0) _a = (0); typeof (1.0 - score) _b = (1.0 - score ); (_a > _b) ? _a : _b; }); |
1528 | positive_loss += hinge_loss; |
1529 | double pos_weight = sqrt((double)neg_prog[v->id] / pos_prog[v->id] * balance); // positive weight |
1530 | loss += pos_weight * hinge_loss; |
1531 | ++posvn; |
1532 | } |
1533 | } |
1534 | for (i = 0; i < negnum; i++) |
1535 | { |
1536 | if (label[i + posnum] < 0) |
1537 | continue; |
1538 | assert(label[i + posnum] < model->count)((void) sizeof ((label[i + posnum] < model->count) ? 1 : 0), __extension__ ({ if (label[i + posnum] < model->count ) ; else __assert_fail ("label[i + posnum] < model->count" , "ccv_dpm.c", 1538, __extension__ __PRETTY_FUNCTION__); })); |
1539 | ccv_dpm_feature_vector_t* v = (ccv_dpm_feature_vector_t*)ccv_array_get(negex[label[i + posnum]], i)((void*)(((char*)((negex[label[i + posnum]])->data)) + (size_t )(negex[label[i + posnum]])->rsize * (size_t)(i))); |
1540 | double score = _ccv_dpm_vector_score(model, v); |
1541 | assert(!isnan(score))((void) sizeof ((!__builtin_isnan (score)) ? 1 : 0), __extension__ ({ if (!__builtin_isnan (score)) ; else __assert_fail ("!isnan(score)" , "ccv_dpm.c", 1541, __extension__ __PRETTY_FUNCTION__); })); |
1542 | double hinge_loss = ccv_max(0, 1.0 + score)({ typeof (0) _a = (0); typeof (1.0 + score) _b = (1.0 + score ); (_a > _b) ? _a : _b; }); |
1543 | negative_loss += hinge_loss; |
1544 | double neg_weight = sqrt((double)pos_prog[v->id] / neg_prog[v->id] / balance); // negative weight |
1545 | loss += neg_weight * hinge_loss; |
1546 | } |
1547 | loss = loss / (posvn + negnum); |
1548 | positive_loss = positive_loss / posvn; |
1549 | negative_loss = negative_loss / negnum; |
1550 | FLUSH(CCV_CLI_INFO, " - with loss %.5lf (positive %.5lf, negative %.5f) at rate %.5lf %d | %d -- %d%%", loss, positive_loss, negative_loss, alpha, posvn, negnum, (t + 1) * 100 / iterations)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf("\b"); for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf(" "); for ( _CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP ++) printf("\b"); _CCV_PRINT_COUNT = printf(" - with loss %.5lf (positive %.5lf, negative %.5f) at rate %.5lf %d | %d -- %d%%" , loss, positive_loss, negative_loss, alpha, posvn, negnum, ( t + 1) * 100 / iterations); fflush(stdout); } } while (0); |
1551 | // check symmetric property of generated root feature |
1552 | if (symmetric) |
1553 | for (i = 0; i < model->count; i++) |
1554 | { |
1555 | ccv_dpm_root_classifier_t* root_classifier = model->root + i; |
1556 | _ccv_dpm_check_root_classifier_symmetry(root_classifier->root.w); |
1557 | } |
1558 | if (fabs(previous_positive_loss - positive_loss) < 1e-5 && |
1559 | fabs(previous_negative_loss - negative_loss) < 1e-5) |
1560 | { |
1561 | PRINT(CCV_CLI_INFO, "\n - aborting iteration at %d because we didn't gain much", t + 1)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("\n - aborting iteration at %d because we didn't gain much", t + 1); fflush(stdout); } } while (0); |
1562 | break; |
1563 | } |
1564 | previous_positive_loss = positive_loss; |
1565 | previous_negative_loss = negative_loss; |
1566 | alpha *= alpha_ratio; // it will decrease with each iteration |
1567 | } |
1568 | PRINT(CCV_CLI_INFO, "\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("\n"); fflush(stdout); } } while (0); |
1569 | } |
1570 | ccfreefree(order); |
1571 | ccfreefree(label); |
1572 | return model; |
1573 | } |
1574 | |
1575 | void ccv_dpm_mixture_model_new(char** posfiles, ccv_rect_t* bboxes, int posnum, char** bgfiles, int bgnum, int negnum, const char* dir, ccv_dpm_new_param_t params) |
1576 | { |
1577 | int t, d, c, i, j, k, p; |
1578 | _ccv_dpm_check_params(params); |
1579 | assert(params.negative_cache_size <= negnum && params.negative_cache_size > REGQ && params.negative_cache_size > MINI_BATCH)((void) sizeof ((params.negative_cache_size <= negnum && params.negative_cache_size > (100) && params.negative_cache_size > (10)) ? 1 : 0), __extension__ ({ if (params.negative_cache_size <= negnum && params.negative_cache_size > (100 ) && params.negative_cache_size > (10)) ; else __assert_fail ("params.negative_cache_size <= negnum && params.negative_cache_size > REGQ && params.negative_cache_size > MINI_BATCH" , "ccv_dpm.c", 1579, __extension__ __PRETTY_FUNCTION__); })); |
1580 | PRINT(CCV_CLI_INFO, "with %d positive examples and %d negative examples\n"do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("with %d positive examples and %d negative examples\n" "negative examples are are going to be collected from %d background images\n" , posnum, negnum, bgnum); fflush(stdout); } } while (0) |
1581 | "negative examples are are going to be collected from %d background images\n",do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("with %d positive examples and %d negative examples\n" "negative examples are are going to be collected from %d background images\n" , posnum, negnum, bgnum); fflush(stdout); } } while (0) |
1582 | posnum, negnum, bgnum)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("with %d positive examples and %d negative examples\n" "negative examples are are going to be collected from %d background images\n" , posnum, negnum, bgnum); fflush(stdout); } } while (0); |
1583 | PRINT(CCV_CLI_INFO, "use symmetric property? %s\n", params.symmetric ? "yes" : "no")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("use symmetric property? %s\n", params.symmetric ? "yes" : "no" ); fflush(stdout); } } while (0); |
1584 | PRINT(CCV_CLI_INFO, "use color? %s\n", params.grayscale ? "no" : "yes")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("use color? %s\n", params.grayscale ? "no" : "yes"); fflush( stdout); } } while (0); |
1585 | PRINT(CCV_CLI_INFO, "negative examples cache size : %d\n", params.negative_cache_size)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("negative examples cache size : %d\n", params.negative_cache_size ); fflush(stdout); } } while (0); |
1586 | PRINT(CCV_CLI_INFO, "%d components and %d parts\n", params.components, params.parts)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("%d components and %d parts\n", params.components, params.parts ); fflush(stdout); } } while (0); |
1587 | PRINT(CCV_CLI_INFO, "expected %d root relabels, %d relabels, %d data minings and %d iterations\n", params.root_relabels, params.relabels, params.data_minings, params.iterations)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("expected %d root relabels, %d relabels, %d data minings and %d iterations\n" , params.root_relabels, params.relabels, params.data_minings, params.iterations); fflush(stdout); } } while (0); |
1588 | PRINT(CCV_CLI_INFO, "include overlap : %lf\n"do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("include overlap : %lf\n" "alpha : %lf\n" "alpha decreasing ratio : %lf\n" "C : %lf\n" "balance ratio : %lf\n" "------------------------\n" , params.include_overlap, params.alpha, params.alpha_ratio, params .C, params.balance); fflush(stdout); } } while (0) |
1589 | "alpha : %lf\n"do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("include overlap : %lf\n" "alpha : %lf\n" "alpha decreasing ratio : %lf\n" "C : %lf\n" "balance ratio : %lf\n" "------------------------\n" , params.include_overlap, params.alpha, params.alpha_ratio, params .C, params.balance); fflush(stdout); } } while (0) |
1590 | "alpha decreasing ratio : %lf\n"do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("include overlap : %lf\n" "alpha : %lf\n" "alpha decreasing ratio : %lf\n" "C : %lf\n" "balance ratio : %lf\n" "------------------------\n" , params.include_overlap, params.alpha, params.alpha_ratio, params .C, params.balance); fflush(stdout); } } while (0) |
1591 | "C : %lf\n"do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("include overlap : %lf\n" "alpha : %lf\n" "alpha decreasing ratio : %lf\n" "C : %lf\n" "balance ratio : %lf\n" "------------------------\n" , params.include_overlap, params.alpha, params.alpha_ratio, params .C, params.balance); fflush(stdout); } } while (0) |
1592 | "balance ratio : %lf\n"do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("include overlap : %lf\n" "alpha : %lf\n" "alpha decreasing ratio : %lf\n" "C : %lf\n" "balance ratio : %lf\n" "------------------------\n" , params.include_overlap, params.alpha, params.alpha_ratio, params .C, params.balance); fflush(stdout); } } while (0) |
1593 | "------------------------\n",do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("include overlap : %lf\n" "alpha : %lf\n" "alpha decreasing ratio : %lf\n" "C : %lf\n" "balance ratio : %lf\n" "------------------------\n" , params.include_overlap, params.alpha, params.alpha_ratio, params .C, params.balance); fflush(stdout); } } while (0) |
1594 | params.include_overlap, params.alpha, params.alpha_ratio, params.C, params.balance)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("include overlap : %lf\n" "alpha : %lf\n" "alpha decreasing ratio : %lf\n" "C : %lf\n" "balance ratio : %lf\n" "------------------------\n" , params.include_overlap, params.alpha, params.alpha_ratio, params .C, params.balance); fflush(stdout); } } while (0); |
1595 | gsl_rng_env_setup(); |
1596 | gsl_rng* rng = gsl_rng_alloc(gsl_rng_default); |
1597 | gsl_rng_set(rng, *(unsigned long int*)¶ms); |
1598 | ccv_dpm_mixture_model_t* model = (ccv_dpm_mixture_model_t*)ccmallocmalloc(sizeof(ccv_dpm_mixture_model_t)); |
1599 | memset(model, 0, sizeof(ccv_dpm_mixture_model_t)); |
1600 | struct feature_node* fn = (struct feature_node*)ccmallocmalloc(sizeof(struct feature_node) * posnum); |
1601 | for (i = 0; i < posnum; i++) |
1602 | { |
1603 | assert(bboxes[i].width > 0 && bboxes[i].height > 0)((void) sizeof ((bboxes[i].width > 0 && bboxes[i]. height > 0) ? 1 : 0), __extension__ ({ if (bboxes[i].width > 0 && bboxes[i].height > 0) ; else __assert_fail ("bboxes[i].width > 0 && bboxes[i].height > 0" , "ccv_dpm.c", 1603, __extension__ __PRETTY_FUNCTION__); })); |
1604 | fn[i].value = (float)bboxes[i].width / (float)bboxes[i].height; |
1605 | fn[i].index = i; |
1606 | } |
1607 | char checkpoint[512]; |
1608 | char initcheckpoint[512]; |
1609 | sprintf(checkpoint, "%s/model", dir); |
1610 | sprintf(initcheckpoint, "%s/init.model", dir); |
1611 | _ccv_dpm_aspect_qsort(fn, posnum, 0); |
1612 | double mean = 0; |
1613 | for (i = 0; i < posnum; i++) |
1614 | mean += fn[i].value; |
1615 | mean /= posnum; |
1616 | double variance = 0; |
1617 | for (i = 0; i < posnum; i++) |
1618 | variance += (fn[i].value - mean) * (fn[i].value - mean); |
1619 | variance /= posnum; |
1620 | PRINT(CCV_CLI_INFO, "global mean: %lf, & variance: %lf\ninterclass mean(variance):", mean, variance)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("global mean: %lf, & variance: %lf\ninterclass mean(variance):" , mean, variance); fflush(stdout); } } while (0); |
1621 | int* mnum = (int*)alloca(sizeof(int) * params.components)__builtin_alloca (sizeof(int) * params.components); |
1622 | int outnum = posnum, innum = 0; |
1623 | for (i = 0; i < params.components; i++) |
1624 | { |
1625 | mnum[i] = (int)((double)outnum / (double)(params.components - i) + 0.5); |
1626 | double mean = 0; |
1627 | for (j = innum; j < innum + mnum[i]; j++) |
1628 | mean += fn[j].value; |
1629 | mean /= mnum[i]; |
1630 | double variance = 0; |
1631 | for (j = innum; j < innum + mnum[i]; j++) |
1632 | variance += (fn[j].value - mean) * (fn[j].value - mean); |
1633 | variance /= mnum[i]; |
1634 | PRINT(CCV_CLI_INFO, " %lf(%lf)", mean, variance)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (" %lf(%lf)", mean, variance); fflush(stdout); } } while (0); |
1635 | outnum -= mnum[i]; |
1636 | innum += mnum[i]; |
1637 | } |
1638 | PRINT(CCV_CLI_INFO, "\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("\n"); fflush(stdout); } } while (0); |
1639 | int* areas = (int*)ccmallocmalloc(sizeof(int) * posnum); |
1640 | for (i = 0; i < posnum; i++) |
1641 | areas[i] = bboxes[i].width * bboxes[i].height; |
1642 | _ccv_dpm_area_qsort(areas, posnum, 0); |
1643 | // so even the object is 1/4 in size, we can still detect them (in detection phase, we start at 2x image) |
1644 | int area = ccv_clamp(areas[(int)(posnum * 0.2 + 0.5)], params.min_area, params.max_area)({ typeof (params.min_area) _a = (params.min_area); typeof (params .max_area) _b = (params.max_area); typeof (areas[(int)(posnum * 0.2 + 0.5)]) _x = (areas[(int)(posnum * 0.2 + 0.5)]); (_x < _a) ? _a : ((_x > _b) ? _b : _x); }); |
1645 | ccfreefree(areas); |
1646 | innum = 0; |
1647 | _ccv_dpm_read_checkpoint(model, checkpoint); |
1648 | if (model->count <= 0) |
1649 | { |
1650 | /* initialize root mixture model with liblinear */ |
1651 | model->count = params.components; |
1652 | model->root = (ccv_dpm_root_classifier_t*)ccmallocmalloc(sizeof(ccv_dpm_root_classifier_t) * model->count); |
1653 | memset(model->root, 0, sizeof(ccv_dpm_root_classifier_t) * model->count); |
1654 | } |
1655 | PRINT(CCV_CLI_INFO, "computing root mixture model dimensions: ")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("computing root mixture model dimensions: "); fflush(stdout) ; } } while (0); |
1656 | fflush(stdoutstdout); |
1657 | int* poslabels = (int*)ccmallocmalloc(sizeof(int) * posnum); |
1658 | int* rows = (int*)alloca(sizeof(int) * params.components)__builtin_alloca (sizeof(int) * params.components); |
1659 | int* cols = (int*)alloca(sizeof(int) * params.components)__builtin_alloca (sizeof(int) * params.components); |
1660 | for (i = 0; i < params.components; i++) |
1661 | { |
1662 | double aspect = 0; |
1663 | for (j = innum; j < innum + mnum[i]; j++) |
1664 | { |
1665 | aspect += fn[j].value; |
1666 | poslabels[fn[j].index] = i; // setup labels |
1667 | } |
1668 | aspect /= mnum[i]; |
1669 | cols[i] = ccv_max((int)(sqrtf(area / aspect) * aspect / CCV_DPM_WINDOW_SIZE + 0.5), 1)({ typeof ((int)(sqrtf(area / aspect) * aspect / (8) + 0.5)) _a = ((int)(sqrtf(area / aspect) * aspect / (8) + 0.5)); typeof (1) _b = (1); (_a > _b) ? _a : _b; }); |
1670 | rows[i] = ccv_max((int)(sqrtf(area / aspect) / CCV_DPM_WINDOW_SIZE + 0.5), 1)({ typeof ((int)(sqrtf(area / aspect) / (8) + 0.5)) _a = ((int )(sqrtf(area / aspect) / (8) + 0.5)); typeof (1) _b = (1); (_a > _b) ? _a : _b; }); |
1671 | if (i < params.components - 1) |
1672 | PRINT(CCV_CLI_INFO, "%dx%d, ", cols[i], rows[i])do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("%dx%d, ", cols[i], rows[i]); fflush(stdout); } } while (0); |
1673 | else |
1674 | PRINT(CCV_CLI_INFO, "%dx%d\n", cols[i], rows[i])do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("%dx%d\n", cols[i], rows[i]); fflush(stdout); } } while (0); |
1675 | fflush(stdoutstdout); |
1676 | innum += mnum[i]; |
1677 | } |
1678 | ccfreefree(fn); |
1679 | int corrupted = 1; |
1680 | for (i = 0; i < params.components; i++) |
1681 | if (model->root[i].root.w) |
1682 | { |
1683 | PRINT(CCV_CLI_INFO, "skipping root mixture model initialization for model %d(%d)\n", i + 1, params.components)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("skipping root mixture model initialization for model %d(%d)\n" , i + 1, params.components); fflush(stdout); } } while (0); |
1684 | corrupted = 0; |
1685 | } else |
1686 | break; |
1687 | if (corrupted) |
1688 | { |
1689 | PRINT(CCV_CLI_INFO, "root mixture model initialization corrupted, reboot\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("root mixture model initialization corrupted, reboot\n"); fflush (stdout); } } while (0); |
1690 | ccv_array_t** posex = (ccv_array_t**)alloca(sizeof(ccv_array_t*) * params.components)__builtin_alloca (sizeof(ccv_array_t*) * params.components); |
1691 | for (i = 0; i < params.components; i++) |
1692 | posex[i] = _ccv_dpm_summon_examples_by_rectangle(posfiles, bboxes, posnum, i, rows[i], cols[i], params.grayscale); |
1693 | PRINT(CCV_CLI_INFO, "\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("\n"); fflush(stdout); } } while (0); |
1694 | ccv_array_t** negex = (ccv_array_t**)alloca(sizeof(ccv_array_t*) * params.components)__builtin_alloca (sizeof(ccv_array_t*) * params.components); |
1695 | _ccv_dpm_collect_examples_randomly(rng, negex, bgfiles, bgnum, negnum, params.components, rows, cols, params.grayscale); |
1696 | PRINT(CCV_CLI_INFO, "\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("\n"); fflush(stdout); } } while (0); |
1697 | int* neglabels = (int*)ccmallocmalloc(sizeof(int) * negex[0]->rnum); |
1698 | for (i = 0; i < negex[0]->rnum; i++) |
1699 | neglabels[i] = gsl_rng_uniform_int(rng, params.components); |
1700 | for (i = 0; i < params.components; i++) |
1701 | { |
1702 | ccv_dpm_root_classifier_t* root_classifier = model->root + i; |
1703 | root_classifier->root.w = ccv_dense_matrix_new(rows[i], cols[i], CCV_32F | 31, 0, 0); |
1704 | PRINT(CCV_CLI_INFO, "initializing root mixture model for model %d(%d)\n", i + 1, params.components)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("initializing root mixture model for model %d(%d)\n", i + 1, params.components); fflush(stdout); } } while (0); |
1705 | _ccv_dpm_initialize_root_classifier(rng, root_classifier, i, mnum[i], poslabels, posex[i], neglabels, negex[i], params.C, params.symmetric, params.grayscale); |
1706 | } |
1707 | ccfreefree(neglabels); |
1708 | ccfreefree(poslabels); |
1709 | // check symmetric property of generated root feature |
1710 | if (params.symmetric) |
1711 | for (i = 0; i < params.components; i++) |
1712 | { |
1713 | ccv_dpm_root_classifier_t* root_classifier = model->root + i; |
1714 | _ccv_dpm_check_root_classifier_symmetry(root_classifier->root.w); |
1715 | } |
1716 | if (params.components > 1) |
1717 | { |
1718 | /* TODO: coordinate-descent for lsvm */ |
1719 | PRINT(CCV_CLI_INFO, "optimizing root mixture model with coordinate-descent approach\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("optimizing root mixture model with coordinate-descent approach\n" ); fflush(stdout); } } while (0); |
1720 | model = _ccv_dpm_optimize_root_mixture_model(rng, model, posex, negex, params.root_relabels, params.balance, params.C, params.alpha, params.alpha_ratio, params.iterations, params.symmetric); |
1721 | } else { |
1722 | PRINT(CCV_CLI_INFO, "components == 1, skipped coordinate-descent to optimize root mixture model\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("components == 1, skipped coordinate-descent to optimize root mixture model\n" ); fflush(stdout); } } while (0); |
1723 | } |
1724 | for (i = 0; i < params.components; i++) |
1725 | { |
1726 | for (j = 0; j < posex[i]->rnum; j++) |
1727 | _ccv_dpm_feature_vector_cleanup((ccv_dpm_feature_vector_t*)ccv_array_get(posex[i], j)((void*)(((char*)((posex[i])->data)) + (size_t)(posex[i])-> rsize * (size_t)(j)))); |
1728 | ccv_array_free(posex[i]); |
1729 | for (j = 0; j < negex[i]->rnum; j++) |
1730 | _ccv_dpm_feature_vector_cleanup((ccv_dpm_feature_vector_t*)ccv_array_get(negex[i], j)((void*)(((char*)((negex[i])->data)) + (size_t)(negex[i])-> rsize * (size_t)(j)))); |
1731 | ccv_array_free(negex[i]); |
1732 | } |
1733 | } else { |
1734 | ccfreefree(poslabels); |
1735 | } |
1736 | _ccv_dpm_write_checkpoint(model, 0, checkpoint); |
1737 | /* initialize part filter */ |
1738 | PRINT(CCV_CLI_INFO, "initializing part filters\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("initializing part filters\n"); fflush(stdout); } } while (0 ); |
1739 | for (i = 0; i < params.components; i++) |
1740 | { |
1741 | if (model->root[i].count > 0) |
1742 | { |
1743 | PRINT(CCV_CLI_INFO, " - skipping part filters initialization for model %d(%d)\n", i + 1, params.components)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (" - skipping part filters initialization for model %d(%d)\n" , i + 1, params.components); fflush(stdout); } } while (0); |
1744 | } else { |
1745 | PRINT(CCV_CLI_INFO, " - initializing part filters for model %d(%d)\n", i + 1, params.components)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (" - initializing part filters for model %d(%d)\n", i + 1, params .components); fflush(stdout); } } while (0); |
1746 | _ccv_dpm_initialize_part_classifiers(model->root + i, params.parts, params.symmetric); |
1747 | _ccv_dpm_write_checkpoint(model, 0, checkpoint); |
1748 | _ccv_dpm_write_checkpoint(model, 0, initcheckpoint); |
1749 | } |
1750 | } |
1751 | _ccv_dpm_write_checkpoint(model, 0, checkpoint); |
1752 | /* optimize both root filter and part filters with stochastic gradient descent */ |
1753 | PRINT(CCV_CLI_INFO, "optimizing root filter & part filters with stochastic gradient descent\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("optimizing root filter & part filters with stochastic gradient descent\n" ); fflush(stdout); } } while (0); |
1754 | char gradient_progress_checkpoint[512]; |
1755 | sprintf(gradient_progress_checkpoint, "%s/gradient_descent_progress", dir); |
1756 | char feature_vector_checkpoint[512]; |
1757 | sprintf(feature_vector_checkpoint, "%s/positive_vectors", dir); |
1758 | char neg_vector_checkpoint[512]; |
1759 | sprintf(neg_vector_checkpoint, "%s/negative_vectors", dir); |
1760 | ccv_dpm_feature_vector_t** posv = (ccv_dpm_feature_vector_t**)ccmallocmalloc(posnum * sizeof(ccv_dpm_feature_vector_t*)); |
1761 | int* order = (int*)ccmallocmalloc(sizeof(int) * (posnum + params.negative_cache_size + 64 /* the magical number for maximum negative examples collected per image */)); |
1762 | double previous_positive_loss = 0, previous_negative_loss = 0, positive_loss = 0, negative_loss = 0, loss = 0; |
1763 | // need to re-weight for each examples |
1764 | c = d = t = 0; |
Although the value stored to 't' is used in the enclosing expression, the value is never actually read from 't' | |
1765 | ccv_array_t* negv = 0; |
1766 | if (0 == _ccv_dpm_read_negative_feature_vectors(&negv, params.negative_cache_size, neg_vector_checkpoint)) |
1767 | PRINT(CCV_CLI_INFO, " - read collected negative responses from last interrupted process\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (" - read collected negative responses from last interrupted process\n" ); fflush(stdout); } } while (0); |
1768 | _ccv_dpm_read_gradient_descent_progress(&c, &d, gradient_progress_checkpoint); |
1769 | for (; c < params.relabels; c++) |
1770 | { |
1771 | double regz_rate = params.C; |
1772 | ccv_dpm_mixture_model_t* _model; |
1773 | if (0 == _ccv_dpm_read_positive_feature_vectors(posv, posnum, feature_vector_checkpoint)) |
1774 | { |
1775 | PRINT(CCV_CLI_INFO, " - read collected positive responses from last interrupted process\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (" - read collected positive responses from last interrupted process\n" ); fflush(stdout); } } while (0); |
1776 | } else { |
1777 | FLUSH(CCV_CLI_INFO, " - collecting responses from positive examples : 0%%")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf("\b"); for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf(" "); for ( _CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP ++) printf("\b"); _CCV_PRINT_COUNT = printf(" - collecting responses from positive examples : 0%%" ); fflush(stdout); } } while (0); |
1778 | for (i = 0; i < posnum; i++) |
1779 | { |
1780 | FLUSH(CCV_CLI_INFO, " - collecting responses from positive examples : %d%%", i * 100 / posnum)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf("\b"); for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf(" "); for ( _CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP ++) printf("\b"); _CCV_PRINT_COUNT = printf(" - collecting responses from positive examples : %d%%" , i * 100 / posnum); fflush(stdout); } } while (0); |
1781 | ccv_dense_matrix_t* image = 0; |
1782 | ccv_read(posfiles[i], &image, (params.grayscale ? CCV_IO_GRAY : 0) | CCV_IO_ANY_FILE)ccv_read_impl(posfiles[i], &image, (params.grayscale ? CCV_IO_GRAY : 0) | CCV_IO_ANY_FILE, 0, 0, 0); |
1783 | posv[i] = _ccv_dpm_collect_best(image, model, bboxes[i], params.include_overlap, params.detector); |
1784 | ccv_matrix_free(image); |
1785 | } |
1786 | FLUSH(CCV_CLI_INFO, " - collecting responses from positive examples : 100%%\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf("\b"); for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf(" "); for ( _CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP ++) printf("\b"); _CCV_PRINT_COUNT = printf(" - collecting responses from positive examples : 100%%\n" ); fflush(stdout); } } while (0); |
1787 | _ccv_dpm_write_positive_feature_vectors(posv, posnum, feature_vector_checkpoint); |
1788 | } |
1789 | int* posvnum = (int*)alloca(sizeof(int) * model->count)__builtin_alloca (sizeof(int) * model->count); |
1790 | memset(posvnum, 0, sizeof(int) * model->count); |
1791 | for (i = 0; i < posnum; i++) |
1792 | if (posv[i]) |
1793 | { |
1794 | assert(posv[i]->id >= 0 && posv[i]->id < model->count)((void) sizeof ((posv[i]->id >= 0 && posv[i]-> id < model->count) ? 1 : 0), __extension__ ({ if (posv[ i]->id >= 0 && posv[i]->id < model->count ) ; else __assert_fail ("posv[i]->id >= 0 && posv[i]->id < model->count" , "ccv_dpm.c", 1794, __extension__ __PRETTY_FUNCTION__); })); |
1795 | ++posvnum[posv[i]->id]; |
1796 | } |
1797 | PRINT(CCV_CLI_INFO, " - positive examples divided by components : %d", posvnum[0])do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (" - positive examples divided by components : %d", posvnum[0 ]); fflush(stdout); } } while (0); |
1798 | for (i = 1; i < model->count; i++) |
1799 | PRINT(CCV_CLI_INFO, ", %d", posvnum[i])do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (", %d", posvnum[i]); fflush(stdout); } } while (0); |
1800 | PRINT(CCV_CLI_INFO, "\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("\n"); fflush(stdout); } } while (0); |
1801 | params.detector.threshold = 0; |
1802 | for (; d < params.data_minings; d++) |
1803 | { |
1804 | // the cache is used up now, collect again |
1805 | _ccv_dpm_write_gradient_descent_progress(c, d, gradient_progress_checkpoint); |
1806 | double alpha = params.alpha; |
1807 | if (negv) |
1808 | { |
1809 | ccv_array_t* av = ccv_array_new(sizeof(ccv_dpm_feature_vector_t*), 64, 0); |
1810 | for (j = 0; j < negv->rnum; j++) |
1811 | { |
1812 | ccv_dpm_feature_vector_t* v = *(ccv_dpm_feature_vector_t**)ccv_array_get(negv, j)((void*)(((char*)((negv)->data)) + (size_t)(negv)->rsize * (size_t)(j))); |
1813 | double score = _ccv_dpm_vector_score(model, v); |
1814 | assert(!isnan(score))((void) sizeof ((!__builtin_isnan (score)) ? 1 : 0), __extension__ ({ if (!__builtin_isnan (score)) ; else __assert_fail ("!isnan(score)" , "ccv_dpm.c", 1814, __extension__ __PRETTY_FUNCTION__); })); |
1815 | if (score >= -1) |
1816 | ccv_array_push(av, &v); |
1817 | else |
1818 | _ccv_dpm_feature_vector_free(v); |
1819 | } |
1820 | ccv_array_free(negv); |
1821 | negv = av; |
1822 | } else { |
1823 | negv = ccv_array_new(sizeof(ccv_dpm_feature_vector_t*), 64, 0); |
1824 | } |
1825 | FLUSH(CCV_CLI_INFO, " - collecting negative examples -- (0%%)")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf("\b"); for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf(" "); for ( _CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP ++) printf("\b"); _CCV_PRINT_COUNT = printf(" - collecting negative examples -- (0%%)" ); fflush(stdout); } } while (0); |
1826 | if (negv->rnum < params.negative_cache_size) |
1827 | _ccv_dpm_collect_from_background(negv, rng, bgfiles, bgnum, model, params, 0); |
1828 | _ccv_dpm_write_negative_feature_vectors(negv, params.negative_cache_size, neg_vector_checkpoint); |
1829 | FLUSH(CCV_CLI_INFO, " - collecting negative examples -- (100%%)\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf("\b"); for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf(" "); for ( _CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP ++) printf("\b"); _CCV_PRINT_COUNT = printf(" - collecting negative examples -- (100%%)\n" ); fflush(stdout); } } while (0); |
1830 | int* negvnum = (int*)alloca(sizeof(int) * model->count)__builtin_alloca (sizeof(int) * model->count); |
1831 | memset(negvnum, 0, sizeof(int) * model->count); |
1832 | for (i = 0; i < negv->rnum; i++) |
1833 | { |
1834 | ccv_dpm_feature_vector_t* v = *(ccv_dpm_feature_vector_t**)ccv_array_get(negv, i)((void*)(((char*)((negv)->data)) + (size_t)(negv)->rsize * (size_t)(i))); |
1835 | assert(v->id >= 0 && v->id < model->count)((void) sizeof ((v->id >= 0 && v->id < model ->count) ? 1 : 0), __extension__ ({ if (v->id >= 0 && v->id < model->count) ; else __assert_fail ("v->id >= 0 && v->id < model->count" , "ccv_dpm.c", 1835, __extension__ __PRETTY_FUNCTION__); })); |
1836 | ++negvnum[v->id]; |
1837 | } |
1838 | if (negv->rnum <= ccv_max(params.negative_cache_size / 2, ccv_max(REGQ, MINI_BATCH))({ typeof (params.negative_cache_size / 2) _a = (params.negative_cache_size / 2); typeof (({ typeof ((100)) _a = ((100)); typeof ((10)) _b = ((10)); (_a > _b) ? _a : _b; })) _b = (({ typeof ((100) ) _a = ((100)); typeof ((10)) _b = ((10)); (_a > _b) ? _a : _b; })); (_a > _b) ? _a : _b; })) |
1839 | { |
1840 | for (i = 0; i < model->count; i++) |
1841 | // we cannot get sufficient negatives, adjust constant and abort for next round |
1842 | _ccv_dpm_adjust_model_constant(model, i, posv, posnum, params.percentile_breakdown); |
1843 | continue; |
1844 | } |
1845 | PRINT(CCV_CLI_INFO, " - negative examples divided by components : %d", negvnum[0])do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (" - negative examples divided by components : %d", negvnum[0 ]); fflush(stdout); } } while (0); |
1846 | for (i = 1; i < model->count; i++) |
1847 | PRINT(CCV_CLI_INFO, ", %d", negvnum[i])do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (", %d", negvnum[i]); fflush(stdout); } } while (0); |
1848 | PRINT(CCV_CLI_INFO, "\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("\n"); fflush(stdout); } } while (0); |
1849 | previous_positive_loss = previous_negative_loss = 0; |
1850 | uint64_t elapsed_time = _ccv_dpm_time_measure(); |
1851 | assert(negv->rnum < params.negative_cache_size + 64)((void) sizeof ((negv->rnum < params.negative_cache_size + 64) ? 1 : 0), __extension__ ({ if (negv->rnum < params .negative_cache_size + 64) ; else __assert_fail ("negv->rnum < params.negative_cache_size + 64" , "ccv_dpm.c", 1851, __extension__ __PRETTY_FUNCTION__); })); |
1852 | for (t = 0; t < params.iterations; t++) |
1853 | { |
1854 | for (p = 0; p < model->count; p++) |
1855 | { |
1856 | // if don't have enough negnum or posnum, aborting |
1857 | if (negvnum[p] <= ccv_max(params.negative_cache_size / (model->count * 3), ccv_max(REGQ, MINI_BATCH))({ typeof (params.negative_cache_size / (model->count * 3) ) _a = (params.negative_cache_size / (model->count * 3)); typeof (({ typeof ((100)) _a = ((100)); typeof ((10)) _b = ((10)); ( _a > _b) ? _a : _b; })) _b = (({ typeof ((100)) _a = ((100 )); typeof ((10)) _b = ((10)); (_a > _b) ? _a : _b; })); ( _a > _b) ? _a : _b; }) || |
1858 | posvnum[p] <= ccv_max(REGQ, MINI_BATCH)({ typeof ((100)) _a = ((100)); typeof ((10)) _b = ((10)); (_a > _b) ? _a : _b; })) |
1859 | continue; |
1860 | double pos_weight = sqrt((double)negvnum[p] / posvnum[p] * params.balance); // positive weight |
1861 | double neg_weight = sqrt((double)posvnum[p] / negvnum[p] / params.balance); // negative weight |
1862 | _model = _ccv_dpm_model_copy(model); |
1863 | for (i = 0; i < posnum + negv->rnum; i++) |
1864 | order[i] = i; |
1865 | gsl_ran_shuffle(rng, order, posnum + negv->rnum, sizeof(int)); |
1866 | int l = 0; |
1867 | for (i = 0; i < posnum + negv->rnum; i++) |
1868 | { |
1869 | k = order[i]; |
1870 | if (k < posnum) |
1871 | { |
1872 | if (posv[k] == 0 || posv[k]->id != p) |
1873 | continue; |
1874 | double score = _ccv_dpm_vector_score(model, posv[k]); // the loss for mini-batch method (computed on model) |
1875 | assert(!isnan(score))((void) sizeof ((!__builtin_isnan (score)) ? 1 : 0), __extension__ ({ if (!__builtin_isnan (score)) ; else __assert_fail ("!isnan(score)" , "ccv_dpm.c", 1875, __extension__ __PRETTY_FUNCTION__); })); |
1876 | if (score <= 1) |
1877 | _ccv_dpm_stochastic_gradient_descent(_model, posv[k], 1, alpha * pos_weight, regz_rate, params.symmetric); |
1878 | } else { |
1879 | ccv_dpm_feature_vector_t* v = *(ccv_dpm_feature_vector_t**)ccv_array_get(negv, k - posnum)((void*)(((char*)((negv)->data)) + (size_t)(negv)->rsize * (size_t)(k - posnum))); |
1880 | if (v->id != p) |
1881 | continue; |
1882 | double score = _ccv_dpm_vector_score(model, v); |
1883 | assert(!isnan(score))((void) sizeof ((!__builtin_isnan (score)) ? 1 : 0), __extension__ ({ if (!__builtin_isnan (score)) ; else __assert_fail ("!isnan(score)" , "ccv_dpm.c", 1883, __extension__ __PRETTY_FUNCTION__); })); |
1884 | if (score >= -1) |
1885 | _ccv_dpm_stochastic_gradient_descent(_model, v, -1, alpha * neg_weight, regz_rate, params.symmetric); |
1886 | } |
1887 | ++l; |
1888 | if (l % REGQ(100) == REGQ(100) - 1) |
1889 | _ccv_dpm_regularize_mixture_model(_model, p, 1.0 - pow(1.0 - alpha / (double)((posvnum[p] + negvnum[p]) * (!!params.symmetric + 1)), REGQ(100))); |
1890 | if (l % MINI_BATCH(10) == MINI_BATCH(10) - 1) |
1891 | { |
1892 | // mimicking mini-batch way of doing things |
1893 | _ccv_dpm_mixture_model_cleanup(model); |
1894 | ccfreefree(model); |
1895 | model = _model; |
1896 | _model = _ccv_dpm_model_copy(model); |
1897 | } |
1898 | } |
1899 | _ccv_dpm_regularize_mixture_model(_model, p, 1.0 - pow(1.0 - alpha / (double)((posvnum[p] + negvnum[p]) * (!!params.symmetric + 1)), (((posvnum[p] + negvnum[p]) % REGQ(100)) + 1) % (REGQ(100) + 1))); |
1900 | _ccv_dpm_mixture_model_cleanup(model); |
1901 | ccfreefree(model); |
1902 | model = _model; |
1903 | } |
1904 | // compute the loss |
1905 | int posvn = 0; |
1906 | positive_loss = negative_loss = loss = 0; |
1907 | for (i = 0; i < posnum; i++) |
1908 | if (posv[i] != 0) |
1909 | { |
1910 | double score = _ccv_dpm_vector_score(model, posv[i]); |
1911 | assert(!isnan(score))((void) sizeof ((!__builtin_isnan (score)) ? 1 : 0), __extension__ ({ if (!__builtin_isnan (score)) ; else __assert_fail ("!isnan(score)" , "ccv_dpm.c", 1911, __extension__ __PRETTY_FUNCTION__); })); |
1912 | double hinge_loss = ccv_max(0, 1.0 - score)({ typeof (0) _a = (0); typeof (1.0 - score) _b = (1.0 - score ); (_a > _b) ? _a : _b; }); |
1913 | positive_loss += hinge_loss; |
1914 | double pos_weight = sqrt((double)negvnum[posv[i]->id] / posvnum[posv[i]->id] * params.balance); // positive weight |
1915 | loss += pos_weight * hinge_loss; |
1916 | ++posvn; |
1917 | } |
1918 | for (i = 0; i < negv->rnum; i++) |
1919 | { |
1920 | ccv_dpm_feature_vector_t* v = *(ccv_dpm_feature_vector_t**)ccv_array_get(negv, i)((void*)(((char*)((negv)->data)) + (size_t)(negv)->rsize * (size_t)(i))); |
1921 | double score = _ccv_dpm_vector_score(model, v); |
1922 | assert(!isnan(score))((void) sizeof ((!__builtin_isnan (score)) ? 1 : 0), __extension__ ({ if (!__builtin_isnan (score)) ; else __assert_fail ("!isnan(score)" , "ccv_dpm.c", 1922, __extension__ __PRETTY_FUNCTION__); })); |
1923 | double hinge_loss = ccv_max(0, 1.0 + score)({ typeof (0) _a = (0); typeof (1.0 + score) _b = (1.0 + score ); (_a > _b) ? _a : _b; }); |
1924 | negative_loss += hinge_loss; |
1925 | double neg_weight = sqrt((double)posvnum[v->id] / negvnum[v->id] / params.balance); // negative weight |
1926 | loss += neg_weight * hinge_loss; |
1927 | } |
1928 | loss = loss / (posvn + negv->rnum); |
1929 | positive_loss = positive_loss / posvn; |
1930 | negative_loss = negative_loss / negv->rnum; |
1931 | FLUSH(CCV_CLI_INFO, " - with loss %.5lf (positive %.5lf, negative %.5f) at rate %.5lf %d | %d -- %d%%", loss, positive_loss, negative_loss, alpha, posvn, negv->rnum, (t + 1) * 100 / params.iterations)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf("\b"); for (_CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP++) printf(" "); for ( _CCV_PRINT_LOOP = 0; _CCV_PRINT_LOOP < _CCV_PRINT_COUNT; _CCV_PRINT_LOOP ++) printf("\b"); _CCV_PRINT_COUNT = printf(" - with loss %.5lf (positive %.5lf, negative %.5f) at rate %.5lf %d | %d -- %d%%" , loss, positive_loss, negative_loss, alpha, posvn, negv-> rnum, (t + 1) * 100 / params.iterations); fflush(stdout); } } while (0); |
1932 | // check symmetric property of generated root feature |
1933 | if (params.symmetric) |
1934 | for (i = 0; i < params.components; i++) |
1935 | { |
1936 | ccv_dpm_root_classifier_t* root_classifier = model->root + i; |
1937 | _ccv_dpm_check_root_classifier_symmetry(root_classifier->root.w); |
1938 | } |
1939 | if (fabs(previous_positive_loss - positive_loss) < 1e-5 && |
1940 | fabs(previous_negative_loss - negative_loss) < 1e-5) |
1941 | { |
1942 | PRINT(CCV_CLI_INFO, "\n - aborting iteration at %d because we didn't gain much", t + 1)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("\n - aborting iteration at %d because we didn't gain much", t + 1); fflush(stdout); } } while (0); |
1943 | break; |
1944 | } |
1945 | previous_positive_loss = positive_loss; |
1946 | previous_negative_loss = negative_loss; |
1947 | alpha *= params.alpha_ratio; // it will decrease with each iteration |
1948 | } |
1949 | _ccv_dpm_write_checkpoint(model, 0, checkpoint); |
1950 | PRINT(CCV_CLI_INFO, "\n - data mining %d takes %.2lf seconds at loss %.5lf, %d more to go (%d of %d)\n", d + 1, (double)(_ccv_dpm_time_measure() - elapsed_time) / 1000000.0, loss, params.data_minings - d - 1, c + 1, params.relabels)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("\n - data mining %d takes %.2lf seconds at loss %.5lf, %d more to go (%d of %d)\n" , d + 1, (double)(_ccv_dpm_time_measure() - elapsed_time) / 1000000.0 , loss, params.data_minings - d - 1, c + 1, params.relabels); fflush(stdout); } } while (0); |
1951 | j = 0; |
1952 | double* scores = (double*)ccmallocmalloc(posnum * sizeof(double)); |
1953 | for (i = 0; i < posnum; i++) |
1954 | if (posv[i]) |
1955 | { |
1956 | scores[j] = _ccv_dpm_vector_score(model, posv[i]); |
1957 | assert(!isnan(scores[j]))((void) sizeof ((!__builtin_isnan (scores[j])) ? 1 : 0), __extension__ ({ if (!__builtin_isnan (scores[j])) ; else __assert_fail ("!isnan(scores[j])" , "ccv_dpm.c", 1957, __extension__ __PRETTY_FUNCTION__); })); |
1958 | j++; |
1959 | } |
1960 | _ccv_dpm_score_qsort(scores, j, 0); |
1961 | ccfreefree(scores); |
1962 | double breakdown; |
1963 | PRINT(CCV_CLI_INFO, " - threshold breakdown by percentile")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (" - threshold breakdown by percentile"); fflush(stdout); } } while (0); |
1964 | for (breakdown = params.percentile_breakdown; breakdown < 1.0; breakdown += params.percentile_breakdown) |
1965 | PRINT(CCV_CLI_INFO, " %0.2lf(%.1f%%)", scores[ccv_clamp((int)(breakdown * j), 0, j - 1)], (1.0 - breakdown) * 100)do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf (" %0.2lf(%.1f%%)", scores[({ typeof (0) _a = (0); typeof (j - 1) _b = (j - 1); typeof ((int)(breakdown * j)) _x = ((int)(breakdown * j)); (_x < _a) ? _a : ((_x > _b) ? _b : _x); })], (1.0 - breakdown) * 100); fflush(stdout); } } while (0); |
1966 | PRINT(CCV_CLI_INFO, "\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("\n"); fflush(stdout); } } while (0); |
1967 | char persist[512]; |
1968 | sprintf(persist, "%s/model.%d.%d", dir, c, d); |
1969 | _ccv_dpm_write_checkpoint(model, 0, persist); |
1970 | } |
1971 | d = 0; |
1972 | // if abort, means that we cannot find enough negative examples, try to adjust constant |
1973 | for (i = 0; i < posnum; i++) |
1974 | if (posv[i]) |
1975 | _ccv_dpm_feature_vector_free(posv[i]); |
1976 | remove(feature_vector_checkpoint); |
1977 | } |
1978 | if (negv) |
1979 | { |
1980 | for (i = 0; i < negv->rnum; i++) |
1981 | { |
1982 | ccv_dpm_feature_vector_t* v = *(ccv_dpm_feature_vector_t**)ccv_array_get(negv, i)((void*)(((char*)((negv)->data)) + (size_t)(negv)->rsize * (size_t)(i))); |
1983 | _ccv_dpm_feature_vector_free(v); |
1984 | } |
1985 | ccv_array_free(negv); |
1986 | } |
1987 | remove(neg_vector_checkpoint); |
1988 | ccfreefree(order); |
1989 | ccfreefree(posv); |
1990 | PRINT(CCV_CLI_INFO, "root rectangle prediction with linear regression\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("root rectangle prediction with linear regression\n"); fflush (stdout); } } while (0); |
1991 | _ccv_dpm_initialize_root_rectangle_estimator(model, posfiles, bboxes, posnum, params); |
1992 | _ccv_dpm_write_checkpoint(model, 1, checkpoint); |
1993 | PRINT(CCV_CLI_INFO, "done\n")do { if ((CCV_CLI_INFO & ccv_cli_get_output_levels())) { printf ("done\n"); fflush(stdout); } } while (0); |
1994 | remove(gradient_progress_checkpoint); |
1995 | _ccv_dpm_mixture_model_cleanup(model); |
1996 | ccfreefree(model); |
1997 | gsl_rng_free(rng); |
1998 | } |
1999 | #else |
2000 | void ccv_dpm_mixture_model_new(char** posfiles, ccv_rect_t* bboxes, int posnum, char** bgfiles, int bgnum, int negnum, const char* dir, ccv_dpm_new_param_t params) |
2001 | { |
2002 | fprintf(stderrstderr, " ccv_dpm_classifier_cascade_new requires libgsl and liblinear support, please compile ccv with them.\n"); |
2003 | } |
2004 | #endif |
2005 | #else |
2006 | void ccv_dpm_mixture_model_new(char** posfiles, ccv_rect_t* bboxes, int posnum, char** bgfiles, int bgnum, int negnum, const char* dir, ccv_dpm_new_param_t params) |
2007 | { |
2008 | fprintf(stderrstderr, " ccv_dpm_classifier_cascade_new requires libgsl and liblinear support, please compile ccv with them.\n"); |
2009 | } |
2010 | #endif |
2011 | |
2012 | static int _ccv_is_equal(const void* _r1, const void* _r2, void* data) |
2013 | { |
2014 | const ccv_root_comp_t* r1 = (const ccv_root_comp_t*)_r1; |
2015 | const ccv_root_comp_t* r2 = (const ccv_root_comp_t*)_r2; |
2016 | int distance = (int)(ccv_min(r1->rect.width, r1->rect.height)({ typeof (r1->rect.width) _a = (r1->rect.width); typeof (r1->rect.height) _b = (r1->rect.height); (_a < _b) ? _a : _b; }) * 0.25 + 0.5); |
2017 | |
2018 | return r2->rect.x <= r1->rect.x + distance && |
2019 | r2->rect.x >= r1->rect.x - distance && |
2020 | r2->rect.y <= r1->rect.y + distance && |
2021 | r2->rect.y >= r1->rect.y - distance && |
2022 | r2->rect.width <= (int)(r1->rect.width * 1.5 + 0.5) && |
2023 | (int)(r2->rect.width * 1.5 + 0.5) >= r1->rect.width && |
2024 | r2->rect.height <= (int)(r1->rect.height * 1.5 + 0.5) && |
2025 | (int)(r2->rect.height * 1.5 + 0.5) >= r1->rect.height; |
2026 | } |
2027 | |
2028 | static int _ccv_is_equal_same_class(const void* _r1, const void* _r2, void* data) |
2029 | { |
2030 | const ccv_root_comp_t* r1 = (const ccv_root_comp_t*)_r1; |
2031 | const ccv_root_comp_t* r2 = (const ccv_root_comp_t*)_r2; |
2032 | int distance = (int)(ccv_min(r1->rect.width, r1->rect.height)({ typeof (r1->rect.width) _a = (r1->rect.width); typeof (r1->rect.height) _b = (r1->rect.height); (_a < _b) ? _a : _b; }) * 0.25 + 0.5); |
2033 | |
2034 | return r2->classification.id == r1->classification.id && |
2035 | r2->rect.x <= r1->rect.x + distance && |
2036 | r2->rect.x >= r1->rect.x - distance && |
2037 | r2->rect.y <= r1->rect.y + distance && |
2038 | r2->rect.y >= r1->rect.y - distance && |
2039 | r2->rect.width <= (int)(r1->rect.width * 1.5 + 0.5) && |
2040 | (int)(r2->rect.width * 1.5 + 0.5) >= r1->rect.width && |
2041 | r2->rect.height <= (int)(r1->rect.height * 1.5 + 0.5) && |
2042 | (int)(r2->rect.height * 1.5 + 0.5) >= r1->rect.height; |
2043 | } |
2044 | |
2045 | ccv_array_t* ccv_dpm_detect_objects(ccv_dense_matrix_t* a, ccv_dpm_mixture_model_t** _model, int count, ccv_dpm_param_t params) |
2046 | { |
2047 | int c, i, j, k, x, y; |
2048 | double scale = pow(2.0, 1.0 / (params.interval + 1.0)); |
2049 | int next = params.interval + 1; |
2050 | int scale_upto = _ccv_dpm_scale_upto(a, _model, count, params.interval); |
2051 | if (scale_upto < 0) // image is too small to be interesting |
2052 | return 0; |
2053 | ccv_dense_matrix_t** pyr = (ccv_dense_matrix_t**)alloca((scale_upto + next * 2) * sizeof(ccv_dense_matrix_t*))__builtin_alloca ((scale_upto + next * 2) * sizeof(ccv_dense_matrix_t *)); |
2054 | _ccv_dpm_feature_pyramid(a, pyr, scale_upto, params.interval); |
2055 | ccv_array_t* idx_seq; |
2056 | ccv_array_t* seq = ccv_array_new(sizeof(ccv_root_comp_t), 64, 0); |
2057 | ccv_array_t* seq2 = ccv_array_new(sizeof(ccv_root_comp_t), 64, 0); |
2058 | ccv_array_t* result_seq = ccv_array_new(sizeof(ccv_root_comp_t), 64, 0); |
2059 | for (c = 0; c < count; c++) |
2060 | { |
2061 | ccv_dpm_mixture_model_t* model = _model[c]; |
2062 | double scale_x = 1.0; |
2063 | double scale_y = 1.0; |
2064 | for (i = next; i < scale_upto + next * 2; i++) |
2065 | { |
2066 | for (j = 0; j < model->count; j++) |
2067 | { |
2068 | ccv_dpm_root_classifier_t* root = model->root + j; |
2069 | ccv_dense_matrix_t* root_feature = 0; |
2070 | ccv_dense_matrix_t* part_feature[CCV_DPM_PART_MAX(10)]; |
2071 | ccv_dense_matrix_t* dx[CCV_DPM_PART_MAX(10)]; |
2072 | ccv_dense_matrix_t* dy[CCV_DPM_PART_MAX(10)]; |
2073 | _ccv_dpm_compute_score(root, pyr[i], pyr[i - next], &root_feature, part_feature, dx, dy); |
2074 | int rwh = (root->root.w->rows - 1) / 2, rww = (root->root.w->cols - 1) / 2; |
2075 | int rwh_1 = root->root.w->rows / 2, rww_1 = root->root.w->cols / 2; |
2076 | /* these values are designed to make sure works with odd/even number of rows/cols |
2077 | * of the root classifier: |
2078 | * suppose the image is 6x6, and the root classifier is 6x6, the scan area should starts |
2079 | * at (2,2) and end at (2,2), thus, it is capped by (rwh, rww) to (6 - rwh_1 - 1, 6 - rww_1 - 1) |
2080 | * this computation works for odd root classifier too (i.e. 5x5) */ |
2081 | float* f_ptr = (float*)ccv_get_dense_matrix_cell_by(CCV_32F | CCV_C1, root_feature, rwh, 0, 0)(((CCV_32F | CCV_C1) & CCV_32S) ? (void*)((root_feature)-> data.i32 + ((rwh) * (root_feature)->cols + (0)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)) : (((CCV_32F | CCV_C1) & CCV_32F ) ? (void*)((root_feature)->data.f32+ ((rwh) * (root_feature )->cols + (0)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)) : (((CCV_32F | CCV_C1) & CCV_64S) ? (void*)((root_feature) ->data.i64+ ((rwh) * (root_feature)->cols + (0)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)) : (((CCV_32F | CCV_C1) & CCV_64F ) ? (void*)((root_feature)->data.f64 + ((rwh) * (root_feature )->cols + (0)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)) : (void*)((root_feature)->data.u8 + (rwh) * (root_feature)-> step + (0) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)))))); |
2082 | for (y = rwh; y < root_feature->rows - rwh_1; y++) |
2083 | { |
2084 | for (x = rww; x < root_feature->cols - rww_1; x++) |
2085 | if (f_ptr[x] + root->beta > params.threshold) |
2086 | { |
2087 | ccv_root_comp_t comp; |
2088 | comp.neighbors = 1; |
2089 | comp.classification.id = c + 1; |
2090 | comp.classification.confidence = f_ptr[x] + root->beta; |
2091 | comp.pnum = root->count; |
2092 | float drift_x = root->alpha[0], |
2093 | drift_y = root->alpha[1], |
2094 | drift_scale = root->alpha[2]; |
2095 | for (k = 0; k < root->count; k++) |
2096 | { |
2097 | ccv_dpm_part_classifier_t* part = root->part + k; |
2098 | comp.part[k].neighbors = 1; |
2099 | comp.part[k].classification.id = c; |
2100 | int pww = (part->w->cols - 1) / 2, pwh = (part->w->rows - 1) / 2; |
2101 | int offy = part->y + pwh - rwh * 2; |
2102 | int offx = part->x + pww - rww * 2; |
2103 | int iy = ccv_clamp(y * 2 + offy, pwh, part_feature[k]->rows - part->w->rows + pwh)({ typeof (pwh) _a = (pwh); typeof (part_feature[k]->rows - part->w->rows + pwh) _b = (part_feature[k]->rows - part ->w->rows + pwh); typeof (y * 2 + offy) _x = (y * 2 + offy ); (_x < _a) ? _a : ((_x > _b) ? _b : _x); }); |
2104 | int ix = ccv_clamp(x * 2 + offx, pww, part_feature[k]->cols - part->w->cols + pww)({ typeof (pww) _a = (pww); typeof (part_feature[k]->cols - part->w->cols + pww) _b = (part_feature[k]->cols - part ->w->cols + pww); typeof (x * 2 + offx) _x = (x * 2 + offx ); (_x < _a) ? _a : ((_x > _b) ? _b : _x); }); |
2105 | int ry = ccv_get_dense_matrix_cell_value_by(CCV_32S | CCV_C1, dy[k], iy, ix, 0)(((CCV_32S | CCV_C1) & CCV_32S) ? (dy[k])->data.i32[(( iy) * (dy[k])->cols + (ix)) * ((CCV_32S | CCV_C1) & 0xFFF ) + (0)] : (((CCV_32S | CCV_C1) & CCV_32F) ? (dy[k])-> data.f32[((iy) * (dy[k])->cols + (ix)) * ((CCV_32S | CCV_C1 ) & 0xFFF) + (0)] : (((CCV_32S | CCV_C1) & CCV_64S) ? (dy[k])->data.i64[((iy) * (dy[k])->cols + (ix)) * ((CCV_32S | CCV_C1) & 0xFFF) + (0)] : (((CCV_32S | CCV_C1) & CCV_64F ) ? (dy[k])->data.f64[((iy) * (dy[k])->cols + (ix)) * ( (CCV_32S | CCV_C1) & 0xFFF) + (0)] : (dy[k])->data.u8[ (iy) * (dy[k])->step + (ix) * ((CCV_32S | CCV_C1) & 0xFFF ) + (0)])))); |
2106 | int rx = ccv_get_dense_matrix_cell_value_by(CCV_32S | CCV_C1, dx[k], iy, ix, 0)(((CCV_32S | CCV_C1) & CCV_32S) ? (dx[k])->data.i32[(( iy) * (dx[k])->cols + (ix)) * ((CCV_32S | CCV_C1) & 0xFFF ) + (0)] : (((CCV_32S | CCV_C1) & CCV_32F) ? (dx[k])-> data.f32[((iy) * (dx[k])->cols + (ix)) * ((CCV_32S | CCV_C1 ) & 0xFFF) + (0)] : (((CCV_32S | CCV_C1) & CCV_64S) ? (dx[k])->data.i64[((iy) * (dx[k])->cols + (ix)) * ((CCV_32S | CCV_C1) & 0xFFF) + (0)] : (((CCV_32S | CCV_C1) & CCV_64F ) ? (dx[k])->data.f64[((iy) * (dx[k])->cols + (ix)) * ( (CCV_32S | CCV_C1) & 0xFFF) + (0)] : (dx[k])->data.u8[ (iy) * (dx[k])->step + (ix) * ((CCV_32S | CCV_C1) & 0xFFF ) + (0)])))); |
2107 | drift_x += part->alpha[0] * rx + part->alpha[1] * ry; |
2108 | drift_y += part->alpha[2] * rx + part->alpha[3] * ry; |
2109 | drift_scale += part->alpha[4] * rx + part->alpha[5] * ry; |
2110 | ry = iy - ry; |
2111 | rx = ix - rx; |
2112 | comp.part[k].rect = ccv_rect((int)((rx - pww) * CCV_DPM_WINDOW_SIZE(8) / 2 * scale_x + 0.5), (int)((ry - pwh) * CCV_DPM_WINDOW_SIZE(8) / 2 * scale_y + 0.5), (int)(part->w->cols * CCV_DPM_WINDOW_SIZE(8) / 2 * scale_x + 0.5), (int)(part->w->rows * CCV_DPM_WINDOW_SIZE(8) / 2 * scale_y + 0.5)); |
2113 | comp.part[k].classification.confidence = -ccv_get_dense_matrix_cell_value_by(CCV_32F | CCV_C1, part_feature[k], iy, ix, 0)(((CCV_32F | CCV_C1) & CCV_32S) ? (part_feature[k])->data .i32[((iy) * (part_feature[k])->cols + (ix)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)] : (((CCV_32F | CCV_C1) & CCV_32F ) ? (part_feature[k])->data.f32[((iy) * (part_feature[k])-> cols + (ix)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)] : (((CCV_32F | CCV_C1) & CCV_64S) ? (part_feature[k])->data.i64[(( iy) * (part_feature[k])->cols + (ix)) * ((CCV_32F | CCV_C1 ) & 0xFFF) + (0)] : (((CCV_32F | CCV_C1) & CCV_64F) ? (part_feature[k])->data.f64[((iy) * (part_feature[k])-> cols + (ix)) * ((CCV_32F | CCV_C1) & 0xFFF) + (0)] : (part_feature [k])->data.u8[(iy) * (part_feature[k])->step + (ix) * ( (CCV_32F | CCV_C1) & 0xFFF) + (0)])))); |
2114 | } |
2115 | comp.rect = ccv_rect((int)((x + drift_x) * CCV_DPM_WINDOW_SIZE(8) * scale_x - rww * CCV_DPM_WINDOW_SIZE(8) * scale_x * (1.0 + drift_scale) + 0.5), (int)((y + drift_y) * CCV_DPM_WINDOW_SIZE(8) * scale_y - rwh * CCV_DPM_WINDOW_SIZE(8) * scale_y * (1.0 + drift_scale) + 0.5), (int)(root->root.w->cols * CCV_DPM_WINDOW_SIZE(8) * scale_x * (1.0 + drift_scale) + 0.5), (int)(root->root.w->rows * CCV_DPM_WINDOW_SIZE(8) * scale_y * (1.0 + drift_scale) + 0.5)); |
2116 | ccv_array_push(seq, &comp); |
2117 | } |
2118 | f_ptr += root_feature->cols; |
2119 | } |
2120 | for (k = 0; k < root->count; k++) |
2121 | { |
2122 | ccv_matrix_free(part_feature[k]); |
2123 | ccv_matrix_free(dx[k]); |
2124 | ccv_matrix_free(dy[k]); |
2125 | } |
2126 | ccv_matrix_free(root_feature); |
2127 | } |
2128 | scale_x *= scale; |
2129 | scale_y *= scale; |
2130 | } |
2131 | /* the following code from OpenCV's haar feature implementation */ |
2132 | if (params.min_neighbors == 0) |
2133 | { |
2134 | for (i = 0; i < seq->rnum; i++) |
2135 | { |
2136 | ccv_root_comp_t* comp = (ccv_root_comp_t*)ccv_array_get(seq, i)((void*)(((char*)((seq)->data)) + (size_t)(seq)->rsize * (size_t)(i))); |
2137 | ccv_array_push(result_seq, comp); |
2138 | } |
2139 | } else { |
2140 | idx_seq = 0; |
2141 | ccv_array_clear(seq2); |
2142 | // group retrieved rectangles in order to filter out noise |
2143 | int ncomp = ccv_array_group(seq, &idx_seq, _ccv_is_equal_same_class, 0); |
2144 | ccv_root_comp_t* comps = (ccv_root_comp_t*)ccmallocmalloc((ncomp + 1) * sizeof(ccv_root_comp_t)); |
2145 | memset(comps, 0, (ncomp + 1) * sizeof(ccv_root_comp_t)); |
2146 | |
2147 | // count number of neighbors |
2148 | for (i = 0; i < seq->rnum; i++) |
2149 | { |
2150 | ccv_root_comp_t r1 = *(ccv_root_comp_t*)ccv_array_get(seq, i)((void*)(((char*)((seq)->data)) + (size_t)(seq)->rsize * (size_t)(i))); |
2151 | int idx = *(int*)ccv_array_get(idx_seq, i)((void*)(((char*)((idx_seq)->data)) + (size_t)(idx_seq)-> rsize * (size_t)(i))); |
2152 | |
2153 | comps[idx].classification.id = r1.classification.id; |
2154 | comps[idx].pnum = r1.pnum; |
2155 | if (r1.classification.confidence > comps[idx].classification.confidence || comps[idx].neighbors == 0) |
2156 | { |
2157 | comps[idx].rect = r1.rect; |
2158 | comps[idx].classification.confidence = r1.classification.confidence; |
2159 | memcpy(comps[idx].part, r1.part, sizeof(ccv_comp_t) * CCV_DPM_PART_MAX(10)); |
2160 | } |
2161 | |
2162 | ++comps[idx].neighbors; |
2163 | } |
2164 | |
2165 | // calculate average bounding box |
2166 | for (i = 0; i < ncomp; i++) |
2167 | { |
2168 | int n = comps[i].neighbors; |
2169 | if (n >= params.min_neighbors) |
2170 | ccv_array_push(seq2, comps + i); |
2171 | } |
2172 | |
2173 | // filter out large object rectangles contains small object rectangles |
2174 | for (i = 0; i < seq2->rnum; i++) |
2175 | { |
2176 | ccv_root_comp_t* r2 = (ccv_root_comp_t*)ccv_array_get(seq2, i)((void*)(((char*)((seq2)->data)) + (size_t)(seq2)->rsize * (size_t)(i))); |
2177 | int distance = (int)(ccv_min(r2->rect.width, r2->rect.height)({ typeof (r2->rect.width) _a = (r2->rect.width); typeof (r2->rect.height) _b = (r2->rect.height); (_a < _b) ? _a : _b; }) * 0.25 + 0.5); |
2178 | for (j = 0; j < seq2->rnum; j++) |
2179 | { |
2180 | ccv_root_comp_t r1 = *(ccv_root_comp_t*)ccv_array_get(seq2, j)((void*)(((char*)((seq2)->data)) + (size_t)(seq2)->rsize * (size_t)(j))); |
2181 | if (i != j && |
2182 | abs(r1.classification.id) == r2->classification.id && |
2183 | r1.rect.x >= r2->rect.x - distance && |
2184 | r1.rect.y >= r2->rect.y - distance && |
2185 | r1.rect.x + r1.rect.width <= r2->rect.x + r2->rect.width + distance && |
2186 | r1.rect.y + r1.rect.height <= r2->rect.y + r2->rect.height + distance && |
2187 | // if r1 (the smaller one) is better, mute r2 |
2188 | (r2->classification.confidence <= r1.classification.confidence && r2->neighbors < r1.neighbors)) |
2189 | { |
2190 | r2->classification.id = -r2->classification.id; |
2191 | break; |
2192 | } |
2193 | } |
2194 | } |
2195 | |
2196 | // filter out small object rectangles inside large object rectangles |
2197 | for (i = 0; i < seq2->rnum; i++) |
2198 | { |
2199 | ccv_root_comp_t r1 = *(ccv_root_comp_t*)ccv_array_get(seq2, i)((void*)(((char*)((seq2)->data)) + (size_t)(seq2)->rsize * (size_t)(i))); |
2200 | if (r1.classification.id > 0) |
2201 | { |
2202 | int flag = 1; |
2203 | |
2204 | for (j = 0; j < seq2->rnum; j++) |
2205 | { |
2206 | ccv_root_comp_t r2 = *(ccv_root_comp_t*)ccv_array_get(seq2, j)((void*)(((char*)((seq2)->data)) + (size_t)(seq2)->rsize * (size_t)(j))); |
2207 | int distance = (int)(ccv_min(r2.rect.width, r2.rect.height)({ typeof (r2.rect.width) _a = (r2.rect.width); typeof (r2.rect .height) _b = (r2.rect.height); (_a < _b) ? _a : _b; }) * 0.25 + 0.5); |
2208 | |
2209 | if (i != j && |
2210 | r1.classification.id == abs(r2.classification.id) && |
2211 | r1.rect.x >= r2.rect.x - distance && |
2212 | r1.rect.y >= r2.rect.y - distance && |
2213 | r1.rect.x + r1.rect.width <= r2.rect.x + r2.rect.width + distance && |
2214 | r1.rect.y + r1.rect.height <= r2.rect.y + r2.rect.height + distance && |
2215 | (r2.classification.confidence > r1.classification.confidence || r2.neighbors >= r1.neighbors)) |
2216 | { |
2217 | flag = 0; |
2218 | break; |
2219 | } |
2220 | } |
2221 | |
2222 | if (flag) |
2223 | ccv_array_push(result_seq, &r1); |
2224 | } |
2225 | } |
2226 | ccv_array_free(idx_seq); |
2227 | ccfreefree(comps); |
2228 | } |
2229 | } |
2230 | |
2231 | for (i = 0; i < scale_upto + next * 2; i++) |
2232 | ccv_matrix_free(pyr[i]); |
2233 | |
2234 | ccv_array_free(seq); |
2235 | ccv_array_free(seq2); |
2236 | |
2237 | ccv_array_t* result_seq2; |
2238 | /* the following code from OpenCV's haar feature implementation */ |
2239 | if (params.flags & CCV_DPM_NO_NESTED) |
2240 | { |
2241 | result_seq2 = ccv_array_new(sizeof(ccv_root_comp_t), 64, 0); |
2242 | idx_seq = 0; |
2243 | // group retrieved rectangles in order to filter out noise |
2244 | int ncomp = ccv_array_group(result_seq, &idx_seq, _ccv_is_equal, 0); |
2245 | ccv_root_comp_t* comps = (ccv_root_comp_t*)ccmallocmalloc((ncomp + 1) * sizeof(ccv_root_comp_t)); |
2246 | memset(comps, 0, (ncomp + 1) * sizeof(ccv_root_comp_t)); |
2247 | |
2248 | // count number of neighbors |
2249 | for(i = 0; i < result_seq->rnum; i++) |
2250 | { |
2251 | ccv_root_comp_t r1 = *(ccv_root_comp_t*)ccv_array_get(result_seq, i)((void*)(((char*)((result_seq)->data)) + (size_t)(result_seq )->rsize * (size_t)(i))); |
2252 | int idx = *(int*)ccv_array_get(idx_seq, i)((void*)(((char*)((idx_seq)->data)) + (size_t)(idx_seq)-> rsize * (size_t)(i))); |
2253 | |
2254 | if (comps[idx].neighbors == 0 || comps[idx].classification.confidence < r1.classification.confidence) |
2255 | { |
2256 | comps[idx].classification.confidence = r1.classification.confidence; |
2257 | comps[idx].neighbors = 1; |
2258 | comps[idx].rect = r1.rect; |
2259 | comps[idx].classification.id = r1.classification.id; |
2260 | comps[idx].pnum = r1.pnum; |
2261 | memcpy(comps[idx].part, r1.part, sizeof(ccv_comp_t) * CCV_DPM_PART_MAX(10)); |
2262 | } |
2263 | } |
2264 | |
2265 | // calculate average bounding box |
2266 | for(i = 0; i < ncomp; i++) |
2267 | if(comps[i].neighbors) |
2268 | ccv_array_push(result_seq2, &comps[i]); |
2269 | |
2270 | ccv_array_free(result_seq); |
2271 | ccfreefree(comps); |
2272 | } else { |
2273 | result_seq2 = result_seq; |
2274 | } |
2275 | |
2276 | return result_seq2; |
2277 | } |
2278 | |
2279 | ccv_dpm_mixture_model_t* ccv_dpm_read_mixture_model(const char* directory) |
2280 | { |
2281 | FILE* r = fopen(directory, "r"); |
2282 | if (r == 0) |
2283 | return 0; |
2284 | int count; |
2285 | char flag; |
2286 | fscanf(r, "%c", &flag); |
2287 | assert(flag == '.')((void) sizeof ((flag == '.') ? 1 : 0), __extension__ ({ if ( flag == '.') ; else __assert_fail ("flag == '.'", "ccv_dpm.c" , 2287, __extension__ __PRETTY_FUNCTION__); })); |
2288 | fscanf(r, "%d", &count); |
2289 | ccv_dpm_root_classifier_t* root_classifier = (ccv_dpm_root_classifier_t*)ccmallocmalloc(sizeof(ccv_dpm_root_classifier_t) * count); |
2290 | memset(root_classifier, 0, sizeof(ccv_dpm_root_classifier_t) * count); |
2291 | int i, j, k; |
2292 | size_t size = sizeof(ccv_dpm_mixture_model_t) + sizeof(ccv_dpm_root_classifier_t) * count; |
2293 | /* the format is easy, but I tried to copy all data into one memory region */ |
2294 | for (i = 0; i < count; i++) |
2295 | { |
2296 | int rows, cols; |
2297 | fscanf(r, "%d %d", &rows, &cols); |
2298 | fscanf(r, "%f %f %f %f", &root_classifier[i].beta, &root_classifier[i].alpha[0], &root_classifier[i].alpha[1], &root_classifier[i].alpha[2]); |
2299 | root_classifier[i].root.w = ccv_dense_matrix_new(rows, cols, CCV_32F | 31, ccmallocmalloc(ccv_compute_dense_matrix_size(rows, cols, CCV_32F | 31)(((sizeof(ccv_dense_matrix_t) + 63) & -64) + (((cols) * _ccv_get_data_type_size [((CCV_32F | 31) & 0xFF000) >> 12] * ((CCV_32F | 31 ) & 0xFFF) + 3) & -4) * (rows))), 0); |
2300 | size += ccv_compute_dense_matrix_size(rows, cols, CCV_32F | 31)(((sizeof(ccv_dense_matrix_t) + 63) & -64) + (((cols) * _ccv_get_data_type_size [((CCV_32F | 31) & 0xFF000) >> 12] * ((CCV_32F | 31 ) & 0xFFF) + 3) & -4) * (rows)); |
2301 | for (j = 0; j < rows * cols * 31; j++) |
2302 | fscanf(r, "%f", &root_classifier[i].root.w->data.f32[j]); |
2303 | ccv_make_matrix_immutable(root_classifier[i].root.w); |
2304 | fscanf(r, "%d", &root_classifier[i].count); |
2305 | ccv_dpm_part_classifier_t* part_classifier = (ccv_dpm_part_classifier_t*)ccmallocmalloc(sizeof(ccv_dpm_part_classifier_t) * root_classifier[i].count); |
2306 | size += sizeof(ccv_dpm_part_classifier_t) * root_classifier[i].count; |
2307 | for (j = 0; j < root_classifier[i].count; j++) |
2308 | { |
2309 | fscanf(r, "%d %d %d", &part_classifier[j].x, &part_classifier[j].y, &part_classifier[j].z); |
2310 | fscanf(r, "%lf %lf %lf %lf", &part_classifier[j].dx, &part_classifier[j].dy, &part_classifier[j].dxx, &part_classifier[j].dyy); |
2311 | fscanf(r, "%f %f %f %f %f %f", &part_classifier[j].alpha[0], &part_classifier[j].alpha[1], &part_classifier[j].alpha[2], &part_classifier[j].alpha[3], &part_classifier[j].alpha[4], &part_classifier[j].alpha[5]); |
2312 | fscanf(r, "%d %d %d", &rows, &cols, &part_classifier[j].counterpart); |
2313 | part_classifier[j].w = ccv_dense_matrix_new(rows, cols, CCV_32F | 31, ccmallocmalloc(ccv_compute_dense_matrix_size(rows, cols, CCV_32F | 31)(((sizeof(ccv_dense_matrix_t) + 63) & -64) + (((cols) * _ccv_get_data_type_size [((CCV_32F | 31) & 0xFF000) >> 12] * ((CCV_32F | 31 ) & 0xFFF) + 3) & -4) * (rows))), 0); |
2314 | size += ccv_compute_dense_matrix_size(rows, cols, CCV_32F | 31)(((sizeof(ccv_dense_matrix_t) + 63) & -64) + (((cols) * _ccv_get_data_type_size [((CCV_32F | 31) & 0xFF000) >> 12] * ((CCV_32F | 31 ) & 0xFFF) + 3) & -4) * (rows)); |
2315 | for (k = 0; k < rows * cols * 31; k++) |
2316 | fscanf(r, "%f", &part_classifier[j].w->data.f32[k]); |
2317 | ccv_make_matrix_immutable(part_classifier[j].w); |
2318 | } |
2319 | root_classifier[i].part = part_classifier; |
2320 | } |
2321 | fclose(r); |
2322 | unsigned char* m = (unsigned char*)ccmallocmalloc(size); |
2323 | ccv_dpm_mixture_model_t* model = (ccv_dpm_mixture_model_t*)m; |
2324 | m += sizeof(ccv_dpm_mixture_model_t); |
2325 | model->count = count; |
2326 | model->root = (ccv_dpm_root_classifier_t*)m; |
2327 | m += sizeof(ccv_dpm_root_classifier_t) * model->count; |
2328 | memcpy(model->root, root_classifier, sizeof(ccv_dpm_root_classifier_t) * model->count); |
2329 | ccfreefree(root_classifier); |
2330 | for (i = 0; i < model->count; i++) |
2331 | { |
2332 | ccv_dpm_part_classifier_t* part_classifier = model->root[i].part; |
2333 | model->root[i].part = (ccv_dpm_part_classifier_t*)m; |
2334 | m += sizeof(ccv_dpm_part_classifier_t) * model->root[i].count; |
2335 | memcpy(model->root[i].part, part_classifier, sizeof(ccv_dpm_part_classifier_t) * model->root[i].count); |
2336 | ccfreefree(part_classifier); |
2337 | } |
2338 | for (i = 0; i < model->count; i++) |
2339 | { |
2340 | ccv_dense_matrix_t* w = model->root[i].root.w; |
2341 | model->root[i].root.w = (ccv_dense_matrix_t*)m; |
2342 | m += ccv_compute_dense_matrix_size(w->rows, w->cols, w->type)(((sizeof(ccv_dense_matrix_t) + 63) & -64) + (((w->cols ) * _ccv_get_data_type_size[((w->type) & 0xFF000) >> 12] * ((w->type) & 0xFFF) + 3) & -4) * (w->rows )); |
2343 | memcpy(model->root[i].root.w, w, ccv_compute_dense_matrix_size(w->rows, w->cols, w->type)(((sizeof(ccv_dense_matrix_t) + 63) & -64) + (((w->cols ) * _ccv_get_data_type_size[((w->type) & 0xFF000) >> 12] * ((w->type) & 0xFFF) + 3) & -4) * (w->rows ))); |
2344 | model->root[i].root.w->data.u8 = (unsigned char*)(model->root[i].root.w + 1); |
2345 | ccfreefree(w); |
2346 | for (j = 0; j < model->root[i].count; j++) |
2347 | { |
2348 | w = model->root[i].part[j].w; |
2349 | model->root[i].part[j].w = (ccv_dense_matrix_t*)m; |
2350 | m += ccv_compute_dense_matrix_size(w->rows, w->cols, w->type)(((sizeof(ccv_dense_matrix_t) + 63) & -64) + (((w->cols ) * _ccv_get_data_type_size[((w->type) & 0xFF000) >> 12] * ((w->type) & 0xFFF) + 3) & -4) * (w->rows )); |
2351 | memcpy(model->root[i].part[j].w, w, ccv_compute_dense_matrix_size(w->rows, w->cols, w->type)(((sizeof(ccv_dense_matrix_t) + 63) & -64) + (((w->cols ) * _ccv_get_data_type_size[((w->type) & 0xFF000) >> 12] * ((w->type) & 0xFFF) + 3) & -4) * (w->rows ))); |
2352 | model->root[i].part[j].w->data.u8 = (unsigned char*)(model->root[i].part[j].w + 1); |
2353 | ccfreefree(w); |
2354 | } |
2355 | } |
2356 | return model; |
2357 | } |
2358 | |
2359 | void ccv_dpm_mixture_model_free(ccv_dpm_mixture_model_t* model) |
2360 | { |
2361 | ccfreefree(model); |
2362 | } |