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

import java.awt.geom.AffineTransform;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.util.HashMap;

import java.util.Set;

import org.cresques.cts.IProjection;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.coverage.filter.FilterLoader;

import org.gvsig.fmap.dal.coverage.grid.RasterFilterList;

import org.gvsig.fmap.dal.coverage.grid.render.ImageDrawer;

import org.gvsig.fmap.dal.coverage.process.TaskEventManager;

import org.gvsig.fmap.dal.coverage.process.overview.OverviewBuilder;

import org.gvsig.fmap.dal.coverage.process.vector.Vectorization;

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.raster.impl.buffer.DefaultDataServerWriter;

import org.gvsig.raster.impl.buffer.DefaultRasterQuery;

import org.gvsig.raster.impl.buffer.RasterBuffer;

import org.gvsig.raster.impl.buffer.RasterMemoryBuffer;

import org.gvsig.raster.impl.buffer.cache.RasterCache;

import org.gvsig.raster.impl.buffer.cache.RasterReadOnlyBuffer;

import org.gvsig.raster.impl.datastruct.DefaultDataStructFactory;

import org.gvsig.raster.impl.datastruct.legend.GimpGradients;

import org.gvsig.raster.impl.datastruct.legend.GimpPalettes;

import org.gvsig.raster.impl.datastruct.legend.LegendgvSIG;

import org.gvsig.raster.impl.datastruct.legend.RasterLegendIO;

import org.gvsig.raster.impl.grid.filter.DefaultRasterFilterList;

import org.gvsig.raster.impl.grid.filter.FilterLoaderImpl;

import org.gvsig.raster.impl.grid.render.ImageDrawerImpl;

import org.gvsig.raster.impl.grid.roi.ROIStatistic;

import org.gvsig.raster.impl.grid.roi.VectorialROIImpl;

import org.gvsig.raster.impl.grid.roi.VectorialROIsReader;

import org.gvsig.raster.impl.grid.roi.VectorialROIsWriter;

import org.gvsig.raster.impl.process.DefaultTaskEventManager;

import org.gvsig.raster.impl.process.RasterTask;

import org.gvsig.raster.impl.process.RasterTaskQueue;

import org.gvsig.raster.impl.process.vector.PotraceVectorization;

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

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

import org.gvsig.raster.impl.store.writer.DefaultRasterWriter;

import org.gvsig.raster.roi.AbstractROI;

import org.gvsig.raster.roi.ROIReader;

import org.gvsig.raster.roi.ROIWriter;

import org.gvsig.raster.roi.VectorialROI;

import org.gvsig.raster.util.DefaultColorConversion;

import org.gvsig.raster.util.DefaultFileUtils;

import org.gvsig.raster.util.DefaultHistorical;

import org.gvsig.raster.util.DefaultMathUtils;

import org.gvsig.raster.util.DefaultProviderServices;

import org.gvsig.raster.util.DefaultRasterUtils;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.extensionpoint.ExtensionPointManager;

import org.gvsig.tools.service.ServiceException;

/**

 * Default {@link RasterManager} implementation.

 * 

 * @author gvSIG Team

 * @version $Id$

 */

public class DefaultRasterManager implements RasterManager {

        private static DefaultRasterManager internalInstance  = new DefaultRasterManager();

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

        private FileUtils                   file              = null;

        private MathUtils                   math              = null;

        private RasterUtils                 util              = null;

        private ProviderServices            pInfo             = null;

        private DefaultColorConversion      colorConversion   = null;

        private DataStructFactory           dataStructFactory = null;

        public static HashMap<String, OverviewBuilder>

                                                                            overviewBuilderRegistry   = new HashMap<String, OverviewBuilder>();

        public static CRSUtils              crsUtilRegistry   = null;

        /**

         * Gets an instance of this object for internal use.

         * @return DefaultRasterManager

         */

        public static DefaultRasterManager getInstance() {

                return internalInstance;

        }

        public DataStructFactory getDataStructFactory() {

                if(dataStructFactory == null)

                        dataStructFactory = new DefaultDataStructFactory();

                return dataStructFactory;

        }

        public ProviderServices getProviderServices() {

                if(pInfo == null)

                        pInfo = new DefaultProviderServices();

                return pInfo;

        }

        public boolean isCRSUtilSupported() {

                return crsUtilRegistry != null;

        }

        public CRSUtils getCRSUtils() {

                return crsUtilRegistry;

        }

        public FileUtils getFileUtils() {

                if(file == null)

                        file = new DefaultFileUtils();

                return file;

        }

        public RasterUtils getRasterUtils() {

                if(util == null)

                        util = new DefaultRasterUtils();

                return util;

        }

        public MathUtils getMathUtils() {

                if(math == null)

                        math = new DefaultMathUtils();

                return math;

        }

    public RasterService getRasterService()

        throws ServiceException {

        RasterService fc = new DefaultRasterService(this);

        return fc;

    }

        public String[] getLegendFormats() {

                return RasterLegendIO.formats;

        }

        public RasterLegend getRasterLegendIO(String formatName) throws RasterLegendIONotFound {

                if (formatName.equals(RasterLegendIO.formats[0]))

                        return new LegendgvSIG();

                if (formatName.equals(RasterLegendIO.formats[1]))

                        return new GimpGradients();

                if (formatName.equals(RasterLegendIO.formats[2]))

                        return new GimpPalettes();

                // Incluir mas formatos de la misma manera

                throw new RasterLegendIONotFound();

        }

        public DataServerWriter createDataServerWriter() {

                return new DefaultDataServerWriter();

        }

        public RasterQuery createQuery() {

                return new DefaultRasterQuery();

        }

        public Buffer createBuffer(int dataType, int width, int height, int bandNr, boolean malloc) {

                //Opci?n de cachear siempre activada (Solo DEBUG)

                if(RasterBuffer.forceToLoadInCache)

                        return new RasterCache(dataType, width, height, bandNr);

                if(RasterBuffer.forceToLoadInReadOnlyCache){

                return new RasterReadOnlyBuffer(dataType, width, height, bandNr);

                }

                if(RasterBuffer.cacheOn){

                        long size = (long)((long)getRasterUtils().getBytesFromRasterBufType(dataType) * (long)width * (long)height * (long)bandNr) / 1024L;

                        long ms1 = RasterLibrary.cacheSize * 1024L;

                        if(size <= ms1)

                                return new RasterMemoryBuffer(dataType, width, height, bandNr, malloc);

                        else

                                return new RasterCache(dataType, width, height, bandNr);

                }else

                        return new RasterMemoryBuffer(dataType, width, height, bandNr, malloc);

        }

        public Buffer createReadOnlyBuffer(int dataType, int width, int height, int bandNr) {

                return new RasterReadOnlyBuffer(dataType, width, height, bandNr);

        }

        public Buffer createMemoryBuffer(int dataType, int width, int height, int bandNr, boolean malloc) {

                return new RasterMemoryBuffer(dataType, width, height, bandNr, malloc);

        }

        public RasterWriter createWriter(String fName) throws NotSupportedExtensionException, RasterDriverException {

                String ext = getFileUtils().getExtensionFromFileName(fName);

                DefaultRasterWriter grw = null;

                ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

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

//                ExtensionPoint extensionPoint = ExtensionPoint.getExtensionPoint("RasterWriter");

                if (!point.has(ext))

                        return grw;

                Class<?> clase = point.get(ext).getExtension();

                Class<?>[] args = { String.class };

                try {

                        Constructor<?> hazNuevo = clase.getConstructor(args);

                        Object[] args2 = { fName };

                        grw = (DefaultRasterWriter) hazNuevo.newInstance(args2);

                } catch (SecurityException e) {

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

                } catch (NoSuchMethodException e) {

                        throw new RasterDriverException("Error NoSuchMethodException in open", e);

                } catch (IllegalArgumentException e) {

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

                } catch (InstantiationException e) {

                        throw new RasterDriverException("Error InstantiationException in open", e);

                } catch (IllegalAccessException e) {

                        throw new RasterDriverException("Error IllegalAccessException in open", e);

                } catch (InvocationTargetException e) {

                        throw new NotSupportedExtensionException("Error in open", e);

                }

                return grw;

        }

        public RasterWriter createWriter(DataServerWriter dataWriter,

                                                                                                 String outFileName,

                                                                                                 int nBands,

                                                                                                 AffineTransform at,

                                                                                                 int outSizeX,

                                                                                                 int outSizeY,

                                                                                                 int dataType,

                                                                                                 Params params,

                                                                                                 IProjection proj) throws NotSupportedExtensionException, RasterDriverException {

                return createWriter(dataWriter, outFileName, nBands, at, outSizeX, outSizeY, dataType, params, proj, true);

        }

        public RasterWriter createWriter(DataServerWriter dataWriter,

                                                                                                 String outFileName,

                                                                                                 int nBands,

                                                                                                 AffineTransform at,

                                                                                                 int outSizeX,

                                                                                                 int outSizeY,

                                                                                                 int dataType,

                                                                                                 Params params,

                                                                                                 IProjection proj,

                                                                                                 boolean geo) throws NotSupportedExtensionException, RasterDriverException {

                String ext = outFileName.toLowerCase().substring(outFileName.lastIndexOf('.') + 1);

                DefaultRasterWriter grw = null;

                ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

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

                if (!point.has(ext))

                        return grw;

                Class<?> clase = point.get(ext).getExtension();

                Class<?>[] args = { DataServerWriter.class, String.class, Integer.class, AffineTransform.class, Integer.class, Integer.class, Integer.class, Params.class, IProjection.class, Boolean.class };

                try {

                        Constructor<?> hazNuevo = clase.getConstructor(args);

                        Object [] args2 = {dataWriter, outFileName, new Integer(nBands), at,

                                                                new Integer(outSizeX), new Integer(outSizeY), new Integer(dataType),

                                                                params, proj, new Boolean(geo)};

                        grw = (DefaultRasterWriter) hazNuevo.newInstance(args2);

                } catch (SecurityException e) {

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

                } catch (NoSuchMethodException e) {

                        throw new RasterDriverException("Error NoSuchMethodException in open", e);

                } catch (IllegalArgumentException e) {

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

                } catch (InstantiationException e) {

                        throw new RasterDriverException("Error InstantiationException in open", e);

                } catch (IllegalAccessException e) {

                        throw new RasterDriverException("Error IllegalAccessException in open", e);

                } catch (InvocationTargetException e) {

                        throw new NotSupportedExtensionException("Error in open. Problemas con las librer?as nativas.", e);

                }

                return grw;

        }

        public Params createWriterParams(String fileName) {

                try {

                        return createWriter(fileName).getParams();

                } catch (NotSupportedExtensionException e) {

                        return null;

                } catch (RasterDriverException e) {

                        return null;

                }

        }

        /**

         * Gets an object which vectorize a raster

         * @param dataStore

         * @return

         * @throws RasterDriverException

         * @throws ProcessInterruptedException

         *         When the object Vectorization is built the raster data buffer is loaded. 

         *         This operation can be interrupted

         */

        public Vectorization getVectorizeObject(QueryableRaster queryable) throws QueryException, ProcessInterruptedException {

                return new PotraceVectorization(queryable);

        }

        public OverviewBuilder getOverviewBuilder(String id) {

                return overviewBuilderRegistry.get(id);

        }

        public boolean isOverviewBuilderSupported() {

                return overviewBuilderRegistry.size() > 0;

        }

        public Set<String> getOverviewBuilderKeyList() {

                return overviewBuilderRegistry.keySet();

        }

        public FilterLoader createFilterLoader(int dataType) {

                return new FilterLoaderImpl(dataType);

        }

        public FilterLoader createFilterLoader(RasterFilterList filterList) {

                return new FilterLoaderImpl(filterList);

        }

    public Historical createHistoricalService() {

            return new DefaultHistorical();

    }

    public ColorConversion getColorConversion() {

            if(colorConversion == null)

                    colorConversion = new DefaultColorConversion();

            return colorConversion;

    }

        public Statistics createROIStatistics(AbstractROI roi) {

                return new ROIStatistic(roi);

        }

        public RasterFilterList createEmptyFilterList(int type) {

                DefaultRasterFilterList fl = new DefaultRasterFilterList();

                fl.setInitDataType(type);

                return fl;

        }

        public TaskEventManager getRasterTask() {

                return DefaultTaskEventManager.get();

        }

        public TaskEventManager createRasterTask(Object process) {

                RasterTask task = RasterTaskQueue.getRasterTask(Thread.currentThread().getId() + "");

                if(task != null) {

                        DefaultTaskEventManager man = new DefaultTaskEventManager();

                        man.setTask(task);

                        return man;

                }

                DefaultTaskEventManager man = new DefaultTaskEventManager(process);

                return man;

        }

        /**

         * Builds a new parameter object. These parameters represents the fieds of a filter

         * panel.

         * @param id

         * @param value

         * @param type

         * @param list

         * @return

         */

        public Params createParams(String id, Object value, int type, String[] list) {

                ParamsImpl params = new ParamsImpl();

                params.setParam(id, 

                                value, 

                                type, 

                                list);

                return params;

        }

        public ImageDrawer createImageDrawerService() {

                return new ImageDrawerImpl();

        }

        public BufferFactory getBufferFactory() {

                return new BufferFactoryImpl();

        }

        public ROIReader createROIReader(String filename, RasterDataStore store,

                        IProjection projection) throws ROIException, FileNotExistsException {

                //Actualmente solo puede ser vectorial pero filename puede ser raster tambi?n

                return new VectorialROIsReader(filename, store, projection);

        }

        public ROIWriter createROIWriter(String filename, IProjection projection) {

                //Actualmente solo puede ser vectorial pero filename puede ser raster tambi?n

                return new VectorialROIsWriter(filename, projection);

        }

        public VectorialROI createVectorialROI(RasterDataStore store) {

                return new VectorialROIImpl(store);

        }

        public ROIReader createVectorialROIReader(FeatureStore roiStore,

                        RasterDataStore store, IProjection projection) {

                return new VectorialROIsReader(roiStore, store, projection);

        }

}