// ----------------------------------------------------------------------------
// application: Diffuse demo
// author:      Pavel Tisnovsky
// file name:   Diffuse1.java
// directory:   java
// date:        19.05.2004
// description: Demonstracni aplikace pro vytvoreni a zobrazeni fraktalniho
//              objektu, ktery je zalozeny na simulaci difuze.
// ----------------------------------------------------------------------------



// Nasledujici radky jsou urceny pro spusteni appletu v programu AppletViewer:
//
// <applet code="Diffuse1.class" width="640" height="400">
// </applet>
//
// pro kompatibilitu se starsi JVM firmy Microsoft se musi provest preklad
// pomoci prikazu:
// javac -target 1.1 Diffuse1.java



// ----------------------------------------------------------------------------
// seznam importovanych balicku
// ----------------------------------------------------------------------------
import java.util.*;
import java.awt.*;
import java.awt.image.*;
import java.awt.event.*;
import java.applet.Applet;



// ----------------------------------------------------------------------------
// Trida pro aplikaci filtru na zvolenou zdrojovou pixmapu. Vysledek se uklada
// do cilove pixmapy.
// ----------------------------------------------------------------------------
class Filter {
    private int imageWidth;                         // velikost zpracovavanych pixmap
    private int imageHeight;
    private int pixelSrc[];                         // zdrojova pixmapa
    private int pixelDest[];                        // cilova pixmapa



    // ------------------------------------------------------------------------
    // V konstruktoru se nastavi velikost filtru a zdrojova a cilova pixmapa.
    // ------------------------------------------------------------------------
    public Filter(int imageWidth, int imageHeight, int pixelSrc[], int pixelDest[]) {
        this.imageWidth=imageWidth;                 // nastavit velikost pixmapy
        this.imageHeight=imageHeight;
        this.pixelSrc=pixelSrc;                     // nastavit handle zdrojove
        this.pixelDest=pixelDest;                   // a cilove pixmapy
    }



    // ------------------------------------------------------------------------
    // Nastaveni nove sirky zpracovavane pixmapy.
    // ------------------------------------------------------------------------
    public void setImageWidth(int imageWidth) {
        this.imageWidth=imageWidth;
    }



    // ------------------------------------------------------------------------
    // Nastaveni nove vysky zpracovavane pixmapy.
    // ------------------------------------------------------------------------
    public void setImageHeight(int imageHeight) {
        this.imageHeight=imageHeight;
    }



    // ------------------------------------------------------------------------
    // Nastaveni zdrojove pixmapy.
    // ------------------------------------------------------------------------
    public void setSourceImage(int pixelSrc[]) {
        this.pixelSrc=pixelSrc;
    }



    // ------------------------------------------------------------------------
    // Nastaveni cilove pixmapy.
    // ------------------------------------------------------------------------
    public void setDestinationImage(int pixelDest[]) {
        this.pixelDest=pixelDest;
    }



    // ------------------------------------------------------------------------
    // Ziskani sirky zpracovavanych pixmap.
    // ------------------------------------------------------------------------
    public int getImageWidth() {
        return imageWidth;
    }



    // ------------------------------------------------------------------------
    // Ziskani vysky zpracovavanych pixmap.
    // ------------------------------------------------------------------------
    public int getImageHeight() {
        return imageHeight;
    }



    // ------------------------------------------------------------------------
    // Ziskani zdrojove pixmapy.
    // ------------------------------------------------------------------------
    public int[] getSourceImage() {
        return pixelSrc;
    }



    // ------------------------------------------------------------------------
    // Ziskani cilove pixmapy.
    // ------------------------------------------------------------------------
    public int[] getDestinationImage() {
        return pixelDest;
    }



    // ------------------------------------------------------------------------
    // Tato metoda provede filtraci pixmapy s filtrem typu:
    // zadny filtr, pouze kopie zdrojove pixmapy do cilove pixmapy.
    // ------------------------------------------------------------------------
    public void filterNone() {
        int pos=0;
        for (int j=0; j<imageHeight; j++) {         // pro vsechny radky pixmapy
            for (int i=0; i<imageWidth; i++) {      // pro vsechny pixely na radku
                pixelDest[pos]=0xffffffff;          // provest vymazani pixelu
                pos++;
            }
        }
    }



    // ------------------------------------------------------------------------
    // Tato metoda provede filtraci pixmapy s filtrem typu:
    // rozmazani v bloku 2x2 pixely s vyberem ve tvaru bloku.
    // ------------------------------------------------------------------------
    public void filter2x2smooth() {
        int pos=0;                                  // index do zdrojove a cilove pixmapy
        int color;                                  // RGBA barvove slozky zakodovane do typu int
        int r, g, b;                                // jednotlive rozkodovane barvove slozky
        filterNone();                               // nejprve pixmapy zkopirovat
        for (int j=0; j<imageHeight-1; j++) {       // pro vsechny radky pixmapy
            for (int i=0; i<imageWidth-1; i++) {    // pro vsechny sloupce na radku pixmapy
                color=pixelSrc[pos];
                r =(color & 0x00ff0000)>>16;
                g =(color & 0x0000ff00)>>8;
                b =(color & 0x000000ff);
                color=pixelSrc[pos+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+imageWidth];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+imageWidth+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                r/=4; g/=4; b/=4;                   // provest filtraci
                pixelDest[pos]=(r<<16) | (g<<8) | b | (0xff<<24);
                pos++;
            }
        }
    }



    // ------------------------------------------------------------------------
    // Tato metoda provede filtraci pixmapy s filtrem typu:
    // rozmazani v bloku 3x3 pixely s vyberem ve tvaru diamantu.
    // ------------------------------------------------------------------------
    public void filter3x3diamond() {
        int pos=0;                                  // index do zdrojove a cilove pixmapy
        int color;                                  // RGBA barvove slozky zakodovane do typu int
        int r, g, b;                                // jednotlive rozkodovane barvove slozky
        filterNone();                               // nejprve pixmapy zkopirovat
        pos=1+imageWidth;
        for (int j=1; j<imageHeight-1; j++) {       // pro vsechny radky pixmapy
            for (int i=1; i<imageWidth-1; i++) {    // pro vsechny sloupce na radku pixmapy
                color=pixelSrc[pos-imageWidth];
                r =(color & 0x00ff0000)>>16;
                g =(color & 0x0000ff00)>>8;
                b =(color & 0x000000ff);
                color=pixelSrc[pos-1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+imageWidth];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                r/=4; g/=4; b/=4;                   // provest filtraci
                pixelDest[pos]=(r<<16) | (g<<8) | b | (0xff<<24);
                pos++;
            }
        }
    }



    // ------------------------------------------------------------------------
    // Tato metoda provede filtraci pixmapy s filtrem typu:
    // rozmazani v bloku 3x3 pixely s vyberem ve tvaru osoveho krize.
    // ------------------------------------------------------------------------
    public void filter3x3cross() {
        int pos=0;                                  // index do zdrojove a cilove pixmapy
        int color;                                  // RGBA barvove slozky zakodovane do typu int
        int r, g, b;                                // jednotlive rozkodovane barvove slozky
        filterNone();                               // nejprve pixmapy zkopirovat
        pos=1+imageWidth;
        for (int j=1; j<imageHeight-1; j++) {       // pro vsechny radky pixmapy
            for (int i=1; i<imageWidth-1; i++) {    // pro vsechny sloupce na radku pixmapy
                color=pixelSrc[pos-imageWidth];
                r =(color & 0x00ff0000)>>16;
                g =(color & 0x0000ff00)>>8;
                b =(color & 0x000000ff);
                color=pixelSrc[pos-1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+imageWidth];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                r/=5; g/=5; b/=5;                   // provest filtraci
                pixelDest[pos]=(r<<16) | (g<<8) | b | (0xff<<24);
                pos++;
            }
        }
    }



    // ------------------------------------------------------------------------
    // Tato metoda provede filtraci pixmapy s filtrem typu:
    // rozmazani v bloku 3x3 pixelu s vyberem ve tvaru uhlopricneho krize.
    // ------------------------------------------------------------------------
    public void filter3x3Xcross() {
        int pos=0;                                  // index do zdrojove a cilove pixmapy
        int color;                                  // RGBA barvove slozky zakodovane do typu int
        int r, g, b;                                // jednotlive rozkodovane barvove slozky
        filterNone();                               // nejprve pixmapy zkopirovat
        pos=1+imageWidth;
        for (int j=1; j<imageHeight-1; j++) {       // pro vsechny radky pixmapy
            for (int i=1; i<imageWidth-1; i++) {    // pro vsechny sloupce na radku pixmapy
                color=pixelSrc[pos-imageWidth-1];
                r =(color & 0x00ff0000)>>16;
                g =(color & 0x0000ff00)>>8;
                b =(color & 0x000000ff);
                color=pixelSrc[pos-imageWidth+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+imageWidth-1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-imageWidth+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                r/=5; g/=5; b/=5;                   // provest filtraci
                pixelDest[pos]=(r<<16) | (g<<8) | b | (0xff<<24);
                pos++;
            }
        }
    }



    // ------------------------------------------------------------------------
    // Tato metoda provede filtraci pixmapy s filtrem typu:
    // rozmazani v bloku 3x3 pixelu s blokovym vyberem.
    // ------------------------------------------------------------------------
    public void filter3x3block() {
        int pos=0;                                  // index do zdrojove a cilove pixmapy
        int color;                                  // RGBA barvove slozky zakodovane do typu int
        int r, g, b;                                // jednotlive rozkodovane barvove slozky
        filterNone();                               // nejprve pixmapy zkopirovat
        pos=1+imageWidth;
        for (int j=1; j<imageHeight-1; j++) {       // pro vsechny radky pixmapy
            for (int i=1; i<imageWidth-1; i++) {    // pro vsechny sloupce na radku pixmapy
                color=pixelSrc[pos-imageWidth-1];
                r =(color & 0x00ff0000)>>16;
                g =(color & 0x0000ff00)>>8;
                b =(color & 0x000000ff);
                color=pixelSrc[pos-imageWidth];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-imageWidth+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+imageWidth-1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+imageWidth];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-imageWidth+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                r/=9; g/=9; b/=9;                   // provest filtraci
                pixelDest[pos]=(r<<16) | (g<<8) | b | (0xff<<24);
                pos++;
            }
        }
    }



    // ------------------------------------------------------------------------
    // Tato metoda provede filtraci pixmapy s filtrem typu:
    // rozmazani v bloku 5x5 pixelu s vyberem ve tvaru diamantu.
    // ------------------------------------------------------------------------
    public void filter5x5diamond() {
        int pos=0;                                  // index do zdrojove a cilove pixmapy
        int color;                                  // RGBA barvove slozky zakodovane do typu int
        int r, g, b;                                // jednotlive rozkodovane barvove slozky
        filterNone();                               // nejprve pixmapy zkopirovat
        pos=2+2*imageWidth;
        for (int j=2; j<imageHeight-2; j++) {       // pro vsechny radky pixmapy
            for (int i=2; i<imageWidth-2; i++) {    // pro vsechny sloupce na radku pixmapy
                color=pixelSrc[pos-2*imageWidth+0];
                r =(color & 0x00ff0000)>>16;
                g =(color & 0x0000ff00)>>8;
                b =(color & 0x000000ff);
                color=pixelSrc[pos-  imageWidth-1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-  imageWidth+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-2];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+2];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+  imageWidth-1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+  imageWidth+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+2*imageWidth+0];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                r/=8; g/=8; b/=8;                   // provest filtraci
                pixelDest[pos]=(r<<16) | (g<<8) | b | (0xff<<24);
                pos++;
            }
        }
    }



    // ------------------------------------------------------------------------
    // Tato metoda provede filtraci pixmapy s filtrem typu:
    // rozmazani v bloku 5x5 pixelu s vyberem ve tvaru osoveho krize.
    // ------------------------------------------------------------------------
    public void filter5x5cross() {
        int pos=0;                                  // index do zdrojove a cilove pixmapy
        int color;                                  // RGBA barvove slozky zakodovane do typu int
        int r, g, b;                                // jednotlive rozkodovane barvove slozky
        filterNone();                               // nejprve pixmapy zkopirovat
        pos=2+2*imageWidth;
        for (int j=2; j<imageHeight-2; j++) {       // pro vsechny radky pixmapy
            for (int i=2; i<imageWidth-2; i++) {    // pro vsechny sloupce na radku pixmapy
                color=pixelSrc[pos-2*imageWidth+0];
                r =(color & 0x00ff0000)>>16;
                g =(color & 0x0000ff00)>>8;
                b =(color & 0x000000ff);
                color=pixelSrc[pos-  imageWidth+0];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-2];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+2];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+  imageWidth+0];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+2*imageWidth+0];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                r/=9; g/=9; b/=9;                   // provest filtraci
                pixelDest[pos]=(r<<16) | (g<<8) | b | (0xff<<24);
                pos++;
            }
        }
    }



    // ------------------------------------------------------------------------
    // Tato metoda provede filtraci pixmapy s filtrem typu:
    // rozmazani v bloku 5x5 pixelu s vyberem ve tvaru uhlopricneho krize.
    // ------------------------------------------------------------------------
    public void filter5x5Xcross() {
        int pos=0;                                  // index do zdrojove a cilove pixmapy
        int color;                                  // RGBA barvove slozky zakodovane do typu int
        int r, g, b;                                // jednotlive rozkodovane barvove slozky
        filterNone();                               // nejprve pixmapy zkopirovat
        pos=2+2*imageWidth;
        for (int j=2; j<imageHeight-2; j++) {       // pro vsechny radky pixmapy
            for (int i=2; i<imageWidth-2; i++) {    // pro vsechny sloupce na radku pixmapy
                color=pixelSrc[pos-2*imageWidth-2];
                r =(color & 0x00ff0000)>>16;
                g =(color & 0x0000ff00)>>8;
                b =(color & 0x000000ff);
                color=pixelSrc[pos-2*imageWidth+2];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-  imageWidth-1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-  imageWidth+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+  imageWidth-1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+  imageWidth+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+2*imageWidth-2];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+2*imageWidth+2];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                r/=9; g/=9; b/=9;                   // provest filtraci
                pixelDest[pos]=(r<<16) | (g<<8) | b | (0xff<<24);
                pos++;
            }
        }
    }



    // ------------------------------------------------------------------------
    // Tato metoda provede filtraci pixmapy s filtrem typu:
    // rozmazani v bloku 5x5 pixelu s vyberem ve tvaru bloku.
    // ------------------------------------------------------------------------
    public void filter5x5block() {
        int pos=0;                                  // index do zdrojove a cilove pixmapy
        int color;                                  // RGBA barvove slozky zakodovane do typu int
        int r, g, b;                                // jednotlive rozkodovane barvove slozky
        filterNone();                               // nejprve pixmapy zkopirovat
        pos=2+2*imageWidth;
        for (int j=2; j<imageHeight-2; j++) {       // pro vsechny radky pixmapy
            for (int i=2; i<imageWidth-2; i++) {    // pro vsechny sloupce na radku pixmapy
                color=pixelSrc[pos-2*imageWidth-2];
                r =(color & 0x00ff0000)>>16;
                g =(color & 0x0000ff00)>>8;
                b =(color & 0x000000ff);
                color=pixelSrc[pos-2*imageWidth-1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-2*imageWidth+0];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-2*imageWidth+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-2*imageWidth+2];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-  imageWidth-2];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-  imageWidth-1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-  imageWidth+0];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-  imageWidth+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-  imageWidth+2];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-2];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos-1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+2];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+  imageWidth-2];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+  imageWidth-1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+  imageWidth+0];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+  imageWidth+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+  imageWidth+2];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+2*imageWidth-2];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+2*imageWidth-1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+2*imageWidth+0];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+2*imageWidth+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+2*imageWidth+2];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                r/=25; g/=25; b/=25;                // provest filtraci
                pixelDest[pos]=(r<<16) | (g<<8) | b | (0xff<<24);
                pos++;
            }
        }
    }



    // ------------------------------------------------------------------------
    // Tato metoda provede filtraci pixmapy s filtrem typu:
    // horizontalni filtr rozmazani tri pixelu.
    // ------------------------------------------------------------------------
    public void filter3pixelsH() {
        int pos=0;                                  // index do zdrojove a cilove pixmapy
        int color;                                  // RGBA barvove slozky zakodovane do typu int
        int r, g, b;                                // jednotlive rozkodovane barvove slozky
        filterNone();                               // nejprve pixmapy zkopirovat
        pos=1;
        for (int j=0; j<imageHeight; j++) {         // pro vsechny radky pixmapy
            for (int i=1; i<imageWidth-1; i++) {    // pro vsechny sloupce na radku pixmapy
                color=pixelSrc[pos-1];
                r =(color & 0x00ff0000)>>16;
                g =(color & 0x0000ff00)>>8;
                b =(color & 0x000000ff);
                color=pixelSrc[pos];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                r/=3; g/=3; b/=3;                   // provest filtraci
                pixelDest[pos]=(r<<16) | (g<<8) | b | (0xff<<24);
                pos++;
            }
        }
    }



    // ------------------------------------------------------------------------
    // Tato metoda provede filtraci pixmapy s filtrem typu:
    // vertikalni filtr rozmazani tri pixelu.
    // ------------------------------------------------------------------------
    public void filter3pixelsV() {
        int pos=0;                                  // index do zdrojove a cilove pixmapy
        int color;                                  // RGBA barvove slozky zakodovane do typu int
        int r, g, b;                                // jednotlive rozkodovane barvove slozky
        filterNone();                               // nejprve pixmapy zkopirovat
        pos=imageWidth;
        for (int j=1; j<imageHeight-1; j++) {       // pro vsechny radky pixmapy
            for (int i=0; i<imageWidth; i++) {      // pro vsechny sloupce na radku pixmapy
                color=pixelSrc[pos-imageWidth];
                r =(color & 0x00ff0000)>>16;
                g =(color & 0x0000ff00)>>8;
                b =(color & 0x000000ff);
                color=pixelSrc[pos];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+imageWidth];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                r/=3; g/=3; b/=3;                   // provest filtraci
                pixelDest[pos]=(r<<16) | (g<<8) | b | (0xff<<24);
                pos++;
            }
        }
    }



    // ------------------------------------------------------------------------
    // Tato metoda provede filtraci pixmapy s filtrem typu:
    // horizontalni filtr rozmazani peti pixelu.
    // ------------------------------------------------------------------------
    public void filter5pixelsH() {
        int pos=0;                                  // index do zdrojove a cilove pixmapy
        int color;                                  // RGBA barvove slozky zakodovane do typu int
        int r, g, b;                                // jednotlive rozkodovane barvove slozky
        filterNone();                               // nejprve pixmapy zkopirovat
        pos=2;
        for (int j=0; j<imageHeight; j++) {         // pro vsechny radky pixmapy
            for (int i=2; i<imageWidth-2; i++) {    // pro vsechny sloupce na radku pixmapy
                color=pixelSrc[pos-2];
                r =(color & 0x00ff0000)>>16;
                g =(color & 0x0000ff00)>>8;
                b =(color & 0x000000ff);
                color=pixelSrc[pos-1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+1];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+2];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                r/=5; g/=5; b/=5;                   // provest filtraci
                pixelDest[pos]=(r<<16) | (g<<8) | b | (0xff<<24);
                pos++;
            }
        }
    }



    // ------------------------------------------------------------------------
    // Tato metoda provede filtraci pixmapy s filtrem typu:
    // vertikalni filtr rozmazani peti pixelu.
    // ------------------------------------------------------------------------
    public void filter5pixelsV() {
        int pos=0;                                  // index do zdrojove a cilove pixmapy
        int color;                                  // RGBA barvove slozky zakodovane do typu int
        int r, g, b;                                // jednotlive rozkodovane barvove slozky
        filterNone();                               // nejprve pixmapy zkopirovat
        pos=2*imageWidth;
        for (int j=2; j<imageHeight-2; j++) {       // pro vsechny radky pixmapy
            for (int i=0; i<imageWidth; i++) {      // pro vsechny sloupce na radku pixmapy
                color=pixelSrc[pos-2*imageWidth];
                r =(color & 0x00ff0000)>>16;
                g =(color & 0x0000ff00)>>8;
                b =(color & 0x000000ff);
                color=pixelSrc[pos-  imageWidth];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+  imageWidth];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                color=pixelSrc[pos+2*imageWidth];
                r+=(color & 0x00ff0000)>>16;
                g+=(color & 0x0000ff00)>>8;
                b+=(color & 0x000000ff);
                r/=5; g/=5; b/=5;                   // provest filtraci
                pixelDest[pos]=(r<<16) | (g<<8) | b | (0xff<<24);
                pos++;
            }
        }
    }
}
// ----------------------------------------------------------------------------
// Konec tridy Filter.
// ----------------------------------------------------------------------------



// ----------------------------------------------------------------------------
// Trida s panelem, na kterem se zobrazuje pixmapa o predem danem rozmeru.
// ----------------------------------------------------------------------------
class ImagePanel extends Canvas {
    int               width;                        // rozmery pixmapy
    int               height;
    public int[]      pixels;                       // pixmapa - zdroj pixelu
    MemoryImageSource imageSource;                  // objekt zaobalujici zdroj pixelu
    Image             image;                        // pixmapa vytvorena nad zdrojem pixelu



    // ------------------------------------------------------------------------
    // V konstruktoru se nastavi velikost panelu a soucasne barva jeho pozadi.
    // ------------------------------------------------------------------------
    public ImagePanel(int width, int height) {
        pixels=new int[width*height];
        for (int j=0; j<height; j++)                // pro vsechny radky pixmapy
            for (int i=0; i<width; i++)             // pro vsechny sloupce pixmapy
                pixels[i+j*width]=0xffffffff;       // vyplnit pixmapu i s alfa kanalem
        imageSource=new MemoryImageSource(width, height, pixels, 0, height);
        image=createImage(imageSource);             // vytvoreni pixmapy
        this.width=width;                           // nastaveni velikosti pixmapy
        this.height=height;
        this.setBackground(Color.white);            // nastaveni vlastnosti panelu
        this.setSize(width, height);
    }



    // ------------------------------------------------------------------------
    // Pristup k jednotlivym pixelum pixmapy.
    // ------------------------------------------------------------------------
    public void putpixel(int x, int y, int r, int g, int b) {
        pixels[x+y*width]=r+(g<<8)+(b<<16)+(255<<24);
    }



    // ------------------------------------------------------------------------
    // Aplikaci dostupne prekresleni celeho panelu s volbou vymazu stare kresby.
    // ------------------------------------------------------------------------
    public void redraw(boolean clear) {
        Graphics g=this.getGraphics();
        if (clear)                                  // premazat starou kresbu
            g.clearRect(0, 0, width, height);
        image.flush();                              // prenest pixely do obrazu
        g.drawImage(image, 0, 0, this);             // a vykreslit obraz s pixmapou
    }



    // ------------------------------------------------------------------------
    // Prekresleni panelu s pixmapou.
    // ------------------------------------------------------------------------
    public void paint(Graphics g) {
        g.drawImage(image, 0, 0, this);             // vykreslit obraz s pixmapou
    }
}
// ----------------------------------------------------------------------------
// Konec tridy ImagePanel.
// ----------------------------------------------------------------------------



// ----------------------------------------------------------------------------
// Trida s kodem pro zobrazeni napovedy.
// ----------------------------------------------------------------------------
class WindowHelp extends Frame implements ActionListener {
    static boolean visible=false;                   // priznak indikujici zobrazeni napovedy



    // ------------------------------------------------------------------------
    // Konstrukce okna s napovedou.
    // ------------------------------------------------------------------------
    public WindowHelp() {
        TextArea text=new TextArea(
            "1. choose point shape\n"+
            "2. choose seed (starting points) shape\n"+
            "3. adjust number of points\n"+
            "4. set filter type\n"+
            "5. set stop condition and neighbourhood type\n"+
            "6. then press the 'Recalc' button\n"+
            "7. apply filter with 'Redraw' button"
        );
        visible=true;
        Button buttonOK=new Button("ok");
        Label  label=new Label("How to work with this applet:");
        buttonOK.addActionListener(this);           // po stlaceni tlacitka se ma napoveda zavrit
        this.setSize(320, 240);                     // nastaveni velikosti a rozmeru okna
        this.setLocation(100, 100);
        this.setTitle("Diffuse 1 - Help");          // zobrazeni titulku
        this.add("Center", text);                   // a pridani vsech ovladacich prvku
        this.add("South", buttonOK);
        this.add("North", label);
        this.setVisible(true);
    }



    // ------------------------------------------------------------------------
    // Reakce na stlaceni tlacitka s textem OK.
    // ------------------------------------------------------------------------
    public void actionPerformed(ActionEvent e) {
        visible=false;
        this.dispose();
    }
}
// ----------------------------------------------------------------------------
// Konec tridy WindowHelp.
// ----------------------------------------------------------------------------



// ----------------------------------------------------------------------------
// Trida s kodem pro zobrazeni informaci o aplikaci.
// ----------------------------------------------------------------------------
class WindowAbout extends Frame implements ActionListener {
    static boolean visible=false;                   // priznak indikujici zobrazeni okna



    // ------------------------------------------------------------------------
    // Konstrukce okna s informaci o aplikaci.
    // ------------------------------------------------------------------------
    public WindowAbout() {
        TextArea text=new TextArea(
            "Diffuse 1 demo\n\n"+
            "version 1.0\n"+
            "Author: Pavel Tisnovsky\n"+
            "Date: 2004-05-10\n"+
            "http://www.fit.vutbr.cz/~tisnovpa\n"
        );
        visible=true;
        Button buttonOK=new Button("ok");
        Label  label=new Label("About Diffuse 1");
        buttonOK.addActionListener(this);           // po stlaceni tlacitka se ma okno zavrit
        this.setSize(320, 240);                     // nastaveni velikosti a rozmeru okna
        this.setLocation(100, 100);
        this.setTitle("Diffuse 1 - About");         // zobrazeni titulku
        this.add("Center", text);                   // a pridani vsech ovladacich prvku
        this.add("South", buttonOK);
        this.add("North", label);
        this.setVisible(true);
    }



    // ------------------------------------------------------------------------
    // Reakce na stlaceni tlacitka s textem OK.
    // ------------------------------------------------------------------------
    public void actionPerformed(ActionEvent e) {
        visible=false;
        this.dispose();
    }
}
// ----------------------------------------------------------------------------
// Konec tridy WindowAbout.
// ----------------------------------------------------------------------------



// ----------------------------------------------------------------------------
// Trida s kodem pro zobrazeni informaci o systemu.
// ----------------------------------------------------------------------------
class WindowInfo extends Frame implements ActionListener {
    static boolean visible=false;                   // priznak indikujici zobrazeni okna



    // ------------------------------------------------------------------------
    // Konstrukce okna s informacemi.
    // ------------------------------------------------------------------------
    public WindowInfo() {
        Runtime r=Runtime.getRuntime();             // ziskat objekt s informacemi o aplikaci
        TextArea text=new TextArea("");
        text.append("Total memory: "+r.totalMemory()+"\n");
        text.append("Free memory: "+r.freeMemory()+"\n");
        visible=true;
        Button buttonOK=new Button("ok");
        Label  label=new Label("System informations:");
        buttonOK.addActionListener(this);           // po stlaceni tlacitka se ma okno zavrit
        this.setSize(320, 240);                     // nastaveni velikosti a rozmeru okna
        this.setLocation(100, 100);
        this.setTitle("Diffuse 1 - Info");          // zobrazeni titulku
        this.add("Center", text);                   // a pridani vsech ovladacich prvku
        this.add("South", buttonOK);
        this.add("North", label);
        this.setVisible(true);
    }



    // ------------------------------------------------------------------------
    // Reakce na stlaceni tlacitka s textem OK.
    // ------------------------------------------------------------------------
    public void actionPerformed(ActionEvent e) {
        visible=false;
        this.dispose();
    }
}
// ----------------------------------------------------------------------------
// Konec tridy WindowInfo.
// ----------------------------------------------------------------------------



// ----------------------------------------------------------------------------
// Rozhrani s tvary seminek.
// ----------------------------------------------------------------------------
interface SeedShape {
    int OnePoint=     0,                            // seminko ve tvaru jednoho bodu
        TwoPoints=    1,                            // dva body na usecce
        ThreePoints=  2,                            // tri body ve vrcholech trojuhelnika
        FourPoints=   3,                            // ctyri body ve vrcholech ctverce
        Line=         4,                            // cela usecka
        BottomLine=   5,                            // usecka ve spodni casti obrazce
        Square=       6,                            // ctverec
        Border=       7,                            // ctverec az k okrajum bitmapy
        SmallCircle=  8,                            // mala kruznice
        NormalCircle= 9,                            // normalni kruznice
        BigCircle=   10;                            // vetsi kruznice
}
// ----------------------------------------------------------------------------
// Konec rozhrani SeedShape.
// ----------------------------------------------------------------------------



// ----------------------------------------------------------------------------
// Rozhrani s tvary bodu.
// ----------------------------------------------------------------------------
interface PointShape {
    int OnePixel=   0,                              // bod ma tvar jednoho pixelu
        Cross3x3=   1,                              // pet pixelu ve tvaru krize
        XCross3x3=  2,                              // pet pixelu ve tvaru uhlopricneho krize
        Diamond3x3= 3,                              // ctyri pixely ve tvaru diamantu
        Block3x3=   4,                              // blok deviti pixelu
        Cross5x5=   5,                              // dtto pro okoli 5x5
        XCross5x5=  6,
        Diamond5x5= 7,
        Block5x5=   8,
        Horizontal3=9,                              // tri pixely vedle sebe
        Horizontal5=10,                             // pet pixelu vedle sebe
        Vertical3=  11,                             // tri pixely pod sebou
        Vertical5=  12;                             // pet pixelu pod sebou
}
// ----------------------------------------------------------------------------
// Konec rozhrani PointShape.
// ----------------------------------------------------------------------------



// ----------------------------------------------------------------------------
// Rozhrani se jmeny filtru.
// ----------------------------------------------------------------------------
interface FilterType {
    int None=       0,                              // zadny filtr
        Smooth2x2=  1,                              // filtr typu 2x2 smooth
        Diamond3x3= 2,                              // filtr typu 3x3 diamond
        Cross3x3=   3,                              // filtr typu 3x3 cross
        XCross3x3=  4,                              // filtr typu 3x3 X cross
        Block3x3=   5,                              // filtr typu 3x3 block
        Diamond5x5= 6,                              // filtr typu 5x5 diamond
        Cross5x5=   7,                              // filtr typu 5x5 cross
        XCross5x5=  8,                              // filtr typu 5x5 X cross
        Block5x5=   9,                              // filtr typu 5x5 block
        Horizontal3=10,                             // filtr typu 3 pixels horizontal
        Horizontal5=11,                             // filtr typu 5 pixels horizontal
        Vertical3=  12,                             // filtr typu 3 pixels vertical
        Vertical5=  13;                             // filtr typu 5 pixels vertical
}
// ----------------------------------------------------------------------------
// Konec rozhrani FilterType.
// ----------------------------------------------------------------------------



// ----------------------------------------------------------------------------
// Rozhrani se jmeny podminky pro ukonceni cyklu
// ----------------------------------------------------------------------------
interface StopCondition {
    int Iterations=0,                               // pouze pocet iteraci
        Border=    1,                               // pouze dosazeni okraje
        And=       2,                               // pocet iteraci a dosazeni okraje
        Or=        3;                               // pocet iteraci nebo dosazeni okraje
}
// ----------------------------------------------------------------------------
// Konec rozhrani StopCondition.
// ----------------------------------------------------------------------------



// ----------------------------------------------------------------------------
// V pripade, ze by bylo nutne tento demonstrani program spustit jako Java ap-
// likaci, je mozne odkomentovat metodu "main". V tomto pripade se vsak vytvo-
// ri dalsi soubor .class s anonymni tridou Listener.
// ----------------------------------------------------------------------------
public class Diffuse1 extends Applet implements
        Runnable,
        ActionListener,
        ItemListener,
        AdjustmentListener,
        SeedShape,
        FilterType,
        PointShape,
        StopCondition
{
    static final int ImageWidth=256;                // sirka pixmapy s fraktalem
    static final int ImageHeight=256;               // vyska pixmapy s fraktalem
    static final int DrawingWidth=256;              // sirka kresby pouzivane pro konstrukci fraktalu

    int              points=5000;                   // pocet vsech iteraci
    int              pointShape=PointShape.OnePixel;// typ vykreslovanych bodu
    int              seedShape=SeedShape.OnePoint;  // tvar seminka
    int              filterType=FilterType.Cross3x3;// typ pouziteho filtru
    int              stopCondition=StopCondition.Iterations;// zpusob ukonceni generovani fraktalu
    boolean          neighboorType=false;           // typ okoli pixelu

    // vytvoreni vsech panelu pouzitych v appletu
    ImagePanel  panelLeft=           new ImagePanel(ImageWidth, ImageHeight);
    ImagePanel  panelCenter=         new ImagePanel(ImageWidth, ImageHeight);
    Panel       panelUp=             new Panel(new GridLayout(2, 5, 5, 5));// horni panel s list-boxy
    Panel       panelDown=           new Panel(new GridLayout(2, 1, 5, 5));// dolni panel s posuvniky
    Panel       panelRight=          new Panel(new GridLayout(8, 1));// pravy panel s tlacitky

    // filtr aplikovany na zdrojovou pixmapu, vysledek je v cilove pixmape
    Filter filter=new Filter(ImageWidth, ImageHeight, panelLeft.pixels, panelCenter.pixels);

    // objekt, ve kterem je implementovan algoritmus difuze
    Diffuser diffuser=null;

    // vytvoreni vsech textovych navesti pouzitych v appletu
    Label       labelPointShape=        new Label("Point shape");
    Label       labelSeedShape=         new Label("Seed shape");
    Label       labelNeighbourHoodType= new Label("Neighbourhood type");
    Label       labelStopCondition=     new Label("Stop condition");
    Label       labelFilterType=        new Label("Filter");
    Label       labelPoints=            new Label("Points: "+String.valueOf(points));

    // vytvoreni vsech list-boxu pouzitych v appletu
    Choice      choicePointShape=       new Choice();  // list-box pro vyber tvaru bodu
    Choice      choiceSeedShape=        new Choice();  // list-box pro vyber tvaru seminka
    Choice      choiceNeigbourhoodType= new Choice();  // list-box pro vyber okoli pixelu
    Choice      choiceStopCondition=    new Choice();  // list-box pro vyber koncove podminky
    Choice      choiceFilter=           new Choice();  // list-box pro vyber aktivniho filtru

    // vytvoreni vsech tlacitek pouzitych v appletu
    Button      buttonRedraw=           new Button("Redraw");
    Button      buttonRecalc=           new Button("Recalc");
    Button      buttonAbout=            new Button("About");
    Button      buttonInfo=             new Button("Info");
    Button      buttonHelp=             new Button("Help");

    // vytvoreni vsech slideru pouzitych v appletu
    Scrollbar   scrollBarPoints=        new Scrollbar(Scrollbar.HORIZONTAL, points, 1000, 100, 100000+1000);



    // ------------------------------------------------------------------------
    // Tato metoda provede inicializaci horniho panelu s rolovacimi list-boxy.
    // Metoda je zavolana behem inicializace aplikace ci appletu.
    // ------------------------------------------------------------------------
    private void initPanelUp() {
        panelUp.setBackground(Color.white);         // nastaveni barvy pozadi

        panelUp.add(labelPointShape);               // pridani vsech textovych navesti
        panelUp.add(labelSeedShape);                // do horniho panelu
        panelUp.add(labelNeighbourHoodType);
        panelUp.add(labelStopCondition);
        panelUp.add(labelFilterType);

        panelUp.add(choicePointShape);              // pridani vsech list-boxu
        panelUp.add(choiceSeedShape);
        panelUp.add(choiceNeigbourhoodType);
        panelUp.add(choiceStopCondition);
        panelUp.add(choiceFilter);

        // prace s list-boxem pointShape
        choicePointShape.setEnabled(true);          // naplneni list-boxu texty a povoleni list-boxu
        choicePointShape.add("1 pixel");
        choicePointShape.add("Cross 3x3 pixels");
        choicePointShape.add("X cross 3x3 pixels");
        choicePointShape.add("Diamond 3x3 pixels");
        choicePointShape.add("Block 3x3 pixels");
        choicePointShape.add("Cross 5x5 pixels");
        choicePointShape.add("X cross 5x5 pixels");
        choicePointShape.add("Diamond 5x5 pixels");
        choicePointShape.add("Block 5x5 pixels");
        choicePointShape.add("3 pixels horizontal");
        choicePointShape.add("5 pixels horizontal");
        choicePointShape.add("3 pixels vertical");
        choicePointShape.add("5 pixels vertical");
        choicePointShape.select(pointShape);        // vyber aktivni polozky z list-boxu
        choicePointShape.addItemListener(this);     // nastaveni zpracovani udalosti od list-boxu

        // prace s list-boxem NeighbourhoodType
        choiceNeigbourhoodType.setEnabled(true);    // naplneni list-boxu s typem okoli pixelu
        choiceNeigbourhoodType.add("4 pixels");
        choiceNeigbourhoodType.add("8 pixels");
        choiceNeigbourhoodType.select(0);           // vyber aktivni polozky z list-boxu
        choiceNeigbourhoodType.addItemListener(this);// nastaveni zpracovani udalosti od list-boxu
        
        // prace s list-boxem SeedShape
        choiceSeedShape.setEnabled(true);           // naplneni list-boxu texty a povoleni list-boxu
        choiceSeedShape.add("One point");
        choiceSeedShape.add("Two points");
        choiceSeedShape.add("Three points");
        choiceSeedShape.add("Four points");
        choiceSeedShape.add("Line");
        choiceSeedShape.add("Bottom line");
        choiceSeedShape.add("Square");
        choiceSeedShape.add("Border");
        choiceSeedShape.add("Small circle");
        choiceSeedShape.add("Normal circle");
        choiceSeedShape.add("Big circle");
        choiceSeedShape.select(seedShape);          // vyber aktivni polozky z list-boxu
        choiceSeedShape.addItemListener(this);      // nastaveni zpracovani udalosti od list-boxu

        // prace s list-boxem StopCondition
        choiceStopCondition.setEnabled(true);       // naplneni list-boxu texty a povoleni list-boxu
        choiceStopCondition.add("maxiter");
        choiceStopCondition.add("borders");
        choiceStopCondition.add("maxiter and borders");
        choiceStopCondition.add("maxiter or borders");
        choiceStopCondition.select(0);
        choiceStopCondition.addItemListener(this);  // nastaveni zpracovani udalosti od list-boxu

        // prace s list-boxem Filter
        choiceFilter.setEnabled(true);              // naplneni list-boxu texty a povoleni list-boxu
        choiceFilter.add("none");
        choiceFilter.add("2x2 smooth");
        choiceFilter.add("3x3 diamond");
        choiceFilter.add("3x3 cross");
        choiceFilter.add("3x3 X cross");
        choiceFilter.add("3x3 block");
        choiceFilter.add("5x5 diamond");
        choiceFilter.add("5x5 cross");
        choiceFilter.add("5x5 X cross");
        choiceFilter.add("5x5 block");
        choiceFilter.add("3 pixels horizontal");
        choiceFilter.add("5 pixels horizontal");
        choiceFilter.add("3 pixels vertical");
        choiceFilter.add("5 pixels vertical");
        choiceFilter.select(filterType);            // vyber aktivni polozky z list-boxu
        choiceFilter.addItemListener(this);         // nastaveni zpracovani udalosti od list-boxu
    }



    // ------------------------------------------------------------------------
    // Tato metoda provede inicializaci dolniho panelu se slidery.
    // Metoda je zavolana behem inicializace aplikace ci appletu.
    // ------------------------------------------------------------------------
    private void initPanelDown() {
        panelDown.setBackground(Color.white);       // nastaveni barvy pozadi
        panelDown.add(labelPoints);                 // pridani vsech textovych navesti
        panelDown.add(scrollBarPoints);             // pridani vsech slideru
        scrollBarPoints.addAdjustmentListener(this);// nastaveni reakci na udalosti slideru
    }



    // ------------------------------------------------------------------------
    // Tato metoda provede nastaveni praveho panelu s tlacitky (buttony).
    // Metoda je zavolana behem inicializace aplikace ci appletu.
    // ------------------------------------------------------------------------
    private void initPanelRight() {
        panelRight.setBackground(Color.white);      // nastaveni barvy pozadi
        panelRight.add(buttonRecalc);               // pridani vsech textovych tlacitek
        panelRight.add(buttonRedraw);
        panelRight.add(new Label(""));              // volna polozka pro oddeleni tlacitek
        panelRight.add(buttonAbout);
        panelRight.add(buttonInfo);
        panelRight.add(buttonHelp);
        buttonRedraw.addActionListener(this);       // nastaveni reakce na udalosti od tlacitek
        buttonRecalc.addActionListener(this);
        buttonAbout.addActionListener(this);
        buttonInfo.addActionListener(this);
        buttonHelp.addActionListener(this);
    }



    // ------------------------------------------------------------------------
    // Tato metoda provede inicializaci appletu.
    // Metoda je volana z virtualniho stroje Javy (JVM).
    // ------------------------------------------------------------------------
    public void init() {
        this.setBackground(Color.white);            // nastaveni barvy pozadi
        setLayout(new BorderLayout(5,5));           // nastaveni layoutu aplikace
        initPanelUp();                              // nastavit horni panel
        initPanelDown();                            // nastavit dolni panel
        initPanelRight();                           // nastavit pravy panel
        add("North",  panelUp);                     // pridat horni panel do plochy aplikace
        add("South",  panelDown);                   // pridat dolni panel do plochy aplikace
        add("East",   panelRight);                  // pridat pravy panel do plochy aplikace
        add("Center", panelCenter);                 // pridat centralni panel do plochy aplikace
        add("West",   panelLeft);
    }



    // ------------------------------------------------------------------------
    // Tato metoda se zavola pri destrukci appletu.
    // Metoda je volana z virtualniho stroje Javy (JVM)
    // ------------------------------------------------------------------------
    public void destroy() {
        remove(panelLeft);
        remove(panelRight);                         // zrusit pravy panel
        remove(panelUp);                            // zrusit horni panel
        remove(panelDown);                          // zrusit dolni panel
        remove(panelCenter);                        // zrusit centralni panel
    }



    // ------------------------------------------------------------------------
    // Tato metoda se zavola vzdy pri nastartovani appletu.
    // Metoda je volana z virtualniho stroje Javy (JVM).
    // ------------------------------------------------------------------------
    public void start() {
    }



    // ------------------------------------------------------------------------
    // Tato metoda se zavola pri kazdem zastaveni appletu.
    // Metoda je volana z virtualniho stroje Javy (JVM).
    // ------------------------------------------------------------------------
    public void stop() {
    }



    // ------------------------------------------------------------------------
    // Tato metoda se zavola pri nastartovani appletu.
    // Metoda je volana z virtualniho stroje Javy (JVM).
    // ------------------------------------------------------------------------
    public void run() {
        repaint();                                  // prvotni vykresleni plochy appletu
    }



    // ------------------------------------------------------------------------
    // Tato metoda se zavola vzdy, kdyz je nutno prekreslit plochu appletu.
    // Metoda je volana z virtualniho stroje Javy (JVM).
    // ------------------------------------------------------------------------
    public void update(Graphics g) {
        paint(g);                                   // povolit prekresleni appletu
    }



    // ------------------------------------------------------------------------
    // Tato metoda se zavola kdyz je potreba prekreslit applet.
    // Metoda je volana z virtualniho stroje Javy (JVM).
    // ------------------------------------------------------------------------
    public void paint(Graphics g) {
    }



    // ------------------------------------------------------------------------
    // Nastaveni vnitrnich okraju v okne appletu.
    // Metoda je volana z virtualniho stroje Javy (JVM).
    // ------------------------------------------------------------------------
    public Insets getInsets() {
        return new Insets(5, 5, 5, 5);
    }



    // ------------------------------------------------------------------------
    // Tato metoda je zavolana v pripade, ze je stlaceno nektere tlacitko
    // umistene na plose appletu.
    // Metoda je volana z virtualniho stroje Javy (JVM).
    // ------------------------------------------------------------------------
    public void actionPerformed(ActionEvent e) {
        Object o=e.getSource();                     // ktere tlacitko je stlaceno?
        if (o==buttonRedraw) {                      // ma se pouze prekreslit fraktal
            panelLeft.redraw(false);
            applyFilter();
            panelCenter.redraw(false);
        }
        if (o==buttonRecalc) {                      // prepocitani celeho fraktalu
            recalcFractal();
        }
        if (o==buttonAbout) {                       // text s informacemi o autorech
            if (!WindowAbout.visible) {
                WindowAbout window=new WindowAbout();
            }
        }
        if (o==buttonHelp) {                        // text s napovedou
            if (!WindowHelp.visible) {
                WindowHelp window=new WindowHelp();
            }
        }
        if (o==buttonInfo) {                        // text s informacemi o aplikaci
            if (!WindowInfo.visible) {
                WindowInfo window=new WindowInfo();
            }
        }
    }



    // ------------------------------------------------------------------------
    // Tato metoda je zavolana v pripade, ze je vybran prvek z list-boxu
    // umisteneho na plose appletu.
    // Metoda je volana z virtualniho stroje Javy (JVM).
    // ------------------------------------------------------------------------
    public void itemStateChanged(ItemEvent e) {
        Object o=e.getSource();                     // ziskat informace, ktery list-box je zmenen
        if (o==choicePointShape) {
            pointShape=choicePointShape.getSelectedIndex();
        }
        if (o==choiceSeedShape) {
            seedShape=choiceSeedShape.getSelectedIndex();
        }
        if (o==choiceFilter) {                      // uzivatel zmenil filtr aplikovany na obrazek
            filterType=choiceFilter.getSelectedIndex();// ziskat index vybraneho filtru
            applyFilter();
            panelCenter.redraw(false);
        }
        if (o==choiceStopCondition) {               // uzivatel zmenil pocet aktivnich vertexu
            stopCondition=choiceStopCondition.getSelectedIndex();
        }
        if (o==choiceNeigbourhoodType) {            // uzivatel zmenil typ okoli pixelu
            neighboorType=(choiceNeigbourhoodType.getSelectedIndex()==1);
        }
    }



    // ------------------------------------------------------------------------
    // Tato metoda je zavolana v pripade, ze uzivatel zmenil polohu nektereho
    // posuvniku (slideru) umisteneho na plose appletu.
    // Metoda je volana z virtualniho stroje Javy (JVM).
    // ------------------------------------------------------------------------
    public void adjustmentValueChanged(AdjustmentEvent e) {
        Object o=e.getSource();                     // ziskat slider, ktery byl zmenen
        if (o==scrollBarPoints) {                   // zmena poctu iteraci
            points=scrollBarPoints.getValue();      // ziskat pocet iteraci
            labelPoints.setText("Points: "+String.valueOf(points));
        }
    }



    // ------------------------------------------------------------------------
    // Tato metoda zmeni aktualni filtr.
    // ------------------------------------------------------------------------
    public void applyFilter() {
        switch (filterType) {
            case FilterType.None:       filter.filterNone();       break; // zadny filtr
            case FilterType.Smooth2x2:  filter.filter2x2smooth();  break; // filtr typu 2x2 smooth
            case FilterType.Diamond3x3: filter.filter3x3diamond(); break; // filtr typu 3x3 diamond
            case FilterType.Cross3x3:   filter.filter3x3cross();   break; // filtr typu 3x3 cross
            case FilterType.XCross3x3:  filter.filter3x3Xcross();  break; // filtr typu 3x3 X cross
            case FilterType.Block3x3:   filter.filter3x3block();   break; // filtr typu 3x3 block
            case FilterType.Diamond5x5: filter.filter5x5diamond(); break; // filtr typu 5x5 diamond
            case FilterType.Cross5x5:   filter.filter5x5cross();   break; // filtr typu 5x5 cross
            case FilterType.XCross5x5:  filter.filter5x5Xcross();  break; // filtr typu 5x5 X cross
            case FilterType.Block5x5:   filter.filter5x5block();   break; // filtr typu 5x5 block
            case FilterType.Horizontal3:filter.filter3pixelsH();   break; // filtr typu 3 pixels horizontal
            case FilterType.Horizontal5:filter.filter5pixelsH();   break; // filtr typu 5 pixels horizontal
            case FilterType.Vertical3:  filter.filter3pixelsV();   break; // filtr typu 3 pixels vertical
            case FilterType.Vertical5:  filter.filter5pixelsV();   break; // filtr typu 5 pixels vertical
            default:                                               break; // tato volba by nemela nikdy nastat
        }
    }



    // ------------------------------------------------------------------------
    // Tato metoda provede prepocet fraktalu.
    // ------------------------------------------------------------------------
    private void recalcFractal() {
        if (diffuser!=null) {
            if (diffuser.isAlive()) 
                return;
        }
        diffuser=new Diffuser();                // vytvorit diffuser
        diffuser.setPixels(panelLeft.pixels);   // nastavit jeho parametry
        diffuser.setSize(ImageWidth, ImageHeight);
        diffuser.setMaxPoints(points);
        diffuser.setStopCondition(stopCondition);
        diffuser.setPointShape(pointShape);
        diffuser.setSeedShape(seedShape);
        diffuser.setNeighbourhoodType(neighboorType);
        diffuser.setObject(this);
        diffuser.start();                       // a spustit ho
    }



    // -----------------------------------------------------------------------
    // Metoda main, ktera neni v appletu vyuzita.
    // Muze se definovat v pripade, ze se ma vytvorit samostatne spustitelna
    // aplikace interpretovana virtualnim strojem jazyja Java, nikoli applet.
    // V tomto pripade se vsak vytvori dalsi soubor .class s anonymni tridou
    // se jmenem Listener.
    // -----------------------------------------------------------------------
    public static void main(String[] args) {
        Frame frame=new Frame("Diffuse1");
        Applet applet=new Diffuse1();
        frame.add(applet);
        applet.init();
        frame.setSize(640, 480);
        frame.setVisible(true);
        frame.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
            }
        );
    }
}
// ----------------------------------------------------------------------------
// Konec tridy Diffuse1.
// ----------------------------------------------------------------------------



// ----------------------------------------------------------------------------
// Trida, ve krere je implementovan algoritmus simulace difuze.
// ----------------------------------------------------------------------------
class Diffuser extends Thread {
    Frame      frame=null;                          // okno pro vypis prubehu prace
    Label      label=null;                          // do tohoto labelu se bude provadet vypis
    int        pixelSrc[];                          // pixmapa pro vykreslovani
    int        width;                               // velikost pixmapy
    int        height;
    int        maxPoints;                           // max. pocet bodu
    int        pointShape;                          // typ vykreslovych bodu
    int        seedShape;                           // tvar seminka
    int        stopCondition;                       // podminka pro ukonceni generovani
    boolean    neighboorType;                       // typ okoli pixelu
    boolean    pixels[][];                          // pomocna mrizka, ve ktere se bude generovat
    Diffuse1   object;                              // objekt s panely, do kterych se kresli



    // -----------------------------------------------------------------------
    // Konstruktor, ve kterem se nastavi vhodne implicitni hodnoty.
    // -----------------------------------------------------------------------
    public Diffuser() {
        pixelSrc=null;
        width=height=100;
        maxPoints=100;
        pointShape=seedShape=0;
        stopCondition=StopCondition.Iterations;
        neighboorType=false;
        pixels=null;
    }



    // -----------------------------------------------------------------------
    // Nastaveni pixmapy, do ktere se bude provadet vykreslovani
    // -----------------------------------------------------------------------
    public void setPixels(int pixels[]) {
        pixelSrc=pixels;
    }



    // -----------------------------------------------------------------------
    // Nastaveni rozmeru generovane pixmapy.
    // -----------------------------------------------------------------------
    public void setSize(int width, int height) {
        this.width=width;
        this.height=height;
    }



    // -----------------------------------------------------------------------
    // Nastaveni maximalniho poctu bodu v pixmape.
    // -----------------------------------------------------------------------
    public void setMaxPoints(int maxPoints) {
        this.maxPoints=maxPoints;
    }



    // -----------------------------------------------------------------------
    // Nastaveni podminky pro ukonceni generovani fraktalu.
    // -----------------------------------------------------------------------
    public void setStopCondition(int stopCondition) {
        this.stopCondition=stopCondition;
    }



    // -----------------------------------------------------------------------
    // Nastaveni typu okoli pixelu, na kterem se provadi testy.
    // -----------------------------------------------------------------------
    public void setNeighbourhoodType(boolean neighboorType) {
        this.neighboorType=neighboorType;
    }



    // -----------------------------------------------------------------------
    // Nastaveni tvaru, ktery se bude ukladat do pracovni bitmapy.
    // -----------------------------------------------------------------------
    public void setPointShape(int pointShape) {
        this.pointShape=pointShape;
    }



    // -----------------------------------------------------------------------
    // Nastaveni seminka - pocatecnich bodu fraktalniho obrazce.
    // -----------------------------------------------------------------------
    public void setSeedShape(int seedShape) {
        this.seedShape=seedShape;
    }



    // -----------------------------------------------------------------------
    // Predani reference hlavniho GUI objektu.
    // -----------------------------------------------------------------------
    public void setObject(Diffuse1 o) {
        object=o;
    }



    // -----------------------------------------------------------------------
    // Vytvoreni a zobrazeni pomocneho okna, ve kterem se zobrazuje prubeh prace.
    // -----------------------------------------------------------------------
    private void prepareGUI() {
        frame=new Frame("Computing diffuse");
        label=new Label("Points:");
        frame.add(label);
        label.setAlignment(Label.CENTER);           // vlastnosti napisu
        label.setVisible(true);
        frame.setSize(200, 100);                    // vlastnosti okna
        frame.setVisible(true);
    }



    // -----------------------------------------------------------------------
    // Tato metoda se zavola po dokonceni generovani fraktalu.
    // -----------------------------------------------------------------------
    private void finishGUI() {
        label.setText("Filtering bitmaps");
        object.panelLeft.redraw(false);
        object.applyFilter();                       // aplikace filtru na bitmapu
        object.panelCenter.redraw(false);
        frame.setVisible(false);                    // a zruseni pomocneho okna
        frame.dispose();
    }



    // -----------------------------------------------------------------------
    // Vytvoreni a inicializace pomocneho pole - plosne mrizky.
    // -----------------------------------------------------------------------
    private void initBitmap() {
        pixels=new boolean[height][width];
        for (int j=0; j<height; j++) {
            for (int i=0; i<width; i++) {
                pixels[j][i]=false;                 // vsechny pixely nastavit
            }                                       // na stejnou hodnotu false
        }
    }



    // -----------------------------------------------------------------------
    // Kopie dat z pomocne bitmapy do pixmapy, ktera se bude zobrazovat.
    // -----------------------------------------------------------------------
    private void copyBitmapToPixmap() {
        int pos=0;
        for (int j=0; j<height; j++) {
            for (int i=0; i<width; i++) {           // pixel je bud cerny nebo bily
                pixelSrc[pos]=pixels[j][i] ? 0xff000000: 0xffffffff;
                pos++;                              // index do cilove pixmapy
            }
        }
    }



    // -----------------------------------------------------------------------
    // Inicializace seminka - pocatecnich bodu ve fraktalnim objektu.
    // -----------------------------------------------------------------------
    private void initSeed() {
        int wh=width/2;
        int hh=height/2;
        int wh1=width/3;
        int wh2=2*width/3;
        int hh1=height/3;
        int hh2=2*height/3;
        switch (seedShape) {
            case SeedShape.OnePoint:                // generuje se pouze jeden bod
                pixels[hh][wh]=true;
                break;
            case SeedShape.TwoPoints:               // generuji se dva symetricky postavene body
                pixels[hh][wh1]=true;
                pixels[hh][wh2]=true;
                break;
            case SeedShape.ThreePoints:             // generuji se tri symetricky postavene body
                pixels[hh1][wh]=true;
                pixels[hh2][wh1]=true;
                pixels[hh2][wh2]=true;
                break;
            case SeedShape.FourPoints:              // ctyri body ve vrcholech ctverce
                pixels[hh1][wh1]=true;
                pixels[hh2][wh1]=true;
                pixels[hh1][wh2]=true;
                pixels[hh2][wh2]=true;
                break;
            case SeedShape.Line:                    // usecka uprostred bitmapy
                for (int i=wh1; i<=wh2; i++)
                    pixels[hh][i]=true;
                break;
            case SeedShape.BottomLine:              // usecka na spodnim okraji bitmapy
                for (int i=0; i<width; i++)
                    pixels[height-1][i]=true;
                break;
            case SeedShape.Square:                  // ctverec uprostred bitmapy
                for (int i=wh1; i<=wh2; i++) {
                    pixels[hh1][i]=true;
                    pixels[hh2][i]=true;
                }
                for (int i=hh1; i<=hh2; i++) {
                    pixels[i][wh1]=true;
                    pixels[i][wh2]=true;
                }
                break;
            case SeedShape.Border:                  // okraj okolo cele bitmapy
                for (int i=0; i<width; i++) {
                    pixels[0][i]=true;
                    pixels[height-1][i]=true;
                }
                for (int i=0; i<height; i++) {
                    pixels[i][0]=true;
                    pixels[i][width-1]=true;
                }
                break;
            case SeedShape.SmallCircle:             // mala kruznice uprostred bitmapy
                {
                double r=wh/4.0;
                for (int i=0; i<1000; i++) {
                    double x=wh+r*Math.cos((double)i);
                    double y=hh+r*Math.sin((double)i);
                    pixels[(int)x][(int)y]=true;
                }
                }
                break;
            case SeedShape.NormalCircle:            // kruznice uprostred bitmapy
                {
                double r=wh/2.0;
                for (int i=0; i<1000; i++) {
                    double x=wh+r*Math.cos((double)i);
                    double y=hh+r*Math.sin((double)i);
                    pixels[(int)x][(int)y]=true;
                }
                }
                break;
            case SeedShape.BigCircle:               // velka kruznice uprostred bitmapy
                {
                double r=wh-9.0;
                for (int i=0; i<1000; i++) {
                    double x=wh+r*Math.cos((double)i);
                    double y=hh+r*Math.sin((double)i);
                    pixels[(int)x][(int)y]=true;
                }
                }
                break;
            default:
                pixels[hh][wh]=true;
                break;
        }
    }



    // -----------------------------------------------------------------------
    // Tato metoda vrati hodnotu true, pokud se v okoli pixelu vyskytuje
    // pixel, jez nalezi do vytvareneho fraktalniho objektu.
    // -----------------------------------------------------------------------
    private boolean neighboor(boolean type, int i, int j) {
        return type ? 
               pixels[j-1][i-1] |                   // osmiokoli pixelu
               pixels[j-1][i]   |
               pixels[j-1][i+1] |
               pixels[j][i-1]   |
               pixels[j][i+1]   |
               pixels[j+1][i-1] |
               pixels[j+1][i]   |
               pixels[j+1][i+1]
               :
               pixels[j-1][i]   |                   // ctyrokoli pixelu
               pixels[j][i-1]   |
               pixels[j][i+1]   |
               pixels[j+1][i]
               ;
    }



    // -----------------------------------------------------------------------
    // Vykresleni jednoho bodu do temporalni bitmapy podle zvoleneho tvaru.
    // -----------------------------------------------------------------------
    private void putPoint(int x, int y) {
        if (x<3) x=3;                               // zabranit zapisum
        if (x>=width-3) x=width-4;                  // mimo pole
        if (y<3) y=3;
        if (y>=height-3) y=height-3;
        if (pointShape!=PointShape.Diamond3x3 &&
            pointShape!=PointShape.Diamond5x5) {
            pixels[y][x]=true;                      // prostredni pixel
        }
        if (pointShape==PointShape.Cross3x3 ||
            pointShape==PointShape.Diamond3x3 ||
            pointShape==PointShape.Block3x3 ||
            pointShape==PointShape.Cross5x5 ||
            pointShape==PointShape.Block5x5 ||
            pointShape==PointShape.Horizontal3 ||
            pointShape==PointShape.Horizontal5) {
            pixels[y][x-1]=true;                    // pixel nalevo
            pixels[y][x+1]=true;                    // pixel napravo
        }
        if (pointShape==PointShape.Horizontal5 ||
            pointShape==PointShape.Cross5x5 ||
            pointShape==PointShape.Diamond5x5 ||
            pointShape==PointShape.Block5x5) {
            pixels[y][x-2]=true;                    // druhy pixel nalevo
            pixels[y][x+2]=true;                    // druhy pixel napravo
        }
        if (pointShape==PointShape.Cross3x3 ||
            pointShape==PointShape.Diamond3x3 ||
            pointShape==PointShape.Block3x3 ||
            pointShape==PointShape.Cross5x5 ||
            pointShape==PointShape.Block5x5 ||
            pointShape==PointShape.Vertical3 ||
            pointShape==PointShape.Vertical5) {
            pixels[y-1][x]=true;                    // pixel nahore
            pixels[y+1][x]=true;                    // pixel dole
        }
        if (pointShape==PointShape.Vertical5 ||
            pointShape==PointShape.Cross5x5 ||
            pointShape==PointShape.Diamond5x5 ||
            pointShape==PointShape.Block5x5) {
            pixels[y-1][x]=true;                    // druhy pixel nahore
            pixels[y+1][x]=true;                    // druhy pixel dole
        }
        if (pointShape==PointShape.XCross3x3 ||
            pointShape==PointShape.Block3x3 ||
            pointShape==PointShape.XCross5x5 ||
            pointShape==PointShape.Diamond5x5 ||
            pointShape==PointShape.Block5x5) {
            pixels[y-1][x-1]=true;                  // diagonalni pixely
            pixels[y+1][x-1]=true;
            pixels[y-1][x+1]=true;
            pixels[y+1][x+1]=true;
        }
        if (pointShape==PointShape.XCross5x5 ||
            pointShape==PointShape.Block5x5) {
            pixels[y-2][x-2]=true;                  // diagonalni pixely
            pixels[y+2][x-2]=true;                  // ve vzdalenosti 2
            pixels[y-2][x+2]=true;
            pixels[y+2][x+2]=true;
        }
        if (pointShape==PointShape.Block5x5) {
            pixels[y-2][x-1]=true;
            pixels[y+2][x-1]=true;
            pixels[y-2][x+1]=true;
            pixels[y+2][x+1]=true;
            pixels[y-1][x-2]=true;
            pixels[y+1][x-2]=true;
            pixels[y-1][x+2]=true;
            pixels[y+1][x+2]=true;
        }
    }



    // -----------------------------------------------------------------------
    // Test, zda se ma generovani difuze zastavit
    // -----------------------------------------------------------------------
    private boolean checkStopCondition(int iter, int xi, int yi) {
        boolean  flagMaxiter;
        boolean  flagBorder;
        boolean  done;

        flagMaxiter=iter>=maxPoints;                // kontrola poctu iteraci
        flagBorder=(xi<2 || xi>(width-2) || yi<4 || yi>(height-2)); // kontrola mezi
        switch (stopCondition) {                    // podle typu ukoncovaci podminky
            case StopCondition.Iterations:          // nastavit priznak ukonceni
                done=flagMaxiter;
                break;
            case StopCondition.Border:
                done=flagBorder;
                break;
            case StopCondition.And:
                done=flagMaxiter && flagBorder;
                break;
            case StopCondition.Or:
                done=flagMaxiter || flagBorder;
                break;
            default:
                done=true;
                break;
        }
        return done;
    }



    // -----------------------------------------------------------------------
    // Vlastni aplikace algoritmu difuze
    // -----------------------------------------------------------------------
    private void applyDiffuse() {
        boolean  doneInnerLoop;
        int      counter=0;
        int      xi, yi;
        int      i=0;

        do {                                        // vnejsi smycka, ktera se zastavi
            doneInnerLoop=false;                    // po nastaveni ukoncovaci podminky
            do {                                    // vnitrni smycka
                double x=Math.random()*(float)(width-2)+1;  // generovat bod
                double y=Math.random()*(float)(height-2)+1;
                xi=(int)x;
                yi=(int)y;
                if (neighboor(neighboorType, xi, yi)) { // pokud se bod nachazi v blizkosti obrazce
                    putPoint(xi, yi);               // pridat ho do fraktalu
                    doneInnerLoop=true;             // a ukoncit vnitrni smycku
                }
            } while (!doneInnerLoop);
            counter++;
            if (counter==50) {                      // prubezny vypis prace programu
                label.setText("Points: "+String.valueOf(i));
                counter=0;
            }
            i++;
        } while (!checkStopCondition(i, xi, yi));   // test na ukonceni vnejsi smycky
    }



    // -----------------------------------------------------------------------
    // Funkce, ktera rozbehne cele vypocetni vlakno.
    // -----------------------------------------------------------------------
    public void run() {
        prepareGUI();                               // vytvoreni vsech GUI prvku
        label.setText("Initializing");
        initBitmap();                               // inicializace bitmapy
        initSeed();                                 // inicializace seminka
        applyDiffuse();                             // aplikace algoritmu difuze
        label.setText("Finishing");
        copyBitmapToPixmap();                       // kopie pracovni bitmapy do vysledne pixmapy
        finishGUI();                                // fitrace a zavreni pomocneho okna
    }
}
// ----------------------------------------------------------------------------
// Konec tridy Diffuser.
// ----------------------------------------------------------------------------



// ----------------------------------------------------------------------------
// finito
// ----------------------------------------------------------------------------