Application: gvSIG desktop

<?xml version="1.0" encoding="UTF-8"?>

<projectDescription>

	<name>libFMap</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

			<name>org.eclipse.jdt.core.javabuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>de.loskutov.FileSync.FSBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>com.gentleware.uml2.reveng.IncrementalReverseEngineeringBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>com.gentleware.uml2.resource.xmi.xmiIndexBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

		<nature>org.eclipse.jem.workbench.JavaEMFNature</nature>

		<nature>org.eclipse.jdt.core.javanature</nature>

		<nature>org.eclipse.jem.beaninfo.BeanInfoNature</nature>

		<nature>com.gentleware.uml2.reveng.RoundtripProject</nature>

		<nature>com.gentleware.uml2.resource.xmi.indexedXmiNature</nature>

	</natures>

</projectDescription>

/*

 * Created on 06-oct-2006

 *

 * gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

/* CVS MESSAGES:

 *

 * $Id: SnapPointLocator.java 13685 2007-09-13 18:02:35Z azabala $

 * $Log$

 * Revision 1.3  2007-09-13 17:59:04  azabala

 * changes to adapt to JTS 1.8

 *

 * Revision 1.2  2007/03/06 17:08:55  caballero

 * Exceptions

 *

 * Revision 1.1  2006/12/04 19:29:31  azabala

 * *** empty log message ***

 *

 * Revision 1.1  2006/10/17 18:25:53  azabala

 * *** empty log message ***

 *

 * Revision 1.1  2006/10/09 19:10:56  azabala

 * First version in CVS

 *

 *

 */

package com.vividsolutions.jts.algorithms;

import java.util.Iterator;

import com.vividsolutions.jts.algorithm.BoundaryNodeRule;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryCollection;

import com.vividsolutions.jts.geom.GeometryCollectionIterator;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geom.LinearRing;

import com.vividsolutions.jts.geom.Location;

import com.vividsolutions.jts.geom.MultiLineString;

import com.vividsolutions.jts.geom.MultiPolygon;

import com.vividsolutions.jts.geom.Polygon;

public class SnapPointLocator extends

		com.vividsolutions.jts.algorithm.PointLocator {

	private BoundaryNodeRule boundaryRule = BoundaryNodeRule.ENDPOINT_BOUNDARY_RULE; // OGC_SFS_BOUNDARY_RULE;

	private boolean isIn; // true if the point lies in or on any Geometry

	// element

	private int numBoundaries; // the number of sub-elements whose boundaries

	// the point lies in

	public SnapPointLocator() {

	}

	public SnapPointLocator(BoundaryNodeRule boundaryRule) {

		if (boundaryRule == null)

			throw new IllegalArgumentException("Rule must be non-null");

		this.boundaryRule = boundaryRule;

	}

	/**

	 * Convenience method to test a point for intersection with a Geometry

	 * 

	 * @param p

	 *            the coordinate to test

	 * @param geom

	 *            the Geometry to test

	 * @return <code>true</code> if the point is in the interior or boundary

	 *         of the Geometry

	 */

	public boolean intersects(Coordinate p, Geometry geom, double snapTolerance) {

		return locate(p, geom, snapTolerance) != Location.EXTERIOR;

	}

	/**

	 * Computes the topological relationship ({@link Location}) of a single

	 * point to a Geometry. It handles both single-element and multi-element

	 * Geometries. The algorithm for multi-part Geometries takes into account

	 * the SFS Boundary Determination Rule.

	 * 

	 * @return the {@link Location} of the point relative to the input Geometry

	 */

	public int locate(Coordinate p, Geometry geom, double snapTolerance) {

		if (geom.isEmpty())

			return Location.EXTERIOR;

		if (geom instanceof LinearRing) {

			return locate(p, (LinearRing) geom, snapTolerance);

		}

		if (geom instanceof LineString) {

			return locate(p, (LineString) geom, snapTolerance);

		} else if (geom instanceof Polygon) {

			return locate(p, (Polygon) geom, snapTolerance);

		}

		isIn = false;

		numBoundaries = 0;

		computeLocation(p, geom, snapTolerance);

//		if (SnappingGeometryGraph.isInBoundary(numBoundaries))

//			return Location.BOUNDARY;

		if (boundaryRule.isInBoundary(numBoundaries))

			return Location.BOUNDARY;

		if (numBoundaries > 0 || isIn)

			return Location.INTERIOR;

		return Location.EXTERIOR;

	}

	private void computeLocation(Coordinate p, Geometry geom,

			double snapTolerance) {

		if (geom instanceof LinearRing) {

			updateLocationInfo(locate(p, (LinearRing) geom, snapTolerance));

		}

		if (geom instanceof LineString) {

			updateLocationInfo(locate(p, (LineString) geom, snapTolerance));

		} else if (geom instanceof Polygon) {

			updateLocationInfo(locate(p, (Polygon) geom, snapTolerance));

		} else if (geom instanceof MultiLineString) {

			MultiLineString ml = (MultiLineString) geom;

			for (int i = 0; i < ml.getNumGeometries(); i++) {

				LineString l = (LineString) ml.getGeometryN(i);

				updateLocationInfo(locate(p, l, snapTolerance));

			}

		} else if (geom instanceof MultiPolygon) {

			MultiPolygon mpoly = (MultiPolygon) geom;

			for (int i = 0; i < mpoly.getNumGeometries(); i++) {

				Polygon poly = (Polygon) mpoly.getGeometryN(i);

				updateLocationInfo(locate(p, poly, snapTolerance));

			}

		} else if (geom instanceof GeometryCollection) {

			Iterator geomi = new GeometryCollectionIterator(

					(GeometryCollection) geom);

			while (geomi.hasNext()) {

				Geometry g2 = (Geometry) geomi.next();

				if (g2 != geom)

					computeLocation(p, g2, snapTolerance);

			}

		}

	}

	private void updateLocationInfo(int loc) {

		if (loc == Location.INTERIOR)

			isIn = true;

		if (loc == Location.BOUNDARY)

			numBoundaries++;

	}

	private int locate(Coordinate p, LineString l, double snapTolerance) {

		Coordinate[] pt = l.getCoordinates();

		if (!l.isClosed()) {

			if (p.distance(pt[0]) <= snapTolerance

					|| p.distance(pt[pt.length - 1]) <= snapTolerance) {

				return Location.BOUNDARY;

			}

		}

		if (SnapCGAlgorithms.isOnLine(p, pt, snapTolerance))

			return Location.INTERIOR;

		return Location.EXTERIOR;

	}

	private int locate(Coordinate p, LinearRing ring, double snapTolerance) {

		// can this test be folded into isPointInRing ?

		if (SnapCGAlgorithms.isOnLine(p, ring.getCoordinates())) {

			return Location.BOUNDARY;

		}

		if (SnapCGAlgorithms.isPointInRing(p, ring.getCoordinates(),

				snapTolerance))

			return Location.INTERIOR;

		return Location.EXTERIOR;

	}

	private int locate(Coordinate p, Polygon poly, double snapTolerance) {

		if (poly.isEmpty())

			return Location.EXTERIOR;

		LinearRing shell = (LinearRing) poly.getExteriorRing();

		int shellLoc = locate(p, shell, snapTolerance);

		if (shellLoc == Location.EXTERIOR)

			return Location.EXTERIOR;

		if (shellLoc == Location.BOUNDARY)

			return Location.BOUNDARY;

		// now test if the point lies in or on the holes

		for (int i = 0; i < poly.getNumInteriorRing(); i++) {

			LinearRing hole = (LinearRing) poly.getInteriorRingN(i);

			int holeLoc = locate(p, hole, snapTolerance);

			if (holeLoc == Location.INTERIOR)

				return Location.EXTERIOR;

			if (holeLoc == Location.BOUNDARY)

				return Location.BOUNDARY;

		}

		return Location.INTERIOR;

	}

}

/*

 * Created on 06-oct-2006

 *

 * gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

/* CVS MESSAGES:

*

* $Id: SnapCGAlgorithms.java 13683 2007-09-13 17:58:32Z azabala $

* $Log$

* Revision 1.2  2007-09-13 17:58:32  azabala

* added snapEquals2D method

*

* Revision 1.1  2006/12/04 19:29:31  azabala

* *** empty log message ***

*

* Revision 1.2  2006/10/19 16:06:48  azabala

* *** empty log message ***

*

* Revision 1.1  2006/10/17 18:25:53  azabala

* *** empty log message ***

*

* Revision 1.1  2006/10/09 19:10:56  azabala

* First version in CVS

*

*

*/

package com.vividsolutions.jts.algorithms;

import com.vividsolutions.jts.algorithm.CGAlgorithms;

import com.vividsolutions.jts.algorithm.RobustDeterminant;

import com.vividsolutions.jts.geom.Coordinate;

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

public class SnapCGAlgorithms extends CGAlgorithms {

	/**

	   * Test whether a point lies on the line segments defined by a

	   * list of coordinates.

	   *

	   * @return true true if

	   * the point is a vertex of the line or lies in the interior of a line

	   * segment in the linestring

	   */

	  public static boolean isOnLine(Coordinate p, Coordinate[] pt, double snapTol) {

	    SnapLineIntersector lineIntersector = new SnapLineIntersector(snapTol);

	    for (int i = 1; i < pt.length; i++) {

	      Coordinate p0 = pt[i - 1];

	      Coordinate p1 = pt[i];

	      lineIntersector.computeIntersection(p, p0, p1);

	      if (lineIntersector.hasIntersection()) {

	        return true;

	      }

	    }

	    return false;

	  }

	  public static boolean isPointInRing(Coordinate p, Coordinate[] ring, double snapTolerance) {

		    /*

		     *  For each segment l = (i-1, i), see if it crosses ray from test point in positive x direction.

		     */

		    int crossings = 0;  // number of segment/ray crossings

		    SnapLineIntersector lineIntersector = new SnapLineIntersector(snapTolerance);

		    for (int i = 1; i < ring.length; i++) {

		      int i1 = i - 1;

		      Coordinate p1 = ring[i];

		      Coordinate p2 = ring[i1];

		      lineIntersector.computeIntersection(p, p1, p2);

		      if (lineIntersector.hasIntersection()) {

		        crossings ++;

		      }

//		      if (((p1.y > (p.y - snapTolerance)) && (p2.y <= (p.y + snapTolerance))) ||

//		          ((p2.y > (p.y - snapTolerance)) && (p1.y <= (p.y) + snapTolerance))) {//si no se cumple, no pueden intersectar

//		        

//		    	double x1 = p1.x - p.x;

//		        double y1 = p1.y - p.y;

//		        double x2 = p2.x - p.x;

//		        double y2 = p2.y - p.y;

//		        /*

//		        *  segment straddles x axis, so compute intersection with x-axis.

//		         */

//		        double xInt = RobustDeterminant.signOfDet2x2(x1, y1, x2, y2) / (y2 - y1);

//		        //xsave = xInt;

//		        /*

//		        *  crosses ray if strictly positive intersection.

//		         */

//		        if (xInt > 0.0) {

//		          crossings++;

//		        }

//		      }

		    }

		    /*

		     *  p is inside if number of crossings is odd.

		     */

		    if ((crossings % 2) == 1) {

		      return true;

		    }

		    else {

		      return false;

		    }

		  }

	  /**

	   * Computes the orientation of a point q to the directed line segment p1-p2.

	   * The orientation of a point relative to a directed line segment indicates

	   * which way you turn to get to q after travelling from p1 to p2.

	   *

	   * @return 1 if q is counter-clockwise from p1-p2

	   * @return -1 if q is clockwise from p1-p2

	   * @return 0 if q is collinear with p1-p2

	   */

	  public static int computeOrientation(Coordinate p1, Coordinate p2, Coordinate q) {

	    return orientationIndex(p1, p2, q);

	  }

	  /**

	   * Returns the index of the direction of the point <code>q</code>

	   * relative to a

	   * vector specified by <code>p1-p2</code>.

	   *

	   * @param p1 the origin point of the vector

	   * @param p2 the final point of the vector

	   * @param q the point to compute the direction to

	   *

	   * @return 1 if q is counter-clockwise (left) from p1-p2

	   * @return -1 if q is clockwise (right) from p1-p2

	   * @return 0 if q is collinear with p1-p2

	   */

	  public static int orientationIndex(Coordinate p1, Coordinate p2, Coordinate q) {

	    // travelling along p1->p2, turn counter clockwise to get to q return 1,

	    // travelling along p1->p2, turn clockwise to get to q return -1,

	    // p1, p2 and q are colinear return 0.

	    double dx1 = p2.x - p1.x;

	    double dy1 = p2.y - p1.y;

	    double dx2 = q.x - p2.x;

	    double dy2 = q.y - p2.y;

	    return RobustDeterminant.signOfDet2x2(dx1, dy1, dx2, dy2);

	  }

	  public static boolean snapEquals2D(Coordinate a, Coordinate b, double snapTolerance){

		  return a.distance(b) <= snapTolerance;

	  }

}

/*

 * Created on 06-oct-2006

 *

 * gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

/* CVS MESSAGES:

*

* $Id: SnapSimplePointInAreaLocator.java 10627 2007-03-06 17:10:21Z caballero $

* $Log$

* Revision 1.2  2007-03-06 17:08:55  caballero

* Exceptions

*

* Revision 1.1  2006/12/04 19:29:31  azabala

* *** empty log message ***

*

* Revision 1.1  2006/10/17 18:25:53  azabala

* *** empty log message ***

*

* Revision 1.1  2006/10/09 19:10:56  azabala

* First version in CVS

*

*

*/

package com.vividsolutions.jts.algorithms;

import java.util.Iterator;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryCollection;

import com.vividsolutions.jts.geom.GeometryCollectionIterator;

import com.vividsolutions.jts.geom.LinearRing;

import com.vividsolutions.jts.geom.Location;

import com.vividsolutions.jts.geom.Polygon;

public class SnapSimplePointInAreaLocator extends

		com.vividsolutions.jts.algorithm.SimplePointInAreaLocator {

	 public static int locate(Coordinate p, Geometry geom, double snapTolerance)

	  {

	    if (geom.isEmpty()) return Location.EXTERIOR;

	    if (containsPoint(p, geom, snapTolerance))

	      return Location.INTERIOR;

	    return Location.EXTERIOR;

	  }

	  private static boolean containsPoint(Coordinate p, Geometry geom, double snapTolerance)

	  {

	    if (geom instanceof Polygon) {

	      return containsPointInPolygon(p, (Polygon) geom);

	    }

	    else if (geom instanceof GeometryCollection) {

	      Iterator geomi = new GeometryCollectionIterator((GeometryCollection) geom);

	      while (geomi.hasNext()) {

	        Geometry g2 = (Geometry) geomi.next();

	        if (g2 != geom)

	          if (containsPoint(p, g2, snapTolerance))

	            return true;

	      }

	    }

	    return false;

	  }

	  public static boolean containsPointInPolygon(Coordinate p, Polygon poly, double snapTolerance)

	  {

	    if (poly.isEmpty()) return false;

	    LinearRing shell = (LinearRing) poly.getExteriorRing();

	    if (! SnapCGAlgorithms.isPointInRing(p, shell.getCoordinates(), snapTolerance)) return false;

	    // now test if the point lies in or on the holes

	    for (int i = 0; i < poly.getNumInteriorRing(); i++) {

	      LinearRing hole = (LinearRing) poly.getInteriorRingN(i);

	      if (SnapCGAlgorithms.isPointInRing(p, hole.getCoordinates(), snapTolerance)) return false;

	    }

	    return true;

	  }