Application: gvSIG desktop » gvSIG geoprocess

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2012 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.geoprocess.algorithm.intersection;

import java.util.Iterator;

import java.util.List;

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

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

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

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

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.Geometry.TYPES;

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

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

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

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

import org.gvsig.fmap.geom.operation.fromjts.FromJTS;

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

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

import org.gvsig.geoprocess.algorithm.base.core.GeometryOperation;

import org.gvsig.geoprocess.algorithm.base.util.GeometryUtil;

import org.gvsig.geoprocess.lib.sextante.AbstractSextanteGeoProcess;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryCollection;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geom.MultiLineString;

import com.vividsolutions.jts.geom.MultiPoint;

import com.vividsolutions.jts.geom.MultiPolygon;

import com.vividsolutions.jts.geom.Point;

import com.vividsolutions.jts.geom.Polygon;

import com.vividsolutions.jts.precision.EnhancedPrecisionOp;

import es.unex.sextante.core.Sextante;

/**

 * Builds a geometry with the intersection between two layers

 *

 * @author <a href="mailto:nachobrodin@gmail.com">Nacho Brodin</a>

 */

public class IntersectionOperation extends GeometryOperation {

        private FeatureStore                     storeOverlay     = null;

        protected GeometryManager                geomManager      = GeometryLocator.getGeometryManager();

        private Logger                           log              = LoggerFactory.getLogger(IntersectionOperation.class);

        private boolean                          errorInfo        = false;

        public IntersectionOperation(FeatureStore overlayLayer, AbstractSextanteGeoProcess p) {

                super(p);

                this.storeOverlay = overlayLayer;

        }

        public boolean getErrorInfo() {

                return errorInfo;

        }

        /**

         * Computes intersection between the geometry and the overlay layer. The fields of the

         * intersected features will be added.

         * @param g

         * @param featureInput

         * @return

         */

        @SuppressWarnings({ "unchecked", "deprecation" })

        public EditableFeature invoke(org.gvsig.fmap.geom.Geometry g, Feature featureInput) {

                if(g == null)

                        return lastEditFeature;

                FeatureSet features = null;

                Iterator it = null;

                try {

                        if(selectedGeomOverlay) {

                                features = (FeatureSet)storeOverlay.getSelection();

                        } else {

                                features = storeOverlay.getFeatureSet();

                        }

                        it = features.iterator();

                } catch (DataException e) {

                        Sextante.addErrorToLog(e);

                        return lastEditFeature;

                }

                while( it.hasNext() ) {

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

                        List<org.gvsig.fmap.geom.Geometry> geomList = featureOverlay.getGeometries();

                        if(geomList == null) {

                                org.gvsig.fmap.geom.Geometry geom = featureOverlay.getDefaultGeometry();

                                lastEditFeature = intersection(g, geom, featureInput, featureOverlay);

                                continue;

                        }

                        Iterator<org.gvsig.fmap.geom.Geometry> itGeom = geomList.iterator();

                        while(itGeom.hasNext()) {

                                org.gvsig.fmap.geom.Geometry geom = itGeom.next();

                                lastEditFeature = intersection(g, geom, featureInput, featureOverlay);

                        }

                }

//                it.dispose();

                return lastEditFeature;

        }

        private EditableFeature intersection(        org.gvsig.fmap.geom.Geometry g1,

                                                                                        org.gvsig.fmap.geom.Geometry g2,

                                                                                        Feature featureInput,

                                                                                        Feature featureOverlay) {

            if(g1 == null || g2 == null){

                return null;

            }

                Geometry overlaysGeom = null;

                Geometry jtsGeom = null;

                int outPutType = TYPES.SURFACE;

                try {

                        outPutType = persister.getOutputFeatureStore().getDefaultFeatureType()

                                                        .getDefaultGeometryAttribute().getGeomType().getType();

                } catch (DataException e2) {

                        Sextante.addErrorToLog(e2);

                }

                try {

                        if( ((g1 instanceof Surface && g2 instanceof Curve) ||

                                 (g2 instanceof Surface && g1 instanceof Curve)) &&

                                 outPutType == TYPES.MULTIPOINT) {

                                org.gvsig.fmap.geom.Geometry overGeom = (g1 instanceof Surface) ? g1 : g2;

                                jtsGeom = (g1 instanceof Surface) ? GeometryUtil.geomToJTS(g2) : GeometryUtil.geomToJTS(g1);

                                overlaysGeom =  (Geometry)overGeom.invokeOperation("toJTSLineString", null);

                        } else {

                                if( g1 instanceof Surface &&

                                        g2 instanceof Surface &&

                                        (outPutType == TYPES.MULTIPOINT)) {

                                        jtsGeom =  (Geometry)g1.invokeOperation("toJTSLineString", null);

                                        overlaysGeom =  (Geometry)g2.invokeOperation("toJTSLineString", null);

                                } else {

                                        jtsGeom = GeometryUtil.geomToJTS(g1);

                                        overlaysGeom = GeometryUtil.geomToJTS(g2);

                                }

                        }

                        if(!jtsGeom.getEnvelope().intersects(overlaysGeom.getEnvelope()))

                                return lastEditFeature;

                        if(jtsGeom.intersects(overlaysGeom)) {

                                Geometry newGeom = EnhancedPrecisionOp.intersection(jtsGeom, overlaysGeom);

                                if(!newGeom.isEmpty()) {

                                        if(typesMatch(outPutType, newGeom) || newGeom instanceof GeometryCollection) {

                                                lastEditFeature = persister.addFeature(featureInput, featureOverlay, newGeom);

                                        } else {

                                                //Para intersecciones entre pol?gonos cuando la salida es de tipo l?nea

                                                //la generamos a partir del pol?gono resultante de la intersecci?n

                                                if( g1 instanceof Surface &&

                                                                g2 instanceof Surface &&

                                                                outPutType == TYPES.MULTICURVE &&

                                                                (newGeom instanceof Polygon || newGeom instanceof MultiPolygon)) {

                                                        GeometryOperationContext ctx = new GeometryOperationContext();

                                                        ctx.setAttribute(FromJTS.PARAM, newGeom);

                                                        org.gvsig.fmap.geom.Geometry newDalGeom = (org.gvsig.fmap.geom.Geometry)geomManager.invokeOperation(FromJTS.NAME, ctx);

                                                        newGeom = (Geometry)newDalGeom.invokeOperation("toJTSLineString", null);

                                                }

                                                lastEditFeature = persister.addFeature(featureInput, featureOverlay, newGeom);

                                        }

                                }

                        }

                } catch (CreateGeometryException e) {

                        Sextante.addErrorToLog(e);

                } catch (DataException e) {

                        Sextante.addErrorToLog(e);

                } catch (GeometryOperationNotSupportedException e1) {

                        Sextante.addErrorToLog(e1);

                } catch (GeometryOperationException e1) {

                        Sextante.addErrorToLog(e1);

                } catch (com.vividsolutions.jts.geom.TopologyException e) {

                        errorInfo = true;

                        log.info("Problems operating intersection: ", e);

                }

                return lastEditFeature;

        }

        private boolean typesMatch(int dalType, Geometry newGeom) {

                return

                   ((dalType == TYPES.MULTICURVE &&

                   (newGeom instanceof MultiLineString || newGeom instanceof LineString)) ||

                   (dalType == TYPES.MULTIPOINT &&

                   (newGeom instanceof MultiPoint || newGeom instanceof Point)) ||

                   (dalType == TYPES.MULTISURFACE &&

               (newGeom instanceof Polygon || newGeom instanceof MultiPolygon)) ||

               (dalType == TYPES.CURVE && newGeom instanceof LineString) ||

               (dalType == TYPES.SURFACE && newGeom instanceof Polygon) ||

               (dalType == TYPES.POINT && newGeom instanceof Point));

        }

        /**

         * clips feature's geometry with the clipping geometry, preserving

         * feature's original attributes.

         * If feature's geometry doesn't touch clipping geometry, it will be

         * ignored.

         */

        public void invoke(org.gvsig.fmap.geom.Geometry g, EditableFeature featureInput) {

        }

}