skrueger/geotools/StyledLayerUtil.java

/*******************************************************************************
 * Copyright (c) 2009 Martin O. J. Schmitz.
 * 
 * This file is part of the SCHMITZM library - a collection of utility 
 * classes based on Java 1.6, focusing (not only) on Java Swing 
 * and the Geotools library.
 * 
 * The SCHMITZM project is hosted at:
 * http://wald.intevation.org/projects/schmitzm/
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License (license.txt)
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 * or try this link: http://www.gnu.org/licenses/lgpl.html
 * 
 * Contributors:
 *     Martin O. J. Schmitz - initial API and implementation
 *     Stefan A. Krüger - additional utility classes
 ******************************************************************************/
package skrueger.geotools;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.ComponentColorModel;
import java.awt.image.DataBuffer;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.net.URL;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.swing.BorderFactory;
import javax.swing.ImageIcon;
import javax.swing.JComponent;
import javax.swing.JLabel;

import net.miginfocom.swing.MigLayout;

import org.apache.log4j.Logger;
import org.geotools.coverage.grid.GeneralGridEnvelope;
import org.geotools.coverage.grid.GridCoverage2D;
import org.geotools.coverage.grid.GridGeometry2D;
import org.geotools.coverage.grid.io.AbstractGridCoverage2DReader;
import org.geotools.coverage.grid.io.AbstractGridFormat;
import org.geotools.feature.FeatureCollection;
import org.geotools.feature.NameImpl;
import org.geotools.geometry.jts.ReferencedEnvelope;
import org.geotools.map.DefaultMapLayer;
import org.geotools.map.MapLayer;
import org.geotools.parameter.Parameter;
import org.geotools.renderer.lite.gridcoverage2d.GridCoverageRenderer;
import org.geotools.styling.ColorMap;
import org.geotools.styling.ColorMapEntry;
import org.geotools.styling.FeatureTypeStyle;
import org.geotools.styling.RasterSymbolizer;
import org.geotools.styling.Rule;
import org.geotools.styling.Style;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
import org.jdom.output.XMLOutputter;
import org.opengis.feature.simple.SimpleFeature;
import org.opengis.feature.simple.SimpleFeatureType;
import org.opengis.feature.type.AttributeDescriptor;
import org.opengis.feature.type.GeometryDescriptor;
import org.opengis.feature.type.Name;
import org.opengis.parameter.GeneralParameterValue;

import schmitzm.geotools.JTSUtil;
import schmitzm.geotools.feature.FeatureUtil;
import schmitzm.geotools.styling.StylingUtil;
import schmitzm.io.IOUtil;
import schmitzm.lang.LangUtil;
import schmitzm.swing.JPanel;
import schmitzm.swing.SwingUtil;
import skrueger.AttributeMetadata;
import skrueger.RasterLegendData;
import skrueger.i8n.Translation;

/**
 * This class provides static helper methods for dealing with
 * {@link StyledLayerInterface} stuff.
 * 
 * @author <a href="mailto:[email protected]">Martin Schmitz</a>
 *         (University of Bonn/Germany)
 * @version 1.0
 */
public class StyledLayerUtil {
        private static final Logger LOGGER = Logger.getLogger(StyledLayerUtil.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 StyledLayerInterface} 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(final Object object) throws Exception {
                return createMapLayer(object, null);
        }

        /**
         * Creates a Geotools {@link MapLayer} from an object. If the object is a
         * {@link StyledLayerInterface} 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, final Style forcedStyle)
                        throws Exception {
                MapLayer layer = null;
                Style style = null;
                if (object instanceof StyledLayerInterface) {
                        style = ((StyledLayerInterface<?>) object).getStyle();
                        object = ((StyledLayerInterface<?>) 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 StyledLayerInterface} 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 StyledLayerInterface<?> createStyledLayer(
                        final Object object, final String title) {
                return createStyledLayer(object, title, null);
        }

        /**
         * Creates an default instance of {@link StyledLayerInterface} 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 StyledLayerInterface<?> createStyledLayer(
                        final Object object, final String title,
                        final StyledLayerStyle style) {
                StyledLayerInterface<?> styledLayer = null;

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

                if (object instanceof GridCoverage2D)
                        styledLayer = new StyledGridCoverage((GridCoverage2D) object, id,
                                        title, style);
                else if (object instanceof AbstractGridCoverage2DReader)
                        styledLayer = new StyledGridCoverageReader(
                                        (AbstractGridCoverage2DReader) object, id, title, style);
                else if (object instanceof FeatureCollection)
                        styledLayer = new StyledFeatureCollection(
                                        (FeatureCollection) object, id, title, style);

                if (styledLayer == null)
                        throw new UnsupportedOperationException(
                                        "Can not create StyledLayerInterface object from "
                                                        + (object == null ? "null" : object.getClass()));

                return styledLayer;
        }

        /**
         * 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
         * 
         *            TODO replace with
         *            {@link AttributeMetadataMap#sortedValuesVisibleOnly()}
         */
        public static AttributeMetadataMap getVisibleAttributeMetaData(
                        final AttributeMetadataMap amdMap, final boolean visible) {

                final AttributeMetadataMap filteredMap = new AttributeMetadataMap(
                                amdMap.getLanguages());
                for (final AttributeMetadata amd : amdMap.values())
                        if (amd.isVisible() == visible)
                                filteredMap.put(amd.getName(), 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.
         * 
         * TODO 20.11.2009, SK: There are some new attribute weight, functiona,
         * functionX and nodata in AttributeMetaData that should be parsed/exported
         * too. but this method is only used by ISDSS, which is not supporting that
         * stuff anyways.
         * 
         * @param element
         *            {@link Element} to parse
         */
        public static AttributeMetadata parseAttributeMetaData(final Element element) {
                final String namespace = String.valueOf(element
                                .getAttributeValue("namespace"));
                final String localname = String.valueOf(element
                                .getAttributeValue("localname"));
                final Name aName = new NameImpl(namespace, localname);
                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(aName, visible, name, desc, unit);
        }

        /**
         * Parses a {@link AttributeMetadata} map from an JDOM-{@link Element} with
         * {@code <attribute>}-childs.
         * 
         * @param element
         *            {@link Element} to parse
         * 
         *            TODO Since GP 1.3 the {@link AttributeMetadata} class has more
         *            attributes which are not used by Xulu/ISDSS. GP
         *            exports/imports the AMD via AMLExporter and AMLImporter
         *            classes. (SK, 3.2.2010) *
         */
        public static AttributeMetadataMap parseAttributeMetaDataMap(
                        final Element element) {
                final AttributeMetadataMap metaData = new AttributeMetadataMap();
                final List<Element> attributesElements = element
                                .getChildren(ELEM_NAME_ATTRIBUTE);
                for (final Element attibuteElement : attributesElements) {
                        final AttributeMetadata attrMetaData = parseAttributeMetaData(attibuteElement);
                        metaData.put(attrMetaData.getName(), attrMetaData);
                }
                return metaData;
        }

        /**
         * Loads a {@link AttributeMetadata} object from an URL.
         * 
         * @param documentUrl
         *            {@link URL} to parse
         * @see #parseAttributeMetaData(Element)
         */
        public static AttributeMetadataMap loadAttributeMetaDataMap(
                        final URL documentUrl) throws Exception {
                final 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
         * 
         *            TODO Since GP 1.3 the {@link AttributeMetadata} class has more
         *            attributes which are not used by Xulu/ISDSS. GP
         *            exports/imports the AMD via AMLExporter and AMLImporter
         *            classes. (SK, 3.2.2010)
         */
        public static Element createAttributeMetaDataElement(
                        final AttributeMetadata amd) {
                final Element element = new Element(ELEM_NAME_ATTRIBUTE, AMLURI);
                element.setAttribute("namespace", String.valueOf(amd.getName()
                                .getNamespaceURI()));
                element.setAttribute("localname", String.valueOf(amd.getLocalName()));
                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 AttributeMetadataMap amdMap) {
                final Element element = new Element(ELEM_NAME_AMD, AMLURI);
                for (final 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 AttributeMetadataMap 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(final Element element) {

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

                final RasterLegendData rld = new RasterLegendData(paintGaps);

                for (final 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
                                final 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 {
                final 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 (final Double key : rld.getSortedKeys()) {
                        final 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(
                        final ColorMap colorMap, final boolean paintGaps,
                        final Integer digits) {
                final DecimalFormat decFormat = digits != null ? new DecimalFormat(
                                SwingUtil.getNumberFormatPattern(digits)) : null;
                final RasterLegendData rld = new RasterLegendData(paintGaps);
                for (final ColorMapEntry cme : colorMap.getColorMapEntries()) {
                        final 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(final Style style,
                        final boolean paintGaps, final Integer digits) {
                final 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) {
                final 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(final String tagname,
                        final Translation translation) {
                final 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 (final String lang : translation.keySet()) {
                        final 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 StyledLayerInterface}.
         * 
         * @param styledObject
         *            a styled object
         * @param style
         *            a Style
         */
        public static void setStyledLayerStyle(
                        final StyledLayerInterface styledObject,
                        final StyledLayerStyle<?> style) {
                // set SLD style
                styledObject.setStyle(style.getGeoObjectStyle());
                // set meta data
                if (styledObject instanceof StyledGridCoverageInterface
                                && (style.getMetaData() instanceof RasterLegendData || style
                                                .getMetaData() == null)) {
                        final RasterLegendData sourceRld = (RasterLegendData) style
                                        .getMetaData();
                        final 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)) {
                        final AttributeMetadataMap sourceAmd = (AttributeMetadataMap) style
                                        .getMetaData();
                        final AttributeMetadataMap 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 StyledLayerInterface} as a
         * {@link StyledLayerStyle}.
         * 
         * @param styledObject
         *            a styled object
         * @return {@code StyledLayerStyle<RasterLegendData>} for
         *         {@link StyledGridCoverageInterface} or {@code
         *         StyledLayerStyle<Map<Integer,AttributeMetaData>>} for
         *         {@link StyledFeatureCollectionInterface}
         */
        public static StyledLayerStyle<?> getStyledLayerStyle(
                        final StyledLayerInterface styledObject) {
                if (styledObject instanceof StyledGridCoverageInterface)
                        return getStyledLayerStyle((StyledGridCoverageInterface) styledObject);
                if (styledObject instanceof StyledFeatureCollectionInterface)
                        return getStyledLayerStyle((StyledFeatureCollectionInterface) styledObject);
                throw new UnsupportedOperationException(
                                "Unknown type of StyledLayerInterface: "
                                                + (styledObject == null ? null : styledObject
                                                                .getClass().getSimpleName()));
        }

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

        /**
         * Returns the style and attribute meta data of a
         * {@link StyledFeatureCollectionInterface} as a {@link StyledLayerStyle}.
         * 
         * @param styledFC
         *            a styled feature collection
         */
        public static StyledLayerStyle<AttributeMetadataMap> getStyledLayerStyle(
                        final StyledFeatureCollectionInterface styledFC) {
                return new StyledLayerStyle<AttributeMetadataMap>(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 StyledLayerStyle<RasterLegendData> loadStyledRasterStyle(
                        final URL geoObjectURL, final String sldExt, final String rldExt) {
                RasterLegendData metaData = null;
                Style sldStyle = null;
                try {
                        final Style[] styles = StylingUtil.loadSLD(IOUtil.changeUrlExt(
                                        geoObjectURL, sldExt));
                        // SLD must be present
                        if (styles == null || styles.length == 0)
                                return null;
                        sldStyle = styles[0];
                } catch (final Exception err) {
                        // SLD must be present
                        LangUtil.logDebugError(LOGGER, err);
                        return null;
                }

                try {
                        metaData = StyledLayerUtil.loadRasterLegendData(IOUtil
                                        .changeUrlExt(geoObjectURL, rldExt));
                } catch (final FileNotFoundException err) {
                        // ignore missing raster legend data
                } catch (final Exception err) {
                        // any other error during legend data creation leads to error
                        LangUtil.logDebugError(LOGGER, err);
                        return null;
                }
                return new StyledLayerStyle<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 StyledLayerStyle<RasterLegendData> loadStyledRasterStyle(
                        final 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 StyledLayerStyle<AttributeMetadataMap> loadStyledFeatureStyle(
                        final URL geoObjectURL, final String sldExt, final String rldExt) {
                AttributeMetadataMap metaData = null;
                Style sldStyle = null;
                try {
                        final Style[] styles = StylingUtil.loadSLD(IOUtil.changeUrlExt(
                                        geoObjectURL, sldExt));
                        // SLD must be present
                        if (styles == null || styles.length == 0)
                                return null;
                        sldStyle = styles[0];
                } catch (final Exception err) {
                        // SLD must be present
                        LangUtil.logDebugError(LOGGER, err);
                        return null;
                }

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

                return new StyledLayerStyle<AttributeMetadataMap>(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 StyledLayerStyle<AttributeMetadataMap> loadStyledFeatureStyle(
                        final 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 saveStyledLayerStyle(
                        final StyledLayerStyle<T> style, final URL geoObjectURL,
                        final String sldExt, final String mdExt) throws Exception {
                // Store the SLD
                final Style sldStyle = style.getGeoObjectStyle();
                if (sldStyle != null) {
                        StylingUtil.saveStyleToSLD(sldStyle, IOUtil.changeFileExt(new File(
                                        geoObjectURL.toURI()), sldExt));
                }

                // Store the meta data
                final 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((AttributeMetadataMap) 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 saveStyledLayerStyle(final StyledLayerStyle<?> style,
                        final URL geoObjectURL) throws Exception {
                if (style.getMetaData() instanceof RasterLegendData)
                        saveStyledLayerStyle(style, geoObjectURL, "sld", "rld");
                else
                        saveStyledLayerStyle(style, geoObjectURL, "sld", "amd");
        }

        /**
         * *If appended to the name of a rule, this rule shall not be shown in the
         * legend
         */
        public final static String HIDE_IN_LAYER_LEGEND_HINT = "HIDE_IN_LEGEND";

        /**
         * Creates a {@link JPanel} that shows a legend for a list of
         * {@link FeatureTypeStyle}s and a targeted featureType
         * 
         * @param featureType
         *            If this a legend for Point, Polygon or Line?
         * @param list
         *            The Styles to presented in this legend
         * 
         * @author <a href="mailto:[email protected]">Stefan Alfons
         *         Kr&uuml;ger</a>
         */
        public static JPanel createLegendPanel(Style style,
                        final SimpleFeatureType featureType, final int iconWidth,
                        final int iconHeight) {

                final List<FeatureTypeStyle> list = style.featureTypeStyles();

                final JPanel panel = new JPanel(new MigLayout("wrap 2", "[]:3:[]"));

                if (style == null) {
                        // No Style => no legend
                        return panel;
                }

                for (final FeatureTypeStyle ftStyle : list) {

                        // One child-node for every rule
                        final List<Rule> rules = ftStyle.rules();
                        for (final Rule rule : rules) {

                                // Check if this RULE shall actually appear in the legend
                                if (rule.getName() != null && rule.getName().endsWith(HIDE_IN_LAYER_LEGEND_HINT))
                                        continue;

                                /**
                                 * Let's not create a hbox for Rules that only contain
                                 * TextSymbolizers
                                 */
                                if (StylingUtil.getTextSymbolizers(rule.getSymbolizers())
                                                .size() == rule.getSymbolizers().length)
                                        continue;

                                final BufferedImage imageForRule = LegendIconFeatureRenderer
                                                .getInstance().createImageForRule(rule, featureType,
                                                                new Dimension(iconWidth, iconHeight));

                                final ImageIcon legendIcon = new ImageIcon(imageForRule);

                                final JLabel iconLabel = new JLabel(legendIcon);
                                panel.add(iconLabel, "sgx1");
                                // hbox.setAlignmentX(0f);
                                // hbox.add(iconLabel);
                                // hbox.add(Box.createHorizontalStrut(3));

                                final Translation labelT = new Translation();
                                labelT.fromOneLine(rule.getDescription().getTitle());
                                final JLabel classTitleLabel = new JLabel(labelT.toString());

                                panel.add(classTitleLabel, "sgx2");
                                classTitleLabel.setLabelFor(iconLabel);
                        }
                }

                return panel;
        }

        /**
         * Creates a {@link JComponent} that contains a legend for a given
         * rasterLayer and a given {@link Style}.
         * 
         * @param style
         *            if <code>null</code>, the default {@link Style} is extracetd
         *            from the {@link StyledRasterInterface}
         */
        public static JPanel createLegendPanel(
                        final StyledRasterInterface<?> styledRaster, Style style,
                        final int iconWidth, final int iconHeight) {

                // If no style is given, we use the default style for this layer
                if (style == null)
                        style = styledRaster.getStyle();

                /**
                 * Determine whether a Style is responsible for the coloring
                 */
                ColorModel colorModel = null;
                if (!isStyleable(styledRaster)
                                || (isStyleable(styledRaster) && style == null)) {
                        colorModel = getColorModel(styledRaster);
                }

                final RasterLegendData rasterLegendData = styledRaster
                                .getLegendMetaData();
                final List<Double> legendRasterValues = rasterLegendData
                                .getSortedKeys();
                final Map<Double, GridCoverage2D> sampleRasters = rasterLegendData
                                .createSampleRasters();

                final JPanel panel = new JPanel(new MigLayout("wrap 2, gapy 0"));

                for (final Double rValue : legendRasterValues) {

                        // final Dimension ICON_SIZE = new Dimension(iconWidth,
                        // new JLabel().getFontMetrics(new JLabel().getFont())
                        // .getHeight() > 5 ? new JLabel().getFontMetrics(
                        // new JLabel().getFont()).getHeight() : iconHeight);

                        // ****************************************************************************
                        // Create the actual icon
                        // ****************************************************************************
                        final BufferedImage buffImage = new BufferedImage(iconWidth,
                                        iconHeight, BufferedImage.TYPE_INT_ARGB);

                        final Graphics2D graphics = buffImage.createGraphics();

                        if (colorModel != null) {
                                // The colors come from the ColorModel!

                                try {
                                        Object inData = null;
                                        switch (colorModel.getTransferType()) {
                                        case DataBuffer.TYPE_BYTE:
                                                inData = new byte[] { rValue.byteValue() };
                                                break;
                                        case DataBuffer.TYPE_USHORT:
                                                inData = new short[] { rValue.shortValue() };
                                                break;
                                        case DataBuffer.TYPE_INT:
                                                inData = new int[] { rValue.intValue() };
                                                break;
                                        case DataBuffer.TYPE_SHORT:
                                                inData = new short[] { rValue.shortValue() };
                                                break;
                                        case DataBuffer.TYPE_FLOAT:
                                                inData = new float[] { rValue.floatValue() };
                                                break;
                                        case DataBuffer.TYPE_DOUBLE:
                                                inData = new double[] { rValue.doubleValue() };
                                                break;
                                        default:
                                                inData = rValue.intValue();
                                        }
                                        final Color color = new Color(colorModel.getRGB(inData));
                                        graphics.setBackground(color);
                                        graphics.setColor(color);
                                        graphics.fillRect(0, 0, iconWidth, iconHeight);
                                } catch (final Exception e) {
                                        LOGGER.info(
                                                        "Dann nehmen wir halt den GridCoverageRenderer", e);
                                        colorModel = null;
                                }
                        } else {
                                // The colors come from the Style

                                /**
                                 * The coverage contains only one value of value rValue
                                 */
                                final GridCoverage2D sampleCov = sampleRasters.get(rValue);
                                GridCoverageRenderer renderer;
                                try {
                                        renderer = new GridCoverageRenderer(sampleCov
                                                        .getCoordinateReferenceSystem(), JTSUtil
                                                        .createEnvelope(sampleCov.getEnvelope()),
                                                        new Rectangle(iconWidth, iconHeight),
                                                        (AffineTransform) null);
                                } catch (final Exception e1) {
                                        throw new RuntimeException(
                                                        "Creating a GridCoverageRenderer failed:", e1);
                                }

                                /**
                                 * Iterate over all FeatureTypeStyles.
                                 */
                                final List<RasterSymbolizer> rSymbols = StylingUtil
                                                .getRasterSymbolizers(style);

                                for (final RasterSymbolizer symbolizer : rSymbols) {
                                        try {
                                                renderer.paint(graphics, sampleCov, symbolizer);
                                        } catch (final Exception ee) {
                                                LOGGER.error("Unable to paint " + symbolizer
                                                                + " into the legend image", ee);
                                        }
                                }
                        }

                        final JLabel iconLabel = new JLabel(new ImageIcon(buffImage));
                        panel.add(iconLabel, "sgx1");

                        final Translation labelT = rasterLegendData.get(rValue);
                        final JLabel classTitleLabel = new JLabel(labelT.toString());
                        panel.add(classTitleLabel, "sgx2"
                                        + (rasterLegendData.isPaintGaps() ? ", gapy 0:0:0 5:5:5"
                                                        : ""));
                        classTitleLabel.setLabelFor(iconLabel);

                        if (rasterLegendData.isPaintGaps()) {
                                iconLabel
                                                .setBorder(BorderFactory.createLineBorder(Color.black));
                        }

                }

                return panel;
        }

        /**
         * Extracts the {@link ColorModel} of any {@link StyledRasterInterface}. May
         * return <code>null</code> if the geoobject can not be accessed.
         */
        @SuppressWarnings("unchecked")
        public static ColorModel getColorModel(
                        final StyledRasterInterface<?> styledGrid) {
                ColorModel colorModel = null;
                try {
                        final Object geoObject = styledGrid.getGeoObject();
                        if (geoObject instanceof GridCoverage2D) {
                                final GridCoverage2D cov = (GridCoverage2D) geoObject;
                                colorModel = cov.getRenderedImage().getColorModel();
                        } else if (styledGrid instanceof StyledRasterPyramidInterface) {

                                final Parameter readGG = new Parameter(
                                                AbstractGridFormat.READ_GRIDGEOMETRY2D);

                                final ReferencedEnvelope mapExtend = new org.geotools.geometry.jts.ReferencedEnvelope(
                                                styledGrid.getEnvelope(), styledGrid.getCrs());

                                readGG.setValue(new GridGeometry2D(new GeneralGridEnvelope(
                                                new Rectangle(0, 0, 1, 1)), mapExtend));

                                final FeatureCollection<SimpleFeatureType, SimpleFeature> rFc = (FeatureCollection<SimpleFeatureType, SimpleFeature>) geoObject;

                                final AbstractGridCoverage2DReader aReader = (AbstractGridCoverage2DReader) FeatureUtil
                                                .getWrappedGeoObject(rFc);
                                final GridCoverage2D cov = (GridCoverage2D) aReader
                                                .read(new GeneralParameterValue[] { readGG });
                                colorModel = cov.getRenderedImage().getColorModel();
                        }
                } catch (final Exception e) {
                        LOGGER.error("Error reading the colormodel from " + styledGrid, e);
                        return null;
                }
                return colorModel;
        }

        /**
         * @return <code>true</code> if a {@link RasterSymbolizer} can be applied
         *         and will have an effect. Some rasters (e.g. GeoTIFF) can come
         *         with their own {@link ColorModel} and will ignore any
         *         {@link RasterSymbolizer} = SLD.
         */
        public static boolean isStyleable(
                        final StyledRasterInterface<?> styledRaster) {
                final ColorModel colorModel = getColorModel(styledRaster);

                // LOGGER.info("The colormodel of " + styledRaster.getTitle() + " is "
                // + colorModel != null ? colorModel.getClass().getSimpleName() :
                // "NULL");

                if (colorModel == null)
                        return true;
                if (colorModel instanceof ComponentColorModel)
                        return true;
                return false;
        }

        /**
         * Set the given Style as the Style of the {@link MapLayer}, unless the
         * styles are the same (not comparing selection stuff). If the
         * {@link MapLayer}s {@link Style} is changed, the selection FTS is kept.<br/>
         * Remember {@link MapLayer#setStyle(Style)} triggers an event leading to a
         * repaint, so only use it when needed.
         * 
         * @return <code>true</code> if the {@link MapLayer}'s {@link Style} has
         *         been changed.
         */
        public static boolean updateMapLayerStyleIfChangedAndKeepSelection(
                        MapLayer mapLayer, Style style2) {

                Style mapLayerStyleCleaned = StylingUtil
                                .removeSelectionFeatureTypeStyle(mapLayer.getStyle());

                Style newStyleCleaned = StylingUtil
                                .removeSelectionFeatureTypeStyle(style2);

                if (StylingUtil.isStyleDifferent(mapLayerStyleCleaned, newStyleCleaned)) {

                        // They are different when compared without SELECTION FTS!

                        // Now let's copy any SELECTION FTS to the now style
                        FeatureTypeStyle selectionFeatureTypeStyle = StylingUtil
                                        .getSelectionFeatureTypeStyle(mapLayer.getStyle());
                        if (selectionFeatureTypeStyle != null) {
                                newStyleCleaned.featureTypeStyles().add(
                                                selectionFeatureTypeStyle);
                                // newStyleCleaned is not so clean anymore... We just alled a
                                // selcetion FTS
                        }

                        mapLayer.setStyle(newStyleCleaned);

                        return true;

                } else {
                        return false;
                }
        }

        /**
         * After loading an atlas, the AttribteMetaData contains whatever is written
         * in the XML. But the DBF may have changed! This method checks an
         * {@link AttributeMetadataMap} against a schema and also corrects
         * upperCase/lowerCase problems. It will also remove any geometry column
         * attribute metadata.
         */
        /**
         * After loading an atlas, the AttribteMetaData contains whatever is written
         * in the XML. But the DBF may have changed!
         */
        public static void checkAttribMetaData(
                        AttributeMetadataMap attributeMetaDataMap, SimpleFeatureType schema) {
                
                if (schema == null) throw new IllegalArgumentException("schmema may not be null!");

                ArrayList<Name> willRemove = new ArrayList<Name>();

                // 1. Check.. all attributes in the atm should be in the schema as well.
                // maybe correct some upperCase/loweCase stuff

                for (AttributeMetadata atm : attributeMetaDataMap.values()) {

                        AttributeDescriptor foundDescr = schema
                                        .getDescriptor(atm.getName());
                        if (foundDescr == null) {
                                Name bestMatch = FeatureUtil.findBestMatchingAttribute(schema,
                                                atm.getLocalName());
                                if (bestMatch == null)
                                        willRemove.add(atm.getName());
                                else
                                        atm.setName(bestMatch);
                        } else if (foundDescr instanceof GeometryDescriptor) {
                                // We don't want GeometryColumns in here
                                willRemove.add(atm.getName());
                        }
                }

                // Remove the ones that were not findable in the schema
                for (Name removeName : willRemove) {
                        if (attributeMetaDataMap.remove(removeName) == null) {
                                LOGGER.warn("removing the AMData didn't work");
                        }
                }

                // 2. check... all attributes from the schema must have an ATM
                for (AttributeDescriptor ad : schema.getAttributeDescriptors()) {
                        if (ad instanceof GeometryDescriptor)
                                continue;
                        if (!attributeMetaDataMap.containsKey(ad.getName())) {
                                attributeMetaDataMap.put(ad.getName(), new AttributeMetadata(
                                                ad, schema.getAttributeDescriptors().indexOf(ad),
                                                attributeMetaDataMap.getLanguages()));
                        }
                }
        }

        /**
         * Checks every attribute name in the {@link AttributeMetadataMap} for its
         * binding type. It the type is textual, add the mrpty string as a NODATA
         * value.
         * 
         * @param attributeMetaDataMap
         * @param schema
         */
        public static void addEmptyStringToAllTextualAttributes(
                        AttributeMetadataMap attributeMetaDataMap, SimpleFeatureType schema) {

                for (Name name : attributeMetaDataMap.keySet()) {
                        if (String.class.isAssignableFrom(schema.getDescriptor(name)
                                        .getType().getBinding())) {
                                attributeMetaDataMap.get(name).getNodataValues().add("");
                        }
                }
        }
}