int convert_anim(const char *infname) { int i, bufsz; const struct aiScene *aiscn; struct goat3d *goat; char *outfname; bufsz = output_filename(0, 0, infname, "goatanim"); outfname = alloca(bufsz); output_filename(outfname, bufsz, infname, "goatanim"); printf("converting %s -> %s\n", infname, outfname); if(!(aiscn = aiImportFile(infname, ANM_PPFLAGS))) { fprintf(stderr, "failed to import %s\n", infname); return -1; } goat = goat3d_create(); for(i=0; i<(int)aiscn->mRootNode->mNumChildren; i++) { process_node(goat, 0, aiscn->mRootNode->mChildren[i]); } for(i=0; i<aiscn->mNumAnimations; i++) { if(process_anim(goat, aiscn->mAnimations[i]) == -1) { return -1; } } goat3d_save_anim(goat, outfname); goat3d_free(goat); aiReleaseImport(aiscn); return 0; }
void go() override { const std::string comp_type = get_arg("type"); std::unique_ptr<Botan::Transform> compress; #if defined(BOTAN_HAS_COMPRESSION) compress.reset(Botan::make_compressor(comp_type, get_arg_sz("level"))); #endif if(!compress) { throw CLI_Error_Unsupported("Compression", comp_type); } const std::string in_file = get_arg("file"); std::ifstream in(in_file); if(!in.good()) { throw CLI_IO_Error("reading", in_file); } const std::string out_file = output_filename(in_file, comp_type); std::ofstream out(out_file); if(!in.good()) { throw CLI_IO_Error("writing", out_file); } do_compress(*compress, in, out, get_arg_sz("buf-size")); }
void run_lexer_on_file( const std::string & filename ) { std::cout << "Parsing file " << filename << "..." << std::endl; llvm::SmallString<128> output_filename( filename ); llvm::sys::path::replace_extension( output_filename, ".cpp.lex" ); std::ofstream output( output_filename.c_str() ); clang::CompilerInstance ci; ci.createDiagnostics(0, 0); clang::TargetOptions * targ_opts = new clang::TargetOptions(); targ_opts->Triple = llvm::sys::getDefaultTargetTriple(); clang::TargetInfo * targ = clang::TargetInfo::CreateTargetInfo( ci.getDiagnostics(), *targ_opts ); ci.setTarget( targ ); ci.createFileManager(); ci.createSourceManager( ci.getFileManager() ); ci.createPreprocessor(); const clang::FileEntry * file = ci.getFileManager().getFile( filename ); ci.getSourceManager().createMainFileID( file ); ci.getPreprocessor().EnterMainSourceFile(); ci.getDiagnosticClient().BeginSourceFile( ci.getLangOpts(), &ci.getPreprocessor() ); clang::Token tok; do { ci.getPreprocessor().Lex( tok ); output << tok.getName() << '\n'; } while( tok.isNot( clang::tok::eof ) ); ci.getDiagnosticClient().EndSourceFile(); }
int convert(const char *infname) { int i, bufsz; const struct aiScene *aiscn; struct goat3d *goat; char *outfname; bufsz = output_filename(0, 0, infname, "goat3d"); outfname = alloca(bufsz); output_filename(outfname, bufsz, infname, "goat3d"); printf("converting %s -> %s\n", infname, outfname); if(!(aiscn = aiImportFile(infname, SCE_PPFLAGS))) { fprintf(stderr, "failed to import %s\n", infname); return -1; } goat = goat3d_create(); for(i=0; i<(int)aiscn->mNumMaterials; i++) { struct aiMaterial *aimat = aiscn->mMaterials[i]; struct goat3d_material *mat = goat3d_create_mtl(); process_material(mat, aimat); goat3d_add_mtl(goat, mat); } for(i=0; i<(int)aiscn->mNumMeshes; i++) { struct aiMesh *aimesh = aiscn->mMeshes[i]; struct goat3d_mesh *mesh = goat3d_create_mesh(); process_mesh(goat, mesh, aimesh); goat3d_add_mesh(goat, mesh); } for(i=0; i<(int)aiscn->mRootNode->mNumChildren; i++) { process_node(goat, 0, aiscn->mRootNode->mChildren[i]); } goat3d_save(goat, outfname); goat3d_free(goat); aiReleaseImport(aiscn); return 0; }
void plot_output( double *t, ///< time (I) double *xd, ///< differential states (I) double *xa, ///< algebraic states (I) double *u, ///< controls (I) double *p_free, ///< global model parameters (I) double *rwh, ///< real work array (I) long *iwh, ///< integer work array (I) InfoPtr *info ){ FILE *fp; stringstream output_filename(""); // Filename char problemname[50]; get_pname(problemname); output_filename << "./RES/" << problemname <<".plt"; if (*t == 0) fp = fopen(output_filename.str().c_str(), "w"); else fp = fopen(output_filename.str().c_str(), "a"); if (!fp) { fprintf(stderr, "Error: Could not open file '%s'!\n", output_filename.str().c_str()); return; } if (*t == 0) { // write header: /// Get names of model quantities. char **xd_name[1]; /* differential state names (O) */ char **xa_name[1]; /* algebraic state names (O) */ char **u_name[1]; /* control names (O) */ char **h_name[1]; /* model stage duration names (O) */ char **p_name[1]; /* global model parameter names (O) */ char *of_name[1]; /* objective name (O) */ get_names(xd_name, xa_name, u_name, h_name, p_name, of_name); fprintf(fp, "//time\t"); for (int i = 0; i<NY; i++){ fprintf(fp, "%s\t",xd_name[0][i]); } for (int i = 0; i<NU; i++){ fprintf(fp, "%s\t",u_name[0][i]); } fprintf(fp, "\n"); } fprintf(fp, "%e\t", *t); for (int i = 0; i<NY; i++){ fprintf(fp, "%e\t",xd[i]); } for (int i = 0; i<NU; i++){ fprintf(fp, "%e\t",u[i]); } fprintf(fp, "\n"); // Close file fclose(fp); }
void go() override { const std::string comp_type = get_arg("type"); const size_t buf_size = get_arg_sz("buf-size"); const size_t comp_level = get_arg_sz("level"); std::unique_ptr<Botan::Compression_Algorithm> compress; compress.reset(Botan::make_compressor(comp_type)); if(!compress) { throw CLI_Error_Unsupported("Compression", comp_type); } const std::string in_file = get_arg("file"); std::ifstream in(in_file, std::ios::binary); if(!in.good()) { throw CLI_IO_Error("reading", in_file); } const std::string out_file = output_filename(in_file, comp_type); std::ofstream out(out_file, std::ios::binary); if(!in.good()) { throw CLI_IO_Error("writing", out_file); } Botan::secure_vector<uint8_t> buf; compress->start(comp_level); while(in.good()) { buf.resize(buf_size); in.read(reinterpret_cast<char*>(&buf[0]), buf.size()); buf.resize(in.gcount()); compress->update(buf); out.write(reinterpret_cast<const char*>(&buf[0]), buf.size()); } buf.clear(); compress->finish(buf); out.write(reinterpret_cast<const char*>(&buf[0]), buf.size()); out.close(); }
void getSokolovOfChainsBulk(string path, string input_name) { string input_filename(path); input_filename.append(input_name); std::ifstream input_file; input_file.open(input_filename); string line; getline (input_file, line); istringstream linestream(line); int L, l, m; long double eps; string output_name; linestream >> L >> l >> m >> eps >> output_name; string output_filename(path); output_filename.append(output_name); std::ofstream output_file; output_file.open(output_filename); output_file.close(); int max_probs_count = 20; vector<long double> probs; probs.reserve(max_probs_count); int probs_count = 0; do { getline (input_file, line); if (!line.empty()) { vector<int> errors(readChainErrors(line)); long double prob = GetSokolovBound(L, l, m, eps, errors); probs.push_back(prob); ++probs_count; } if ((probs_count == max_probs_count) or (input_file.eof())) { output_file.open(output_filename, std::ios::app); copy(probs.begin(), probs.end(), std::ostream_iterator<long double>(output_file, "\n")); output_file.close(); probs.clear(); probs.reserve(max_probs_count); probs_count = 0; } std::cout << probs.size() << "\n"; } while (!input_file.eof()); input_file.close(); }
void Transcoder::run() { position_ = eta_ = audio_b_ = video_b_ = -1; stopping_ = false; pass_ = extra_args_.contains("--two-pass") ? 0 : -1; proc_.start(ffmpeg2theora(), QStringList() << "--frontend" << extra_args_ << "--output" << output_filename() << input_filename()); if (proc_.waitForStarted()) exec(); else emit statusUpdate("Encoding failed to start"); }
static void write_log(gpr_timer_log *log) { size_t i; if (output_file == NULL) { output_file = fopen(output_filename(), "w"); } for (i = 0; i < log->num_entries; i++) { gpr_timer_entry *entry = &(log->log[i]); if (gpr_time_cmp(entry->tm, gpr_time_0(entry->tm.clock_type)) < 0) { entry->tm = gpr_time_0(entry->tm.clock_type); } fprintf(output_file, "{\"t\": %" PRId64 ".%09d, \"thd\": \"%d\", \"type\": \"%c\", \"tag\": " "\"%s\", \"file\": \"%s\", \"line\": %d, \"imp\": %d}\n", entry->tm.tv_sec, entry->tm.tv_nsec, entry->thd, entry->type, entry->tagstr, entry->file, entry->line, entry->important); } }
int main(int argc, char **argv) { try { TCLAP::CmdLine cmd("Centers a mesh", ' ', "1.0"); TCLAP::ValueArg<std::string> log_filename("l","logfile", "Log file name (default is convert.log)", false, "convert.log", "string"); cmd.add( log_filename ); TCLAP::UnlabeledValueArg<std::string> input_filename( "input-filename", "Input file name", true, "", "InputFile" ); cmd.add( input_filename ); TCLAP::UnlabeledValueArg<std::string> output_filename( "output-filename", "Output file name", true, "", "OutputFile" ); cmd.add( output_filename ); cmd.parse( argc, argv ); if ( !log_filename.getValue().empty() ) viennamesh_log_add_logging_file(log_filename.getValue().c_str(), NULL); viennamesh::context_handle context; viennamesh::algorithm_handle mesh_reader = context.make_algorithm("mesh_reader"); mesh_reader.set_input( "filename", input_filename.getValue() ); mesh_reader.run(); viennamesh::algorithm_handle center_mesh = context.make_algorithm("center_mesh"); center_mesh.set_default_source(mesh_reader); center_mesh.run(); viennamesh::algorithm_handle mesh_writer = context.make_algorithm("mesh_writer"); mesh_writer.set_default_source(center_mesh); mesh_writer.set_input( "filename", output_filename.getValue() ); mesh_writer.run(); } catch (TCLAP::ArgException &e) // catch any exceptions { std::cerr << "error: " << e.error() << " for arg " << e.argId() << std::endl; } return 0; }
int main(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << " INFILE\n"; exit(1); } std::string output_format("SQLite"); std::string input_filename(argv[1]); std::string output_filename("multipolygon.db"); OGRDataSource* data_source = initialize_database(output_format, output_filename); osmium::area::ProblemReporterOGR problem_reporter(data_source); osmium::area::Assembler::config_type assembler_config(&problem_reporter); assembler_config.enable_debug_output(); osmium::area::MultipolygonCollector<osmium::area::Assembler> collector(assembler_config); std::cerr << "Pass 1...\n"; osmium::io::Reader reader1(input_filename); collector.read_relations(reader1); reader1.close(); std::cerr << "Pass 1 done\n"; index_type index_pos; index_type index_neg; location_handler_type location_handler(index_pos, index_neg); location_handler.ignore_errors(); TestHandler test_handler(data_source); std::cerr << "Pass 2...\n"; osmium::io::Reader reader2(input_filename); osmium::apply(reader2, location_handler, test_handler, collector.handler([&test_handler](const osmium::memory::Buffer& area_buffer) { osmium::apply(area_buffer, test_handler); })); reader2.close(); std::cerr << "Pass 2 done\n"; OGRDataSource::DestroyDataSource(data_source); OGRCleanupAll(); }
int main(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << " INFILE\n"; exit(1); } std::string output_format("SQLite"); std::string input_filename(argv[1]); std::string output_filename("testdata-overview.db"); ::unlink(output_filename.c_str()); osmium::io::Reader reader(input_filename); index_type index; location_handler_type location_handler(index); location_handler.ignore_errors(); TestOverviewHandler handler(output_format, output_filename); osmium::apply(reader, location_handler, handler); reader.close(); }
int main(int argc, char** argv) { if (argc != 3) { std::cerr << "Usage: urdf_to_collada input.urdf output.dae" << std::endl; return -1; } ros::init(argc, argv, "urdf_to_collada"); std::string input_filename(argv[1]); std::string output_filename(argv[2]); urdf::Model robot_model; if( !robot_model.initFile(input_filename) ) { ROS_ERROR("failed to open urdf file %s",input_filename.c_str()); } collada_urdf::WriteUrdfModelToColladaFile(robot_model, output_filename); std::cout << std::endl << "Document successfully written to " << output_filename << std::endl; return 0; }
void dot_graph(const binspector_analyzer_t::structure_map_t& struct_map, const std::string& starting_struct, const boost::filesystem::path& output_root) { boost::filesystem::path output_filename(output_root / "graph.gv"); boost::filesystem::ofstream output(output_filename); dot_graph_t graph; assert (output); graph.name_m = "G"; graph.type_m = "digraph"; //graph.setting_vector_m.push_back("node [shape=box]"); //graph.setting_vector_m.push_back("rankdir=TB"); //graph.setting_vector_m.push_back("packMode=clust"); graph.setting_vector_m.push_back("outputMode=nodesfirst"); adobe::name_t starting_name(starting_struct.c_str()); std::string starting_id(name_map(starting_name)); dot_node_t node; node.attribute_map_m["label"] = starting_name.c_str(); node.id_m = starting_id; graph.node_vector_m.push_back(node); graph_struct(struct_map, starting_name, starting_id, binspector_analyzer_t::typedef_map_t(), 0, graph); format_graph(graph, output); std::cerr << "File written to " << output_filename.string() << '\n'; }
int main(int argc, char* argv[]) { static struct option long_options[] = { {"help", no_argument, 0, 'h'}, {"format", required_argument, 0, 'f'}, {0, 0, 0, 0} }; std::string output_format("SQLite"); while (true) { int c = getopt_long(argc, argv, "hf:", long_options, 0); if (c == -1) { break; } switch (c) { case 'h': print_help(); exit(0); case 'f': output_format = optarg; break; default: exit(1); } } std::string input_filename; std::string output_filename("ogr_out"); int remaining_args = argc - optind; if (remaining_args > 2) { std::cerr << "Usage: " << argv[0] << " [OPTIONS] [INFILE [OUTFILE]]" << std::endl; exit(1); } else if (remaining_args == 2) { input_filename = argv[optind]; output_filename = argv[optind+1]; } else if (remaining_args == 1) { input_filename = argv[optind]; } else { input_filename = "-"; } index_type index_pos; location_handler_type location_handler(index_pos); osmium::experimental::FlexReader<location_handler_type> exr(input_filename, location_handler, osmium::osm_entity_bits::object); MyOGRHandler ogr_handler(output_format, output_filename); while (auto buffer = exr.read()) { osmium::apply(buffer, ogr_handler); } exr.close(); std::vector<const osmium::Relation*> incomplete_relations = exr.collector().get_incomplete_relations(); if (!incomplete_relations.empty()) { std::cerr << "Warning! Some member ways missing for these multipolygon relations:"; for (const auto* relation : incomplete_relations) { std::cerr << " " << relation->id(); } std::cerr << "\n"; } google::protobuf::ShutdownProtobufLibrary(); }
po::variables_map ParseCommandLineOptions(int argc, char* argv[]) {/*{{{*/ //////////////////////////////////////////////////////////////////////////////// //{{{ record command line options string output_filename("EnsNVeBath"); string command_opt(""); for(int i=1; i<argc; ++i) command_opt += argv[i]; cout << "Command line options recieved: " << command_opt << endl; output_filename += command_opt; //}}} //////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////// //{{{ Set path char *env_path = std::getenv("CCE_PROJ_PATH"); if(env_path!=NULL) { PROJECT_PATH = env_path; cout << "PROJECT_PATH got from environment varialbe: "; } else { char pwd[500]; getcwd(pwd, sizeof(pwd)); PROJECT_PATH = pwd; cout << "PROJECT_PATH set as present working directory (pwd): "; } cout << PROJECT_PATH << endl; LOG_PATH = PROJECT_PATH + "/dat/log/"; INPUT_PATH = PROJECT_PATH + "/dat/input/"; OUTPUT_PATH = PROJECT_PATH + "/dat/output/"; CONFIG_PATH = PROJECT_PATH + "/dat/config/"; DEBUG_PATH = PROJECT_PATH + "/dat/debug/"; //}}} //////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////// //{{{ Parse command line options po::variables_map para; po::options_description desc("Allowed options"); desc.add_options() ("help,h", "Print help message") ("input,i", po::value<string>()->default_value("None"), "Input file name (not used)") ("output,o", po::value<string>()->default_value(output_filename), "Output .mat file of results") ("logfile,l", po::value<string>()->default_value("EnsembleCCE.conf"), "Config. file of logging") ("position,P", po::value<string>()->default_value("0.0 0.0 0.0"), "Central spin position") ("state0,a", po::value<int>()->default_value(0), "Central spin state index - a") ("state1,b", po::value<int>()->default_value(1), "Central spin state index - b") ("cce,c", po::value<int>()->default_value(3), "CCE order") ("cutoff,d", po::value<double>()->default_value(300.0), "Cut-off distance of bath spins") ("polarization,z", po::value<string>()->default_value("0.0 0.0 0.0"), "bath spin polarization") ("dephasing_rate,r", po::value<double>()->default_value(10000.0), "dephasing rate of bath spins") ("dephasing_axis,x", po::value<string>()->default_value("1.0 1.0 1.0"), "dephasing axis of bath spins") ("length,L", po::value<double>()->default_value(3.57), "size of unit cell in angstrom (default diamond)") ("num_cell,u", po::value<int>()->default_value(8), "atom num in unit cell (default diamond)") ("concentration,C", po::value<double>()->default_value(1.0), "bath concentration in ppm") ("max_number,M", po::value<int>()->default_value(2000), "Max bath spin number") ("number,N", po::value<int>()->default_value(100), "bath spin number") ("seed,D", po::value<int>()->default_value(1), "bath seed") ("isotope", po::value<string>()->default_value("E"), "bath spin isotope") ("nTime,n", po::value<int>()->default_value(101), "Number of time points") ("start,s", po::value<double>()->default_value(0.0), "Start time (in unit of sec.)") ("finish,f", po::value<double>()->default_value(0.0002), "Finish time (in unit of sec.)") ("magnetic_field,B", po::value<string>()->default_value("0.1 0.1 0.1"), "magnetic field vector in Tesla") ("pulse,p", po::value<string>()->default_value("CPMG"), "Pulse name") ("pulse_num,m", po::value<int>()->default_value(1), "Pulse number") ; po::store(parse_command_line(argc, argv, desc), para); ifstream ifs("config.cfg"); if (ifs!=NULL) po::store(parse_config_file(ifs,desc),para); else cout << "No configure file found." << endl; po::notify(para); PrintVariableMap(para); if (para.count("help")) { cout << desc; exit(0); } //}}} //////////////////////////////////////////////////////////////////////////////// return para; }/*}}}*/
int export_png_rgb_16(image *i, output *output) { const char *fn; int shouldclose; png_structp png_ptr; png_infop info_ptr; png_uint_32 n, x, y, pi; pixelref src; colour rgb; png_bytep pp; uint16_t *bp; FILE *fp; pixel_converter_fn converter; converter = convert_pixels(i->format, PF_RGB, 16); if(!converter) { fprintf(stderr, "cannot locate a suitable format converter for RGB-16\n"); return -1; } fn = output_filename(output, i, &shouldclose); fp = fopen(fn, "wb"); if(!fp) { return -1; } png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); if(!png_ptr) { return -1; } info_ptr = png_create_info_struct(png_ptr); if(!info_ptr) { return -1; } png_init_io(png_ptr, fp); png_set_IHDR(png_ptr, info_ptr, i->width, i->height, 16, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); png_write_info(png_ptr, info_ptr); pp = (png_bytep) malloc(i->width * 3 * sizeof(uint16_t)); bp = (uint16_t *) pp; src.pixel[0] = i->pixels[0]; src.pixel[1] = i->pixels[1]; src.pixel[2] = i->pixels[2]; for(y = 0, pi = 0; y < i->height; y++) { for(n = 0, x = 0; x < i->width; x++, pi++) { converter(src, &rgb); src.pixel[0]++; src.pixel[1]++; src.pixel[2]++; bp[n] = htons(rgb.p.rgb.r); n++; bp[n] = htons(rgb.p.rgb.g); n++; bp[n] = htons(rgb.p.rgb.b); n++; } png_write_row(png_ptr, pp); } png_write_end(png_ptr, NULL); free(pp); fclose(fp); png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); png_destroy_write_struct(&png_ptr, NULL); return 0; }
int main(int argc, char **argv) { try { TCLAP::CmdLine cmd("Clips elements based on a hyperplane", ' ', "1.0"); TCLAP::ValueArg<std::string> log_filename("l","logfile", "Log file name (default is convert.log)", false, "convert.log", "string"); cmd.add( log_filename ); TCLAP::ValueArg<std::string> input_filetype("","inputtype", "Input file type. Can be\nauto - ViennaMesh automatically detects the file format (default)\nvtk - for VTK files\nmesh - for Netgen .mesh files\npoly - for Tetgen .poly files\ndeva - for GTS deva files", false, "auto", "string"); cmd.add( input_filetype ); TCLAP::ValueArg<std::string> output_filetype("","outputtype", "Output file type. Can be\nauto - ViennaMesh automatically detects the file format (default)\nvtk - for VTK files\nvmesh - for Vienna vmesh files", false, "auto", "string"); cmd.add( output_filetype ); TCLAP::ValueArg<std::string> hyperplane_point_string("p","hyperplane_point", "Point of the clip hyperplane", true, "", "string"); cmd.add( hyperplane_point_string ); TCLAP::ValueArg<std::string> hyperplane_normal_string("n","hyperplane_normal", "Normal vector of the clip hyperplane", true, "", "string"); cmd.add( hyperplane_normal_string ); TCLAP::UnlabeledValueArg<std::string> input_filename( "input-filename", "Input file name", true, "", "InputFile" ); cmd.add( input_filename ); TCLAP::UnlabeledValueArg<std::string> output_filename( "output-filename", "Output file name", true, "", "OutputFile" ); cmd.add( output_filename ); cmd.parse( argc, argv ); viennamesh::logger().register_callback( new viennamesh::FileStreamCallback<viennamesh::FileStreamFormater>( log_filename.getValue() ) ); viennamesh::algorithm_handle reader( new viennamesh::io::mesh_reader() ); reader->set_input( "filename", input_filename.getValue() ); if (input_filetype.isSet() && (input_filetype.getValue() != "auto")) reader->set_input( "file_type", input_filetype.getValue() ); reader->run(); viennamesh::dynamic_point hyperplane_point = viennamesh::dynamic_point_from_string( hyperplane_point_string.getValue() ); viennamesh::dynamic_point hyperplane_normal = viennamesh::dynamic_point_from_string( hyperplane_normal_string.getValue() ); viennamesh::algorithm_handle clip( new viennamesh::hyperplane_clip() ); clip->set_input( "mesh", reader->get_output("mesh") ); clip->set_input( "hyperplane_point", hyperplane_point ); clip->set_input( "hyperplane_normal", hyperplane_normal ); clip->run(); viennamesh::algorithm_handle writer( new viennamesh::io::mesh_writer() ); writer->set_input( "mesh", clip->get_output("mesh") ); writer->set_input( "filename", output_filename.getValue() ); if (output_filetype.isSet() && (output_filetype.getValue() != "auto")) writer->set_input( "file_type", output_filetype.getValue() ); writer->run(); } catch (TCLAP::ArgException &e) // catch any exceptions { std::cerr << "error: " << e.error() << " for arg " << e.argId() << std::endl; } return 0; }
int main(int argc, char **argv) { try { TCLAP::CmdLine cmd("Maps/Renames segments", ' ', "1.0"); TCLAP::ValueArg<std::string> log_filename("l","logfile", "Log file name (default is convert.log)", false, "convert.log", "string"); cmd.add( log_filename ); TCLAP::ValueArg<std::string> input_filetype("","inputtype", "Input file type. Can be\nauto - ViennaMesh automatically detects the file format (default)\nvtk - for VTK files\nmesh - for Netgen .mesh files\npoly - for Tetgen .poly files\ndeva - for GTS deva files", false, "auto", "string"); cmd.add( input_filetype ); TCLAP::ValueArg<std::string> output_filetype("","outputtype", "Output file type. Can be\nauto - ViennaMesh automatically detects the file format (default)\nvtk - for VTK files\nvmesh - for Vienna vmesh files", false, "auto", "string"); cmd.add( output_filetype ); TCLAP::ValueArg<std::string> segment_mapping_string("m","segment-mapping", "Segment mapping. Syntax: \"src_id,dst_id;src_id,dst_id\"", true, "", "string"); cmd.add( segment_mapping_string ); TCLAP::UnlabeledValueArg<std::string> input_filename( "input-filename", "Input file name", true, "", "InputFile" ); cmd.add( input_filename ); TCLAP::UnlabeledValueArg<std::string> output_filename( "output-filename", "Output file name", true, "", "OutputFile" ); cmd.add( output_filename ); cmd.parse( argc, argv ); viennamesh::logger().register_callback( new viennamesh::FileStreamCallback<viennamesh::FileStreamFormater>( log_filename.getValue() ) ); viennamesh::algorithm_handle reader( new viennamesh::io::mesh_reader() ); reader->set_input( "filename", input_filename.getValue() ); if (input_filetype.isSet() && (input_filetype.getValue() != "auto")) reader->set_input( "file_type", input_filetype.getValue() ); reader->run(); std::map<int, int> segment_mapping; std::list<std::string> split_mappings = stringtools::split_string( segment_mapping_string.getValue(), ";" ); for (std::list<std::string>::const_iterator mit = split_mappings.begin(); mit != split_mappings.end(); ++mit) { std::list<std::string> from_to = stringtools::split_string( *mit, "," ); std::list<std::string>::const_iterator it = from_to.begin(); if (it == from_to.end()) continue; int src_segment_id = lexical_cast<int>(*it); ++it; if (it == from_to.end()) continue; int dst_segment_id = lexical_cast<int>(*it); segment_mapping[src_segment_id] = dst_segment_id; } viennamesh::algorithm_handle map_segments( new viennamesh::map_segments() ); map_segments->set_input( "mesh", reader->get_output("mesh") ); map_segments->set_input( "segment_mapping", segment_mapping ); map_segments->run(); viennamesh::algorithm_handle writer( new viennamesh::io::mesh_writer() ); writer->set_input( "mesh", map_segments->get_output("mesh") ); writer->set_input( "quantities", reader->get_output("quantities") ); writer->set_input( "filename", output_filename.getValue() ); if (output_filetype.isSet() && (output_filetype.getValue() != "auto")) writer->set_input( "file_type", output_filetype.getValue() ); writer->run(); } catch (TCLAP::ArgException &e) // catch any exceptions { std::cerr << "error: " << e.error() << " for arg " << e.argId() << std::endl; } return 0; }
int main() { //std::vector<int> items = {1,2,3,4,5,6,7,8,9,10}; std::string filename("sampleEmbedding_200.txt"); //std::string filename("iris.data"); std::vector< std::vector<double> > items = load_data(filename); // generate similarity matrix unsigned int size = items.size(); Eigen::MatrixXd m = Eigen::MatrixXd::Zero(size,size); std::cout << "------------" << std::endl; for (unsigned int i=0; i < size; i++) { for (unsigned int j=0; j < size; j++) { // generate similarity //int d = items[i] - items[j]; double d = eculidean_distance(items[i], items[j]); int similarity = exp(-d*d / 1); m(i,j) = similarity; m(j,i) = similarity; } } // the number of eigenvectors to consider. This should be near (but greater) than the number of clusters you expect. Fewer dimensions will speed up the clustering int numDims = size; // do eigenvalue decomposition SpectralClustering* c = new SpectralClustering(m, numDims); // whether to use auto-tuning spectral clustering or kmeans spectral clustering bool autotune = false; std::vector<std::vector<int> > clusters; if (autotune) { // auto-tuning clustering clusters = c->clusterRotate(); } else { // how many clusters you want int numClusters = 10; clusters = c->clusterKmeans(numClusters); } // output clustered items // items are ordered according to distance from cluster centre for (unsigned int i=0; i < clusters.size(); i++) { std::cout << "Cluster " << i << ": " << "Item "; std::copy(clusters[i].begin(), clusters[i].end(), std::ostream_iterator<int>(std::cout, ", ")); std::cout << std::endl; } std::map<int, int> sampleid_to_clusterid; for (unsigned int i = 0; i < clusters.size(); i++) { for (unsigned int j = 0; j < clusters[i].size(); j++){ sampleid_to_clusterid.insert(std::make_pair(clusters[i][j], i)); } } std::string output_filename("sample_assignment.txt"); std::ofstream out(output_filename.c_str(), std::ios::out); if(!out) { std::cerr << "Can't open output file " << output_filename << std::endl; return 0; } std::map<int, int>::iterator it; for(it = sampleid_to_clusterid.begin(); it != sampleid_to_clusterid.end(); it++) { out << it->second << std::endl; } out.close(); }
void motion_output(long *imos, ///< index of model stage (I) long *imsn, ///< index of m.s. node on current model stage (I) double *ts, ///< time at m.s. node (I) double *te, ///< time at end of m.s. interval (I) double *sd, ///< differential states at m.s. node (I) double *sa, ///< algebraic states at m.s. node (I) double *u, ///< controls at m.s. node (I) double *udot, ///< control slopes at m.s. node (I) double *ue, ///< controls at end of m.s. interval (I) double *uedot, ///< control slopes at end of m.s. interval (I) double *p_free, ///< global model parameters (I) double *pr, ///< local i.p.c. parameters (I) double *ccxd, double *mul_ccxd, ///< multipliers of continuity conditions (I) #if defined(PRSQP) || defined(EXTPRSQP) double *ares, double *mul_ares, #endif double *rd, double *mul_rd, ///< multipliers of decoupled i.p.c. (I) double *rc, double *mul_rc, ///< multipliers of coupled i.p.c. (I) double *obj, double *rwh, ///< real work array (I) long *iwh ///< integer work array (I) ) { FILE *fp; stringstream output_filename(""); // Filename char problemname[50]; get_pname(problemname); output_filename << "./RES/" << problemname <<".mot"; if ((*imsn == 0) && (*imos == 0)) fp = fopen(output_filename.str().c_str(), "w"); else fp = fopen(output_filename.str().c_str(), "a"); if (!fp) { fprintf(stderr, "Error: Could not open file '%s'!\n", output_filename.str().c_str()); return; } /* Create and reset file when we're in the first MS-knot. * otherwise just append data */ if ((*imsn == 0) && (*imos == 0)) { // write header: /// Get names of model quantities. char **xd_name[1]; /* differential state names (O) */ char **xa_name[1]; /* algebraic state names (O) */ char **u_name[1]; /* control names (O) */ char **h_name[1]; /* model stage duration names (O) */ char **p_name[1]; /* global model parameter names (O) */ char *of_name[1]; /* objective name (O) */ get_names(xd_name, xa_name, u_name, h_name, p_name, of_name); // Objective: fprintf(fp, "COT: %e\n", *obj); // Print parameters first: fprintf(fp, "//"); for (int i = 0; i<NPFree; i++){ fprintf(fp, "%s\t",p_name[0][i]); } fprintf(fp, "\n"); for (int i = 0; i<NPFree; i++){ fprintf(fp, "%e\t",p_free[i]); } fprintf(fp, "\n"); // States and timing: fprintf(fp, "//imos\t"); fprintf(fp, "imsn\t"); fprintf(fp, "time\t"); for (int i = 0; i<NY; i++){ fprintf(fp, "%s\t",xd_name[0][i]); } for (int i = 0; i<NU; i++){ fprintf(fp, "%s\t",u_name[0][i]); } fprintf(fp, "\n"); } fprintf(fp, "%li\t", *imos); fprintf(fp, "%li\t", *imsn); fprintf(fp, "%e\t", *ts); for (int i = 0; i<NY; i++){ fprintf(fp, "%e\t",sd[i]); } for (int i = 0; i<NU; i++){ fprintf(fp, "%e\t",u[i]); } fprintf(fp, "\n"); // Close file fclose(fp); }
int main(int argc, char** argv) { // abort if the user didn't pass the correct number of command line args if (argc != 4) { fprintf ( stderr, "Error! Invalid command line arguments.\n" "Usage: %s [initial_grid.png] [output_pattern] [iterations]\n", argv[0] ); return -1; } else if (argc > 4) { fprintf ( stderr, "Warning! Ignoring all but the first 3 command line arguments\n" "Usage: %s [initial_grid.png] [output_pattern] [iterations]\n", argv[0] ); } // detect the number of iterations unsigned iterations = atoi(argv[3]); if (iterations < 1) { fprintf(stderr, "Error! Iteration count must be at least 1\n"); return -1; } unsigned width; unsigned height; // double buffered cell memory. // cell_grid_read is NULL to tell pngrw_read_file() to allocate new memory for us unsigned char* cell_grid_read = NULL; unsigned char* cell_grid_write; // attempt to load the inital cell grid. cell_grid_read will be allocated unsigned bytes = pngrw_read_file(&cell_grid_read, &width, &height, argv[1]); if (bytes == 0) // error messages printed from inside pngrw_read_file() return -1; if (width < 1) { fprintf(stderr, "Error! %s must have a width >= 1\n", argv[1]); delete[] cell_grid_read; return -1; } if (height < 1) { fprintf(stderr, "Error! %s must have a height >= 1\n", argv[1]); delete[] cell_grid_read; return -1; } // we're double buffering, pngrw_read_file only allocated the input buffer cell_grid_write = new unsigned char[bytes]; // need to init to 0 so valgrind won't complain (it can't track single-bit initializations) memset(cell_grid_write, 0, bytes); // simulate the cell grid for 'iterations' steps output_filename_t output_filename(argv[2], iterations); double start = get_timestamp(); for (unsigned ix = 0; ix < iterations; ix++) { // simulate one time step (generation) recalculate_grid_cpu(cell_grid_write, cell_grid_read, width, height); // write the new cell grid to a png file pngrw_write_file ( output_filename.str, cell_grid_write, width, height ); output_filename.next_filename(); // swap buffers unsigned char* swap = cell_grid_read; cell_grid_read = cell_grid_write; cell_grid_write = swap; } double elapsed_sec = get_timestamp() - start; // cleanup delete[] cell_grid_read; delete[] cell_grid_write; printf ( "Success! Finished %s ~ %u iterations in %lf seconds ~ %lf cells/sec\n", argv[1], iterations, elapsed_sec, ((double)width * (double)height * (double)iterations) / elapsed_sec ); return 0; }
int main(int argc, char *argv[]) { int iOS = 0; char *pInputFile = NULL; char *pOutputFile = NULL; /* Figure out arguments. * [REQUIRED] First argument is input file. * [OPTIONAL] Second argument is output file. */ if(argc > 1) { FILE *pInputStream = NULL; FILE *pOutputStream = NULL; /* Form respective filenames. */ pInputFile = input_filename(argv[1]); pOutputFile = output_filename(pInputFile, argc > 2 ? argv[2] : NULL); if(pInputFile == NULL) { fprintf(stderr, "MANTOMAK: Unable to form input filename\n"); iOS = 1; } else { pInputStream = fopen(pInputFile, "rb"); if(pInputStream == NULL) { fprintf(stderr, "MANTOMAK: Unable to open input file %s\n", pInputFile); iOS = 1; } } if(pOutputFile == NULL) { fprintf(stderr, "MANTOMAK: Unable to form output filename\n"); iOS = 1; } else if(pInputStream != NULL) { pOutputStream = fopen(pOutputFile, "wt"); if(pOutputStream == NULL) { fprintf(stderr, "MANTOMAK: Unable to open output file %s\n", pOutputFile); iOS = 1; } } /* Only do the real processing if our error code is not * already set. */ if(iOS == 0) { iOS = input_to_output(pInputStream, pOutputStream); } if(pInputStream != NULL) { fclose(pInputStream); pInputStream = NULL; } if(pOutputStream != NULL) { fclose(pOutputStream); pOutputStream = NULL; } } else { help(); iOS = 1; } if(pInputFile) { free(pInputFile); pInputFile = NULL; } if(pOutputFile) { free(pOutputFile); pOutputFile = NULL; } return(iOS); }
int main(int argc, char* argv[]) { const auto& map_factory = osmium::index::MapFactory<osmium::unsigned_object_id_type, osmium::Location>::instance(); static struct option long_options[] = { {"help", no_argument, 0, 'h'}, {"format", required_argument, 0, 'f'}, {"location_store", required_argument, 0, 'l'}, {"list_location_stores", no_argument, 0, 'L'}, {0, 0, 0, 0} }; std::string output_format { "SQLite" }; std::string location_store { "sparse_mem_array" }; while (true) { int c = getopt_long(argc, argv, "hf:l:L", long_options, 0); if (c == -1) { break; } switch (c) { case 'h': print_help(); exit(0); case 'f': output_format = optarg; break; case 'l': location_store = optarg; break; case 'L': std::cout << "Available map types:\n"; for (const auto& map_type : map_factory.map_types()) { std::cout << " " << map_type << "\n"; } exit(0); default: exit(1); } } std::string input_filename; std::string output_filename("ogr_out"); int remaining_args = argc - optind; if (remaining_args > 2) { std::cerr << "Usage: " << argv[0] << " [OPTIONS] [INFILE [OUTFILE]]" << std::endl; exit(1); } else if (remaining_args == 2) { input_filename = argv[optind]; output_filename = argv[optind+1]; } else if (remaining_args == 1) { input_filename = argv[optind]; } else { input_filename = "-"; } osmium::io::Reader reader(input_filename); std::unique_ptr<index_pos_type> index_pos = map_factory.create_map(location_store); index_neg_type index_neg; location_handler_type location_handler(*index_pos, index_neg); location_handler.ignore_errors(); MyOGRHandler ogr_handler(output_format, output_filename); osmium::apply(reader, location_handler, ogr_handler); reader.close(); int locations_fd = open("locations.dump", O_WRONLY | O_CREAT, 0644); if (locations_fd < 0) { throw std::system_error(errno, std::system_category(), "Open failed"); } index_pos->dump_as_list(locations_fd); close(locations_fd); }
int main(int argc, char **argv) { try { TCLAP::CmdLine cmd("Geometrically transforms a mesh", ' ', "1.0"); TCLAP::ValueArg<std::string> log_filename("l","logfile", "Log file name (default is convert.log)", false, "convert.log", "string"); cmd.add( log_filename ); TCLAP::ValueArg<std::string> input_filetype("","inputtype", "Input file type. Can be\nauto - ViennaMesh automatically detects the file format (default)\nvtk - for VTK files\nmesh - for Netgen .mesh files\npoly - for Tetgen .poly files\ndeva - for GTS deva files", false, "auto", "string"); cmd.add( input_filetype ); TCLAP::ValueArg<std::string> output_filetype("","outputtype", "Output file type. Can be\nauto - ViennaMesh automatically detects the file format (default)\nvtk - for VTK files\nvmesh - for Vienna vmesh files", false, "auto", "string"); cmd.add( output_filetype ); TCLAP::ValueArg<std::string> matrix_string("m","matrix", "Translate matrix", false, "", "string"); cmd.add( matrix_string ); TCLAP::ValueArg<double> scale("s","scale", "Scale the mesh", false, 0.0, "double"); cmd.add( scale ); TCLAP::ValueArg<std::string> translate_string("t","translate", "Translate the mesh", false, "", "string"); cmd.add( translate_string ); TCLAP::UnlabeledValueArg<std::string> input_filename( "input-filename", "Input file name", true, "", "InputFile" ); cmd.add( input_filename ); TCLAP::UnlabeledValueArg<std::string> output_filename( "output-filename", "Output file name", true, "", "OutputFile" ); cmd.add( output_filename ); cmd.parse( argc, argv ); viennamesh::logger().register_callback( new viennamesh::FileStreamCallback<viennamesh::FileStreamFormater>( log_filename.getValue() ) ); viennamesh::algorithm_handle reader( new viennamesh::io::mesh_reader() ); reader->set_input( "filename", input_filename.getValue() ); if (input_filetype.isSet() && (input_filetype.getValue() != "auto")) reader->set_input( "file_type", input_filetype.getValue() ); reader->run(); int dimension = lexical_cast<int>(reader->get_output("mesh")->get_property("geometric_dimension").first); viennamesh::algorithm_handle transform( new viennamesh::affine_transform() ); viennamesh::dynamic_point matrix(dimension*dimension, 0.0); for (int i = 0; i < dimension; ++i) matrix[dimension*i+i] = 1.0; if ( matrix_string.isSet() ) { matrix = stringtools::vector_from_string<double>( matrix_string.getValue() ); } else if (scale.isSet()) { for (int i = 0; i < dimension*dimension; ++i) matrix[i] *= scale.getValue(); } viennamesh::dynamic_point translate( dimension, 0.0 ); if ( translate_string.isSet() ) { translate = stringtools::vector_from_string<double>( translate_string.getValue() ); } transform->set_input( "mesh", reader->get_output("mesh") ); transform->set_output( "mesh", reader->get_output("mesh") ); transform->set_input( "matrix", matrix ); transform->set_input( "translate", translate ); transform->run(); viennamesh::algorithm_handle writer( new viennamesh::io::mesh_writer() ); writer->set_input( "mesh", transform->get_output("mesh") ); writer->set_input( "quantities", reader->get_output("quantities") ); writer->set_input( "filename", output_filename.getValue() ); if (output_filetype.isSet() && (output_filetype.getValue() != "auto")) writer->set_input( "file_type", output_filetype.getValue() ); writer->run(); } catch (TCLAP::ArgException &e) // catch any exceptions { std::cerr << "error: " << e.error() << " for arg " << e.argId() << std::endl; } return 0; }
/********************************* * Output Functions *********************************/ void figureview_output(long *imos, ///< index of model stage (I) long *imsn, ///< index of m.s. node on current model stage (I) double *ts, ///< time at m.s. node (I) double *te, ///< time at end of m.s. interval (I) double *sd, ///< differential states at m.s. node (I) double *sa, ///< algebraic states at m.s. node (I) double *u, ///< controls at m.s. node (I) double *udot, ///< control slopes at m.s. node (I) double *ue, ///< controls at end of m.s. interval (I) double *uedot, ///< control slopes at end of m.s. interval (I) double *p_free, ///< global model parameters (I) double *pr, ///< local i.p.c. parameters (I) double *ccxd, double *mul_ccxd, ///< multipliers of continuity conditions (I) #if defined(PRSQP) || defined(EXTPRSQP) double *ares, double *mul_ares, #endif double *rd, double *mul_rd, ///< multipliers of decoupled i.p.c. (I) double *rc, double *mul_rc, ///< multipliers of coupled i.p.c. (I) double *obj, double *rwh, ///< real work array (I) long *iwh ///< integer work array (I) ) { FILE *fp; stringstream output_filename(""); const char* fv_header_state_names = "# Time\n" "# LowerTrunk_TX\n" "# LowerTrunk_TY\n" "# LowerTrunk_RZ\n" "# UpperLeg_R_RZ\n" "# UpperLeg_R_TY\n" "# UpperLeg_L_RZ\n" "# UpperLeg_L_TY\n" "# LowerLeg_R_RZ\n" "# LowerLeg_R_TY\n" "# LowerLeg_L_RZ\n" "# LowerLeg_L_TY\n"; // Filename output_filename << "./RES/" << figureview_file_name; /* Create and reset file when we're in the first MS-knot. * otherwise just append data */ if ((*imsn == 0) && (*imos == 0)) { fp = fopen(output_filename.str().c_str(), "w"); if (!fp) { fprintf(stderr, "Error: Could not open file '%s'!\n", output_filename.str().c_str()); return; } // Write the header of the figureview file fprintf( fp, "# JAFV Format: DOF_0 DOF_1 ... DOF_N TAG0_x TAG0_y ... TAGN_z\n"); fprintf(fp, "# Format for cal3dview:\n"); fprintf(fp, "# MODEL hopper\n"); fprintf(fp, "# SYMMETRIC_DATA\n"); fprintf(fp, "# BEGIN_FORMAT\n"); // the degrees of freedom fprintf(fp, "%s", fv_header_state_names); fprintf(fp, "# END_FORMAT\n"); // More header information fprintf( fp, "#\n#\n# Articulating biped hopper\n#\n# Variables per frame: \n#\n# %d\n#\n", 1 + NQ + 2); } else { fp = fopen(output_filename.str().c_str(), "a"); if (!fp) { fprintf(stderr, "Error: Could not open file '%s'!\n", output_filename.str().c_str()); return; } } // Write a line of data: fprintf(fp, "%e\t", *ts); fprintf(fp, "%e\t", sd[x]); fprintf(fp, "%e\t", sd[y]); fprintf(fp, "%e\t", sd[phi]); fprintf(fp, "%e\t", sd[alphaR]); fprintf(fp, "0\t"); fprintf(fp, "%e\t", sd[alphaL]); fprintf(fp, "0\t"); fprintf(fp, "0\t"); fprintf(fp, "%e\t", 1 - sd[betaR]); fprintf(fp, "0\t"); fprintf(fp, "%e\t", 1 - sd[betaL]); fprintf(fp, "\n"); // Close file fclose(fp); }