import java.awt.image.*;

/***********************************************************************
*
* An anti-aliasing image filter.
*
* <p>
* This is an image filter class that can be used for anti-aliasing.
* The input image is scaled down by the factor <code>ScalingFactor</code>.
* The color value of an output pixel is computed by averaging the
* color values of the corresponding input pixels.
*
* <p>
* Home page: <a href="http://www.source-code.biz" target="_top">www.source-code.biz</a><br>
* Copyright 1997-2003: Christian d'Heureuse, Inventec Informatik AG, Switzerland.<br>
* License: This is "Open Source" software and released under the <a href="http://www.gnu.org/licenses/gpl.html" target="_top">GNU/GPL</a> license.
* It is provided "as is" without warranty of any kind. Please contact the author for other licensing arrangements.<br>
*
* <p>
* Version history:<br>
* 1997-07-01 Christian d'Heureuse (chdh): Module created.<br>
* 2003-06-30 chdh: Revision.<br>
*
***********************************************************************/

public class AntiAliasingFilter extends ImageFilter {

private static final ColorModel rgbModel = ColorModel.getRGBdefault();

private int              scalingFactor;
private int              scalingFactorSqr;
private int              srcWidth;
private int              srcHeight;
private int              destWidth;
private int              destHeight;
private int              expectedSrcY;
private int              accu[];
private int              outLine[];

private void fatalError (String msg) {
   throw new RuntimeException(getClass().getName()+": "+msg); }

private void sendOutputLine (int destY) {
   consumer.setPixels (0,destY,destWidth,1,rgbModel,outLine,0,destWidth); }

private void genOutputLine() {
   int p = 0;
   for (int i=0; i<destWidth; i++) {
      int rgb = 0xFF;
      for (int j=0; j<3; j++) {
         rgb <<= 8;
         rgb |= accu[p++] / scalingFactorSqr; }
      outLine[i] = rgb; }}

private void procSrcLine (int srcY, byte pixelsB[], int pixelsI[], int offs0,
      ColorModel model) {
   int yMod = srcY % scalingFactor;
   if (yMod == 0) for (int i=0; i<accu.length; i++) accu[i] = 0;
   int offs = offs0;
   int p = 0;
   for (int i=0; i<destWidth; i++) {
      for (int j=0; j<scalingFactor; j++) {
         int pixel = pixelsB != null ? pixelsB[offs++]&0xFF : pixelsI[offs++];
         int rgb = model.getRGB(pixel);
         accu[p+2] += rgb & 0xff;
         rgb >>>= 8;
         accu[p+1] += rgb & 0xff;
         rgb >>>= 8;
         accu[p] += rgb & 0xff; }
      p += 3; }
   if (yMod == scalingFactor-1) {
      genOutputLine();
      sendOutputLine (srcY/scalingFactor); }}

private void procSetPixels (int x, int y, int w, int h, ColorModel model,
      byte pixelsB[], int pixelsI[], int offs0, int scansize) {
   if (x != 0 || w != srcWidth) fatalError ("Invalid x or w in setPixels.");
   if (y != expectedSrcY) fatalError ("ExpectedSrcY does not match.");
   int offs = offs0;
   for (int srcY=y; srcY<y+h; srcY++) {
      procSrcLine (srcY,pixelsB,pixelsI,offs,model);
      offs += scansize; }
   expectedSrcY = y+h; }

public void setPixels (int x, int y, int w, int h, ColorModel model,
      int pixels[], int offs, int scansize) {
   procSetPixels (x,y,w,h,model,null,pixels,offs,scansize); }

public void setPixels (int x, int y, int w, int h, ColorModel model,
      byte pixels[], int offs, int scansize) {
   procSetPixels (x,y,w,h,model,pixels,null,offs,scansize); }

public void setColorModel (ColorModel model) {
   consumer.setColorModel (rgbModel); }

public void setDimensions (int width, int height) {
   srcWidth = width;
   srcHeight = height;
   destWidth  = srcWidth  / scalingFactor;
   destHeight = srcHeight / scalingFactor;
   expectedSrcY = 0;
   accu = new int[destWidth*3];
   outLine = new int[destWidth];
   consumer.setDimensions (destWidth,destHeight); }

public void setHints (int flags) {
   int reqFlags = TOPDOWNLEFTRIGHT | COMPLETESCANLINES | SINGLEPASS;
   if ((flags&reqFlags)!=reqFlags)
      fatalError ("Incompatible hint flags passed ("+flags+").");
   consumer.setHints (flags); }

public AntiAliasingFilter (int scalingFactor) {
   this.scalingFactor = scalingFactor;
   scalingFactorSqr = scalingFactor * scalingFactor; }

};