//-----------------------------------------------------------------------------
// Fraktaly v pocitacove grafice
// Ukazkovy priklad cislo 48.1
// Autor: Pavel Tisnovsky
//
// Vykresleni animace plasmy pomoci alternativni metody - deleni ctverce na dve
// poloviny a zvysovani/snizovani intenzit pixelu v obou polovinach. Animace je
// provedena prubeznym prekryvanim dvou obrazku s plasmou. Animace je mozne
// spustit a opetovne zastavit klavesou [S]. Pomoci klaves [1]-[4] se nastavuje
// faktor michani pro zdrojovou cast a pomoci klaves [5]-[8] faktor michani
// pro cast cilovou.
// 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>
#include <limits.h>
#define WINDOW_TITLE "Fraktaly 48.1" // titulek okna
#define WINDOW_WIDTH 512+10 // pocatecni velikost okna
#define WINDOW_HEIGHT 512+10
#define PIXMAP_WIDTH 512 // sirka pixmapy
#define PIXMAP_HEIGHT 512 // vyska pixmapy
typedef struct { // struktura popisujici pixmapu
unsigned int width;
unsigned int height;
unsigned char *pixels;
} pixmap;
int blendSrc[]={
GL_ZERO,
GL_ONE,
GL_DST_COLOR,
GL_ONE_MINUS_DST_COLOR
};
int blendDst[]={
GL_ZERO,
GL_ONE,
GL_SRC_COLOR,
GL_ONE_MINUS_SRC_COLOR
};
pixmap *pix1;
pixmap *pix2;
int maxiter=2000;
int t=0;
int stop=0;
int src=2;
int dst=2;
//-----------------------------------------------------------------------------
// 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);
}
//-----------------------------------------------------------------------------
// 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 bitmapy 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;
}
//-----------------------------------------------------------------------------
// Pridani poloroviny do pracovni bitmapy pomoci modifikovaneho Bresenhamova
// algoritmu pro rasterizaci usecky
//-----------------------------------------------------------------------------
void addHalfPlane(int bitmap[PIXMAP_HEIGHT][PIXMAP_WIDTH], int x1, int y1, int x2, int y2)
{
int x, y;
int i, j, deltax, deltay, numpixels;
int d, dinc1, dinc2, xinc1, xinc2, yinc1, yinc2;
int dir;
dir=rand()%2; // smer "kladne" a "zaporne" poloroviny
// otestovat mezni stavy
if (x1<0 || x2<0 || y1<0 || y2<0) return;
if (x1>=PIXMAP_WIDTH || x2>=PIXMAP_WIDTH || y1>=PIXMAP_HEIGHT || y2>=PIXMAP_HEIGHT) return;
deltax=abs(x2-x1); // pouzito pro predikci v Bresenhamove algoritmu
deltay=abs(y2-y1);
if (deltax>=deltay) { // uhel je mensi nez +-45 stupnu
numpixels=deltax; // celkovy pocet pixelu na usecce
d=(deltay<<1)-deltax; // predikce
dinc1=deltay<<1; // zmena predikce v kazdem kroku
dinc2=(deltay-deltax)<<1;
xinc1=xinc2=1;
yinc1=0;
yinc2=1;
}
else { // uhel je vetsi nez +-45 stupnu
numpixels=deltay; // celkovy pocet pixelu na usecce
d=(deltax<<1)-deltay; // predikce
dinc1=deltax<<1; // zmena predikce v kazdem kroku
dinc2=(deltax-deltay)<<1;
xinc1=0;
yinc1=yinc2=1;
xinc2=1;
}
if (x2<x1) { // opacna orientace usecky:
xinc1=-xinc1; // prohozeni x-ovych souradnic
xinc2=-xinc2;
}
if (y2<y1) { // opacna orientace usecky:
yinc1=-yinc1; // prohozeni y-ovych souradnic
yinc2=-yinc2;
}
x=x1; // nastaveni pocatecniho pixelu
y=y1;
for (i=0; i<numpixels; i++) { // pro vsechny pixely na usecce
if (deltax>=deltay) { // mene nez 45 stupnu - vertikalni cary
if (dir) {
for (j=0; j<=y; j++)
bitmap[j][x]--; // snizeni intenzity pixelu
for (j=y; j<PIXMAP_HEIGHT; j++)
bitmap[j][x]++; // zvyseni intenzity pixelu
}
else {
for (j=0; j<=y; j++)
bitmap[j][x]++; // zvyseni intenzity pixelu
for (j=y; j<PIXMAP_HEIGHT; j++)
bitmap[j][x]--; // snizeni intenzity pixelu
}
}
else { // vice nez 45 stupnu - horizontalni cary
if (dir) {
for (j=0; j<=x; j++)
bitmap[y][j]--; // snizeni intenzity pixelu
for (j=x; j<PIXMAP_WIDTH; j++)
bitmap[y][j]++; // zvyseni intenzity pixelu
}
else {
for (j=0; j<=x; j++)
bitmap[y][j]++; // zvyseni intenzity pixelu
for (j=x; j<PIXMAP_WIDTH; j++)
bitmap[y][j]--; // snizeni intenzity pixelu
}
}
if (d<0) { // posun na dalsi pixel
d+=dinc1; // podle predikce
x+=xinc1;
y+=yinc1;
}
else {
d+=dinc2;
x+=xinc2;
y+=yinc2;
}
}
}
//-----------------------------------------------------------------------------
// Prekresleni fraktalni plasmy
//-----------------------------------------------------------------------------
void recalcFractal(pixmap *pix, int randSeed)
{
int bitmap[PIXMAP_HEIGHT][PIXMAP_WIDTH];
int i, x, y;
int min=INT_MAX, max=0; // pro zmenu kontrastu bitmapy
float fmin=1e10, fmax=-1e10; // pro prepocet intenzit pixelu
int x1, y1, x2, y2; // souradnice generovanych bodu
srand(randSeed);
for (y=0; y<PIXMAP_HEIGHT; y++) // vymazani pracovni bitmapy
for (x=0; x<PIXMAP_WIDTH; x++)
bitmap[y][x]=0;
for (i=0; i<maxiter; i++) { // iteracni smycka
x1=rand()%PIXMAP_WIDTH;
y1=0;
x2=rand()%PIXMAP_WIDTH;
y2=PIXMAP_HEIGHT-1;
addHalfPlane(bitmap, x1, y1, x2, y2);// usecka z horniho k dolnimu okraji
x1=0;
y1=rand()%PIXMAP_HEIGHT;
x2=PIXMAP_WIDTH-1;
y2=rand()%PIXMAP_HEIGHT;
addHalfPlane(bitmap, x1, y1, x2, y2);// usecka z leveho k pravemu okraji
if (!(i%100)) printf("%i\t", i);
}
putchar('\n');
// oprava intenzity rohoveho bodu
bitmap[PIXMAP_HEIGHT-1][PIXMAP_WIDTH-1]=bitmap[PIXMAP_HEIGHT-2][PIXMAP_WIDTH-2];
// ziskani statistiky o obrazku
for (y=0; y<PIXMAP_HEIGHT; y++)
for (x=0; x<PIXMAP_WIDTH; x++) {
if (max<bitmap[y][x]) max=bitmap[y][x];
if (min>bitmap[y][x]) min=bitmap[y][x];
}
printf("min=%d\nmax=%d\n", min, max);
// zmena kontrastu a kopie bitmapy
for (y=0; y<PIXMAP_HEIGHT; y++)
for (x=0; x<PIXMAP_WIDTH; x++) {
float f=bitmap[y][x];
f-=min;
f*=255.0/(max-min);
if (fmin>f) fmin=f;
if (fmax<f) fmax=f;
putpixel(pix, x, y, (int)f, (int)f, (int)f);
}
printf("fmin=%f\nfmax=%f\n", fmin, fmax);
}
//-----------------------------------------------------------------------------
// 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);
}
}
//-----------------------------------------------------------------------------
// Vypsani informaci o zadanych parametrech
//-----------------------------------------------------------------------------
void drawInfo(int x1, int y1, int x2, int y2)
{
char *srcStr[]={
"GL_ZERO",
"GL_ONE",
"GL_DST_COLOR",
"GL_ONE_MINUS_DST_COLOR"
};
char *dstStr[]={
"GL_ZERO",
"GL_ONE",
"GL_SRC_COLOR",
"GL_ONE_MINUS_SRC_COLOR"
};
char str[100];
drawString(10, 130, 0.8, 0.2, 0.8, "[1]-[4] source");
drawString(10, 110, 1.0, 0.0, 1.0, srcStr[src]);
drawString(10, 90, 1.0, 0.2, 0.8, "[5]-[8] destination");
drawString(10, 70, 1.0, 0.4, 0.6, dstStr[dst]);
sprintf(str, "[s] %s", stop ? "stopped":"running");
drawString(10, 50, 1.0, 0.6, 0.4, str);
sprintf(str, "(x1, y1)=(%d,%d)", x1, y1);
drawString(10, 30, 1.0, 0.8, 0.2, str);
sprintf(str, "(x2, y2)=(%d,%d)", x2, y2);
drawString(10, 10, 1.0, 1.0, 0.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
pix1=createPixmap(PIXMAP_WIDTH, PIXMAP_HEIGHT);
pix2=createPixmap(PIXMAP_WIDTH, PIXMAP_HEIGHT);
recalcFractal(pix1, 123);
recalcFractal(pix2, 456);
}
//-----------------------------------------------------------------------------
// 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)
{
#define RADIUS 100.0
int x1, y1, x2, y2;
glClear(GL_COLOR_BUFFER_BIT); // vymazani vsech bitovych rovin barvoveho bufferu
glDrawBuffer(GL_BACK); // pixmapa se bude kreslit do zadniho barvoveho bufferu
x1=RADIUS+RADIUS*cos(t/10.0); // pozice prvni pixmapy
y1=RADIUS+RADIUS*sin(t/7.0);
x2=RADIUS+RADIUS*sin(t/11.0); // pozice druhe pixmapy
y2=RADIUS+RADIUS*cos(t/13.0);
glEnable(GL_SCISSOR_TEST); // orezani vykreslovani
glScissor(RADIUS*2, RADIUS*2, PIXMAP_WIDTH, PIXMAP_HEIGHT);
glRasterPos2i(x1, y1); // nastaveni souradnic leveho spodniho rohu pixmapy
drawPixmap(pix1); // vykresleni pixmapy
glEnable(GL_BLEND);
glBlendFunc(blendSrc[src], blendDst[dst]); // povoleni a nastaveni michaci funkce
glRasterPos2i(x2, y2); // nastaveni souradnic leveho spodniho rohu pixmapy
drawPixmap(pix2); // vykresleni pixmapy
glDisable(GL_BLEND);
glDisable(GL_SCISSOR_TEST);
drawInfo(x1, y1, x2, y2);
glFlush(); // provedeni a vykresleni vsech zmen
glutSwapBuffers();
}
//-----------------------------------------------------------------------------
// Tato callback funkce je zavolana pri tiku casovace
//-----------------------------------------------------------------------------
void onTimer(int value)
{
t++;
glutPostRedisplay();
if (!stop)
glutTimerFunc(100, onTimer, 0);
}
//-----------------------------------------------------------------------------
// 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)
{
if (key>='A' && key<='Z') key+='a'-'A';
if (key>='1' && key<='4') { // nastaveni blendingu
src=key-'1';
return;
}
if (key>='5' && key<='8') { // nastaveni blendingu
dst=key-'5';
return;
}
switch (key) {
case 'q':
case 27: exit(0); break;// pokud byla stlacena klavesa ESC, konec programu
case 's': stop=!stop; if (!stop) glutTimerFunc(100, onTimer, 0); 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
glutTimerFunc(100, onTimer, 0); // registrace funkce volane pri tiku casovace
onInit(); // inicializace vykreslovani
glutMainLoop(); // nekonecna smycka, kde se volaji zaregistrovane funkce
return 0; // navratova hodnota vracena operacnimu systemu
}
//-----------------------------------------------------------------------------
// finito
//-----------------------------------------------------------------------------