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;
}
