1 /*
   2  * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package java.awt.image;
  27 
  28 import java.awt.color.ColorSpace;
  29 import java.awt.color.ICC_ColorSpace;
  30 
  31 /**
  32  * A {@code ColorModel} class that works with pixel values that
  33  * represent color and alpha information as separate samples and that
  34  * store each sample in a separate data element.  This class can be
  35  * used with an arbitrary {@code ColorSpace}.  The number of
  36  * color samples in the pixel values must be same as the number of
  37  * color components in the {@code ColorSpace}. There may be a
  38  * single alpha sample.
  39  * <p>
  40  * For those methods that use
  41  * a primitive array pixel representation of type {@code transferType},
  42  * the array length is the same as the number of color and alpha samples.
  43  * Color samples are stored first in the array followed by the alpha
  44  * sample, if present.  The order of the color samples is specified
  45  * by the {@code ColorSpace}.  Typically, this order reflects the
  46  * name of the color space type. For example, for {@code TYPE_RGB},
  47  * index 0 corresponds to red, index 1 to green, and index 2 to blue.
  48  * <p>
  49  * The translation from pixel sample values to color/alpha components for
  50  * display or processing purposes is based on a one-to-one correspondence of
  51  * samples to components.
  52  * Depending on the transfer type used to create an instance of
  53  * {@code ComponentColorModel}, the pixel sample values
  54  * represented by that instance may be signed or unsigned and may
  55  * be of integral type or float or double (see below for details).
  56  * The translation from sample values to normalized color/alpha components
  57  * must follow certain rules.  For float and double samples, the translation
  58  * is an identity, i.e. normalized component values are equal to the
  59  * corresponding sample values.  For integral samples, the translation
  60  * should be only a simple scale and offset, where the scale and offset
  61  * constants may be different for each component.  The result of
  62  * applying the scale and offset constants is a set of color/alpha
  63  * component values, which are guaranteed to fall within a certain
  64  * range.  Typically, the range for a color component will be the range
  65  * defined by the {@code getMinValue} and {@code getMaxValue}
  66  * methods of the {@code ColorSpace} class.  The range for an
  67  * alpha component should be 0.0 to 1.0.
  68  * <p>
  69  * Instances of {@code ComponentColorModel} created with transfer types
  70  * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
  71  * and {@code DataBuffer.TYPE_INT} have pixel sample values which
  72  * are treated as unsigned integral values.
  73  * The number of bits in a color or alpha sample of a pixel value might not
  74  * be the same as the number of bits for the corresponding color or alpha
  75  * sample passed to the
  76  * {@code ComponentColorModel(ColorSpace, int[], boolean, boolean, int, int)}
  77  * constructor.  In
  78  * that case, this class assumes that the least significant n bits of a sample
  79  * value hold the component value, where n is the number of significant bits
  80  * for the component passed to the constructor.  It also assumes that
  81  * any higher-order bits in a sample value are zero.  Thus, sample values
  82  * range from 0 to 2<sup>n</sup> - 1.  This class maps these sample values
  83  * to normalized color component values such that 0 maps to the value
  84  * obtained from the {@code ColorSpace's getMinValue}
  85  * method for each component and 2<sup>n</sup> - 1 maps to the value
  86  * obtained from {@code getMaxValue}.  To create a
  87  * {@code ComponentColorModel} with a different color sample mapping
  88  * requires subclassing this class and overriding the
  89  * {@code getNormalizedComponents(Object, float[], int)} method.
  90  * The mapping for an alpha sample always maps 0 to 0.0 and
  91  * 2<sup>n</sup> - 1 to 1.0.
  92  * <p>
  93  * For instances with unsigned sample values,
  94  * the unnormalized color/alpha component representation is only
  95  * supported if two conditions hold.  First, sample value 0 must
  96  * map to normalized component value 0.0 and sample value 2<sup>n</sup> - 1
  97  * to 1.0.  Second the min/max range of all color components of the
  98  * {@code ColorSpace} must be 0.0 to 1.0.  In this case, the
  99  * component representation is the n least
 100  * significant bits of the corresponding sample.  Thus each component is
 101  * an unsigned integral value between 0 and 2<sup>n</sup> - 1, where
 102  * n is the number of significant bits for a particular component.
 103  * If these conditions are not met, any method taking an unnormalized
 104  * component argument will throw an {@code IllegalArgumentException}.
 105  * <p>
 106  * Instances of {@code ComponentColorModel} created with transfer types
 107  * {@code DataBuffer.TYPE_SHORT}, {@code DataBuffer.TYPE_FLOAT}, and
 108  * {@code DataBuffer.TYPE_DOUBLE} have pixel sample values which
 109  * are treated as signed short, float, or double values.
 110  * Such instances do not support the unnormalized color/alpha component
 111  * representation, so any methods taking such a representation as an argument
 112  * will throw an {@code IllegalArgumentException} when called on one
 113  * of these instances.  The normalized component values of instances
 114  * of this class have a range which depends on the transfer
 115  * type as follows: for float samples, the full range of the float data
 116  * type; for double samples, the full range of the float data type
 117  * (resulting from casting double to float); for short samples,
 118  * from approximately -maxVal to +maxVal, where maxVal is the per
 119  * component maximum value for the {@code ColorSpace}
 120  * (-32767 maps to -maxVal, 0 maps to 0.0, and 32767 maps
 121  * to +maxVal).  A subclass may override the scaling for short sample
 122  * values to normalized component values by overriding the
 123  * {@code getNormalizedComponents(Object, float[], int)} method.
 124  * For float and double samples, the normalized component values are
 125  * taken to be equal to the corresponding sample values, and subclasses
 126  * should not attempt to add any non-identity scaling for these transfer
 127  * types.
 128  * <p>
 129  * Instances of {@code ComponentColorModel} created with transfer types
 130  * {@code DataBuffer.TYPE_SHORT}, {@code DataBuffer.TYPE_FLOAT}, and
 131  * {@code DataBuffer.TYPE_DOUBLE}
 132  * use all the bits of all sample values.  Thus all color/alpha components
 133  * have 16 bits when using {@code DataBuffer.TYPE_SHORT}, 32 bits when
 134  * using {@code DataBuffer.TYPE_FLOAT}, and 64 bits when using
 135  * {@code DataBuffer.TYPE_DOUBLE}.  When the
 136  * {@code ComponentColorModel(ColorSpace, int[], boolean, boolean, int, int)}
 137  * form of constructor is used with one of these transfer types, the
 138  * bits array argument is ignored.
 139  * <p>
 140  * It is possible to have color/alpha sample values
 141  * which cannot be reasonably interpreted as component values for rendering.
 142  * This can happen when {@code ComponentColorModel} is subclassed to
 143  * override the mapping of unsigned sample values to normalized color
 144  * component values or when signed sample values outside a certain range
 145  * are used.  (As an example, specifying an alpha component as a signed
 146  * short value outside the range 0 to 32767, normalized range 0.0 to 1.0, can
 147  * lead to unexpected results.) It is the
 148  * responsibility of applications to appropriately scale pixel data before
 149  * rendering such that color components fall within the normalized range
 150  * of the {@code ColorSpace} (obtained using the {@code getMinValue}
 151  * and {@code getMaxValue} methods of the {@code ColorSpace} class)
 152  * and the alpha component is between 0.0 and 1.0.  If color or alpha
 153  * component values fall outside these ranges, rendering results are
 154  * indeterminate.
 155  * <p>
 156  * Methods that use a single int pixel representation throw
 157  * an {@code IllegalArgumentException}, unless the number of components
 158  * for the {@code ComponentColorModel} is one and the component
 159  * value is unsigned -- in other words,  a single color component using
 160  * a transfer type of {@code DataBuffer.TYPE_BYTE},
 161  * {@code DataBuffer.TYPE_USHORT}, or {@code DataBuffer.TYPE_INT}
 162  * and no alpha.
 163  * <p>
 164  * A {@code ComponentColorModel} can be used in conjunction with a
 165  * {@code ComponentSampleModel}, a {@code BandedSampleModel},
 166  * or a {@code PixelInterleavedSampleModel} to construct a
 167  * {@code BufferedImage}.
 168  *
 169  * @see ColorModel
 170  * @see ColorSpace
 171  * @see ComponentSampleModel
 172  * @see BandedSampleModel
 173  * @see PixelInterleavedSampleModel
 174  * @see BufferedImage
 175  *
 176  */
 177 public class ComponentColorModel extends ColorModel {
 178 
 179     /**
 180      * {@code signed}  is {@code true} for {@code short},
 181      * {@code float}, and {@code double} transfer types; it
 182      * is {@code false} for {@code byte}, {@code ushort},
 183      * and {@code int} transfer types.
 184      */
 185     private boolean signed; // true for transfer types short, float, double
 186                             // false for byte, ushort, int
 187     private boolean is_sRGB_stdScale;
 188     private boolean is_LinearRGB_stdScale;
 189     private boolean is_LinearGray_stdScale;
 190     private boolean is_ICCGray_stdScale;
 191     private byte[] tosRGB8LUT;
 192     private byte[] fromsRGB8LUT8;
 193     private short[] fromsRGB8LUT16;
 194     private byte[] fromLinearGray16ToOtherGray8LUT;
 195     private short[] fromLinearGray16ToOtherGray16LUT;
 196     private boolean needScaleInit;
 197     private boolean noUnnorm;
 198     private boolean nonStdScale;
 199     private float[] min;
 200     private float[] diffMinMax;
 201     private float[] compOffset;
 202     private float[] compScale;
 203 
 204     /**
 205      * Constructs a {@code ComponentColorModel} from the specified
 206      * parameters. Color components will be in the specified
 207      * {@code ColorSpace}.  The supported transfer types are
 208      * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
 209      * {@code DataBuffer.TYPE_INT},
 210      * {@code DataBuffer.TYPE_SHORT}, {@code DataBuffer.TYPE_FLOAT},
 211      * and {@code DataBuffer.TYPE_DOUBLE}.
 212      * If not null, the {@code bits} array specifies the
 213      * number of significant bits per color and alpha component and its
 214      * length should be at least the number of components in the
 215      * {@code ColorSpace} if there is no alpha
 216      * information in the pixel values, or one more than this number if
 217      * there is alpha information.  When the {@code transferType} is
 218      * {@code DataBuffer.TYPE_SHORT}, {@code DataBuffer.TYPE_FLOAT},
 219      * or {@code DataBuffer.TYPE_DOUBLE} the {@code bits} array
 220      * argument is ignored.  {@code hasAlpha} indicates whether alpha
 221      * information is present.  If {@code hasAlpha} is true, then
 222      * the boolean {@code isAlphaPremultiplied}
 223      * specifies how to interpret color and alpha samples in pixel values.
 224      * If the boolean is true, color samples are assumed to have been
 225      * multiplied by the alpha sample. The {@code transparency}
 226      * specifies what alpha values can be represented by this color model.
 227      * The acceptable {@code transparency} values are
 228      * {@code OPAQUE}, {@code BITMASK} or {@code TRANSLUCENT}.
 229      * The {@code transferType} is the type of primitive array used
 230      * to represent pixel values.
 231      *
 232      * @param colorSpace       The {@code ColorSpace} associated
 233      *                         with this color model.
 234      * @param bits             The number of significant bits per component.
 235      *                         May be null, in which case all bits of all
 236      *                         component samples will be significant.
 237      *                         Ignored if transferType is one of
 238      *                         {@code DataBuffer.TYPE_SHORT},
 239      *                         {@code DataBuffer.TYPE_FLOAT}, or
 240      *                         {@code DataBuffer.TYPE_DOUBLE},
 241      *                         in which case all bits of all component
 242      *                         samples will be significant.
 243      * @param hasAlpha         If true, this color model supports alpha.
 244      * @param isAlphaPremultiplied If true, alpha is premultiplied.
 245      * @param transparency     Specifies what alpha values can be represented
 246      *                         by this color model.
 247      * @param transferType     Specifies the type of primitive array used to
 248      *                         represent pixel values.
 249      *
 250      * @throws IllegalArgumentException If the {@code bits} array
 251      *         argument is not null, its length is less than the number of
 252      *         color and alpha components, and transferType is one of
 253      *         {@code DataBuffer.TYPE_BYTE},
 254      *         {@code DataBuffer.TYPE_USHORT}, or
 255      *         {@code DataBuffer.TYPE_INT}.
 256      * @throws IllegalArgumentException If transferType is not one of
 257      *         {@code DataBuffer.TYPE_BYTE},
 258      *         {@code DataBuffer.TYPE_USHORT},
 259      *         {@code DataBuffer.TYPE_INT},
 260      *         {@code DataBuffer.TYPE_SHORT},
 261      *         {@code DataBuffer.TYPE_FLOAT}, or
 262      *         {@code DataBuffer.TYPE_DOUBLE}.
 263      *
 264      * @see ColorSpace
 265      * @see java.awt.Transparency
 266      */
 267     public ComponentColorModel (ColorSpace colorSpace,
 268                                 int[] bits,
 269                                 boolean hasAlpha,
 270                                 boolean isAlphaPremultiplied,
 271                                 int transparency,
 272                                 int transferType) {
 273         super (bitsHelper(transferType, colorSpace, hasAlpha),
 274                bitsArrayHelper(bits, transferType, colorSpace, hasAlpha),
 275                colorSpace, hasAlpha, isAlphaPremultiplied, transparency,
 276                transferType);
 277         switch(transferType) {
 278             case DataBuffer.TYPE_BYTE:
 279             case DataBuffer.TYPE_USHORT:
 280             case DataBuffer.TYPE_INT:
 281                 signed = false;
 282                 needScaleInit = true;
 283                 break;
 284             case DataBuffer.TYPE_SHORT:
 285                 signed = true;
 286                 needScaleInit = true;
 287                 break;
 288             case DataBuffer.TYPE_FLOAT:
 289             case DataBuffer.TYPE_DOUBLE:
 290                 signed = true;
 291                 needScaleInit = false;
 292                 noUnnorm = true;
 293                 nonStdScale = false;
 294                 break;
 295             default:
 296                 throw new IllegalArgumentException("This constructor is not "+
 297                          "compatible with transferType " + transferType);
 298         }
 299         setupLUTs();
 300     }
 301 
 302     /**
 303      * Constructs a {@code ComponentColorModel} from the specified
 304      * parameters. Color components will be in the specified
 305      * {@code ColorSpace}.  The supported transfer types are
 306      * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
 307      * {@code DataBuffer.TYPE_INT},
 308      * {@code DataBuffer.TYPE_SHORT}, {@code DataBuffer.TYPE_FLOAT},
 309      * and {@code DataBuffer.TYPE_DOUBLE}.  The number of significant
 310      * bits per color and alpha component will be 8, 16, 32, 16, 32,  or 64,
 311      * respectively.  The number of color components will be the
 312      * number of components in the {@code ColorSpace}.  There will be
 313      * an alpha component if {@code hasAlpha} is {@code true}.
 314      * If {@code hasAlpha} is true, then
 315      * the boolean {@code isAlphaPremultiplied}
 316      * specifies how to interpret color and alpha samples in pixel values.
 317      * If the boolean is true, color samples are assumed to have been
 318      * multiplied by the alpha sample. The {@code transparency}
 319      * specifies what alpha values can be represented by this color model.
 320      * The acceptable {@code transparency} values are
 321      * {@code OPAQUE}, {@code BITMASK} or {@code TRANSLUCENT}.
 322      * The {@code transferType} is the type of primitive array used
 323      * to represent pixel values.
 324      *
 325      * @param colorSpace       The {@code ColorSpace} associated
 326      *                         with this color model.
 327      * @param hasAlpha         If true, this color model supports alpha.
 328      * @param isAlphaPremultiplied If true, alpha is premultiplied.
 329      * @param transparency     Specifies what alpha values can be represented
 330      *                         by this color model.
 331      * @param transferType     Specifies the type of primitive array used to
 332      *                         represent pixel values.
 333      *
 334      * @throws IllegalArgumentException If transferType is not one of
 335      *         {@code DataBuffer.TYPE_BYTE},
 336      *         {@code DataBuffer.TYPE_USHORT},
 337      *         {@code DataBuffer.TYPE_INT},
 338      *         {@code DataBuffer.TYPE_SHORT},
 339      *         {@code DataBuffer.TYPE_FLOAT}, or
 340      *         {@code DataBuffer.TYPE_DOUBLE}.
 341      *
 342      * @see ColorSpace
 343      * @see java.awt.Transparency
 344      * @since 1.4
 345      */
 346     public ComponentColorModel (ColorSpace colorSpace,
 347                                 boolean hasAlpha,
 348                                 boolean isAlphaPremultiplied,
 349                                 int transparency,
 350                                 int transferType) {
 351         this(colorSpace, null, hasAlpha, isAlphaPremultiplied,
 352              transparency, transferType);
 353     }
 354 
 355     private static int bitsHelper(int transferType,
 356                                   ColorSpace colorSpace,
 357                                   boolean hasAlpha) {
 358         int numBits = DataBuffer.getDataTypeSize(transferType);
 359         int numComponents = colorSpace.getNumComponents();
 360         if (hasAlpha) {
 361             ++numComponents;
 362         }
 363         return numBits * numComponents;
 364     }
 365 
 366     private static int[] bitsArrayHelper(int[] origBits,
 367                                          int transferType,
 368                                          ColorSpace colorSpace,
 369                                          boolean hasAlpha) {
 370         switch(transferType) {
 371             case DataBuffer.TYPE_BYTE:
 372             case DataBuffer.TYPE_USHORT:
 373             case DataBuffer.TYPE_INT:
 374                 if (origBits != null) {
 375                     return origBits;
 376                 }
 377                 break;
 378             default:
 379                 break;
 380         }
 381         int numBits = DataBuffer.getDataTypeSize(transferType);
 382         int numComponents = colorSpace.getNumComponents();
 383         if (hasAlpha) {
 384             ++numComponents;
 385         }
 386         int[] bits = new int[numComponents];
 387         for (int i = 0; i < numComponents; i++) {
 388             bits[i] = numBits;
 389         }
 390         return bits;
 391     }
 392 
 393     private void setupLUTs() {
 394         // REMIND: there is potential to accelerate sRGB, LinearRGB,
 395         // LinearGray, ICCGray, and non-ICC Gray spaces with non-standard
 396         // scaling, if that becomes important
 397         //
 398         // NOTE: The is_xxx_stdScale and nonStdScale booleans are provisionally
 399         // set here when this method is called at construction time.  These
 400         // variables may be set again when initScale is called later.
 401         // When setupLUTs returns, nonStdScale is true if (the transferType
 402         // is not float or double) AND (some minimum ColorSpace component
 403         // value is not 0.0 OR some maximum ColorSpace component value
 404         // is not 1.0).  This is correct for the calls to
 405         // getNormalizedComponents(Object, float[], int) from initScale().
 406         // initScale() may change the value nonStdScale based on the
 407         // return value of getNormalizedComponents() - this will only
 408         // happen if getNormalizedComponents() has been overridden by a
 409         // subclass to make the mapping of min/max pixel sample values
 410         // something different from min/max color component values.
 411         if (is_sRGB) {
 412             is_sRGB_stdScale = true;
 413             nonStdScale = false;
 414         } else if (ColorModel.isLinearRGBspace(colorSpace)) {
 415             // Note that the built-in Linear RGB space has a normalized
 416             // range of 0.0 - 1.0 for each coordinate.  Usage of these
 417             // LUTs makes that assumption.
 418             is_LinearRGB_stdScale = true;
 419             nonStdScale = false;
 420             if (transferType == DataBuffer.TYPE_BYTE) {
 421                 tosRGB8LUT = ColorModel.getLinearRGB8TosRGB8LUT();
 422                 fromsRGB8LUT8 = ColorModel.getsRGB8ToLinearRGB8LUT();
 423             } else {
 424                 tosRGB8LUT = ColorModel.getLinearRGB16TosRGB8LUT();
 425                 fromsRGB8LUT16 = ColorModel.getsRGB8ToLinearRGB16LUT();
 426             }
 427         } else if ((colorSpaceType == ColorSpace.TYPE_GRAY) &&
 428                    (colorSpace instanceof ICC_ColorSpace) &&
 429                    (colorSpace.getMinValue(0) == 0.0f) &&
 430                    (colorSpace.getMaxValue(0) == 1.0f)) {
 431             // Note that a normalized range of 0.0 - 1.0 for the gray
 432             // component is required, because usage of these LUTs makes
 433             // that assumption.
 434             ICC_ColorSpace ics = (ICC_ColorSpace) colorSpace;
 435             is_ICCGray_stdScale = true;
 436             nonStdScale = false;
 437             fromsRGB8LUT16 = ColorModel.getsRGB8ToLinearRGB16LUT();
 438             if (ColorModel.isLinearGRAYspace(ics)) {
 439                 is_LinearGray_stdScale = true;
 440                 if (transferType == DataBuffer.TYPE_BYTE) {
 441                     tosRGB8LUT = ColorModel.getGray8TosRGB8LUT(ics);
 442                 } else {
 443                     tosRGB8LUT = ColorModel.getGray16TosRGB8LUT(ics);
 444                 }
 445             } else {
 446                 if (transferType == DataBuffer.TYPE_BYTE) {
 447                     tosRGB8LUT = ColorModel.getGray8TosRGB8LUT(ics);
 448                     fromLinearGray16ToOtherGray8LUT =
 449                         ColorModel.getLinearGray16ToOtherGray8LUT(ics);
 450                 } else {
 451                     tosRGB8LUT = ColorModel.getGray16TosRGB8LUT(ics);
 452                     fromLinearGray16ToOtherGray16LUT =
 453                         ColorModel.getLinearGray16ToOtherGray16LUT(ics);
 454                 }
 455             }
 456         } else if (needScaleInit) {
 457             // if transferType is byte, ushort, int, or short and we
 458             // don't already know the ColorSpace has minVlaue == 0.0f and
 459             // maxValue == 1.0f for all components, we need to check that
 460             // now and setup the min[] and diffMinMax[] arrays if necessary.
 461             nonStdScale = false;
 462             for (int i = 0; i < numColorComponents; i++) {
 463                 if ((colorSpace.getMinValue(i) != 0.0f) ||
 464                     (colorSpace.getMaxValue(i) != 1.0f)) {
 465                     nonStdScale = true;
 466                     break;
 467                 }
 468             }
 469             if (nonStdScale) {
 470                 min = new float[numColorComponents];
 471                 diffMinMax = new float[numColorComponents];
 472                 for (int i = 0; i < numColorComponents; i++) {
 473                     min[i] = colorSpace.getMinValue(i);
 474                     diffMinMax[i] = colorSpace.getMaxValue(i) - min[i];
 475                 }
 476             }
 477         }
 478     }
 479 
 480     private void initScale() {
 481         // This method is called the first time any method which uses
 482         // pixel sample value to color component value scaling information
 483         // is called if the transferType supports non-standard scaling
 484         // as defined above (byte, ushort, int, and short), unless the
 485         // method is getNormalizedComponents(Object, float[], int) (that
 486         // method must be overridden to use non-standard scaling).  This
 487         // method also sets up the noUnnorm boolean variable for these
 488         // transferTypes.  After this method is called, the nonStdScale
 489         // variable will be true if getNormalizedComponents() maps a
 490         // sample value of 0 to anything other than 0.0f OR maps a
 491         // sample value of 2^^n - 1 (2^^15 - 1 for short transferType)
 492         // to anything other than 1.0f.  Note that this can be independent
 493         // of the colorSpace min/max component values, if the
 494         // getNormalizedComponents() method has been overridden for some
 495         // reason, e.g. to provide greater dynamic range in the sample
 496         // values than in the color component values.  Unfortunately,
 497         // this method can't be called at construction time, since a
 498         // subclass may still have uninitialized state that would cause
 499         // getNormalizedComponents() to return an incorrect result.
 500         needScaleInit = false; // only needs to called once
 501         if (nonStdScale || signed) {
 502             // The unnormalized form is only supported for unsigned
 503             // transferTypes and when the ColorSpace min/max values
 504             // are 0.0/1.0.  When this method is called nonStdScale is
 505             // true if the latter condition does not hold.  In addition,
 506             // the unnormalized form requires that the full range of
 507             // the pixel sample values map to the full 0.0 - 1.0 range
 508             // of color component values.  That condition is checked
 509             // later in this method.
 510             noUnnorm = true;
 511         } else {
 512             noUnnorm = false;
 513         }
 514         float[] lowVal, highVal;
 515         switch (transferType) {
 516         case DataBuffer.TYPE_BYTE:
 517             {
 518                 byte[] bpixel = new byte[numComponents];
 519                 for (int i = 0; i < numColorComponents; i++) {
 520                     bpixel[i] = 0;
 521                 }
 522                 if (supportsAlpha) {
 523                     bpixel[numColorComponents] =
 524                         (byte) ((1 << nBits[numColorComponents]) - 1);
 525                 }
 526                 lowVal = getNormalizedComponents(bpixel, null, 0);
 527                 for (int i = 0; i < numColorComponents; i++) {
 528                     bpixel[i] = (byte) ((1 << nBits[i]) - 1);
 529                 }
 530                 highVal = getNormalizedComponents(bpixel, null, 0);
 531             }
 532             break;
 533         case DataBuffer.TYPE_USHORT:
 534             {
 535                 short[] uspixel = new short[numComponents];
 536                 for (int i = 0; i < numColorComponents; i++) {
 537                     uspixel[i] = 0;
 538                 }
 539                 if (supportsAlpha) {
 540                     uspixel[numColorComponents] =
 541                         (short) ((1 << nBits[numColorComponents]) - 1);
 542                 }
 543                 lowVal = getNormalizedComponents(uspixel, null, 0);
 544                 for (int i = 0; i < numColorComponents; i++) {
 545                     uspixel[i] = (short) ((1 << nBits[i]) - 1);
 546                 }
 547                 highVal = getNormalizedComponents(uspixel, null, 0);
 548             }
 549             break;
 550         case DataBuffer.TYPE_INT:
 551             {
 552                 int[] ipixel = new int[numComponents];
 553                 for (int i = 0; i < numColorComponents; i++) {
 554                     ipixel[i] = 0;
 555                 }
 556                 if (supportsAlpha) {
 557                     ipixel[numColorComponents] =
 558                         ((1 << nBits[numColorComponents]) - 1);
 559                 }
 560                 lowVal = getNormalizedComponents(ipixel, null, 0);
 561                 for (int i = 0; i < numColorComponents; i++) {
 562                     ipixel[i] = ((1 << nBits[i]) - 1);
 563                 }
 564                 highVal = getNormalizedComponents(ipixel, null, 0);
 565             }
 566             break;
 567         case DataBuffer.TYPE_SHORT:
 568             {
 569                 short[] spixel = new short[numComponents];
 570                 for (int i = 0; i < numColorComponents; i++) {
 571                     spixel[i] = 0;
 572                 }
 573                 if (supportsAlpha) {
 574                     spixel[numColorComponents] = 32767;
 575                 }
 576                 lowVal = getNormalizedComponents(spixel, null, 0);
 577                 for (int i = 0; i < numColorComponents; i++) {
 578                     spixel[i] = 32767;
 579                 }
 580                 highVal = getNormalizedComponents(spixel, null, 0);
 581             }
 582             break;
 583         default:
 584             lowVal = highVal = null;  // to keep the compiler from complaining
 585             break;
 586         }
 587         nonStdScale = false;
 588         for (int i = 0; i < numColorComponents; i++) {
 589             if ((lowVal[i] != 0.0f) || (highVal[i] != 1.0f)) {
 590                 nonStdScale = true;
 591                 break;
 592             }
 593         }
 594         if (nonStdScale) {
 595             noUnnorm = true;
 596             is_sRGB_stdScale = false;
 597             is_LinearRGB_stdScale = false;
 598             is_LinearGray_stdScale = false;
 599             is_ICCGray_stdScale = false;
 600             compOffset = new float[numColorComponents];
 601             compScale = new float[numColorComponents];
 602             for (int i = 0; i < numColorComponents; i++) {
 603                 compOffset[i] = lowVal[i];
 604                 compScale[i] = 1.0f / (highVal[i] - lowVal[i]);
 605             }
 606         }
 607     }
 608 
 609     private int getRGBComponent(int pixel, int idx) {
 610         if (numComponents > 1) {
 611             throw new
 612                 IllegalArgumentException("More than one component per pixel");
 613         }
 614         if (signed) {
 615             throw new
 616                 IllegalArgumentException("Component value is signed");
 617         }
 618         if (needScaleInit) {
 619             initScale();
 620         }
 621         // Since there is only 1 component, there is no alpha
 622 
 623         // Normalize the pixel in order to convert it
 624         Object opixel = null;
 625         switch (transferType) {
 626         case DataBuffer.TYPE_BYTE:
 627             {
 628                 byte[] bpixel = { (byte) pixel };
 629                 opixel = bpixel;
 630             }
 631             break;
 632         case DataBuffer.TYPE_USHORT:
 633             {
 634                 short[] spixel = { (short) pixel };
 635                 opixel = spixel;
 636             }
 637             break;
 638         case DataBuffer.TYPE_INT:
 639             {
 640                 int[] ipixel = { pixel };
 641                 opixel = ipixel;
 642             }
 643             break;
 644         }
 645         float[] norm = getNormalizedComponents(opixel, null, 0);
 646         float[] rgb = colorSpace.toRGB(norm);
 647 
 648         return (int) (rgb[idx] * 255.0f + 0.5f);
 649     }
 650 
 651     /**
 652      * Returns the red color component for the specified pixel, scaled
 653      * from 0 to 255 in the default RGB ColorSpace, sRGB.  A color conversion
 654      * is done if necessary.  The pixel value is specified as an int.
 655      * The returned value will be a non pre-multiplied value.
 656      * If the alpha is premultiplied, this method divides
 657      * it out before returning the value (if the alpha value is 0,
 658      * the red value will be 0).
 659      *
 660      * @param pixel The pixel from which you want to get the red color component.
 661      *
 662      * @return The red color component for the specified pixel, as an int.
 663      *
 664      * @throws IllegalArgumentException If there is more than
 665      * one component in this {@code ColorModel}.
 666      * @throws IllegalArgumentException If the component value for this
 667      * {@code ColorModel} is signed
 668      */
 669     public int getRed(int pixel) {
 670         return getRGBComponent(pixel, 0);
 671     }
 672 
 673     /**
 674      * Returns the green color component for the specified pixel, scaled
 675      * from 0 to 255 in the default RGB ColorSpace, sRGB.  A color conversion
 676      * is done if necessary.  The pixel value is specified as an int.
 677      * The returned value will be a non
 678      * pre-multiplied value. If the alpha is premultiplied, this method
 679      * divides it out before returning the value (if the alpha value is 0,
 680      * the green value will be 0).
 681      *
 682      * @param pixel The pixel from which you want to get the green color component.
 683      *
 684      * @return The green color component for the specified pixel, as an int.
 685      *
 686      * @throws IllegalArgumentException If there is more than
 687      * one component in this {@code ColorModel}.
 688      * @throws IllegalArgumentException If the component value for this
 689      * {@code ColorModel} is signed
 690      */
 691     public int getGreen(int pixel) {
 692         return getRGBComponent(pixel, 1);
 693     }
 694 
 695     /**
 696      * Returns the blue color component for the specified pixel, scaled
 697      * from 0 to 255 in the default RGB ColorSpace, sRGB.  A color conversion
 698      * is done if necessary.  The pixel value is specified as an int.
 699      * The returned value will be a non
 700      * pre-multiplied value. If the alpha is premultiplied, this method
 701      * divides it out before returning the value (if the alpha value is 0,
 702      * the blue value will be 0).
 703      *
 704      * @param pixel The pixel from which you want to get the blue color component.
 705      *
 706      * @return The blue color component for the specified pixel, as an int.
 707      *
 708      * @throws IllegalArgumentException If there is more than
 709      * one component in this {@code ColorModel}.
 710      * @throws IllegalArgumentException If the component value for this
 711      * {@code ColorModel} is signed
 712      */
 713     public int getBlue(int pixel) {
 714         return getRGBComponent(pixel, 2);
 715     }
 716 
 717     /**
 718      * Returns the alpha component for the specified pixel, scaled
 719      * from 0 to 255.   The pixel value is specified as an int.
 720      *
 721      * @param pixel The pixel from which you want to get the alpha component.
 722      *
 723      * @return The alpha component for the specified pixel, as an int.
 724      *
 725      * @throws IllegalArgumentException If there is more than
 726      * one component in this {@code ColorModel}.
 727      * @throws IllegalArgumentException If the component value for this
 728      * {@code ColorModel} is signed
 729      */
 730     public int getAlpha(int pixel) {
 731         if (supportsAlpha == false) {
 732             return 255;
 733         }
 734         if (numComponents > 1) {
 735             throw new
 736                 IllegalArgumentException("More than one component per pixel");
 737         }
 738         if (signed) {
 739             throw new
 740                 IllegalArgumentException("Component value is signed");
 741         }
 742 
 743         return (int) ((((float) pixel) / ((1<<nBits[0])-1)) * 255.0f + 0.5f);
 744     }
 745 
 746     /**
 747      * Returns the color/alpha components of the pixel in the default
 748      * RGB color model format.  A color conversion is done if necessary.
 749      * The returned value will be in a non pre-multiplied format. If
 750      * the alpha is premultiplied, this method divides it out of the
 751      * color components (if the alpha value is 0, the color values will be 0).
 752      *
 753      * @param pixel The pixel from which you want to get the color/alpha components.
 754      *
 755      * @return The color/alpha components for the specified pixel, as an int.
 756      *
 757      * @throws IllegalArgumentException If there is more than
 758      * one component in this {@code ColorModel}.
 759      * @throws IllegalArgumentException If the component value for this
 760      * {@code ColorModel} is signed
 761      */
 762     public int getRGB(int pixel) {
 763         if (numComponents > 1) {
 764             throw new
 765                 IllegalArgumentException("More than one component per pixel");
 766         }
 767         if (signed) {
 768             throw new
 769                 IllegalArgumentException("Component value is signed");
 770         }
 771 
 772         return (getAlpha(pixel) << 24)
 773             | (getRed(pixel) << 16)
 774             | (getGreen(pixel) << 8)
 775             | (getBlue(pixel) << 0);
 776     }
 777 
 778     private int extractComponent(Object inData, int idx, int precision) {
 779         // Extract component idx from inData.  The precision argument
 780         // should be either 8 or 16.  If it's 8, this method will return
 781         // an 8-bit value.  If it's 16, this method will return a 16-bit
 782         // value for transferTypes other than TYPE_BYTE.  For TYPE_BYTE,
 783         // an 8-bit value will be returned.
 784 
 785         // This method maps the input value corresponding to a
 786         // normalized ColorSpace component value of 0.0 to 0, and the
 787         // input value corresponding to a normalized ColorSpace
 788         // component value of 1.0 to 2^n - 1 (where n is 8 or 16), so
 789         // it is appropriate only for ColorSpaces with min/max component
 790         // values of 0.0/1.0.  This will be true for sRGB, the built-in
 791         // Linear RGB and Linear Gray spaces, and any other ICC grayscale
 792         // spaces for which we have precomputed LUTs.
 793 
 794         boolean needAlpha = (supportsAlpha && isAlphaPremultiplied);
 795         int alp = 0;
 796         int comp;
 797         int mask = (1 << nBits[idx]) - 1;
 798 
 799         switch (transferType) {
 800             // Note: we do no clamping of the pixel data here - we
 801             // assume that the data is scaled properly
 802             case DataBuffer.TYPE_SHORT: {
 803                 short sdata[] = (short[]) inData;
 804                 float scalefactor = (float) ((1 << precision) - 1);
 805                 if (needAlpha) {
 806                     short s = sdata[numColorComponents];
 807                     if (s != (short) 0) {
 808                         return (int) ((((float) sdata[idx]) /
 809                                        ((float) s)) * scalefactor + 0.5f);
 810                     } else {
 811                         return 0;
 812                     }
 813                 } else {
 814                     return (int) ((sdata[idx] / 32767.0f) * scalefactor + 0.5f);
 815                 }
 816             }
 817             case DataBuffer.TYPE_FLOAT: {
 818                 float fdata[] = (float[]) inData;
 819                 float scalefactor = (float) ((1 << precision) - 1);
 820                 if (needAlpha) {
 821                     float f = fdata[numColorComponents];
 822                     if (f != 0.0f) {
 823                         return (int) (((fdata[idx] / f) * scalefactor) + 0.5f);
 824                     } else {
 825                         return 0;
 826                     }
 827                 } else {
 828                     return (int) (fdata[idx] * scalefactor + 0.5f);
 829                 }
 830             }
 831             case DataBuffer.TYPE_DOUBLE: {
 832                 double ddata[] = (double[]) inData;
 833                 double scalefactor = (double) ((1 << precision) - 1);
 834                 if (needAlpha) {
 835                     double d = ddata[numColorComponents];
 836                     if (d != 0.0) {
 837                         return (int) (((ddata[idx] / d) * scalefactor) + 0.5);
 838                     } else {
 839                         return 0;
 840                     }
 841                 } else {
 842                     return (int) (ddata[idx] * scalefactor + 0.5);
 843                 }
 844             }
 845             case DataBuffer.TYPE_BYTE:
 846                byte bdata[] = (byte[])inData;
 847                comp = bdata[idx] & mask;
 848                precision = 8;
 849                if (needAlpha) {
 850                    alp = bdata[numColorComponents] & mask;
 851                }
 852             break;
 853             case DataBuffer.TYPE_USHORT:
 854                short usdata[] = (short[])inData;
 855                comp = usdata[idx] & mask;
 856                if (needAlpha) {
 857                    alp = usdata[numColorComponents] & mask;
 858                }
 859             break;
 860             case DataBuffer.TYPE_INT:
 861                int idata[] = (int[])inData;
 862                comp = idata[idx];
 863                if (needAlpha) {
 864                    alp = idata[numColorComponents];
 865                }
 866             break;
 867             default:
 868                throw new
 869                    UnsupportedOperationException("This method has not "+
 870                    "been implemented for transferType " + transferType);
 871         }
 872         if (needAlpha) {
 873             if (alp != 0) {
 874                 float scalefactor = (float) ((1 << precision) - 1);
 875                 float fcomp = ((float) comp) / ((float)mask);
 876                 float invalp = ((float) ((1<<nBits[numColorComponents]) - 1)) /
 877                                ((float) alp);
 878                 return (int) (fcomp * invalp * scalefactor + 0.5f);
 879             } else {
 880                 return 0;
 881             }
 882         } else {
 883             if (nBits[idx] != precision) {
 884                 float scalefactor = (float) ((1 << precision) - 1);
 885                 float fcomp = ((float) comp) / ((float)mask);
 886                 return (int) (fcomp * scalefactor + 0.5f);
 887             }
 888             return comp;
 889         }
 890     }
 891 
 892     private int getRGBComponent(Object inData, int idx) {
 893         if (needScaleInit) {
 894             initScale();
 895         }
 896         if (is_sRGB_stdScale) {
 897             return extractComponent(inData, idx, 8);
 898         } else if (is_LinearRGB_stdScale) {
 899             int lutidx = extractComponent(inData, idx, 16);
 900             return tosRGB8LUT[lutidx] & 0xff;
 901         } else if (is_ICCGray_stdScale) {
 902             int lutidx = extractComponent(inData, 0, 16);
 903             return tosRGB8LUT[lutidx] & 0xff;
 904         }
 905 
 906         // Not CS_sRGB, CS_LINEAR_RGB, or any TYPE_GRAY ICC_ColorSpace
 907         float[] norm = getNormalizedComponents(inData, null, 0);
 908         // Note that getNormalizedComponents returns non-premultiplied values
 909         float[] rgb = colorSpace.toRGB(norm);
 910         return (int) (rgb[idx] * 255.0f + 0.5f);
 911     }
 912 
 913     /**
 914      * Returns the red color component for the specified pixel, scaled
 915      * from 0 to 255 in the default RGB ColorSpace, sRGB.  A color conversion
 916      * is done if necessary.  The {@code pixel} value is specified by an array
 917      * of data elements of type {@code transferType} passed in as an object
 918      * reference. The returned value will be a non pre-multiplied value. If the
 919      * alpha is premultiplied, this method divides it out before returning
 920      * the value (if the alpha value is 0, the red value will be 0). Since
 921      * {@code ComponentColorModel} can be subclassed, subclasses
 922      * inherit the implementation of this method and if they don't override
 923      * it then they throw an exception if they use an unsupported
 924      * {@code transferType}.
 925      *
 926      * @param inData The pixel from which you want to get the red color component,
 927      * specified by an array of data elements of type {@code transferType}.
 928      *
 929      * @return The red color component for the specified pixel, as an int.
 930      *
 931      * @throws ClassCastException If {@code inData} is not a primitive array
 932      * of type {@code transferType}.
 933      * @throws ArrayIndexOutOfBoundsException if {@code inData} is not
 934      * large enough to hold a pixel value for this
 935      * {@code ColorModel}.
 936      * @throws UnsupportedOperationException If the transfer type of
 937      * this {@code ComponentColorModel}
 938      * is not one of the supported transfer types:
 939      * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
 940      * {@code DataBuffer.TYPE_INT}, {@code DataBuffer.TYPE_SHORT},
 941      * {@code DataBuffer.TYPE_FLOAT}, or {@code DataBuffer.TYPE_DOUBLE}.
 942      */
 943     public int getRed(Object inData) {
 944         return getRGBComponent(inData, 0);
 945     }
 946 
 947 
 948     /**
 949      * Returns the green color component for the specified pixel, scaled
 950      * from 0 to 255 in the default RGB {@code ColorSpace}, sRGB.
 951      * A color conversion is done if necessary.  The {@code pixel} value
 952      * is specified by an array of data elements of type {@code transferType}
 953      * passed in as an object reference. The returned value is a non pre-multiplied
 954      * value. If the alpha is premultiplied, this method divides it out before
 955      * returning the value (if the alpha value is 0, the green value will be 0).
 956      * Since {@code ComponentColorModel} can be subclassed,
 957      * subclasses inherit the implementation of this method and if they
 958      * don't override it then they throw an exception if they use an
 959      * unsupported {@code transferType}.
 960      *
 961      * @param inData The pixel from which you want to get the green color component,
 962      * specified by an array of data elements of type {@code transferType}.
 963      *
 964      * @return The green color component for the specified pixel, as an int.
 965      *
 966      * @throws ClassCastException If {@code inData} is not a primitive array
 967      * of type {@code transferType}.
 968      * @throws ArrayIndexOutOfBoundsException if {@code inData} is not
 969      * large enough to hold a pixel value for this
 970      * {@code ColorModel}.
 971      * @throws UnsupportedOperationException If the transfer type of
 972      * this {@code ComponentColorModel}
 973      * is not one of the supported transfer types:
 974      * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
 975      * {@code DataBuffer.TYPE_INT}, {@code DataBuffer.TYPE_SHORT},
 976      * {@code DataBuffer.TYPE_FLOAT}, or {@code DataBuffer.TYPE_DOUBLE}.
 977      */
 978     public int getGreen(Object inData) {
 979         return getRGBComponent(inData, 1);
 980     }
 981 
 982 
 983     /**
 984      * Returns the blue color component for the specified pixel, scaled
 985      * from 0 to 255 in the default RGB {@code ColorSpace}, sRGB.
 986      * A color conversion is done if necessary.  The {@code pixel} value is
 987      * specified by an array of data elements of type {@code transferType}
 988      * passed in as an object reference. The returned value is a non pre-multiplied
 989      * value. If the alpha is premultiplied, this method divides it out before
 990      * returning the value (if the alpha value is 0, the blue value will be 0).
 991      * Since {@code ComponentColorModel} can be subclassed,
 992      * subclasses inherit the implementation of this method and if they
 993      * don't override it then they throw an exception if they use an
 994      * unsupported {@code transferType}.
 995      *
 996      * @param inData The pixel from which you want to get the blue color component,
 997      * specified by an array of data elements of type {@code transferType}.
 998      *
 999      * @return The blue color component for the specified pixel, as an int.
1000      *
1001      * @throws ClassCastException If {@code inData} is not a primitive array
1002      * of type {@code transferType}.
1003      * @throws ArrayIndexOutOfBoundsException if {@code inData} is not
1004      * large enough to hold a pixel value for this
1005      * {@code ColorModel}.
1006      * @throws UnsupportedOperationException If the transfer type of
1007      * this {@code ComponentColorModel}
1008      * is not one of the supported transfer types:
1009      * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
1010      * {@code DataBuffer.TYPE_INT}, {@code DataBuffer.TYPE_SHORT},
1011      * {@code DataBuffer.TYPE_FLOAT}, or {@code DataBuffer.TYPE_DOUBLE}.
1012      */
1013     public int getBlue(Object inData) {
1014         return getRGBComponent(inData, 2);
1015     }
1016 
1017     /**
1018      * Returns the alpha component for the specified pixel, scaled from
1019      * 0 to 255.  The pixel value is specified by an array of data
1020      * elements of type {@code transferType} passed in as an
1021      * object reference.  Since {@code ComponentColorModel} can be
1022      * subclassed, subclasses inherit the
1023      * implementation of this method and if they don't override it then
1024      * they throw an exception if they use an unsupported
1025      * {@code transferType}.
1026      *
1027      * @param inData The pixel from which you want to get the alpha component,
1028      * specified by an array of data elements of type {@code transferType}.
1029      *
1030      * @return The alpha component for the specified pixel, as an int.
1031      *
1032      * @throws ClassCastException If {@code inData} is not a primitive array
1033      * of type {@code transferType}.
1034      * @throws ArrayIndexOutOfBoundsException if {@code inData} is not
1035      * large enough to hold a pixel value for this
1036      * {@code ColorModel}.
1037      * @throws UnsupportedOperationException If the transfer type of
1038      * this {@code ComponentColorModel}
1039      * is not one of the supported transfer types:
1040      * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
1041      * {@code DataBuffer.TYPE_INT}, {@code DataBuffer.TYPE_SHORT},
1042      * {@code DataBuffer.TYPE_FLOAT}, or {@code DataBuffer.TYPE_DOUBLE}.
1043      */
1044     public int getAlpha(Object inData) {
1045         if (supportsAlpha == false) {
1046             return 255;
1047         }
1048 
1049         int alpha = 0;
1050         int aIdx = numColorComponents;
1051         int mask = (1 << nBits[aIdx]) - 1;
1052 
1053         switch (transferType) {
1054             case DataBuffer.TYPE_SHORT:
1055                 short sdata[] = (short[])inData;
1056                 alpha = (int) ((sdata[aIdx] / 32767.0f) * 255.0f + 0.5f);
1057                 return alpha;
1058             case DataBuffer.TYPE_FLOAT:
1059                 float fdata[] = (float[])inData;
1060                 alpha = (int) (fdata[aIdx] * 255.0f + 0.5f);
1061                 return alpha;
1062             case DataBuffer.TYPE_DOUBLE:
1063                 double ddata[] = (double[])inData;
1064                 alpha = (int) (ddata[aIdx] * 255.0 + 0.5);
1065                 return alpha;
1066             case DataBuffer.TYPE_BYTE:
1067                byte bdata[] = (byte[])inData;
1068                alpha = bdata[aIdx] & mask;
1069             break;
1070             case DataBuffer.TYPE_USHORT:
1071                short usdata[] = (short[])inData;
1072                alpha = usdata[aIdx] & mask;
1073             break;
1074             case DataBuffer.TYPE_INT:
1075                int idata[] = (int[])inData;
1076                alpha = idata[aIdx];
1077             break;
1078             default:
1079                throw new
1080                    UnsupportedOperationException("This method has not "+
1081                    "been implemented for transferType " + transferType);
1082         }
1083 
1084         if (nBits[aIdx] == 8) {
1085             return alpha;
1086         } else {
1087             return (int)
1088                 ((((float) alpha) / ((float) ((1 << nBits[aIdx]) - 1))) *
1089                  255.0f + 0.5f);
1090         }
1091     }
1092 
1093     /**
1094      * Returns the color/alpha components for the specified pixel in the
1095      * default RGB color model format.  A color conversion is done if
1096      * necessary.  The pixel value is specified by an
1097      * array of data elements of type {@code transferType} passed
1098      * in as an object reference.
1099      * The returned value is in a non pre-multiplied format. If
1100      * the alpha is premultiplied, this method divides it out of the
1101      * color components (if the alpha value is 0, the color values will be 0).
1102      * Since {@code ComponentColorModel} can be subclassed,
1103      * subclasses inherit the implementation of this method and if they
1104      * don't override it then they throw an exception if they use an
1105      * unsupported {@code transferType}.
1106      *
1107      * @param inData The pixel from which you want to get the color/alpha components,
1108      * specified by an array of data elements of type {@code transferType}.
1109      *
1110      * @return The color/alpha components for the specified pixel, as an int.
1111      *
1112      * @throws ClassCastException If {@code inData} is not a primitive array
1113      * of type {@code transferType}.
1114      * @throws ArrayIndexOutOfBoundsException if {@code inData} is not
1115      * large enough to hold a pixel value for this
1116      * {@code ColorModel}.
1117      * @throws UnsupportedOperationException If the transfer type of
1118      * this {@code ComponentColorModel}
1119      * is not one of the supported transfer types:
1120      * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
1121      * {@code DataBuffer.TYPE_INT}, {@code DataBuffer.TYPE_SHORT},
1122      * {@code DataBuffer.TYPE_FLOAT}, or {@code DataBuffer.TYPE_DOUBLE}.
1123      * @see ColorModel#getRGBdefault
1124      */
1125     public int getRGB(Object inData) {
1126         if (needScaleInit) {
1127             initScale();
1128         }
1129         if (is_sRGB_stdScale || is_LinearRGB_stdScale) {
1130             return (getAlpha(inData) << 24)
1131                 | (getRed(inData) << 16)
1132                 | (getGreen(inData) << 8)
1133                 | (getBlue(inData));
1134         } else if (colorSpaceType == ColorSpace.TYPE_GRAY) {
1135             int gray = getRed(inData); // Red sRGB component should equal
1136                                        // green and blue components
1137             return (getAlpha(inData) << 24)
1138                 | (gray << 16)
1139                 | (gray <<  8)
1140                 | gray;
1141         }
1142         float[] norm = getNormalizedComponents(inData, null, 0);
1143         // Note that getNormalizedComponents returns non-premult values
1144         float[] rgb = colorSpace.toRGB(norm);
1145         return (getAlpha(inData) << 24)
1146             | (((int) (rgb[0] * 255.0f + 0.5f)) << 16)
1147             | (((int) (rgb[1] * 255.0f + 0.5f)) << 8)
1148             | (((int) (rgb[2] * 255.0f + 0.5f)) << 0);
1149     }
1150 
1151     /**
1152      * Returns a data element array representation of a pixel in this
1153      * {@code ColorModel}, given an integer pixel representation
1154      * in the default RGB color model.
1155      * This array can then be passed to the {@code setDataElements}
1156      * method of a {@code WritableRaster} object.  If the
1157      * {@code pixel}
1158      * parameter is null, a new array is allocated.  Since
1159      * {@code ComponentColorModel} can be subclassed, subclasses
1160      * inherit the implementation of this method and if they don't
1161      * override it then
1162      * they throw an exception if they use an unsupported
1163      * {@code transferType}.
1164      *
1165      * @param rgb the integer representation of the pixel in the RGB
1166      *            color model
1167      * @param pixel the specified pixel
1168      * @return The data element array representation of a pixel
1169      * in this {@code ColorModel}.
1170      * @throws ClassCastException If {@code pixel} is not null and
1171      * is not a primitive array of type {@code transferType}.
1172      * @throws ArrayIndexOutOfBoundsException If {@code pixel} is
1173      * not large enough to hold a pixel value for this
1174      * {@code ColorModel}.
1175      * @throws UnsupportedOperationException If the transfer type of
1176      * this {@code ComponentColorModel}
1177      * is not one of the supported transfer types:
1178      * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
1179      * {@code DataBuffer.TYPE_INT}, {@code DataBuffer.TYPE_SHORT},
1180      * {@code DataBuffer.TYPE_FLOAT}, or {@code DataBuffer.TYPE_DOUBLE}.
1181      *
1182      * @see WritableRaster#setDataElements
1183      * @see SampleModel#setDataElements
1184      */
1185     public Object getDataElements(int rgb, Object pixel) {
1186         // REMIND: Use rendering hints?
1187 
1188         int red, grn, blu, alp;
1189         red = (rgb>>16) & 0xff;
1190         grn = (rgb>>8) & 0xff;
1191         blu = rgb & 0xff;
1192 
1193         if (needScaleInit) {
1194             initScale();
1195         }
1196         if (signed) {
1197             // Handle SHORT, FLOAT, & DOUBLE here
1198 
1199             switch(transferType) {
1200             case DataBuffer.TYPE_SHORT:
1201                 {
1202                     short sdata[];
1203                     if (pixel == null) {
1204                         sdata = new short[numComponents];
1205                     } else {
1206                         sdata = (short[])pixel;
1207                     }
1208                     float factor;
1209                     if (is_sRGB_stdScale || is_LinearRGB_stdScale) {
1210                         factor = 32767.0f / 255.0f;
1211                         if (is_LinearRGB_stdScale) {
1212                             red = fromsRGB8LUT16[red] & 0xffff;
1213                             grn = fromsRGB8LUT16[grn] & 0xffff;
1214                             blu = fromsRGB8LUT16[blu] & 0xffff;
1215                             factor = 32767.0f / 65535.0f;
1216                         }
1217                         if (supportsAlpha) {
1218                             alp = (rgb>>24) & 0xff;
1219                             sdata[3] =
1220                                 (short) (alp * (32767.0f / 255.0f) + 0.5f);
1221                             if (isAlphaPremultiplied) {
1222                                 factor = alp * factor * (1.0f / 255.0f);
1223                             }
1224                         }
1225                         sdata[0] = (short) (red * factor + 0.5f);
1226                         sdata[1] = (short) (grn * factor + 0.5f);
1227                         sdata[2] = (short) (blu * factor + 0.5f);
1228                     } else if (is_LinearGray_stdScale) {
1229                         red = fromsRGB8LUT16[red] & 0xffff;
1230                         grn = fromsRGB8LUT16[grn] & 0xffff;
1231                         blu = fromsRGB8LUT16[blu] & 0xffff;
1232                         float gray = ((0.2125f * red) +
1233                                       (0.7154f * grn) +
1234                                       (0.0721f * blu)) / 65535.0f;
1235                         factor = 32767.0f;
1236                         if (supportsAlpha) {
1237                             alp = (rgb>>24) & 0xff;
1238                             sdata[1] =
1239                                 (short) (alp * (32767.0f / 255.0f) + 0.5f);
1240                             if (isAlphaPremultiplied) {
1241                                 factor = alp * factor * (1.0f / 255.0f);
1242                             }
1243                         }
1244                         sdata[0] = (short) (gray * factor + 0.5f);
1245                     } else if (is_ICCGray_stdScale) {
1246                         red = fromsRGB8LUT16[red] & 0xffff;
1247                         grn = fromsRGB8LUT16[grn] & 0xffff;
1248                         blu = fromsRGB8LUT16[blu] & 0xffff;
1249                         int gray = (int) ((0.2125f * red) +
1250                                           (0.7154f * grn) +
1251                                           (0.0721f * blu) + 0.5f);
1252                         gray = fromLinearGray16ToOtherGray16LUT[gray] & 0xffff;
1253                         factor = 32767.0f / 65535.0f;
1254                         if (supportsAlpha) {
1255                             alp = (rgb>>24) & 0xff;
1256                             sdata[1] =
1257                                 (short) (alp * (32767.0f / 255.0f) + 0.5f);
1258                             if (isAlphaPremultiplied) {
1259                                 factor = alp * factor * (1.0f / 255.0f);
1260                             }
1261                         }
1262                         sdata[0] = (short) (gray * factor + 0.5f);
1263                     } else {
1264                         factor = 1.0f / 255.0f;
1265                         float norm[] = new float[3];
1266                         norm[0] = red * factor;
1267                         norm[1] = grn * factor;
1268                         norm[2] = blu * factor;
1269                         norm = colorSpace.fromRGB(norm);
1270                         if (nonStdScale) {
1271                             for (int i = 0; i < numColorComponents; i++) {
1272                                 norm[i] = (norm[i] - compOffset[i]) *
1273                                           compScale[i];
1274                                 // REMIND: need to analyze whether this
1275                                 // clamping is necessary
1276                                 if (norm[i] < 0.0f) {
1277                                     norm[i] = 0.0f;
1278                                 }
1279                                 if (norm[i] > 1.0f) {
1280                                     norm[i] = 1.0f;
1281                                 }
1282                             }
1283                         }
1284                         factor = 32767.0f;
1285                         if (supportsAlpha) {
1286                             alp = (rgb>>24) & 0xff;
1287                             sdata[numColorComponents] =
1288                                 (short) (alp * (32767.0f / 255.0f) + 0.5f);
1289                             if (isAlphaPremultiplied) {
1290                                 factor *= alp * (1.0f / 255.0f);
1291                             }
1292                         }
1293                         for (int i = 0; i < numColorComponents; i++) {
1294                             sdata[i] = (short) (norm[i] * factor + 0.5f);
1295                         }
1296                     }
1297                     return sdata;
1298                 }
1299             case DataBuffer.TYPE_FLOAT:
1300                 {
1301                     float fdata[];
1302                     if (pixel == null) {
1303                         fdata = new float[numComponents];
1304                     } else {
1305                         fdata = (float[])pixel;
1306                     }
1307                     float factor;
1308                     if (is_sRGB_stdScale || is_LinearRGB_stdScale) {
1309                         if (is_LinearRGB_stdScale) {
1310                             red = fromsRGB8LUT16[red] & 0xffff;
1311                             grn = fromsRGB8LUT16[grn] & 0xffff;
1312                             blu = fromsRGB8LUT16[blu] & 0xffff;
1313                             factor = 1.0f / 65535.0f;
1314                         } else {
1315                             factor = 1.0f / 255.0f;
1316                         }
1317                         if (supportsAlpha) {
1318                             alp = (rgb>>24) & 0xff;
1319                             fdata[3] = alp * (1.0f / 255.0f);
1320                             if (isAlphaPremultiplied) {
1321                                 factor *= fdata[3];
1322                             }
1323                         }
1324                         fdata[0] = red * factor;
1325                         fdata[1] = grn * factor;
1326                         fdata[2] = blu * factor;
1327                     } else if (is_LinearGray_stdScale) {
1328                         red = fromsRGB8LUT16[red] & 0xffff;
1329                         grn = fromsRGB8LUT16[grn] & 0xffff;
1330                         blu = fromsRGB8LUT16[blu] & 0xffff;
1331                         fdata[0] = ((0.2125f * red) +
1332                                     (0.7154f * grn) +
1333                                     (0.0721f * blu)) / 65535.0f;
1334                         if (supportsAlpha) {
1335                             alp = (rgb>>24) & 0xff;
1336                             fdata[1] = alp * (1.0f / 255.0f);
1337                             if (isAlphaPremultiplied) {
1338                                 fdata[0] *= fdata[1];
1339                             }
1340                         }
1341                     } else if (is_ICCGray_stdScale) {
1342                         red = fromsRGB8LUT16[red] & 0xffff;
1343                         grn = fromsRGB8LUT16[grn] & 0xffff;
1344                         blu = fromsRGB8LUT16[blu] & 0xffff;
1345                         int gray = (int) ((0.2125f * red) +
1346                                           (0.7154f * grn) +
1347                                           (0.0721f * blu) + 0.5f);
1348                         fdata[0] = (fromLinearGray16ToOtherGray16LUT[gray] &
1349                                     0xffff) / 65535.0f;
1350                         if (supportsAlpha) {
1351                             alp = (rgb>>24) & 0xff;
1352                             fdata[1] = alp * (1.0f / 255.0f);
1353                             if (isAlphaPremultiplied) {
1354                                 fdata[0] *= fdata[1];
1355                             }
1356                         }
1357                     } else {
1358                         float norm[] = new float[3];
1359                         factor = 1.0f / 255.0f;
1360                         norm[0] = red * factor;
1361                         norm[1] = grn * factor;
1362                         norm[2] = blu * factor;
1363                         norm = colorSpace.fromRGB(norm);
1364                         if (supportsAlpha) {
1365                             alp = (rgb>>24) & 0xff;
1366                             fdata[numColorComponents] = alp * factor;
1367                             if (isAlphaPremultiplied) {
1368                                 factor *= alp;
1369                                 for (int i = 0; i < numColorComponents; i++) {
1370                                     norm[i] *= factor;
1371                                 }
1372                             }
1373                         }
1374                         for (int i = 0; i < numColorComponents; i++) {
1375                             fdata[i] = norm[i];
1376                         }
1377                     }
1378                     return fdata;
1379                 }
1380             case DataBuffer.TYPE_DOUBLE:
1381                 {
1382                     double ddata[];
1383                     if (pixel == null) {
1384                         ddata = new double[numComponents];
1385                     } else {
1386                         ddata = (double[])pixel;
1387                     }
1388                     if (is_sRGB_stdScale || is_LinearRGB_stdScale) {
1389                         double factor;
1390                         if (is_LinearRGB_stdScale) {
1391                             red = fromsRGB8LUT16[red] & 0xffff;
1392                             grn = fromsRGB8LUT16[grn] & 0xffff;
1393                             blu = fromsRGB8LUT16[blu] & 0xffff;
1394                             factor = 1.0 / 65535.0;
1395                         } else {
1396                             factor = 1.0 / 255.0;
1397                         }
1398                         if (supportsAlpha) {
1399                             alp = (rgb>>24) & 0xff;
1400                             ddata[3] = alp * (1.0 / 255.0);
1401                             if (isAlphaPremultiplied) {
1402                                 factor *= ddata[3];
1403                             }
1404                         }
1405                         ddata[0] = red * factor;
1406                         ddata[1] = grn * factor;
1407                         ddata[2] = blu * factor;
1408                     } else if (is_LinearGray_stdScale) {
1409                         red = fromsRGB8LUT16[red] & 0xffff;
1410                         grn = fromsRGB8LUT16[grn] & 0xffff;
1411                         blu = fromsRGB8LUT16[blu] & 0xffff;
1412                         ddata[0] = ((0.2125 * red) +
1413                                     (0.7154 * grn) +
1414                                     (0.0721 * blu)) / 65535.0;
1415                         if (supportsAlpha) {
1416                             alp = (rgb>>24) & 0xff;
1417                             ddata[1] = alp * (1.0 / 255.0);
1418                             if (isAlphaPremultiplied) {
1419                                 ddata[0] *= ddata[1];
1420                             }
1421                         }
1422                     } else if (is_ICCGray_stdScale) {
1423                         red = fromsRGB8LUT16[red] & 0xffff;
1424                         grn = fromsRGB8LUT16[grn] & 0xffff;
1425                         blu = fromsRGB8LUT16[blu] & 0xffff;
1426                         int gray = (int) ((0.2125f * red) +
1427                                           (0.7154f * grn) +
1428                                           (0.0721f * blu) + 0.5f);
1429                         ddata[0] = (fromLinearGray16ToOtherGray16LUT[gray] &
1430                                     0xffff) / 65535.0;
1431                         if (supportsAlpha) {
1432                             alp = (rgb>>24) & 0xff;
1433                             ddata[1] = alp * (1.0 / 255.0);
1434                             if (isAlphaPremultiplied) {
1435                                 ddata[0] *= ddata[1];
1436                             }
1437                         }
1438                     } else {
1439                         float factor = 1.0f / 255.0f;
1440                         float norm[] = new float[3];
1441                         norm[0] = red * factor;
1442                         norm[1] = grn * factor;
1443                         norm[2] = blu * factor;
1444                         norm = colorSpace.fromRGB(norm);
1445                         if (supportsAlpha) {
1446                             alp = (rgb>>24) & 0xff;
1447                             ddata[numColorComponents] = alp * (1.0 / 255.0);
1448                             if (isAlphaPremultiplied) {
1449                                 factor *= alp;
1450                                 for (int i = 0; i < numColorComponents; i++) {
1451                                     norm[i] *= factor;
1452                                 }
1453                             }
1454                         }
1455                         for (int i = 0; i < numColorComponents; i++) {
1456                             ddata[i] = norm[i];
1457                         }
1458                     }
1459                     return ddata;
1460                 }
1461             }
1462         }
1463 
1464         // Handle BYTE, USHORT, & INT here
1465         //REMIND: maybe more efficient not to use int array for
1466         //DataBuffer.TYPE_USHORT and DataBuffer.TYPE_INT
1467         int intpixel[];
1468         if (transferType == DataBuffer.TYPE_INT &&
1469             pixel != null) {
1470            intpixel = (int[])pixel;
1471         } else {
1472             intpixel = new int[numComponents];
1473         }
1474 
1475         if (is_sRGB_stdScale || is_LinearRGB_stdScale) {
1476             int precision;
1477             float factor;
1478             if (is_LinearRGB_stdScale) {
1479                 if (transferType == DataBuffer.TYPE_BYTE) {
1480                     red = fromsRGB8LUT8[red] & 0xff;
1481                     grn = fromsRGB8LUT8[grn] & 0xff;
1482                     blu = fromsRGB8LUT8[blu] & 0xff;
1483                     precision = 8;
1484                     factor = 1.0f / 255.0f;
1485                 } else {
1486                     red = fromsRGB8LUT16[red] & 0xffff;
1487                     grn = fromsRGB8LUT16[grn] & 0xffff;
1488                     blu = fromsRGB8LUT16[blu] & 0xffff;
1489                     precision = 16;
1490                     factor = 1.0f / 65535.0f;
1491                 }
1492             } else {
1493                 precision = 8;
1494                 factor = 1.0f / 255.0f;
1495             }
1496             if (supportsAlpha) {
1497                 alp = (rgb>>24)&0xff;
1498                 if (nBits[3] == 8) {
1499                     intpixel[3] = alp;
1500                 }
1501                 else {
1502                     intpixel[3] = (int)
1503                         (alp * (1.0f / 255.0f) * ((1<<nBits[3]) - 1) + 0.5f);
1504                 }
1505                 if (isAlphaPremultiplied) {
1506                     factor *= (alp * (1.0f / 255.0f));
1507                     precision = -1;  // force component calculations below
1508                 }
1509             }
1510             if (nBits[0] == precision) {
1511                 intpixel[0] = red;
1512             }
1513             else {
1514                 intpixel[0] = (int) (red * factor * ((1<<nBits[0]) - 1) + 0.5f);
1515             }
1516             if (nBits[1] == precision) {
1517                 intpixel[1] = grn;
1518             }
1519             else {
1520                 intpixel[1] = (int) (grn * factor * ((1<<nBits[1]) - 1) + 0.5f);
1521             }
1522             if (nBits[2] == precision) {
1523                 intpixel[2] = blu;
1524             }
1525             else {
1526                 intpixel[2] = (int) (blu * factor * ((1<<nBits[2]) - 1) + 0.5f);
1527             }
1528         } else if (is_LinearGray_stdScale) {
1529             red = fromsRGB8LUT16[red] & 0xffff;
1530             grn = fromsRGB8LUT16[grn] & 0xffff;
1531             blu = fromsRGB8LUT16[blu] & 0xffff;
1532             float gray = ((0.2125f * red) +
1533                           (0.7154f * grn) +
1534                           (0.0721f * blu)) / 65535.0f;
1535             if (supportsAlpha) {
1536                 alp = (rgb>>24) & 0xff;
1537                 if (nBits[1] == 8) {
1538                     intpixel[1] = alp;
1539                 } else {
1540                     intpixel[1] = (int) (alp * (1.0f / 255.0f) *
1541                                          ((1 << nBits[1]) - 1) + 0.5f);
1542                 }
1543                 if (isAlphaPremultiplied) {
1544                     gray *= (alp * (1.0f / 255.0f));
1545                 }
1546             }
1547             intpixel[0] = (int) (gray * ((1 << nBits[0]) - 1) + 0.5f);
1548         } else if (is_ICCGray_stdScale) {
1549             red = fromsRGB8LUT16[red] & 0xffff;
1550             grn = fromsRGB8LUT16[grn] & 0xffff;
1551             blu = fromsRGB8LUT16[blu] & 0xffff;
1552             int gray16 = (int) ((0.2125f * red) +
1553                                 (0.7154f * grn) +
1554                                 (0.0721f * blu) + 0.5f);
1555             float gray = (fromLinearGray16ToOtherGray16LUT[gray16] &
1556                           0xffff) / 65535.0f;
1557             if (supportsAlpha) {
1558                 alp = (rgb>>24) & 0xff;
1559                 if (nBits[1] == 8) {
1560                     intpixel[1] = alp;
1561                 } else {
1562                     intpixel[1] = (int) (alp * (1.0f / 255.0f) *
1563                                          ((1 << nBits[1]) - 1) + 0.5f);
1564                 }
1565                 if (isAlphaPremultiplied) {
1566                     gray *= (alp * (1.0f / 255.0f));
1567                 }
1568             }
1569             intpixel[0] = (int) (gray * ((1 << nBits[0]) - 1) + 0.5f);
1570         } else {
1571             // Need to convert the color
1572             float[] norm = new float[3];
1573             float factor = 1.0f / 255.0f;
1574             norm[0] = red * factor;
1575             norm[1] = grn * factor;
1576             norm[2] = blu * factor;
1577             norm = colorSpace.fromRGB(norm);
1578             if (nonStdScale) {
1579                 for (int i = 0; i < numColorComponents; i++) {
1580                     norm[i] = (norm[i] - compOffset[i]) *
1581                               compScale[i];
1582                     // REMIND: need to analyze whether this
1583                     // clamping is necessary
1584                     if (norm[i] < 0.0f) {
1585                         norm[i] = 0.0f;
1586                     }
1587                     if (norm[i] > 1.0f) {
1588                         norm[i] = 1.0f;
1589                     }
1590                 }
1591             }
1592             if (supportsAlpha) {
1593                 alp = (rgb>>24) & 0xff;
1594                 if (nBits[numColorComponents] == 8) {
1595                     intpixel[numColorComponents] = alp;
1596                 }
1597                 else {
1598                     intpixel[numColorComponents] =
1599                         (int) (alp * factor *
1600                                ((1<<nBits[numColorComponents]) - 1) + 0.5f);
1601                 }
1602                 if (isAlphaPremultiplied) {
1603                     factor *= alp;
1604                     for (int i = 0; i < numColorComponents; i++) {
1605                         norm[i] *= factor;
1606                     }
1607                 }
1608             }
1609             for (int i = 0; i < numColorComponents; i++) {
1610                 intpixel[i] = (int) (norm[i] * ((1<<nBits[i]) - 1) + 0.5f);
1611             }
1612         }
1613 
1614         switch (transferType) {
1615             case DataBuffer.TYPE_BYTE: {
1616                byte bdata[];
1617                if (pixel == null) {
1618                    bdata = new byte[numComponents];
1619                } else {
1620                    bdata = (byte[])pixel;
1621                }
1622                for (int i = 0; i < numComponents; i++) {
1623                    bdata[i] = (byte)(0xff&intpixel[i]);
1624                }
1625                return bdata;
1626             }
1627             case DataBuffer.TYPE_USHORT:{
1628                short sdata[];
1629                if (pixel == null) {
1630                    sdata = new short[numComponents];
1631                } else {
1632                    sdata = (short[])pixel;
1633                }
1634                for (int i = 0; i < numComponents; i++) {
1635                    sdata[i] = (short)(intpixel[i]&0xffff);
1636                }
1637                return sdata;
1638             }
1639             case DataBuffer.TYPE_INT:
1640                 if (maxBits > 23) {
1641                     // fix 4412670 - for components of 24 or more bits
1642                     // some calculations done above with float precision
1643                     // may lose enough precision that the integer result
1644                     // overflows nBits, so we need to clamp.
1645                     for (int i = 0; i < numComponents; i++) {
1646                         if (intpixel[i] > ((1<<nBits[i]) - 1)) {
1647                             intpixel[i] = (1<<nBits[i]) - 1;
1648                         }
1649                     }
1650                 }
1651                 return intpixel;
1652         }
1653         throw new IllegalArgumentException("This method has not been "+
1654                  "implemented for transferType " + transferType);
1655     }
1656 
1657    /** Returns an array of unnormalized color/alpha components given a pixel
1658      * in this {@code ColorModel}.
1659      * An IllegalArgumentException is thrown if the component value for this
1660      * {@code ColorModel} is not conveniently representable in the
1661      * unnormalized form.  Color/alpha components are stored
1662      * in the {@code components} array starting at {@code offset}
1663      * (even if the array is allocated by this method).
1664      *
1665      * @param pixel The pixel value specified as an integer.
1666      * @param components An integer array in which to store the unnormalized
1667      * color/alpha components. If the {@code components} array is null,
1668      * a new array is allocated.
1669      * @param offset An offset into the {@code components} array.
1670      *
1671      * @return The components array.
1672      *
1673      * @throws IllegalArgumentException If there is more than one
1674      * component in this {@code ColorModel}.
1675      * @throws IllegalArgumentException If this
1676      * {@code ColorModel} does not support the unnormalized form
1677      * @throws ArrayIndexOutOfBoundsException If the {@code components}
1678      * array is not null and is not large enough to hold all the color and
1679      * alpha components (starting at offset).
1680      */
1681     public int[] getComponents(int pixel, int[] components, int offset) {
1682         if (numComponents > 1) {
1683             throw new
1684                 IllegalArgumentException("More than one component per pixel");
1685         }
1686         if (needScaleInit) {
1687             initScale();
1688         }
1689         if (noUnnorm) {
1690             throw new
1691                 IllegalArgumentException(
1692                     "This ColorModel does not support the unnormalized form");
1693         }
1694         if (components == null) {
1695             components = new int[offset+1];
1696         }
1697 
1698         components[offset+0] = (pixel & ((1<<nBits[0]) - 1));
1699         return components;
1700     }
1701 
1702     /**
1703      * Returns an array of unnormalized color/alpha components given a pixel
1704      * in this {@code ColorModel}.  The pixel value is specified by an
1705      * array of data elements of type {@code transferType} passed in as
1706      * an object reference.
1707      * An IllegalArgumentException is thrown if the component values for this
1708      * {@code ColorModel} are not conveniently representable in the
1709      * unnormalized form.
1710      * Color/alpha components are stored in the {@code components} array
1711      * starting at  {@code offset} (even if the array is allocated by
1712      * this method).  Since {@code ComponentColorModel} can be
1713      * subclassed, subclasses inherit the
1714      * implementation of this method and if they don't override it then
1715      * this method might throw an exception if they use an unsupported
1716      * {@code transferType}.
1717      *
1718      * @param pixel A pixel value specified by an array of data elements of
1719      * type {@code transferType}.
1720      * @param components An integer array in which to store the unnormalized
1721      * color/alpha components. If the {@code components} array is null,
1722      * a new array is allocated.
1723      * @param offset An offset into the {@code components} array.
1724      *
1725      * @return The {@code components} array.
1726      *
1727      * @throws IllegalArgumentException If this
1728      * {@code ComponentColorModel} does not support the unnormalized form
1729      * @throws UnsupportedOperationException in some cases iff the
1730      * transfer type of this {@code ComponentColorModel}
1731      * is not one of the following transfer types:
1732      * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
1733      * or {@code DataBuffer.TYPE_INT}.
1734      * @throws ClassCastException If {@code pixel} is not a primitive
1735      * array of type {@code transferType}.
1736      * @throws IllegalArgumentException If the {@code components} array is
1737      * not null and is not large enough to hold all the color and alpha
1738      * components (starting at offset), or if {@code pixel} is not large
1739      * enough to hold a pixel value for this ColorModel.
1740      */
1741     public int[] getComponents(Object pixel, int[] components, int offset) {
1742         int intpixel[];
1743         if (needScaleInit) {
1744             initScale();
1745         }
1746         if (noUnnorm) {
1747             throw new
1748                 IllegalArgumentException(
1749                     "This ColorModel does not support the unnormalized form");
1750         }
1751         if (pixel instanceof int[]) {
1752             intpixel = (int[])pixel;
1753         } else {
1754             intpixel = DataBuffer.toIntArray(pixel);
1755             if (intpixel == null) {
1756                throw new UnsupportedOperationException("This method has not been "+
1757                    "implemented for transferType " + transferType);
1758             }
1759         }
1760         if (intpixel.length < numComponents) {
1761             throw new IllegalArgumentException
1762                 ("Length of pixel array < number of components in model");
1763         }
1764         if (components == null) {
1765             components = new int[offset+numComponents];
1766         }
1767         else if ((components.length-offset) < numComponents) {
1768             throw new IllegalArgumentException
1769                 ("Length of components array < number of components in model");
1770         }
1771         System.arraycopy(intpixel, 0, components, offset, numComponents);
1772 
1773         return components;
1774     }
1775 
1776     /**
1777      * Returns an array of all of the color/alpha components in unnormalized
1778      * form, given a normalized component array.  Unnormalized components
1779      * are unsigned integral values between 0 and 2<sup>n</sup> - 1, where
1780      * n is the number of bits for a particular component.  Normalized
1781      * components are float values between a per component minimum and
1782      * maximum specified by the {@code ColorSpace} object for this
1783      * {@code ColorModel}.  An {@code IllegalArgumentException}
1784      * will be thrown if color component values for this
1785      * {@code ColorModel} are not conveniently representable in the
1786      * unnormalized form.  If the
1787      * {@code components} array is {@code null}, a new array
1788      * will be allocated.  The {@code components} array will
1789      * be returned.  Color/alpha components are stored in the
1790      * {@code components} array starting at {@code offset} (even
1791      * if the array is allocated by this method). An
1792      * {@code ArrayIndexOutOfBoundsException} is thrown if the
1793      * {@code components} array is not {@code null} and is not
1794      * large enough to hold all the color and alpha
1795      * components (starting at {@code offset}).  An
1796      * {@code IllegalArgumentException} is thrown if the
1797      * {@code normComponents} array is not large enough to hold
1798      * all the color and alpha components starting at
1799      * {@code normOffset}.
1800      * @param normComponents an array containing normalized components
1801      * @param normOffset the offset into the {@code normComponents}
1802      * array at which to start retrieving normalized components
1803      * @param components an array that receives the components from
1804      * {@code normComponents}
1805      * @param offset the index into {@code components} at which to
1806      * begin storing normalized components from
1807      * {@code normComponents}
1808      * @return an array containing unnormalized color and alpha
1809      * components.
1810      * @throws IllegalArgumentException If this
1811      * {@code ComponentColorModel} does not support the unnormalized form
1812      * @throws IllegalArgumentException if the length of
1813      *          {@code normComponents} minus {@code normOffset}
1814      *          is less than {@code numComponents}
1815      */
1816     public int[] getUnnormalizedComponents(float[] normComponents,
1817                                            int normOffset,
1818                                            int[] components, int offset) {
1819         if (needScaleInit) {
1820             initScale();
1821         }
1822         if (noUnnorm) {
1823             throw new
1824                 IllegalArgumentException(
1825                     "This ColorModel does not support the unnormalized form");
1826         }
1827         return super.getUnnormalizedComponents(normComponents, normOffset,
1828                                                components, offset);
1829     }
1830 
1831     /**
1832      * Returns an array of all of the color/alpha components in normalized
1833      * form, given an unnormalized component array.  Unnormalized components
1834      * are unsigned integral values between 0 and 2<sup>n</sup> - 1, where
1835      * n is the number of bits for a particular component.  Normalized
1836      * components are float values between a per component minimum and
1837      * maximum specified by the {@code ColorSpace} object for this
1838      * {@code ColorModel}.  An {@code IllegalArgumentException}
1839      * will be thrown if color component values for this
1840      * {@code ColorModel} are not conveniently representable in the
1841      * unnormalized form.  If the
1842      * {@code normComponents} array is {@code null}, a new array
1843      * will be allocated.  The {@code normComponents} array
1844      * will be returned.  Color/alpha components are stored in the
1845      * {@code normComponents} array starting at
1846      * {@code normOffset} (even if the array is allocated by this
1847      * method).  An {@code ArrayIndexOutOfBoundsException} is thrown
1848      * if the {@code normComponents} array is not {@code null}
1849      * and is not large enough to hold all the color and alpha components
1850      * (starting at {@code normOffset}).  An
1851      * {@code IllegalArgumentException} is thrown if the
1852      * {@code components} array is not large enough to hold all the
1853      * color and alpha components starting at {@code offset}.
1854      * @param components an array containing unnormalized components
1855      * @param offset the offset into the {@code components} array at
1856      * which to start retrieving unnormalized components
1857      * @param normComponents an array that receives the normalized components
1858      * @param normOffset the index into {@code normComponents} at
1859      * which to begin storing normalized components
1860      * @return an array containing normalized color and alpha
1861      * components.
1862      * @throws IllegalArgumentException If this
1863      * {@code ComponentColorModel} does not support the unnormalized form
1864      */
1865     public float[] getNormalizedComponents(int[] components, int offset,
1866                                            float[] normComponents,
1867                                            int normOffset) {
1868         if (needScaleInit) {
1869             initScale();
1870         }
1871         if (noUnnorm) {
1872             throw new
1873                 IllegalArgumentException(
1874                     "This ColorModel does not support the unnormalized form");
1875         }
1876         return super.getNormalizedComponents(components, offset,
1877                                              normComponents, normOffset);
1878     }
1879 
1880     /**
1881      * Returns a pixel value represented as an int in this {@code ColorModel},
1882      * given an array of unnormalized color/alpha components.
1883      *
1884      * @param components An array of unnormalized color/alpha components.
1885      * @param offset An offset into the {@code components} array.
1886      *
1887      * @return A pixel value represented as an int.
1888      *
1889      * @throws IllegalArgumentException If there is more than one component
1890      * in this {@code ColorModel}.
1891      * @throws IllegalArgumentException If this
1892      * {@code ComponentColorModel} does not support the unnormalized form
1893      */
1894     public int getDataElement(int[] components, int offset) {
1895         if (needScaleInit) {
1896             initScale();
1897         }
1898         if (numComponents == 1) {
1899             if (noUnnorm) {
1900                 throw new
1901                     IllegalArgumentException(
1902                     "This ColorModel does not support the unnormalized form");
1903             }
1904             return components[offset+0];
1905         }
1906         throw new IllegalArgumentException("This model returns "+
1907                                            numComponents+
1908                                            " elements in the pixel array.");
1909     }
1910 
1911     /**
1912      * Returns a data element array representation of a pixel in this
1913      * {@code ColorModel}, given an array of unnormalized color/alpha
1914      * components. This array can then be passed to the {@code setDataElements}
1915      * method of a {@code WritableRaster} object.
1916      *
1917      * @param components An array of unnormalized color/alpha components.
1918      * @param offset The integer offset into the {@code components} array.
1919      * @param obj The object in which to store the data element array
1920      * representation of the pixel. If {@code obj} variable is null,
1921      * a new array is allocated.  If {@code obj} is not null, it must
1922      * be a primitive array of type {@code transferType}. An
1923      * {@code ArrayIndexOutOfBoundsException} is thrown if
1924      * {@code obj} is not large enough to hold a pixel value
1925      * for this {@code ColorModel}.  Since
1926      * {@code ComponentColorModel} can be subclassed, subclasses
1927      * inherit the implementation of this method and if they don't
1928      * override it then they throw an exception if they use an
1929      * unsupported {@code transferType}.
1930      *
1931      * @return The data element array representation of a pixel
1932      * in this {@code ColorModel}.
1933      *
1934      * @throws IllegalArgumentException If the components array
1935      * is not large enough to hold all the color and alpha components
1936      * (starting at offset).
1937      * @throws ClassCastException If {@code obj} is not null and is not a
1938      * primitive  array of type {@code transferType}.
1939      * @throws ArrayIndexOutOfBoundsException If {@code obj} is not large
1940      * enough to hold a pixel value for this {@code ColorModel}.
1941      * @throws IllegalArgumentException If this
1942      * {@code ComponentColorModel} does not support the unnormalized form
1943      * @throws UnsupportedOperationException If the transfer type of
1944      * this {@code ComponentColorModel}
1945      * is not one of the following transfer types:
1946      * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
1947      * or {@code DataBuffer.TYPE_INT}.
1948      *
1949      * @see WritableRaster#setDataElements
1950      * @see SampleModel#setDataElements
1951      */
1952     public Object getDataElements(int[] components, int offset, Object obj) {
1953         if (needScaleInit) {
1954             initScale();
1955         }
1956         if (noUnnorm) {
1957             throw new
1958                 IllegalArgumentException(
1959                     "This ColorModel does not support the unnormalized form");
1960         }
1961         if ((components.length-offset) < numComponents) {
1962             throw new IllegalArgumentException("Component array too small"+
1963                                                " (should be "+numComponents);
1964         }
1965         switch(transferType) {
1966         case DataBuffer.TYPE_INT:
1967             {
1968                 int[] pixel;
1969                 if (obj == null) {
1970                     pixel = new int[numComponents];
1971                 }
1972                 else {
1973                     pixel = (int[]) obj;
1974                 }
1975                 System.arraycopy(components, offset, pixel, 0,
1976                                  numComponents);
1977                 return pixel;
1978             }
1979 
1980         case DataBuffer.TYPE_BYTE:
1981             {
1982                 byte[] pixel;
1983                 if (obj == null) {
1984                     pixel = new byte[numComponents];
1985                 }
1986                 else {
1987                     pixel = (byte[]) obj;
1988                 }
1989                 for (int i=0; i < numComponents; i++) {
1990                     pixel[i] = (byte) (components[offset+i]&0xff);
1991                 }
1992                 return pixel;
1993             }
1994 
1995         case DataBuffer.TYPE_USHORT:
1996             {
1997                 short[] pixel;
1998                 if (obj == null) {
1999                     pixel = new short[numComponents];
2000                 }
2001                 else {
2002                     pixel = (short[]) obj;
2003                 }
2004                 for (int i=0; i < numComponents; i++) {
2005                     pixel[i] = (short) (components[offset+i]&0xffff);
2006                 }
2007                 return pixel;
2008             }
2009 
2010         default:
2011             throw new UnsupportedOperationException("This method has not been "+
2012                                         "implemented for transferType " +
2013                                         transferType);
2014         }
2015     }
2016 
2017     /**
2018      * Returns a pixel value represented as an {@code int} in this
2019      * {@code ColorModel}, given an array of normalized color/alpha
2020      * components.  This method will throw an
2021      * {@code IllegalArgumentException} if pixel values for this
2022      * {@code ColorModel} are not conveniently representable as a
2023      * single {@code int}.  An
2024      * {@code ArrayIndexOutOfBoundsException} is thrown if  the
2025      * {@code normComponents} array is not large enough to hold all the
2026      * color and alpha components (starting at {@code normOffset}).
2027      * @param normComponents an array of normalized color and alpha
2028      * components
2029      * @param normOffset the index into {@code normComponents} at which to
2030      * begin retrieving the color and alpha components
2031      * @return an {@code int} pixel value in this
2032      * {@code ColorModel} corresponding to the specified components.
2033      * @throws IllegalArgumentException if
2034      *  pixel values for this {@code ColorModel} are not
2035      *  conveniently representable as a single {@code int}
2036      * @throws ArrayIndexOutOfBoundsException if
2037      *  the {@code normComponents} array is not large enough to
2038      *  hold all of the color and alpha components starting at
2039      *  {@code normOffset}
2040      * @since 1.4
2041      */
2042     public int getDataElement(float[] normComponents, int normOffset) {
2043         if (numComponents > 1) {
2044             throw new
2045                 IllegalArgumentException("More than one component per pixel");
2046         }
2047         if (signed) {
2048             throw new
2049                 IllegalArgumentException("Component value is signed");
2050         }
2051         if (needScaleInit) {
2052             initScale();
2053         }
2054         Object pixel = getDataElements(normComponents, normOffset, null);
2055         switch (transferType) {
2056         case DataBuffer.TYPE_BYTE:
2057             {
2058                 byte bpixel[] = (byte[]) pixel;
2059                 return bpixel[0] & 0xff;
2060             }
2061         case DataBuffer.TYPE_USHORT:
2062             {
2063                 short[] uspixel = (short[]) pixel;
2064                 return uspixel[0] & 0xffff;
2065             }
2066         case DataBuffer.TYPE_INT:
2067             {
2068                 int[] ipixel = (int[]) pixel;
2069                 return ipixel[0];
2070             }
2071         default:
2072             throw new UnsupportedOperationException("This method has not been "
2073                 + "implemented for transferType " + transferType);
2074         }
2075     }
2076 
2077     /**
2078      * Returns a data element array representation of a pixel in this
2079      * {@code ColorModel}, given an array of normalized color/alpha
2080      * components.  This array can then be passed to the
2081      * {@code setDataElements} method of a {@code WritableRaster}
2082      * object.  An {@code ArrayIndexOutOfBoundsException} is thrown
2083      * if the {@code normComponents} array is not large enough to hold
2084      * all the color and alpha components (starting at
2085      * {@code normOffset}).  If the {@code obj} variable is
2086      * {@code null}, a new array will be allocated.  If
2087      * {@code obj} is not {@code null}, it must be a primitive
2088      * array of type transferType; otherwise, a
2089      * {@code ClassCastException} is thrown.  An
2090      * {@code ArrayIndexOutOfBoundsException} is thrown if
2091      * {@code obj} is not large enough to hold a pixel value for this
2092      * {@code ColorModel}.
2093      * @param normComponents an array of normalized color and alpha
2094      * components
2095      * @param normOffset the index into {@code normComponents} at which to
2096      * begin retrieving color and alpha components
2097      * @param obj a primitive data array to hold the returned pixel
2098      * @return an {@code Object} which is a primitive data array
2099      * representation of a pixel
2100      * @throws ClassCastException if {@code obj}
2101      *  is not a primitive array of type {@code transferType}
2102      * @throws ArrayIndexOutOfBoundsException if
2103      *  {@code obj} is not large enough to hold a pixel value
2104      *  for this {@code ColorModel} or the {@code normComponents}
2105      *  array is not large enough to hold all of the color and alpha
2106      *  components starting at {@code normOffset}
2107      * @see WritableRaster#setDataElements
2108      * @see SampleModel#setDataElements
2109      * @since 1.4
2110      */
2111     public Object getDataElements(float[] normComponents, int normOffset,
2112                                   Object obj) {
2113         boolean needAlpha = supportsAlpha && isAlphaPremultiplied;
2114         float[] stdNormComponents;
2115         if (needScaleInit) {
2116             initScale();
2117         }
2118         if (nonStdScale) {
2119             stdNormComponents = new float[numComponents];
2120             for (int c = 0, nc = normOffset; c < numColorComponents;
2121                  c++, nc++) {
2122                 stdNormComponents[c] = (normComponents[nc] - compOffset[c]) *
2123                                        compScale[c];
2124                 // REMIND: need to analyze whether this
2125                 // clamping is necessary
2126                 if (stdNormComponents[c] < 0.0f) {
2127                     stdNormComponents[c] = 0.0f;
2128                 }
2129                 if (stdNormComponents[c] > 1.0f) {
2130                     stdNormComponents[c] = 1.0f;
2131                 }
2132             }
2133             if (supportsAlpha) {
2134                 stdNormComponents[numColorComponents] =
2135                     normComponents[numColorComponents + normOffset];
2136             }
2137             normOffset = 0;
2138         } else {
2139             stdNormComponents = normComponents;
2140         }
2141         switch (transferType) {
2142         case DataBuffer.TYPE_BYTE:
2143             byte[] bpixel;
2144             if (obj == null) {
2145                 bpixel = new byte[numComponents];
2146             } else {
2147                 bpixel = (byte[]) obj;
2148             }
2149             if (needAlpha) {
2150                 float alpha =
2151                     stdNormComponents[numColorComponents + normOffset];
2152                 for (int c = 0, nc = normOffset; c < numColorComponents;
2153                      c++, nc++) {
2154                     bpixel[c] = (byte) ((stdNormComponents[nc] * alpha) *
2155                                         ((float) ((1 << nBits[c]) - 1)) + 0.5f);
2156                 }
2157                 bpixel[numColorComponents] =
2158                     (byte) (alpha *
2159                             ((float) ((1 << nBits[numColorComponents]) - 1)) +
2160                             0.5f);
2161             } else {
2162                 for (int c = 0, nc = normOffset; c < numComponents;
2163                      c++, nc++) {
2164                     bpixel[c] = (byte) (stdNormComponents[nc] *
2165                                         ((float) ((1 << nBits[c]) - 1)) + 0.5f);
2166                 }
2167             }
2168             return bpixel;
2169         case DataBuffer.TYPE_USHORT:
2170             short[] uspixel;
2171             if (obj == null) {
2172                 uspixel = new short[numComponents];
2173             } else {
2174                 uspixel = (short[]) obj;
2175             }
2176             if (needAlpha) {
2177                 float alpha =
2178                     stdNormComponents[numColorComponents + normOffset];
2179                 for (int c = 0, nc = normOffset; c < numColorComponents;
2180                      c++, nc++) {
2181                     uspixel[c] = (short) ((stdNormComponents[nc] * alpha) *
2182                                           ((float) ((1 << nBits[c]) - 1)) +
2183                                           0.5f);
2184                 }
2185                 uspixel[numColorComponents] =
2186                     (short) (alpha *
2187                              ((float) ((1 << nBits[numColorComponents]) - 1)) +
2188                              0.5f);
2189             } else {
2190                 for (int c = 0, nc = normOffset; c < numComponents;
2191                      c++, nc++) {
2192                     uspixel[c] = (short) (stdNormComponents[nc] *
2193                                           ((float) ((1 << nBits[c]) - 1)) +
2194                                           0.5f);
2195                 }
2196             }
2197             return uspixel;
2198         case DataBuffer.TYPE_INT:
2199             int[] ipixel;
2200             if (obj == null) {
2201                 ipixel = new int[numComponents];
2202             } else {
2203                 ipixel = (int[]) obj;
2204             }
2205             if (needAlpha) {
2206                 float alpha =
2207                     stdNormComponents[numColorComponents + normOffset];
2208                 for (int c = 0, nc = normOffset; c < numColorComponents;
2209                      c++, nc++) {
2210                     ipixel[c] = (int) ((stdNormComponents[nc] * alpha) *
2211                                        ((float) ((1 << nBits[c]) - 1)) + 0.5f);
2212                 }
2213                 ipixel[numColorComponents] =
2214                     (int) (alpha *
2215                            ((float) ((1 << nBits[numColorComponents]) - 1)) +
2216                            0.5f);
2217             } else {
2218                 for (int c = 0, nc = normOffset; c < numComponents;
2219                      c++, nc++) {
2220                     ipixel[c] = (int) (stdNormComponents[nc] *
2221                                        ((float) ((1 << nBits[c]) - 1)) + 0.5f);
2222                 }
2223             }
2224             return ipixel;
2225         case DataBuffer.TYPE_SHORT:
2226             short[] spixel;
2227             if (obj == null) {
2228                 spixel = new short[numComponents];
2229             } else {
2230                 spixel = (short[]) obj;
2231             }
2232             if (needAlpha) {
2233                 float alpha =
2234                     stdNormComponents[numColorComponents + normOffset];
2235                 for (int c = 0, nc = normOffset; c < numColorComponents;
2236                      c++, nc++) {
2237                     spixel[c] = (short)
2238                         (stdNormComponents[nc] * alpha * 32767.0f + 0.5f);
2239                 }
2240                 spixel[numColorComponents] = (short) (alpha * 32767.0f + 0.5f);
2241             } else {
2242                 for (int c = 0, nc = normOffset; c < numComponents;
2243                      c++, nc++) {
2244                     spixel[c] = (short)
2245                         (stdNormComponents[nc] * 32767.0f + 0.5f);
2246                 }
2247             }
2248             return spixel;
2249         case DataBuffer.TYPE_FLOAT:
2250             float[] fpixel;
2251             if (obj == null) {
2252                 fpixel = new float[numComponents];
2253             } else {
2254                 fpixel = (float[]) obj;
2255             }
2256             if (needAlpha) {
2257                 float alpha = normComponents[numColorComponents + normOffset];
2258                 for (int c = 0, nc = normOffset; c < numColorComponents;
2259                      c++, nc++) {
2260                     fpixel[c] = normComponents[nc] * alpha;
2261                 }
2262                 fpixel[numColorComponents] = alpha;
2263             } else {
2264                 for (int c = 0, nc = normOffset; c < numComponents;
2265                      c++, nc++) {
2266                     fpixel[c] = normComponents[nc];
2267                 }
2268             }
2269             return fpixel;
2270         case DataBuffer.TYPE_DOUBLE:
2271             double[] dpixel;
2272             if (obj == null) {
2273                 dpixel = new double[numComponents];
2274             } else {
2275                 dpixel = (double[]) obj;
2276             }
2277             if (needAlpha) {
2278                 double alpha =
2279                     (double) (normComponents[numColorComponents + normOffset]);
2280                 for (int c = 0, nc = normOffset; c < numColorComponents;
2281                      c++, nc++) {
2282                     dpixel[c] = normComponents[nc] * alpha;
2283                 }
2284                 dpixel[numColorComponents] = alpha;
2285             } else {
2286                 for (int c = 0, nc = normOffset; c < numComponents;
2287                      c++, nc++) {
2288                     dpixel[c] = (double) normComponents[nc];
2289                 }
2290             }
2291             return dpixel;
2292         default:
2293             throw new UnsupportedOperationException("This method has not been "+
2294                                         "implemented for transferType " +
2295                                         transferType);
2296         }
2297     }
2298 
2299     /**
2300      * Returns an array of all of the color/alpha components in normalized
2301      * form, given a pixel in this {@code ColorModel}.  The pixel
2302      * value is specified by an array of data elements of type transferType
2303      * passed in as an object reference.  If pixel is not a primitive array
2304      * of type transferType, a {@code ClassCastException} is thrown.
2305      * An {@code ArrayIndexOutOfBoundsException} is thrown if
2306      * {@code pixel} is not large enough to hold a pixel value for this
2307      * {@code ColorModel}.
2308      * Normalized components are float values between a per component minimum
2309      * and maximum specified by the {@code ColorSpace} object for this
2310      * {@code ColorModel}.  If the
2311      * {@code normComponents} array is {@code null}, a new array
2312      * will be allocated.  The {@code normComponents} array
2313      * will be returned.  Color/alpha components are stored in the
2314      * {@code normComponents} array starting at
2315      * {@code normOffset} (even if the array is allocated by this
2316      * method).  An {@code ArrayIndexOutOfBoundsException} is thrown
2317      * if the {@code normComponents} array is not {@code null}
2318      * and is not large enough to hold all the color and alpha components
2319      * (starting at {@code normOffset}).
2320      * <p>
2321      * This method must be overridden by a subclass if that subclass
2322      * is designed to translate pixel sample values to color component values
2323      * in a non-default way.  The default translations implemented by this
2324      * class is described in the class comments.  Any subclass implementing
2325      * a non-default translation must follow the constraints on allowable
2326      * translations defined there.
2327      * @param pixel the specified pixel
2328      * @param normComponents an array to receive the normalized components
2329      * @param normOffset the offset into the {@code normComponents}
2330      * array at which to start storing normalized components
2331      * @return an array containing normalized color and alpha
2332      * components.
2333      * @throws ClassCastException if {@code pixel} is not a primitive
2334      *          array of type transferType
2335      * @throws ArrayIndexOutOfBoundsException if
2336      *          {@code normComponents} is not large enough to hold all
2337      *          color and alpha components starting at {@code normOffset}
2338      * @throws ArrayIndexOutOfBoundsException if
2339      *          {@code pixel} is not large enough to hold a pixel
2340      *          value for this {@code ColorModel}.
2341      * @since 1.4
2342      */
2343     public float[] getNormalizedComponents(Object pixel,
2344                                            float[] normComponents,
2345                                            int normOffset) {
2346         if (normComponents == null) {
2347             normComponents = new float[numComponents+normOffset];
2348         }
2349         switch (transferType) {
2350         case DataBuffer.TYPE_BYTE:
2351             byte[] bpixel = (byte[]) pixel;
2352             for (int c = 0, nc = normOffset; c < numComponents; c++, nc++) {
2353                 normComponents[nc] = ((float) (bpixel[c] & 0xff)) /
2354                                      ((float) ((1 << nBits[c]) - 1));
2355             }
2356             break;
2357         case DataBuffer.TYPE_USHORT:
2358             short[] uspixel = (short[]) pixel;
2359             for (int c = 0, nc = normOffset; c < numComponents; c++, nc++) {
2360                 normComponents[nc] = ((float) (uspixel[c] & 0xffff)) /
2361                                      ((float) ((1 << nBits[c]) - 1));
2362             }
2363             break;
2364         case DataBuffer.TYPE_INT:
2365             int[] ipixel = (int[]) pixel;
2366             for (int c = 0, nc = normOffset; c < numComponents; c++, nc++) {
2367                 normComponents[nc] = ((float) ipixel[c]) /
2368                                      ((float) ((1 << nBits[c]) - 1));
2369             }
2370             break;
2371         case DataBuffer.TYPE_SHORT:
2372             short[] spixel = (short[]) pixel;
2373             for (int c = 0, nc = normOffset; c < numComponents; c++, nc++) {
2374                 normComponents[nc] = ((float) spixel[c]) / 32767.0f;
2375             }
2376             break;
2377         case DataBuffer.TYPE_FLOAT:
2378             float[] fpixel = (float[]) pixel;
2379             for (int c = 0, nc = normOffset; c < numComponents; c++, nc++) {
2380                 normComponents[nc] = fpixel[c];
2381             }
2382             break;
2383         case DataBuffer.TYPE_DOUBLE:
2384             double[] dpixel = (double[]) pixel;
2385             for (int c = 0, nc = normOffset; c < numComponents; c++, nc++) {
2386                 normComponents[nc] = (float) dpixel[c];
2387             }
2388             break;
2389         default:
2390             throw new UnsupportedOperationException("This method has not been "+
2391                                         "implemented for transferType " +
2392                                         transferType);
2393         }
2394 
2395         if (supportsAlpha && isAlphaPremultiplied) {
2396             float alpha = normComponents[numColorComponents + normOffset];
2397             if (alpha != 0.0f) {
2398                 float invAlpha = 1.0f / alpha;
2399                 for (int c = normOffset; c < numColorComponents + normOffset;
2400                      c++) {
2401                     normComponents[c] *= invAlpha;
2402                 }
2403             }
2404         }
2405         if (min != null) {
2406             // Normally (i.e. when this class is not subclassed to override
2407             // this method), the test (min != null) will be equivalent to
2408             // the test (nonStdScale).  However, there is an unlikely, but
2409             // possible case, in which this method is overridden, nonStdScale
2410             // is set true by initScale(), the subclass method for some
2411             // reason calls this superclass method, but the min and
2412             // diffMinMax arrays were never initialized by setupLUTs().  In
2413             // that case, the right thing to do is follow the intended
2414             // semantics of this method, and rescale the color components
2415             // only if the ColorSpace min/max were detected to be other
2416             // than 0.0/1.0 by setupLUTs().  Note that this implies the
2417             // transferType is byte, ushort, int, or short - i.e. components
2418             // derived from float and double pixel data are never rescaled.
2419             for (int c = 0; c < numColorComponents; c++) {
2420                 normComponents[c + normOffset] = min[c] +
2421                     diffMinMax[c] * normComponents[c + normOffset];
2422             }
2423         }
2424         return normComponents;
2425     }
2426 
2427     /**
2428      * Forces the raster data to match the state specified in the
2429      * {@code isAlphaPremultiplied} variable, assuming the data
2430      * is currently correctly described by this {@code ColorModel}.
2431      * It may multiply or divide the color raster data by alpha, or
2432      * do nothing if the data is in the correct state.  If the data needs
2433      * to be coerced, this method also returns an instance of
2434      * this {@code ColorModel} with
2435      * the {@code isAlphaPremultiplied} flag set appropriately.
2436      * Since {@code ColorModel} can be subclassed, subclasses inherit
2437      * the implementation of this method and if they don't override it
2438      * then they throw an exception if they use an unsupported
2439      * {@code transferType}.
2440      *
2441      * @throws NullPointerException if {@code raster} is
2442      * {@code null} and data coercion is required.
2443      * @throws UnsupportedOperationException if the transfer type of
2444      * this {@code ComponentColorModel}
2445      * is not one of the supported transfer types:
2446      * {@code DataBuffer.TYPE_BYTE}, {@code DataBuffer.TYPE_USHORT},
2447      * {@code DataBuffer.TYPE_INT}, {@code DataBuffer.TYPE_SHORT},
2448      * {@code DataBuffer.TYPE_FLOAT}, or {@code DataBuffer.TYPE_DOUBLE}.
2449      */
2450     public ColorModel coerceData (WritableRaster raster,
2451                                   boolean isAlphaPremultiplied) {
2452         if ((supportsAlpha == false) ||
2453             (this.isAlphaPremultiplied == isAlphaPremultiplied))
2454         {
2455             // Nothing to do
2456             return this;
2457         }
2458 
2459         int w = raster.getWidth();
2460         int h = raster.getHeight();
2461         int aIdx = raster.getNumBands() - 1;
2462         float normAlpha;
2463         int rminX = raster.getMinX();
2464         int rY = raster.getMinY();
2465         int rX;
2466         if (isAlphaPremultiplied) {
2467             switch (transferType) {
2468                 case DataBuffer.TYPE_BYTE: {
2469                     byte pixel[] = null;
2470                     byte zpixel[] = null;
2471                     float alphaScale = 1.0f / ((float) ((1<<nBits[aIdx]) - 1));
2472                     for (int y = 0; y < h; y++, rY++) {
2473                         rX = rminX;
2474                         for (int x = 0; x < w; x++, rX++) {
2475                             pixel = (byte[])raster.getDataElements(rX, rY,
2476                                                                    pixel);
2477                             normAlpha = (pixel[aIdx] & 0xff) * alphaScale;
2478                             if (normAlpha != 0.0f) {
2479                                 for (int c=0; c < aIdx; c++) {
2480                                     pixel[c] = (byte)((pixel[c] & 0xff) *
2481                                                       normAlpha + 0.5f);
2482                                 }
2483                                 raster.setDataElements(rX, rY, pixel);
2484                             } else {
2485                                 if (zpixel == null) {
2486                                     zpixel = new byte[numComponents];
2487                                     java.util.Arrays.fill(zpixel, (byte) 0);
2488                                 }
2489                                 raster.setDataElements(rX, rY, zpixel);
2490                             }
2491                         }
2492                     }
2493                 }
2494                 break;
2495                 case DataBuffer.TYPE_USHORT: {
2496                     short pixel[] = null;
2497                     short zpixel[] = null;
2498                     float alphaScale = 1.0f / ((float) ((1<<nBits[aIdx]) - 1));
2499                     for (int y = 0; y < h; y++, rY++) {
2500                         rX = rminX;
2501                         for (int x = 0; x < w; x++, rX++) {
2502                             pixel = (short[])raster.getDataElements(rX, rY,
2503                                                                     pixel);
2504                             normAlpha = (pixel[aIdx] & 0xffff) * alphaScale;
2505                             if (normAlpha != 0.0f) {
2506                                 for (int c=0; c < aIdx; c++) {
2507                                     pixel[c] = (short)
2508                                         ((pixel[c] & 0xffff) * normAlpha +
2509                                          0.5f);
2510                                 }
2511                                 raster.setDataElements(rX, rY, pixel);
2512                             } else {
2513                                 if (zpixel == null) {
2514                                     zpixel = new short[numComponents];
2515                                     java.util.Arrays.fill(zpixel, (short) 0);
2516                                 }
2517                                 raster.setDataElements(rX, rY, zpixel);
2518                             }
2519                         }
2520                     }
2521                 }
2522                 break;
2523                 case DataBuffer.TYPE_INT: {
2524                     int pixel[] = null;
2525                     int zpixel[] = null;
2526                     float alphaScale = 1.0f / ((float) ((1<<nBits[aIdx]) - 1));
2527                     for (int y = 0; y < h; y++, rY++) {
2528                         rX = rminX;
2529                         for (int x = 0; x < w; x++, rX++) {
2530                             pixel = (int[])raster.getDataElements(rX, rY,
2531                                                                   pixel);
2532                             normAlpha = pixel[aIdx] * alphaScale;
2533                             if (normAlpha != 0.0f) {
2534                                 for (int c=0; c < aIdx; c++) {
2535                                     pixel[c] = (int) (pixel[c] * normAlpha +
2536                                                       0.5f);
2537                                 }
2538                                 raster.setDataElements(rX, rY, pixel);
2539                             } else {
2540                                 if (zpixel == null) {
2541                                     zpixel = new int[numComponents];
2542                                     java.util.Arrays.fill(zpixel, 0);
2543                                 }
2544                                 raster.setDataElements(rX, rY, zpixel);
2545                             }
2546                         }
2547                     }
2548                 }
2549                 break;
2550                 case DataBuffer.TYPE_SHORT: {
2551                     short pixel[] = null;
2552                     short zpixel[] = null;
2553                     float alphaScale = 1.0f / 32767.0f;
2554                     for (int y = 0; y < h; y++, rY++) {
2555                         rX = rminX;
2556                         for (int x = 0; x < w; x++, rX++) {
2557                             pixel = (short[]) raster.getDataElements(rX, rY,
2558                                                                      pixel);
2559                             normAlpha = pixel[aIdx] * alphaScale;
2560                             if (normAlpha != 0.0f) {
2561                                 for (int c=0; c < aIdx; c++) {
2562                                     pixel[c] = (short) (pixel[c] * normAlpha +
2563                                                         0.5f);
2564                                 }
2565                                 raster.setDataElements(rX, rY, pixel);
2566                             } else {
2567                                 if (zpixel == null) {
2568                                     zpixel = new short[numComponents];
2569                                     java.util.Arrays.fill(zpixel, (short) 0);
2570                                 }
2571                                 raster.setDataElements(rX, rY, zpixel);
2572                             }
2573                         }
2574                     }
2575                 }
2576                 break;
2577                 case DataBuffer.TYPE_FLOAT: {
2578                     float pixel[] = null;
2579                     float zpixel[] = null;
2580                     for (int y = 0; y < h; y++, rY++) {
2581                         rX = rminX;
2582                         for (int x = 0; x < w; x++, rX++) {
2583                             pixel = (float[]) raster.getDataElements(rX, rY,
2584                                                                      pixel);
2585                             normAlpha = pixel[aIdx];
2586                             if (normAlpha != 0.0f) {
2587                                 for (int c=0; c < aIdx; c++) {
2588                                     pixel[c] *= normAlpha;
2589                                 }
2590                                 raster.setDataElements(rX, rY, pixel);
2591                             } else {
2592                                 if (zpixel == null) {
2593                                     zpixel = new float[numComponents];
2594                                     java.util.Arrays.fill(zpixel, 0.0f);
2595                                 }
2596                                 raster.setDataElements(rX, rY, zpixel);
2597                             }
2598                         }
2599                     }
2600                 }
2601                 break;
2602                 case DataBuffer.TYPE_DOUBLE: {
2603                     double pixel[] = null;
2604                     double zpixel[] = null;
2605                     for (int y = 0; y < h; y++, rY++) {
2606                         rX = rminX;
2607                         for (int x = 0; x < w; x++, rX++) {
2608                             pixel = (double[]) raster.getDataElements(rX, rY,
2609                                                                       pixel);
2610                             double dnormAlpha = pixel[aIdx];
2611                             if (dnormAlpha != 0.0) {
2612                                 for (int c=0; c < aIdx; c++) {
2613                                     pixel[c] *= dnormAlpha;
2614                                 }
2615                                 raster.setDataElements(rX, rY, pixel);
2616                             } else {
2617                                 if (zpixel == null) {
2618                                     zpixel = new double[numComponents];
2619                                     java.util.Arrays.fill(zpixel, 0.0);
2620                                 }
2621                                 raster.setDataElements(rX, rY, zpixel);
2622                             }
2623                         }
2624                     }
2625                 }
2626                 break;
2627                 default:
2628                     throw new UnsupportedOperationException("This method has not been "+
2629                          "implemented for transferType " + transferType);
2630             }
2631         }
2632         else {
2633             // We are premultiplied and want to divide it out
2634             switch (transferType) {
2635                 case DataBuffer.TYPE_BYTE: {
2636                     byte pixel[] = null;
2637                     float alphaScale = 1.0f / ((float) ((1<<nBits[aIdx]) - 1));
2638                     for (int y = 0; y < h; y++, rY++) {
2639                         rX = rminX;
2640                         for (int x = 0; x < w; x++, rX++) {
2641                             pixel = (byte[])raster.getDataElements(rX, rY,
2642                                                                    pixel);
2643                             normAlpha = (pixel[aIdx] & 0xff) * alphaScale;
2644                             if (normAlpha != 0.0f) {
2645                                 float invAlpha = 1.0f / normAlpha;
2646                                 for (int c=0; c < aIdx; c++) {
2647                                     pixel[c] = (byte)
2648                                         ((pixel[c] & 0xff) * invAlpha + 0.5f);
2649                                 }
2650                                 raster.setDataElements(rX, rY, pixel);
2651                             }
2652                         }
2653                     }
2654                 }
2655                 break;
2656                 case DataBuffer.TYPE_USHORT: {
2657                     short pixel[] = null;
2658                     float alphaScale = 1.0f / ((float) ((1<<nBits[aIdx]) - 1));
2659                     for (int y = 0; y < h; y++, rY++) {
2660                         rX = rminX;
2661                         for (int x = 0; x < w; x++, rX++) {
2662                             pixel = (short[])raster.getDataElements(rX, rY,
2663                                                                     pixel);
2664                             normAlpha = (pixel[aIdx] & 0xffff) * alphaScale;
2665                             if (normAlpha != 0.0f) {
2666                                 float invAlpha = 1.0f / normAlpha;
2667                                 for (int c=0; c < aIdx; c++) {
2668                                     pixel[c] = (short)
2669                                         ((pixel[c] & 0xffff) * invAlpha + 0.5f);
2670                                 }
2671                                 raster.setDataElements(rX, rY, pixel);
2672                             }
2673                         }
2674                     }
2675                 }
2676                 break;
2677                 case DataBuffer.TYPE_INT: {
2678                     int pixel[] = null;
2679                     float alphaScale = 1.0f / ((float) ((1<<nBits[aIdx]) - 1));
2680                     for (int y = 0; y < h; y++, rY++) {
2681                         rX = rminX;
2682                         for (int x = 0; x < w; x++, rX++) {
2683                             pixel = (int[])raster.getDataElements(rX, rY,
2684                                                                   pixel);
2685                             normAlpha = pixel[aIdx] * alphaScale;
2686                             if (normAlpha != 0.0f) {
2687                                 float invAlpha = 1.0f / normAlpha;
2688                                 for (int c=0; c < aIdx; c++) {
2689                                     pixel[c] = (int)
2690                                         (pixel[c] * invAlpha + 0.5f);
2691                                 }
2692                                 raster.setDataElements(rX, rY, pixel);
2693                             }
2694                         }
2695                     }
2696                 }
2697                 break;
2698                 case DataBuffer.TYPE_SHORT: {
2699                     short pixel[] = null;
2700                     float alphaScale = 1.0f / 32767.0f;
2701                     for (int y = 0; y < h; y++, rY++) {
2702                         rX = rminX;
2703                         for (int x = 0; x < w; x++, rX++) {
2704                             pixel = (short[])raster.getDataElements(rX, rY,
2705                                                                     pixel);
2706                             normAlpha = pixel[aIdx] * alphaScale;
2707                             if (normAlpha != 0.0f) {
2708                                 float invAlpha = 1.0f / normAlpha;
2709                                 for (int c=0; c < aIdx; c++) {
2710                                     pixel[c] = (short)
2711                                         (pixel[c] * invAlpha + 0.5f);
2712                                 }
2713                                 raster.setDataElements(rX, rY, pixel);
2714                             }
2715                         }
2716                     }
2717                 }
2718                 break;
2719                 case DataBuffer.TYPE_FLOAT: {
2720                     float pixel[] = null;
2721                     for (int y = 0; y < h; y++, rY++) {
2722                         rX = rminX;
2723                         for (int x = 0; x < w; x++, rX++) {
2724                             pixel = (float[])raster.getDataElements(rX, rY,
2725                                                                     pixel);
2726                             normAlpha = pixel[aIdx];
2727                             if (normAlpha != 0.0f) {
2728                                 float invAlpha = 1.0f / normAlpha;
2729                                 for (int c=0; c < aIdx; c++) {
2730                                     pixel[c] *= invAlpha;
2731                                 }
2732                                 raster.setDataElements(rX, rY, pixel);
2733                             }
2734                         }
2735                     }
2736                 }
2737                 break;
2738                 case DataBuffer.TYPE_DOUBLE: {
2739                     double pixel[] = null;
2740                     for (int y = 0; y < h; y++, rY++) {
2741                         rX = rminX;
2742                         for (int x = 0; x < w; x++, rX++) {
2743                             pixel = (double[])raster.getDataElements(rX, rY,
2744                                                                      pixel);
2745                             double dnormAlpha = pixel[aIdx];
2746                             if (dnormAlpha != 0.0) {
2747                                 double invAlpha = 1.0 / dnormAlpha;
2748                                 for (int c=0; c < aIdx; c++) {
2749                                     pixel[c] *= invAlpha;
2750                                 }
2751                                 raster.setDataElements(rX, rY, pixel);
2752                             }
2753                         }
2754                     }
2755                 }
2756                 break;
2757                 default:
2758                     throw new UnsupportedOperationException("This method has not been "+
2759                          "implemented for transferType " + transferType);
2760             }
2761         }
2762 
2763         // Return a new color model
2764         if (!signed) {
2765             return new ComponentColorModel(colorSpace, nBits, supportsAlpha,
2766                                            isAlphaPremultiplied, transparency,
2767                                            transferType);
2768         } else {
2769             return new ComponentColorModel(colorSpace, supportsAlpha,
2770                                            isAlphaPremultiplied, transparency,
2771                                            transferType);
2772         }
2773 
2774     }
2775 
2776     /**
2777       * Returns true if {@code raster} is compatible with this
2778       * {@code ColorModel}; false if it is not.
2779       *
2780       * @param raster The {@code Raster} object to test for compatibility.
2781       *
2782       * @return {@code true} if {@code raster} is compatible with this
2783       * {@code ColorModel}, {@code false} if it is not.
2784       */
2785     public boolean isCompatibleRaster(Raster raster) {
2786 
2787         SampleModel sm = raster.getSampleModel();
2788 
2789         if (sm instanceof ComponentSampleModel) {
2790             if (sm.getNumBands() != getNumComponents()) {
2791                 return false;
2792             }
2793             for (int i=0; i<nBits.length; i++) {
2794                 if (sm.getSampleSize(i) < nBits[i]) {
2795                     return false;
2796                 }
2797             }
2798             return (raster.getTransferType() == transferType);
2799         }
2800         else {
2801             return false;
2802         }
2803     }
2804 
2805     /**
2806      * Creates a {@code WritableRaster} with the specified width and height,
2807      * that  has a data layout ({@code SampleModel}) compatible with
2808      * this {@code ColorModel}.
2809      *
2810      * @param w The width of the {@code WritableRaster} you want to create.
2811      * @param h The height of the {@code WritableRaster} you want to create.
2812      *
2813      * @return A {@code WritableRaster} that is compatible with
2814      * this {@code ColorModel}.
2815      * @see WritableRaster
2816      * @see SampleModel
2817      */
2818     public WritableRaster createCompatibleWritableRaster (int w, int h) {
2819         int dataSize = w*h*numComponents;
2820         WritableRaster raster = null;
2821 
2822         switch (transferType) {
2823         case DataBuffer.TYPE_BYTE:
2824         case DataBuffer.TYPE_USHORT:
2825             raster = Raster.createInterleavedRaster(transferType,
2826                                                     w, h,
2827                                                     numComponents, null);
2828             break;
2829         default:
2830             SampleModel sm = createCompatibleSampleModel(w, h);
2831             DataBuffer db = sm.createDataBuffer();
2832             raster = Raster.createWritableRaster(sm, db, null);
2833         }
2834 
2835         return raster;
2836     }
2837 
2838     /**
2839      * Creates a {@code SampleModel} with the specified width and height,
2840      * that  has a data layout compatible with this {@code ColorModel}.
2841      *
2842      * @param w The width of the {@code SampleModel} you want to create.
2843      * @param h The height of the {@code SampleModel} you want to create.
2844      *
2845      * @return A {@code SampleModel} that is compatible with this
2846      * {@code ColorModel}.
2847      *
2848      * @see SampleModel
2849      */
2850     public SampleModel createCompatibleSampleModel(int w, int h) {
2851         int[] bandOffsets = new int[numComponents];
2852         for (int i=0; i < numComponents; i++) {
2853             bandOffsets[i] = i;
2854         }
2855         switch (transferType) {
2856         case DataBuffer.TYPE_BYTE:
2857         case DataBuffer.TYPE_USHORT:
2858             return new PixelInterleavedSampleModel(transferType, w, h,
2859                                                    numComponents,
2860                                                    w*numComponents,
2861                                                    bandOffsets);
2862         default:
2863             return new ComponentSampleModel(transferType, w, h,
2864                                             numComponents,
2865                                             w*numComponents,
2866                                             bandOffsets);
2867         }
2868     }
2869 
2870     /**
2871      * Checks whether or not the specified {@code SampleModel}
2872      * is compatible with this {@code ColorModel}.
2873      *
2874      * @param sm The {@code SampleModel} to test for compatibility.
2875      *
2876      * @return {@code true} if the {@code SampleModel} is
2877      * compatible with this {@code ColorModel}, {@code false}
2878      * if it is not.
2879      *
2880      * @see SampleModel
2881      */
2882     public boolean isCompatibleSampleModel(SampleModel sm) {
2883         if (!(sm instanceof ComponentSampleModel)) {
2884             return false;
2885         }
2886 
2887         // Must have the same number of components
2888         if (numComponents != sm.getNumBands()) {
2889             return false;
2890         }
2891 
2892         if (sm.getTransferType() != transferType) {
2893             return false;
2894         }
2895 
2896         return true;
2897     }
2898 
2899     /**
2900      * Returns a {@code Raster} representing the alpha channel of an image,
2901      * extracted from the input {@code Raster}.
2902      * This method assumes that {@code Raster} objects associated with
2903      * this {@code ColorModel} store the alpha band, if present, as
2904      * the last band of image data. Returns null if there is no separate spatial
2905      * alpha channel associated with this {@code ColorModel}.
2906      * This method creates a new {@code Raster}, but will share the data
2907      * array.
2908      *
2909      * @param raster The {@code WritableRaster} from which to extract the
2910      * alpha  channel.
2911      *
2912      * @return A {@code WritableRaster} containing the image's alpha channel.
2913      *
2914      */
2915     public WritableRaster getAlphaRaster(WritableRaster raster) {
2916         if (hasAlpha() == false) {
2917             return null;
2918         }
2919 
2920         int x = raster.getMinX();
2921         int y = raster.getMinY();
2922         int[] band = new int[1];
2923         band[0] = raster.getNumBands() - 1;
2924         return raster.createWritableChild(x, y, raster.getWidth(),
2925                                           raster.getHeight(), x, y,
2926                                           band);
2927     }
2928 
2929     /**
2930      * Tests if the specified {@code Object} is an instance
2931      * of {@code ComponentColorModel} and equals this
2932      * {@code ComponentColorModel}.
2933      * @param obj the {@code Object} to test for equality
2934      * @return {@code true} if the specified {@code Object}
2935      * is an instance of {@code ComponentColorModel} and equals this
2936      * {@code ComponentColorModel}; {@code false} otherwise.
2937      */
2938     @Override
2939     public boolean equals(Object obj) {
2940 
2941         ComponentColorModel cm = (ComponentColorModel) obj;
2942         if (this == cm) {
2943             return true;
2944         }
2945 
2946         if (!super.equals(obj)) {
2947             return false;
2948         }
2949         return true;
2950     }
2951 
2952     /**
2953      * Returns the hash code for this ComponentColorModel.
2954      *
2955      * @return    a hash code for this ComponentColorModel.
2956      */
2957     @Override
2958     public int hashCode() {
2959         int hash = 7;
2960         hash = 79 * hash + super.hashCode();
2961         return hash;
2962     }
2963 
2964 }