public List<DirectEdge> getOutgoingEdges(Vertex vertex) {
    Graph graph = _graphService.getGraph();
    GraphVertex gv = graph.getGraphVertex(vertex);
    if (gv == null) {
      return Collections.emptyList();
    }
    List<DirectEdge> result = new ArrayList<DirectEdge>();
    for (Edge out : gv.getOutgoing()) {

      if (!(out instanceof TurnEdge || out instanceof OutEdge || out instanceof PlainStreetEdge)) {
        continue;
      }
      result.add((StreetEdge) out);
    }
    return result;
  }
 @Override
 public void buildGraph(Graph graph) {
   WeightTable wt = new WeightTable(graph);
   if (maxWalkSpeed != null) {
     wt.setMaxWalkSpeed(maxWalkSpeed);
   }
   wt.buildTable();
   graph.putService(WeightTable.class, wt);
 }
Ejemplo n.º 3
0
  public void testNetworkLinker() {
    int numVerticesBefore = graph.getVertices().size();
    NetworkLinker nl = new NetworkLinker(graph);
    nl.createLinkage();
    int numVerticesAfter = graph.getVertices().size();
    assertEquals(4, numVerticesAfter - numVerticesBefore);
    Collection<Edge> outgoing = graph.getOutgoing(station1);
    assertTrue(outgoing.size() == 1);
    DirectEdge edge = (DirectEdge) outgoing.iterator().next();

    Vertex midpoint = edge.getToVertex();
    assertTrue(Math.abs(midpoint.getCoordinate().y - 40.01) < 0.00000001);

    outgoing = graph.getOutgoing(station2);
    assertTrue(outgoing.size() == 1);
    edge = (DirectEdge) outgoing.iterator().next();

    Vertex station2point = edge.getToVertex();
    assertTrue(Math.abs(station2point.getCoordinate().x - -74.002) < 0.00000001);
  }
 public boolean multipleOptionsBefore(Edge edge, State state) {
   Graph graph = _graphService.getGraph();
   boolean foundAlternatePaths = false;
   Vertex start = edge.getFromVertex();
   GraphVertex gv = graph.getGraphVertex(start);
   if (gv == null) {
     return false;
   }
   for (Edge out : gv.getOutgoing()) {
     if (out == edge) {
       continue;
     }
     if (!(out instanceof TurnEdge || out instanceof OutEdge || out instanceof PlainStreetEdge)) {
       continue;
     }
     if (state != null && out.traverse(state) == null) {
       continue;
     }
     // there were paths we didn't take.
     foundAlternatePaths = true;
     break;
   }
   return foundAlternatePaths;
 }
Ejemplo n.º 5
0
  public void setUp() {
    graph = new Graph();
    // a 0.1 degree x 0.1 degree square
    top =
        new StreetVertex(
            "top",
            GeometryUtils.makeLineString(-74.01, 40.01, -74.0, 40.01),
            "top",
            1500,
            false,
            null);
    bottom =
        new StreetVertex(
            "bottom",
            GeometryUtils.makeLineString(-74.01, 40.0, -74.0, 40.0),
            "bottom",
            1500,
            false,
            null);
    left =
        new StreetVertex(
            "left",
            GeometryUtils.makeLineString(-74.01, 40.0, -74.01, 40.01),
            "left",
            1500,
            false,
            null);
    right =
        new StreetVertex(
            "right",
            GeometryUtils.makeLineString(-74.0, 40.0, -74.0, 40.01),
            "right",
            1500,
            false,
            null);

    StreetVertex topBack =
        new StreetVertex(
            "topBack",
            GeometryUtils.makeLineString(-74.0, 40.01, -74.01, 40.01),
            "topBack",
            1500,
            true,
            null);
    StreetVertex bottomBack =
        new StreetVertex(
            "bottomBack",
            GeometryUtils.makeLineString(-74.0, 40.0, -74.01, 40.0),
            "bottomBack",
            1500,
            true,
            null);
    leftBack =
        new StreetVertex(
            "leftBack",
            GeometryUtils.makeLineString(-74.01, 40.01, -74.01, 40.0),
            "leftBack",
            1500,
            true,
            null);
    rightBack =
        new StreetVertex(
            "rightBack",
            GeometryUtils.makeLineString(-74.0, 40.01, -74.0, 40.0),
            "rightBack",
            1500,
            true,
            null);

    right.setPermission(StreetTraversalPermission.PEDESTRIAN);

    graph.addVertex(top);
    graph.addVertex(bottom);
    graph.addVertex(left);
    graph.addVertex(right);

    graph.addVertex(topBack);
    graph.addVertex(bottomBack);
    graph.addVertex(leftBack);
    graph.addVertex(rightBack);

    EndpointVertex tlIn =
        (EndpointVertex) graph.addVertex(new EndpointVertex("tl in", -74.01, 40.01));
    EndpointVertex trIn =
        (EndpointVertex) graph.addVertex(new EndpointVertex("tr in", -74.0, 40.01));
    EndpointVertex blIn =
        (EndpointVertex) graph.addVertex(new EndpointVertex("bl in", -74.0, 40.0));
    EndpointVertex brIn =
        (EndpointVertex) graph.addVertex(new EndpointVertex("br in", -74.01, 40.0));

    Vertex tlOut = graph.addVertex(new EndpointVertex("tl out", -74.01, 40.01));
    trOut = graph.addVertex(new EndpointVertex("tr out", -74.0, 40.01));
    Vertex blOut = graph.addVertex(new EndpointVertex("bl out", -74.0, 40.0));
    brOut = graph.addVertex(new EndpointVertex("br out", -74.01, 40.0));

    graph.addEdge(new FreeEdge(tlOut, top));
    graph.addEdge(new FreeEdge(tlOut, leftBack));

    graph.addEdge(new FreeEdge(trOut, topBack));
    graph.addEdge(new FreeEdge(trOut, rightBack));

    graph.addEdge(new FreeEdge(blOut, bottom));
    graph.addEdge(new FreeEdge(blOut, left));

    graph.addEdge(new FreeEdge(brOut, bottomBack));
    graph.addEdge(new FreeEdge(brOut, right));

    graph.addEdge(new OutEdge(topBack, tlIn));
    graph.addEdge(new OutEdge(left, tlIn));

    graph.addEdge(new OutEdge(top, trIn));
    graph.addEdge(new OutEdge(right, trIn));

    graph.addEdge(new OutEdge(bottomBack, blIn));
    graph.addEdge(new OutEdge(leftBack, blIn));

    graph.addEdge(new OutEdge(bottom, brIn));
    graph.addEdge(new OutEdge(rightBack, brIn));

    graph.addEdge(new TurnEdge(top, rightBack));
    graph.addEdge(new TurnEdge(rightBack, bottomBack));
    graph.addEdge(new TurnEdge(bottomBack, left));
    graph.addEdge(new TurnEdge(left, top));

    graph.addEdge(new TurnEdge(topBack, leftBack));
    graph.addEdge(new TurnEdge(leftBack, bottom));
    graph.addEdge(new TurnEdge(bottom, right));
    graph.addEdge(new TurnEdge(right, topBack));

    station1 =
        new TransitStop(
            "transitVertex 1",
            -74.005,
            40.0099999,
            "transitVertex 1",
            new AgencyAndId("A", "fleem station"),
            null);
    graph.addVertex(station1);
    station2 =
        new TransitStop(
            "transitVertex 2",
            -74.002,
            40.0099999,
            "transitVertex 2",
            new AgencyAndId("A", "morx station"),
            null);
    graph.addVertex(station2);
  }
Ejemplo n.º 6
0
  public void testHalfEdges() {
    // the shortest half-edge from the start vertex takes you down, but the shortest total path
    // is up and over

    TraverseOptions options = new TraverseOptions();

    HashSet<Edge> turns = new HashSet<Edge>(graph.getOutgoing(left));
    turns.addAll(graph.getOutgoing(leftBack));

    StreetLocation start =
        StreetLocation.createStreetLocation(
            "start",
            "start",
            cast(turns, StreetEdge.class),
            new LinearLocation(0, 0.4).getCoordinate(left.getGeometry()));

    HashSet<Edge> endTurns = new HashSet<Edge>(graph.getOutgoing(right));
    endTurns.addAll(graph.getOutgoing(rightBack));

    StreetLocation end =
        StreetLocation.createStreetLocation(
            "end",
            "end",
            cast(endTurns, StreetEdge.class),
            new LinearLocation(0, 0.8).getCoordinate(right.getGeometry()));

    assertTrue(start.getX() < end.getX());
    assertTrue(start.getY() < end.getY());

    List<DirectEdge> extra = end.getExtra();

    assertEquals(12, extra.size());

    GregorianCalendar startTime = new GregorianCalendar(2009, 11, 1, 12, 34, 25);

    ShortestPathTree spt1 =
        AStar.getShortestPathTree(graph, brOut, end, TestUtils.toSeconds(startTime), options);

    GraphPath pathBr = spt1.getPath(end, false);
    assertNotNull("There must be a path from br to end", pathBr);

    ShortestPathTree spt2 =
        AStar.getShortestPathTree(graph, trOut, end, TestUtils.toSeconds(startTime), options);

    GraphPath pathTr = spt2.getPath(end, false);
    assertNotNull("There must be a path from tr to end", pathTr);
    assertTrue(
        "path from bottom to end must be longer than path from top to end",
        pathBr.getWeight() > pathTr.getWeight());

    ShortestPathTree spt =
        AStar.getShortestPathTree(graph, start, end, TestUtils.toSeconds(startTime), options);

    GraphPath path = spt.getPath(end, false);
    assertNotNull("There must be a path from start to end", path);

    // the bottom is not part of the shortest path
    for (State s : path.states) {
      assertNotSame(s.getVertex(), graph.getVertex("bottom"));
      assertNotSame(s.getVertex(), graph.getVertex("bottomBack"));
    }

    startTime = new GregorianCalendar(2009, 11, 1, 12, 34, 25);

    options.setArriveBy(true);
    spt = AStar.getShortestPathTree(graph, start, end, TestUtils.toSeconds(startTime), options);

    path = spt.getPath(start, false);
    assertNotNull("There must be a path from start to end (looking back)", path);

    // the bottom edge is not part of the shortest path
    for (State s : path.states) {
      assertNotSame(s.getVertex(), graph.getVertex("bottom"));
      assertNotSame(s.getVertex(), graph.getVertex("bottomBack"));
    }

    /* Now, the right edge is not bikeable.  But the user can walk their bike.  So here are some tests
     * that prove (a) that walking bikes works, but that (b) it is not preferred to riding a tiny bit longer.
     */

    options = new TraverseOptions(new TraverseModeSet(TraverseMode.BICYCLE));
    start =
        StreetLocation.createStreetLocation(
            "start1",
            "start1",
            cast(turns, StreetEdge.class),
            new LinearLocation(0, 0.95).getCoordinate(top.getGeometry()));
    end =
        StreetLocation.createStreetLocation(
            "end1",
            "end1",
            cast(turns, StreetEdge.class),
            new LinearLocation(0, 0.95).getCoordinate(bottom.getGeometry()));
    spt = AStar.getShortestPathTree(graph, start, end, TestUtils.toSeconds(startTime), options);

    path = spt.getPath(start, false);
    assertNotNull("There must be a path from top to bottom along the right", path);

    // the left edge is not part of the shortest path (even though the bike must be walked along the
    // right)
    for (State s : path.states) {
      assertNotSame(s.getVertex(), graph.getVertex("left"));
      assertNotSame(s.getVertex(), graph.getVertex("leftBack"));
    }

    start =
        StreetLocation.createStreetLocation(
            "start2",
            "start2",
            cast(turns, StreetEdge.class),
            new LinearLocation(0, 0.55).getCoordinate(top.getGeometry()));
    end =
        StreetLocation.createStreetLocation(
            "end2",
            "end2",
            cast(turns, StreetEdge.class),
            new LinearLocation(0, 0.55).getCoordinate(bottom.getGeometry()));
    spt = AStar.getShortestPathTree(graph, start, end, TestUtils.toSeconds(startTime), options);

    path = spt.getPath(start, false);
    assertNotNull("There must be a path from top to bottom", path);

    // the right edge is not part of the shortest path, e
    for (State s : path.states) {
      assertNotSame(s.getVertex(), graph.getVertex("right"));
      assertNotSame(s.getVertex(), graph.getVertex("rightBack"));
    }
  }