Application: gvSIG desktop » gvSIG raster

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

import java.awt.Color;

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.gvsig.raster.lib.buffer.api.FilterList;

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

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

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

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

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

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

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.impl.io.gvSIGColorTableIO;

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Default implementation of {@link RasterLegendManager}.

 *

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

 *

 */

public class DefaultRasterLegendManager implements RasterLegendManager {

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

    private Map<String, ColorTableIOFactory> colorTableIOFactories =

        new HashMap<String, ColorTableIOFactory>();

    @Override

    public RasterLegend createLegend() {

        return new DefaultRasterLegend();

    }

    @Override

    public RasterLegend createLegend(ColorInterpretation colorInterpretation) {

        return new DefaultRasterLegend(colorInterpretation);

    }

    @Override

    public RasterLegend createLegend(ColorInterpretation colorInterpretation,

        ColorTable colorTable, Transparency transparency, FilterList filters) {

        return new DefaultRasterLegend(colorInterpretation, colorTable, 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(String definedColorInterpretation) {

        return new DefaultColorInterpretation(definedColorInterpretation);

    }

    @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);

    }

}