< prev index next >
src/java.desktop/share/classes/java/awt/color/ColorSpace.java
Print this page
*** 1,7 ****
/*
! * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
--- 1,7 ----
/*
! * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
*** 21,32 ****
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
! /*
! **********************************************************************
**********************************************************************
**********************************************************************
*** COPYRIGHT (c) Eastman Kodak Company, 1997 ***
*** As an unpublished work pursuant to Title 17 of the United ***
*** States Code. All rights reserved. ***
--- 21,31 ----
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
! /* ********************************************************************
**********************************************************************
**********************************************************************
*** COPYRIGHT (c) Eastman Kodak Company, 1997 ***
*** As an unpublished work pursuant to Title 17 of the United ***
*** States Code. All rights reserved. ***
*** 36,102 ****
package java.awt.color;
import java.lang.annotation.Native;
- import sun.java2d.cmm.PCMM;
import sun.java2d.cmm.CMSManager;
-
/**
* This abstract class is used to serve as a color space tag to identify the
! * specific color space of a Color object or, via a ColorModel object,
! * of an Image, a BufferedImage, or a GraphicsDevice. It contains
! * methods that transform colors in a specific color space to/from sRGB
! * and to/from a well-defined CIEXYZ color space.
* <p>
! * For purposes of the methods in this class, colors are represented as
! * arrays of color components represented as floats in a normalized range
! * defined by each ColorSpace. For many ColorSpaces (e.g. sRGB), this
! * range is 0.0 to 1.0. However, some ColorSpaces have components whose
! * values have a different range. Methods are provided to inquire per
! * component minimum and maximum normalized values.
* <p>
! * Several variables are defined for purposes of referring to color
! * space types (e.g. TYPE_RGB, TYPE_XYZ, etc.) and to refer to specific
! * color spaces (e.g. CS_sRGB and CS_CIEXYZ).
! * sRGB is a proposed standard RGB color space. For more information,
! * see <A href="http://www.w3.org/pub/WWW/Graphics/Color/sRGB.html">
! * http://www.w3.org/pub/WWW/Graphics/Color/sRGB.html
! * </A>.
* <p>
! * The purpose of the methods to transform to/from the well-defined
! * CIEXYZ color space is to support conversions between any two color
! * spaces at a reasonably high degree of accuracy. It is expected that
! * particular implementations of subclasses of ColorSpace (e.g.
! * ICC_ColorSpace) will support high performance conversion based on
! * underlying platform color management systems.
* <p>
! * The CS_CIEXYZ space used by the toCIEXYZ/fromCIEXYZ methods can be
! * described as follows:
! <pre>
!
! CIEXYZ
! viewing illuminance: 200 lux
! viewing white point: CIE D50
! media white point: "that of a perfectly reflecting diffuser" -- D50
! media black point: 0 lux or 0 Reflectance
! flare: 1 percent
! surround: 20percent of the media white point
! media description: reflection print (i.e., RLAB, Hunt viewing media)
! note: For developers creating an ICC profile for this conversion
! space, the following is applicable. Use a simple Von Kries
! white point adaptation folded into the 3X3 matrix parameters
! and fold the flare and surround effects into the three
! one-dimensional lookup tables (assuming one uses the minimal
! model for monitors).
!
! </pre>
*
* @see ICC_ColorSpace
*/
-
public abstract class ColorSpace implements java.io.Serializable {
static final long serialVersionUID = -409452704308689724L;
private int type;
--- 35,98 ----
package java.awt.color;
import java.lang.annotation.Native;
import sun.java2d.cmm.CMSManager;
/**
* This abstract class is used to serve as a color space tag to identify the
! * specific color space of a {@code Color} object or, via a {@code ColorModel}
! * object, of an {@code Image}, a {@code BufferedImage}, or a
! * {@code GraphicsDevice}. It contains methods that transform colors in a
! * specific color space to/from sRGB and to/from a well-defined CIEXYZ color
! * space.
* <p>
! * For purposes of the methods in this class, colors are represented as arrays
! * of color components represented as floats in a normalized range defined by
! * each {@code ColorSpace}. For many {@code ColorSpaces} (e.g. sRGB), this range
! * is 0.0 to 1.0. However, some {@code ColorSpaces} have components whose values
! * have a different range. Methods are provided to inquire per component minimum
! * and maximum normalized values.
* <p>
! * Several variables are defined for purposes of referring to color space types
! * (e.g. {@code TYPE_RGB}, {@code TYPE_XYZ}, etc.) and to refer to specific
! * color spaces (e.g. {@code CS_sRGB} and {@code CS_CIEXYZ}). sRGB is a proposed
! * standard RGB color space. For more information, see
! * <a href="http://www.w3.org/pub/WWW/Graphics/Color/sRGB.html">
! * http://www.w3.org/pub/WWW/Graphics/Color/sRGB.html</a>.
* <p>
! * The purpose of the methods to transform to/from the well-defined CIEXYZ color
! * space is to support conversions between any two color spaces at a reasonably
! * high degree of accuracy. It is expected that particular implementations of
! * subclasses of {@code ColorSpace} (e.g. {@code ICC_ColorSpace}) will support
! * high performance conversion based on underlying platform color management
! * systems.
* <p>
! * The {@code CS_CIEXYZ} space used by the {@code toCIEXYZ/fromCIEXYZ} methods
! * can be described as follows:
! * <pre>
! *
! * CIEXYZ
! * viewing illuminance: 200 lux
! * viewing white point: CIE D50
! * media white point: "that of a perfectly reflecting diffuser" -- D50
! * media black point: 0 lux or 0 Reflectance
! * flare: 1 percent
! * surround: 20percent of the media white point
! * media description: reflection print (i.e., RLAB, Hunt viewing media)
! * note: For developers creating an ICC profile for this conversion
! * space, the following is applicable. Use a simple Von Kries
! * white point adaptation folded into the 3X3 matrix parameters
! * and fold the flare and surround effects into the three
! * one-dimensional lookup tables (assuming one uses the minimal
! * model for monitors).
! *
! * </pre>
*
* @see ICC_ColorSpace
*/
public abstract class ColorSpace implements java.io.Serializable {
static final long serialVersionUID = -409452704308689724L;
private int type;
*** 235,253 ****
*/
@Native public static final int TYPE_FCLR = 25;
/**
* The sRGB color space defined at
! * <A href="http://www.w3.org/pub/WWW/Graphics/Color/sRGB.html">
! * http://www.w3.org/pub/WWW/Graphics/Color/sRGB.html
! * </A>.
*/
@Native public static final int CS_sRGB = 1000;
/**
! * A built-in linear RGB color space. This space is based on the
! * same RGB primaries as CS_sRGB, but has a linear tone reproduction curve.
*/
@Native public static final int CS_LINEAR_RGB = 1004;
/**
* The CIEXYZ conversion color space defined above.
--- 231,248 ----
*/
@Native public static final int TYPE_FCLR = 25;
/**
* The sRGB color space defined at
! * <a href="http://www.w3.org/pub/WWW/Graphics/Color/sRGB.html">
! * http://www.w3.org/pub/WWW/Graphics/Color/sRGB.html</a>.
*/
@Native public static final int CS_sRGB = 1000;
/**
! * A built-in linear RGB color space. This space is based on the same RGB
! * primaries as {@code CS_sRGB}, but has a linear tone reproduction curve.
*/
@Native public static final int CS_LINEAR_RGB = 1004;
/**
* The CIEXYZ conversion color space defined above.
*** 262,290 ****
/**
* The built-in linear gray scale color space.
*/
@Native public static final int CS_GRAY = 1003;
-
/**
! * Constructs a ColorSpace object given a color space type
! * and the number of components.
* @param type one of the {@code ColorSpace} type constants
* @param numcomponents the number of components in the color space
*/
! protected ColorSpace (int type, int numcomponents) {
this.type = type;
this.numComponents = numcomponents;
}
-
/**
! * Returns a ColorSpace representing one of the specific
! * predefined color spaces.
! * @param colorspace a specific color space identified by one of
! * the predefined class constants (e.g. CS_sRGB, CS_LINEAR_RGB,
! * CS_CIEXYZ, CS_GRAY, or CS_PYCC)
* @return the requested {@code ColorSpace} object
*/
// NOTE: This method may be called by privileged threads.
// DO NOT INVOKE CLIENT CODE ON THIS THREAD!
public static ColorSpace getInstance (int colorspace)
--- 257,286 ----
/**
* The built-in linear gray scale color space.
*/
@Native public static final int CS_GRAY = 1003;
/**
! * Constructs a {@code ColorSpace} object given a color space type and the
! * number of components.
! *
* @param type one of the {@code ColorSpace} type constants
* @param numcomponents the number of components in the color space
*/
! protected ColorSpace(int type, int numcomponents) {
this.type = type;
this.numComponents = numcomponents;
}
/**
! * Returns a {@code ColorSpace} representing one of the specific predefined
! * color spaces.
! *
! * @param colorspace a specific color space identified by one of the
! * predefined class constants (e.g. {@code CS_sRGB},
! * {@code CS_LINEAR_RGB}, {@code CS_CIEXYZ}, {@code CS_GRAY}, or
! * {@code CS_PYCC})
* @return the requested {@code ColorSpace} object
*/
// NOTE: This method may be called by privileged threads.
// DO NOT INVOKE CLIENT CODE ON THIS THREAD!
public static ColorSpace getInstance (int colorspace)
*** 361,514 ****
}
return theColorSpace;
}
-
/**
! * Returns true if the ColorSpace is CS_sRGB.
! * @return {@code true} if this is a {@code CS_sRGB} color
! * space, {@code false} if it is not
*/
public boolean isCS_sRGB () {
/* REMIND - make sure we know sRGBspace exists already */
return (this == sRGBspace);
}
/**
! * Transforms a color value assumed to be in this ColorSpace
! * into a value in the default CS_sRGB color space.
* <p>
! * This method transforms color values using algorithms designed
! * to produce the best perceptual match between input and output
! * colors. In order to do colorimetric conversion of color values,
! * you should use the {@code toCIEXYZ}
! * method of this color space to first convert from the input
! * color space to the CS_CIEXYZ color space, and then use the
! * {@code fromCIEXYZ} method of the CS_sRGB color space to
! * convert from CS_CIEXYZ to the output color space.
! * See {@link #toCIEXYZ(float[]) toCIEXYZ} and
* {@link #fromCIEXYZ(float[]) fromCIEXYZ} for further information.
*
! * @param colorvalue a float array with length of at least the number
! * of components in this ColorSpace
* @return a float array of length 3
! * @throws ArrayIndexOutOfBoundsException if array length is not
! * at least the number of components in this ColorSpace
*/
public abstract float[] toRGB(float[] colorvalue);
-
/**
! * Transforms a color value assumed to be in the default CS_sRGB
! * color space into this ColorSpace.
* <p>
! * This method transforms color values using algorithms designed
! * to produce the best perceptual match between input and output
! * colors. In order to do colorimetric conversion of color values,
! * you should use the {@code toCIEXYZ}
! * method of the CS_sRGB color space to first convert from the input
! * color space to the CS_CIEXYZ color space, and then use the
! * {@code fromCIEXYZ} method of this color space to
! * convert from CS_CIEXYZ to the output color space.
! * See {@link #toCIEXYZ(float[]) toCIEXYZ} and
* {@link #fromCIEXYZ(float[]) fromCIEXYZ} for further information.
*
* @param rgbvalue a float array with length of at least 3
! * @return a float array with length equal to the number of
! * components in this ColorSpace
! * @throws ArrayIndexOutOfBoundsException if array length is not
! * at least 3
*/
public abstract float[] fromRGB(float[] rgbvalue);
-
/**
! * Transforms a color value assumed to be in this ColorSpace
! * into the CS_CIEXYZ conversion color space.
* <p>
! * This method transforms color values using relative colorimetry,
! * as defined by the International Color Consortium standard. This
! * means that the XYZ values returned by this method are represented
! * relative to the D50 white point of the CS_CIEXYZ color space.
! * This representation is useful in a two-step color conversion
! * process in which colors are transformed from an input color
! * space to CS_CIEXYZ and then to an output color space. This
! * representation is not the same as the XYZ values that would
! * be measured from the given color value by a colorimeter.
! * A further transformation is necessary to compute the XYZ values
! * that would be measured using current CIE recommended practices.
! * See the {@link ICC_ColorSpace#toCIEXYZ(float[]) toCIEXYZ} method of
* {@code ICC_ColorSpace} for further information.
*
! * @param colorvalue a float array with length of at least the number
! * of components in this ColorSpace
* @return a float array of length 3
! * @throws ArrayIndexOutOfBoundsException if array length is not
! * at least the number of components in this ColorSpace.
*/
public abstract float[] toCIEXYZ(float[] colorvalue);
-
/**
! * Transforms a color value assumed to be in the CS_CIEXYZ conversion
! * color space into this ColorSpace.
* <p>
! * This method transforms color values using relative colorimetry,
! * as defined by the International Color Consortium standard. This
! * means that the XYZ argument values taken by this method are represented
! * relative to the D50 white point of the CS_CIEXYZ color space.
! * This representation is useful in a two-step color conversion
! * process in which colors are transformed from an input color
! * space to CS_CIEXYZ and then to an output color space. The color
! * values returned by this method are not those that would produce
! * the XYZ value passed to the method when measured by a colorimeter.
! * If you have XYZ values corresponding to measurements made using
! * current CIE recommended practices, they must be converted to D50
! * relative values before being passed to this method.
! * See the {@link ICC_ColorSpace#fromCIEXYZ(float[]) fromCIEXYZ} method of
* {@code ICC_ColorSpace} for further information.
*
* @param colorvalue a float array with length of at least 3
! * @return a float array with length equal to the number of
! * components in this ColorSpace
! * @throws ArrayIndexOutOfBoundsException if array length is not
! * at least 3
*/
public abstract float[] fromCIEXYZ(float[] colorvalue);
/**
! * Returns the color space type of this ColorSpace (for example
! * TYPE_RGB, TYPE_XYZ, ...). The type defines the
! * number of components of the color space and the interpretation,
! * e.g. TYPE_RGB identifies a color space with three components - red,
! * green, and blue. It does not define the particular color
! * characteristics of the space, e.g. the chromaticities of the
! * primaries.
*
* @return the type constant that represents the type of this
* {@code ColorSpace}
*/
public int getType() {
return type;
}
/**
* Returns the number of components of this ColorSpace.
! * @return The number of components in this {@code ColorSpace}.
*/
public int getNumComponents() {
return numComponents;
}
/**
* Returns the name of the component given the component index.
*
* @param idx the component index
* @return the name of the component at the specified index
! * @throws IllegalArgumentException if {@code idx} is
! * less than 0 or greater than numComponents - 1
*/
public String getName (int idx) {
/* REMIND - handle common cases here */
if ((idx < 0) || (idx > numComponents - 1)) {
throw new IllegalArgumentException(
--- 357,501 ----
}
return theColorSpace;
}
/**
! * Returns true if the {@code ColorSpace} is {@code CS_sRGB}.
! *
! * @return {@code true} if this is a {@code CS_sRGB} color space,
! * {@code false} if it is not
*/
public boolean isCS_sRGB () {
/* REMIND - make sure we know sRGBspace exists already */
return (this == sRGBspace);
}
/**
! * Transforms a color value assumed to be in this {@code ColorSpace} into a
! * value in the default {@code CS_sRGB} color space.
* <p>
! * This method transforms color values using algorithms designed to produce
! * the best perceptual match between input and output colors. In order to do
! * colorimetric conversion of color values, you should use the
! * {@code toCIEXYZ} method of this color space to first convert from the
! * input color space to the CS_CIEXYZ color space, and then use the
! * {@code fromCIEXYZ} method of the {@code CS_sRGB} color space to convert
! * from {@code CS_CIEXYZ} to the output color space. See
! * {@link #toCIEXYZ(float[]) toCIEXYZ} and
* {@link #fromCIEXYZ(float[]) fromCIEXYZ} for further information.
*
! * @param colorvalue a float array with length of at least the number of
! * components in this {@code ColorSpace}
* @return a float array of length 3
! * @throws ArrayIndexOutOfBoundsException if array length is not at least
! * the number of components in this {@code ColorSpace}
*/
public abstract float[] toRGB(float[] colorvalue);
/**
! * Transforms a color value assumed to be in the default {@code CS_sRGB}
! * color space into this {@code ColorSpace}.
* <p>
! * This method transforms color values using algorithms designed to produce
! * the best perceptual match between input and output colors. In order to do
! * colorimetric conversion of color values, you should use the
! * {@code toCIEXYZ} method of the {@code CS_sRGB} color space to first
! * convert from the input color space to the {@code CS_CIEXYZ} color space,
! * and then use the {@code fromCIEXYZ} method of this color space to convert
! * from {@code CS_CIEXYZ} to the output color space. See
! * {@link #toCIEXYZ(float[]) toCIEXYZ} and
* {@link #fromCIEXYZ(float[]) fromCIEXYZ} for further information.
*
* @param rgbvalue a float array with length of at least 3
! * @return a float array with length equal to the number of components in
! * this {@code ColorSpace}
! * @throws ArrayIndexOutOfBoundsException if array length is not at least 3
*/
public abstract float[] fromRGB(float[] rgbvalue);
/**
! * Transforms a color value assumed to be in this {@code ColorSpace} into
! * the {@code CS_CIEXYZ} conversion color space.
* <p>
! * This method transforms color values using relative colorimetry, as
! * defined by the International Color Consortium standard. This means that
! * the XYZ values returned by this method are represented relative to the
! * D50 white point of the {@code CS_CIEXYZ} color space. This representation
! * is useful in a two-step color conversion process in which colors are
! * transformed from an input color space to {@code CS_CIEXYZ} and then to an
! * output color space. This representation is not the same as the XYZ values
! * that would be measured from the given color value by a colorimeter. A
! * further transformation is necessary to compute the XYZ values that would
! * be measured using current CIE recommended practices. See the
! * {@link ICC_ColorSpace#toCIEXYZ(float[]) toCIEXYZ} method of
* {@code ICC_ColorSpace} for further information.
*
! * @param colorvalue a float array with length of at least the number of
! * components in this {@code ColorSpace}
* @return a float array of length 3
! * @throws ArrayIndexOutOfBoundsException if array length is not at least
! * the number of components in this {@code ColorSpace}.
*/
public abstract float[] toCIEXYZ(float[] colorvalue);
/**
! * Transforms a color value assumed to be in the {@code CS_CIEXYZ}
! * conversion color space into this {@code ColorSpace}.
* <p>
! * This method transforms color values using relative colorimetry, as
! * defined by the International Color Consortium standard. This means that
! * the XYZ argument values taken by this method are represented relative to
! * the D50 white point of the {@code CS_CIEXYZ} color space. This
! * representation is useful in a two-step color conversion process in which
! * colors are transformed from an input color space to {@code CS_CIEXYZ} and
! * then to an output color space. The color values returned by this method
! * are not those that would produce the XYZ value passed to the method when
! * measured by a colorimeter. If you have XYZ values corresponding to
! * measurements made using current CIE recommended practices, they must be
! * converted to D50 relative values before being passed to this method. See
! * the {@link ICC_ColorSpace#fromCIEXYZ(float[]) fromCIEXYZ} method of
* {@code ICC_ColorSpace} for further information.
*
* @param colorvalue a float array with length of at least 3
! * @return a float array with length equal to the number of components in
! * this {@code ColorSpace}
! * @throws ArrayIndexOutOfBoundsException if array length is not at least 3
*/
public abstract float[] fromCIEXYZ(float[] colorvalue);
/**
! * Returns the color space type of this {@code ColorSpace} (for example
! * {@code TYPE_RGB}, {@code TYPE_XYZ}, ...). The type defines the number of
! * components of the color space and the interpretation, e.g.
! * {@code TYPE_RGB} identifies a color space with three components - red,
! * green, and blue. It does not define the particular color characteristics
! * of the space, e.g. the chromaticities of the primaries.
*
* @return the type constant that represents the type of this
* {@code ColorSpace}
*/
public int getType() {
return type;
}
/**
* Returns the number of components of this ColorSpace.
! *
! * @return the number of components in this {@code ColorSpace}
*/
public int getNumComponents() {
return numComponents;
}
/**
* Returns the name of the component given the component index.
*
* @param idx the component index
* @return the name of the component at the specified index
! * @throws IllegalArgumentException if {@code idx} is less than 0 or greater
! * than {@code numComponents - 1}
*/
public String getName (int idx) {
/* REMIND - handle common cases here */
if ((idx < 0) || (idx > numComponents - 1)) {
throw new IllegalArgumentException(
*** 562,580 ****
}
return compName[idx];
}
/**
! * Returns the minimum normalized color component value for the
! * specified component. The default implementation in this abstract
! * class returns 0.0 for all components. Subclasses should override
! * this method if necessary.
*
* @param component the component index
* @return the minimum normalized component value
! * @throws IllegalArgumentException if component is less than 0 or
! * greater than numComponents - 1
* @since 1.4
*/
public float getMinValue(int component) {
if ((component < 0) || (component > numComponents - 1)) {
throw new IllegalArgumentException(
--- 549,566 ----
}
return compName[idx];
}
/**
! * Returns the minimum normalized color component value for the specified
! * component. The default implementation in this abstract class returns 0.0
! * for all components. Subclasses should override this method if necessary.
*
* @param component the component index
* @return the minimum normalized component value
! * @throws IllegalArgumentException if component is less than 0 or greater
! * than {@code numComponents - 1}
* @since 1.4
*/
public float getMinValue(int component) {
if ((component < 0) || (component > numComponents - 1)) {
throw new IllegalArgumentException(
*** 582,611 ****
}
return 0.0f;
}
/**
! * Returns the maximum normalized color component value for the
! * specified component. The default implementation in this abstract
! * class returns 1.0 for all components. Subclasses should override
! * this method if necessary.
*
* @param component the component index
* @return the maximum normalized component value
! * @throws IllegalArgumentException if component is less than 0 or
! * greater than numComponents - 1
* @since 1.4
*/
public float getMaxValue(int component) {
if ((component < 0) || (component > numComponents - 1)) {
throw new IllegalArgumentException(
"Component index out of range: " + component);
}
return 1.0f;
}
! /* Returns true if cspace is the XYZspace.
*/
static boolean isCS_CIEXYZ(ColorSpace cspace) {
return (cspace == XYZspace);
}
}
--- 568,597 ----
}
return 0.0f;
}
/**
! * Returns the maximum normalized color component value for the specified
! * component. The default implementation in this abstract class returns 1.0
! * for all components. Subclasses should override this method if necessary.
*
* @param component the component index
* @return the maximum normalized component value
! * @throws IllegalArgumentException if component is less than 0 or greater
! * than {@code numComponents - 1}
* @since 1.4
*/
public float getMaxValue(int component) {
if ((component < 0) || (component > numComponents - 1)) {
throw new IllegalArgumentException(
"Component index out of range: " + component);
}
return 1.0f;
}
! /*
! * Returns {@code true} if {@code cspace} is the XYZspace.
*/
static boolean isCS_CIEXYZ(ColorSpace cspace) {
return (cspace == XYZspace);
}
}
< prev index next >