Application: gvSIG desktop

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

 * 

 */

/*

 * AUTHORS (In addition to CIT):

 * 2008 Prodevelop S.L  main development

 */

package org.gvsig.geocoding.geommatches;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import org.apache.log4j.Logger;

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

import org.gvsig.fmap.geom.DefaultGeometryManager;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryManager;

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

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

import org.gvsig.fmap.geom.operation.tojts.ToJTS;

import com.vividsolutions.jts.operation.overlay.OverlayOp;

/**

 * 

 * class

 * 

 * @author <a href="mailto:jsanz@prodevelop.es"> Jorge Gaspar Sanz Salinas</a>

 * @author <a href="mailto:vsanjaime@prodevelop.es"> Vicente Sanjaime Calvet</a>

 * 

 */

public abstract class GeomMatcher {

        public Logger log = Logger.getLogger(GeomMatcher.class);

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

        private List listFeats;

        private MatchesParams params;

        private int fieldPosition;

        /**

         * Set features

         * 

         * @param _collectionsList

         */

        @SuppressWarnings("unchecked")

        public void setFeatures(List listFeatures) {

                this.listFeats = listFeatures;

        }

        /**

         * Get the features

         * 

         * @return

         */

        @SuppressWarnings("unchecked")

        public List getFeatures() {

                return this.listFeats;

        }

        /**

         * Set field name to group features

         * 

         * @param _collectionsList

         */

        public void setGroupField(int _fieldPosition) {

                this.fieldPosition = _fieldPosition;

        }

        /**

         * Get the group field name

         * 

         * @return

         */

        public int getGroupFieldPosition() {

                return this.fieldPosition;

        }

        /**

         * Get the parameters to make a match

         * 

         * @param context

         */

        public void setParams(MatchesParams context) {

                this.params = context;

        };

        /**

         * Set the parameters to make a match

         * 

         * @return

         */

        public MatchesParams getParams() {

                return params;

        }

        /**

         * This method parses geometries (FMap) to geometries (JTS)

         * 

         * @param geomClass

         *            type of geometry (Point2d.class, Curve2D.class, ...)

         * @param geoms

         * @return

         */

        @SuppressWarnings("unchecked")

        protected com.vividsolutions.jts.geom.Geometry[] parseGeomsToJTS(

                        Class geomClass, Geometry[] geoms) {

                com.vividsolutions.jts.geom.Geometry[] geomsjts = new com.vividsolutions.jts.geom.Geometry[geoms.length];

                GeometryManager gm = new DefaultGeometryManager();

                GeometryOperation geomOp = null;

                try {

                        geomOp = gm.getGeometryOperation(geomClass, ToJTS.CODE);

                        // Fill the operation context with required params

                        GeometryOperationContext ctx = new GeometryOperationContext();

                        // Here is the main loop where you call the operation

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

                                geomsjts[i] = (com.vividsolutions.jts.geom.Geometry) geomOp

                                                .invoke(geoms[i], ctx);

                        }

                } catch (Exception e) {

                        log.debug("Error parsing geometries to JTS",e);

                }

                log.debug("Geometry parsed");

                return geomsjts;

        }

        /**

         * This method makes the union the geometries with one attribute common.

         * 

         * @param geomsJts

         * @return

         */

        protected com.vividsolutions.jts.geom.Geometry unionLinesJTS(

                        com.vividsolutions.jts.geom.Geometry[] geomsJts) {

                com.vividsolutions.jts.geom.Geometry geometJTS = null;

                // if there are more that one geometries

                if (geomsJts.length > 1) {

                        geometJTS = OverlayOp.overlayOp(geomsJts[0], geomsJts[1],

                                        OverlayOp.UNION);

                        for (int i = 2; i < geomsJts.length; i++) {

                                geometJTS = OverlayOp.overlayOp(geometJTS, geomsJts[i],

                                                OverlayOp.UNION);

                        }

                        log.debug("Union of geometries");

                        return geometJTS;

                }

                // Only there is one geometry

                else {

                        log.debug("Union of geometries");

                        return geomsJts[0];

                }

        }

        // /**

        // *

        // * @param geometriesJts

        // * @return

        // */

        // protected List intersectLinesJTS(

        // com.vividsolutions.jts.geom.Geometry[] geometriesJts) {

        //

        // List points = new ArrayList();

        // com.vividsolutions.jts.geom.Geometry geomPointsJTS = null;

        // com.vividsolutions.jts.geom.Geometry interBBoxJTS = null;

        // com.vividsolutions.jts.geom.Geometry colPointsJts[] = null;

        //

        // if (geometriesJts.length > 0 || geometriesJts != null) {

        //

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

        //

        // for (int j = i + 1; j < geometriesJts.length; j++) {

        //

        // interBBoxJTS = OverlayOp.overlayOp(geometriesJts[i]

        // .getEnvelope(), geometriesJts[j].getEnvelope(),

        // OverlayOp.INTERSECTION);

        // if (interBBoxJTS.getGeometryType().compareTo("LineString") == 0) {

        // geomPointsJTS = OverlayOp.overlayOp(geometriesJts[i],

        // geometriesJts[j], OverlayOp.INTERSECTION);

        // if (geomPointsJTS.getGeometryType().compareTo("Point") == 0) {

        //

        // boolean toca = false;

        // for (int k = 0; k < points.size(); k++) {

        // com.vividsolutions.jts.geom.Point po =

        // (com.vividsolutions.jts.geom.Point) points

        // .get(k);

        // if (po.getCoordinate().x == geomPointsJTS

        // .getCoordinate().x

        // && po.getCoordinate().y == geomPointsJTS

        // .getCoordinate().y) {

        // toca = true;

        // break;

        // }

        // }

        // if (!toca) {

        // points.add(geomPointsJTS);

        // }

        // }

        // }

        // }

        // }

        // return points;

        //

        // } else {

        // return points;

        // }

        // }

        /**

         * This method intersect two lines and return the intersection point. If

         * result is null, two lines doesn't intersect

         * 

         * @param geometriesJts

         * @return

         */

        protected com.vividsolutions.jts.geom.Point intersectTwoLinesJTS(

                        com.vividsolutions.jts.geom.Geometry geom1Jts,

                        com.vividsolutions.jts.geom.Geometry geom2Jts) {

                com.vividsolutions.jts.geom.Geometry interBBoxJTS = null;

                com.vividsolutions.jts.geom.Geometry geomPointJTS = null;

                if (geom1Jts != null || geom2Jts != null) {

                        log.debug("Intersect: Two geometries not nulls");

                        interBBoxJTS = OverlayOp.overlayOp(geom1Jts.getEnvelope(), geom2Jts

                                        .getEnvelope(), OverlayOp.INTERSECTION);

                        if (interBBoxJTS.getGeometryType().compareTo("LineString") == 0

                                        || interBBoxJTS.getGeometryType().compareTo("Polygon") == 0) {

                                log.debug("Intersect: Intersect two BBOX");

                                geomPointJTS = OverlayOp.overlayOp(geom1Jts, geom2Jts,

                                                OverlayOp.INTERSECTION);

                                if (geomPointJTS.getGeometryType().compareTo("Point") == 0) {

                                        log.debug("Intersect: Intersect in the point X= "

                                                        + geomPointJTS.getCoordinate().x + " Y= "

                                                        + geomPointJTS.getCoordinate().y);

                                        return (com.vividsolutions.jts.geom.Point) geomPointJTS;

                                } else {

                                        log.debug("Intersect: Two lines don't intersect");

                                        return null;

                                }

                        } else {

                                log.debug("Intersect: Two BBOX don't intersect");

                                return null;

                        }

                }

                return null;

        }

        /**

         * This method group geometries to one attribute

         * 

         * @param fieldPosition

         *            position of the field with the attribute

         * @param feats

         *            features collection

         * @return

         */

        @SuppressWarnings("unchecked")

        protected HashMap groupFeaturesByAttribute(int fieldPosition, List feats) {

                HashMap coleccion = new HashMap();

                Iterator it = feats.iterator();

                // Go for all geometries of the collection

                while (it.hasNext()) {

                        // Get feature

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

                        String key = featur.get(fieldPosition).toString();

                        // Get geometry

                        Geometry geomet = (Geometry) featur.getGeometry("GEOMETRY");

                        // Store the geometries for attribute in the List

                        boolean contiene = coleccion.containsKey(key);

                        if (!contiene) {

                                List geomss = new ArrayList();

                                geomss.add(geomet);

                                coleccion.put(key, geomss);

                        } else {

                                ((ArrayList) coleccion.get(key)).add(geomet);

                        }

                }

                return coleccion;

        }

        /**

         * This abstract method gets the position over the geometries

         * 

         * @return

         */

        public abstract Geometry[] match();

}