| gvSIG desktop 1

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * 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.

 *

 */

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

import java.io.File;

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.exception.DataException;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.task.AbstractMonitorableTask;

/**

 * @author gvSIG Team

 * @version $Id$

 * 

 */

public class ExporttoShapeService extends AbstractMonitorableTask implements

    ExporttoService {

    private File shapeFile;

    private IProjection projection;

    private FeatureStore featureStore;

    private int geometryType = -1;

    private NewFeatureStoreParameters newFeatureStoreParameters;

    private FilesystemServerExplorer filesystemServerExplorer;

    private ExporttoServiceFinishAction exporttoServiceFinishAction;

    public ExporttoShapeService(File shapeFile, FeatureStore featureStore,

        IProjection projection) {

        super("Export to shape");

        this.featureStore = featureStore;

        this.shapeFile = shapeFile;

        this.projection = projection;

    }

    public void export(FeatureSet featureSet) throws ExporttoServiceException {

        initializeParams(featureSet);

        File file =

            ((FilesystemStoreParameters) newFeatureStoreParameters).getFile();

        String pathFile = file.getAbsolutePath();

        if (geometryType == Geometry.TYPES.GEOMETRY) {

            String withoutShp = pathFile.replaceAll("\\.shp", "");

            // POINT

            String fileName = withoutShp + "_point" + ".shp";

            newFeatureStoreParameters

                .setDynValue("shpfile", new File(fileName));

            taskStatus.setTittle("Exporting points");

            export(filesystemServerExplorer, newFeatureStoreParameters,

                featureSet, Geometry.TYPES.POINT, true);

            finishAction(fileName, newFeatureStoreParameters);

            // CURVE

            fileName = withoutShp + "_curve" + ".shp";

            newFeatureStoreParameters

                .setDynValue("shpfile", new File(fileName));

            taskStatus.setTittle("Exporting curves");

            export(filesystemServerExplorer, newFeatureStoreParameters,

                featureSet, Geometry.TYPES.CURVE, true);

            finishAction(fileName, newFeatureStoreParameters);

            // SURFACE

            fileName = withoutShp + "_surface" + ".shp";

            newFeatureStoreParameters

                .setDynValue("shpfile", new File(fileName));

            taskStatus.setTittle("Exporting surfaces");

            export(filesystemServerExplorer, newFeatureStoreParameters,

                featureSet, Geometry.TYPES.SURFACE, true);

            finishAction(fileName, newFeatureStoreParameters);

        } else {

            export(filesystemServerExplorer, newFeatureStoreParameters,

                featureSet, geometryType, false);

            finishAction(file.getName(), newFeatureStoreParameters);

        }

        this.taskStatus.terminate();

        this.taskStatus.remove();

    }

    private void initializeParams(FeatureSet featureSet)

        throws ExporttoServiceException {

        String path = shapeFile.getAbsolutePath();

        if (!(path.toLowerCase().endsWith(".shp"))) {

            path = path + ".shp";

        }

        File newFile = new File(path);

        DataManager dataManager = DALLocator.getDataManager();

        FilesystemServerExplorerParameters explorerParams;

        try {

            explorerParams =

                (FilesystemServerExplorerParameters) dataManager

                    .createServerExplorerParameters(FilesystemServerExplorer.NAME);

        } catch (InitializeException e) {

            throw new ExporttoServiceException(e);

        } catch (ProviderNotRegisteredException e) {

            throw new ExporttoServiceException(e);

        }

        explorerParams.setRoot(newFile.getParent());

        try {

            filesystemServerExplorer =

                (FilesystemServerExplorer) dataManager.openServerExplorer(

                    "FilesystemExplorer", explorerParams);

        } catch (ValidateDataParametersException e) {

            throw new ExporttoServiceException(e);

        } catch (InitializeException e) {

            throw new ExporttoServiceException(e);

        } catch (ProviderNotRegisteredException e) {

            throw new ExporttoServiceException(e);

        }

        try {

            newFeatureStoreParameters =

                (NewFeatureStoreParameters) filesystemServerExplorer

                    .getAddParameters(newFile);

        } catch (DataException e) {

            throw new ExporttoServiceException(e);

        }

        newFeatureStoreParameters.setDynValue("CRS", projection);

        geometryType =

            featureSet.getDefaultFeatureType().getDefaultGeometryAttribute()

                .getGeometryType();

    }

    private void export(FilesystemServerExplorer explorer,

        NewFeatureStoreParameters params, FeatureSet featureSet,

        int geometryType, boolean checkType) throws ExporttoServiceException {

        String providerName = params.getDataStoreName();

        String explorerName = explorer.getProviderName();

        DisposableIterator it = null;

        try {

            EditableFeatureType type =

                featureStore.getDefaultFeatureType().getEditable();

            FeatureAttributeDescriptor fad =

                (FeatureAttributeDescriptor) type.get(type

                    .getDefaultGeometryAttributeName());

            type.remove(fad.getName());

            EditableFeatureAttributeDescriptor efad =

                type.add(fad.getName(), fad.getType(), fad.getSize());

            efad.setDefaultValue(fad.getDefaultValue());

            efad.setGeometryType(geometryType);

            efad.setPrecision(fad.getPrecision());

            type.setDefaultGeometryAttributeName(fad.getName());

            params.setDefaultFeatureType(type);

            params.setDynValue("geometryType", null);

            DataManager manager = DALLocator.getDataManager();

            manager.newStore(explorerName, providerName, params, true);

            FeatureStore target =

                (FeatureStore) manager.openStore(providerName, params);

            FeatureType targetType = target.getDefaultFeatureType();

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

            target.edit(FeatureStore.MODE_APPEND);

            it = featureSet.fastIterator();

            int featureCount = 0;

            int geometryattribute =

                featureSet.getDefaultFeatureType()

                    .getDefaultGeometryAttributeIndex();

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

            // Reprojection stuff

            Geometry reproj_geom = null;

            EditableFeature edit_feat = null;

            IProjection sourceProjection =

                featureStore.getDefaultFeatureType().getDefaultGeometryAttribute().getSRS();

            ICoordTrans coord_trans = null;

            // this comparison is perhaps too preventive

            // we could  have two instances of same projection

            // so we would do more computations than needed

            if (sourceProjection != this.projection) {

                coord_trans = sourceProjection.getCT(this.projection); 

            }

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

            while (it.hasNext()) {

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

                if (checkType

                    && (feature.getGeometry(geometryattribute).getType() != geometryType)) {

                    continue;

                }

                edit_feat = target.createNewFeature(targetType, feature);

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

                // Reprojection stuff

                if (coord_trans != null) {

                    reproj_geom = edit_feat.getDefaultGeometry();

                    reproj_geom = reproj_geom.cloneGeometry();

                    reproj_geom.reProject(coord_trans);

                    edit_feat.setDefaultGeometry(reproj_geom);

                }

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

                target.insert(edit_feat);

                featureCount++;

                this.taskStatus.setCurValue(featureCount);

                if (this.taskStatus.isCancellationRequested()) {

                    return;

                }

            }

            target.finishEditing();

            target.dispose();

        } catch (DataException e) {

            throw new ExporttoServiceException(e);

        } catch (ValidateDataParametersException e) {

            throw new ExporttoServiceException(e);

        } finally {

            DisposeUtils.dispose(it);

        }

    }

    private void finishAction(String layerName,

        NewFeatureStoreParameters newFeatureStoreParameters) {

        if (exporttoServiceFinishAction != null) {

            exporttoServiceFinishAction.finished(layerName,

                newFeatureStoreParameters);

        }

    }

    public void setFinishAction(

        ExporttoServiceFinishAction exporttoServiceFinishAction) {

        this.exporttoServiceFinishAction = exporttoServiceFinishAction;

    }

}