gvSIG projects pool

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

	<parent>

		<groupId>org.gvsig</groupId>

		<artifactId>org.gvsig.lidar</artifactId>

		<version>1.0.1-SNAPSHOT</version>

	</parent>

	<artifactId>org.gvsig.lidar.prov</artifactId>

	<packaging>pom</packaging>

	<name>org.gvsig.lidar.prov</name>

	<modules>

		<module>org.gvsig.lidar.prov.common</module>

		<module>org.gvsig.lidar.prov.whitebox</module>

		<module>org.gvsig.lidar.prov.jgrass</module>

	</modules>

</project>

<?xml version="1.0"?>

<definitions>

	<version>1.0.0</version>

	<classes>

		<class name="LASDataStoreParameters">

			<extends>

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

			</extends>

			<description>Parameters needed to open LAS stores

			</description>

			<fields>

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

					<description>Coordinate reference system used</description>

				</field>

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

					<description>LAS file</description>

				</field>

				<field name="thinningDivisor" type="integer" mandatory="false" group="Basic">

					<description>Loads only 1 of every n points (1/n), e.g. thinningDivisor=10 loads 10% of total points</description>

				</field>

				<field name="thinningResolution" type="double" mandatory="false" group="Advanced">

					<description>Loads n points per square map unit (e.g. 0.0001 points/m2 on a projected layer or 100 points/km2)</description>

				</field>

			</fields>

		</class>

	</classes>

</definitions>  

/**

 * 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.lidar.prov;

import java.util.Map;

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

/**

 * 

 * @author <a href="mailto:cmartinez@scolab.es">Cesar Martinez Izquierdo</a>

 *

 */

@SuppressWarnings("unchecked")

public class LASUnsupportedFormatException extends DataException {

    private static final long serialVersionUID = -2670314598211236837L;

    private final static String MESSAGE =

        "Unsupported vectorial format. There is no LAS driver registered to open %(connectionString)";

    private final static String KEY = "_UnsupportedVectorialFormatException";

    /**

     * @param messageFormat

     *            Message format

     * @param cause

     *            Cause

     * @param messageKey

     *            Message key

     * @param code

     *            code

     * @param values

     *            Values

     */

    public LASUnsupportedFormatException(String messageFormat, Throwable cause, String messageKey,

        long code, Map<Object, Object> values) {

        super(messageFormat, cause, messageKey, code);

        this.values.putAll(values);

    }

    /**

     * @param messageFormat

     *            Message format

     * @param cause

     *            Cause

     * @param values

     *            Values

     */

    public LASUnsupportedFormatException(String messageFormat, Throwable cause,

        Map<Object, Object> values) {

        super(messageFormat, cause, KEY, serialVersionUID);

        this.values.putAll(values);

    }

    /**

     * @param connectionString

     *            Conenction string

     */

    public LASUnsupportedFormatException(String connectionString) {

        super(MESSAGE, KEY, serialVersionUID);

        this.values.put("connectionString", connectionString);

    }

}

/**

 * 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.lidar.prov;

import java.io.File;

import java.util.Iterator;

import org.apache.commons.io.FileUtils;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.exception.BaseException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * 

 * @author <a href="mailto:cmartinez@scolab.es">Cesar Martinez Izquierdo</a>

 *

 */

public abstract class LASDataStoreProvider extends AbstractFeatureStoreProvider implements

    FeatureStoreProvider, ResourceConsumer {

    private static final Logger LOG = LoggerFactory.getLogger(LASDataStoreProvider.class);

    public static final String GEOM_FIELD="GEOM";

    public static final String CLASS_FIELD="CLASSIFICATION";

    public static final String POINTX_FIELD="POINTX";

    public static final String POINTY_FIELD="POINTY";

    public static final String POINTZ_FIELD="POINTZ";

    public static final String TIME_FIELD="TIME";

    public static final String WEEKTIME_FIELD="WEEKTIME";

    public static final String COLOR_FIELD="COLOR";

    public static final String INTENSITY_FIELD="INTENSITY";

    public static final String RETURNNUM_FIELD="RETURNNUM";

    public static final String NUMRETURNS_FIELD="NUMRETURNS";

    protected File file;

    protected Envelope envelope = null;

    protected ResourceProvider resourceProvider;

    protected boolean opened = false;

    protected long counterNewsOIDs = -1;

    protected  GeometryManager gm;

    protected double decimation = 1.0d;

    protected double resolution = 0.0d;

    protected LASDataStoreProvider(DataStoreParameters dataParameters,

        DataStoreProviderServices storeServices, DynObject metadata) throws InitializeException {

        super(dataParameters, storeServices, metadata);

        // Set CRS parameter to metadata

        this.setDynValue(DataStore.METADATA_CRS, dataParameters.getDynValue(DataStore.METADATA_CRS));

        file = (File) dataParameters.getDynValue(LASDataStoreParameters.FILE_PARAMETER_NAME);

        if (dataParameters instanceof LASDataStoreParameters) {

        	LASDataStoreParameters lasParameters = (LASDataStoreParameters) dataParameters;

        	decimation = (double) lasParameters.getDecimation();

        	if (decimation<1) {

        		decimation = 1;

        	}

        	resolution = lasParameters.getResolution();

        }

        getResource().addConsumer(this);

        this.gm = GeometryLocator.getGeometryManager();

        try {

            this.open();

        } catch (OpenException e) {

            throw new InitializeException(getProviderName(), e);

        }

    }

    /*

    public FeatureProvider createFeatureProvider(FeatureType type) throws DataException {

        return new DBFFeatureProvider(this, type);

    }*/

    @Override

    public String getFullName() {

    	return getName();

    }

    @Override

    public String getName() {

        return getLASParameters().getFile().getName();

    }

    @Override

    public boolean allowWrite() {

    	return false;

    }

    @Override

    public ResourceProvider getResource() {

        if (this.resourceProvider == null) {

            try {

                this.resourceProvider =

                    this.createResource(FileResource.NAME, new Object[] { getLASParameters()

                        .getFile().getAbsolutePath() });

            } catch (InitializeException e) {

                throw new ReadRuntimeException(String.format(

                    "Can not create file resource with %1s path", getLASParameters().getFile()

                        .getAbsolutePath()), e);

            }

        }

        return resourceProvider;

    }

    @Override

    public Object getSourceId() {

        return this.getLASParameters().getFile();

    }

    @Override

    public void open() throws OpenException {

    	// FIXME: should this method be synchronized?

        if (opened == false) {

            try {

            	this.opened = loadFeatureType();

                updateDecimationFromResolution();

            } catch (BaseException e) {

                LOG.error("Can not load feature type", e);

                throw new OpenException(getFullName(), e);

            }

        }

    }

    protected void updateDecimationFromResolution() {

    	if (resolution>0.0d) {

    		try {

				double width = getEnvelope().getLength(0);

				double height = getEnvelope().getLength(1);

				long count = getFeatureCount();

				double origResolution = ((count/width)/height); // divide twice instead of multiply denominator to avoid overflow of the product

				double calculatedDecimation = origResolution/resolution;

				if (calculatedDecimation>1) {

					decimation = calculatedDecimation;

				}

				else {

					decimation = 1;

				}

			} catch (DataException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

    	}

    }

    protected abstract boolean loadFeatureType() throws LASUnsupportedFormatException,

        GeometryTypeNotSupportedException, GeometryTypeNotValidException, DataException;

    @SuppressWarnings("rawtypes")

    @Override

    public void performChanges(Iterator deleteds, Iterator inserteds,

            Iterator updateds, Iterator originalFeatureTypesUpdated)

            throws PerformEditingException {

        try {

            final FeatureStore store

                    = this.getStoreServices().getFeatureStore();

            getResource().closeRequest();

            getResource().execute(new ResourceAction() {

                public Object run() throws Exception {

                    FeatureSet set = null;

                    DisposableIterator iter = null;

                    try {

                        set = store.getFeatureSet();

                        LASDataStoreParameters params = (LASDataStoreParameters) getParameters();

                        LASDataStoreParameters tmpParams

                                = (LASDataStoreParameters) params.getCopy();

                        File tmp_file = File.createTempFile(

                                "tmp_" + System.currentTimeMillis(), ".las");

                        tmp_file.deleteOnExit();

                        tmpParams.setFile(tmp_file);

                        /*

                        writer.begin(tmpParams, store.getDefaultFeatureType(),

                                set.getSize());

                        iter = set.fastIterator();

                        while (iter.hasNext()) {

                            Feature feature = (Feature) iter.next();

                            writer.append(feature);

                        }

                        writer.end();

						*/

                        try {

                            close();

                        } catch (CloseException e1) {

                            throw new PerformEditingException(getProviderName(), e1);

                        }

                        params.getFile().delete();

                        File target_file = params.getFile();

                        if (target_file.exists()) {

                            target_file.delete();

                        }

                        tmp_file.renameTo(target_file);

                        if (tmp_file.exists() && !target_file.exists()) {

                            // Renaming failed, let's simply copy.

                            // We assume we cannot delete it, but we

                            // used deleteOnExit and it's

                            // temporary, so no problem

                            LOG.info("Warning: copying tmp file instead of renaming: "

                                    + target_file.getName());

                            FileUtils.copyFile(tmp_file, target_file);

                        }

                        getResource().notifyChanges();

                        loadFeatureType();

                    } finally {

                        if (set != null) {

                            set.dispose();

                        }

                        if (iter != null) {

                            iter.dispose();

                        }

                    }

                    return null;

                }

            });

        } catch (ResourceExecuteException | ResourceException e) {

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

        }

        this.counterNewsOIDs = -1;

    }

    @Override

    public Object createNewOID() {

        if (this.counterNewsOIDs < 0) {

            try {

                this.counterNewsOIDs = this.getFeatureCount();

            } catch (DataException e) {

                e.printStackTrace();

            }

        } else {

            this.counterNewsOIDs++;

        }

        return new Long(counterNewsOIDs);

    }

    @Override

    public FeatureSetProvider createSet(FeatureQuery query, FeatureType featureType)

        throws DataException {

        open();

        return new LASFetureSetProvider(this, query, featureType);

    }

    @Override

    public int getOIDType() {

        return DataTypes.LONG;

    }

    @Override

    protected FeatureProvider internalGetFeatureProviderByReference(

        FeatureReferenceProviderServices reference, FeatureType featureType)

        throws DataException {

    	return internalGetFeatureProviderByIndex(((Long) reference.getOID()).longValue(), featureType);

    }

    public abstract FeatureProvider internalGetFeatureProviderByIndex(

    		long index, FeatureType featureType)

    				throws DataException;

    protected LASDataStoreParameters getLASParameters() {

        return (LASDataStoreParameters) this.getParameters();

    }

}

/**

 * 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.lidar.prov;

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

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.exception.BaseException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * 

 * @author <a href="mailto:cmartinez@scolab.es">Cesar Martinez Izquierdo</a>

 *

 */

public class LASFetureSetProvider extends AbstractFeatureSetProvider implements FeatureSetProvider {

    private static final Logger LOG = LoggerFactory.getLogger(LASFetureSetProvider.class);

    private static final String regularExpresion =

        "\\s*ST_intersects[(]\\s*ST_GeomFromText[(]\\s*'([^']*)'\\s*,\\s*'([^']*)'\\s*[)],\\s*(?s).*";

    /**

     * @param store

     *            Source of this feature set

     * @param query

     *            Query

     * @param featureType

     *            Featuretype requested

     */

    public LASFetureSetProvider(AbstractFeatureStoreProvider store, FeatureQuery query,

        FeatureType featureType) {

        super(store, query, featureType);

    }

    @Override

    public boolean canFilter() {

        return false;

    }

    @Override

    public boolean canOrder() {

        return false;

    }

    @Override

    public boolean canIterateFromIndex() {

        return true;

    }

    @Override

    public long getSize() throws DataException {

        return getStore().getFeatureCount(); // FIXME

    }

    @Override

    public boolean isEmpty() throws DataException {

        return getSize() == 0;

    }

    @Override

    protected AbstractFeatureProviderIterator createIterator(long index) throws DataException {

        return createFastIterator(index);

    }

    @Override

    protected AbstractFeatureProviderIterator createFastIterator(long index) throws DataException {

        return new LASFastIterator(getStore(), index);

    }

    @Override

    protected void doDispose() throws BaseException {

    }

    class LASFastIterator extends AbstractFeatureProviderIterator {

        private long index;

        public LASFastIterator(FeatureStoreProvider storeProvider, long index)

            throws LASUnsupportedFormatException {

            super(storeProvider);

            ToolsLocator.getDisposableManager().bind(storeProvider);

            this.index = index;

        }

        @Override

        public void remove() {

        	throw new UnsupportedOperationException();

        }

        @Override

        protected Object internalNext() {

        	try {

				return ((LASDataStoreProvider)this.getDataStoreProvider()).internalGetFeatureProviderByIndex(index++, getFeatureType());

			} catch (DataException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

        	return null;

        }

        @Override

        protected boolean internalHasNext() {

            try {

				return index < ((LASDataStoreProvider)this.getDataStoreProvider()).getFeatureCount() ? true : false;

			} catch (DataException e) {

				e.printStackTrace();

			}

            return false;

        }

        @Override

        protected void doDispose() throws BaseException {

            ToolsLocator.getDisposableManager().release(getStore());

        }

    }

}

package org.gvsig.lidar.prov;

public class ConversionUtils {

    private static final int RED_MASK = 255 << 16;

    private static final int GREEN_MASK = 255 << 8;

    private static final int BLUE_MASK = 255;

    /**

     * GPS time as GPS timestamp = LAS  GPS adjusted time + 1000000000

     * GPS time as Unix timestamp = GPS time as GPS timestamp + 315964800

     * UTC time as Unix timestamp = GPS time as Unix timestamp + leap seconds

     * As leap seconds depend on the actual date being converted, we'll ignore them

     * Therefore, we'll use the following constant

     * UNIX TIME = LAS GPS adjusted time + LAS_TIME_TO_UNIX_TIME,

     * where LAS_TIME_TO_UNIX_TIME = 1000000000 + 315964800 = 1315964800

     */

    final public static long LAS_TIME_TO_UNIX_TIME = 1315964800;

    /**

     * Converts red, green and blue values to a RGB int as defined

     * by java.awt.Color(int) constructor.

     * 

     */

    public static int rgbToInt(int red, int green, int blue) {

    	return (red << 16) | (green << 8) | blue;

    }

    /**

     * Converts a RGB int as defined by java.awt.Color(int) constructor

     * to separate red, green and blue values

     * 

     * @returns an array containing the red, green and blue values

     */

    public static int[] intToRgb(int rgb) {

    	int[] rgbArray = new int[3];

    	rgbArray[0] = (rgb & RED_MASK) >> 16;

        rgbArray[1] = (rgb & GREEN_MASK) >> 8;

    	rgbArray[2] = rgb & BLUE_MASK;

    	return rgbArray;

    }

}

/**

 * 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.lidar.prov;

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

import org.gvsig.tools.dynobject.DynObject;

/**

 * LAS Data Store Provider factory to create parameters to create

 * specific server data explorers and specific data store providers.

 * 

 * @author <a href="mailto:cmartinez@scolab.es">Cesar Martinez Izquierdo</a>

 *

 */

public interface LASDataStoreProviderFactory extends FeatureStoreProviderFactory {

    /**

     * Creates specific parameters if factory can open connection object. If it

     * can not open, it will be return null.

     * 

     * @param connectionObject

     *            File or connection string to be opened

     * @return Data explorer parameters If this factory can open connection

     *         object it will be return specific parameters, otherwise return

     *         null.

     */

    public DynObject createParameters(Object connectionObject);

    /**

     * Creates specific data explorer parameters if factory can open connection

     * object. If it

     * can not open, it will be return null.

     * 

     * @param connectionObject

     *            File or connection string to be opened

     * @return Data explorer parameters If this factory can open connection

     *         object it will be return specific data explrer parameters,

     *         otherwise return

     *         null.

     */

    public DynObject createDataExplorerParameters(Object connectionObject);

}

/**

 * 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.lidar.prov;

import java.io.File;

import java.io.IOException;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.cresques.cts.ICRSFactory;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

import org.gvsig.tools.dynobject.DelegatedDynObject;

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

/**

 * 

 * @author <a href="mailto:cmartinez@scolab.es">Cesar Martinez Izquierdo</a>

 *

 */

public class LASDataStoreParameters extends AbstractDataParameters

		implements DataStoreParameters, FilesystemStoreParameters, NewFeatureStoreParameters {

    public static final String FILE_PARAMETER_NAME = "file";

    public static final String CRS_PARAMETER_NAME = "CRS";

    public static final String POINT_DENSITY_PARAMETER_NAME = "PointDensity";

    /**

     * Simple method to load a subset of the data, useful for faster

     * visualization. The decimation parameter will only keep the n'th

     * point from the file. For instance, a value of 2 will skip half

     * of the points. A value of 3 will load 1/3 of the original points.

     * A value of 10 will load 1/10 of the original points.

     */

    public static final String THINNING_DIV_PARAMETER_NAME = "thinningDivisor";

    /**

     * An alternative method to load a subset of the data. This parameter

     * defines how many points should be loaded by square map unit.

     * For instance, a value of 0.1 on a layer using EPSG:25830 means that

     * 0.1 points should be loaded per square meter (100.000 points per

     * square kilometer). The same value for a layer using EPSG:4326 means

     * that 0.1 points should be loaded per square degree.

     * 

     * Note that this is an approximated method which assumes that points are

     * evenly separated on x and y axis. When resolution is defined,

     * the decimation parameter is ignored.

     * 

     */

    public static final String THINNING_RESOLUTION_PARAMETER_NAME = "thinningResolution";

    protected DelegatedDynObject parameters;

    public static final String DATASET_CREATION_OPTION_PARAMETER_NAME = "datasetCreationOptions";

    public static final String PARAMETERS_DEFINITION_NAME = "LASDataStoreParameters";

	public LASDataStoreParameters() {

		this(PARAMETERS_DEFINITION_NAME, "to be defined");

	}

    public LASDataStoreParameters(String providerName) {

    	this(PARAMETERS_DEFINITION_NAME, providerName);

    }

    public LASDataStoreParameters(String parametersDefinitionName, String providerName) {

        this.parameters =

            (DelegatedDynObject) ToolsLocator.getDynObjectManager().createDynObject(

                ToolsLocator.getPersistenceManager().getDefinition(parametersDefinitionName));

        this.setDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME, providerName);

    }

	public String getDataStoreName() {

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

	}

	public String getDescription() {

		return this.getDynClass().getDescription();

	}

    /**

     * @return File

     */

    public File getFile() {

        return (File) this.getDynValue(FILE_PARAMETER_NAME);

    }

    /**

     * 

     * @return String

     */

    public IProjection getCRS() {

        return (IProjection) this.getDynValue(CRS_PARAMETER_NAME);

    }

    /**

     * @param file

     *            File

     */

    public void setFile(File file) {

        this.setDynValue(FILE_PARAMETER_NAME, file);

        if (getCRS()==null) {

        	// only set CRS automatically if it has not been previously set

        	loadProj();

        }

    }

    private void loadProj() {

    	String wktString = readProj();

        if (wktString != null) {

            IProjection proj = CRSFactory.getCRSFactory().get(ICRSFactory.FORMAT_WKT, wktString);

            setCRS(proj);

        }

    }

	private String readProj(){

        File prjFile = getPrj();

        if (prjFile.exists()) {

            try {

                return FileUtils.readFileToString(prjFile);

            } catch (IOException e) {

                return null;

            }

        }

        return null;

	}

	/**

	 * Gets the .prj path corresponding to the .las file. It will

	 * always return a path if getFile is not null, even if none

	 * of the files actually exists. 

	 *  

	 * @return

	 */

    public File getPrj() {

    	File lasFile = getFile(); 

    	if (lasFile!=null) {

    		String path = lasFile.getPath();

    		String baseName = FilenameUtils.getFullPath(path) + FilenameUtils.getBaseName(path);

    		return new File(baseName + ".prj");

    	}

    	return null;

    }

    /**

     * 

     * @param crs

     */

    public void setCRS(IProjection crs) {

        this.setDynValue(CRS_PARAMETER_NAME, crs);

    }

    public int getDecimation() {

    	try {

    		this.hasDynValue(THINNING_DIV_PARAMETER_NAME);

    		return (int) this.getDynValue(THINNING_DIV_PARAMETER_NAME);

    	}

    	catch (Exception ex) {}

    	return 0;

    }

    public double getResolution() {

    	try {

    		this.hasDynValue(THINNING_RESOLUTION_PARAMETER_NAME);

    		return (double) this.getDynValue(THINNING_RESOLUTION_PARAMETER_NAME);

    	}

    	catch (Exception ex) {}

    	return 0.0d;

    }

    @Override

    public boolean isValid() {

        if (this.getFile() != null && this.getFile().exists()) {

            return true;

        }

        return false;

    }

    @Override

    protected DelegatedDynObject getDelegatedDynObject() {

        return parameters;

    }

    @Override

    public void setDefaultFeatureType(FeatureType defaultFeatureType) {

        this.setDynValue(FEATURETYPE_PARAMTER_NAME, defaultFeatureType);

    }

    @Override

    public EditableFeatureType getDefaultFeatureType() {

        return (EditableFeatureType) this.getDynValue(FEATURETYPE_PARAMTER_NAME);

    }

	@Override

	public void validate() throws ValidateDataParametersException {

		fixParameters();

		super.validate();

	}

    public void fixParameters() {

    	try {

    		EditableFeatureType featureType = getDefaultFeatureType();    

    		if (featureType != null) {

    			FeatureAttributeDescriptor geometryAttribute =

    					featureType.getAttributeDescriptor(featureType.getDefaultGeometryAttributeName());

    			if (geometryAttribute != null) {

    				//If the CRS parameter has not been fixed, but there is

    				//a geometric attribute with the CRS, this attribute

    				//can be used.

    				if (getCRS() == null) {

    					setCRS(geometryAttribute.getSRS());

    				}

    			}

    		}

    	}

    	catch (DynFieldNotFoundException ex) {

    		// we are not creating a new NewFeatureStoreParameters,

    		// we can safely ignore the error

    	}

    }

}

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

	<parent>

		<groupId>org.gvsig</groupId>

		<artifactId>org.gvsig.lidar.prov</artifactId>

		<version>1.0.1-SNAPSHOT</version>

	</parent>

	<artifactId>org.gvsig.lidar.prov.common</artifactId>

	<name>org.gvsig.lidar.prov.common</name>

	<dependencies>

		<dependency>

			<groupId>org.gvsig</groupId>

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

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.fmap.dal.spi</artifactId>

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.tools.lib</artifactId>

			<scope>compile</scope>

		</dependency>

                <dependency>

                        <groupId>commons-io</groupId>

                        <artifactId>commons-io</artifactId>

                </dependency>

	</dependencies>

</project>

<?xml version="1.0"?>

<!--

Definitions of metadata fields of a shp file.  

 -->

<definitions>

  <version>1.0.0</version>

  <classes>

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

      <extends>

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

      </extends>

      <description>Metadata of a LIDAR LAS provider</description>

      <fields>

      </fields>

    </class>

  </classes>

</definitions>  

org.gvsig.lidar.prov.jgrasstools.JGrassLASLibrary

/**

 * 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.lidar.prov.jgrasstools;

import java.io.File;

import java.io.IOException;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Date;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import org.apache.commons.io.FileUtils;

import org.cresques.cts.ICRSFactory;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

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

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

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

import org.gvsig.lidar.prov.LASDataStoreParameters;

import org.gvsig.lidar.prov.LASDataStoreProvider;

import org.gvsig.lidar.prov.ConversionUtils;

import org.gvsig.lidar.prov.LASUnsupportedFormatException;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.exception.BaseException;

import org.jgrasstools.gears.io.las.core.ALasReader;

import org.jgrasstools.gears.io.las.core.ILasHeader;

import org.jgrasstools.gears.io.las.core.LasRecord;

import org.jgrasstools.gears.io.las.core.liblas.LiblasReader;

import org.jgrasstools.gears.io.las.core.v_1_0.LasReader;

import org.jgrasstools.gears.io.las.core.v_1_0.LasWriter;

import org.opengis.metadata.Identifier;

import org.opengis.metadata.extent.Extent;

import org.opengis.referencing.crs.CRSFactory;

import org.opengis.referencing.crs.CoordinateReferenceSystem;

import org.opengis.referencing.cs.CoordinateSystem;

import org.opengis.util.GenericName;

import org.opengis.util.InternationalString;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.sun.jna.Native;

import com.sun.jna.NativeLibrary;

/**

 * 

 * @author <a href="mailto:cmartinez@scolab.es">Cesar Martinez Izquierdo</a>

 *

 */

public class JGrassLASDataStoreProvider extends LASDataStoreProvider {

    private static final Logger LOG = LoggerFactory.getLogger(JGrassLASDataStoreProvider.class);

    public static final String NAME = "JGrassLASDataStoreProvider";

    public static final String DESCRIPTION = "LIDAR LAS file (jgrasstools)";

    public static final String METADATA_DEFINITION_NAME = "JGrassLASDataStoreProvider";

    protected ALasReader reader = null;

    protected JGrassLASDataStoreProvider(DataStoreParameters dataParameters,

        DataStoreProviderServices storeServices, DynObject metadata) throws InitializeException {

        super(dataParameters, storeServices, metadata);

    }

    protected JGrassLASDataStoreProvider(DataStoreParameters dataParameters,

        DataStoreProviderServices storeServices) throws InitializeException {

    	super(dataParameters, storeServices, FileHelper

    	        .newMetadataContainer(METADATA_DEFINITION_NAME));

    }

    @Override

    public String getFullName() {

    	return getName();

    }

    @Override

    public String getName() {

        return getLASParameters().getFile().getName();

    }

    @Override

    public String getProviderName() {

        return NAME;

    }

    @Override

    public boolean allowWrite() {

    	return true;

    }

    protected boolean loadFeatureType() throws LASUnsupportedFormatException,

        GeometryTypeNotSupportedException, GeometryTypeNotValidException, DataException {

        return (boolean) getResource().execute(new ResourceAction() {

            @Override

            public Object run() throws Exception {

            	EditableFeatureType editableFeatureType = DALLocator.getDataManager().createFeatureType();

                editableFeatureType.setHasOID(true);

                EditableFeatureAttributeDescriptor attributeDescriptor = editableFeatureType.add("GEOM",  DataTypes.GEOMETRY);

                GeometryManager geometryManager = GeometryLocator.getGeometryManager();

                GeometryType geometryType =

                        geometryManager.getGeometryType(

                        		TYPES.POINT, SUBTYPES.GEOM3D);

                attributeDescriptor.setGeometryType(geometryType);

                if (getLASParameters().getCRS()!=null) {

                	attributeDescriptor.setSRS(getLASParameters().getCRS());

                }

                editableFeatureType.setDefaultGeometryAttributeName(JGrassLASDataStoreProvider.GEOM_FIELD);

                attributeDescriptor =

                        editableFeatureType.add(CLASS_FIELD, DataTypes.BYTE);

                attributeDescriptor =

                        editableFeatureType.add(POINTX_FIELD, DataTypes.DOUBLE);

                attributeDescriptor =

                        editableFeatureType.add(POINTY_FIELD, DataTypes.DOUBLE);

                attributeDescriptor =

                        editableFeatureType.add(POINTZ_FIELD, DataTypes.DOUBLE);

                attributeDescriptor =

                        editableFeatureType.add(INTENSITY_FIELD, DataTypes.INT);

                attributeDescriptor =

                        editableFeatureType.add(RETURNNUM_FIELD, DataTypes.BYTE);

                attributeDescriptor =

                        editableFeatureType.add(NUMRETURNS_FIELD, DataTypes.BYTE);

                ILasHeader header = getReader().getHeader();

                if (header.hasRGB()) {

                	attributeDescriptor =

                            editableFeatureType.add(COLOR_FIELD, DataTypes.INT);

                }

                if (header.hasGpsTime()) {

                	if (header.getGpsTimeType()==1) {

                		// Show adjusted standard GPS time as a Java Date

                		attributeDescriptor = editableFeatureType.add(TIME_FIELD, DataTypes.DATE);

                	}

                	else {

                		// Show GPS week time as a plain long, as we don't have enough context to translate it to a real date

                		attributeDescriptor = editableFeatureType.add(WEEKTIME_FIELD, DataTypes.LONG);

                	}

                }

                FeatureType featureType = editableFeatureType.getNotEditableCopy();

                if (featureType.getDefaultSRS() != null) {

                    setDynValue(DataStore.METADATA_CRS, featureType.getDefaultSRS());

                }

                List<FeatureType> featureTypes = new ArrayList<FeatureType>(1);

                featureTypes.add(featureType);

                getStoreServices().setFeatureTypes(featureTypes, featureType);

                return true;

            }

        });

    }

    public FeatureProvider internalGetFeatureProviderByIndex(

    		long index, FeatureType featureType)

    				throws DataException {

    	long decimatedIndex = (long) Math.floor(index * decimation);

    	FeatureProvider featureProvider = this.createFeatureProvider(featureType);

    	featureProvider.setOID(new Long(decimatedIndex));

    	LasRecord record;

		try {

			record = getReader().getPointAt(decimatedIndex);

		} catch (IOException e1) {

			throw new FeatureIndexException("Error accessing record", e1,

					"Error accessing record", -1);

		}

		if (featureType.getAttributeDescriptor(GEOM_FIELD)!=null) {

			try {

				Point p = (Point) this.gm.create(TYPES.POINT, SUBTYPES.GEOM3D);

				p.setCoordinateAt(0, record.x);

				p.setCoordinateAt(1, record.y);

				p.setCoordinateAt(2, record.z);

				featureProvider.set(GEOM_FIELD, p);

			} catch (CreateGeometryException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

		}

    	if (featureType.getAttributeDescriptor(POINTX_FIELD)!=null) {

    		featureProvider.set(POINTX_FIELD, record.x);

    	}

    	if (featureType.getAttributeDescriptor(POINTY_FIELD)!=null) {

    		featureProvider.set(POINTY_FIELD, record.y);

    	}

    	if (featureType.getAttributeDescriptor(POINTZ_FIELD)!=null) {

    		featureProvider.set(POINTZ_FIELD, record.z);

    	}

    	if (featureType.getAttributeDescriptor(CLASS_FIELD)!=null) {

    		featureProvider.set(CLASS_FIELD, record.classification);

    	}

    	if (featureType.getAttributeDescriptor(INTENSITY_FIELD)!=null) {

    		featureProvider.set(INTENSITY_FIELD, (int)record.intensity);

    	}

    	if (featureType.getAttributeDescriptor(RETURNNUM_FIELD)!=null) {

    		featureProvider.set(RETURNNUM_FIELD, (byte)record.returnNumber);

    	}

    	if (featureType.getAttributeDescriptor(NUMRETURNS_FIELD)!=null) {

    		featureProvider.set(NUMRETURNS_FIELD, (byte) record.numberOfReturns);

    	}

    	if (featureType.getAttributeDescriptor(TIME_FIELD)!=null) {

    		long las_time  = (long)record.gpsTime;

    		// file uses LAS 1.2/1.3/1.4 adjusted GPS Time

    		// convert to unix time and build a Date object

    		Date unix_time = new Date(las_time + ConversionUtils.LAS_TIME_TO_UNIX_TIME);

			featureProvider.set(TIME_FIELD, unix_time);

    	}

    	if (featureType.getAttributeDescriptor(WEEKTIME_FIELD)!=null) {

    		// LAS 1.0, 1.1 gps week time, we handle it as a plain long.

    		// It could be translated to Unix time using the following formulas:

    		// seconds_per_week = 604800

    		// las_gps_time = las_week_time + ( week_number_from_6_1_1980 * seconds_per_week)

    		// unix_time = las_gps_time + 315964800

    		long las_time  = (long)record.gpsTime;

    		featureProvider.set(WEEKTIME_FIELD, new Long(las_time));

    	}

    	if (featureType.getAttributeDescriptor(COLOR_FIELD)!=null) {

    		int red = record.color[0];

    		int green = record.color[1];

    		int blue = record.color[2];

    		// RGB value representing the color in the default sRGB ColorModel.

    		// (Bits 24-31 are alpha, 16-23 are red, 8-15 are green, 0-7 are blue).

    		featureProvider.set(COLOR_FIELD, ConversionUtils.rgbToInt(red, green, blue));

    	}

    	return featureProvider;

    }

    protected synchronized ALasReader getReader() throws LASUnsupportedFormatException, OpenException {

        if (this.reader == null) {

        	/**

        	 * We create a fake geoapi CRS, because providing a null CRS to JGrasstools readers

        	 * causes errors if the .prj file exists and the dependences are not satisfied

        	 */

        	CoordinateReferenceSystemFakeImpl crs = new CoordinateReferenceSystemFakeImpl();

        	try {

        		if (ALasReader.supportsNative()) {

        			reader = new LiblasReader(file, crs);

        			LOG.info("JGrass LiblasReader loaded");

        		}

        	} catch (Exception exc) {

        		LOG.debug("Error loading native liblas reader", exc);

        	}

        	if (reader==null) {

        		try {

        			reader = new LasReader(file, crs);

        			LOG.info("JGrass LasReader loaded");

        		}

        		catch (Exception e) {

        			throw new OpenException("Error loading Java JGrass LAS reader", e);

        		}

        	}

        	try {

        		reader.open();

        	} catch (Exception e) {

        		throw new OpenException("Error opening JGrass LAS reader", e);

        	}

        }

        return this.reader;

    }

    /*

     * Lazy envelope initialization

     */

    @Override

    public Envelope getEnvelope() throws DataException {

        open();

        if (this.envelope == null) {

        	Envelope env;

			try {

				env = this.gm.createEnvelope(SUBTYPES.GEOM3D);

	        	Point p1 = (Point) this.gm.create(TYPES.POINT, SUBTYPES.GEOM3D);

	        	Point p2 = (Point) this.gm.create(TYPES.POINT, SUBTYPES.GEOM3D);

	        	// FIXME: do we need to consider projection for upper & lower corner?

	        	ILasHeader header = getReader().getHeader();

	        	double[] env3d = header.getRawDataEnvelope();

	        	p1.setCoordinateAt(0, env3d[0]);

	        	p1.setCoordinateAt(1, env3d[1]);

	        	p1.setCoordinateAt(2, env3d[2]);

	        	p2.setCoordinateAt(0, env3d[3]);

	        	p2.setCoordinateAt(1, env3d[4]);

	        	p2.setCoordinateAt(2, env3d[5]);

	        	env.setLowerCorner(p1);

	        	env.setUpperCorner(p2);

	        	this.envelope = env;

			} catch (CreateEnvelopeException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			} catch (CreateGeometryException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

        }

        return this.envelope;

    }

    @Override

    public long getFeatureCount() throws DataException {

        open();

        return ((Number) getResource().execute(new ResourceAction() {

            @Override

            public Object run() throws Exception {

            	long count = getReader().getHeader().getRecordsCount();

            	if (decimation>1.0d) {

            		count = (long) Math.floor((count/decimation));

            	}

            	return count;

            }

        })).longValue();

    }

    @Override

    protected void doDispose() throws BaseException {

        super.doDispose();

        getResource().removeConsumer(this);

        this.resourceProvider = null;

        this.gm = null;

        this.envelope = null;

        this.opened = false;

        try { this.reader.close(); } catch (Exception e) {}

        this.reader = null;

    }

    @Override

    public boolean closeResourceRequested(ResourceProvider resource) {

        this.envelope = null;

        this.opened = false;

        try { this.reader.close(); } catch (Exception e) {}

        this.reader = null;

        return true;

    }

    @Override

    public void resourceChanged(ResourceProvider resource) {

        this.envelope = null;

        this.opened = false;

        try { this.reader.close(); } catch (Exception e) {}

        this.reader = null;

    }

    @SuppressWarnings("rawtypes")

    public void performChanges(Iterator deleteds, Iterator inserteds, Iterator updateds,

        Iterator originalFeatureTypesUpdated) throws PerformEditingException {

        final FeatureType fType;

        try {

            fType = this.getStoreServices().getDefaultFeatureType();

        } catch (DataException e) {

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

        }

        final FeatureAttributeDescriptor geomAttrib = fType.getDefaultGeometryAttribute();

        if (geomAttrib.getGeomType().getType()!=TYPES.POINT) {