/* * Try and read in the file from path as if it was a grid. * * Will exit with appropriate status if the file isn't actually a valid grid * for this game. * * On return g should be ready to play games with. */ void read_grid_file(char *path, struct game *g) { int n = 0; FILE *f; if ((f = fopen(path, "r")) == NULL) { fprintf(stderr, "Invalid grid file\n"); exit(4); } if ((g->current_player = read_num_until(f, '\n', g) - 1) < 0) { fprintf(stderr, "Error reading grid contents\n"); exit(5); } while (n != 2 * g->height + 1) { read_edges(f, n++, g); } read_filled(f, g); if (fgetc(f) != EOF) { fprintf(stderr, "Error reading grid contents\n"); exit(5); } fclose(f); }
int read_network(NETWORK *network, FILE *stream) { fill_buffer(stream); create_network(network); get_degrees(network); read_edges(network); free_buffer(); return 0; }
void dd::FactorGraph::load(const CmdParser & cmd, const bool is_quiet) { // get factor graph file names from command line arguments std::string weight_file = cmd.weight_file->getValue(); std::string variable_file = cmd.variable_file->getValue(); std::string factor_file = cmd.factor_file->getValue(); std::string edge_file = cmd.edge_file->getValue(); std::string filename_edges = edge_file; std::string filename_factors = factor_file; std::string filename_variables = variable_file; std::string filename_weights = weight_file; // load variables long long n_loaded = read_variables(filename_variables, *this); assert(n_loaded == n_var); if (!is_quiet) { std::cout << "LOADED VARIABLES: #" << n_loaded << std::endl; std::cout << " N_QUERY: #" << n_query << std::endl; std::cout << " N_EVID : #" << n_evid << std::endl; } // load factors n_loaded = read_factors(filename_factors, *this); assert(n_loaded == n_factor); if (!is_quiet) { std::cout << "LOADED FACTORS: #" << n_loaded << std::endl; } // load weights n_loaded = read_weights(filename_weights, *this); assert(n_loaded == n_weight); if (!is_quiet) { std::cout << "LOADED WEIGHTS: #" << n_loaded << std::endl; } // sort the above components // NOTE This is very important, as read_edges assume variables, // factors and weights are ordered so that their id is the index // where they are stored in the array this->sort_by_id(); // load edges n_loaded = read_edges(edge_file, *this); if (!is_quiet) { std::cout << "LOADED EDGES: #" << n_loaded << std::endl; } // construct edge-based store this->organize_graph_by_edge(); this->safety_check(); assert(this->is_usable() == true); }
/*** MAIN FUNCTION ***/ int main (int argc, char **argv) { // process the command line process_args (argc, argv); determine_limits(); // check if there is something wrong in the command if (n_nodes <= 0 || n_edges <= 0) { fprintf (stderr, "Incorrect or missing node numbers\n"); exit (1); } fprintf (stderr, "allocating edges..\n"); edges = (edge_t *) malloc(n_edges * sizeof(edge_t)); read_edges(); fprintf (stderr, "allocating nodes..\n"); nodes = (node_t *) malloc(n_nodes * sizeof(node_t)); memset (nodes, 0, n_nodes * sizeof(node_t)); for (unsigned int i=0; i < n_nodes; i++) { nodes[i].old_values = (float *) malloc (n_classes * sizeof(float)); nodes[i].new_values = (float *) malloc (n_classes * sizeof(float)); } read_labels(); for (unsigned int i=0; i < n_nodes; i++) { for (short j=0; j < n_classes; j++) { if (!nodes[i].labeled) nodes[i].old_values[j] = 1.0 / n_classes; nodes[i].new_values[j] = 0; } } // compute the influx (weighted degree) of each node for (unsigned int i=0; i < n_edges; i++) { nodes[edges[i].ids[0]].influx += edges[i].weight; nodes[edges[i].ids[1]].influx += edges[i].weight; } float max_error; do { max_error = propagate_labels(); fprintf (stderr, "error: %f\n", max_error); } while (max_error > 0.0002); output_labels(); return 0; }
bool read_data(char* inputFolder) { bool success; char* nodesPath = NULL; char* edgesPath = NULL; success = (concat_path(inputFolder, "nodes", &nodesPath) && concat_path(inputFolder, "edges", &edgesPath)); if (success) { success = success && read_nodes(nodesPath); success = success && read_edges(edgesPath); } free(nodesPath); free(edgesPath); return success; }
/* main entry point */ int main(int argc, char *argv[]) { int ret; /* init the default settings */ struct settings_t settings; settings.gpio_base = 55; settings.gpio_count = MAX_GPIO_COUNT; settings.loop = 0; settings.poll = 0; settings.poll_timeout = -1; print_info(); /* parse the cmdline arguments */ handle_parameters(argc, argv, &settings); /* initialize the gpio file names */ init_gpio_filenames(settings.gpio_base, settings.gpio_count, settings.gpio_filenames); /* read the gpios */ read_gpios(settings.gpio_count, settings.gpio_states, settings.gpio_filenames); /* print the states of the gpios */ printf("initial values:\n"); print_gpios(settings.gpio_base, settings.gpio_count, settings.gpio_states); printf("\n"); /* keep reading gpios cpu intensive in a tight loop */ if (settings.loop) enter_read_gpios_loop(settings.gpio_base, settings.gpio_count, settings.gpio_states, settings.gpio_filenames); /* poll the gpios once */ if (settings.poll) { init_gpio_edges(settings.gpio_base, settings.gpio_count, settings.gpio_edge_filenames); if (read_edges(settings.gpio_count, settings.gpio_edge_values, settings.gpio_edge_filenames)) if (validate_edges(settings.gpio_base, settings.gpio_count, settings.gpio_edge_values)) enter_poll_gpios(settings.gpio_base, settings.gpio_count, settings.poll_timeout, settings.gpio_states, settings.gpio_filenames); } }
// query4 $inputfile $datapath int main(int argc, char *argv[]){ // initialization input_file_name = argv[1]; dir_name = argv[2]; dir_name_len = (int)strlen(argv[2]); file_name_max_len = dir_name_len + 50; data_file_name = new char [file_name_max_len]; cnt_data_lines("person.csv", &personcnt); cnt_data_lines("forum.csv", &forumcnt); cnt_data_lines("tag.csv", &tagcnt); person_in_induced_graph = new char[personcnt]; #if DEBUG printf("cnt done.\n"); #endif read_edges(); convert2undirected(); #if DEBUG printf("start forums.\n"); #endif read_forums(); read_tags(); read_queries(); #if DEBUG printf("read Q done\n"); #endif // solve freopen("query4.out", "w", stdout); for (vector < pair<int, int> > :: iterator it=queries.begin(); it!=queries.end(); it++) query(it->first, it->second); fclose(stdout); free_memory(); return 0; }
int main(int argc, char **argv){ if( argc<6){ if(argc>1) fprintf(stderr,"Error, not enough arguments\n"); usage(); exit(1); } // read arguments color_image_t *im1 = color_image_load(argv[1]); color_image_t *im2 = color_image_load(argv[2]); float_image edges = read_edges(argv[3], im1->width, im1->height); float_image matches = read_matches(argv[4]); const char *outputfile = argv[5]; // prepare variables epic_params_t epic_params; epic_params_default(&epic_params); variational_params_t flow_params; variational_params_default(&flow_params); image_t *wx = image_new(im1->width, im1->height), *wy = image_new(im1->width, im1->height); // read optional arguments #define isarg(key) !strcmp(a,key) int current_arg = 6; while(current_arg < argc ){ const char* a = argv[current_arg++]; if( isarg("-h") || isarg("-help") ) usage(); else if( isarg("-nw") ) strcpy(epic_params.method, "NW"); else if( isarg("-p") || isarg("-prefnn") ) epic_params.pref_nn = atoi(argv[current_arg++]); else if( isarg("-n") || isarg("-nn") ) epic_params.nn = atoi(argv[current_arg++]); else if( isarg("-k") ) epic_params.coef_kernel = atof(argv[current_arg++]); else if( isarg("-i") || isarg("-iter") ) flow_params.niter_outer = atoi(argv[current_arg++]); else if( isarg("-a") || isarg("-alpha") ) flow_params.alpha= atof(argv[current_arg++]); else if( isarg("-g") || isarg("-gamma") ) flow_params.gamma= atof(argv[current_arg++]); else if( isarg("-d") || isarg("-delta") ) flow_params.delta= atof(argv[current_arg++]); else if( isarg("-s") || isarg("-sigma") ) flow_params.sigma= atof(argv[current_arg++]); else if( isarg("-sintel") ){ epic_params.pref_nn= 25; epic_params.nn= 160; epic_params.coef_kernel = 1.1f; flow_params.niter_outer = 5; flow_params.alpha = 1.0f; flow_params.gamma = 0.72f; flow_params.delta = 0.0f; flow_params.sigma = 1.1f; } else if( isarg("-kitti") ){ epic_params.pref_nn= 25; epic_params.nn= 160; epic_params.coef_kernel = 1.1f; flow_params.niter_outer = 2; flow_params.alpha = 1.0f; flow_params.gamma = 0.77f; flow_params.delta = 0.0f; flow_params.sigma = 1.7f; } else if( isarg("-middlebury") ){ epic_params.pref_nn= 15; epic_params.nn= 65; epic_params.coef_kernel = 0.2f; flow_params.niter_outer = 25; flow_params.alpha = 1.0f; flow_params.gamma = 0.72f; flow_params.delta = 0.0f; flow_params.sigma = 1.1f; } else{ fprintf(stderr, "unknown argument %s", a); usage(); exit(1); } } // compute interpolation and energy minimization color_image_t *imlab = rgb_to_lab(im1); epic(wx, wy, imlab, &matches, &edges, &epic_params, 1); // energy minimization variational(wx, wy, im1, im2, &flow_params); // write output file and free memory writeFlowFile(outputfile, wx, wy); color_image_delete(im1); color_image_delete(imlab); color_image_delete(im2); free(matches.pixels); free(edges.pixels); image_delete(wx); image_delete(wy); return 0; }
static void read_all_data(DATA **data, DATA *valdata, int n_vars) { int i; DATA *area; init_data_minmax(); area = get_data_area(); for (i = 0; i < n_vars; i++) { if (get_mode() == STRATIFY) printlog("stratum # %d:\n", i + strata_min); printlog("data(%s): ", name_identifier(i)); if (data[i]->id < 0) { message("data(%s) was not specified\n", name_identifier(i)); ErrMsg(ER_SYNTAX, "data specification error"); } read_gstat_data(data[i]); report_data(data[i]); } /* for i */ /* * what to do when area is specified, but no masks or data()? * default prediction to `area'. Create a valdata with one point at * centre of area (for select()); and centre area at (0,0,0) */ if (area && get_n_masks() <= 0 && valdata->id == -1) { valdata->id = ID_OF_VALDATA; valdata->centre = area->centre = 1; } /* * read data() data: */ if (valdata->id > -1) { setup_valdata_X(valdata); if (! valdata->centre) valdata = read_gstat_data(valdata); } /* * read area, if existed */ if (area != NULL && get_method() != POLY) { read_gstat_data(area); /* now, before centring area: */ if (valdata->centre) valdata = get_area_centre(area, valdata); if (area->centre) centre_area(area); printlog("area:%s\n", area->centre ? " (centred around 0)" : ""); report_data(area); if (DEBUG_DATA) print_data_list(area); } /* * read edges, if existed */ if (get_n_edges() > 0) { read_edges(); report_edges(); /* setup_visibility_graph(); */ /*setup_planar_subdivisions();*/ } /* * setup and report data */ if (valdata->id > -1) { printlog("data():%s ", valdata->centre ? " [at area centre]" : ""); report_data(valdata); } for (i = 0; i < n_vars; i++) setup_data_minmax(data[i]); if (valdata->id > -1) setup_data_minmax(valdata); for (i = 0; i < n_vars; i++) calc_polynomials(data[i]); if (valdata->id > -1) calc_polynomials(valdata); if (DEBUG_DATA) { for (i = 0; i < n_vars; i++) print_data_list(data[i]); if (valdata->id > -1) print_data_list(valdata); } }