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.styles;

import java.util.ArrayList;

import java.util.List;

import java.util.Set;

import java.util.TreeSet;

import org.gvsig.geocoding.Address;

import org.gvsig.geocoding.Literal;

import org.gvsig.geocoding.geommatches.MatcherUtils;

import org.gvsig.geocoding.result.DissolveResult;

import org.gvsig.geocoding.result.GeocodingResult;

import org.gvsig.geocoding.result.GeomMatchResult;

import org.gvsig.geocoding.result.ScoredFeature;

/**

 * 

 * 

 * @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 Composed extends AbstractGeocodingStyle {

        private List<Literal> intersectsLiterals;

        /**

         * 

         * @return

         */

        public List<Literal> getIntersectsLiterals() {

                return intersectsLiterals;

        }

        /**

         * 

         * @param intersectName

         */

        public void setIntersectsLiterals(List<Literal> intersects) {

                this.intersectsLiterals = intersects;

        }

        @Override

        public Set<GeocodingResult> match(List listLists, Address address) {

                List<ScoredFeature> mainList = (List<ScoredFeature>) listLists.get(0);

                List<ScoredFeature> secondList = (List<ScoredFeature>) listLists.get(1);

                // this list store dissolve element of the first intersection (cross)

                List<ScoredFeature> crossList = new ArrayList<ScoredFeature>();

                for (ScoredFeature maRes : mainList) {

                        com.vividsolutions.jts.geom.Geometry mainGeomJTS = MatcherUtils

                                        .parseGeomGVToJTS(maRes.getDefaultGeometry());

                        for (ScoredFeature secRes : secondList) {

                                com.vividsolutions.jts.geom.Geometry secGeomJTS = MatcherUtils

                                                .parseGeomGVToJTS(secRes.getDefaultGeometry());

                                if (mainGeomJTS.touches(secGeomJTS)) {

                                        crossList.add(maRes);

                                        break;

                                }

                        }

                }

                // Triple Intersect (Cross Streets)

                // this list store dissolve element of the second intersection (three

                // intersection)

                List<ScoredFeature> reslist = new ArrayList<ScoredFeature>();

                if (listLists.size() == 3) {

                        List<ScoredFeature> thirdList = (List<ScoredFeature>) listLists

                                        .get(2);

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

                                ScoredFeature mainCrossFeat = crossList.get(i);

                                com.vividsolutions.jts.geom.Geometry mainCrossGeomJTS = MatcherUtils

                                                .parseGeomGVToJTS(mainCrossFeat.getDefaultGeometry());

                                for (ScoredFeature thiRes : thirdList) {

                                        com.vividsolutions.jts.geom.Geometry thiGeomJTS = MatcherUtils

                                                        .parseGeomGVToJTS(thiRes.getDefaultGeometry());

                                        if (mainCrossGeomJTS.touches(thiGeomJTS)) {

                                                reslist.add(mainCrossFeat);

                                                break;

                                        }

                                }

                        }

                }

                Set<GeocodingResult> fin = new TreeSet<GeocodingResult>();

                if (listLists.size() == 2) {

                        for (ScoredFeature res : crossList) {

                                GeomMatchResult mat = new GeomMatchResult();

                        }

                }

                if (listLists.size() == 3) {

                        for (ScoredFeature res : reslist) {

                                GeomMatchResult mat = new GeomMatchResult();

                        }

                }

                return fin;

        }

        /**

         * 

         * @param listLists

         * @return

         */

        private Set<GeocodingResult> multiIntersect(

                        List<List<DissolveResult>> listLists) {

                List<DissolveResult> mainList = listLists.get(0);

                List<DissolveResult> secondList = listLists.get(1);

                // this list store dissolve element of the first intersection (cross)

                List<DissolveResult> crossList = new ArrayList<DissolveResult>();

                for (DissolveResult maRes : mainList) {

                        com.vividsolutions.jts.geom.Geometry mainGeomJTS = MatcherUtils

                                        .parseGeomGVToJTS(maRes.getGeom());

                        for (DissolveResult secRes : secondList) {

                                com.vividsolutions.jts.geom.Geometry secGeomJTS = MatcherUtils

                                                .parseGeomGVToJTS(secRes.getGeom());

                                if (mainGeomJTS.touches(secGeomJTS)) {

                                        crossList.add(maRes);

                                        break;

                                }

                        }

                }

                // Triple Intersect (Cross Streets)

                // this list store dissolve element of the second intersection (three

                // intersection)

                List<DissolveResult> reslist = new ArrayList<DissolveResult>();

                if (listLists.size() == 3) {

                        List<DissolveResult> thirdList = listLists.get(2);

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

                                DissolveResult mainCrossRes = crossList.get(i);

                                com.vividsolutions.jts.geom.Geometry mainCrossGeomJTS = MatcherUtils

                                                .parseGeomGVToJTS(mainCrossRes.getGeom());

                                for (DissolveResult thiRes : thirdList) {

                                        com.vividsolutions.jts.geom.Geometry thiGeomJTS = MatcherUtils

                                                        .parseGeomGVToJTS(thiRes.getGeom());

                                        if (mainCrossGeomJTS.touches(thiGeomJTS)) {

                                                reslist.add(mainCrossRes);

                                                break;

                                        }

                                }

                        }

                }

                Set<GeocodingResult> fin = new TreeSet<GeocodingResult>();

                if (listLists.size() == 2) {

                        for (DissolveResult res : crossList) {

                                GeomMatchResult mat = new GeomMatchResult();

                        }

                }

                if (listLists.size() == 3) {

                        for (DissolveResult res : reslist) {

                                GeomMatchResult mat = new GeomMatchResult();

                        }

                }

                return null;

        }

}