| gvSIG desktop 1

/*

 * Created on 22-feb-2006

 *

 * gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

/* CVS MESSAGES:

 *

 * $Id$

 * $Log$

 * Revision 1.1  2006-05-24 21:11:38  azabala

 * primera version en cvs despues de refactoring orientado a crear un framework extensible de geoprocessing

 *

 * Revision 1.4  2006/05/01 19:15:18  azabala

 * *** empty log message ***

 *

 * Revision 1.3  2006/03/26 20:02:25  azabala

 * *** empty log message ***

 *

 * Revision 1.2  2006/03/07 21:01:33  azabala

 * *** empty log message ***

 *

 * Revision 1.1  2006/03/06 19:48:39  azabala

 * *** empty log message ***

 *

 * Revision 1.2  2006/03/05 19:58:10  azabala

 * *** empty log message ***

 *

 * Revision 1.1  2006/02/26 20:53:28  azabala

 * *** empty log message ***

 *

 *

 */

package com.iver.cit.gvsig.geoprocess.difference.fmap;

import com.hardcode.gdbms.engine.data.driver.DriverException;

import com.hardcode.gdbms.engine.values.Value;

import com.hardcode.gdbms.engine.values.ValueFactory;

import com.iver.cit.gvsig.fmap.core.IFeature;

import com.iver.cit.gvsig.fmap.core.IGeometry;

import com.iver.cit.gvsig.fmap.core.v02.FConverter;

import com.iver.cit.gvsig.fmap.drivers.FieldDescription;

import com.iver.cit.gvsig.fmap.drivers.ILayerDefinition;

import com.iver.cit.gvsig.fmap.edition.EditionException;

import com.iver.cit.gvsig.fmap.layers.FBitSet;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.iver.cit.gvsig.fmap.layers.SelectableDataSource;

import com.iver.cit.gvsig.fmap.layers.layerOperations.AlphanumericData;

import com.iver.cit.gvsig.fmap.layers.layerOperations.VectorialData;

import com.iver.cit.gvsig.fmap.operations.strategies.FeatureVisitor;

import com.iver.cit.gvsig.fmap.operations.strategies.Strategy;

import com.iver.cit.gvsig.fmap.operations.strategies.VisitException;

import com.iver.cit.gvsig.geoprocess.convexhull.fmap.ScalableUnionVisitor;

import com.iver.cit.gvsig.geoprocess.core.fmap.FeatureFactory;

import com.iver.cit.gvsig.geoprocess.core.fmap.FeatureProcessor;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryCollection;

import com.vividsolutions.jts.geom.MultiPolygon;

import com.vividsolutions.jts.geom.Polygon;

import com.vividsolutions.jts.precision.EnhancedPrecisionOp;

public class DifferenceVisitor implements FeatureVisitor {

        /**

         * Allows to get attributes of first layer features which is being

         * differenced

         */

        SelectableDataSource firstRs;

        /**

         * Number of fields of first layer recordset

         */

        int numFieldsA;

        /**

         * looks for overlay features of the processed feauture by spatial criteria

         * (queryByEnvelope)

         */

        FLyrVect overlayLayer;

        /**

         * Strategy to process overlaylayer, allowing cancelations

         */

        Strategy strategy;

        /**

         * this flag marks if visitor only must process overlay layer selection

         */

        boolean onlyOverlayLayerSelected;

        /**

         * It processes features resulting of intersetions. It could saves them in

         * persistent datastore, caching them, reprocess them, reprojects them, etc.

         */

        FeatureProcessor featureProcessor;

        /**

         * Schema of result layer

         */

        ILayerDefinition layerDefinition;

        /**

         * Constructor

         *

         * @param overlayLayer

         * @param processor

         * @throws DriverException

         */

        public DifferenceVisitor(FLyrVect overlayLayer, FeatureProcessor processor,

                        Strategy strategy, boolean onlySelection) throws DriverException {

                this.overlayLayer = overlayLayer;

                this.featureProcessor = processor;

                this.strategy = strategy;

                this.onlyOverlayLayerSelected = onlySelection;

        }

        /**

         * Inner class to process with a given strategy all geometries of overlay layer

         * that overlays with a given geometry of input layer.

         * @author azabala

         *

         */

        class UnionOverlaysVisitor implements FeatureVisitor {

                /**

                 * Result of the strategy process (union of overlays of a IGeometry)

                 */

                Geometry overlayGeometry;

                /**

                 * Flag to process or not selections of overlay layer

                 */

                boolean overlayLayerSelected = true;

                Geometry getUnionOfOverlays() {

                        return overlayGeometry;

                }

                public void visit(IGeometry g, int index) throws VisitException {

                        if (overlayLayerSelected) {

                                try {

                                        if (!overlayLayer.getRecordset().getSelection().get(index))

                                                return;

                                } catch (com.iver.cit.gvsig.fmap.DriverException e) {

                                        throw new VisitException(

                                                        "Error en diferencia: verificando si un posible overlay esta seleccionado",

                                                        e);

                                }// geometry g is not selected

                        }

                        Geometry actualGeometry = g.toJTSGeometry();

                        if (overlayGeometry == null) {

                                overlayGeometry = actualGeometry;

                        } else {

                                /*

                                 * Geometry[] geoms = new Geometry[2];

                                 * geoms[0] = actualGeometry;

                                 * geoms[1] = overlayGeometry;

                                 * GeometryCollection gc = geomFact.

                                 *         createGeometryCollection(geoms);

                                 * geometry = gc.buffer(0);

                                 */

                                overlayGeometry = actualGeometry.union(overlayGeometry);

                        }// if

                }// visit

                public String getProcessDescription() {

                        return "";

                }

                public void stop(FLayer layer) {

                }

                public boolean start(FLayer layer) {

                        return true;

                }

        }//UnionOverlaysVisitor

        public void visit(IGeometry g, final int index) throws VisitException {

                Geometry firstJts = g.toJTSGeometry();

                Geometry solution = null;

                try {

                        UnionOverlaysVisitor unionVisitor = new UnionOverlaysVisitor();

                        unionVisitor.overlayLayerSelected = onlyOverlayLayerSelected;

                        strategy.process(unionVisitor, g.getBounds2D());

                        // now we compute difference of firstJts and overlaysUnion

                        Geometry overlays = unionVisitor.getUnionOfOverlays();

                        if (overlays != null) {

                                solution = EnhancedPrecisionOp.difference(firstJts, overlays);

                        } else {

                                solution = firstJts;

                        }

                        if (!(solution instanceof Polygon)) {

                                if (!(solution instanceof MultiPolygon)) {

                                        // intersection of adjacent polygons is a linestring

                                        // but we are not interested in it

                                        return;

                                }

                        }

                        featureProcessor.processFeature(createFeature(solution, index));

                } catch (com.iver.cit.gvsig.fmap.DriverException e) {

                        throw new VisitException(

                                        "Error buscando los overlays que intersectan con un feature");

                } catch (DriverException e) {

                        throw new VisitException(

                                        "Error al guardar feature en el geoproceso diferencia");

                }

        }

        public void stop(FLayer layer) {

                featureProcessor.finish();

        }

        public boolean start(FLayer layer) {

                if (layer instanceof AlphanumericData && layer instanceof VectorialData) {

                        try {

                                this.firstRs = ((AlphanumericData) layer).getRecordset();

                                numFieldsA = firstRs.getFieldCount();

                                this.featureProcessor.start();

                        } catch (com.iver.cit.gvsig.fmap.DriverException e) {

                                return false;

                        } catch (DriverException e) {

                                return false;

                        } catch (EditionException e) {

                                return false;

                        }

                        return true;

                }

                return false;

        }

        /**

         *

         * @param jtsGeometry

         * @param firstLayerIndex

         * @return

         * @throws DriverException

         *

         * FIXME Revisar. Para el caso de la Union, hay que hacer dos pasadas:

         * diferencia A-B y diferencia B-A. Pero los features tienen que tener el

         * esquema de la intersecci?n. ?Como saber el lugar que ocupa cada atributo

         * en el esquema ILayerDefinition, en el caso de que dos capas tuviesen

         * atributos con el mismo nombre?) De momento, se buscar? en

         * ILayerDefinition la posicion que ocupa un campo a partir de su nombre.

         * Esto obliga a que 2 campos no tomen el mismo nombre

         */

        private IFeature createFeature(Geometry jtsGeometry, int firstLayerIndex)

                        throws DriverException {

                IFeature solution = null;

                IGeometry diffGeometry = FConverter.jts_to_igeometry(jtsGeometry);

                FieldDescription[] fields = layerDefinition.getFieldsDesc();

                Value[] featureAttr = new Value[fields.length];

                for (int indexField = 0; indexField < numFieldsA; indexField++) {

                        // for each field of firstRs

                        String fieldName = firstRs.getFieldName(indexField);

                        for (int j = 0; j < fields.length; j++) {

                                if (fieldName.equalsIgnoreCase(fields[j].getFieldName())) {

                                        featureAttr[j] = firstRs.getFieldValue(firstLayerIndex,

                                                        indexField);

                                        break;

                                }// if

                        }// for

                }// for

                // now we put null values

                for (int i = 0; i < featureAttr.length; i++) {

                        if (featureAttr[i] == null)

                                featureAttr[i] = ValueFactory.createNullValue();

                }

                solution = FeatureFactory.createFeature(featureAttr, diffGeometry);

                return solution;

        }

        /*

         * Value[] featureAttr = new Value[numFieldsA]; for (int indexField = 0;

         * indexField < numFieldsA; indexField++) { featureAttr[indexField] =

         * firstRs.getFieldValue(firstLayerIndex, indexField); } solution =

         * FeatureFactory.createFeature(featureAttr, diffGeometry); return solution;

         */

        public void setFeatureProcessor(FeatureProcessor featureProcessor) {

                this.featureProcessor = featureProcessor;

        }

        public String getProcessDescription() {

                return "Computing differences between two layers";

        }

        public ILayerDefinition getLayerDefinition() {

                return layerDefinition;

        }

        public void setLayerDefinition(ILayerDefinition layerDefinition) {

                this.layerDefinition = layerDefinition;

        }

}