/**
* Test Read exploiting JAI-ImageIO tools capabilities
*
* @throws FileNotFoundException
* @throws IOException
*/
@Test
public void testGCP() throws FileNotFoundException, IOException {
if (!isGDALAvailable) {
return;
}
String fileName = "gcp.tif";
final File file = TestData.file(this, fileName);
ImageReader reader = new GeoTiffImageReaderSpi().createReaderInstance();
reader.setInput(file);
GDALCommonIIOImageMetadata metadata = (GDALCommonIIOImageMetadata) reader.getImageMetadata(0);
final int gcpNumber = metadata.getGcpNumber();
Assert.assertEquals(gcpNumber, 4);
final List<GCP> gcps = metadata.getGCPs();
Assert.assertNotNull(gcps);
Assert.assertFalse(gcps.isEmpty());
for (int i = 0; i < 4; i++) {
Assert.assertEquals(gcps.get(i), referenceGCPs.get(i));
}
reader.dispose();
}
void readAndDisplayMetadata(String fileName) {
try {
File file = new File(fileName);
ImageInputStream iis = ImageIO.createImageInputStream(file);
Iterator<ImageReader> readers = ImageIO.getImageReaders(iis);
if (readers.hasNext()) {
// pick the first available ImageReader
ImageReader reader = readers.next();
// attach source to the reader
reader.setInput(iis, true);
// read metadata of first image
IIOMetadata metadata = reader.getImageMetadata(0);
String[] names = metadata.getMetadataFormatNames();
int length = names.length;
for (int i = 0; i < length; i++) {
System.out.println("Format name: " + names[i]);
displayMetadata(metadata.getAsTree(names[i]));
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 图片文件转换为tif格式
*
* @param imageFile 文件路径
* @param imageFormat 文件扩展名
* @return
*/
public static File createImage(File imageFile, String imageFormat) {
File tempFile = null;
try {
Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName(imageFormat);
ImageReader reader = readers.next();
ImageInputStream iis = ImageIO.createImageInputStream(imageFile);
reader.setInput(iis);
// Read the stream metadata
IIOMetadata streamMetadata = reader.getStreamMetadata();
// Set up the writeParam
TIFFImageWriteParam tiffWriteParam = new TIFFImageWriteParam(Locale.CHINESE);
tiffWriteParam.setCompressionMode(ImageWriteParam.MODE_DISABLED);
// Get tif writer and set output to file
Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName("tiff");
ImageWriter writer = writers.next();
BufferedImage bi = reader.read(0);
IIOImage image = new IIOImage(bi, null, reader.getImageMetadata(0));
tempFile = tempImageFile(imageFile);
ImageOutputStream ios = ImageIO.createImageOutputStream(tempFile);
writer.setOutput(ios);
writer.write(streamMetadata, image, tiffWriteParam);
ios.close();
writer.dispose();
reader.dispose();
} catch (IOException e) {
e.printStackTrace();
}
return tempFile;
}
public static IIOMetadata getImageMetadata(File image) throws IOException {
Iterator readers =
ImageIO.getImageReadersBySuffix(StringHelper.getFileExtension(image.getName()));
if (StringHelper.isImage(image.getName())) {
if (!readers.hasNext()) {
return null;
} else {
ImageReader imageReader = (ImageReader) readers.next();
FileImageInputStream in = new FileImageInputStream(image);
try {
imageReader.setInput(in);
return imageReader.getImageMetadata(0);
} finally {
if (in != null) {
try {
in.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
} else {
return null;
}
}
/**
* Test Writing capabilities.
*
* @throws FileNotFoundException
* @throws IOException
*/
@Test
public void write() throws IOException, FileNotFoundException {
if (!isGDALAvailable) {
return;
}
final File outputFile = TestData.temp(this, "writetest.tif", false);
outputFile.deleteOnExit();
final File inputFile = TestData.file(this, "utmByte.tif");
ImageReadParam rparam = new ImageReadParam();
rparam.setSourceRegion(new Rectangle(1, 1, 300, 500));
rparam.setSourceSubsampling(1, 2, 0, 0);
ImageReader reader = new GeoTiffImageReaderSpi().createReaderInstance();
reader.setInput(inputFile);
final IIOMetadata metadata = reader.getImageMetadata(0);
final ParameterBlockJAI pbjImageRead = new ParameterBlockJAI("ImageRead");
pbjImageRead.setParameter("Input", inputFile);
pbjImageRead.setParameter("reader", reader);
pbjImageRead.setParameter("readParam", rparam);
final ImageLayout l = new ImageLayout();
l.setTileGridXOffset(0).setTileGridYOffset(0).setTileHeight(256).setTileWidth(256);
RenderedOp image =
JAI.create("ImageRead", pbjImageRead, new RenderingHints(JAI.KEY_IMAGE_LAYOUT, l));
if (TestData.isInteractiveTest()) Viewer.visualizeAllInformation(image, "geotiff");
// ////////////////////////////////////////////////////////////////
// preparing to write
// ////////////////////////////////////////////////////////////////
final ParameterBlockJAI pbjImageWrite = new ParameterBlockJAI("ImageWrite");
ImageWriter writer = new GeoTiffImageWriterSpi().createWriterInstance();
pbjImageWrite.setParameter("Output", outputFile);
pbjImageWrite.setParameter("writer", writer);
pbjImageWrite.setParameter("ImageMetadata", metadata);
pbjImageWrite.setParameter("Transcode", false);
ImageWriteParam param = new ImageWriteParam(Locale.getDefault());
param.setSourceRegion(new Rectangle(10, 10, 100, 100));
param.setSourceSubsampling(2, 1, 0, 0);
pbjImageWrite.setParameter("writeParam", param);
pbjImageWrite.addSource(image);
final RenderedOp op = JAI.create("ImageWrite", pbjImageWrite);
final ImageWriter writer2 =
(ImageWriter) op.getProperty(ImageWriteDescriptor.PROPERTY_NAME_IMAGE_WRITER);
writer2.dispose();
// ////////////////////////////////////////////////////////////////
// preparing to read again
// ////////////////////////////////////////////////////////////////
final ParameterBlockJAI pbjImageReRead = new ParameterBlockJAI("ImageRead");
pbjImageReRead.setParameter("Input", outputFile);
pbjImageReRead.setParameter("Reader", new GeoTiffImageReaderSpi().createReaderInstance());
final RenderedOp image2 = JAI.create("ImageRead", pbjImageReRead);
if (TestData.isInteractiveTest()) Viewer.visualizeAllInformation(image2, "geotif2");
else Assert.assertNotNull(image2.getTiles());
}
@Test
public void metaDataTest() throws IOException {
Iterator<ImageReader> itrR = ImageIO.getImageReadersByFormatName("jpg");
ImageReader imageReader = itrR.next();
ImageInputStream imageInputStream = ImageIO.createImageInputStream(new File(SRCIMG));
imageReader.setInput(imageInputStream, true);
IIOMetadata ioMetadata = imageReader.getImageMetadata(0);
System.out.println(ioMetadata.toString());
}
/**
* Returns the geotiff metadata for this geotiff file.
*
* @return the metadata
*/
public GeoTiffIIOMetadataDecoder getMetadata() {
GeoTiffIIOMetadataDecoder metadata = null;
ImageReader reader = null;
boolean closeMe = true;
ImageInputStream stream = null;
try {
if ((source instanceof InputStream) || (source instanceof ImageInputStream)) {
closeMe = false;
}
if (source instanceof ImageInputStream) {
stream = (ImageInputStream) source;
} else {
inStreamSPI = ImageIOExt.getImageInputStreamSPI(source);
if (inStreamSPI == null) {
throw new IllegalArgumentException("No input stream for the provided source");
}
stream =
inStreamSPI.createInputStreamInstance(
source, ImageIO.getUseCache(), ImageIO.getCacheDirectory());
}
if (stream == null) {
throw new IllegalArgumentException("No input stream for the provided source");
}
stream.mark();
reader = READER_SPI.createReaderInstance();
reader.setInput(stream);
final IIOMetadata iioMetadata = reader.getImageMetadata(0);
metadata = new GeoTiffIIOMetadataDecoder(iioMetadata);
} catch (IOException e) {
if (LOGGER.isLoggable(Level.SEVERE)) {
LOGGER.log(Level.SEVERE, e.getMessage(), e);
}
} finally {
if (reader != null)
try {
reader.dispose();
} catch (Throwable t) {
}
if (stream != null) {
try {
stream.reset();
} catch (Throwable t) {
}
if (closeMe) {
try {
stream.close();
} catch (Throwable t) {
}
}
}
}
return metadata;
}
/**
* Test Read on a Paletted Image
*
* @throws FileNotFoundException
* @throws IOException
*/
@Test
public void palette() throws FileNotFoundException, IOException {
if (!isGDALAvailable) {
return;
}
final File outputFile = TestData.temp(this, "writetest.tif", false);
outputFile.deleteOnExit();
final File inputFile = TestData.file(this, "paletted.tif");
ImageReader reader = new GeoTiffImageReaderSpi().createReaderInstance();
reader.setInput(inputFile);
final IIOMetadata metadata = reader.getImageMetadata(0);
final ParameterBlockJAI pbjImageRead = new ParameterBlockJAI("ImageRead");
pbjImageRead.setParameter("Input", inputFile);
pbjImageRead.setParameter("reader", reader);
final ImageLayout l = new ImageLayout();
l.setTileGridXOffset(0).setTileGridYOffset(0).setTileHeight(256).setTileWidth(256);
RenderedOp image =
JAI.create("ImageRead", pbjImageRead, new RenderingHints(JAI.KEY_IMAGE_LAYOUT, l));
if (TestData.isInteractiveTest()) Viewer.visualizeAllInformation(image, "Paletted image read");
// ////////////////////////////////////////////////////////////////
// preparing to write
// ////////////////////////////////////////////////////////////////
final ParameterBlockJAI pbjImageWrite = new ParameterBlockJAI("ImageWrite");
ImageWriter writer = new GeoTiffImageWriterSpi().createWriterInstance();
pbjImageWrite.setParameter("Output", outputFile);
pbjImageWrite.setParameter("writer", writer);
pbjImageWrite.setParameter("ImageMetadata", metadata);
pbjImageWrite.setParameter("Transcode", false);
pbjImageWrite.addSource(image);
final RenderedOp op = JAI.create("ImageWrite", pbjImageWrite);
final ImageWriter writer2 =
(ImageWriter) op.getProperty(ImageWriteDescriptor.PROPERTY_NAME_IMAGE_WRITER);
writer2.dispose();
// ////////////////////////////////////////////////////////////////
// preparing to read again
// ////////////////////////////////////////////////////////////////
final ParameterBlockJAI pbjImageReRead = new ParameterBlockJAI("ImageRead");
pbjImageReRead.setParameter("Input", outputFile);
pbjImageReRead.setParameter("Reader", new GeoTiffImageReaderSpi().createReaderInstance());
final RenderedOp image2 = JAI.create("ImageRead", pbjImageReRead);
if (TestData.isInteractiveTest())
Viewer.visualizeAllInformation(image2, "Paletted image read back after writing");
else Assert.assertNotNull(image2.getTiles());
ImageIOUtilities.disposeImage(image2);
ImageIOUtilities.disposeImage(image);
}
/**
* Collect georeferencing information about this geotiff.
*
* @param hints
* @throws DataSourceException
*/
private void getHRInfo(Hints hints) throws DataSourceException {
ImageReader reader = null;
ImageReader ovrReader = null;
ImageInputStream ovrStream = null;
try {
// //
//
// Get a reader for this format
//
// //
reader = READER_SPI.createReaderInstance();
// //
//
// get the METADATA
//
// //
inStream.mark();
reader.setInput(inStream);
final IIOMetadata iioMetadata = reader.getImageMetadata(0);
final GeoTiffIIOMetadataDecoder metadata = new GeoTiffIIOMetadataDecoder(iioMetadata);
gtcs = new GeoTiffMetadata2CRSAdapter(hints);
// //
//
// get the CRS INFO
//
// //
final Object tempCRS = this.hints.get(Hints.DEFAULT_COORDINATE_REFERENCE_SYSTEM);
if (tempCRS != null) {
this.crs = (CoordinateReferenceSystem) tempCRS;
if (LOGGER.isLoggable(Level.FINE))
LOGGER.log(Level.FINE, "Using forced coordinate reference system");
} else {
// check external prj first
crs = getCRS(source);
// now, if we did not want to override the inner CRS or we did not have any external PRJ at
// hand
// let's look inside the geotiff
if (!OVERRIDE_INNER_CRS || crs == null) {
if (metadata.hasGeoKey() && gtcs != null) {
crs = gtcs.createCoordinateSystem(metadata);
}
}
}
//
// No data
//
if (metadata.hasNoData()) {
noData = metadata.getNoData();
}
//
// parse and set layout
//
setLayout(reader);
// //
//
// get the dimension of the hr image and build the model as well as
// computing the resolution
// //
numOverviews = reader.getNumImages(true) - 1;
int hrWidth = reader.getWidth(0);
int hrHeight = reader.getHeight(0);
final Rectangle actualDim = new Rectangle(0, 0, hrWidth, hrHeight);
originalGridRange = new GridEnvelope2D(actualDim);
if (gtcs != null
&& metadata != null
&& (metadata.hasModelTrasformation()
|| (metadata.hasPixelScales() && metadata.hasTiePoints()))) {
this.raster2Model = GeoTiffMetadata2CRSAdapter.getRasterToModel(metadata);
} else {
// world file
this.raster2Model = parseWorldFile(source);
// now world file --> mapinfo?
if (raster2Model == null) {
MapInfoFileReader mifReader = parseMapInfoFile(source);
if (mifReader != null) {
raster2Model = mifReader.getTransform();
crs = mifReader.getCRS();
}
}
}
if (crs == null) {
if (LOGGER.isLoggable(Level.WARNING)) {
LOGGER.warning("Coordinate Reference System is not available");
}
crs = AbstractGridFormat.getDefaultCRS();
}
if (this.raster2Model == null) {
TiePoint[] modelTiePoints = metadata.getModelTiePoints();
if (modelTiePoints != null && modelTiePoints.length > 1) {
// use a unit transform and expose the GCPs
gcps = new GroundControlPoints(Arrays.asList(modelTiePoints), crs);
raster2Model = ProjectiveTransform.create(new AffineTransform());
crs = AbstractGridFormat.getDefaultCRS();
} else {
throw new DataSourceException("Raster to Model Transformation is not available");
}
}
// create envelope using corner transformation
final AffineTransform tempTransform = new AffineTransform((AffineTransform) raster2Model);
tempTransform.concatenate(CoverageUtilities.CENTER_TO_CORNER);
originalEnvelope =
CRS.transform(ProjectiveTransform.create(tempTransform), new GeneralEnvelope(actualDim));
originalEnvelope.setCoordinateReferenceSystem(crs);
// ///
//
// setting the higher resolution available for this coverage
//
// ///
highestRes = new double[2];
highestRes[0] = XAffineTransform.getScaleX0(tempTransform);
highestRes[1] = XAffineTransform.getScaleY0(tempTransform);
if (ovrInStreamSPI != null) {
ovrReader = READER_SPI.createReaderInstance();
ovrStream =
ovrInStreamSPI.createInputStreamInstance(
ovrSource, ImageIO.getUseCache(), ImageIO.getCacheDirectory());
ovrReader.setInput(ovrStream);
// this includes the real image as this is a image index, we need to add one.
extOvrImgChoice = numOverviews + 1;
numOverviews = numOverviews + ovrReader.getNumImages(true);
if (numOverviews < extOvrImgChoice) extOvrImgChoice = -1;
}
// //
//
// get information for the successive images
//
// //
if (numOverviews >= 1) {
overViewResolutions = new double[numOverviews][2];
// Internal overviews start at 1, so lastInternalOverview matches numOverviews if no
// external.
int firstExternalOverview = extOvrImgChoice == -1 ? numOverviews : extOvrImgChoice - 1;
double spanRes0 = highestRes[0] * this.originalGridRange.getSpan(0);
double spanRes1 = highestRes[1] * this.originalGridRange.getSpan(1);
for (int i = 0; i < firstExternalOverview; i++) {
overViewResolutions[i][0] = spanRes0 / reader.getWidth(i + 1);
overViewResolutions[i][1] = spanRes1 / reader.getHeight(i + 1);
}
for (int i = firstExternalOverview; i < numOverviews; i++) {
overViewResolutions[i][0] = spanRes0 / ovrReader.getWidth(i - firstExternalOverview);
overViewResolutions[i][1] = spanRes1 / ovrReader.getHeight(i - firstExternalOverview);
}
} else overViewResolutions = null;
} catch (Throwable e) {
throw new DataSourceException(e);
} finally {
if (reader != null)
try {
reader.dispose();
} catch (Throwable t) {
}
if (ovrReader != null)
try {
ovrReader.dispose();
} catch (Throwable t) {
}
if (ovrStream != null)
try {
ovrStream.close();
} catch (Throwable t) {
}
if (inStream != null)
try {
inStream.reset();
} catch (Throwable t) {
}
}
}
private static JSONObject getResultJson(File file, boolean extractLiveProject)
throws IOException, JSONException, ScriptException {
final JSONObject result = new JSONObject();
result.put("formatChecked", true);
final ImageInputStream iis = ImageIO.createImageInputStream(file);
final Iterator<ImageReader> iterator = ImageIO.getImageReaders(iis);
if (!iterator.hasNext()) {
result.put("rejected", true);
result.put("message", "Unknown image format: can't create an ImageInputStream");
return result;
}
final ImageReader reader = iterator.next();
final JSONObject imageType = SimagisLiveUtils.openObject(result, "imageType");
try {
reader.setInput(iis);
JSONObject formatSpecific = new JSONObject();
formatSpecific.put("javaFormatType", "DICOM");
formatSpecific.put("javaFormatName", reader.getFormatName());
result.put("formatSpecific", formatSpecific);
final int dimX = reader.getWidth(0);
final int dimY = reader.getHeight(0);
if ((long) dimX * (long) dimY >= 512L * 1024L * 1024L) {
result.put("rejected", true);
result.put("message", "Too large image (more than 512 million pixels)");
return result;
// We are little reinsuring here: Java API can try to create a single byte[]
// or short[] array with packed RGB triples (3 * dimX * dimY), and we would like
// to be sure that its size will be far from the Java language limit 2 GB.
}
result.put("dimX", dimX);
result.put("dimY", dimY);
final Iterator<ImageTypeSpecifier> iioImageTypes = reader.getImageTypes(0);
if (iioImageTypes != null && iioImageTypes.hasNext()) {
// some 3rd party implementation can still return null here, though it is prohibited in
// JavaDoc
ImageTypeSpecifier imageTypeSpecifier = iioImageTypes.next();
imageType.put("numComponents", imageTypeSpecifier.getNumComponents());
imageType.put("numBands", imageTypeSpecifier.getNumBands());
if (imageTypeSpecifier.getNumComponents() >= 4) {
result.put("recommendedRenderingFormat", "png");
}
}
final IIOMetadata streamMetadata = reader.getStreamMetadata();
final IIOMetadataToJsonConverter converter = new IIOMetadataToJsonConverter();
if (streamMetadata != null) {
DICOMImageIOMetadata imageIOMetadata = DICOMImageIOMetadata.getInstance(streamMetadata, 0);
if (imageIOMetadata != null) {
result.put("DICOMMetadata", new JSONObject(imageIOMetadata));
}
result.put("streamMetadata", converter.toJson(streamMetadata));
}
final IIOMetadata imageMetadata = reader.getImageMetadata(0);
if (imageMetadata != null) {
result.put("imageMetadata", converter.toJson(imageMetadata));
}
} finally {
reader.dispose();
iis.close();
}
if (extractLiveProject) {
JSONObject liveProject = extractLiveProject(result);
result.put("liveProject", liveProject);
result.remove("imageMetadata");
result.remove("streamMetadata");
}
result.put("rejected", false);
return result;
}
