gvSIG data provider for seismic formats

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

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

  <name>${project.artifactId}</name>

  <parent>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.seismic</artifactId>

      <version>1.0.3</version>

  </parent>  

  <dependencies>

    <dependency>

        <groupId>commons-io</groupId>

        <artifactId>commons-io</artifactId>

      <scope>compile</scope>

    </dependency>

   <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.fmap.dal.file.lib</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.seismic.lib.api</artifactId>

      <scope>compile</scope>

    </dependency>

  </dependencies>

  <build>

      <plugins>

          <plugin>

              <groupId>org.apache.maven.plugins</groupId>

              <artifactId>maven-compiler-plugin</artifactId>

              <configuration>

                  <source>1.5</source>

                  <target>1.5</target>

                  <encoding>ISO-8859-1</encoding>

              </configuration>

          </plugin>

      </plugins>

  </build>

</project>

package org.gvsig.fmap.dal.store.seismic;

public class test {

/*

	public static void main(String[] args) throws IOException {

		new test().doMain(args);

	}

	public void doMain(String[] args) throws IOException {

		CSVFormat format = CSVFormat.DEFAULT

				.withHeader()

				.withSkipHeaderRecord(true)

				.withIgnoreEmptyLines(true)

				.withDelimiter(';');

		URL data = this.getClass().getResource("/test1.csv");

		CSVParser parser = CSVParser.parse(data,Charset.forName("UTF-8"), format); 

		Map headerMap = parser.getHeaderMap();

		String header[] = new String[headerMap.size()];

		int i=0;

		Iterator it = headerMap.keySet().iterator();

		while(it.hasNext()) {

			header[i++] = (String) it.next();

		}

		for(i=0; i<header.length;i++) {

			System.out.println("header["+i+"]="+header[i]);

		}

		List r = parser.getRecords();

		System.out.println(r.toString());

	}

	*/

}

<?xml version="1.0"?>

<!--

Definitions of metadata fields of a seismic file.  

 -->

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="Seismic" namespace="Metadata">

      <extends>

      	<class namespace="Metadata" name="SpatialProvider"/>

      </extends>

      <description>Metadata of a Seismic store</description>

      <fields>

      </fields>

    </class>

  </classes>

</definitions>  

<?xml version= "1.0 "?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="SeismicStoreParameters">

       <extends>

      	<class namespace="dal" name="ProviderParameters"/>

      </extends>

      <description>Store the parameters need to open a Seismic file</description>

      <fields>

        <field name="File" type="file" mandatory="true" group="Basic">

          <description>Seismic file</description>

        </field>

        <field name="Parser" type="String" hidden="true" mandatory="true" group="Basic">

          <description>Parser name used to get the data from the file.</description>

        </field>

        <field name="CRS" type="crs" mandatory="false" group="Basic">

          <description>The coordinate reference system used in this seismic file if contains geometries</description>

        </field>

        <field name="point" type="string" hidden="true" mandatory="false" defaultValue="" group="Basic">

          <description>This field allow to add a Geometry column to the table. It is a list of field names separated by commas used as dimensions for the attribute GEOM of type point to add to the table.</description>

        </field>

        <field name="ProjectID" type="string" mandatory="false" defaultValue="" group="Advanced">

          <description>This field allow to add a Geometry column to the table. It is a list of field names separated by commas used as dimensions for the attribute GEOM of type point to add to the table.</description>

        </field>

        <field name="Project" type="string" mandatory="false" defaultValue="" group="Advanced">

          <description>This field allow to add a Geometry column to the table. It is a list of field names separated by commas used as dimensions for the attribute GEOM of type point to add to the table.</description>

        </field>

        <field name="State" type="string" mandatory="false" defaultValue="" group="Advanced">

          <description>This field allow to add a Geometry column to the table. It is a list of field names separated by commas used as dimensions for the attribute GEOM of type point to add to the table.</description>

        </field>

        <field name="Year" type="string" mandatory="false" defaultValue="" group="Advanced">

          <description>This field allow to add a Geometry column to the table. It is a list of field names separated by commas used as dimensions for the attribute GEOM of type point to add to the table.</description>

        </field>

      </fields>

    </class>

  </classes>

</definitions>  

org.gvsig.fmap.dal.store.seismic.SeismicStoreProviderLibrary

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 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 3

 * 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.fmap.dal.store.seismic;

import java.io.File;

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.impl.AbstractFilesystemServerExplorerProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerProviderServices;

public class SeismicFilesystemServerProvider extends AbstractFilesystemServerExplorerProvider 

	implements FilesystemServerExplorerProvider, ResourceConsumer {

	private FilesystemServerExplorerProviderServices serverExplorer;

	public String getDataStoreProviderName() {

		return SeismicStoreProvider.NAME;

	}

	public int getMode() {

		return DataServerExplorer.MODE_FEATURE | DataServerExplorer.MODE_GEOMETRY;

	}

	public boolean accept(File pathname) {

		return (pathname.getName().toLowerCase().endsWith(".uk"));

	}

	public String getDescription() {

		return SeismicStoreProvider.DESCRIPTION;

	}

	public DataStoreParameters getParameters(File file) throws DataException {

		DataManager manager = DALLocator.getDataManager();

		SeismicStoreParameters params = (SeismicStoreParameters) manager

				.createStoreParameters(this

				.getDataStoreProviderName());

		params.setFile(file);

		return params;

	}

	public boolean canCreate() {

		return false;

	}

	public boolean canCreate(NewDataStoreParameters parameters) {

			throw new UnsupportedOperationException(); 

	}

	public void create(NewDataStoreParameters parameters, boolean overwrite)

			throws CreateException {

		throw new UnsupportedOperationException(); 

	}

	public NewDataStoreParameters getCreateParameters() throws DataException {

		throw new UnsupportedOperationException(); 

	}

	public void initialize(

			FilesystemServerExplorerProviderServices serverExplorer) {

		this.serverExplorer = serverExplorer;

	}

	public void remove(DataStoreParameters parameters) throws RemoveException {

		File file = ((SeismicStoreParameters) parameters).getFile();

		if (!file.exists()) {

			throw new RemoveException(this.getDataStoreProviderName(),

					new FileNotFoundException(file));

		}

		if (!file.delete()) {

			// FIXME throws ???

		}

	}

	public boolean closeResourceRequested(ResourceProvider resource) {

		// while it is using a resource anyone can't close it

		return false;

	}

	public void resourceChanged(ResourceProvider resource) {

		//Do nothing

	}

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 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 3

 * 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.fmap.dal.store.seismic;

import java.io.File;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.apache.commons.io.FilenameUtils;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreNotification;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.FileHelper;

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.feature.EditableFeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.EditableFeatureType;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.dal.feature.exception.PerformEditingException;

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureStoreProviderServices;

import org.gvsig.fmap.dal.feature.spi.memory.AbstractMemoryStoreProvider;

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

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.spi.DataStoreProviderServices;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.seismic.Parser;

import org.gvsig.seismic.SeismicLocator;

import org.gvsig.seismic.SeismicManager;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataTypesManager.Coercion;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynStruct;

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.exception.NotYetImplemented;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class SeismicStoreProvider extends AbstractMemoryStoreProvider implements

ResourceConsumer {

    private static final Logger logger = LoggerFactory.getLogger(SeismicStoreProvider.class);

    public static final String NAME = "Seismic";

    public static final String DESCRIPTION = "Seismic file";

    public static final String METADATA_DEFINITION_NAME = NAME;

    private ResourceProvider resource;

    private long counterNewsOIDs = 0;

    private Envelope envelope;

    private boolean need_calculate_envelope = false;

    private SimpleTaskStatus taskStatus;

	private SeismicManager driverManager;

	private boolean isOpenedPreviously = false;

    public SeismicStoreProvider(SeismicStoreParameters parameters,

        DataStoreProviderServices storeServices) throws InitializeException {

        super(

            parameters, 

            storeServices,

            FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME)

        );

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

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

        driverManager = SeismicLocator.getDriverManager();

        counterNewsOIDs = 0;

        File file = getDriverParameters().getFile();

        resource = this.createResource(

            FileResource.NAME,

            new Object[] { file.getAbsolutePath() }

        );

        resource.addConsumer(this);

        initializeFeatureTypes();

    }

    public SeismicManager getDriverManager(){

    	return this.driverManager;

    }

    public SeismicStoreParameters getDriverParameters() {

        return (SeismicStoreParameters) this.getParameters();

    }

    public String getProviderName() {

        return NAME;

    }

    public boolean allowWrite() {

        return true;

    }

    private String getFullFileName() {

    	// Usar solo para mostrar mensajes en el logger.

		String s = "(unknow)";

		try { 

			s = getDriverParameters().getFile().getAbsolutePath();

		} catch(Exception e2) {

			s = "(unknow)";

		}

		return s;

    }

    public void open() throws OpenException {

    	this.isOpenedPreviously = true;

        if (this.data != null) {

            return;

        }

        this.data = new ArrayList<FeatureProvider>();

        resource.setData(new HashMap());

        counterNewsOIDs = 0;

		try {

			loadFeatures();

		} catch (RuntimeException e) {

			logger.warn("Can't load features from Seismic '"+getFullFileName()+"'.", e);

			throw e;

		} catch (Exception e) {

			logger.warn("Can't load features from Seismic '"+getFullFileName()+"'.", e);

			throw new RuntimeException(e);

		}

    }

//    public DataServerExplorer getExplorer() throws ReadException {

//        DataManager manager = DALLocator.getDataManager();

//        FilesystemServerExplorerParameters params;

//        try {

//            params = (FilesystemServerExplorerParameters) manager

//            .createServerExplorerParameters(FilesystemServerExplorer.NAME);

//            params.setRoot(this.getDriverParameters().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);

//        }

//

//    }

//

//    class Writer {

//    	private Envelope envelope = null;

//		private boolean calculate_envelope = false;

//		private CsvListWriter listWriter = null;

//		private CsvPreference csvpreferences = null;

//		private FileWriter fwriter = null;

//		private FeatureType ftype;

//		private File file;

//		private String[] values;

//		private FeatureAttributeDescriptor[] descriptors;

//		private Coercion convert = null;

//		private int errorcounts =0;

//		private Throwable lasterror = null;

//		private Locale locale = null;

//    	

//    	public void initialize(File file, FeatureType ftype, CsvPreference csvpreferences) {

//    		this.file = file;

//    		this.ftype = ftype;

//			this.csvpreferences = csvpreferences;

//			this.locale = DriverStoreParameters.getLocale(getDriverParameters());

//    		if( csvpreferences == null ) {

//    			this.csvpreferences = CsvPreference.STANDARD_PREFERENCE;

//    		}

//    		if( ftype.getDefaultGeometryAttributeName() != null ) {

//    			this.calculate_envelope = true;

//    		}

//    		this.descriptors = this.ftype.getAttributeDescriptors();

//    		this.convert = ToolsLocator.getDataTypesManager().getCoercion(org.gvsig.tools.dataTypes.DataTypes.STRING);

//    		this.errorcounts = 0;

//    	}

//    	

//    	public void begin() {

//    		try {

//				this.fwriter = new FileWriter(file);

//			} catch (IOException e) {

//				logger.warn("Can't open file for write ("+file.getAbsolutePath()+").",e);

//				throw new RuntimeException(e);

//			}

//    		this.listWriter = new CsvListWriter(this.fwriter,this.csvpreferences);

//    		int n = 0;

//    		for(int i=0; i<descriptors.length; i++ ) {

//    			FeatureAttributeDescriptor descriptor = descriptors[i];

//    			if( descriptor.getEvaluator()== null ) {

//    				n++;

//    			}

//    		}

//    			

//    		String[] header = new String[n];

//    		this.values = new String[n];

//    		n = 0;

//    		for(int i=0; i<descriptors.length; i++ ) {

//    			FeatureAttributeDescriptor descriptor = descriptors[i];

//    			if( descriptor.getEvaluator()== null ) {

//	    			String name = descriptor.getName();

//	    			String typeName = descriptor.getDataTypeName();

//	    			if( descriptor.getDataType().getType() == DataTypes.STRING ) {

//		    			header[n++] = name + "__" + typeName + "__" + descriptor.getSize();

//	    			} else {

//	    				header[n++] = name + "__" + typeName;

//	    			}

//    			}

//    		}

//            try {

//				listWriter.writeHeader(header);

//			} catch (Exception e) {

//				logger.warn("Can't write header '"+header.toString()+"' file for write ("+file.getAbsolutePath()+").",e);

//				throw new RuntimeException(e);

//			}

//    	}

//    	

//    	public void add(FeatureProvider feature) {

//			if (this.calculate_envelope) {

//				Geometry geom = feature.getDefaultGeometry();

//				if (geom != null) {

//					if (envelope == null) {

//						try {

//							envelope = (Envelope) geom.getEnvelope().clone();

//						} catch (CloneNotSupportedException e) {

//							logger.warn("Este error no deberia pasar, siempre se puede hacer un clone de un envelope.",e);

//						}

//					} else {

//						envelope.add(geom.getEnvelope());

//					}

//				}

//			}

//    		int n = 0;

//    		for(int i=0; i<descriptors.length; i++ ) {

//    			FeatureAttributeDescriptor descriptor = descriptors[i];

//    			if( descriptor.getEvaluator()== null ) {

//					Object value = feature.get(i);

//    				try {

//    					n++;

//    					if( this.convert!=null && this.convert instanceof CoercionWithLocale ) {

//    						values[n] = (String) ((CoercionWithLocale)this.convert).coerce(value,this.locale);

//    					} else {

//    						values[n] = (String) this.convert.coerce(value);

//    					}

//					} catch (CoercionException e) {

//						try {

//							values[n] = value.toString();

//						} catch(Exception ex) {

//							values[n] = "";

//						}

//						if( errorcounts++ <= 10 ) {

//							this.lasterror = e;

//							logger.warn("Can't convert value of field "+i+" to string in CVS file '"+getFullFileName()+"'.",e);

//							if( errorcounts == 10 ) {

//								logger.warn("Too many error writing CVS file '"+getFullFileName()+"', don't output more.");

//							}

//						} 

//					} 

//    			}

//    		}

//    		try {

//				this.listWriter.writeHeader(values);

//			} catch (IOException e) {

//				if( errorcounts++ <= 10 ) {

//					this.lasterror = e;

//					logger.warn("Can't write values to CVS file '"+getFullFileName()+"'.",e);

//					if( errorcounts == 10 ) {

//						logger.warn("Too many error writing CVS file '"+getFullFileName()+"', don't output more.");

//					}

//				} 

//			}

//			

//    	}

//    	

//    	public void end() throws PerformEditingException {

//    		if( this.errorcounts>0 ) {

//    			throw new PerformEditingException(this.file.getAbsolutePath(), lasterror);

//    		}

//			if( listWriter!=null ) {

//	    		try {

//	    			listWriter.close();

//	    		} catch(Exception ex) {

//	    			// Ignore error

//	    		}

//				listWriter=null ;

//			}

//			if( fwriter!=null ) {

//	    		try {

//	    			fwriter.close();

//	    		} catch(Exception ex) {

//	    			// Ignore error

//	    		}

//				fwriter=null ;

//			}

//    	}

//    	

//    	public Envelope getEnvelope() {

//    		return this.envelope;

//    	}

//    }

    public void performChanges(Iterator deleteds, Iterator inserteds, Iterator updateds, Iterator originalFeatureTypesUpdated) throws PerformEditingException {

        try {

            this.taskStatus.add();

            taskStatus.message("_preparing");

            getResource().execute(new ResourceAction() {

                public Object run() throws Exception {

                    FeatureSet features = null;

                    DisposableIterator it = null;

                    try {

                        File file = (File) resource.get();

                        FeatureType featType = getStoreServices().getDefaultFeatureType();

                        features =

                            getStoreServices().getFeatureStore()

                            .getFeatureSet();

                        List<FeatureProvider> newdata = new ArrayList<FeatureProvider>();

                        it = features.fastIterator();

                        taskStatus.setRangeOfValues(0,0);

                        long counter=0;

                        while (it.hasNext()) {

                            taskStatus.setCurValue(counter++);

                            FeatureProvider feature = getStoreServices().getFeatureProviderFromFeature(

                                (org.gvsig.fmap.dal.feature.Feature) it.next());

                            if (feature.getOID() == null){

                                logger.warn("feature without OID");

                                feature.setOID(createNewOID());

                            }

                            newdata.add(feature);

                        }

                        data = newdata;

                        envelope = getEnvelope();

                        resource.notifyChanges();

                    } finally {

                        if (it != null) {

                            it.dispose();

                        }

                        if (features != null) {

                            features.dispose();

                        }

                    }

                    return null;

                }

            });

            this.taskStatus.terminate();

        } catch (Exception e) {

            this.taskStatus.abort();

            throw new PerformEditingException(getResource().toString(), e);

        } finally {

            this.taskStatus.remove();

        }

    }

    public boolean closeResourceRequested(ResourceProvider resource) {

        return true;

    }

    public int getOIDType() {

        return DataTypes.LONG;

    }

    public boolean supportsAppendMode() {

        return false;

    }

    public void append(FeatureProvider featureProvider) {

    	throw new UnsupportedOperationException();

    }

    public void beginAppend() {

    	throw new UnsupportedOperationException();

    }

    public void endAppend() {

    	throw new UnsupportedOperationException();

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        throw new NotYetImplemented();

    }

    public void loadFromState(PersistentState state) throws PersistenceException {

        throw new NotYetImplemented();

    }

    public Object createNewOID() {

        return new Long(counterNewsOIDs++);

    }

    protected void initializeFeatureTypes() throws InitializeException {

        if(!isOpenedPreviously){

	    	try {

	            this.open();

	        } catch (OpenException e) {

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

	        }

        }

    }

    public Envelope getEnvelope() throws DataException {

    	if(!isOpenedPreviously )

    		this.open();

        if( this.envelope!= null )  {

        	return this.envelope;

        }

        if( !this.need_calculate_envelope ) {

        	return null;

        }

        FeatureStore fs = this.getFeatureStore();

        long i = fs.getFeatureCount();

        FeatureType ft = fs.getDefaultFeatureType();

        FeatureAttributeDescriptor fad = ft.getDefaultGeometryAttribute();

        try {

            this.envelope = GeometryLocator.getGeometryManager().createEnvelope(fad.getGeometrySubType());

			fs.accept(new Visitor() {

				public void visit(Object obj) throws VisitCanceledException, BaseException {

					Feature f = (Feature) obj;

					Geometry geom = f.getDefaultGeometry();

					envelope.add(geom.getEnvelope());

				}

			});

		} catch (BaseException e) {

			logger.warn("Can't calculate the envelope of Seismic file '"+this.getFullName()+"'.",e);

			this.envelope = null;

		}

        this.need_calculate_envelope = false;

        return this.envelope;

    }

    public Object getDynValue(String name) throws DynFieldNotFoundException {

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

            try {

                return this.getEnvelope();

            } catch (DataException e) {

                return null;

            }

        } else {

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

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

                if (pro != null){

                    return pro;

                }

            }

        }

        return super.getDynValue(name);

    }

    public void resourceChanged(ResourceProvider resource) {

        this.getStoreServices().notifyChange(

            DataStoreNotification.RESOURCE_CHANGED,

            resource);

    }

    public Object getSourceId() {

        return this.getDriverParameters().getFile();

    }

    public String getName() {

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

        return FilenameUtils.getBaseName(name);

    }

    public String getFullName() {

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

    }

    public ResourceProvider getResource() {

        return resource;

    }

    private boolean isEmpty(String s) {

    	if( s==null ) {

    		return true;

    	}

    	return s.trim().length()==0;

    }

//	private Map<String, String> getDriverPreferences() {

//		return this.getMetadata();

//	}

//    private EditableFeatureType getFeatureType(String headers[], int automaticTypes[]) {

//		EditableFeatureType fType =	getStoreServices().createFeatureType(this.getName());

//		fType.setHasOID(true);

//		DataTypesManager dataTypesManager = ToolsLocator.getDataTypesManager();

//		

//    	int[] types = new int[headers.length];

//    	int[] sizes = new int[headers.length];

//    	//

//    	// Calculamos cuales pueden ser los tipos de datos

//    	//

//    	

//    	// Por defecto todos string

//    	for( int i=0; i<types.length ; i++) {

//    		types[i] = DataTypes.STRING;

//    		sizes[i] = 0;

//    	}

//    	

//    	// Luego asuminos los tipos pasados por parametro, que se supone

//    	// son los detectados automaticamente.

//		if (automaticTypes != null) {

//			for (int i = 0; i < types.length && i < automaticTypes.length; i++) {

//				types[i] = automaticTypes[i];

//			}

//		}

//    	

//    	// Luego probamos con lo que diga las cabezeras del CVS, sobreescribiendo

//    	// los tipos anteriores en caso de definirse en la cabezara.

//		// El formato de la cabecera seria:

//		//   name[:typename[:size]]

//		//   name[__typename[__size]]

//		//

//    	for( int i=0; i<types.length; i++) {

//    		String s = headers[i];

//    		String typename = null;

//    		String[] ss = null;

//    		if( s.contains(":") ) {

//    			ss = s.split(":");

//    		} else if( s.contains("__") ) {

//        		ss = s.split("__");

//    		}

//    		if( ss!=null ) {

//    			headers[i] = ss[0];

//    			typename = ss[1];

//    			types[i] = dataTypesManager.getType(typename); 

//    			if( types[i]==DataTypes.INVALID ) {

//    				types[i] = DataTypes.STRING;

//    				logger.info("Type '"+typename+"' not valid for attribute '"+s+"' in CSV file '"+this.getFullFileName()+"'.");

//    			}

//    			if( types[i]== DataTypes.STRING && ss.length>2 ) {

//    				try {

//    					sizes[i] = Integer.parseInt(ss[2]);

//    				} catch(Exception ex) {

//    					logger.warn("Ignore incorrect field size for field "+i+" ("+s+") in CSV header of '"+getFullFileName()+"'.",ex);

//    				}

//    			}

//    		}

//    	}

//    	

//    	// Y por ultimo hacemos caso a lo que se haya especificado en los parametros

//    	// de apertura del CSV, teniendo esto prioridad sobre todo.

//    	int[] param_types = DriverStoreParameters.getFieldTypes(this.getParameters());

//    	if( param_types != null ) {

//        	for( int i=0; i<types.length && i<param_types.length; i++) {

//        		types[i] = param_types[i];

//        	}

//    	}

//    	

//    	//

//    	// Una vez ya sabemos los tipos de datos rellenamos el feature-type

//    	//

//    	for(int i=0; i<types.length; i++) {

//			int fieldType = types[i];

//			String fieldName = headers[i];

//			EditableFeatureAttributeDescriptor fad = fType.add(fieldName, fieldType);

////			if( param_sizes!=null && i<param_sizes.length && param_sizes[i]>0 ) {

////				fad.setSize(param_sizes[i]);

////			} else {

////				fad.setSize(sizes[i]);

////			}

//			if( fieldType == DataTypes.GEOMETRY && fType.getDefaultGeometryAttributeName() == null) {

//				fType.setDefaultGeometryAttributeName(fieldName);

//			}

//		}

//    		EditableFeatureAttributeDescriptor attr = fType.add("GEOM", DataTypes.GEOMETRY);

//    		GeometryManager geommgr = GeometryLocator.getGeometryManager();

//    		GeometryType gt;

//			try {

//				gt = geommgr.getGeometryType(Geometry.TYPES.GEOMETRY, Geometry.SUBTYPES.GEOM2D);

//	    		attr.setGeometryType(gt);

//			} catch (Exception e) {

//				logger.warn("Can't set geometry type for the calculated field in Driver file '"+getFullFileName()+"'.",e);

//			}

//		return fType;

//    }

	private void loadFeatures() throws DataException,

			CoercionException, CloneNotSupportedException {

			//logger.info("---------------------------------DRIVERSTOREPROVIDER: loadFeatures() -> start");

			FeatureStoreProviderServices store = this.getStoreServices();

			// Initiaize the parser

			Parser parser = driverManager.createParser(this.getDriverParameters().getParserName());

			parser.setProjectId(getDriverParameters().getProjectId());

			parser.setProjectName(getDriverParameters().getProjectName());

			parser.setProjectYear(getDriverParameters().getProjectYear());

			parser.setEstado(getDriverParameters().getEstado());

			//parser.initializeParser();

			File file = this.getDriverParameters().getFile();

			Map<String, String> headers = parser.getMetadataInfo(file);

			if (headers == null) {

				String msg = "Can't retrieve header from Seismic file '"

						+ this.getDriverParameters().getFile()

								.getAbsolutePath()

						+ "' and not specified in the parameters.";

				logger.warn(msg);

				throw new RuntimeException(msg);

			}

			// Initialize the feature types

			DynStruct struct = parser.getDataStruct();

			EditableFeatureType edftype = this.getFeatureTypeDefinition(

					struct, 

					this.getDriverParameters().getCRS(), 

					parser.getOrderedFieldNames());

			FeatureType ftype = edftype.getNotEditableCopy();

			List<FeatureType> ftypes = new ArrayList<FeatureType>();

			ftypes.add(ftype);

			store.setFeatureTypes(ftypes, ftype);

			Coercion coercion[] = new Coercion[ftype.size()];

			int sizes[] = new int[ftype.size()];

			for (int i = 0; i < ftype.size(); i++) {

				sizes[i] = -1;

				FeatureAttributeDescriptor ad = ftype.getAttributeDescriptor(i);

				coercion[i] = ad.getDataType().getCoercion();

				if( ad.getDataType().getType() == DataTypes.STRING ) {

					if( ad.getSize() == 0 ) {

						// Es un string y no tiene un size asignado.

						// Lo ponemos a cero para calcularlo.

						sizes[i] = 0;

					}

				}

			}

			if( ftype.getDefaultGeometryAttributeName() != null) {

				this.need_calculate_envelope = true;

			}

			//Locale locale = DriverStoreParameters.getLocale(getDriverParameters());

			taskStatus.message("_loading");

			int count = 0;

			List<DynObject> row = parser.getData();

			Iterator<DynObject> features = row.iterator();

			while(features.hasNext()){

				//logger.info("-----------New feature:"+ count);

				taskStatus.setCurValue(count++);

				FeatureProvider feature = this.createFeatureProvider(ftype);

				DynObject obj = (DynObject) features.next();

				for(int i=0; i<parser.getOrderedFieldNames().length; i++){

					int index = getDynFieldIndex(ftype, parser.getOrderedFieldNames()[i]);

					if(index>= 0){

						String fieldName = parser.getOrderedFieldNames()[i];

						Object value = null;

						value = coercion[index].coerce(obj.getDynValue(fieldName));

						if(obj.getDynClass().getDeclaredDynField(fieldName).getType() == DataTypes.GEOMETRY){

							value = obj.getDynValue(fieldName);

						}

						feature.set(fieldName, value);

						if ( sizes[i] >= 0 && value != null ) {

                            int x = ((String) value).length();

                            if ( sizes[i] < x ) {

                                sizes[i] = x;

                            }

                        }

	//					logger.info("           Adding value " + obj.getDynValue(fieldName) +" to field: "+fieldName);

					}

				}

				Geometry geom = feature.getDefaultGeometry();

				if (geom != null) {

					if (envelope == null) {

						try {

							envelope = (Envelope) geom.getEnvelope().clone();

						} catch (CloneNotSupportedException e) {

							logger.warn("Este error no deberia pasar, siempre se puede hacer un clone de un envelope.",e);

						}

					} else {

						envelope.add(geom.getEnvelope());

					}

				}

				feature.setDefaultEnvelope(envelope);

				this.addFeatureProvider(feature);

			}

			for ( int i = 0; i < ftype.size(); i++ ) {

                if ( sizes[i] > 0 ) {

                    EditableFeatureAttributeDescriptor efad = ((EditableFeatureAttributeDescriptor) edftype.getAttributeDescriptor(i));

                    efad.setSize(sizes[i]);

                }

            }

	          // Volvemos a asignar al store el featuretype, ya que puede

            // haber cambiado.

            ftype = edftype.getNotEditableCopy();

            ftypes = new ArrayList<FeatureType>();

            ftypes.add(ftype);

            store.setFeatureTypes(ftypes, ftype);

			taskStatus.terminate();

//			logger.info("---------------------------------DRIVERSTOREPROVIDER: loadFeatures() -> end");

	}

	private int getDynFieldIndex(FeatureType ftype, String name) {

	for(int i = 0; i<ftype.getDynFields().length; i++){

		if(ftype.getDynFields()[i].getName().equals(name)){

			return i;

		}

	}

	return -1;

}

	private EditableFeatureType getFeatureTypeDefinition(DynStruct struct, IProjection projection, String[] names) {

		EditableFeatureType editableFeatureType = getStoreServices().createFeatureType(this.getName());

//		logger.info("------Set Definition");

		//DynField[] fields = struct.getDynFields();

		for(int i=0; i<names.length; i++){

			DynField field = struct.getDynField(names[i]);

			if(field != null && !field.isHidden()){

				editableFeatureType.add(field.getName(), field.getType());

	//			logger.info("     Adding field: "+field.getName() + " of Type: " + field.getType());

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

					editableFeatureType.setDefaultGeometryAttributeName(field.getName());

					EditableFeatureAttributeDescriptor editableAttrDescr = 

							((EditableFeatureAttributeDescriptor) editableFeatureType

									.getDefaultGeometryAttribute());

					GeometryManager geommgr = GeometryLocator.getGeometryManager();

					GeometryType gt;

					try {

					  gt = geommgr.getGeometryType(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2D);

					  editableAttrDescr.setGeometryType(gt);

					} catch (Exception e) {

					  logger.warn("Can't set geometry type in '"+field.getName()+"' field",e);

					}

					if(projection == null){

						projection = getDriverParameters().getCRS();

					}

					editableAttrDescr.setSRS(projection);

				}

			}

		}

		editableFeatureType.setHasOID(true);

		return editableFeatureType;

	}

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 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 3

 * 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.fmap.dal.store.seismic;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.dal.DALFileLibrary;

import org.gvsig.fmap.dal.DALFileLocator;

import org.gvsig.fmap.dal.DALLibrary;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.FileHelper;

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

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.seismic.SeismicLibrary;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

public class SeismicStoreProviderLibrary extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsServiceOf(SeismicLibrary.class);

        require(SeismicLibrary.class);

        require(DALLibrary.class);

        require(DALFileLibrary.class);

    }

	@Override

	protected void doInitialize() throws LibraryException {

	}

	@Override

	protected void doPostInitialize() throws LibraryException {

		List<Throwable> exs = new ArrayList<Throwable>();

		FileHelper.registerParametersDefinition(

				SeismicStoreParameters.PARAMETERS_DEFINITION_NAME,

				SeismicStoreParameters.class, "SeismicParameters.xml");

		try {

			FileHelper.registerMetadataDefinition(

					SeismicStoreProvider.METADATA_DEFINITION_NAME,

					SeismicStoreProvider.class, "SeismicMetadata.xml");

		} catch (MetadataException e) {

			exs.add(e);

		}

		DataManagerProviderServices dataman = (DataManagerProviderServices) DALLocator

				.getDataManager();

		try {

			if (!dataman.getStoreProviders().contains(SeismicStoreProvider.NAME)) {

				dataman.registerStoreProviderFactory(new SeismicStoreProviderFactory(SeismicStoreProvider.NAME, SeismicStoreProvider.DESCRIPTION));

			}

		} catch (RuntimeException e) {

			exs.add(e);

		}

		try {

			DALFileLocator.getFilesystemServerExplorerManager()

					.registerProvider(SeismicStoreProvider.NAME,

							SeismicStoreProvider.DESCRIPTION,

							SeismicFilesystemServerProvider.class);

		} catch (RuntimeException e) {

			exs.add(e);

		}

		if (exs.size() > 0) {

			throw new LibraryException(this.getClass(), exs);

		}

	}

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 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 3

 * 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.fmap.dal.store.seismic;

import org.gvsig.fmap.dal.DataParameters;

import org.gvsig.fmap.dal.DataStoreProvider;

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

import org.gvsig.fmap.dal.feature.FeatureStoreProviderFactory;

import org.gvsig.fmap.dal.feature.spi.AbstractFeatureStoreProviderFactory;

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

import org.gvsig.tools.dynobject.DynObject;

public class SeismicStoreProviderFactory extends AbstractFeatureStoreProviderFactory implements FeatureStoreProviderFactory{

	protected SeismicStoreProviderFactory(String name, String description) {

		super(name, description);

	}

	public DataStoreProvider createProvider(DataParameters parameters,

			DataStoreProviderServices providerServices)

			throws InitializeException {

		return new SeismicStoreProvider((SeismicStoreParameters) parameters, providerServices);

	}

	public DynObject createParameters() {

		return new SeismicStoreParameters();

	}

	public int allowCreate() {

		return NO;

	}

	public int allowWrite() {

		return NO;

	}

	public int allowRead() {

		return YES;

	}

	public int hasRasterSupport() {

		return NO;

	}

	public int hasTabularSupport() {

		return YES;

	}

	public int hasVectorialSupport() {

		return YES;

	}

	public int allowMultipleGeometryTypes() {

		return YES;

	}

	public int allowEditableFeatureType() {

		return YES;

	}

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 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 3

 * 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.fmap.dal.store.seismic;

import java.io.File;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.FileHelper;

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

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

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

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynObject;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class SeismicStoreParameters extends AbstractDataParameters implements

		DataStoreParameters, FilesystemStoreParameters {

	private static final Logger logger = LoggerFactory.getLogger(SeismicStoreParameters.class);

    public static final String PARAMETERS_DEFINITION_NAME = "SeismicStoreParameters";

    private static final String FILE = "file";

    private static final String CRS = "CRS";

    private static final String PARSER = "parser";

    private static final String LOCALE = "locale";

	private static final String PROJECTID = "ProjectID";

	private static final String PROJECTNAME = "Project";

	private static final String PROJECTYEAR = "Year";

	private static final String ESTADO = "State";

	private DelegatedDynObject parameters;

	public SeismicStoreParameters() {

		this(PARAMETERS_DEFINITION_NAME);

	}

	protected SeismicStoreParameters(String parametersDefinitionName) {

		this(parametersDefinitionName, SeismicStoreProvider.NAME);

	}

	public SeismicStoreParameters(String parametersDefinitionName, String name) {

		super();

		this.parameters = (DelegatedDynObject) FileHelper.newParameters(parametersDefinitionName);

		this.setDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME, name);

	}

	public String getDataStoreName() {

		return (String) this.getDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME);

	}

	public String getDescription() {

		return this.getDynClass().getDescription();

	}

	protected DelegatedDynObject getDelegatedDynObject() {

		return parameters;

	}

	public boolean isValid() {

		if (getFileName() == null) {

			return false;

		}

		return true;

	}

	public File getFile() {

		return (File) this.getDynValue(FILE);

	}

	public void setFile(File file) {

		this.setDynValue(FILE, file);

	}

	public void setCRS(IProjection file) {

		this.setDynValue(CRS, file);

	}

	public void setProjectId(String projID) {

		this.setDynValue(PROJECTID, projID);

	}

	public void setProjectName(String projName) {

		this.setDynValue(PROJECTNAME, projName);

	}

	public void setEstado(String estado) {

		this.setDynValue(ESTADO, estado);

	}

	public void setProjectYear(int year) {

		this.setDynValue(PROJECTYEAR, year);

	}

	public IProjection getCRS() {

		return (IProjection) getDynValue(CRS);

	}

	public String getProjectId() {

		return (String) getDynValue(PROJECTID);

	}

	public String getProjectName() {

		return (String) getDynValue(PROJECTNAME);

	}

	public String getProjectYear() {

		return (String) getDynValue(PROJECTYEAR);

	}

	public String getEstado() {

		return (String) getDynValue(ESTADO);

	}

	public String getFileName() {

		File f = (File) getDynValue(FILE);

		if( f == null ) {

			return null;

		}

		return f.getPath();

	}

	public String getParserName() {

		return (String) getDynValue(PARSER);

	}

	public String getLocale() {

		return (String) getDynValue(LOCALE);

	}

}