import org.geotools.geometry.GeneralEnvelope; //导入依赖的package包/类
@Override
public GeneralEnvelope getOriginalEnvelope(
		final String coverageName ) {
	final DataStatistics<?> statistics = geowaveStatisticsStore.getDataStatistics(
			new ByteArrayId(
					coverageName),
			BoundingBoxDataStatistics.STATS_TYPE,
			authorizationSPI.getAuthorizations());
	// try to use both the bounding box and the overview statistics to
	// determine the width and height at the highest resolution
	if (statistics instanceof BoundingBoxDataStatistics) {
		final BoundingBoxDataStatistics<?> bboxStats = (BoundingBoxDataStatistics<?>) statistics;
		final GeneralEnvelope env = new GeneralEnvelope(
				new Rectangle2D.Double(
						bboxStats.getMinX(),
						bboxStats.getMinY(),
						bboxStats.getWidth(),
						bboxStats.getHeight()));
		env.setCoordinateReferenceSystem(GeoWaveGTRasterFormat.DEFAULT_CRS);
		return env;
	}
	return null;
}
 

import org.geotools.geometry.GeneralEnvelope; //导入依赖的package包/类
private CloseableIterator<GridCoverage> queryForTiles(
		final Rectangle pixelDimension,
		final GeneralEnvelope requestEnvelope,
		final double levelResX,
		final double levelResY,
		final RasterDataAdapter adapter )
		throws IOException {
	return queryForTiles(
			adapter,
			new IndexOnlySpatialQuery(
					new GeometryFactory().toGeometry(new Envelope(
							requestEnvelope.getMinimum(0),
							requestEnvelope.getMaximum(0),
							requestEnvelope.getMinimum(1),
							requestEnvelope.getMaximum(1)))),
			new double[] {
				levelResX * adapter.getTileSize(),
				levelResY * adapter.getTileSize()
			});
}
 

import org.geotools.geometry.GeneralEnvelope; //导入依赖的package包/类
public FT_Coverage cropEnvelope(Envelope env) {
  GridCoverage2D coverage = this.coverage();
  final CoverageProcessor processor = new CoverageProcessor();
  final ParameterValueGroup param = processor.getOperation("CoverageCrop")
      .getParameters();

  final GeneralEnvelope cropEnv = new GeneralEnvelope(env);
  param.parameter("Source").setValue(coverage);
  param.parameter("Envelope").setValue(cropEnv);
  GridCoverage2D cropped = (GridCoverage2D) processor.doOperation(param);
  return new FT_Coverage(cropped);

}
 

import org.geotools.geometry.GeneralEnvelope; //导入依赖的package包/类
public GridCoverage2D renderGridCoverage(
		final String coverageName,
		final Rectangle dim,
		final GeneralEnvelope generalEnvelope,
		Color backgroundColor,
		Color outputTransparentColor,
		final Interpolation interpolation )
		throws IOException {
	if (backgroundColor == null) {
		backgroundColor = AbstractGridFormat.BACKGROUND_COLOR.getDefaultValue();
	}
	if (outputTransparentColor == null) {
		outputTransparentColor = GeoWaveGTRasterFormat.OUTPUT_TRANSPARENT_COLOR.getDefaultValue();
	}

	final GeoWaveRasterReaderState state = new GeoWaveRasterReaderState(
			coverageName);
	state.setRequestedEnvelope(generalEnvelope);
	// /////////////////////////////////////////////////////////////////////
	//
	// Loading tiles trying to optimize as much as possible
	//
	// /////////////////////////////////////////////////////////////////////
	final GridCoverage2D coverage = loadTiles(
			coverageName,
			backgroundColor,
			outputTransparentColor,
			interpolation,
			dim,
			state,
			crs,
			getOriginalEnvelope(coverageName));

	return coverage;
}
 

import org.geotools.geometry.GeneralEnvelope; //导入依赖的package包/类
private static org.opengis.geometry.Envelope getIntersection(
		final org.opengis.geometry.Envelope originalEnvelope,
		final org.opengis.geometry.Envelope indexedEnvelope ) {
	if (originalEnvelope == null) {
		return indexedEnvelope;
	}
	if (indexedEnvelope == null) {
		return originalEnvelope;
	}
	final int dimensions = originalEnvelope.getDimension();
	final double[] minDP = new double[dimensions];
	final double[] maxDP = new double[dimensions];
	for (int d = 0; d < dimensions; d++) {
		// to perform the intersection of the original envelope and the
		// indexed envelope, use the max of the mins per dimension and the
		// min of the maxes
		minDP[d] = Math.max(
				originalEnvelope.getMinimum(d),
				indexedEnvelope.getMinimum(d));
		maxDP[d] = Math.min(
				originalEnvelope.getMaximum(d),
				indexedEnvelope.getMaximum(d));
	}
	return new GeneralEnvelope(
			minDP,
			maxDP);
}
 

import org.geotools.geometry.GeneralEnvelope; //导入依赖的package包/类
protected void addSource( File imageMosaicSource ) throws IOException {

        URL imageMosaicUrl = imageMosaicSource.toURI().toURL();
        final AbstractGridFormat imageMosaicFormat = (AbstractGridFormat) GridFormatFinder.findFormat(imageMosaicUrl);
        final ImageMosaicReader imReader = (ImageMosaicReader) imageMosaicFormat.getReader(imageMosaicUrl);
        // ImageMosaicReader imReader = new ImageMosaicReader(imageMosaicSource);

        if (readers.size() == 0) {
            File propertiesFile = FileUtilities.substituteExtention(imageMosaicSource, "properties");
            HashMap<String, String> propertiesMap = FileUtilities
                    .readFileToHashMap(propertiesFile.getAbsolutePath(), null, false);

            String xyREs = propertiesMap.get("Levels");
            String[] split = xyREs.split(",");
            xRes = Double.parseDouble(split[0]);
            yRes = Double.parseDouble(split[1]);

            locationField = propertiesMap.get("LocationAttribute");
            crs = imReader.getCoordinateReferenceSystem();

            GeneralEnvelope originalEnvelope = imReader.getOriginalEnvelope();
            llCorner = originalEnvelope.getLowerCorner().getCoordinate();
            urCorner = originalEnvelope.getUpperCorner().getCoordinate();

            SimpleFeatureCollection vectorBounds = OmsVectorReader.readVector(imageMosaicSource.getAbsolutePath());
            boundsGeometries = FeatureUtilities.featureCollectionToGeometriesList(vectorBounds, true, locationField);

            Envelope singleTileEnv = boundsGeometries.get(0).getEnvelopeInternal();
            Envelope allTilesEnv = new Envelope();
            for( Geometry boundsGeometry : boundsGeometries ) {
                allTilesEnv.expandToInclude(boundsGeometry.getEnvelopeInternal());
            }
            if (allTilesEnv.getWidth() > singleTileEnv.getWidth()) {
                isSingleInX = false;
            }
            if (allTilesEnv.getHeight() > singleTileEnv.getHeight()) {
                isSingleInY = false;
            }

        }
        readers.add(imReader);
    }
 

import org.geotools.geometry.GeneralEnvelope; //导入依赖的package包/类
/**
 * transforms (if necessary) the requested envelope into the CRS used by
 * this reader.
 *
 * @throws DataSourceException
 */
public static void transformRequestEnvelope(
		final GeoWaveRasterReaderState state,
		final CoordinateReferenceSystem crs )
		throws DataSourceException {

	if (CRS.equalsIgnoreMetadata(
			state.getRequestedEnvelope().getCoordinateReferenceSystem(),
			crs)) {
		state.setRequestEnvelopeXformed(state.getRequestedEnvelope());

		return; // and finish
	}

	try {
		/** Buffered factory for coordinate operations. */

		// transforming the envelope back to the dataset crs in
		final MathTransform transform = OPERATION_FACTORY.createOperation(
				state.getRequestedEnvelope().getCoordinateReferenceSystem(),
				crs).getMathTransform();

		if (transform.isIdentity()) { // Identity Transform ?
			state.setRequestEnvelopeXformed(state.getRequestedEnvelope());
			return; // and finish
		}

		state.setRequestEnvelopeXformed(CRS.transform(
				transform,
				state.getRequestedEnvelope()));
		state.getRequestEnvelopeXformed().setCoordinateReferenceSystem(
				crs);

		// if (config.getIgnoreAxisOrder() == false) { // check for axis
		// order
		// required
		final int indexX = indexOfX(crs);
		final int indexY = indexOfY(crs);
		final int indexRequestedX = indexOfX(state.getRequestedEnvelope().getCoordinateReferenceSystem());
		final int indexRequestedY = indexOfY(state.getRequestedEnvelope().getCoordinateReferenceSystem());

		// x Axis problem ???
		if ((indexX == indexRequestedY) && (indexY == indexRequestedX)) {
			state.setAxisSwap(true);
			final Rectangle2D tmp = new Rectangle2D.Double(
					state.getRequestEnvelopeXformed().getMinimum(
							1),
					state.getRequestEnvelopeXformed().getMinimum(
							0),
					state.getRequestEnvelopeXformed().getSpan(
							1),
					state.getRequestEnvelopeXformed().getSpan(
							0));
			state.setRequestEnvelopeXformed(new GeneralEnvelope(
					tmp));
			state.getRequestEnvelopeXformed().setCoordinateReferenceSystem(
					crs);
		}
		else if ((indexX == indexRequestedX) && (indexY == indexRequestedY)) {
			// everything is fine
		}
		else {
			throw new DataSourceException(
					"Unable to resolve the X Axis problem");
		}
		// }
	}
	catch (final Exception e) {
		throw new DataSourceException(
				"Unable to create a coverage for this source",
				e);
	}
}
 

import org.geotools.geometry.GeneralEnvelope; //导入依赖的package包/类
/**
 * @return the requestedEnvelope
 */
public GeneralEnvelope getRequestedEnvelope() {
	return requestedEnvelope;
}
 

import org.geotools.geometry.GeneralEnvelope; //导入依赖的package包/类
/**
 * @param requestedEnvelope
 *            the requestedEnvelope to set
 */
public void setRequestedEnvelope(
		GeneralEnvelope requestedEnvelope ) {
	this.requestedEnvelope = requestedEnvelope;
}
 

import org.geotools.geometry.GeneralEnvelope; //导入依赖的package包/类
/**
 * @return the requestEnvelopeXformed
 */
public GeneralEnvelope getRequestEnvelopeXformed() {
	return requestEnvelopeXformed;
}
 

import org.geotools.geometry.GeneralEnvelope; //导入依赖的package包/类
/**
 * @param requestEnvelopeXformed
 *            the requestEnvelopeXformed to set
 */
public void setRequestEnvelopeXformed(
		GeneralEnvelope requestEnvelopeXformed ) {
	this.requestEnvelopeXformed = requestEnvelopeXformed;
}