Application: gvSIG desktop

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

import java.awt.Color;

import java.io.File;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

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

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

import org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretationNotification;

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

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

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

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

import org.gvsig.raster.lib.legend.impl.colorinterpretation.DefaultColorInterpretationNotification;

import org.gvsig.raster.lib.legend.impl.colortable.DefaultColorTableNotification;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.observer.Notification;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.impl.BaseWeakReferencingObservable;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

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

 *

 */

public class DefaultColorTable extends BaseWeakReferencingObservable implements ColorTable {

    /**

     * Persistence definition name

     */

    public static final String PERSISTENT_NAME = "ColorTablePersistent";

    /**

     * Description of persistence definition

     */

    public static final String PERSISTENT_DESCRIPTION = "Persistent definition of color table";

    private static final String NAME_PERSISTENCE_FIELD = "name";

    private static final String RANGE_PERSISTENCE_FIELD = "range";

    private static final String NAME_CLASS_PERSISTENCE_FIELD = "nameClass";

    private static final String CLASSES_PERSISTENCE_FIELD = "classes";

    private static final String PALETTE_BY_BAND_PERSISTENCE_FIELD = "paletteByBand";

    private static final String INTERPOLATED_PERSISTENCE_FIELD = "interpolated";

    private static final String ERROR_COLOR_PERSISTENCE_FIELD = "errorColor";

    /**

     * Default number of classes when {@link ColorTable} is created

     */

    private static final int defaultNumberOfClasses = 256;

    private List<ColorTableClass> classes;

    private String name;

    private boolean interpolated;

    private int errorColor = 8;

    private double[] classValues = null;

    private byte[][] paletteByBand = null;

    private String[] classNames = null;

    /**

     * Empty constructor

     */

    public DefaultColorTable() {

    }

    /**

     * Default constructor

     *

     * @param name

     *            Name of {@link ColorTable}

     * @param classes

     *            Classes of {@link ColorTable}

     * @param interpolated

     *            True if this {@link ColorTable} is interpolated

     */

    public DefaultColorTable(String name, List<ColorTableClass> classes, boolean interpolated) {

        if (isNamePath(name)) {

            throw new IllegalArgumentException("Name of Color table can not be a path");

        }

        this.name = name;

        this.classes = classes;

        this.interpolated = interpolated;

        observeClasses();

        reCalculateColorTable(false);

    }

    private void observeClasses() {

        for (ColorTableClass clazz : this.classes) {

            clazz.addObserver(this);

        }

    }

    private void stopObservingClasses() {

        for (ColorTableClass clazz : this.classes) {

            clazz.deleteObserver(this);

        }

    }

    private void applyPalette(List<ColorTableClass> colorItems) {

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

        classValues = new double[0];

        classNames = new String[0];

        if (colorItems.size() == 0) {

            return;

        }

        double min = colorItems.get(0).getValue();

        double max = colorItems.get(colorItems.size() - 1).getValue();

        if (min > max) {

            double aux = max;

            max = min;

            min = aux;

        }

        Color color = Color.white;

        Color colorOld = null;

        // Make parts, keeping each class in an array

        for (int i = 0; i < defaultNumberOfClasses; i++) {

            double value = min + ((i * (max - min)) / (defaultNumberOfClasses - 1));

            int pos = 0;

            for (int j = 1; j <= colorItems.size(); j++) {

                if (j < colorItems.size()) {

                    if (value < colorItems.get(j).getValue()) {

                        pos = j - 1;

                        break;

                    }

                } else {

                    pos = j - 1;

                    break;

                }

            }

            // Calculate palette color

            if (interpolated) {

                color = interpolatedColor(value, pos);

            } else {

                if ((pos + 1) < colorItems.size()) {

                    double min2 = colorItems.get(pos).getValue();

                    double max2 = colorItems.get(pos + 1).getValue();

                    if ((min2 + ((max2 - min2) * colorItems.get(pos + 1).getInterpolated() / 100)) < value) {

                        pos++;

                    }

                }

                color = colorItems.get(pos).getColor();

            }

            if (!isEqualColor(color, colorOld, 0)) {

                ColorTableClass colorItem = new DefaultColorTableClass();

                colorItem.setValue(value);

                colorItem.setColor(color);

                arrayColors.add(colorItem);

            }

            colorOld = color;

        }

        // Una vez tenemos una paleta de 256 colores o inferior, rellenamos

        // los siguientes valores para hacer busquedas rapidas.

        paletteByBand = new byte[arrayColors.size()][4];

        classValues = new double[arrayColors.size()];

        classNames = new String[arrayColors.size()];

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

            paletteByBand[i][0] = (byte) arrayColors.get(i).getColor().getRed();

            paletteByBand[i][1] = (byte) arrayColors.get(i).getColor().getGreen();

            paletteByBand[i][2] = (byte) arrayColors.get(i).getColor().getBlue();

            paletteByBand[i][3] = (byte) arrayColors.get(i).getColor().getAlpha();

            classValues[i] = arrayColors.get(i).getValue();

            classNames[i] = arrayColors.get(i).getName();

        }

    }

    private boolean canDelete(int first, int last) {

        if (first >= getClasses().size()) {

            return false;

        }

        if (last >= getClasses().size()) {

            return false;

        }

        ColorTableClass c1 = getClasses().get(first);

        ColorTableClass c2 = getClasses().get(last);

        for (int i = (first + 1); i < last; i++) {

            if (!isCorrectColor(c1, c2, getClasses().get(i))) {

                return false;

            }

        }

        return true;

    }

    @Override

    public void compressPalette() {

        removeDuplicatedValues();

        int size = -1;

        while (size != classes.size()) {

            int init = 0;

            int posMax = 2;

            size = classes.size();

            while (init < classes.size()) {

                if ((posMax < classes.size()) && canDelete(init, posMax)) {

                    posMax++;

                    continue;

                }

                if ((init + 2) < posMax) {

                    if (canDelete(init, posMax - 1)) {

                        for (int i = (posMax - 2); i > init; i--) {

                            if (i < classes.size()) {

                                classes.remove(i);

                            }

                        }

                    }

                }

                init++;

                posMax = init + 2;

            }

        }

    }

    @Override

    public void copyFrom(ColorTable colorTable) {

        RasterLegendManager rasterLegendManager = RasterLegendLocator.getRasterLegendManager();

        this.interpolated = colorTable.isInterpolated();

        this.name = colorTable.getName();

        List<ColorTableClass> clonedClasses = new ArrayList<ColorTableClass>(colorTable.getClasses().size());

        for (ColorTableClass colorTableClass : colorTable.getClasses()) {

            ColorTableClass clonedClass = rasterLegendManager.createColorTableClass(

                colorTableClass.getName(),

                colorTableClass.getValue(),

                colorTableClass.getInterpolated(),

                colorTableClass.getColor());

            clonedClasses.add(clonedClass);

        }

        setClasses(clonedClasses, false);

        this.notifyObservers(new DefaultColorTableNotification(ColorTableNotification.COPIED_FROM_COLOR_TABLE, new Object[] { colorTable }));

    }

    @Override

    public List<ColorTableClass> getClasses() {

        return this.classes;

    }

    @Override

    public String getName() {

        return this.name;

    }

    @Override

    public boolean hasAlpha() {

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

            ColorTableClass colorTableClass = classes.get(i);

            if (colorTableClass.getColor().getAlpha() != 255) {

                return true;

            }

        }

        return false;

    }

    private Color interpolatedColor(double value, int pos) {

        if (classes.size() <= 0) {

            return Color.black;

        }

        if ((pos + 1) == classes.size()) {

            return classes.get(pos).getColor();

        }

        if (value <= classes.get(0).getValue()) {

            return classes.get(0).getColor();

        }

        ColorTableClass item1 = classes.get(pos);

        ColorTableClass item2 = classes.get(pos + 1);

        double percValue =

            ((value - item1.getValue()) * 100) / (item2.getValue() - item1.getValue());

        Color halfColor =

            new Color((item2.getColor().getRed() + item1.getColor().getRed()) >> 1, (item2

                .getColor().getGreen() + item1.getColor().getGreen()) >> 1, (item2.getColor()

                .getBlue() + item1.getColor().getBlue()) >> 1, (item2.getColor().getAlpha() + item1

                .getColor().getAlpha()) >> 1);

        Color color1, color2;

        double perc1, perc2;

        if (percValue > item2.getInterpolated()) {

            color1 = halfColor;

            color2 = item2.getColor();

            perc1 = item2.getInterpolated();

            perc2 = 100;

        } else {

            color1 = item1.getColor();

            color2 = halfColor;

            perc1 = 0;

            perc2 = item2.getInterpolated();

        }

        double percNew = (percValue - perc1) / (perc2 - perc1);

        Color newColor =

            new Color(

                (int) (color1.getRed() + ((color2.getRed() - color1.getRed()) * percNew)) & 0xff,

                (int) (color1.getGreen() + ((color2.getGreen() - color1.getGreen()) * percNew)) & 0xff,

                (int) (color1.getBlue() + ((color2.getBlue() - color1.getBlue()) * percNew)) & 0xff,

                (int) (color1.getAlpha() + ((color2.getAlpha() - color1.getAlpha()) * percNew)) & 0xff);

        return newColor;

    }

    private boolean isCorrectColor(ColorTableClass c1, ColorTableClass c2, ColorTableClass c3) {

        if ((c3.getName() != null) && (c3.getName().length() > 0)) {

            return false;

        }

        if (c3.getInterpolated() != 50) {

            return false;

        }

        if (c2.getInterpolated() != 50) {

            return false;

        }

        double max = c2.getValue() - c1.getValue();

        int r =

            c1.getColor().getRed()

                + (int) (((c2.getColor().getRed() - c1.getColor().getRed()) * (c3.getValue() - c1

                    .getValue())) / max);

        int g =

            c1.getColor().getGreen()

                + (int) (((c2.getColor().getGreen() - c1.getColor().getGreen()) * (c3.getValue() - c1

                    .getValue())) / max);

        int b =

            c1.getColor().getBlue()

                + (int) (((c2.getColor().getBlue() - c1.getColor().getBlue()) * (c3.getValue() - c1

                    .getValue())) / max);

        int a =

            c1.getColor().getAlpha()

                + (int) (((c2.getColor().getAlpha() - c1.getColor().getAlpha()) * (c3.getValue() - c1

                    .getValue())) / max);

        Color aux = new Color(r & 0xff, g & 0xff, b & 0xff, a & 0xff);

        return isEqualColor(c3.getColor(), aux, errorColor);

    }

    private boolean isEqualColor(Color c1, Color c2, int error) {

        if ((c2 == null) && (c1 != null)) {

            return false;

        }

        if ((c1 == null) && (c2 != null)) {

            return false;

        }

        if (c2.getRed() < (c1.getRed() - error)) {

            return false;

        }

        if (c2.getGreen() < (c1.getGreen() - error)) {

            return false;

        }

        if (c2.getBlue() < (c1.getBlue() - error)) {

            return false;

        }

        if (c2.getAlpha() < (c1.getAlpha() - error)) {

            return false;

        }

        if (c2.getRed() > (c1.getRed() + error)) {

            return false;

        }

        if (c2.getGreen() > (c1.getGreen() + error)) {

            return false;

        }

        if (c2.getBlue() > (c1.getBlue() + error)) {

            return false;

        }

        if (c2.getAlpha() > (c1.getAlpha() + error)) {

            return false;

        }

        return true;

    }

    @Override

    public boolean isInterpolated() {

        return interpolated;

    }

    @Override

    @SuppressWarnings("unchecked")

    public void loadFromState(PersistentState state) throws PersistenceException {

        interpolated = state.getBoolean(INTERPOLATED_PERSISTENCE_FIELD);

        errorColor = state.getInt(ERROR_COLOR_PERSISTENCE_FIELD);

        name = state.getString(NAME_PERSISTENCE_FIELD);

        List<Double> range = state.getList(RANGE_PERSISTENCE_FIELD);

        this.classValues = new double[range.size()];

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

            this.classValues[i] = range.get(i);

        }

        List<String> nameClass = state.getList(NAME_CLASS_PERSISTENCE_FIELD);

        if (nameClass != null) {

            this.classNames = new String[nameClass.size()];

            nameClass.toArray(this.classNames);

        }

        List<ColorTableClass> colorItems = state.getList(CLASSES_PERSISTENCE_FIELD);

        if (colorItems != null) {

            this.classes = new ArrayList<ColorTableClass>();

            this.classes.addAll(colorItems);

        }

        List<String> aux = state.getList(PALETTE_BY_BAND_PERSISTENCE_FIELD);

        if (aux != null) {

            this.paletteByBand = null;

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

                String[] values = aux.get(i).split("#");

                if (paletteByBand == null) {

                    if (values.length == 3) {

                        this.paletteByBand = new byte[aux.size()][3];

                    }

                    if (values.length == 4) {

                        this.paletteByBand = new byte[aux.size()][4];

                    }

                }

                paletteByBand[i][0] = Byte.valueOf(values[0]).byteValue();

                paletteByBand[i][1] = Byte.valueOf(values[1]).byteValue();

                paletteByBand[i][2] = Byte.valueOf(values[2]).byteValue();

                if (values.length == 4) {

                    paletteByBand[i][3] = Byte.valueOf(values[3]).byteValue();

                }

            }

        }

    }

    private void reCalculateColorTable(boolean compress) {

        // Sort classes

        Collections.sort(this.classes);

        // Compress palette

        if (compress) {

            compressPalette();

        }

        // Calculate and apply palette

        applyPalette(classes);

        // Remove duplicated values

        removeDuplicatedValues();

    }

    @Override

    public void removeDuplicatedValues() {

        for (int i = classes.size() - 2; i >= 0; i--) {

            if ((i + 1) >= classes.size()) {

                continue;

            }

            ColorTableClass nextColorTableClass = classes.get(i + 1);

            ColorTableClass colorTableClass = classes.get(i);

            // If value is different, don't remove it

            if (nextColorTableClass.getValue() != colorTableClass.getValue()) {

                continue;

            }

            // If color is different, don't remove it

            if (!nextColorTableClass.getColor().equals(colorTableClass.getColor())) {

                continue;

            }

            // If class does not have name, remove it

            if (StringUtils.isBlank(nextColorTableClass.getName())) {

                classes.remove(i + 1);

                continue;

            }

            if (StringUtils.isBlank(colorTableClass.getName())) {

                classes.remove(i);

                continue;

            }

            // Remove class if class name is equals

            if (nextColorTableClass.getName().equals(colorTableClass.getName())) {

                classes.remove(i);

                continue;

            }

        }

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set(INTERPOLATED_PERSISTENCE_FIELD, interpolated);

        state.set(ERROR_COLOR_PERSISTENCE_FIELD, errorColor);

        state.set(NAME_PERSISTENCE_FIELD, name);

        state.set(RANGE_PERSISTENCE_FIELD, classValues);

        state.set(NAME_CLASS_PERSISTENCE_FIELD, classNames);

        state.set(CLASSES_PERSISTENCE_FIELD, classes);

        ArrayList<String> list = new ArrayList<String>();

        if (paletteByBand != null) {

            String entry = null;

            for (int i = 0; i < paletteByBand.length; i++) {

                entry = paletteByBand[i][0] + "#" + paletteByBand[i][1] + "#" + paletteByBand[i][2];

                if (paletteByBand[0].length > 3) {

                    entry += "#" + paletteByBand[i][3];

                }

                list.add(entry);

            }

            state.set(PALETTE_BY_BAND_PERSISTENCE_FIELD, list);

        } else {

            state.setNull(PALETTE_BY_BAND_PERSISTENCE_FIELD);

        }

    }

    @Override

    public void setClasses(List<ColorTableClass> colorTableClasses, boolean compress) {

        if(this.classes!=null){

            stopObservingClasses();

        }

        this.classes = colorTableClasses;

        observeClasses();

        reCalculateColorTable(compress);

        this.notifyObservers(new DefaultColorTableNotification(ColorTableNotification.SETTED_CLASS_VALUES_COLOR_TABLE, new Object[] { colorTableClasses }));

    }

    @Override

    public void setClasses(double min, double max, boolean compress) {

        ColorTableClass colorTableClass;

        double max2 = Double.NEGATIVE_INFINITY;

        double min2 = Double.POSITIVE_INFINITY;

        if (min > max) {

            double aux = min;

            min = max;

            max = aux;

        }

        RasterLegendManager rasterLegendManager = RasterLegendLocator.getRasterLegendManager();

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

        List<ColorTableClass> items = this.getClasses();

        // Actualizamos el maximo y minimo del array

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

            colorTableClass = items.get(i);

            if (colorTableClass.getValue() > max2) {

                max2 = colorTableClass.getValue();

            }

            if (colorTableClass.getValue() < min2) {

                min2 = colorTableClass.getValue();

            }

        }

        // A?adir el minimo

        if (items.size() > 0) {

            colorTableClass = items.get(0);

        } else {

            colorTableClass = rasterLegendManager.createColorTableClass();

            colorTableClass.setValue(0);

            colorTableClass.setColor(Color.black);

        }

        arrayList.add(colorTableClass);

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

            colorTableClass = items.get(i);

            colorTableClass.setValue(min

                + (((colorTableClass.getValue() - min2) * (max - min)) / (max2 - min2)));

            arrayList.add(colorTableClass);

        }

        // A?adir el maximo

        if (items.size() > 0) {

            colorTableClass = items.get(items.size() - 1);

        } else {

            colorTableClass = rasterLegendManager.createColorTableClass();

            colorTableClass.setValue(255);

            colorTableClass.setColor(Color.white);

        }

        arrayList.add(colorTableClass);

        setClasses(arrayList, compress);

    }

    @Override

    public void setInterpolated(boolean flag) {

        boolean oldInterpolated = this.interpolated;

        this.interpolated = flag;

        if(this.classes!=null){

            reCalculateColorTable(false);

        }

        this.notifyObservers(new DefaultColorTableNotification(ColorTableNotification.CHANGED_INTERPOLATED_COLOR_TABLE, new Object[] { new Boolean(oldInterpolated), new Boolean(this.interpolated) }));

    }

    @Override

    public void setName(String name) {

        if (isNamePath(name)) {

            throw new IllegalArgumentException("Name of Color table can not be a path");

        }

        this.name = name;

        this.notifyObservers(new DefaultColorTableNotification(ColorTableNotification.RENAMED_COLOR_TABLE, new Object[] { name }));

    }

    public static void registerPersistence() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        DynStruct definition = manager.getDefinition(PERSISTENT_NAME);

        if (definition == null) {

            definition =

                manager.addDefinition(DefaultColorTable.class, PERSISTENT_NAME,

                    PERSISTENT_DESCRIPTION, null, null);

            definition.addDynFieldBoolean(INTERPOLATED_PERSISTENCE_FIELD).setMandatory(true);

            definition.addDynFieldInt(ERROR_COLOR_PERSISTENCE_FIELD).setMandatory(false);

            definition.addDynFieldString(NAME_PERSISTENCE_FIELD).setMandatory(false);

            definition.addDynFieldList(RANGE_PERSISTENCE_FIELD).setClassOfItems(Double.class)

                .setMandatory(false);

            definition.addDynFieldList(NAME_CLASS_PERSISTENCE_FIELD).setClassOfItems(String.class)

                .setMandatory(false);

            definition.addDynFieldList(CLASSES_PERSISTENCE_FIELD)

                .setClassOfItems(ColorTableClass.class).setMandatory(false);

            definition.addDynFieldList(PALETTE_BY_BAND_PERSISTENCE_FIELD)

                .setClassOfItems(String.class).setMandatory(false);

        }

    }

    private boolean isNamePath(String name) {

        if(name.contains(File.pathSeparator) || name.contains(".")){

            return true;

        }

        return false;

    }

    @Override

    public byte[] getRGBA(Object value) {

        Number number = null;

        if (value instanceof Number) {

            number = (Number) value;

            for (int i = 1; i <= classValues.length; i++) {

                if (i < classValues.length) {

                    if (number.doubleValue() < classValues[i]){

                        return paletteByBand[i - 1].clone();

                    }

                } else {

                    return paletteByBand[i - 1].clone();

                }

            }

            return new byte[4];

        }

        throw new IllegalArgumentException("Value has to be a number");

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        ColorTable cloned = (ColorTable) super.clone();

        cloned.copyFrom(this);

        return cloned;

    }

    @Override

    public void update(Observable observable, Object notification) {

        //FIXME:

        if (notification instanceof ColorTableClassNotification && observable instanceof ColorTableClass) {

            Notification colorTableClassNotification = (Notification) notification;

            if (colorTableClassNotification.getType().equals(ColorTableClassNotification.SETTED_COLOR)

                || colorTableClassNotification.getType().equals(ColorTableClassNotification.SETTED_INTERPOLATED)

                || colorTableClassNotification.getType().equals(ColorTableClassNotification.SETTED_NAME)

                || colorTableClassNotification.getType().equals(ColorTableClassNotification.SETTED_VALUE)) {

                this.notifyObservers(new DefaultColorTableNotification(ColorTableNotification.SETTED_CLASS_VALUES_COLOR_TABLE,

                    new Object[] { observable }));

            }

        }

    }

}