Subversion Repositories general

package ak.photoalbum.images.jiu;

import java.awt.Image;

import java.awt.image.BufferedImage;

import java.awt.image.PixelGrabber;

import java.awt.image.ImageObserver;

import org.apache.log4j.Logger;

import ak.photoalbum.images.ImageResizer;

import net.sourceforge.jiu.data.BilevelImage;

import net.sourceforge.jiu.data.Gray8Image;

import net.sourceforge.jiu.data.MemoryRGB24Image;

import net.sourceforge.jiu.data.Palette;

import net.sourceforge.jiu.data.Paletted8Image;

import net.sourceforge.jiu.data.PixelImage;

import net.sourceforge.jiu.data.RGB24Image;

import net.sourceforge.jiu.data.RGBIndex;

import net.sourceforge.jiu.geometry.Resample;

public class JiuResizer

  implements ImageResizer

{

  protected static final int DEFAULT_ALPHA = 0xff000000;

  protected static final int FILTER_TYPE   = Resample.FILTER_TYPE_LANCZOS3;

    /*

      Possible type          small, ms      medium, ms    quality

      -----------------------------------------------------------

      FILTER_TYPE_BOX           2.4           3.5         very bad

      FILTER_TYPE_TRIANGLE      2.9           5.2

      FILTER_TYPE_B_SPLINE      3.6           7.2

      FILTER_TYPE_BELL          3.5           6.1

      FILTER_TYPE_HERMITE       2.9           5.3

      FILTER_TYPE_LANCZOS3      4.7           9.7         the best

      FILTER_TYPE_MITCHELL      3.6           7.1

    */

  protected Logger logger;

  public JiuResizer()

  {

    this.logger = Logger.getLogger(this.getClass());

  }

  public BufferedImage resize(Image origin, int newWidth, int newHeight)

  {

    try {

      RGB24Image image    = convertImageToRGB24Image(origin);

      Resample   resample;

      if(image == null) return null;

      if(image.getWidth() == newWidth && image.getHeight() == newHeight)

        return convertToAwtImage(image, DEFAULT_ALPHA);

      resample = new Resample();

      resample.setInputImage(image);

      resample.setSize(newWidth, newHeight);

      resample.setFilter(FILTER_TYPE);

      resample.process();

      return convertToAwtImage(resample.getOutputImage(), DEFAULT_ALPHA);

    }

    catch(Exception ex) {

      ex.printStackTrace();

      throw new RuntimeException(ex.getMessage());

    }

  }

  protected static BufferedImage convertToAwtImage(PixelImage image, int alpha)

  {

    if (image == null)

    {

      return null;

    }

    if (image instanceof RGB24Image)

    {

      return convertToAwtImage((RGB24Image)image, alpha);

    }

    else

    if (image instanceof Gray8Image)

    {

      return null; //convertToAwtImage((Gray8Image)image, alpha);

    }

    else

    if (image instanceof Paletted8Image)

    {

      return null; //convertToAwtImage((Paletted8Image)image, alpha);

    }

    else

    if (image instanceof BilevelImage)

    {

      return null; //convertToAwtImage((BilevelImage)image, alpha);

    }

    else

    {

      return null;

    }

  }

  protected static BufferedImage convertToAwtImage(RGB24Image image, int alpha)

  {

    if (image == null)

    {

      return null;

    }

    int width = image.getWidth();

    int height = image.getHeight();

    if (width < 1 || height < 1)

    {

      return null;

    }

    int[] pixels = new int[width];

    byte[] red = new byte[width];

    byte[] green = new byte[width];

    byte[] blue = new byte[width];

    BufferedImage newImage = new BufferedImage(width, height,

      BufferedImage.TYPE_INT_RGB);

    for (int y = 0; y < height; y++)

    {

      image.getByteSamples(RGBIndex.INDEX_RED, 0, y, width, 1, red, 0);

      image.getByteSamples(RGBIndex.INDEX_GREEN, 0, y, width, 1, green, 0);

      image.getByteSamples(RGBIndex.INDEX_BLUE, 0, y, width, 1, blue, 0);

      convertFromRGB24(red, 0, green, 0, blue, 0, alpha, pixels, 0, width);

      for(int x = 0; x < width; x++)

        newImage.setRGB(x, y, pixels[x]);

    }

    return newImage;

  }

  protected static void convertFromRGB24(

    byte[] srcRed, int srcRedOffset,

    byte[] srcGreen, int srcGreenOffset,

    byte[] srcBlue, int srcBlueOffset,

    int alpha,

    int[] dest, int destOffset,

    int num)

  {

    while (num-- > 0)

    {

      dest[destOffset++] =

        alpha |

        (srcBlue[srcBlueOffset++] & 0xff) |

        ((srcGreen[srcGreenOffset++] & 0xff) << 8) |

        ((srcRed[srcRedOffset++] & 0xff) << 16);

    }

  }

  /**

   * Creates an {@link RGB24Image} from the argument AWT image instance.

   * @param image AWT image object to be converted to a {@link RGB24Image}

   * @return a {@link RGB24Image} object holding the

   *         image data from the argument image

   */

  protected static RGB24Image convertImageToRGB24Image(Image image)

  {

    if (image == null)

    {

      return null;

    }

    int width = image.getWidth(null);

    int height = image.getHeight(null);

    if (width < 1 || height < 1)

    {

      return null;

    }

    int[] pixels = new int[width * height];

    PixelGrabber pg = new PixelGrabber(

      image, 0, 0, width, height, pixels, 0, width);

    try

    {

      pg.grabPixels();

    }

    catch (InterruptedException e)

    {

      return null;

    }

    if ((pg.getStatus() & ImageObserver.ABORT) != 0)

    {

      //System.err.println("image fetch aborted or errored");

      return null;

    }

    RGB24Image result = new MemoryRGB24Image(width, height);

    int offset = 0;

    for (int y = 0; y < height; y++)

    {

      for (int x = 0; x < width; x++)

      {

        int pixel = pixels[offset++] & 0xffffff;

        result.putSample(RGBIndex.INDEX_RED, x, y, pixel >> 16);

        result.putSample(RGBIndex.INDEX_GREEN, x, y, (pixel >> 8) & 0xff);

        result.putSample(RGBIndex.INDEX_BLUE, x, y, pixel & 0xff);

      }

    }

    return result;

  }

}