static void add_line_to_postscript(paps_private_t *paps, GString *line_str, double x_pos, double y_pos, PangoLayoutLine *line) { PangoRectangle ink_rect, logical_rect; pango_layout_line_get_extents(line, &ink_rect, &logical_rect); #if 0 // TBD - Handle RTL scripts if (paps->pango_dir == PANGO_DIRECTION_RTL) { x_pos += page_layout->column_width - logical_rect.width / (page_layout->pt_to_pixel * PANGO_SCALE); } #endif draw_contour(paps, line_str, line, x_pos, y_pos); }
/* Find fastest path from known maze information * and return the FRBL turn array to the caller. * if first turn is one of RBL, it means that the * mouse has to make back turn or smooth L/R turn. * In that case, no diagonal turns. * * fast_path_type: 0 find all possible pathes * 1 find from only known blocks */ unsigned char *find_maze_fastest_path( unsigned char cur_mouse_pos, char cur_mouse_dir, unsigned int search_type, struct s_link *f_node, int fast_path_type) { unsigned char *path; struct s_link *mouse_path; struct s_link *sl_fast_path; #ifdef DEBUG int i; #endif if (!f_node) print_exit("f_node NULL\n"); print_dbg(DEBUG_SEARCH, "mouse pos:%d,%d mouse_dir:%d " "search_type:%d\n", pos_x(cur_mouse_pos), pos_y(cur_mouse_pos), cur_mouse_dir, search_type); /* draw contour map from the goal */ draw_contour(maze_search, contour_map, search_type, cur_mouse_pos); /* generate full binary tree with all pathes */ mouse_path = gen_bin_tree(maze_search, contour_map, cur_mouse_pos, cur_mouse_dir); /* find the fastest path and get the node */ sl_fast_path = find_fastest_path(mouse_path, fast_path_type); if (sl_fast_path) { memcpy(f_node, sl_fast_path, sizeof(struct s_link)); /* Free sl_nodes after searching the fastest path */ sl_node_free(mouse_path); } else { sl_node_free(mouse_path); return NULL; } /* generate FRBL array for the fastest path */ path = gen_frbl_from_node(f_node); #ifdef DEBUG printf("%s\n", __func__); for (i = 0; path[i] != 0xff; i++) printf("%C", (path[i] == FD) ? 'F' : \ ((path[i] == RD) ? 'R' : \ ((path[i] == BD) ? 'B' : \ ((path[i] == LD) ? 'L' : 'X')))); printf("\n"); #endif return path; }
int main (int argc, char *argv[]) { IplImage *rgb, *depth, *tmp, *body, *hand; CvMat **tr, *mean, *cov; CvFileStorage *fs; int count=0, p=0, warmup=1; parse_args(argc, argv); rgb = cvCreateImage(cvSize(W,H), 8, 3); tr = (CvMat**)malloc(sizeof(CvMat*)*num); init_training_data(tr,num); mean = cvCreateMat(1, FD_NUM, CV_64FC1); cov = cvCreateMat(FD_NUM, FD_NUM, CV_64FC1); fs = cvOpenFileStorage(outfile, NULL, CV_STORAGE_WRITE, NULL); assert(fs); for (;;) { int z, k, c; CvMat *fd; CvSeq *cnt; tmp = freenect_sync_get_rgb_cv(0); cvCvtColor(tmp, rgb, CV_BGR2RGB); depth = freenect_sync_get_depth_cv(0); body = body_detection(depth); hand = hand_detection(body, &z); if (!get_hand_contour_advanced(hand, rgb, z, &cnt, NULL)) continue; if (warmup) { draw_contour(cnt); if (k = cvWaitKey(T) == 'g') { warmup = 0; cvDestroyAllWindows(); } continue; } fd = get_fourier_descriptors(cnt); add_training_data(tr[count], fd); if (count == 0) printf("---> training hand pose %d\n", p); if (++count == num) { int c; cvCalcCovarMatrix((void*)tr, count, cov, mean, CV_COVAR_NORMAL); cvInvert(cov, cov, CV_LU); save_posture_model(fs, mean, cov); p++; count = 0; printf("save and quit:s exit:q next:any \n"); if ((c = cvWaitKey(0)) == 's') { break; } else if (c == 'q') { break; } else { continue; } } draw_contour(cnt); cvWaitKey(T); } cvWriteInt(fs, "total", p); freenect_sync_stop(); free_training_data(tr,num); cvReleaseFileStorage(&fs); cvReleaseMat(&mean); cvReleaseMat(&cov); cvReleaseImage(&rgb); return 0; }
void compute_optimized() { const int divisions = 5; const int generations = 10; const int initial_seed_num = 10; const int min_seed_num = 1; const int max_seed_num = 10; const int items_in_each_division = points_collection.size() / divisions; const int points_collection_size = points_collection.size(); int total_iterations = 0; bool checker[1000] { 0 }; unordered_map<int, float> division_dist_min_checker; unordered_map<float, int> dist_min_division_checker; unordered_map<float, bool> dist_min_checker; unordered_map<float, int> dist_min_index_checker; float dist_min_selected = 9999; vector<Point> database_points_selected; for (int i = 0; i < generations; ++i) { for (int a = 0; a < (points_collection_size - 1); a += items_in_each_division) { int index_min = a; int index_max = a + items_in_each_division; vector<int> seed_indexes; for (int b = index_min; b <= index_max; ++b) seed_indexes.push_back(b); if (seed_indexes.size() == 0) continue; int seed_num = initial_seed_num; if (i > 0) { float dist_min = division_dist_min_checker[a]; int index_division = dist_min_index_checker[dist_min]; seed_num = map_val(index_division, 0, divisions - 1, min_seed_num, max_seed_num); } for (int b = 0; b < seed_num; ++b) { int k = get_random(0, seed_indexes.size() - 1); int seed_index = seed_indexes[k]; if (checker[seed_index] == true) continue; checker[seed_index] = true; vector<Point> database_points = points_collection[seed_index]; float dist = compute_dtw_dist(points_current, database_points); if (dist < dist_min_selected) { dist_min_selected = dist; database_points_selected = database_points; } ++total_iterations; float dist_min = division_dist_min_checker.count(a) > 0 ? division_dist_min_checker[a] : 9999; if (dist >= dist_min) continue; dist_min = dist; while (dist_min_checker.count(dist_min) > 0) dist_min += 0.001; dist_min_checker[dist_min] = true; division_dist_min_checker[a] = dist_min; dist_min_division_checker[dist_min] = a; } } vector<float> dist_min_vec; for (int a = 0; a < (points_collection_size - 1); a += items_in_each_division) dist_min_vec.push_back(division_dist_min_checker[a]); std::sort(dist_min_vec.begin(), dist_min_vec.end(), decreasing()); int index = -1; for (float& dist_min : dist_min_vec) { ++index; dist_min_index_checker[dist_min] = index; } } Mat image_haha = Mat::zeros(HEIGHT_SMALL, WIDTH_SMALL, CV_8UC1); draw_contour(database_points_selected, image_haha, 254, 1, 0); imshow("image_haha", image_haha); waitKey(1); cout << total_iterations << endl; }