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

import java.io.DataOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Vector;

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

import org.gdal.gdal.GCP;

import org.gdal.gdal.gdal;

import org.gdal.gdalconst.gdalconstConstants;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

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

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

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.geom.GeometryLocator;

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

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

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

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynClass_v2;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.Tags;

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

import org.gvsig.tools.locator.LocatorException;

/**

 * Provider for Raster GDAL files

 * @author dmartinezizquierdo

 *

 */

public abstract class AbstractFileRasterGdalStoreProvider extends AbstractRasterGdalStoreProvider implements

ResourceConsumer{

    private static final Logger logger =

        LoggerFactory.getLogger(AbstractFileRasterGdalStoreProvider.class);

    /**

     * Constructor

     * @param params

     * @param storeServices

     * @throws InitializeException

     */

    public AbstractFileRasterGdalStoreProvider(RasterGdalFileStoreParameters params,

        DataStoreProviderServices storeServices)

        throws InitializeException {

        super(

                params,

                storeServices);

    }

    protected AbstractFileRasterGdalStoreProvider(RasterGdalFileStoreParameters params,

            DataStoreProviderServices storeServices, DynObject metadata)

            throws InitializeException {

        super(params, storeServices, metadata);

    }

    protected AbstractFileRasterGdalStoreProvider(NewRasterGdalStoreParameters params, Driver gdalDriver) {

        //PARA Exportar

        super(params,gdalDriver);

    }

    @Override

    protected void init(DataStoreParameters params,

        DataStoreProviderServices storeServices) throws InitializeException {

        super.init(params, storeServices);

        File file = getRasterGdalParameters().getFile();

        if (file == null) {

            throw new InitializeException(

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

        }

        this.projection=getRasterGdalParameters().getCRS();

        resource = this.createResource(

            FileResource.NAME,

            new Object[] { file.getAbsolutePath() }

        );

        resource.addConsumer(this);

    }

    protected RasterGdalFileStoreParameters getRasterGdalParameters() {

        return (RasterGdalFileStoreParameters) this.getParameters();

    }

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

        }

    }

    /**

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

    }

    private String getOpeningString(File file, String[] driverOptions){

        String openingString="PDF:"+"\""+file.getAbsolutePath()+"\"";

        for (String option:driverOptions){

            openingString+=" "+option;

        }

        return openingString;

    }

    @Override

    protected void openEver() throws OpenException {

        try {

            getResource().execute(new ResourceAction() {

                public Object run() throws Exception {

                    //Used in a future when we could use them

                    String[] driverOptions=getParametersDriverOptions();

                    if (driverOptions!=null && driverOptions.length>0){

                        //If we have driver specific opening options

                        //FIXME: Use "driverOptions" properly

                        String openingString=getOpeningString(getRasterGdalParameters().getFile(), driverOptions);

                        gdalDataSet = gdal.Open(

                            openingString,

                            gdalconstConstants.GA_ReadOnly);

                    }else{

                        //If we don't have driver specific opening options

                        gdalDataSet = gdal.Open(

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

                            gdalconstConstants.GA_ReadOnly);

                    }

                    if (gdalDataSet==null){

                        String errorMsg=gdal.GetLastErrorMsg();

                        logger.info(errorMsg);

                    }

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

        boolean geoTransformCreated=false;

        // 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] = rotationAxisY;

            geotransform[5] = pixelSizeY;

            geoTransformCreated=true;

        }

        if (!geoTransformCreated) {

            // Try to get a geotransform from the file

            geotransform = gdalDataSet.GetGeoTransform();

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

                geoTransformCreated=false;

            }

        }

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

        if (!geoTransformCreated) {

            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;

    }

    protected void createWorldFile(File file, Buffer buffer) throws IOException {

        String fileName=file.getAbsolutePath();

        File tfw = null;

        String extWorldFile = ".wld";

        Tags paramsTags=((DynClass_v2)getParameters().getDynClass()).getTags();

        if (paramsTags!=null && paramsTags.has(RasterGdalFileStoreParameters.WLD_EXTENSION_TAG_NAME)){

            String tagWorldFile=(String)paramsTags.get(RasterGdalFileStoreParameters.WLD_EXTENSION_TAG_NAME);

            if (StringUtils.isNotEmpty(tagWorldFile)){

                extWorldFile=FilenameUtils.EXTENSION_SEPARATOR_STR+tagWorldFile;

            }

        }

        tfw = new File(FilenameUtils.removeExtension(fileName) + extWorldFile);

        Envelope envelope;

        try {

            envelope = buffer.getEnvelope();

        } catch (LocatorException | CreateEnvelopeException e) {

            logger.warn("Can't get the buffer envelope", e);

            return;

        }

        double pixelSizeX = buffer.getPixelSizeX();//(envelope.getMaximum(DIMENSIONS.X) - envelope.getMinimum(DIMENSIONS.X)) / (gdalDataSet.getRasterXSize());

        double pixelSizeY = -buffer.getPixelSizeY();//(envelope.getMinimum(DIMENSIONS.Y) - envelope.getMaximum(DIMENSIONS.Y)) / (gdalDataSet.getRasterYSize());

        double upperLeftPixelCenterCoordX = envelope.getMinimum(DIMENSIONS.X)+pixelSizeX/2;//+gdalDataSet.getRasterXSize()/2;

        double upperLeftPixelCenterCoordY = envelope.getMaximum(DIMENSIONS.Y)+pixelSizeY/2;//gdalDataSet.getRasterYSize()/2;

        // Generamos un world file para gdal

        DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(tfw)));

        dos.writeBytes(pixelSizeX + "\n");

        dos.writeBytes("0.0\n");//rotationAxisY:Not implemented yet

        dos.writeBytes("0.0\n");//rotationAxisX:Not implemented yet

        dos.writeBytes(pixelSizeY + "\n");//Negative value

        dos.writeBytes("" + upperLeftPixelCenterCoordX + "\n");

        dos.writeBytes("" + upperLeftPixelCenterCoordY + "\n");

        dos.close();

    }

    @Override

    public Object getSourceId() {

        return this.getRasterGdalParameters().getFile();

    }

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

        gdalDataSet.delete();

        gdalDataSet=null;

        return true;

    }

    /**

     * Stores a buffer into a new file

     * @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");

    }

    /**

     * Creates a Geotransform (Geolocalization data in Gdal formal) from  buffer envelope

     * @param buffer

     * @return

     */

    protected double[] createGeoTransform(Buffer buffer){

        double[] result=new double[6];

        try {

            result[0]=buffer.getEnvelope().getMinimum(DIMENSIONS.X);

        } catch (LocatorException | CreateEnvelopeException e) {

            result[0]=0;

        }

        result[1]=buffer.getPixelSizeX();

        //TODO: Rotation not implemented yet

        result[2]=0;

        try {

            result[3]=buffer.getEnvelope().getMaximum(DIMENSIONS.Y);

        } catch (LocatorException | CreateEnvelopeException e) {

            result[3]=0;

        }

        //TODO: Rotation not implemented yet

        result[4]=0;

        result[5]=-buffer.getPixelSizeY();

        return result;

    }

    /**

     * Extracts the options to create a new raster, if any of them exist

     * @param newRasterParams

     * @return

     */

    protected String[] getStoringOptions(

        NewRasterGdalStoreParameters newRasterParams) {

        //Specific params from the driver are readed

        //IMPORTANT:Param names defined in the XML must be the same that the properties used for the driver

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

        DynClass dynClass = newRasterParams.getDynClass();

        DynField[] fields = dynClass.getDynFields();

        for (DynField field:fields){

            String fieldName = field.getName();

            String gdalOption = fieldName.toUpperCase();

            Object dynValue = newRasterParams.getDynValue(fieldName);

            if (dynValue!=null && field.getGroup().equalsIgnoreCase(NewRasterGdalStoreParameters.CREATE_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;

    }

    protected void savePrjFile(File dataFile, IProjection proj) throws IOException {

        if (proj == null) {

            return;

        }

        File file = new File(FilenameUtils.removeExtension(dataFile.getAbsolutePath()) + ".prj");

        String export = proj.export(ICRSFactory.FORMAT_WKT_ESRI);

        if (export != null) {

            FileUtils.writeStringToFile(file, export);

        }

    }

}