// Copyright 1997-2015 Christian d'Heureuse, Inventec Informatik AG, Zurich, Switzerland
// www.source-code.biz, www.inventec.ch/chdh
//
// This module is multi-licensed and may be used under the terms of any of the following licenses:
//
//  LGPL, GNU Lesser General Public License, V2.1 or later, http://www.gnu.org/licenses/lgpl.html
//  EPL, Eclipse Public License, V1.0 or later, http://www.eclipse.org/legal
//
// Please contact the author if you need another license.
// This module is provided "as is", without warranties of any kind.
//
// Home page: http://www.source-code.biz/snippets/java/1.htm

import java.awt.image.ImageFilter;
import java.awt.image.ColorModel;

/**
* 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.
*/
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 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) {
      throw new IllegalArgumentException("Invalid x or w in setPixels."); }
   if (y != expectedSrcY) {
      throw new IllegalArgumentException("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) {
      throw new IllegalArgumentException("Incompatible hint flags passed (" + flags + ")."); }
   consumer.setHints(flags); }

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

}