Cityseer Examples

This repository contains examples for the cityseer-api package.

• cityseer main repository
• cityseer API documentation

Use the navigation menu to explore examples.

Getting Started

cityseer is a python package that can be installed with pip:

# !pip install --upgrade cityseer

Warning

The guide and examples are based on cityseer>=4.19.1.

cityseer revolves around networks (graphs). If you’re comfortable with numpy and abstract data handling, then the underlying data structures can be created and manipulated directly. However, it is generally more convenient to sketch the graph using NetworkX and to let cityseer take care of initialising and converting the graph for you.

# any networkX MultiGraph with 'x' and 'y' node attributes will do
# here we'll use the cityseer mock module to generate an example networkX graph
import networkx as nx
from cityseer.tools import mock, graphs, plot, io

G = mock.mock_graph()
print(G)
# let's plot the network
plot.plot_nx(G, labels=True, node_size=80, dpi=200, figsize=(4, 4))

INFO:cityseer.tools.plot:Preparing graph nodes
INFO:cityseer.tools.plot:Preparing graph edges

MultiGraph with 57 nodes and 79 edges

  0%|          | 0/79 [00:00<?, ?it/s]100%|██████████| 79/79 [00:00<00:00, 482314.43it/s]

Graph Preparation

The tools.graphs module contains a collection of convenience functions for the preparation and conversion of networkX MultiGraphs, i.e. undirected graphs allowing for parallel edges. The tools.graphs module is designed to work with raw shapely Linestring geometries that have been assigned to the graph’s edge (link) geom attributes. The benefit to this approach is that the geometry of the network is decoupled from the topology: the topology is consequently free from distortions which would otherwise confound centrality and other metrics.

There are generally two scenarios when creating a street network graph:

1. In the ideal case, if you have access to a high-quality street network dataset – which keeps the topology of the network separate from the geometry of the streets – then you would construct the network based on the topology while assigning the roadway geometries to the respective edges spanning the nodes. OS Open Roads is a good example of this type of dataset. Assigning the geometries to an edge involves A - casting the geometry to a shapely LineString, and B - assigning this geometry to the respective edge by adding the LineString geometry as a geom attribute. e.g. G.add_edge(start_node, end_node, geom=a_linestring_geom).

2. In reality, most data-sources are not this refined and will represent roadway geometries by adding additional nodes to the network. For a variety of reasons, this is not ideal and you may want to follow the Graph Cleaning guide.

Here, we’ll walk through a high-level overview showing how to use cityseer. You can provide your own shapely geometries if available; else, you can auto-infer simple geometries from the start to end node of each network edge, which works well for graphs where nodes have been used to inscribe roadway geometries (i.e. OSM).

# use nx_simple_geoms to infer geoms for your edges
G = graphs.nx_simple_geoms(G)
plot.plot_nx(G, labels=True, node_size=80, plot_geoms=True, dpi=200, figsize=(4, 4))

INFO:cityseer.tools.graphs:Generating interpolated edge geometries.
  0%|          | 0/79 [00:00<?, ?it/s]100%|██████████| 79/79 [00:00<00:00, 49462.61it/s]
INFO:cityseer.tools.plot:Preparing graph nodes
INFO:cityseer.tools.plot:Preparing graph edges
  0%|          | 0/79 [00:00<?, ?it/s]100%|██████████| 79/79 [00:00<00:00, 41418.75it/s]

We have now inferred geometries for each edge, meaning that each edge now has an associated LineString geometry. Any further manipulation of the graph using the cityseer.graph module will retain and further manipulate these geometries in-place.

Once the geoms are readied, we can use tools such as nx_decompose for generating granular graph representations and nx_to_dual for casting a primal graph representation to its dual.

# this will (optionally) decompose the graph
G_decomp = graphs.nx_decompose(G, 50)
plot.plot_nx(G_decomp, plot_geoms=True, labels=False, dpi=200, figsize=(4, 4))

INFO:cityseer.tools.graphs:Decomposing graph to maximum edge lengths of 50.
  0%|          | 0/79 [00:00<?, ?it/s]100%|██████████| 79/79 [00:00<00:00, 2020.97it/s]
INFO:cityseer.tools.plot:Preparing graph nodes
INFO:cityseer.tools.plot:Preparing graph edges
  0%|          | 0/316 [00:00<?, ?it/s]100%|██████████| 316/316 [00:00<00:00, 21851.10it/s]

# this will (optionally) cast to a dual network
G_dual = graphs.nx_to_dual(G)
# here we are plotting the newly decomposed graph (blue) against the original graph (red)
plot.plot_nx_primal_or_dual(G, G_dual, plot_geoms=False, dpi=200, figsize=(4, 4))

INFO:cityseer.tools.graphs:Converting graph to dual.
INFO:cityseer.tools.graphs:Preparing dual nodes
  0%|          | 0/79 [00:00<?, ?it/s]100%|██████████| 79/79 [00:00<00:00, 38222.40it/s]
INFO:cityseer.tools.graphs:Preparing dual edges (splitting and welding geoms)
  0%|          | 0/79 [00:00<?, ?it/s]100%|██████████| 79/79 [00:00<00:00, 978.11it/s]
INFO:cityseer.tools.plot:Preparing graph nodes
INFO:cityseer.tools.plot:Preparing graph edges
  0%|          | 0/79 [00:00<?, ?it/s]100%|██████████| 79/79 [00:00<00:00, 460848.42it/s]
INFO:cityseer.tools.plot:Preparing graph nodes
INFO:cityseer.tools.plot:Preparing graph edges
  0%|          | 0/155 [00:00<?, ?it/s]100%|██████████| 155/155 [00:00<00:00, 561898.98it/s]

Metrics

After graph preparation and cleaning has been completed, the networkX graph can be transformed into data structures for efficiently computing centralities, land-use measures, or statistical aggregations.

Use network_structure_from_nx to convert a networkX graph into a GeoPandas GeoDataFrame and a rustalgos.NetworkStructure, which is used by Cityseer for efficiently computing over the network.

Network Centralities

The networks.node_centrality_shortest, networks.node_centrality_simplest, and networks.segment_centrality methods wrap underlying rust functions that compute the centrality methods. All selected measures and distance thresholds are computed simultaneously to reduce the amount of time required for multi-variable and multi-scalar workflows. The results of the computations will be written to the GeoDataFrame.

from cityseer.metrics import networks

# create a Network layer from the networkX graph
# use a CRS EPSG code matching the projected coordinate reference system for your data
nodes_gdf, edges_gdf, network_structure = io.network_structure_from_nx(
    G_decomp, crs=3395
)
# the underlying method allows the computation of various centralities simultaneously, e.g.
nodes_gdf = networks.segment_centrality(
    network_structure=network_structure,  # the network structure for which to compute the measures
    nodes_gdf=nodes_gdf,  # the nodes GeoDataFrame, to which the results will be written
    distances=[
        200,
        400,
        800,
        1600,
    ],  # the distance thresholds for which to compute centralities
)
nodes_gdf.head()  # the results are now in the GeoDataFrame

INFO:cityseer.tools.io:Preparing node and edge arrays from networkX graph.
  0%|          | 0/294 [00:00<?, ?it/s]100%|██████████| 294/294 [00:00<00:00, 114114.88it/s]
  0%|          | 0/294 [00:00<?, ?it/s]100%|██████████| 294/294 [00:00<00:00, 8818.12it/s]
INFO:cityseer.metrics.networks:Computing shortest path segment centrality.
  0%|          | 0/294 [00:00<?, ?it/s]100%|██████████| 294/294 [00:01<00:00, 293.86it/s]100%|██████████| 294/294 [00:01<00:00, 293.60it/s]

	ns_node_idx	x	y	live	weight	geom	cc_seg_density_200	cc_seg_density_400	cc_seg_density_800	cc_seg_density_1600	...	cc_seg_harmonic_800	cc_seg_harmonic_1600	cc_seg_beta_200	cc_seg_beta_400	cc_seg_beta_800	cc_seg_beta_1600	cc_seg_betweenness_200	cc_seg_betweenness_400	cc_seg_betweenness_800	cc_seg_betweenness_1600
0	0	700700.0	5719700.0	True	1	POINT (700700 5719700)	857.327026	3042.260254	10088.987305	13137.789062	...	36.822689	40.173214	159.837616	421.984436	1365.011597	3582.891113	590.866028	2805.017822	23575.000000	159337.875000
1	1	700610.0	5719780.0	True	1	POINT (700610 5719780)	784.184753	2527.174805	9059.986328	13137.791992	...	34.135193	38.450062	154.743927	388.553589	1221.976562	3301.651611	534.708496	2270.786865	15957.033203	103352.492188
2	2	700460.0	5719700.0	True	1	POINT (700460 5719700)	695.835876	2062.288330	6928.821289	13137.790039	...	29.375729	35.568359	150.506683	353.928864	999.668030	2788.973877	484.306824	1700.836914	7541.833984	36259.539062
3	3	700520.0	5719820.0	True	1	POINT (700520 5719820)	817.972900	2366.633057	5945.978027	13137.791992	...	28.526949	35.446590	156.397873	392.560852	1018.365723	2680.288574	538.021912	2131.172119	7549.370605	24907.949219
4	4	700620.0	5719905.0	True	1	POINT (700620 5719905)	812.112549	2419.865234	7675.241699	13137.791992	...	31.385777	36.887234	155.821732	388.663147	1108.671631	2981.365723	528.050293	2153.490234	11441.315430	66363.093750

5 rows × 22 columns

# plot centrality
from matplotlib import colors

# custom colourmap
cmap = colors.LinearSegmentedColormap.from_list("cityseer", ["#64c1ff", "#d32f2f"])
# normalise the values
segment_harmonic_vals = nodes_gdf["cc_seg_harmonic_800"]
segment_harmonic_vals = colors.Normalize()(segment_harmonic_vals)
# cast against the colour map
segment_harmonic_cols = cmap(segment_harmonic_vals)
# plot segment_harmonic
# cityseer's plot methods are used here and in tests for convenience
# that said, rather use plotting methods directly from networkX or GeoPandas where possible
plot.plot_nx(
    G_decomp, labels=False, node_colour=segment_harmonic_cols, dpi=200, figsize=(4, 4)
)

INFO:cityseer.tools.plot:Preparing graph nodes
INFO:cityseer.tools.plot:Preparing graph edges
  0%|          | 0/316 [00:00<?, ?it/s]100%|██████████| 316/316 [00:00<00:00, 226447.99it/s]

Land-use and statistical measures

Landuse and statistical measures require a GeoPandas GeoDataFrame consisting of Point geometries. Columns representing categorical landuse information (“pub”, “shop”, “school”) can be passed to landuse methods, whereas columns representing numerical information can be used for statistical methods.

When computing these measures, cityseer will assign each data point to the two closest network nodes — one in either direction — based on the closest adjacent street edge. This enables cityseer to use dynamic spatial aggregation methods that more accurately describe distances from the perspective of pedestrians travelling over the network, and relative to the direction of approach.

layers.compute_landuses and layers.compute_mixed_uses methods are used for the calculation of land-use accessibility and mixed-use measures whereas layers.compute_stats can be used for statistical aggregations. As with the centrality methods, the measures are computed over the network and are computed simultaneously for all measures and distances.

from cityseer.metrics import layers

# a mock data dictionary representing categorical landuse data
# here randomly generated letters represent fictitious landuse categories
data_gdf = mock.mock_landuse_categorical_data(G_decomp, random_seed=25)
data_gdf.head()

	geometry	data_id	categorical_landuses
uid
0	POINT (701144.149 5719228.311)	0	h
1	POINT (700798.732 5719938.464)	1	f
2	POINT (700434.607 5719165.951)	2	h
3	POINT (700323.093 5719450.769)	3	a
4	POINT (700593.32 5719841.434)	4	h

# example easy-wrapper method for computing mixed-uses
# this is a distance weighted form of hill diversity
nodes_gdf, data_gdf = layers.compute_mixed_uses(
    data_gdf,  # the source data
    landuse_column_label="categorical_landuses",  # column in the dataframe which contains the landuse labels
    nodes_gdf=nodes_gdf,  # nodes GeoDataFrame - the results are written here
    network_structure=network_structure,  # measures will be computed relative to pedestrian distances over the network
    distances=[
        200,
        400,
        800,
        1600,
    ],  # distance thresholds for which you want to compute the measures
)
print(
    nodes_gdf.columns
)  # the GeoDataFrame will contain the results of the calculations
print(nodes_gdf["cc_hill_q0_800_nw"])  # which can be retrieved as needed

INFO:cityseer.metrics.layers:Computing mixed-use measures.
  0%|          | 0/294 [00:00<?, ?it/s]100%|██████████| 294/294 [00:01<00:00, 293.88it/s]100%|██████████| 294/294 [00:01<00:00, 293.67it/s]

Index(['ns_node_idx', 'x', 'y', 'live', 'weight', 'geom', 'cc_seg_density_200',
       'cc_seg_density_400', 'cc_seg_density_800', 'cc_seg_density_1600',
       'cc_seg_harmonic_200', 'cc_seg_harmonic_400', 'cc_seg_harmonic_800',
       'cc_seg_harmonic_1600', 'cc_seg_beta_200', 'cc_seg_beta_400',
       'cc_seg_beta_800', 'cc_seg_beta_1600', 'cc_seg_betweenness_200',
       'cc_seg_betweenness_400', 'cc_seg_betweenness_800',
       'cc_seg_betweenness_1600', 'cc_hill_q0_200_nw', 'cc_hill_q0_200_wt',
       'cc_hill_q1_200_nw', 'cc_hill_q1_200_wt', 'cc_hill_q2_200_nw',
       'cc_hill_q2_200_wt', 'cc_hill_q0_400_nw', 'cc_hill_q0_400_wt',
       'cc_hill_q1_400_nw', 'cc_hill_q1_400_wt', 'cc_hill_q2_400_nw',
       'cc_hill_q2_400_wt', 'cc_hill_q0_800_nw', 'cc_hill_q0_800_wt',
       'cc_hill_q1_800_nw', 'cc_hill_q1_800_wt', 'cc_hill_q2_800_nw',
       'cc_hill_q2_800_wt', 'cc_hill_q0_1600_nw', 'cc_hill_q0_1600_wt',
       'cc_hill_q1_1600_nw', 'cc_hill_q1_1600_wt', 'cc_hill_q2_1600_nw',
       'cc_hill_q2_1600_wt'],
      dtype='object')
0          9.0
1          9.0
2          9.0
3          9.0
4          9.0
          ... 
53±0±54    2.0
53±1±54    2.0
53±2±54    2.0
54±0±55    2.0
54±1±55    2.0
Name: cc_hill_q0_800_nw, Length: 294, dtype: float32

# for curiosity's sake - plot the assignments to see which edges the data points were assigned to
plot.plot_assignment(network_structure, G_decomp, data_gdf, dpi=200, figsize=(4, 4))

/home/runner/work/cityseer-examples/cityseer-examples/.venv/lib/python3.13/site-packages/cityseer/tools/plot.py:560: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.
  plt.tight_layout()

# plot distance-weighted hill mixed uses
mixed_uses_vals = nodes_gdf["cc_hill_q0_800_wt"]
mixed_uses_vals = colors.Normalize()(mixed_uses_vals)
mixed_uses_cols = cmap(mixed_uses_vals)
plot.plot_assignment(
    network_structure,
    G_decomp,
    data_gdf,
    node_colour=mixed_uses_cols,
    data_labels=data_gdf["categorical_landuses"].values,
    dpi=200,
    figsize=(4, 4),
)

# compute landuse accessibilities for land-use types a, b, c
nodes_gdf, data_gdf = layers.compute_accessibilities(
    data_gdf,  # the source data
    landuse_column_label="categorical_landuses",  # column in the dataframe which contains the landuse labels
    accessibility_keys=[
        "a",
        "b",
        "c",
    ],  # the landuse categories for which to compute accessibilities
    nodes_gdf=nodes_gdf,  # nodes GeoDataFrame - the results are written here
    network_structure=network_structure,  # measures will be computed relative to pedestrian distances over the network
    distances=[
        200,
        400,
        800,
        1600,
    ],  # distance thresholds for which you want to compute the measures
)
# accessibilities are computed in both weighted and unweighted forms, e.g. for "a" and "b" landuse codes
print(
    nodes_gdf[["cc_a_800_wt", "cc_b_1600_nw"]]
)  # and can be retrieved as needed

INFO:cityseer.metrics.layers:Computing land-use accessibility for: a, b, c
  0%|          | 0/294 [00:00<?, ?it/s]100%|██████████| 294/294 [00:01<00:00, 293.92it/s]100%|██████████| 294/294 [00:01<00:00, 293.69it/s]

         cc_a_800_wt  cc_b_1600_nw
0           0.316222           2.0
1           0.173186           2.0
2           0.074022           2.0
3           0.047997           2.0
4           0.092515           2.0
...              ...           ...
53±0±54     0.000000           0.0
53±1±54     0.000000           0.0
53±2±54     0.000000           0.0
54±0±55     0.000000           0.0
54±1±55     0.000000           0.0

[294 rows x 2 columns]

Aggregations can likewise be computed for numerical data:

numerical_data_gdf = mock.mock_numerical_data(G_decomp, num_arrs=3)
numerical_data_gdf.head()
# compute stats for column mock_numerical_1
nodes_gdf, numerical_data_gdf = layers.compute_stats(
    numerical_data_gdf,  # the source data
    stats_column_labels=["mock_numerical_1"],  # numerical columns to compute stats for
    nodes_gdf=nodes_gdf,  # nodes GeoDataFrame - the results are written here
    network_structure=network_structure,  # measures will be computed relative to pedestrian distances over the network
    distances=[
        800,
        1600,
    ],  # distance thresholds for which you want to compute the measures
)
# statistical aggregations are calculated for each requested column, and in the following forms:
# max, min, sum, sum_weighted, mean, mean_weighted, variance, variance_weighted
print(nodes_gdf["cc_mock_numerical_1_max_800"])
print(nodes_gdf["cc_mock_numerical_1_mean_800_wt"])

INFO:cityseer.metrics.layers:Computing statistics.
  0%|          | 0/294 [00:00<?, ?it/s]100%|██████████| 294/294 [00:01<00:00, 293.87it/s]100%|██████████| 294/294 [00:01<00:00, 293.62it/s]

0          99.438004
1          99.438004
2          99.438004
3          90.749001
4          99.438004
             ...    
53±0±54     1.913000
53±1±54     1.913000
53±2±54     1.913000
54±0±55     1.913000
54±1±55     1.913000
Name: cc_mock_numerical_1_max_800, Length: 294, dtype: float32
0          51.426273
1          53.213051
2          51.837532
3          49.952991
4          53.090729
             ...    
53±0±54     1.913000
53±1±54     1.913000
53±2±54     1.913000
54±0±55     1.913000
54±1±55     1.913000
Name: cc_mock_numerical_1_mean_800_wt, Length: 294, dtype: float32

The landuse metrics and statistical aggregations are computed over the street network relative to the network, with results written to each node. The mixed-use, accessibility, and statistical aggregations can therefore be compared directly to centrality computations from the same locations, and can be correlated or otherwise compared.

Data derived from metrics can be converted back into a NetworkX graph using the nx_from_cityseer_geopandas method.

nx_multigraph_round_trip = io.nx_from_cityseer_geopandas(
    nodes_gdf,
    edges_gdf,
)
nx_multigraph_round_trip.nodes["0"]

INFO:cityseer.tools.io:Populating node and edge map data to a networkX graph.
INFO:cityseer.tools.io:Unpacking node data.
0it [00:00, ?it/s]294it [00:00, 16011.08it/s]
INFO:cityseer.tools.io:Unpacking edge data.
0it [00:00, ?it/s]632it [00:00, 17712.15it/s]
INFO:cityseer.tools.io:Unpacking metrics to nodes.
0it [00:00, ?it/s]294it [00:00, 27352.34it/s]
0it [00:00, ?it/s]294it [00:00, 24022.55it/s]
0it [00:00, ?it/s]294it [00:00, 24175.61it/s]
0it [00:00, ?it/s]294it [00:00, 24707.48it/s]
0it [00:00, ?it/s]294it [00:00, 24989.37it/s]
0it [00:00, ?it/s]294it [00:00, 24824.36it/s]
0it [00:00, ?it/s]294it [00:00, 24438.17it/s]
0it [00:00, ?it/s]294it [00:00, 25177.64it/s]
0it [00:00, ?it/s]294it [00:00, 25335.94it/s]
0it [00:00, ?it/s]294it [00:00, 25347.92it/s]
0it [00:00, ?it/s]294it [00:00, 24326.32it/s]
0it [00:00, ?it/s]294it [00:00, 25046.72it/s]
0it [00:00, ?it/s]294it [00:00, 24743.67it/s]
0it [00:00, ?it/s]294it [00:00, 24914.64it/s]
0it [00:00, ?it/s]294it [00:00, 24953.97it/s]
0it [00:00, ?it/s]294it [00:00, 24100.01it/s]
0it [00:00, ?it/s]294it [00:00, 24563.76it/s]
0it [00:00, ?it/s]294it [00:00, 23841.87it/s]
0it [00:00, ?it/s]294it [00:00, 24368.14it/s]
0it [00:00, ?it/s]294it [00:00, 24583.35it/s]
0it [00:00, ?it/s]294it [00:00, 24350.82it/s]
0it [00:00, ?it/s]294it [00:00, 25282.95it/s]
0it [00:00, ?it/s]294it [00:00, 24707.48it/s]
0it [00:00, ?it/s]294it [00:00, 24391.28it/s]
0it [00:00, ?it/s]294it [00:00, 24722.34it/s]
0it [00:00, ?it/s]294it [00:00, 25092.59it/s]
0it [00:00, ?it/s]294it [00:00, 24608.37it/s]
0it [00:00, ?it/s]294it [00:00, 24559.36it/s]
0it [00:00, ?it/s]294it [00:00, 25080.35it/s]
0it [00:00, ?it/s]294it [00:00, 24910.62it/s]
0it [00:00, ?it/s]294it [00:00, 24593.65it/s]
0it [00:00, ?it/s]294it [00:00, 24298.04it/s]
0it [00:00, ?it/s]294it [00:00, 24610.33it/s]
0it [00:00, ?it/s]294it [00:00, 25296.44it/s]
0it [00:00, ?it/s]294it [00:00, 24951.95it/s]
0it [00:00, ?it/s]294it [00:00, 24786.94it/s]
0it [00:00, ?it/s]294it [00:00, 24806.38it/s]
0it [00:00, ?it/s]294it [00:00, 26348.27it/s]
0it [00:00, ?it/s]294it [00:00, 24007.11it/s]
0it [00:00, ?it/s]294it [00:00, 26267.45it/s]
0it [00:00, ?it/s]294it [00:00, 24552.02it/s]
0it [00:00, ?it/s]294it [00:00, 25803.54it/s]
0it [00:00, ?it/s]294it [00:00, 26516.54it/s]
0it [00:00, ?it/s]294it [00:00, 24829.36it/s]
0it [00:00, ?it/s]294it [00:00, 26592.60it/s]
0it [00:00, ?it/s]294it [00:00, 25393.33it/s]
0it [00:00, ?it/s]294it [00:00, 24938.83it/s]
0it [00:00, ?it/s]294it [00:00, 24407.21it/s]
0it [00:00, ?it/s]294it [00:00, 25194.62it/s]
0it [00:00, ?it/s]294it [00:00, 25036.55it/s]
0it [00:00, ?it/s]294it [00:00, 25512.06it/s]
0it [00:00, ?it/s]294it [00:00, 23820.68it/s]
0it [00:00, ?it/s]294it [00:00, 24729.77it/s]
0it [00:00, ?it/s]294it [00:00, 25515.75it/s]
0it [00:00, ?it/s]294it [00:00, 24504.21it/s]
0it [00:00, ?it/s]294it [00:00, 26588.01it/s]
0it [00:00, ?it/s]294it [00:00, 24566.21it/s]
0it [00:00, ?it/s]294it [00:00, 24692.14it/s]
0it [00:00, ?it/s]294it [00:00, 25854.40it/s]
0it [00:00, ?it/s]294it [00:00, 25957.26it/s]
0it [00:00, ?it/s]294it [00:00, 25297.99it/s]
0it [00:00, ?it/s]294it [00:00, 24579.43it/s]
0it [00:00, ?it/s]294it [00:00, 24563.27it/s]
0it [00:00, ?it/s]294it [00:00, 24661.52it/s]
0it [00:00, ?it/s]294it [00:00, 24847.37it/s]
0it [00:00, ?it/s]294it [00:00, 24707.48it/s]
0it [00:00, ?it/s]294it [00:00, 24780.46it/s]
0it [00:00, ?it/s]294it [00:00, 24532.00it/s]
0it [00:00, ?it/s]294it [00:00, 25198.74it/s]
0it [00:00, ?it/s]294it [00:00, 26116.13it/s]
0it [00:00, ?it/s]294it [00:00, 24205.51it/s]
0it [00:00, ?it/s]294it [00:00, 24978.74it/s]
0it [00:00, ?it/s]294it [00:00, 25803.54it/s]
0it [00:00, ?it/s]294it [00:00, 25558.06it/s]
0it [00:00, ?it/s]294it [00:00, 25241.03it/s]
0it [00:00, ?it/s]294it [00:00, 25450.45it/s]
0it [00:00, ?it/s]294it [00:00, 25470.96it/s]
0it [00:00, ?it/s]294it [00:00, 24389.35it/s]
0it [00:00, ?it/s]294it [00:00, 24257.89it/s]
0it [00:00, ?it/s]294it [00:00, 24198.38it/s]
0it [00:00, ?it/s]294it [00:00, 24480.37it/s]
0it [00:00, ?it/s]294it [00:00, 22490.80it/s]
0it [00:00, ?it/s]294it [00:00, 26887.15it/s]
0it [00:00, ?it/s]294it [00:00, 24474.06it/s]
0it [00:00, ?it/s]294it [00:00, 25018.77it/s]
0it [00:00, ?it/s]294it [00:00, 23419.41it/s]
0it [00:00, ?it/s]294it [00:00, 24645.26it/s]

{'x': 700700.0,
 'y': 5719700.0,
 'live': True,
 'weight': 1,
 'cc_seg_density_200': 857.3270263671875,
 'cc_seg_density_400': 3042.26025390625,
 'cc_seg_density_800': 10088.9873046875,
 'cc_seg_density_1600': 13137.7890625,
 'cc_seg_harmonic_200': 17.577617645263672,
 'cc_seg_harmonic_400': 24.706350326538086,
 'cc_seg_harmonic_800': 36.822689056396484,
 'cc_seg_harmonic_1600': 40.173213958740234,
 'cc_seg_beta_200': 159.83761596679688,
 'cc_seg_beta_400': 421.98443603515625,
 'cc_seg_beta_800': 1365.0115966796875,
 'cc_seg_beta_1600': 3582.89111328125,
 'cc_seg_betweenness_200': 590.8660278320312,
 'cc_seg_betweenness_400': 2805.017822265625,
 'cc_seg_betweenness_800': 23575.0,
 'cc_seg_betweenness_1600': 159337.875,
 'cc_hill_q0_200_nw': 4.0,
 'cc_hill_q0_200_wt': 0.2142721265554428,
 'cc_hill_q1_200_nw': 3.789292097091675,
 'cc_hill_q1_200_wt': 0.20572812855243683,
 'cc_hill_q2_200_nw': 3.5714285373687744,
 'cc_hill_q2_200_wt': 0.19956745207309723,
 'cc_hill_q0_400_nw': 9.0,
 'cc_hill_q0_400_wt': 1.1907039880752563,
 'cc_hill_q1_400_nw': 8.171717643737793,
 'cc_hill_q1_400_wt': 1.084071159362793,
 'cc_hill_q2_400_nw': 7.529411792755127,
 'cc_hill_q2_400_wt': 1.0111382007598877,
 'cc_hill_q0_800_nw': 9.0,
 'cc_hill_q0_800_wt': 3.055056571960449,
 'cc_hill_q1_800_nw': 8.061278343200684,
 'cc_hill_q1_800_wt': 2.7106282711029053,
 'cc_hill_q2_800_nw': 7.449613094329834,
 'cc_hill_q2_800_wt': 2.509385108947754,
 'cc_hill_q0_1600_nw': 10.0,
 'cc_hill_q0_1600_wt': 5.220044136047363,
 'cc_hill_q1_1600_nw': 9.228510856628418,
 'cc_hill_q1_1600_wt': 4.775951862335205,
 'cc_hill_q2_1600_nw': 8.672131538391113,
 'cc_hill_q2_1600_wt': 4.4679412841796875,
 'cc_a_200_nw': 0.0,
 'cc_a_200_wt': 0.0,
 'cc_a_400_nw': 2.0,
 'cc_a_400_wt': 0.050510115921497345,
 'cc_a_800_nw': 2.0,
 'cc_a_800_wt': 0.3162217140197754,
 'cc_a_1600_nw': 5.0,
 'cc_a_1600_wt': 1.0843467712402344,
 'cc_a_nearest_max_1600': 349.61199951171875,
 'cc_b_200_nw': 1.0,
 'cc_b_200_wt': 0.01839187555015087,
 'cc_b_400_nw': 1.0,
 'cc_b_400_wt': 0.13561664521694183,
 'cc_b_800_nw': 2.0,
 'cc_b_800_wt': 0.46969375014305115,
 'cc_b_1600_nw': 2.0,
 'cc_b_1600_wt': 0.9253296852111816,
 'cc_b_nearest_max_1600': 199.7923126220703,
 'cc_c_200_nw': 0.0,
 'cc_c_200_wt': 0.0,
 'cc_c_400_nw': 1.0,
 'cc_c_400_wt': 0.1017569750547409,
 'cc_c_800_nw': 4.0,
 'cc_c_800_wt': 0.39100760221481323,
 'cc_c_1600_nw': 5.0,
 'cc_c_1600_wt': 1.1247146129608154,
 'cc_c_nearest_max_1600': 228.5167999267578,
 'cc_mock_numerical_1_sum_800_nw': 1170.739013671875,
 'cc_mock_numerical_1_sum_800_wt': 211.98065185546875,
 'cc_mock_numerical_1_mean_800_nw': 41.81210708618164,
 'cc_mock_numerical_1_mean_800_wt': 51.426273345947266,
 'cc_mock_numerical_1_count_800_nw': 28.0,
 'cc_mock_numerical_1_count_800_wt': 4.122030258178711,
 'cc_mock_numerical_1_var_800_nw': 766.1062622070312,
 'cc_mock_numerical_1_var_800_wt': 5831.8525390625,
 'cc_mock_numerical_1_max_800': 99.43800354003906,
 'cc_mock_numerical_1_min_800': 0.4690000116825104,
 'cc_mock_numerical_1_sum_1600_nw': 2528.324951171875,
 'cc_mock_numerical_1_sum_1600_wt': 541.5323486328125,
 'cc_mock_numerical_1_mean_1600_nw': 51.59846878051758,
 'cc_mock_numerical_1_mean_1600_wt': 48.469390869140625,
 'cc_mock_numerical_1_count_1600_nw': 49.0,
 'cc_mock_numerical_1_count_1600_wt': 11.172666549682617,
 'cc_mock_numerical_1_var_1600_nw': 986.6461181640625,
 'cc_mock_numerical_1_var_1600_wt': 4370.0771484375,
 'cc_mock_numerical_1_max_1600': 99.43800354003906,
 'cc_mock_numerical_1_min_1600': 0.4690000116825104}