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>

/**

 * 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 org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DALLocator;

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

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

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

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

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.serverexplorer.filesystem.impl.AbstractFilesystemServerExplorerProvider;

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

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

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

import org.gvsig.lidar.prov.LASDataStoreParameters;

import org.gvsig.lidar.prov.LASDataStoreProvider;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * 

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

 *

 */

public class JGrassLASFilesystemServerProvider extends AbstractFilesystemServerExplorerProvider implements

    FilesystemServerExplorerProvider, ResourceConsumer {

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

    private FilesystemServerExplorerProviderServices serverExplorer;

    @Override

    public String getDataStoreProviderName() {

        return JGrassLASDataStoreProvider.NAME;

    }

    @Override

    public String getDescription() {

        return JGrassLASDataStoreProvider.DESCRIPTION;

    }

    @Override

    public boolean accept(File pathname) {

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

    }

    @Override

    public boolean closeResourceRequested(ResourceProvider resource) {

        // Do nothing

        return true;

    }

    @Override

    public void resourceChanged(ResourceProvider resource) {

        // Do nothing

    }

    @Override

    public void initialize(FilesystemServerExplorerProviderServices serverExplorer) {

        this.serverExplorer = serverExplorer;

    }

    @Override

    public boolean canCreate() {

    	return true;

    }

    @Override

    public void create(NewDataStoreParameters parameters, boolean overwrite) throws CreateException {

    	if (parameters instanceof LASDataStoreParameters) {

            final LASDataStoreParameters newLASDataStoreParameters =

                (LASDataStoreParameters) parameters;

            final File file = newLASDataStoreParameters.getFile();

            if (file.isFile() && file.exists()) {

                if (overwrite) {

                    // Deleting existing file

                    try {

                        this.remove(newLASDataStoreParameters);

                    } catch (RemoveException e) {

                        throw new CreateException("Can not overwrite file", e);

                    }

                } else {

                    throw new CreateException(file.getAbsolutePath(), new IllegalArgumentException(

                        String.format("%1s exists and overwrite option is false",

                            file.getAbsolutePath())));

                }

            }

            try {

                final FileResource resource =

                    (FileResource) serverExplorer.getServerExplorerProviderServices()

                        .createResource(FileResource.NAME, new Object[] { file.getAbsolutePath() });

                resource.addConsumer(this);

                resource.execute(new ResourceAction() {

                    @Override

                    public Object run() throws Exception {

                        FeatureAttributeDescriptor geometryAttribute =

                            newLASDataStoreParameters.getDefaultFeatureType()

                                .getDefaultGeometryAttribute();

                        if (geometryAttribute != null) {

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

                        		throw new IllegalArgumentException(

                                        "LAS files can only store points.");

                        	}

                            IProjection projection = geometryAttribute.getSRS();

                            if (projection == null && newLASDataStoreParameters.getCRS() != null) {

                                projection = newLASDataStoreParameters.getCRS();

                            }

                        }

                        EditableFeatureType featureType = newLASDataStoreParameters.getDefaultFeatureType();

                        JGrassLASWriter writer = new JGrassLASWriter(newLASDataStoreParameters, featureType, null);                                            

                        writer.open();

                        writer.close();

                        return null;

                    }

                });

            } catch (InitializeException e) {

                throw new CreateException("Can not create file resource to create it", e);

            }

        }

    }

    @Override

    public NewDataStoreParameters getCreateParameters() throws DataException {

    	LASDataStoreParameters newParameters = new LASDataStoreParameters(JGrassLASDataStoreProvider.NAME);

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

        newParameters.setDefaultFeatureType(editableFeatureType);

        return newParameters;

    }

    @Override

    public void remove(DataStoreParameters parameters) throws RemoveException {

        if (parameters instanceof LASDataStoreParameters) {

        	LASDataStoreParameters newLASDataStoreParameters =

                (LASDataStoreParameters) parameters;

            final File file = newLASDataStoreParameters.getFile();

            if (!file.exists() && !file.canWrite()) {

                throw new RemoveException(file.getAbsolutePath(), new IllegalArgumentException(

                    String.format("%1s does not exist", file.getAbsolutePath())));

            }

            try {

                final FileResource resource =

                    (FileResource) serverExplorer.getServerExplorerProviderServices()

                        .createResource(FileResource.NAME, new Object[] { file.getAbsolutePath() });

                resource.addConsumer(this);

                resource.execute(new ResourceAction() {

                    @Override

                    public Object run() throws Exception {

                        resource.closeRequest();

                        file.delete();

                        return null;

                    }

                });

                resource.addConsumer(this);

            } catch (InitializeException e) {

                throw new RemoveException("Can not create file resource to remove it", e);

            }

        }

    }

    @Override

    public boolean canCreate(NewDataStoreParameters parameters) {

        if (parameters instanceof LASDataStoreParameters) {

        	LASDataStoreParameters newLASDataStoreParameters =

                (LASDataStoreParameters) parameters;

                File file = newLASDataStoreParameters.getFile();

                if (file != null && file.canWrite()) {

                    return true;

                }

                FeatureAttributeDescriptor geometryAttribute =

                    newLASDataStoreParameters.getDefaultFeatureType()

                        .getDefaultGeometryAttribute();

                if (geometryAttribute != null) {

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

                		throw new IllegalArgumentException(

                                "LAS files can only store points.");

                	}

            }

        }

        return false;

    }

    @Override

	public int getMode() {

		return DataServerExplorer.MODE_GEOMETRY|DataServerExplorer.MODE_FEATURE;

	}

}

/**

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

import java.util.List;

import org.gvsig.fmap.dal.DataParameters;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataStoreProvider;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

import org.gvsig.lidar.prov.LASDataStoreParameters;

import org.gvsig.lidar.prov.LASDataStoreProviderFactory;

import org.gvsig.tools.dynobject.DynObject;

/**

 * 

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

 *

 */

public class JGrassLASDataStoreProviderFactory extends AbstractFeatureStoreProviderFactory implements

    LASDataStoreProviderFactory {

    /**

     * @param name

     *            Name of factory

     * @param description

     *            Description of factory

     */

    public JGrassLASDataStoreProviderFactory(String name, String description) {

        super(name, description);

    }

    @Override

    public DataStoreProvider createProvider(DataParameters dataParameters,

        DataStoreProviderServices providerServices) throws InitializeException {

        return new JGrassLASDataStoreProvider((DataStoreParameters) dataParameters, providerServices);

    }

    @Override

    public DynObject createParameters() {

        return new LASDataStoreParameters(JGrassLASDataStoreProvider.NAME);

    }

    public int allowMultipleGeometryTypes() {

        return NO;

    }

    public int allowEditableFeatureType() {

        return NO;

    }

    @SuppressWarnings("rawtypes")

    public List getSupportedDataTypes() {

        List<Integer> supportedDataTypes = new ArrayList<Integer>();

        supportedDataTypes.add(DataTypes.BOOLEAN);

        supportedDataTypes.add(DataTypes.DATE);

        supportedDataTypes.add(DataTypes.FLOAT);

        supportedDataTypes.add(DataTypes.DOUBLE);

        supportedDataTypes.add(DataTypes.STRING);

        supportedDataTypes.add(DataTypes.INT);

        supportedDataTypes.add(DataTypes.LONG);

        supportedDataTypes.add(DataTypes.BYTE);

        supportedDataTypes.add(DataTypes.TIME);

        supportedDataTypes.add(DataTypes.TIMESTAMP);

        return supportedDataTypes;

    }

    @SuppressWarnings("rawtypes")

    public List getSupportedGeometryTypesSubtypes() {

        List<Integer> supportedSubtypes = new ArrayList<Integer>();

        supportedSubtypes.add(SUBTYPES.GEOM3D);

        return supportedSubtypes;

    }

    public boolean allowsMandatoryAttributes() {

        return false;

    }

    public boolean allowsPrimaryKeyAttributes() {

        return false;

    }

    public int useLocalIndexesCanImprovePerformance() {

        return YES;

    }

    @Override

    public DynObject createDataExplorerParameters(Object connectionString) {

    	return new FilesystemServerExplorerParameters();

    }

    @Override

    public DynObject createParameters(Object connectionObject) {

        return createParameters();

    }

}

package org.gvsig.lidar.prov.jgrasstools;

import java.io.File;

import java.util.Date;

import org.apache.commons.io.FileUtils;

import org.cresques.cts.ICRSFactory;

import org.cresques.cts.IProjection;

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

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

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

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

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.geom.Geometry.TYPES;

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

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

import org.gvsig.lidar.prov.ConversionUtils;

import org.gvsig.lidar.prov.LASDataStoreParameters;

import org.gvsig.lidar.prov.LASDataStoreProvider;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dispose.DisposeUtils;

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

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class JGrassLASWriter {

	protected LASDataStoreParameters params;

	protected Envelope outEnvelope;

	protected FeatureType fType;

	private int geomIndex, colorIdx, classificationIdx, weektimeIdx, gpstimeIdx, intensityIdx, returnNumIdx, numberOfReturnsIdx;

	protected ALasWriter writer = null;

	protected LasRecord record = null;

	double[] scale = null;

	double[] offset = null;

	int pointFormat = -1;

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

	public JGrassLASWriter(LASDataStoreParameters outParams, FeatureType featType, Envelope outEnvelope) throws DataException {

		this.params = outParams;

		this.outEnvelope = outEnvelope;

		this.fType = featType;

	}

	protected ALasWriter getWriter() throws CantCreateWriterException {

		if (writer==null) {

			try{

				if (ALasWriter.supportsNative()) {

					writer = new LiblasWriter(this.params.getFile(), null);

				}

				else {

					writer = new LasWriter(this.params.getFile(), null);

				}

			} catch (Exception exc) {

				throw new CantCreateWriterException("Can't create LAS writer", exc, "Can't create LAS writer", -1);

			}

		}

		return writer;

	}

	protected int getPointFormat() {

		if (this.pointFormat!=-1) {