JDK 11 java.desktop.jmod - Desktop Module
JDK 11 java.desktop.jmod is the JMOD file for JDK 11 Desktop module.
JDK 11 Desktop module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\java.desktop.jmod.
JDK 11 Desktop module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.
JDK 11 Desktop module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\java.desktop.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ javax/imageio/ImageTypeSpecifier.java
/*
* Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package javax.imageio;
import java.awt.Point;
import java.awt.Transparency;
import java.awt.image.BandedSampleModel;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.color.ColorSpace;
import java.awt.image.IndexColorModel;
import java.awt.image.ComponentColorModel;
import java.awt.image.DataBuffer;
import java.awt.image.DirectColorModel;
import java.awt.image.MultiPixelPackedSampleModel;
import java.awt.image.PixelInterleavedSampleModel;
import java.awt.image.SinglePixelPackedSampleModel;
import java.awt.image.Raster;
import java.awt.image.RenderedImage;
import java.awt.image.SampleModel;
import java.awt.image.WritableRaster;
import java.util.Hashtable;
/**
* A class that allows the format of an image (in particular, its
* {@code SampleModel} and {@code ColorModel}) to be
* specified in a convenient manner.
*
*/
public class ImageTypeSpecifier {
/**
* The {@code ColorModel} to be used as a prototype.
*/
protected ColorModel colorModel;
/**
* A {@code SampleModel} to be used as a prototype.
*/
protected SampleModel sampleModel;
/**
* Cached specifiers for all of the standard
* {@code BufferedImage} types.
*/
private static ImageTypeSpecifier[] BISpecifier;
private static ColorSpace sRGB;
// Initialize the standard specifiers
static {
sRGB = ColorSpace.getInstance(ColorSpace.CS_sRGB);
BISpecifier =
new ImageTypeSpecifier[BufferedImage.TYPE_BYTE_INDEXED + 1];
}
/**
* A constructor to be used by inner subclasses only.
*/
private ImageTypeSpecifier() {}
/**
* Constructs an {@code ImageTypeSpecifier} directly
* from a {@code ColorModel} and a {@code SampleModel}.
* It is the caller's responsibility to supply compatible
* parameters.
*
* @param colorModel a {@code ColorModel}.
* @param sampleModel a {@code SampleModel}.
*
* @exception IllegalArgumentException if either parameter is
* {@code null}.
* @exception IllegalArgumentException if {@code sampleModel}
* is not compatible with {@code colorModel}.
*/
public ImageTypeSpecifier(ColorModel colorModel, SampleModel sampleModel) {
if (colorModel == null) {
throw new IllegalArgumentException("colorModel == null!");
}
if (sampleModel == null) {
throw new IllegalArgumentException("sampleModel == null!");
}
if (!colorModel.isCompatibleSampleModel(sampleModel)) {
throw new IllegalArgumentException
("sampleModel is incompatible with colorModel!");
}
this.colorModel = colorModel;
this.sampleModel = sampleModel;
}
/**
* Constructs an {@code ImageTypeSpecifier} from a
* {@code RenderedImage}. If a {@code BufferedImage} is
* being used, one of the factory methods
* {@code createFromRenderedImage} or
* {@code createFromBufferedImageType} should be used instead in
* order to get a more accurate result.
*
* @param image a {@code RenderedImage}.
*
* @exception IllegalArgumentException if the argument is
* {@code null}.
*/
public ImageTypeSpecifier(RenderedImage image) {
if (image == null) {
throw new IllegalArgumentException("image == null!");
}
colorModel = image.getColorModel();
sampleModel = image.getSampleModel();
}
// Packed
static class Packed extends ImageTypeSpecifier {
ColorSpace colorSpace;
int redMask;
int greenMask;
int blueMask;
int alphaMask;
int transferType;
boolean isAlphaPremultiplied;
public Packed(ColorSpace colorSpace,
int redMask,
int greenMask,
int blueMask,
int alphaMask, // 0 if no alpha
int transferType,
boolean isAlphaPremultiplied) {
if (colorSpace == null) {
throw new IllegalArgumentException("colorSpace == null!");
}
if (colorSpace.getType() != ColorSpace.TYPE_RGB) {
throw new IllegalArgumentException
("colorSpace is not of type TYPE_RGB!");
}
if (transferType != DataBuffer.TYPE_BYTE &&
transferType != DataBuffer.TYPE_USHORT &&
transferType != DataBuffer.TYPE_INT) {
throw new IllegalArgumentException
("Bad value for transferType!");
}
if (redMask == 0 && greenMask == 0 &&
blueMask == 0 && alphaMask == 0) {
throw new IllegalArgumentException
("No mask has at least 1 bit set!");
}
this.colorSpace = colorSpace;
this.redMask = redMask;
this.greenMask = greenMask;
this.blueMask = blueMask;
this.alphaMask = alphaMask;
this.transferType = transferType;
this.isAlphaPremultiplied = isAlphaPremultiplied;
int bits = 32;
this.colorModel =
new DirectColorModel(colorSpace,
bits,
redMask, greenMask, blueMask,
alphaMask, isAlphaPremultiplied,
transferType);
this.sampleModel = colorModel.createCompatibleSampleModel(1, 1);
}
}
/**
* Returns a specifier for a packed image format that will use a
* {@code DirectColorModel} and a packed
* {@code SampleModel} to store each pixel packed into in a
* single byte, short, or int.
*
* @param colorSpace the desired {@code ColorSpace}.
* @param redMask a contiguous mask indicated the position of the
* red channel.
* @param greenMask a contiguous mask indicated the position of the
* green channel.
* @param blueMask a contiguous mask indicated the position of the
* blue channel.
* @param alphaMask a contiguous mask indicated the position of the
* alpha channel.
* @param transferType the desired {@code SampleModel} transfer type.
* @param isAlphaPremultiplied {@code true} if the color channels
* will be premultipled by the alpha channel.
*
* @return an {@code ImageTypeSpecifier} with the desired
* characteristics.
*
* @exception IllegalArgumentException if {@code colorSpace}
* is {@code null}.
* @exception IllegalArgumentException if {@code colorSpace}
* is not of type {@code TYPE_RGB}.
* @exception IllegalArgumentException if no mask has at least 1
* bit set.
* @exception IllegalArgumentException if
* {@code transferType} if not one of
* {@code DataBuffer.TYPE_BYTE},
* {@code DataBuffer.TYPE_USHORT}, or
* {@code DataBuffer.TYPE_INT}.
*/
public static ImageTypeSpecifier
createPacked(ColorSpace colorSpace,
int redMask,
int greenMask,
int blueMask,
int alphaMask, // 0 if no alpha
int transferType,
boolean isAlphaPremultiplied) {
return new ImageTypeSpecifier.Packed(colorSpace,
redMask,
greenMask,
blueMask,
alphaMask, // 0 if no alpha
transferType,
isAlphaPremultiplied);
}
static ColorModel createComponentCM(ColorSpace colorSpace,
int numBands,
int dataType,
boolean hasAlpha,
boolean isAlphaPremultiplied) {
int transparency =
hasAlpha ? Transparency.TRANSLUCENT : Transparency.OPAQUE;
int[] numBits = new int[numBands];
int bits = DataBuffer.getDataTypeSize(dataType);
for (int i = 0; i < numBands; i++) {
numBits[i] = bits;
}
return new ComponentColorModel(colorSpace,
numBits,
hasAlpha,
isAlphaPremultiplied,
transparency,
dataType);
}
// Interleaved
static class Interleaved extends ImageTypeSpecifier {
ColorSpace colorSpace;
int[] bandOffsets;
int dataType;
boolean hasAlpha;
boolean isAlphaPremultiplied;
public Interleaved(ColorSpace colorSpace,
int[] bandOffsets,
int dataType,
boolean hasAlpha,
boolean isAlphaPremultiplied) {
if (colorSpace == null) {
throw new IllegalArgumentException("colorSpace == null!");
}
if (bandOffsets == null) {
throw new IllegalArgumentException("bandOffsets == null!");
}
int numBands = colorSpace.getNumComponents() +
(hasAlpha ? 1 : 0);
if (bandOffsets.length != numBands) {
throw new IllegalArgumentException
("bandOffsets.length is wrong!");
}
if (dataType != DataBuffer.TYPE_BYTE &&
dataType != DataBuffer.TYPE_SHORT &&
dataType != DataBuffer.TYPE_USHORT &&
dataType != DataBuffer.TYPE_INT &&
dataType != DataBuffer.TYPE_FLOAT &&
dataType != DataBuffer.TYPE_DOUBLE) {
throw new IllegalArgumentException
("Bad value for dataType!");
}
this.colorSpace = colorSpace;
this.bandOffsets = bandOffsets.clone();
this.dataType = dataType;
this.hasAlpha = hasAlpha;
this.isAlphaPremultiplied = isAlphaPremultiplied;
this.colorModel =
ImageTypeSpecifier.createComponentCM(colorSpace,
bandOffsets.length,
dataType,
hasAlpha,
isAlphaPremultiplied);
int minBandOffset = bandOffsets[0];
int maxBandOffset = minBandOffset;
for (int i = 0; i < bandOffsets.length; i++) {
int offset = bandOffsets[i];
minBandOffset = Math.min(offset, minBandOffset);
maxBandOffset = Math.max(offset, maxBandOffset);
}
int pixelStride = maxBandOffset - minBandOffset + 1;
int w = 1;
int h = 1;
this.sampleModel =
new PixelInterleavedSampleModel(dataType,
w, h,
pixelStride,
w*pixelStride,
bandOffsets);
}
public boolean equals(Object o) {
if ((o == null) ||
!(o instanceof ImageTypeSpecifier.Interleaved)) {
return false;
}
ImageTypeSpecifier.Interleaved that =
(ImageTypeSpecifier.Interleaved)o;
if ((!(this.colorSpace.equals(that.colorSpace))) ||
(this.dataType != that.dataType) ||
(this.hasAlpha != that.hasAlpha) ||
(this.isAlphaPremultiplied != that.isAlphaPremultiplied) ||
(this.bandOffsets.length != that.bandOffsets.length)) {
return false;
}
for (int i = 0; i < bandOffsets.length; i++) {
if (this.bandOffsets[i] != that.bandOffsets[i]) {
return false;
}
}
return true;
}
public int hashCode() {
return (super.hashCode() +
(4 * bandOffsets.length) +
(25 * dataType) +
(hasAlpha ? 17 : 18));
}
}
/**
* Returns a specifier for an interleaved image format that will
* use a {@code ComponentColorModel} and a
* {@code PixelInterleavedSampleModel} to store each pixel
* component in a separate byte, short, or int.
*
* @param colorSpace the desired {@code ColorSpace}.
* @param bandOffsets an array of {@code int}s indicating the
* offsets for each band.
* @param dataType the desired data type, as one of the enumerations
* from the {@code DataBuffer} class.
* @param hasAlpha {@code true} if an alpha channel is desired.
* @param isAlphaPremultiplied {@code true} if the color channels
* will be premultipled by the alpha channel.
*
* @return an {@code ImageTypeSpecifier} with the desired
* characteristics.
*
* @exception IllegalArgumentException if {@code colorSpace}
* is {@code null}.
* @exception IllegalArgumentException if {@code bandOffsets}
* is {@code null}.
* @exception IllegalArgumentException if {@code dataType} is
* not one of the legal {@code DataBuffer.TYPE_*} constants.
* @exception IllegalArgumentException if
* {@code bandOffsets.length} does not equal the number of
* color space components, plus 1 if {@code hasAlpha} is
* {@code true}.
*/
public static ImageTypeSpecifier
createInterleaved(ColorSpace colorSpace,
int[] bandOffsets,
int dataType,
boolean hasAlpha,
boolean isAlphaPremultiplied) {
return new ImageTypeSpecifier.Interleaved(colorSpace,
bandOffsets,
dataType,
hasAlpha,
isAlphaPremultiplied);
}
// Banded
static class Banded extends ImageTypeSpecifier {
ColorSpace colorSpace;
int[] bankIndices;
int[] bandOffsets;
int dataType;
boolean hasAlpha;
boolean isAlphaPremultiplied;
public Banded(ColorSpace colorSpace,
int[] bankIndices,
int[] bandOffsets,
int dataType,
boolean hasAlpha,
boolean isAlphaPremultiplied) {
if (colorSpace == null) {
throw new IllegalArgumentException("colorSpace == null!");
}
if (bankIndices == null) {
throw new IllegalArgumentException("bankIndices == null!");
}
if (bandOffsets == null) {
throw new IllegalArgumentException("bandOffsets == null!");
}
if (bankIndices.length != bandOffsets.length) {
throw new IllegalArgumentException
("bankIndices.length != bandOffsets.length!");
}
if (dataType != DataBuffer.TYPE_BYTE &&
dataType != DataBuffer.TYPE_SHORT &&
dataType != DataBuffer.TYPE_USHORT &&
dataType != DataBuffer.TYPE_INT &&
dataType != DataBuffer.TYPE_FLOAT &&
dataType != DataBuffer.TYPE_DOUBLE) {
throw new IllegalArgumentException
("Bad value for dataType!");
}
int numBands = colorSpace.getNumComponents() +
(hasAlpha ? 1 : 0);
if (bandOffsets.length != numBands) {
throw new IllegalArgumentException
("bandOffsets.length is wrong!");
}
this.colorSpace = colorSpace;
this.bankIndices = bankIndices.clone();
this.bandOffsets = bandOffsets.clone();
this.dataType = dataType;
this.hasAlpha = hasAlpha;
this.isAlphaPremultiplied = isAlphaPremultiplied;
this.colorModel =
ImageTypeSpecifier.createComponentCM(colorSpace,
bankIndices.length,
dataType,
hasAlpha,
isAlphaPremultiplied);
int w = 1;
int h = 1;
this.sampleModel = new BandedSampleModel(dataType,
w, h,
w,
bankIndices,
bandOffsets);
}
public boolean equals(Object o) {
if ((o == null) ||
!(o instanceof ImageTypeSpecifier.Banded)) {
return false;
}
ImageTypeSpecifier.Banded that =
(ImageTypeSpecifier.Banded)o;
if ((!(this.colorSpace.equals(that.colorSpace))) ||
(this.dataType != that.dataType) ||
(this.hasAlpha != that.hasAlpha) ||
(this.isAlphaPremultiplied != that.isAlphaPremultiplied) ||
(this.bankIndices.length != that.bankIndices.length) ||
(this.bandOffsets.length != that.bandOffsets.length)) {
return false;
}
for (int i = 0; i < bankIndices.length; i++) {
if (this.bankIndices[i] != that.bankIndices[i]) {
return false;
}
}
for (int i = 0; i < bandOffsets.length; i++) {
if (this.bandOffsets[i] != that.bandOffsets[i]) {
return false;
}
}
return true;
}
public int hashCode() {
return (super.hashCode() +
(3 * bandOffsets.length) +
(7 * bankIndices.length) +
(21 * dataType) +
(hasAlpha ? 19 : 29));
}
}
/**
* Returns a specifier for a banded image format that will use a
* {@code ComponentColorModel} and a
* {@code BandedSampleModel} to store each channel in a
* separate array.
*
* @param colorSpace the desired {@code ColorSpace}.
* @param bankIndices an array of {@code int}s indicating the
* bank in which each band will be stored.
* @param bandOffsets an array of {@code int}s indicating the
* starting offset of each band within its bank.
* @param dataType the desired data type, as one of the enumerations
* from the {@code DataBuffer} class.
* @param hasAlpha {@code true} if an alpha channel is desired.
* @param isAlphaPremultiplied {@code true} if the color channels
* will be premultipled by the alpha channel.
*
* @return an {@code ImageTypeSpecifier} with the desired
* characteristics.
*
* @exception IllegalArgumentException if {@code colorSpace}
* is {@code null}.
* @exception IllegalArgumentException if {@code bankIndices}
* is {@code null}.
* @exception IllegalArgumentException if {@code bandOffsets}
* is {@code null}.
* @exception IllegalArgumentException if the lengths of
* {@code bankIndices} and {@code bandOffsets} differ.
* @exception IllegalArgumentException if
* {@code bandOffsets.length} does not equal the number of
* color space components, plus 1 if {@code hasAlpha} is
* {@code true}.
* @exception IllegalArgumentException if {@code dataType} is
* not one of the legal {@code DataBuffer.TYPE_*} constants.
*/
public static ImageTypeSpecifier
createBanded(ColorSpace colorSpace,
int[] bankIndices,
int[] bandOffsets,
int dataType,
boolean hasAlpha,
boolean isAlphaPremultiplied) {
return new ImageTypeSpecifier.Banded(colorSpace,
bankIndices,
bandOffsets,
dataType,
hasAlpha,
isAlphaPremultiplied);
}
// Grayscale
static class Grayscale extends ImageTypeSpecifier {
int bits;
int dataType;
boolean isSigned;
boolean hasAlpha;
boolean isAlphaPremultiplied;
public Grayscale(int bits,
int dataType,
boolean isSigned,
boolean hasAlpha,
boolean isAlphaPremultiplied)
{
if (bits != 1 && bits != 2 && bits != 4 &&
bits != 8 && bits != 16)
{
throw new IllegalArgumentException("Bad value for bits!");
}
if (dataType != DataBuffer.TYPE_BYTE &&
dataType != DataBuffer.TYPE_SHORT &&
dataType != DataBuffer.TYPE_USHORT)
{
throw new IllegalArgumentException
("Bad value for dataType!");
}
if (bits > 8 && dataType == DataBuffer.TYPE_BYTE) {
throw new IllegalArgumentException
("Too many bits for dataType!");
}
this.bits = bits;
this.dataType = dataType;
this.isSigned = isSigned;
this.hasAlpha = hasAlpha;
this.isAlphaPremultiplied = isAlphaPremultiplied;
ColorSpace colorSpace = ColorSpace.getInstance(ColorSpace.CS_GRAY);
if ((bits == 8 && dataType == DataBuffer.TYPE_BYTE) ||
(bits == 16 &&
(dataType == DataBuffer.TYPE_SHORT ||
dataType == DataBuffer.TYPE_USHORT))) {
// Use component color model & sample model
int numBands = hasAlpha ? 2 : 1;
int transparency =
hasAlpha ? Transparency.TRANSLUCENT : Transparency.OPAQUE;
int[] nBits = new int[numBands];
nBits[0] = bits;
if (numBands == 2) {
nBits[1] = bits;
}
this.colorModel =
new ComponentColorModel(colorSpace,
nBits,
hasAlpha,
isAlphaPremultiplied,
transparency,
dataType);
int[] bandOffsets = new int[numBands];
bandOffsets[0] = 0;
if (numBands == 2) {
bandOffsets[1] = 1;
}
int w = 1;
int h = 1;
this.sampleModel =
new PixelInterleavedSampleModel(dataType,
w, h,
numBands, w*numBands,
bandOffsets);
} else {
int numEntries = 1 << bits;
byte[] arr = new byte[numEntries];
for (int i = 0; i < numEntries; i++) {
arr[i] = (byte)(i*255/(numEntries - 1));
}
this.colorModel =
new IndexColorModel(bits, numEntries, arr, arr, arr);
this.sampleModel =
new MultiPixelPackedSampleModel(dataType, 1, 1, bits);
}
}
}
/**
* Returns a specifier for a grayscale image format that will pack
* pixels of the given bit depth into array elements of
* the specified data type.
*
* @param bits the number of bits per gray value (1, 2, 4, 8, or 16).
* @param dataType the desired data type, as one of the enumerations
* from the {@code DataBuffer} class.
* @param isSigned {@code true} if negative values are to
* be represented.
*
* @return an {@code ImageTypeSpecifier} with the desired
* characteristics.
*
* @exception IllegalArgumentException if {@code bits} is
* not one of 1, 2, 4, 8, or 16.
* @exception IllegalArgumentException if {@code dataType} is
* not one of {@code DataBuffer.TYPE_BYTE},
* {@code DataBuffer.TYPE_SHORT}, or
* {@code DataBuffer.TYPE_USHORT}.
* @exception IllegalArgumentException if {@code bits} is
* larger than the bit size of the given {@code dataType}.
*/
public static ImageTypeSpecifier
createGrayscale(int bits,
int dataType,
boolean isSigned) {
return new ImageTypeSpecifier.Grayscale(bits,
dataType,
isSigned,
false,
false);
}
/**
* Returns a specifier for a grayscale plus alpha image format
* that will pack pixels of the given bit depth into array
* elements of the specified data type.
*
* @param bits the number of bits per gray value (1, 2, 4, 8, or 16).
* @param dataType the desired data type, as one of the enumerations
* from the {@code DataBuffer} class.
* @param isSigned {@code true} if negative values are to
* be represented.
* @param isAlphaPremultiplied {@code true} if the luminance channel
* will be premultipled by the alpha channel.
*
* @return an {@code ImageTypeSpecifier} with the desired
* characteristics.
*
* @exception IllegalArgumentException if {@code bits} is
* not one of 1, 2, 4, 8, or 16.
* @exception IllegalArgumentException if {@code dataType} is
* not one of {@code DataBuffer.TYPE_BYTE},
* {@code DataBuffer.TYPE_SHORT}, or
* {@code DataBuffer.TYPE_USHORT}.
* @exception IllegalArgumentException if {@code bits} is
* larger than the bit size of the given {@code dataType}.
*/
public static ImageTypeSpecifier
createGrayscale(int bits,
int dataType,
boolean isSigned,
boolean isAlphaPremultiplied) {
return new ImageTypeSpecifier.Grayscale(bits,
dataType,
isSigned,
true,
isAlphaPremultiplied);
}
// Indexed
static class Indexed extends ImageTypeSpecifier {
byte[] redLUT;
byte[] greenLUT;
byte[] blueLUT;
byte[] alphaLUT = null;
int bits;
int dataType;
public Indexed(byte[] redLUT,
byte[] greenLUT,
byte[] blueLUT,
byte[] alphaLUT,
int bits,
int dataType) {
if (redLUT == null || greenLUT == null || blueLUT == null) {
throw new IllegalArgumentException("LUT is null!");
}
if (bits != 1 && bits != 2 && bits != 4 &&
bits != 8 && bits != 16) {
throw new IllegalArgumentException("Bad value for bits!");
}
if (dataType != DataBuffer.TYPE_BYTE &&
dataType != DataBuffer.TYPE_SHORT &&
dataType != DataBuffer.TYPE_USHORT &&
dataType != DataBuffer.TYPE_INT) {
throw new IllegalArgumentException
("Bad value for dataType!");
}
if ((bits > 8 && dataType == DataBuffer.TYPE_BYTE) ||
(bits > 16 && dataType != DataBuffer.TYPE_INT)) {
throw new IllegalArgumentException
("Too many bits for dataType!");
}
int len = 1 << bits;
if (redLUT.length != len ||
greenLUT.length != len ||
blueLUT.length != len ||
(alphaLUT != null && alphaLUT.length != len)) {
throw new IllegalArgumentException("LUT has improper length!");
}
this.redLUT = redLUT.clone();
this.greenLUT = greenLUT.clone();
this.blueLUT = blueLUT.clone();
if (alphaLUT != null) {
this.alphaLUT = alphaLUT.clone();
}
this.bits = bits;
this.dataType = dataType;
if (alphaLUT == null) {
this.colorModel = new IndexColorModel(bits,
redLUT.length,
redLUT,
greenLUT,
blueLUT);
} else {
this.colorModel = new IndexColorModel(bits,
redLUT.length,
redLUT,
greenLUT,
blueLUT,
alphaLUT);
}
if ((bits == 8 && dataType == DataBuffer.TYPE_BYTE) ||
(bits == 16 &&
(dataType == DataBuffer.TYPE_SHORT ||
dataType == DataBuffer.TYPE_USHORT))) {
int[] bandOffsets = { 0 };
this.sampleModel =
new PixelInterleavedSampleModel(dataType,
1, 1, 1, 1,
bandOffsets);
} else {
this.sampleModel =
new MultiPixelPackedSampleModel(dataType, 1, 1, bits);
}
}
}
/**
* Returns a specifier for an indexed-color image format that will pack
* index values of the given bit depth into array elements of
* the specified data type.
*
* @param redLUT an array of {@code byte}s containing
* the red values for each index.
* @param greenLUT an array of {@code byte}s containing * the
* green values for each index.
* @param blueLUT an array of {@code byte}s containing the
* blue values for each index.
* @param alphaLUT an array of {@code byte}s containing the
* alpha values for each index, or {@code null} to create a
* fully opaque LUT.
* @param bits the number of bits in each index.
* @param dataType the desired output type, as one of the enumerations
* from the {@code DataBuffer} class.
*
* @return an {@code ImageTypeSpecifier} with the desired
* characteristics.
*
* @exception IllegalArgumentException if {@code redLUT} is
* {@code null}.
* @exception IllegalArgumentException if {@code greenLUT} is
* {@code null}.
* @exception IllegalArgumentException if {@code blueLUT} is
* {@code null}.
* @exception IllegalArgumentException if {@code bits} is
* not one of 1, 2, 4, 8, or 16.
* @exception IllegalArgumentException if the
* non-{@code null} LUT parameters do not have lengths of
* exactly {@code 1 << bits}.
* @exception IllegalArgumentException if {@code dataType} is
* not one of {@code DataBuffer.TYPE_BYTE},
* {@code DataBuffer.TYPE_SHORT},
* {@code DataBuffer.TYPE_USHORT},
* or {@code DataBuffer.TYPE_INT}.
* @exception IllegalArgumentException if {@code bits} is
* larger than the bit size of the given {@code dataType}.
*/
public static ImageTypeSpecifier
createIndexed(byte[] redLUT,
byte[] greenLUT,
byte[] blueLUT,
byte[] alphaLUT,
int bits,
int dataType) {
return new ImageTypeSpecifier.Indexed(redLUT,
greenLUT,
blueLUT,
alphaLUT,
bits,
dataType);
}
/**
* Returns an {@code ImageTypeSpecifier} that encodes
* one of the standard {@code BufferedImage} types
* (other than {@code TYPE_CUSTOM}).
*
* @param bufferedImageType an int representing one of the standard
* {@code BufferedImage} types.
*
* @return an {@code ImageTypeSpecifier} with the desired
* characteristics.
*
* @exception IllegalArgumentException if
* {@code bufferedImageType} is not one of the standard
* types, or is equal to {@code TYPE_CUSTOM}.
*
* @see java.awt.image.BufferedImage
* @see java.awt.image.BufferedImage#TYPE_INT_RGB
* @see java.awt.image.BufferedImage#TYPE_INT_ARGB
* @see java.awt.image.BufferedImage#TYPE_INT_ARGB_PRE
* @see java.awt.image.BufferedImage#TYPE_INT_BGR
* @see java.awt.image.BufferedImage#TYPE_3BYTE_BGR
* @see java.awt.image.BufferedImage#TYPE_4BYTE_ABGR
* @see java.awt.image.BufferedImage#TYPE_4BYTE_ABGR_PRE
* @see java.awt.image.BufferedImage#TYPE_USHORT_565_RGB
* @see java.awt.image.BufferedImage#TYPE_USHORT_555_RGB
* @see java.awt.image.BufferedImage#TYPE_BYTE_GRAY
* @see java.awt.image.BufferedImage#TYPE_USHORT_GRAY
* @see java.awt.image.BufferedImage#TYPE_BYTE_BINARY
* @see java.awt.image.BufferedImage#TYPE_BYTE_INDEXED
*/
public static
ImageTypeSpecifier createFromBufferedImageType(int bufferedImageType) {
if (bufferedImageType >= BufferedImage.TYPE_INT_RGB &&
bufferedImageType <= BufferedImage.TYPE_BYTE_INDEXED) {
return getSpecifier(bufferedImageType);
} else if (bufferedImageType == BufferedImage.TYPE_CUSTOM) {
throw new IllegalArgumentException("Cannot create from TYPE_CUSTOM!");
} else {
throw new IllegalArgumentException("Invalid BufferedImage type!");
}
}
/**
* Returns an {@code ImageTypeSpecifier} that encodes the
* layout of a {@code RenderedImage} (which may be a
* {@code BufferedImage}).
*
* @param image a {@code RenderedImage}.
*
* @return an {@code ImageTypeSpecifier} with the desired
* characteristics.
*
* @exception IllegalArgumentException if {@code image} is
* {@code null}.
*/
public static
ImageTypeSpecifier createFromRenderedImage(RenderedImage image) {
if (image == null) {
throw new IllegalArgumentException("image == null!");
}
if (image instanceof BufferedImage) {
int bufferedImageType = ((BufferedImage)image).getType();
if (bufferedImageType != BufferedImage.TYPE_CUSTOM) {
return getSpecifier(bufferedImageType);
}
}
return new ImageTypeSpecifier(image);
}
/**
* Returns an int containing one of the enumerated constant values
* describing image formats from {@code BufferedImage}.
*
* @return an {@code int} representing a
* {@code BufferedImage} type.
*
* @see java.awt.image.BufferedImage
* @see java.awt.image.BufferedImage#TYPE_CUSTOM
* @see java.awt.image.BufferedImage#TYPE_INT_RGB
* @see java.awt.image.BufferedImage#TYPE_INT_ARGB
* @see java.awt.image.BufferedImage#TYPE_INT_ARGB_PRE
* @see java.awt.image.BufferedImage#TYPE_INT_BGR
* @see java.awt.image.BufferedImage#TYPE_3BYTE_BGR
* @see java.awt.image.BufferedImage#TYPE_4BYTE_ABGR
* @see java.awt.image.BufferedImage#TYPE_4BYTE_ABGR_PRE
* @see java.awt.image.BufferedImage#TYPE_USHORT_565_RGB
* @see java.awt.image.BufferedImage#TYPE_USHORT_555_RGB
* @see java.awt.image.BufferedImage#TYPE_BYTE_GRAY
* @see java.awt.image.BufferedImage#TYPE_USHORT_GRAY
* @see java.awt.image.BufferedImage#TYPE_BYTE_BINARY
* @see java.awt.image.BufferedImage#TYPE_BYTE_INDEXED
*/
public int getBufferedImageType() {
BufferedImage bi = createBufferedImage(1, 1);
return bi.getType();
}
/**
* Return the number of color components
* specified by this object. This is the same value as returned by
* {@code ColorModel.getNumComponents}
*
* @return the number of components in the image.
*/
public int getNumComponents() {
return colorModel.getNumComponents();
}
/**
* Return the number of bands
* specified by this object. This is the same value as returned by
* {@code SampleModel.getNumBands}
*
* @return the number of bands in the image.
*/
public int getNumBands() {
return sampleModel.getNumBands();
}
/**
* Return the number of bits used to represent samples of the given band.
*
* @param band the index of the band to be queried, as an
* int.
*
* @return an int specifying a number of bits.
*
* @exception IllegalArgumentException if {@code band} is
* negative or greater than the largest band index.
*/
public int getBitsPerBand(int band) {
if (band < 0 || band >= getNumBands()) {
throw new IllegalArgumentException("band out of range!");
}
return sampleModel.getSampleSize(band);
}
/**
* Returns a {@code SampleModel} based on the settings
* encapsulated within this object. The width and height of the
* {@code SampleModel} will be set to arbitrary values.
*
* @return a {@code SampleModel} with arbitrary dimensions.
*/
public SampleModel getSampleModel() {
return sampleModel;
}
/**
* Returns a {@code SampleModel} based on the settings
* encapsulated within this object. The width and height of the
* {@code SampleModel} will be set to the supplied values.
*
* @param width the desired width of the returned {@code SampleModel}.
* @param height the desired height of the returned
* {@code SampleModel}.
*
* @return a {@code SampleModel} with the given dimensions.
*
* @exception IllegalArgumentException if either {@code width} or
* {@code height} are negative or zero.
* @exception IllegalArgumentException if the product of
* {@code width} and {@code height} is greater than
* {@code Integer.MAX_VALUE}
*/
public SampleModel getSampleModel(int width, int height) {
if ((long)width*height > Integer.MAX_VALUE) {
throw new IllegalArgumentException
("width*height > Integer.MAX_VALUE!");
}
return sampleModel.createCompatibleSampleModel(width, height);
}
/**
* Returns the {@code ColorModel} specified by this object.
*
* @return a {@code ColorModel}.
*/
public ColorModel getColorModel() {
return colorModel;
}
/**
* Creates a {@code BufferedImage} with a given width and
* height according to the specification embodied in this object.
*
* @param width the desired width of the returned
* {@code BufferedImage}.
* @param height the desired height of the returned
* {@code BufferedImage}.
*
* @return a new {@code BufferedImage}
*
* @exception IllegalArgumentException if either {@code width} or
* {@code height} are negative or zero.
* @exception IllegalArgumentException if the product of
* {@code width} and {@code height} is greater than
* {@code Integer.MAX_VALUE}, or if the number of array
* elements needed to store the image is greater than
* {@code Integer.MAX_VALUE}.
*/
public BufferedImage createBufferedImage(int width, int height) {
try {
SampleModel sampleModel = getSampleModel(width, height);
WritableRaster raster =
Raster.createWritableRaster(sampleModel,
new Point(0, 0));
return new BufferedImage(colorModel, raster,
colorModel.isAlphaPremultiplied(),
new Hashtable<>());
} catch (NegativeArraySizeException e) {
// Exception most likely thrown from a DataBuffer constructor
throw new IllegalArgumentException
("Array size > Integer.MAX_VALUE!");
}
}
/**
* Returns {@code true} if the given {@code Object} is
* an {@code ImageTypeSpecifier} and has a
* {@code SampleModel} and {@code ColorModel} that are
* equal to those of this object.
*
* @param o the {@code Object} to be compared for equality.
*
* @return {@code true} if the given object is an equivalent
* {@code ImageTypeSpecifier}.
*/
public boolean equals(Object o) {
if ((o == null) || !(o instanceof ImageTypeSpecifier)) {
return false;
}
ImageTypeSpecifier that = (ImageTypeSpecifier)o;
return (colorModel.equals(that.colorModel)) &&
(sampleModel.equals(that.sampleModel));
}
/**
* Returns the hash code for this ImageTypeSpecifier.
*
* @return a hash code for this ImageTypeSpecifier
*/
public int hashCode() {
return (9 * colorModel.hashCode()) + (14 * sampleModel.hashCode());
}
private static ImageTypeSpecifier getSpecifier(int type) {
if (BISpecifier[type] == null) {
BISpecifier[type] = createSpecifier(type);
}
return BISpecifier[type];
}
private static ImageTypeSpecifier createSpecifier(int type) {
switch(type) {
case BufferedImage.TYPE_INT_RGB:
return createPacked(sRGB,
0x00ff0000,
0x0000ff00,
0x000000ff,
0x0,
DataBuffer.TYPE_INT,
false);
case BufferedImage.TYPE_INT_ARGB:
return createPacked(sRGB,
0x00ff0000,
0x0000ff00,
0x000000ff,
0xff000000,
DataBuffer.TYPE_INT,
false);
case BufferedImage.TYPE_INT_ARGB_PRE:
return createPacked(sRGB,
0x00ff0000,
0x0000ff00,
0x000000ff,
0xff000000,
DataBuffer.TYPE_INT,
true);
case BufferedImage.TYPE_INT_BGR:
return createPacked(sRGB,
0x000000ff,
0x0000ff00,
0x00ff0000,
0x0,
DataBuffer.TYPE_INT,
false);
case BufferedImage.TYPE_3BYTE_BGR:
return createInterleaved(sRGB,
new int[] { 2, 1, 0 },
DataBuffer.TYPE_BYTE,
false,
false);
case BufferedImage.TYPE_4BYTE_ABGR:
return createInterleaved(sRGB,
new int[] { 3, 2, 1, 0 },
DataBuffer.TYPE_BYTE,
true,
false);
case BufferedImage.TYPE_4BYTE_ABGR_PRE:
return createInterleaved(sRGB,
new int[] { 3, 2, 1, 0 },
DataBuffer.TYPE_BYTE,
true,
true);
case BufferedImage.TYPE_USHORT_565_RGB:
return createPacked(sRGB,
0xF800,
0x07E0,
0x001F,
0x0,
DataBuffer.TYPE_USHORT,
false);
case BufferedImage.TYPE_USHORT_555_RGB:
return createPacked(sRGB,
0x7C00,
0x03E0,
0x001F,
0x0,
DataBuffer.TYPE_USHORT,
false);
case BufferedImage.TYPE_BYTE_GRAY:
return createGrayscale(8,
DataBuffer.TYPE_BYTE,
false);
case BufferedImage.TYPE_USHORT_GRAY:
return createGrayscale(16,
DataBuffer.TYPE_USHORT,
false);
case BufferedImage.TYPE_BYTE_BINARY:
return createGrayscale(1,
DataBuffer.TYPE_BYTE,
false);
case BufferedImage.TYPE_BYTE_INDEXED:
{
BufferedImage bi =
new BufferedImage(1, 1, BufferedImage.TYPE_BYTE_INDEXED);
IndexColorModel icm = (IndexColorModel)bi.getColorModel();
int mapSize = icm.getMapSize();
byte[] redLUT = new byte[mapSize];
byte[] greenLUT = new byte[mapSize];
byte[] blueLUT = new byte[mapSize];
byte[] alphaLUT = new byte[mapSize];
icm.getReds(redLUT);
icm.getGreens(greenLUT);
icm.getBlues(blueLUT);
icm.getAlphas(alphaLUT);
return createIndexed(redLUT, greenLUT, blueLUT, alphaLUT,
8,
DataBuffer.TYPE_BYTE);
}
default:
throw new IllegalArgumentException("Invalid BufferedImage type!");
}
}
}
⏎ javax/imageio/ImageTypeSpecifier.java
Or download all of them as a single archive file:
File name: java.desktop-11.0.1-src.zip File size: 7974380 bytes Release date: 2018-11-04 Download
⇒ JDK 11 java.instrument.jmod - Instrument Module
2022-08-06, 194563👍, 5💬
Related Topics: