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;

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

    }

}