Application: gvSIG desktop

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

import java.awt.Color;

import java.awt.image.BufferedImage;

import java.awt.image.ColorModel;

import java.awt.image.ComponentColorModel;

import java.awt.image.IndexColorModel;

import java.awt.image.WritableRaster;

import java.io.File;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.apache.commons.lang3.tuple.ImmutablePair;

import org.apache.commons.lang3.tuple.Pair;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.raster.lib.buffer.api.operations.OperationList;

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

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

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

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

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

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

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.ColorTableIOFactory;

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

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

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

import org.gvsig.raster.lib.legend.impl.io.gvSIGColorTableIO;

/**

 * Default implementation of {@link RasterLegendManager}.

 *

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

 *

 */

public class DefaultRasterLegendManager implements RasterLegendManagerServices {

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

    private Map<String, ColorTableIOFactory> colorTableIOFactories =

        new HashMap<String, ColorTableIOFactory>();

    private ColorManager colorManager;

    @Override

    public RasterLegend createLegend() {

        return new DefaultRasterLegend();

    }

    @Override

    public RasterLegend createLegend(ColorInterpretation colorInterpretation) {

        return new DefaultRasterLegend(colorInterpretation);

    }

    @Override

    public RasterLegend createLegend(ColorInterpretation colorInterpretation,

        Transparency transparency, OperationList filters) {

        return new DefaultRasterLegend(colorInterpretation, transparency, filters);

    }

    @Override

    public List<Pair<File, ColorTable>> getColorTables(File folder) {

        if (folder.isFile()) {

            throw new IllegalArgumentException("File object has to be a directory");

        }

        if (!folder.canRead()) {

            throw new IllegalArgumentException(

                "It is necessary read permissions to get files and load color tables");

        }

        List<Pair<File, ColorTable>> colorTables = new ArrayList<Pair<File, ColorTable>>();

        for (File file : listFilesForFolder(folder)) {

            Collection<ColorTableIOFactory> factories = this.colorTableIOFactories.values();

            for (ColorTableIOFactory colorTableIOFactory : factories) {

                if(colorTableIOFactory.accept(file)){

                    ColorTableIO colorTableIO = colorTableIOFactory.create();

                    try{

                        ColorTable colorTable = colorTableIO.read(file);

                        colorTables.add(new ImmutablePair<File, ColorTable>(file,colorTable));

                        break;

                    } catch (Exception e){

                        // Log warn but continue reading files.

                        LOG.warn(String.format(

                            "%1s factory accepts file but it can not get ColorTable from file",

                            colorTableIOFactory.getName()), e);

                    }

                }

            }

        }

        return colorTables;

    }

    private List<File> listFilesForFolder(File folder) {

        List<File> files = new ArrayList<File>();

        for (File fileEntry : folder.listFiles()) {

            if (fileEntry.isDirectory()) {

                listFilesForFolder(fileEntry);

            } else {

                files.add(fileEntry);

            }

        }

        return files;

    }

    @Override

    public ColorTable createColorTable() {

        return new DefaultColorTable();

    }

    @Override

    public ColorTable createColorTable(String name, List<ColorTableClass> colorTableClasses,

        boolean interpolated) {

        return new DefaultColorTable(name, colorTableClasses, interpolated);

    }

    @Override

    public List<ColorTableClass> createListColorTableClasses(double minimum, double maximum, int intervals, Color fromColor, Color toColor){

        double intervalSize = (maximum-minimum)/intervals;

        return createListColorTableClasses(minimum, maximum, intervalSize, fromColor, toColor);

    }

    @Override

    public List<ColorTableClass> createListColorTableClasses(double minimum, double maximum, double intervalSize, Color fromColor, Color toColor){

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

        int counter = 0;

        double value = minimum;

        Color color = fromColor;

        while(value<maximum){

            double proportion = (value-minimum)/(maximum-minimum);

            color = getInterpolatedColor(fromColor, toColor, proportion);

            ColorTableClass colorTableClass = this.createColorTableClass(new Integer(counter).toString(), value, 50.0, color);

            colorTableClasses.add(colorTableClass);

            value = value + intervalSize;

            counter++;

        }

        value = maximum;

        ColorTableClass colorTableClass = this.createColorTableClass(new Integer(counter).toString(), value, 50.0, toColor);

        colorTableClasses.add(colorTableClass);

        return colorTableClasses;

    }

    private Color getInterpolatedColor(Color fromColor, Color toColor, double proportion){

        int red = fromColor.getRed();

        int green = fromColor.getGreen();

        int blue = fromColor.getBlue();

        int alpha = fromColor.getAlpha();

            int rangeRed = toColor.getRed()-fromColor.getRed();

            red = (int)Math.round(fromColor.getRed()+(rangeRed*proportion));

            int rangeGreen = toColor.getGreen()-fromColor.getGreen();

            green = (int)Math.round(fromColor.getGreen()+(rangeGreen*proportion));

            int rangeBlue = toColor.getBlue()-fromColor.getBlue();

            blue = (int)Math.round(fromColor.getBlue()+(rangeBlue*proportion));

            int rangeAlpha = toColor.getAlpha()-fromColor.getAlpha();

            alpha = (int)Math.round(fromColor.getAlpha()+(rangeAlpha*proportion));

        return new Color(red, green, blue, alpha);

    }

    @Override

    public ColorTableIO getColorTableIO() {

        ColorTableIOFactory defaultFactory = this.colorTableIOFactories.get(gvSIGColorTableIO.NAME);

        if (defaultFactory == null) {

            if (this.colorTableIOFactories.isEmpty()) {

                LOG.warn("Any default Color Table IO factory registered");

                return null;

            }

        }

        return defaultFactory.create();

    }

    @Override

    public List<ColorTableIOFactory> getColorTableIOFactories() {

        return new ArrayList<ColorTableIOFactory>(this.colorTableIOFactories.values());

    }

    @Override

    public ColorTableIOFactory getColorTableIOFactory(String name) {

        return this.colorTableIOFactories.get(name);

    }

    @Override

    public void registerColorTableIOFactory(String name, ColorTableIOFactory colorTableIOFactory) {

        colorTableIOFactories.put(name, colorTableIOFactory);

    }

    @Override

    public ColorTableClass createColorTableClass() {

        return new DefaultColorTableClass();

    }

    @Override

    public ColorTableClass createColorTableClass(String className, double value,

        double interpolated, Color color) {

        return new DefaultColorTableClass(className, value, color, interpolated);

    }

    @Override

    public ColorInterpretation createColorInterpretation(String[] coloInterpretations) {

        return new DefaultColorInterpretation(coloInterpretations);

    }

    @Override

    public ColorInterpretation createColorInterpretation(List<String> coloInterpretations) {

        String[] x = coloInterpretations.toArray(new String[coloInterpretations.size()]);

        return new DefaultColorInterpretation(x);

    }

    @Override

    public ColorInterpretation createColorInterpretation(String definedColorInterpretation) {

        return new DefaultColorInterpretation(definedColorInterpretation);

    }

    @Override

    public ColorInterpretation createColorInterpretation(BufferedImage image, String prefix) {        

        ColorInterpretation colorInterpretation = null;

        ColorModel colorModel = image.getColorModel();

        if (colorModel instanceof ComponentColorModel) { //DirectColorModel) {

            WritableRaster raster = image.getRaster();

            if (raster.getNumBands() == 3) {

                colorInterpretation = this.createColorInterpretation(ColorInterpretation.RGB);

            } else if (raster.getNumBands() == 4) {

                colorInterpretation = this.createColorInterpretation(ColorInterpretation.ARGB);

            }

        } else if (colorModel instanceof IndexColorModel) {

            colorInterpretation = this.createColorInterpretation(ColorInterpretation.PALETTE);

            ColorTable colorTable;

            IndexColorModel indexColorModel = (IndexColorModel) colorModel;

            int[] rgbs = new int[indexColorModel.getMapSize()];

            boolean hasalpha = indexColorModel.hasAlpha();

            indexColorModel.getRGBs(rgbs);

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

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

                String className = i + "";

                double value = ((byte) i);

                double interpolation = 50.0;

                Color color = new Color(rgbs[i], hasalpha);

                ColorTableClass colorTableClass =

                    this.createColorTableClass(className, value, interpolation, color);

                colorTableClasses.add(colorTableClass);

            }

            String colorTableName = prefix + "_color_table";

            colorTable = this.createColorTable(colorTableName, colorTableClasses, true);

            colorInterpretation.setPalette(colorTable);

            colorInterpretation.setPaletteBand(0);

        }

        return colorInterpretation;

    }

    @Override

    public Transparency createTransparency() {

        return new DefaultTransparency();

    }

    @Override

    public Transparency createTransparency(int transparency,

        List<TransparencyRange> transparencyRanges) {

        return new DefaultTransparency(transparency, transparencyRanges);

    }

    @Override

    public TransparencyRange createTransparencyRange() {

        return new DefaultTransparencyRange();

    }

    @Override

    public TransparencyRange createTransparencyRange(int[] redRange, int[] greenRange, int[] blueRange, int alpha,

        boolean isAnd) {

        return new DefaultTransparencyRange(redRange, greenRange, blueRange, alpha, isAnd);

    }

    @Override

    public MakeColorTable createMakeColorTable() {

        return new DefaultMakeColorTable();

    }

    @Override

    public ColorManager getColorManager() {

        if( colorManager == null ) {

            colorManager = new DefaultColorManager();

        }

        return colorManager;

    }

}