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

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

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

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

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

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

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

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

import org.gvsig.lidar.prov.ConversionUtils;

import org.gvsig.lidar.prov.LASUnsupportedFormatException;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.exception.BaseException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import whitebox.geospatialfiles.LASReader;

import whitebox.geospatialfiles.LASReader.PointRecColours;

import whitebox.geospatialfiles.LASReader.PointRecord;

/**

 * 

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

 *

 */

public class WhiteboxLASDataStoreProvider extends LASDataStoreProvider {

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

    public static final String NAME = "WhiteboxLASDataStoreProvider";

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

    public static final String METADATA_DEFINITION_NAME = "WhiteboxLASDataStoreProvider";

    protected LASReader reader = null;

    protected WhiteboxLASDataStoreProvider(DataStoreParameters dataParameters,

        DataStoreProviderServices storeServices, DynObject metadata) throws InitializeException {

        super(dataParameters, storeServices, metadata);

    }

    protected WhiteboxLASDataStoreProvider(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 false;

    }

    protected boolean loadFeatureType() throws LASUnsupportedFormatException,

        GeometryTypeNotSupportedException, GeometryTypeNotValidException {

        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(WhiteboxLASDataStoreProvider.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);

                short pointFormatId = getReader().getPointDataFormatID();

                switch (pointFormatId) {

                        case 1:

                        case 3:

                        case 4:

                        case 5:

                                if (getReader().getGPSTimeType()==1) {

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

                                }

                                else {

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

                                }

                                break;

                }

                switch (pointFormatId) {

                    case 2:

                    case 3:

                    case 5:

                    case 7:

                    case 8:

                    case 10:

                            attributeDescriptor =

                    editableFeatureType.add(COLOR_FIELD, DataTypes.INT);

                            break;

                }

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

            PointRecord record = getReader().getPointRecord((int)decimatedIndex);

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

                    try {

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

                            p.setCoordinateAt(0, record.getX());

                            p.setCoordinateAt(1, record.getY());

                            p.setCoordinateAt(2, record.getZ());

                            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.getX());

            }

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

                    featureProvider.set(POINTY_FIELD, record.getY());

            }

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

                    featureProvider.set(POINTZ_FIELD, record.getZ());

            }

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

                    featureProvider.set(CLASS_FIELD, record.getClassification());

            }

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

                    featureProvider.set(INTENSITY_FIELD, record.getIntensity());

            }

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

                    featureProvider.set(RETURNNUM_FIELD, record.getReturnNumber());

            }

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

                    featureProvider.set(NUMRETURNS_FIELD, record.getNumberOfReturns());

            }

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

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

                    // convert to unix time and build a Date object

                    long las_time  = (long)record.getGPSTime();

                        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.getGPSTime();

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

            }

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

                    PointRecColours colors = getReader().getPointRecordColours((int)decimatedIndex);

                    int rgb;

                    if (colors!=null) {

                            int red = colors.getRed();

                            int green = colors.getGreen();

                            int blue = colors.getBlue();

                            // 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).

                            rgb = ConversionUtils.rgbToInt(red, green, blue);

                    }

                    else {

                            rgb = 0;

                    }

                    featureProvider.set(COLOR_FIELD, rgb);

            }

            return featureProvider;

    }

    protected synchronized LASReader getReader() throws LASUnsupportedFormatException {

        if (this.reader == null) {

                reader = new LASReader(file.getPath());

        }

        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?

                        p1.setCoordinateAt(0, getReader().getMinX());

                        p1.setCoordinateAt(1, getReader().getMinY());

                        p1.setCoordinateAt(2, getReader().getMinZ());

                        p2.setCoordinateAt(0, getReader().getMaxX());

                        p2.setCoordinateAt(1, getReader().getMaxY());

                        p2.setCoordinateAt(2, getReader().getMaxZ());

                        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().getNumPointRecords();

                    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;

        this.reader = null;

    }

    @Override

    public boolean closeResourceRequested(ResourceProvider resource) {

        this.envelope = null;

        this.opened = false;

        this.reader = null;

        return true;

    }

    @Override

    public void resourceChanged(ResourceProvider resource) {

        this.envelope = null;

        this.opened = false;

        this.reader = null;

    }

}