Skip to content

visualization.plot_graph

Module for handling graph plots.

AbstractGraphPlot

Bases: abc.ABC

Abstract interface for developing subclass to plot network graph.

Source code in erad\visualization\plot_graph.py 
19
20
21
22
23
24
25
26
27
28
class AbstractGraphPlot(abc.ABC):
    """Abstract interface for developing subclass to plot network graph."""

    @abc.abstractmethod
    def add_network_data(self, *args, **kwargs):
        """Abstract method for adding network data."""

    @abc.abstractmethod
    def prepare_plot(self, *args, **kwargs):
        """Abstract method for preparing and showing teh plot"""

add_network_data(*args, **kwargs) abstractmethod

Abstract method for adding network data.

Source code in erad\visualization\plot_graph.py 
22
23
24
@abc.abstractmethod
def add_network_data(self, *args, **kwargs):
    """Abstract method for adding network data."""

prepare_plot(*args, **kwargs) abstractmethod

Abstract method for preparing and showing teh plot

Source code in erad\visualization\plot_graph.py 
26
27
28
@abc.abstractmethod
def prepare_plot(self, *args, **kwargs):
    """Abstract method for preparing and showing teh plot"""

PloltyGraph

Bases: AbstractGraphPlot

Class for managing graph plot using Plotly.

Attributes:

Name Type Description
access_token str

MapBox API token
style str

MapBox style
zoom_level int

Zoom level for the plot
data List

Stores the data to be fed to plotly for plotting
scatter_data Dict

Stores longitudes and latitudes of nodes from network
fig go.Figure

Plotly graph objects figure instance
Source code in erad\visualization\plot_graph.py 
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 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
 99
100
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
149
150
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
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
class PloltyGraph(AbstractGraphPlot):
    """Class for managing graph plot using Plotly.

    Attributes:
        access_token (str): MapBox API token
        style (str): MapBox style
        zoom_level (int): Zoom level for the plot
        data (List): Stores the data to be fed to plotly for plotting
        scatter_data (Dict): Stores longitudes and latitudes of nodes
            from network
        fig (go.Figure): Plotly graph objects figure instance
    """

    def __init__(
        self,
        access_token: str = None,
        style: str = "carto-darkmatter",
        zoom_level: int = 13,
    ) -> None:
        """Constructor for `PlotlyGraph` Subclass.

        Args:
            access_token (str): MapBox API token
            style (str): MapBox style
            zoom_level (int): Zoom level for the plot
        """

        if access_token:
            self.access_token = access_token
        else:
            self.access_token = os.getenv("MAPBOX_API_KEY")
        self.style = style
        self.zoom_level = zoom_level

        self.data = []

    def _get_map_centre(self, longitudes: List[float], latitudes: List[float]):
        """Returns map center."""
        return {
            "lon": sum(longitudes) / len(longitudes),
            "lat": sum(latitudes) / len(latitudes),
        }

    def add_network_data(
        self,
        network: nx.Graph,
        latitude_property: str = "lat",
        longitude_property: str = "long",
        node_color: str = "blue",
        line_color: str = "red",
    ) -> None:
        """Method to add network data to plot data.

        Args:
            network (nx.Graph): Networkx graph instance
            latitude_property (str): Property name to be
                used as latitude
            longitude_property (str): Property name to be
                used as longitude
            node_color (str): Color name to be used to plot
                nodes
            line_color (str): Color name to be used to plot
                line segments
        """

        # Add nodes
        self.scatter_data = {"latitudes": [], "longitudes": []}

        for node in network.nodes.data():

            # Storing the lat lons in scatter data
            # container
            self.scatter_data["latitudes"].append(node[1][latitude_property])
            self.scatter_data["longitudes"].append(node[1][longitude_property])

        # Stroing the edge data in container
        line_data = {"latitudes": [], "longitudes": []}
        node_data = {node[0]: node[1] for node in network.nodes.data()}

        for edge in network.edges():
            line_data["latitudes"].extend(
                [
                    node_data[edge[0]][latitude_property],
                    node_data[edge[1]][latitude_property],
                    None,
                ]
            )

            line_data["longitudes"].extend(
                [
                    node_data[edge[0]][longitude_property],
                    node_data[edge[1]][longitude_property],
                    None,
                ]
            )

        # Adding plots to plotly graph object
        self.data.append(
            go.Scattermapbox(
                mode="markers",
                lon=self.scatter_data["longitudes"],
                lat=self.scatter_data["latitudes"],
                marker={"size": 5, "color": node_color},
            )
        )

        self.data.append(
            go.Scattermapbox(
                mode="markers+lines",
                lon=line_data["longitudes"],
                lat=line_data["latitudes"],
                marker={"size": 0},
                line={"color": line_color},
            )
        )

    def add_scatter_points(
        self,
        latitudes: List[float],
        longitudes: List[float],
        color: str = "yellow",
        size: int = 5,
    ) -> None:
        """Method for scatter points to plot data.

        Args:
            latitudes (List[float]): List of latitude points
            longitudes (List[float]): List of longitude points
            color (str): Color to be used for scatter points
            size (int): Size of scatter points
        """

        self.data.append(
            go.Scattermapbox(
                mode="markers",
                lon=longitudes,
                lat=latitudes,
                marker={"size": size, "color": color},
            )
        )

    def add_polygon(
        self,
        latitudes: List[float],
        longitudes: List[float],
        fill: str = "toself",
    ) -> None:
        """Method for adding polygon to the plot.

        Args:
            latitudes (List[float]): List of latitude points
            longitudes (List[float]): List of longitude points
            fill (str): Accepted fill value by plotly
        """
        self.data.append(
            go.Scattermapbox(
                lon=longitudes, lat=latitudes, fill=fill, mode="lines"
            )
        )

    def prepare_plot(self, show: bool = True):
        """Method to prepare and show the plot.

        Args:
            show (bool): True if want to see the plot.
        """
        self.fig = go.Figure(data=self.data)
        self.fig.update_layout(margin={"r": 0, "t": 0, "l": 0, "b": 0})
        self.fig.update_mapboxes(
            {
                "accesstoken": self.access_token,
                "style": self.style,
                "center": self._get_map_centre(
                    self.scatter_data["longitudes"],
                    self.scatter_data["latitudes"],
                ),
                "zoom": self.zoom_level,
            }
        )

        if show:
            self.fig.show()

    def html_export(self, html_file_path: str):
        """Method for exporting plot as HTML file."""
        path_validation(html_file_path)
        self.fig.write_html(html_file_path)

__init__(access_token=None, style='carto-darkmatter', zoom_level=13)

Constructor for PlotlyGraph Subclass.

Parameters:

Name Type Description Default
access_token str

MapBox API token

 None
style str

MapBox style

 'carto-darkmatter'
zoom_level int

Zoom level for the plot

 13
Source code in erad\visualization\plot_graph.py 
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
def __init__(
    self,
    access_token: str = None,
    style: str = "carto-darkmatter",
    zoom_level: int = 13,
) -> None:
    """Constructor for `PlotlyGraph` Subclass.

    Args:
        access_token (str): MapBox API token
        style (str): MapBox style
        zoom_level (int): Zoom level for the plot
    """

    if access_token:
        self.access_token = access_token
    else:
        self.access_token = os.getenv("MAPBOX_API_KEY")
    self.style = style
    self.zoom_level = zoom_level

    self.data = []

add_network_data(network, latitude_property='lat', longitude_property='long', node_color='blue', line_color='red')

Method to add network data to plot data.

Parameters:

Name Type Description Default
network nx.Graph

Networkx graph instance

 required
latitude_property str

Property name to be used as latitude

 'lat'
longitude_property str

Property name to be used as longitude

 'long'
node_color str

Color name to be used to plot nodes

 'blue'
line_color str

Color name to be used to plot line segments

 'red'
Source code in erad\visualization\plot_graph.py 
 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
 99
100
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
def add_network_data(
    self,
    network: nx.Graph,
    latitude_property: str = "lat",
    longitude_property: str = "long",
    node_color: str = "blue",
    line_color: str = "red",
) -> None:
    """Method to add network data to plot data.

    Args:
        network (nx.Graph): Networkx graph instance
        latitude_property (str): Property name to be
            used as latitude
        longitude_property (str): Property name to be
            used as longitude
        node_color (str): Color name to be used to plot
            nodes
        line_color (str): Color name to be used to plot
            line segments
    """

    # Add nodes
    self.scatter_data = {"latitudes": [], "longitudes": []}

    for node in network.nodes.data():

        # Storing the lat lons in scatter data
        # container
        self.scatter_data["latitudes"].append(node[1][latitude_property])
        self.scatter_data["longitudes"].append(node[1][longitude_property])

    # Stroing the edge data in container
    line_data = {"latitudes": [], "longitudes": []}
    node_data = {node[0]: node[1] for node in network.nodes.data()}

    for edge in network.edges():
        line_data["latitudes"].extend(
            [
                node_data[edge[0]][latitude_property],
                node_data[edge[1]][latitude_property],
                None,
            ]
        )

        line_data["longitudes"].extend(
            [
                node_data[edge[0]][longitude_property],
                node_data[edge[1]][longitude_property],
                None,
            ]
        )

    # Adding plots to plotly graph object
    self.data.append(
        go.Scattermapbox(
            mode="markers",
            lon=self.scatter_data["longitudes"],
            lat=self.scatter_data["latitudes"],
            marker={"size": 5, "color": node_color},
        )
    )

    self.data.append(
        go.Scattermapbox(
            mode="markers+lines",
            lon=line_data["longitudes"],
            lat=line_data["latitudes"],
            marker={"size": 0},
            line={"color": line_color},
        )
    )

add_polygon(latitudes, longitudes, fill='toself')

Method for adding polygon to the plot.

Parameters:

Name Type Description Default
latitudes List[float]

List of latitude points

 required
longitudes List[float]

List of longitude points

 required
fill str

Accepted fill value by plotly

 'toself'
Source code in erad\visualization\plot_graph.py 
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
def add_polygon(
    self,
    latitudes: List[float],
    longitudes: List[float],
    fill: str = "toself",
) -> None:
    """Method for adding polygon to the plot.

    Args:
        latitudes (List[float]): List of latitude points
        longitudes (List[float]): List of longitude points
        fill (str): Accepted fill value by plotly
    """
    self.data.append(
        go.Scattermapbox(
            lon=longitudes, lat=latitudes, fill=fill, mode="lines"
        )
    )

add_scatter_points(latitudes, longitudes, color='yellow', size=5)

Method for scatter points to plot data.

Parameters:

Name Type Description Default
latitudes List[float]

List of latitude points

 required
longitudes List[float]

List of longitude points

 required
color str

Color to be used for scatter points

 'yellow'
size int

Size of scatter points

 5
Source code in erad\visualization\plot_graph.py 
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
def add_scatter_points(
    self,
    latitudes: List[float],
    longitudes: List[float],
    color: str = "yellow",
    size: int = 5,
) -> None:
    """Method for scatter points to plot data.

    Args:
        latitudes (List[float]): List of latitude points
        longitudes (List[float]): List of longitude points
        color (str): Color to be used for scatter points
        size (int): Size of scatter points
    """

    self.data.append(
        go.Scattermapbox(
            mode="markers",
            lon=longitudes,
            lat=latitudes,
            marker={"size": size, "color": color},
        )
    )

html_export(html_file_path)

Method for exporting plot as HTML file.

Source code in erad\visualization\plot_graph.py 
214
215
216
217
def html_export(self, html_file_path: str):
    """Method for exporting plot as HTML file."""
    path_validation(html_file_path)
    self.fig.write_html(html_file_path)

prepare_plot(show=True)

Method to prepare and show the plot.

Parameters:

Name Type Description Default
show bool

True if want to see the plot.

 True
Source code in erad\visualization\plot_graph.py 
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
def prepare_plot(self, show: bool = True):
    """Method to prepare and show the plot.

    Args:
        show (bool): True if want to see the plot.
    """
    self.fig = go.Figure(data=self.data)
    self.fig.update_layout(margin={"r": 0, "t": 0, "l": 0, "b": 0})
    self.fig.update_mapboxes(
        {
            "accesstoken": self.access_token,
            "style": self.style,
            "center": self._get_map_centre(
                self.scatter_data["longitudes"],
                self.scatter_data["latitudes"],
            ),
            "zoom": self.zoom_level,
        }
    )

    if show:
        self.fig.show()