Search in sources :

Example 1 with UomRescaleStyleVisitor

use of org.geotools.styling.visitor.UomRescaleStyleVisitor in project sldeditor by robward-scisys.

the class SLDEditorBufferedImageLegendGraphicBuilder method buildLegendGraphic.

/**
 * Takes a GetLegendGraphicRequest and produces a BufferedImage that then can be used by a
 * subclass to encode it to the appropriate output format.
 *
 * @param request the "parsed" request, where "parsed" means that it's values are already
 *        validated so this method must not take care of verifying the requested layer exists
 *        and the like.
 *
 * @throws ServiceException if there are problems creating a "sample" feature instance for the
 *         FeatureType <code>request</code> returns as the required layer (which should not
 *         occur).
 */
public BufferedImage buildLegendGraphic(GetLegendGraphicRequest request) throws ServiceException {
    // list of images to be rendered for the layers (more than one if
    // a layer group is given)
    List<RenderedImage> layersImages = new ArrayList<RenderedImage>();
    List<LegendRequest> layers = request.getLegends();
    boolean forceLabelsOn = false;
    boolean forceLabelsOff = false;
    if (request.getLegendOptions().get("forceLabels") instanceof String) {
        String forceLabelsOpt = (String) request.getLegendOptions().get("forceLabels");
        if (forceLabelsOpt.equalsIgnoreCase("on")) {
            forceLabelsOn = true;
        } else if (forceLabelsOpt.equalsIgnoreCase("off")) {
            forceLabelsOff = true;
        }
    }
    boolean forceTitlesOff = false;
    if (request.getLegendOptions().get("forceTitles") instanceof String) {
        String forceTitlesOpt = (String) request.getLegendOptions().get("forceTitles");
        if (forceTitlesOpt.equalsIgnoreCase("off")) {
            forceTitlesOff = true;
        }
    }
    double imageSizeFactor = 1.0;
    if (request.getLegendOptions().get("imageSizeFactor") instanceof String) {
        String imageSizeFactorOpt = (String) request.getLegendOptions().get("imageSizeFactor");
        imageSizeFactor = Double.valueOf(imageSizeFactorOpt);
    }
    FeatureCountProcessor countProcessor = null;
    if (Boolean.TRUE.equals(request.getLegendOption(GetLegendGraphicRequest.COUNT_MATCHED_KEY, Boolean.class))) {
        countProcessor = new FeatureCountProcessor(request);
    }
    for (LegendRequest legend : layers) {
        FeatureType layer = legend.getFeatureType();
        // style and rule to use for the current layer
        Style gt2Style = legend.getStyle();
        if (gt2Style == null) {
            throw new NullPointerException("request.getStyle()");
        }
        // get rule corresponding to the layer index
        // normalize to null for NO RULE
        // was null
        String ruleName = legend.getRule();
        // width and height, we might have to rescale those in case of DPI usage
        int w = request.getWidth();
        int h = request.getHeight();
        // apply dpi rescale
        double dpi = RendererUtilities.getDpi(request.getLegendOptions());
        double standardDpi = RendererUtilities.getDpi(Collections.emptyMap());
        if (dpi != standardDpi) {
            double scaleFactor = dpi / standardDpi;
            w = (int) Math.round(w * scaleFactor);
            h = (int) Math.round(h * scaleFactor);
            DpiRescaleStyleVisitor dpiVisitor = new DpiRescaleStyleVisitor(scaleFactor);
            dpiVisitor.visit(gt2Style);
            gt2Style = (Style) dpiVisitor.getCopy();
        }
        // apply UOM rescaling if we have a scale
        if (request.getScale() > 0) {
            double pixelsPerMeters = RendererUtilities.calculatePixelsPerMeterRatio(request.getScale(), request.getLegendOptions());
            UomRescaleStyleVisitor rescaleVisitor = new UomRescaleStyleVisitor(pixelsPerMeters);
            rescaleVisitor.visit(gt2Style);
            gt2Style = (Style) rescaleVisitor.getCopy();
        }
        boolean strict = request.isStrict();
        final boolean transparent = request.isTransparent();
        RenderedImage titleImage = null;
        // if we have more than one layer, we put a title on top of each layer legend
        if (layers.size() > 1 && !forceTitlesOff) {
            titleImage = getLayerTitle(legend, w, h, transparent, request);
        }
        // Check for rendering transformation
        boolean hasVectorTransformation = false;
        boolean hasRasterTransformation = false;
        List<FeatureTypeStyle> ftsList = gt2Style.featureTypeStyles();
        for (int i = 0; i < ftsList.size(); i++) {
            FeatureTypeStyle fts = ftsList.get(i);
            Expression exp = fts.getTransformation();
            if (exp != null) {
                ProcessFunction processFunction = (ProcessFunction) exp;
                Name processName = processFunction.getProcessName();
                Map<String, Parameter<?>> outputs = Processors.getResultInfo(processName, null);
                if (outputs.isEmpty()) {
                    continue;
                }
                // we assume there is
                Parameter<?> output = outputs.values().iterator().next();
                // only one output
                if (SimpleFeatureCollection.class.isAssignableFrom(output.getType())) {
                    hasVectorTransformation = true;
                    break;
                } else if (GridCoverage2D.class.isAssignableFrom(output.getType())) {
                    hasRasterTransformation = true;
                    break;
                }
            }
        }
        final boolean buildRasterLegend = (!strict && layer == null && LegendUtils.checkRasterSymbolizer(gt2Style)) || (LegendUtils.checkGridLayer(layer) && !hasVectorTransformation) || hasRasterTransformation;
        // Just checks LegendInfo currently, should check gtStyle
        final boolean useProvidedLegend = layer != null && legend.getLayerInfo() != null;
        RenderedImage legendImage = null;
        if (useProvidedLegend) {
            legendImage = getLayerLegend(legend, w, h, transparent, request);
        }
        if (buildRasterLegend) {
            final RasterLayerLegendHelper rasterLegendHelper = new RasterLayerLegendHelper(request, gt2Style, ruleName);
            final BufferedImage image = rasterLegendHelper.getLegend();
            if (image != null) {
                if (titleImage != null) {
                    layersImages.add(titleImage);
                }
                layersImages.add(image);
            }
        } else if (useProvidedLegend && legendImage != null) {
            if (titleImage != null) {
                layersImages.add(titleImage);
            }
            layersImages.add(legendImage);
        } else {
            final Feature sampleFeature;
            if (layer == null || hasVectorTransformation) {
                sampleFeature = createSampleFeature();
            } else {
                sampleFeature = createSampleFeature(layer);
            }
            final FeatureTypeStyle[] ftStyles = gt2Style.featureTypeStyles().toArray(new FeatureTypeStyle[0]);
            final double scaleDenominator = request.getScale();
            Rule[] applicableRules;
            if (ruleName != null) {
                Rule rule = LegendUtils.getRule(ftStyles, ruleName);
                if (rule == null) {
                    throw new ServiceException("Specified style does not contains a rule named " + ruleName);
                }
                applicableRules = new Rule[] { rule };
            } else {
                applicableRules = LegendUtils.getApplicableRules(ftStyles, scaleDenominator);
            }
            // do we have to alter the style to do context sensitive feature counts?
            if (countProcessor != null && !forceLabelsOff) {
                applicableRules = updateRuleTitles(countProcessor, legend, applicableRules);
            }
            final NumberRange<Double> scaleRange = NumberRange.create(scaleDenominator, scaleDenominator);
            final int ruleCount = applicableRules.length;
            /**
             * A legend graphic is produced for each applicable rule. They're being held here
             * until the process is done and then painted on a "stack" like legend.
             */
            final List<RenderedImage> legendsStack = new ArrayList<RenderedImage>(ruleCount);
            final SLDStyleFactory styleFactory = new SLDStyleFactory();
            double minimumSymbolSize = MINIMUM_SYMBOL_SIZE;
            // get minSymbolSize from LEGEND_OPTIONS, if defined
            if (request.getLegendOptions().get("minSymbolSize") instanceof String) {
                String minSymbolSizeOpt = (String) request.getLegendOptions().get("minSymbolSize");
                try {
                    minimumSymbolSize = Double.parseDouble(minSymbolSizeOpt);
                } catch (NumberFormatException e) {
                    throw new IllegalArgumentException("Invalid minSymbolSize value: should be a number");
                }
            }
            // calculate the symbols rescaling factor necessary for them to be
            // drawn inside the icon box
            double symbolScale = calcSymbolScale(w, h, layer, sampleFeature, applicableRules, minimumSymbolSize);
            for (int i = 0; i < ruleCount; i++) {
                final RenderedImage image = ImageUtils.createImage(w, h, (IndexColorModel) null, transparent);
                final Map<RenderingHints.Key, Object> hintsMap = new HashMap<RenderingHints.Key, Object>();
                final Graphics2D graphics = ImageUtils.prepareTransparency(transparent, LegendUtils.getBackgroundColor(request), image, hintsMap);
                graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                Feature sample = getSampleFeatureForRule(layer, sampleFeature, applicableRules[i]);
                FilterFactory ff = CommonFactoryFinder.getFilterFactory();
                final Symbolizer[] symbolizers = applicableRules[i].getSymbolizers();
                final GraphicLegend graphic = applicableRules[i].getLegend();
                // If this rule has a legend graphic defined in the SLD, use it
                if (graphic != null) {
                    if (this.samplePoint == null) {
                        Coordinate coord = new Coordinate(w / 2, h / 2);
                        try {
                            this.samplePoint = new LiteShape2(geomFac.createPoint(coord), null, null, false);
                        } catch (Exception e) {
                            this.samplePoint = null;
                        }
                    }
                    shapePainter.paint(graphics, this.samplePoint, graphic, scaleDenominator, false);
                } else {
                    for (int sIdx = 0; sIdx < symbolizers.length; sIdx++) {
                        Symbolizer symbolizer = symbolizers[sIdx];
                        if (symbolizer instanceof RasterSymbolizer) {
                        // skip it
                        } else {
                            // rescale symbols if needed
                            if (symbolScale > 1.0 && symbolizer instanceof PointSymbolizer) {
                                PointSymbolizer pointSymbolizer = (PointSymbolizer) cloneSymbolizer(symbolizer);
                                if (pointSymbolizer.getGraphic() != null) {
                                    double size = getGraphicSize(sample, pointSymbolizer.getGraphic(), Math.min(w, h) - 4);
                                    pointSymbolizer.getGraphic().setSize(ff.literal(size / symbolScale + minimumSymbolSize));
                                    symbolizer = pointSymbolizer;
                                }
                            }
                            if (!(Math.abs(imageSizeFactor - 1.0) < 0.0001)) {
                                if (symbolizer instanceof PointSymbolizer) {
                                    PointSymbolizer pointSymbolizer2 = (PointSymbolizer) cloneSymbolizer(symbolizer);
                                    if (pointSymbolizer2.getGraphic() != null) {
                                        double size = getGraphicSize(sample, pointSymbolizer2.getGraphic(), Math.min(w, h) - 4);
                                        pointSymbolizer2.getGraphic().setSize(ff.literal(size * imageSizeFactor + minimumSymbolSize));
                                        symbolizer = pointSymbolizer2;
                                    }
                                } else if (symbolizer instanceof PolygonSymbolizer) {
                                    PolygonSymbolizer polygonSymbolizer2 = (PolygonSymbolizer) cloneSymbolizer(symbolizer);
                                    if (polygonSymbolizer2.getFill() != null) {
                                        // Fill
                                        double size = 0.0;
                                        if (polygonSymbolizer2.getFill().getGraphicFill() != null) {
                                            size = getGraphicSize(sample, polygonSymbolizer2.getFill().getGraphicFill(), Math.min(w, h) - 4);
                                            polygonSymbolizer2.getFill().getGraphicFill().setSize(ff.literal(size * imageSizeFactor + minimumSymbolSize));
                                        }
                                    }
                                    if (polygonSymbolizer2.getStroke() != null) {
                                        // Stroke
                                        double size = getGraphicSize(sample, polygonSymbolizer2.getStroke().getGraphicFill(), Math.min(w, h) - 4);
                                        polygonSymbolizer2.getStroke().getGraphicFill().setSize(ff.literal(size * imageSizeFactor + minimumSymbolSize));
                                        if (polygonSymbolizer2.getStroke().getGraphicStroke() != null) {
                                            size = getGraphicSize(sample, polygonSymbolizer2.getStroke().getGraphicStroke(), Math.min(w, h) - 4);
                                            polygonSymbolizer2.getStroke().getGraphicStroke().setSize(ff.literal(size * imageSizeFactor + minimumSymbolSize));
                                        }
                                    }
                                    symbolizer = polygonSymbolizer2;
                                } else if (symbolizer instanceof LineSymbolizer) {
                                    LineSymbolizer lineSymbolizer2 = (LineSymbolizer) cloneSymbolizer(symbolizer);
                                    if (lineSymbolizer2.getStroke() != null) {
                                        // Stroke
                                        double size = 0.0;
                                        if (lineSymbolizer2.getStroke().getGraphicFill() != null) {
                                            size = getGraphicSize(sample, lineSymbolizer2.getStroke().getGraphicFill(), Math.min(w, h) - 4);
                                            lineSymbolizer2.getStroke().getGraphicFill().setSize(ff.literal(size * imageSizeFactor + minimumSymbolSize));
                                        }
                                        if (lineSymbolizer2.getStroke().getGraphicStroke() != null) {
                                            size = getGraphicSize(sample, lineSymbolizer2.getStroke().getGraphicStroke(), Math.min(w, h) - 4);
                                            lineSymbolizer2.getStroke().getGraphicStroke().setSize(ff.literal(size * imageSizeFactor + minimumSymbolSize));
                                        }
                                        if (lineSymbolizer2.getStroke().getWidth() != null) {
                                            size = getWidthSize(sample, lineSymbolizer2.getStroke().getWidth(), 1);
                                            lineSymbolizer2.getStroke().setWidth(ff.literal(size * imageSizeFactor));
                                        }
                                    }
                                    symbolizer = lineSymbolizer2;
                                }
                            }
                        }
                        Style2D style2d = styleFactory.createStyle(sample, symbolizer, scaleRange);
                        LiteShape2 shape = getSampleShape(symbolizer, w, h);
                        if (style2d != null) {
                            shapePainter.paint(graphics, shape, style2d, scaleDenominator);
                        }
                    }
                }
                if (image != null && titleImage != null) {
                    layersImages.add(titleImage);
                    titleImage = null;
                }
                legendsStack.add(image);
                graphics.dispose();
            }
            int labelMargin = 3;
            if (!StringUtils.isEmpty(request.getLegendOptions().get("labelMargin"))) {
                labelMargin = Integer.parseInt(request.getLegendOptions().get("labelMargin").toString());
            }
            LegendMerger.MergeOptions options = LegendMerger.MergeOptions.createFromRequest(legendsStack, 0, 0, 0, labelMargin, request, forceLabelsOn, forceLabelsOff, forceTitlesOff);
            if (ruleCount > 0) {
                BufferedImage image = LegendMerger.mergeLegends(applicableRules, request, options);
                if (image != null) {
                    layersImages.add(image);
                }
            }
        }
    }
    // all legend graphics are merged if we have a layer group
    BufferedImage finalLegend = mergeGroups(layersImages, null, request, forceLabelsOn, forceLabelsOff, forceTitlesOff);
    if (finalLegend == null) {
        throw new IllegalArgumentException("no legend passed");
    }
    return finalLegend;
}
Also used : PolygonSymbolizer(org.geotools.styling.PolygonSymbolizer) ArrayList(java.util.ArrayList) LineString(com.vividsolutions.jts.geom.LineString) SimpleFeature(org.opengis.feature.simple.SimpleFeature) Feature(org.opengis.feature.Feature) FilterFactory(org.opengis.filter.FilterFactory) Name(org.opengis.feature.type.Name) List(java.util.List) ArrayList(java.util.ArrayList) GraphicLegend(org.opengis.style.GraphicLegend) UomRescaleStyleVisitor(org.geotools.styling.visitor.UomRescaleStyleVisitor) ProcessFunction(org.geotools.process.function.ProcessFunction) RasterSymbolizer(org.geotools.styling.RasterSymbolizer) ServiceException(org.geoserver.platform.ServiceException) Coordinate(com.vividsolutions.jts.geom.Coordinate) LineSymbolizer(org.geotools.styling.LineSymbolizer) Rule(org.geotools.styling.Rule) Map(java.util.Map) HashMap(java.util.HashMap) SimpleFeatureType(org.opengis.feature.simple.SimpleFeatureType) FeatureType(org.opengis.feature.type.FeatureType) BufferedImage(java.awt.image.BufferedImage) RenderingHints(java.awt.RenderingHints) Style2D(org.geotools.renderer.style.Style2D) DpiRescaleStyleVisitor(org.geotools.styling.visitor.DpiRescaleStyleVisitor) SLDStyleFactory(org.geotools.renderer.style.SLDStyleFactory) Style(org.geotools.styling.Style) FeatureTypeStyle(org.geotools.styling.FeatureTypeStyle) LiteShape2(org.geotools.geometry.jts.LiteShape2) IndexColorModel(java.awt.image.IndexColorModel) PointSymbolizer(org.geotools.styling.PointSymbolizer) GridCoverage2D(org.geotools.coverage.grid.GridCoverage2D) Point(com.vividsolutions.jts.geom.Point) ServiceException(org.geoserver.platform.ServiceException) SchemaException(org.geotools.feature.SchemaException) MalformedURLException(java.net.MalformedURLException) IOException(java.io.IOException) IllegalAttributeException(org.opengis.feature.IllegalAttributeException) PolygonSymbolizer(org.geotools.styling.PolygonSymbolizer) Symbolizer(org.geotools.styling.Symbolizer) TextSymbolizer(org.geotools.styling.TextSymbolizer) LineSymbolizer(org.geotools.styling.LineSymbolizer) PointSymbolizer(org.geotools.styling.PointSymbolizer) RasterSymbolizer(org.geotools.styling.RasterSymbolizer) Graphics2D(java.awt.Graphics2D) NumberRange(org.geotools.util.NumberRange) Expression(org.opengis.filter.expression.Expression) Parameter(org.geotools.data.Parameter) FeatureTypeStyle(org.geotools.styling.FeatureTypeStyle) RenderedImage(java.awt.image.RenderedImage) LegendRequest(org.geoserver.wms.GetLegendGraphicRequest.LegendRequest)

Aggregations

Coordinate (com.vividsolutions.jts.geom.Coordinate)1 LineString (com.vividsolutions.jts.geom.LineString)1 Point (com.vividsolutions.jts.geom.Point)1 Graphics2D (java.awt.Graphics2D)1 RenderingHints (java.awt.RenderingHints)1 BufferedImage (java.awt.image.BufferedImage)1 IndexColorModel (java.awt.image.IndexColorModel)1 RenderedImage (java.awt.image.RenderedImage)1 IOException (java.io.IOException)1 MalformedURLException (java.net.MalformedURLException)1 ArrayList (java.util.ArrayList)1 HashMap (java.util.HashMap)1 List (java.util.List)1 Map (java.util.Map)1 ServiceException (org.geoserver.platform.ServiceException)1 LegendRequest (org.geoserver.wms.GetLegendGraphicRequest.LegendRequest)1 GridCoverage2D (org.geotools.coverage.grid.GridCoverage2D)1 Parameter (org.geotools.data.Parameter)1 SchemaException (org.geotools.feature.SchemaException)1 LiteShape2 (org.geotools.geometry.jts.LiteShape2)1