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

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.cresques.cts.IProjection;

import org.gdal.gdal.Dataset;

import org.gdal.gdal.Driver;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DataStoreNotification;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.FileHelper;

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.DataTypes;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.Geometry.DIMENSIONS;

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

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

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

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

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

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

import org.gvsig.raster.lib.buffer.spi.DefaultTileStruct;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

/**

 * Provider for Raster GDAL files

 * @author dmartinezizquierdo

 *

 */

public abstract class AbstractRasterGdalStoreProvider extends AbstractRasterStoreProvider implements

ResourceConsumer{

    private static final Logger logger =

        LoggerFactory.getLogger(AbstractRasterGdalStoreProvider.class);

    /**

     * Provider name

     */

    public static String NAME = "RasterGdal";

    /**

     * Provider description

     */

    public static String DESCRIPTION = "Raster GDAL provider";

    /**

     * Parameters definition name for metadata

     */

    public static final String METADATA_DEFINITION_NAME = NAME;

    protected ResourceProvider resource;

    protected final SimpleTaskStatus taskStatus;

    protected Envelope envelope = null;

    protected IProjection projection= null;

    protected Dataset gdalDataSet;

    protected Driver gdalDriver;

    private List<PageManager> pageManagers;

    /**

     * Dataset from gdal containing the raster data

     * @return Dataset

     */

    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,

                DataStoreParameters.class

                    .getResourceAsStream("RasterGdalMetadata.xml"),

                    DataStoreParameters.class.getClassLoader());

        }

    }

    /**

     * Constructor

     * @param params

     * @param storeServices

     * @throws InitializeException

     */

    public AbstractRasterGdalStoreProvider(DataStoreParameters 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 AbstractRasterGdalStoreProvider(DataStoreParameters params,

            DataStoreProviderServices storeServices, DynObject metadata)

            throws InitializeException {

        super(params, storeServices, metadata);

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

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

        this.init((DataStoreParameters)params, storeServices);

    }

    protected AbstractRasterGdalStoreProvider(NewRasterGdalStoreParameters params, Driver gdalDriver) {

        //PARA Exportar

        super(params,null,null);

        this.gdalDriver=gdalDriver;

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

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

    }

    protected void init(DataStoreParameters params,

        DataStoreProviderServices storeServices) throws InitializeException {

        if (params == null) {

            throw new InitializeException(

                new NullPointerException("params is null"));

        }

    }

    protected DataStoreParameters getRasterGdalParameters() {

        return (DataStoreParameters) this.getParameters();

    }

    /**

     * Used to obtain the specific options for a specific driver

     * Not in use yet. Used as example.

     * @return options used to open a specific driver in format ("optionName=optionValue")

     */

    private String [] getParametersDriverOptions(){

        ArrayList<String> optionsList=new ArrayList<String>();

        DynClass dynClass = getRasterGdalParameters().getDynClass();

        DynField[] fields = dynClass.getDynFields();

        for (DynField field:fields){

            String fieldName = field.getName();

            String gdalOption = fieldName.toUpperCase();

            Object dynValue = getRasterGdalParameters().getDynValue(fieldName);

            if (dynValue!=null && field.getGroup().equalsIgnoreCase(RasterGdalFileStoreParameters.OPEN_OPTIONS_GROUP)){

                if(field.getType() == DataTypes.BOOLEAN) {

                    if((Boolean)dynValue){

                        optionsList.add(gdalOption+"=YES");

                    }else{

                        optionsList.add(gdalOption+"=NO");

                    }

                } else {

                    optionsList.add(gdalOption+"="+dynValue);

                }

            }

        }

        String[]options=new String[optionsList.size()];

        optionsList.toArray(options);

        return options;

    }

    @Override

    public Buffer createBuffer(RasterQuery rasterQuery) throws BufferException {

        BufferManager bufferManager = BufferLocator.getBufferManager();

        Buffer buffer = null;

        if (rasterQuery != null && !rasterQuery.getBands().isEmpty()) {

            List<BandQuery> bands;

            bands = rasterQuery.getBands();

            int bandDataTypes[];

            bandDataTypes = new int[bands.size()];

            NoData[] bandNoDatas = new NoData[bands.size()];

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

            int i=0;

            for (BandQuery bandQuery : bands) {

                int band = bandQuery.getBand();

                bandDataTypes[i] = this.getBandDescriptor(band).getDataType();

                bandNoDatas[i] = this.getNoData(rasterQuery, band);

                pageManagers.add(this.pageManagers.get(band));

                i++;

            }

            buffer =

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

                    bandNoDatas, this.projection, envelope, pageManagers);

        } else {

            buffer =

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

                    this.getNoDatas(), this.projection, this.envelope, this.pageManagers);

        }

        return buffer;

    }

    @Override

    public int getBands() {

        return gdalDataSet.getRasterCount();

    }

    private Double getNoData(org.gdal.gdal.Band gdalBand){

        Double[] noDataValueResult=new Double[1];

        gdalBand.GetNoDataValue(noDataValueResult);

        Double noData=noDataValueResult[0];

        return noData;

    }

    public void open() throws OpenException {

        if (this.gdalDataSet != null) {

            return;

        }

        openEver();

        //Create the page managers

        BufferManager bufferManager=BufferLocator.getBufferManager();

        int bandCount=gdalDataSet.getRasterCount();

        pageManagers = new ArrayList<PageManager>();

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

            //Gdal bands begin count in 1

            int gdalBandNumber=i+1;

            org.gdal.gdal.Band gdalBand=gdalDataSet.GetRasterBand(gdalBandNumber);

            this.getBandDescriptor(i).setDataType(getRasterBufTypeFromGdalType(gdalBand.getDataType()));

            Double noData=getNoData(gdalBand);

            this.getBandDescriptor(i).setDescription(gdalBand.GetDescription());

            if (noData!=null){

                this.getBandDescriptor(i).setNoData(bufferManager.createNoData(noData, noData));

            }

            //Paginated

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

            //Tiled

//            pageManagers.add(new RasterGdalBandTileManager(gdalDataSet, gdalBandNumber, 256, 256));

        }

    }

    protected abstract void openEver() throws OpenException;

    protected 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 =Math.abs(gdalDataSet.getRasterXSize()*pixelSizeX);

        double height=Math.abs(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 void close() throws CloseException {

        this.gdalDataSet.delete();

        this.gdalDataSet = null;

    }

    @Override

    public ResourceProvider getResource() {

        return this.resource;

    }

    @Override

    public String getProviderName() {

        return getRasterGdalParameters().getDataStoreName();

    }

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

        if(gdalDataSet!=null){

            gdalDataSet.delete();

            gdalDataSet=null;

        }

        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;

    }

    /**

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

     * @param ype Tipo de dato de RasterBuffer

     * @return Tipo de dato de gdal

     */

    protected static int getGdalTypeFromRasterBufType(int type) {

        switch (type) {

        case BufferManager.TYPE_BYTE:

            return 1; // Eight bit unsigned integer GDT_Byte = 1

        case BufferManager.TYPE_SHORT:

            return 3;// Sixteen bit signed integer GDT_Int16 = 3,

        case BufferManager.TYPE_USHORT:

            return 2;// Sixteen bit unsigned integer GDT_UInt16 = 2

        case BufferManager.TYPE_INT:

            return 5;// Thirty two bit signed integer GDT_Int32 = 5

        case BufferManager.TYPE_FLOAT:

            return 6;// Thirty two bit floating point GDT_Float32 = 6

        case BufferManager.TYPE_DOUBLE:

            return 7;// Sixty four bit floating point GDT_Float64 = 7

        default:

            return 1; // By default eight bit unsigned integer GDT_Byte = 1 and the force be with you.

        }

    }

    /**

     * Stores a buffer into a new entity

     * @param newRasterParams

     * @param overwrite

     * @throws CreateException

     */

    public void store(boolean overwrite)

        throws CreateException {

        //This method must be overwritten by subclasses than can be stored

        throw new UnsupportedOperationException("This provider can't store the raster");

    }

    /**

     * Fills a given dataset with data from a buffer

     * @param buffer

     * @param gdalDataset

     */

    protected void fillDataset(Buffer buffer, Dataset gdalDataset) {

        for (int i=0;i<buffer.getBandCount();i++){

            Band band = buffer.getBand(i);

            switch (band.getDataType()) {

            case BufferManager.TYPE_BYTE:

                byte[] byteRowBuffer = (byte[])band.createRowBuffer(); //new byte[band.getColumns()];

                for (int row=0;row<band.getRows();row++){

                    band.fetchRow(row, byteRowBuffer);

                    gdalDataset.GetRasterBand(i+1).WriteRaster(0, row, band.getColumns(), 1,

                        byteRowBuffer);

                }

                break;

            case BufferManager.TYPE_DOUBLE:

                double[] doubleRowBuffer=(double[])band.createRowBuffer();

                for (int row=0;row<band.getRows();row++){

                    band.fetchRow(row, doubleRowBuffer);

                    gdalDataset.GetRasterBand(i+1).WriteRaster(0, row, band.getColumns(), 1,

                        doubleRowBuffer);

                }

                break;

            case BufferManager.TYPE_FLOAT:

                float[] floatRowBuffer=(float[])band.createRowBuffer();

                for (int row=0;row<band.getRows();row++){

                    band.fetchRow(row, floatRowBuffer);

                    gdalDataset.GetRasterBand(i+1).WriteRaster(0, row, band.getColumns(), 1,

                        floatRowBuffer);

                }

                break;

            case BufferManager.TYPE_INT:

                int[] intRowBuffer=(int[])band.createRowBuffer();

                for (int row=0;row<band.getRows();row++){

                    band.fetchRow(row, intRowBuffer);

                    gdalDataset.GetRasterBand(i+1).WriteRaster(0, row, band.getColumns(), 1,

                        intRowBuffer);

                }

                break;

            case BufferManager.TYPE_SHORT:

            case BufferManager.TYPE_USHORT:

                short[] shortRowBuffer=(short[])band.createRowBuffer();

                for (int row=0;row<band.getRows();row++){

                    band.fetchRow(row, shortRowBuffer);

                    gdalDataset.GetRasterBand(i+1).WriteRaster(0, row, band.getColumns(), 1,

                        shortRowBuffer);

                }

                break;

            default:

                break;

            }

        }

    }

    public TileStruct getTileStruct() {

        List<Double> pixelSizes = new ArrayList<Double>();

        Map<Integer, Double> zoomLevels = new HashMap<Integer, Double>();

        TileStruct tileStruct = new DefaultTileStruct();

        //FIXME: DefaultTileStruct ya pone un rows y columns per tile por defecto a 256,

        // si se prefiere otro asignar los nuevos valores aqu?.

        int completeRows = getGdalDataSet().getRasterYSize();

        int completeColumns = getGdalDataSet().getRasterXSize(); //image.columns;

        double completePixelSizeX = envelope.getLength(DIMENSIONS.X)/completeColumns;

        double completePixelSizeY = envelope.getLength(DIMENSIONS.Y)/completeRows;

        int maximumLength = completeColumns;

        int tileMaximumLength = tileStruct.getColumnsPerTile(); //tileSizeX;

        double maximumPixelSize = completePixelSizeX;

        if (completeRows * tileStruct.getRowsPerTile() > completeColumns * tileStruct.getColumnsPerTile()) {

            maximumLength = completeRows;

            tileMaximumLength = tileStruct.getRowsPerTile();

            maximumPixelSize = completePixelSizeY;

        }

        double pixelSize = maximumPixelSize;

        while (maximumLength * maximumPixelSize / pixelSize > tileMaximumLength) {

            pixelSizes.add(pixelSize);

            pixelSize = pixelSize * 2;

        }

        pixelSizes.add(pixelSize);

        int i = 0;

        for (int zoomLevel = pixelSizes.size() - 1; zoomLevel >= 0; zoomLevel--) {

            zoomLevels.put(i, pixelSizes.get(zoomLevel));

            i++;

        }

        tileStruct.setEnvelope(this.envelope);

        tileStruct.setPixelSizePerZoomLevel(zoomLevels);

        return tileStruct;

    }

    @Override

    public BufferDimensions getDimensions() throws InitializeException {

        if(this.dimensions==null){;

        this.dimensions = BufferLocator.getBufferManager().createBufferDimensions(this.gdalDataSet.getRasterYSize(), this.gdalDataSet.getRasterXSize(),  this.envelope);

    }

    return this.dimensions;

}

}