GranuleOverviewLevelDescriptor getLevel(final int index) {
// load level
// create the base grid to world transformation
ImageInputStream inStream = null;
ImageReader reader = null;
try {
// get a stream
assert cachedStreamSPI != null : "no cachedStreamSPI available!";
inStream =
cachedStreamSPI.createInputStreamInstance(
granuleUrl, ImageIO.getUseCache(), ImageIO.getCacheDirectory());
if (inStream == null)
throw new IllegalArgumentException(
"Unable to create an inputstream for the granuleurl:"
+ (granuleUrl != null ? granuleUrl : "null"));
// get a reader and try to cache the relevant SPI
if (cachedReaderSPI == null) {
reader = ImageIOExt.getImageioReader(inStream);
if (reader != null) cachedReaderSPI = reader.getOriginatingProvider();
} else reader = cachedReaderSPI.createReaderInstance();
if (reader == null)
throw new IllegalArgumentException(
"Unable to get an ImageReader for the provided file " + granuleUrl.toString());
reader.setInput(inStream);
// call internal method which will close everything
return getLevel(index, reader);
} catch (IllegalStateException e) {
// clean up
try {
if (inStream != null) inStream.close();
} catch (Throwable ee) {
} finally {
if (reader != null) reader.dispose();
}
throw new IllegalArgumentException(e);
} catch (IOException e) {
// clean up
try {
if (inStream != null) inStream.close();
} catch (Throwable ee) {
} finally {
if (reader != null) reader.dispose();
}
throw new IllegalArgumentException(e);
}
}
static {
final Iterator<ImageReader> imageReaders = ImageIO.getImageReadersByFormatName("png");
if (!imageReaders.hasNext()) {
throw new SolrException(
SolrException.ErrorCode.SERVER_ERROR,
"Can't find png image reader, neaded for heatmaps!");
}
ImageReader imageReader = imageReaders.next();
imageReaderSpi = imageReader.getOriginatingProvider();
}
/** @see org.geotools.data.coverage.grid.AbstractGridFormat#accepts(java.lang.Object input) */
@Override
public boolean accepts(Object input, Hints hints) {
try {
// Directories aren't accepted
if (input != null && input instanceof File) {
final File directory = (File) input;
if (!directory.exists() || directory.isDirectory()) return false;
}
final ImageInputStream stream = ImageIO.createImageInputStream(input);
if (spi == null) {
ImageReader reader = Utils.getReader(stream);
if (reader != null) spi = reader.getOriginatingProvider();
else return false;
}
return spi.canDecodeInput(stream);
} catch (IOException e) {
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE, e.getLocalizedMessage(), e);
}
return false;
}
}
/**
* Load a specified a raster as a portion of the granule describe by this {@link
* GranuleDescriptor}.
*
* @param imageReadParameters the {@link ImageReadParam} to use for reading.
* @param index the index to use for the {@link ImageReader}.
* @param cropBBox the bbox to use for cropping.
* @param mosaicWorldToGrid the cropping grid to world transform.
* @param request the incoming request to satisfy.
* @param hints {@link Hints} to be used for creating this raster.
* @return a specified a raster as a portion of the granule describe by this {@link
* GranuleDescriptor}.
* @throws IOException in case an error occurs.
*/
public GranuleLoadingResult loadRaster(
final ImageReadParam imageReadParameters,
final int index,
final ReferencedEnvelope cropBBox,
final MathTransform2D mosaicWorldToGrid,
final RasterLayerRequest request,
final Hints hints)
throws IOException {
if (LOGGER.isLoggable(java.util.logging.Level.FINER)) {
final String name = Thread.currentThread().getName();
LOGGER.finer(
"Thread:" + name + " Loading raster data for granuleDescriptor " + this.toString());
}
ImageReadParam readParameters = null;
int imageIndex;
final ReferencedEnvelope bbox =
inclusionGeometry != null
? new ReferencedEnvelope(
granuleBBOX.intersection(inclusionGeometry.getEnvelopeInternal()),
granuleBBOX.getCoordinateReferenceSystem())
: granuleBBOX;
boolean doFiltering = false;
if (filterMe) {
doFiltering = Utils.areaIsDifferent(inclusionGeometry, baseGridToWorld, granuleBBOX);
}
// intersection of this tile bound with the current crop bbox
final ReferencedEnvelope intersection =
new ReferencedEnvelope(
bbox.intersection(cropBBox), cropBBox.getCoordinateReferenceSystem());
if (intersection.isEmpty()) {
if (LOGGER.isLoggable(java.util.logging.Level.FINE)) {
LOGGER.fine(
new StringBuilder("Got empty intersection for granule ")
.append(this.toString())
.append(" with request ")
.append(request.toString())
.append(" Resulting in no granule loaded: Empty result")
.toString());
}
return null;
}
ImageInputStream inStream = null;
ImageReader reader = null;
try {
//
// get info about the raster we have to read
//
// get a stream
assert cachedStreamSPI != null : "no cachedStreamSPI available!";
inStream =
cachedStreamSPI.createInputStreamInstance(
granuleUrl, ImageIO.getUseCache(), ImageIO.getCacheDirectory());
if (inStream == null) return null;
// get a reader and try to cache the relevant SPI
if (cachedReaderSPI == null) {
reader = ImageIOExt.getImageioReader(inStream);
if (reader != null) cachedReaderSPI = reader.getOriginatingProvider();
} else reader = cachedReaderSPI.createReaderInstance();
if (reader == null) {
if (LOGGER.isLoggable(java.util.logging.Level.WARNING)) {
LOGGER.warning(
new StringBuilder("Unable to get s reader for granuleDescriptor ")
.append(this.toString())
.append(" with request ")
.append(request.toString())
.append(" Resulting in no granule loaded: Empty result")
.toString());
}
return null;
}
// set input
reader.setInput(inStream);
// Checking for heterogeneous granules
if (request.isHeterogeneousGranules()) {
// create read parameters
readParameters = new ImageReadParam();
// override the overviews controller for the base layer
imageIndex =
ReadParamsController.setReadParams(
request.getRequestedResolution(),
request.getOverviewPolicy(),
request.getDecimationPolicy(),
readParameters,
request.rasterManager,
overviewsController);
} else {
imageIndex = index;
readParameters = imageReadParameters;
}
// get selected level and base level dimensions
final GranuleOverviewLevelDescriptor selectedlevel = getLevel(imageIndex, reader);
// now create the crop grid to world which can be used to decide
// which source area we need to crop in the selected level taking
// into account the scale factors imposed by the selection of this
// level together with the base level grid to world transformation
AffineTransform2D cropWorldToGrid =
new AffineTransform2D(selectedlevel.gridToWorldTransformCorner);
cropWorldToGrid = (AffineTransform2D) cropWorldToGrid.inverse();
// computing the crop source area which lives into the
// selected level raster space, NOTICE that at the end we need to
// take into account the fact that we might also decimate therefore
// we cannot just use the crop grid to world but we need to correct
// it.
final Rectangle sourceArea =
CRS.transform(cropWorldToGrid, intersection).toRectangle2D().getBounds();
// gutter
if (selectedlevel.baseToLevelTransform.isIdentity()) sourceArea.grow(2, 2);
XRectangle2D.intersect(
sourceArea,
selectedlevel.rasterDimensions,
sourceArea); // make sure roundings don't bother us
// is it empty??
if (sourceArea.isEmpty()) {
if (LOGGER.isLoggable(java.util.logging.Level.FINE)) {
LOGGER.fine(
"Got empty area for granuleDescriptor "
+ this.toString()
+ " with request "
+ request.toString()
+ " Resulting in no granule loaded: Empty result");
}
return null;
} else if (LOGGER.isLoggable(java.util.logging.Level.FINER)) {
LOGGER.finer(
"Loading level "
+ imageIndex
+ " with source region: "
+ sourceArea
+ " subsampling: "
+ readParameters.getSourceXSubsampling()
+ ","
+ readParameters.getSourceYSubsampling()
+ " for granule:"
+ granuleUrl);
}
// Setting subsampling
int newSubSamplingFactor = 0;
final String pluginName = cachedReaderSPI.getPluginClassName();
if (pluginName != null && pluginName.equals(ImageUtilities.DIRECT_KAKADU_PLUGIN)) {
final int ssx = readParameters.getSourceXSubsampling();
final int ssy = readParameters.getSourceYSubsampling();
newSubSamplingFactor = ImageIOUtilities.getSubSamplingFactor2(ssx, ssy);
if (newSubSamplingFactor != 0) {
if (newSubSamplingFactor > maxDecimationFactor && maxDecimationFactor != -1) {
newSubSamplingFactor = maxDecimationFactor;
}
readParameters.setSourceSubsampling(newSubSamplingFactor, newSubSamplingFactor, 0, 0);
}
}
// set the source region
readParameters.setSourceRegion(sourceArea);
final RenderedImage raster;
try {
// read
raster =
request
.getReadType()
.read(
readParameters,
imageIndex,
granuleUrl,
selectedlevel.rasterDimensions,
reader,
hints,
false);
} catch (Throwable e) {
if (LOGGER.isLoggable(java.util.logging.Level.FINE)) {
LOGGER.log(
java.util.logging.Level.FINE,
"Unable to load raster for granuleDescriptor "
+ this.toString()
+ " with request "
+ request.toString()
+ " Resulting in no granule loaded: Empty result",
e);
}
return null;
}
// use fixed source area
sourceArea.setRect(readParameters.getSourceRegion());
//
// setting new coefficients to define a new affineTransformation
// to be applied to the grid to world transformation
// -----------------------------------------------------------------------------------
//
// With respect to the original envelope, the obtained planarImage
// needs to be rescaled. The scaling factors are computed as the
// ratio between the cropped source region sizes and the read
// image sizes.
//
// place it in the mosaic using the coords created above;
double decimationScaleX = ((1.0 * sourceArea.width) / raster.getWidth());
double decimationScaleY = ((1.0 * sourceArea.height) / raster.getHeight());
final AffineTransform decimationScaleTranform =
XAffineTransform.getScaleInstance(decimationScaleX, decimationScaleY);
// keep into account translation to work into the selected level raster space
final AffineTransform afterDecimationTranslateTranform =
XAffineTransform.getTranslateInstance(sourceArea.x, sourceArea.y);
// now we need to go back to the base level raster space
final AffineTransform backToBaseLevelScaleTransform = selectedlevel.baseToLevelTransform;
// now create the overall transform
final AffineTransform finalRaster2Model = new AffineTransform(baseGridToWorld);
finalRaster2Model.concatenate(CoverageUtilities.CENTER_TO_CORNER);
final double x = finalRaster2Model.getTranslateX();
final double y = finalRaster2Model.getTranslateY();
if (!XAffineTransform.isIdentity(backToBaseLevelScaleTransform, Utils.AFFINE_IDENTITY_EPS))
finalRaster2Model.concatenate(backToBaseLevelScaleTransform);
if (!XAffineTransform.isIdentity(afterDecimationTranslateTranform, Utils.AFFINE_IDENTITY_EPS))
finalRaster2Model.concatenate(afterDecimationTranslateTranform);
if (!XAffineTransform.isIdentity(decimationScaleTranform, Utils.AFFINE_IDENTITY_EPS))
finalRaster2Model.concatenate(decimationScaleTranform);
// keep into account translation factors to place this tile
finalRaster2Model.preConcatenate((AffineTransform) mosaicWorldToGrid);
final Interpolation interpolation = request.getInterpolation();
// paranoiac check to avoid that JAI freaks out when computing its internal layouT on images
// that are too small
Rectangle2D finalLayout =
ImageUtilities.layoutHelper(
raster,
(float) finalRaster2Model.getScaleX(),
(float) finalRaster2Model.getScaleY(),
(float) finalRaster2Model.getTranslateX(),
(float) finalRaster2Model.getTranslateY(),
interpolation);
if (finalLayout.isEmpty()) {
if (LOGGER.isLoggable(java.util.logging.Level.INFO))
LOGGER.info(
"Unable to create a granuleDescriptor "
+ this.toString()
+ " due to jai scale bug creating a null source area");
return null;
}
ROI granuleLoadingShape = null;
if (granuleROIShape != null) {
final Point2D translate =
mosaicWorldToGrid.transform(new DirectPosition2D(x, y), (Point2D) null);
AffineTransform tx2 = new AffineTransform();
tx2.preConcatenate(
AffineTransform.getScaleInstance(
((AffineTransform) mosaicWorldToGrid).getScaleX(),
-((AffineTransform) mosaicWorldToGrid).getScaleY()));
tx2.preConcatenate(
AffineTransform.getScaleInstance(
((AffineTransform) baseGridToWorld).getScaleX(),
-((AffineTransform) baseGridToWorld).getScaleY()));
tx2.preConcatenate(
AffineTransform.getTranslateInstance(translate.getX(), translate.getY()));
granuleLoadingShape = (ROI) granuleROIShape.transform(tx2);
}
// apply the affine transform conserving indexed color model
final RenderingHints localHints =
new RenderingHints(
JAI.KEY_REPLACE_INDEX_COLOR_MODEL,
interpolation instanceof InterpolationNearest ? Boolean.FALSE : Boolean.TRUE);
if (XAffineTransform.isIdentity(finalRaster2Model, Utils.AFFINE_IDENTITY_EPS)) {
return new GranuleLoadingResult(raster, granuleLoadingShape, granuleUrl, doFiltering);
} else {
//
// In case we are asked to use certain tile dimensions we tile
// also at this stage in case the read type is Direct since
// buffered images comes up untiled and this can affect the
// performances of the subsequent affine operation.
//
final Dimension tileDimensions = request.getTileDimensions();
if (tileDimensions != null && request.getReadType().equals(ReadType.DIRECT_READ)) {
final ImageLayout layout = new ImageLayout();
layout.setTileHeight(tileDimensions.width).setTileWidth(tileDimensions.height);
localHints.add(new RenderingHints(JAI.KEY_IMAGE_LAYOUT, layout));
} else {
if (hints != null && hints.containsKey(JAI.KEY_IMAGE_LAYOUT)) {
final Object layout = hints.get(JAI.KEY_IMAGE_LAYOUT);
if (layout != null && layout instanceof ImageLayout) {
localHints.add(
new RenderingHints(JAI.KEY_IMAGE_LAYOUT, ((ImageLayout) layout).clone()));
}
}
}
if (hints != null && hints.containsKey(JAI.KEY_TILE_CACHE)) {
final Object cache = hints.get(JAI.KEY_TILE_CACHE);
if (cache != null && cache instanceof TileCache)
localHints.add(new RenderingHints(JAI.KEY_TILE_CACHE, (TileCache) cache));
}
if (hints != null && hints.containsKey(JAI.KEY_TILE_SCHEDULER)) {
final Object scheduler = hints.get(JAI.KEY_TILE_SCHEDULER);
if (scheduler != null && scheduler instanceof TileScheduler)
localHints.add(new RenderingHints(JAI.KEY_TILE_SCHEDULER, (TileScheduler) scheduler));
}
boolean addBorderExtender = true;
if (hints != null && hints.containsKey(JAI.KEY_BORDER_EXTENDER)) {
final Object extender = hints.get(JAI.KEY_BORDER_EXTENDER);
if (extender != null && extender instanceof BorderExtender) {
localHints.add(new RenderingHints(JAI.KEY_BORDER_EXTENDER, (BorderExtender) extender));
addBorderExtender = false;
}
}
// border extender
if (addBorderExtender) {
localHints.add(ImageUtilities.BORDER_EXTENDER_HINTS);
}
// boolean hasScaleX=!(Math.abs(finalRaster2Model.getScaleX()-1) <
// 1E-2/(raster.getWidth()+1-raster.getMinX()));
// boolean hasScaleY=!(Math.abs(finalRaster2Model.getScaleY()-1) <
// 1E-2/(raster.getHeight()+1-raster.getMinY()));
// boolean hasShearX=!(finalRaster2Model.getShearX() == 0.0);
// boolean hasShearY=!(finalRaster2Model.getShearY() == 0.0);
// boolean hasTranslateX=!(Math.abs(finalRaster2Model.getTranslateX()) <
// 0.01F);
// boolean hasTranslateY=!(Math.abs(finalRaster2Model.getTranslateY()) <
// 0.01F);
// boolean isTranslateXInt=!(Math.abs(finalRaster2Model.getTranslateX() -
// (int) finalRaster2Model.getTranslateX()) < 0.01F);
// boolean isTranslateYInt=!(Math.abs(finalRaster2Model.getTranslateY() -
// (int) finalRaster2Model.getTranslateY()) < 0.01F);
//
// boolean isIdentity = finalRaster2Model.isIdentity() &&
// !hasScaleX&&!hasScaleY &&!hasTranslateX&&!hasTranslateY;
// // TODO how can we check that the a skew is harmelss????
// if(isIdentity){
// // TODO check if we are missing anything like tiling or such that
// comes from hints
// return new GranuleLoadingResult(raster, granuleLoadingShape,
// granuleUrl, doFiltering);
// }
//
// // TOLERANCE ON PIXELS SIZE
//
// // Check and see if the affine transform is in fact doing
// // a Translate operation. That is a scale by 1 and no rotation.
// // In which case call translate. Note that only integer translate
// // is applicable. For non-integer translate we'll have to do the
// // affine.
// // If the hints contain an ImageLayout hint, we can't use
// // TranslateIntOpImage since it isn't capable of dealing with that.
// // Get ImageLayout from renderHints if any.
// ImageLayout layout = RIFUtil.getImageLayoutHint(localHints);
// if ( !hasScaleX &&
// !hasScaleY &&
// !hasShearX&&
// !hasShearY&&
// isTranslateXInt&&
// isTranslateYInt&&
// layout == null) {
// // It's a integer translate
// return new GranuleLoadingResult(new TranslateIntOpImage(raster,
// localHints,
// (int) finalRaster2Model.getShearX(),
// (int)
// finalRaster2Model.getShearY()),granuleLoadingShape, granuleUrl, doFiltering);
// }
ImageWorker iw = new ImageWorker(raster);
iw.setRenderingHints(localHints);
iw.affine(finalRaster2Model, interpolation, request.getBackgroundValues());
return new GranuleLoadingResult(
iw.getRenderedImage(), granuleLoadingShape, granuleUrl, doFiltering);
}
} catch (IllegalStateException e) {
if (LOGGER.isLoggable(java.util.logging.Level.WARNING)) {
LOGGER.log(
java.util.logging.Level.WARNING,
new StringBuilder("Unable to load raster for granuleDescriptor ")
.append(this.toString())
.append(" with request ")
.append(request.toString())
.append(" Resulting in no granule loaded: Empty result")
.toString(),
e);
}
return null;
} catch (org.opengis.referencing.operation.NoninvertibleTransformException e) {
if (LOGGER.isLoggable(java.util.logging.Level.WARNING)) {
LOGGER.log(
java.util.logging.Level.WARNING,
new StringBuilder("Unable to load raster for granuleDescriptor ")
.append(this.toString())
.append(" with request ")
.append(request.toString())
.append(" Resulting in no granule loaded: Empty result")
.toString(),
e);
}
return null;
} catch (TransformException e) {
if (LOGGER.isLoggable(java.util.logging.Level.WARNING)) {
LOGGER.log(
java.util.logging.Level.WARNING,
new StringBuilder("Unable to load raster for granuleDescriptor ")
.append(this.toString())
.append(" with request ")
.append(request.toString())
.append(" Resulting in no granule loaded: Empty result")
.toString(),
e);
}
return null;
} finally {
try {
if (request.getReadType() != ReadType.JAI_IMAGEREAD && inStream != null) {
inStream.close();
}
} finally {
if (request.getReadType() != ReadType.JAI_IMAGEREAD && reader != null) {
reader.dispose();
}
}
}
}
private void init(
final BoundingBox granuleBBOX,
final URL granuleUrl,
final ImageReaderSpi suggestedSPI,
final Geometry inclusionGeometry,
final boolean heterogeneousGranules,
final boolean handleArtifactsFiltering) {
this.granuleBBOX = ReferencedEnvelope.reference(granuleBBOX);
this.granuleUrl = granuleUrl;
this.inclusionGeometry = inclusionGeometry;
this.handleArtifactsFiltering = handleArtifactsFiltering;
filterMe = handleArtifactsFiltering && inclusionGeometry != null;
// create the base grid to world transformation
ImageInputStream inStream = null;
ImageReader reader = null;
try {
//
// get info about the raster we have to read
//
// get a stream
if (cachedStreamSPI == null) {
cachedStreamSPI = ImageIOExt.getImageInputStreamSPI(granuleUrl, true);
if (cachedStreamSPI == null) {
final File file = DataUtilities.urlToFile(granuleUrl);
if (file != null) {
if (LOGGER.isLoggable(Level.WARNING)) {
LOGGER.log(Level.WARNING, Utils.getFileInfo(file));
}
}
throw new IllegalArgumentException(
"Unable to get an input stream for the provided granule " + granuleUrl.toString());
}
}
assert cachedStreamSPI != null : "no cachedStreamSPI available!";
inStream =
cachedStreamSPI.createInputStreamInstance(
granuleUrl, ImageIO.getUseCache(), ImageIO.getCacheDirectory());
if (inStream == null) {
final File file = DataUtilities.urlToFile(granuleUrl);
if (file != null) {
if (LOGGER.isLoggable(Level.WARNING)) {
LOGGER.log(Level.WARNING, Utils.getFileInfo(file));
}
}
throw new IllegalArgumentException(
"Unable to get an input stream for the provided file " + granuleUrl.toString());
}
// get a reader and try to cache the suggested SPI first
if (cachedReaderSPI == null) {
inStream.mark();
if (suggestedSPI != null && suggestedSPI.canDecodeInput(inStream)) {
cachedReaderSPI = suggestedSPI;
inStream.reset();
} else {
inStream.mark();
reader = ImageIOExt.getImageioReader(inStream);
if (reader != null) cachedReaderSPI = reader.getOriginatingProvider();
inStream.reset();
}
}
reader = cachedReaderSPI.createReaderInstance();
if (reader == null)
throw new IllegalArgumentException(
"Unable to get an ImageReader for the provided file " + granuleUrl.toString());
reader.setInput(inStream);
// get selected level and base level dimensions
final Rectangle originalDimension = Utils.getDimension(0, reader);
// build the g2W for this tile, in principle we should get it
// somehow from the tile itself or from the index, but at the moment
// we do not have such info, hence we assume that it is a simple
// scale and translate
final GridToEnvelopeMapper geMapper =
new GridToEnvelopeMapper(new GridEnvelope2D(originalDimension), granuleBBOX);
geMapper.setPixelAnchor(
PixelInCell
.CELL_CENTER); // this is the default behavior but it is nice to write it down anyway
this.baseGridToWorld = geMapper.createAffineTransform();
try {
if (inclusionGeometry != null) {
geMapper.setPixelAnchor(PixelInCell.CELL_CORNER);
Geometry mapped = JTS.transform(inclusionGeometry, geMapper.createTransform().inverse());
this.granuleROIShape = new ROIGeometry(mapped);
}
} catch (TransformException e1) {
throw new IllegalArgumentException(e1);
}
// add the base level
this.granuleLevels.put(
Integer.valueOf(0),
new GranuleOverviewLevelDescriptor(
1, 1, originalDimension.width, originalDimension.height));
////////////////////// Setting overviewController ///////////////////////
if (heterogeneousGranules) {
// //
//
// Right now we are setting up overviewsController by assuming that
// overviews are internal images as happens in TIFF images
// We can improve this by leveraging on coverageReaders
//
// //
// Getting the first level descriptor
final GranuleOverviewLevelDescriptor baseOverviewLevelDescriptor = granuleLevels.get(0);
// Variables initialization
final int numberOfOvervies = reader.getNumImages(true) - 1;
final AffineTransform2D baseG2W = baseOverviewLevelDescriptor.getGridToWorldTransform();
final int width = baseOverviewLevelDescriptor.getWidth();
final int height = baseOverviewLevelDescriptor.getHeight();
final double resX = AffineTransform2D.getScaleX0(baseG2W);
final double resY = AffineTransform2D.getScaleY0(baseG2W);
final double[] highestRes = new double[] {resX, resY};
final double[][] overviewsResolution = new double[numberOfOvervies][2];
// Populating overviews and initializing overviewsController
for (int i = 0; i < numberOfOvervies; i++) {
overviewsResolution[i][0] = (highestRes[0] * width) / reader.getWidth(i + 1);
overviewsResolution[i][1] = (highestRes[1] * height) / reader.getWidth(i + 1);
}
overviewsController =
new OverviewsController(highestRes, numberOfOvervies, overviewsResolution);
}
//////////////////////////////////////////////////////////////////////////
} catch (IllegalStateException e) {
throw new IllegalArgumentException(e);
} catch (IOException e) {
throw new IllegalArgumentException(e);
} finally {
// close/dispose stream and readers
try {
if (inStream != null) {
inStream.close();
}
} catch (Throwable e) {
throw new IllegalArgumentException(e);
} finally {
if (reader != null) {
reader.dispose();
}
}
}
}