Application: gvSIG desktop

package org.gvsig.export.shape.service;

import java.io.File;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICoordTrans;

import org.gvsig.export.ExportException;

import org.gvsig.export.ExportLocator;

import org.gvsig.export.spi.AbstractExportService;

import org.gvsig.export.spi.ExportService;

import org.gvsig.export.spi.ExportServiceFactory;

import org.gvsig.export.spi.ExportServiceManager;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.NewDataStoreParameters;

import org.gvsig.fmap.dal.OpenDataStoreParameters;

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

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

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

import org.gvsig.fmap.geom.DataTypes;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.aggregate.Aggregate;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.util.HasAFile;

/**

 *

 * @author jjdelcerro

 */

public class ExportShapeService

        extends AbstractExportService

        implements ExportService {

    public static final int MAX_FIELD_NAME_LENGTH = 10;

    private final List<OpenDataStoreParameters> targetOpenStoreParameters;

    public File targetFile = null;

    public ExportShapeService(ExportServiceFactory factory, ExportShapeParameters parameters) {

        super(factory, parameters);

        this.targetOpenStoreParameters = new ArrayList<>();

    }

    @Override

    public ExportShapeParameters getParameters() {

        return (ExportShapeParameters) super.getParameters();

    }

    @Override

    protected DataServerExplorer createServerExplorer() throws ExportException {

        DataManager dataManager = DALLocator.getDataManager();

        FilesystemServerExplorerParameters explorerParams;

        try {

            explorerParams

                    = (FilesystemServerExplorerParameters) dataManager

                            .createServerExplorerParameters(FilesystemServerExplorer.NAME);

        } catch (Exception e) {

            throw new ExportException(e);

        }

        File parametersFile = this.getTargetFile();

        explorerParams.setRoot(parametersFile.getParent());

        FilesystemServerExplorer explorer;

        try {

            explorer = (FilesystemServerExplorer) dataManager.openServerExplorer(

                    "FilesystemExplorer", explorerParams

            );

            return explorer;

        } catch (Exception e) {

            throw new ExportException(e);

        }

    }

    @Override

    protected NewDataStoreParameters createTargetNewStoreParameters() throws ExportException {

        try {

            FilesystemServerExplorer explorer = (FilesystemServerExplorer) this.createServerExplorer();

            ;

            NewFeatureStoreParameters newStoreParameters = (NewFeatureStoreParameters) explorer.getAddParameters(

                    this.getTargetFile());

            newStoreParameters.setDynValue("Encoding", this.getParameters().getEncoding());

            newStoreParameters.setDynValue("CRS", this.getParameters().getTargetProjection());

            FeatureType ft;

            if (this.getParameters().getExportAttributes() != null) {

                ft = this.getParameters().getExportAttributes().getTargetFeatureType();

            } else {

                ft = this.getParameters().getSourceFeatureType();

            }

            // FIXME: check if ft has one and only one geometry.

            newStoreParameters.setDefaultFeatureType(ft.getEditable());

            return newStoreParameters;

        } catch (DataException ex) {

            throw new ExportException(ex);

        }

    }

    public File getTargetFile() {

        if (this.targetFile == null) {

            this.targetFile = ExpressionUtils.evaluateFilename(this.getParameters().getFile());

            return this.targetFile;

        }

        return this.targetFile;

    }

    @Override

    public List<OpenDataStoreParameters> getTargetOpenStoreParameters() throws ExportException {

        return this.targetOpenStoreParameters;

    }

    @Override

    public OpenDataStoreParameters createTargetOpenStoreParameters() throws ExportException {

        try {

            DataManager dataManager = DALLocator.getDataManager();

            OpenFeatureStoreParameters openStoreParameters = (OpenFeatureStoreParameters) dataManager.createStoreParameters("Shape");

            ((HasAFile) openStoreParameters).setFile(this.getTargetFile());

            openStoreParameters.setDynValue("Encoding", getParameters().getEncoding());

            openStoreParameters.setDynValue("CRS", this.getParameters().getTargetProjection());

            return openStoreParameters;

        } catch (DataException ex) {

            throw new ExportException(ex);

        }

    }

    @Override

    public void export(FeatureSet featureSet) throws ExportException {

        File parametersFile = ExpressionUtils.evaluateFilename(this.getParameters().getFile());

        String pathName = FilenameUtils.removeExtension(parametersFile.getAbsolutePath());

        int geometryType = this.getParameters().getTargetGeometryTypeAsInt();

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

            try {

                // SURFACE

                String fullPathName = pathName + "_surface" + ".shp";

                this.getParameters().setFile(new File(fullPathName));

                this.getTaskStatus().setTitle("Exporting surfaces");

                export(featureSet, Geometry.TYPES.SURFACE, true);

                // CURVE

                fullPathName = pathName + "_curve" + ".shp";

                this.getParameters().setFile(new File(fullPathName));

                this.getTaskStatus().setTitle("Exporting curves");

                export(featureSet, Geometry.TYPES.CURVE, true);

                // POINT

                fullPathName = pathName + "_point" + ".shp";

                this.getParameters().setFile(new File(fullPathName));

                this.getTaskStatus().setTitle("Exporting points");

                export(featureSet, Geometry.TYPES.POINT, true);

            } finally {

                this.getParameters().setFile(parametersFile);

            }

        } else {

            export(featureSet, geometryType, false);

        }

        this.getTaskStatus().terminate();

        this.getTaskStatus().remove();

    }

    private void export(

            FeatureSet featureSet,

            int geometryType,

            boolean checkType

    ) throws ExportException {

        DataServerExplorer explorer = this.createServerExplorer();

        NewFeatureStoreParameters params = (NewFeatureStoreParameters) this.createTargetNewStoreParameters();

        String providerName = params.getDataStoreName();

        String explorerName = explorer.getProviderName();

        boolean there_was_error = false;

        DisposableIterator it = null;

        try {

//            EditableFeatureType type = this.getParameters().getSourceFeatureType().getCopy().getEditable();

            EditableFeatureType type = params.getDefaultFeatureType();

            String geomFieldName = this.getParameters().getSourceGeometryFieldName();

            FeatureAttributeDescriptor geomFieldDescSource = (FeatureAttributeDescriptor) type.getDefaultGeometryAttribute();

            if (geomFieldDescSource != null) {

                type.remove(geomFieldDescSource.getName());

            }

            EditableFeatureAttributeDescriptor geomFieldDescTarget = type.add(

                    "GEOMETRY",

                    DataTypes.GEOMETRY

            );

            geomFieldDescTarget.setDefaultValue(null);

            int gsubtype = this.getParameters().getTargetGeometrySubtype();

            // El shp solo soporta los subtipos 2D y 3D

            switch (gsubtype) {

                case Geometry.SUBTYPES.GEOM2D:

                    break;

                case Geometry.SUBTYPES.GEOM3D:

                    break;

                default:

                    // Forzaremos las geometrias a 3D

                    gsubtype = Geometry.SUBTYPES.GEOM3D;

                    break;

            }

            GeometryType gty = null;

            try {

                GeometryManager geoManager = GeometryLocator.getGeometryManager();

                gty = geoManager.getGeometryType(geometryType, gsubtype);

            } catch (Exception e) {

                throw new ExportException(e);

            }

            geomFieldDescTarget.setGeometryType(gty);

            String newGeometryFieldName;

            if (this.getParameters().getExportAttributes().getTargetName("GEOMETRY") == null) {

                newGeometryFieldName = "GEOMETRY";

            } else {

                newGeometryFieldName = this.getParameters().getExportAttributes().getTargetName("GEOMETRY");

            }

            geomFieldDescTarget.setName(newGeometryFieldName);

            type.setDefaultGeometryAttributeName(geomFieldDescTarget.getName());

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

            //fixNames(type);

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

            params.setDefaultFeatureType(type.getNotEditableCopy());

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

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

            target.edit(FeatureStore.MODE_APPEND);

            it = featureSet.fastIterator();

            int featureCount = 0;

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

            // Reprojection stuff

            Geometry reproj_geom;

            EditableFeature edit_feat = null;

            ICoordTrans coord_trans = this.getParameters().getTransformationToUse();

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

            List<Geometry> extracted;

            Geometry gitem;

            DataTypesManager.Coercion toGeometry = ToolsLocator.getDataTypesManager()

                    .get(DataTypes.GEOMETRY).getCoercion();

            //Usefull for reproject

            ExportServiceManager serviceManager = ExportLocator.getServiceManager();

            FeatureType theTargetFeatureType = target.getDefaultFeatureType();

            int targetGeometryIndex = theTargetFeatureType.getDefaultGeometryAttributeIndex();

            //

            while (it.hasNext()) {

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

                if (geomFieldName == null) {

                    edit_feat = target.createNewFeature(true);

                    //

                    // Accumulate error in boolean.

                    // This also fixes field names (using origNameToDbfName)

                    // 

                    there_was_error = there_was_error

                            | setNonNulls(

                                    getParameters().getSourceFeatureType(),

                                    targetType,

                                    feature,

                                    edit_feat

                            );

                    edit_feat.setDefaultGeometry(null);

                    target.insert(edit_feat);

                } else {

                    Object x = feature.getGeometry(geomFieldName);

                    try {

                        gitem = (Geometry) toGeometry.coerce(x);

                    } catch (CoercionException ex) {

                        gitem = null;

                    }

                    if (checkType) {

                        extracted = getGeometriesFrom(gitem, geometryType);

                        if (extracted.isEmpty()) {

                            // found no geometries of correct type

                            continue;

                        } else {

                            if (geometryType != Geometry.TYPES.POINT) {

                                // If not points, merge geometries

                                // (curves or surfaces)

                                try {

                                    gitem = union(extracted);

                                    extracted = new ArrayList<>();

                                    extracted.add(gitem);

                                } catch (Exception ex) {

                                    there_was_error = true;

                                    LOG.info("Error in union.", ex);

                                }

                            } else {

                                // only in the case of points, we can have several

                                // geometries if source is multipoint

                            }

                        }

                    } else {

                        extracted = new ArrayList<>();

                        extracted.add(gitem);

                    }

                    for (int i = 0; i < extracted.size(); i++) {

                        gitem = extracted.get(i);

                        if (gsubtype == Geometry.SUBTYPES.GEOM2D) {

                            gitem = force2D(gitem, geometryType);

                        } else {

                            gitem = force3D(gitem, geometryType);

                        }

                        edit_feat = target.createNewFeature(true);

                        //

                        // Accumulate error in boolean.

                        // This also fixes field names (using origNameToDbfName)

                        // 

                        there_was_error = there_was_error

                                | setNonNulls(

                                        getParameters().getSourceFeatureType(),

                                        targetType,

                                        feature,

                                        edit_feat

                                );

                        edit_feat.setDefaultGeometry(gitem);

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

                        // Reprojection stuff

                        if (coord_trans != null && gitem != null) {

                            Geometry geometry = edit_feat.getDefaultGeometry();

                            ExportServiceManager.FixGeometryStatus check = serviceManager.fixGeometry(getParameters(), coord_trans, geometry);

                            switch (check.getState()) {

                                case ExportServiceManager.FixGeometryStatus.STATE_OK:

                                    edit_feat.setDefaultGeometry(check.getGeometry());

                                    break;

                                case ExportServiceManager.FixGeometryStatus.STATE_SKIP:

                                    continue;

                                case ExportServiceManager.FixGeometryStatus.STATE_ABORT:

                                    throw new InvalidGeometryException(edit_feat, check.getMessage());

                            }

                        }

                    }

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

                    target.insert(edit_feat);

                }

                featureCount++;

                this.getTaskStatus().setCurValue(featureCount);

                if (this.getTaskStatus().isCancellationRequested()) {

                    return;

                }

            }

            target.finishEditing();

            target.dispose();

            this.targetOpenStoreParameters.add(this.createTargetOpenStoreParameters());

        } catch (Exception e) {

            throw new ExportException(e);

        } finally {

            DisposeUtils.dispose(it);

        }

        if (there_was_error) {

            Exception cause = new Exception(

                    "_Issues_with_attributes_or_geometries");

            throw new ExportException(cause);

        }

    }

    private void fixNames(EditableFeatureType eft) {

        FeatureAttributeDescriptor[] atts = eft.getAttributeDescriptors();

        String defaultGeometryField = eft.getDefaultGeometryAttributeName();

        for (FeatureAttributeDescriptor att : atts) {

            String new_name = this.getParameters().getExportAttributes().getTargetName(att.getName());

            if (new_name != null) {

                //efad = eft.add(new_name, att.getType(), att.getSize());

                EditableFeatureAttributeDescriptor efad = eft.getEditableAttributeDescriptor(att.getName());

                efad.setName(new_name);

                efad.setType(att.getDataType());

                efad.setSize(att.getSize());

                efad.setPrecision(att.getPrecision());

                if (att.getDataType().getType() == DataTypes.GEOMETRY) {

                    efad.setGeometryType(att.getGeomType());

                    if (StringUtils.equals(defaultGeometryField, att.getName())) {

                        eft.setDefaultGeometryAttributeName(new_name);

                    }

                }

            }

        }

    }

    /**

     * @param gitem

     * @param geometryType2

     * @return

     */

    private Geometry force2D(Geometry ge, int gt) throws CreateGeometryException {

        if (ge == null) {

            return null;

        }

        if (ge.getGeometryType().getSubType() == Geometry.SUBTYPES.GEOM2D) {

            return ge;

        } else {

            GeometryManager geoManager = GeometryLocator.getGeometryManager();

            switch (gt) {

                case Geometry.TYPES.POINT:

                    Point p = (Point) ge;

                    Point point = geoManager.createPoint(

                            p.getX(), p.getY(),

                            Geometry.SUBTYPES.GEOM2D);

                    return point;

                case Geometry.TYPES.CURVE:

                    return geoManager.createCurve(ge.getGeneralPath(), Geometry.SUBTYPES.GEOM2D);

                case Geometry.TYPES.SURFACE:

                    return geoManager.createSurface(ge.getGeneralPath(), Geometry.SUBTYPES.GEOM2D);

                default:

                    return ge;

            }

        }

    }

    /**

     * @param gitem

     * @param geometryType2

     * @return

     */

    private Geometry force3D(Geometry ge, int gt) throws CreateGeometryException {

        if (ge == null) {

            return null;

        }

        // Los try catch que hay abajo, son para asegurarse de que la geometr?a original

        // tiene las 3 dimensiones necesarias. A veces nos llegan geometr?as que aunque son de subtipo GEOM3D

        // los puntos del generalPath que contienen no son 3D y no tienen la coordenada Z

        GeometryManager geoManager = GeometryLocator.getGeometryManager();

        Point point;

        switch (gt) {

            case Geometry.TYPES.POINT:

                Point p = (Point) ge;

                point = geoManager.createPoint(

                        p.getX(), p.getY(),

                        Geometry.SUBTYPES.GEOM3D);

                try {

                    point.setCoordinateAt(2, p.getCoordinateAt(2));

                } catch (Exception e) {

                    point.setCoordinateAt(2, 0);

                }

                return point;

            case Geometry.TYPES.CURVE:

            case Geometry.TYPES.LINE:

                Line line = geoManager.createLine(Geometry.SUBTYPES.GEOM3D);

                for (int i = 0; i < ((OrientablePrimitive) ge).getNumVertices(); i++) {

                    Point vertex = ((OrientablePrimitive) ge).getVertex(i);

                    point = geoManager.createPoint(vertex.getX(), vertex.getY(), Geometry.SUBTYPES.GEOM3D);

                    try {

                        point.setCoordinateAt(2, vertex.getCoordinateAt(2));

                    } catch (Exception e) {

                        point.setCoordinateAt(2, 0);

                    }

                    line.addVertex(point);

                }

                ;

                return line;

            case Geometry.TYPES.SURFACE:

            case Geometry.TYPES.POLYGON:

                Polygon polygon = geoManager.createPolygon(Geometry.SUBTYPES.GEOM3D);

                for (int i = 0; i < ((OrientablePrimitive) ge).getNumVertices(); i++) {

                    Point vertex = ((OrientablePrimitive) ge).getVertex(i);

                    point = geoManager.createPoint(vertex.getX(), vertex.getY(), Geometry.SUBTYPES.GEOM3D);

                    try {

                        point.setCoordinateAt(2, vertex.getCoordinateAt(2));

                    } catch (Exception e) {

                        point.setCoordinateAt(2, 0);

                    }

                    polygon.addVertex(point);

                }

                ;

                return polygon;

            default:

                return ge;

        }

    }

    /**

     * @param feature

     * @param edit_feat

     */

    private boolean setNonNulls(

            FeatureType src_ft,

            FeatureType target_ft,

            Feature feat,

            EditableFeature edit_f

    ) {

        boolean error = false;

        FeatureAttributeDescriptor[] atts = src_ft.getAttributeDescriptors();

        String orig_name;

        String dbf_name;

        for (FeatureAttributeDescriptor att : atts) {

            if (att.getType() != org.gvsig.fmap.geom.DataTypes.GEOMETRY) {

                Object val;

                try {

                    orig_name = att.getName();

                    dbf_name = this.getParameters().getExportAttributes().getTargetName(orig_name);

                    if (dbf_name == null) {

                        dbf_name = orig_name;

                    }

                    val = feat.get(orig_name);

                    if (val != null && target_ft.getAttributeDescriptor(dbf_name) != null) {

                        edit_f.set(dbf_name, val);

                    }

                } catch (Exception ex) {

                    LOG.info("Error while getting/setting value", ex);

                    error = true;

                }

            }

        }

        return error;

    }

    private Geometry union(List<Geometry> geoms)

            throws GeometryOperationNotSupportedException, GeometryOperationException {

        if (geoms == null || geoms.isEmpty()) {

            return null;

        }

        if (geoms.size() == 1) {

            return geoms.get(0);

        }

        Geometry resp = geoms.get(0);

        for (int i = 1; i < geoms.size(); i++) {

            resp = resp.union(geoms.get(i));

        }

        return resp;

    }

    /**

     * @param feat_geom_type

     * @param type must be POINT, LINE or POLYGON (Geometry.TYPES)

     * @return

     */

    private List<Geometry> getGeometriesFrom(Geometry in_geom, int type) {

        List<Geometry> resp = new ArrayList<>();

        Aggregate agg;

        /*

         * If input geometry is aggregate, search its

         * primitives

         */

        if (in_geom instanceof Aggregate) {

            agg = (Aggregate) in_geom;

            Geometry item;

            List<Geometry> add_parts;

            for (int i = 0; i < agg.getPrimitivesNumber(); i++) {

                item = agg.getPrimitiveAt(i);

                add_parts = getGeometriesFrom(item, type);

                resp.addAll(add_parts);

            }

            return resp;

        }

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

        switch (type) {

            case Geometry.TYPES.POINT:

                if (in_geom instanceof Point) {

                    resp.add(in_geom);

                }

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

                break;

            case Geometry.TYPES.CURVE:

                if (in_geom instanceof Curve) {

                    resp.add(in_geom);

                }

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

                break;

            case Geometry.TYPES.SURFACE:

                if (in_geom instanceof Surface) {

                    resp.add(in_geom);

                }

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

                break;

        }

        return resp;

    }

}