epyt-flow 0.10.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

epyt_flow/{simulation → visualization}/scenario_visualizer.py

@@ -1,18 +1,20 @@
 """
 Module provides a class for visualizing scenarios.
 """
-from typing import Optional, Union, List, Tuple, Iterable
+from typing import Optional, Union, List, Tuple
+
+import numpy as np
 from deprecated import deprecated
 
 import matplotlib.pyplot as plt
 from matplotlib.animation import FuncAnimation
 import matplotlib as mpl
 import networkx.drawing.nx_pylab as nxp
-import numpy as np
 from svgpath2mpl import parse_path
 
-from .scenario_simulator import ScenarioSimulator
-from .scada.scada_data import ScadaData
+from ..simulation.scenario_simulator import ScenarioSimulator
+from ..simulation.scada.scada_data import ScadaData
+from ..visualization import JunctionObject, EdgeObject, ColorScheme, epyt_flow_colors
 
 PUMP_PATH = ('M 202.5 93 A 41.5 42 0 0 0 161 135 A 41.5 42 0 0 0 202.5 177 A '
              '41.5 42 0 0 0 244 135 A 41.5 42 0 0 0 241.94922 122 L 278 122 '
@@ -33,18 +35,19 @@ class Marker:
     """
     The Marker class provides svg representations of hydraulic components
     (pump, reservoir, tank and valve), which are loaded from their respective
-    svg paths and transformed into :class:`~matplotlib.path.Path` objects in
-    order to be used with the matplotlib library.
+    svg paths and transformed into
+    `~matplotlib.path.Path <https://matplotlib.org/stable/api/path_api.html#matplotlib.path.Path>`_
+    objects in order to be used with the matplotlib library.
 
     Attributes
     ----------
-    pump : :class:`~matplotlib.path.Path` object
+    pump : `matplotlib.path.Path <https://matplotlib.org/stable/api/path_api.html#matplotlib.path.Path>`_
         Marker for the pump, loaded from PUMP_PATH.
-    reservoir : :class:`~matplotlib.path.Path` object
+    reservoir : `matplotlib.path.Path <https://matplotlib.org/stable/api/path_api.html#matplotlib.path.Path>`_
         Marker for the reservoir, loaded from RESERVOIR_PATH.
-    tank : :class:`~matplotlib.path.Path` object
+    tank : `matplotlib.path.Path <https://matplotlib.org/stable/api/path_api.html#matplotlib.path.Path>`_
         Marker for the tank, loaded from TANK_PATH.
-    valve : :class:`~matplotlib.path.Path` object
+    valve : `matplotlib.path.Path <https://matplotlib.org/stable/api/path_api.html#matplotlib.path.Path>`_
         Marker for the valve, loaded from VALVE_PATH.
 
     Methods
@@ -53,9 +56,11 @@ class Marker:
         Loads and applies transformations to the marker shape from the given
         path.
     """
+
     def __init__(self):
         """
-        Initializes the Marker class and assigns :class:`~matplotlib.path.Path`
+        Initializes the Marker class and assigns
+        `matplotlib.path.Path <https://matplotlib.org/stable/api/path_api.html#matplotlib.path.Path>`_
         markers for pump, reservoir, tank, and valve components.
         """
         self.pump = self.__marker_from_path(PUMP_PATH, 2)
@@ -78,7 +83,7 @@ class Marker:
 
         Returns
         -------
-        marker_tmp : :class:`~matplotlib.path.Path` object
+        `matplotlib.path.Path <https://matplotlib.org/stable/api/path_api.html#matplotlib.path.Path>`_
             The transformed marker object after loading and adjusting it.
         """
         marker_tmp = parse_path(path)
@@ -95,20 +100,20 @@ class ScenarioVisualizer:
     This class provides the necessary function to generate visualizations in
     the form of plots or animations from water network data.
 
-    Given a :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator` object, this class
-    provides the necessary functions to plot the network topology and to color
-    hydraulic elements according to simulation data. The resulting plot can
-    then either be displayed or saved.
+    Given a :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`
+    object, this class provides the necessary functions to plot the network
+    topology and to color hydraulic elements according to simulation data. The
+    resulting plot can then be displayed or saved.
 
     Attributes
     ----------
     __scenario : :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`
         ScenarioSimulator object containing the network topology and
         configurations to obtain the simulation data which should be displayed.
-    fig : :class:`~matplotlib.pyplot.Figure` or None
+    fig : `matplotlib.pyplot.Figure <https://matplotlib.org/stable/api/_as_gen/matplotlib.figure.Figure.html#matplotlib.figure.Figure>`_ or None
         Figure object used for plotting, created and customized by calling the
         methods of this class, initialized as None.
-    ax : :class:`~matplotlib.axes.Axes` or None
+    ax : `~matplotlib.axes.Axes <https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.html#matplotlib-axes-axes>`_ or None
         The axes for plotting, initialized as None.
     scada_data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData` or None
         SCADA data created by the ScenarioSimulator object, initialized as
@@ -116,47 +121,58 @@ class ScenarioVisualizer:
     topology : :class:`~epyt_flow.topology.NetworkTopology`
         Topology object retrieved from the scenario, containing the structure
         of the water distribution network.
-    pos_dict : `dict`
-        A dictionary mapping nodes to their coordinates in the correct format
+    color_scheme : :class:`~epyt_flow.visualization.visualization_utils.ColorScheme`
+        Contains the selected ColorScheme for visualization.
+    pipe_parameters : :class:`~epyt_flow.visualization.visualization_utils.EdgeObject`
+        Class contains parameters for visualizing pipes in the correct format
+        for drawing.
+    junction_parameters : :class:`~epyt_flow.visualization.visualization_utils.JunctionObject`
+        Class contains parameters for visualizing junctions in the correct
+        format for drawing.
+    tank_parameters : :class:`~epyt_flow.visualization.visualization_utils.JunctionObject`
+        Class contains parameters for visualizing tanks in the correct format
         for drawing.
-    pipe_parameters : `dict`
-        Parameters for visualizing pipes in the correct format for drawing.
-    junction_parameters : `dict`
-        Parameters for visualizing junctions in the correct format for drawing.
-    tank_parameters : `dict`
-        Parameters for visualizing tanks in the correct format for drawing.
-    reservoir_parameters : `dict`
-        Parameters for visualizing reservoirs in the correct format for
+    reservoir_parameters : :class:`~epyt_flow.visualization.visualization_utils.JunctionObject`
+        Class contains parameters for visualizing reservoirs in the correct
+        format for
         drawing.
-    valve_parameters : `dict`
-        Parameters for visualizing valves in the correct format for drawing.
-    pump_parameters : `dict`
-        Parameters for visualizing pumps in the correct format for drawing.
-    animation_dict : `dict`
-        A dictionary containing frame by frame data for the animated
-        components.
+    valve_parameters : :class:`~epyt_flow.visualization.visualization_utils.JunctionObject`
+        Class contains parameters for visualizing valves in the correct format
+        for drawing.
+    pump_parameters : :class:`~epyt_flow.visualization.visualization_utils.JunctionObject`
+        Class contains parameters for visualizing pumps in the correct format
+        for drawing.
     colorbars : `dict`
         A dictionary containing the necessary data for drawing the required
         colorbars.
+    labels : `dict`
+        A dictionary containing components as keys and drawing information for
+        the labels as values.
+
     """
-    def __init__(self, scenario: ScenarioSimulator) -> None:
+
+    def __init__(self, scenario: ScenarioSimulator,
+                 color_scheme: ColorScheme = epyt_flow_colors) -> None:
         """
         Initializes the class with a given scenario, sets up the topology,
-        SCADA data, and parameters for visualizing various hydraulic components
-        (pipes, junctions, tanks, reservoirs, valves, and pumps).
+        SCADA data, and the classes containing parameters for visualizing
+        various hydraulic components (pipes, junctions, tanks, reservoirs,
+        valves, and pumps).
 
         Parameters
         ----------
         scenario : :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`
             An instance of the `ScenarioSimulator` class, used to simulate and
             retrieve the system topology.
+        color_scheme : :class:`~epyt_flow.visualization.visualization_utils.ColorScheme`
+            Contains the selected ColorScheme for visualization. Default is
+            EPYT_FLOW.
 
         Raises
         ------
         TypeError
             If `scenario` is not an instance of
             :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`.
-
         """
         if not isinstance(scenario, ScenarioSimulator):
             raise TypeError("'scenario' must be an instance of " +
@@ -169,30 +185,43 @@ class ScenarioVisualizer:
         self.scada_data = None
         markers = Marker()
         self.topology = self.__scenario.get_topology()
-        self.pos_dict = {x: self.topology.get_node_info(x)['coord'] for x in
-                         self.topology.get_all_nodes()}
-        self.pipe_parameters = {
-            'edgelist': [x[1] for x in self.topology.get_all_links()],
-            'edge_color': 'k'}
-        self.junction_parameters = {
-            'nodelist': self.topology.get_all_junctions(), 'node_size': 10,
-            'node_color': 'k'}
-        self.tank_parameters = {'nodelist': self.topology.get_all_tanks(),
-                                'node_size': 100, 'node_color': 'k',
-                                'node_shape': markers.tank}
-        self.reservoir_parameters = {
-            'nodelist': self.topology.get_all_reservoirs(), 'node_size': 100,
-            'node_color': 'k', 'node_shape': markers.reservoir}
-        self.valve_parameters = {'nodelist': self.topology.get_all_valves(),
-                                 'node_size': 75, 'node_color': 'k',
-                                 'node_shape': markers.valve}
-        self.pump_parameters = {'nodelist': self.topology.get_all_pumps(),
-                                'node_size': 100, 'node_color': 'k',
-                                'node_shape': markers.pump}
-        self.animation_dict = {}
+
+        pos_dict = {x: self.topology.get_node_info(x)['coord'] for x in
+                    self.topology.get_all_nodes()}
+
+        self.color_scheme = color_scheme
+
+        self.pipe_parameters = EdgeObject(
+            [x[1] for x in self.topology.get_all_links()], pos_dict,
+            self.color_scheme.pipe_color)
+        self.junction_parameters = JunctionObject(
+            self.topology.get_all_junctions(), pos_dict,
+            node_color=self.color_scheme.node_color)
+        self.tank_parameters = JunctionObject(self.topology.get_all_tanks(),
+                                              pos_dict, node_size=100,
+                                              node_shape=markers.tank,
+                                              node_color=self.color_scheme.tank_color)
+        self.reservoir_parameters = JunctionObject(
+            self.topology.get_all_reservoirs(), pos_dict, node_size=100,
+            node_shape=markers.reservoir,
+            node_color=self.color_scheme.reservoir_color)
+        self.valve_parameters = JunctionObject(self.topology.get_all_valves(),
+                                               self._get_midpoints(
+                                                   self.topology.get_all_valves()),
+                                               node_size=50,
+                                               node_shape=markers.valve,
+                                               node_color=self.color_scheme.valve_color)
+        self.pump_parameters = JunctionObject(self.topology.get_all_pumps(),
+                                              self._get_midpoints(
+                                                  self.topology.get_all_pumps()),
+                                              node_size=50,
+                                              node_shape=markers.pump,
+                                              node_color=self.color_scheme.pump_color)
+
         self.colorbars = {}
+        self.labels = {}
 
-    def __get_midpoints(self, elements: List[str]) -> dict[str, tuple[float, float]]:
+    def _get_midpoints(self, elements: List[str]) -> dict[str, tuple[float, float]]:
         """
         Computes and returns the midpoints for drawing either valves or pumps
         in a water distribution network.
@@ -229,7 +258,7 @@ class ScenarioVisualizer:
             elements_pos_dict[element] = pos
         return elements_pos_dict
 
-    def __get_next_frame(self, frame_number: int) -> None:
+    def _get_next_frame(self, frame_number: int) -> None:
         """
         Draws the next frame of a water distribution network animation.
 
@@ -243,297 +272,150 @@ class ScenarioVisualizer:
             The current frame number used to retrieve the data corresponding to
             that frame
         """
+        plt.clf()
         self.ax = self.fig.add_subplot(111)
         self.ax.axis('off')
 
-        nxp.draw_networkx_edges(self.topology, self.pos_dict, ax=self.ax,
-                                label='Pipes', **self.pipe_parameters)
-
-        if 'junctions' in self.animation_dict:
-            self.junction_parameters['node_color'] = \
-                self.animation_dict['junctions'][frame_number]
-        if 'pipes' in self.animation_dict:
-            self.pipe_parameters['edge_color'] = self.animation_dict['pipes'][
-                frame_number]
-        if 'pipe_sizes' in self.animation_dict:
-            self.pipe_parameters['width'] = self.animation_dict['pipe_sizes'][
-                frame_number]
-        if 'pumps' in self.animation_dict:
-            self.pump_parameters['node_color'] = self.animation_dict['pumps'][
-                frame_number]
-        if 'tanks' in self.animation_dict:
-            self.tank_parameters['node_color'] = self.animation_dict['tanks'][
-                frame_number]
-        if 'valves' in self.animation_dict:
-            self.valve_parameters['node_color'] = \
-                self.animation_dict['valves'][frame_number]
-
-        nxp.draw_networkx_nodes(self.topology, self.pos_dict, ax=self.ax,
-                                label='Junctions', **self.junction_parameters)
-        nxp.draw_networkx_nodes(self.topology, self.pos_dict, ax=self.ax,
-                                label='Tanks', **self.tank_parameters)
-        nxp.draw_networkx_nodes(self.topology, self.pos_dict, ax=self.ax,
+        nxp.draw_networkx_edges(self.topology, ax=self.ax,
+                                label='Pipes',
+                                **self.pipe_parameters.get_frame(frame_number))
+        nxp.draw_networkx_nodes(self.topology, ax=self.ax,
+                                label='Junctions',
+                                **self.junction_parameters.get_frame(
+                                    frame_number))
+        nxp.draw_networkx_nodes(self.topology, ax=self.ax,
+                                label='Tanks',
+                                **self.tank_parameters.get_frame(frame_number))
+        nxp.draw_networkx_nodes(self.topology, ax=self.ax,
                                 label='Reservoirs',
-                                **self.reservoir_parameters)
+                                **self.reservoir_parameters.get_frame(
+                                    frame_number))
         nxp.draw_networkx_nodes(
-            self.topology,
-            self.__get_midpoints(self.topology.get_all_valves()), ax=self.ax,
-            label='Valves', **self.valve_parameters)
+            self.topology, ax=self.ax,
+            label='Valves', **self.valve_parameters.get_frame(frame_number))
         nxp.draw_networkx_nodes(
-            self.topology, self.__get_midpoints(self.topology.get_all_pumps()),
-            ax=self.ax, label='Pumps', **self.pump_parameters)
+            self.topology,
+            ax=self.ax, label='Pumps',
+            **self.pump_parameters.get_frame(frame_number))
 
+        self._draw_labels()
         self.ax.legend(fontsize=6)
 
-    def __get_link_data(
-            self, scada_data: Optional[ScadaData] = None,
-            parameter: str = 'flow_rate', statistic: str = 'mean',
-            pit: Optional[Union[int, Tuple[int]]] = None,
-            intervals: Optional[Union[int, List[Union[int, float]]]] = None,
-            conversion: Optional[dict] = None)\
-            -> Tuple[Union[List, Iterable], int]:
+        for colorbar_stats in self.colorbars.values():
+            self.fig.colorbar(ax=self.ax, **colorbar_stats)
 
+    def _interpolate_frames(self, num_inter_frames: int):
         """
-        Retrieves or generates SCADA data and processes it according to the
-        parameters.
-
-        The method extracts SCADA data corresponding to links. The given
-        statistic is then applied and the data returned in a format suitable
-        for plotting.
+        Interpolates intermediate values between frames using cubic spline
+        interpolation for smoother animation.
 
         Parameters
         ----------
-        scada_data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData`, optional
-            The SCADA data object to retrieve link data from. If `None`, a
-            simulation is run to generate the SCADA data. Default is `None`.
-        parameter : `str`, optional
-            The type of link data to retrieve. Must be either 'flow_rate',
-            'link_quality', or 'diameter'. Default is 'flow_rate'.
-        statistic : `str`, optional
-            The statistic to calculate for the link data. Can be 'mean', 'min',
-            'max', or 'time_step'. Default is 'mean'.
-        pit : `int` or `tuple(int, int)`, optional
-            Point in time for the 'time_step' statistic. Can be either one
-            point or a tuple setting a range. Required if 'time_step' is
-            selected as the statistic. Default is `None`.
-        intervals : `int`, `float`, or `list` of `int` or `float`, optional
-            If specified, the link data will be grouped into intervals. This
-            can either be an integer specifying the number of groups or a
-            `list` of boundary points defining the intervals. Default is
-            `None`.
-        conversion : `dict`, optional
-            A dictionary of conversion parameters to convert SCADA data units.
-            Default is `None`.
+        num_inter_frames : `int`
+            Number of total frames after interpolation.
 
         Returns
         -------
-        sorted_values : `list`
-            A list of processed and sorted values for each link in the water
-            distribution network.
-        sim_length : `int`
-            The length of the simulation or SCADA data used.
-
-        Raises
-        ------
-        ValueError
-            If an invalid `parameter`, `statistic`, or `intervals` argument is
-            provided, or if `pit` is not provided when using the 'time_step'
-            statistic.
-
+        num_inter_frames : `int`
+            Number of total frames after interpolation.
         """
+        for node_source in [self.junction_parameters, self.tank_parameters,
+                            self.reservoir_parameters, self.valve_parameters,
+                            self.pump_parameters]:
+            node_source.interpolate(num_inter_frames)
+        self.pipe_parameters.interpolate(num_inter_frames)
 
-        if scada_data:
-            self.scada_data = scada_data
-        elif not self.scada_data:
-            self.scada_data = self.__scenario.run_simulation()
+        return num_inter_frames
 
-        if conversion:
-            self.scada_data = self.scada_data.convert_units(**conversion)
-
-        if parameter == 'flow_rate':
-            values = self.scada_data.flow_data_raw
-        elif parameter == 'link_quality':
-            values = self.scada_data.link_quality_data_raw
-        elif parameter == 'diameter':
-            value_dict = {
-                link[0]: self.topology.get_link_info(link[0])['diameter'] for
-                link in self.topology.get_all_links()}
-            sorted_values = [value_dict[x[0]] for x in
-                             self.topology.get_all_links()]
-            return (self.__rescale(sorted_values, (1, 2)),
-                    self.scada_data.flow_data_raw.shape[0])
-        else:
-            raise ValueError('Parameter must be flow_rate or link_quality')
-
-        sim_length = values.shape[0]
-
-        if statistic == 'mean':
-            stat_values = np.mean(values, axis=0)
-        elif statistic == 'min':
-            stat_values = np.min(values, axis=0)
-        elif statistic == 'max':
-            stat_values = np.max(values, axis=0)
-        elif statistic == 'time_step':
-            if not pit and pit != 0:
-                raise ValueError(
-                    'Please input point in time (pit) parameter when selecting'
-                    ' time_step statistic')
-            stat_values = np.take(values, pit, axis=0)
-        else:
-            raise ValueError(
-                'Statistic parameter must be mean, min, max or time_step')
-
-        if intervals is None:
-            pass
-        elif isinstance(intervals, (int, float)):
-            interv = np.linspace(stat_values.min(), stat_values.max(),
-                                 intervals + 1)
-            stat_values = np.digitize(stat_values, interv) - 1
-        elif isinstance(intervals, list):
-            stat_values = np.digitize(stat_values, intervals) - 1
-        else:
-            raise ValueError(
-                'Intervals must be either number of groups or list of interval'
-                ' boundary points')
-
-        value_dict = dict(zip(self.scada_data.sensor_config.links,
-                              stat_values))
-        sorted_values = [value_dict[x[0]] for x in
-                         self.topology.get_all_links()]
-
-        return sorted_values, sim_length
-
-    @staticmethod
-    def __get_parameters_update(statistic: str, values: np.ndarray,
-                                pit: Union[int, Tuple[int]],
-                                intervals: Union[int, List[Union[int, float]]],
-                                all_junctions: List[str],
-                                junction_sorting: List[str]) -> List:
+    def _draw_labels(self):
         """
-        Computes and returns statistical values for junctions in a water
-        network.
-
-        This method processes a 2D array of data (e.g., flow rates or quality)
-        by calculating specified statistics (mean, min, max, or time step) and
-        optionally grouping the data into intervals. It returns the data sorted
-        according to the provided junction sorting order.
+        Method accesses the dict `self.labels` and draws all generated labels
+        within.
+        """
+        for k, v in self.labels.items():
+            if k in ['pipes']:
+                nxp.draw_networkx_edge_labels(self.topology, ax=self.ax, **v)
+                continue
+            nxp.draw_networkx_labels(self.topology, ax=self.ax, **v)
 
-        Parameters
-        ----------
-        statistic : `str`
-            The statistical operation to apply to the data. Must be one of
-            'mean', 'min', 'max', or 'time_step'.
-        values : :class:`~np.ndarray`
-            A 2D NumPy array of shape (timesteps, junctions) containing the
-            data for all junctions over time.
-        pit : `int` or `tuple` of `int`
-            The point in time or range of points in time for which to retrieve
-            data, required if 'time_step' is selected as the statistic. If an
-            integer is provided, it selects a single point in time.
-        intervals : `int`, `float`, or `list[int]` or `list[float]`
-            If specified, divides the data into intervals. Can be an integer
-            representing the number of groups, or a list of boundary points
-            defining the intervals.
-        all_junctions : `list` of `str`
-            A list of all junction IDs in the network, corresponding to the
-            data  in the `values` array.
-        junction_sorting : `list` of `str`
-            The order in which to sort the junctions for the return value.
+    def _get_sensor_config_nodes_and_links(self):
+        """
+        Iterates through the sensor config and collects all nodes and links
+        within, that have a sensor attached.
 
         Returns
         -------
-        sorted_values : `list`
-            A list of statistical values for the junctions, sorted according to
-            `junction_sorting`.
-
-        Raises
-        ------
-        ValueError
-            If the `statistic` is not 'mean', 'min', 'max', or 'time_step', or
-            if `pit` is not provided for the 'time_step' statistic, or if
-            `intervals` is not in a valid format.
-
+        highlighted_links : `list`
+            List of all links with sensors.
+        highlighted_nodes : `list`
+            List of all nodes with sensors.
         """
+        highlighted_nodes = []
+        highlighted_links = []
 
-        if statistic == 'mean':
-            stat_values = np.mean(values, axis=0)
-        elif statistic == 'min':
-            stat_values = np.min(values, axis=0)
-        elif statistic == 'max':
-            stat_values = np.max(values, axis=0)
-        elif statistic == 'time_step':
-            if not pit and pit != 0:
-                raise ValueError(
-                    'Please input point in time (pit) parameter when selecting'
-                    ' time_step statistic')
-            stat_values = np.take(values, pit, axis=0)
-        else:
-            raise ValueError(
-                'Statistic parameter must be mean, min, max or time_step')
-
-        if intervals is None:
-            pass
-        elif isinstance(intervals, (int, float)):
-            interv = np.linspace(stat_values.min(), stat_values.max(),
-                                 intervals + 1)
-            stat_values = np.digitize(stat_values, interv) - 1
-        elif isinstance(intervals, list):
-            stat_values = np.digitize(stat_values, intervals) - 1
-        else:
-            raise ValueError(
-                'Intervals must be either number of groups or list of interval'
-                ' boundary points')
-
-        value_dict = dict(zip(all_junctions, stat_values))
-        sorted_values = [value_dict[x] for x in junction_sorting]
-
-        return sorted_values
+        sensor_config = self.__scenario.sensor_config
+        highlighted_nodes += (sensor_config.pressure_sensors
+                              + sensor_config.demand_sensors
+                              + sensor_config.quality_node_sensors)
+        highlighted_links += (sensor_config.flow_sensors
+                              + sensor_config.quality_link_sensors)
+        return highlighted_nodes, highlighted_links
 
-    @staticmethod
-    def __rescale(values: np.ndarray, scale_min_max: List,
-                  values_min_max: List = None) -> List:
+    def add_labels(self, components: list or tuple = () or str,
+                   font_size: int = 8):
         """
-        Rescales the given values to a new range.
-
-        This method rescales an array of values to fit within a specified
-        minimum and maximum scale range. Optionally, the minimum and maximum
-        of the input values can be manually provided; otherwise, they are
-        automatically determined from the data.
+        Adds labels to hydraulic components according to the specified
+        components.
 
         Parameters
         ----------
-        values : :class:`~np.ndarray`
-            The array of numerical values to be rescaled.
-        scale_min_max : `list`
-            A list containing two elements: the minimum and maximum values
-            of the desired output range.
-        values_min_max : `list`, optional
-            A list containing two elements: the minimum and maximum values
-            of the input data. If not provided, they are computed from the
-            input `values`. Default is `None`.
-
-        Returns
-        -------
-        rescaled_values : `list`
-            A list of values rescaled to the range specified by
-            `scale_min_max`.
-
+        components : `str` or `list` or `tuple`, default is ()
+            Can either be 'all': all components, 'sensor_config': all nodes and
+            pipes which have a sensor attached, or a list of the component
+            names that are to be labeled: nodes, tanks, reservoirs, pipes,
+            valves, pumps. If the list is empty, all nodes are labeled.
+        font_size : `int`, default is 8
+            Font size of the labels.
         """
-
-        if not values_min_max:
-            min_val, max_val = min(values), max(values)
-        else:
-            min_val, max_val = values_min_max
-        scale = scale_min_max[1] - scale_min_max[0]
-
-        def range_map(x):
-            return scale_min_max[0] + (x - min_val) / (
-                    max_val - min_val) * scale
-
-        return [range_map(x) for x in values]
+        sc_nodes, sc_links = None, None
+        if components == 'all':
+            components = ['nodes', 'tanks', 'reservoirs', 'pipes', 'valves',
+                          'pumps']
+        elif components == 'sensor_config':
+            components = ['nodes', 'tanks', 'reservoirs', 'pipes', 'valves',
+                          'pumps']
+            sc_nodes, sc_links = self._get_sensor_config_nodes_and_links()
+
+        elif len(components) == 0:
+            components = ['nodes']
+
+        component_mapping = {
+            'nodes': self.junction_parameters,
+            'tanks': self.tank_parameters,
+            'reservoirs': self.reservoir_parameters,
+            'valves': self.valve_parameters,
+            'pumps': self.pump_parameters
+        }
+
+        for component, parameters in component_mapping.items():
+            if component in components:
+                labels = {n: str(n) for n in parameters.nodelist if
+                          sc_nodes is None or n in sc_nodes}
+                self.labels[component] = {'pos': parameters.pos,
+                                          'labels': labels,
+                                          'font_size': font_size}
+                if component in ['pumps', 'valves']:
+                    self.labels[component]['verticalalignment'] = 'bottom'
+        if 'pipes' in components:
+            labels = {tuple(n[1]): n[0] for n in self.topology.get_all_links()
+                      if sc_links is None or n[0] in sc_links}
+            self.labels['pipes'] = {'pos': self.pipe_parameters.pos,
+                                    'edge_labels': labels,
+                                    'font_size': font_size}
 
     def show_animation(self, export_to_file: str = None,
-                       return_animation: bool = False)\
+                       return_animation: bool = False, duration: int = 5,
+                       fps: int = 15, interpolate: bool = True) \
             -> Optional[FuncAnimation]:
         """
         Displays, exports, or returns an animation of a water distribution
@@ -551,37 +433,62 @@ class ScenarioVisualizer:
         return_animation : `bool`, optional
             If `True`, the animation object is returned. If `False`, the
             animation will be shown, but not returned. Default is `False`.
+        duration : `int`, default is 5
+            Duration of the animation in seconds.
+        fps : `int`, default is 15
+            Frames per seconds, is achieved through interpolation.
+        interpolate : `bool`, default is True
+            Whether to allow interpolating the sensor values or not. Necessary
+            for fixed fps.
 
         Returns
         -------
         anim : :class:`~FuncAnimation` or None
             Returns the animation object if `return_animation` is `True`.
             Otherwise, returns `None`.
-
         """
         self.fig = plt.figure(figsize=(6.4, 4.8), dpi=200)
 
         total_frames = float('inf')
-        for ll in self.animation_dict.values():
-            total_frames = min(total_frames, len(ll))
-
-        if not self.animation_dict or total_frames == 0:
+        for node_source in [self.junction_parameters, self.tank_parameters,
+                            self.reservoir_parameters, self.valve_parameters,
+                            self.pump_parameters]:
+            if not isinstance(node_source.node_color, str) and len(
+                    node_source.node_color) > 1:
+                total_frames = min(total_frames, len(node_source.node_color))
+        if hasattr(self.pipe_parameters, 'edge_color'):
+            if not isinstance(self.pipe_parameters.edge_color, str) and len(
+                    self.pipe_parameters.edge_color) > 1:
+                total_frames = min(total_frames,
+                                   len(self.pipe_parameters.edge_color))
+        if hasattr(self.pipe_parameters, 'width'):
+            if not isinstance(self.pipe_parameters.width, str) and len(
+                    self.pipe_parameters.width) > 1:
+                total_frames = min(total_frames,
+                                   len(self.pipe_parameters.width))
+
+        if total_frames == 0 or total_frames == float('inf'):
             raise RuntimeError("The color or resize functions must be called "
-                               "with a time_step range (pit) to enable "
+                               "with a time_step range (pit) > 1 to enable "
                                "animations")
 
-        anim = FuncAnimation(self.fig, self.__get_next_frame,
-                             frames=total_frames, interval=25)
+        if interpolate:
+            total_frames = self._interpolate_frames(fps * duration)
+
+        anim = FuncAnimation(self.fig, self._get_next_frame,
+                             frames=total_frames,
+                             interval=round(duration * 100 / total_frames))
 
         if export_to_file is not None:
-            anim.save(export_to_file, writer='ffmpeg', fps=4)
+            anim.save(export_to_file, writer='ffmpeg', fps=fps)
         if return_animation:
             plt.close(self.fig)
             return anim
         plt.show()
         return None
 
-    def show_plot(self, export_to_file: str = None) -> None:
+    def show_plot(self, export_to_file: str = None,
+                  suppress_plot: bool = False) -> None:
         """
         Displays a static plot of the water distribution network.
 
@@ -594,46 +501,29 @@ class ScenarioVisualizer:
         export_to_file : `str`, optional
             The file path where the plot should be saved, if provided.
             Default is `None`.
-
+        suppress_plot : `bool`, default is False
+            If true, no plot is displayed after running this method.
         """
         self.fig = plt.figure(figsize=(6.4, 4.8), dpi=200)
-        self.ax = self.fig.add_subplot(111)
-        self.ax.axis('off')
-
-        nxp.draw_networkx_edges(self.topology, self.pos_dict, ax=self.ax,
-                                label='Pipes', **self.pipe_parameters)
-        nxp.draw_networkx_nodes(self.topology, self.pos_dict, ax=self.ax,
-                                label='Junctions', **self.junction_parameters)
-        nxp.draw_networkx_nodes(self.topology, self.pos_dict, ax=self.ax,
-                                label='Tanks', **self.tank_parameters)
-        nxp.draw_networkx_nodes(self.topology, self.pos_dict, ax=self.ax,
-                                label='Reservoirs',
-                                **self.reservoir_parameters)
-        nxp.draw_networkx_nodes(
-            self.topology,
-            self.__get_midpoints(self.topology.get_all_valves()), ax=self.ax,
-            label='Valves', **self.valve_parameters)
-        nxp.draw_networkx_nodes(
-            self.topology, self.__get_midpoints(self.topology.get_all_pumps()),
-            ax=self.ax, label='Pumps', **self.pump_parameters)
-        self.ax.legend(fontsize=6)
-
-        for colorbar_stats in self.colorbars.values():
-            self.fig.colorbar(ax=self.ax, **colorbar_stats)
+        self._get_next_frame(0)
 
         if export_to_file is not None:
             plt.savefig(export_to_file, transparent=True, bbox_inches='tight',
                         dpi=200)
-        plt.show()
+        if not suppress_plot:
+            plt.show()
+        else:
+            plt.close(self.fig)
+            plt.clf()
 
     def color_nodes(
-            self, scada_data: Optional[ScadaData] = None,
+            self, data: Optional[Union[ScadaData, np.ndarray]] = None,
             parameter: str = 'pressure', statistic: str = 'mean',
-            pit: Optional[Union[int, Tuple[int]]] = None,
+            pit: Optional[Union[int, Tuple[int, int]]] = None,
             colormap: str = 'viridis',
             intervals: Optional[Union[int, List[Union[int, float]]]] = None,
-            conversion: Optional[dict] = None, show_colorbar: bool = False) ->\
-            None:
+            conversion: Optional[dict] = None,
+            show_colorbar: bool = False) -> None:
         """
         Colors the nodes (junctions) in the water distribution network based on
         the SCADA data and the specified parameters.
@@ -644,9 +534,11 @@ class ScenarioVisualizer:
 
         Parameters
         ----------
-        scada_data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData`, optional
-            The SCADA data object containing node data. If `None`, a simulation
-            will be run to generate SCADA data. Default is `None`.
+        data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData` or
+            `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_, optional
+            The SCADA data object containing node data or a numpy array of the
+            shape nodes*timesteps. If `None`, a simulation is run to generate
+            SCADA data. Default is `None`.
         parameter : `str`, optional
             The node data to visualize. Must be 'pressure', 'demand', or
             'node_quality'. Default is 'pressure'.
@@ -681,11 +573,10 @@ class ScenarioVisualizer:
             'time_step' statistic.
 
         """
+        self.junction_parameters.cmap = colormap
 
-        self.junction_parameters.update({'cmap': colormap})
-
-        if scada_data:
-            self.scada_data = scada_data
+        if data is not None:
+            self.scada_data = data
         elif not self.scada_data:
             self.scada_data = self.__scenario.run_simulation()
 
@@ -698,59 +589,49 @@ class ScenarioVisualizer:
             values = self.scada_data.demand_data_raw
         elif parameter == 'node_quality':
             values = self.scada_data.node_quality_data_raw
+        elif parameter == 'custom_data':
+            # Custom should have the dimensions (timesteps, nodes)
+            values = self.scada_data
         else:
             raise ValueError(
-                'Parameter must be pressure, demand or node_quality')
+                'Parameter must be pressure, demand, node_quality or custom_'
+                'data.')
 
         if statistic == 'time_step' and isinstance(pit, tuple) and len(
                 pit) == 2 and all(isinstance(i, int) for i in pit):
-            sorted_values = self.__get_parameters_update(
-                statistic, values, pit[0], intervals,
-                self.scada_data.sensor_config.nodes,
-                self.topology.get_all_junctions())
-            self.animation_dict['junctions'] = []
-            vmin, vmax = min(sorted_values), max(sorted_values)
-            for frame in range(*pit):
+            rng = pit
+            if pit[1] == -1:
+                rng = (pit[0], values.shape[0])
+            for frame in range(*rng):
                 if frame > values.shape[0] - 1:
                     break
-                sorted_values = self.__get_parameters_update(
-                    statistic, values, frame, intervals,
-                    self.scada_data.sensor_config.nodes,
-                    self.topology.get_all_junctions())
-                vmin, vmax = (min(*sorted_values, vmin),
-                              max(*sorted_values, vmax))
-                self.animation_dict['junctions'].append(sorted_values)
-            self.junction_parameters['vmin'] = vmin
-            self.junction_parameters['vmax'] = vmax
+                self.junction_parameters.add_frame(statistic, values, frame,
+                                                   intervals)
         else:
-            sorted_values = self.__get_parameters_update(
-                statistic, values, pit, intervals,
-                self.scada_data.sensor_config.nodes,
-                self.topology.get_all_junctions())
-            self.junction_parameters.update(
-                {'node_color': sorted_values, 'vmin': min(sorted_values),
-                 'vmax': max(sorted_values)})
+            self.junction_parameters.add_frame(statistic, values, pit,
+                                               intervals)
 
         if show_colorbar:
             if statistic == 'time_step':
                 label = str(parameter).capitalize() + ' at timestep ' + str(
                     pit)
             else:
-                label = str(statistic).capitalize() + ' ' + str(parameter)
+                label = str(statistic).capitalize() + ' ' + str(
+                    parameter).replace('_', ' ')
             self.colorbars['junctions'] = {'mappable': plt.cm.ScalarMappable(
                 norm=mpl.colors.Normalize(
-                    vmin=self.junction_parameters['vmin'],
-                    vmax=self.junction_parameters['vmax']), cmap=colormap),
+                    vmin=self.junction_parameters.vmin,
+                    vmax=self.junction_parameters.vmin), cmap=colormap),
                 'label': label}
 
     def color_links(
-            self, scada_data: Optional[ScadaData] = None,
+            self, data: Optional[Union[ScadaData, np.ndarray]] = None,
             parameter: str = 'flow_rate', statistic: str = 'mean',
-            pit: Optional[Union[int, Tuple[int]]] = None,
+            pit: Optional[Union[int, Tuple[int, int]]] = None,
             colormap: str = 'coolwarm',
             intervals: Optional[Union[int, List[Union[int, float]]]] = None,
-            conversion: Optional[dict] = None, show_colorbar: bool = False) ->\
-            None:
+            conversion: Optional[dict] = None,
+            show_colorbar: bool = False) -> None:
         """
         Colors the links (pipes) in the water distribution network based on the
         SCADA data and the specified parameters.
@@ -761,9 +642,11 @@ class ScenarioVisualizer:
 
         Parameters
         ----------
-        scada_data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData`, optional
-            The SCADA data object. If `None`, the method will run a simulation.
-            Default is `None`.
+        data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData` or
+            `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_, optional
+            The SCADA data object containing link data or a numpy array of the
+            shape links*timesteps. If `None`, a simulation is run to generate
+            SCADA data. Default is `None`.
         parameter : `str`, optional
             The link data to visualize. Options are 'flow_rate', 'velocity', or
             'status'. Default is 'flow_rate'.
@@ -774,7 +657,7 @@ class ScenarioVisualizer:
             The point in time or range of time steps for the 'time_step'
             statistic. If a tuple is provided, it should contain two integers
             representing the start and end time steps. A tuple is necessary to
-            process the data for the :meth:`~ScenarioVisualizer.show_animation`
+            process the data for the :func:`~ScenarioVisualizer.show_animation`
             method. Default is `None`.
         colormap : `str`, optional
             The colormap to use for visualizing link values. Default is
@@ -797,40 +680,38 @@ class ScenarioVisualizer:
             incorrectly provided for the 'time_step' statistic.
 
         """
+        sim_length = None
+
+        if data is not None:
+            self.scada_data = data
+            if not isinstance(self.scada_data, ScadaData):
+                sim_length = self.scada_data.shape[0]
+        elif not self.scada_data:
+            self.scada_data = self.__scenario.run_simulation()
+
+        if conversion:
+            self.scada_data = self.scada_data.convert_units(**conversion)
+
+        self.pipe_parameters.edge_cmap = mpl.colormaps[colormap]
+
+        if sim_length is None:
+            sim_length = self.scada_data.sensor_readings_time.shape[0]
 
         if statistic == 'time_step' and isinstance(pit, tuple) and len(
                 pit) == 2 and all(isinstance(i, int) for i in pit):
-            sorted_values, sim_length = self.__get_link_data(scada_data,
-                                                             parameter,
-                                                             statistic, pit[0],
-                                                             intervals,
-                                                             conversion)
-            self.pipe_parameters.update({'edge_color': sorted_values,
-                                         'edge_cmap': mpl.colormaps[colormap],
-                                         'edge_vmin': min(sorted_values),
-                                         'edge_vmax': max(sorted_values)})
-            self.animation_dict['pipes'] = []
-            vmin = min(sorted_values)
-            vmax = max(sorted_values)
-            for frame in range(*pit):
-                if frame > sim_length - 1:
+            rng = pit
+            if pit[1] == -1:
+                rng = (pit[0], sim_length)
+            for frame in range(*rng):
+                if frame >= sim_length:
                     break
-                sorted_values, _ = self.__get_link_data(scada_data, parameter,
-                                                        statistic, frame,
-                                                        intervals, conversion)
-                vmin = min(*sorted_values, vmin)
-                vmax = max(*sorted_values, vmax)
-                self.animation_dict['pipes'].append(sorted_values)
-            self.pipe_parameters['edge_vmin'] = vmin
-            self.pipe_parameters['edge_vmax'] = vmax
+                self.pipe_parameters.add_frame(self.topology, 'edge_color',
+                                               self.scada_data, parameter,
+                                               statistic, frame, intervals)
         else:
-            sorted_values, _ = self.__get_link_data(scada_data, parameter,
-                                                    statistic, pit, intervals,
-                                                    conversion)
-            self.pipe_parameters.update({'edge_color': sorted_values,
-                                         'edge_cmap': mpl.colormaps[colormap],
-                                         'edge_vmin': min(sorted_values),
-                                         'edge_vmax': max(sorted_values)})
+            self.pipe_parameters.add_frame(self.topology, 'edge_color',
+                                           self.scada_data, parameter,
+                                           statistic, pit, intervals)
 
         if show_colorbar:
             if statistic == 'time_step':
@@ -841,12 +722,12 @@ class ScenarioVisualizer:
                     parameter).replace('_', ' ')
             self.colorbars['pipes'] = {'mappable': plt.cm.ScalarMappable(
                 norm=mpl.colors.Normalize(
-                    vmin=self.pipe_parameters['edge_vmin'],
-                    vmax=self.pipe_parameters['edge_vmax']), cmap=colormap),
+                    vmin=self.pipe_parameters.edge_vmin,
+                    vmax=self.pipe_parameters.edge_vmax), cmap=colormap),
                 'label': label}
 
     def color_pumps(
-            self, scada_data: Optional[ScadaData] = None,
+            self, data: Optional[Union[ScadaData, np.ndarray]] = None,
             parameter: str = 'efficiency', statistic: str = 'mean',
             pit: Optional[Union[int, Tuple[int]]] = None,
             intervals: Optional[Union[int, List[Union[int, float]]]] = None,
@@ -861,9 +742,11 @@ class ScenarioVisualizer:
 
         Parameters
         ----------
-        scada_data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData`, optional
-            The SCADA data object containing the pump data. If `None`, a
-            simulation will be run to generate SCADA data. Default is `None`.
+        data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData` or
+            `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_, optional
+            The SCADA data object containing pump data or a numpy array of the
+            shape pumps*timesteps. If `None`, a simulation is run to generate
+            SCADA data. Default is `None`.
         parameter : `str`, optional
             The pump data to visualize. Must be 'efficiency',
             'energy_consumption', or 'state'. Default is 'efficiency'.
@@ -896,10 +779,10 @@ class ScenarioVisualizer:
 
         """
 
-        self.pump_parameters.update({'cmap': colormap})
+        self.pump_parameters.cmap = colormap
 
-        if scada_data:
-            self.scada_data = scada_data
+        if data is not None:
+            self.scada_data = data
         elif not self.scada_data:
             self.scada_data = self.__scenario.run_simulation()
 
@@ -909,39 +792,24 @@ class ScenarioVisualizer:
             values = self.scada_data.pumps_energyconsumption_data_raw
         elif parameter == 'state':
             values = self.scada_data.pumps_state_data_raw
+        elif parameter == 'custom_data':
+            values = self.scada_data
         else:
             raise ValueError(
-                'Parameter must be efficiency, energy_consumption or state')
+                'Parameter must be efficiency, energy_consumption, state or custom_data')
 
         if statistic == 'time_step' and isinstance(pit, tuple) and len(
                 pit) == 2 and all(isinstance(i, int) for i in pit):
-            sorted_values = self.__get_parameters_update(
-                statistic, values, pit[0], intervals,
-                self.scada_data.sensor_config.pumps,
-                self.topology.get_all_pumps())
-            self.animation_dict['pumps'] = []
-            vmin = min(sorted_values)
-            vmax = max(sorted_values)
-            for frame in range(*pit):
+            rng = pit
+            if pit[1] == -1:
+                rng = (pit[0], values.shape[0])
+            for frame in range(*rng):
                 if frame > values.shape[0] - 1:
                     break
-                sorted_values = self.__get_parameters_update(
-                    statistic, values, frame, intervals,
-                    self.scada_data.sensor_config.pumps,
-                    self.topology.get_all_pumps())
-                vmin = min(*sorted_values, vmin)
-                vmax = max(*sorted_values, vmax)
-                self.animation_dict['pumps'].append(sorted_values)
-            self.pump_parameters['vmin'] = vmin
-            self.pump_parameters['vmax'] = vmax
+                self.pump_parameters.add_frame(statistic, values, frame,
+                                               intervals)
         else:
-            sorted_values = self.__get_parameters_update(
-                statistic, values, pit, intervals,
-                self.scada_data.sensor_config.pumps,
-                self.topology.get_all_pumps())
-            self.pump_parameters.update(
-                {'node_color': sorted_values, 'vmin': min(sorted_values),
-                 'vmax': max(sorted_values)})
+            self.pump_parameters.add_frame(statistic, values, pit, intervals)
 
         if show_colorbar:
             if statistic == 'time_step':
@@ -951,14 +819,14 @@ class ScenarioVisualizer:
                 label = str(statistic).capitalize() + ' ' + str(
                     parameter).replace('_', ' ')
             self.colorbars['pumps'] = {'mappable': plt.cm.ScalarMappable(
-                norm=mpl.colors.Normalize(vmin=self.pump_parameters['vmin'],
-                                          vmax=self.pump_parameters['vmax']),
+                norm=mpl.colors.Normalize(vmin=self.pump_parameters.vmin,
+                                          vmax=self.pump_parameters.vmax),
                 cmap=colormap), 'label': label}
 
     def color_tanks(
-            self, scada_data: Optional[ScadaData] = None,
+            self, data: Optional[Union[ScadaData, np.ndarray]] = None,
             statistic: str = 'mean',
-            pit: Optional[Union[int, Tuple[int]]] = None,
+            pit: Optional[Union[int, Tuple[int, int]]] = None,
             intervals: Optional[Union[int, List[Union[int, float]]]] = None,
             colormap: str = 'viridis', show_colorbar: bool = False) -> None:
         """
@@ -971,10 +839,11 @@ class ScenarioVisualizer:
 
         Parameters
         ----------
-        scada_data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData`, optional
-            The SCADA data object containing tank volume data.
-            If `None`, a simulation will be run to generate it.
-            Default is `None`.
+        data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData` or
+            `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_, optional
+            The SCADA data object containing tank data or a numpy array of the
+            shape tanks*timesteps. If `None`, a simulation is run to generate
+            SCADA data. Default is `None`.
         statistic : `str`, optional
             The statistic to calculate for the data. Can be 'mean', 'min',
             'max', or 'time_step'. Default is 'mean'.
@@ -1001,59 +870,47 @@ class ScenarioVisualizer:
             If `pit` is not correctly provided for the 'time_step' statistic.
 
         """
-        self.pump_parameters.update({'node_size': 10, 'cmap': colormap})
+        self.tank_parameters.cmap = colormap
 
-        if scada_data:
-            self.scada_data = scada_data
+        if data is not None:
+            self.scada_data = data
         elif not self.scada_data:
             self.scada_data = self.__scenario.run_simulation()
 
-        values = self.scada_data.tanks_volume_data_raw
+        if isinstance(self.scada_data, ScadaData):
+            values = self.scada_data.tanks_volume_data_raw
+            parameter = 'tank volume'
+        else:
+            values = self.scada_data
+            parameter = 'custom data'
 
         if statistic == 'time_step' and isinstance(pit, tuple) and len(
                 pit) == 2 and all(isinstance(i, int) for i in pit):
-            sorted_values = self.__get_parameters_update(
-                statistic, values, pit[0], intervals,
-                self.scada_data.sensor_config.tanks,
-                self.topology.get_all_tanks())
-            self.animation_dict['tanks'] = []
-            vmin = min(sorted_values)
-            vmax = max(sorted_values)
-            for frame in range(*pit):
+            rng = pit
+            if pit[1] == -1:
+                rng = (pit[0], values.shape[0])
+            for frame in range(*rng):
                 if frame > values.shape[0] - 1:
                     break
-                sorted_values = self.__get_parameters_update(
-                    statistic, values, frame, intervals,
-                    self.scada_data.sensor_config.tanks,
-                    self.topology.get_all_tanks())
-                vmin = min(*sorted_values, vmin)
-                vmax = max(*sorted_values, vmax)
-                self.animation_dict['tanks'].append(sorted_values)
-            self.tank_parameters['vmin'] = vmin
-            self.tank_parameters['vmax'] = vmax
+                self.tank_parameters.add_frame(statistic, values, frame,
+                                               intervals)
         else:
-            sorted_values = self.__get_parameters_update(
-                statistic, values, pit, intervals,
-                self.scada_data.sensor_config.tanks,
-                self.topology.get_all_tanks())
-            self.tank_parameters.update(
-                {'node_color': sorted_values, 'vmin': min(sorted_values),
-                 'vmax': max(sorted_values)})
+            self.tank_parameters.add_frame(statistic, values, pit, intervals)
 
         if show_colorbar:
             if statistic == 'time_step':
-                label = 'tank volume'.capitalize() + ' at timestep ' + str(pit)
+                label = parameter.capitalize() + ' at timestep ' + str(pit)
             else:
-                label = str(statistic).capitalize() + ' ' + 'tank volume'
+                label = str(statistic).capitalize() + ' ' + parameter
             self.colorbars['tanks'] = {'mappable': plt.cm.ScalarMappable(
-                norm=mpl.colors.Normalize(vmin=self.tank_parameters['vmin'],
-                                          vmax=self.tank_parameters['vmax']),
+                norm=mpl.colors.Normalize(vmin=self.tank_parameters.vmin,
+                                          vmax=self.tank_parameters.vmin),
                 cmap=colormap), 'label': label}
 
     def color_valves(
-            self, scada_data: Optional[ScadaData] = None,
+            self, data: Optional[Union[ScadaData, np.ndarray]] = None,
             statistic: str = 'mean',
-            pit: Optional[Union[int, Tuple[int]]] = None,
+            pit: Optional[Union[int, Tuple[int, int]]] = None,
             intervals: Optional[Union[int, List[Union[int, float]]]] = None,
             colormap: str = 'viridis', show_colorbar: bool = False) -> None:
         """
@@ -1066,9 +923,11 @@ class ScenarioVisualizer:
 
         Parameters
         ----------
-        scada_data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData`, optional
-            The SCADA data object containing valve state data. If `None`, a
-            simulation is run to generate SCADA data. Default is `None`.
+        data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData` or
+            `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_, optional
+            The SCADA data object containing valve data or a numpy array of the
+            shape valves*timesteps. If `None`, a simulation is run to generate
+            SCADA data. Default is `None`.
         statistic : `str`, optional
             The statistic to calculate for the data. Can be 'mean', 'min',
             'max', or 'time_step'. Default is 'mean'.
@@ -1096,60 +955,49 @@ class ScenarioVisualizer:
 
         """
 
-        self.valve_parameters.update({'node_size': 15, 'cmap': colormap})
+        self.valve_parameters.cmap = colormap
 
-        if scada_data:
-            self.scada_data = scada_data
+        if data is not None:
+            self.scada_data = data
         elif not self.scada_data:
             self.scada_data = self.__scenario.run_simulation()
 
-        values = self.scada_data.valves_state_data_raw
+        if isinstance(self.scada_data, ScadaData):
+            values = self.scada_data.valves_state_data_raw
+            parameter = 'valve state'
+        else:
+            values = self.scada_data
+            parameter = 'custom data'
 
         if statistic == 'time_step' and isinstance(pit, tuple) and len(
                 pit) == 2 and all(isinstance(i, int) for i in pit):
-            sorted_values = self.__get_parameters_update(
-                statistic, values, pit[0], intervals,
-                self.scada_data.sensor_config.valves,
-                self.topology.get_all_valves())
-            self.animation_dict['valves'] = []
-            vmin = min(sorted_values)
-            vmax = max(sorted_values)
-            for frame in range(*pit):
+            rng = pit
+            if pit[1] == -1:
+                rng = (pit[0], values.shape[0])
+            for frame in range(*rng):
                 if frame > values.shape[0] - 1:
                     break
-                sorted_values = self.__get_parameters_update(
-                    statistic, values, frame, intervals,
-                    self.scada_data.sensor_config.valves,
-                    self.topology.get_all_valves())
-                vmin = min(*sorted_values, vmin)
-                vmax = max(*sorted_values, vmax)
-                self.animation_dict['valves'].append(sorted_values)
-            self.valve_parameters['vmin'] = vmin
-            self.valve_parameters['vmax'] = vmax
+                self.valve_parameters.add_frame(statistic, values, frame,
+                                                intervals)
         else:
-            sorted_values = self.__get_parameters_update(
-                statistic, values, pit, intervals,
-                self.scada_data.sensor_config.valves,
-                self.topology.get_all_valves())
-            self.valve_parameters.update(
-                {'node_color': sorted_values, 'vmin': min(sorted_values),
-                 'vmax': max(sorted_values)})
+            self.valve_parameters.add_frame(statistic, values, pit,
+                                            intervals)
 
         if show_colorbar:
             if statistic == 'time_step':
-                label = 'valve state'.capitalize() + ' at timestep ' + str(pit)
+                label = parameter.capitalize() + ' at timestep ' + str(pit)
             else:
                 label = str(statistic).capitalize() + ' ' + 'valve state'
             self.colorbars['valves'] = {'mappable': plt.cm.ScalarMappable(
-                norm=mpl.colors.Normalize(vmin=self.valve_parameters['vmin'],
-                                          vmax=self.valve_parameters['vmax']),
+                norm=mpl.colors.Normalize(vmin=self.valve_parameters.vmin,
+                                          vmax=self.valve_parameters.vmax),
                 cmap=colormap), 'label': label}
 
     def resize_links(
-            self, scada_data: Optional[ScadaData] = None,
+            self, data: Optional[Union[ScadaData, np.ndarray]] = None,
             parameter: str = 'flow_rate', statistic: str = 'mean',
-            line_widths: Tuple[int] = (1, 2),
-            pit: Optional[Union[int, Tuple[int]]] = None,
+            line_widths: Tuple[int, int] = (1, 2),
+            pit: Optional[Union[int, Tuple[int, int]]] = None,
             intervals: Optional[Union[int, List[Union[int, float]]]] = None,
             conversion: Optional[dict] = None) -> None:
         """
@@ -1162,9 +1010,11 @@ class ScenarioVisualizer:
 
         Parameters
         ----------
-        scada_data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData`, optional
-            The SCADA data object. If `None`, a simulation will be run to
-            generate it. Default is `None`.
+        data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData` or
+            `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_, optional
+            The SCADA data object containing link data or a numpy array of the
+            shape links*timesteps. If `None`, a simulation is run to generate
+            SCADA data. Default is `None`.
         parameter : `str`, optional
             The data used to resize to. Default is 'flow_rate'.
         statistic : `str`, optional
@@ -1187,37 +1037,37 @@ class ScenarioVisualizer:
             A dictionary of conversion parameters to convert SCADA data units.
             Default is `None`.
         """
+        sim_length = None
+
+        if data is not None:
+            self.scada_data = data
+            if not isinstance(self.scada_data, ScadaData):
+                sim_length = self.scada_data.shape[0]
+        elif not self.scada_data:
+            self.scada_data = self.__scenario.run_simulation()
+
+        if conversion:
+            self.scada_data = self.scada_data.convert_units(**conversion)
+
+        if sim_length is None:
+            sim_length = self.scada_data.sensor_readings_time.shape[0]
 
         if statistic == 'time_step' and isinstance(pit, tuple) and len(
                 pit) == 2 and all(isinstance(i, int) for i in pit):
-            sorted_values, sim_length = self.__get_link_data(scada_data,
-                                                             parameter,
-                                                             statistic, pit[0],
-                                                             intervals,
-                                                             conversion)
-            pipe_size_list = []
-            vmin = min(sorted_values)
-            vmax = max(sorted_values)
-            for frame in range(*pit):
-                if frame > sim_length - 1:
+            rng = pit
+            if pit[1] == -1:
+                rng = (pit[0], sim_length)
+            for frame in range(*rng):
+                if frame >= sim_length:
                     break
-                sorted_values, _ = self.__get_link_data(scada_data, parameter,
-                                                        statistic, frame,
-                                                        intervals, conversion)
-                vmin = min(*sorted_values, vmin)
-                vmax = max(*sorted_values, vmax)
-                pipe_size_list.append(sorted_values)
-            self.animation_dict['pipe_sizes'] = []
-            for vals in pipe_size_list:
-                self.animation_dict['pipe_sizes'].append(
-                    self.__rescale(vals, line_widths,
-                                   values_min_max=(vmin, vmax)))
+                self.pipe_parameters.add_frame(self.topology, 'edge_width',
+                                               self.scada_data, parameter,
+                                               statistic, frame, intervals)
         else:
-            sorted_values, _ = self.__get_link_data(scada_data, parameter,
-                                                    statistic, pit, intervals,
-                                                    conversion)
-            self.pipe_parameters.update(
-                {'width': self.__rescale(sorted_values, line_widths)})
+            self.pipe_parameters.add_frame(self.topology, 'edge_width',
+                                           self.scada_data, parameter,
+                                           statistic, pit, intervals)
+        self.pipe_parameters.rescale_widths(line_widths)
 
     def hide_nodes(self) -> None:
         """
@@ -1225,10 +1075,10 @@ class ScenarioVisualizer:
         visualization.
 
         This method clears the node list from the `junction_parameters`
-        dictionary, effectively removing all nodes from view in the current
+        class, effectively removing all nodes from view in the current
         visualization.
         """
-        self.junction_parameters['nodelist'] = []
+        self.junction_parameters.nodelist = []
 
     def highlight_sensor_config(self) -> None:
         """
@@ -1236,30 +1086,23 @@ class ScenarioVisualizer:
         the water distribution network visualization.
 
         This method identifies nodes and links equipped with different types of
-        sensors from the :class:`~epyt_flow.simulation.sensor_config.SensorConfig` and
+        sensors from the
+        :class:`~epyt_flow.simulation.sensor_config.SensorConfig` and
         updates their visual appearance. Nodes with sensors are highlighted
         with an orange border, while links with sensors are displayed with a
         dashed line style.
         """
-        highlighted_nodes = []
-        highlighted_links = []
-
-        sensor_config = self.__scenario.sensor_config
-        highlighted_nodes += (sensor_config.pressure_sensors
-                              + sensor_config.demand_sensors
-                              + sensor_config.quality_node_sensors)
-        highlighted_links += (sensor_config.flow_sensors
-                              + sensor_config.quality_link_sensors)
+        highlighted_nodes, highlighted_links = self._get_sensor_config_nodes_and_links()
 
         node_edges = [
             (17, 163, 252) if node in highlighted_nodes else (0, 0, 0) for node
             in self.topology]
-        pipe_style = ['dashed' if link in highlighted_links else 'solid' for
-                      link in self.topology]
+        pipe_style = ['dashed' if link[0] in highlighted_links else 'solid' for
+                      link in self.topology.get_all_links()]
 
-        self.junction_parameters.update(
+        self.junction_parameters.add_attributes(
             {'linewidths': 1, 'edgecolors': node_edges})
-        self.pipe_parameters.update({'style': pipe_style})
+        self.pipe_parameters.add_attributes({'style': pipe_style})
 
     @deprecated(reason="This function will be removed in feature versions, "
                        "please use show_plot() instead.")