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

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICRSFactory;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.crs.CRSFactory;

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

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

            String fname = getFileName(params);

            setFName(fname);

            file = new GdalDataSource(fname);

            setColorInterpretation(file.colorInterpr);

            setColorTable(file.palette);

            noData = file.getNoDataValue();

            ICRSFactory crsFactory = CRSFactory.getCRSFactory();

            IProjection proj = params.getSRS();

            if (proj == null) {

                File prjFile = getPrjFile(params.getURI());

                if (prjFile.exists()) {

                    String wktEsri = loadPrj(prjFile);

                    if (wktEsri != null) {

                        proj = crsFactory.get(ICRSFactory.FORMAT_WKT_ESRI,

                            wktEsri);

                    }

                }

            }

            if (proj == null) {

                String wktProjection = file.getProjectionRef();

                if (!StringUtils.isEmpty(wktProjection) ) {

                    try {

                        proj = crsFactory.get(ICRSFactory.FORMAT_WKT, wktProjection);

                        setProjection(proj, true);

                        if ( StringUtils.isEmpty( proj.getAbrev()) ){

                            proj=null;

                        } else {

                            setProjection(proj, true);

                        }

                    } catch (Exception e ) {

                        proj=null;

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

                    }

                }

            } else {

                setProjection(proj, false);

            }

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

        }

    }

    private String getFileName(RasterDataParameters params) throws GdalException {

        File f = new File(params.getURI());

        validRmf(f.getAbsolutePath());

        return translateFileName(f.getAbsolutePath());

    }

    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) {

        String absolutePath = new File(uri).getAbsolutePath();

        if ("hdr".equalsIgnoreCase(FilenameUtils.getExtension(absolutePath))) {

            File file = new File(FilenameUtils.removeExtension(absolutePath));

            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

    }

    private File getPrjFile(URI uri) {

        if ("file".equalsIgnoreCase(uri.getScheme())) {

            String uriPath = new File(uri).getAbsolutePath();

            String prjPath = FilenameUtils.removeExtension(uriPath) + ".prj";

            return new File(prjPath);

        }

        return null;

    }

    ;

    private String loadPrj(File prjFile) {

        if (prjFile.exists()) {

            try {

                return FileUtils.readFileToString(prjFile);

            } catch (IOException e) {

                return null;

            }

        }

        return null;

    }

}