Application: gvSIG desktop

/*

 * Created on 09-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$

* $Log$

* Revision 1.1  2006-12-04 19:30:23  azabala

* *** empty log message ***

*

* Revision 1.2  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.operation.overlay;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

import com.vividsolutions.jts.algorithm.CGAlgorithms;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Envelope;

import com.vividsolutions.jts.geom.GeometryFactory;

import com.vividsolutions.jts.geom.LinearRing;

import com.vividsolutions.jts.geom.Polygon;

import com.vividsolutions.jts.geomgraph.DirectedEdge;

import com.vividsolutions.jts.geomgraph.EdgeRing;

import com.vividsolutions.jts.geomgraph.SnappingPlanarGraph;

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

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

import com.vividsolutions.jts.util.Assert;

public class SnapPolygonBuilder extends PolygonBuilder {

	 private GeometryFactory geometryFactory;

	  private CGAlgorithms cga;

	  //private List dirEdgeList;

	  //private NodeMap nodes;

	  private List shellList        = new ArrayList();

	  public SnapPolygonBuilder(GeometryFactory geometryFactory, 

			  CGAlgorithms cga)

	  {

		super(geometryFactory, cga);

	    this.geometryFactory = geometryFactory;

	    this.cga = cga;

	  }

	  /**

	   * Add a complete graph.

	   * The graph is assumed to contain one or more polygons,

	   * possibly with holes.

	   */

	  public void add(SnappingPlanarGraph graph)

	  {

	    add(graph.getEdgeEnds(), graph.getNodes());

	  }

	  /**

	   * Add a set of edges and nodes, which form a graph.

	   * The graph is assumed to contain one or more polygons,

	   * possibly with holes.

	   */

	  public void add(Collection dirEdges, Collection nodes)

	  {

		SnappingPlanarGraph.linkResultDirectedEdges(nodes);

	    List maxEdgeRings = buildMaximalEdgeRings(dirEdges);

	    List freeHoleList = new ArrayList();

	    List edgeRings = buildMinimalEdgeRings(maxEdgeRings, shellList, freeHoleList);

	    sortShellsAndHoles(edgeRings, shellList, freeHoleList);

	    placeFreeHoles(shellList, freeHoleList);

	  }

	  public List getPolygons()

	  {

	    List resultPolyList = computePolygons(shellList);

	    return resultPolyList;

	  }

	  /**

	   * for all DirectedEdges in result, form them into MaximalEdgeRings

	   */

	  private List buildMaximalEdgeRings(Collection dirEdges)

	  {

	    List maxEdgeRings     = new ArrayList();

	    for (Iterator it = dirEdges.iterator(); it.hasNext(); ) {

	      DirectedEdge de = (DirectedEdge) it.next();

	      if (de.isInResult() && de.getLabel().isArea() ) {

	        // if this edge has not yet been processed

	        if (de.getEdgeRing() == null) {

	          MaximalEdgeRing er = new MaximalEdgeRing(de, geometryFactory, cga);

	          maxEdgeRings.add(er);

	          er.setInResult();

//	System.out.println("max node degree = " + er.getMaxDegree());

	        }

	      }

	    }

	    return maxEdgeRings;

	  }

	  private List buildMinimalEdgeRings(List maxEdgeRings, List shellList, List freeHoleList)

	  {

	    List edgeRings = new ArrayList();

	    for (Iterator it = maxEdgeRings.iterator(); it.hasNext(); ) {

	      MaximalEdgeRing er = (MaximalEdgeRing) it.next();

	      if (er.getMaxNodeDegree() > 2) {

	        er.linkDirectedEdgesForMinimalEdgeRings();

	        List minEdgeRings = er.buildMinimalRings();

	        // at this point we can go ahead and attempt to place holes, if this EdgeRing is a polygon

	        EdgeRing shell = findShell(minEdgeRings);

	        if (shell != null) {

	          placePolygonHoles(shell, minEdgeRings);

	          shellList.add(shell);

	        }

	        else {

	          freeHoleList.addAll(minEdgeRings);

	        }

	      }

	      else {

	        edgeRings.add(er);

	      }

	    }

	    return edgeRings;

	  }

	  /**

	   * This method takes a list of MinimalEdgeRings derived from a MaximalEdgeRing,

	   * and tests whether they form a Polygon.  This is the case if there is a single shell

	   * in the list.  In this case the shell is returned.

	   * The other possibility is that they are a series of connected holes, in which case

	   * no shell is returned.

	   *

	   * @return the shell EdgeRing, if there is one

	   * @return null, if all the rings are holes

	   */

	  private EdgeRing findShell(List minEdgeRings)

	  {

	    int shellCount = 0;

	    EdgeRing shell = null;

	    for (Iterator it = minEdgeRings.iterator(); it.hasNext(); ) {

	      EdgeRing er = (MinimalEdgeRing) it.next();

	      if (! er.isHole()) {

	        shell = er;

	        shellCount++;

	      }

	    }

	    Assert.isTrue(shellCount <= 1, "found two shells in MinimalEdgeRing list");

	    return shell;

	  }

	  /**

	   * This method assigns the holes for a Polygon (formed from a list of

	   * MinimalEdgeRings) to its shell.

	   * Determining the holes for a MinimalEdgeRing polygon serves two purposes:

	   * <ul>

	   * <li>it is faster than using a point-in-polygon check later on.

	   * <li>it ensures correctness, since if the PIP test was used the point

	   * chosen might lie on the shell, which might return an incorrect result from the

	   * PIP test

	   * </ul>

	   */

	  private void placePolygonHoles(EdgeRing shell, List minEdgeRings)

	  {

	    for (Iterator it = minEdgeRings.iterator(); it.hasNext(); ) {

	      MinimalEdgeRing er = (MinimalEdgeRing) it.next();

	      if (er.isHole()) {

	        er.setShell(shell);

	      }

	    }

	  }

	  /**

	   * For all rings in the input list,

	   * determine whether the ring is a shell or a hole

	   * and add it to the appropriate list.

	   * Due to the way the DirectedEdges were linked,

	   * a ring is a shell if it is oriented CW, a hole otherwise.

	   */

	  private void sortShellsAndHoles(List edgeRings, List shellList, List freeHoleList)

	  {

	    for (Iterator it = edgeRings.iterator(); it.hasNext(); ) {

	      EdgeRing er = (EdgeRing) it.next();

//	      er.setInResult();

	      if (er.isHole() ) {

	        freeHoleList.add(er);

	      }

	      else {

	        shellList.add(er);

	      }

	    }

	  }

	  /**

	   * This method determines finds a containing shell for all holes

	   * which have not yet been assigned to a shell.

	   * These "free" holes should

	   * all be <b>properly</b> contained in their parent shells, so it is safe to use the

	   * <code>findEdgeRingContaining</code> method.

	   * (This is the case because any holes which are NOT

	   * properly contained (i.e. are connected to their

	   * parent shell) would have formed part of a MaximalEdgeRing

	   * and been handled in a previous step).

	   */

	  private void placeFreeHoles(List shellList, List freeHoleList)

	  {

	    for (Iterator it = freeHoleList.iterator(); it.hasNext(); ) {

	      EdgeRing hole = (EdgeRing) it.next();

	      // only place this hole if it doesn't yet have a shell

	      if (hole.getShell() == null) {

	        EdgeRing shell = findEdgeRingContaining(hole, shellList);

	        Assert.isTrue(shell != null, "unable to assign hole to a shell");

	        hole.setShell(shell);

	      }

	    }

	  }

	  /**

	   * Find the innermost enclosing shell EdgeRing containing the argument EdgeRing, if any.

	   * The innermost enclosing ring is the <i>smallest</i> enclosing ring.

	   * The algorithm used depends on the fact that:

	   * <br>

	   *  ring A contains ring B iff envelope(ring A) contains envelope(ring B)

	   * <br>

	   * This routine is only safe to use if the chosen point of the hole

	   * is known to be properly contained in a shell

	   * (which is guaranteed to be the case if the hole does not touch its shell)

	   *

	   * @return containing EdgeRing, if there is one

	   * @return null if no containing EdgeRing is found

	   */

	  //TODO Estudiar como meter el snapping

	  private EdgeRing findEdgeRingContaining(EdgeRing testEr, List shellList)

	  {

	    LinearRing testRing = testEr.getLinearRing();

	    Envelope testEnv = testRing.getEnvelopeInternal();

	    Coordinate testPt = testRing.getCoordinateN(0);

	    EdgeRing minShell = null;

	    Envelope minEnv = null;

	    for (Iterator it = shellList.iterator(); it.hasNext(); ) {

	      EdgeRing tryShell = (EdgeRing) it.next();

	      LinearRing tryRing = tryShell.getLinearRing();

	      Envelope tryEnv = tryRing.getEnvelopeInternal();

	      if (minShell != null) minEnv = minShell.getLinearRing().getEnvelopeInternal();

	      boolean isContained = false;

	      if (tryEnv.contains(testEnv)

	          && CGAlgorithms.isPointInRing(testPt, tryRing.getCoordinates()) )

	        isContained = true;

	      // check if this new containing ring is smaller than the current minimum ring

	      if (isContained) {

	        if (minShell == null

	            || minEnv.contains(tryEnv)) {

	          minShell = tryShell;

	        }

	      }

	    }

	    return minShell;

	  }

	  private List computePolygons(List shellList)

	  {

	    List resultPolyList   = new ArrayList();

	    // add Polygons for all shells

	    for (Iterator it = shellList.iterator(); it.hasNext(); ) {

	      EdgeRing er = (EdgeRing) it.next();

	      Polygon poly = er.toPolygon(geometryFactory);

	      resultPolyList.add(poly);

	    }

	    return resultPolyList;

	  }

	  /**

	   * Checks the current set of shells (with their associated holes) to

	   * see if any of them contain the point.

	   */

	  //TODO METER SNAPPING

	  public boolean containsPoint(Coordinate p)

	  {

	    for (Iterator it = shellList.iterator(); it.hasNext(); ) {

	      EdgeRing er = (EdgeRing) it.next();

	      if (er.containsPoint(p))

	       return true;

	    }

	    return false;

	  }

}

/*

 * Created on 12-sep-2006 by azabala

 *

 */

package com.vividsolutions.jts.operation.overlay;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import com.vividsolutions.jts.algorithm.CGAlgorithms;

import com.vividsolutions.jts.algorithm.LineIntersector;

import com.vividsolutions.jts.algorithm.PointLocator;

import com.vividsolutions.jts.algorithms.SnapPointLocator;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryFactory;

import com.vividsolutions.jts.geom.Location;

import com.vividsolutions.jts.geom.Point;

import com.vividsolutions.jts.geomgraph.Depth;

import com.vividsolutions.jts.geomgraph.DirectedEdge;

import com.vividsolutions.jts.geomgraph.DirectedEdgeStar;

import com.vividsolutions.jts.geomgraph.Edge;

import com.vividsolutions.jts.geomgraph.EdgeList;

import com.vividsolutions.jts.geomgraph.Label;

import com.vividsolutions.jts.geomgraph.Node;

import com.vividsolutions.jts.geomgraph.PlanarGraph;

import com.vividsolutions.jts.geomgraph.Position;

import com.vividsolutions.jts.geomgraph.SnapEdgeList;

import com.vividsolutions.jts.geomgraph.SnappingGeometryGraph;

import com.vividsolutions.jts.geomgraph.SnappingPlanarGraph;

import com.vividsolutions.jts.io.ParseException;

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

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

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

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

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

import com.vividsolutions.jts.util.Assert;

/**

 * TODO 

 * El codigo esta lleno de coordinateA.distance(coordinateB)

 * <= snapTolerance;

 * 

 * CAMBIAR POR SnapCoordinate, de forma que equals haga

 * esta comprobacin

 * 

 * 

 */

public class SnappingOverlayOperation extends OverlayOp {

	protected final SnapPointLocator ptLocator = new SnapPointLocator();

	protected GeometryFactory geomFact;

	protected Geometry resultGeom;

	protected LineIntersector li;

	protected double snapTolerance;

	/*Planar graph of the overlay operation*/

	protected SnappingPlanarGraph graph;

	/*Geometry graph of each individual geometry*/

	protected SnappingGeometryGraph[] arg;

	/*It saves all the new edges resulting from intersections of

	 * edges of geometries A and B. It is a temporal repository, before

	 * to save them in SnappingPlanarGraph*/

	protected SnapEdgeList edgeList = null;

/*

 * El resultado de una operacion de overlay puede contener

 * puntos, lineas y poligonos.

 * */	

	protected List resultPolyList = new ArrayList();

	protected List resultLineList = new ArrayList();

	protected List resultPointList = new ArrayList();

	public static Geometry overlayOp(Geometry geom0, Geometry geom1,

			int opCode, double tolerance) {

		SnappingOverlayOperation gov = new SnappingOverlayOperation(geom0,

				geom1, tolerance);

		Geometry geomOv = gov.getResultGeometry(opCode);

		return geomOv;

	}

	public SnappingOverlayOperation(Geometry g0, Geometry g1, double tolerance) {

		super(g0, g1);

		graph = new SnappingPlanarGraph(new OverlayNodeFactory(), tolerance);

		arg = new SnappingGeometryGraph[2];

		arg[0] = new SnappingGeometryGraph(tolerance, 0, g0);

		arg[1] = new SnappingGeometryGraph(tolerance, 1, g1);

		geomFact = g0.getFactory();

		li = new SnapLineIntersector(tolerance);

		edgeList = new SnapEdgeList(tolerance);

		this.snapTolerance = tolerance;

	}

	public Geometry getResultGeometry(int funcCode) {

		computeOverlay(funcCode);

		return resultGeom;

	}

	public PlanarGraph getGraph() {

		return graph;

	}

	private boolean isReused = false;

	/**

	 * Metodo de utilidad cuando vayamos a intersectar la geometria

	 * g1 con varias geometrias (g2, g3, g4, .... , etc.)

	 * 

	 * Los calculos basicos no se repiten para g1

	 * 

	 * */

	public void setSecondGeometry(Geometry geometry){

		Geometry g0 = arg[0].getGeometry();

		 if (g0.getPrecisionModel().compareTo(geometry.getPrecisionModel()) >= 0)

		      setComputationPrecision(g0.getPrecisionModel());

		    else

		      setComputationPrecision(geometry.getPrecisionModel());

		graph = new SnappingPlanarGraph(new OverlayNodeFactory(), snapTolerance);

		/*

		 *TODO

		 *Deberiamos borrar todos los nodos del GeometryGraph,

		 *o solo las intersecciones?????

		 *De todos modos, aunque borrasemos los nodos, getBoundaryNodes

		 *devolveria nodos cacheados 

		 * 

		 * TODO REVISAR

		 * */

		arg[0].clearIntersections();

		arg[1] = new SnappingGeometryGraph(snapTolerance, 1, geometry);

		geomFact = g0.getFactory();

		edgeList = new SnapEdgeList(snapTolerance);

		resultPolyList.clear();

		resultLineList.clear();

		resultPointList.clear();

		resultGeom = null;

		isReused = true;

	}

	/*

	 * ************************************************************

	 * METODO PRINCIPAL

	 * ************************************************************

	 * */

	private void computeOverlay(int opCode) {

		/*

		 * Se copian los NODOS de las dos geometrias. 

		 * ESTO ES IMPORTANTE, PUES:

		 * a) un punto origina un nodo.

		 * b) una linea origina dos nodos

		 * c) un poligono origina un nodo.

		 * 

		 * */

		copyPoints(0);

		copyPoints(1);

		if(! isReused) //esto solo se hace si no se ha calculado ya

			arg[0].computeSelfNodes(li, false);

		arg[1].computeSelfNodes(li, false);

		/*

		 * Calcula las intersecciones.

		 * Se supone que daran lugar a Nodes, ?NO?

		 * Como resultado, cada Edge guardar? en sus EdgeIntersectionList

		 * las intersecciones que hay en sus segmentos (EdgeIntersection).

		 * 

		 * Estas intersecciones se representan por:

		 * -segmento del edge en que ocurren.

		 * -coordenada

		 * -distancia al primer vertice del segmento

		 * 

		 * ?OJO? COMO RESULTADO DE ESTO NO SE GENERAN EJES NUEVOS.

		 * PARA HACER SNAP EN LAS INTERSECCIONES TENDRIAMOS QUE RETOCAR LA 

		 * CLASE EDGEINTERSECTIONLIST

		 * 

		 * */

		arg[0].computeEdgeIntersections(arg[1], li, true);

		/*

		 * Ahora lo que se hace es: para cada Edge del grafo,

		 * se parte (en funci?n de sus intersecciones) y se a?aden

		 * los Edges fragmentados a la colecci?n baseSplitEdges

		 * 

		 * */

		List baseSplitEdges = new ArrayList();

		arg[0].computeSplitEdges(baseSplitEdges);

		//TODO Quizas la clave est? tambien en la 2? geometria

		arg[1].computeSplitEdges(baseSplitEdges);

		/*

		 * Edges resulting of A intersection B, that are in baseSplitEdges 

		 * Collection, are saved in EdgeList.

		 * ?OJO? Si aparecen ejes repetidos, no se duplican (pero si 

		 * que se cambia su etiqueta)

		 * */

		//Se copian los nuevos Edges generados en EdgeList

		insertUniqueEdges(baseSplitEdges);

		/*Se etiquetan*/

		computeLabelsFromDepths();

		/*

		 * Quita los Edges que hayan sufrido colapso dimensional

		 * (en la documentac?on de JTS viene algo de esto)

		 * */

		replaceCollapsedEdges();

        /*

         * Finalmente, se a?ade al SnappingPlanarGraph resultado los Edges

         * calculados como fruto de las intersecciones (contenidos en EdgeList).

         * 

         * Aqu? se hace algo muy importante tambi?n: se a?aden nuevos nodos

         * al grafo (correspondientes con los extremos de los nuevos Edge

         * que no estuvieran ya en el grafo)

         * 

         * */

		graph.addEdges(edgeList.getEdges());

		computeLabelling();

		labelIncompleteNodes();

		/**

		 * The ordering of building the result Geometries is important. Areas

		 * must be built before lines, which must be built before points. This

		 * is so that lines which are covered by areas are not included

		 * explicitly, and similarly for points.

		 */

		findResultAreaEdges(opCode);

		cancelDuplicateResultEdges();

		//TODO Todos los builders deber?n usar los metodos snap de locator

		SnapPolygonBuilder polyBuilder = new SnapPolygonBuilder(geomFact, cga);

		polyBuilder.add(graph);

		resultPolyList = polyBuilder.getPolygons();

		LineBuilder lineBuilder = new LineBuilder(this, geomFact, ptLocator);

		resultLineList = lineBuilder.build(opCode);

		PointBuilder pointBuilder = new PointBuilder(this, geomFact, ptLocator){

			 public List build(int opCode)

			  {

				 for (Iterator nodeit = getGraph().getNodes().iterator(); nodeit.hasNext(); ) {

				      Node n = (Node) nodeit.next();

				      // filter out nodes which are known to be in the result

				      if (n.isInResult())

				        continue;

				      // if an incident edge is in the result, then the node coordinate is included already

				      if (n.isIncidentEdgeInResult())

				        continue;

				      if (n.getEdges().getDegree() == 0 || opCode == OverlayOp.INTERSECTION) {

				        /**

				         * For nodes on edges, only INTERSECTION can result in edge nodes being included even

				         * if none of their incident edges are included

				         */

				          Label label = n.getLabel();

				          if (SnappingOverlayOperation.checkLabelLocation(label.getLocation(0),

				        		  label.getLocation(1), opCode)) {

				            filterCoveredNodeToPoint(n);

				          }

				      }

				 }

			    return resultPointList;

			  }

			 private void filterCoveredNodeToPoint(Node n)

			  {

			    Coordinate coord = n.getCoordinate();

			    if (! isCoveredByLA(coord)) {

			      Point pt = geomFact.createPoint(coord);

			      resultPointList.add(pt);

			    }

			  }	

		};

		resultPointList = pointBuilder.build(opCode);

		// gather the results from all calculations into a single Geometry for

		// the result set

		resultGeom = computeGeometry(resultPointList, resultLineList,

				resultPolyList);

	}

	 /**

	   * This method will handle arguments of Location.NONE correctly

	   *

	   * @return true if the locations correspond to the opCode

	   */

	  public static boolean isResultOfOp(int loc0, int loc1, int opCode)

	  {

	    if (loc0 == Location.BOUNDARY) loc0 = Location.INTERIOR;

	    if (loc1 == Location.BOUNDARY) loc1 = Location.INTERIOR;

	    switch (opCode) {

	    case INTERSECTION:

	      return loc0 == Location.INTERIOR

	          && loc1 == Location.INTERIOR;

	    case UNION:

	      return loc0 == Location.INTERIOR

	          || loc1 == Location.INTERIOR;

	    case DIFFERENCE:

	      return loc0 == Location.INTERIOR

	          && loc1 != Location.INTERIOR;

	    case SYMDIFFERENCE:

	      return   (     loc0 == Location.INTERIOR &&  loc1 != Location.INTERIOR)

	            || (     loc0 != Location.INTERIOR &&  loc1 == Location.INTERIOR);

	    }

	    return false;

	  }

	  public static boolean isResultOfOp(Label label, int opCode)

	  {

	    int loc0 = label.getLocation(0);

	    int loc1 = label.getLocation(1);

	    return isResultOfOp(loc0, loc1, opCode);

	  }

	//TODO Quitar esto de aqui

	 public static boolean checkLabelLocation(int loc0, int loc1, int opCode)

	  {

	    if (loc0 == Location.BOUNDARY) loc0 = Location.INTERIOR;

	    if (loc1 == Location.BOUNDARY) loc1 = Location.INTERIOR;

	    switch (opCode) {

	    case INTERSECTION:

	      return loc0 == Location.INTERIOR

	          && loc1 == Location.INTERIOR;

	    case UNION:

	      return loc0 == Location.INTERIOR

	          || loc1 == Location.INTERIOR;

	    case DIFFERENCE:

	      return loc0 == Location.INTERIOR

	          && loc1 != Location.INTERIOR;

	    case SYMDIFFERENCE:

	      return   (     loc0 == Location.INTERIOR &&  loc1 != Location.INTERIOR)

	            || (     loc0 != Location.INTERIOR &&  loc1 == Location.INTERIOR);

	    }

	    return false;

	  }

	private void insertUniqueEdges(List edges) {

		for (Iterator i = edges.iterator(); i.hasNext();) {

			Edge e = (Edge) i.next();

			insertUniqueEdge(e);

		}

	}

	/**

	 * Insert an edge from one of the noded input graphs. Checks edges that are

	 * inserted to see if an identical edge already exists. If so, the edge is

	 * not inserted, but its label is merged with the existing edge.

	 */

	protected void insertUniqueEdge(Edge e) {

		//TODO Crear una clase SnapEdge y SnapEdgeList puede ser necesario???

		//creo que si pq SnapEdgeList mantiene una cache que no considera snap

		Edge existingEdge = edgeList.findEqualEdge(e);

		// If an identical edge already exists, simply update its label

		if (existingEdge != null) {

			Label existingLabel = existingEdge.getLabel();

			Label labelToMerge = e.getLabel();

			// check if new edge is in reverse direction to existing edge

			// if so, must flip the label before merging it

			if (!existingEdge.isPointwiseEqual(e)) {

				labelToMerge = new Label(e.getLabel());

				labelToMerge.flip();

			}

			Depth depth = existingEdge.getDepth();

			// if this is the first duplicate found for this edge, initialize

			// the depths

			if (depth.isNull()) {

				depth.add(existingLabel);

			}

			depth.add(labelToMerge);

			existingLabel.merge(labelToMerge);

		} else { // no matching existing edge was found

			// add this new edge to the list of edges in this graph

			edgeList.add(e);

		}

	}

	/**

	 * Update the labels for edges according to their depths. For each edge, the

	 * depths are first normalized. Then, if the depths for the edge are equal,

	 * this edge must have collapsed into a line edge. If the depths are not

	 * equal, update the label with the locations corresponding to the depths

	 * (i.e. a depth of 0 corresponds to a Location of EXTERIOR, a depth of 1

	 * corresponds to INTERIOR)

	 */

	private void computeLabelsFromDepths() {

		for (Iterator it = edgeList.iterator(); it.hasNext();) {

			Edge e = (Edge) it.next();

			Label lbl = e.getLabel();

			Depth depth = e.getDepth();

			/*

			 * Only check edges for which there were duplicates, since these are

			 * the only ones which might be the result of dimensional collapses.

			 */

			if (!depth.isNull()) {

				depth.normalize();

				for (int i = 0; i < 2; i++) {

					if (!lbl.isNull(i) && lbl.isArea() && !depth.isNull(i)) {

						/**

						 * if the depths are equal, this edge is the result of

						 * the dimensional collapse of two or more edges. It has

						 * the same location on both sides of the edge, so it

						 * has collapsed to a line.

						 */

						if (depth.getDelta(i) == 0) {

							lbl.toLine(i);

						} else {

							/**

							 * This edge may be the result of a dimensional

							 * collapse, but it still has different locations on

							 * both sides. The label of the edge must be updated

							 * to reflect the resultant side locations indicated

							 * by the depth values.

							 */

							Assert

									.isTrue(!depth.isNull(i, Position.LEFT),

											"depth of LEFT side has not been initialized");

							lbl.setLocation(i, Position.LEFT, depth

									.getLocation(i, Position.LEFT));

							Assert

									.isTrue(!depth.isNull(i, Position.RIGHT),

											"depth of RIGHT side has not been initialized");

							lbl.setLocation(i, Position.RIGHT, depth

									.getLocation(i, Position.RIGHT));

						}

					}

				}

			}

		}

	}

	/**

	 * If edges which have undergone dimensional collapse are found, replace

	 * them with a new edge which is a L edge

	 */

	private void replaceCollapsedEdges() {

		List newEdges = new ArrayList();

		for (Iterator it = edgeList.iterator(); it.hasNext();) {

			Edge e = (Edge) it.next();

			if (e.isCollapsed()) {

				//	Debug.print(e);

				it.remove();

				newEdges.add(e.getCollapsedEdge());

			}

		}

		edgeList.addAll(newEdges);

	}

	/**

	 * Copy all nodes from an arg geometry into this graph. The node label in

	 * the arg geometry overrides any previously computed label for that

	 * argIndex. (E.g. a node may be an intersection node with a previously

	 * computed label of BOUNDARY, but in the original arg Geometry it is

	 * actually in the interior due to the Boundary Determination Rule)

	 */

	private void copyPoints(int argIndex) {

		for (Iterator i = arg[argIndex].getNodeIterator(); i.hasNext();) {

			Node graphNode = (Node) i.next();

			Node newNode = graph.addNode(graphNode.getCoordinate());

			newNode.setLabel(argIndex, graphNode.getLabel().getLocation(

					argIndex));

		}

	}

	/**

	 * Compute initial labelling for all DirectedEdges at each node. In this

	 * step, DirectedEdges will acquire a complete labelling (i.e. one with

	 * labels for both Geometries) only if they are incident on a node which has

	 * edges for both Geometries

	 */

	private void computeLabelling() {

		for (Iterator nodeit = graph.getNodes().iterator(); nodeit.hasNext();) {

			Node node = (Node) nodeit.next();

			node.getEdges().computeLabelling(arg);

		}

		mergeSymLabels();

		updateNodeLabelling();

	}

	/**

	 * For nodes which have edges from only one Geometry incident on them, the

	 * previous step will have left their dirEdges with no labelling for the

	 * other Geometry. However, the sym dirEdge may have a labelling for the

	 * other Geometry, so merge the two labels.

	 */

	private void mergeSymLabels() {

		for (Iterator nodeit = graph.getNodes().iterator(); nodeit.hasNext();) {

			Node node = (Node) nodeit.next();

			((DirectedEdgeStar) node.getEdges()).mergeSymLabels();

		}

	}

	private void updateNodeLabelling() {

		// update the labels for nodes

		// The label for a node is updated from the edges incident on it

		// (Note that a node may have already been labelled

		// because it is a point in one of the input geometries)

		for (Iterator nodeit = graph.getNodes().iterator(); nodeit.hasNext();) {

			Node node = (Node) nodeit.next();

			Label lbl = ((DirectedEdgeStar) node.getEdges()).getLabel();

			Label otherLbl = node.getLabel();

			otherLbl.merge(lbl);

		}

	}

	/**

	 * Incomplete nodes are nodes whose labels are incomplete. (e.g. the

	 * location for one Geometry is null). These are either isolated nodes, or

	 * nodes which have edges from only a single Geometry incident on them.

	 * 

	 * Isolated nodes are found because nodes in one graph which don't intersect

	 * nodes in the other are not completely labelled by the initial process of

	 * adding nodes to the nodeList. To complete the labelling we need to check

	 * for nodes that lie in the interior of edges, and in the interior of

	 * areas.

	 * <p>

	 * When each node labelling is completed, the labelling of the incident

	 * edges is updated, to complete their labelling as well.

	 */

	private void labelIncompleteNodes() {

		for (Iterator ni = graph.getNodes().iterator(); ni.hasNext();) {

			Node n = (Node) ni.next();

			Label label = n.getLabel();

			if (n.isIsolated()) {

				if (label.isNull(0))

					labelIncompleteNode(n, 0);

				else

					labelIncompleteNode(n, 1);

			}

			// now update the labelling for the DirectedEdges incident on this

			// node

			((DirectedEdgeStar) n.getEdges()).updateLabelling(label);

		}

	}

	/**

	 * Label an isolated node with its relationship to the target geometry.

	 */

	private void labelIncompleteNode(Node n, int targetIndex) {

	    //TODO Ver si el pointLocator deberia snapear

		Coordinate coord = n.getCoordinate();

	    Geometry geom = arg[targetIndex].getGeometry();

		int loc = ptLocator.locate(coord, geom, snapTolerance);

		n.getLabel().setLocation(targetIndex, loc);

	}

	/**

	 * Find all edges whose label indicates that they are in the result area(s),

	 * according to the operation being performed. Since we want polygon shells

	 * to be oriented CW, choose dirEdges with the interior of the result on the

	 * RHS. Mark them as being in the result. Interior Area edges are the result

	 * of dimensional collapses. They do not form part of the result area

	 * boundary.

	 */

	private void findResultAreaEdges(int opCode) {

		for (Iterator it = graph.getEdgeEnds().iterator(); it.hasNext();) {

			DirectedEdge de = (DirectedEdge) it.next();

			// mark all dirEdges with the appropriate label

			Label label = de.getLabel();

			if (label.isArea()

					&& !de.isInteriorAreaEdge()

					&& isResultOfOp(label.getLocation(0, Position.RIGHT), label

							.getLocation(1, Position.RIGHT), opCode)) {

				de.setInResult(true);

				//	Debug.print("in result "); Debug.println(de);

			}

		}

	}

	/**

	 * If both a dirEdge and its sym are marked as being in the result, cancel

	 * them out.

	 */

	private void cancelDuplicateResultEdges() {

		// remove any dirEdges whose sym is also included

		// (they "cancel each other out")

		for (Iterator it = graph.getEdgeEnds().iterator(); it.hasNext();) {

			DirectedEdge de = (DirectedEdge) it.next();

			DirectedEdge sym = de.getSym();

			if (de.isInResult() && sym.isInResult()) {

				de.setInResult(false);

				sym.setInResult(false);

				//	Debug.print("cancelled "); Debug.println(de);

				// Debug.println(sym);

			}

		}

	}

	/**

	 * This method is used to decide if a point node should be included in the

	 * result or not.

	 * 

	 * @return true if the coord point is covered by a result Line or Area

	 *         geometry

	 */

	public boolean isCoveredByLA(Coordinate coord) {

		if (isCovered(coord, resultLineList))

			return true;

		if (isCovered(coord, resultPolyList))

			return true;

		return false;

	}

	/**

	 * This method is used to decide if an L edge should be included in the

	 * result or not.

	 * 

	 * @return true if the coord point is covered by a result Area geometry

	 */

	public boolean isCoveredByA(Coordinate coord) {

		if (isCovered(coord, resultPolyList))

			return true;

		return false;

	}

	/**

	 * @return true if the coord is located in the interior or boundary of a

	 *         geometry in the list.

	 */

	private boolean isCovered(Coordinate coord, List geomList) {

		for (Iterator it = geomList.iterator(); it.hasNext();) {

			Geometry geom = (Geometry) it.next();

			int loc = ptLocator.locate(coord, geom, snapTolerance);

			if (loc != Location.EXTERIOR)

				return true;

		}

		return false;

	}

	private Geometry computeGeometry(List resultPointList, List resultLineList,

			List resultPolyList) {

		List geomList = new ArrayList();

		// element geometries of the result are always in the order P,L,A

		geomList.addAll(resultPointList);

		geomList.addAll(resultLineList);

		geomList.addAll(resultPolyList);

		// build the most specific geometry possible

		return geomFact.buildGeometry(geomList);

	}

	public static void main(String[] args){

		GeometryFactory factory = new GeometryFactory();

		com.vividsolutions.jts.io.WKTReader reader = new com.vividsolutions.jts.io.WKTReader(factory);

		Geometry a, b, c, d;

		try {

			//Snap en un extremo y en un vertice intermedio

			a = reader.read("LINESTRING(0.001 0.001, 5.001 5.001)");

			b = reader.read("LINESTRING(2.1 -3, 0.0 -0.001, -2.22 4.88, 10.0 10.0, 5.002 5.002)");

			System.out.println(SnappingOverlayOperation.overlayOp(a, b, OverlayOp.INTERSECTION, 0.01));			

//			//snap mediante l?neas paralelas

			c = reader.read("LINESTRING(0 0, 5 0, 10 0.001)");

			d = reader.read("LINESTRING(0.001 0.01, 5.001 0.002, 10.001 0.002)");		

			long t0 = System.currentTimeMillis();

			System.out.println(SnappingOverlayOperation.overlayOp(c, d, OverlayOp.INTERSECTION, 0.1));		

			long t1 = System.currentTimeMillis();

			System.out.println(OverlayOp.overlayOp(c, d, OverlayOp.INTERSECTION));

			long t2 = System.currentTimeMillis();

			System.out.println("Con snap: "+(t1-t0)+" ms");

			System.out.println("Sin snap: "+(t2-t1)+" ms");

			d = reader.read("LINESTRING(0 0, 5 0, 10 0.001)");

			System.out.println(OverlayOp.overlayOp(c, d, OverlayOp.INTERSECTION));

			//lineas paralelas a una distancia superior a la de snap

			//(para comprobar el criterio de paralelismo en LineIntersector

			c = reader.read("LINESTRING(0 0, 5 0, 10 0.001)");

			d = reader.read("LINESTRING(0 0.11, 5 0.12, 10 0.14)");

			System.out.println(SnappingOverlayOperation.overlayOp(c, d, OverlayOp.INTERSECTION, 0.001));

//			

			c = reader.read("LINESTRING(1 0, 3 2)");

			d = reader.read("LINESTRING(3.05 2.01, 5 1.25, 0.25 1.75)");

			System.out.println(OverlayOp.overlayOp(c, d, OverlayOp.INTERSECTION));

			System.out.println((SnappingOverlayOperation.overlayOp(c, d, OverlayOp.INTERSECTION, 0.1)));

//			

//			

			d = reader.read("LINESTRING(3 2, 5 1.25, 0.25 1.75)");

			System.out.println(OverlayOp.overlayOp(c, d, OverlayOp.INTERSECTION));

			System.out.println((SnappingOverlayOperation.overlayOp(c, d, OverlayOp.INTERSECTION, 0.1)));

			//Que un pol?gono est? cerrado o no no es snap, sino regla topologica

			//TODO CON POLIGONOS EST? DANDO PROBLEMAS. HABRA QUE REVISAR LINEAS Y POLIGONOS

//			c = reader.read("POLYGON((0 0, 0 5, 5 5, 5 0,  0 0))");

//			d = reader.read("POLYGON((-0.01 0, 3 8, 6 6 ,  -0.01 0))");

			c = reader.read("POLYGON((5 0, 5 5, 10 5, 10 0,  5 0))");

			d = reader.read("POLYGON((4 3, 4.99 3.5, 10.01 3.5, 12 3,  4 3))");

			//REVISI?N TOPOLOGICA 

			/*

			 * Un aspecto esencial de la topologia en JTS es el etiquetado.

			 * Todo Eje del grafo asociado a un pol?gono tiene una etiqueta o Label, 

			 * con tres valores posibles para la izquierda, derecha y encima del poligono

			 * (EXTERIOR, BOUNDARY, INTERIOR)

			 * 

			 * Por tanto, si la orientaci?n no es la correcta, todo se va al traste

			 * (pues las cosas se invierten especularmente)

			 * */

			if(CGAlgorithms.isCCW(c.getCoordinates())){

				System.out.println("Anillo exterior de poligono en orden incorrecto");

			    System.out.println(c.toText());

				System.exit(-2);

			}

			if(CGAlgorithms.isCCW(d.getCoordinates())){

				System.out.println("Anillo exterior de poligono en orden incorrecto");

				   System.out.println(d.toText());

				System.exit(-2);

			}

			System.out.println((SnappingOverlayOperation.overlayOp(c, d, OverlayOp.INTERSECTION, 0.1)));

			Geometry pol1 = reader.read("POLYGON((0 0, -5 0, -10 5, 0 10,  10 5, 5 0, 0 0))");

			Geometry pol2 = reader.read("POLYGON((10.01 0, 5 5, 5 10, 10 10, 10.01 0))");

			System.out.println((SnappingOverlayOperation.overlayOp(pol1, pol2, OverlayOp.INTERSECTION, 0.1)));

			System.out.println((OverlayOp.overlayOp(pol1, pol2, OverlayOp.INTERSECTION)));

		} catch (ParseException e) {

			e.printStackTrace();

		}

	}

}

/*

 * Created on 03-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$

* $Log$

* Revision 1.1  2006-12-04 19:30:23  azabala

* *** empty log message ***

*

* Revision 1.1  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.3  2006/10/10 18:50:57  azabala

* *** empty log message ***

*

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

* First version in CVS

*

* Revision 1.1  2006/10/05 19:20:57  azabala

* first version in cvs

*

*

*/

package com.vividsolutions.jts.operation.overlay;

import junit.framework.TestCase;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryCollection;

import com.vividsolutions.jts.geom.GeometryFactory;

import com.vividsolutions.jts.geom.Polygon;

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

public class SnappingOverlayOperationTest extends TestCase {

	//test 1

	Geometry a,b;

	GeometryFactory factory ;

	com.vividsolutions.jts.io.WKTReader reader;

	//test 2

	Geometry c,d;

	//test 4

	Geometry f;

	//test 5

	Geometry g, h;

	//test 6

	Geometry pol1, pol2;

	public static void main(String[] args) {

	}

	public SnappingOverlayOperationTest(String name) {

		super(name);

	}

	protected void setUp() throws Exception {

		super.setUp();

		factory = new GeometryFactory();

		reader = new com.vividsolutions.jts.io.WKTReader(factory);

		a = reader.read("LINESTRING(0.001 0.001, 5.001 5.001)");

		b = reader.read("LINESTRING(2.1 -3, 0.0 -0.001, -2.22 4.88, 10.0 10.0, 5.002 5.002)");

		c = reader.read("LINESTRING(0 0, 5 0, 10 0.001)");

		d = reader.read("LINESTRING(0 0.01, 5 0.002, 10 0.002)");

		f = reader.read("LINESTRING(0 0.11, 5 0.12, 10 0.14)");

		g = reader.read("LINESTRING(1 0, 3 2)");

		h = reader.read("LINESTRING(3.05 2.01, 5 1.25, 0.25 1.75)");

		pol1 = reader.read("POLYGON((0 0, -5 0, -10 5, 0 10,  10 5, 5 0, 0 0))");

		pol2 = reader.read("POLYGON((10.01 0, 5 5, 5 10, 10 10, 10.01 0))");

	}

	protected void tearDown() throws Exception {

		super.tearDown();

		factory = null;

		reader = null;

		a = null;

		b = null;

	}

	/*

	 * Test method for 'com.iver.cit.gvsig.fmap.topology.SnappingOverlayOperation.SnappingOverlayOperation(Geometry, Geometry, double)'

	 */

	public void testSnappingOverlayOperation() {

		//test 1: dos lineas que intersectan en dos puntos: uno Nodo y otro vertice

		Geometry geom = SnappingOverlayOperation.overlayOp(a, b, 

									OverlayOp.INTERSECTION, 0.01);

		assertTrue(geom.toString().equals("MULTIPOINT (0.001 0.001, 5.001 5.001)"));

		//test 2: dos lineas paralelas separadas por una distancia inferior a la

		//de snap

		geom = SnappingOverlayOperation.overlayOp(c, d, 

				OverlayOp.INTERSECTION, 0.1);

		assertTrue(geom.toString().equals("MULTILINESTRING ((0 0, 5 0), (5 0, 10 0.001))"));

		//test 3: identicas l?neas pero reducimos la distancia de snap

		geom = SnappingOverlayOperation.overlayOp(c, d, 

				OverlayOp.INTERSECTION, 0.0001);

		assertTrue(geom.toString().equals("GEOMETRYCOLLECTION EMPTY"));

		//test 4: identicas l?neas, pero se separan un poco mas

		geom = SnappingOverlayOperation.overlayOp(c, f, OverlayOp.INTERSECTION, 0.1);

		assertTrue(geom.toString().equals("GEOMETRYCOLLECTION EMPTY"));

		//test 5: interseccion de dos lineas, la solucion son dos puntos:

		//uno con snap y el otro normal. Presentan cambios de orientacion

		geom = SnappingOverlayOperation.overlayOp(g, h, OverlayOp.INTERSECTION, 0.1);

		assertTrue(geom instanceof GeometryCollection);

		assertTrue(geom.toString().equals("MULTIPOINT (2.511904761904762 1.5119047619047619, 3 2)"));

		geom = SnappingOverlayOperation.overlayOp(pol1, 

												  pol2, 

											OverlayOp.INTERSECTION, 

											0.01);

		assertTrue(geom instanceof Polygon);

		assertTrue(geom.toString().equals("POLYGON ((5 7.5, 10 5, 7.502497502497502 2.5024975024975022, 5 5, 5 7.5))"));

	}

}

/*

 * Created on 28-sep-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$

* $Log$

* Revision 1.1  2006-12-04 19:30:23  azabala

* *** empty log message ***

*

* Revision 1.1  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/05 19:20:57  azabala

* first version in cvs

*

* Revision 1.1  2006/10/02 19:06:56  azabala

* *** empty log message ***

*

*

*/

package com.vividsolutions.jts.operation.overlay;

import com.vividsolutions.jts.algorithm.NonRobustLineIntersector;

public class NonRobustSnapLineIntersector extends NonRobustLineIntersector {

	/**

	   * @return true if both numbers are positive or if both numbers are negative.

	   * Returns false if both numbers are zero.

	   */

	  public static boolean isSameSignAndNonZero(double a, double b) {

	    if (a == 0 || b == 0) {

	      return false;

	    }

	    return (a < 0 && b < 0) || (a > 0 && b > 0);

	  }

	  public NonRobustSnapLineIntersector() {

	  }

}

/*

 * Created on 27-sep-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$

 * $Log$

 * Revision 1.1  2006-12-04 19:30:23  azabala

 * *** empty log message ***

 *

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

 * *** empty log message ***

 *

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

 * *** empty log message ***

 *