Application: gvSIG desktop » gvSIG raster

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2016 gvSIG Association

 *

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.raster.gdal.provider;

import java.io.File;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Vector;

import org.apache.commons.io.FilenameUtils;

import org.cresques.cts.IProjection;

import org.gdal.gdal.Band;

import org.gdal.gdal.Dataset;

import org.gdal.gdal.GCP;

import org.gdal.gdal.gdal;

import org.gdal.gdalconst.gdalconstConstants;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreNotification;

import org.gvsig.fmap.dal.FileHelper;

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

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

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

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

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

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

import org.gvsig.fmap.dal.raster.api.BandAttributeDescriptor;

import org.gvsig.fmap.dal.raster.api.BandDescriptor;

import org.gvsig.fmap.dal.raster.api.RasterQuery;

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

import org.gvsig.fmap.dal.resource.ResourceAction;

import org.gvsig.fmap.dal.resource.exception.AccessResourceException;

import org.gvsig.fmap.dal.resource.file.FileResource;

import org.gvsig.fmap.dal.resource.spi.ResourceConsumer;

import org.gvsig.fmap.dal.resource.spi.ResourceProvider;

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.metadata.MetadataManager;

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.raster.lib.buffer.api.BandInfo;

import org.gvsig.raster.lib.buffer.api.Buffer;

import org.gvsig.raster.lib.buffer.api.BufferLocator;

import org.gvsig.raster.lib.buffer.api.BufferManager;

import org.gvsig.raster.lib.buffer.api.NoData;

import org.gvsig.raster.lib.buffer.api.PageManager;

import org.gvsig.raster.lib.buffer.api.exceptions.BufferException;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.exception.DynFieldNotFoundException;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Provider for Raster GDAL files

 * @author dmartinezizquierdo

 *

 */

public class RasterGdalStoreProvider extends AbstractRasterStoreProvider implements

ResourceConsumer{

    private static final Logger logger =

        LoggerFactory.getLogger(RasterGdalStoreProvider.class);

    public static String NAME = "RasterGdal";

    public static String DESCRIPTION = "Raster GDAL file";

    public static final String METADATA_DEFINITION_NAME = NAME;

    private ResourceProvider resource;

    private final SimpleTaskStatus taskStatus;

    private Envelope envelope = null;

    private IProjection projection= null;

    private Dataset gdalDataSet;

    public Dataset getGdalDataSet() {

        return gdalDataSet;

    }

    protected static void registerMetadataDefinition()

        throws MetadataException {

        MetadataManager manager = MetadataLocator.getMetadataManager();

        if (manager.getDefinition(METADATA_DEFINITION_NAME) == null) {

            manager.addDefinition(METADATA_DEFINITION_NAME,

                RasterGdalStoreProviderParameters.class

                    .getResourceAsStream("RasterGdalMetadata.xml"),

                RasterGdalStoreProviderParameters.class.getClassLoader());

        }

    }

    public RasterGdalStoreProvider(RasterGdalStoreProviderParameters params,

        DataStoreProviderServices storeServices)

        throws InitializeException {

        super(

                params,

                storeServices,

                FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME)

        );

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

        this.taskStatus = manager.createDefaultSimpleTaskStatus("RasterGdal");

        this.init(params, storeServices);

    }

    protected RasterGdalStoreProvider(RasterGdalStoreProviderParameters params,

            DataStoreProviderServices storeServices, DynObject metadata)

            throws InitializeException {

        super(params, storeServices, metadata);

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

        this.taskStatus = manager.createDefaultSimpleTaskStatus("RasterGdal");

        this.init(params, storeServices);

    }

    protected void init(RasterGdalStoreProviderParameters params,

        DataStoreProviderServices storeServices) throws InitializeException {

        if (params == null) {

            throw new InitializeException(

                new NullPointerException("params is null"));

        }

        File file = getRasterGdalParameters().getFile();

        if (file == null) {

            throw new InitializeException(

                new NullPointerException("Raster GDAL file is null"));

        }

        this.projection=params.getCRS();

        resource = this.createResource(

            FileResource.NAME,

            new Object[] { file.getAbsolutePath() }

        );

        resource.addConsumer(this);

    }

    private RasterGdalStoreProviderParameters getRasterGdalParameters() {

        return (RasterGdalStoreProviderParameters) this.getParameters();

    }

    @Override

    public Buffer createBuffer(RasterQuery rasterQuery) throws BufferException {

        int bandCount=gdalDataSet.getRasterCount();

        BufferManager bufferManager=BufferLocator.getBufferManager();

        int[] bandDataTypes=new int[bandCount];

        NoData[] bandNoData=new NoData[bandCount];

        List<PageManager> pageManagers=new ArrayList<PageManager>();

        for (int i=0;i<bandCount;i++){

            //Gdal bands begin count in 1

            int gdalBandNumber=i+1;

            Band gdalBand=gdalDataSet.GetRasterBand(gdalBandNumber);

            bandDataTypes[i]=getRasterBufTypeFromGdalType(gdalBand.getDataType());

            Double noData=getNoData(gdalBand);

            if (noData!=null){

                bandNoData[i]=bufferManager.createNoData(noData, noData);

            }else{

                bandNoData[i]=null;

            }

            pageManagers.add(new RasterGdalBandPageManager(gdalDataSet, gdalBandNumber));

        }

        Buffer buffer =

            bufferManager.createBuffer(gdalDataSet.getRasterYSize(), gdalDataSet.getRasterXSize(),

                bandDataTypes, bandNoData, projection, envelope, pageManagers);

        return buffer;

    }

    @Override

    public BandInfo getBandInfo(int band) {

        RasterGdalBandPageManager gdalBandPageManager =

            new RasterGdalBandPageManager(gdalDataSet, band + 1); // Gdal bands start at 1

        return gdalBandPageManager.getBandInfo();

    }

    @Override

    public BandDescriptor getBandDescriptor(int band) {

        // Returns an empty band descriptor

        return getStoreServices().createBandDescriptor(band,

            new ArrayList<BandAttributeDescriptor>(0));

    }

    @Override

    public int getBands() {

        return gdalDataSet.getRasterCount();

    }

    private Double getNoData(Band gdalBand){

        Double[] noDataValueResult=new Double[1];

        gdalBand.GetNoDataValue(noDataValueResult);

        Double noData=noDataValueResult[0];

        return noData;

    }

    @Override

    public DataServerExplorer getExplorer()

        throws ReadException, ValidateDataParametersException {

        DataManager manager = DALLocator.getDataManager();

        FilesystemServerExplorerParameters params;

        try {

            params = (FilesystemServerExplorerParameters) manager

            .createServerExplorerParameters(FilesystemServerExplorer.NAME);

            params.setRoot(this.getRasterGdalParameters().getFile().getParent());

            return manager.openServerExplorer(FilesystemServerExplorer.NAME,params);

        } catch (DataException e) {

            throw new ReadException(this.getProviderName(), e);

        } catch (ValidateDataParametersException e) {

            throw new ReadException(this.getProviderName(), e);

        }

    }

    public void open() throws OpenException {

        if (this.gdalDataSet != null) {

            return;

        }

        openEver();

    }

    private void openEver() throws OpenException {

        try {

            getResource().execute(new ResourceAction() {

                public Object run() throws Exception {

                    gdalDataSet = gdal.Open(

                        getRasterGdalParameters().getFile().getAbsolutePath(),

                        gdalconstConstants.GA_ReadOnly);

                    resource.notifyOpen();

                    envelope = createEnvelope(getGeoTransform());

                    if (envelope == null) {

                        // If couldn't be possible to create an envelope,

                        // this is created at 0,0 coordinates.

                        envelope = GeometryLocator.getGeometryManager()

                            .createEnvelope(0, 0, gdalDataSet.getRasterXSize(),

                                gdalDataSet.getRasterYSize(),

                                Geometry.SUBTYPES.GEOM2D);

                    }

                    resource.notifyClose();

                    resource.setData(gdalDataSet);

                    return null;

                }

            });

        } catch (Exception e) {

            this.gdalDataSet = null;

            try {

                throw new OpenException(resource.getName(), e);

            } catch (AccessResourceException e1) {

                throw new OpenException(getProviderName(), e);

            }

        } finally {

            this.taskStatus.remove();

        }

    }

    private double[] getGeoTransform(){

        double[] geotransform = null;

        double[] defaultGeotransform =

            { 0.0, 1.0, 0.0, 0.0, 0.0, 1.0 };

        // Try to create an Envelope through geolocalization

        // methods

        if (getRasterGdalParameters().getWldParams() != null) {

            // Try to get a geotransform from wld file

            List<String> wldParams =

                getRasterGdalParameters().getWldParams();

            double pixelSizeX =

                Double.valueOf(wldParams.get(0));

            double rotationAxisY =

                Double.valueOf(wldParams.get(1));

            double rotationAxisX =

                Double.valueOf(wldParams.get(2));

            double pixelSizeY =

                -Double.valueOf(wldParams.get(3));

            double upperLeftPixelCenterCoordX =

                Double.valueOf(wldParams.get(4));

            double upperLeftPixelCenterCoordY =

                Double.valueOf(wldParams.get(5));

            geotransform = new double[6];

            // Info found at:

            // http://www.gdal.org/gdal_8h.html#adae2ed5807e4ec288812b54c6fccda1e

            // and http://www.gdal.org/gdal_tutorial.html

            // GDALReadWorldFile

            geotransform[0] = upperLeftPixelCenterCoordX

                - (pixelSizeX * 0.5) - (rotationAxisX * 0.5);

            geotransform[1] = pixelSizeX;

            geotransform[2] = rotationAxisX;

            geotransform[3] = upperLeftPixelCenterCoordY

                - (pixelSizeY * 0.5) - (rotationAxisY * 0.5);

            geotransform[4] = pixelSizeY;

            geotransform[5] = rotationAxisY;

        } else if (geotransform == null) {

            // Try to get a geotransform from the file

            geotransform = gdalDataSet.GetGeoTransform();

        }

        // Try to get a geotransform from GCPs in the file

        if (Arrays.equals(defaultGeotransform, geotransform)) {

            Vector vectorGCPs = gdalDataSet.GetGCPs();

            GCP[] gcps = new GCP[gdalDataSet.GetGCPCount()];

            for (int i = 0; i < gdalDataSet

                .GetGCPCount(); i++) {

                gcps[i] = (GCP) vectorGCPs.get(i);

            }

            double[] gcpsGeotransform = new double[6];

            int isOK =

                gdal.GCPsToGeoTransform(gcps, gcpsGeotransform);

            if (isOK != 0) {

                geotransform = gcpsGeotransform;

            }

        }

        return geotransform;

    }

    private Envelope createEnvelope(double[] geotransform){

        double leftMostX        = geotransform[0];/* top left x */

        double pixelSizeX       = geotransform[1];/* w-e pixel resolution */

        double rotationAxisX    = geotransform[2];/* 0 */

        double upperMostY       = geotransform[3];/* top left y */

        double rotationAxisY    = geotransform[4];/* 0 */

        double pixelSizeY       = geotransform[5];/* n-s pixel resolution (negative value) */

        if (0.0 != rotationAxisX || 0.0 != rotationAxisY) {

            logger.warn(

                "Rotation in wld file not implemented yet. It will be ignored");

        }

        double width =gdalDataSet.getRasterXSize()*pixelSizeX;

        double height=gdalDataSet.getRasterYSize()*pixelSizeY;

        // double minX, double minY, double maxX, double maxY, int subType

        try {

            envelope = GeometryLocator.getGeometryManager().createEnvelope(

                Math.min(leftMostX,leftMostX + width),

                Math.min(upperMostY,upperMostY + height),

                Math.max(leftMostX,leftMostX + width),

                Math.max(upperMostY,upperMostY + height),

                Geometry.SUBTYPES.GEOM2D);

        } catch (LocatorException | CreateEnvelopeException e) {

            logger.warn(

                "Failed to create envelope from wld file with coords: minx:"+leftMostX+

                ", miny:"+upperMostY+", maxX: "+leftMostX + width+", maxY: "+upperMostY + height);

            e.printStackTrace();

        }

        return envelope;

    }

    @Override

    public Object getDynValue(String name) throws DynFieldNotFoundException {

        if( DataStore.METADATA_ENVELOPE.equalsIgnoreCase(name) ) {

            return this.envelope;

        } else if( DataStore.METADATA_CRS.equalsIgnoreCase(name) ) {

            IProjection pro = this.getRasterGdalParameters().getCRS();

            if (pro != null) {

                return pro;

            }

        }

        return super.getDynValue(name);

    }

    @Override

    public void close() throws CloseException {

        this.gdalDataSet = null;

    }

    @Override

    public ResourceProvider getResource() {

        return this.resource;

    }

    @Override

    public Object getSourceId() {

        return this.getRasterGdalParameters().getFile();

    }

    @Override

    public String getProviderName() {

        return NAME;

    }

    @Override

    public String getName() {

        String name = this.getRasterGdalParameters().getFile().getName();

        return FilenameUtils.getBaseName(name);

    }

    @Override

    public String getFullName() {

        return this.getRasterGdalParameters().getFile().getAbsolutePath();

    }

    @Override

    public boolean closeResourceRequested(ResourceProvider resource) {

        return true;

    }

    @Override

    /*

     * (non-Javadoc)

     *

     * @see

     * org.gvsig.fmap.dal.resource.spi.ResourceConsumer#resourceChanged(org.

     * gvsig.fmap.dal.resource.spi.ResourceProvider)

     */

    public void resourceChanged(ResourceProvider resource) {

        this.getStoreServices().notifyChange(

            DataStoreNotification.RESOURCE_CHANGED,

            resource);

    }

    @Override

    /* (non-Javadoc)

     * @see org.gvsig.fmap.dal.feature.spi.memory.AbstractMemoryStoreProvider#doDispose()

     */

    protected void doDispose() throws BaseException {

        super.doDispose();

        resource.removeConsumer(this);

    }

    /**

     * Conversi?n de los tipos de datos de gdal a los tipos de datos de RasterBuf

     * @param gdalType Tipo de dato de gdal

     * @return Tipo de dato de RasterBuf

     */

    protected static int getRasterBufTypeFromGdalType(int gdalType) {

        switch (gdalType) {

            case 1:// Eight bit unsigned integer GDT_Byte = 1

                return BufferManager.TYPE_BYTE;

            case 3:// Sixteen bit signed integer GDT_Int16 = 3,

                return BufferManager.TYPE_SHORT;

            case 2:// Sixteen bit unsigned integer GDT_UInt16 = 2

                //return RasterBuffer.TYPE_USHORT;

                return BufferManager.TYPE_SHORT; //Apa?o para usar los tipos de datos que soportamos

            case 5:// Thirty two bit signed integer GDT_Int32 = 5

                return BufferManager.TYPE_INT;

            case 6:// Thirty two bit floating point GDT_Float32 = 6

                return BufferManager.TYPE_FLOAT;

            case 7:// Sixty four bit floating point GDT_Float64 = 7

                return BufferManager.TYPE_DOUBLE;

                // TODO:Estos tipos de datos no podemos gestionarlos. Habria que definir

                // el tipo complejo y usar el tipo long que de momento no se gasta.

            case 4:// Thirty two bit unsigned integer GDT_UInt32 = 4,

                return BufferManager.TYPE_INT;

                //return RasterBuffer.TYPE_UNDEFINED; // Deberia devolver un Long

            case 8:// Complex Int16 GDT_CInt16 = 8

            case 9:// Complex Int32 GDT_CInt32 = 9

            case 10:// Complex Float32 GDT_CFloat32 = 10

            case 11:// Complex Float64 GDT_CFloat64 = 11

                return BufferManager.TYPE_UNDEFINED;

        }

        return BufferManager.TYPE_UNDEFINED;

    }

}