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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * 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 GdalNative        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[] {

                                "bmp", 

                                "gif",

                                "tif",

                                "tiff",

                                "jpg",

                                "jpeg",

                                "png",

                                "vrt",

                                "dat", // Envi

                                "lan", // Erdas

                                "gis", // Erdas

                                "img", // Erdas

                                "pix", // PCI Geomatics

                                "aux", // PCI Geomatics

                                "adf", // ESRI Grids

                                "mpr", // Ilwis

                                "mpl", // Ilwis

                                "map", // PC Raster

                                "asc",

                                "pgm", //Ficheros PNM en escala de grises

                                "ppm", //Ficheros PNM en RGB

                                "rst", //IDRISIS

                                "rmf", //Raster Matrix Format

                                "nos",

                                "kap",

                                "hdr",

                                "raw",

                                "ers",

                                "xml",

                                "grd",

                                "txt"/*,

                                "jp2"*/};

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

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

        }

        public String[] getFormatList() {

                return formatList;

        }

        /**

         * 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].compareTo(ext) == 0)

                                return true;

                }

                return false;

        }

        /**

         * Mandatory constructor to instantiate an empty provider

         */

        public GdalProvider() {

        }

        /**

         * Constructor. Abre el dataset.

         * @param proj Proyecci?n

         * @param fName Nombre del fichero

         * @throws NotSupportedExtensionException

         */

        public GdalProvider(String params) throws NotSupportedExtensionException {

                super(params);

                if(params instanceof String) {

                        GdalDataParameters p = new GdalDataParameters();

                        p.setURI((String)params);

                        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

         * @throws NotSupportedExtensionException

         */

        public void init (AbstractRasterDataParameters params,

                        DataStoreProviderServices storeServices) throws NotSupportedExtensionException {

                try {

                        setParam(storeServices, params);

                        validRmf(params.getURI());

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

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

//                        long ptro = aux.getPtro();

//                        aux.delete();

                        file = new GdalNative(translateFileName(params.getURI()));

                        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] = GdalNative.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);

                }

        }

        /**

         * 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 String translateFileName(String fileName) {

                if(fileName.endsWith("hdr"))

                        return fileName.substring(0, fileName.lastIndexOf("."));

                return fileName;

        }

        /**

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

         */

        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;

        }

        public GdalNative 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();

        }

}