With these changes I can run make on my Mac and build ann, sparsehash, and contraction_hierarchies with Apple's clang compiler. I still cannot build the pyaccess extension, though, because clang does not support dllexport and dllimport used there. If we want to be able to build this without GNU gcc we'll have to take those out somehow.

Description of the bug

I am assigning network node_ids a to parcel data set and then running nearest_poi to find all of the parcels within a mile of a set of coordinates. I want to be able to re-run these queries without re-creating the network. However, If I use one set of coordinates, then a different set of coordinates whose buffer intersects with the first set, then run the first set again, I get a different number of parcels returned in the first and third query. Please see the code as it might be easier to understand.

I am pretty sure that this is not a copy of a reference problem (in my code) because I use df.copy() to make a copy of the original parcel dataframe in the get_nearest_parcels function before any modifications are made to it. Also, the reason I do not want to recreate the network after each query is to save time- I am prototyping a web service that uses pandana to generate geojson isochrones from a passed in set of coordinates. So ideally the network is loaded and the app is listening for coordinates to run the query. I noticed this behavior because the app started generating weird polygons when making multiple calls from the same area. I have added the network files below.

UPDATE: The parcel DataFrame has nothing to do with the error so I have updated the code for simplicity.

Thanks,

Stefan

Network data (optional)

https://file.ac/8UQg8JUbhvs/

Environment

• Operating system: Windows

• Python version: 2,7

• Pandana version: 0.2.0

• Pandana required packages versions (optional):

Paste the code that reproduces the issue here:

import pandana as pdna
import pandas as pd
import numpy as np

nodes_file_name = r'D:\Stefan\Isochrone\repository\data\all_streets_nodes_2014.csv'
links_file_name = r'D:\Stefan\Isochrone\repository\data\all_streets_links_2014.csv'

max_dist = 5280 

# nodes must be indexed by node_id column, which is the first column
nodes = pd.DataFrame.from_csv(nodes_file_name)
links = pd.DataFrame.from_csv(links_file_name, index_col = None )

# get rid of circular links
links = links.loc[(links.from_node_id <> links.to_node_id)]

# assign impedance
imp = pd.DataFrame(links.Shape_Length)
imp = imp.rename(columns = {'Shape_Length':'distance'})

# create pandana network
network = pdna.network.Network(nodes.x, nodes.y, links.from_node_id, links.to_node_id, imp)

network.init_pois(1, max_dist, 1)

def get_nearest_nodes(x,y):
    print 'Getting data'
    x = pd.Series(x)
    y = pd.Series(y)
    #Set as a point of interest on the pandana network
    network.set_pois('tstop', x, y)
    #Find distance to point from all nodes, everything over max_dist gets a value of 99999
    res = network.nearest_pois(max_dist, 'tstop', num_pois=1, max_distance=99999)
    res = (res[res <> 99999]/5280.).astype(res.dtypes) # convert to miles
    return res 


#### ****Re-Run above code for each test**** #####

##### TEST 1 #####
# Same coordinates, same result
test1 = get_nearest_nodes(1272010.0, 228327.0)
print len(test1[(test1[1] > 0)])
test2 = get_nearest_nodes(1272010.0, 228327.0)
print len(test2[(test2[1] > 0)])

##### TEST 2- this shows the potential bug #####
# First and Third coordinates are the same but give different result. 
# The second set of coordinates are within the buffer distance of the first/third. 
test1 = get_nearest_nodes(1272010.0, 228327.0)
print len(test1[(test1[1] > 0)])
test2 = get_nearest_nodes(1268830.0, 228417.0)
print len(test2[(test2[1] > 0)])
# Same coords as the first call, but yields different results
test3 = get_nearest_nodes(1272010.0, 228327.0)
print len(test3[(test3[1] > 0)])

##### TEST 3 #####
# First and third coordinates are the same and give the same result. 
# The second set of coordinates are outside the buffer distance of the first/third.
test1 = get_nearest_nodes(1272010.0, 228327.0)
print len(test1[(test1[1] > 0)])
# These coords are outside the buffered area as the first call. 
test2 = get_nearest_nodes(1264180.0, 193485.0)
print len(test2[(test2[1] > 0)])
# Same coords and same results as the first call.
test3 = get_nearest_nodes(1272010.0, 228327.0)
print len(test3[(test3[1] > 0)])

Paste the error message (if applicable):

# place error message here

I ran into this problem while running an instance of bayarea_urbansim using my own network where the node ids were OSM node IDs. A lot of digging led me to identify net.set() as the source of my problems. Network.set() relies on this class method when relating the node IDs of the network to the node IDs of the variable that is being set. The problem is that this function, self._node_indexes(), in turn relies on a merge of the node IDs from the variable in question with the node indices of this class object, self.node_idx, which for some reason is defined as a NumPy arange(). Thus, if the node IDs of the variable you wish to compute with Network.set() are not themselves sequentially ordered integers a-la a NumPy arange(), the network will not be able to find any matching POI's, which is precisely the problem that I was encountering. I'm sure there is some reason why self.node_idx is defined the way it is, but without knowing the rationale I don't know whether it makes more sense to implement a fix or to instead update the documentation to reflect the requirement that network node IDs be sequentially ordered IDs.

I have applied the .nearest_pois function to find out how well connected nodes within a network are in relation to their nearest hospital. I got positive results so far and stored the results in a data frame and .csv. However, for every poi (1-10) with an output distance, I am also interested in retrieving the ID of the hospital that this corresponds to in the cases where it found a point located within my threshold distance of 2000 m (See relevant bits of my code below). I.e. if this is my current output (data frame):

node id 1 2 3 [dist] 600 800 2000

I'd like a corresponding output (data frame) with: node id 1 2 3 hosp1 hosp2 N/A ..

Would you be able to help? I looked at the function definitions in the network.py file to identify if there is another function or local variable within an existing function that returns such output.

Relevant bits of the code:

Initialise the network with the point of interest queries:

network.init_pois(num_categories=1,max_dist=2000,max_pois=10)

network.set_pois('hospitals',nodes['lon'],nodes['lat'])

Perform point of interest queries - I would like to obtain the node_ids

df = network.nearest_pois(2000,"hospitals",num_pois=10)

I am running 64-bit Windows 8.1 with python 2.7 and have installed pandana 0.1.2 with the following code:

conda config --add channels synthicity conda install pandana

pandana imports fine with:

import pandana

but it seems the loader scripts were not installed correctly. I get the following error running:

from pandana.loaders import osm ImportError: No module named loaders

Checking the pandana package directory in anaconda: C:\Anaconda\pkgs\pandana-0.1.2-py27_0 there are no loader subfolder or scripts.

As a work around, I tried installing pandana via the github zipfile and installation gets hung up when building _pyaccess. See below:

Any ideas on the issue or potential solutions?

A couple of modifications were done to support Python 3.x. It was tested with Python 3.5 and Python 2.7 for backwards compatibility, running the full set of tests of the library.

It's difficult to guarantee that no performance differences were introduced, but functionality seems not to be affected.

I am running 64-bit Windows 7 with python 2.7.11 and have installed pandana 0.2.0 via pip - this is a new install of pandana on a machine that has never had it. When I import pandana I receive the following error, any ideas on what may be wrong here?:

import pandana as pdna

ImportError Traceback (most recent call last) in () ----> 1 import pandana as pdna

C:\Users\samb\Anaconda2\lib\site-packages\pandana__init__.py in () ----> 1 from network import Network 2 3 version = version = '0.2.0'

C:\Users\samb\Anaconda2\lib\site-packages\pandana\network.py in () 8 import pandas as pd 9 ---> 10 from . import _pyaccess 11 from .loaders import pandash5 as ph5 12

ImportError: DLL load failed: The application has failed to start because its side-by-side configuration is incorrect. Please see the application event log or use the command-line sxstrace.exe tool for more detail.

This PR removes the need to create an initial set of POIIndex entries.

To achieve that, the POIIndex data structure was converted to a std::map with std::string keys.

The init_pois function is still in place because it's also used to define the max_dist and max_pois parameters. We should decide soon if we want to move those definitions to another method.

#I read in the documentation that this is already implemented on the C++ side? I was curious what the most current information on shapefile/geodatabase import is? A lot of analysis requires custom edge weights based on prior analysis on the network. I was reviewing NetworkX implementation of the graph network importer, but it is pure Python implementation that has been shown to be slower relative to IGraph/graph-tool. Questions about the implementation: Does the C++ shapefile import functionality allow import of networks that have connections based on vertices along with line end points? Or just end points? What are the dependencies on the C++ implementation on import? Depending on where this was on your priority queue I was thinking about implementing something myself. Any thoughts or updates on this would be great.

Thanks for this package!

I only have one problem with it: at the top of network.py, you are setting

matplotlib.use('Agg')

According to the comment, this is to fix Travis. I guess you are switching to a backend that doesn't need an X server. However, this can be very disruptive to anybody importing your library, e.g. in a Jupyter notebook, where plots stop appearing:

UserWarning: Matplotlib is currently using agg, which is a non-GUI backend,
so cannot show the figure

It took me quite a while to find out that this line from pandana was the culprit. Please remove it.

If it's just about testing on Travis, you can just set the display, it works well, I do it too.

Thanks!

attempting to run conda update pandana gives me

# All requested packages already installed.
# packages in environment at C:\Anaconda2:
#
pandana                   0.1.2                    py27_0    synthicity

Looks like 0.2.0 was never loaded on conda for windows.

Description of the bug

PLotting with Pandana/UrbanAccess doesn't properly format title when calling .set_title

GTFS feed or OSM data (optional)

bbox = [43.435966,-80.682529,43.528884,-80.418858]

Environment

• Operating system: Windows

• Python version: 3.9.7

Paste the code that reproduces the issue here:

n = 1
bmap, fig, ax = network.plot(access[n], bbox=bbox, plot_kwargs=plot_kwargs, fig_kwargs=fig_kwargs, 
                            )
ax.set_axis_bgcolor('k')
ax.set_title('Walking distance (m) to nearest amenity around Waterloo', fontsize=15)

Paste the error message (if applicable):

No error but this happens:

Description of the bug

I am encountering incorrect shortest path solutions when using the Network.shortest_path (and Network.shortest_paths) method on a network with impedance values of small or large (though still reasonable) orders of magnitude. I have included a very simple toy example below that captures the problem. Essentially, when the impedance values are scaled to a sufficiently small order of magnitude (by experiment seems to be ~1e-4) or large order of magnitude (by experiment seems to be ~1e7), the shortest path solution is no longer correct (and, incidentally, appears to revert to a solution that traverses the least number of nodes, rather than minimizing total impedance, though my example doesn't explore this aspect of the problem).

Environment

• Operating system: Windows 10 Enterprise

• Python version: 3.9.10

• Pandana version: 0.6.1

Paste the code that reproduces the issue here:

import numpy as np
import pandana as pdna
import pandas as pd


nodes = [1, 2, 3, 4, 5]
nodes = pd.DataFrame(
    np.random.uniform(size=(5, 2)), columns=["x", "y"], index=nodes
)

edges = pd.DataFrame(
    [
        [1, 2, 0.001],
        [2, 3, 0.001],
        [3, 4, 0.001],
        [1, 5, 0.002],
        [5, 4, 0.002],
    ],
    columns=["from_node", "to_node", "weight"]
)

net = pdna.Network(nodes["x"], nodes["y"], edges["from_node"], edges["to_node"], edges[["weight"]], twoway=False)

net.shortest_path(1, 4)

>>> array([1, 2, 3, 4], dtype=int64)

The above example produces the expected solution.

Now, use exactly the same nodes and edges, but scale the impedance values down by a factor of 10:

net = pdna.Network(nodes["x"], nodes["y"], edges["from_node"], edges["to_node"], edges[["weight"]]  / 10, twoway=False)

net.shortest_path(1, 4)

>>> array([1, 5, 4], dtype=int64)

In the second example, clearly the more expensive and incorrect route has been chosen. The same behavior is observed at the larger end of impedance values also: for example, using the above example, when the impedance values are 1e7 instead .0001, and 2e7 instead of .0002, the same behavior occurs. I'm at a loss as to why this is happening?

Thank you for your help!

Description of the bug

Attempting to install pandana on python 3.10.x with pip fails because it requires tables>=3.1, <3.7; which is not supported through pip on python 3.10 (see: https://github.com/PyTables/PyTables/issues/909)

Environment

• Operating system: Ubuntu 22.04

• Python version: 3.10.4

• Pandana version: (attempting to install) 0.6.1

• Pandana required packages versions (optional): tables==3.6.1

Paste the code that reproduces the issue here:

pip install pandana==0.6.1

Paste the error message (if applicable):

error: legacy-install-failure

× Encountered error while trying to install package.
╰─> tables

note: This is an issue with the package mentioned above, not pip.
hint: See above for output from the failure.

Hi,

I'm having a little of trouble trying to use Pandana with multiprocessing

Description of the bug

When I call net.shortest_paths (with an 's') in a multiprocessing process (I use a multiprocessing.Pool object), it doesn't finish like an infinite loop (no error message). I tested to do the same with net.shortest_path (without an 's') and it worked! However I have to use shortest_paths because it is faster in my case. I wanted to know if there is an explanation to this.

Network data (optional)

OpenStreetMap Data

Environment

Mac OS 11.2.1 Python 3.9.7 Pandana 0.6.1

Paste the code that reproduces the issue here:

from multiprocessing import Pool

n_cores = 3

def f(n_repet): return [net.shortest_paths([node_0_id], [node_1_id]) for i in tqdm(range(n_repet))]

p = Pool(n_cores) a = p.map(f, [10 for i in range(10)])

Thanks for your help!

I am initializing a pandana network for Canada roads network. My hdf5 file is just under 200mb and the number of edges is around 2.2 million. Been running the code below for almost 5 hrs and it's still on going.

I am quite new to this domain and am wondering if anyone can give me suggestions on speeding up the computation. Would it be possible to implement multiprocessing here? Or should I break the roads network into something smaller like census divisions or provinces and somehow merge them back together, would that make it run faster?

Thanks in advance !

Environment

• Windows 10
• Operating system: 64-bit operating system, x64-based processor
• Processor: Intel(R) Core(TM) i5-1035G4 CPU @ 1.10GHz 1.50 GHz
• 16GB RAM, 4 CPU core
• Python version: 3.9.7
• Pandana version: 0.6.1

network = pdna.Network(nodes.x, nodes.y, edges['from'], edges['to'], edges[['dist']], twoway=False)
network.precompute(distance + 1)

In my city there are many points of interest that are not represented as nodes in OpenStreetMap, but rather ways around a building area. I usually deal with this by taking the centroids of relevant closed ways and treating them as nodes.

I wrote a simple addition to the OSM loader tonight that uses a "way_query" to download ways using the Overpass output option 'center': "adds the center of the object's boundingbox to the output, not guaranteed to be on the object's area." I think this would work fine for the cases I am looking at. It might introduce inaccuracy for large or oddly shaped POIs (if someone requested parks, for example).

Is this something wanted in pandana? Should I raise a PR?