import java.applet.*;
import java.awt.*;
import java.awt.image.*;

public class blurimage extends Applet {

//"blueimage" kommer att hålla reda på
//bilden som vi skapar.
Image image=null;

public void init()
{
    //Ladda in bilden (filnamnet finns i
    //parametern "image").
    MediaTracker tracker=new MediaTracker(this);
    image=getImage(getDocumentBase(),getParameter("image"));
    tracker.addImage(image,0);
    try {tracker.waitForAll();}
    catch(InterruptedException e){}

    //Nu anropar vi metoden blurImage()
    //för att göra bilden suddig.
    image=blurImage(image);
}

public Image blurImage(Image img)
{
    //Skapa en array för att lagra bildens pixlar och
    //hämta dem.
    Dimension d=new Dimension(img.getWidth(this),img.getHeight(this));
    int pixels[]=new int[d.width*d.height];
    PixelGrabber grabber
        =new PixelGrabber(img,0,0,d.width,d.height,pixels,0,d.width);
    try {grabber.grabPixels();} catch(InterruptedException e){};

    //Variabeln "div" används för att dividera
    //summan av alla komponenterna.
    int div;

    //Det är bäst att vi först skapar tre
    //arrayer för att lagra färgkomponenterna
    //så att bildbehandlingen snabbas upp.
    //Storleken på dessa arrayer måste vara
    //samma som antalet pixlar i bilden.
    int lr[]=new int[d.width*d.height];
    int lg[]=new int[d.width*d.height];
    int lb[]=new int[d.width*d.height];

    //Vi använder en enkel FOR-slinga för att
    //gå lagra varje komponent.
    for (int index=0; index<d.width*d.height; index++)
    {
        //Vi struntar i alfa kanalen så den
        //här metoden kommer bara att fungera
        //med transparenta bilder.
        lr[index]=(pixels[index]&0xff0000)>>16;
        lg[index]=(pixels[index]&0xff00)>>8;
        lb[index]=pixels[index]&0xff;
    }

    //Vi använder två FOR-slingor för bildbehandlingen
    //den här gången.
    int r,g,b;
    for (int x=0; x<d.width; x++)
    {
        for (int y=0; y<d.height; y++)
        {
            //Börja med att sätta d=1 och
            //sätta r,g,b till pixeln
            //(x,y)
            r=lr[x+y*d.width];
            g=lg[x+y*d.width];
            b=lb[x+y*d.width];
            div=1;
            if (x>0)
            {
                //Lägg till pixeln till vänster
                //om pixeln i mitten.
                r+=lr[(x-1)+y*d.width];
                g+=lg[(x-1)+y*d.width];
                b+=lb[(x-1)+y*d.width];
                div++;
                if (y>0)
                {
                    //Lägg till pixeln ovanför
                    //och längst upp till vänster
                    //om pixeln i centrum.
                    r+=lr[x+(y-1)*d.width];
                    g+=lg[x+(y-1)*d.width];
                    b+=lb[x+(y-1)*d.width];
                    r+=lr[(x-1)+(y-1)*d.width];
                    g+=lg[(x-1)+(y-1)*d.width];
                    b+=lb[(x-1)+(y-1)*d.width];
                    div+=2;
                }
                if (y<d.height-1)
                {
                    //Lägg till pixeln nedanför
                    //och längst ner till vänster
                    //om pixeln i centrum.
                    r+=lr[x+(y+1)*d.width];
                    g+=lg[x+(y+1)*d.width];
                    b+=lb[x+(y+1)*d.width];
                    r+=lr[(x-1)+(y+1)*d.width];
                    g+=lg[(x-1)+(y+1)*d.width];
                    b+=lb[(x-1)+(y+1)*d.width];
                    div+=2;
                }
            }
            if (x<d.width-1)
            {
                //Lägg till pixeln till höger
                //om pixeln i mitten.
                r+=lr[(x+1)+y*d.width];
                g+=lg[(x+1)+y*d.width];
                b+=lb[(x+1)+y*d.width];
                div++;
                if (y>0)
                {
                    //Lägg till pixeln längst
                    //upp till höger
                    //om pixeln i centrum.
                    r+=lr[(x+1)+(y-1)*d.width];
                    g+=lg[(x+1)+(y-1)*d.width];
                    b+=lb[(x+1)+(y-1)*d.width];
                    div++;
                }
                if (y<d.height-1)
                {
                    //Lägg till pixeln längst
                    //ner till höger
                    //om pixeln i centrum.
                    r+=lr[(x+1)+(y+1)*d.width];
                    g+=lg[(x+1)+(y+1)*d.width];
                    b+=lb[(x+1)+(y+1)*d.width];
                    div++;
                }
            }
            //Vi måste dividera med "div" som
            //egentligen bara säger hur många
            //pixlar vi har manipulerat.
            r/=div;
            g/=div;
            b/=div;

            //Till sist så bygger vi upp pixelvärdet igen.
            pixels[x+y*d.width]=0xff000000+(r<<16)+(g<<8)+b;
        }
    }
    //Nur återstår bara att återskapa bilden och returnera den.
    MemoryImageSource imgsrc
        =new MemoryImageSource(d.width,d.height,pixels,0,d.width);
    img=createImage(imgsrc);
    return img;
}

public void paint(Graphics g)
{
    if (image!=null) g.drawImage(image,0,0,this);
}

}