AeroViz 0.1.9.5__tar.gz → 0.1.10__tar.gz

{aeroviz-0.1.9.5 → aeroviz-0.1.10}/AeroViz/__init__.py

@@ -2,13 +2,12 @@
 from AeroViz import plot
 from AeroViz.dataProcess import DataProcess
 from AeroViz.rawDataReader import RawDataReader
-from AeroViz.tools import DataBase, DataReader, DataClassifier
+from AeroViz.tools import DataBase, DataClassifier
 
 __all__ = [
     'plot',
     'RawDataReader',
     'DataProcess',
     'DataBase',
-    'DataReader',
     'DataClassifier'
 ]

{aeroviz-0.1.9.5/AeroViz/plot/optical → aeroviz-0.1.10/AeroViz/dataProcess/Optical}/PyMieScatt_update.py

@@ -6,13 +6,6 @@ import numpy as np
 from scipy.special import jv, yv
 
 
-def coerceDType(d):
-    if type(d) is not np.ndarray:
-        return np.array(d)
-    else:
-        return d
-
-
 def MieQ(m, wavelength, diameter, nMedium=1.0, asDict=False, asCrossSection=False):
     #  http://pymiescatt.readthedocs.io/en/latest/forward.html#MieQ
     nMedium = nMedium.real
@@ -271,8 +264,8 @@ def Mie_SD(m, wavelength, dp, ndp, nMedium=1.0, SMPS=True, interpolate=False, as
     nMedium = nMedium.real
     m /= nMedium
     wavelength /= nMedium
-    dp = coerceDType(dp)
-    ndp = coerceDType(ndp)
+    dp = np.array(dp)
+    ndp = np.array(ndp)
     _length = np.size(dp)
     Q_ext = np.zeros(_length)
     Q_sca = np.zeros(_length)
@@ -373,8 +366,8 @@ def SF_SD(m, wavelength, dp, ndp, nMedium=1.0, minAngle=0, maxAngle=180, angular
     wavelength /= nMedium
 
     _steps = int(1 + (maxAngle - minAngle) / angularResolution)
-    ndp = coerceDType(ndp)
-    dp = coerceDType(dp)
+    ndp = np.array(ndp)
+    dp = np.array(dp)
     SL = np.zeros(_steps)
     SR = np.zeros(_steps)
     SU = np.zeros(_steps)

aeroviz-0.1.10/AeroViz/dataProcess/SizeDistr/prop.py

@@ -0,0 +1,62 @@
+import numpy as np
+from numpy import exp, log
+from scipy.signal import find_peaks
+
+
+def geometric(dp: np.ndarray,
+              dist: np.ndarray
+              ) -> tuple[float, float]:
+    """ Calculate the geometric mean and standard deviation. """
+
+    _gmd = (((dist * log(dp)).sum()) / dist.sum())
+
+    logdp_mesh, gmd_mesh = np.meshgrid(log(dp), _gmd)
+    _gsd = ((((logdp_mesh - gmd_mesh) ** 2) * dist).sum() / dist.sum()) ** .5
+
+    return exp(_gmd), exp(_gsd)
+
+
+def contribution(dp: np.ndarray,
+                 dist: np.ndarray
+                 ) -> tuple[float, float, float]:
+    """ Calculate the relative contribution of each mode. """
+
+    ultra = dist[(dp >= 11.8) & (dp < 100)].sum() / dist.sum()
+    accum = dist[(dp >= 100) & (dp < 1000)].sum() / dist.sum()
+    coars = dist[(dp >= 1000) & (dp < 2500)].sum() / dist.sum()
+
+    return ultra, accum, coars
+
+
+def mode(dp: np.ndarray,
+         dist: np.ndarray
+         ) -> np.ndarray:
+    """ Find three peak mode in distribution. """
+
+    min_value = np.array([dist.min()])
+    mode, _ = find_peaks(np.concatenate([min_value, dist, min_value]), distance=len(dist) - 1)
+
+    return dp[mode - 1]
+
+
+def properties(dist,
+               dp: np.ndarray,
+               dlogdp: np.ndarray,
+               weighting: str
+               ) -> dict:
+    """ for apply """
+    dist = np.array(dist)
+
+    gmd, gsd = geometric(dp, dist)
+    ultra, accum, coarse = contribution(dp, dist)
+    peak = mode(dp, dist)
+
+    return {key: round(value, 3) for key, value in
+            {f'total_{weighting}': (dist * dlogdp).sum(),
+             f'GMD_{weighting}': gmd,
+             f'GSD_{weighting}': gsd,
+             f'mode_{weighting}': peak[0],
+             f'ultra_{weighting}': ultra,
+             f'accum_{weighting}': accum,
+             f'coarse_{weighting}': coarse}
+            .items()}

{aeroviz-0.1.9.5 → aeroviz-0.1.10}/AeroViz/plot/__init__.py

@@ -3,7 +3,6 @@ from . import meteorology
 from . import optical
 from .bar import bar
 from .box import box
-from .hysplit import hysplit
 from .pie import pie, donuts
 from .radar import radar
 from .regression import linear_regression, multiple_linear_regression

aeroviz-0.1.9.5/AeroViz/plot/meteorology/meteorology.py → aeroviz-0.1.10/AeroViz/plot/meteorology/CBPF.py

@@ -1,85 +1,159 @@
 import math
-from typing import Literal
 
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
-import windrose
 from matplotlib.pyplot import Figure, Axes
 from pandas import DataFrame, Series
 from scipy.ndimage import gaussian_filter
 
 from AeroViz.plot.utils import *
 
-__all__ = ['wind_rose',
-           'CBPF'
-           ]
+__all__ = ['CBPF']
+
+
+def improve_density_estimation(df, WS, WD, val, resolution=100, bandwidth=None):
+    """
+    改進的密度估計函數，使用KDE方法來產生更平滑的分布
+
+    Parameters:
+    -----------
+    df : DataFrame
+        包含風速風向數據的DataFrame
+    WS : str
+        風速列名
+    WD : str
+        風向列名
+    val : str
+        要分析的變量列名
+    resolution : int
+        網格解析度
+    bandwidth : float or tuple
+        KDE的頻寬參數，如果為None則自動選擇
+    """
+    from scipy.stats import gaussian_kde
+    import numpy as np
+
+    # 轉換為笛卡爾坐標
+    u = df[WS] * np.sin(np.radians(df[WD]))
+    v = df[WS] * np.cos(np.radians(df[WD]))
+
+    # 創建網格
+    u_range = np.linspace(u.min(), u.max(), resolution)
+    v_range = np.linspace(v.min(), v.max(), resolution)
+    U, V = np.meshgrid(u_range, v_range)
+
+    # 準備KDE的位置
+    positions = np.vstack([U.ravel(), V.ravel()])
+    values = np.vstack([u, v])
+
+    # 使用KDE進行密度估計
+    kernel = gaussian_kde(values, bw_method=bandwidth)
+    Z = np.reshape(kernel(positions), U.shape)
+
+    # 將密度值歸一化到[0,1]區間
+    Z = (Z - Z.min()) / (Z.max() - Z.min())
+
+    # 應用極坐標遮罩
+    center_u = len(u_range) // 2
+    center_v = len(v_range) // 2
+    max_radius = min(center_u, center_v)
+
+    Y, X = np.ogrid[-center_v:resolution - center_v, -center_u:resolution - center_u]
+    mask = X * X + Y * Y > max_radius * max_radius
+    Z[mask] = np.nan
+
+    return Z, U, V
+
+
+def smooth_and_clean(Z, smooth_radius=2, min_density=1):
+    """
+    平滑並清理密度圖，去除孤立點
+
+    Parameters:
+    -----------
+    Z : ndarray
+        密度估計結果
+    smooth_radius : int
+        平滑半徑
+    min_density : float
+        最小密度閾值
+    """
+    from scipy.ndimage import gaussian_filter
+
+    # 先進行高斯平滑
+    Z_smooth = gaussian_filter(Z, sigma=smooth_radius)
+
+    # 去除低於閾值的點
+    # Z_smooth[Z_smooth < min_density] = np.nan
+
+    # 去除孤立點
+    rows, cols = Z_smooth.shape
+    for i in range(rows):
+        for j in range(cols):
+            if not np.isnan(Z_smooth[i, j]):
+                # 檢查周圍點
+                neighborhood = Z_smooth[
+                               max(0, i - smooth_radius):min(rows, i + smooth_radius + 1),
+                               max(0, j - smooth_radius):min(cols, j + smooth_radius + 1)
+                               ]
+                if np.count_nonzero(~np.isnan(neighborhood)) < 1:  # 如果周圍有效點太少
+                    Z_smooth[i, j] = np.nan
+
+    return Z_smooth
+
+
+def is_within_circle(center_row, center_col, row, col, radius):
+    return np.sqrt((center_row - row) ** 2 + (center_col - col) ** 2) <= radius
+
+
+def remove_lonely_point(filtered_histogram, radius=4, magic_num=13):
+    rows, cols = filtered_histogram.shape
+    data_positions = np.where(~np.isnan(filtered_histogram))
+
+    for row, col in zip(*data_positions):
+        valid_data_count = 0
+        for i in range(max(0, row - radius), min(rows, row + radius + 1)):
+            for j in range(max(0, col - radius), min(cols, col + radius + 1)):
+                if (i, j) != (row, col) and is_within_circle(row, col, i, j, radius):
+                    if not np.isnan(filtered_histogram[i, j]):
+                        valid_data_count += 1
+
+        if valid_data_count <= magic_num:
+            filtered_histogram[row, col] = np.nan
+
+    return filtered_histogram
+
+
+def fill_nan_with_mean(filtered_histogram, radius=4, magic_num=13):
+    rows, cols = filtered_histogram.shape
+    nan_positions = np.where(np.isnan(filtered_histogram))
+
+    for row, col in zip(*nan_positions):
+        surrounding_values = []
+        surrounding_values_within_one = []
+        nan_count = 0
 
+        for i in range(max(0, row - radius), min(rows, row + radius + 1)):
+            for j in range(max(0, col - radius), min(cols, col + radius + 1)):
+                if (i, j) != (row, col) and is_within_circle(row, col, i, j, radius):
+                    if np.isnan(filtered_histogram[i, j]):
+                        nan_count += 1
+                    else:
+                        surrounding_values.append(filtered_histogram[i, j])
 
-@set_figure(figsize=(4.3, 4))
-def wind_rose(df: DataFrame,
-              WS: Series | str,
-              WD: Series | str,
-              val: Series | str | None = None,
-              typ: Literal['bar', 'scatter'] = 'scatter',
-              rlabel_pos: float = 30,
-              **kwargs
-              ) -> tuple[Figure, Axes]:
-    # conditional bivariate probability function (cbpf) python
-    # https://davidcarslaw.github.io/openair/reference/polarPlot.html
-    # https://github.com/davidcarslaw/openair/blob/master/R/polarPlot.R
-    windrose.WindroseAxes._info = 'WindroseAxes'
-
-    df = df.dropna(subset=[WS, WD] + ([val] if val is not None else []))
-
-    radius = df[WS].to_numpy()
-    theta = df[WD].to_numpy()
-    radian = np.radians(theta)
-    values = df[val].to_numpy() if val is not None else None
-
-    # In this case, the windrose is a simple frequency diagram,
-    # the function automatically calculates the radians of the given wind direction.
-    if typ == 'bar':
-        fig, ax = plt.subplots(figsize=(5.5, 4), subplot_kw={'projection': 'windrose'})
-        fig.subplots_adjust(left=0)
-
-        ax.bar(theta, radius, bins=[0, 1, 2, 3], normed=True, colors=['#0F1035', '#365486', '#7FC7D9', '#DCF2F1'])
-        ax.set(
-            ylim=(0, 30),
-            yticks=[0, 15, 30],
-            yticklabels=['', '15 %', '30 %'],
-            rlabel_position=rlabel_pos
-        )
-        ax.set_thetagrids(angles=[0, 45, 90, 135, 180, 225, 270, 315],
-                          labels=["E", "NE", "N", "NW", "W", "SW", "S", "SE"])
-
-        ax.legend(units='m/s', bbox_to_anchor=[1.1, 0.5], loc='center left', ncol=1)
-
-    # In this case, the windrose is a scatter plot,
-    # in contrary, this function does not calculate the radians, so user have to input the radian.
-    else:
-        fig, ax = plt.subplots(figsize=(5, 4), subplot_kw={'projection': 'windrose'})
-        fig.subplots_adjust(left=0)
-
-        scatter = ax.scatter(radian, radius, s=15, c=values, vmax=np.quantile(values, 0.90), edgecolors='none',
-                             cmap='jet', alpha=0.8)
-        ax.set(
-            ylim=(0, 7),
-            yticks=[1, 3, 5, 7],
-            yticklabels=['1 m/s', '3 m/s', '5 m/s', '7 m/s'],
-            rlabel_position=rlabel_pos,
-            theta_direction=-1,
-            theta_zero_location='N',
-            title=kwargs.get('title', None)
-        )
-        ax.set_thetagrids(angles=[0, 45, 90, 135, 180, 225, 270, 315],
-                          labels=["N", "NE", "E", "SE", "S", "SW", "W", "NW"])
-
-        plt.colorbar(scatter, ax=ax, label=Unit(val), pad=0.1, fraction=0.04)
+        for i in range(max(0, row - 2), min(rows, row + 2 + 1)):
+            for j in range(max(0, col - 2), min(cols, col + 2 + 1)):
+                if (i, j) != (row, col) and is_within_circle(row, col, i, j, 2):
+                    if np.isnan(filtered_histogram[i, j]):
+                        pass
+                    else:
+                        surrounding_values_within_one.append(filtered_histogram[i, j])
 
-    plt.show()
+        if nan_count < magic_num and surrounding_values_within_one:
+            filtered_histogram[row, col] = np.mean(surrounding_values)
 
-    return fig, ax
+    return filtered_histogram
 
 
 # TODO: fix the bug of the CBPF function
@@ -90,7 +164,7 @@ def CBPF(df: DataFrame,
          val: Series | str | None = None,
          percentile: list | float | int | None = None,
          max_ws: float | None = 5,
-         resolution: int = 100,
+         resolution: int = 50,
          sigma: float | tuple = 2,
          rlabel_pos: float = 30,
          bottom_text: str | bool | None = None,
@@ -157,64 +231,18 @@ def CBPF(df: DataFrame,
     histogram_filled = np.nan_to_num(histogram, nan=0)  # 將 NaN 替換為 0
 
     filtered_histogram = gaussian_filter(histogram_filled, sigma=sigma)
-    filtered_histogram[np.isnan(histogram)] = np.nan
-
-    def is_within_circle(center_row, center_col, row, col, radius):
-        return np.sqrt((center_row - row) ** 2 + (center_col - col) ** 2) <= radius
-
-    def remove_lonely_point(filtered_histogram, radius=4, magic_num=13):
-        rows, cols = filtered_histogram.shape
-        data_positions = np.where(~np.isnan(filtered_histogram))
-
-        for row, col in zip(*data_positions):
-            valid_data_count = 0
-            for i in range(max(0, row - radius), min(rows, row + radius + 1)):
-                for j in range(max(0, col - radius), min(cols, col + radius + 1)):
-                    if (i, j) != (row, col) and is_within_circle(row, col, i, j, radius):
-                        if not np.isnan(filtered_histogram[i, j]):
-                            valid_data_count += 1
-
-            if valid_data_count <= magic_num:
-                filtered_histogram[row, col] = np.nan
-
-        return filtered_histogram
-
-    def fill_nan_with_mean(filtered_histogram, radius=4, magic_num=13):
-        rows, cols = filtered_histogram.shape
-        nan_positions = np.where(np.isnan(filtered_histogram))
-
-        for row, col in zip(*nan_positions):
-            surrounding_values = []
-            surrounding_values_within_one = []
-            nan_count = 0
-
-            for i in range(max(0, row - radius), min(rows, row + radius + 1)):
-                for j in range(max(0, col - radius), min(cols, col + radius + 1)):
-                    if (i, j) != (row, col) and is_within_circle(row, col, i, j, radius):
-                        if np.isnan(filtered_histogram[i, j]):
-                            nan_count += 1
-                        else:
-                            surrounding_values.append(filtered_histogram[i, j])
-
-            for i in range(max(0, row - 2), min(rows, row + 2 + 1)):
-                for j in range(max(0, col - 2), min(cols, col + 2 + 1)):
-                    if (i, j) != (row, col) and is_within_circle(row, col, i, j, 2):
-                        if np.isnan(filtered_histogram[i, j]):
-                            pass
-                        else:
-                            surrounding_values_within_one.append(filtered_histogram[i, j])
-
-            if nan_count < magic_num and surrounding_values_within_one:
-                filtered_histogram[row, col] = np.mean(surrounding_values)
-
-        return filtered_histogram
+    # filtered_histogram[np.isnan(histogram)] = np.nan
+    # breakpoint()
+    # filtered_histogram = smooth_and_clean(filtered_histogram)
 
     # Apply the function to your data
-    fil_radius, magic_num = 3, 13
-    filtered_histogram = remove_lonely_point(filtered_histogram, fil_radius, magic_num)
-    filtered_histogram = fill_nan_with_mean(filtered_histogram, fil_radius, magic_num)
+    # fil_radius, magic_num = 3, 13
+    # filtered_histogram = remove_lonely_point(filtered_histogram, fil_radius, magic_num)
+    # filtered_histogram = fill_nan_with_mean(filtered_histogram, fil_radius, magic_num)
+
     if np.all(np.isnan(filtered_histogram)):
         raise ValueError("All values in the filtered histogram are NaN. Please decrease the resolution.")
+
     # plot
     fig, ax = plt.subplots()
     fig.subplots_adjust(left=0)

aeroviz-0.1.10/AeroViz/plot/meteorology/__init__.py

@@ -0,0 +1,3 @@
+from .CBPF import CBPF
+from .hysplit import hysplit
+from .wind_rose import wind_rose

aeroviz-0.1.10/AeroViz/plot/meteorology/wind_rose.py

@@ -0,0 +1,77 @@
+from typing import Literal
+
+import matplotlib.pyplot as plt
+import numpy as np
+import windrose
+from matplotlib.pyplot import Figure, Axes
+from pandas import DataFrame, Series
+
+from AeroViz.plot.utils import *
+
+__all__ = ['wind_rose']
+
+
+@set_figure(figsize=(4.3, 4))
+def wind_rose(df: DataFrame,
+              WS: Series | str,
+              WD: Series | str,
+              val: Series | str | None = None,
+              typ: Literal['bar', 'scatter'] = 'scatter',
+              rlabel_pos: float = 30,
+              **kwargs
+              ) -> tuple[Figure, Axes]:
+    # conditional bivariate probability function (cbpf) python
+    # https://davidcarslaw.github.io/openair/reference/polarPlot.html
+    # https://github.com/davidcarslaw/openair/blob/master/R/polarPlot.R
+    windrose.WindroseAxes._info = 'WindroseAxes'
+
+    df = df.dropna(subset=[WS, WD] + ([val] if val is not None else []))
+
+    radius = df[WS].to_numpy()
+    theta = df[WD].to_numpy()
+    radian = np.radians(theta)
+    values = df[val].to_numpy() if val is not None else None
+
+    # In this case, the windrose is a simple frequency diagram,
+    # the function automatically calculates the radians of the given wind direction.
+    if typ == 'bar':
+        fig, ax = plt.subplots(figsize=(5.5, 4), subplot_kw={'projection': 'windrose'})
+        fig.subplots_adjust(left=0)
+
+        ax.bar(theta, radius, bins=[0, 1, 2, 3], normed=True, colors=['#0F1035', '#365486', '#7FC7D9', '#DCF2F1'])
+        ax.set(
+            ylim=(0, 30),
+            yticks=[0, 15, 30],
+            yticklabels=['', '15 %', '30 %'],
+            rlabel_position=rlabel_pos
+        )
+        ax.set_thetagrids(angles=[0, 45, 90, 135, 180, 225, 270, 315],
+                          labels=["E", "NE", "N", "NW", "W", "SW", "S", "SE"])
+
+        ax.legend(units='m/s', bbox_to_anchor=[1.1, 0.5], loc='center left', ncol=1)
+
+    # In this case, the windrose is a scatter plot,
+    # in contrary, this function does not calculate the radians, so user have to input the radian.
+    else:
+        fig, ax = plt.subplots(figsize=(5, 4), subplot_kw={'projection': 'windrose'})
+        fig.subplots_adjust(left=0)
+
+        scatter = ax.scatter(radian, radius, s=15, c=values, vmax=np.quantile(values, 0.90), edgecolors='none',
+                             cmap='jet', alpha=0.8)
+        ax.set(
+            ylim=(0, 7),
+            yticks=[1, 3, 5, 7],
+            yticklabels=['1 m/s', '3 m/s', '5 m/s', '7 m/s'],
+            rlabel_position=rlabel_pos,
+            theta_direction=-1,
+            theta_zero_location='N',
+            title=kwargs.get('title', None)
+        )
+        ax.set_thetagrids(angles=[0, 45, 90, 135, 180, 225, 270, 315],
+                          labels=["N", "NE", "E", "SE", "S", "SW", "W", "NW"])
+
+        plt.colorbar(scatter, ax=ax, label=Unit(val), pad=0.1, fraction=0.04)
+
+    plt.show()
+
+    return fig, ax

{aeroviz-0.1.9.5 → aeroviz-0.1.10}/AeroViz/plot/optical/optical.py

@@ -3,11 +3,10 @@ from typing import Literal
 
 import matplotlib.pyplot as plt
 import numpy as np
-# from PyMieScatt import ScatteringFunction
 from matplotlib.pyplot import Figure, Axes
 
-from AeroViz.plot.optical.PyMieScatt_update import ScatteringFunction
-from AeroViz.plot.optical.mie_theory import Mie_Q, Mie_MEE, Mie_PESD
+from AeroViz.dataProcess.Optical.PyMieScatt_update import ScatteringFunction
+from AeroViz.dataProcess.Optical.mie_theory import Mie_Q, Mie_MEE, Mie_PESD
 from AeroViz.plot.utils import *
 
 __all__ = ['Q_plot',

{aeroviz-0.1.9.5 → aeroviz-0.1.10}/AeroViz/plot/utils/plt_utils.py

@@ -50,7 +50,7 @@ def set_figure(func=None,
             plt.rcParams['legend.labelspacing'] = 0.7
 
             plt.rcParams['figure.figsize'] = figsize or (4, 4)
-            plt.rcParams['figure.dpi'] = 200
+            plt.rcParams['figure.dpi'] = 300
             plt.rcParams['figure.autolayout'] = autolayout
 
             if not autolayout: