/[schmitzm]/trunk/src/skrueger/geotools/StyledLayerUtil.java
ViewVC logotype

Diff of /trunk/src/skrueger/geotools/StyledLayerUtil.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

branches/1.0-gt2-2.6/src/skrueger/geotools/StyledLayerUtil.java revision 400 by alfonx, Mon Sep 14 12:24:50 2009 UTC trunk/src/skrueger/geotools/StyledLayerUtil.java revision 769 by alfonx, Sun Mar 21 11:02:34 2010 UTC
# Line 31  package skrueger.geotools; Line 31  package skrueger.geotools;
31    
32  import java.awt.Color;  import java.awt.Color;
33  import java.awt.Dimension;  import java.awt.Dimension;
 import java.awt.Graphics;  
34  import java.awt.Graphics2D;  import java.awt.Graphics2D;
35  import java.awt.Rectangle;  import java.awt.Rectangle;
36  import java.awt.geom.AffineTransform;  import java.awt.geom.AffineTransform;
37  import java.awt.image.BufferedImage;  import java.awt.image.BufferedImage;
38    import java.awt.image.ColorModel;
39    import java.awt.image.ComponentColorModel;
40    import java.awt.image.DataBuffer;
41  import java.io.File;  import java.io.File;
42  import java.io.FileNotFoundException;  import java.io.FileNotFoundException;
43  import java.io.FileWriter;  import java.io.FileWriter;
44  import java.net.URL;  import java.net.URL;
45  import java.text.DecimalFormat;  import java.text.DecimalFormat;
46  import java.util.HashMap;  import java.util.ArrayList;
47  import java.util.List;  import java.util.List;
48  import java.util.Map;  import java.util.Map;
49  import java.util.Set;  import java.util.Set;
 import java.util.SortedMap;  
 import java.util.TreeMap;  
50    
51  import javax.swing.Box;  import javax.swing.BorderFactory;
 import javax.swing.BoxLayout;  
52  import javax.swing.ImageIcon;  import javax.swing.ImageIcon;
53    import javax.swing.JComponent;
54  import javax.swing.JLabel;  import javax.swing.JLabel;
55    
56    import net.miginfocom.swing.MigLayout;
57    
58  import org.apache.log4j.Logger;  import org.apache.log4j.Logger;
59    import org.geotools.coverage.grid.GeneralGridEnvelope;
60  import org.geotools.coverage.grid.GridCoverage2D;  import org.geotools.coverage.grid.GridCoverage2D;
61    import org.geotools.coverage.grid.GridGeometry2D;
62  import org.geotools.coverage.grid.io.AbstractGridCoverage2DReader;  import org.geotools.coverage.grid.io.AbstractGridCoverage2DReader;
63    import org.geotools.coverage.grid.io.AbstractGridFormat;
64  import org.geotools.feature.FeatureCollection;  import org.geotools.feature.FeatureCollection;
65    import org.geotools.feature.NameImpl;
66    import org.geotools.geometry.jts.ReferencedEnvelope;
67  import org.geotools.map.DefaultMapLayer;  import org.geotools.map.DefaultMapLayer;
68  import org.geotools.map.MapLayer;  import org.geotools.map.MapLayer;
69    import org.geotools.parameter.Parameter;
70  import org.geotools.renderer.lite.gridcoverage2d.GridCoverageRenderer;  import org.geotools.renderer.lite.gridcoverage2d.GridCoverageRenderer;
71  import org.geotools.styling.ColorMap;  import org.geotools.styling.ColorMap;
72  import org.geotools.styling.ColorMapEntry;  import org.geotools.styling.ColorMapEntry;
# Line 70  import org.jdom.Document; Line 78  import org.jdom.Document;
78  import org.jdom.Element;  import org.jdom.Element;
79  import org.jdom.input.SAXBuilder;  import org.jdom.input.SAXBuilder;
80  import org.jdom.output.XMLOutputter;  import org.jdom.output.XMLOutputter;
81    import org.opengis.feature.simple.SimpleFeature;
82  import org.opengis.feature.simple.SimpleFeatureType;  import org.opengis.feature.simple.SimpleFeatureType;
83    import org.opengis.feature.type.AttributeDescriptor;
84    import org.opengis.feature.type.GeometryDescriptor;
85    import org.opengis.feature.type.Name;
86    import org.opengis.parameter.GeneralParameterValue;
87    
88  import schmitzm.geotools.JTSUtil;  import schmitzm.geotools.JTSUtil;
89    import schmitzm.geotools.feature.FeatureUtil;
90  import schmitzm.geotools.styling.StylingUtil;  import schmitzm.geotools.styling.StylingUtil;
91  import schmitzm.io.IOUtil;  import schmitzm.io.IOUtil;
92  import schmitzm.lang.LangUtil;  import schmitzm.lang.LangUtil;
93    import schmitzm.swing.JPanel;
94  import schmitzm.swing.SwingUtil;  import schmitzm.swing.SwingUtil;
95  import skrueger.AttributeMetaData;  import skrueger.AttributeMetadata;
96    import skrueger.AttributeMetadataImpl;
97  import skrueger.RasterLegendData;  import skrueger.RasterLegendData;
98  import skrueger.i8n.Translation;  import skrueger.i8n.Translation;
99    
# Line 121  public class StyledLayerUtil { Line 137  public class StyledLayerUtil {
137           *                if {@code null} is given as object or an error occurs           *                if {@code null} is given as object or an error occurs
138           *                during layer creation           *                during layer creation
139           */           */
140          public static MapLayer createMapLayer(Object object) throws Exception {          public static MapLayer createMapLayer(final Object object) throws Exception {
141                  return createMapLayer(object, null);                  return createMapLayer(object, null);
142          }          }
143    
# Line 140  public class StyledLayerUtil { Line 156  public class StyledLayerUtil {
156           *                if {@code null} is given as object or an error occurs           *                if {@code null} is given as object or an error occurs
157           *                during layer creation           *                during layer creation
158           */           */
159          public static MapLayer createMapLayer(Object object, Style forcedStyle)          public static MapLayer createMapLayer(Object object, final Style forcedStyle)
160                          throws Exception {                          throws Exception {
161                  MapLayer layer = null;                  MapLayer layer = null;
162                  Style style = null;                  Style style = null;
# Line 181  public class StyledLayerUtil { Line 197  public class StyledLayerUtil {
197           *                if {@code null} is given as object or an error occurs           *                if {@code null} is given as object or an error occurs
198           *                during creation           *                during creation
199           */           */
200          public static StyledLayerInterface<?> createStyledLayer(Object object,          public static StyledLayerInterface<?> createStyledLayer(
201                          String title) {                          final Object object, final String title) {
202                  return createStyledLayer(object, title, null);                  return createStyledLayer(object, title, null);
203          }          }
204    
# Line 201  public class StyledLayerUtil { Line 217  public class StyledLayerUtil {
217           *                if {@code null} is given as object or an error occurs           *                if {@code null} is given as object or an error occurs
218           *                during creation           *                during creation
219           */           */
220          public static StyledLayerInterface<?> createStyledLayer(Object object,          public static StyledLayerInterface<?> createStyledLayer(
221                          String title, StyledLayerStyle style) {                          final Object object, final String title,
222                            final StyledLayerStyle style) {
223                  StyledLayerInterface<?> styledLayer = null;                  StyledLayerInterface<?> styledLayer = null;
224    
225                  String id = (title != null) ? title : "defaultID";                  final String id = (title != null) ? title : "defaultID";
226    
227                  if (object instanceof GridCoverage2D)                  if (object instanceof GridCoverage2D)
228                          styledLayer = new StyledGridCoverage((GridCoverage2D) object, id,                          styledLayer = new StyledGridCoverage((GridCoverage2D) object, id,
# Line 233  public class StyledLayerUtil { Line 250  public class StyledLayerUtil {
250           * @param visible           * @param visible
251           *            indicated whether the visible or invisible entries are           *            indicated whether the visible or invisible entries are
252           *            returned           *            returned
253             *
254             *            TODO replace with
255             *            {@link AttributeMetadataMap#sortedValuesVisibleOnly()}
256           */           */
257          public static SortedMap<Integer, AttributeMetaData> getVisibleAttributeMetaData(          public static AttributeMetadataMap<? extends AttributeMetadata > getVisibleAttributeMetaData(
258                          Map<Integer, AttributeMetaData> amdMap, boolean visible) {                          final AttributeMetadataMap<? extends AttributeMetadata> amdMap,
259                  SortedMap<Integer, AttributeMetaData> filteredMap = new TreeMap<Integer, AttributeMetaData>();                          final boolean visible) {
260                  for (AttributeMetaData amd : amdMap.values())  
261                          if (amd.isVisible())                  final AttributeMetadataMap<AttributeMetadata> filteredMap = (AttributeMetadataMap<AttributeMetadata>) amdMap.clone();
262                                  filteredMap.put(amd.getColIdx(), amd);                  if (filteredMap.size() > 0 ) {
263                            filteredMap.clear(); // Just in case the close copies the contents
264                    }
265                    
266                    for (final AttributeMetadata amd : amdMap.values())
267                            if (amd.isVisible() == visible)
268                                    filteredMap.put(amd.getName(), amd);
269    
270                  return filteredMap;                  return filteredMap;
271          }          }
272    
273          /**          /**
274           * Parses a {@link AttributeMetaData} object from an JDOM-{@link Element}.           * Parses a {@link AttributeMetadataImpl} object from an JDOM-
275           * This method works like {@link           * {@link Element}. This method works like {@link
276           * AMLImport#parseDataAttribute(org.w3c.dom.Node}, but for JDOM.           * AMLImport#parseDataAttribute(org.w3c.dom.Node}, but for JDOM.
277           *           *
278             * TODO 20.11.2009, SK: There are some new attribute weight, functiona,
279             * functionX and nodata in AttributeMetaData that should be parsed/exported
280             * too. but this method is only used by ISDSS, which is not supporting that
281             * stuff anyways.
282             *
283           * @param element           * @param element
284           *            {@link Element} to parse           *            {@link Element} to parse
285           */           */
286          public static AttributeMetaData parseAttributeMetaData(final Element element) {          public static AttributeMetadataImpl parseAttributeMetaData(
287                  final Integer col = Integer.valueOf(element.getAttributeValue("col"));                          final Element element) {
288                    final String namespace = String.valueOf(element
289                                    .getAttributeValue("namespace"));
290                    final String localname = String.valueOf(element
291                                    .getAttributeValue("localname"));
292                    final Name aName = new NameImpl(namespace, localname);
293                  final Boolean visible = Boolean.valueOf(element                  final Boolean visible = Boolean.valueOf(element
294                                  .getAttributeValue("visible"));                                  .getAttributeValue("visible"));
295                  final String unit = element.getAttributeValue("unit");                  final String unit = element.getAttributeValue("unit");
# Line 269  public class StyledLayerUtil { Line 305  public class StyledLayerUtil {
305                          else if (childElement.getName().equals("desc"))                          else if (childElement.getName().equals("desc"))
306                                  desc = parseTranslation(childElement);                                  desc = parseTranslation(childElement);
307                  }                  }
308                  return new AttributeMetaData(col, visible, name, desc, unit);                  return new AttributeMetadataImpl(aName, visible, name, desc, unit);
309          }          }
310    
311          /**          /**
312           * Parses a {@link AttributeMetaData} map from an JDOM-{@link Element} with           * Parses a {@link AttributeMetadataImpl} map from an JDOM-{@link Element}
313           * {@code <attribute>}-childs.           * with {@code <attribute>}-childs.
314           *           *
315           * @param element           * @param element
316           *            {@link Element} to parse           *            {@link Element} to parse
317             *
318             *            TODO Since GP 1.3 the {@link AttributeMetadataImpl} class has
319             *            more attributes which are not used by Xulu/ISDSS. GP
320             *            exports/imports the AMD via AMLExporter and AMLImporter
321             *            classes. (SK, 3.2.2010) *
322           */           */
323          public static Map<Integer, AttributeMetaData> parseAttributeMetaDataMap(          public static AttributeMetadataMap parseAttributeMetaDataMap(
324                          final Element element) {                          final Element element) {
325                  HashMap<Integer, AttributeMetaData> metaData = new HashMap<Integer, AttributeMetaData>();                  final AttributeMetadataMap metaData = new AttributeMetadataImplMap();
326                  List<Element> attributesElements = element                  final List<Element> attributesElements = element
327                                  .getChildren(ELEM_NAME_ATTRIBUTE);                                  .getChildren(ELEM_NAME_ATTRIBUTE);
328                  for (Element attibuteElement : attributesElements) {                  for (final Element attibuteElement : attributesElements) {
329                          AttributeMetaData attrMetaData = parseAttributeMetaData(attibuteElement);                          final AttributeMetadataImpl attrMetaData = parseAttributeMetaData(attibuteElement);
330                          metaData.put(attrMetaData.getColIdx(), attrMetaData);                          metaData.put(attrMetaData.getName(), attrMetaData);
331                  }                  }
332                  return metaData;                  return metaData;
333          }          }
334    
335          /**          /**
336           * Loads a {@link AttributeMetaData} object from an URL.           * Loads a {@link AttributeMetadataImpl} object from an URL.
337           *           *
338           * @param documentUrl           * @param documentUrl
339           *            {@link URL} to parse           *            {@link URL} to parse
340           * @see #parseAttributeMetaData(Element)           * @see #parseAttributeMetaData(Element)
341           */           */
342          public static Map<Integer, AttributeMetaData> loadAttributeMetaDataMap(          public static AttributeMetadataMap loadAttributeMetaDataMap(
343                          final URL documentUrl) throws Exception {                          final URL documentUrl) throws Exception {
344                  Document document = SAX_BUILDER.build(documentUrl);                  final Document document = SAX_BUILDER.build(documentUrl);
345                  return parseAttributeMetaDataMap(document.getRootElement());                  return parseAttributeMetaDataMap(document.getRootElement());
346          }          }
347    
348          /**          /**
349           * Creates an JDOM {@link Element} for the given {@link AttributeMetaData}           * Creates an JDOM {@link Element} for the given
350           * object.           * {@link AttributeMetadataImpl} object.
351           *           *
352           * @param amd           * @param amd
353           *            meta data for one attribute           *            meta data for one attribute
354             *
355             *            TODO Since GP 1.3 the {@link AttributeMetadataImpl} class has
356             *            more attributes which are not used by Xulu/ISDSS. GP
357             *            exports/imports the AMD via AMLExporter and AMLImporter
358             *            classes. (SK, 3.2.2010)
359           */           */
360          public static Element createAttributeMetaDataElement(          public static Element createAttributeMetaDataElement(
361                          final AttributeMetaData amd) {                          final AttributeMetadata amd) {
362                  final Element element = new Element(ELEM_NAME_ATTRIBUTE, AMLURI);                  final Element element = new Element(ELEM_NAME_ATTRIBUTE, AMLURI);
363                  element.setAttribute("col", String.valueOf(amd.getColIdx()));                  element.setAttribute("namespace", String.valueOf(amd.getName()
364                                    .getNamespaceURI()));
365                    element.setAttribute("localname", String.valueOf(amd.getLocalName()));
366                  element.setAttribute("visible", String.valueOf(amd.isVisible()));                  element.setAttribute("visible", String.valueOf(amd.isVisible()));
367                  element.setAttribute("unit", amd.getUnit());                  element.setAttribute("unit", amd.getUnit());
368                  // Creating a aml:name tag...                  // Creating a aml:name tag...
# Line 325  public class StyledLayerUtil { Line 373  public class StyledLayerUtil {
373          }          }
374    
375          /**          /**
376           * Creates an JDOM {@link Element} for the given {@link AttributeMetaData}           * Creates an JDOM {@link Element} for the given
377           * map.           * {@link AttributeMetadataImpl} map.
378           *           *
379           * @param amdMap           * @param amdMap
380           *            map of attribute meta data           *            map of attribute meta data
381           */           */
382          public static Element createAttributeMetaDataMapElement(          public static Element createAttributeMetaDataMapElement(
383                          final Map<Integer, AttributeMetaData> amdMap) {                          final AttributeMetadataMap<? extends AttributeMetadata> amdMap) {
384                  final Element element = new Element(ELEM_NAME_AMD, AMLURI);                  final Element element = new Element(ELEM_NAME_AMD, AMLURI);
385                  for (AttributeMetaData amd : amdMap.values())                  for (final AttributeMetadata amd : amdMap.values())
386                          element.addContent(createAttributeMetaDataElement(amd));                          element.addContent(createAttributeMetaDataElement(amd));
387                  return element;                  return element;
388          }          }
389    
390          /**          /**
391           * Saves a {@link AttributeMetaData AttributeMetaData-Map} to an URL.           * Saves a {@link AttributeMetadataImpl AttributeMetaData-Map} to an URL.
392           *           *
393           * @param amdMap           * @param amdMap
394           *            map of {@link AttributeMetaData}           *            map of {@link AttributeMetadataImpl}
395           * @param documentUrl           * @param documentUrl
396           *            {@link URL} to store the XML           *            {@link URL} to store the XML
397           */           */
398          public static void saveAttributeMetaDataMap(          public static void saveAttributeMetaDataMap(
399                          final Map<Integer, AttributeMetaData> amdMap, final URL documentUrl)                          final AttributeMetadataMap amdMap, final URL documentUrl)
400                          throws Exception {                          throws Exception {
401                  // Create XML-Document                  // Create XML-Document
402                  final FileWriter out = new FileWriter(new File(documentUrl.toURI()));                  final FileWriter out = new FileWriter(new File(documentUrl.toURI()));
# Line 365  public class StyledLayerUtil { Line 413  public class StyledLayerUtil {
413           * @param element           * @param element
414           *            {@link Element} to parse           *            {@link Element} to parse
415           */           */
416          public static RasterLegendData parseRasterLegendData(Element element) {          public static RasterLegendData parseRasterLegendData(final Element element) {
417    
418                  final boolean paintGaps = Boolean.valueOf(element                  final boolean paintGaps = Boolean.valueOf(element
419                                  .getAttributeValue("paintGaps"));                                  .getAttributeValue("paintGaps"));
420    
421                  RasterLegendData rld = new RasterLegendData(paintGaps);                  final RasterLegendData rld = new RasterLegendData(paintGaps);
422    
423                  for (Element childElement : (List<Element>) element.getChildren()) {                  for (final Element childElement : (List<Element>) element.getChildren()) {
424                          final String name = childElement.getName();                          final String name = childElement.getName();
425                          // Cancel if it's an attribute                          // Cancel if it's an attribute
426                          if (childElement.getChildren().size() == 0)                          if (childElement.getChildren().size() == 0)
# Line 392  public class StyledLayerUtil { Line 440  public class StyledLayerUtil {
440                                  // id label element is missing, the translation is searched                                  // id label element is missing, the translation is searched
441                                  // directly                                  // directly
442                                  // as childs of the rasterLegendItem element                                  // as childs of the rasterLegendItem element
443                                  Translation label = parseTranslation(labelElement != null ? labelElement                                  final Translation label = parseTranslation(labelElement != null ? labelElement
444                                                  : childElement);                                                  : childElement);
445                                  rld.put(value, label);                                  rld.put(value, label);
446                          }                          }
# Line 410  public class StyledLayerUtil { Line 458  public class StyledLayerUtil {
458           */           */
459          public static RasterLegendData loadRasterLegendData(final URL documentUrl)          public static RasterLegendData loadRasterLegendData(final URL documentUrl)
460                          throws Exception {                          throws Exception {
461                  Document document = SAX_BUILDER.build(documentUrl);                  final Document document = SAX_BUILDER.build(documentUrl);
462                  return parseRasterLegendData(document.getRootElement());                  return parseRasterLegendData(document.getRootElement());
463          }          }
464    
# Line 425  public class StyledLayerUtil { Line 473  public class StyledLayerUtil {
473                          final RasterLegendData rld) {                          final RasterLegendData rld) {
474                  final Element element = new Element(ELEM_NAME_RLD, AMLURI);                  final Element element = new Element(ELEM_NAME_RLD, AMLURI);
475                  element.setAttribute("paintGaps", rld.isPaintGaps().toString());                  element.setAttribute("paintGaps", rld.isPaintGaps().toString());
476                  for (Double key : rld.getSortedKeys()) {                  for (final Double key : rld.getSortedKeys()) {
477                          Element item = new Element(ELEM_NAME_RASTERLEGEND, AMLURI);                          final Element item = new Element(ELEM_NAME_RASTERLEGEND, AMLURI);
478                          item.setAttribute("value", key.toString());                          item.setAttribute("value", key.toString());
479                          item.addContent(createTranslationElement("label", rld.get(key)));                          item.addContent(createTranslationElement("label", rld.get(key)));
480                          element.addContent(item);                          element.addContent(item);
# Line 446  public class StyledLayerUtil { Line 494  public class StyledLayerUtil {
494           *            rounded to (null means no round; >= 0 means digits after           *            rounded to (null means no round; >= 0 means digits after
495           *            comma; < 0 means digits before comma)           *            comma; < 0 means digits before comma)
496           */           */
497          public static RasterLegendData generateRasterLegendData(ColorMap colorMap,          public static RasterLegendData generateRasterLegendData(
498                          boolean paintGaps, Integer digits) {                          final ColorMap colorMap, final boolean paintGaps,
499                  DecimalFormat decFormat = digits != null ? new DecimalFormat(SwingUtil                          final Integer digits) {
500                                  .getNumberFormatPattern(digits)) : null;                  final DecimalFormat decFormat = digits != null ? new DecimalFormat(
501                  RasterLegendData rld = new RasterLegendData(paintGaps);                                  SwingUtil.getNumberFormatPattern(digits)) : null;
502                  for (ColorMapEntry cme : colorMap.getColorMapEntries()) {                  final RasterLegendData rld = new RasterLegendData(paintGaps);
503                          double value = StylingUtil.getQuantityFromColorMapEntry(cme);                  for (final ColorMapEntry cme : colorMap.getColorMapEntries()) {
504                            final double value = StylingUtil.getQuantityFromColorMapEntry(cme);
505                          String label = cme.getLabel();                          String label = cme.getLabel();
506                          // if no label is set (e.g. quantitative style),                          // if no label is set (e.g. quantitative style),
507                          // use the value as label                          // use the value as label
# Line 478  public class StyledLayerUtil { Line 527  public class StyledLayerUtil {
527           *            rounded to (null means no round; >= 0 means digits after           *            rounded to (null means no round; >= 0 means digits after
528           *            comma; < 0 means digits before comma)           *            comma; < 0 means digits before comma)
529           */           */
530          public static RasterLegendData generateRasterLegendData(Style style,          public static RasterLegendData generateRasterLegendData(final Style style,
531                          boolean paintGaps, Integer digits) {                          final boolean paintGaps, final Integer digits) {
532                  ColorMap colorMap = StylingUtil.getColorMapFromStyle(style);                  final ColorMap colorMap = StylingUtil.getColorMapFromStyle(style);
533                  if (colorMap == null)                  if (colorMap == null)
534                          throw new IllegalArgumentException(                          throw new IllegalArgumentException(
535                                          "Color map can not be determined from style!");                                          "Color map can not be determined from style!");
# Line 513  public class StyledLayerUtil { Line 562  public class StyledLayerUtil {
562           *            {@link Element} to parse           *            {@link Element} to parse
563           */           */
564          public final static Translation parseTranslation(final Element element) {          public final static Translation parseTranslation(final Element element) {
565                  Translation trans = new Translation();                  final Translation trans = new Translation();
566    
567                  if (element == null)                  if (element == null)
568                          return trans;                          return trans;
# Line 555  public class StyledLayerUtil { Line 604  public class StyledLayerUtil {
604           * @param translation           * @param translation
605           *            Translation to store in the Element           *            Translation to store in the Element
606           */           */
607          public final static Element createTranslationElement(String tagname,          public final static Element createTranslationElement(final String tagname,
608                          Translation translation) {                          final Translation translation) {
609                  Element element = new Element(tagname, AMLURI);                  final Element element = new Element(tagname, AMLURI);
610                  if (translation == null)                  if (translation == null)
611                          throw new UnsupportedOperationException(                          throw new UnsupportedOperationException(
612                                          "Translation element can not be created from null!");                                          "Translation element can not be created from null!");
# Line 573  public class StyledLayerUtil { Line 622  public class StyledLayerUtil {
622    
623                  // add a <translation lang="..">..</tranlation> part to the element for                  // add a <translation lang="..">..</tranlation> part to the element for
624                  // all languages                  // all languages
625                  for (String lang : translation.keySet()) {                  for (final String lang : translation.keySet()) {
626                          Element translationElement = new Element(ELEM_NAME_TRANSLATION,                          final Element translationElement = new Element(
627                                          AMLURI);                                          ELEM_NAME_TRANSLATION, AMLURI);
628                          translationElement.setAttribute("lang", lang);                          translationElement.setAttribute("lang", lang);
629                          String translationString = translation.get(lang);                          String translationString = translation.get(lang);
630                          if (translationString == null)                          if (translationString == null)
# Line 595  public class StyledLayerUtil { Line 644  public class StyledLayerUtil {
644           * @param style           * @param style
645           *            a Style           *            a Style
646           */           */
647          public static void setStyledLayerStyle(StyledLayerInterface styledObject,          public static void setStyledLayerStyle(
648                          StyledLayerStyle<?> style) {                          final StyledLayerInterface styledObject,
649                            final StyledLayerStyle<?> style) {
650                  // set SLD style                  // set SLD style
651                  styledObject.setStyle(style.getGeoObjectStyle());                  styledObject.setStyle(style.getGeoObjectStyle());
652                  // set meta data                  // set meta data
653                  if (styledObject instanceof StyledGridCoverageInterface                  if (styledObject instanceof StyledGridCoverageInterface
654                                  && (style.getMetaData() instanceof RasterLegendData || style                                  && (style.getMetaData() instanceof RasterLegendData || style
655                                                  .getMetaData() == null)) {                                                  .getMetaData() == null)) {
656                          RasterLegendData sourceRld = (RasterLegendData) style.getMetaData();                          final RasterLegendData sourceRld = (RasterLegendData) style
657                          RasterLegendData destRld = ((StyledGridCoverageInterface) styledObject)                                          .getMetaData();
658                            final RasterLegendData destRld = ((StyledGridCoverageInterface) styledObject)
659                                          .getLegendMetaData();                                          .getLegendMetaData();
660                          if (destRld != null && sourceRld != null) {                          if (destRld != null && sourceRld != null) {
661                                  destRld.setPaintGaps(sourceRld.isPaintGaps());                                  destRld.setPaintGaps(sourceRld.isPaintGaps());
# Line 615  public class StyledLayerUtil { Line 666  public class StyledLayerUtil {
666                  }                  }
667                  if (styledObject instanceof StyledFeatureCollectionInterface                  if (styledObject instanceof StyledFeatureCollectionInterface
668                                  && (style.getMetaData() instanceof Map || style.getMetaData() == null)) {                                  && (style.getMetaData() instanceof Map || style.getMetaData() == null)) {
669                          Map<Integer, AttributeMetaData> sourceAmd = (Map<Integer, AttributeMetaData>) style                          final AttributeMetadataMap sourceAmd = (AttributeMetadataMap) style
670                                          .getMetaData();                                          .getMetaData();
671                          Map<Integer, AttributeMetaData> destAmd = ((StyledFeatureCollectionInterface) styledObject)                          final AttributeMetadataMap destAmd = ((StyledFeatureCollectionInterface) styledObject)
672                                          .getAttributeMetaDataMap();                                          .getAttributeMetaDataMap();
673                          if (destAmd != null && sourceAmd != null) {                          if (destAmd != null && sourceAmd != null) {
674                                  destAmd.clear();                                  destAmd.clear();
# Line 647  public class StyledLayerUtil { Line 698  public class StyledLayerUtil {
698           *         {@link StyledFeatureCollectionInterface}           *         {@link StyledFeatureCollectionInterface}
699           */           */
700          public static StyledLayerStyle<?> getStyledLayerStyle(          public static StyledLayerStyle<?> getStyledLayerStyle(
701                          StyledLayerInterface styledObject) {                          final StyledLayerInterface styledObject) {
702                  if (styledObject instanceof StyledGridCoverageInterface)                  if (styledObject instanceof StyledGridCoverageInterface)
703                          return getStyledLayerStyle((StyledGridCoverageInterface) styledObject);                          return getStyledLayerStyle((StyledGridCoverageInterface) styledObject);
704                  if (styledObject instanceof StyledFeatureCollectionInterface)                  if (styledObject instanceof StyledFeatureCollectionInterface)
# Line 666  public class StyledLayerUtil { Line 717  public class StyledLayerUtil {
717           *            a styled grid coverage           *            a styled grid coverage
718           */           */
719          public static StyledLayerStyle<RasterLegendData> getStyledLayerStyle(          public static StyledLayerStyle<RasterLegendData> getStyledLayerStyle(
720                          StyledGridCoverageInterface styledGC) {                          final StyledGridCoverageInterface styledGC) {
721                  return new StyledLayerStyle<RasterLegendData>(styledGC.getStyle(),                  return new StyledLayerStyle<RasterLegendData>(styledGC.getStyle(),
722                                  styledGC.getLegendMetaData());                                  styledGC.getLegendMetaData());
723          }          }
# Line 678  public class StyledLayerUtil { Line 729  public class StyledLayerUtil {
729           * @param styledFC           * @param styledFC
730           *            a styled feature collection           *            a styled feature collection
731           */           */
732          public static StyledLayerStyle<Map<Integer, AttributeMetaData>> getStyledLayerStyle(          public static StyledLayerStyle<AttributeMetadataMap> getStyledLayerStyle(
733                          StyledFeatureCollectionInterface styledFC) {                          final StyledFeatureCollectionInterface styledFC) {
734                  return new StyledLayerStyle<Map<Integer, AttributeMetaData>>(styledFC                  return new StyledLayerStyle<AttributeMetadataMap>(styledFC.getStyle(),
735                                  .getStyle(), styledFC.getAttributeMetaDataMap());                                  styledFC.getAttributeMetaDataMap());
736          }          }
737    
738          /**          /**
# Line 698  public class StyledLayerUtil { Line 749  public class StyledLayerUtil {
749           * @return {@code null} in case of any error           * @return {@code null} in case of any error
750           */           */
751          public static StyledLayerStyle<RasterLegendData> loadStyledRasterStyle(          public static StyledLayerStyle<RasterLegendData> loadStyledRasterStyle(
752                          URL geoObjectURL, String sldExt, String rldExt) {                          final URL geoObjectURL, final String sldExt, final String rldExt) {
753                  RasterLegendData metaData = null;                  RasterLegendData metaData = null;
754                  Style sldStyle = null;                  Style sldStyle = null;
755                  try {                  try {
756                          Style[] styles = StylingUtil.loadSLD(IOUtil.changeUrlExt(                          final Style[] styles = StylingUtil.loadSLD(IOUtil.changeUrlExt(
757                                          geoObjectURL, sldExt));                                          geoObjectURL, sldExt));
758                          // SLD must be present                          // SLD must be present
759                          if (styles == null || styles.length == 0)                          if (styles == null || styles.length == 0)
760                                  return null;                                  return null;
761                          sldStyle = styles[0];                          sldStyle = styles[0];
762                  } catch (Exception err) {                  } catch (final Exception err) {
763                          // SLD must be present                          // SLD must be present
764                          LangUtil.logDebugError(LOGGER, err);                          LangUtil.logDebugError(LOGGER, err);
765                          return null;                          return null;
# Line 717  public class StyledLayerUtil { Line 768  public class StyledLayerUtil {
768                  try {                  try {
769                          metaData = StyledLayerUtil.loadRasterLegendData(IOUtil                          metaData = StyledLayerUtil.loadRasterLegendData(IOUtil
770                                          .changeUrlExt(geoObjectURL, rldExt));                                          .changeUrlExt(geoObjectURL, rldExt));
771                  } catch (FileNotFoundException err) {                  } catch (final FileNotFoundException err) {
772                          // ignore missing raster legend data                          // ignore missing raster legend data
773                  } catch (Exception err) {                  } catch (final Exception err) {
774                          // any other error during legend data creation leads to error                          // any other error during legend data creation leads to error
775                          LangUtil.logDebugError(LOGGER, err);                          LangUtil.logDebugError(LOGGER, err);
776                          return null;                          return null;
# Line 742  public class StyledLayerUtil { Line 793  public class StyledLayerUtil {
793           * @return {@code null} in case of any error           * @return {@code null} in case of any error
794           */           */
795          public static StyledLayerStyle<RasterLegendData> loadStyledRasterStyle(          public static StyledLayerStyle<RasterLegendData> loadStyledRasterStyle(
796                          URL geoObjectURL) {                          final URL geoObjectURL) {
797                  return loadStyledRasterStyle(geoObjectURL, "sld", "rld");                  return loadStyledRasterStyle(geoObjectURL, "sld", "rld");
798          }          }
799    
800          /**          /**
801           * Loads a {@linkplain Style SLD-Style} and a {@linkplain AttributeMetaData           * Loads a {@linkplain Style SLD-Style} and a
802           * AttributeMetaData-Map} for a given geo-object (feature) source. The SLD           * {@linkplain AttributeMetadataImpl AttributeMetaData-Map} for a given
803           * file must be present. A missing attribute meta-data file is tolerated.           * geo-object (feature) source. The SLD file must be present. A missing
804             * attribute meta-data file is tolerated.
805           *           *
806           * @param geoObjectURL           * @param geoObjectURL
807           *            URL of the (already read) feature object           *            URL of the (already read) feature object
# Line 759  public class StyledLayerUtil { Line 811  public class StyledLayerUtil {
811           *            file extention for the raster legend-data file           *            file extention for the raster legend-data file
812           * @return {@code null} in case of any error           * @return {@code null} in case of any error
813           */           */
814          public static StyledLayerStyle<Map<Integer, AttributeMetaData>> loadStyledFeatureStyle(          public static StyledLayerStyle<AttributeMetadataMap> loadStyledFeatureStyle(
815                          URL geoObjectURL, String sldExt, String rldExt) {                          final URL geoObjectURL, final String sldExt, final String rldExt) {
816                  Map<Integer, AttributeMetaData> metaData = null;                  AttributeMetadataMap metaData = null;
817                  Style sldStyle = null;                  Style sldStyle = null;
818                  try {                  try {
819                          Style[] styles = StylingUtil.loadSLD(IOUtil.changeUrlExt(                          final Style[] styles = StylingUtil.loadSLD(IOUtil.changeUrlExt(
820                                          geoObjectURL, sldExt));                                          geoObjectURL, sldExt));
821                          // SLD must be present                          // SLD must be present
822                          if (styles == null || styles.length == 0)                          if (styles == null || styles.length == 0)
823                                  return null;                                  return null;
824                          sldStyle = styles[0];                          sldStyle = styles[0];
825                  } catch (Exception err) {                  } catch (final Exception err) {
826                          // SLD must be present                          // SLD must be present
827                          LangUtil.logDebugError(LOGGER, err);                          LangUtil.logDebugError(LOGGER, err);
828                          return null;                          return null;
# Line 779  public class StyledLayerUtil { Line 831  public class StyledLayerUtil {
831                  try {                  try {
832                          metaData = StyledLayerUtil.loadAttributeMetaDataMap(IOUtil                          metaData = StyledLayerUtil.loadAttributeMetaDataMap(IOUtil
833                                          .changeUrlExt(geoObjectURL, rldExt));                                          .changeUrlExt(geoObjectURL, rldExt));
834                  } catch (FileNotFoundException err) {                  } catch (final FileNotFoundException err) {
835                          // ignore missing attribute meta data                          // ignore missing attribute meta data
836                  } catch (Exception err) {                  } catch (final Exception err) {
837                          // any other error during meta data creation leads to error                          // any other error during meta data creation leads to error
838                          LangUtil.logDebugError(LOGGER, err);                          LangUtil.logDebugError(LOGGER, err);
839                          return null;                          return null;
840                  }                  }
841    
842                  return new StyledLayerStyle<Map<Integer, AttributeMetaData>>(sldStyle,                  return new StyledLayerStyle<AttributeMetadataMap>(sldStyle, metaData);
                                 metaData);  
843          }          }
844    
845          /**          /**
846           * Loads a {@linkplain Style SLD-Style} from a {@code .sld} file and           * Loads a {@linkplain Style SLD-Style} from a {@code .sld} file and
847           * {@linkplain AttributeMetaData AttributeMetaData-Map} from a {@code .amd}           * {@linkplain AttributeMetadataImpl AttributeMetaData-Map} from a {@code
848           * file for a given geo-object (feature) source. The SLD file must be           * .amd} file for a given geo-object (feature) source. The SLD file must be
849           * present. A missing attribute meta-data file is tolerated.           * present. A missing attribute meta-data file is tolerated.
850           *           *
851           * @param geoObjectURL           * @param geoObjectURL
# Line 805  public class StyledLayerUtil { Line 856  public class StyledLayerUtil {
856           *            file extention for the raster legend-data file           *            file extention for the raster legend-data file
857           * @return {@code null} in case of any error           * @return {@code null} in case of any error
858           */           */
859          public static StyledLayerStyle<Map<Integer, AttributeMetaData>> loadStyledFeatureStyle(          public static StyledLayerStyle<AttributeMetadataMap> loadStyledFeatureStyle(
860                          URL geoObjectURL) {                          final URL geoObjectURL) {
861                  return loadStyledFeatureStyle(geoObjectURL, "sld", "amd");                  return loadStyledFeatureStyle(geoObjectURL, "sld", "amd");
862          }          }
863    
# Line 823  public class StyledLayerUtil { Line 874  public class StyledLayerUtil {
874           * @param mdExt           * @param mdExt
875           *            file extention for the meta-data file           *            file extention for the meta-data file
876           */           */
877          public static <T> void saveStyledLayerStyle(StyledLayerStyle<T> style,          public static <T> void saveStyledLayerStyle(
878                          URL geoObjectURL, String sldExt, String mdExt) throws Exception {                          final StyledLayerStyle<T> style, final URL geoObjectURL,
879                            final String sldExt, final String mdExt) throws Exception {
880                  // Store the SLD                  // Store the SLD
881                  Style sldStyle = style.getGeoObjectStyle();                  final Style sldStyle = style.getGeoObjectStyle();
882                  if (sldStyle != null) {                  if (sldStyle != null) {
883                          StylingUtil.saveStyleToSLD(sldStyle, IOUtil.changeFileExt(new File(                          StylingUtil.saveStyleToSLD(sldStyle, IOUtil.changeFileExt(new File(
884                                          geoObjectURL.toURI()), sldExt));                                          geoObjectURL.toURI()), sldExt));
885                  }                  }
886    
887                  // Store the meta data                  // Store the meta data
888                  T metaData = style.getMetaData();                  final T metaData = style.getMetaData();
889                  if (metaData != null) {                  if (metaData != null) {
890                          if (metaData instanceof RasterLegendData) {                          if (metaData instanceof RasterLegendData) {
891                                  saveRasterLegendData((RasterLegendData) metaData, IOUtil                                  saveRasterLegendData((RasterLegendData) metaData, IOUtil
# Line 842  public class StyledLayerUtil { Line 894  public class StyledLayerUtil {
894                                  // Map<Integer,AttributeMetaData> ) { // LEIDER NICHT                                  // Map<Integer,AttributeMetaData> ) { // LEIDER NICHT
895                                  // KOMPILIERBAR!!                                  // KOMPILIERBAR!!
896                          } else if (metaData instanceof Map) {                          } else if (metaData instanceof Map) {
897                                  saveAttributeMetaDataMap(                                  saveAttributeMetaDataMap((AttributeMetadataMap) metaData,
898                                                  (Map<Integer, AttributeMetaData>) metaData, IOUtil                                                  IOUtil.changeUrlExt(geoObjectURL, mdExt));
                                                                 .changeUrlExt(geoObjectURL, mdExt));  
899                          } else                          } else
900                                  throw new UnsupportedOperationException(                                  throw new UnsupportedOperationException(
901                                                  "Export for meta data not yet supported: "                                                  "Export for meta data not yet supported: "
# Line 854  public class StyledLayerUtil { Line 905  public class StyledLayerUtil {
905    
906          /**          /**
907           * Stores the {@linkplain Style SLD-Style} to a {@code .sld} file and the           * Stores the {@linkplain Style SLD-Style} to a {@code .sld} file and the
908           * meta data ({@link RasterLegendData} or {@link AttributeMetaData}) to a           * meta data ({@link RasterLegendData} or {@link AttributeMetadataImpl}) to
909           * {@code .rld} or {@code .amd} file. for a given geo-object source.           * a {@code .rld} or {@code .amd} file. for a given geo-object source.
910           *           *
911           * @param style           * @param style
912           *            style to save           *            style to save
913           * @param geoObjectURL           * @param geoObjectURL
914           *            URL of the (already read) raster object           *            URL of the (already read) raster object
915           */           */
916          public static void saveStyledLayerStyle(StyledLayerStyle<?> style,          public static void saveStyledLayerStyle(final StyledLayerStyle<?> style,
917                          URL geoObjectURL) throws Exception {                          final URL geoObjectURL) throws Exception {
918                  if (style.getMetaData() instanceof RasterLegendData)                  if (style.getMetaData() instanceof RasterLegendData)
919                          saveStyledLayerStyle(style, geoObjectURL, "sld", "rld");                          saveStyledLayerStyle(style, geoObjectURL, "sld", "rld");
920                  else                  else
# Line 871  public class StyledLayerUtil { Line 922  public class StyledLayerUtil {
922          }          }
923    
924          /**          /**
925           * Creates a {@link Box} that shows a legend for a list of           * *If appended to the name of a rule, this rule shall not be shown in the
926             * legend
927             */
928            public final static String HIDE_IN_LAYER_LEGEND_HINT = "HIDE_IN_LEGEND";
929    
930            /**
931             * Creates a {@link JPanel} that shows a legend for a list of
932           * {@link FeatureTypeStyle}s and a targeted featureType           * {@link FeatureTypeStyle}s and a targeted featureType
933           *           *
934           * @param featureType           * @param featureType
# Line 882  public class StyledLayerUtil { Line 939  public class StyledLayerUtil {
939           * @author <a href="mailto:[email protected]">Stefan Alfons           * @author <a href="mailto:[email protected]">Stefan Alfons
940           *         Kr&uuml;ger</a>           *         Kr&uuml;ger</a>
941           */           */
942          public static Box createLegendPanel(List<FeatureTypeStyle> list,          public static JPanel createLegendPanel(Style style,
943                          SimpleFeatureType featureType, int iconWidth, int iconHeight) {                          final SimpleFeatureType featureType, final int iconWidth,
944                            final int iconHeight) {
945    
946                  Box box = new Box(BoxLayout.Y_AXIS) {                  final List<FeatureTypeStyle> list = style.featureTypeStyles();
947    
948                          /**                  final JPanel panel = new JPanel(new MigLayout("wrap 2", "[]:3:[]"));
949                           * Nuetzlich wenn die Componente gedruckt (z.B. wenn ein Screenshot  
950                           * gemacht wird) wird. Dann werden wird der Hintergrund auf WEISS                  if (style == null) {
951                           * gesetzt.                          // No Style => no legend
952                           *                          return panel;
953                           * @author <a href="mailto:[email protected]">Stefan Alfons                  }
                          *         Kr&uuml;ger</a>  
                          */  
                         @Override  
                         public void print(Graphics g) {  
                                 final Color orig = getBackground();  
                                 setBackground(Color.WHITE);  
                                 // wrap in try/finally so that we always restore the state  
                                 try {  
                                         super.print(g);  
                                 } finally {  
                                         setBackground(orig);  
                                 }  
                         }  
                 };  
954    
955                  for (FeatureTypeStyle ftStyle : list) {                  for (final FeatureTypeStyle ftStyle : list) {
956    
957                          // One child-node for every rule                          // One child-node for every rule
958                          List<Rule> rules = ftStyle.rules();                          final List<Rule> rules = ftStyle.rules();
959                          for (Rule rule : rules) {                          for (final Rule rule : rules) {
960    
961                                    // Check if this RULE shall actually appear in the legend
962                                    if (rule.getName() != null
963                                                    && rule.getName().endsWith(HIDE_IN_LAYER_LEGEND_HINT))
964                                            continue;
965    
966                                  /**                                  /**
967                                   * Let's not create a hbox for Rules that only contain                                   * Let's not create a hbox for Rules that only contain
# Line 922  public class StyledLayerUtil { Line 971  public class StyledLayerUtil {
971                                                  .size() == rule.getSymbolizers().length)                                                  .size() == rule.getSymbolizers().length)
972                                          continue;                                          continue;
973    
                                 Box hbox = new Box(BoxLayout.X_AXIS) {  
   
                                         /**  
                                          * Nuetzlich wenn die Componente gedruckt (z.B. wenn ein  
                                          * Screenshot gemacht wird) wird. Dann werden wird der  
                                          * Hintergrund auf WEISS gesetzt.  
                                          */  
                                         @Override  
                                         public void print(Graphics g) {  
                                                 final Color orig = getBackground();  
                                                 setBackground(Color.WHITE);  
                                                 // wrap in try/finally so that we always restore the  
                                                 // state  
                                                 try {  
                                                         super.print(g);  
                                                 } finally {  
                                                         setBackground(orig);  
                                                 }  
                                         }  
                                 };  
   
                                 /**  
                                  * The size of the legend Symbol is dependent on the size of the  
                                  * font.  
                                  */  
                                 final int fontHeight = new JLabel().getFontMetrics(  
                                                 new JLabel().getFont()).getHeight();  
   
                                 final Dimension ICON_SIZE = new Dimension(iconWidth,  
                                                 fontHeight > 5 ? fontHeight : iconHeight);  
   
                                 // ****************************************************************************  
                                 // Create the actual icon  
                                 // ****************************************************************************  
974                                  final BufferedImage imageForRule = LegendIconFeatureRenderer                                  final BufferedImage imageForRule = LegendIconFeatureRenderer
975                                                  .getInstance().createImageForRule(rule, featureType,                                                  .getInstance().createImageForRule(rule, featureType,
976                                                                  ICON_SIZE);                                                                  new Dimension(iconWidth, iconHeight));
977    
978                                  // LOGGER.debug("Creating a new Legend Image for RUle name =                                  final ImageIcon legendIcon = new ImageIcon(imageForRule);
                                 // "+rule.getName());  
   
                                 ImageIcon legendIcon = new ImageIcon(imageForRule);  
979    
980                                  final JLabel iconLabel = new JLabel(legendIcon);                                  final JLabel iconLabel = new JLabel(legendIcon);
981                                  hbox.setAlignmentX(0f);                                  panel.add(iconLabel, "sgx1");
982                                  hbox.add(iconLabel);                                  // hbox.setAlignmentX(0f);
983                                  hbox.add(Box.createHorizontalStrut(3));                                  // hbox.add(iconLabel);
984                                    // hbox.add(Box.createHorizontalStrut(3));
                                 // ****************************************************************************  
                                 // The labeltext is read from the SLD. Its either the title  
                                 // directly, or interpreted as OneLine Code  
                                 // ****************************************************************************  
                                 // final String rawText =  
                                 // rule.getDescription().getTitle().toString();  
                                 final String rawText = rule.getDescription().getTitle()  
                                                 .toString();  
   
                                 Translation labelT = new Translation();  
                                 labelT.fromOneLine(rawText);  
985    
986                                    final Translation labelT = new Translation();
987                                    labelT.fromOneLine(rule.getDescription().getTitle());
988                                  final JLabel classTitleLabel = new JLabel(labelT.toString());                                  final JLabel classTitleLabel = new JLabel(labelT.toString());
                                 hbox.add(classTitleLabel);  
                                 classTitleLabel.setLabelFor(iconLabel);  
   
                                 box.add(hbox);  
989    
990                                    panel.add(classTitleLabel, "sgx2");
991                                    classTitleLabel.setLabelFor(iconLabel);
992                          }                          }
993                  }                  }
994    
995                  return box;                  return panel;
996          }          }
997    
998          /**          /**
999           * Creates a           * Creates a {@link JComponent} that contains a legend for a given
1000             * rasterLayer and a given {@link Style}.
1001           *           *
1002           * @param styledGrid           * @param style
1003           * @param iconHeight           *            if <code>null</code>, the default {@link Style} is extracetd
1004           * @param iconWidth           *            from the {@link StyledRasterInterface}
          * @return  
1005           */           */
1006          public static Box createLegendPanel(StyledRasterInterface<?> styledGrid,          public static JPanel createLegendPanel(
1007                          int iconWidth, int iconHeight) {                          final StyledRasterInterface<?> styledRaster, Style style,
1008                  RasterLegendData rasterLegendData = styledGrid.getLegendMetaData();                          final int iconWidth, final int iconHeight) {
1009                  Set<Double> legendRasterValues = rasterLegendData.keySet();  
1010                  Map<Double, GridCoverage2D> sampleRasters = rasterLegendData                  // If no style is given, we use the default style for this layer
1011                    if (style == null)
1012                            style = styledRaster.getStyle();
1013    
1014                    /**
1015                     * Determine whether a Style is responsible for the coloring
1016                     */
1017                    ColorModel colorModel = null;
1018                    if (!isStyleable(styledRaster)
1019                                    || (isStyleable(styledRaster) && style == null)) {
1020                            colorModel = getColorModel(styledRaster);
1021                    }
1022    
1023                    final RasterLegendData rasterLegendData = styledRaster
1024                                    .getLegendMetaData();
1025                    final List<Double> legendRasterValues = rasterLegendData
1026                                    .getSortedKeys();
1027                    final Map<Double, GridCoverage2D> sampleRasters = rasterLegendData
1028                                  .createSampleRasters();                                  .createSampleRasters();
1029    
1030                  Box box = new Box(BoxLayout.Y_AXIS) {                  final JPanel panel = new JPanel(new MigLayout("wrap 2, gapy 0"));
1031    
1032                          /**                  for (final Double rValue : legendRasterValues) {
                          * Nuetzlich wenn die Componente gedruckt (z.B. wenn ein Screenshot  
                          * gemacht wird) wird. Dann werden wird der Hintergrund auf WEISS  
                          * gesetzt.  
                          */  
                         @Override  
                         public void print(Graphics g) {  
                                 final Color orig = getBackground();  
                                 setBackground(Color.WHITE);  
                                 // wrap in try/finally so that we always restore the state  
                                 try {  
                                         super.print(g);  
                                 } finally {  
                                         setBackground(orig);  
                                 }  
                         }  
                 };  
1033    
1034                  for (Double rValue : legendRasterValues) {                          // final Dimension ICON_SIZE = new Dimension(iconWidth,
1035                            // new JLabel().getFontMetrics(new JLabel().getFont())
1036                            // .getHeight() > 5 ? new JLabel().getFontMetrics(
1037                            // new JLabel().getFont()).getHeight() : iconHeight);
1038    
1039                          /**                          // ****************************************************************************
1040                           * The coverage contains only one value of value rValue                          // Create the actual icon
1041                           */                          // ****************************************************************************
1042                          GridCoverage2D sampleCov = sampleRasters.get(rValue);                          final BufferedImage buffImage = new BufferedImage(iconWidth,
1043                          GridCoverageRenderer renderer;                                          iconHeight, BufferedImage.TYPE_INT_ARGB);
                         try {  
                                 renderer = new GridCoverageRenderer(sampleCov  
                                                 .getCoordinateReferenceSystem(), JTSUtil  
                                                 .createEnvelope(sampleCov.getEnvelope()),  
                                                 new Rectangle(iconWidth, iconHeight),  
                                                 (AffineTransform) null);  
                         } catch (Exception e1) {  
                                 throw new RuntimeException(  
                                                 "Creating the GridCoverageRenderer:", e1);  
                         }  
1044    
1045                          /**                          final Graphics2D graphics = buffImage.createGraphics();
1046                           *  
1047                           */                          if (colorModel != null) {
1048                          Box hbox = new Box(BoxLayout.X_AXIS) {                                  // The colors come from the ColorModel!
1049    
1050                                    try {
1051                                            Object inData = null;
1052                                            switch (colorModel.getTransferType()) {
1053                                            case DataBuffer.TYPE_BYTE:
1054                                                    inData = new byte[] { rValue.byteValue() };
1055                                                    break;
1056                                            case DataBuffer.TYPE_USHORT:
1057                                                    inData = new short[] { rValue.shortValue() };
1058                                                    break;
1059                                            case DataBuffer.TYPE_INT:
1060                                                    inData = new int[] { rValue.intValue() };
1061                                                    break;
1062                                            case DataBuffer.TYPE_SHORT:
1063                                                    inData = new short[] { rValue.shortValue() };
1064                                                    break;
1065                                            case DataBuffer.TYPE_FLOAT:
1066                                                    inData = new float[] { rValue.floatValue() };
1067                                                    break;
1068                                            case DataBuffer.TYPE_DOUBLE:
1069                                                    inData = new double[] { rValue.doubleValue() };
1070                                                    break;
1071                                            default:
1072                                                    inData = rValue.intValue();
1073                                            }
1074                                            final Color color = new Color(colorModel.getRGB(inData));
1075                                            graphics.setBackground(color);
1076                                            graphics.setColor(color);
1077                                            graphics.fillRect(0, 0, iconWidth, iconHeight);
1078                                    } catch (final Exception e) {
1079                                            LOGGER.info(
1080                                                            "Dann nehmen wir halt den GridCoverageRenderer", e);
1081                                            colorModel = null;
1082                                    }
1083                            } else {
1084                                    // The colors come from the Style
1085    
1086                                    /**
1087                                     * The coverage contains only one value of value rValue
1088                                     */
1089                                    final GridCoverage2D sampleCov = sampleRasters.get(rValue);
1090                                    GridCoverageRenderer renderer;
1091                                    try {
1092                                            renderer = new GridCoverageRenderer(sampleCov
1093                                                            .getCoordinateReferenceSystem(), JTSUtil
1094                                                            .createEnvelope(sampleCov.getEnvelope()),
1095                                                            new Rectangle(iconWidth, iconHeight),
1096                                                            (AffineTransform) null);
1097                                    } catch (final Exception e1) {
1098                                            throw new RuntimeException(
1099                                                            "Creating a GridCoverageRenderer failed:", e1);
1100                                    }
1101    
1102                                  /**                                  /**
1103                                   * Nuetzlich wenn die Componente gedruckt (z.B. wenn ein                                   * Iterate over all FeatureTypeStyles.
                                  * Screenshot gemacht wird) wird. Dann werden wird der  
                                  * Hintergrund auf WEISS gesetzt.  
1104                                   */                                   */
1105                                  @Override                                  final List<RasterSymbolizer> rSymbols = StylingUtil
1106                                  public void print(Graphics g) {                                                  .getRasterSymbolizers(style);
1107                                          final Color orig = getBackground();  
1108                                          setBackground(Color.WHITE);                                  for (final RasterSymbolizer symbolizer : rSymbols) {
                                         // wrap in try/finally so that we always restore the  
                                         // state  
1109                                          try {                                          try {
1110                                                  super.print(g);                                                  renderer.paint(graphics, sampleCov, symbolizer);
1111                                          } finally {                                          } catch (final Exception ee) {
1112                                                  setBackground(orig);                                                  LOGGER.error("Unable to paint " + symbolizer
1113                                                                    + " into the legend image", ee);
1114                                          }                                          }
1115                                  }                                  }
1116                          };                          }
1117    
1118                          final Dimension ICON_SIZE = new Dimension(iconWidth,                          final JLabel iconLabel = new JLabel(new ImageIcon(buffImage));
1119                                          new JLabel().getFontMetrics(new JLabel().getFont())                          panel.add(iconLabel, "sgx1");
                                                         .getHeight() > 5 ? new JLabel().getFontMetrics(  
                                                         new JLabel().getFont()).getHeight() : iconHeight);  
1120    
1121                          // ****************************************************************************                          final Translation labelT = rasterLegendData.get(rValue);
1122                          // Create the actual icon                          final JLabel classTitleLabel = new JLabel(labelT.toString());
1123                          // ****************************************************************************                          panel.add(classTitleLabel, "sgx2"
1124                          BufferedImage buffImage = new BufferedImage(ICON_SIZE.width,                                          + (rasterLegendData.isPaintGaps() ? ", gapy 0:0:0 5:5:5"
1125                                          ICON_SIZE.height, BufferedImage.TYPE_INT_ARGB);                                                          : ""));
1126                          Graphics2D graphics = buffImage.createGraphics();                          classTitleLabel.setLabelFor(iconLabel);
   
                         /**  
                          * Iterate over all FeatureTypeStyles.  
                          */  
                         // for (FeatureTypeStyle ftStyle : styledGrid.getStyle()  
                         // .featureTypeStyles()) {  
                         // One child-node for every rule  
                         // List<Rule> rules = ftStyle.rules();  
1127    
1128                          // for (Rule rule : rules) {                          if (rasterLegendData.isPaintGaps()) {
1129                          List<RasterSymbolizer> rSymbols = StylingUtil                                  iconLabel
1130                                          .getRasterSymbolizers(styledGrid.getStyle());                                                  .setBorder(BorderFactory.createLineBorder(Color.black));
   
                         for (RasterSymbolizer symbolizer : rSymbols) {  
                                 // LOGGER.debug("Creating a new Legend Image for RUle name =  
                                 // "+rule.getName());  
                                 try {  
                                         renderer.paint(graphics, sampleCov, symbolizer);  
                                 } catch (Exception e) {  
                                         LOGGER.error("Unable to paint " + symbolizer  
                                                         + " into the legend image", e);  
                                 }  
                                 // }  
                                 // }  
1131                          }                          }
1132    
1133                          ImageIcon legendIcon = new ImageIcon(buffImage);                  }
1134    
1135                          final JLabel iconLabel = new JLabel(legendIcon);                  return panel;
1136                          hbox.setAlignmentX(0f);          }
                         hbox.add(iconLabel);  
                         hbox.add(Box.createHorizontalStrut(3));  
1137    
1138                          Translation labelT = rasterLegendData.get(rValue);          /**
1139                          final JLabel classTitleLabel = new JLabel(labelT.toString());           * Extracts the {@link ColorModel} of any {@link StyledRasterInterface}. May
1140                          hbox.add(classTitleLabel);           * return <code>null</code> if the geoobject can not be accessed.
1141                          classTitleLabel.setLabelFor(iconLabel);           */
1142            @SuppressWarnings("unchecked")
1143            public static ColorModel getColorModel(
1144                            final StyledRasterInterface<?> styledGrid) {
1145                    ColorModel colorModel = null;
1146                    try {
1147                            final Object geoObject = styledGrid.getGeoObject();
1148                            if (geoObject instanceof GridCoverage2D) {
1149                                    final GridCoverage2D cov = (GridCoverage2D) geoObject;
1150                                    colorModel = cov.getRenderedImage().getColorModel();
1151                            } else if (styledGrid instanceof StyledRasterPyramidInterface) {
1152    
1153                                    final Parameter readGG = new Parameter(
1154                                                    AbstractGridFormat.READ_GRIDGEOMETRY2D);
1155    
1156                                    final ReferencedEnvelope mapExtend = new org.geotools.geometry.jts.ReferencedEnvelope(
1157                                                    styledGrid.getEnvelope(), styledGrid.getCrs());
1158    
1159                                    readGG.setValue(new GridGeometry2D(new GeneralGridEnvelope(
1160                                                    new Rectangle(0, 0, 1, 1)), mapExtend));
1161    
1162                                    final FeatureCollection<SimpleFeatureType, SimpleFeature> rFc = (FeatureCollection<SimpleFeatureType, SimpleFeature>) geoObject;
1163    
1164                                    final AbstractGridCoverage2DReader aReader = (AbstractGridCoverage2DReader) FeatureUtil
1165                                                    .getWrappedGeoObject(rFc);
1166                                    final GridCoverage2D cov = (GridCoverage2D) aReader
1167                                                    .read(new GeneralParameterValue[] { readGG });
1168                                    colorModel = cov.getRenderedImage().getColorModel();
1169                            }
1170                    } catch (final Exception e) {
1171                            LOGGER.error("Error reading the colormodel from " + styledGrid, e);
1172                            return null;
1173                    }
1174                    return colorModel;
1175            }
1176    
1177            /**
1178             * @return <code>true</code> if a {@link RasterSymbolizer} can be applied
1179             *         and will have an effect. Some rasters (e.g. GeoTIFF) can come
1180             *         with their own {@link ColorModel} and will ignore any
1181             *         {@link RasterSymbolizer} = SLD.
1182             */
1183            public static boolean isStyleable(
1184                            final StyledRasterInterface<?> styledRaster) {
1185                    final ColorModel colorModel = getColorModel(styledRaster);
1186    
1187                    // LOGGER.info("The colormodel of " + styledRaster.getTitle() + " is "
1188                    // + colorModel != null ? colorModel.getClass().getSimpleName() :
1189                    // "NULL");
1190    
1191                    if (colorModel == null)
1192                            return true;
1193                    if (colorModel instanceof ComponentColorModel)
1194                            return true;
1195                    return false;
1196            }
1197    
1198            /**
1199             * Set the given Style as the Style of the {@link MapLayer}, unless the
1200             * styles are the same (not comparing selection stuff). If the
1201             * {@link MapLayer}s {@link Style} is changed, the selection FTS is kept.<br/>
1202             * Remember {@link MapLayer#setStyle(Style)} triggers an event leading to a
1203             * repaint, so only use it when needed.
1204             *
1205             * @return <code>true</code> if the {@link MapLayer}'s {@link Style} has
1206             *         been changed.
1207             */
1208            public static boolean updateMapLayerStyleIfChangedAndKeepSelection(
1209                            MapLayer mapLayer, Style style2) {
1210    
1211                    Style mapLayerStyleCleaned = StylingUtil
1212                                    .removeSelectionFeatureTypeStyle(mapLayer.getStyle());
1213    
1214                    Style newStyleCleaned = StylingUtil
1215                                    .removeSelectionFeatureTypeStyle(style2);
1216    
1217                    if (StylingUtil.isStyleDifferent(mapLayerStyleCleaned, newStyleCleaned)) {
1218    
1219                            // They are different when compared without SELECTION FTS!
1220    
1221                            // Now let's copy any SELECTION FTS to the now style
1222                            FeatureTypeStyle selectionFeatureTypeStyle = StylingUtil
1223                                            .getSelectionFeatureTypeStyle(mapLayer.getStyle());
1224                            if (selectionFeatureTypeStyle != null) {
1225                                    newStyleCleaned.featureTypeStyles().add(
1226                                                    selectionFeatureTypeStyle);
1227                                    // newStyleCleaned is not so clean anymore... We just alled a
1228                                    // selcetion FTS
1229                            }
1230    
1231                            mapLayer.setStyle(newStyleCleaned);
1232    
1233                            return true;
1234    
1235                          box.add(hbox);                  } else {
1236                            return false;
1237                  }                  }
1238            }
1239    
1240            /**
1241             * After loading an atlas, the AttribteMetaData contains whatever is written
1242             * in the XML. But the DBF may have changed! This method checks an
1243             * {@link AttributeMetadataMap} against a schema and also corrects
1244             * upperCase/lowerCase problems. It will also remove any geometry column
1245             * attribute metadata.
1246             */
1247            /**
1248             * After loading an atlas, the AttribteMetaData contains whatever is written
1249             * in the XML. But the DBF may have changed!
1250             */
1251            public static void checkAttribMetaData(
1252                            AttributeMetadataMap<AttributeMetadataImpl> attributeMetaDataMap,
1253                            SimpleFeatureType schema) {
1254    
1255                    if (schema == null)
1256                            throw new IllegalArgumentException("schmema may not be null!");
1257    
1258                    ArrayList<Name> willRemove = new ArrayList<Name>();
1259    
1260                  return box;                  // 1. Check.. all attributes in the atm should be in the schema as well.
1261                    // maybe correct some upperCase/loweCase stuff
1262    
1263                    for (AttributeMetadata atm : attributeMetaDataMap.values()) {
1264    
1265                            AttributeDescriptor foundDescr = schema
1266                                            .getDescriptor(atm.getName());
1267                            if (foundDescr == null) {
1268                                    Name bestMatch = FeatureUtil.findBestMatchingAttribute(schema,
1269                                                    atm.getLocalName());
1270                                    if (bestMatch == null)
1271                                            willRemove.add(atm.getName());
1272                                    else
1273                                            atm.setName(bestMatch);
1274                            } else if (foundDescr instanceof GeometryDescriptor) {
1275                                    // We don't want GeometryColumns in here
1276                                    willRemove.add(atm.getName());
1277                            }
1278                    }
1279    
1280                    // Remove the ones that were not findable in the schema
1281                    for (Name removeName : willRemove) {
1282                            if (attributeMetaDataMap.remove(removeName) == null) {
1283                                    LOGGER.warn("removing the AMData didn't work");
1284                            }
1285                    }
1286    
1287                    // 2. check... all attributes from the schema must have an ATM
1288                    for (AttributeDescriptor ad : schema.getAttributeDescriptors()) {
1289                            if (ad instanceof GeometryDescriptor)
1290                                    continue;
1291                            if (!attributeMetaDataMap.containsKey(ad.getName())) {
1292                                    attributeMetaDataMap.put(ad.getName(),
1293                                                    new AttributeMetadataImpl(ad, schema
1294                                                                    .getAttributeDescriptors().indexOf(ad),
1295                                                                    attributeMetaDataMap.getLanguages()));
1296                            }
1297                    }
1298          }          }
1299    
1300            /**
1301             * Checks every attribute name in the {@link AttributeMetadataMap} for its
1302             * binding type. It the type is textual, add the mrpty string as a NODATA
1303             * value.
1304             *
1305             * @param attributeMetaDataMap
1306             * @param schema
1307             */
1308            public static void addEmptyStringToAllTextualAttributes(
1309                            AttributeMetadataMap<? extends AttributeMetadata> attributeMetaDataMap,
1310                            SimpleFeatureType schema) {
1311    
1312                    for (Name name : attributeMetaDataMap.keySet()) {
1313                            if (String.class.isAssignableFrom(schema.getDescriptor(name)
1314                                            .getType().getBinding())) {
1315                                    attributeMetaDataMap.get(name).getNodataValues().add("");
1316                            }
1317                    }
1318            }
1319    
1320            /**
1321             * @return a nicely formatted String containing all NODATA values of any
1322             *         {@link AttributeMetadata} object. Strings are quoted so that any
1323             *         empty {@link String} can be seen.
1324             */
1325            public static String formatNoDataValues(Set<Object> nodataValuesList) {
1326                    String nicelyFormatted = "";
1327                    if (nodataValuesList != null) {
1328                            if (nodataValuesList.size() == 0)
1329                                    nicelyFormatted = "";
1330                            else {
1331                                    for (Object ndo : nodataValuesList) {
1332                                            if (ndo instanceof String)
1333                                                    nicelyFormatted += "\"" + ndo + "\"";
1334                                            else
1335                                                    nicelyFormatted += ndo.toString();
1336    
1337                                            nicelyFormatted += ",";
1338                                    }
1339                                    // Remove the extra comma
1340                                    nicelyFormatted = nicelyFormatted.substring(0, nicelyFormatted
1341                                                    .length() - 1);
1342                            }
1343                    }
1344                    return nicelyFormatted;
1345            }
1346  }  }
Legend:
Removed from v.400  
changed lines
  Added in v.769
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26