int run_program(int argc, char **argv) { CommandLineArgument<std::string> image_pathname; CommandLineArgument<std::string> points_pathname; CommandLineArgument<std::string> output_pathname; int radius = 5; cv::Scalar colour(0,0,255); int thickness = 1; int line_type = 8; int shift = 0; double wait_time; for (int i = 1; i < argc; i++) { std::string argument(argv[i]); if (argument == "--help") { print_usage(); return 0; } else if (argument == "--radius") { radius = get_argument<int>(&i, argc, argv); } else if (argument == "--colour") { colour[2] = get_argument<int>(&i, argc, argv); colour[1] = get_argument<int>(&i, argc, argv); colour[0] = get_argument<int>(&i, argc, argv); } else if (argument == "--wait-time") { wait_time = get_argument<double>(&i, argc, argv); } else if (!assign_argument(argument, image_pathname, points_pathname, output_pathname)) { throw make_runtime_error("Do not know how to process argument '%s'", argument.c_str()); } } if (!have_arguments_p(image_pathname, points_pathname)) { print_usage(); return 0; } cv::Mat img = cv::imread(image_pathname->c_str()); if ((img.rows == 0) || (img.cols == 0)) throw make_runtime_error("Unable to load image at path '%s'", image_pathname->c_str()); std::vector<cv::Point_<double> > pts = load_points(points_pathname->c_str()); for (size_t i = 0; i < pts.size(); i++) { cv::circle(img, pts[i], radius, colour, thickness, line_type, shift); } if (have_argument_p(output_pathname)) { cv::imwrite(output_pathname->c_str(), img); } else { cv::imshow("Image", img); cv::waitKey(1000*wait_time); } return 0; }
int run_program(int argc, char **argv) { CommandLineArgument<std::string> input_pathnames_filename; CommandLineArgument<std::string> output_pathnames_filename; CommandLineArgument<std::string> new_directory; CommandLineArgument<std::string> new_type; for (int i = 1; i < argc; i++) { std::string argument = argv[i]; if (argument == "--help") { print_usage(); return 0; } else if (argument == "--directory") { new_directory = get_argument(&i, argc, argv); } else if (argument == "--type") { new_type = get_argument(&i, argc, argv); } else if (!assign_argument(argument, input_pathnames_filename, output_pathnames_filename)) { throw make_runtime_error("Unable to process argument '%s'", argument.c_str()); } } if (!have_arguments_p(input_pathnames_filename, output_pathnames_filename)) { print_usage(); return -1; } std::list<std::string> input_pathnames; if (*input_pathnames_filename == "-") input_pathnames = read_list(std::cin); else input_pathnames = read_list(input_pathnames_filename->c_str()); std::ostream *out; std::ofstream out_f; if (*output_pathnames_filename == "-") out = &std::cout; else { out_f.open(output_pathnames_filename->c_str(), std::ios::out | std::ios::trunc); if (!out_f.is_open()) throw make_runtime_error("Failed to open file '%s'", output_pathnames_filename->c_str()); out = &out_f; } if (have_arguments_p(new_directory, new_type)) output_new_pathnames(input_pathnames, *out, DirectoryAndType(*new_directory, *new_type)); else if (have_argument_p(new_directory)) output_new_pathnames(input_pathnames, *out, DirectoryOnly(*new_directory)); else if (have_argument_p(new_type)) output_new_pathnames(input_pathnames, *out, TypeOnly(*new_type)); return 0; }
void perform(const std::string &command, const std::list<std::string> &arguments) { STARTUPINFO si; PROCESS_INFORMATION pi; ZeroMemory( &si, sizeof(si) ); si.cb = sizeof(si); ZeroMemory( &pi, sizeof(pi) ); if(!CreateProcess(NULL, "", NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)){ //child process char *argv[arguments.size() + 2]; argv[0] = (char *)command.c_str(); argv[arguments.size() + 1] = 0; std::list<std::string>::const_iterator it = arguments.begin(); for (size_t i = 0; i < arguments.size(); i++) { argv[i + 1] = (char *)it->c_str(); it++; } int rv = _execvp(command.c_str(), argv); if (rv == -1) throw make_runtime_error("Unable to create new process: %s.", strerror(errno)); } else { // parent process throw make_runtime_error("CreateProcess failed (%d).\n", GetLastError() ); return; } // Wait until child process exits. WaitForSingleObject( pi.hProcess, INFINITE ); // Close process and thread handles. CloseHandle( pi.hProcess ); CloseHandle( pi.hThread ); }
int run_program(int argc, char **argv) { CommandLineArgument<std::string> model_pathname; for (int i = 1; i < argc; i++) { std::string argument(argv[i]); if (argument == "--help") { print_usage(); return 0; } else if (!assign_argument(argument, model_pathname)) { throw make_runtime_error("Do not know how to process argument '%s'", argument.c_str()); } } if (!have_argument_p(model_pathname)) model_pathname = AVATAR::DefaultAvatarModelPathname(); if (!file_exists_p(model_pathname->c_str())) throw make_runtime_error("Model file '%s' does not exist", model_pathname->c_str()); AVATAR::Avatar *avatar = AVATAR::LoadAvatar(model_pathname->c_str()); if (avatar->numberOfAvatars() == 0) return 0; print_controls(); const int minimum_avatar = 0; const int maximum_avatar = avatar->numberOfAvatars() - 1; int index = 0; bool quit_application_p = false; printf("Number of avatars: %d\n", avatar->numberOfAvatars()); show_avatar(avatar, index); while (!quit_application_p) { char ch = cv::waitKey(10); switch (ch) { case 'a': case 2: index = std::max(minimum_avatar, index - 1); show_avatar(avatar, index); break; case 'd': case 3: index = std::min(maximum_avatar, index + 1); show_avatar(avatar, index); break; case 'q': case 27: quit_application_p = true; break; case -1: break; default: break; } } printf("\n"); delete avatar; return 0; }
int run_program(int argc, char **argv) { CommandLineArgument<std::string> points_pathname; Configuration cfg; cfg.width = 640; cfg.height = 480; cfg.window_title = ""; cfg.circle_radius = 2; cfg.circle_thickness = 1; cfg.circle_linetype = 8; cfg.circle_shift = 0; cfg.circle_colour = cv::Scalar(0, 0, 255); for (int i = 1; i < argc; i++) { std::string argument(argv[i]); if (argument == "--help") { print_usage(); return 0; } else if (argument == "--width") { cfg.width = get_argument<int>(&i, argc, argv); } else if (argument == "--height") { cfg.height = get_argument<int>(&i, argc, argv); } else if (argument == "--window-title") { cfg.window_title = get_argument(&i, argc, argv); } else if (argument == "--circle-radius") { cfg.circle_radius = get_argument<int>(&i, argc, argv); } else if (!assign_argument(argument, points_pathname)) { throw make_runtime_error("Unable to process argument: %s\n", argument.c_str()); } } if (!have_argument_p(points_pathname)) { print_usage(); return -1; } if (cfg.window_title == "") cfg.window_title = points_pathname->c_str(); std::vector<cv::Point3_<double> > shape3D; try { shape3D = load_points3(points_pathname->c_str()); } catch (std::exception &e) { throw make_runtime_error("Encountered error when reading file '%s': %s", points_pathname->c_str(), e.what()); } cv::Point3_<double> mean = calculate_mean(shape3D); for (size_t i = 0; i < shape3D.size(); i++) { shape3D[i] -= mean; } cv::Mat_<double> projection = cv::Mat_<double>::eye(3,4); if (cfg.height < cfg.width) { projection(0,3) = double(cfg.width - cfg.height) / 2.0; } else { projection(1,3) = double(cfg.height - cfg.width) / 2.0; } cv::Mat_<double> starting_A = calculate_similarity_transform(shape3D, cfg.height, cfg.width); cv::Mat_<double> A(starting_A.clone()); bool quit = false; while (!quit) { int key = cv::waitKey(1); switch (key) { case 27: quit = true; break; case 'z': A = A * scaling_matrix(1.1); break; case 'x': A = A * scaling_matrix(0.9); break; case 'a': A = A * rotation_about_y_axis(-0.1); break; case 'd': A = A * rotation_about_y_axis(0.1); break; case 'w': A = A * rotation_about_x_axis(-0.1); break; case 's': A = A * rotation_about_x_axis(0.1); break; case 'q': A = A * rotation_about_z_axis(0.1); break; case 'e': A = A * rotation_about_z_axis(-0.1); break; case 'r': A = starting_A.clone(); break; } display_points(cfg, projection * A, shape3D); } return 0; }
int run_program(int argc, char **argv) { CommandLineArgument<int> number_of_list_files; int next_command_line_argument = 0; bool echo_commands = false; for (int i = 1; ((i < argc) && (!have_argument_p(number_of_list_files))); i++) { std::string argument(argv[i]); if (argument == "--help") { print_usage(); return 0; } else if (argument == "--echo") { echo_commands = true; } else if (!have_argument_p(number_of_list_files)) { number_of_list_files = argument; next_command_line_argument = i + 1; } } if (!have_argument_p(number_of_list_files)) { print_usage(); return -1; } if (*number_of_list_files == 0) return 0; const int minimum_number_of_arguments = 0 + *number_of_list_files + 1 // the command; + 0; if ((argc - next_command_line_argument) < minimum_number_of_arguments) throw make_runtime_error("Not enough arguments available for processing.\n"); std::list<std::string> standard_input_list; bool have_read_standard_input_list = false; std::vector<std::string> list_filenames(*number_of_list_files); std::vector<std::list<std::string> > lists(*number_of_list_files); for (int i = 0; i < *number_of_list_files; i++) { int argument_index = i + next_command_line_argument; std::string list_file = argv[argument_index]; std::list<std::string> l; if ((list_file == "-") && (have_read_standard_input_list)) { l = standard_input_list; } else if ((list_file == "-")) { standard_input_list = read_list(std::cin); have_read_standard_input_list = true; l = standard_input_list; } else if (!file_exists_p(list_file)) { throw make_runtime_error("List file %s does not exist.", list_file.c_str()); } else { l = read_list(list_file.c_str()); } list_filenames[i] = list_file; lists[i] = l; } next_command_line_argument += *number_of_list_files; // read the command and its options. std::string command(argv[next_command_line_argument]); std::list<std::string> command_arguments; std::copy(argv + next_command_line_argument + 1, argv + argc, std::back_inserter(command_arguments)); // check all lists are the same size. for (size_t i = 0; i < lists.size(); i++) { if (lists[i].size() != lists[0].size()) throw make_runtime_error("The number of entires in list %s (%d) differs to %s (%d).", list_filenames[i].c_str(), lists[i].size(), list_filenames[0].c_str(), lists[0].size()); } EchoRunner echo_runner(std::cout); ForkRunner fork_runner; Runner *runner = 0; if (echo_commands) runner = &echo_runner; else runner = &fork_runner; assert(runner); std::vector<std::list<std::string>::const_iterator> iterators(*number_of_list_files); for (int i = 0; i < *number_of_list_files; i++) iterators[i] = lists[i].begin(); for (size_t i = 0; i < lists[0].size(); i++) { std::string invocation_command = command; std::list<std::string> invocation_arguments; std::copy(command_arguments.begin(), command_arguments.end(), std::back_inserter(invocation_arguments)); for (size_t j = 0; j < iterators.size(); j++) { invocation_arguments.push_back(*iterators[j]); iterators[j]++; } runner->perform(invocation_command, invocation_arguments); } return 0; }