bufferedimagedemo1.java

java 完全探索的随书源码

// BufferedImageDemo1.java

import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;

class BufferedImageDemo1 extends Frame implements ActionListener
{
   picture pic;
   BufferedImage bi;

   Dimension ps = new Dimension (300, 100);

   BufferedImageDemo1 (String title)
   {
      super (title);

      addWindowListener (new WindowAdapter ()
                         {
                             public void windowClosing (WindowEvent e)
                             {
                                System.exit (0);
                             }
                         });

      MenuBar mb = new MenuBar ();

      Menu m = new Menu ("File");
      m.addActionListener (this);

      m.add ("Open...");
      m.addSeparator ();
      m.add ("Revert");
      m.addSeparator ();
      m.add ("Exit");

      mb.add (m);

      m = new Menu ("Process");
      m.addActionListener (this);

      m.add ("Blur");
      m.add ("Edge Detect");
      m.add ("Emboss");
      m.add ("Negative");
      m.add ("Posterize");
      m.add ("Sharpen");
      m.add ("Threshold");

      mb.add (m);

      setMenuBar (mb);

      add (pic = new picture ());

      pack ();
      setResizable (false);
      setVisible (true);
   }

   public void actionPerformed (ActionEvent e)
   {
      if (e.getActionCommand ().equals ("Exit"))
          System.exit (0);

      if (e.getActionCommand ().equals ("Revert"))
      {
          pic.draw (bi);
          return;
      }

      if (!e.getActionCommand ().equals ("Open..."))
      {
          process (e.getActionCommand ());
          return;
      }

      FileDialog fd = new FileDialog (this);
      fd.show ();

      if (fd.getFile () != null)
      {
          MediaTracker mt = new MediaTracker (this);

          Toolkit tk = Toolkit.getDefaultToolkit ();
          Image im = tk.getImage (fd.getDirectory () + fd.getFile ());
          mt.addImage (im, 0);

          try
          {
             mt.waitForID (0);
          }
          catch (InterruptedException e2) { }

          bi = new BufferedImage (im.getWidth (this),
                                  im.getHeight (this),
                                  BufferedImage.TYPE_INT_RGB);

          Graphics2D g2 = bi.createGraphics ();
          g2.drawImage (im, 0, 0, this);

          Insets in = getInsets ();

          ps = new Dimension (im.getWidth (this) + in.left + in.right,
                               im.getHeight (this) + in.top + in.bottom);

          pic.set (bi);

          pack ();
      }
   }

   public Dimension getPreferredSize ()
   {
      return ps;
   }

   public void process (String command)
   {
      if (command.equals ("Blur"))
      {
          float ninth = 1.0f / 9.0f;

          float [] blurKernel =
          {
             ninth, ninth, ninth,
             ninth, ninth, ninth,
             ninth, ninth, ninth
          };

          BufferedImageOp blurOp =
             new ConvolveOp (new Kernel (3, 3, blurKernel));

          BufferedImage clone = blurOp.filter (bi, null);
          pic.draw (clone);
          return;
      }

      if (command.equals ("Edge Detect"))
      {
          float [] edgeKernel =
          {
             0.0f, -1.0f,  0.0f,
            -1.0f,  4.0f, -1.0f,
             0.0f, -1.0f,  0.0f
          };

          BufferedImageOp edgeOp =
             new ConvolveOp (new Kernel (3, 3, edgeKernel));

          BufferedImage clone = edgeOp.filter (bi, null);
          pic.draw (clone);
          return;
      }

      if (command.equals ("Emboss"))
      {
          pic.draw (emboss (bi));
          return;
      }

      if (command.equals ("Negative"))
      {
          short [] invert = new short [256];

          for (int i = 0; i < invert.length; i++)
               invert [i] = (short) (255 - i);

          BufferedImageOp invertOp =
             new LookupOp (new ShortLookupTable (0, invert), null);

          BufferedImage clone = invertOp.filter (bi, null);
          pic.draw (clone);
          return;
      }

      if (command.equals ("Posterize"))
      {
          short [] posterize = new short [256];

          for (int i = 0; i < posterize.length; i++)
               posterize [i] = (short) (i - i % 32);

          BufferedImageOp posterizeOp =
             new LookupOp (new ShortLookupTable (0, posterize), null);

          BufferedImage clone = posterizeOp.filter (bi, null);
          pic.draw (clone);
          return;
      }

      if (command.equals ("Sharpen"))
      {
          float [] sharpenKernel =
          {
             0.0f, -1.0f,  0.0f,
            -1.0f,  5.0f, -1.0f,
             0.0f, -1.0f,  0.0f
          };

          BufferedImageOp sharpenOp =
             new ConvolveOp (new Kernel (3, 3, sharpenKernel));

          BufferedImage clone = sharpenOp.filter (bi, null);
          pic.draw (clone);
          return;
      }

      if (command.equals ("Threshold"))
      {
          short [] threshold = new short [256];

          for (int i = 0; i < threshold.length; i++)
               threshold [i] = (i < 128) ? (short) 0 : (short) 255;

          BufferedImageOp thresholdOp =
             new LookupOp (new ShortLookupTable (0, threshold), null);

          BufferedImage clone = thresholdOp.filter (bi, null);
          pic.draw (clone);
          return;
      }
   }

   public BufferedImage emboss (BufferedImage src)
   {
      int width = src.getWidth ();
      int height = src.getHeight ();

      BufferedImage dst;
      dst = new BufferedImage (width, height,
                               BufferedImage.TYPE_INT_RGB);

      for (int i = 0; i < height; i++)
           for (int j = 0; j < width; j++)
           {
                int upperLeft = 0;
                int lowerRight = 0;

                if (i > 0 && j > 0)
                    upperLeft = src.getRGB (j - 1, i - 1);

                if (i < height - 1 && j < width - 1)
                    lowerRight = src.getRGB (j + 1, i + 1);

                int redDiff = ((lowerRight >> 16) & 255) -
                              ((upperLeft >> 16) & 255);

                int greenDiff = ((lowerRight >> 8) & 255) -
                                ((upperLeft >> 8) & 255);

                int blueDiff = (lowerRight & 255) -
                               (upperLeft & 255);

                int diff = redDiff;
                if (Math.abs (greenDiff) > Math.abs (diff))
                    diff = greenDiff;
                if (Math.abs (blueDiff) > Math.abs (diff))
                    diff = blueDiff;

                int grayColor = 128 + diff;

                if (grayColor > 255) grayColor = 255;
                else
                if (grayColor < 0) grayColor = 0;

                int newColor = (grayColor << 16) + (grayColor << 8)
                               + grayColor;

                dst.setRGB (j, i, newColor);
           }

      return dst;
   }

   public static void main (String [] args)
   {
      new BufferedImageDemo1 ("Buffered Image Demo1");
   }
}

class picture extends Canvas
{
   private Image image;    

   public void draw (Image image)
   {
      set (image);
      repaint ();
   }

   public void paint (Graphics g)
   {
      // Draw the image.

      if (image != null)
          g.drawImage (image, 0, 0, this);
   }

   public void set (Image image)
   {
      this.image = image;
   }

   public void update (Graphics g)
   {
      paint (g);
   }
}