wcsutils.java

电子地图服务器,搭建自己的地图服务

        return (GridCoverage2D) scaleFactory.doOperation(param, hints);
    }

    /**
     * Reprojecting the input coverage using the provided parameters.
     *
     * @param gc
     * @param crs
     * @param interpolation
     * @return
     */
    public static GridCoverage2D resample(final GridCoverage2D gc, CoordinateReferenceSystem crs,
        final Interpolation interpolation) {
        final ParameterValueGroup param = (ParameterValueGroup) resampleParams.clone();
        param.parameter("source").setValue(gc);
        param.parameter("CoordinateReferenceSystem").setValue(crs);
        param.parameter("InterpolationType").setValue(interpolation);

        return (GridCoverage2D) resampleFactory.doOperation(param, hints);
    }

    /**
     * Subsampling the provided {@link GridCoverage2D} with the provided
     * parameters.
     *
     * @param gc
     * @param scaleXInt
     * @param scaleYInt
     * @param interpolation
     * @param be
     * @return
     */
    public static GridCoverage2D filteredSubsample(final GridCoverage2D gc, int scaleXInt,
        int scaleYInt, final Interpolation interpolation, final BorderExtender be) {
        final GridCoverage2D preScaledGridCoverage;

        if ((scaleXInt == 1) && (scaleYInt == 1)) {
            preScaledGridCoverage = gc;
        } else {
            final ParameterValueGroup param = (ParameterValueGroup) filteredSubsampleParams.clone();
            param.parameter("source").setValue(gc);
            param.parameter("scaleX").setValue(new Integer(scaleXInt));
            param.parameter("scaleY").setValue(new Integer(scaleYInt));

            if (interpolation.equals(new InterpolationNearest())) {
                param.parameter("qsFilterArray").setValue(new float[] { 1.0F });
            } else {
                param.parameter("qsFilterArray")
                     .setValue(new float[] { 0.5F, 1.0F / 3.0F, 0.0F, -1.0F / 12.0F });
            }

            param.parameter("Interpolation").setValue(interpolation);
            param.parameter("BorderExtender").setValue(be);
            preScaledGridCoverage = (GridCoverage2D) filteredSubsampleFactory.doOperation(param,
                    hints);
        }

        return preScaledGridCoverage;
    }

    /**
     * <strong>Cropping</strong><br>
     * The crop operation is responsible for selecting geographic subareas of
     * the source coverage.
     *
     * @param coverage
     *            Coverage
     * @param sourceEnvelope
     *            GeneralEnvelope
     * @param sourceCRS
     *            CoordinateReferenceSystem
     * @param destinationEnvelopeInSourceCRS
     *            GeneralEnvelope
     * @return GridCoverage2D
     * @throws WcsException
     */
    public static GridCoverage2D crop(final Coverage coverage,
        final GeneralEnvelope sourceEnvelope, final CoordinateReferenceSystem sourceCRS,
        final GeneralEnvelope destinationEnvelopeInSourceCRS, final Boolean conserveEnvelope)
        throws WcsException {
        // ///////////////////////////////////////////////////////////////////
        //
        // CROP
        //
        //
        // ///////////////////////////////////////////////////////////////////
        final GridCoverage2D croppedGridCoverage;

        // intersect the envelopes
        final GeneralEnvelope intersectionEnvelope = new GeneralEnvelope(destinationEnvelopeInSourceCRS);
        intersectionEnvelope.setCoordinateReferenceSystem(sourceCRS);
        intersectionEnvelope.intersect((GeneralEnvelope) sourceEnvelope);

        // dow we have something to show?
        if (intersectionEnvelope.isEmpty()) {
            throw new WcsException("The Intersection is null. Check the requested BBOX!");
        }

        if (!intersectionEnvelope.equals((GeneralEnvelope) sourceEnvelope)) {
            // get the cropped grid geometry
            // final GridGeometry2D cropGridGeometry = getCroppedGridGeometry(
            // intersectionEnvelope, gridCoverage);

            /* Operations.DEFAULT.crop(coverage, intersectionEnvelope) */
            final ParameterValueGroup param = (ParameterValueGroup) cropParams.clone();
            param.parameter("Source").setValue(coverage);
            param.parameter("Envelope").setValue(intersectionEnvelope);
            param.parameter("ConserveEnvelope").setValue(conserveEnvelope);

            croppedGridCoverage = (GridCoverage2D) cropFactory.doOperation(param, hints);
        } else {
            croppedGridCoverage = (GridCoverage2D) coverage;
        }

        // prefetch to be faster afterwards.
        // This step is important since at this stage we might be loading tiles
        // from disk
        croppedGridCoverage.prefetch(intersectionEnvelope.toRectangle2D());

        return croppedGridCoverage;
    }

    /**
     * <strong>Band Selecting</strong><br>
     * Chooses <var>N</var>
     * {@linkplain org.geotools.coverage.GridSampleDimension sample dimensions}
     * from a grid coverage and copies their sample data to the destination grid
     * coverage in the order specified. The {@code "SampleDimensions"} parameter
     * specifies the source {@link org.geotools.coverage.GridSampleDimension}
     * indices, and its size ({@code SampleDimensions.length}) determines the
     * number of sample dimensions of the destination grid coverage. The
     * destination coverage may have any number of sample dimensions, and a
     * particular sample dimension of the source coverage may be repeated in the
     * destination coverage by specifying it multiple times in the
     * {@code "SampleDimensions"} parameter.
     *
     * @param params
     *            Set
     * @param coverage
     *            GridCoverage
     * @return Coverage
     * @throws WcsException
     */
    public static Coverage bandSelect(final Map params, final GridCoverage coverage)
        throws WcsException {
        // ///////////////////////////////////////////////////////////////////
        //
        // BAND SELECT
        //
        //
        // ///////////////////////////////////////////////////////////////////
        final int numDimensions = coverage.getNumSampleDimensions();
        final Map dims = new HashMap();
        final ArrayList selectedBands = new ArrayList();

        for (int d = 0; d < numDimensions; d++) {
            dims.put("band" + (d + 1), new Integer(d));
        }

        if ((params != null) && !params.isEmpty()) {
            for (Iterator p = params.keySet().iterator(); p.hasNext();) {
                final String param = (String) p.next();

                if (param.equalsIgnoreCase("BAND")) {
                    try {
                        final String values = (String) params.get(param);

                        if (values.indexOf("/") > 0) {
                            final String[] minMaxRes = values.split("/");
                            final int min = (int) Math.round(Double.parseDouble(minMaxRes[0]));
                            final int max = (int) Math.round(Double.parseDouble(minMaxRes[1]));
                            final double res = ((minMaxRes.length > 2)
                                ? Double.parseDouble(minMaxRes[2]) : 0.0);

                            for (int v = min; v <= max; v++) {
                                final String key = param.toLowerCase() + v;

                                if (dims.containsKey(key)) {
                                    selectedBands.add(dims.get(key));
                                }
                            }
                        } else {
                            final String[] bands = values.split(",");

                            for (int v = 0; v < bands.length; v++) {
                                final String key = param.toLowerCase() + bands[v];

                                if (dims.containsKey(key)) {
                                    selectedBands.add(dims.get(key));
                                }
                            }

                            if (selectedBands.size() == 0) {
                                throw new Exception("WRONG PARAM VALUES.");
                            }
                        }
                    } catch (Exception e) {
                        throw new WcsException("Band parameters incorrectly specified: "
                            + e.getLocalizedMessage());
                    }
                }
            }
        }

        final int length = selectedBands.size();
        final int[] bands = new int[length];

        for (int b = 0; b < length; b++) {
            bands[b] = ((Integer) selectedBands.get(b)).intValue();
        }

        Coverage bandSelectedCoverage;

        if ((bands != null) && (bands.length > 0)) {
            /* Operations.DEFAULT.selectSampleDimension(coverage, bands) */
            final ParameterValueGroup param = (ParameterValueGroup) bandSelectParams.clone();
            param.parameter("Source").setValue(coverage);
            param.parameter("SampleDimensions").setValue(bands);
            // param.parameter("VisibleSampleDimension").setValue(bands);
            bandSelectedCoverage = bandSelectFactory.doOperation(param, hints);
        } else {
            bandSelectedCoverage = coverage;
        }

        return bandSelectedCoverage;
    }
}