Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

/*

 * AUTHORS (In addition to CIT):

 * 2009 {DiSiD Technologies}  {{Task}}

 * 

 **************************************************************

 * Colors from www.ColorBrewer.org by Cynthia A. Brewer,

 * Geography, Pennsylvania State University.

 * Using groups of 4 colors from the 9 Diverging Schemes

 * 4 * 9 = 36 colors

 **************************************************************

 * 

 */

package org.gvsig.fmap.mapcontext.rendering.symbols.impl;

import java.awt.Color;

import java.io.File;

import java.io.FileFilter;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.Map;

import java.util.Random;

import org.gvsig.fmap.mapcontext.MapContextRuntimeException;

import org.gvsig.fmap.mapcontext.impl.InvalidRegisteredClassException;

import org.gvsig.fmap.mapcontext.impl.RegisteredClassInstantiationException;

import org.gvsig.fmap.mapcontext.rendering.symbols.IMultiLayerSymbol;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.fmap.mapcontext.rendering.symbols.IWarningSymbol;

import org.gvsig.fmap.mapcontext.rendering.symbols.SymbolException;

import org.gvsig.fmap.mapcontext.rendering.symbols.SymbolManager;

import org.gvsig.fmap.mapcontext.rendering.symbols.SymbolPreferences;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

import org.gvsig.tools.task.AbstractMonitorableTask;

import org.gvsig.tools.task.CancellableTask;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Default {@link SymbolManager} implementation.

 * 

 * @author gvSIG team

 */

public class DefaultSymbolManager implements SymbolManager {

        private static final Logger logger = LoggerFactory.getLogger(DefaultSymbolManager.class);

        private SymbolPreferences symbolPreferences =

                        new DefaultSymbolPreferences();

        private Map symbolsByName = Collections.synchronizedMap(new HashMap());

        private Map symbolsByShapeType = Collections.synchronizedMap(new HashMap());

        private Map multiLineSymbolsByName =

                        Collections.synchronizedMap(new HashMap());

        private Map multiLineSymbolsByShapeType =

                        Collections.synchronizedMap(new HashMap());

        private IWarningSymbol warningSymbol;

        private Object warningSymbolLock = new Object();

        public ISymbol[] loadSymbols(File folder) throws SymbolException {

                return loadSymbols(folder, null);

        }

        public ISymbol[] loadSymbols(File folder, FileFilter fileFilter)

                        throws SymbolException {

                // TODO: add symbol caching

                if (folder.exists()) {

                        File[] symbolFiles = null;

                        if (fileFilter == null) {

                                symbolFiles = folder.listFiles();

                        } else {

                                symbolFiles = folder.listFiles(fileFilter);

                        }

                        if (symbolFiles != null) {

                            TaskStatusManager tm = ToolsLocator.getTaskStatusManager();

                            SimpleTaskStatus status = tm.createDefaultSimpleTaskStatus("Load symbols");

                            status.setRangeOfValues(0, symbolFiles.length);

                            status.setAutoremove(true);

                            status.add();

                            /*

                             * Sorting by file name before loading.

                             * The problem here is that some

                             * descriptions can be empty, so sorting using description

                             * can have strange behavior. Sorting by file name is not

                             * very elegant, though.

                             */

                status.message("sorting symbols");

                                Arrays.sort(symbolFiles, new Comparator() {

                                        public int compare( Object o1, Object o2) {

                                                File f1 = (File) o1;

                                                File f2 = (File) o2;

                                                return f1.getName().compareTo(f2.getName());

                                        }

                                });

                            ISymbol[] symbols = null;

                            try {

                        symbols = new ISymbol[symbolFiles.length];

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

                            status.setCurValue(i);

                            symbols[i] = loadSymbol(symbolFiles[i]);

                        }

                            } finally {

                                status.terminate();

                            }

                                return symbols;

                        }

                }

                return null;

        }

        public class SymbolsLoaderTask extends AbstractMonitorableTask {

                private File folder;

                private FileFilter filter;

                private Visitor visitor;

                public SymbolsLoaderTask(File folder, FileFilter filter, Visitor visitor) {

                        super("Load symbols", true);

                        this.folder = folder; 

                        this.filter = filter;

                        this.visitor = visitor;

                        if( folder == null ) {

                                throw new IllegalArgumentException("folder is null");

                        }

                        if( visitor == null ) {

                                throw new IllegalArgumentException("visitor is null");

                        }

                }

                private File[] getFiles() {

                        if (filter == null) {

                                return folder.listFiles();

                        } else {

                                return folder.listFiles(filter);

                        }

                }

                private String getVisitorName() {

                        String s = visitor.toString() + "/" + visitor.getClass().getName();

                        return s;

                }

                private void visit(final File file, final ISymbol symbol) throws VisitCanceledException {

                        try {

                                visitor.visit(symbol);

                        } catch (BaseException e) {

                                logger.warn("Can't call visit '"+getVisitorName()+"' to offer the symbol '"+file.getAbsolutePath()+"'.",e);

                        }

                }

                public void run() {

                        // TODO: add symbol caching

                        try {

                                logger.info("[SymbolsLoaderTask"+this.getId()+"] process initited.");

                                if (folder.exists()) {

                                        taskStatus.setAutoremove(true);

                                        taskStatus.message("preparing");

                                        File[] symbolFiles = getFiles();

                                        if (symbolFiles != null) {

                                                taskStatus.setRangeOfValues(0, symbolFiles.length);

                                                /*

                                                 * Sorting by file name before loading. The problem here

                                                 * is that some descriptions can be empty, so sorting

                                                 * using description can have strange behavior. Sorting

                                                 * by file name is not very elegant, though.

                                                 */

                                                taskStatus.message("sorting");

                                                Arrays.sort(symbolFiles, new Comparator() {

                                                        public int compare(Object o1, Object o2) {

                                                                File f1 = (File) o1;

                                                                File f2 = (File) o2;

                                                                return f1.getName().compareTo(f2.getName());

                                                        }

                                                });

                                                taskStatus.message("loading");

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

                                                        taskStatus.setCurValue(i);

                                                        if( taskStatus.isCancellationRequested() ) {

                                                                logger.info("[SymbolsLoaderTask"+this.getId()+"] process canceled.");

                                                                break;

                                                        }

                                                        ISymbol symbol = null;

                                                        try {

                                                                symbol = loadSymbol(symbolFiles[i]);

                                                                visit(symbolFiles[i], symbol);

                                                        } catch (VisitCanceledException e) {

                                                                break;

                                                        } catch (SymbolException e) {

                                                                logger.warn("Can't load symbol '"

                                                                                + symbolFiles[i].getAbsolutePath()

                                                                                + "'.", e);

                                                        }

                                                }

                                                taskStatus.message("");

                                        }

                                }

                        } finally {

                                taskStatus.terminate();

                        }

                        logger.info("[SymbolsLoaderTask"+this.getId()+"] process terminated.");

                }

        }

        public CancellableTask loadSymbols(File folder, FileFilter filter, Visitor visitor) {

                SymbolsLoaderTask task = new SymbolsLoaderTask(folder, filter, visitor);

                task.start();

                return task;

        }

        public void saveSymbol(ISymbol symbol, String fileName, File folder)

                        throws SymbolException {

                saveSymbol(symbol, fileName, folder, false);

        }

        public void saveSymbol(ISymbol symbol, String fileName, File folder,

                        boolean overwrite) throws SymbolException {

                // TODO: add symbol caching

                PersistenceManager persistenceManager = ToolsLocator

                                .getPersistenceManager();

                File symbolFile = new File(folder, fileName);

                if (!overwrite && symbolFile.exists()) {

                        throw new SymbolFileAlreadyExistsException(symbolFile);

                }

                try {

                        FileOutputStream fos = new FileOutputStream(symbolFile);

                        persistenceManager.saveState(persistenceManager.getState(symbol),

                                        fos);

                        fos.flush();

                        fos.close();

                } catch (PersistenceException e) {

                        throw new SaveSymbolException(e);

                } catch (IOException e) {

                        throw new SaveSymbolException(e);

                }

        }

        /**

         * Loads a persisted symbol from the given file.

         */

        private ISymbol loadSymbol(File file) throws SymbolException {

                if (file.exists()) {

                        try {

                                FileInputStream fis = new FileInputStream(file);

                                PersistenceManager persistenceManager = ToolsLocator

                                                .getPersistenceManager();

                                PersistentState state = persistenceManager.loadState(fis);

                                ISymbol symbol = (ISymbol) persistenceManager.create(state);

                                fis.close();

                                return symbol;

                        } catch (PersistenceException e) {

                                throw new LoadSymbolException(e);

                        } catch (IOException e) {

                                throw new LoadSymbolException(e);

                        }

                }

                return null;

        }

        public SymbolPreferences getSymbolPreferences() {

                return symbolPreferences;

        }

        public ISymbol createSymbol(String symbolName)

                        throws MapContextRuntimeException {

                return createSymbol(symbolName, (Class) symbolsByName.get(symbolName),

                                ISymbol.class);

        }

        public ISymbol createSymbol(int shapeType)

                        throws MapContextRuntimeException {

                String symbolName =

                                (String) symbolsByShapeType.get(new Integer(shapeType));

                return symbolName == null ? null : createSymbol(symbolName);

        }

        public ISymbol createSymbol(String symbolName, Color color)

                        throws MapContextRuntimeException {

                ISymbol symbol = createSymbol(symbolName);

                if (symbol != null) {

                        symbol.setColor(color);

                }

                return symbol;

        }

        public ISymbol createSymbol(int shapeType, Color color)

                        throws MapContextRuntimeException {

                String symbolName =

                                (String) symbolsByShapeType.get(new Integer(shapeType));

                return symbolName == null ? null : createSymbol(symbolName, color);

        }

        public IMultiLayerSymbol createMultiLayerSymbol(String symbolName)

                        throws MapContextRuntimeException {

                return (IMultiLayerSymbol) createSymbol(symbolName,

                                (Class) multiLineSymbolsByName.get(symbolName),

                                IMultiLayerSymbol.class);

        }

        public IMultiLayerSymbol createMultiLayerSymbol(int shapeType)

                        throws MapContextRuntimeException {

                String symbolName =

                                (String) multiLineSymbolsByShapeType.get(new Integer(shapeType));

                return symbolName == null ? null : createMultiLayerSymbol(symbolName);

        }

        public void registerSymbol(String symbolName, Class symbolClass)

                        throws MapContextRuntimeException {

                if (symbolClass == null || !ISymbol.class.isAssignableFrom(symbolClass)) {

                        throw new InvalidRegisteredClassException(ISymbol.class,

                                        symbolClass, symbolName);

                }

                symbolsByName.put(symbolName, symbolClass);

        }

        public void registerSymbol(String symbolName, int[] shapeTypes,

                        Class symbolClass) throws MapContextRuntimeException {

                registerSymbol(symbolName, symbolClass);

                if (shapeTypes != null) {

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

                                symbolsByShapeType.put(new Integer(shapeTypes[i]), symbolName);

                        }

                }

        }

        public void registerMultiLayerSymbol(String symbolName, Class symbolClass)

                        throws MapContextRuntimeException {

                if (symbolClass == null

                                || !IMultiLayerSymbol.class.isAssignableFrom(symbolClass)) {

                        throw new InvalidRegisteredClassException(IMultiLayerSymbol.class,

                                        symbolClass, symbolName);

                }

                multiLineSymbolsByName.put(symbolName, symbolClass);

        }

        public void registerMultiLayerSymbol(String symbolName, int[] shapeTypes,

                        Class symbolClass) throws MapContextRuntimeException {

                registerMultiLayerSymbol(symbolName, symbolClass);

                if (shapeTypes != null) {

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

                                multiLineSymbolsByShapeType.put(new Integer(shapeTypes[i]),

                                                symbolName);

                        }

                }

        }

        public IWarningSymbol getWarningSymbol(String message, String symbolDesc,

                        int symbolDrawExceptionType) throws MapContextRuntimeException {

                synchronized (warningSymbolLock) {

                        if (warningSymbol == null) {

                                warningSymbol = (IWarningSymbol) createSymbol("warning");

                        }

                }

                // TODO: set those values as parameter values in the draw method.

                warningSymbol.setDescription(symbolDesc);

                warningSymbol.setMessage(message);

                warningSymbol.setDrawExceptionType(symbolDrawExceptionType);

                return warningSymbol;

        }

        private ISymbol createSymbol(String symbolName, Class symbolClass,

                        Class expectedType) throws MapContextRuntimeException {

                ISymbol symbol;

                try {

                        symbol =

                                        (ISymbol) (symbolClass == null ? null

                                                        : symbolClass.newInstance());

                } catch (InstantiationException e) {

                        throw new RegisteredClassInstantiationException(expectedType,

                                        symbolClass, symbolName, e);

                } catch (IllegalAccessException e) {

                        throw new RegisteredClassInstantiationException(expectedType,

                                        symbolClass, symbolName, e);

                }

                Color the_color = null;

        if (getSymbolPreferences().isDefaultSymbolFillColorAleatory()) {

            the_color = getRandomBrewerBasedColor();

        } else {

            // not random

            the_color = getSymbolPreferences().getDefaultSymbolFillColor();

        }

        symbol.setColor(the_color);

                // Perform this initialization into the Symbol implementation

                // if (symbol instanceof CartographicSupport) {

                // CartographicSupport cs = (CartographicSupport) symbol;

                // cs.setUnit(getDefaultCartographicSupportMeasureUnit());

                // cs

                // .setReferenceSystem(getDefaultCartographicSupportReferenceSystem();

                // }

                return symbol;

        }

        public void setSymbolPreferences(SymbolPreferences symbolPreferences) {

                this.symbolPreferences = symbolPreferences;

        }

        /**

         * 

         * @param col

         * @return color 1/3 closer to black

         */

        public static Color darker(Color col) {

            return new Color(

                (2 * col.getRed()) / 3,

                (2 * col.getGreen()) / 3,

                (2 * col.getBlue()) / 3,

                col.getAlpha());

        }

        /**

         * 

         * @param col

         * @return color 1/3 closer to white

         */

        public static Color lighter(Color col) {

            Color resp = invert(col);

            resp = darker(resp);

            return invert(resp);

        }

        /**

         * 

         * @param col

         * @return inverted color (inverts each band, same alpha)

         */

        public static Color invert(Color col) {

        return new Color(

            255 - col.getRed(),

            255 - col.getGreen(),

            255 - col.getBlue(),

            col.getAlpha());

        }

        private static Color getRandomBrewerBasedColor() {

            int ind = rnd.nextInt(BREWER_COLOR.length);

            Color resp = BREWER_COLOR[ind]; 

            ind = rnd.nextInt(100);

            if (ind > 66) {

                resp = darker(resp);

            } else {

                if (ind > 33) {

                    resp = lighter(resp);

                }

                // ...else resp remains the same

            }

            // finally add some dark noise 

            resp = addDarkNoise(resp);

            return resp;

        }

    private static Color addDarkNoise(Color c) {

        int r = Math.max(0, c.getRed() - rnd.nextInt(30));

        int g = Math.max(0, c.getGreen() - rnd.nextInt(30));

        int b = Math.max(0, c.getBlue() - rnd.nextInt(30));

        return new Color(r, g, b, c.getAlpha());

    }

    private static Color[] BREWER_COLOR = new Color[36];

    private static final Random rnd = new Random();

        static {

            /**

             * Colors from www.ColorBrewer.org by Cynthia A. Brewer,

             * Geography, Pennsylvania State University.

             *

             * Using groups of 4 colors from the 9 Diverging Schemes

             * 4 * 9 = 36 colors

             */

            BREWER_COLOR[0] = new Color(230, 97, 1);

            BREWER_COLOR[1] = new Color(253, 184, 99);

            BREWER_COLOR[2] = new Color(178, 171, 210);

            BREWER_COLOR[3] = new Color(94, 60, 153);

            BREWER_COLOR[4] = new Color(166, 97, 26);

            BREWER_COLOR[5] = new Color(223, 194, 125);

            BREWER_COLOR[6] = new Color(128, 205, 193);

            BREWER_COLOR[7] = new Color(1, 133, 113);

            BREWER_COLOR[8] = new Color(123, 50, 148);

            BREWER_COLOR[9] = new Color(194, 165, 207);

            BREWER_COLOR[10] = new Color(166, 219, 160);

            BREWER_COLOR[11] = new Color(0, 136, 55);

            BREWER_COLOR[12] = new Color(208, 28, 139);

            BREWER_COLOR[13] = new Color(241, 182, 218);

            BREWER_COLOR[14] = new Color(184, 225, 134);

            BREWER_COLOR[15] = new Color(77, 172, 38);

            BREWER_COLOR[16] = new Color(202, 0, 32);

            BREWER_COLOR[17] = new Color(244, 165, 130);

            BREWER_COLOR[18] = new Color(146, 197, 222);

            BREWER_COLOR[19] = new Color(5, 113, 176);

            BREWER_COLOR[20] = new Color(202, 0, 32);

            BREWER_COLOR[21] = new Color(244, 165, 130);

            BREWER_COLOR[22] = new Color(186, 186, 186);

            BREWER_COLOR[23] = new Color(64, 64, 64);

            BREWER_COLOR[24] = new Color(215, 25, 28);

            BREWER_COLOR[25] = new Color(253, 174, 97);

            BREWER_COLOR[26] = new Color(171, 217, 233);

            BREWER_COLOR[27] = new Color(44, 123, 182);

            BREWER_COLOR[28] = new Color(215, 25, 28);

            BREWER_COLOR[29] = new Color(253, 174, 97);

            BREWER_COLOR[30] = new Color(171, 221, 164);

            BREWER_COLOR[31] = new Color(43, 131, 186);

            BREWER_COLOR[32] = new Color(215, 25, 28);

            BREWER_COLOR[33] = new Color(253, 174, 97);

            BREWER_COLOR[34] = new Color(166, 217, 106);

            BREWER_COLOR[35] = new Color(26, 150, 65);

        }

}