AeroViz 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

AeroViz/plot/utils/_color.py

@@ -9,63 +9,63 @@ __all__ = ['Color']
 
 
 class Color:
-	color_cycle = cycler(color=['b', 'g', 'r', 'c', 'm', 'y', 'k'])
-
-	linecolor = [{'line': '#1a56db', 'edge': '#0F50A6', 'face': '#5983D9'},
-				 {'line': '#046c4e', 'edge': '#1B591F', 'face': '#538C4A'},
-				 {'line': '#c81e1e', 'edge': '#f05252', 'face': '#f98080'}]
-
-	# colors = ['#FF3333', '#33FF33', '#FFFF33', '#5555FF', '#B94FFF', '#AAAAAA', '#748690'] # the last one is "unknown"
-
-	colors1 = ['#A65E58', '#A5BF6B', '#F2BF5E', '#3F83BF', '#B777C2', '#D1CFCB']
-	colors2 = ['#A65E58', '#A5BF6B', '#F2BF5E', '#3F83BF', '#B777C2', '#D1CFCB', '#96c8e6']
-	colors3 = ['#A65E58', '#A5BF6B', '#a6710d', '#F2BF5E', '#3F83BF', '#B777C2', '#D1CFCB', '#96c8e6']  # POC SOC
-
-	colors_mutiWater = ['#A65E58', '#c18e8a', '#A5BF6B', '#c5d6a0', '#F2BF5E', '#3F83BF', '#c089ca', '#d3acda',
-						'#D1CFCB']
-	colors_mutiWater2 = ['#A65E58', '#96c8e6', '#A5BF6B', '#96c8e6', '#F2BF5E', '#3F83BF', '#c089ca', '#96c8e6',
-						 '#D1CFCB']  # water
-
-	color_choose = {'Clean': ['#1d4a9f', '#84a7e9'],
-					'Transition': ['#4a9f1d', '#a7e984'],
-					'Event': ['#9f1d4a', '#e984a7']}
-
-	paired = [plt.get_cmap('Paired')(i) for i in range(4)]
-
-	@staticmethod
-	def getColor(num: int = 6, cmap: str = 'jet_r'):
-		category_colors = plt.colormaps[cmap](np.linspace(0.1, 0.9, num))
-		return [plc.to_hex(category_colors[i]) for i in range(num)]
-
-	@staticmethod
-	def palplot(*args, **kwargs):
-		sns.palplot(*args, **kwargs)
-
-	@staticmethod
-	def adjust_opacity(colors: str | list[str], alpha: float):
-		if isinstance(colors, str):
-			colors = [colors]
-
-		adjusted_colors = []
-		for color in colors:
-			# 將顏色轉換為RGB表示
-			r, g, b = int(color[1:3], 16), int(color[3:5], 16), int(color[5:7], 16)
-			# 調整透明度
-			r_new = int(alpha * r + (1 - alpha) * 255)
-			g_new = int(alpha * g + (1 - alpha) * 255)
-			b_new = int(alpha * b + (1 - alpha) * 255)
-			# 轉換為新的色碼
-			new_color = '#{:02X}{:02X}{:02X}'.format(r_new, g_new, b_new)
-			adjusted_colors.append(new_color)
-		return adjusted_colors
-
-	@staticmethod
-	def color_maker(obj, cmap='Blues'):
-		colors = np.nan_to_num(obj, nan=0)
-		scalar_map = plt.cm.ScalarMappable(cmap=colormaps[cmap])  # create a scalar map for the colorbar
-		scalar_map.set_array(colors)
-		return scalar_map, colors
+    color_cycle = cycler(color=['b', 'g', 'r', 'c', 'm', 'y', 'k'])
+
+    linecolor = [{'line': '#1a56db', 'edge': '#0F50A6', 'face': '#5983D9'},
+                 {'line': '#046c4e', 'edge': '#1B591F', 'face': '#538C4A'},
+                 {'line': '#c81e1e', 'edge': '#f05252', 'face': '#f98080'}]
+
+    # colors = ['#FF3333', '#33FF33', '#FFFF33', '#5555FF', '#B94FFF', '#AAAAAA', '#748690'] # the last one is "unknown"
+
+    colors1 = ['#A65E58', '#A5BF6B', '#F2BF5E', '#3F83BF', '#B777C2', '#D1CFCB']
+    colors2 = ['#A65E58', '#A5BF6B', '#F2BF5E', '#3F83BF', '#B777C2', '#D1CFCB', '#96c8e6']
+    colors3 = ['#A65E58', '#A5BF6B', '#a6710d', '#F2BF5E', '#3F83BF', '#B777C2', '#D1CFCB', '#96c8e6']  # POC SOC
+
+    colors_mutiWater = ['#A65E58', '#c18e8a', '#A5BF6B', '#c5d6a0', '#F2BF5E', '#3F83BF', '#c089ca', '#d3acda',
+                        '#D1CFCB']
+    colors_mutiWater2 = ['#A65E58', '#96c8e6', '#A5BF6B', '#96c8e6', '#F2BF5E', '#3F83BF', '#c089ca', '#96c8e6',
+                         '#D1CFCB']  # water
+
+    color_choose = {'Clean': ['#1d4a9f', '#84a7e9'],
+                    'Transition': ['#4a9f1d', '#a7e984'],
+                    'Event': ['#9f1d4a', '#e984a7']}
+
+    paired = [plt.get_cmap('Paired')(i) for i in range(4)]
+
+    @staticmethod
+    def getColor(num: int = 6, cmap: str = 'jet_r'):
+        category_colors = plt.colormaps[cmap](np.linspace(0.1, 0.9, num))
+        return [plc.to_hex(category_colors[i]) for i in range(num)]
+
+    @staticmethod
+    def palplot(*args, **kwargs):
+        sns.palplot(*args, **kwargs)
+
+    @staticmethod
+    def adjust_opacity(colors: str | list[str], alpha: float):
+        if isinstance(colors, str):
+            colors = [colors]
+
+        adjusted_colors = []
+        for color in colors:
+            # 將顏色轉換為RGB表示
+            r, g, b = int(color[1:3], 16), int(color[3:5], 16), int(color[5:7], 16)
+            # 調整透明度
+            r_new = int(alpha * r + (1 - alpha) * 255)
+            g_new = int(alpha * g + (1 - alpha) * 255)
+            b_new = int(alpha * b + (1 - alpha) * 255)
+            # 轉換為新的色碼
+            new_color = '#{:02X}{:02X}{:02X}'.format(r_new, g_new, b_new)
+            adjusted_colors.append(new_color)
+        return adjusted_colors
+
+    @staticmethod
+    def color_maker(obj, cmap='Blues'):
+        colors = np.nan_to_num(obj, nan=0)
+        scalar_map = plt.cm.ScalarMappable(cmap=colormaps[cmap])  # create a scalar map for the colorbar
+        scalar_map.set_array(colors)
+        return scalar_map, colors
 
 
 if __name__ == '__main__':
-	Color.palplot(Color.colors2)
+    Color.palplot(Color.colors2)

AeroViz/plot/utils/_unit.py

@@ -5,51 +5,51 @@ __all__ = ['Unit']
 
 
 class Unit:
-	file_path = Path(__file__).parent / 'units.json'
-	data = None
-
-	def __new__(cls, unit: str):
-		cls.data = cls.load_jsonfile()
-		try:
-			value = cls.data[unit]
-			return r'${}$'.format(value.replace(' ', r'\ '))
-		except KeyError:
-			print(f"Attribute '{unit}' not found. Using default value.")
-			return r'${}$'.format(unit.replace(' ', r'\ ')) if unit is not None else 'None'
-
-	@classmethod
-	def load_jsonfile(cls):
-		""" 讀取 JSON 檔中數據并將其變成屬性 """
-		try:
-			with open(cls.file_path, 'r', encoding='utf-8') as f:
-				return json.load(f)
-
-		except FileNotFoundError:
-			print(f"JSON file '{cls.file_path}' not found.")
-		except json.JSONDecodeError:
-			print(f"Invalid JSON format in '{cls.file_path}'.")
-
-	@classmethod
-	def update_jsonfile(cls, key, value):
-		""" 更新JSON檔 """
-		with open(cls.file_path, 'r', encoding='utf-8') as f:
-			old_data = json.load(f)
-
-		old_data[key] = value
-
-		with open(cls.file_path, 'w', encoding='utf-8') as f:
-			json.dump(old_data, f, indent=4)
-
-	@classmethod
-	def del_jsonfile(cls, key):
-		""" 更新JSON檔 """
-		with open(cls.file_path, 'r', encoding='utf-8') as f:
-			old_data = json.load(f)
-
-		if key in old_data:
-			del old_data[key]
-
-			with open(cls.file_path, 'w', encoding='utf-8') as f:
-				json.dump(old_data, f, indent=4)
-		else:
-			print(f"Key '{key}' not found.")
+    file_path = Path(__file__).parent / 'units.json'
+    data = None
+
+    def __new__(cls, unit: str):
+        cls.data = cls.load_jsonfile()
+        try:
+            value = cls.data[unit]
+            return r'${}$'.format(value.replace(' ', r'\ '))
+        except KeyError:
+            print(f"Attribute '{unit}' not found. Using default value.")
+            return r'${}$'.format(unit.replace(' ', r'\ ')) if unit is not None else 'None'
+
+    @classmethod
+    def load_jsonfile(cls):
+        """ 讀取 JSON 檔中數據并將其變成屬性 """
+        try:
+            with open(cls.file_path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+
+        except FileNotFoundError:
+            print(f"JSON file '{cls.file_path}' not found.")
+        except json.JSONDecodeError:
+            print(f"Invalid JSON format in '{cls.file_path}'.")
+
+    @classmethod
+    def update_jsonfile(cls, key, value):
+        """ 更新JSON檔 """
+        with open(cls.file_path, 'r', encoding='utf-8') as f:
+            old_data = json.load(f)
+
+        old_data[key] = value
+
+        with open(cls.file_path, 'w', encoding='utf-8') as f:
+            json.dump(old_data, f, indent=4)
+
+    @classmethod
+    def del_jsonfile(cls, key):
+        """ 更新JSON檔 """
+        with open(cls.file_path, 'r', encoding='utf-8') as f:
+            old_data = json.load(f)
+
+        if key in old_data:
+            del old_data[key]
+
+            with open(cls.file_path, 'w', encoding='utf-8') as f:
+                json.dump(old_data, f, indent=4)
+        else:
+            print(f"Key '{key}' not found.")

AeroViz/plot/utils/plt_utils.py

@@ -0,0 +1,92 @@
+from functools import wraps
+from typing import Literal
+
+import matplotlib.pyplot as plt
+from matplotlib.pyplot import Axes
+
+__all__ = ['set_figure', 'combine_legends', 'auto_label_pct']
+
+
+def set_figure(func=None,
+               *,
+               figsize: tuple | None = None,
+               fs: int | None = None,
+               fw: str = None,
+               autolayout: bool = True):
+    # For more details please see https://matplotlib.org/stable/users/explain/customizing.html
+    def decorator(_func):
+        @wraps(_func)
+        def wrapper(*args, **kwargs):
+            print(f'\n\tPlot:\033[96m {_func.__name__}\033[0m')
+
+            plt.rcParams['mathtext.fontset'] = 'custom'
+            plt.rcParams['mathtext.rm'] = 'Times New Roman'
+            plt.rcParams['mathtext.it'] = 'Times New Roman: italic'
+            plt.rcParams['mathtext.bf'] = 'Times New Roman: bold'
+            plt.rcParams['mathtext.default'] = 'regular'
+
+            # The font properties used by `text.Text`.
+            # The text, annotate, label, title, ticks, are used to create text
+            plt.rcParams['font.family'] = 'Times New Roman'
+            plt.rcParams['font.weight'] = fw or 'normal'
+            plt.rcParams['font.size'] = fs or 8
+
+            plt.rcParams['axes.titlesize'] = 'large'
+            plt.rcParams['axes.titleweight'] = 'bold'
+            plt.rcParams['axes.labelweight'] = 'bold'
+
+            # color
+            plt.rcParams['axes.prop_cycle'] = plt.cycler(color=['b', 'g', 'r', 'c', 'm', 'y', 'k'])
+
+            plt.rcParams['xtick.labelsize'] = 'medium'
+            plt.rcParams['ytick.labelsize'] = 'medium'
+
+            # matplotlib.font_manager.FontProperties ---> matplotlib.rcParams
+            plt.rcParams['legend.loc'] = 'best'
+            plt.rcParams['legend.frameon'] = False
+            plt.rcParams['legend.fontsize'] = 'small'
+            plt.rcParams['legend.title_fontsize'] = 'medium'
+            plt.rcParams['legend.handlelength'] = 1.5
+            plt.rcParams['legend.labelspacing'] = 0.7
+
+            plt.rcParams['figure.figsize'] = figsize or (4, 4)
+            plt.rcParams['figure.dpi'] = 200
+            plt.rcParams['figure.autolayout'] = autolayout
+
+            if not autolayout:
+                plt.rcParams['figure.subplot.left'] = 0.1
+                plt.rcParams['figure.subplot.right'] = 0.875
+                plt.rcParams['figure.subplot.top'] = 0.875
+                plt.rcParams['figure.subplot.bottom'] = 0.125
+
+            # plt.rcParams['figure.constrained_layout.use'] = True
+
+            plt.rcParams['savefig.transparent'] = True
+
+            return _func(*args, **kwargs)
+
+        return wrapper
+
+    if func is None:
+        return decorator
+
+    return decorator(func)
+
+
+def combine_legends(axes_list: list[Axes]) -> tuple[list, list]:
+    return (
+        [legend for axes in axes_list for legend in axes.get_legend_handles_labels()[0]],
+        [label for axes in axes_list for label in axes.get_legend_handles_labels()[1]]
+    )
+
+
+def auto_label_pct(pct,
+                   symbol: bool = True,
+                   include_pct: bool = False,
+                   ignore: Literal["inner", "outer"] = 'inner',
+                   value: float = 2):
+    if not symbol:
+        return ''
+    cond = pct <= value if ignore == 'inner' else pct > value
+    label = '' if cond else '{:.1f}'.format(pct)
+    return '' if label == '' else label + '%' if include_pct else label

AeroViz/plot/utils/sklearn_utils.py

@@ -0,0 +1,49 @@
+import numpy as np
+from sklearn.linear_model import LinearRegression
+from tabulate import tabulate
+
+__all__ = ['linear_regression_base']
+
+
+def linear_regression_base(x_array: np.ndarray,
+                           y_array: np.ndarray,
+                           columns: str | list[str] | None = None,
+                           positive: bool = True,
+                           fit_intercept: bool = True):
+    if len(x_array.shape) > 1 and x_array.shape[1] >= 2:
+        model = LinearRegression(positive=positive, fit_intercept=fit_intercept).fit(x_array, y_array)
+
+        coefficients = model.coef_[0].round(3)
+        intercept = model.intercept_[0].round(3) if fit_intercept else 'None'
+        r_square = model.score(x_array, y_array).__round__(3)
+        y_predict = model.predict(x_array)
+
+        equation = ' + '.join([f'{coeff:.3f} * {col}' for coeff, col in zip(coefficients, columns)])
+        equation = equation.replace(' + 0.000 * Const', '')  # Remove terms with coefficient 0
+
+        text = 'y = ' + str(equation) + '\n' + r'$\bf R^2 = $' + str(r_square)
+        tab = tabulate([[*coefficients, intercept, r_square]], headers=[*columns, 'intercept', 'R^2'], floatfmt=".3f",
+                       tablefmt="fancy_grid")
+        print('\n' + tab)
+
+        return text, y_predict, coefficients
+
+    else:
+        x_array = x_array.reshape(-1, 1)
+        y_array = y_array.reshape(-1, 1)
+
+        model = LinearRegression(positive=positive, fit_intercept=fit_intercept).fit(x_array, y_array)
+
+        slope = model.coef_[0][0].round(3)
+        intercept = model.intercept_[0].round(3) if fit_intercept else 'None'
+        r_square = model.score(x_array, y_array).__round__(3)
+        y_predict = model.predict(x_array)
+
+        text = np.poly1d([slope, intercept])
+        text = 'y = ' + str(text).replace('\n', "") + '\n' + r'$\bf R^2 = $' + str(r_square)
+
+        tab = tabulate([[slope, intercept, r_square]], headers=['slope', 'intercept', 'R^2'], floatfmt=".3f",
+                       tablefmt="fancy_grid")
+        print('\n' + tab)
+
+        return text, y_predict, slope

AeroViz/plot/utils/units.json

@@ -6,6 +6,8 @@
   "T_OC": "OC (\u00b5g/m^3)",
   "PM1": "PM_{1} (\u00b5g/m^3)",
   "PM25": "PM_{2.5} (\u00b5g/m^3)",
+  "PM2.5": "PM_{2.5} (\u00b5g/m^3)",
+  "PM10": "PM_{10} (\u00b5g/m^3)",
   "SIA": "SIA (\u00b5g/m^3)",
   "POC": "POC (\u00b5g/m^3)",
   "SOC": "SOC (\u00b5g/m^3)",
@@ -20,12 +22,15 @@
   "Babs": "Mie Amb Absorption (1/Mm)",
   "Babs_dry": "Mie Dry Absorption (1/Mm)",
   "Absorption": "Absorption (1/Mm)",
+  "abs": "Absorption (1/Mm)",
   "Bext": "Mie Amb Extinction (1/Mm)",
   "Bext_dry": "Mie Dry Extinction (1/Mm)",
   "Extinction": "Extinction (1/Mm)",
+  "ext": "Extinction (1/Mm)",
   "Bsca": "Mie Amb Scattering (1/Mm)",
   "Bsca_dry": "Mie Dry Scattering (1/Mm)",
   "Scattering": "Scattering (1/Mm)",
+  "sca": "Scattering (1/Mm)",
   "Diurnal": "Hour",
   "PBLH": "PBLH (m)",
   "VC": "VC (m²/s)",

AeroViz/plot/violin.py

@@ -0,0 +1,80 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+from matplotlib.pyplot import Figure, Axes
+from pandas import DataFrame
+
+from AeroViz.plot.utils import *
+
+__all__ = ['violin']
+
+
+@set_figure(fw='bold')
+def violin(df: DataFrame | dict,
+           unit: str,
+           ax: Axes | None = None,
+           **kwargs
+           ) -> tuple[Figure, Axes]:
+    """
+    Generate a violin plot for multiple data sets.
+
+    Parameters
+    ----------
+    df : pd.DataFrame or dict
+        A mapping from category names to pandas DataFrames containing the data.
+    unit : str
+        The unit for the data being plotted.
+    ax : matplotlib.axes.Axes, optional
+        The Axes object to draw the plot onto. If not provided, a new figure will be created.
+    **kwargs : dict
+        Additional keyword arguments to be passed to the violinplot function.
+
+    Returns
+    -------
+    fig : Figure
+        The matplotlib Figure object.
+    ax : Axes
+        The matplotlib Axes object with the scatter plot.
+
+    """
+    fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
+
+    data = df.to_numpy()
+
+    data = data[~np.isnan(data).any(axis=1)]
+
+    grps = data.shape[1]
+
+    width = 0.6
+    block = width / 2
+    x_position = np.arange(grps)
+
+    plt.boxplot(data, positions=x_position, widths=0.15,
+                showfliers=False, showmeans=True, meanline=False, patch_artist=True,
+                capprops=dict(linewidth=0),
+                whiskerprops=dict(linewidth=1.5, color='k', alpha=1),
+                boxprops=dict(linewidth=1.5, color='k', facecolor='#4778D3', alpha=1),
+                meanprops=dict(marker='o', markeredgecolor='black', markerfacecolor='white', markersize=6),
+                medianprops=dict(linewidth=1.5, ls='-', color='k', alpha=1))
+
+    sns.violinplot(data=data, density_norm='area', color='#4778D3', inner=None)
+
+    for violin, alpha in zip(ax.collections[:], [0.5] * len(ax.collections[:])):
+        violin.set_alpha(alpha)
+        violin.set_edgecolor(None)
+
+    plt.scatter(x_position, data.mean(), marker='o', facecolor='white', edgecolor='k', s=10)
+
+    xlim = kwargs.get('xlim') or (x_position[0] - (width / 2 + block), x_position[-1] + (width / 2 + block))
+    ylim = kwargs.get('ylim') or (0, None)
+    xlabel = kwargs.get('xlabel') or ''
+    ylabel = kwargs.get('ylabel') or Unit(unit)
+    xticks = kwargs.get('xticks') or [x.replace('-', '\n') for x in list(df.keys())]
+
+    ax.set(xlim=xlim, ylim=ylim, xlabel=xlabel, ylabel=ylabel, title=kwargs.get('title'))
+    ax.set_xticks(x_position, xticks, fontweight='bold', fontsize=12)
+
+    plt.show()
+
+    return fig, ax

AeroViz/process/__init__.py

@@ -3,29 +3,29 @@ from pathlib import Path
 from pandas import read_csv, concat
 
 from AeroViz.process.script import (ImpactProc, ImproveProc, ChemicalProc, ParticleSizeDistProc,
-									ExtinctionDistProc, OthersProc)
+                                    ExtinctionDistProc, OthersProc)
 
-__all__ = ['DataProcess']
+__all__ = ['DataProcessor', 'ImpactProc', 'ImproveProc', 'ChemicalProc', 'ParticleSizeDistProc', 'ExtinctionDistProc', ]
 
 
-class DataProcess:
-	def __new__(cls, file_path, reset: bool = False, save_file: Path | str = 'All_data.csv'):
-		file_path = Path(file_path)
+class DataProcessor:
+    def __new__(cls, file_path, reset: bool = False, save_file: Path | str = 'All_data.csv'):
+        file_path = Path(file_path)
 
-		print(f'\t\t \033[96m --- Processing Data --- \033[0m')
+        print(f'\t\t \033[96m --- Processing Data --- \033[0m')
 
-		if file_path.exists() and not reset:
-			return read_csv(file_path, parse_dates=['Time'], index_col='Time',
-							na_values=('-', 'E', 'F'), low_memory=False)
+        if file_path.exists() and not reset:
+            return read_csv(file_path, parse_dates=['Time'], index_col='Time',
+                            na_values=('-', 'E', 'F'), low_memory=False)
 
-		processor = [ImpactProc, ChemicalProc, ImproveProc, ParticleSizeDistProc, ExtinctionDistProc, OthersProc]
-		reset = [False, False, False, False, False, False]
-		save_filename = ['IMPACT.csv', 'chemical.csv', 'revised_IMPROVE.csv', 'PSD.csv', 'PESD.csv', 'Others.csv']
+        processor = [ImpactProc, ChemicalProc, ImproveProc, ParticleSizeDistProc, ExtinctionDistProc, OthersProc]
+        reset = [False, False, False, False, False, False]
+        save_filename = ['IMPACT.csv', 'chemical.csv', 'revised_IMPROVE.csv', 'PSD.csv', 'PESD.csv', 'Others.csv']
 
-		_df = concat([processor().process_data(reset, save_filename) for processor, reset, save_filename in
-					  zip(processor, reset, save_filename)], axis=1)
+        _df = concat([processor().process_data(reset, save_filename) for processor, reset, save_filename in
+                      zip(processor, reset, save_filename)], axis=1)
 
-		# 7. save result
-		_df.to_csv(file_path)
+        # 7. save result
+        _df.to_csv(file_path)
 
-		return _df
+        return _df

AeroViz/process/core/DataProc.py

@@ -7,13 +7,13 @@ __all__ = ['DataProc']
 
 
 class DataProc(ABC):
-	def __init__(self):
-		pass
+    def __init__(self):
+        pass
 
-	@abstractmethod
-	def process_data(self,
-					 reset: bool = False,
-					 save_filename: str | Path = None
-					 ) -> DataFrame:
-		""" Implementation of processing data """
-		pass
+    @abstractmethod
+    def process_data(self,
+                     reset: bool = False,
+                     save_filename: str | Path = None
+                     ) -> DataFrame:
+        """ Implementation of processing data """
+        pass