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);
}
 

private void readGrass( File mapFile ) throws Exception {
    JGrassMapEnvironment mapEnvironment = new JGrassMapEnvironment(new File(file));
    CoordinateReferenceSystem crs = mapEnvironment.getCoordinateReferenceSystem();
    JGrassRegion readRegion = mapEnvironment.getFileRegion();
    double n = readRegion.getNorth();
    double s = readRegion.getSouth();
    double w = readRegion.getWest();
    double e = readRegion.getEast();

    Envelope env = readRegion.getEnvelope();
    originalEnvelope = new GeneralEnvelope(
            new ReferencedEnvelope(env.getMinX(), env.getMaxX(), env.getMinY(), env.getMaxY(), crs));

    // if bounds supplied, use them as region
    if (pBounds != null) {
        // n, s, w, e
        n = pBounds[0];
        s = pBounds[1];
        w = pBounds[2];
        e = pBounds[3];
    }
    if (pRes != null) {
        readRegion = new JGrassRegion(w, e, s, n, pRes[0], pRes[1]);
    }
    if (pRowcol != null) {
        readRegion = new JGrassRegion(w, e, s, n, pRowcol[0], pRowcol[1]);
    }

    if (!doEnvelope) {
        if (generalParameter == null) {
            generalParameter = createGridGeometryGeneralParameter(readRegion.getCols(), readRegion.getRows(),
                    readRegion.getNorth(), readRegion.getSouth(), readRegion.getEast(), readRegion.getWest(), crs);
        }
        GrassCoverageFormat format = new GrassCoverageFormatFactory().createFormat();
        GrassCoverageReader reader = format.getReader(mapEnvironment.getCELL());
        outRaster = (GridCoverage2D) reader.read(generalParameter);
        checkNovalues();
    }
}
 

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,
          getCoordinateReferenceSystem(coverageName),
          getOriginalEnvelope(coverageName));

  return coverage;
}
 

private CloseableIterator<GridCoverage> queryForTiles(
    final Rectangle pixelDimension,
    final GeneralEnvelope requestEnvelope,
    final double levelResX,
    final double levelResY,
    final RasterDataAdapter adapter) throws IOException {
  final QueryConstraints query;
  if (requestEnvelope.getCoordinateReferenceSystem() != null) {
    query =
        new IndexOnlySpatialQuery(
            new GeometryFactory().toGeometry(
                new Envelope(
                    requestEnvelope.getMinimum(0),
                    requestEnvelope.getMaximum(0),
                    requestEnvelope.getMinimum(1),
                    requestEnvelope.getMaximum(1))),
            GeometryUtils.getCrsCode(requestEnvelope.getCoordinateReferenceSystem()));
  } else {
    query =
        new IndexOnlySpatialQuery(
            new GeometryFactory().toGeometry(
                new Envelope(
                    requestEnvelope.getMinimum(0),
                    requestEnvelope.getMaximum(0),
                    requestEnvelope.getMinimum(1),
                    requestEnvelope.getMaximum(1))));
  }
  return queryForTiles(
      adapter,
      query,
      new double[] {levelResX * adapter.getTileSize(), levelResY * adapter.getTileSize()});
}
 

protected void addSource( File imageMosaicSource ) throws Exception {

        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);
    }
 

@Override
public GeneralEnvelope getOriginalEnvelope() {
  throw new UnsupportedOperationException(
      "A coverage name must be provided, there is no support for a default coverage");
}
 

/**
 * 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);
  }
}
 

/** @return the requestedEnvelope */
public GeneralEnvelope getRequestedEnvelope() {
  return requestedEnvelope;
}
 

/** @param requestedEnvelope the requestedEnvelope to set */
public void setRequestedEnvelope(final GeneralEnvelope requestedEnvelope) {
  this.requestedEnvelope = requestedEnvelope;
}
 

/** @return the requestEnvelopeXformed */
public GeneralEnvelope getRequestEnvelopeXformed() {
  return requestEnvelopeXformed;
}
 

/** @param requestEnvelopeXformed the requestEnvelopeXformed to set */
public void setRequestEnvelopeXformed(final GeneralEnvelope requestEnvelopeXformed) {
  this.requestEnvelopeXformed = requestEnvelopeXformed;
}
 

@Test
public void testMosaic() throws Exception {

  // Skip this test if we're on a Mac
  org.junit.Assume.assumeTrue(isNotMac());

  JAIExt.initJAIEXT();
  MapProjection.SKIP_SANITY_CHECKS = true;
  // just use the QA band as QA is the smallest, get the best cloud cover,
  // but ensure it is before now so no recent collection affects the test
  final Landsat8BasicCommandLineOptions analyzeOptions = new Landsat8BasicCommandLineOptions();
  analyzeOptions.setCqlFilter(
      String.format(
          "BBOX(%s,%f,%f,%f,%f) AND %s='B4' AND %s <= '%s' AND path >= %d AND path <= %d AND row >= %d AND row <= %d",
          SceneFeatureIterator.SHAPE_ATTRIBUTE_NAME,
          WEST,
          SOUTH,
          EAST,
          NORTH,
          BandFeatureIterator.BAND_ATTRIBUTE_NAME,
          SceneFeatureIterator.ACQUISITION_DATE_ATTRIBUTE_NAME,
          "2016-06-01T00:00:00Z",
          MIN_PATH,
          MAX_PATH,
          MIN_ROW,
          MAX_ROW));
  analyzeOptions.setNBestPerSpatial(true);
  analyzeOptions.setNBestScenes(1);
  analyzeOptions.setUseCachedScenes(true);
  final Landsat8DownloadCommandLineOptions downloadOptions =
      new Landsat8DownloadCommandLineOptions();
  final Landsat8RasterIngestCommandLineOptions ingestOptions =
      new Landsat8RasterIngestCommandLineOptions();
  ingestOptions.setRetainImages(true);
  ingestOptions.setCreatePyramid(true);
  ingestOptions.setCreateHistogram(true);
  ingestOptions.setCoverageName("test");
  // crop to the specified bbox
  ingestOptions.setCropToSpatialConstraint(true);
  final RasterIngestTester runner =
      new RasterIngestTester(
          dataStoreOptions,
          analyzeOptions,
          downloadOptions,
          ingestOptions,
          null);
  runner.runInternal(null);

  final StringBuilder str =
      new StringBuilder(StoreFactoryOptions.GEOWAVE_NAMESPACE_OPTION).append("=").append(
          dataStoreOptions.getGeoWaveNamespace()).append(
              ";equalizeHistogramOverride=false;interpolationOverride=").append(
                  Interpolation.INTERP_NEAREST);

  str.append(";").append(GeoWaveStoreFinder.STORE_HINT_KEY).append("=").append(
      dataStoreOptions.getType());

  final Map<String, String> options = dataStoreOptions.getOptionsAsMap();

  for (final Entry<String, String> entry : options.entrySet()) {
    if (!entry.getKey().equals(StoreFactoryOptions.GEOWAVE_NAMESPACE_OPTION)) {
      str.append(";").append(entry.getKey()).append("=").append(entry.getValue());
    }
  }
  final GeneralEnvelope queryEnvelope =
      new GeneralEnvelope(new double[] {WEST, SOUTH}, new double[] {EAST, NORTH});
  queryEnvelope.setCoordinateReferenceSystem(GeometryUtils.getDefaultCRS());

  final GeoWaveRasterReader reader =
      new GeoWaveRasterReader(GeoWaveRasterConfig.readFromConfigParams(str.toString()));
  final GridCoverage2D gridCoverage =
      reader.renderGridCoverage(
          "test",
          new Rectangle(0, 0, 1024, 1024),
          queryEnvelope,
          null,
          null,
          null);
  final RenderedImage result = gridCoverage.getRenderedImage();

  // test the result with expected, allowing for minimal error
  final BufferedImage reference = ImageIO.read(new File(REFERENCE_LANDSAT_IMAGE_PATH));
  TestUtils.testTileAgainstReference(
      PlanarImage.wrapRenderedImage(result).getAsBufferedImage(),
      reference,
      0,
      0.005);
  MapProjection.SKIP_SANITY_CHECKS = false;
}
 

private double[][][] testSamplesMatch(
    final String coverageNamePrefix,
    final int numCoverages,
    final GeneralEnvelope queryEnvelope,
    final Rectangle pixelDimensions,
    double[][][] expectedResults) throws Exception {
  final StringBuilder str =
      new StringBuilder(StoreFactoryOptions.GEOWAVE_NAMESPACE_OPTION).append("=").append(
          TEST_COVERAGE_NAMESPACE).append(
              ";equalizeHistogramOverride=false;scaleTo8Bit=false;interpolationOverride=").append(
                  Interpolation.INTERP_NEAREST);

  str.append(";").append(GeoWaveStoreFinder.STORE_HINT_KEY).append("=").append(
      outputDataStorePluginOptions.getType());

  final Map<String, String> options = outputDataStorePluginOptions.getOptionsAsMap();

  for (final Entry<String, String> entry : options.entrySet()) {
    if (!entry.getKey().equals(StoreFactoryOptions.GEOWAVE_NAMESPACE_OPTION)) {
      str.append(";").append(entry.getKey()).append("=").append(entry.getValue());
    }
  }

  final GeoWaveRasterReader reader =
      new GeoWaveRasterReader(GeoWaveRasterConfig.readFromConfigParams(str.toString()));

  queryEnvelope.setCoordinateReferenceSystem(CRS.decode("EPSG:4166", true));
  final Raster[] rasters = new Raster[numCoverages];
  int coverageCount = 0;
  for (int i = MIN_TILE_SIZE_POWER_OF_2; i <= MAX_TILE_SIZE_POWER_OF_2; i += INCREMENT) {
    final String tileSizeCoverageName = coverageNamePrefix + i;
    final GridCoverage gridCoverage =
        reader.renderGridCoverage(
            tileSizeCoverageName,
            pixelDimensions,
            queryEnvelope,
            Color.BLACK,
            null,
            null);
    final RenderedImage image = gridCoverage.getRenderedImage();
    final Raster raster = image.getData();
    rasters[coverageCount++] = raster;
  }
  boolean atLeastOneResult = expectedResults != null;
  for (int i = 0; i < numCoverages; i++) {
    final boolean initialResults = expectedResults == null;
    if (initialResults) {
      expectedResults =
          new double[rasters[i].getWidth()][rasters[i].getHeight()][rasters[i].getNumBands()];
    } else {
      Assert.assertEquals(
          "The expected width does not match the expected width for the coverage " + i,
          expectedResults.length,
          rasters[i].getWidth());
      Assert.assertEquals(
          "The expected height does not match the expected height for the coverage " + i,
          expectedResults[0].length,
          rasters[i].getHeight());
      Assert.assertEquals(
          "The expected number of bands does not match the expected bands for the coverage " + i,
          expectedResults[0][0].length,
          rasters[i].getNumBands());
    }
    long mismatchedSamples = 0;
    for (int y = 0; y < rasters[i].getHeight(); y++) {
      for (int x = 0; x < rasters[i].getWidth(); x++) {
        for (int b = 0; b < rasters[i].getNumBands(); b++) {
          final double sample = rasters[i].getSampleDouble(x, y, b);
          if (initialResults) {
            expectedResults[x][y][b] = sample;
            if (!atLeastOneResult && (sample != 0)) {
              atLeastOneResult = true;
            }
          } else {
            if ((Double.isNaN(sample) && !Double.isNaN(expectedResults[x][y][b]))
                || (!Double.isNaN(sample) && Double.isNaN(expectedResults[x][y][b]))
                || (Math.abs(expectedResults[x][y][b] - sample) > TestUtils.DOUBLE_EPSILON)) {
              mismatchedSamples++;
            }
          }
        }
      }
    }
    final double percentMismatch =
        mismatchedSamples
            / (double) (rasters[i].getWidth()
                * rasters[i].getHeight()
                * rasters[i].getNumBands());
    Assert.assertTrue(
        (percentMismatch * 100) + "% mismatch is less than 1%",
        percentMismatch < 0.01);
  }
  Assert.assertTrue("There should be at least one value that is not black", atLeastOneResult);
  return expectedResults;
}