awt/image/ComponentColorModel.java

38  * color components in the {@code ColorSpace}. There may be a
50  * The translation from pixel sample values to color/alpha components for
52  * samples to components.
57  * The translation from sample values to normalized color/alpha components
98  * to 1.0.  Second the min/max range of all color components of the
133  * use all the bits of all sample values.  Thus all color/alpha components
150  * rendering such that color components fall within the normalized range
158  * an {@code IllegalArgumentException}, unless the number of components
208      * parameters. Color components will be in the specified
216      * length should be at least the number of components in the
254      *         color and alpha components, and transferType is one of
306      * parameters. Color components will be in the specified
313      * respectively.  The number of color components will be the
314      * number of components in the {@code ColorSpace}.  There will be
461             // maxValue == 1.0f for all components, we need to check that
749      * Returns the color/alpha components of the pixel in the default
753      * color components (if the alpha value is 0, the color values will be 0).
755      * @param pixel The pixel from which you want to get the color/alpha components.
757      * @return The color/alpha components for the specified pixel, as an int.
1096      * Returns the color/alpha components for the specified pixel in the
1103      * color components (if the alpha value is 0, the color values will be 0).
1109      * @param inData The pixel from which you want to get the color/alpha components,
1112      * @return The color/alpha components for the specified pixel, as an int.
1138                                        // green and blue components
1643                     // fix 4412670 - for components of 24 or more bits
1659    /** Returns an array of unnormalized color/alpha components given a pixel
1663      * unnormalized form.  Color/alpha components are stored
1664      * in the {@code components} array starting at {@code offset}
1668      * @param components An integer array in which to store the unnormalized
1669      * color/alpha components. If the {@code components} array is null,
1671      * @param offset An offset into the {@code components} array.
1673      * @return The components array.
1679      * @throws ArrayIndexOutOfBoundsException If the {@code components}
1681      * alpha components (starting at offset).
1683     public int[] getComponents(int pixel, int[] components, int offset) {
1696         if (components == null) {
1697             components = new int[offset+1];
1700         components[offset+0] = (pixel & ((1<<nBits[0]) - 1));
1701         return components;
1705      * Returns an array of unnormalized color/alpha components given a pixel
1712      * Color/alpha components are stored in the {@code components} array
1722      * @param components An integer array in which to store the unnormalized
1723      * color/alpha components. If the {@code components} array is null,
1725      * @param offset An offset into the {@code components} array.
1727      * @return The {@code components} array.
1738      * @throws IllegalArgumentException If the {@code components} array is
1740      * components (starting at offset), or if {@code pixel} is not large
1743     public int[] getComponents(Object pixel, int[] components, int offset) {
1764                 ("Length of pixel array < number of components in model");
1766         if (components == null) {
1767             components = new int[offset+numComponents];
1769         else if ((components.length-offset) < numComponents) {
1771                 ("Length of components array < number of components in model");
1773         System.arraycopy(intpixel, 0, components, offset, numComponents);
1775         return components;
1779      * Returns an array of all of the color/alpha components in unnormalized
1780      * form, given a normalized component array.  Unnormalized components
1783      * components are float values between a per component minimum and
1789      * {@code components} array is {@code null}, a new array
1790      * will be allocated.  The {@code components} array will
1791      * be returned.  Color/alpha components are stored in the
1792      * {@code components} array starting at {@code offset} (even
1795      * {@code components} array is not {@code null} and is not
1797      * components (starting at {@code offset}).  An
1800      * all the color and alpha components starting at
1802      * @param normComponents an array containing normalized components
1804      * array at which to start retrieving normalized components
1805      * @param components an array that receives the components from
1807      * @param offset the index into {@code components} at which to
1808      * begin storing normalized components from
1811      * components.
1820                                            int[] components, int offset) {
1830                                                components, offset);
1834      * Returns an array of all of the color/alpha components in normalized
1835      * form, given an unnormalized component array.  Unnormalized components
1838      * components are float values between a per component minimum and
1846      * will be returned.  Color/alpha components are stored in the
1851      * and is not large enough to hold all the color and alpha components
1854      * {@code components} array is not large enough to hold all the
1855      * color and alpha components starting at {@code offset}.
1856      * @param components an array containing unnormalized components
1857      * @param offset the offset into the {@code components} array at
1858      * which to start retrieving unnormalized components
1859      * @param normComponents an array that receives the normalized components
1861      * which to begin storing normalized components
1863      * components.
1867     public float[] getNormalizedComponents(int[] components, int offset,
1878         return super.getNormalizedComponents(components, offset,
1884      * given an array of unnormalized color/alpha components.
1886      * @param components An array of unnormalized color/alpha components.
1887      * @param offset An offset into the {@code components} array.
1896     public int getDataElement(int[] components, int offset) {
1906             return components[offset+0];
1916      * components. This array can then be passed to the {@code setDataElements}
1919      * @param components An array of unnormalized color/alpha components.
1920      * @param offset The integer offset into the {@code components} array.
1936      * @throws IllegalArgumentException If the components array
1937      * is not large enough to hold all the color and alpha components
1954     public Object getDataElements(int[] components, int offset, Object obj) {
1963         if ((components.length-offset) < numComponents) {
1977                 System.arraycopy(components, offset, pixel, 0,
1992                     pixel[i] = (byte) (components[offset+i]&0xff);
2007                     pixel[i] = (short) (components[offset+i]&0xffff);
2022      * components.  This method will throw an
2028      * color and alpha components (starting at {@code normOffset}).
2030      * components
2032      * begin retrieving the color and alpha components
2034      * {@code ColorModel} corresponding to the specified components.
2040      *  hold all of the color and alpha components starting at
2082      * components.  This array can then be passed to the
2086      * all the color and alpha components (starting at
2096      * components
2098      * begin retrieving color and alpha components
2108      *  components starting at {@code normOffset}
2302      * Returns an array of all of the color/alpha components in normalized
2310      * Normalized components are float values between a per component minimum
2315      * will be returned.  Color/alpha components are stored in the
2320      * and is not large enough to hold all the color and alpha components
2330      * @param normComponents an array to receive the normalized components
2332      * array at which to start storing normalized components
2334      * components.
2339      *          color and alpha components starting at {@code normOffset}
2416             // semantics of this method, and rescale the color components
2419             // transferType is byte, ushort, int, or short - i.e. components
2889         // Must have the same number of components