Application: gvSIG desktop

	private int number;

	 * 

	 * 

public class GeomMatchResult implements GeocodingResult,

		Comparable<GeomMatchResult> {

	public double getScore() {

import org.gvsig.geocoding.styles.SimpleCentroid;

		AbstractGeocodingStyle astyle = getPattern().getSource().getStyle();

			List<ScoredFeature> litResults = literalSearch(literalRelations,

					literalAddress, store);

			List<ScoredFeature> litResults = literalSearch(literalRelations,

					literalAddress, store);

		else if (astyle instanceof SimpleCentroid) {

			SimpleCentroid style = (SimpleCentroid) astyle;

			List<ScoredFeature> litResults = literalSearch(literalRelations,

					mainLiteral, store);

			List<ScoredFeature> litResults = literalSearch(literalRelations,

					mainLiteralAddress, store);

			// Match

		this.firstNumber = (RelationsComponent) state.get(FIRSTNUMBER);

		this.lastNumber = (RelationsComponent) state.get(LASTNUMBER);

			int number = ((NumberAddress) address).getNumber();

import org.gvsig.geocoding.geommatches.MatcherUtils;

import org.gvsig.geocoding.result.GeomMatchResult;

public class Composed extends AbstractGeocodingStyle {

	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;

	}

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

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.TreeSet;

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

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.geocoding.Address;

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 SimpleCentroid extends AbstractGeocodingStyle {

	@Override

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

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

		// catch the first element of the main Literal to get the field

		// descriptor

		// to make the dissolve

		FeatureAttributeDescriptor desc = (FeatureAttributeDescriptor) this

				.getMainLiteral().get(0).getValue();

		// POINTs FEATURES

		if (((ScoredFeature) inFeats.get(0)).getDefaultGeometry()

				.getDimension() == 0) {

			geocoRes = createPointsFeaturesResult(inFeats);

		}

		// OTHER GEOMETRIES TYPES

		else {

			// dissolve features selected

			List<DissolveResult> disRes = this.dissolveScoredFeatures(desc,

					inFeats);

			for (DissolveResult dis : disRes) {

				GeomMatchResult matchres = new GeomMatchResult();

				Point2D position = null;

				Geometry geom = dis.getGeom();

				// Points

				if (geom.getDimension() == 0) {

					// TODO faltan los puntos

				}

				// Lines

				if (geom.getDimension() == 1) {

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

							.parseGeomGVToJTS(geom);

					position = MatcherUtils

							.getLinePositionFromRelativeDistance(geoJTS, 50);

				}

				// Polys

				if (geom.getDimension() == 2) {

					position = MatcherUtils.internalPointGeometry(geom);

				}

				matchres.setGeom(position);

				matchres.setSources(dis.getScoredFeatures());

				geocoRes.add(matchres);

			}

		}

		return geocoRes;

	}

	/**

	 * 

	 * @param inFeats

	 * @return

	 */

	private Set<GeocodingResult> createPointsFeaturesResult(

			List<ScoredFeature> inFeats) {

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

		for (ScoredFeature feat : inFeats) {

			GeomMatchResult res = new GeomMatchResult();

			res.setGeom(feat.getDefaultGeometry());

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

			sources.add(feat);

			res.setSources(sources);

			results.add(res);

		}

		return results;

	}

	/**

	 * Dissolve features geometry behind one folder

	 * 

	 * @param field

	 * @param features

	 */

	public List<DissolveResult> dissolveScoredFeatures(

			FeatureAttributeDescriptor field, List<ScoredFeature> features) {

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

		// Group geometries by main attribute

		HashMap<String, List<ScoredFeature>> dissolAttributes = MatcherUtils

				.groupScoredFeaturesByAttribute(field, features);

		// For each group of features, to do geometries dissolve process getting

		// at the end one o more geometries

		for (Iterator<Map.Entry<String, List<ScoredFeature>>> iterator = dissolAttributes

				.entrySet().iterator(); iterator.hasNext();) {

			Map.Entry<String, List<ScoredFeature>> e = iterator.next();

			List<ScoredFeature> feats = e.getValue();

			// dissolve Lines (if first geometry of array is Line)

			List<DissolveResult> geomsDissol = null;

			if (feats.get(0).getDefaultGeometry().getDimension() == 1) {

				geomsDissol = MatcherUtils.dissolveLinesJTS(feats);

			}

			// dissolve Polys (if first geometry of array is Poly)

			if (feats.get(0).getDefaultGeometry().getDimension() == 2) {

				geomsDissol = MatcherUtils.dissolvePolysJTS(feats);

			}

			// insert each dissolve result in the general array

			for (DissolveResult dissolveResult : geomsDissol) {

				listResults.add(dissolveResult);

			}

		}

		return listResults;

	}

}

public interface Geocoder {

	public Set<GeocodingResult> geocode(Address address)

			throws InitializeException, LocatorException, DataException;

 * 

 * 

	 * 

	 * 

	public static int getLevenshteinDistance(String s, String t) {

		if (s == null || t == null) {

			throw new IllegalArgumentException("Strings must not be null");

		}

		/*

		 * The difference between this impl. and the previous is that, rather

		 * than creating and retaining a matrix of size s.length()+1 by

		 * t.length()+1, we maintain two single-dimensional arrays of length

		 * s.length()+1. The first, d, is the 'current working' distance array

		 * that maintains the newest distance cost counts as we iterate through

		 * the characters of String s. Each time we increment the index of

		 * String t we are comparing, d is copied to p, the second int[]. Doing

		 * so allows us to retain the previous cost counts as required by the

		 * algorithm (taking the minimum of the cost count to the left, up one,

		 * and diagonally up and to the left of the current cost count being

		 * calculated). (Note that the arrays aren't really copied anymore, just

		 * switched...this is clearly much better than cloning an array or doing

		 * a System.arraycopy() each time through the outer loop.)

		 * 

		 * Effectively, the difference between the two implementations is this

		 * one does not cause an out of memory condition when calculating the LD

		 * over two very large strings.

		 */

		int n = s.length(); // length of s

		int m = t.length(); // length of t

		if (n == 0) {

			return m;

		} else if (m == 0) {

			return n;

		}

		int p[] = new int[n + 1]; // 'previous' cost array, horizontally

		int d[] = new int[n + 1]; // cost array, horizontally

		int _d[]; // placeholder to assist in swapping p and d

		// indexes into strings s and t

		int i; // iterates through s

		int j; // iterates through t

		char t_j; // jth character of t

		int cost; // cost

		for (i = 0; i <= n; i++) {

			p[i] = i;

		for (j = 1; j <= m; j++) {

			t_j = t.charAt(j - 1);

			d[0] = j;

			for (i = 1; i <= n; i++) {

				cost = s.charAt(i - 1) == t_j ? 0 : 1;

				// minimum of cell to the left+1, to the top+1, diagonally left

				// and up +cost

				d[i] = Math.min(Math.min(d[i - 1] + 1, p[i] + 1), p[i - 1]

						+ cost);

			}

			// copy current distance counts to 'previous row' distance counts

			_d = p;

			p = d;

			d = _d;

		}

		// our last action in the above loop was to switch d and p, so p now

		// actually has the most recent cost counts

		return p[n];

	}

	 * 

	private List<Literal> intersectionLiteral = new ArrayList<Literal>();

	 * 

	 * 

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

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

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

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

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

	private static final String OFFSET = "OFFSET";

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

	public GeocodingSource() {

	 *