Skip to content

graph

This module manages graph network representing roads from openstreet data.

Examples:

>>> from shift.graph import RoadNetworkFromPlace
>>> graph = RoadNetworkFromPlace('chennai, india')
>>> graph.get_network()

OpenStreetRoadNetwork

Bases: ABC

Interface for getting road network from OpenStreet data

Attributes:

Name Type Description
updated_network nx.Graph

Graph of road network with udpated metadata

Raises:

Type Description
AttributeDoesNotExistError

If graph attribute does not already exist.
Source code in shift\graph.py 
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
class OpenStreetRoadNetwork(ABC):
    """Interface for getting road network from OpenStreet data

    Attributes:
        updated_network (nx.Graph): Graph of road network with udpated metadata

    Raises:
        AttributeDoesNotExistError: If `graph` attribute does not already exist.
    """

    def get_network(self, node_append_str=Union[str, None]) -> nx.Graph:
        """Returns a minimum spanning tree with updated metadata.

        Args:
            node_append_str (Union[str, None]): String to append in the
                name of all nodes
        """

        if hasattr(self, "graph"):
            # Converting diected graph to undirected graph
            network = self.graph.to_undirected()

            # Find a minimum spanning tree of the network
            network = nx.minimum_spanning_tree(network)

            if node_append_str:
                network = nx.relabel_nodes(
                    network,
                    {n: str(n) + node_append_str for n in network.nodes()},
                )

            self.updated_network = nx.Graph()
            for node in network.nodes.data():
                # x is longitude and y is latitude
                self.updated_network.add_node(
                    node[0],
                    pos=(node[1]["x"], node[1]["y"]),
                    type="node",
                    data=node[1],
                )
            for edge in network.edges():
                self.updated_network.add_edge(edge[0], edge[1], type="edge")

            return self.updated_network
        else:
            raise AttributeDoesNotExistError(
                "'graph' attribute does not exist yet \
                for OpenStreet type road netwwork!"
            )

get_network(node_append_str=Union[str, None])

Returns a minimum spanning tree with updated metadata.

Parameters:

Name Type Description Default
node_append_str Union[str, None]

String to append in the name of all nodes

 Union[str, None]
Source code in shift\graph.py 
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
def get_network(self, node_append_str=Union[str, None]) -> nx.Graph:
    """Returns a minimum spanning tree with updated metadata.

    Args:
        node_append_str (Union[str, None]): String to append in the
            name of all nodes
    """

    if hasattr(self, "graph"):
        # Converting diected graph to undirected graph
        network = self.graph.to_undirected()

        # Find a minimum spanning tree of the network
        network = nx.minimum_spanning_tree(network)

        if node_append_str:
            network = nx.relabel_nodes(
                network,
                {n: str(n) + node_append_str for n in network.nodes()},
            )

        self.updated_network = nx.Graph()
        for node in network.nodes.data():
            # x is longitude and y is latitude
            self.updated_network.add_node(
                node[0],
                pos=(node[1]["x"], node[1]["y"]),
                type="node",
                data=node[1],
            )
        for edge in network.edges():
            self.updated_network.add_edge(edge[0], edge[1], type="edge")

        return self.updated_network
    else:
        raise AttributeDoesNotExistError(
            "'graph' attribute does not exist yet \
            for OpenStreet type road netwwork!"
        )

RoadNetworkFromPlace

Bases: OpenStreetRoadNetwork

Getting road network from a place address within bounding box.

Attributes:

Name Type Description
place str

string representing location
max_dist float

Distance to be used to create bounding box around a point
dist_type str

Type of region to be created around the point
network_type str

Type of network to be retrived from openstreet data
Source code in shift\graph.py 
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
class RoadNetworkFromPlace(OpenStreetRoadNetwork):
    """Getting road network from a place address within bounding box.

    Attributes:
        place (str): string representing location
        max_dist (float): Distance to be used to create
            bounding box around a point
        dist_type (str): Type of region to be
            created around the point
        network_type (str): Type of network to be
            retrived from openstreet data
    """

    def __init__(
        self,
        place: str,
        max_dist: float = 1000,
        dist_type: str = "bbox",
        network_type: str = "drive",
    ) -> None:
        """Constructor for `RoadNetworkFromPlace` class.

        Args:
            place (str): string representing location
            max_dist (float): Distance to be used to create
                bounding box around a point
            dist_type (str): Type of region to be created around the point
            network_type (str): Type of network to be retrived
                from openstreet data
        """
        # e.g. Chennai, India
        self.place = place
        self.max_dist = max_dist
        self.dist_type = dist_type
        self.network_type = network_type

    def get_network(self, node_append_str: Union[str, None] = None) -> nx.Graph:
        """Refer to base class for more details."""
        self.graph = ox.graph.graph_from_address(
            self.place,
            dist=self.max_dist,
            dist_type=self.dist_type,
            network_type=self.network_type,
        )
        super().get_network(node_append_str)

__init__(place, max_dist=1000, dist_type='bbox', network_type='drive')

Constructor for RoadNetworkFromPlace class.

Parameters:

Name Type Description Default
place str

string representing location

 required
max_dist float

Distance to be used to create bounding box around a point

 1000
dist_type str

Type of region to be created around the point

 'bbox'
network_type str

Type of network to be retrived from openstreet data

 'drive'
Source code in shift\graph.py 
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
def __init__(
    self,
    place: str,
    max_dist: float = 1000,
    dist_type: str = "bbox",
    network_type: str = "drive",
) -> None:
    """Constructor for `RoadNetworkFromPlace` class.

    Args:
        place (str): string representing location
        max_dist (float): Distance to be used to create
            bounding box around a point
        dist_type (str): Type of region to be created around the point
        network_type (str): Type of network to be retrived
            from openstreet data
    """
    # e.g. Chennai, India
    self.place = place
    self.max_dist = max_dist
    self.dist_type = dist_type
    self.network_type = network_type

get_network(node_append_str=None)

Refer to base class for more details.

Source code in shift\graph.py 
187
188
189
190
191
192
193
194
195
def get_network(self, node_append_str: Union[str, None] = None) -> nx.Graph:
    """Refer to base class for more details."""
    self.graph = ox.graph.graph_from_address(
        self.place,
        dist=self.max_dist,
        dist_type=self.dist_type,
        network_type=self.network_type,
    )
    super().get_network(node_append_str)

RoadNetworkFromPoint

Bases: OpenStreetRoadNetwork

Getting road network from single point within bounding box.

Attributes:

Name Type Description
point tuple

(longitude, latitude) pair representing point location
max_dist float

Distance to be used to create bounding box around a point
dist_type str

Type of region to be created around the point
network_type str

Type of network to be retrived from openstreet data
Source code in shift\graph.py 
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
class RoadNetworkFromPoint(OpenStreetRoadNetwork):
    """Getting road network from single point within bounding box.

    Attributes:
        point (tuple): (longitude, latitude) pair representing
            point location
        max_dist (float): Distance to be used to create bounding
            box around a point
        dist_type (str): Type of region to be created around the point
        network_type (str): Type of network to be retrived from
            openstreet data
    """

    def __init__(
        self,
        point: tuple,
        max_dist: float = 1000,
        dist_type: str = "bbox",
        network_type: str = "drive",
    ) -> None:
        """Constructor for `RoadNetworkFromPoint` class.

        Args:
            point (tuple): (longitude, latitude) pair representing
                point location
            max_dist (float): Distance to be used to create
                bounding box around a point
            dist_type (str): Type of region to be created
                around the point
            network_type (str): Type of network to be retrived
                from openstreet data
        """

        # e.g. (13.242134, 80.275948)
        self.point = point
        self.max_dist = max_dist
        self.dist_type = dist_type
        self.network_type = network_type

    def get_network(self, node_append_str: Union[str, None] = None) -> nx.Graph:
        """Refer to base class for more details."""
        self.graph = ox.graph.graph_from_point(
            self.point,
            dist=self.max_dist,
            dist_type=self.dist_type,
            network_type=self.network_type,
        )
        super().get_network(node_append_str)

__init__(point, max_dist=1000, dist_type='bbox', network_type='drive')

Constructor for RoadNetworkFromPoint class.

Parameters:

Name Type Description Default
point tuple

(longitude, latitude) pair representing point location

 required
max_dist float

Distance to be used to create bounding box around a point

 1000
dist_type str

Type of region to be created around the point

 'bbox'
network_type str

Type of network to be retrived from openstreet data

 'drive'
Source code in shift\graph.py 
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
def __init__(
    self,
    point: tuple,
    max_dist: float = 1000,
    dist_type: str = "bbox",
    network_type: str = "drive",
) -> None:
    """Constructor for `RoadNetworkFromPoint` class.

    Args:
        point (tuple): (longitude, latitude) pair representing
            point location
        max_dist (float): Distance to be used to create
            bounding box around a point
        dist_type (str): Type of region to be created
            around the point
        network_type (str): Type of network to be retrived
            from openstreet data
    """

    # e.g. (13.242134, 80.275948)
    self.point = point
    self.max_dist = max_dist
    self.dist_type = dist_type
    self.network_type = network_type

get_network(node_append_str=None)

Refer to base class for more details.

Source code in shift\graph.py 
140
141
142
143
144
145
146
147
148
def get_network(self, node_append_str: Union[str, None] = None) -> nx.Graph:
    """Refer to base class for more details."""
    self.graph = ox.graph.graph_from_point(
        self.point,
        dist=self.max_dist,
        dist_type=self.dist_type,
        network_type=self.network_type,
    )
    super().get_network(node_append_str)

RoadNetworkFromPolygon

Bases: OpenStreetRoadNetwork

Getting road network from a given polygon.

Attributes:

Name Type Description
polygon List[list]

List of (lon, lat) pairs
custom_filter str

Valid osmnx type customer filter to be applied
Source code in shift\graph.py 
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
class RoadNetworkFromPolygon(OpenStreetRoadNetwork):
    """Getting road network from a given polygon.

    Attributes:
        polygon (List[list]): List of (lon, lat) pairs
        custom_filter (str): Valid osmnx type customer filter to be applied
    """

    def __init__(
        self, polygon: List[list], custom_filter: str = '["highway"]'
    ) -> None:
        """Constructor for `RoadNetworkFromPolygon` class.

        Args:
            polygon (List[list]): List of (lon, lat) pairs
            custom_filter (str): Valid osmnx type customer filter to be applied
        """

        # e.g. [[13.242134, 80.275948]]
        self.polygon = polygon
        self.custom_filter = custom_filter

    def get_network(self, node_append_str: Union[str, None] = None) -> nx.Graph:
        """Refer to base class for more details."""

        polygon = shapely.geometry.Polygon(self.polygon)
        self.graph = ox.graph.graph_from_polygon(
            polygon, custom_filter=self.custom_filter
        )
        super().get_network(node_append_str)

__init__(polygon, custom_filter='["highway"]')

Constructor for RoadNetworkFromPolygon class.

Parameters:

Name Type Description Default
polygon List[list]

List of (lon, lat) pairs

 required
custom_filter str

Valid osmnx type customer filter to be applied

 '["highway"]'
Source code in shift\graph.py 
206
207
208
209
210
211
212
213
214
215
216
217
218
def __init__(
    self, polygon: List[list], custom_filter: str = '["highway"]'
) -> None:
    """Constructor for `RoadNetworkFromPolygon` class.

    Args:
        polygon (List[list]): List of (lon, lat) pairs
        custom_filter (str): Valid osmnx type customer filter to be applied
    """

    # e.g. [[13.242134, 80.275948]]
    self.polygon = polygon
    self.custom_filter = custom_filter

get_network(node_append_str=None)

Refer to base class for more details.

Source code in shift\graph.py 
220
221
222
223
224
225
226
227
def get_network(self, node_append_str: Union[str, None] = None) -> nx.Graph:
    """Refer to base class for more details."""

    polygon = shapely.geometry.Polygon(self.polygon)
    self.graph = ox.graph.graph_from_polygon(
        polygon, custom_filter=self.custom_filter
    )
    super().get_network(node_append_str)