コード例 #1
0
  /**
   * 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();
    // List<FeatureType> layers=request.getLayers();
    // List<Style> styles=request.getStyles();
    // List<String> rules=request.getRules();

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

    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
      String ruleName = legend.getRule(); // was null

      // 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;
          }
          Parameter<?> output =
              outputs.values().iterator().next(); // we assume there is 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();

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

        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 = cloneSymbolizer(symbolizer);
                  if (pointSymbolizer.getGraphic() != null) {
                    double size =
                        getPointSymbolizerSize(sample, pointSymbolizer, Math.min(w, h) - 4);
                    pointSymbolizer
                        .getGraphic()
                        .setSize(ff.literal(size / symbolScale + minimumSymbolSize));

                    symbolizer = pointSymbolizer;
                  }
                }

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

        // JD: changed legend behavior, see GEOS-812
        // this.legendGraphic = scaleImage(mergeLegends(legendsStack), request);
        BufferedImage image =
            mergeLegends(legendsStack, applicableRules, request, forceLabelsOn, forceLabelsOff);
        if (image != null) {
          layersImages.add(image);
        }
      }
    }
    // all legend graphics are merged if we have a layer group
    BufferedImage finalLegend =
        mergeLegends(layersImages, null, request, forceLabelsOn, forceLabelsOff);
    if (finalLegend == null) {
      throw new IllegalArgumentException("no legend passed");
    }
    return finalLegend;
  }
コード例 #2
0
ファイル: Drawing.java プロジェクト: BestSolution-at/uDig
  /** Unsure if this is the paint for the border, or the fill? */
  private void paint(ViewportGraphics g, SimpleFeature feature, LiteShape shape, Symbolizer symb) {
    if (symb instanceof PolygonSymbolizer) {
      PolygonSymbolizer polySymb = (PolygonSymbolizer) symb;
      double opacity = SLDs.polyFillOpacity(polySymb);
      Color fillColor = SLDs.polyFill(polySymb);
      Stroke stroke = SLDs.stroke(polySymb);
      Color strokeColor = SLDs.polyColor(polySymb);

      int width = SLDs.width(stroke);
      if (width == SLDs.NOTFOUND) width = 1;

      if (Double.isNaN(opacity)) opacity = 1.0;
      if (fillColor != null) {
        fillColor =
            new Color(
                fillColor.getRed(),
                fillColor.getGreen(),
                fillColor.getBlue(),
                (int) (255 * opacity));
        g.setColor(fillColor);
        g.fill(shape);
      }
      if (stroke != null && strokeColor != null) {
        Graphics2D g2d = g.getGraphics(Graphics2D.class);
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g.setColor(strokeColor);

        float[] dashArray = stroke.getDashArray();
        Float dashOffset = stroke.getDashOffset().evaluate(null, Float.class);
        if (dashOffset == null) {
          dashOffset = 0f;
        }
        String cap = stroke.getLineCap().evaluate(null, String.class);
        int capInt = Utilities.sld2awtCap(cap);
        String join = stroke.getLineJoin().evaluate(null, String.class);
        int joinInt = Utilities.sld2awtJoin(join);
        BasicStroke bStroke = new BasicStroke(width, capInt, joinInt, 1f, dashArray, dashOffset);
        g2d.setStroke(bStroke);
        g2d.draw(shape);
      }
    }
    if (symb instanceof LineSymbolizer) {
      LineSymbolizer lineSymbolizer = (LineSymbolizer) symb;
      Color c = SLDs.color(lineSymbolizer);
      int w = SLDs.width(lineSymbolizer);
      Stroke stroke = SLDs.stroke(lineSymbolizer);
      if (c != null && w > 0) {
        Graphics2D g2d = g.getGraphics(Graphics2D.class);
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.setColor(c);

        float[] dashArray = stroke.getDashArray();
        Float dashOffset = stroke.getDashOffset().evaluate(null, Float.class);
        if (dashOffset == null) {
          dashOffset = 0f;
        }
        String cap = stroke.getLineCap().evaluate(null, String.class);
        int capInt = Utilities.sld2awtCap(cap);
        String join = stroke.getLineJoin().evaluate(null, String.class);
        int joinInt = Utilities.sld2awtJoin(join);
        BasicStroke bStroke = new BasicStroke(w, capInt, joinInt, 1f, dashArray, dashOffset);
        g2d.setStroke(bStroke);
        g2d.draw(shape);
      }
    }
    if (symb instanceof PointSymbolizer) {
      PointSymbolizer pointSymbolizer = (PointSymbolizer) symb;

      AffineTransform transform = g.getTransform();

      // offset
      Point2D offset = Utilities.getOffset(pointSymbolizer);
      if (offset != null) {
        java.awt.Point off = new java.awt.Point((int) offset.getX(), -1 * (int) offset.getY());
        g.translate(off);
      }

      // rotation
      Graphic graphic = SLDs.graphic(pointSymbolizer);
      Double rotation = graphic.getRotation().evaluate(null, Double.class);
      Double gSize = graphic.getSize().evaluate(null, Double.class);
      if (gSize != null && rotation != null) {
        g.setTransform(
            AffineTransform.getRotateInstance(toRadians(rotation), gSize / 2, gSize / 2));
      }

      Color c = SLDs.pointStrokeColorWithAlpha(pointSymbolizer);
      Color fill = SLDs.pointFillWithAlpha(pointSymbolizer);
      int width = SLDs.width(SLDs.stroke(pointSymbolizer));
      if (width < 0) {
        width = 0;
      }
      float[] point = new float[6];
      PathIterator pathIterator = shape.getPathIterator(null);
      pathIterator.currentSegment(point);

      SLDStyleFactory styleFactory = new SLDStyleFactory();
      Style2D tmp = null;
      try {
        tmp =
            styleFactory.createStyle(
                feature,
                pointSymbolizer,
                new NumberRange(Double.class, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
      } catch (Exception e) {
        PointSymbolizerWrapper tmpPs = new PointSymbolizerWrapper(pointSymbolizer, null);
        tmp =
            styleFactory.createStyle(
                feature,
                pointSymbolizer,
                new NumberRange(Double.class, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
      }
      if (tmp instanceof MarkStyle2D) {
        MarkStyle2D style = (MarkStyle2D) tmp;
        Shape shape2 = style.getTransformedShape(point[0], point[1]);

        if (c == null && fill == null) {
          // g.setColor(Color.GRAY);
          // g.fill(shape2);
        }

        if (fill != null) {
          g.setColor(fill);
          g.fill(shape2);
        }
        // else {
        // g.setColor(Color.GRAY);
        // g.fill(shape2);
        // }
        if (c != null) {
          g.setStroke(ViewportGraphics.LINE_SOLID, width);
          g.setColor(c);
          g.draw(shape2);
        }
        // else {
        // g.setStroke(ViewportGraphics.LINE_SOLID, width);
        // g.setColor(Color.DARK_GRAY);
        // g.draw(shape2);
        // }
      } else if (tmp instanceof GraphicStyle2D) {
        GraphicStyle2D style = (GraphicStyle2D) tmp;

        RenderedImage image = (RenderedImage) style.getImage();
        g.drawImage(
            image,
            (int) (point[0] - ((double) image.getWidth()) / (double) 2),
            (int) (point[1] - ((double) image.getHeight()) / (double) 2));
      }
    }
  }