/*
* GeoTools - The Open Source Java GIS Toolkit
* http://geotools.org
*
* (C) 2002-2008, Open Source Geospatial Foundation (OSGeo)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*/
package org.geotools.styling;
import java.awt.Color;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.geotools.data.AbstractDataStore;
import org.geotools.factory.CommonFactoryFinder;
import org.geotools.filter.Filters;
import org.geotools.styling.visitor.DuplicatingStyleVisitor;
import org.opengis.feature.simple.SimpleFeatureType;
import org.opengis.feature.type.FeatureType;
import org.opengis.feature.type.GeometryDescriptor;
import org.opengis.filter.Filter;
import org.opengis.filter.FilterFactory;
import org.opengis.filter.expression.Expression;
import org.opengis.style.GraphicalSymbol;
import org.opengis.style.SemanticType;
import com.vividsolutions.jts.geom.LineString;
import com.vividsolutions.jts.geom.MultiLineString;
import com.vividsolutions.jts.geom.MultiPoint;
import com.vividsolutions.jts.geom.MultiPolygon;
import com.vividsolutions.jts.geom.Point;
import com.vividsolutions.jts.geom.Polygon;
/**
* Utility class that provides static helper methods for common operations on
* GeoTools styling objects (e.g. StyledLayerDescriptor, Style, FeatureTypeStyle,
* Rule, Symbolizer, Stroke and Fill).
*
* @author Jody Garnett
*
* @source $URL$
* @version $Id$
*/
public class SLD {
private static StyleFactory sf = CommonFactoryFinder.getStyleFactory(null);
private static FilterFactory ff = CommonFactoryFinder.getFilterFactory(null);
/** <code>NOTFOUND</code> indicates int value was unavailable */
public static final int NOTFOUND = Filters.NOTFOUND;
public static final double ALIGN_LEFT = 1.0;
public static final double ALIGN_CENTER = 0.5;
public static final double ALIGN_RIGHT = 0.0;
public static final double ALIGN_BOTTOM = 1.0;
public static final double ALIGN_MIDDLE = 0.5;
public static final double ALIGN_TOP = 0.0;
/**
* Retrieve linestring color from linesymbolizer if available.
*
* @param symbolizer Line symbolizer information.
*
* @return Color of linestring, or null if unavailable.
*/
public static Color lineColor(LineSymbolizer symbolizer) {
if (symbolizer == null) {
return null;
}
Stroke stroke = symbolizer.getStroke();
return color(stroke);
}
/**
* Retrieve the color of a stroke object
* @param stroke a Stroke object
* @return color or null if stroke was null
*/
public static Color color(Stroke stroke) {
if (stroke == null) {
return null;
}
return color(stroke.getColor());
}
/**
* Retrieve the color of a fill object
* @param fill a Fill object
* @return color or null if fill was null
*/
public static Color color(Fill fill) {
if (fill == null) {
return null;
}
return color(fill.getColor());
}
/**
* Updates the color for line symbolizers in the current style.
* <p>
* This method will update the Style in place; some of the symbolizers
* will be replaced with modified copies.
*
* @param style the Style object to be updated
* @param colour Color to to use
*/
public static void setLineColour(Style style, final Color colour) {
if (style == null) {
return;
}
for (FeatureTypeStyle featureTypeStyle : style.featureTypeStyles()) {
for (int i = 0; i < featureTypeStyle.rules().size(); i++) {
Rule rule = featureTypeStyle.rules().get(i);
DuplicatingStyleVisitor update = new DuplicatingStyleVisitor() {
@Override
public void visit(LineSymbolizer line) {
String name = line.getGeometryPropertyName();
Stroke stroke = update(line.getStroke());
LineSymbolizer copy = sf.createLineSymbolizer(stroke, name);
pages.push(copy);
}
Stroke update(Stroke stroke) {
Expression color = ff.literal(colour);
Expression width = copy(stroke.getWidth());
Expression opacity = copy(stroke.getOpacity());
Expression lineJoin = copy(stroke.getLineJoin());
Expression lineCap = copy(stroke.getLineCap());
float[] dashArray = copy(stroke.getDashArray());
Expression dashOffset = copy(stroke.getDashOffset());
Graphic graphicStroke = copy(stroke.getGraphicStroke());
Graphic graphicFill = copy(stroke.getGraphicFill());
return sf.createStroke(color, width, opacity, lineJoin, lineCap, dashArray, dashOffset, graphicFill, graphicStroke);
}
};
rule.accept(update);
Rule updatedRule = (Rule) update.getCopy();
featureTypeStyle.rules().set(i, updatedRule);
}
}
}
/**
* Sets the Colour for the given Line symbolizer
*
* @param symbolizer
* @param colour
*/
public static void setLineColour(LineSymbolizer symbolizer, Color colour) {
if (symbolizer == null || colour == null) {
return;
}
Stroke stroke = symbolizer.getStroke();
if (stroke == null) {
stroke = sf.createStroke(ff.literal(colour), Stroke.DEFAULT.getWidth());
symbolizer.setStroke(stroke);
} else {
stroke.setColor(ff.literal(colour));
}
}
/**
* Retrieve color from linesymbolizer if available.
*
* @param symbolizer Line symbolizer information.
*
* @return Color of linestring, or null if unavailable.
*/
public static Color color(LineSymbolizer symbolizer) {
return lineColor(symbolizer);
}
/**
* Retrieve linestring width from symbolizer if available.
*
* @param symbolizer Line symbolizer information.
*
* @return width of linestring, or NOTFOUND
*/
public static int lineWidth(LineSymbolizer symbolizer) {
if (symbolizer == null) {
return NOTFOUND;
}
Stroke stroke = symbolizer.getStroke();
return width(stroke);
}
/**
* Retrieve the width of a Stroke object.
*
* @param stroke the Stroke object.
*
* @return width or {@linkplain #NOTFOUND} if not available.
*/
public static int width(Stroke stroke) {
if (stroke == null) {
return NOTFOUND;
}
return Filters.asInt(stroke.getWidth());
}
/**
* Retrieve the size of a Mark object
* @param mark the Mark object
* @return size or {@linkplain #NOTFOUND} if not available
* @deprecated please check graphic as an indication of mark size
*/
public static int size(Mark mark) {
return NOTFOUND;
}
/**
* Retrieve linestring width from symbolizer if available.
*
* @param symbolizer Line symbolizer information.
*
* @return width or {@linkplain #NOTFOUND} if not available
*/
public static int width(LineSymbolizer symbolizer) {
return lineWidth(symbolizer);
}
/**
* Retrieve the opacity from a LineSymbolizer object.
*
* @param symbolizer Line symbolizer information.
*
* @return double of the line symbolizer's opacity, or NaN if unavailable.
*/
public static double lineOpacity(LineSymbolizer symbolizer) {
if (symbolizer == null) {
return Double.NaN;
}
Stroke stroke = symbolizer.getStroke();
return opacity(stroke);
}
/**
* Retrieve the opacity from a Stroke object.
*
* @param stroke the Stroke object.
*
* @return double of the line stroke's opacity, or NaN if unavailable.
*/
public static double opacity(Stroke stroke) {
if (stroke == null) {
return Double.NaN;
}
return opacity( stroke.getOpacity() );
}
/**
* Retrieve the opacity from a RasterSymbolizer object.
*
* @param symbolizer raster symbolizer information.
*
* @return double of the raster symbolizer's opacity, or 1.0 if unavailable.
*/
public static double opacity(RasterSymbolizer rasterSymbolizer ){
if( rasterSymbolizer == null ){
return 1.0;
}
return opacity( rasterSymbolizer.getOpacity() );
}
/**
* Retrieve the opacity value of an Expression.
*
* @param opacity Expression object
*
* @returna double value or 1.0 if unavailable.
*/
private static double opacity( Expression opacity ) {
if( opacity == null ){
return 1.0;
}
double value = Filters.asDouble(opacity);
return (Double.isNaN(value) ? 1.0 : value);
}
/**
* Retrieves the linejoin from a LineSymbolizer.
*
* @param symbolizer Line symbolizer information.
*
* @return String of the linejoin, or null if unavailable.
*/
public static String lineLinejoin(LineSymbolizer symbolizer) {
if (symbolizer == null) {
return null;
}
Stroke stroke = symbolizer.getStroke();
if (stroke == null) {
return null;
}
Expression linejoinExp = stroke.getLineJoin();
return linejoinExp.toString();
}
/**
* Retrieves the line cap from a LineSymbolizer.
*
* @param symbolizer Line symbolizer information.
*
* @return String of the line stroke's line cap, or null if unavailable.
*/
public static String lineLinecap(LineSymbolizer symbolizer) {
if (symbolizer == null) {
return null;
}
Stroke stroke = symbolizer.getStroke();
if (stroke == null) {
return null;
}
Expression linecapExp = stroke.getLineCap();
return linecapExp.toString();
}
/**
* Retrieves the dashes array from a LineSymbolizer.
*
* @param symbolizer Line symbolizer information.
*
* @return float[] of the line dashes array, or null if unavailable.
*/
public static float[] lineDash(LineSymbolizer symbolizer) {
if (symbolizer == null) {
return null;
}
Stroke stroke = symbolizer.getStroke();
if (stroke == null) {
return null;
}
float[] linedash = stroke.getDashArray();
return linedash;
}
/**
* Retrieves the location of the first external graphic in
* a Style object.
*
* @param style SLD style information.
*
* @return Location of the first external graphic, or null if unavailabe.
*/
public static URL pointGraphic(Style style) {
PointSymbolizer point = pointSymbolizer(style);
if (point == null) {
return null;
}
Graphic graphic = point.getGraphic();
if (graphic == null) {
return null;
}
for (GraphicalSymbol gs : graphic.graphicalSymbols()) {
if (gs != null && gs instanceof ExternalGraphic) {
ExternalGraphic externalGraphic = (ExternalGraphic) gs;
try {
URL location = externalGraphic.getLocation(); // Should check format is supported by SWT
if (location != null) {
return location;
}
} catch (MalformedURLException e) {
// ignore, try the next one
}
}
}
return null;
}
/**
* Retrieves the first Mark used in a Style object.
*
* @param style the Style
*
* @return the first Mark object or null if unavailable.
*/
public static Mark pointMark(Style style) {
if (style == null) {
return null;
}
return mark(pointSymbolizer(style));
}
/**
* Retrieves the first Mark used in a PointSymbolizer object.
*
* @param sym the PointSymbolizer
*
* @return the first Mark object or null if unavailable.
*/
public static Mark mark(PointSymbolizer sym) {
return mark(graphic(sym));
}
/**
* Retrieves the first Mark object from the given Graphic object.
*
* @param graphic the Graphic object.
*
* @return a Mark object or null if unavailable.
*/
public static Mark mark(Graphic graphic) {
if (graphic == null) {
return null;
}
for (GraphicalSymbol gs : graphic.graphicalSymbols()) {
if (gs != null && gs instanceof Mark) {
return (Mark) gs;
}
}
return null;
}
public static Graphic graphic(PointSymbolizer sym) {
if (sym == null) {
return null;
}
return sym.getGraphic();
}
/**
* Retrieves the size of the point's graphic, if found.
* <p>
* If you are using something fun like symbols you will need to do your
* own thing.
*
* @param symbolizer Point symbolizer information.
*
* @return size of the graphic or {@linkplain #NOTFOUND}
*/
public static int pointSize(PointSymbolizer symbolizer) {
if (symbolizer == null) {
return NOTFOUND;
}
Graphic g = symbolizer.getGraphic();
if (g == null) {
return NOTFOUND;
}
Expression exp = g.getSize();
return Filters.asInt(exp);
}
/**
* Retrieves the well known name of the first Mark that has one in a
* PointSymbolizer object
* <p>
* If you are using something fun like symbols you will need to do your
* own thing.
*
* @param symbolizer Point symbolizer information.
*
* @return well known name of the first Mark or null if unavailable.
*/
public static String pointWellKnownName(PointSymbolizer symbolizer) {
if (symbolizer == null) {
return null;
}
Graphic graphic = symbolizer.getGraphic();
if (graphic == null) {
return null;
}
for (GraphicalSymbol gs : graphic.graphicalSymbols()) {
if (gs != null && gs instanceof Mark) {
Mark mark = (Mark) gs;
String s = wellKnownName(mark);
if (s != null) {
return s;
}
}
}
return null;
}
/**
* Retrieves the "well known name" of a Mark object.
*
* @param mark the Mark object
*
* @return well known name or null if unavailable.
*/
public static String wellKnownName(Mark mark) {
if (mark == null) {
return null;
}
Expression exp = mark.getWellKnownName();
if (exp == null) {
return null;
}
return Filters.asString(exp);
}
/**
* Retrieves the color of the first Mark in a PointSymbolizer object.
* This method is identical to {@linkplain #color(org.geotools.styling.PointSymbolizer)}.
* <p>
* If you are using something fun like symbols you will need to do your
* own thing.
*
* @param symbolizer Point symbolizer information.
*
* @return Color of the point's mark, or null if unavailable.
*/
public static Color pointColor(PointSymbolizer symbolizer) {
return color(symbolizer);
}
/**
* Sets the Colour for the point symbolizer
*
* @param style
* @param colour
*/
public static void setPointColour(Style style, Color colour) {
if (style == null) {
return;
}
setPointColour(pointSymbolizer(style), colour);
}
/**
* Sets the Colour for the given point symbolizer
*
* @param symbolizer the point symbolizer
*
* @param colour the new colour
*/
public static void setPointColour(PointSymbolizer symbolizer, Color colour) {
if (symbolizer == null || colour == null) {
return;
}
Graphic graphic = symbolizer.getGraphic();
if (graphic == null) {
graphic = sf.createDefaultGraphic();
}
for (GraphicalSymbol gs : graphic.graphicalSymbols()) {
if (gs != null && gs instanceof Mark) {
Mark mark = (Mark) gs;
Stroke stroke = mark.getStroke();
if (stroke == null) {
stroke = sf.createStroke(ff.literal(Color.BLACK), Stroke.DEFAULT.getWidth());
mark.setStroke(stroke);
}
Fill fill = mark.getFill();
if (fill != null) {
fill.setColor(ff.literal(colour));
}
}
}
}
/**
* Retrieves the color from the first Mark in a PointSymbolizer object.
* <p>
* If you are using something fun like symbols you will need to do your
* own thing.
*
* @param symbolizer Point symbolizer information.
*
* @return Color of the point's mark, or null if unavailable.
*/
public static Color color(PointSymbolizer symbolizer) {
if (symbolizer == null) {
return null;
}
Graphic graphic = symbolizer.getGraphic();
if (graphic == null) {
return null;
}
for (GraphicalSymbol gs : graphic.graphicalSymbols()) {
if (gs != null && gs instanceof Mark) {
Mark mark = (Mark) gs;
Stroke stroke = mark.getStroke();
if (stroke != null) {
Color colour = color(stroke);
if (colour != null) {
return colour;
}
}
}
}
return null;
}
/**
* Retrieves the width of the first Mark with a Stroke that has a non-null
* width.
* <p>
* If you are using something fun like symbols you will need to do your
* own thing.
*
* @param symbolizer Point symbolizer information.
*
* @return width of the points border or {@linkplain #NOTFOUND} if unavailable.
*/
public static int pointWidth(PointSymbolizer symbolizer) {
if (symbolizer == null) {
return NOTFOUND;
}
Graphic graphic = symbolizer.getGraphic();
if (graphic == null) {
return NOTFOUND;
}
for (GraphicalSymbol gs : graphic.graphicalSymbols()) {
if (gs != null && gs instanceof Mark) {
Mark mark = (Mark) gs;
Stroke stroke = mark.getStroke();
if (stroke != null) {
Expression exp = stroke.getWidth();
if (exp != null) {
int width = Filters.asInt(exp);
if (width != NOTFOUND) {
return width;
}
}
}
}
}
return NOTFOUND;
}
/**
* Retrieves the point border opacity from a PointSymbolizer.
* <p>
* If you are using something fun like rules you will need to do your own
* thing.
*
* @param symbolizer Point symbolizer information.
*
* @return double of the point's border opacity, or NaN if unavailable.
*/
public static double pointBorderOpacity(PointSymbolizer symbolizer) {
if (symbolizer == null) {
return Double.NaN;
}
Graphic graphic = symbolizer.getGraphic();
if (graphic == null) {
return Double.NaN;
}
for (GraphicalSymbol gs : graphic.graphicalSymbols()) {
if (gs != null && gs instanceof Mark) {
Mark mark = (Mark) gs;
Stroke stroke = mark.getStroke();
if (stroke != null) {
Expression exp = stroke.getOpacity();
return Filters.asDouble(exp);
}
}
}
return Double.NaN;
}
/**
* Retrieves the point opacity from a PointSymbolizer.
* <p>
* If you are using something fun like rules you will need to do your own
* thing.
*
* @param symbolizer Point symbolizer information.
*
* @return double of the point's opacity, or NaN if unavailable.
*/
public static double pointOpacity(PointSymbolizer symbolizer) {
if (symbolizer == null) {
return Double.NaN;
}
Graphic graphic = symbolizer.getGraphic();
if (graphic == null) {
return Double.NaN;
}
for (GraphicalSymbol gs : graphic.graphicalSymbols()) {
if (gs != null && gs instanceof Mark) {
Mark mark = (Mark) gs;
Fill fill = mark.getFill();
if (fill != null) {
Expression expr = fill.getOpacity();
if (expr != null) {
return SLD.opacity(expr);
}
}
}
}
return Double.NaN;
}
/**
* Retrieves the fill from the first Mark defined in a PointSymbolizer.
* <p>
* If you are using something fun like symbols you will need to do your
* own thing.
*
* @param symbolizer Point symbolizer information.
*
* @return Color of the point's fill, or null if unavailable.
*/
public static Color pointFill(PointSymbolizer symbolizer) {
if (symbolizer == null) {
return null;
}
Graphic graphic = symbolizer.getGraphic();
if (graphic == null) {
return null;
}
for (GraphicalSymbol gs : graphic.graphicalSymbols()) {
if (gs != null && gs instanceof Mark) {
Mark mark = (Mark) gs;
Fill fill = mark.getFill();
if (fill != null) {
Color colour = color(fill.getColor());
if (colour != null) {
return colour;
}
}
}
}
return null;
}
/**
* Retrieves the outline width from a PolygonSymbolizer
* <p>
* If you are using something fun like rules you will need to do your own
* thing.
*
* @param symbolizer Polygon symbolizer information.
*
* @return outline width or {@linkplain #NOTFOUND} if unavailable.
*/
public static int polyWidth(PolygonSymbolizer symbolizer) {
if (symbolizer == null) {
return NOTFOUND;
}
Stroke stroke = symbolizer.getStroke();
if (stroke != null) {
return Filters.asInt(stroke.getWidth());
}
return NOTFOUND;
}
/**
* Retrieves the outline (stroke) color from a PolygonSymbolizer.
* <p>
* If you are using something fun like rules you will need to do your own
* thing.
*
* @param symbolizer Polygon symbolizer information.
*
* @return Color of the polygon's stroke, or null if unavailable.
*/
public static Color polyColor(PolygonSymbolizer symbolizer) {
if (symbolizer == null) {
return null;
}
Stroke stroke = symbolizer.getStroke();
if (stroke == null) {
return null;
}
Color colour = color(stroke.getColor());
if (colour != null) {
return colour;
}
return null;
}
/**
* Updates the raster opacity in the current style
* <p>
* <b>Note:</b> This method will update the Style in place; some of the rules
* and symbolizers will be replaced with modified copies.
* All symbolizers associated with all rules are modified.
*
* @param style the Style object to be updated
* @param opacity - a new opacity value between 0 and 1
*/
public static void setRasterOpacity(Style style, final double opacity) {
if (style == null) {
return;
}
for (FeatureTypeStyle featureTypeStyle : style.featureTypeStyles()) {
for (int i = 0; i < featureTypeStyle.rules().size(); i++) {
Rule rule = featureTypeStyle.rules().get(i);
DuplicatingStyleVisitor update = new DuplicatingStyleVisitor() {
@Override
public void visit(RasterSymbolizer raster) {
ChannelSelection channelSelection = copy(raster.getChannelSelection());
ColorMap colorMap = copy(raster.getColorMap());
ContrastEnhancement ce = copy(raster.getContrastEnhancement());
String geometryProperty = raster.getGeometryPropertyName();
Symbolizer outline = copy(raster.getImageOutline());
Expression overlap = copy(raster.getOverlap());
ShadedRelief shadedRelief = copy(raster.getShadedRelief());
Expression newOpacity = ff.literal(opacity);
RasterSymbolizer copy = sf.createRasterSymbolizer(geometryProperty, newOpacity, channelSelection,
overlap, colorMap, ce, shadedRelief, outline);
if (STRICT && !copy.equals(raster)) {
throw new IllegalStateException("Was unable to duplicate provided raster:" + raster);
}
pages.push(copy);
}
};
rule.accept(update);
Rule updatedRule = (Rule) update.getCopy();
featureTypeStyle.rules().set(i, updatedRule);
}
}
}
/**
* Updates the raster channel selection in a Style object
* <p>
* This method will update the Style in place; some of the rules &
* symbolizers will be replace with modified copies.
* All symbolizes associated with all rules are updated.
*
* @param style the Style object to be updated
* @param rgb - an array of the new red, green, blue channels or null if setting the gray channel
* @param gray - the new gray channel; ignored if rgb is not null
*/
public static void setChannelSelection(Style style, final SelectedChannelType[] rgb, final SelectedChannelType gray) {
if (style == null) {
return;
}
for (FeatureTypeStyle featureTypeStyle : style.featureTypeStyles()) {
for (int i = 0; i < featureTypeStyle.rules().size(); i++) {
Rule rule = featureTypeStyle.rules().get(i);
DuplicatingStyleVisitor update = new DuplicatingStyleVisitor() {
@Override
public void visit(RasterSymbolizer raster) {
ChannelSelection channelSelection = createChannelSelection();
ColorMap colorMap = copy(raster.getColorMap());
ContrastEnhancement ce = copy(raster.getContrastEnhancement());
String geometryProperty = raster.getGeometryPropertyName();
Symbolizer outline = copy(raster.getImageOutline());
Expression overlap = copy(raster.getOverlap());
ShadedRelief shadedRelief = copy(raster.getShadedRelief());
Expression opacity = copy(raster.getOpacity());
RasterSymbolizer copy = sf.createRasterSymbolizer(geometryProperty, opacity,
channelSelection, overlap, colorMap, ce,
shadedRelief, outline);
if (STRICT && !copy.equals(raster)) {
throw new IllegalStateException("Was unable to duplicate provided raster:" + raster);
}
pages.push(copy);
}
private ChannelSelection createChannelSelection() {
if (rgb == null) {
return sf.createChannelSelection(new SelectedChannelType[]{gray});
} else {
return sf.createChannelSelection(rgb);
}
}
};
rule.accept(update);
Rule updatedRule = (Rule) update.getCopy();
featureTypeStyle.rules().set(i, updatedRule);
}
}
}
/**
* Sets the colour for the first polygon symbolizer defined in
* the provided style
*
* @param style the Style object
* @param colour the colour for polygon outlines and fill
*/
public static void setPolyColour(Style style, Color colour) {
if (style == null) {
return;
}
setPolyColour(polySymbolizer(style), colour);
}
/**
* Sets the colour to use for outline (stroke) and fill in a polygon symbolizer
*
* @param symbolizer the polygon symbolizer
* @param colour the colour for polygon outlines and fill
*/
public static void setPolyColour(PolygonSymbolizer symbolizer, Color colour) {
if (symbolizer == null || colour == null) {
return;
}
Expression colourExp = ff.literal(colour);
Stroke stroke = symbolizer.getStroke();
if (stroke == null) {
stroke = sf.createStroke(colourExp, Stroke.DEFAULT.getWidth());
symbolizer.setStroke(stroke);
} else {
stroke.setColor(ff.literal(colour));
}
Fill fill = symbolizer.getFill();
if (fill != null) {
fill.setColor(colourExp);
}
}
/**
* Retrieves the fill colour from a PolygonSymbolizer.
* <p>
* If you are using something fun like rules you will need to do your own
* thing.
*
* @param symbolizer Polygon symbolizer information.
*
* @return Color of the polygon's fill, or null if unavailable.
*/
public static Color polyFill(PolygonSymbolizer symbolizer) {
if (symbolizer == null) {
return null;
}
Fill fill = symbolizer.getFill();
if (fill == null) {
return null;
}
return color(fill.getColor());
}
/**
* Retrieves the border (stroke) opacity from a PolygonSymbolizer.
* <p>
* If you are using something fun like rules you will need to do your own
* thing.
*
* @param symbolizer Polygon symbolizer information.
*
* @return double of the polygon's border opacity, or NaN if unavailable.
*/
public static double polyBorderOpacity(PolygonSymbolizer symbolizer) {
if (symbolizer == null) {
return Double.NaN;
}
Stroke stroke = symbolizer.getStroke();
if (stroke == null) {
return Double.NaN;
}
return opacity(stroke);
}
/**
* Retrieves the fill opacity from the first PolygonSymbolizer.
* <p>
* If you are using something fun like rules you will need to do your own
* thing.
*
* @param symbolizer Polygon symbolizer information.
*
* @return double of the polygon's fill opacity, or NaN if unavailable.
*/
public static double polyFillOpacity(PolygonSymbolizer symbolizer) {
if (symbolizer == null) {
return Double.NaN;
}
Fill fill = symbolizer.getFill();
return opacity(fill);
}
/**
* Retrieve the opacity from the provided fill; or return the default.
* @param fill
* @return opacity from the above fill; or return the Fill.DEFAULT value
*/
public static double opacity(Fill fill) {
if (fill == null) {
fill = Fill.DEFAULT;
}
Expression opacityExp = fill.getOpacity();
if( opacityExp == null ){
opacityExp = Fill.DEFAULT.getOpacity();
}
return Filters.asDouble(opacityExp);
}
/**
* Retrieves the opacity from a RasterSymbolizer.
* <p>
* If you are using something fun like rules you will need to do your own
* thing.
* </p>
*
* @param symbolizer Raster symbolizer information.
* @return opacity of the first RasterSymbolizer or NaN if unavailable.
*/
public static double rasterOpacity(RasterSymbolizer symbolizer) {
if (symbolizer == null) {
return Double.NaN;
}
return Filters.asDouble(symbolizer.getOpacity());
}
/**
* Retrieves the opacity from the first RasterSymbolizer defined
* in a style.
*
* @param style the Style object
*
* @return opacity of the raster symbolizer or NaN if unavailable.
*/
public static double rasterOpacity(Style style) {
return rasterOpacity(rasterSymbolizer(style));
}
/**
* Retrieve the first TextSymbolizer from the provided FeatureTypeStyle.
*
* @param fts FeatureTypeStyle information.
*
* @return TextSymbolizer, or null if not found.
*/
public static TextSymbolizer textSymbolizer(FeatureTypeStyle fts) {
return (TextSymbolizer) symbolizer(fts, TextSymbolizer.class);
}
/**
* Retrieve the first TextSymbolizer from the provided Style.
*
* @param style the Style object
*
* @return TextSymbolizer, or null if not found.
*/
public static TextSymbolizer textSymbolizer(Style style) {
return (TextSymbolizer) symbolizer(style, TextSymbolizer.class);
}
/**
* Retrieves the font from a TextSymbolizer. Equivalent to
* {@code symbolizer.getFont()}.
*
* @param symbolizer the symbolizer
*
* @return the first font defined in the symbolizer or null if unavailable.
*/
public static Font font( TextSymbolizer symbolizer ) {
if(symbolizer == null) {
return null;
}
return symbolizer.getFont();
}
/**
* Retrieves the label from a TextSymbolizer.
*
* @param symbolizer Text symbolizer information.
*
* @return Expression of the label's text, or null if unavailable.
*/
public static Expression textLabel(TextSymbolizer symbolizer) {
if (symbolizer == null) {
return null;
}
Expression exp = symbolizer.getLabel();
if (exp == null) {
return null;
}
return exp;
}
/**
* Retrieves the label from a TextSymbolizer.
*
* @param symbolizer Text symbolizer information.
*
* @return the label's text, or null if unavailable.
*/
public static String textLabelString(TextSymbolizer sym) {
Expression exp = textLabel(sym);
return (exp == null) ? null : exp.toString();
}
/**
* Retrieves the colour of the font fill from a TextSymbolizer.
*
* @param symbolizer Text symbolizer information.
*
* @return Color of the font's fill, or null if unavailable.
*/
public static Color textFontFill(TextSymbolizer symbolizer) {
if (symbolizer == null) {
return null;
}
Fill fill = symbolizer.getFill();
if (fill == null) {
return null;
}
return color(fill.getColor());
}
/**
* Retrieves the colour of the halo fill a TextSymbolizer.
*
* @param symbolizer Text symbolizer information.
*
* @return Color of the halo's fill, or null if unavailable.
*/
public static Color textHaloFill(TextSymbolizer symbolizer) {
Halo halo = symbolizer.getHalo();
if (halo == null) {
return null;
}
Fill fill = halo.getFill();
if (fill == null) {
return null;
}
return color(fill.getColor());
}
/**
* Retrieves the halo width from a TextSymbolizer.
*
* @param symbolizer Text symbolizer information.
*
* @return the halo's width, or 0 if unavailable.
*/
public static int textHaloWidth(TextSymbolizer symbolizer) {
Halo halo = symbolizer.getHalo();
if (halo == null) {
return 0;
}
Expression exp = halo.getRadius();
if (exp == null) {
return 0;
}
int width = (int) Float.parseFloat(exp.toString());
if (width != 0) {
return width;
}
return 0;
}
/**
* Retrieves the halo opacity from the first TextSymbolizer.
*
* @param symbolizer Text symbolizer information.
*
* @return double of the halo's opacity, or NaN if unavailable.
*/
public static double textHaloOpacity(TextSymbolizer symbolizer) {
if (symbolizer == null) {
return Double.NaN;
}
Halo halo = symbolizer.getHalo();
if (halo == null) {
return Double.NaN;
}
Fill fill = halo.getFill();
if (fill == null) {
return Double.NaN;
}
Expression expr = fill.getOpacity();
if( expr == null ){
return Double.NaN;
}
return Filters.asDouble(expr);
}
/**
* Navigate through the expression finding the first mentioned Color.
* <p>
* If you have a specific Feature in mind please use:
* <pre><code>
* Object value = expr.getValue( feature );
* return value instanceof Color ? (Color) value : null;
* </code></pre>
*
* @param expr the Expression object
*
* @return First available color, or null.
*/
public static Color color(Expression expr) {
if (expr == null) {
return null;
}
return expr.evaluate(null, Color.class );
}
/**
* Retrieve the first RasterSymbolizer from the provided FeatureTypeStyle.
*
* @param fts the FeatureTypeStyle information.
*
* @return RasterSymbolizer, or null if not found.
*/
public static RasterSymbolizer rasterSymbolizer(FeatureTypeStyle fts) {
return (RasterSymbolizer) symbolizer(fts, RasterSymbolizer.class);
}
/**
* Retrieve the first RasterSymbolizer from the provided Style.
*
* @param style the Style object
*
* @return RasterSymbolizer, or null if not found.
*/
public static RasterSymbolizer rasterSymbolizer(Style style) {
return (RasterSymbolizer) symbolizer(style, RasterSymbolizer.class);
}
/**
* Retrieve the first LineSymbolizer from the provided FeatureTypeStyle.
*
* @param fts the FeatureTypeStyle object
*
* @return LineSymbolizer, or null if not found.
*/
public static LineSymbolizer lineSymbolizer(FeatureTypeStyle fts) {
return (LineSymbolizer) symbolizer(fts, LineSymbolizer.class);
}
/**
* Retrieve the first LineSymbolizer from the provided Style.
*
* @param style the Style object
*
* @return LineSymbolizer, or null if not found.
*/
public static LineSymbolizer lineSymbolizer(Style style) {
return (LineSymbolizer) symbolizer(style, LineSymbolizer.class);
}
/**
* Retrieves the Stroke from a LineSymbolizer.
* @param sym the symbolizer
* @return the Stroke or null if not found.
*/
public static Stroke stroke(LineSymbolizer sym) {
if (sym == null) {
return null;
}
return sym.getStroke();
}
/**
* Retrieves the Stroke from a PolygonSymbolizer.
* @param sym the symbolizer
* @return the Stroke or null if not found.
*/
public static Stroke stroke(PolygonSymbolizer sym) {
if (sym == null) {
return null;
}
return sym.getStroke();
}
/**
* Retrieves the Stroke from a PointSymbolizer.
* @param sym the symbolizer
* @return the Stroke or null if not found.
*/
public static Stroke stroke(PointSymbolizer sym) {
Mark mark = mark(sym);
return (mark == null) ? null : mark.getStroke();
}
/**
* Retrieves the Fill from a PolygonSymbolizer.
* @param sym the symbolizer
* @return the Fill or null if not found.
*/
public static Fill fill(PolygonSymbolizer sym) {
if (sym == null) {
return null;
}
return sym.getFill();
}
/**
* Retrieves the Fill from a PointSymbolizer.
* @param sym the symbolizer
* @return the Fill or null if not found.
*/
public static Fill fill(PointSymbolizer sym) {
Mark mark = mark(sym);
return (mark == null) ? null : mark.getFill();
}
/**
* Retrieve the first PointSymbolizer from the provided FeatureTypeStyle.
*
* @param fts the FeatureTypeStyle object
*
* @return PointSymbolizer, or null if not found.
*/
public static PointSymbolizer pointSymbolizer(FeatureTypeStyle fts) {
return (PointSymbolizer) symbolizer(fts, PointSymbolizer.class);
}
/**
* Retrieve the first PointSymbolizer from the provided Style.
*
* @param style the Style object
*
* @return PointSymbolizer, or null if not found.
*/
public static PointSymbolizer pointSymbolizer(Style style) {
return (PointSymbolizer) symbolizer(style, PointSymbolizer.class);
}
/**
* Retrieve the first PolygonSymbolizer from the provided FeatureTypeStyle.
*
* @param fts FeatureTypeStyle object.
*
* @return PolygonSymbolizer, or null if not found.
*/
public static PolygonSymbolizer polySymbolizer(FeatureTypeStyle fts) {
return (PolygonSymbolizer) symbolizer(fts, PolygonSymbolizer.class);
}
/**
* Retrieve the first PolygonSymbolizer from the provided Style.
*
* @param style the Style object
*
* @return PolygonSymbolizer, or null if not found.
*/
public static PolygonSymbolizer polySymbolizer(Style style) {
return (PolygonSymbolizer) symbolizer(style, PolygonSymbolizer.class);
}
/**
* Returns the feature type style in the style which matched a particular
* name.
*
* @param style the Style object
* @param type the feature type (must be non-null)
*
* @return The FeatureTypeStyle object if it exists, otherwise false.
*/
public static FeatureTypeStyle featureTypeStyle(Style style, SimpleFeatureType type) {
if (style == null) {
return null;
}
if ((type == null) || (type.getTypeName() == null)) {
return null;
}
for (FeatureTypeStyle fts : style.featureTypeStyles()) {
if (type.getTypeName().equalsIgnoreCase(fts.getName())) {
return fts;
}
}
return null;
}
/**
* Returns the first style object which matches a given schema.
*
* @param styles Array of style objects.
* @param schema Feature schema.
*
* @return The first object to match the feature type, otherwise null if no
* match.
*/
public static Style matchingStyle(Style[] styles, SimpleFeatureType schema) {
if ((styles == null) || (styles.length == 0)) {
return null;
}
for (int i = 0; i < styles.length; i++) {
Style style = styles[i];
if (featureTypeStyle(style, schema) != null) {
return style;
}
}
return null;
}
/**
* Retrieve the first Symbolizer from the provided Style.
*
* @param style SLD style information.
* @param SYMBOLIZER LineSymbolizer.class, PointSymbolizer.class,
* PolygonSymbolizer.class, RasterSymbolizer.class, or TextSymbolizer.class
*
* @return symbolizer instance from style, or null if not found.
*/
protected static Symbolizer symbolizer(Style style, final Class SYMBOLIZER) {
if (style == null) {
return null;
}
for (FeatureTypeStyle fts : style.featureTypeStyles()) {
Symbolizer sym = symbolizer(fts, SYMBOLIZER);
if (sym != null) {
return sym;
}
}
return null;
}
/**
* Retrieve the first Symbolizer from the provided FeatureTypeStyle.
*
* @param fts the FeatureTypeStyle SLD style information.
* @param SYMBOLIZER LineSymbolizer.class, PointSymbolizer.class,
* PolygonSymbolizer.class, RasterSymbolizer.class,
* or TextSymbolizer.class
*
* @return symbolizer instance from fts, or null if not found.
*/
protected static Symbolizer symbolizer(FeatureTypeStyle fts, final Class SYMBOLIZER) {
if (fts == null) {
return null;
}
for (Rule rule : fts.rules()) {
for (Symbolizer sym : rule.symbolizers()) {
if (SYMBOLIZER.isInstance(sym)) {
return sym;
}
}
}
return null;
}
/**
* Convert a Color object to hex representation
* @param c the Color object
* @return a hex String
*/
public static String colorToHex(Color c) {
return "#" + Integer.toHexString(c.getRGB() & 0x00ffffff);
}
/**
* Get the Styles defined in the given StyledLayerDescriptor
* @param sld the StyledLayerDescriptor object
* @return an array of Styles
*/
public static Style[] styles(StyledLayerDescriptor sld) {
StyledLayer[] layers = sld.getStyledLayers();
List<Style> styles = new ArrayList<Style>();
for (int i = 0; i < layers.length; i++) {
if (layers[i] instanceof UserLayer) {
UserLayer layer = (UserLayer) layers[i];
styles.addAll(layer.userStyles());
} else if (layers[i] instanceof NamedLayer) {
NamedLayer layer = (NamedLayer) layers[i];
styles.addAll(layer.styles());
}
}
return styles.toArray(new Style[0]);
}
/**
* Get the FeatureTypeStyles defined in the given StyledLayerDescriptor
* @param sld the StyledLayerDescriptor object
* @return an array of FeatureTypeStyles
*/
public static FeatureTypeStyle[] featureTypeStyles(StyledLayerDescriptor sld) {
Style[] style = styles(sld);
List<FeatureTypeStyle> fts = new ArrayList<FeatureTypeStyle>();
for (int i = 0; i < style.length; i++) {
fts.addAll(style[i].featureTypeStyles());
}
return fts.toArray(new FeatureTypeStyle[0]);
}
/**
* Retrieve the first FeatureTypeStyle defined in the given StyledLayerDescriptor
* object that matches the specified feature type
*
* @param sld a StyledLayerDescriptor object
* @param type the feature type to match
* @return a FeatureTypeStyle or null if there was no match
*/
public static FeatureTypeStyle featureTypeStyle(StyledLayerDescriptor sld, SimpleFeatureType type) {
//alternatively, we could use a StyleVisitor here
Style[] styles = styles(sld);
for (int i = 0; i < styles.length; i++) {
for (FeatureTypeStyle fts : styles[i].featureTypeStyles()) {
if (type.getTypeName().equalsIgnoreCase(fts.getName())) {
return fts;
}
}
}
return null;
}
/**
* Retrieve the default style from the given StyledLayerDescriptor.
*
* @param sld the StyledLayerDescriptor object
*
* @return the default style; or the first style if no default is
* defined; or null if there are not styles
*/
public static Style defaultStyle(StyledLayerDescriptor sld) {
Style[] style = styles(sld);
for (int i = 0; i < style.length; i++) {
if (style[i].isDefault()) {
return style[i];
}
}
//no default, so just grab the first one
if (style.length == 0) {
return null;
}
return style[0];
}
/**
* Retrieves all filters defined in a rule
*
* @param rule the rule
*
* @return array of filters
*/
public static Filter[] filters(Rule[] rule) {
Filter[] filter = new Filter[rule.length];
for (int i = 0; i < rule.length; i++) {
filter[i] = rule[0].getFilter();
}
return filter;
}
/**
* Retrieves all filters defined in a style
*
* @param style the style
*
* @return array of filters
*/
public static Filter[] filters(Style style) {
Rule[] rule = rules(style);
return filters(rule);
}
/**
* Retrieves all rules defined in a style
*
* @param style the style
*
* @return an array of unique rules
*/
public static Rule[] rules(Style style) {
Set<Rule> ruleSet = new HashSet<Rule>();
for (FeatureTypeStyle fts : style.featureTypeStyles()) {
ruleSet.addAll(fts.rules());
}
if (ruleSet.size() > 0) {
return ruleSet.toArray(new Rule[0]);
} else {
return new Rule[0];
}
}
/**
* Retrieves all symbolizers defined in a style
*
* @param style the style
*
* @return an array of unique symbolizers
*/
public static Symbolizer[] symbolizers(Style style) {
Set<Symbolizer> symbolizers = new HashSet<Symbolizer>();
for (FeatureTypeStyle fts : style.featureTypeStyles()) {
for (Rule rule : fts.rules()) {
symbolizers.addAll(rule.symbolizers());
}
}
if (symbolizers.size() > 0) {
return symbolizers.toArray(new Symbolizer[0]);
} else {
return new Symbolizer[0];
}
}
/**
* Retrieves all symbolizers defined in a rule
*
* @param rule the rule
*
* @return an array of unique symbolizers
*/
public static Symbolizer[] symbolizers(Rule rule) {
Set<Symbolizer> symbolizers = new HashSet<Symbolizer>();
symbolizers.addAll(rule.symbolizers());
if (symbolizers.size() > 0) {
return symbolizers.toArray(new Symbolizer[0]);
} else {
return new Symbolizer[0];
}
}
/**
* Retrieves all colour names defined in a style
* @param style the style
* @return an array of unique colour names
*/
public static String[] colors(Style style) {
Set<String> colorSet = new HashSet<String>();
for (FeatureTypeStyle fts : style.featureTypeStyles()) {
for (Rule rule : fts.rules()) {
String[] color = colors(rule);
for (int j = 0; j < color.length; j++) {
colorSet.add(color[j]);
}
}
}
if (colorSet.size() > 0) {
return colorSet.toArray(new String[0]);
} else {
return new String[0];
}
}
/**
* Retrieves all colour names defined in a rule
* @param rule the rule
* @return an array of unique colour names
*/
public static String[] colors(Rule rule) {
Set<String> colorSet = new HashSet<String>();
Color color = null;
for (Symbolizer sym : rule.symbolizers()) {
if (sym instanceof PolygonSymbolizer) {
PolygonSymbolizer symb = (PolygonSymbolizer) sym;
color = polyFill(symb);
} else if (sym instanceof LineSymbolizer) {
LineSymbolizer symb = (LineSymbolizer) sym;
color = color(symb);
} else if (sym instanceof PointSymbolizer) {
PointSymbolizer symb = (PointSymbolizer) sym;
color = color(symb);
}
if (color != null) {
colorSet.add(color.toString());
}
}
if (colorSet.size() > 0) {
return colorSet.toArray(new String[0]);
} else {
return new String[0];
}
}
/**
* Converts a java.awt.Color into an HTML Colour
*
* @param color color to convert
*
* @return HTML Color (fill) in hex #RRGGBB
*/
public static String toHTMLColor(Color color) {
if (color == null) {
return null;
}
String red = "0" + Integer.toHexString(color.getRed());
red = red.substring(red.length() - 2);
String grn = "0" + Integer.toHexString(color.getGreen());
grn = grn.substring(grn.length() - 2);
String blu = "0" + Integer.toHexString(color.getBlue());
blu = blu.substring(blu.length() - 2);
return ("#" + red + grn + blu).toUpperCase();
}
/**
* Convert an HTML colour string to a java.awt.Color object
*
* @param htmlColor the colour string
*
* @return a new Color object
*/
public static Color toColor(String htmlColor) {
return new Color(Integer.parseInt(htmlColor.substring(1), 16));
}
/**
* Test if the given FeatureTypeStyle object matches a regular expression
* @param fts the feature type style
* @param regex regular expression to match
* @return true if a match is found; false otherwise
*/
public static boolean isSemanticTypeMatch( FeatureTypeStyle fts, String regex ) {
for (SemanticType id : fts.semanticTypeIdentifiers()) {
if (id.matches(regex)) {
return true;
}
}
return false;
}
/**
* Returns the min scale of the default (first) rule
*
* @param fts the feature type style
*
* @return min scale or 0 if no min scale is set
*/
public static double minScale( FeatureTypeStyle fts ) {
if(fts == null || fts.rules().isEmpty())
return 0.0;
return fts.rules().get(0).getMinScaleDenominator();
}
/**
* Returns the max scale of the default (first) rule
*
* @param fts the feature type style
*
* @return min scale or NaN if no max scale is set
*/
public static double maxScale( FeatureTypeStyle fts ) {
if(fts == null || fts.rules().isEmpty())
return Double.NaN;
return fts.rules().get(0).getMaxScaleDenominator();
}
/**
* Create a PointPlacement object.
*
* @param horizAlign horizontal alignment (0 to 1)
* @param vertAlign vertical alignment (0 to 1)
* @param rotation rotation angle in degrees
*
* @return a new PointPlacement object
*/
public static PointPlacement getPlacement( double horizAlign, double vertAlign, double rotation ) {
AnchorPoint anchorPoint = sf.createAnchorPoint(ff.literal(horizAlign), ff.literal(vertAlign));
return sf.createPointPlacement(anchorPoint, null, ff.literal(rotation));
}
/**
* Create a minimal style to render features of type {@code typeName}
* read from the given data store
*
* @param store the data store containing the features
*
* @param typeName the feature type to create the style for
*
* @param color single color to use for all components of the Style
*
* @return a new Style instance
*
* @throws java.io.IOException if the data store cannot be accessed
*/
public static Style createSimpleStyle(AbstractDataStore store, String typeName, Color color) throws IOException {
SimpleFeatureType type = store.getSchema(typeName);
return createSimpleStyle(type, color);
}
/**
* Create a minimal style to render features of type {@code type}.
*
* @param type the feature type
*
* @return a new Style instance
*/
public static Style createSimpleStyle(FeatureType type) {
return createSimpleStyle(type, Color.BLACK);
}
/**
* Create a minimal style to render features of type {@code type}
*
* @param store the data store containing the features
*
* @param typeName the feature type to create the style for
*
* @param color single color to use for all components of the Style
*
* @return a new Style instance
*
* @throws java.io.IOException if the data store cannot be accessed
*/
public static Style createSimpleStyle(FeatureType type, Color color) {
GeometryDescriptor desc = type.getGeometryDescriptor();
Class<?> clazz = desc.getType().getBinding();
Color fillColor = null;
if (Polygon.class.isAssignableFrom(clazz) ||
MultiPolygon.class.isAssignableFrom(clazz)) {
if (color.equals(Color.BLACK)) {
fillColor = null;
} else {
fillColor = color;
}
return createPolygonStyle(color, fillColor, 0.5f);
} else if (LineString.class.isAssignableFrom(clazz) ||
MultiLineString.class.isAssignableFrom(clazz)) {
return createLineStyle(color, 1.0f);
} else if (Point.class.isAssignableFrom(clazz) ||
MultiPoint.class.isAssignableFrom(clazz)) {
if (color.equals(Color.BLACK)) {
fillColor = null;
} else {
fillColor = color;
}
return createPointStyle("Circle", color, fillColor, 0.5f, 3.0f);
}
throw new UnsupportedOperationException("No style method for " + clazz.getName());
}
/**
* Create a polygon style with the given colors and opacity.
*
* @param outlineColor color of polygon outlines
* @param fillColor color for the fill
* @param opacity proportional opacity (0 to 1)
*
* @return a new Style instance
*/
public static Style createPolygonStyle(Color outlineColor, Color fillColor, float opacity) {
Stroke stroke = sf.createStroke(ff.literal(outlineColor), ff.literal(1.0f));
Fill fill = Fill.NULL;
if (fillColor != null) {
fill = sf.createFill(ff.literal(fillColor), ff.literal(opacity));
}
return wrapSymbolizers( sf.createPolygonSymbolizer(stroke, fill, null) );
}
/**
* Create a polygon style with the given colors, opacity and optional labels.
*
* @param outlineColor color of polygon outlines
* @param fillColor color for the fill
* @param opacity proportional opacity (0 to 1)
*
* @param labelField name of the feature field (attribute) to use for labelling;
* mauy be {@code null} for no labels
*
* @param labelFont GeoTools Font object to use for labelling; if {@code null}
* and {@code labelField} is not {@code null} the default font will be
* used
*
* @return a new Style instance
*/
public static Style createPolygonStyle(Color outlineColor, Color fillColor, float opacity,
String labelField, Font labelFont) {
Stroke stroke = sf.createStroke(ff.literal(outlineColor), ff.literal(1.0f));
Fill fill = Fill.NULL;
if (fillColor != null) {
fill = sf.createFill(ff.literal(fillColor), ff.literal(opacity));
}
PolygonSymbolizer polySym = sf.createPolygonSymbolizer(stroke, fill, null);
if (labelField == null) {
return wrapSymbolizers( polySym );
} else {
Font font = (labelFont == null ? sf.getDefaultFont() : labelFont);
Fill labelFill = sf.createFill(ff.literal(Color.BLACK));
TextSymbolizer textSym = sf.createTextSymbolizer(
labelFill, new Font[]{font}, null, ff.property(labelField), null, null);
return wrapSymbolizers( polySym, textSym );
}
}
/**
* Create a line style with given color and line width
*
* @param lineColor color of lines
* @param width width of lines
*
* @return a new Style instance
*/
public static Style createLineStyle(Color lineColor, float width) {
Stroke stroke = sf.createStroke(ff.literal(lineColor), ff.literal(width));
return wrapSymbolizers( sf.createLineSymbolizer(stroke, null) );
}
/**
* Create a line style with given color, line width and optional labels
*
* @param lineColor color of lines
* @param width width of lines
*
* @param labelField name of the feature field (attribute) to use for labelling;
* mauy be {@code null} for no labels
*
* @param labelFont GeoTools Font object to use for labelling; if {@code null}
* and {@code labelField} is not {@code null} the default font will be
* used
*
* @return a new Style instance
*/
public static Style createLineStyle(Color lineColor, float width,
String labelField, Font labelFont) {
Stroke stroke = sf.createStroke(ff.literal(lineColor), ff.literal(width));
LineSymbolizer lineSym = sf.createLineSymbolizer(stroke, null);
if (labelField == null) {
return wrapSymbolizers( lineSym );
} else {
Font font = (labelFont == null ? sf.getDefaultFont() : labelFont);
Fill labelFill = sf.createFill(ff.literal(Color.BLACK));
TextSymbolizer textSym = sf.createTextSymbolizer(
labelFill, new Font[]{font}, null, ff.property(labelField), null, null);
return wrapSymbolizers( lineSym, textSym );
}
}
/**
* Create a point style without labels
*
* @param wellKnownName one of: Circle, Square, Cross, X, Triangle or Star
* @param lineColor color for the point symbol outline
* @param fillColor color for the point symbol fill
* @param opacity a value between 0 and 1 for the opacity of the fill
* @param size size of the point symbol
*
* @return a new Style instance
*/
public static Style createPointStyle(
String wellKnownName,
Color lineColor,
Color fillColor,
float opacity,
float size) {
return createPointStyle(wellKnownName, lineColor, fillColor, opacity, size, null, null);
}
/**
* Create a point style, optionally with text labels
*
* @param wellKnownName one of: Circle, Square, Cross, X, Triangle or Star
* @param lineColor color for the point symbol outline
* @param fillColor color for the point symbol fill
* @param opacity a value between 0 and 1 for the opacity of the fill
* @param size size of the point symbol
*
* @param labelField name of the feature field (attribute) to use for labelling;
* mauy be {@code null} for no labels
*
* @param labelFont GeoTools Font object to use for labelling; if {@code null}
* and {@code labelField} is not {@code null} the default font will be
* used
*
* @return a new Style instance
*/
public static Style createPointStyle(
String wellKnownName,
Color lineColor,
Color fillColor,
float opacity,
float size,
String labelField,
Font labelFont) {
Stroke stroke = sf.createStroke(ff.literal(lineColor), ff.literal(1.0f));
Fill fill = Fill.NULL;
if (fillColor != null) {
fill = sf.createFill(ff.literal(fillColor), ff.literal(opacity));
}
Mark mark = sf.createMark(ff.literal(wellKnownName),
stroke, fill, ff.literal(size), ff.literal(0));
Graphic graphic = sf.createDefaultGraphic();
graphic.graphicalSymbols().clear();
graphic.graphicalSymbols().add(mark);
graphic.setSize(ff.literal(size));
PointSymbolizer pointSym = sf.createPointSymbolizer(graphic, null);
if (labelField == null) {
return wrapSymbolizers( pointSym );
} else {
Font font = (labelFont == null ? sf.getDefaultFont() : labelFont);
Fill labelFill = sf.createFill(ff.literal(Color.BLACK));
AnchorPoint anchor = sf.createAnchorPoint(ff.literal(0.5), ff.literal(0.0));
Displacement disp = sf.createDisplacement(ff.literal(0), ff.literal(5));
LabelPlacement placement = sf.createPointPlacement(anchor, disp, ff.literal(0));
TextSymbolizer textSym = sf.createTextSymbolizer(
labelFill, new Font[]{font}, null, ff.property(labelField), placement, null);
return wrapSymbolizers( pointSym, textSym );
}
}
/**
* Wrap one or more symbolizers into a Rule / FeatureTypeStyle / Style
*
* @param symbolizers one or more symbolizer objects
*
* @return a new Style instance or null if no symbolizers are provided
*/
public static Style wrapSymbolizers(Symbolizer ...symbolizers) {
if (symbolizers == null || symbolizers.length == 0) {
return null;
}
Rule rule = sf.createRule();
for (Symbolizer sym : symbolizers) {
rule.symbolizers().add(sym);
}
FeatureTypeStyle fts = sf.createFeatureTypeStyle(new Rule[] {rule});
Style style = sf.createStyle();
style.featureTypeStyles().add(fts);
return style;
}
}