gvSIG projects pool

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 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 3 of the License, or (at your option) any later

 * version.

 *

 * This program is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more

 * details.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program; if not, write to the Free Software Foundation, Inc., 51

 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us at info AT

 * gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.exportto.swing.prov.lidar;

import java.io.File;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.exportto.ExporttoService;

import org.gvsig.exportto.ExporttoServiceException;

import org.gvsig.exportto.ExporttoServiceFinishAction;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

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

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

import org.gvsig.lidar.prov.LASDataStoreParameters;

import org.gvsig.lidar.prov.jgrasstools.JGrassLASDataStoreProvider;

import org.gvsig.lidar.prov.jgrasstools.JGrassLASWriter;

import org.gvsig.timesupport.Instant;

import org.gvsig.timesupport.Interval;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.evaluator.EvaluatorData;

import org.gvsig.tools.task.AbstractMonitorableTask;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.exportto.swing.prov.lidar.ExporttoLASOptions;

/**

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

 *

 */

public class ExporttoLASService extends AbstractMonitorableTask implements

        ExporttoService {

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

    public static final int CHECK_NONE = 0;

    public static final int CHECK_IF_CORRUPT = 1;

    public static final int CHECK_IF_VALID = 2;

    public static final int ACTION_SET_GEOMETRY_TO_NULL = 0;

    public static final int ACTION_SKIP_FEATURE = 1;

    public static final int ACTION_ABORT = 2;

    private ExporttoServiceFinishAction exporttoServiceFinishAction = null;

    private ExporttoLASOptions options;

    public ExporttoLASService(ExporttoLASOptions options) {

        this.options = options;

    }

    public void export(FeatureSet featureSet) throws ExporttoServiceException {

            File outFile = this.options.getOutputFile();

        DisposableIterator it = null;

        try {

            // ======================================

            // Reprojection 

            FeatureAttributeDescriptor geo_att = this.options.getSource().getDefaultFeatureType().getDefaultGeometryAttribute();

            IProjection sourceProjection = null;

            ICoordTrans coord_trans = null;

            Geometry reproj_geom = null;

            Envelope filterEnvelope = this.options.getFilterEnvelope();

            if (geo_att != null) {

                sourceProjection = geo_att.getSRS();

                // FIXME: we should get the transformation from the options and not from the layer projection.

                // If the layer contains a CT, it has been set to convert from layer to view projection,

                // which is not necessarily the right one for the target export projection.

                // We will be able to improve these corner cases when the new CRS API is fully implemented

                if (sourceProjection != null && sourceProjection != this.options.getTargetProjection()) {

                    coord_trans = sourceProjection.getCT(this.options.getTargetProjection());

                }

            }

            // ============================================

            LASDataStoreParameters openParams = new LASDataStoreParameters(JGrassLASDataStoreProvider.NAME);

            openParams.setFile(outFile);

            openParams.setCRS(this.options.getTargetProjection());

            FeatureType sourceFeatureType = featureSet.getDefaultFeatureType();

            Envelope outEnvelope = null;

            if (coord_trans!=null) {

                    outEnvelope = this.options.getSource().getEnvelope().convert(coord_trans);

            }

            else {

                    outEnvelope = this.options.getSource().getEnvelope();

            }

            JGrassLASWriter writer = new JGrassLASWriter(openParams, sourceFeatureType, outEnvelope);            

            writer.open();

            int featureCount = 1;

            taskStatus.setRangeOfValues(0, featureSet.getSize());

            logger.debug("Inserting rows");

            taskStatus.message("Inserting rows");

            it = featureSet.fastIterator();

            while (it.hasNext()) {

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

                this.taskStatus.setCurValue(featureCount);

                Geometry geometry = feature.getDefaultGeometry();

                if (filterEnvelope==null

                                || filterEnvelope.intersects(geometry)) {

                        // ================================================

                        // Reprojection 

                        if (geometry != null && 

                                        geo_att != null && coord_trans != null) {

                                CustomFeatureImpl customFeature = new CustomFeatureImpl(feature);

                                reproj_geom = geometry.cloneGeometry();

                                reproj_geom.reProject(coord_trans);

                                customFeature.setDefaultGeometry(reproj_geom);

                                feature = customFeature;

                        }

                        // ================================================

                    writer.write(feature);

                }

                if (this.taskStatus.isCancellationRequested()) {

                    return;

                }

                featureCount++;

            }

            writer.close();

            finishAction(this.options.getOutputFile().getName(), this.options.getOutputFile(), this.options.getTargetProjection());

            taskStatus.message("Exportation finished");

        } catch (Exception e) {

            logger.warn("Can't export data.", e);

            taskStatus.message("Problems exporting data");

            throw new ExporttoServiceException(e);

        } finally {

                DisposeUtils.disposeQuietly(it);

                DisposeUtils.disposeQuietly(featureSet);

            this.taskStatus.terminate();

            this.taskStatus.remove();

        }

    }

    protected void finishAction(String layerName, File out_file, IProjection proj)

    throws ExporttoServiceException {

        if (exporttoServiceFinishAction != null) {

            /*

             * Export is done. We notify with a SHPStoreParameters,

             * not with the NewSHPParameters we have used:

             */

                DataStoreParameters las_params = null;

            try {

                    las_params = DALLocator.getDataManager().createStoreParameters(JGrassLASDataStoreProvider.NAME);

                    las_params.setDynValue("file", out_file);

                    las_params.setDynValue("CRS", proj);

                    las_params.validate();

            } catch (Exception e) {

                throw new ExporttoServiceException(e);

            }

            exporttoServiceFinishAction.finished(layerName, las_params);

        }

    }

    public void setFinishAction(

            ExporttoServiceFinishAction exporttoServiceFinishAction) {

        this.exporttoServiceFinishAction = exporttoServiceFinishAction;

    }

    /**

     * Incomplete implementation of editable feature, only used to feed

     * reprojected features to the LAS Writer

     * 

     * @author cesar

     *

     */

    protected class CustomFeatureImpl implements Feature {

            private Feature feature;

            private Geometry theGeom;

            private String defaultGeomName;

            private int defaultGeomIndex;

            public CustomFeatureImpl(Feature feat) {

                    this.feature = feat;

                    this.defaultGeomName = feat.getType().getDefaultGeometryAttributeName();

                    this.defaultGeomIndex = feat.getType().getDefaultGeometryAttributeIndex();

            }

                public FeatureReference getReference() {

                        throw new UnsupportedOperationException();

                }

                public FeatureType getType() {

                        return feature.getType();

                }

                public Feature getCopy() {

                        CustomFeatureImpl copy = new CustomFeatureImpl(feature.getCopy());

                        copy.setDefaultGeometry(theGeom);

                        return copy;

                }

                public void validate(int mode) throws DataException {

                        feature.validate(mode);

                }

                public EditableFeature getEditable() {

                        return feature.getEditable();

                }

                public Object get(String name) {

                        if (name.equals(defaultGeomName) && theGeom!=null) {

                                return theGeom;

                        }

                        return feature.get(name);

                }

                public Object get(int index) {

                        if (index==defaultGeomIndex && theGeom!=null) {

                                return theGeom;

                        }

                        return feature.get(index);

                }

                public int getInt(String name) {

                        return feature.getInt(name);

                }

                public int getInt(int index) {

                        return feature.getInt(index);

                }

                public boolean getBoolean(String name) {

                        return feature.getBoolean(name);

                }

                public boolean getBoolean(int index) {

                        return feature.getBoolean(index);

                }

                public long getLong(String name) {

                        return feature.getLong(name);

                }

                public long getLong(int index) {

                        return feature.getLong(index);

                }

                public float getFloat(String name) {

                        return feature.getFloat(name);

                }

                public float getFloat(int index) {

                        return feature.getFloat(index);

                }

                public double getDouble(String name) {

                        return feature.getDouble(name);

                }

                public double getDouble(int index) {

                        return feature.getDouble(index);

                }

                public Date getDate(String name) {

                        return feature.getDate(name);

                }

                public Date getDate(int index) {

                        return feature.getDate(index);

                }

                public String getString(String name) {

                        return feature.getString(name);

                }

                public String getString(int index) {

                        return feature.getString(index);

                }

                public byte getByte(String name) {

                        return feature.getByte(name);

                }

                public byte getByte(int index) {

                        return feature.getByte(index);

                }

                public Geometry getGeometry(String name) {

                        if (name.equals(this.defaultGeomName) && theGeom!=null) {

                                return theGeom;

                        }

                        return feature.getGeometry(name);

                }

                public Geometry getGeometry(int index) {

                        if (index==defaultGeomIndex && theGeom!=null) {

                                return theGeom;

                        }

                        return feature.getGeometry(index);

                }

                public Object[] getArray(String name) {

                        return feature.getArray(name);

                }

                public Object[] getArray(int index) {

                        return feature.getArray(index);

                }

                public Feature getFeature(String name) {

                        return feature.getFeature(name);

                }

                public Feature getFeature(int index) {

                        return feature.getFeature(index);

                }

                public Envelope getDefaultEnvelope() {

                        return feature.getDefaultEnvelope();

                }

                public Geometry getDefaultGeometry() {

                        if (theGeom!=null) {

                                return theGeom;

                        }

                        return feature.getDefaultGeometry();

                }

                public void setDefaultGeometry(Geometry geom) {

                        this.theGeom = geom;

                }

                public List getGeometries() {

                        throw new UnsupportedOperationException();

                }

                public IProjection getDefaultSRS() {

                        return feature.getDefaultSRS();

                }

                public List getSRSs() {

                        return feature.getSRSs();

                }

                public Instant getInstant(int index) {

                        return feature.getInstant(index);

                }

                public Instant getInstant(String name) {

                        return feature.getInstant(name);

                }

                public Interval getInterval(int index) {

                        return feature.getInterval(index);

                }

                public Interval getInterval(String name) {

                        return feature.getInterval(name);

                }

                public DynObject getAsDynObject() {

                        return feature.getAsDynObject();

                }

                public EvaluatorData getEvaluatorData() {

                        return feature.getEvaluatorData();

                }

                public FeatureStore getStore() {

                        return feature.getStore();

                }

    }

}