@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; } });
try { Style parsedStyle = parsedStyleResources(s); parsedStyle.accept( new AbstractStyleVisitor() { @Override
public void visit(Style style) { Style copy = null; FeatureTypeStyle[] fts = style.getFeatureTypeStyles(); final int length = fts.length; FeatureTypeStyle[] ftsCopy = new FeatureTypeStyle[length]; for (int i = 0; i < length; i++) { if (fts[i] != null) { fts[i].accept(this); ftsCopy[i] = (FeatureTypeStyle) pages.pop(); } } copy = sf.createStyle(); copy.setAbstract(style.getAbstract()); copy.setName(style.getName()); copy.setTitle(style.getTitle()); copy.setFeatureTypeStyles(ftsCopy); if (STRICT && !copy.equals(style)) { throw new IllegalStateException("Was unable to duplicate provided Style:" + style); } pages.push(copy); }
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",
@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}"))); }
@Test public void testLabelDisplacement() 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); null, null); rule.symbolizers().add(text); yHasEntry("placement", equalTo("point"))); assertThat( yaml.lookupY("feature-styles/0/rules/0/symbolizers/0/text"), assertThat( yaml.lookupY("feature-styles/0/rules/0/symbolizers/0/text"), yHasEntry("rotation", equalTo(90))); assertThat(kvpLine(out.toString(), "displacement"), equalTo("[10, 15]"));
@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)));
@Test public void testRenderingTransformationInput() throws IOException { StyleFactory styleFactory = CommonFactoryFinder.getStyleFactory(); FilterFactory filterFactory = CommonFactoryFinder.getFilterFactory(); StyledLayerDescriptor sld = styleFactory.createStyledLayerDescriptor(); UserLayer layer = styleFactory.createUserLayer(); sld.layers().add(layer); Style style = styleFactory.createStyle(); layer.userStyles().add(style); FeatureTypeStyle featureStyle = styleFactory.createFeatureTypeStyle(); style.featureTypeStyles().add(featureStyle); featureStyle.setTransformation(rt); yHasEntry( "params", allOf( not(yHasEntry("data")), not(yHasEntry("alternateInput")), yHasEntry( "levels",
@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 testFilterFunctionWithMarker2() throws Exception { String yaml = "rules: \n" + "- filter: ${scalerank < 4}\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(PropertyIsLessThan.class)); assertThat(((PropertyIsLessThan) f).getExpression1(), attribute("scalerank")); assertThat(((PropertyIsLessThan) f).getExpression2(), literal(4)); }
@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 }
public Style getLISAStyle(String propertyName) { final String styleName = "LISA"; final String[] classValues = { "HH", "LH", "LL", "HL", "" }; final String[] classDescs = { "H-H", "L-H", "L-L", "H-L", "None" }; // http://www.w3schools.com/tags/ref_color_tryit.asp // Color.Tomato, Color.LightGoldenrodYellow, Color.CornflowerBlue, Color.Thistle final Color[] colorList = { new Color(255, 99, 71), new Color(250, 250, 210), new Color(100, 149, 237), new Color(216, 191, 216), new Color(225, 225, 225) }; FeatureTypeStyle featureTypeStyle = sf.createFeatureTypeStyle(); featureTypeStyle.setName(styleName); for (int k = 0; k < classValues.length; k++) { Fill fill = sf.createFill(ff.literal(colorList[k]), ff.literal(opacity)); Symbolizer symbolizer = sf.createPolygonSymbolizer(lineStroke, fill, geometryField); symbolizer.setName(classDescs[k]); Rule rule = sf.createRule(); rule.setName(classDescs[k]); rule.setFilter(ff.equal(ff.property(propertyName), ff.literal(classValues[k]), false)); rule.symbolizers().add(symbolizer); featureTypeStyle.rules().add(rule); } Style style = sf.createStyle(); style.featureTypeStyles().add(featureTypeStyle); style.setName(styleName); return style; }
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();
@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))))); }
throws IllegalFilterException { PropertyName value = ff.property(name); String geomName = schema.getGeometryDescriptor().getLocalName(); PropertyIsLessThan cf1 = ff.less(value, ff.literal(breaks[0])); rules[0] = sf.createRule(); rules[0].setFilter(cf1); rules[0].setSymbolizers(new Symbolizer[] {symb1}); LOGGER.fine("added low class " + breaks[0] + " " + colors[0]); rules[i] = sf.createRule(); rules[i].setSymbolizers(new Symbolizer[] {symb}); rules[i].setFilter(cf); rules[colors.length - 1] = sf.createRule(); rules[colors.length - 1].setFilter(cf2); rules[colors.length - 1].setName(geomName); FeatureTypeStyle ft = sf.createFeatureTypeStyle(rules); ft.setFeatureTypeName("Feature"); ft.setName(name); ret.addFeatureTypeStyle(ft);
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)));
@Test public void testFunction() throws Exception { StyleFactory styleFactory = CommonFactoryFinder.getStyleFactory(); FilterFactory filterFactory = CommonFactoryFinder.getFilterFactory(); StyledLayerDescriptor sld = styleFactory.createStyledLayerDescriptor(); UserLayer layer = styleFactory.createUserLayer(); sld.layers().add(layer); Style style = styleFactory.createStyle(); layer.userStyles().add(style); Rule rule = styleFactory.createRule(); style.featureTypeStyles().add(styleFactory.createFeatureTypeStyle()); style.featureTypeStyles().get(0).rules().add(rule); Function func = filterFactory.function( "strEndsWith", filterFactory.property("foo"), filterFactory.literal("bar")); rule.setFilter(filterFactory.equal(func, filterFactory.literal(true), false)); StringWriter out = new StringWriter(); Ysld.encode(sld, out); YamlMap obj = new YamlMap(YamlUtil.getSafeYaml().load(out.toString())); String filter = obj.seq("feature-styles").map(0).seq("rules").map(0).str("filter"); assertEquals("${strEndsWith(foo,'bar') = true}", filter); }