|
/*
Java Media APIs: Cross-Platform Imaging, Media and Visualization
Alejandro Terrazas
Sams, Published November 2002,
ISBN 0672320940
*/
import
java.awt.Rectangle;
import
java.awt.image.BufferedImage;
import
java.awt.image.DataBuffer;
import
java.awt.image.WritableRaster;
import
java.io.IOException;
import
java.util.Iterator;
import
javax.imageio.IIOException;
import
javax.imageio.ImageReadParam;
import
javax.imageio.ImageReader;
import
javax.imageio.ImageTypeSpecifier;
import
javax.imageio.metadata.IIOMetadata;
import
javax.imageio.metadata.IIOMetadataFormat;
import
javax.imageio.metadata.IIOMetadataNode;
import
javax.imageio.spi.ImageReaderSpi;
import
javax.imageio.stream.ImageInputStream;
import
org.w3c.dom.Node;
/**
* ch5ImageReader.java -- this class provides the functionality to read an image
* of format ch5.
*/
public class
ch5ImageReader
extends
ImageReader
{
private
ImageInputStream iis;
private
ch5ImageMetadata
[]
imagemd;
private
ch5StreamMetadata streammd;
public
ch5ImageReader
(
ImageReaderSpi originatingProvider
) {
super
(
originatingProvider
)
;
}
/**
* return the ch5StreamMetadata object instantiated in the setStreamMetadata
* method
*/
public
IIOMetadata getStreamMetadata
() {
return
streammd;
}
/**
* return the ch5ImageMetadata object instantiated in the setImageMetadata
* method
*/
public
IIOMetadata getImageMetadata
(
int
imageIndex
) {
return
imagemd
[
imageIndex
]
;
}
/**
* this method sets the input for this ImageReader and also calls the
* setStreamMetadata method so that the numberImages field is available
*/
public
void
setInput
(
Object object,
boolean
seekForwardOnly
) {
super
.setInput
(
object, seekForwardOnly
)
;
if
(
object ==
null
)
throw new
IllegalArgumentException
(
"input is null"
)
;
if
(
!
(
object
instanceof
ImageInputStream
)) {
String argString =
"input not an ImageInputStream"
;
throw new
IllegalArgumentException
(
argString
)
;
}
iis =
(
ImageInputStream
)
object;
setStreamMetadata
(
iis
)
;
}
/**
* this method provides suggestions for possible image types that will be
* used to decode the image specified by index imageIndex. By default, the
* first image type returned by this method will be the image type of the
* BufferedImage returned by the ImageReader's getDestination method. In
* this case, we are suggesting using an 8 bit grayscale image with no alpha
* component.
*/
public
Iterator getImageTypes
(
int
imageIndex
) {
java.util.List l =
new
java.util.ArrayList
()
;
;
int
bits =
8
;
/*
* can convert ch5 format into 8 bit grayscale image with no alpha
*/
l.add
(
ImageTypeSpecifier.createGrayscale
(
bits, DataBuffer.TYPE_BYTE,
false
))
;
return
l.iterator
()
;
}
/**
* read in the input image specified by index imageIndex using the
* parameters specified by the ImageReadParam object param
*/
public
BufferedImage read
(
int
imageIndex, ImageReadParam param
) {
checkIndex
(
imageIndex
)
;
if
(
isSeekForwardOnly
())
minIndex = imageIndex;
else
minIndex =
0
;
BufferedImage bimage =
null
;
WritableRaster raster =
null
;
/*
* this method sets the image metadata so that we can use the getWidth
* and getHeight methods
*/
setImageMetadata
(
iis, imageIndex
)
;
int
srcWidth = getWidth
(
imageIndex
)
;
int
srcHeight = getHeight
(
imageIndex
)
;
// initialize values to -1
int
dstWidth = -
1
;
int
dstHeight = -
1
;
int
srcRegionWidth = -
1
;
int
srcRegionHeight = -
1
;
int
srcRegionXOffset = -
1
;
int
srcRegionYOffset = -
1
;
int
xSubsamplingFactor = -
1
;
int
ySubsamplingFactor = -
1
;
if
(
param ==
null
)
param = getDefaultReadParam
()
;
Iterator imageTypes = getImageTypes
(
imageIndex
)
;
try
{
/*
* get the destination BufferedImage which will be filled using the
* input image's pixel data
*/
bimage = getDestination
(
param, imageTypes, srcWidth, srcHeight
)
;
/*
* get Rectangle object which will be used to clip the source
* image's dimensions.
*/
Rectangle srcRegion = param.getSourceRegion
()
;
if
(
srcRegion !=
null
) {
srcRegionWidth =
(
int
)
srcRegion.getWidth
()
;
srcRegionHeight =
(
int
)
srcRegion.getHeight
()
;
srcRegionXOffset =
(
int
)
srcRegion.getX
()
;
srcRegionYOffset =
(
int
)
srcRegion.getY
()
;
/*
* correct for overextended source regions
*/
if
(
srcRegionXOffset + srcRegionWidth > srcWidth
)
dstWidth = srcWidth - srcRegionXOffset;
else
dstWidth = srcRegionWidth;
if
(
srcRegionYOffset + srcRegionHeight > srcHeight
)
dstHeight = srcHeight - srcRegionYOffset;
else
dstHeight = srcRegionHeight;
}
else
{
dstWidth = srcWidth;
dstHeight = srcHeight;
srcRegionXOffset = srcRegionYOffset =
0
;
}
/*
* get subsampling factors
*/
xSubsamplingFactor = param.getSourceXSubsampling
()
;
ySubsamplingFactor = param.getSourceYSubsampling
()
;
/**
* dstWidth and dstHeight should be equal to bimage.getWidth() and
* bimage.getHeight() after these next two instructions
*/
dstWidth =
(
dstWidth -
1
)
/ xSubsamplingFactor +
1
;
dstHeight =
(
dstHeight -
1
)
/ ySubsamplingFactor +
1
;
}
catch
(
IIOException e
) {
System.err.println
(
"Can't create destination BufferedImage"
)
;
}
raster = bimage.getWritableTile
(
0
,
0
)
;
/*
* using the parameters specified by the ImageReadParam object, read the
* image image data into the destination BufferedImage
*/
byte
[]
srcBuffer =
new
byte
[
srcWidth
]
;
byte
[]
dstBuffer =
new
byte
[
dstWidth
]
;
int
jj;
int
index;
try
{
for
(
int
j =
0
; j < srcHeight; j++
) {
iis.readFully
(
srcBuffer,
0
, srcWidth
)
;
jj = j - srcRegionYOffset;
if
(
jj % ySubsamplingFactor ==
0
) {
jj /= ySubsamplingFactor;
if
((
jj >=
0
)
&&
(
jj < dstHeight
)) {
for
(
int
i =
0
; i < dstWidth; i++
) {
index = srcRegionXOffset + i * xSubsamplingFactor;
dstBuffer
[
i
]
= srcBuffer
[
index
]
;
}
raster.setDataElements
(
0
, jj, dstWidth,
1
, dstBuffer
)
;
}
}
}
}
catch
(
IOException e
) {
bimage =
null
;
}
return
bimage;
}
/**
* this method sets the image metadata for the image indexed by index
* imageIndex. This method is specific for the ch5 format and thus only sets
* the image width and image height
*/
private
void
setImageMetadata
(
ImageInputStream iis,
int
imageIndex
) {
imagemd
[
imageIndex
]
=
new
ch5ImageMetadata
()
;
try
{
String s;
s = iis.readLine
()
;
while
(
s.length
()
==
0
)
s = iis.readLine
()
;
imagemd
[
imageIndex
]
.imageWidth = Integer.parseInt
(
s.trim
())
;
s = iis.readLine
()
;
imagemd
[
imageIndex
]
.imageHeight = Integer.parseInt
(
s.trim
())
;
}
catch
(
IOException exception
) {
}
}
/**
* this method sets the stream metadata for the images represented by the
* ImageInputStream iis. This method is specific for the ch5 format and thus
* only sets the numberImages field.
*/
private
void
setStreamMetadata
(
ImageInputStream iis
) {
streammd =
new
ch5StreamMetadata
()
;
try
{
String magicNumber = iis.readLine
()
;
int
numImages = Integer.parseInt
(
iis.readLine
()
.trim
())
;
streammd.numberImages = numImages;
imagemd =
new
ch5ImageMetadata
[
streammd.numberImages
]
;
}
catch
(
IOException exception
) {
}
}
/**
* This method can only be used after the stream metadata has been set
* (which occurs in the setInput method). Else it will return a -1
*/
public
int
getNumImages
(
boolean
allowSearch
) {
return
streammd.numberImages;
}
/**
* This method can only be used after the stream metadata has been set
* (which occurs in the setInput method). Else it will return a -1
*/
public
int
getHeight
(
int
imageIndex
) {
if
(
imagemd ==
null
)
return
-
1
;
checkIndex
(
imageIndex
)
;
return
imagemd
[
imageIndex
]
.imageHeight;
}
/**
* This method can only be used after the stream metadata has been set
* (which occurs in the setInput method). Else it will return a -1
*/
public
int
getWidth
(
int
imageIndex
) {
if
(
imagemd ==
null
)
return
-
1
;
checkIndex
(
imageIndex
)
;
return
imagemd
[
imageIndex
]
.imageWidth;
}
private
void
checkIndex
(
int
imageIndex
) {
if
(
imageIndex >= streammd.numberImages
) {
String argString =
"imageIndex >= number of images"
;
throw new
IndexOutOfBoundsException
(
argString
)
;
}
if
(
imageIndex < minIndex
) {
String argString =
"imageIndex < minIndex"
;
throw new
IndexOutOfBoundsException
(
argString
)
;
}
}
}
/**
* ch5StreamMetadata.java -- holds stream metadata for the ch5 format. The
* internal tree for holding this metadata is read only
*/
class
ch5StreamMetadata
extends
IIOMetadata
{
static final
String nativeMetadataFormatName =
"ch5.imageio.ch5stream_1.00"
;
static final
String nativeMetadataFormatClassName =
"ch5.imageio.ch5stream"
;
static final
String
[]
extraMetadataFormatNames =
null
;
static final
String
[]
extraMetadataFormatClassNames =
null
;
static final
boolean
standardMetadataFormatSupported =
false
;
public
int
numberImages;
public
ch5StreamMetadata
() {
super
(
standardMetadataFormatSupported, nativeMetadataFormatName,
nativeMetadataFormatClassName, extraMetadataFormatNames,
extraMetadataFormatClassNames
)
;
numberImages = -
1
;
}
public
boolean
isReadOnly
() {
return true
;
}
/**
* IIOMetadataFormat objects are meant to describe the structure of metadata
* returned from the getAsTree method. In this case, no such description is
* available
*/
public
IIOMetadataFormat getMetadataFormat
(
String formatName
) {
if
(
formatName.equals
(
nativeMetadataFormatName
)) {
return null
;
}
else
{
throw new
IllegalArgumentException
(
"Unrecognized format!"
)
;
}
}
/**
* returns the stream metadata in a tree corresponding to the provided
* formatName
*/
public
Node getAsTree
(
String formatName
) {
if
(
formatName.equals
(
nativeMetadataFormatName
)) {
return
getNativeTree
()
;
}
else
{
throw new
IllegalArgumentException
(
"Unrecognized format!"
)
;
}
}
/**
* returns the stream metadata in a tree using the following format
*
<!ELEMENT ch5.imageio.ch5stream_1.00 (imageDimensions)>
<!ATTLIST
* imageDimensions numberImages CDATA #REQUIRED
*/
private
Node getNativeTree
() {
IIOMetadataNode node;
// scratch node
IIOMetadataNode root =
new
IIOMetadataNode
(
nativeMetadataFormatName
)
;
// Image descriptor
node =
new
IIOMetadataNode
(
"imageDimensions"
)
;
node.setAttribute
(
"numberImages"
, Integer.toString
(
numberImages
))
;
root.appendChild
(
node
)
;
return
root;
}
public
void
setFromTree
(
String formatName, Node root
) {
throw new
IllegalStateException
(
"Metadata is read-only!"
)
;
}
public
void
mergeTree
(
String formatName, Node root
) {
throw new
IllegalStateException
(
"Metadata is read-only!"
)
;
}
public
void
reset
() {
throw new
IllegalStateException
(
"Metadata is read-only!"
)
;
}
/**
* initialize the stream metadata element numberImages
*/
public
void
initialize
(
int
numberImages
) {
this
.numberImages = numberImages;
}
}
/**
* ch5ImageMetadata.java -- holds image metadata for the ch5 format. The
* internal tree for holding this metadata is read only
*/
class
ch5ImageMetadata
extends
IIOMetadata
{
static final
String nativeMetadataFormatName =
"ch5.imageio.ch5image_1.00"
;
static final
String nativeMetadataFormatClassName =
"ch5.imageio.ch5image"
;
static final
String
[]
extraMetadataFormatNames =
null
;
static final
String
[]
extraMetadataFormatClassNames =
null
;
static final
boolean
standardMetadataFormatSupported =
false
;
public
int
imageWidth;
public
int
imageHeight;
public
ch5ImageMetadata
() {
super
(
standardMetadataFormatSupported, nativeMetadataFormatName,
nativeMetadataFormatClassName, extraMetadataFormatNames,
extraMetadataFormatClassNames
)
;
imageWidth = -
1
;
imageHeight = -
1
;
}
public
boolean
isReadOnly
() {
return true
;
}
/**
* IIOMetadataFormat objects are meant to describe the structure of metadata
* returned from the getAsTree method. In this case, no such description is
* available
*/
public
IIOMetadataFormat getMetadataFormat
(
String formatName
) {
if
(
formatName.equals
(
nativeMetadataFormatName
)) {
return null
;
}
else
{
throw new
IllegalArgumentException
(
"Unrecognized format!"
)
;
}
}
/**
* returns the image metadata in a tree corresponding to the provided
* formatName
*/
public
Node getAsTree
(
String formatName
) {
if
(
formatName.equals
(
nativeMetadataFormatName
)) {
return
getNativeTree
()
;
}
else
{
throw new
IllegalArgumentException
(
"Unrecognized format!"
)
;
}
}
/**
* returns the image metadata in a tree using the following format
<!ELEMENT
* ch5.imageio.ch5image_1.00 (imageDimensions)>
<!ATTLIST imageDimensions
* imageWidth CDATA #REQUIRED imageHeight CDATA #REQUIRED
*/
private
Node getNativeTree
() {
IIOMetadataNode root =
new
IIOMetadataNode
(
nativeMetadataFormatName
)
;
IIOMetadataNode node =
new
IIOMetadataNode
(
"imageDimensions"
)
;
node.setAttribute
(
"imageWidth"
, Integer.toString
(
imageWidth
))
;
node.setAttribute
(
"imageHeight"
, Integer.toString
(
imageHeight
))
;
root.appendChild
(
node
)
;
return
root;
}
public
void
setFromTree
(
String formatName, Node root
) {
throw new
IllegalStateException
(
"Metadata is read-only!"
)
;
}
public
void
mergeTree
(
String formatName, Node root
) {
throw new
IllegalStateException
(
"Metadata is read-only!"
)
;
}
public
void
reset
() {
throw new
IllegalStateException
(
"Metadata is read-only!"
)
;
}
/**
* initialize the image metadata elements width and height
*/
public
void
initialize
(
int
width,
int
height
) {
imageWidth = width;
imageHeight = height;
}
}
|