/** * Initializes the *params struct with the parameters provided. * * @param n_neighbors The number of nearest neighbors to be found * @param tree_depth The tree depth of the tree to be built * @param num_threads The number of threads that should be used * @param num_nXtrain_chunks The number of chunks the training data should be split into * @param platform_id The OpenCL platform that should be used * @param device_id The id of the OpenCL device that should be used * @param allowed_train_mem_percent_chunk The amount of memory (percentage) that the training data may occupy * @param allowed_test_mem_percent The amount of memory (percentage) that the test data may occupy * @param splitting_type The splitting type that can be used during the construction of the tree * @param *kernels_source_directory Pointer to string that contains the path to the OpenCL kernels * @param verbosity_level The verbosity level (0==no output, 1==more output, 2==...) * @param *params Pointer to struct that is used to store all parameters * */ void init_extern(int n_neighbors, int tree_depth, int num_threads, int num_nXtrain_chunks, int platform_id, int device_id, double allowed_train_mem_percent_chunk, double allowed_test_mem_percent, int splitting_type, char *kernels_source_directory, int verbosity_level, TREE_PARAMETERS *params) { set_default_parameters(params); params->n_neighbors = n_neighbors; params->tree_depth = tree_depth; params->num_threads = num_threads; params->n_train_chunks = num_nXtrain_chunks; params->splitting_type = splitting_type; params->kernels_source_directory = (char*) malloc((strlen(kernels_source_directory) + 10) * sizeof(char)); strcpy(params->kernels_source_directory, kernels_source_directory); params->verbosity_level = verbosity_level; params->platform_id = platform_id; params->device_id = device_id; params->allowed_train_mem_percent_chunk = allowed_train_mem_percent_chunk; params->allowed_test_mem_percent = allowed_test_mem_percent; check_parameters(params); omp_set_num_threads(params->num_threads); }
ILPSolverSCIP::ILPSolverSCIP() { call_scip(SCIPcreate, &d_scip); call_scip(SCIPincludeDefaultPlugins, d_scip); // All the nullptr's are possible User-data. call_scip(SCIPcreateProb, d_scip, "problem", nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr); call_scip(SCIPsetObjsense, d_scip, SCIP_OBJSENSE_MINIMIZE); // Needs a start objective sense. set_default_parameters(this); }
static void initialize() { constants_init(); set_default_parameters(); parse_input(); parameter_setup(); sim_init(); simple_tank_fill(); }
int carmen_hokuyo_start(int argc, char **argv) { /* initialize laser messages */ ipc_initialize_messages(); /* get laser parameters */ set_default_parameters(&hokuyo); read_parameters(argc, argv); printf("starting device\n"); hokuyo_start(&hokuyo); return 0; }
One_Class_SVM::One_Class_SVM(){ _parameters = new svm_parameter(); _training_samples = 0; _class_labels = new std::vector<double>(); _support_vectors = new std::vector<struct svm_node*>(); set_default_parameters(); trained = false; }
ILPSolverCbc::ILPSolverCbc() { // CbcModel assumes ownership over solver and deletes it in its destructor. OsiSolverInterface* solver = new OsiClpSolverInterface(); // Output should come from CBC, not from CBCs solver. solver->messageHandler()->setLogLevel(0); solver->setHintParam(OsiDoReducePrint, 1); d_model.assignSolver(solver, true); set_default_parameters(this); }
int carmen_laser_start(int argc, char **argv) { /* initialize laser messages */ ipc_initialize_messages(); /* get laser parameters */ set_default_parameters(&laser1, CARMEN_FRONT_LASER_NUM); set_default_parameters(&laser2, CARMEN_REAR_LASER_NUM); set_default_parameters(&laser3, CARMEN_LASER3_NUM); set_default_parameters(&laser4, CARMEN_LASER4_NUM); set_default_parameters(&laser5, CARMEN_LASER5_NUM); read_parameters(argc, argv); /* start lasers, and start publishing scans */ if(use_laser1) { set_laser_config_structure(&laser1, &laser1_config); sick_start_laser(&laser1); } if(use_laser2) { set_laser_config_structure(&laser2, &laser2_config); sick_start_laser(&laser2); } if(use_laser3) { set_laser_config_structure(&laser3, &laser3_config); sick_start_laser(&laser3); } if(use_laser4) { set_laser_config_structure(&laser4, &laser4_config); sick_start_laser(&laser4); } if(use_laser5) { set_laser_config_structure(&laser5, &laser5_config); sick_start_laser(&laser5); } return 0; }
/* -------------------------------------------------------------------------------- * Interface (extern): Initialize all components * -------------------------------------------------------------------------------- */ void init_extern(int n_neighbors, int tree_depth, int num_threads, int splitting_type, int verbosity_level, KD_TREE_PARAMETERS *params) { set_default_parameters(params); params->n_neighbors = n_neighbors; params->tree_depth = tree_depth; params->num_threads = num_threads; params->verbosity_level = verbosity_level; params->splitting_type = splitting_type; check_parameters(params); omp_set_num_threads(params->num_threads); }
/* -------------------------------------------------------------------------- */ int main(int argc, char **argv) { opj_decompress_parameters parameters; /* decompression parameters */ opj_image_t* image = NULL; opj_stream_t *l_stream = NULL; /* Stream */ opj_codec_t* l_codec = NULL; /* Handle to a decompressor */ opj_codestream_index_t* cstr_index = NULL; char indexfilename[OPJ_PATH_LEN]; /* index file name */ OPJ_INT32 num_images, imageno; img_fol_t img_fol; dircnt_t *dirptr = NULL; int failed = 0; OPJ_FLOAT64 t, tCumulative = 0; OPJ_UINT32 numDecompressedImages = 0; /* set decoding parameters to default values */ set_default_parameters(¶meters); /* FIXME Initialize indexfilename and img_fol */ *indexfilename = 0; /* Initialize img_fol */ memset(&img_fol,0,sizeof(img_fol_t)); /* parse input and get user encoding parameters */ if(parse_cmdline_decoder(argc, argv, ¶meters,&img_fol, indexfilename) == 1) { destroy_parameters(¶meters); return EXIT_FAILURE; } /* Initialize reading of directory */ if(img_fol.set_imgdir==1){ int it_image; num_images=get_num_images(img_fol.imgdirpath); dirptr=(dircnt_t*)malloc(sizeof(dircnt_t)); if(dirptr){ dirptr->filename_buf = (char*)malloc((size_t)num_images*OPJ_PATH_LEN*sizeof(char)); /* Stores at max 10 image file names*/ dirptr->filename = (char**) malloc((size_t)num_images*sizeof(char*)); if(!dirptr->filename_buf){ destroy_parameters(¶meters); return EXIT_FAILURE; } for(it_image=0;it_image<num_images;it_image++){ dirptr->filename[it_image] = dirptr->filename_buf + it_image*OPJ_PATH_LEN; } } if(load_images(dirptr,img_fol.imgdirpath)==1){ destroy_parameters(¶meters); return EXIT_FAILURE; } if (num_images==0){ fprintf(stdout,"Folder is empty\n"); destroy_parameters(¶meters); return EXIT_FAILURE; } }else{ num_images=1; } /*Decoding image one by one*/ for(imageno = 0; imageno < num_images ; imageno++) { fprintf(stderr,"\n"); if(img_fol.set_imgdir==1){ if (get_next_file(imageno, dirptr,&img_fol, ¶meters)) { fprintf(stderr,"skipping file...\n"); destroy_parameters(¶meters); continue; } } /* read the input file and put it in memory */ /* ---------------------------------------- */ l_stream = opj_stream_create_default_file_stream(parameters.infile,1); if (!l_stream){ fprintf(stderr, "ERROR -> failed to create the stream from the file %s\n", parameters.infile); destroy_parameters(¶meters); return EXIT_FAILURE; } /* decode the JPEG2000 stream */ /* ---------------------- */ switch(parameters.decod_format) { case J2K_CFMT: /* JPEG-2000 codestream */ { /* Get a decoder handle */ l_codec = opj_create_decompress(OPJ_CODEC_J2K); break; } case JP2_CFMT: /* JPEG 2000 compressed image data */ { /* Get a decoder handle */ l_codec = opj_create_decompress(OPJ_CODEC_JP2); break; } case JPT_CFMT: /* JPEG 2000, JPIP */ { /* Get a decoder handle */ l_codec = opj_create_decompress(OPJ_CODEC_JPT); break; } default: fprintf(stderr, "skipping file..\n"); destroy_parameters(¶meters); opj_stream_destroy(l_stream); continue; } /* catch events using our callbacks and give a local context */ opj_set_info_handler(l_codec, info_callback,00); opj_set_warning_handler(l_codec, warning_callback,00); opj_set_error_handler(l_codec, error_callback,00); t = opj_clock(); /* Setup the decoder decoding parameters using user parameters */ if ( !opj_setup_decoder(l_codec, &(parameters.core)) ){ fprintf(stderr, "ERROR -> opj_decompress: failed to setup the decoder\n"); destroy_parameters(¶meters); opj_stream_destroy(l_stream); opj_destroy_codec(l_codec); return EXIT_FAILURE; } /* Read the main header of the codestream and if necessary the JP2 boxes*/ if(! opj_read_header(l_stream, l_codec, &image)){ fprintf(stderr, "ERROR -> opj_decompress: failed to read the header\n"); destroy_parameters(¶meters); opj_stream_destroy(l_stream); opj_destroy_codec(l_codec); opj_image_destroy(image); return EXIT_FAILURE; } if (!parameters.nb_tile_to_decode) { /* Optional if you want decode the entire image */ if (!opj_set_decode_area(l_codec, image, (OPJ_INT32)parameters.DA_x0, (OPJ_INT32)parameters.DA_y0, (OPJ_INT32)parameters.DA_x1, (OPJ_INT32)parameters.DA_y1)){ fprintf(stderr, "ERROR -> opj_decompress: failed to set the decoded area\n"); destroy_parameters(¶meters); opj_stream_destroy(l_stream); opj_destroy_codec(l_codec); opj_image_destroy(image); return EXIT_FAILURE; } /* Get the decoded image */ if (!(opj_decode(l_codec, l_stream, image) && opj_end_decompress(l_codec, l_stream))) { fprintf(stderr,"ERROR -> opj_decompress: failed to decode image!\n"); destroy_parameters(¶meters); opj_destroy_codec(l_codec); opj_stream_destroy(l_stream); opj_image_destroy(image); return EXIT_FAILURE; } } else { /* It is just here to illustrate how to use the resolution after set parameters */ /*if (!opj_set_decoded_resolution_factor(l_codec, 5)) { fprintf(stderr, "ERROR -> opj_decompress: failed to set the resolution factor tile!\n"); opj_destroy_codec(l_codec); opj_stream_destroy(l_stream); opj_image_destroy(image); return EXIT_FAILURE; }*/ if (!opj_get_decoded_tile(l_codec, l_stream, image, parameters.tile_index)) { fprintf(stderr, "ERROR -> opj_decompress: failed to decode tile!\n"); destroy_parameters(¶meters); opj_destroy_codec(l_codec); opj_stream_destroy(l_stream); opj_image_destroy(image); return EXIT_FAILURE; } fprintf(stdout, "tile %d is decoded!\n\n", parameters.tile_index); } tCumulative += opj_clock() - t; numDecompressedImages++; /* Close the byte stream */ opj_stream_destroy(l_stream); if( image->color_space != OPJ_CLRSPC_SYCC && image->numcomps == 3 && image->comps[0].dx == image->comps[0].dy && image->comps[1].dx != 1 ) image->color_space = OPJ_CLRSPC_SYCC; else if (image->numcomps <= 2) image->color_space = OPJ_CLRSPC_GRAY; if(image->color_space == OPJ_CLRSPC_SYCC){ color_sycc_to_rgb(image); } else if((image->color_space == OPJ_CLRSPC_CMYK) && (parameters.cod_format != TIF_DFMT)){ color_cmyk_to_rgb(image); } else if(image->color_space == OPJ_CLRSPC_EYCC){ color_esycc_to_rgb(image); } if(image->icc_profile_buf) { #if defined(OPJ_HAVE_LIBLCMS1) || defined(OPJ_HAVE_LIBLCMS2) if(image->icc_profile_len) color_apply_icc_profile(image); else color_cielab_to_rgb(image); #endif free(image->icc_profile_buf); image->icc_profile_buf = NULL; image->icc_profile_len = 0; } /* Force output precision */ /* ---------------------- */ if (parameters.precision != NULL) { OPJ_UINT32 compno; for (compno = 0; compno < image->numcomps; ++compno) { OPJ_UINT32 precno = compno; OPJ_UINT32 prec; if (precno >= parameters.nb_precision) { precno = parameters.nb_precision - 1U; } prec = parameters.precision[precno].prec; if (prec == 0) { prec = image->comps[compno].prec; } switch (parameters.precision[precno].mode) { case OPJ_PREC_MODE_CLIP: clip_component(&(image->comps[compno]), prec); break; case OPJ_PREC_MODE_SCALE: scale_component(&(image->comps[compno]), prec); break; default: break; } } } /* Upsample components */ /* ------------------- */ if (parameters.upsample) { image = upsample_image_components(image); if (image == NULL) { fprintf(stderr, "ERROR -> opj_decompress: failed to upsample image components!\n"); destroy_parameters(¶meters); opj_destroy_codec(l_codec); return EXIT_FAILURE; } } /* Force RGB output */ /* ---------------- */ if (parameters.force_rgb) { switch (image->color_space) { case OPJ_CLRSPC_SRGB: break; case OPJ_CLRSPC_GRAY: image = convert_gray_to_rgb(image); break; default: fprintf(stderr, "ERROR -> opj_decompress: don't know how to convert image to RGB colorspace!\n"); opj_image_destroy(image); image = NULL; break; } if (image == NULL) { fprintf(stderr, "ERROR -> opj_decompress: failed to convert to RGB image!\n"); destroy_parameters(¶meters); opj_destroy_codec(l_codec); return EXIT_FAILURE; } } /* create output image */ /* ------------------- */ switch (parameters.cod_format) { case PXM_DFMT: /* PNM PGM PPM */ if (imagetopnm(image, parameters.outfile, parameters.split_pnm)) { fprintf(stderr,"[ERROR] Outfile %s not generated\n",parameters.outfile); failed = 1; } else { fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile); } break; case PGX_DFMT: /* PGX */ if(imagetopgx(image, parameters.outfile)){ fprintf(stderr,"[ERROR] Outfile %s not generated\n",parameters.outfile); failed = 1; } else { fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile); } break; case BMP_DFMT: /* BMP */ if(imagetobmp(image, parameters.outfile)){ fprintf(stderr,"[ERROR] Outfile %s not generated\n",parameters.outfile); failed = 1; } else { fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile); } break; #ifdef OPJ_HAVE_LIBTIFF case TIF_DFMT: /* TIFF */ if(imagetotif(image, parameters.outfile)){ fprintf(stderr,"[ERROR] Outfile %s not generated\n",parameters.outfile); failed = 1; } else { fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile); } break; #endif /* OPJ_HAVE_LIBTIFF */ case RAW_DFMT: /* RAW */ if(imagetoraw(image, parameters.outfile)){ fprintf(stderr,"[ERROR] Error generating raw file. Outfile %s not generated\n",parameters.outfile); failed = 1; } else { fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile); } break; case RAWL_DFMT: /* RAWL */ if(imagetorawl(image, parameters.outfile)){ fprintf(stderr,"[ERROR] Error generating rawl file. Outfile %s not generated\n",parameters.outfile); failed = 1; } else { fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile); } break; case TGA_DFMT: /* TGA */ if(imagetotga(image, parameters.outfile)){ fprintf(stderr,"[ERROR] Error generating tga file. Outfile %s not generated\n",parameters.outfile); failed = 1; } else { fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile); } break; #ifdef OPJ_HAVE_LIBPNG case PNG_DFMT: /* PNG */ if(imagetopng(image, parameters.outfile)){ fprintf(stderr,"[ERROR] Error generating png file. Outfile %s not generated\n",parameters.outfile); failed = 1; } else { fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile); } break; #endif /* OPJ_HAVE_LIBPNG */ /* Can happen if output file is TIFF or PNG * and OPJ_HAVE_LIBTIF or OPJ_HAVE_LIBPNG is undefined */ default: fprintf(stderr,"[ERROR] Outfile %s not generated\n",parameters.outfile); failed = 1; } /* free remaining structures */ if (l_codec) { opj_destroy_codec(l_codec); } /* free image data structure */ opj_image_destroy(image); /* destroy the codestream index */ opj_destroy_cstr_index(&cstr_index); if(failed) remove(parameters.outfile); } destroy_parameters(¶meters); if (numDecompressedImages) { fprintf(stdout, "decode time: %d ms\n", (int)( (tCumulative * 1000.0) / (OPJ_FLOAT64)numDecompressedImages)); } return failed ? EXIT_FAILURE : EXIT_SUCCESS; }
void try_one_parameter(int method, char seq_name[], float sparse_penalty, float lambda_min, float lambda_max, int normalization_method, float lambda_in_normalization, bool save_intermediate_results) { int i, j, k; COpt *opt; char simple_result_filename[200]; char result_filename[200]; char intermediate_result_filename[200]; char input_data_filename[200]; int tmp_pop_size = 100; float para[4]; for (k=1; k<=20; k++){ // STEP 1: create new COpt opt = create_new_copt(method); // STEP 2: set up FCM opt->fcm = new CFcm(); sprintf(input_data_filename, "%s.txt", seq_name); opt->fcm->lambda_in_normalization = lambda_in_normalization; opt->fcm->read_problem_from_file(input_data_filename); opt->fcm->normalize_data_seq(normalization_method); // STEP 3: set parameters set_default_parameters(method, para); opt->set_parameters(para); opt->pop_size = tmp_pop_size; opt->max_iter = 0;//15000*100/(opt->pop_size); opt->seed = k*100; if (sparse_penalty != 0) opt->use_sparse = true; else opt->use_sparse = false; opt->sparse_penalty = sparse_penalty; sprintf(simple_result_filename, "result-s-%s-para1-np%d-sp%0.2f-%s-norm%d-lam%1.1f-%1.1f-%1.2f.txt", opt->method_name, tmp_pop_size, sparse_penalty, seq_name, normalization_method, lambda_min, lambda_max, lambda_in_normalization); sprintf(result_filename, "result-%s-para1-np%d-sp%0.2f-%s-norm%d-lam%1.1f-%1.1f-%1.2f.txt", opt->method_name, tmp_pop_size, sparse_penalty, seq_name, normalization_method, lambda_min, lambda_max, lambda_in_normalization); // STEP 4: allocate memory opt->allocate_memory(); opt->save_intermediate_results=save_intermediate_results; if (save_intermediate_results==true) opt->init_intermediate_result(); // STEP 5: modify settings opt->solution_lowerbound[ opt->fcm->n_nodes ] = lambda_min; opt->solution_upperbound[ opt->fcm->n_nodes ] = lambda_max; opt->solution_range[ opt->fcm->n_nodes ] = lambda_max - lambda_min; // STEP 6: run the algorithm opt->run_decomposed(); // STEP 7: write the results and release the memory opt->write_result(result_filename); opt->write_simple_result(simple_result_filename, false); if (save_intermediate_results==true){ sprintf(intermediate_result_filename, "result-intermediate-%s-para1-np%d-sp%0.2f-%s-norm%d-lam%1.1f-%1.1f-%1.2f.txt", opt->method_name, tmp_pop_size, sparse_penalty, seq_name, normalization_method, lambda_min, lambda_max, lambda_in_normalization); opt->write_intermediate_result_to_file(intermediate_result_filename); opt->free_intermediate_result(); } delete opt->fcm; opt->release_memory(); delete opt; } opt->write_simple_result(simple_result_filename, true); }
void try_diff_parameters(int method, char seq_name[]) { int i, j, k; COpt *opt; char simple_result_filename[200]; char result_filename[200]; char input_data_filename[200]; float tmp_sparse_penalty = 0.0; int tmp_pop_size = 100; float para[4]; set_default_parameters(method, para); for (i=1; i<=9; i++){ for (j=1; j<=9; j++){ para[0] = (float)i/10.0; para[1] = (float)j/10.0; for (k=1; k<=10; k++){ // STEP 1: create new COpt opt = create_new_copt(method); // STEP 2: set up FCM // srand(k); // opt->fcm = new CFcm(n_nodes, density, lambda, n_seq, n_seq*n_len_per_seq, tmp_noise_level); opt->fcm = new CFcm(); sprintf(input_data_filename, "%s.txt", seq_name); opt->fcm->read_problem_from_file(input_data_filename); // STEP 3: set parameters // set_default_parameters(method, para); opt->set_parameters(para); opt->pop_size = tmp_pop_size; opt->max_iter = 15000*100/(opt->pop_size); opt->seed = k*100; opt->use_sparse = false; opt->sparse_penalty = tmp_sparse_penalty; sprintf(simple_result_filename, "result-s-%s-diffpara-np%d-sp%0.2f-%s.txt", opt->method_name, tmp_pop_size, tmp_sparse_penalty, seq_name); sprintf(result_filename, "result-%s-diffpara-np%d-sp%0.2f-%s.txt", opt->method_name, tmp_pop_size, tmp_sparse_penalty, seq_name); // STEP 4: allocate memory opt->allocate_memory(); // STEP 5: modify settings opt->solution_lowerbound[ opt->fcm->n_nodes ] = 5.0; opt->solution_upperbound[ opt->fcm->n_nodes ] = 5.0; opt->solution_range[ opt->fcm->n_nodes ] = 0.0; // STEP 6: run the algorithm opt->run_decomposed(); // STEP 7: write the results and release the memory opt->write_result(result_filename); opt->write_simple_result(simple_result_filename, false); delete opt->fcm; opt->release_memory(); delete opt; } opt->write_simple_result(simple_result_filename, true); } } }
void try_diff_parameters(int method, char seq_name[], float sparse_penalty, float lambda_min, float lambda_max, int normalization_method) { int i, j, k; COpt *opt; char simple_result_filename[200]; char result_filename[200]; char input_data_filename[200]; int tmp_pop_size = 100; float para[4]; set_default_parameters(method, para); for (i=1; i<=9; i++){ for (j=1; j<=9; j++){ para[0] = (float)i/10.0; //////////////////////////// Set parameters para[1] = (float)j/10.0; for (k=1; k<=20; k++){ // STEP 1: create new COpt opt = create_new_copt(method); // STEP 2: set up FCM opt->fcm = new CFcm(); sprintf(input_data_filename, "%s.txt", seq_name); opt->fcm->read_problem_from_file(input_data_filename); opt->fcm->normalize_data_seq(normalization_method); // STEP 3: set parameters opt->set_parameters(para); opt->pop_size = tmp_pop_size; opt->max_iter = 15000*100/(opt->pop_size); opt->seed = k*100; if (sparse_penalty != 0) opt->use_sparse = true; else opt->use_sparse = false; opt->sparse_penalty = sparse_penalty; sprintf(simple_result_filename, "result-s-%s-diffpara-np%d-sp%0.2f-%s-norm%d-lam%1.1f-%1.1f.txt", opt->method_name, tmp_pop_size, sparse_penalty, seq_name, normalization_method, lambda_min, lambda_max); sprintf(result_filename, "result-%s-diffpara-np%d-sp%0.2f-%s-norm%d-lam%1.1f-%1.1f.txt", opt->method_name, tmp_pop_size, sparse_penalty, seq_name, normalization_method, lambda_min, lambda_max); // STEP 4: allocate memory opt->allocate_memory(); // STEP 5: modify settings opt->solution_lowerbound[ opt->fcm->n_nodes ] = lambda_min; opt->solution_upperbound[ opt->fcm->n_nodes ] = lambda_max; opt->solution_range[ opt->fcm->n_nodes ] = lambda_max - lambda_min; // STEP 6: run the algorithm opt->run_decomposed(); // STEP 7: write the results and release the memory opt->write_result(result_filename); opt->write_simple_result(simple_result_filename, false); delete opt->fcm; opt->release_memory(); delete opt; } opt->write_simple_result(simple_result_filename, true); } } }