gvSIG projects pool

/**

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

                throw new PerformEditingException(getProviderName(), new RuntimeException("LAS files can only store points"));

        }

        try {

            resourceCloseRequest();

            getResource().execute(new ResourceAction() {

                public Object run() throws Exception {

                    FeatureSet set = null;

                    DisposableIterator iter = null;

                    try {

                        set = getFeatureStore().getFeatureSet();

                        LASDataStoreParameters lasParams = getLASParameters();

                        LASDataStoreParameters tmpParams = (LASDataStoreParameters) lasParams.getCopy();

                        File tmp_file = File.createTempFile("tmp_" + System.currentTimeMillis(), ".las");

                        tmpParams.setFile(tmp_file);

                        JGrassLASWriter writer = new JGrassLASWriter(tmpParams, fType, getFeatureStore().getEnvelope());                        

                        ILasHeader h = getReader().getHeader();

                        writer.setOffset(h.getXYZOffset()[0], h.getXYZOffset()[1], h.getXYZOffset()[2]);

                        writer.setScale(h.getXYZScale()[0], h.getXYZScale()[1], h.getXYZScale()[2]);

                        writer.setPointFormat(h.getPointDataFormat());

                        writer.open();

                        iter = set.fastIterator();

                        while (iter.hasNext()) {

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

                            writer.write(feature);

                        }

                        writer.close();

                        close();

                        if (!lasParams.getFile().delete()) {

                            LOG.debug("Can't delete las file '" + lasParams.getFile() + "'.");

                            throw new IOException("Can't delete las '"

                                + lasParams.getFile().getAbsolutePath()

                                + "' file to replace with the new las.\nThe new las is in temporary file '" + tmp_file.getCanonicalPath()

                                + "'");

                        }

                        FileUtils.moveFile(tmpParams.getFile(), lasParams.getFile());

                        return null;

                    } finally {

                        dispose(set);

                        dispose(iter);

                        getResource().notifyChanges();

                    }

                }

            });

        } catch (Exception e) {

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

        }

    }

    protected void resourceCloseRequest() throws ResourceException {

        getResource().closeRequest();

    }

    public FeatureProvider createFeatureProvider(FeatureType type) throws DataException {

            return new DefaultFeatureProvider(type);

    }

    /**

     * A fake implementation of GeoAPI CoordinateReferenceSystem. It must

     * only be used to fake JGrass LAS readers, as they are happy if a

     * CRS fake object is provided (they won't do anything special with it)

     */

    public class CoordinateReferenceSystemFakeImpl implements CoordinateReferenceSystem {

            public CoordinateReferenceSystemFakeImpl() {

            }

                public Extent getDomainOfValidity() {

                        // TODO Auto-generated method stub

                        return null;

                }

                public InternationalString getScope() {

                        // TODO Auto-generated method stub

                        return null;

                }

                public Collection<GenericName> getAlias() {

                        // TODO Auto-generated method stub

                        return null;

                }

                /**

                 * Identifier must be replaced by ReferenceIdentifier when

                 * using Geoapi >= 3.0

                 */

                public Set<Identifier> getIdentifiers() {

                        // TODO Auto-generated method stub

                        return null;

                }

                /**

                 * Identifier must be replaced by ReferenceIdentifier when

                 * using Geoapi >= 3.0

                 */

                public Identifier getName() {

                        // TODO Auto-generated method stub

                        return null;

                }

                public InternationalString getRemarks() {

                        // TODO Auto-generated method stub

                        return null;

                }

                public String toWKT() throws UnsupportedOperationException {

                        return null;

                }

                public CoordinateSystem getCoordinateSystem() {

                        // TODO Auto-generated method stub

                        return null;

                }

                public Extent getValidArea() {

                        return null;

                }

    }

}