libjava/java/awt/image/RGBImageFilter.java

   1 /* RGBImageFilter.java -- Java class for filtering Pixels by RGB values
   2    Copyright (C) 1999 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.awt.image;
  40
  41 /**
  42  * A filter designed to filter images in the default RGBColorModel regardless of
  43  * the ImageProducer's ColorModel.
  44  *
  45  * @author Mark Benvenuto <mcb54@columbia.edu>
  46  */
  47 public abstract class RGBImageFilter extends ImageFilter
  48 {
  49     protected ColorModel origmodel = ColorModel.getRGBdefault();
  50
  51     protected ColorModel newmodel;
  52
  53     /**
  54        Specifies whether to apply the filter to the index entries of the
  55        IndexColorModel. Subclasses should set this to true if the filter
  56        does not depend on the pixel's coordinate.
  57      */
  58     protected boolean canFilterIndexColorModel = false;
  59
  60     /**
  61        Construct new RGBImageFilter.
  62      */
  63     public RGBImageFilter()
  64     {
  65     }
  66
  67     /**
  68      * Sets the ColorModel used to filter with. If the specified ColorModel is IndexColorModel
  69      * and canFilterIndexColorModel is true, we subsitute the ColorModel for a filtered one
  70      * here and in setPixels whenever the original one appears. Otherwise overrides the default
  71      * ColorModel of ImageProducer and specifies the default RGBColorModel
  72      *
  73      * @param model the color model to be used most often by setPixels
  74      * @see ColorModel */
  75     public void setColorModel(ColorModel model)
  76     {
  77         origmodel = model;
  78         newmodel = model;
  79
  80         if( ( model instanceof IndexColorModel) && canFilterIndexColorModel  ) {
  81                 newmodel = filterIndexColorModel( (IndexColorModel) model );
  82             }
  83     }
  84
  85     /**
  86        Registers a new ColorModel to subsitute for the old ColorModel when
  87        setPixels encounters the a pixel with the old ColorModel. The pixel
  88        remains unchanged except for a new ColorModel.
  89
  90        @param oldcm the old ColorModel
  91        @param newcm the new ColorModel
  92      */
  93     public void substituteColorModel(ColorModel oldcm,
  94                                      ColorModel newcm)
  95     {
  96         origmodel = oldcm;
  97         newmodel = newcm;
  98     }
  99
 100     /**
 101        Filters an IndexColorModel through the filterRGB function. Uses
 102        coordinates of -1 to indicate its filtering an index and not a pixel.
 103
 104        @param icm an IndexColorModel to filter
 105      */
 106     public IndexColorModel filterIndexColorModel(IndexColorModel icm)
 107     {
 108         int len = icm.getMapSize(), rgb;
 109         byte reds[] = new byte[len], greens[] = new byte[len], blues[] = new byte[len], alphas[]  = new byte[len];
 110
 111         icm.getAlphas( alphas );
 112         icm.getReds( reds );
 113         icm.getGreens( greens );
 114         icm.getBlues( blues );
 115
 116         for( int i = 0; i < len; i++ )
 117             {
 118                 rgb = filterRGB( -1, -1, makeColor ( alphas[i], reds[i], greens[i], blues[i] ) );
 119                 alphas[i] = (byte)(( 0xff000000 & rgb ) >> 24);
 120                 reds[i] = (byte)(( 0xff0000 & rgb ) >> 16);
 121                 greens[i] = (byte)(( 0xff00 & rgb ) >> 8);
 122                 blues[i] = (byte)(0xff & rgb);
 123             }
 124         return new IndexColorModel( icm.getPixelSize(), len, reds, greens, blues, alphas );
 125     }
 126
 127     private int makeColor( byte a, byte r, byte g, byte b )
 128     {
 129         return ( 0xff000000 & (a << 24) | 0xff0000 & (r << 16) | 0xff00 & (b << 8) | 0xff & g );
 130     }
 131
 132     /**
 133        This functions filters a set of RGB pixels through filterRGB.
 134
 135        @param x the x coordinate of the rectangle
 136        @param y the y coordinate of the rectangle
 137        @param w the width of the rectangle
 138        @param h the height of the rectangle
 139        @param model the <code>ColorModel</code> used to translate the pixels
 140        @param pixels the array of pixel values
 141        @param offset the index of the first pixels in the <code>pixels</code> array
 142        @param scansize the width to use in extracting pixels from the <code>pixels</code> array
 143     */
 144     public void filterRGBPixels(int x,
 145                                 int y,
 146                                 int w,
 147                                 int h,
 148                                 int[] pixels,
 149                                 int off,
 150                                 int scansize)
 151     {
 152         int xp, yp;
 153
 154         for( xp = x; xp < ( x + w); xp++ )
 155             for( yp = y; yp < (y + h); yp++ )
 156                  pixels[ off + yp * scansize + xp ] = filterRGB( xp, yp, pixels[ off + yp * scansize + xp ] );
 157     }
 158
 159
 160     /**
 161      * If the ColorModel is the same ColorModel which as already converted
 162      * then it converts it the converted ColorModel. Otherwise it passes the
 163      * array of pixels through filterRGBpixels.
 164      *
 165      * @param x the x coordinate of the rectangle
 166      * @param y the y coordinate of the rectangle
 167      * @param w the width of the rectangle
 168      * @param h the height of the rectangle
 169      * @param model the <code>ColorModel</code> used to translate the pixels
 170      * @param pixels the array of pixel values
 171      * @param offset the index of the first pixels in the <code>pixels</code> array
 172      * @param scansize the width to use in extracting pixels from the <code>pixels</code> array
 173      */
 174     public void setPixels(int x, int y, int w, int h,
 175            ColorModel model, byte[] pixels, int offset, int scansize)
 176     {
 177         if( model == origmodel ) {
 178             consumer.setPixels(x, y, w, h, newmodel, pixels, offset, scansize);
 179         } else {
 180             //FIXME
 181             //convert to proper CM
 182             int pixelsi[] = new int[ pixels.length / 4 ];
 183             filterRGBPixels( x, y, w, h, pixelsi, offset, scansize );
 184         }
 185     }
 186
 187     /**
 188      * This function delivers a rectangle of pixels where any
 189      * pixel(m,n) is stored in the array as an <code>int</code> at
 190      * index (n * scansize + m + offset).
 191      *
 192      * @param x the x coordinate of the rectangle
 193      * @param y the y coordinate of the rectangle
 194      * @param w the width of the rectangle
 195      * @param h the height of the rectangle
 196      * @param model the <code>ColorModel</code> used to translate the pixels
 197      * @param pixels the array of pixel values
 198      * @param offset the index of the first pixels in the <code>pixels</code> array
 199      * @param scansize the width to use in extracting pixels from the <code>pixels</code> array
 200      */
 201     public void setPixels(int x, int y, int w, int h,
 202            ColorModel model, int[] pixels, int offset, int scansize)
 203     {
 204         if( model == origmodel ) {
 205             consumer.setPixels(x, y, w, h, newmodel, pixels, offset, scansize);
 206         } else {
 207             convertColorModelToDefault( x, y, w, h, model, pixels, offset, scansize );
 208             filterRGBPixels( x, y, w, h, pixels, offset, scansize );
 209         }
 210     }
 211
 212     private void convertColorModelToDefault( int x, int y, int w, int h,
 213             ColorModel model, int pixels[], int offset, int scansize)
 214         {
 215         int xp, yp;
 216
 217         for( xp = x; xp < ( x + w); xp++ )
 218             for( yp = y; yp < (y + h); yp++ )
 219                  pixels[ offset + yp * scansize + xp ] =  makeColorbyDefaultCM( pixels[ offset + yp * scansize + xp ] );
 220
 221         }
 222     private int makeColorbyDefaultCM( int rgb )
 223         {
 224             return makeColor( origmodel.getRed( rgb ), origmodel.getGreen( rgb ), origmodel.getGreen( rgb ), origmodel.getBlue( rgb ) );
 225         }
 226
 227
 228     private int makeColor( int a, int r, int g, int b )
 229     {
 230         return (int)( 0xff000000 & (a << 24) | 0xff0000 & (r << 16) | 0xff00 & (b << 8) | 0xff & g );
 231     }
 232
 233
 234     /**
 235        Filters a single pixel from the default ColorModel.
 236
 237        @param x x-coordinate
 238        @param y y-coordinate
 239        @param rgb color
 240      */
 241     public abstract int filterRGB(int x,
 242                                   int y,
 243                                   int rgb);
 244 }