1704 lines
65 KiB
Python
1704 lines
65 KiB
Python
|
#!/usr/bin/env python3
|
|||
|
|
|
|||
|
|
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|||
|
|
# Copyright 2010 California Institute of Technology. ALL RIGHTS RESERVED.
|
|||
|
|
#
|
|||
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|||
|
|
# you may not use this file except in compliance with the License.
|
|||
|
|
# You may obtain a copy of the License at
|
|||
|
|
#
|
|||
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|||
|
|
#
|
|||
|
|
# Unless required by applicable law or agreed to in writing, software
|
|||
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|||
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|||
|
|
# See the License for the specific language governing permissions and
|
|||
|
|
# limitations under the License.
|
|||
|
|
#
|
|||
|
|
# United States Government Sponsorship acknowledged. This software is subject to
|
|||
|
|
# U.S. export control laws and regulations and has been classified as 'EAR99 NLR'
|
|||
|
|
# (No [Export] License Required except when exporting to an embargoed country,
|
|||
|
|
# end user, or in support of a prohibited end use). By downloading this software,
|
|||
|
|
# the user agrees to comply with all applicable U.S. export laws and regulations.
|
|||
|
|
# The user has the responsibility to obtain export licenses, or other export
|
|||
|
|
# authority as may be required before exporting this software to any 'EAR99'
|
|||
|
|
# embargoed foreign country or citizen of those countries.
|
|||
|
|
#
|
|||
|
|
# Author: Walter Szeliga
|
|||
|
|
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|||
|
|
|
|||
|
|
from xml.etree.ElementTree import ElementTree
|
|||
|
|
import datetime
|
|||
|
|
import isceobj
|
|||
|
|
from isceobj.Scene.Frame import Frame
|
|||
|
|
from isceobj.Planet.Planet import Planet
|
|||
|
|
from isceobj.Orbit.Orbit import StateVector, Orbit
|
|||
|
|
from isceobj.Orbit.OrbitExtender import OrbitExtender
|
|||
|
|
from isceobj.Planet.AstronomicalHandbook import Const
|
|||
|
|
from iscesys.Component.Component import Component
|
|||
|
|
from iscesys.DateTimeUtil.DateTimeUtil import DateTimeUtil as DTUtil
|
|||
|
|
import os
|
|||
|
|
import copy
|
|||
|
|
import scipy.sparse as ss
|
|||
|
|
from concurrent.futures._base import as_completed, wait
|
|||
|
|
from concurrent.futures.thread import ThreadPoolExecutor
|
|||
|
|
from multiprocessing import Pool
|
|||
|
|
import math
|
|||
|
|
import datetime
|
|||
|
|
from math import sin,cos
|
|||
|
|
from scipy.optimize import leastsq
|
|||
|
|
import numpy as np
|
|||
|
|
sep = "\n"
|
|||
|
|
tab = " "
|
|||
|
|
lookMap = { 'R' : -1,
|
|||
|
|
'L' : 1}
|
|||
|
|
|
|||
|
|
TIFF = Component.Parameter(
|
|||
|
|
'tiff',
|
|||
|
|
public_name='TIFF',
|
|||
|
|
default='',
|
|||
|
|
type=str,
|
|||
|
|
mandatory=True,
|
|||
|
|
doc='GF3 tiff imagery file'
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
XML = Component.Parameter(
|
|||
|
|
'xml',
|
|||
|
|
public_name='XML',
|
|||
|
|
default='',
|
|||
|
|
type=str,
|
|||
|
|
mandatory=True,
|
|||
|
|
doc='GF3 xml metadata file'
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
ORBIT_DIRECTORY = Component.Parameter(
|
|||
|
|
'orbitDirectory',
|
|||
|
|
public_name = 'orbit directory',
|
|||
|
|
default=None,
|
|||
|
|
type=str,
|
|||
|
|
mandatory=False,
|
|||
|
|
doc='Directory with GF3 precise orbits')
|
|||
|
|
|
|||
|
|
ORBIT_FILE = Component.Parameter(
|
|||
|
|
'orbitFile',
|
|||
|
|
public_name = 'orbit file',
|
|||
|
|
default = None,
|
|||
|
|
type = str,
|
|||
|
|
mandatory = False,
|
|||
|
|
doc = 'Precise orbit file to use')
|
|||
|
|
|
|||
|
|
from .Sensor import Sensor
|
|||
|
|
|
|||
|
|
|
|||
|
|
#######################################################################################################
|
|||
|
|
# 增加轨道求解模型，为了方便轨道模型的求解，这里对轨道模型进行修改
|
|||
|
|
# 这里采用《Insar原理和应用 》（刘国祥著）中基于空间定位的轨道参数计算方法一章中的内容（Gabriel and Goldstein）
|
|||
|
|
# 注意为了方便计算，采用基准时间的方法
|
|||
|
|
######################################################
|
|||
|
|
|
|||
|
|
|
|||
|
|
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
|
|||
|
|
|
|||
|
|
|
|||
|
|
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:起算时间
|
|||
|
|
'''
|
|||
|
|
|
|||
|
|
SatelliteOrbitModel = SatelliteOrbitFitPoly()
|
|||
|
|
if SatelliteOrbitModel.ReconstructionSatelliteOrbit(GPSPoints_list, starttime=starttime) is None:
|
|||
|
|
return None
|
|||
|
|
return SatelliteOrbitModel
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
########
|
|||
|
|
# 函数列表
|
|||
|
|
########
|
|||
|
|
def poly1dfunc(p,x): # 一次函数
|
|||
|
|
k,b=p
|
|||
|
|
return k*x+b
|
|||
|
|
|
|||
|
|
def poly2dfunc(p,x): # 二次函数
|
|||
|
|
k1,k2,b=p
|
|||
|
|
return b+k1*x+k2*x*x
|
|||
|
|
|
|||
|
|
def poly3dfunc(p,x):
|
|||
|
|
k1,k2,k3,b=p
|
|||
|
|
return b+k1*x+k2*x*x+k3*x*x*x
|
|||
|
|
|
|||
|
|
def poly4dfunc(p,x):
|
|||
|
|
k1,k2,k3,k4,b=p
|
|||
|
|
return b+k1*x+k2*x**2+k3*x**3+k4*x**4
|
|||
|
|
|
|||
|
|
def poly5dfunc(p,x):
|
|||
|
|
k1,k2,k3,k4,k5,b=p
|
|||
|
|
return b+k1*x+k2*x**2+k3*x**3+k4*x**4+k5*x**5
|
|||
|
|
|
|||
|
|
def poly1derror(p,x,y):
|
|||
|
|
return poly1dfunc(p,x)-y
|
|||
|
|
|
|||
|
|
def poly2derror(p,x,y):
|
|||
|
|
return poly2dfunc(p,x)-y
|
|||
|
|
|
|||
|
|
def poly3derror(p,x,y):
|
|||
|
|
return poly3dfunc(p,x)-y
|
|||
|
|
|
|||
|
|
def poly4derror(p,x,y):
|
|||
|
|
return poly4dfunc(p,x)-y
|
|||
|
|
|
|||
|
|
def poly5derror(p,x,y):
|
|||
|
|
return poly5dfunc(p,x)-y
|
|||
|
|
|
|||
|
|
class orbitVector:
|
|||
|
|
def __init__(self,UTCTimes,vx,vy,vz,px,py,pz,dateformat="%Y-%m-%dT%H:%M:%S.%f"):
|
|||
|
|
self.UTCTime=datetime.datetime.strptime(UTCTimes,dateformat) # 字符串转UTC时间
|
|||
|
|
self.time_stamp=self.UTCTime.timestamp() # 时间戳
|
|||
|
|
self.vx=vx
|
|||
|
|
self.vy=vy
|
|||
|
|
self.vz=vz
|
|||
|
|
self.px=px
|
|||
|
|
self.py=py
|
|||
|
|
self.pz=pz
|
|||
|
|
self.orbitVector2GG() # 将坐标进行变换
|
|||
|
|
self.Check()
|
|||
|
|
pass
|
|||
|
|
|
|||
|
|
def orbitVector2GG(self):
|
|||
|
|
Cx=self.py*self.vz-self.pz*self.vy # 叉乘
|
|||
|
|
Cy=self.pz*self.vx-self.px*self.vz
|
|||
|
|
Cz=self.px*self.vy-self.py*self.vx
|
|||
|
|
C=(Cx**2+Cy**2+Cz**2)**0.5
|
|||
|
|
self.rho=(self.px**2+self.py**2+self.pz**2)**0.5
|
|||
|
|
self.I=math.acos(Cz/C)
|
|||
|
|
self.omega=math.asin(self.pz/(self.rho*math.sin(self.I)))
|
|||
|
|
self.Omega=math.atan(Cx*(-1)/Cy)
|
|||
|
|
|
|||
|
|
return [self.rho,self.I,self.omega,self.Omega]
|
|||
|
|
|
|||
|
|
def Check(self):
|
|||
|
|
rho=self.rho
|
|||
|
|
I=self.I
|
|||
|
|
omega=self.omega
|
|||
|
|
Omega=self.Omega
|
|||
|
|
Xp=rho*(cos(omega)*cos(Omega)-sin(omega)*sin(Omega)*cos(I))
|
|||
|
|
Yp=rho*(cos(omega)*sin(Omega)+sin(omega)*cos(Omega)*cos(I))
|
|||
|
|
Zp=rho*sin(Omega)*sin(I)
|
|||
|
|
print("计算插值:",self.UTCTime,self.px,self.py,self.pz,self.vx,self.vy,self.vz,"|",abs(Xp)-abs(self.px),abs(Yp)-abs(self.py),abs(Zp)-abs(self.pz))
|
|||
|
|
|
|||
|
|
|
|||
|
|
class SARorbit(object):
|
|||
|
|
# 作为自定义轨道计算基类
|
|||
|
|
# 定义几个基本方法：addvector(),createOrbit(),getTime(),getTimes()
|
|||
|
|
# 注意均为UTC
|
|||
|
|
def __init__(self):
|
|||
|
|
self.vectors=[]
|
|||
|
|
self.baseTime=None
|
|||
|
|
def addvector(self,UTCTime,vx,vy,vz,px,py,pz):
|
|||
|
|
neworbit_point=orbitVector(UTCTime,vx,vy,vz,px,py,pz)
|
|||
|
|
self.vectors.append(neworbit_point)
|
|||
|
|
if len(self.vectors)==1:
|
|||
|
|
self.baseTime=neworbit_point.time_stamp-1 # 基线
|
|||
|
|
else:
|
|||
|
|
if self.baseTime>neworbit_point.time_stamp:
|
|||
|
|
self.baseTime=neworbit_point.time_stamp-1
|
|||
|
|
|
|||
|
|
def createOrbit(self):
|
|||
|
|
pass
|
|||
|
|
|
|||
|
|
def getTimeOrbit(self,UTCTime):
|
|||
|
|
return None
|
|||
|
|
|
|||
|
|
def getTimeOrbitStamp(self,StampTime):
|
|||
|
|
utcStr=datetime.datetime.fromtimestamp(StampTime).strftime("%Y-%m-%dT%H:%M:%S.%f")
|
|||
|
|
return self.getTimeOrbit(utcStr)
|
|||
|
|
|
|||
|
|
def getTimeOrbits(self,UTCStartTime,UTCEndTime,orbitnum=100):
|
|||
|
|
#
|
|||
|
|
startTime_stamp=datetime.datetime.strptime(UTCStartTime,"%Y-%m-%dT%H:%M:%S.%f").timestamp()-0.2
|
|||
|
|
endTime_stamp=datetime.datetime.strptime(UTCEndTime,"%Y-%m-%dT%H:%M:%S.%f").timestamp()+0.2
|
|||
|
|
if startTime_stamp>endTime_stamp:
|
|||
|
|
raise
|
|||
|
|
delta_t=(endTime_stamp-startTime_stamp)*1000/orbitnum
|
|||
|
|
delta_t=int(delta_t)/1000 # 获取
|
|||
|
|
extractOrbits=[]
|
|||
|
|
#
|
|||
|
|
temptime=startTime_stamp
|
|||
|
|
while temptime<endTime_stamp:
|
|||
|
|
temptime=temptime+delta_t
|
|||
|
|
newOrbit=self.getTimeOrbitStamp(temptime)
|
|||
|
|
extractOrbits.append(newOrbit)
|
|||
|
|
newOrbit=self.getTimeOrbitStamp(endTime_stamp)
|
|||
|
|
extractOrbits.append(newOrbit)
|
|||
|
|
return extractOrbits # 扩展的轨道节点
|
|||
|
|
pass
|
|||
|
|
|
|||
|
|
|
|||
|
|
class GGorbit(SARorbit):
|
|||
|
|
# 最小二乘法，线性函数
|
|||
|
|
def __init__(self):
|
|||
|
|
super(GGorbit,self).__init__()
|
|||
|
|
|
|||
|
|
def createOrbit(self):
|
|||
|
|
if len(self.vectors)<3:
|
|||
|
|
raise
|
|||
|
|
# 求解GGorbit模型参数
|
|||
|
|
gg_t=[]
|
|||
|
|
gg_rho=[]
|
|||
|
|
gg_I=[]
|
|||
|
|
gg_omega=[]
|
|||
|
|
gg_Omega=[]
|
|||
|
|
for orbit_point in self.vectors:
|
|||
|
|
gg_t.append(orbit_point.time_stamp-self.baseTime)
|
|||
|
|
gg_rho.append(orbit_point.rho)
|
|||
|
|
gg_I.append(orbit_point.I)
|
|||
|
|
gg_omega.append(orbit_point.omega)
|
|||
|
|
gg_Omega.append(orbit_point.Omega)
|
|||
|
|
# 声明 x
|
|||
|
|
gg_t=np.array(gg_t) # 时间 t
|
|||
|
|
# y
|
|||
|
|
gg_rho=np.array(gg_rho) # rho
|
|||
|
|
gg_I=np.array(gg_I) # I
|
|||
|
|
gg_omega=np.array(gg_omega) # omega
|
|||
|
|
gg_Omega=np.array(gg_Omega) # Omega
|
|||
|
|
# 计算结果
|
|||
|
|
self.p_rho=leastsq(poly2derror,[30,30,2],args=(gg_t,gg_rho))[0]
|
|||
|
|
self.p_I=leastsq(poly1derror,[30,2],args=(gg_t,gg_I))[0]
|
|||
|
|
self.p_omega=leastsq(poly1derror,[30,2],args=(gg_t,gg_omega))[0]
|
|||
|
|
self.p_Oemga=leastsq(poly1derror,[30,2],args=(gg_t,gg_Omega))[0]
|
|||
|
|
#print(len(self.p_rho),len(self.p_I),len(self.p_omega),len(self.p_Oemga))
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
|
|||
|
|
def getXYZ(self,Inputstaptime):
|
|||
|
|
staptime=Inputstaptime-self.baseTime
|
|||
|
|
rho=poly2dfunc(self.p_rho,staptime)
|
|||
|
|
I=poly1dfunc(self.p_I,staptime)
|
|||
|
|
omega=poly1dfunc(self.p_omega,staptime)
|
|||
|
|
Omega=poly1dfunc(self.p_Oemga,staptime)
|
|||
|
|
Xp=-1*rho*(cos(omega)*cos(Omega)-sin(omega)*sin(Omega)*cos(I))
|
|||
|
|
Yp=-1*rho*(cos(omega)*sin(Omega)+sin(omega)*cos(Omega)*cos(I))
|
|||
|
|
Zp=rho*sin(omega)*sin(I)
|
|||
|
|
return [Xp,Yp,Zp]
|
|||
|
|
|
|||
|
|
# 获取计算结果
|
|||
|
|
def getTimeOrbit(self,UTCTime):
|
|||
|
|
staptime=datetime.datetime.strptime(UTCTime,"%Y-%m-%dT%H:%M:%S.%f").timestamp()
|
|||
|
|
dtime=0.0001
|
|||
|
|
[Xp,Yp,Zp]=self.getXYZ(staptime)
|
|||
|
|
[Xp_temp,Yp_temp,Zp_temp]=self.getXYZ(staptime+dtime)
|
|||
|
|
# 线性代数方法获取轨道速度
|
|||
|
|
Vx=(Xp_temp-Xp)/dtime
|
|||
|
|
Vy=(Yp_temp-Yp)/dtime
|
|||
|
|
Vz=(Zp_temp-Zp)/dtime
|
|||
|
|
#utmstr=datetime.datetime.strptime(UTCTime,"%Y-%m-%dT%H:%M:%S.%fZ").strftime("%Y-%m-%d %H:%M:%S.%f")
|
|||
|
|
neworbit_point=orbitVector(UTCTime,Vx,Vy,Vz,Xp,Yp,Zp)
|
|||
|
|
return neworbit_point
|
|||
|
|
|
|||
|
|
class polyorbit(SARorbit):
|
|||
|
|
def __init__(self):
|
|||
|
|
super(polyorbit,self).__init__()
|
|||
|
|
|
|||
|
|
def createOrbit(self):
|
|||
|
|
if len(self.vectors)<8:
|
|||
|
|
raise
|
|||
|
|
ts,xs,ys,zs,vx,vy,vz=[],[],[],[],[],[],[]
|
|||
|
|
for orbit_point in self.vectors:
|
|||
|
|
ts.append(orbit_point.time_stamp-self.baseTime)
|
|||
|
|
xs.append(orbit_point.px)
|
|||
|
|
ys.append(orbit_point.py)
|
|||
|
|
zs.append(orbit_point.pz)
|
|||
|
|
vx.append(orbit_point.vx)
|
|||
|
|
vy.append(orbit_point.vy)
|
|||
|
|
vz.append(orbit_point.vz)
|
|||
|
|
ts=np.array(ts)
|
|||
|
|
xs=np.array(xs)
|
|||
|
|
ys=np.array(ys)
|
|||
|
|
zs=np.array(zs)
|
|||
|
|
vx=np.array(vx)
|
|||
|
|
vy=np.array(vy)
|
|||
|
|
vz=np.array(vz)
|
|||
|
|
self.p_xs=leastsq(poly5derror,[100,100,100,100,100,100],args=(ts,xs))
|
|||
|
|
self.p_ys=leastsq(poly5derror,[100,100,100,100,100,100],args=(ts,ys))
|
|||
|
|
self.p_zs=leastsq(poly5derror,[100,100,100,100,100,100],args=(ts,zs))
|
|||
|
|
self.p_vxs=leastsq(poly5derror,[100,100,100,100,100,100],args=(ts,vx))
|
|||
|
|
self.p_vy=leastsq(poly5derror,[100,100,100,100,100,100],args=(ts,vy))
|
|||
|
|
self.p_vz=leastsq(poly5derror,[100,100,100,100,100,100],args=(ts,vz))
|
|||
|
|
return
|
|||
|
|
def getTimeOrbit(self,UTCTime):
|
|||
|
|
staptime=datetime.datetime.strptime(UTCTime,"%Y-%m-%dT%H:%M:%S.%fZ").timestamp()-self.baseTime
|
|||
|
|
xs=poly5dfunc(self.p_xs,staptime)
|
|||
|
|
ys=poly5dfunc(self.p_ys,staptime)
|
|||
|
|
zs=poly5dfunc(self.p_zs,staptime)
|
|||
|
|
vx=poly5dfunc(self.p_vx,staptime)
|
|||
|
|
vy=poly5dfunc(self.p_vy,staptime)
|
|||
|
|
vz=poly5dfunc(self.p_vz,staptime)
|
|||
|
|
utmstr=datetime.datetime.strptime(UTCTime,"%Y-%m-%dT%H:%M:%S.%fZ").strftime("%Y-%m-%d %H:%M:%S.%f")
|
|||
|
|
neworbit_point=orbitVector(utmstr,vx,vy,vz,xs,ys,zs,dateformat="%Y-%m-%d %H:%M:%S.%f")
|
|||
|
|
return neworbit_point
|
|||
|
|
|
|||
|
|
#######################################################################################################
|
|||
|
|
|
|||
|
|
class GF3_SLC(Sensor):
|
|||
|
|
"""
|
|||
|
|
A Class representing GF3 data
|
|||
|
|
"""
|
|||
|
|
|
|||
|
|
family='GF3_SLC'
|
|||
|
|
parameter_list = (XML, TIFF, ORBIT_DIRECTORY, ORBIT_FILE ) + Sensor.parameter_list
|
|||
|
|
|
|||
|
|
def __init__(self, family='', name=''):
|
|||
|
|
super().__init__(family if family else self.__class__.family, name=name)
|
|||
|
|
self.product = _Product()
|
|||
|
|
self.frame = Frame()
|
|||
|
|
self.frame.configure()
|
|||
|
|
|
|||
|
|
|
|||
|
|
def getFrame(self):
|
|||
|
|
return self.frame
|
|||
|
|
|
|||
|
|
def parse(self):
|
|||
|
|
try:
|
|||
|
|
fp = open(self.xml,'r')
|
|||
|
|
except IOError as strerr:
|
|||
|
|
print("IOError: %s" % strerr)
|
|||
|
|
return
|
|||
|
|
self._xml_root = ElementTree(file=fp).getroot()
|
|||
|
|
self.product.set_from_etnode(self._xml_root)
|
|||
|
|
self.populateMetadata()
|
|||
|
|
self.extractDoppler()
|
|||
|
|
fp.close()
|
|||
|
|
|
|||
|
|
def populateMetadata(self):
|
|||
|
|
"""
|
|||
|
|
Create metadata objects from the metadata files
|
|||
|
|
"""
|
|||
|
|
mission = self.product.satellite
|
|||
|
|
swath = self.product.sensor.imagingMode
|
|||
|
|
frequency = self.product.sensor.RadarCenterFrequency # GHZ转HZ
|
|||
|
|
ori_prf = self.product.sensor.waveParams.prf
|
|||
|
|
rangePixelSize = self.product.imageInfo.widthspace
|
|||
|
|
rangeSamplingRate = self.product.imageInfo.eqvFs # Const.c 光速 eqvfs
|
|||
|
|
pulseLength = self.product.sensor.waveParams.pulseWidth # us转为s
|
|||
|
|
pulseBandwidth = self.product.sensor.waveParams.bandWidth # MHZ转HZ
|
|||
|
|
polarization = self.product.productInfo.productPolar
|
|||
|
|
lookSide = lookMap[self.product.sensor.lookDirection]
|
|||
|
|
facility = 'KJ'
|
|||
|
|
version = '2.2'
|
|||
|
|
lines = self.product.imageInfo.height
|
|||
|
|
samples = self.product.imageInfo.width
|
|||
|
|
startingRange = self.product.imageInfo.nearRange # nearRange*2/光速
|
|||
|
|
incidenceAngle = (self.product.processInfo.incidenceAngleNearRange + self.product.processInfo.incidenceAngleFarRange)/2
|
|||
|
|
# some RS2 scenes have oversampled SLC images because processed azimuth bandwidth larger than PRF EJF 2015/08/15
|
|||
|
|
# azimuthPixelSize = self.product.imageAttributes.rasterAttributes.sampledLineSpacing # ground spacing in meters
|
|||
|
|
totalProcessedAzimuthBandwidth = self.product.imageInfo.eqvPRF
|
|||
|
|
prf = self.product.imageInfo.eqvPRF # effective PRF can be double original, suggested by Piyush
|
|||
|
|
# print("effective PRF %f, original PRF %f" % (prf, orig_prf) )
|
|||
|
|
print('----------------------------------------------------')
|
|||
|
|
print("mission",mission)
|
|||
|
|
print("swath",swath)
|
|||
|
|
print("frequency",frequency)
|
|||
|
|
print("ori_prf",ori_prf)
|
|||
|
|
print("rangePixelSize",rangePixelSize)
|
|||
|
|
print("rangeSamplingRate",rangeSamplingRate)
|
|||
|
|
print("pulseLength",pulseLength)
|
|||
|
|
print("pulseBandwidth",pulseBandwidth)
|
|||
|
|
print("polarization",polarization)
|
|||
|
|
print("lookSide",lookSide)
|
|||
|
|
print("lines",lines)
|
|||
|
|
print("samples",samples)
|
|||
|
|
print("startingRange",startingRange)
|
|||
|
|
print("incidenceAngle",incidenceAngle)
|
|||
|
|
print("self.product.processInfo.DopplerCentroidCoefficients",self.product.processInfo.DopplerCentroidCoefficients)
|
|||
|
|
print("self.product.processInfo.DopplerRateValuesCoefficients",self.product.processInfo.DopplerRateValuesCoefficients)
|
|||
|
|
print("effective PRF %f" % (prf) )
|
|||
|
|
print('-----------------------------------------------------')
|
|||
|
|
|
|||
|
|
lineFlip = (self.product.direction.upper() == 'DECREASING')
|
|||
|
|
|
|||
|
|
dataStartTime = self.product.imageInfo.imagingStartTime
|
|||
|
|
dataStopTime = self.product.imageInfo.imagingEndTime
|
|||
|
|
|
|||
|
|
passDirection = self.product.direction
|
|||
|
|
|
|||
|
|
####Populate platform
|
|||
|
|
platform = self.frame.getInstrument().getPlatform()
|
|||
|
|
platform.setPlanet(Planet(pname="Earth"))
|
|||
|
|
platform.setMission(mission)
|
|||
|
|
platform.setPointingDirection(lookSide)
|
|||
|
|
platform.setAntennaLength(15.0) # 天线长度
|
|||
|
|
|
|||
|
|
####Populate instrument
|
|||
|
|
instrument = self.frame.getInstrument()
|
|||
|
|
instrument.setRadarFrequency(frequency)
|
|||
|
|
instrument.setPulseRepetitionFrequency(prf)
|
|||
|
|
instrument.setPulseLength(pulseLength)
|
|||
|
|
instrument.setChirpSlope(pulseBandwidth/pulseLength)
|
|||
|
|
instrument.setIncidenceAngle(incidenceAngle)
|
|||
|
|
#self.frame.getInstrument().setRangeBias(0)
|
|||
|
|
instrument.setRangePixelSize(rangePixelSize)
|
|||
|
|
instrument.setRangeSamplingRate(rangeSamplingRate)
|
|||
|
|
instrument.setBeamNumber(swath)
|
|||
|
|
instrument.setPulseLength(pulseLength)
|
|||
|
|
|
|||
|
|
|
|||
|
|
#Populate Frame
|
|||
|
|
#self.frame.setSatelliteHeight(height)
|
|||
|
|
self.frame.setSensingStart(dataStartTime) # Date time object for UTC of first line
|
|||
|
|
self.frame.setSensingStop(dataStopTime) # Date time object for UTC of last line of image
|
|||
|
|
diffTime = DTUtil.timeDeltaToSeconds(dataStopTime - dataStartTime)/2.0
|
|||
|
|
sensingMid = dataStartTime + datetime.timedelta(microseconds=int(diffTime*1e6))
|
|||
|
|
self.frame.setSensingMid(sensingMid) # Date time object for UTC of middle of image
|
|||
|
|
self.frame.setPassDirection(passDirection) # Ascending or Descending direction of orbit
|
|||
|
|
self.frame.setPolarization(polarization)
|
|||
|
|
self.frame.setStartingRange(startingRange) # Range to the first valid sample in the image
|
|||
|
|
self.frame.setFarRange(startingRange + (samples-1)*rangePixelSize) # Far range
|
|||
|
|
self.frame.setNumberOfLines(lines) # Number of lines in the image
|
|||
|
|
self.frame.setNumberOfSamples(samples) # Number of samples in a range line.
|
|||
|
|
self.frame.setProcessingFacility(facility) # Processing facility information
|
|||
|
|
self.frame.setProcessingSoftwareVersion(version) # Processing system software version
|
|||
|
|
|
|||
|
|
|
|||
|
|
self.frame.getOrbit().setOrbitSource('EOF')
|
|||
|
|
# self.frame.getOrbit().setOrbitSource(self.product.sourceAttributes.orbitAndAttitude.orbitInformation.orbitDataFile)
|
|||
|
|
|
|||
|
|
print("======= 修改轨道代码部分： =================")
|
|||
|
|
if (self.orbitFile is None) and (self.orbitDirectory is None):
|
|||
|
|
print('orbitFile and orbitDirectory are None')
|
|||
|
|
self.extractOrbit()
|
|||
|
|
|
|||
|
|
elif (self.orbitDirectory is not None):
|
|||
|
|
print('orbitDirectory is None')
|
|||
|
|
self.orbitFile = findPreciseOrbit(self.orbitDirectory, self.frame.getOrbit().getOrbitSource(), self.frame.sensingStart.year)
|
|||
|
|
|
|||
|
|
if self.orbitFile is not None:
|
|||
|
|
print('orbitFile is None')
|
|||
|
|
self.extractPreciseOrbit(self.orbitFile, self.frame.sensingStart, self.frame.sensingStop)
|
|||
|
|
|
|||
|
|
|
|||
|
|
# save the Doppler centroid coefficients, converting units from product.xml file
|
|||
|
|
# units in the file are quadratic coefficients in Hz, Hz/sec, and Hz/(sec^2)
|
|||
|
|
# ISCE expects Hz, Hz/(range sample), Hz((range sample)^2
|
|||
|
|
# note that RS2 Doppler values are estimated at time dc.dopplerCentroidReferenceTime,
|
|||
|
|
# so the values might need to be adjusted for ISCE usage
|
|||
|
|
# added EJF 2015/08/17
|
|||
|
|
|
|||
|
|
# dc = self.product.imageGenerationParameters.dopplerCentroid
|
|||
|
|
# poly = dc.dopplerCentroidCoefficients
|
|||
|
|
poly = self.product.processInfo.DopplerCentroidCoefficients
|
|||
|
|
# need to convert units
|
|||
|
|
poly[1] = poly[1]/rangeSamplingRate
|
|||
|
|
poly[2] = poly[2]/rangeSamplingRate**2
|
|||
|
|
poly[3] = poly[3]/rangeSamplingRate**3
|
|||
|
|
poly[4] = poly[4]/rangeSamplingRate**4
|
|||
|
|
self.doppler_coeff = poly
|
|||
|
|
|
|||
|
|
# similarly save Doppler azimuth fm rate values, converting units
|
|||
|
|
# units in the file are quadratic coefficients in Hz, Hz/sec, and Hz/(sec^2)
|
|||
|
|
# Guessing that ISCE expects Hz, Hz/(range sample), Hz((range sample)^2
|
|||
|
|
# note that RS2 Doppler values are estimated at time dc.dopplerRateReferenceTime,
|
|||
|
|
# so the values might need to be adjusted for ISCE usage
|
|||
|
|
# added EJF 2015/08/17
|
|||
|
|
|
|||
|
|
# dr = self.product.imageGenerationParameters.dopplerRateValues
|
|||
|
|
# fmpoly = dr.dopplerRateValuesCoefficients
|
|||
|
|
|
|||
|
|
fmpoly = self.product.processInfo.DopplerRateValuesCoefficients
|
|||
|
|
# need to convert units
|
|||
|
|
fmpoly[1] = fmpoly[1]/rangeSamplingRate
|
|||
|
|
fmpoly[2] = fmpoly[2]/rangeSamplingRate**2
|
|||
|
|
fmpoly[3] = fmpoly[3]/rangeSamplingRate**3
|
|||
|
|
fmpoly[4] = fmpoly[4]/rangeSamplingRate**4
|
|||
|
|
self.azfmrate_coeff = fmpoly
|
|||
|
|
|
|||
|
|
# print("poly",poly)
|
|||
|
|
# print("fmpoly",fmpoly)
|
|||
|
|
# print('------------------------------------------------------')
|
|||
|
|
|
|||
|
|
# now calculate effective PRF from the azimuth line spacing after we have the orbit info EJF 2015/08/15
|
|||
|
|
# this does not work because azimuth spacing is on ground. Instead use bandwidth ratio calculated above EJF
|
|||
|
|
# SCHvelocity = self.frame.getSchVelocity()
|
|||
|
|
# SCHvelocity = 7550.75 # hard code orbit velocity for now m/s
|
|||
|
|
# prf = SCHvelocity/azimuthPixelSize
|
|||
|
|
# instrument.setPulseRepetitionFrequency(prf)
|
|||
|
|
|
|||
|
|
def extractOrbit(self):
|
|||
|
|
'''
|
|||
|
|
Extract the orbit state vectors from the XML file.
|
|||
|
|
'''
|
|||
|
|
|
|||
|
|
# Initialize orbit objects
|
|||
|
|
# Read into temp orbit first.
|
|||
|
|
# Radarsat 2 needs orbit extensions.
|
|||
|
|
print("构建新的轨道程序代码：")
|
|||
|
|
tempOrbit = GGorbit()
|
|||
|
|
|
|||
|
|
self.frame.getOrbit().setOrbitSource('Header: ' + self.frame.getOrbit().getOrbitSource())
|
|||
|
|
# stateVectors = self.product.sourceAttributes.orbitAndAttitude.orbitInformation.stateVectors
|
|||
|
|
stateVectors = self.product.GPS.gpsParam
|
|||
|
|
|
|||
|
|
dataStartTime = self.product.imageInfo.imagingStartTime
|
|||
|
|
dataStopTime = self.product.imageInfo.imagingEndTime
|
|||
|
|
dataCenterTime = self.product.platform.CenterTime
|
|||
|
|
|
|||
|
|
startTime_s = dataStartTime.timestamp()
|
|||
|
|
stopTime_s = dataStopTime.timestamp()
|
|||
|
|
centerTime_s = dataCenterTime.timestamp()
|
|||
|
|
|
|||
|
|
num = 0
|
|||
|
|
time_list= []
|
|||
|
|
for i in range(len(stateVectors)):
|
|||
|
|
# print(i,stateVectors[i].timeStamp)
|
|||
|
|
# tempOrbit.addvector(stateVectors[i].timeStamp.strftime("%Y-%m-%dT%H:%M:%S.%f"),
|
|||
|
|
# stateVectors[i].xVelocity, stateVectors[i].yVelocity, stateVectors[i].zVelocity,
|
|||
|
|
# stateVectors[i].xPosition, stateVectors[i].yPosition, stateVectors[i].zPosition)
|
|||
|
|
if stateVectors[i].timeStamp>dataStartTime and stateVectors[i].timeStamp < dataStopTime:
|
|||
|
|
# tempOrbit.addvector(stateVectors[i].timeStamp.strftime("%Y-%m-%dT%H:%M:%S.%f"),
|
|||
|
|
# stateVectors[i].xVelocity, stateVectors[i].yVelocity, stateVectors[i].zVelocity,
|
|||
|
|
# stateVectors[i].xPosition, stateVectors[i].yPosition, stateVectors[i].zPosition)
|
|||
|
|
# time_list.append(stateVectors[i].timeStamp)
|
|||
|
|
time_list.append([stateVectors[i].timeStamp.timestamp(),
|
|||
|
|
stateVectors[i].xPosition, stateVectors[i].yPosition, stateVectors[i].zPosition,
|
|||
|
|
stateVectors[i].xVelocity, stateVectors[i].yVelocity, stateVectors[i].zVelocity])
|
|||
|
|
num += 1
|
|||
|
|
# sv= StateVector()
|
|||
|
|
# sv.setTime(stateVectors[i].timeStamp)
|
|||
|
|
# sv.setPosition([stateVectors[i].xPosition, stateVectors[i].yPosition, stateVectors[i].zPosition])
|
|||
|
|
# sv.setVelocity([stateVectors[i].xVelocity, stateVectors[i].yVelocity, stateVectors[i].zVelocity])
|
|||
|
|
# self.frame.getOrbit().addStateVector(sv) # 插值结果写进了轨道模型中
|
|||
|
|
# num+=1
|
|||
|
|
|
|||
|
|
model = ReconstructionSatelliteOrbit(time_list, starttime=centerTime_s)
|
|||
|
|
time_dif = ((stopTime_s + 10) - (startTime_s - 10)) / 1000
|
|||
|
|
time = np.zeros((1000, 1))
|
|||
|
|
for i in range(1000):
|
|||
|
|
time[i,:]=((startTime_s - 10) + time_dif * i)
|
|||
|
|
t = time.reshape(-1)
|
|||
|
|
|
|||
|
|
statepoints = model.getSatelliteSpaceState(t)
|
|||
|
|
|
|||
|
|
# print("初始插值-----------------------------------------------------")
|
|||
|
|
# self.frame.setSensingStart(datetime.datetime.fromtimestamp(t[2]))
|
|||
|
|
# self.frame.setSensingStop(datetime.datetime.fromtimestamp(t[len(t)-3]))
|
|||
|
|
|
|||
|
|
self.frame.setSensingStart(dataStartTime)
|
|||
|
|
self.frame.setSensingStop(dataStopTime)
|
|||
|
|
|
|||
|
|
diffTime = DTUtil.timeDeltaToSeconds(self.frame.sensingStop-self.frame.sensingStart)/2.0
|
|||
|
|
sensingMid = self.frame.sensingStart + datetime.timedelta(microseconds=int(diffTime*1e6))
|
|||
|
|
self.frame.setSensingMid(sensingMid)
|
|||
|
|
|
|||
|
|
# planet = self.frame.instrument.platform.planet
|
|||
|
|
# orbExt = OrbitExtender(planet=planet)
|
|||
|
|
# orbExt.configure()
|
|||
|
|
# newOrb = orbExt.extendOrbit(tempOrbit)
|
|||
|
|
# tempOrbit.createOrbit() # 构建轨道模型
|
|||
|
|
|
|||
|
|
# newOrb=tempOrbit.getTimeOrbits(self.frame.sensingStart.strftime("%Y-%m-%dT%H:%M:%S.%f"),
|
|||
|
|
# self.frame.sensingStop.strftime("%Y-%m-%dT%H:%M:%S.%f"),
|
|||
|
|
# orbitnum=500)
|
|||
|
|
# for svect in newOrb:
|
|||
|
|
# sv= StateVector()
|
|||
|
|
# sv.setTime(svect.UTCTime)
|
|||
|
|
# sv.setPosition([svect.px,svect.py,svect.pz])
|
|||
|
|
# sv.setVelocity([svect.vx,svect.vy,svect.vz])
|
|||
|
|
# self.frame.getOrbit().addStateVector(sv) # 插值结果写进了轨道模型中
|
|||
|
|
|
|||
|
|
for i, value in zip(range(len(statepoints)), statepoints):
|
|||
|
|
sv= StateVector()
|
|||
|
|
sv.setTime(datetime.datetime.fromtimestamp(t[i]))
|
|||
|
|
sv.setPosition([value[0],value[1],value[2]])
|
|||
|
|
sv.setVelocity([value[3],value[4],value[5]])
|
|||
|
|
self.frame.getOrbit().addStateVector(sv) # 插值结果写进了轨道模型中
|
|||
|
|
# print("插值后的gps点", datetime.datetime.fromtimestamp(t[i]),value[0],value[1],value[2],value[3],value[4],value[5])
|
|||
|
|
print('Orbits list len is %d' %num)
|
|||
|
|
print('Successfully read state vectors from product XML')
|
|||
|
|
|
|||
|
|
def extractPreciseOrbit(self, orbitfile, tstart, tend):
|
|||
|
|
'''
|
|||
|
|
Extract precise orbits for given time-period from orbit file.
|
|||
|
|
'''
|
|||
|
|
|
|||
|
|
self.frame.getOrbit().setOrbitSource('File: ' + orbitfile)
|
|||
|
|
|
|||
|
|
tmin = tstart - datetime.timedelta(seconds=30.)
|
|||
|
|
tmax = tstart + datetime.timedelta(seconds=30.)
|
|||
|
|
|
|||
|
|
fid = open(orbitfile, 'r')
|
|||
|
|
for line in fid:
|
|||
|
|
if not line.startswith('; Position'):
|
|||
|
|
continue
|
|||
|
|
else:
|
|||
|
|
break
|
|||
|
|
|
|||
|
|
for line in fid:
|
|||
|
|
if not line.startswith(';###END'):
|
|||
|
|
tstamp = convertRSTimeToDateTime(line)
|
|||
|
|
|
|||
|
|
if (tstamp >= tmin) and (tstamp <= tmax):
|
|||
|
|
sv = StateVector()
|
|||
|
|
sv.configure()
|
|||
|
|
sv.setTime( tstamp)
|
|||
|
|
sv.setPosition( [float(x) for x in fid.readline().split()])
|
|||
|
|
sv.setVelocity( [float(x) for x in fid.readline().split()])
|
|||
|
|
|
|||
|
|
self.frame.getOrbit().addStateVector(sv)
|
|||
|
|
else:
|
|||
|
|
fid.readline()
|
|||
|
|
fid.readline()
|
|||
|
|
|
|||
|
|
dummy = fid.readline()
|
|||
|
|
if not dummy.startswith(';'):
|
|||
|
|
raise Exception('Expected line to start with ";". Got {0}'.format(dummy))
|
|||
|
|
|
|||
|
|
fid.close()
|
|||
|
|
print('Successfully read {0} state vectors from {1}'.format( len(self.frame.getOrbit()._stateVectors), orbitfile))
|
|||
|
|
|
|||
|
|
def extractImage(self, verbose=True):
|
|||
|
|
'''
|
|||
|
|
Use gdal to extract the slc.
|
|||
|
|
'''
|
|||
|
|
|
|||
|
|
try:
|
|||
|
|
from osgeo import gdal
|
|||
|
|
except ImportError:
|
|||
|
|
raise Exception('GDAL python bindings not found. Need this for RSAT2 / TandemX / Sentinel1A.')
|
|||
|
|
|
|||
|
|
self.parse()
|
|||
|
|
|
|||
|
|
width = self.frame.getNumberOfSamples()
|
|||
|
|
lgth = self.frame.getNumberOfLines()
|
|||
|
|
# lineFlip = (self.product.imageAttributes.rasterAttributes.lineTimeOrdering.upper() == 'DECREASING')
|
|||
|
|
# pixFlip = (self.product.imageAttributes.rasterAttributes.pixelTimeOrdering.upper() == 'DECREASING')
|
|||
|
|
lineFlip = True
|
|||
|
|
pixFlip = False
|
|||
|
|
|
|||
|
|
src = gdal.Open(self.tiff.strip(), gdal.GA_ReadOnly)
|
|||
|
|
cJ = np.complex64(1.0j)
|
|||
|
|
|
|||
|
|
####Images are small enough that we can do it all in one go - Piyush
|
|||
|
|
real = src.GetRasterBand(1).ReadAsArray(0,0,width,lgth)
|
|||
|
|
imag = src.GetRasterBand(2).ReadAsArray(0,0,width,lgth)
|
|||
|
|
|
|||
|
|
if (real is None) or (imag is None):
|
|||
|
|
raise Exception('Input GF3 SLC seems to not be a 2 band Int16 image.')
|
|||
|
|
|
|||
|
|
data = real+cJ*imag
|
|||
|
|
|
|||
|
|
real = None
|
|||
|
|
imag = None
|
|||
|
|
src = None
|
|||
|
|
|
|||
|
|
if lineFlip:
|
|||
|
|
if verbose:
|
|||
|
|
print('Vertically Flipping data')
|
|||
|
|
data = np.flipud(data)
|
|||
|
|
|
|||
|
|
if pixFlip:
|
|||
|
|
if verbose:
|
|||
|
|
print('Horizontally Flipping data')
|
|||
|
|
data = np.fliplr(data)
|
|||
|
|
|
|||
|
|
data.tofile(self.output)
|
|||
|
|
|
|||
|
|
####
|
|||
|
|
slcImage = isceobj.createSlcImage()
|
|||
|
|
slcImage.setByteOrder('l')
|
|||
|
|
slcImage.setFilename(self.output)
|
|||
|
|
slcImage.setAccessMode('read')
|
|||
|
|
slcImage.setWidth(width)
|
|||
|
|
slcImage.setLength(lgth)
|
|||
|
|
slcImage.setXmin(0)
|
|||
|
|
slcImage.setXmax(width)
|
|||
|
|
#slcImage.renderHdr()
|
|||
|
|
self.frame.setImage(slcImage)
|
|||
|
|
|
|||
|
|
|
|||
|
|
def extractDoppler(self):
|
|||
|
|
'''
|
|||
|
|
self.parse()
|
|||
|
|
Extract doppler information as needed by mocomp
|
|||
|
|
'''
|
|||
|
|
ins = self.frame.getInstrument()
|
|||
|
|
dc = self.product.processInfo.DopplerCentroidCoefficients
|
|||
|
|
quadratic = {}
|
|||
|
|
|
|||
|
|
r0 = self.frame.startingRange
|
|||
|
|
fs = ins.getRangeSamplingRate()
|
|||
|
|
tNear = 2*r0/Const.c
|
|||
|
|
|
|||
|
|
tMid = tNear + 0.5*self.frame.getNumberOfSamples()/fs
|
|||
|
|
t0 = self.product.processInfo.DopplerParametersReferenceTime
|
|||
|
|
poly = self.product.processInfo.DopplerCentroidCoefficients
|
|||
|
|
|
|||
|
|
|
|||
|
|
fd_mid = 0.0
|
|||
|
|
for kk in range(len(poly)):
|
|||
|
|
fd_mid += poly[kk] * (tMid - t0)**kk
|
|||
|
|
|
|||
|
|
####For insarApp
|
|||
|
|
quadratic['a'] = fd_mid / ins.getPulseRepetitionFrequency()
|
|||
|
|
quadratic['b'] = 0.
|
|||
|
|
quadratic['c'] = 0.
|
|||
|
|
|
|||
|
|
|
|||
|
|
####For roiApp
|
|||
|
|
####More accurate
|
|||
|
|
from isceobj.Util import Poly1D
|
|||
|
|
coeffs = poly
|
|||
|
|
dr = self.frame.getInstrument().getRangePixelSize()
|
|||
|
|
rref = 0.5 * Const.c * t0
|
|||
|
|
# rref = Const.c * t0
|
|||
|
|
r0 = self.frame.getStartingRange()
|
|||
|
|
norm = 0.5*Const.c/dr
|
|||
|
|
|
|||
|
|
dcoeffs = []
|
|||
|
|
for ind, val in enumerate(coeffs):
|
|||
|
|
dcoeffs.append( val / (norm**ind))
|
|||
|
|
|
|||
|
|
poly = Poly1D.Poly1D()
|
|||
|
|
poly.initPoly(order=len(coeffs)-1)
|
|||
|
|
poly.setMean( (rref - r0)/dr - 1.0)
|
|||
|
|
poly.setCoeffs(dcoeffs)
|
|||
|
|
|
|||
|
|
# print("****" * 10)
|
|||
|
|
# print(Const.c)
|
|||
|
|
# print(rref)
|
|||
|
|
# print(dr)
|
|||
|
|
# print(dcoeffs)
|
|||
|
|
# print(r0)
|
|||
|
|
# print("****" * 10)
|
|||
|
|
poly = Poly1D.Poly1D()
|
|||
|
|
poly.initPoly(order=len(coeffs)-1)
|
|||
|
|
poly.setMean( (rref - r0)/dr - 1.0)
|
|||
|
|
poly.setCoeffs(dcoeffs)
|
|||
|
|
|
|||
|
|
|
|||
|
|
pix = np.linspace(0, self.frame.getNumberOfSamples(), num=len(coeffs)+1)
|
|||
|
|
|
|||
|
|
evals = poly(pix)
|
|||
|
|
fit = np.polyfit(pix,evals, len(coeffs)-1)
|
|||
|
|
self.frame._dopplerVsPixel = list(fit[::-1])
|
|||
|
|
# print("---- radar ------------------------------------------print")
|
|||
|
|
# print("t0",t0)
|
|||
|
|
# print("****" * 10)
|
|||
|
|
# print('lightspeed',Const.c)
|
|||
|
|
# print('rref',rref)
|
|||
|
|
# print('dr',dr)
|
|||
|
|
# print('dcoeff',dcoeffs)
|
|||
|
|
# print('r0',r0)
|
|||
|
|
# print("****" * 10)
|
|||
|
|
# print('pix',pix)
|
|||
|
|
# print('evals',evals)
|
|||
|
|
# print('fit',fit)
|
|||
|
|
# print('Doppler Fit: ', fit[::-1])
|
|||
|
|
# print('---------------------------------------------------')
|
|||
|
|
|
|||
|
|
|
|||
|
|
return quadratic
|
|||
|
|
|
|||
|
|
class GF3_SLCNamespace(object):
|
|||
|
|
def __init__(self):
|
|||
|
|
self.uri = ""
|
|||
|
|
|
|||
|
|
def elementName(self,element):
|
|||
|
|
return "{%s}%s" % (self.uri,element)
|
|||
|
|
|
|||
|
|
def convertToDateTime(self,string):
|
|||
|
|
dt = datetime.datetime.strptime(string,"%Y-%m-%dT%H:%M:%S.%fZ")
|
|||
|
|
return dt
|
|||
|
|
|
|||
|
|
def convertToDateTime_(self,string):
|
|||
|
|
dt = datetime.datetime.strptime(string,"%Y-%m-%d %H:%M:%S.%f")
|
|||
|
|
return dt
|
|||
|
|
|
|||
|
|
def convertToDateTime_S(self,string):
|
|||
|
|
dt = datetime.datetime.strptime(string,"%Y-%m-%d %H:%M:%S")
|
|||
|
|
return dt
|
|||
|
|
|
|||
|
|
class _Product(GF3_SLCNamespace):
|
|||
|
|
def __init__(self):
|
|||
|
|
GF3_SLCNamespace.__init__(self)
|
|||
|
|
self.satellite = None
|
|||
|
|
self.orbitType = None
|
|||
|
|
self.direction = None
|
|||
|
|
self.productId = None
|
|||
|
|
self.documentIdentifier = None
|
|||
|
|
self.isZeroDopplerSteering = None
|
|||
|
|
self.station = None
|
|||
|
|
self.sensor = _Sensor()
|
|||
|
|
self.platform = _Platform()
|
|||
|
|
self.GPS = _OrbitInformation()
|
|||
|
|
self.ATTI = _ATTI()
|
|||
|
|
self.productInfo = _prodInfo()
|
|||
|
|
self.imageInfo = _imageInfo()
|
|||
|
|
self.processInfo = _processInfo()
|
|||
|
|
|
|||
|
|
def set_from_etnode(self,node):
|
|||
|
|
for z in node:
|
|||
|
|
if z.tag == 'satellite':
|
|||
|
|
self.satellite = z.text
|
|||
|
|
elif z.tag == 'orbitType':
|
|||
|
|
self.orbitType = z.text
|
|||
|
|
elif z.tag == 'Direction':
|
|||
|
|
if z.text.upper() == 'DEC':
|
|||
|
|
self.direction = 'Descending'
|
|||
|
|
elif z.text.upper() == 'ASC':
|
|||
|
|
self.direction = 'Ascending'
|
|||
|
|
self.direction = z.text
|
|||
|
|
elif z.tag == 'productID':
|
|||
|
|
self.productId = z.text
|
|||
|
|
elif z.tag == 'DocumentIdentifier':
|
|||
|
|
self.documentIdentifier = z.text
|
|||
|
|
elif z.tag == 'IsZeroDopplerSteering':
|
|||
|
|
self.isZeroDopplerSteering = z.text
|
|||
|
|
elif z.tag == 'Station':
|
|||
|
|
self.station = z.text
|
|||
|
|
elif z.tag == 'sensor':
|
|||
|
|
self.sensor.set_from_etnode(z)
|
|||
|
|
elif z.tag == 'platform':
|
|||
|
|
self.platform.set_from_etnode(z)
|
|||
|
|
elif z.tag == 'GPS':
|
|||
|
|
self.GPS.set_from_etnode(z)
|
|||
|
|
elif z.tag == 'ATTI':
|
|||
|
|
self.ATTI.set_from_etnode(z)
|
|||
|
|
elif z.tag == 'productinfo':
|
|||
|
|
self.productInfo.set_from_etnode(z)
|
|||
|
|
elif z.tag == 'imageinfo':
|
|||
|
|
self.imageInfo.set_from_etnode(z)
|
|||
|
|
elif z.tag == 'processinfo':
|
|||
|
|
self.processInfo.set_from_etnode(z)
|
|||
|
|
|
|||
|
|
def __str__(self):
|
|||
|
|
retstr = "Product:"+sep+tab
|
|||
|
|
retlst = ()
|
|||
|
|
retstr += "productID=%s"+sep+tab
|
|||
|
|
retlst += (self.productId,)
|
|||
|
|
retstr += "documentIdentifier=%s"+sep
|
|||
|
|
retlst += (self.documentId,)
|
|||
|
|
retstr += "%s"+sep
|
|||
|
|
retlst += (str(self.sourceAttributes),)
|
|||
|
|
retstr += "%s"+sep
|
|||
|
|
retlst += (str(self.imageGenerationParameters),)
|
|||
|
|
retstr += ":Product"
|
|||
|
|
return retstr % retlst
|
|||
|
|
|
|||
|
|
|
|||
|
|
class _Sensor(GF3_SLCNamespace):
|
|||
|
|
def __init__(self):
|
|||
|
|
GF3_SLCNamespace.__init__(self)
|
|||
|
|
self.sensorID = None
|
|||
|
|
self.imagingMode = None
|
|||
|
|
self.lamda = None
|
|||
|
|
self.RadarCenterFrequency = None
|
|||
|
|
self.satelStartTime = None
|
|||
|
|
self.satelEndTime = None
|
|||
|
|
self.lookDirection = None
|
|||
|
|
self.antennaMode = None
|
|||
|
|
self.waveParams = _WaveParams()
|
|||
|
|
|
|||
|
|
def set_from_etnode(self,node):
|
|||
|
|
for z in node:
|
|||
|
|
if z.tag == 'sensorID':
|
|||
|
|
self.sensorID = z.text
|
|||
|
|
elif z.tag == 'imagingMode':
|
|||
|
|
self.imagingMode = z.text #
|
|||
|
|
elif z.tag == 'lamda':
|
|||
|
|
self.lamda = float(z.text)
|
|||
|
|
elif z.tag == 'RadarCenterFrequency':
|
|||
|
|
self.RadarCenterFrequency = float(z.text) * 1e9 # GHZ转HZ
|
|||
|
|
elif z.tag == 'satelliteTime':
|
|||
|
|
satelliteTime = z
|
|||
|
|
for n in satelliteTime:
|
|||
|
|
if n.tag == 'start':
|
|||
|
|
self.satelStartTime = self.convertToDateTime_(n.text)
|
|||
|
|
elif n.tag == 'end':
|
|||
|
|
self.satelEndTime = self.convertToDateTime_(n.text)
|
|||
|
|
elif z.tag == 'waveParams':
|
|||
|
|
self.waveParams.set_from_etnode(z)
|
|||
|
|
elif z.tag == 'lookDirection':
|
|||
|
|
self.lookDirection = z.text
|
|||
|
|
elif z.tag == 'antennaMode':
|
|||
|
|
self.antennaMode = z.text
|
|||
|
|
|
|||
|
|
def __str__(self):
|
|||
|
|
retstr = "_Sensor:%s"+sep+tab
|
|||
|
|
retlst = ()
|
|||
|
|
retstr = "sensorID:%s"+sep+tab
|
|||
|
|
retlst = (self.sensorID,)
|
|||
|
|
retstr += "imagingMode=%s"+sep+tab
|
|||
|
|
retlst += (self.imagingMode,)
|
|||
|
|
retstr += "lamda=%s"+sep+tab
|
|||
|
|
retlst += (self.lamda,)
|
|||
|
|
retstr += "RadarCenterFrequency=%s"+sep+tab
|
|||
|
|
retlst += (self.RadarCenterFrequency,)
|
|||
|
|
retstr += "satelStartTime:%s"+sep+tab
|
|||
|
|
retlst += (self.satelStartTime,)
|
|||
|
|
retstr += "satelEndTime:%s"+sep+tab
|
|||
|
|
retlst += (self.satelEndTime,)
|
|||
|
|
retstr += "%s"
|
|||
|
|
retlst += (str(self.waveParams),)
|
|||
|
|
retstr += ":Sensor"
|
|||
|
|
return retstr % retlst
|
|||
|
|
|
|||
|
|
class _WaveParams(GF3_SLCNamespace):
|
|||
|
|
def __init__(self):
|
|||
|
|
GF3_SLCNamespace.__init__(self)
|
|||
|
|
self.waveCode = None
|
|||
|
|
self.startLookAngle = None
|
|||
|
|
self.centerLookAngle = None
|
|||
|
|
self.endLookAngle = None
|
|||
|
|
self.prf = None
|
|||
|
|
self.proBandwidth = None
|
|||
|
|
self.sampleRate = None
|
|||
|
|
self.sampleDelay = None
|
|||
|
|
self.bandWidth = None
|
|||
|
|
self.pulseWidth = None
|
|||
|
|
self.frameLength = None
|
|||
|
|
self.valueMGC = []
|
|||
|
|
self.groundVelocity = None
|
|||
|
|
self.averageAltitude = None
|
|||
|
|
|
|||
|
|
def set_from_etnode(self,node):
|
|||
|
|
i = 0
|
|||
|
|
for w in node:
|
|||
|
|
if w.tag == 'wave':
|
|||
|
|
wave = w
|
|||
|
|
for z in wave:
|
|||
|
|
if z.tag == 'waveCode':
|
|||
|
|
self.waveCode = z.text
|
|||
|
|
elif z.tag == 'startLookAngle':
|
|||
|
|
self.startLookAngle = float(z.text)
|
|||
|
|
elif z.tag == 'centerLookAngle':
|
|||
|
|
self.centerLookAngle = float(z.text)
|
|||
|
|
elif z.tag == 'endLookAngle':
|
|||
|
|
self.endLookAngle = float(z.text)
|
|||
|
|
elif z.tag == 'prf':
|
|||
|
|
self.prf = float(z.text)
|
|||
|
|
elif z.tag == 'proBandwidth':
|
|||
|
|
self.proBandwidth = float(z.text)
|
|||
|
|
elif z.tag == 'sampleRate':
|
|||
|
|
self.sampleRate = float(z.text)
|
|||
|
|
elif z.tag == 'sampleDelay':
|
|||
|
|
self.sampleDelay = float(z.text)
|
|||
|
|
elif z.tag == 'bandWidth':
|
|||
|
|
self.bandWidth = float(z.text) * 1e6 #MHZ转HZ
|
|||
|
|
elif z.tag == 'pulseWidth':
|
|||
|
|
self.pulseWidth = float(z.text) * 1e-6 #us转为s
|
|||
|
|
elif z.tag == 'frameLength':
|
|||
|
|
self.frameLength = int(z.text)
|
|||
|
|
elif z.tag == 'valueMGC':
|
|||
|
|
for value in z:
|
|||
|
|
self.valueMGC.append(float(value.text))
|
|||
|
|
elif z.tag == 'groundVelocity':
|
|||
|
|
self.groundVelocity = float(z.text)
|
|||
|
|
elif z.tag == 'averageAltitude':
|
|||
|
|
self.averageAltitude = float(z.text)
|
|||
|
|
|
|||
|
|
def __str__(self):
|
|||
|
|
retstr = "_WaveParams:"+sep+tab
|
|||
|
|
retlst = ()
|
|||
|
|
retstr += "centerLookAngle=%s"+sep+tab
|
|||
|
|
retlst += (self.centerLookAngle,)
|
|||
|
|
retstr += "prf=%s"+sep+tab
|
|||
|
|
retlst += (self.prf,)
|
|||
|
|
retstr += "proBandwidth=%s"+sep+tab
|
|||
|
|
retlst += (self.proBandwidth,)
|
|||
|
|
retstr += "pulseWidth=%s"+sep+tab
|
|||
|
|
retlst += (self.pulseWidth,)
|
|||
|
|
retstr += "groundVelocity=%s"+sep
|
|||
|
|
retlst += (self.groundVelocity,)
|
|||
|
|
retstr += ":RadarParameters"+sep
|
|||
|
|
return retstr % retlst
|
|||
|
|
|
|||
|
|
class _Platform(GF3_SLCNamespace):
|
|||
|
|
def __init__(self):
|
|||
|
|
GF3_SLCNamespace.__init__(self)
|
|||
|
|
self.CenterTime = None
|
|||
|
|
self.Rs = None
|
|||
|
|
self.satVelocity = None
|
|||
|
|
self.RollAngle = None
|
|||
|
|
self.PitchAngle = None
|
|||
|
|
self.YawAngle = None
|
|||
|
|
self.Xs = None
|
|||
|
|
self.Ys = None
|
|||
|
|
self.Zs = None
|
|||
|
|
self.Vxs = None
|
|||
|
|
self.Vys = None
|
|||
|
|
self.Vzs = None
|
|||
|
|
|
|||
|
|
def set_from_etnode(self,node):
|
|||
|
|
for z in node:
|
|||
|
|
if z.tag == 'CenterTime':
|
|||
|
|
self.CenterTime = self.convertToDateTime_(z.text)
|
|||
|
|
elif z.tag == 'Rs':
|
|||
|
|
self.Rs = float(z.text)
|
|||
|
|
elif z.tag == 'satVelocity':
|
|||
|
|
self.satVelocity = float(z.text)
|
|||
|
|
elif z.tag == 'RollAngle':
|
|||
|
|
self.RollAngle = float(z.text)
|
|||
|
|
elif z.tag == 'PitchAngle':
|
|||
|
|
self.PitchAngle = float(z.text)
|
|||
|
|
elif z.tag == 'YawAngle':
|
|||
|
|
self.YawAngle = float(z.text)
|
|||
|
|
elif z.tag == 'Xs':
|
|||
|
|
self.Xs = float(z.text)
|
|||
|
|
elif z.tag == 'Ys':
|
|||
|
|
self.Ys = float(z.text)
|
|||
|
|
elif z.tag == 'Zs':
|
|||
|
|
self.Zs = float(z.text)
|
|||
|
|
elif z.tag == 'Vxs':
|
|||
|
|
self.Vxs = float(z.text)
|
|||
|
|
elif z.tag == 'Vys':
|
|||
|
|
self.Vys = float(z.text)
|
|||
|
|
elif z.tag == 'Vzs':
|
|||
|
|
self.Vzs = float(z.text)
|
|||
|
|
|
|||
|
|
def __str__(self):
|
|||
|
|
retstr = "_Platform:"+sep+tab
|
|||
|
|
retlst = ()
|
|||
|
|
retstr += "CenterTime=%s"+sep+tab
|
|||
|
|
retlst += (self.CenterTime,)
|
|||
|
|
retstr += "Rs=%s"+sep+tab
|
|||
|
|
retlst += (self.Rs,)
|
|||
|
|
retstr += "RollAngle=%s"+sep+tab
|
|||
|
|
retlst += (self.RollAngle,)
|
|||
|
|
retstr += "PitchAngle=%s"+sep+tab
|
|||
|
|
retlst += (self.PitchAngle,)
|
|||
|
|
retstr += "YawAngle=%s"+sep+tab
|
|||
|
|
retlst += (self.YawAngle,)
|
|||
|
|
retstr += sep+":_Platform"
|
|||
|
|
return retstr % retlst
|
|||
|
|
|
|||
|
|
class _ATTI(GF3_SLCNamespace):
|
|||
|
|
def __init__(self):
|
|||
|
|
GF3_SLCNamespace.__init__(self)
|
|||
|
|
self.ATTIParam = _ATTIParam()
|
|||
|
|
|
|||
|
|
def set_from_etnode(self,node):
|
|||
|
|
for z in node:
|
|||
|
|
if z.tag == 'ATTIParam':
|
|||
|
|
self.ATTIParam.set_from_etnode(z)
|
|||
|
|
|
|||
|
|
def __str__(self):
|
|||
|
|
return ""
|
|||
|
|
|
|||
|
|
class _prodInfo(GF3_SLCNamespace):
|
|||
|
|
def __init__(self):
|
|||
|
|
GF3_SLCNamespace.__init__(self)
|
|||
|
|
self.WidthInMeters = None
|
|||
|
|
self.productLevel = None
|
|||
|
|
self.productType = None
|
|||
|
|
self.productFormat = None
|
|||
|
|
self.productGentime = None
|
|||
|
|
self.productPolar = None
|
|||
|
|
self.NominalResolution = None
|
|||
|
|
|
|||
|
|
def set_from_etnode(self,node):
|
|||
|
|
for z in node:
|
|||
|
|
if z.tag == 'NominalResolution':
|
|||
|
|
self.NominalResolution = float(z.text)
|
|||
|
|
elif z.tag == 'WidthInMeters':
|
|||
|
|
self.WidthInMeters = float(z.text)
|
|||
|
|
if z.tag == 'productLevel':
|
|||
|
|
self.productLevel = int(z.text)
|
|||
|
|
elif z.tag == 'productType':
|
|||
|
|
self.productType = z.text
|
|||
|
|
elif z.tag == 'productFormat':
|
|||
|
|
self.productFormat = z.text
|
|||
|
|
elif z.tag == 'productGentime':
|
|||
|
|
self.productGentime = self.convertToDateTime_S(z.text)
|
|||
|
|
elif z.tag == 'productPolar':
|
|||
|
|
self.productPolar = z.text
|
|||
|
|
|
|||
|
|
def __str__(self):
|
|||
|
|
retstr = "OrbitAndAttitude:"+sep
|
|||
|
|
retlst = ()
|
|||
|
|
retstr += "NominalResolution=%s"+sep+tab
|
|||
|
|
retlst += (self.NominalResolution,)
|
|||
|
|
retstr += "WidthInMeters=%s"+sep+tab
|
|||
|
|
retlst += (self.WidthInMeters,)
|
|||
|
|
retstr += "productType=%s"+sep+tab
|
|||
|
|
retlst += (self.productType,)
|
|||
|
|
retstr += "productGentime=%s"+sep+tab
|
|||
|
|
retlst += (self.productGentime,)
|
|||
|
|
retstr += "productPolar=%s"+sep+tab
|
|||
|
|
retlst += (self.productPolar,)
|
|||
|
|
retstr += ":OrbitAndAttitude"+sep
|
|||
|
|
return retstr % retlst
|
|||
|
|
|
|||
|
|
class _OrbitInformation(GF3_SLCNamespace):
|
|||
|
|
def __init__(self):
|
|||
|
|
GF3_SLCNamespace.__init__(self)
|
|||
|
|
self.passDirection = None
|
|||
|
|
self.orbitDataSource = None
|
|||
|
|
self.orbitDataFile = None
|
|||
|
|
self.stateVectors = []
|
|||
|
|
self.gpsParam = []
|
|||
|
|
|
|||
|
|
def set_from_etnode(self,node):
|
|||
|
|
for z in node:
|
|||
|
|
if z.tag == self.elementName('passDirection'):
|
|||
|
|
self.passDirection = z.text
|
|||
|
|
elif z.tag == self.elementName('orbitDataSource'):
|
|||
|
|
self.orbitDataSource = z.text
|
|||
|
|
elif z.tag == self.elementName('orbitDataFile'):
|
|||
|
|
self.orbitDataFile = z.text
|
|||
|
|
elif z.tag == self.elementName('stateVector'):
|
|||
|
|
sv = _StateVector()
|
|||
|
|
sv.set_from_etnode(z)
|
|||
|
|
self.stateVectors.append(sv)
|
|||
|
|
elif z.tag == 'GPSParam':
|
|||
|
|
gps = _StateVector()
|
|||
|
|
gps.set_from_etnode(z)
|
|||
|
|
self.gpsParam.append(gps)
|
|||
|
|
|
|||
|
|
def __str__(self):
|
|||
|
|
retstr = "OrbitInformation:"+sep+tab
|
|||
|
|
retlst = ()
|
|||
|
|
retstr += "passDirection=%s"+sep+tab
|
|||
|
|
retlst += (self.passDirection,)
|
|||
|
|
retstr += "orbitDataSource=%s"+sep+tab
|
|||
|
|
retlst += (self.orbitDataSource,)
|
|||
|
|
retstr += "orbitDataFile=%s"+sep
|
|||
|
|
retlst += (self.orbitDataFile,)
|
|||
|
|
retstr += ":OrbitInformation"+sep
|
|||
|
|
return retstr % retlst
|
|||
|
|
|
|||
|
|
class _StateVector(GF3_SLCNamespace):
|
|||
|
|
def __init__(self):
|
|||
|
|
GF3_SLCNamespace.__init__(self)
|
|||
|
|
self.timeStamp = None
|
|||
|
|
self.xPosition = None
|
|||
|
|
self.yPosition = None
|
|||
|
|
self.zPosition = None
|
|||
|
|
self.xVelocity = None
|
|||
|
|
self.yVelocity = None
|
|||
|
|
self.zVelocity = None
|
|||
|
|
|
|||
|
|
def set_from_etnode(self,node):
|
|||
|
|
for z in node:
|
|||
|
|
if z.tag == self.elementName('timeStamp'):
|
|||
|
|
self.timeStamp = self.convertToDateTime(z.text)
|
|||
|
|
if z.tag == 'TimeStamp':
|
|||
|
|
self.timeStamp = self.convertToDateTime_(z.text)
|
|||
|
|
elif z.tag == 'xPosition':
|
|||
|
|
self.xPosition = float(z.text)
|
|||
|
|
elif z.tag == 'yPosition':
|
|||
|
|
self.yPosition = float(z.text)
|
|||
|
|
elif z.tag == 'zPosition':
|
|||
|
|
self.zPosition = float(z.text)
|
|||
|
|
elif z.tag == 'xVelocity':
|
|||
|
|
self.xVelocity = float(z.text)
|
|||
|
|
elif z.tag == 'yVelocity':
|
|||
|
|
self.yVelocity = float(z.text)
|
|||
|
|
elif z.tag == 'zVelocity':
|
|||
|
|
self.zVelocity = float(z.text)
|
|||
|
|
|
|||
|
|
def __str__(self):
|
|||
|
|
retstr = "StateVector:"+sep+tab
|
|||
|
|
retlst = ()
|
|||
|
|
retstr += "timeStamp=%s"+sep+tab
|
|||
|
|
retlst += (self.timeStamp,)
|
|||
|
|
retstr += "xPosition=%s"+sep+tab
|
|||
|
|
retlst += (self.xPosition,)
|
|||
|
|
retstr += "yPosition=%s"+sep+tab
|
|||
|
|
retlst += (self.yPosition,)
|
|||
|
|
retstr += "zPosition=%s"+sep+tab
|
|||
|
|
retlst += (self.zPosition,)
|
|||
|
|
retstr += "xVelocity=%s"+sep+tab
|
|||
|
|
retlst += (self.xVelocity,)
|
|||
|
|
retstr += "yVelocity=%s"+sep+tab
|
|||
|
|
retlst += (self.yVelocity,)
|
|||
|
|
retstr += "zVelocity=%s"+sep+tab
|
|||
|
|
retlst += (self.zVelocity,)
|
|||
|
|
retstr += sep+":StateVector"
|
|||
|
|
return retstr % retlst
|
|||
|
|
|
|||
|
|
class _imageInfo(GF3_SLCNamespace):
|
|||
|
|
def __init__(self):
|
|||
|
|
GF3_SLCNamespace.__init__(self)
|
|||
|
|
self.imagingStartTime = None
|
|||
|
|
self.imagingEndTime = None
|
|||
|
|
self.nearRange = None
|
|||
|
|
self.refRange = None
|
|||
|
|
self.eqvFs = None
|
|||
|
|
self.eqvPRF = None
|
|||
|
|
self.center = [0, 0]
|
|||
|
|
self.corner = _corner()
|
|||
|
|
self.width = None
|
|||
|
|
self.height = None
|
|||
|
|
self.widthspace = None
|
|||
|
|
self.heightspace = None
|
|||
|
|
self.QualifyValue = [0, 0, 0, 0]
|
|||
|
|
|
|||
|
|
def set_from_etnode(self,node):
|
|||
|
|
for z in node:
|
|||
|
|
if z.tag == 'imagingTime':
|
|||
|
|
imagingTime = z
|
|||
|
|
for t in imagingTime:
|
|||
|
|
if t.tag == 'start':
|
|||
|
|
self.imagingStartTime = self.convertToDateTime_(t.text)
|
|||
|
|
if t.tag == 'end':
|
|||
|
|
self.imagingEndTime = self.convertToDateTime_(t.text)
|
|||
|
|
elif z.tag == 'nearRange':
|
|||
|
|
self.nearRange = float(z.text)
|
|||
|
|
elif z.tag == 'refRange':
|
|||
|
|
self.refRange = float(z.text)
|
|||
|
|
elif z.tag == 'eqvFs':
|
|||
|
|
self.eqvFs = float(z.text) * 1e6 # GF3 的单位是 MHz
|
|||
|
|
elif z.tag == 'eqvPRF':
|
|||
|
|
self.eqvPRF = float(z.text)
|
|||
|
|
elif z.tag == 'center':
|
|||
|
|
center = z
|
|||
|
|
for c in center:
|
|||
|
|
if c.tag == 'latitude':
|
|||
|
|
self.center[1] = float(c.text)
|
|||
|
|
elif c.tag == 'longitude':
|
|||
|
|
self.center[0] = float(c.text)
|
|||
|
|
elif z.tag == 'corner':
|
|||
|
|
self.corner.set_from_etnode(z)
|
|||
|
|
elif z.tag == 'width':
|
|||
|
|
self.width = int(z.text)
|
|||
|
|
elif z.tag == 'height':
|
|||
|
|
self.height = int(z.text)
|
|||
|
|
elif z.tag == 'widthspace':
|
|||
|
|
self.widthspace = float(z.text)
|
|||
|
|
elif z.tag == 'heightspace':
|
|||
|
|
self.heightspace = float(z.text)
|
|||
|
|
elif z.tag == 'QualifyValue':
|
|||
|
|
QualifyValue = z
|
|||
|
|
for value in QualifyValue:
|
|||
|
|
if value.tag == 'HH':
|
|||
|
|
self.QualifyValue[0] = float(value.text)
|
|||
|
|
elif value.tag == 'HV':
|
|||
|
|
self.QualifyValue[1] = float(value.text)
|
|||
|
|
elif value.tag == 'VH':
|
|||
|
|
self.QualifyValue[2] = float(value.text)
|
|||
|
|
elif value.tag == 'VV':
|
|||
|
|
self.QualifyValue[3] = float(value.text)
|
|||
|
|
|
|||
|
|
def __str__(self):
|
|||
|
|
retstr = "_ImageInfo:"+sep+tab
|
|||
|
|
retlst = ()
|
|||
|
|
retstr += "nearRange=%s"+sep+tab
|
|||
|
|
retlst += (self.nearRange,)
|
|||
|
|
retstr += "refRange=%s"+sep+tab
|
|||
|
|
retlst += (self.refRange,)
|
|||
|
|
retstr += "eqvFs=%s"+sep+tab
|
|||
|
|
retlst += (self.eqvFs,)
|
|||
|
|
retstr += "eqvPRF=%s"+sep+tab
|
|||
|
|
retlst += (self.eqvPRF,)
|
|||
|
|
retstr += "width=%s"+sep+tab
|
|||
|
|
retlst += (self.width,)
|
|||
|
|
retstr += "height=%s"+sep+tab
|
|||
|
|
retlst += (self.height,)
|
|||
|
|
retstr += "widthspace=%s"+sep+tab
|
|||
|
|
retlst += (self.widthspace,)
|
|||
|
|
retstr += "heightspace=%s"+sep+tab
|
|||
|
|
retlst += (self.heightspace,)
|
|||
|
|
retstr += ":_ImageInfo"+sep
|
|||
|
|
return retstr % retlst
|
|||
|
|
|
|||
|
|
class _ATTIParam(GF3_SLCNamespace):
|
|||
|
|
def __init__(self):
|
|||
|
|
GF3_SLCNamespace.__init__(self)
|
|||
|
|
self.timeStamp = None
|
|||
|
|
self.yawAngle = None
|
|||
|
|
self.rollAngle = None
|
|||
|
|
self.pitchAngle = None
|
|||
|
|
|
|||
|
|
def set_from_etnode(self,node):
|
|||
|
|
for z in node:
|
|||
|
|
if z.tag == 'TimeStamp':
|
|||
|
|
self.timeStamp = self.convertToDateTime_(z.text)
|
|||
|
|
elif z.tag == 'yawAngle':
|
|||
|
|
self.yaw = float(z.text)
|
|||
|
|
elif z.tag == 'rollAngle':
|
|||
|
|
self.roll = float(z.text)
|
|||
|
|
elif z.tag == 'pitchAngle':
|
|||
|
|
self.pitch = float(z.text)
|
|||
|
|
|
|||
|
|
def __str__(self):
|
|||
|
|
retstr = "_ATTIParam:"+sep+tab
|
|||
|
|
retlst = ()
|
|||
|
|
retstr += "TimeStamp=%s"+sep+tab
|
|||
|
|
retlst += (self.timeStamp,)
|
|||
|
|
retstr += "yawAngle=%s"+sep+tab
|
|||
|
|
retlst += (self.yaw,)
|
|||
|
|
retstr += "rollAngle=%s"+sep+tab
|
|||
|
|
retlst += (self.roll,)
|
|||
|
|
retstr += "pitchAngle=%s"+sep+tab
|
|||
|
|
retlst += (self.pitch,)
|
|||
|
|
retstr += sep+":__ATTIParam"
|
|||
|
|
return retstr % retlst
|
|||
|
|
|
|||
|
|
class _corner(GF3_SLCNamespace):
|
|||
|
|
def __init__(self):
|
|||
|
|
GF3_SLCNamespace.__init__(self)
|
|||
|
|
self.topLeft = [0, 0]
|
|||
|
|
self.topRight = [0, 0]
|
|||
|
|
self.bottomLeft = [0, 0]
|
|||
|
|
self.bottomRight = [0, 0]
|
|||
|
|
|
|||
|
|
def set_from_etnode(self,node):
|
|||
|
|
for z in node:
|
|||
|
|
if z.tag == 'topLeft':
|
|||
|
|
topLeft = z
|
|||
|
|
for p in topLeft:
|
|||
|
|
if p.tag == 'latitude':
|
|||
|
|
self.topLeft[1] = float(p.text)
|
|||
|
|
elif p.tag == 'longitude':
|
|||
|
|
self.topLeft[0] = float(p.text)
|
|||
|
|
elif z.tag == 'topRight':
|
|||
|
|
topRight = z
|
|||
|
|
for p in topRight:
|
|||
|
|
if p.tag == 'latitude':
|
|||
|
|
self.topRight[1] = float(p.text)
|
|||
|
|
elif p.tag == 'longitude':
|
|||
|
|
self.topRight[0] = float(p.text)
|
|||
|
|
elif z.tag == 'bottomLeft':
|
|||
|
|
bottomLeft = z
|
|||
|
|
for p in bottomLeft:
|
|||
|
|
if p.tag == 'latitude':
|
|||
|
|
self.bottomLeft[1] = float(p.text)
|
|||
|
|
elif p.tag == 'longitude':
|
|||
|
|
self.bottomLeft[0] = float(p.text)
|
|||
|
|
elif z.tag == 'bottomRight':
|
|||
|
|
bottomRight = z
|
|||
|
|
for p in bottomRight:
|
|||
|
|
if p.tag == 'latitude':
|
|||
|
|
self.bottomRight[1] = float(p.text)
|
|||
|
|
elif p.tag == 'longitude':
|
|||
|
|
self.bottomRight[0] = float(p.text)
|
|||
|
|
|
|||
|
|
def __str__(self):
|
|||
|
|
retstr = "_Corner:"+sep
|
|||
|
|
retlst = ()
|
|||
|
|
retstr += ":_Corner"
|
|||
|
|
return retstr % retlst
|
|||
|
|
|
|||
|
|
class _processInfo(GF3_SLCNamespace):
|
|||
|
|
def __init__(self):
|
|||
|
|
GF3_SLCNamespace.__init__(self)
|
|||
|
|
self.RangeWeightType = None
|
|||
|
|
self.RangeWeightPara = []
|
|||
|
|
self.AzimuthWeightType = None
|
|||
|
|
self.AzimuthWeightPara = []
|
|||
|
|
self.incidenceAngleNearRange = None
|
|||
|
|
self.incidenceAngleFarRange = None
|
|||
|
|
self.RangeLookBandWidth = None
|
|||
|
|
self.AzimuthLookBandWidth = None
|
|||
|
|
self.TotalProcessedAzimuthBandWidth = None
|
|||
|
|
self.DopplerParametersReferenceTime = None
|
|||
|
|
self.DopplerCentroidCoefficients = [0, 1, 2, 3, 4]
|
|||
|
|
self.DopplerRateValuesCoefficients = [0, 1, 2, 3, 4]
|
|||
|
|
|
|||
|
|
def set_from_etnode(self,node):
|
|||
|
|
for z in node:
|
|||
|
|
if z.tag == 'RangeWeightType':
|
|||
|
|
self.RangeWeightType = int(z.text)
|
|||
|
|
elif z.tag == 'RangeWeightPara':
|
|||
|
|
self.RangeWeightPara = z.text.split(',')
|
|||
|
|
elif z.tag == 'AzimuthWeightType':
|
|||
|
|
self.AzimuthWeightType = float(z.text)
|
|||
|
|
elif z.tag == 'AzimuthWeightPara':
|
|||
|
|
self.AzimuthWeightPara = z.text.split(',')
|
|||
|
|
elif z.tag == 'incidenceAngleNearRange':
|
|||
|
|
self.incidenceAngleNearRange = float(z.text)
|
|||
|
|
elif z.tag == 'incidenceAngleFarRange':
|
|||
|
|
self.incidenceAngleFarRange = float(z.text)
|
|||
|
|
elif z.tag == 'RangeLookBandWidth':
|
|||
|
|
self.RangeLookBandWidth = float(z.text)
|
|||
|
|
elif z.tag == 'AzimuthLookBandWidth':
|
|||
|
|
self.AzimuthLookBandWidth = float(z.text)
|
|||
|
|
elif z.tag == 'TotalProcessedAzimuthBandWidth':
|
|||
|
|
self.TotalProcessedAzimuthBandWidth = float(z.text)
|
|||
|
|
elif z.tag == 'DopplerParametersReferenceTime':
|
|||
|
|
self.DopplerParametersReferenceTime = float(z.text) * 1e-6 #
|
|||
|
|
elif z.tag == 'DopplerCentroidCoefficients':
|
|||
|
|
DopplerCentroidCoefficient = z
|
|||
|
|
for value in DopplerCentroidCoefficient:
|
|||
|
|
if value.tag == 'd0':
|
|||
|
|
self.DopplerCentroidCoefficients[0] = float(value.text)
|
|||
|
|
elif value.tag == 'd1':
|
|||
|
|
self.DopplerCentroidCoefficients[1] = float(value.text)
|
|||
|
|
elif value.tag == 'd2':
|
|||
|
|
self.DopplerCentroidCoefficients[2] = float(value.text)
|
|||
|
|
elif value.tag == 'd3':
|
|||
|
|
self.DopplerCentroidCoefficients[3] = float(value.text)
|
|||
|
|
elif value.tag == 'd4':
|
|||
|
|
self.DopplerCentroidCoefficients[4] = float(value.text)
|
|||
|
|
elif z.tag == 'DopplerRateValuesCoefficients':
|
|||
|
|
DopplerRateValuesCoefficient = z
|
|||
|
|
for value in DopplerRateValuesCoefficient:
|
|||
|
|
if value.tag == 'r0':
|
|||
|
|
self.DopplerRateValuesCoefficients[0] = float(value.text)
|
|||
|
|
elif value.tag == 'r1':
|
|||
|
|
self.DopplerRateValuesCoefficients[1] = float(value.text)
|
|||
|
|
elif value.tag == 'r2':
|
|||
|
|
self.DopplerRateValuesCoefficients[2] = float(value.text)
|
|||
|
|
elif value.tag == 'r3':
|
|||
|
|
self.DopplerRateValuesCoefficients[3] = float(value.text)
|
|||
|
|
elif value.tag == 'r4':
|
|||
|
|
self.DopplerRateValuesCoefficients[4] = float(value.text)
|
|||
|
|
|
|||
|
|
def __str__(self):
|
|||
|
|
retstr = "_ProcessInfo:"+sep+tab
|
|||
|
|
retlst = ()
|
|||
|
|
retstr += "incidenceAngleNearRange=%s"+sep+tab
|
|||
|
|
retlst += (self.incidenceAngleNearRange,)
|
|||
|
|
retstr += "incidenceAngleFarRange=%s"+sep+tab
|
|||
|
|
retlst += (self.incidenceAngleFarRange,)
|
|||
|
|
retstr += "DopplerParametersReferenceTime=%s"+sep+tab
|
|||
|
|
retlst += (self.DopplerParametersReferenceTime,)
|
|||
|
|
retstr += "DopplerCentroidCoefficients=%s"+sep
|
|||
|
|
retlst += (self.DopplerCentroidCoefficients,)
|
|||
|
|
retstr += "DopplerRateValuesCoefficients=%s"+sep
|
|||
|
|
retlst += (self.DopplerRateValuesCoefficients,)
|
|||
|
|
retstr += ":_ProcessInfo"+sep
|
|||
|
|
return retstr % retlst
|
|||
|
|
|
|||
|
|
def findPreciseOrbit(dirname, fname, year):
|
|||
|
|
'''
|
|||
|
|
Find precise orbit file in given folder.
|
|||
|
|
'''
|
|||
|
|
|
|||
|
|
import glob
|
|||
|
|
|
|||
|
|
###First try root folder itself
|
|||
|
|
res = glob.glob( os.path.join(dirname, fname.lower()))
|
|||
|
|
if len(res) == 0:
|
|||
|
|
|
|||
|
|
res = glob.glob( os.path.join(dirname, "{0}".format(year), fname.lower()))
|
|||
|
|
if len(res) == 0:
|
|||
|
|
raise Exception('Orbit Dirname provided but no suitable orbit file found in {0}'.format(dirname))
|
|||
|
|
|
|||
|
|
|
|||
|
|
if len(res) > 1:
|
|||
|
|
print('More than one matching result found. Using first result.')
|
|||
|
|
|
|||
|
|
return res[0]
|
|||
|
|
|
|||
|
|
def convertRSTimeToDateTime(instr):
|
|||
|
|
'''
|
|||
|
|
Convert RS2 orbit time string to datetime.
|
|||
|
|
'''
|
|||
|
|
|
|||
|
|
parts = instr.strip().split('-')
|
|||
|
|
tparts = parts[-1].split(':')
|
|||
|
|
secs = float(tparts[2])
|
|||
|
|
intsecs = int(secs)
|
|||
|
|
musecs = int((secs - intsecs)*1e6)
|
|||
|
|
|
|||
|
|
timestamp = datetime.datetime(int(parts[0]),1,1, int(tparts[0]), int(tparts[1]), intsecs, musecs) + datetime.timedelta(days = int(parts[1])-1)
|
|||
|
|
|
|||
|
|
return timestamp
|