def testNotEqualCompare(self):
"""
Test that __cmp__ returns false when the times are different, but the
positions and velocities are the same.
"""
sv1 = StateVector()
time1 = datetime.datetime(year=2001,
month=2,
day=7,
hour=12,
minute=13,
second=5)
pos1 = [1.0, 2.0, 3.0]
vel1 = [0.6, 0.6, 0.6]
sv1.setTime(time1)
sv1.setPosition(pos1)
sv1.setVelocity(vel1)
sv2 = StateVector()
time2 = datetime.datetime(year=2001,
month=2,
day=7,
hour=12,
minute=13,
second=4)
pos2 = [1.0, 2.0, 3.0]
vel2 = [0.6, 0.6, 0.6]
sv2.setTime(time2)
sv2.setPosition(pos2)
sv2.setVelocity(vel2)
self.assertFalse(sv1 == sv2)
def orbit2sch(self):
for port in self.inputPorts:
port()
self.dim1_orbitPosition = len(self.orbitPosition)
self.dim2_orbitPosition = len(self.orbitPosition[0])
self.dim1_orbitVelocity = len(self.orbitVelocity)
self.dim2_orbitVelocity = len(self.orbitVelocity[0])
self.dim1_position = self.dim1_orbitPosition
self.dim2_position = self.dim2_orbitPosition
self.dim1_velocity = self.dim1_orbitVelocity
self.dim2_velocity = self.dim2_orbitVelocity
self.dim1_acceleration = self.dim1_orbitPosition
self.dim2_acceleration = self.dim2_orbitPosition
self.allocateArrays()
self.setState()
orbit2sch.orbit2sch_Py()
self.getState()
self.deallocateArrays()
self._orbit = Orbit(source='SCH')
# self._orbit.setOrbitSource('Orbit2SCH')
self._orbit.setReferenceFrame('SCH')
#
for i in range(len(self.position)):
sv = StateVector()
sv.setTime(self._time[i])
sv.setPosition(self.position[i])
sv.setVelocity(self.velocity[i])
self._orbit.addStateVector(sv)
return
def setUp(self):
logging.basicConfig()
self.linearOrbit = Orbit()
self.quadOrbit = Orbit()
linpos, linvel = self.generateLinearSV(10, [[1.0, 2.0, 3.0]],
[[1.0 / 60.0
for j in range(3)]])
quadpos, quadvel = self.generateQuadraticSV(10, [[1.0, 2.0, 3.0]], 0.1)
dt = datetime.datetime(year=2010, month=1, day=1)
for i in range(10):
linsv = StateVector()
quadsv = StateVector()
linsv.setTime(dt)
quadsv.setTime(dt)
linsv.setPosition(linpos[i])
linsv.setVelocity(linvel[i])
quadsv.setPosition(quadpos[i])
quadsv.setVelocity(quadvel[i])
self.linearOrbit.addStateVector(linsv)
self.quadOrbit.addStateVector(quadsv)
dt = dt + datetime.timedelta(minutes=1)
def populateCEOSOrbit(self):
from isceobj.Orbit.Inertial import ECI2ECR
t0 = datetime.datetime(year=self.leaderFile.platformPositionRecord.metadata['Year of data point'],
month=self.leaderFile.platformPositionRecord.metadata['Month of data point'],
day=self.leaderFile.platformPositionRecord.metadata['Day of data point'])
t0 = t0 + datetime.timedelta(seconds=self.leaderFile.platformPositionRecord.metadata['Seconds of day'])
#####Read in orbit in inertial coordinates
orb = Orbit()
for i in range(self.leaderFile.platformPositionRecord.metadata['Number of data points']):
vec = StateVector()
t = t0 + datetime.timedelta(seconds=(i*self.leaderFile.platformPositionRecord.metadata['Time interval between DATA points']))
vec.setTime(t)
dataPoints = self.leaderFile.platformPositionRecord.metadata['Positional Data Points'][i]
vec.setPosition([dataPoints['Position vector X'], dataPoints['Position vector Y'], dataPoints['Position vector Z']])
vec.setVelocity([dataPoints['Velocity vector X']/1000., dataPoints['Velocity vector Y']/1000., dataPoints['Velocity vector Z']/1000.])
orb.addStateVector(vec)
#####Convert orbits from ECI to ECEF frame.
t0 = orb._stateVectors[0]._time
ang = self.leaderFile.platformPositionRecord.metadata['Greenwich mean hour angle']
cOrb = ECI2ECR(orb, GAST=ang, epoch=t0)
wgsorb = cOrb.convert()
orb = self.frame.getOrbit()
for sv in wgsorb:
orb.addStateVector(sv)
print(sv)
def extractOrbit(self):
'''
Extract orbit information from xml node.
'''
node = self._xml_root.find('generalAnnotation/orbitList')
frameOrbit = self.frame.getOrbit()
frameOrbit.setOrbitSource('Header')
for child in node.getchildren():
timestamp = self.convertToDateTime(child.find('time').text)
pos = []
vel = []
posnode = child.find('position')
velnode = child.find('velocity')
for tag in ['x', 'y', 'z']:
pos.append(float(posnode.find(tag).text))
for tag in ['x', 'y', 'z']:
vel.append(float(velnode.find(tag).text))
vec = StateVector()
vec.setTime(timestamp)
vec.setPosition(pos)
vec.setVelocity(vel)
frameOrbit.addStateVector(vec)
def extractOrbit(self):
'''
Extract orbit information from xml node.
'''
node = self._xml_root.find('generalAnnotation/orbitList')
frameOrbit = Orbit()
frameOrbit.configure()
for child in node.getchildren():
timestamp = self.convertToDateTime(child.find('time').text)
pos = []
vel = []
posnode = child.find('position')
velnode = child.find('velocity')
for tag in ['x','y','z']:
pos.append(float(posnode.find(tag).text))
for tag in ['x','y','z']:
vel.append(float(velnode.find(tag).text))
vec = StateVector()
vec.setTime(timestamp)
vec.setPosition(pos)
vec.setVelocity(vel)
frameOrbit.addStateVector(vec)
print(vec)
orbExt = OrbitExtender(planet=Planet(pname='Earth'))
orbExt.configure()
newOrb = orbExt.extendOrbit(frameOrbit)
return newOrb
def extractOrbit(self):
'''
Extract orbit information from xml node.
'''
node = self._xml_root.find('generalAnnotation/orbitList')
print('Extracting orbit from annotation XML file')
frameOrbit = Orbit()
frameOrbit.configure()
for child in node:
timestamp = self.convertToDateTime(child.find('time').text)
pos = []
vel = []
posnode = child.find('position')
velnode = child.find('velocity')
for tag in ['x', 'y', 'z']:
pos.append(float(posnode.find(tag).text))
for tag in ['x', 'y', 'z']:
vel.append(float(velnode.find(tag).text))
vec = StateVector()
vec.setTime(timestamp)
vec.setPosition(pos)
vec.setVelocity(vel)
frameOrbit.addStateVector(vec)
return frameOrbit
def readOrbit(self, platformPositionRecord):
'''
reformat orbit from platformPositionRecord
'''
orb=Orbit()
orb.setOrbitSource('leaderfile')
orb.setOrbitQuality(self.orbitElementsDesignator[platformPositionRecord.metadata['Orbital elements designator']])
t0 = datetime.datetime(year=platformPositionRecord.metadata['Year of data point'],
month=platformPositionRecord.metadata['Month of data point'],
day=platformPositionRecord.metadata['Day of data point'])
t0 = t0 + datetime.timedelta(seconds=platformPositionRecord.metadata['Seconds of day'])
#####Read in orbit in inertial coordinates
deltaT = platformPositionRecord.metadata['Time interval between data points']
numPts = platformPositionRecord.metadata['Number of data points']
for i in range(numPts):
vec = StateVector()
t = t0 + datetime.timedelta(seconds=i*deltaT)
vec.setTime(t)
dataPoints = platformPositionRecord.metadata['Positional Data Points'][i]
pos = [dataPoints['Position vector X'], dataPoints['Position vector Y'], dataPoints['Position vector Z']]
vel = [dataPoints['Velocity vector X'], dataPoints['Velocity vector Y'], dataPoints['Velocity vector Z']]
vec.setPosition(pos)
vec.setVelocity(vel)
orb.addStateVector(vec)
return orb
def extractOrbitFromAnnotation(self):
'''
Extract orbit information from xml node.
'''
node = self._xml_root.find('generalAnnotation/orbitList')
frameOrbit = Orbit()
frameOrbit.setOrbitSource('Header')
for child in node:
timestamp = self.convertToDateTime(child.find('time').text)
pos = []
vel = []
posnode = child.find('position')
velnode = child.find('velocity')
for tag in ['x', 'y', 'z']:
pos.append(float(posnode.find(tag).text))
for tag in ['x', 'y', 'z']:
vel.append(float(velnode.find(tag).text))
vec = StateVector()
vec.setTime(timestamp)
vec.setPosition(pos)
vec.setVelocity(vel)
frameOrbit.addStateVector(vec)
planet = self.frame.instrument.platform.planet
orbExt = OrbitExtender(planet=planet)
orbExt.configure()
newOrb = orbExt.extendOrbit(frameOrbit)
return newOrb
def sch2orbit(self):
for port in self.inputPorts:
port()
lens = [len(self.orbitPosition), len(self.orbitVelocity)]
if min(lens) != max(lens):
raise Exception('Position and Velocity vector lengths dont match')
self._numVectors = lens[0]
self.allocateArrays()
self.setState()
sch2orbit.sch2orbit_Py()
self.getState()
self.deallocateArrays()
self._orbit = Orbit(source='XYZ')
self._orbit.setReferenceFrame('XYZ')
#
for i in range(len(self.position)):
sv = StateVector()
sv.setTime(self._time[i])
sv.setPosition(self.position[i])
sv.setVelocity(self.velocity[i])
self._orbit.addStateVector(sv)
return
def _populateOrbit(self, file):
import numpy as np
orbit = self.frame.getOrbit()
orbit.setReferenceFrame('ECR')
orbit.setOrbitSource('Header')
t = file['state_vector_time_utc'][:]
position = np.zeros((t.size, 3))
position[:, 0] = file['posX'][:]
position[:, 1] = file['posY'][:]
position[:, 2] = file['posZ'][:]
velocity = np.zeros((t.size, 3))
velocity[:, 0] = file['velX'][:]
velocity[:, 1] = file['velY'][:]
velocity[:, 2] = file['velZ'][:]
for ii in range(t.size):
vec = StateVector()
vec.setTime(
datetime.datetime.strptime(t[ii][0].decode('utf-8'),
'%Y-%m-%dT%H:%M:%S.%f'))
vec.setPosition(
[position[ii, 0], position[ii, 1], position[ii, 2]])
vec.setVelocity(
[velocity[ii, 0], velocity[ii, 1], velocity[ii, 2]])
orbit.addStateVector(vec)
def parseParFile(self):
'''Parse the par file if any is available.'''
if self._parFile not in (None, ''):
par = ParFile(self._parFile)
####Update orbit
svs = par['prep_block']['sensor']['ephemeris']['sv_block'][
'state_vector']
datefmt = '%Y%m%d%H%M%S%f'
for entry in svs:
sv = StateVector()
sv.setPosition(
[float(entry['x']),
float(entry['y']),
float(entry['z'])])
sv.setVelocity([
float(entry['xv']),
float(entry['yv']),
float(entry['zv'])
])
sv.setTime(datetime.datetime.strptime(entry['Date'], datefmt))
self.frame.orbit.addStateVector(sv)
self.frame.orbit._stateVectors = sorted(
self.frame.orbit._stateVectors, key=lambda x: x.getTime())
doppinfo = par['prep_block']['sensor']['beam'][
'DopplerCentroidParameters']
#######Selectively update some values.
#######Currently used only for doppler centroids.
self.doppler_ref_range = float(doppinfo['reference_range'])
self.doppler_ref_azi = datetime.datetime.strptime(
doppinfo['reference_date'], '%Y%m%d%H%M%S%f')
self.doppler_predict = float(doppinfo['Predict_doppler'])
self.doppler_DAR = float(doppinfo['DAR_doppler'])
coeff = doppinfo['doppler_centroid_coefficients']
rngOrder = int(coeff['number_of_coefficients_first_dimension']) - 1
azOrder = int(coeff['number_of_coefficients_second_dimension']) - 1
self.doppler_coeff = Poly2D.Poly2D()
self.doppler_coeff.initPoly(rangeOrder=rngOrder,
azimuthOrder=azOrder)
self.doppler_coeff.setMeanRange(self.doppler_ref_range)
self.doppler_coeff.setMeanAzimuth(
secondsSinceMidnight(self.doppler_ref_azi))
parms = []
for ii in range(azOrder + 1):
row = []
for jj in range(rngOrder + 1):
key = 'a%d%d' % (ii, jj)
val = float(coeff[key])
row.append(val)
parms.append(row)
self.doppler_coeff.setCoeffs(parms)
def interpolateOrbit(self, time, frame='ITRF93'):
if frame not in ('ITRF93', 'J2000', 'ECI_TOD', 'ECLIPJ2000'):
raise Exception(
'Currently only ITRF93/J2000 frames are supported.')
et = SpiceyPy.str2et(str(time))
res, lt = SpiceyPy.spkezr('-123710', et, frame, 'None', 'EARTH')
sv = StateVector()
sv.setTime(time)
sv.setPosition([x * 1000.0 for x in res[0:3]])
sv.setVelocity([x * 1000.0 for x in res[3:6]])
return sv
def _populateOrbit(self, file):
orbit = self.frame.getOrbit()
orbit.setReferenceFrame('ECR')
orbit.setOrbitSource(file['Orbit'].attrs['Source'])
for i in range(len(file['Orbit']['Time'])):
vec = StateVector()
time = DTU.parseIsoDateTime(file['Orbit']['Time'][i])
vec.setTime(time)
vec.setPosition(list(file['Orbit']['Position'][i]))
vec.setVelocity(list(file['Orbit']['Velocity'][i]))
orbit.addStateVector(vec)
def convert(self):
'''
Convert ECI orbit to ECEF orbit.
'''
ECROrbit = Orbit()
ECROrbit.configure()
for sv in self.orbit:
svtime = sv.getTime()
position = sv.getPosition()
velocity = sv.getVelocity()
####Compute GMST from GAST - Eq 5.13
dtiff = (svtime - self.referenceEpoch).total_seconds()
theta = self.referenceGAST + self.Omega * dtiff
costh = np.cos(theta)
sinth = np.sin(theta)
###Position transformation
A = np.zeros((3, 3))
A[0, 0] = costh
A[0, 1] = sinth
A[1, 0] = -sinth
A[1, 1] = costh
A[2, 2] = 1
###Velocity transformation
Adot = np.zeros((3, 3))
Adot[0, 0] = -self.Omega * sinth
Adot[0, 1] = self.Omega * costh
Adot[1, 0] = -self.Omega * costh
Adot[1, 1] = -self.Omega * sinth
###Compute ECR state vector
newPos = np.dot(A, position)
newVel = np.dot(Adot, position) + np.dot(A, velocity)
####Create state vector object
newsv = StateVector()
newsv.setTime(svtime)
newsv.setPosition(newPos.tolist())
newsv.setVelocity(newVel.tolist())
###Append to orbit
ECROrbit.addStateVector(newsv)
ECROrbit.setOrbitSource('Sidereal angle conversion')
ECROrbit.setOrbitQuality(self.orbit.getOrbitQuality())
return ECROrbit
def readStateVectors(self):
headerLength = self.mphLength + self.sphLength
self.fp.seek(headerLength)
for line in self.fp.readlines():
vals = line.decode('utf8').split()
dateTime = self._parseDateTime(vals[0] + ' ' + vals[1])
position = list(map(float, vals[4:7]))
velocity = list(map(float, vals[7:10]))
sv = StateVector()
sv.setTime(dateTime)
sv.setPosition(position)
sv.setVelocity(velocity)
self.orbit.addStateVector(sv)
def createStateVectors(self, positions):
"""Calculate the satellite velocity from the position data and create StateVector objects"""
for i in range(len(positions)):
t0 = positions[i]['time']
x0 = positions[i]['x']
y0 = positions[i]['y']
z0 = positions[i]['z']
sv = StateVector()
sv.setTime(t0)
sv.setPosition([x0, y0, z0])
sv.setVelocity([0.0, 0.0, 0.0])
self._ephemeris.addStateVector(sv)
self._calculateVelocities()
def createFacility():
# StateVector
global svcount, t0, dt
svcount += 1
sv = StateVector()
sv.configure()
sv.setPosition(list(np.random.randint(10, size=(3, ))))
sv.setVelocity(list(np.random.randint(10, size=(3, ))))
t = t0 + (svcount - 1) * dt
#Force microseconds=0 on some statevectors
if svcount % 2 == 0:
t = datetime.datetime(t.year, t.month, t.day, t.hour, t.minute,
t.second)
sv.setTime(t)
return sv
def testScalarVelocity(self):
"""
Test that the scalar velocity returns the expected value
"""
ans = 0.0288675134594813
sv1 = StateVector()
time1 = datetime.datetime(year=2001,month=2,day=7,hour=12,minute=13,second=5)
pos1 = [1.0,2.0,3.0]
vel1 = [0.0166666,0.0166666,0.0166666]
sv1.setTime(time1)
sv1.setPosition(pos1)
sv1.setVelocity(vel1)
vel = sv1.getScalarVelocity()
self.assertAlmostEquals(ans,vel,5)
def extractPreciseOrbit(self):
'''
Extract precise orbit from given Orbit file.
'''
try:
fp = open(self.orbitfile, 'r')
except IOError as strerr:
print("IOError: %s" % strerr)
return
_xml_root = ElementTree(file=fp).getroot()
node = _xml_root.find('Data_Block/List_of_OSVs')
orb = Orbit()
orb.configure()
margin = datetime.timedelta(seconds=40.0)
tstart = self.frame.getSensingStart() - margin
tend = self.frame.getSensingStop() + margin
for child in node.getchildren():
timestamp = self.convertToDateTime(child.find('UTC').text[4:])
if (timestamp >= tstart) and (timestamp < tend):
pos = []
vel = []
for tag in ['VX', 'VY', 'VZ']:
vel.append(float(child.find(tag).text))
for tag in ['X', 'Y', 'Z']:
pos.append(float(child.find(tag).text))
vec = StateVector()
vec.setTime(timestamp)
vec.setPosition(pos)
vec.setVelocity(vel)
orb.addStateVector(vec)
fp.close()
self.frame.getOrbit().setOrbitSource('Header')
for sv in orb:
self.frame.getOrbit().addStateVector(sv)
return
def __parseStateVectorLine(self,line):
date = line[0:11]
time = line[12:27]
x = float(line[44:56])
y = float(line[57:69])
z = float(line[70:82])
vx = float(line[83:95])
vy = float(line[96:108])
vz = float(line[109:121])
dt = self.__parseDateTimeString(date,time)
sv = StateVector()
sv.setTime(dt)
sv.setPosition([x,y,z])
sv.setVelocity([vx,vy,vz])
self.orbit.addStateVector(sv)
def _populateOrbit(self):
orbit = self.frame.getOrbit()
orbit.setReferenceFrame('ECR')
orbit.setOrbitSource('Header')
t0 = self._parseNanoSecondTimeStamp(self._xmlFileParser.orbitStartTime)
t = np.arange(self._xmlFileParser.numberSV)*self._xmlFileParser.deltaTimeSV
position = self._xmlFileParser.orbitPositionXYZ
velocity = self._xmlFileParser.orbitVelocityXYZ
for i in range(0,self._xmlFileParser.numberSV):
vec = StateVector()
dt = t0 + datetime.timedelta(seconds=t[i])
vec.setTime(dt)
vec.setPosition([position[i*3],position[i*3+1],position[i*3+2]])
vec.setVelocity([velocity[i*3],velocity[i*3+1],velocity[i*3+2]])
orbit.addStateVector(vec)
print("valor "+str(i)+": "+str(dt))
def _populateOrbit(self,file):
orbit = self.frame.getOrbit()
orbit.setReferenceFrame('ECR')
orbit.setOrbitSource('Header')
t0 = datetime.datetime.strptime(file.attrs['Reference UTC'].decode('utf-8'),'%Y-%m-%d %H:%M:%S.%f000')
t = file.attrs['State Vectors Times']
position = file.attrs['ECEF Satellite Position']
velocity = file.attrs['ECEF Satellite Velocity']
for i in range(len(position)):
vec = StateVector()
dt = t0 + datetime.timedelta(seconds=t[i])
vec.setTime(dt)
vec.setPosition([position[i,0],position[i,1],position[i,2]])
vec.setVelocity([velocity[i,0],velocity[i,1],velocity[i,2]])
orbit.addStateVector(vec)
def _populateOrbit(self):
orbit = self.frame.getOrbit()
velocityScale = 1.0
if (self.leaderFile.sceneHeaderRecord.
metadata['Processing facility identifier'] == 'ERSDAC'):
# The ERSDAC header orbits are in mm/s
velocityScale = 1000.0
orbit.setReferenceFrame(self.leaderFile.platformPositionRecord.
metadata['Reference coordinate system'])
orbit.setOrbitSource('Header')
orbitQuality = self._decodeOrbitQuality(
self.leaderFile.platformPositionRecord.
metadata['Orbital elements designator'])
orbit.setOrbitQuality(orbitQuality)
t0 = datetime.datetime(year=self.leaderFile.platformPositionRecord.
metadata['Year of data point'],
month=self.leaderFile.platformPositionRecord.
metadata['Month of data point'],
day=self.leaderFile.platformPositionRecord.
metadata['Day of data point'])
t0 = t0 + datetime.timedelta(
seconds=self.leaderFile.platformPositionRecord.
metadata['Seconds of day'])
for i in range(self.leaderFile.platformPositionRecord.
metadata['Number of data points']):
vec = OrbitStateVector()
t = t0 + datetime.timedelta(
seconds=i * self.leaderFile.platformPositionRecord.
metadata['Time interval between DATA points'])
vec.setTime(t)
dataPoints = self.leaderFile.platformPositionRecord.metadata[
'Positional Data Points'][i]
vec.setPosition([
dataPoints['Position vector X'],
dataPoints['Position vector Y'],
dataPoints['Position vector Z']
])
vec.setVelocity([
dataPoints['Velocity vector X'] / velocityScale,
dataPoints['Velocity vector Y'] / velocityScale,
dataPoints['Velocity vector Z'] / velocityScale
])
orbit.addStateVector(vec)
def _populateOrbit(self, mdict=None):
orbit = self.frame.getOrbit()
orbit.setReferenceFrame('ECR')
orbit.setOrbitSource('Header')
refDate = self.frame.getSensingStart().date()
t0 = datetime.datetime(refDate.year, refDate.month, refDate.day)
lines = [line.strip() for line in open(self.hdrFile, 'r')]
for line in lines:
vec = StateVector()
if len(line.split()) == 7:
fields = [float(val) for val in line.split()]
dt = t0 + datetime.timedelta(seconds=fields[0])
vec.setTime(dt)
vec.setPosition(fields[1:4])
vec.setVelocity(fields[4:7])
orbit.addStateVector(vec)
def getOrbitFromXML(self):
'''
Populate orbit.
'''
orb = Orbit()
orb.configure()
for node in self._xml_root.find('platform/orbit'):
if node.tag == 'stateVec':
sv = StateVector()
sv.configure()
for z in node:
if z.tag == 'timeUTC':
timeStamp = self.convertToDateTime2(z.text)
elif z.tag == 'posX':
xPosition = float(z.text)
elif z.tag == 'posY':
yPosition = float(z.text)
elif z.tag == 'posZ':
zPosition = float(z.text)
elif z.tag == 'velX':
xVelocity = float(z.text)
elif z.tag == 'velY':
yVelocity = float(z.text)
elif z.tag == 'velZ':
zVelocity = float(z.text)
sv.setTime(timeStamp)
sv.setPosition([xPosition, yPosition, zPosition])
sv.setVelocity([xVelocity, yVelocity, zVelocity])
orb.addStateVector(sv)
print('sv=',sv)
orbExt = OrbitExtender(planet=Planet(pname='Earth'))
orbExt.configure()
newOrb = orbExt.extendOrbit(orb)
return newOrb
self.product.orbit.setOrbitSource('Header')
for sv in newOrb:
self.product.orbit.addStateVector(sv)
def getOrbitFromXML(self):
'''
Populate orbit.
'''
orb = Orbit()
orb.configure()
for node in self._xml_root.find(
'sourceAttributes/orbitAndAttitude/orbitInformation'):
if node.tag == 'stateVector':
sv = StateVector()
sv.configure()
for z in node.getchildren():
if z.tag == 'timeStamp':
timeStamp = self.convertToDateTime(z.text)
elif z.tag == 'xPosition':
xPosition = float(z.text)
elif z.tag == 'yPosition':
yPosition = float(z.text)
elif z.tag == 'zPosition':
zPosition = float(z.text)
elif z.tag == 'xVelocity':
xVelocity = float(z.text)
elif z.tag == 'yVelocity':
yVelocity = float(z.text)
elif z.tag == 'zVelocity':
zVelocity = float(z.text)
sv.setTime(timeStamp)
sv.setPosition([xPosition, yPosition, zPosition])
sv.setVelocity([xVelocity, yVelocity, zVelocity])
orb.addStateVector(sv)
orbExt = OrbitExtender(planet=Planet(pname='Earth'))
orbExt.configure()
newOrb = orbExt.extendOrbit(orb)
return newOrb
self.product.orbit.setOrbitSource('Header')
for sv in newOrb:
self.product.orbit.addStateVector(sv)
def __parseTerrestrialLine(self, line):
j2000Day = float(line[14:20]) / 10.0 + 0.5
tdt = float(line[20:31]) / 1e6
x = float(line[31:43]) / 1e3
y = float(line[43:55]) / 1e3
z = float(line[55:67]) / 1e3
vx = float(line[67:78]) / 1e6
vy = float(line[78:89]) / 1e6
vz = float(line[89:100]) / 1e6
quality = line[127]
tdt = tdt - self.tdtOffset
dt = self.__j2000ToDatetime(j2000Day, tdt)
sv = StateVector()
sv.setTime(dt)
sv.setPosition([x, y, z])
sv.setVelocity([vx, vy, vz])
self.orbit.addStateVector(sv)
def populateMetadata(self):
"""
Create the appropriate metadata objects from our CEOSFormat metadata
"""
frame = self.leaderFile.sceneHeaderRecord.metadata['Scene reference number'].strip()
frame = self._decodeSceneReferenceNumber(frame)
rangePixelSize = Constants.SPEED_OF_LIGHT/(2*self.leaderFile.sceneHeaderRecord.metadata['Range sampling rate']*1e6)
self.frame.getInstrument().getPlatform().setMission(self.leaderFile.sceneHeaderRecord.metadata['Sensor platform mission identifier'])
self.frame.getInstrument().getPlatform().setPlanet(Planet(pname='Earth'))
self.frame.getInstrument().setWavelength(self.leaderFile.sceneHeaderRecord.metadata['Radar wavelength'])
self.frame.getInstrument().setIncidenceAngle(self.leaderFile.sceneHeaderRecord.metadata['Incidence angle at scene centre'])
self.frame.getInstrument().setPulseRepetitionFrequency(self.leaderFile.sceneHeaderRecord.metadata['Pulse Repetition Frequency'])
self.frame.getInstrument().setRangePixelSize(rangePixelSize)
self.frame.getInstrument().setPulseLength(self.leaderFile.sceneHeaderRecord.metadata['Range pulse length']*1e-6)
chirpPulseBandwidth = 15.50829e6 # Is this really not in the CEOSFormat Header?
self.frame.getInstrument().setChirpSlope(chirpPulseBandwidth/(self.leaderFile.sceneHeaderRecord.metadata['Range pulse length']*1e-6))
self.frame.setFrameNumber(frame)
self.frame.setOrbitNumber(self.leaderFile.sceneHeaderRecord.metadata['Orbit number'])
#self.frame.setStartingRange(self.leaderFile.facilityRecord.metadata['Slant range reference'])
self.frame.setProcessingFacility(self.leaderFile.sceneHeaderRecord.metadata['Processing facility identifier'])
self.frame.setProcessingSystem(self.leaderFile.sceneHeaderRecord.metadata['Processing system identifier'])
self.frame.setProcessingSoftwareVersion(self.leaderFile.sceneHeaderRecord.metadata['Processing version identifier'])
self.frame.setPolarization('HH')
self.frame.setNumberOfLines(self.imageFile.imageFDR.metadata['Number of lines per data set'])
self.frame.setNumberOfSamples(self.imageFile.imageFDR.metadata['Number of pixels per line per SAR channel'])
self.frame.getOrbit().setOrbitSource('Header')
t0 = datetime.datetime(year=self.leaderFile.platformPositionRecord.metadata['Year of data point'],
month=self.leaderFile.platformPositionRecord.metadata['Month of data point'],
day=self.leaderFile.platformPositionRecord.metadata['Day of data point'])
t0 = t0 + datetime.timedelta(seconds=self.leaderFile.platformPositionRecord.metadata['Seconds of day'])
for i in range(self.leaderFile.platformPositionRecord.metadata['Number of data points']):
vec = StateVector()
t = t0 + datetime.timedelta(seconds=(i*self.leaderFile.platformPositionRecord.metadata['Time interval between DATA points']))
vec.setTime(t)
dataPoints = self.leaderFile.platformPositionRecord.metadata['Positional Data Points'][i]
vec.setPosition([dataPoints['Position vector X'], dataPoints['Position vector Y'], dataPoints['Position vector Z']])
vec.setVelocity([dataPoints['Velocity vector X'], dataPoints['Velocity vector Y'], dataPoints['Velocity vector Z']])
self.frame.getOrbit().addStateVector(vec)
def _populateHeaderOrbit(self):
"""Populate an orbit object with the header orbits"""
self.logger.info("Using Header Orbits")
orbit = self.frame.getOrbit()
orbit.setOrbitSource('Header')
orbit.setOrbitQuality('Unknown')
t0 = datetime.datetime(year=self.leaderFile.platformPositionRecord.metadata['Year of data point'],
month=self.leaderFile.platformPositionRecord.metadata['Month of data point'],
day=self.leaderFile.platformPositionRecord.metadata['Day of data point'])
t0 = t0 + datetime.timedelta(microseconds=self.leaderFile.platformPositionRecord.metadata['Seconds of day']*1e6)
for i in range(self.leaderFile.platformPositionRecord.metadata['Number of data points']):
vec = StateVector()
deltaT = self.leaderFile.platformPositionRecord.metadata['Time interval between DATA points']
t = t0 + datetime.timedelta(microseconds=i*deltaT*1e6)
vec.setTime(t)
dataPoints = self.leaderFile.platformPositionRecord.metadata['Positional Data Points'][i]
vec.setPosition([dataPoints['Position vector X'], dataPoints['Position vector Y'], dataPoints['Position vector Z']])
vec.setVelocity([dataPoints['Velocity vector X'], dataPoints['Velocity vector Y'], dataPoints['Velocity vector Z']])
orbit.addStateVector(vec)