int main(int argc, char **argv)
{
int maxprims, maxfigs, maxpts, state, namelen;
int nfigs, nprims, npts;
double angle;
struct Figure *figs;
struct NestMatrix res;
char str[2048];
int i, j;
maxfigs = 128;
namelen = 2048;
state = STATE_NEWFIG;
nfigs = nprims = npts = 0;
figs = (struct Figure*)xmalloc(sizeof(struct Figure) * maxfigs);
//printf("started writing\n");
while (fgets(str, 2048, stdin)) {
double x, y;
trim(str);
if (state == STATE_NEWFIG) {
int quant, angstep;
char name[2048];
figs[nfigs].name = (char*)xmalloc(sizeof(char) * namelen);
sscanf(str, "%s %d %d\n", figs[nfigs].name, &figs[nfigs].quant, &figs[nfigs].angstep);
sscanf(str, "%s %d %d\n", name, &quant, &angstep);
state = STATE_PRIM;
maxpts = 2048;
maxprims = 128;
figs[nfigs].prims = (struct Primitive*)xmalloc(sizeof(struct Primitive) * maxprims);
figs[nfigs].prims[nprims].pts = (struct Point*)xmalloc(sizeof(struct Point) * maxpts);
continue;
}
if (strcmp(str, FIG_SEPAR) == 0) {
state = STATE_NEWFIG;
figs[nfigs].prims[nprims].npts = npts;
nprims++;
figs[nfigs].id = nfigs;
figs[nfigs].nprims = nprims;
nfigs++;
if (nfigs == maxfigs) {
maxfigs *= 2;
figs = (struct Figure*)xrealloc(figs, sizeof(struct Figure) * maxfigs);
}
nprims = 0;
npts = 0;
continue;
}
if (strcmp(str, PRIM_SEPAR) == 0) {
figs[nfigs].prims[nprims].npts = npts;
nprims++;
if (nprims == maxprims) {
maxprims *= 2;
figs[nfigs].prims = (struct Primitive*)xrealloc(figs[nfigs].prims, sizeof(struct Primitive) * maxprims);
}
maxpts = 2048;
figs[nfigs].prims[nprims].pts = (struct Point*)xmalloc(sizeof(struct Point) * maxpts);
npts = 0;
continue;
}
sscanf(str, "%lf %lf\n", &x, &y);
figs[nfigs].prims[nprims].pts[npts].x = x;
figs[nfigs].prims[nprims].pts[npts].y = y;
npts++;
if (npts == maxpts) {
maxpts *= 2;
figs[nfigs].prims[nprims].pts = (struct Point*)xrealloc(figs[nfigs].prims[nprims].pts, sizeof(struct Point) * maxpts);
}
}
for (i = 0; i < nfigs; i++) {
figinit(&figs[i]);
}
for (angle = 0.0; angle < 360; angle += figs[0].angstep) {
rotate(&figs[0], figs[0].angstep);
res = approxfig(&figs[0], 10);
printf("%d %d\n", res.w, res.h);
for (i = 0; i < res.h; i++) {
for (j = 0; j < res.w; j++)
printf("%d", res.mtx[j][i]);
printf("\n");
}
}
return 0;
}
void main(int argc, char* argv[])
{
figinit();
/****************************************/
/* Initialize GLUT and create window */
/****************************************/
glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH );
glutInitWindowPosition( 50, 50 );
glutInitWindowSize( 800, 600 );
main_window = glutCreateWindow( "GLUI Example 5" );
glutDisplayFunc( myGlutDisplay );
GLUI_Master.set_glutReshapeFunc( myGlutReshape );
GLUI_Master.set_glutKeyboardFunc( myGlutKeyboard );
GLUI_Master.set_glutSpecialFunc( NULL );
GLUI_Master.set_glutMouseFunc( myGlutMouse );
glutMotionFunc( myGlutMotion );
/****************************************/
/* Set up OpenGL lights */
/****************************************/
glEnable(GL_LIGHTING);
glEnable( GL_NORMALIZE );
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_AMBIENT, light0_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
glEnable(GL_LIGHT1);
glLightfv(GL_LIGHT1, GL_AMBIENT, light1_ambient);
glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_diffuse);
glLightfv(GL_LIGHT1, GL_POSITION, light1_position);
/****************************************/
/* Enable z-buferring */
/****************************************/
glEnable(GL_DEPTH_TEST);
/****************************************/
/* Here's the GLUI code */
/****************************************/
printf( "GLUI version: %3.2f\n", GLUI_Master.get_version() );
/*** Create the side subwindow ***/
glui = GLUI_Master.create_glui_subwindow( main_window,
GLUI_SUBWINDOW_LEFT );
obj_panel = glui->add_rollout( "Properties", false );
/***** Control for object params *****/
checkbox =
glui->add_checkbox_to_panel( obj_panel, "Wireframe", &wireframe, 1,
control_cb );
spinner = glui->add_spinner_to_panel( obj_panel, "Segments:",
GLUI_SPINNER_INT, &segments);
spinner->set_int_limits( 3, 60 );
spinner->set_alignment( GLUI_ALIGN_RIGHT );
GLUI_Spinner *scale_spinner =
glui->add_spinner_to_panel( obj_panel, "Scale:",
GLUI_SPINNER_FLOAT, &scale);
scale_spinner->set_float_limits( .2f, 4.0 );
scale_spinner->set_alignment( GLUI_ALIGN_RIGHT );
/******** Add some controls for lights ********/
GLUI_Rollout *roll_lights = glui->add_rollout( "Lights", false );
GLUI_Panel *light0 = glui->add_panel_to_panel( roll_lights, "Light 1" );
GLUI_Panel *light1 = glui->add_panel_to_panel( roll_lights, "Light 2" );
glui->add_checkbox_to_panel( light0, "Enabled", &light0_enabled,
LIGHT0_ENABLED_ID, control_cb );
light0_spinner =
glui->add_spinner_to_panel( light0, "Intensity:", GLUI_SPINNER_FLOAT,
&light0_intensity, LIGHT0_INTENSITY_ID,
control_cb );
light0_spinner->set_float_limits( 0.0, 1.0 );
glui->add_checkbox_to_panel( light1, "Enabled", &light1_enabled,
LIGHT1_ENABLED_ID, control_cb );
light1_spinner =
glui->add_spinner_to_panel( light1, "Intensity:", GLUI_SPINNER_FLOAT,
&light1_intensity, LIGHT1_INTENSITY_ID,
control_cb );
light1_spinner->set_float_limits( 0.0, 1.0 );
/*** Add another rollout ***/
GLUI_Rollout *options = glui->add_rollout( "Options", true );
glui->add_checkbox_to_panel( options, "Draw sphere", &show_sphere );
glui->add_checkbox_to_panel( options, "Draw torus", &show_torus );
glui->add_checkbox_to_panel( options, "Draw axes", &show_axes );
glui->add_checkbox_to_panel( options, "Draw text", &show_text );
/**** Add listbox ****/
glui->add_statictext( "" );
GLUI_Listbox *list = glui->add_listbox( "Text:", &curr_string );
int i;
for( i=0; i<4; i++ )
list->add_item( i, string_list[i] );
/**** Add listbox ****/
glui->add_statictext( "" );
GLUI_Listbox *headwear = glui->add_listbox( "HeadWear:", &curr_string );
for( i=0; i< CategorySize[0]; i++ )
headwear->add_item( i, CategoryPtr[0][i].FirstLine->Comment );
/**** Add listbox ****/
glui->add_statictext( "" );
GLUI_Listbox *heads = glui->add_listbox( "Head:", &curr_string );
for( i=0; i< CategorySize[1]; i++ )
heads->add_item( i, CategoryPtr[1][i].FirstLine->Comment );
/**** Add listbox ****/
glui->add_statictext( "" );
GLUI_Listbox *neckwear = glui->add_listbox( "NeckWear:", &curr_string );
for( i=0; i< CategorySize[2]; i++ )
neckwear->add_item( i, CategoryPtr[2][i].FirstLine->Comment );
/**** Add listbox ****/
glui->add_statictext( "" );
GLUI_Listbox *torso = glui->add_listbox( "Torso:", &curr_string );
for( i=0; i< CategorySize[3]; i++ )
torso->add_item( i, CategoryPtr[3][i].FirstLine->Comment );
glui->add_statictext( "" );
/*** Disable/Enable buttons ***/
glui->add_button( "Disable movement", DISABLE_ID, control_cb );
glui->add_button( "Enable movement", ENABLE_ID, control_cb );
glui->add_button( "Hide", HIDE_ID, control_cb );
glui->add_button( "Show", SHOW_ID, control_cb );
glui->add_statictext( "" );
/****** A 'quit' button *****/
glui->add_button( "Quit", 0,(GLUI_Update_CB)exit );
/**** Link windows to GLUI, and register idle callback ******/
glui->set_main_gfx_window( main_window );
#if 0
/*** Create the bottom subwindow ***/
glui2 = GLUI_Master.create_glui_subwindow( main_window,
GLUI_SUBWINDOW_BOTTOM );
glui2->set_main_gfx_window( main_window );
GLUI_Rotation *view_rot = glui2->add_rotation( "Objects", view_rotate );
view_rot->set_spin( 1.0 );
glui2->add_column( false );
GLUI_Rotation *sph_rot = glui2->add_rotation( "Sphere", sphere_rotate );
sph_rot->set_spin( .98 );
glui2->add_column( false );
GLUI_Rotation *tor_rot = glui2->add_rotation( "Torus", torus_rotate );
tor_rot->set_spin( .98 );
glui2->add_column( false );
GLUI_Rotation *lights_rot = glui2->add_rotation( "Blue Light", lights_rotation );
lights_rot->set_spin( .82 );
glui2->add_column( false );
GLUI_Translation *trans_xy =
glui2->add_translation( "Objects XY", GLUI_TRANSLATION_XY, obj_pos );
trans_xy->set_speed( .005 );
glui2->add_column( false );
GLUI_Translation *trans_x =
glui2->add_translation( "Objects X", GLUI_TRANSLATION_X, obj_pos );
trans_x->set_speed( .005 );
glui2->add_column( false );
GLUI_Translation *trans_y =
glui2->add_translation( "Objects Y", GLUI_TRANSLATION_Y, &obj_pos[1] );
trans_y->set_speed( .005 );
glui2->add_column( false );
GLUI_Translation *trans_z =
glui2->add_translation( "Objects Z", GLUI_TRANSLATION_Z, &obj_pos[2] );
trans_z->set_speed( .005 );
#endif
/**** We register the idle callback with GLUI, *not* with GLUT ****/
GLUI_Master.set_glutIdleFunc( myGlutIdle );
/**** Regular GLUT main loop ****/
glutMainLoop();
}
int main(int argc, char **argv)
{
int maxprims, maxfigs, maxpts, state, maxindivs, namelen;
int nfigs, nprims, npts, setsize, iters;
int ext;
struct Individ *indivs, tmp;
struct Figure *figs, *figset;
char *str;
ssize_t chread;
size_t n;
int i, j, k, m, nindivs;
struct NestAttrs attrs;
str = NULL;
n = 0;
maxfigs = 128;
namelen = 2048;
state = STATE_NEWFIG;
nfigs = nprims = npts = 0;
figs = (struct Figure*)xmalloc(sizeof(struct Figure) * maxfigs);
while ((chread = getline(&str, &n, stdin)) != -1) {
double x, y;
trim(str);
if (state == STATE_NEWFIG) {
figs[nfigs].name = (char*)xmalloc(sizeof(char) * namelen);
sscanf(str, "%s %d %d\n", figs[nfigs].name, &figs[nfigs].quant, &figs[nfigs].angstep);
state = STATE_PRIM;
maxpts = 2048;
maxprims = 128;
figs[nfigs].prims = (struct Primitive*)xmalloc(sizeof(struct Primitive) * maxprims);
figs[nfigs].prims[nprims].pts = (struct Point*)xmalloc(sizeof(struct Point) * maxpts);
// free(str);
str = NULL;
continue;
}
if (strcmp(str, FIG_SEPAR) == 0) {
state = STATE_NEWFIG;
figs[nfigs].prims[nprims].npts = npts;
nprims++;
figs[nfigs].id = nfigs;
figs[nfigs].nprims = nprims;
nfigs++;
if (nfigs == maxfigs) {
maxfigs *= 2;
figs = (struct Figure*)xrealloc(figs, sizeof(struct Figure) * maxfigs);
}
nprims = 0;
npts = 0;
// free(str);
str = NULL;
continue;
}
if (strcmp(str, PRIM_SEPAR) == 0) {
figs[nfigs].prims[nprims].npts = npts;
nprims++;
if (nprims == maxprims) {
maxprims *= 2;
figs[nfigs].prims = (struct Primitive*)xrealloc(figs[nfigs].prims, sizeof(struct Primitive) * maxprims);
}
maxpts = 2048;
figs[nfigs].prims[nprims].pts = (struct Point*)xmalloc(sizeof(struct Point) * maxpts);
npts = 0;
// free(str);
str = NULL;
continue;
}
sscanf(str, "%lf %lf\n", &x, &y);
figs[nfigs].prims[nprims].pts[npts].x = x;
figs[nfigs].prims[nprims].pts[npts].y = y;
npts++;
if (npts == maxpts) {
maxprims *= 2;
figs[nfigs].prims[nprims].pts = (struct Point*)xrealloc(figs[nfigs].prims[nprims].pts, sizeof(struct Point) * maxpts);
}
// free(str);
str = NULL;
}
for (i = 0; i < nfigs; i++) {
figinit(&figs[i]);
}
attrs.width = atof(argv[1]);
attrs.height = atof(argv[2]);
attrs.type = ROTNEST_DEFAULT;
attrs.logfile = fopen("./logfile", "w+");
figset = makeset(figs, nfigs, &setsize);
qsort(figset, setsize, sizeof(struct Figure), figcmp);
maxindivs = 1024;
indivs = (struct Individ*)xmalloc(sizeof(struct Individ) * maxindivs);
indivs[0].genom = (int*)xmalloc(sizeof(int) * setsize);
indivs[0].gensize = 0;
rotnest(figset, setsize, &indivs[0], &attrs);
nindivs = 1;
ext = 0;
iters = atoi(argv[3]);
for (i = 0; i < iters && !ext; i++) {
int nnew = 0, equal = 0, oldn;
printf("nindivs=%d\n", nindivs);
for (j = 0; j < 1; j++) {
printf("ind=%d height=%lf gensize=%d genom: ", i, indivs[j].height, indivs[j].gensize);
for (k = 0; k < indivs[j].gensize; k++) {
printf("%d ", indivs[j].genom[k]);
}
printf("\n");
}
printf("\n");
oldn = nindivs;
for (j = 0; j < oldn - 1 && nnew < 30; j++) {
struct Individ heirs[2];
if (indivs[j].gensize == indivs[j + 1].gensize) {
int res;
res = crossover(&indivs[j], &indivs[j + 1], &heirs[0], setsize);
crossover(&indivs[j + 1], &indivs[j], &heirs[1], setsize);
if (res < 0) {
break;
}
}
else {
break;
}
for (k = 0; k < 2; k++) {
for (m = 0; m < nindivs; m++) {
equal = gensequal(&heirs[k], &indivs[m]) || gensequal2(&heirs[k], &indivs[m], figset);
if (equal) {
break;
}
}
if (!equal) {
nnew++;
rotnest(figset, setsize, &heirs[k], &attrs);
indivs[nindivs] = heirs[k];
nindivs++;
if (nindivs == maxindivs) {
maxindivs *= 2;
indivs = (struct Individ*)xrealloc(indivs, sizeof(struct Individ) * maxindivs);
}
} else {
destrindiv(&heirs[k]);
}
}
}
equal = 0;
while (nnew == 0) {
int res;
res = mutate(&indivs[0], &tmp, setsize);
if (res < 0) {
ext = 1;
break;
}
equal = 0;
for (j = 0; j < nindivs; j++) {
equal = gensequal(&tmp, &indivs[j]) || gensequal2(&tmp, &indivs[j], figset);
if (equal) {
break;
}
}
if (!equal) {
nnew++;
rotnest(figset, setsize, &tmp, &attrs);
indivs[nindivs] = tmp;
nindivs++;
if (nindivs == maxindivs) {
maxindivs *= 2;
indivs = (struct Individ*)xrealloc(indivs, sizeof(struct Individ) * maxindivs);
}
} else {
destrindiv(&tmp);
}
}
qsort(indivs, nindivs, sizeof(struct Individ), gencmp);
}
for (i = 0; i < indivs[0].npos; i++) {
double a, b, c, d, e, f;
a = indivs[0].posits[i].fig.mtx[0][0];
b = indivs[0].posits[i].fig.mtx[1][0];
c = indivs[0].posits[i].fig.mtx[0][1];
d = indivs[0].posits[i].fig.mtx[1][1];
e = indivs[0].posits[i].fig.mtx[0][2];
f = indivs[0].posits[i].fig.mtx[1][2];
printf("%s\n", indivs[0].posits[i].fig.name);
printf("matrix(%lf, %lf, %lf, %lf, %lf, %lf)\n:\n", a, b, c, d, e, f);
}
// ppos2file("./drawposits", indivs[0].posits, indivs[0].npos);
return 0;
}
