sptRequestA.setRoutingContext(graphService.getGraph());

        }

        ShortestPathTree sptA = sptService.getShortestPathTree(sptRequestA);

        StreetLocation origin = (StreetLocation) sptRequestA.rctx.fromVertex;

        // create a LineString for display

        Coordinate pathToStreetCoords[] = new Coordinate[2];

        pathToStreetCoords[0] = dropPoint;

        pathToStreetCoords[1] = origin.getCoordinate();

         

            EarliestArrivalSPTService sptService = new EarliestArrivalSPTService();

            sptService.maxDuration = (60 * cutoffMinutes);

            ShortestPathTree spt = sptService.getShortestPathTree(req);

            if (spt != null) {

                TimeSurface surface = new TimeSurface(spt);

                surface.params = Maps.newHashMap();

                for (Map.Entry<String, List<String>> e : uriInfo.getQueryParameters().entrySet()) {

                    // include only the first instance of each query parameter

            response.setError(error);

        } finally {

            if (request != null) {

                response.debugOutput = request.rctx.debugOutput;

            }      

        }

        return response;

    }

        showGraph.setSPTFlattening( Float.parseFloat(sptFlattening.getText()) );

        showGraph.setSPTThickness( Float.parseFloat(sptThickness.getText()) );

        showGraph.redraw();

       

    }

   

  private void showPathsInPanel(List<GraphPath> paths) {

    // show paths in a list panel

    DefaultListModel<PathPrinter> data = new DefaultListModel<PathPrinter>();

            assertNotSame(s.getVertex(), graph.getVertex("bottomBack"));

        }

        // Number of vertices and edges should be the same as before after a cleanup.

        assertEquals(nVertices, graph.getVertices().size());

        assertEquals(nEdges, graph.getEdges().size());

        /*

         * 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

            assertNotSame(s.getVertex(), graph.getVertex("leftBack"));

        }

        // Number of vertices and edges should be the same as before after a cleanup.

        assertEquals(nVertices, graph.getVertices().size());

        assertEquals(nEdges, graph.getEdges().size());

        start = StreetLocation.createStreetLocation(graph, "start2", "start2",

                filter(turns, StreetEdge.class),

            assertNotSame(s.getVertex(), graph.getVertex("rightBack"));

        }

        // Number of vertices and edges should be the same as before after a cleanup.

        assertEquals(nVertices, graph.getVertices().size());

        assertEquals(nEdges, graph.getEdges().size());

    }

   

    public void testRouteToSameEdge() {

        RoutingRequest options = proto.clone();

        options.setRoutingContext(_graph, startBackEdge, u, v);

        ShortestPathTree tree = sptService.getShortestPathTree(options);

        GraphPath path = tree.getPath(v, false);

        return path;

    }

   

    private void checkTriangleInequality() {

        checkTriangleInequality(null);

        GenericAStar aStar = new GenericAStar();

       

        ShortestPathTree tree = aStar.getShortestPathTree(options);

        GraphPath path = tree.getPath(end, false);

        assertNotNull(path);

       

        double startEndWeight = path.getWeight();

        int startEndDuration = path.getDuration();

        assertTrue(startEndWeight > 0);

            if (req != null) {

                ShortestPathTree spt = sptService.getShortestPathTree(req);

                // ResultSet should be a local to avoid memory leak

                ResultSet results = ResultSet.forTravelTimes(destinations, spt);

                switch (mode) {

                case ACCUMULATE:

                    synchronized (aggregateResultSet) {

                        accumulator.accumulate(oi.input, results, aggregateResultSet);

                    }