/* * The JTS Topology Suite is a collection of Java classes that * implement the fundamental operations required to validate a given * geo-spatial data set to a known topological specification. * * Copyright (C) 2001 Vivid Solutions * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library 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 * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * For more information, contact: * * Vivid Solutions * Suite #1A * 2328 Government Street * Victoria BC V8T 5G5 * Canada * * (250)385-6040 * www.vividsolutions.com */ package com.vividsolutions.jts.geomgraph; /** * @version 1.7 */ import java.io.PrintStream; import java.util.*; import com.vividsolutions.jts.algorithm.*; import com.vividsolutions.jts.geom.*; /** * The computation of the <code>IntersectionMatrix</code> relies on the use of a structure * called a "topology graph". The topology graph contains nodes and edges * corresponding to the nodes and line segments of a <code>Geometry</code>. Each * node and edge in the graph is labeled with its topological location relative to * the source geometry. * <P> * Note that there is no requirement that points of self-intersection be a vertex. * Thus to obtain a correct topology graph, <code>Geometry</code>s must be * self-noded before constructing their graphs. * <P> * Two fundamental operations are supported by topology graphs: * <UL> * <LI>Computing the intersections between all the edges and nodes of a single graph * <LI>Computing the intersections between the edges and nodes of two different graphs * </UL> * * @version 1.7 */ public class PlanarGraph { /** * For nodes in the Collection, link the DirectedEdges at the node that are in the result. * This allows clients to link only a subset of nodes in the graph, for * efficiency (because they know that only a subset is of interest). */ public static void linkResultDirectedEdges(Collection nodes) { for (Iterator nodeit = nodes.iterator(); nodeit.hasNext(); ) { Node node = (Node) nodeit.next(); ((DirectedEdgeStar) node.getEdges()).linkResultDirectedEdges(); } } protected List edges = new ArrayList(); protected NodeMap nodes; protected List edgeEndList = new ArrayList(); public PlanarGraph(NodeFactory nodeFact) { nodes = new NodeMap(nodeFact); } public PlanarGraph() { nodes = new NodeMap(new NodeFactory()); } public Iterator getEdgeIterator() { return edges.iterator(); } public Collection getEdgeEnds() { return edgeEndList; } public boolean isBoundaryNode(int geomIndex, Coordinate coord) { Node node = nodes.find(coord); if (node == null) return false; Label label = node.getLabel(); if (label != null && label.getLocation(geomIndex) == Location.BOUNDARY) return true; return false; } protected void insertEdge(Edge e) { edges.add(e); } public void add(EdgeEnd e) { nodes.add(e); edgeEndList.add(e); } public Iterator getNodeIterator() { return nodes.iterator(); } public Collection getNodes() { return nodes.values(); } public Node addNode(Node node) { return nodes.addNode(node); } public Node addNode(Coordinate coord) { return nodes.addNode(coord); } /** * @return the node if found; null otherwise */ public Node find(Coordinate coord) { return nodes.find(coord); } /** * Add a set of edges to the graph. For each edge two DirectedEdges * will be created. DirectedEdges are NOT linked by this method. */ public void addEdges(List edgesToAdd) { // create all the nodes for the edges for (Iterator it = edgesToAdd.iterator(); it.hasNext(); ) { Edge e = (Edge) it.next(); edges.add(e); DirectedEdge de1 = new DirectedEdge(e, true); DirectedEdge de2 = new DirectedEdge(e, false); de1.setSym(de2); de2.setSym(de1); add(de1); add(de2); } } /** * Link the DirectedEdges at the nodes of the graph. * This allows clients to link only a subset of nodes in the graph, for * efficiency (because they know that only a subset is of interest). */ public void linkResultDirectedEdges() { for (Iterator nodeit = nodes.iterator(); nodeit.hasNext(); ) { Node node = (Node) nodeit.next(); ((DirectedEdgeStar) node.getEdges()).linkResultDirectedEdges(); } } /** * Link the DirectedEdges at the nodes of the graph. * This allows clients to link only a subset of nodes in the graph, for * efficiency (because they know that only a subset is of interest). */ public void linkAllDirectedEdges() { for (Iterator nodeit = nodes.iterator(); nodeit.hasNext(); ) { Node node = (Node) nodeit.next(); ((DirectedEdgeStar) node.getEdges()).linkAllDirectedEdges(); } } /** * Returns the EdgeEnd which has edge e as its base edge * (MD 18 Feb 2002 - this should return a pair of edges) * * @return the edge, if found * <code>null</code> if the edge was not found */ public EdgeEnd findEdgeEnd(Edge e) { for (Iterator i = getEdgeEnds().iterator(); i.hasNext(); ) { EdgeEnd ee = (EdgeEnd) i.next(); if (ee.getEdge() == e) return ee; } return null; } /** * Returns the edge whose first two coordinates are p0 and p1 * * @return the edge, if found * <code>null</code> if the edge was not found */ public Edge findEdge(Coordinate p0, Coordinate p1) { for (int i = 0; i < edges.size(); i++) { Edge e = (Edge) edges.get(i); Coordinate[] eCoord = e.getCoordinates(); if (p0.equals(eCoord[0]) && p1.equals(eCoord[1]) ) return e; } return null; } /** * Returns the edge which starts at p0 and whose first segment is * parallel to p1 * * @return the edge, if found * <code>null</code> if the edge was not found */ public Edge findEdgeInSameDirection(Coordinate p0, Coordinate p1) { for (int i = 0; i < edges.size(); i++) { Edge e = (Edge) edges.get(i); Coordinate[] eCoord = e.getCoordinates(); if (matchInSameDirection(p0, p1, eCoord[0], eCoord[1]) ) return e; if (matchInSameDirection(p0, p1, eCoord[eCoord.length - 1], eCoord[eCoord.length - 2]) ) return e; } return null; } /** * The coordinate pairs match if they define line segments lying in the same direction. * E.g. the segments are parallel and in the same quadrant * (as opposed to parallel and opposite!). */ private boolean matchInSameDirection(Coordinate p0, Coordinate p1, Coordinate ep0, Coordinate ep1) { if (! p0.equals(ep0)) return false; if (CGAlgorithms.computeOrientation(p0, p1, ep1) == CGAlgorithms.COLLINEAR && Quadrant.quadrant(p0, p1) == Quadrant.quadrant(ep0, ep1) ) return true; return false; } public void printEdges(PrintStream out) { out.println("Edges:"); for (int i = 0; i < edges.size(); i++) { out.println("edge " + i + ":"); Edge e = (Edge) edges.get(i); e.print(out); e.eiList.print(out); } } void debugPrint(Object o) { System.out.print(o); } void debugPrintln(Object o) { System.out.println(o); } }