Alaea 2.3.4__tar.gz → 2.3.6__tar.gz

{alaea-2.3.4 → alaea-2.3.6}/.gitattributes

@@ -15,6 +15,8 @@
 **/*.jpg filter=lfs diff=lfs merge=lfs -binary
 **/*.nml filter=lfs diff=lfs merge=lfs -binary
 **/*.xlsx filter=lfs diff=lfs merge=lfs -binary
+**/*.nc filter=lfs diff=lfs merge=lfs -binary
+**/*.mat filter=lfs diff=lfs merge=lfs -binary
 **/*.mhtml filter=lfs diff=lfs merge=lfs -binary linguist-language=HTML
 **/*.mlx filter=lfs diff=lfs merge=lfs -binary linguist-language=MATLAB
 **/*.md linguist-language=Markdown

{alaea-2.3.4 → alaea-2.3.6}/.gitignore

@@ -1,2 +1,3 @@
 ../../Project
 **/__pycache__
+**/.idea

{alaea-2.3.4 → alaea-2.3.6}/Alaea/Blogging.py

@@ -402,31 +402,31 @@ class Blog:
         return self._logger
     
     def __write_all_log(self):
-        all_logger_handler = self.__init_logger_handler(self.all_log_filename, Rotating=self.Rotating, when=self.when,
-                                                        interval=self.interval)  # 收集所有日志文件
+        all_logger_handler = self.__init_logger_handler(self.all_log_filename, Rotating=self.Rotating,
+                                                        when=self.when, interval=self.interval)  # 收集所有日志文件
         self.__set_log_formatter(all_logger_handler)  # 设置日志输出格式-all日志文件
         self.__set_log_handler(all_logger_handler, level=logging.DEBUG)  # 设置handler级别并添加到logger收集器
-        self.__close_log_handler(all_logger_handler)  # 关闭handler
+        # self.__close_log_handler(all_logger_handler)  # 关闭handler
     
     def __write_error_plus_log(self):
         error_logger_handler = self.__init_logger_handler(self.bug_log_filename, Rotating=self.Rotating,
                                                           when=self.when, interval=self.interval)  # 收集错误日志信息文件
         self.__set_log_formatter(error_logger_handler)  # 设置日志输出格式-error日志文件
         self.__set_log_handler(error_logger_handler, level=logging.ERROR)  # 设置handler级别并添加到logger收集器
-        self.__close_log_handler(error_logger_handler)  # 关闭handler
+        # self.__close_log_handler(error_logger_handler)  # 关闭handler
+
+    def __write_single_log(self, level=logging.ERROR, _level_log_name='all.log'):  # 日志单独输出
+        single_logger_handler = self.__init_logger_handler(_level_log_name, Rotating=self.Rotating,
+                                                           when=self.when, interval=self.interval)  # 收集随机日志信息文件
+        self.__set_log_formatter(single_logger_handler)  # 设置日志输出格式-single日志文件
+        self.__set_log_Filter(single_logger_handler, level)  # 设置过滤器
+        # self.__close_log_handler(single_logger_handler)  # 关闭handler
     
     def __print_log(self):
         console_handle = colorlog.StreamHandler()  # 创建终端日志记录器handler，用于输出到控制台
         self.__set_color_formatter(console_handle, self.colors_config)  # 设置输出格式-控制台
         self.__set_log_handler(console_handle, level=self.log_level)  # 设置handler级别并添加到终端logger收集器
-        self.__close_log_handler(console_handle)  # 关闭handler
-    
-    def __write_single_log(self, level=logging.ERROR, _level_log_name='all.log'):  # 日志单独输出
-        single_logger_handler = self.__init_logger_handler(_level_log_name, Rotating=self.Rotating, when=self.when,
-                                                           interval=self.interval)  # 收集随机日志信息文件
-        self.__set_log_formatter(single_logger_handler)  # 设置日志输出格式-single日志文件
-        self.__set_log_Filter(single_logger_handler, level)  # 设置过滤器
-        self.__close_log_handler(single_logger_handler)  # 关闭handler
+        # self.__close_log_handler(console_handle)  # 关闭handler
 
     def __rm_single_FileHandler(self):  # 删除日志文件并关闭日志记录器
         handlers = self._logger.handlers
@@ -434,6 +434,7 @@ class Blog:
             if isinstance(handler, logging.FileHandler):  # 找到文件处理器，进行删除操作
                 self._logger.removeHandler(handler)
                 handler.close()  # 关闭文件处理器，释放资源
+                # 注意：handler 只能在移除/销毁时 close；不要在 addHandler 之后立刻 close，否则会导致日志不写入/轮换不稳定
 
     @property
     def logger(self) -> _BlogLogger:

{alaea-2.3.4 → alaea-2.3.6}/Alaea/Standard/xr_attrs.py

@@ -9,33 +9,36 @@
 """
 
 """
+from typing import Union
+
 import numpy as np
+import xarray as xr
 
 from .. import new_filename
 
 __all__ = ['add_coors_attrs', 'add_lon_attrs', 'add_lat_attrs', 'add_time_attrs', 'add_TIME_attrs',
            'add_wind_attrs', 'add_temperature_attrs', 'add_precipitation_attrs', 'add_slp_attrs',
-           'add_wave_attrs', 'add_ice_attrs',
-           'fixed_encoding']
+           'add_wave_attrs', 'add_ice_attrs', 'add_visibility_attrs',
+           'fixed_encoding', 'calc_scale_offset', 'compress_scale_offset',
+           ]
 
 
-def add_coors_attrs(ds):
+def add_coors_attrs(_ds):
     """
     给xarray.Dataset的坐标添加属性
-    :param ds: xarray.Dataset
+    :param _ds: xarray.Dataset
     :return: xarray.Dataset
     """
-    lon_name, lat_name, time_name, TIME_name = 'longitude', 'latitude', 'time', 'TIME'
-    for i in ds.sizes.keys():  # ds.dims.keys(): --> FutureWarning
-        lon_name = i if i in ['lon', 'longitude'] else 'longitude'
-        lat_name = i if i in ['lat', 'latitude'] else 'latitude'
-        time_name = i if i in ['time'] else 'time'
-        TIME_name = i if i in ['TIME'] else 'TIME'
-    add_lon_attrs(ds, lon_name)
-    add_lat_attrs(ds, lat_name)
-    add_time_attrs(ds, time_name)
-    add_TIME_attrs(ds, TIME_name, dim_name='DateStr')
-    return ds
+    lon_name = next((x for x in ['lon', 'longitude'] if x in _ds.dims), None)
+    lat_name = next((x for x in ['lat', 'latitude'] if x in _ds.dims), None)
+    time_name = next((x for x in ['time'] if x in _ds.dims), None)
+    TIME_name = next((x for x in ['TIME'] if x in _ds.dims), None)
+
+    add_lon_attrs(_ds, lon_name)
+    add_lat_attrs(_ds, lat_name)
+    add_time_attrs(_ds, time_name)
+    add_TIME_attrs(_ds, TIME_name, dim_name='DateStr')
+    return _ds
     
 
 def add_lon_attrs(_ds, lon_name):
@@ -120,10 +123,8 @@ def add_wind_attrs(_ds):
     :param _ds: xarray.Dataset
     :return: xarray.Dataset
     """
-    U10_name, V10_name = 'U10', 'V10'
-    for i in list(_ds.data_vars.keys()):
-        U10_name = i if i in ['U10', 'u10'] else 'U10'
-        V10_name = i if i in ['V10', 'v10'] else 'V10'
+    U10_name = next((x for x in ['wind_U10', 'U10', 'u10'] if x in _ds.data_vars), None)
+    V10_name = next((x for x in ['wind_V10', 'V10', 'v10'] if x in _ds.data_vars), None)
     _ds[U10_name].attrs = {
         'units': 'm s-1',
         'long_name': '10 meter U wind component',
@@ -136,6 +137,59 @@ def add_wind_attrs(_ds):
     }
     _ds[U10_name].encoding = dict(_FillValue=9.962100e+36, dtype='single', zlib=True)
     _ds[V10_name].encoding = dict(_FillValue=9.962100e+36, dtype='single', zlib=True)
+
+    if 'AGL_heights' in _ds.variables:
+        _ds['AGL_heights'].attrs = {
+            'units': 'm',
+            'long_name': 'Above Ground Level Height',
+            'standard_name': 'height',
+        }
+        _ds['AGL_heights'].encoding = {'_FillValue': None}
+
+    if 'U_AGL' in _ds.variables and 'V_AGL' in _ds.variables:
+        _ds['U_AGL'].attrs = {
+            'units': 'm s-1',
+            'long_name': 'U-wind at AGL',
+            'standard_name': 'eastward_wind',
+        }
+        _ds['V_AGL'].attrs = {
+            'units': 'm s-1',
+            'long_name': 'V-wind at AGL',
+            'standard_name': 'northward_wind',
+        }
+        _ds['U_AGL'].encoding = dict(_FillValue=9.962100e+36, dtype='single', zlib=True)
+        _ds['V_AGL'].encoding = dict(_FillValue=9.962100e+36, dtype='single', zlib=True)
+
+    if 'MSL_heights' in _ds.variables:
+        _ds['MSL_heights'].attrs = {
+            'units': 'm',
+            'long_name': 'Mean Sea Level Height',
+            'standard_name': 'height',
+        }
+        _ds['MSL_heights'].encoding = {'_FillValue': None}
+
+    if 'U_MSL' in _ds.variables and 'V_MSL' in _ds.variables:
+        _ds['U_MSL'].attrs = {
+            'units': 'm s-1',
+            'long_name': 'U-wind at MSL',
+            'standard_name': 'eastward_wind',
+        }
+        _ds['V_MSL'].attrs = {
+            'units': 'm s-1',
+            'long_name': 'V-wind at MSL',
+            'standard_name': 'northward_wind',
+        }
+        _ds['U_MSL'].encoding = dict(_FillValue=9.962100e+36, dtype='single', zlib=True)
+        _ds['V_MSL'].encoding = dict(_FillValue=9.962100e+36, dtype='single', zlib=True)
+
+    if 'WSPD10MAX' in _ds.variables:
+        _ds['WSPD10MAX'].attrs = {
+            'units': 'm s-1',
+            'long_name': 'Maximum 10m wind speed',
+            'standard_name': 'maximum_10m_wind_speed',
+        }
+        _ds['WSPD10MAX'].encoding = dict(_FillValue=9.962100e+36, dtype='single', zlib=True)
+
     return _ds
 
 
@@ -145,9 +199,8 @@ def add_temperature_attrs(_ds):
     :param _ds: xarray.Dataset
     :return: xarray.Dataset
     """
-    T2_name = 'temperature'
-    for i in list(_ds.data_vars.keys()):
-        T2_name = i if i in ['T2', 't2'] else T2_name
+    T2_name = next((x for x in ['temperature', 'T2', 't2'] if x in _ds.data_vars), None)
+
     _ds[T2_name].attrs = {
         'units': 'K',
         'long_name': 'temperature at 2m',
@@ -157,15 +210,31 @@ def add_temperature_attrs(_ds):
     return _ds
 
 
+def add_visibility_attrs(_ds):
+    """
+    给xarray.Dataset的能见度添加属性
+    :param _ds: xarray.Dataset
+    :return: xarray.Dataset
+    """
+    visibility_name = next((x for x in ['visibility', 'AFWA_VIS', 'VISIBILITY'] if x in _ds.data_vars), None)
+
+    _ds[visibility_name].attrs = {
+        'units': 'm',
+        'long_name': 'visibility',
+        'standard_name': 'visibility'
+    }
+    _ds[visibility_name].encoding = dict(_FillValue=9.962100e+36, dtype='single', zlib=True)
+    return _ds
+
+
 def add_precipitation_attrs(_ds):
     """
     给xarray.Dataset的降水添加属性
     :param _ds: xarray.Dataset
     :return: xarray.Dataset
     """
-    precipitation_name = 'precipitation'
-    for i in list(_ds.data_vars.keys()):
-        precipitation_name = i if i in ['tp', 'TP'] else precipitation_name
+    precipitation_name = next((x for x in ['precipitation', 'tp', 'TP', 'Precipitation'] if x in _ds.data_vars), None)
+
     _ds[precipitation_name].attrs = {
         'units': 'mm',
         'long_name': 'precipitation, positive for ocean gaining water',
@@ -181,9 +250,8 @@ def add_slp_attrs(_ds):
     :param _ds: xarray.Dataset
     :return: xarray.Dataset
     """
-    slp_name = 'slp'
-    for i in list(_ds.data_vars.keys()):
-        slp_name = i if i in ['slp', 'SLP'] else slp_name
+    slp_name = next((x for x in ['slp', 'SLP'] if x in _ds.data_vars), None)
+
     _ds[slp_name].attrs = {
         'units': 'Pa',
         'long_name': 'sea level pressure',
@@ -199,24 +267,20 @@ def add_wave_attrs(_ds):
     :param _ds: xarray.Dataset
     :return: xarray.Dataset
     """
-    swh_name, mwp_name, mwd_name, mwl_name = 'swh', 'mwp', 'mwd', 'mwl'
-    pp1d_name = 'pp1d'
-    shww_name, shts_name, mdww_name, mdts_name = 'shww', 'shts', 'mdww', 'mdts'
-    mpww_name, mpts_name, hmax_name = 'mpww', 'mpts', 'hmax'
-
-    for i in list(_ds.data_vars.keys()):
-        swh_name = i if i in ['swh'] else swh_name
-        mwp_name = i if i in ['mwp'] else mwp_name
-        mwd_name = i if i in ['mwd'] else mwd_name
-        mwl_name = i if i in ['mwl'] else mwl_name
-        pp1d_name = i if i in ['pp1d'] else pp1d_name
-        shww_name = i if i in ['shww'] else shww_name
-        shts_name = i if i in ['shts'] else shts_name
-        mdww_name = i if i in ['mdww'] else mdww_name
-        mdts_name = i if i in ['mdts'] else mdts_name
-        mpww_name = i if i in ['mpww'] else mpww_name
-        mpts_name = i if i in ['mpts'] else mpts_name
-        hmax_name = i if i in ['hmax'] else hmax_name
+    swh_name = next((x for x in ['swh', 'SWH'] if x in _ds.data_vars), None)  # 有效波高
+    mwp_name = next((x for x in ['mwp', 'MWP'] if x in _ds.data_vars), None)  # 平均波周期
+    mwd_name = next((x for x in ['mwd', 'MWD'] if x in _ds.data_vars), None)  # 平均波向
+    mwl_name = next((x for x in ['mwl', 'MWL'] if x in _ds.data_vars), None)  # 平均波长
+
+    shww_name = next((x for x in ['shww', 'SHWW'] if x in _ds.data_vars), None)  # 风浪有效波高
+    shts_name = next((x for x in ['shts', 'SHTS'] if x in _ds.data_vars), None)  # 涌浪有效波高
+    mdww_name = next((x for x in ['mdww', 'MDWW'] if x in _ds.data_vars), None)  # 风浪平均波向
+    mdts_name = next((x for x in ['mdts', 'MDTS'] if x in _ds.data_vars), None)  # 涌浪平均波向
+    mpww_name = next((x for x in ['mpww', 'MPWW'] if x in _ds.data_vars), None)  # 风浪平均波周期
+    mpts_name = next((x for x in ['mpts', 'MPTS'] if x in _ds.data_vars), None)  # 涌浪平均波周期
+    
+    pp1d_name = next((x for x in ['pp1d', 'PP1D'] if x in _ds.data_vars), None)  # 峰值周期
+    hmax_name = next((x for x in ['hmax', 'HMAX'] if x in _ds.data_vars), None)  # 最大波高
 
     if swh_name in _ds:
         _ds[swh_name].attrs = {
@@ -329,12 +393,8 @@ def add_ice_attrs(_ds):
     :param _ds: xarray.Dataset
     :return: xarray.Dataset
     """
-    aice_name = 'aice'
-    tice_name = 'tice'
-
-    for i in list(_ds.data_vars.keys()):
-        aice_name = i if i in ['aice'] else aice_name
-        tice_name = i if i in ['tice'] else tice_name
+    aice_name = next((x for x in ['aice'] if x in _ds.data_vars), None)
+    tice_name = next((x for x in ['tice'] if x in _ds.data_vars), None)
 
     if aice_name in _ds:
         _ds[aice_name].attrs = {
@@ -370,3 +430,57 @@ def fixed_encoding(_ds, **kwargs):
     _ds.encoding['contiguous'] = kwargs.get('contiguous', True)
     _ds.encoding.update(kwargs)
     return _ds
+
+
+def calc_scale_offset(
+        _data: np.ndarray,
+        _dtype=np.int16
+) -> tuple[float, float]:
+    """
+    计算scale_factor和add_offset
+    :param _data: 数据数组
+    :param _dtype: 压缩后的数据类型，默认为int16
+    :return: scale_factor, add_offset
+    """
+    valid_min = np.nanmin(_data)
+    valid_max = np.nanmax(_data)
+
+    if valid_min == valid_max:
+        scale_factor = 1.0
+        add_offset = valid_min
+    else:
+        scale_factor = (valid_max - valid_min) / (np.iinfo(_dtype).max - np.iinfo(_dtype).min)
+        add_offset = valid_min - np.iinfo(_dtype).min * scale_factor
+
+    return scale_factor, add_offset
+
+
+def compress_scale_offset(
+        _ds: xr.Dataset,
+        _var_name: Union[str, list[str]] = None,
+        _dtype=np.int16
+) -> xr.Dataset:
+    """
+    给xarray.Dataset的变量添加压缩属性
+    :param _ds: xarray.Dataset
+    :param _var_name: 变量名或变量名列表
+    :param _dtype: 压缩后的数据类型，默认为int16
+    :return: xarray.Dataset
+    """
+
+    if _var_name is None:
+        _var_name = list(_ds.data_vars.keys())
+    elif isinstance(_var_name, str):
+        _var_name = [_var_name]
+
+    for var in _var_name:
+        if var in _ds.data_vars:
+            data = _ds[var].data
+            scale_factor, add_offset = calc_scale_offset(data, _dtype=_dtype)
+
+            _ds[var].encoding['dtype'] = _dtype
+            _ds[var].encoding['scale_factor'] = scale_factor
+            _ds[var].encoding['add_offset'] = add_offset
+            _ds[var].encoding['_FillValue'] = np.iinfo(_dtype).min
+
+    return _ds

alaea-2.3.6/Alaea/baysalt/Forage/__init__.py

@@ -0,0 +1,11 @@
+#!/Users/christmas/opt/anaconda3/bin/python3
+# -*- coding: utf-8 -*-
+#  日期 : 2023/4/7 23:14
+#  作者 : Christmas
+#  邮箱 : 273519355@qq.com
+#  项目 : Project
+#  版本 : python 3
+#  摘要 :
+"""
+
+"""

alaea-2.3.6/Alaea/baysalt/Forage/erosion_data/__init__.py

@@ -0,0 +1,11 @@
+#!/Users/christmas/opt/anaconda3/bin/python3
+# -*- coding: utf-8 -*-
+#  日期 : 2023/4/7 23:52
+#  作者 : Christmas
+#  邮箱 : 273519355@qq.com
+#  项目 : Project
+#  版本 : python 3
+#  摘要 :
+"""
+
+"""

alaea-2.3.6/Alaea/baysalt/__init__.py

@@ -0,0 +1,11 @@
+#!/bin/env python3
+# -*- coding: utf-8 -*-
+#  日期 : 2026/3/9 14:43
+#  作者 : Christmas
+#  邮箱 : 273519355@qq.com
+#  项目 : Project
+#  版本 : python 3
+#  摘要 :
+"""
+
+"""

alaea-2.3.6/Alaea/baysalt/erosion_coastline.py

@@ -0,0 +1,405 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#  日期 : 2026/3/9 14:44
+#  作者 : Christmas
+#  邮箱 : 273519355@qq.com
+#  项目 : Project
+#  版本 : python 3
+#  摘要 :
+"""
+1. 先找出“需要被填补”的点（通常是海陆交界处的水点、空值点、mask 点）
+2. 再为这些点找到周围最近的 K 个邻居
+3. 过滤掉“周围有效邻居太少”的点
+4. 把可用邻居的值做平均，回填到目标点中
+
+这里的“erosion（侵蚀）”更接近一种海岸线附近的掩膜修正 / 邻域填补：
+"""
+
+import itertools
+import time
+from collections import deque
+
+import matplotlib.pyplot as plt
+import numpy as np
+import scipy.spatial as spt
+import xarray as xr
+from netCDF4 import Dataset
+from scipy.io import loadmat
+
+from Alaea.Blogging import Blog
+from Alaea.tools.Read import read_json, write_json
+
+__all__ = [
+    'erosion_cal_id',
+    'erosion_via_id',
+    'LOGGER',
+]
+
+BLOG = Blog('erosion_coastline')
+BLOG.setup_Blog(log_level=BLOG.DEBUG)
+LOGGER = BLOG.logger
+
+
+def erosion_cal_id(
+        g_lon,
+        g_lat,
+        value,
+        k,
+        judge_num,
+        method='np.nan',
+):
+    """
+    计算“哪些点需要被回填”，以及“每个点应该参考哪些邻居点”。
+
+    这个函数不直接修改 value，而是先生成一个索引说明书 `_weight`：
+    - change_lat / change_lon：哪些点要被修改
+    - value_lat / value_lon：每个待修改点应当使用哪些邻居点的值
+
+    整体流程：
+    1. 把规则网格展开成二维坐标点云
+    2. 用 KDTree 为每个格点查找最近的 k 个邻居
+    3. 根据 method 判断哪些点是“待处理点”
+    4. 再检查它们的 k 个邻居里是否有足够多的有效点
+    5. 只保留满足 judge_num 条件的点，返回后续填补所需索引
+
+    参数说明：
+    - k：每个目标点向周围找多少个最近邻
+    - judge_num：最少需要多少个“有效邻居”才允许回填
+    - method='np.nan'：把 NaN 看成待处理点
+    - method='nc.mask'：把 masked array 中 mask=True 的点看成待处理点
+    - method='txt.mask'：把值为 0 的点看成待处理点（常用于陆海 mask）
+
+    :param g_lon: 一维格点经度
+    :param g_lat: 一维格点纬度
+    :param value: 二维格点值
+    :param k: 寻找近邻点的个数
+    :param judge_num: 至少需要多少个有效邻居点才保留该目标点
+    :param method: 判断目标点类型的方法
+                    np.nan：直接在 value 中用 NaN 表示无效点
+                    nc.mask：NetCDF masked array，用 mask 属性判断无效点
+                    txt.mask：文本/掩膜型数据，0 表示水点，非 0 表示陆点
+    :return: 字典，描述待修改点及其邻居索引
+    """
+    # 网格大小（这里只是记录下来，后面真正高频使用的是 lon_number）
+    lat_number = len(g_lat)
+    # 一行有多少个经度格点，用于后面把一维展开索引还原成二维行列索引
+    lon_number = len(g_lon)
+    # 例如 g_lon.shape=(nlon,), g_lat.shape=(nlat,)
+    # meshgrid 后得到两个 (nlat, nlon) 的二维数组，分别存放每个格点的经纬度
+    LOGGER.debug(f'开始建立Kdtree，格点数量约为 {lat_number} * {lon_number}，每个点找 {k} 个邻居，至少需要 {judge_num} 个有效邻居')
+    lon_mesh, lat_mesh = np.meshgrid(g_lon, g_lat)
+    # 后面 KDTree 就是在这个二维坐标集合上做最近邻搜索
+    point = np.column_stack((lon_mesh.ravel(), lat_mesh.ravel()))
+    # 下面两个 deque 用来保存所有“候选邻居点”的二维索引
+    fp_lon = deque([])
+    fp_lat = deque([])
+
+    # 建立 KDTree：适合大量最近邻查询
+    # 这里 point 里装的是所有格点坐标，所以相当于“让每个格点去找离自己最近的 k 个格点”
+    ckt = spt.cKDTree(point)  # 用C写的查找类，执行速度更快
+    # 这里不再逐点循环，而是一次性把所有格点的近邻都查出来
+    LOGGER.debug('Kdtree建立完毕，开始查找每个格点的近邻点')
+
+    # 对所有格点一次性查询最近邻：
+    # distances.shape 约为 (n_points, k)
+    # sequences.shape 约为 (n_points, k)
+    # sequences 里保存的是最近邻在 point 数组中的一维编号
+    distances, sequences = ckt.query(point, k)
+
+    # point 中每个元素对应一个展开后的一维索引 [0, 1, 2, ...]
+    idx_all = np.arange(point.shape[0])
+    # 把展开索引还原回二维索引：
+    # 行号 = index // 每行列数
+    lat_i_all = idx_all // lon_number
+    # 列号 = index % 每行列数
+    lon_i_all = idx_all % lon_number
+
+    # 先找出哪些格点属于“待处理点”
+    # 不同数据源中，水点/无效点/边界点的表达方式不同，所以这里分三种判断方法
+    if method == 'np.nan':
+        mask = np.isnan(value[lat_i_all, lon_i_all])
+    elif method == 'nc.mask':
+        mask = value.mask[lat_i_all, lon_i_all]
+    elif method == 'txt.mask':
+        mask = (value[lat_i_all, lon_i_all] == 0)
+    else:
+        mask = np.zeros_like(lat_i_all, dtype=bool)
+
+    # 只保留那些“需要处理”的点在 point 里的编号
+    valid_idx = idx_all[mask]
+
+    # 取出这些目标点各自对应的 k 个最近邻编号
+    neigh = sequences[valid_idx]
+
+    # 展平后，后面统一换算成二维索引
+    neigh = neigh.reshape(-1)
+
+    # 邻居点的一维编号 -> 二维行列编号
+    lat_j = neigh // lon_number
+    lon_j = neigh % lon_number
+
+    # 这里会把所有目标点的 k 个邻居顺序拼在一起
+    # 因此后面需要再按 k reshape 回去，恢复“每 k 个属于同一个目标点”的结构
+    fp_lat.extend(lat_j.tolist())
+    fp_lon.extend(lon_j.tolist())
+    LOGGER.debug('所有格点的近邻点查找完毕，开始获取行列索引')
+
+    # 这里 fp_lat / fp_lon 已经是索引，不再需要 find_index
+    lat_id = list(fp_lat)
+    lon_id = list(fp_lon)
+
+    LOGGER.debug('行列索引获取完毕，开始判断每个目标点的邻居里有效点数量')
+    
+    # 根据不同类型的数据，进一步判断：
+    # 某个目标点的 k 个邻居里，是否有足够多的有效点可以拿来回填
+    lonli_arr = np.array([0])
+    latli_arr = np.array([0])
+    if method == 'np.nan':
+        latli_arr, lonli_arr = judge_nan_npnan(lat_id, lon_id, value, k, judge_num)
+    elif method =='nc.mask':
+        latli_arr, lonli_arr = judge_nan_ncmask(lat_id, lon_id, value, k, judge_num)
+    elif method == 'txt.mask':
+        latli_arr, lonli_arr = judge_nan_txtmask(lat_id, lon_id, value, k, judge_num)
+
+    LOGGER.debug('有效邻居点数量判断完毕，开始生成索引')
+
+    # reshape 之后，每一行对应“一个目标点 + 它的 k-1 或 k 个邻居”
+    # 约定每行第 1 列是目标点本身，后面各列是参考邻居
+    _change_lat = latli_arr[:, 0].tolist()
+    _change_lon = lonli_arr[:, 0].tolist()
+    # 每行剩下的就是用来赋值的
+    _value_lat = latli_arr[:, 1:].tolist()
+    _value_lon = lonli_arr[:, 1:].tolist()
+
+    # 组织成统一的索引字典，供 erosion_via_id 直接使用
+    _weight = {
+        'change_lat': _change_lat,
+        'change_lon': _change_lon,
+        'value_lat': _value_lat,
+        'value_lon': _value_lon,
+    }
+    return _weight
+
+
+def judge_nan_ncmask(latli, lonli, value, k, judge_num):
+    """
+    针对 masked array（mask=True 表示无效点）筛选可参与回填的目标点。
+
+    思路：
+    - latli / lonli 当前是展平后的邻居索引序列
+    - 每 k 个索引对应 1 个目标点及其 k 个最近邻
+    - 如果这 k 个点里“未被 mask 的有效点”数量不少于 judge_num，
+      就保留这一组索引
+    """
+    # 先转成数组，便于 reshape 成 [目标点数, k] 的二维结构
+    latli_1 = np.array(latli)
+    lonli_1 = np.array(lonli)
+    # 每一行表示一个目标点对应的 k 个最近邻索引
+    latli_2 = np.reshape(latli_1, [-1, k])
+    lonli_2 = np.reshape(lonli_1, [-1, k])
+    # mask=True 说明该位置是无效/被遮罩的点
+    mask_arr = value.mask
+    # 取出每组 k 个邻居的 mask 情况
+    test_arr = mask_arr[latli_2.tolist(), lonli_2.tolist()]  # 判断找出来的点里有哪些需要处理
+
+    # 统计每组中“无效点”的数量
+    sum_arr = np.sum(test_arr, axis=1)  #
+
+    # 无效点数 <= k - judge_num，等价于有效点数 >= judge_num
+    select_id = np.where(sum_arr <= k-judge_num)[0].tolist()
+
+    latli_r = latli_2[select_id[:]]
+    lonli_r = lonli_2[select_id[:]]
+
+    return latli_r, lonli_r
+
+
+def judge_nan_npnan(latli, lonli, value, k, judge_num):
+    """
+    针对普通 ndarray 中 NaN 表示无效值的情况，筛选可参与回填的目标点。
+
+    逻辑与 judge_nan_ncmask 一样，只不过这里通过 np.isnan(value)
+    判断某个点是否无效。
+    """
+    # 每 k 个索引是一组，后面要恢复成二维结构
+    latli_1 = np.array(latli)
+    lonli_1 = np.array(lonli)
+    # reshape 后每一行对应 1 个目标点的 k 个邻居
+    latli_2 = np.reshape(latli_1, [-1, k])
+    lonli_2 = np.reshape(lonli_1, [-1, k])
+    # NaN 为 True，表示该点不能直接作为有效值参与平均
+    mask_arr = np.isnan(value)
+
+    # 检查每组 k 个邻居中哪些位置是 NaN
+    test_arr = mask_arr[latli_2.tolist(), lonli_2.tolist()]  # 判断找出来的点里有哪些需要处理
+    sum_arr = np.sum(test_arr, axis=1)  #
+
+    # 只有有效值数量 >= judge_num 的目标点，才保留下来
+    select_id = np.where(sum_arr <= k-judge_num)[0].tolist()
+
+    latli_r = latli_2[select_id[:]]
+    lonli_r = lonli_2[select_id[:]]
+
+    return latli_r, lonli_r
+
+
+def judge_nan_txtmask(latli, lonli, value, k, judge_num):
+    """
+    针对文本/掩膜型数据（0 表示水点，非 0 表示陆点）筛选可参与回填的目标点。
+
+    这里与前两个函数不同：
+    - 前两个函数统计的是“无效点个数”
+    - 这里直接统计邻居值之和，本质上是在数一组邻居里有多少个陆点（值为 1）
+
+    当一组邻居中陆点数量 >= judge_num 时，保留该组。
+    """
+    # 同样先恢复成 [目标点数, k] 的结构
+    latli_1 = np.array(latli)
+    lonli_1 = np.array(lonli)
+    latli_2 = np.reshape(latli_1, [-1, k])
+    lonli_2 = np.reshape(lonli_1, [-1, k])
+
+    # 取出每组邻居的实际值；在 mask 中通常 0=水，1=陆
+    test_arr = value[latli_2.tolist(), lonli_2.tolist()]  # 判断找出来的点里有哪些需要处理
+
+    # 每组求和，相当于统计这一组里有多少个陆点
+    sum_arr = np.sum(test_arr, axis=1)  #
+
+    # 只有陆点数达到阈值，才把该目标点纳入后续腐蚀/填补
+    select_id = np.where(sum_arr >= judge_num)[0].tolist()
+
+    latli_r = latli_2[select_id[:]]
+    lonli_r = lonli_2[select_id[:]]
+
+    return latli_r, lonli_r
+
+
+def erosion_via_id(_weight, value):
+    """
+    根据 erosion_cal_id 生成的索引说明书，对目标点执行回填。
+
+    核心思想：
+    - 对每个待修改点，取出它对应邻居点的值
+    - 对这些邻居值做平均（np.nanmean 会自动跳过 NaN）
+    - 再把平均值写回目标点
+
+    支持两种输入：
+    - 2D: [lat, lon]
+    - 3D: [time, lat, lon]
+
+    :param _weight: erosion_cal_id 返回的字典
+    :param value: 二维或三维格点值
+    :return: 回填后的新数组
+    """
+
+    # 要被修改的目标点索引
+    _change_lat = _weight['change_lat']
+    _change_lon = _weight['change_lon']
+    _value_lat = _weight['value_lat']
+    _value_lon = _weight['value_lon']
+
+    # 拷贝一份，避免直接改原数组
+    new = value.copy()
+    # 3D 情况：常见于 [time, lat, lon]
+    if value.ndim == 3:
+        for i in range(value.shape[0]):
+            # 取出当前时刻下，每个目标点对应的一组邻居值
+            replace = value[i, _value_lat, _value_lon]
+            # 对每组邻居求平均，得到每个目标点的新值
+            replace = np.nanmean(replace, axis=1)
+            # 写回当前时刻的目标点位置
+            new[i, _change_lat, _change_lon] = replace[:]
+
+    # 2D 情况：直接对一个平面进行处理
+    elif value.ndim == 2:
+        # 取出每个目标点对应的一组邻居值
+        replace = value[_value_lat, _value_lon]
+        # 每组邻居求平均
+        replace = np.nanmean(replace, axis=1)
+        # 把平均值写回目标点
+        new[_change_lat, _change_lon] = replace[:]
+
+    return new
+
+
+def example_cal_weight(methoood):  # sourcery skip: extract-duplicate-method
+    """
+    示例函数：演示如何针对不同类型的数据源计算 weight，并执行一次回填。
+
+    methoood 含义：
+    1 -> txt.mask：外部 mask 文件中 0/1 表示海陆
+    2 -> nc.mask：NetCDF masked array，用 mask 属性判断无效点
+    3 -> np.nan：直接在数据中用 NaN 表示无效点
+    """
+
+    if methoood == 1:
+        mask_wrf = loadmat('/Users/christmas/Documents/Code/Project/A-pypi/Alaea/Alaea/baysalt/Forage/erosion_data/mask_wrf.mat')['mask_wrf']
+        ds = xr.open_dataset('/Users/christmas/Documents/Code/Project/A-pypi/Alaea/Alaea/baysalt/Forage/erosion_data/erosion_ww3.nc')  # ww3直接输出的nc，由于海浪可能算出来nan，所以用地形文件判断nan
+        lons = ds['longitude'][:].data
+        lats = ds['latitude'][:].data
+        viss = ds['hs'][:].data
+        ds.close()
+        weight_1 = erosion_cal_id(lons, lats, mask_wrf, 16, 3, method='txt.mask')
+        mask_wrf_1 = erosion_via_id(weight_1, mask_wrf)
+        weight_2 = erosion_cal_id(lons, lats, mask_wrf_1, 24, 3, method='txt.mask')
+        new_hs = erosion_via_id(weight_1, viss)
+        new_hs_2 = erosion_via_id(weight_2, new_hs)
+        
+        plt.contourf(viss[0, 500:800, 1200:1700], cmap='jet')
+        plt.colorbar()
+        plt.show()
+        plt.contourf(new_hs[0, 500:800, 1200:1700], cmap='jet')
+        plt.colorbar()
+        plt.show()
+        plt.contourf(new_hs_2[0, 500:800, 1200:1700], cmap='jet')
+        plt.colorbar()
+        plt.show()
+
+    elif methoood == 2:
+        f = Dataset('/Users/christmas/Documents/Code/Project/A-pypi/Alaea/Alaea/baysalt/Forage/erosion_data/erosion_xujie.nc')  # 杰哥写的nc，用mask的属性判断nan，data里是--，mask里是True
+        lons = f.variables['lon'][:]
+        lats = f.variables['lat'][:]
+        viss = f.variables['hs'][:]
+        f.close()
+        weight = erosion_cal_id(lons, lats, viss, 16, 3, method='nc.mask')
+        
+        new_hs = erosion_via_id(weight, viss)
+        
+        plt.contourf(viss[:, :], cmap='jet')
+        plt.colorbar()
+        plt.show()
+        plt.contourf(new_hs[:, :], cmap='jet')
+        plt.colorbar()
+        plt.show()
+
+    elif methoood == 3:
+        # f = Dataset('/Users/christmas/Documents/Code/Project/A-pypi/Alaea/Alaea/baysalt/Forage/erosion_data/erosion_Post_ww3.nc')  # Postprocess_WW3产生的nc，mask为False，data里是nan
+        ds = xr.open_dataset('/Users/christmas/Documents/Code/Project/A-pypi/Alaea/Alaea/baysalt/Forage/erosion_data/erosion_Post_ww3.nc')
+        lons = ds['longitude'][900:1200].data
+        lats = ds['latitude'][300:500].data
+        viss = ds['swh'][:, 300:500, 900:1200].data
+        ds.close()
+        # f.close()
+        weight = erosion_cal_id(lons, lats, viss[0, :, :], 16, 3, method='np.nan')
+        
+        new_hs = erosion_via_id(weight, viss)
+        
+        plt.contourf(viss[0, :, :], cmap='jet')
+        plt.colorbar()
+        plt.show()
+        plt.contourf(new_hs[0, :, :], cmap='jet')
+        plt.colorbar()
+        plt.show()
+        
+    else:
+        raise ValueError()
+
+
+if __name__ == '__main__':
+    # 简单计时，看看一次示例运行要多久
+    start = time.perf_counter()
+    example_cal_weight(1)
+    example_cal_weight(2)
+    example_cal_weight(3)
+    print(f'耗时: {time.perf_counter() - start}秒')
+    # test()

{alaea-2.3.4 → alaea-2.3.6}/Alaea/processBar.py

@@ -11,10 +11,18 @@ processBar such as: ftp sftp
 """
 import datetime
 import time
+from typing import Union
 
 import numpy as np
 
-__all__ = ['translate_byte', 'LowSpeed_Error', 'SftpProcessbar', 'FtpProcessbar', 'FtpHtmlProcessbar']
+__all__ = [
+    'translate_byte',
+    'translate_seconds',
+    'LowSpeed_Error',
+    'SftpProcessbar',
+    'FtpProcessbar',
+    'FtpHtmlProcessbar',
+]
 
 
 def translate_byte(B):
@@ -39,6 +47,22 @@ def translate_byte(B):
         return '{:.2f} TB'.format(B / TB)
 
 
+def translate_seconds(_seconds: Union[int, float]) -> str:
+    """
+    :param _seconds: 秒数
+    :return: 转换后的时间字符串
+    """
+    _seconds = float(_seconds)
+    if _seconds < 60:
+        return f"{_seconds:.2f} seconds"
+    elif 60 <= _seconds < 3600:
+        return f"{_seconds / 60:.2f} minutes"
+    elif 3600 <= _seconds < 86400:
+        return f"{_seconds / 3600:.2f} hours"
+    else:
+        return f"{_seconds / 86400:.2f} days"
+
+
 class LowSpeed_Error(Exception):
     """
     :param value: 低速异常

{alaea-2.3.4 → alaea-2.3.6}/Alaea/tools/Read.py

@@ -11,6 +11,12 @@
 """
 import json
 
+__all__ = [
+    'read_json',
+    'write_json',
+    'unique_list'
+]
+
 
 def read_json(_filepath):
     """
@@ -22,6 +28,24 @@ def read_json(_filepath):
         data = json.load(f)
     return data
 
+def write_json(
+        _filepath,
+        _data,
+        _encoding='utf-8',
+        _ensure_ascii=False,
+        _indent=4
+):
+    """
+    写入JSON文件
+    :param _filepath: JSON文件路径
+    :param _data: 要写入的数据
+    :param _encoding: 文件编码，默认为'utf-8'
+    :param _ensure_ascii: 是否确保ASCII编码，默认为False
+    :param _indent: 缩进级别，默认为4
+    """
+    with open(_filepath, 'w', encoding=_encoding) as f:
+        json.dump(_data, f, ensure_ascii=_ensure_ascii, indent=_indent)
+
 
 # 列表去重
 def unique_list(_lst):
@@ -38,4 +62,4 @@ def unique_list(_lst):
         _set.add(item)
         result.append(item)
     
-    return result
+    return result

{alaea-2.3.4 → alaea-2.3.6/Alaea.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Alaea
-Version: 2.3.4
+Version: 2.3.6
 Summary: Some simple tools by Christmas
 Author: Christmas
 Author-email: 273519355@qq.com

{alaea-2.3.4 → alaea-2.3.6}/Alaea.egg-info/SOURCES.txt

@@ -27,6 +27,10 @@ Alaea/Standard/__init__.py
 Alaea/Standard/xr_attrs.py
 Alaea/Standard/xr_ice.py
 Alaea/Standard/xr_wave.py
+Alaea/baysalt/__init__.py
+Alaea/baysalt/erosion_coastline.py
+Alaea/baysalt/Forage/__init__.py
+Alaea/baysalt/Forage/erosion_data/__init__.py
 Alaea/exutils/__init__.py
 Alaea/exutils/Interp/Interp_g2s.py
 Alaea/exutils/Interp/Interp_s2g.py

{alaea-2.3.4/Alaea.egg-info → alaea-2.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Alaea
-Version: 2.3.4
+Version: 2.3.6
 Summary: Some simple tools by Christmas
 Author: Christmas
 Author-email: 273519355@qq.com

{alaea-2.3.4 → alaea-2.3.6}/setup.py

@@ -8,7 +8,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="Alaea",
-    version="2.3.4",
+    version="2.3.6",
     author="Christmas",
     author_email="273519355@qq.com",
     description="Some simple tools by Christmas",