Application: gvSIG desktop » gvSIG raster

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * 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 2

 * 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.

 *

 */

package org.gvsig.raster.util;

import java.awt.geom.AffineTransform;

import java.io.File;

import java.io.IOException;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.TreeMap;

import org.gvsig.fmap.dal.DALFileLocator;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.coverage.RasterLocator;

import org.gvsig.fmap.dal.coverage.RasterManager;

import org.gvsig.fmap.dal.coverage.dataset.Buffer;

import org.gvsig.fmap.dal.coverage.datastruct.Extent;

import org.gvsig.fmap.dal.coverage.datastruct.Params;

import org.gvsig.fmap.dal.coverage.exception.FileNotSupportedException;

import org.gvsig.fmap.dal.coverage.exception.NotSupportedExtensionException;

import org.gvsig.fmap.dal.coverage.exception.ProcessInterruptedException;

import org.gvsig.fmap.dal.coverage.exception.RasterDriverException;

import org.gvsig.fmap.dal.coverage.exception.RmfSerializerException;

import org.gvsig.fmap.dal.coverage.store.DataServerWriter;

import org.gvsig.fmap.dal.coverage.store.RasterDataStore;

import org.gvsig.fmap.dal.coverage.store.RasterWriter;

import org.gvsig.fmap.dal.coverage.store.parameter.RasterDataParameters;

import org.gvsig.fmap.dal.coverage.store.parameter.RasterFileStoreParameters;

import org.gvsig.fmap.dal.coverage.store.props.ColorInterpretation;

import org.gvsig.fmap.dal.coverage.util.ProviderServices;

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException;

import org.gvsig.fmap.dal.exception.ValidateDataParametersException;

import org.gvsig.fmap.dal.raster.spi.CoverageStoreProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorer;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorerParameters;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemStoreParameters;

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerProvider;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

import org.gvsig.fmap.dal.spi.DataStoreProvider;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

import org.gvsig.raster.impl.DefaultRasterManager;

import org.gvsig.raster.impl.provider.DefaultRasterProvider;

import org.gvsig.raster.impl.provider.RasterProvider;

import org.gvsig.raster.impl.store.WriteFileFormatFeatures;

import org.gvsig.raster.impl.store.rmf.ClassSerializer;

import org.gvsig.raster.impl.store.rmf.RmfBlocksManager;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.extensionpoint.ExtensionPoint.Extension;

import org.gvsig.tools.extensionpoint.ExtensionPointManager;

/**

 * 

 * 31/10/2007

 * @author Nacho Brodin nachobrodin@gmail.com

 */

public class DefaultProviderServices implements ProviderServices {

        public TreeMap<String, WriteFileFormatFeatures>

                                  fileFeature    = new TreeMap<String, WriteFileFormatFeatures>();

        public DefaultRasterManager getManager() {

                return (DefaultRasterManager)RasterLocator.getManager();

        }

        public TreeMap<String, WriteFileFormatFeatures> getFileFeature() {

                return fileFeature;

        }

        /**

         * Abre un dataset pasando como par�metros la proyecci�n y un objeto identificador del dataset. Este

         * objeto puede ser una ruta a un fichero en disco. En este caso la extensi�n del fichero servir� para

         * buscar el driver que lo gestiona. Si proporcionamos un array de cadenas se tratar�n como la ruta a N ficheros

         * de disco. Tambi�n puede ser un buffer de datos en memoria o cualquier otro objeto

         * que pueda aceptar un driver.

         * @param param Par�metros al driver

         * @return RasterMultiDatset

         * @throws NotSupportedExtensionException

         * @throws RasterDriverException

         */

        public RasterDataStore open(DataStoreParameters param) throws NotSupportedExtensionException, RasterDriverException {

                return getManager().open(param);

        }

        public RasterDataStore open(CoverageStoreProvider prov, DataStoreParameters params) throws NotSupportedExtensionException, RasterDriverException {

                return getManager().open(prov, params);

        }

        /**

         * Loads the specific provider to download data

         * @param file

         * @return

         * @throws NotSupportedExtensionException

         * @throws FileNotSupportedException 

         */

        public static DefaultRasterProvider loadProvider(File file) throws ProviderNotRegisteredException, InitializeException {

                DataManagerProviderServices dataManager = (DataManagerProviderServices)DALLocator.getDataManager();

                DataStoreProviderServices storeServices = null;

                DataStoreProvider prov = null;

                if(file != null) {

                        //We have to locate a provider's name which manages the selected file

                        //A FilesystemServerExplorer will give a getProviderNames service

                        FilesystemServerExplorerParameters paramsExplorer = (FilesystemServerExplorerParameters)dataManager.createServerExplorerParameters(FilesystemServerExplorer.NAME);

                        FilesystemServerExplorer serverExplorer = null;

                        try {

                                paramsExplorer.setRoot(File.separator);

                                serverExplorer = (FilesystemServerExplorer)dataManager.openServerExplorer(FilesystemServerExplorer.NAME, paramsExplorer);

                        } catch (ValidateDataParametersException e) {

                                throw new InitializeException(e);

                        }

                        //Gets the list of provider's name to manage the file

                        List<String> provNameList = serverExplorer.getProviderNameList(file);

                        if(provNameList.size() > 0) {

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

                                        //Gets the first provider what is not a TileProvider

                                        if(provNameList.get(i).compareTo("Tile Store") != 0) {

                                                DataStoreParameters newparams = dataManager.createStoreParameters(provNameList.get(i));

                                                ((FilesystemStoreParameters)newparams).setFile(file); 

                                                prov = dataManager.createProvider(storeServices, newparams);

                                        }

                                }

                        } else { //Default provider. This should be Gdal

                                ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

                                ExtensionPoint point = extensionPoints.get("DefaultRasterProvider");

                                Extension ext = point.get("reader");

                                String provName = ext.getDescription();

                                DataStoreParameters newparams = dataManager.createStoreParameters(provName);

                                ((FilesystemStoreParameters)newparams).setFile(file); 

                                prov = dataManager.createProvider(storeServices, newparams);

                        }

                }

                if(prov != null && prov instanceof RasterProvider) {

                        if(((RasterProvider)prov).isRotated())

                                throw new InitializeException("Rotation not supported tiling files", new Throwable());

                        return (DefaultRasterProvider)prov;

                }

                return null;

        }

        public RasterDataParameters createNotTiledParameters(String id) throws InitializeException, ProviderNotRegisteredException {

                DataManagerProviderServices dataManager = (DataManagerProviderServices)DALLocator.getDataManager();

                ArrayList<RasterDataParameters> parametersList = createParametersList(id);

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

                        DataStoreProvider p = dataManager.createProvider(null, parametersList.get(i));

                        if(p instanceof RasterProvider) {

                                if(!((RasterProvider)p).isTiled()) 

                                        return parametersList.get(i);

                        }

                }

                return null;

        }

        @SuppressWarnings("unchecked")

        public RasterDataParameters createParameters(String id) {

                Iterator it = DALFileLocator.getFilesystemServerExplorerManager().getRegisteredProviders();

                while (it.hasNext()) {

                        ExtensionPoint.Extension o = (ExtensionPoint.Extension)it.next();

                        Class c = o.getExtension();

                        try {

                                Constructor hazNuevo = c.getConstructor();

                                Object [] args2 = {};

                                Object obj = hazNuevo.newInstance(args2);

                                if(obj instanceof FilesystemServerExplorerProvider) {

                                        FilesystemServerExplorerProvider prov = (FilesystemServerExplorerProvider)obj;

                                        File file = new File(id);

                                        if(prov.accept(file)) {

                                                DataManager manager = DALLocator.getDataManager();

                                                RasterFileStoreParameters params = null;

                                                try {

                                                        params = (RasterFileStoreParameters) manager

                                                                        .createStoreParameters(prov.getDataStoreProviderName());

                                                } catch (InitializeException e) {

                                                } catch (ProviderNotRegisteredException e) {

                                                }

                                                params.setFile(file);

                                                return params;

                                        }

                                } 

                        } catch (SecurityException e) {

                                System.out.println("Error SecurityException in open");

                        } catch (NoSuchMethodException e) {

                                System.out.println("Error NoSuchMethodException in open");

                        } catch (IllegalArgumentException e) {

                                System.out.println("Error IllegalArgumentException in open");

                        } catch (InstantiationException e) {

                                System.out.println("Error InstantiationException in open");

                        } catch (IllegalAccessException e) {

                                System.out.println("Error IllegalAccessException in open");

                        } catch (InvocationTargetException e) {

                                System.out.println("Error opening this image with ");

                        }

                }

                return null;

        }

        @SuppressWarnings("unchecked")

        public ArrayList<RasterDataParameters> createParametersList(String id) {

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

                Iterator it = DALFileLocator.getFilesystemServerExplorerManager().getRegisteredProviders();

                while (it.hasNext()) {

                        ExtensionPoint.Extension o = (ExtensionPoint.Extension)it.next();

                        Class c = o.getExtension();

                        try {

                                Constructor hazNuevo = c.getConstructor();

                                Object [] args2 = {};

                                Object obj = hazNuevo.newInstance(args2);

                                if(obj instanceof FilesystemServerExplorerProvider) {

                                        FilesystemServerExplorerProvider prov = (FilesystemServerExplorerProvider)obj;

                                        File file = new File(id);

                                        if(prov.accept(file)) {

                                                DataManager manager = DALLocator.getDataManager();

                                                RasterFileStoreParameters params = null;

                                                try {

                                                        params = (RasterFileStoreParameters) manager

                                                                        .createStoreParameters(prov.getDataStoreProviderName());

                                                } catch (InitializeException e) {

                                                } catch (ProviderNotRegisteredException e) {

                                                }

                                                params.setFile(file);

                                                list.add(params);

                                        }

                                } 

                        } catch (SecurityException e) {

                                System.out.println("Error SecurityException in open");

                        } catch (NoSuchMethodException e) {

                                System.out.println("Error NoSuchMethodException in open");

                        } catch (IllegalArgumentException e) {

                                System.out.println("Error IllegalArgumentException in open");

                        } catch (InstantiationException e) {

                                System.out.println("Error InstantiationException in open");

                        } catch (IllegalAccessException e) {

                                System.out.println("Error IllegalAccessException in open");

                        } catch (InvocationTargetException e) {

                                System.out.println("Error opening this image with ");

                        }

                }

                return list;

        }

        public RasterDataParameters createParametersForTiledFiled(String id) {

                DataManager manager = DALLocator.getDataManager();

                RasterFileStoreParameters params = null;

                try {

                        params = (RasterFileStoreParameters) manager.createStoreParameters("Tile Store");

                } catch (InitializeException e) {

                } catch (ProviderNotRegisteredException e) {

                }

                File file = new File(id);

                params.setFile(file);

                return params;

        }

        @SuppressWarnings("unchecked")

        public String[] getDriversExtensions() {

                ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

                ExtensionPoint point = extensionPoints.get("RasterWriter");

                return (String[])point.getNames().toArray(new String[0]);

        }

        public String[] getRODriversExtensions() {

                return getReadOnlyFormatList();

        }

        @SuppressWarnings("unchecked")

        public ArrayList<String> getExtensionsSupported(int dataType, int bands) throws RasterDriverException {

                ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

                ExtensionPoint point = extensionPoints.get("RasterWriter");

                Iterator iterator = point.iterator();

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

                while (iterator.hasNext()) {

                        ExtensionPoint.Extension extension = (ExtensionPoint.Extension) iterator.next();

                        String ext = extension.getName();

                        try {

                                if (isSupportedThisFileToWrite(ext, dataType, bands))

                                        result.add(ext);

                        } catch (SecurityException e) {

                                throw new RasterDriverException("Error SecurityException in open");

                        }  catch (IllegalArgumentException e) {

                                throw new RasterDriverException("Error IllegalArgumentException in open");

                        }

                }

                return result;

        }

        @SuppressWarnings("unchecked")

        public String[] getWriteDriversType() {

                if (fileFeature.size() == 0)

                        return null;

                String[] list = new String[fileFeature.size()];

                Set values = fileFeature.entrySet();

                int i = 0;

                for (Iterator it = values.iterator(); it.hasNext();) {

                        list[i] = ((WriteFileFormatFeatures) ((Map.Entry) it.next()).getValue()).getDriverName();

                        i++;

                }

                return list;

        }

        public String getWriteDriverType(String ext) {

                return ((WriteFileFormatFeatures) fileFeature.get(ext)).getDriverName();

        }

        public int getWriteNDrivers() {

                ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

                ExtensionPoint point = extensionPoints.get("RasterWriter");

                return point.getCount();

        }

        public int getWriteNTypes() {

                return fileFeature.size();

        }

        public boolean isSupportedThisFileToWrite(String ext, int dataType, int bands) {

                WriteFileFormatFeatures features = (WriteFileFormatFeatures) fileFeature.get(ext);

                if (features == null)

                        return false;

                int[] bandsSupported = features.getNBandsSupported();

                if (bandsSupported[0] != -1 && bandsSupported[0] < bands)

                        return false;

                int[] dt = features.getDataTypesSupported();

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

                        if (dataType == dt[i])

                                return true;

                return false;

        }

        /**

         * Guarda en el RMF que trata el BlocksManager el valor value usando el serializador que soporta

         * la clase class1.

         *

         * @param blocksManager

         * @param class1

         * @param value

         * @throws RmfSerializerException

         */

        @SuppressWarnings("unchecked")

        public void saveObjectToRmfFile(RmfBlocksManager blocksManager, Class class1, Object value) throws RmfSerializerException {

                ClassSerializer serializerObject = getSerializerObject(class1, value);

                if (serializerObject == null)

                        throw new RmfSerializerException("No se ha podido encontrar el serializador para el Rmf");

                if (!blocksManager.checkRmf())

                        throw new RmfSerializerException("Error al comprobar el fichero Rmf");

                blocksManager.addClient(serializerObject);

                try {

                        blocksManager.write(true);

                } catch (IOException e) {

                        throw new RmfSerializerException("Error al escribir el fichero Rmf", e);

                }

                blocksManager.removeAllClients();

        }

        @SuppressWarnings("unchecked")

        public void saveObjectToRmfFile(String file, Class class1, Object value) throws RmfSerializerException {

                String fileRMF = RasterLocator.getManager().getFileUtils().getNameWithoutExtension(file) + ".rmf";

                RmfBlocksManager blocksManager = new RmfBlocksManager(fileRMF);

                saveObjectToRmfFile(blocksManager, class1, value);

        }

        public void saveObjectToRmfFile(String file, Object value) throws RmfSerializerException {

                saveObjectToRmfFile(file, value.getClass(), value);

        }

        /**

         * Construye un serializador que soporte la clase class1. El constructor se invoca

         * con el parametro value.

         *

         * @param class1

         * @param value

         * @return

         * @throws RmfSerializerException

         */

        @SuppressWarnings("unchecked")

        public ClassSerializer getSerializerObject(Class class1, Object value) throws RmfSerializerException {

                try {

                        Class[] args = { class1 };

                        Constructor constructor = getSerializerClass(class1).getConstructor(args);

                        Object[] args2 = { value };

                        return (ClassSerializer) constructor.newInstance(args2);

                } catch (Exception e) {

                        throw new RmfSerializerException("No se ha podido crear el serializador para el Rmf", e);

                }

        }

        /**

         * Gets the serializer which has a constructor with the class selected in the 

         * parameters of this function

         * @throws RmfSerializerException

         */

        @SuppressWarnings("unchecked")

        private Class getSerializerClass(Class class1)

                        throws RmfSerializerException {

                ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

                ExtensionPoint point = extensionPoints.get("Serializer");

                Iterator iterator = point.iterator();

                while (iterator.hasNext()) {

                        ExtensionPoint.Extension extension = (ExtensionPoint.Extension) iterator.next();

                        if (extension != null) {

                                Class[] args = { class1 };

                                Class clase = extension.getExtension();

                                try {

                                        clase.getConstructor(args);

                                        return clase;

                                } catch (Exception e) {

                                        // Si no encuentra un constructor para esta clase, seguir� buscando en los dem�s elementos

                                }

                        }

                }

                throw new RmfSerializerException("No se ha encontrado la clase para el serializador");

        }

        @SuppressWarnings("deprecation")

        public void exportBufferToFile(Buffer bufResult, 

                        double pixelSize, 

                        String extension, 

                        boolean alphaBand, 

                        File file, 

                        Extent extent,

                        ColorInterpretation colorInterpretation) throws NotSupportedExtensionException, RasterDriverException, ProcessInterruptedException, IOException {

                //Escritura en disco del tile

                RasterManager rManager = RasterLocator.getManager();

                DataServerWriter dataWriter = RasterLocator.getManager().createDataServerWriter();

                dataWriter.setBuffer(bufResult, -1);

                Params params = rManager.createWriter("_." + extension).getParams();

                AffineTransform affineTransform = new AffineTransform(pixelSize, 0, 0, -pixelSize,

                                extent.getULX(),

                                extent.getULY());

                RasterWriter rw = rManager.createWriter(dataWriter, file.getAbsolutePath(),

                                bufResult.getBandCount(), affineTransform, bufResult.getWidth(),

                                bufResult.getHeight(), bufResult.getDataType(), params, null);

                if(colorInterpretation != null) {

                        String[] values = colorInterpretation.getValues();

                        if(alphaBand) {

                                String[] newValues = values;

                                boolean exists = false;

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

                                        if(values[i] != null && values[i].compareTo("Alpha") == 0)

                                                exists = true;

                                }

                                if(!exists) {

                                        newValues = new String[values.length + 1];

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

                                                newValues[i] = values[i];

                                        }

                                        newValues[newValues.length - 1] = "Alpha";

                                }

                                rw.setColorBandsInterpretation(newValues);

                        }

                } else {

                        if(alphaBand) {

                                String[] ci = new String[bufResult.getBandCount()];

                                if(bufResult.getBandCount() == 4) {

                                        ci[0] = "Red";

                                        ci[1] = "Green";

                                        ci[2] = "Blue";

                                        ci[3] = "Alpha";

                                } else {

                                        for (int i = 0; i < bufResult.getBandCount(); i++) {

                                                ci[i] = "Gray";

                                        }

                                }

                                rw.setColorBandsInterpretation(ci);

                        }

                }

                rw.dataWrite();

                rw.writeClose();

        }

        public void addFormat(String ext, Class<?> c) {

                getManager().addFormat(ext, c);

        }

        public String[] getReadOnlyFormatList() {

                return getManager().getReadOnlyFormatList();

        }

        public boolean isExtensionSupported(String ext, Class<?> c) {

                return getManager().isExtensionSupported(ext, c);

        }

        public boolean isExtensionSupported(String ext) {

                return getManager().isExtensionSupported(ext);

        }

        public void registerFileProvidersTiled(Class<?> provider) {

                getManager().registerFileProvidersTiled(provider);

        }

        public void registerTileProviderFormats(Class<?> c) {

                getManager().registerTileProviderFormats(c);

        }

}