Package org.opengis.coverage.grid

Examples of org.opengis.coverage.grid.GridEnvelope


    }

    private GridCoverage2D displaceCoverage(GridCoverage2D coverage, double tx, double ty) {
        // let's compute the new grid geometry
        GridGeometry2D originalGG = coverage.getGridGeometry();
        GridEnvelope gridRange = originalGG.getGridRange();
        Envelope2D envelope = originalGG.getEnvelope2D();
       
        double minx = envelope.getMinX() + tx;
        double miny = envelope.getMinY() + ty;
        double maxx = envelope.getMaxX() + tx;
View Full Code Here


        Envelope envB = coverageB.getEnvelope();
        if (!envA.equals(envB)) {
            throw new ProcessException(MISMATCHING_ENVELOPE_MESSAGE);
        }
       
        GridEnvelope gridRangeA = coverageA.getGridGeometry().getGridRange();
        GridEnvelope gridRangeB = coverageA.getGridGeometry().getGridRange();
        if (gridRangeA.getSpan(0) != gridRangeB.getSpan(0)
                || gridRangeA.getSpan(1) != gridRangeB.getSpan(1)) {
            throw new ProcessException(MISMATCHING_GRID_MESSAGE);
        }
    }
View Full Code Here

                    .getCoordinateReferenceSystem(coverageName));
            newEnvelope.add(new DirectPosition2D(newEnvelope.getMinimum(0) - 10, newEnvelope
                    .getMinimum(1) - 10));

            // Selecting the same gridRange
            GridEnvelope gridRange = reader.getOriginalGridRange(coverageName);
            gg.setValue(new GridGeometry2D(gridRange, newEnvelope));

            GeneralParameterValue[] values = new GeneralParameterValue[] { gg };
            // Read with the larger BBOX
            GridCoverage2D grid = reader.read(coverageName, values);
View Full Code Here

        super.hints = hints;
        super.coverageFactory = CoverageFactoryFinder.getGridCoverageFactory(this.hints);
        super.crs = rasterInfo.getCoverageCrs();
        super.originalEnvelope = rasterInfo.getOriginalEnvelope(PixelInCell.CELL_CENTER);

        GridEnvelope gridRange = rasterInfo.getOriginalGridRange();
        // super.originalGridRange = new GeneralGridRange(gridRange.toRectangle());
        super.originalGridRange = gridRange;

        super.coverageName = rasterInfo.getRasterTable();
        final int numLevels = rasterInfo.getNumPyramidLevels(0);

        // level 0 is not an overview, but the raster itself
        super.numOverviews = numLevels - 1;

        // ///
        //
        // setting the higher resolution avalaible for this coverage
        //
        // ///
        highestRes = super.getResolution(originalEnvelope,
                new Rectangle(originalGridRange.getLow(0), originalGridRange.getLow(1),
                        originalGridRange.getSpan(0), originalGridRange.getSpan(1)), crs);
        // //
        //
        // get information for the successive images
        //
        // //
        // REVISIT may the different rasters in the raster dataset have different pyramid levels? I
        // guess so
        if (numOverviews > 0) {
            overViewResolutions = new double[numOverviews][2];
            for (int pyramidLevel = 1; pyramidLevel <= numOverviews; pyramidLevel++) {
                GridEnvelope levelGridRange = rasterInfo.getGridRange(0, pyramidLevel);
                GeneralEnvelope levelEnvelope = rasterInfo.getGridEnvelope(0, pyramidLevel);

                Rectangle2D levelGridRangeRect = new Rectangle2D.Double(levelGridRange.getLow(0),
                        levelGridRange.getLow(1), levelGridRange.getSpan(0),
                        levelGridRange.getSpan(1));
                overViewResolutions[pyramidLevel - 1] = super.getResolution(levelEnvelope,
                        levelGridRangeRect, crs);
            }
        } else {
            overViewResolutions = null;
View Full Code Here

     * @return A new {@linkplain GridCoverage grid coverage} from the input source, or {@code null}
     *         if the requested envelope is outside the data bounds
     */
    public GridCoverage2D read(GeneralParameterValue[] params) throws IOException {
        final GeneralEnvelope requestedEnvelope;
        final GridEnvelope requestedDim;
        final OverviewPolicy overviewPolicy;
        {
            final ReadParameters opParams = parseReadParams(params);
            overviewPolicy = opParams.overviewPolicy;
            requestedEnvelope = opParams.requestedEnvelope;
            requestedDim = opParams.dim;
        }

        /*
         * For each raster in the raster dataset, obtain the tiles, pixel range, and resulting
         * envelope
         */
        final List<RasterQueryInfo> queries;
        queries = findMatchingRasters(requestedEnvelope, requestedDim, overviewPolicy);
        if (queries.isEmpty()) {
            if (requestedEnvelope.intersects(getOriginalEnvelope(), true)) {
                /*
                 * No matching rasters but envelopes intersect, meaning it's a raster catalog with
                 * irregular coverage and the request lies on an area with no coverage
                 */
                ImageTypeSpecifier imageTypeSpecifier;
                imageTypeSpecifier = RasterUtils.createFullImageTypeSpecifier(rasterInfo, 0);
                SampleModel sampleModel = imageTypeSpecifier.getSampleModel();
                Point location = new Point(0, 0);
                WritableRaster raster = Raster.createWritableRaster(sampleModel, location);
                GridCoverage2D emptyCoverage;
                emptyCoverage = coverageFactory.create(coverageName, raster, requestedEnvelope);
                return emptyCoverage;
            }
            /*
             * none of the rasters match the requested envelope.
             */
            return null;
        }

        final LoggingHelper log = new LoggingHelper();

        /*
         * Once we collected the matching rasters and their image subsets, find out where in the
         * overall resulting mosaic they fit. If the rasters does not share the spatial resolution,
         * the QueryInfo.resultDimension and QueryInfo.mosaicLocation width or height won't match
         */
        final GridEnvelope mosaicGeometry;
        mosaicGeometry = RasterUtils.setMosaicLocations(rasterInfo, queries);

        if (mosaicGeometry.getSpan(0) == 0 || mosaicGeometry.getSpan(1) == 0) {
            LOGGER.finer("Mosaic geometry width or height is zero,"
                    + " returning fake coverage for pixels " + mosaicGeometry);
            return null;
        }
        /*
         * Gather the rendered images for each of the rasters that match the requested envelope
         */
        final TiledRasterReader rasterReader = rasterReaderFactory.create(rasterInfo);

        try {
            readAllTiledRasters(queries, rasterReader, log);
        } finally {
            // rasterReader.dispose();
        }

        log.log(LoggingHelper.REQ_ENV);
        log.log(LoggingHelper.RES_ENV);
        log.log(LoggingHelper.MOSAIC_ENV);
        log.log(LoggingHelper.MOSAIC_EXPECTED);

        final RenderedImage coverageRaster = createMosaic(queries, mosaicGeometry, log);

        assert mosaicGeometry.getSpan(0) == coverageRaster.getWidth();
        assert mosaicGeometry.getSpan(1) == coverageRaster.getHeight();

        /*
         * BUILDING COVERAGE
         */
        GridSampleDimension[] bands = getSampleDimensions(coverageRaster);
View Full Code Here

            final RenderedImage rasterImage;

            try {
                final int pyramidLevel = queryInfo.getPyramidLevel();
                final GridEnvelope matchingTiles = queryInfo.getMatchingTiles();
                // final Point imageLocation = queryInfo.getTiledImageSize().getLocation();
                rasterImage = rasterReader.read(rasterId, pyramidLevel, matchingTiles);
            } catch (IOException e) {
                LOGGER.log(Level.SEVERE, "Fetching data for " + queryInfo.toString(), e);
                throw e;
View Full Code Here

            // Raster data = image.getData();
            // image = new BufferedImage(image.getColorModel(), (WritableRaster) data, false, null);
            if (queries.size() == 1) {
                return image;
            }
            final GridEnvelope mosaicLocation = query.getMosaicLocation();
            // scale
            Float scaleX = Float.valueOf(((float) mosaicLocation.getSpan(0) / image.getWidth()));
            Float scaleY = Float.valueOf(((float) mosaicLocation.getSpan(1) / image.getHeight()));
            Float translateX = Float.valueOf(0);
            Float translateY = Float.valueOf(0);

            if (!(Float.valueOf(1.0F).equals(scaleX) && Float.valueOf(1.0F).equals(scaleY))) {
                ParameterBlock pb = new ParameterBlock();
                pb.addSource(image);
                pb.add(scaleX);
                pb.add(scaleY);
                pb.add(translateX);
                pb.add(translateY);
                pb.add(new InterpolationNearest());

                image = JAI.create("scale", pb);
                log.log(image, query.getRasterId(), "03_scale");

                int width = image.getWidth();
                int height = image.getHeight();

                assert mosaicLocation.getSpan(0) == width;
                assert mosaicLocation.getSpan(1) == height;
            }

            if (image.getMinX() != mosaicLocation.getLow(0)
                    || image.getMinY() != mosaicLocation.getLow(1)) {
                // translate
                ParameterBlock pb = new ParameterBlock();
                pb.addSource(image);
                pb.add(Float.valueOf(mosaicLocation.getLow(0) - image.getMinX()));
                pb.add(Float.valueOf(mosaicLocation.getLow(1) - image.getMinY()));
                pb.add(null);

                image = JAI.create("translate", pb);
                log.log(image, query.getRasterId(), "04_translate");

                assert image.getMinX() == mosaicLocation.getLow(0) : image.getMinX() + " != "
                        + mosaicLocation.getLow(0);
                assert image.getMinY() == mosaicLocation.getLow(1) : image.getMinY() + " != "
                        + mosaicLocation.getLow(1);
                assert image.getWidth() == mosaicLocation.getSpan(0) : image.getWidth() + " != "
                        + mosaicLocation.getSpan(0);
                assert image.getHeight() == mosaicLocation.getSpan(1) : image.getHeight() + " != "
                        + mosaicLocation.getSpan(1);
            }

            transformed.add(image);
        }
View Full Code Here

        if (params == null) {
            throw new IllegalArgumentException("No GeneralParameterValue given to read operation");
        }

        GeneralEnvelope reqEnvelope = null;
        GridEnvelope dim = null;
        OverviewPolicy overviewPolicy = null;

        // /////////////////////////////////////////////////////////////////////
        //
        // Checking params
        //
        // /////////////////////////////////////////////////////////////////////
        for (int i = 0; i < params.length; i++) {
            final ParameterValue<?> param = (ParameterValue<?>) params[i];
            final String name = param.getDescriptor().getName().getCode();
            if (name.equals(AbstractGridFormat.READ_GRIDGEOMETRY2D.getName().toString())) {
                final GridGeometry2D gg = (GridGeometry2D) param.getValue();
                reqEnvelope = new GeneralEnvelope((Envelope) gg.getEnvelope2D());

                final GeneralEnvelope coverageEnvelope = getOriginalEnvelope();
                CoordinateReferenceSystem nativeCrs = coverageEnvelope
                        .getCoordinateReferenceSystem();
                CoordinateReferenceSystem requestCrs = reqEnvelope.getCoordinateReferenceSystem();
                if (!CRS.equalsIgnoreMetadata(nativeCrs, requestCrs)) {
                    LOGGER.fine("Request CRS and native CRS differ, "
                            + "reprojecting request envelope to native CRS");
                    ReferencedEnvelope nativeCrsEnv;
                    nativeCrsEnv = toNativeCrs(reqEnvelope, nativeCrs);
                    reqEnvelope = new GeneralEnvelope(nativeCrsEnv);
                }

                dim = gg.getGridRange2D();
                continue;
            }
            if (name.equals(AbstractGridFormat.OVERVIEW_POLICY.getName().toString())) {
                overviewPolicy = (OverviewPolicy) param.getValue();
                continue;
            }
        }

        if (reqEnvelope == null && dim == null) {
            reqEnvelope = getOriginalEnvelope();
            dim = getOriginalGridRange();
        }

        if (reqEnvelope == null) {
            reqEnvelope = getOriginalEnvelope();
        }
        if (dim == null) {
            final GeneralEnvelope adjustedGRange;
            try {
                MathTransform gridToWorld = getOriginalGridToWorld(PixelInCell.CELL_CENTER);
                MathTransform worldToGrid = gridToWorld.inverse();
                adjustedGRange = CRS.transform(worldToGrid, reqEnvelope);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
            int xmin = (int) Math.floor(adjustedGRange.getMinimum(0));
            int ymin = (int) Math.floor(adjustedGRange.getMinimum(1));
            int xmax = (int) Math.ceil(adjustedGRange.getMaximum(0));
            int ymax = (int) Math.ceil(adjustedGRange.getMaximum(1));
            dim = new GridEnvelope2D(xmin, ymin, xmax - xmin, ymax - ymin);
        }

        if (!reqEnvelope.intersects(getOriginalEnvelope(), true)) {
            throw new IllegalArgumentException(
                    "The requested extend does not overlap the coverage extent: "
                            + getOriginalEnvelope());
        }

        if (dim.getSpan(0) <= 0 || dim.getSpan(1) <= 0) {
            throw new IllegalArgumentException("The requested coverage dimension can't be null: "
                    + dim);
        }

        if (overviewPolicy == null) {
View Full Code Here

          description.append( "\nDriver: ");
          description.append( driver.getName() );
          description.append( "/" );
          description.append( getDriver().getTitle() );
          description.append( "\nSize is ");
          GridEnvelope size = reader.getOriginalGridRange();
          description.append(size.getSpan(0));
          description.append(", ");
          description.append(size.getSpan(1));
          description.append("\nCoordinate System is:\n");
          CoordinateReferenceSystem crs = reader.getCrs();
          description.append( crs.toWKT() );
         
          GeneralEnvelope bbox = reader.getOriginalEnvelope();         
View Full Code Here

          // set the number of coverages
          numberOfCoverages = reader.getGridCoverageCount();
 
          final GeneralEnvelope envelope = reader.getOriginalEnvelope();
          final CoordinateReferenceSystem crs = reader.getCrs();
          final GridEnvelope range = reader.getOriginalGridRange();
          final MathTransform2D g2w = (MathTransform2D) reader
              .getOriginalGridToWorld(PixelInCell.CELL_CENTER);
 
          name = new NameImpl(reader.getCoverageName());
          Info info = new Info( name );
View Full Code Here

TOP

Related Classes of org.opengis.coverage.grid.GridEnvelope

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.