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;

	}

}

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

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import org.gvsig.fmap.geom.Geometry;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * This class searchs positions in cross lines (cross ways)

 * 

 * @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 CrossLineMatcher extends GeomMatcher {

	private Logger log = LoggerFactory.getLogger(CrossLineMatcher.class);

	/**

	 * Search the position in the cross lines

	 * 

	 * @return cross points

	 */

	@SuppressWarnings("unchecked")

	public Point2D[] match() {

		// Group first features collection by one field

		HashMap geomstreets1 = groupFeaturesByAttribute(this

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

		List streets1 = new ArrayList();

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

		while (itt1.hasNext()) {

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

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

			// Insert geometries of one street into array

			Geometry[] arrGeoms1 = new Geometry[geomss1.size()];

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

				arrGeoms1[i] = (Geometry) geomss1.get(i);

			}

			// Parse geometries to JTS

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

					geomss1.get(0).getClass(), arrGeoms1);

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

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

			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 itt2 = geomstreets2.entrySet().iterator();

		while (itt2.hasNext()) {

			Map.Entry e = (Map.Entry) itt2.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 geomstreetjts = unionLinesJTS(geomsjts);

			streets2.add(geomstreetjts);

		}

		// Proof the intersection of geometries

		com.vividsolutions.jts.geom.Point pto = null;

		Set interPoints = new HashSet();

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

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

					.get(i);

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

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

						.get(j);

				pto = intersectTwoLinesJTS(geomJts1, geomJts2);

				if (pto != null) {

					log.debug("Intersecction point. X= " + pto.getX() + " Y= "

							+ pto.getY());

					interPoints.add(pto);

					log.debug("Point added ");

				} else {

					log.info("No intersection between two lines");

				}

				log.debug("-------------------");

			}

		}

		// Parse HashSet to Point2D Array

		Point2D[] points = new Point2D[interPoints.size()];

		Iterator itt5 = interPoints.iterator();

		int cont = 0;

		while (itt5.hasNext()) {

			com.vividsolutions.jts.geom.Point po = (com.vividsolutions.jts.geom.Point) itt5

					.next();

			points[cont] = new Point2D(po.getCoordinate().x,

					po.getCoordinate().y);

			cont++;

		}

		return points;

	}

}

/* 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.awt.geom.PathIterator;

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.primitive.Point2D;

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

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.linearref.LengthIndexedLine;

/**

 * 

 * This class searchs positions over lines (ways)

 * 

 * @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 SimpleLineMatcher extends GeomMatcher {

	/**

	 * This method gets the position over lines (Streets) or next to the lines

	 * 

	 * @return

	 */

	@SuppressWarnings("unchecked")

	public Geometry[] match() {

		// Group the geometries by one field

		HashMap geomstreets1 = groupFeaturesByAttribute(this

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

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

		Point2D[] points = new Point2D[geomstreets1.size()];

		int position = 0;

		while (it.hasNext()) {

			Map.Entry e = (Map.Entry) it.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 geomstreetjts = unionLinesJTS(geomsjts);

			// Get the point of the geometry (LINE)

			Point2D point = getLinesPosition(geomstreetjts, getParams());

			points[position] = point;

			position++;

		}

		return points;

	}

	/**

	 * Calculate the position inside sigle line

	 * 

	 * @param geometryJts

	 *            line of street

	 * @param params

	 *            Parameters to position the point over the lines

	 * @return

	 */

	private Point2D getLinesPosition(

			com.vividsolutions.jts.geom.Geometry geometryJts,

			MatchesParams params) {

		double totaldistance = geometryJts.getLength();

		LengthIndexedLine lenline = new LengthIndexedLine(geometryJts);

		Long distance = params.getDistance();

		Integer relativedist = params.getRelativeDistance();

		Double offset = params.getOffset();

		Coordinate coors = null;

		// first calculate with the distance

		if (distance != null) {

			if (lenline.isValidIndex(distance)) {

				coors = lenline.extractPoint(distance);

				// with offset

				if (offset != null && offset.doubleValue() > 0) {

					return getOffsetPosition(new Point2D(coors.x, coors.y),

							offset);

				}

				// Without offset

				else {

					return new Point2D(coors.x, coors.y);

				}

			}

		}

		// Calculate percentage of distance

		else if (relativedist != null) {

			if (totaldistance > 0) {

				double dist = (relativedist * totaldistance) / 100.0;

				coors = lenline.extractPoint(dist);

				// with offset

				if (offset != null && offset.doubleValue() > 0) {

					return getOffsetPosition(new Point2D(coors.x, coors.y),

							offset);

				}

				// Without offset

				else {

					return new Point2D(coors.x, coors.y);

				}

			}

		}

		// Any other case

		else {

			if (totaldistance > 0) {

				double dist = totaldistance / 2.0;

				coors = lenline.extractPoint(dist);

				// with offset

				if (offset != null && offset.doubleValue() > 0) {

					return getOffsetPosition(new Point2D(coors.x, coors.y),

							offset);

				}

				// Without offset

				else {

					return new Point2D(coors.x, coors.y);

				}

			}

		}

		return null;

	}

	/**

	 * Calculate the position in the line with offset

	 * 

	 * @param linePoint

	 *            middle point over the liner

	 * @param dist

	 *            perpendicular distance since the line

	 * @return

	 */

	@SuppressWarnings("unchecked")

	private Point2D getOffsetPosition(Point2D linePoint, double dist) {

		List feats = (List) getFeatures().get(0);

		Geometry[] geoms = new Geometry[feats.size()];

		Iterator it = feats.iterator();

		int cont = 0;

		while (it.hasNext()) {

			geoms[cont] = (Geometry) ((Feature) it.next())

					.getGeometry("GEOMETRY");

			cont++;

		}

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

			double[] coords = new double[6];

			Point2D inicio = null;

			Point2D fin = null;

			boolean inter = geoms[j].intersects(linePoint.getBounds2D());

			if (inter) {

				PathIterator iter = ((Curve2D) geoms[j]).getGeneralPathX()

						.getPathIterator(null);

				iter.currentSegment(coords);

				inicio = new Point2D(coords[0], coords[1]);

				iter.next();

				iter.currentSegment(coords);

				fin = new Point2D(coords[0], coords[1]);

				log.debug("Return point with offset");

				return getPerpendicularPoint(inicio, fin, linePoint, dist);

			}

		}

		log.debug("Return original point without offset");

		return linePoint;

	}

	/**

	 * 

	 * This method calculates a point perpendicular to the line at a distance

	 * 

	 * @param inicio

	 *            initial point of the line

	 * @param fin

	 *            end point of the line

	 * @param linePoint

	 *            middle point over line

	 * @param dist

	 *            perpendicular distance to the line

	 * @return

	 */

	private Point2D getPerpendicularPoint(Point2D inicio, Point2D fin,

			Point2D linePoint, double dist) {

		java.awt.geom.Point2D p1 = new java.awt.geom.Point2D.Double(inicio

				.getX(), inicio.getY());

		java.awt.geom.Point2D p2 = new java.awt.geom.Point2D.Double(fin.getX(),

				fin.getY());

		java.awt.geom.Point2D perpPoint = new java.awt.geom.Point2D.Double(

				linePoint.getX(), linePoint.getY());

		java.awt.geom.Point2D[] p = UtilFunctions.getPerpendicular(p1, p2,

				perpPoint);

		java.awt.geom.Point2D unit = UtilFunctions.getUnitVector(p[0], p[1]);

		java.awt.geom.Point2D res = new java.awt.geom.Point2D.Double(perpPoint

				.getX()

				+ (unit.getX() * dist), perpPoint.getY() + (unit.getY() * dist));

		return new Point2D(res.getX(), res.getY());

	}

}

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

import java.util.Map;

/**

 * 

 * 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 class MatchesParams {

	private Map<String, Object> atts = new HashMap<String, Object>();

	private static final String RELATIVEDIST = "RELATIVEDIST";

	private static final String DISTANCE = "DISTANCE";

	private static final String OFFSET = "OFFSET";

	/**

	 * Constructor class

	 */

	public MatchesParams() {

		setDistance(null);

		setRelativeDistance(null);

		setOffset(null);

	}

	/**

	 * Set the distance from initial node

	 * 

	 * @param distance

	 */

	public void setDistance(Long distance) {

		setAttribute(DISTANCE, distance);

	}

	/**

	 * Set the relative distance from the total distance

	 * 

	 * @param relative

	 */

	public void setRelativeDistance(Integer relative) {

		setAttribute(RELATIVEDIST, relative);

	}

	/**

	 * Set the offset distance from the way If the value is positive the offset

	 * is in the right side If the value is negative the offset is in the left

	 * side

	 * 

	 * @param offset

	 */

	public void setOffset(Double offset) {

		setAttribute(OFFSET, offset);

	}

	/**

	 * Get the distance

	 * 

	 * @return

	 */

	public Long getDistance() {

		return (Long) getAttribute(DISTANCE);

	}

	/**

	 * Get the relative distance in percentage value

	 * 

	 * @return

	 */

	public Integer getRelativeDistance() {

		return (Integer) getAttribute(RELATIVEDIST);

	}

	/**

	 * Get the distance from the way If the value is positive the offset is in

	 * the right side If the value is negative the offset is in the left side

	 * 

	 * @return

	 */

	public Double getOffset() {

		return (Double) getAttribute(OFFSET);

	}

	private Object getAttribute(Object key) {

		return this.atts.get(key);

	}

	private void setAttribute(String name, Object value) {

		this.atts.put(name, value);

	}

}

/* 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.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 org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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 = LoggerFactory.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();

}

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.geom.Geometry;

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

import com.vividsolutions.jts.algorithm.InteriorPointArea;

public class PolygonMatcher extends GeomMatcher {

	/**

	 * This method match the centroids (Point2D) of polygons. If there are some

	 * multipolygon in the result features the centroid will be a MultiPoint

	 */

	@Override

	public Geometry[] match() {

		HashMap polys = groupFeaturesByAttribute(this.getGroupFieldPosition(),

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

		Iterator it = polys.entrySet().iterator();

		Geometry[] mPoints = new Geometry[polys.size()];

		int position = 0;

		while (it.hasNext()) {

			Map.Entry e = (Map.Entry) it.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++) {

				Geometry ggeom = (Geometry) geomss.get(i);

				arrGeoms[i] = ggeom;

			}

			// Parse geometries to JTS

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

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

			// Get centroid of polygon or polygons

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

				Point2D pts = getCenterOfPolygon(geomsjts[j]);

				mPoints[position] = pts;

				position++;

			}

		}

		return mPoints;

	}

	/**

	 * This method calculate the centroid of one polygon. Always the centroid

	 * will be within the polygon.

	 * 

	 * @param geomjts

	 * @return

	 */

	private Point2D getCenterOfPolygon(

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

		InteriorPointArea centro = new InteriorPointArea(geomjts);

		com.vividsolutions.jts.geom.Point pto = geomjts.getInteriorPoint();

		return new Point2D(pto.getX(), pto.getY());

	}

}

	private static final Logger log = LoggerFactory.getLogger(MatcherUtils.class);

	 *            (gvSIG geometry)

		log.error("Centroid point null ......");

	 * @return

	 * @param geoms

	 * @return

	 * @param geoms

	 * @return

	 * @param geometriesJts

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

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

					Point2D pto = new Point2D(geomPointJTS.getCoordinate().x,geomPointJTS.getCoordinate().y);

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

	 * @param geomsJts

		// None elemnts

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

	 * @param fieldPosition

	 *            position of the field with the attribute

	 *            features collection

	 * 

	 *            initial point of the line

	 *            end point of the line

	 *            middle point over line

	 *            perpendicular distance to the line

	 * 

	 *            middle point over the liner

	 *            perpendicular distance since the line

 * Class Source.

 * This class has the address components and the layer source

	private static final Logger log = LoggerFactory.getLogger(GeocodingSource.class);

 * Class Settings.

 * This class is one of the elements that define address pattern

	 * Default Constructor