Java tutorial
/* * Copyright (c) 2012 Data Harmonisation Panel * * All rights reserved. This program and the accompanying materials are made * available under the terms of the GNU Lesser General Public License as * published by the Free Software Foundation, either version 3 of the License, * or (at your option) any later version. * * You should have received a copy of the GNU Lesser General Public License * along with this distribution. If not, see <http://www.gnu.org/licenses/>. * * Contributors: * HUMBOLDT EU Integrated Project #030962 * Data Harmonisation Panel <http://www.dhpanel.eu> */ package eu.esdihumboldt.hale.ui.style; import java.awt.Color; import java.util.HashSet; import java.util.Iterator; import java.util.Map.Entry; import java.util.Random; import java.util.Set; import javax.annotation.Nullable; import org.eclipse.ui.PlatformUI; import org.geotools.factory.CommonFactoryFinder; import org.geotools.feature.NameImpl; import org.geotools.styling.FeatureTypeStyle; import org.geotools.styling.Fill; import org.geotools.styling.LineSymbolizer; import org.geotools.styling.Mark; import org.geotools.styling.PointSymbolizer; import org.geotools.styling.PolygonSymbolizer; import org.geotools.styling.Rule; import org.geotools.styling.SLD; import org.geotools.styling.Style; import org.geotools.styling.StyleBuilder; import org.geotools.styling.StyleFactory; import org.geotools.styling.Symbolizer; import org.opengis.filter.FilterFactory; import com.google.common.collect.SetMultimap; import eu.esdihumboldt.hale.common.instance.model.DataSet; import eu.esdihumboldt.hale.common.schema.model.TypeDefinition; import eu.esdihumboldt.hale.common.schema.model.constraint.type.AbstractFlag; import eu.esdihumboldt.hale.ui.geometry.service.GeometrySchemaService; import eu.esdihumboldt.hale.ui.style.service.internal.StylePreferences; /** * Style helper methods * * @author Simon Templer * @partner 01 / Fraunhofer Institute for Computer Graphics Research */ public abstract class StyleHelper { /** * Default fill opacity */ public static final double DEFAULT_FILL_OPACITY = 0.4; private static final StyleBuilder styleBuilder = new StyleBuilder(); private static final StyleFactory styleFactory = CommonFactoryFinder.getStyleFactory(null); private static final FilterFactory filterFactory = CommonFactoryFinder.getFilterFactory(null); /** * Returns a default style for the given type. * * @param typeDef the type definition * @param dataSet the data set (if known) * @return the style */ public static FeatureTypeStyle getDefaultStyle(TypeDefinition typeDef, @Nullable DataSet dataSet) { // GeometrySchemaService gss = (GeometrySchemaService) PlatformUI.getWorkbench().getService(GeometrySchemaService.class); // List<QName> geomPath = gss.getDefaultGeometry(typeDef); // TODO determine default style from default geometry? Color defColor; if (dataSet != null) { defColor = StylePreferences.getDefaultColor(dataSet); } else { defColor = Color.DARK_GRAY; } int defWidth = StylePreferences.getDefaultWidth(); FeatureTypeStyle result; // XXX for now create a polygon style in any case, as it contains fill // and stroke // if (type != null) { // if (type.isAssignableFrom(Polygon.class) // || type.isAssignableFrom(MultiPolygon.class)) { result = createPolygonStyle(defColor, defWidth); // } else if (type.isAssignableFrom(LineString.class) // || type.isAssignableFrom(MultiLineString.class)) { // result = createLineStyle(defColor, defWidth); // } else { // result = createPointStyle(defColor, defWidth); // } // } // else { // result = createPointStyle(defColor, defWidth); // } // XXX StyleBuilder does not support feature type names with namespace // QName name = getFeatureTypeName(typeDef); // result.featureTypeNames().add(new NameImpl(name.getNamespaceURI(), name.getLocalPart())); result.featureTypeNames().add(new NameImpl(getFeatureTypeName(typeDef))); return result; } /** * Returns a default style for the given type. * * @param dataSetTypes type definitions associated to their data set * @return the style */ public static Style getRandomStyles(SetMultimap<DataSet, TypeDefinition> dataSetTypes) { int defWidth = StylePreferences.getDefaultWidth(); Style style = styleFactory.createStyle(); for (Entry<DataSet, TypeDefinition> entry : dataSetTypes.entries()) { DataSet dataSet = entry.getKey(); TypeDefinition typeDef = entry.getValue(); FeatureTypeStyle fts; // TODO based on default geometry? // polygon is always OK as it contains stroke and fill // Color color = generateRandomColor(Color.WHITE); float saturation; float brightness; switch (dataSet) { case TRANSFORMED: saturation = 0.8f; brightness = 0.6f; break; case SOURCE: default: saturation = 0.75f; brightness = 0.8f; break; } Color color = generateRandomColor(saturation, brightness); fts = createPolygonStyle(color, defWidth); fts.featureTypeNames().add(new NameImpl(getFeatureTypeName(typeDef))); style.featureTypeStyles().add(fts); } return style; } /** * Returns a default style for the given type. * * @param dataSetTypes type definitions associated to their data set * @return the style */ public static Style getSpectrumStyles(SetMultimap<DataSet, TypeDefinition> dataSetTypes) { int defWidth = StylePreferences.getDefaultWidth(); Style style = styleFactory.createStyle(); GeometrySchemaService gss = PlatformUI.getWorkbench().getService(GeometrySchemaService.class); for (DataSet dataSet : dataSetTypes.keySet()) { float saturation; float brightness; switch (dataSet) { case TRANSFORMED: saturation = 0.8f; brightness = 0.6f; break; case SOURCE: default: saturation = 0.75f; brightness = 0.8f; break; } Set<TypeDefinition> types = new HashSet<>(dataSetTypes.get(dataSet)); Iterator<TypeDefinition> it = types.iterator(); while (it.hasNext()) { TypeDefinition type = it.next(); // remove invalid types if (type.getConstraint(AbstractFlag.class).isEnabled() || gss.getDefaultGeometry(type) == null) { it.remove(); } } int numberOfTypes = types.size(); int index = 0; for (TypeDefinition typeDef : types) { FeatureTypeStyle fts; // TODO based on default geometry? // polygon is always OK as it contains stroke and fill // Color color = generateRandomColor(Color.WHITE); Color color; if (numberOfTypes == 1) { color = generateRandomColor(saturation, brightness); } else { color = Color.getHSBColor((float) index / (float) numberOfTypes, saturation, brightness); } fts = createPolygonStyle(color, defWidth); fts.featureTypeNames().add(new NameImpl(getFeatureTypeName(typeDef))); style.featureTypeStyles().add(fts); index++; } } return style; } /** * Generate a random color. Mixing in WHITE will create pastel colors. * Mixing in a pastel color will create tinted colors. * * @param mix color to mix in (use average of RGB values) * @return the generated color */ public static Color generateRandomColor(@Nullable Color mix) { Random random = new Random(); int red = random.nextInt(256); int green = random.nextInt(256); int blue = random.nextInt(256); // mix the color if (mix != null) { red = (red + mix.getRed()) / 2; green = (green + mix.getGreen()) / 2; blue = (blue + mix.getBlue()) / 2; } Color color = new Color(red, green, blue); return color; } private static float GOLDEN_RATIO_CONJUGATE = 0.618033988749895f; /** * Generate a random color. * * Inspired by * http://martin.ankerl.com/2009/12/09/how-to-create-random-colors * -programmatically/ * * @param saturation the saturation (between 0.0f and 1.0f) * @param brightness the brightness (between 0.0f and 1.0f) * * @return the random color */ public static Color generateRandomColor(float saturation, float brightness) { Random random = new Random(); float rand = random.nextFloat(); rand = rand + GOLDEN_RATIO_CONJUGATE; rand = rand % 1; return Color.getHSBColor(rand, saturation, brightness); } // XXX StyleBuilder does not support feature type names with namespace // /** // * Get the name used in styles for the given type definition. // * @param typeDef the type definition // * @return the feature type name // */ // public static QName getFeatureTypeName(TypeDefinition typeDef) { // // default to element name // Collection<? extends XmlElement> elements = typeDef.getConstraint(XmlElements.class).getElements(); // if (elements.size() == 1) { // // only use element name if it is unique // return elements.iterator().next().getName(); // } // // // type // return typeDef.getName(); // } /** * Get the name used in styles for the given type definition. * * @param typeDef the type definition * @return the feature type name */ public static String getFeatureTypeName(TypeDefinition typeDef) { // type or element name return typeDef.getDisplayName(); } /** * Get a style containing the default style for the given type. * * @param type the type definition * @param dataSet the data set * @return the style with the default type style */ public static Style getStyle(TypeDefinition type, DataSet dataSet) { Style style = styleFactory.createStyle(); style.featureTypeStyles().add(getDefaultStyle(type, dataSet)); return style; } /** * Create a new point symbolizer based on the given one. * * @param symbolizer the point symbolizer * @param color the new color * @param width the new line width * @return the mutated symbolizer */ public static Symbolizer mutatePointSymbolizer(PointSymbolizer symbolizer, Color color, int width) { // mutate mark Mark mark = SLD.mark(symbolizer); Mark mutiMark = styleBuilder.createMark(mark.getWellKnownName(), styleBuilder.createFill(color, DEFAULT_FILL_OPACITY), styleBuilder.createStroke(color, width)); // XXX commented because unsupported in Geotools 8.0-M1 // mutiMark.setSize(mark.getSize()); // mutiMark.setRotation(mark.getRotation()); // create new symbolizer return styleBuilder.createPointSymbolizer(styleBuilder.createGraphic(null, mutiMark, null)); } /** * Manually create a default point style. * * @param color the point color * @param width the line width * @return a Style for Point objects. */ @SuppressWarnings("unused") private static FeatureTypeStyle createPointStyle(Color color, double width) { PointSymbolizer symbolizer = createPointSymbolizer(color, width); // symbolizer.getGraphic().setSize(filterFactory.literal(1)); Rule rule = styleFactory.createRule(); rule.symbolizers().add(symbolizer); FeatureTypeStyle fts = styleFactory.createFeatureTypeStyle(); fts.rules().add(rule); return fts; } /** * Create a default point symbolizer. * * @param color the color * @param width the line width * @return the point symbolizer */ public static PointSymbolizer createPointSymbolizer(Color color, double width) { return styleBuilder.createPointSymbolizer(styleBuilder.createGraphic(null, styleBuilder.createMark(StyleBuilder.MARK_X, styleBuilder.createFill(color, DEFAULT_FILL_OPACITY), styleBuilder.createStroke(color, width)), null)); } /** * Create a default line style. * * @param color the line color * @param width the line width * @return a Style for Line/LineString objects. */ @SuppressWarnings("unused") private static FeatureTypeStyle createLineStyle(Color color, double width) { LineSymbolizer symbolizer = createLineSymbolizer(color, width); Rule rule = styleFactory.createRule(); rule.symbolizers().add(symbolizer); FeatureTypeStyle fts = styleFactory.createFeatureTypeStyle(); fts.rules().add(rule); return fts; } /** * Create a default line symbolizer. * * @param color the color * @param width the line width * @return the line symbolizer */ public static LineSymbolizer createLineSymbolizer(Color color, double width) { LineSymbolizer symbolizer = styleFactory.createLineSymbolizer(); SLD.setLineColour(symbolizer, color); symbolizer.getStroke().setWidth(filterFactory.literal(width)); return symbolizer; } /** * Create a default polygon style. * * @param color the polygon color * @param width the line width * @return a Style for Polygon objects */ private static FeatureTypeStyle createPolygonStyle(Color color, double width) { PolygonSymbolizer symbolizer = createPolygonSymbolizer(color, width); Rule rule = styleFactory.createRule(); rule.symbolizers().add(symbolizer); FeatureTypeStyle fts = styleFactory.createFeatureTypeStyle(); fts.rules().add(rule); return fts; } /** * Create a default polygon symbolizer. * * @param color the color * @param width the line width * @return the polygon symbolizer */ public static PolygonSymbolizer createPolygonSymbolizer(Color color, double width) { PolygonSymbolizer symbolizer = styleFactory.createPolygonSymbolizer(); SLD.setPolyColour(symbolizer, color); symbolizer.getStroke().setWidth(filterFactory.literal(width)); Fill fill = styleFactory.createFill(filterFactory.literal(color), filterFactory.literal(DEFAULT_FILL_OPACITY)); symbolizer.setFill(fill); return symbolizer; } }