Пример #1
0
  private void styleBuilderExample() throws Exception {
    // styleBuilderExample start
    //
    // We are using the GeoTools StyleBuilder that is helpful for quickly making things
    StyleBuilder builder = new StyleBuilder();
    FilterFactory2 ff = builder.getFilterFactory();

    // RULE 1
    // first rule to draw cities

    // define a point symbolizer representing a city
    Graphic city = builder.createGraphic();
    city.setSize(ff.literal(10));
    city.graphicalSymbols().add(builder.createExternalGraphic("file:city.svg", "svg")); // svg
    // preferred
    city.graphicalSymbols().add(builder.createExternalGraphic("file:city.png", "png")); // png next
    city.graphicalSymbols()
        .add(builder.createMark(StyleBuilder.MARK_CIRCLE, Color.BLUE, Color.BLACK, 1));
    PointSymbolizer pointSymbolizer = builder.createPointSymbolizer(city, "the_geom");

    Rule rule1 = builder.createRule(pointSymbolizer);
    rule1.setName("rule1");
    rule1.getDescription().setTitle("City");
    rule1.getDescription().setAbstract("Rule for drawing cities");
    rule1.setFilter(ff.less(ff.property("POPULATION"), ff.literal(50000)));

    //
    // RULE 2 Default
    Graphic dotGraphic =
        builder.createGraphic(null, builder.createMark(StyleBuilder.MARK_CIRCLE), null);
    PointSymbolizer dotSymbolize = builder.createPointSymbolizer(dotGraphic);
    Rule rule2 = builder.createRule(dotSymbolize);
    rule2.setIsElseFilter(true);

    //
    // define feature type styles used to actually define how features are rendered
    Rule rules[] = new Rule[] {rule1, rule2};
    FeatureTypeStyle featureTypeStyle = builder.createFeatureTypeStyle("Feature", rules);

    //
    // create a "user defined" style
    Style style = builder.createStyle();
    style.setName("style");
    style.getDescription().setTitle("User Style");
    style.getDescription().setAbstract("Definition of Style");
    style.featureTypeStyles().add(featureTypeStyle);
    // styleBuilderExample end
  }
Пример #2
0
  private void quickTextSymbolizer() {
    // quickTextSymbolizer start
    // "labelPoint" feature type style
    StyleBuilder sb = new StyleBuilder();
    FilterFactory2 ff = sb.getFilterFactory();

    // creation of the TextSymbolizer
    AnchorPoint anchorPoint =
        sb.createAnchorPoint(sb.attributeExpression("X"), sb.attributeExpression("Y"));
    PointPlacement pointPlacement =
        sb.createPointPlacement(anchorPoint, null, sb.literalExpression(0));
    TextSymbolizer textSymbolizer =
        sb.createTextSymbolizer(
            sb.createFill(Color.BLACK),
            new Font[] {sb.createFont("Lucida Sans", 10), sb.createFont("Arial", 10)},
            sb.createHalo(),
            sb.attributeExpression("name"),
            pointPlacement,
            null);

    // creation of the Point symbolizer
    Mark circle = sb.createMark(StyleBuilder.MARK_CIRCLE, Color.RED);
    Graphic graph2 = sb.createGraphic(null, circle, null, 1, 4, 0);
    PointSymbolizer pointSymbolizer = sb.createPointSymbolizer(graph2);

    // creation of the style
    Style style = sb.createStyle();
    FeatureTypeStyle featureTypeStyle =
        sb.createFeatureTypeStyle("labelPoint", new Symbolizer[] {textSymbolizer, pointSymbolizer});
    style.featureTypeStyles().add(featureTypeStyle);

    // creation of the style
    // quickTextSymbolizer end
  }
  private static Symbolizer crossSymbolizer(
      final String name, final StyleBuilder builder, final int crossSize, final Color pointColor) {
    Mark cross = builder.createMark(name, pointColor, pointColor, 1);
    Graphic graphic = builder.createGraphic(null, cross, null);
    graphic.setSize(builder.literalExpression(crossSize));

    return builder.createPointSymbolizer(graphic);
  }
Пример #4
0
  private void markTestSLD() {
    // markTestSLD start
    StyleBuilder sb = new StyleBuilder();
    FilterFactory ff = sb.getFilterFactory();
    Style style = sb.createStyle();
    style.setName("MyStyle");

    // "testPoint" feature type style
    Mark testMark =
        sb.createMark(sb.attributeExpression("name"), sb.createFill(Color.RED, 0.5), null);
    Graphic graph =
        sb.createGraphic(
            null,
            new Mark[] {testMark},
            null,
            sb.literalExpression(1),
            sb.attributeExpression("size"),
            sb.attributeExpression("rotation"));
    style
        .featureTypeStyles()
        .add(sb.createFeatureTypeStyle("testPoint", sb.createPointSymbolizer(graph)));

    // "labelPoint" feature type style
    AnchorPoint anchorPoint =
        sb.createAnchorPoint(sb.attributeExpression("X"), sb.attributeExpression("Y"));
    PointPlacement pointPlacement =
        sb.createPointPlacement(anchorPoint, null, sb.literalExpression(0));
    TextSymbolizer textSymbolizer =
        sb.createTextSymbolizer(
            sb.createFill(Color.BLACK),
            new Font[] {sb.createFont("Lucida Sans", 10), sb.createFont("Arial", 10)},
            sb.createHalo(),
            sb.attributeExpression("name"),
            pointPlacement,
            null);
    Mark circle = sb.createMark(StyleBuilder.MARK_CIRCLE, Color.RED);
    Graphic graph2 = sb.createGraphic(null, circle, null, 1, 4, 0);
    PointSymbolizer pointSymbolizer = sb.createPointSymbolizer(graph2);
    style
        .featureTypeStyles()
        .add(
            sb.createFeatureTypeStyle(
                "labelPoint", new Symbolizer[] {textSymbolizer, pointSymbolizer}));
    // markTestSLD end
  }
Пример #5
0
  private void splatExample() {
    // splatExample start
    StyleBuilder builder = new StyleBuilder();
    FilterFactory2 ff = builder.getFilterFactory();

    Graphic splat = builder.createGraphic(null, builder.createMark("splat"), null);
    PointSymbolizer symbolizer = builder.createPointSymbolizer(splat);

    // builder will fill in all the other classes with defaults
    Style style = builder.createStyle(symbolizer);
    // splatExample end
  }
Пример #6
0
  private void featureTypeStyleExample() {
    // featureTypeStyleExample start
    StyleBuilder styleBuilder = new StyleBuilder();
    Style style = styleBuilder.createStyle();

    PointSymbolizer pointSymbolizer = styleBuilder.createPointSymbolizer();

    Graphic graphic = styleBuilder.createGraphic();
    ExternalGraphic external =
        styleBuilder.createExternalGraphic("file:///C:/images/house.gif", "image/gif");
    graphic.graphicalSymbols().add(external);
    graphic.graphicalSymbols().add(styleBuilder.createMark("circle"));

    pointSymbolizer.setGraphic(graphic);

    Rule rule = styleBuilder.createRule(pointSymbolizer);
    FeatureTypeStyle featureTypeStyle = styleBuilder.createFeatureTypeStyle("Feature", rule);
    style.featureTypeStyles().add(featureTypeStyle);

    // featureTypeStyleExample end
  }
Пример #7
0
  private void quickPointSymbolizer() {
    // quickPointSymbolizer start
    // "testPoint" feature type style
    StyleBuilder sb = new StyleBuilder();
    FilterFactory2 ff = sb.getFilterFactory();

    Mark testMark =
        sb.createMark(sb.attributeExpression("name"), sb.createFill(Color.RED, 0.5), null);
    Graphic graph =
        sb.createGraphic(
            null, // An external graphics if needed
            new Mark[] {testMark}, // a Mark if not an external graphics
            null, // aSymbol
            ff.literal(1), // opacity
            ff.property("size"), // read from feature "size" attribute
            ff.property("rotation")); // rotation, here read into the feature
    PointSymbolizer aPointSymbolizer = sb.createPointSymbolizer(graph);

    // creation of the style
    Style style = sb.createStyle(aPointSymbolizer);
    // quickPointSymbolizer end
  }
Пример #8
0
  public static Symbolizer[] getSymbolizers(
      Class<? extends Geometry> type, Color baseColor, boolean useTransparency) {

    StyleBuilder builder = new StyleBuilder();
    Symbolizer[] syms = new Symbolizer[1];
    if (LineString.class.isAssignableFrom(type) || MultiLineString.class.isAssignableFrom(type))
      syms[0] = builder.createLineSymbolizer(baseColor, 2);
    if (Point.class.isAssignableFrom(type) || MultiPoint.class.isAssignableFrom(type)) {
      PointSymbolizer point = builder.createPointSymbolizer(builder.createGraphic());
      FilterFactory ff = builder.getFilterFactory();
      // point.getGraphic().getMarks()[0].setSize((Expression) ff.literal(10));
      point.getGraphic().setSize(ff.literal(10));
      Mark mark = (Mark) point.getGraphic().graphicalSymbols().get(0);
      mark.setFill(builder.createFill(baseColor));
      syms[0] = point;
    }
    if (Polygon.class.isAssignableFrom(type) || MultiPolygon.class.isAssignableFrom(type)) {
      syms[0] =
          builder.createPolygonSymbolizer(
              builder.createStroke(baseColor, 2),
              builder.createFill(baseColor, useTransparency ? .6 : 1.0));
    }
    return syms;
  }
Пример #9
0
 private Style createPointStyle() {
   StyleBuilder sb = new StyleBuilder();
   return sb.createStyle(sb.createPointSymbolizer());
 }