def test_output_weights():
    g = igraph.Graph(directed=True)
    # two boxes
    g.add_vertices(6)
    # the outer rectange
    g.add_edges([
        (1, 0),
        (0, 5),

        (2, 1),
        (2, 3),

        (4, 3),
        (4, 5),
    ])
    g.es["weight"] = range(6)

    # 1->0
    eq_(gt.output_weights(g, 1), [0])

    # 2->1 2->3
    eq_(gt.output_weights(g, 2), [2, 3])

    # bollard
    eq_(gt.output_weights(g, 5), [])
Example #2
0
def test_export_nodes():
    with test_db_session() as session:
        g = igraph.Graph(directed=True)
        # two boxes
        g.add_vertices(6)
        g.vs["osm_id"] = range(6)
        # the outer rectange
        g.add_edges([
            (1, 0),
            (0, 5),
            (2, 1),
            (2, 3),
            (4, 3),
            (4, 5),
        ])
        g.es["weight"] = [x + 1 for x in range(6)]
        g.vs["redundant"] = [False for _ in range(6)]

        for i in range(6):
            new_node = OSRMNode(i, 3400000, 11800000, False, False)
            session.add(new_node)
        session.commit()

        export_nodes(g, session)

        results = session.query(OSRMRouteNode).filter_by(osm_id=4).all()
        eq_(gt.output_weights(g, 4), [5, 6])
        eq_(results[0].n_outputs, 2)
        eq_(results[0].sum_out, 5 + 6)
        eq_(results[0].product_out, 5 * 6)
        assert_almost_equal(results[0].log_sum_out, math.log(5) + math.log(6))
def test_export_nodes():
    with test_db_session() as session:
        g = igraph.Graph(directed=True)
        # two boxes
        g.add_vertices(6)
        g.vs["osm_id"] = range(6)
        # the outer rectange
        g.add_edges([
            (1, 0),
            (0, 5),

            (2, 1),
            (2, 3),

            (4, 3),
            (4, 5),
        ])
        g.es["weight"] = [x + 1 for x in range(6)]
        g.vs["redundant"] = [False for _ in range(6)]

        for i in range(6):
            new_node = OSRMNode(i, 3400000, 11800000, False, False)
            session.add(new_node)
        session.commit()

        export_nodes(g, session)

        results = session.query(OSRMRouteNode).filter_by(osm_id=4).all()
        eq_(gt.output_weights(g, 4), [5, 6])
        eq_(results[0].n_outputs, 2)
        eq_(results[0].sum_out, 5 + 6)
        eq_(results[0].product_out, 5 * 6)
        assert_almost_equal(results[0].log_sum_out,
                            math.log(5) + math.log(6))
def export_nodes(graph, session):
    """Store out-degree information about nodes as OSRMRouteNodes"""
    log.info("Exporting %i nodes in the database", len(graph.vs))
    for i, vtx in enumerate(graph.vs):
        osm_id = vtx["osm_id"]
        out_edges = gt.output_weights(graph, i)
        session.add(
            OSRMRouteNode(osm_id=osm_id,
                          n_outputs=len(out_edges),
                          n_inputs=len(vtx.successors()),
                          sum_out=sum(out_edges),
                          product_out=reduce(mul, out_edges, 1),
                          log_sum_out=sum(math.log(x) for x in out_edges),
                          redundant=vtx["redundant"]))
        if i % 100 == 0:
            session.flush()
    log.info("Committing nodes to DB")
    session.commit()
def export_nodes(graph, session):
    """Store out-degree information about nodes as OSRMRouteNodes"""
    log.info("Exporting %i nodes in the database", len(graph.vs))
    for i, vtx in enumerate(graph.vs):
        osm_id = vtx["osm_id"]
        out_edges = gt.output_weights(graph, i)
        session.add(
            OSRMRouteNode(
                osm_id=osm_id,
                n_outputs=len(out_edges),
                n_inputs=len(vtx.successors()),
                sum_out=sum(out_edges),
                product_out=reduce(mul, out_edges, 1),
                log_sum_out=sum(math.log(x) for x in out_edges),
                redundant=vtx["redundant"],
            )
        )
        if i % 100 == 0:
            session.flush()
    log.info("Committing nodes to DB")
    session.commit()
Example #6
0
def test_build_graph():
    with test_db_session() as session:
        # Make a y-shaped graph
        node1 = OSRMNode(1, 1, 2, True, False)
        node2 = OSRMNode(2, 3, 4, False, False)
        node3 = OSRMNode(3, 5, 6, False, False)
        node4 = OSRMNode(4, 7, 8, False, False)
        session.add(node1)
        session.add(node2)
        session.add(node3)
        session.add(node4)

        # The source-sink nodes aren't necessarily
        # in "forward" order.
        edge_12 = OSRMEdge(2, 1, 5, 5, False)
        edge_23 = OSRMEdge(2, 3, 5, 5, False)
        edge_24 = OSRMEdge(4, 2, 5, 5, False)

        session.add_all([edge_12, edge_23, edge_24])

        session.commit()

        # The combination of the hash + forward
        # nature should define the edge frequency.
        freq_12 = OSRMEdgeFrequencies(
            edge=OSRMEdge.hash_edge(1, 2),
            # 1->2
            forward=True,
            freq=12,
            geom=None)
        freq_21 = OSRMEdgeFrequencies(
            edge=OSRMEdge.hash_edge(1, 2),
            # 2->1
            forward=False,
            freq=21,
            geom=None)
        freq_34 = OSRMEdgeFrequencies(
            edge=OSRMEdge.hash_edge(2, 3),
            # 2-> 3
            forward=True,
            freq=32,
            geom=None)
        freq_24 = OSRMEdgeFrequencies(
            edge=OSRMEdge.hash_edge(2, 4),
            # This means 2->4
            forward=True,
            freq=24,
            geom=None)

        session.add_all([freq_12, freq_21, freq_34, freq_24])
        session.commit()

        results = session.query(OSRMEdgeFrequencies).all()
        eq_(len(results), 4)
        eq_(results[0].edgeobj.source, 2)
        eq_(results[0].edgeobj.sink, 1)

        graph = build_graph(session)

        eq_(len(graph.vs), 4)
        eq_(len(graph.es), 4)
        assert (graph.is_directed)

        eq_(set(graph.vs["osm_id"]), set([1, 2, 3, 4]))

        eq_(len(graph.vs.select(osm_id=1)), 1)
        vtx_1 = graph.vs.select(osm_id=1)[0]
        eq_(vtx_1.indegree(), 1)
        eq_(vtx_1.outdegree(), 1)
        eq_(vtx_1.degree(), 2)
        eq_(vtx_1.successors()[0]["osm_id"], 2)
        eq_(vtx_1.predecessors()[0]["osm_id"], 2)

        vtx_2 = graph.vs.select(osm_id=2)[0]
        eq_(vtx_2.indegree(), 1)
        eq_(vtx_2.outdegree(), 3)
        eq_(vtx_2.degree(), 4)

        # Check edge weights are correct
        # vtx 0 is node 1
        eq_(gt.output_weights(graph, 0), [12])
        eq_(gt.output_weights(graph, 1), [21, 32, 24])
def test_build_graph():
    with test_db_session() as session:
        # Make a y-shaped graph
        node1 = OSRMNode(1, 1, 2, True, False)
        node2 = OSRMNode(2, 3, 4, False, False)
        node3 = OSRMNode(3, 5, 6, False, False)
        node4 = OSRMNode(4, 7, 8, False, False)
        session.add(node1)
        session.add(node2)
        session.add(node3)
        session.add(node4)

        # The source-sink nodes aren't necessarily
        # in "forward" order.
        edge_12 = OSRMEdge(2, 1, 5, 5, False)
        edge_23 = OSRMEdge(2, 3, 5, 5, False)
        edge_24 = OSRMEdge(4, 2, 5, 5, False)

        session.add_all([edge_12, edge_23, edge_24])

        session.commit()

        # The combination of the hash + forward
        # nature should define the edge frequency.
        freq_12 = OSRMEdgeFrequencies(
            edge=OSRMEdge.hash_edge(1, 2),
            # 1->2
            forward=True,
            freq=12,
            geom=None
        )
        freq_21 = OSRMEdgeFrequencies(
            edge=OSRMEdge.hash_edge(1, 2),
            # 2->1
            forward=False,
            freq=21,
            geom=None
        )
        freq_34 = OSRMEdgeFrequencies(
            edge=OSRMEdge.hash_edge(2, 3),
            # 2-> 3
            forward=True,
            freq=32,
            geom=None
        )
        freq_24 = OSRMEdgeFrequencies(
            edge=OSRMEdge.hash_edge(2, 4),
            # This means 2->4
            forward=True,
            freq=24,
            geom=None
        )

        session.add_all(
            [freq_12, freq_21, freq_34, freq_24])
        session.commit()

        results = session.query(OSRMEdgeFrequencies).all()
        eq_(len(results), 4)
        eq_(results[0].edgeobj.source, 2)
        eq_(results[0].edgeobj.sink, 1)

        graph = build_graph(session)

        eq_(len(graph.vs), 4)
        eq_(len(graph.es), 4)
        assert(graph.is_directed)

        eq_(set(graph.vs["osm_id"]), set([1, 2, 3, 4]))

        eq_(len(graph.vs.select(osm_id=1)), 1)
        vtx_1 = graph.vs.select(osm_id=1)[0]
        eq_(vtx_1.indegree(), 1)
        eq_(vtx_1.outdegree(), 1)
        eq_(vtx_1.degree(), 2)
        eq_(vtx_1.successors()[0]["osm_id"], 2)
        eq_(vtx_1.predecessors()[0]["osm_id"], 2)

        vtx_2 = graph.vs.select(osm_id=2)[0]
        eq_(vtx_2.indegree(), 1)
        eq_(vtx_2.outdegree(), 3)
        eq_(vtx_2.degree(), 4)

        # Check edge weights are correct
        # vtx 0 is node 1
        eq_(gt.output_weights(graph, 0), [12])
        eq_(gt.output_weights(graph, 1), [21, 32, 24])