11028671961

Committed 25 Sep 2024 07:50AM UTC coverage: 90.85% (+0.005%) from 90.845%

Build # 11028671961

Build Type

push

github

Committed by

Koaha

Commit Message

lint

Run Details

1322 of 1625 branches covered (81.35%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

4 existing lines in 1 file now uncovered.

5112 of 5457 relevant lines covered (93.68%)

0.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.38

/src/vitalDSP/health_analysis/health_report_visualization.py

import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
import os


class HealthReportVisualizer:
    """
    A class responsible for creating visualizations of health feature data, including line plots and heatmaps.

    The class takes feature data and creates visualizations, such as normal distributions for ranges and heatmaps, and stores them as images.
    """

    def __init__(self, config):
        """
        Initializes the Visualization class by loading the feature configuration.

        Args:
            config (dict): Configuration data that includes normal ranges and interpretations for features.

        Example Usage:
            >>> visualization = Visualization(config)
        """
        if not isinstance(config, dict):
            raise TypeError("Config should be a dictionary.")
        self.config = config

    def _fetch_and_validate_normal_range(self, feature, value):
        """
        Fetches the normal range for a given feature, handles NaN, Inf values, and validates the feature.

        Args:
            feature (str): The feature name.
            value (float): The current value for the feature.

        Returns:
            tuple: (normal_min, normal_max, feature_names) where feature_names are ["Min Range", "Max Range", "Current Value"].

        Raises:
            ValueError: If the feature has NaN or invalid values, or normal range is not found.
        """
        normal_range = self._get_normal_range_for_feature(feature)
        if not normal_range:
            # return None
            raise ValueError(f"Normal range for feature '{feature}' not found.")

        normal_min, normal_max = normal_range
        # feature_names = ["Min Range", "Max Range", "Current Value"]

        # Handle NaN and Inf cases
        if np.isnan(normal_min) or np.isnan(normal_max) or np.isnan(value):
            raise ValueError(f"NaN value encountered in feature '{feature}'.")

        if np.isinf(normal_min):
            normal_min = -10 * abs(value)
        if np.isinf(normal_max):
            normal_max = 10 * abs(value)

        return normal_min, normal_max

    def create_visualizations(self, feature_data, output_dir="visualizations"):
        """
        Creates visualizations for the provided feature data and saves them as image files.

        Args:
            feature_data (dict): Dictionary containing feature values.
            output_dir (str): Directory where the visualizations will be saved.

        Returns:
            dict: Dictionary with feature names as keys and paths to the saved visualizations as values.

        Example Usage:
            >>> visualizations = visualization.create_visualizations(feature_data)
            >>> print(visualizations)
        """
        if output_dir is None:
            output_dir = "visualizations"
            os.makedirs(output_dir, exist_ok=True)

        visualization_paths = {}

        for feature, values in feature_data.items():
            if isinstance(
                values, list
            ):  # Handle list (multiple segments) for each feature
                visualization_paths[feature] = {
                    "heatmap": os.path.normpath(
                        self._create_heatmap_plot(feature, values, output_dir)
                    ),
                    "bell_plot": os.path.normpath(
                        self._create_bell_shape_plot(feature, values, output_dir)
                    ),
                    "radar_plot": os.path.normpath(
                        self._create_radar_plot(feature, values, output_dir)
                    ),
                    "violin_plot": os.path.normpath(
                        self._create_violin_plot(feature, values, output_dir)
                    ),
                }
            else:
                # Handle single values
                visualization_paths[feature] = {
                    "heatmap": os.path.normpath(
                        self._create_heatmap_plot(feature, [values], output_dir)
                    ),
                    "bell_plot": os.path.normpath(
                        self._create_bell_shape_plot(feature, [values], output_dir)
                    ),
                    "radar_plot": os.path.normpath(
                        self._create_radar_plot(feature, [values], output_dir)
                    ),
                    "violin_plot": os.path.normpath(
                        self._create_violin_plot(feature, [values], output_dir)
                    ),
                }

        return visualization_paths

    def _create_bell_shape_plot(self, feature, values, output_dir):
        """
        Creates a bell shape plot with an overlaid histogram for better understanding.
        Caps outliers at 1.5 times the normal range.

        Args:
            feature (str): The name of the feature.
            values (list): List of values for the feature.
            output_dir (str): Directory where the plot will be saved.

        Returns:
            str: Path to the saved bell shape plot image.
        """
        normal_min, normal_max = self._fetch_and_validate_normal_range(
            feature, values[0]
        )

        # Outlier thresholds
        outlier_min = normal_min - 1.5 * (normal_max - normal_min)
        outlier_max = normal_max + 1.5 * (normal_max - normal_min)

        # Cap the values to fit the normal range
        capped_values = np.clip(values, outlier_min, outlier_max)

        # Generate histogram data with clear edges and a less dim color
        plt.figure(figsize=(8, 6))
        plt.hist(
            capped_values,
            bins=15,
            color="lightblue",
            alpha=0.7,
            edgecolor="black",
            label="Histogram",
        )

        # Generate x values for the bell curve
        x = np.linspace(outlier_min, outlier_max, 100)
        mean = (normal_min + normal_max) / 2
        stddev = (normal_max - normal_min) / 4
        y = np.exp(-((x - mean) ** 2) / (2 * stddev**2))

        # Plot the bell-shaped curve
        plt.plot(
            x,
            y * max(np.histogram(capped_values, bins=15)[0]),
            label="Bell Shape",
            color="blue",
        )

        # Mark the normal range and current value
        plt.axvline(
            normal_min, color="blue", linestyle="--", label=f"Normal Min: {normal_min}"
        )
        plt.axvline(
            normal_max, color="red", linestyle="--", label=f"Normal Max: {normal_max}"
        )
        plt.axvline(
            np.median(values),
            color="green",
            linestyle="-",
            label=f"Median: {np.median(values):.2f}",
        )

        # Title and labels
        plt.title(f"{feature} Bell Shape Plot with Histogram")
        plt.xlabel(f"{feature} Values")

        # Explicitly create the legend
        plt.legend(loc="upper right")

        # Save the plot
        filepath = os.path.join(output_dir, f"{feature}_bell_plot.png")
        plt.savefig(filepath, bbox_inches="tight")
        plt.close()

        return filepath

    def _create_violin_plot(self, feature, values, output_dir):
        """
        Creates an enhanced violin plot for visualizing the feature value compared to the normal range.

        Args:
            feature (str): The name of the feature.
            value (list): The values of the feature for the current segment.
            output_dir (str): Directory where the plot will be saved.

        Returns:
            str: Path to the saved violin plot image.
        """
        normal_min, normal_max = self._fetch_and_validate_normal_range(
            feature, values[0]
        )

        # Define the outlier threshold
        outlier_min = normal_min - 1.5 * (normal_max - normal_min)
        outlier_max = normal_max + 1.5 * (normal_max - normal_min)

        # Cap the values to fit within the plot and mark outliers
        capped_values = []
        for value in values:
            if value < outlier_min:
                capped_values.append(outlier_min)
            elif value > outlier_max:
                capped_values.append(outlier_max)
            else:
                capped_values.append(value)

        # Create data for the violin plot (normal distribution)
        data = np.random.normal(
            loc=(normal_max + normal_min) / 2,
            scale=(normal_max - normal_min) / 6,
            size=1000,
        )

        plt.figure(figsize=(8, 6))

        # Create violin plot for normal distribution
        sns.violinplot(data=data, color="lightgreen", inner="quartile")

        # Overlay shaded normal range
        plt.fill_between(
            [0, 1],
            normal_min,
            normal_max,
            color="lightblue",
            alpha=0.3,
            label="Normal Range",
        )

        # Add a horizontal line for the mean of the normal range
        mean_value = (normal_max + normal_min) / 2
        plt.axhline(
            mean_value,
            color="green",
            linestyle="--",
            label=f"Normal Range Mean: {mean_value:.2f}",
        )

        # Plot each value, marking capped values as outliers
        for value in capped_values:
            color = "red" if value == outlier_min or value == outlier_max else "blue"
            plt.scatter(0, value, color=color, zorder=5, s=100, edgecolors="black")

        plt.title(f"{feature} Violin Plot", fontsize=15)
        plt.xlabel(f"{feature} Values")

        # Add legend
        plt.legend(loc="upper right")

        # Save the plot
        filepath = os.path.join(output_dir, f"{feature}_violin_plot.png")
        plt.savefig(filepath, bbox_inches="tight")
        plt.close()

        return filepath

    def _create_heatmap_plot(self, feature, values, output_dir):
        """
        Creates a heatmap plot for visualizing the feature values with highlights for the normal range.

        Args:
            feature (str): The name of the feature.
            values (list): The list of values for the current segment.
            output_dir (str): Directory where the plot will be saved.

        Returns:
            str: Path to the saved heatmap plot image.
        """
        normal_min, normal_max = self._fetch_and_validate_normal_range(
            feature, values[0]
        )

        # Set outlier thresholds
        outlier_min = normal_min - 1.5 * (normal_max - normal_min)
        outlier_max = normal_max + 1.5 * (normal_max - normal_min)

        # Create x-axis values for the heatmap
        x = np.linspace(
            normal_min - 1.5 * (normal_max - normal_min),
            normal_max + 1.5 * (normal_max - normal_min),
            100,
        )
        y = np.exp(
            -((x - np.mean([normal_min, normal_max])) ** 2)
            / (2 * ((normal_max - normal_min) / 2) ** 2)
        )
        heatmap_data = np.outer(y, y)

        plt.figure(figsize=(8, 4))
        sns.heatmap(
            heatmap_data,
            cmap="coolwarm",
            cbar=False,
            xticklabels=False,
            yticklabels=False,
        )

        # Track the number of occurrences for each value
        value_counts = {}
        for value in values:
            capped_value = min(max(value, outlier_min), outlier_max)
            if capped_value in value_counts:
                value_counts[capped_value] += 1
            else:
                value_counts[capped_value] = 1

        # Plot scatter points with size based on frequency of the value
        for capped_value, count in value_counts.items():
            value_interp = np.interp(capped_value, x, np.linspace(0, 100, len(x)))
            scatter_size = 100 + (count - 1) * 50  # Increase size for repeated values
            plt.scatter(
                [value_interp],
                [50],
                color="#3498db",
                s=scatter_size,
                zorder=5,
                edgecolor="white",
            )

        # Mark the normal range
        plt.axvline(
            np.interp(normal_min, x, np.linspace(0, 100, len(x))),
            color="blue",
            linestyle="-",
            label="Normal Min",
        )
        plt.axvline(
            np.interp(normal_max, x, np.linspace(0, 100, len(x))),
            color="red",
            linestyle="-",
            label="Normal Max",
        )

        plt.title(f"Feature: {feature}\nNormal Range: [{normal_min}, {normal_max}]")
        plt.legend()

        # Save heatmap
        filepath = os.path.join(output_dir, f"{feature}_heatmap.png")
        plt.savefig(filepath, bbox_inches="tight")
        plt.close()

        return filepath

    def _create_radar_plot(self, feature, values, output_dir):
        """
        Creates an enhanced radar plot that shows how the feature value compares to the normal range.
        Each axis represents a different feature, and the plot shows how the current feature deviates
        from its normal range.

        Args:
            feature (str): The name of the feature.
            values (list): The list of values for the current segment.
            output_dir (str): Directory where the plot will be saved.

        Returns:
            str: Path to the saved radar plot image.
        """
        # Fetch normal range
        normal_min, normal_max = self._fetch_and_validate_normal_range(
            feature, values[0]
        )
        feature_names = ["Min Range", "Max Range", "Representative Value"]

        # Handle NaN and Inf cases
        if np.isnan(normal_min) or np.isnan(normal_max) or np.any(np.isnan(values)):
            raise ValueError(f"NaN value encountered in feature '{feature}'.")

        if np.isinf(normal_min):
            normal_min = -10 * abs(np.min(values))
        if np.isinf(normal_max):
            normal_max = 10 * abs(np.max(values))

        # Outlier thresholds
        outlier_min = normal_min - 1.5 * (normal_max - normal_min)
        outlier_max = normal_max + 1.5 * (normal_max - normal_min)

        # Cap the values to fit within the plot and mark outliers
        capped_values = np.clip(values, outlier_min, outlier_max)

        # Prepare the "normal range" triangle data
        normal_values = [normal_min, normal_max, (normal_min + normal_max) / 2]
        normal_values += normal_values[:1]  # Complete the loop

        # Prepare the "current value" triangle data: min, max, median of the capped values list
        current_value_triangle = [
            np.min(capped_values),
            np.max(capped_values),
            np.median(capped_values),
        ]
        current_value_triangle += current_value_triangle[:1]  # Complete the loop

        # Calculate angles for radar plot
        angles = np.linspace(0, 2 * np.pi, len(feature_names), endpoint=False).tolist()
        angles += angles[:1]  # Complete the loop for radar chart

        # Start plot
        fig, ax = plt.subplots(figsize=(6, 6), subplot_kw=dict(polar=True))

        # Configure axes
        ax.set_theta_offset(np.pi / 2)
        ax.set_theta_direction(-1)
        plt.xticks(angles[:-1], feature_names)

        # Set radial limits based on min and max of normal and capped data
        y_min = min(normal_min, np.min(capped_values))
        y_max = max(normal_max, np.max(capped_values))
        plt.ylim(y_min, y_max)

        # Plot normal range triangle
        ax.plot(
            angles,
            normal_values,
            linewidth=2,
            linestyle="solid",
            color="green",
            label="Normal Range",
        )
        ax.fill(angles, normal_values, color="green", alpha=0.3)

        # Plot actual values triangle (min, max, median)
        ax.plot(
            angles,
            current_value_triangle,
            linewidth=2,
            linestyle="solid",
            color="blue",
            label="Actual Values",
        )
        ax.fill(angles, current_value_triangle, color="blue", alpha=0.3)

        # Add a scatter point for the median value on the third axis
        median_value = np.median(capped_values)
        ax.scatter(
            angles[2], median_value, color="red", zorder=5, s=150, edgecolors="black"
        )

        # Mark outliers
        for value in values:
            if value < outlier_min or value > outlier_max:
                ax.scatter(
                    angles[2],
                    median_value,
                    color="orange",
                    zorder=5,
                    s=150,
                    edgecolors="black",
                    label="Outlier",
                )

        # Add a legend
        plt.legend(loc="upper right", bbox_to_anchor=(1.1, 1.1))

        # Save the plot
        filepath = os.path.join(output_dir, f"{feature}_radar_plot.png")
        plt.savefig(filepath, bbox_inches="tight")
        plt.close()

        return filepath

    def _get_normal_range_for_feature(self, feature):
        """
        Retrieves the normal range for a given feature from the loaded configuration.

        Args:
            feature (str): The name of the feature to get the normal range for.

        Returns:
            tuple: The (min, max) normal range values for the feature, or None if not found.

        Example Usage:
            >>> normal_range = visualization._get_normal_range_for_feature("RMSSD")
            >>> print(normal_range)  # Output: (20, 100)
        """
        feature_info = self.config.get(feature, {})
        normal_range = feature_info.get("normal_range", {}).get("1_min", None)
        if normal_range is not None:
            # Handle string '-inf' and 'inf' cases
            normal_range = [self._parse_inf_values(val) for val in normal_range]
        return normal_range

    def _parse_inf_values(self, val):
        """
        Parses 'inf' and '-inf' strings and converts them to numpy infinity values.

        Args:
            val (str or float): The value to parse.

        Returns:
            float: Parsed value where 'inf' or '-inf' are converted to np.inf or -np.inf respectively.

        Example Usage:
            >>> value = visualization._parse_inf_values("-inf")
            >>> print(value)  # Output: -inf
        """
        if isinstance(val, str):
            if val.lower() == "inf":
                return np.inf
            elif val.lower() == "-inf":
                return -np.inf
        return val

1	import matplotlib.pyplot as plt	1✔
2	import seaborn as sns	1✔
3	import numpy as np	1✔
4	import os	1✔
5
6
7	class HealthReportVisualizer:	1✔
8	"""
9	A class responsible for creating visualizations of health feature data, including line plots and heatmaps.
10
11	The class takes feature data and creates visualizations, such as normal distributions for ranges and heatmaps, and stores them as images.
12	"""
13
14	def __init__(self, config):	1✔
15	"""
16	Initializes the Visualization class by loading the feature configuration.
17
18	Args:
19	config (dict): Configuration data that includes normal ranges and interpretations for features.
20
21	Example Usage:
22	>>> visualization = Visualization(config)
23	"""
24	if not isinstance(config, dict):	1✔
25	raise TypeError("Config should be a dictionary.")	1✔
26	self.config = config	1✔
27
28	def _fetch_and_validate_normal_range(self, feature, value):	1✔
29	"""
30	Fetches the normal range for a given feature, handles NaN, Inf values, and validates the feature.
31
32	Args:
33	feature (str): The feature name.
34	value (float): The current value for the feature.
35
36	Returns:
37	tuple: (normal_min, normal_max, feature_names) where feature_names are ["Min Range", "Max Range", "Current Value"].
38
39	Raises:
40	ValueError: If the feature has NaN or invalid values, or normal range is not found.
41	"""
42	normal_range = self._get_normal_range_for_feature(feature)	1✔
43	if not normal_range:	1!
44	# return None
45	raise ValueError(f"Normal range for feature '{feature}' not found.")	×
46
47	normal_min, normal_max = normal_range	1✔
48	# feature_names = ["Min Range", "Max Range", "Current Value"]
49
50	# Handle NaN and Inf cases
51	if np.isnan(normal_min) or np.isnan(normal_max) or np.isnan(value):	1!
52	raise ValueError(f"NaN value encountered in feature '{feature}'.")	×
53
54	if np.isinf(normal_min):	1!
55	normal_min = -10 * abs(value)	×
56	if np.isinf(normal_max):	1!
57	normal_max = 10 * abs(value)	×
58
59	return normal_min, normal_max	1✔
60
61	def create_visualizations(self, feature_data, output_dir="visualizations"):	1✔
62	"""
63	Creates visualizations for the provided feature data and saves them as image files.
64
65	Args:
66	feature_data (dict): Dictionary containing feature values.
67	output_dir (str): Directory where the visualizations will be saved.
68
69	Returns:
70	dict: Dictionary with feature names as keys and paths to the saved visualizations as values.
71
72	Example Usage:
73	>>> visualizations = visualization.create_visualizations(feature_data)
74	>>> print(visualizations)
75	"""
76	if output_dir is None:	1✔
77	output_dir = "visualizations"	1✔
78	os.makedirs(output_dir, exist_ok=True)	1✔
79
80	visualization_paths = {}	1✔
81
82	for feature, values in feature_data.items():	1✔
83	if isinstance(	1!
84	values, list
85	): # Handle list (multiple segments) for each feature
86	visualization_paths[feature] = {	1✔
87	"heatmap": os.path.normpath(
88	self._create_heatmap_plot(feature, values, output_dir)
89	),
90	"bell_plot": os.path.normpath(
91	self._create_bell_shape_plot(feature, values, output_dir)
92	),
93	"radar_plot": os.path.normpath(
94	self._create_radar_plot(feature, values, output_dir)
95	),
96	"violin_plot": os.path.normpath(
97	self._create_violin_plot(feature, values, output_dir)
98	),
99	}
100	else:
101	# Handle single values
UNCOV 102	visualization_paths[feature] = {	×
103	"heatmap": os.path.normpath(
104	self._create_heatmap_plot(feature, [values], output_dir)
105	),
106	"bell_plot": os.path.normpath(
107	self._create_bell_shape_plot(feature, [values], output_dir)
108	),
109	"radar_plot": os.path.normpath(
110	self._create_radar_plot(feature, [values], output_dir)
111	),
112	"violin_plot": os.path.normpath(
113	self._create_violin_plot(feature, [values], output_dir)
114	),
115	}
116
117	return visualization_paths	1✔
118
119	def _create_bell_shape_plot(self, feature, values, output_dir):	1✔
120	"""
121	Creates a bell shape plot with an overlaid histogram for better understanding.
122	Caps outliers at 1.5 times the normal range.
123
124	Args:
125	feature (str): The name of the feature.
126	values (list): List of values for the feature.
127	output_dir (str): Directory where the plot will be saved.
128
129	Returns:
130	str: Path to the saved bell shape plot image.
131	"""
132	normal_min, normal_max = self._fetch_and_validate_normal_range(	1✔
133	feature, values[0]
134	)
135
136	# Outlier thresholds
137	outlier_min = normal_min - 1.5 * (normal_max - normal_min)	1✔
138	outlier_max = normal_max + 1.5 * (normal_max - normal_min)	1✔
139
140	# Cap the values to fit the normal range
141	capped_values = np.clip(values, outlier_min, outlier_max)	1✔
142
143	# Generate histogram data with clear edges and a less dim color
144	plt.figure(figsize=(8, 6))	1✔
145	plt.hist(	1✔
146	capped_values,
147	bins=15,
148	color="lightblue",
149	alpha=0.7,
150	edgecolor="black",
151	label="Histogram",
152	)
153
154	# Generate x values for the bell curve
155	x = np.linspace(outlier_min, outlier_max, 100)	1✔
156	mean = (normal_min + normal_max) / 2	1✔
157	stddev = (normal_max - normal_min) / 4	1✔
158	y = np.exp(-((x - mean) ** 2) / (2 * stddev**2))	1✔
159
160	# Plot the bell-shaped curve
161	plt.plot(	1✔
162	x,
163	y * max(np.histogram(capped_values, bins=15)[0]),
164	label="Bell Shape",
165	color="blue",
166	)
167
168	# Mark the normal range and current value
169	plt.axvline(	1✔
170	normal_min, color="blue", linestyle="--", label=f"Normal Min: {normal_min}"
171	)
172	plt.axvline(	1✔
173	normal_max, color="red", linestyle="--", label=f"Normal Max: {normal_max}"
174	)
175	plt.axvline(	1✔
176	np.median(values),
177	color="green",
178	linestyle="-",
179	label=f"Median: {np.median(values):.2f}",
180	)
181
182	# Title and labels
183	plt.title(f"{feature} Bell Shape Plot with Histogram")	1✔
184	plt.xlabel(f"{feature} Values")	1✔
185
186	# Explicitly create the legend
187	plt.legend(loc="upper right")	1✔
188
189	# Save the plot
190	filepath = os.path.join(output_dir, f"{feature}_bell_plot.png")	1✔
191	plt.savefig(filepath, bbox_inches="tight")	1✔
192	plt.close()	1✔
193
194	return filepath	1✔
195
196	def _create_violin_plot(self, feature, values, output_dir):	1✔
197	"""
198	Creates an enhanced violin plot for visualizing the feature value compared to the normal range.
199
200	Args:
201	feature (str): The name of the feature.
202	value (list): The values of the feature for the current segment.
203	output_dir (str): Directory where the plot will be saved.
204
205	Returns:
206	str: Path to the saved violin plot image.
207	"""
208	normal_min, normal_max = self._fetch_and_validate_normal_range(	1✔
209	feature, values[0]
210	)
211
212	# Define the outlier threshold
213	outlier_min = normal_min - 1.5 * (normal_max - normal_min)	1✔
214	outlier_max = normal_max + 1.5 * (normal_max - normal_min)	1✔
215
216	# Cap the values to fit within the plot and mark outliers
217	capped_values = []	1✔
218	for value in values:	1✔
219	if value < outlier_min:	1!
UNCOV 220	capped_values.append(outlier_min)	×
221	elif value > outlier_max:	1✔
222	capped_values.append(outlier_max)	1✔
223	else:
224	capped_values.append(value)	1✔
225
226	# Create data for the violin plot (normal distribution)
227	data = np.random.normal(	1✔
228	loc=(normal_max + normal_min) / 2,
229	scale=(normal_max - normal_min) / 6,
230	size=1000,
231	)
232
233	plt.figure(figsize=(8, 6))	1✔
234
235	# Create violin plot for normal distribution
236	sns.violinplot(data=data, color="lightgreen", inner="quartile")	1✔
237
238	# Overlay shaded normal range
239	plt.fill_between(	1✔
240	[0, 1],
241	normal_min,
242	normal_max,
243	color="lightblue",
244	alpha=0.3,
245	label="Normal Range",
246	)
247
248	# Add a horizontal line for the mean of the normal range
249	mean_value = (normal_max + normal_min) / 2	1✔
250	plt.axhline(	1✔
251	mean_value,
252	color="green",
253	linestyle="--",
254	label=f"Normal Range Mean: {mean_value:.2f}",
255	)
256
257	# Plot each value, marking capped values as outliers
258	for value in capped_values:	1✔
259	color = "red" if value == outlier_min or value == outlier_max else "blue"	1✔
260	plt.scatter(0, value, color=color, zorder=5, s=100, edgecolors="black")	1✔
261
262	plt.title(f"{feature} Violin Plot", fontsize=15)	1✔
263	plt.xlabel(f"{feature} Values")	1✔
264
265	# Add legend
266	plt.legend(loc="upper right")	1✔
267
268	# Save the plot
269	filepath = os.path.join(output_dir, f"{feature}_violin_plot.png")	1✔
270	plt.savefig(filepath, bbox_inches="tight")	1✔
271	plt.close()	1✔
272
273	return filepath	1✔
274
275	def _create_heatmap_plot(self, feature, values, output_dir):	1✔
276	"""
277	Creates a heatmap plot for visualizing the feature values with highlights for the normal range.
278
279	Args:
280	feature (str): The name of the feature.
281	values (list): The list of values for the current segment.
282	output_dir (str): Directory where the plot will be saved.
283
284	Returns:
285	str: Path to the saved heatmap plot image.
286	"""
287	normal_min, normal_max = self._fetch_and_validate_normal_range(	1✔
288	feature, values[0]
289	)
290
291	# Set outlier thresholds
292	outlier_min = normal_min - 1.5 * (normal_max - normal_min)	1✔
293	outlier_max = normal_max + 1.5 * (normal_max - normal_min)	1✔
294
295	# Create x-axis values for the heatmap
296	x = np.linspace(	1✔
297	normal_min - 1.5 * (normal_max - normal_min),
298	normal_max + 1.5 * (normal_max - normal_min),
299	100,
300	)
301	y = np.exp(	1✔
302	-((x - np.mean([normal_min, normal_max])) ** 2)
303	/ (2 * ((normal_max - normal_min) / 2) ** 2)
304	)
305	heatmap_data = np.outer(y, y)	1✔
306
307	plt.figure(figsize=(8, 4))	1✔
308	sns.heatmap(	1✔
309	heatmap_data,
310	cmap="coolwarm",
311	cbar=False,
312	xticklabels=False,
313	yticklabels=False,
314	)
315
316	# Track the number of occurrences for each value
317	value_counts = {}	1✔
318	for value in values:	1✔
319	capped_value = min(max(value, outlier_min), outlier_max)	1✔
320	if capped_value in value_counts:	1✔
321	value_counts[capped_value] += 1	1✔
322	else:
323	value_counts[capped_value] = 1	1✔
324
325	# Plot scatter points with size based on frequency of the value
326	for capped_value, count in value_counts.items():	1✔
327	value_interp = np.interp(capped_value, x, np.linspace(0, 100, len(x)))	1✔
328	scatter_size = 100 + (count - 1) * 50 # Increase size for repeated values	1✔
329	plt.scatter(	1✔
330	[value_interp],
331	[50],
332	color="#3498db",
333	s=scatter_size,
334	zorder=5,
335	edgecolor="white",
336	)
337
338	# Mark the normal range
339	plt.axvline(	1✔
340	np.interp(normal_min, x, np.linspace(0, 100, len(x))),
341	color="blue",
342	linestyle="-",
343	label="Normal Min",
344	)
345	plt.axvline(	1✔
346	np.interp(normal_max, x, np.linspace(0, 100, len(x))),
347	color="red",
348	linestyle="-",
349	label="Normal Max",
350	)
351
352	plt.title(f"Feature: {feature}\nNormal Range: [{normal_min}, {normal_max}]")	1✔
353	plt.legend()	1✔
354
355	# Save heatmap
356	filepath = os.path.join(output_dir, f"{feature}_heatmap.png")	1✔
357	plt.savefig(filepath, bbox_inches="tight")	1✔
358	plt.close()	1✔
359
360	return filepath	1✔
361
362	def _create_radar_plot(self, feature, values, output_dir):	1✔
363	"""
364	Creates an enhanced radar plot that shows how the feature value compares to the normal range.
365	Each axis represents a different feature, and the plot shows how the current feature deviates
366	from its normal range.
367
368	Args:
369	feature (str): The name of the feature.
370	values (list): The list of values for the current segment.
371	output_dir (str): Directory where the plot will be saved.
372
373	Returns:
374	str: Path to the saved radar plot image.
375	"""
376	# Fetch normal range
377	normal_min, normal_max = self._fetch_and_validate_normal_range(	1✔
378	feature, values[0]
379	)
380	feature_names = ["Min Range", "Max Range", "Representative Value"]	1✔
381
382	# Handle NaN and Inf cases
383	if np.isnan(normal_min) or np.isnan(normal_max) or np.any(np.isnan(values)):	1!
UNCOV 384	raise ValueError(f"NaN value encountered in feature '{feature}'.")	×
385
386	if np.isinf(normal_min):	1!
387	normal_min = -10 * abs(np.min(values))	×
388	if np.isinf(normal_max):	1!
UNCOV 389	normal_max = 10 * abs(np.max(values))	×
390
391	# Outlier thresholds
392	outlier_min = normal_min - 1.5 * (normal_max - normal_min)	1✔
393	outlier_max = normal_max + 1.5 * (normal_max - normal_min)	1✔
394
395	# Cap the values to fit within the plot and mark outliers
396	capped_values = np.clip(values, outlier_min, outlier_max)	1✔
397
398	# Prepare the "normal range" triangle data
399	normal_values = [normal_min, normal_max, (normal_min + normal_max) / 2]	1✔
400	normal_values += normal_values[:1] # Complete the loop	1✔
401
402	# Prepare the "current value" triangle data: min, max, median of the capped values list
403	current_value_triangle = [	1✔
404	np.min(capped_values),
405	np.max(capped_values),
406	np.median(capped_values),
407	]
408	current_value_triangle += current_value_triangle[:1] # Complete the loop	1✔
409
410	# Calculate angles for radar plot
411	angles = np.linspace(0, 2 * np.pi, len(feature_names), endpoint=False).tolist()	1✔
412	angles += angles[:1] # Complete the loop for radar chart	1✔
413
414	# Start plot
415	fig, ax = plt.subplots(figsize=(6, 6), subplot_kw=dict(polar=True))	1✔
416
417	# Configure axes
418	ax.set_theta_offset(np.pi / 2)	1✔
419	ax.set_theta_direction(-1)	1✔
420	plt.xticks(angles[:-1], feature_names)	1✔
421
422	# Set radial limits based on min and max of normal and capped data
423	y_min = min(normal_min, np.min(capped_values))	1✔
424	y_max = max(normal_max, np.max(capped_values))	1✔
425	plt.ylim(y_min, y_max)	1✔
426
427	# Plot normal range triangle
428	ax.plot(	1✔
429	angles,
430	normal_values,
431	linewidth=2,
432	linestyle="solid",
433	color="green",
434	label="Normal Range",
435	)
436	ax.fill(angles, normal_values, color="green", alpha=0.3)	1✔
437
438	# Plot actual values triangle (min, max, median)
439	ax.plot(	1✔
440	angles,
441	current_value_triangle,
442	linewidth=2,
443	linestyle="solid",
444	color="blue",
445	label="Actual Values",
446	)
447	ax.fill(angles, current_value_triangle, color="blue", alpha=0.3)	1✔
448
449	# Add a scatter point for the median value on the third axis
450	median_value = np.median(capped_values)	1✔
451	ax.scatter(	1✔
452	angles[2], median_value, color="red", zorder=5, s=150, edgecolors="black"
453	)
454
455	# Mark outliers
456	for value in values:	1✔
457	if value < outlier_min or value > outlier_max:	1✔
458	ax.scatter(	1✔
459	angles[2],
460	median_value,
461	color="orange",
462	zorder=5,
463	s=150,
464	edgecolors="black",
465	label="Outlier",
466	)
467
468	# Add a legend
469	plt.legend(loc="upper right", bbox_to_anchor=(1.1, 1.1))	1✔
470
471	# Save the plot
472	filepath = os.path.join(output_dir, f"{feature}_radar_plot.png")	1✔
473	plt.savefig(filepath, bbox_inches="tight")	1✔
474	plt.close()	1✔
475
476	return filepath	1✔
477
478	def _get_normal_range_for_feature(self, feature):	1✔
479	"""
480	Retrieves the normal range for a given feature from the loaded configuration.
481
482	Args:
483	feature (str): The name of the feature to get the normal range for.
484
485	Returns:
486	tuple: The (min, max) normal range values for the feature, or None if not found.
487
488	Example Usage:
489	>>> normal_range = visualization._get_normal_range_for_feature("RMSSD")
490	>>> print(normal_range) # Output: (20, 100)
491	"""
492	feature_info = self.config.get(feature, {})	1✔
493	normal_range = feature_info.get("normal_range", {}).get("1_min", None)	1✔
494	if normal_range is not None:	1!
495	# Handle string '-inf' and 'inf' cases
496	normal_range = [self._parse_inf_values(val) for val in normal_range]	1✔
497	return normal_range	1✔
498
499	def _parse_inf_values(self, val):	1✔
500	"""
501	Parses 'inf' and '-inf' strings and converts them to numpy infinity values.
502
503	Args:
504	val (str or float): The value to parse.
505
506	Returns:
507	float: Parsed value where 'inf' or '-inf' are converted to np.inf or -np.inf respectively.
508
509	Example Usage:
510	>>> value = visualization._parse_inf_values("-inf")
511	>>> print(value) # Output: -inf
512	"""
513	if isinstance(val, str):	1✔
514	if val.lower() == "inf":	1✔
515	return np.inf	1✔
516	elif val.lower() == "-inf":	1!
517	return -np.inf	1✔
518	return val	1✔

Oucru-Innovations / vital-DSP / 11028671961

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous