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.gdal.io;

import java.awt.geom.AffineTransform;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

import java.net.URI;

import java.net.URISyntaxException;

import org.apache.commons.io.FilenameUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DALFileLocator;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStore;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.jgdal.GdalException;

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.raster.cache.tile.provider.TileServer;

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

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

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

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

import org.gvsig.raster.impl.provider.tile.FileTileServer;

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

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

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

import org.gvsig.raster.impl.store.properties.DataStoreMetadata;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.extensionpoint.ExtensionPointManager;

/**

 * This class represents the data access for gdal formats.

 *

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class GdalProvider extends AbstractRasterProvider {

        public static String        NAME                     = "Gdal Store";

        public static String        DESCRIPTION              = "Gdal Raster file";

        public static final String  METADATA_DEFINITION_NAME = "GdalStore";

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

        public static final String  FORMAT_GTiff    = "GTiff";

        public static final String  FORMAT_VRT      = "VRT";

        public static final String  FORMAT_NITF     = "NITF";

        public static final String  FORMAT_HFA      = "HFA";

        public static final String  FORMAT_ELAS     = "ELAS";

        public static final String  FORMAT_MEM      = "MEM";

        public static final String  FORMAT_BMP      = "BMP";

        public static final String  FORMAT_PCIDSK   = "PCIDSK";

        public static final String  FORMAT_ILWIS    = "ILWIS";

        public static final String  FORMAT_HDF4     = "HDF4Image";

        public static final String  FORMAT_PNM      = "PNM";

        public static final String  FORMAT_ENVI     = "ENVI";

        public static final String  FORMAT_EHDR     = "EHdr";

        public static final String  FORMAT_PAUX     = "PAux";

        public static final String  FORMAT_MFF      = "MFF";

        public static final String  FORMAT_MFF2     = "MFF2";

        public static final String  FORMAT_BT       = "BT";

        public static final String  FORMAT_IDA      = "IDA";

        public static final String  FORMAT_RMF      = "RMF";

        public static final String  FORMAT_RST      = "RST";

        public static final String  FORMAT_LEVELLER = "Leveller";

        public static final String  FORMAT_TERRAGEN = "Terragen";

        public static final String  FORMAT_ERS      = "ERS";

        public static final String  FORMAT_INGR     = "INGR";

        public static final String  FORMAT_GSAG     = "GSAG";

        public static final String  FORMAT_GSBG     = "GSBG";

        public static final String  FORMAT_ADRG     = "ADRG";

        public static final String  FORMAT_JP2      = "JPEG2000";

        public static final String  FORMAT_GRD      = "GRD";

        public static final int     BAND_HEIGHT     = 64;

        protected GdalDataSource        file            = null;

        private Extent              viewRequest     = null;

        protected static String[][]   formatList      = null;

        public static void register() {

                ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

                registerFormats();

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

                point.append("reader", GdalProvider.NAME, GdalProvider.class);

                RasterLocator.getManager().getProviderServices().registerFileProvidersTiled(GdalProvider.class);

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

                if (dataman != null && !dataman.getStoreProviders().contains(NAME)) {

                        dataman.registerStoreProvider(NAME,

                                        GdalProvider.class, GdalDataParameters.class);

                }

                if(DALFileLocator.getFilesystemServerExplorerManager() != null)

                        DALFileLocator.getFilesystemServerExplorerManager().registerProvider(

                                        NAME, DESCRIPTION,

                                        GdalFilesystemServerExplorer.class);

                dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

        }

        private static void registerFormats() {

                formatList      = new String[][] {

                                new String[] {"bmp","image/bmp" },

                                new String[] {"gif","image/gif" },

                                new String[] {"tif","image/tiff" },

                                new String[] {"tiff","image/tiff" },

                                new String[] {"jpg","image/jpeg" },

                                new String[] {"jpeg","image/jpeg" },

                                new String[] {"png","image/png" },

                                new String[] {"vrt","image/vrt" },

                                new String[] {"dat","image/dat" }, // Envi

                                new String[] {"lan","image/lan" }, // Erdas

                                new String[] {"gis","image/gis" }, // Erdas

                                new String[] {"img","image/img" }, // Erdas

                                new String[] {"pix", "image/pix" },// PCI Geomatics

                                new String[] {"aux","image/aux" }, // PCI Geomatics

                                new String[] {"adf","image/adf" }, // ESRI Grids

                                new String[] {"mpr","image/mpr" }, // Ilwis

                                new String[] {"mpl","image/mpl" }, // Ilwis

                                new String[] {"map", "image/map" },// PC Raster

                                new String[] {"asc","image/asc" },

                                new String[] {"pgm", "image/pgn" },//Ficheros PNM en escala de grises

                                new String[] {"ppm", "image/ppm" },//Ficheros PNM en RGB

                                new String[] {"rst", "image/rst" },//IDRISIS

                                new String[] {"rmf", "image/rmf" },//Raster Matrix Format

                                new String[] {"nos","image/nos" },

                                new String[] {"kap","image/kap" },

                                new String[] {"hdr","image/hdr" },

                                new String[] {"raw","image/raw" },

                                new String[] {"ers","image/ers" },

                                new String[] {"xml","image/xml" },

                                new String[] {"grd","image/grd" },

                                /*

                                new String[] {"jp2","image/jp2" },

                                new String[] {"mrsid","image/mrsid" },

                                new String[] {"ecw","image/ecw" },

                                */

                                new String[] {"txt","image/txt" }

                            };

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

                        RasterLocator.getManager().getProviderServices().addFormat(formatList[i][0], GdalProvider.class);

        }

        public String[] getFormatList() {

            String[] fl = new String[formatList.length];

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

                fl[i] = formatList[i][0];

            }

            return fl;

        }

        /**

         * Returns true if the extension is supported and false if doesn't

         * @param ext

         * @return

         */

        public boolean isExtensionSupported(String ext) {

                if(ext.indexOf(".") != -1)

                        ext = ext.substring(ext.lastIndexOf(".") + 1, ext.length());

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

                        if(formatList[i][0].compareTo(ext) == 0)

                                return true;

                }

                return false;

        }

        /**

         * Mandatory constructor to instantiate an empty provider

         */

        public GdalProvider() {

        }

        /**

         * Constructor. Abre el dataset.

     * @param params

         * @throws NotSupportedExtensionException

         * @throws OpenException

     * @deprecated use {@link #GdalProvider(URI)}, this constructor will be removed in gvSIG 2.5

         */

        public GdalProvider(String params) throws NotSupportedExtensionException, OpenException {

                super(params);

        logger.info("Deprecated use of GdalProvider constructor");

                if(params instanceof String) {

                        GdalDataParameters p = new GdalDataParameters();

                        URI uriParam;

            try {

                uriParam = new URI((String)params);

            } catch (URISyntaxException e) {

                throw new OpenException("Can't create uri from "+(String)params, e);

            }

                        p.setURI(uriParam);

                        super.init(p, null, ToolsLocator.getDynObjectManager()

                                        .createDynObject(

                                                        MetadataLocator.getMetadataManager().getDefinition(

                                                                        DataStore.METADATA_DEFINITION_NAME)));

                        init(p, null);

                }

        }

         /**

     * Constructor. Abre el dataset.

     * @param uri

     * @throws NotSupportedExtensionException

     */

    public GdalProvider(URI uri) throws NotSupportedExtensionException {

        super(uri);

        GdalDataParameters p = new GdalDataParameters();

        p.setURI(uri);

        super.init(

            p,

            null,

            ToolsLocator.getDynObjectManager().createDynObject(

                MetadataLocator.getMetadataManager().getDefinition(DataStore.METADATA_DEFINITION_NAME)));

        init(p, null);

    }

    public GdalProvider (GdalDataParameters params,

                        DataStoreProviderServices storeServices) throws NotSupportedExtensionException {

                super(params, storeServices, ToolsLocator.getDynObjectManager()

                                .createDynObject(

                                                MetadataLocator.getMetadataManager().getDefinition(

                                                                DataStore.METADATA_DEFINITION_NAME)));

                init(params, storeServices);

        }

        public GdalProvider(AbstractRasterDataParameters params,

                        DataStoreProviderServices storeServices, DynObject metadata) {

                super(params, storeServices, metadata);

        }

        /**

         * Creates file references and loads structures with the information and metadata

         * @param params load parameters

     * @param storeServices

         * @throws NotSupportedExtensionException

         */

        public void init (AbstractRasterDataParameters params,

                        DataStoreProviderServices storeServices) throws NotSupportedExtensionException {

                try {

                        setParam(storeServices, params);

                        validRmf(params.getURI().getPath());

                        setFName(translateFileName(params.getURI().getPath()));

//                        GdalNative aux = new GdalNative(translateFileName(params.getURI()));

//                        long ptro = aux.getPtro();

//                        aux.delete();

                        file = new GdalDataSource(translateFileName(params.getURI().getPath()));

                        setColorInterpretation(file.colorInterpr);

                        setColorTable(file.palette);

                        noData = file.getNoDataValue();

                        String wktProjection = file.getProjectionRef();

                        if(wktProjection != null && wktProjection != "") {

                                try {

                                        if(RasterLocator.getManager().isCRSUtilSupported())

                                                proj = RasterLocator.getManager().getCRSUtils().convertWktToIProjection(wktProjection);

                                } catch (Exception e) {

                                        logger.info("Error reading WKT from the raster provider", e);

                                }

                        }

                        //CrsWkt crs = new CrsWkt(wktProjection);

                        //IProjection proj = CRSFactory.getCRS("EPSG:23030");

                        ownTransformation = file.getOwnTransformation();

                        externalTransformation = (AffineTransform)ownTransformation.clone();

                        load();

                        if(file != null)

                                bandCount = file.getRasterCount();

                } catch (GdalException e) {

                        throw new NotSupportedExtensionException("Extension not supported", e);

                } catch(Exception e) {

                        System.out.println("Error en GdalOpen");

                        e.printStackTrace();

                        file = null;

                }

                //Obtenemos el tipo de dato de gdal y lo convertimos el de RasterBuf

                int[] dt = new int[file.getDataType().length];

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

                        dt[i] = GdalDataSource.getRasterBufTypeFromGdalType(file.getDataType()[i]);

                setDataType(dt);

                super.init();

                try {

                        loadFromRmf(getRmfBlocksManager());

                } catch (ParsingException e) {

                        //No lee desde rmf

                        logger.debug("Problems reading from the RMF file", e);

                }

        }

    public String getMimeType() {

        try {

            File f = ((FilesystemStoreParameters) (this.getDataStoreParameters())).getFile();

            String ext = FilenameUtils.getExtension(f.getName());

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

                if (ext.equalsIgnoreCase(formatList[i][0])) {

                    return formatList[i][1];

                }

            }

        } catch (Exception ex) {

            logger.warn("Can't get mime type for GDAL archive.",ex);

        }

        return "image";

    }

        /**

         * Comprueba si el fichero abierto es un RasterMetaFile o una imagen

         * raster.

         * @throws GdalException

         */

        private void validRmf(String file) throws GdalException {

                if(file.endsWith(".rmf")) {

                        File f = new File(file);

                        try {

                                FileReader fr = new FileReader(f);

                                BufferedReader br = new BufferedReader(fr);

                                char[] buffer = new char[5];

                                br.read(buffer);

                                StringBuffer st = new StringBuffer(new String(buffer));

                                br.close();

                                fr.close();

                                if(st.toString().equals("<?xml"))

                                        throw new GdalException("RasterMetaFile");

                        } catch (FileNotFoundException e) {

                                throw new GdalException("File Not Found");

                        } catch (IOException e) {

                                throw new GdalException("");

                        }

                }

        }

        public RasterProvider load() {

                return this;

        }

        public boolean isOpen() {

                if(file != null && file.isOpen())

                        return true;

                return false;

        }

        public URI translateURI(URI uri) {

        if ("hdr".equalsIgnoreCase(FilenameUtils.getExtension(uri.getPath()))) {

            File file = new File(FilenameUtils.removeExtension(uri.getPath()));

            return file.toURI();

        }

                return uri;

        }

        /**

         * Asigna el extent de la vista actual. existe un fichero .rmf debemos hacer una transformaci?n

         * de la vista asignada ya que la petici?n viene en coordenadas del fichero .rmf y la vista (v)

         * ha de estar en coordenadas del fichero.

     * @param e

         */

        public void setView(Extent e) {

                viewRequest = new ExtentImpl(e);

        }

        public Extent getView() {

                return viewRequest;

        }

        public double getWidth() {

                return file.width;

        }

        public double getHeight() {

                return file.height;

        }

        /**

         * Read a line from the file

         * @param line

         * @param band

         * @return

         * @throws InvalidSetViewException

         * @throws FileNotOpenException

         * @throws RasterDriverException

         * @Deprecated This operation is deprecated because is not useful and in the future

         * it will not be maintained. The abstract operation has dissapear

         */

        public Object readCompleteLine(int line, int band)throws InvalidSetViewException, FileNotOpenException, RasterDriverException {

                if(line > this.getHeight() || band > this.getBandCount())

                        throw new InvalidSetViewException("Request out of grid");

                try{

                        return file.readCompleteLine(line, band);

                }catch(GdalException e){

                        throw new RasterDriverException("Error reading data from Gdal library");

                }

        }

        public Object readBlock(int pos, int blockHeight, double scale)

                throws InvalidSetViewException, FileNotOpenException, RasterDriverException, ProcessInterruptedException {

                if(pos < 0)

                        throw new InvalidSetViewException("Request out of grid");

                if((pos + blockHeight) > getHeight())

                        blockHeight = Math.abs(((int)getHeight()) - pos);

                try{

                        return file.readBlock(pos, blockHeight, scale);

                }catch(GdalException e){

                        throw new RasterDriverException("Error reading data from Gdal library");

                }

        }

        public Object getData(int x, int y, int band)throws InvalidSetViewException, FileNotOpenException, RasterDriverException {

                if(file != null){

                        if(x < 0 || y < 0 || x >= file.width || y >= file.height)

                                throw new InvalidSetViewException("Request out of grid");

                        Object[] data = file.getData(x, y);

                        return data[band];

                }

                throw new FileNotOpenException("GdalNative not exist");

        }

        @Override

        public void loadBuffer(SpiRasterQuery q)

                        throws ProcessInterruptedException, RasterDriverException {

                setView(q.getAdjustedRequestBoundingBox());

                try {

                        file.readWindow(q.getBufferForProviders(),

                                        q.getBandList(),

                                        q.getAdjustedRequestBoundingBox(),

                                        q.getAdjustedRequestPxWindow(),

                                        q.getTaskStatus());

                } catch (GdalException e) {

                        throw new RasterDriverException("Error reading data", e);

                }

        }

        public int getBlockSize(){

                if(file != null)

                        return file.getBlockSize();

                else

                        return 0;

        }

        public DataStoreMetadata getMetadata() {

                if(file != null)

                        return file.metadata;

                else

                        return null;

        }

        public Transparency getTransparency() {

                return file.fileTransparency;

        }

        public boolean isGeoreferenced() {

                if(file != null)

                        return file.georeferenced;

                else

                        return false;

        }

        /**

         * Informa de si el driver ha supersampleado en el ?ltimo dibujado. Es el driver el que colocar?

         * el valor de esta variable cada vez que dibuja.

         * @return true si se ha supersampleado y false si no se ha hecho.

         */

        public boolean isSupersampling() {

                if(file != null)

                        return file.isSupersampling;

                else

                        return false;

        }

        protected GdalDataSource getNative(){

                return file;

        }

        public void setAffineTransform(AffineTransform t){

                super.setAffineTransform(t);

                file.setExternalTransform(t);

        }

        public int getOverviewCount(int band) throws BandAccessException, RasterDriverException {

                if(band >= getBandCount())

                        throw new BandAccessException("Wrong band");

                try {

                        return file.getRasterBand(band + 1).getOverviewCount();

                } catch (GdalException e) {

                        throw new RasterDriverException("");

                }

        }

        public int getOverviewWidth(int band, int overview) throws BandAccessException, RasterDriverException {

                if (band >= getBandCount())

                        throw new BandAccessException("Wrong band");

                try {

                        if (overview >= file.getRasterBand(band + 1).getOverviewCount())

                                throw new BandAccessException("Wrong overview count");

                        return file.getRasterBand(band + 1).getOverview(overview).getRasterBandXSize();

                } catch (GdalException e) {

                        throw new RasterDriverException("");

                }

        }

        public int getOverviewHeight(int band, int overview) throws BandAccessException, RasterDriverException {

                if (band >= getBandCount())

                        throw new BandAccessException("Wrong band");

                try {

                        if (overview >= file.getRasterBand(band + 1).getOverviewCount())

                                throw new BandAccessException("Wrong overview count");

                        return file.getRasterBand(band + 1).getOverview(overview).getRasterBandYSize();

                } catch (GdalException e) {

                        throw new RasterDriverException("");

                }

        }

        public boolean isOverviewsSupported() {

                return true;

        }

        public boolean isReproyectable() {

                return true;

        }

        public boolean needEnhanced() {

                return (getDataType()[0] != Buffer.TYPE_BYTE);

                //Desconozco pq raz?n estaba esta condici?n. Quiz?s haya que volver a a?adirla

                //Eliminada 30/5/2013

                //|| (getBandCount() == 1 && getDataType()[0] == Buffer.TYPE_BYTE));

        }

        public String getProviderName() {

                return NAME;

        }

        public void setStatus(RasterProvider provider) {

                if(provider instanceof GdalProvider) {

                        //Not implemented yet

                }

        }

        public TileServer getTileServer() {

                if(tileServer == null) {

                        DefaultRasterStore store = new DefaultRasterStore();

                        store.setProvider(this);

                        tileServer = new FileTileServer(store);

//                        tileServer.setFileSuffix("rmf");

                }

                return tileServer;

        }

        public void close() {

                if(file != null){

                        file.dispose();

                }

                try {

                        finalize();

                } catch (Throwable e) {

                }

        }

        protected void finalize() throws Throwable {

                file           = null;

                viewRequest    = null;

                if(formatList != null) {

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

                                formatList[i] = null;

                        }

                        formatList = null;

                }

                super.finalize();

        }

    public void addFile(File file) throws InvalidSourceException {

        // Do nothing

    }

    public void removeFile(File file) {

        // Do nothing

    }

}