def run(frame, catalog=None, sceneid='NO_ID'):
"""
Interpolate orbit.
"""
logger.info("Pulse Timing: %s" % sceneid)
numberOfLines = frame.getNumberOfLines()
prf = frame.getInstrument().getPulseRepetitionFrequency()
pri = 1.0 / prf
startTime = frame.getSensingStart()
orbit = frame.getOrbit()
pulseOrbit = Orbit()
startTimeUTC0 = (
startTime -
datetime.datetime(startTime.year, startTime.month, startTime.day))
timeVec = [
pri * i + startTimeUTC0.seconds + 10**-6 * startTimeUTC0.microseconds
for i in range(numberOfLines)
]
if catalog is not None:
catalog.addItem("timeVector", timeVec, "runPulseTiming.%s" % sceneid)
for i in range(numberOfLines):
dt = i * pri
time = startTime + datetime.timedelta(seconds=dt)
sv = orbit.interpolateOrbit(time, method='hermite')
pulseOrbit.addStateVector(sv)
shift = timeVec[0] * prf
return pulseOrbit, shift
def __init__(self, file=None):
self.filename = file
self.firstEpoch = 0
self.lastEpoch = 0
self.orbit = Orbit()
self.orbit.configure()
self.orbit.setOrbitSource('PDS')
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 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 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 __init__(self, fileName=None):
BaseEnvisatFile.__init__(self)
self.fileName = fileName
self.fp = None
self.orbit = Orbit()
self.orbit.setOrbitSource('DORIS')
self.orbit.setReferenceFrame('ECR')
def computePeg(self):
shortOrb = Orbit()
for i in range(-10, 10):
time = self.tMid + datetime.timedelta(
seconds=(old_div(i, self.prf)))
sv = self.orbVec.interpolateOrbit(time, method='hermite')
shortOrb.addStateVector(sv)
objPeg = stdproc.createGetpeg()
objPeg.wireInputPort(name='planet', object=self.planet)
objPeg.wireInputPort(name='Orbit', object=shortOrb)
stdWriter = create_writer("log", "", True, filename="orbitInfo.log")
stdWriter.setFileTag("getpeg", "log")
stdWriter.setFileTag("getpeg", "err")
stdWriter.setFileTag("getpeg", "log")
objPeg.setStdWriter(stdWriter)
objPeg.estimatePeg()
self.peg = objPeg.getPeg()
self.rds = objPeg.getPegRadiusOfCurvature()
self.hgt = objPeg.getAverageHeight()
return
def get_orbit():
from isceobj.Orbit.Orbit import Orbit
"""Return orbit object."""
orb = Orbit()
orb.configure()
return orb
def __init__(self, file=None):
self.filename = file
self.firstEpoch = 0
self.lastEpoch = 0
self.tdtOffset = 0
self.orbit = Orbit()
self.orbit.setOrbitQuality('Precise')
self.orbit.setOrbitSource('PRC')
return None
class DOR(BaseEnvisatFile):
"""A class for parsing Envisat DORIS orbit files"""
def __init__(self,fileName=None):
BaseEnvisatFile.__init__(self)
self.fileName = fileName
self.fp = None
self.orbit = Orbit()
self.orbit.setOrbitSource('DORIS')
self.orbit.setReferenceFrame('ECR')
def parse(self):
orbitDict = {}
try:
self.fp = open(self.fileName, 'rb')
except IOError as errs:
errno,strerr = errs
print("IOError: %s" % strerr)
return
self.readMPH()
self.readSPH()
self.readStateVectors()
self.fp.close()
if (self.sph['dataSets'][0]['DS_NAME'] == 'DORIS PRELIMINARY ORBIT'):
self.orbit.setOrbitQuality('Preliminary')
elif (self.sph['dataSets'][0]['DS_NAME'] == 'DORIS PRECISE ORBIT'):
self.orbit.setOrbitQuality('Precise')
orbitDict.update(self.mph)
orbitDict.update(self.sph)
return orbitDict
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 _parseDateTime(self,dtString):
dateTime = datetime.datetime.strptime(dtString,'%d-%b-%Y %H:%M:%S.%f')
return dateTime
def formslc(self):
for item in self.inputPorts:
item()
self.computeRangeParams()
try:
self.rawImage.setCaster('read','CFLOAT')
self.rawImage.setExtraInfo()
self.rawImage.createImage()
self.rawAccessor = self.rawImage.getImagePointer()
self.slcAccessor = self.slcImage.getImagePointer()
except AttributeError:
self.logger.error("Error in accessing image pointers")
raise AttributeError
self.computePatchParams()
self.allocateArrays()
self.setState()
###New changes
cOrbit = self.inOrbit.exportToC()
formslc.setOrbit_Py(cOrbit)
formslc.setSensingStart_Py(
DTU.seconds_since_midnight(self.sensingStart)
)
####Create an empty/dummy orbit of same length as input orbit
mOrbit = copy.copy(self.inOrbit).exportToC()
formslc.setMocompOrbit_Py(mOrbit)
formslc.formslc_Py(self.rawAccessor, self.slcAccessor)
###Freeing Orbit
combinedlibmodule.freeCOrbit(cOrbit)
self.outOrbit = Orbit()
self.outOrbit.configure()
self.outOrbit.importFromC(mOrbit,
datetime.datetime.combine(self.sensingStart.date(),
datetime.time(0)
)
)
combinedlibmodule.freeCOrbit(mOrbit)
#the size of this vectors where unknown until the end of the run
posSize = formslc.getMocompPositionSize_Py()
self.dim1_mocompPosition = 2
self.dim2_mocompPosition = posSize
self.dim1_mocompIndx = posSize
self.getState()
self.deallocateArrays()
self.slcImage.finalizeImage()
self.slcImage.renderHdr()
return self.slcImage
def trimOrbit(self, startTime, stopTime):
"""Trim the list of state vectors to encompass the time span [startTime:stopTime]"""
newOrbit = Orbit()
newOrbit.configure()
newOrbit.setOrbitSource('ODR')
newOrbit.setReferenceFrame('ECR')
for sv in self._ephemeris:
if ((sv.getTime() > startTime) and (sv.getTime() < stopTime)):
newOrbit.addStateVector(sv)
return newOrbit
def createOrbit(self):
orbitAll = Orbit()
for i in range(len(self._frames)):
orbit = self._frames[i].getOrbit()
#remember that everything is by reference, so the changes applied to orbitAll will be made to the Orbit
#object in self.frame
for sv in orbit._stateVectors:
orbitAll.addStateVector(sv)
# sort the orbit state vecotrs according to time
orbitAll._stateVectors.sort(key=lambda sv: sv.time)
self.removeDuplicateVectors(orbitAll._stateVectors)
self._frame.setOrbit(orbitAll)
def mocomptsx(self):
for port in self.inputPorts:
port()
try:
self.inAccessor = self.slcInImage.getImagePointer()
except AttributeError:
self.logger.error("Error in accessing image pointers")
raise AttributeError("Error in accessing image pointers")
if self.stdWriter is None:
self.createStdWriter()
self.createOutSlcImage()
self.outAccessor = self.slcOutImage.getImagePointer()
self.allocateArrays()
self.setState()
###New changes
cOrbit = self.inOrbit.exportToC()
mocompTSX.setOrbit_Py(cOrbit)
mocompTSX.setSensingStart_Py(
DTU.seconds_since_midnight(self.sensingStart)
)
####Create an empty/dummy orbit of same length as input orbit
mOrbit = copy.copy(self.inOrbit).exportToC()
mocompTSX.setMocompOrbit_Py(mOrbit)
mocompTSX.mocompTSX_Py(self.inAccessor, self.outAccessor)
###Freeing Orbit
combinedlibmodule.freeCOrbit(cOrbit)
self.outOrbit = Orbit()
self.outOrbit.configure()
self.outOrbit.importFromC(mOrbit,
datetime.datetime.combine(self.sensingStart.date(),
datetime.time(0)
)
)
combinedlibmodule.freeCOrbit(mOrbit)
self.mocompPositionSize = mocompTSX.getMocompPositionSize_Py()
self.dim1_mocompPosition = 2
self.dim2_mocompPosition = self.mocompPositionSize
self.dim1_mocompIndex = self.mocompPositionSize
self.getState()
self.deallocateArrays()
self.slcOutImage.finalizeImage()
self.slcOutImage.renderHdr()
return self.slcOutImage
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 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
class Pulsetiming(Component):
logging_name = "isce.stdproc.pulsetiming"
def __init__(self):
super(Pulsetiming, self).__init__()
self.frame = None
self.orbit = Orbit(source='Pulsetiming')
return None
def createPorts(self):
framePort = Port(name='frame',method=self.addFrame)
self._inputPorts.add(framePort)
return None
def getOrbit(self):
return self.orbit
def addFrame(self):
frame = self.inputPorts['frame']
if frame:
if isinstance(frame, Frame):
self.frame = frame
else:
self.logger.error(
"Object must be of type Frame, not %s" % (frame.__class__)
)
raise TypeError
pass
return None
# @port(Frame)
# def addFrame(self):
# return None
def pulsetiming(self):
self.activateInputPorts()
numberOfLines = self.frame.getNumberOfLines()
prf = self.frame.getInstrument().getPulseRepetitionFrequency()
pri = 1.0/prf
startTime = self.frame.getSensingStart()
thisOrbit = self.frame.getOrbit()
self.orbit.setReferenceFrame(thisOrbit.getReferenceFrame())
for i in range(numberOfLines):
dt = i*pri
time = startTime + datetime.timedelta(seconds=dt)
sv = thisOrbit.interpolateOrbit(time,method='hermite')
self.orbit.addStateVector(sv)
def __init__(self, file=None):
self._file = file
self._format = None
self._satellite = None
self._arcNumber = None
self._cycleLength = None
self._numberOfRecords = None
self._version = None
self._ephemeris = Orbit()
self._ephemeris.setOrbitSource('ODR')
self._ephemeris.setReferenceFrame('ECR')
self.grs80 = Ellipsoid.Ellipsoid(
*AstronomicalHandbook.PlanetsData.ellipsoid['Earth']['GRS-80'])
return None
def extractPreciseOrbit(sentinel1, margin=60.0):
'''
Extract precise orbit from given Orbit file.
'''
try:
try:
fp = open(sentinel1.orbitFile, 'r')
except IOError as strerr:
print("IOError: %s" % strerr)
traceback.print_exc()
return False
_xml_root = ET.ElementTree(file=fp).getroot()
node = _xml_root.find('Data_Block/List_of_OSVs')
print('Extracting orbit from Orbit File: ', sentinel1.orbitFile)
orb = Orbit()
orb.configure()
margin = datetime.timedelta(seconds=margin)
print("sentinel1.product.bursts : %s" % sentinel1.product.bursts)
tstart = sentinel1.product.bursts[0].sensingStart - margin
tend = sentinel1.product.bursts[-1].sensingStop + margin
for child in node.getchildren():
timestamp = sentinel1.convertToDateTime(child.find('UTC').text[4:])
if (timestamp >= tstart) and (timestamp < tend):
###Warn if state vector quality is not nominal
quality = child.find('Quality').text.strip()
if quality != 'NOMINAL':
print(
'WARNING: State Vector at time {0} tagged as {1} in orbit file {2}'
.format(timestamp, quality, sentinel1.orbitFile))
print("Excluding the date data")
return False
except Exception as err:
print("extractPreciseOrbit Error : %s" % str(err))
traceback.print_exc()
return False
return True
def unpackOrbitVectors(self, orb):
self.orbVec = Orbit(source='json', quality='good')
self.orbVec._referenceFrame = 'WGS-84'
relTims = orb[0]
satPos = orb[1]
satVel = orb[2]
refTime = orb[3]
for kk in range(len(satPos)):
vecTime = refTime + datetime.timedelta(seconds=relTims[kk])
tempVec = StateVector(time=vecTime,
position=satPos[kk],
velocity=satVel[kk])
self.orbVec.addStateVector(tempVec)
stateVec = self.orbVec.interpolateOrbit(self.tMid, 'hermite')
self.pos = stateVec.getPosition()
self.vel = stateVec.getVelocity()
return
def loadHdrAsOrbit(fname, date=None):
'''Read a hdr file and convert to ISCE orbit'''
from isceobj.Orbit.Orbit import Orbit, StateVector
if date is None:
date = datetime.datetime.now().date()
t0 = datetime.datetime(year=date.year, month=date.month, day=date.day)
orb = Orbit()
inData = np.loadtxt(fname)
for line in inData:
time = t0 + datetime.timedelta(seconds=line[0])
sv = StateVector()
sv.setTime(time)
sv.setPosition(line[1:4].tolist())
sv.setVelocity(line[4:7].tolist())
orb.addStateVector(sv)
print(sv)
return orb
def getPeg(self):
shortOrb = Orbit()
for i in range(-10, 10):
time = self.dt + datetime.timedelta(seconds=(i / self.prf))
sv = self.orbit.interpolateOrbit(time, method='hermite')
shortOrb.addStateVector(sv)
objPeg = stdproc.createGetpeg()
objPeg.wireInputPort(name='planet', object=self.planet)
objPeg.wireInputPort(name='Orbit', object=shortOrb)
stdWriter.setFileTag("getpeg", "log")
stdWriter.setFileTag("getpeg", "err")
stdWriter.setFileTag("getpeg", "out")
objPeg.setStdWriter(stdWriter)
objPeg.estimatePeg()
self.peg = objPeg.getPeg()
self.hgt = objPeg.getAverageHeight()
self.rds = self.peg.getRadiusOfCurvature()
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 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 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 pulseTiming(frame, catalog, which):
logger.info("Pulse Timing")
numberOfLines = frame.getNumberOfLines()
prf = frame.getInstrument().getPulseRepetitionFrequency()
pri = 1.0 / prf
startTime = frame.getSensingStart()
orbit = frame.getOrbit()
pulseOrbit = Orbit(name=which + 'orbit')
startTimeUTC0 = (
startTime -
datetime.datetime(startTime.year, startTime.month, startTime.day))
timeVec = [
pri * i + startTimeUTC0.seconds + 10**-6 * startTimeUTC0.microseconds
for i in range(numberOfLines)
]
catalog.addItem("timeVector", timeVec, "runPulseTiming.%s" % which)
for i in range(numberOfLines):
dt = i * pri
time = startTime + datetime.timedelta(seconds=dt)
sv = orbit.interpolateOrbit(time, method='hermite')
pulseOrbit.addStateVector(sv)
return pulseOrbit
def pulseTiming(frame):
#From runPulseTiming() in InsarProc
numberOfLines = frame.getNumberOfLines()
prf = frame.getInstrument().getPulseRepetitionFrequency()
pri = 1.0 / prf
startTime = frame.getSensingStart()
orbit = frame.getOrbit()
pulseOrbit = Orbit()
startTimeUTC0 = (
startTime -
datetime.datetime(startTime.year, startTime.month, startTime.day))
timeVec = [
pri * i + startTimeUTC0.seconds + 10**-6 * startTimeUTC0.microseconds
for i in xrange(numberOfLines)
]
for i in range(numberOfLines):
dt = i * pri
time = startTime + datetime.timedelta(seconds=dt)
sv = orbit.interpolateOrbit(time, method='hermite')
pulseOrbit.addStateVector(sv)
return pulseOrbit
def getMergedOrbit(product):
from isceobj.Orbit.Orbit import Orbit
###Create merged orbit
orb = Orbit()
orb.configure()
#Add first orbit to begin with
for sv in product.orbit:
orb.addStateVector(sv)
return orb
def getMergedOrbit(product):
import isce
from isceobj.Orbit.Orbit import Orbit
###Create merged orbit
orb = Orbit()
orb.configure()
burst = product[0].bursts[0]
#Add first burst orbit to begin with
for sv in burst.orbit:
orb.addStateVector(sv)
for pp in product:
##Add all state vectors
for bb in pp.bursts:
for sv in bb.orbit:
if (sv.time < orb.minTime) or (sv.time > orb.maxTime):
orb.addStateVector(sv)
return orb
