Application: gvSIG desktop » gvSIG raster

package org.gvsig.raster.gdal.provider;

import java.util.Arrays;

import java.util.Vector;

import org.apache.commons.lang3.StringUtils;

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.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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.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.tools.dynobject.DynObject;

//FIXME: THIS PROVIDER IS NOT IN USE. IT WAS IMPLEMENTED AS AN EXAMPLE AS HOW IT SHOULD BE

//IT NEEDED THIS DEPENDENCY WITH POSTGRES PLUGIN, OR FIX HOW TO MANAGE THE RESOURCE

//<dependency>

//<groupId>org.gvsig</groupId>

//<artifactId>org.gvsig.postgresql.provider</artifactId>

//</dependency>

/**

 * Provider for Postgis through GDAL

 * @author dmartinezizquierdo

 *

 */

public class RasterGdalPostgisStoreProvider

    extends AbstractRasterGdalStoreProvider {

    protected RasterGdalPostgisStoreProvider(

        RasterGdalStoreParameters params,

        DataStoreProviderServices storeServices, DynObject metadata)

        throws InitializeException {

        super(params, storeServices, metadata);

    }

    /**

     * Constructor

     * @param params

     * @param storeServices

     * @throws InitializeException

     */

    public RasterGdalPostgisStoreProvider(RasterGdalStoreParameters params,

        DataStoreProviderServices storeServices) throws InitializeException {

        super(params, storeServices);

    }

    @Override

    protected void init(DataStoreParameters params,

        DataStoreProviderServices storeServices) throws InitializeException {

        super.init(params, storeServices);

        String connectionString=getConnectionString();

        if (StringUtils.isEmpty(connectionString)) {

            throw new InitializeException(

                new NullPointerException("Raster GDAL connection string is not valid"));

        }

//      FIXME: HOW TO CREATE A SQL RESOURCE (IT NEEDS NOW A DEPENDENCY WITH THE PLUGIN)

//        resource = this.createResource(PostgreSQLResource.NAME,

//           null);

//        if (resource instanceof PostgreSQLResource){

//            PostgreSQLResource sqlresource = (PostgreSQLResource)resource;

//            PostgreSQLResourceParameters  sqlParams = (PostgreSQLResourceParameters) sqlresource.getParameters();

//            try {

//                sqlParams.setHost(getHost());

//                sqlParams.setPort(getPort());

//                sqlParams.setDBName(getDBName());

//                sqlParams.setUser(getUser());

//                sqlParams.setPassword(getPassword());

//                sqlParams.setUseSSL(false);

//                this.projection = getCRS();

//            } catch (ParameterMissingException e) {

//                throw new InitializeException("PostgreSQLResource", e);

//            }

//        }

        resource.addConsumer(this);

    }

    protected RasterGdalPostgisStoreProvider(

        NewRasterGdalStoreParameters params, Driver gdalDriver) {

        super(params, gdalDriver);

    }

    @Override

    public Object getSourceId() {

        return getShortConnectionString();

    }

    @Override

    public String getName() {

        return getShortConnectionString();

    }

    @Override

    public String getFullName() {

        return getShortConnectionString();

    }

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

        }

    }

    protected void openEver() throws OpenException {

        try {

            getResource().execute(new ResourceAction() {

                public Object run() throws Exception {

                    gdalDataSet = gdal.Open(

                        getConnectionString(),

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

        boolean geoTransformCreated=false;

        // Try to create an Envelope through geolocalization

        // methods

        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;

    }

    private String getConnectionString(){

        try {

            return "PG:host='"+getHost()+

                "' port='"+getPort()+

                "' dbname='"+getDBName()+

                "' user='"+getUser()+

                "' password='"+getPassword()+

                "' schema='"+getSchema()+

                "' table='"+getTable()+"'";

        } catch (ParameterMissingException e) {

            return null;

        }

    }

    private String getShortConnectionString(){

        try {

            return "PG:host='"+getHost()+

                "' port='"+getPort()+

                "' dbname='"+getDBName()+

                "' user='"+getUser()+

                "' password='***********"+

                "' schema='"+getSchema()+

                "' table='"+getTable()+"'";

        } catch (ParameterMissingException e) {

            return null;

        }

    }

    private String getHost() throws ParameterMissingException{

        if (getParameters().hasDynValue("host")){

            return (String)getParameters().getDynValue("host");

        }else {

            throw new ParameterMissingException("host");

        }

    }

    private String getDBName() throws ParameterMissingException{

        if (getParameters().hasDynValue("dbname")){

            return (String)getParameters().getDynValue("dbname");

        }else {

            throw new ParameterMissingException("dbname");

        }

    }

    private IProjection getCRS() throws ParameterMissingException{

        if (getParameters().hasDynValue("crs")){

            return (IProjection)getParameters().getDynValue("crs");

        }else {

            throw new ParameterMissingException("crs");

        }

    }

    private String getTable() throws ParameterMissingException{

        if (getParameters().hasDynValue("table")){

            return (String)getParameters().getDynValue("table");

        }else {

            throw new ParameterMissingException("table");

        }

    }

    private String getSchema() throws ParameterMissingException{

        if (getParameters().hasDynValue("schema")){

            return (String)getParameters().getDynValue("schema");

        }else {

            throw new ParameterMissingException("schema");

        }

    }

    private String getUser() throws ParameterMissingException{

        if (getParameters().hasDynValue("user")){

            return (String)getParameters().getDynValue("user");

        }else {

            throw new ParameterMissingException("user");

        }

    }

    private String getPassword() throws ParameterMissingException{

        if (getParameters().hasDynValue("password")){

            return (String)getParameters().getDynValue("password");

        }else {

            throw new ParameterMissingException("password");

        }

    }

    private int getPort() throws ParameterMissingException{

        if (getParameters().hasDynValue("port")){

            return (int)getParameters().getDynValue("port");

        }else {

            throw new ParameterMissingException("port");

        }

    }

}