Application: gvSIG desktop » gvSIG raster

package org.gvsig.raster.lib.legend.impl.io;

import java.awt.Color;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.raster.lib.legend.api.RasterLegendLocator;

import org.gvsig.raster.lib.legend.api.RasterLegendManager;

import org.gvsig.raster.lib.legend.api.colortable.ColorTable;

import org.gvsig.raster.lib.legend.api.colortable.ColorTableIO;

import org.gvsig.raster.lib.legend.api.colortable.colortableclass.ColorTableClass;

import org.gvsig.raster.lib.legend.api.exceptions.ColorTableIOException;

import org.kxml2.io.KXmlParser;

import org.kxml2.io.KXmlSerializer;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.xmlpull.v1.XmlPullParserException;

/**

 * {@link ColorTableIO} to read and write gvSIG color tables.

 *

 * @author <a href="mailto:lmarques@disid.com">Lluis Marques</a>

 *

 */

public class gvSIGColorTableIO implements ColorTableIO {

    private static final Logger LOG = LoggerFactory.getLogger(gvSIGColorTableIO.class);

    public static final String NAME = "gvSIGColorTableIO";

    public static final String DESCRIPTION = "Color table IO to read and write gvSIG color tables";

    @Override

    public String getName() {

        return NAME;

    }

    @Override

    public String getDescription() {

        return DESCRIPTION;

    }

    @Override

    public ColorTable read(File file) throws ColorTableIOException {

        if (file.isDirectory()) {

            throw new IllegalArgumentException("File can not be a directory.");

        }

        if (!file.exists() || !file.canRead()) {

            throw new IllegalArgumentException("File does not exist or can be readed");

        }

        RasterLegendManager rasterLegendManager = RasterLegendLocator.getRasterLegendManager();

        ColorTable colorTable = rasterLegendManager.createColorTable();

        List<ColorTableClass> classes = new ArrayList<ColorTableClass>();

        KXmlParser parser = new KXmlParser();

        FileInputStream in = null;

        InputStreamReader reader = null;

        int tag = 0;

        try {

            in = new FileInputStream(file);

            reader = new InputStreamReader(in, "UTF8");

            parser.setInput(reader);

            tag = parser.nextTag();

            parser.require(KXmlParser.START_TAG, null, "ColorTable");

        } catch (FileNotFoundException e) {

            LOG.error(String.format("Can not find %1s file", file.getAbsolutePath()), e);

            throw new ColorTableIOException(e);

        } catch (XmlPullParserException e) {

            LOG.error("Can not parse XML", e);

            throw new ColorTableIOException(e);

        } catch (IOException e) {

            LOG.error("Can not go to next XML tag or there are errors setting require tag", e);

            throw new ColorTableIOException(e);

        }

        for (int i = 0; i < parser.getAttributeCount(); i++) {

            if (parser.getAttributeName(i).equals("name")) {

                colorTable.setName(parser.getAttributeValue(i));

                continue;

            } else if (parser.getAttributeName(i).equals("interpolated")) {

                colorTable.setInterpolated(Boolean.parseBoolean(parser.getAttributeValue(i)));

                continue;

            }

        }

        try {

            tag = parser.nextTag();

        } catch (XmlPullParserException | IOException e) {

            LOG.error("Can not go to next XML tag", e);

            throw new ColorTableIOException(e);

        }

        while (!((tag == KXmlParser.END_TAG) && (parser.getName().equals("ColorTable")))) {

            try {

                if (tag == KXmlParser.START_TAG) {

                    if (parser.getName().equals("Color")) {

                        ColorTableClass colorTableClass =

                            rasterLegendManager.createColorTableClass();

                        int a = 255;

                        for (int i = 0; i < parser.getAttributeCount(); i++) {

                            if (parser.getAttributeName(i).equals("value")) {

                                colorTableClass.setValue(Double.parseDouble((String) parser

                                    .getAttributeValue(i)));

                                ColorTableClass aux =

                                    getColorItem(classes,

                                        Double.parseDouble((String) parser.getAttributeValue(i)));

                                if (aux != null)

                                    a = aux.getColor().getAlpha();

                            }

                            if (parser.getAttributeName(i).equals("name")) {

                                colorTableClass.setName((String) parser.getAttributeValue(i));

                            }

                            if (parser.getAttributeName(i).equals("rgb")) {

                                String rgb = parser.getAttributeValue(i);

                                int r =

                                    Integer.valueOf(rgb.substring(0, rgb.indexOf(","))).intValue();

                                int g =

                                    Integer.valueOf(

                                        rgb.substring(rgb.indexOf(",") + 1, rgb.lastIndexOf(",")))

                                        .intValue();

                                int b =

                                    Integer.valueOf(

                                        rgb.substring(rgb.lastIndexOf(",") + 1, rgb.length()))

                                        .intValue();

                                colorTableClass.setColor(new Color(r, g, b, a));

                            }

                            if (parser.getAttributeName(i).equals("interpolated")) {

                                colorTableClass.setInterpolated(Double.parseDouble((String) parser

                                    .getAttributeValue(i)));

                            }

                        }

                        classes.add(colorTableClass);

                        continue;

                    }

                    if (parser.getName().equals("Alpha")) {

                        ColorTableClass colorItem = null;

                        for (int i = 0; i < parser.getAttributeCount(); i++) {

                            if (parser.getAttributeName(i).equals("value")) {

                                colorItem =

                                    getColorItem(classes,

                                        Double.parseDouble((String) parser.getAttributeValue(i)));

                            }

                            if (parser.getAttributeName(i).equals("alpha") && colorItem != null) {

                                int a = Integer.parseInt(parser.getAttributeValue(i));

                                colorItem.setColor(new Color(colorItem.getColor().getRed(),

                                    colorItem.getColor().getGreen(),

                                    colorItem.getColor().getBlue(), a));

                            }

                            if (parser.getAttributeName(i).equals("interpolated") && colorItem != null) {

                                colorItem.setInterpolated(Double.parseDouble((String) parser

                                    .getAttributeValue(i)));

                            }

                        }

                        classes.add(colorItem);

                        continue;

                    }

                }

            } finally {

                try {

                    tag = parser.nextTag();

                } catch (XmlPullParserException | IOException e) {

                    LOG.error("Can not go to next XML tag", e);

                    throw new ColorTableIOException(e);

                }

            }

        }

        try {

            reader.close();

        } catch (IOException e) {

            // Just notice but not throw an exception

            LOG.warn("Can not close input stream", e);

        }

        colorTable.setClasses(classes, false);

        return colorTable;

    }

    private ColorTableClass getColorItem(List<ColorTableClass> classes, double value) {

        for (int i = 0; i < classes.size(); i++) {

            if (classes.get(i).getValue() == value) {

                return classes.remove(i);

            }

        }

        return null;

    }

    @Override

    public void read(ColorTable colorTable, File file) throws ColorTableIOException {

        ColorTable tmpColorTable = this.read(file);

        colorTable.copyFrom(tmpColorTable);

    }

    @Override

    public void write(ColorTable colorTable, File file) throws ColorTableIOException {

        try {

            KXmlSerializer parserOutput = new KXmlSerializer();

            FileOutputStream out = new FileOutputStream(file);

            OutputStreamWriter writer = new OutputStreamWriter(out, "UTF8");

            parserOutput.setOutput(writer);

            parserOutput.startDocument("UTF-8", null);

            parserOutput.startTag(null, "ColorTable");

            parserOutput.attribute(null, "name", colorTable.getName());

            parserOutput.attribute(null, "interpolated", String.valueOf(colorTable.isInterpolated()));

            parserOutput.attribute(null, "version", "1.1");

            parserOutput.text("\n");

            List<ColorTableClass> classes = colorTable.getClasses();

            for (int i = 0; i < classes.size(); i++) {

                ColorTableClass colorItem = classes.get(i);

                parserOutput.startTag(null, "Color");

                parserOutput.attribute(null, "value", String.valueOf(colorItem.getValue()));

                if (colorItem.getName() != null)

                    parserOutput.attribute(null, "name", String.valueOf(colorItem.getName()));

                else

                    parserOutput.attribute(null, "name", "");

                Color color = colorItem.getColor();

                parserOutput

                    .attribute(

                        null,

                        "rgb",

                        String.valueOf(color.getRed() + "," + color.getGreen() + ","

                            + color.getBlue()));

                parserOutput.attribute(null, "interpolated",

                    String.valueOf(colorItem.getInterpolated()));

                parserOutput.endTag(null, "Color");

                parserOutput.text("\n");

            }

            for (int i = 0; i < classes.size(); i++) {

                ColorTableClass colorItem = classes.get(i);

                parserOutput.startTag(null, "Alpha");

                parserOutput.attribute(null, "value", String.valueOf(colorItem.getValue()));

                parserOutput.attribute(null, "alpha",

                    String.valueOf(colorItem.getColor().getAlpha()));

                parserOutput.attribute(null, "interpolated",

                    String.valueOf(colorItem.getInterpolated()));

                parserOutput.endTag(null, "Alpha");

                parserOutput.text("\n");

            }

            parserOutput.endTag(null, "ColorTable");

            parserOutput.text("\n");

            parserOutput.endDocument();

            writer.close();

        } catch (FileNotFoundException e) {

            LOG.error(String.format("Can not find %1s file", file.getAbsolutePath()), e);

            throw new ColorTableIOException(e);

        } catch (IOException e) {

            LOG.error("Error writting Color table to XML file", e);

            throw new ColorTableIOException(e);

        }

    }

}