jacksung-dev 0.0.4.15__py3-none-any.whl

jacksung/ai/utils/metsat.py

@@ -0,0 +1,164 @@
+import traceback
+
+from satpy import Scene
+from pyresample import create_area_def
+import numpy as np
+import os
+from datetime import timedelta
+from jacksung.utils.data_convert import np2tif, Coordinate
+from contextlib import contextmanager
+
+
+@contextmanager
+def satpy_scene_context(filenames, reader):
+    """satpy Scene上下文管理器"""
+    scn = None
+    try:
+        scn = Scene(filenames=filenames, reader=reader)
+        yield scn
+    finally:
+        # 显式清理satpy资源
+        if scn is not None:
+            try:
+                # 尝试调用satpy的清理方法
+                if hasattr(scn, 'close'):
+                    scn.close()
+                # 手动删除引用
+                del scn
+            except Exception as e:
+                print(f"清理satpy资源时警告: {e}")
+
+
+def _define_wgs84_area(resolution=0.05, area_extent=(-14.5, -60, 105.5, 60.0)):
+    """定义WGS84坐标系目标区域（60°N-60°S，全经度），保持您原有的区域定义"""
+
+    wgs84_proj = "+proj=longlat +datum=WGS84 +ellps=WGS84 +no_defs"  # 旧版projection参数（PROJ4字符串）
+    target_area = create_area_def(
+        area_id="wgs84_60n60s",
+        projection=wgs84_proj,  # 旧版参数：projection（PROJ4字符串）
+        area_extent=area_extent,  # 保持您原有的区域范围
+        resolution=resolution,
+        description=f"WGS84 Lat/Lon, 60N-60S, {resolution}deg resolution"
+    )
+    return target_area
+
+
+def _extract_time_from_filename(filename):
+    """从MSG文件名中提取时间戳（格式：20251126062741 → 2025-11-26_06-27-41）"""
+    try:
+        # MSG文件名格式示例：MSG2-SEVI-MSG15-0100-NA-20251126062741.272000000Z-NA.nat
+        time_part = filename.split("-")[5].split(".")[0]  # 提取"20251126062741"
+        formatted_time = f"{time_part[:4]}-{time_part[4:6]}-{time_part[6:8]}_{time_part[8:10]}-{time_part[10:12]}-{time_part[12:14]}"
+        return formatted_time
+    except IndexError:
+        print("警告：无法从文件名提取时间戳，使用默认时间格式")
+        return "unknown_time"
+
+
+def _process_msg_seviri_to_numpy(nat_file_path, resolution=0.05, resampler="nearest", channels=("WV_062",), lock=None,
+                                 only_ld=False):
+    try:
+        if lock is not None:
+            lock.acquire()
+        # ========== 主要改动开始 ==========
+        # 使用上下文管理器确保Scene资源被释放（替换原来的Scene创建）
+        with satpy_scene_context(filenames=[nat_file_path], reader="seviri_l1b_native") as scn:
+            scn.load(channels)
+            ld = scn[channels[0]].attrs['orbital_parameters']['projection_longitude']
+            if only_ld:
+                return ld
+            area_extent = (ld - 60, -60, ld + 60, 60.0)
+            target_area = _define_wgs84_area(resolution=resolution, area_extent=area_extent)
+            scn_wgs84 = scn.resample(target_area, resampler=resampler)
+            time_str = _extract_time_from_filename(os.path.basename(nat_file_path))
+            result = {
+                'data': {},
+                'metadata': {},
+                'coordinates': {},
+                'global_attrs': {
+                    'source_file': os.path.basename(nat_file_path),
+                    'processing_time': time_str,
+                    'resolution_degrees': resolution,
+                    'resampling_method': resampler,
+                    'area_extent': area_extent
+                }
+            }
+            # 提取每个通道的数据
+            for ch in channels:
+                try:
+                    data_array = scn_wgs84[ch].values
+                    result['data'][ch] = data_array
+                    result['metadata'][ch] = dict(scn_wgs84[ch].attrs)
+                except Exception as e:
+                    print(f"提取{ch}通道数据失败：{str(e)}")
+            # 提取坐标信息
+            if channels:
+                first_ch = channels[0]
+                try:
+                    area = scn_wgs84[first_ch].attrs['area']
+                    lons, lats = area.get_lonlats()
+                    result['coordinates']['longitude'] = lons
+                    result['coordinates']['latitude'] = lats
+                    result['coordinates']['shape'] = lons.shape
+                except Exception as e:
+                    print(f"提取坐标信息失败：{str(e)}")
+            return result
+    except Exception as e:
+        print(f"处理失败：{str(e)}")
+        traceback.print_exc()
+        return None
+    finally:
+        if lock is not None:
+            lock.release()
+
+
+def getNPfromNAT(file_path, save_file=False, lock=None, return_coord=False, only_coord=False):
+    all_target_channels = ["WV_062", "WV_073", "IR_087", "IR_097", "IR_108", "IR_120", "IR_134"]
+    # all_target_channels = ["VIS006", "VIS008"]
+    if only_coord:
+        ld = _process_msg_seviri_to_numpy(nat_file_path=file_path, resolution=0.05, resampler="nearest",
+                                          channels=all_target_channels, lock=lock, only_ld=True)
+        return Coordinate(left=ld - 60, bottom=-60, right=ld + 60, top=60, x_res=0.05, y_res=0.05)
+    else:
+        result = _process_msg_seviri_to_numpy(nat_file_path=file_path, resolution=0.05, resampler="nearest",
+                                              channels=all_target_channels, lock=lock, only_ld=False)
+    np_data = None
+    coord = None
+    if result is not None:
+        for idx, channel in enumerate(all_target_channels):
+            if channel in result['data']:
+                chann_data = result['data'][channel].copy()
+                if np_data is None:
+                    np_data = np.zeros((len(all_target_channels),) + chann_data.shape, dtype=chann_data.dtype)
+                    area_extent = result['global_attrs']['area_extent']
+                    coord = Coordinate(left=area_extent[0], bottom=area_extent[1], right=area_extent[2],
+                                       top=area_extent[3], x_res=0.05, y_res=0.05)
+                np_data[idx] = chann_data
+            else:
+                del result
+                raise Exception(f"文件{file_path}，通道 {channel} 数据未找到")
+    else:
+        raise Exception(f"文件{file_path}处理失败，未获取数据")
+    if save_file:
+        np2tif(np_data, save_path='np2tif_dir', coord=coord, out_name='MetSat',
+               dtype='float32')
+    if return_coord:
+        return np_data, coord
+    else:
+        return np_data
+
+
+def get_seviri_file_path(data_path, data_date):
+    e_date = data_date + timedelta(minutes=14, seconds=59)
+    parent_dir = rf'{data_path}/{data_date.year}/{data_date.month}/{data_date.day}/'
+    start_date_str = data_date.strftime('%Y%m%d%H%M%S')
+    end_date_str = e_date.strftime('%Y%m%d%H%M%S')
+    for file in os.listdir(parent_dir):
+        if file.endswith('.nat') and start_date_str <= file.split('-')[5].split('.')[0] <= end_date_str:
+            return os.path.join(parent_dir, file)
+    return None
+
+
+if __name__ == '__main__':
+    np_data = getNPfromNAT("MSG4-SEVI-MSG15-0100-NA-20221230031243.610000000Z-NA.nat", save_file=False)
+    print()

jacksung/ai/utils/norm_util.py

@@ -0,0 +1,109 @@
+import os.path
+
+import torch
+import numpy as np
+from einops import rearrange
+
+
+class PredNormalization:
+    def __init__(self, data_path):
+        self.mean = np.load(os.path.join(data_path, 'mean_level.npy')).astype(np.float32)[2:]
+        self.std = np.load(os.path.join(data_path, 'std_level.npy')).astype(np.float32)[2:]
+        self.mean = torch.from_numpy(self.mean)
+        self.std = torch.from_numpy(self.std)
+
+    def norm(self, data):
+        data = rearrange(data, 'b c h w->b h w c')
+        data = (data - self.mean) / self.std
+        return rearrange(data, 'b h w c->b c h w')
+
+    def denorm(self, data):
+        data = rearrange(data, 'b c h w->b h w c')
+        data = data * self.std + self.mean
+        return rearrange(data, 'b h w c->b c h w')
+
+
+class PrecNormalization:
+    def __init__(self, data_path):
+        self.mean_qpe = torch.from_numpy(
+            np.load(os.path.join(data_path, 'mean_level_qpe.npy')).astype(np.float32))
+        self.std_qpe = torch.from_numpy(
+            np.load(os.path.join(data_path, 'std_level_qpe.npy')).astype(np.float32))
+        self.mean_fy = torch.from_numpy(
+            np.load(os.path.join(data_path, 'mean_level_fy.npy')).astype(np.float32).mean(axis=0)[2:])
+        self.std_fy = torch.from_numpy(
+            np.load(os.path.join(data_path, 'std_level_fy.npy')).astype(np.float32).mean(axis=0)[2:])
+
+    def norm(self, data, norm_type='fy'):
+        if norm_type == 'fy':
+            data = rearrange(data, 'b t c h w->b h w t c')
+            data = (data - self.mean_fy) / self.std_fy
+            return rearrange(data, 'b h w t c->b t c h w')
+        elif norm_type == 'qpe':
+            data = rearrange(data, 'b c h w->b h w c')
+            data = (data - self.mean_qpe) / self.std_qpe
+            return rearrange(data, 'b h w c->b c h w')
+
+    def denorm(self, data, norm_type='fy'):
+        if norm_type == 'fy':
+            data = rearrange(data, 'b t c h w->b h w t c')
+            data = data * self.std_fy + self.mean_fy
+            return rearrange(data, 'b h w t c->b t c h w')
+        elif norm_type == 'qpe':
+            data = rearrange(data, 'b c h w->b h w c')
+            data = data * self.std_qpe + self.mean_qpe
+            return rearrange(data, 'b h w c->b c h w')
+
+
+class PremNormalization:
+
+    def __init__(self, prec_data_path):
+        self.mean = torch.from_numpy(
+            np.load(os.path.join(prec_data_path, 'imerg_mean.npy')).astype(np.float32))
+        self.std = torch.from_numpy(
+            np.load(os.path.join(prec_data_path, 'imerg_std.npy')).astype(np.float32))
+        # self.mean = torch.Tensor(
+        #     [3.6614e+03, 3.3748e+03, 3.3829e+03, 2.8368e+03, 2.5664e+03, 2.4914e+03, 2.4259e+03, 0.5723, 0, 0])
+        # self.std = torch.Tensor([164.7376, 265.8857, 252.9820, 509.8994, 532.4901, 518.8191, 414.1427, 0.6308, 1, 1])
+        # print(self.mean, self.std)
+
+    def norm(self, data, fy_norm=True):
+        data = rearrange(data, 'b c h w->b h w c')
+        if fy_norm:
+            data = (data - self.mean[:7]) / self.std[:7]
+        else:
+            # data[:, 0][data[:, 0] == 0] = torch.inf
+            # data[:, 0] = 1 / torch.sqrt(data[:, 0].clone())
+            data = (data - self.mean[7:]) / self.std[7:]
+        return rearrange(data, 'b h w c->b c h w')
+
+    def denorm(self, data, fy_norm=True):
+        data = rearrange(data, 'b c h w->b h w c')
+        if fy_norm:
+            data = data * self.std[:7] + self.mean[:7]
+        else:
+            data = data * self.std[7:] + self.mean[7:]
+            # data[:, 0][data[:, 0] == 0] = torch.inf
+            # data[:, 0] = 1 / (data[:, 0].clone() ** 2)
+        return rearrange(data, 'b h w c->b c h w')
+
+
+class Normalization:
+    def __init__(self, mean_std_npy, idx=None):
+        mean_std = torch.from_numpy(mean_std_npy.astype(np.float32))
+        if idx:
+            self.mean = mean_std[0, idx[0]:idx[1]]
+            self.std = mean_std[1, idx[0]:idx[1]]
+        else:
+            self.mean = mean_std[0]
+            self.std = mean_std[1]
+
+    def norm(self, data):
+        data = rearrange(data, 'b c h w->b h w c')
+        data = (data - self.mean) / self.std
+        return rearrange(data, 'b h w c->b c h w')
+
+    def denorm(self, data):
+        data = rearrange(data, 'b c h w->b h w c')
+        data = data * self.std + self.mean
+        return rearrange(data, 'b h w c->b c h w')

jacksung/ai/utils/util.py

@@ -0,0 +1,300 @@
+import torch
+import torch.nn as nn
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+from jacksung.utils.image import crop_png, zoom_image, zoomAndDock
+import rasterio
+from cartopy.mpl.ticker import LongitudeFormatter, LatitudeFormatter
+from matplotlib.colors import LinearSegmentedColormap
+import cartopy.feature as cfeature
+import cartopy.crs as ccrs
+import yaml
+import argparse
+from datetime import datetime, timedelta
+from matplotlib.ticker import MaxNLocator
+import random
+
+
+def load_model(model, state_dict, strict=True):
+    own_state = model.state_dict()
+    for name, param in state_dict.items():
+        name = name[name.index('.') + 1:]
+        if name in own_state.keys():
+            if isinstance(param, nn.Parameter):
+                param = param.data
+            try:
+                own_state[name].copy_(param)
+                # own_state[name].requires_grad = False
+            except Exception as e:
+                err_log = f'While copying the parameter named {name}, ' \
+                          f'whose dimensions in the model are {own_state[name].size()} and ' \
+                          f'whose dimensions in the checkpoint are {param.size()}.'
+                if not strict:
+                    print(err_log)
+                else:
+                    raise Exception(err_log)
+        elif strict:
+            raise KeyError(f'unexpected key {name} in {own_state.keys()}')
+        else:
+            print(f'{name} not loaded by model')
+
+
+def get_stat_dict(metrics, extra_info=None):
+    if extra_info is None:
+        extra_info = dict()
+    stat_dict = {'epochs': 0, 'loss': [], 'metrics': {}}
+    for idx, metrics in enumerate(metrics):
+        name, default_value, op = metrics
+        stat_dict['metrics'][name] = {'value': [], 'best': {'value': default_value, 'epoch': 0, 'op': op}}
+    for key, value in extra_info.items():
+        stat_dict[key] = value
+    return stat_dict
+
+
+def data_to_device(datas, device, fp=32):
+    outs = []
+    for data in datas:
+        if fp == 16:
+            data = data.type(torch.HalfTensor)
+        if fp == 64:
+            data = data.type(torch.DoubleTensor)
+        if fp == 32:
+            data = data.type(torch.FloatTensor)
+        data = data.to(device)
+        outs.append(data)
+    return outs
+
+
+def draw_lines(stat_dict_path):
+    os.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'
+    print('[TemporaryTag]Producing the LinePicture of Log...', end='[TemporaryTag]\n')
+    yaml_args = yaml.load(open(stat_dict_path), Loader=yaml.FullLoader)
+    # 创建图表
+    m_len = len(yaml_args['metrics'])
+    sub_loss_count = 0
+    for i in range(0, 5):
+        if f'loss{i}es' in yaml_args:
+            sub_loss_count += 1
+        else:
+            break
+    plt.figure(figsize=(8 * (m_len + sub_loss_count), 6))  # 设置图表的大小
+    x = np.array(range(1, yaml_args['epochs'] + 1))
+    for idx, d in enumerate(yaml_args['metrics'].items()):
+        m_name, m_value = d
+        y = np.array(m_value['value'])
+        # 生成数据
+        plt.subplot(1, m_len + sub_loss_count, idx + 1)
+        plt.plot(x, y)
+        plt.title(m_name)
+        plt.gca().xaxis.set_major_locator(MaxNLocator(integer=True))
+    for i in range(0, sub_loss_count):
+        y = np.array(yaml_args[f'loss{i}es'])
+        plt.subplot(1, m_len + sub_loss_count, m_len + i + 1)
+        scale = len(y) / yaml_args['epochs']
+        # 把X坐标的纯统计范围缩放到和其他图表一致(epoch)
+        x = np.array(range(1, len(y) + 1)) / scale
+        plt.plot(x, y)
+        plt.title(f'Loss{i}')
+        plt.gca().xaxis.set_major_locator(MaxNLocator(integer=True))
+    # 添加图例
+    # plt.legend()
+    plt.savefig(os.path.join(os.path.dirname(stat_dict_path), 'Metrics.jpg'))
+
+
+def make_best_metric(stat_dict, metrics, epoch, save_model_param, server_log_param):
+    save_model_flag = False
+    experiment_model_path, model, optimizer, scheduler = save_model_param
+    log, epochs, cloudLogName = server_log_param
+
+    for name, m_value in metrics:
+        stat_dict['metrics'][name]['value'].append(m_value)
+        inf = float('inf')
+        if eval(str(m_value) + stat_dict['metrics'][name]['best']['op'] + str(
+                stat_dict['metrics'][name]['best']['value'])):
+            stat_dict['metrics'][name]['best']['value'] = m_value
+            stat_dict['metrics'][name]['best']['epoch'] = epoch
+            log.send_log('{}:{} epoch:{}/{}'.format(name, m_value, epoch, epochs), cloudLogName)
+            save_model_flag = True
+
+    if save_model_flag:
+        # sava best model
+        save_model(os.path.join(experiment_model_path, 'model_{}.pt'.format(epoch)), epoch,
+                   model, optimizer, scheduler, stat_dict)
+    # '[Validation] nRMSE/RMSE: {:.4f}/{:.4f} (Best: {:.4f}/{:.4f}, Epoch: {}/{})\n'
+    test_log = f'[Val epoch:{epoch}] ' \
+               + ' '.join([str(m[0]) + ':' + str(round(m[1], 4)) + '('
+                           + str(round(stat_dict['metrics'][m[0]]['best']['value'], 4)) + ')' for m in metrics]) \
+               + ' (Best Epoch: ' \
+               + '/'.join([str(stat_dict['metrics'][m[0]]['best']['epoch']) for m in metrics]) \
+               + ')'
+    save_model(os.path.join(experiment_model_path, 'model_latest.pt'), epoch, model, optimizer, scheduler, stat_dict)
+    return test_log
+
+
+def save_model(_path, _epoch, _model, _optimizer, _scheduler, _stat_dict):
+    # torch.save(model.state_dict(), saved_model_path)
+    torch.save({
+        'epoch': _epoch,
+        'model_state_dict': _model.state_dict(),
+        'optimizer_state_dict': _optimizer.state_dict(),
+        'scheduler_state_dict': _scheduler.state_dict(),
+        'stat_dict': _stat_dict
+    }, _path)
+
+
+def parse_config(config=None, set_gpu=True):
+    parser = argparse.ArgumentParser(description='config')
+    parser.add_argument('--config', type=str, default=None, help='pre-config file for training')
+    parser.add_argument('--prec_data_path', type=str, default=None, help='dataset path')
+    args = parser.parse_args()
+    if args.config:
+        opt = vars(args)
+        yaml_args = yaml.load(open(args.config), Loader=yaml.FullLoader)
+        opt.update(yaml_args)
+    else:
+        opt = vars(args)
+        yaml_args = yaml.load(open(config), Loader=yaml.FullLoader)
+        opt.update(yaml_args)
+
+    if set_gpu:
+        # set visible gpu
+        os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
+        os.environ['CUDA_VISIBLE_DEVICES'] = ','.join([str(x) for x in args.gpu_ids])
+
+        # select active gpu devices
+        if args.gpu_ids is not None and torch.cuda.is_available():
+            print('use cuda & cudnn for acceleration!')
+            print('the gpu id is: {}'.format(args.gpu_ids))
+            device = torch.device('cuda')
+            # device = torch.device('cuda:' + str(args.gpu_ids[0]))
+        else:
+            print('use cpu for training!')
+            device = torch.device('cpu')
+        return device, args
+    else:
+        return args
+
+
+def _get_color_normalization(data, colors):
+    max_value = colors[-1][0]
+    min_value = colors[0][0]
+    data[data < min_value] = min_value
+    data[data > max_value] = max_value
+    data = (data - min_value) / (max_value - min_value)
+    new_colors = []
+    for color in colors:
+        new_colors.append([(color[0] - min_value) / (max_value - min_value), color[1]])
+    return data, new_colors
+
+
+def data_augmentation(images):
+    # 旋转
+    rotate = random.random()
+    if 0 <= rotate < 0.25:
+        images = [torch.rot90(image, 1, [2, 3]) for image in images]
+    elif 0.25 <= rotate < 0.5:
+        images = [torch.rot90(image, 2, [2, 3]) for image in images]
+    elif 0.5 <= rotate < 0.75:
+        images = [torch.rot90(image, 3, [2, 3]) for image in images]
+    # 水平翻折
+    if random.random() > 0.5:
+        images = [torch.flip(image, [2]) for image in images]
+    # 垂直翻折
+    if random.random() > 0.5:
+        images = [torch.flip(image, [3]) for image in images]
+    return images
+
+
+def make_fig(file_name, root_path, out_folder=None, tz='UTC',
+             colors=((0, '#1E90FF'), (0.1, '#1874CD'), (0.2, '#3A5FCD'), (0.3, '#0000CD'), (1, '#9400D3')),
+             area=((100, 140, 10), (20, 60, 10)), font_size=20, corp=(0, 0, None, None),
+             zoom_rectangle=(310 * 5, 300 * 5, 50 * 5, 40 * 5), docker=(300, 730), dpi=500, filter=0.3, exposure=None):
+    # corp = [92, 31, 542, 456]
+    print('过期的make_figure方法！')
+    os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+    extents = [100, 140, 20, 60]
+    proj = ccrs.PlateCarree()
+    fig = plt.figure(dpi=dpi)
+    ax = fig.add_subplot(111, projection=proj)
+    ax.set_extent(extents, crs=proj)
+    # 读取TIFF数据
+    elevation = None
+    if type(file_name) == list:
+        for each_file in file_name:
+            file_path = os.path.join(root_path, each_file)
+            with rasterio.open(file_path) as dataset:
+                el_rd = dataset.read(1)
+                elevation[elevation < filter] = np.nan
+                if elevation is None:
+                    elevation = el_rd
+                else:
+                    elevation += el_rd
+    else:
+        file_path = os.path.join(root_path, file_name)
+        with rasterio.open(file_path) as dataset:
+            elevation = dataset.read(1)
+        elevation[elevation <= filter] = np.nan
+    elevation, colors = _get_color_normalization(elevation, colors)
+    cmap = LinearSegmentedColormap.from_list('custom_cmap', colors)
+    # 添加各种特征
+    land = cfeature.NaturalEarthFeature('physical', 'land', '50m', edgecolor='black', facecolor='none',
+                                        linewidth=0.4)
+    ax.add_feature(land)
+    ax.imshow(elevation, origin='upper', extent=extents, transform=proj, cmap=cmap)
+    ax.add_feature(cfeature.OCEAN)
+    ax.add_feature(cfeature.LAND)
+    # ax.add_feature(cfeature.LAKES, edgecolor='black')
+    ax.add_feature(cfeature.RIVERS)
+    # ax.add_feature(cfeature.BORDERS)
+    # 添加网格线
+    # ax.gridlines(linestyle='--')
+    # 设置大刻度和小刻度
+    tick_proj = ccrs.PlateCarree()
+    ax.set_xticks(np.arange(area[0][0], area[0][1] + 1, area[0][2]), crs=tick_proj)
+    # ax.set_xticks(np.arange(-180, 180 + 30, 30), minor=True, crs=tick_proj)
+    ax.set_yticks(np.arange(area[1][0], area[1][1] + 1, area[1][2]), crs=tick_proj)
+    # ax.set_yticks(np.arange(-90, 90 + 15, 15), minor=True, crs=tick_proj)
+    # 利用Formatter格式化刻度标签
+    ax.xaxis.set_major_formatter(LongitudeFormatter())
+    ax.yaxis.set_major_formatter(LatitudeFormatter())
+    if out_folder is None:
+        if type(file_name) == list:
+            file_name = file_name[0]
+            file_dir = 'concate'
+        else:
+            file_dir = 'outs'
+    else:
+        file_dir = out_folder
+    os.makedirs(os.path.join(root_path, file_dir), exist_ok=True)
+    file_name = file_name.replace('.tif', '.png')
+    file_title = datetime.strptime(file_name.split('-')[0].replace('target_', ''), '%Y%m%d_%H%M%S')
+    file_name = file_title.strftime('%Y%m%d_%H%M%S.png')
+    exposure = exposure if exposure else (60 if file_dir == 'concate' else 15)
+    if tz == 'BJT':
+        exposure_end = (file_title + timedelta(hours=8) + timedelta(minutes=exposure)).strftime('%H:%M')
+        file_title = (file_title + timedelta(hours=8)).strftime('%Y-%m-%d %H:%M')
+    else:
+        exposure_end = (file_title + timedelta(minutes=exposure)).strftime('%H:%M')
+        file_title = file_title.strftime('%Y-%m-%d %H:%M')
+    ax.set_title(file_title + f'-' + exposure_end + f' ({tz})', fontsize=font_size)
+    plt.xticks(fontsize=font_size)
+    plt.yticks(fontsize=font_size)
+    # plt.title(fontsize=font_size)
+    file_save_path = os.path.join(root_path, file_dir, file_name)
+    plt.savefig(file_save_path)
+    if zoom_rectangle is not None:
+        read_png = cv2.imread(file_save_path)
+        read_png = zoomAndDock(read_png, zoom_rectangle, docker, scale_factor=5, border=14)
+        cv2.imwrite(file_save_path, read_png)
+    crop_png(file_save_path, left=corp[0], top=corp[1], right=corp[2], bottom=corp[3])
+    return file_save_path
+    # plt.show()
+
+
+def clipSatelliteNP(np_data, ld, area=((100, 140, 10), (20, 60, 10))):
+    lon_d = int((ld - (area[0][0] + area[0][1]) / 2) * 20)
+    lat_d = int(((area[1][0] + area[1][1]) / 2) * 20)
+    np_data = np_data[:, 800 - lat_d:1600 - lat_d, 800 - lon_d:1600 - lon_d]
+    return np_data

jacksung/utils/__init__.py

@@ -0,0 +1 @@
+from . import *

jacksung/utils/base_db.py

@@ -0,0 +1,72 @@
+import os
+import time
+import pymysql
+from datetime import datetime, timedelta
+from tqdm import tqdm
+
+import threading
+import multiprocessing
+import traceback, sys
+
+import configparser
+
+
+def convert_str(s):
+    return "'" + str(s).replace("'", '"') + "'"
+
+
+def convert_num(n):
+    return str(n)
+
+
+class BaseDB:
+    def __init__(self, ini_path='db.ini'):
+        self.conn = None
+        self.db = None
+        self.passwd = None
+        self.user = None
+        self.host = None
+        self.port = None
+        self.autocommit = True
+        self.ini_path = ini_path
+        pymysql.install_as_MySQLdb()
+        self.lock_t = threading.Lock()
+
+    def read_config(self):
+        config = configparser.ConfigParser()
+        config.read(self.ini_path)
+        # Create the connection object
+        self.host = config['database']['host']
+        self.passwd = config['database']['password']
+        self.db = config['database']['database']
+        self.user = config['database'].get('user', 'root')
+        self.port = config['database'].getint('port', 3306)
+
+    def reconnect(self):
+        if not self.conn:
+            self.read_config()
+        # 打开数据库连接
+        connection = pymysql.connect(host=self.host, user=self.user, passwd=self.passwd, db=self.db, port=self.port,
+                                     autocommit=self.autocommit)
+        tqdm.write('Reconnected!')
+        return connection
+
+    def execute(self, sql):
+        self.lock_t.acquire()
+        cursor = None
+        try:
+            cursor = self.conn.cursor()
+            result = cursor.execute(sql)
+        except Exception as e:
+            self.conn = self.reconnect()
+            cursor = self.conn.cursor()
+            try:
+                result = cursor.execute(sql)
+            except Exception as e:
+                print(f'err SQL: {sql}')
+                raise e
+        finally:
+            if cursor:
+                cursor.close()
+        self.lock_t.release()
+        return result, cursor