AeroViz 0.1.2__py3-none-any.whl → 0.1.3b0__py3-none-any.whl

AeroViz/plot/pie.py

@@ -0,0 +1,198 @@
+from typing import Literal
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from matplotlib.pyplot import Figure, Axes
+from pandas import DataFrame
+
+from AeroViz.plot.utils import *
+
+__all__ = [
+    'pie',
+    'donuts'
+]
+
+
+@set_figure(fw='bold')
+def pie(data_set: DataFrame | dict,
+        labels: list[str],
+        unit: str,
+        style: Literal["pie", 'donut'],
+        ax: Axes | None = None,
+        symbol: bool = True,
+        **kwargs) -> tuple[Figure, Axes]:
+    """
+    Create a pie or donut chart based on the provided data.
+
+    Parameters
+    ----------
+    data_set : pd.DataFrame | dict
+        A pandas DataFrame or dictionary mapping category names to a list of species.
+        If a DataFrame is provided, the index represents the categories, and each column contains species data.
+        If a dictionary is provided, it maps category names to lists of species data.
+        It is assumed that all lists or DataFrame columns contain the same number of entries as the *labels* list.
+    labels : list of str
+        The labels for each category.
+    unit : str
+        The unit to display in the center of the donut chart.
+    style : Literal["pie", 'donut']
+        The style of the chart, either 'pie' for a standard pie chart or 'donut' for a donut chart.
+    ax : plt.Axes or None, optional
+        The Axes object to plot the chart onto. If None, a new figure and Axes will be created.
+    symbol : bool, optional
+        Whether to display values for each species in the chart.
+    **kwargs
+        Additional keyword arguments to be passed to the plotting function.
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+        The Axes object containing the violin plot.
+
+    Notes
+    -----
+    - If *data_set* is a dictionary, it should contain lists of species that correspond to each category in *labels*.
+    - The length of each list in *data_set* or the number of columns in the DataFrame should match the length of the *labels* list.
+
+    Examples
+    --------
+    >>> data_set = {'Category 1': [10, 20, 30], 'Category 2': [15, 25, 35]}
+    >>> labels = ['Species 1', 'Species 2', 'Species 3']
+    >>> pie(data_set, labels, unit='kg', style='pie', symbol=True)
+    """
+    if isinstance(data_set, DataFrame):
+        category_names = list(data_set.index)
+        data = data_set.to_numpy()
+
+        pies, species = data.shape
+
+    elif isinstance(data_set, dict):
+        category_names = list(data_set.keys())
+        data = np.array(list(data_set.values()))
+
+        pies, species = data.shape
+
+    else:
+        raise ValueError('data_set must be a DataFrame or a dictionary.')
+
+    colors = kwargs.get('colors') or (Color.colors1 if species == 6 else Color.getColor(num=species))
+
+    radius = 4
+    width = 4 if style == 'pie' else 1
+
+    text = [''] * pies if style == 'pie' else [Unit(unit) + '\n\n' + '{:.2f}'.format(x) for x in data.sum(axis=1)]
+    pct_distance = 0.6 if style == 'pie' else 0.88
+
+    fig, ax = plt.subplots(1, pies, figsize=((pies * 2) + 1, 2)) if ax is None else (ax.get_figure(), ax)
+
+    if pies == 1:
+        ax = [ax]
+
+    for i in range(pies):
+        ax[i].pie(data[i], labels=None, colors=colors, textprops=None,
+                  autopct=lambda pct: auto_label_pct(pct, symbol=symbol, include_pct=True),
+                  pctdistance=pct_distance, radius=radius, wedgeprops=dict(width=width, edgecolor='w'))
+
+        ax[i].pie(data[i], labels=None, colors=colors, textprops=None,
+                  autopct=lambda pct: auto_label_pct(pct, symbol=symbol, ignore='outer', include_pct=True),
+                  pctdistance=1.3, radius=radius, wedgeprops=dict(width=width, edgecolor='w'))
+        ax[i].axis('equal')
+        ax[i].text(0, 0, text[i], ha='center', va='center')
+        ax[i].set_title(category_names[i])
+
+    ax[-1].legend(labels, loc='center left', prop={'size': 8, 'weight': 'normal'}, bbox_to_anchor=(1, 0, 1.15, 1))
+
+    # fig.savefig(f"pie_{style}_{title}")
+
+    plt.show()
+
+    return fig, ax
+
+
+@set_figure(fw='bold')
+def donuts(data_set: DataFrame | dict,
+           labels: list[str],
+           unit: str,
+           ax: Axes | None = None,
+           symbol=True,
+           **kwargs) -> tuple[Figure, Axes]:
+    """
+    Plot a donut chart based on the data set.
+
+    Parameters
+    ----------
+    data_set : pd.DataFrame | dict
+        A pandas DataFrame or a dictionary mapping category names to a list of species.
+        If a DataFrame is provided, the index represents the categories, and each column contains species data.
+        If a dictionary is provided, it maps category names to lists of species data.
+        It is assumed that all lists or DataFrame columns contain the same number of entries as the *labels* list.
+    labels : list of str
+        The category labels.
+    unit : str
+        The unit to be displayed in the center of the donut chart.
+    ax : matplotlib.axes.Axes, optional
+        The axes to plot on. If None, the current axes will be used (default).
+    symbol : bool, optional
+        Whether to display values for each species (default is True).
+    **kwargs : dict, optional
+        Additional keyword arguments to pass to the matplotlib pie chart function.
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+        The axes containing the donut chart.
+    """
+
+    if isinstance(data_set, DataFrame):
+        category_names = list(data_set.index)
+        data = data_set.to_numpy()
+
+        pies, species = data.shape
+
+    elif isinstance(data_set, dict):
+        category_names = list(data_set.keys())
+        data = np.array(list(data_set.values()))
+
+        pies, species = data.shape
+
+    else:
+        raise ValueError('data_set must be a DataFrame or a dictionary.')
+
+    colors1 = kwargs.get('colors') or (Color.colors1 if species == 6 else Color.getColor(num=species))
+    colors2 = Color.adjust_opacity(colors1, 0.8)
+    colors3 = Color.adjust_opacity(colors1, 0.6)
+
+    fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
+
+    ax.pie(data[2], labels=None, colors=colors1, textprops=None,
+           autopct=lambda pct: auto_label_pct(pct, symbol=symbol, include_pct=True),
+           pctdistance=0.9, radius=14, wedgeprops=dict(width=3, edgecolor='w'))
+
+    ax.pie(data[1], labels=None, colors=colors2, textprops=None,
+           autopct=lambda pct: auto_label_pct(pct, symbol=symbol, include_pct=True),
+           pctdistance=0.85, radius=11, wedgeprops=dict(width=3, edgecolor='w'))
+
+    ax.pie(data[0], labels=None, colors=colors3, textprops=None,
+           autopct=lambda pct: auto_label_pct(pct, symbol=symbol, include_pct=True),
+           pctdistance=0.80, radius=8, wedgeprops=dict(width=3, edgecolor='w'))
+
+    text = (Unit(f'{unit}') + '\n\n' +
+            'Event : ' + "{:.2f}".format(np.sum(data[2])) + '\n' +
+            'Transition : ' + "{:.2f}".format(np.sum(data[1])) + '\n' +
+            'Clean : ' + "{:.2f}".format(np.sum(data[0])))
+
+    ax.text(0, 0, text, ha='center', va='center')
+    ax.axis('equal')
+
+    ax.set_title(kwargs.get('title', ''))
+
+    ax.legend(labels, loc='center', prop={'size': 8}, title_fontproperties={'weight': 'bold'},
+              title=f'Outer : {category_names[2]}' + '\n' + f'Middle : {category_names[1]}' + '\n' + f'Inner : {category_names[0]}',
+              bbox_to_anchor=(0.8, 0, 0.5, 1))
+
+    # fig.savefig(f"donuts_{title}")
+
+    plt.show()
+
+    return fig, ax

AeroViz/plot/regression.py

@@ -0,0 +1,210 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from matplotlib.pyplot import Figure, Axes
+
+from AeroViz.plot.utils import *
+
+__all__ = [
+    'linear_regression',
+    'multiple_linear_regression',
+]
+
+
+@set_figure
+def linear_regression(df: pd.DataFrame,
+                      x: str | list[str],
+                      y: str | list[str],
+                      labels: str | list[str] = None,
+                      ax: Axes | None = None,
+                      diagonal=False,
+                      positive: bool = True,
+                      fit_intercept: bool = True,
+                      **kwargs
+                      ) -> tuple[Figure, Axes]:
+    """
+    Create a scatter plot with multiple regression lines for the given data.
+
+    Parameters
+    ----------
+    df : DataFrame
+        Input DataFrame containing the data.
+
+    x : str or list of str
+        Column name(s) for the x-axis variable(s).
+
+    y : str or list of str
+        Column name(s) for the y-axis variable(s).
+
+    labels : str or list of str, optional
+        Labels for the y-axis variable(s). If None, column names are used as labels. Default is None.
+
+    ax : AxesSubplot, optional
+        Matplotlib AxesSubplot to use for the plot. If None, a new subplot is created. Default is None.
+
+    diagonal : bool, optional
+        If True, a diagonal line (1:1 line) is added to the plot. Default is False.
+
+    positive : bool, optional
+       Whether to let coefficient positive. Default is True.
+
+    fit_intercept: bool, optional
+        Whether to fit intercept. Default is True.
+
+    **kwargs
+        Additional keyword arguments to customize the plot.
+
+    Returns
+    -------
+    AxesSubplot
+        Matplotlib AxesSubplot containing the scatter plot.
+
+    Notes
+    -----
+    - The function creates a scatter plot with the option to include multiple regression lines.
+    - If regression is True, regression lines are fitted for each y variable.
+    - Additional customization can be done using the **kwargs.
+
+    Example
+    -------
+    >>> linear_regression(df, x='X', y=['Y1', 'Y2'], labels=['Label1', 'Label2'],
+    ...                      regression=True, diagonal=True, xlim=(0, 10), ylim=(0, 20),
+    ...                      xlabel="X-axis", ylabel="Y-axis", title="Scatter Plot with Regressions")
+    """
+    fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
+
+    if not isinstance(x, str):
+        x = x[0]
+
+    if not isinstance(y, list):
+        y = [y]
+
+    if labels is None:
+        labels = y
+
+    df = df.dropna(subset=[x, *y])
+    x_array = df[[x]].to_numpy()
+
+    color_cycle = Color.linecolor
+
+    handles, text_list = [], []
+
+    for i, y_var in enumerate(y):
+        y_array = df[[y_var]].to_numpy()
+
+        color = color_cycle[i % len(color_cycle)]
+
+        scatter = ax.scatter(x_array, y_array, s=25, color=color['face'], edgecolors=color['edge'], alpha=0.8,
+                             label=labels[i])
+        handles.append(scatter)
+
+        text, y_predict, slope = linear_regression_base(x_array, y_array,
+                                                        columns=labels[i],
+                                                        positive=positive,
+                                                        fit_intercept=fit_intercept)
+
+        text_list.append(f'{labels[i]}:\n{text}')
+        plt.plot(x_array, y_predict, linewidth=3, color=color['line'], alpha=1, zorder=3)
+
+    ax.set(xlim=kwargs.get('xlim'), ylim=kwargs.get('ylim'), xlabel=Unit(x), ylabel=Unit(y[0]),
+           title=kwargs.get('title'))
+
+    # Add regression info to the legend
+    leg = plt.legend(handles=handles, labels=text_list, loc='upper left', prop={'weight': 'bold'})
+
+    for text, color in zip(leg.get_texts(), [color['line'] for color in color_cycle]):
+        text.set_color(color)
+
+    if diagonal:
+        ax.axline((0, 0), slope=1., color='k', lw=2, ls='--', alpha=0.5, label='1:1')
+        plt.text(0.97, 0.97, r'$\bf 1:1\ Line$', color='k', ha='right', va='top', transform=ax.transAxes)
+
+    plt.show()
+
+    return fig, ax
+
+
+@set_figure
+def multiple_linear_regression(df: pd.DataFrame,
+                               x: str | list[str],
+                               y: str | list[str],
+                               labels: str | list[str] = None,
+                               ax: Axes | None = None,
+                               diagonal=False,
+                               positive: bool = True,
+                               fit_intercept: bool = True,
+                               **kwargs
+                               ) -> tuple[Figure, Axes]:
+    """
+    Perform multiple linear regression analysis and plot the results.
+
+    Parameters
+    ----------
+    df : pandas.DataFrame
+       Input DataFrame containing the data.
+
+    x : str or list of str
+       Column name(s) for the independent variable(s). Can be a single string or a list of strings.
+
+    y : str or list of str
+       Column name(s) for the dependent variable(s). Can be a single string or a list of strings.
+
+    labels : str or list of str, optional
+       Labels for the dependent variable(s). If None, column names are used as labels. Default is None.
+
+    ax : matplotlib.axes.Axes or None, optional
+       Matplotlib Axes object to use for the plot. If None, a new subplot is created. Default is None.
+
+    diagonal : bool, optional
+       Whether to include a diagonal line (1:1 line) in the plot. Default is False.
+
+    positive : bool, optional
+       Whether to let coefficient positive. Default is True.
+
+    fit_intercept: bool, optional
+        Whether to fit intercept. Default is True.
+
+    **kwargs
+       Additional keyword arguments to customize the plot.
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+       Matplotlib Axes object containing the regression plot.
+
+    Notes
+    -----
+    This function performs multiple linear regression analysis using the input DataFrame.
+    It supports multiple independent variables and can plot the regression results.
+
+    Example
+    -------
+    >>> multiple_linear_regression(df, x=['X1', 'X2'], y='Y', labels=['Y1', 'Y2'],
+    ...                             diagonal=True, add_constant=True,
+    ...                             xlabel="X-axis", ylabel="Y-axis", title="Multiple Linear Regression Plot")
+    """
+    fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
+
+    if not isinstance(x, list):
+        x = [x]
+
+    if not isinstance(y, str):
+        y = y[0]
+
+    if labels is None:
+        labels = x
+
+    df = df[[*x, y]].dropna()
+    x_array = df[[*x]].to_numpy()
+    y_array = df[[y]].to_numpy()
+
+    text, y_predict, coefficients = linear_regression_base(x_array, y_array,
+                                                           columns=labels,
+                                                           positive=positive,
+                                                           fit_intercept=fit_intercept)
+
+    df = pd.DataFrame(np.concatenate([y_array, y_predict], axis=1), columns=['y_actual', 'y_predict'])
+
+    linear_regression(df, x='y_actual', y='y_predict', ax=ax, regression=True, diagonal=diagonal)
+
+    return fig, ax

AeroViz/plot/scatter.py

@@ -0,0 +1,99 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+from matplotlib.colors import Normalize
+from matplotlib.pyplot import Figure, Axes
+from matplotlib.ticker import ScalarFormatter
+
+from AeroViz.plot.utils import *
+
+__all__ = ['scatter']
+
+
+@set_figure(figsize=(5, 4))
+def scatter(df: pd.DataFrame,
+            x: str,
+            y: str,
+            c: str | None = None,
+            s: str | None = None,
+            cmap='jet',
+            regression=False,
+            diagonal=False,
+            ax: Axes | None = None,
+            **kwargs) -> tuple[Figure, Axes]:
+    fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
+
+    if c is not None and s is not None:
+        df_ = df.dropna(subset=[x, y, c, s]).copy()
+        x_data, y_data, c_data, s_data = df_[x].to_numpy(), df_[y].to_numpy(), df_[c].to_numpy(), df_[s].to_numpy()
+
+        scatter = ax.scatter(x_data, y_data, c=c_data,
+                             norm=Normalize(vmin=np.percentile(c_data, 10), vmax=np.percentile(c_data, 90)),
+                             cmap=cmap, s=50 * (s_data / s_data.max()) ** 1.5, alpha=0.7, edgecolors=None)
+        colorbar = True
+
+        dot = np.linspace(s_data.min(), s_data.max(), 6).round(-1)
+
+        for dott in dot[1:-1]:
+            plt.scatter([], [], c='k', alpha=0.8, s=50 * (dott / s_data.max()) ** 1.5, label='{:.0f}'.format(dott))
+
+        plt.legend(title=Unit(s))
+
+    elif c is not None:
+        df_ = df.dropna(subset=[x, y, c]).copy()
+        x_data, y_data, c_data = df_[x].to_numpy(), df_[y].to_numpy(), df_[c].to_numpy()
+
+        scatter = ax.scatter(x_data, y_data, c=c_data, vmin=c_data.min(), vmax=np.percentile(c_data, 90), cmap=cmap,
+                             alpha=0.7,
+                             edgecolors=None)
+        colorbar = True
+
+    elif s is not None:
+        df_ = df.dropna(subset=[x, y, s]).copy()
+        x_data, y_data, s_data = df_[x].to_numpy(), df_[y].to_numpy(), df_[s].to_numpy()
+
+        scatter = ax.scatter(x_data, y_data, s=50 * (s_data / s_data.max()) ** 1.5, color='#7a97c9', alpha=0.7,
+                             edgecolors='white')
+        colorbar = False
+
+        # dealing
+        dot = np.linspace(s_data.min(), s_data.max(), 6).round(-1)
+
+        for dott in dot[1:-1]:
+            plt.scatter([], [], c='k', alpha=0.8, s=50 * (dott / s_data.max()) ** 1.5, label='{:.0f}'.format(dott))
+
+        plt.legend(title=Unit(s))
+
+    else:
+        df_ = df.dropna(subset=[x, y]).copy()
+        x_data, y_data = df_[x].to_numpy(), df_[y].to_numpy()
+
+        scatter = ax.scatter(x_data, y_data, s=30, color='#7a97c9', alpha=0.7, edgecolors='white')
+        colorbar = False
+
+    ax.set(xlim=kwargs.get('xlim', (x_data.min(), x_data.max())),
+           ylim=kwargs.get('ylim', (y_data.min(), y_data.max())),
+           xlabel=kwargs.get('xlabel', Unit(x)),
+           ylabel=kwargs.get('ylabel', Unit(y)),
+           title=kwargs.get('title', ''))
+
+    if colorbar:
+        plt.colorbar(scatter, extend='both', label=Unit(c))
+
+    if regression:
+        text, y_predict, slope = linear_regression_base(x_data, y_data)
+        ax.plot(x_data, y_predict, linewidth=3, color=sns.xkcd_rgb["denim blue"], alpha=1, zorder=3)
+        plt.text(0.05, 0.95, text, fontdict={'weight': 'bold'}, color=sns.xkcd_rgb["denim blue"],
+                 ha='left', va='top', transform=ax.transAxes)
+
+    if diagonal:
+        ax.axline((0, 0), slope=1., color='k', lw=2, ls='--', alpha=0.5, label='1:1')
+        plt.text(0.91, 0.97, r'$\bf 1:1\ Line$', color='k', ha='right', va='top', transform=ax.transAxes)
+
+    ax.xaxis.set_major_formatter(ScalarFormatter())
+    ax.yaxis.set_major_formatter(ScalarFormatter())
+
+    plt.show()
+
+    return fig, ax

AeroViz/plot/templates/__init__.py

@@ -3,6 +3,3 @@ from .corr_matrix import corr_matrix
 from .diurnal_pattern import *
 from .koschmieder import *
 from .metal_heatmap import metal_heatmaps, process_data
-from .regression import *
-from .scatter import *
-from .templates import *

AeroViz/plot/templates/contour.py

@@ -10,38 +10,38 @@ __all__ = ['contour']
 
 @set_figure
 def contour(df, ax: Axes | None = None, **kwargs) -> tuple[Figure, Axes]:
-	fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
+    fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
 
-	npoints = 1000
-	xreg = np.linspace(df.PM25.min(), df.PM25.max(), 83)
-	yreg = np.linspace(df.gRH.min(), df.gRH.max(), 34)
-	X, Y = np.meshgrid(xreg, yreg)
+    npoints = 1000
+    xreg = np.linspace(df.PM25.min(), df.PM25.max(), 83)
+    yreg = np.linspace(df.gRH.min(), df.gRH.max(), 34)
+    X, Y = np.meshgrid(xreg, yreg)
 
-	d_f = df.copy()
-	df['gRH'] = d_f['gRH'].round(2)
-	df['PM25'] = d_f['PM25'].round(2)
+    d_f = df.copy()
+    df['gRH'] = d_f['gRH'].round(2)
+    df['PM25'] = d_f['PM25'].round(2)
 
-	def func(data, *params):
-		return params[0] * data ** (params[1])
+    def func(data, *params):
+        return params[0] * data ** (params[1])
 
-	initial_guess = [1.0, 1.0]
+    initial_guess = [1.0, 1.0]
 
-	fit_df = df[['PM25', 'gRH', 'Extinction']].dropna()
-	popt, pcov = curve_fit(func, xdata=(fit_df['PM25'] * fit_df['gRH']), ydata=fit_df['Extinction'], p0=initial_guess,
-						   maxfev=2000000, method='trf')
+    fit_df = df[['PM25', 'gRH', 'Extinction']].dropna()
+    popt, pcov = curve_fit(func, xdata=(fit_df['PM25'] * fit_df['gRH']), ydata=fit_df['Extinction'], p0=initial_guess,
+                           maxfev=2000000, method='trf')
 
-	x, y = df.PM25, df.gRH
+    x, y = df.PM25, df.gRH
 
-	# pcolor = ax.pcolormesh(X, Y, (X * 4.5 * Y ** (1 / 3)), cmap='jet', shading='auto', vmin=0, vmax=843, alpha=0.8)
-	Z = func(X * Y, *popt)
-	cont = ax.contour(X, Y, Z, colors='black', levels=5, vmin=0, vmax=Z.max())
-	conf = ax.contourf(X, Y, Z, cmap='YlGnBu', levels=100, vmin=0, vmax=Z.max())
-	ax.clabel(cont, colors=['black'], fmt=lambda s: f"{s:.0f} 1/Mm")
-	ax.set(xlabel=Unit('PM25'), ylabel=Unit('gRH'), xlim=(x.min(), x.max()), ylim=(y.min(), y.max()))
+    # pcolor = ax.pcolormesh(X, Y, (X * 4.5 * Y ** (1 / 3)), cmap='jet', shading='auto', vmin=0, vmax=843, alpha=0.8)
+    Z = func(X * Y, *popt)
+    cont = ax.contour(X, Y, Z, colors='black', levels=5, vmin=0, vmax=Z.max())
+    conf = ax.contourf(X, Y, Z, cmap='YlGnBu', levels=100, vmin=0, vmax=Z.max())
+    ax.clabel(cont, colors=['black'], fmt=lambda s: f"{s:.0f} 1/Mm")
+    ax.set(xlabel=Unit('PM25'), ylabel=Unit('gRH'), xlim=(x.min(), x.max()), ylim=(y.min(), y.max()))
 
-	color_bar = plt.colorbar(conf, pad=0.02, fraction=0.05, label='Extinction (1/Mm)')
-	color_bar.ax.set_xticklabels(color_bar.ax.get_xticks().astype(int))
+    color_bar = plt.colorbar(conf, pad=0.02, fraction=0.05, label='Extinction (1/Mm)')
+    color_bar.ax.set_xticklabels(color_bar.ax.get_xticks().astype(int))
 
-	plt.show()
+    plt.show()
 
-	return fig, ax
+    return fig, ax