void init (void) { initialize_engine (); width = height = 550; init_model(); glEnable (GL_LINE_SMOOTH); }
/** * Program entry point */ int main(int argc, char* argv[]) { // Initialize GLUT and create a window glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_DEPTH | GLUT_RGBA); glutInitWindowSize(400, 400); glutInitWindowPosition(30,30); glutCreateWindow("Loading models from file"); // Enable Z-buffer glEnable(GL_DEPTH_TEST); // Set up perspective glMatrixMode(GL_PROJECTION); gluPerspective(45, 1, 0.5, 100); glMatrixMode(GL_MODELVIEW); // Enable basic lighting glEnable(GL_LIGHT0); glEnable(GL_COLOR_MATERIAL); glEnable(GL_LIGHTING); // Load model init_model(); // Register handlers glutDisplayFunc(display); // Run main application loop glutMainLoop(); return 0; }
int main(int const argc, char const * const * const argv) { Option opt; try { opt = parse_option(argv_to_args(argc, argv)); } catch(std::invalid_argument const &e) { std::cout << e.what(); return EXIT_FAILURE; } std::cout << "reading data..." << std::flush; Problem const Va = read_problem(opt.Va_path); Problem const Tr = read_problem(opt.Tr_path); std::cout << "done\n" << std::flush; std::cout << "initializing model..." << std::flush; Model model(Tr.nr_feature, opt.nr_factor, Tr.nr_field); init_model(model); std::cout << "done\n" << std::flush; omp_set_num_threads(static_cast<int>(opt.nr_threads)); train(Tr, Va, model, opt); omp_set_num_threads(1); if(opt.do_prediction) predict(Va, model, opt.Va_path+".out"); return EXIT_SUCCESS; }
void init (void) { width = height = 550; init_model(); init_menu (); glEnable (GL_LINE_SMOOTH); }
int main (void) { hid_t file_id; int status; detector_data *data; model *mod = NULL; double *data_stream = NULL; unsigned int *qual = NULL; /* open file -- ignore failure on this step */ status = RD_open_file(TESTDATAFILE, &file_id); if (status) return TEST_EXIT_SKIP; /* initialize data struct */ status = RD_init_data(file_id, 0, -1, &data); if (status) return TEST_EXIT_SKIP; /* get data */ status = RD_get_data(file_id, data); if (status) return TEST_EXIT_SKIP; /* close file */ status = RD_close_file(file_id); if (status) return TEST_EXIT_SKIP; /* setup flt model */ status = setup_model(MODEL_TYPE_FLT, &mod, data, FILT_NPAD, FILT_SCALE); if (status) return TEST_EXIT_SKIP; /* initialize flt model */ status = init_model(mod, data); if (status) return TEST_EXIT_SKIP; /* run flt model */ data_stream = malloc(mod->ndet*mod->nsamp*sizeof(*data_stream)); memcpy(data_stream, data->signal, mod->ndet*mod->nsamp*sizeof(*data_stream)); qual = malloc(mod->ndet*mod->nsamp*sizeof(*qual)); memcpy(qual, data->qual, mod->ndet*mod->nsamp*sizeof(*qual)); status = model_flt_calc(0, 1, mod, data_stream, qual); if (status) return EXIT_FAILURE; free(data_stream); free(qual); /* free flt model */ status = free_model(mod); if (status) return TEST_EXIT_SKIP; /* free data */ status = RD_free_data(data); if (status) return TEST_EXIT_SKIP; /* success! */ return EXIT_SUCCESS; }
void cone::gl_render(view& scene) { if (degenerate()) return; init_model(scene); clear_gl_error(); // See sphere::gl_render() for a description of the level of detail calc. double coverage = scene.pixel_coverage( pos, radius); int lod = 0; if (coverage < 0) lod = 5; else if (coverage < 10) lod = 0; else if (coverage < 30) lod = 1; else if (coverage < 90) lod = 2; else if (coverage < 250) lod = 3; else if (coverage < 450) lod = 4; else lod = 5; lod += scene.lod_adjust; if (lod < 0) lod = 0; else if (lod > 5) lod = 5; gl_matrix_stackguard guard; const double length = axis.mag(); model_world_transform( scene.gcf, vector( length, radius, radius ) ).gl_mult(); color.gl_set(opacity); if (translucent()) { gl_enable cull_face( GL_CULL_FACE); // Render the back half. glCullFace( GL_FRONT); scene.cone_model[lod].gl_render(); // Render the front half. glCullFace( GL_BACK); scene.cone_model[lod].gl_render(); } else { scene.cone_model[lod].gl_render(); } check_gl_error(); }
void sphere::gl_render( view& geometry) { if (degenerate()) return; //init_model(); init_model(geometry); // coverage is the radius of this sphere in pixels: double coverage = geometry.pixel_coverage( pos, radius); int lod = 0; if (coverage < 0) // Behind the camera, but still visible. lod = 4; else if (coverage < 30) lod = 0; else if (coverage < 100) lod = 1; else if (coverage < 500) lod = 2; else if (coverage < 5000) lod = 3; else lod = 4; lod += geometry.lod_adjust; // allow user to reduce level of detail if (lod > 5) lod = 5; else if (lod < 0) lod = 0; gl_matrix_stackguard guard; model_world_transform( geometry.gcf, get_scale() ).gl_mult(); color.gl_set(opacity); if (translucent()) { // Spheres are convex, so we don't need to sort gl_enable cull_face( GL_CULL_FACE); // Render the back half (inside) glCullFace( GL_FRONT ); geometry.sphere_model[lod].gl_render(); // Render the front half (outside) glCullFace( GL_BACK ); geometry.sphere_model[lod].gl_render(); } else { // Render a simple sphere. geometry.sphere_model[lod].gl_render(); } }
int main(int argc, char* argv[]) { if (argc != 4) { printf("usage: <twtm train file> <num topics> <output dir>\n"); return -1; } srand(time(NULL)); int num_words, num_labels; int num_topics = atoi(argv[2]); read_data(argv[1], num_words, num_labels); init_model(argv[3], num_words, num_labels, num_topics); return 0; }
int main(void) { int __retres1 ; { { init_model(); start_simulation(); } __retres1 = 0; return (__retres1); } }
void sphere::gl_pick_render( view& geometry) { if (degenerate()) return; //init_model(); init_model(geometry); gl_matrix_stackguard guard; model_world_transform( geometry.gcf, get_scale() ).gl_mult(); geometry.sphere_model[0].gl_render(); //check_gl_error(); }
void arrow::gl_render( const view& scene) { if (degenerate()) return; init_model(); color.gl_set(opacity); double hl,hw,len,sw; effective_geometry( hw, sw, len, hl, 1.0 ); int model_material_loc = mat && mat->get_shader_program() ? mat->get_shader_program()->get_uniform_location( scene, "model_material" ) : -1; // Render the shaft and the head in back to front order (the shaft is in front // of the head if axis points away from the camera) int shaft = axis.dot( scene.camera - (pos + axis * (1-hl/len)) ) < 0; for(int part=0; part<2; part++) { gl_matrix_stackguard guard; model_world_transform( scene.gcf ).gl_mult(); if (part == shaft) { glScaled( len - hl, sw, sw ); glTranslated( 0.5, 0, 0 ); if (model_material_loc >= 0) { // TODO simplify tmatrix model_mat; double s = 1.0 / std::max( len, hw ); model_mat.translate( vector((len-hl)*s*0.5,0.5,0.5) ); model_mat.scale( vector((len-hl), sw, sw)*s ); mat->get_shader_program()->set_uniform_matrix( scene, model_material_loc, model_mat ); } shaft_model.gl_render(); } else { glTranslated( len - hl, 0, 0 ); glScaled( hl, hw, hw ); if (model_material_loc >= 0) { // TODO simplify tmatrix model_mat; double s = 1.0 / std::max( len, hw ); model_mat.translate( vector((len-hl)*s,0.5,0.5) ); model_mat.scale( vector(hl, hw, hw)*s ); mat->get_shader_program()->set_uniform_matrix( scene, model_material_loc, model_mat ); } pyramid::model.gl_render(); } } }
void Model::InitFromFile(UString filePath, ModelInit initMode) { if(initMode == ModelInit::THREADED) { //try initializing in dedicated thread auto func = [](Model* model, UString filePath) { model->SetTexture(new GLTexture); Model::InitModelThreaded(model, filePath); }; std::thread t(func, this, filePath); t.detach(); } else init_model(filePath); //init unthreaded }
static void fm_places_view_init(FmPlacesView *self) { GtkTreeViewColumn* col; GtkCellRenderer* renderer; GtkTargetList* targets; GdkPixbuf* pix; guint handler; init_model(); gtk_tree_view_set_model(GTK_TREE_VIEW(self), model); g_object_unref(model); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(self), FALSE); gtk_tree_view_set_row_separator_func(GTK_TREE_VIEW(self), (GtkTreeViewRowSeparatorFunc)sep_func, NULL, NULL ); col = gtk_tree_view_column_new(); renderer = fm_cell_renderer_pixbuf_new(); handler = g_signal_connect(fm_config, "changed::pane_icon_size", G_CALLBACK(on_renderer_icon_size_changed), renderer); g_object_weak_ref(G_OBJECT(renderer), (GDestroyNotify)on_cell_renderer_pixbuf_destroy, GUINT_TO_POINTER(handler)); fm_cell_renderer_pixbuf_set_fixed_size(FM_CELL_RENDERER_PIXBUF(renderer), fm_config->pane_icon_size, fm_config->pane_icon_size); gtk_tree_view_column_pack_start( col, renderer, FALSE ); gtk_tree_view_column_set_attributes( col, renderer, "pixbuf", COL_ICON, NULL ); renderer = gtk_cell_renderer_text_new(); // g_signal_connect( renderer, "edited", G_CALLBACK(on_bookmark_edited), view ); gtk_tree_view_column_pack_start( col, renderer, TRUE ); gtk_tree_view_column_set_attributes( col, renderer, "text", COL_LABEL, NULL ); gtk_tree_view_append_column ( GTK_TREE_VIEW(self), col ); /* gtk_drag_source_set(fv->view, GDK_BUTTON1_MASK, fm_default_dnd_src_targets, N_FM_DND_SRC_DEFAULT_TARGETS, GDK_ACTION_COPY|GDK_ACTION_MOVE|GDK_ACTION_LINK|GDK_ACTION_ASK); fm_dnd_src_set_widget(fv->dnd_src, fv->view); */ gtk_drag_dest_set(self, 0, fm_default_dnd_dest_targets, N_FM_DND_DEST_DEFAULT_TARGETS, GDK_ACTION_COPY|GDK_ACTION_MOVE|GDK_ACTION_LINK|GDK_ACTION_ASK); targets = gtk_drag_dest_get_target_list((GtkWidget*)self); /* add our own targets */ gtk_target_list_add_table(targets, dnd_dest_targets, G_N_ELEMENTS(dnd_dest_targets)); self->dnd_dest = fm_dnd_dest_new((GtkWidget*)self); g_signal_connect(self->dnd_dest, "query-info", G_CALLBACK(on_dnd_dest_query_info), self); g_signal_connect(self->dnd_dest, "files_dropped", G_CALLBACK(on_dnd_dest_files_dropped), self); }
void cone::gl_pick_render(view& scene) { if (degenerate()) return; init_model(scene); size_t lod = 2; clear_gl_error(); gl_matrix_stackguard guard; const double length = axis.mag(); model_world_transform( scene.gcf, vector( length, radius, radius ) ).gl_mult(); scene.cone_model[lod].gl_render(); check_gl_error(); }
int main(void) { int __retres1 ; { { init_model(); start_simulation(); } if (! ((int )z_val == 0)) { { error(); } } else { } __retres1 = 0; return (__retres1); } }
int main (int argc, char *argv[]) { GtkWidget *window; GtkWidget *icon_view; GtkWidget *sw; gtk_init (&argc, &argv); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW (window), "Icon View"); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_container_set_border_width(GTK_CONTAINER(window), 10); gtk_widget_set_size_request(window, 350, 330); sw = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER (window), sw); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN); icon_view = gtk_icon_view_new_with_model(init_model()); gtk_container_add(GTK_CONTAINER(sw), icon_view); gtk_icon_view_set_text_column(GTK_ICON_VIEW(icon_view), COL_DISPLAY_NAME); gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(icon_view), COL_PIXBUF); gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(icon_view), GTK_SELECTION_MULTIPLE); g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL); gtk_widget_show_all(window); gtk_main(); return 0; }
static void goa_panel_accounts_model_constructed (GObject *object) { GoaPanelAccountsModel *model = GOA_PANEL_ACCOUNTS_MODEL (object); GType types[GOA_PANEL_ACCOUNTS_MODEL_N_COLUMNS]; G_STATIC_ASSERT (5 == GOA_PANEL_ACCOUNTS_MODEL_N_COLUMNS); types[0] = G_TYPE_STRING; types[1] = GOA_TYPE_OBJECT; types[2] = G_TYPE_BOOLEAN; types[3] = G_TYPE_STRING; types[4] = G_TYPE_ICON; gtk_list_store_set_column_types (GTK_LIST_STORE (model), GOA_PANEL_ACCOUNTS_MODEL_N_COLUMNS, types); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), GOA_PANEL_ACCOUNTS_MODEL_COLUMN_SORT_KEY, GTK_SORT_ASCENDING); g_signal_connect (model->client, "account-added", G_CALLBACK (on_account_added), model); g_signal_connect (model->client, "account-removed", G_CALLBACK (on_account_removed), model); g_signal_connect (model->client, "account-changed", G_CALLBACK (on_account_changed), model); init_model (model); if (G_OBJECT_CLASS (goa_panel_accounts_model_parent_class)->constructed != NULL) G_OBJECT_CLASS (goa_panel_accounts_model_parent_class)->constructed (object); }
int main( int argc, char *argv[] ) { int ret = EXIT_FAILURE; serial_port_t port; struct model *model = malloc(sizeof(struct model)); struct activity *activity = malloc(sizeof(struct activity)); model->num_theta_region = CONF_NUM_THETA_REGION; char chosen_username[NAME_LEN]; char chosen_activity[NAME_LEN]; if (prompt_activity_name(chosen_activity)) goto ERROR; if (prompt_user_name(chosen_username)) goto ERROR; strncpy(activity->name, chosen_activity, NAME_LEN); strncpy(activity->user, chosen_username, NAME_LEN); activity->name[strlen(chosen_activity)] = '\0'; activity->user[strlen(chosen_username)] = '\0'; if (init_model(model)) goto ERROR; if (init_activity(activity, model)) goto ERROR; if (check_file_exists(FILE_CONF_CALIBRATION)) goto ERROR; if (serial_port_open(CONF_SERIAL_PORT, &port)) goto ERROR; if (serial_port_configure(port)) goto ERROR; if (real_time_listen(port, activity, model)) goto ERROR; file_write_activity_code(activity->files[FILE_ACTIVITY_CODE], activity, model); ret = EXIT_SUCCESS; ERROR: serial_port_close(port); free_activity(activity); free_model(model); return ret; }
int main(void) { int count ; int __retres2 ; { { num = 0; i = 0; max_loop = 2; e ; timer = 0; P_1_pc = 0; C_1_pc = 0; count = 0; init_model(); start_simulation(); } __retres2 = 0; return (__retres2); } }
void SampleSAT::solve(SatProblem* sat, int* sample) { sat_ = sat; model = sample; if(!csmode_){ //only SampleSAT sat_->initParams(); } sat_->cpClVector(); init_model(); numRW = 0; numGW = 0; numSA = 0; step_ = 0; if(sat_->initSatCheck(model)){ stepAve += (double)step_; return; } while(step_ < ssparams_->walkmax && walk() == false); if(step_ >= ssparams_->walkmax){ printf("Walking over\n"); exit(1); } if(ssdebug == true){ if (step_ < ssparams_->walkmax) cout << "SAT!!"<< endl; else cout << "UNKNOWN""!!"<< endl; cout << "step = " << step_ << endl; cout << "numRW = " << numRW << endl; cout << "numGW = " << numGW << endl; cout << "numSA = " << numSA << endl; } stepAve += (double)step_; return; }
/** * PPU program entry point. */ int main(int argc, char** argv) { /* Get global memory pointer */ fixedgrid_t* const G = &G_GLOBAL; /* Iterators */ uint32_t k, iter; /* Start wall clock timer */ timer_start(&G->metrics.wallclock); /* Check dimensions */ if(NX % BLOCK_X != 0) { fprintf(stderr, "NX must be a multiple of %d\n", BLOCK_X); exit(1); } if(NY % BLOCK_Y != 0) { fprintf(stderr, "NY must be a multiple of %d\n", BLOCK_Y); exit(1); } if(NZ % BLOCK_Z != 0) { fprintf(stderr, "NZ must be a multiple of %d\n", BLOCK_Z); exit(1); } /* Initialize the model parameters */ init_model(G); /* Add emissions */ process_emissions(G); /* Print startup banner */ print_start_banner(G); /* Store initial concentration */ printf("Writing initial concentration data... "); write_conc(G, 0, 0); printf("done.\n"); printf("\n!!!!FIXME: Report # FPEs\n"); /* BEGIN CALCULATIONS */ for(iter=1, G->time = G->tstart; G->time < G->tend; G->time += G->dt, ++iter) { start_saprc99(G); for(k=0; k<NLOOKAT; k++) { // Copy concentration data to device CU_SAFE_CALL(cuMemcpyHtoD(G->dev_conc, &G->conc(0, 0, 0, MONITOR[k]), NX*NY*NZ*sizeof(real_t))); discretize_all_x(G, G->dt*0.5); discretize_all_y(G, G->dt*0.5); discretize_all_z(G, G->dt); discretize_all_y(G, G->dt*0.5); discretize_all_x(G, G->dt*0.5); // Copy updated concentrations back to host CU_SAFE_CALL(cuMemcpyDtoH((void*)&G->conc(0, 0, 0, MONITOR[k]), G->dev_conc_out, NX*NY*NZ*sizeof(real_t))); } update_model(G); #if WRITE_EACH_ITER == 1 write_conc(G, iter, 0); #endif printf(" After iteration %02d: Model time = %07.2f sec.\n", iter, iter*G->dt); } /* END CALCULATIONS */ /* Store concentration */ #if WRITE_EACH_ITER != 1 write_conc(G, iter-1, 0); #endif /* Show final time */ printf("\nFinal time: %f seconds.\n", (iter-1)*G->dt); timer_stop(&G->metrics.wallclock); /* Write metrics to CSV file */ write_metrics_as_csv(G, "NVidia CUDA"); /* Cleanup and exit */ CU_SAFE_CALL(cuMemFree(G->dev_conc)); CU_SAFE_CALL(cuMemFree(G->dev_wind)); CU_SAFE_CALL(cuMemFree(G->dev_diff)); CU_SAFE_CALL(cuMemFree(G->dev_buff)); CU_SAFE_CALL(cuMemFree(G->dev_conc_out)); CU_SAFE_CALL_NO_SYNC(cuCtxDetach(cu_context_global)); return 0; }
void GyroDataWidget::set_model(GyroData *model) { m_model = model; init_model(); }
void init(){ init_model(); main_menu_window_init(); }
/** * Program entry point. */ int main(int argc, char** argv) { /* Global data pointer */ fixedgrid_t* G = &G_GLOBAL; /* Iterators */ int iter; /* Start wall clock timer */ timer_start(&G->metrics.wallclock); /* Set number of processes */ G->nprocs = 1; printf("\nRunning %d thread.\n", G->nprocs); /* Initialize the model parameters */ init_model(G); /* Add emissions */ process_emissions(G); /* Print startup banner */ print_start_banner(G); /* Store initial concentration */ printf("Writing initial concentration..."); write_conc(G, 0, 0); printf(" done.\n"); /* BEGIN CALCULATIONS */ for(iter=1, G->time = G->tstart; G->time < G->tend; G->time += G->dt, ++iter) { /* Chemistry */ saprc99_chem(G); discretize_all_x(G, G->dt*0.5); discretize_all_y(G, G->dt*0.5); discretize_all_z(G, G->dt); discretize_all_y(G, G->dt*05); discretize_all_x(G, G->dt*05); /* * Could update wind field here... */ /* * Could update diffusion tensor here... */ /* * Could update environment here... */ /* Store concentration */ #if WRITE_EACH_ITER == 1 write_conc(G, iter, 0); #endif /* Indicate progress */ printf(" After iteration %02d: Model time = %07.2f sec.\n", iter, iter*G->dt); } /* END CALCULATIONS */ /* Store concentration */ #if WRITE_EACH_ITER != 1 write_conc(G, iter-1, 0); #endif /* Show final time */ printf("Final time: %f seconds.\n", (iter-1)*G->dt); timer_stop(&G->metrics.wallclock); /* Print metrics */ print_metrics(&G->metrics); /* Write metrics to CSV file */ write_metrics_as_csv(G, "Serial"); /* Cleanup and exit */ return 0; }
static int init_mixw() { model_def_t *src_mdef; float32 ***src_mixw; vector_t ***src_mean; vector_t ***src_var = NULL; vector_t ****src_fullvar = NULL; float32 ***src_tmat; model_def_t *dest_mdef; float32 ***dest_mixw; vector_t ***dest_mean; vector_t ***dest_var = NULL; vector_t ****dest_fullvar = NULL; float32 ***dest_tmat; uint32 n_mixw_src; uint32 n_mixw_dest; uint32 n_feat; uint32 tmp_n_feat; uint32 n_gau; uint32 tmp_n_gau; uint32 n_cb_src; uint32 n_cb_dest; uint32 n_state_pm; uint32 n_tmat_src; uint32 n_tmat_dest; uint32 *veclen; uint32 *tmp_veclen; uint32 m; uint32 dest_m; uint32 dest_m_base; uint32 src_m; acmod_id_t src_m_base; const char *dest_m_name; const char *dest_m_base_name; uint32 i; uint32 n_ts; uint32 n_cb; const char *ts2cbfn; E_INFO("Reading src %s\n", cmd_ln_str("-src_moddeffn")); /* read in the source model definition file */ if (model_def_read(&src_mdef, cmd_ln_str("-src_moddeffn")) != S3_SUCCESS) { return S3_ERROR; } ts2cbfn = cmd_ln_str("-src_ts2cbfn"); if (strcmp(SEMI_LABEL, ts2cbfn) == 0) { E_INFO("Generating semi-continous ts2cb mapping\n"); src_mdef->cb = semi_ts2cb(src_mdef->n_tied_state); n_ts = src_mdef->n_tied_state; n_cb = 1; } else if (strcmp(CONT_LABEL, ts2cbfn) == 0) { E_INFO("Generating continous ts2cb mapping\n"); src_mdef->cb = cont_ts2cb(src_mdef->n_tied_state); n_ts = src_mdef->n_tied_state; n_cb = src_mdef->n_tied_state; } else if (strcmp(PTM_LABEL, ts2cbfn) == 0) { E_INFO("Generating phonetically tied ts2cb mapping\n"); src_mdef->cb = ptm_ts2cb(src_mdef); n_ts = src_mdef->n_tied_state; n_cb = src_mdef->acmod_set->n_ci; } else { E_INFO("Reading src %s\n", cmd_ln_str("-src_ts2cbfn")); if (s3ts2cb_read(ts2cbfn, &src_mdef->cb, &n_ts, &n_cb) != S3_SUCCESS) { return S3_ERROR; } } E_INFO("Reading src %s\n", cmd_ln_str("-src_mixwfn")); /* read in the source mixing weight parameter file */ if (s3mixw_read(cmd_ln_str("-src_mixwfn"), &src_mixw, &n_mixw_src, &n_feat, &n_gau) != S3_SUCCESS) { return S3_ERROR; } E_INFO("Reading src %s\n", cmd_ln_str("-src_tmatfn")); if (s3tmat_read(cmd_ln_str("-src_tmatfn"), &src_tmat, &n_tmat_src, &n_state_pm) != S3_SUCCESS) { return S3_ERROR; } E_INFO("Reading src %s\n", cmd_ln_str("-src_meanfn")); if (s3gau_read(cmd_ln_str("-src_meanfn"), &src_mean, &n_cb_src, &tmp_n_feat, &tmp_n_gau, &veclen) != S3_SUCCESS) { return S3_ERROR; } if (tmp_n_feat != n_feat) { E_FATAL("src mean n_feat (== %u) != prior value (== %u)\n", tmp_n_feat, n_feat); } if (tmp_n_gau != n_gau) { E_FATAL("src mean n_gau (== %u) != prior value (== %u)\n", tmp_n_gau, n_gau); } if (n_cb_src != n_cb) { E_FATAL("src mean n_cb (== %u) is inconsistent with ts2cb mapping %u. Most probably phoneset has duplicated phones\n", n_cb_src, n_cb); } E_INFO("Reading src %s\n", cmd_ln_str("-src_varfn")); if (cmd_ln_int32("-fullvar")) { if (s3gau_read_full(cmd_ln_str("-src_varfn"), &src_fullvar, &n_cb_src, &tmp_n_feat, &tmp_n_gau, &tmp_veclen) != S3_SUCCESS) { return S3_ERROR; } } else { if (s3gau_read(cmd_ln_str("-src_varfn"), &src_var, &n_cb_src, &tmp_n_feat, &tmp_n_gau, &tmp_veclen) != S3_SUCCESS) { return S3_ERROR; } } if (tmp_n_feat != n_feat) { E_FATAL("src var n_feat (== %u) != prior value (== %u)\n", tmp_n_feat, n_feat); } if (tmp_n_gau != n_gau) { E_FATAL("src var n_gau (== %u) != prior value (== %u)\n", tmp_n_gau, n_gau); } if (n_cb_src != n_cb) { E_FATAL("src var n_cb (== %u) inconsistent w/ ts2cb mapping %u\n", n_cb_src, n_cb); } if (n_mixw_src < src_mdef->n_tied_state) { E_FATAL("Too few source mixing weights, %u, for the # of tied states, %u\n", n_mixw_src, src_mdef->n_tied_state); } for (i = 0; i < n_feat; i++) { if (veclen[i] != tmp_veclen[i]) { E_FATAL("src var veclen[%u] (== %u) != prior value (== %u)\n", i, tmp_veclen[i], veclen[i]); } } ckd_free(tmp_veclen); E_INFO("Reading dest %s\n", cmd_ln_str("-dest_moddeffn")); /* read in the destination model definition file */ if (model_def_read(&dest_mdef, cmd_ln_str("-dest_moddeffn")) < S3_SUCCESS) { return S3_ERROR; } ts2cbfn = cmd_ln_str("-dest_ts2cbfn"); if (strcmp(SEMI_LABEL, ts2cbfn) == 0) { E_INFO("Generating semi-continous ts2cb mapping\n"); dest_mdef->cb = semi_ts2cb(dest_mdef->n_tied_state); n_ts = dest_mdef->n_tied_state; n_cb = 1; } else if (strcmp(CONT_LABEL, ts2cbfn) == 0) { E_INFO("Generating continous ts2cb mapping\n"); dest_mdef->cb = cont_ts2cb(dest_mdef->n_tied_state); n_ts = dest_mdef->n_tied_state; n_cb = dest_mdef->n_tied_state; } else if (strcmp(PTM_LABEL, ts2cbfn) == 0) { E_INFO("Generating phonetically tied ts2cb mapping\n"); dest_mdef->cb = ptm_ts2cb(dest_mdef); n_ts = dest_mdef->n_tied_state; n_cb = dest_mdef->acmod_set->n_ci; } else { E_INFO("Reading dest %s\n", cmd_ln_str("-dest_ts2cbfn")); if (s3ts2cb_read(ts2cbfn, &dest_mdef->cb, &n_ts, &n_cb) != S3_SUCCESS) { return S3_ERROR; } } E_INFO("Calculating initial model parameters\n"); n_tmat_dest = dest_mdef->n_tied_tmat; tmat_dest_list = init_was_added(n_tmat_dest); E_INFO("Alloc %ux%ux%u dest tmat\n", n_tmat_dest, n_state_pm-1, n_state_pm); dest_tmat = (float32 ***)ckd_calloc_3d(n_tmat_dest, n_state_pm-1, n_state_pm, sizeof(float32)); n_mixw_dest = dest_mdef->n_tied_state; mixw_dest_list = init_was_added(n_mixw_dest); E_INFO("Alloc %ux%ux%u dest mixw\n", n_mixw_dest, n_feat, n_gau); dest_mixw = (float32 ***)ckd_calloc_3d(n_mixw_dest, n_feat, n_gau, sizeof(float32)); for (i = 0, n_cb_dest = 0; i < n_mixw_dest; i++) { if (dest_mdef->cb[i] > n_cb_dest) { n_cb_dest = dest_mdef->cb[i]; } } ++n_cb_dest; cb_dest_list = init_was_added(n_cb_dest); E_INFO("Alloc %ux%ux%u dest mean and var\n", n_cb_dest, n_feat, n_gau); dest_mean = gauden_alloc_param(n_cb_dest, n_feat, n_gau, veclen); if (src_var) dest_var = gauden_alloc_param(n_cb_dest, n_feat, n_gau, veclen); else if (src_fullvar) dest_fullvar = gauden_alloc_param_full(n_cb_dest, n_feat, n_gau, veclen); for (dest_m = 0; dest_m < dest_mdef->n_defn; dest_m++) { dest_m_name = acmod_set_id2name(dest_mdef->acmod_set, dest_m); src_m = acmod_set_name2id(src_mdef->acmod_set, dest_m_name); if (src_m == NO_ACMOD) { /* No corresponding phone model in the source set */ /* See if there is a source base phone corresponding to this destination model base phone */ dest_m_base = acmod_set_base_phone(dest_mdef->acmod_set, dest_m); dest_m_base_name = acmod_set_id2name(dest_mdef->acmod_set, dest_m_base); src_m_base = acmod_set_name2id(src_mdef->acmod_set, dest_m_base_name); if (src_m_base == NO_ACMOD) { /* No corresponding model or base model found. Use uniform distribution */ E_INFO("No source base phone %s found. Initializing %s using uniform distribution\n", dest_m_base_name, dest_m_name); if (src_tmat) { E_INFO("Uniform initialization of tmat not supported\n"); } init_uniform(dest_mixw, &dest_mdef->defn[dest_m], n_feat, n_gau); } else { /* No corresponding model, but a base model was found. Use base distribution. */ init_model(dest_mixw, dest_mean, dest_var, dest_fullvar, dest_tmat, &dest_mdef->defn[dest_m], dest_mdef->cb, dest_mdef->acmod_set, src_mixw, src_mean, src_var, src_fullvar, src_tmat, &src_mdef->defn[src_m_base], src_mdef->cb, src_mdef->acmod_set, n_feat, n_gau, n_state_pm, veclen); } } else { /* Found a corresponding model in the source set, so use source distributions to init the destination */ init_model(dest_mixw, dest_mean, dest_var, dest_fullvar, dest_tmat, &dest_mdef->defn[dest_m], dest_mdef->cb, dest_mdef->acmod_set, src_mixw, src_mean, src_var, src_fullvar, src_tmat, &src_mdef->defn[src_m], src_mdef->cb, src_mdef->acmod_set, n_feat, n_gau, n_state_pm, veclen); } } for (m = 0; m < n_mixw_dest; m++) { if (mixw_dest_list[m] == NULL) { E_WARN("Destination state %u has not been initialized!\n", m); } } for (m = 0; m < n_cb_dest; m++) { if (cb_dest_list[m] == NULL) { E_WARN("Destination cb %u has not been initialized!\n", m); } else if (cb_dest_list[m]->next != NULL) { E_WARN("dest cb %u has > 1 corresponding source cb\n", m); } } E_INFO("Writing dest %s\n", cmd_ln_str("-dest_tmatfn")); if (s3tmat_write(cmd_ln_str("-dest_tmatfn"), dest_tmat, n_tmat_dest, n_state_pm) != S3_SUCCESS) { return S3_ERROR; } E_INFO("Writing dest %s\n", cmd_ln_str("-dest_mixwfn")); if (s3mixw_write(cmd_ln_str("-dest_mixwfn"), dest_mixw, dest_mdef->n_tied_state, n_feat, n_gau) < S3_SUCCESS) { return S3_ERROR; } E_INFO("Writing dest %s\n", cmd_ln_str("-dest_meanfn")); if (s3gau_write(cmd_ln_str("-dest_meanfn"), (const vector_t ***)dest_mean, n_cb_dest, n_feat, n_gau, veclen) != S3_SUCCESS) { return S3_ERROR; } E_INFO("Writing dest %s\n", cmd_ln_str("-dest_varfn")); if (cmd_ln_int32("-fullvar")) { if (s3gau_write_full(cmd_ln_str("-dest_varfn"), (const vector_t ****)dest_fullvar, n_cb_dest, n_feat, n_gau, veclen) != S3_SUCCESS) { return S3_ERROR; } } else { if (s3gau_write(cmd_ln_str("-dest_varfn"), (const vector_t ***)dest_var, n_cb_dest, n_feat, n_gau, veclen) != S3_SUCCESS) { return S3_ERROR; } } ckd_free(veclen); return S3_SUCCESS; }
shared_ptr<ffm_model> train( ffm_problem *tr, vector<ffm_int> &order, ffm_parameter param, ffm_problem *va=nullptr) { #if defined USEOMP ffm_int old_nr_threads = omp_get_num_threads(); omp_set_num_threads(param.nr_threads); #endif shared_ptr<ffm_model> model = shared_ptr<ffm_model>(init_model(tr->n, tr->m, param), [] (ffm_model *ptr) { ffm_destroy_model(&ptr); }); vector<ffm_float> R_tr, R_va; if(param.normalization) { R_tr = normalize(*tr); if(va != nullptr) R_va = normalize(*va); } else { R_tr = vector<ffm_float>(tr->l, 1); if(va != nullptr) R_va = vector<ffm_float>(va->l, 1); } if(!param.quiet) { cout.width(4); cout << "iter"; cout.width(13); cout << "tr_logloss"; if(va != nullptr && va->l != 0) { cout.width(13); cout << "va_logloss"; } cout << endl; } for(ffm_int iter = 0; iter < param.nr_iters; iter++) { ffm_double tr_loss = 0; if(param.random) random_shuffle(order.begin(), order.end()); #if defined USEOMP #pragma omp parallel for schedule(static) reduction(+: tr_loss) #endif for(ffm_int ii = 0; ii < tr->l; ii++) { ffm_int i = order[ii]; ffm_float y = tr->Y[i]; ffm_node *begin = &tr->X[tr->P[i]]; ffm_node *end = &tr->X[tr->P[i+1]]; ffm_float r = R_tr[i]; ffm_float t = wTx(begin, end, r, *model); ffm_float expnyt = exp(-y*t); tr_loss += log(1+expnyt); ffm_float kappa = -y*expnyt/(1+expnyt); wTx(begin, end, r, *model, kappa, param.eta, param.lambda, true); } if(!param.quiet) { tr_loss /= tr->l; cout.width(4); cout << iter; cout.width(13); cout << fixed << setprecision(5) << tr_loss; if(va != nullptr && va->l != 0) { ffm_double va_loss = 0; #if defined USEOMP #pragma omp parallel for schedule(static) reduction(+:va_loss) #endif for(ffm_int i = 0; i < va->l; i++) { ffm_float y = va->Y[i]; ffm_node *begin = &va->X[va->P[i]]; ffm_node *end = &va->X[va->P[i+1]]; ffm_float r = R_va[i]; ffm_float t = wTx(begin, end, r, *model); ffm_float expnyt = exp(-y*t); va_loss += log(1+expnyt); } va_loss /= va->l; cout.width(13); cout << fixed << setprecision(5) << va_loss; } cout << endl; } } shrink_model(*model, param.k); #if defined USEOMP omp_set_num_threads(old_nr_threads); #endif return model; }
int main(int argc, char **argv){ /* initialize sdl */ if (SDL_Init(SDL_INIT_VIDEO) < 0){ perror("could not initialize sdl"); return 1; } SDL_ShowCursor(SDL_DISABLE); SDL_WM_SetCaption("simple raytracer demo", ""); SDL_Surface *screen = SDL_SetVideoMode(WIDTH, HEIGHT, BPP*8, SDL_HWSURFACE|SDL_DOUBLEBUF); if(!screen) { perror("could not set video mode"); SDL_Quit(); return 1; } /* initialize graphics state */ graphics_state state; state.screen = screen; if(init_model(&state) != 0) return -1; if(init_lights(&state) != 0) return -1; if(init_graphics(&state) != 0) return -1; if(init_worker_threads(&state) != 0) return -1; /* main loop */ int run = 1; float ema_nanos = 0, ema_nanos2 = 0, max_nanos = 0; long start_time; start_time = now(); while(run){ /* change the scene */ timestep(&state); /* render the scene */ if(draw_screen(&state)){ perror("render error"); return 1; } /* performance metrics */ state.frame++; long nanos = now()-start_time; ema_nanos = 0.9f*ema_nanos + 0.1*nanos; ema_nanos2 = 0.9f*ema_nanos2 + 0.1*nanos*nanos; if(nanos > max_nanos) max_nanos = nanos; if(state.frame % 10 == 0){ float stdev_nanos = sqrtf(ema_nanos2 - ema_nanos*ema_nanos); float fps = 1000000000 / ema_nanos; float fps_sigma = 1000000000 / (ema_nanos + stdev_nanos); float fps_worst = 1000000000 / max_nanos; printf("%.2f +/- %.2f (worst: %.2f) fps\n", fps, fps-fps_sigma, fps_worst); max_nanos = 0; } start_time = now(); int sleep_us = TARGET_US - nanos/1000; if(sleep_us > 0) usleep(sleep_us); /* check if we need to exit */ SDL_Event event; while(SDL_PollEvent(&event)) { if(event.type == SDL_QUIT || event.type == SDL_MOUSEBUTTONDOWN){ run = 0; break; } } } /* reset resolution to normal, exit */ SDL_Quit(); return 0; }
/* Add a face with the given vertices */ void add_face(int a, int b, int c) { if (faces.len == faces.capacity) { /* Double size when we run out... */ faces.capacity *= 2; faces.nodes = (face_t **)realloc(faces.nodes, sizeof(face_t *) * faces.capacity); } if (vertices.len < a || vertices.len < b || vertices.len < c) { /* Frick... */ fprintf(stderr, "ERROR: Haven't yet collected enough vertices for the face %d %d %d (have %d)!\n", a, b, c, vertices.len); exit(1); } /* Create a new triangle */ faces.nodes[faces.len] = malloc(sizeof(face_t)); faces.nodes[faces.len]->a = vertices.nodes[a-1]; faces.nodes[faces.len]->b = vertices.nodes[b-1]; faces.nodes[faces.len]->c = vertices.nodes[c-1]; /* Calculate some normals */ vertex_t u = {.x = faces.nodes[faces.len]->b->x - faces.nodes[faces.len]->a->x, .y = faces.nodes[faces.len]->b->y - faces.nodes[faces.len]->a->y, .z = faces.nodes[faces.len]->b->z - faces.nodes[faces.len]->a->z}; vertex_t v = {.x = faces.nodes[faces.len]->c->x - faces.nodes[faces.len]->a->x, .y = faces.nodes[faces.len]->c->y - faces.nodes[faces.len]->a->y, .z = faces.nodes[faces.len]->c->z - faces.nodes[faces.len]->a->z}; /* Set the face normals */ faces.nodes[faces.len]->normal.x = ((u.y * v.z) - (u.z * v.y)); faces.nodes[faces.len]->normal.y = -((u.z * v.x) - (u.x * v.z)); faces.nodes[faces.len]->normal.z = ((u.x * v.y) - (u.y * v.x)); faces.len++; } void finish_normals() { /* Loop through vertices and accumulate normals for them */ for (uint32_t i = 0; i < faces.len; ++i) { /* Vertex a */ faces.nodes[i]->a->normal.x += faces.nodes[i]->normal.x; faces.nodes[i]->a->normal.y += faces.nodes[i]->normal.y; faces.nodes[i]->a->normal.z += faces.nodes[i]->normal.z; /* Vertex b */ faces.nodes[i]->b->normal.x += faces.nodes[i]->normal.x; faces.nodes[i]->b->normal.y += faces.nodes[i]->normal.y; faces.nodes[i]->b->normal.z += faces.nodes[i]->normal.z; /* Vertex c */ faces.nodes[i]->c->normal.x += faces.nodes[i]->normal.x; faces.nodes[i]->c->normal.y += faces.nodes[i]->normal.y; faces.nodes[i]->c->normal.z += faces.nodes[i]->normal.z; } } /* Discard the rest of this line */ void toss(FILE * f) { while (fgetc(f) != '\n'); } /* Load a Wavefront Obj model */ void load_wavefront(char * filename) { /* Open the file */ FILE * obj = fopen(filename, "r"); int collected = 0; char d = ' '; /* Initialize the lists */ init_model(); while (!feof(obj)) { /* Scan in a line */ collected = fscanf(obj, "%c ", &d); if (collected == 0) continue; switch (d) { case 'v': { /* Vertex */ float x, y, z; collected = fscanf(obj, "%f %f %f\n", &x, &y, &z); if (collected < 3) fprintf(stderr, "ERROR: Only collected %d points!\n", collected); add_vertex(x, y, z); } break; case 'f': { /* Face */ int a, b, c; collected = fscanf(obj, "%d %d %d\n", &a, &b, &c); if (collected < 3) fprintf(stderr, "ERROR: Only collected %d vertices!\n", collected); add_face(a,b,c); } break; default: /* Something else that we don't care about */ toss(obj); break; } } /* Finalize the vertex normals */ finish_normals(); fclose(obj); } /* Vertex, fragment, program */ GLuint v, f, p; /* Read a file into a buffer and return a pointer to the buffer */ char * readFile(char * filename, int32_t * size) { FILE * tex; char * texture; tex = fopen(filename, "r"); fseek(tex, 0L, SEEK_END); *size = ftell(tex); texture = malloc(*size); fseek(tex, 0L, SEEK_SET); fread(texture, *size, 1, tex); fclose(tex); return texture; }
int main (int argc, char **argv) { GtkWidget *window; GtkWidget *frame; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *list; GtkWidget *scroll; GtkWidget *setts; GtkWidget *adder; GtkListStore *model; GtkCellRenderer *renderer; GtkTreeViewColumn *col; GtkTreeSelection *selection; TrackerSparqlConnection *tracker; gtk_init (&argc, &argv); g_set_application_name ("Phidias Feeds Manager"); tracker = tracker_sparql_connection_get (NULL, NULL); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10); gtk_container_add (GTK_CONTAINER (window), vbox); frame = gtk_frame_new ("Manage"); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10); gtk_container_add (GTK_CONTAINER (frame), hbox); list = gtk_tree_view_new (); renderer = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Title", renderer, "text", 1, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (list), col); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scroll), list); gtk_box_pack_start (GTK_BOX (hbox), scroll, TRUE, TRUE, 0); setts = feed_settings_new (); gtk_box_pack_start (GTK_BOX (hbox), setts, FALSE, FALSE, 0); frame = gtk_frame_new ("Add"); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); adder = feeds_adder_new (); gtk_container_add (GTK_CONTAINER (frame), adder); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (list)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); model = gtk_list_store_new (7, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_BOOLEAN); /* TODO Sort elements by name */ gtk_tree_view_set_model (GTK_TREE_VIEW (list), GTK_TREE_MODEL (model)); g_signal_connect (setts, "remove-feed", G_CALLBACK (feed_removed), tracker); g_signal_connect (setts, "save-feed", G_CALLBACK (feed_saved), tracker); g_signal_connect (setts, "update-feed", G_CALLBACK (feed_modified), model); g_signal_connect (selection, "changed", G_CALLBACK (feed_selected_cb), setts); g_signal_connect (window, "delete-event", G_CALLBACK (exit_all), setts); init_model (tracker, model); listen_tracker (model); tune_model (tracker, model); feeds_adder_wire_tracker (FEEDS_ADDER (adder), tracker); gtk_widget_show_all (window); gtk_main (); g_object_unref (tracker); exit (0); }
/** * \fn int main(int argc, char *argv[]) * \brief Fonction principale. * * * La fonction principale récupère les arguments et le fichier de configuration, * initialise la vue, le modèle, puis éxécute la boucle de calcul. * Une fois cette boucle terminée, elle libère la mémoire et finalise l'éxécution. * * */ int main(int argc, char *argv[]) { config_t *conf = parse_args(argc, argv); int error = 0; error_t *error_cell = NULL; if(conf == NULL) { return 1; } view_t *view = init_view(conf); model_t *model = init_model(conf); double delta_time = 0; event_t event; init_event(&event); vect_t chunk_pos; init_vect(&chunk_pos, 0.4, 0.4, 0.4); add_chunk(model, &chunk_pos); //add_chunk(model, &chunk_pos); //add_chunk(model, &chunk_pos); //add_chunk(model, &chunk_pos); //add_chunk(model, &chunk_pos); //add_chunk(model, &chunk_pos); while(!event.exit_wanted) { delta_time = temporize(conf); get_event(&event, view); if(event.click_callback != NULL) (*(event.click_callback))(model); error = update_model(model, &event, delta_time); if(error) { printf("ERREUR DETECTEE !\n"); error_cell = get_error_list(); int error_count = 0; while(error_cell != NULL) { printf("%s\n", error_cell->comment); error_cell = error_cell->next; error_count++; if(error_count >= 10) { printf("Appuyez sur ENTREE pour voir la suite, q puis ENTREE pour quitter.\n"); if(getchar() == 'q') return 1; error_count = 0; } } return 1; } update_view(view, model, &event); } close_conf(conf); close_view(view); close_model(model); return 0; }