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 java.util.Map;

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

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.geom.util.Converter;

/**

 * 

 * This class gets the line between two lines

 * 

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

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

 * 

 */

public class DoubleCrossLineMatcher extends GeomMatcher {

        /**

         * Search lines between two lines

         */

        @SuppressWarnings("unchecked")

        public Curve2D[] match() {

                // Group first features collection

                HashMap geomstreets1 = groupFeaturesByAttribute(this

                                .getGroupFieldPosition(), (List) this.getFeatures().get(0));

                List streets1 = new ArrayList();

                Iterator it1 = geomstreets1.entrySet().iterator();

                while (it1.hasNext()) {

                        Map.Entry e = (Map.Entry) it1.next();

                        ArrayList geomss = (ArrayList) e.getValue();

                        // Insert geometries of one street into array

                        Geometry[] arrGeoms = new Geometry[geomss.size()];

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

                                arrGeoms[i] = (Geometry) geomss.get(i);

                        }

                        // Parse geometries to JTS

                        com.vividsolutions.jts.geom.Geometry[] geomsjts = parseGeomsToJTS(

                                        geomss.get(0).getClass(), arrGeoms);

                        // Make the UNION of the all geometries with the same attribute

                        com.vividsolutions.jts.geom.Geometry geomstreetjts1 = unionLinesJTS(geomsjts);

                        streets1.add(geomstreetjts1);

                }

                // Group second features collection by one field

                HashMap geomstreets2 = groupFeaturesByAttribute(this

                                .getGroupFieldPosition(), (List) this.getFeatures().get(1));

                List streets2 = new ArrayList();

                Iterator it2 = geomstreets2.entrySet().iterator();

                while (it2.hasNext()) {

                        Map.Entry e = (Map.Entry) it2.next();

                        ArrayList geomss = (ArrayList) e.getValue();

                        // Insert geometries of one street into array

                        Geometry[] arrGeoms = new Geometry[geomss.size()];

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

                                arrGeoms[i] = (Geometry) geomss.get(i);

                        }

                        // Parse geometries to JTS

                        com.vividsolutions.jts.geom.Geometry[] geomsjts = parseGeomsToJTS(

                                        geomss.get(0).getClass(), arrGeoms);

                        // Make the UNION of the all geometries with the same attribute

                        com.vividsolutions.jts.geom.Geometry geomstreetjts2 = unionLinesJTS(geomsjts);

                        streets2.add(geomstreetjts2);

                }

                // Group third features collection

                HashMap ppalstreets = groupFeaturesByAttribute(this

                                .getGroupFieldPosition(), (List) this.getFeatures().get(2));

                List streets3 = new ArrayList();

                Iterator it3 = ppalstreets.entrySet().iterator();

                while (it3.hasNext()) {

                        Map.Entry e = (Map.Entry) it3.next();

                        ArrayList geomss = (ArrayList) e.getValue();

                        // Insert geometries of one street into array

                        Geometry[] arrGeoms = new Geometry[geomss.size()];

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

                                arrGeoms[i] = (Geometry) geomss.get(i);

                        }

                        // Parse geometries to JTS

                        com.vividsolutions.jts.geom.Geometry[] geomsjts = parseGeomsToJTS(

                                        geomss.get(0).getClass(), arrGeoms);

                        // Make the UNION of the all geometries with the same attribute

                        com.vividsolutions.jts.geom.Geometry geomstreetjts3 = unionLinesJTS(geomsjts);

                        streets3.add(geomstreetjts3);

                }

                // Intersect each main street with all streets of the second group, if

                // it intersects with some street proof with the intersection with

                // second streets group

                List geomStreets = new ArrayList();

                com.vividsolutions.jts.geom.Point[] segment = new com.vividsolutions.jts.geom.Point[2];

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

                        log.debug("STREET PPAL: " + i);

                        com.vividsolutions.jts.geom.Geometry street3jts = (com.vividsolutions.jts.geom.Geometry) streets3

                                        .get(i);

                        for (int j = 0; j < streets1.size(); j++) {

                                log.debug("STREET: " + i + " SECUNDARY: " + j);

                                com.vividsolutions.jts.geom.Geometry street1jts = (com.vividsolutions.jts.geom.Geometry) streets1

                                                .get(j);

                                com.vividsolutions.jts.geom.Point pto = intersectTwoLinesJTS(

                                                street3jts, street1jts);

                                if (pto != null) {

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

                                                log.debug("STREET: " + i + " SECUNDARY: " + j

                                                                + " TERTIARY: " + k);

                                                com.vividsolutions.jts.geom.Geometry street2jts = (com.vividsolutions.jts.geom.Geometry) streets2

                                                                .get(k);

                                                com.vividsolutions.jts.geom.Point pto2 = intersectTwoLinesJTS(

                                                                street3jts, street2jts);

                                                if (pto2 != null) {

                                                        segment[0] = pto;

                                                        segment[1] = pto2;

                                                        geomStreets.add(segment);

                                                        log.debug("Segment added. Number: "

                                                                        + geomStreets.size());

                                                        log.debug("Segment x1= " + pto.getCoordinate().x

                                                                        + " y1= " + pto.getCoordinate().y);

                                                        log.debug("Segment x2= " + pto2.getCoordinate().x

                                                                        + " y1= " + pto2.getCoordinate().y);

                                                }

                                        }

                                }

                        }

                }

                List ppalFeats = (List) getFeatures().get(2);

                List results = new ArrayList();

                Iterator it7 = ppalFeats.iterator();

                while (it7.hasNext()) {

                        Feature fea = (Feature) it7.next();

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

                        Geometry[] ges = new Geometry[1];

                        ges[0] = geomet;

                        com.vividsolutions.jts.geom.Geometry[] jtsGeoms = parseGeomsToJTS(

                                        ges[0].getClass(), ges);

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

                                for (int j = 0; j < geomStreets.size(); j++) {

                                        com.vividsolutions.jts.geom.Point[] ptos = (com.vividsolutions.jts.geom.Point[]) geomStreets

                                                        .get(j);

                                        boolean cont1 = (jtsGeoms[i].intersects(ptos[0]));

                                        if (cont1) {

                                                boolean cont2 = jtsGeoms[i].intersects(ptos[1]);

                                                if (cont2) {

                                                        results.add(fea);

                                                }

                                        }

                                }

                        }

                }

                Curve2D[] sublines = new Curve2D[results.size()];

                Geometry[] geome1 = new Geometry[1];

                Geometry geome = null;

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

                        geome = (Geometry) ((Feature) results.get(i))

                                        .getGeometry("GEOMETRY");

                        geome1[0] = geome;

                        com.vividsolutions.jts.geom.Geometry[] tempsJts = parseGeomsToJTS(

                                        geome1[0].getClass(), geome1);

                        com.vividsolutions.jts.geom.Geometry tempgeom = unionLinesJTS(tempsJts);

                        Geometry geometr = Converter.jtsToGeometry(tempgeom);

                        sublines[i] = (Curve2D) geometr;

                }

                return sublines;

        }

}