protected ColorSpace(int type,
    int numcomponents) 
{
        this.type = type;
        this.numComponents = numcomponents;
}

Constructs a ColorSpace object given a color space type and the number of components.

Parameters:

type - one of the ColorSpace type constants

numcomponents - the number of components in the color space

 abstract public float[] fromCIEXYZ(float[] colorvalue)
Transforms a color value assumed to be in the CS_CIEXYZ conversion
color space into this ColorSpace.

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  fromCIEXYZ  method of
ICC_ColorSpace for further information.

 abstract public float[] fromRGB(float[] rgbvalue)
Transforms a color value assumed to be in the default CS_sRGB
color space into this ColorSpace.

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 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
fromCIEXYZ method of this color space to
convert from CS_CIEXYZ to the output color space.
See  toCIEXYZ  and
 fromCIEXYZ  for further information.

 public static ColorSpace getInstance(int colorspace) 
{
    ColorSpace    theColorSpace;
        switch (colorspace) {
        case CS_sRGB:
            synchronized(ColorSpace.class) {
                if (sRGBspace == null) {
                    ICC_Profile theProfile = ICC_Profile.getInstance (CS_sRGB);
                    sRGBspace = new ICC_ColorSpace (theProfile);
                }
                theColorSpace = sRGBspace;
            }
            break;
        case CS_CIEXYZ:
            synchronized(ColorSpace.class) {
                if (XYZspace == null) {
                    ICC_Profile theProfile =
                        ICC_Profile.getInstance (CS_CIEXYZ);
                    XYZspace = new ICC_ColorSpace (theProfile);
                }
                theColorSpace = XYZspace;
            }
            break;
        case CS_PYCC:
            synchronized(ColorSpace.class) {
                if (PYCCspace == null) {
                    ICC_Profile theProfile = ICC_Profile.getInstance (CS_PYCC);
                    PYCCspace = new ICC_ColorSpace (theProfile);
                }
                theColorSpace = PYCCspace;
            }
            break;
        case CS_GRAY:
            synchronized(ColorSpace.class) {
                if (GRAYspace == null) {
                    ICC_Profile theProfile = ICC_Profile.getInstance (CS_GRAY);
                    GRAYspace = new ICC_ColorSpace (theProfile);
                    /* to allow access from java.awt.ColorModel */
                    CMSManager.GRAYspace = GRAYspace;
                }
                theColorSpace = GRAYspace;
            }
            break;
        case CS_LINEAR_RGB:
            synchronized(ColorSpace.class) {
                if (LINEAR_RGBspace == null) {
                    ICC_Profile theProfile =
                        ICC_Profile.getInstance(CS_LINEAR_RGB);
                    LINEAR_RGBspace = new ICC_ColorSpace (theProfile);
                    /* to allow access from java.awt.ColorModel */
                    CMSManager.LINEAR_RGBspace = LINEAR_RGBspace;
                }
                theColorSpace = LINEAR_RGBspace;
            }
            break;
        default:
            throw new IllegalArgumentException ("Unknown color space");
        }
        return theColorSpace;
}

Returns a ColorSpace representing one of the specific predefined color spaces.

 public float getMaxValue(int component) 
{
        if ((component <  0) || (component  > numComponents - 1)) {
            throw new IllegalArgumentException(
                "Component index out of range: " + component);
        }
        return 1.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.

 public float getMinValue(int component) 
{
        if ((component <  0) || (component  > numComponents - 1)) {
            throw new IllegalArgumentException(
                "Component index out of range: " + component);
        }
        return 0.0f;
}

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.

 public String getName(int idx) 
{
        /* REMIND - handle common cases here */
        if ((idx <  0) || (idx  > numComponents - 1)) {
            throw new IllegalArgumentException(
                "Component index out of range: " + idx);
        }
        if (compName == null) {
            switch (type) {
                case ColorSpace.TYPE_XYZ:
                    compName = new String[] {"X", "Y", "Z"};
                    break;
                case ColorSpace.TYPE_Lab:
                    compName = new String[] {"L", "a", "b"};
                    break;
                case ColorSpace.TYPE_Luv:
                    compName = new String[] {"L", "u", "v"};
                    break;
                case ColorSpace.TYPE_YCbCr:
                    compName = new String[] {"Y", "Cb", "Cr"};
                    break;
                case ColorSpace.TYPE_Yxy:
                    compName = new String[] {"Y", "x", "y"};
                    break;
                case ColorSpace.TYPE_RGB:
                    compName = new String[] {"Red", "Green", "Blue"};
                    break;
                case ColorSpace.TYPE_GRAY:
                    compName = new String[] {"Gray"};
                    break;
                case ColorSpace.TYPE_HSV:
                    compName = new String[] {"Hue", "Saturation", "Value"};
                    break;
                case ColorSpace.TYPE_HLS:
                    compName = new String[] {"Hue", "Lightness",
                                             "Saturation"};
                    break;
                case ColorSpace.TYPE_CMYK:
                    compName = new String[] {"Cyan", "Magenta", "Yellow",
                                             "Black"};
                    break;
                case ColorSpace.TYPE_CMY:
                    compName = new String[] {"Cyan", "Magenta", "Yellow"};
                    break;
                default:
                    String [] tmp = new String[numComponents];
                    for (int i = 0; i <  tmp.length; i++) {
                        tmp[i] = "Unnamed color component(" + i + ")";
                    }
                    compName = tmp;
            }
        }
        return compName[idx];
}

Returns the name of the component given the component index.

 public int getNumComponents() 
{
        return numComponents;
}

Returns the number of components of this ColorSpace.

 public int getType() 
{
        return type;
}

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.

 static boolean isCS_CIEXYZ(ColorSpace cspace) 
{
        return (cspace == XYZspace);
}

 public boolean isCS_sRGB() 
{
        /* REMIND - make sure we know sRGBspace exists already */
        return (this == sRGBspace);
}

Returns true if the ColorSpace is CS_sRGB.

 abstract public float[] toCIEXYZ(float[] colorvalue)
Transforms a color value assumed to be in this ColorSpace
into the CS_CIEXYZ conversion color space.

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  toCIEXYZ  method of
ICC_ColorSpace for further information.

 abstract public float[] toRGB(float[] colorvalue)
Transforms a color value assumed to be in this ColorSpace
into a value in the default CS_sRGB color space.

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 toCIEXYZ
method of this color space to first convert from the input
color space to the CS_CIEXYZ color space, and then use the
fromCIEXYZ method of the CS_sRGB color space to
convert from CS_CIEXYZ to the output color space.
See  toCIEXYZ  and
 fromCIEXYZ  for further information.