1 /*
2 * Copyright (c) 1995, 2013, 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.Transparency;
29 import java.awt.color.ColorSpace;
30 import java.awt.color.ICC_ColorSpace;
31 import sun.java2d.cmm.CMSManager;
32 import sun.java2d.cmm.ColorTransform;
33 import sun.java2d.cmm.PCMM;
34 import java.util.Arrays;
35 import java.util.Collections;
36 import java.util.Map;
37 import java.util.WeakHashMap;
38
39 /**
40 * The {@code ColorModel} abstract class encapsulates the
41 * methods for translating a pixel value to color components
42 * (for example, red, green, and blue) and an alpha component.
43 * In order to render an image to the screen, a printer, or another
44 * image, pixel values must be converted to color and alpha components.
45 * As arguments to or return values from methods of this class,
46 * pixels are represented as 32-bit ints or as arrays of primitive types.
47 * The number, order, and interpretation of color components for a
48 * {@code ColorModel} is specified by its {@code ColorSpace}.
49 * A {@code ColorModel} used with pixel data that does not include
50 * alpha information treats all pixels as opaque, which is an alpha
51 * value of 1.0.
52 * <p>
53 * This {@code ColorModel} class supports two representations of
54 * pixel values. A pixel value can be a single 32-bit int or an
55 * array of primitive types. The Java(tm) Platform 1.0 and 1.1 APIs
56 * represented pixels as single {@code byte} or single
57 * {@code int} values. For purposes of the {@code ColorModel}
58 * class, pixel value arguments were passed as ints. The Java(tm) 2
59 * Platform API introduced additional classes for representing images.
60 * With {@link BufferedImage} or {@link RenderedImage}
61 * objects, based on {@link Raster} and {@link SampleModel} classes, pixel
62 * values might not be conveniently representable as a single int.
63 * Consequently, {@code ColorModel} now has methods that accept
64 * pixel values represented as arrays of primitive types. The primitive
65 * type used by a particular {@code ColorModel} object is called its
66 * transfer type.
67 * <p>
68 * {@code ColorModel} objects used with images for which pixel values
69 * are not conveniently representable as a single int throw an
70 * {@link IllegalArgumentException} when methods taking a single int pixel
71 * argument are called. Subclasses of {@code ColorModel} must
72 * specify the conditions under which this occurs. This does not
73 * occur with {@link DirectColorModel} or {@link IndexColorModel} objects.
74 * <p>
75 * Currently, the transfer types supported by the Java 2D(tm) API are
76 * DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT, DataBuffer.TYPE_INT,
77 * DataBuffer.TYPE_SHORT, DataBuffer.TYPE_FLOAT, and DataBuffer.TYPE_DOUBLE.
78 * Most rendering operations will perform much faster when using ColorModels
79 * and images based on the first three of these types. In addition, some
80 * image filtering operations are not supported for ColorModels and
81 * images based on the latter three types.
82 * The transfer type for a particular {@code ColorModel} object is
83 * specified when the object is created, either explicitly or by default.
84 * All subclasses of {@code ColorModel} must specify what the
85 * possible transfer types are and how the number of elements in the
86 * primitive arrays representing pixels is determined.
87 * <p>
88 * For {@code BufferedImages}, the transfer type of its
89 * {@code Raster} and of the {@code Raster} object's
90 * {@code SampleModel} (available from the
91 * {@code getTransferType} methods of these classes) must match that
92 * of the {@code ColorModel}. The number of elements in an array
93 * representing a pixel for the {@code Raster} and
94 * {@code SampleModel} (available from the
95 * {@code getNumDataElements} methods of these classes) must match
96 * that of the {@code ColorModel}.
97 * <p>
98 * The algorithm used to convert from pixel values to color and alpha
99 * components varies by subclass. For example, there is not necessarily
100 * a one-to-one correspondence between samples obtained from the
101 * {@code SampleModel} of a {@code BufferedImage} object's
102 * {@code Raster} and color/alpha components. Even when
103 * there is such a correspondence, the number of bits in a sample is not
104 * necessarily the same as the number of bits in the corresponding color/alpha
105 * component. Each subclass must specify how the translation from
106 * pixel values to color/alpha components is done.
107 * <p>
108 * Methods in the {@code ColorModel} class use two different
109 * representations of color and alpha components - a normalized form
110 * and an unnormalized form. In the normalized form, each component is a
111 * {@code float} value between some minimum and maximum values. For
112 * the alpha component, the minimum is 0.0 and the maximum is 1.0. For
113 * color components the minimum and maximum values for each component can
114 * be obtained from the {@code ColorSpace} object. These values
115 * will often be 0.0 and 1.0 (e.g. normalized component values for the
116 * default sRGB color space range from 0.0 to 1.0), but some color spaces
117 * have component values with different upper and lower limits. These
118 * limits can be obtained using the {@code getMinValue} and
119 * {@code getMaxValue} methods of the {@code ColorSpace}
120 * class. Normalized color component values are not premultiplied.
121 * All {@code ColorModels} must support the normalized form.
122 * <p>
123 * In the unnormalized
124 * form, each component is an unsigned integral value between 0 and
125 * 2<sup>n</sup> - 1, where n is the number of significant bits for a
126 * particular component. If pixel values for a particular
127 * {@code ColorModel} represent color samples premultiplied by
128 * the alpha sample, unnormalized color component values are
129 * also premultiplied. The unnormalized form is used only with instances
130 * of {@code ColorModel} whose {@code ColorSpace} has minimum
131 * component values of 0.0 for all components and maximum values of
132 * 1.0 for all components.
133 * The unnormalized form for color and alpha components can be a convenient
134 * representation for {@code ColorModels} whose normalized component
135 * values all lie
136 * between 0.0 and 1.0. In such cases the integral value 0 maps to 0.0 and
137 * the value 2<sup>n</sup> - 1 maps to 1.0. In other cases, such as
138 * when the normalized component values can be either negative or positive,
139 * the unnormalized form is not convenient. Such {@code ColorModel}
140 * objects throw an {@link IllegalArgumentException} when methods involving
141 * an unnormalized argument are called. Subclasses of {@code ColorModel}
142 * must specify the conditions under which this occurs.
143 *
144 * @see IndexColorModel
145 * @see ComponentColorModel
146 * @see PackedColorModel
147 * @see DirectColorModel
148 * @see java.awt.Image
149 * @see BufferedImage
150 * @see RenderedImage
151 * @see java.awt.color.ColorSpace
152 * @see SampleModel
153 * @see Raster
154 * @see DataBuffer
155 */
156 public abstract class ColorModel implements Transparency{
157 private long pData; // Placeholder for data for native functions
158
159 /**
160 * The total number of bits in the pixel.
161 */
162 protected int pixel_bits;
163 int nBits[];
164 int transparency = Transparency.TRANSLUCENT;
165 boolean supportsAlpha = true;
166 boolean isAlphaPremultiplied = false;
167 int numComponents = -1;
168 int numColorComponents = -1;
169 ColorSpace colorSpace = ColorSpace.getInstance(ColorSpace.CS_sRGB);
170 int colorSpaceType = ColorSpace.TYPE_RGB;
171 int maxBits;
172 boolean is_sRGB = true;
173
174 /**
175 * Data type of the array used to represent pixel values.
176 */
177 protected int transferType;
178
179 /**
180 * This is copied from java.awt.Toolkit since we need the library
181 * loaded in java.awt.image also:
182 *
183 * WARNING: This is a temporary workaround for a problem in the
184 * way the AWT loads native libraries. A number of classes in the
185 * AWT package have a native method, initIDs(), which initializes
186 * the JNI field and method ids used in the native portion of
187 * their implementation.
188 *
189 * Since the use and storage of these ids is done by the
190 * implementation libraries, the implementation of these method is
191 * provided by the particular AWT implementations (for example,
192 * "Toolkit"s/Peer), such as Motif, Microsoft Windows, or Tiny. The
193 * problem is that this means that the native libraries must be
194 * loaded by the java.* classes, which do not necessarily know the
195 * names of the libraries to load. A better way of doing this
196 * would be to provide a separate library which defines java.awt.*
197 * initIDs, and exports the relevant symbols out to the
198 * implementation libraries.
199 *
200 * For now, we know it's done by the implementation, and we assume
201 * that the name of the library is "awt". -br.
202 */
203 private static boolean loaded = false;
204 static void loadLibraries() {
205 if (!loaded) {
206 java.security.AccessController.doPrivileged(
207 new java.security.PrivilegedAction<Void>() {
208 public Void run() {
209 System.loadLibrary("awt");
210 return null;
211 }
212 });
213 loaded = true;
214 }
215 }
216 private static native void initIDs();
217 static {
218 /* ensure that the proper libraries are loaded */
219 loadLibraries();
220 initIDs();
221 }
222 private static ColorModel RGBdefault;
223
224 /**
225 * Returns a {@code DirectColorModel} that describes the default
226 * format for integer RGB values used in many of the methods in the
227 * AWT image interfaces for the convenience of the programmer.
228 * The color space is the default {@link ColorSpace}, sRGB.
229 * The format for the RGB values is an integer with 8 bits
230 * each of alpha, red, green, and blue color components ordered
231 * correspondingly from the most significant byte to the least
232 * significant byte, as in: 0xAARRGGBB. Color components are
233 * not premultiplied by the alpha component. This format does not
234 * necessarily represent the native or the most efficient
235 * {@code ColorModel} for a particular device or for all images.
236 * It is merely used as a common color model format.
237 * @return a {@code DirectColorModel} object describing default
238 * RGB values.
239 */
240 public static ColorModel getRGBdefault() {
241 if (RGBdefault == null) {
242 RGBdefault = new DirectColorModel(32,
243 0x00ff0000, // Red
244 0x0000ff00, // Green
245 0x000000ff, // Blue
246 0xff000000 // Alpha
247 );
248 }
249 return RGBdefault;
250 }
251
252 /**
253 * Constructs a {@code ColorModel} that translates pixels of the
254 * specified number of bits to color/alpha components. The color
255 * space is the default RGB {@code ColorSpace}, which is sRGB.
256 * Pixel values are assumed to include alpha information. If color
257 * and alpha information are represented in the pixel value as
258 * separate spatial bands, the color bands are assumed not to be
259 * premultiplied with the alpha value. The transparency type is
260 * java.awt.Transparency.TRANSLUCENT. The transfer type will be the
261 * smallest of DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT,
262 * or DataBuffer.TYPE_INT that can hold a single pixel
263 * (or DataBuffer.TYPE_UNDEFINED if bits is greater
264 * than 32). Since this constructor has no information about the
265 * number of bits per color and alpha component, any subclass calling
266 * this constructor should override any method that requires this
267 * information.
268 * @param bits the number of bits of a pixel
269 * @throws IllegalArgumentException if the number
270 * of bits in {@code bits} is less than 1
271 */
272 public ColorModel(int bits) {
273 pixel_bits = bits;
274 if (bits < 1) {
275 throw new IllegalArgumentException("Number of bits must be > 0");
276 }
277 numComponents = 4;
278 numColorComponents = 3;
279 maxBits = bits;
280 // REMIND: make sure transferType is set correctly
281 transferType = ColorModel.getDefaultTransferType(bits);
282 }
283
284 /**
285 * Constructs a {@code ColorModel} that translates pixel values
286 * to color/alpha components. Color components will be in the
287 * specified {@code ColorSpace}. {@code pixel_bits} is the
288 * number of bits in the pixel values. The bits array
289 * specifies the number of significant bits per color and alpha component.
290 * Its length should be the number of components in the
291 * {@code ColorSpace} if there is no alpha information in the
292 * pixel values, or one more than this number if there is alpha
293 * information. {@code hasAlpha} indicates whether or not alpha
294 * information is present. The {@code boolean}
295 * {@code isAlphaPremultiplied} specifies how to interpret pixel
296 * values in which color and alpha information are represented as
297 * separate spatial bands. If the {@code boolean}
298 * is {@code true}, color samples are assumed to have been
299 * multiplied by the alpha sample. The {@code transparency}
300 * specifies what alpha values can be represented by this color model.
301 * The transfer type is the type of primitive array used to represent
302 * pixel values. Note that the bits array contains the number of
303 * significant bits per color/alpha component after the translation
304 * from pixel values. For example, for an
305 * {@code IndexColorModel} with {@code pixel_bits} equal to
306 * 16, the bits array might have four elements with each element set
307 * to 8.
308 * @param pixel_bits the number of bits in the pixel values
309 * @param bits array that specifies the number of significant bits
310 * per color and alpha component
311 * @param cspace the specified {@code ColorSpace}
312 * @param hasAlpha {@code true} if alpha information is present;
313 * {@code false} otherwise
314 * @param isAlphaPremultiplied {@code true} if color samples are
315 * assumed to be premultiplied by the alpha samples;
316 * {@code false} otherwise
317 * @param transparency what alpha values can be represented by this
318 * color model
319 * @param transferType the type of the array used to represent pixel
320 * values
321 * @throws IllegalArgumentException if the length of
322 * the bit array is less than the number of color or alpha
323 * components in this {@code ColorModel}, or if the
324 * transparency is not a valid value.
325 * @throws IllegalArgumentException if the sum of the number
326 * of bits in {@code bits} is less than 1 or if
327 * any of the elements in {@code bits} is less than 0.
328 * @see java.awt.Transparency
329 */
330 protected ColorModel(int pixel_bits, int[] bits, ColorSpace cspace,
331 boolean hasAlpha,
332 boolean isAlphaPremultiplied,
333 int transparency,
334 int transferType) {
335 colorSpace = cspace;
336 colorSpaceType = cspace.getType();
337 numColorComponents = cspace.getNumComponents();
338 numComponents = numColorComponents + (hasAlpha ? 1 : 0);
339 supportsAlpha = hasAlpha;
340 if (bits.length < numComponents) {
341 throw new IllegalArgumentException("Number of color/alpha "+
342 "components should be "+
343 numComponents+
344 " but length of bits array is "+
345 bits.length);
346 }
347
348 // 4186669
349 if (transparency < Transparency.OPAQUE ||
350 transparency > Transparency.TRANSLUCENT)
351 {
352 throw new IllegalArgumentException("Unknown transparency: "+
353 transparency);
354 }
355
356 if (supportsAlpha == false) {
357 this.isAlphaPremultiplied = false;
358 this.transparency = Transparency.OPAQUE;
359 }
360 else {
361 this.isAlphaPremultiplied = isAlphaPremultiplied;
362 this.transparency = transparency;
363 }
364
365 nBits = bits.clone();
366 this.pixel_bits = pixel_bits;
367 if (pixel_bits <= 0) {
368 throw new IllegalArgumentException("Number of pixel bits must "+
369 "be > 0");
370 }
371 // Check for bits < 0
372 maxBits = 0;
373 for (int i=0; i < bits.length; i++) {
374 // bug 4304697
375 if (bits[i] < 0) {
376 throw new
377 IllegalArgumentException("Number of bits must be >= 0");
378 }
379 if (maxBits < bits[i]) {
380 maxBits = bits[i];
381 }
382 }
383
384 // Make sure that we don't have all 0-bit components
385 if (maxBits == 0) {
386 throw new IllegalArgumentException("There must be at least "+
387 "one component with > 0 "+
388 "pixel bits.");
389 }
390
391 // Save this since we always need to check if it is the default CS
392 if (cspace != ColorSpace.getInstance(ColorSpace.CS_sRGB)) {
393 is_sRGB = false;
394 }
395
396 // Save the transfer type
397 this.transferType = transferType;
398 }
399
400 /**
401 * Returns whether or not alpha is supported in this
402 * {@code ColorModel}.
403 * @return {@code true} if alpha is supported in this
404 * {@code ColorModel}; {@code false} otherwise.
405 */
406 public final boolean hasAlpha() {
407 return supportsAlpha;
408 }
409
410 /**
411 * Returns whether or not the alpha has been premultiplied in the
412 * pixel values to be translated by this {@code ColorModel}.
413 * If the boolean is {@code true}, this {@code ColorModel}
414 * is to be used to interpret pixel values in which color and alpha
415 * information are represented as separate spatial bands, and color
416 * samples are assumed to have been multiplied by the
417 * alpha sample.
418 * @return {@code true} if the alpha values are premultiplied
419 * in the pixel values to be translated by this
420 * {@code ColorModel}; {@code false} otherwise.
421 */
422 public final boolean isAlphaPremultiplied() {
423 return isAlphaPremultiplied;
424 }
425
426 /**
427 * Returns the transfer type of this {@code ColorModel}.
428 * The transfer type is the type of primitive array used to represent
429 * pixel values as arrays.
430 * @return the transfer type.
431 * @since 1.3
432 */
433 public final int getTransferType() {
434 return transferType;
435 }
436
437 /**
438 * Returns the number of bits per pixel described by this
439 * {@code ColorModel}.
440 * @return the number of bits per pixel.
441 */
442 public int getPixelSize() {
443 return pixel_bits;
444 }
445
446 /**
447 * Returns the number of bits for the specified color/alpha component.
448 * Color components are indexed in the order specified by the
449 * {@code ColorSpace}. Typically, this order reflects the name
450 * of the color space type. For example, for TYPE_RGB, index 0
451 * corresponds to red, index 1 to green, and index 2
452 * to blue. If this {@code ColorModel} supports alpha, the alpha
453 * component corresponds to the index following the last color
454 * component.
455 * @param componentIdx the index of the color/alpha component
456 * @return the number of bits for the color/alpha component at the
457 * specified index.
458 * @throws ArrayIndexOutOfBoundsException if {@code componentIdx}
459 * is greater than the number of components or
460 * less than zero
461 * @throws NullPointerException if the number of bits array is
462 * {@code null}
463 */
464 public int getComponentSize(int componentIdx) {
465 // REMIND:
466 if (nBits == null) {
467 throw new NullPointerException("Number of bits array is null.");
468 }
469
470 return nBits[componentIdx];
471 }
472
473 /**
474 * Returns an array of the number of bits per color/alpha component.
475 * The array contains the color components in the order specified by the
476 * {@code ColorSpace}, followed by the alpha component, if
477 * present.
478 * @return an array of the number of bits per color/alpha component
479 */
480 public int[] getComponentSize() {
481 if (nBits != null) {
482 return nBits.clone();
483 }
484
485 return null;
486 }
487
488 /**
489 * Returns the transparency. Returns either OPAQUE, BITMASK,
490 * or TRANSLUCENT.
491 * @return the transparency of this {@code ColorModel}.
492 * @see Transparency#OPAQUE
493 * @see Transparency#BITMASK
494 * @see Transparency#TRANSLUCENT
495 */
496 public int getTransparency() {
497 return transparency;
498 }
499
500 /**
501 * Returns the number of components, including alpha, in this
502 * {@code ColorModel}. This is equal to the number of color
503 * components, optionally plus one, if there is an alpha component.
504 * @return the number of components in this {@code ColorModel}
505 */
506 public int getNumComponents() {
507 return numComponents;
508 }
509
510 /**
511 * Returns the number of color components in this
512 * {@code ColorModel}.
513 * This is the number of components returned by
514 * {@link ColorSpace#getNumComponents}.
515 * @return the number of color components in this
516 * {@code ColorModel}.
517 * @see ColorSpace#getNumComponents
518 */
519 public int getNumColorComponents() {
520 return numColorComponents;
521 }
522
523 /**
524 * Returns the red color component for the specified pixel, scaled
525 * from 0 to 255 in the default RGB ColorSpace, sRGB. A color conversion
526 * is done if necessary. The pixel value is specified as an int.
527 * An {@code IllegalArgumentException} is thrown if pixel
528 * values for this {@code ColorModel} are not conveniently
529 * representable as a single int. The returned value is not a
530 * pre-multiplied value. For example, if the
531 * alpha is premultiplied, this method divides it out before returning
532 * the value. If the alpha value is 0, the red value is 0.
533 * @param pixel a specified pixel
534 * @return the value of the red component of the specified pixel.
535 */
536 public abstract int getRed(int pixel);
537
538 /**
539 * Returns the green color component for the specified pixel, scaled
540 * from 0 to 255 in the default RGB ColorSpace, sRGB. A color conversion
541 * is done if necessary. The pixel value is specified as an int.
542 * An {@code IllegalArgumentException} is thrown if pixel
543 * values for this {@code ColorModel} are not conveniently
544 * representable as a single int. The returned value is a non
545 * pre-multiplied value. For example, if the alpha is premultiplied,
546 * this method divides it out before returning
547 * the value. If the alpha value is 0, the green value is 0.
548 * @param pixel the specified pixel
549 * @return the value of the green component of the specified pixel.
550 */
551 public abstract int getGreen(int pixel);
552
553 /**
554 * Returns the blue color component for the specified pixel, scaled
555 * from 0 to 255 in the default RGB ColorSpace, sRGB. A color conversion
556 * is done if necessary. The pixel value is specified as an int.
557 * An {@code IllegalArgumentException} is thrown if pixel values
558 * for this {@code ColorModel} are not conveniently representable
559 * as a single int. The returned value is a non pre-multiplied
560 * value, for example, if the alpha is premultiplied, this method
561 * divides it out before returning the value. If the alpha value is
562 * 0, the blue value is 0.
563 * @param pixel the specified pixel
564 * @return the value of the blue component of the specified pixel.
565 */
566 public abstract int getBlue(int pixel);
567
568 /**
569 * Returns the alpha component for the specified pixel, scaled
570 * from 0 to 255. The pixel value is specified as an int.
571 * An {@code IllegalArgumentException} is thrown if pixel
572 * values for this {@code ColorModel} are not conveniently
573 * representable as a single int.
574 * @param pixel the specified pixel
575 * @return the value of alpha component of the specified pixel.
576 */
577 public abstract int getAlpha(int pixel);
578
579 /**
580 * Returns the color/alpha components of the pixel in the default
581 * RGB color model format. A color conversion is done if necessary.
582 * The pixel value is specified as an int.
583 * An {@code IllegalArgumentException} thrown if pixel values
584 * for this {@code ColorModel} are not conveniently representable
585 * as a single int. The returned value is in a non
586 * pre-multiplied format. For example, if the alpha is premultiplied,
587 * this method divides it out of the color components. If the alpha
588 * value is 0, the color values are 0.
589 * @param pixel the specified pixel
590 * @return the RGB value of the color/alpha components of the
591 * specified pixel.
592 * @see ColorModel#getRGBdefault
593 */
594 public int getRGB(int pixel) {
595 return (getAlpha(pixel) << 24)
596 | (getRed(pixel) << 16)
597 | (getGreen(pixel) << 8)
598 | (getBlue(pixel) << 0);
599 }
600
601 /**
602 * Returns the red color component for the specified pixel, scaled
603 * from 0 to 255 in the default RGB {@code ColorSpace}, sRGB. A
604 * color conversion is done if necessary. The pixel value is
605 * specified by an array of data elements of type transferType passed
606 * in as an object reference. The returned value is a non
607 * pre-multiplied value. For example, if alpha is premultiplied,
608 * this method divides it out before returning
609 * the value. If the alpha value is 0, the red value is 0.
610 * If {@code inData} is not a primitive array of type
611 * transferType, a {@code ClassCastException} is thrown. An
612 * {@code ArrayIndexOutOfBoundsException} is thrown if
613 * {@code inData} is not large enough to hold a pixel value for
614 * this {@code ColorModel}.
615 * If this {@code transferType} is not supported, a
616 * {@code UnsupportedOperationException} will be
617 * thrown. Since
618 * {@code ColorModel} is an abstract class, any instance
619 * must be an instance of a subclass. Subclasses inherit the
620 * implementation of this method and if they don't override it, this
621 * method throws an exception if the subclass uses a
622 * {@code transferType} other than
623 * {@code DataBuffer.TYPE_BYTE},
624 * {@code DataBuffer.TYPE_USHORT}, or
625 * {@code DataBuffer.TYPE_INT}.
626 * @param inData an array of pixel values
627 * @return the value of the red component of the specified pixel.
628 * @throws ClassCastException if {@code inData}
629 * is not a primitive array of type {@code transferType}
630 * @throws ArrayIndexOutOfBoundsException if
631 * {@code inData} is not large enough to hold a pixel value
632 * for this {@code ColorModel}
633 * @throws UnsupportedOperationException if this
634 * {@code transferType} is not supported by this
635 * {@code ColorModel}
636 */
637 public int getRed(Object inData) {
638 int pixel=0,length=0;
639 switch (transferType) {
640 case DataBuffer.TYPE_BYTE:
641 byte bdata[] = (byte[])inData;
642 pixel = bdata[0] & 0xff;
643 length = bdata.length;
644 break;
645 case DataBuffer.TYPE_USHORT:
646 short sdata[] = (short[])inData;
647 pixel = sdata[0] & 0xffff;
648 length = sdata.length;
649 break;
650 case DataBuffer.TYPE_INT:
651 int idata[] = (int[])inData;
652 pixel = idata[0];
653 length = idata.length;
654 break;
655 default:
656 throw new UnsupportedOperationException("This method has not been "+
657 "implemented for transferType " + transferType);
658 }
659 if (length == 1) {
660 return getRed(pixel);
661 }
662 else {
663 throw new UnsupportedOperationException
664 ("This method is not supported by this color model");
665 }
666 }
667
668 /**
669 * Returns the green color component for the specified pixel, scaled
670 * from 0 to 255 in the default RGB {@code ColorSpace}, sRGB. A
671 * color conversion is done if necessary. The pixel value is
672 * specified by an array of data elements of type transferType passed
673 * in as an object reference. The returned value will be a non
674 * pre-multiplied value. For example, if the alpha is premultiplied,
675 * this method divides it out before returning the value. If the
676 * alpha value is 0, the green value is 0. If {@code inData} is
677 * not a primitive array of type transferType, a
678 * {@code ClassCastException} is thrown. An
679 * {@code ArrayIndexOutOfBoundsException} is thrown if
680 * {@code inData} is not large enough to hold a pixel value for
681 * this {@code ColorModel}.
682 * If this {@code transferType} is not supported, a
683 * {@code UnsupportedOperationException} will be
684 * thrown. Since
685 * {@code ColorModel} is an abstract class, any instance
686 * must be an instance of a subclass. Subclasses inherit the
687 * implementation of this method and if they don't override it, this
688 * method throws an exception if the subclass uses a
689 * {@code transferType} other than
690 * {@code DataBuffer.TYPE_BYTE},
691 * {@code DataBuffer.TYPE_USHORT}, or
692 * {@code DataBuffer.TYPE_INT}.
693 * @param inData an array of pixel values
694 * @return the value of the green component of the specified pixel.
695 * @throws ClassCastException if {@code inData}
696 * is not a primitive array of type {@code transferType}
697 * @throws ArrayIndexOutOfBoundsException if
698 * {@code inData} is not large enough to hold a pixel value
699 * for this {@code ColorModel}
700 * @throws UnsupportedOperationException if this
701 * {@code transferType} is not supported by this
702 * {@code ColorModel}
703 */
704 public int getGreen(Object inData) {
705 int pixel=0,length=0;
706 switch (transferType) {
707 case DataBuffer.TYPE_BYTE:
708 byte bdata[] = (byte[])inData;
709 pixel = bdata[0] & 0xff;
710 length = bdata.length;
711 break;
712 case DataBuffer.TYPE_USHORT:
713 short sdata[] = (short[])inData;
714 pixel = sdata[0] & 0xffff;
715 length = sdata.length;
716 break;
717 case DataBuffer.TYPE_INT:
718 int idata[] = (int[])inData;
719 pixel = idata[0];
720 length = idata.length;
721 break;
722 default:
723 throw new UnsupportedOperationException("This method has not been "+
724 "implemented for transferType " + transferType);
725 }
726 if (length == 1) {
727 return getGreen(pixel);
728 }
729 else {
730 throw new UnsupportedOperationException
731 ("This method is not supported by this color model");
732 }
733 }
734
735 /**
736 * Returns the blue color component for the specified pixel, scaled
737 * from 0 to 255 in the default RGB {@code ColorSpace}, sRGB. A
738 * color conversion is done if necessary. The pixel value is
739 * specified by an array of data elements of type transferType passed
740 * in as an object reference. The returned value is a non
741 * pre-multiplied value. For example, if the alpha is premultiplied,
742 * this method divides it out before returning the value. If the
743 * alpha value is 0, the blue value will be 0. If
744 * {@code inData} is not a primitive array of type transferType,
745 * a {@code ClassCastException} is thrown. An
746 * {@code ArrayIndexOutOfBoundsException} is
747 * thrown if {@code inData} is not large enough to hold a pixel
748 * value for this {@code ColorModel}.
749 * If this {@code transferType} is not supported, a
750 * {@code UnsupportedOperationException} will be
751 * thrown. Since
752 * {@code ColorModel} is an abstract class, any instance
753 * must be an instance of a subclass. Subclasses inherit the
754 * implementation of this method and if they don't override it, this
755 * method throws an exception if the subclass uses a
756 * {@code transferType} other than
757 * {@code DataBuffer.TYPE_BYTE},
758 * {@code DataBuffer.TYPE_USHORT}, or
759 * {@code DataBuffer.TYPE_INT}.
760 * @param inData an array of pixel values
761 * @return the value of the blue component of the specified pixel.
762 * @throws ClassCastException if {@code inData}
763 * is not a primitive array of type {@code transferType}
764 * @throws ArrayIndexOutOfBoundsException if
765 * {@code inData} is not large enough to hold a pixel value
766 * for this {@code ColorModel}
767 * @throws UnsupportedOperationException if this
768 * {@code transferType} is not supported by this
769 * {@code ColorModel}
770 */
771 public int getBlue(Object inData) {
772 int pixel=0,length=0;
773 switch (transferType) {
774 case DataBuffer.TYPE_BYTE:
775 byte bdata[] = (byte[])inData;
776 pixel = bdata[0] & 0xff;
777 length = bdata.length;
778 break;
779 case DataBuffer.TYPE_USHORT:
780 short sdata[] = (short[])inData;
781 pixel = sdata[0] & 0xffff;
782 length = sdata.length;
783 break;
784 case DataBuffer.TYPE_INT:
785 int idata[] = (int[])inData;
786 pixel = idata[0];
787 length = idata.length;
788 break;
789 default:
790 throw new UnsupportedOperationException("This method has not been "+
791 "implemented for transferType " + transferType);
792 }
793 if (length == 1) {
794 return getBlue(pixel);
795 }
796 else {
797 throw new UnsupportedOperationException
798 ("This method is not supported by this color model");
799 }
800 }
801
802 /**
803 * Returns the alpha component for the specified pixel, scaled
804 * from 0 to 255. The pixel value is specified by an array of data
805 * elements of type transferType passed in as an object reference.
806 * If inData is not a primitive array of type transferType, a
807 * {@code ClassCastException} is thrown. An
808 * {@code ArrayIndexOutOfBoundsException} is thrown if
809 * {@code inData} is not large enough to hold a pixel value for
810 * this {@code ColorModel}.
811 * If this {@code transferType} is not supported, a
812 * {@code UnsupportedOperationException} will be
813 * thrown. Since
814 * {@code ColorModel} is an abstract class, any instance
815 * must be an instance of a subclass. Subclasses inherit the
816 * implementation of this method and if they don't override it, this
817 * method throws an exception if the subclass uses a
818 * {@code transferType} other than
819 * {@code DataBuffer.TYPE_BYTE},
820 * {@code DataBuffer.TYPE_USHORT}, or
821 * {@code DataBuffer.TYPE_INT}.
822 * @param inData the specified pixel
823 * @return the alpha component of the specified pixel, scaled from
824 * 0 to 255.
825 * @throws ClassCastException if {@code inData}
826 * is not a primitive array of type {@code transferType}
827 * @throws ArrayIndexOutOfBoundsException if
828 * {@code inData} is not large enough to hold a pixel value
829 * for this {@code ColorModel}
830 * @throws UnsupportedOperationException if this
831 * {@code tranferType} is not supported by this
832 * {@code ColorModel}
833 */
834 public int getAlpha(Object inData) {
835 int pixel=0,length=0;
836 switch (transferType) {
837 case DataBuffer.TYPE_BYTE:
838 byte bdata[] = (byte[])inData;
839 pixel = bdata[0] & 0xff;
840 length = bdata.length;
841 break;
842 case DataBuffer.TYPE_USHORT:
843 short sdata[] = (short[])inData;
844 pixel = sdata[0] & 0xffff;
845 length = sdata.length;
846 break;
847 case DataBuffer.TYPE_INT:
848 int idata[] = (int[])inData;
849 pixel = idata[0];
850 length = idata.length;
851 break;
852 default:
853 throw new UnsupportedOperationException("This method has not been "+
854 "implemented for transferType " + transferType);
855 }
856 if (length == 1) {
857 return getAlpha(pixel);
858 }
859 else {
860 throw new UnsupportedOperationException
861 ("This method is not supported by this color model");
862 }
863 }
864
865 /**
866 * Returns the color/alpha components for the specified pixel in the
867 * default RGB color model format. A color conversion is done if
868 * necessary. The pixel value is specified by an array of data
869 * elements of type transferType passed in as an object reference.
870 * If inData is not a primitive array of type transferType, a
871 * {@code ClassCastException} is thrown. An
872 * {@code ArrayIndexOutOfBoundsException} is
873 * thrown if {@code inData} is not large enough to hold a pixel
874 * value for this {@code ColorModel}.
875 * The returned value will be in a non pre-multiplied format, i.e. if
876 * the alpha is premultiplied, this method will divide it out of the
877 * color components (if the alpha value is 0, the color values will be 0).
878 * @param inData the specified pixel
879 * @return the color and alpha components of the specified pixel.
880 * @see ColorModel#getRGBdefault
881 */
882 public int getRGB(Object inData) {
883 return (getAlpha(inData) << 24)
884 | (getRed(inData) << 16)
885 | (getGreen(inData) << 8)
886 | (getBlue(inData) << 0);
887 }
888
889 /**
890 * Returns a data element array representation of a pixel in this
891 * {@code ColorModel}, given an integer pixel representation in
892 * the default RGB color model.
893 * This array can then be passed to the
894 * {@link WritableRaster#setDataElements} method of
895 * a {@link WritableRaster} object. If the pixel variable is
896 * {@code null}, a new array will be allocated. If
897 * {@code pixel} is not
898 * {@code null}, it must be a primitive array of type
899 * {@code transferType}; otherwise, a
900 * {@code ClassCastException} is thrown. An
901 * {@code ArrayIndexOutOfBoundsException} is thrown if
902 * {@code pixel} is
903 * not large enough to hold a pixel value for this
904 * {@code ColorModel}. The pixel array is returned.
905 * If this {@code transferType} is not supported, a
906 * {@code UnsupportedOperationException} will be
907 * thrown. Since {@code ColorModel} is an abstract class,
908 * any instance is an instance of a subclass. Subclasses must
909 * override this method since the implementation in this abstract
910 * class throws an {@code UnsupportedOperationException}.
911 * @param rgb the integer pixel representation in the default RGB
912 * color model
913 * @param pixel the specified pixel
914 * @return an array representation of the specified pixel in this
915 * {@code ColorModel}.
916 * @throws ClassCastException if {@code pixel}
917 * is not a primitive array of type {@code transferType}
918 * @throws ArrayIndexOutOfBoundsException if
919 * {@code pixel} is not large enough to hold a pixel value
920 * for this {@code ColorModel}
921 * @throws UnsupportedOperationException if this
922 * method is not supported by this {@code ColorModel}
923 * @see WritableRaster#setDataElements
924 * @see SampleModel#setDataElements
925 */
926 public Object getDataElements(int rgb, Object pixel) {
927 throw new UnsupportedOperationException
928 ("This method is not supported by this color model.");
929 }
930
931 /**
932 * Returns an array of unnormalized color/alpha components given a pixel
933 * in this {@code ColorModel}. The pixel value is specified as
934 * an {@code int}. An {@code IllegalArgumentException}
935 * will be thrown if pixel values for this {@code ColorModel} are
936 * not conveniently representable as a single {@code int} or if
937 * color component values for this {@code ColorModel} are not
938 * conveniently representable in the unnormalized form.
939 * For example, this method can be used to retrieve the
940 * components for a specific pixel value in a
941 * {@code DirectColorModel}. If the components array is
942 * {@code null}, a new array will be allocated. The
943 * components array will be returned. Color/alpha components are
944 * stored in the components array starting at {@code offset}
945 * (even if the array is allocated by this method). An
946 * {@code ArrayIndexOutOfBoundsException} is thrown if the
947 * components array is not {@code null} and is not large
948 * enough to hold all the color and alpha components (starting at offset).
949 * Since {@code ColorModel} is an abstract class,
950 * any instance is an instance of a subclass. Subclasses must
951 * override this method since the implementation in this abstract
952 * class throws an {@code UnsupportedOperationException}.
953 * @param pixel the specified pixel
954 * @param components the array to receive the color and alpha
955 * components of the specified pixel
956 * @param offset the offset into the {@code components} array at
957 * which to start storing the color and alpha components
958 * @return an array containing the color and alpha components of the
959 * specified pixel starting at the specified offset.
960 * @throws UnsupportedOperationException if this
961 * method is not supported by this {@code ColorModel}
962 */
963 public int[] getComponents(int pixel, int[] components, int offset) {
964 throw new UnsupportedOperationException
965 ("This method is not supported by this color model.");
966 }
967
968 /**
969 * Returns an array of unnormalized color/alpha components given a pixel
970 * in this {@code ColorModel}. The pixel value is specified by
971 * an array of data elements of type transferType passed in as an
972 * object reference. If {@code pixel} is not a primitive array
973 * of type transferType, a {@code ClassCastException} is thrown.
974 * An {@code IllegalArgumentException} will be thrown if color
975 * component values for this {@code ColorModel} are not
976 * conveniently representable in the unnormalized form.
977 * An {@code ArrayIndexOutOfBoundsException} is
978 * thrown if {@code pixel} is not large enough to hold a pixel
979 * value for this {@code ColorModel}.
980 * This method can be used to retrieve the components for a specific
981 * pixel value in any {@code ColorModel}. If the components
982 * array is {@code null}, a new array will be allocated. The
983 * components array will be returned. Color/alpha components are
984 * stored in the {@code components} array starting at
985 * {@code offset} (even if the array is allocated by this
986 * method). An {@code ArrayIndexOutOfBoundsException}
987 * is thrown if the components array is not {@code null} and is
988 * not large enough to hold all the color and alpha components
989 * (starting at {@code offset}).
990 * Since {@code ColorModel} is an abstract class,
991 * any instance is an instance of a subclass. Subclasses must
992 * override this method since the implementation in this abstract
993 * class throws an {@code UnsupportedOperationException}.
994 * @param pixel the specified pixel
995 * @param components an array that receives the color and alpha
996 * components of the specified pixel
997 * @param offset the index into the {@code components} array at
998 * which to begin storing the color and alpha components of the
999 * specified pixel
1000 * @return an array containing the color and alpha components of the
1001 * specified pixel starting at the specified offset.
1002 * @throws UnsupportedOperationException if this
1003 * method is not supported by this {@code ColorModel}
1004 */
1005 public int[] getComponents(Object pixel, int[] components, int offset) {
1006 throw new UnsupportedOperationException
1007 ("This method is not supported by this color model.");
1008 }
1009
1010 /**
1011 * Returns an array of all of the color/alpha components in unnormalized
1012 * form, given a normalized component array. Unnormalized components
1013 * are unsigned integral values between 0 and 2<sup>n</sup> - 1, where
1014 * n is the number of bits for a particular component. Normalized
1015 * components are float values between a per component minimum and
1016 * maximum specified by the {@code ColorSpace} object for this
1017 * {@code ColorModel}. An {@code IllegalArgumentException}
1018 * will be thrown if color component values for this
1019 * {@code ColorModel} are not conveniently representable in the
1020 * unnormalized form. If the
1021 * {@code components} array is {@code null}, a new array
1022 * will be allocated. The {@code components} array will
1023 * be returned. Color/alpha components are stored in the
1024 * {@code components} array starting at {@code offset} (even
1025 * if the array is allocated by this method). An
1026 * {@code ArrayIndexOutOfBoundsException} is thrown if the
1027 * {@code components} array is not {@code null} and is not
1028 * large enough to hold all the color and alpha
1029 * components (starting at {@code offset}). An
1030 * {@code IllegalArgumentException} is thrown if the
1031 * {@code normComponents} array is not large enough to hold
1032 * all the color and alpha components starting at
1033 * {@code normOffset}.
1034 * @param normComponents an array containing normalized components
1035 * @param normOffset the offset into the {@code normComponents}
1036 * array at which to start retrieving normalized components
1037 * @param components an array that receives the components from
1038 * {@code normComponents}
1039 * @param offset the index into {@code components} at which to
1040 * begin storing normalized components from
1041 * {@code normComponents}
1042 * @return an array containing unnormalized color and alpha
1043 * components.
1044 * @throws IllegalArgumentException If the component values for this
1045 * {@code ColorModel} are not conveniently representable in the
1046 * unnormalized form.
1047 * @throws IllegalArgumentException if the length of
1048 * {@code normComponents} minus {@code normOffset}
1049 * is less than {@code numComponents}
1050 * @throws UnsupportedOperationException if the
1051 * constructor of this {@code ColorModel} called the
1052 * {@code super(bits)} constructor, but did not
1053 * override this method. See the constructor,
1054 * {@link #ColorModel(int)}.
1055 */
1056 public int[] getUnnormalizedComponents(float[] normComponents,
1057 int normOffset,
1058 int[] components, int offset) {
1059 // Make sure that someone isn't using a custom color model
1060 // that called the super(bits) constructor.
1061 if (colorSpace == null) {
1062 throw new UnsupportedOperationException("This method is not supported "+
1063 "by this color model.");
1064 }
1065
1066 if (nBits == null) {
1067 throw new UnsupportedOperationException ("This method is not supported. "+
1068 "Unable to determine #bits per "+
1069 "component.");
1070 }
1071 if ((normComponents.length - normOffset) < numComponents) {
1072 throw new
1073 IllegalArgumentException(
1074 "Incorrect number of components. Expecting "+
1075 numComponents);
1076 }
1077
1078 if (components == null) {
1079 components = new int[offset+numComponents];
1080 }
1081
1082 if (supportsAlpha && isAlphaPremultiplied) {
1083 float normAlpha = normComponents[normOffset+numColorComponents];
1084 for (int i=0; i < numColorComponents; i++) {
1085 components[offset+i] = (int) (normComponents[normOffset+i]
1086 * ((1<<nBits[i]) - 1)
1087 * normAlpha + 0.5f);
1088 }
1089 components[offset+numColorComponents] = (int)
1090 (normAlpha * ((1<<nBits[numColorComponents]) - 1) + 0.5f);
1091 }
1092 else {
1093 for (int i=0; i < numComponents; i++) {
1094 components[offset+i] = (int) (normComponents[normOffset+i]
1095 * ((1<<nBits[i]) - 1) + 0.5f);
1096 }
1097 }
1098
1099 return components;
1100 }
1101
1102 /**
1103 * Returns an array of all of the color/alpha components in normalized
1104 * form, given an unnormalized component array. Unnormalized components
1105 * are unsigned integral values between 0 and 2<sup>n</sup> - 1, where
1106 * n is the number of bits for a particular component. Normalized
1107 * components are float values between a per component minimum and
1108 * maximum specified by the {@code ColorSpace} object for this
1109 * {@code ColorModel}. An {@code IllegalArgumentException}
1110 * will be thrown if color component values for this
1111 * {@code ColorModel} are not conveniently representable in the
1112 * unnormalized form. If the
1113 * {@code normComponents} array is {@code null}, a new array
1114 * will be allocated. The {@code normComponents} array
1115 * will be returned. Color/alpha components are stored in the
1116 * {@code normComponents} array starting at
1117 * {@code normOffset} (even if the array is allocated by this
1118 * method). An {@code ArrayIndexOutOfBoundsException} is thrown
1119 * if the {@code normComponents} array is not {@code null}
1120 * and is not large enough to hold all the color and alpha components
1121 * (starting at {@code normOffset}). An
1122 * {@code IllegalArgumentException} is thrown if the
1123 * {@code components} array is not large enough to hold all the
1124 * color and alpha components starting at {@code offset}.
1125 * <p>
1126 * Since {@code ColorModel} is an abstract class,
1127 * any instance is an instance of a subclass. The default implementation
1128 * of this method in this abstract class assumes that component values
1129 * for this class are conveniently representable in the unnormalized
1130 * form. Therefore, subclasses which may
1131 * have instances which do not support the unnormalized form must
1132 * override this method.
1133 * @param components an array containing unnormalized components
1134 * @param offset the offset into the {@code components} array at
1135 * which to start retrieving unnormalized components
1136 * @param normComponents an array that receives the normalized components
1137 * @param normOffset the index into {@code normComponents} at
1138 * which to begin storing normalized components
1139 * @return an array containing normalized color and alpha
1140 * components.
1141 * @throws IllegalArgumentException If the component values for this
1142 * {@code ColorModel} are not conveniently representable in the
1143 * unnormalized form.
1144 * @throws UnsupportedOperationException if the
1145 * constructor of this {@code ColorModel} called the
1146 * {@code super(bits)} constructor, but did not
1147 * override this method. See the constructor,
1148 * {@link #ColorModel(int)}.
1149 * @throws UnsupportedOperationException if this method is unable
1150 * to determine the number of bits per component
1151 */
1152 public float[] getNormalizedComponents(int[] components, int offset,
1153 float[] normComponents,
1154 int normOffset) {
1155 // Make sure that someone isn't using a custom color model
1156 // that called the super(bits) constructor.
1157 if (colorSpace == null) {
1158 throw new UnsupportedOperationException("This method is not supported by "+
1159 "this color model.");
1160 }
1161 if (nBits == null) {
1162 throw new UnsupportedOperationException ("This method is not supported. "+
1163 "Unable to determine #bits per "+
1164 "component.");
1165 }
1166
1167 if ((components.length - offset) < numComponents) {
1168 throw new
1169 IllegalArgumentException(
1170 "Incorrect number of components. Expecting "+
1171 numComponents);
1172 }
1173
1174 if (normComponents == null) {
1175 normComponents = new float[numComponents+normOffset];
1176 }
1177
1178 if (supportsAlpha && isAlphaPremultiplied) {
1179 // Normalized coordinates are non premultiplied
1180 float normAlpha = (float)components[offset+numColorComponents];
1181 normAlpha /= (float) ((1<<nBits[numColorComponents]) - 1);
1182 if (normAlpha != 0.0f) {
1183 for (int i=0; i < numColorComponents; i++) {
1184 normComponents[normOffset+i] =
1185 ((float) components[offset+i]) /
1186 (normAlpha * ((float) ((1<<nBits[i]) - 1)));
1187 }
1188 } else {
1189 for (int i=0; i < numColorComponents; i++) {
1190 normComponents[normOffset+i] = 0.0f;
1191 }
1192 }
1193 normComponents[normOffset+numColorComponents] = normAlpha;
1194 }
1195 else {
1196 for (int i=0; i < numComponents; i++) {
1197 normComponents[normOffset+i] = ((float) components[offset+i]) /
1198 ((float) ((1<<nBits[i]) - 1));
1199 }
1200 }
1201
1202 return normComponents;
1203 }
1204
1205 /**
1206 * Returns a pixel value represented as an {@code int} in this
1207 * {@code ColorModel}, given an array of unnormalized color/alpha
1208 * components. This method will throw an
1209 * {@code IllegalArgumentException} if component values for this
1210 * {@code ColorModel} are not conveniently representable as a
1211 * single {@code int} or if color component values for this
1212 * {@code ColorModel} are not conveniently representable in the
1213 * unnormalized form. An
1214 * {@code ArrayIndexOutOfBoundsException} is thrown if the
1215 * {@code components} array is not large enough to hold all the
1216 * color and alpha components (starting at {@code offset}).
1217 * Since {@code ColorModel} is an abstract class,
1218 * any instance is an instance of a subclass. Subclasses must
1219 * override this method since the implementation in this abstract
1220 * class throws an {@code UnsupportedOperationException}.
1221 * @param components an array of unnormalized color and alpha
1222 * components
1223 * @param offset the index into {@code components} at which to
1224 * begin retrieving the color and alpha components
1225 * @return an {@code int} pixel value in this
1226 * {@code ColorModel} corresponding to the specified components.
1227 * @throws IllegalArgumentException if
1228 * pixel values for this {@code ColorModel} are not
1229 * conveniently representable as a single {@code int}
1230 * @throws IllegalArgumentException if
1231 * component values for this {@code ColorModel} are not
1232 * conveniently representable in the unnormalized form
1233 * @throws ArrayIndexOutOfBoundsException if
1234 * the {@code components} array is not large enough to
1235 * hold all of the color and alpha components starting at
1236 * {@code offset}
1237 * @throws UnsupportedOperationException if this
1238 * method is not supported by this {@code ColorModel}
1239 */
1240 public int getDataElement(int[] components, int offset) {
1241 throw new UnsupportedOperationException("This method is not supported "+
1242 "by this color model.");
1243 }
1244
1245 /**
1246 * Returns a data element array representation of a pixel in this
1247 * {@code ColorModel}, given an array of unnormalized color/alpha
1248 * components. This array can then be passed to the
1249 * {@code setDataElements} method of a {@code WritableRaster}
1250 * object. This method will throw an {@code IllegalArgumentException}
1251 * if color component values for this {@code ColorModel} are not
1252 * conveniently representable in the unnormalized form.
1253 * An {@code ArrayIndexOutOfBoundsException} is thrown
1254 * if the {@code components} array is not large enough to hold
1255 * all the color and alpha components (starting at
1256 * {@code offset}). If the {@code obj} variable is
1257 * {@code null}, a new array will be allocated. If
1258 * {@code obj} is not {@code null}, it must be a primitive
1259 * array of type transferType; otherwise, a
1260 * {@code ClassCastException} is thrown. An
1261 * {@code ArrayIndexOutOfBoundsException} is thrown if
1262 * {@code obj} is not large enough to hold a pixel value for this
1263 * {@code ColorModel}.
1264 * Since {@code ColorModel} is an abstract class,
1265 * any instance is an instance of a subclass. Subclasses must
1266 * override this method since the implementation in this abstract
1267 * class throws an {@code UnsupportedOperationException}.
1268 * @param components an array of unnormalized color and alpha
1269 * components
1270 * @param offset the index into {@code components} at which to
1271 * begin retrieving color and alpha components
1272 * @param obj the {@code Object} representing an array of color
1273 * and alpha components
1274 * @return an {@code Object} representing an array of color and
1275 * alpha components.
1276 * @throws ClassCastException if {@code obj}
1277 * is not a primitive array of type {@code transferType}
1278 * @throws ArrayIndexOutOfBoundsException if
1279 * {@code obj} is not large enough to hold a pixel value
1280 * for this {@code ColorModel} or the {@code components}
1281 * array is not large enough to hold all of the color and alpha
1282 * components starting at {@code offset}
1283 * @throws IllegalArgumentException if
1284 * component values for this {@code ColorModel} are not
1285 * conveniently representable in the unnormalized form
1286 * @throws UnsupportedOperationException if this
1287 * method is not supported by this {@code ColorModel}
1288 * @see WritableRaster#setDataElements
1289 * @see SampleModel#setDataElements
1290 */
1291 public Object getDataElements(int[] components, int offset, Object obj) {
1292 throw new UnsupportedOperationException("This method has not been implemented "+
1293 "for this color model.");
1294 }
1295
1296 /**
1297 * Returns a pixel value represented as an {@code int} in this
1298 * {@code ColorModel}, given an array of normalized color/alpha
1299 * components. This method will throw an
1300 * {@code IllegalArgumentException} if pixel values for this
1301 * {@code ColorModel} are not conveniently representable as a
1302 * single {@code int}. An
1303 * {@code ArrayIndexOutOfBoundsException} is thrown if the
1304 * {@code normComponents} array is not large enough to hold all the
1305 * color and alpha components (starting at {@code normOffset}).
1306 * Since {@code ColorModel} is an abstract class,
1307 * any instance is an instance of a subclass. The default implementation
1308 * of this method in this abstract class first converts from the
1309 * normalized form to the unnormalized form and then calls
1310 * {@code getDataElement(int[], int)}. Subclasses which may
1311 * have instances which do not support the unnormalized form must
1312 * override this method.
1313 * @param normComponents an array of normalized color and alpha
1314 * components
1315 * @param normOffset the index into {@code normComponents} at which to
1316 * begin retrieving the color and alpha components
1317 * @return an {@code int} pixel value in this
1318 * {@code ColorModel} corresponding to the specified components.
1319 * @throws IllegalArgumentException if
1320 * pixel values for this {@code ColorModel} are not
1321 * conveniently representable as a single {@code int}
1322 * @throws ArrayIndexOutOfBoundsException if
1323 * the {@code normComponents} array is not large enough to
1324 * hold all of the color and alpha components starting at
1325 * {@code normOffset}
1326 * @since 1.4
1327 */
1328 public int getDataElement(float[] normComponents, int normOffset) {
1329 int components[] = getUnnormalizedComponents(normComponents,
1330 normOffset, null, 0);
1331 return getDataElement(components, 0);
1332 }
1333
1334 /**
1335 * Returns a data element array representation of a pixel in this
1336 * {@code ColorModel}, given an array of normalized color/alpha
1337 * components. This array can then be passed to the
1338 * {@code setDataElements} method of a {@code WritableRaster}
1339 * object. An {@code ArrayIndexOutOfBoundsException} is thrown
1340 * if the {@code normComponents} array is not large enough to hold
1341 * all the color and alpha components (starting at
1342 * {@code normOffset}). If the {@code obj} variable is
1343 * {@code null}, a new array will be allocated. If
1344 * {@code obj} is not {@code null}, it must be a primitive
1345 * array of type transferType; otherwise, a
1346 * {@code ClassCastException} is thrown. An
1347 * {@code ArrayIndexOutOfBoundsException} is thrown if
1348 * {@code obj} is not large enough to hold a pixel value for this
1349 * {@code ColorModel}.
1350 * Since {@code ColorModel} is an abstract class,
1351 * any instance is an instance of a subclass. The default implementation
1352 * of this method in this abstract class first converts from the
1353 * normalized form to the unnormalized form and then calls
1354 * {@code getDataElement(int[], int, Object)}. Subclasses which may
1355 * have instances which do not support the unnormalized form must
1356 * override this method.
1357 * @param normComponents an array of normalized color and alpha
1358 * components
1359 * @param normOffset the index into {@code normComponents} at which to
1360 * begin retrieving color and alpha components
1361 * @param obj a primitive data array to hold the returned pixel
1362 * @return an {@code Object} which is a primitive data array
1363 * representation of a pixel
1364 * @throws ClassCastException if {@code obj}
1365 * is not a primitive array of type {@code transferType}
1366 * @throws ArrayIndexOutOfBoundsException if
1367 * {@code obj} is not large enough to hold a pixel value
1368 * for this {@code ColorModel} or the {@code normComponents}
1369 * array is not large enough to hold all of the color and alpha
1370 * components starting at {@code normOffset}
1371 * @see WritableRaster#setDataElements
1372 * @see SampleModel#setDataElements
1373 * @since 1.4
1374 */
1375 public Object getDataElements(float[] normComponents, int normOffset,
1376 Object obj) {
1377 int components[] = getUnnormalizedComponents(normComponents,
1378 normOffset, null, 0);
1379 return getDataElements(components, 0, obj);
1380 }
1381
1382 /**
1383 * Returns an array of all of the color/alpha components in normalized
1384 * form, given a pixel in this {@code ColorModel}. The pixel
1385 * value is specified by an array of data elements of type transferType
1386 * passed in as an object reference. If pixel is not a primitive array
1387 * of type transferType, a {@code ClassCastException} is thrown.
1388 * An {@code ArrayIndexOutOfBoundsException} is thrown if
1389 * {@code pixel} is not large enough to hold a pixel value for this
1390 * {@code ColorModel}.
1391 * Normalized components are float values between a per component minimum
1392 * and maximum specified by the {@code ColorSpace} object for this
1393 * {@code ColorModel}. If the
1394 * {@code normComponents} array is {@code null}, a new array
1395 * will be allocated. The {@code normComponents} array
1396 * will be returned. Color/alpha components are stored in the
1397 * {@code normComponents} array starting at
1398 * {@code normOffset} (even if the array is allocated by this
1399 * method). An {@code ArrayIndexOutOfBoundsException} is thrown
1400 * if the {@code normComponents} array is not {@code null}
1401 * and is not large enough to hold all the color and alpha components
1402 * (starting at {@code normOffset}).
1403 * Since {@code ColorModel} is an abstract class,
1404 * any instance is an instance of a subclass. The default implementation
1405 * of this method in this abstract class first retrieves color and alpha
1406 * components in the unnormalized form using
1407 * {@code getComponents(Object, int[], int)} and then calls
1408 * {@code getNormalizedComponents(int[], int, float[], int)}.
1409 * Subclasses which may
1410 * have instances which do not support the unnormalized form must
1411 * override this method.
1412 * @param pixel the specified pixel
1413 * @param normComponents an array to receive the normalized components
1414 * @param normOffset the offset into the {@code normComponents}
1415 * array at which to start storing normalized components
1416 * @return an array containing normalized color and alpha
1417 * components.
1418 * @throws ClassCastException if {@code pixel} is not a primitive
1419 * array of type transferType
1420 * @throws ArrayIndexOutOfBoundsException if
1421 * {@code normComponents} is not large enough to hold all
1422 * color and alpha components starting at {@code normOffset}
1423 * @throws ArrayIndexOutOfBoundsException if
1424 * {@code pixel} is not large enough to hold a pixel
1425 * value for this {@code ColorModel}.
1426 * @throws UnsupportedOperationException if the
1427 * constructor of this {@code ColorModel} called the
1428 * {@code super(bits)} constructor, but did not
1429 * override this method. See the constructor,
1430 * {@link #ColorModel(int)}.
1431 * @throws UnsupportedOperationException if this method is unable
1432 * to determine the number of bits per component
1433 * @since 1.4
1434 */
1435 public float[] getNormalizedComponents(Object pixel,
1436 float[] normComponents,
1437 int normOffset) {
1438 int components[] = getComponents(pixel, null, 0);
1439 return getNormalizedComponents(components, 0,
1440 normComponents, normOffset);
1441 }
1442
1443 /**
1444 * Tests if the specified {@code Object} is an instance of
1445 * {@code ColorModel} and if it equals this
1446 * {@code ColorModel}.
1447 * @param obj the {@code Object} to test for equality
1448 * @return {@code true} if the specified {@code Object}
1449 * is an instance of {@code ColorModel} and equals this
1450 * {@code ColorModel}; {@code false} otherwise.
1451 */
1452 @Override
1453 public boolean equals(Object obj) {
1454 if ((obj == null) || (obj.getClass() != getClass())) {
1455 return false;
1456 }
1457 ColorModel cm = (ColorModel) obj;
1458
1459 if (this == cm) {
1460 return true;
1461 }
1462 if (supportsAlpha != cm.hasAlpha() ||
1463 isAlphaPremultiplied != cm.isAlphaPremultiplied() ||
1464 pixel_bits != cm.getPixelSize() ||
1465 transparency != cm.getTransparency() ||
1466 numComponents != cm.getNumComponents())
1467 {
1468 return false;
1469 }
1470
1471 int[] nb = cm.getComponentSize();
1472
1473 if ((nBits != null) && (nb != null)) {
1474 for (int i = 0; i < numComponents; i++) {
1475 if (nBits[i] != nb[i]) {
1476 return false;
1477 }
1478 }
1479 } else {
1480 return ((nBits == null) && (nb == null));
1481 }
1482
1483 return true;
1484 }
1485
1486 /**
1487 * Returns the hash code for this ColorModel.
1488 *
1489 * @return a hash code for this ColorModel.
1490 */
1491 @Override
1492 public int hashCode() {
1493 int hash = 7;
1494 hash = 89 * hash + this.pixel_bits;
1495 hash = 89 * hash + Arrays.hashCode(this.nBits);
1496 hash = 89 * hash + this.transparency;
1497 hash = 89 * hash + (this.supportsAlpha ? 1 : 0);
1498 hash = 89 * hash + (this.isAlphaPremultiplied ? 1 : 0);
1499 hash = 89 * hash + this.numComponents;
1500 return hash;
1501 }
1502
1503 /**
1504 * Returns the {@code ColorSpace} associated with this
1505 * {@code ColorModel}.
1506 * @return the {@code ColorSpace} of this
1507 * {@code ColorModel}.
1508 */
1509 public final ColorSpace getColorSpace() {
1510 return colorSpace;
1511 }
1512
1513 /**
1514 * Forces the raster data to match the state specified in the
1515 * {@code isAlphaPremultiplied} variable, assuming the data is
1516 * currently correctly described by this {@code ColorModel}. It
1517 * may multiply or divide the color raster data by alpha, or do
1518 * nothing if the data is in the correct state. If the data needs to
1519 * be coerced, this method will also return an instance of this
1520 * {@code ColorModel} with the {@code isAlphaPremultiplied}
1521 * flag set appropriately. This method will throw a
1522 * {@code UnsupportedOperationException} if it is not supported
1523 * by this {@code ColorModel}.
1524 * Since {@code ColorModel} is an abstract class,
1525 * any instance is an instance of a subclass. Subclasses must
1526 * override this method since the implementation in this abstract
1527 * class throws an {@code UnsupportedOperationException}.
1528 * @param raster the {@code WritableRaster} data
1529 * @param isAlphaPremultiplied {@code true} if the alpha is
1530 * premultiplied; {@code false} otherwise
1531 * @return a {@code ColorModel} object that represents the
1532 * coerced data.
1533 */
1534 public ColorModel coerceData (WritableRaster raster,
1535 boolean isAlphaPremultiplied) {
1536 throw new UnsupportedOperationException
1537 ("This method is not supported by this color model");
1538 }
1539
1540 /**
1541 * Returns {@code true} if {@code raster} is compatible
1542 * with this {@code ColorModel} and {@code false} if it is
1543 * not.
1544 * Since {@code ColorModel} is an abstract class,
1545 * any instance is an instance of a subclass. Subclasses must
1546 * override this method since the implementation in this abstract
1547 * class throws an {@code UnsupportedOperationException}.
1548 * @param raster the {@link Raster} object to test for compatibility
1549 * @return {@code true} if {@code raster} is compatible
1550 * with this {@code ColorModel}.
1551 * @throws UnsupportedOperationException if this
1552 * method has not been implemented for this
1553 * {@code ColorModel}
1554 */
1555 public boolean isCompatibleRaster(Raster raster) {
1556 throw new UnsupportedOperationException(
1557 "This method has not been implemented for this ColorModel.");
1558 }
1559
1560 /**
1561 * Creates a {@code WritableRaster} with the specified width and
1562 * height that has a data layout ({@code SampleModel}) compatible
1563 * with this {@code ColorModel}.
1564 * Since {@code ColorModel} is an abstract class,
1565 * any instance is an instance of a subclass. Subclasses must
1566 * override this method since the implementation in this abstract
1567 * class throws an {@code UnsupportedOperationException}.
1568 * @param w the width to apply to the new {@code WritableRaster}
1569 * @param h the height to apply to the new {@code WritableRaster}
1570 * @return a {@code WritableRaster} object with the specified
1571 * width and height.
1572 * @throws UnsupportedOperationException if this
1573 * method is not supported by this {@code ColorModel}
1574 * @see WritableRaster
1575 * @see SampleModel
1576 */
1577 public WritableRaster createCompatibleWritableRaster(int w, int h) {
1578 throw new UnsupportedOperationException
1579 ("This method is not supported by this color model");
1580 }
1581
1582 /**
1583 * Creates a {@code SampleModel} with the specified width and
1584 * height that has a data layout compatible with this
1585 * {@code ColorModel}.
1586 * Since {@code ColorModel} is an abstract class,
1587 * any instance is an instance of a subclass. Subclasses must
1588 * override this method since the implementation in this abstract
1589 * class throws an {@code UnsupportedOperationException}.
1590 * @param w the width to apply to the new {@code SampleModel}
1591 * @param h the height to apply to the new {@code SampleModel}
1592 * @return a {@code SampleModel} object with the specified
1593 * width and height.
1594 * @throws UnsupportedOperationException if this
1595 * method is not supported by this {@code ColorModel}
1596 * @see SampleModel
1597 */
1598 public SampleModel createCompatibleSampleModel(int w, int h) {
1599 throw new UnsupportedOperationException
1600 ("This method is not supported by this color model");
1601 }
1602
1603 /** Checks if the {@code SampleModel} is compatible with this
1604 * {@code ColorModel}.
1605 * Since {@code ColorModel} is an abstract class,
1606 * any instance is an instance of a subclass. Subclasses must
1607 * override this method since the implementation in this abstract
1608 * class throws an {@code UnsupportedOperationException}.
1609 * @param sm the specified {@code SampleModel}
1610 * @return {@code true} if the specified {@code SampleModel}
1611 * is compatible with this {@code ColorModel}; {@code false}
1612 * otherwise.
1613 * @throws UnsupportedOperationException if this
1614 * method is not supported by this {@code ColorModel}
1615 * @see SampleModel
1616 */
1617 public boolean isCompatibleSampleModel(SampleModel sm) {
1618 throw new UnsupportedOperationException
1619 ("This method is not supported by this color model");
1620 }
1621
1622 /**
1623 * Disposes of system resources associated with this
1624 * {@code ColorModel} once this {@code ColorModel} is no
1625 * longer referenced.
1626 */
1627 public void finalize() {
1628 }
1629
1630
1631 /**
1632 * Returns a {@code Raster} representing the alpha channel of an
1633 * image, extracted from the input {@code Raster}, provided that
1634 * pixel values of this {@code ColorModel} represent color and
1635 * alpha information as separate spatial bands (e.g.
1636 * {@link ComponentColorModel} and {@code DirectColorModel}).
1637 * This method assumes that {@code Raster} objects associated
1638 * with such a {@code ColorModel} store the alpha band, if
1639 * present, as the last band of image data. Returns {@code null}
1640 * if there is no separate spatial alpha channel associated with this
1641 * {@code ColorModel}. If this is an
1642 * {@code IndexColorModel} which has alpha in the lookup table,
1643 * this method will return {@code null} since
1644 * there is no spatially discrete alpha channel.
1645 * This method will create a new {@code Raster} (but will share
1646 * the data array).
1647 * Since {@code ColorModel} is an abstract class, any instance
1648 * is an instance of a subclass. Subclasses must override this
1649 * method to get any behavior other than returning {@code null}
1650 * because the implementation in this abstract class returns
1651 * {@code null}.
1652 * @param raster the specified {@code Raster}
1653 * @return a {@code Raster} representing the alpha channel of
1654 * an image, obtained from the specified {@code Raster}.
1655 */
1656 public WritableRaster getAlphaRaster(WritableRaster raster) {
1657 return null;
1658 }
1659
1660 /**
1661 * Returns the {@code String} representation of the contents of
1662 * this {@code ColorModel} object.
1663 * @return a {@code String} representing the contents of this
1664 * {@code ColorModel} object.
1665 */
1666 public String toString() {
1667 return new String("ColorModel: #pixelBits = "+pixel_bits
1668 + " numComponents = "+numComponents
1669 + " color space = "+colorSpace
1670 + " transparency = "+transparency
1671 + " has alpha = "+supportsAlpha
1672 + " isAlphaPre = "+isAlphaPremultiplied
1673 );
1674 }
1675
1676 static int getDefaultTransferType(int pixel_bits) {
1677 if (pixel_bits <= 8) {
1678 return DataBuffer.TYPE_BYTE;
1679 } else if (pixel_bits <= 16) {
1680 return DataBuffer.TYPE_USHORT;
1681 } else if (pixel_bits <= 32) {
1682 return DataBuffer.TYPE_INT;
1683 } else {
1684 return DataBuffer.TYPE_UNDEFINED;
1685 }
1686 }
1687
1688 static byte[] l8Tos8 = null; // 8-bit linear to 8-bit non-linear sRGB LUT
1689 static byte[] s8Tol8 = null; // 8-bit non-linear sRGB to 8-bit linear LUT
1690 static byte[] l16Tos8 = null; // 16-bit linear to 8-bit non-linear sRGB LUT
1691 static short[] s8Tol16 = null; // 8-bit non-linear sRGB to 16-bit linear LUT
1692
1693 // Maps to hold LUTs for grayscale conversions
1694 static Map<ICC_ColorSpace, byte[]> g8Tos8Map = null; // 8-bit gray values to 8-bit sRGB values
1695 static Map<ICC_ColorSpace, byte[]> lg16Toog8Map = null; // 16-bit linear to 8-bit "other" gray
1696 static Map<ICC_ColorSpace, byte[]> g16Tos8Map = null; // 16-bit gray values to 8-bit sRGB values
1697 static Map<ICC_ColorSpace, short[]> lg16Toog16Map = null; // 16-bit linear to 16-bit "other" gray
1698
1699 static boolean isLinearRGBspace(ColorSpace cs) {
1700 // Note: CMM.LINEAR_RGBspace will be null if the linear
1701 // RGB space has not been created yet.
1702 return (cs == CMSManager.LINEAR_RGBspace);
1703 }
1704
1705 static boolean isLinearGRAYspace(ColorSpace cs) {
1706 // Note: CMM.GRAYspace will be null if the linear
1707 // gray space has not been created yet.
1708 return (cs == CMSManager.GRAYspace);
1709 }
1710
1711 static byte[] getLinearRGB8TosRGB8LUT() {
1712 if (l8Tos8 == null) {
1713 l8Tos8 = new byte[256];
1714 float input, output;
1715 // algorithm for linear RGB to nonlinear sRGB conversion
1716 // is from the IEC 61966-2-1 International Standard,
1717 // Colour Management - Default RGB colour space - sRGB,
1718 // First Edition, 1999-10,
1719 // available for order at http://www.iec.ch
1720 for (int i = 0; i <= 255; i++) {
1721 input = ((float) i) / 255.0f;
1722 if (input <= 0.0031308f) {
1723 output = input * 12.92f;
1724 } else {
1725 output = 1.055f * ((float) Math.pow(input, (1.0 / 2.4)))
1726 - 0.055f;
1727 }
1728 l8Tos8[i] = (byte) Math.round(output * 255.0f);
1729 }
1730 }
1731 return l8Tos8;
1732 }
1733
1734 static byte[] getsRGB8ToLinearRGB8LUT() {
1735 if (s8Tol8 == null) {
1736 s8Tol8 = new byte[256];
1737 float input, output;
1738 // algorithm from IEC 61966-2-1 International Standard
1739 for (int i = 0; i <= 255; i++) {
1740 input = ((float) i) / 255.0f;
1741 if (input <= 0.04045f) {
1742 output = input / 12.92f;
1743 } else {
1744 output = (float) Math.pow((input + 0.055f) / 1.055f, 2.4);
1745 }
1746 s8Tol8[i] = (byte) Math.round(output * 255.0f);
1747 }
1748 }
1749 return s8Tol8;
1750 }
1751
1752 static byte[] getLinearRGB16TosRGB8LUT() {
1753 if (l16Tos8 == null) {
1754 l16Tos8 = new byte[65536];
1755 float input, output;
1756 // algorithm from IEC 61966-2-1 International Standard
1757 for (int i = 0; i <= 65535; i++) {
1758 input = ((float) i) / 65535.0f;
1759 if (input <= 0.0031308f) {
1760 output = input * 12.92f;
1761 } else {
1762 output = 1.055f * ((float) Math.pow(input, (1.0 / 2.4)))
1763 - 0.055f;
1764 }
1765 l16Tos8[i] = (byte) Math.round(output * 255.0f);
1766 }
1767 }
1768 return l16Tos8;
1769 }
1770
1771 static short[] getsRGB8ToLinearRGB16LUT() {
1772 if (s8Tol16 == null) {
1773 s8Tol16 = new short[256];
1774 float input, output;
1775 // algorithm from IEC 61966-2-1 International Standard
1776 for (int i = 0; i <= 255; i++) {
1777 input = ((float) i) / 255.0f;
1778 if (input <= 0.04045f) {
1779 output = input / 12.92f;
1780 } else {
1781 output = (float) Math.pow((input + 0.055f) / 1.055f, 2.4);
1782 }
1783 s8Tol16[i] = (short) Math.round(output * 65535.0f);
1784 }
1785 }
1786 return s8Tol16;
1787 }
1788
1789 /*
1790 * Return a byte LUT that converts 8-bit gray values in the grayCS
1791 * ColorSpace to the appropriate 8-bit sRGB value. I.e., if lut
1792 * is the byte array returned by this method and sval = lut[gval],
1793 * then the sRGB triple (sval,sval,sval) is the best match to gval.
1794 * Cache references to any computed LUT in a Map.
1795 */
1796 static byte[] getGray8TosRGB8LUT(ICC_ColorSpace grayCS) {
1797 if (isLinearGRAYspace(grayCS)) {
1798 return getLinearRGB8TosRGB8LUT();
1799 }
1800 if (g8Tos8Map != null) {
1801 byte[] g8Tos8LUT = g8Tos8Map.get(grayCS);
1802 if (g8Tos8LUT != null) {
1803 return g8Tos8LUT;
1804 }
1805 }
1806 byte[] g8Tos8LUT = new byte[256];
1807 for (int i = 0; i <= 255; i++) {
1808 g8Tos8LUT[i] = (byte) i;
1809 }
1810 ColorTransform[] transformList = new ColorTransform[2];
1811 PCMM mdl = CMSManager.getModule();
1812 ICC_ColorSpace srgbCS =
1813 (ICC_ColorSpace) ColorSpace.getInstance(ColorSpace.CS_sRGB);
1814 transformList[0] = mdl.createTransform(
1815 grayCS.getProfile(), ColorTransform.Any, ColorTransform.In);
1816 transformList[1] = mdl.createTransform(
1817 srgbCS.getProfile(), ColorTransform.Any, ColorTransform.Out);
1818 ColorTransform t = mdl.createTransform(transformList);
1819 byte[] tmp = t.colorConvert(g8Tos8LUT, null);
1820 for (int i = 0, j= 2; i <= 255; i++, j += 3) {
1821 // All three components of tmp should be equal, since
1822 // the input color space to colorConvert is a gray scale
1823 // space. However, there are slight anomalies in the results.
1824 // Copy tmp starting at index 2, since colorConvert seems
1825 // to be slightly more accurate for the third component!
1826 g8Tos8LUT[i] = tmp[j];
1827 }
1828 if (g8Tos8Map == null) {
1829 g8Tos8Map = Collections.synchronizedMap(new WeakHashMap<ICC_ColorSpace, byte[]>(2));
1830 }
1831 g8Tos8Map.put(grayCS, g8Tos8LUT);
1832 return g8Tos8LUT;
1833 }
1834
1835 /*
1836 * Return a byte LUT that converts 16-bit gray values in the CS_GRAY
1837 * linear gray ColorSpace to the appropriate 8-bit value in the
1838 * grayCS ColorSpace. Cache references to any computed LUT in a Map.
1839 */
1840 static byte[] getLinearGray16ToOtherGray8LUT(ICC_ColorSpace grayCS) {
1841 if (lg16Toog8Map != null) {
1842 byte[] lg16Toog8LUT = lg16Toog8Map.get(grayCS);
1843 if (lg16Toog8LUT != null) {
1844 return lg16Toog8LUT;
1845 }
1846 }
1847 short[] tmp = new short[65536];
1848 for (int i = 0; i <= 65535; i++) {
1849 tmp[i] = (short) i;
1850 }
1851 ColorTransform[] transformList = new ColorTransform[2];
1852 PCMM mdl = CMSManager.getModule();
1853 ICC_ColorSpace lgCS =
1854 (ICC_ColorSpace) ColorSpace.getInstance(ColorSpace.CS_GRAY);
1855 transformList[0] = mdl.createTransform (
1856 lgCS.getProfile(), ColorTransform.Any, ColorTransform.In);
1857 transformList[1] = mdl.createTransform (
1858 grayCS.getProfile(), ColorTransform.Any, ColorTransform.Out);
1859 ColorTransform t = mdl.createTransform(transformList);
1860 tmp = t.colorConvert(tmp, null);
1861 byte[] lg16Toog8LUT = new byte[65536];
1862 for (int i = 0; i <= 65535; i++) {
1863 // scale unsigned short (0 - 65535) to unsigned byte (0 - 255)
1864 lg16Toog8LUT[i] =
1865 (byte) (((float) (tmp[i] & 0xffff)) * (1.0f /257.0f) + 0.5f);
1866 }
1867 if (lg16Toog8Map == null) {
1868 lg16Toog8Map = Collections.synchronizedMap(new WeakHashMap<ICC_ColorSpace, byte[]>(2));
1869 }
1870 lg16Toog8Map.put(grayCS, lg16Toog8LUT);
1871 return lg16Toog8LUT;
1872 }
1873
1874 /*
1875 * Return a byte LUT that converts 16-bit gray values in the grayCS
1876 * ColorSpace to the appropriate 8-bit sRGB value. I.e., if lut
1877 * is the byte array returned by this method and sval = lut[gval],
1878 * then the sRGB triple (sval,sval,sval) is the best match to gval.
1879 * Cache references to any computed LUT in a Map.
1880 */
1881 static byte[] getGray16TosRGB8LUT(ICC_ColorSpace grayCS) {
1882 if (isLinearGRAYspace(grayCS)) {
1883 return getLinearRGB16TosRGB8LUT();
1884 }
1885 if (g16Tos8Map != null) {
1886 byte[] g16Tos8LUT = g16Tos8Map.get(grayCS);
1887 if (g16Tos8LUT != null) {
1888 return g16Tos8LUT;
1889 }
1890 }
1891 short[] tmp = new short[65536];
1892 for (int i = 0; i <= 65535; i++) {
1893 tmp[i] = (short) i;
1894 }
1895 ColorTransform[] transformList = new ColorTransform[2];
1896 PCMM mdl = CMSManager.getModule();
1897 ICC_ColorSpace srgbCS =
1898 (ICC_ColorSpace) ColorSpace.getInstance(ColorSpace.CS_sRGB);
1899 transformList[0] = mdl.createTransform (
1900 grayCS.getProfile(), ColorTransform.Any, ColorTransform.In);
1901 transformList[1] = mdl.createTransform (
1902 srgbCS.getProfile(), ColorTransform.Any, ColorTransform.Out);
1903 ColorTransform t = mdl.createTransform(transformList);
1904 tmp = t.colorConvert(tmp, null);
1905 byte[] g16Tos8LUT = new byte[65536];
1906 for (int i = 0, j= 2; i <= 65535; i++, j += 3) {
1907 // All three components of tmp should be equal, since
1908 // the input color space to colorConvert is a gray scale
1909 // space. However, there are slight anomalies in the results.
1910 // Copy tmp starting at index 2, since colorConvert seems
1911 // to be slightly more accurate for the third component!
1912
1913 // scale unsigned short (0 - 65535) to unsigned byte (0 - 255)
1914 g16Tos8LUT[i] =
1915 (byte) (((float) (tmp[j] & 0xffff)) * (1.0f /257.0f) + 0.5f);
1916 }
1917 if (g16Tos8Map == null) {
1918 g16Tos8Map = Collections.synchronizedMap(new WeakHashMap<ICC_ColorSpace, byte[]>(2));
1919 }
1920 g16Tos8Map.put(grayCS, g16Tos8LUT);
1921 return g16Tos8LUT;
1922 }
1923
1924 /*
1925 * Return a short LUT that converts 16-bit gray values in the CS_GRAY
1926 * linear gray ColorSpace to the appropriate 16-bit value in the
1927 * grayCS ColorSpace. Cache references to any computed LUT in a Map.
1928 */
1929 static short[] getLinearGray16ToOtherGray16LUT(ICC_ColorSpace grayCS) {
1930 if (lg16Toog16Map != null) {
1931 short[] lg16Toog16LUT = lg16Toog16Map.get(grayCS);
1932 if (lg16Toog16LUT != null) {
1933 return lg16Toog16LUT;
1934 }
1935 }
1936 short[] tmp = new short[65536];
1937 for (int i = 0; i <= 65535; i++) {
1938 tmp[i] = (short) i;
1939 }
1940 ColorTransform[] transformList = new ColorTransform[2];
1941 PCMM mdl = CMSManager.getModule();
1942 ICC_ColorSpace lgCS =
1943 (ICC_ColorSpace) ColorSpace.getInstance(ColorSpace.CS_GRAY);
1944 transformList[0] = mdl.createTransform (
1945 lgCS.getProfile(), ColorTransform.Any, ColorTransform.In);
1946 transformList[1] = mdl.createTransform(
1947 grayCS.getProfile(), ColorTransform.Any, ColorTransform.Out);
1948 ColorTransform t = mdl.createTransform(
1949 transformList);
1950 short[] lg16Toog16LUT = t.colorConvert(tmp, null);
1951 if (lg16Toog16Map == null) {
1952 lg16Toog16Map = Collections.synchronizedMap(new WeakHashMap<ICC_ColorSpace, short[]>(2));
1953 }
1954 lg16Toog16Map.put(grayCS, lg16Toog16LUT);
1955 return lg16Toog16LUT;
1956 }
1957
1958 }