Application: gvSIG desktop

org.gvsig.fmap.mapcontext.layers.order.impl.BasicLayerOrderLibrary

org.gvsig.fmap.mapcontext.raster.impl.MapContextRasterLibrary

_Raster_at_bottom_then_polygons_lines_points=Capas de im?genes en el fondo, despu?s pol?gonos, l?neas y puntos

_Raster_Polygon_Line_Point_order_manager=Orden Im?genes-Pol?gonos-L?neas-Puntos

_Default_order=Orden por defecto

_Layers_are_placed_always_on_top=Las capas se colocan siempre sobre las existentes

_Raster_at_bottom_then_polygons_lines_points=Raster layers at bottom, then polygon, linear and point layers

_Raster_Polygon_Line_Point_order_manager=Raster-Polygon-Line-Point order

_Default_order=Default order

_Layers_are_placed_always_on_top=Layers are placed always on top

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="CMYKToRGBOperationParameters">

       <extends>

      </extends>

      <description>CMYKToRGBOperationParameters</description>

      <fields>

        <field name="color_interpretation" type="object" mandatory="true" group="Basic" classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation" hidden="true">

          <description></description>

          <tags>

            <valueItem name="lookupParameter" value="output_color_interpretation" />

          </tags>

          <description></description>

        </field>

        <field name="copy_unprocessed_bands" type="boolean" mandatory="false"

          defaultValue="true" group="Basic">

          <description>Marked if it must copy the unprocessed bands</description>

        </field>

        <field name="output_color_interpretation" type="object" mandatory="false" group="Basic"

          classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation"

          hidden="true">

          <description></description>

        </field>      </fields>

    </class>

  </classes>

</definitions>

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="RGBToCMYKOperationParameters">

       <extends>

      </extends>

      <description>RGBToCMYKOperationParameters</description>

      <fields>

        <field name="color_interpretation" type="object" mandatory="true" group="Basic" classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation" hidden="true">

          <description></description>

          <tags>

            <valueItem name="lookupParameter" value="output_color_interpretation" />

          </tags>

          <description></description>

        </field>

        <field name="copy_unprocessed_bands" type="boolean" mandatory="false"

          defaultValue="true" group="Basic">

          <description>Marked if it must copy the unprocessed bands</description>

        </field>

        <field name="output_color_interpretation" type="object" mandatory="false" group="Basic"

          classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation"

          hidden="true">

          <description></description>

        </field>      </fields>

    </class>

  </classes>

</definitions>

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="HSLToRGBOperationParameters">

       <extends>

      </extends>

      <description>HSLToRGBOperationParameters</description>

      <fields>

        <field name="color_interpretation" type="object" mandatory="true" group="Basic" classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation" hidden="true">

          <description></description>

          <tags>

            <valueItem name="lookupParameter" value="output_color_interpretation" />

          </tags>

          <description></description>

        </field>

        <field name="copy_unprocessed_bands" type="boolean" mandatory="false"

          defaultValue="true" group="Basic">

          <description>Marked if it must copy the unprocessed bands</description>

        </field>

        <field name="output_color_interpretation" type="object" mandatory="false" group="Basic"

          classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation"

          hidden="true">

          <description></description>

        </field>

      </fields>

    </class>

  </classes>

</definitions>

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="RGBToHSLOperationParameters">

       <extends>

      </extends>

      <description>RGBToHSLOperationParameters</description>

      <fields>

        <field name="color_interpretation" type="object" mandatory="true" group="Basic" classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation" hidden="true">

          <description></description>

          <tags>

            <valueItem name="lookupParameter" value="output_color_interpretation" />

          </tags>

          <description></description>

        </field>

        <field name="copy_unprocessed_bands" type="boolean" mandatory="false"

          defaultValue="true" group="Basic">

          <description>Marked if it must copy the unprocessed bands</description>

        </field>

        <field name="output_color_interpretation" type="object" mandatory="false" group="Basic"

          classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation"

          hidden="true">

          <description></description>

        </field>

      </fields>

    </class>

  </classes>

</definitions>

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="EqualizationOperationParameters">

       <extends>

      </extends>

      <description>EqualizationOperationParameters</description>

      <fields>

        <field name="color_interpretation" type="object" mandatory="true"

          group="Basic"

          classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation"

          hidden="true">

          <description></description>

          <tags>

            <valueItem name="lookupParameter" value="output_color_interpretation" />

          </tags>

          <description></description>

        </field>

        <field name="statistics" type="object" mandatory="true" group="Basic" classOfValue="org.gvsig.raster.lib.buffer.api.statistics.Statistics" hidden="true">

          <description></description>

        </field>

        <field name="copy_unprocessed_bands" type="boolean" mandatory="false"

          defaultValue="true" group="Basic">

          <description>Marked if it must copy the unprocessed bands</description>

        </field>

        <field name="output_color_interpretation" type="object" mandatory="false" group="Basic"

          classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation"

          hidden="true">

          <description></description>

        </field>

      </fields>

    </class>

  </classes>

</definitions>

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="ColorTableOperationParameters">

       <extends>

      </extends>

      <description>ColorTableOperationParameters</description>

      <fields>

        <field name="color_interpretation" type="object" mandatory="true" group="Basic" classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation" hidden="true">

          <description></description>

          <tags>

            <valueItem name="lookupParameter" value="output_color_interpretation" />

          </tags>

          <description></description>

        </field>

        <field name="copy_unprocessed_bands" type="boolean" mandatory="false"

          defaultValue="true" group="Basic">

          <description>Marked if it must copy the unprocessed bands</description>

        </field>

        <field name="output_color_interpretation" type="object" mandatory="false" group="Basic"

          classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation"

          hidden="true">

          <description></description>

        </field>      </fields>

    </class>

  </classes>

</definitions>

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="BrightnessOperationParameters">

      <extends>

      </extends>

      <description>BrightnessOperationParameters</description>

      <fields>

        <field name="brightness" type="integer" mandatory="true" group="Basic"

          minValue="-255" maxValue="255" defaultValue="0">

          <description>Integer value [-255,255]</description>

        </field>

        <field name="color_interpretation" type="object" mandatory="true"

          group="Basic"

          classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation"

          hidden="true">

          <tags>

            <valueItem name="lookupParameter" value="output_color_interpretation" />

          </tags>

          <description></description>

        </field>

        <field name="copy_unprocessed_bands" type="boolean" mandatory="false"

          defaultValue="true" group="Basic">

          <description>Marked if it must copy the unprocessed bands</description>

        </field>

        <field name="output_color_interpretation" type="object" mandatory="false" group="Basic"

          classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation"

          hidden="true">

          <description></description>

        </field>

      </fields>

    </class>

  </classes>

</definitions>

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="GrayScaleOperationParameters">

       <extends>

      </extends>

      <description>GrayScaleOperationParameters</description>

      <fields>

        <field name="color_interpretation" type="object" mandatory="true" group="Basic" classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation" hidden="true">

          <description></description>

          <tags>

            <valueItem name="lookupParameter" value="output_color_interpretation" />

          </tags>

          <description></description>

        </field>

        <field name="copy_unprocessed_bands" type="boolean" mandatory="false"

          defaultValue="true" group="Basic">

          <description>Marked if it must copy the unprocessed bands</description>

        </field>

        <field name="output_color_interpretation" type="object" mandatory="false" group="Basic"

          classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation"

          hidden="true">

          <description></description>

        </field>

      </fields>

    </class>

  </classes>

</definitions>

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="ColorBalanceHSLOperationParameters">

       <extends>

      </extends>

      <description>ColorBalanceHSLOperationParameters</description>

      <fields>

        <field name="color_interpretation" type="object" mandatory="true" group="Basic" classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation" hidden="true">

          <description></description>

          <tags>

            <valueItem name="lookupParameter" value="output_color_interpretation" />

          </tags>

          <description></description>

        </field>

        <field name="hue" type="double" mandatory="true" group="Basic" minValue="-180" maxValue="180" defaultValue="0">

          <description>Double value [-180,180]</description>

        </field>

        <field name="lightness" type="double" mandatory="true" group="Basic" minValue="-100" maxValue="100" defaultValue="0">

          <description>Double value [-100,100]</description>

        </field>

        <field name="saturation" type="double" mandatory="true" group="Basic" minValue="-100" maxValue="100" defaultValue="0">

          <description>Double value [-100,100]</description>

        </field>

        <field name="copy_unprocessed_bands" type="boolean" mandatory="false"

          defaultValue="true" group="Basic">

          <description>Marked if it must copy the unprocessed bands</description>

        </field>

        <field name="output_color_interpretation" type="object" mandatory="false" group="Basic"

          classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation"

          hidden="true">

          <description></description>

        </field>

      </fields>

    </class>

  </classes>

</definitions>

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="ColorBalanceCMYOperationParameters">

       <extends>

      </extends>

      <description>ColorBalanceCMYOperationParameters</description>

      <fields>

        <field name="color_interpretation" type="object" mandatory="true" group="Basic" classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation" hidden="true">

          <description></description>

          <tags>

            <valueItem name="lookupParameter" value="output_color_interpretation" />

          </tags>

          <description></description>

        </field>

        <field name="cyan" type="integer" mandatory="true" group="Basic" minValue="0" maxValue="100" defaultValue="0">

          <description>Integer value [0,100]</description>

        </field>

        <field name="magenta" type="integer" mandatory="true" group="Basic" minValue="0" maxValue="100" defaultValue="0">

          <description>Integer value [0,100]</description>

        </field>

        <field name="yellow" type="integer" mandatory="true" group="Basic" minValue="0" maxValue="100" defaultValue="0">

          <description>Integer value [0,100]</description>

        </field>

        <field name="luminosity" type="boolean" mandatory="false" group="Basic" defaultValue="false">

          <description>Marked if it must respect the luminosity</description>

        </field>

        <field name="copy_unprocessed_bands" type="boolean" mandatory="false"

          defaultValue="true" group="Basic">

          <description>Marked if it must copy the unprocessed bands</description>

        </field>

        <field name="output_color_interpretation" type="object" mandatory="false" group="Basic"

          classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation"

          hidden="true">

          <description></description>

        </field>

      </fields>

    </class>

  </classes>

</definitions>

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="ContrastOperationParameters">

      <extends>

      </extends>

      <description>ContrastOperationParameters</description>

      <fields>

        <field name="contrast" type="integer" mandatory="true" group="Basic"

          minValue="-255" maxValue="255" defaultValue="0">

          <description>Integer value [-255,255]</description>

        </field>

        <field name="color_interpretation" type="object" mandatory="true"

          group="Basic"

          classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation"

          hidden="true">

          <description></description>

          <tags>

            <valueItem name="lookupParameter" value="output_color_interpretation" />

          </tags>

          <description></description>

        </field>

        <field name="copy_unprocessed_bands" type="boolean" mandatory="false"

          defaultValue="true" group="Basic">

          <description>Marked if it must copy the unprocessed bands</description>

        </field>

        <field name="output_color_interpretation" type="object" mandatory="false" group="Basic"

          classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation"

          hidden="true">

          <description></description>

        </field>

      </fields>

    </class>

  </classes>

</definitions>

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="PansharpeningOperationParameters">

       <extends>

      </extends>

      <description>PansharpeningOperationParameters</description>

      <fields>

        <field name="statistics" type="object" mandatory="true" group="Basic" classOfValue="org.gvsig.raster.lib.buffer.api.statistics.Statistics">

          <description></description>

          <tags>

            <valueItem name="lookupParameter" value="output_color_interpretation" />

          </tags>

          <description></description>

        </field>

        <field name="color_interpretation" type="object" mandatory="true" group="Basic" classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation" hidden="true">

          <description></description>

        </field>

        <!-- <field name="bands_to_process" type="List" typeOfItems="integer" mandatory="false" group="Basic">

          <description></description>

        </field> -->

      </fields>

    </class>

  </classes>

</definitions>

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="ColorBalanceRGBOperationParameters">

       <extends>

      </extends>

      <description>ColorBalanceRGBOperationParameters</description>

      <fields>

        <field name="color_interpretation" type="object" mandatory="true" group="Basic" classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation" hidden="true">

          <description></description>

          <tags>

            <valueItem name="lookupParameter" value="output_color_interpretation" />

          </tags>

          <description></description>

        </field>

        <field name="red" type="integer" mandatory="true" group="Basic" minValue="0" maxValue="100" defaultValue="50">

          <description>Integer value [-100,100]</description>

        </field>

        <field name="green" type="integer" mandatory="true" group="Basic" minValue="0" maxValue="100" defaultValue="50">

          <description>Integer value [-100,100]</description>

        </field>

        <field name="blue" type="integer" mandatory="true" group="Basic" minValue="0" maxValue="100" defaultValue="50">

          <description>Integer value [-100,100]</description>

        </field>

        <field name="luminosity" type="boolean" mandatory="false" group="Basic" defaultValue="false">

          <description>Marked if it must copy the unprocessed bands</description>

        </field>

        <field name="copy_unprocessed_bands" type="boolean" mandatory="false"

          defaultValue="true" group="Basic">

          <description>Marked if it must copy the unprocessed bands</description>

        </field>

        <field name="output_color_interpretation" type="object" mandatory="false" group="Basic"

          classOfValue="org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation"

          hidden="true">

          <description></description>

        </field>

      </fields>

    </class>

  </classes>

</definitions>

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

import java.util.List;

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

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.impl.colorinterpretation.DefaultColorInterpretationNotification;

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 DefaultColorInterpretation extends BaseWeakReferencingObservable implements ColorInterpretation {

    /**

     * Persistence definition name

     */

    public static final String PERSISTENCE_DEFINITION = "ColorInterpretationPersistence";

    /**

     * Persistence definition description

     */

    public static final String PERSISTENCE_DESCRIPTION =

        "Persistence color interpretation definition description";

    private static final String COLOR_INTERPRETATION_PERSISTENCE_FIELD = "colorInterpretation";

    private static final String COLOR_TABLE_PERSISTENCE_FIELD = "colorTable";

    private static final String PALETTE_BAND_PERSISTENCE_FIELD = "paletteBand";

    private String[] colorInterpretation = null;

    private ColorTable colorTable;

    private int paletteBand;

    /**

     * Empty constructor

     */

    public DefaultColorInterpretation() {

        this.colorInterpretation = new String[0];

        this.paletteBand = -1;

        this.colorTable = null;

    }

    /**

     *

     * @param bandColorInterpretations

     */

    public DefaultColorInterpretation(String[] bandColorInterpretations) {

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

            if (!isColorInterpretationValid(bandColorInterpretations[i])) {

                throw new IllegalArgumentException(String.format(

                    "%1s color interpretation is not valid", bandColorInterpretations[i]));

            }

        }

        this.colorInterpretation = new String[bandColorInterpretations.length];

        System.arraycopy(bandColorInterpretations, 0, this.colorInterpretation, 0,

            this.colorInterpretation.length);

        this.paletteBand = -1;

        this.colorTable = null;

    }

    /**

     * Constructor to initialize color interpretation with the number of bands.

     * It is necessary to indicate color interpretation of each band using

     * {@link ColorInterpretation#setColorInterpValue(int, String)}

     *

     * @param nBands

     *            Number of bands of this color interpretation

     */

    public DefaultColorInterpretation(int nBands) {

        this.colorInterpretation = new String[nBands];

        this.paletteBand = -1;

        this.colorTable = null;

    }

    /**

     * @param bandColorInterpretation

     */

    public DefaultColorInterpretation(String bandColorInterpretation) {

        this.paletteBand = -1;

        this.colorTable = null;

        if (bandColorInterpretation.equals(RGB)) {

            this.colorInterpretation = new String[] { RED_BAND, GREEN_BAND, BLUE_BAND };

        } else if (bandColorInterpretation.equals(BGR)) {

            this.colorInterpretation = new String[] { BLUE_BAND, GREEN_BAND, RED_BAND };

        } else if (bandColorInterpretation.equals(ARGB)) {

            this.colorInterpretation = new String[] { RED_BAND, GREEN_BAND, BLUE_BAND, ALPHA_BAND };

        } else if (bandColorInterpretation.equals(GRAYSCALE)) {

            this.colorInterpretation = new String[] { GRAY_BAND };

        }else if (bandColorInterpretation.equals(PALETTE)) {

            this.colorInterpretation = new String[] { PALETTE_BAND };

            this.paletteBand = 0;

        }else if (bandColorInterpretation.equals(HSL)) {

            this.colorInterpretation = new String[] { HUE_BAND, SATURATION_BAND, LIGHTNESS_BAND };

        }else if (bandColorInterpretation.equals(CMYK)) {

            this.colorInterpretation = new String[] { CYAN_BAND, MAGENTA_BAND, YELLOW_BAND, BLACK_BAND };

        }else if (bandColorInterpretation.equals(YCBCR)) {

            this.colorInterpretation = new String[] { YCBCR_Y_BAND, YCBCR_CB_BAND, YCBCR_CR_BAND };

        }

        if(this.colorInterpretation == null){

            throw new IllegalArgumentException(

                "Can not create color interpretation. Type is not recognised");

        }

    }

    @Override

    public void setColorInterpValue(int band, String value) {

        String[] oldColorInterpretation = new String[this.colorInterpretation.length];

        System.arraycopy(this.colorInterpretation, 0, oldColorInterpretation, 0, this.colorInterpretation.length);

        if (band < 0 || band >= this.colorInterpretation.length) {

            throw new IllegalArgumentException("Band is out of color interpretation bands");

        }

        if (!isColorInterpretationValid(value)) {

            throw new IllegalArgumentException(String.format("%1s is not valid", value));

        }

        this.colorInterpretation[band] = value;

        this.notifyObservers(new DefaultColorInterpretationNotification(ColorInterpretationNotification.CHANGED_COLOR_INTERPRETATION_VALUE,

            new Object[] { oldColorInterpretation, this.colorInterpretation }));

    }

    @Override

    public int length() {

        return this.colorInterpretation.length;

    }

    private boolean isColorInterpretationValid(String bandColorInterpretation) {

        if (bandColorInterpretation.equals(RED_BAND)

            || bandColorInterpretation.equals(GREEN_BAND)

            || bandColorInterpretation.equals(BLUE_BAND)

            || bandColorInterpretation.equals(GRAY_BAND)

            || bandColorInterpretation.equals(PALETTE_BAND)

            || bandColorInterpretation.equals(HUE_BAND)

            || bandColorInterpretation.equals(SATURATION_BAND)

            || bandColorInterpretation.equals(LIGHTNESS_BAND)

            || bandColorInterpretation.equals(CYAN_BAND)

            || bandColorInterpretation.equals(MAGENTA_BAND)

            || bandColorInterpretation.equals(YELLOW_BAND)

            || bandColorInterpretation.equals(BLACK_BAND)

            || bandColorInterpretation.equals(YCBCR_Y_BAND)

            || bandColorInterpretation.equals(YCBCR_CB_BAND)

            || bandColorInterpretation.equals(YCBCR_CR_BAND)

            || bandColorInterpretation.equals(UNDEFINED_BAND)

//            || colorInterpretation.equals(RED_BLUE_BAND)

//            || colorInterpretation.equals(RED_GREEN_BAND)

//            || colorInterpretation.equals(GREEN_BLUE_BAND)

            || bandColorInterpretation.equals(ALPHA_BAND)) {

            return true;

        }

        return false;

    }

    @Override

    public boolean hasInterpretation() {

        if (colorInterpretation == null) {

            return false;

        }

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

            if (colorInterpretation[i].equals(RED_BAND)

                || colorInterpretation[i].equals(GREEN_BAND)

                || colorInterpretation[i].equals(BLUE_BAND)

//                || colorInterpretation[i].equals(RED_GREEN_BAND)

//                || colorInterpretation[i].equals(RED_BLUE_BAND)

//                || colorInterpretation[i].equals(GREEN_BLUE_BAND)

                || colorInterpretation[i].equals(PALETTE_BAND)

                || colorInterpretation[i].equals(HUE_BAND)

                || colorInterpretation[i].equals(SATURATION_BAND)

                || colorInterpretation[i].equals(LIGHTNESS_BAND)

                || colorInterpretation[i].equals(CYAN_BAND)

                || colorInterpretation[i].equals(MAGENTA_BAND)

                || colorInterpretation[i].equals(YELLOW_BAND)

                || colorInterpretation[i].equals(BLACK_BAND)

                || colorInterpretation[i].equals(YCBCR_Y_BAND)

                || colorInterpretation[i].equals(YCBCR_CB_BAND)

                || colorInterpretation[i].equals(YCBCR_CR_BAND)

                || colorInterpretation[i].equals(GRAY_BAND)) {

                return true;

            }

        }

        return false;

    }

    @Override

    public boolean isBGR() {

        if (colorInterpretation != null) {

            if (colorInterpretation.length == 3 && colorInterpretation[0] == BLUE_BAND

                && colorInterpretation[1] == GREEN_BAND && colorInterpretation[2] == RED_BAND) {

                return true;

            }

        }

        return false;

    }

    @Override

    public boolean isRGB() {

        if (colorInterpretation != null) {

            if (colorInterpretation.length >= 3 && hasAnyBandWithThisColorInterpretation(RED_BAND)

                && hasAnyBandWithThisColorInterpretation(GREEN_BAND)

                && hasAnyBandWithThisColorInterpretation(BLUE_BAND)) {

                return true;

            }

        }

        return false;

    }

    @Override

    public boolean hasAnyRGBBand() {

        if (colorInterpretation != null) {

                boolean redFound = false;

                boolean greenFound = false;

                boolean bluefound = false;

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

                    if(colorInterpretation[i]==RED_BAND){

                        redFound = true;

                    }

                    if(colorInterpretation[i]==GREEN_BAND){

                        greenFound = true;

                    }

                    if(colorInterpretation[i]==BLUE_BAND){

                        bluefound = true;

                    }

                }

                if(redFound || greenFound || bluefound){

                    return true;

                }

        }

        return false;

    }

    @Override

    public boolean isHSL() {

        if (colorInterpretation != null) {

            if (colorInterpretation.length >= 3 && hasAnyBandWithThisColorInterpretation( HUE_BAND)

                && hasAnyBandWithThisColorInterpretation(LIGHTNESS_BAND) && hasAnyBandWithThisColorInterpretation(SATURATION_BAND) ) {

                return true;

            }

        }

        return false;

    }

    private boolean hasAnyBandWithThisColorInterpretation(String interpretation){

        if (colorInterpretation != null) {

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

                if(colorInterpretation[i] == interpretation){

                    return true;

                }

            }

        }

        return false;

    }

    @Override

    public boolean isCMYK() {

        if (colorInterpretation != null) {

            if (colorInterpretation.length >= 4 && hasAnyBandWithThisColorInterpretation(CYAN_BAND)

                && hasAnyBandWithThisColorInterpretation(MAGENTA_BAND)

                && hasAnyBandWithThisColorInterpretation(YELLOW_BAND)

                && hasAnyBandWithThisColorInterpretation(BLACK_BAND) ) {

                return true;

            }

        }

        return false;

    }

    @Override

    public boolean isYCBCR() {

        if (colorInterpretation != null) {

            if (colorInterpretation.length >= 3 && hasAnyBandWithThisColorInterpretation(YCBCR_Y_BAND)

                && hasAnyBandWithThisColorInterpretation(YCBCR_CB_BAND)

                && hasAnyBandWithThisColorInterpretation(YCBCR_CR_BAND) ) {

                return true;

            }

        }

        return false;

    }

    @Override

    public boolean isRGBA() {

        if (colorInterpretation != null) {

            if (colorInterpretation.length >= 4 && hasAnyBandWithThisColorInterpretation(RED_BAND)

                && hasAnyBandWithThisColorInterpretation(GREEN_BAND)

                && hasAnyBandWithThisColorInterpretation(BLUE_BAND)

                && hasAnyBandWithThisColorInterpretation(ALPHA_BAND)) {

                return true;

            }

        }

        return false;

    }

    @Override

    public boolean isGray() {

        if (colorInterpretation != null && this.length() >= 1

            && hasAnyBandWithThisColorInterpretation(GRAY_BAND)) {

            return true;

        }

        return false;

    }

    @Override

    public boolean hasAnyGrayBand() {

        if (colorInterpretation != null) {

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

                if (colorInterpretation[i] == GRAY_BAND) {

                    return true;

                }

            }

        }

        return false;

    }

    @Override

    public boolean hasAnyPaletteBand() {

        if (colorInterpretation != null) {

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

                if (colorInterpretation[i] == PALETTE_BAND) {

                    return true;

                }

            }

        }

        return false;

    }

    @Override

    public boolean isColorInterpretation(int band) {

        return colorInterpretation[band].equals(RED_BAND)

            || colorInterpretation[band].equals(GREEN_BAND)

            || colorInterpretation[band].equals(BLUE_BAND)

            || colorInterpretation[band].equals(HUE_BAND)

            || colorInterpretation[band].equals(SATURATION_BAND)

            || colorInterpretation[band].equals(LIGHTNESS_BAND)

            || colorInterpretation[band].equals(CYAN_BAND)

            || colorInterpretation[band].equals(MAGENTA_BAND)

            || colorInterpretation[band].equals(YELLOW_BAND)

            || colorInterpretation[band].equals(BLACK_BAND)

            || colorInterpretation[band].equals(YCBCR_Y_BAND)

            || colorInterpretation[band].equals(YCBCR_CB_BAND)

            || colorInterpretation[band].equals(YCBCR_CR_BAND);

    }

    @Override

    public boolean hasAnyColorInterpretationBand() {

        if (colorInterpretation != null) {

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

                if (isColorInterpretation(i)) {

                    return true;

                }

            }

        }

        return false;

    }

    @Override

    public boolean isGrayInterpretation(int band) {

        return colorInterpretation[band].equals(GRAY_BAND);

    }

    @Override

    public boolean isPaletteInterpretation(int band) {

        return colorInterpretation[band].equals(PALETTE_BAND);

    }

    @Override

    public boolean isAlphaInterpretation(int band) {

        return colorInterpretation[band].equals(ALPHA_BAND);

    }

    @Override

    public String get(int i) {

        if (i < 0 || i >= colorInterpretation.length) {

            throw new IllegalArgumentException("Index out of defined color interpretation");

        }

        return colorInterpretation[i];

    }

    @Override

    public int getBand(String id) {

        if (colorInterpretation != null && !id.equalsIgnoreCase(ColorInterpretation.UNDEFINED_BAND)) {

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

                if (colorInterpretation[i] != null && colorInterpretation[i].equals(id))

                    return i;

        }

        return -1;

    }

    @Override

    public boolean isUndefined() {

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

            if (colorInterpretation[i] != null) {

                if (!colorInterpretation[i].equals(ALPHA_BAND))

                    return false;

            }

        }

        return true;

    }

    @Override

    public String[] getValues() {

        return colorInterpretation;

    }

    @Override

    public boolean hasAlphaBand() {

        return getAlphaBand() >= 0;

    }

    @Override

    public int getAlphaBand() {

        String[] values = getValues();

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

            if (values[i] != null && values[i].equals(ALPHA_BAND))

                return i;

        }

        return -1;

    }

    @Override

    public void addColorInterpretation(ColorInterpretation ci) {

        String[] oldColorInterpretation = this.colorInterpretation;

        String[] newCI = new String[colorInterpretation.length + ci.length()];

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

            newCI[i] = colorInterpretation[i];

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

            newCI[colorInterpretation.length + i] = ci.get(i);

        }

        this.colorInterpretation = newCI;

        this.notifyObservers(new DefaultColorInterpretationNotification(ColorInterpretationNotification.ADDED_COLOR_INTERPRETATION,

            new Object[] { oldColorInterpretation, this.colorInterpretation }));

    }

    public static void registerPersistence() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        DynStruct definition = manager.getDefinition(PERSISTENCE_DEFINITION);

        if (definition == null) {

            definition =

                manager.addDefinition(DefaultColorInterpretation.class, PERSISTENCE_DEFINITION,

                    PERSISTENCE_DESCRIPTION, null, null);

            definition.addDynFieldList(COLOR_INTERPRETATION_PERSISTENCE_FIELD)

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

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

            definition.addDynFieldObject(COLOR_TABLE_PERSISTENCE_FIELD).setClassOfValue(ColorTable.class);

        }

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set(COLOR_INTERPRETATION_PERSISTENCE_FIELD, colorInterpretation);

    }

    @SuppressWarnings("unchecked")

    public void loadFromState(PersistentState state) throws PersistenceException {

        List<String> descriptions =

            (List<String>) state.get(COLOR_INTERPRETATION_PERSISTENCE_FIELD);

        this.colorInterpretation = descriptions.toArray(new String[descriptions.size()]);

        this.setPaletteBand(state.getInt(PALETTE_BAND_PERSISTENCE_FIELD, -1));

        this.setPalette((ColorTable)state.get(COLOR_TABLE_PERSISTENCE_FIELD));

    }

    @Override

    public void copyFrom(ColorInterpretation colorInterpretation) {

        String[] oldColorInterpretation = new String[this.length()];

        System.arraycopy(this.colorInterpretation, 0, oldColorInterpretation, 0, length());

        this.colorInterpretation = new String[colorInterpretation.length()];

        System.arraycopy(colorInterpretation.getValues(), 0, this.colorInterpretation, 0, colorInterpretation.length());

        this.paletteBand = colorInterpretation.getPaletteBand();

        this.notifyObservers(new DefaultColorInterpretationNotification(ColorInterpretationNotification.COPIED_FROM_COLOR_INTERPRETATION,

            new Object[] { oldColorInterpretation, this.colorInterpretation }));

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        ColorInterpretation cloned = new DefaultColorInterpretation(this.length());

        cloned.copyFrom(this);

        if(this.colorTable!=null){

            cloned.setPalette((ColorTable)this.colorTable.clone());

        }

        return cloned;

    }

    @Override

    public boolean hasAnyHSLBand() {

        if (colorInterpretation != null) {

            boolean hueFound = false;

            boolean saturationFound = false;

            boolean lightnessFound = false;

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

                if (colorInterpretation[i] == HUE_BAND) {

                    hueFound = true;

                }

                if (colorInterpretation[i] == SATURATION_BAND) {

                    saturationFound = true;

                }

                if (colorInterpretation[i] == LIGHTNESS_BAND) {

                    lightnessFound = true;

                }

            }

            if (hueFound || saturationFound || lightnessFound) {

                return true;

            }

        }

        return false;

    }

    @Override

    public boolean hasAnyCMYKBand() {

        if (colorInterpretation != null) {

            boolean cyanFound = false;

            boolean magentaFound = false;

            boolean yellowFound = false;

            boolean blackFound = false;

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

                if (colorInterpretation[i] == CYAN_BAND) {

                    cyanFound = true;

                }

                if (colorInterpretation[i] == MAGENTA_BAND) {

                    magentaFound = true;

                }

                if (colorInterpretation[i] == YELLOW_BAND) {

                    yellowFound = true;

                }

                if (colorInterpretation[i] == BLACK_BAND) {

                    blackFound = true;

                }

            }

            if (cyanFound || magentaFound || yellowFound || blackFound) {

                return true;

            }

        }

        return false;

    }

    @Override

    public boolean hasAnyYCBCRBand() {

        if (colorInterpretation != null) {

            boolean cBFound = false;

            boolean cRFound = false;

            boolean yFound = false;

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

                if (colorInterpretation[i] == YCBCR_CB_BAND) {

                    cBFound = true;

                }

                if (colorInterpretation[i] == YCBCR_CR_BAND) {

                    cRFound = true;

                }

                if (colorInterpretation[i] == YCBCR_Y_BAND) {

                    yFound = true;

                }

            }

            if (cBFound || cRFound || yFound ) {

                return true;

            }

        }

        return false;

    }

    @Override

    public boolean isPalette() {

        if(this.paletteBand>=0 && this.paletteBand<this.length() && this.colorTable!=null){

            return true;

        }

        return false;

    }

    @Override

    public void setPalette(ColorTable colorTable) {

        ColorTable oldColorTable = this.colorTable;

        if (colorTable != null && !colorTable.equals(oldColorTable)) {

            if(oldColorTable!=null){

                oldColorTable.deleteObserver(this);

            }

            this.colorTable = colorTable;

            this.colorTable.addObserver(this);

            this.notifyObservers(new DefaultColorInterpretationNotification(

                ColorInterpretationNotification.SETTED_PALETTE, new Object[] { oldColorTable, colorTable }));

        }

    }

    @Override

    public void setPaletteBand(int band) {

        if (band != this.paletteBand) {

            int oldPaletteBand = this.paletteBand;

            if (band >= 0 && band < this.length()) {

                this.paletteBand = band;

            } else {

                this.paletteBand = -1;

            }

            this.notifyObservers(new DefaultColorInterpretationNotification(

                ColorInterpretationNotification.SETTED_PALETTE_BAND, new Object[] { new Integer(oldPaletteBand),

                    new Integer(this.paletteBand) }));

        }

    }

    @Override

    public int getPaletteBand() {

        return this.paletteBand;

    }

    @Override

    public ColorTable getPalette() {

        return this.colorTable;

    }

    @Override

    public void update(Observable observable, Object notification) {

        if (notification instanceof ColorTableNotification && observable instanceof ColorTable) {

            Notification colorTableNotification = (Notification) notification;

            if (colorTableNotification.getType().equals(ColorTableNotification.CHANGED_INTERPOLATED_COLOR_TABLE)

                || colorTableNotification.getType().equals(ColorTableNotification.COMPRESSED_COLOR_TABLE)

                || colorTableNotification.getType().equals(ColorTableNotification.COPIED_FROM_COLOR_TABLE)

                || colorTableNotification.getType().equals(ColorTableNotification.REMOVED_DUPLICATED_VALUES_COLOR_TABLE)

                || colorTableNotification.getType().equals(ColorTableNotification.SETTED_CLASS_VALUES_COLOR_TABLE)) {

                this.notifyObservers(new DefaultColorInterpretationNotification(ColorInterpretationNotification.CHANGED_PALETTE,

                    new Object[] { observable }));

            }

        }

    }

}

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;