diff --git a/Ortho-Top/.gitignore b/Ortho-Top/.gitignore new file mode 100644 index 0000000..a6d09ea --- /dev/null +++ b/Ortho-Top/.gitignore @@ -0,0 +1,17 @@ +# 输入文件 +Input/ +Input2/ +Input3/ +Input4/ +Input5/ +# 输出文件 +Temporary/ +# 忽略工具文件 +__pycache__/ +dist/ +build/ +Ortho/ +run_log/ +*.tiff +*.tif +*.log \ No newline at end of file diff --git a/Ortho-Top/OrthOne.spec b/Ortho-Top/OrthOne.spec new file mode 100644 index 0000000..925f5ec --- /dev/null +++ b/Ortho-Top/OrthOne.spec @@ -0,0 +1,49 @@ +# -*- mode: python ; coding: utf-8 -*- + + +block_cipher = None + + +a = Analysis( + ['OrthoMain.py'], + pathex=['.'], + binaries=[], + datas=[], + hiddenimports=[], + hookspath=[], + runtime_hooks=[], + excludes=[], + win_no_prefer_redirects=False, + win_private_assemblies=False, + cipher=block_cipher, + noarchive=False, +) +pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher) + +exe = EXE( + pyz, + a.scripts, + [], + exclude_binaries=True, + name='OrthOne', + debug=False, + bootloader_ignore_signals=False, + strip=False, + upx=True, + console=True, + disable_windowed_traceback=False, + argv_emulation=False, + target_arch=None, + codesign_identity=None, + entitlements_file=None, +) +coll = COLLECT( + exe, + a.binaries, + a.zipfiles, + a.datas, + strip=False, + upx=True, + upx_exclude=[], + name='OrthOne', +) diff --git a/Ortho-Top/Ortho-S-SAR.xml.bak b/Ortho-Top/Ortho-S-SAR.xml.bak new file mode 100644 index 0000000..ab233ed --- /dev/null +++ b/Ortho-Top/Ortho-S-SAR.xml.bak @@ -0,0 +1,103 @@ + + + CSAR_202107275419_0001-0 + D:\micro\SWork\ + + File + ElementAlg + Ortho_S_SAR_V2.2 + Ortho_S_SAR_V2.2.exe + 正射校正 + 微波卫星3-5级产品生产模型 + Ortho-S-SAR-V2.2-1 + 1.0 + 辐射类产品_正射校正 + 4 + Ortho_中科卫星应用德清研究院_2.2 + 中科卫星应用德清研究院 + 景-算法 + Ortho\\Input6 + + 2599253_San_Francisco + + Ortho\\Output + + + 1.8 + python + + 0 + 0 + Windows10 + 4核 + 8GB + 25GB + 无需求 + 无需求 + 无需求 + + + + + SLC + SLC元文件 + 原始SLC各相关文件和参数 + File + tar.gz + Cal + F:\MicroWorkspace\S_SAR\AHV\HJ2E_MYC_QPS_001752_E118.0_N37.7_20230204_SLC_AHV_L10000010458.tar.gz + True + False + File + Satellite + 1 + GF3A + + + DEM + DEM数字高程影像 + 30m分辨率DEM数字高程影像tif + File + zip + Cal + F:\al_zhongji\S-SAR-data\backScattering\DEM\115E33N_COP30.zip + True + True + File + DEM + 0 + DEM + + + CorrectMethod + 选择校正方法 + 1.RPC;2.RD + int + int + Cal + 2 + True + True + UploadInput + Aux + 0 + Aux + + + + + OrthoProduct + 产品结果文件 + 产品结果文件 + File + tar.gz + Cal + D:\micro\SWork\Ortho\Output\HJ2E_MYC_QPS_001752_E118.0_N37.7_20230204_SLC_AHV_L10000010458-Ortho.tar.gz + DEFAULT + DEFAULT + DEFAULT + DEFAULT + + + + \ No newline at end of file diff --git a/Ortho-Top/OrthoAlg.py b/Ortho-Top/OrthoAlg.py new file mode 100644 index 0000000..0964e6b --- /dev/null +++ b/Ortho-Top/OrthoAlg.py @@ -0,0 +1,3276 @@ +# -*- coding: UTF-8 -*- +""" +@Project ：microproduct +@File ：OneOrthoAlg.py +@Function ：正射校正算法 +@Author ：KHZ +@Contact： +@Date ：2021/8/14 +@Version ：1.0.0 +""" +# from re import I, T, X, match +# from types import DynamicClassAttribute +# from numpy.core.einsumfunc import _parse_possible_contraction +# from numpy.core.fromnumeric import shape +# from numpy.core.shape_base import block +# from numpy.lib import row_stack +# from numpy.lib.function_base import delete +import psutil +import os +import gc +# import sys +# import scipy +# from scipy.sparse import data +# from scipy.sparse.construct import random +import xmltodict +import numpy as np +import json +import datetime, time +import yaml +import math +import time +#import cv2 +#import cv2 as cv +from osgeo import gdal, gdalconst +# from yaml.events import AliasEvent, NodeEvent +from OrthoAuxData import OrthoAuxData +# from OrthoImage import ImageHandler +from tool.algorithm.image.ImageHandle import ImageHandler +from tool.algorithm.algtools.MetaDataHandler import MetaDataHandler +# from logHandler import LogHandler +from osgeo import osr +from scipy import interpolate +import scipy.io as scipyio +import copy +import scipy.sparse as ss +import shutil +import pandas +import uuid +from concurrent.futures._base import as_completed, wait +from concurrent.futures.thread import ThreadPoolExecutor +from multiprocessing import Pool + +class ScatteringAlg: + def __init__(self): + pass + + @staticmethod + def sar_backscattering_coef(in_sar_tif, meta_file_path, out_sar_tif, inc_xml_path, replece_VV = False, is_DB = True): + + # 读取原始SAR影像 + proj, geotrans, in_data = ImageHandler.read_img(in_sar_tif) + + pol_id = int((os.path.splitext(os.path.basename(in_sar_tif))[0].split('_')[-1])[-1:]) + # 解析头文件 + + # 计算强度信息 + I = np.array(in_data[0], dtype="float32") + Q = np.array(in_data[1], dtype="float32") + + where_9999_0 = np.where(I == -9999) + where_9999_1 = np.where(Q == -9999) + I[where_9999_0] = 1.0 + Q[where_9999_1] = 1.0 + + I2 = np.square(I) + Q2 = np.square(Q) + intensity_arr = I2 + Q2 + + # 获取极化类型 + if 'HH' in os.path.basename(in_sar_tif): + polarization = 'HH' + elif 'HV' in os.path.basename(in_sar_tif): + polarization = 'HV' + elif 'VH' in os.path.basename(in_sar_tif): + polarization = 'VH' + elif 'VV' in os.path.basename(in_sar_tif): + polarization = 'VV' + if replece_VV: + polarization = 'HV' #土壤水分算法中可能会用HV替换VV + elif 'DH' in os.path.basename(in_sar_tif): + polarization = 'HH' + else: + raise Exception ('there are not HH、HV、VH、VV in path:',in_sar_tif) + + # 获取参数 + QualifyValue = MetaDataHandler.get_SubQualifyValue(meta_file_path, polarization, pol_id) + Kdb = MetaDataHandler.get_Kdb(meta_file_path, polarization) + + # 计算后向散射系数 + #对数形式 + coef_arr = 10 * (np.log10(intensity_arr * ((QualifyValue/32767)**2))) - Kdb + coef_arr[np.isnan(coef_arr)] = -9999 + coef_arr[np.isinf(coef_arr)] = -9999 + coef_arr[where_9999_0] = -9999 + coef_arr[where_9999_1] = -9999 + ## 输出的SAR后向散射系数产品 + # ImageHandler.write_img(out_sar_tif, proj, geotrans, coef_arr, 0) + _, _, inc_arr = ImageHandler().read_img(inc_xml_path) + rad_arr = np.radians(inc_arr) + sin_arr = np.sin(rad_arr) + + tif_array = np.power(10.0, coef_arr / 10.0) # dB --> 线性值 后向散射系数 + + tif_array[np.isnan(tif_array)] = 0 + tif_array[np.isinf(tif_array)] = 0 + tif_array[where_9999_0] = 0 + tif_array[where_9999_1] = 0 + # tif_array = tif_array / sin_arr + + ImageHandler.write_img(out_sar_tif, proj, geotrans, tif_array, 0) + return True + + @staticmethod + def lin_to_db(lin_path, db_path): + proj, geotrans, in_data = ImageHandler.read_img(lin_path) + db_arr = 10 * np.log10(in_data) + # db_arr[np.isnan(db_arr)] = -9999 + # db_arr[np.isinf(db_arr)] = -9999 + ImageHandler.write_img(db_path, proj, geotrans, db_arr, -9999) + + @staticmethod + def lin_to_db_top(lin_path, db_path): + proj, geotrans, in_data = ImageHandler.read_img(lin_path) + db_arr = 10 * np.log10(in_data) + db_arr[np.isnan(db_arr)] = 0 + db_arr[np.isinf(db_arr)] = 0 + # db_arr[np.isnan(db_arr)] = -9999 + # db_arr[np.isinf(db_arr)] = -9999 + ImageHandler.write_img(db_path, proj, geotrans, db_arr, '0') + + @staticmethod + def sar_backscattering_coef_RPC(in_sar_tif, meta_file_path, out_sar_tif, replece_VV=False, is_DB=True): + + # 读取原始SAR影像 + proj, geotrans, in_data = ImageHandler.read_img(in_sar_tif) + + # 计算强度信息 + I = np.array(in_data[0], dtype="float32") + Q = np.array(in_data[1], dtype="float32") + + where_9999_0 = np.where(I == -9999) + where_9999_1 = np.where(Q == -9999) + I[where_9999_0] = 1.0 + Q[where_9999_1] = 1.0 + + I2 = np.square(I) + Q2 = np.square(Q) + intensity_arr = I2 + Q2 + + # 获取极化类型 + if 'HH' in os.path.basename(in_sar_tif): + polarization = 'HH' + elif 'HV' in os.path.basename(in_sar_tif): + polarization = 'HV' + elif 'VH' in os.path.basename(in_sar_tif): + polarization = 'VH' + elif 'VV' in os.path.basename(in_sar_tif): + polarization = 'VV' + if replece_VV: + polarization = 'HV' # 土壤水分算法中可能会用HV替换VV + elif 'DH' in os.path.basename(in_sar_tif): + polarization = 'HH' + else: + raise Exception('there are not HH、HV、VH、VV in path:', in_sar_tif) + + # 获取参数 + QualifyValue = MetaDataHandler.get_QualifyValue(meta_file_path, polarization) + # Kdb = MetaDataHandler.get_Kdb(meta_file_path, polarization) + Kdb = 0 + + # 计算后向散射系数 + # 对数形式 + coef_arr = 10 * (np.log10(intensity_arr * ((QualifyValue / 32767) ** 2))) - Kdb + coef_arr[np.isnan(coef_arr)] = 0 + coef_arr[np.isinf(coef_arr)] = 0 + coef_arr[where_9999_0] = 0 + coef_arr[where_9999_1] = 0 + ## 输出的SAR后向散射系数产品 + ImageHandler.write_img(out_sar_tif, proj, geotrans, coef_arr, 0) + + return True + + + +def FindInfomationFromJson(HeaderFile_dom_json, node_path_list): + """ + 在Json文件中，按照指定路径解析出制定节点 + """ + result_node = HeaderFile_dom_json + for nodename in node_path_list: + result_node = result_node[nodename] + return result_node + + +def GetVectorNorm(Vecter): + """ + 得到向量的模 + """ + Vecter = Vecter.reshape(-1,1) + Vecter_Norm_pow = np.matmul(Vecter.T,Vecter) + return np.sqrt(Vecter_Norm_pow) + + +def XYZOuterM2(A, B): + """ + 外积（叉乘）,日后版本换成可以任意维度的外积运算方程 + args: + A:nx3 + B:nx3 + """ + cnt = A.shape[0] + C = np.zeros((cnt, 3)) + C[:, 0] = A[:, 1] * B[:, 2] - A[:, 2] * B[:, 1] + C[:, 1] = A[:, 2] * B[:, 0] - A[:, 0] * B[:, 2] + C[:, 2] = A[:, 0] * B[:, 1] - A[:, 1] * B[:, 0] + return C + +def LinearSampling_raster(source_raster,tar_raster,source_start_row,source_start_col,tar_start_row,tar_start_col): + ''' 双线性重采样 + agrs: + source_raster:原影像 + tar_raster:目标影像 + source_start_row:原影像的起始行号 + source_start_col:原影像的起始列号 + tar_start_row:目标影像的起始行号 + tar_start_col:目标影像的起始列号 + return: + tar_raster:目标影像 + ''' + # 根据原影像的起始行列号与目标影像行列号，计算目标影像行列号的校正值 + d_row=tar_start_row-source_start_row # + d_col=tar_start_col-source_start_col # + + + source_height=source_raster.shape[0] + source_width=source_raster.shape[1] + tar_height=tar_raster.shape[0] + tar_width=tar_raster.shape[1] + + source_row=(np.ones((source_width,source_height))*range(source_height)).transpose(1,0) + source_col=np.ones((source_height,source_width))*range(source_width) + + tar_row=(np.ones((tar_width,tar_height))*range(tar_height)).transpose(1,0) + tar_col=np.ones((tar_height,tar_width))*range(tar_width) + + tar_row=tar_row+d_row # 坐标系变换 + tar_col=tar_col+d_col # 坐标系变换 + # 确定行列号 + last_source_row=np.floor(tar_row) + last_source_col=np.floor(tar_col) + next_source_row=np.ceil(tar_row) + next_source_col=np.ceil(tar_col) + + # 双线性重采样模型示意图， + # y1 r1 y2 + # + # r + # + # y3 r2 y4 + # 计算重采样 + r1=source_raster[last_source_row,last_source_col]*(tar_col-last_source_col)+source_raster[last_source_row,next_source_col]*(next_source_col-tar_col) + r2=source_raster[next_source_row,last_source_col]*(tar_col-last_source_col)+source_raster[next_source_row,next_source_col]*(next_source_col-tar_col) + tar_raster=r1*(tar_row-last_source_row)+r2*(next_source_row-tar_row) + tar_raster=tar_raster.reshape(tar_height,tar_width) # 目标影像 + return tar_raster.copy() + +'''-----双线性重采样-----''' + + +""" RPC 校正部分 """ + +def parse_rpc_file(rpc_file): + # rpc_file:.rpc文件的绝对路径 + # rpc_dict：符号RPC域下的16个关键字的字典 + # 参考网址：http://geotiff.maptools.org/rpc_prop.html； + # https://www.osgeo.cn/gdal/development/rfc/rfc22_rpc.html + + rpc_dict = {} + with open(rpc_file) as f: + text = f.read() + + # .rpc文件中的RPC关键词 + words = ['errBias', 'errRand', 'lineOffset', 'sampOffset', 'latOffset', + 'longOffset', 'heightOffset', 'lineScale', 'sampScale', 'latScale', + 'longScale', 'heightScale', 'lineNumCoef', 'lineDenCoef','sampNumCoef', 'sampDenCoef',] + + # GDAL库对应的RPC关键词 + keys = ['ERR_BIAS', 'ERR_RAND', 'LINE_OFF', 'SAMP_OFF', 'LAT_OFF', 'LONG_OFF', + 'HEIGHT_OFF', 'LINE_SCALE', 'SAMP_SCALE', 'LAT_SCALE', + 'LONG_SCALE', 'HEIGHT_SCALE', 'LINE_NUM_COEFF', 'LINE_DEN_COEFF', + 'SAMP_NUM_COEFF', 'SAMP_DEN_COEFF'] + + for old, new in zip(words, keys): + text = text.replace(old, new) + # 以‘;\n’作为分隔符 + text_list = text.split(';\n') + # 删掉无用的行 + text_list = text_list[3:-2] + # + text_list[0] = text_list[0].split('\n')[1] + # 去掉制表符、换行符、空格 + text_list = [item.strip('\t').replace('\n', '').replace(' ', '') for item in text_list] + + for item in text_list: + # 去掉‘=’ + key, value = item.split('=') + # 去掉多余的括号‘(’，‘)’ + if '(' in value: + value = value.replace('(', '').replace(')', '') + rpc_dict[key] = value + + for key in keys[:12]: + # 为正数添加符号‘+’ + if not rpc_dict[key].startswith('-'): + rpc_dict[key] = '+' + rpc_dict[key] + # 为归一化项和误差标志添加单位 + if key in ['LAT_OFF', 'LONG_OFF', 'LAT_SCALE', 'LONG_SCALE']: + rpc_dict[key] = rpc_dict[key] + ' degrees' + if key in ['LINE_OFF', 'SAMP_OFF', 'LINE_SCALE', 'SAMP_SCALE']: + rpc_dict[key] = rpc_dict[key] + ' pixels' + if key in ['ERR_BIAS', 'ERR_RAND', 'HEIGHT_OFF', 'HEIGHT_SCALE']: + rpc_dict[key] = rpc_dict[key] + ' meters' + + # 处理有理函数项 + for key in keys[-4:]: + values = [] + for item in rpc_dict[key].split(','): + #print(item) + if not item.startswith('-'): + values.append('+'+item) + else: + values.append(item) + rpc_dict[key] = ' '.join(values) + return rpc_dict + + +def write_rpc_to_tiff(inputpath,rpc_file,ap = True,outpath = None): + rpc_dict = parse_rpc_file(rpc_file) + if ap: + # 可修改读取 + dataset = gdal.Open(inputpath,gdal.GA_Update) + # 向tif影像写入rpc域信息 + # 注意，这里虽然写入了RPC域信息，但实际影像还没有进行实际的RPC校正 + # 尽管有些RS/GIS能加载RPC域信息，并进行动态校正 + for k in rpc_dict.keys(): + dataset.SetMetadataItem(k, rpc_dict[k], 'RPC') + dataset.FlushCache() + del dataset + else: + dataset = gdal.Open(inputpath,gdal.GA_Update) + tiff_driver= gdal.GetDriverByName('Gtiff') + out_ds = tiff_driver.CreateCopy(outpath, dataset, 1) + for k in rpc_dict.keys(): + out_ds.SetMetadataItem(k, rpc_dict[k], 'RPC') + out_ds.FlushCache() + + +def rpc_correction(inputpath,rpc_file,corrtiff,dem_tif_file = None): + ## 设置rpc校正的参数 + # 原图像和输出影像缺失值设置为0，输出影像坐标系为WGS84(EPSG:4326), 重采样方法为双线性插值（bilinear，还有最邻近‘near’、三次卷积‘cubic’等可选) + # 注意DEM的覆盖范围要比原影像的范围大，此外，DEM不能有缺失值，有缺失值会报错 + # 通常DEM在水域是没有值的（即缺失值的情况），因此需要将其填充设置为0，否则在RPC校正时会报错 + # 这里使用的DEM是填充0值后的SRTM V4.1 3秒弧度的DEM(分辨率为90m) + # RPC_DEMINTERPOLATION=bilinear 表示对DEM重采样使用双线性插值算法 + # 如果要修改输出的坐标系，则要修改dstSRS参数值，使用该坐标系统的EPSG代码 + # 可以在网址https://spatialreference.org/ref/epsg/32650/ 查询得到EPSG代码 + + write_rpc_to_tiff(inputpath,rpc_file,ap = True,outpath = None) + + if dem_tif_file is None: + wo = gdal.WarpOptions(srcNodata=0, dstNodata=0, dstSRS='EPSG:4326', resampleAlg='bilinear', + format='Gtiff',rpc=True, warpOptions=["INIT_DEST=NO_DATA"]) + + wr = gdal.Warp(corrtiff, inputpath, options=wo) + print("RPC_GEOcorr>>>") + else: + wo = gdal.WarpOptions(srcNodata=0, dstNodata=0, dstSRS='EPSG:4326', resampleAlg='bilinear', format='Gtiff',rpc=True, warpOptions=["INIT_DEST=NO_DATA"], + transformerOptions=["RPC_DEM=%s"%(dem_tif_file), "RPC_DEMINTERPOLATION=bilinear"]) + wr = gdal.Warp(corrtiff, inputpath, options=wo) + print("RPC_GEOcorr>>>") + ## 对于全海域的影像或者不使用DEM校正的话，可以将transformerOptions有关的RPC DEM关键字删掉 + ## 即将上面gdal.WarpOptions注释掉，将下面的语句取消注释，无DEM时，影像范围的高程默认全为0 + del wr + + +########################## +# 输出RPC 行列号到 经纬度的变换 +########################## + #最大迭代次数超过则报错 +class MaxLocalizationIterationsError(Exception): + """ + Custom rpcm Exception. + """ + pass + +def apply_poly(poly, x, y, z): + """ + Evaluates a 3-variables polynom of degree 3 on a triplet of numbers. + 将三次多项式的统一模式构建为一个单独的函数 + Args: + poly: list of the 20 coefficients of the 3-variate degree 3 polynom, + ordered following the RPC convention. + x, y, z: triplet of floats. They may be numpy arrays of same length. + Returns: + the value(s) of the polynom on the input point(s). + """ + out = 0 + out += poly[0] + out += poly[1]*y + poly[2]*x + poly[3]*z + out += poly[4]*y*x + poly[5]*y*z +poly[6]*x*z + out += poly[7]*y*y + poly[8]*x*x + poly[9]*z*z + out += poly[10]*x*y*z + out += poly[11]*y*y*y + out += poly[12]*y*x*x + poly[13]*y*z*z + poly[14]*y*y*x + out += poly[15]*x*x*x + out += poly[16]*x*z*z + poly[17]*y*y*z + poly[18]*x*x*z + out += poly[19]*z*z*z + return out + +def apply_rfm(num, den, x, y, z): + """ + Evaluates a Rational Function Model (rfm), on a triplet of numbers. + 执行20个参数的分子和20个参数的除法 + Args: + num: list of the 20 coefficients of the numerator + den: list of the 20 coefficients of the denominator + All these coefficients are ordered following the RPC convention. + x, y, z: triplet of floats. They may be numpy arrays of same length. + + Returns: + the value(s) of the rfm on the input point(s). + """ + return apply_poly(num, x, y, z) / apply_poly(den, x, y, z) + +def rpc_from_geotiff(geotiff_path): + """ + Read the RPC coefficients from a GeoTIFF file and return an RPCModel object. + 该函数返回影像的Gdal格式的影像和RPCmodel + Args: + geotiff_path (str): path or url to a GeoTIFF file + + Returns: + instance of the rpc_model.RPCModel class + """ + # with rasterio.open(geotiff_path, 'r') as src: + # + dataset = gdal.Open(geotiff_path, gdal.GA_ReadOnly) + rpc_dict = dataset.GetMetadata("RPC") + # 同时返回影像与rpc + return dataset, RPCModel(rpc_dict,'geotiff') + + +def read_rpc_file(rpc_file): + """ + Read RPC from a RPC_txt file and return a RPCmodel + 从TXT中直接单独读取RPC模型 + Args: + rpc_file: RPC sidecar file path + + Returns: + dictionary read from the RPC file, or an empty dict if fail + + """ + rpc = parse_rpc_file(rpc_file) + return RPCModel(rpc) + +class RPCModel: + def __init__(self, d, dict_format="geotiff"): + """ + Args: + d (dict): dictionary read from a geotiff file with + rasterio.open('/path/to/file.tiff', 'r').tags(ns='RPC'), + or from the .__dict__ of an RPCModel object. + dict_format (str): format of the dictionary passed in `d`. + Either "geotiff" if read from the tags of a geotiff file, + or "rpcm" if read from the .__dict__ of an RPCModel object. + """ + if dict_format == "geotiff": + self.row_offset = float(d['LINE_OFF'][0:d['LINE_OFF'].rfind(' ')]) + self.col_offset = float(d['SAMP_OFF'][0:d['SAMP_OFF'].rfind(' ')]) + self.lat_offset = float(d['LAT_OFF'][0:d['LAT_OFF'].rfind(' ')]) + self.lon_offset = float(d['LONG_OFF'][0:d['LONG_OFF'].rfind(' ')]) + self.alt_offset = float(d['HEIGHT_OFF'][0:d['HEIGHT_OFF'].rfind(' ')]) + + self.row_scale = float(d['LINE_SCALE'][0:d['LINE_SCALE'].rfind(' ')]) + self.col_scale = float(d['SAMP_SCALE'][0:d['SAMP_SCALE'].rfind(' ')]) + self.lat_scale = float(d['LAT_SCALE'][0:d['LAT_SCALE'].rfind(' ')]) + self.lon_scale = float(d['LONG_SCALE'][0:d['LONG_SCALE'].rfind(' ')]) + self.alt_scale = float(d['HEIGHT_SCALE'][0:d['HEIGHT_SCALE'].rfind(' ')]) + + self.row_num = list(map(float, d['LINE_NUM_COEFF'].split())) + self.row_den = list(map(float, d['LINE_DEN_COEFF'].split())) + self.col_num = list(map(float, d['SAMP_NUM_COEFF'].split())) + self.col_den = list(map(float, d['SAMP_DEN_COEFF'].split())) + + if 'LON_NUM_COEFF' in d: + self.lon_num = list(map(float, d['LON_NUM_COEFF'].split())) + self.lon_den = list(map(float, d['LON_DEN_COEFF'].split())) + self.lat_num = list(map(float, d['LAT_NUM_COEFF'].split())) + self.lat_den = list(map(float, d['LAT_DEN_COEFF'].split())) + + elif dict_format == "rpcm": + self.__dict__ = d + + else: + raise ValueError( + "dict_format '{}' not supported. " + "Should be {{'geotiff','rpcm'}}".format(dict_format) + ) + + + def projection(self, lon, lat, alt): + """ + Convert geographic coordinates of 3D points into image coordinates. + 正投影：从地理坐标到图像坐标 + Args: + lon (float or list): longitude(s) of the input 3D point(s) + lat (float or list): latitude(s) of the input 3D point(s) + alt (float or list): altitude(s) of the input 3D point(s) + + Returns: + float or list: horizontal image coordinate(s) (column index, ie x) + float or list: vertical image coordinate(s) (row index, ie y) + """ + nlon = (np.asarray(lon) - self.lon_offset) / self.lon_scale + nlat = (np.asarray(lat) - self.lat_offset) / self.lat_scale + nalt = (np.asarray(alt) - self.alt_offset) / self.alt_scale + + col = apply_rfm(self.col_num, self.col_den, nlat, nlon, nalt) + row = apply_rfm(self.row_num, self.row_den, nlat, nlon, nalt) + + col = col * self.col_scale + self.col_offset + row = row * self.row_scale + self.row_offset + + return col, row + + + def localization(self, col, row, alt, return_normalized=False): + """ + Convert image coordinates plus altitude into geographic coordinates. + 反投影：从图像坐标到地理坐标 + Args: + col (float or list): x image coordinate(s) of the input point(s) + row (float or list): y image coordinate(s) of the input point(s) + alt (float or list): altitude(s) of the input point(s) + + Returns: + float or list: longitude(s) + float or list: latitude(s) + """ + ncol = (np.asarray(col) - self.col_offset) / self.col_scale + nrow = (np.asarray(row) - self.row_offset) / self.row_scale + nalt = (np.asarray(alt) - self.alt_offset) / self.alt_scale + + if not hasattr(self, 'lat_num'): + lon, lat = self.localization_iterative(ncol, nrow, nalt) + else: + lon = apply_rfm(self.lon_num, self.lon_den, nrow, ncol, nalt) + lat = apply_rfm(self.lat_num, self.lat_den, nrow, ncol, nalt) + + if not return_normalized: + lon = lon * self.lon_scale + self.lon_offset + lat = lat * self.lat_scale + self.lat_offset + + return lon, lat + + + def localization_iterative(self, col, row, alt): + """ + Iterative estimation of the localization function (image to ground), + for a list of image points expressed in image coordinates. + 逆投影时的迭代函数 + Args: + col, row: normalized image coordinates (between -1 and 1) + alt: normalized altitude (between -1 and 1) of the corresponding 3D + point + + Returns: + lon, lat: normalized longitude and latitude + + Raises: + MaxLocalizationIterationsError: if the while loop exceeds the max + number of iterations, which is set to 100. + """ + # target point: Xf (f for final) + Xf = np.vstack([col, row]).T + + # use 3 corners of the lon, lat domain and project them into the image + # to get the first estimation of (lon, lat) + # EPS is 2 for the first iteration, then 0.1. + lon = -col ** 0 # vector of ones + lat = -col ** 0 + EPS = 2 + x0 = apply_rfm(self.col_num, self.col_den, lat, lon, alt) + y0 = apply_rfm(self.row_num, self.row_den, lat, lon, alt) + x1 = apply_rfm(self.col_num, self.col_den, lat, lon + EPS, alt) + y1 = apply_rfm(self.row_num, self.row_den, lat, lon + EPS, alt) + x2 = apply_rfm(self.col_num, self.col_den, lat + EPS, lon, alt) + y2 = apply_rfm(self.row_num, self.row_den, lat + EPS, lon, alt) + + + + n = 0 + while not np.all((x0 - col) ** 2 + (y0 - row) ** 2 < 1e-18): + + if n > 100: + raise MaxLocalizationIterationsError("Max localization iterations (100) exceeded") + + X0 = np.vstack([x0, y0]).T + X1 = np.vstack([x1, y1]).T + X2 = np.vstack([x2, y2]).T + e1 = X1 - X0 + e2 = X2 - X0 + u = Xf - X0 + + # project u on the base (e1, e2): u = a1*e1 + a2*e2 + # the exact computation is given by: + # M = np.vstack((e1, e2)).T + # a = np.dot(np.linalg.inv(M), u) + # but I don't know how to vectorize this. + # Assuming that e1 and e2 are orthogonal, a1 is given by + # / + num = np.sum(np.multiply(u, e1), axis=1) + den = np.sum(np.multiply(e1, e1), axis=1) + a1 = np.divide(num, den).squeeze() + + num = np.sum(np.multiply(u, e2), axis=1) + den = np.sum(np.multiply(e2, e2), axis=1) + a2 = np.divide(num, den).squeeze() + + # use the coefficients a1, a2 to compute an approximation of the + # point on the gound which in turn will give us the new X0 + lon += a1 * EPS + lat += a2 * EPS + + # update X0, X1 and X2 + EPS = .1 + x0 = apply_rfm(self.col_num, self.col_den, lat, lon, alt) + y0 = apply_rfm(self.row_num, self.row_den, lat, lon, alt) + x1 = apply_rfm(self.col_num, self.col_den, lat, lon + EPS, alt) + y1 = apply_rfm(self.row_num, self.row_den, lat, lon + EPS, alt) + x2 = apply_rfm(self.col_num, self.col_den, lat + EPS, lon, alt) + y2 = apply_rfm(self.row_num, self.row_den, lat + EPS, lon, alt) + n += 1 + + return lon, lat +############################################# +# 校正影像 输出影像转换表 +############################################# + +""" +[pool.putRequest(req) for req in requests]等同于 +　　for req in requests: +　　　　 pool.putRequest(req) +""" + +def rpc_row_col(params): + rpc_mdl,r_block,c_block,ati_block,i,block_shape=params + r_block ,c_block = rpc_mdl.localization(r_block,c_block,0) + print("\t{}\t".format(i)) + return [i,r_block ,c_block,block_shape] + + +def get_RPC_lon_lat(in_rpc_tiff,out_rpc_rc_path): + exe_path=r".\baseTool\x64\Release\SIMOrthoProgram-S-SAR.exe" + exe_cmd=r"set PROJ_LIB=.\baseTool\x64\Release; & {0} {1} {2} {3} ".format(exe_path,8,in_rpc_tiff,out_rpc_rc_path) + print(exe_cmd) + print(os.system(exe_cmd)) + print("==========================================================================") +def getRCImageRC2(inputPath,out_rpc_rc_path): + #shutil.copy2(inputPath, out_rpc_rc_path) + # 创建重采样输出文件（设置投影及六参数） + input_rpc_sar=gdal.Open(inputPath) + + driver = gdal.GetDriverByName('GTiff') + output = driver.Create(out_rpc_rc_path, input_rpc_sar.RasterXSize,input_rpc_sar.RasterYSize, 2,gdal.GDT_Float32) + output.SetGeoTransform(list(input_rpc_sar.GetGeoTransform())) + output.SetProjection(input_rpc_sar.GetProjection()) + # 参数说明 输入数据集、输出文件、输入投影、参考投影、重采样方法(最邻近内插\双线性内插\三次卷积等)、回调函数 + + rpc_rc_img=output + # 计算行列号 + rc_height=rpc_rc_img.RasterYSize + rc_width=rpc_rc_img.RasterXSize + + + for i in range(0,rc_height,100): + c_block=np.ones((100,rc_width)).astype(np.float32)*(np.array(list(range(rc_width))).reshape(1,rc_width)) + r_block=np.ones((100,rc_width)).astype(np.float32)*(np.array(list(range(100))).reshape(100,1)) + r_block=r_block+i + if rc_height-i>100: + rpc_rc_img.GetRasterBand(1).WriteArray(r_block.astype(np.float32),0,i) + rpc_rc_img.GetRasterBand(2).WriteArray(c_block.astype(np.float32),0,i) + else: + num=rc_height-i + rpc_rc_img.GetRasterBand(1).WriteArray(r_block[:num,:].astype(np.float32),0,i) + rpc_rc_img.GetRasterBand(2).WriteArray(c_block[:num,:].astype(np.float32),0,i) + + del rpc_rc_img,output,input_rpc_sar + +def getRCImageRC(inputPath,out_rpc_rc_path,rpc_file_path): + rpc_tool = read_rpc_file(rpc_file_path) + #shutil.copy2(inputPath, out_rpc_rc_path) + # 创建重采样输出文件（设置投影及六参数） + input_rpc_sar=gdal.Open(inputPath) + + driver = gdal.GetDriverByName('GTiff') + output = driver.Create(out_rpc_rc_path, input_rpc_sar.RasterXSize,input_rpc_sar.RasterYSize, 2,gdal.GDT_Float32) + output.SetGeoTransform(list(input_rpc_sar.GetGeoTransform())) + output.SetProjection(input_rpc_sar.GetProjection()) + # 参数说明 输入数据集、输出文件、输入投影、参考投影、重采样方法(最邻近内插\双线性内插\三次卷积等)、回调函数 + + rpc_rc_img=output + # 计算行列号 + rc_height=rpc_rc_img.RasterYSize + rc_width=rpc_rc_img.RasterXSize + + + with Pool(8) as t: + plist=[] + for i in range(0,rc_height,1000): + c_block=np.ones((1000,rc_width)).astype(np.float32)*(np.array(list(range(rc_width))).reshape(1,rc_width)) + r_block=np.ones((1000,rc_width)).astype(np.float32)*(np.array(list(range(1000))).reshape(1000,1)) + r_block=r_block+i + if not rc_height-i>1000: + num=rc_height-i + r_block=r_block[:num,:].astype(np.float32) + c_block=c_block[:num,:].astype(np.float32) + block_shape=r_block.shape + + plist.append(t.apply_async(rpc_row_col,args=([rpc_tool,r_block.reshape(-1).astype(np.int32),c_block.reshape(-1).astype(np.int32) ,c_block.reshape(-1)*0+0,i,block_shape],))) + t.close() + t.join() + for future in plist: + data = future.get() + i,r_block ,c_block,block_shape=data + rpc_rc_img.GetRasterBand(1).WriteArray(r_block.reshape(block_shape).astype(np.float32),0,i) + rpc_rc_img.GetRasterBand(2).WriteArray(c_block.reshape(block_shape).astype(np.float32),0,i) + del rpc_rc_img,output,input_rpc_sar +""" RPC 结束 """ + + +class SatelliteOrbit(object): + def __init__(self) -> None: + super().__init__() + self.starttime = 1262275200.0 + self.modelName="" + + def get_starttime(self): + ''' + 返回卫星轨道时间起算点 + ''' + return self.starttime + + def ReconstructionSatelliteOrbit(self, GPSPoints_list): + ''' + 重建卫星轨道，使用多项式拟合法 + args: + GPSPoints_list:GPS 卫星轨道点 + return： + SatelliteOrbitModel 卫星轨道模型 + ''' + self.SatelliteOrbitModel = None + + def SatelliteSpaceState(self, time_float): + ''' + 根据时间戳，返回对应时间的卫星的轨迹状态 + args: + time_float:时间戳 + return： + State_list:[time,Xp,Yp,Zp,Vx,Vy,Vz] + ''' + return None + + +class SatelliteOrbitFitPoly(SatelliteOrbit): + ''' + 继承于SatelliteOribit类，为拟合多项式实现方法 + ''' + + def __init__(self) -> None: + super().__init__() + self.modelName="多项式" + self.polynum=4 + + def ReconstructionSatelliteOrbit(self, GPSPoints_list, starttime): + if len(GPSPoints_list)==2: + self.polynum=1 + self.starttime = starttime + + record_count = len(GPSPoints_list) + time_arr = np.zeros((record_count, 1), dtype=np.float64) # 使用np.float64只是为了精度高些；如果32位也能满足需求，请用32位 + state_arr = np.zeros((record_count, 6), dtype=np.float64) + A_arr = np.zeros((self.polynum+1, 6), dtype=np.float64) # 四次项 + X=np.ones((record_count,self.polynum+1),dtype=np.float64) # 记录时间坐标 + # 将点记录转换为自变量矩阵、因变量矩阵 + + for i in range(record_count): + GPSPoint = GPSPoints_list[i] + time_ = GPSPoint[0] - self.starttime # 为了保证精度，对时间进行缩放 + X[i,:]=np.array([1,time_]) + state_arr[i, :] = np.array(GPSPoint[1:],dtype=np.float64).reshape(1,6) # 空间坐标 + self.model_f=[] + for i in range(6): + Y = state_arr[:, i].reshape(-1,1) + A_arr[:,i]=np.matmul(np.matmul(np.linalg.inv(np.matmul(X.T,X)),X.T),Y)[:,0] + + self.A_arr=copy.deepcopy(A_arr.copy()) + return self.A_arr + elif len(GPSPoints_list) > 6: + self.polynum=4 + # 多项式的节点数，理论上是超过5个可以起算，这里为了精度选择10个点起算。 + # 多项式 XA=Y ==> A=(X'X)^X'Y，其中 A 为待求系数，X为变量，Y为因变量 + # 这里使用三次项多项式，共有6组参数。 + # 声明自变量，因变量，系数矩阵 + self.starttime = starttime + + record_count = len(GPSPoints_list) + time_arr = np.zeros((record_count, 1), dtype=np.float64) # 使用np.float64只是为了精度高些；如果32位也能满足需求，请用32位 + state_arr = np.zeros((record_count, 6), dtype=np.float64) + A_arr = np.zeros((self.polynum+1, 6), dtype=np.float64) # 四次项 + X=np.ones((record_count,self.polynum+1),dtype=np.float64) # 记录时间坐标 + # 将点记录转换为自变量矩阵、因变量矩阵 + + for i in range(record_count): + GPSPoint = GPSPoints_list[i] + time_ = GPSPoint[0] - self.starttime # 为了保证精度，对时间进行缩放 + X[i,:]=np.array([1,time_,time_**2,time_**3,time_**4]) + state_arr[i, :] = np.array(GPSPoint[1:],dtype=np.float64).reshape(1,6) # 空间坐标 + self.model_f=[] + for i in range(6): + Y = state_arr[:, i].reshape(-1,1) + A_arr[:,i]=np.matmul(np.matmul(np.linalg.inv(np.matmul(X.T,X)),X.T),Y)[:,0] + + self.A_arr=copy.deepcopy(A_arr.copy()) + ''' 测试误差 + from matplotlib import pyplot + label_list=['x','y','z','vx','vy','vz'] + color_list=['r','g','b','gold','gray','pink'] + pyplot.figure() + for i in range(6): + Y = state_arr[:, i] + Y_predict=self.model_f[i](X) + pyplot.subplot(int("23{}".format(i+1))) + d=Y-Y_predict + pyplot.plot(X,d,label=label_list[i],color=color_list[i]) + pyplot.title("max:{}".format(np.max(d))) + #self.model_f.append(interpolate.interp1d(X,Y,kind='cubic',fill_value='extrapolate')) + pyplot.legend() + pyplot.show() + ''' + return self.A_arr + else: + self.A_arr = None + return None + + def SatelliteSpaceState(self, time_float): + ''' + 逐像素求解 + 根据时间戳，返回对应时间的卫星的轨迹状态，会自动计算与起算时间之差 + args: + time_float:时间戳 + return： + State_list:[time,Xp,Yp,Zp,Vx,Vy,Vz] + ''' + if self.model_f is None: + return None + + result_arr=np.zeros((1,7)) + + time_float = time_float - self.starttime + result_arr[0,0]=time_float + #time_arr[0, 4] = time_arr[0, 3] * time_float ** 4 + time_float=np.array([1,time_float,time_float**2,time_float**3,time_float**4]).reshape(1,5) + result_arr=np.matmul(time_float,self.A_arr) + return [time_float,result_arr] + + def getSatelliteSpaceState(self, time_array): + ''' + 矩阵求解 + 根据时间戳矩阵，返回对应时刻的卫星空间状态（位置，速度），且会自动计算与起算时间之差 + args: + time_array:nparray nx1 时间戳 + return: + SatellitSpaceStateArray:nparray nx6 状态信息 + ''' + if self.model_f is None: + return None # 返回None,表示没有结果 + if self.polynum==4: + n=time_array.shape[0] + result_arr_=np.zeros((n,6),dtype=np.float64) + time_float = time_array - self.starttime + time_float=time_float.reshape(-1) # nx1 + time_arr=np.ones((time_float.shape[0],5)) # nx5 + time_arr[:,1]=time_float + time_arr[:,2]=time_float**2 + time_arr[:,3]=time_float**3 + time_arr[:,4]=time_float**4 + result_arr_=np.matmul(time_arr,self.A_arr) # nx5 5x6 + #time_arr[0, 4] = time_arr[0, 3] * time_float ** 4 + #result_arr=result_arr_ + return result_arr_ # 位置矩阵 + else: + n=time_array.shape[0] + result_arr_=np.zeros((n,6),dtype=np.float64) + time_float = time_array - self.starttime + time_float=time_float.reshape(-1) # nx1 + time_arr=np.ones((time_float.shape[0],self.polynum+1)) # nx5 + time_arr[:,1]=time_float + result_arr_=np.matmul(time_arr,self.A_arr) # nx5 5x6 + #time_arr[0, 4] = time_arr[0, 3] * time_float ** 4 + #result_arr=result_arr_ + return result_arr_ # 位置矩阵 + + +def ReconstructionSatelliteOrbit(GPSPoints_list, starttime): + ''' + 构建卫星轨道 + args: + GPSPoints_list:卫星轨道点 + starttime:起算时间 + ''' + if len(GPSPoints_list) > 10: + SatelliteOrbitModel = SatelliteOrbitFitPoly() + if SatelliteOrbitModel.ReconstructionSatelliteOrbit(GPSPoints_list, starttime=starttime) is None: + return None + return SatelliteOrbitModel + elif len(GPSPoints_list)==2: + SatelliteOrbitModel = SatelliteOrbitFitPoly() + if SatelliteOrbitModel.ReconstructionSatelliteOrbit(GPSPoints_list, starttime=starttime) is None: + return None + return SatelliteOrbitModel + + + +class DEMProcess(object): + def __init__(self): + pass + + @staticmethod + def get_extent(fn): + ''' + 原文链接：https://blog.csdn.net/XBR_2014/article/details/85255412 + ''' + ds = gdal.Open(fn) + rows = ds.RasterYSize + cols = ds.RasterXSize + # 获取图像角点坐标 + gt = ds.GetGeoTransform() + minx = gt[0] + maxy = gt[3] + maxx = gt[0] + gt[1] * rows + miny = gt[3] + gt[5] * cols + return (minx, maxy, maxx, miny) + + @staticmethod + def img_mosaic(in_files, out_dem_path): + # 通过两两比较大小,将最终符合条件的四个角点坐标保存 + # 即为拼接图像的四个角点坐标 + minX, maxY, maxX, minY = DEMProcess.get_extent(in_files[0]) + for fn in in_files[1:]: + minx, maxy, maxx, miny = DEMProcess.get_extent(fn) + minX = min(minX, minx) + maxY = max(maxY, maxy) + maxX = max(maxX, maxx) + minY = min(minY, miny) + + # 获取输出图像的行列数 + in_ds = gdal.Open(in_files[0]) + bands_num = in_ds.RasterCount + gt = in_ds.GetGeoTransform() + rows = int((maxX - minX) / abs(gt[5])) + cols = int((maxY - minY) / gt[1]) + + # 判断栅格数据的数据类型 + datatype = gdal.GDT_UInt16 + + # 创建输出图像 + driver = gdal.GetDriverByName('GTiff') + out_dem = os.path.join(out_dem_path, 'mosaic0.tif') + out_ds = driver.Create(out_dem, cols, rows, bands_num, datatype) + out_ds.SetProjection(in_ds.GetProjection()) + + gt = list(in_ds.GetGeoTransform()) + gt[0], gt[3] = minX, maxY + out_ds.SetGeoTransform(gt) + + for fn in in_files: + in_ds = gdal.Open(fn) + x_size = in_ds.RasterXSize + y_size = in_ds.RasterYSize + trans = gdal.Transformer(in_ds, out_ds, []) + success, xyz = trans.TransformPoint(False, 0, 0) + x, y, z = map(int, xyz) + for i in range(1, bands_num + 1): + data = in_ds.GetRasterBand(i).ReadAsArray() + out_band = out_ds.GetRasterBand(i) + out_data = out_band.ReadAsArray(x, y, x_size, y_size) + data = np.maximum(data, out_data) + out_band.WriteArray(data, x, y) + + del in_ds, out_band, out_ds + + @staticmethod + def dem_clip(OutFilePath, DEMFilePath, SelectArea): + ''' + 根据选择范围裁剪DEM,并输出 + agrs: + outFilePath:裁剪DEM输出地址 + DEMFilePath:被裁减DEM地址 + SelectArea:list [(xmin,ymax),(xmax,ymin)] 框选范围 左上角，右下角 + ''' + DEM_ptr = gdal.Open(DEMFilePath) + DEM_GeoTransform = DEM_ptr.GetGeoTransform() # 读取影像的投影变换 + DEM_InvGeoTransform = gdal.InvGeoTransform(DEM_GeoTransform) + SelectAreaArrayPoints = [gdal.ApplyGeoTransform(DEM_InvGeoTransform, p[0], p[1]) for p in SelectArea] + SelectAreaArrayPoints = list(map(lambda p: (int(p[0]), int(p[1])), SelectAreaArrayPoints)) # 确定坐标 + + [(ulx, uly), (brx, bry)] = SelectAreaArrayPoints + rowCount, colCount = bry - uly, brx - ulx + + # 输出DEM的桌面坐标转换 + Out_Transfrom = list(DEM_GeoTransform) + Out_Transfrom[0] = SelectArea[0][0] + Out_Transfrom[3] = SelectArea[0][1] + + # 构建输出DEM + Bands_num = DEM_ptr.RasterCount + gtiff_driver = gdal.GetDriverByName('GTiff') + datatype = gdal.GDT_UInt16 + out_dem = gtiff_driver.Create(OutFilePath, colCount, rowCount, Bands_num, datatype) + out_dem.SetProjection(DEM_ptr.GetProjection()) + out_dem.SetGeoTransform(Out_Transfrom) + + for i in range(1, Bands_num + 1): + data_band = DEM_ptr.GetRasterBand(i) + out_band = out_dem.GetRasterBand(i) + data = data_band.ReadAsArray(ulx, uly, colCount, rowCount) + out_band.WriteArray(data) + del out_dem + + @staticmethod + def dem_merged(in_dem_path, meta_file_path, out_dem_path): + ''' + DEM重采样函数，默认坐标系为WGS84 + agrs: + in_dem_path: 输入的DEM文件夹路径 + meta_file_path: 输入的xml元文件路径 + out_dem_path: 输出的DEM文件夹路径 + ''' + # 读取文件夹中所有的DEM + dem_file_paths=[os.path.join(in_dem_path,dem_name) for dem_name in os.listdir(in_dem_path) if dem_name.find(".tif")>=0 and dem_name.find(".tif.")==-1] + spatialreference=osr.SpatialReference() + spatialreference.SetWellKnownGeogCS("WGS84") # 设置地理坐标，单位为度 degree # 设置投影坐标，单位为度 degree + spatialproj=spatialreference.ExportToWkt() # 导出投影结果 + # 将DEM拼接成一张大图 + mergeFile =gdal.BuildVRT(os.path.join(out_dem_path,"mergedDEM_VRT.tif"),dem_file_paths) + out_DEM=os.path.join(out_dem_path,"mergedDEM.tif") + gdal.Warp(out_DEM, + mergeFile, + format="GTiff", + dstSRS=spatialproj, + dstNodata=-9999, + outputType=gdal.GDT_Float32) + time.sleep(3) + #gdal.CloseDir(out_DEM) + return out_DEM + + @staticmethod + def bsMap_merged(in_bsMap_path, meta_file_path, out_bsMap_path): + ''' + DEM重采样函数，默认坐标系为WGS84 + agrs: + in_dem_path: 输入的DEM文件夹路径 + meta_file_path: 输入的xml元文件路径 + out_dem_path: 输出的DEM文件夹路径 + ''' + # 读取文件夹中所有的DEM + bsMap_file_paths = [os.path.join(in_bsMap_path, dem_name) for dem_name in os.listdir(in_bsMap_path) if + dem_name.find(".tif") >= 0 and dem_name.find(".tif.") == -1] + spatialreference = osr.SpatialReference() + spatialreference.SetWellKnownGeogCS("WGS84") # 设置地理坐标，单位为度 degree # 设置投影坐标，单位为度 degree + spatialproj = spatialreference.ExportToWkt() # 导出投影结果 + # 将DEM拼接成一张大图 + mergeFile = gdal.BuildVRT(os.path.join(out_bsMap_path, "mergedBsMap_VRT.tif"), bsMap_file_paths) + out_DEM = os.path.join(out_bsMap_path, "MergedBsMap.tif") + gdal.Warp(out_DEM, + mergeFile, + format="GTiff", + dstSRS=spatialproj, + dstNodata=-9999, + outputType=gdal.GDT_Float32) + time.sleep(3) + # gdal.CloseDir(out_DEM) + return out_DEM + + @staticmethod + def tif_merged(in_tif_path, temp_dir, out_tif_path): + ''' + DEM重采样函数，默认坐标系为WGS84 + agrs: + in_dem_path: 输入的DEM文件夹路径 + meta_file_path: 输入的xml元文件路径 + out_dem_path: 输出的DEM文件夹路径 + ''' + # 读取文件夹中所有的DEM + bsMap_file_paths = [os.path.join(in_tif_path, dem_name) for dem_name in os.listdir(in_tif_path) if + dem_name.find(".tif") >= 0 and dem_name.find(".tif.") == -1] + spatialreference = osr.SpatialReference() + spatialreference.SetWellKnownGeogCS("WGS84") # 设置地理坐标，单位为度 degree # 设置投影坐标，单位为度 degree + spatialproj = spatialreference.ExportToWkt() # 导出投影结果 + + # # 将DEM拼接成一张大图 + baseName = os.path.splitext(os.path.basename(bsMap_file_paths[0]))[0] + mergeFile = gdal.BuildVRT(os.path.join(temp_dir, f"{baseName}_VRT.tif"), bsMap_file_paths) + out_DEM = os.path.join(out_tif_path, f"{baseName.split('_Strip')[0]}-ortho.tif") + gdal.Warp(out_DEM, + mergeFile, + format="GTiff", + dstSRS=spatialproj, + srcNodata=0, + dstNodata=-9999, + outputType=gdal.GDT_Float32, + resampleAlg='average') + time.sleep(3) + # gdal.CloseDir(out_DEM) + return out_DEM + + @staticmethod + def dem_resampled(in_dem_path,out_dem_path,samling_f): + in_dem=gdal.Open(in_dem_path,gdalconst.GA_ReadOnly) + width=in_dem.RasterXSize + height=in_dem.RasterYSize + gt=list(in_dem.GetGeoTransform()) + width=width*samling_f + height=height*samling_f + gt=[gt[0],gt[1]/samling_f,gt[2]/samling_f,gt[3],gt[4]/samling_f,gt[5]/samling_f] + driver = gdal.GetDriverByName('GTiff') + output = driver.Create(out_dem_path, width,height, 1,in_dem.GetRasterBand(1).DataType) + output.SetGeoTransform(gt) + output.SetProjection(in_dem.GetProjection()) + # 参数说明 输入数据集、输出文件、输入投影、参考投影、重采样方法(最邻近内插\双线性内插\三次卷积等)、回调函数 + gdal.ReprojectImage(in_dem, output, in_dem.GetProjection(), output.GetProjection(), gdalconst.GRA_CubicSpline,0.0,0.0,) + return out_dem_path + @staticmethod + def dem_resampled_RPC(in_dem_path,refrence_img_path,out_dem_path): + in_dem=gdal.Open(in_dem_path,gdalconst.GA_ReadOnly) + refrence_img=gdal.Open(refrence_img_path,gdalconst.GA_ReadOnly) + width=refrence_img.RasterXSize + height=refrence_img.RasterYSize + gt=list(refrence_img.GetGeoTransform()) + driver = gdal.GetDriverByName('GTiff') + output = driver.Create(out_dem_path, width,height, 1,in_dem.GetRasterBand(1).DataType) + output.SetGeoTransform(gt) + output.SetProjection(refrence_img.GetProjection()) + # 参数说明 输入数据集、输出文件、输入投影、参考投影、重采样方法(最邻近内插\双线性内插\三次卷积等)、回调函数 + gdal.ReprojectImage(in_dem, output, in_dem.GetProjection(), output.GetProjection(), gdalconst.GRA_CubicSpline,0.0,0.0,) + return out_dem_path + # referencefile = gdal.Open(referencefilefilePath, gdal.GA_ReadOnly) + # referencefileProj = referencefile.GetProjection() + # referencefileTrans = referencefile.GetGeoTransform() + # bandreferencefile = referencefile.GetRasterBand(1) + # Width= referencefile.RasterXSize + # Height = referencefile.RasterYSize + # nbands = referencefile.RasterCount + # # 创建重采样输出文件（设置投影及六参数） + # driver = gdal.GetDriverByName('GTiff') + # output = driver.Create(outputfilePath, Width,Height, nbands, bandreferencefile.DataType) + # output.SetGeoTransform(referencefileTrans) + # output.SetProjection(referencefileProj) + # # 参数说明 输入数据集、输出文件、输入投影、参考投影、重采样方法(最邻近内插\双线性内插\三次卷积等)、回调函数 + # gdal.ReprojectImage(inputrasfile, output, inputProj, referencefileProj, gdalconst.GRA_Bilinear,0.0,0.0,) + + +class Orthorectification(object): + """ + 正射校正模块类 + """ + def __init__(self, configPath="./config.ymal") -> None: + super().__init__() + # 常量声明 + # 加载配置文件 + d=os.listdir(".") + with open(configPath, 'r', encoding='utf-8') as f: + const = f.read() + self.config = yaml.load(const, Loader=yaml.FullLoader) + self.config['SatelliteOribit']['StartTime'] = datetime.datetime.strptime( + self.config['SatelliteOribit']['StartTime']['Value'], + self.config['SatelliteOribit']['StartTime']['format']).timestamp() # 转化成UTC时间格式 + self.R_e = self.config['SatelliteOribit']['ReferenceSpheroid']['Re'] # m + self.R_p = self.config['SatelliteOribit']['ReferenceSpheroid']['Rp'] # m + self.w_e = self.config['SatelliteOribit']['ReferenceSpheroid']['we'] # rad/s + + def ParseHearderFile(self, HeaderFilePath_str): + """ + 解析头文件，返回计算所需要的必要信息。 + args: + HeaderFilePath_str: 头文件地址 + return: + HeaderFileInfomation_json: 头文件信息包 + """ + + with open(HeaderFilePath_str, 'r', encoding='utf-8') as fp: + HeaderFile_dom_str = fp.read() + HeaderFile_dom = xmltodict.parse(HeaderFile_dom_str) # 将XML转成json文本 + HeaderFile_dom_json = json.loads(json.dumps(HeaderFile_dom)) # 将json字符串，转成json对象（对应于python中的dict） + # 获取头文件 + HeaderInformation_json = {} + # 解析轨道节点，假定是GPS节点 + HeaderInformation_json['GPS'] = [] + # GPS 解析信息 + GPSNode_Path = self.config['GPS']['GPSNode_Path'] + GPSNodeNames_list = self.config['GPS']['NodeInfomation_Name'] + GPSTime_Format = self.config['GPS']['Time_format'] + GPSPoints = FindInfomationFromJson(HeaderFile_dom_json, GPSNode_Path) + + for GPSPoint in GPSPoints: + GPSPoint = [ + datetime.datetime.strptime(GPSPoint[GPSNodeNames_list[0]], GPSTime_Format).timestamp(), # TimeStamp + float(GPSPoint[GPSNodeNames_list[1]]), # Xp + float(GPSPoint[GPSNodeNames_list[2]]), # Yp + float(GPSPoint[GPSNodeNames_list[3]]), # Zp + float(GPSPoint[GPSNodeNames_list[4]]), # Vx + float(GPSPoint[GPSNodeNames_list[5]]), # Vy + float(GPSPoint[GPSNodeNames_list[6]])] # VZ + HeaderInformation_json['GPS'].append(GPSPoint) + + # 提取成像相关信息 + HeaderInformation_json['ImageInformation'] = {} + # 1、开始成像时间 + HeaderInformation_json['ImageInformation']['StartTime'] = datetime.datetime.strptime( + FindInfomationFromJson(HeaderFile_dom_json, self.config['imageinfo']['StartImageTime']['NodePath']), + self.config['imageinfo']['StartImageTime']['Format'] + ).timestamp() + # 2、结束成像时间 + HeaderInformation_json['ImageInformation']['EndTime'] = datetime.datetime.strptime( + FindInfomationFromJson(HeaderFile_dom_json, self.config['imageinfo']['EndImageTime']['NodePath']), + self.config['imageinfo']['StartImageTime']['Format'] + ).timestamp() + # 3、影像的宽高 + HeaderInformation_json['ImageInformation']['height'] = int( + FindInfomationFromJson(HeaderFile_dom_json, self.config['imageinfo']['ImageHeight']['NodePath'])) + HeaderInformation_json['ImageInformation']['width'] = int( + FindInfomationFromJson(HeaderFile_dom_json, self.config['imageinfo']['ImageWidth']['NodePath'])) + # 4、影像的近斜距 + HeaderInformation_json['ImageInformation']['NearRange'] = float( + FindInfomationFromJson(HeaderFile_dom_json, self.config['imageinfo']['NearRange']['NodePath'])) + # 5、入射角 + HeaderInformation_json['ImageInformation']['incidenceAngle'] = { + 'NearRange': float(FindInfomationFromJson(HeaderFile_dom_json, + self.config['imageinfo']['incidenceAngle']['NearRange'][ + 'NodePath'])), + 'FarRange': float(FindInfomationFromJson(HeaderFile_dom_json, + self.config['imageinfo']['incidenceAngle']['FarRange'][ + 'NodePath'])) + } + # 6、成像时刻影像带宽 + HeaderInformation_json['ImageInformation']['bandWidth'] = float( + FindInfomationFromJson(HeaderFile_dom_json, self.config['sensor']['bandWidth']['NodePath'])) + # 7、多普勒质心常数 + DopplerCentroidCoefficients_list = FindInfomationFromJson(HeaderFile_dom_json, self.config['imageinfo'][ + 'DopplerCentroidCoefficients']['NodePath']) + HeaderInformation_json['ImageInformation']['DopplerCentroidCoefficients'] = [ + float(DopplerCentroidCoefficients_list[ + self.config['imageinfo']['DopplerCentroidCoefficients']['DopplerCentroidCoefficients_Name'][0]]), + float(DopplerCentroidCoefficients_list[ + self.config['imageinfo']['DopplerCentroidCoefficients']['DopplerCentroidCoefficients_Name'][1]]), + float(DopplerCentroidCoefficients_list[ + self.config['imageinfo']['DopplerCentroidCoefficients']['DopplerCentroidCoefficients_Name'][2]]), + float(DopplerCentroidCoefficients_list[ + self.config['imageinfo']['DopplerCentroidCoefficients']['DopplerCentroidCoefficients_Name'][3]]), + float(DopplerCentroidCoefficients_list[ + self.config['imageinfo']['DopplerCentroidCoefficients']['DopplerCentroidCoefficients_Name'][4]]), + ] + # 8、波长 + HeaderInformation_json['ImageInformation']['lambda'] = float( + FindInfomationFromJson(HeaderFile_dom_json, self.config['sensor']['lambda']['NodePath'])) + # 9、中心像元对应的中心经纬度 + CenterPoint = FindInfomationFromJson(HeaderFile_dom_json, + self.config['imageinfo']['CenterImagePositon']['NodePath']) + HeaderInformation_json['ImageInformation']['centerPosition'] = [ + float(CenterPoint[self.config['imageinfo']['CenterImagePositon']['Value'][0]]), # 纬度 + float(CenterPoint[self.config['imageinfo']['CenterImagePositon']['Value'][1]]), # 经度 + ] + # 10、多普勒参数参考时间 + HeaderInformation_json['ImageInformation']['DopplerParametersReferenceTime'] = float( + FindInfomationFromJson(HeaderFile_dom_json, + self.config['imageinfo']['DopplerParametersReferenceTime']['NodePath'])) + # 11、参考斜距 + HeaderInformation_json['ImageInformation']['refRange'] = float( + FindInfomationFromJson(HeaderFile_dom_json, self.config['imageinfo']['ReferenceRange']['NodePath'])) + # 12、PRF + HeaderInformation_json['PRF'] = float( + FindInfomationFromJson(HeaderFile_dom_json, self.config['sensor']['PRF']['NodePath'])) + HeaderInformation_json['Fs'] = float( + FindInfomationFromJson(HeaderFile_dom_json, self.config['sensor']['Fs']['NodePath'])) + # 13、中心时间 + HeaderInformation_json['ImageInformation']['CenterTime'] = datetime.datetime.strptime( + FindInfomationFromJson(HeaderFile_dom_json, self.config['imageinfo']['CenterImageTime']['NodePath']), + self.config['imageinfo']['CenterImageTime']['Format'] + ).timestamp() + # 13.1 中心坐标 + # HeaderInformation_json['ImageInformation']['CenterPosition']=[ + # float(FindInfomationFromJson(HeaderFile_dom_json, ['product', 'platform', 'Xs'])), + # float(FindInfomationFromJson(HeaderFile_dom_json, ['product', 'platform', 'Ys'])), + # float(FindInfomationFromJson(HeaderFile_dom_json, ['product', 'platform', 'Zs'])), + # float(FindInfomationFromJson(HeaderFile_dom_json, ['product', 'platform', 'Vxs'])), + # float(FindInfomationFromJson(HeaderFile_dom_json, ['product', 'platform', 'Vys'])), + # float(FindInfomationFromJson(HeaderFile_dom_json, ['product', 'platform', 'Vzs'])) + # + # ] + + + + #14. 影像的空间间隔分辨率 + HeaderInformation_json['ImageInformation']['ImageWidthSpace']=float( + FindInfomationFromJson(HeaderFile_dom_json, self.config['imageinfo']['ImageWidthSpace']['NodePath'])) + + HeaderInformation_json['ImageInformation']['ImageHeightSpace']=float( + FindInfomationFromJson(HeaderFile_dom_json, self.config['imageinfo']['ImageHeightSpace']['NodePath'])) + + # 部分需要解析 + self.lamda=HeaderInformation_json['ImageInformation']['lambda'] + self.PRF=HeaderInformation_json['PRF'] + self.imgwidth=HeaderInformation_json['ImageInformation']['width'] + self.imgheight=HeaderInformation_json['ImageInformation']['height'] + self.imgstarttime=HeaderInformation_json['ImageInformation']['StartTime'] + self.widthspace=HeaderInformation_json['ImageInformation']['ImageWidthSpace'] + self.heightspace=HeaderInformation_json['ImageInformation']['ImageHeightSpace'] + self.refrange=HeaderInformation_json['ImageInformation']['refRange'] + self.nearrange=HeaderInformation_json['ImageInformation']['NearRange'] + self.Fs = HeaderInformation_json['Fs'] # Mhz todo + return HeaderInformation_json + pass + + + def ParseHearderFile_top(self, HeaderFilePath_str, pol_id): + """ + 解析头文件，返回计算所需要的必要信息。 + args: + HeaderFilePath_str: 头文件地址 + return: + HeaderFileInfomation_json: 头文件信息包 + """ + + with open(HeaderFilePath_str, 'r', encoding='utf-8') as fp: + HeaderFile_dom_str = fp.read() + HeaderFile_dom = xmltodict.parse(HeaderFile_dom_str) # 将XML转成json文本 + HeaderFile_dom_json = json.loads(json.dumps(HeaderFile_dom)) # 将json字符串，转成json对象（对应于python中的dict） + # 获取头文件 + HeaderInformation_json = {} + # 解析轨道节点，假定是GPS节点 + HeaderInformation_json['GPS'] = [] + # GPS 解析信息 + GPSNode_Path = self.config['GPS']['GPSNode_Path'] + GPSNodeNames_list = self.config['GPS']['NodeInfomation_Name'] + GPSTime_Format = self.config['GPS']['Time_format'] + GPSPoints = FindInfomationFromJson(HeaderFile_dom_json, GPSNode_Path) + + for GPSPoint in GPSPoints: + GPSPoint = [ + datetime.datetime.strptime(GPSPoint[GPSNodeNames_list[0]], GPSTime_Format).timestamp(), # TimeStamp + float(GPSPoint[GPSNodeNames_list[1]]), # Xp + float(GPSPoint[GPSNodeNames_list[2]]), # Yp + float(GPSPoint[GPSNodeNames_list[3]]), # Zp + float(GPSPoint[GPSNodeNames_list[4]]), # Vx + float(GPSPoint[GPSNodeNames_list[5]]), # Vy + float(GPSPoint[GPSNodeNames_list[6]])] # VZ + HeaderInformation_json['GPS'].append(GPSPoint) + + # 提取成像相关信息 + HeaderInformation_json['ImageInformation'] = {} + # 1、开始成像时间 + startTimeList = self.config['imageinfo']['SubStartImageTime']['NodePath'] + startTimeList.insert(4, pol_id) + HeaderInformation_json['ImageInformation']['StartTime'] = datetime.datetime.strptime( + FindInfomationFromJson(HeaderFile_dom_json, startTimeList), + self.config['imageinfo']['StartImageTime']['Format'] + ).timestamp() + # 2、结束成像时间 + endTimeList = self.config['imageinfo']['SubEndImageTime']['NodePath'] + endTimeList.insert(4, pol_id) + HeaderInformation_json['ImageInformation']['EndTime'] = datetime.datetime.strptime( + FindInfomationFromJson(HeaderFile_dom_json, endTimeList), + self.config['imageinfo']['StartImageTime']['Format'] + ).timestamp() + # 3、影像的宽高 + temp = FindInfomationFromJson(HeaderFile_dom_json, self.config['imageinfo']['ImageHeight']['NodePath']) + HeaderInformation_json['ImageInformation']['height'] = int( + FindInfomationFromJson(HeaderFile_dom_json, self.config['imageinfo']['ImageHeight']['NodePath']).split(',')[ + pol_id]) + HeaderInformation_json['ImageInformation']['width'] = int( + FindInfomationFromJson(HeaderFile_dom_json, self.config['imageinfo']['ImageWidth']['NodePath']).split(',')[ + pol_id]) + # 4、影像的近斜距 + HeaderInformation_json['ImageInformation']['NearRange'] = float( + FindInfomationFromJson(HeaderFile_dom_json, self.config['imageinfo']['NearRange']['NodePath']).split(',')[ + pol_id]) + # 5、入射角 + HeaderInformation_json['ImageInformation']['incidenceAngle'] = { + 'NearRange': float(FindInfomationFromJson(HeaderFile_dom_json, + self.config['imageinfo']['incidenceAngle']['NearRange'][ + 'NodePath']).split(',')[pol_id]), + 'FarRange': float(FindInfomationFromJson(HeaderFile_dom_json, + self.config['imageinfo']['incidenceAngle']['FarRange'][ + 'NodePath']).split(',')[pol_id]) + } + # 6、成像时刻影像带宽 + bandWidth_list = self.config['sensor']['bandWidth']['NodePath'] + bandWidth_list.insert(4, pol_id) + HeaderInformation_json['ImageInformation']['bandWidth'] = float( + FindInfomationFromJson(HeaderFile_dom_json, bandWidth_list)) + # 7、多普勒质心常数 + DopplerCentroidCoefficients_list = FindInfomationFromJson(HeaderFile_dom_json, self.config['imageinfo']['DopplerCentroidCoefficients']['NodePath']) + HeaderInformation_json['ImageInformation']['DopplerCentroidCoefficients'] = [ + float(DopplerCentroidCoefficients_list[ + self.config['imageinfo']['DopplerCentroidCoefficients']['DopplerCentroidCoefficients_Name'][0]].split(',')[pol_id]), + float(DopplerCentroidCoefficients_list[ + self.config['imageinfo']['DopplerCentroidCoefficients']['DopplerCentroidCoefficients_Name'][1]].split(',')[pol_id]), + float(DopplerCentroidCoefficients_list[ + self.config['imageinfo']['DopplerCentroidCoefficients']['DopplerCentroidCoefficients_Name'][2]].split(',')[pol_id]), + float(DopplerCentroidCoefficients_list[ + self.config['imageinfo']['DopplerCentroidCoefficients']['DopplerCentroidCoefficients_Name'][3]].split(',')[pol_id]), + float(DopplerCentroidCoefficients_list[ + self.config['imageinfo']['DopplerCentroidCoefficients']['DopplerCentroidCoefficients_Name'][4]].split(',')[pol_id]), + ] + # 8、波长 + HeaderInformation_json['ImageInformation']['lambda'] = float( + FindInfomationFromJson(HeaderFile_dom_json, self.config['sensor']['lambda']['NodePath'])) + # 9、中心像元对应的中心经纬度 + CenterPoint = FindInfomationFromJson(HeaderFile_dom_json, + self.config['imageinfo']['CenterImagePositon']['NodePath']) + HeaderInformation_json['ImageInformation']['centerPosition'] = [ + float(CenterPoint[self.config['imageinfo']['CenterImagePositon']['Value'][0]]), # 纬度 + float(CenterPoint[self.config['imageinfo']['CenterImagePositon']['Value'][1]]), # 经度 + ] + # 10、多普勒参数参考时间 + HeaderInformation_json['ImageInformation']['DopplerParametersReferenceTime'] = float( + FindInfomationFromJson(HeaderFile_dom_json, + self.config['imageinfo']['DopplerParametersReferenceTime']['NodePath']).split(',')[pol_id]) + # 11、参考斜距 + HeaderInformation_json['ImageInformation']['refRange'] = float( + FindInfomationFromJson(HeaderFile_dom_json, self.config['imageinfo']['ReferenceRange']['NodePath']).split( + ',')[pol_id]) + # 12、PRF + HeaderInformation_json['PRF'] = float( + FindInfomationFromJson(HeaderFile_dom_json, self.config['sensor']['PRF']['NodePath']).split(',')[pol_id]) + HeaderInformation_json['Fs'] = float( + FindInfomationFromJson(HeaderFile_dom_json, self.config['sensor']['Fs']['NodePath']).split(',')[pol_id]) + # 13、中心时间 + HeaderInformation_json['ImageInformation']['CenterTime'] = datetime.datetime.strptime( + FindInfomationFromJson(HeaderFile_dom_json, self.config['imageinfo']['CenterImageTime']['NodePath']), + self.config['imageinfo']['CenterImageTime']['Format'] + ).timestamp() + # 14. 影像的空间间隔分辨率 + HeaderInformation_json['ImageInformation']['ImageWidthSpace'] = float( + FindInfomationFromJson(HeaderFile_dom_json, self.config['imageinfo']['ImageWidthSpace']['NodePath']).split( + ',')[pol_id]) + + HeaderInformation_json['ImageInformation']['ImageHeightSpace'] = float( + FindInfomationFromJson(HeaderFile_dom_json, self.config['imageinfo']['ImageHeightSpace']['NodePath']).split( + ',')[pol_id]) + + # 部分需要解析 + self.lamda = HeaderInformation_json['ImageInformation']['lambda'] + self.PRF = HeaderInformation_json['PRF'] + self.imgwidth = HeaderInformation_json['ImageInformation']['width'] + self.imgheight = HeaderInformation_json['ImageInformation']['height'] + self.imgstarttime = HeaderInformation_json['ImageInformation']['StartTime'] + self.widthspace = HeaderInformation_json['ImageInformation']['ImageWidthSpace'] + self.heightspace = HeaderInformation_json['ImageInformation']['ImageHeightSpace'] + self.refrange = HeaderInformation_json['ImageInformation']['refRange'] + self.nearrange = HeaderInformation_json['ImageInformation']['NearRange'] + self.Fs = HeaderInformation_json['Fs'] # Mhz + return HeaderInformation_json + pass + + def LLA_to_XYZ(self, latitude, longitude, altitude): + """ + 经纬度转大地坐标系 + args: + latitude:纬度 + longitude:经纬 + altitude:海拔高程 + refrence: https://blog.csdn.net/dulingwen/article/details/96868530 + """ + # 经纬度的余弦值 + cosLat = math.cos(latitude * math.pi / 180) + sinLat = math.sin(latitude * math.pi / 180) + cosLon = math.cos(longitude * math.pi / 180) + sinLon = math.sin(longitude * math.pi / 180) + + # WGS84坐标系的参数 + rad = 6378137.0 # 地球赤道平均半径（椭球长半轴：a） + f = 1.0 / 298.257224 # WGS84椭球扁率 :f = (a-b)/a + C = 1.0 / math.sqrt(cosLat * cosLat + (1 - f) * (1 - f) * sinLat * sinLat) + S = (1 - f) * (1 - f) * C + h = altitude + + # 计算XYZ坐标 + X = (rad * C + h) * cosLat * cosLon + Y = (rad * C + h) * cosLat * sinLon + Z = (rad * S + h) * sinLat + + return np.array([X, Y, Z]).reshape(1, 3) + + def XYZ_to_LLA(self, X, Y, Z): + """ + 大地坐标系转经纬度 + 适用于WGS84坐标系 + args: + x,y,z + return: + lat,lon,altitude + """ + # WGS84坐标系的参数 + a = 6378137.0 # 椭球长半轴 + b = 6356752.314245 # 椭球短半轴 + ea = np.sqrt((a ** 2 - b ** 2) / a ** 2) + eb = np.sqrt((a ** 2 - b ** 2) / b ** 2) + p = np.sqrt(X ** 2 + Y ** 2) + theta = np.arctan2(Z * a, p * b) + + # 计算经纬度及海拔 + longitude = np.arctan2(Y, X) + latitude = np.arctan2(Z + eb ** 2 * b * np.sin(theta) ** 3, p - ea ** 2 * a * np.cos(theta) ** 3) + N = a / np.sqrt(1 - ea ** 2 * np.sin(latitude) ** 2) + altitude = p / np.cos(latitude) - N + + return np.array([np.degrees(latitude), np.degrees(longitude), altitude]) + + def getRByColumnCode(self, c): + """ + 根据列号计算斜距 + args: + c: 列号 + """ + return self.R0 + c * self.delta_R + pass + + def getTimeByLineCode(self, r): + """ + 根据行号计算成像时间 + args: + r: 行号 + """ + return np.matmul( + np.concatenate([np.array([r ** i]).reshape(1, 1) for i in range(self.r2t_A_arr.shape[0])], axis=1), + self.r2t_A_arr) + + def ReconstuctionTimesOflyDirectionPositionModel(self, timePoints_list): + """ + 构建飞行向坐标与时间的转换模型,注意这里没有调整时间的起算点。 + args: + timePoints_list:时间点坐标 [r,t] + """ + # 根据点数确定模型，最高为3次项模型 + Y = np.zeros((len(timePoints_list), 1)) + X = np.zeros((len(timePoints_list), 1)) + + for i in range(len(timePoints_list)): + Y[i, 0] = timePoints_list[i][1] + X[i, 0] = timePoints_list[i][0] + + if len(timePoints_list) == 2: # 一次项 + X = np.concatenate([np.ones((len(timePoints_list), 1)), X], axis=1) + A = np.matmul(np.matmul(np.linalg.inv(np.matmul(X.T, X)), X.T), Y) + + elif len(timePoints_list) >= 3: # 二次项 + X = np.concatenate([np.ones(len(timePoints_list), 1), X, np.power(X, 2)], axis=1) + A = np.matmul(np.matmul(np.linalg.inv(np.matmul(X.T, X)), X.T), Y) + + elif len(timePoints_list) >= 8: # 三次项 + X = np.concatenate([np.ones(len(timePoints_list), 1), X, np.power(X, 2), np.power(X, 3)], axis=1) + A = np.matmul(np.matmul(np.linalg.inv(np.matmul(X.T, X)), X.T), Y) + + self.r2t_A_arr = A + + def PrepareConvertSystem(self): + """ + 计算常量 + 在数据计算之前，提前处理部分常量信息 + 构建r,c到坐标斜距的计算公式 + """ + self.R0 = self.header_info['ImageInformation']['NearRange'] # 起始斜距/近斜距 + self.ReconstuctionTimesOflyDirectionPositionModel([ + [0, self.header_info['ImageInformation']['StartTime']], + [self.header_info['ImageInformation']['height'] - 1, self.header_info['ImageInformation']['EndTime']] + ]) # 构建坐标到时间的变换，这里仅用两个数据点构建 + self.delta_R = self.widthspace + + + + + def ConvertCoordinary(self): + """ + 批量求解点坐标 + """ + pass + + def Orthorectification(self, FilePath_str): + """ + 正射校正组件 + 正射校正整体可以分为两个步骤： + Step 1：计算出栅格坐标对应的真实的大地坐标系坐标 + Step 2：根据大地坐标系将影像重采样到大地坐标系空间中 + args: + FilePath_str:影像所在文件夹 + """ + # 分离需要校正对象 + file_name_list = os.listdir(FilePath_str) + header_name = [file_name for file_name in file_name_list if + file_name.rfind(".meta.xml") == len(file_name) - len('.meta.xml')][0] # xml头文件，存储在list中 + tiff_name = [file_name for file_name in file_name_list if + file_name.rfind(".tiff") == len(file_name) - len('.tiff')] # tif影像文件，存储在list中 + # 解析头文件 + self.header_info = self.ParseHearderFile(os.path.join(FilePath_str, header_name)) + # 构建轨道模型 + self.SatelliteOrbitModel = ReconstructionSatelliteOrbit(self.header_info['GPS'], + starttime=self.config['SatelliteOribit']['StartTime']) + # 求解模型前计算常数变换模型 + self.PrepareConvertSystem() + # 批量计算空间坐标 + self.ConvertCoordinary() + +''' +卫星轨道定位法，修改为静态类 +间接定法法，模拟SAR方法的静态方法，与类独立，方便使用多进程 +''' +def getSatelliteSpaceState(time_array,SatelliteOrbitModelstarttime,SatelliteOrbitModelParameters=None,SatelliteOrbitModelName="多项式"): + if SatelliteOrbitModelName=="多项式": + if SatelliteOrbitModelParameters is None: + return None # 返回None,表示没有结果 + n=time_array.shape[0] + result_arr_=np.zeros((n,6),dtype=np.float64) + time_float = time_array - SatelliteOrbitModelstarttime + time_float=time_float.reshape(-1) # nx1 + time_arr=np.ones((time_float.shape[0],5)) # nx5 + time_arr[:,1]=time_float + time_arr[:,2]=time_float**2 + time_arr[:,3]=time_float**3 + time_arr[:,4]=time_float**4 + result_arr_=np.matmul(time_arr,SatelliteOrbitModelParameters) # nx5 5x6 + #time_arr[0, 4] = time_arr[0, 3] * time_float ** 4 + #result_arr=result_arr_ + return result_arr_ # 位置矩阵 + +''' +双线性重采样 +''' +def LinearSampling(ori_dem,sampling_f,offset_row=1,offset_col=1): + ''' + 简化双线性重采样模型 + 根据重采样率对原始对象进行重采样。 + 双线性重采样，这里去栅格所涉及的四个角点作为起算点。 + 模型示意图： + + y1 r1 y2 + + r + + y3 r2 y4 + args: + ori_dem:原始DEM + sampling_f:采样率 int + return: + new_dem:采样结果 + ''' + # 原始dem的行列号 + ori_height=ori_dem.shape[0]-offset_row + ori_width=ori_dem.shape[1]-offset_col + + # 采样之后的影像的范围大小 + new_height=int(ori_height*sampling_f) + new_width=int(ori_width*sampling_f) + # 获取采样之后的栅格单元对应的原DEM的行列号 + row_index_list=list(range(new_height)) + col_index_list=list(range(new_width)) + + new_dem=np.ones((new_height,new_width)) + row_index_arr=(new_dem.transpose(1,0)*row_index_list).transpose(1,0) + col_index_arr=new_dem*col_index_list + row_index_arr=row_index_arr*1.0/sampling_f + col_index_arr=col_index_arr*1.0/sampling_f + # 初始化 + new_dem=0 + # 计算权重 + row_index_arr=row_index_arr.reshape(-1) + col_index_arr=col_index_arr.reshape(-1) + last_row_index_arr=np.floor(row_index_arr).astype(np.int32) + next_row_index_arr=np.ceil(row_index_arr).astype(np.int32) + last_col_index_arr=np.floor(col_index_arr).astype(np.int32) + next_col_index_arr=np.ceil(col_index_arr).astype(np.int32) + # 双线性重采样模型示意图， + # y1 r1 y2 + # + # r + # + # y3 r2 y4 + # 计算重采样 + + R1=ori_dem[last_row_index_arr,last_col_index_arr]*(col_index_arr-last_col_index_arr)+ori_dem[last_row_index_arr,next_col_index_arr]*(next_col_index_arr-col_index_arr) + R2=ori_dem[next_row_index_arr,last_col_index_arr]*(col_index_arr-last_col_index_arr)+ori_dem[next_row_index_arr,next_col_index_arr]*(next_col_index_arr-col_index_arr) + new_dem=R1*(row_index_arr-last_row_index_arr)+R2*(next_row_index_arr-row_index_arr) # 双线性重采样 + new_dem=new_dem.reshape(new_height,new_width) + del R1,R2,next_row_index_arr,next_col_index_arr,last_row_index_arr,last_col_index_arr,row_index_arr,col_index_arr + result_dem=np.ones((new_height,new_width,3)) + result_dem[:,:,2]=new_dem + result_dem[:,:,0]=(np.ones((new_height,new_width)).transpose(1,0)*list(range(new_height))).transpose(1,0) + result_dem[:,:,1]=np.ones((new_height,new_width))*col_index_list + + return result_dem + + pass + + +class IndirectOrthorectification(Orthorectification): + """ + 间接定位法 + """ + def outParameterText(self,outparameter_path): + ''' + 生成配置文件 + ''' + with open(outparameter_path,"w",encoding='utf-8') as fp: + # 输出文件 + fp.write("{}\n".format(self.header_info['ImageInformation']['height'])) + fp.write("{}\n".format(self.header_info['ImageInformation']['width'])) + fp.write("{}\n".format(self.header_info['ImageInformation']['NearRange'])) # 近斜距 + fp.write("{}\n".format(self.header_info['ImageInformation']['incidenceAngle']['NearRange'])) # 近斜距入射角 + fp.write("{}\n".format(self.header_info['ImageInformation']['incidenceAngle']['FarRange'])) # 远距入射角 + fp.write("{}\n".format(self.config['LightSpeed'])) # 光速 + fp.write("{}\n".format(self.header_info['ImageInformation']['lambda'])) + fp.write("{}\n".format(self.header_info['ImageInformation']['StartTime'])) + fp.write("{}\n".format(self.header_info['PRF'])) + fp.write("{}\n".format(self.refrange)) + fp.write("{}\n".format(self.Fs)) + fp.write("{}\n".format(self.header_info['ImageInformation']['DopplerParametersReferenceTime'])) + #fp.write("{}\n".format(self.widthspace)) + + # 多普勒系数 + fp.write("{}\n".format(len(self.header_info['ImageInformation']['DopplerCentroidCoefficients']))) + for i in range(len(self.header_info['ImageInformation']['DopplerCentroidCoefficients'])): + fp.write("{}\n".format(self.header_info['ImageInformation']['DopplerCentroidCoefficients'][i])) + fp.write("{}\n".format(1)) + fp.write("{}\n".format(self.SatelliteOrbitModel.polynum)) + fp.write("{}\n".format(self.SatelliteOrbitModel.get_starttime())) + # X + for i in range(self.SatelliteOrbitModel.polynum+1): + fp.write("{}\n".format(self.SatelliteOrbitModel.A_arr[i,0])) + # Y + for i in range(self.SatelliteOrbitModel.polynum+1): + fp.write("{}\n".format(self.SatelliteOrbitModel.A_arr[i,1])) + # Z + for i in range(self.SatelliteOrbitModel.polynum+1): + fp.write("{}\n".format(self.SatelliteOrbitModel.A_arr[i,2])) + # Vx + for i in range(self.SatelliteOrbitModel.polynum+1): + fp.write("{}\n".format(self.SatelliteOrbitModel.A_arr[i,3])) + # Vy + for i in range(self.SatelliteOrbitModel.polynum+1): + fp.write("{}\n".format(self.SatelliteOrbitModel.A_arr[i,4])) + # vz + for i in range(self.SatelliteOrbitModel.polynum+1): + fp.write("{}\n".format(self.SatelliteOrbitModel.A_arr[i,5])) + # UTC参数 + startTime=time.localtime(self.header_info['ImageInformation']["StartTime"]) + fp.write("{}\n".format(startTime.tm_year)) + fp.write("{}\n".format(startTime.tm_mon)) + fp.write("{}".format(startTime.tm_mday)) + + self.paramterFile_path=outparameter_path + + + + def IndirectOrthorectification(self, FilePath_str,workspace_dir): + """ + 正射校正组件 + 正射校正整体可以分为两个步骤： + Step 1：计算出栅格坐标对应的真实的大地坐标系坐标 + Step 2：根据大地坐标系将影像重采样到大地坐标系空间中 + args: + FilePath_str：影像所在文件夹 + dem_resampled_path：重采样后的DEM路径 + lut_tif_path：输出的r,c,ti数据影像 + work_temp_path: 输出的临时文件地址路径，方便存放计算临时文件 + """ + # 分离需要校正对象 + file_name_list = os.listdir(FilePath_str) + # header_name = [file_name for file_name in file_name_list if + # file_name.rfind(".meta.xml") == len(file_name) - len('.meta.xml')][0] # 头文件 + header_name = [file_name for file_name in file_name_list if + file_name.rfind(".xml") == len(file_name) - len('.xml')][0] # 头文件 + tiff_name = [file_name for file_name in file_name_list if + file_name.rfind(".tiff") == len(file_name) - len('.tiff')] # 影像文件 + # 解析头文件 + self.header_info = self.ParseHearderFile(os.path.join(FilePath_str, header_name)) + # 构建轨道模型 + self.SatelliteOrbitModel = ReconstructionSatelliteOrbit(self.header_info['GPS'], + starttime=self.header_info['ImageInformation']['CenterTime']) # 构建卫星轨道模型,取第0个节点的时间 + # 获取所有轨道节点时间 + gpslist=np.array(self.header_info['GPS']).reshape(-1,7) + # 验证轨道模型 + statepoints=self.SatelliteOrbitModel.getSatelliteSpaceState(gpslist[:,0].reshape(-1)) + # 计算轨道差距 + statepoints_dist=statepoints-gpslist[:,1:] + statepoints_dist_line=statepoints_dist[:,:3] + statepoints_dist_line=np.sum(statepoints_dist_line**2,axis=1)**0.5 + + statepoints_dist_ver=np.sum(statepoints_dist[:,3:]**2,axis=1)**0.5 + # print(statepoints_dist_ver.tolist()) + print("sata Point distance:\t{}\t -\t{}\t ".format(np.min(statepoints_dist_line),np.max(statepoints_dist_line))) + # statepoints_center = self.SatelliteOrbitModel.getSatelliteSpaceState(np.array([self.header_info['ImageInformation']['CenterTime']])) + # center_dist=statepoints_center-np.array(self.header_info['ImageInformation']['CenterPosition']) + # + # print("{}\n{}\ndistance center:{}\n".format(statepoints_center.tolist(),self.header_info['ImageInformation']['CenterPosition'],np.sqrt(np.sum(center_dist**2)))) + # 求解模型前计算常数变换模型 + self.PrepareConvertSystem() + self.outParameterText(os.path.join(workspace_dir,"orth_para.txt")) + + def IndirectOrthorectification_top(self, xml_path, tif_path, workspace_dir): + """ + 正射校正组件 + 正射校正整体可以分为两个步骤： + Step 1：计算出栅格坐标对应的真实的大地坐标系坐标 + Step 2：根据大地坐标系将影像重采样到大地坐标系空间中 + args: + FilePath_str：影像所在文件夹 + dem_resampled_path：重采样后的DEM路径 + lut_tif_path：输出的r,c,ti数据影像 + work_temp_path: 输出的临时文件地址路径，方便存放计算临时文件 + """ + # 分离需要校正对象 + pol_id = os.path.splitext(os.path.basename(tif_path))[0].split('_')[-1] + # 解析头文件 + self.header_info = self.ParseHearderFile_top(xml_path, int(pol_id[-1:])) + # 构建轨道模型 + self.SatelliteOrbitModel = ReconstructionSatelliteOrbit(self.header_info['GPS'], + starttime=self.header_info['ImageInformation'][ + 'CenterTime']) # 构建卫星轨道模型,取第0个节点的时间 + # 获取所有轨道节点时间 + gpslist = np.array(self.header_info['GPS']).reshape(-1, 7) + # 验证轨道模型 + tempp = gpslist[:, 0].reshape(-1) + statepoints = self.SatelliteOrbitModel.getSatelliteSpaceState(gpslist[:, 0].reshape(-1)) + # 计算轨道差距 + statepoints_dist = statepoints - gpslist[:, 1:] + statepoints_dist_line = statepoints_dist[:, :3] + statepoints_dist_line = np.sum(statepoints_dist_line ** 2, axis=1) ** 0.5 + + statepoints_dist_ver = np.sum(statepoints_dist[:, 3:] ** 2, axis=1) ** 0.5 + print( + "sata Point distance:\t{}\t -\t{}\t ".format(np.min(statepoints_dist_line), np.max(statepoints_dist_line))) + + # 求解模型前计算常数变换模型 + self.PrepareConvertSystem() + self.outParameterText(os.path.join(workspace_dir, "orth_para.txt")) + + def preCaldem_sar_rc(self,dem_path,ori_sar_path,work_path,taget_path): + #.\SIMOrthoProgram-S-SAR\x64\Release\SIMOrthoProgram-S-SAR.exe 1 parameter_path dem_path ori_sar_path work_path taget_path + # SIMOrthoProgram-S-SAR.exe 1 in_parameter_path in_dem_path in_ori_sar_path in_work_path in_taget_path + exe_path=r".\baseTool\x64\Release\SIMOrthoProgram-S-SAR.exe" + exe_cmd=r"set PROJ_LIB=.\baseTool\x64\Release; & {0} {1} {2} {3} {4} {5} {6} {7}".format(exe_path,1,self.paramterFile_path,dem_path,ori_sar_path,work_path ,taget_path,"\\") + print(exe_cmd) + print(os.system(exe_cmd)) + print("==========================================================================") + + def getRPC_incidenceAngle(self,in_dem_path,in_rpc_rc_path,out_rpc_dem_path,out_incident_angle_path,out_local_incident_angle_path): + ''' + std::cout << "mode 4: get RPC incident and local incident angle sar model:"; + std::cout << "SIMOrthoProgram-S-SAR.exe 4 in_parameter_path in_dem_path in_rpc_rc_path out_rpc_dem_path out_incident_angle_path out_local_incident_angle_path"; + + ''' + exe_path=r".\baseTool\x64\Release\SIMOrthoProgram-S-SAR.exe" + exe_cmd=r"set PROJ_LIB=.\baseTool\x64\Release; & {0} {1} {2} {3} {4} {5} {6} {7}".format(exe_path,4,self.paramterFile_path,in_dem_path,in_rpc_rc_path,out_rpc_dem_path,out_incident_angle_path,out_local_incident_angle_path) + print(exe_cmd) + print(os.system(exe_cmd)) + print("==========================================================================") + + def getRPC_incidenceAngle_lon_lat(self,in_dem_path,in_gec_lon_lat_path,work_path,taget_path,out_incident_angle_path,out_local_incident_angle_path,out_incangle_geo_path,out_localincangle_geo_path): + ''' + std::cout << "mode 7: get RPC incident and local incident angle sar model:"; + std::cout << "SIMOrthoProgram-S-SAR.exe 7 in_parameter_path in_dem_path in_gec_lon_lat_path work_path taget_path out_incident_angle_path out_local_incident_angle_path"; + + ''' + cwd_path = os.getcwd() + print("cwd_path:" + cwd_path) + exe_path=r"{}\baseTool\x64\Release\SIMOrthoProgram-S-SAR.exe".format(cwd_path) + exe_cmd=r"set PROJ_LIB=.\baseTool\x64\Release; & {0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10}".format(exe_path,7,self.paramterFile_path,in_dem_path,in_gec_lon_lat_path,work_path,taget_path,out_incident_angle_path,out_local_incident_angle_path,out_incangle_geo_path,out_localincangle_geo_path) + print(exe_cmd) + print(os.system(exe_cmd)) + print("==========================================================================") + + def get_incidenceAngle(self,in_dem_path,in_rc_wgs84_path,out_incident_angle_path,out_local_incident_angle_path): + ''' + std::cout << "mode 2: get incident angle and local incident angle by rc_wgs84 and dem and statellite model:\n"; + std::cout << "SIMOrthoProgram-S-SAR.exe 2 in_parameter_path in_dem_path in_rc_wgs84_path out_incident_angle_path out_local_incident_angle_path"; + ''' + exe_path=r".\baseTool\x64\Release\SIMOrthoProgram-S-SAR.exe" + exe_cmd=r"set PROJ_LIB=.\baseTool\x64\Release; & {0} {1} {2} {3} {4} {5} {6}".format(exe_path,2,self.paramterFile_path,in_dem_path,in_rc_wgs84_path,out_incident_angle_path,out_local_incident_angle_path) + print(exe_cmd) + print(os.system(exe_cmd)) + print("==========================================================================") + def get_GEC_incidenceAngle(self,in_dem_path,in_gec_lon_lat_path,out_incident_angle_path,out_local_incident_angle_path): + ''' + std::cout << "mode 6: get gec incident and local incident angle sar model:"; + std::cout << "SIMOrthoProgram-S-SAR.exe 6 in_parameter_path in_dem_path in_gec_lon_lat_path out_incident_angle_path out_local_incident_angle_path"; + ''' + exe_path=r".\baseTool\x64\Release\SIMOrthoProgram-S-SAR.exe" + exe_cmd=r"set PROJ_LIB=.\baseTool\x64\Release; & {0} {1} {2} {3} {4} {5} {6}".format(exe_path,6,self.paramterFile_path,in_dem_path,in_gec_lon_lat_path,out_incident_angle_path,out_local_incident_angle_path) + print(exe_cmd) + print(os.system(exe_cmd)) + print("==========================================================================") + def get_GTC_SAR(self,in_rc_wgs84_path,in_ori_sar_path,out_orth_sar_path,modecode=3): + ''' + std::cout << "mode 3: interpolation(cubic convolution) orth sar value by rc_wgs84 and ori_sar image and model:\n "; + std::cout << "SIMOrthoProgram-S-SAR.exe 3 in_parameter_path in_rc_wgs84_path in_ori_sar_path out_orth_sar_path"; + ''' + exe_path=r".\baseTool\x64\Release\SIMOrthoProgram-S-SAR.exe" + exe_cmd=r"set PROJ_LIB=.\baseTool\x64\Release; & {0} {1} {2} {3} {4} {5}".format(exe_path,modecode,self.paramterFile_path,in_rc_wgs84_path,in_ori_sar_path,out_orth_sar_path) + print(exe_cmd) + print(os.system(exe_cmd)) + print("==========================================================================") + + def inter_Range2Geo(self,lon_lat_path , data_tiff , grid_path , space): + ''' + # std::cout << "mode 10"; + # std::cout << "SIMOrthoProgram-S-SAR.exe 10 lon_lat_path data_tiff grid_path space"; + ''' + exe_path=r".\baseTool\x64\Release\SIMOrthoProgram-S-SAR.exe" + exe_cmd=r"set PROJ_LIB=.\baseTool\x64\Release; & {0} {1} {2} {3} {4} {5}".format(exe_path,10,lon_lat_path , data_tiff , grid_path , space) + print(exe_cmd) + print(os.system(exe_cmd)) + print("==========================================================================") + + def calInterpolation_cubic_Wgs84_rc_sar_sigma(self, parameter_path, dem_rc, in_sar, out_sar): + ''' + # std::cout << "mode 10"; + # std::cout << "SIMOrthoProgram-S-SAR.exe 9 in_parameter_path in_rc_wgs84_path in_ori_sar_path out_orth_sar_path"; + ''' + exe_path = r".\baseTool\x64\Release\SIMOrthoProgram-S-SAR.exe" + exe_cmd = r"set PROJ_LIB=.\baseTool\x64\Release; & {0} {1} {2} {3} {4} {5}".format(exe_path, 9, parameter_path, + dem_rc, in_sar, out_sar) + print(exe_cmd) + print(os.system(exe_cmd)) + print("==========================================================================") + + def calInterpolation_bil_Wgs84_rc_sar_sigma(self, parameter_path, dem_rc, in_sar, out_sar): + ''' + # std::cout << "mode 11"; + # std::cout << "SIMOrthoProgram-S-SAR.exe 11 in_parameter_path in_rc_wgs84_path in_ori_sar_path out_orth_sar_path"; + ''' + exe_path = r".\baseTool\x64\Release\SIMOrthoProgram-S-SAR.exe" + exe_cmd = r"set PROJ_LIB=.\baseTool\x64\Release; & {0} {1} {2} {3} {4} {5}".format(exe_path, 11, parameter_path, + dem_rc, in_sar, out_sar) + print(exe_cmd) + print(os.system(exe_cmd)) + print("==========================================================================") + + def get_offset(self, baseMap, in_sar, in_sar_sigma): + exe = r".\baseTool\x64\calOffset\calOffset.exe" + exe_cmd = r"set PROJ_LIB=.\baseTool\x64\Release; & {0} {1} {2} {3}".format(exe, baseMap, in_sar, in_sar_sigma) + print(exe_cmd) + print(os.system(exe_cmd)) + print("==========================================================================") + + def lee_process_sar(self,in_sar, out_sar, win_size, noise_var): + ''' + # std::cout << "mode 12" + # std::cout << "SIMOrthoProgram-S-SAR.exe 12 in_sar_path out_sar_path win_size noise_var" + ''' + exe_path = r".\baseTool\x64\Release\SIMOrthoProgram-S-SAR.exe" + exe_cmd = r"set PROJ_LIB=.\baseTool\x64\Release; & {0} {1} {2} {3} {4} {5}".format(exe_path, 12, in_sar, + out_sar, win_size, noise_var) + print(exe_cmd) + print(os.system(exe_cmd)) + print("==========================================================================") + + + def getPowerTif(self,in_ori_path,out_power_path): + ''' + std::cout << "mode 5: convert ori tiff to power tiff:"; + std::cout << "SIMOrthoProgram-S-SAR.exe 5 in_ori_path out_power_path"; + ''' + exe_path=r".\baseTool\x64\Release\SIMOrthoProgram-S-SAR.exe" + exe_cmd=r"set PROJ_LIB=.\baseTool\x64\Release; & {0} {1} {2} {3} ".format(exe_path,5,in_ori_path,out_power_path) + print(exe_cmd) + print(os.system(exe_cmd)) + print("==========================================================================") + + def test_PSTN(self): + landpoint=np.array([-1945072.5,5344083.0,2878316.0]).reshape(1,3) + # 间接定位法所需的参数 + Doppler_d = np.array(self.header_info['ImageInformation']['DopplerCentroidCoefficients']).reshape(-1, 1) + LightSpeed = self.config['LightSpeed'] + T0 = self.header_info['ImageInformation']['refRange'] * 2 / LightSpeed + lamda = self.header_info['ImageInformation']['lambda'] + StartTime = self.header_info['ImageInformation']['StartTime'] + PRF = self.header_info['PRF'] + R0 = self.header_info['ImageInformation']['NearRange'] + r,c,ti=self.PSTN_block(landpoint, Doppler_d, StartTime, lamda, T0, LightSpeed, PRF, R0) + + pass + def findInitPoint(self,sim_mask,dem_gt,sim_r_tif,sim_c_tif,sampling_f): + + # 根据采样点，大致计算出影像的仿射矩阵，并以此进行外扩 + sampling_f=sampling_f//10 + [r_ids,c_ids]=np.where(sim_mask==1) + sim_r_ids=sim_r_tif[r_ids,c_ids] + sim_c_ids=sim_c_tif[r_ids,c_ids] + X=dem_gt[0]+dem_gt[1]*c_ids+dem_gt[2]*r_ids + Y=dem_gt[3]+dem_gt[4]*c_ids+dem_gt[5]*r_ids + # 首先计算X 变换式 + sim_r_ids=sim_r_ids.reshape(-1,1) + sim_c_ids=sim_c_ids.reshape(-1,1) + X=X.reshape(-1,1) + Y=Y.reshape(-1,1) + point_count=sim_c_ids.shape[0] + X_input=np.ones((point_count,3)) + X_input[:,1]=sim_c_ids[:,0] + X_input[:,2]=sim_r_ids[:,0] + A_X=np.matmul(np.matmul(np.linalg.inv(np.matmul(X_input.T,X_input)), X_input.T), X).reshape(-1,1) + A_Y=np.matmul(np.matmul(np.linalg.inv(np.matmul(X_input.T,X_input)), X_input.T), Y).reshape(-1,1) + + sar_gt=[A_X[0,0],A_X[1,0],A_X[2,0],A_Y[0,0],A_Y[1,0],A_Y[2,0]] + width=self.header_info['ImageInformation']['width'] + height=self.header_info['ImageInformation']['height'] + width_f=self.header_info['ImageInformation']['width']/width + height_f=self.header_info['ImageInformation']['height']/height + sar_gt[1]=sar_gt[1]*width_f + sar_gt[2]=sar_gt[2]*height_f + sar_gt[4]=sar_gt[4]*width_f + sar_gt[5]=sar_gt[5]*height_f + # 外扩 + sar_gt[0]=sar_gt[0]+sar_gt[1]*-60+sar_gt[2]*-60 + sar_gt[3]=sar_gt[3]+sar_gt[4]*-60+sar_gt[5]*-60 + + inv_sar_gt=gdal.InvGeoTransform(sar_gt) + for dem_height in [0,sim_mask.shape[0]-1]: + for dem_width in [0,sim_mask.shape[1]-1]: + dem_edge_x=dem_gt[0]+dem_gt[1]*dem_width+dem_gt[2]*dem_height + dem_edge_y=dem_gt[3]+dem_gt[4]*dem_width+dem_gt[5]*dem_height + c_width=inv_sar_gt[0]+inv_sar_gt[1]*dem_edge_x+inv_sar_gt[2]*dem_edge_y + r_height=inv_sar_gt[3]+inv_sar_gt[4]*dem_edge_x+inv_sar_gt[5]*dem_edge_y + if c_width<=0 or r_height<=0: + continue + width=width+120 if width+120=-3000)&(sim_r_tif=0)&(sim_c_tif=0 else 0 + c_min=c_min-len_col if c_min-len_col>=0 else 0 + r_max=r_max+len_row if r_max+len_row=0)&(r_int=0)&(c_int0: # 可以进行行前推 + start_row=1 # 因为外推了一行 + else: # 不可以进行行前推 + start_row=0 # 此时没有外推一行 + if i+block_height_width>=row_count: # 不存在行后推 + if i>0: # 存在行前推， + end_row=start_row+block_row_count-1 + else: # 不存在行前推 + end_row=start_row+block_row_count + else: # 存在行后推 + if i>0: # 存在行前推 + end_row=start_row+block_row_count-2 + else: # 不存在行前推 + end_row=start_row+block_row_count-1 + pass + # 确定列的范围 + if j>0: # 存在列前推 + start_col=1 + else: # 不存在列前推 + start_col=0 + if j+block_height_width>=col_count: # 不存在列后推 + if j>0: # 存在列前推 + end_col=start_col+block_col_count-1 + else: # 不存在列前推 + end_col=start_col+block_col_count + else: # 存在列后推 + if j>0: # 存在列前推 + end_col=start_col+block_col_count-2 + else: # 不存在列前推 + end_col=start_col+block_col_count-1 + pass + return [start_row,start_col,end_row,end_col] + + def CalIntensityResampled(self,TargetPosition,ti,min_theta=0,max_theta=1): + '''计算入射角 + agrs: + TargetPosition: 地面坐标 nxmx3 + ti:对应的卫星空间位置 nxm + return: + Intensity:入射角阵，-9999 不参与运算 + ''' + # 1 + # 2 0 4 + # 3 + # n=(n12+n23+n34+n41)/4 + # n=(n24xn31)/4 + # 计算 n24=n4-n2 + n24=TargetPosition[:,2:,:]-TargetPosition[:,:-2,:] # 4-2 2: 5070x5068 + n24=n24[1:-1,:,:] + # 计算 n31=n1-n3 + n31=TargetPosition[:-2,:,:]-TargetPosition[2:,:,:] # 1-3 5068x5070 + n31=n31[:,1:-1,:] + # 计算坡度平面向量 + N=np.zeros((n31.shape[0],n31.shape[1],n31.shape[2])) + # n24=[a,b,c] + # n31=[d,f,g] + N[:,:,0]=n24[:,:,1]*n31[:,:,2]-n24[:,:,2]*n31[:,:,1] # bg-cf + N[:,:,1]=n24[:,:,2]*n31[:,:,0]-n24[:,:,0]*n31[:,:,2] # cd-ag + N[:,:,2]=n24[:,:,0]*n31[:,:,1]-n24[:,:,1]*n31[:,:,0] # af-bd + N=N*0.25 # 平面坡度向量 + N=N.reshape(-1,3) + del n24,n31 + n=ti.shape[0] + m=ti.shape[1] + # 分块计算 + theta=np.ones((n-2,m-2)).astype(bool) + ti=ti[1:-1,1:-1] + TargetPosition=TargetPosition[1:-1,1:-1] + TargetPosition=TargetPosition.reshape(-1,3) + ti=ti.reshape(-1) + theta=theta.reshape(-1) + # 分块计算 + le_iter=4000 + for i in range(0,theta.shape[0],le_iter): + len_ti=le_iter + if len_ti+i>theta.shape[0]: + len_ti=theta.shape[0]-i + end_i=i+len_ti + # 计算卫星空间坐标 + R_sp = self.SatelliteOrbitModel.getSatelliteSpaceState(ti[i:end_i])[:, :3]-TargetPosition[i:end_i] + # 夹角=arccos((R_sp*N)/(|R_sp|*|N|)) + theta_=np.sum(R_sp*N[i:end_i],axis=1)/(np.sum(R_sp**2,axis=1)*np.sum(N[i:end_i],axis=1)) + theta[i:end_i]=(theta_>min_theta)&(theta_ self.header_info['ImageInformation']['height']+sampling_f*2: + return False,ti[-1,0] + if np.max(c)<-1*sampling_f*2 or np.min(c) > self.header_info['ImageInformation']['width']+sampling_f*2: + return False,ti[-1,0] + return True + + def ConvertCoordinary_test(self, dem_merged_path, sim_out_path,work_temp_path, flag=1): + + print("当前python程序，内存占用 {}G".format(psutil.Process(os.getpid()).memory_info().rss / 1024 / 1024 / 1024)) + """ + 批量求解点坐标的性能改进： + 主要针对数据频繁开关文件读写 + flag:是否想要经纬度转大地坐标系 + """ + start = time.time() + # 间接定位法所需的参数 + Doppler_d = np.array(self.header_info['ImageInformation']['DopplerCentroidCoefficients']).reshape(-1, 1) + LightSpeed = self.config['LightSpeed'] + T0 = self.header_info['ImageInformation']['refRange'] * 2 / LightSpeed + lamda = self.header_info['ImageInformation']['lambda'] + StartTime = self.header_info['ImageInformation']['StartTime'] + PRF = self.header_info['PRF'] + R0 = self.header_info['ImageInformation']['NearRange'] + # 计算采样率 + + # 读取影像 + dem_resampled_tiff = gdal.Open(dem_merged_path) + row_count = dem_resampled_tiff.RasterYSize # 读取图像的行数 + col_count = dem_resampled_tiff.RasterXSize # 读取图像的列数 + im_proj = dem_resampled_tiff.GetProjection() + im_geotrans = list(dem_resampled_tiff.GetGeoTransform()) + gt = im_geotrans # 坐标变换参数 + # 计算采样率 + sampling_f=self.CalSamplingRateOfDEM(dem_resampled_tiff) + + # 创建目标虚拟影像 + SAR_width=self.header_info['ImageInformation']['width'] + SAR_height=self.header_info['ImageInformation']['height'] + + SAR_row_col_array=np.zeros((row_count,col_count,2),np.float32) + + for ii in range(0,row_count,3000): + if ii==row_count: + continue + altii=dem_resampled_tiff.GetRasterBand(1).ReadAsArray(0, ii, col_count, 3000) + if altii is None: + # 长度过长，设置行数 + altii=dem_resampled_tiff.GetRasterBand(1).ReadAsArray(0, ii, col_count, int(row_count-ii)) + pass + h=int(altii.shape[0]) + w=int(altii.shape[1]) + y_pixel=(np.ones((w,h))*range(h)+ii).transpose(1,0) + x_pixel=np.ones((h,w))*range(w) + lat=gt[0]+gt[1]*x_pixel+gt[2]*y_pixel # 经度 + lon=gt[3]+gt[4]*x_pixel+gt[5]*y_pixel # 纬度 + #del x_pixel,y_pixel + #gc.collect() + [X, Y, Z] = OrthoAuxData.LLA2XYZM(lat.reshape(-1,1), lon.reshape(-1,1), altii.reshape(-1,1)) # 计算错误 + TargetPosition = np.ones((int(h*w), 3), dtype=np.float32) + TargetPosition[:, 0] = X.reshape(-1) + TargetPosition[:, 1] = Y.reshape(-1) + TargetPosition[:, 2] = Z.reshape(-1) + r, c, ti = self.PSTN_M(TargetPosition, Doppler_d, StartTime, lamda, T0, LightSpeed, PRF, R0) # 间接定位法，核心求解代码 + + SAR_row_col_array[ii:ii+h,:,0]=r.reshape(-1,col_count) + SAR_row_col_array[ii:ii+h,:,1]=c.reshape(-1,col_count) + gtiff_driver = gdal.GetDriverByName('GTiff') + SAR_row_col=gtiff_driver.Create(sim_out_path.replace(".tif","rc.tif"),col_count,row_count,2,gdal.GDT_Float32) + SAR_row_col.SetGeoTransform(im_geotrans) # 写入仿射变换参数 + SAR_row_col.SetProjection(im_proj) # 写入投影 + # 写入tiff + SAR_row_col.GetRasterBand(1).WriteArray(SAR_row_col_array[:,:,0]) + SAR_row_col.GetRasterBand(2).WriteArray(SAR_row_col_array[:,:,1]) + print(sim_out_path.replace(".tif","rc.tif")) + return sim_out_path.replace(".tif","rc.tif") + pass + + def CalSamplingRateOfDEM(self,DEM_tiff): + '''计算DEM的重采样率f，必须在解析头文件之后，参考陈尔学 博士学位论文 《 星载合成孔径雷达影像正射校正方法研究 》 + args: + DEM_tiff:tif DEM的影像 + return: + f:采样率，向上取整 + ''' + # 获取DEM_tiff的高宽、投影、仿射矩阵 + Trans_array=list(DEM_tiff.GetGeoTransform()) # 仿射变换矩阵 + width=DEM_tiff.RasterXSize + height=DEM_tiff.RasterYSize + # x=trans[0]+trans[1]*c+trans[2]*r + # y=trans[3]+trans[4]*c+trans[5]*r + # 获得其高宽分辨率 + delta_x=Trans_array[1]+Trans_array[2] # x轴上的分辨率 经度 + delta_y=Trans_array[4]+Trans_array[5] # y轴上的分辨率 纬度 + # 因为单位为度，所以需要转换为 米 + y_resultion=abs(111194.926644558737*delta_y) + x_resultion=abs(111194.926644*math.cos(Trans_array[3])*delta_x) + resultion=x_resultion if x_resultion>y_resultion else y_resultion + delta_R=self.delta_R # 斜距分辨率 + incidenceAngle=self.header_info['ImageInformation']['incidenceAngle']["NearRange"] # 入射角 + f=math.sin(incidenceAngle*math.pi/180)*1.4142135623730951*resultion/delta_R + f=math.ceil(f) + return f + + def PSTN_M2(self, TargetPostion, Doppler_d, StartTime, lamda, T0, LightSpeed, PRF, R0): + """ + 间接求解方法，使用矩阵方法,分段计算，方便加速 + args: + TargetPosition：nparray,nx3 地面坐标 + Doppler_d:多普勒系数 -1，1 + lamda:波长 + T0:多普勒参考时间 + LightSpeed:光速 + return: + rc:nparray shape nx2 行列号 + """ + # + + n = int(TargetPostion.shape[0]) # 坐标点数据 nx3 + r=np.zeros((n,1)) + c=np.zeros((n,1)) + ti=np.zeros((n,1),dtype=np.float64) + len_iter=2000 + pool= ThreadPoolExecutor() + pool_ls=[] + SatelliteOrbitModelstarttime=self.SatelliteOrbitModel.get_starttime() + SatelliteOrbitModelParameters=self.SatelliteOrbitModel.A_arr + SatelliteOrbitModelName=self.SatelliteOrbitModel.modelName + delta_R=self.delta_R + for i in range(0, n, len_iter): + start_i=i + len_block=len_iter + if start_i+len_block>n: + len_block=n-start_i + end_i=start_i+len_block + temp_TargetPosition=TargetPostion[start_i:end_i,:] + pool_ls.append( pool.submit(PSTN_block_MuilThread,copy.deepcopy(start_i),copy.deepcopy(end_i), + temp_TargetPosition.copy(), + copy.deepcopy(Doppler_d), + copy.deepcopy(StartTime), + copy.deepcopy(lamda), + copy.deepcopy(T0), copy.deepcopy(LightSpeed), + copy.deepcopy(PRF),copy.deepcopy(R0), + copy.deepcopy(delta_R), + copy.deepcopy(SatelliteOrbitModelstarttime), + SatelliteOrbitModelParameters.copy(), + copy.deepcopy(SatelliteOrbitModelName),)) + pool.close() + pool.join() + for p in pool_ls: + r_temp, c_temp, ti_temp,start_i,end_i=p.get() + r[start_i:end_i,:]=r_temp + c[start_i:end_i,:]=c_temp + ti[start_i:end_i,:]=ti_temp + + return r,c,ti + + def PSTN_M(self, TargetPostion, Doppler_d, StartTime, lamda, T0, LightSpeed, PRF, R0): + """ + 间接求解方法，使用矩阵方法,分段计算，方便加速 + args: + TargetPosition：nparray,nx3 地面坐标 + Doppler_d:多普勒系数 -1，1 + lamda:波长 + T0:多普勒参考时间 + LightSpeed:光速 + return: + rc:nparray shape nx2 行列号 + """ + # + n = int(TargetPostion.shape[0]) # 坐标点数据 nx3 + r=np.zeros((n,1)) + c=np.zeros((n,1)) + ti=np.zeros((n,1),dtype=np.float64) + init_size=3000 + for i in range(0,n,init_size): + start_i=i + len_block=init_size + if start_i+len_block>n: + len_block=n-start_i + end_i=start_i+len_block + temp_TargetPosition=TargetPostion[start_i:end_i,:] + r_temp, c_temp, ti_temp=self.PSTN_block(temp_TargetPosition, Doppler_d, StartTime, lamda, T0, LightSpeed, PRF, R0) + + r[start_i:end_i,:]=r_temp.copy() + c[start_i:end_i,:]=c_temp.copy() + ti[start_i:end_i,:]=ti_temp.copy() + return r,c,ti + + def PSTN_block(self, TargetPostion, Doppler_d, StartTime, lamda, T0, LightSpeed, PRF, R0): + ''' + 间接求解方法，使用矩阵方法 + args: + TargetPosition：nparray,nx3 地面坐标 + Doppler_d:多普勒系数 -1，1 + lamda:波长 + T0:多普勒参考时间 + LightSpeed:光速 + return: + rc:nparray shape nx2 行列号 + ''' + n = TargetPostion.shape[0] # 坐标点数据 nx3 + ti = np.ones((n, 1),dtype=np.float64) * StartTime # 初始值 + delta_R = self.delta_R + delta_t = 1 / PRF + R=np.zeros((n,1)) + Rs = np.zeros((n, 3)) + R_sc = np.zeros((n, 3)) # 地面-卫星空间位置矢量 + V_sc = np.zeros((n, 3)) # 地面-卫星空间速率矢量 + FdNumerical = np.ones((n, 1)) # 多普勒公式的数值解法 + FdTheory = np.ones((n, 1)) # 多普勒公式的理论解法 + FdTheory_grad = np.ones((n, 1)) # 多普勒公式的导数 + # 多普勒参数系数 + Doppler_d = Doppler_d.reshape(-1, 1) # 5x1 + TSR=np.ones((n, 1)) # nx1 + TSRx = np.ones((n, Doppler_d.shape[0])) # nx5 + inc_t = np.ones((n, 1)) # 计算增加的导数 + dt = 0.0001 # 数值法求解多普勒距离公式的导数 + dt_rec=1/dt + # 默认最高迭代100次，如果还未求解出结果，就将所有的未收敛的时间值记录为0 ，注意时间不能为0 + for i in range(100): + tempT = ti + dt # 计算增加时间 + # ------- 求解导数 ---------------- + #del Rs,R_sc,V_sc,TSR,TSRx,satelliteSpaceState,R + satelliteSpaceState = self.SatelliteOrbitModel.getSatelliteSpaceState(tempT) # 卫星坐标与速度 nx6 + Rs = satelliteSpaceState[:, :3] + R_sc = satelliteSpaceState[:, :3] - TargetPostion # 地面-卫星空间位置矢量 + V_sc = satelliteSpaceState[:, 3:] # 地面-卫星空间位置矢量 + R =np.sqrt(np.sum(R_sc ** 2, axis=1)).reshape(-1, 1) # nx1 + #FdTheory_grad = (-2 / lamda) * (1 / R) * np.sum(R_sc * V_sc, axis=1).reshape(-1, 1) # nx1 + FdTheory_grad = -2*np.reciprocal(R*lamda) * np.sum(R_sc * V_sc, axis=1).reshape(-1, 1) # nx1 + + # 获取卫星轨道状态信息 + satelliteSpaceState = self.SatelliteOrbitModel.getSatelliteSpaceState(ti) # 卫星坐标与速度 nx6 + # 卫星轨道坐标 + Rs =satelliteSpaceState[:, :3] + # 卫星相对地面的位置向量、卫星速度向量 + R_sc=Rs - TargetPostion # 地面-卫星空间位置矢量 + V_sc =satelliteSpaceState[:, 3:] # 地面-卫星空间位置矢量 + # 斜距 + R = np.sqrt(np.sum(R_sc ** 2, axis=1)).reshape(-1, 1) # nx1 + # 根据多普勒数值求解公式求解多普勒频移值 + TSR= R * (2 / LightSpeed) - T0 # nx1 + TSRx[:,0]=TSR[:,0]**0 # nx5 + TSRx[:,1]=TSR[:,0]**1 + TSRx[:,2]=TSR[:,0]**2 + TSRx[:,3]=TSR[:,0]**3 + TSRx[:,4]=TSR[:,0]**4 + # 根据多普勒物理公式求解求解多普勒频移值 + FdTheory=-2*np.reciprocal(lamda*R)*np.sum(R_sc * V_sc, axis=1).reshape(-1, 1) # nx1 + FdNumerical= np.matmul(TSRx, Doppler_d) # nx1 + + FdTheory_grad = np.reciprocal((FdTheory_grad - FdTheory) * dt_rec) # nx1 + inc_t = (FdTheory - FdNumerical) * FdTheory_grad #(FdTheory - FdNumerical) * (1 / FdTheory_grad) # nx1 + # inc_t = inc_t - inc_t * ti_mask # 允许继续迭代 nx1 + if np.max(np.abs(inc_t)) < delta_t * 0.001: + break + ti = ti - inc_t # 更新坐标 + #del Rs,R_sc,V_sc,R,satelliteSpaceState,FdTheory_grad,FdNumerical,inc_t + #print("当前python程序，{} step， inc_t {} 求解内存占用 {}G".format(i,np.max(inc_t),psutil.Process(os.getpid()).memory_info().rss / 1024 / 1024 / 1024)) + # 计算行号 + ti_=copy.deepcopy(ti.copy()) + r_ = (ti_ - StartTime)*PRF + delta_t_light=delta_t*LightSpeed + r=copy.deepcopy(r_.copy()) + del r_ + c_ = (R - R0) * (1 / delta_R) + c=copy.deepcopy(c_.copy()) + del c_ + ti = copy.deepcopy(ti_.copy()) + del ti_ + return r, c, ti + pass + + def sim_intensity(self, in_tif_path, dem_resampled_path, lut_tif_path, incidence_tif_path, sim_out_path): + """ + 局部入射角计算 + 原方法存在的问题：多次文件读写 + """ + dem_resampled_tiff = gdal.Open(dem_resampled_path) # 获取重采样的DEM 数据，为了减少文件读写操作，这里做了持久化 + im_proj = dem_resampled_tiff.GetProjection() # 构建投影 + im_geotrans = list(dem_resampled_tiff.GetGeoTransform()) # 构建投影变换对象 + [a1, b1, c1, a2, b2, c2] = im_geotrans # 坐标变换参数：c1=0,b2=0 + start = time.time() # 度量算法 + dem_resampled = dem_resampled_tiff.GetRasterBand(1).ReadAsArray(0, 0, dem_resampled_tiff.RasterXSize, + dem_resampled_tiff.RasterYSize) + del dem_resampled_tiff # 释放内存 + incidence = dem_resampled * 0.0 + 1.8 + # 读取时间 + in_ds = gdal.Open(lut_tif_path) # 读取间接法 + row_cnt = in_ds.RasterYSize + col_cnt = in_ds.RasterXSize + t_arr = in_ds.GetRasterBand(3).ReadAsArray(0, 0, col_cnt, row_cnt).astype(np.float64) # 获取时间阵列 + t_arr = t_arr[1:-1, 1:-1] + self.header_info['ImageInformation']['StartTime'] # 去除最外围一圈时间数据 + row_data = in_ds.GetRasterBand(1).ReadAsArray(0, 0, col_cnt, row_cnt) # 读取行号 + col_data = in_ds.GetRasterBand(2).ReadAsArray(0, 0, col_cnt, row_cnt) # 读取列号 + row_data = np.round(row_data) + col_data = np.round(col_data) + row_data = row_data.astype(np.int16) + col_data = col_data.astype(np.int16) + del in_ds # 释放内存 + c = range(0, col_cnt) + c = np.array(c).reshape(-1, 1) + + for r0 in range(1, row_cnt - 1): + T0 = np.zeros((col_cnt, 3)) # colcount-2 ，3 + T0[:, 0] = a1 + b1 * c[:, 0] + c1 * r0 + T0[:, 1] = a2 + b2 * c[:, 0] + c2 * r0 + T0[:, 2] = dem_resampled[r0, :] + + T0 = np.concatenate(OrthoAuxData.LLA2XYZM(T0[:, 0].reshape(-1, 1), T0[:, 1].reshape(-1, 1), T0[:, 2].reshape(-1, 1)), axis=1) + n1 = np.concatenate(OrthoAuxData.LLA2XYZM(a1 + b1 * c + c1 * (r0 - 1), a2 + b2 * c + c2 * (r0 - 1), + dem_resampled[r0 - 1, :]), axis=1)[1:-1, :] - T0[1:-1, :] # colcount-2 ，3 + n3 = np.concatenate(OrthoAuxData.LLA2XYZM(a1 + b1 * c + c1 * (r0 + 1), a2 + b2 * c + c2 * (r0 + 1), + dem_resampled[r0 + 1, :]), axis=1)[1:-1, :] - T0[1:-1, :] # colcount-2 ，3 + n2 = T0[:-2, :] - T0[1:-1, :] + n4 = T0[2:, :] - T0[1:-1, :] + T0 = T0[1:-1, :] + n31 = n1 - n3 + n42 = n2 - n4 + + N = XYZOuterM2(n31, n42) / 4 + ti = t_arr[r0 - 1, :].reshape(-1, 1) # rowcount-2,colcount-2 + satelliteSpaceState = self.SatelliteOrbitModel.getSatelliteSpaceState(ti) + Rps = satelliteSpaceState[:, :3] - T0 # nx3 + # 计算向量模之积 + N_Norm = np.sqrt(np.sum(N * N, axis=1)).reshape(-1, 1) + Rps_Norm = np.sqrt(np.sum(Rps * Rps, axis=1)).reshape(-1, 1) + N_Norm = np.concatenate((N_Norm, N_Norm, N_Norm), axis=1) + Rps_Norm = np.concatenate((Rps_Norm, Rps_Norm, Rps_Norm), axis=1) + N = N / N_Norm + Rps = Rps / Rps_Norm + # 计算向量相乘 + N_Rps = np.sum(N * Rps, axis=1) # col_count-2 + theta = np.arccos(N_Rps) # 入射角 + incidence[r0, 1:-1] = theta + + incidence = np.degrees(incidence) + print('整张图入射角计算完成，耗时{}秒'.format(time.time() - start)) + ImageHandler.write_img(incidence_tif_path, im_proj, im_geotrans, incidence) + + # 读取原始影像相关信息 + in_tif = gdal.Open(in_tif_path) + col_num = in_tif.RasterXSize + row_num = in_tif.RasterYSize + im_proj1 = in_tif.GetProjection() # 构建投影 + im_geotrans1 = in_tif.GetGeoTransform() + out_arr = np.zeros((row_num, col_num), dtype=np.float32) + for h in range(row_cnt): + r_min = min(row_data[h]) + r_max = max(row_data[h]) + c_min = min(col_data[h]) + c_max = max(col_data[h]) + if 0 <= r_min < row_num or 0 <= r_max < row_num or (r_min < 0 and r_max >= row_num): + if 0 <= c_min < col_num or 0 <= c_max < col_num or (c_min < 0 and c_max >= col_num): + for w in range(col_cnt): + r = row_data[h, w] + c = col_data[h, w] + if 0 <= r < row_num and 0 <= c < col_num: + if 0 <= incidence[h, w] < 90: + out_arr[r, c] += 1 + K = 10 + out_arr = K * out_arr + max_delta = np.max(out_arr) + min_delta = np.min(out_arr) + out_arr = (out_arr - min_delta) / (max_delta - min_delta) + ImageHandler.write_img(sim_out_path, im_proj1, im_geotrans1, out_arr) + + @staticmethod + def sar_intensity_synthesis(sar_in_tif, sar_out_tif): + # 获取SLC格式SAR影像的相关信息 + in_ds = gdal.Open(sar_in_tif) + bands_num = in_ds.RasterCount + rows = in_ds.RasterYSize + columns = in_ds.RasterXSize + proj = in_ds.GetProjection() + geotrans = in_ds.GetGeoTransform() + + datatype = gdal.GDT_Float32 + + # 创建输出的SAR强度图 + gtiff_driver = gdal.GetDriverByName('GTiff') + out_ds = gtiff_driver.Create(sar_out_tif, columns, rows, 1, datatype) + + # 输出SAR强度图 + out_data=np.zeros((rows,columns)) + for i in range(0,rows,10000): + for j in range(0,columns,10000): + len_row=10000 + len_col=10000 + if i+len_row>rows: + len_row=rows-i + if j+len_col>columns: + len_col=columns-j + end_i=i+len_row + end_j=j+len_col + in_data1 = in_ds.GetRasterBand(1).ReadAsArray(j, i, len_col, len_row).astype(np.float32) + in_data2 = in_ds.GetRasterBand(2).ReadAsArray(j, i, len_col, len_row).astype(np.float32) + out_data[i:end_i,j:end_j] = np.log10((in_data1**2 + in_data2**2)+1)*10 + out_ds.GetRasterBand(1).WriteArray(out_data) + del in_ds, out_ds + + @staticmethod + def img_match(sim_sar_path, ori_sar_path,work_sapce_path): + ''' 影像匹配并根据配准点 + args: + sim_sar_path:模拟SAR强度图 + orig_sar_path: 原始SAR强度图 + out_path:配准结果输出点 + work_space_path: 工作目录 + return: + point_correct: 点集映射结果 + raise： + None: 出现错误 + ''' + match_points_path=ImageMatchClass.ImageMatch(ori_sar_path,sim_sar_path,work_sapce_path) + match_points_path=os.path.join(work_sapce_path,"GridMatch.npy") + match_result_path=os.path.join(work_sapce_path,"match_result.npy") + match_result_image_path=os.path.join(work_sapce_path,"match_result_show.tif") + ImageMatchClass.DeNoiseMatch(match_points_path,match_result_path) + ImageMatchClass.DrawMatchResult(ori_sar_path,sim_sar_path,match_result_path,match_result_image_path) + return match_result_path + + def IndireOrtho_smi(self,sim_SAR_rc_path,ori_SAR_path,tar_sar_path): + ''' + 测试间接定位法计算的影像坐标是否有问题。 + 方法核心，插值出间接定位法坐标处的 实部和虚部，不考虑其他区域 + 使用插值方法：等权反距离权重法 + 考虑实际的数据量较大，为节省内存，使用分块处理方法。 + 块大小为1000。 + ''' + sim_rc_tif=gdal.Open(sim_SAR_rc_path) + sim_width=sim_rc_tif.RasterXSize + sim_height=sim_rc_tif.RasterYSize + sim_r_tif=sim_rc_tif.GetRasterBand(1).ReadAsArray(0,0,sim_width,sim_height) + sim_c_tif=sim_rc_tif.GetRasterBand(2).ReadAsArray(0,0,sim_width,sim_height) + # 构建掩膜 + sim_mask=(sim_r_tif>0)&(sim_r_tif0)&(sim_c_tif模拟 + args: + point_arr:[模拟row,模拟col，原始row,原始col] + ''' + # 由模拟->原始 + point_cnt = point_arr.shape[0] # + rs_arr = point_arr[:,2].reshape(point_cnt, 1) # 原始 行 + cs_arr = point_arr[:,3].reshape(point_cnt, 1) + + rm_arr = point_arr[:,0].reshape(point_cnt, 1)-3000 # 模拟 行 还原偏移 + cm_arr = point_arr[:,1].reshape(point_cnt, 1) + X = np.concatenate( + [np.ones((point_cnt, 1), dtype=np.float64), rm_arr, cm_arr, rm_arr ** 2, cm_arr ** 2, rm_arr * cm_arr], + axis=1) + sim2orirc_arr=np.ones((2,6)) + sim2orirc_arr[0,:] = np.matmul(np.matmul(np.linalg.inv(np.matmul(X.T, X)), X.T), rs_arr).reshape(1, 6) + sim2orirc_arr[1,:] = np.matmul(np.matmul(np.linalg.inv(np.matmul(X.T, X)), X.T), cs_arr).reshape(1, 6) + + # 翻转 sim->ori + X = np.concatenate( + [np.ones((point_cnt, 1), dtype=np.float64), rs_arr, cs_arr, rs_arr ** 2, cs_arr ** 2, rs_arr * cs_arr], + axis=1) + ori2simrc_arr=np.ones((2,6)) + ori2simrc_arr[0,:] = np.matmul(np.matmul(np.linalg.inv(np.matmul(X.T, X)), X.T), rm_arr).reshape(1, 6) + ori2simrc_arr[1,:] = np.matmul(np.matmul(np.linalg.inv(np.matmul(X.T, X)), X.T), cm_arr).reshape(1, 6) + return ori2simrc_arr.copy(),sim2orirc_arr.copy() + + @staticmethod + def ReSamplingSAR(ori_sar_path,out_sar_path,lon_lat_point_match_path,gt): + ''' 根据影像点匹配点，插值得到正射图像 + args: + ori_sar_path: 输入sar地址 + out_sar_path: 正射结果地址 + lon_lat_point_match_path: CoordinateCorrection计算结果的路径 + gt: 仿射矩阵 + return: + out_sar_path + ''' + + ori_sar=gdal.Open(ori_sar_path) + ori_height=ori_sar.RasterYSize # 获得高度 + ori_width=ori_sar.RasterXSize # 获得宽度 + # 开始插值 + spatialreference=osr.SpatialReference() + spatialreference.SetWellKnownGeogCS("WGS84") # 设置地理坐标，单位为度 degree # 设置投影坐标，单位为度 degree + spatialproj=spatialreference.ExportToWkt() # 导出投影结果 + gtiff_driver = gdal.GetDriverByName('GTiff') + out_sar=gtiff_driver.Create(out_sar_path, ori_width, ori_height, 2, gdal.GDT_Float32) + out_sar.SetGeoTransform(gt) # 写入仿射变换参数 + out_sar.SetProjection(spatialproj) # 写入投影 + + ab=np.array([gt[1],gt[2],gt[4],gt[5]]).reshape(2,2) + ab=np.np.matmul(np.linalg.inv(np.np.matmul(ab.T,ab)),ab.T) + # 解算仿射矩阵，为后面的插值做准备 + lon_lat_file_list=os.listdir(lon_lat_point_match_path) + block_info_json=[] + for lon_lat_file_name in lon_lat_file_list: + lon_lat=np.load(os.path.join(lon_lat_point_match_path,lon_lat_file_name)) + ori_r=lon_lat[:,0] # 原始影像的行坐标 + ori_c=lon_lat[:,1] # 原始影像的列坐标 + lon=lon_lat[:,2].copy() + lat=lon_lat[:,3].copy() + # 根据仿射矩阵阶段投影变换结果 + lon=lon-gt[0] + lat=lat-gt[3] + lon_lat[:,2]=ab[0,0]*lon+ab[0,1]*lat # 行 + lon_lat[:,3]=ab[1,0]*lon+ab[1,1]*lat # 列 + block_info_json.append({ + 'ori':[np.min(lon_lat[:,0]),np.max(lon_lat[:,0]),np.min(lon_lat[:,1]),np.max(lon_lat[:,1])],# r0 r1 c0 c1 + 'ortho':[np.min(lon_lat[:,2]),np.max(lon_lat[:,2]),np.min(lon_lat[:,3]),np.max(lon_lat[:,3])], + 'path':os.path.join(lon_lat_point_match_path,lon_lat_file_name) + }) + + for i in range(0,ori_height,6000): + for j in range(0,ori_width,6000): + # 判断需要检索的行列 + len_row=6000 + len_col=6000 + if i+len_row>ori_height: + len_row=ori_height-i + if j+len_col>ori_width: + len_col=ori_width-j + end_i=i+len_row + end_j=j+len_col + select_region=[i-1000,end_i+1000,j-1000,end_i+1000] + # 根据求交原则，解出需要可以参与插值计算的 方块 + inter_block=[] + for block in block_info_json: + block_ortho =block['ortho'] + if block_ortho[0]>select_region[0] and block_ortho[1]select_region[2] and block_ortho[3]模拟SAR + # X=a0+a1*r+a2*c+a5*r*c+a3*r^2+a4*c^2 + # Y=b0+b1*r+b2*c+b5*r*c+b3*r^2+b4*r^2 + point_arr=np.load(point_match_path) + rcori2simrc_arr,sim2orirc_arr=IndirectOrthorectification.CoordinateTransformation(point_arr) + # 根据行列号裁剪DEM + sim_rc_tif=gdal.Open(sim_out_path) + sim_width=sim_rc_tif.RasterXSize + sim_height=sim_rc_tif.RasterYSize + sim_r_tif=sim_rc_tif.GetRasterBand(1).ReadAsArray(0,0,sim_width,sim_height) + sim_c_tif=sim_rc_tif.GetRasterBand(2).ReadAsArray(0,0,sim_width,sim_height) + + # 计算实际行列号 + r=sim2orirc_arr[0,0]+sim2orirc_arr[0,1]*sim_r_tif+sim2orirc_arr[0,2]*sim_c_tif+sim2orirc_arr[0,3]*sim_r_tif*sim_r_tif+sim2orirc_arr[0,4]*sim_c_tif*sim_c_tif+sim2orirc_arr[0,5]*sim_r_tif*sim_c_tif + c=sim2orirc_arr[1,0]+sim2orirc_arr[1,1]*sim_r_tif+sim2orirc_arr[1,2]*sim_c_tif+sim2orirc_arr[1,3]*sim_r_tif*sim_r_tif+sim2orirc_arr[1,4]*sim_c_tif*sim_c_tif+sim2orirc_arr[1,5]*sim_r_tif*sim_c_tif + sim_r_tif=r + sim_c_tif=c + del r,c + + # + sim_mask=(sim_r_tif>=-1)&(sim_r_tif=-1)&(sim_c_tif原始 + ori_rc=np.ones((r_ids.size,2)) + ori_rc[:,0]=r_arr_trans[0,0]+r_ids*r_arr_trans[0,1]+c_ids*r_arr_trans[0,2]+r_arr_trans[0,3]*r_ids ** 2+r_arr_trans[0,4]*c_ids ** 2+r_arr_trans[0,5]*r_ids * c_ids + ori_rc[:,1]=c_arr_trans[0,0]+r_ids*c_arr_trans[0,1]+c_ids*c_arr_trans[0,2]+c_arr_trans[0,3]*r_ids ** 2+c_arr_trans[0,4]*c_ids ** 2+c_arr_trans[0,5]*r_ids * c_ids + # 插值x坐标 + sim_x_data=gdal.Open(sim_sar_x_path) + sim_x_arr=sim_x_data.GetRasterBand(1).ReadAsArray(0,0 , sim_x_data.RasterXSize, sim_x_data.RasterYSize) # 块 高程文件 + sim_x=sim_x_arr[r_ids,c_ids] + del sim_x_arr,sim_x_data + tree=KDTree(ori_rc) # 原始sar点对应的坐标 + + gtiff_driver = gdal.GetDriverByName('GTiff') + SAR_row_col=gtiff_driver.Create(ori_xyz_path,width,height,3,gdal.GDT_Float32) + # 准备插值--分块插值 + blocksize=5000 + SAR_ori=np.zeros((height,width)) + for i in range(0,height,blocksize): + for j in range(0,width,blocksize): + start_row=i + start_col=j + len_row=blocksize + len_col=blocksize + if(start_row+len_row>height): + len_row=height-start_row + if(start_col+len_col>width): + len_col=width-start_col + end_row=start_row+len_row + end_col=start_col+len_col + grid_xy= np.mgrid[start_row:end_row:1, start_col:end_col:1] + grid_xy=grid_xy.reshape(2,-1).transpose(1,0) + distance_weight,ori_select=tree.query(grid_xy,k=10) + distance_weight=np.reciprocal(distance_weight) + distance_weight=np.multiply(distance_weight.transpose(1,0),np.reciprocal(np.sum(distance_weight,axis=1))) + distance_weight=distance_weight.transpose(1,0) + SAR_ori[start_row:end_row,start_col:end_col]=np.sum( np.multiply(distance_weight,sim_x[ori_select]),axis=1).reshape(len_row,len_col) + + SAR_row_col.GetRasterBand(1).WriteArray(SAR_ori) + + # 插值y坐标 + sim_y_data=gdal.Open(sim_sar_y_path) + sim_y_arr=sim_y_data.GetRasterBand(1).ReadAsArray(0,0 , sim_y_data.RasterXSize, sim_y_data.RasterYSize) # 块 高程文件 + sim_y=sim_y_arr[r_ids,c_ids] + del sim_y_arr,sim_y_data,sim_x + # 准备插值--分块插值 + blocksize=5000 + SAR_ori=np.zeros((height,width)) + for i in range(0,height,blocksize): + for j in range(0,width,blocksize): + start_row=i + start_col=j + len_row=blocksize + len_col=blocksize + if(start_row+len_row>height): + len_row=height-start_row + if(start_col+len_col>width): + len_col=width-start_col + end_row=start_row+len_row + end_col=start_col+len_col + grid_xy= np.mgrid[start_row:end_row:1, start_col:end_col:1] + grid_xy=grid_xy.reshape(2,-1).transpose(1,0) + distance_weight,ori_select=tree.query(grid_xy,k=10) + distance_weight=np.reciprocal(distance_weight) + distance_weight=np.multiply(distance_weight.transpose(1,0),np.reciprocal(np.sum(distance_weight,axis=1))) + distance_weight=distance_weight.transpose(1,0) + SAR_ori[start_row:end_row,start_col:end_col]=np.sum(np.multiply(distance_weight,sim_y[ori_select]),axis=1).reshape(len_row,len_col) + + SAR_row_col.GetRasterBand(2).WriteArray(SAR_ori) + # 插值z坐标 + sim_z_data=gdal.Open(sim_sar_z_path) + sim_z_arr=sim_z_data.GetRasterBand(1).ReadAsArray(0,0 , sim_z_data.RasterXSize, sim_z_data.RasterYSize) # 块 高程文件 + sim_z=sim_z_arr[r_ids,c_ids] + del sim_z_arr,sim_z_data,sim_y + # 准备插值--分块插值 + blocksize=5000 + SAR_ori=np.zeros((height,width)) + for i in range(0,height,blocksize): + for j in range(0,width,blocksize): + start_row=i + start_col=j + len_row=blocksize + len_col=blocksize + if(start_row+len_row>height): + len_row=height-start_row + if(start_col+len_col>width): + len_col=width-start_col + end_row=start_row+len_row + end_col=start_col+len_col + grid_xy= np.mgrid[start_row:end_row:1, start_col:end_col:1] + grid_xy=grid_xy.reshape(2,-1).transpose(1,0) + distance_weight,ori_select=tree.query(grid_xy,k=10) + distance_weight=np.reciprocal(distance_weight) + distance_weight=np.multiply(distance_weight.transpose(1,0),np.reciprocal(np.sum(distance_weight,axis=1))) + distance_weight=distance_weight.transpose(1,0) + SAR_ori[start_row:end_row,start_col:end_col]=np.sum(np.multiply(distance_weight,sim_z[ori_select]),axis=1).reshape(len_row,len_col) + SAR_row_col.GetRasterBand(3).WriteArray(SAR_ori) + return ori_xyz_path + + def outResamplingParas(self,work_space_file,ortho_sar_xyz_pow_path,sar_xyz_path,sar_incidence_path,ortho_sar_xyz_path,ortho_sar_incidence_path,out_sar_file_list,dem_clip_path,ori2sim,sim2ori): + ''' + sar_xyz_path:xyz插值结果 + sar_incidence_path: 入射角 + ortho_sar_xyz_path： 重采样结果文件夹 + out_sar_file_list：需要重采样的文件 + rc_trans_arr：变换结果 + + ''' + with open(os.path.join(work_space_file,"resample_para.txt"),'w',encoding='utf-8') as fp: + fp.write("{}\n".format(dem_clip_path)) + fp.write("{}\n".format(os.path.join(work_space_file,"ori_sim.tif"))) + fp.write("{}\n".format(sar_xyz_path)) + fp.write("{}\n".format(sar_incidence_path)) + fp.write("{}\n".format(ortho_sar_incidence_path)) + fp.write("{}\n".format(ortho_sar_incidence_path.replace("orth_sar_incidence.tif","orth_sar_local_incidence.tif"))) + fp.write("{}\n".format(ortho_sar_xyz_path)) + fp.write("{}\n".format(len(out_sar_file_list))) + for i in range(len(out_sar_file_list)): + file_name=os.path.split(out_sar_file_list[i])[1] + fp.write("{}\n".format(out_sar_file_list[i])) + fp.write("{}\n".format(os.path.join(ortho_sar_xyz_path,file_name))) + fp.write("{}\n".format(os.path.join(ortho_sar_xyz_pow_path,file_name))) + #os.path.split(in_tif_path)[1] + + fp.write("{}\n".format(12)) + for i in range(6): + fp.write("{}\n".format(ori2sim[0,i])) + for i in range(6): + fp.write("{}\n".format(ori2sim[1,i])) + fp.write("{}\n".format(12)) + for i in range(6): + fp.write("{}\n".format(sim2ori[0,i])) + for i in range(6): + fp.write("{}\n".format(sim2ori[1,i])) + return os.path.join(work_space_file,"resample_para.txt") + + def Resampling(self,out_sar_xyz_path,inv_gt,gt,ori_resampling_file_path): + out_xyz=gdal.Open(out_sar_xyz_path) + ori_height=out_xyz.RasterYSize # 获得高度 + ori_width=out_xyz.RasterXSize # 获得宽度 + out_xyz_x=out_xyz.GetRasterBand(1).ReadAsArray(0,0 , ori_width, ori_height) + out_xyz_y=out_xyz.GetRasterBand(2).ReadAsArray(0,0 , ori_width, ori_height) + + # 计算对应的行列号 + out_xyz_rc=np.ones((ori_height,ori_width,2)) + out_xyz_rc[:,:,1]=inv_gt[0]+inv_gt[1]*out_xyz_x+inv_gt[2]*out_xyz_y + out_xyz_rc[:,:,0]=inv_gt[3]+inv_gt[4]*out_xyz_x+inv_gt[5]*out_xyz_y + del out_xyz_x,out_xyz_y,out_xyz + out_xyz_rc=out_xyz_rc.reshape(-1,2) + + blocksize=2000 + ori_data=gdal.Open(ori_resampling_file_path[0][0][0]) + width=ori_data.RasterXSize + height=ori_data.RasterYSize + SAR_ori=np.ones((width,height)) + sim_x=ori_data.GetRasterBand(1).ReadAsArray(0,0 , width, height).reshape(-1) + tree=KDTree(out_xyz_rc) + for i in range(0,height,blocksize): + for j in range(0,width,blocksize): + start_row=i + start_col=j + len_row=blocksize + len_col=blocksize + if(start_row+len_row>height): + len_row=height-start_row + if(start_col+len_col>width): + len_col=width-start_col + end_row=start_row+len_row + end_col=start_col+len_col + grid_xy= np.mgrid[start_row:end_row:1, start_col:end_col:1] + grid_xy=grid_xy.reshape(2,-1).transpose(1,0) + distance_weight,ori_select=tree.query(grid_xy,k=4) + distance_weight=np.reciprocal(distance_weight) + distance_weight=np.multiply(distance_weight.transpose(1,0),np.reciprocal(np.sum(distance_weight,axis=1))) + distance_weight=distance_weight.transpose(1,0) + SAR_ori[start_row:end_row,start_col:end_col]=np.sum( np.multiply(distance_weight,sim_x[ori_select]),axis=1).reshape(len_row,len_col) + pass + ''' + # 获得所有点集 + del point_arr + # 构建查询表 + ori_sar=gdal.Open(ori_sar_path) + ori_height=ori_sar.RasterYSize # 获得高度 + ori_width=ori_sar.RasterXSize # 获得宽度 + point_arr_path=[os.path.join(work_space_file,"point_refrence.npy")] + for point_match_arr_filename in os.listdir(os.path.join(work_space_file,'temp_point_refrence')): + point_arr_path.append(os.path.join(work_space_file,'temp_point_refrence',point_match_arr_filename)) + point_arr=np.ones((1,5)) + for point_path in point_arr_path: + point_temp_arr=np.load(point_path) + point_arr=np.row_stack((point_arr,point_temp_arr)) + point_arr=point_arr[1:,:] + ori_points=np.zeros((point_arr.shape[0],2)) + # 求解对应的行列号 + for i in range(r_arr_trans.shape[1]): + ori_points[:,0]=ori_points[:,0]+r_arr_trans[0,i]*point_arr[:,1]**i + ori_points[:,1]=ori_points[:,1]+c_arr_trans[0,i]*point_arr[:,1]**i + point_arr[:,0]=ori_points[:,0].copy() + point_arr[:,1]=ori_points[:,1].copy() + del ori_points + gc.collect() + # 根据此进行散点插值，确定 + lon_lat_point_match_path=os.path.join(work_space_file,"lon_lat_point_match") + if os.path.exists(lon_lat_point_match_path): + shutil.rmtree(lon_lat_point_match_path) + os.makedirs(lon_lat_point_match_path) + lon_lat=np.zeros((4,2)) + block_info_json={"ori_rc":[]} + # + block_size=5000 + for i in range(0,ori_height,block_size): + for j in range(0,ori_width,block_size): + len_row=block_size + len_col=block_size + if i+len_row>ori_height: + len_row=ori_height-i + if j+len_col>ori_width: + len_col=ori_width-j + end_i=i+len_row + end_j=j+len_col + + r=(np.ones((len_col,len_row))*range(len_row)).transpose(1,0)+i + c=np.ones((len_row,len_col))*range(len_col)+j + # 格网插值 + # scipy 规则格网插值 + lon_lat_r_c=np.ones((len_col*len_row,5)) + lon_lat_r_c[:,0]=r.reshape(-1) + lon_lat_r_c[:,1]=c.reshape(-1) + + SAR_ori_X=interpolate.griddata(point_arr[:,:2], point_arr[:,2], (lon_lat_r_c[:,0], lon_lat_r_c[:,1]), method='linear').reshape(-1) + SAR_ori_Y=interpolate.griddata(point_arr[:,:2], point_arr[:,3], (lon_lat_r_c[:,0], lon_lat_r_c[:,1]), method='linear').reshape(-1) + SAR_ori_Z=interpolate.griddata(point_arr[:,:2], point_arr[:,4], (lon_lat_r_c[:,0], lon_lat_r_c[:,1]), method='linear').reshape(-1) + [lon_lat_r_c[:,2],lon_lat_r_c[:,3],lon_lat_r_c[:,4]]=OrthoAuxData.XYZ2LLAM(SAR_ori_X,SAR_ori_Y,SAR_ori_Z) + temp_path=os.path.join(lon_lat_point_match_path,"r_c_{}_{}.npy".format(i,j)) + np.save(temp_path,lon_lat_r_c) + block_info_json['ori_rc'].append({'ori':[i,j,end_i,end_j],"path":temp_path}) + if i==0 and j==0: + lon_lat[0,0]=lon_lat_r_c[:,2].reshape(len_row,len_col)[0,0] # 经度 + lon_lat[0,1]=lon_lat_r_c[:,3].reshape(len_row,len_col)[0,0] # 纬度 + + if i+len_row==ori_height and j==0: + lon_lat[1,0]=lon_lat_r_c[:,2].reshape(len_row,len_col)[-1,0] + lon_lat[1,1]=lon_lat_r_c[:,3].reshape(len_row,len_col)[-1,0] + + if j+len_col==ori_width and i==0: + lon_lat[2,0]=lon_lat_r_c[:,2].reshape(len_row,len_col)[0,-1] + lon_lat[2,1]=lon_lat_r_c[:,3].reshape(len_row,len_col)[0,-1] + if j+len_col==ori_width and i+len_row==ori_height: + lon_lat[3,0]=lon_lat_r_c[:,2].reshape(len_row,len_col)[-1,-1] + lon_lat[3,1]=lon_lat_r_c[:,3].reshape(len_row,len_col)[-1,-1] + # 1 3 + # 2 4 + gt=[0,1,2,3,4,5] + # 计算 经度 + gt[0]= lon_lat[0,0] + gt[1]=(lon_lat[2,0]-gt[0])/(ori_width-1) + gt[2]=(lon_lat[3,0]-gt[0]-gt[1]*(ori_width-1))/(ori_height-1) + # 计算 纬度 + gt[3]= lon_lat[0,1] + gt[5]=(lon_lat[1,1]-gt[3])/(ori_height-1) + gt[4]=(lon_lat[3,1]-gt[3]-gt[5]*(ori_height-1))/(ori_width-1) + + + return lon_lat_point_match_path,gt + #return lon_lat_point_match_path + + return None + pass + ''' + diff --git a/Ortho-Top/OrthoAuxData.py b/Ortho-Top/OrthoAuxData.py new file mode 100644 index 0000000..8f443cc --- /dev/null +++ b/Ortho-Top/OrthoAuxData.py @@ -0,0 +1,415 @@ +# 一米正射辅助数据处理类 +import time +import math +import numpy as np +from osgeo import gdal +from xml.etree.ElementTree import ElementTree +from scipy.optimize import leastsq + + +class OrthoAuxData: + def __init__(self): + pass + + @staticmethod + def time_stamp(tm): + list = tm.split(':') + sec = math.ceil(float(list[2])) + tm1 = list[0] + ':' + list[1] + ':' + str(sec) + tmArr = time.strptime(tm1, "%Y-%m-%d %H:%M:%S") + # tmArr = time.strptime(tm1, "%Y-%m-%d %H:%M:%S.%f") + ts = float(time.mktime(tmArr)) # 转换为时间戳 + return ts + + @staticmethod + def read_meta(meta_file_path): + tree = ElementTree() + tree.parse(meta_file_path) + root = tree.getroot() + T = [] + Xs = [] + Ys = [] + Zs = [] + Vsx = [] + Vsy = [] + Vsz = [] + GPS_data = root.find('GPS') + for child in GPS_data: + Xs.append(float(child.find('xPosition').text)) + Ys.append(float(child.find('yPosition').text)) + Zs.append(float(child.find('zPosition').text)) + Vsx.append(float(child.find('xVelocity').text)) + Vsy.append(float(child.find('yVelocity').text)) + Vsz.append(float(child.find('zVelocity').text)) + tm = child.find('TimeStamp').text + ts = OrthoAuxData.time_stamp(tm) + T.append(ts) + meta_data = [Xs, Ys, Zs, Vsx, Vsy, Vsz] + return T, meta_data + + @staticmethod + def read_control_points(meta_file_path): + tree = ElementTree() + tree.parse(meta_file_path) + root = tree.getroot() + imageinfo = root.find('imageinfo') + center = imageinfo.find('center') + corner = imageinfo.find('corner') + ctrl_pts = [[] for i in range(2)] + ctrl_pts[0].append(float(center.find('longitude').text)) + ctrl_pts[1].append(float(center.find('latitude').text)) + + for child in corner: + ctrl_pts[0].append(float(child.find('longitude').text)) + ctrl_pts[1].append(float(child.find('latitude').text)) + return ctrl_pts + + @staticmethod + def read_dem(dem_resampled_path, flag=1): + in_ds = gdal.Open(dem_resampled_path) + gt = list(in_ds.GetGeoTransform()) + bands_num = in_ds.RasterCount + x_size = in_ds.RasterXSize + y_size = in_ds.RasterYSize + pstn_arr = np.zeros([y_size, x_size, 3], dtype=np.float) + for i in range(1, bands_num + 1): + data = in_ds.GetRasterBand(i).ReadAsArray(0, 0, x_size, y_size) + for y in range(y_size): + for x in range(x_size): + longitude = gt[0] + x * gt[1] + latitude = gt[3] + y * gt[5] + altitude = data[y, x] + if flag == 1: + pstn = OrthoAuxData.LLA2XYZ(longitude, latitude, altitude) + else: + pstn = [longitude, latitude, altitude] + pstn_arr[y, x, 0] = pstn[0] + pstn_arr[y, x, 1] = pstn[1] + pstn_arr[y, x, 2] = pstn[2] + + del in_ds, data + return pstn_arr + + @staticmethod + def read_demM(dem_resampled_path, part_cnt, r_cnt, c_cnt, flag=1): + in_ds = gdal.Open(dem_resampled_path) + gt = list(in_ds.GetGeoTransform()) + bands_num = in_ds.RasterCount + x_size = in_ds.RasterXSize // part_cnt + y_size = in_ds.RasterYSize // part_cnt + x = [[i] * y_size for i in range(x_size)] + y = [[i] * x_size for i in range(y_size)] + x = np.array(x) + x = x.T + y = np.array(y) + x_off = c_cnt * x_size + y_off = r_cnt * y_size + gt[0] = gt[0] + c_cnt * x_size * gt[1] + gt[3] = gt[3] + r_cnt * y_size * gt[5] + for i in range(1, bands_num + 1): + data = in_ds.GetRasterBand(i).ReadAsArray(x_off, y_off, x_size, y_size) + altitude = data / 255 * 1024 + longitude = gt[0] + x * gt[1] + latitude = gt[3] + y * gt[5] + if flag == 1: + pstn = OrthoAuxData.LLA2XYZM(longitude, latitude, altitude) + else: + pstn = [longitude, latitude, altitude] + + del in_ds, data + return pstn + + @staticmethod + def read_dem_row(dem_resampled_path, p, flag=1): + in_ds = gdal.Open(dem_resampled_path) + gt = list(in_ds.GetGeoTransform()) + bands_num = in_ds.RasterCount + x_size = in_ds.RasterXSize + y_size = in_ds.RasterYSize + + x = [[i] for i in range(x_size)] + x = np.array(x) + x = x.T + y = np.ones((1, x_size)) * p + x_off = 0 + y_off = p + for i in range(1, bands_num + 1): + data = in_ds.GetRasterBand(i).ReadAsArray(x_off, y_off, x_size, 1) + altitude = data + longitude = gt[0] + x * gt[1] + latitude = gt[3] + y * gt[5] + if flag == 1: + pstn = OrthoAuxData.LLA2XYZM(longitude, latitude, altitude) + else: + pstn = [longitude, latitude, altitude] + + del in_ds, data + return pstn + + @staticmethod + def orbit_fitting(time_array, meta_data): + # 最小二乘法求解轨道参数 + T0 = (time_array[0] + time_array[len(time_array)-1]) / 2 + t = [] + for i in range(len(time_array)): + t.append(time_array[i]-T0) + + def func(p, x): + w3, w2, w1, w0 = p + return w3*x**3 + w2*x**2 + w1*x + w0 + + def error(p, x, y): + return func(p, x) - y + + orbital_paras = [] + for j in range(len(meta_data)): + p0 = [1, 2, 3, 4] + x = np.array(t) + y = np.array(meta_data[j]) + Para = leastsq(error, p0, args=(x, y)) + orbital_paras.append(Para[0]) + print(Para[0], Para[1]) + + return orbital_paras, T0 + + @staticmethod + def get_PRF(meta_file_path): + tree = ElementTree() + tree.parse(meta_file_path) + root = tree.getroot() + sensor = root.find('sensor') + waveParams = sensor.find('waveParams') + PRF = float(waveParams.find('wave').find('prf').text) + return PRF + + @staticmethod + def get_delta_R(meta_file_path): + tree = ElementTree() + tree.parse(meta_file_path) + root = tree.getroot() + sensor = root.find('sensor') + pulseWidth = float(sensor.find('waveParams').find('wave').find('pulseWidth').text) + bandWidth = float(sensor.find('waveParams').find('wave').find('bandWidth').text) + c = 299792458 + delta_R = c / (1000000 * 2 * bandWidth) + return delta_R + + @staticmethod + def get_doppler_rate_coef(meta_file_path): + tree = ElementTree() + tree.parse(meta_file_path) + root = tree.getroot() + processinfo = root.find('processinfo') + doppler = processinfo.find('DopplerRateValuesCoefficients') + t0 = float(processinfo.find('DopplerParametersReferenceTime').text) + r0 = float(doppler.find('r0').text) + r1 = float(doppler.find('r1').text) + r2 = float(doppler.find('r2').text) + r3 = float(doppler.find('r3').text) + r4 = float(doppler.find('r4').text) + + return t0, np.array([r0, r1, r2, r3, r4]).reshape(5, 1) + + @staticmethod + def get_doppler_center_coef(meta_file_path): + tree = ElementTree() + tree.parse(meta_file_path) + root = tree.getroot() + processinfo = root.find('processinfo') + doppler = processinfo.find('DopplerCentroidCoefficients') + b0 = float(doppler.find('d0').text) + b1 = float(doppler.find('d1').text) + b2 = float(doppler.find('d2').text) + return b0, b1, b2 + + @staticmethod + def get_lamda(meta_file_path): + tree = ElementTree() + tree.parse(meta_file_path) + root = tree.getroot() + sensor = root.find('sensor') + λ = float(sensor.find('lamda').text) + return λ + + @staticmethod + def get_t0(meta_file_path): + tree = ElementTree() + tree.parse(meta_file_path) + root = tree.getroot() + imageinfo = root.find('imageinfo') + tm = imageinfo.find('imagingTime').find('start').text + t0 = OrthoAuxData.time_stamp(tm) + return t0 + + @staticmethod + def get_start_and_end_time(meta_file_path): + tree = ElementTree() + tree.parse(meta_file_path) + root = tree.getroot() + imageinfo = root.find('imageinfo') + tm0 = imageinfo.find('imagingTime').find('start').text + tm1 = imageinfo.find('imagingTime').find('end').text + starttime = OrthoAuxData.time_stamp(tm0) + endtime = OrthoAuxData.time_stamp(tm1) + return starttime, endtime + + @staticmethod + def get_width_and_height(meta_file_path): + tree = ElementTree() + tree.parse(meta_file_path) + root = tree.getroot() + imageinfo = root.find('imageinfo') + width = int(imageinfo.find('width').text) + height = int(imageinfo.find('height').text) + return width, height + + @staticmethod + def get_R0(meta_file_path): + tree = ElementTree() + tree.parse(meta_file_path) + root = tree.getroot() + imageinfo = root.find('imageinfo') + R0 = float(imageinfo.find('nearRange').text) + return R0 + + @staticmethod + def get_h(): + h = 6.6 + return h + + @staticmethod + def LLA2XYZ(longitude, latitude, altitude): + ''' + WGS-84坐标系下：经纬度坐标转空间直角坐标 + ''' + # 经纬度余弦值 + cosLat = math.cos(latitude * math.pi / 180) + sinLat = math.sin(latitude * math.pi / 180) + cosLon = math.cos(longitude * math.pi / 180) + sinLon = math.sin(longitude * math.pi / 180) + # WGS84坐标系参数 + rad = 6378137.0 #地球赤道平均半径 + f = 1.0/298.257224 #WGS84椭球扁率 + C = 1.0/math.sqrt(cosLat*cosLat + (1-f)*(1-f)*sinLat*sinLat) + S = (1-f)*(1-f)*C + h = altitude + # 计算XYZ坐标 + X = (rad * C + h) * cosLat * cosLon + Y = (rad * C + h) * cosLat * sinLon + Z = (rad * S + h) * sinLat + # return np.array([X, Y, Z]).reshape(1,3) + return [X, Y, Z] + + @staticmethod + def LLA2XYZM(longitude, latitude, altitude): + # 经纬度余弦值 + cosLat = np.cos(latitude * math.pi / 180).reshape(-1,1) + sinLat = np.sin(latitude * math.pi / 180).reshape(-1,1) + cosLon = np.cos(longitude * math.pi / 180).reshape(-1,1) + sinLon = np.sin(longitude * math.pi / 180).reshape(-1,1) + # WGS84坐标系参数 + rad = 6378137.0 #地球赤道平均半径 + f = 1.0/298.257224 #WGS84椭球扁率 + C = 1.0/(np.sqrt(cosLat*cosLat + (1-f)*(1-f)*sinLat*sinLat)).reshape(-1,1) + S = (1-f)*(1-f)*C + h = altitude.reshape(-1,1) + # 计算XYZ坐标 + X = (rad * C + h) * cosLat * cosLon + Y = (rad * C + h) * cosLat * sinLon + Z = (rad * S + h) * sinLat + return [X, Y, Z] + + @staticmethod + def XYZ2LLA(X, Y, Z): + ''' 大地坐标系转经纬度 + 适用于WGS84坐标系 + args: + x,y,z + return: + lat,long,altitude + ''' + # WGS84坐标系的参数 + a = 6378137.0 # 椭球长半轴 + b = 6356752.314245 # 椭球短半轴 + ea = np.sqrt((a ** 2 - b ** 2) / a ** 2) + eb = np.sqrt((a ** 2 - b ** 2) / b ** 2) + p = np.sqrt(X ** 2 + Y ** 2) + theta = np.arctan2(Z * a, p * b) + + # 计算经纬度及海拔 + longitude = np.arctan2(Y, X) + latitude = np.arctan2(Z + eb ** 2 * b * np.sin(theta) ** 3, p - ea ** 2 * a * np.cos(theta) ** 3) + N = a / np.sqrt(1 - ea ** 2 * np.sin(latitude) ** 2) + altitude = p / np.cos(latitude) - N + + # return np.array([np.degrees(latitude), np.degrees(longitude), altitude]) + return [np.degrees(longitude), np.degrees(latitude), altitude] + + @staticmethod + def XYZ2LLAM(X, Y, Z): + ''' 大地坐标系转经纬度 + 适用于WGS84坐标系 + args: + x,y,z + return: + lat,long,altitude + ''' + # WGS84坐标系的参数 + a = 6378137.0 # 椭球长半轴 + b = 6356752.314245 # 椭球短半轴 + ea = np.sqrt((a ** 2 - b ** 2) / a ** 2) + eb = np.sqrt((a ** 2 - b ** 2) / b ** 2) + p = np.sqrt(X ** 2 + Y ** 2) + theta = np.arctan2(Z * a, p * b) + + # 计算经纬度及海拔 + longitude = np.arctan2(Y, X) + latitude = np.arctan2(Z + eb ** 2 * b * np.sin(theta) ** 3, p - ea ** 2 * a * np.cos(theta) ** 3) + N = a / np.sqrt(1 - ea ** 2 * np.sin(latitude) ** 2) + altitude = p / np.cos(latitude) - N + + # return np.array([np.degrees(latitude), np.degrees(longitude), altitude]) + return [np.degrees(longitude), np.degrees(latitude), altitude] + + @staticmethod + def world2Pixel(geoMatrix, x, y): + """ + 使用GDAL库的geomatrix对象((gdal.GetGeoTransform()))计算地理坐标的像素位置 + """ + ulx = geoMatrix[0] + uly = geoMatrix[3] + xDist = geoMatrix[1] + yDist = geoMatrix[5] + rtnX = geoMatrix[2] + rtnY = geoMatrix[4] + pixel = int((x - ulx) / xDist) + line = int((uly - y) / abs(yDist)) + return pixel, line + + @staticmethod + def sar_intensity_synthesis(in_sar_tif, out_sar_tif): + # 获取SLC格式SAR影像的相关信息 + in_ds = gdal.Open(in_sar_tif) + bands_num = in_ds.RasterCount + rows = in_ds.RasterYSize + columns = in_ds.RasterXSize + proj = in_ds.GetProjection() + geotrans = in_ds.GetGeoTransform() + + # 创建输出的SAR强度图 + gtiff_driver = gdal.GetDriverByName('GTiff') + out_ds = gtiff_driver.Create(out_sar_tif, columns, rows, 1) + out_ds.SetProjection(proj) + out_ds.SetGeoTransform(geotrans) + + # 输出SAR强度图 + in_data1 = in_ds.GetRasterBand(1).ReadAsArray(0, 0, columns, rows) + in_data1 = in_data1/10 + in_data1 = np.power(10, in_data1) + in_data2 = in_ds.GetRasterBand(2).ReadAsArray(0, 0, columns, rows) + in_data2 = in_data2 / 10 + in_data2 = np.power(10, in_data2) + out_data = np.sqrt(in_data1**2 + in_data2**2) + out_ds.GetRasterBand(1).WriteArray(out_data) + + del in_ds, out_ds diff --git a/Ortho-Top/OrthoMain.py b/Ortho-Top/OrthoMain.py new file mode 100644 index 0000000..56a7b06 --- /dev/null +++ b/Ortho-Top/OrthoMain.py @@ -0,0 +1,625 @@ +# -*- coding: UTF-8 -*- +""" +@Project ：microproduct +@File ：OneOrthoMain.py +@Function ：正射校正 +@Author ：KHZ +@Contact： +@Date ：2021/8/14 +@Version ：1.0.0 +""" +import logging + +from tool.algorithm.block.blockprocess import BlockProcess +from tool.algorithm.image.ImageHandle import ImageHandler +from tool.algorithm.xml.CreateMetaDict import CreateMetaDict, CreateProductXml, OrthoAzimuth +from tool.algorithm.xml.AnalysisXml import DictXml +from tool.algorithm.algtools.PreProcess import PreProcess as pp +import tarfile +from tool.algorithm.xml.AlgXmlHandle import ManageAlgXML, CheckSource # 导入xml文件读取与检查文件 +from OrthoAlg import IndirectOrthorectification, DEMProcess, rpc_correction, getRCImageRC, get_RPC_lon_lat, \ + getRCImageRC2 +from OrthoAlg import ScatteringAlg as alg +from tool.algorithm.algtools.logHandler import LogHandler +from tool.config.ConfigeHandle import Config as cf +import os +import glob +# import gc +import datetime +import shutil +import sys +import scipy # 解决打包错误 +import scipy.spatial.transform # 用于解决打包错误 +import scipy.spatial.transform.rotation +import scipy.spatial.transform._rotation_groups # 用于解决打包错误 + +if cf.get('debug') == 'True': + DEBUG = True +else: + DEBUG = False +EXE_NAME = cf.get('exe_name') +productLevel = cf.get('productLEVEL') +tager = '-' + cf.get('target') +# env_str = os.getcwd() +env_str = os.path.dirname(os.path.abspath(sys.argv[0])) # os.path.split(os.path.realpath(__file__))[0] +os.environ['PROJ_LIB'] = env_str +LogHandler.init_log_handler(os.path.join("run_log", EXE_NAME)) # r"run_log\Ortho" +logger = logging.getLogger("mylog") +logger.info(env_str) + + +class LogHandler2: + """日志记录工具，用于输出程序运行状况。 + 这里因为是单程序执行，没有必要调用logging 类。 + 具体日志策略： + 1. 最外层使用try,catch 捕捉异常 + 2. 最后程序执行终止判断。 + 日志记录格式： + 第一行： + TaskID，时间，输入参数文件地址。 + 中间： + 时间，状态，执行步骤，消息 + + 最后一行： + finished 表示程序执行完成 + failed 程序执行出现错误 + + """ + + def __init__(self, sLogPath) -> None: + ''' + 初始化日志文件 + args: + sLogPath:str 日志文件的路径 + raise: + IOError:Exception 错误 + ''' + self.__sLogPath = sLogPath + + def loggingStart(self, sTaskID, sParamPath): + '''输出日志开头 + TaskID，时间，输入参数文件地址。 + args: + sTaskID:str 任务ID + sParamPath:str 任务参数文件地址 + return: + None + ''' + sDateTime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f") # 执行时间 + sOutput = "[{}],[{}],[{}]".format(sTaskID, sDateTime, sParamPath) + self.__outputText(sOutput) + pass + + def logging(self, sStates, sExecuteStep, sException): + """输出中间计算信息""" + sDateTime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f") # 执行时间 + sOutput = "[{}],[{}],[{}],[{}]".format(sDateTime, sStates, sExecuteStep, sExecuteStep) + self.__outputText(sOutput) + pass + + def __outputText(self, sMessage): + '''将消息输出到最终的日志文件中 + ''' + with open(self.__sLogPath, 'a', encoding='utf-8') as fp: + fp.write("{}".format(sMessage)) + + def logggingEnd(self, bSuccessful): + ''' + 最后一行输出，判断输出的结果是否是正确的 + ''' + if bSuccessful: + sEndText = "\n{}\nfinished".format(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")) + else: + sEndText = "\n{}\nError".format(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")) + self.__outputText(sEndText) + + +class OrthoMain: + """ + 间接定位法正射校正 主函数 + """ + + def __init__(self, alg_xml_path): + self.alg_xml_path = alg_xml_path + self.imageHandler = ImageHandler() + self.__alg_xml_handler = ManageAlgXML(alg_xml_path) + self.__check_handler = CheckSource(self.__alg_xml_handler) + self.__workspace_path = None + self.__task_id = None + self.__input_paras = {} + # self.__output_paras = {} + self.__in_processing_paras = {} + # self.__out_processing_paras = {} + self.__preprocessed_paras = {} + self.polsar_list = [] + self.__out_para = None + + def check_source(self): + """ + 检查算法相关的配置文件，图 + 像，辅助文件是否齐全 + """ + if self.__check_handler.check_alg_xml() is False: + return False + + if self.__check_handler.check_run_env() is False: + return False + + input_para_names = ["SLC", "DEM"] # //todo 增加检查校正方法 + if self.__check_handler.check_input_paras(input_para_names) is False: + return False + + self.__workspace_path = self.__alg_xml_handler.get_workspace_path() + self.__task_id = self.__alg_xml_handler.get_task_id() + self.__input_paras = self.__alg_xml_handler.get_input_paras() + # self.__output_paras = self.__alg_xml_handler.get_output_paras() + self.__create_work_space() + self.__in_processing_paras = self.__init_processing_paras(self.__input_paras) # 输入{paraname：paravalue} + # self.__out_processing_paras = self.__init_processing_paras(self.__output_paras) # 输入{paraname：paravalue} + + self.__out_name = \ + os.path.splitext(os.path.splitext(os.path.basename(self.__input_paras['SLC']['ParaValue']))[0])[0] + # AlgorithmName = self.__alg_xml_handler.get_algorithm_name() + # TaskId = self.__alg_xml_handler.get_task_id() + result_name = self.__out_name + ".tar.gz" + self.__out_para = os.path.join(self.__workspace_path, EXE_NAME, 'Output', result_name) + self.__out_para = self.__out_para.replace(".tar.gz", tager + ".tar.gz") + self.__alg_xml_handler.write_out_para("OrthoProduct", self.__out_para) # 写入输出参数 + logger.info('check_source finished!') + logger.info('progress bar :5％') + return True + + def __create_work_space(self): + """ + 删除原有工作区文件夹,创建新工作区文件夹 + """ + self.__workspace_Output_path = os.path.join(self.__workspace_path, EXE_NAME, "Output") + self.__workspace_Temporary_path = os.path.join(self.__workspace_path, EXE_NAME, "Temporary") + self.__workspace_unpack_path = os.path.join(self.__workspace_path, EXE_NAME, "Temporary", "unpack") + self.__workspace_ResampledDEM_path = os.path.join(self.__workspace_path, EXE_NAME, "Temporary", 'TestDEM') + self.__workspace_baseMap_path = os.path.join(self.__workspace_path, EXE_NAME, "Temporary", 'baseMap') + self.__workspace_LutImg_path = os.path.join(self.__workspace_path, EXE_NAME, "Temporary", 'TestLut') + self.__workspace_IncidenceImg_path = os.path.join(self.__workspace_path, EXE_NAME, "Temporary", 'TestInc') + self.__workspace_SimImg_path = os.path.join(self.__workspace_path, EXE_NAME, "Temporary", 'TestSim') + self.__workspace_SARIntensity_path = os.path.join(self.__workspace_path, EXE_NAME, "Temporary", 'TestSAR') + self.__workspace_package_path = os.path.join(self.__workspace_path, EXE_NAME, "Temporary", 'package') + self.__workspace_origin_path = os.path.join(self.__workspace_path, EXE_NAME, "Temporary", "origin") + + path_list = [self.__workspace_Output_path, self.__workspace_Temporary_path, + self.__workspace_unpack_path, self.__workspace_ResampledDEM_path, + self.__workspace_LutImg_path, self.__workspace_IncidenceImg_path, + self.__workspace_SimImg_path, self.__workspace_SARIntensity_path, + self.__workspace_package_path, self.__workspace_origin_path, + self.__workspace_baseMap_path] + + for path in path_list: + if os.path.exists(path): + if DEBUG is True: + continue + self.del_floder(path) + os.makedirs(path) + else: + os.makedirs(path) + logger.info('create new workspace success!') + + @staticmethod + def force_del_file(file_path): + """ + 强制删除文件 + """ + if os.path.isdir(file_path): + for main_dir, subdir, file_name_list in os.walk(file_path): + for filename in file_name_list: + apath = main_dir + filename + # noinspection PyBroadException + try: + os.remove(apath) + except Exception as error: # 使用windows命令行强制删除 + os.system("del /f /q %s" % apath) + elif os.path.isfile(file_path) is True: + # noinspection PyBroadException + try: + os.remove(file_path) + except Exception as error: # 使用windows命令行强制删除 + os.system("del /f /q %s" % file_path) + + @staticmethod + def make_targz(output_filename, source_dir): + """ + 一次性打包整个根目录。空子目录会被打包。 + 如果只打包不压缩，将"w:gz"参数改为"w:"或"w"即可。 + :param output_filename:输出压缩包的完整路径，eg:'E:\test.tar.gz' + :param source_dir:需要打包的跟目录，eg: 'E:\testFfile\'打包文件夹里面的所有文件,'E:\testFfile'打包文件夹 + """ + dir = os.path.split(output_filename)[0] + if os.path.exists(dir) is False: + os.makedirs(dir) + with tarfile.open(output_filename, "w:gz") as tar: + tar.add(source_dir, arcname=os.path.basename(source_dir)) + + @staticmethod + def del_floder(path_data): + """ + 删除整个文件夹 + """ + if os.path.isdir(path_data): + shutil.rmtree(path_data) + + def del_temp_workspace(self): + """ + 临时工作区 + """ + if DEBUG is True: + return + path = self.__workspace_path + EXE_NAME + r'\Temporary' + if os.path.exists(path): + self.del_floder(path) + + def __init_processing_paras(self, names): + """ + :param names:字典列表，每个字典为一个输入产品的配置信息 + """ + processing_paras = {} + for name in names: + para = names[name] + if para is None: + logger.error(name + "is None!") + return False + + if para['ParaType'] == 'File': + if para['DataType'] == 'File': + para_path = os.path.join(self.__workspace_path, para['ParaValue']) + processing_paras.update({name: para_path}) + if para['DataType'] == 'xml': + para_path = os.path.join(self.__workspace_path, para['ParaValue']) + processing_paras.update({name: para_path}) + if para['DataType'] == "ymal": + para_path = os.path.join(self.__workspace_path, para['ParaValue']) + processing_paras.update({name: para_path}) + if para['DataType'] == 'tar.gz': + para_path = os.path.join(self.__workspace_path, para['ParaValue']) + tar_gz_dic = self.__dec_tar_gz(name, para_path, self.__workspace_unpack_path) + processing_paras.update(tar_gz_dic) + if para['DataType'] == 'tif' or para['DataType'] == 'tiff': # 新增修改dem数据为文件绝对路径 + if para['ParaValue'] != 'empty' and para['ParaValue'] != 'Empty' and para['ParaValue'] != '': + para_path_list = para['ParaValue'].split(";") + if len(para_path_list) != 0: + dem_path = os.path.join(self.__workspace_origin_path, para['ParaName']) + if os.path.exists(dem_path) is False: + os.mkdir(dem_path) + for file_path in para_path_list: + tif_name = os.path.basename(file_path) + shutil.copy(file_path, os.path.join(dem_path, tif_name)) + para_path = os.path.join(self.__workspace_origin_path, para['ParaName']) + processing_paras.update({name: para_path}) + if para['DataType'] == 'zip': # 新增修改dem数据为文件绝对路径 + if para['ParaValue'] != 'empty' and para['ParaValue'] != 'Empty' and para['ParaValue'] != '': + para_path_list = para['ParaValue'].split(";") + if len(para_path_list) != 0: + dem_path = os.path.join(self.__workspace_origin_path, para['ParaName']) + if os.path.exists(dem_path) is False: + os.mkdir(dem_path) + for file_path in para_path_list: + BlockProcess.unzip_dem(file_path, dem_path) + # tif_name = os.path.basename(file_path) + # shutil.copy(file_path, os.path.join(dem_path, tif_name)) + para_path = os.path.join(self.__workspace_origin_path, para['ParaName']) + processing_paras.update({name: dem_path}) + elif para['ParaType'] == 'Value': + if para['DataType'] == 'float': + value = float(para['ParaValue']) + processing_paras.update({name: value}) + return processing_paras + + def __dec_tar_gz(self, name1, tar_gz_path, out_dir): + """ + 解压.tar_gz格式景影像文件 + :param tar_gz_path:.tar_gz文件路径 + :param out_dir:输出文件夹 + :return para_dic:全极化影像路径 + """ + # 创建文件夹 + name = os.path.split(tar_gz_path)[1].rstrip('.tar.gz') + name_d = name.split('_')[6] + file_dir = os.path.join(out_dir, name_d + '\\') + if os.path.exists(file_dir) is False: + os.makedirs(file_dir) + # 解压 + t = tarfile.open(tar_gz_path) + t.extractall(path=file_dir) + + para_dic = {} + + tif_files = list(glob.glob(os.path.join(file_dir, '*.tiff'))) + tif_files += list(glob.glob(os.path.join(file_dir, '*.tif'))) + hh_list, hv_list, vh_list, vv_list, dh_list = [], [], [], [], [] + for in_tif_path in tif_files: + file_baseName = os.path.splitext(os.path.basename(in_tif_path))[0] + + if 'hh' in file_baseName or 'HH' in file_baseName: + hh_list.append(in_tif_path) + self.polsar_list.append('HH') + elif 'hv' in file_baseName or 'HV' in file_baseName: + hv_list.append(in_tif_path) + self.polsar_list.append('HV') + elif 'vh' in file_baseName or 'VH' in file_baseName: + vh_list.append(in_tif_path) + self.polsar_list.append('VH') + elif 'vv' in file_baseName or 'VV' in file_baseName: + vv_list.append(in_tif_path) + self.polsar_list.append('VV') + elif "DH" in os.path.basename(in_tif_path): + dh_list.append(in_tif_path) + self.polsar_list.append('DH') + self.polsar_list = list(set(self.polsar_list)) + para_dic.update({'HH': hh_list}) + para_dic.update({'HV': hv_list}) + para_dic.update({'VH': vh_list}) + para_dic.update({'VV': vv_list}) + para_dic.update({'DH': dh_list}) + + # 获取文件夹内的文件 + + if os.path.exists(file_dir + name + '\\'): + meta_xml_paths = list(glob.glob(os.path.join(file_dir + name, '*.xml'))) + para_dic.update({'SLC': file_dir + name}) + else: + meta_xml_paths = list(glob.glob(os.path.join(file_dir, '*.xml'))) + para_dic.update({'SLC': file_dir}) + + if meta_xml_paths == []: + raise Exception('there is not .meta.xml in path: ', file_dir + '\\') + para_dic.update({'META': meta_xml_paths[0]}) + self.image_meta_xml = meta_xml_paths + # para_dic.update({name1: file_dir}) # {SLC: file_path} + + return para_dic + + def process_handle(self): + return self.RD_process_handle() + + def cut_dem(self, dem_merged_path, meta_file_path): + _, scopes = DictXml(meta_file_path).get_extend() + intersect_polygon = pp().intersect_polygon(scopes) + if intersect_polygon is None: + raise Exception('cal intersect box fail!') + shp_path = os.path.join(self.__workspace_Temporary_path, 'IntersectPolygon.shp') + if pp().write_polygon_shp(shp_path, intersect_polygon, 4326) is False: + raise Exception('create intersect shp fail!') + dem_process = os.path.join(self.__workspace_Temporary_path, 'dem_cut.tif') + pp().cut_img(dem_process, dem_merged_path, shp_path) + return dem_process + + def process_sim_ori(self, ori_sim, sim_ori): + p = pp() + scopes = () + scopes += p.box2scope('34.60;34.67;113.05;113.18') + + intersect_polygon = pp().intersect_polygon(scopes) + if intersect_polygon is None: + raise Exception('create intersect shp fail!') + shp_path = os.path.join(self.__workspace_Temporary_path, 'IntersectPolygon.shp') + if pp().write_polygon_shp(shp_path, intersect_polygon, 4326) is False: + raise Exception('create intersect shp fail!') + sim_ori_process = os.path.join(self.__workspace_Temporary_path, 'sim_ori_process.tif') + pp().cut_img(sim_ori_process, sim_ori, shp_path) + return sim_ori_process + + def correct_sim_ori(self, Orthorectification, slc_paths, bsMap_merged_path, out_dir_path): + # 对映射表进行校正 + sim_ori_tiff = out_dir_path + "\\" + "RD_sim_ori.tif" + out_sim_ori = out_dir_path + "\\" + "sim_ori-ortho.tif" + out_sim_ori_temp = self.__workspace_baseMap_path + "\\" + "sim_ori-ortho.tif" + parameter_path = os.path.join(self.__workspace_package_path, "orth_para.txt") + in_tif_paths = list(glob.glob(os.path.join(slc_paths, '*.tiff'))) + out_rpc_db = os.path.join(self.__workspace_baseMap_path, 'rpc_line.tif') + alg.sar_backscattering_coef_RPC(in_tif_paths[0], self.__in_processing_paras['META'], out_rpc_db) + + db_tif_path = os.path.join(self.__workspace_baseMap_path, 'rpc_db_geo.tif') + + Orthorectification.calInterpolation_bil_Wgs84_rc_sar_sigma(parameter_path, sim_ori_tiff, out_rpc_db, + db_tif_path) + dataset = ImageHandler().get_dataset(db_tif_path) + baseMapCut = os.path.join(self.__workspace_baseMap_path, 'baseMapCut.tif') + inputCut = os.path.join(self.__workspace_baseMap_path, 'inputCut.tif') + baseMapResample = os.path.join(self.__workspace_baseMap_path, 'baseMapCut_Resample.tif') + shpCenterFile = os.path.join(self.__workspace_baseMap_path, 'shpCenter.shp') + center_scopes = (ImageHandler().get_center_scopes(dataset),) + intersect_polygon = pp().intersect_polygon(center_scopes) + if intersect_polygon is None: + raise Exception('create intersect shp fail!') + if pp().write_polygon_shp(shpCenterFile, intersect_polygon, 4326) is False: + raise Exception('create intersect shp fail!') + pp().cut_img(baseMapCut, bsMap_merged_path, shpCenterFile) + pp().cut_img(inputCut, db_tif_path, shpCenterFile) + pp().resampling_by_scale(baseMapCut, baseMapResample, inputCut) + in_sar_png = self.imageHandler.write_view(inputCut) + baseMap_png = self.imageHandler.write_view(baseMapResample) + Orthorectification.get_offset(in_sar_png, baseMap_png, inputCut) + off_txt = os.path.join(os.path.dirname(inputCut), 'off.txt') + with open(off_txt, 'r') as f: + data = f.readlines() + x = float(data[0]) + y = float(data[1]) + im_proj, im_geotrans, im_arr = self.imageHandler.read_img(sim_ori_tiff) + lon_new = im_geotrans[0] + x + lat_new = im_geotrans[3] - y + im_geosNew = [lon_new, im_geotrans[1], im_geotrans[2], lat_new, im_geotrans[4], im_geotrans[5]] + # ImageHandler().write_img(out_sim_ori, im_proj, im_geosNew, im_arr) + ImageHandler().write_img(out_sim_ori_temp, im_proj, im_geosNew, im_arr) + pp.resample_by_gdal(out_sim_ori_temp, out_sim_ori) # todo 重采样为方像元 + os.remove(sim_ori_tiff) + return out_sim_ori + + def RD_process_handle(self): + # RPC + logger.info(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')) + # print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')) + # 1、DEM拼接、裁剪、重采样 + Orth_Slc = [] + in_dem_path = self.__in_processing_paras['DEM'] + meta_file_path = self.__in_processing_paras['META'] # .meta文件路径 + out_dem_path = self.__workspace_ResampledDEM_path + dem_merged_path = DEMProcess.dem_merged(in_dem_path, meta_file_path, + out_dem_path) # 生成TestDEM\mergedDEM_VRT.tif + + # bsMap = self.__in_processing_paras['baseMap'] + # ortho_bsMap_path = self.__workspace_baseMap_path + # bsMap_merged_path = DEMProcess.bsMap_merged(bsMap, meta_file_path, ortho_bsMap_path) + + dem_path = self.cut_dem(dem_merged_path, meta_file_path) + # 2、间接定位法求解行列坐标 + sim_ori_map = {} + patamter_map = {} + inc_angle_dir = os.path.join(self.__workspace_Temporary_path, f"incAngle") + localincidentAngle_dir = os.path.join(self.__workspace_Temporary_path, f"localincidentAngle") + if not os.path.exists(inc_angle_dir): + os.makedirs(inc_angle_dir) + if not os.path.exists(localincidentAngle_dir): + os.makedirs(localincidentAngle_dir) + slc_paths = self.__in_processing_paras[self.polsar_list[0]] + for slc_path in slc_paths: + baseName = os.path.splitext(os.path.basename(slc_path))[0] + + temp_dir = os.path.join(self.__workspace_Temporary_path, baseName) + if not os.path.exists(temp_dir): + os.makedirs(temp_dir) + + path2 = env_str + Orthorectification = IndirectOrthorectification(os.path.join(path2, "config.yaml")) + + Orthorectification.IndirectOrthorectification_top(self.__in_processing_paras["META"], slc_path, + temp_dir) # 改动1 + + Orthorectification.preCaldem_sar_rc(dem_path, slc_path, self.__workspace_Temporary_path, temp_dir) + + strip_id = baseName.split('_')[-1] + RD_sim_ori = os.path.join(temp_dir, 'RD_sim_ori.tif') + sim_ori_ortho = os.path.join(self.__workspace_package_path, f"sim_ori_{strip_id}-ortho.tif") + shutil.move(RD_sim_ori, sim_ori_ortho) + sim_ori_map.update({'sim_ori_strip_' + strip_id: sim_ori_ortho}) + + paramter_path = os.path.join(temp_dir, 'orth_para.txt') + patamter_map.update({'paramter_strip_' + strip_id: paramter_path}) + + inc_angle_strip = os.path.join(temp_dir, 'incidentAngle.tiff') + inc_angle_merged = os.path.join(inc_angle_dir, f"incidentAngle_{strip_id}.tif") + shutil.move(inc_angle_strip, inc_angle_merged) + + localincidentAngle_strip = os.path.join(temp_dir, 'localincidentAngle.tiff') + localincidentAngle_merged = os.path.join(localincidentAngle_dir, f"localincidentAngle_{strip_id}.tif") + shutil.move(localincidentAngle_strip, localincidentAngle_merged) + + DEMProcess.tif_merged(inc_angle_dir, self.__workspace_origin_path, self.__workspace_package_path) + DEMProcess.tif_merged(localincidentAngle_dir, self.__workspace_origin_path, self.__workspace_package_path) + + tif_db_dir_list = [] + for polr in self.polsar_list: + tifFiles = self.__in_processing_paras[polr] + tif_db_dir = os.path.join(self.__workspace_Temporary_path, f"{polr}_db") + if not os.path.exists(tif_db_dir): + os.makedirs(tif_db_dir) + tif_db_dir_list.append(tif_db_dir) + for tif in tifFiles: + baseName = os.path.splitext(os.path.basename(tif))[0] + strip_id = baseName.split('_')[-1] + inc_xml_path = os.path.join(os.path.dirname(slc_path), baseName + '.incidence') + inc_path = os.path.join(self.__workspace_Temporary_path, baseName + '_angle.tif') + rows = self.imageHandler.get_img_height(slc_path) + ImageHandler.get_inc_angle(inc_xml_path, rows, 1, inc_path) + + out_power_path = os.path.join(self.__workspace_Temporary_path, + os.path.basename(tif).replace(".tiff", "-lin.tif").replace("L1A", + "L1B")).replace( + "HH", "h_h").replace("HV", "h_v").replace("VH", "v_h").replace("VV", "v_v").replace("DH", "d_h") + + alg.sar_backscattering_coef(tif, self.__in_processing_paras['META'], out_power_path, inc_path) + + lin_tif_path = os.path.join(self.__workspace_Temporary_path, + os.path.basename(out_power_path).split('-')[0] + "-lin_geo.tif") + + Orthorectification.calInterpolation_bil_Wgs84_rc_sar_sigma(patamter_map[f"paramter_strip_{strip_id}"], + sim_ori_map[f"sim_ori_strip_{strip_id}"], + out_power_path, + lin_tif_path) + tempout_tif_path = os.path.join(tif_db_dir, + os.path.basename(lin_tif_path).split('-')[0] + '.tif') + alg.lin_to_db_top(lin_tif_path, tempout_tif_path) # 线性值转回DB值 + + for tif_merged in tif_db_dir_list: + DEMProcess.tif_merged(tif_merged, self.__workspace_origin_path, self.__workspace_package_path) + + for tiff_name in os.listdir(self.__workspace_package_path): + if (tiff_name.find(".tiff") > 0 or tiff_name.find(".tif") > 0) and 'sim_ori' not in tiff_name: + self.imageHandler.write_quick_view(os.path.join(self.__workspace_package_path, tiff_name)) + + tem_folder = self.__workspace_path + EXE_NAME + r"\Temporary""\\" + image_path = tempout_tif_path # os.path.join(self.__workspace_package_path, "OrthoMapTable.tif") + out_path1 = os.path.join(tem_folder, "trans_geo_projcs.tif") + out_path2 = os.path.join(tem_folder, "trans_projcs_geo.tif") + model_path = "./product.xml" + meta_xml_path = os.path.join(self.__workspace_package_path, + os.path.basename(self.__out_para).replace(".tar.gz", ".meta.xml")) + + para_dict = CreateMetaDict(image_path, self.__in_processing_paras['META'], self.__workspace_package_path, + out_path1, out_path2).calu_nature() + + Azimuth = os.path.join(self.__workspace_Temporary_path, 'Azimuth.txt') + if os.path.exists(Azimuth): + Azimuth_incidence = OrthoAzimuth.get_Azimuth_incidence(Azimuth) + else: + logger.warning("read Azimuth txt failed!") + Azimuth_incidence = 'None' + + para_dict.update({"ObservationGeometry_SatelliteAzimuth": Azimuth_incidence}) + para_dict.update({"imageinfo_ProductName": '正射校正'}) + para_dict.update({"imageinfo_ProductIdentifier": 'Ortho'}) + para_dict.update({"imageinfo_ProductLevel": productLevel}) + para_dict.update({"ProductProductionInfo_BandSelection": "1,2"}) + para_dict.update({"ProductProductionInfo_AuxiliaryDataDescription": "DEM"}) + CreateProductXml(para_dict, model_path, meta_xml_path).create_standard_xml() + + temp_folder = os.path.join(self.__workspace_path, EXE_NAME, 'Output') + out_xml = os.path.join(temp_folder, os.path.basename(meta_xml_path)) + if os.path.exists(temp_folder) is False: + os.mkdir(temp_folder) + # CreateProductXml(para_dict, model_path, out_xml).create_standard_xml() + shutil.copy(meta_xml_path, out_xml) + + # 生成压缩包 + logger.info('progress bar :94％') + logger.info('start make targz..') + # self.del_floder(self.__workspace_unpack_path) + # self.del_floder(self.__workspace_ResampledDEM_path) + # self.del_floder(self.__workspace_LutImg_path) + # self.del_floder(self.__workspace_IncidenceImg_path) + # self.del_floder(self.__workspace_SimImg_path) + # self.del_floder(self.__workspace_SARIntensity_path) + self.make_targz(self.__out_para, self.__workspace_package_path + "\\") + logger.info('make targz finish') + logger.info('progress bar :100％') + return True + pass + + +if __name__ == '__main__': + start = datetime.datetime.now() + try: + if len(sys.argv) < 2: + xml_path = 'Ortho_S_SAR_V3.xml' + else: + xml_path = sys.argv[1] + OrthoMain = OrthoMain(xml_path) + if OrthoMain.check_source() is False: + raise Exception('check_source() failed!') + if OrthoMain.process_handle() is False: + raise Exception('check_source() failed!') + logger.info('successful production of ortho products!') + except Exception: + logger.exception("run-time error!") + finally: + OrthoMain.del_temp_workspace() + pass + end = datetime.datetime.now() + logger.info('running use time: %s ' % (end - start)) + diff --git a/Ortho-Top/OrthoMain.spec b/Ortho-Top/OrthoMain.spec new file mode 100644 index 0000000..b9503b2 --- /dev/null +++ b/Ortho-Top/OrthoMain.spec @@ -0,0 +1,62 @@ +# -*- mode: python ; coding: utf-8 -*- +import sys +from shutil import copy +import os + +cwdpath = os.getcwd() +toolDir = os.path.join(cwdpath, 'tool') +if os.path.exists(toolDir): + os.remove(toolDir) +os.mkdir(toolDir) +source_folder = '../tool' + +def copy_file(path_read, path_write): + names = os.listdir(path_read) + for name in names: + path_read_new = os.path.join(path_read, name) + path_write_new = os.path.join(path_write, name) + if os.path.isdir(path_read_new): + if not os.path.exists(path_write_new): + os.mkdir(path_write_new) + copy_file(path_read_new, path_write_new) + else: + copy(path_read_new, path_write_new) + +copy_file(source_folder, toolDir) +block_cipher = None + + +a = Analysis(['OrthoMain.py'], + pathex=[], + binaries=[], + datas=[('D:/Anaconda/envs/micro/Lib/site-packages/dask/dask.yaml', './dask'), ('D:/Anaconda/envs/micro/Lib/site-packages/distributed/distributed.yaml', './distributed')], + hiddenimports=['pyproj._compat'], + hookspath=[], + hooksconfig={}, + runtime_hooks=[], + excludes=[], + win_no_prefer_redirects=False, + win_private_assemblies=False, + cipher=block_cipher, + noarchive=False) +pyz = PYZ(a.pure, a.zipped_data, + cipher=block_cipher) + +exe = EXE(pyz, + a.scripts, + a.binaries, + a.zipfiles, + a.datas, + [], + name='OrthoMain', + debug=False, + bootloader_ignore_signals=False, + strip=False, + upx=True, + upx_exclude=[], + runtime_tmpdir=None, + console=True, + disable_windowed_traceback=False, + target_arch=None, + codesign_identity=None, + entitlements_file=None ) diff --git a/Ortho-Top/OrthoXmlInfo.py b/Ortho-Top/OrthoXmlInfo.py new file mode 100644 index 0000000..b689502 --- /dev/null +++ b/Ortho-Top/OrthoXmlInfo.py @@ -0,0 +1,310 @@ +""" +@Project ：microproduct +@File ：BackScatteringXmlInfo.PY +@Function ：主函数 +@Author ：LMM +@Date ：2021/10/19 14:39 +@Version ：1.0.0 +""" +import os +from xml.etree.ElementTree import ElementTree, Element +import xml.dom.minidom +from lxml import etree +import shutil +from tool.algorithm.image.ImageHandle import ImageHandler +from tool.algorithm.algtools.PreProcess import PreProcess as pp +from osgeo import gdal +import numpy as np +import datetime +from PIL import Image + + +class CreateDict: + """根据影像/DEM的属性信息添加到字典中""" + def __init__(self): + self.ImageHandler = ImageHandler() + pass + + def calu_nature(self, image_path, image_pair, out_path1, out_path2): + """ + 将productinfo节点需要填写的信息存入字典中 + image_path:影像路径 + image_pair:输入的压缩包中的极化对 例：hh,hv,vh,vv=【1，1，1，1】 + out_path1：地理转平面的输出路径 + out_path2：平面转地理的输出路径 + """ + + para_dict = {} + imageinfo_width = self.ImageHandler.get_img_width(image_path) + para_dict.update({"imageinfo_width":imageinfo_width}) + imageinfo_height = self.ImageHandler.get_img_height(image_path) + para_dict.update({"imageinfo_height":imageinfo_height}) + para_dict.update({"imageinfo_EarthModel": "WGS84"}) + para_dict.update({"imageinfo_ProjectModel": "UTM"}) + proj = self.ImageHandler.get_projection(image_path) # 输出的影像若是投影坐标系则先转成地理坐标系 + keyword = proj.split("[", 2)[0] # 若是地理坐标系则pass + if keyword == "GEOGCS": + pass + elif keyword == "PROJCS": + pp.trans_projcs2geogcs(out_path2, image_path) + image_path = out_path2 + elif len(keyword) == 0 or keyword.strip() == "" or keyword.isspace() is True: + raise Exception('image projection is missing!') + + pp.trans_geogcs2projcs(out_path1, image_path) # 坐标投影, 地理转平面投影坐标 + imageinfo_widthspace = self.ImageHandler.get_geotransform(out_path1)[1] # 投影后的分辨率 + imageinfo_heightspace = -self.ImageHandler.get_geotransform(out_path1)[5] # 投影后的分辨率 + para_dict.update({"imageinfo_widthspace":imageinfo_widthspace}) + para_dict.update({"imageinfo_heightspace":imageinfo_heightspace}) + para_dict.update({"NominalResolution":imageinfo_widthspace}) + + WidthInMeters = imageinfo_width*imageinfo_widthspace # 投影后的分辨率×宽度 + para_dict.update({"WidthInMeters":WidthInMeters}) + + image_array = self.ImageHandler.get_band_array(image_path) + a2 = np.where(np.isnan(image_array), 999999, image_array) + MinValue = np.min(a2) + a3 = np.where(np.isnan(image_array), -999999, image_array) + MaxValue = np.max(a3) + + para_dict.update({"MaxValue":MaxValue}) + para_dict.update({"MinValue":MinValue}) + + get_scope = self.ImageHandler.get_scope(image_path) + point_upleft, point_upright, point_downleft, point_downright=get_scope[0], get_scope[1], get_scope[2], get_scope[3] + para_dict.update({"imageinfo_corner_topLeft_latitude": point_upleft[1]}) + para_dict.update({"imageinfo_corner_topLeft_longitude": point_upleft[0]}) + para_dict.update({"imageinfo_corner_topRight_latitude": point_upright[1]}) + para_dict.update({"imageinfo_corner_topRight_longitude": point_upright[0]}) + para_dict.update({"imageinfo_corner_bottomLeft_latitude": point_downleft[1]}) + para_dict.update({"imageinfo_corner_bottomLeft_longitude": point_downleft[0]}) + para_dict.update({"imageinfo_corner_bottomRight_latitude": point_downright[1]}) + para_dict.update({"imageinfo_corner_bottomRight_longitude": point_downright[0]}) + + longitude_max=np.array([point_upleft[0], point_upright[0], point_downleft[0], point_downright[0]]).max() + longitude_min=np.array([point_upleft[0], point_upright[0], point_downleft[0], point_downright[0]]).min() + latitude_max=np.array([point_upleft[1], point_upright[1], point_downleft[1], point_downright[1]]).max() + latitude_min=np.array([point_upleft[1], point_upright[1], point_downleft[1], point_downright[1]]).min() + imageinfo_center_latitude=(latitude_max+latitude_min)/2 + imageinfo_center_longitude=(longitude_max+longitude_min)/2 + para_dict.update({"imageinfo_center_latitude": imageinfo_center_latitude}) + para_dict.update({"imageinfo_center_longitude": imageinfo_center_longitude}) + + # self.para_dict.update({"productType": "GTC"}) # 设置产品类型 + para_dict.update({"productFormat": "TIF"}) + productGentime = datetime.datetime.now() + para_dict.update({"productGentime": productGentime}) + para_dict.update({"unit": "none"}) # 设置单位 + para_dict.update({"NoDataValue": "nan"}) + para_dict.update({"productLevel": "4"}) # 设置图像位深度 + + image_array = self.ImageHandler.get_band_array(image_path) + try: # 设置图像位深度 + gdal_dtypes = { + 'int8': gdal.GDT_Byte, + 'unit16': gdal.GDT_UInt16, + 'int16': gdal.GDT_Int16, + 'unit32': gdal.GDT_UInt32, + 'int32': gdal.GDT_Int32, + 'float32': gdal.GDT_Float32, + 'float64': gdal.GDT_Float64, + } + bit_dtypes = { + 'int8': 8, + 'unit16': 16, + 'int16': 16, + 'unit32': 32, + 'int32': 32, + 'float32': 32, + 'float64': 64, + } + if not gdal_dtypes.get(image_array.dtype.name, None) is None: + bit_num = str(bit_dtypes[image_array.dtype.name]) + datatype=bit_num+"bit" + else: + datatype = str(32) + "bit" + # datatype = str(gdal.GDT_Float32)+"bit" + para_dict.update({"imagebit": datatype}) + except Exception: + para_dict.update({"imagebit": "None"}) + + HH, HV, VH ,VV= image_pair[0], image_pair[1], image_pair[2], image_pair[3] + if HH == 0: + HH = "delete" + else: + HH = "NULL" + para_dict.update({"imageinfo_QualifyValue_HH": HH}) + if HV==0: + HV = "delete" + else: + HV = "NULL" + para_dict.update({"imageinfo_QualifyValue_HV": HV}) + if VH==0: + VH = "delete" + else: + VH = "NULL" + para_dict.update({"imageinfo_QualifyValue_VH": VH}) + if VV==0: + VV = "delete" + else: + VV = "NULL" + para_dict.update({"imageinfo_QualifyValue_VV": VV}) + + return para_dict + + def calu_dem_nature(self, dem_path, out_dem_path1, out_dem_path2, sampling_f, para_A_arr): + """ + 正射需要单独加上dem影像的信息 + dem_path：mergedDEM.tif路径 + out_dem_path1：将mergedDEM.tif由地理坐标转化为平面坐标的保存路径 + out_dem_path2：将mergedDEM.tif由平面坐标转化为地理坐标的保存路径 + sampling_f： 采样率 + para_A_arr：四次多项式模型的参数数组 + """ + para_dict2 = {} + proj = self.ImageHandler.get_projection(dem_path) # 输出的影像若是投影坐标系则先转成地理坐标系 + keyword = proj.split("[", 2)[0] # 若是地理坐标系则pass + if keyword == "GEOGCS": + pass + elif keyword == "PROJCS": + pp.trans_projcs2geogcs(out_dem_path2, dem_path) + dem_path = out_dem_path2 + elif len(keyword) == 0 or keyword.strip() == "" or keyword.isspace() is True: + raise Exception('image projection is missing!') + pp.trans_geogcs2projcs(out_dem_path1, dem_path) # 坐标投影, 地理转平面投影坐标 + DEM_widthspace = self.ImageHandler.get_geotransform(out_dem_path1)[1] # 投影后的分辨率 + DEM_heightspace = -self.ImageHandler.get_geotransform(out_dem_path1)[5] # 投影后的分辨率 + para_dict2.update({"DEM_widthspace":DEM_widthspace}) + para_dict2.update({"DEM_heightspace":DEM_heightspace}) + # tree = ElementTree() # 获取DEMProduct：dem产品来源、DEMDate：dem对应的日期 + # tree.parse(dem_meta) # 影像头文件 + # root = tree.getroot() + # productinfo = root.find("metadata") + # DEMProduct = list(productinfo)[0].tag + # para_dict2.update({"DEM_DEMProduct":DEMProduct}) + # + # DEMDate = root.find("metadata").find(DEMProduct).text + # para_dict2.update({"DEM_DEMDate": DEMDate}) + get_scope = self.ImageHandler.get_scope(dem_path) # 获取mergedDEM.tif数据的四个角的经纬度信息 + point_upleft, point_upright, point_downleft, point_downright=get_scope[0], get_scope[1], get_scope[2], get_scope[3] + para_dict2.update({"DEM_corner_topLeft_latitude": point_upleft[1]}) + para_dict2.update({"DEM_corner_topLeft_longitude": point_upleft[0]}) + para_dict2.update({"DEM_corner_topRight_latitude": point_upright[1]}) + para_dict2.update({"DEM_corner_topRight_longitude": point_upright[0]}) + para_dict2.update({"DEM_corner_bottomLeft_latitude": point_downleft[1]}) + para_dict2.update({"DEM_corner_bottomLeft_longitude": point_downleft[0]}) + para_dict2.update({"DEM_corner_bottomRight_latitude": point_downright[1]}) + para_dict2.update({"DEM_corner_bottomRight_longitude": point_downright[0]}) + #para_dict2.update({"orthoModel_samplingrate": sampling_f}) + + para_dict2.update({"satalliteOrbitModel_parameter_X_a0": para_A_arr[0, 0]}) # 获取四次多项式模型6个参数的数值 + para_dict2.update({"satalliteOrbitModel_parameter_X_a1": para_A_arr[1, 0]}) + para_dict2.update({"satalliteOrbitModel_parameter_X_a2": para_A_arr[2, 0]}) + para_dict2.update({"satalliteOrbitModel_parameter_X_a3": para_A_arr[3, 0]}) + para_dict2.update({"satalliteOrbitModel_parameter_X_a4": para_A_arr[4, 0]}) + + para_dict2.update({"satalliteOrbitModel_parameter_Y_b0": para_A_arr[0, 1]}) + para_dict2.update({"satalliteOrbitModel_parameter_Y_b1": para_A_arr[1, 1]}) + para_dict2.update({"satalliteOrbitModel_parameter_Y_b2": para_A_arr[2, 1]}) + para_dict2.update({"satalliteOrbitModel_parameter_Y_b3": para_A_arr[3, 1]}) + para_dict2.update({"satalliteOrbitModel_parameter_Y_b4": para_A_arr[4, 1]}) + + para_dict2.update({"satalliteOrbitModel_parameter_Z_c0": para_A_arr[0, 2]}) + para_dict2.update({"satalliteOrbitModel_parameter_Z_c1": para_A_arr[1, 2]}) + para_dict2.update({"satalliteOrbitModel_parameter_Z_c2": para_A_arr[2, 2]}) + para_dict2.update({"satalliteOrbitModel_parameter_Z_c3": para_A_arr[3, 2]}) + para_dict2.update({"satalliteOrbitModel_parameter_Z_c4": para_A_arr[4, 2]}) + + para_dict2.update({"satalliteOrbitModel_parameter_Vx_d0": para_A_arr[0, 3]}) + para_dict2.update({"satalliteOrbitModel_parameter_Vx_d1": para_A_arr[1, 3]}) + para_dict2.update({"satalliteOrbitModel_parameter_Vx_d2": para_A_arr[2, 3]}) + para_dict2.update({"satalliteOrbitModel_parameter_Vx_d3": para_A_arr[3, 3]}) + para_dict2.update({"satalliteOrbitModel_parameter_Vx_d4": para_A_arr[4, 3]}) + + para_dict2.update({"satalliteOrbitModel_parameter_Vy_e0": para_A_arr[0, 4]}) + para_dict2.update({"satalliteOrbitModel_parameter_Vy_e1": para_A_arr[1, 4]}) + para_dict2.update({"satalliteOrbitModel_parameter_Vy_e2": para_A_arr[2, 4]}) + para_dict2.update({"satalliteOrbitModel_parameter_Vy_e3": para_A_arr[3, 4]}) + para_dict2.update({"satalliteOrbitModel_parameter_Vy_e4": para_A_arr[4, 4]}) + + para_dict2.update({"satalliteOrbitModel_parameter_Vz_f0": para_A_arr[0, 5]}) + para_dict2.update({"satalliteOrbitModel_parameter_Vz_f1": para_A_arr[1, 5]}) + para_dict2.update({"satalliteOrbitModel_parameter_Vz_f2": para_A_arr[2, 5]}) + para_dict2.update({"satalliteOrbitModel_parameter_Vz_f3": para_A_arr[3, 5]}) + para_dict2.update({"satalliteOrbitModel_parameter_Vz_f4": para_A_arr[4, 5]}) + return para_dict2 + + +class CreateStadardXmlFile: + """读取字典中的属性值，生成一个标准的xml文件""" + def __init__(self, xml_path, para_xml_path, par_dict, par_dict2, path): + """ + xml_path:模板路径 + para_xml_path:算法配置文件的路径 + par_dict:字典 + path:xml模板输出路径 + """ + self.par_dict = par_dict + self.par_dict2 = par_dict2 + self.path = path + shutil.copy(xml_path, path) + pass + + def create_standard_xml(self): + """将字典中的信息写入到copy的xml文件中""" + tree = ElementTree() + tree.parse(self.path) # 影像头文件 + root = tree.getroot() + + productinfo = root.find("productinfo") + for key, value in self.par_dict.items(): + if key.split("_")[0] != "imageinfo": + productinfo.find(key).text = str(value) + elif key.split("_")[0] == "imageinfo": + imageinfo = productinfo.find("imageinfo") + if key.split("_")[1] in ["EarthModel", "ProjectModel", "width", "height", "widthspace", "heightspace"]: + imageinfo.find(key.split("_")[1]).text = str(value) + elif key.split("_")[1] == "center": + center = imageinfo.find("center") + center.find(key.split("_")[2]).text = str(value) + elif key.split("_")[1] == "corner": + corner = imageinfo.find("corner") + corner.find(key.split("_")[2]).find(key.split("_")[3]).text = str(value) + elif key.split("_")[1] == "QualifyValue": + QualifyValue = imageinfo.find("QualifyValue") + if value =="delete": + element_QualifyValue = list(QualifyValue) + for i in element_QualifyValue: + if i.tag == key.split("_")[2]: + QualifyValue.remove(i) + else: + QualifyValue.find(key.split("_")[2]).text = str(value) + pass + orthoModel = root.find("processinfo").find("orthoModel") # 写入四次多项式模型 + for key, value in self.par_dict2.items(): + if key.split("_")[0] == "satalliteOrbitModel": + satalliteOrbitModel = orthoModel.find("satalliteOrbitModel") + satalliteOrbitModel.find(key.split("_")[1]).find(key.split("_")[2]).find(key.split("_")[3]).text = str(value) + elif key.split("_")[0] == "DEM": # 写入dem四个角坐标 + DEM= orthoModel.find("DEM") + if key.split("_")[1] == "corner": + corner = DEM.find("corner") + corner.find(key.split("_")[2]).find(key.split("_")[3]).text = str(value) + elif key.split("_")[1] == "widthspace" or key.split("_")[1] == "heightspace": + DEM.find(key.split("_")[1]).text = str(value) + elif key.split("_")[1] == "samplingrate": + orthoModel.find(key.split("_")[1]).text = str(value) + tree.write(self.path, encoding="utf-8", xml_declaration=True) + +# +# if __name__ == '__main__': +# +# xml_path = "./model_meta.xml" +# tem_folder= r"E:\microproduct\测试" +# image_path = r"E:\microproduct\测试\GF3_MYN_QPSI_011437_E98_HH_AtmosphericDelay.tif" # 输入影像 +# out_path = os.path.join(tem_folder, "trans_geo_projcs.tif") +# image_pair=[1, 1, 1, 0] +# par_dict = CreateDict(image_path, image_pair, out_path).calu_nature() # 计算属性字典 +# +# out_xml_path = os.path.join(tem_folder, "creat_standard.meta.xml") # 输出xml路径 +# CreateStadardXmlFile(xml_path, par_dict, out_xml_path).create_standard_xml() diff --git a/Ortho-Top/Ortho_S_SAR_V3.xml b/Ortho-Top/Ortho_S_SAR_V3.xml new file mode 100644 index 0000000..a53baec --- /dev/null +++ b/Ortho-Top/Ortho_S_SAR_V3.xml @@ -0,0 +1,88 @@ + + + CSAR_202107275419_0001-0 + D:\micro\SWork\ + + File + ElementAlg + Ortho_S_SAR_V2.2 + Ortho_S_SAR_V2.2.exe + 正射校正 + 微波卫星3-5级产品生产模型 + Ortho-S-SAR-V2.2-1 + 1.0 + 辐射类产品_正射校正 + 4 + Ortho_中科卫星应用德清研究院_2.2 + 中科卫星应用德清研究院 + 景-算法 + Ortho\\Input6 + + 2599253_San_Francisco + + Ortho\\Output + + + 1.8 + python + + 0 + 0 + Windows10 + 4核 + 8GB + 25GB + 无需求 + 无需求 + 无需求 + + + + + SLC + SLC元文件 + 原始SLC各相关文件和参数 + File + tar.gz + Cal + F:\20241021yuan-HJ2F\HJ2F_LJ1_NSCAN_005566_E116.8_N44.1_20240808_SLC_HHHV_L10000094944.tar.gz + True + False + File + Satellite + 1 + GF3A + + + DEM + DEM数字高程影像 + 30m分辨率DEM数字高程影像tif + File + File + Cal + F:\20241021yuan-HJ2F\dem + True + True + File + DEM + 0 + DEM + + + + + OrthoProduct + 产品结果文件 + 产品结果文件 + File + tar.gz + Cal + D:\micro\SWork\Ortho\Output\HJ2F_LJ1_NSCAN_005566_E116.8_N44.1_20240808_SLC_HHHV_L10000094944-Ortho.tar.gz + DEFAULT + DEFAULT + DEFAULT + DEFAULT + + + + \ No newline at end of file diff --git a/Ortho-Top/baseTool/x64/Release/ImageMatch.obj b/Ortho-Top/baseTool/x64/Release/ImageMatch.obj new file mode 100644 index 0000000..2dffc26 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/ImageMatch.obj differ diff --git a/Ortho-Top/baseTool/x64/Release/LIBPQ.dll b/Ortho-Top/baseTool/x64/Release/LIBPQ.dll new file mode 100644 index 0000000..21f1003 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/LIBPQ.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/Lerc.dll b/Ortho-Top/baseTool/x64/Release/Lerc.dll new file mode 100644 index 0000000..29513ed Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/Lerc.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/OctreeNode.obj b/Ortho-Top/baseTool/x64/Release/OctreeNode.obj new file mode 100644 index 0000000..3d22e50 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/OctreeNode.obj differ diff --git a/Ortho-Top/baseTool/x64/Release/RPC_Correct.obj b/Ortho-Top/baseTool/x64/Release/RPC_Correct.obj new file mode 100644 index 0000000..4b6479f Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/RPC_Correct.obj differ diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/CL.11108.write.1.tlog b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/CL.11108.write.1.tlog new file mode 100644 index 0000000..fec0179 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/CL.11108.write.1.tlog differ diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/CL.11472.write.1.tlog b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/CL.11472.write.1.tlog new file mode 100644 index 0000000..79c356d Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/CL.11472.write.1.tlog differ diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/CL.command.1.tlog b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/CL.command.1.tlog new file mode 100644 index 0000000..4727173 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/CL.command.1.tlog differ diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/CL.read.1.tlog b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/CL.read.1.tlog new file mode 100644 index 0000000..c45d321 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/CL.read.1.tlog differ diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/CopyLocal.read.1u.tlog b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/CopyLocal.read.1u.tlog new file mode 100644 index 0000000..b56a673 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/CopyLocal.read.1u.tlog differ diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/CopyLocal.write.1u.tlog b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/CopyLocal.write.1u.tlog new file mode 100644 index 0000000..605eacb Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/CopyLocal.write.1u.tlog differ diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/SIMOrthoProgram-S-SAR.lastbuildstate b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/SIMOrthoProgram-S-SAR.lastbuildstate new file mode 100644 index 0000000..a4d4182 --- /dev/null +++ b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/SIMOrthoProgram-S-SAR.lastbuildstate @@ -0,0 +1,2 @@ +PlatformToolSet=v142:VCToolArchitecture=Native32Bit:VCToolsVersion=14.29.30133:TargetPlatformVersion=10.0.19041.0:VcpkgTriplet=x64-windows: +Release|x64|D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\| diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/SIMOrthoProgram-S-SAR.write.1u.tlog b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/SIMOrthoProgram-S-SAR.write.1u.tlog new file mode 100644 index 0000000..024973f Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/SIMOrthoProgram-S-SAR.write.1u.tlog differ diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/link.command.1.tlog b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/link.command.1.tlog new file mode 100644 index 0000000..71d26aa Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/link.command.1.tlog differ diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/link.read.1.tlog b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/link.read.1.tlog new file mode 100644 index 0000000..6b36871 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/link.read.1.tlog differ diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/link.write.1.tlog b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/link.write.1.tlog new file mode 100644 index 0000000..e69aabe Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/link.write.1.tlog differ diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/rc.command.1.tlog b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/rc.command.1.tlog new file mode 100644 index 0000000..4d44e42 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/rc.command.1.tlog differ diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/rc.read.1.tlog b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/rc.read.1.tlog new file mode 100644 index 0000000..7404a57 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/rc.read.1.tlog differ diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/rc.write.1.tlog b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/rc.write.1.tlog new file mode 100644 index 0000000..af942f2 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/SIMOrtho.7722b0a9.tlog/rc.write.1.tlog differ diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram-S-SAR.exe b/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram-S-SAR.exe new file mode 100644 index 0000000..7045b35 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram-S-SAR.exe differ diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram-S-SAR.exe.recipe b/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram-S-SAR.exe.recipe new file mode 100644 index 0000000..80ff377 --- /dev/null +++ b/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram-S-SAR.exe.recipe @@ -0,0 +1,11 @@ + + + + + D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\SIMOrthoProgram-S-SAR.exe + + + + + + \ No newline at end of file diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram-S-SAR.pdb b/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram-S-SAR.pdb new file mode 100644 index 0000000..934bf10 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram-S-SAR.pdb differ diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram.obj b/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram.obj new file mode 100644 index 0000000..17450ec Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram.obj differ diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram.res b/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram.res new file mode 100644 index 0000000..36f26e2 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram.res differ diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram.vcxproj.CopyComplete b/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram.vcxproj.CopyComplete new file mode 100644 index 0000000..e69de29 diff --git a/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram.vcxproj.FileListAbsolute.txt b/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram.vcxproj.FileListAbsolute.txt new file mode 100644 index 0000000..a08de7c --- /dev/null +++ b/Ortho-Top/baseTool/x64/Release/SIMOrthoProgram.vcxproj.FileListAbsolute.txt @@ -0,0 +1,47 @@ +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\SIMOrthoProgram.vcxproj.CopyComplete +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\SIMOrthoProgram-S-SAR.exe +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\concrt140.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\msvcp140.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\msvcp140_1.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\msvcp140_2.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\msvcp140_atomic_wait.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\msvcp140_codecvt_ids.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\vccorlib140.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\vcruntime140.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\vcruntime140_1.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\vcamp140.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\vcomp140.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\boost_filesystem-vc142-mt-x64-1_82.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\gdal.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\zlib1.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\libcrypto-3-x64.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\libssl-3-x64.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\liblzma.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\qhull_r.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\jpeg62.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\tiff.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\geotiff.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\proj.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\sqlite3.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\libcurl.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\libpng16.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\Lerc.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\zstd.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\gif.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\netcdf.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\hdf5_hl.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\hdf5.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\libwebp.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\libsharpyuv.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\LIBPQ.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\pcre2-8.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\libexpat.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\libxml2.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\iconv-2.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\geos_c.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\geos.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\json-c.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\openjp2.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\spatialite.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\freexl-1.dll +D:\estar-proj\SIMOrthoProgram-Orth_GF3-Strip-master\simorthoprogram-orth_s_sar-strip\x64\Release\minizip.dll diff --git a/Ortho-Top/baseTool/x64/Release/SateOrbit.obj b/Ortho-Top/baseTool/x64/Release/SateOrbit.obj new file mode 100644 index 0000000..b70006e Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/SateOrbit.obj differ diff --git a/Ortho-Top/baseTool/x64/Release/baseTool.obj b/Ortho-Top/baseTool/x64/Release/baseTool.obj new file mode 100644 index 0000000..c3806e0 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/baseTool.obj differ diff --git a/Ortho-Top/baseTool/x64/Release/boost_filesystem-vc142-mt-x64-1_82.dll b/Ortho-Top/baseTool/x64/Release/boost_filesystem-vc142-mt-x64-1_82.dll new file mode 100644 index 0000000..f5c136f Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/boost_filesystem-vc142-mt-x64-1_82.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/concrt140.dll b/Ortho-Top/baseTool/x64/Release/concrt140.dll new file mode 100644 index 0000000..9752449 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/concrt140.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/freexl-1.dll b/Ortho-Top/baseTool/x64/Release/freexl-1.dll new file mode 100644 index 0000000..9145a7d Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/freexl-1.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/gdal.dll b/Ortho-Top/baseTool/x64/Release/gdal.dll new file mode 100644 index 0000000..bda7c20 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/gdal.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/geos.dll b/Ortho-Top/baseTool/x64/Release/geos.dll new file mode 100644 index 0000000..2edcb83 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/geos.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/geos_c.dll b/Ortho-Top/baseTool/x64/Release/geos_c.dll new file mode 100644 index 0000000..d358b2a Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/geos_c.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/geotiff.dll b/Ortho-Top/baseTool/x64/Release/geotiff.dll new file mode 100644 index 0000000..f513a51 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/geotiff.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/gif.dll b/Ortho-Top/baseTool/x64/Release/gif.dll new file mode 100644 index 0000000..27fdc78 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/gif.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/hdf5.dll b/Ortho-Top/baseTool/x64/Release/hdf5.dll new file mode 100644 index 0000000..97fd469 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/hdf5.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/hdf5_hl.dll b/Ortho-Top/baseTool/x64/Release/hdf5_hl.dll new file mode 100644 index 0000000..7da3e86 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/hdf5_hl.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/iconv-2.dll b/Ortho-Top/baseTool/x64/Release/iconv-2.dll new file mode 100644 index 0000000..29c175c Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/iconv-2.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/interpolation.obj b/Ortho-Top/baseTool/x64/Release/interpolation.obj new file mode 100644 index 0000000..29cb9cc Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/interpolation.obj differ diff --git a/Ortho-Top/baseTool/x64/Release/jpeg62.dll b/Ortho-Top/baseTool/x64/Release/jpeg62.dll new file mode 100644 index 0000000..9c1a2c0 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/jpeg62.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/json-c.dll b/Ortho-Top/baseTool/x64/Release/json-c.dll new file mode 100644 index 0000000..abbb168 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/json-c.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/libcrypto-3-x64.dll b/Ortho-Top/baseTool/x64/Release/libcrypto-3-x64.dll new file mode 100644 index 0000000..a0ee3e3 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/libcrypto-3-x64.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/libcurl.dll b/Ortho-Top/baseTool/x64/Release/libcurl.dll new file mode 100644 index 0000000..647bdc6 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/libcurl.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/libexpat.dll b/Ortho-Top/baseTool/x64/Release/libexpat.dll new file mode 100644 index 0000000..6cea742 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/libexpat.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/liblzma.dll b/Ortho-Top/baseTool/x64/Release/liblzma.dll new file mode 100644 index 0000000..44372c5 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/liblzma.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/libpng16.dll b/Ortho-Top/baseTool/x64/Release/libpng16.dll new file mode 100644 index 0000000..c06222a Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/libpng16.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/libsharpyuv.dll b/Ortho-Top/baseTool/x64/Release/libsharpyuv.dll new file mode 100644 index 0000000..e6c1b52 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/libsharpyuv.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/libssl-3-x64.dll b/Ortho-Top/baseTool/x64/Release/libssl-3-x64.dll new file mode 100644 index 0000000..4856e67 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/libssl-3-x64.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/libwebp.dll b/Ortho-Top/baseTool/x64/Release/libwebp.dll new file mode 100644 index 0000000..e758fc8 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/libwebp.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/libxml2.dll b/Ortho-Top/baseTool/x64/Release/libxml2.dll new file mode 100644 index 0000000..1e2599f Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/libxml2.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/minizip.dll b/Ortho-Top/baseTool/x64/Release/minizip.dll new file mode 100644 index 0000000..44f5e99 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/minizip.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/msvcp140.dll b/Ortho-Top/baseTool/x64/Release/msvcp140.dll new file mode 100644 index 0000000..130f84a Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/msvcp140.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/msvcp140_1.dll b/Ortho-Top/baseTool/x64/Release/msvcp140_1.dll new file mode 100644 index 0000000..5c2f46d Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/msvcp140_1.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/msvcp140_2.dll b/Ortho-Top/baseTool/x64/Release/msvcp140_2.dll new file mode 100644 index 0000000..737b70a Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/msvcp140_2.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/msvcp140_atomic_wait.dll b/Ortho-Top/baseTool/x64/Release/msvcp140_atomic_wait.dll new file mode 100644 index 0000000..c92fcc3 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/msvcp140_atomic_wait.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/msvcp140_codecvt_ids.dll b/Ortho-Top/baseTool/x64/Release/msvcp140_codecvt_ids.dll new file mode 100644 index 0000000..9879454 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/msvcp140_codecvt_ids.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/netcdf.dll b/Ortho-Top/baseTool/x64/Release/netcdf.dll new file mode 100644 index 0000000..e1cbbf1 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/netcdf.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/openjp2.dll b/Ortho-Top/baseTool/x64/Release/openjp2.dll new file mode 100644 index 0000000..d6c8011 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/openjp2.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/pcre2-8.dll b/Ortho-Top/baseTool/x64/Release/pcre2-8.dll new file mode 100644 index 0000000..d047b3c Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/pcre2-8.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/proj.db b/Ortho-Top/baseTool/x64/Release/proj.db new file mode 100644 index 0000000..7780dbe Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/proj.db differ diff --git a/Ortho-Top/baseTool/x64/Release/proj.dll b/Ortho-Top/baseTool/x64/Release/proj.dll new file mode 100644 index 0000000..f4f6147 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/proj.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/qhull_r.dll b/Ortho-Top/baseTool/x64/Release/qhull_r.dll new file mode 100644 index 0000000..0267c70 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/qhull_r.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/simptsn.obj b/Ortho-Top/baseTool/x64/Release/simptsn.obj new file mode 100644 index 0000000..7795393 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/simptsn.obj differ diff --git a/Ortho-Top/baseTool/x64/Release/spatialite.dll b/Ortho-Top/baseTool/x64/Release/spatialite.dll new file mode 100644 index 0000000..165b6e1 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/spatialite.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/sqlite3.dll b/Ortho-Top/baseTool/x64/Release/sqlite3.dll new file mode 100644 index 0000000..65359e2 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/sqlite3.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/test_moudel.obj b/Ortho-Top/baseTool/x64/Release/test_moudel.obj new file mode 100644 index 0000000..d254e06 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/test_moudel.obj differ diff --git a/Ortho-Top/baseTool/x64/Release/tiff.dll b/Ortho-Top/baseTool/x64/Release/tiff.dll new file mode 100644 index 0000000..125e94b Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/tiff.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/vc142.pdb b/Ortho-Top/baseTool/x64/Release/vc142.pdb new file mode 100644 index 0000000..6868526 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/vc142.pdb differ diff --git a/Ortho-Top/baseTool/x64/Release/vcamp140.dll b/Ortho-Top/baseTool/x64/Release/vcamp140.dll new file mode 100644 index 0000000..9fd7179 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/vcamp140.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/vccorlib140.dll b/Ortho-Top/baseTool/x64/Release/vccorlib140.dll new file mode 100644 index 0000000..7194329 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/vccorlib140.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/vcomp140.dll b/Ortho-Top/baseTool/x64/Release/vcomp140.dll new file mode 100644 index 0000000..dbad71a Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/vcomp140.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/vcruntime140.dll b/Ortho-Top/baseTool/x64/Release/vcruntime140.dll new file mode 100644 index 0000000..1d6afaa Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/vcruntime140.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/vcruntime140_1.dll b/Ortho-Top/baseTool/x64/Release/vcruntime140_1.dll new file mode 100644 index 0000000..7bf05d3 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/vcruntime140_1.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/zlib1.dll b/Ortho-Top/baseTool/x64/Release/zlib1.dll new file mode 100644 index 0000000..e9300f6 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/zlib1.dll differ diff --git a/Ortho-Top/baseTool/x64/Release/zstd.dll b/Ortho-Top/baseTool/x64/Release/zstd.dll new file mode 100644 index 0000000..09c9050 Binary files /dev/null and b/Ortho-Top/baseTool/x64/Release/zstd.dll differ diff --git a/Ortho-Top/baseTool/x64/calOffset/calOffset.exe b/Ortho-Top/baseTool/x64/calOffset/calOffset.exe new file mode 100644 index 0000000..d67b305 Binary files /dev/null and b/Ortho-Top/baseTool/x64/calOffset/calOffset.exe differ diff --git a/Ortho-Top/baseTool/x64/calOffset/models/d2_tf.pth b/Ortho-Top/baseTool/x64/calOffset/models/d2_tf.pth new file mode 100644 index 0000000..dbec398 Binary files /dev/null and b/Ortho-Top/baseTool/x64/calOffset/models/d2_tf.pth differ diff --git a/Ortho-Top/config.ini b/Ortho-Top/config.ini new file mode 100644 index 0000000..b68d3c5 --- /dev/null +++ b/Ortho-Top/config.ini @@ -0,0 +1,11 @@ +# -*- coding: UTF-8 -*- +# 定义config分组 +[config] +######1-算法基本参数###### +productLevel = 3 +target = Ortho +# 算法名称。修改临时工作区生成临时文件的名称，日志名称； +exe_name = Ortho +# 开启调试模式则不删除临时工作区，True:开启调试，False:不开启调试 +debug = False + diff --git a/Ortho-Top/config.yaml b/Ortho-Top/config.yaml new file mode 100644 index 0000000..78fdace --- /dev/null +++ b/Ortho-Top/config.yaml @@ -0,0 +1,108 @@ +SatelliteOribit: # 轨道起算时间 + StartTime: + Value: + '2017-09-15 01:55:21.0000' + format: # 时间格式 + "%Y-%m-%d %H:%M:%S.%f" + ReferenceSpheroid: + Re: # 长半轴 + 6378137 + Rp: # 短半轴 + 6356752.3142451795 + we: + 0.000072292115 +GPS: # GPS 轨道节点 + GPSNode_Path: + ['product','GPS','GPSParam'] + NodeInfomation_Name: # [时间，x坐标，y坐标，z坐标，x速度，y速度，z速度] + ['TimeStamp', 'xPosition', 'yPosition', 'zPosition', 'xVelocity', 'yVelocity', 'zVelocity'] + Time_format: + "%Y-%m-%d %H:%M:%S" + +imageinfo: # 影像信息 + ImageBox: + NodePath: + ['product','imageinfo','corner'] + NodeName: + ['topLeft','topRight','bottomLeft','bottomRight'] + latLon: + ["latitude","longitude"] + ImageWidthSpace: + NodePath: + ['product','imageinfo','widthspace'] + ImageHeightSpace: + NodePath: + ['product','imageinfo','heightspace'] + ImageWidth: # 影像宽 + NodePath: + ['product','imageinfo','width'] + ImageHeight: # 影像高 + NodePath: + ['product','imageinfo','height'] + StartImageTime: # 影像开始时间 + NodePath: + ['product','imageinfo','imagingTime',start] + Format: + "%Y-%m-%d %H:%M:%S.%f" + EndImageTime: # 影像中止时间 + NodePath: + ['product','imageinfo','imagingTime',end] + Format: + "%Y-%m-%d %H:%M:%S.%f" + SubStartImageTime: # 影像开始时间 + NodePath: + [ 'product','imageinfo','subImagingTime','stripTime', 'start'] + Format: + "%Y-%m-%d %H:%M:%S.%f" + SubEndImageTime: # 影像中止时间 + NodePath: + [ 'product','imageinfo','subImagingTime','stripTime', 'end'] + Format: + "%Y-%m-%d %H:%M:%S.%f" + CenterImageTime: # 中心像元时间 + NodePath: + ['product','platform','CenterTime'] + Format: + "%Y-%m-%d %H:%M:%S" + CenterImagePositon: # 中心像元，可以作为迭代起算点 + NodePath: + ['product','imageinfo','center'] + Value: + ['latitude','longitude'] + NearRange: # 近斜距 + NodePath: + ['product','imageinfo','nearRange'] + DopplerCentroidCoefficients: # 多普勒质心常数 + NodePath: + ['product','processinfo','DopplerCentroidCoefficients'] + DopplerCentroidCoefficients_Name: + ['d0','d1','d2','d3','d4'] + DopplerParametersReferenceTime: + NodePath: + ['product','processinfo',"DopplerParametersReferenceTime"] + ReferenceRange: + NodePath: + ['product','imageinfo','refRange'] + incidenceAngle: # 入射角 + NearRange: # 近入射角 + NodePath: + ['product','processinfo','incidenceAngleNearRange'] + FarRange: # 远入射角 + NodePath: + ['product','processinfo','incidenceAngleFarRange'] + +sensor: + PRF: # 脉冲重复频率 + NodePath: + ['product','imageinfo','eqvPRF'] + bandWidth: # 信号带宽，计算距离向分辨率 用于距离向分辨率 + NodePath: + ['product','sensor','waveParams','wave','bandWidth'] + lambda: # 波长 + NodePath: + ['product','sensor','lamda'] + Fs: # 等效采样频率 eqvFs + NodePath: + ['product','imageinfo','eqvFs'] +LightSpeed: + 299792458 diff --git a/Ortho-Top/geo_rpc.py b/Ortho-Top/geo_rpc.py new file mode 100644 index 0000000..58a5802 --- /dev/null +++ b/Ortho-Top/geo_rpc.py @@ -0,0 +1,330 @@ +#命名为：geo_rpc.py +""" +RPC model parsers, localization, and projection +""" +import numpy as np +from osgeo import gdal + + #最大迭代次数超过则报错 +class MaxLocalizationIterationsError(Exception): + """ + Custom rpcm Exception. + """ + pass + +def apply_poly(poly, x, y, z): + """ + Evaluates a 3-variables polynom of degree 3 on a triplet of numbers. + 将三次多项式的统一模式构建为一个单独的函数 + Args: + poly: list of the 20 coefficients of the 3-variate degree 3 polynom, + ordered following the RPC convention. + x, y, z: triplet of floats. They may be numpy arrays of same length. + Returns: + the value(s) of the polynom on the input point(s). + """ + out = 0 + out += poly[0] + out += poly[1]*y + poly[2]*x + poly[3]*z + out += poly[4]*y*x + poly[5]*y*z +poly[6]*x*z + out += poly[7]*y*y + poly[8]*x*x + poly[9]*z*z + out += poly[10]*x*y*z + out += poly[11]*y*y*y + out += poly[12]*y*x*x + poly[13]*y*z*z + poly[14]*y*y*x + out += poly[15]*x*x*x + out += poly[16]*x*z*z + poly[17]*y*y*z + poly[18]*x*x*z + out += poly[19]*z*z*z + return out + +def apply_rfm(num, den, x, y, z): + """ + Evaluates a Rational Function Model (rfm), on a triplet of numbers. + 执行20个参数的分子和20个参数的除法 + Args: + num: list of the 20 coefficients of the numerator + den: list of the 20 coefficients of the denominator + All these coefficients are ordered following the RPC convention. + x, y, z: triplet of floats. They may be numpy arrays of same length. + + Returns: + the value(s) of the rfm on the input point(s). + """ + return apply_poly(num, x, y, z) / apply_poly(den, x, y, z) + +def rpc_from_geotiff(geotiff_path): + """ + Read the RPC coefficients from a GeoTIFF file and return an RPCModel object. + 该函数返回影像的Gdal格式的影像和RPCmodel + Args: + geotiff_path (str): path or url to a GeoTIFF file + + Returns: + instance of the rpc_model.RPCModel class + """ + # with rasterio.open(geotiff_path, 'r') as src: + # + dataset = gdal.Open(geotiff_path, gdal.GA_ReadOnly) + rpc_dict = dataset.GetMetadata("RPC") + # 同时返回影像与rpc + return dataset, RPCModel(rpc_dict,'geotiff') + + +def parse_rpc_file(rpc_file): + # rpc_file:.rpc文件的绝对路径 + # rpc_dict：符号RPC域下的16个关键字的字典 + # 参考网址：http://geotiff.maptools.org/rpc_prop.html； + # https://www.osgeo.cn/gdal/development/rfc/rfc22_rpc.html + + rpc_dict = {} + with open(rpc_file) as f: + text = f.read() + + # .rpc文件中的RPC关键词 + words = ['errBias', 'errRand', 'lineOffset', 'sampOffset', 'latOffset', + 'longOffset', 'heightOffset', 'lineScale', 'sampScale', 'latScale', + 'longScale', 'heightScale', 'lineNumCoef', 'lineDenCoef','sampNumCoef', 'sampDenCoef',] + + # GDAL库对应的RPC关键词 + keys = ['ERR_BIAS', 'ERR_RAND', 'LINE_OFF', 'SAMP_OFF', 'LAT_OFF', 'LONG_OFF', + 'HEIGHT_OFF', 'LINE_SCALE', 'SAMP_SCALE', 'LAT_SCALE', + 'LONG_SCALE', 'HEIGHT_SCALE', 'LINE_NUM_COEFF', 'LINE_DEN_COEFF', + 'SAMP_NUM_COEFF', 'SAMP_DEN_COEFF'] + + for old, new in zip(words, keys): + text = text.replace(old, new) + # 以‘;\n’作为分隔符 + text_list = text.split(';\n') + # 删掉无用的行 + text_list = text_list[3:-2] + # + text_list[0] = text_list[0].split('\n')[1] + # 去掉制表符、换行符、空格 + text_list = [item.strip('\t').replace('\n', '').replace(' ', '') for item in text_list] + + for item in text_list: + # 去掉‘=’ + key, value = item.split('=') + # 去掉多余的括号‘(’，‘)’ + if '(' in value: + value = value.replace('(', '').replace(')', '') + rpc_dict[key] = value + + for key in keys[:12]: + # 为正数添加符号‘+’ + if not rpc_dict[key].startswith('-'): + rpc_dict[key] = '+' + rpc_dict[key] + # 为归一化项和误差标志添加单位 + if key in ['LAT_OFF', 'LONG_OFF', 'LAT_SCALE', 'LONG_SCALE']: + rpc_dict[key] = rpc_dict[key] + ' degrees' + if key in ['LINE_OFF', 'SAMP_OFF', 'LINE_SCALE', 'SAMP_SCALE']: + rpc_dict[key] = rpc_dict[key] + ' pixels' + if key in ['ERR_BIAS', 'ERR_RAND', 'HEIGHT_OFF', 'HEIGHT_SCALE']: + rpc_dict[key] = rpc_dict[key] + ' meters' + + # 处理有理函数项 + for key in keys[-4:]: + values = [] + for item in rpc_dict[key].split(','): + #print(item) + if not item.startswith('-'): + values.append('+'+item) + else: + values.append(item) + rpc_dict[key] = ' '.join(values) + return rpc_dict + + +def read_rpc_file(rpc_file): + """ + Read RPC from a RPC_txt file and return a RPCmodel + 从TXT中直接单独读取RPC模型 + Args: + rpc_file: RPC sidecar file path + + Returns: + dictionary read from the RPC file, or an empty dict if fail + + """ + rpc = parse_rpc_file(rpc_file) + return RPCModel(rpc) + +class RPCModel: + def __init__(self, d, dict_format="geotiff"): + """ + Args: + d (dict): dictionary read from a geotiff file with + rasterio.open('/path/to/file.tiff', 'r').tags(ns='RPC'), + or from the .__dict__ of an RPCModel object. + dict_format (str): format of the dictionary passed in `d`. + Either "geotiff" if read from the tags of a geotiff file, + or "rpcm" if read from the .__dict__ of an RPCModel object. + """ + if dict_format == "geotiff": + self.row_offset = float(d['LINE_OFF'][0:d['LINE_OFF'].rfind(' ')]) + self.col_offset = float(d['SAMP_OFF'][0:d['SAMP_OFF'].rfind(' ')]) + self.lat_offset = float(d['LAT_OFF'][0:d['LAT_OFF'].rfind(' ')]) + self.lon_offset = float(d['LONG_OFF'][0:d['LONG_OFF'].rfind(' ')]) + self.alt_offset = float(d['HEIGHT_OFF'][0:d['HEIGHT_OFF'].rfind(' ')]) + + self.row_scale = float(d['LINE_SCALE'][0:d['LINE_SCALE'].rfind(' ')]) + self.col_scale = float(d['SAMP_SCALE'][0:d['SAMP_SCALE'].rfind(' ')]) + self.lat_scale = float(d['LAT_SCALE'][0:d['LAT_SCALE'].rfind(' ')]) + self.lon_scale = float(d['LONG_SCALE'][0:d['LONG_SCALE'].rfind(' ')]) + self.alt_scale = float(d['HEIGHT_SCALE'][0:d['HEIGHT_SCALE'].rfind(' ')]) + + self.row_num = list(map(float, d['LINE_NUM_COEFF'].split())) + self.row_den = list(map(float, d['LINE_DEN_COEFF'].split())) + self.col_num = list(map(float, d['SAMP_NUM_COEFF'].split())) + self.col_den = list(map(float, d['SAMP_DEN_COEFF'].split())) + + if 'LON_NUM_COEFF' in d: + self.lon_num = list(map(float, d['LON_NUM_COEFF'].split())) + self.lon_den = list(map(float, d['LON_DEN_COEFF'].split())) + self.lat_num = list(map(float, d['LAT_NUM_COEFF'].split())) + self.lat_den = list(map(float, d['LAT_DEN_COEFF'].split())) + + elif dict_format == "rpcm": + self.__dict__ = d + + else: + raise ValueError( + "dict_format '{}' not supported. " + "Should be {{'geotiff','rpcm'}}".format(dict_format) + ) + + + def projection(self, lon, lat, alt): + """ + Convert geographic coordinates of 3D points into image coordinates. + 正投影：从地理坐标到图像坐标 + Args: + lon (float or list): longitude(s) of the input 3D point(s) + lat (float or list): latitude(s) of the input 3D point(s) + alt (float or list): altitude(s) of the input 3D point(s) + + Returns: + float or list: horizontal image coordinate(s) (column index, ie x) + float or list: vertical image coordinate(s) (row index, ie y) + """ + nlon = (np.asarray(lon) - self.lon_offset) / self.lon_scale + nlat = (np.asarray(lat) - self.lat_offset) / self.lat_scale + nalt = (np.asarray(alt) - self.alt_offset) / self.alt_scale + + col = apply_rfm(self.col_num, self.col_den, nlat, nlon, nalt) + row = apply_rfm(self.row_num, self.row_den, nlat, nlon, nalt) + + col = col * self.col_scale + self.col_offset + row = row * self.row_scale + self.row_offset + + return col, row + + + def localization(self, col, row, alt, return_normalized=False): + """ + Convert image coordinates plus altitude into geographic coordinates. + 反投影：从图像坐标到地理坐标 + Args: + col (float or list): x image coordinate(s) of the input point(s) + row (float or list): y image coordinate(s) of the input point(s) + alt (float or list): altitude(s) of the input point(s) + + Returns: + float or list: longitude(s) + float or list: latitude(s) + """ + ncol = (np.asarray(col) - self.col_offset) / self.col_scale + nrow = (np.asarray(row) - self.row_offset) / self.row_scale + nalt = (np.asarray(alt) - self.alt_offset) / self.alt_scale + + if not hasattr(self, 'lat_num'): + lon, lat = self.localization_iterative(ncol, nrow, nalt) + else: + lon = apply_rfm(self.lon_num, self.lon_den, nrow, ncol, nalt) + lat = apply_rfm(self.lat_num, self.lat_den, nrow, ncol, nalt) + + if not return_normalized: + lon = lon * self.lon_scale + self.lon_offset + lat = lat * self.lat_scale + self.lat_offset + + return lon, lat + + + def localization_iterative(self, col, row, alt): + """ + Iterative estimation of the localization function (image to ground), + for a list of image points expressed in image coordinates. + 逆投影时的迭代函数 + Args: + col, row: normalized image coordinates (between -1 and 1) + alt: normalized altitude (between -1 and 1) of the corresponding 3D + point + + Returns: + lon, lat: normalized longitude and latitude + + Raises: + MaxLocalizationIterationsError: if the while loop exceeds the max + number of iterations, which is set to 100. + """ + # target point: Xf (f for final) + Xf = np.vstack([col, row]).T + + # use 3 corners of the lon, lat domain and project them into the image + # to get the first estimation of (lon, lat) + # EPS is 2 for the first iteration, then 0.1. + lon = -col ** 0 # vector of ones + lat = -col ** 0 + EPS = 2 + x0 = apply_rfm(self.col_num, self.col_den, lat, lon, alt) + y0 = apply_rfm(self.row_num, self.row_den, lat, lon, alt) + x1 = apply_rfm(self.col_num, self.col_den, lat, lon + EPS, alt) + y1 = apply_rfm(self.row_num, self.row_den, lat, lon + EPS, alt) + x2 = apply_rfm(self.col_num, self.col_den, lat + EPS, lon, alt) + y2 = apply_rfm(self.row_num, self.row_den, lat + EPS, lon, alt) + + n = 0 + while not np.all((x0 - col) ** 2 + (y0 - row) ** 2 < 1e-18): + + if n > 100: + raise MaxLocalizationIterationsError("Max localization iterations (100) exceeded") + + X0 = np.vstack([x0, y0]).T + X1 = np.vstack([x1, y1]).T + X2 = np.vstack([x2, y2]).T + e1 = X1 - X0 + e2 = X2 - X0 + u = Xf - X0 + + # project u on the base (e1, e2): u = a1*e1 + a2*e2 + # the exact computation is given by: + # M = np.vstack((e1, e2)).T + # a = np.dot(np.linalg.inv(M), u) + # but I don't know how to vectorize this. + # Assuming that e1 and e2 are orthogonal, a1 is given by + # / + num = np.sum(np.multiply(u, e1), axis=1) + den = np.sum(np.multiply(e1, e1), axis=1) + a1 = np.divide(num, den).squeeze() + + num = np.sum(np.multiply(u, e2), axis=1) + den = np.sum(np.multiply(e2, e2), axis=1) + a2 = np.divide(num, den).squeeze() + + # use the coefficients a1, a2 to compute an approximation of the + # point on the gound which in turn will give us the new X0 + lon += a1 * EPS + lat += a2 * EPS + + # update X0, X1 and X2 + EPS = .1 + x0 = apply_rfm(self.col_num, self.col_den, lat, lon, alt) + y0 = apply_rfm(self.row_num, self.row_den, lat, lon, alt) + x1 = apply_rfm(self.col_num, self.col_den, lat, lon + EPS, alt) + y1 = apply_rfm(self.row_num, self.row_den, lat, lon + EPS, alt) + x2 = apply_rfm(self.col_num, self.col_den, lat + EPS, lon, alt) + y2 = apply_rfm(self.row_num, self.row_den, lat + EPS, lon, alt) + + n += 1 + + return lon, lat + \ No newline at end of file diff --git a/Ortho-Top/model_meta.xml b/Ortho-Top/model_meta.xml new file mode 100644 index 0000000..afa1137 --- /dev/null +++ b/Ortho-Top/model_meta.xml @@ -0,0 +1,133 @@ + + + + + + + GEC + TIF + + + + + nan + BSQ + + + + +
+ + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 模拟影像法 + 常数累加法 + + 四次多项式模型 + WGS84 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + NULL + NULL + + + + + + + + + + + + + + + + + + + + + + + 标准相关匹配 + + + diff --git a/Ortho-Top/models/d2_tf.pth b/Ortho-Top/models/d2_tf.pth new file mode 100644 index 0000000..dbec398 Binary files /dev/null and b/Ortho-Top/models/d2_tf.pth differ diff --git a/Ortho-Top/orthProcess.ipynb b/Ortho-Top/orthProcess.ipynb new file mode 100644 index 0000000..b81ef25 --- /dev/null +++ b/Ortho-Top/orthProcess.ipynb @@ -0,0 +1,267 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 32, + "id": "ce677517-20b0-4c35-ac26-4dc53273c790", + "metadata": {}, + "outputs": [], + "source": [ + "import cv2\n", + "import os\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "plt.rcParams['font.sans-serif'] = ['SimHei'] # 用来正常显示中文标签\n", + "plt.rcParams['axes.unicode_minus'] = False # 用来正常显示负号" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "92c174ba-9c1d-4297-ac62-1f39cf1b92da", + "metadata": {}, + "outputs": [], + "source": [ + "sim_path =r\"D:\\MicroSAR\\C-SAR\\Ortho\\Ortho\\Temporary\\dem_rcs.jpg\"\n", + "sim2_path =r\"D:\\MicroSAR\\Temporary\\dem_rcs.jpg\"\n", + "ori_path=r\"D:\\MicroSAR\\C-SAR\\Ortho\\Ortho\\Temporary\\sar_rcs.jpg\"" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "b84a1ad4-e56b-45cd-9ac6-ddc26ce8eaad", + "metadata": {}, + "outputs": [], + "source": [ + "ori_img = cv2.imread(ori_path)[:,:,0]\n", + "sim_img = cv2.imread(sim_path)[:,:,0]\n", + "sim2_img = cv2.imread(sim2_path)[:,:,0]" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "809a17e7-196b-44aa-9022-c62f0ff93b36", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(19821, 14285)" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sim2_img.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5a23f79b-4472-4362-9dcd-224f07fb2432", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.matshow(sim_img,cmap=\"jet\")\n", + "plt.colorbar()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a4025626-1e91-4576-b707-9eb21c10825d", + "metadata": {}, + "outputs": [], + "source": [ + "img1=sim_img*1.0" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "65a1f3da-5ae3-48d7-afa4-8fc9882a4909", + "metadata": {}, + "outputs": [], + "source": [ + "for i in range(0,5887,300):\n", + " if i+2*300>5887:\n", + " continue\n", + " for j in range(0,8062,300):\n", + " if j+2*300>8062:\n", + " continue \n", + " temp=img1[i:i+600,j:j+600]\n", + " img1[i:i+600,j:j+600]=np.std(temp)/(np.nanmax(temp)-np.nanmin(temp))" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "0639d283-7491-472f-80d5-85d5e8de301d", + "metadata": {}, + "outputs": [], + "source": [ + "img2=sim2_img*1.0\n", + "for i in range(0,19821,300):\n", + " if i+2*300>19821:\n", + " continue\n", + " for j in range(0,14285,300):\n", + " if j+2*300>14285:\n", + " continue \n", + " temp=img2[i:i+600,j:j+600]\n", + " img2[i:i+600,j:j+600]=np.std(temp)/(np.nanmax(temp)-np.nanmin(temp))" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "11be6d02-863c-4c5c-b23b-d72d04ef88be", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.matshow(img2[15000:19000,:4000],cmap=\"jet\")\n", + "plt.colorbar()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "2df5bd3e-2777-43fc-a00c-1cb343f04f5a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.matshow(img2,cmap=\"jet\")\n", + "plt.colorbar()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "afe62adb-2875-40e5-9f67-89b5221126b6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.matshow(img1,cmap=\"jet\")\n", + "plt.colorbar()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "8d694781-d527-4c1d-a811-de2df88f11bc", + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "angle_arr=np.zeros((900,2))\n", + "for i in range(900):\n", + " angle=i*(math.pi/2)/900.0\n", + " angle_arr[i,0]=angle*180/math.pi\n", + " angle_arr[i,1]=(0.0133 * math.cos(angle)) / ((math.sin(angle) + 0.1 * math.cos(angle))**3)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "edcc3785-f880-4ef6-bea3-ce735f4591d2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(angle_arr[:,0],angle_arr[:,1])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "616b92c4-7d19-462f-8ce6-b671e0a94037", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Ortho-Top/packing.spec b/Ortho-Top/packing.spec new file mode 100644 index 0000000..a6fed4d --- /dev/null +++ b/Ortho-Top/packing.spec @@ -0,0 +1,89 @@ +# -*- mode: python ; coding: utf-8 -*- +import sys +import shutil +import os +import tarfile + +#ļб +sys.setrecursionlimit(5000) +block_cipher = None + +#######begin-ǰ############## +#һtoolļ滻ǰ·µtool +# Դ +cwdpath = os.getcwd() +tool_path = '' +src = '../tool' +des = os.path.join(cwdpath, "tool") +targz_path = os.path.join(cwdpath, "tool.tar.gz") +#ļ +if os.path.exists(des): + if os.path.isdir(des): + shutil.rmtree(des) + os.makedirs(des) +#ѹ +dir = os.path.split(targz_path )[0] +if os.path.exists(dir) is False: + os.makedirs(dir) +with tarfile.open(targz_path, "w:gz") as tar: + tar.add(src, arcname=os.path.basename(src)) +#ѹ +t = tarfile.open(targz_path) +t.extractall(path=cwdpath) +#ɾʱѹ +#os.remove(targz_path) + +# +main_name = '' +for name in os.listdir(cwdpath): + if 'Main.py' in name: + main_name = name +exe_name = exe_name = main_name .split('.')[0][:-4] + '-C-SAR-V2.0' +#######end-ǰ############## + + + +#######beging-pyinstaller############## + +a = Analysis(['OrthoMain.py', +'./tool/algorithm/algtools/ScatteringAuxData.py', +'./tool/algorithm/algtools/CoordinateTransformation.py', +'./tool/algorithm/algtools/DEMJoint.py', +'./tool/algorithm/algtools/logHandler.py', +'./tool/algorithm/algtools/PreProcess.py', +'./tool/algorithm/algtools/RieveFilter.py', +'./tool/algorithm/algtools/ROIAlg.py', +'./tool/algorithm/block/blockprocess.py', +'./tool/algorithm/image/ImageHandle.py', +'./tool/algorithm/xml/AlgXmlHandle.py', +'./tool/algorithm/xml/CreatMetafile.py', +'./tool/config/ConfigeHandle.py', +'./tool/logs/logHandler.py',], + pathex=[cwdpath], + binaries=[], + datas=[], + hiddenimports=[], + hookspath=[], + runtime_hooks=[], + excludes=[], + win_no_prefer_redirects=False, + win_private_assemblies=False, + cipher=block_cipher, + noarchive=False) +pyz = PYZ(a.pure, a.zipped_data, + cipher=block_cipher) +exe = EXE(pyz, + a.scripts, + a.binaries, + a.zipfiles, + a.datas, + [], + name= 'Ortho-C-SAR-V2.0', + debug=False, + bootloader_ignore_signals=False, + strip=False, + upx=True, + upx_exclude=[], + runtime_tmpdir=None, + console=True ) +######beging-pyinstaller################# \ No newline at end of file diff --git a/Ortho-Top/product.xml b/Ortho-Top/product.xml new file mode 100644 index 0000000..1d8c5f1 --- /dev/null +++ b/Ortho-Top/product.xml @@ -0,0 +1,60 @@ + + + 正射校正 + Ortho + LEVEL3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + None + 参考产品介绍PDF + + + + + 德清 + + + + \ No newline at end of file diff --git a/Ortho-Top/proj.db b/Ortho-Top/proj.db new file mode 100644 index 0000000..020f3a7 Binary files /dev/null and b/Ortho-Top/proj.db differ diff --git a/Ortho-Top/test/DeLevelingEffect.py b/Ortho-Top/test/DeLevelingEffect.py new file mode 100644 index 0000000..f28c0e6 --- /dev/null +++ b/Ortho-Top/test/DeLevelingEffect.py @@ -0,0 +1,47 @@ +''' 去地平效应功能代码 +因为去地平效应是需要像元的成像时间作为的输入参数量，因此需要原始影像的SLC作为输出项，或者原始的SLC中，保留了影像的成像时刻。 +作为模型约定： +1.模型的输入需要已经经过了正射校正，否则没有办法与已有的DEM进行匹配。 +2.开发示例使用的高分三号，注意高分三号的正射模型为rpc，因此需要需要计算的对应的时间。 +''' +import os +import numpy as np +# import gdal +import math + +class DeLevelingEffect: + ''' 去地平效应 + 计算公式： + Phi=(4*pi/lambda_)*(r1-r2) + lambda_ 波长 + pi=3.14159265358979323846264338327950288 + r1:主 + r2:辅 + ''' + def LevelingEffect(lamda_,r1,r2,pi=3.14159265358979323846264338327950288): + '''计算地平效应的相位 + agrs: + lamda_: double, 波长 + r1:shape nx1 ,主影像的斜距 + r2:shape nx1 ,辅影像的斜距 + pi:double,圆周率 + return： + Phi:shape nx1 + ''' + Phi=(4*pi/lamda_)*(r1-r2) + return Phi + + def CalSlantDistance(Rs_Salatellite,Rs_SeaLevel): + '''计算斜率 + agrs: + Rs_Salatellite:nx3 x,y,z 地面对应时刻的 卫星位置和速度 + Rs_SeaLevel:nx3 x,y,z 地面的坐标 + return: + SlantDistance:nx1 斜距 + ''' + SlantDistance=np.sqrt(np.sum((Rs_Salatellite-Rs_SeaLevel)**2,axis=1)).reshape(-1,1) + return SlantDistance + + # 根据根据卫星轨道数据，构建合适的影像信息 + + pass \ No newline at end of file diff --git a/Ortho-Top/test/EOP-Last5Years.csv b/Ortho-Top/test/EOP-Last5Years.csv new file mode 100644 index 0000000..5f75161 --- /dev/null +++ b/Ortho-Top/test/EOP-Last5Years.csv @@ -0,0 +1,2338 @@ +DATE,MJD,X,Y,UT1-UTC,LOD,DPSI,DEPS,DX,DY,DAT,DATA_TYPE +2017-01-01,57754,0.080406,0.263110,0.5912977,0.0010160,-0.099181,-0.009295,-0.000041,-0.000127,37,O +2017-01-02,57755,0.080234,0.263612,0.5901980,0.0011845,-0.099234,-0.009257,-0.000051,-0.000127,37,O +2017-01-03,57756,0.080325,0.264049,0.5889489,0.0013554,-0.099359,-0.009165,-0.000060,-0.000127,37,O +2017-01-04,57757,0.080085,0.264248,0.5875560,0.0014755,-0.099409,-0.009048,-0.000069,-0.000128,37,O +2017-01-05,57758,0.078979,0.264771,0.5860113,0.0015833,-0.099345,-0.008947,-0.000071,-0.000156,37,O +2017-01-06,57759,0.076659,0.265079,0.5844176,0.0015733,-0.099286,-0.008804,-0.000065,-0.000153,37,O +2017-01-07,57760,0.074997,0.264999,0.5828289,0.0015881,-0.099388,-0.008680,-0.000056,-0.000138,37,O +2017-01-08,57761,0.073590,0.265346,0.5812971,0.0015171,-0.099719,-0.008689,-0.000048,-0.000122,37,O +2017-01-09,57762,0.072292,0.265405,0.5798632,0.0013991,-0.100203,-0.008887,-0.000041,-0.000104,37,O +2017-01-10,57763,0.070974,0.265630,0.5785447,0.0012681,-0.100710,-0.009151,-0.000058,-0.000086,37,O +2017-01-11,57764,0.069188,0.266009,0.5773226,0.0011980,-0.100952,-0.009243,-0.000056,-0.000068,37,O +2017-01-12,57765,0.067206,0.266760,0.5761501,0.0011623,-0.100925,-0.009050,-0.000068,-0.000029,37,O +2017-01-13,57766,0.065434,0.267601,0.5749710,0.0011970,-0.100619,-0.008774,-0.000083,0.000015,37,O +2017-01-14,57767,0.064123,0.268514,0.5737486,0.0012671,-0.100052,-0.008721,-0.000062,0.000014,37,O +2017-01-15,57768,0.062094,0.269403,0.5724482,0.0013292,-0.099488,-0.008909,-0.000026,-0.000003,37,O +2017-01-16,57769,0.059790,0.270125,0.5710855,0.0013475,-0.099159,-0.009130,0.000010,-0.000023,37,O +2017-01-17,57770,0.056596,0.270860,0.5697355,0.0012962,-0.099101,-0.009194,0.000045,-0.000043,37,O +2017-01-18,57771,0.053236,0.271069,0.5684687,0.0012312,-0.099189,-0.009105,0.000081,-0.000062,37,O +2017-01-19,57772,0.049831,0.271594,0.5672621,0.0011544,-0.099616,-0.008995,0.000003,-0.000066,37,O +2017-01-20,57773,0.046722,0.272046,0.5661354,0.0010835,-0.100149,-0.008988,-0.000100,-0.000078,37,O +2017-01-21,57774,0.044253,0.272777,0.5650772,0.0010396,-0.100415,-0.009045,-0.000095,-0.000089,37,O +2017-01-22,57775,0.042223,0.273622,0.5640539,0.0009761,-0.100422,-0.009111,-0.000037,-0.000136,37,O +2017-01-23,57776,0.040821,0.274538,0.5631156,0.0009027,-0.100355,-0.009082,-0.000035,-0.000148,37,O +2017-01-24,57777,0.039583,0.275760,0.5622595,0.0008250,-0.100150,-0.009055,-0.000032,-0.000159,37,O +2017-01-25,57778,0.038517,0.276614,0.5614608,0.0007689,-0.099987,-0.009107,-0.000038,-0.000159,37,O +2017-01-26,57779,0.037014,0.277717,0.5606755,0.0007617,-0.099880,-0.009265,-0.000045,-0.000156,37,O +2017-01-27,57780,0.035647,0.278508,0.5598651,0.0008294,-0.099724,-0.009456,-0.000052,-0.000153,37,O +2017-01-28,57781,0.034439,0.279471,0.5589886,0.0009339,-0.099419,-0.009577,-0.000037,-0.000165,37,O +2017-01-29,57782,0.033163,0.280636,0.5579999,0.0010635,-0.099116,-0.009561,-0.000014,-0.000180,37,O +2017-01-30,57783,0.032188,0.281673,0.5568596,0.0012118,-0.098981,-0.009461,0.000009,-0.000196,37,O +2017-01-31,57784,0.031679,0.282720,0.5555742,0.0013455,-0.099004,-0.009383,0.000032,-0.000212,37,O +2017-02-01,57785,0.031191,0.283698,0.5541788,0.0014251,-0.099361,-0.009224,-0.000072,-0.000062,37,O +2017-02-02,57786,0.030748,0.284679,0.5527206,0.0014521,-0.099511,-0.009295,-0.000124,-0.000093,37,O +2017-02-03,57787,0.030524,0.285671,0.5512606,0.0014618,-0.099600,-0.009414,-0.000151,-0.000192,37,O +2017-02-04,57788,0.030066,0.286876,0.5498336,0.0014133,-0.099760,-0.009435,-0.000148,-0.000214,37,O +2017-02-05,57789,0.029276,0.288333,0.5484764,0.0013301,-0.100073,-0.009491,-0.000132,-0.000208,37,O +2017-02-06,57790,0.027940,0.289708,0.5471907,0.0012443,-0.100449,-0.009669,-0.000117,-0.000202,37,O +2017-02-07,57791,0.025783,0.290937,0.5459617,0.0011784,-0.100691,-0.009899,-0.000101,-0.000195,37,O +2017-02-08,57792,0.023504,0.291995,0.5447813,0.0011966,-0.100801,-0.009956,-0.000132,-0.000121,37,O +2017-02-09,57793,0.021386,0.293084,0.5435687,0.0012574,-0.100711,-0.009811,-0.000174,-0.000029,37,O +2017-02-10,57794,0.019705,0.294105,0.5422705,0.0013534,-0.100390,-0.009806,-0.000171,-0.000154,37,O +2017-02-11,57795,0.018117,0.295030,0.5408616,0.0014923,-0.100029,-0.009851,-0.000154,-0.000207,37,O +2017-02-12,57796,0.016533,0.296190,0.5393236,0.0015821,-0.099727,-0.010046,-0.000138,-0.000207,37,O +2017-02-13,57797,0.014945,0.297050,0.5376803,0.0016412,-0.099517,-0.010329,-0.000122,-0.000208,37,O +2017-02-14,57798,0.013603,0.298053,0.5360022,0.0016773,-0.099450,-0.010508,-0.000106,-0.000208,37,O +2017-02-15,57799,0.012199,0.298908,0.5343223,0.0016530,-0.099635,-0.010485,-0.000112,-0.000184,37,O +2017-02-16,57800,0.010653,0.299914,0.5327041,0.0015749,-0.100019,-0.010368,-0.000123,-0.000155,37,O +2017-02-17,57801,0.009096,0.300662,0.5311837,0.0014455,-0.100478,-0.010292,-0.000135,-0.000126,37,O +2017-02-18,57802,0.008066,0.301408,0.5298432,0.0012789,-0.100791,-0.010341,-0.000132,-0.000141,37,O +2017-02-19,57803,0.007626,0.302891,0.5286507,0.0011131,-0.100835,-0.010419,-0.000123,-0.000171,37,O +2017-02-20,57804,0.007330,0.304749,0.5275398,0.0009881,-0.100612,-0.010443,-0.000115,-0.000202,37,O +2017-02-21,57805,0.006830,0.306848,0.5265701,0.0009153,-0.100241,-0.010425,-0.000106,-0.000232,37,O +2017-02-22,57806,0.006292,0.308971,0.5256816,0.0009103,-0.099918,-0.010361,-0.000106,-0.000159,37,O +2017-02-23,57807,0.006313,0.310992,0.5247251,0.0009917,-0.099650,-0.010473,-0.000079,-0.000133,37,O +2017-02-24,57808,0.006506,0.313447,0.5237032,0.0010771,-0.099461,-0.010691,-0.000044,-0.000127,37,O +2017-02-25,57809,0.006351,0.315906,0.5226220,0.0011600,-0.099394,-0.010870,-0.000056,-0.000143,37,O +2017-02-26,57810,0.005864,0.317660,0.5214174,0.0012737,-0.099305,-0.010873,-0.000087,-0.000167,37,O +2017-02-27,57811,0.004992,0.319182,0.5200555,0.0014175,-0.099166,-0.010720,-0.000117,-0.000191,37,O +2017-02-28,57812,0.004458,0.320769,0.5185559,0.0015372,-0.099077,-0.010578,-0.000147,-0.000214,37,O +2017-03-01,57813,0.004201,0.322772,0.5169206,0.0016149,-0.099015,-0.010594,-0.000133,-0.000225,37,O +2017-03-02,57814,0.004435,0.324530,0.5152707,0.0016207,-0.099067,-0.010779,-0.000107,-0.000231,37,O +2017-03-03,57815,0.004753,0.326399,0.5137386,0.0015313,-0.099206,-0.011005,-0.000081,-0.000238,37,O +2017-03-04,57816,0.004922,0.328387,0.5122784,0.0014347,-0.099490,-0.011101,-0.000098,-0.000197,37,O +2017-03-05,57817,0.005038,0.330067,0.5108909,0.0013442,-0.099813,-0.011106,-0.000130,-0.000138,37,O +2017-03-06,57818,0.004656,0.331886,0.5095838,0.0012611,-0.100065,-0.011117,-0.000163,-0.000079,37,O +2017-03-07,57819,0.003842,0.333541,0.5083262,0.0012567,-0.100133,-0.011166,-0.000196,-0.000020,37,O +2017-03-08,57820,0.003361,0.335017,0.5070546,0.0013135,-0.099928,-0.011235,-0.000219,0.000002,37,O +2017-03-09,57821,0.003516,0.336230,0.5057278,0.0013630,-0.099550,-0.011250,-0.000239,0.000014,37,O +2017-03-10,57822,0.004054,0.337739,0.5043303,0.0014235,-0.099283,-0.011310,-0.000288,-0.000048,37,O +2017-03-11,57823,0.004522,0.339497,0.5028649,0.0015119,-0.099092,-0.011399,-0.000290,-0.000082,37,O +2017-03-12,57824,0.004623,0.341460,0.5012981,0.0016026,-0.099017,-0.011565,-0.000271,-0.000095,37,O +2017-03-13,57825,0.004329,0.343151,0.4996338,0.0016806,-0.098981,-0.011767,-0.000253,-0.000108,37,O +2017-03-14,57826,0.004108,0.344483,0.4979534,0.0016946,-0.098937,-0.011903,-0.000235,-0.000122,37,O +2017-03-15,57827,0.003946,0.345936,0.4963503,0.0015974,-0.099079,-0.011873,-0.000252,-0.000086,37,O +2017-03-16,57828,0.003934,0.347162,0.4948329,0.0014473,-0.099427,-0.011763,-0.000279,-0.000037,37,O +2017-03-17,57829,0.004042,0.348900,0.4934113,0.0013260,-0.099406,-0.011838,-0.000126,-0.000152,37,O +2017-03-18,57830,0.004447,0.350950,0.4921127,0.0012046,-0.099511,-0.011846,-0.000070,-0.000130,37,O +2017-03-19,57831,0.004857,0.353166,0.4909106,0.0011585,-0.099531,-0.011831,-0.000072,-0.000037,37,O +2017-03-20,57832,0.005254,0.355662,0.4897700,0.0011271,-0.099353,-0.011802,-0.000075,0.000055,37,O +2017-03-21,57833,0.005426,0.358050,0.4886539,0.0011271,-0.099040,-0.011713,-0.000077,0.000148,37,O +2017-03-22,57834,0.005638,0.360271,0.4875037,0.0012074,-0.098972,-0.011706,-0.000207,0.000131,37,O +2017-03-23,57835,0.005959,0.362598,0.4862691,0.0013346,-0.098582,-0.011834,-0.000193,0.000029,37,O +2017-03-24,57836,0.005500,0.364846,0.4848670,0.0014359,-0.098268,-0.012079,-0.000128,-0.000089,37,O +2017-03-25,57837,0.005014,0.366667,0.4833895,0.0015687,-0.098337,-0.012257,-0.000127,-0.000097,37,O +2017-03-26,57838,0.004885,0.368375,0.4817351,0.0017442,-0.098460,-0.012286,-0.000150,-0.000063,37,O +2017-03-27,57839,0.004890,0.370263,0.4799358,0.0018584,-0.098349,-0.012121,-0.000173,-0.000030,37,O +2017-03-28,57840,0.004992,0.372010,0.4780207,0.0019526,-0.098093,-0.011871,-0.000196,0.000003,37,O +2017-03-29,57841,0.005269,0.373530,0.4760266,0.0020072,-0.098666,-0.011748,-0.000475,0.000063,37,O +2017-03-30,57842,0.005359,0.375029,0.4740320,0.0019058,-0.098812,-0.012021,-0.000437,-0.000007,37,O +2017-03-31,57843,0.004895,0.376308,0.4721706,0.0017391,-0.098525,-0.012437,-0.000142,-0.000086,37,O +2017-04-01,57844,0.005294,0.377543,0.4704666,0.0016269,-0.098677,-0.012679,-0.000054,-0.000086,37,O +2017-04-02,57845,0.005726,0.379066,0.4689063,0.0014914,-0.098833,-0.012710,-0.000060,-0.000063,37,O +2017-04-03,57846,0.006227,0.379825,0.4674913,0.0013746,-0.098799,-0.012636,-0.000065,-0.000039,37,O +2017-04-04,57847,0.007153,0.380838,0.4661507,0.0013230,-0.098661,-0.012569,-0.000070,-0.000016,37,O +2017-04-05,57848,0.008418,0.382508,0.4648247,0.0013373,-0.098374,-0.012356,-0.000051,0.000194,37,O +2017-04-06,57849,0.009587,0.384603,0.4634343,0.0014635,-0.098066,-0.012276,-0.000063,0.000300,37,O +2017-04-07,57850,0.010455,0.386575,0.4619097,0.0015867,-0.097894,-0.012578,-0.000137,0.000050,37,O +2017-04-08,57851,0.010555,0.388428,0.4603054,0.0016542,-0.097662,-0.012733,-0.000132,-0.000039,37,O +2017-04-09,57852,0.010582,0.390108,0.4586447,0.0016711,-0.097549,-0.012765,-0.000093,-0.000030,37,O +2017-04-10,57853,0.010954,0.391815,0.4570130,0.0016200,-0.097552,-0.012729,-0.000054,-0.000022,37,O +2017-04-11,57854,0.011615,0.393605,0.4554115,0.0015628,-0.097560,-0.012633,-0.000014,-0.000014,37,O +2017-04-12,57855,0.012353,0.395189,0.4538072,0.0015655,-0.097725,-0.012545,-0.000032,-0.000011,37,O +2017-04-13,57856,0.014173,0.396821,0.4522472,0.0015977,-0.097995,-0.012520,-0.000065,-0.000009,37,O +2017-04-14,57857,0.016279,0.398825,0.4507197,0.0015318,-0.098248,-0.012554,-0.000080,0.000004,37,O +2017-04-15,57858,0.018224,0.401065,0.4492444,0.0014306,-0.098413,-0.012630,-0.000088,0.000023,37,O +2017-04-16,57859,0.019709,0.403514,0.4478193,0.0014057,-0.098482,-0.012743,-0.000096,0.000041,37,O +2017-04-17,57860,0.021176,0.405745,0.4463842,0.0014669,-0.098502,-0.012872,-0.000103,0.000060,37,O +2017-04-18,57861,0.022689,0.407739,0.4449259,0.0014977,-0.098435,-0.012963,-0.000111,0.000078,37,O +2017-04-19,57862,0.023887,0.409771,0.4434259,0.0015095,-0.098146,-0.012949,-0.000119,0.000096,37,O +2017-04-20,57863,0.024672,0.411357,0.4419414,0.0015148,-0.097661,-0.012898,-0.000124,0.000057,37,O +2017-04-21,57864,0.026074,0.412745,0.4403657,0.0016288,-0.097354,-0.012866,-0.000142,0.000018,37,O +2017-04-22,57865,0.027893,0.414973,0.4386298,0.0018037,-0.097418,-0.012919,-0.000141,0.000008,37,O +2017-04-23,57866,0.029188,0.417538,0.4367309,0.0020108,-0.097701,-0.013009,-0.000132,0.000007,37,O +2017-04-24,57867,0.029775,0.419822,0.4346461,0.0021600,-0.097798,-0.012973,-0.000123,0.000006,37,O +2017-04-25,57868,0.030533,0.421627,0.4324562,0.0022208,-0.097632,-0.012784,-0.000114,0.000005,37,O +2017-04-26,57869,0.031503,0.423256,0.4302575,0.0021462,-0.097855,-0.012573,-0.000215,0.000086,37,O +2017-04-27,57870,0.032210,0.424548,0.4281606,0.0020042,-0.098176,-0.012672,-0.000195,0.000128,37,O +2017-04-28,57871,0.033208,0.425930,0.4262633,0.0017946,-0.098723,-0.013040,-0.000178,0.000093,37,O +2017-04-29,57872,0.034628,0.427532,0.4246052,0.0015522,-0.099092,-0.013308,-0.000168,0.000079,37,O +2017-04-30,57873,0.036275,0.429467,0.4231249,0.0014037,-0.099050,-0.013340,-0.000153,0.000080,37,O +2017-05-01,57874,0.037902,0.431334,0.4217257,0.0013892,-0.098757,-0.013239,-0.000139,0.000081,37,O +2017-05-02,57875,0.039389,0.432900,0.4203557,0.0013941,-0.098500,-0.013142,-0.000125,0.000082,37,O +2017-05-03,57876,0.040572,0.434223,0.4189708,0.0013856,-0.098682,-0.013020,-0.000210,0.000149,37,O +2017-05-04,57877,0.041577,0.435189,0.4175587,0.0014286,-0.098763,-0.012939,-0.000219,0.000209,37,O +2017-05-05,57878,0.043196,0.436527,0.4160970,0.0015356,-0.098454,-0.013051,-0.000119,0.000119,37,O +2017-05-06,57879,0.045141,0.437894,0.4145443,0.0016338,-0.098158,-0.013124,-0.000083,0.000097,37,O +2017-05-07,57880,0.047704,0.438989,0.4129179,0.0016287,-0.097972,-0.013099,-0.000080,0.000115,37,O +2017-05-08,57881,0.050056,0.440496,0.4113774,0.0015006,-0.097980,-0.012944,-0.000077,0.000133,37,O +2017-05-09,57882,0.051965,0.441775,0.4099350,0.0013823,-0.098174,-0.012704,-0.000074,0.000152,37,O +2017-05-10,57883,0.053989,0.443124,0.4085580,0.0013309,-0.098170,-0.012485,0.000032,0.000215,37,O +2017-05-11,57884,0.056190,0.444377,0.4072740,0.0012501,-0.098388,-0.012466,0.000030,0.000246,37,O +2017-05-12,57885,0.058581,0.445931,0.4060909,0.0011401,-0.098606,-0.012585,-0.000011,0.000263,37,O +2017-05-13,57886,0.060692,0.447295,0.4049824,0.0010663,-0.098751,-0.012722,-0.000053,0.000278,37,O +2017-05-14,57887,0.062928,0.448435,0.4039607,0.0010183,-0.098909,-0.012839,-0.000094,0.000292,37,O +2017-05-15,57888,0.064749,0.449370,0.4029798,0.0009724,-0.099160,-0.012974,-0.000136,0.000306,37,O +2017-05-16,57889,0.066769,0.449808,0.4019951,0.0010301,-0.099407,-0.013117,-0.000177,0.000320,37,O +2017-05-17,57890,0.068683,0.450261,0.4009243,0.0011089,-0.099015,-0.013204,-0.000062,0.000292,37,O +2017-05-18,57891,0.070545,0.450676,0.3997859,0.0011737,-0.098612,-0.013115,-0.000078,0.000258,37,O +2017-05-19,57892,0.072542,0.451760,0.3985764,0.0012451,-0.098339,-0.012928,-0.000157,0.000211,37,O +2017-05-20,57893,0.074412,0.452910,0.3972817,0.0013513,-0.098317,-0.012793,-0.000169,0.000180,37,O +2017-05-21,57894,0.076326,0.453653,0.3958681,0.0014966,-0.098676,-0.012792,-0.000153,0.000156,37,O +2017-05-22,57895,0.078346,0.454504,0.3942892,0.0016203,-0.099080,-0.012806,-0.000137,0.000131,37,O +2017-05-23,57896,0.079818,0.455090,0.3926231,0.0016921,-0.099274,-0.012717,-0.000121,0.000107,37,O +2017-05-24,57897,0.081147,0.455475,0.3909289,0.0016664,-0.099630,-0.012531,-0.000175,0.000186,37,O +2017-05-25,57898,0.082343,0.455649,0.3893134,0.0015630,-0.100072,-0.012615,-0.000170,0.000195,37,O +2017-05-26,57899,0.083957,0.455917,0.3878318,0.0013526,-0.100551,-0.012889,-0.000141,0.000175,37,O +2017-05-27,57900,0.085484,0.456291,0.3865631,0.0011527,-0.100791,-0.013081,-0.000124,0.000153,37,O +2017-05-28,57901,0.087442,0.456398,0.3854661,0.0010372,-0.100599,-0.013070,-0.000111,0.000130,37,O +2017-05-29,57902,0.089864,0.456519,0.3844115,0.0010581,-0.100141,-0.012983,-0.000098,0.000107,37,O +2017-05-30,57903,0.092119,0.457095,0.3832675,0.0011626,-0.099794,-0.012964,-0.000086,0.000084,37,O +2017-05-31,57904,0.094026,0.457366,0.3820383,0.0012646,-0.099845,-0.012988,-0.000073,0.000061,37,O +2017-06-01,57905,0.095973,0.457506,0.3807131,0.0013420,-0.100275,-0.012927,-0.000077,0.000087,37,O +2017-06-02,57906,0.097757,0.457787,0.3793404,0.0013639,-0.100654,-0.012844,-0.000086,0.000126,37,O +2017-06-03,57907,0.099567,0.458215,0.3779862,0.0013285,-0.100601,-0.012846,-0.000071,0.000133,37,O +2017-06-04,57908,0.101117,0.458581,0.3766834,0.0012553,-0.100285,-0.012875,-0.000047,0.000128,37,O +2017-06-05,57909,0.102695,0.458523,0.3754598,0.0011671,-0.100120,-0.012814,-0.000023,0.000124,37,O +2017-06-06,57910,0.103952,0.458428,0.3743504,0.0010432,-0.100298,-0.012649,0.000001,0.000119,37,O +2017-06-07,57911,0.105355,0.458308,0.3733798,0.0009034,-0.100662,-0.012506,0.000024,0.000114,37,O +2017-06-08,57912,0.106868,0.458048,0.3725887,0.0007231,-0.100749,-0.012450,0.000122,0.000166,37,O +2017-06-09,57913,0.108532,0.457811,0.3719481,0.0005379,-0.101163,-0.012560,0.000006,0.000178,37,O +2017-06-10,57914,0.109980,0.457484,0.3714596,0.0004535,-0.101252,-0.012669,-0.000034,0.000187,37,O +2017-06-11,57915,0.111451,0.457234,0.3710437,0.0004149,-0.101220,-0.012706,-0.000018,0.000201,37,O +2017-06-12,57916,0.112994,0.456975,0.3706514,0.0003977,-0.101320,-0.012736,-0.000003,0.000216,37,O +2017-06-13,57917,0.114578,0.457220,0.3702609,0.0003921,-0.101506,-0.012816,0.000013,0.000230,37,O +2017-06-14,57918,0.116272,0.457399,0.3698380,0.0004550,-0.101660,-0.012925,0.000003,0.000200,37,O +2017-06-15,57919,0.118300,0.457308,0.3693452,0.0005437,-0.101573,-0.012906,-0.000013,0.000158,37,O +2017-06-16,57920,0.120585,0.457118,0.3687665,0.0006577,-0.101300,-0.012694,-0.000014,0.000148,37,O +2017-06-17,57921,0.122593,0.456680,0.3680847,0.0007541,-0.101206,-0.012436,-0.000010,0.000149,37,O +2017-06-18,57922,0.124179,0.456211,0.3672999,0.0007959,-0.101507,-0.012276,-0.000005,0.000151,37,O +2017-06-19,57923,0.125730,0.455709,0.3664782,0.0008290,-0.102049,-0.012214,0.000000,0.000152,37,O +2017-06-20,57924,0.127862,0.455315,0.3656602,0.0008472,-0.102577,-0.012180,0.000004,0.000154,37,O +2017-06-21,57925,0.130457,0.454990,0.3648458,0.0008045,-0.103083,-0.012212,-0.000007,0.000149,37,O +2017-06-22,57926,0.133152,0.454762,0.3641273,0.0006638,-0.103618,-0.012383,-0.000023,0.000143,37,O +2017-06-23,57927,0.136000,0.454478,0.3635410,0.0004858,-0.104093,-0.012616,-0.000039,0.000138,37,O +2017-06-24,57928,0.138788,0.454113,0.3631326,0.0003972,-0.104262,-0.012698,-0.000038,0.000138,37,O +2017-06-25,57929,0.141007,0.454000,0.3627390,0.0003835,-0.104048,-0.012572,-0.000029,0.000141,37,O +2017-06-26,57930,0.143021,0.453452,0.3623006,0.0004419,-0.103592,-0.012432,-0.000021,0.000144,37,O +2017-06-27,57931,0.145147,0.452649,0.3618042,0.0005187,-0.103203,-0.012452,-0.000013,0.000147,37,O +2017-06-28,57932,0.147212,0.451658,0.3612434,0.0005636,-0.103314,-0.012506,-0.000041,0.000205,37,O +2017-06-29,57933,0.149572,0.450811,0.3606418,0.0005790,-0.103922,-0.012459,-0.000077,0.000278,37,O +2017-06-30,57934,0.152473,0.449903,0.3600727,0.0005539,-0.104371,-0.012396,-0.000003,0.000261,37,O +2017-07-01,57935,0.155696,0.449250,0.3595126,0.0005590,-0.104597,-0.012386,0.000023,0.000214,37,O +2017-07-02,57936,0.159025,0.448761,0.3589361,0.0005418,-0.104512,-0.012471,0.000017,0.000166,37,O +2017-07-03,57937,0.162254,0.448332,0.3584609,0.0004434,-0.104416,-0.012571,0.000011,0.000119,37,O +2017-07-04,57938,0.165708,0.447674,0.3581064,0.0003019,-0.104620,-0.012592,0.000006,0.000071,37,O +2017-07-05,57939,0.168962,0.447193,0.3578547,0.0002085,-0.105007,-0.012497,0.000018,0.000073,37,O +2017-07-06,57940,0.171987,0.446681,0.3576899,0.0001454,-0.105326,-0.012423,0.000036,0.000088,37,O +2017-07-07,57941,0.174976,0.445962,0.3575860,0.0000802,-0.105446,-0.012431,0.000053,0.000103,37,O +2017-07-08,57942,0.177786,0.445212,0.3575080,0.0000763,-0.105446,-0.012464,0.000062,0.000121,37,O +2017-07-09,57943,0.180221,0.444721,0.3574431,0.0000742,-0.105432,-0.012454,0.000067,0.000140,37,O +2017-07-10,57944,0.182001,0.443926,0.3573311,0.0001460,-0.105466,-0.012414,0.000072,0.000160,37,O +2017-07-11,57945,0.183758,0.442796,0.3571391,0.0002704,-0.105579,-0.012399,0.000078,0.000179,37,O +2017-07-12,57946,0.185216,0.441706,0.3568049,0.0004019,-0.105790,-0.012460,0.000071,0.000153,37,O +2017-07-13,57947,0.187119,0.440577,0.3563455,0.0005121,-0.105978,-0.012503,0.000062,0.000114,37,O +2017-07-14,57948,0.189361,0.439329,0.3557732,0.0005981,-0.106044,-0.012461,0.000053,0.000076,37,O +2017-07-15,57949,0.191161,0.438169,0.3551376,0.0006275,-0.105977,-0.012301,0.000069,0.000087,37,O +2017-07-16,57950,0.192339,0.436690,0.3545254,0.0005909,-0.106002,-0.012118,0.000095,0.000115,37,O +2017-07-17,57951,0.193490,0.435030,0.3539270,0.0005814,-0.106271,-0.011990,0.000121,0.000144,37,O +2017-07-18,57952,0.194733,0.433766,0.3533529,0.0005388,-0.106733,-0.011963,0.000147,0.000172,37,O +2017-07-19,57953,0.195900,0.432299,0.3528581,0.0004642,-0.107238,-0.012080,0.000173,0.000201,37,O +2017-07-20,57954,0.197066,0.430717,0.3524275,0.0003825,-0.107793,-0.012360,0.000140,0.000202,37,O +2017-07-21,57955,0.197923,0.428948,0.3520860,0.0003165,-0.108191,-0.012633,0.000091,0.000195,37,O +2017-07-22,57956,0.198629,0.426561,0.3518093,0.0002704,-0.108258,-0.012710,0.000078,0.000169,37,O +2017-07-23,57957,0.199930,0.424439,0.3515352,0.0002800,-0.108061,-0.012555,0.000078,0.000136,37,O +2017-07-24,57958,0.201761,0.422658,0.3512073,0.0003484,-0.107700,-0.012380,0.000078,0.000103,37,O +2017-07-25,57959,0.203423,0.421227,0.3507753,0.0004816,-0.107346,-0.012401,0.000078,0.000070,37,O +2017-07-26,57960,0.204802,0.419916,0.3501881,0.0005927,-0.107193,-0.012401,0.000107,0.000213,37,O +2017-07-27,57961,0.206134,0.418494,0.3495150,0.0006871,-0.107457,-0.012299,0.000144,0.000403,37,O +2017-07-28,57962,0.207107,0.416880,0.3488203,0.0006952,-0.108015,-0.012262,0.000167,0.000374,37,O +2017-07-29,57963,0.207742,0.415305,0.3481523,0.0006325,-0.108517,-0.012214,0.000159,0.000310,37,O +2017-07-30,57964,0.208296,0.413679,0.3475431,0.0005502,-0.108700,-0.012252,0.000142,0.000260,37,O +2017-07-31,57965,0.208825,0.411811,0.3470427,0.0004607,-0.108700,-0.012390,0.000125,0.000210,37,O +2017-08-01,57966,0.209835,0.409886,0.3466598,0.0003137,-0.108778,-0.012510,0.000108,0.000160,37,O +2017-08-02,57967,0.211398,0.408248,0.3464200,0.0001727,-0.108968,-0.012472,0.000100,0.000163,37,O +2017-08-03,57968,0.213291,0.406601,0.3462795,0.0000993,-0.109173,-0.012355,0.000095,0.000181,37,O +2017-08-04,57969,0.214709,0.405433,0.3462009,0.0000931,-0.109331,-0.012280,0.000090,0.000198,37,O +2017-08-05,57970,0.215447,0.404172,0.3461365,0.0001136,-0.109468,-0.012322,0.000083,0.000187,37,O +2017-08-06,57971,0.216162,0.402972,0.3459953,0.0001351,-0.109578,-0.012420,0.000075,0.000165,37,O +2017-08-07,57972,0.217134,0.401528,0.3458381,0.0001868,-0.109621,-0.012481,0.000066,0.000143,37,O +2017-08-08,57973,0.218544,0.399806,0.3456227,0.0002779,-0.109619,-0.012465,0.000058,0.000121,37,O +2017-08-09,57974,0.220136,0.398184,0.3452912,0.0004027,-0.109583,-0.012372,0.000094,0.000126,37,O +2017-08-10,57975,0.221888,0.396576,0.3448193,0.0005551,-0.109641,-0.012284,0.000142,0.000138,37,O +2017-08-11,57976,0.223520,0.394783,0.3441755,0.0006498,-0.109709,-0.012243,0.000189,0.000149,37,O +2017-08-12,57977,0.224272,0.393044,0.3435062,0.0006914,-0.109761,-0.012230,0.000187,0.000159,37,O +2017-08-13,57978,0.224896,0.391349,0.3428387,0.0006686,-0.109760,-0.012196,0.000166,0.000168,37,O +2017-08-14,57979,0.225434,0.389550,0.3422042,0.0005853,-0.109859,-0.012133,0.000146,0.000177,37,O +2017-08-15,57980,0.225504,0.387912,0.3416548,0.0004652,-0.110205,-0.012107,0.000125,0.000185,37,O +2017-08-16,57981,0.225102,0.385969,0.3412337,0.0003525,-0.110709,-0.012228,0.000105,0.000174,37,O +2017-08-17,57982,0.225340,0.383821,0.3409345,0.0002400,-0.111139,-0.012489,0.000085,0.000158,37,O +2017-08-18,57983,0.226326,0.381367,0.3407294,0.0002003,-0.111247,-0.012725,0.000091,0.000158,37,O +2017-08-19,57984,0.227537,0.379678,0.3405044,0.0002042,-0.111037,-0.012749,0.000119,0.000173,37,O +2017-08-20,57985,0.228598,0.378522,0.3403106,0.0002715,-0.110669,-0.012534,0.000150,0.000190,37,O +2017-08-21,57986,0.229558,0.377439,0.3399784,0.0004262,-0.110260,-0.012254,0.000181,0.000208,37,O +2017-08-22,57987,0.230232,0.375700,0.3394944,0.0005179,-0.109898,-0.012117,0.000212,0.000225,37,O +2017-08-23,57988,0.230696,0.373866,0.3390036,0.0005317,-0.109851,-0.012186,0.000182,0.000208,37,O +2017-08-24,57989,0.231049,0.371805,0.3384781,0.0005067,-0.110115,-0.012287,0.000135,0.000181,37,O +2017-08-25,57990,0.231829,0.369601,0.3379075,0.0004783,-0.110614,-0.012283,0.000088,0.000153,37,O +2017-08-26,57991,0.232957,0.367826,0.3374465,0.0004120,-0.111071,-0.012181,0.000072,0.000154,37,O +2017-08-27,57992,0.233753,0.366209,0.3370878,0.0003330,-0.111317,-0.012132,0.000066,0.000165,37,O +2017-08-28,57993,0.234245,0.364398,0.3367924,0.0002433,-0.111309,-0.012198,0.000060,0.000177,37,O +2017-08-29,57994,0.234844,0.362943,0.3365842,0.0001331,-0.111143,-0.012296,0.000055,0.000188,37,O +2017-08-30,57995,0.235156,0.361481,0.3364611,0.0000932,-0.110913,-0.012302,0.000074,0.000203,37,O +2017-08-31,57996,0.235394,0.359463,0.3363733,0.0001055,-0.110781,-0.012207,0.000099,0.000219,37,O +2017-09-01,57997,0.235563,0.357060,0.3362970,0.0001351,-0.110810,-0.012118,0.000123,0.000238,37,O +2017-09-02,57998,0.236028,0.355000,0.3361941,0.0001463,-0.110974,-0.012176,0.000139,0.000228,37,O +2017-09-03,57999,0.236808,0.353230,0.3360359,0.0002014,-0.111138,-0.012353,0.000152,0.000208,37,O +2017-09-04,58000,0.237536,0.351605,0.3357933,0.0003011,-0.111166,-0.012502,0.000165,0.000188,37,O +2017-09-05,58001,0.237920,0.350129,0.3353965,0.0004775,-0.111055,-0.012478,0.000177,0.000168,37,O +2017-09-06,58002,0.238534,0.348089,0.3348249,0.0006648,-0.110928,-0.012265,0.000190,0.000149,37,O +2017-09-07,58003,0.239949,0.346217,0.3340654,0.0008328,-0.111002,-0.011981,0.000166,0.000156,37,O +2017-09-08,58004,0.241033,0.344387,0.3331719,0.0009041,-0.111199,-0.011820,0.000131,0.000170,37,O +2017-09-09,58005,0.241460,0.342815,0.3322438,0.0009404,-0.111301,-0.011889,0.000128,0.000143,37,O +2017-09-10,58006,0.241406,0.341734,0.3312789,0.0009249,-0.111304,-0.012065,0.000137,0.000101,37,O +2017-09-11,58007,0.241149,0.340693,0.3303711,0.0008592,-0.111308,-0.012193,0.000145,0.000059,37,O +2017-09-12,58008,0.240712,0.339184,0.3295699,0.0007488,-0.111412,-0.012229,0.000154,0.000017,37,O +2017-09-13,58009,0.239490,0.337433,0.3289039,0.0006369,-0.111625,-0.012177,0.000161,0.000050,37,O +2017-09-14,58010,0.237894,0.335801,0.3283142,0.0005645,-0.111775,-0.012170,0.000180,0.000106,37,O +2017-09-15,58011,0.236997,0.334277,0.3277308,0.0005783,-0.111734,-0.012205,0.000194,0.000161,37,O +2017-09-16,58012,0.236151,0.333110,0.3271296,0.0006602,-0.111452,-0.012204,0.000201,0.000178,37,O +2017-09-17,58013,0.235437,0.331475,0.3263790,0.0008362,-0.111028,-0.012076,0.000206,0.000181,37,O +2017-09-18,58014,0.234932,0.329981,0.3254469,0.0010116,-0.110641,-0.011871,0.000210,0.000184,37,O +2017-09-19,58015,0.234376,0.328251,0.3243832,0.0010991,-0.110403,-0.011712,0.000215,0.000187,37,O +2017-09-20,58016,0.233504,0.326435,0.3232856,0.0011158,-0.110345,-0.011669,0.000210,0.000174,37,O +2017-09-21,58017,0.232368,0.324511,0.3221774,0.0010613,-0.110402,-0.011680,0.000202,0.000156,37,O +2017-09-22,58018,0.231480,0.322598,0.3211052,0.0009977,-0.110531,-0.011667,0.000193,0.000139,37,O +2017-09-23,58019,0.230275,0.320849,0.3201659,0.0009103,-0.110645,-0.011605,0.000203,0.000156,37,O +2017-09-24,58020,0.229146,0.318541,0.3193171,0.0008010,-0.110721,-0.011569,0.000200,0.000203,37,O +2017-09-25,58021,0.228437,0.316331,0.3186011,0.0006364,-0.110584,-0.011619,0.000198,0.000251,37,O +2017-09-26,58022,0.227384,0.314024,0.3180127,0.0005399,-0.110208,-0.011696,0.000196,0.000298,37,O +2017-09-27,58023,0.226738,0.311756,0.3174763,0.0005185,-0.109740,-0.011786,0.000205,0.000263,37,O +2017-09-28,58024,0.226108,0.309713,0.3169636,0.0005437,-0.109456,-0.011803,0.000217,0.000206,37,O +2017-09-29,58025,0.225592,0.307796,0.3163823,0.0006093,-0.109459,-0.011798,0.000229,0.000149,37,O +2017-09-30,58026,0.224857,0.305629,0.3157773,0.0006513,-0.109606,-0.011833,0.000245,0.000127,37,O +2017-10-01,58027,0.224071,0.303037,0.3151520,0.0006489,-0.109694,-0.011949,0.000262,0.000118,37,O +2017-10-02,58028,0.222819,0.300646,0.3145029,0.0006786,-0.109641,-0.012054,0.000279,0.000109,37,O +2017-10-03,58029,0.222129,0.298414,0.3137523,0.0008123,-0.109497,-0.011994,0.000296,0.000100,37,O +2017-10-04,58030,0.221797,0.296685,0.3128743,0.0009580,-0.109380,-0.011702,0.000296,0.000093,37,O +2017-10-05,58031,0.221944,0.294777,0.3118597,0.0010656,-0.109286,-0.011301,0.000292,0.000087,37,O +2017-10-06,58032,0.221694,0.293830,0.3107083,0.0011534,-0.109232,-0.011030,0.000288,0.000080,37,O +2017-10-07,58033,0.220172,0.293025,0.3095429,0.0011747,-0.109284,-0.011048,0.000273,0.000076,37,O +2017-10-08,58034,0.218361,0.292105,0.3084078,0.0011144,-0.109435,-0.011289,0.000254,0.000074,37,O +2017-10-09,58035,0.216190,0.290860,0.3073780,0.0009523,-0.109627,-0.011518,0.000235,0.000072,37,O +2017-10-10,58036,0.214075,0.289134,0.3064886,0.0008137,-0.109804,-0.011554,0.000216,0.000070,37,O +2017-10-11,58037,0.212230,0.287377,0.3057000,0.0007520,-0.109936,-0.011426,0.000197,0.000067,37,O +2017-10-12,58038,0.210250,0.285371,0.3049588,0.0007432,-0.109951,-0.011273,0.000199,0.000078,37,O +2017-10-13,58039,0.208688,0.283429,0.3041878,0.0008181,-0.109838,-0.011200,0.000207,0.000092,37,O +2017-10-14,58040,0.207152,0.281526,0.3033061,0.0009286,-0.109586,-0.011195,0.000206,0.000095,37,O +2017-10-15,58041,0.205699,0.279734,0.3023366,0.0010431,-0.109222,-0.011181,0.000198,0.000094,37,O +2017-10-16,58042,0.204789,0.278139,0.3012098,0.0012003,-0.108866,-0.011129,0.000192,0.000093,37,O +2017-10-17,58043,0.203852,0.276870,0.2999400,0.0013201,-0.108676,-0.011055,0.000186,0.000093,37,O +2017-10-18,58044,0.202570,0.275423,0.2985802,0.0013856,-0.108627,-0.010958,0.000195,0.000105,37,O +2017-10-19,58045,0.201228,0.273719,0.2971914,0.0013915,-0.108620,-0.010839,0.000209,0.000122,37,O +2017-10-20,58046,0.199944,0.272093,0.2958171,0.0013185,-0.108560,-0.010722,0.000222,0.000138,37,O +2017-10-21,58047,0.198720,0.270643,0.2945597,0.0011990,-0.108436,-0.010697,0.000236,0.000118,37,O +2017-10-22,58048,0.197301,0.269564,0.2933902,0.0011196,-0.108256,-0.010781,0.000250,0.000085,37,O +2017-10-23,58049,0.196020,0.268412,0.2923027,0.0010418,-0.107946,-0.010932,0.000264,0.000052,37,O +2017-10-24,58050,0.194584,0.266918,0.2913105,0.0009175,-0.107458,-0.011069,0.000278,0.000019,37,O +2017-10-25,58051,0.192750,0.265653,0.2904360,0.0008474,-0.106940,-0.011068,0.000294,0.000049,37,O +2017-10-26,58052,0.190522,0.264053,0.2896147,0.0008123,-0.106651,-0.010978,0.000311,0.000095,37,O +2017-10-27,58053,0.188640,0.262493,0.2887939,0.0008334,-0.106665,-0.010857,0.000327,0.000141,37,O +2017-10-28,58054,0.186601,0.261204,0.2879459,0.0008936,-0.106791,-0.010783,0.000328,0.000145,37,O +2017-10-29,58055,0.184638,0.259903,0.2869850,0.0010265,-0.106765,-0.010742,0.000324,0.000134,37,O +2017-10-30,58056,0.183111,0.258826,0.2859308,0.0011120,-0.106605,-0.010698,0.000319,0.000122,37,O +2017-10-31,58057,0.181829,0.257809,0.2847593,0.0012724,-0.106504,-0.010595,0.000314,0.000111,37,O +2017-11-01,58058,0.180296,0.256856,0.2834260,0.0013777,-0.106511,-0.010381,0.000305,0.000085,37,O +2017-11-02,58059,0.179139,0.255937,0.2819666,0.0014899,-0.106480,-0.010059,0.000295,0.000055,37,O +2017-11-03,58060,0.178168,0.255529,0.2804309,0.0015674,-0.106352,-0.009789,0.000285,0.000025,37,O +2017-11-04,58061,0.176819,0.255000,0.2788424,0.0015059,-0.106193,-0.009737,0.000300,0.000038,37,O +2017-11-05,58062,0.175227,0.254016,0.2773391,0.0014047,-0.106151,-0.009947,0.000325,0.000066,37,O +2017-11-06,58063,0.173465,0.252887,0.2760567,0.0012567,-0.106207,-0.010183,0.000349,0.000094,37,O +2017-11-07,58064,0.171798,0.251605,0.2749413,0.0010899,-0.106245,-0.010180,0.000373,0.000122,37,O +2017-11-08,58065,0.170596,0.250256,0.2738988,0.0010311,-0.106304,-0.009967,0.000359,0.000124,37,O +2017-11-09,58066,0.169120,0.249358,0.2728644,0.0010728,-0.106318,-0.009745,0.000335,0.000118,37,O +2017-11-10,58067,0.167646,0.247946,0.2717606,0.0011765,-0.106284,-0.009663,0.000311,0.000112,37,O +2017-11-11,58068,0.166396,0.246848,0.2705042,0.0013010,-0.106208,-0.009703,0.000289,0.000098,37,O +2017-11-12,58069,0.164923,0.246174,0.2691669,0.0013675,-0.106087,-0.009771,0.000268,0.000080,37,O +2017-11-13,58070,0.163368,0.245937,0.2677576,0.0014516,-0.105934,-0.009828,0.000248,0.000062,37,O +2017-11-14,58071,0.161570,0.245403,0.2663008,0.0015009,-0.105831,-0.009872,0.000227,0.000044,37,O +2017-11-15,58072,0.160062,0.244625,0.2648310,0.0014389,-0.105745,-0.009873,0.000248,0.000016,37,O +2017-11-16,58073,0.158441,0.244147,0.2634238,0.0013377,-0.105720,-0.009790,0.000281,-0.000015,37,O +2017-11-17,58074,0.156031,0.243545,0.2621434,0.0012121,-0.105676,-0.009662,0.000313,-0.000047,37,O +2017-11-18,58075,0.153245,0.242360,0.2610143,0.0010708,-0.105640,-0.009564,0.000304,-0.000041,37,O +2017-11-19,58076,0.150733,0.241508,0.2599935,0.0009289,-0.105541,-0.009588,0.000280,-0.000022,37,O +2017-11-20,58077,0.148216,0.240689,0.2591342,0.0007991,-0.105337,-0.009688,0.000256,-0.000004,37,O +2017-11-21,58078,0.145643,0.239916,0.2584099,0.0006741,-0.105037,-0.009744,0.000232,0.000015,37,O +2017-11-22,58079,0.143796,0.239140,0.2577664,0.0005958,-0.104627,-0.009741,0.000261,0.000004,37,O +2017-11-23,58080,0.141993,0.238659,0.2571255,0.0006479,-0.104462,-0.009692,0.000276,-0.000006,37,O +2017-11-24,58081,0.139593,0.238267,0.2564500,0.0007206,-0.104560,-0.009642,0.000280,-0.000013,37,O +2017-11-25,58082,0.136821,0.237907,0.2557083,0.0008135,-0.104678,-0.009569,0.000280,-0.000019,37,O +2017-11-26,58083,0.135302,0.237390,0.2548803,0.0008983,-0.104574,-0.009444,0.000284,-0.000026,37,O +2017-11-27,58084,0.133543,0.237050,0.2539082,0.0010037,-0.104348,-0.009298,0.000287,-0.000032,37,O +2017-11-28,58085,0.131125,0.236745,0.2527766,0.0011990,-0.104274,-0.009217,0.000286,-0.000061,37,O +2017-11-29,58086,0.128797,0.236939,0.2514787,0.0013712,-0.104158,-0.009158,0.000374,-0.000093,37,O +2017-11-30,58087,0.126354,0.237180,0.2500223,0.0014800,-0.104223,-0.008989,0.000372,-0.000094,37,O +2017-12-01,58088,0.124093,0.236688,0.2485146,0.0015526,-0.104224,-0.008714,0.000337,-0.000066,37,O +2017-12-02,58089,0.121669,0.236396,0.2469845,0.0014888,-0.104242,-0.008589,0.000307,-0.000074,37,O +2017-12-03,58090,0.119232,0.235541,0.2455790,0.0013598,-0.104436,-0.008739,0.000271,-0.000103,37,O +2017-12-04,58091,0.116892,0.234876,0.2442675,0.0012433,-0.104661,-0.008966,0.000233,-0.000115,37,O +2017-12-05,58092,0.114703,0.233893,0.2430519,0.0011899,-0.104582,-0.008969,0.000254,-0.000106,37,O +2017-12-06,58093,0.112573,0.233274,0.2418883,0.0012004,-0.104340,-0.008726,0.000274,-0.000097,37,O +2017-12-07,58094,0.109471,0.233507,0.2406610,0.0012285,-0.104033,-0.008487,0.000295,-0.000088,37,O +2017-12-08,58095,0.106820,0.233390,0.2393921,0.0013084,-0.103786,-0.008449,0.000304,-0.000089,37,O +2017-12-09,58096,0.104779,0.233975,0.2380590,0.0014075,-0.103678,-0.008532,0.000302,-0.000101,37,O +2017-12-10,58097,0.102552,0.234646,0.2366194,0.0014623,-0.103667,-0.008557,0.000313,-0.000101,37,O +2017-12-11,58098,0.100164,0.235436,0.2351531,0.0014388,-0.103650,-0.008519,0.000335,-0.000089,37,O +2017-12-12,58099,0.097687,0.236146,0.2337292,0.0013979,-0.103587,-0.008521,0.000346,-0.000078,37,O +2017-12-13,58100,0.095346,0.236563,0.2323789,0.0012996,-0.103545,-0.008559,0.000346,-0.000066,37,O +2017-12-14,58101,0.092869,0.237048,0.2311805,0.0011260,-0.103622,-0.008547,0.000346,-0.000055,37,O +2017-12-15,58102,0.090256,0.237578,0.2301449,0.0009664,-0.104133,-0.008469,0.000212,-0.000057,37,O +2017-12-16,58103,0.087663,0.238079,0.2292828,0.0008096,-0.104257,-0.008405,0.000210,-0.000061,37,O +2017-12-17,58104,0.084775,0.238599,0.2285224,0.0006581,-0.104213,-0.008449,0.000208,-0.000064,37,O +2017-12-18,58105,0.081905,0.239044,0.2279421,0.0005536,-0.103920,-0.008560,0.000243,-0.000055,37,O +2017-12-19,58106,0.078820,0.239525,0.2274388,0.0005109,-0.103727,-0.008650,0.000210,-0.000069,37,O +2017-12-20,58107,0.075952,0.239470,0.2269498,0.0005232,-0.103530,-0.008628,0.000194,-0.000068,37,O +2017-12-21,58108,0.073645,0.238795,0.2263773,0.0005487,-0.103465,-0.008572,0.000182,-0.000062,37,O +2017-12-22,58109,0.071910,0.238294,0.2258219,0.0005620,-0.103561,-0.008558,0.000170,-0.000057,37,O +2017-12-23,58110,0.070537,0.238466,0.2252380,0.0006447,-0.103698,-0.008551,0.000158,-0.000051,37,O +2017-12-24,58111,0.069324,0.239063,0.2245258,0.0007923,-0.103729,-0.008483,0.000146,-0.000046,37,O +2017-12-25,58112,0.068299,0.239814,0.2236718,0.0009227,-0.103681,-0.008368,0.000134,-0.000040,37,O +2017-12-26,58113,0.067657,0.240686,0.2226951,0.0010303,-0.103721,-0.008311,0.000123,-0.000035,37,O +2017-12-27,58114,0.067318,0.241626,0.2216122,0.0011376,-0.103879,-0.008338,0.000111,-0.000029,37,O +2017-12-28,58115,0.066650,0.243120,0.2204482,0.0011573,-0.103936,-0.008136,0.000120,0.000161,37,O +2017-12-29,58116,0.064878,0.244392,0.2192942,0.0011094,-0.104003,-0.008100,0.000092,0.000031,37,O +2017-12-30,58117,0.063071,0.245448,0.2182464,0.0010466,-0.104182,-0.007948,0.000086,-0.000018,37,O +2017-12-31,58118,0.061214,0.246580,0.2172353,0.0009457,-0.104640,-0.007939,0.000090,-0.000022,37,O +2018-01-01,58119,0.059224,0.247646,0.2163654,0.0008241,-0.104830,-0.008240,0.000207,-0.000160,37,O +2018-01-02,58120,0.057406,0.248566,0.2156078,0.0007355,-0.104920,-0.008348,0.000208,-0.000188,37,O +2018-01-03,58121,0.055667,0.249547,0.2148691,0.0007464,-0.104527,-0.008241,0.000209,-0.000215,37,O +2018-01-04,58122,0.054388,0.250409,0.2140616,0.0008484,-0.103785,-0.008056,0.000249,-0.000192,37,O +2018-01-05,58123,0.053497,0.251568,0.2131861,0.0008848,-0.103061,-0.008026,0.000300,-0.000157,37,O +2018-01-06,58124,0.052593,0.252938,0.2122905,0.0008868,-0.102711,-0.008109,0.000312,-0.000156,37,O +2018-01-07,58125,0.050970,0.254226,0.2114201,0.0008519,-0.102756,-0.008078,0.000309,-0.000167,37,O +2018-01-08,58126,0.049223,0.255002,0.2106218,0.0007565,-0.102991,-0.007917,0.000307,-0.000179,37,O +2018-01-09,58127,0.047987,0.255808,0.2099302,0.0006126,-0.103161,-0.007814,0.000304,-0.000191,37,O +2018-01-10,58128,0.046686,0.257130,0.2093475,0.0005072,-0.103295,-0.007867,0.000274,-0.000188,37,O +2018-01-11,58129,0.045008,0.258580,0.2088731,0.0004246,-0.103520,-0.008005,0.000236,-0.000181,37,O +2018-01-12,58130,0.043355,0.259855,0.2085075,0.0003018,-0.103884,-0.008103,0.000198,-0.000174,37,O +2018-01-13,58131,0.041402,0.260606,0.2082775,0.0001676,-0.104168,-0.008165,0.000174,-0.000184,37,O +2018-01-14,58132,0.039860,0.260774,0.2081607,0.0000794,-0.104193,-0.008253,0.000155,-0.000199,37,O +2018-01-15,58133,0.038639,0.261182,0.2081094,0.0000335,-0.103991,-0.008384,0.000136,-0.000215,37,O +2018-01-16,58134,0.037810,0.261913,0.2080798,0.0000282,-0.103728,-0.008484,0.000117,-0.000230,37,O +2018-01-17,58135,0.037169,0.263221,0.2080186,0.0000780,-0.103399,-0.008477,0.000150,-0.000225,37,O +2018-01-18,58136,0.036146,0.264989,0.2078912,0.0001477,-0.103126,-0.008418,0.000197,-0.000214,37,O +2018-01-19,58137,0.034752,0.266831,0.2076636,0.0002862,-0.102951,-0.008394,0.000245,-0.000203,37,O +2018-01-20,58138,0.032747,0.268633,0.2073080,0.0004294,-0.102985,-0.008422,0.000252,-0.000199,37,O +2018-01-21,58139,0.030561,0.270346,0.2067994,0.0005816,-0.103123,-0.008449,0.000245,-0.000198,37,O +2018-01-22,58140,0.028676,0.272068,0.2061278,0.0007363,-0.103265,-0.008452,0.000238,-0.000196,37,O +2018-01-23,58141,0.027384,0.273712,0.2053153,0.0008662,-0.103382,-0.008479,0.000231,-0.000195,37,O +2018-01-24,58142,0.026021,0.275528,0.2044009,0.0009243,-0.103507,-0.008570,0.000209,-0.000212,37,O +2018-01-25,58143,0.024129,0.277399,0.2034218,0.0009929,-0.103584,-0.008638,0.000184,-0.000233,37,O +2018-01-26,58144,0.022368,0.279079,0.2024259,0.0010030,-0.103671,-0.008590,0.000158,-0.000254,37,O +2018-01-27,58145,0.020849,0.280621,0.2014710,0.0009578,-0.103904,-0.008471,0.000161,-0.000255,37,O +2018-01-28,58146,0.019338,0.281805,0.2005689,0.0008831,-0.104442,-0.008465,0.000175,-0.000247,37,O +2018-01-29,58147,0.018277,0.282895,0.1996857,0.0008961,-0.105068,-0.008630,0.000188,-0.000239,37,O +2018-01-30,58148,0.017699,0.284465,0.1987616,0.0009826,-0.105329,-0.008791,0.000201,-0.000232,37,O +2018-01-31,58149,0.016664,0.286211,0.1977227,0.0011157,-0.105103,-0.008826,0.000173,-0.000248,37,O +2018-02-01,58150,0.015367,0.288248,0.1965069,0.0012990,-0.104483,-0.008809,0.000134,-0.000270,37,O +2018-02-02,58151,0.014067,0.290203,0.1950929,0.0015264,-0.103812,-0.008900,0.000094,-0.000292,37,O +2018-02-03,58152,0.012458,0.291691,0.1935028,0.0016713,-0.103351,-0.009034,0.000085,-0.000296,37,O +2018-02-04,58153,0.010601,0.293313,0.1918164,0.0016883,-0.103308,-0.009019,0.000087,-0.000294,37,O +2018-02-05,58154,0.008260,0.295375,0.1901389,0.0016217,-0.103585,-0.008806,0.000089,-0.000291,37,O +2018-02-06,58155,0.006624,0.296675,0.1885561,0.0014783,-0.103904,-0.008589,0.000091,-0.000289,37,O +2018-02-07,58156,0.006188,0.297813,0.1871202,0.0013497,-0.104131,-0.008559,0.000093,-0.000272,37,O +2018-02-08,58157,0.005592,0.299623,0.1858660,0.0011840,-0.104357,-0.008730,0.000095,-0.000252,37,O +2018-02-09,58158,0.004664,0.301372,0.1847954,0.0009818,-0.104632,-0.008951,0.000097,-0.000231,37,O +2018-02-10,58159,0.004091,0.303167,0.1839041,0.0008318,-0.104757,-0.009131,0.000109,-0.000242,37,O +2018-02-11,58160,0.003494,0.305155,0.1831267,0.0007473,-0.104559,-0.009253,0.000124,-0.000265,37,O +2018-02-12,58161,0.003276,0.307207,0.1823799,0.0007322,-0.104107,-0.009357,0.000138,-0.000288,37,O +2018-02-13,58162,0.002984,0.309331,0.1816279,0.0007615,-0.103642,-0.009446,0.000153,-0.000311,37,O +2018-02-14,58163,0.002565,0.311263,0.1808512,0.0007852,-0.103368,-0.009454,0.000149,-0.000308,37,O +2018-02-15,58164,0.001884,0.313278,0.1800285,0.0008537,-0.103219,-0.009383,0.000140,-0.000297,37,O +2018-02-16,58165,0.001348,0.315040,0.1791409,0.0009340,-0.103126,-0.009287,0.000130,-0.000287,37,O +2018-02-17,58166,0.001023,0.316434,0.1781745,0.0010498,-0.103112,-0.009237,0.000127,-0.000285,37,O +2018-02-18,58167,0.000643,0.317986,0.1771163,0.0011086,-0.103236,-0.009264,0.000125,-0.000286,37,O +2018-02-19,58168,0.000907,0.319569,0.1759756,0.0011378,-0.103422,-0.009362,0.000124,-0.000287,37,O +2018-02-20,58169,0.001162,0.321719,0.1747959,0.0011246,-0.103544,-0.009499,0.000122,-0.000288,37,O +2018-02-21,58170,0.002029,0.324307,0.1736372,0.0011258,-0.103588,-0.009618,0.000113,-0.000286,37,O +2018-02-22,58171,0.002404,0.327028,0.1725392,0.0010527,-0.103624,-0.009676,0.000102,-0.000283,37,O +2018-02-23,58172,0.002546,0.329196,0.1715292,0.0009602,-0.103731,-0.009674,0.000091,-0.000280,37,O +2018-02-24,58173,0.002346,0.331737,0.1706169,0.0008620,-0.103928,-0.009675,0.000084,-0.000267,37,O +2018-02-25,58174,0.001950,0.333862,0.1697908,0.0007958,-0.104175,-0.009768,0.000080,-0.000251,37,O +2018-02-26,58175,0.001248,0.336065,0.1690150,0.0007669,-0.104370,-0.009944,0.000075,-0.000234,37,O +2018-02-27,58176,0.000269,0.337967,0.1682352,0.0008250,-0.104374,-0.010082,0.000071,-0.000217,37,O +2018-02-28,58177,-0.000516,0.339621,0.1673848,0.0009292,-0.104135,-0.010152,0.000065,-0.000248,37,O +2018-03-01,58178,-0.000331,0.341456,0.1664040,0.0010315,-0.103717,-0.010206,0.000060,-0.000292,37,O +2018-03-02,58179,0.001126,0.343708,0.1652728,0.0011896,-0.103285,-0.010366,0.000054,-0.000336,37,O +2018-03-03,58180,0.002712,0.346327,0.1640424,0.0012725,-0.102932,-0.010534,0.000077,-0.000301,37,O +2018-03-04,58181,0.003975,0.349010,0.1627918,0.0012376,-0.102798,-0.010579,0.000112,-0.000236,37,O +2018-03-05,58182,0.005332,0.351687,0.1615893,0.0011401,-0.102888,-0.010416,0.000147,-0.000172,37,O +2018-03-06,58183,0.006531,0.354263,0.1604864,0.0009967,-0.103085,-0.010146,0.000182,-0.000107,37,O +2018-03-07,58184,0.007274,0.356696,0.1594963,0.0009130,-0.103472,-0.010060,0.000149,-0.000118,37,O +2018-03-08,58185,0.007637,0.358777,0.1586161,0.0008357,-0.103902,-0.010203,0.000098,-0.000150,37,O +2018-03-09,58186,0.007944,0.360408,0.1578248,0.0007524,-0.104271,-0.010463,0.000047,-0.000181,37,O +2018-03-10,58187,0.008378,0.361611,0.1570935,0.0006874,-0.104345,-0.010670,0.000025,-0.000192,37,O +2018-03-11,58188,0.009615,0.362571,0.1563865,0.0006912,-0.104047,-0.010771,0.000014,-0.000197,37,O +2018-03-12,58189,0.011419,0.363948,0.1556864,0.0007115,-0.103516,-0.010809,0.000003,-0.000201,37,O +2018-03-13,58190,0.012950,0.365561,0.1549527,0.0007747,-0.103023,-0.010837,-0.000007,-0.000205,37,O +2018-03-14,58191,0.013959,0.367340,0.1541281,0.0008772,-0.102770,-0.010882,-0.000023,-0.000243,37,O +2018-03-15,58192,0.014539,0.369281,0.1532194,0.0009668,-0.102711,-0.010869,-0.000040,-0.000291,37,O +2018-03-16,58193,0.014779,0.371257,0.1522313,0.0010444,-0.102716,-0.010771,-0.000056,-0.000339,37,O +2018-03-17,58194,0.014886,0.373052,0.1511761,0.0011224,-0.102691,-0.010595,-0.000050,-0.000324,37,O +2018-03-18,58195,0.015019,0.374488,0.1500468,0.0011740,-0.102694,-0.010497,-0.000034,-0.000284,37,O +2018-03-19,58196,0.015609,0.375890,0.1488428,0.0012189,-0.102742,-0.010574,-0.000018,-0.000245,37,O +2018-03-20,58197,0.016813,0.377449,0.1475917,0.0012435,-0.102786,-0.010776,-0.000002,-0.000205,37,O +2018-03-21,58198,0.017650,0.378784,0.1463366,0.0012241,-0.102871,-0.011001,-0.000004,-0.000191,37,O +2018-03-22,58199,0.019086,0.379665,0.1451449,0.0011419,-0.103031,-0.011120,-0.000011,-0.000184,37,O +2018-03-23,58200,0.020817,0.381008,0.1440622,0.0010292,-0.103270,-0.011130,-0.000018,-0.000177,37,O +2018-03-24,58201,0.022159,0.382614,0.1430972,0.0009171,-0.103469,-0.011135,-0.000024,-0.000175,37,O +2018-03-25,58202,0.023438,0.384261,0.1422092,0.0008399,-0.103448,-0.011210,-0.000029,-0.000176,37,O +2018-03-26,58203,0.024380,0.385508,0.1413379,0.0008807,-0.103137,-0.011325,-0.000034,-0.000176,37,O +2018-03-27,58204,0.025665,0.386420,0.1404065,0.0010139,-0.102654,-0.011387,-0.000039,-0.000176,37,O +2018-03-28,58205,0.026966,0.387391,0.1393347,0.0011568,-0.102119,-0.011348,-0.000002,-0.000167,37,O +2018-03-29,58206,0.028097,0.388998,0.1381541,0.0012561,-0.101870,-0.011300,0.000010,-0.000156,37,O +2018-03-30,58207,0.029413,0.390776,0.1368509,0.0013371,-0.101883,-0.011355,0.000009,-0.000145,37,O +2018-03-31,58208,0.031024,0.392661,0.1354288,0.0013923,-0.102007,-0.011517,0.000008,-0.000135,37,O +2018-04-01,58209,0.032262,0.394493,0.1340372,0.0013722,-0.102118,-0.011650,0.000007,-0.000124,37,O +2018-04-02,58210,0.033078,0.396270,0.1327228,0.0012839,-0.102198,-0.011633,0.000006,-0.000114,37,O +2018-04-03,58211,0.033726,0.398187,0.1315290,0.0011210,-0.102323,-0.011487,0.000005,-0.000103,37,O +2018-04-04,58212,0.034053,0.400233,0.1304899,0.0009570,-0.102561,-0.011362,0.000004,-0.000093,37,O +2018-04-05,58213,0.034315,0.402096,0.1296118,0.0007920,-0.102921,-0.011404,-0.000018,-0.000109,37,O +2018-04-06,58214,0.034383,0.403888,0.1288635,0.0006835,-0.103213,-0.011580,-0.000045,-0.000132,37,O +2018-04-07,58215,0.034304,0.405470,0.1281968,0.0006690,-0.103185,-0.011760,-0.000039,-0.000140,37,O +2018-04-08,58216,0.034814,0.407120,0.1275568,0.0006626,-0.102837,-0.011866,-0.000021,-0.000142,37,O +2018-04-09,58217,0.035585,0.408611,0.1268920,0.0006681,-0.102293,-0.011899,-0.000003,-0.000143,37,O +2018-04-10,58218,0.036758,0.410135,0.1261868,0.0006805,-0.101753,-0.011908,0.000015,-0.000145,37,O +2018-04-11,58219,0.037937,0.411910,0.1254467,0.0007539,-0.101474,-0.011894,0.000006,-0.000131,37,O +2018-04-12,58220,0.038729,0.413822,0.1246552,0.0008512,-0.101479,-0.011833,-0.000010,-0.000114,37,O +2018-04-13,58221,0.038891,0.415750,0.1237615,0.0009701,-0.101673,-0.011688,-0.000026,-0.000096,37,O +2018-04-14,58222,0.039901,0.417161,0.1227404,0.0011177,-0.101835,-0.011482,-0.000020,-0.000076,37,O +2018-04-15,58223,0.041810,0.418839,0.1215701,0.0012640,-0.101878,-0.011328,-0.000005,-0.000054,37,O +2018-04-16,58224,0.044022,0.420295,0.1202380,0.0013772,-0.101848,-0.011352,0.000009,-0.000032,37,O +2018-04-17,58225,0.045901,0.421593,0.1188655,0.0013269,-0.101868,-0.011583,0.000024,-0.000011,37,O +2018-04-18,58226,0.047414,0.422322,0.1176157,0.0011790,-0.102167,-0.011913,-0.000014,-0.000003,37,O +2018-04-19,58227,0.049409,0.423167,0.1164865,0.0010522,-0.102611,-0.012144,-0.000065,0.000001,37,O +2018-04-20,58228,0.051700,0.424507,0.1154525,0.0009750,-0.103044,-0.012168,-0.000117,0.000005,37,O +2018-04-21,58229,0.053949,0.426011,0.1144821,0.0009481,-0.103168,-0.012076,-0.000104,-0.000020,37,O +2018-04-22,58230,0.056126,0.427544,0.1135260,0.0009773,-0.102994,-0.011994,-0.000067,-0.000056,37,O +2018-04-23,58231,0.057956,0.429171,0.1125234,0.0010753,-0.102557,-0.011988,-0.000030,-0.000091,37,O +2018-04-24,58232,0.059869,0.430738,0.1113951,0.0012418,-0.101945,-0.012029,0.000006,-0.000127,37,O +2018-04-25,58233,0.061417,0.432190,0.1100992,0.0013921,-0.101570,-0.011985,-0.000039,-0.000087,37,O +2018-04-26,58234,0.062620,0.433033,0.1086636,0.0014991,-0.101517,-0.011913,-0.000106,-0.000028,37,O +2018-04-27,58235,0.063635,0.433952,0.1071450,0.0015208,-0.101825,-0.011863,-0.000174,0.000032,37,O +2018-04-28,58236,0.064945,0.434755,0.1055951,0.0015117,-0.102197,-0.011971,-0.000182,-0.000043,37,O +2018-04-29,58237,0.066326,0.435745,0.1041191,0.0014257,-0.102473,-0.012106,-0.000168,-0.000169,37,O +2018-04-30,58238,0.067601,0.436689,0.1028034,0.0012537,-0.102574,-0.012184,-0.000155,-0.000296,37,O +2018-05-01,58239,0.068765,0.437662,0.1016513,0.0010894,-0.102627,-0.012075,-0.000158,-0.000265,37,O +2018-05-02,58240,0.069520,0.438837,0.1006354,0.0009498,-0.102758,-0.011969,-0.000165,-0.000193,37,O +2018-05-03,58241,0.070349,0.439382,0.0997424,0.0008206,-0.102980,-0.011953,-0.000173,-0.000121,37,O +2018-05-04,58242,0.071442,0.439846,0.0989734,0.0007079,-0.103050,-0.012052,-0.000134,-0.000093,37,O +2018-05-05,58243,0.072190,0.440340,0.0982642,0.0006546,-0.102994,-0.012202,-0.000099,-0.000101,37,O +2018-05-06,58244,0.073183,0.441116,0.0976011,0.0006706,-0.102802,-0.012330,-0.000070,-0.000117,37,O +2018-05-07,58245,0.074056,0.441974,0.0969513,0.0006702,-0.102481,-0.012408,-0.000042,-0.000133,37,O +2018-05-08,58246,0.075289,0.442794,0.0962777,0.0007266,-0.102055,-0.012434,-0.000014,-0.000149,37,O +2018-05-09,58247,0.076503,0.443814,0.0955178,0.0008166,-0.101656,-0.012417,0.000014,-0.000165,37,O +2018-05-10,58248,0.077859,0.444662,0.0946444,0.0009443,-0.101637,-0.012350,-0.000004,-0.000159,37,O +2018-05-11,58249,0.078921,0.445387,0.0936809,0.0009918,-0.102025,-0.012253,-0.000035,-0.000148,37,O +2018-05-12,58250,0.080633,0.445320,0.0926207,0.0010798,-0.102555,-0.012112,-0.000055,-0.000128,37,O +2018-05-13,58251,0.083066,0.445202,0.0915097,0.0011393,-0.102904,-0.011947,-0.000071,-0.000106,37,O +2018-05-14,58252,0.085130,0.445100,0.0904261,0.0010683,-0.103004,-0.011846,-0.000087,-0.000083,37,O +2018-05-15,58253,0.087493,0.445214,0.0894081,0.0009538,-0.103096,-0.011926,-0.000102,-0.000060,37,O +2018-05-16,58254,0.089595,0.445498,0.0885287,0.0007773,-0.103402,-0.012225,-0.000121,-0.000076,37,O +2018-05-17,58255,0.091800,0.445717,0.0877927,0.0006490,-0.103808,-0.012527,-0.000141,-0.000101,37,O +2018-05-18,58256,0.093988,0.446225,0.0871846,0.0005571,-0.104055,-0.012609,-0.000160,-0.000127,37,O +2018-05-19,58257,0.095672,0.446942,0.0866198,0.0005359,-0.103931,-0.012424,-0.000128,-0.000133,37,O +2018-05-20,58258,0.096977,0.447467,0.0860403,0.0006025,-0.103642,-0.012164,-0.000076,-0.000132,37,O +2018-05-21,58259,0.098121,0.447749,0.0854020,0.0007001,-0.103568,-0.011997,-0.000106,-0.000108,37,O +2018-05-22,58260,0.099178,0.447686,0.0846313,0.0008201,-0.103532,-0.011976,-0.000149,-0.000081,37,O +2018-05-23,58261,0.100747,0.447750,0.0837199,0.0009697,-0.103451,-0.012031,-0.000193,-0.000054,37,O +2018-05-24,58262,0.102548,0.447827,0.0826952,0.0010442,-0.103268,-0.012137,-0.000192,-0.000078,37,O +2018-05-25,58263,0.104514,0.447972,0.0816500,0.0010393,-0.103224,-0.012209,-0.000179,-0.000116,37,O +2018-05-26,58264,0.105963,0.447994,0.0806253,0.0009715,-0.103472,-0.012171,-0.000179,-0.000127,37,O +2018-05-27,58265,0.107448,0.447738,0.0796856,0.0008876,-0.103875,-0.012042,-0.000183,-0.000128,37,O +2018-05-28,58266,0.109050,0.447462,0.0788342,0.0007686,-0.104225,-0.011898,-0.000188,-0.000129,37,O +2018-05-29,58267,0.110654,0.447233,0.0781916,0.0005957,-0.104422,-0.011841,-0.000192,-0.000130,37,O +2018-05-30,58268,0.112145,0.447210,0.0777028,0.0004489,-0.104521,-0.011917,-0.000196,-0.000132,37,O +2018-05-31,58269,0.113238,0.447171,0.0773029,0.0003526,-0.104555,-0.012030,-0.000187,-0.000098,37,O +2018-06-01,58270,0.114210,0.446949,0.0769859,0.0003037,-0.104565,-0.012109,-0.000175,-0.000054,37,O +2018-06-02,58271,0.116000,0.446795,0.0766843,0.0003065,-0.104624,-0.012171,-0.000180,-0.000052,37,O +2018-06-03,58272,0.117672,0.446819,0.0763717,0.0003404,-0.104741,-0.012227,-0.000192,-0.000065,37,O +2018-06-04,58273,0.118894,0.446915,0.0760220,0.0003991,-0.104834,-0.012281,-0.000203,-0.000078,37,O +2018-06-05,58274,0.120342,0.446952,0.0756060,0.0004776,-0.104764,-0.012294,-0.000214,-0.000092,37,O +2018-06-06,58275,0.121747,0.447225,0.0751102,0.0005681,-0.104487,-0.012208,-0.000201,-0.000090,37,O +2018-06-07,58276,0.122644,0.447324,0.0744992,0.0006524,-0.104361,-0.012076,-0.000182,-0.000084,37,O +2018-06-08,58277,0.123501,0.447248,0.0737808,0.0007832,-0.104716,-0.011986,-0.000163,-0.000078,37,O +2018-06-09,58278,0.124610,0.446848,0.0729647,0.0008502,-0.105321,-0.011984,-0.000104,-0.000107,37,O +2018-06-10,58279,0.125717,0.446336,0.0720932,0.0008620,-0.105755,-0.011961,-0.000030,-0.000149,37,O +2018-06-11,58280,0.127341,0.445679,0.0712602,0.0007992,-0.106089,-0.011786,-0.000071,-0.000106,37,O +2018-06-12,58281,0.128905,0.445424,0.0705446,0.0006350,-0.106407,-0.011630,-0.000164,-0.000025,37,O +2018-06-13,58282,0.130659,0.445312,0.0699876,0.0004698,-0.106732,-0.011785,-0.000200,-0.000058,37,O +2018-06-14,58283,0.132046,0.445215,0.0695863,0.0003253,-0.107077,-0.012079,-0.000222,-0.000120,37,O +2018-06-15,58284,0.133109,0.444532,0.0693087,0.0002358,-0.107177,-0.012237,-0.000244,-0.000182,37,O +2018-06-16,58285,0.134123,0.443412,0.0690922,0.0002020,-0.106886,-0.012073,-0.000228,-0.000159,37,O +2018-06-17,58286,0.135386,0.442035,0.0688800,0.0002342,-0.106531,-0.011799,-0.000198,-0.000104,37,O +2018-06-18,58287,0.136764,0.440775,0.0685978,0.0003425,-0.106417,-0.011640,-0.000168,-0.000048,37,O +2018-06-19,58288,0.138420,0.439691,0.0682100,0.0004256,-0.106565,-0.011614,-0.000138,0.000007,37,O +2018-06-20,58289,0.140390,0.438615,0.0677780,0.0004504,-0.106840,-0.011704,-0.000141,-0.000009,37,O +2018-06-21,58290,0.142450,0.438071,0.0673423,0.0003833,-0.106954,-0.011816,-0.000152,-0.000044,37,O +2018-06-22,58291,0.144511,0.437432,0.0669892,0.0002672,-0.106900,-0.011923,-0.000164,-0.000078,37,O +2018-06-23,58292,0.146600,0.436646,0.0668460,0.0000814,-0.106923,-0.011945,-0.000177,-0.000076,37,O +2018-06-24,58293,0.148455,0.435852,0.0669409,-0.0001473,-0.107224,-0.011855,-0.000192,-0.000059,37,O +2018-06-25,58294,0.150195,0.435051,0.0671880,-0.0003268,-0.107726,-0.011717,-0.000207,-0.000042,37,O +2018-06-26,58295,0.152116,0.433889,0.0675349,-0.0004823,-0.108181,-0.011662,-0.000221,-0.000025,37,O +2018-06-27,58296,0.153952,0.432657,0.0680172,-0.0005866,-0.108321,-0.011756,-0.000197,-0.000005,37,O +2018-06-28,58297,0.156053,0.431580,0.0686157,-0.0006457,-0.108224,-0.011909,-0.000162,0.000017,37,O +2018-06-29,58298,0.158519,0.430881,0.0692978,-0.0006204,-0.108055,-0.011966,-0.000128,0.000038,37,O +2018-06-30,58299,0.160961,0.430375,0.0699969,-0.0006147,-0.108038,-0.011907,-0.000119,0.000036,37,O +2018-07-01,58300,0.162871,0.429780,0.0706673,-0.0005928,-0.108216,-0.011825,-0.000119,0.000026,37,O +2018-07-02,58301,0.164852,0.428652,0.0712428,-0.0005769,-0.108490,-0.011807,-0.000120,0.000016,37,O +2018-07-03,58302,0.166885,0.427192,0.0716877,-0.0004792,-0.108644,-0.011817,-0.000120,0.000006,37,O +2018-07-04,58303,0.169493,0.425894,0.0720020,-0.0003125,-0.108565,-0.011763,-0.000109,-0.000011,37,O +2018-07-05,58304,0.172372,0.425368,0.0722155,-0.0001618,-0.108504,-0.011644,-0.000094,-0.000030,37,O +2018-07-06,58305,0.174544,0.425409,0.0723399,-0.0000079,-0.108835,-0.011577,-0.000079,-0.000050,37,O +2018-07-07,58306,0.176281,0.425151,0.0723312,0.0000967,-0.109655,-0.011616,-0.000099,-0.000053,37,O +2018-07-08,58307,0.177822,0.425068,0.0722035,0.0001420,-0.110479,-0.011678,-0.000133,-0.000050,37,O +2018-07-09,58308,0.178757,0.424807,0.0720414,0.0001328,-0.110916,-0.011640,-0.000167,-0.000048,37,O +2018-07-10,58309,0.179172,0.423852,0.0718882,0.0001034,-0.111095,-0.011552,-0.000201,-0.000046,37,O +2018-07-11,58310,0.180186,0.422669,0.0717859,0.0000650,-0.111169,-0.011551,-0.000175,-0.000011,37,O +2018-07-12,58311,0.181301,0.421677,0.0717594,-0.0000210,-0.111232,-0.011673,-0.000131,0.000031,37,O +2018-07-13,58312,0.182418,0.420426,0.0717762,-0.0000531,-0.111089,-0.011729,-0.000088,0.000074,37,O +2018-07-14,58313,0.184079,0.419376,0.0717853,0.0000123,-0.110824,-0.011636,-0.000100,0.000092,37,O +2018-07-15,58314,0.185564,0.418707,0.0716902,0.0001510,-0.110592,-0.011514,-0.000133,0.000100,37,O +2018-07-16,58315,0.186391,0.418469,0.0714208,0.0003376,-0.110625,-0.011504,-0.000166,0.000109,37,O +2018-07-17,58316,0.187240,0.418109,0.0709820,0.0004982,-0.111029,-0.011546,-0.000199,0.000117,37,O +2018-07-18,58317,0.188227,0.417540,0.0704302,0.0005515,-0.111574,-0.011522,-0.000202,0.000108,37,O +2018-07-19,58318,0.189238,0.416763,0.0698823,0.0005042,-0.111963,-0.011456,-0.000197,0.000095,37,O +2018-07-20,58319,0.190448,0.415788,0.0694402,0.0003588,-0.111977,-0.011489,-0.000193,0.000081,37,O +2018-07-21,58320,0.191637,0.414675,0.0691558,0.0001953,-0.111740,-0.011633,-0.000179,0.000083,37,O +2018-07-22,58321,0.192614,0.413612,0.0690418,0.0000312,-0.111664,-0.011771,-0.000161,0.000092,37,O +2018-07-23,58322,0.193731,0.412738,0.0690641,-0.0000813,-0.111937,-0.011814,-0.000144,0.000100,37,O +2018-07-24,58323,0.194740,0.412257,0.0691774,-0.0001218,-0.112339,-0.011812,-0.000126,0.000109,37,O +2018-07-25,58324,0.195441,0.411953,0.0693378,-0.0001512,-0.112609,-0.011885,-0.000129,0.000096,37,O +2018-07-26,58325,0.195783,0.411402,0.0695047,-0.0001754,-0.112615,-0.011996,-0.000136,0.000077,37,O +2018-07-27,58326,0.196299,0.410511,0.0696524,-0.0001537,-0.112497,-0.012012,-0.000144,0.000059,37,O +2018-07-28,58327,0.196883,0.409820,0.0698066,-0.0001301,-0.112396,-0.011850,-0.000130,0.000069,37,O +2018-07-29,58328,0.197516,0.408770,0.0699385,-0.0000860,-0.112434,-0.011631,-0.000107,0.000090,37,O +2018-07-30,58329,0.198295,0.407726,0.0699910,-0.0000152,-0.112591,-0.011506,-0.000085,0.000111,37,O +2018-07-31,58330,0.198408,0.406559,0.0699410,0.0000754,-0.112726,-0.011486,-0.000062,0.000132,37,O +2018-08-01,58331,0.198567,0.405230,0.0697827,0.0001948,-0.112807,-0.011528,-0.000067,0.000088,37,O +2018-08-02,58332,0.198928,0.404282,0.0695405,0.0002858,-0.112854,-0.011525,-0.000079,0.000027,37,O +2018-08-03,58333,0.199383,0.403118,0.0692490,0.0003289,-0.113074,-0.011526,-0.000092,-0.000035,37,O +2018-08-04,58334,0.199965,0.402113,0.0689270,0.0003065,-0.113664,-0.011573,-0.000140,-0.000048,37,O +2018-08-05,58335,0.200232,0.401033,0.0686353,0.0002713,-0.114375,-0.011676,-0.000202,-0.000043,37,O +2018-08-06,58336,0.200431,0.399820,0.0684321,0.0001688,-0.114886,-0.011752,-0.000264,-0.000038,37,O +2018-08-07,58337,0.200636,0.398585,0.0683256,0.0000637,-0.115151,-0.011782,-0.000326,-0.000033,37,O +2018-08-08,58338,0.200792,0.397380,0.0683069,-0.0000044,-0.115063,-0.011817,-0.000282,-0.000002,37,O +2018-08-09,58339,0.200735,0.396172,0.0682933,0.0000438,-0.114887,-0.011877,-0.000212,0.000035,37,O +2018-08-10,58340,0.201186,0.394671,0.0682018,0.0001696,-0.114610,-0.011835,-0.000141,0.000073,37,O +2018-08-11,58341,0.202013,0.393049,0.0679453,0.0003397,-0.114410,-0.011678,-0.000147,0.000079,37,O +2018-08-12,58342,0.203168,0.391474,0.0675175,0.0005155,-0.114284,-0.011549,-0.000183,0.000072,37,O +2018-08-13,58343,0.203873,0.390131,0.0669514,0.0005994,-0.114302,-0.011578,-0.000218,0.000066,37,O +2018-08-14,58344,0.204204,0.388855,0.0663162,0.0006048,-0.114586,-0.011655,-0.000253,0.000060,37,O +2018-08-15,58345,0.204222,0.387607,0.0657262,0.0005749,-0.114956,-0.011521,-0.000215,0.000109,37,O +2018-08-16,58346,0.204491,0.386161,0.0651953,0.0004866,-0.115309,-0.011245,-0.000159,0.000172,37,O +2018-08-17,58347,0.204697,0.384858,0.0647660,0.0003637,-0.115342,-0.011091,-0.000102,0.000235,37,O +2018-08-18,58348,0.205208,0.383290,0.0644980,0.0001888,-0.115051,-0.011246,-0.000066,0.000260,37,O +2018-08-19,58349,0.205710,0.381891,0.0644053,0.0000218,-0.114731,-0.011556,-0.000038,0.000271,37,O +2018-08-20,58350,0.206205,0.380975,0.0644261,-0.0000671,-0.114753,-0.011851,-0.000041,0.000210,37,O +2018-08-21,58351,0.207158,0.380236,0.0645243,-0.0001217,-0.115001,-0.011988,-0.000050,0.000134,37,O +2018-08-22,58352,0.207972,0.379551,0.0646862,-0.0001424,-0.115119,-0.011941,-0.000031,0.000151,37,O +2018-08-23,58353,0.208582,0.378510,0.0648586,-0.0001537,-0.115036,-0.011869,-0.000005,0.000192,37,O +2018-08-24,58354,0.209114,0.377213,0.0650048,-0.0001779,-0.114862,-0.011775,0.000021,0.000233,37,O +2018-08-25,58355,0.209678,0.376017,0.0651013,-0.0001032,-0.114840,-0.011624,-0.000004,0.000245,37,O +2018-08-26,58356,0.210426,0.375049,0.0651186,0.0000334,-0.114911,-0.011417,-0.000048,0.000246,37,O +2018-08-27,58357,0.210969,0.373850,0.0650147,0.0001808,-0.115013,-0.011241,-0.000092,0.000247,37,O +2018-08-28,58358,0.211157,0.372845,0.0647918,0.0003014,-0.115154,-0.011165,-0.000136,0.000248,37,O +2018-08-29,58359,0.211142,0.371729,0.0644813,0.0003395,-0.115158,-0.011192,-0.000113,0.000225,37,O +2018-08-30,58360,0.211548,0.370511,0.0641044,0.0003904,-0.115104,-0.011237,-0.000072,0.000197,37,O +2018-08-31,58361,0.211819,0.369442,0.0636996,0.0004154,-0.115048,-0.011271,-0.000031,0.000168,37,O +2018-09-01,58362,0.211659,0.367906,0.0633163,0.0003848,-0.115212,-0.011252,-0.000041,0.000201,37,O +2018-09-02,58363,0.211577,0.366188,0.0629941,0.0002587,-0.115558,-0.011242,-0.000070,0.000258,37,O +2018-09-03,58364,0.211673,0.364479,0.0627594,0.0001541,-0.115889,-0.011298,-0.000081,0.000279,37,O +2018-09-04,58365,0.211634,0.363167,0.0626152,0.0001077,-0.115981,-0.011460,-0.000051,0.000218,37,O +2018-09-05,58366,0.211640,0.361805,0.0625141,0.0001020,-0.115903,-0.011572,-0.000039,0.000212,37,O +2018-09-06,58367,0.212048,0.360904,0.0623951,0.0001653,-0.115668,-0.011593,-0.000031,0.000219,37,O +2018-09-07,58368,0.212541,0.360446,0.0621697,0.0002882,-0.115388,-0.011427,-0.000024,0.000226,37,O +2018-09-08,58369,0.212705,0.359876,0.0617750,0.0004833,-0.115259,-0.011075,-0.000048,0.000261,37,O +2018-09-09,58370,0.212593,0.359172,0.0611591,0.0007147,-0.115270,-0.010769,-0.000084,0.000304,37,O +2018-09-10,58371,0.212953,0.358347,0.0603230,0.0009400,-0.115353,-0.010695,-0.000121,0.000348,37,O +2018-09-11,58372,0.213677,0.357568,0.0593573,0.0009847,-0.115504,-0.010766,-0.000157,0.000392,37,O +2018-09-12,58373,0.214091,0.356765,0.0583947,0.0009403,-0.115659,-0.010841,-0.000142,0.000337,37,O +2018-09-13,58374,0.213972,0.355925,0.0575376,0.0007586,-0.115871,-0.010778,-0.000113,0.000256,37,O +2018-09-14,58375,0.213400,0.355115,0.0568606,0.0005625,-0.115963,-0.010750,-0.000085,0.000175,37,O +2018-09-15,58376,0.212829,0.354057,0.0563961,0.0003670,-0.115819,-0.010862,-0.000074,0.000192,37,O +2018-09-16,58377,0.212199,0.352900,0.0561269,0.0002203,-0.115521,-0.011132,-0.000070,0.000246,37,O +2018-09-17,58378,0.211977,0.351630,0.0559831,0.0001201,-0.115281,-0.011362,-0.000066,0.000299,37,O +2018-09-18,58379,0.212054,0.350327,0.0559101,0.0000571,-0.115173,-0.011383,-0.000062,0.000353,37,O +2018-09-19,58380,0.212096,0.348780,0.0558825,0.0000390,-0.115026,-0.011305,-0.000028,0.000336,37,O +2018-09-20,58381,0.211925,0.347173,0.0558190,0.0000949,-0.114832,-0.011227,0.000014,0.000301,37,O +2018-09-21,58382,0.211828,0.345665,0.0556640,0.0002158,-0.114642,-0.011206,0.000056,0.000266,37,O +2018-09-22,58383,0.211821,0.344294,0.0553655,0.0003614,-0.114528,-0.011157,0.000075,0.000258,37,O +2018-09-23,58384,0.211590,0.342637,0.0549109,0.0005122,-0.114398,-0.011009,0.000084,0.000259,37,O +2018-09-24,58385,0.211872,0.340887,0.0543066,0.0006748,-0.114212,-0.010770,0.000094,0.000260,37,O +2018-09-25,58386,0.211960,0.339315,0.0535719,0.0008149,-0.114070,-0.010538,0.000104,0.000262,37,O +2018-09-26,58387,0.211289,0.337662,0.0527362,0.0008751,-0.114061,-0.010426,0.000113,0.000263,37,O +2018-09-27,58388,0.210522,0.336045,0.0518376,0.0009016,-0.114124,-0.010456,0.000122,0.000269,37,O +2018-09-28,58389,0.210397,0.334750,0.0509139,0.0009203,-0.114142,-0.010561,0.000130,0.000277,37,O +2018-09-29,58390,0.210482,0.333693,0.0500141,0.0008681,-0.114131,-0.010642,0.000130,0.000283,37,O +2018-09-30,58391,0.210513,0.332262,0.0491808,0.0007725,-0.114200,-0.010654,0.000126,0.000288,37,O +2018-10-01,58392,0.210528,0.330843,0.0484320,0.0006964,-0.114384,-0.010632,0.000122,0.000293,37,O +2018-10-02,58393,0.210618,0.329823,0.0477521,0.0006496,-0.114535,-0.010640,0.000118,0.000298,37,O +2018-10-03,58394,0.210355,0.328630,0.0470980,0.0006627,-0.114384,-0.010670,0.000140,0.000306,37,O +2018-10-04,58395,0.209699,0.327678,0.0463869,0.0007689,-0.113941,-0.010622,0.000169,0.000315,37,O +2018-10-05,58396,0.208569,0.326669,0.0455337,0.0009519,-0.113415,-0.010396,0.000199,0.000324,37,O +2018-10-06,58397,0.207798,0.325015,0.0444666,0.0011845,-0.113146,-0.010033,0.000196,0.000328,37,O +2018-10-07,58398,0.207422,0.323667,0.0431936,0.0013610,-0.113165,-0.009728,0.000181,0.000331,37,O +2018-10-08,58399,0.207032,0.322683,0.0417907,0.0014287,-0.113316,-0.009660,0.000166,0.000334,37,O +2018-10-09,58400,0.206379,0.321901,0.0403497,0.0013973,-0.113435,-0.009800,0.000151,0.000337,37,O +2018-10-10,58401,0.205780,0.321116,0.0389687,0.0012980,-0.113342,-0.009956,0.000190,0.000331,37,O +2018-10-11,58402,0.204962,0.320079,0.0377295,0.0011636,-0.113190,-0.009988,0.000243,0.000322,37,O +2018-10-12,58403,0.204071,0.318663,0.0366742,0.0009740,-0.113013,-0.009959,0.000297,0.000314,37,O +2018-10-13,58404,0.203072,0.316938,0.0357993,0.0007920,-0.112928,-0.010013,0.000280,0.000317,37,O +2018-10-14,58405,0.202237,0.315398,0.0350913,0.0006451,-0.112779,-0.010185,0.000236,0.000325,37,O +2018-10-15,58406,0.201709,0.314253,0.0345237,0.0005261,-0.112544,-0.010341,0.000193,0.000333,37,O +2018-10-16,58407,0.201587,0.313377,0.0340535,0.0004738,-0.112317,-0.010337,0.000149,0.000341,37,O +2018-10-17,58408,0.201061,0.312464,0.0336228,0.0004420,-0.112039,-0.010202,0.000155,0.000331,37,O +2018-10-18,58409,0.200195,0.311053,0.0331706,0.0004956,-0.111833,-0.010062,0.000173,0.000316,37,O +2018-10-19,58410,0.199086,0.309868,0.0326354,0.0005882,-0.111706,-0.010019,0.000192,0.000301,37,O +2018-10-20,58411,0.197901,0.308640,0.0319874,0.0007321,-0.111575,-0.010024,0.000222,0.000291,37,O +2018-10-21,58412,0.196795,0.307520,0.0311912,0.0008843,-0.111395,-0.009938,0.000258,0.000283,37,O +2018-10-22,58413,0.195484,0.306314,0.0302229,0.0010232,-0.111185,-0.009679,0.000294,0.000275,37,O +2018-10-23,58414,0.194680,0.304994,0.0290990,0.0011954,-0.111023,-0.009326,0.000329,0.000266,37,O +2018-10-24,58415,0.193785,0.304246,0.0278631,0.0012869,-0.111120,-0.009062,0.000300,0.000269,37,O +2018-10-25,58416,0.193195,0.303702,0.0265748,0.0012844,-0.111310,-0.009042,0.000254,0.000274,37,O +2018-10-26,58417,0.192548,0.303242,0.0253051,0.0011730,-0.111452,-0.009233,0.000207,0.000280,37,O +2018-10-27,58418,0.192071,0.302535,0.0241148,0.0011236,-0.111404,-0.009467,0.000203,0.000271,37,O +2018-10-28,58419,0.191657,0.302139,0.0230447,0.0010507,-0.111307,-0.009558,0.000215,0.000257,37,O +2018-10-29,58420,0.190191,0.301362,0.0220904,0.0009204,-0.111267,-0.009473,0.000227,0.000243,37,O +2018-10-30,58421,0.188153,0.300142,0.0212105,0.0008419,-0.111241,-0.009323,0.000239,0.000229,37,O +2018-10-31,58422,0.186298,0.298764,0.0203477,0.0008863,-0.111079,-0.009184,0.000258,0.000247,37,O +2018-11-01,58423,0.184510,0.297031,0.0194049,0.0010019,-0.110693,-0.009112,0.000290,0.000242,37,O +2018-11-02,58424,0.183144,0.295254,0.0183388,0.0011360,-0.110199,-0.009018,0.000327,0.000224,37,O +2018-11-03,58425,0.182231,0.293548,0.0171490,0.0012288,-0.109827,-0.008864,0.000364,0.000207,37,O +2018-11-04,58426,0.181200,0.292497,0.0159215,0.0012681,-0.109772,-0.008734,0.000385,0.000187,37,O +2018-11-05,58427,0.180114,0.291721,0.0146529,0.0012425,-0.110054,-0.008737,0.000363,0.000160,37,O +2018-11-06,58428,0.179336,0.291078,0.0134069,0.0012003,-0.110353,-0.008870,0.000341,0.000134,37,O +2018-11-07,58429,0.178247,0.290503,0.0122412,0.0011079,-0.110181,-0.008972,0.000436,0.000167,37,O +2018-11-08,58430,0.177661,0.289421,0.0111876,0.0009951,-0.109729,-0.008991,0.000563,0.000216,37,O +2018-11-09,58431,0.177501,0.288243,0.0102529,0.0008568,-0.109862,-0.008964,0.000426,0.000249,37,O +2018-11-10,58432,0.176916,0.286977,0.0094525,0.0007531,-0.109852,-0.008970,0.000350,0.000252,37,O +2018-11-11,58433,0.175896,0.285895,0.0087502,0.0006728,-0.109685,-0.009013,0.000328,0.000246,37,O +2018-11-12,58434,0.174771,0.284813,0.0080933,0.0006445,-0.109428,-0.009025,0.000307,0.000240,37,O +2018-11-13,58435,0.173670,0.283804,0.0074412,0.0006762,-0.109130,-0.008942,0.000285,0.000233,37,O +2018-11-14,58436,0.172446,0.282819,0.0067457,0.0007411,-0.108889,-0.008790,0.000277,0.000222,37,O +2018-11-15,58437,0.171170,0.281693,0.0059726,0.0008234,-0.108796,-0.008661,0.000273,0.000210,37,O +2018-11-16,58438,0.169491,0.280662,0.0050997,0.0008890,-0.108783,-0.008628,0.000269,0.000198,37,O +2018-11-17,58439,0.168053,0.279704,0.0041430,0.0010038,-0.108707,-0.008667,0.000282,0.000172,37,O +2018-11-18,58440,0.167032,0.279192,0.0030788,0.0011294,-0.108606,-0.008650,0.000301,0.000141,37,O +2018-11-19,58441,0.166027,0.278644,0.0018622,0.0012732,-0.108575,-0.008472,0.000321,0.000110,37,O +2018-11-20,58442,0.164954,0.278351,0.0005233,0.0013792,-0.108627,-0.008155,0.000341,0.000079,37,O +2018-11-21,58443,0.163866,0.278087,-0.0008724,0.0014208,-0.108896,-0.007790,0.000273,0.000112,37,O +2018-11-22,58444,0.162902,0.277650,-0.0022440,0.0013873,-0.108645,-0.007534,0.000380,0.000242,37,O +2018-11-23,58445,0.161893,0.277324,-0.0035499,0.0012594,-0.108127,-0.007523,0.000565,0.000403,37,O +2018-11-24,58446,0.160485,0.277286,-0.0047834,0.0011370,-0.108139,-0.007835,0.000521,0.000378,37,O +2018-11-25,58447,0.159235,0.277088,-0.0058934,0.0010245,-0.108218,-0.008066,0.000432,0.000316,37,O +2018-11-26,58448,0.158313,0.276843,-0.0068777,0.0009646,-0.108254,-0.008030,0.000342,0.000253,37,O +2018-11-27,58449,0.156839,0.276929,-0.0078373,0.0009866,-0.108287,-0.007813,0.000252,0.000190,37,O +2018-11-28,58450,0.154662,0.276653,-0.0088268,0.0010576,-0.108102,-0.007613,0.000263,0.000148,37,O +2018-11-29,58451,0.152413,0.276054,-0.0099233,0.0011645,-0.107874,-0.007574,0.000300,0.000111,37,O +2018-11-30,58452,0.150563,0.275167,-0.0111364,0.0012871,-0.107639,-0.007659,0.000337,0.000074,37,O +2018-12-01,58453,0.148511,0.274295,-0.0124404,0.0013301,-0.107499,-0.007704,0.000348,0.000100,37,O +2018-12-02,58454,0.146188,0.273492,-0.0137573,0.0012950,-0.107519,-0.007714,0.000349,0.000148,37,O +2018-12-03,58455,0.143733,0.272864,-0.0150086,0.0012135,-0.107735,-0.007723,0.000350,0.000197,37,O +2018-12-04,58456,0.141902,0.272288,-0.0161171,0.0010113,-0.108055,-0.007732,0.000351,0.000246,37,O +2018-12-05,58457,0.139736,0.272071,-0.0170051,0.0007823,-0.108315,-0.007786,0.000330,0.000223,37,O +2018-12-06,58458,0.137181,0.271827,-0.0176993,0.0006074,-0.108339,-0.007827,0.000303,0.000182,37,O +2018-12-07,58459,0.134745,0.271478,-0.0182430,0.0005137,-0.108180,-0.007871,0.000276,0.000140,37,O +2018-12-08,58460,0.132922,0.271000,-0.0187018,0.0004389,-0.107895,-0.007915,0.000290,0.000125,37,O +2018-12-09,58461,0.131771,0.270813,-0.0191110,0.0003767,-0.107611,-0.007946,0.000318,0.000120,37,O +2018-12-10,58462,0.130336,0.271024,-0.0194946,0.0003776,-0.107316,-0.007910,0.000346,0.000116,37,O +2018-12-11,58463,0.128667,0.271114,-0.0198879,0.0004417,-0.107023,-0.007800,0.000375,0.000111,37,O +2018-12-12,58464,0.126861,0.271006,-0.0203412,0.0004915,-0.106924,-0.007688,0.000372,0.000100,37,O +2018-12-13,58465,0.124815,0.270460,-0.0208707,0.0005611,-0.106989,-0.007642,0.000363,0.000088,37,O +2018-12-14,58466,0.123182,0.270033,-0.0214888,0.0006532,-0.107077,-0.007675,0.000353,0.000076,37,O +2018-12-15,58467,0.121105,0.269581,-0.0221963,0.0007461,-0.107038,-0.007730,0.000350,0.000071,37,O +2018-12-16,58468,0.119215,0.268992,-0.0230150,0.0008557,-0.106962,-0.007747,0.000349,0.000068,37,O +2018-12-17,58469,0.117513,0.268466,-0.0239543,0.0009899,-0.107029,-0.007681,0.000348,0.000065,37,O +2018-12-18,58470,0.115378,0.268031,-0.0249722,0.0010471,-0.107229,-0.007498,0.000347,0.000063,37,O +2018-12-19,58471,0.113310,0.267412,-0.0259807,0.0009827,-0.107331,-0.007241,0.000361,0.000033,37,O +2018-12-20,58472,0.111645,0.267029,-0.0268884,0.0008161,-0.107290,-0.007010,0.000380,-0.000003,37,O +2018-12-21,58473,0.109928,0.266784,-0.0276359,0.0006370,-0.107265,-0.006989,0.000398,-0.000040,37,O +2018-12-22,58474,0.107844,0.266547,-0.0282166,0.0005040,-0.107383,-0.007193,0.000389,-0.000035,37,O +2018-12-23,58475,0.105771,0.266523,-0.0286836,0.0004507,-0.107406,-0.007440,0.000371,-0.000015,37,O +2018-12-24,58476,0.103568,0.266619,-0.0291417,0.0004771,-0.107129,-0.007457,0.000352,0.000006,37,O +2018-12-25,58477,0.101399,0.266731,-0.0296751,0.0005616,-0.106658,-0.007202,0.000333,0.000026,37,O +2018-12-26,58478,0.099191,0.267291,-0.0302990,0.0007122,-0.106280,-0.006907,0.000314,0.000047,37,O +2018-12-27,58479,0.097243,0.268068,-0.0310764,0.0008673,-0.106154,-0.006789,0.000295,0.000067,37,O +2018-12-28,58480,0.095386,0.268935,-0.0320059,0.0010205,-0.106161,-0.006924,0.000303,-0.000007,37,O +2018-12-29,58481,0.093289,0.269801,-0.0330198,0.0011069,-0.106156,-0.007114,0.000345,-0.000102,37,O +2018-12-30,58482,0.090829,0.270475,-0.0340678,0.0010617,-0.106159,-0.007262,0.000388,-0.000173,37,O +2018-12-31,58483,0.088414,0.270763,-0.0351611,0.0009706,-0.106322,-0.007311,0.000383,-0.000138,37,O +2019-01-01,58484,0.086360,0.271107,-0.0361345,0.0009196,-0.106561,-0.007355,0.000379,-0.000102,37,O +2019-01-02,58485,0.084450,0.272019,-0.0370076,0.0008103,-0.106814,-0.007352,0.000374,-0.000066,37,O +2019-01-03,58486,0.081750,0.272569,-0.0377478,0.0006117,-0.106924,-0.007309,0.000370,-0.000030,37,O +2019-01-04,58487,0.079016,0.272577,-0.0382792,0.0004701,-0.106742,-0.007378,0.000395,-0.000077,37,O +2019-01-05,58488,0.076411,0.272536,-0.0387496,0.0004125,-0.106503,-0.007496,0.000387,-0.000101,37,O +2019-01-06,58489,0.074159,0.272895,-0.0391547,0.0003598,-0.106286,-0.007600,0.000366,-0.000108,37,O +2019-01-07,58490,0.072162,0.273364,-0.0394760,0.0003132,-0.106129,-0.007608,0.000344,-0.000116,37,O +2019-01-08,58491,0.071062,0.273800,-0.0397729,0.0003272,-0.106065,-0.007513,0.000323,-0.000124,37,O +2019-01-09,58492,0.070637,0.274756,-0.0401419,0.0004111,-0.106021,-0.007429,0.000351,-0.000133,37,O +2019-01-10,58493,0.069750,0.275757,-0.0405867,0.0004624,-0.106065,-0.007451,0.000393,-0.000143,37,O +2019-01-11,58494,0.068810,0.276031,-0.0410933,0.0005626,-0.106089,-0.007555,0.000434,-0.000152,37,O +2019-01-12,58495,0.068327,0.276958,-0.0417183,0.0006858,-0.106072,-0.007644,0.000431,-0.000146,37,O +2019-01-13,58496,0.067619,0.278392,-0.0424490,0.0007617,-0.106040,-0.007694,0.000405,-0.000131,37,O +2019-01-14,58497,0.067041,0.280037,-0.0432643,0.0008473,-0.106126,-0.007738,0.000380,-0.000117,37,O +2019-01-15,58498,0.066278,0.281989,-0.0441419,0.0008947,-0.106336,-0.007740,0.000354,-0.000102,37,O +2019-01-16,58499,0.065560,0.283745,-0.0450371,0.0008947,-0.106506,-0.007597,0.000317,-0.000097,37,O +2019-01-17,58500,0.064413,0.285541,-0.0459084,0.0008434,-0.106619,-0.007284,0.000277,-0.000094,37,O +2019-01-18,58501,0.063021,0.286806,-0.0467215,0.0007935,-0.106964,-0.007028,0.000237,-0.000091,37,O +2019-01-19,58502,0.061886,0.287736,-0.0474810,0.0007474,-0.107547,-0.007123,0.000231,-0.000104,37,O +2019-01-20,58503,0.060924,0.288663,-0.0482192,0.0007625,-0.107969,-0.007519,0.000237,-0.000122,37,O +2019-01-21,58504,0.059951,0.289646,-0.0490001,0.0008539,-0.107732,-0.007846,0.000244,-0.000141,37,O +2019-01-22,58505,0.059500,0.290588,-0.0499002,0.0009738,-0.106895,-0.007846,0.000250,-0.000160,37,O +2019-01-23,58506,0.059020,0.291974,-0.0509753,0.0011441,-0.106010,-0.007644,0.000257,-0.000178,37,O +2019-01-24,58507,0.058404,0.293938,-0.0522360,0.0013438,-0.105628,-0.007477,0.000228,-0.000173,37,O +2019-01-25,58508,0.057037,0.295895,-0.0536317,0.0014479,-0.105742,-0.007399,0.000189,-0.000160,37,O +2019-01-26,58509,0.055392,0.297230,-0.0550842,0.0014242,-0.105974,-0.007320,0.000207,-0.000156,37,O +2019-01-27,58510,0.054208,0.298636,-0.0565001,0.0013738,-0.106164,-0.007238,0.000246,-0.000154,37,O +2019-01-28,58511,0.053443,0.300145,-0.0577925,0.0012435,-0.106239,-0.007275,0.000284,-0.000153,37,O +2019-01-29,58512,0.052614,0.301578,-0.0589106,0.0010153,-0.106259,-0.007456,0.000323,-0.000151,37,O +2019-01-30,58513,0.051577,0.302934,-0.0598406,0.0008170,-0.106486,-0.007654,0.000306,-0.000143,37,O +2019-01-31,58514,0.050593,0.304306,-0.0605800,0.0006817,-0.106774,-0.007773,0.000273,-0.000132,37,O +2019-02-01,58515,0.049834,0.306171,-0.0611621,0.0005584,-0.106884,-0.007845,0.000241,-0.000122,37,O +2019-02-02,58516,0.049056,0.308504,-0.0616373,0.0004658,-0.106616,-0.007971,0.000251,-0.000143,37,O +2019-02-03,58517,0.047559,0.310550,-0.0620986,0.0005001,-0.106158,-0.008105,0.000278,-0.000177,37,O +2019-02-04,58518,0.045944,0.311689,-0.0626460,0.0005894,-0.105763,-0.008131,0.000305,-0.000211,37,O +2019-02-05,58519,0.044745,0.312776,-0.0633149,0.0007100,-0.105553,-0.008029,0.000332,-0.000244,37,O +2019-02-06,58520,0.043838,0.313876,-0.0640945,0.0008363,-0.105635,-0.007889,0.000317,-0.000240,37,O +2019-02-07,58521,0.043000,0.314914,-0.0649870,0.0009471,-0.105853,-0.007869,0.000291,-0.000225,37,O +2019-02-08,58522,0.042225,0.316266,-0.0659817,0.0010463,-0.106061,-0.007974,0.000265,-0.000210,37,O +2019-02-09,58523,0.041812,0.318184,-0.0670693,0.0011151,-0.106088,-0.008089,0.000270,-0.000186,37,O +2019-02-10,58524,0.041158,0.320405,-0.0682263,0.0011816,-0.106008,-0.008171,0.000287,-0.000159,37,O +2019-02-11,58525,0.040091,0.322109,-0.0694157,0.0011896,-0.105961,-0.008266,0.000305,-0.000132,37,O +2019-02-12,58526,0.038728,0.323345,-0.0706131,0.0011548,-0.105965,-0.008382,0.000322,-0.000106,37,O +2019-02-13,58527,0.037643,0.323847,-0.0717962,0.0011475,-0.105944,-0.008457,0.000319,-0.000138,37,O +2019-02-14,58528,0.036400,0.324163,-0.0729229,0.0010705,-0.105889,-0.008343,0.000312,-0.000186,37,O +2019-02-15,58529,0.035202,0.324437,-0.0739690,0.0010196,-0.106118,-0.008168,0.000304,-0.000234,37,O +2019-02-16,58530,0.034898,0.325551,-0.0749476,0.0009527,-0.106932,-0.008213,0.000243,-0.000240,37,O +2019-02-17,58531,0.035382,0.326979,-0.0759113,0.0009808,-0.107770,-0.008611,0.000178,-0.000234,37,O +2019-02-18,58532,0.036402,0.328814,-0.0769283,0.0010855,-0.107720,-0.009090,0.000203,-0.000244,37,O +2019-02-19,58533,0.037158,0.330699,-0.0781012,0.0012574,-0.106883,-0.009282,0.000228,-0.000254,37,O +2019-02-20,58534,0.037516,0.332551,-0.0794595,0.0014033,-0.105824,-0.009182,0.000252,-0.000264,37,O +2019-02-21,58535,0.037409,0.334157,-0.0809464,0.0015192,-0.105225,-0.008980,0.000250,-0.000223,37,O +2019-02-22,58536,0.036823,0.335959,-0.0824905,0.0015702,-0.105220,-0.008808,0.000240,-0.000168,37,O +2019-02-23,58537,0.035746,0.337468,-0.0840100,0.0014712,-0.105540,-0.008638,0.000248,-0.000155,37,O +2019-02-24,58538,0.035260,0.338447,-0.0853945,0.0012778,-0.105880,-0.008464,0.000263,-0.000159,37,O +2019-02-25,58539,0.035478,0.339220,-0.0865600,0.0010413,-0.106026,-0.008457,0.000278,-0.000164,37,O +2019-02-26,58540,0.035848,0.340191,-0.0874895,0.0008125,-0.106016,-0.008713,0.000293,-0.000168,37,O +2019-02-27,58541,0.036335,0.341340,-0.0882138,0.0006230,-0.106093,-0.009088,0.000297,-0.000171,37,O +2019-02-28,58542,0.037308,0.342419,-0.0887866,0.0005456,-0.106299,-0.009364,0.000299,-0.000174,37,O +2019-03-01,58543,0.038585,0.344058,-0.0892695,0.0004493,-0.106391,-0.009471,0.000301,-0.000177,37,O +2019-03-02,58544,0.040115,0.345746,-0.0897285,0.0004525,-0.106128,-0.009492,0.000303,-0.000185,37,O +2019-03-03,58545,0.041705,0.347321,-0.0902115,0.0005032,-0.105583,-0.009477,0.000306,-0.000194,37,O +2019-03-04,58546,0.043027,0.348978,-0.0907359,0.0005849,-0.105071,-0.009389,0.000309,-0.000204,37,O +2019-03-05,58547,0.043941,0.350881,-0.0913366,0.0006457,-0.104818,-0.009201,0.000312,-0.000214,37,O +2019-03-06,58548,0.044629,0.352612,-0.0920497,0.0007774,-0.104870,-0.008995,0.000290,-0.000221,37,O +2019-03-07,58549,0.045490,0.354228,-0.0928815,0.0009090,-0.105051,-0.008917,0.000261,-0.000228,37,O +2019-03-08,58550,0.045755,0.355899,-0.0938209,0.0009788,-0.105246,-0.009012,0.000232,-0.000236,37,O +2019-03-09,58551,0.045492,0.356807,-0.0948250,0.0010281,-0.105343,-0.009197,0.000229,-0.000240,37,O +2019-03-10,58552,0.045250,0.357817,-0.0958689,0.0010329,-0.105364,-0.009385,0.000235,-0.000244,37,O +2019-03-11,58553,0.045393,0.359065,-0.0969307,0.0010556,-0.105349,-0.009556,0.000241,-0.000248,37,O +2019-03-12,58554,0.045392,0.360610,-0.0979533,0.0009685,-0.105325,-0.009723,0.000248,-0.000252,37,O +2019-03-13,58555,0.044941,0.361834,-0.0988761,0.0008698,-0.105290,-0.009830,0.000251,-0.000239,37,O +2019-03-14,58556,0.044600,0.363157,-0.0997021,0.0007680,-0.105217,-0.009832,0.000254,-0.000222,37,O +2019-03-15,58557,0.044689,0.364244,-0.1004688,0.0007574,-0.105205,-0.009780,0.000257,-0.000204,37,O +2019-03-16,58558,0.044882,0.365639,-0.1012581,0.0008150,-0.105404,-0.009859,0.000243,-0.000205,37,O +2019-03-17,58559,0.045118,0.366716,-0.1021314,0.0009185,-0.105652,-0.010133,0.000223,-0.000214,37,O +2019-03-18,58560,0.045569,0.367665,-0.1031393,0.0011095,-0.105622,-0.010438,0.000203,-0.000223,37,O +2019-03-19,58561,0.045849,0.368711,-0.1043490,0.0013120,-0.105212,-0.010557,0.000184,-0.000232,37,O +2019-03-20,58562,0.045602,0.369656,-0.1057537,0.0015004,-0.104517,-0.010457,0.000243,-0.000206,37,O +2019-03-21,58563,0.045363,0.370584,-0.1073331,0.0016399,-0.104038,-0.010349,0.000324,-0.000171,37,O +2019-03-22,58564,0.045163,0.371781,-0.1090042,0.0016718,-0.104348,-0.010440,0.000239,-0.000265,37,O +2019-03-23,58565,0.045059,0.373068,-0.1106258,0.0015653,-0.104760,-0.010388,0.000200,-0.000254,37,O +2019-03-24,58566,0.045366,0.374421,-0.1121099,0.0013668,-0.105049,-0.010200,0.000199,-0.000189,37,O +2019-03-25,58567,0.045815,0.375834,-0.1133803,0.0011510,-0.105152,-0.010085,0.000197,-0.000124,37,O +2019-03-26,58568,0.045966,0.377276,-0.1144432,0.0009612,-0.105112,-0.010200,0.000196,-0.000059,37,O +2019-03-27,58569,0.045903,0.378402,-0.1153100,0.0008170,-0.105153,-0.010559,0.000188,-0.000077,37,O +2019-03-28,58570,0.046141,0.379230,-0.1160950,0.0007469,-0.105345,-0.010875,0.000177,-0.000116,37,O +2019-03-29,58571,0.046500,0.380235,-0.1168183,0.0006843,-0.105462,-0.010986,0.000166,-0.000155,37,O +2019-03-30,58572,0.047100,0.381203,-0.1175404,0.0007409,-0.105210,-0.010921,0.000160,-0.000179,37,O +2019-03-31,58573,0.047984,0.382645,-0.1183133,0.0008329,-0.104636,-0.010800,0.000155,-0.000197,37,O +2019-04-01,58574,0.048795,0.384044,-0.1191791,0.0009226,-0.104085,-0.010668,0.000149,-0.000216,37,O +2019-04-02,58575,0.049786,0.385278,-0.1201631,0.0010292,-0.103838,-0.010494,0.000144,-0.000234,37,O +2019-04-03,58576,0.050547,0.386499,-0.1212445,0.0011882,-0.103870,-0.010265,0.000148,-0.000224,37,O +2019-04-04,58577,0.051078,0.387917,-0.1224765,0.0012751,-0.104020,-0.010099,0.000154,-0.000207,37,O +2019-04-05,58578,0.051313,0.389067,-0.1237650,0.0012629,-0.104171,-0.010098,0.000159,-0.000190,37,O +2019-04-06,58579,0.051595,0.390130,-0.1250294,0.0012887,-0.104305,-0.010279,0.000156,-0.000186,37,O +2019-04-07,58580,0.051785,0.391337,-0.1263223,0.0012566,-0.104387,-0.010543,0.000149,-0.000186,37,O +2019-04-08,58581,0.051821,0.392345,-0.1275976,0.0012183,-0.104400,-0.010783,0.000142,-0.000186,37,O +2019-04-09,58582,0.052091,0.393318,-0.1287589,0.0011124,-0.104412,-0.010941,0.000135,-0.000187,37,O +2019-04-10,58583,0.052480,0.394328,-0.1297840,0.0009744,-0.104459,-0.010999,0.000149,-0.000165,37,O +2019-04-11,58584,0.053117,0.395119,-0.1307304,0.0008031,-0.104546,-0.011020,0.000167,-0.000138,37,O +2019-04-12,58585,0.053769,0.396173,-0.1314543,0.0007505,-0.104511,-0.011059,0.000186,-0.000111,37,O +2019-04-13,58586,0.054679,0.397319,-0.1322260,0.0008202,-0.104283,-0.011176,0.000184,-0.000124,37,O +2019-04-14,58587,0.055085,0.398276,-0.1330707,0.0009118,-0.103874,-0.011299,0.000174,-0.000153,37,O +2019-04-15,58588,0.055163,0.399057,-0.1340708,0.0010927,-0.103443,-0.011323,0.000165,-0.000182,37,O +2019-04-16,58589,0.055809,0.399974,-0.1352472,0.0012953,-0.103206,-0.011221,0.000155,-0.000211,37,O +2019-04-17,58590,0.056668,0.400687,-0.1365967,0.0014476,-0.103385,-0.011075,0.000103,-0.000210,37,O +2019-04-18,58591,0.057766,0.401049,-0.1380786,0.0014767,-0.103855,-0.011057,0.000039,-0.000202,37,O +2019-04-19,58592,0.058599,0.401935,-0.1394963,0.0013893,-0.104449,-0.011222,-0.000041,-0.000235,37,O +2019-04-20,58593,0.059160,0.402829,-0.1408141,0.0012170,-0.104959,-0.011386,-0.000126,-0.000284,37,O +2019-04-21,58594,0.060249,0.403665,-0.1419326,0.0010019,-0.105044,-0.011352,-0.000114,-0.000268,37,O +2019-04-22,58595,0.061350,0.404826,-0.1427672,0.0007530,-0.104854,-0.011231,-0.000053,-0.000221,37,O +2019-04-23,58596,0.062199,0.406269,-0.1433845,0.0005894,-0.104625,-0.011216,0.000009,-0.000173,37,O +2019-04-24,58597,0.062809,0.407465,-0.1440057,0.0005152,-0.104494,-0.011345,0.000070,-0.000125,37,O +2019-04-25,58598,0.063457,0.408277,-0.1444919,0.0004827,-0.104633,-0.011529,0.000067,-0.000122,37,O +2019-04-26,58599,0.064471,0.408795,-0.1449987,0.0005138,-0.104749,-0.011597,0.000047,-0.000130,37,O +2019-04-27,58600,0.065708,0.409250,-0.1455687,0.0005617,-0.104588,-0.011603,0.000030,-0.000204,37,O +2019-04-28,58601,0.067070,0.409477,-0.1461789,0.0006526,-0.104171,-0.011600,0.000014,-0.000304,37,O +2019-04-29,58602,0.068612,0.409997,-0.1468502,0.0007258,-0.103481,-0.011464,0.000113,-0.000247,37,O +2019-04-30,58603,0.070177,0.410662,-0.1476395,0.0008642,-0.103053,-0.011305,0.000221,-0.000176,37,O +2019-05-01,58604,0.072222,0.411351,-0.1485556,0.0010083,-0.103267,-0.011155,0.000203,-0.000173,37,O +2019-05-02,58605,0.074216,0.412141,-0.1496023,0.0010507,-0.103724,-0.010994,0.000152,-0.000188,37,O +2019-05-03,58606,0.075847,0.412864,-0.1506622,0.0010023,-0.104158,-0.010912,0.000100,-0.000202,37,O +2019-05-04,58607,0.076746,0.413367,-0.1516396,0.0009372,-0.104387,-0.010994,0.000080,-0.000205,37,O +2019-05-05,58608,0.077564,0.413858,-0.1525399,0.0008497,-0.104447,-0.011231,0.000071,-0.000202,37,O +2019-05-06,58609,0.078131,0.414792,-0.1533570,0.0007607,-0.104416,-0.011506,0.000063,-0.000199,37,O +2019-05-07,58610,0.078967,0.415625,-0.1540793,0.0006757,-0.104425,-0.011684,0.000054,-0.000197,37,O +2019-05-08,58611,0.080111,0.416276,-0.1547104,0.0005839,-0.104580,-0.011720,0.000046,-0.000194,37,O +2019-05-09,58612,0.081678,0.416736,-0.1552848,0.0005478,-0.104804,-0.011662,0.000054,-0.000173,37,O +2019-05-10,58613,0.083198,0.417395,-0.1558351,0.0005435,-0.104898,-0.011624,0.000067,-0.000148,37,O +2019-05-11,58614,0.084358,0.418035,-0.1564141,0.0006254,-0.104663,-0.011655,0.000073,-0.000143,37,O +2019-05-12,58615,0.085071,0.418630,-0.1571147,0.0007676,-0.104099,-0.011669,0.000075,-0.000145,37,O +2019-05-13,58616,0.085813,0.418754,-0.1579536,0.0009279,-0.103497,-0.011568,0.000078,-0.000148,37,O +2019-05-14,58617,0.086600,0.419108,-0.1589774,0.0011158,-0.103238,-0.011364,0.000081,-0.000151,37,O +2019-05-15,58618,0.087514,0.419659,-0.1601841,0.0012695,-0.103538,-0.011173,0.000067,-0.000145,37,O +2019-05-16,58619,0.088999,0.420446,-0.1614640,0.0012897,-0.104212,-0.011128,0.000048,-0.000136,37,O +2019-05-17,58620,0.090613,0.421097,-0.1627193,0.0012090,-0.104900,-0.011227,0.000029,-0.000128,37,O +2019-05-18,58621,0.092152,0.421974,-0.1637982,0.0009581,-0.105215,-0.011462,0.000049,-0.000242,37,O +2019-05-19,58622,0.093282,0.422813,-0.1646108,0.0006955,-0.105164,-0.011648,0.000083,-0.000404,37,O +2019-05-20,58623,0.094326,0.423729,-0.1652087,0.0004967,-0.105089,-0.011504,0.000058,-0.000314,37,O +2019-05-21,58624,0.095131,0.424424,-0.1656005,0.0003204,-0.105045,-0.011387,0.000033,-0.000223,37,O +2019-05-22,58625,0.096224,0.424661,-0.1658605,0.0002467,-0.105075,-0.011410,0.000031,-0.000186,37,O +2019-05-23,58626,0.097554,0.425052,-0.1660855,0.0002189,-0.105179,-0.011489,0.000036,-0.000164,37,O +2019-05-24,58627,0.099078,0.425636,-0.1663191,0.0002588,-0.105259,-0.011527,0.000041,-0.000141,37,O +2019-05-25,58628,0.100677,0.426354,-0.1665911,0.0002955,-0.105209,-0.011544,0.000050,-0.000147,37,O +2019-05-26,58629,0.101998,0.427131,-0.1669195,0.0003554,-0.105032,-0.011567,0.000059,-0.000163,37,O +2019-05-27,58630,0.102789,0.428011,-0.1673156,0.0004345,-0.104834,-0.011609,0.000068,-0.000179,37,O +2019-05-28,58631,0.103380,0.428645,-0.1677794,0.0005092,-0.104791,-0.011621,0.000077,-0.000195,37,O +2019-05-29,58632,0.104189,0.429128,-0.1683015,0.0005697,-0.105028,-0.011535,0.000087,-0.000211,37,O +2019-05-30,58633,0.105214,0.429435,-0.1688666,0.0006065,-0.105585,-0.011324,0.000066,-0.000203,37,O +2019-05-31,58634,0.106824,0.429366,-0.1694735,0.0006029,-0.106194,-0.011093,0.000037,-0.000187,37,O +2019-06-01,58635,0.109192,0.429288,-0.1700445,0.0005755,-0.106503,-0.010983,0.000047,-0.000178,37,O +2019-06-02,58636,0.111767,0.429661,-0.1705907,0.0004583,-0.106507,-0.011056,0.000072,-0.000171,37,O +2019-06-03,58637,0.114354,0.430266,-0.1709787,0.0003102,-0.106379,-0.011266,0.000097,-0.000165,37,O +2019-06-04,58638,0.117030,0.430851,-0.1712318,0.0002154,-0.106310,-0.011479,0.000121,-0.000158,37,O +2019-06-05,58639,0.119239,0.431321,-0.1714035,0.0001493,-0.106502,-0.011554,0.000089,-0.000139,37,O +2019-06-06,58640,0.121052,0.431429,-0.1715420,0.0001022,-0.106769,-0.011472,0.000041,-0.000116,37,O +2019-06-07,58641,0.122690,0.430872,-0.1716602,0.0001382,-0.106950,-0.011322,-0.000007,-0.000093,37,O +2019-06-08,58642,0.124490,0.430649,-0.1718378,0.0002370,-0.106893,-0.011241,-0.000022,-0.000097,37,O +2019-06-09,58643,0.126185,0.430126,-0.1721356,0.0003910,-0.106666,-0.011240,-0.000025,-0.000111,37,O +2019-06-10,58644,0.128346,0.429871,-0.1725999,0.0005326,-0.106402,-0.011245,-0.000029,-0.000125,37,O +2019-06-11,58645,0.130420,0.429746,-0.1732075,0.0006185,-0.106276,-0.011200,-0.000032,-0.000139,37,O +2019-06-12,58646,0.132347,0.429558,-0.1738778,0.0006416,-0.106466,-0.011124,-0.000035,-0.000153,37,O +2019-06-13,58647,0.134380,0.429399,-0.1744966,0.0005803,-0.106937,-0.011074,-0.000015,-0.000167,37,O +2019-06-14,58648,0.136665,0.429210,-0.1750200,0.0004295,-0.107533,-0.011074,0.000011,-0.000182,37,O +2019-06-15,58649,0.138696,0.429013,-0.1753572,0.0002232,-0.108004,-0.011052,0.000023,-0.000153,37,O +2019-06-16,58650,0.140244,0.428691,-0.1754768,0.0000056,-0.108150,-0.011015,0.000030,-0.000107,37,O +2019-06-17,58651,0.141742,0.428108,-0.1753998,-0.0001226,-0.108037,-0.010995,0.000037,-0.000062,37,O +2019-06-18,58652,0.143306,0.427548,-0.1752467,-0.0001850,-0.107884,-0.011007,0.000044,-0.000016,37,O +2019-06-19,58653,0.144520,0.426783,-0.1750128,-0.0002563,-0.107882,-0.011148,0.000034,-0.000085,37,O +2019-06-20,58654,0.145785,0.426239,-0.1747707,-0.0002204,-0.108008,-0.011288,0.000020,-0.000184,37,O +2019-06-21,58655,0.147173,0.426049,-0.1745848,-0.0001854,-0.108113,-0.011328,0.000045,-0.000225,37,O +2019-06-22,58656,0.148438,0.425869,-0.1744462,-0.0001293,-0.108294,-0.011325,0.000058,-0.000222,37,O +2019-06-23,58657,0.149329,0.425822,-0.1743743,-0.0000398,-0.108487,-0.011356,0.000060,-0.000210,37,O +2019-06-24,58658,0.149642,0.425359,-0.1743632,0.0000263,-0.108584,-0.011405,0.000063,-0.000199,37,O +2019-06-25,58659,0.150443,0.424519,-0.1744216,0.0000533,-0.108638,-0.011396,0.000065,-0.000187,37,O +2019-06-26,58660,0.151503,0.423564,-0.1744781,0.0000439,-0.108850,-0.011281,0.000074,-0.000172,37,O +2019-06-27,58661,0.153050,0.422505,-0.1745257,0.0000453,-0.109396,-0.011082,0.000085,-0.000155,37,O +2019-06-28,58662,0.154952,0.422105,-0.1745566,0.0000056,-0.110270,-0.010897,0.000038,-0.000172,37,O +2019-06-29,58663,0.156506,0.421788,-0.1745339,-0.0000611,-0.110904,-0.010776,0.000009,-0.000206,37,O +2019-06-30,58664,0.157773,0.421437,-0.1744325,-0.0001824,-0.111115,-0.010766,-0.000007,-0.000241,37,O +2019-07-01,58665,0.158510,0.420694,-0.1741775,-0.0003108,-0.111109,-0.010917,-0.000023,-0.000277,37,O +2019-07-02,58666,0.158923,0.419603,-0.1738182,-0.0004383,-0.111144,-0.011198,-0.000039,-0.000313,37,O +2019-07-03,58667,0.159301,0.418248,-0.1733282,-0.0005289,-0.111185,-0.011393,-0.000035,-0.000285,37,O +2019-07-04,58668,0.159771,0.417182,-0.1727712,-0.0005358,-0.111123,-0.011389,-0.000027,-0.000239,37,O +2019-07-05,58669,0.160760,0.416147,-0.1722981,-0.0004260,-0.110956,-0.011199,-0.000018,-0.000193,37,O +2019-07-06,58670,0.162741,0.415345,-0.1719953,-0.0002040,-0.110865,-0.011009,-0.000013,-0.000167,37,O +2019-07-07,58671,0.165082,0.415030,-0.1719175,-0.0000221,-0.110958,-0.010950,-0.000008,-0.000149,37,O +2019-07-08,58672,0.167058,0.414824,-0.1719241,0.0000585,-0.111157,-0.011001,-0.000004,-0.000131,37,O +2019-07-09,58673,0.168829,0.414243,-0.1720129,0.0000734,-0.111316,-0.011058,0.000000,-0.000113,37,O +2019-07-10,58674,0.170656,0.413399,-0.1720373,0.0000259,-0.111499,-0.011080,-0.000029,-0.000104,37,O +2019-07-11,58675,0.172168,0.412428,-0.1720134,-0.0001153,-0.111779,-0.011068,-0.000067,-0.000097,37,O +2019-07-12,58676,0.173303,0.411231,-0.1717954,-0.0003342,-0.112239,-0.011038,-0.000106,-0.000091,37,O +2019-07-13,58677,0.174483,0.409932,-0.1713282,-0.0005760,-0.112705,-0.011012,-0.000114,-0.000096,37,O +2019-07-14,58678,0.176050,0.408613,-0.1706787,-0.0007695,-0.113005,-0.011022,-0.000110,-0.000105,37,O +2019-07-15,58679,0.177687,0.407424,-0.1698085,-0.0009133,-0.113051,-0.011115,-0.000107,-0.000114,37,O +2019-07-16,58680,0.179332,0.406414,-0.1688618,-0.0009571,-0.112919,-0.011274,-0.000103,-0.000123,37,O +2019-07-17,58681,0.180565,0.406010,-0.1679382,-0.0009163,-0.112696,-0.011371,-0.000066,-0.000108,37,O +2019-07-18,58682,0.181617,0.405295,-0.1670432,-0.0008163,-0.112563,-0.011323,-0.000020,-0.000087,37,O +2019-07-19,58683,0.182544,0.404573,-0.1662851,-0.0006897,-0.112591,-0.011157,0.000027,-0.000066,37,O +2019-07-20,58684,0.183047,0.403589,-0.1656322,-0.0005755,-0.112918,-0.011058,0.000016,-0.000096,37,O +2019-07-21,58685,0.183724,0.402446,-0.1651379,-0.0004998,-0.113327,-0.011085,-0.000014,-0.000144,37,O +2019-07-22,58686,0.184514,0.401331,-0.1646548,-0.0004473,-0.113583,-0.011177,-0.000045,-0.000193,37,O +2019-07-23,58687,0.185834,0.400342,-0.1642195,-0.0003851,-0.113640,-0.011221,-0.000075,-0.000241,37,O +2019-07-24,58688,0.187682,0.399458,-0.1638659,-0.0003124,-0.113699,-0.011118,-0.000079,-0.000221,37,O +2019-07-25,58689,0.189630,0.398277,-0.1635104,-0.0003293,-0.114129,-0.010988,-0.000075,-0.000182,37,O +2019-07-26,58690,0.191786,0.396756,-0.1631804,-0.0003897,-0.114903,-0.010914,-0.000071,-0.000144,37,O +2019-07-27,58691,0.194250,0.395533,-0.1627645,-0.0004129,-0.115571,-0.010888,-0.000067,-0.000125,37,O +2019-07-28,58692,0.196630,0.394957,-0.1623692,-0.0004457,-0.115787,-0.010859,-0.000063,-0.000113,37,O +2019-07-29,58693,0.198637,0.394721,-0.1618353,-0.0005432,-0.115685,-0.010884,-0.000059,-0.000101,37,O +2019-07-30,58694,0.200514,0.394157,-0.1612463,-0.0006170,-0.115580,-0.011050,-0.000054,-0.000089,37,O +2019-07-31,58695,0.202626,0.393370,-0.1606707,-0.0005429,-0.115528,-0.011286,-0.000056,-0.000081,37,O +2019-08-01,58696,0.204690,0.392301,-0.1602267,-0.0004012,-0.115349,-0.011371,-0.000059,-0.000074,37,O +2019-08-02,58697,0.206262,0.391220,-0.1598692,-0.0002143,-0.115077,-0.011222,-0.000062,-0.000067,37,O +2019-08-03,58698,0.207816,0.390218,-0.1597619,0.0000136,-0.115004,-0.011008,-0.000073,-0.000056,37,O +2019-08-04,58699,0.209328,0.389372,-0.1598705,0.0002047,-0.115286,-0.010928,-0.000088,-0.000044,37,O +2019-08-05,58700,0.210566,0.388756,-0.1601388,0.0002868,-0.115791,-0.010971,-0.000102,-0.000033,37,O +2019-08-06,58701,0.211602,0.388370,-0.1604604,0.0002509,-0.116247,-0.011005,-0.000117,-0.000021,37,O +2019-08-07,58702,0.212386,0.388019,-0.1606720,0.0001189,-0.116361,-0.011020,-0.000095,-0.000017,37,O +2019-08-08,58703,0.212729,0.387457,-0.1606950,-0.0000725,-0.116228,-0.011085,-0.000064,-0.000015,37,O +2019-08-09,58704,0.213213,0.386456,-0.1605177,-0.0002884,-0.116092,-0.011205,-0.000032,-0.000013,37,O +2019-08-10,58705,0.213618,0.385343,-0.1600900,-0.0005104,-0.116211,-0.011294,-0.000025,-0.000003,37,O +2019-08-11,58706,0.213982,0.383799,-0.1595070,-0.0006517,-0.116484,-0.011321,-0.000027,0.000011,37,O +2019-08-12,58707,0.214516,0.382169,-0.1588184,-0.0007450,-0.116658,-0.011349,-0.000029,0.000025,37,O +2019-08-13,58708,0.214944,0.380545,-0.1580556,-0.0007526,-0.116598,-0.011422,-0.000031,0.000039,37,O +2019-08-14,58709,0.215570,0.378976,-0.1573339,-0.0006479,-0.116386,-0.011487,-0.000031,0.000025,37,O +2019-08-15,58710,0.216255,0.377777,-0.1567325,-0.0005263,-0.116211,-0.011396,-0.000031,0.000003,37,O +2019-08-16,58711,0.216650,0.376719,-0.1562758,-0.0004420,-0.116199,-0.011146,-0.000031,-0.000019,37,O +2019-08-17,58712,0.216754,0.375676,-0.1558223,-0.0003914,-0.116312,-0.010903,-0.000016,-0.000041,37,O +2019-08-18,58713,0.216967,0.374479,-0.1555081,-0.0003343,-0.116444,-0.010820,0.000005,-0.000065,37,O +2019-08-19,58714,0.216955,0.373221,-0.1552168,-0.0002577,-0.116428,-0.010870,0.000027,-0.000088,37,O +2019-08-20,58715,0.217091,0.371942,-0.1549961,-0.0001989,-0.116217,-0.010917,0.000048,-0.000111,37,O +2019-08-21,58716,0.217230,0.370375,-0.1548084,-0.0001647,-0.116189,-0.010821,0.000005,-0.000050,37,O +2019-08-22,58717,0.217272,0.368758,-0.1546673,-0.0001669,-0.116555,-0.010733,-0.000055,0.000032,37,O +2019-08-23,58718,0.217196,0.367299,-0.1545252,-0.0001604,-0.117316,-0.010760,-0.000114,0.000115,37,O +2019-08-24,58719,0.216899,0.365602,-0.1543575,-0.0002102,-0.117963,-0.010926,-0.000123,0.000111,37,O +2019-08-25,58720,0.216628,0.363656,-0.1540886,-0.0003062,-0.118165,-0.011042,-0.000114,0.000075,37,O +2019-08-26,58721,0.216427,0.361682,-0.1537159,-0.0004026,-0.117983,-0.011065,-0.000104,0.000039,37,O +2019-08-27,58722,0.216384,0.359848,-0.1533169,-0.0004038,-0.117718,-0.011113,-0.000094,0.000003,37,O +2019-08-28,58723,0.216234,0.357990,-0.1529938,-0.0002607,-0.117507,-0.011174,-0.000089,-0.000001,37,O +2019-08-29,58724,0.215974,0.356213,-0.1528093,-0.0000692,-0.117261,-0.011118,-0.000086,0.000003,37,O +2019-08-30,58725,0.215295,0.354392,-0.1528582,0.0001634,-0.117017,-0.010878,-0.000083,0.000007,37,O +2019-08-31,58726,0.214589,0.352607,-0.1531164,0.0003889,-0.117000,-0.010630,-0.000090,0.000020,37,O +2019-09-01,58727,0.214251,0.351024,-0.1536230,0.0005509,-0.117270,-0.010580,-0.000102,0.000037,37,O +2019-09-02,58728,0.214229,0.349770,-0.1542362,0.0006158,-0.117690,-0.010657,-0.000114,0.000054,37,O +2019-09-03,58729,0.213821,0.348481,-0.1548126,0.0005143,-0.118091,-0.010651,-0.000126,0.000071,37,O +2019-09-04,58730,0.213451,0.346759,-0.1552653,0.0003387,-0.118299,-0.010579,-0.000129,0.000075,37,O +2019-09-05,58731,0.213287,0.345150,-0.1555174,0.0001664,-0.118238,-0.010634,-0.000131,0.000077,37,O +2019-09-06,58732,0.213284,0.343292,-0.1555427,-0.0000562,-0.117998,-0.010893,-0.000132,0.000078,37,O +2019-09-07,58733,0.213605,0.341584,-0.1553511,-0.0002258,-0.117758,-0.011185,-0.000095,0.000075,37,O +2019-09-08,58734,0.213748,0.340214,-0.1551104,-0.0003264,-0.117724,-0.011307,-0.000044,0.000071,37,O +2019-09-09,58735,0.213582,0.338873,-0.1547174,-0.0003835,-0.117754,-0.011258,0.000008,0.000066,37,O +2019-09-10,58736,0.212916,0.337633,-0.1543020,-0.0003792,-0.117596,-0.011165,0.000059,0.000062,37,O +2019-09-11,58737,0.211643,0.336271,-0.1539400,-0.0003457,-0.117407,-0.011071,0.000034,0.000068,37,O +2019-09-12,58738,0.210279,0.334464,-0.1535993,-0.0003023,-0.117223,-0.010907,-0.000010,0.000078,37,O +2019-09-13,58739,0.209357,0.332511,-0.1533809,-0.0001592,-0.117151,-0.010629,-0.000054,0.000087,37,O +2019-09-14,58740,0.208780,0.330745,-0.1532910,-0.0000117,-0.117083,-0.010329,-0.000056,0.000098,37,O +2019-09-15,58741,0.208414,0.329530,-0.1533171,0.0000314,-0.116993,-0.010161,-0.000042,0.000109,37,O +2019-09-16,58742,0.207861,0.328404,-0.1533320,-0.0000025,-0.116843,-0.010154,-0.000029,0.000120,37,O +2019-09-17,58743,0.207375,0.326891,-0.1533303,-0.0000354,-0.116621,-0.010198,-0.000015,0.000132,37,O +2019-09-18,58744,0.206919,0.325493,-0.1532853,-0.0000746,-0.116461,-0.010216,-0.000012,0.000135,37,O +2019-09-19,58745,0.206058,0.324124,-0.1531654,-0.0001887,-0.116519,-0.010242,-0.000012,0.000136,37,O +2019-09-20,58746,0.204867,0.323038,-0.1529207,-0.0003054,-0.116856,-0.010355,-0.000012,0.000138,37,O +2019-09-21,58747,0.203740,0.321672,-0.1525495,-0.0004187,-0.117239,-0.010517,0.000004,0.000154,37,O +2019-09-22,58748,0.202952,0.320373,-0.1521046,-0.0004659,-0.117374,-0.010607,0.000026,0.000175,37,O +2019-09-23,58749,0.202247,0.319367,-0.1516530,-0.0004642,-0.117154,-0.010553,0.000049,0.000197,37,O +2019-09-24,58750,0.201645,0.318571,-0.1512166,-0.0003760,-0.116741,-0.010403,0.000071,0.000219,37,O +2019-09-25,58751,0.201081,0.317719,-0.1508992,-0.0001448,-0.116340,-0.010248,0.000085,0.000191,37,O +2019-09-26,58752,0.200126,0.317163,-0.1508833,0.0001271,-0.116027,-0.010002,0.000096,0.000150,37,O +2019-09-27,58753,0.199436,0.316266,-0.1512096,0.0004451,-0.115877,-0.009666,0.000107,0.000110,37,O +2019-09-28,58754,0.199110,0.315576,-0.1518123,0.0006726,-0.116053,-0.009432,0.000076,0.000093,37,O +2019-09-29,58755,0.198862,0.314678,-0.1525147,0.0007271,-0.116385,-0.009501,0.000030,0.000086,37,O +2019-09-30,58756,0.198848,0.313423,-0.1532049,0.0006476,-0.116658,-0.009755,-0.000016,0.000079,37,O +2019-10-01,58757,0.198410,0.312207,-0.1537485,0.0003901,-0.116838,-0.009882,-0.000063,0.000072,37,O +2019-10-02,58758,0.197567,0.311034,-0.1539883,0.0000893,-0.116830,-0.009751,-0.000052,0.000123,37,O +2019-10-03,58759,0.196521,0.310013,-0.1539122,-0.0001661,-0.116702,-0.009698,-0.000029,0.000146,37,O +2019-10-04,58760,0.195512,0.308733,-0.1536855,-0.0003216,-0.116430,-0.009908,-0.000007,0.000153,37,O +2019-10-05,58761,0.194646,0.307613,-0.1532978,-0.0004249,-0.116142,-0.010226,0.000015,0.000160,37,O +2019-10-06,58762,0.193612,0.306147,-0.1528333,-0.0004566,-0.116021,-0.010363,0.000037,0.000167,37,O +2019-10-07,58763,0.192696,0.304968,-0.1523685,-0.0004190,-0.116014,-0.010226,0.000059,0.000174,37,O +2019-10-08,58764,0.191558,0.303570,-0.1519645,-0.0003952,-0.115900,-0.009968,0.000081,0.000181,37,O +2019-10-09,58765,0.190547,0.301914,-0.1516533,-0.0002629,-0.115598,-0.009766,0.000103,0.000188,37,O +2019-10-10,58766,0.189439,0.300716,-0.1514464,-0.0001207,-0.115448,-0.009637,0.000044,0.000190,37,O +2019-10-11,58767,0.188637,0.299690,-0.1513803,0.0000031,-0.115427,-0.009477,-0.000035,0.000191,37,O +2019-10-12,58768,0.187871,0.299356,-0.1514616,0.0001639,-0.115239,-0.009268,-0.000022,0.000178,37,O +2019-10-13,58769,0.186230,0.299271,-0.1516517,0.0002330,-0.114968,-0.009087,0.000025,0.000159,37,O +2019-10-14,58770,0.184374,0.298532,-0.1519120,0.0002854,-0.114713,-0.009018,0.000072,0.000141,37,O +2019-10-15,58771,0.182663,0.297785,-0.1522347,0.0003192,-0.114516,-0.009061,0.000119,0.000122,37,O +2019-10-16,58772,0.181451,0.297182,-0.1525644,0.0003320,-0.114510,-0.009117,0.000110,0.000133,37,O +2019-10-17,58773,0.179963,0.296654,-0.1528796,0.0002835,-0.114561,-0.009165,0.000087,0.000151,37,O +2019-10-18,58774,0.178272,0.295649,-0.1531347,0.0002222,-0.114664,-0.009217,0.000063,0.000169,37,O +2019-10-19,58775,0.176769,0.294516,-0.1533264,0.0001545,-0.114780,-0.009291,0.000060,0.000171,37,O +2019-10-20,58776,0.175243,0.293466,-0.1534304,0.0000914,-0.114845,-0.009340,0.000064,0.000167,37,O +2019-10-21,58777,0.173642,0.292375,-0.1535058,0.0000687,-0.114712,-0.009312,0.000069,0.000162,37,O +2019-10-22,58778,0.172439,0.291301,-0.1536109,0.0001472,-0.114334,-0.009178,0.000074,0.000158,37,O +2019-10-23,58779,0.171356,0.290381,-0.1538184,0.0003219,-0.113832,-0.008904,0.000086,0.000173,37,O +2019-10-24,58780,0.170144,0.289971,-0.1542370,0.0005318,-0.113452,-0.008499,0.000101,0.000194,37,O +2019-10-25,58781,0.168762,0.289141,-0.1549127,0.0007802,-0.113389,-0.008063,0.000115,0.000214,37,O +2019-10-26,58782,0.167818,0.287812,-0.1558032,0.0009548,-0.113673,-0.007843,0.000109,0.000208,37,O +2019-10-27,58783,0.167273,0.286523,-0.1568092,0.0009718,-0.114031,-0.007985,0.000095,0.000193,37,O +2019-10-28,58784,0.167133,0.285481,-0.1577255,0.0008493,-0.114178,-0.008351,0.000081,0.000178,37,O +2019-10-29,58785,0.166908,0.284350,-0.1584554,0.0006110,-0.114086,-0.008614,0.000067,0.000162,37,O +2019-10-30,58786,0.167018,0.283062,-0.1589241,0.0003454,-0.113914,-0.008570,0.000055,0.000185,37,O +2019-10-31,58787,0.166656,0.282117,-0.1591501,0.0001216,-0.113761,-0.008419,0.000043,0.000217,37,O +2019-11-01,58788,0.166024,0.281083,-0.1592044,0.0000290,-0.113520,-0.008438,0.000058,0.000223,37,O +2019-11-02,58789,0.165338,0.280270,-0.1591866,-0.0000229,-0.113233,-0.008601,0.000082,0.000220,37,O +2019-11-03,58790,0.164712,0.279387,-0.1591777,0.0000031,-0.113011,-0.008677,0.000106,0.000217,37,O +2019-11-04,58791,0.163921,0.278764,-0.1591947,0.0000618,-0.112875,-0.008530,0.000130,0.000213,37,O +2019-11-05,58792,0.163092,0.278229,-0.1592855,0.0001031,-0.112734,-0.008263,0.000154,0.000210,37,O +2019-11-06,58793,0.162362,0.277999,-0.1594469,0.0002318,-0.112588,-0.008098,0.000155,0.000182,37,O +2019-11-07,58794,0.161420,0.277887,-0.1597681,0.0003988,-0.112461,-0.008077,0.000148,0.000148,37,O +2019-11-08,58795,0.160475,0.277218,-0.1602407,0.0005640,-0.112391,-0.008075,0.000142,0.000113,37,O +2019-11-09,58796,0.159241,0.276588,-0.1608634,0.0006676,-0.112381,-0.007923,0.000123,0.000111,37,O +2019-11-10,58797,0.157895,0.275927,-0.1615582,0.0007108,-0.112372,-0.007651,0.000099,0.000120,37,O +2019-11-11,58798,0.156727,0.275260,-0.1622553,0.0006808,-0.112392,-0.007409,0.000076,0.000129,37,O +2019-11-12,58799,0.155603,0.274984,-0.1629060,0.0006010,-0.112500,-0.007328,0.000052,0.000138,37,O +2019-11-13,58800,0.154311,0.275077,-0.1634446,0.0004930,-0.112607,-0.007392,0.000037,0.000174,37,O +2019-11-14,58801,0.153268,0.274960,-0.1639043,0.0003652,-0.112590,-0.007518,0.000026,0.000216,37,O +2019-11-15,58802,0.152222,0.274968,-0.1641959,0.0002686,-0.112434,-0.007593,0.000014,0.000258,37,O +2019-11-16,58803,0.150295,0.275080,-0.1643655,0.0001742,-0.112208,-0.007621,0.000022,0.000250,37,O +2019-11-17,58804,0.147587,0.274490,-0.1644541,0.0000196,-0.112034,-0.007606,0.000039,0.000222,37,O +2019-11-18,58805,0.145289,0.273683,-0.1645155,0.0000739,-0.111862,-0.007577,0.000055,0.000194,37,O +2019-11-19,58806,0.143281,0.273081,-0.1646594,0.0002184,-0.111548,-0.007535,0.000071,0.000166,37,O +2019-11-20,58807,0.141572,0.272389,-0.1650117,0.0004566,-0.111071,-0.007394,0.000102,0.000167,37,O +2019-11-21,58808,0.139739,0.271754,-0.1655856,0.0006891,-0.110682,-0.007141,0.000137,0.000174,37,O +2019-11-22,58809,0.137935,0.270986,-0.1663474,0.0008501,-0.110631,-0.006855,0.000172,0.000182,37,O +2019-11-23,58810,0.135854,0.270490,-0.1672098,0.0008984,-0.111089,-0.006702,0.000145,0.000194,37,O +2019-11-24,58811,0.133695,0.270065,-0.1680987,0.0008706,-0.111706,-0.006804,0.000095,0.000208,37,O +2019-11-25,58812,0.131862,0.269518,-0.1688806,0.0007028,-0.112110,-0.007079,0.000045,0.000222,37,O +2019-11-26,58813,0.130125,0.269096,-0.1694679,0.0004439,-0.112184,-0.007294,-0.000005,0.000236,37,O +2019-11-27,58814,0.128691,0.269088,-0.1698161,0.0002162,-0.111964,-0.007333,-0.000021,0.000212,37,O +2019-11-28,58815,0.127259,0.269277,-0.1699512,0.0001048,-0.111589,-0.007240,0.000013,0.000173,37,O +2019-11-29,58816,0.126025,0.269630,-0.1700093,0.0000503,-0.111219,-0.007182,0.000062,0.000133,37,O +2019-11-30,58817,0.124622,0.269887,-0.1700295,0.0000065,-0.110916,-0.007195,0.000095,0.000121,37,O +2019-12-01,58818,0.122977,0.270474,-0.1700083,0.0000115,-0.110641,-0.007209,0.000126,0.000111,37,O +2019-12-02,58819,0.121295,0.270919,-0.1700652,0.0001125,-0.110426,-0.007124,0.000156,0.000102,37,O +2019-12-03,58820,0.119056,0.271391,-0.1702069,0.0002032,-0.110287,-0.006980,0.000187,0.000093,37,O +2019-12-04,58821,0.116202,0.271402,-0.1704075,0.0002412,-0.109773,-0.006858,0.000394,0.000129,37,O +2019-12-05,58822,0.113387,0.271331,-0.1706831,0.0002888,-0.109907,-0.006923,0.000357,0.000094,37,O +2019-12-06,58823,0.111157,0.271130,-0.1710324,0.0003641,-0.110252,-0.007017,0.000235,0.000034,37,O +2019-12-07,58824,0.109446,0.271083,-0.1714476,0.0004120,-0.110410,-0.006891,0.000179,0.000043,37,O +2019-12-08,58825,0.107845,0.270977,-0.1718773,0.0004384,-0.110499,-0.006557,0.000148,0.000076,37,O +2019-12-09,58826,0.106731,0.270915,-0.1722563,0.0003279,-0.110625,-0.006179,0.000118,0.000110,37,O +2019-12-10,58827,0.105853,0.271007,-0.1725299,0.0001560,-0.110807,-0.005966,0.000087,0.000144,37,O +2019-12-11,58828,0.105246,0.271040,-0.1726501,0.0000269,-0.110865,-0.006060,0.000098,0.000136,37,O +2019-12-12,58829,0.104919,0.271256,-0.1726192,-0.0001170,-0.110755,-0.006347,0.000121,0.000117,37,O +2019-12-13,58830,0.104891,0.271967,-0.1724695,-0.0001672,-0.110456,-0.006619,0.000143,0.000097,37,O +2019-12-14,58831,0.104387,0.273241,-0.1722776,-0.0001813,-0.110018,-0.006695,0.000172,0.000104,37,O +2019-12-15,58832,0.103420,0.274169,-0.1721003,-0.0001567,-0.109579,-0.006594,0.000202,0.000119,37,O +2019-12-16,58833,0.101523,0.274834,-0.1719915,-0.0000768,-0.109207,-0.006442,0.000233,0.000135,37,O +2019-12-17,58834,0.099491,0.275064,-0.1720193,0.0001269,-0.108887,-0.006347,0.000264,0.000150,37,O +2019-12-18,58835,0.097486,0.275323,-0.1722457,0.0003512,-0.108602,-0.006311,0.000295,0.000166,37,O +2019-12-19,58836,0.095902,0.275669,-0.1727030,0.0005690,-0.108659,-0.006343,0.000230,0.000107,37,O +2019-12-20,58837,0.095103,0.276115,-0.1733419,0.0006708,-0.108997,-0.006361,0.000140,0.000029,37,O +2019-12-21,58838,0.094742,0.276421,-0.1740825,0.0006995,-0.109367,-0.006353,0.000139,0.000001,37,O +2019-12-22,58839,0.094482,0.277227,-0.1748044,0.0006483,-0.109770,-0.006414,0.000173,-0.000008,37,O +2019-12-23,58840,0.093397,0.278386,-0.1753803,0.0005092,-0.110048,-0.006544,0.000206,-0.000017,37,O +2019-12-24,58841,0.091836,0.279097,-0.1757728,0.0003494,-0.110009,-0.006649,0.000239,-0.000026,37,O +2019-12-25,58842,0.090305,0.279607,-0.1760220,0.0001839,-0.109785,-0.006611,0.000227,0.000020,37,O +2019-12-26,58843,0.088530,0.280066,-0.1761523,0.0000805,-0.109486,-0.006498,0.000203,0.000080,37,O +2019-12-27,58844,0.086894,0.280745,-0.1762143,0.0000471,-0.109262,-0.006403,0.000180,0.000140,37,O +2019-12-28,58845,0.085073,0.281330,-0.1762581,0.0000518,-0.109039,-0.006433,0.000201,0.000123,37,O +2019-12-29,58846,0.082939,0.281710,-0.1763377,0.0001236,-0.108827,-0.006497,0.000239,0.000079,37,O +2019-12-30,58847,0.080306,0.281800,-0.1764974,0.0002229,-0.108655,-0.006532,0.000276,0.000034,37,O +2019-12-31,58848,0.078246,0.281929,-0.1767593,0.0003452,-0.108568,-0.006562,0.000314,-0.000011,37,O +2020-01-01,58849,0.076609,0.282358,-0.1771222,0.0004455,-0.108588,-0.006586,0.000348,0.000003,37,O +2020-01-02,58850,0.074635,0.282666,-0.1775806,0.0004667,-0.108606,-0.006644,0.000382,0.000033,37,O +2020-01-03,58851,0.072663,0.283156,-0.1781029,0.0004803,-0.108526,-0.006664,0.000416,0.000062,37,O +2020-01-04,58852,0.071338,0.284013,-0.1786507,0.0004801,-0.108550,-0.006567,0.000382,0.000067,37,O +2020-01-05,58853,0.070121,0.284887,-0.1791377,0.0004064,-0.108694,-0.006317,0.000322,0.000064,37,O +2020-01-06,58854,0.068393,0.285277,-0.1794674,0.0002265,-0.108947,-0.006003,0.000263,0.000060,37,O +2020-01-07,58855,0.066587,0.285482,-0.1796058,0.0000717,-0.109259,-0.005786,0.000203,0.000056,37,O +2020-01-08,58856,0.064905,0.285932,-0.1795597,-0.0000717,-0.109555,-0.005800,0.000144,0.000053,37,O +2020-01-09,58857,0.063591,0.286537,-0.1793746,-0.0002132,-0.109698,-0.006077,0.000127,0.000036,37,O +2020-01-10,58858,0.062631,0.287462,-0.1791201,-0.0002979,-0.109691,-0.006467,0.000121,0.000017,37,O +2020-01-11,58859,0.061854,0.288667,-0.1788961,-0.0002007,-0.109426,-0.006715,0.000119,0.000019,37,O +2020-01-12,58860,0.061134,0.289907,-0.1788057,-0.0000038,-0.108895,-0.006685,0.000117,0.000029,37,O +2020-01-13,58861,0.060864,0.291018,-0.1789353,0.0002968,-0.108296,-0.006450,0.000116,0.000039,37,O +2020-01-14,58862,0.060557,0.292386,-0.1793255,0.0005750,-0.107913,-0.006224,0.000115,0.000049,37,O +2020-01-15,58863,0.059588,0.293794,-0.1799543,0.0007465,-0.107769,-0.006196,0.000150,0.000019,37,O +2020-01-16,58864,0.058520,0.295343,-0.1807846,0.0008774,-0.107837,-0.006302,0.000195,-0.000020,37,O +2020-01-17,58865,0.057430,0.296819,-0.1817437,0.0010052,-0.108001,-0.006417,0.000239,-0.000059,37,O +2020-01-18,58866,0.056515,0.297636,-0.1827608,0.0010297,-0.108336,-0.006441,0.000228,-0.000048,37,O +2020-01-19,58867,0.055634,0.298582,-0.1837339,0.0009318,-0.108744,-0.006424,0.000195,-0.000018,37,O +2020-01-20,58868,0.054617,0.299454,-0.1845425,0.0007783,-0.109091,-0.006405,0.000163,0.000012,37,O +2020-01-21,58869,0.053801,0.300237,-0.1852307,0.0005888,-0.109236,-0.006378,0.000130,0.000042,37,O +2020-01-22,58870,0.053304,0.301090,-0.1857979,0.0004516,-0.109097,-0.006357,0.000098,0.000072,37,O +2020-01-23,58871,0.052618,0.302469,-0.1861858,0.0003157,-0.108638,-0.006398,0.000129,0.000084,37,O +2020-01-24,58872,0.051965,0.303572,-0.1864849,0.0002606,-0.108196,-0.006499,0.000178,0.000092,37,O +2020-01-25,58873,0.051957,0.304776,-0.1867979,0.0003582,-0.107967,-0.006615,0.000217,0.000090,37,O +2020-01-26,58874,0.051500,0.306324,-0.1871882,0.0004438,-0.107884,-0.006673,0.000254,0.000085,37,O +2020-01-27,58875,0.050488,0.307421,-0.1876943,0.0005593,-0.107859,-0.006674,0.000291,0.000079,37,O +2020-01-28,58876,0.049407,0.308653,-0.1883290,0.0006623,-0.107879,-0.006689,0.000327,0.000074,37,O +2020-01-29,58877,0.048378,0.310139,-0.1890559,0.0007174,-0.108081,-0.006785,0.000299,0.000059,37,O +2020-01-30,58878,0.047078,0.311687,-0.1898028,0.0007392,-0.108239,-0.006916,0.000255,0.000042,37,O +2020-01-31,58879,0.045724,0.312939,-0.1905245,0.0006980,-0.108232,-0.006994,0.000210,0.000025,37,O +2020-02-01,58880,0.044494,0.314392,-0.1911699,0.0005988,-0.108012,-0.006963,0.000223,0.000025,37,O +2020-02-02,58881,0.043505,0.316036,-0.1917194,0.0004836,-0.107876,-0.006862,0.000257,0.000031,37,O +2020-02-03,58882,0.042727,0.317663,-0.1921721,0.0003794,-0.107929,-0.006737,0.000291,0.000038,37,O +2020-02-04,58883,0.042236,0.319419,-0.1925141,0.0002354,-0.108039,-0.006617,0.000324,0.000044,37,O +2020-02-05,58884,0.042192,0.321224,-0.1927412,0.0001382,-0.108221,-0.006572,0.000323,0.000039,37,O +2020-02-06,58885,0.041387,0.322939,-0.1928644,0.0000870,-0.108517,-0.006722,0.000311,0.000031,37,O +2020-02-07,58886,0.040107,0.323988,-0.1929351,0.0000853,-0.108855,-0.007119,0.000300,0.000023,37,O +2020-02-08,58887,0.038702,0.324883,-0.1930242,0.0001418,-0.108909,-0.007587,0.000279,0.000004,37,O +2020-02-09,58888,0.037913,0.325300,-0.1932662,0.0003533,-0.108384,-0.007796,0.000253,-0.000020,37,O +2020-02-10,58889,0.037635,0.326014,-0.1937899,0.0006718,-0.107527,-0.007618,0.000228,-0.000043,37,O +2020-02-11,58890,0.037317,0.327316,-0.1945859,0.0008996,-0.106951,-0.007292,0.000203,-0.000067,37,O +2020-02-12,58891,0.037414,0.328670,-0.1955386,0.0009962,-0.106914,-0.007081,0.000209,-0.000043,37,O +2020-02-13,58892,0.037440,0.330236,-0.1965300,0.0009626,-0.107285,-0.007084,0.000223,-0.000008,37,O +2020-02-14,58893,0.036532,0.331984,-0.1974312,0.0007962,-0.107697,-0.007156,0.000236,0.000028,37,O +2020-02-15,58894,0.034910,0.333280,-0.1981377,0.0005980,-0.107921,-0.007234,0.000254,0.000020,37,O +2020-02-16,58895,0.033056,0.334012,-0.1986185,0.0004101,-0.107997,-0.007308,0.000274,-0.000005,37,O +2020-02-17,58896,0.031510,0.334883,-0.1989191,0.0002210,-0.108036,-0.007389,0.000294,-0.000030,37,O +2020-02-18,58897,0.030655,0.336009,-0.1990725,0.0000639,-0.108041,-0.007459,0.000315,-0.000055,37,O +2020-02-19,58898,0.030313,0.337617,-0.1991016,0.0000235,-0.107939,-0.007476,0.000324,-0.000036,37,O +2020-02-20,58899,0.029598,0.339041,-0.1991206,0.0000386,-0.107646,-0.007524,0.000331,-0.000006,37,O +2020-02-21,58900,0.028482,0.340031,-0.1992279,0.0001792,-0.107273,-0.007634,0.000338,0.000024,37,O +2020-02-22,58901,0.027450,0.340780,-0.1995108,0.0004273,-0.107060,-0.007747,0.000326,0.000031,37,O +2020-02-23,58902,0.026983,0.341571,-0.1999703,0.0005556,-0.107064,-0.007746,0.000306,0.000028,37,O +2020-02-24,58903,0.027040,0.342668,-0.2005609,0.0006445,-0.107212,-0.007629,0.000286,0.000026,37,O +2020-02-25,58904,0.027405,0.344602,-0.2012484,0.0006880,-0.107404,-0.007533,0.000267,0.000024,37,O +2020-02-26,58905,0.027969,0.346651,-0.2019948,0.0007245,-0.107505,-0.007570,0.000266,0.000022,37,O +2020-02-27,58906,0.028570,0.348892,-0.2027642,0.0007973,-0.107457,-0.007703,0.000270,0.000020,37,O +2020-02-28,58907,0.028790,0.351114,-0.2035270,0.0008132,-0.107243,-0.007821,0.000274,0.000019,37,O +2020-02-29,58908,0.028282,0.353263,-0.2042647,0.0007321,-0.106979,-0.007895,0.000285,0.000016,37,O +2020-03-01,58909,0.027663,0.355257,-0.2049580,0.0006589,-0.106884,-0.007984,0.000299,0.000013,37,O +2020-03-02,58910,0.027052,0.357171,-0.2055930,0.0005935,-0.106987,-0.008114,0.000312,0.000011,37,O +2020-03-03,58911,0.026374,0.359002,-0.2061635,0.0005165,-0.107074,-0.008201,0.000326,0.000008,37,O +2020-03-04,58912,0.026040,0.360668,-0.2066763,0.0004635,-0.107072,-0.008177,0.000330,0.000007,37,O +2020-03-05,58913,0.026271,0.362020,-0.2071658,0.0005028,-0.107168,-0.008176,0.000331,0.000006,37,O +2020-03-06,58914,0.026971,0.363910,-0.2076964,0.0006226,-0.107478,-0.008427,0.000332,0.000006,37,O +2020-03-07,58915,0.027743,0.365695,-0.2083559,0.0008000,-0.107690,-0.008948,0.000311,-0.000028,37,O +2020-03-08,58916,0.028156,0.367442,-0.2092279,0.0009841,-0.107295,-0.009352,0.000282,-0.000074,37,O +2020-03-09,58917,0.028068,0.369116,-0.2103544,0.0012166,-0.106424,-0.009324,0.000254,-0.000121,37,O +2020-03-10,58918,0.028186,0.370679,-0.2117167,0.0014868,-0.105806,-0.009002,0.000225,-0.000167,37,O +2020-03-11,58919,0.028655,0.372325,-0.2132290,0.0015777,-0.105808,-0.008698,0.000236,-0.000130,37,O +2020-03-12,58920,0.029168,0.373782,-0.2147503,0.0014394,-0.106277,-0.008634,0.000258,-0.000071,37,O +2020-03-13,58921,0.030390,0.375474,-0.2161386,0.0012287,-0.106712,-0.008675,0.000280,-0.000012,37,O +2020-03-14,58922,0.031837,0.377519,-0.2172921,0.0009841,-0.106856,-0.008710,0.000289,0.000024,37,O +2020-03-15,58923,0.033166,0.379483,-0.2181787,0.0007350,-0.106750,-0.008775,0.000293,0.000051,37,O +2020-03-16,58924,0.034196,0.380925,-0.2188244,0.0005614,-0.106616,-0.008915,0.000297,0.000078,37,O +2020-03-17,58925,0.034810,0.382174,-0.2192893,0.0004298,-0.106627,-0.009047,0.000301,0.000105,37,O +2020-03-18,58926,0.035518,0.383028,-0.2196482,0.0003245,-0.106777,-0.009158,0.000282,0.000050,37,O +2020-03-19,58927,0.036746,0.383993,-0.2199551,0.0002934,-0.106794,-0.009218,0.000256,-0.000027,37,O +2020-03-20,58928,0.038706,0.385063,-0.2202542,0.0003209,-0.106546,-0.009288,0.000230,-0.000104,37,O +2020-03-21,58929,0.040911,0.386045,-0.2205675,0.0003708,-0.106103,-0.009294,0.000243,-0.000126,37,O +2020-03-22,58930,0.042767,0.387279,-0.2209353,0.0004059,-0.105789,-0.009173,0.000270,-0.000127,37,O +2020-03-23,58931,0.043796,0.388552,-0.2213969,0.0004873,-0.105734,-0.008934,0.000298,-0.000129,37,O +2020-03-24,58932,0.044596,0.389940,-0.2219350,0.0005568,-0.105821,-0.008722,0.000325,-0.000131,37,O +2020-03-25,58933,0.044822,0.391441,-0.2224998,0.0005687,-0.106014,-0.008653,0.000293,-0.000088,37,O +2020-03-26,58934,0.044435,0.393108,-0.2230571,0.0005525,-0.106097,-0.008758,0.000246,-0.000032,37,O +2020-03-27,58935,0.043828,0.394126,-0.2235761,0.0004775,-0.106048,-0.008916,0.000199,0.000023,37,O +2020-03-28,58936,0.044672,0.395067,-0.2240329,0.0004229,-0.105838,-0.009089,0.000213,0.000025,37,O +2020-03-29,58937,0.045829,0.396454,-0.2244108,0.0003321,-0.105715,-0.009286,0.000251,0.000006,37,O +2020-03-30,58938,0.047045,0.398009,-0.2247096,0.0002516,-0.105752,-0.009531,0.000289,-0.000013,37,O +2020-03-31,58939,0.048812,0.399638,-0.2249477,0.0002144,-0.105749,-0.009749,0.000327,-0.000032,37,O +2020-04-01,58940,0.050857,0.401270,-0.2251625,0.0002453,-0.105703,-0.009836,0.000299,-0.000071,37,O +2020-04-02,58941,0.052653,0.403240,-0.2254211,0.0003060,-0.105614,-0.009820,0.000254,-0.000114,37,O +2020-04-03,58942,0.054027,0.405231,-0.2258088,0.0004711,-0.105674,-0.009919,0.000209,-0.000158,37,O +2020-04-04,58943,0.054964,0.406848,-0.2264201,0.0007577,-0.105687,-0.010198,0.000205,-0.000159,37,O +2020-04-05,58944,0.055428,0.407980,-0.2273265,0.0010730,-0.105396,-0.010461,0.000215,-0.000146,37,O +2020-04-06,58945,0.055966,0.408880,-0.2285432,0.0013584,-0.104852,-0.010423,0.000226,-0.000132,37,O +2020-04-07,58946,0.056183,0.409449,-0.2300159,0.0015401,-0.104541,-0.010126,0.000236,-0.000119,37,O +2020-04-08,58947,0.056906,0.409913,-0.2316246,0.0016364,-0.104960,-0.009890,0.000183,-0.000104,37,O +2020-04-09,58948,0.057714,0.411016,-0.2332083,0.0015201,-0.105749,-0.009882,0.000114,-0.000088,37,O +2020-04-10,58949,0.058140,0.412006,-0.2346158,0.0012941,-0.106222,-0.009957,0.000102,-0.000073,37,O +2020-04-11,58950,0.058541,0.412979,-0.2357568,0.0009873,-0.106219,-0.009975,0.000110,-0.000058,37,O +2020-04-12,58951,0.059089,0.413985,-0.2366150,0.0007077,-0.105893,-0.010021,0.000119,-0.000043,37,O +2020-04-13,58952,0.059763,0.415408,-0.2372105,0.0004790,-0.105542,-0.010205,0.000127,-0.000028,37,O +2020-04-14,58953,0.060958,0.416729,-0.2375994,0.0003122,-0.105435,-0.010428,0.000136,-0.000013,37,O +2020-04-15,58954,0.062096,0.418082,-0.2378589,0.0001702,-0.105601,-0.010498,0.000144,0.000002,37,O +2020-04-16,58955,0.062913,0.419660,-0.2380460,0.0001722,-0.105676,-0.010416,0.000181,-0.000021,37,O +2020-04-17,58956,0.063849,0.421394,-0.2382560,0.0002674,-0.105412,-0.010280,0.000226,-0.000055,37,O +2020-04-18,58957,0.064558,0.422987,-0.2385852,0.0004043,-0.104993,-0.010115,0.000228,-0.000034,37,O +2020-04-19,58958,0.064398,0.424255,-0.2390202,0.0004905,-0.104699,-0.009913,0.000214,0.000005,37,O +2020-04-20,58959,0.063813,0.425119,-0.2395002,0.0004897,-0.104731,-0.009640,0.000200,0.000045,37,O +2020-04-21,58960,0.063199,0.425896,-0.2399975,0.0004841,-0.105006,-0.009376,0.000186,0.000085,37,O +2020-04-22,58961,0.063315,0.426486,-0.2405026,0.0004852,-0.105195,-0.009378,0.000203,0.000029,37,O +2020-04-23,58962,0.064241,0.427347,-0.2409715,0.0004599,-0.105205,-0.009629,0.000228,-0.000053,37,O +2020-04-24,58963,0.065516,0.428239,-0.2413900,0.0003616,-0.105147,-0.009935,0.000224,-0.000076,37,O +2020-04-25,58964,0.067108,0.429319,-0.2416852,0.0002295,-0.105079,-0.010187,0.000209,-0.000078,37,O +2020-04-26,58965,0.068444,0.430783,-0.2418475,0.0001213,-0.105079,-0.010365,0.000194,-0.000079,37,O +2020-04-27,58966,0.069374,0.431979,-0.2419828,0.0000962,-0.105206,-0.010515,0.000179,-0.000080,37,O +2020-04-28,58967,0.070651,0.432914,-0.2420713,0.0000758,-0.105389,-0.010653,0.000164,-0.000081,37,O +2020-04-29,58968,0.072257,0.433716,-0.2421323,0.0000576,-0.105433,-0.010721,0.000156,-0.000073,37,O +2020-04-30,58969,0.074184,0.434641,-0.2422391,0.0001523,-0.105249,-0.010705,0.000149,-0.000063,37,O +2020-05-01,58970,0.075876,0.435873,-0.2424745,0.0003425,-0.104877,-0.010695,0.000161,-0.000074,37,O +2020-05-02,58971,0.077588,0.436915,-0.2429170,0.0005860,-0.104504,-0.010735,0.000179,-0.000093,37,O +2020-05-03,58972,0.079720,0.438133,-0.2436308,0.0008396,-0.104236,-0.010751,0.000197,-0.000112,37,O +2020-05-04,58973,0.081539,0.439339,-0.2445748,0.0010690,-0.104164,-0.010635,0.000216,-0.000131,37,O +2020-05-05,58974,0.083001,0.440397,-0.2456700,0.0011321,-0.104431,-0.010443,0.000234,-0.000149,37,O +2020-05-06,58975,0.084371,0.441298,-0.2468040,0.0011108,-0.105097,-0.010359,0.000219,-0.000162,37,O +2020-05-07,58976,0.085880,0.442199,-0.2478448,0.0009728,-0.105809,-0.010446,0.000195,-0.000173,37,O +2020-05-08,58977,0.087577,0.442774,-0.2486936,0.0007462,-0.106198,-0.010544,0.000172,-0.000184,37,O +2020-05-09,58978,0.089488,0.443500,-0.2493145,0.0005172,-0.106130,-0.010504,0.000159,-0.000168,37,O +2020-05-10,58979,0.091613,0.444552,-0.2497270,0.0003195,-0.105757,-0.010452,0.000151,-0.000142,37,O +2020-05-11,58980,0.093236,0.445566,-0.2499850,0.0001858,-0.105356,-0.010560,0.000142,-0.000116,37,O +2020-05-12,58981,0.094612,0.446353,-0.2501641,0.0001770,-0.105189,-0.010778,0.000133,-0.000090,37,O +2020-05-13,58982,0.095989,0.446778,-0.2503571,0.0001767,-0.105297,-0.010922,0.000145,-0.000093,37,O +2020-05-14,58983,0.097182,0.446651,-0.2505619,0.0001941,-0.105516,-0.010861,0.000162,-0.000103,37,O +2020-05-15,58984,0.098876,0.446341,-0.2507604,0.0002778,-0.105536,-0.010690,0.000180,-0.000114,37,O +2020-05-16,58985,0.100314,0.446369,-0.2510803,0.0003654,-0.105365,-0.010536,0.000170,-0.000114,37,O +2020-05-17,58986,0.101760,0.446093,-0.2514781,0.0004799,-0.105227,-0.010422,0.000150,-0.000110,37,O +2020-05-18,58987,0.102987,0.446067,-0.2520116,0.0005811,-0.105372,-0.010272,0.000129,-0.000106,37,O +2020-05-19,58988,0.104425,0.445811,-0.2526084,0.0005937,-0.105774,-0.010077,0.000109,-0.000102,37,O +2020-05-20,58989,0.106126,0.445938,-0.2531595,0.0005169,-0.106129,-0.009951,0.000118,-0.000097,37,O +2020-05-21,58990,0.107451,0.446340,-0.2536215,0.0004139,-0.106311,-0.010015,0.000135,-0.000093,37,O +2020-05-22,58991,0.108276,0.446830,-0.2539584,0.0002708,-0.106320,-0.010248,0.000152,-0.000088,37,O +2020-05-23,58992,0.108413,0.447082,-0.2541455,0.0001033,-0.106287,-0.010513,0.000143,-0.000084,37,O +2020-05-24,58993,0.108453,0.446641,-0.2541522,-0.0000695,-0.106250,-0.010675,0.000125,-0.000079,37,O +2020-05-25,58994,0.108379,0.446015,-0.2540079,-0.0001838,-0.106292,-0.010717,0.000107,-0.000075,37,O +2020-05-26,58995,0.108296,0.445345,-0.2538363,-0.0002193,-0.106487,-0.010705,0.000089,-0.000071,37,O +2020-05-27,58996,0.109175,0.444412,-0.2536837,-0.0001520,-0.106744,-0.010711,0.000071,-0.000067,37,O +2020-05-28,58997,0.110181,0.443910,-0.2535569,-0.0000617,-0.106628,-0.010805,0.000132,-0.000121,37,O +2020-05-29,58998,0.110932,0.443391,-0.2535459,0.0000737,-0.106144,-0.010894,0.000213,-0.000191,37,O +2020-05-30,58999,0.112039,0.442888,-0.2537140,0.0002698,-0.105698,-0.010833,0.000211,-0.000201,37,O +2020-05-31,59000,0.113109,0.442390,-0.2540926,0.0004718,-0.105517,-0.010624,0.000177,-0.000189,37,O +2020-06-01,59001,0.114095,0.441605,-0.2546428,0.0006051,-0.105806,-0.010341,0.000144,-0.000176,37,O +2020-06-02,59002,0.115356,0.440965,-0.2552636,0.0005944,-0.106564,-0.010124,0.000111,-0.000164,37,O +2020-06-03,59003,0.116557,0.440577,-0.2558111,0.0004238,-0.107494,-0.010093,0.000078,-0.000152,37,O +2020-06-04,59004,0.117960,0.440275,-0.2561433,0.0001999,-0.108118,-0.010211,0.000086,-0.000144,37,O +2020-06-05,59005,0.119592,0.440373,-0.2562125,-0.0000442,-0.108296,-0.010303,0.000106,-0.000138,37,O +2020-06-06,59006,0.121341,0.440754,-0.2560362,-0.0002611,-0.108144,-0.010264,0.000109,-0.000129,37,O +2020-06-07,59007,0.123021,0.441349,-0.2556732,-0.0004235,-0.107813,-0.010194,0.000107,-0.000119,37,O +2020-06-08,59008,0.124214,0.441730,-0.2551905,-0.0005518,-0.107489,-0.010254,0.000105,-0.000109,37,O +2020-06-09,59009,0.125342,0.441604,-0.2546373,-0.0006060,-0.107342,-0.010451,0.000103,-0.000099,37,O +2020-06-10,59010,0.126901,0.441125,-0.2540253,-0.0006402,-0.107467,-0.010628,0.000098,-0.000095,37,O +2020-06-11,59011,0.128704,0.440696,-0.2533824,-0.0006234,-0.107782,-0.010652,0.000092,-0.000092,37,O +2020-06-12,59012,0.130552,0.440812,-0.2527082,-0.0006319,-0.107931,-0.010533,0.000145,-0.000061,37,O +2020-06-13,59013,0.132365,0.440839,-0.2520923,-0.0005984,-0.107880,-0.010403,0.000221,-0.000018,37,O +2020-06-14,59014,0.134367,0.440694,-0.2515698,-0.0004699,-0.107775,-0.010305,0.000297,0.000025,37,O +2020-06-15,59015,0.136361,0.440461,-0.2511455,-0.0003956,-0.107793,-0.010160,0.000373,0.000067,37,O +2020-06-16,59016,0.138330,0.439889,-0.2507551,-0.0004115,-0.107995,-0.009914,0.000449,0.000110,37,O +2020-06-17,59017,0.140357,0.439316,-0.2502728,-0.0004882,-0.108624,-0.009739,0.000386,0.000059,37,O +2020-06-18,59018,0.142486,0.438802,-0.2496915,-0.0006405,-0.109271,-0.009721,0.000287,-0.000016,37,O +2020-06-19,59019,0.144941,0.438049,-0.2490204,-0.0008280,-0.109762,-0.009922,0.000187,-0.000092,37,O +2020-06-20,59020,0.147096,0.437587,-0.2481020,-0.0010077,-0.109892,-0.010209,0.000161,-0.000111,37,O +2020-06-21,59021,0.149313,0.437067,-0.2470621,-0.0011348,-0.109828,-0.010443,0.000162,-0.000109,37,O +2020-06-22,59022,0.151173,0.436544,-0.2459006,-0.0011882,-0.109758,-0.010523,0.000163,-0.000107,37,O +2020-06-23,59023,0.152501,0.435847,-0.2447075,-0.0011609,-0.109810,-0.010469,0.000163,-0.000106,37,O +2020-06-24,59024,0.153957,0.435016,-0.2435776,-0.0010590,-0.109912,-0.010391,0.000191,-0.000102,37,O +2020-06-25,59025,0.155435,0.434459,-0.2426081,-0.0008700,-0.109954,-0.010382,0.000227,-0.000098,37,O +2020-06-26,59026,0.156934,0.433845,-0.2418658,-0.0006289,-0.109798,-0.010422,0.000262,-0.000094,37,O +2020-06-27,59027,0.158898,0.433340,-0.2413584,-0.0003980,-0.109615,-0.010420,0.000243,-0.000101,37,O +2020-06-28,59028,0.160843,0.432785,-0.2410263,-0.0002585,-0.109584,-0.010291,0.000203,-0.000111,37,O +2020-06-29,59029,0.162741,0.432243,-0.2408089,-0.0002157,-0.109921,-0.010075,0.000163,-0.000121,37,O +2020-06-30,59030,0.164819,0.432093,-0.2405730,-0.0003266,-0.110655,-0.009904,0.000123,-0.000131,37,O +2020-07-01,59031,0.166926,0.431645,-0.2401540,-0.0005330,-0.111450,-0.009888,0.000117,-0.000151,37,O +2020-07-02,59032,0.168557,0.431033,-0.2394930,-0.0007733,-0.112028,-0.009994,0.000119,-0.000173,37,O +2020-07-03,59033,0.170032,0.430055,-0.2386042,-0.0009919,-0.112198,-0.010092,0.000132,-0.000181,37,O +2020-07-04,59034,0.171560,0.428853,-0.2374976,-0.0011888,-0.112030,-0.010127,0.000148,-0.000184,37,O +2020-07-05,59035,0.173368,0.427397,-0.2362157,-0.0013336,-0.111724,-0.010151,0.000164,-0.000187,37,O +2020-07-06,59036,0.175553,0.426079,-0.2348932,-0.0013264,-0.111465,-0.010244,0.000180,-0.000190,37,O +2020-07-07,59037,0.177661,0.424849,-0.2336113,-0.0012547,-0.111360,-0.010402,0.000196,-0.000193,37,O +2020-07-08,59038,0.179613,0.423425,-0.2324088,-0.0011768,-0.111541,-0.010513,0.000173,-0.000177,37,O +2020-07-09,59039,0.181521,0.421864,-0.2312898,-0.0010791,-0.111915,-0.010521,0.000139,-0.000156,37,O +2020-07-10,59040,0.183418,0.420421,-0.2302231,-0.0009941,-0.112372,-0.010458,0.000106,-0.000136,37,O +2020-07-11,59041,0.185188,0.419417,-0.2292534,-0.0009766,-0.112718,-0.010414,0.000102,-0.000134,37,O +2020-07-12,59042,0.186700,0.418240,-0.2282505,-0.0010200,-0.112927,-0.010386,0.000108,-0.000140,37,O +2020-07-13,59043,0.187629,0.416964,-0.2272025,-0.0010697,-0.113074,-0.010296,0.000115,-0.000146,37,O +2020-07-14,59044,0.188400,0.415662,-0.2261191,-0.0011213,-0.113315,-0.010100,0.000121,-0.000152,37,O +2020-07-15,59045,0.189708,0.414695,-0.2249892,-0.0011788,-0.113730,-0.009860,0.000130,-0.000152,37,O +2020-07-16,59046,0.190936,0.413918,-0.2237845,-0.0012457,-0.114237,-0.009729,0.000140,-0.000152,37,O +2020-07-17,59047,0.192195,0.412935,-0.2224785,-0.0013164,-0.114632,-0.009814,0.000149,-0.000151,37,O +2020-07-18,59048,0.193260,0.411933,-0.2211074,-0.0014070,-0.114762,-0.010090,0.000159,-0.000153,37,O +2020-07-19,59049,0.193896,0.410755,-0.2196918,-0.0014663,-0.114658,-0.010407,0.000169,-0.000156,37,O +2020-07-20,59050,0.194356,0.409458,-0.2182373,-0.0014190,-0.114471,-0.010603,0.000178,-0.000159,37,O +2020-07-21,59051,0.194688,0.408238,-0.2168640,-0.0012724,-0.114312,-0.010608,0.000188,-0.000162,37,O +2020-07-22,59052,0.195127,0.406704,-0.2156688,-0.0010646,-0.114300,-0.010469,0.000163,-0.000153,37,O +2020-07-23,59053,0.195548,0.405185,-0.2147063,-0.0008562,-0.114364,-0.010330,0.000128,-0.000142,37,O +2020-07-24,59054,0.196360,0.403989,-0.2139791,-0.0006416,-0.114489,-0.010293,0.000093,-0.000131,37,O +2020-07-25,59055,0.197205,0.402836,-0.2134367,-0.0005213,-0.114568,-0.010346,0.000106,-0.000123,37,O +2020-07-26,59056,0.197779,0.401664,-0.2129757,-0.0004897,-0.114673,-0.010390,0.000136,-0.000117,37,O +2020-07-27,59057,0.198067,0.400506,-0.2124662,-0.0005643,-0.114849,-0.010349,0.000167,-0.000110,37,O +2020-07-28,59058,0.198139,0.399287,-0.2118373,-0.0006872,-0.115111,-0.010246,0.000198,-0.000103,37,O +2020-07-29,59059,0.198581,0.398202,-0.2110818,-0.0008293,-0.115556,-0.010138,0.000183,-0.000082,37,O +2020-07-30,59060,0.199254,0.397133,-0.2101850,-0.0009562,-0.115989,-0.010075,0.000157,-0.000056,37,O +2020-07-31,59061,0.199858,0.395993,-0.2091724,-0.0010540,-0.116238,-0.010062,0.000130,-0.000031,37,O +2020-08-01,59062,0.200916,0.394791,-0.2081196,-0.0010540,-0.116211,-0.010102,0.000112,-0.000013,37,O +2020-08-02,59063,0.202618,0.394109,-0.2070472,-0.0010157,-0.116010,-0.010194,0.000097,0.000003,37,O +2020-08-03,59064,0.203857,0.393712,-0.2060676,-0.0009380,-0.115823,-0.010311,0.000082,0.000018,37,O +2020-08-04,59065,0.204978,0.393256,-0.2052248,-0.0007909,-0.115773,-0.010378,0.000066,0.000034,37,O +2020-08-05,59066,0.206149,0.392575,-0.2044963,-0.0006824,-0.115805,-0.010356,0.000077,0.000022,37,O +2020-08-06,59067,0.207131,0.391715,-0.2038968,-0.0005592,-0.115946,-0.010242,0.000094,0.000003,37,O +2020-08-07,59068,0.207997,0.390904,-0.2034232,-0.0004263,-0.116174,-0.010128,0.000111,-0.000016,37,O +2020-08-08,59069,0.208823,0.389508,-0.2030598,-0.0003350,-0.116395,-0.010086,0.000127,-0.000032,37,O +2020-08-09,59070,0.209912,0.388019,-0.2027319,-0.0003316,-0.116470,-0.010089,0.000143,-0.000047,37,O +2020-08-10,59071,0.210987,0.386680,-0.2023438,-0.0004217,-0.116390,-0.010053,0.000159,-0.000062,37,O +2020-08-11,59072,0.212000,0.385344,-0.2018452,-0.0005731,-0.116368,-0.009950,0.000175,-0.000077,37,O +2020-08-12,59073,0.213138,0.383934,-0.2012087,-0.0007229,-0.116651,-0.009858,0.000191,-0.000092,37,O +2020-08-13,59074,0.214369,0.382229,-0.2004326,-0.0008567,-0.117224,-0.009878,0.000195,-0.000106,37,O +2020-08-14,59075,0.215208,0.380501,-0.1995089,-0.0009856,-0.117713,-0.010037,0.000195,-0.000120,37,O +2020-08-15,59076,0.215710,0.379116,-0.1984422,-0.0010961,-0.117813,-0.010280,0.000192,-0.000136,37,O +2020-08-16,59077,0.216181,0.377875,-0.1972937,-0.0011496,-0.117568,-0.010520,0.000187,-0.000152,37,O +2020-08-17,59078,0.216815,0.377092,-0.1961824,-0.0010903,-0.117230,-0.010677,0.000183,-0.000169,37,O +2020-08-18,59079,0.217198,0.376427,-0.1951499,-0.0009586,-0.116952,-0.010677,0.000179,-0.000185,37,O +2020-08-19,59080,0.217097,0.375794,-0.1942910,-0.0007516,-0.116736,-0.010502,0.000174,-0.000201,37,O +2020-08-20,59081,0.216740,0.374898,-0.1936905,-0.0004787,-0.116528,-0.010230,0.000208,-0.000180,37,O +2020-08-21,59082,0.216769,0.373565,-0.1933538,-0.0002135,-0.116516,-0.010083,0.000253,-0.000149,37,O +2020-08-22,59083,0.216932,0.371778,-0.1932222,-0.0000596,-0.116944,-0.010170,0.000217,-0.000130,37,O +2020-08-23,59084,0.217580,0.370054,-0.1931667,-0.0000789,-0.117518,-0.010359,0.000151,-0.000115,37,O +2020-08-24,59085,0.218417,0.368646,-0.1930381,-0.0002268,-0.117966,-0.010456,0.000086,-0.000100,37,O +2020-08-25,59086,0.218821,0.367280,-0.1927121,-0.0004572,-0.118246,-0.010403,0.000021,-0.000085,37,O +2020-08-26,59087,0.218848,0.366011,-0.1921170,-0.0007332,-0.118255,-0.010302,0.000038,-0.000090,37,O +2020-08-27,59088,0.218568,0.364900,-0.1912433,-0.0009788,-0.118249,-0.010225,0.000077,-0.000101,37,O +2020-08-28,59089,0.218460,0.363753,-0.1901406,-0.0011675,-0.118258,-0.010195,0.000116,-0.000111,37,O +2020-08-29,59090,0.218163,0.363164,-0.1888889,-0.0012589,-0.118188,-0.010207,0.000142,-0.000102,37,O +2020-08-30,59091,0.217507,0.362331,-0.1876041,-0.0012675,-0.117952,-0.010281,0.000164,-0.000086,37,O +2020-08-31,59092,0.216816,0.361537,-0.1864039,-0.0011495,-0.117634,-0.010374,0.000185,-0.000069,37,O +2020-09-01,59093,0.215870,0.360680,-0.1853447,-0.0009829,-0.117380,-0.010369,0.000206,-0.000053,37,O +2020-09-02,59094,0.214888,0.359360,-0.1844359,-0.0008078,-0.117277,-0.010199,0.000218,-0.000059,37,O +2020-09-03,59095,0.214008,0.357869,-0.1836718,-0.0006993,-0.117281,-0.009905,0.000228,-0.000071,37,O +2020-09-04,59096,0.213234,0.356016,-0.1830210,-0.0006290,-0.117339,-0.009656,0.000237,-0.000082,37,O +2020-09-05,59097,0.212795,0.354430,-0.1824364,-0.0005731,-0.117410,-0.009573,0.000230,-0.000085,37,O +2020-09-06,59098,0.212274,0.353191,-0.1818721,-0.0005450,-0.117361,-0.009619,0.000217,-0.000084,37,O +2020-09-07,59099,0.211790,0.351835,-0.1812925,-0.0005934,-0.117172,-0.009671,0.000204,-0.000084,37,O +2020-09-08,59100,0.211193,0.350339,-0.1806562,-0.0006743,-0.117062,-0.009686,0.000191,-0.000083,37,O +2020-09-09,59101,0.210918,0.349451,-0.1799467,-0.0007776,-0.117306,-0.009743,0.000178,-0.000082,37,O +2020-09-10,59102,0.210855,0.348811,-0.1791721,-0.0008106,-0.117945,-0.009884,0.000137,-0.000059,37,O +2020-09-11,59103,0.210933,0.348368,-0.1783511,-0.0007954,-0.118497,-0.010053,0.000090,-0.000029,37,O +2020-09-12,59104,0.210314,0.347629,-0.1775178,-0.0007983,-0.118447,-0.010143,0.000085,-0.000019,37,O +2020-09-13,59105,0.209427,0.346406,-0.1767408,-0.0007225,-0.117930,-0.010102,0.000097,-0.000017,37,O +2020-09-14,59106,0.208717,0.345499,-0.1761147,-0.0005314,-0.117381,-0.009988,0.000108,-0.000014,37,O +2020-09-15,59107,0.208051,0.344156,-0.1757085,-0.0002763,-0.117022,-0.009833,0.000120,-0.000012,37,O +2020-09-16,59108,0.207856,0.342757,-0.1755535,-0.0000032,-0.116945,-0.009617,0.000082,-0.000038,37,O +2020-09-17,59109,0.207763,0.341482,-0.1756637,0.0002120,-0.117040,-0.009366,0.000030,-0.000071,37,O +2020-09-18,59110,0.207499,0.340031,-0.1759844,0.0003569,-0.117335,-0.009280,-0.000021,-0.000104,37,O +2020-09-19,59111,0.206755,0.338625,-0.1764092,0.0004253,-0.117637,-0.009464,-0.000017,-0.000110,37,O +2020-09-20,59112,0.205778,0.337224,-0.1767967,0.0003203,-0.117831,-0.009763,0.000009,-0.000106,37,O +2020-09-21,59113,0.204647,0.335988,-0.1770190,0.0001175,-0.117862,-0.009894,0.000034,-0.000102,37,O +2020-09-22,59114,0.203448,0.334984,-0.1770237,-0.0001062,-0.117782,-0.009802,0.000059,-0.000097,37,O +2020-09-23,59115,0.202369,0.333990,-0.1768324,-0.0002892,-0.117806,-0.009680,0.000033,-0.000089,37,O +2020-09-24,59116,0.201447,0.333000,-0.1764820,-0.0004005,-0.117893,-0.009670,-0.000006,-0.000079,37,O +2020-09-25,59117,0.200100,0.331835,-0.1760287,-0.0004429,-0.118024,-0.009719,-0.000045,-0.000069,37,O +2020-09-26,59118,0.198705,0.330548,-0.1755265,-0.0004754,-0.117994,-0.009700,-0.000024,-0.000032,37,O +2020-09-27,59119,0.197236,0.329251,-0.1750164,-0.0005323,-0.117779,-0.009640,0.000020,0.000015,37,O +2020-09-28,59120,0.196127,0.327949,-0.1745224,-0.0005057,-0.117408,-0.009587,0.000063,0.000062,37,O +2020-09-29,59121,0.195040,0.326608,-0.1740769,-0.0003921,-0.116991,-0.009492,0.000107,0.000108,37,O +2020-09-30,59122,0.194222,0.325303,-0.1737113,-0.0002857,-0.116712,-0.009323,0.000132,0.000080,37,O +2020-10-01,59123,0.193592,0.324399,-0.1734352,-0.0002262,-0.116558,-0.009037,0.000152,0.000032,37,O +2020-10-02,59124,0.192652,0.323725,-0.1732413,-0.0001769,-0.116447,-0.008783,0.000171,-0.000016,37,O +2020-10-03,59125,0.191328,0.322856,-0.1731044,-0.0001385,-0.116377,-0.008683,0.000158,-0.000014,37,O +2020-10-04,59126,0.190376,0.321580,-0.1729735,-0.0001437,-0.116249,-0.008755,0.000132,0.000006,37,O +2020-10-05,59127,0.190057,0.320101,-0.1727946,-0.0002063,-0.116057,-0.008872,0.000106,0.000026,37,O +2020-10-06,59128,0.189565,0.319194,-0.1725157,-0.0003291,-0.115950,-0.008947,0.000080,0.000046,37,O +2020-10-07,59129,0.188477,0.318544,-0.1720944,-0.0004769,-0.116058,-0.009059,0.000075,0.000044,37,O +2020-10-08,59130,0.187213,0.317589,-0.1715545,-0.0005752,-0.116402,-0.009250,0.000075,0.000036,37,O +2020-10-09,59131,0.185866,0.316267,-0.1709438,-0.0006027,-0.116661,-0.009422,0.000075,0.000028,37,O +2020-10-10,59132,0.184598,0.314938,-0.1703470,-0.0005638,-0.116474,-0.009397,0.000081,0.000028,37,O +2020-10-11,59133,0.183096,0.313821,-0.1698266,-0.0004507,-0.115905,-0.009145,0.000089,0.000030,37,O +2020-10-12,59134,0.181364,0.312491,-0.1694229,-0.0002698,-0.115345,-0.008820,0.000096,0.000032,37,O +2020-10-13,59135,0.180150,0.311276,-0.1692873,0.0000023,-0.115042,-0.008554,0.000104,0.000034,37,O +2020-10-14,59136,0.179028,0.310496,-0.1694783,0.0003013,-0.114958,-0.008314,0.000112,0.000036,37,O +2020-10-15,59137,0.178273,0.309566,-0.1699480,0.0005931,-0.114992,-0.008083,0.000131,0.000024,37,O +2020-10-16,59138,0.177870,0.308850,-0.1706403,0.0007682,-0.115149,-0.008005,0.000152,0.000008,37,O +2020-10-17,59139,0.177728,0.308173,-0.1714530,0.0007984,-0.115386,-0.008208,0.000134,0.000009,37,O +2020-10-18,59140,0.177883,0.307413,-0.1722056,0.0006699,-0.115413,-0.008528,0.000102,0.000015,37,O +2020-10-19,59141,0.177193,0.306640,-0.1727351,0.0003985,-0.115221,-0.008621,0.000069,0.000022,37,O +2020-10-20,59142,0.175829,0.305561,-0.1730135,0.0001477,-0.115069,-0.008425,0.000037,0.000029,37,O +2020-10-21,59143,0.174443,0.304709,-0.1731105,0.0000250,-0.114600,-0.008189,0.000201,0.000094,37,O +2020-10-22,59144,0.173243,0.304010,-0.1731120,0.0000231,-0.114500,-0.008238,0.000249,0.000130,37,O +2020-10-23,59145,0.172122,0.303220,-0.1731129,0.0000584,-0.114516,-0.008427,0.000248,0.000152,37,O +2020-10-24,59146,0.170979,0.302398,-0.1731915,0.0001102,-0.114565,-0.008525,0.000236,0.000123,37,O +2020-10-25,59147,0.169567,0.301498,-0.1733234,0.0001512,-0.114587,-0.008447,0.000219,0.000074,37,O +2020-10-26,59148,0.168213,0.300588,-0.1735104,0.0002021,-0.114466,-0.008323,0.000203,0.000025,37,O +2020-10-27,59149,0.167025,0.299828,-0.1737708,0.0003055,-0.114237,-0.008249,0.000186,-0.000024,37,O +2020-10-28,59150,0.165274,0.299221,-0.1741049,0.0003277,-0.113945,-0.008074,0.000210,0.000012,37,O +2020-10-29,59151,0.163658,0.298406,-0.1744617,0.0003476,-0.113743,-0.007783,0.000245,0.000070,37,O +2020-10-30,59152,0.162242,0.298257,-0.1747434,0.0003315,-0.113588,-0.007469,0.000280,0.000128,37,O +2020-10-31,59153,0.160455,0.297779,-0.1750666,0.0002816,-0.113483,-0.007338,0.000277,0.000138,37,O +2020-11-01,59154,0.158546,0.297059,-0.1753208,0.0002180,-0.113363,-0.007412,0.000261,0.000131,37,O +2020-11-02,59155,0.156760,0.296584,-0.1754892,0.0001127,-0.113250,-0.007572,0.000244,0.000123,37,O +2020-11-03,59156,0.155022,0.296077,-0.1755506,-0.0000052,-0.113186,-0.007698,0.000228,0.000116,37,O +2020-11-04,59157,0.153756,0.295403,-0.1755009,-0.0001017,-0.113206,-0.007789,0.000211,0.000109,37,O +2020-11-05,59158,0.153116,0.294628,-0.1753222,-0.0002389,-0.113449,-0.007880,0.000133,0.000118,37,O +2020-11-06,59159,0.152204,0.293485,-0.1750506,-0.0003217,-0.113690,-0.007949,0.000038,0.000132,37,O +2020-11-07,59160,0.150933,0.292707,-0.1747265,-0.0002549,-0.113428,-0.007918,0.000064,0.000114,37,O +2020-11-08,59161,0.149316,0.292406,-0.1745355,-0.0000783,-0.112854,-0.007723,0.000133,0.000085,37,O +2020-11-09,59162,0.147825,0.292052,-0.1745810,0.0001968,-0.112271,-0.007463,0.000203,0.000056,37,O +2020-11-10,59163,0.146154,0.291593,-0.1748950,0.0004636,-0.111866,-0.007260,0.000272,0.000027,37,O +2020-11-11,59164,0.144139,0.291248,-0.1754908,0.0006676,-0.111856,-0.007082,0.000264,0.000019,37,O +2020-11-12,59165,0.142123,0.290642,-0.1762784,0.0008387,-0.112077,-0.006888,0.000236,0.000017,37,O +2020-11-13,59166,0.140177,0.290279,-0.1771548,0.0008941,-0.112454,-0.006778,0.000208,0.000015,37,O +2020-11-14,59167,0.137794,0.289624,-0.1779689,0.0007757,-0.112856,-0.006893,0.000162,0.000020,37,O +2020-11-15,59168,0.135204,0.288983,-0.1786182,0.0005395,-0.112982,-0.007138,0.000109,0.000029,37,O +2020-11-16,59169,0.132881,0.288419,-0.1790137,0.0002432,-0.112780,-0.007208,0.000057,0.000038,37,O +2020-11-17,59170,0.130805,0.288003,-0.1791225,-0.0000384,-0.112539,-0.006999,0.000004,0.000047,37,O +2020-11-18,59171,0.129000,0.287331,-0.1790233,-0.0002270,-0.112275,-0.006789,0.000028,0.000053,37,O +2020-11-19,59172,0.127530,0.286787,-0.1787553,-0.0002633,-0.112062,-0.006858,0.000073,0.000058,37,O +2020-11-20,59173,0.126286,0.286684,-0.1784481,-0.0002468,-0.111851,-0.007106,0.000118,0.000063,37,O +2020-11-21,59174,0.125104,0.286777,-0.1781848,-0.0001944,-0.111756,-0.007212,0.000137,0.000062,37,O +2020-11-22,59175,0.124481,0.286278,-0.1780687,-0.0000424,-0.111769,-0.007037,0.000147,0.000060,37,O +2020-11-23,59176,0.124228,0.286214,-0.1781330,0.0001506,-0.111766,-0.006754,0.000157,0.000058,37,O +2020-11-24,59177,0.123617,0.286438,-0.1783447,0.0002542,-0.111679,-0.006573,0.000167,0.000055,37,O +2020-11-25,59178,0.122556,0.286916,-0.1786339,0.0002858,-0.111583,-0.006497,0.000177,0.000053,37,O +2020-11-26,59179,0.120973,0.287505,-0.1789614,0.0002630,-0.111632,-0.006331,0.000156,0.000114,37,O +2020-11-27,59180,0.118868,0.287888,-0.1791698,0.0001765,-0.111714,-0.006069,0.000126,0.000192,37,O +2020-11-28,59181,0.116181,0.288266,-0.1793065,0.0000654,-0.111727,-0.005913,0.000098,0.000193,37,O +2020-11-29,59182,0.113478,0.288418,-0.1792998,-0.0000570,-0.111707,-0.005939,0.000071,0.000165,37,O +2020-11-30,59183,0.110735,0.288608,-0.1792037,-0.0001561,-0.111732,-0.006110,0.000045,0.000137,37,O +2020-12-01,59184,0.108321,0.288148,-0.1790069,-0.0002546,-0.111780,-0.006317,0.000018,0.000108,37,O +2020-12-02,59185,0.106317,0.287572,-0.1787175,-0.0003630,-0.111655,-0.006507,0.000023,0.000041,37,O +2020-12-03,59186,0.104638,0.287348,-0.1783211,-0.0004220,-0.111381,-0.006645,0.000037,-0.000038,37,O +2020-12-04,59187,0.102958,0.287742,-0.1779212,-0.0003645,-0.111061,-0.006741,0.000051,-0.000116,37,O +2020-12-05,59188,0.101346,0.288801,-0.1776326,-0.0001936,-0.110793,-0.006736,0.000055,-0.000130,37,O +2020-12-06,59189,0.099422,0.289616,-0.1775418,-0.0000216,-0.110546,-0.006660,0.000056,-0.000121,37,O +2020-12-07,59190,0.097392,0.289604,-0.1776428,0.0002074,-0.110294,-0.006554,0.000056,-0.000112,37,O +2020-12-08,59191,0.095366,0.289667,-0.1779633,0.0004263,-0.110093,-0.006435,0.000056,-0.000103,37,O +2020-12-09,59192,0.093289,0.289586,-0.1785100,0.0005628,-0.109973,-0.006283,0.000086,-0.000091,37,O +2020-12-10,59193,0.091596,0.289267,-0.1791348,0.0006352,-0.110077,-0.006091,0.000123,-0.000078,37,O +2020-12-11,59194,0.090377,0.289317,-0.1797372,0.0005418,-0.110411,-0.005942,0.000160,-0.000065,37,O +2020-12-12,59195,0.089352,0.289933,-0.1801889,0.0003407,-0.110951,-0.005944,0.000137,-0.000041,37,O +2020-12-13,59196,0.088122,0.291099,-0.1803980,0.0000936,-0.111333,-0.006074,0.000092,-0.000014,37,O +2020-12-14,59197,0.086753,0.292095,-0.1803677,-0.0001487,-0.111383,-0.006136,0.000047,0.000013,37,O +2020-12-15,59198,0.085413,0.292842,-0.1801153,-0.0003569,-0.111225,-0.006017,0.000002,0.000041,37,O +2020-12-16,59199,0.084102,0.293335,-0.1797032,-0.0004950,-0.110928,-0.005931,-0.000003,0.000002,37,O +2020-12-17,59200,0.082931,0.293953,-0.1792128,-0.0004784,-0.110605,-0.006042,0.000002,-0.000053,37,O +2020-12-18,59201,0.082113,0.294634,-0.1787692,-0.0003551,-0.110288,-0.006303,0.000007,-0.000109,37,O +2020-12-19,59202,0.081252,0.294893,-0.1784509,-0.0002153,-0.109970,-0.006405,0.000055,-0.000102,37,O +2020-12-20,59203,0.080081,0.295269,-0.1783092,-0.0000815,-0.109817,-0.006241,0.000117,-0.000072,37,O +2020-12-21,59204,0.078855,0.295467,-0.1782871,0.0000540,-0.109810,-0.005948,0.000179,-0.000042,37,O +2020-12-22,59205,0.077844,0.295794,-0.1783855,0.0001406,-0.109823,-0.005736,0.000242,-0.000012,37,O +2020-12-23,59206,0.077211,0.296035,-0.1785628,0.0001221,-0.110230,-0.005520,0.000137,0.000157,37,O +2020-12-24,59207,0.077016,0.296473,-0.1786707,0.0000410,-0.110488,-0.005418,0.000076,0.000222,37,O +2020-12-25,59208,0.076715,0.297267,-0.1786670,-0.0000506,-0.110595,-0.005267,0.000046,0.000236,37,O +2020-12-26,59209,0.076045,0.297941,-0.1785195,-0.0002103,-0.110611,-0.005079,0.000016,0.000244,37,O +2020-12-27,59210,0.075038,0.298659,-0.1782183,-0.0003764,-0.110613,-0.005004,-0.000014,0.000256,37,O +2020-12-28,59211,0.074030,0.299926,-0.1777849,-0.0004947,-0.110694,-0.005136,-0.000043,0.000267,37,O +2020-12-29,59212,0.072622,0.301626,-0.1772430,-0.0005595,-0.110809,-0.005395,-0.000073,0.000279,37,O +2020-12-30,59213,0.071147,0.302690,-0.1766472,-0.0006211,-0.110613,-0.005732,-0.000035,0.000180,37,O +2020-12-31,59214,0.069721,0.303116,-0.1760010,-0.0006564,-0.110185,-0.005874,0.000003,0.000133,37,O +2021-01-01,59215,0.068685,0.304111,-0.1753710,-0.0005759,-0.109655,-0.005849,0.000035,0.000126,37,O +2021-01-02,59216,0.067783,0.305455,-0.1748394,-0.0004419,-0.109207,-0.005801,0.000066,0.000106,37,O +2021-01-03,59217,0.066068,0.306714,-0.1744761,-0.0002389,-0.108905,-0.005785,0.000098,0.000096,37,O +2021-01-04,59218,0.063906,0.307809,-0.1743246,-0.0000472,-0.108696,-0.005813,0.000129,0.000081,37,O +2021-01-05,59219,0.061685,0.308623,-0.1743819,0.0001362,-0.108543,-0.005819,0.000161,0.000066,37,O +2021-01-06,59220,0.060391,0.309503,-0.1746023,0.0002499,-0.108462,-0.005682,0.000217,0.000116,37,O +2021-01-07,59221,0.059466,0.310304,-0.1748751,0.0002552,-0.108581,-0.005465,0.000280,0.000183,37,O +2021-01-08,59222,0.059005,0.311054,-0.1750757,0.0001439,-0.108877,-0.005272,0.000343,0.000250,37,O +2021-01-09,59223,0.058270,0.311975,-0.1750823,-0.0000968,-0.109379,-0.005255,0.000324,0.000250,37,O +2021-01-10,59224,0.058057,0.313002,-0.1748654,-0.0003119,-0.109768,-0.005367,0.000274,0.000224,37,O +2021-01-11,59225,0.057636,0.314178,-0.1744765,-0.0004727,-0.109894,-0.005482,0.000223,0.000197,37,O +2021-01-12,59226,0.057033,0.314438,-0.1739724,-0.0005349,-0.109829,-0.005535,0.000172,0.000171,37,O +2021-01-13,59227,0.056028,0.315487,-0.1734272,-0.0005343,-0.109447,-0.005630,0.000217,0.000094,37,O +2021-01-14,59228,0.054873,0.316051,-0.1729081,-0.0004820,-0.108989,-0.005827,0.000286,0.000003,37,O +2021-01-15,59229,0.054335,0.316875,-0.1724606,-0.0004365,-0.108538,-0.006095,0.000356,-0.000087,37,O +2021-01-16,59230,0.053758,0.317833,-0.1721004,-0.0003468,-0.108364,-0.006182,0.000345,-0.000055,37,O +2021-01-17,59231,0.052962,0.318726,-0.1718081,-0.0002251,-0.108437,-0.006069,0.000302,0.000023,37,O +2021-01-18,59232,0.052474,0.319502,-0.1715790,-0.0001821,-0.108695,-0.005857,0.000261,0.000101,37,O +2021-01-19,59233,0.052506,0.319950,-0.1714126,-0.0001740,-0.109065,-0.005677,0.000219,0.000179,37,O +2021-01-20,59234,0.052837,0.320909,-0.1712427,-0.0001911,-0.109276,-0.005676,0.000232,0.000156,37,O +2021-01-21,59235,0.052498,0.321943,-0.1710484,-0.0002353,-0.109337,-0.005703,0.000259,0.000108,37,O +2021-01-22,59236,0.052370,0.323115,-0.1707975,-0.0002896,-0.109257,-0.005649,0.000287,0.000060,37,O +2021-01-23,59237,0.052397,0.324238,-0.1704758,-0.0004014,-0.109168,-0.005506,0.000284,0.000056,37,O +2021-01-24,59238,0.051888,0.325635,-0.1700327,-0.0005333,-0.109121,-0.005441,0.000269,0.000069,37,O +2021-01-25,59239,0.050946,0.327158,-0.1694247,-0.0006595,-0.109156,-0.005578,0.000255,0.000083,37,O +2021-01-26,59240,0.050305,0.328651,-0.1687165,-0.0007026,-0.109246,-0.005884,0.000241,0.000096,37,O +2021-01-27,59241,0.050009,0.330496,-0.1680026,-0.0006860,-0.109141,-0.006231,0.000276,0.000078,37,O +2021-01-28,59242,0.049854,0.332424,-0.1673675,-0.0005433,-0.108815,-0.006433,0.000324,0.000051,37,O +2021-01-29,59243,0.049925,0.334359,-0.1669073,-0.0003382,-0.108303,-0.006429,0.000372,0.000024,37,O +2021-01-30,59244,0.049593,0.336126,-0.1666565,-0.0001087,-0.107958,-0.006281,0.000334,0.000020,37,O +2021-01-31,59245,0.049315,0.337874,-0.1666887,0.0001728,-0.107833,-0.006144,0.000261,0.000024,37,O +2021-02-01,59246,0.049420,0.339866,-0.1670204,0.0004253,-0.107947,-0.006114,0.000188,0.000028,37,O +2021-02-02,59247,0.049490,0.341692,-0.1675614,0.0006019,-0.108292,-0.006165,0.000115,0.000032,37,O +2021-02-03,59248,0.049274,0.343178,-0.1681920,0.0006439,-0.108630,-0.006177,0.000107,0.000061,37,O +2021-02-04,59249,0.049231,0.344351,-0.1688000,0.0005490,-0.108983,-0.006111,0.000117,0.000097,37,O +2021-02-05,59250,0.049262,0.345628,-0.1692802,0.0003550,-0.109304,-0.006001,0.000126,0.000132,37,O +2021-02-06,59251,0.049156,0.346983,-0.1696139,0.0001374,-0.109483,-0.005921,0.000140,0.000158,37,O +2021-02-07,59252,0.049075,0.348358,-0.1696850,-0.0000406,-0.109454,-0.005901,0.000156,0.000180,37,O +2021-02-08,59253,0.049311,0.349885,-0.1694924,-0.0001406,-0.109221,-0.005926,0.000172,0.000202,37,O +2021-02-09,59254,0.049922,0.351343,-0.1693373,-0.0001271,-0.108874,-0.005989,0.000188,0.000224,37,O +2021-02-10,59255,0.050607,0.352626,-0.1692436,-0.0000444,-0.108510,-0.006178,0.000222,0.000170,37,O +2021-02-11,59256,0.051207,0.353801,-0.1692657,0.0000908,-0.108257,-0.006433,0.000261,0.000095,37,O +2021-02-12,59257,0.051383,0.354941,-0.1694090,0.0002396,-0.108111,-0.006679,0.000301,0.000020,37,O +2021-02-13,59258,0.051474,0.355706,-0.1697045,0.0004123,-0.108084,-0.006767,0.000308,0.000024,37,O +2021-02-14,59259,0.051922,0.356756,-0.1701305,0.0005143,-0.108104,-0.006728,0.000302,0.000059,37,O +2021-02-15,59260,0.051716,0.358143,-0.1706473,0.0005197,-0.108193,-0.006652,0.000296,0.000095,37,O +2021-02-16,59261,0.050949,0.359283,-0.1711965,0.0004778,-0.108366,-0.006610,0.000290,0.000131,37,O +2021-02-17,59262,0.050326,0.360338,-0.1716669,0.0003633,-0.108536,-0.006606,0.000284,0.000166,37,O +2021-02-18,59263,0.050378,0.361154,-0.1719511,0.0001677,-0.108669,-0.006586,0.000247,0.000200,37,O +2021-02-19,59264,0.050885,0.361987,-0.1720228,-0.0000263,-0.108704,-0.006521,0.000202,0.000234,37,O +2021-02-20,59265,0.051501,0.363070,-0.1719007,-0.0002145,-0.108603,-0.006534,0.000198,0.000191,37,O +2021-02-21,59266,0.051463,0.363914,-0.1715820,-0.0004374,-0.108490,-0.006656,0.000209,0.000120,37,O +2021-02-22,59267,0.050700,0.364562,-0.1710795,-0.0005628,-0.108387,-0.006899,0.000219,0.000048,37,O +2021-02-23,59268,0.049836,0.365309,-0.1704677,-0.0006244,-0.108274,-0.007237,0.000230,-0.000023,37,O +2021-02-24,59269,0.049396,0.365588,-0.1698548,-0.0005855,-0.108271,-0.007557,0.000207,-0.000047,37,O +2021-02-25,59270,0.049801,0.366059,-0.1693475,-0.0003937,-0.108285,-0.007804,0.000174,-0.000058,37,O +2021-02-26,59271,0.050306,0.367069,-0.1690477,-0.0001387,-0.108145,-0.007894,0.000142,-0.000069,37,O +2021-02-27,59272,0.050431,0.368528,-0.1690351,0.0001377,-0.107687,-0.007757,0.000151,-0.000054,37,O +2021-02-28,59273,0.050498,0.370227,-0.1693081,0.0003809,-0.107188,-0.007498,0.000176,-0.000029,37,O +2021-03-01,59274,0.050616,0.371982,-0.1697877,0.0005501,-0.107024,-0.007321,0.000201,-0.000004,37,O +2021-03-02,59275,0.050706,0.373771,-0.1703934,0.0006476,-0.107298,-0.007344,0.000226,0.000022,37,O +2021-03-03,59276,0.050584,0.375262,-0.1710261,0.0006133,-0.107867,-0.007504,0.000212,0.000040,37,O +2021-03-04,59277,0.051059,0.376549,-0.1715540,0.0004339,-0.108333,-0.007617,0.000188,0.000057,37,O +2021-03-05,59278,0.052201,0.377870,-0.1718838,0.0001699,-0.108535,-0.007596,0.000164,0.000073,37,O +2021-03-06,59279,0.053360,0.379379,-0.1719881,-0.0000526,-0.108484,-0.007535,0.000164,0.000048,37,O +2021-03-07,59280,0.054561,0.380833,-0.1718731,-0.0001992,-0.108315,-0.007503,0.000173,0.000007,37,O +2021-03-08,59281,0.056191,0.382351,-0.1716080,-0.0002890,-0.108062,-0.007541,0.000183,-0.000033,37,O +2021-03-09,59282,0.057662,0.383909,-0.1713243,-0.0002599,-0.107722,-0.007670,0.000192,-0.000074,37,O +2021-03-10,59283,0.058750,0.385265,-0.1710993,-0.0001499,-0.107375,-0.007862,0.000200,-0.000097,37,O +2021-03-11,59284,0.059621,0.386346,-0.1710012,-0.0000302,-0.107167,-0.008064,0.000207,-0.000115,37,O +2021-03-12,59285,0.060542,0.387744,-0.1710599,0.0001393,-0.107158,-0.008179,0.000214,-0.000132,37,O +2021-03-13,59286,0.061723,0.389349,-0.1712387,0.0002694,-0.107228,-0.008103,0.000230,-0.000102,37,O +2021-03-14,59287,0.063046,0.391028,-0.1715574,0.0003398,-0.107262,-0.007921,0.000248,-0.000055,37,O +2021-03-15,59288,0.064331,0.392504,-0.1719515,0.0003290,-0.107234,-0.007783,0.000267,-0.000007,37,O +2021-03-16,59289,0.065375,0.394218,-0.1722335,0.0002248,-0.107189,-0.007770,0.000286,0.000040,37,O +2021-03-17,59290,0.065657,0.395943,-0.1724026,0.0000715,-0.107206,-0.007877,0.000272,0.000050,37,O +2021-03-18,59291,0.065853,0.397460,-0.1724204,-0.0000538,-0.107183,-0.007985,0.000249,0.000049,37,O +2021-03-19,59292,0.066235,0.398938,-0.1722871,-0.0001722,-0.107132,-0.008061,0.000226,0.000048,37,O +2021-03-20,59293,0.066580,0.400421,-0.1720284,-0.0003318,-0.107100,-0.008160,0.000219,0.000055,37,O +2021-03-21,59294,0.067507,0.401767,-0.1716900,-0.0003582,-0.107085,-0.008324,0.000218,0.000065,37,O +2021-03-22,59295,0.068766,0.403525,-0.1713132,-0.0003644,-0.106944,-0.008502,0.000218,0.000075,37,O +2021-03-23,59296,0.070017,0.405095,-0.1709575,-0.0003337,-0.106635,-0.008631,0.000217,0.000085,37,O +2021-03-24,59297,0.071509,0.406504,-0.1706787,-0.0002430,-0.106366,-0.008749,0.000216,0.000095,37,O +2021-03-25,59298,0.072812,0.407873,-0.1705313,-0.0000510,-0.106282,-0.008977,0.000225,0.000066,37,O +2021-03-26,59299,0.073728,0.409056,-0.1705938,0.0002010,-0.106226,-0.009237,0.000236,0.000026,37,O +2021-03-27,59300,0.074948,0.409668,-0.1709185,0.0004661,-0.105910,-0.009285,0.000252,0.000016,37,O +2021-03-28,59301,0.076573,0.409823,-0.1714942,0.0006701,-0.105462,-0.009044,0.000270,0.000018,37,O +2021-03-29,59302,0.078236,0.410129,-0.1722454,0.0007908,-0.105357,-0.008732,0.000287,0.000019,37,O +2021-03-30,59303,0.079581,0.410456,-0.1730409,0.0007669,-0.105788,-0.008649,0.000305,0.000020,37,O +2021-03-31,59304,0.080692,0.411065,-0.1737315,0.0005975,-0.106341,-0.008853,0.000345,-0.000003,37,O +2021-04-01,59305,0.081597,0.411745,-0.1742201,0.0003752,-0.106565,-0.009093,0.000392,-0.000034,37,O +2021-04-02,59306,0.082266,0.412527,-0.1744884,0.0001577,-0.106526,-0.009134,0.000373,-0.000016,37,O +2021-04-03,59307,0.082863,0.413394,-0.1745594,-0.0000218,-0.106357,-0.009054,0.000331,0.000018,37,O +2021-04-04,59308,0.083694,0.413955,-0.1744710,-0.0001093,-0.106265,-0.008993,0.000288,0.000052,37,O +2021-04-05,59309,0.084866,0.414476,-0.1744009,-0.0000380,-0.106290,-0.008990,0.000246,0.000086,37,O +2021-04-06,59310,0.085863,0.415604,-0.1744328,0.0000917,-0.106306,-0.009021,0.000204,0.000120,37,O +2021-04-07,59311,0.086636,0.416842,-0.1745974,0.0002245,-0.106207,-0.009070,0.000162,0.000154,37,O +2021-04-08,59312,0.087374,0.417758,-0.1748862,0.0003464,-0.105886,-0.009192,0.000190,0.000100,37,O +2021-04-09,59313,0.087621,0.418801,-0.1752874,0.0004559,-0.105640,-0.009234,0.000238,0.000022,37,O +2021-04-10,59314,0.087511,0.419908,-0.1757729,0.0005100,-0.105648,-0.009045,0.000264,0.000007,37,O +2021-04-11,59315,0.087081,0.420785,-0.1762939,0.0005274,-0.105773,-0.008744,0.000281,0.000015,37,O +2021-04-12,59316,0.086768,0.421358,-0.1767986,0.0004752,-0.105846,-0.008552,0.000299,0.000023,37,O +2021-04-13,59317,0.086839,0.421892,-0.1772455,0.0004063,-0.105810,-0.008603,0.000316,0.000031,37,O +2021-04-14,59318,0.087692,0.422398,-0.1776055,0.0002914,-0.105761,-0.008851,0.000299,0.000020,37,O +2021-04-15,59319,0.088768,0.423267,-0.1778557,0.0001882,-0.105691,-0.009111,0.000272,0.000005,37,O +2021-04-16,59320,0.089996,0.423845,-0.1779907,0.0000721,-0.105670,-0.009299,0.000246,-0.000009,37,O +2021-04-17,59321,0.092158,0.424284,-0.1780250,-0.0000067,-0.105805,-0.009475,0.000213,-0.000020,37,O +2021-04-18,59322,0.094246,0.425257,-0.1779868,-0.0000674,-0.106010,-0.009692,0.000179,-0.000029,37,O +2021-04-19,59323,0.095947,0.426181,-0.1779103,-0.0000733,-0.106040,-0.009876,0.000144,-0.000039,37,O +2021-04-20,59324,0.097266,0.427588,-0.1778571,-0.0000075,-0.105762,-0.009917,0.000110,-0.000048,37,O +2021-04-21,59325,0.098245,0.428908,-0.1779160,0.0001384,-0.105268,-0.009880,0.000136,-0.000061,37,O +2021-04-22,59326,0.099005,0.430149,-0.1781298,0.0003258,-0.105013,-0.009959,0.000179,-0.000074,37,O +2021-04-23,59327,0.099573,0.431096,-0.1785406,0.0005455,-0.105001,-0.010212,0.000222,-0.000087,37,O +2021-04-24,59328,0.099809,0.432023,-0.1791390,0.0007338,-0.104988,-0.010408,0.000228,-0.000120,37,O +2021-04-25,59329,0.100034,0.432771,-0.1799364,0.0009053,-0.104884,-0.010282,0.000222,-0.000173,37,O +2021-04-26,59330,0.100355,0.433380,-0.1809123,0.0009884,-0.105067,-0.009919,0.000216,-0.000221,37,O +2021-04-27,59331,0.101324,0.433851,-0.1819026,0.0008952,-0.105732,-0.009704,0.000210,-0.000268,37,O +2021-04-28,59332,0.102654,0.434414,-0.1826964,0.0006420,-0.106374,-0.009680,0.000244,-0.000185,37,O +2021-04-29,59333,0.104008,0.434868,-0.1831982,0.0003262,-0.106517,-0.009750,0.000288,-0.000071,37,O +2021-04-30,59334,0.105404,0.435218,-0.1833833,0.0000436,-0.106106,-0.009736,0.000332,0.000043,37,O +2021-05-01,59335,0.106820,0.435779,-0.1833089,-0.0001567,-0.105639,-0.009780,0.000316,0.000058,37,O +2021-05-02,59336,0.108188,0.436419,-0.1830909,-0.0002640,-0.105392,-0.009936,0.000276,0.000037,37,O +2021-05-03,59337,0.109767,0.437441,-0.1827909,-0.0002949,-0.105435,-0.010113,0.000237,0.000016,37,O +2021-05-04,59338,0.111592,0.438462,-0.1825243,-0.0002191,-0.105659,-0.010174,0.000197,-0.000006,37,O +2021-05-05,59339,0.113313,0.439364,-0.1823978,-0.0000554,-0.105759,-0.010107,0.000182,-0.000033,37,O +2021-05-06,59340,0.115279,0.440309,-0.1824200,0.0000973,-0.105659,-0.009997,0.000173,-0.000063,37,O +2021-05-07,59341,0.117172,0.441478,-0.1825670,0.0002145,-0.105509,-0.009864,0.000164,-0.000092,37,O +2021-05-08,59342,0.118681,0.442646,-0.1827886,0.0002700,-0.105519,-0.009632,0.000166,-0.000099,37,O +2021-05-09,59343,0.120432,0.443435,-0.1830318,0.0002301,-0.105761,-0.009338,0.000172,-0.000097,37,O +2021-05-10,59344,0.122013,0.444253,-0.1832398,0.0001781,-0.106060,-0.009161,0.000178,-0.000096,37,O +2021-05-11,59345,0.123229,0.444950,-0.1833696,0.0000832,-0.106211,-0.009260,0.000184,-0.000094,37,O +2021-05-12,59346,0.124570,0.445119,-0.1834050,-0.0000417,-0.106142,-0.009592,0.000197,-0.000091,37,O +2021-05-13,59347,0.126398,0.444900,-0.1833166,-0.0001604,-0.105971,-0.009938,0.000212,-0.000088,37,O +2021-05-14,59348,0.128393,0.445000,-0.1831001,-0.0002467,-0.105857,-0.010138,0.000228,-0.000084,37,O +2021-05-15,59349,0.130276,0.445421,-0.1828031,-0.0003065,-0.105951,-0.010226,0.000226,-0.000081,37,O +2021-05-16,59350,0.132466,0.445767,-0.1824802,-0.0003050,-0.106179,-0.010311,0.000219,-0.000079,37,O +2021-05-17,59351,0.134899,0.446354,-0.1822601,-0.0002399,-0.106325,-0.010390,0.000212,-0.000076,37,O +2021-05-18,59352,0.137096,0.446653,-0.1820734,-0.0001333,-0.106203,-0.010375,0.000204,-0.000073,37,O +2021-05-19,59353,0.139382,0.446488,-0.1819842,0.0000440,-0.105891,-0.010264,0.000197,-0.000071,37,O +2021-05-20,59354,0.142062,0.446194,-0.1821300,0.0002771,-0.105602,-0.010265,0.000227,-0.000129,37,O +2021-05-21,59355,0.144518,0.446092,-0.1825058,0.0004653,-0.105556,-0.010433,0.000267,-0.000204,37,O +2021-05-22,59356,0.146638,0.446087,-0.1830591,0.0006161,-0.105780,-0.010527,0.000254,-0.000207,37,O +2021-05-23,59357,0.148357,0.446319,-0.1837359,0.0007012,-0.106114,-0.010345,0.000222,-0.000183,37,O +2021-05-24,59358,0.150055,0.446007,-0.1844377,0.0006778,-0.106686,-0.009942,0.000190,-0.000159,37,O +2021-05-25,59359,0.151671,0.445578,-0.1850358,0.0005120,-0.107551,-0.009625,0.000157,-0.000135,37,O +2021-05-26,59360,0.153177,0.445002,-0.1854186,0.0002683,-0.108338,-0.009587,0.000125,-0.000111,37,O +2021-05-27,59361,0.154610,0.444641,-0.1855433,-0.0000135,-0.108444,-0.009736,0.000155,-0.000132,37,O +2021-05-28,59362,0.156083,0.444149,-0.1854061,-0.0002723,-0.107948,-0.009867,0.000203,-0.000165,37,O +2021-05-29,59363,0.157787,0.443296,-0.1850586,-0.0004259,-0.107319,-0.009999,0.000216,-0.000173,37,O +2021-05-30,59364,0.159496,0.443194,-0.1846181,-0.0004360,-0.106855,-0.010257,0.000215,-0.000173,37,O +2021-05-31,59365,0.160764,0.443056,-0.1841962,-0.0003658,-0.106714,-0.010524,0.000215,-0.000172,37,O +2021-06-01,59366,0.162221,0.442541,-0.1838763,-0.0002431,-0.106913,-0.010562,0.000215,-0.000172,37,O +2021-06-02,59367,0.163505,0.442197,-0.1837088,-0.0001118,-0.107189,-0.010310,0.000238,-0.000157,37,O +2021-06-03,59368,0.164269,0.441835,-0.1836734,0.0000119,-0.107307,-0.009973,0.000267,-0.000139,37,O +2021-06-04,59369,0.165264,0.441101,-0.1837182,0.0000536,-0.107243,-0.009722,0.000296,-0.000120,37,O +2021-06-05,59370,0.166494,0.439959,-0.1837435,-0.0000156,-0.107338,-0.009564,0.000285,-0.000120,37,O +2021-06-06,59371,0.167443,0.438760,-0.1837213,-0.0001340,-0.107712,-0.009420,0.000260,-0.000126,37,O +2021-06-07,59372,0.168452,0.437773,-0.1835146,-0.0002761,-0.108222,-0.009335,0.000235,-0.000131,37,O +2021-06-08,59373,0.169988,0.437038,-0.1831307,-0.0004348,-0.108616,-0.009447,0.000210,-0.000137,37,O +2021-06-09,59374,0.171662,0.436466,-0.1825961,-0.0006056,-0.108746,-0.009756,0.000198,-0.000126,37,O +2021-06-10,59375,0.173060,0.436107,-0.1819126,-0.0007632,-0.108720,-0.010098,0.000190,-0.000111,37,O +2021-06-11,59376,0.174245,0.435720,-0.1810931,-0.0008734,-0.108643,-0.010282,0.000205,-0.000105,37,O +2021-06-12,59377,0.175463,0.435402,-0.1802017,-0.0009192,-0.108645,-0.010266,0.000228,-0.000104,37,O +2021-06-13,59378,0.176463,0.435076,-0.1792824,-0.0009227,-0.108763,-0.010171,0.000251,-0.000102,37,O +2021-06-14,59379,0.177561,0.434800,-0.1783898,-0.0008460,-0.108931,-0.010112,0.000274,-0.000100,37,O +2021-06-15,59380,0.178436,0.434544,-0.1776041,-0.0007086,-0.109005,-0.010092,0.000297,-0.000098,37,O +2021-06-16,59381,0.179161,0.433958,-0.1769638,-0.0005221,-0.109007,-0.010090,0.000273,-0.000128,37,O +2021-06-17,59382,0.179975,0.433150,-0.1765219,-0.0003366,-0.108937,-0.010073,0.000235,-0.000167,37,O +2021-06-18,59383,0.181538,0.431985,-0.1762920,-0.0001418,-0.108971,-0.010051,0.000198,-0.000206,37,O +2021-06-19,59384,0.183459,0.431221,-0.1762499,-0.0000088,-0.109186,-0.009941,0.000195,-0.000200,37,O +2021-06-20,59385,0.185268,0.430690,-0.1762848,0.0000040,-0.109672,-0.009715,0.000204,-0.000177,37,O +2021-06-21,59386,0.187008,0.430371,-0.1762299,-0.0001366,-0.110397,-0.009446,0.000213,-0.000153,37,O +2021-06-22,59387,0.188612,0.429729,-0.1759694,-0.0003671,-0.111169,-0.009304,0.000223,-0.000130,37,O +2021-06-23,59388,0.190249,0.428692,-0.1754577,-0.0006531,-0.111740,-0.009402,0.000211,-0.000157,37,O +2021-06-24,59389,0.191984,0.427561,-0.1746551,-0.0009461,-0.111870,-0.009570,0.000193,-0.000198,37,O +2021-06-25,59390,0.193895,0.426260,-0.1736026,-0.0011467,-0.111627,-0.009678,0.000175,-0.000239,37,O +2021-06-26,59391,0.195529,0.424979,-0.1723902,-0.0012514,-0.111223,-0.009764,0.000169,-0.000232,37,O +2021-06-27,59392,0.197249,0.423941,-0.1711520,-0.0012122,-0.110867,-0.009981,0.000169,-0.000206,37,O +2021-06-28,59393,0.199016,0.423212,-0.1700013,-0.0010808,-0.110723,-0.010241,0.000168,-0.000180,37,O +2021-06-29,59394,0.201014,0.422014,-0.1689979,-0.0008954,-0.110903,-0.010285,0.000167,-0.000155,37,O +2021-06-30,59395,0.203151,0.420682,-0.1681557,-0.0007509,-0.111326,-0.010039,0.000175,-0.000142,37,O +2021-07-01,59396,0.205011,0.419357,-0.1674255,-0.0007061,-0.111755,-0.009689,0.000185,-0.000133,37,O +2021-07-02,59397,0.206921,0.418137,-0.1667352,-0.0007290,-0.112004,-0.009464,0.000195,-0.000125,37,O +2021-07-03,59398,0.209024,0.416956,-0.1660067,-0.0007956,-0.112140,-0.009398,0.000213,-0.000118,37,O +2021-07-04,59399,0.211331,0.415811,-0.1651797,-0.0008841,-0.112363,-0.009373,0.000234,-0.000112,37,O +2021-07-05,59400,0.213414,0.414996,-0.1642095,-0.0010197,-0.112694,-0.009336,0.000255,-0.000106,37,O +2021-07-06,59401,0.215650,0.414027,-0.1630892,-0.0011760,-0.112980,-0.009377,0.000276,-0.000100,37,O +2021-07-07,59402,0.218140,0.413172,-0.1618291,-0.0013002,-0.113113,-0.009583,0.000297,-0.000094,37,O +2021-07-08,59403,0.220214,0.412138,-0.1604574,-0.0014004,-0.113230,-0.009877,0.000276,-0.000077,37,O +2021-07-09,59404,0.221832,0.410821,-0.1590228,-0.0014520,-0.113321,-0.010078,0.000245,-0.000059,37,O +2021-07-10,59405,0.223600,0.409097,-0.1575892,-0.0014271,-0.113323,-0.010077,0.000240,-0.000056,37,O +2021-07-11,59406,0.225666,0.407615,-0.1562169,-0.0013154,-0.113312,-0.009920,0.000245,-0.000060,37,O +2021-07-12,59407,0.227521,0.406499,-0.1549674,-0.0011382,-0.113374,-0.009766,0.000250,-0.000064,37,O +2021-07-13,59408,0.229363,0.405735,-0.1538980,-0.0009647,-0.113495,-0.009729,0.000256,-0.000067,37,O +2021-07-14,59409,0.230852,0.405177,-0.1530567,-0.0007412,-0.113617,-0.009794,0.000239,-0.000073,37,O +2021-07-15,59410,0.232364,0.404183,-0.1524225,-0.0005190,-0.113614,-0.009847,0.000216,-0.000080,37,O +2021-07-16,59411,0.233932,0.403085,-0.1520045,-0.0003391,-0.113595,-0.009787,0.000193,-0.000086,37,O +2021-07-17,59412,0.235568,0.402256,-0.1517411,-0.0002516,-0.113759,-0.009608,0.000192,-0.000098,37,O +2021-07-18,59413,0.236938,0.401571,-0.1515176,-0.0002888,-0.114276,-0.009388,0.000197,-0.000111,37,O +2021-07-19,59414,0.238366,0.400312,-0.1511975,-0.0003898,-0.115015,-0.009262,0.000202,-0.000125,37,O +2021-07-20,59415,0.239941,0.398929,-0.1507114,-0.0005551,-0.115643,-0.009312,0.000207,-0.000138,37,O +2021-07-21,59416,0.241402,0.397614,-0.1500616,-0.0007199,-0.115876,-0.009476,0.000224,-0.000143,37,O +2021-07-22,59417,0.242550,0.396349,-0.1492653,-0.0008670,-0.115745,-0.009604,0.000244,-0.000145,37,O +2021-07-23,59418,0.243559,0.394850,-0.1483896,-0.0009224,-0.115468,-0.009626,0.000263,-0.000148,37,O +2021-07-24,59419,0.244504,0.393363,-0.1475216,-0.0008550,-0.115321,-0.009619,0.000241,-0.000137,37,O +2021-07-25,59420,0.244659,0.392108,-0.1467385,-0.0007245,-0.115265,-0.009715,0.000205,-0.000120,37,O +2021-07-26,59421,0.244282,0.390818,-0.1460743,-0.0006021,-0.115280,-0.009873,0.000168,-0.000104,37,O +2021-07-27,59422,0.244021,0.389282,-0.1455380,-0.0004795,-0.115457,-0.009910,0.000132,-0.000087,37,O +2021-07-28,59423,0.243957,0.387023,-0.1451164,-0.0004072,-0.115784,-0.009750,0.000131,-0.000079,37,O +2021-07-29,59424,0.244271,0.384533,-0.1447485,-0.0003704,-0.116221,-0.009509,0.000140,-0.000073,37,O +2021-07-30,59425,0.245054,0.382456,-0.1443684,-0.0004102,-0.116596,-0.009367,0.000149,-0.000067,37,O +2021-07-31,59426,0.246021,0.381094,-0.1439172,-0.0005170,-0.116756,-0.009383,0.000182,-0.000083,37,O +2021-08-01,59427,0.246780,0.380162,-0.1433541,-0.0006384,-0.116809,-0.009429,0.000223,-0.000105,37,O +2021-08-02,59428,0.247724,0.379020,-0.1426563,-0.0007555,-0.116864,-0.009419,0.000264,-0.000127,37,O +2021-08-03,59429,0.248665,0.377672,-0.1418281,-0.0008856,-0.116928,-0.009418,0.000305,-0.000149,37,O +2021-08-04,59430,0.249247,0.376225,-0.1408819,-0.0009926,-0.117087,-0.009488,0.000295,-0.000110,37,O +2021-08-05,59431,0.250318,0.374716,-0.1398588,-0.0010475,-0.117212,-0.009692,0.000272,-0.000054,37,O +2021-08-06,59432,0.251557,0.373439,-0.1388293,-0.0010580,-0.117228,-0.009944,0.000256,-0.000038,37,O +2021-08-07,59433,0.252384,0.372189,-0.1377997,-0.0010329,-0.117131,-0.010037,0.000244,-0.000034,37,O +2021-08-08,59434,0.252618,0.370959,-0.1367543,-0.0009699,-0.116976,-0.009913,0.000231,-0.000031,37,O +2021-08-09,59435,0.251958,0.369547,-0.1358220,-0.0008438,-0.116861,-0.009698,0.000219,-0.000028,37,O +2021-08-10,59436,0.250843,0.367504,-0.1350686,-0.0006799,-0.116860,-0.009570,0.000206,-0.000025,37,O +2021-08-11,59437,0.250176,0.365255,-0.1345085,-0.0004603,-0.116935,-0.009605,0.000194,-0.000022,37,O +2021-08-12,59438,0.249897,0.363348,-0.1341190,-0.0003252,-0.117018,-0.009784,0.000182,-0.000080,37,O +2021-08-13,59439,0.249586,0.361519,-0.1338317,-0.0003000,-0.117129,-0.009917,0.000169,-0.000157,37,O +2021-08-14,59440,0.249168,0.359749,-0.1335458,-0.0003549,-0.117340,-0.009843,0.000169,-0.000170,37,O +2021-08-15,59441,0.248726,0.358103,-0.1331531,-0.0004593,-0.117733,-0.009659,0.000172,-0.000160,37,O +2021-08-16,59442,0.248321,0.356538,-0.1325675,-0.0006686,-0.118199,-0.009514,0.000176,-0.000150,37,O +2021-08-17,59443,0.248130,0.354895,-0.1317488,-0.0009228,-0.118520,-0.009488,0.000179,-0.000140,37,O +2021-08-18,59444,0.248008,0.353279,-0.1307185,-0.0010982,-0.118546,-0.009545,0.000183,-0.000131,37,O +2021-08-19,59445,0.247978,0.351653,-0.1295488,-0.0011741,-0.118297,-0.009587,0.000203,-0.000126,37,O +2021-08-20,59446,0.247731,0.350108,-0.1283563,-0.0011739,-0.117988,-0.009566,0.000229,-0.000124,37,O +2021-08-21,59447,0.247290,0.348276,-0.1272649,-0.0010243,-0.117743,-0.009514,0.000268,-0.000114,37,O +2021-08-22,59448,0.246822,0.346558,-0.1263384,-0.0008459,-0.117577,-0.009494,0.000313,-0.000103,37,O +2021-08-23,59449,0.246343,0.344554,-0.1255763,-0.0006538,-0.117446,-0.009485,0.000357,-0.000091,37,O +2021-08-24,59450,0.245986,0.342232,-0.1249636,-0.0005235,-0.117350,-0.009416,0.000401,-0.000080,37,O +2021-08-25,59451,0.246006,0.340077,-0.1244735,-0.0004466,-0.117582,-0.009295,0.000360,-0.000093,37,O +2021-08-26,59452,0.246029,0.338309,-0.1240162,-0.0004798,-0.118022,-0.009189,0.000296,-0.000112,37,O +2021-08-27,59453,0.246039,0.336463,-0.1235117,-0.0005674,-0.118513,-0.009184,0.000233,-0.000131,37,O +2021-08-28,59454,0.246083,0.334712,-0.1228899,-0.0006892,-0.118761,-0.009205,0.000223,-0.000091,37,O +2021-08-29,59455,0.246022,0.333214,-0.1221387,-0.0008198,-0.118783,-0.009190,0.000231,-0.000031,37,O +2021-08-30,59456,0.245834,0.331664,-0.1212791,-0.0008920,-0.118708,-0.009104,0.000239,0.000029,37,O +2021-08-31,59457,0.245060,0.329881,-0.1203267,-0.0009814,-0.118658,-0.009011,0.000247,0.000089,37,O +2021-09-01,59458,0.244291,0.327776,-0.1193071,-0.0010322,-0.118653,-0.009123,0.000253,0.000051,37,O +2021-09-02,59459,0.243859,0.325972,-0.1182574,-0.0010516,-0.118581,-0.009390,0.000260,-0.000013,37,O +2021-09-03,59460,0.243838,0.324135,-0.1172280,-0.0010009,-0.118364,-0.009679,0.000266,-0.000077,37,O +2021-09-04,59461,0.243924,0.322819,-0.1162657,-0.0008934,-0.118147,-0.009782,0.000233,-0.000089,37,O +2021-09-05,59462,0.243284,0.321221,-0.1154565,-0.0007065,-0.117995,-0.009664,0.000188,-0.000083,37,O +2021-09-06,59463,0.242288,0.319291,-0.1149183,-0.0004500,-0.117966,-0.009415,0.000143,-0.000077,37,O +2021-09-07,59464,0.241085,0.317267,-0.1145864,-0.0002230,-0.118054,-0.009194,0.000097,-0.000071,37,O +2021-09-08,59465,0.240168,0.315380,-0.1144389,-0.0000487,-0.118217,-0.009134,0.000052,-0.000065,37,O +2021-09-09,59466,0.239509,0.313682,-0.1144456,0.0000445,-0.118199,-0.009278,0.000108,-0.000082,37,O +2021-09-10,59467,0.239055,0.311944,-0.1145001,0.0000481,-0.118196,-0.009493,0.000190,-0.000103,37,O +2021-09-11,59468,0.238903,0.310398,-0.1145067,-0.0000661,-0.118376,-0.009600,0.000217,-0.000108,37,O +2021-09-12,59469,0.239057,0.309176,-0.1143417,-0.0002835,-0.118582,-0.009536,0.000225,-0.000108,37,O +2021-09-13,59470,0.239061,0.308241,-0.1139194,-0.0005446,-0.118703,-0.009367,0.000233,-0.000107,37,O +2021-09-14,59471,0.238135,0.306840,-0.1132542,-0.0007658,-0.118709,-0.009209,0.000240,-0.000106,37,O +2021-09-15,59472,0.236855,0.305424,-0.1124265,-0.0008470,-0.118560,-0.009153,0.000260,-0.000133,37,O +2021-09-16,59473,0.235175,0.304217,-0.1115600,-0.0008380,-0.118299,-0.009166,0.000282,-0.000168,37,O +2021-09-17,59474,0.234052,0.302470,-0.1107776,-0.0006952,-0.117981,-0.009206,0.000304,-0.000203,37,O +2021-09-18,59475,0.233267,0.300669,-0.1101847,-0.0004981,-0.117771,-0.009190,0.000294,-0.000179,37,O +2021-09-19,59476,0.231901,0.298971,-0.1097908,-0.0003079,-0.117692,-0.009120,0.000271,-0.000133,37,O +2021-09-20,59477,0.230860,0.297082,-0.1095369,-0.0001935,-0.117703,-0.008971,0.000250,-0.000088,37,O +2021-09-21,59478,0.230386,0.295169,-0.1093835,-0.0001309,-0.117745,-0.008710,0.000229,-0.000021,37,O +2021-09-22,59479,0.230280,0.293410,-0.1092939,-0.0000808,-0.117784,-0.008514,0.000215,-0.000032,37,O +2021-09-23,59480,0.229745,0.291932,-0.1092075,-0.0001148,-0.117885,-0.008448,0.000201,-0.000063,37,O +2021-09-24,59481,0.229059,0.290744,-0.1090710,-0.0001808,-0.118056,-0.008545,0.000187,-0.000093,37,O +2021-09-25,59482,0.228196,0.289721,-0.1088548,-0.0002793,-0.118125,-0.008697,0.000198,-0.000095,37,O +2021-09-26,59483,0.226765,0.288616,-0.1085235,-0.0004236,-0.118017,-0.008793,0.000218,-0.000088,37,O +2021-09-27,59484,0.224983,0.286909,-0.1080259,-0.0005541,-0.117799,-0.008801,0.000237,-0.000081,37,O +2021-09-28,59485,0.223233,0.285091,-0.1073996,-0.0006578,-0.117613,-0.008799,0.000257,-0.000075,37,O +2021-09-29,59486,0.221642,0.283266,-0.1067014,-0.0007266,-0.117515,-0.008884,0.000266,-0.000086,37,O +2021-09-30,59487,0.220649,0.281274,-0.1059687,-0.0007290,-0.117316,-0.009021,0.000272,-0.000102,37,O +2021-10-01,59488,0.219900,0.279843,-0.1052566,-0.0006552,-0.116894,-0.009099,0.000278,-0.000118,37,O +2021-10-02,59489,0.219232,0.278385,-0.1046635,-0.0005041,-0.116396,-0.009043,0.000288,-0.000132,37,O +2021-10-03,59490,0.218114,0.277440,-0.1042262,-0.0003168,-0.116108,-0.008872,0.000301,-0.000145,37,O +2021-10-04,59491,0.216463,0.276398,-0.1040412,-0.0000538,-0.116115,-0.008648,0.000314,-0.000158,37,O +2021-10-05,59492,0.214966,0.275265,-0.1041427,0.0002367,-0.116245,-0.008435,0.000326,-0.000172,37,O +2021-10-06,59493,0.212886,0.274073,-0.1045130,0.0004438,-0.116543,-0.008305,0.000255,-0.000172,37,O +2021-10-07,59494,0.210670,0.272310,-0.1050355,0.0005448,-0.116846,-0.008364,0.000164,-0.000169,37,O +2021-10-08,59495,0.208740,0.270354,-0.1055552,0.0004758,-0.117140,-0.008593,0.000073,-0.000166,37,O +2021-10-09,59496,0.206987,0.268630,-0.1059176,0.0002801,-0.117149,-0.008775,0.000080,-0.000140,37,O +2021-10-10,59497,0.205587,0.267049,-0.1060489,0.0000458,-0.117005,-0.008734,0.000123,-0.000105,37,O +2021-10-11,59498,0.204294,0.265940,-0.1059506,-0.0002003,-0.116845,-0.008499,0.000164,-0.000071,37,O +2021-10-12,59499,0.202929,0.265318,-0.1056985,-0.0003003,-0.116696,-0.008264,0.000206,-0.000037,37,O +2021-10-13,59500,0.201347,0.265115,-0.1053769,-0.0003296,-0.116533,-0.008163,0.000249,-0.000003,37,O +2021-10-14,59501,0.199531,0.264474,-0.1050561,-0.0002785,-0.116392,-0.008233,0.000253,-0.000031,37,O +2021-10-15,59502,0.197144,0.264052,-0.1048215,-0.0001786,-0.116168,-0.008339,0.000247,-0.000076,37,O +2021-10-16,59503,0.194540,0.263311,-0.1047296,-0.0000160,-0.115892,-0.008371,0.000238,-0.000079,37,O +2021-10-17,59504,0.192522,0.262732,-0.1047961,0.0001436,-0.115671,-0.008326,0.000228,-0.000068,37,O +2021-10-18,59505,0.190330,0.262116,-0.1049797,0.0002729,-0.115586,-0.008172,0.000218,-0.000056,37,O +2021-10-19,59506,0.188419,0.261094,-0.1053261,0.0003283,-0.115599,-0.007898,0.000207,-0.000044,37,O +2021-10-20,59507,0.186951,0.260372,-0.1056852,0.0003063,-0.115532,-0.007637,0.000226,-0.000066,37,O +2021-10-21,59508,0.185890,0.259671,-0.1059933,0.0002542,-0.115408,-0.007531,0.000253,-0.000096,37,O +2021-10-22,59509,0.185109,0.258931,-0.1061695,0.0001074,-0.115283,-0.007652,0.000280,-0.000127,37,O +2021-10-23,59510,0.183997,0.258126,-0.1061599,-0.0001073,-0.115214,-0.007852,0.000282,-0.000110,37,O +2021-10-24,59511,0.182170,0.256859,-0.1059532,-0.0003135,-0.115105,-0.007981,0.000275,-0.000073,37,O +2021-10-25,59512,0.180765,0.255674,-0.1055673,-0.0004478,-0.114951,-0.007995,0.000267,-0.000036,37,O +2021-10-26,59513,0.179443,0.255135,-0.1050710,-0.0004914,-0.114842,-0.007976,0.000259,0.000001,37,O +2021-10-27,59514,0.177475,0.254614,-0.1045560,-0.0004736,-0.114798,-0.008064,0.000244,-0.000029,37,O +2021-10-28,59515,0.174986,0.254210,-0.1040921,-0.0004235,-0.114636,-0.008154,0.000226,-0.000076,37,O +2021-10-29,59516,0.172883,0.253703,-0.1037503,-0.0002679,-0.114222,-0.008112,0.000209,-0.000124,37,O +2021-10-30,59517,0.171153,0.253485,-0.1035881,-0.0000628,-0.113712,-0.007886,0.000211,-0.000123,37,O +2021-10-31,59518,0.169153,0.253030,-0.1036762,0.0002284,-0.113489,-0.007636,0.000221,-0.000105,37,O +2021-11-01,59519,0.167161,0.252590,-0.1040619,0.0005226,-0.113648,-0.007463,0.000230,-0.000087,37,O +2021-11-02,59520,0.165421,0.252037,-0.1047142,0.0007367,-0.113919,-0.007301,0.000239,-0.000069,37,O +2021-11-03,59521,0.164345,0.251154,-0.1055305,0.0008486,-0.114076,-0.007098,0.000249,-0.000051,37,O +2021-11-04,59522,0.163380,0.250407,-0.1063597,0.0007779,-0.114274,-0.006977,0.000200,-0.000036,37,O +2021-11-05,59523,0.161527,0.249780,-0.1070350,0.0005185,-0.114417,-0.007068,0.000135,-0.000022,37,O +2021-11-06,59524,0.158959,0.249274,-0.1074216,0.0002206,-0.114174,-0.007273,0.000153,-0.000034,37,O +2021-11-07,59525,0.156428,0.248766,-0.1075061,-0.0000193,-0.113720,-0.007312,0.000204,-0.000058,37,O +2021-11-08,59526,0.154365,0.248057,-0.1073849,-0.0001713,-0.113374,-0.007138,0.000254,-0.000081,37,O +2021-11-09,59527,0.152501,0.247567,-0.1071716,-0.0002182,-0.113247,-0.007009,0.000304,-0.000104,37,O +2021-11-10,59528,0.150781,0.247125,-0.1069620,-0.0001425,-0.113363,-0.007072,0.000289,-0.000093,37,O +2021-11-11,59529,0.149470,0.246785,-0.1068772,0.0000166,-0.113428,-0.007227,0.000255,-0.000072,37,O +2021-11-12,59530,0.148470,0.246564,-0.1069721,0.0001709,-0.113370,-0.007262,0.000222,-0.000052,37,O +2021-11-13,59531,0.147692,0.246455,-0.1072523,0.0003196,-0.113185,-0.007165,0.000220,-0.000061,37,O +2021-11-14,59532,0.147041,0.246459,-0.1076527,0.0003813,-0.112994,-0.007024,0.000230,-0.000082,37,O +2021-11-15,59533,0.145836,0.246338,-0.1080024,0.0003295,-0.112892,-0.006878,0.000239,-0.000102,37,O +2021-11-16,59534,0.143555,0.246023,-0.1082774,0.0002430,-0.112883,-0.006691,0.000249,-0.000122,37,O +2021-11-17,59535,0.141392,0.245346,-0.1084806,0.0001504,-0.112918,-0.006416,0.000247,-0.000082,37,O +2021-11-18,59536,0.139789,0.245077,-0.1085552,0.0000024,-0.112878,-0.006226,0.000242,-0.000025,37,O +2021-11-19,59537,0.137868,0.245245,-0.1084680,-0.0001716,-0.112755,-0.006253,0.000237,0.000032,37,O +2021-11-20,59538,0.135470,0.245267,-0.1081943,-0.0003451,-0.112586,-0.006495,0.000242,0.000032,37,O +2021-11-21,59539,0.133433,0.245936,-0.1077699,-0.0004589,-0.112425,-0.006731,0.000250,0.000011,37,O +2021-11-22,59540,0.131584,0.246933,-0.1072664,-0.0005149,-0.112282,-0.006830,0.000257,-0.000010,37,O +2021-11-23,59541,0.129614,0.247350,-0.1067281,-0.0005456,-0.112157,-0.006857,0.000265,-0.000031,37,O +2021-11-24,59542,0.127746,0.247246,-0.1062044,-0.0005261,-0.112031,-0.006907,0.000273,-0.000052,37,O +2021-11-25,59543,0.126546,0.247694,-0.1057277,-0.0004280,-0.111742,-0.006906,0.000305,-0.000029,37,O +2021-11-26,59544,0.125318,0.248339,-0.1053900,-0.0002261,-0.111266,-0.006772,0.000344,0.000006,37,O +2021-11-27,59545,0.123926,0.249137,-0.1053000,0.0000260,-0.110920,-0.006579,0.000321,-0.000017,37,O +2021-11-28,59546,0.122510,0.250182,-0.1054501,0.0002285,-0.110873,-0.006446,0.000278,-0.000060,37,O +2021-11-29,59547,0.120935,0.250800,-0.1057693,0.0003902,-0.111138,-0.006451,0.000234,-0.000103,37,O +2021-11-30,59548,0.119462,0.251409,-0.1062356,0.0005403,-0.111496,-0.006463,0.000190,-0.000147,37,O +2021-12-01,59549,0.117908,0.252101,-0.1068219,0.0005712,-0.111672,-0.006258,0.000205,-0.000142,37,O +2021-12-02,59550,0.116646,0.253077,-0.1073817,0.0004702,-0.111874,-0.005966,0.000235,-0.000125,37,O +2021-12-03,59551,0.115236,0.254139,-0.1077758,0.0002768,-0.112122,-0.005874,0.000265,-0.000108,37,O +2021-12-04,59552,0.113528,0.254463,-0.1079062,-0.0000071,-0.112187,-0.006031,0.000270,-0.000106,37,O +2021-12-05,59553,0.112210,0.254544,-0.1077891,-0.0002049,-0.111884,-0.006154,0.000266,-0.000109,37,O +2021-12-06,59554,0.110933,0.255126,-0.1075299,-0.0002631,-0.111458,-0.006078,0.000263,-0.000112,37,O +2021-12-07,59555,0.109262,0.255631,-0.1072636,-0.0001957,-0.111227,-0.006002,0.000259,-0.000116,37,O +2021-12-08,59556,0.106686,0.256326,-0.1071092,-0.0000541,-0.111176,-0.006134,0.000249,-0.000116,37,O +2021-12-09,59557,0.103984,0.256757,-0.1071653,0.0001373,-0.111132,-0.006338,0.000237,-0.000116,37,O +2021-12-10,59558,0.101414,0.257116,-0.1074002,0.0003090,-0.111095,-0.006308,0.000225,-0.000115,37,O +2021-12-11,59559,0.098426,0.257383,-0.1077748,0.0004257,-0.111085,-0.005998,0.000239,-0.000111,37,O +2021-12-12,59560,0.095231,0.257384,-0.1082102,0.0004477,-0.111113,-0.005653,0.000263,-0.000105,37,O +2021-12-13,59561,0.092509,0.257408,-0.1086201,0.0003713,-0.111139,-0.005474,0.000286,-0.000099,37,O +2021-12-14,59562,0.090306,0.258026,-0.1089586,0.0002966,-0.111161,-0.005420,0.000310,-0.000093,37,O +2021-12-15,59563,0.087829,0.258992,-0.1091980,0.0001665,-0.111310,-0.005388,0.000278,-0.000106,37,O +2021-12-16,59564,0.085353,0.259707,-0.1093060,0.0000223,-0.111400,-0.005371,0.000232,-0.000124,37,O +2021-12-17,59565,0.082621,0.260745,-0.1092661,-0.0001186,-0.111355,-0.005475,0.000186,-0.000142,37,O +2021-12-18,59566,0.080179,0.261328,-0.1090678,-0.0002676,-0.111129,-0.005691,0.000193,-0.000128,37,O +2021-12-19,59567,0.078732,0.261660,-0.1087469,-0.0003304,-0.110910,-0.005904,0.000220,-0.000102,37,O +2021-12-20,59568,0.077355,0.262569,-0.1083780,-0.0003631,-0.110743,-0.005989,0.000247,-0.000076,37,O +2021-12-21,59569,0.075405,0.263444,-0.1079991,-0.0003958,-0.110539,-0.005957,0.000274,-0.000050,37,O +2021-12-22,59570,0.073133,0.264278,-0.1076234,-0.0003472,-0.110373,-0.005927,0.000250,-0.000038,37,O +2021-12-23,59571,0.070881,0.265173,-0.1073418,-0.0001681,-0.110167,-0.005926,0.000213,-0.000030,37,O +2021-12-24,59572,0.068514,0.266510,-0.1072445,0.0000386,-0.109820,-0.005940,0.000223,-0.000071,37,O +2021-12-25,59573,0.066054,0.267813,-0.1073681,0.0002146,-0.109476,-0.005907,0.000252,-0.000130,37,O +2021-12-26,59574,0.064264,0.268977,-0.1077173,0.0004337,-0.109284,-0.005886,0.000280,-0.000190,37,O +2021-12-27,59575,0.062771,0.270366,-0.1082590,0.0006074,-0.109258,-0.005945,0.000309,-0.000249,37,O +2021-12-28,59576,0.061119,0.271893,-0.1089162,0.0006456,-0.109321,-0.005997,0.000337,-0.000309,37,O +2021-12-29,59577,0.059184,0.273531,-0.1095688,0.0005855,-0.109831,-0.005839,0.000221,-0.000316,37,O +2021-12-30,59578,0.057753,0.274728,-0.1101029,0.0004366,-0.110666,-0.005560,0.000068,-0.000309,37,O +2021-12-31,59579,0.056304,0.275973,-0.1104355,0.0001907,-0.111412,-0.005426,0.000040,-0.000287,37,O +2022-01-01,59580,0.054574,0.276983,-0.1105197,-0.0000357,-0.111899,-0.005573,0.000059,-0.000259,37,O +2022-01-02,59581,0.053381,0.277886,-0.1103891,-0.0002254,-0.111877,-0.005801,0.000077,-0.000230,37,O +2022-01-03,59582,0.052855,0.278999,-0.1101398,-0.0002593,-0.111401,-0.005868,0.000095,-0.000202,37,O +2022-01-04,59583,0.053294,0.280607,-0.1099190,-0.0001210,-0.110807,-0.005829,0.000114,-0.000174,37,O +2022-01-05,59584,0.053559,0.282963,-0.1098692,0.0000832,-0.110307,-0.005882,0.000132,-0.000152,37,O +2022-01-06,59585,0.053042,0.285048,-0.1100259,0.0002481,-0.109937,-0.005974,0.000150,-0.000132,37,O +2022-01-07,59586,0.051849,0.286983,-0.1103610,0.0003632,-0.109778,-0.005861,0.000169,-0.000113,37,O +2022-01-08,59587,0.050225,0.288671,-0.1107892,0.0004361,-0.109885,-0.005484,0.000194,-0.000092,37,O +2022-01-09,59588,0.048602,0.290231,-0.1112277,0.0004120,-0.110147,-0.005099,0.000222,-0.000071,37,O +2022-01-10,59589,0.047155,0.291472,-0.1116091,0.0003188,-0.110373,-0.004960,0.000249,-0.000050,37,O +2022-01-11,59590,0.045595,0.292576,-0.1118697,0.0001719,-0.110484,-0.005049,0.000277,-0.000029,37,O +2022-01-12,59591,0.044205,0.293449,-0.1119606,-0.0000010,-0.110597,-0.005195,0.000266,-0.000035,37,O +2022-01-13,59592,0.043394,0.294345,-0.1118677,-0.0001786,-0.110603,-0.005273,0.000244,-0.000047,37,O +2022-01-14,59593,0.043106,0.295839,-0.1115941,-0.0003603,-0.110438,-0.005353,0.000223,-0.000060,37,O +2022-01-15,59594,0.043114,0.297844,-0.1111643,-0.0004983,-0.110195,-0.005540,0.000205,-0.000078,37,O +2022-01-16,59595,0.042534,0.299918,-0.1106129,-0.0005991,-0.110039,-0.005787,0.000188,-0.000097,37,O +2022-01-17,59596,0.041549,0.301463,-0.1100064,-0.0006154,-0.109987,-0.005955,0.000172,-0.000117,37,O +2022-01-18,59597,0.039912,0.303016,-0.1093760,-0.0006054,-0.109902,-0.005973,0.000155,-0.000136,37,O +2022-01-19,59598,0.038420,0.303951,-0.1088179,-0.0004807,-0.109671,-0.005907,0.000139,-0.000156,37,O +2022-01-20,59599,0.037831,0.305025,-0.1084531,-0.0002680,-0.109285,-0.005871,0.000157,-0.000185,37,O +2022-01-21,59600,0.037456,0.306196,-0.1082981,-0.0000409,-0.108956,-0.005893,0.000184,-0.000218,37,O +2022-01-22,59601,0.036968,0.307328,-0.1083306,0.0001170,-0.108866,-0.005897,0.000174,-0.000208,37,O +2022-01-23,59602,0.036011,0.308634,-0.1085119,0.0002229,-0.108922,-0.005877,0.000149,-0.000180,37,O +2022-01-24,59603,0.034458,0.310100,-0.1087689,0.0002555,-0.109048,-0.005839,0.000124,-0.000153,37,O +2022-01-25,59604,0.032747,0.311519,-0.1090294,0.0002359,-0.109241,-0.005759,0.000100,-0.000126,37,O +2022-01-26,59605,0.031327,0.312793,-0.1092242,0.0001302,-0.109416,-0.005652,0.000124,-0.000137,37,O +2022-01-27,59606,0.030254,0.314102,-0.1092764,-0.0000451,-0.109698,-0.005548,0.000162,-0.000159,37,O +2022-01-28,59607,0.029060,0.315654,-0.1091370,-0.0002362,-0.110085,-0.005577,0.000200,-0.000181,37,O +2022-01-29,59608,0.028306,0.317130,-0.1088191,-0.0004108,-0.110488,-0.005790,0.000198,-0.000190,37,O +2022-01-30,59609,0.027664,0.318978,-0.1083658,-0.0004934,-0.110627,-0.006064,0.000181,-0.000195,37,O +2022-01-31,59610,0.026619,0.320963,-0.1078483,-0.0004966,-0.110424,-0.006222,0.000165,-0.000200,37,O +2022-02-01,59611,0.026107,0.323014,-0.1073994,-0.0003435,-0.110029,-0.006256,0.000148,-0.000205,37,O +2022-02-02,59612,0.025834,0.325489,-0.1071431,-0.0001248,-0.109538,-0.006310,0.000154,-0.000230,37,O +2022-02-03,59613,0.025683,0.327751,-0.1070987,0.0000410,-0.109116,-0.006393,0.000165,-0.000260,37,O +2022-02-04,59614,0.025779,0.330022,-0.1072225,0.0001631,-0.108919,-0.006381,0.000176,-0.000291,37,O +2022-02-05,59615,0.025738,0.332211,-0.1074267,0.0002001,-0.109063,-0.006141,0.000179,-0.000242,37,O +2022-02-06,59616,0.025676,0.333942,-0.1076113,0.0001192,-0.109447,-0.005873,0.000180,-0.000163,37,O +2022-02-07,59617,0.025772,0.335603,-0.1076870,-0.0000055,-0.109853,-0.005790,0.000180,-0.000084,37,O +2022-02-08,59618,0.025193,0.337374,-0.1075919,-0.0001773,-0.110126,-0.005888,0.000180,-0.000005,37,O +2022-02-09,59619,0.024114,0.338478,-0.1072977,-0.0003784,-0.110203,-0.006067,0.000186,0.000003,37,O +2022-02-10,59620,0.022952,0.339544,-0.1067962,-0.0005835,-0.110062,-0.006157,0.000194,-0.000009,37,O +2022-02-11,59621,0.021317,0.340636,-0.1061126,-0.0007824,-0.109706,-0.006193,0.000202,-0.000020,37,O +2022-02-12,59622,0.019510,0.341957,-0.1052912,-0.0008659,-0.109259,-0.006321,0.000208,-0.000043,37,O +2022-02-13,59623,0.017952,0.343165,-0.1044265,-0.0008125,-0.108917,-0.006560,0.000214,-0.000071,37,O +2022-02-14,59624,0.017178,0.344276,-0.1036375,-0.0006966,-0.108763,-0.006785,0.000221,-0.000099,37,O +2022-02-15,59625,0.016814,0.345848,-0.1029937,-0.0005407,-0.108690,-0.006864,0.000227,-0.000127,37,O +2022-02-16,59626,0.016373,0.347600,-0.1025279,-0.0003604,-0.108569,-0.006803,0.000222,-0.000167,37,O +2022-02-17,59627,0.016174,0.349955,-0.1022855,-0.0001249,-0.108379,-0.006702,0.000213,-0.000210,37,O +2022-02-18,59628,0.015893,0.352552,-0.1022778,0.0001177,-0.108238,-0.006679,0.000205,-0.000253,37,O +2022-02-19,59629,0.016057,0.355009,-0.1024803,0.0003106,-0.108239,-0.006688,0.000199,-0.000224,37,O +2022-02-20,59630,0.016152,0.357350,-0.1028229,0.0003746,-0.108367,-0.006714,0.000194,-0.000170,37,O +2022-02-21,59631,0.016225,0.359459,-0.1032042,0.0003443,-0.108568,-0.006699,0.000189,-0.000115,37,O +2022-02-22,59632,0.016672,0.361277,-0.1035256,0.0002538,-0.108817,-0.006617,0.000184,-0.000061,37,O +2022-02-23,59633,0.017619,0.362779,-0.1037081,0.0000945,-0.109078,-0.006583,0.000177,-0.000085,37,O +2022-02-24,59634,0.018496,0.364360,-0.1036928,-0.0001444,-0.109259,-0.006613,0.000169,-0.000128,37,O +2022-02-25,59635,0.018931,0.365807,-0.1034734,-0.0003469,-0.109270,-0.006743,0.000162,-0.000172,37,O +2022-02-26,59636,0.019607,0.367229,-0.1031018,-0.0004237,-0.109106,-0.006902,0.000156,-0.000164,37,O +2022-02-27,59637,0.020241,0.368836,-0.1026797,-0.0004119,-0.108854,-0.007042,0.000150,-0.000136,37,O +2022-02-28,59638,0.020656,0.370624,-0.1023250,-0.0002793,-0.108624,-0.007107,0.000144,-0.000108,37,O +2022-03-01,59639,0.020909,0.372342,-0.1021425,-0.0000861,-0.108462,-0.007107,0.000139,-0.000080,37,O +2022-03-02,59640,0.021778,0.373951,-0.1021944,0.0001374,-0.108199,-0.007104,0.000190,-0.000054,37,O +2022-03-03,59641,0.023290,0.376273,-0.1024561,0.0003524,-0.107898,-0.007117,0.000256,-0.000028,37,O +2022-03-04,59642,0.024972,0.378479,-0.1028435,0.0004407,-0.107637,-0.007109,0.000322,-0.000003,37,O +2022-03-05,59643,0.026774,0.380581,-0.1032424,0.0003800,-0.107706,-0.007086,0.000310,-0.000006,37,O +2022-03-06,59644,0.028086,0.382600,-0.1035550,0.0002448,-0.108027,-0.007094,0.000269,-0.000021,37,O +2022-03-07,59645,0.029543,0.384798,-0.1037203,0.0000610,-0.108450,-0.007191,0.000228,-0.000036,37,O +2022-03-08,59646,0.031018,0.386712,-0.1036844,-0.0001762,-0.108826,-0.007354,0.000187,-0.000051,37,O +2022-03-09,59647,0.032281,0.388541,-0.1034089,-0.0003856,-0.108866,-0.007460,0.000208,-0.000044,37,O +2022-03-10,59648,0.033104,0.390312,-0.1029383,-0.0005485,-0.108612,-0.007475,0.000245,-0.000032,37,O +2022-03-11,59649,0.033708,0.392105,-0.1023346,-0.0006461,-0.108109,-0.007473,0.000283,-0.000019,37,O +2022-03-12,59650,0.034130,0.393729,-0.1016864,-0.0006622,-0.107569,-0.007581,0.000282,-0.000021,37,O +2022-03-13,59651,0.034502,0.395152,-0.1010372,-0.0006340,-0.107117,-0.007813,0.000267,-0.000027,37,O +2022-03-14,59652,0.034354,0.396685,-0.1004104,-0.0005758,-0.106877,-0.008063,0.000251,-0.000033,37,O +2022-03-15,59653,0.034250,0.398014,-0.0998830,-0.0004198,-0.106865,-0.008198,0.000236,-0.000040,37,O +2022-03-16,59654,0.033972,0.399563,-0.0995467,-0.0002068,-0.106918,-0.008181,0.000240,-0.000064,37,O +2022-03-17,59655,0.033426,0.401244,-0.0994339,0.0000163,-0.106930,-0.008064,0.000248,-0.000093,37,O +2022-03-18,59656,0.033046,0.402931,-0.0995428,0.0001805,-0.106876,-0.007950,0.000256,-0.000123,37,O +2022-03-19,59657,0.032894,0.404430,-0.0998242,0.0003191,-0.106884,-0.007889,0.000250,-0.000121,37,O +2022-03-20,59658,0.033017,0.405997,-0.1001905,0.0003801,-0.107059,-0.007919,0.000239,-0.000108,37,O +2022-03-21,59659,0.033291,0.407432,-0.1005194,0.0002940,-0.107409,-0.008005,0.000227,-0.000094,37,O +2022-03-22,59660,0.034163,0.408866,-0.1007374,0.0000994,-0.107806,-0.008084,0.000216,-0.000081,37,O +2022-03-23,59661,0.035739,0.410677,-0.1007668,-0.0001129,-0.108069,-0.008122,0.000204,-0.000068,37,O +2022-03-24,59662,0.037184,0.412921,-0.1005632,-0.0003225,-0.108121,-0.008146,0.000172,-0.000063,37,O +2022-03-25,59663,0.038276,0.415002,-0.1001852,-0.0004645,-0.107917,-0.008187,0.000135,-0.000060,37,O +2022-03-26,59664,0.039275,0.416959,-0.0997325,-0.0004511,-0.107413,-0.008263,0.000151,-0.000064,37,O +2022-03-27,59665,0.040293,0.418593,-0.0993188,-0.0003561,-0.106845,-0.008345,0.000188,-0.000069,37,O +2022-03-28,59666,0.041691,0.420175,-0.0990554,-0.0001799,-0.106412,-0.008410,0.000224,-0.000075,37,O +2022-03-29,59667,0.042792,0.421696,-0.0989777,0.0000252,-0.106189,-0.008449,0.000260,-0.000080,37,O +2022-03-30,59668,0.043491,0.423055,-0.0990426,0.0001445,-0.106244,-0.008453,0.000260,-0.000082,37,O +2022-03-31,59669,0.043570,0.424794,-0.0992346,0.0002320,-0.106398,-0.008414,0.000250,-0.000084,37,O +2022-04-01,59670,0.043301,0.426919,-0.0995031,0.0002946,-0.106506,-0.008343,0.000240,-0.000085,37,O +2022-04-02,59671,0.043471,0.428898,-0.0997958,0.0002749,-0.106536,-0.008278,0.000233,-0.000071,37,O +2022-04-03,59672,0.044401,0.430964,-0.1000185,0.0001447,-0.106583,-0.008291,0.000226,-0.000050,37,O +2022-04-04,59673,0.045179,0.433548,-0.1000877,-0.0000328,-0.106727,-0.008395,0.000220,-0.000030,37,O +2022-04-05,59674,0.045558,0.436184,-0.0999601,-0.0002317,-0.106928,-0.008515,0.000214,-0.000009,37,O +2022-04-06,59675,0.046324,0.438296,-0.0996161,-0.0004384,-0.107011,-0.008588,0.000222,-0.000008,37,O +2022-04-07,59676,0.047660,0.440084,-0.0991087,-0.0005727,-0.106904,-0.008610,0.000233,-0.000013,37,O +2022-04-08,59677,0.049412,0.441800,-0.0985116,-0.0006006,-0.106602,-0.008670,0.000245,-0.000018,37,O +2022-04-09,59678,0.051279,0.443588,-0.0979207,-0.0005595,-0.106131,-0.008844,0.000264,-0.000022,37,O +2022-04-10,59679,0.052631,0.445310,-0.0973816,-0.0005042,-0.105574,-0.009106,0.000286,-0.000028,37,O +2022-04-11,59680,0.053447,0.447037,-0.0969159,-0.0004145,-0.105095,-0.009347,0.000307,-0.000033,37,O +2022-04-12,59681,0.054284,0.449011,-0.0965845,-0.0002357,-0.104884,-0.009491,0.000329,-0.000038,37,O +2022-04-13,59682,0.055292,0.451073,-0.0964523,-0.0000043,-0.105062,-0.009565,0.000323,-0.000084,37,O +2022-04-14,59683,0.056547,0.452892,-0.0965557,0.0002481,-0.105379,-0.009547,0.000309,-0.000141,37,O +2022-04-15,59684,0.057823,0.454485,-0.0968994,0.0004668,-0.105550,-0.009362,0.000302,-0.000137,37,O +2022-04-16,59685,0.059424,0.456172,-0.0974129,0.0005563,-0.105603,-0.009095,0.000298,-0.000109,37,O +2022-04-17,59686,0.061164,0.457851,-0.0979865,0.0005239,-0.105807,-0.008908,0.000293,-0.000082,37,O +2022-04-18,59687,0.063734,0.459266,-0.0985020,0.0004144,-0.106274,-0.008922,0.000289,-0.000054,37,O +2022-04-19,59688,0.066192,0.460869,-0.0988272,0.0002090,-0.106773,-0.009104,0.000284,-0.000027,37,O +2022-04-20,59689,0.068329,0.461999,-0.0988949,-0.0000552,-0.106960,-0.009291,0.000280,0.000001,37,O +2022-04-21,59690,0.070468,0.463064,-0.0987060,-0.0003082,-0.106695,-0.009434,0.000297,-0.000039,37,O +2022-04-22,59691,0.072707,0.464098,-0.0983386,-0.0004087,-0.106211,-0.009508,0.000320,-0.000096,37,O +2022-04-23,59692,0.075204,0.465058,-0.0979051,-0.0003976,-0.105797,-0.009527,0.000323,-0.000106,37,O +2022-04-24,59693,0.077859,0.466247,-0.0975194,-0.0003138,-0.105498,-0.009555,0.000318,-0.000099,37,O +2022-04-25,59694,0.080557,0.467896,-0.0972632,-0.0001778,-0.105265,-0.009590,0.000313,-0.000093,37,O +2022-04-26,59695,0.082859,0.469891,-0.0971847,-0.0000024,-0.105109,-0.009593,0.000308,-0.000086,37,O +2022-04-27,59696,0.084908,0.471486,-0.0972203,0.0001167,-0.105096,-0.009548,0.000307,-0.000106,37,O +2022-04-28,59697,0.086518,0.472819,-0.0973522,0.0001364,-0.105258,-0.009407,0.000307,-0.000133,37,O +2022-04-29,59698,0.087895,0.473595,-0.0974914,0.0001236,-0.105480,-0.009203,0.000308,-0.000160,37,O +2022-04-30,59699,0.089653,0.474104,-0.0975559,0.0000411,-0.105614,-0.009011,0.000307,-0.000141,37,O +2022-05-01,59700,0.091728,0.474632,-0.0975257,-0.0000873,-0.105627,-0.008987,0.000306,-0.000104,37,O +2022-05-02,59701,0.093634,0.475311,-0.0974187,-0.0001804,-0.105619,-0.009154,0.000304,-0.000068,37,O +2022-05-03,59702,0.095563,0.476140,-0.0972185,-0.0002597,-0.105662,-0.009372,0.000303,-0.000031,37,O +2022-05-04,59703,0.097691,0.476906,-0.0969126,-0.0003627,-0.105734,-0.009493,0.000302,0.000005,37,O +2022-05-05,59704,0.099882,0.477903,-0.0964992,-0.0004471,-0.105770,-0.009526,0.000306,0.000025,37,O +2022-05-06,59705,0.101687,0.478833,-0.0960256,-0.0004926,-0.105754,-0.009581,0.000311,0.000041,37,O +2022-05-07,59706,0.103404,0.479538,-0.0955546,-0.0004413,-0.105646,-0.009779,0.000312,0.000014,37,O +2022-05-08,59707,0.105117,0.480078,-0.0951550,-0.0003482,-0.105347,-0.010030,0.000312,-0.000029,37,O +2022-05-09,59708,0.106699,0.480537,-0.0949242,-0.0001830,-0.104904,-0.010197,0.000312,-0.000072,37,O +2022-05-10,59709,0.108427,0.480933,-0.0948334,0.0000630,-0.104607,-0.010261,0.000311,-0.000116,37,O +2022-05-11,59710,0.110941,0.481776,-0.0950144,0.0003317,-0.104732,-0.010281,0.000308,-0.000138,37,O +2022-05-12,59711,0.113474,0.482707,-0.0954543,0.0005401,-0.105174,-0.010290,0.000303,-0.000155,37,O +2022-05-13,59712,0.116107,0.483379,-0.0960629,0.0006728,-0.105566,-0.010162,0.000299,-0.000172,37,O +2022-05-14,59713,0.118527,0.483975,-0.0967431,0.0006758,-0.105773,-0.009799,0.000308,-0.000168,37,O +2022-05-15,59714,0.120799,0.484444,-0.0973670,0.0005635,-0.106086,-0.009399,0.000321,-0.000156,37,O +2022-05-16,59715,0.122385,0.485333,-0.0978659,0.0003927,-0.106653,-0.009281,0.000335,-0.000144,37,O +2022-05-17,59716,0.123240,0.485912,-0.0981728,0.0001822,-0.107146,-0.009513,0.000349,-0.000131,37,O +2022-05-18,59717,0.124614,0.485666,-0.0982338,-0.0000398,-0.107148,-0.009846,0.000360,-0.000115,37,O +2022-05-19,59718,0.126492,0.485563,-0.0980742,-0.0001864,-0.106655,-0.010034,0.000371,-0.000098,37,O +2022-05-20,59719,0.128370,0.485536,-0.0979421,-0.0002105,-0.106062,-0.010068,0.000382,-0.000080,37,O +2022-05-21,59720,0.130677,0.486020,-0.0977739,-0.0001399,-0.105765,-0.010071,0.000370,-0.000069,37,O +2022-05-22,59721,0.132949,0.486774,-0.0977075,0.0000022,-0.105758,-0.010059,0.000349,-0.000059,37,O +2022-05-23,59722,0.135359,0.487350,-0.0977582,0.0001510,-0.105848,-0.009982,0.000327,-0.000050,37,O +2022-05-24,59723,0.137703,0.488205,-0.0979698,0.0002528,-0.105891,-0.009829,0.000306,-0.000041,37,O +2022-05-25,59724,0.139642,0.488593,-0.0982642,0.0002434,-0.105852,-0.009614,0.000312,-0.000009,37,O +2022-05-26,59725,0.141637,0.488529,-0.0985094,0.0002071,-0.105918,-0.009361,0.000325,0.000029,37,O +2022-05-27,59726,0.143638,0.488445,-0.0986407,0.0000754,-0.106153,-0.009084,0.000338,0.000066,37,O +2022-05-28,59727,0.145102,0.488400,-0.0986068,-0.0001651,-0.106467,-0.008914,0.000336,0.000064,37,O +2022-05-29,59728,0.146706,0.488268,-0.0983314,-0.0004364,-0.106669,-0.008976,0.000329,0.000046,37,O +2022-05-30,59729,0.148067,0.488086,-0.0977877,-0.0006967,-0.106716,-0.009293,0.000322,0.000028,37,O +2022-05-31,59730,0.149795,0.487092,-0.0969563,-0.0009206,-0.106703,-0.009703,0.000314,0.000011,37,O +2022-06-01,59731,0.151943,0.486170,-0.0959109,-0.0010845,-0.106731,-0.009971,0.000307,-0.000007,37,O +2022-06-02,59732,0.154357,0.485426,-0.0947757,-0.0011408,-0.106670,-0.010005,0.000376,-0.000007,37,O +2022-06-03,59733,0.156589,0.484781,-0.0936356,-0.0011169,-0.106660,-0.009955,0.000463,-0.000003,37,O +2022-06-04,59734,0.158889,0.484149,-0.0925602,-0.0010138,-0.106851,-0.009984,0.000465,-0.000013,37,O +2022-06-05,59735,0.161161,0.483622,-0.0916220,-0.0008734,-0.106921,-0.010058,0.000435,-0.000027,37,O +2022-06-06,59736,0.163382,0.483150,-0.0908246,-0.0007378,-0.106715,-0.010044,0.000405,-0.000041,37,O +2022-06-07,59737,0.166198,0.482812,-0.0901686,-0.0005555,-0.106474,-0.009925,0.000375,-0.000055,37,O +2022-06-08,59738,0.169346,0.482843,-0.0896819,-0.0003808,-0.106581,-0.009834,0.000345,-0.000069,37,O +2022-06-09,59739,0.172338,0.482895,-0.0893344,-0.0002872,-0.107056,-0.009817,0.000340,-0.000057,37,O +2022-06-10,59740,0.175150,0.482907,-0.0890843,-0.0002453,-0.107652,-0.009745,0.000341,-0.000039,37,O +2022-06-11,59741,0.177834,0.482720,-0.0888551,-0.0003041,-0.108201,-0.009465,0.000329,-0.000042,37,O +2022-06-12,59742,0.180290,0.482016,-0.0885165,-0.0004513,-0.108809,-0.009083,0.000312,-0.000054,37,O +2022-06-13,59743,0.182826,0.481258,-0.0879480,-0.0006834,-0.109531,-0.008942,0.000296,-0.000065,37,O +2022-06-14,59744,0.185100,0.480403,-0.0870940,-0.0009713,-0.110036,-0.009188,0.000279,-0.000077,37,O +2022-06-15,59745,0.187052,0.479331,-0.0859830,-0.0012046,-0.109873,-0.009588,0.000293,-0.000109,37,O +2022-06-16,59746,0.189149,0.478024,-0.0847332,-0.0012518,-0.109222,-0.009837,0.000316,-0.000146,37,O +2022-06-17,59747,0.191602,0.476728,-0.0834949,-0.0011637,-0.108594,-0.009934,0.000338,-0.000184,37,O +2022-06-18,59748,0.194019,0.475550,-0.0824189,-0.0009673,-0.108365,-0.009983,0.000341,-0.000186,37,O +2022-06-19,59749,0.196541,0.474534,-0.0815575,-0.0007600,-0.108509,-0.009976,0.000336,-0.000174,37,O +2022-06-20,59750,0.199454,0.473574,-0.0808812,-0.0006133,-0.108836,-0.009796,0.000331,-0.000163,37,O +2022-06-21,59751,0.202403,0.472799,-0.0803109,-0.0005480,-0.109153,-0.009467,0.000327,-0.000152,37,O +2022-06-22,59752,0.205128,0.472282,-0.0797589,-0.0005850,-0.109347,-0.009175,0.000322,-0.000141,37,O +2022-06-23,59753,0.207619,0.471645,-0.0791011,-0.0007191,-0.109587,-0.009025,0.000273,-0.000124,37,O +2022-06-24,59754,0.210148,0.470821,-0.0782976,-0.0009049,-0.109961,-0.008971,0.000212,-0.000107,37,O +2022-06-25,59755,0.212693,0.469719,-0.0773260,-0.0010879,-0.110305,-0.008982,0.000222,-0.000111,37,O +2022-06-26,59756,0.215376,0.468485,-0.0761726,-0.0012474,-0.110571,-0.009112,0.000259,-0.000123,37,O +2022-06-27,59757,0.218164,0.467038,-0.0748406,-0.0014033,-0.110659,-0.009428,0.000296,-0.000135,37,O +2022-06-28,59758,0.221330,0.465623,-0.0733645,-0.0015360,-0.110576,-0.009834,0.000333,-0.000147,37,O +2022-06-29,59759,0.224443,0.464165,-0.0718011,-0.0015903,-0.110496,-0.010059,0.000359,-0.000125,37,O +2022-06-30,59760,0.227220,0.462671,-0.0702118,-0.0015738,-0.110526,-0.009992,0.000382,-0.000094,37,O +2022-07-01,59761,0.230002,0.460818,-0.0686663,-0.0015022,-0.110679,-0.009749,0.000406,-0.000063,37,O +2022-07-02,59762,0.232881,0.459225,-0.0672447,-0.0013642,-0.110959,-0.009582,0.000393,-0.000073,37,O +2022-07-03,59763,0.236109,0.457809,-0.0659625,-0.0011592,-0.111150,-0.009536,0.000367,-0.000099,37,O +2022-07-04,59764,0.239234,0.456579,-0.0649159,-0.0009084,-0.111121,-0.009498,0.000340,-0.000125,37,O +2022-07-05,59765,0.241892,0.455171,-0.0641393,-0.0006862,-0.110976,-0.009390,0.000313,-0.000150,37,O +2022-07-06,59766,0.244450,0.453302,-0.0635337,-0.0005426,-0.110950,-0.009262,0.000314,-0.000154,37,O +2022-07-07,59767,0.247124,0.451582,-0.0630501,-0.0004797,-0.111305,-0.009226,0.000321,-0.000151,37,O +2022-07-08,59768,0.249756,0.450120,-0.0625785,-0.0004960,-0.111978,-0.009228,0.000318,-0.000142,37,O +2022-07-09,59769,0.252297,0.448682,-0.0620271,-0.0006294,-0.112723,-0.009129,0.000311,-0.000130,37,O +2022-07-10,59770,0.254733,0.447060,-0.0612967,-0.0008520,-0.113423,-0.008960,0.000305,-0.000118,37,O +2022-07-11,59771,0.256857,0.445395,-0.0603249,-0.0010853,-0.114007,-0.008936,0.000298,-0.000107,37,O +2022-07-12,59772,0.258411,0.443974,-0.0591324,-0.0012873,-0.114246,-0.009142,0.000291,-0.000095,37,O +2022-07-13,59773,0.259174,0.442066,-0.0577813,-0.0013649,-0.113960,-0.009403,0.000300,-0.000118,37,O +2022-07-14,59774,0.260201,0.439888,-0.0564587,-0.0012892,-0.113418,-0.009484,0.000313,-0.000150,37,O +2022-07-15,59775,0.261642,0.438122,-0.0552630,-0.0010962,-0.113037,-0.009466,0.000326,-0.000182,37,O +2022-07-16,59776,0.263441,0.436373,-0.0542876,-0.0008698,-0.112983,-0.009496,0.000335,-0.000163,37,O +2022-07-17,59777,0.265267,0.434398,-0.0535228,-0.0006893,-0.113161,-0.009544,0.000344,-0.000122,37,O +2022-07-18,59778,0.267234,0.432352,-0.0528927,-0.0005997,-0.113506,-0.009398,0.000352,-0.000081,37,O +2022-07-19,59779,0.269260,0.430298,-0.0523068,-0.0006023,-0.113947,-0.009037,0.000360,-0.000040,37,O +2022-07-20,59780,0.270974,0.428173,-0.0516628,-0.0006984,-0.114393,-0.008784,0.000337,-0.000064,37,O +2022-07-21,59781,0.272574,0.426255,-0.0508922,-0.0008571,-0.114674,-0.008805,0.000306,-0.000105,37,O +2022-07-22,59782,0.274053,0.424453,-0.0499591,-0.0010273,-0.114884,-0.009018,0.000275,-0.000147,37,O +2022-07-23,59783,0.275681,0.422673,-0.0488673,-0.0011798,-0.115096,-0.009210,0.000282,-0.000165,37,O +2022-07-24,59784,0.277006,0.420915,-0.0476028,-0.0013501,-0.115333,-0.009343,0.000304,-0.000173,37,O +2022-07-25,59785,0.278471,0.419285,-0.0462003,-0.0014358,-0.115452,-0.009519,0.000327,-0.000181,37,O +2022-07-26,59786,0.279867,0.417962,-0.0447491,-0.0014548,-0.115399,-0.009768,0.000349,-0.000190,37,O +2022-07-27,59787,0.281044,0.416126,-0.0432579,-0.0014585,-0.115379,-0.009934,0.000331,-0.000183,37,O +2022-07-28,59788,0.282267,0.414205,-0.0417953,-0.0014381,-0.115431,-0.009867,0.000303,-0.000172,37,O +2022-07-29,59789,0.283345,0.411841,-0.0404282,-0.0013321,-0.115538,-0.009595,0.000274,-0.000161,37,O +2022-07-30,59790,0.284587,0.409400,-0.0392089,-0.0011116,-0.115593,-0.009353,0.000267,-0.000190,37,O +2022-07-31,59791,0.286000,0.407286,-0.0381849,-0.0008909,-0.115593,-0.009273,0.000267,-0.000233,37,O +2022-08-01,59792,0.287161,0.405194,-0.0373892,-0.0007008,-0.115536,-0.009320,0.000268,-0.000276,37,O +2022-08-02,59793,0.287882,0.403262,-0.0367846,-0.0005426,-0.115439,-0.009376,0.000268,-0.000319,37,O +2022-08-03,59794,0.288468,0.401019,-0.0362792,-0.0004556,-0.115414,-0.009314,0.000267,-0.000295,37,O +2022-08-04,59795,0.289489,0.398709,-0.0358145,-0.0004487,-0.115635,-0.009222,0.000265,-0.000254,37,O +2022-08-05,59796,0.290582,0.396579,-0.0353263,-0.0005230,-0.116154,-0.009192,0.000267,-0.000247,37,O +2022-08-06,59797,0.291080,0.394221,-0.0347316,-0.0006895,-0.116838,-0.009204,0.000271,-0.000253,37,O +2022-08-07,59798,0.291487,0.391652,-0.0339451,-0.0008715,-0.117435,-0.009261,0.000275,-0.000259,37,O +2022-08-08,59799,0.292293,0.389056,-0.0329721,-0.0010338,-0.117715,-0.009399,0.000279,-0.000264,37,O +2022-08-09,59800,0.293211,0.386232,-0.0318918,-0.0010953,-0.117585,-0.009565,0.000282,-0.000270,37,O +2022-08-10,59801,0.293803,0.383250,-0.0308088,-0.0010233,-0.117149,-0.009591,0.000300,-0.000281,37,O +2022-08-11,59802,0.294459,0.380298,-0.0298577,-0.0008434,-0.116770,-0.009397,0.000321,-0.000293,37,O +2022-08-12,59803,0.295055,0.377755,-0.0291384,-0.0006199,-0.116681,-0.009171,0.000342,-0.000305,37,O +2022-08-13,59804,0.295537,0.375740,-0.0286307,-0.0004312,-0.116834,-0.009134,0.000344,-0.000290,37,O +2022-08-14,59805,0.296313,0.373591,-0.0282983,-0.0003275,-0.117006,-0.009266,0.000339,-0.000266,37,O +2022-08-15,59806,0.297500,0.371314,-0.0279699,-0.0003218,-0.117203,-0.009307,0.000333,-0.000241,37,O +2022-08-16,59807,0.298583,0.369059,-0.0276395,-0.0004297,-0.117555,-0.009139,0.000328,-0.000217,37,O +2022-08-17,59808,0.299254,0.366732,-0.0270866,-0.0006249,-0.118003,-0.008949,0.000323,-0.000193,37,O +2022-08-18,59809,0.299866,0.364425,-0.0263517,-0.0008700,-0.118274,-0.008860,0.000342,-0.000071,37,O +2022-08-19,59810,0.300823,0.362010,-0.0253455,-0.0010674,-0.118335,-0.008921,0.000368,0.000072,37,O +2022-08-20,59811,0.302176,0.359779,-0.0241871,-0.0012488,-0.118439,-0.009099,0.000343,0.000063,37,O +2022-08-21,59812,0.302992,0.357455,-0.0228266,-0.0013887,-0.118572,-0.009192,0.000299,-0.000002,37,O +2022-08-22,59813,0.303769,0.354926,-0.0213929,-0.0014142,-0.118711,-0.009174,0.000223,0.000000,37,O +2022-08-23,59814,0.304513,0.352500,-0.0199836,-0.0013938,-0.118563,-0.009296,0.000220,-0.000053,37,O +2022-08-24,59815,0.304896,0.349874,-0.0186613,-0.0013096,-0.118310,-0.009455,0.000250,-0.000087,37,O +2022-08-25,59816,0.305201,0.347486,-0.0174037,-0.0011721,-0.118092,-0.009509,0.000288,-0.000116,37,O +2022-08-26,59817,0.305398,0.344912,-0.0162851,-0.0010132,-0.117898,-0.009376,0.000327,-0.000145,37,O +2022-08-27,59818,0.305290,0.342335,-0.0153482,-0.0008311,-0.117776,-0.009142,0.000327,-0.000159,37,O +2022-08-28,59819,0.304974,0.339946,-0.0146136,-0.0006297,-0.117687,-0.008993,0.000314,-0.000166,37,O +2022-08-29,59820,0.304586,0.337401,-0.0140968,-0.0004071,-0.117660,-0.009022,0.000300,-0.000173,37,O +2022-08-30,59821,0.304464,0.334971,-0.0137838,-0.0002461,-0.117694,-0.009153,0.000286,-0.000180,37,O +2022-08-31,59822,0.304595,0.332751,-0.0136099,-0.0001468,-0.117736,-0.009230,0.000282,-0.000167,37,O +2022-09-01,59823,0.304814,0.330440,-0.0134836,-0.0001740,-0.117854,-0.009197,0.000281,-0.000148,37,O +2022-09-02,59824,0.304501,0.327651,-0.0132494,-0.0003019,-0.118154,-0.009102,0.000279,-0.000128,37,O +2022-09-03,59825,0.304186,0.324993,-0.0128821,-0.0004375,-0.118590,-0.009080,0.000278,-0.000145,37,O +2022-09-04,59826,0.304085,0.322764,-0.0123741,-0.0006067,-0.118929,-0.009170,0.000277,-0.000176,37,O +2022-09-05,59827,0.303820,0.320481,-0.0117203,-0.0006953,-0.118715,-0.009299,0.000356,-0.000177,37,O +2022-09-06,59828,0.303248,0.318029,-0.0110190,-0.0006716,-0.118490,-0.009420,0.000290,-0.000231,37,O +2022-09-07,59829,0.302652,0.314951,-0.0103738,-0.0005314,-0.117928,-0.009248,0.000320,-0.000193,37,O +2022-09-08,59830,0.301793,0.311758,-0.0099952,-0.0003090,-0.117555,-0.008854,0.000376,-0.000131,37,O +2022-09-09,59831,0.300297,0.308670,-0.0098037,-0.0000563,-0.117535,-0.008462,0.000431,-0.000068,37,O +2022-09-10,59832,0.299086,0.305665,-0.0098938,0.0001980,-0.117785,-0.008356,0.000425,-0.000069,37,O +2022-09-11,59833,0.298524,0.302843,-0.0101991,0.0003620,-0.117952,-0.008498,0.000396,-0.000094,37,O +2022-09-12,59834,0.298153,0.300265,-0.0105663,0.0003547,-0.118015,-0.008668,0.000364,-0.000118,37,O +2022-09-13,59835,0.297509,0.297897,-0.0108687,0.0002112,-0.118191,-0.008727,0.000336,-0.000143,37,O +2022-09-14,59836,0.296992,0.295809,-0.0110048,0.0000090,-0.118525,-0.008698,0.000331,-0.000130,37,O +2022-09-15,59837,0.296326,0.293853,-0.0109071,-0.0002310,-0.118889,-0.008737,0.000331,-0.000107,37,O +2022-09-16,59838,0.295633,0.291666,-0.0105453,-0.0004503,-0.119069,-0.008841,0.000332,-0.000084,37,O +2022-09-17,59839,0.294765,0.289613,-0.0099966,-0.0006416,-0.119260,-0.008985,0.000229,-0.000169,37,O +2022-09-18,59840,0.293594,0.287789,-0.0092502,-0.0007737,-0.119359,-0.009034,0.000089,-0.000294,37,O +2022-09-19,59841,0.292235,0.285928,-0.0084134,-0.0008552,-0.118767,-0.008893,0.000183,-0.000264,37,O +2022-09-20,59842,0.291284,0.283515,-0.0075559,-0.0008596,-0.117876,-0.008797,0.000385,-0.000164,37,O +2022-09-21,59843,0.290675,0.281089,-0.0066950,-0.0007858,-0.117536,-0.008865,0.000391,-0.000099,37,O +2022-09-22,59844,0.289785,0.278400,-0.0059969,-0.0006484,-0.117441,-0.008922,0.000347,-0.000043,37,O +2022-09-23,59845,0.288673,0.275532,-0.0054471,-0.0004588,-0.117457,-0.008810,0.000302,0.000013,37,O +2022-09-24,59846,0.287244,0.272949,-0.0051006,-0.0002620,-0.117465,-0.008621,0.000281,-0.000021,37,O +2022-09-25,59847,0.285878,0.270404,-0.0049635,-0.0000762,-0.117484,-0.008457,0.000268,-0.000089,37,O +2022-09-26,59848,0.285103,0.268121,-0.0049793,0.0000876,-0.117537,-0.008441,0.000256,-0.000157,37,O +2022-09-27,59849,0.284746,0.266357,-0.0051012,0.0001844,-0.117616,-0.008597,0.000243,-0.000225,37,O +2022-09-28,59850,0.283878,0.264953,-0.0053014,0.0001489,-0.117693,-0.008703,0.000229,-0.000180,37,O +2022-09-29,59851,0.282943,0.263319,-0.0054180,0.0000247,-0.117779,-0.008707,0.000213,-0.000102,37,O +2022-09-30,59852,0.282338,0.261528,-0.0053388,-0.0001717,-0.117905,-0.008604,0.000198,-0.000025,37,O +2022-10-01,59853,0.281388,0.259744,-0.0049041,-0.0004002,-0.117919,-0.008575,0.000233,-0.000065,37,O +2022-10-02,59854,0.280092,0.257931,-0.0043864,-0.0004904,-0.117763,-0.008633,0.000289,-0.000153,37,O +2022-10-03,59855,0.278478,0.255746,-0.0040146,-0.0004785,-0.117380,-0.008681,0.000335,-0.000178,37,O +2022-10-04,59856,0.276607,0.253527,-0.0035590,-0.0004129,-0.116777,-0.008672,0.000377,-0.000174,37,O +2022-10-05,59857,0.274352,0.251450,-0.0032281,-0.0002727,-0.116158,-0.008550,0.000419,-0.000171,37,O +2022-10-06,59858,0.272409,0.249284,-0.0030816,-0.0000290,-0.115892,-0.008306,0.000413,-0.000159,37,O +2022-10-07,59859,0.270869,0.246728,-0.0031810,0.0002299,-0.115963,-0.008047,0.000393,-0.000144,37,O +2022-10-08,59860,0.269464,0.244272,-0.0035337,0.0004475,-0.116181,-0.007889,0.000370,-0.000130,37,O +2022-10-09,59861,0.267436,0.242181,-0.0040628,0.0005515,-0.116323,-0.007852,0.000345,-0.000116,37,O +2022-10-10,59862,0.265240,0.239987,-0.0046541,0.0005668,-0.116330,-0.007871,0.000320,-0.000102,37,O +2022-10-11,59863,0.263701,0.237885,-0.0051692,0.0004419,-0.116344,-0.007899,0.000295,-0.000088,37,O +2022-10-12,59864,0.262046,0.235701,-0.0055011,0.0002017,-0.116517,-0.007950,0.000271,-0.000074,37,O +2022-10-13,59865,0.260021,0.233734,-0.0055722,-0.0000324,-0.116707,-0.008023,0.000294,-0.000044,37,O +2022-10-14,59866,0.256936,0.232102,-0.0054362,-0.0001958,-0.116793,-0.008078,0.000330,-0.000010,37,O +2022-10-15,59867,0.254063,0.230356,-0.0051876,-0.0002708,-0.116700,-0.008075,0.000335,-0.000015,37,O +2022-10-16,59868,0.251206,0.228893,-0.0049099,-0.0002692,-0.116365,-0.007987,0.000327,-0.000034,37,O +2022-10-17,59869,0.248052,0.227286,-0.0046783,-0.0001717,-0.115804,-0.007935,0.000352,-0.000079,37,O +2022-10-18,59870,0.245102,0.225158,-0.0045660,-0.0000332,-0.115200,-0.008015,0.000394,-0.000137,37,O +2022-10-19,59871,0.243041,0.222898,-0.0045814,0.0001434,-0.114747,-0.008164,0.000407,-0.000163,37,O +2022-10-20,59872,0.240817,0.221191,-0.0047645,0.0002754,-0.114446,-0.008265,0.000413,-0.000180,37,O +2022-10-21,59873,0.237688,0.219313,-0.0051434,0.0004368,-0.114344,-0.008197,0.000419,-0.000197,37,O +2022-10-22,59874,0.234606,0.217522,-0.0057243,0.0006618,-0.114532,-0.007927,0.000398,-0.000185,37,O +2022-10-23,59875,0.231878,0.216031,-0.0064986,0.0008786,-0.114866,-0.007589,0.000368,-0.000162,37,O +2022-10-24,59876,0.230043,0.214645,-0.0074339,0.0009730,-0.115163,-0.007341,0.000337,-0.000139,37,O +2022-10-25,59877,0.228137,0.213232,-0.0084121,0.0009253,-0.115318,-0.007265,0.000307,-0.000116,37,O +2022-10-26,59878,0.226115,0.211747,-0.0092591,0.0007382,-0.115297,-0.007349,0.000303,-0.000092,37,O +2022-10-27,59879,0.223756,0.210409,-0.0098856,0.0004920,-0.115222,-0.007492,0.000307,-0.000068,37,O +2022-10-28,59880,0.220823,0.208832,-0.0102779,0.0002273,-0.115143,-0.007612,0.000310,-0.000083,37,O +2022-10-29,59881,0.217711,0.207417,-0.0103958,0.0000214,-0.115022,-0.007628,0.000312,-0.000114,37,O +2022-10-30,59882,0.214479,0.206229,-0.0103095,-0.0000903,-0.114810,-0.007575,0.000314,-0.000145,37,O +2022-10-31,59883,0.211344,0.205236,-0.0101927,-0.0000786,-0.114492,-0.007537,0.000316,-0.000176,37,O +2022-11-01,59884,0.208518,0.204213,-0.0101774,0.0001052,-0.114100,-0.007544,0.000319,-0.000208,37,O +2022-11-02,59885,0.206236,0.203539,-0.0104066,0.0003887,-0.113655,-0.007496,0.000345,-0.000189,37,O +2022-11-03,59886,0.203843,0.202363,-0.0109528,0.0007038,-0.113289,-0.007387,0.000379,-0.000156,37,O +2022-11-04,59887,0.201480,0.201349,-0.0118134,0.0009475,-0.113093,-0.007232,0.000413,-0.000124,37,O +2022-11-05,59888,0.199408,0.200705,-0.0128173,0.0010203,-0.113210,-0.007050,0.000389,-0.000091,37,O +2022-11-06,59889,0.197881,0.199784,-0.0138347,0.0009614,-0.113445,-0.006858,0.000344,-0.000059,37,O +2022-11-07,59890,0.196413,0.198989,-0.0147268,0.0008196,-0.113604,-0.006682,0.000300,-0.000027,37,O +2022-11-08,59891,0.194573,0.198429,-0.0154464,0.0006267,-0.113650,-0.006581,0.000255,0.000005,37,O +2022-11-09,59892,0.192689,0.197560,-0.0159730,0.0004151,-0.113611,-0.006688,0.000239,-0.000042,37,O +2022-11-10,59893,0.190373,0.196713,-0.0162609,0.0001422,-0.113607,-0.006856,0.000249,-0.000047,37,O +2022-11-11,59894,0.187815,0.195886,-0.0162986,-0.0000879,-0.113664,-0.007014,0.000257,-0.000052,37,O +2022-11-12,59895,0.185358,0.195077,-0.0160849,-0.0002328,-0.113613,-0.007056,0.000263,-0.000057,37,O +2022-11-13,59896,0.183211,0.193994,-0.0158139,-0.0002714,-0.113353,-0.006995,0.000270,-0.000060,37,O +2022-11-14,59897,0.181781,0.192797,-0.0155463,-0.0002358,-0.112951,-0.006948,0.000276,-0.000060,37,O +2022-11-15,59898,0.181070,0.192172,-0.0153598,-0.0001051,-0.112526,-0.006990,0.000280,-0.000059,37,O +2022-11-16,59899,0.180605,0.192088,-0.0153088,0.0000691,-0.112124,-0.007060,0.000279,-0.000059,37,O +2022-11-17,59900,0.179893,0.192230,-0.0154737,0.0002577,-0.111795,-0.007032,0.000269,-0.000062,37,O +2022-11-18,59901,0.178577,0.192664,-0.0158672,0.0004613,-0.111688,-0.006855,0.000254,-0.000067,37,O +2022-11-19,59902,0.176611,0.192952,-0.0164339,0.0006352,-0.111942,-0.006595,0.000237,-0.000075,37,O +2022-11-20,59903,0.174681,0.192934,-0.0171380,0.0007456,-0.112447,-0.006335,0.000223,-0.000082,37,O +2022-11-21,59904,0.172464,0.192697,-0.0179310,0.0007712,-0.112896,-0.006109,0.000217,-0.000086,37,O +2022-11-22,59905,0.170148,0.192561,-0.0187050,0.0006878,-0.113096,-0.005950,0.000220,-0.000087,37,O +2022-11-23,59906,0.167859,0.192139,-0.0193305,0.0005103,-0.113107,-0.005944,0.000230,-0.000085,37,O +2022-11-24,59907,0.165813,0.191632,-0.0196762,0.0002469,-0.113034,-0.006130,0.000242,-0.000082,37,O +2022-11-25,59908,0.163365,0.191410,-0.0197815,-0.0000026,-0.112859,-0.006373,0.000253,-0.000079,37,O +2022-11-26,59909,0.160567,0.191170,-0.0197136,-0.0001201,-0.112567,-0.006465,0.000259,-0.000077,37,O +2022-11-27,59910,0.157813,0.190855,-0.0196014,-0.0001015,-0.112263,-0.006366,0.000261,-0.000075,37,P +2022-11-28,59911,0.155197,0.190599,-0.0195762,0.0000705,-0.112064,-0.006235,0.000258,-0.000075,37,P +2022-11-29,59912,0.152559,0.190618,-0.0197928,0.0003553,-0.111960,-0.006203,0.000251,-0.000075,37,P +2022-11-30,59913,0.149929,0.190670,-0.0202955,0.0006305,-0.111871,-0.006224,0.000241,-0.000075,37,P +2022-12-01,59914,0.147561,0.190830,-0.0210441,0.0008401,-0.111780,-0.006185,0.000230,-0.000074,37,P +2022-12-02,59915,0.145248,0.191146,-0.0219561,0.0009527,-0.111743,-0.006059,0.000220,-0.000071,37,P +2022-12-03,59916,0.142834,0.191464,-0.0229272,0.0009599,-0.111816,-0.005893,0.000216,-0.000067,37,P +2022-12-04,59917,0.140395,0.191770,-0.0238615,0.0008862,-0.111970,-0.005719,0.000218,-0.000063,37,P +2022-12-05,59918,0.137848,0.192067,-0.0246892,0.0007438,-0.112074,-0.005553,0.000226,-0.000062,37,P +2022-12-06,59919,0.135194,0.192376,-0.0253354,0.0005219,-0.111999,-0.005456,0.000238,-0.000064,37,P +2022-12-07,59920,0.132607,0.192847,-0.0257409,0.0002838,-0.111768,-0.005519,0.000251,-0.000071,37,P +2022-12-08,59921,0.130239,0.193289,-0.0259378,0.0001092,-0.111546,-0.005750,0.000261,-0.000081,37,P +2022-12-09,59922,0.127844,0.193671,-0.0259973,0.0000080,-0.111448,-0.006015,0.000269,-0.000092,37,P +2022-12-10,59923,0.125281,0.193926,-0.0259903,-0.0000231,-0.111412,-0.006156,0.000274,-0.000101,37,P +2022-12-11,59924,0.122674,0.194270,-0.0259909,0.0000263,-0.111310,-0.006148,0.000278,-0.000106,37,P +2022-12-12,59925,0.120190,0.194862,-0.0260820,0.0001542,-0.111096,-0.006107,0.000281,-0.000108,37,P +2022-12-13,59926,0.117620,0.195524,-0.0263224,0.0003137,-0.110798,-0.006123,0.000282,-0.000109,37,P +2022-12-14,59927,0.115033,0.196160,-0.0267294,0.0004975,-0.110436,-0.006135,0.000278,-0.000112,37,P +2022-12-15,59928,0.112421,0.196736,-0.0273335,0.0006951,-0.110058,-0.006030,0.000268,-0.000118,37,P +2022-12-16,59929,0.109747,0.197361,-0.0281179,0.0008528,-0.109850,-0.005818,0.000255,-0.000125,37,P +2022-12-17,59930,0.107138,0.198020,-0.0290364,0.0009655,-0.110026,-0.005641,0.000242,-0.000132,37,P +2022-12-18,59931,0.104663,0.198678,-0.0300331,0.0009911,-0.110533,-0.005579,0.000232,-0.000136,37,P +2022-12-19,59932,0.102165,0.199448,-0.0310108,0.0009531,-0.111060,-0.005532,0.000228,-0.000137,37,P +2022-12-20,59933,0.099572,0.200256,-0.0319210,0.0008223,-0.111427,-0.005391,0.000231,-0.000134,37,P +2022-12-21,59934,0.097065,0.201207,-0.0326330,0.0005887,-0.111739,-0.005278,0.000239,-0.000129,37,P +2022-12-22,59935,0.094687,0.202233,-0.0331040,0.0003351,-0.112031,-0.005414,0.000248,-0.000125,37,P +2022-12-23,59936,0.092412,0.203264,-0.0333374,0.0001431,-0.112052,-0.005766,0.000256,-0.000121,37,P +2022-12-24,59937,0.090231,0.204172,-0.0334597,0.0001133,-0.111644,-0.006005,0.000260,-0.000119,37,P +2022-12-25,59938,0.088061,0.205116,-0.0336261,0.0002218,-0.111078,-0.005932,0.000258,-0.000118,37,P +2022-12-26,59939,0.085901,0.206111,-0.0339524,0.0004327,-0.110753,-0.005725,0.000252,-0.000119,37,P +2022-12-27,59940,0.083604,0.206988,-0.0345206,0.0006920,-0.110736,-0.005636,0.000242,-0.000120,37,P +2022-12-28,59941,0.081228,0.207987,-0.0353313,0.0009013,-0.110835,-0.005644,0.000230,-0.000122,37,P +2022-12-29,59942,0.078891,0.209059,-0.0362933,0.0009862,-0.110944,-0.005558,0.000218,-0.000122,37,P +2022-12-30,59943,0.076798,0.210252,-0.0372747,0.0009480,-0.111093,-0.005351,0.000210,-0.000120,37,P +2022-12-31,59944,0.074761,0.211619,-0.0381677,0.0008077,-0.111285,-0.005178,0.000207,-0.000116,37,P +2023-01-01,59945,0.072623,0.213050,-0.0388812,0.0006034,-0.111463,-0.005132,0.000211,-0.000113,37,P +2023-01-02,59946,0.070606,0.214535,-0.0393799,0.0003780,-0.111551,-0.005154,0.000220,-0.000112,37,P +2023-01-03,59947,0.068735,0.216098,-0.0396483,0.0001470,-0.111478,-0.005183,0.000233,-0.000116,37,P +2023-01-04,59948,0.067027,0.217680,-0.0396976,-0.0000541,-0.111227,-0.005270,0.000247,-0.000126,37,P +2023-01-05,59949,0.065305,0.219368,-0.0395749,-0.0001940,-0.110901,-0.005485,0.000258,-0.000138,37,P +2023-01-06,59950,0.063576,0.221160,-0.0393508,-0.0002535,-0.110661,-0.005763,0.000266,-0.000149,37,P +2023-01-07,59951,0.061878,0.222925,-0.0391008,-0.0002555,-0.110564,-0.005932,0.000270,-0.000157,37,P +2023-01-08,59952,0.060288,0.224620,-0.0388708,-0.0002035,-0.110518,-0.005913,0.000271,-0.000161,37,P +2023-01-09,59953,0.058666,0.226316,-0.0387322,-0.0000736,-0.110397,-0.005800,0.000269,-0.000163,37,P +2023-01-10,59954,0.057101,0.227967,-0.0387526,0.0001077,-0.110156,-0.005727,0.000265,-0.000165,37,P +2023-01-11,59955,0.055677,0.229543,-0.0389587,0.0002888,-0.109823,-0.005694,0.000258,-0.000170,37,P +2023-01-12,59956,0.054271,0.231153,-0.0393272,0.0004289,-0.109478,-0.005603,0.000249,-0.000178,37,P +2023-01-13,59957,0.052810,0.232793,-0.0398151,0.0005319,-0.109273,-0.005456,0.000239,-0.000186,37,P +2023-01-14,59958,0.051302,0.234399,-0.0403859,0.0005826,-0.109370,-0.005394,0.000231,-0.000191,37,P +2023-01-15,59959,0.049700,0.236028,-0.0409681,0.0005551,-0.109739,-0.005510,0.000225,-0.000192,37,P +2023-01-16,59960,0.048074,0.237731,-0.0414818,0.0004420,-0.110149,-0.005665,0.000224,-0.000189,37,P +2023-01-17,59961,0.046407,0.239513,-0.0418395,0.0002502,-0.110496,-0.005652,0.000227,-0.000184,37,P +2023-01-18,59962,0.044736,0.241249,-0.0419878,0.0000375,-0.110960,-0.005526,0.000232,-0.000178,37,P +2023-01-19,59963,0.043179,0.243118,-0.0419369,-0.0001453,-0.111592,-0.005592,0.000238,-0.000173,37,P +2023-01-20,59964,0.041750,0.245092,-0.0417427,-0.0002329,-0.111984,-0.005959,0.000242,-0.000169,37,P +2023-01-21,59965,0.040494,0.247015,-0.0415340,-0.0001790,-0.111712,-0.006313,0.000242,-0.000168,37,P +2023-01-22,59966,0.039392,0.248952,-0.0414474,0.0000130,-0.110961,-0.006318,0.000238,-0.000168,37,P +2023-01-23,59967,0.038133,0.250944,-0.0416038,0.0002890,-0.110318,-0.006070,0.000229,-0.000169,37,P +2023-01-24,59968,0.036703,0.252924,-0.0420344,0.0005501,-0.110086,-0.005900,0.000218,-0.000171,37,P +2023-01-25,59969,0.035289,0.254933,-0.0426881,0.0007269,-0.110142,-0.005880,0.000206,-0.000173,37,P +2023-01-26,59970,0.033796,0.256863,-0.0434503,0.0007551,-0.110335,-0.005810,0.000196,-0.000173,37,P +2023-01-27,59971,0.032288,0.258719,-0.0441633,0.0006421,-0.110640,-0.005622,0.000191,-0.000170,37,P +2023-01-28,59972,0.030771,0.260760,-0.0447136,0.0004287,-0.110973,-0.005513,0.000191,-0.000165,37,P +2023-01-29,59973,0.029445,0.262801,-0.0450189,0.0001718,-0.111188,-0.005640,0.000197,-0.000160,37,P +2023-01-30,59974,0.028140,0.264923,-0.0450737,-0.0000739,-0.111239,-0.005896,0.000208,-0.000157,37,P +2023-01-31,59975,0.026760,0.267076,-0.0448974,-0.0002808,-0.111161,-0.006085,0.000222,-0.000160,37,P +2023-02-01,59976,0.025534,0.269146,-0.0445474,-0.0004251,-0.110950,-0.006173,0.000236,-0.000167,37,P +2023-02-02,59977,0.024391,0.271235,-0.0440827,-0.0005090,-0.110614,-0.006276,0.000248,-0.000175,37,P +2023-02-03,59978,0.023124,0.273390,-0.0435713,-0.0005138,-0.110273,-0.006442,0.000255,-0.000182,37,P +2023-02-04,59979,0.021696,0.275637,-0.0430950,-0.0004435,-0.110072,-0.006557,0.000258,-0.000186,37,P +2023-02-05,59980,0.020300,0.277947,-0.0427184,-0.0003127,-0.110009,-0.006498,0.000255,-0.000186,37,P +2023-02-06,59981,0.018999,0.280208,-0.0424967,-0.0001398,-0.109945,-0.006307,0.000248,-0.000187,37,P +2023-02-07,59982,0.017688,0.282429,-0.0424567,0.0000503,-0.109775,-0.006141,0.000239,-0.000190,37,P +2023-02-08,59983,0.016555,0.284762,-0.0426027,0.0002231,-0.109535,-0.006084,0.000228,-0.000196,37,P +2023-02-09,59984,0.015629,0.287020,-0.0428953,0.0003413,-0.109336,-0.006082,0.000220,-0.000205,37,P +2023-02-10,59985,0.014719,0.289328,-0.0432774,0.0004028,-0.109267,-0.006079,0.000214,-0.000213,37,P +2023-02-11,59986,0.013816,0.291525,-0.0436918,0.0003996,-0.109361,-0.006119,0.000211,-0.000217,37,P +2023-02-12,59987,0.012995,0.293723,-0.0440661,0.0003229,-0.109570,-0.006273,0.000211,-0.000217,37,P +2023-02-13,59988,0.012220,0.296011,-0.0443266,0.0001689,-0.109766,-0.006478,0.000213,-0.000213,37,P +2023-02-14,59989,0.011425,0.298312,-0.0444035,-0.0000293,-0.109899,-0.006580,0.000216,-0.000207,37,P +2023-02-15,59990,0.010608,0.300613,-0.0442857,-0.0002134,-0.110107,-0.006563,0.000219,-0.000202,37,P +2023-02-16,59991,0.009863,0.302912,-0.0440146,-0.0003215,-0.110499,-0.006628,0.000222,-0.000198,37,P +2023-02-17,59992,0.009164,0.305263,-0.0436988,-0.0003026,-0.110845,-0.006909,0.000223,-0.000196,37,P +2023-02-18,59993,0.008493,0.307617,-0.0434721,-0.0001422,-0.110765,-0.007218,0.000220,-0.000195,37,P +2023-02-19,59994,0.007910,0.310070,-0.0434730,0.0001438,-0.110236,-0.007261,0.000214,-0.000195,37,P +2023-02-20,59995,0.007333,0.312533,-0.0437908,0.0004738,-0.109646,-0.007048,0.000204,-0.000196,37,P +2023-02-21,59996,0.006829,0.314974,-0.0444149,0.0007426,-0.109317,-0.006859,0.000194,-0.000197,37,P +2023-02-22,59997,0.006285,0.317428,-0.0452394,0.0008634,-0.109266,-0.006840,0.000184,-0.000197,37,P +2023-02-23,59998,0.005578,0.320015,-0.0460983,0.0008180,-0.109422,-0.006858,0.000178,-0.000195,37,P +2023-02-24,59999,0.004906,0.322530,-0.0468442,0.0006425,-0.109749,-0.006809,0.000178,-0.000190,37,P +2023-02-25,60000,0.004359,0.324855,-0.0473708,0.0003916,-0.110122,-0.006823,0.000182,-0.000183,37,P +2023-02-26,60001,0.004012,0.327055,-0.0476362,0.0001289,-0.110343,-0.007046,0.000191,-0.000176,37,P +2023-02-27,60002,0.003655,0.329213,-0.0476511,-0.0001048,-0.110351,-0.007388,0.000202,-0.000171,37,P +2023-02-28,60003,0.003208,0.331420,-0.0474621,-0.0002725,-0.110225,-0.007621,0.000216,-0.000171,37,P +2023-03-01,60004,0.002722,0.333781,-0.0471474,-0.0003600,-0.109990,-0.007664,0.000229,-0.000173,37,P +2023-03-02,60005,0.002432,0.336216,-0.0467828,-0.0003724,-0.109605,-0.007644,0.000241,-0.000176,37,P +2023-03-03,60006,0.002276,0.338583,-0.0464433,-0.0003114,-0.109146,-0.007692,0.000248,-0.000178,37,P +2023-03-04,60007,0.002103,0.341047,-0.0461968,-0.0001874,-0.108814,-0.007766,0.000248,-0.000176,37,P +2023-03-05,60008,0.001952,0.343482,-0.0461011,-0.0000096,-0.108719,-0.007725,0.000241,-0.000174,37,P +2023-03-06,60009,0.001978,0.345995,-0.0461967,0.0001851,-0.108758,-0.007532,0.000228,-0.000175,37,P +2023-03-07,60010,0.002144,0.348448,-0.0464806,0.0003701,-0.108765,-0.007316,0.000213,-0.000179,37,P +2023-03-08,60011,0.002300,0.350918,-0.0469367,0.0005203,-0.108710,-0.007226,0.000201,-0.000188,37,P +2023-03-09,60012,0.002594,0.353507,-0.0475102,0.0006053,-0.108685,-0.007286,0.000193,-0.000198,37,P +2023-03-10,60013,0.002997,0.356205,-0.0481309,0.0006080,-0.108742,-0.007415,0.000191,-0.000207,37,P +2023-03-11,60014,0.003349,0.359011,-0.0487086,0.0005218,-0.108845,-0.007542,0.000194,-0.000211,37,P +2023-03-12,60015,0.003664,0.361923,-0.0491652,0.0003671,-0.108936,-0.007662,0.000200,-0.000211,37,P +2023-03-13,60016,0.003927,0.364774,-0.0494438,0.0001719,-0.108983,-0.007792,0.000205,-0.000208,37,P +2023-03-14,60017,0.004228,0.367418,-0.0495254,-0.0000164,-0.108956,-0.007915,0.000209,-0.000205,37,P +2023-03-15,60018,0.004606,0.369771,-0.0494423,-0.0001495,-0.108848,-0.008026,0.000211,-0.000202,37,P +2023-03-16,60019,0.005024,0.371961,-0.0492735,-0.0001780,-0.108692,-0.008163,0.000212,-0.000200,37,P +2023-03-17,60020,0.005448,0.374135,-0.0491433,-0.0000740,-0.108516,-0.008348,0.000210,-0.000200,37,P +2023-03-18,60021,0.005874,0.376318,-0.0491829,0.0001583,-0.108313,-0.008488,0.000205,-0.000199,37,P +2023-03-19,60022,0.006293,0.378663,-0.0495018,0.0004681,-0.108106,-0.008457,0.000197,-0.000199,37,P +2023-03-20,60023,0.006803,0.381129,-0.0501321,0.0007690,-0.107968,-0.008277,0.000188,-0.000199,37,P +2023-03-21,60024,0.007565,0.383722,-0.0510229,0.0009752,-0.107931,-0.008122,0.000178,-0.000198,37,P +2023-03-22,60025,0.008398,0.386476,-0.0520425,0.0010220,-0.107967,-0.008103,0.000172,-0.000197,37,P +2023-03-23,60026,0.009293,0.389110,-0.0530263,0.0009105,-0.108086,-0.008159,0.000171,-0.000193,37,P +2023-03-24,60027,0.010088,0.391569,-0.0538364,0.0006814,-0.108325,-0.008208,0.000175,-0.000187,37,P +2023-03-25,60028,0.010838,0.394026,-0.0543848,0.0004016,-0.108624,-0.008293,0.000183,-0.000179,37,P +2023-03-26,60029,0.011568,0.396444,-0.0546560,0.0001327,-0.108822,-0.008492,0.000193,-0.000173,37,P +2023-03-27,60030,0.012244,0.398806,-0.0546811,-0.0000811,-0.108829,-0.008747,0.000204,-0.000168,37,P +2023-03-28,60031,0.012953,0.401079,-0.0545348,-0.0002101,-0.108682,-0.008903,0.000216,-0.000167,37,P +2023-03-29,60032,0.013682,0.403498,-0.0543041,-0.0002511,-0.108405,-0.008905,0.000227,-0.000167,37,P +2023-03-30,60033,0.014641,0.405841,-0.0540753,-0.0002092,-0.107970,-0.008866,0.000238,-0.000166,37,P +2023-03-31,60034,0.015904,0.408032,-0.0539223,-0.0001044,-0.107438,-0.008917,0.000243,-0.000164,37,P +2023-04-01,60035,0.017065,0.410222,-0.0538986,0.0000509,-0.107020,-0.009037,0.000241,-0.000161,37,P +2023-04-02,60036,0.017927,0.412628,-0.0540493,0.0002387,-0.106905,-0.009077,0.000230,-0.000159,37,P +2023-04-03,60037,0.018814,0.415004,-0.0543906,0.0004301,-0.107071,-0.008940,0.000213,-0.000162,37,P +2023-04-04,60038,0.019651,0.417290,-0.0549127,0.0005938,-0.107330,-0.008701,0.000194,-0.000169,37,P +2023-04-05,60039,0.020401,0.419540,-0.0555705,0.0006996,-0.107533,-0.008530,0.000179,-0.000180,37,P +2023-04-06,60040,0.021074,0.421758,-0.0562981,0.0007309,-0.107670,-0.008532,0.000173,-0.000192,37,P +2023-04-07,60041,0.021853,0.424028,-0.0570126,0.0006702,-0.107787,-0.008672,0.000175,-0.000200,37,P +2023-04-08,60042,0.022698,0.426318,-0.0576209,0.0005220,-0.107897,-0.008844,0.000183,-0.000205,37,P +2023-04-09,60043,0.023480,0.428597,-0.0580503,0.0003165,-0.107984,-0.008979,0.000193,-0.000206,37,P +2023-04-10,60044,0.024332,0.430858,-0.0582651,0.0001034,-0.108034,-0.009086,0.000201,-0.000204,37,P +2023-04-11,60045,0.025291,0.432945,-0.0582872,-0.0000604,-0.107997,-0.009207,0.000206,-0.000203,37,P +2023-04-12,60046,0.026376,0.434981,-0.0581882,-0.0001306,-0.107783,-0.009362,0.000208,-0.000202,37,P +2023-04-13,60047,0.027362,0.437135,-0.0580788,-0.0000771,-0.107356,-0.009526,0.000206,-0.000203,37,P +2023-04-14,60048,0.028260,0.439284,-0.0580862,0.0000987,-0.106830,-0.009639,0.000202,-0.000203,37,P +2023-04-15,60049,0.029310,0.441448,-0.0583191,0.0003649,-0.106427,-0.009648,0.000194,-0.000202,37,P +2023-04-16,60050,0.030406,0.443520,-0.0588377,0.0006530,-0.106315,-0.009538,0.000185,-0.000201,37,P +2023-04-17,60051,0.031556,0.445658,-0.0596205,0.0008827,-0.106485,-0.009363,0.000175,-0.000200,37,P +2023-04-18,60052,0.032731,0.447721,-0.0605767,0.0009911,-0.106771,-0.009212,0.000167,-0.000197,37,P +2023-04-19,60053,0.034141,0.449766,-0.0615656,0.0009495,-0.107005,-0.009137,0.000164,-0.000194,37,P +2023-04-20,60054,0.035626,0.451739,-0.0624434,0.0007740,-0.107146,-0.009130,0.000166,-0.000190,37,P +2023-04-21,60055,0.037079,0.453566,-0.0630964,0.0005099,-0.107258,-0.009175,0.000174,-0.000185,37,P +2023-04-22,60056,0.038562,0.455400,-0.0634688,0.0002246,-0.107395,-0.009283,0.000183,-0.000181,37,P +2023-04-23,60057,0.040124,0.457317,-0.0635704,-0.0000245,-0.107529,-0.009454,0.000193,-0.000178,37,P +2023-04-24,60058,0.041751,0.459240,-0.0634573,-0.0001984,-0.107592,-0.009622,0.000203,-0.000177,37,P +2023-04-25,60059,0.043396,0.461079,-0.0632151,-0.0002848,-0.107543,-0.009709,0.000212,-0.000177,37,P +2023-04-26,60060,0.045091,0.462933,-0.0629286,-0.0002872,-0.107358,-0.009719,0.000221,-0.000177,37,P +2023-04-27,60061,0.046594,0.464831,-0.0626795,-0.0002146,-0.107025,-0.009753,0.000229,-0.000176,37,P +2023-04-28,60062,0.048033,0.466690,-0.0625327,-0.0000848,-0.106584,-0.009888,0.000233,-0.000173,37,P +2023-04-29,60063,0.049481,0.468490,-0.0625367,0.0000834,-0.106182,-0.010070,0.000228,-0.000172,37,P +2023-04-30,60064,0.050828,0.470116,-0.0627164,0.0002622,-0.106021,-0.010148,0.000215,-0.000173,37,P +2023-05-01,60065,0.052224,0.471679,-0.0630694,0.0004276,-0.106201,-0.010026,0.000195,-0.000178,37,P +2023-05-02,60066,0.053861,0.473175,-0.0635698,0.0005499,-0.106632,-0.009758,0.000175,-0.000187,37,P +2023-05-03,60067,0.055674,0.474707,-0.0641588,0.0006038,-0.107096,-0.009497,0.000160,-0.000198,37,P +2023-05-04,60068,0.057473,0.476295,-0.0647602,0.0005706,-0.107423,-0.009363,0.000156,-0.000208,37,P +2023-05-05,60069,0.059254,0.477866,-0.0652800,0.0004439,-0.107606,-0.009385,0.000161,-0.000214,37,P +2023-05-06,60070,0.061193,0.479361,-0.0656343,0.0002424,-0.107747,-0.009521,0.000172,-0.000216,37,P +2023-05-07,60071,0.063280,0.480788,-0.0657659,0.0000078,-0.107907,-0.009714,0.000184,-0.000215,37,P +2023-05-08,60072,0.065531,0.482140,-0.0656740,-0.0001941,-0.108020,-0.009914,0.000194,-0.000213,37,P +2023-05-09,60073,0.067869,0.483341,-0.0654208,-0.0003072,-0.107961,-0.010080,0.000198,-0.000212,37,P +2023-05-10,60074,0.070205,0.484590,-0.0651138,-0.0002956,-0.107678,-0.010187,0.000198,-0.000212,37,P +2023-05-11,60075,0.072486,0.485862,-0.0648819,-0.0001609,-0.107246,-0.010233,0.000193,-0.000212,37,P +2023-05-12,60076,0.074870,0.487161,-0.0648323,0.0000626,-0.106820,-0.010222,0.000186,-0.000212,37,P +2023-05-13,60077,0.077278,0.488529,-0.0650291,0.0003180,-0.106540,-0.010156,0.000175,-0.000212,37,P +2023-05-14,60078,0.079600,0.489824,-0.0654688,0.0005363,-0.106482,-0.010041,0.000163,-0.000209,37,P +2023-05-15,60079,0.081748,0.491010,-0.0660842,0.0006604,-0.106642,-0.009887,0.000153,-0.000206,37,P +2023-05-16,60080,0.084001,0.492195,-0.0667601,0.0006548,-0.106944,-0.009709,0.000146,-0.000202,37,P +2023-05-17,60081,0.086382,0.493304,-0.0673644,0.0005219,-0.107267,-0.009533,0.000145,-0.000198,37,P +2023-05-18,60082,0.088898,0.494280,-0.0677846,0.0002929,-0.107489,-0.009415,0.000151,-0.000194,37,P +2023-05-19,60083,0.091450,0.495110,-0.0679478,0.0000178,-0.107568,-0.009425,0.000160,-0.000192,37,P +2023-05-20,60084,0.094153,0.495910,-0.0678371,-0.0002466,-0.107566,-0.009589,0.000171,-0.000193,37,P +2023-05-21,60085,0.096797,0.496664,-0.0674867,-0.0004546,-0.107590,-0.009843,0.000180,-0.000196,37,P +2023-05-22,60086,0.099429,0.497472,-0.0669686,-0.0005786,-0.107677,-0.010052,0.000188,-0.000199,37,P +2023-05-23,60087,0.102079,0.498352,-0.0663711,-0.0006146,-0.107774,-0.010131,0.000194,-0.000202,37,P +2023-05-24,60088,0.104760,0.499262,-0.0657784,-0.0005706,-0.107807,-0.010123,0.000201,-0.000203,37,P +2023-05-25,60089,0.107317,0.500044,-0.0652641,-0.0004626,-0.107738,-0.010149,0.000206,-0.000202,37,P +2023-05-26,60090,0.109616,0.500706,-0.0648807,-0.0003114,-0.107554,-0.010266,0.000208,-0.000200,37,P diff --git a/Ortho-Top/test/ceshiL.py b/Ortho-Top/test/ceshiL.py new file mode 100644 index 0000000..d7d3e81 --- /dev/null +++ b/Ortho-Top/test/ceshiL.py @@ -0,0 +1,24 @@ +""" +@Project ：microproduct +@File ：OnePlantHeight.PY +@Function ：主函数 +@Author ：LMM +@Date ：2021/10/19 14:39 +@Version ：1.0.0 +""" + +import numpy as np +from scipy.special import lambertw +H_arr=np.array([1,2]) +array_angle=np.array([1,0.5]) +a = 0.5 * H_arr * H_arr +b = -0.5 * np.sin(array_angle) +y = 2 + + + +a1 = 2 * lambertw(-b * np.sqrt(y / a) / 2) / b +print(a1) +pass + + diff --git a/Ortho-Top/test/test.py b/Ortho-Top/test/test.py new file mode 100644 index 0000000..9a0fdc8 --- /dev/null +++ b/Ortho-Top/test/test.py @@ -0,0 +1,19 @@ +import os +import sys +import cv2 +import numpy as np + +img1 = cv2.imread('D:\MicroSAR\C-SAR\Ortho\Ortho\Temporary\dem_rcs.jpg', 0) +img2 = cv2.imread('D:\MicroSAR\C-SAR\Ortho\Ortho\Temporary\sar_rcs.jpg', 0) +def cv_show(name,img): + cv2.imshow(name, img) + cv2.waitKey(0) + cv2.destroyAllWindows() +sift = cv2.xfeatures2d.SIFT_create() +kp1, des1 = sift.detectAndCompute(img1, None) +kp2, des2 = sift.detectAndCompute(img2, None) +bf = cv2.BFMatcher(crossCheck=True) +matches = bf.match(des1, des2) +matches = sorted(matches, key=lambda x: x.distance) +img3 = cv2.drawMatches(img1, kp1, img2, kp2, matches[:10], None,flags=2) +cv_show('img3',img3) diff --git a/Ortho-Top/test/test1.py b/Ortho-Top/test/test1.py new file mode 100644 index 0000000..949d760 --- /dev/null +++ b/Ortho-Top/test/test1.py @@ -0,0 +1,30 @@ + +def cal(base_block,i,j): + + std=np.std(base_block) + dist=np.max(base_block)-np.min(base_block) + return [i,j,std,dist] + + +plist=[] +with Pool() as pool: + for i in range(height): + print("\r",i,"/",height," ",end="") + if i<50 or i>height-51: + continue + for j in range(width): + if j<50 or j>width-51: + continue + base_block=data[i-50:i+50,j-50:j+50] + plist.append(pool.apply_async(cal,args=(base,i,j,))) + pool.close() + pool.join() + for p in plist: + result=p.get() + [i,j,std,dist]=result + base_std[i,j]=std + base_dist[i,j]=dist + +base_std.astype(np.float32).tofile(r"D:\MicroSAR\C-SAR\Ortho\Ortho\Temporary\HH_std.bin") +base_dist.astype(np.float32).tofile(r"D:\MicroSAR\C-SAR\Ortho\Ortho\Temporary\HH_dist.bin") +print(base_dist.shape,base_dist.dtype) \ No newline at end of file diff --git a/Ortho-Top/test/testMatch.py b/Ortho-Top/test/testMatch.py new file mode 100644 index 0000000..b03477e --- /dev/null +++ b/Ortho-Top/test/testMatch.py @@ -0,0 +1,113 @@ +import logging +# from re import S +# from oneOrthoAuxData import OrthoAuxData +# from OrthoImage import ImageHandler +from tool.algorithm.image.ImageHandle import ImageHandler +import tarfile +# from OrthoDB import ManageAlgXML, CheckSource +from tool.algorithm.xml.AlgXmlHandle import ManageAlgXML, CheckSource # 导入xml文件读取与检查文件 +from OrthoAlg import IndirectOrthorectification, DEMProcess,ImageMatchClass +# from logHandler import LogHandler +from tool.algorithm.algtools.logHandler import LogHandler +from tool.algorithm.xml.CreatMetafile import CreateMetafile +from OrthoXmlInfo import CreateDict, CreateStadardXmlFile +from osgeo import gdal, osr +import os +import glob +import gc +import datetime +import shutil +import sys +import cv2 + +ori_sar_path="D:\MicroWorkspace\C-SAR\Ortho\Temporary\TestSAR\GF3_SAY_QPSI_013952_E118.9_N31.5_20190404_L1A_HH_L10003923848.jpg" +sim_sar_path="D:\MicroWorkspace\C-SAR\Ortho\Temporary\TestSim\sim_img_sum.jpg" +work_sapce_path="D:\MicroWorkspace\C-SAR\Ortho\Temporary" + +''' +import matplotlib.pyplot as plt +img1 = cv2.imread(ori_sar_path, 0) +img2 = cv2.imread(sim_sar_path, 0) +def cv_show(name,img): + cv2.imshow(name, img) + cv2.waitKey(0) + cv2.destroyAllWindows() +sift = cv2.SIFT_create() +kp1, des1 = sift.detectAndCompute(img1, None) +kp2, des2 = sift.detectAndCompute(img2, None) +bf = cv2.BFMatcher(crossCheck=True) +matches = bf.match(des1, des2) +matches = sorted(matches, key=lambda x: x.distance) +img3 = cv2.drawMatches(img1, kp1, img2, kp2, matches[:10], None,flags=2) +cv2.imwrite(work_sapce_path,img3) +''' + +# 匹配影像 +def ImageMatch(ori_sar_path,sim_sar_path,work_sapce_path): + ori_sar=gdal.Open(ori_sar_path) + sim_sar=gdal.Open(sim_sar_path) + # 影像尺寸 + ori_height=ori_sar.RasterYSize + ori_width=ori_sar.RasterXSize + sim_height=sim_sar.RasterYSize + sim_width=sim_sar.RasterXSize + # 分块匹配 + ori_sar_arr=ori_sar.GetRasterBand(1).ReadAsArray(0,0,ori_width,ori_height) # 原始影像 + ori_img=(255*ori_sar_arr/np.max(ori_sar_arr)).astype(np.uint8) + + sim_sar_arr=np.log(sim_sar.GetRasterBand(1).ReadAsArray(0,0,sim_width,sim_height)+1) # 模拟影像 + sim_img=(1+253*sim_sar_arr/np.max(sim_sar_arr)).astype(np.uint8) + + res = cv.matchTemplate(img,template,method) + min_val, max_val, min_loc, max_loc = cv.minMaxLoc(res) + top_left = max_loc + # 范围 + min_w=top_left[0] if top_left[0]>0 else 0 + min_h=top_left[1] if top_left[1]>0 else 0 + + max_w=top_left[0]+ori_width if top_left[0]+ori_width