@Override public Void answer() throws Throwable { Object[] args = getCurrentArguments(); InputStream is = (InputStream) args[1]; byte[] input = IOUtils.toByteArray(is); SLDParser parser = new SLDParser(CommonFactoryFinder.getStyleFactory()); parser.setInput(new ByteArrayInputStream(input)); StyledLayerDescriptor sld = parser.parseSLD(); NamedLayer nl = (NamedLayer) sld.getStyledLayers()[0]; assertEquals("foo", nl.getName()); Style style = nl.getStyles()[0]; assertEquals( "A raster style", style.getDescription().getTitle().toString()); assertEquals(1, style.featureTypeStyles().size()); FeatureTypeStyle fts = style.featureTypeStyles().get(0); assertEquals(1, fts.rules().size()); assertThat( fts.rules().get(0).symbolizers().get(0), instanceOf(RasterSymbolizer.class)); // make sure it's valid SLDValidator validator = new SLDValidator(); List errors = validator.validateSLD(new ByteArrayInputStream(input)); assertEquals(0, errors.size()); return null; } });
public void visit(FeatureTypeStyle fts) { start("FeatureTypeStyle"); if ((fts.getName() != null) && (fts.getName().length() > 0)) { element("Name", fts.getName()); } if (fts.getDescription() != null && fts.getDescription().getTitle() != null) element("Title", fts.getDescription().getTitle()); if (fts.getDescription() != null && fts.getDescription().getAbstract() != null) element("Abstract", fts.getDescription().getAbstract()); if ((fts.featureTypeNames() != null) && (fts.featureTypeNames().size() > 0)) { element("FeatureTypeName", fts.featureTypeNames().iterator().next().toString()); } if (fts.getTransformation() != null) { element("Transformation", fts.getTransformation()); } String[] sti = fts.getSemanticTypeIdentifiers(); if (sti.length != 1 || !sti[0].equals(SemanticType.ANY.toString())) { for (int i = 0; i < sti.length; i++) { element("SemanticTypeIdentifier", sti[i]); } } Rule[] rules = fts.getRules(); for (int i = 0; i < rules.length; i++) { rules[i].accept(this); } encodeVendorOptions(fts.getOptions()); end("FeatureTypeStyle"); }
private boolean isFeatureTypeStyleActive(FeatureType ftype, FeatureTypeStyle fts) { // TODO: find a complex feature equivalent for this check return fts.featureTypeNames().isEmpty() || ((ftype.getName().getLocalPart() != null) && (ftype.getName() .getLocalPart() .equalsIgnoreCase(fts.getFeatureTypeName()) || FeatureTypes.isDecendedFrom( ftype, null, fts.getFeatureTypeName()))); }
new SLDParser(CommonFactoryFinder.getStyleFactory()); parser.setInput(new ByteArrayInputStream(input)); StyledLayerDescriptor sld = parser.parseSLD(); assertEquals( "A orange generic style", style.getDescription().getTitle().toString()); assertEquals(1, style.featureTypeStyles().size()); FeatureTypeStyle fts = style.featureTypeStyles().get(0); assertEquals("first", fts.getOptions().get("ruleEvaluation")); assertEquals(4, fts.rules().size()); assertEquals( "raster", fts.rules().get(0).getDescription().getTitle().toString()); assertEquals( "orange polygon", fts.rules().get(1).getDescription().getTitle().toString()); assertEquals( "orange line", fts.rules().get(2).getDescription().getTitle().toString()); assertEquals( "orange point", fts.rules().get(3).getDescription().getTitle().toString());
/** * create a SimpleFeature type styler see the SLD Spec for more details of scaleDenominators * * @param typeName - The feature typeName you want to draw (use "Feature" as a wild card to * match all) * @param rules - the rules that make up the FeatureTypeStyle * @return the new feature type styler */ public FeatureTypeStyle createFeatureTypeStyle(String typeName, Rule[] rules) { FeatureTypeStyle fts = sf.createFeatureTypeStyle(); fts.setRules(rules); if (typeName != null) { fts.setFeatureTypeName(typeName); } return fts; }
Rule[] rules = fts.getRules(); int length = rules.length; Rule[] rulesCopy = new Rule[length]; for (int i = 0; i < length; i++) { if (rules[i] != null) { rules[i].accept(this); rulesCopy[i] = (Rule) pages.pop(); copy.setRules(rulesCopy); if (fts.getTransformation() != null) { copy.setTransformation(copy(fts.getTransformation())); if (fts.getOnlineResource() != null) { copy.setOnlineResource(fts.getOnlineResource()); copy.getOptions().clear(); copy.getOptions().putAll(fts.getOptions());
@Test public void testLabelEmbeded() throws Exception { String yaml = "text: \n" + " label: literal0${attribute1}literal2\n" + ""; StyledLayerDescriptor sld = Ysld.parse(yaml); FeatureTypeStyle fs = SLD.defaultStyle(sld).featureTypeStyles().get(0); TextSymbolizer symb = (TextSymbolizer) fs.rules().get(0).symbolizers().get(0); Expression label = symb.getLabel(); assertThat(label, instanceOf(ConcatenateFunction.class)); List<Expression> params = ((ConcatenateFunction) label).getParameters(); assertThat(params.size(), is(3)); assertThat(params.get(0), literal(equalTo("literal0"))); assertThat(params.get(1), attribute("attribute1")); assertThat(params.get(2), literal(equalTo("literal2"))); }
@SuppressWarnings("unchecked") @Test public void testLabelLiteral() throws Exception { String yaml = "text: \n" + " label: test literal\n" + ""; StyledLayerDescriptor sld = Ysld.parse(yaml); FeatureTypeStyle fs = SLD.defaultStyle(sld).featureTypeStyles().get(0); TextSymbolizer symb = (TextSymbolizer) fs.rules().get(0).symbolizers().get(0); Expression label = symb.getLabel(); assertThat( label, allOf(instanceOf(Literal.class), hasProperty("value", equalTo("test literal")))); }
@Test public void testFilter() throws Exception { FilterFactory2 filterFactory = CommonFactoryFinder.getFilterFactory2(); StyleFactory styleFactory = CommonFactoryFinder.getStyleFactory(); StyledLayerDescriptor sld = styleFactory.createStyledLayerDescriptor(); UserLayer layer = styleFactory.createUserLayer(); sld.layers().add(layer); Style style = styleFactory.createStyle(); layer.userStyles().add(style); Rule rule = styleFactory.createRule(); rule.setFilter(filterFactory.less(filterFactory.property("foo"), filterFactory.literal(2))); style.featureTypeStyles().add(styleFactory.createFeatureTypeStyle()); style.featureTypeStyles().get(0).rules().add(rule); PointSymbolizer p = styleFactory.createPointSymbolizer(); rule.symbolizers().add((Symbolizer) p); StringWriter out = new StringWriter(); Ysld.encode(sld, out); YamlMap obj = new YamlMap(YamlUtil.getSafeYaml().load(out.toString())); YamlMap result = obj.seq("feature-styles").map(0).seq("rules").map(0); assertThat(result, yHasEntry("filter", equalTo("${foo < 2}"))); }
FeatureTypeStyle fs = SLD.defaultStyle(sld).featureTypeStyles().get(0); Expression tx = fs.getTransformation(); assertNotNull(tx); assertThat(pf, hasProperty("name", equalTo("ras:Contour"))); Function param1 = (Function) pf.getParameters().get(1); Function param0 = (Function) pf.getParameters().get(0); assertThat(param1, rtParam("levels", literal(-5), literal(0), literal(5))); assertThat( param0, rtParam("data", allOf(hasProperty("name", equalTo("vec:BarnesSurface")))));
@Test public void testLabelShield() throws IOException { StyleFactory sf = CommonFactoryFinder.getStyleFactory(); FilterFactory ff = CommonFactoryFinder.getFilterFactory(); StyledLayerDescriptor sld = sf.createStyledLayerDescriptor(); UserLayer layer = sf.createUserLayer(); sld.layers().add(layer); Style style = sf.createStyle(); layer.userStyles().add(style); FeatureTypeStyle featureStyle = sf.createFeatureTypeStyle(); style.featureTypeStyles().add(featureStyle); Rule rule = sf.createRule(); featureStyle.rules().add(rule); Stroke stroke = sf.stroke(ff.literal("#555555"), null, null, null, null, null, null); rule.symbolizers().add(sf.lineSymbolizer("line", null, null, null, stroke, null)); Mark mark = sf.mark(ff.literal("circle"), sf.fill(null, ff.literal("#995555"), null), null); List<GraphicalSymbol> symbols = new ArrayList<GraphicalSymbol>(); null); text.setGraphic(sf.graphic(symbols, null, null, null, null, null)); rule.symbolizers().add(text);
@Test public void testLabelLinePlacement() throws IOException { StyleFactory sf = CommonFactoryFinder.getStyleFactory(); FilterFactory ff = CommonFactoryFinder.getFilterFactory(); StyledLayerDescriptor sld = sf.createStyledLayerDescriptor(); UserLayer layer = sf.createUserLayer(); sld.layers().add(layer); Style style = sf.createStyle(); layer.userStyles().add(style); FeatureTypeStyle featureStyle = sf.createFeatureTypeStyle(); style.featureTypeStyles().add(featureStyle); Rule rule = sf.createRule(); featureStyle.rules().add(rule); LabelPlacement place = sf.createLinePlacement(ff.literal(10)); null, null); rule.symbolizers().add(text); yHasEntry("placement", equalTo("line"))); assertThat( yaml.lookupY("feature-styles/0/rules/0/symbolizers/0/text"), yHasEntry("offset", equalTo(10)));
@SuppressWarnings("unchecked") @Test public void testZoomSimple() throws IOException { String yaml = "grid:\n" + " initial-scale: 5000000\n" + "feature-styles: \n" + "- name: name\n" + " rules:\n" + " - zoom: " + tuple(0, 0) + "\n"; StyledLayerDescriptor sld = Ysld.parse(yaml); FeatureTypeStyle fs = SLD.defaultStyle(sld).featureTypeStyles().get(0); assertThat( (Iterable<Rule>) fs.rules(), hasItems( allOf( appliesToScale(5000000), not(appliesToScale(5000000 / 2)), not(appliesToScale(5000000 * 2))))); }
@Test public void testRenderingTransformation() throws IOException { String yaml = "feature-styles: \n" + "- transform:\n" + " name: ras:Contour\n" + " params:\n" + " levels:\n" + " - 1000\n" + " - 1100\n" + " - 1200\n"; StyledLayerDescriptor sld = Ysld.parse(yaml); FeatureTypeStyle fs = SLD.defaultStyle(sld).featureTypeStyles().get(0); Expression tx = fs.getTransformation(); assertNotNull(tx); ProcessFunction pf = (ProcessFunction) tx; assertThat( pf, hasProperty( "parameters", containsInAnyOrder( rtParam("data"), rtParam("levels", literal(1000), literal(1100), literal(1200))))); }
@Test public void testFTSVendorOption() throws Exception { PointSymbolizer p = CommonFactoryFinder.getStyleFactory().createPointSymbolizer(); FeatureTypeStyle fts = fts(p); fts.getOptions().put("foo", "bar"); StringWriter out = new StringWriter(); Ysld.encode(sld(fts), out); System.out.append(out.toString()); YamlMap obj = new YamlMap(YamlUtil.getSafeYaml().load(out.toString())); YamlMap result = obj.seq("feature-styles").map(0); assertThat(result.str("x-foo"), equalTo("bar")); }
@Test public void testFilterWithEscape() throws Exception { String yaml = "rules: \n" + "- filter: ${foo = '\\$\\}'}\n"; StyledLayerDescriptor sld = Ysld.parse(yaml); Rule r = SLD.defaultStyle(sld).featureTypeStyles().get(0).rules().get(0); Filter f = r.getFilter(); assertThat(f, Matchers.instanceOf(PropertyIsEqualTo.class)); assertThat(((PropertyIsEqualTo) f).getExpression1(), attribute("foo")); assertThat(((PropertyIsEqualTo) f).getExpression2(), literal("$}")); }
@Test public void testZoomSimpleRange() throws IOException { String yaml = "grid:\n" + " initial-scale: 5000000\n" + "feature-styles: \n" + "- name: name\n" + " rules:\n" + " - zoom: " + tuple(1, 2) + "\n"; StyledLayerDescriptor sld = Ysld.parse(yaml); FeatureTypeStyle fs = SLD.defaultStyle(sld).featureTypeStyles().get(0); Rule r = fs.rules().get(0); assertThat(r, appliesToScale(5000000 / 2)); // Z=1 assertThat(r, appliesToScale(5000000 / 4)); // Z=2 assertThat(r, not(appliesToScale(5000000))); // Z=0 assertThat(r, not(appliesToScale(5000000 / 8))); // Z=3 }
LineSymbolizer ls = styleFactory.createLineSymbolizer(); ls.setStroke( styleFactory.createStroke( filterFactory.literal(color), filterFactory.literal(2))); PolygonSymbolizer ps = styleFactory.createPolygonSymbolizer(); ps.setFill(styleFactory.createFill(filterFactory.literal(color))); Rule r = styleFactory.createRule(); r.symbolizers().add(sym); FeatureTypeStyle fts = styleFactory.createFeatureTypeStyle(); fts.rules().add(r); Style s = styleFactory.createStyle(); s.featureTypeStyles().add(fts); UserLayer l = styleFactory.createUserLayer();
@SuppressWarnings({"deprecation"}) private static Style createStyle() { StyleFactory styleFactory = CommonFactoryFinder.getStyleFactory(null); FilterFactory filterFactory = CommonFactoryFinder.getFilterFactory(null); PolygonSymbolizer symbolizer = styleFactory.createPolygonSymbolizer(); Fill fill = styleFactory.createFill( filterFactory.literal("#FFAA00"), filterFactory.literal(0.5) ); symbolizer.setFill(fill); Rule rule = styleFactory.createRule(); rule.setSymbolizers(new Symbolizer[]{symbolizer}); FeatureTypeStyle fts = styleFactory.createFeatureTypeStyle(); fts.setRules(new Rule[]{rule}); Style style = styleFactory.createStyle(); style.addFeatureTypeStyle(fts); return style; }
PointSymbolizer ps = (PointSymbolizer) style.featureTypeStyles().get(0).rules().get(0).symbolizers().get(0); FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2(null); ps.setGeometry(ff.function("convert", ff.property("wkt"), ff.literal(Point.class)));