//----------------------------------------------------------------------------- // Fraktaly v pocitacove grafice // Autor: Pavel Tisnovsky // // Vykresleni fraktalnich obrazcu pomoci algoritmu "Fractal Flame" navrzeneho // a posleze implementovaneho Scottem Dravesem. // Po prekladu a spusteni programu se ve spodni casti okna zobrazi kratka // napoveda spolu s klavesovymi zkratkami. // Pixmapu s vykreslenym fraktalem je mozne ulozit do souboru ve formatu TGA // pomoci klavesove zkratky [S]. Zmena typu fraktalu se provadi stiskem klaves // [0]-[9]. Pouzite transformace jsou vypsany v dolni casti obrazovky. // Ukonceni aplikace se provede klavesou [Esc] nebo klavesou [Q]. //----------------------------------------------------------------------------- #ifdef __BORLANDC__ #include <windows.h> #endif #include <GL/glut.h> // hlavickovy soubor funkci GLUTu a OpenGL #include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> #define WINDOW_TITLE "Fraktaly 39.1" // titulek okna #define WINDOW_WIDTH 640 // pocatecni velikost okna #define WINDOW_HEIGHT 480 #define FILE_NAME "fraktaly391.tga" // jmeno souboru pro ulozeni pixmapy #define PIXMAP_WIDTH 512 // sirka pixmapy #define PIXMAP_HEIGHT 384 // vyska pixmapy typedef struct { // struktura popisujici pixmapu unsigned int width; unsigned int height; unsigned char *pixels; } pixmap; typedef enum { // typy vykreslovacich rezimu IterPutPixel, IterAddPixel, IterLogPixel, TransfPutPixel, TransfAddPixel, TransfLogPixel, } DrawType; pixmap *pixFractalFlame; // pixmapa pro obrazek IFS fraktalu float floatMap[PIXMAP_HEIGHT][PIXMAP_WIDTH]; // pixmapa s floaty pro logaritmovani histogramu float floatMapRGB[PIXMAP_HEIGHT][PIXMAP_WIDTH][3]; int ifs=1; // cislo systemu iterovanych funkci int maxiter=1000; // maximalni pocet iteraci int rf=1, gf=1, bf=1; // priznaky barvovych slozek int deltar=1, deltag=1, deltab=1; // prirustky barvovych slozek double scale=30.0; // meritko fraktalu double xpos=PIXMAP_WIDTH/2.0; // posun fraktalu double ypos=PIXMAP_HEIGHT/2.0; // posun fraktalu int redraw=1; DrawType drawType=IterPutPixel; //----------------------------------------------------------------------------- // Funkce pro vytvoreni pixmapy o zadane velikosti //----------------------------------------------------------------------------- pixmap * createPixmap(const unsigned int width, const unsigned int height) { pixmap *p=(pixmap *)malloc(sizeof(pixmap)); // alokace struktury pixmapy if (!p) return NULL; p->width=width; // naplneni struktury p->height=height; p->pixels=(unsigned char *)malloc(3*width*height); if (!p->pixels) { // alokace pole pro pixely free(p); // alokace se nepovedla return NULL; } else { memset(p->pixels, 0, 3*width*height); // smazani pixmapy } return p; } //----------------------------------------------------------------------------- // Funkce pro zruseni pixmapy //----------------------------------------------------------------------------- void destroyPixmap(pixmap *p) { if (p->pixels) free(p->pixels); // uvolnit vlastni pixmapu if (p) free(p); // i okolni strukturu } //----------------------------------------------------------------------------- // Vymazani pixmapy //----------------------------------------------------------------------------- void clearPixmap(const pixmap *p) { if (!p) return; if (!p->pixels) return; memset(p->pixels, 0, 3*p->width*p->height); if (drawType==IterLogPixel) memset(floatMap, 0, PIXMAP_WIDTH*PIXMAP_HEIGHT*sizeof(float)); if (drawType==TransfLogPixel) memset(floatMapRGB, 0, PIXMAP_WIDTH*PIXMAP_HEIGHT*sizeof(float)*3); } //----------------------------------------------------------------------------- // Funkce pro vykresleni pixmapy do barvoveho bufferu //----------------------------------------------------------------------------- void drawPixmap(const pixmap *p) { if (!p || !p->pixels) return; glDrawPixels( // vykresleni pixmapy p->width, p->height, // sirka a vyska pixmapy GL_RGB, // format dat pixelu GL_UNSIGNED_BYTE, // datovy typ kazde barevne slozky p->pixels); // ukazatel na pamet s barvami pixelu } //----------------------------------------------------------------------------- // Ulozeni pixmapy do externiho souboru //----------------------------------------------------------------------------- void savePixmap(const pixmap *p, const char *fileName) { FILE *fout; unsigned int i, j, k; unsigned char tgaHeader[18]={ // hlavicka formatu typu TGA 0x00, // typ hlavicky TGA 0x00, // nepouzivame paletu 0x02, // typ obrazku je RGB TrueColor 0x00, 0x00, // delka palety je nulova 0x00, 0x00, 0x00, // pozice v palete nas nezajima 0x00, 0x00, 0x00, 0x00, // obrazek je umisteny na pozici [0, 0] 0x00, 0x00, 0x00, 0x00, // sirka a vyska obrazku (dva byty na polozku) 0x18, // format je 24 bitu na pixel 0x20 // orientace pixmapy v obrazku }; if (!p || !p->pixels) return; memcpy(tgaHeader+12, &(p->width), 2); // do hlavicky TGA zapsat velikost obrazku memcpy(tgaHeader+14, &(p->height), 2); fout=fopen(fileName, "wb"); if (fout) { fwrite(tgaHeader, 18, 1, fout); // zapsat hlavicku TGA do souboru for (j=p->height; j; j--) { // radky zapisovat v opacnem poradi unsigned int yoff=(j-1)*3*p->width; // y-ovy offset v poli unsigned int xoff=0; // x-ovy offset v poli for (i=0; i<p->width; i++) { // pro kazdy pixel na radku for (k=0; k<3; k++) { // prohodit barvy RGB na BGR fputc(p->pixels[xoff+yoff+2-k], fout); // a zapsat do souboru } xoff+=3; // posun na dalsi pixel } } fclose(fout); } } //----------------------------------------------------------------------------- // Zmena barvy pixelu na zadanych souradnicich //----------------------------------------------------------------------------- void putpixel(pixmap *p, const unsigned int x, // pozice pixelu v pixmape const unsigned int y, const unsigned char r, // barva pixelu const unsigned char g, const unsigned char b) { int pos; // zde se vyuziva zkraceneho vyhodnoceni vyrazu - pokud plati !p, nic se dale netestuje if (!p || !p->pixels || x>=p->width || y>=p->height) return; pos=3*(x+y*p->width); p->pixels[pos++]=r; // nastaveni barvy pixelu p->pixels[pos++]=g; p->pixels[pos]=b; } //----------------------------------------------------------------------------- // Prirustek barvy pixelu na zadanych souradnicich //----------------------------------------------------------------------------- void addpixel(pixmap *p, const unsigned int x, const unsigned int y, const unsigned char dr, const unsigned char dg, const unsigned char db) { int pos; // zde se vyuziva zkraceneho vyhodnoceni vyrazu - pokud plati !p, nic se dale netestuje if (!p || !p->pixels || x>=p->width || y>=p->height) return; pos=3*(x+y*p->width); if (p->pixels[pos]<256-dr) p->pixels[pos]+=dr;// nastaveni cervene slozky barvy pixelu pos++; if (p->pixels[pos]<256-dg) p->pixels[pos]+=dg;// nastaveni zelene slozky barvy pixelu pos++; if (p->pixels[pos]<256-db) p->pixels[pos]+=db;// nastaveni modre slozky barvy pixelu } //----------------------------------------------------------------------------- // Vynasobeni kazdeho pixelu konstantou vypoctenou tak, aby se provedl prevod // z linearniho do logaritmickeho meritka //----------------------------------------------------------------------------- void multiplepixel(pixmap *p, const unsigned int x, const unsigned int y, float pixelR, float pixelG, float pixelB) { int pos; // zde se vyuziva zkraceneho vyhodnoceni vyrazu - pokud plati !p, nic se dale netestuje if (!p || !p->pixels || x>=p->width || y>=p->height) return; pos=3*(x+y*p->width); p->pixels[pos]*=pixelR; pos++; p->pixels[pos]*=pixelG; pos++; p->pixels[pos]*=pixelB; } //----------------------------------------------------------------------------- // Prirustek barvy pixelu na zadanych souradnicich ve floatove monochromaticke // mape //----------------------------------------------------------------------------- void addfloat(const unsigned int x, const unsigned int y) { if (x>=PIXMAP_WIDTH || y>=PIXMAP_HEIGHT) return; floatMap[y][x]++; } //----------------------------------------------------------------------------- // Prirustek barvy pixelu na zadanych souradnicich ve floatove mape typu RGB //----------------------------------------------------------------------------- void addfloatRGB(const unsigned int x, const unsigned int y, int r, int g, int b) { if (x>=PIXMAP_WIDTH || y>=PIXMAP_HEIGHT) return; floatMapRGB[y][x][0]+=r; floatMapRGB[y][x][1]+=g; floatMapRGB[y][x][2]+=b; } //----------------------------------------------------------------------------- // Kopie pixelu z floatove pixmapy do pixmapy kompatibilni s OpenGL spolu // s logaritmickym prevodem meritka //----------------------------------------------------------------------------- void convertFloatMap(void) { // logaritmovani histogramu a prevod na byty float maxp=0; float pixelFactor; // faktor konverze int i, j; for (j=0; j<PIXMAP_HEIGHT; j++) // zjistit maximalni hodnotu ulozenou for (i=0; i<PIXMAP_WIDTH; i++) // ve floatove pixmape if (maxp<floatMap[j][i]) maxp=floatMap[j][i]; pixelFactor=255.0/log(maxp); // vypocitat faktor konverze for (j=0; j<PIXMAP_HEIGHT; j++) { // konverze a zmena na logaritmicke meritko for (i=0; i<PIXMAP_WIDTH; i++) { // s tim, ze vysledne barvove slozky jsou float pixel=log(floatMap[j][i])*pixelFactor; // v rozsahu 0..255 putpixel(pixFractalFlame, i, j, (int)pixel, (int)pixel, (int)pixel); } } } //----------------------------------------------------------------------------- // Zmena pixelu v pixmape tak, aby se zmenila linearni zavislost mezi poctem // zasahu pixelu na zavislost logaritmickou //----------------------------------------------------------------------------- void convertFloatMap2(void) { // logaritmovani histogramu a prevod na byty float max[3]={0, 0, 0}; float factor[3]; int i, j, k; for (j=0; j<PIXMAP_HEIGHT; j++) // zjistit maximalni hodnoty ulozene for (i=0; i<PIXMAP_WIDTH; i++) // ve floatove pixmapy for (k=0; k<3; k++) if (max[k]<floatMapRGB[j][i][k]) max[k]=floatMapRGB[j][i][k]; for (k=0; k<3; k++) // vypocitat vektor faktoru konverze factor[k]=255.0/log(max[k]); for (j=0; j<PIXMAP_HEIGHT; j++) { for (i=0; i<PIXMAP_WIDTH; i++) { float pixel[3]; for (k=0; k<3; k++) pixel[k]=log(floatMapRGB[j][i][k])*factor[k]; putpixel(pixFractalFlame, i, j, (int)pixel[0], (int)pixel[1], (int)pixel[2]); } } } //----------------------------------------------------------------------------- // Vypocet x-ove souradnice pomoci funkce Vn() //----------------------------------------------------------------------------- double vx(int type, double x, double y) { double r=sqrt(x*x+y*y); // vzdalenost od pocatku double phi=atan2(y,x); // uhel od x-ove osy double result; switch (type) { case 0: // linear result=x; break; case 1: // sinusoidal result=sin(x); break; case 2: // spherical result=x/(r*r); break; case 3: // swirl result=r*cos(phi+r); break; case 4: // horseshoe result=r*cos(2*phi); break; case 5: // polar result=phi/M_PI; break; case 6: // handkerchief result=r*sin(phi+r); break; case 7: // heart result=r*sin(phi*r); break; case 8: // disc result=phi*sin(M_PI*r)/M_PI; break; case 9: // spiral result=(cos(phi)+sin(r))/r; break; case 10: // hyperbolic result=sin(phi)/r; break; case 11: // diamond result=sin(phi)*cos(r); break; case 12: // ex result=r*pow(sin(phi+r),3); break; case 13: // Julia result=sqrt(r)*cos(phi/2); break; case 16: // fisheye result=2*r/((r+1)*x); break; case 20: // cosine result=cos(M_PI*x)*cosh(y); break; default: result=x; break; }; return result; } //----------------------------------------------------------------------------- // Vypocet y-ove souradnice pomoci funkce Vn() //----------------------------------------------------------------------------- double vy(int type, double x, double y) { double r=sqrt(x*x+y*y); // vzdalenost od pocatku double phi=atan2(y,x); // uhel od x-ove osy double result; switch (type) { case 0: // linear result=y; break; case 1: // sinusoidal result=sin(y); break; case 2: // spherical result=y/(r*r); break; case 3: // swirl result=r*sin(phi+r); break; case 4: // horseshoe result=r*sin(2*phi); break; case 5: // polar result=r-1; break; case 6: // handkerchief result=r*cos(phi-r); break; case 7: // heart result=-r*cos(phi*r); break; case 8: // disc result=phi*cos(M_PI*r)/M_PI; break; case 9: // spiral result=(sin(phi)-cos(r))/r; break; case 10: // hyperbolic result=cos(phi)/r; break; case 11: // diamond result=cos(phi)*sin(r); break; case 12: // ex result=r*pow(cos(phi-r),3); break; case 13: // Julia result=sqrt(r)*sin(phi/2); break; case 16: // fisheye result=2*r/((r+1)*y); break; case 20: // cosine result=-sin(M_PI*x)*sinh(y); break; default: result=y; break; }; return result; } //----------------------------------------------------------------------------- // Prekresleni fraktalu typu FractalFlame //----------------------------------------------------------------------------- void recalcFractalFlame( pixmap *pix, // pixmapa pro vykreslovani int maxiter, // maximalni pocet iteraci double scale, // meritko obrazce double xpos, // posun obrazce double ypos, int type, // vybrany IFS system int rf, int gf, int bf, // priznaky barvovych slozek int dr, int dg, int db, // prirustky barvovych slozek DrawType drawType) // zpusob vykresleni { int iter=0; // pocitadlo iteraci int threshold=50; // hranice poctu iteraci pro vykreslovani double x, y; // poloha iterovaneho bodu double xn, yn; // nova poloha iterovaneho bodu int k; // cislo vybraneho ridiciho bodu unsigned char red=rf ? dr : 0; // realne prirustky barvovych slozek unsigned char green=gf ? dg : 0; unsigned char blue=bf ? db : 0; double coefs[][3][7]={ // koeficienty jednotlivych transformaci { { 0.500000, 0.0000000, 0.000000, 0.5000000, 0.000000, 0.000000, 2}, { 0.500000, 0.0000000, 0.000000, 0.5000000, 0.000000, 1.000000, 0}, { 0.500000, 0.0000000, 0.000000, 0.5000000, 1.000000, 1.000000, 0} }, { { 0.983960, 0.2983280, 0.359416, -0.5835410, -0.850590, -0.378754, 0}, {-0.900388, 0.2930630, 0.397598, 0.0225629, 0.465126, -0.277212, 9}, {-0.329863, -0.0855261, -0.369381, -0.8583790, 0.977861, 0.547595, 3}, }, { { 0.562482, 0.3978610, -0.539599, 0.5010880, -0.429920, -0.112404, 2}, { 0.830039, -0.4961740, 0.162480, 0.7504680, 0.910220, 0.288389, 2}, { 1.000000, 0.0000000, 0.000000, 1.0000000, 0.000000, 0.000000, 0}, }, { { 0.983960, 0.2983280, 0.359416, -0.5835410, -0.850590, -0.378754, 2}, { 0.830039, -0.4961740, 0.162480, 0.7504680, 0.910220, 0.288389, 2}, { 0.500000, 0.0000000, 0.000000, 0.5000000, 1.000000, 1.000000, 0} }, { { 0.983960, 0.2983280, 0.359416, -0.5835410, -0.850590, -0.378754, 3}, { 0.830039, -0.4961740, 0.162480, 0.7504680, 0.910220, 0.288389, 3}, { 0.500000, 0.0000000, 0.000000, 0.5000000, 1.000000, 1.000000, 3} }, { { 0.500000, -0.4000000, 0.000000, 0.5000000, 0.000000, 0.000000, 20}, { 0.500000, 0.1000000, 0.000000, 0.5000000, 0.000000, 0.300000, 3}, { 0.500000, 0.0000000, 0.100000, 0.4000000, 0.500000, 1.000000, 5} }, { { 0.983960, 0.2983280, 0.359416, -0.5835410, -0.850590, -0.378754, 1}, {-0.900388, 0.2930630, 0.397598, 0.0225629, 0.465126, -0.277212, 2}, {-0.329863, -0.0855261, -0.369381, -0.8583790, 0.977861, 0.547595, 3} }, { { 0.983960, 0.2983280, 0.359416, -0.5835410, -0.850590, -0.378754, 4}, {-0.900388, 0.2930630, 0.397598, 0.0225629, 0.465126, -0.277212, 5}, {-0.329863, -0.0855261, -0.369381, -0.8583790, 0.977861, 0.547595, 6} }, { { 0.983960, 0.2983280, 0.359416, -0.5835410, -0.850590, -0.378754, 7}, {-0.900388, 0.2930630, 0.397598, 0.0225629, 0.465126, -0.277212, 8}, {-0.329863, -0.0855261, -0.369381, -0.8583790, 0.977861, 0.547595, 9} }, { { 0.983960, 0.2983280, 0.359416, -0.5835410, -0.850590, -0.378754, 10}, {-0.900388, 0.2930630, 0.397598, 0.0225629, 0.465126, -0.277212, 11}, {-0.329863, -0.0855261, -0.369381, -0.8583790, 0.977861, 0.547595, 12} }, }; unsigned char pal[8][3]={ // barvova paleta {0xff, 0x00, 0x00}, {0x00, 0xff, 0x00}, {0x00, 0x00, 0xff}, {0xff, 0xff, 0x00}, {0x00, 0xff, 0xff}, {0xff, 0x00, 0xff}, {0xff, 0xff, 0xff}, {0x80, 0x80, 0x80}, }; x=0; y=0; // nastaveni pocatecni polohy bodu srand(0); while (iter++<maxiter*100) { // iteracni smycka k=rand()%3; // zvolit jednu ze tri transformaci xn=x*coefs[type][k][0]+y*coefs[type][k][2]+coefs[type][k][4]; // aplikovat linearni yn=x*coefs[type][k][1]+y*coefs[type][k][3]+coefs[type][k][5]; // transformaci x=vx((int)coefs[type][k][6], xn, yn); // aplikovat nelinearni transformaci y=vy((int)coefs[type][k][6], xn, yn); if (iter>threshold) { // je-li dosazeno hranice iteraci double xx=x*scale+xpos; double yy=y*scale+ypos; switch (drawType) { // vyber vykreslovaciho rezimu case IterPutPixel: putpixel(pix, xx, yy, rf ? 0xff:0x00, gf ? 0xff:0x00, bf ? 0xff:0x00); break; case IterAddPixel: addpixel(pix, xx, yy, red, green, blue); break; case IterLogPixel: addfloat(xx, yy); break; case TransfPutPixel: putpixel(pix, xx, yy, pal[k&7][0], pal[k&7][1], pal[k&7][2]); break; case TransfAddPixel: addpixel(pix, xx, yy, (!!pal[k&7][0])*dr, (!!pal[k&7][1])*dg, (!!pal[k&7][2])*db); break; case TransfLogPixel: addfloatRGB(xx, yy, (!!pal[k&7][0]), (!!pal[k&7][1]), (!!pal[k&7][2])); break; default: break; } } x=xn; y=yn; } // u logaritmickych prevodu provest finalni konverzi pixmap if (drawType==IterLogPixel) convertFloatMap(); if (drawType==TransfLogPixel) convertFloatMap2(); } //----------------------------------------------------------------------------- // Vykresleni retezce na obrazovku //----------------------------------------------------------------------------- void drawString(const int x, const int y, // umisteni retezce const float r, const float g, const float b, // barva pisma char *str) // ukazatel na retezec { char *c; glColor3f(r, g, b); glRasterPos2i(x, y); for (c=str; *c!=0; c++) { glutBitmapCharacter(GLUT_BITMAP_9_BY_15, *c); } } //----------------------------------------------------------------------------- // Vypis informaci o vykreslovanem fraktalu //----------------------------------------------------------------------------- void drawInfo(int maxiter, double xpos, double ypos, double scale, int ifs, int r, int g, int b, int deltar, int deltag, int deltab, DrawType drawType) { #define drawString2(x, y, r, g, b, str) drawString((x)+1, (y), 0.0, 0.0, 0.0, (str)); drawString((x), (y)+1, (r), (g), (b), (str)); char str[100]; char *ifsNames[10]={ "Chaos 1", "Chaos 2", "Chaos 3", "Chaos 4", "Chaos 5", "Chaos 6", "Chaos 7", "Chaos 8", "Chaos 9", "Chaos 10", }; sprintf(str, "[0]-[9] IFS type = %s", ifsNames[ifs]); drawString2( 10, 112, 0.0, 1.0, 1.0, str); sprintf(str, "[F1] draw: IterPutPixel: %s", drawType==IterPutPixel ? "set":""); drawString2( 10, 96, 0.2, 1.0, 1.0, str); sprintf(str, "[F2] draw: IterAddPixel: %s", drawType==IterAddPixel ? "set":""); drawString2( 10, 80, 0.4, 1.0, 0.8, str); sprintf(str, "[F3] draw: IterLogPixel: %s", drawType==IterLogPixel ? "set":""); drawString2( 10, 64, 0.6, 1.0, 0.6, str); sprintf(str, "[F4] draw: TransfPutPixel: %s", drawType==TransfPutPixel ? "set":""); drawString2( 10, 48, 0.8, 1.0, 0.4, str); sprintf(str, "[F5] draw: TransfAddPixel: %s", drawType==TransfAddPixel ? "set":""); drawString2( 10, 32, 1.0, 1.0, 0.2, str); sprintf(str, "[F6] draw: TransfLogPixel: %s", drawType==TransfLogPixel ? "set":""); drawString2( 10, 16, 1.0, 1.0, 0.0, str); sprintf(str, "[<][>][,][.] maxiter = %d", maxiter*10); drawString2(320, 112, 1.0, 0.0, 0.6, str); sprintf(str, "[PgUp][PgDn] scale = %4.2f ", scale); drawString2(320, 96, 1.0, 0.0, 1.0, str); sprintf(str, "[Arrows] pan = %5.3f, %5.3f", xpos, ypos); drawString2(320, 80, 0.8, 0.2, 1.0, str); sprintf(str, "[R][G][B] colors = %d %d %d", r, g, b); drawString2(320, 64, 0.6, 0.4, 1.0, str); sprintf(str, "[F7][F8] delta R = %d", deltar); drawString2(320, 48, 0.4, 0.6, 1.0, str); sprintf(str, "[F9][F10] delta G = %d", deltag); drawString2(320, 32, 0.2, 0.8, 1.0, str); sprintf(str, "[F11][F12] delta B = %d", deltab); drawString2(320, 16, 0.0, 1.0, 1.0, str); } //----------------------------------------------------------------------------- // Funkce volana pro inicializaci vykreslovani //----------------------------------------------------------------------------- void onInit(void) { glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // barva pozadi glPixelStorei(GL_UNPACK_ALIGNMENT, 1); // mod ulozeni pixelu pixFractalFlame=createPixmap(PIXMAP_WIDTH, PIXMAP_HEIGHT); } //----------------------------------------------------------------------------- // Nastaveni souradneho systemu v zavislosti na velikosti okna //----------------------------------------------------------------------------- void onResize(int w, int h) // argumenty w a h reprezentuji novou velikost okna { glViewport(0, 0, w, h); // viditelna oblast pres cele okno glMatrixMode(GL_PROJECTION); // zacatek modifikace projekcni matice glLoadIdentity(); // vymazani projekcni matice (=identita) glOrtho(0, w, 0, h, -1, 1); // mapovani abstraktnich souradnic do souradnic okna } //----------------------------------------------------------------------------- // Tato callback funkce je zavolana pri kazdem prekresleni okna //----------------------------------------------------------------------------- void onDisplay(void) { glClear(GL_COLOR_BUFFER_BIT); // vymazani vsech bitovych rovin barvoveho bufferu glDrawBuffer(GL_BACK); // pixmapa se bude kreslit do zadniho barvoveho bufferu if (redraw) { clearPixmap(pixFractalFlame); // vymazani pixmapy a prepocet fraktalu recalcFractalFlame(pixFractalFlame, maxiter, scale, xpos, ypos, ifs, rf, gf, bf, deltar, deltag, deltab, drawType);// prepocet fraktalu redraw=0; } glRasterPos2i(0, WINDOW_HEIGHT-PIXMAP_HEIGHT); // nastaveni souradnic leveho spodniho rohu pixmapy drawPixmap(pixFractalFlame); // vykresleni pixmapy glRasterPos2i(0, 0); drawInfo(maxiter, xpos, ypos, scale, ifs, rf, gf, bf, deltar, deltag, deltab, drawType); glFlush(); // provedeni a vykresleni vsech zmen glutSwapBuffers(); } //----------------------------------------------------------------------------- // Tato callback funkce je zavolana pri stlaceni ASCII klavesy //----------------------------------------------------------------------------- #ifdef __BORLANDC__ #pragma option -w-par #endif void onKeyboard(unsigned char key, int x, int y) { key=(key>='A' && key<='Z') ? key-'A'+'a': key; if (key>='0' && key<='9') { ifs=key-'0'; redraw=1; glutPostRedisplay(); } // nastaveni barvove palety switch (key) { case 27: // pokud byla stlacena klavesa ESC, konec programu case 'q': exit(0); break; // totez co klavesa ESC case 's': savePixmap(pixFractalFlame, FILE_NAME); break; // ulozeni pixmapy case '<': if (maxiter>1000) maxiter-=1000; redraw=1; glutPostRedisplay(); break; case ',': if (maxiter>100) maxiter-=100; redraw=1; glutPostRedisplay(); break; // zmena poctu iteraci case '>': maxiter+=1000; redraw=1; glutPostRedisplay(); break; case '.': maxiter+=100; redraw=1; glutPostRedisplay(); break; case 'r': rf=!rf; redraw=1; glutPostRedisplay(); break; // priznaky barvovych slozek case 'g': gf=!gf; redraw=1; glutPostRedisplay(); break; case 'b': bf=!bf; redraw=1; glutPostRedisplay(); break; default: break; } } #ifdef __BORLANDC__ #pragma option -w+par #endif //----------------------------------------------------------------------------- // Tato callback funkce je zavolana pri stlaceni non-ASCII klavesy //----------------------------------------------------------------------------- #ifdef __BORLANDC__ #pragma option -w-par #endif void onSpecial(int key, int x, int y) { // posun fraktalu a zmena meritka switch (key) { case GLUT_KEY_LEFT: xpos-=5; redraw=1; glutPostRedisplay(); break; case GLUT_KEY_RIGHT: xpos+=5; redraw=1; glutPostRedisplay(); break; case GLUT_KEY_UP: ypos+=5; redraw=1; glutPostRedisplay(); break; case GLUT_KEY_DOWN: ypos-=5; redraw=1; glutPostRedisplay(); break; case GLUT_KEY_PAGE_UP: scale*=1.1; redraw=1; glutPostRedisplay(); break; case GLUT_KEY_PAGE_DOWN: if (scale>1) scale/=1.1; redraw=1; glutPostRedisplay(); break; case GLUT_KEY_F1: drawType=IterPutPixel ; redraw=1; glutPostRedisplay(); break; case GLUT_KEY_F2: drawType=IterAddPixel; redraw=1; glutPostRedisplay(); break; case GLUT_KEY_F3: drawType=IterLogPixel; redraw=1; glutPostRedisplay(); break; case GLUT_KEY_F4: drawType=TransfPutPixel; redraw=1; glutPostRedisplay(); break; case GLUT_KEY_F5: drawType=TransfAddPixel; redraw=1; glutPostRedisplay(); break; case GLUT_KEY_F6: drawType=TransfLogPixel; redraw=1; glutPostRedisplay(); break; case GLUT_KEY_F7: if (deltar>1) deltar--; redraw=1; glutPostRedisplay(); break; case GLUT_KEY_F8: deltar++; redraw=1; glutPostRedisplay(); break; case GLUT_KEY_F9: if (deltag>1) deltag--; redraw=1; glutPostRedisplay(); break; case GLUT_KEY_F10: deltag++; redraw=1; glutPostRedisplay(); break; case GLUT_KEY_F11: if (deltab>1) deltab--; redraw=1; glutPostRedisplay(); break; case GLUT_KEY_F12: deltab++; redraw=1; glutPostRedisplay(); break; default: break; } } #ifdef __BORLANDC__ #pragma option -w+par #endif //----------------------------------------------------------------------------- // Hlavni funkce konzolove aplikace //----------------------------------------------------------------------------- int main(int argc, char **argv) { glutInit(&argc, argv); // inicializace knihovny GLUT glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE); glutCreateWindow(WINDOW_TITLE); // vytvoreni okna pro kresleni glutReshapeWindow(WINDOW_WIDTH, WINDOW_HEIGHT);// zmena velikosti okna glutPositionWindow(100, 100); // pozice leveho horniho rohu okna glutDisplayFunc(onDisplay); // registrace funkce volane pri prekreslovani okna glutReshapeFunc(onResize); // registrace funkce volane pri zmene velikosti okna glutKeyboardFunc(onKeyboard); // registrace funkce volane pri stlaceni klavesy glutSpecialFunc(onSpecial); // registrace funkce volane pri stlaceni specialni klavesy onInit(); // inicializace vykreslovani glutMainLoop(); // nekonecna smycka, kde se volaji zaregistrovane funkce return 0; // navratova hodnota vracena operacnimu systemu } //----------------------------------------------------------------------------- // finito //-----------------------------------------------------------------------------