skrueger/geotools/StyledMapUtil.java

package skrueger.geotools;

import java.text.DecimalFormat;
import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.SortedMap;
import java.util.TreeMap;
import java.net.URL;

import org.geotools.feature.FeatureCollection;
import org.geotools.map.MapLayer;
import org.geotools.map.DefaultMapLayer;
import org.geotools.coverage.grid.GridCoverage2D;
import org.geotools.coverage.grid.io.AbstractGridCoverage2DReader;
import org.geotools.data.FeatureSource;
import org.geotools.styling.ColorMap;
import org.geotools.styling.ColorMapEntry;
import org.geotools.styling.Style;

import org.apache.log4j.Logger;

import org.jdom.Element;
import org.jdom.Document;
import org.jdom.input.SAXBuilder;
import org.jdom.output.XMLOutputter;

import schmitzm.geotools.styling.StylingUtil;
import skrueger.AttributeMetaData;
import skrueger.RasterLegendData;
import skrueger.i8n.Translation;
import schmitzm.io.IOUtil;
import java.io.File;
import java.io.FileNotFoundException;
import schmitzm.lang.LangUtil;
import schmitzm.swing.SwingUtil;

import java.io.FileWriter;

/**
 * This class provides static helper methods for dealing with
 * {@link StyledMapInterface} stuff.
 * @author <a href="mailto:[email protected]">Martin Schmitz</a> (University of Bonn/Germany)
 * @version 1.0
 */
public class StyledMapUtil {
  private static final Logger LOGGER = Logger.getLogger(StyledMapUtil.class.getName());
  private static final SAXBuilder SAX_BUILDER = new SAXBuilder();
  private static final XMLOutputter XML_OUTPUTTER = new XMLOutputter();

  /** URL for Atlas XML schema */
  public static final String AMLURI = "http://www.wikisquare.de/AtlasML";
  /** Name of the XML Element for the attribute meta data map */
  public static final String ELEM_NAME_AMD = "attributeMetaData";
  /** Name of the XML Element for the raster legend data */
  public static final String ELEM_NAME_RLD = "rasterLegendData";
  /** Name of the XML Element for an attribute meta data map entry */
  public static final String ELEM_NAME_ATTRIBUTE = "dataAttribute";
  /** Name of the XML Element for an raster legend data entry */
  public static final String ELEM_NAME_RASTERLEGEND = "rasterLegendItem";
  /** Name of the XML Element for a translation */
  public static final String ELEM_NAME_TRANSLATION = "translation";

  /**
   * Creates a Geotools {@link MapLayer} from an object. If the object is a
   * {@link StyledMapInterface} then its sytle is used. In case of direct
   * Geotools objects ({@link GridCoverage2D}, {@link AbstractGridCoverage2DReader},
   * {@link FeatureCollection}) a default style is generated.
   * @param object an Object
   * @exception Exception if {@code null} is given as object or an error occurs during layer creation
   */
  public static MapLayer createMapLayer(Object object) throws Exception {
    return createMapLayer(object,null);
  }

  /**
   * Creates a Geotools {@link MapLayer} from an object. If the object is a
   * {@link StyledMapInterface} then its sytle is used. In case of direct
   * Geotools objects ({@link GridCoverage2D}, {@link AbstractGridCoverage2DReader},
   * {@link FeatureCollection}) a default style is generated.
   * @param object an Object
   * @param forcedStyle (SLD-)Style to force for the object
   * @exception Exception if {@code null} is given as object or an error occurs during layer creation
   */
  public static MapLayer createMapLayer(Object object, Style forcedStyle) throws Exception {
    MapLayer layer     = null;
    Style    style     = null;
    if ( object instanceof StyledMapInterface ) {
      style =  ((StyledMapInterface<?>)object).getStyle();
      object = ((StyledMapInterface<?>)object).getGeoObject();
    }
    if ( forcedStyle != null )
      style = forcedStyle;
    if ( style == null )
      style = StylingUtil.createDefaultStyle(object);

    if (object instanceof GridCoverage2D)
      layer = new DefaultMapLayer( (GridCoverage2D) object, style);
    if (object instanceof AbstractGridCoverage2DReader)
      layer = new DefaultMapLayer( (AbstractGridCoverage2DReader) object, style);
    if (object instanceof FeatureCollection)
      layer = new DefaultMapLayer( (FeatureCollection) object, style);

    if ( layer == null )
      throw new Exception("Can not create MapLayer from "+(object == null ? "null" : object.getClass()));

    return layer;
  }

  /**
   * Creates an default instance of {@link StyledMapInterface} for a Geotools
   * object ({@link GridCoverage2D}, {@link FeatureCollection}) with a default
   * style.
   * @param object an Object
   * @param title  title for the object
   * @exception UnsupportedOperationException if {@code null} is given as object or an error occurs during creation
   */
  public static StyledMapInterface<?> createStyledMap(Object object, String title) {
     return createStyledMap(object, title, null);
  }

  /**
   * Creates an default instance of {@link StyledMapInterface} for a Geotools
   * object ({@link GridCoverage2D}, {@link FeatureCollection}) with a given
   * style.
   * @param object an Object
   * @param title  title for the object
   * @param style  style and meta data for the object
   * @exception UnsupportedOperationException if {@code null} is given as object or an error occurs during creation
   */
  public static StyledMapInterface<?> createStyledMap(Object object, String title, StyledMapStyle style) {
    StyledMapInterface<?> styledObject = null;

    String id = (title != null) ? title : "defaultID";

    if ( object instanceof GridCoverage2D )
      styledObject = new StyledGridCoverage(
          (GridCoverage2D)object,
          id,
          title,
          style
      );
    else if ( object instanceof AbstractGridCoverage2DReader )
           styledObject = new StyledGridCoverageReader(
               (AbstractGridCoverage2DReader)object,
               id,
               title,
               style
           );
    else if ( object instanceof FeatureCollection )
      styledObject = new StyledFeatureCollection(
          (FeatureCollection)object,
          id,
          title,
          style
      );
    
    if ( styledObject == null )
      throw new UnsupportedOperationException("Can not create StyledMapInterface object from "+(object == null ? "null" : object.getClass()));

    return styledObject;
  }

  /**
   * Return only the visible or invisible entries of an AttributeMetaData-Map.
   * @param amdMap AttributeMetaData-Map
   * @param visible indicated whether the visible or invisible entries are
   *                returned 
   */
  public static SortedMap<Integer,AttributeMetaData> getVisibleAttributeMetaData(Map<Integer,AttributeMetaData> amdMap, boolean visible) {
    SortedMap<Integer,AttributeMetaData> filteredMap = new TreeMap<Integer,AttributeMetaData>();
    for (AttributeMetaData amd : amdMap.values())
      if ( amd.isVisible() )
        filteredMap.put(amd.getColIdx(), amd);
    
    return filteredMap;
  }
  
  
  /**
   * Parses a {@link AttributeMetaData} object from an JDOM-{@link Element}.
   * This method works like {@link AMLImport#parseDataAttribute(org.w3c.dom.Node},
   * but for JDOM.
   * @param element {@link Element} to parse
   */
  public static AttributeMetaData parseAttributeMetaData(final Element element) {
    final Integer col = Integer.valueOf(element.getAttributeValue("col"));
    final Boolean visible = Boolean.valueOf(element.getAttributeValue("visible"));
    final String unit = element.getAttributeValue("unit");

    Translation name = new Translation();
    Translation desc = new Translation();
    for (final Element childElement : (List<Element>)element.getChildren()) {
      if (childElement.getName() == null)
        continue;

      if (childElement.getName().equals("name"))
        name = parseTranslation(childElement);
      else if (childElement.getName().equals("desc"))
        desc = parseTranslation(childElement);
    }
    return new AttributeMetaData(col, visible, name, desc, unit);
  }

  /**
   * Parses a {@link AttributeMetaData} map from an JDOM-{@link Element}
   * with {@code <attribute>}-childs.
   * @param element {@link Element} to parse
   */
  public static Map<Integer,AttributeMetaData> parseAttributeMetaDataMap(final Element element) {
    HashMap<Integer,AttributeMetaData> metaData = new HashMap<Integer,AttributeMetaData>();
    List<Element> attributesElements = element.getChildren( ELEM_NAME_ATTRIBUTE );
    for (Element attibuteElement : attributesElements)
    {
      AttributeMetaData attrMetaData = parseAttributeMetaData( attibuteElement );
      metaData.put( attrMetaData.getColIdx(), attrMetaData );
    }
    return metaData;
  }

  /**
   * Loads a {@link AttributeMetaData} object from an URL.
   * @param documentUrl {@link URL} to parse
   * @see #parseAttributeMetaData(Element)
   */
  public static Map<Integer,AttributeMetaData> loadAttributeMetaDataMap(final URL documentUrl) throws Exception {
    Document document = SAX_BUILDER.build(documentUrl);
    return parseAttributeMetaDataMap( document.getRootElement() );
  }

  /**
   * Creates an JDOM {@link Element} for the given {@link AttributeMetaData}
   * object.
   * @param amd meta data for one attribute
   */
  public static Element createAttributeMetaDataElement(final AttributeMetaData amd) {
    final Element element = new Element( ELEM_NAME_ATTRIBUTE , AMLURI);
    element.setAttribute("col", String.valueOf( amd.getColIdx() ) );
    element.setAttribute("visible", String.valueOf( amd.isVisible() ) );
    element.setAttribute("unit", amd.getUnit() );
    // Creating a aml:name tag...
    element.addContent( createTranslationElement("name", amd.getTitle()) );
    // Creating a aml:desc tag...
    element.addContent( createTranslationElement("desc", amd.getDesc()) );
    return element;
  }

  /**
   * Creates an JDOM {@link Element} for the given {@link AttributeMetaData}
   * map.
   * @param amdMap map of attribute meta data
   */
  public static Element createAttributeMetaDataMapElement(final Map<Integer,AttributeMetaData> amdMap) {
    final Element element = new Element( ELEM_NAME_AMD , AMLURI);
    for (AttributeMetaData amd : amdMap.values())
      element.addContent( createAttributeMetaDataElement( amd ) );
    return element;
  }

  /**
   * Saves a {@link AttributeMetaData AttributeMetaData-Map} to an URL.
   * @param amdMap map of {@link AttributeMetaData}
   * @param documentUrl {@link URL} to store the XML
   */
  public static void saveAttributeMetaDataMap(final Map<Integer,AttributeMetaData> amdMap, final URL documentUrl) throws Exception {
    // Create XML-Document
    final FileWriter out = new FileWriter( new File(documentUrl.toURI()) );
    XML_OUTPUTTER.output(
      createAttributeMetaDataMapElement(amdMap),
      out
    );
    out.flush();
    out.close();
  }


  /**
   * Parses a {@link RasterLegendData} object from an JDOM-{@link Element}.
   * This method works like {@link AMLImport#parseRasterLegendData(org.w3c.dom.Node},
   * but for JDOM.
   * @param element {@link Element} to parse
   */
  public static RasterLegendData parseRasterLegendData(Element element) {

    final boolean paintGaps = Boolean.valueOf( element.getAttributeValue("paintGaps") );

    RasterLegendData rld = new RasterLegendData(paintGaps);

    for ( Element childElement : (List<Element>)element.getChildren() ) {
      final String name = childElement.getName();
      // Cancel if it's an attribute
      if ( childElement.getChildren().size() == 0 )
        continue;

      if (name.equals( ELEM_NAME_RASTERLEGEND )) {
        final String valueAttr = childElement.getAttributeValue("value");
        if ( valueAttr == null )
          throw new UnsupportedOperationException("Attribute 'value' missing for definition of <"+ELEM_NAME_RASTERLEGEND+">");
        final double value = Double.valueOf(valueAttr);

        // first and only item should be the label
        final Element labelElement = childElement.getChild("label");
        // id label element is missing, the translation is searched directly
        // as childs of the rasterLegendItem element
        Translation label = parseTranslation( labelElement != null ? labelElement : childElement );
        rld.put(value, label);
      }
    }

    return rld;
  }

  /**
   * Loads a {@link RasterLegendData} object from an URL.
   * @param documentUrl {@link URL} to parse
   * @see #parseAttributeMetaData(Element)
   */
  public static RasterLegendData loadRasterLegendData(final URL documentUrl) throws Exception {
    Document document = SAX_BUILDER.build(documentUrl);
    return parseRasterLegendData( document.getRootElement() );
  }

 /**
   * Creates an JDOM {@link Element} for the given {@link RasterLegendData}
   * map.
   * @param rld raster legend data
   */
  public static Element createRasterLegendDataElement(final RasterLegendData rld) {
    final Element element = new Element( ELEM_NAME_RLD , AMLURI);
    element.setAttribute("paintGaps", rld.isPaintGaps().toString());
    for (Double key : rld.getSortedKeys()) {
      Element item = new Element( ELEM_NAME_RASTERLEGEND, AMLURI);
      item.setAttribute("value", key.toString());
      item.addContent( createTranslationElement("label", rld.get(key)) );
      element.addContent(item);
    }
    return element;
  }

  /**
   * Creates {@link RasterLegendData} from a {@link ColorMap}.
   * @param colorMap  a color map
   * @param paintGaps indicated whether gaps are painted between the legend items 
   * @param digits    number of digits the grid value classes (and legend) are
   *                  rounded to (null means no round; >= 0 means digits after comma;
   *                  < 0 means digits before comma)    */
  public static RasterLegendData generateRasterLegendData(ColorMap colorMap, boolean paintGaps, Integer digits) {
    DecimalFormat    decFormat = digits != null ? new DecimalFormat( SwingUtil.getNumberFormatPattern(digits) ) : null;
    RasterLegendData rld       = new RasterLegendData(paintGaps);
    for (ColorMapEntry cme : colorMap.getColorMapEntries())
    {
      double value = StylingUtil.getQuantityFromColorMapEntry(cme);
      String label = cme.getLabel();
      // if no label is set (e.g. quantitative style),
      // use the value as label
      if ( label == null || label.equals("") )
        if ( digits == null )
          label = String.valueOf(value);
        else
          label = decFormat.format( LangUtil.round(value, digits) ); 
      rld.put( value, new Translation("   "+label) );
    }
    return rld;
  }

  /**
   * Creates {@link RasterLegendData} from the {@link ColorMap} of a style.
   * @param style     a raster style (must contain a  {@link RasterSymbolizer})
   * @param paintGaps indicated whether gaps are painted between the legend items 
   * @param digits    number of digits the grid value classes (and legend) are
   *                  rounded to (null means no round; >= 0 means digits after comma;
   *                  < 0 means digits before comma)    */
  public static RasterLegendData generateRasterLegendData(Style style, boolean paintGaps, Integer digits) {
    ColorMap colorMap = StylingUtil.getColorMapFromStyle(style);
    if ( colorMap == null)
      throw new IllegalArgumentException("Color map can not be determined from style!");
    return generateRasterLegendData(colorMap, paintGaps, digits);
  }

  /**
   * Saves a {@link RasterLegendData} to an URL.
   * @param rld raster legend data
   * @param documentUrl {@link URL} to store the XML
   */
  public static void saveRasterLegendData(final RasterLegendData rld, final URL documentUrl) throws Exception {
    // Create XML-Document
    final FileWriter out = new FileWriter( new File(documentUrl.toURI()) );
    XML_OUTPUTTER.output(
      createRasterLegendDataElement(rld),
      out
    );
    out.flush();
    out.close();
  }

  /**
   * Parses a {@link Translation} object from an JDOM-{@link Element}.
   * This method works like {@link AMLImport#parseTranslation(org.w3c.dom.Node},
   * but for JDOM.
   * @param element {@link Element} to parse
   */
  public final static Translation parseTranslation(final Element element) {
    Translation trans = new Translation();

    if (element == null)
     return trans;

    for (final Element translationElement : (List<Element>)element.getChildren()) {
      final String name = translationElement.getName();
      if (name == null)
        continue;

      // lang attribute
      String lang = translationElement.getAttributeValue("lang");
      // set the default, if no language code is set
      if ( lang == null )
        lang = Translation.DEFAULT_KEY;

      final String translationText = translationElement.getValue();
      if (translationText == null)
        trans.put(lang, "");
      else
        trans.put(lang, translationText);
    }

    // if no <translation> is given, the value of the node should
    // be used as a default translation
    if (trans.size() == 0)
      trans.put( Translation.DEFAULT_KEY, element.getValue() );
    //     trans = new Translation( ((List<Element>)element.getChildren()).get(0).getValue() );

    return trans;
  }

  /**
   * Creates an JDOM {@link Element} for the given {@link Translation}.
   * @param tagname Name of the Element
   * @param translation Translation to store in the Element
   */
  public final static Element createTranslationElement(String tagname, Translation translation) {
    Element element = new Element(tagname, AMLURI);
    if ( translation == null )
      throw new UnsupportedOperationException("Translation element can not be created from null!");

    // If only a default translation is set, the <translation lang="..">..</tranlation>
    // part is not used
    if (translation.keySet().size() == 1 && translation.get(Translation.DEFAULT_KEY) != null) {
      element.addContent( translation.get(Translation.DEFAULT_KEY) );
      return element;
    }

    // add a <translation lang="..">..</tranlation> part to the element for
    // all languages
    for (String lang : translation.keySet()) {
      Element translationElement = new Element( ELEM_NAME_TRANSLATION , AMLURI);
      translationElement.setAttribute("lang", lang);
      String translationString = translation.get(lang);
      if (translationString == null)
       translationString = "";
      translationElement.addContent( translationString );
      element.addContent(translationElement);
    }

    return element;
  }


  /**
   * Sets a style to {@link StyledMapInterface}.
   * @param styledObject a styled object
   * @param style a Style
   */
  public static void setStyledMapStyle(StyledMapInterface styledObject, StyledMapStyle<?> style) {
    // set SLD style
    styledObject.setStyle( style.getGeoObjectStyle() );
    // set meta data
    if ( styledObject        instanceof StyledGridCoverageInterface &&
         (style.getMetaData() instanceof RasterLegendData || style.getMetaData() == null) ) {
      RasterLegendData sourceRld = (RasterLegendData)style.getMetaData();
      RasterLegendData destRld = ((StyledGridCoverageInterface)styledObject).getLegendMetaData();
      if ( destRld != null && sourceRld != null ) {
        destRld.setPaintGaps(sourceRld.isPaintGaps());
        destRld.clear();
        destRld.putAll( sourceRld );
      }
      return;
    }
    if ( styledObject        instanceof StyledFeatureCollectionInterface &&
         (style.getMetaData() instanceof Map || style.getMetaData() == null) ) {
      Map<Integer, AttributeMetaData> sourceAmd = (Map<Integer, AttributeMetaData>)style.getMetaData();
      Map<Integer, AttributeMetaData> destAmd   = ((StyledFeatureCollectionInterface)styledObject).getAttributeMetaDataMap();
      if ( destAmd != null && sourceAmd != null ) {
        destAmd.clear();
        destAmd.putAll( sourceAmd );
      }
      return;
    }

    throw new UnsupportedOperationException("Style is not compatible to object: " +
                                            (style.getMetaData() == null ? null : style.getMetaData().getClass().getSimpleName()) +
                                            " <-> " +
                                            (styledObject == null ? null : styledObject.getClass().getSimpleName()));
  }

  /**
   * Returns the style a {@link StyledMapInterface} as a {@link StyledMapStyle}.
   * @param styledObject a styled object
   * @return {@code StyledMapStyle<RasterLegendData>} for {@link StyledGridCoverageInterface}
   *         or {@code StyledMapStyle<Map<Integer,AttributeMetaData>>} for
   *         {@link StyledFeatureCollectionInterface}
   */
  public static StyledMapStyle<?> getStyledMapStyle(StyledMapInterface styledObject) {
    if ( styledObject instanceof StyledGridCoverageInterface )
      return getStyledMapStyle( (StyledGridCoverageInterface)styledObject );
    if ( styledObject instanceof StyledFeatureCollectionInterface )
      return getStyledMapStyle( (StyledFeatureCollectionInterface)styledObject );
    throw new UnsupportedOperationException("Unknown type of StyledMapInterface: "+(styledObject == null ? null : styledObject.getClass().getSimpleName()));
  }

  /**
   * Returns the style and raster meta data of a {@link StyledGridCoverageInterface}
   * as a {@link StyledMapStyle}.
   * @param styledGC a styled grid coverage
   */
  public static StyledMapStyle<RasterLegendData> getStyledMapStyle(StyledGridCoverageInterface styledGC) {
    return new StyledMapStyle<RasterLegendData>(
      styledGC.getStyle(),
      styledGC.getLegendMetaData()
    );
  }

  /**
   * Returns the style and attribute meta data of a {@link StyledFeatureCollectionInterface}
   * as a {@link StyledMapStyle}.
   * @param styledFC a styled feature collection
   */
  public static StyledMapStyle<Map<Integer,AttributeMetaData>> getStyledMapStyle(StyledFeatureCollectionInterface styledFC) {
    return new StyledMapStyle<Map<Integer,AttributeMetaData>>(
      styledFC.getStyle(),
      styledFC.getAttributeMetaDataMap()
    );
  }

  /**
   * Loads a {@linkplain Style SLD-Style} and {@linkplain RasterLegendData Raster-LegendData}
   * for a given geo-object (raster) source. The SLD file must be present. A missing
   * raster legend-data file is tolerated.
   * @param geoObjectURL URL of the (already read) raster object
   * @param sldExt file extention for the SLD file
   * @param rldExt file extention for the raster legend-data file
   * @return {@code null} in case of any error
   */
  public static StyledMapStyle<RasterLegendData> loadStyledRasterStyle(URL geoObjectURL, String sldExt, String rldExt) {
    RasterLegendData metaData = null;
    Style sldStyle = null;
    try {
      Style[] styles = StylingUtil.loadSLD(IOUtil.changeUrlExt(geoObjectURL, sldExt));
      // SLD must be present
      if ( styles == null || styles.length == 0 )
        return null;
      sldStyle = styles[0];
    }
    catch (Exception err) {
      // SLD must be present
      LangUtil.logDebugError(LOGGER,err);
      return null;
    }

    try {
      metaData = StyledMapUtil.loadRasterLegendData( IOUtil.changeUrlExt(geoObjectURL,rldExt) );
    } catch (FileNotFoundException err) {
      // ignore missing raster legend data
    } catch (Exception err) {
      // any other error during legend data creation leads to error
      LangUtil.logDebugError(LOGGER,err);
      return null;
    }
    return new StyledMapStyle<RasterLegendData>(sldStyle, metaData);
  }

  /**
   * Loads a {@linkplain Style SLD-Style} from a {@code .sld} file and
   * {@linkplain RasterLegendData Raster-LegendData} from a {@code .rld} file
   * for a given geo-object (raster) source. The SLD file must be present. A missing
   * raster legend-data file is tolerated.
   * @param geoObjectURL URL of the (already read) raster object
   * @param sldExt file extention for the SLD file
   * @param rldExt file extention for the raster legend-data file
   * @return {@code null} in case of any error
   */
  public static StyledMapStyle<RasterLegendData> loadStyledRasterStyle(URL geoObjectURL) {
    return loadStyledRasterStyle(geoObjectURL, "sld", "rld");
  }

  /**
   * Loads a {@linkplain Style SLD-Style} and a {@linkplain AttributeMetaData AttributeMetaData-Map}
   * for a given geo-object (feature) source. The SLD file must be present. A missing
   * attribute meta-data file is tolerated.
   * @param geoObjectURL URL of the (already read) feature object
   * @param sldExt file extention for the SLD file
   * @param rldExt file extention for the raster legend-data file
   * @return {@code null} in case of any error
   */
  public static StyledMapStyle<Map<Integer,AttributeMetaData>> loadStyledFeatureStyle(URL geoObjectURL, String sldExt, String rldExt) {
    Map<Integer,AttributeMetaData> metaData = null;
    Style                          sldStyle = null;
    try {
      Style[] styles = StylingUtil.loadSLD(IOUtil.changeUrlExt(geoObjectURL, sldExt));
      // SLD must be present
      if ( styles == null || styles.length == 0 )
        return null;
      sldStyle = styles[0];
    } catch (Exception err) {
      // SLD must be present
      LangUtil.logDebugError(LOGGER,err);
      return null;
    }

    try {
      metaData = StyledMapUtil.loadAttributeMetaDataMap( IOUtil.changeUrlExt(geoObjectURL,rldExt) );
    } catch (FileNotFoundException err) {
      // ignore missing attribute meta data
    } catch (Exception err) {
      // any other error during meta data creation leads to error
      LangUtil.logDebugError(LOGGER,err);
      return null;
    }

    return new StyledMapStyle<Map<Integer,AttributeMetaData>>(sldStyle, metaData);
  }

  /**
   * Loads a {@linkplain Style SLD-Style} from a {@code .sld} file and
   * {@linkplain AttributeMetaData AttributeMetaData-Map} from a {@code .amd} file
   * for a given geo-object (feature) source. The SLD file must be present. A missing
   * attribute meta-data file is tolerated.
   * @param geoObjectURL URL of the (already read) feature object
   * @param sldExt file extention for the SLD file
   * @param rldExt file extention for the raster legend-data file
   * @return {@code null} in case of any error
   */
  public static StyledMapStyle<Map<Integer,AttributeMetaData>> loadStyledFeatureStyle(URL geoObjectURL) {
    return loadStyledFeatureStyle(geoObjectURL, "sld", "amd");
  }

  /**
   * Stores a {@linkplain Style SLD-Style} and {@linkplain RasterLegendData Raster-LegendData}
   * for a given geo-object (raster) source.
   * @param style  style to save
   * @param geoObjectURL URL of the raster object
   * @param sldExt file extention for the SLD file
   * @param mdExt file extention for the meta-data file
   */
  public static <T> void saveStyledMapStyle(StyledMapStyle<T> style, URL geoObjectURL, String sldExt, String mdExt) throws Exception {
    // Store the SLD
    Style sldStyle = style.getGeoObjectStyle();
    if ( sldStyle != null ) {
      StylingUtil.saveStyleToSLD(
         sldStyle,
         IOUtil.changeFileExt(
              new File(geoObjectURL.toURI()),
              sldExt
         )
      );
    }

    // Store the meta data
    T metaData = style.getMetaData();
    if ( metaData != null ) {
      if ( metaData instanceof RasterLegendData ) {
        saveRasterLegendData(
            (RasterLegendData)metaData,
            IOUtil.changeUrlExt(geoObjectURL,mdExt)
        );
//      } else if ( metaData instanceof Map<Integer,AttributeMetaData> ) { // LEIDER NICHT KOMPILIERBAR!!
      } else if ( metaData instanceof Map ) {
        saveAttributeMetaDataMap(
            (Map<Integer,AttributeMetaData>)metaData,
            IOUtil.changeUrlExt(geoObjectURL,mdExt)
        );
      } else
        throw new UnsupportedOperationException("Export for meta data not yet supported: "+metaData.getClass().getSimpleName());
    }
  }

  /**
   * Stores the {@linkplain Style SLD-Style} to a {@code .sld} file and
   * the meta data ({@link RasterLegendData} or {@link AttributeMetaData})
   * to a {@code .rld} or {@code .amd} file.
   * for a given geo-object source.
   * @param style  style to save
   * @param geoObjectURL URL of the (already read) raster object
   */
  public static void saveStyledMapStyle(StyledMapStyle<?> style, URL geoObjectURL) throws Exception {
    if ( style.getMetaData() instanceof RasterLegendData )
      saveStyledMapStyle(style,geoObjectURL, "sld", "rld");
    else
      saveStyledMapStyle(style,geoObjectURL, "sld", "amd");
  }

}