/** * reate a simple styling rule * * @param symbolizers - an array of symbolizers to use * @return the new rule */ public Rule createRule(Symbolizer[] symbolizers) { return createRule(symbolizers, Double.NaN, Double.NaN); }
/** * create a simple styling rule * * @param symbolizer - the symbolizer to use * @return the new rule */ public Rule createRule(Symbolizer symbolizer) { return createRule(symbolizer, Double.NaN, Double.NaN); }
/** * create a simple styling rule, see the SLD Spec for more details of scaleDenominators * * @param symbolizer - the symbolizer to use * @param minScaleDenominator - the minimim scale to draw the feature at * @param maxScaleDenominator - the maximum scale to draw the feature at * @return the new rule */ public Rule createRule( Symbolizer symbolizer, double minScaleDenominator, double maxScaleDenominator) { return createRule(new Symbolizer[] {symbolizer}, minScaleDenominator, maxScaleDenominator); }
/** * 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 symbolizers - an array of symbolizers to use * @param minScaleDenominator - the minimim scale to draw the feature at * @param maxScaleDenominator - the maximum scale to draw the feature at * @return the new feature type styler */ public FeatureTypeStyle createFeatureTypeStyle( String typeName, Symbolizer[] symbolizers, double minScaleDenominator, double maxScaleDenominator) { Rule r = createRule(symbolizers, minScaleDenominator, maxScaleDenominator); // setup the feature type style FeatureTypeStyle fts = sf.createFeatureTypeStyle(); fts.setRules(new Rule[] {r}); if (typeName != null) { fts.setFeatureTypeName(typeName); } return fts; }
Rule rule = sb.createRule(symb);
/** * reate a simple styling rule * * @param symbolizers - an array of symbolizers to use * * @return the new rule */ public Rule createRule(Symbolizer[] symbolizers) { return createRule(symbolizers, Double.NaN, Double.NaN); }
/** * create a simple styling rule * * @param symbolizer - the symbolizer to use * * @return the new rule */ public Rule createRule(Symbolizer symbolizer) { return createRule(symbolizer, Double.NaN, Double.NaN); }
/** * create a simple styling rule * * @param symbolizer - the symbolizer to use * * @return the new rule */ public Rule createRule(Symbolizer symbolizer) { return createRule(symbolizer, Double.NaN, Double.NaN); }
@Test public void testPlainFilter() { Filter f = ff.greater(ff.property("attribute"), ff.literal(10)); Rule r = sb.createRule(sb.createPointSymbolizer()); r.setFilter(f); StyleAttributeExtractor extractor = new StyleAttributeExtractor(); r.accept(extractor); Set<String> atts = extractor.getAttributeNameSet(); assertTrue(atts.contains("attribute")); assertEquals(1, atts.size()); assertTrue(extractor.getDefaultGeometryUsed()); }
@Test public void testGeometryTransformation() { PointSymbolizer ps = sb.createPointSymbolizer(); ps.setGeometry( ff.function( "offset", ff.property("the_geom"), ff.property("offx"), ff.property("offy"))); Rule r = sb.createRule(ps); StyleAttributeExtractor extractor = new StyleAttributeExtractor(); r.accept(extractor); Set<String> atts = extractor.getAttributeNameSet(); assertEquals(3, atts.size()); assertTrue(atts.contains("the_geom")); assertTrue(atts.contains("offx")); assertTrue(atts.contains("offy")); assertFalse(extractor.getDefaultGeometryUsed()); }
@Test public void testLineSymbolizer() { // Try with property Expression expression = ff.property("attribute"); LineSymbolizer lineSymbolizer = sb.createLineSymbolizer(); lineSymbolizer.setPerpendicularOffset(expression); Rule r = sb.createRule(lineSymbolizer); StyleAttributeExtractor extractor = new StyleAttributeExtractor(); r.accept(extractor); Set<String> atts = extractor.getAttributeNameSet(); assertTrue(atts.contains("attribute")); assertEquals(1, atts.size()); // Try without property but with a literal value lineSymbolizer.setPerpendicularOffset(ff.literal(34.12)); extractor = new StyleAttributeExtractor(); r.accept(extractor); atts = extractor.getAttributeNameSet(); assertEquals(0, atts.size()); } }
@Test public void testConstantFunction() { Function cos = ff.function("cos", ff.literal(Math.toRadians(Math.PI))); Symbolizer ls = sb.createLineSymbolizer(sb.createStroke(sb.colorExpression(Color.BLACK), cos)); Rule r = sb.createRule(new Symbolizer[] {ls}); MetaBufferEstimator rbe = new MetaBufferEstimator(); // cos(pi) == 1 rbe.visit(r); assertEquals(1, rbe.getBuffer()); assertTrue(rbe.isEstimateAccurate()); }
Function func = ff.function("property", ff.function("env", ff.literal("pname"))); PropertyIsEqualTo filter = ff.equals(func, ff.literal("test")); Rule r = sb.createRule(ps); r.setFilter(filter);
@Test public void testMultiSymbolizers() { Symbolizer ls = sb.createLineSymbolizer(sb.createStroke(10.8)); Symbolizer ps = sb.createPolygonSymbolizer(sb.createStroke(12), sb.createFill()); Rule r = sb.createRule(new Symbolizer[] {ls, ps}); MetaBufferEstimator rbe = new MetaBufferEstimator(); rbe.visit(r); assertEquals(12, rbe.getBuffer()); assertTrue(rbe.isEstimateAccurate()); }
final Rule rule = sb.createRule(symbolizer);
opacity, defaultStroke); Rule elseRule = sb.createRule(symb); elseRule.setIsElseFilter(true); elseRule.setTitle("Else");
@Test public void testMath() { Add add = ff.add(ff.literal("5"), ff.literal("-2")); Symbolizer ls = sb.createLineSymbolizer(sb.createStroke(sb.colorExpression(Color.BLACK), add)); Rule r = sb.createRule(new Symbolizer[] {ls}); MetaBufferEstimator rbe = new MetaBufferEstimator(); // 5-2 = 3 rbe.visit(r); assertEquals(3, rbe.getBuffer()); assertTrue(rbe.isEstimateAccurate()); }
@Test public void testPropertyWidth() { Symbolizer ls = sb.createLineSymbolizer( sb.createStroke( sb.colorExpression(Color.BLACK), sb.attributeExpression("gimbo"))); Symbolizer ps = sb.createPolygonSymbolizer(sb.createStroke(12), sb.createFill()); Rule r = sb.createRule(new Symbolizer[] {ls, ps}); MetaBufferEstimator rbe = new MetaBufferEstimator(); rbe.visit(r); assertEquals(12, rbe.getBuffer()); assertTrue(!rbe.isEstimateAccurate()); }
Rule rule = sb.createRule(symb); rule.setFilter(filter); rule.setTitle(title);
@Test public void testEnvironmentWidth() { Symbolizer ls = sb.createLineSymbolizer( sb.createStroke( sb.colorExpression(Color.BLACK), ff.function("env", ff.literal("thickness"), ff.literal(10)))); Rule r = sb.createRule(new Symbolizer[] {ls}); MetaBufferEstimator rbe = new MetaBufferEstimator(); // no env variable, fall back on the default value rbe.visit(r); assertEquals(10, rbe.getBuffer()); assertTrue(rbe.isEstimateAccurate()); // set the env variable EnvFunction.setLocalValue("thickness", 15); try { rbe.visit(r); assertEquals(15, rbe.getBuffer()); assertTrue(rbe.isEstimateAccurate()); } finally { EnvFunction.clearLocalValues(); } }