oafuncs 0.0.98.42__tar.gz → 0.0.98.44__tar.gz

{oafuncs-0.0.98.42/oafuncs.egg-info → oafuncs-0.0.98.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oafuncs
-Version: 0.0.98.42
+Version: 0.0.98.44
 Summary: Oceanic and Atmospheric Functions
 Home-page: https://github.com/Industry-Pays/OAFuncs
 Author: Kun Liu
@@ -65,8 +65,6 @@ Just for the convenience of daily use, some complex operations are integrated in
 The code will be optimized and updated from time to time, with additions, deletions, or modifications…
 
 Existing functions will not be completely removed, they might just have a different function name, or the parameter passing might have been optimized…
-
-Note: If there are any requirements, you can email to liukun0312@stu.ouc.edu.cn. Within my capabilities, I can consider implementing them.
 ```
 
 ## PyPI
@@ -81,6 +79,11 @@ https://pypi.org/project/oafuncs
 https://github.com/Industry-Pays/OAFuncs
 ```
 
+## Download information
+```html
+https://pypistats.org/packages/oafuncs
+```
+
 ## Example
 
 ```python
@@ -182,3 +185,6 @@ query()
 <img title="" src="./oafuncs/data_store/OAFuncs.png" alt="">
 
 <img title="OAFuncs" src="https://raw.githubusercontent.com/Industry-Pays/OAFuncs/main/oafuncs/_data/oafuncs.png" alt="OAFuncs">
+
+## Wiki
+更多内容，查看[wiki](https://opendeep.wiki/Industry-Pays/OAFuncs/introduction)

{oafuncs-0.0.98.42 → oafuncs-0.0.98.44}/README.md

@@ -12,8 +12,6 @@ Just for the convenience of daily use, some complex operations are integrated in
 The code will be optimized and updated from time to time, with additions, deletions, or modifications…
 
 Existing functions will not be completely removed, they might just have a different function name, or the parameter passing might have been optimized…
-
-Note: If there are any requirements, you can email to liukun0312@stu.ouc.edu.cn. Within my capabilities, I can consider implementing them.
 ```
 
 ## PyPI
@@ -28,6 +26,11 @@ https://pypi.org/project/oafuncs
 https://github.com/Industry-Pays/OAFuncs
 ```
 
+## Download information
+```html
+https://pypistats.org/packages/oafuncs
+```
+
 ## Example
 
 ```python
@@ -129,3 +132,6 @@ query()
 <img title="" src="./oafuncs/data_store/OAFuncs.png" alt="">
 
 <img title="OAFuncs" src="https://raw.githubusercontent.com/Industry-Pays/OAFuncs/main/oafuncs/_data/oafuncs.png" alt="OAFuncs">
+
+## Wiki
+更多内容，查看[wiki](https://opendeep.wiki/Industry-Pays/OAFuncs/introduction)

{oafuncs-0.0.98.42 → oafuncs-0.0.98.44}/oafuncs/__init__.py

@@ -40,4 +40,6 @@ from .oa_tool import *
 # from ._script import *
 # ------------------- 2025-03-16 15:56:01 -------------------
 from .oa_date import *
-# ------------------- 2025-03-27 16:56:57 -------------------
+# ------------------- 2025-03-27 16:56:57 -------------------
+from .oa_geo import *
+# ------------------- 2025-09-04 14:08:26 -------------------

{oafuncs-0.0.98.42 → oafuncs-0.0.98.44}/oafuncs/_script/netcdf_write.py

@@ -1,55 +1,28 @@
 import os
 import warnings
-
-import netCDF4 as nc
 import numpy as np
 import xarray as xr
+import netCDF4 as nc
 
 warnings.filterwarnings("ignore", category=RuntimeWarning)
 
-
-
-def _nan_to_fillvalue(ncfile,set_fill_value):
+def _get_dtype_info(dtype):
     """
-    将 NetCDF 文件中所有变量的 NaN 和掩码值替换为其 _FillValue 属性（若无则自动添加 _FillValue=-32767 并替换）。
-    同时处理掩码数组中的无效值。
-    仅对数值型变量（浮点型、整型）生效。
+    根据输入的 dtype 返回其 numpy_type, clip_min, clip_max。
+    支持 int8, int16, int32, int64 四种整数类型。
+    简化处理：不使用fill_value，所有特殊值统一为NaN。
+    使用完整的数据类型范围，不预留填充值空间。
     """
-    with nc.Dataset(ncfile, "r+") as ds:
-        for var_name in ds.variables:
-            var = ds.variables[var_name]
-            # 只处理数值类型变量 (f:浮点型, i:有符号整型, u:无符号整型)
-            if var.dtype.kind not in ["f", "i", "u"]:
-                continue
-
-            # 读取数据
-            arr = var[:]
-
-            # 确定填充值
-            if "_FillValue" in var.ncattrs():
-                fill_value = var.getncattr("_FillValue")
-            elif hasattr(var, "missing_value"):
-                fill_value = var.getncattr("missing_value")
-            else:
-                fill_value = set_fill_value
-                try:
-                    var.setncattr("_FillValue", fill_value)
-                except Exception:
-                    # 某些变量可能不允许动态添加 _FillValue
-                    continue
-
-            # 处理掩码数组
-            if hasattr(arr, "mask"):
-                # 如果是掩码数组，将掩码位置的值设为 fill_value
-                if np.any(arr.mask):
-                    arr = np.where(arr.mask, fill_value, arr.data if hasattr(arr, "data") else arr)
-
-            # 处理剩余 NaN 和无穷值
-            if arr.dtype.kind in ["f", "i", "u"] and np.any(~np.isfinite(arr)):
-                arr = np.nan_to_num(arr, nan=fill_value, posinf=fill_value, neginf=fill_value)
-
-            # 写回变量
-            var[:] = arr
+    dtype_map = {
+        "int8": (np.int8, np.iinfo(np.int8).min, np.iinfo(np.int8).max),
+        "int16": (np.int16, np.iinfo(np.int16).min, np.iinfo(np.int16).max),
+        "int32": (np.int32, np.iinfo(np.int32).min, np.iinfo(np.int32).max),
+        "int64": (np.int64, np.iinfo(np.int64).min, np.iinfo(np.int64).max),
+    }
+    if dtype not in dtype_map:
+        raise ValueError(f"Unsupported dtype: {dtype}. Supported types are 'int8', 'int16', 'int32', and 'int64'.")
+    
+    return dtype_map[dtype]
 
 
 def _numpy_to_nc_type(numpy_type):
@@ -72,109 +45,89 @@ def _numpy_to_nc_type(numpy_type):
 
 def _calculate_scale_and_offset(data, dtype="int32"):
     """
-    只对有效数据（非NaN、非填充值、非自定义缺失值）计算scale_factor和add_offset。
-    使用 int32 类型，n=32
+    只对有效数据（非NaN、非无穷值、非自定义缺失值）计算scale_factor和add_offset。
+    为填充值保留最小值位置，有效数据范围为 [clip_min+1, clip_max]。
     """
     if not isinstance(data, np.ndarray):
         raise ValueError("Input data must be a NumPy array.")
-    
-    if dtype == "int32":
-        n = 32
-        fill_value = np.iinfo(np.int32).min  # -2147483648
-        max_packed_value = np.iinfo(np.int32).max  # 2147483647
-        min_packed_value = np.iinfo(np.int32).min + 1  # -2147483647 (保留最小值作为填充值)
-    elif dtype == "int16":
-        n = 16
-        fill_value = np.iinfo(np.int16).min  # -32768
-        max_packed_value = np.iinfo(np.int16).max  # 32767
-        min_packed_value = np.iinfo(np.int16).min + 1  # -32767 (保留最小值作为填充值)
-    else:
-        raise ValueError("Unsupported dtype. Supported types are 'int16' and 'int32'.")
 
-    # 有效掩码：非NaN、非inf、非fill_value
-    valid_mask = np.isfinite(data) & (data != fill_value)
+    np_dtype, clip_min, clip_max = _get_dtype_info(dtype)
+
+    # 创建有效数据掩码，只排除NaN和无穷值
+    valid_mask = np.isfinite(data)
     if hasattr(data, "mask") and np.ma.is_masked(data):
         valid_mask &= ~data.mask
 
-    if np.any(valid_mask):
-        data_min = np.min(data[valid_mask])
-        data_max = np.max(data[valid_mask])
-        
-        # 添加一个小的缓冲以确保所有值都在范围内，但不要过大
-        data_range = data_max - data_min
-        if data_range > 0:
-            buffer = data_range * 1e-6  # 使用相对缓冲而不是绝对值1
-            data_min -= buffer
-            data_max += buffer
-    else:
-        data_min, data_max = 0, 1
+    # 如果没有有效数据，返回默认值
+    if not np.any(valid_mask):
+        return 1.0, 0.0
+
+    # 基于有效数据计算最小值和最大值
+    data_min = np.min(data[valid_mask])
+    data_max = np.max(data[valid_mask])
 
-    # 防止scale为0，且保证scale/offset不会影响缺省值
+    # 防止 scale 为 0
     if data_max == data_min:
         scale_factor = 1.0
         add_offset = data_min
     else:
-        # 使用可用的打包值范围计算scale_factor
-        packed_range = max_packed_value - min_packed_value
-        scale_factor = (data_max - data_min) / packed_range
+        # 使用数据中心点作为offset
         add_offset = (data_max + data_min) / 2.0
+        
+        # 计算数据范围相对于中心点的最大偏移
+        max_deviation = max(abs(data_max - add_offset), abs(data_min - add_offset))
+        
+        # 可用的整数范围（为填充值保留最小值）
+        available_range = min(abs(clip_min + 1), abs(clip_max))
+        scale_factor = max_deviation / available_range
+
     return scale_factor, add_offset
 
 
-def _data_to_scale_offset(data, scale, offset, dtype='int32'):
+def _data_to_scale_offset(data, scale, offset, dtype="int32"):
     """
-    只对有效数据做缩放，NaN/inf/填充值直接赋为fill_value。
-    掩码区域的值会被保留并进行缩放，除非掩码本身标记为无效。
-    使用 int32 类型
+    将数据应用 scale 和 offset 转换，转换为整型以实现压缩。
+    NaN、inf 和掩码值将被转换为指定数据类型的最小值作为填充值。
+    
+    转换公式：scaled_value = (original_value - add_offset) / scale_factor
+    返回整型数组，用最小值表示无效数据
     """
     if not isinstance(data, np.ndarray):
         raise ValueError("Input data must be a NumPy array.")
-    
-    if dtype == "int32":
-        # n = 32
-        np_dtype = np.int32
-        fill_value = np.iinfo(np.int32).min  # -2147483648
-        clip_min = np.iinfo(np.int32).min + 1  # -2147483647
-        clip_max = np.iinfo(np.int32).max  # 2147483647
-    elif dtype == "int16":
-        # n = 16
-        np_dtype = np.int16
-        fill_value = np.iinfo(np.int16).min  # -32768
-        clip_min = np.iinfo(np.int16).min + 1  # -32767
-        clip_max = np.iinfo(np.int16).max  # 32767
-    else:
-        raise ValueError("Unsupported dtype. Supported types are 'int16' and 'int32'.")
 
-    # 创建掩码，只排除 NaN/inf 和显式的填充值
+    np_dtype, clip_min, clip_max = _get_dtype_info(dtype)
+    fill_value = clip_min  # 使用数据类型的最小值作为填充值
+    
+    # 创建输出数组，初始化为填充值
+    result = np.full(data.shape, fill_value, dtype=np_dtype)
+    
+    # 只对有限值进行转换
     valid_mask = np.isfinite(data)
-    valid_mask &= data != fill_value
-
-    # 如果数据有掩码属性，还需考虑掩码
+    
+    # 对于掩码数组，排除掩码区域
     if hasattr(data, "mask") and np.ma.is_masked(data):
-        # 只有掩码标记的区域视为无效
         valid_mask &= ~data.mask
-
-    # 初始化结果数组为填充值
-    result = np.full_like(data, fill_value, dtype=np_dtype)
     
     if np.any(valid_mask):
-        # 标准的scale/offset转换公式：packed_value = (unpacked_value - add_offset) / scale_factor
+        # 进行scale/offset转换
         scaled = (data[valid_mask] - offset) / scale
-        # 四舍五入到最近的整数
-        scaled = np.round(scaled).astype(np_dtype)
-        # clip到整数范围，保留最大范围供转换
-        scaled = np.clip(scaled, clip_min, clip_max)  # 不使用最小值，保留做 _FillValue
-        result[valid_mask] = scaled
+        # 四舍五入并转换为目标整型，同时确保在有效范围内
+        scaled_int = np.round(scaled).astype(np_dtype)
+        # 由于我们使用了最小值作为填充值，所以有效数据范围是 [clip_min+1, clip_max]
+        scaled_int = np.clip(scaled_int, clip_min + 1, clip_max)
+        result[valid_mask] = scaled_int
     
-    return result
+    return result, fill_value
 
 
-def save_to_nc(file, data, varname=None, coords=None, mode="w", convert_dtype='int32',scale_offset_switch=True, compile_switch=True, preserve_mask_values=True):
+def save_to_nc(file, data, varname=None, coords=None, mode="w", convert_dtype='int16', scale_offset_switch=True, compile_switch=True, preserve_mask_values=True, missing_value=None):
     """
     保存数据到 NetCDF 文件，支持 xarray 对象（DataArray 或 Dataset）和 numpy 数组。
 
-    仅对数据变量中数值型数据进行压缩转换（利用 scale_factor/add_offset 转换后转为 int32），
+    仅对数据变量中数值型数据进行压缩转换（利用 scale_factor/add_offset 转换后转为指定整数类型），
     非数值型数据以及所有坐标变量将禁用任何压缩，直接保存原始数据。
+    
+    简化处理：所有特殊值（missing_value、掩码、无穷值等）统一转换为NaN处理。
 
     参数：
       - file: 保存文件的路径
@@ -182,72 +135,80 @@ def save_to_nc(file, data, varname=None, coords=None, mode="w", convert_dtype='i
       - varname: 变量名（仅适用于传入 numpy 数组或 DataArray 时）
       - coords: 坐标字典（numpy 数组分支时使用），所有坐标变量均不压缩
       - mode: "w"（覆盖）或 "a"（追加）
-      - convert_dtype: 转换为的数值类型（"int16" 或 "int32"），默认为 "int32"
+      - convert_dtype: 转换为的数值类型（"int8", "int16", "int32", "int64"），默认为 "int32"
       - scale_offset_switch: 是否对数值型数据变量进行压缩转换
       - compile_switch: 是否启用 NetCDF4 的 zlib 压缩（仅针对数值型数据有效）
-      - missing_value: 自定义缺失值，将被替换为 fill_value
       - preserve_mask_values: 是否保留掩码区域的原始值（True）或将其替换为缺省值（False）
+      - missing_value: 自定义缺失值，将被替换为 NaN
     """
-    if convert_dtype not in ["int16", "int32"]:
+    if convert_dtype not in ["int8", "int16", "int32", "int64"]:
         convert_dtype = "int32"
     nc_dtype = _numpy_to_nc_type(convert_dtype)
-    # fill_value = np.iinfo(np.convert_dtype).min  # -2147483648 或 -32768
-    # fill_value = np.iinfo(eval('np.' + convert_dtype)).min  # -2147483648 或 -32768
-    np_dtype = getattr(np, convert_dtype)  # 更安全的类型获取方式
-    fill_value = np.iinfo(np_dtype).min
+
     # ----------------------------------------------------------------------------
-    # 处理 xarray 对象（DataArray 或 Dataset）的情况
+    # 处理 xarray 对象（DataArray 或 Dataset）
     if isinstance(data, (xr.DataArray, xr.Dataset)):
         encoding = {}
-
         if isinstance(data, xr.DataArray):
             if data.name is None:
                 data = data.rename("data")
             varname = data.name if varname is None else varname
             arr = np.array(data.values)
-            try:
-                data_missing_val = data.attrs.get("missing_value")
-            except AttributeError:
-                data_missing_val = data.attrs.get("_FillValue", None)
-            # 只对有效数据计算scale/offset
-            valid_mask = np.ones(arr.shape, dtype=bool)  # 默认所有值都有效
-            if arr.dtype.kind in ["f", "i", "u"]:  # 仅对数值数据应用isfinite
+            data_missing_val = data.attrs.get("missing_value", None)
+
+            valid_mask = np.ones(arr.shape, dtype=bool)
+            if arr.dtype.kind in ["f", "i", "u"]:
                 valid_mask = np.isfinite(arr)
                 if data_missing_val is not None:
                     valid_mask &= arr != data_missing_val
                 if hasattr(arr, "mask"):
-                    valid_mask &= ~getattr(arr, "mask", False)
+                    valid_mask &= ~arr.mask
+
             if np.issubdtype(arr.dtype, np.number) and scale_offset_switch:
+                # 确保有有效数据用于计算scale/offset
+                if not np.any(valid_mask):
+                    # 如果没有有效数据，不进行压缩转换
+                    for k in ["_FillValue", "missing_value"]:
+                        if k in data.attrs:
+                            del data.attrs[k]
+                    data.to_dataset(name=varname).to_netcdf(file, mode=mode)
+                    return
+
                 arr_valid = arr[valid_mask]
                 scale, offset = _calculate_scale_and_offset(arr_valid, convert_dtype)
-                # 写入前处理无效值（只在这里做！）
+
+                # 创建需要转换的数据副本，但不修改特殊值
                 arr_to_save = arr.copy()
-                # 处理自定义缺失值
+                
+                # 只处理自定义缺失值，转换为NaN（让后面统一处理）
                 if data_missing_val is not None:
-                    arr_to_save[arr == data_missing_val] = fill_value
-                # 处理 NaN/inf
-                arr_to_save[~np.isfinite(arr_to_save)] = fill_value
-                new_values = _data_to_scale_offset(arr_to_save, scale, offset)
+                    arr_to_save[arr == data_missing_val] = np.nan
+
+                # 进行压缩转换（_data_to_scale_offset会正确处理NaN和掩码）
+                new_values, fill_value = _data_to_scale_offset(arr_to_save, scale, offset, convert_dtype)
                 new_da = data.copy(data=new_values)
-                # 移除 _FillValue 和 missing_value 属性
+                
+                # 清除原有的填充值属性，设置新的压缩属性
                 for k in ["_FillValue", "missing_value"]:
                     if k in new_da.attrs:
                         del new_da.attrs[k]
+                        
                 new_da.attrs["scale_factor"] = float(scale)
                 new_da.attrs["add_offset"] = float(offset)
+                
                 encoding[varname] = {
                     "zlib": compile_switch,
                     "complevel": 4,
                     "dtype": nc_dtype,
-                    # "_FillValue": -2147483648,
+                    "_FillValue": fill_value,  # 使用计算出的填充值
                 }
                 new_da.to_dataset(name=varname).to_netcdf(file, mode=mode, encoding=encoding)
             else:
+                # 对于非数值数据或不压缩的情况，移除填充值属性防止冲突
                 for k in ["_FillValue", "missing_value"]:
                     if k in data.attrs:
                         del data.attrs[k]
                 data.to_dataset(name=varname).to_netcdf(file, mode=mode)
-            _nan_to_fillvalue(file, fill_value)
             return
 
         else:  # Dataset 情况
@@ -256,19 +217,16 @@ def save_to_nc(file, data, varname=None, coords=None, mode="w", convert_dtype='i
             for var in data.data_vars:
                 da = data[var]
                 arr = np.array(da.values)
-                try:
-                    data_missing_val = da.attrs.get("missing_value")
-                except AttributeError:
-                    data_missing_val = da.attrs.get("_FillValue", None)
-                valid_mask = np.ones(arr.shape, dtype=bool)  # 默认所有值都有效
-                if arr.dtype.kind in ["f", "i", "u"]:  # 仅对数值数据应用isfinite
+                data_missing_val = da.attrs.get("missing_value", None)
+
+                valid_mask = np.ones(arr.shape, dtype=bool)
+                if arr.dtype.kind in ["f", "i", "u"]:
                     valid_mask = np.isfinite(arr)
                     if data_missing_val is not None:
                         valid_mask &= arr != data_missing_val
                     if hasattr(arr, "mask"):
-                        valid_mask &= ~getattr(arr, "mask", False)
+                        valid_mask &= ~arr.mask
 
-                # 创建属性的副本以避免修改原始数据集
                 attrs = da.attrs.copy()
                 for k in ["_FillValue", "missing_value"]:
                     if k in attrs:
@@ -285,23 +243,21 @@ def save_to_nc(file, data, varname=None, coords=None, mode="w", convert_dtype='i
                     scale, offset = _calculate_scale_and_offset(arr_valid, convert_dtype)
                     arr_to_save = arr.copy()
 
-                    # 使用与DataArray相同的逻辑，使用_data_to_scale_offset处理数据
-                    # 处理自定义缺失值
+                    # 只处理自定义缺失值，转换为NaN（让后面统一处理）
                     if data_missing_val is not None:
-                        arr_to_save[arr == data_missing_val] = fill_value
-                    # 处理 NaN/inf
-                    arr_to_save[~np.isfinite(arr_to_save)] = fill_value
-                    new_values = _data_to_scale_offset(arr_to_save, scale, offset)
+                        arr_to_save[arr == data_missing_val] = np.nan
+                    
+                    # 进行压缩转换（_data_to_scale_offset会正确处理NaN和掩码）
+                    new_values, fill_value = _data_to_scale_offset(arr_to_save, scale, offset, convert_dtype)
                     new_da = xr.DataArray(new_values, dims=da.dims, coords=da.coords, attrs=attrs)
                     new_da.attrs["scale_factor"] = float(scale)
                     new_da.attrs["add_offset"] = float(offset)
-                    # 不设置_FillValue属性，改为使用missing_value
-                    # new_da.attrs["missing_value"] = -2147483648
                     new_vars[var] = new_da
                     encoding[var] = {
                         "zlib": compile_switch,
                         "complevel": 4,
                         "dtype": nc_dtype,
+                        "_FillValue": fill_value,  # 使用计算出的填充值
                     }
                 else:
                     new_vars[var] = xr.DataArray(arr, dims=da.dims, coords=da.coords, attrs=attrs)
@@ -309,7 +265,6 @@ def save_to_nc(file, data, varname=None, coords=None, mode="w", convert_dtype='i
             # 确保坐标变量被正确复制
             new_ds = xr.Dataset(new_vars, coords=data.coords.copy())
             new_ds.to_netcdf(file, mode=mode, encoding=encoding if encoding else None)
-        _nan_to_fillvalue(file, fill_value)
         return
 
     # 处理纯 numpy 数组情况
@@ -320,12 +275,12 @@ def save_to_nc(file, data, varname=None, coords=None, mode="w", convert_dtype='i
     data = np.asarray(data)
     is_numeric = np.issubdtype(data.dtype, np.number)
 
+    # 处理缺失值
     if hasattr(data, "mask") and np.ma.is_masked(data):
         # 处理掩码数组，获取缺失值
         data = data.data
-        missing_value = getattr(data, "missing_value", None)
-    else:
-        missing_value = None
+        if missing_value is None:
+            missing_value = getattr(data, "missing_value", None)
     
     try:
         with nc.Dataset(file, mode, format="NETCDF4") as ncfile:
@@ -353,44 +308,60 @@ def save_to_nc(file, data, varname=None, coords=None, mode="w", convert_dtype='i
 
                 # 确保有有效数据
                 if not np.any(valid_mask):
-                    # 如果没有有效数据，不进行压缩，直接保存原始数据类型
+                # 如果没有有效数据，不进行压缩，直接保存原始数据类型
                     dtype = _numpy_to_nc_type(data.dtype)
                     var = ncfile.createVariable(varname, dtype, dims, zlib=False)
-                    # 确保没有 NaN
-                    clean_data = np.nan_to_num(data, nan=missing_value if missing_value is not None else fill_value)
+                    # 确保没有 NaN，直接用0替换
+                    clean_data = np.nan_to_num(data, nan=0.0)
                     var[:] = clean_data
-                    return
-
-                # 计算 scale 和 offset 仅使用有效区域数据
+                    return                # 计算 scale 和 offset 仅使用有效区域数据
                 arr_valid = arr_to_save[valid_mask]
                 scale, offset = _calculate_scale_and_offset(arr_valid, convert_dtype)
 
-                # 执行压缩转换
-                new_data = _data_to_scale_offset(arr_to_save, scale, offset)
+                # 只处理自定义缺失值，转换为NaN
+                if missing_value is not None:
+                    arr_to_save[arr == missing_value] = np.nan
+
+                # 执行压缩转换（_data_to_scale_offset会正确处理NaN和掩码）
+                new_data, fill_value = _data_to_scale_offset(arr_to_save, scale, offset, convert_dtype)
 
                 # 创建变量并设置属性
-                var = ncfile.createVariable(varname, nc_dtype, dims, zlib=compile_switch)
+                var = ncfile.createVariable(varname, nc_dtype, dims, zlib=compile_switch, fill_value=fill_value)
                 var.scale_factor = scale
                 var.add_offset = offset
-                var._FillValue = fill_value  # 明确设置填充值
                 var[:] = new_data
             else:
+                # 非压缩情况，直接保存但要处理特殊值
                 dtype = _numpy_to_nc_type(data.dtype)
+                
+                clean_data = data.copy()
+                
+                # 处理自定义缺失值（转换为NaN）
+                if missing_value is not None:
+                    clean_data[data == missing_value] = np.nan
+                
+                # 对于整数类型，处理NaN和无穷值 - 用0替换
+                if not np.issubdtype(data.dtype, np.floating):
+                    finite_mask = np.isfinite(clean_data)
+                    if not np.all(finite_mask):
+                        clean_data = clean_data.astype(float)  # 转换为浮点型保持NaN
+                
+                # 处理掩码（统一转换为NaN）
+                if hasattr(data, "mask") and np.ma.is_masked(data):
+                    clean_data[data.mask] = np.nan
+                
+                # 创建变量
                 var = ncfile.createVariable(varname, dtype, dims, zlib=False)
-                # 确保不写入 NaN
-                if np.issubdtype(data.dtype, np.floating) and np.any(~np.isfinite(data)):
-                    fill_val = missing_value if missing_value is not None else fill_value
-                    var._FillValue = fill_val
-                    clean_data = np.nan_to_num(data, nan=fill_val)
-                    var[:] = clean_data
-                else:
-                    var[:] = data
-        # 最后确保所有 NaN 值被处理
-        _nan_to_fillvalue(file, fill_value)
+                var[:] = clean_data
+        # 只对压缩数据调用_nan_to_fillvalue，处理掩码但保持NaN
+        if is_numeric and scale_offset_switch:
+            pass  # 简化策略：不再需要后处理
     except Exception as e:
         raise RuntimeError(f"netCDF4 保存失败: {str(e)}") from e
 
 
+
+
 # 测试用例
 if __name__ == "__main__":
     # 示例文件路径，需根据实际情况修改

{oafuncs-0.0.98.42 → oafuncs-0.0.98.44}/oafuncs/_script/plot_dataset.py

@@ -197,12 +197,12 @@ def select_colormap_and_levels(data_range: Tuple[float, float], plot_type: str)
         num_levels = 128
 
     if data_range[0] * data_range[1] < 0:
-        cmap = oafuncs.oa_cmap.get("diverging_1")
+        cmap = oafuncs.oa_cmap.get(diverging_cmap)
         bdy = max(abs(data_range[0]), abs(data_range[1]))
         norm = mpl.colors.TwoSlopeNorm(vmin=-bdy, vcenter=0, vmax=bdy)
         levels = np.linspace(-bdy, bdy, num_levels)
     else:
-        cmap = oafuncs.oa_cmap.get("cool_1") if data_range[0] < 0 else oafuncs.oa_cmap.get("warm_1")
+        cmap = oafuncs.oa_cmap.get(negative_cmap) if data_range[0] < 0 else oafuncs.oa_cmap.get(positive_cmap)
         norm = mpl.colors.Normalize(vmin=data_range[0], vmax=data_range[1])
         levels = np.linspace(data_range[0], data_range[1], num_levels)
 
@@ -320,9 +320,14 @@ def get_xyzt_names(ds_in, xyzt_dims):
     return x_dim, y_dim, z_dim, t_dim
 
 
-def func_plot_dataset(ds_in: Union[xr.Dataset, xr.DataArray], output_dir: str, xyzt_dims: Tuple[str, str, str, str] = None, plot_type: str = "contourf", fixed_colorscale: bool = False) -> None:
+def func_plot_dataset(ds_in: Union[xr.Dataset, xr.DataArray], output_dir: str, cmap='diverging_3', pcmap='warm_3', ncmap='cool_3', xyzt_dims: Tuple[str, str, str, str] = None, plot_type: str = "contourf", fixed_colorscale: bool = False) -> None:
     """Plot variables from a NetCDF file and save the plots to the specified directory."""
     os.makedirs(output_dir, exist_ok=True)
+    
+    global diverging_cmap, positive_cmap, negative_cmap
+    diverging_cmap = cmap
+    positive_cmap = pcmap
+    negative_cmap = ncmap
 
     # Main processing function
     try:

{oafuncs-0.0.98.42 → oafuncs-0.0.98.44}/oafuncs/_script/replace_file_content.py

@@ -106,10 +106,10 @@ def replace_direct_content(source_file, target_dir, content_dict, key_value=Fals
         with open(target_file, "w") as f:
             f.write(content)
 
-        print(f"[green]已将内容替换到新文件：{target_file}[/green]")
+        print(f"[green]Content replaced and saved to new file: {target_file}[/green]")
         return True
     except Exception as e:
-        print(f"[red]替换内容时出错：{str(e)}[/red]")
+        print(f"[red]Error replacing content: {str(e)}[/red]")
         return False
 
 

{oafuncs-0.0.98.42 → oafuncs-0.0.98.44}/oafuncs/oa_data.py

@@ -1,11 +1,9 @@
-from typing import Any, List, Union, Literal
+from typing import Any, List, Union
 
 import numpy as np
-import xarray as xr
-from rich import print
 
 
-__all__ = ["interp_along_dim", "interp_2d", "ensure_list", "mask_shapefile", "mask_land_ocean"]
+__all__ = ["interp_along_dim", "interp_2d", "ensure_list"]
 
 
 def ensure_list(input_value: Any) -> List[str]:
@@ -146,125 +144,6 @@ def interp_2d(
     )
 
 
-def mask_shapefile(
-    data_array: np.ndarray,
-    longitudes: np.ndarray,
-    latitudes: np.ndarray,
-    shapefile_path: str,
-) -> Union[xr.DataArray, None]:
-    """
-    Mask a 2D data array using a shapefile.
-
-    Args:
-        data_array (np.ndarray): 2D array of data to be masked.
-        longitudes (np.ndarray): 1D array of longitudes.
-        latitudes (np.ndarray): 1D array of latitudes.
-        shapefile_path (str): Path to the shapefile used for masking.
-
-    Returns:
-        Union[xr.DataArray, None]: Masked xarray DataArray or None if an error occurs.
-
-    Raises:
-        FileNotFoundError: If the shapefile does not exist.
-        ValueError: If the data dimensions do not match the coordinates.
-
-    Examples:
-        >>> data_array = np.random.rand(10, 10)
-        >>> longitudes = np.linspace(-180, 180, 10)
-        >>> latitudes = np.linspace(-90, 90, 10)
-        >>> shapefile_path = "path/to/shapefile.shp"
-        >>> masked_data = mask_shapefile(data_array, longitudes, latitudes, shapefile_path)
-        >>> print(masked_data)  # Expected output: Masked DataArray
-
-    """
-    import salem
-    try:
-        shp_f = salem.read_shapefile(shapefile_path)
-        data_da = xr.DataArray(data_array, coords=[("latitude", latitudes), ("longitude", longitudes)])
-        masked_data = data_da.salem.roi(shape=shp_f)
-        return masked_data
-    except Exception as e:
-        print(f"[red]An error occurred: {e}[/red]")
-        return None
-
-
-
-def _normalize_lon(lon: np.ndarray) -> np.ndarray:
-    """将经度转换到 [-180, 180)。"""
-    lon = np.asarray(lon, dtype=float)
-    return np.where(lon >= 180, lon - 360, lon)
-
-
-def _land_sea_mask(
-    lon: np.ndarray,
-    lat: np.ndarray,
-    keep: Literal["land", "ocean"],
-) -> np.ndarray:
-    """
-    根据 1-D 或 2-D 经纬度返回布尔掩膜。
-    True 表示该位置 *保留*，False 表示该位置将被掩掉。
-    """
-    from global_land_mask import globe
-    
-    lon = _normalize_lon(lon)
-    lat = np.asarray(lat, dtype=float)
-
-    # 如果输入是 1-D，则网格化；2-D 则直接使用
-    if lon.ndim == 1 and lat.ndim == 1:
-        lon_2d, lat_2d = np.meshgrid(lon, lat)
-    elif lon.ndim == 2 and lat.ndim == 2:
-        lon_2d, lat_2d = lon, lat
-    else:
-        raise ValueError("经纬度必须是同维度的 1-D 或 2-D 数组")
-
-    is_ocean = globe.is_ocean(lat_2d, lon_2d)
-
-    if keep == "land":
-        mask = ~is_ocean
-    elif keep == "ocean":
-        mask = is_ocean
-    else:
-        raise ValueError("keep 只能是 'land' 或 'ocean'")
-
-    return mask
-
-
-def mask_land_ocean(
-    data: xr.DataArray | xr.Dataset,
-    lon: np.ndarray,
-    lat: np.ndarray,
-    *,  # 强制关键字参数
-    keep: Literal["land", "ocean"] = "land",
-) -> xr.DataArray | xr.Dataset:
-    """
-    根据海陆分布掩膜 xarray 对象。
-
-    Parameters
-    ----------
-    data : xr.DataArray 或 xr.Dataset
-        至少包含 'lat' 和 'lon' 维度/坐标的数组。
-    lon : array_like
-        经度，可以是 1-D 或 2-D。
-    lat : array_like
-        纬度，可以是 1-D 或 2-D。
-    keep : {'land', 'ocean'}, optional
-        指定要保留的部分，默认为 'land'。
-
-    Returns
-    -------
-    掩膜后的 xr.DataArray / xr.Dataset
-    """
-    mask = _land_sea_mask(lon, lat, keep)
-
-    # 用 apply_ufunc 自动对齐并广播掩膜
-    return xr.apply_ufunc(
-        lambda x, m: x.where(m),
-        data,
-        xr.DataArray(mask, dims=("lat", "lon")),
-        dask="parallelized",
-        keep_attrs=True,
-    )
-
 
 if __name__ == "__main__":
     pass

{oafuncs-0.0.98.42 → oafuncs-0.0.98.44}/oafuncs/oa_file.py

@@ -418,6 +418,9 @@ def replace_content(source_file: Union[str, os.PathLike], replacements: Dict[str
 
     if target_dir is None:
         target_dir = os.path.dirname(source_file)
+        # If source_file is just a filename without path, use current working directory
+        if not target_dir:
+            target_dir = os.getcwd()
     replace_direct_content(source_file, target_dir, replacements, key_value=use_key_value, new_name=new_filename)
 
 

oafuncs-0.0.98.44/oafuncs/oa_geo.py

@@ -0,0 +1,148 @@
+from typing import Union, Literal
+
+import numpy as np
+import xarray as xr
+from rich import print
+
+
+__all__ = ["earth_distance", "mask_shapefile", "mask_land_ocean"]
+
+
+def earth_distance(lon1, lat1, lon2, lat2):
+    """
+    计算两点间的距离（km）
+    """
+    from math import asin, cos, radians, sin, sqrt
+    # 将经纬度转换为弧度
+    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])
+
+    # haversine公式
+    dlon = lon2 - lon1
+    dlat = lat2 - lat1
+    a = sin(dlat / 2) ** 2 + cos(lat1) * cos(lat2) * sin(dlon / 2) ** 2
+    c = 2 * asin(sqrt(a))
+    r = 6371  # 地球半径（公里）
+    return c * r
+
+
+def mask_shapefile(
+    data_array: np.ndarray,
+    longitudes: np.ndarray,
+    latitudes: np.ndarray,
+    shapefile_path: str,
+) -> Union[xr.DataArray, None]:
+    """
+    Mask a 2D data array using a shapefile.
+
+    Args:
+        data_array (np.ndarray): 2D array of data to be masked.
+        longitudes (np.ndarray): 1D array of longitudes.
+        latitudes (np.ndarray): 1D array of latitudes.
+        shapefile_path (str): Path to the shapefile used for masking.
+
+    Returns:
+        Union[xr.DataArray, None]: Masked xarray DataArray or None if an error occurs.
+
+    Raises:
+        FileNotFoundError: If the shapefile does not exist.
+        ValueError: If the data dimensions do not match the coordinates.
+
+    Examples:
+        >>> data_array = np.random.rand(10, 10)
+        >>> longitudes = np.linspace(-180, 180, 10)
+        >>> latitudes = np.linspace(-90, 90, 10)
+        >>> shapefile_path = "path/to/shapefile.shp"
+        >>> masked_data = mask_shapefile(data_array, longitudes, latitudes, shapefile_path)
+        >>> print(masked_data)  # Expected output: Masked DataArray
+
+    """
+    import salem
+    try:
+        shp_f = salem.read_shapefile(shapefile_path)
+        data_da = xr.DataArray(data_array, coords=[("latitude", latitudes), ("longitude", longitudes)])
+        masked_data = data_da.salem.roi(shape=shp_f)
+        return masked_data
+    except Exception as e:
+        print(f"[red]An error occurred: {e}[/red]")
+        return None
+
+
+
+def _normalize_lon(lon: np.ndarray) -> np.ndarray:
+    """将经度转换到 [-180, 180)。"""
+    lon = np.asarray(lon, dtype=float)
+    return np.where(lon >= 180, lon - 360, lon)
+
+
+def _land_sea_mask(
+    lon: np.ndarray,
+    lat: np.ndarray,
+    keep: Literal["land", "ocean"],
+) -> np.ndarray:
+    """
+    根据 1-D 或 2-D 经纬度返回布尔掩膜。
+    True 表示该位置 *保留*，False 表示该位置将被掩掉。
+    """
+    from global_land_mask import globe
+    
+    lon = _normalize_lon(lon)
+    lat = np.asarray(lat, dtype=float)
+
+    # 如果输入是 1-D，则网格化；2-D 则直接使用
+    if lon.ndim == 1 and lat.ndim == 1:
+        lon_2d, lat_2d = np.meshgrid(lon, lat)
+    elif lon.ndim == 2 and lat.ndim == 2:
+        lon_2d, lat_2d = lon, lat
+    else:
+        raise ValueError("经纬度必须是同维度的 1-D 或 2-D 数组")
+
+    is_ocean = globe.is_ocean(lat_2d, lon_2d)
+
+    if keep == "land":
+        mask = ~is_ocean
+    elif keep == "ocean":
+        mask = is_ocean
+    else:
+        raise ValueError("keep 只能是 'land' 或 'ocean'")
+
+    return mask
+
+
+def mask_land_ocean(
+    data: xr.DataArray | xr.Dataset,
+    lon: np.ndarray,
+    lat: np.ndarray,
+    *,  # 强制关键字参数
+    keep: Literal["land", "ocean"] = "land",
+) -> xr.DataArray | xr.Dataset:
+    """
+    根据海陆分布掩膜 xarray 对象。
+
+    Parameters
+    ----------
+    data : xr.DataArray 或 xr.Dataset
+        至少包含 'lat' 和 'lon' 维度/坐标的数组。
+    lon : array_like
+        经度，可以是 1-D 或 2-D。
+    lat : array_like
+        纬度，可以是 1-D 或 2-D。
+    keep : {'land', 'ocean'}, optional
+        指定要保留的部分，默认为 'land'。
+
+    Returns
+    -------
+    掩膜后的 xr.DataArray / xr.Dataset
+    """
+    mask = _land_sea_mask(lon, lat, keep)
+
+    # 用 apply_ufunc 自动对齐并广播掩膜
+    return xr.apply_ufunc(
+        lambda x, m: x.where(m),
+        data,
+        xr.DataArray(mask, dims=("lat", "lon")),
+        dask="parallelized",
+        keep_attrs=True,
+    )
+
+if __name__ == "__main__":
+    pass

{oafuncs-0.0.98.42 → oafuncs-0.0.98.44}/oafuncs/oa_nc.py

@@ -15,10 +15,11 @@ def save(
     variable_name: Optional[str] = None,
     coordinates: Optional[dict] = None,
     write_mode: str = "w",
-    convert_dtype: str = "int32",
+    convert_dtype: str = "int16",
     use_scale_offset: bool = True,
     use_compression: bool = True,
     preserve_mask_values: bool = True,
+    missing_value: Optional[Union[float, int]] = None,
 ) -> None:
     """
     Write data to a NetCDF file.
@@ -42,7 +43,7 @@ def save(
     """
     from ._script.netcdf_write import save_to_nc
 
-    save_to_nc(file_path, data, variable_name, coordinates, write_mode, convert_dtype,use_scale_offset, use_compression, preserve_mask_values)
+    save_to_nc(file_path, data, variable_name, coordinates, write_mode, convert_dtype,use_scale_offset, use_compression, preserve_mask_values, missing_value)
     print(f"[green]Data successfully saved to {file_path}[/green]")
 
 
@@ -270,6 +271,9 @@ def draw(
     output_directory: Optional[str] = None,
     dataset: Optional[xr.Dataset] = None,
     file_path: Optional[str] = None,
+    cmap='diverging_3',
+    pcmap='warm_3',
+    ncmap='cool_3',
     dims_xyzt: Union[List[str], Tuple[str, str, str, str]] = None,
     plot_style: str = "contourf",
     use_fixed_colorscale: bool = False,
@@ -296,18 +300,18 @@ def draw(
         raise ValueError("dimensions must be a list or tuple")
 
     if dataset is not None:
-        func_plot_dataset(dataset, output_directory, dims_xyzt, plot_style, use_fixed_colorscale)
+        func_plot_dataset(dataset, output_directory, cmap, pcmap, ncmap, dims_xyzt, plot_style, use_fixed_colorscale)
     elif file_path is not None:
         if check(file_path):
             ds = xr.open_dataset(file_path)
-            func_plot_dataset(ds, output_directory, dims_xyzt, plot_style, use_fixed_colorscale)
+            func_plot_dataset(ds, output_directory, cmap, pcmap, ncmap, dims_xyzt, plot_style, use_fixed_colorscale)
         else:
             print(f"[red]Invalid file: {file_path}[/red]")
     else:
         print("[red]No dataset or file provided.[/red]")
 
 
-def compress(src_path, dst_path=None,convert_dtype='int16'):
+def compress(src_path, dst_path=None, convert_dtype='int16'):
     """
     压缩 NetCDF 文件，使用 scale_factor/add_offset 压缩数据。
     若 dst_path 省略，则自动生成新文件名，写出后删除原文件并将新文件改回原名。

{oafuncs-0.0.98.42 → oafuncs-0.0.98.44/oafuncs.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oafuncs
-Version: 0.0.98.42
+Version: 0.0.98.44
 Summary: Oceanic and Atmospheric Functions
 Home-page: https://github.com/Industry-Pays/OAFuncs
 Author: Kun Liu
@@ -65,8 +65,6 @@ Just for the convenience of daily use, some complex operations are integrated in
 The code will be optimized and updated from time to time, with additions, deletions, or modifications…
 
 Existing functions will not be completely removed, they might just have a different function name, or the parameter passing might have been optimized…
-
-Note: If there are any requirements, you can email to liukun0312@stu.ouc.edu.cn. Within my capabilities, I can consider implementing them.
 ```
 
 ## PyPI
@@ -81,6 +79,11 @@ https://pypi.org/project/oafuncs
 https://github.com/Industry-Pays/OAFuncs
 ```
 
+## Download information
+```html
+https://pypistats.org/packages/oafuncs
+```
+
 ## Example
 
 ```python
@@ -182,3 +185,6 @@ query()
 <img title="" src="./oafuncs/data_store/OAFuncs.png" alt="">
 
 <img title="OAFuncs" src="https://raw.githubusercontent.com/Industry-Pays/OAFuncs/main/oafuncs/_data/oafuncs.png" alt="OAFuncs">
+
+## Wiki
+更多内容，查看[wiki](https://opendeep.wiki/Industry-Pays/OAFuncs/introduction)

{oafuncs-0.0.98.42 → oafuncs-0.0.98.44}/oafuncs.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ oafuncs/oa_data.py
 oafuncs/oa_date.py
 oafuncs/oa_draw.py
 oafuncs/oa_file.py
+oafuncs/oa_geo.py
 oafuncs/oa_help.py
 oafuncs/oa_nc.py
 oafuncs/oa_python.py

{oafuncs-0.0.98.42 → oafuncs-0.0.98.44}/setup.py

@@ -18,7 +18,7 @@ URL = "https://github.com/Industry-Pays/OAFuncs"
 EMAIL = "liukun0312@stu.ouc.edu.cn"
 AUTHOR = "Kun Liu"
 REQUIRES_PYTHON = ">=3.10.0"  # 2025/03/13
-VERSION = "0.0.98.42"
+VERSION = "0.0.98.44"
 
 # What packages are required for this module to be executed?
 REQUIRED = [