Source for java.awt.image.IndexColorModel

   1: /* IndexColorModel.java -- Java class for interpreting Pixel objects
   2:    Copyright (C) 1999, 2005 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., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 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: package java.awt.image;
  39: 
  40: import gnu.java.awt.Buffers;
  41: 
  42: import java.awt.color.ColorSpace;
  43: import java.math.BigInteger;
  44: 
  45: /**
  46:  * Color model similar to pseudo visual in X11.
  47:  * <br><br>
  48:  * This color model maps linear pixel values to actual RGB and alpha colors.
  49:  * Thus, pixel values are indexes into the color map.  Each color component is
  50:  * an 8-bit unsigned value.
  51:  * <br><br>
  52:  * The <code>IndexColorModel</code> supports a map of valid pixels, allowing
  53:  * the representation of holes in the the color map.  The valid map is
  54:  * represented as a {@link BigInteger} where each bit indicates the validity
  55:  * of the map entry with the same index.
  56:  * <br><br>
  57:  * Colors can have alpha components for transparency support.  If alpha
  58:  * component values aren't given, color values are opaque.  The model also
  59:  * supports a reserved pixel value to represent completely transparent colors,
  60:  * no matter what the actual color component values are.
  61:  * <br><br>
  62:  * <code>IndexColorModel</code> supports anywhere from 1 to 16 bit index
  63:  * values.  The allowed transfer types are {@link DataBuffer#TYPE_BYTE} and
  64:  * {@link DataBuffer#TYPE_USHORT}.
  65:  *
  66:  * @author C. Brian Jones (cbj@gnu.org)
  67:  */
  68: public class IndexColorModel extends ColorModel
  69: {
  70:   private int map_size;
  71:   private boolean opaque;  // no alpha, but doesn't account for trans
  72:   private int trans = -1;
  73:   private int[] rgb;
  74:   private BigInteger validBits = BigInteger.ZERO;
  75: 
  76:   /**
  77:    * Creates a new indexed color model for <code>size</code> color elements
  78:    * with no alpha component.  Each array must contain at least
  79:    * <code>size</code> elements.  For each array, the i-th color is described
  80:    * by reds[i], greens[i] and blues[i].
  81:    *
  82:    * @param bits the number of bits needed to represent <code>size</code>
  83:    *             colors.
  84:    * @param size the number of colors in the color map.
  85:    * @param reds the red component of all colors.
  86:    * @param greens the green component of all colors.
  87:    * @param blues the blue component of all colors.
  88:    *
  89:    * @throws IllegalArgumentException if <code>bits</code> &lt; 1 or
  90:    *         <code>bits</code> &gt; 16.
  91:    * @throws NullPointerException if any of the arrays is <code>null</code>.
  92:    * @throws ArrayIndexOutOfBoundsException if <code>size</code> is greater
  93:    *         than the length of the component arrays.
  94:    */
  95:   public IndexColorModel(int bits, int size, byte[] reds, byte[] greens,
  96:                          byte[] blues)
  97:   {
  98:     this(bits, size, reds, greens, blues, (byte[]) null);
  99:   }
 100: 
 101:   /**
 102:    * Creates a new indexed color model for <code>size</code> color elements.
 103:    * Each array must contain at least <code>size</code> elements.  For each
 104:    * array, the i-th color is described by reds[i], greens[i] and blues[i].
 105:    * All the colors are opaque except for the transparent color.
 106:    *
 107:    * @param bits the number of bits needed to represent <code>size</code>
 108:    *             colors
 109:    * @param size the number of colors in the color map
 110:    * @param reds the red component of all colors
 111:    * @param greens the green component of all colors
 112:    * @param blues the blue component of all colors
 113:    * @param trans the index of the transparent color (use -1 for no
 114:    *              transparent color).
 115:    *
 116:    * @throws IllegalArgumentException if <code>bits</code> &lt; 1 or
 117:    *         <code>bits</code> &gt; 16.
 118:    * @throws NullPointerException if any of the arrays is <code>null</code>.
 119:    * @throws ArrayIndexOutOfBoundsException if <code>size</code> is greater
 120:    *         than the length of the component arrays.
 121:    */
 122:   public IndexColorModel(int bits, int size, byte[] reds, byte[] greens,
 123:                          byte[] blues, int trans)
 124:   {
 125:     super(bits, nArray(8, (0 <= trans && trans < size) ? 4 : 3),
 126:         ColorSpace.getInstance(ColorSpace.CS_sRGB),
 127:         (0 <= trans && trans < size),  // hasAlpha
 128:         false, OPAQUE,
 129:         Buffers.smallestAppropriateTransferType(bits));
 130:     if (bits < 1)
 131:       throw new IllegalArgumentException("bits < 1");
 132:     if (bits > 16)
 133:       throw new IllegalArgumentException("bits > 16");
 134:     if (size < 1)
 135:       throw new IllegalArgumentException("size < 1");
 136:     map_size = size;
 137:     rgb = createColorMap(bits, size);
 138:     for (int i = 0; i < size; i++)
 139:       {
 140:         rgb[i] = (0xff000000
 141:                   | ((reds[i] & 0xff) << 16)
 142:                   | ((greens[i] & 0xff) << 8)
 143:                   | (blues[i] & 0xff));
 144:       }
 145: 
 146:     setTransparentPixel(trans);
 147: 
 148:     // Generate a bigint with 1's for every pixel
 149:     validBits = validBits.setBit(size).subtract(BigInteger.ONE);
 150:   }
 151: 
 152:   /**
 153:    * Creates a new indexed color model for <code>size</code> color elements
 154:    * including alpha.  Each array must contain at least <code>size</code>
 155:    * elements.  For each array, the i-th color is described
 156:    * by reds[i], greens[i], blues[i] and alphas[i].
 157:    *
 158:    * @param bits the number of bits needed to represent <code>size</code>
 159:    *             colors.
 160:    * @param size the number of colors in the color map.
 161:    * @param reds the red component of all colors.
 162:    * @param greens the green component of all colors.
 163:    * @param blues the blue component of all colors.
 164:    * @param alphas the alpha component of all colors (<code>null</code>
 165:    *               permitted).
 166:    *
 167:    * @throws IllegalArgumentException if <code>bits</code> &lt; 1 or
 168:    *           <code>bits</code> &gt; 16.
 169:    * @throws NullPointerException if <code>reds</code>, <code>greens</code> or
 170:    *         <code>blues</code> is <code>null</code>.
 171:    * @throws ArrayIndexOutOfBoundsException if <code>size</code> is greater
 172:    *         than the length of the component arrays.
 173:    */
 174:   public IndexColorModel(int bits, int size, byte[] reds, byte[] greens,
 175:                          byte[] blues, byte[] alphas)
 176:   {
 177:     super(bits, nArray(8, (alphas == null ? 3 : 4)),
 178:         ColorSpace.getInstance(ColorSpace.CS_sRGB),
 179:         (alphas != null), false, TRANSLUCENT,
 180:         Buffers.smallestAppropriateTransferType(bits));
 181:     if (bits < 1)
 182:       throw new IllegalArgumentException("bits < 1");
 183:     if (bits > 16)
 184:       throw new IllegalArgumentException("bits > 16");
 185:     if (size < 1)
 186:       throw new IllegalArgumentException("size < 1");
 187:     map_size = size;
 188:     opaque = (alphas == null);
 189: 
 190:     rgb = createColorMap(bits, size);
 191:     if (alphas == null)
 192:       {
 193:         for (int i = 0; i < size; i++)
 194:           {
 195:             rgb[i] = (0xff000000
 196:                       | ((reds[i] & 0xff) << 16)
 197:                       | ((greens[i] & 0xff) << 8)
 198:                       | (blues[i] & 0xff));
 199:           }
 200:         transparency = OPAQUE;
 201:       }
 202:     else
 203:       {
 204:         byte alphaZero = (byte) 0x00;
 205:         byte alphaOne = (byte) 0xFF;
 206:         for (int i = 0; i < size; i++)
 207:           {
 208:             alphaZero = (byte) (alphaZero | alphas[i]);
 209:             alphaOne = (byte) (alphaOne & alphas[i]);
 210:             rgb[i] = ((alphas[i] & 0xff) << 24
 211:                       | ((reds[i] & 0xff) << 16)
 212:                       | ((greens[i] & 0xff) << 8)
 213:                       | (blues[i] & 0xff));
 214:           }
 215:         if ((alphaZero == (byte) 0x00) || (alphaOne == (byte) 0xFF))
 216:           transparency = BITMASK;
 217:         else
 218:           transparency = TRANSLUCENT;
 219:       }
 220: 
 221:     // Generate a bigint with 1's for every pixel
 222:     validBits = validBits.setBit(size).subtract(BigInteger.ONE);
 223:   }
 224: 
 225:   /**
 226:    * Creates a new indexed color model using the color components in
 227:    * <code>cmap</code>. If <code>hasAlpha</code> is <code>true</code> then
 228:    * <code>cmap</code> contains an alpha component after each of the red, green
 229:    * and blue components.
 230:    *
 231:    * @param bits the number of bits needed to represent <code>size</code>
 232:    *             colors
 233:    * @param size the number of colors in the color map
 234:    * @param cmap packed color components
 235:    * @param start the offset of the first color component in <code>cmap</code>
 236:    * @param hasAlpha <code>cmap</code> has alpha values
 237:    * @throws IllegalArgumentException if bits &lt; 1, bits &gt; 16, or size
 238:    *         &lt; 1.
 239:    * @throws NullPointerException if <code>cmap</code> is <code>null</code>.
 240:    */
 241:   public IndexColorModel(int bits, int size, byte[] cmap, int start,
 242:                          boolean hasAlpha)
 243:   {
 244:     this(bits, size, cmap, start, hasAlpha, -1);
 245:   }
 246: 
 247:   /**
 248:    * Construct an IndexColorModel from an array of red, green, blue, and
 249:    * optional alpha components. The component values are interleaved as RGB(A).
 250:    *
 251:    * @param bits the number of bits needed to represent <code>size</code>
 252:    *             colors
 253:    * @param size the number of colors in the color map
 254:    * @param cmap interleaved color components
 255:    * @param start the offset of the first color component in <code>cmap</code>
 256:    * @param hasAlpha <code>cmap</code> has alpha values
 257:    * @param trans the index of the transparent color
 258:    * @throws IllegalArgumentException if bits &lt; 1, bits &gt; 16, or size
 259:    *         &lt; 1.
 260:    * @throws NullPointerException if <code>cmap</code> is <code>null</code>.
 261:    */
 262:   public IndexColorModel(int bits, int size, byte[] cmap, int start,
 263:                          boolean hasAlpha, int trans)
 264:   {
 265:     super(bits, nArray(8, hasAlpha || (0 <= trans && trans < size) ? 4 : 3),
 266:         ColorSpace.getInstance(ColorSpace.CS_sRGB),
 267:         hasAlpha || (0 <= trans && trans < size), false, OPAQUE,
 268:         Buffers.smallestAppropriateTransferType(bits));
 269:     if (bits < 1)
 270:       throw new IllegalArgumentException("bits < 1");
 271:     if (bits > 16)
 272:       throw new IllegalArgumentException("bits > 16");
 273:     if (size < 1)
 274:       throw new IllegalArgumentException("size < 1");
 275:     map_size = size;
 276:     opaque = !hasAlpha;
 277: 
 278:     rgb = createColorMap(bits, size);
 279:     if (hasAlpha)
 280:     {
 281:       int alpha;
 282:       int alphaZero = 0x00;  // use to detect all zeros
 283:       int alphaOne = 0xff;   // use to detect all ones
 284:       for (int i = 0; i < size; i++) {
 285:         alpha = cmap[4 * i + 3 + start] & 0xff;
 286:         alphaZero = alphaZero | alpha;
 287:         alphaOne = alphaOne & alpha;
 288:         rgb[i] =
 289:           ( alpha << 24
 290:            // red
 291:            | ((cmap[4 * i + start] & 0xff) << 16)
 292:            // green
 293:            | ((cmap[4 * i + 1 + start] & 0xff) << 8)
 294:            // blue
 295:            | (cmap[4 * i + 2 + start] & 0xff));
 296:       }
 297:       if (alphaZero == 0)
 298:         transparency = BITMASK;
 299:       else if (alphaOne == 255)
 300:         transparency = (trans != -1 ? BITMASK : OPAQUE);
 301:       else
 302:         transparency = TRANSLUCENT;
 303:     }
 304:     else
 305:     {
 306:       for (int i = 0; i < size; i++)
 307:         rgb[i] = (0xff000000
 308:                   // red
 309:                   | ((cmap[3 * i + start] & 0xff) << 16)
 310:                   // green
 311:                   | ((cmap[3 * i + 1 + start] & 0xff) << 8)
 312:                   // blue
 313:                   | (cmap[3 * i + 2 + start] & 0xff));
 314:       if (trans != -1)
 315:         transparency = BITMASK;
 316:     }
 317: 
 318:     setTransparentPixel(trans);
 319: 
 320:     // Generate a bigint with 1's for every pixel
 321:     validBits = validBits.setBit(size).subtract(BigInteger.ONE);
 322:   }
 323: 
 324:   /**
 325:    * Construct an IndexColorModel from an array of <code>size</code> packed
 326:    * colors.  Each int element contains 8-bit red, green, blue, and optional
 327:    * alpha values packed in order.  If hasAlpha is false, then all the colors
 328:    * are opaque except for the transparent color.
 329:    *
 330:    * @param bits the number of bits needed to represent <code>size</code>
 331:    *             colors
 332:    * @param size the number of colors in the color map
 333:    * @param cmap packed color components
 334:    * @param start the offset of the first color component in <code>cmap</code>
 335:    * @param hasAlpha <code>cmap</code> has alpha values
 336:    * @param trans the index of the transparent color
 337:    * @param transferType {@link DataBuffer#TYPE_BYTE} or
 338:             {@link DataBuffer#TYPE_USHORT}.
 339:    * @throws IllegalArgumentException if bits &lt; 1, bits &gt; 16, or size
 340:    *         &lt; 1.
 341:    * @throws IllegalArgumentException if <code>transferType</code> is something
 342:    *         other than {@link DataBuffer#TYPE_BYTE} or
 343:    *         {@link DataBuffer#TYPE_USHORT}.
 344:    */
 345:   public IndexColorModel(int bits, int size, int[] cmap, int start,
 346:                          boolean hasAlpha, int trans, int transferType)
 347:   {
 348:     super(bits,
 349:           nArray(8, 4), // bits for each channel
 350:           ColorSpace.getInstance(ColorSpace.CS_sRGB), // sRGB
 351:           true, // has alpha
 352:           false, // not premultiplied
 353:           TRANSLUCENT, transferType);
 354:     if (transferType != DataBuffer.TYPE_BYTE
 355:         && transferType != DataBuffer.TYPE_USHORT)
 356:       throw new IllegalArgumentException();
 357:     if (bits > 16)
 358:       throw new IllegalArgumentException("bits > 16");
 359:     if (size < 1)
 360:       throw new IllegalArgumentException("size < 1");
 361:     map_size = size;
 362:     opaque = !hasAlpha;
 363:     rgb = createColorMap(bits, size);
 364:     if (!hasAlpha)
 365:       for (int i = 0; i < size; i++)
 366:         rgb[i] = cmap[i + start] | 0xff000000;
 367:     else
 368:       System.arraycopy(cmap, start, rgb, 0, size);
 369: 
 370:     setTransparentPixel(trans);
 371: 
 372:     // Generate a bigint with 1's for every pixel
 373:     validBits = validBits.setBit(size).subtract(BigInteger.ONE);
 374:   }
 375: 
 376:   /**
 377:    * Construct an IndexColorModel using a colormap with holes.
 378:    * <br><br>
 379:    * The IndexColorModel is built from the array of ints defining the
 380:    * colormap.  Each element contains red, green, blue, and alpha
 381:    * components.    The ColorSpace is sRGB.  The transparency value is
 382:    * automatically determined.
 383:    * <br><br>
 384:    * This constructor permits indicating which colormap entries are valid,
 385:    * using the validBits argument.  Each entry in cmap is valid if the
 386:    * corresponding bit in validBits is set.
 387:    *
 388:    * @param bits the number of bits needed to represent <code>size</code>
 389:    *             colors.
 390:    * @param size the number of colors in the color map.
 391:    * @param cmap packed color components.
 392:    * @param start the offset of the first color component in <code>cmap</code>.
 393:    * @param transferType {@link DataBuffer#TYPE_BYTE} or
 394:    *                     {@link DataBuffer#TYPE_USHORT}.
 395:    * @param validBits a map of the valid entries in <code>cmap</code>.
 396:    * @throws IllegalArgumentException if bits &lt; 1, bits &gt; 16, or size
 397:    *         &lt; 1.
 398:    * @throws IllegalArgumentException if transferType is something other than
 399:    *         {@link DataBuffer#TYPE_BYTE} or {@link DataBuffer#TYPE_USHORT}.
 400:    */
 401:   public IndexColorModel(int bits, int size, int[] cmap, int start,
 402:                          int transferType, BigInteger validBits)
 403:   {
 404:     super(bits, // total bits, sRGB, four channels
 405:           nArray(8, 4), // bits for each channel
 406:           ColorSpace.getInstance(ColorSpace.CS_sRGB), // sRGB
 407:           true, // has alpha
 408:           false, // not premultiplied
 409:           TRANSLUCENT, transferType);
 410:     if (transferType != DataBuffer.TYPE_BYTE
 411:         && transferType != DataBuffer.TYPE_USHORT)
 412:       throw new IllegalArgumentException();
 413:     if (bits > 16)
 414:       throw new IllegalArgumentException("bits > 16");
 415:     if (size < 1)
 416:       throw new IllegalArgumentException("size < 1");
 417:     map_size = size;
 418:     opaque = false;
 419:     this.trans = -1;
 420:     this.validBits = validBits;
 421: 
 422:     rgb = createColorMap(bits, size);
 423:     if (!hasAlpha)
 424:       for (int i = 0; i < size; i++)
 425:         rgb[i] = cmap[i + start] | 0xff000000;
 426:     else
 427:       System.arraycopy(cmap, start, rgb, 0, size);
 428:   }
 429: 
 430:   /**
 431:    * Returns the size of the color lookup table.
 432:    *
 433:    * @return The size of the color lookup table.
 434:    */
 435:   public final int getMapSize()
 436:   {
 437:     return map_size;
 438:   }
 439: 
 440:   /**
 441:    * Get the index of the transparent color in this color model.
 442:    *
 443:    * @return The index of the color that is considered transparent, or -1 if
 444:    *         there is no transparent color.
 445:    */
 446:   public final int getTransparentPixel()
 447:   {
 448:     return trans;
 449:   }
 450: 
 451:   /**
 452:    * Fills the supplied array with the red component of each color in the
 453:    * lookup table.
 454:    *
 455:    * @param r an array that is at least as large as {@link #getMapSize()}.
 456:    * @throws NullPointerException if <code>r</code> is <code>null</code>.
 457:    * @throws ArrayIndexOutOfBoundsException if <code>r</code> has less
 458:    *         than {@link #getMapSize()} elements.
 459:    */
 460:   public final void getReds(byte[] r)
 461:   {
 462:     int i;
 463:     for (i = 0; i < map_size; i++)
 464:       r[i] = (byte) ((0x00FF0000  & rgb[i]) >> 16);
 465:   }
 466: 
 467:   /**
 468:    * Fills the supplied array with the green component of each color in the
 469:    * lookup table.
 470:    *
 471:    * @param g an array that is at least as large as {@link #getMapSize()}.
 472:    * @throws NullPointerException if <code>g</code> is <code>null</code>.
 473:    * @throws ArrayIndexOutOfBoundsException if <code>g</code> has less
 474:    *         than {@link #getMapSize()} elements.
 475:    */
 476:   public final void getGreens(byte[] g)
 477:   {
 478:     int i;
 479:     for (i = 0; i < map_size; i++)
 480:       g[i] = (byte) ((0x0000FF00  & rgb[i]) >> 8);
 481:   }
 482: 
 483:   /**
 484:    * Fills the supplied array with the blue component of each color in the
 485:    * lookup table.
 486:    *
 487:    * @param b an array that is at least as large as {@link #getMapSize()}.
 488:    * @throws NullPointerException if <code>b</code> is <code>null</code>.
 489:    * @throws ArrayIndexOutOfBoundsException if <code>b</code> has less
 490:    *         than {@link #getMapSize()} elements.
 491:    */
 492:   public final void getBlues(byte[] b)
 493:   {
 494:     int i;
 495:     for (i = 0; i < map_size; i++)
 496:       b[i] = (byte) (0x000000FF & rgb[i]);
 497:   }
 498: 
 499:   /**
 500:    * Fills the supplied array with the alpha component of each color in the
 501:    * lookup table.  If the model has a transparent pixel specified, the alpha
 502:    * for that pixel will be 0.
 503:    *
 504:    * @param a an array that is at least as large as {@link #getMapSize()}.
 505:    * @throws NullPointerException if <code>a</code> is <code>null</code>.
 506:    * @throws ArrayIndexOutOfBoundsException if <code>a</code> has less
 507:    *         than {@link #getMapSize()} elements.
 508:    */
 509:   public final void getAlphas(byte[] a)
 510:   {
 511:     int i;
 512:     for (i = 0; i < map_size; i++)
 513:       if (i == trans)
 514:         a[i] = (byte) 0;
 515:       else
 516:         a[i] = (byte) ((0xFF000000  & rgb[i]) >> 24);
 517:   }
 518: 
 519:   /**
 520:    * Returns the red component of the color in the lookup table for the
 521:    * given pixel value.
 522:    *
 523:    * @param pixel  the pixel lookup value.
 524:    *
 525:    * @return The red component of the color in the lookup table.
 526:    * @throws ArrayIndexOutOfBoundsException if <code>pixel</code> is negative.
 527:    */
 528:   public final int getRed(int pixel)
 529:   {
 530:     if (pixel < map_size)
 531:       return (0x00FF0000 & rgb[pixel]) >> 16;
 532: 
 533:     return 0;
 534:   }
 535: 
 536:   /**
 537:    * Returns the green component of the color in the lookup table for the
 538:    * given pixel value.
 539:    *
 540:    * @param pixel  the pixel lookup value.
 541:    *
 542:    * @return The green component of the color in the lookup table.
 543:    * @throws ArrayIndexOutOfBoundsException if <code>pixel</code> is negative.
 544:    */
 545:   public final int getGreen(int pixel)
 546:   {
 547:     if (pixel < map_size)
 548:       return (0x0000FF00 & rgb[pixel]) >> 8;
 549: 
 550:     return 0;
 551:   }
 552: 
 553:   /**
 554:    * Returns the blue component of the color in the lookup table for the
 555:    * given pixel value.
 556:    *
 557:    * @param pixel  the pixel lookup value.
 558:    *
 559:    * @return The blue component of the color in the lookup table.
 560:    * @throws ArrayIndexOutOfBoundsException if <code>pixel</code> is negative.
 561:    */
 562:   public final int getBlue(int pixel)
 563:   {
 564:     if (pixel < map_size)
 565:       return 0x000000FF & rgb[pixel];
 566: 
 567:     return 0;
 568:   }
 569: 
 570:   /**
 571:    * Returns the alpha component of the color in the lookup table for the
 572:    * given pixel value. If no alpha channel was specified when the color model
 573:    * was created, then 255 is returned for all pixels except the transparent
 574:    * pixel (if one is defined - see {@link #getTransparentPixel()}) which
 575:    * returns an alpha of 0.
 576:    *
 577:    * @param pixel  the pixel lookup value.
 578:    *
 579:    * @return The alpha component of the color in the lookup table (in the
 580:    *         range 0 to 255).
 581:    * @throws ArrayIndexOutOfBoundsException if <code>pixel</code> is negative.
 582:    */
 583:   public final int getAlpha(int pixel)
 584:   {
 585:     return (rgb[pixel] >> 24) & 0xFF;
 586:   }
 587: 
 588:   /**
 589:    * Get the RGB color value of the given pixel using the default
 590:    * RGB color model.
 591:    *
 592:    * @param pixel the pixel lookup value.
 593:    * @return The RGB color value.
 594:    * @throws ArrayIndexOutOfBoundsException if <code>pixel</code> is negative.
 595:    */
 596:   public final int getRGB(int pixel)
 597:   {
 598:     if (pixel >= 0 && pixel < map_size)
 599:       return rgb[pixel];
 600: 
 601:     return 0;
 602:   }
 603: 
 604:   /**
 605:    * Get the RGB color values of all pixels in the map using the default
 606:    * RGB color model.
 607:    *
 608:    * @param rgb The destination array.
 609:    */
 610:   public final void getRGBs(int[] rgb)
 611:   {
 612:     System.arraycopy(this.rgb, 0, rgb, 0, map_size);
 613:   }
 614: 
 615:   /**
 616:    * Return <code>true</code> if the lookup table contains valid data for
 617:    * <code>pixel</code>, and <code>false</code> otherwise.
 618:    *
 619:    * @param pixel  the pixel value used to index the color lookup table.
 620:    * @return <code>true</code> if <code>pixel</code> is valid,
 621:    *         <code>false</code> otherwise.
 622:    */
 623:   public boolean isValid(int pixel)
 624:   {
 625:     if (pixel >= 0)
 626:       return validBits.testBit(pixel);
 627:     return false;
 628:   }
 629: 
 630:   /**
 631:    * Return <code>true</code> if all pixels are valid, <code>false</code>
 632:    * otherwise.
 633:    *
 634:    * @return <code>true</code> if all pixels are valid, <code>false</code>
 635:    * otherwise.
 636:    */
 637:   public boolean isValid()
 638:   {
 639:     // Generate a bigint with 1's for every pixel
 640:     BigInteger allbits = new BigInteger("0");
 641:     allbits = allbits.setBit(map_size);
 642:     allbits = allbits.subtract(new BigInteger("1"));
 643:     return allbits.equals(validBits);
 644:   }
 645: 
 646:   /**
 647:    * Returns a binary value ({@link BigInteger}) where each bit represents an
 648:    * entry in the color lookup table.  If the bit is on, the entry is valid.
 649:    *
 650:    * @return The binary value.
 651:    */
 652:   public BigInteger getValidPixels()
 653:   {
 654:     return validBits;
 655:   }
 656: 
 657:   /**
 658:    * Construct a {@link BufferedImage} with rgb pixel values from a
 659:    * {@link Raster}.
 660:    *
 661:    * Constructs a new BufferedImage in which each pixel is an RGBA int from
 662:    * a Raster with index-valued pixels.  If this model has no alpha component
 663:    * or transparent pixel, the type of the new BufferedImage is TYPE_INT_RGB.
 664:    * Otherwise the type is TYPE_INT_ARGB.  If forceARGB is true, the type is
 665:    * forced to be TYPE_INT_ARGB no matter what.
 666:    *
 667:    * @param raster The source of pixel values.
 668:    * @param forceARGB True if type must be TYPE_INT_ARGB.
 669:    * @return New BufferedImage with RBGA int pixel values.
 670:    */
 671:   public BufferedImage convertToIntDiscrete(Raster raster, boolean forceARGB)
 672:   {
 673:     int type = forceARGB ? BufferedImage.TYPE_INT_ARGB
 674:       : ((opaque && trans == -1) ? BufferedImage.TYPE_INT_RGB :
 675:          BufferedImage.TYPE_INT_ARGB);
 676: 
 677:     // FIXME: assuming that raster has only 1 band since pixels are supposed
 678:     // to be int indexes.
 679:     // FIXME: it would likely be more efficient to fetch a complete array,
 680:     // but it would take much more memory.
 681:     // FIXME: I'm not sure if transparent pixels or alpha values need special
 682:     // handling here.
 683:     BufferedImage im = new BufferedImage(raster.width, raster.height, type);
 684:     for (int x = raster.minX; x < raster.width + raster.minX; x++)
 685:       for (int y = raster.minY; y < raster.height + raster.minY; y++)
 686:         im.setRGB(x, y, rgb[raster.getSample(x, y, 0)]);
 687: 
 688:     return im;
 689:   }
 690: 
 691:   /**
 692:    * Creates a {@link SampleModel} that is compatible to this color model.
 693:    * This will be a {@link MultiPixelPackedSampleModel} for bits/pixel of
 694:    * 1, 2 or 4, or a {@link ComponentColorModel} for the other cases.
 695:    *
 696:    * @param w the width of the sample model to create
 697:    * @param h the height of the sample model to create
 698:    *
 699:    * @return a compatible sample model
 700:    */
 701:   public SampleModel createCompatibleSampleModel(int w, int h)
 702:   {
 703:     SampleModel sm;
 704:     if (pixel_bits == 1 || pixel_bits == 2 || pixel_bits == 4)
 705:       sm = new MultiPixelPackedSampleModel(transferType, w, h, pixel_bits);
 706:     else
 707:       sm = new ComponentSampleModel(transferType, w, h, 1, w, new int[]{0});
 708:     return sm;
 709:   }
 710: 
 711:   /**
 712:    * Sets the transparent pixel. This is called by the various constructors.
 713:    *
 714:    * @param t the transparent pixel
 715:    */
 716:   private void setTransparentPixel(int t)
 717:   {
 718:     if (t >= 0 && t < map_size)
 719:       {
 720:         rgb[t] &= 0xffffff; // Make the value transparent.
 721:         trans = t;
 722:         if (transparency == OPAQUE)
 723:           {
 724:             transparency = BITMASK;
 725:             hasAlpha = true;
 726:           }
 727:       }
 728:   }
 729: 
 730:   private int[] createColorMap(int bits, int size)
 731:   {
 732:     // According to a Mauve test, the RI allocates at least 256 entries here.
 733:     int realSize = Math.max(256, Math.max(1 << bits, size));
 734:     return new int[realSize];
 735:   }
 736: }