def _legendreOrbitInterpolation(self,time):
"""Interpolate a state vector using an 8th order Legendre polynomial.
This method returns None if there are fewer than 9 state vectors in
the orbit.
@type time: datetime.datetime
@param time: the time at which to interpolate a state vector
@rtype: Orbit.StateVector
@return: the state vector at the desired time
"""
if len(self) < 9:
self.logger.error(
"Fewer than 9 state vectors present in orbit, cannot interpolate"
)
return None
try:
newOrbit = self.selectStateVectors(time, 4, 5)
except LookupError as e:
return None
obsTime, obsPos, obsVel, offset = newOrbit.to_tuple(
relativeTo=self.minTime
)
t = DTU.timeDeltaToSeconds(time-self.minTime)
t0 = DTU.timeDeltaToSeconds(newOrbit.minTime-self.minTime)
tn = DTU.timeDeltaToSeconds(newOrbit.maxTime-self.minTime)
ansPos = self._legendre8(t0, tn, t, obsPos)
ansVel = self._legendre8(t0, tn, t, obsVel)
return StateVector(time, ansPos, ansVel)
def _linearOrbitInterpolation(self,time):
"""
Linearly interpolate a state vector. This method returns None if
there are fewer than 2 state vectors in the orbit.
@type time: datetime.datetime
@param time: the time at which to interpolate a state vector
@rtype: Orbit.StateVector
@return: the state vector at the desired time
"""
if len(self) < 2:
self.logger.error("Fewer than 2 state vectors present in orbit, cannot interpolate")
return None
position = [0.0 for i in range(3)]
velocity = [0.0 for i in range(3)]
for sv1 in self.stateVectors:
tmp=1.0
for sv2 in self.stateVectors:
if sv1.time == sv2.time:
continue
numerator = float(DTU.timeDeltaToSeconds(sv2.time-time))
denominator = float(
DTU.timeDeltaToSeconds(sv2.time - sv1.time)
)
tmp = tmp*(numerator)/(denominator)
for i in range(3):
position[i] = position[i] + sv1.getPosition()[i]*tmp
velocity[i] = velocity[i] + sv1.getVelocity()[i]*tmp
return StateVector(time, position, velocity)
def _hermiteOrbitInterpolation(self,time):
"""
Interpolate a state vector using Hermite interpolation.
This method returns None if there are fewer than 4 state
vectors in the orbit.
@type time: datetime.datetime
@param time: the time at which to interpolate a state vector
@rtype: Orbit.StateVector
@return: the state vector at the desired time
"""
import os
from ctypes import c_double, cdll,byref
orbitHermite = (
cdll.LoadLibrary(os.path.dirname(__file__)+'/orbitHermite.so')
)
if len(self) < 4:
self.logger.error(
"Fewer than 4 state vectors present in orbit, cannot interpolate"
)
return None
# The Fortran routine assumes that it is getting an array of four
# state vectors
try:
newOrbit = self.selectStateVectors(time, 2, 2)
except LookupError:
self.logger.error("Unable to select 2 state vectors before and after chosen time %s" % (time))
return None
# For now, assume that time is an array containing the times at which
# we want to interpolate
obsTime, obsPos, obsVel,offset = newOrbit.to_tuple(
relativeTo=self.minTime
)
td = time - self.minTime
ansTime = DTU.timeDeltaToSeconds(td)
flatObsPos = [item for sublist in obsPos for item in sublist]
flatObsVel = [item for sublist in obsVel for item in sublist]
flatAnsPos= [0.,0.,0.]# list([0.0 for i in range(3)])
flatAnsVel= [0.,0.,0.]#list([0.0 for i in range(3)])
obsTime_C = (c_double*len(obsTime))(*obsTime)
obsPos_C = (c_double*len(flatObsPos))(*flatObsPos)
obsVel_C = (c_double*len(flatObsVel))(*flatObsVel)
ansTime_C = c_double(ansTime)
ansPos_C = (c_double*3)(*flatAnsPos)
ansVel_C = (c_double*3)(*flatAnsVel)
# Use the C wrapper to the fortran Hermite interpolator
orbitHermite.orbitHermite_C(obsPos_C,
obsVel_C,
obsTime_C,
byref(ansTime_C),
ansPos_C,
ansVel_C)
return StateVector(time, ansPos_C[:], ansVel_C[:])
def _populateFrame(self, **kwargs):
tStart = datetime.datetime.strptime(
self.metadata['Start Time of Acquisition'], "%d-%b-%Y %H:%M:%S %Z")
tStop = datetime.datetime.strptime(
self.metadata['Stop Time of Acquisition'], "%d-%b-%Y %H:%M:%S %Z")
dtMid = DTU.timeDeltaToSeconds(tStop - tStart) / 2.
tMid = tStart + datetime.timedelta(microseconds=int(dtMid * 1e6))
frame = self.frame
frame.setSensingStart(tStart)
frame.setSensingStop(tStop)
frame.setSensingMid(tMid)
frame.setNumberOfLines(int(self.metadata['slc_mag.set_rows']))
frame.setNumberOfSamples(int(self.metadata['slc_mag.set_cols']))
frame.C0 = self.metadata['slc_mag.col_addr']
frame.S0 = self.metadata['slc_mag.row_addr']
self.extractDoppler()
frame.setStartingRange(self.startingRange)
frame.platformHeight = self.platformHeight
width = frame.getNumberOfSamples()
deltaRange = frame.instrument.getRangePixelSize()
nearRange = frame.getStartingRange()
frame.setFarRange(nearRange + width * deltaRange)
frame._ellipsoid = self.elp
frame.peg = self.peg
frame.procVelocity = self.velocity
frame.terrainHeight = self.terrainHeight
frame.upperLeftCorner = Coordinate()
frame.upperLeftCorner.setLatitude(
math.degrees(self.metadata['Approximate Upper Left Latitude']))
frame.upperLeftCorner.setLongitude(
math.degrees(self.metadata['Approximate Upper Left Longitude']))
frame.upperLeftCorner.setHeight(self.terrainHeight)
frame.upperRightCorner = Coordinate()
frame.upperRightCorner.setLatitude(
math.degrees(self.metadata['Approximate Upper Right Latitude']))
frame.upperRightCorner.setLongitude(
math.degrees(self.metadata['Approximate Upper Right Longitude']))
frame.upperRightCorner.setHeight(self.terrainHeight)
frame.lowerRightCorner = Coordinate()
frame.lowerRightCorner.setLatitude(
math.degrees(self.metadata['Approximate Lower Right Latitude']))
frame.lowerRightCorner.setLongitude(
math.degrees(self.metadata['Approximate Lower Right Longitude']))
frame.lowerRightCorner.setHeight(self.terrainHeight)
frame.lowerLeftCorner = Coordinate()
frame.lowerLeftCorner.setLatitude(
math.degrees(self.metadata['Approximate Lower Left Latitude']))
frame.lowerLeftCorner.setLongitude(
math.degrees(self.metadata['Approximate Lower Left Longitude']))
frame.lowerLeftCorner.setHeight(self.terrainHeight)
def _legendreOrbitInterpolation(self,time):
"""Interpolate a state vector using an 8th order Legendre polynomial.
This method returns None if there are fewer than 9 state vectors in
the orbit.
@type time: datetime.datetime
@param time: the time at which to interpolate a state vector
@rtype: Orbit.StateVector
@return: the state vector at the desired time
"""
if len(self) < 9:
self.logger.error(
"Fewer than 9 state vectors present in orbit, cannot interpolate"
)
return None
seq = [4,5,3,6,2,7,1,8]
found = False
for ind in seq:
rind = 9 - ind
try:
newOrbit = self.selectStateVectors(time, 4, 5)
found = True
except LookupError as e:
pass
if found:
break
if not found:
raise Exception('Could not find state vectors before/after for interpolation')
obsTime, obsPos, obsVel, offset = newOrbit.to_tuple(
relativeTo=self.minTime
)
t = DTU.timeDeltaToSeconds(time-self.minTime)
t0 = DTU.timeDeltaToSeconds(newOrbit.minTime-self.minTime)
tn = DTU.timeDeltaToSeconds(newOrbit.maxTime-self.minTime)
ansPos = self._legendre8(t0, tn, t, obsPos)
ansVel = self._legendre8(t0, tn, t, obsVel)
return StateVector(time=time, position=ansPos, velocity=ansVel)
def calculateHeightDt(self):
orbit = self.orbit
ellipsoid = self.ellipsoid
startTime = self.sensingStart
midTime = self.sensingMid
sv0 = orbit.interpolate(startTime)
sv1 = orbit.interpolate(midTime)
startHeight = sv0.calculateHeight(ellipsoid)
midHeight = sv1.calculateHeight(ellipsoid)
self.spacecraftHeight = startHeight
self.heightDt = ((midHeight - startHeight) /
DTU.timeDeltaToSeconds(midTime - startTime))
def calculateHeightDt(self):
orbit = self.orbit
ellipsoid = self.ellipsoid
startTime = self.sensingStart
midTime = self.sensingMid
sv0 = orbit.interpolate(startTime)
sv1 = orbit.interpolate(midTime)
startHeight = sv0.calculateHeight(ellipsoid)
midHeight = sv1.calculateHeight(ellipsoid)
if 'uav' in self.sensor.family.lower():
self.spacecraftHeight = self.sensor.platformHeight
else:
self.spacecraftHeight = startHeight
self.heightDt = ((midHeight - startHeight) /
DTU.timeDeltaToSeconds(midTime - startTime))
def _linearOrbitInterpolation(self,time):
"""
Linearly interpolate a state vector. This method returns None if
there are fewer than 2 state vectors in the orbit.
@type time: datetime.datetime
@param time: the time at which to interpolate a state vector
@rtype: Orbit.StateVector
@return: the state vector at the desired time
"""
if len(self) < 2:
self.logger.error("Fewer than 2 state vectors present in orbit, cannot interpolate")
return None
position = [0.0 for i in range(3)]
velocity = [0.0 for i in range(3)]
newOrbit = self.selectStateVectors(time, 1, 1)
obsTime, obsPos, obsVel, offset = newOrbit.to_tuple(
relativeTo=self.minTime
)
dtime = float(DTU.timeDeltaToSeconds(time-offset))
for i in range(3):
position[i] = (obsPos[0][i] +
(obsPos[1][i]-obsPos[0][i])*
(dtime-obsTime[0])/(obsTime[1]-obsTime[0]))
velocity[i] = (obsVel[0][i] +
(obsVel[1][i]-obsVel[0][i])*
(dtime-obsTime[0])/(obsTime[1]-obsTime[0]))
"""
for sv1 in self.stateVectors:
tmp=1.0
for sv2 in self.stateVectors:
if sv1.time == sv2.time:
continue
numerator = float(DTU.timeDeltaToSeconds(sv2.time-time))
denominator = float(
DTU.timeDeltaToSeconds(sv2.time - sv1.time)
)
tmp = tmp*(numerator)/(denominator)
for i in range(3):
position[i] = position[i] + sv1.getPosition()[i]*tmp
velocity[i] = velocity[i] + sv1.getVelocity()[i]*tmp
"""
return StateVector(time=time, position=position, velocity=velocity)
def _populateFrame(self, polarization='HH', farRange=None):
frame = self._decodeSceneReferenceNumber(
self.leaderFile.sceneHeaderRecord.metadata['Scene reference number']
)
try:
first_line_utc = self.imageFile.start_time
last_line_utc = self.imageFile.stop_time
centerTime = DTUtil.timeDeltaToSeconds(
last_line_utc-first_line_utc
)/2.0
center_line_utc = first_line_utc + datetime.timedelta(
microseconds=int(centerTime*1e6)
)
self.frame.setSensingStart(first_line_utc)
self.frame.setSensingMid(center_line_utc)
self.frame.setSensingStop(last_line_utc)
rangePixelSize = self.frame.getInstrument().getRangePixelSize()
farRange = (
self.imageFile.startingRange +
self.imageFile.width*rangePixelSize
)
except TypeError as strerr:
self.logger.warning(strerr)
self.frame.frameNumber = frame
self.frame.setOrbitNumber(
self.leaderFile.sceneHeaderRecord.metadata['Orbit number']
)
self.frame.setStartingRange(self.imageFile.startingRange)
self.frame.setFarRange(farRange)
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(polarization)
self.frame.setNumberOfLines(self.imageFile.length)
self.frame.setNumberOfSamples(self.imageFile.width)
def _populateFrame(self):
#Get the Start, Mid, and Stop times
import datetime
tStart = datetime.datetime.strptime(
self.metadata['Start Time of Acquisition'], "%d-%b-%Y %H:%M:%S %Z")
tStop = datetime.datetime.strptime(
self.metadata['Stop Time of Acquisition'], "%d-%b-%Y %H:%M:%S %Z")
dtMid = DTU.timeDeltaToSeconds(tStop - tStart) / 2.
tMid = tStart + datetime.timedelta(microseconds=int(dtMid * 1e6))
frame = self.frame
frame._frameNumber = 1
frame._trackNumber = 1
frame.setSensingStart(tStart)
frame.setSensingStop(tStop)
frame.setSensingMid(tMid)
frame.setNumberOfLines(int(self.metadata['slc_1_1x1_mag.set_rows']))
frame.setNumberOfSamples(int(self.metadata['slc_1_1x1_mag.set_cols']))
frame.setPolarization(self.metadata['Polarization'])
frame.C0 = self.metadata['slc_1_1x1_mag.col_addr']
frame.S0 = self.metadata['Segment {} Data Starting Azimuth'.format(
self.segment_index)]
frame.nearLookAngle = self.metadata['Minimum Look Angle']
frame.farLookAngle = self.metadata['Maximum Look Angle']
frame.setStartingRange(self.startingRange)
frame.platformHeight = self.platformHeight
width = frame.getNumberOfSamples()
deltaRange = frame.instrument.getRangePixelSize()
nearRange = frame.getStartingRange()
midRange = nearRange + (width / 2.) * deltaRange
frame.setFarRange(nearRange + width * deltaRange)
self.extractDoppler()
frame._ellipsoid = self.elp
frame.peg = self.peg
frame.procVelocity = self.velocity
from isceobj.Location.Coordinate import Coordinate
frame.upperLeftCorner = Coordinate()
#The corner latitude, longitudes are given as a pair
#of values in degrees at each corner (without rdf unit specified)
llC = []
for ic in range(1, 5):
key = 'Segment {0} Data Approximate Corner {1}'.format(
self.segment_index, ic)
self.logger.info("key = {}".format(key))
self.logger.info("metadata[key] = {}".format(
self.metadata[key], type(self.metadata[key])))
llC.append(list(map(float, self.metadata[key].split(','))))
frame.terrainHeight = self.terrainHeight
frame.upperLeftCorner.setLatitude(llC[0][0])
frame.upperLeftCorner.setLongitude(llC[0][1])
frame.upperLeftCorner.setHeight(self.terrainHeight)
frame.upperRightCorner = Coordinate()
frame.upperRightCorner.setLatitude(llC[1][0])
frame.upperRightCorner.setLongitude(llC[1][1])
frame.upperRightCorner.setHeight(self.terrainHeight)
frame.lowerRightCorner = Coordinate()
frame.lowerRightCorner.setLatitude(llC[2][0])
frame.lowerRightCorner.setLongitude(llC[2][1])
frame.lowerRightCorner.setHeight(self.terrainHeight)
frame.lowerLeftCorner = Coordinate()
frame.lowerLeftCorner.setLatitude(llC[3][0])
frame.lowerLeftCorner.setLongitude(llC[3][1])
frame.lowerLeftCorner.setHeight(self.terrainHeight)
frame.nearLookAngle = math.degrees(self.metadata['Minimum Look Angle'])
frame.farLookAngle = math.degrees(self.metadata['Maximum Look Angle'])
return
def _populateFrameFromPair(self, sip1):
# print("UAVSAR_RPI._populateFrameFromPair: metadatafile = ",
# self.metadataFile)
#Get the Start, Mid, and Stop times
import datetime
tStart = datetime.datetime.strptime(
self.metadata['Start Time of Acquisition for Pass ' + sip1],
"%d-%b-%Y %H:%M:%S %Z")
tStop = datetime.datetime.strptime(
self.metadata['Stop Time of Acquisition for Pass ' + sip1],
"%d-%b-%Y %H:%M:%S %Z")
dtMid = DTU.timeDeltaToSeconds(tStop - tStart) / 2.
# print("dtMid = ", dtMid)
tMid = tStart + datetime.timedelta(microseconds=int(dtMid * 1e6))
# print("tStart = ", tStart)
# print("tMid = ", tMid)
# print("tStop = ", tStop)
frame = self.frame
frame.setSensingStart(tStart)
frame.setSensingStop(tStop)
frame.setSensingMid(tMid)
frame.setNumberOfLines(
int(self.metadata['Single Look Complex Data Azimuth Lines']))
frame.setNumberOfSamples(
int(self.metadata['Single Look Complex Data Range Samples']))
frame.setPolarization(self.metadata['Polarization'])
frame.C0 = self.metadata['Single Look Complex Data at Near Range']
frame.S0 = self.metadata['Single Look Complex Data Starting Azimuth']
frame.nearLookAngle = self.metadata['Average Look Angle in Near Range']
frame.farLookAngle = self.metadata['Average Look Angle in Far Range']
# print("frame.nearLookAngle = ", math.degrees(frame.nearLookAngle))
# frame.setStartingAzimuth(frame.S0)
self.extractDoppler()
frame.setStartingRange(self.startingRange)
frame.platformHeight = self.platformHeight
# print("platformHeight, startingRange = ", self.platformHeight, frame.getStartingRange())
width = frame.getNumberOfSamples()
deltaRange = frame.instrument.getRangePixelSize()
nearRange = frame.getStartingRange()
midRange = nearRange + (width / 2.) * deltaRange
frame.setFarRange(nearRange + width * deltaRange)
frame.peg = self.peg
# print("frame.peg = ", frame.peg)
frame.procVelocity = self.velocity
# print("frame.procVelocity = ", frame.procVelocity)
from isceobj.Location.Coordinate import Coordinate
frame.terrainHeight = self.terrainHeight
frame.upperLeftCorner = Coordinate()
frame.upperLeftCorner.setLatitude(
math.degrees(self.metadata['Approximate Upper Left Latitude']))
frame.upperLeftCorner.setLongitude(
math.degrees(self.metadata['Approximate Upper Left Longitude']))
frame.upperLeftCorner.setHeight(self.terrainHeight)
frame.upperRightCorner = Coordinate()
frame.upperRightCorner.setLatitude(
math.degrees(self.metadata['Approximate Upper Right Latitude']))
frame.upperRightCorner.setLongitude(
math.degrees(self.metadata['Approximate Upper Right Longitude']))
frame.upperRightCorner.setHeight(self.terrainHeight)
frame.lowerRightCorner = Coordinate()
frame.lowerRightCorner.setLatitude(
math.degrees(self.metadata['Approximate Lower Right Latitude']))
frame.lowerRightCorner.setLongitude(
math.degrees(self.metadata['Approximate Lower Right Longitude']))
frame.lowerRightCorner.setHeight(self.terrainHeight)
frame.lowerLeftCorner = Coordinate()
frame.lowerLeftCorner.setLatitude(
math.degrees(self.metadata['Approximate Lower Left Latitude']))
frame.lowerLeftCorner.setLongitude(
math.degrees(self.metadata['Approximate Lower Left Longitude']))
frame.lowerLeftCorner.setHeight(self.terrainHeight)
frame.nearLookAngle = math.degrees(
self.metadata['Average Look Angle in Near Range'])
frame.farLookAngle = math.degrees(
self.metadata['Average Look Angle in Far Range'])
return
