483 lines
24 KiB
Python
483 lines
24 KiB
Python
# -*- coding: UTF-8 -*-
|
||
"""
|
||
@Project ：microproduct
|
||
@File ：BackscatteringMain.py
|
||
@Function ：后向散射
|
||
@Author ：KHZ
|
||
@Contact：
|
||
@Date ：2021/9/1
|
||
@Version ：1.0.0
|
||
"""
|
||
import logging
|
||
from tool.algorithm.algtools.logHandler import LogHandler
|
||
from tool.algorithm.xml.AlgXmlHandle import ManageAlgXML, CheckSource
|
||
from tool.algorithm.xml.CreateMetaDict import CreateMetaDict, CreateProductXml
|
||
from tool.algorithm.image.ImageHandle import ImageHandler
|
||
from tool.algorithm.algtools.PreProcess import PreProcess as pp
|
||
from BackScatteringAlg import IndirectOrthorectification, DEMProcess,rpc_correction,getRCImageRC,get_RPC_lon_lat,getRCImageRC2
|
||
from BackScatteringAlg import ScatteringAlg as alg
|
||
from tool.config.ConfigeHandle import Config as cf
|
||
import os
|
||
import glob
|
||
import datetime
|
||
import shutil
|
||
import tarfile
|
||
import sys
|
||
|
||
|
||
if cf.get('debug') == 'True':
|
||
DEBUG = True
|
||
else:
|
||
DEBUG = False
|
||
EXE_NAME = 'BackScattering'
|
||
LogHandler.init_log_handler('run_log\\' + EXE_NAME)
|
||
logger = logging.getLogger("mylog")
|
||
env_str = os.path.split(os.path.realpath(__file__))[0]
|
||
os.environ['PROJ_LIB'] = env_str
|
||
|
||
class ScatteringMain:
|
||
"""
|
||
后向散射系数主函数
|
||
"""
|
||
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_para = None
|
||
self.__preprocessed_paras = {}
|
||
self.__tif_names_list = []
|
||
self.__feature_name_list = []
|
||
|
||
def check_source(self):
|
||
"""
|
||
检查算法相关的配置文件，图像，辅助文件是否齐全
|
||
"""
|
||
env_str = os.getcwd()
|
||
logger.info("sysdir: %s", env_str)
|
||
|
||
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"]
|
||
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.__create_work_space()
|
||
self.__task_id = self.__alg_xml_handler.get_task_id()
|
||
self.__input_paras = self.__alg_xml_handler.get_input_paras()
|
||
self.__in_processing_paras = self.__init_processing_paras(self.__input_paras)
|
||
SrcImageName = os.path.split(self.__input_paras["SLC"]['ParaValue'])[1].split('.tar.gz')[0]
|
||
AlgorithmName = self.__alg_xml_handler.get_algorithm_name()
|
||
TaskId = self.__alg_xml_handler.get_task_id()
|
||
result_name = SrcImageName + "-cal.tar.gz"
|
||
# out_name = os.path.splitext(os.path.splitext(os.path.basename(self.__input_paras['SLC']['ParaValue']))[0])[0]
|
||
# self.__out_para = os.path.join(self.__workspace_path, EXE_NAME, 'Output', "BackScatteringProduct.tar.gz")
|
||
self.__out_para = os.path.join(self.__workspace_path, EXE_NAME, 'Output', result_name)
|
||
self.__alg_xml_handler.write_out_para("BackScatteringProduct", self.__out_para) # 写入输出参数
|
||
|
||
logger.info('check_source success!')
|
||
logger.info('progress bar: 30%')
|
||
return True
|
||
|
||
def __init_processing_paras(self, names):
|
||
"""
|
||
:param names:字典列表，每个字典为一个输入产品的配置信息
|
||
"""
|
||
processing_paras = {}
|
||
for name in names:
|
||
para = self.__input_paras[name]
|
||
if para is None:
|
||
logger.error(name + "is None!")
|
||
return False
|
||
if para['ParaType'] == 'File':
|
||
if para['DataType'] == 'File':
|
||
processing_paras.update({name: para['ParaValue']})
|
||
# if para['DataType'] == 'csv':
|
||
# para_value_list = para['ParaValue'].split(";")
|
||
# if len(para_value_list) == 1:
|
||
# para_path = para['ParaValue']
|
||
# processing_paras.update({name: para_path})
|
||
# else:
|
||
# for n, para_value in zip(range(len(para_value_list)), para_value_list):
|
||
# processing_paras.update({'feature'+str(n): para_value})
|
||
# self.__feature_name_list.append('feature'+str(n))
|
||
elif para['DataType'] == 'tar.gz':
|
||
paths = para['ParaValue'].split(';')
|
||
for path in paths:
|
||
tar_gz_dic = self.__dec_tar_gz(path, self.__workspace_preprocessing_path)
|
||
processing_paras.update(tar_gz_dic)
|
||
elif 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})
|
||
else:
|
||
para_path = para['ParaValue']
|
||
processing_paras.update({name: para_path})
|
||
elif para['ParaType'] == 'Value':
|
||
if para['DataType'] == 'float':
|
||
value = float(para['ParaValue'])
|
||
elif para['DataType'] == 'int':
|
||
value = int(para['ParaValue'])
|
||
else: # 默认string
|
||
value = para['ParaValue']
|
||
processing_paras.update({name: value})
|
||
return processing_paras
|
||
|
||
def __dec_tar_gz(self, 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')
|
||
file_dir = os.path.join(out_dir, name + '\\')
|
||
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 = {}
|
||
# if os.path.exists(file_dir + name + '\\'):
|
||
# meta_xml_paths = list(glob.glob(os.path.join(file_dir + name, '*.meta.xml')))
|
||
# para_dic.update({'SLC': file_dir + name})
|
||
# else:
|
||
# meta_xml_paths = list(glob.glob(os.path.join(file_dir, '*.meta.xml')))
|
||
# para_dic.update({'SLC': file_dir})
|
||
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
|
||
return para_dic
|
||
|
||
def __create_work_space(self):
|
||
"""
|
||
删除原有工作区文件夹,创建新工作区文件夹
|
||
"""
|
||
self.__workspace_preprocessing_path = os.path.join(self.__workspace_path, EXE_NAME, "Temporary", "preprocessing") # self.__workspace_path + EXE_NAME + r"\Temporary\preprocessing""\\"
|
||
self.__workspace_preprocessed_path = os.path.join(self.__workspace_path, EXE_NAME, "Temporary", "preprocessed") # self.__workspace_path + EXE_NAME + r"\Temporary\preprocessed""\\"
|
||
self.__workspace_processing_path = os.path.join(self.__workspace_path, EXE_NAME, "Temporary","processing\\") #self.__workspace_path + EXE_NAME + r"\Temporary\processing""\\"
|
||
self.__workspace_origin_path = os.path.join(self.__workspace_path, EXE_NAME, "Temporary", "origin")
|
||
path_list = [self.__workspace_preprocessing_path, self.__workspace_preprocessed_path,
|
||
self.__workspace_processing_path, self.__workspace_origin_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!')
|
||
|
||
def del_file(self, path_data):
|
||
"""
|
||
只删除文件，不删除文件夹
|
||
"""
|
||
if DEBUG is True:
|
||
return
|
||
for i in os.listdir(path_data): # os.listdir(path_data)#返回一个列表，里面是当前目录下面的所有东西的相对路径
|
||
file_data = os.path.join(path_data, i) # path_data + "\\" + i # 当前文件夹的下面的所有东西的绝对路径
|
||
if os.path.isfile(file_data) is True: # os.path.isfile判断是否为文件,如果是文件,就删除.如果是文件夹.递归给del_file.
|
||
os.remove(file_data)
|
||
else:
|
||
self.del_file(file_data)
|
||
@staticmethod
|
||
def del_floder(dic):
|
||
"""
|
||
删除整个文件夹
|
||
"""
|
||
if DEBUG is True:
|
||
return
|
||
if os.path.isdir(dic):
|
||
shutil.rmtree(dic)
|
||
|
||
@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))
|
||
|
||
def del_temp_workspace(self):
|
||
"""
|
||
临时工作区
|
||
"""
|
||
if DEBUG is True:
|
||
return
|
||
path = os.path.join(self.__workspace_path, EXE_NAME, "Temporary") # self.__workspace_path + EXE_NAME + r"\Temporary"
|
||
if os.path.exists(path):
|
||
self.del_floder(path)
|
||
|
||
def process_sim_ori(self, ori_sim, sim_ori):
|
||
|
||
scopes = ()
|
||
scopes += (ImageHandler.get_scope_ori_sim(ori_sim),)
|
||
|
||
intersect_polygon = pp().intersect_polygon(scopes)
|
||
if intersect_polygon is None:
|
||
raise Exception('create intersect shp fail!')
|
||
shp_path = os.path.join(self.__workspace_preprocessing_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_preprocessing_path, 'sim_ori_process.tif')
|
||
pp().cut_img(sim_ori_process, sim_ori, shp_path)
|
||
return sim_ori_process
|
||
|
||
def process_handle(self,start):
|
||
in_tif_paths = list(glob.glob(os.path.join(self.__in_processing_paras['SLC'], '*.tif')))
|
||
if in_tif_paths == []:
|
||
in_tif_paths = list(glob.glob(os.path.join(self.__in_processing_paras['SLC'], '*.tiff')))
|
||
|
||
hh_flag, hv_flag, vh_flag, vv_flag, angle_flag = 0, 0, 0, 0, 0
|
||
for in_tif_path in in_tif_paths:
|
||
if 'HH' in os.path.basename(in_tif_path):
|
||
hh_flag = 1
|
||
elif 'HV' in os.path.basename(in_tif_path):
|
||
hv_flag = 1
|
||
elif 'VH' in os.path.basename(in_tif_path):
|
||
vh_flag = 1
|
||
elif 'VV' in os.path.basename(in_tif_path):
|
||
vv_flag = 1
|
||
self.processinfo=[hh_flag, hv_flag, vh_flag, vv_flag]
|
||
|
||
ref_tif_path = ""
|
||
meta_file_path = self.__in_processing_paras['META']
|
||
rpc_path=None
|
||
|
||
#######################
|
||
# RD
|
||
######################
|
||
# 2.2 生成局地入射角
|
||
path2 = env_str
|
||
print("path2:" + path2)
|
||
Orthorectification = IndirectOrthorectification(os.path.join(path2,"config.yaml"))
|
||
Orthorectification.IndirectOrthorectification(self.__in_processing_paras["SLC"], self.__workspace_processing_path) # 改动1
|
||
# 2.3 输出结果
|
||
|
||
# 3 处理RD
|
||
# 合并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_preprocessing_path
|
||
dem_merged_path=DEMProcess.dem_merged(in_dem_path, meta_file_path, out_dem_path) # 生成TestDEM\mergedDEM_VRT.tif
|
||
|
||
in_slc_path=None
|
||
for slc_path in in_tif_paths:
|
||
if slc_path.find(".tiff")>0 and (slc_path.find("_HH_")>0 or slc_path.find("_VV_")>0):
|
||
in_slc_path=slc_path
|
||
break
|
||
|
||
# 获取校正模型后
|
||
Orthorectification.preCaldem_sar_rc(dem_merged_path,in_slc_path,self.__workspace_preprocessing_path,self.__workspace_processing_path.replace("\\","\\\\")) # 初步筛选坐标范围
|
||
logger.info('progress bar: 40%')
|
||
# clip_dem_reample_path=os.path.join(self.__workspace_preprocessing_path, "SAR_dem.tiff")
|
||
# infooption=gdal.InfoOptions("-json")
|
||
# clip_dem_tif_info=gdal.Info(clip_dem_reample_path,options=infooption)
|
||
# dem_merged_info=gdal.Info(dem_merged_path,options=infooption)
|
||
# sampling_f=clip_dem_tif_info['size'][0]/dem_merged_info['size'][0]
|
||
# 处理RD 的结果
|
||
out_dir_path=self.__workspace_processing_path.replace("\\","\\\\")
|
||
this_outSpace_path = out_dir_path
|
||
this_out_dem_slantRange_path = os.path.join(out_dir_path, "dem_slantRange.tiff") # out_dir_path + "\\" + "dem_slantRange.tiff"#// 地形斜距
|
||
this_out_plant_slantRange_path = os.path.join(out_dir_path, "flat_slantRange.tiff") # out_dir_path + "\\" + "flat_slantRange.tiff"#// 平地斜距
|
||
# 保留结果
|
||
if(os.path.exists(this_out_dem_slantRange_path)):
|
||
os.remove(this_out_dem_slantRange_path)
|
||
|
||
if(os.path.exists(this_out_plant_slantRange_path)):
|
||
os.remove(this_out_plant_slantRange_path)
|
||
|
||
|
||
this_out_dem_rc_path = os.path.join(out_dir_path, "WGS_SAR_map.tiff") # out_dir_path + "\\" + "WGS_SAR_map.tiff"#// 经纬度与行列号映射
|
||
if(os.path.exists(this_out_dem_rc_path)):
|
||
os.remove(this_out_dem_rc_path)
|
||
|
||
this_out_sar_sim_path = out_dir_path + "\\" + "sar_sim.tiff"
|
||
if (os.path.exists(this_out_sar_sim_path)):
|
||
os.remove(this_out_sar_sim_path)
|
||
|
||
this_out_sar_sim_wgs_path = out_dir_path + "\\" + "sar_sim_wgs.tiff" # // 经纬度与行列号映射
|
||
if (os.path.exists(this_out_sar_sim_wgs_path)):
|
||
os.remove(this_out_sar_sim_wgs_path)
|
||
|
||
this_out_incidence_path = os.path.join(out_dir_path, "incidentAngle.tiff") # out_dir_path + "\\" + "incidentAngle.tiff"#// 入射角
|
||
this_out_localIncidenct_path = os.path.join(out_dir_path, "localIncidentAngle.tiff") # out_dir_path + "\\" + "localIncidentAngle.tiff"#// 局地入射角
|
||
if(os.path.exists(this_out_incidence_path)):
|
||
shutil.move(this_out_incidence_path,os.path.join(out_dir_path, "inc_angle.tif")) # out_dir_path + "\\" + "inc_angle.tif")
|
||
if(os.path.exists(this_out_localIncidenct_path)):
|
||
shutil.move(this_out_localIncidenct_path, os.path.join(out_dir_path, "LocalIncidenceAngle.tif")) # out_dir_path + "\\" + "LocalIncidenceAngle.tif")
|
||
|
||
this_out_inc_angle_rpc_path = os.path.join(out_dir_path, "RD_incidentAngle.tiff") # out_dir_path + "\\" + "RD_incidentAngle.tiff"#// 局地入射角
|
||
this_out_local_inc_angle_rpc_path = os.path.join(out_dir_path, "RD_localIncidentAngle.tiff") # out_dir_path + "\\" + "RD_localIncidentAngle.tiff"#// 局地入射角
|
||
if(os.path.exists(this_out_inc_angle_rpc_path)):
|
||
os.remove(this_out_inc_angle_rpc_path)
|
||
if(os.path.exists(this_out_local_inc_angle_rpc_path)):
|
||
os.remove(this_out_local_inc_angle_rpc_path)
|
||
|
||
this_out_ori_sim_tiff = os.path.join(out_dir_path, "RD_ori_sim.tif") # out_dir_path + "\\" + "RD_ori_sim.tif"#// 局地入射角
|
||
this_in_rpc_lon_lat_path = this_out_ori_sim_tiff
|
||
|
||
this_out_sim_ori_tiff = os.path.join(out_dir_path, "RD_sim_ori.tif")
|
||
this_in_rpc_x_y_path = this_out_sim_ori_tiff
|
||
|
||
this_in_rpc_x_y_path_pro = self.process_sim_ori(this_in_rpc_lon_lat_path, this_in_rpc_x_y_path)
|
||
|
||
parameter_path = os.path.join(self.__workspace_processing_path, "orth_para.txt")
|
||
|
||
|
||
for in_tif_path in in_tif_paths:
|
||
# out_tif_path = os.path.join(self.__workspace_preprocessing_path,os.path.splitext(os.path.basename(in_tif_path))[0]) + r"_lin.tif"
|
||
out_tif_path = os.path.join(self.__workspace_preprocessing_path,os.path.splitext(os.path.basename(in_tif_path))[0]) + r"_lin.tif"
|
||
if ('HH' in os.path.basename(in_tif_path)) or ('HV' in os.path.basename(in_tif_path)) or ('VH' in os.path.basename(in_tif_path)) or ('VV' in os.path.basename(in_tif_path)):
|
||
alg.sar_backscattering_coef(in_tif_path, meta_file_path, out_tif_path)
|
||
# 构建RPC
|
||
# 查找RPC
|
||
rpc_path=in_tif_path.replace(".tiff",".rpc") if os.path.exists(in_tif_path.replace(".tiff",".rpc")) else in_tif_path.replace(".tiff",".rpb")
|
||
if not os.path.exists(rpc_path):
|
||
logger.error('rpc not found!')
|
||
|
||
# db->地理编码
|
||
# lin_tif_path = os.path.join(self.__workspace_processing_path,
|
||
# os.path.splitext(os.path.basename(in_tif_path))[0]) + r"-cal.tif"
|
||
# Orthorectification.calInterpolation_cubic_Wgs84_rc_sar_sigma(parameter_path, this_in_rpc_x_y_path,
|
||
# out_tif_path,
|
||
# lin_tif_path)
|
||
# 线性->地理编码->db
|
||
lin_tif_path=os.path.join(self.__workspace_preprocessing_path,os.path.splitext(os.path.basename(in_tif_path))[0]) + r"-lin_geo.tif"
|
||
# Orthorectification.calInterpolation_cubic_Wgs84_rc_sar_sigma(parameter_path, this_in_rpc_x_y_path_pro,
|
||
# out_tif_path,
|
||
# lin_tif_path)
|
||
|
||
Orthorectification.calInterpolation_bil_Wgs84_rc_sar_sigma(parameter_path, this_in_rpc_x_y_path_pro,
|
||
out_tif_path,
|
||
lin_tif_path)
|
||
tempout_tif_path = os.path.join(self.__workspace_processing_path,
|
||
os.path.splitext(os.path.basename(in_tif_path))[0]) + r"-cal.tif"
|
||
alg.lin_to_db(lin_tif_path, tempout_tif_path) #线性值转回DB值
|
||
|
||
|
||
# 移动RPC
|
||
#rpc_correction(in_tif_path,rpc_path,out_tif_path,dem_tif_file = None)
|
||
# Orthorectification.inter_Range2Geo(this_in_rpc_lon_lat_path,out_tif_path,tempout_tif_path,Orthorectification.heightspace)
|
||
|
||
self.imageHandler.write_quick_view(tempout_tif_path, color_img=False)
|
||
# self.imageHandler.write_quick_view(lin_tif_path, color_img=False)
|
||
else:
|
||
shutil.copy(in_tif_path,self.__workspace_processing_path)
|
||
ref_tif_path = tempout_tif_path
|
||
# ref_tif_path = lin_tif_path
|
||
# 构建行列号映射表
|
||
#out_rpc_rc_path = os.path.join(self.__workspace_processing_path,"RPC_ori_sim.tif")
|
||
#getRCImageRC(in_tif_path,out_rpc_rc_path,rpc_path)
|
||
logger.info('progress bar: 90%')
|
||
if(os.path.exists(this_in_rpc_lon_lat_path)):
|
||
os.remove(this_in_rpc_lon_lat_path)
|
||
if (os.path.exists(this_in_rpc_x_y_path)):
|
||
os.remove(this_in_rpc_x_y_path)
|
||
# out_mate_file_path = os.path.join(self.__workspace_processing_path,os.path.split(meta_file_path)[1].rstrip('.meta.xml') + '_DB.meta.xml')
|
||
out_mate_file_path = os.path.join(self.__workspace_processing_path,os.path.basename(meta_file_path))
|
||
shutil.copy(meta_file_path, out_mate_file_path)
|
||
|
||
if ref_tif_path != "":
|
||
# xml_path = "./model_meta.xml"
|
||
tem_folder = os.path.join(self.__workspace_path, EXE_NAME, "Temporary")
|
||
image_path = ref_tif_path
|
||
out_path1 = os.path.join(tem_folder, "trans_geo_projcs.tif")
|
||
out_path2 = os.path.join(tem_folder, "trans_projcs_geo.tif")
|
||
# par_dict = CreateDict(image_path, self.processinfo, out_path1, out_path2).calu_nature(start)
|
||
# model_xml_path = os.path.join(tem_folder, "creat_standa5rd.meta.xml") # 输出xml路径
|
||
# CreateStadardXmlFile(xml_path, par_dict, model_xml_path).create_standard_xml()
|
||
#
|
||
SrcImageName = os.path.split(self.__input_paras["SLC"]['ParaValue'])[1].split('.tar.gz')[0]
|
||
# meta_xml_path = os.path.join(self.__workspace_processing_path, SrcImageName + "-cal.meta.xml")
|
||
# CreateMetafile(self.image_meta_xml[0], self.alg_xml_path, model_xml_path,meta_xml_path).process(SrcImageName)
|
||
|
||
model_path = "./product.xml"
|
||
meta_xml_path = os.path.join(self.__workspace_processing_path, SrcImageName + "-cal.meta.xml")
|
||
|
||
para_dict = CreateMetaDict(image_path, self.__in_processing_paras['META'], self.__workspace_processing_path,
|
||
out_path1, out_path2).calu_nature()
|
||
para_dict.update({"imageinfo_ProductName": "后向散射系数"})
|
||
para_dict.update({"imageinfo_ProductIdentifier": "BackScattering"})
|
||
para_dict.update({"imageinfo_ProductLevel": "LEVEL3"})
|
||
para_dict.update({"ProductProductionInfo_BandSelection": "1,2"})
|
||
para_dict.update({"ProductProductionInfo_AuxiliaryDataDescription": "DEM"})
|
||
para_dict.update({"MetaInfo_UnitDes": "DB"}) # 设置单位
|
||
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)
|
||
|
||
self.make_targz(self.__out_para, self.__workspace_processing_path)
|
||
|
||
logger.info('process_handle finished!')
|
||
logger.info('progress bar: 100%')
|
||
return True
|
||
|
||
|
||
if __name__ == '__main__':
|
||
start = datetime.datetime.now()
|
||
try:
|
||
if len(sys.argv)<2:
|
||
xml_path = 'BackScattering.xml'
|
||
else:
|
||
xml_path = sys.argv[1]
|
||
ScatteringMain = ScatteringMain(xml_path)
|
||
if not ScatteringMain.check_source():
|
||
raise Exception('check_source() failed!')
|
||
if not ScatteringMain.process_handle(start):
|
||
raise Exception('process_handle() failed!')
|
||
logger.info('successful production of backscattering products!')
|
||
except Exception:
|
||
logger.exception("run-time error!")
|
||
finally:
|
||
ScatteringMain.del_temp_workspace()
|
||
# pass
|
||
|
||
end = datetime.datetime.now()
|
||
msg = 'running use time: %s ' % (end - start)
|
||
logger.info(msg)
|