import java.applet.Applet;
import java.awt.*;

import java.net.*;
import java.awt.image.*;

public class ObjectRemoval2 extends BufferedApplet{
    final int OK = 0;
    final int ABORTED = 1;
    final int LOADING = 2;
    final int GRABBING = 3;
    int threshhold=110;
    int flag = OK;
    double[][][] pixelarray;
    int[] pixel;
    int[] pixels;
    int[] drawn;
    Image image,temp_image,temp_image2;
    int w,h;
    int counter=0;
    int win=1;
    float weight;
    boolean continueflag=true;
    boolean doneflag=true;
    int maxx=0;
    int maxy=0;
    int minx,miny;
    double x,y,x2,y2,offsetx,offsety,offsetx2,offsety2;
    int selected=1;
    Cubic xspline[]=new Cubic[100];
    Cubic yspline[]=new Cubic[100];
    double GX[] = new double[2000];
    double GY[]= new double[2000];
    double min;
    double distance=0;
    int splines=0;
    
    public void init(){
        flag = LOADING;
        repaint();
        image = getImage(getDocumentBase(),"inpaint3.png");
        MediaTracker mt = new MediaTracker(this);
        mt.addImage(image,0);
        try{
            mt.waitForID(0);
        }catch(InterruptedException e){
        } 
        flag = GRABBING;
        repaint();
        w =minx= image.getWidth(this);
        h =miny= image.getHeight(this);
        int pixels[] = new int[w * h];
        int drawn[] = new int[w * h];
        PixelGrabber pg = new PixelGrabber(image,0,0,w,h,pixels,0,w);
        try {
            pg.grabPixels();
        }catch(InterruptedException e){
        }
        if((pg.getStatus() & ImageObserver.ABORT) != 0){
            flag = ABORTED;
        }else{
            flag = OK;
        }
        repaint();
        pixelarray=new double[w][h][4];
        for (int j=0;j<h;j++)
            for (int i=0;i<w;i++){
                pixelarray[i][j][0]=(pixels[i+j*w] >> 24) & 0xFF;
                pixelarray[i][j][1]=(pixels[i+j*w] >> 16) & 0xFF;
                pixelarray[i][j][2]=(pixels[i+j*w] >> 8) & 0xFF;
                pixelarray[i][j][3]=(pixels[i+j*w] ) & 0xFF;
            }
  // only process rectangle with missing pixels
  for(int i=0;i<w;i++){ 
       for(int j=0;j<h;j++){
         if (pixelarray[i][j][0]<255){
            pixelarray[i][j][0]=0;
            if (i<minx)
                minx=i;
            if (i>maxx)
                maxx=i;
            if(j<miny)
                miny=j;
            if(j>maxy)
                maxy=j;
         }
       }
     }
        //inpaint(pixelarray); 
       for (int j=0;j<h;j++)
         for (int i=0;i<w;i++){    
             drawn[i+j*w]=0;
             drawn[i+j*w]+=((int)pixelarray[i][j][3]);
             drawn[i+j*w]+=((int)pixelarray[i][j][2] << 8);
             drawn[i+j*w]+=((int)pixelarray[i][j][1] << 16) ;
             drawn[i+j*w]+=((int)pixelarray[i][j][0]  << 24);
             drawn[i+j*w]+=(255 << 24);
        }
        temp_image = createImage(new MemoryImageSource(w, h, drawn, 0, w));          
    }
    
    public void render(Graphics g){
        if (counter>2) drawSpline(g);
         if (counter<3) g.drawImage(temp_image,0,0,this); 
        switch(flag){
        case OK:  
        if (doneflag==true && counter>2){
                doneflag=false; 
                 temp_image2 = createImage(w, h);
                  Graphics g2 = temp_image2.getGraphics();
                  drawSpline(g2);
                  int pixels[] = new int[w * h];
                  int drawn[] = new int[w * h];
                 PixelGrabber pg = new PixelGrabber(temp_image2,0,0,w,h,pixels,0,w);
                 try {
                     pg.grabPixels();
                 }catch(InterruptedException e){
                 }
                 if((pg.getStatus() & ImageObserver.ABORT) != 0){
                     flag = ABORTED;
                 }else{
                      flag = OK;
                 }
                 repaint();
                 pixelarray=new double[w][h][4];
                 for (int j=0;j<h;j++)
                     for (int i=0;i<w;i++){
                         pixelarray[i][j][0]=(pixels[i+j*w] >> 24) & 0xFF;   
                         pixelarray[i][j][1]=(pixels[i+j*w] >> 16) & 0xFF;
                         pixelarray[i][j][2]=(pixels[i+j*w] >> 8) & 0xFF;
                         pixelarray[i][j][3]=(pixels[i+j*w] ) & 0xFF;
                          if(pixelarray[i][j][2]>250){pixelarray[i][j][0]=0;}else{pixelarray[i][j][0]=255;}  
                     }
                  inpaint(pixelarray); 
                  for (int j=0;j<h;j++)
                    for (int i=0;i<w;i++){    
                        drawn[i+j*w]=0;
                        drawn[i+j*w]+=((int)pixelarray[i][j][3]);
                        drawn[i+j*w]+=((int)pixelarray[i][j][2] << 8);
                        drawn[i+j*w]+=((int)pixelarray[i][j][1] << 16) ;
                        drawn[i+j*w]+=((int)pixelarray[i][j][0]  << 24);
                        drawn[i+j*w]+=(255 << 24);
                    }  
                 temp_image2 = createImage(new MemoryImageSource(w, h, drawn, 0, w));     
            }
            if (counter>2) g.drawImage(temp_image2,0,h,null);   
            g.drawImage(image,0,h,this);
        break;
        case ABORTED:
            g.drawString("Aborted.",30,30);
            break;
        case LOADING:
            g.drawString("Loading Image...",30,30);
            break;
        case GRABBING:
            g.drawString("Grabbing Pixels...",30,30);
            break;
        }
    }
    
    public void bluri(int i, int j){
        for (int w=1;w<4;w++){
            pixelarray[i][j][w]=(.3125*pixelarray[i][j][w]+.234375*(pixelarray[i-1][j][w]+pixelarray[i+1][j][w])+.09375*(pixelarray[i-2][j][w]+pixelarray[i+2][j][w])+.015625*(pixelarray[i-3][j][w]+pixelarray[i+3][j][w]));
        }
    }
    public void blurj(int i, int j){
        for (int w=1;w<4;w++){
            pixelarray[i][j][w]=(.3125*pixelarray[i][j][w]+.234375*(pixelarray[i][j-1][w]+pixelarray[i][j+1][w])+.09375*(pixelarray[i][j-2][w]+pixelarray[i][j+2][w])+.015625*(pixelarray[i][j-3][w]+pixelarray[i][j+3][w]));
        }
    }
    
    public void blurismall(int i, int j){
        for (int w=1;w<4;w++){
            pixelarray[i][j][w]=(.5*pixelarray[i][j][w]+.25*(pixelarray[i-1][j][w]+pixelarray[i+1][j][w]));
        }
    }
    public void blurjsmall(int i, int j){
        for (int w=1;w<4;w++){
            pixelarray[i][j][w]=(.5*pixelarray[i][j][w]+.25*(pixelarray[i][j-1][w]+pixelarray[i][j+1][w]));
        }
    }
    public void inpaint(double pixelarray[][][]){            
     while(continueflag==true){
        continueflag=false;  
        //set operating area to thin band around area to be filled in
        for(int i=minx;i<maxx+1;i++){ 
            for(int j=miny;j<maxy+1;j++){
                if (pixelarray[i][j][0]==0){
                    continueflag=true;
                    if(pixelarray[i-1][j][0]>250 || pixelarray[i+1][j][0]>250 || pixelarray[i][j-1][0]>250 || pixelarray[i][j+1][0]>250){
                        pixelarray[i][j][0]=100;
                    }
                }
            }
        }
        for(int i=minx;i<maxx+1;i++){ 
            for(int j=miny;j<maxy+1;j++){
                if (pixelarray[i][j][0]==100){
                    process(i,j);
                }
            }
        }
        for(int i=minx;i<maxx+1;i++){ 
          for(int j=miny;j<maxy+1;j++){
             if (pixelarray[i][j][0]==100){
                 pixelarray[i][j][0]=254;
             }
         }
      }
    }
    for (int k=0;k<((maxx-minx)+(maxy-miny))/3;k++){
        for(int i=minx;i<maxx+1;i++){ 
          for(int j=miny;j<maxy+1;j++){
             if (pixelarray[i][j][0]<255){
                 bluri(i,j);
                }
          }
        } 
          for(int i=minx;i<maxx+1;i++){ 
          for(int j=miny;j<maxy+1;j++){
             if (pixelarray[i][j][0]<255){
                    blurj(i,j);
                }
          }
        }
    }
    for (int k=0;k<20;k++){
     for(int i=minx;i<maxx+1;i++){ 
          for(int j=miny;j<maxy+1;j++){
             if (pixelarray[i][j][0]<255){
                 blurismall(i,j);
                }
          }
        } 
          for(int i=minx;i<maxx+1;i++){ 
          for(int j=miny;j<maxy+1;j++){
             if (pixelarray[i][j][0]<255){
                    blurjsmall(i,j);
                }
          }
        }
    }
    for(int i=minx;i<maxx+1;i++){ 
          for(int j=miny;j<maxy+1;j++){
            if (pixelarray[i][j][0]<250){ 
                  pixelarray[i][j][1]=0;
                  pixelarray[i][j][2]=pixelarray[i][j][0];
                  pixelarray[i][j][3]=pixelarray[i][j][0];
                   pixelarray[i][j][0]=254;
              }   
            }
        }
    }
    
    public void process(int i,int j){
        weight=0;
        pixelarray[i][j][1]=0;
        pixelarray[i][j][2]=0;
        pixelarray[i][j][3]=0;
                    
        if (pixelarray[i+1][j][0]>threshhold){
            for (int k=1;k<4;k++){
                pixelarray[i][j][k]+=pixelarray[i+1][j][k];
            }
            weight+=1;
       }
       if (pixelarray[i+1][j+1][0]>threshhold){
           for (int k=1;k<4;k++){
               pixelarray[i][j][k]+=pixelarray[i+1][j+1][k];
            }
            weight+=1;
        }
        if (pixelarray[i][j+1][0]>threshhold){
            for (int k=1;k<4;k++){
                pixelarray[i][j][k]+=pixelarray[i][j+1][k];
            }
            weight+=1;
        }
        if (pixelarray[i-1][j+1][0]>threshhold){
            for (int k=1;k<4;k++){
                pixelarray[i][j][k]+=pixelarray[i-1][j+1][k];
            }
            weight+=1;
       }
       if (pixelarray[i-1][j][0]>threshhold){
           for (int k=1;k<4;k++){
               pixelarray[i][j][k]+=pixelarray[i-1][j][k];
            }
            weight+=1;
        }
        if (pixelarray[i-1][j-1][0]>threshhold){
            for (int k=1;k<4;k++){
                pixelarray[i][j][k]+=pixelarray[i-1][j-1][k];
            }
            weight+=1;
        }
        if (pixelarray[i][j-1][0]>threshhold){
            for (int k=1;k<4;k++){
                pixelarray[i][j][k]+=pixelarray[i][j-1][k];
            }
            weight+=1;
        }
        if (pixelarray[i+1][j-1][0]>threshhold){
            for (int k=1;k<4;k++){
                pixelarray[i][j][k]+=pixelarray[i+1][j-1][k];
            }
            weight+=1;
        }
        if (weight>0){
            for (int k=1;k<4;k++){
                pixelarray[i][j][k]=(pixelarray[i][j][k]/(double)(weight));
            }  
        }
    }
    public boolean mouseDown(Event e, int x, int y) {
        GX[counter]=x;
        GY[counter]=y;
        counter=(counter+1);
        return true;
   }
 
    public boolean keyUp(Event e, int key) {
        switch (key){
            case 'r':
                doneflag=true;
                continueflag=true;
            break;
            case 'n':
                splines+=1;
                counter=0;
            break;
        }
        return true;
    }
  
   public void drawSpline(Graphics g){
       double xcoords[]= {GX[(counter-4)],GX[(counter-3)],GX[(counter-2)],GX[(counter-1)]};
       double ycoords[]= {GY[(counter-4)],GY[(counter-3)],GY[(counter-2)],GY[(counter-1)]};
       xspline[splines]=new Cubic(Cubic.CATMULL_ROM, xcoords);
       yspline[splines]=new Cubic(Cubic.CATMULL_ROM, ycoords);  
       g.drawImage(temp_image,0,0,this);
       for (int i=0;i<splines+1;i++){
            double x0=xspline[i].eval(0);
            double y0=yspline[i].eval(0);
            double x20=xspline[i].eval(.1);
            double y20=yspline[i].eval(.1);
            double length0=Math.sqrt(((y20-y0)*(y20-y0)+(x20-x0)*(x20-x0)));
            double offsetx0=2*(y20-y0)/length0;
            double offsety0=-2*(x20-x0)/length0;
            double x1=xspline[i].eval(.9);
            double y1=yspline[i].eval(.9);
            double x21=xspline[i].eval(1);
            double y21=yspline[i].eval(1);
            double length1=Math.sqrt(((y21-y1)*(y21-y1)+(x21-x1)*(x21-x1)));
            double offsetx1=2*(y21-y1)/length1;
            double offsety1=-2*(x21-x1)/length1;
        
            for (double t = 0 ; t < 1 ; t+=.1) {
                x2=x;
                y2=y;
                offsetx2=offsetx;
                offsety2=offsety;
                y = (yspline[i].eval(t));
                x = (xspline[i].eval(t)); 
                if (t==0){ x2=x; y2=y; }
                double length=Math.sqrt(((y2-y)*(y2-y)+(x2-x)*(x2-x)));
                if (length==0) length=1000;
                offsetx=2.5*(y2-y)/length;
                offsety=-2.5*(x2-x)/length; 
                if (offsetx2==0) offsetx2=offsetx;
                if (offsety2==0) offsety2=offsety;
      
                int colorx0=(int)(x0+4*offsetx0);
                int colory0=(int)(y0+4*offsety0);
                int colorx1=(int)(x1+4*offsetx1);
                int colory1=(int)(y1+4*offsety1);
                g.setColor(new Color((int)((double)pixelarray[colorx0][colory0][1]*(1-t)+(double)pixelarray[colorx1][colory1][1]*(t)),
                                     (int)((double)pixelarray[colorx0][colory0][2]*(1-t)+(double)pixelarray[colorx1][colory1][2]*(t)),
                                     (int)((double)pixelarray[colorx0][colory0][3]*(1-t)+(double)pixelarray[colorx1][colory1][3]*(t))));
                int xpoints[]={(int)(x-offsetx),(int)(x2-offsetx2),(int)(x2-.3*offsetx2),(int)(x-.3*offsetx)};
                int ypoints[]={(int)(y-offsety),(int)(y2-offsety2),(int)(y2-.3*offsety2),(int)(y-.3*offsety)};
                g.fillPolygon(xpoints,ypoints,4);
                xpoints[0]=(int)(x+offsetx); xpoints[1]=(int)(x2+offsetx2);xpoints[2]=(int)(x2+.3*offsetx2);xpoints[3]=(int)(x+.3*offsetx);
                ypoints[0]=(int)(y+offsety); ypoints[1]=(int)(y2+offsety2);ypoints[2]=(int)(y2+.3*offsety2);ypoints[3]=(int)(y+.3*offsety);
                colorx0=(int)(x0-4*offsetx0);
                colory0=(int)(y0-4*offsety0);
                colorx1=(int)(x1-4*offsetx1);
                colory1=(int)(y1-4*offsety1);
                g.setColor(new Color((int)((double)pixelarray[colorx0][colory0][1]*(1-t)+(double)pixelarray[colorx1][colory1][1]*(t)),
                                     (int)((double)pixelarray[colorx0][colory0][2]*(1-t)+(double)pixelarray[colorx1][colory1][2]*(t)),
                                     (int)((double)pixelarray[colorx0][colory0][3]*(1-t)+(double)pixelarray[colorx1][colory1][3]*(t))));
                g.fillPolygon(xpoints,ypoints,4);
            }
        }
   }
}