static boolean isCompositingBase(FeatureTypeStyle fts) { return "true".equalsIgnoreCase(fts.getOptions().get(FeatureTypeStyle.COMPOSITE_BASE)); }
@Override public void visit(FeatureTypeStyle fts) { super.visit(fts); FeatureTypeStyle copy = (FeatureTypeStyle) pages.peek(); copy.getOptions().remove(FeatureTypeStyle.COMPOSITE); copy.getOptions().remove(FeatureTypeStyle.COMPOSITE_BASE); } };
assertEquals(1, style.featureTypeStyles().size()); FeatureTypeStyle fts = style.featureTypeStyles().get(0); assertEquals("first", fts.getOptions().get("ruleEvaluation")); assertEquals(4, fts.rules().size()); assertEquals(
@Override public void visit(FeatureTypeStyle fts) { super.visit(fts); Map<String, String> options = fts.getOptions(); checkAlphaComposite(options); }
private static Composite getComposite(List<Layer> layers) { Layer layer = layers.get(0); if (layer instanceof ZGroupLayer) { return ((ZGroupLayer) layer).getComposite(); } Style styles = layer.getStyle(); List<FeatureTypeStyle> featureTypeStyles = styles.featureTypeStyles(); if (featureTypeStyles.size() > 0) { FeatureTypeStyle firstFts = featureTypeStyles.get(0); Composite composite = SLDStyleFactory.getComposite(firstFts.getOptions()); return composite; } else { return null; } }
private void forceSortByGroup(Style style, String sortByGroup) { if (sortByGroup != null) { for (FeatureTypeStyle fts : style.featureTypeStyles()) { fts.getOptions().put(FeatureTypeStyle.SORT_BY_GROUP, sortByGroup); } } }
private void forceSortBy(Style style, String sortBy) { if (sortBy != null) { for (FeatureTypeStyle fts : style.featureTypeStyles()) { fts.getOptions().put(FeatureTypeStyle.SORT_BY, sortBy); } } }
private static List<Layer> arrangeOnZGroups(Layer layer, ZGroupLayer previousGroup) { List<Layer> splitLayers = new ArrayList<>(); if (previousGroup != null) { splitLayers.add(previousGroup); } String currentGroupId = previousGroup != null ? previousGroup.getGroupId() : null; List<FeatureTypeStyle> featureTypeStyles = new ArrayList<>(); for (FeatureTypeStyle fts : layer.getStyle().featureTypeStyles()) { String groupName = fts.getOptions().get(FeatureTypeStyle.SORT_BY_GROUP); if (!(groupName == currentGroupId || (groupName != null && groupName.equals(currentGroupId))) && !featureTypeStyles.isEmpty()) { // the group name changed, dump the current feature type styles addToSplitLayers( layer, previousGroup, splitLayers, currentGroupId, featureTypeStyles); } featureTypeStyles.add(fts); currentGroupId = groupName; } // add the residual fts, if needed if (featureTypeStyles != null) { addToSplitLayers(layer, previousGroup, splitLayers, currentGroupId, featureTypeStyles); } return splitLayers; }
public FeatureTypeStyle build() { if (unset) { return null; } List<org.opengis.style.Rule> list = new ArrayList<org.opengis.style.Rule>(); for (RuleBuilder ruleBuilder : rules) { list.add(ruleBuilder.build()); } FeatureTypeStyle fts = sf.featureTypeStyle( name, description.build(), definedFor.build(), featureTypeNames, types, list); if (!options.isEmpty()) { fts.getOptions().putAll(options); } fts.setTransformation(transformation); if (parent == null) { reset(); } return fts; }
if (layer.getStyle() != null) { for (FeatureTypeStyle fts : layer.getStyle().featureTypeStyles()) { Map<String, String> options = fts.getOptions(); String groupName = options.get(FeatureTypeStyle.SORT_BY_GROUP); if (groupName != null && !groupName.trim().isEmpty()) {
public FeatureTypeStyleBuilder reset(FeatureTypeStyle fts) { if (fts == null) { return unset(); } this.name = fts.getName(); this.description.reset(fts.getDescription()); this.definedFor.reset(fts.getFeatureInstanceIDs()); this.featureTypeNames.clear(); if (fts.featureTypeNames() != null) { this.featureTypeNames.addAll(fts.featureTypeNames()); } this.rules.clear(); if (fts.rules() != null) { for (Rule rule : fts.rules()) { this.rules.add(new RuleBuilder(this).reset(rule)); } } this.options.clear(); this.options.putAll(fts.getOptions()); this.transformation = fts.getTransformation(); this.unset = false; return this; }
boolean cleanupStyle = false; for (FeatureTypeStyle fts : featureTypeStyles) { Map<String, String> options = fts.getOptions(); String compositingBaseDefinition = options.get(FeatureTypeStyle.COMPOSITE_BASE); if ("true".equalsIgnoreCase(compositingBaseDefinition)) {
private static FeatureLayer buildNewFeatureLayer(Layer layer, Style style) { FeatureLayer singleGroupLayer = new FeatureLayer(layer.getFeatureSource(), style); SortBy[] sortBy = SLDStyleFactory.getSortBy(style.featureTypeStyles().get(0).getOptions()); Query nativeQuery = layer.getQuery(); Query query = ensureSortProperties(nativeQuery, sortBy); singleGroupLayer.setQuery(query); singleGroupLayer.setTitle(layer.getTitle()); return singleGroupLayer; }
@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 testZOrderComposite() throws Exception { Style roadsStyle = RendererBaseTest.loadStyle(this, "zorder/zroads.sld"); forceSortBy(roadsStyle, "z"); forceSortByGroup(roadsStyle, "theGroup"); FeatureTypeStyle fts = roadsStyle.featureTypeStyles().get(0); fts.getOptions().put(FeatureTypeStyle.COMPOSITE_BASE, "true"); fts.getOptions().put(FeatureTypeStyle.COMPOSITE, "destination-in"); Style buildingsStyle = RendererBaseTest.loadStyle(this, "zorder/zbuildings.sld"); MapContent mc = new MapContent(); mc.addLayer(new FeatureLayer(zbuildings, buildingsStyle)); mc.addLayer(new FeatureLayer(zroads, roadsStyle)); runImageComparison("zorder-composite.png", mc); } }
@Override public void handle(YamlObject<?> obj, YamlParseContext context) { YamlSeq seq = obj.seq(); for (YamlObject<?> o : seq) { YamlMap fs = o.map(); FeatureTypeStyle featureStyle = factory.style.createFeatureTypeStyle(); style.featureTypeStyles().add(featureStyle); featureStyle.setName(fs.str("name")); if (fs.has("title")) { featureStyle.getDescription().setTitle(fs.str("title")); } if (fs.has("abstract")) { featureStyle.getDescription().setAbstract(fs.str("abstract")); } featureStyle.getOptions().putAll(Util.vendorOptions(fs)); context.push(fs, "transform", new TransformHandler(featureStyle, factory)); context.push(fs, "rules", new RuleParser(featureStyle, factory)); } } }
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 BufferedImage composeFts(GridCoverage2D first, GridCoverage2D second) { // build the map content MapContent mc = new MapContent(); StyleBuilder sb = new StyleBuilder(); Style baseStyle = sb.createStyle(sb.createRasterSymbolizer()); mc.addLayer(new GridCoverageLayer(first, baseStyle)); FeatureTypeStyle compositeFts = sb.createFeatureTypeStyle(sb.createRasterSymbolizer()); compositeFts.getOptions().put(FeatureTypeStyle.COMPOSITE, composite); Style compositeStyle = sb.createStyle(); compositeStyle.featureTypeStyles().add(compositeFts); mc.addLayer(new GridCoverageLayer(second, compositeStyle)); // prepare the graphics for the streaming renderer and paint RenderedImage referenceImage = first.getRenderedImage(); BufferedImage blended = new BufferedImage( referenceImage.getWidth(), referenceImage.getWidth(), BufferedImage.TYPE_4BYTE_ABGR); Graphics2D graphics = blended.createGraphics(); StreamingRenderer sr = new StreamingRenderer(); sr.setMapContent(mc); sr.paint( graphics, new Rectangle(0, 0, referenceImage.getWidth(), referenceImage.getHeight()), ReferencedEnvelope.reference(first.getEnvelope())); graphics.dispose(); mc.dispose(); return blended; }
@Override protected void encode(FeatureTypeStyle featureStyle) { put("name", featureStyle.getName()); put("title", featureStyle.getTitle()); put("abstract", featureStyle.getAbstract()); if (featureStyle.getTransformation() != null) { push("transform").inline(new TransformEncoder(featureStyle.getTransformation())); pop(); } put("rules", new RuleEncoder(featureStyle)); vendorOptions(featureStyle.getOptions()); } }
public void testFeatureTypeStyle() throws Exception { FeatureTypeStyle fts = sf.createFeatureTypeStyle(); fts.setFeatureTypeName("feature-type"); fts.getOptions().put("key", "value"); Rule rule1; rule1 = sf.createRule(); rule1.setName("rule1"); rule1.setFilter(ff.id(Collections.singleton(ff.featureId("FID")))); Rule rule2 = sf.createRule(); rule2.setIsElseFilter(true); rule2.setName("rule2"); fts.addRule(rule1); fts.addRule(rule2); fts.accept(visitor); FeatureTypeStyle clone = (FeatureTypeStyle) visitor.getCopy(); // assertClone(fts, clone); assertEqualsContract(fts, clone); rule1 = sf.createRule(); rule1.setName("rule1"); rule1.setFilter(ff.id(Collections.singleton(ff.featureId("FID")))); FeatureTypeStyle notEq = sf.createFeatureTypeStyle(); notEq.setName("fts-not-equal"); notEq.addRule(rule1); assertEqualsContract(clone, notEq, fts); fts.setTransformation(ff.literal("transformation")); fts.setOnlineResource(new OnLineResourceImpl()); fts.accept(visitor); clone = (FeatureTypeStyle) visitor.getCopy(); assertEqualsContract(fts, clone); }