class Risat1_SLC(Sensor):
"""
Code to read CEOSFormat leader files for Risat-1 SAR data.
"""
family = "risat1"
logging_name = 'isce.sensor.Risat1'
parameter_list = (IMAGEFILE, LEADERFILE, METAFILE,
DATATYPE) + Sensor.parameter_list
@logged
def __init__(self, name=''):
super().__init__(family=self.__class__.family, name=name)
self.imageFile = None
self.leaderFile = None
#####Specific doppler functions for RISAT1
self.doppler_coeff = None
self.azfmrate_coeff = None
self.lineDirection = None
self.pixelDirection = None
self.frame = Frame()
self.frame.configure()
self.constants = {
'antennaLength': 6,
}
self.TxPolMap = {
1: 'V',
2: 'H',
3: 'L',
4: 'R',
}
self.RxPolMap = {
1: 'V',
2: 'H',
}
def getFrame(self):
return self.frame
def parse(self):
self.leaderFile = LeaderFile(self, file=self._leaderFile)
self.leaderFile.parse()
self.imageFile = ImageFile(self, file=self._imageFile)
self.imageFile.parse()
self.populateMetadata()
def populateMetadata(self):
"""
Create the appropriate metadata objects from our CEOSFormat metadata
"""
frame = self._decodeSceneReferenceNumber(
self.leaderFile.sceneHeaderRecord.
metadata['Scene reference number'])
try:
rangePixelSize = Const.c / (2 * self.leaderFile.sceneHeaderRecord.
metadata['Range sampling rate'])
except ZeroDivisionError:
rangePixelSize = 0
print(
'Average terrain height: ', 1000 * self.leaderFile.
sceneHeaderRecord.metadata['Average terrain height in km'])
ins = self.frame.getInstrument()
platform = ins.getPlatform()
platform.setMission(self.leaderFile.sceneHeaderRecord.
metadata['Sensor platform mission identifier'])
platform.setAntennaLength(self.constants['antennaLength'])
platform.setPlanet(Planet(pname='Earth'))
ins.setRadarWavelength(
self.leaderFile.sceneHeaderRecord.metadata['Radar wavelength'])
ins.setIncidenceAngle(self.leaderFile.sceneHeaderRecord.
metadata['Incidence angle at scene centre'])
self.frame.getInstrument().setPulseRepetitionFrequency(
self.leaderFile.sceneHeaderRecord.
metadata['Pulse Repetition Frequency'])
ins.setRangePixelSize(rangePixelSize)
ins.setRangeSamplingRate(
self.leaderFile.sceneHeaderRecord.metadata['Range sampling rate'])
ins.setPulseLength(
self.leaderFile.sceneHeaderRecord.metadata['Range pulse length'])
chirpPulseBandwidth = self.leaderFile.processingRecord.metadata[
'Pulse bandwidth code'] * 1e4
ins.setChirpSlope(
chirpPulseBandwidth /
self.leaderFile.sceneHeaderRecord.metadata['Range pulse length'])
ins.setInPhaseValue(0.0)
ins.setQuadratureValue(0.0)
self.lineDirection = self.leaderFile.sceneHeaderRecord.metadata[
'Time direction indicator along line direction'].strip()
self.pixelDirection = self.leaderFile.sceneHeaderRecord.metadata[
'Time direction indicator along pixel direction'].strip()
######RISAT-1 sensor orientation convention is opposite to ours
lookSide = self.leaderFile.processingRecord.metadata[
'Sensor orientation']
if lookSide == 'RIGHT':
platform.setPointingDirection(1)
elif lookSide == 'LEFT':
platform.setPointingDirection(-1)
else:
raise Exception('Unknown look side')
print('Leader file look side: ', lookSide)
self.frame.setFrameNumber(frame)
self.frame.setOrbitNumber(
self.leaderFile.sceneHeaderRecord.metadata['Orbit number'])
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.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')
self.frame.getOrbit().setOrbitQuality(
self.leaderFile.platformPositionRecord.
metadata['Orbital elements designator'])
t0 = datetime.datetime(year=2000 +
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()
deltaT = self.leaderFile.platformPositionRecord.metadata[
'Time interval between DATA points']
numPts = self.leaderFile.platformPositionRecord.metadata[
'Number of data points']
for i in range(numPts):
vec = StateVector()
t = t0 + datetime.timedelta(seconds=i * deltaT)
vec.setTime(t)
dataPoints = self.leaderFile.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)
#####Convert orbits from ECI to ECR frame
t0 = orb._stateVectors[0]._time
ang = self.leaderFile.platformPositionRecord.metadata[
'Greenwich mean hour angle']
cOrb = ECI2ECR(orb, GAST=ang, epoch=t0)
iOrb = cOrb.convert()
#####Extend the orbits by a few points
#####Expect large azimuth shifts - absolutely needed
#####Since CEOS contains state vectors that barely covers scene extent
planet = self.frame.instrument.platform.planet
orbExt = OrbitExtender()
orbExt.configure()
orbExt._newPoints = 4
newOrb = orbExt.extendOrbit(iOrb)
orb = self.frame.getOrbit()
for sv in newOrb:
orb.addStateVector(sv)
self.doppler_coeff = [
self.leaderFile.sceneHeaderRecord.
metadata['Cross track Doppler frequency centroid constant term'],
self.leaderFile.sceneHeaderRecord.
metadata['Cross track Doppler frequency centroid linear term'],
self.leaderFile.sceneHeaderRecord.
metadata['Cross track Doppler frequency centroid quadratic term']
]
self.azfmrate_coeff = [
self.leaderFile.sceneHeaderRecord.
metadata['Cross track Doppler frequency rate constant term'],
self.leaderFile.sceneHeaderRecord.
metadata['Cross track Doppler frequency rate linear term'],
self.leaderFile.sceneHeaderRecord.
metadata['Cross track Doppler frequency rate quadratic term']
]
def extractImage(self):
import isceobj
if (self.imageFile is None) or (self.leaderFile is None):
self.parse()
try:
out = open(self.output, 'wb')
except IOError as strerr:
self.logger.error("IOError: %s" % strerr)
self.imageFile.extractImage(output=out, dtype=self._dataType)
out.close()
self.frame.setSensingStart(self.imageFile.sensingStart)
self.frame.setSensingStop(self.imageFile.sensingStop)
sensingMid = self.imageFile.sensingStart + datetime.timedelta(
seconds=0.5 * (self.imageFile.sensingStop -
self.imageFile.sensingStart).total_seconds())
self.frame.setSensingMid(sensingMid)
self.frame.setStartingRange(self.imageFile.nearRange)
self.frame.setFarRange(self.imageFile.farRange)
# self.doppler_coeff = self.imageFile.dopplerCoeff
self.frame.getInstrument().setPulseRepetitionFrequency(
self.imageFile.prf)
pol = self.TxPolMap[int(
self.imageFile.polarization[0])] + self.TxPolMap[int(
self.imageFile.polarization[1])]
self.frame.setPolarization(pol)
rawImage = isceobj.createSlcImage()
rawImage.setByteOrder('l')
rawImage.setAccessMode('read')
rawImage.setFilename(self.output)
rawImage.setWidth(self.imageFile.width)
rawImage.setXmin(0)
rawImage.setXmax(self.imageFile.width)
rawImage.renderHdr()
self.frame.setImage(rawImage)
return
def extractDoppler(self):
'''
Evaluate the doppler polynomial and return the average value for now.
'''
####For insarApp
quadratic = {}
quadratic['a'] = self.doppler_coeff[0] / self.frame.getInstrument(
).getPulseRepetitionFrequency()
quadratic['b'] = 0.
quadratic['c'] = 0.
###For roiApp
###More accurate
self.frame._dopplerVsPixel = self.doppler_coeff
return quadratic
def _decodeSceneReferenceNumber(self, referenceNumber):
return referenceNumber
class ALOS2(Sensor):
"""
Code to read CEOSFormat leader files for ALOS2 SLC data.
"""
family = 'alos2'
parameter_list = (WAVELENGTH, LEADERFILE,
IMAGEFILE) + Sensor.parameter_list
fsampConst = {
104: 1.047915957140240E+08,
52: 5.239579785701190E+07,
34: 3.493053190467460E+07,
17: 1.746526595233730E+07
}
#Orbital Elements (Quality) Designator
#ALOS-2/PALSAR-2 Level 1.1/1.5/2.1/3.1 CEOS SAR Product Format Description
#PALSAR-2_xx_Format_CEOS_E_r.pdf
orbitElementsDesignator = {
'0': 'preliminary',
'1': 'decision',
'2': 'high precision'
}
def __init__(self, name=''):
super().__init__(family=self.__class__.family, name=name)
self.leaderFile = None
self.imageFile = None
#####Soecific doppler functions for ALOS2
self.doppler_coeff = None
self.azfmrate_coeff = None
self.lineDirection = None
self.pixelDirection = None
self.frame = Frame()
self.frame.configure()
self.constants = {'polarization': 'HH', 'antennaLength': 10}
def getFrame(self):
return self.frame
def parse(self):
self.leaderFile = LeaderFile(self, file=self._leaderFile)
self.leaderFile.parse()
self.imageFile = ImageFile(self, file=self._imageFile)
self.imageFile.parse()
self.populateMetadata()
def populateMetadata(self):
"""
Create the appropriate metadata objects from our CEOSFormat metadata
"""
frame = self._decodeSceneReferenceNumber(
self.leaderFile.sceneHeaderRecord.
metadata['Scene reference number'])
fsamplookup = int(self.leaderFile.sceneHeaderRecord.
metadata['Range sampling rate in MHz'])
rangePixelSize = Const.c / (2 * self.fsampConst[fsamplookup])
ins = self.frame.getInstrument()
platform = ins.getPlatform()
platform.setMission(self.leaderFile.sceneHeaderRecord.
metadata['Sensor platform mission identifier'])
platform.setAntennaLength(self.constants['antennaLength'])
platform.setPointingDirection(1)
platform.setPlanet(Planet(pname='Earth'))
if self.wavelength:
ins.setRadarWavelength(float(self.wavelength))
# print('ins.radarWavelength = ', ins.getRadarWavelength(),
# type(ins.getRadarWavelength()))
else:
ins.setRadarWavelength(
self.leaderFile.sceneHeaderRecord.metadata['Radar wavelength'])
ins.setIncidenceAngle(self.leaderFile.sceneHeaderRecord.
metadata['Incidence angle at scene centre'])
self.frame.getInstrument().setPulseRepetitionFrequency(
self.leaderFile.sceneHeaderRecord.
metadata['Pulse Repetition Frequency in mHz'] * 1.0e-3)
ins.setRangePixelSize(rangePixelSize)
ins.setRangeSamplingRate(self.fsampConst[fsamplookup])
ins.setPulseLength(self.leaderFile.sceneHeaderRecord.
metadata['Range pulse length in microsec'] * 1.0e-6)
chirpSlope = self.leaderFile.sceneHeaderRecord.metadata[
'Nominal range pulse (chirp) amplitude coefficient linear term']
chirpPulseBandwidth = abs(
chirpSlope * self.leaderFile.sceneHeaderRecord.
metadata['Range pulse length in microsec'] * 1.0e-6)
ins.setChirpSlope(chirpSlope)
ins.setInPhaseValue(7.5)
ins.setQuadratureValue(7.5)
self.lineDirection = self.leaderFile.sceneHeaderRecord.metadata[
'Time direction indicator along line direction'].strip()
self.pixelDirection = self.leaderFile.sceneHeaderRecord.metadata[
'Time direction indicator along pixel direction'].strip()
######ALOS2 includes this information in clock angle
clockAngle = self.leaderFile.sceneHeaderRecord.metadata[
'Sensor clock angle']
if clockAngle == 90.0:
platform.setPointingDirection(-1)
elif clockAngle == -90.0:
platform.setPointingDirection(1)
else:
raise Exception(
'Unknown look side. Clock Angle = {0}'.format(clockAngle))
# print(self.leaderFile.sceneHeaderRecord.metadata["Sensor ID and mode of operation for this channel"])
self.frame.setFrameNumber(frame)
self.frame.setOrbitNumber(
self.leaderFile.sceneHeaderRecord.metadata['Orbit number'])
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(self.constants['polarization'])
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'])
######
orb = self.frame.getOrbit()
orb.setOrbitSource('Header')
orb.setOrbitQuality(self.orbitElementsDesignator[
self.leaderFile.platformPositionRecord.
metadata['Orbital elements designator']])
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
deltaT = self.leaderFile.platformPositionRecord.metadata[
'Time interval between data points']
numPts = self.leaderFile.platformPositionRecord.metadata[
'Number of data points']
orb = self.frame.getOrbit()
for i in range(numPts):
vec = StateVector()
t = t0 + datetime.timedelta(seconds=i * deltaT)
vec.setTime(t)
dataPoints = self.leaderFile.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)
self.doppler_coeff = [
self.leaderFile.sceneHeaderRecord.
metadata['Cross track Doppler frequency centroid constant term'],
self.leaderFile.sceneHeaderRecord.
metadata['Cross track Doppler frequency centroid linear term'],
self.leaderFile.sceneHeaderRecord.
metadata['Cross track Doppler frequency centroid quadratic term']
]
self.azfmrate_coeff = [
self.leaderFile.sceneHeaderRecord.
metadata['Cross track Doppler frequency rate constant term'],
self.leaderFile.sceneHeaderRecord.
metadata['Cross track Doppler frequency rate linear term'],
self.leaderFile.sceneHeaderRecord.
metadata['Cross track Doppler frequency rate quadratic term']
]
# print('Terrain height: ', self.leaderFile.sceneHeaderRecord.metadata['Average terrain ellipsoid height'])
def extractImage(self):
import isceobj
if (self.imageFile is None) or (self.leaderFile is None):
self.parse()
try:
out = open(self.output, 'wb')
except IOError as strerr:
self.logger.error("IOError: %s" % strerr)
self.imageFile.extractImage(output=out)
out.close()
# rangeGate = self.leaderFile.sceneHeaderRecord.metadata['Range gate delay in microsec']*1e-6
# delt = datetime.timedelta(seconds=rangeGate)
delt = datetime.timedelta(seconds=0.0)
self.frame.setSensingStart(self.imageFile.sensingStart + delt)
self.frame.setSensingStop(self.imageFile.sensingStop + delt)
sensingMid = self.imageFile.sensingStart + datetime.timedelta(
seconds=0.5 * (self.imageFile.sensingStop -
self.imageFile.sensingStart).total_seconds()) + delt
self.frame.setSensingMid(sensingMid)
self.frame.setStartingRange(self.imageFile.nearRange)
self.frame.getInstrument().setPulseRepetitionFrequency(
self.imageFile.prf)
pixelSize = self.frame.getInstrument().getRangePixelSize()
farRange = self.imageFile.nearRange + (pixelSize -
1) * self.imageFile.width
self.frame.setFarRange(farRange)
rawImage = isceobj.createSlcImage()
rawImage.setByteOrder('l')
rawImage.setAccessMode('read')
rawImage.setFilename(self.output)
rawImage.setWidth(self.imageFile.width)
rawImage.setXmin(0)
rawImage.setXmax(self.imageFile.width)
rawImage.renderHdr()
self.frame.setImage(rawImage)
return
def extractDoppler(self):
'''
Evaluate the doppler polynomial and return the average value for now.
'''
midwidth = self.frame.getNumberOfSamples() / 2.0
dop = 0.0
prod = 1.0
for ind, kk in enumerate(self.doppler_coeff):
dop += kk * prod
prod *= midwidth
print('Average Doppler: {0}'.format(dop))
####For insarApp
quadratic = {}
quadratic['a'] = dop / self.frame.getInstrument(
).getPulseRepetitionFrequency()
quadratic['b'] = 0.
quadratic['c'] = 0.
####For roiApp
####More accurate
####CEOS already provides function vs pixel
self.frame._dopplerVsPixel = self.doppler_coeff
return quadratic
def _decodeSceneReferenceNumber(self, referenceNumber):
return referenceNumber
class ERS(Component):
#Parsers.CEOS.CEOSFormat.ceosTypes['text'] =
# {'typeCode': 63, 'subtypeCode': [18,18,18]}
#Parsers.CEOS.CEOSFormat.ceosTypes['leaderFile'] =
# {'typeCode': 192, 'subtypeCode': [63,18,18]}
#Parsers.CEOS.CEOSFormat.ceosTypes['dataSetSummary'] =
# {'typeCode': 10, 'subtypeCode': [10,31,20]}
#Parsers.CEOS.CEOSFormat.ceosTypes['platformPositionData'] =
# {'typeCode': 30, 'subtypeCode': [10,31,20]}
#Parsers.CEOS.CEOSFormat.ceosTypes['facilityData'] =
# {'typeCode': 200, 'subtypeCode': [10,31,50]}
#Parsers.CEOS.CEOSFormat.ceosTypes['datafileDescriptor'] =
# {'typeCode': 192, 'subtypeCode':[63,18,18]}
#Parsers.CEOS.CEOSFormat.ceosTypes['signalData'] =
# {'typeCode': 10, 'subtypeCode': [50,31,20]}
#Parsers.CEOS.CEOSFormat.ceosTypes['nullFileDescriptor'] =
# {'typeCode': 192, 'subtypeCode': [192,63,18]}
logging_name = 'isce.sensor.ers'
def __init__(self):
Component.__init__(self)
self._leaderFile = None
self._imageFileList = ''
self._leaderFileList = ''
self._imageFile = None
self._orbitDir = None # Use this for Delft Orbit files
self._orbitFile = None # Use this for PDS Orbit files for now
self._orbitType = None
self.frameList = []
self.output = None
self.descriptionOfVariables = {}
self.dictionaryOfVariables = {
'ORBIT_TYPE': ['self._orbitType','str','mandatory'],
'ORBIT_DIRECTORY': ['self._orbitDir','str','optional'],
'ORBIT_FILE': ['self._orbitFile','str','optional'],
'LEADERFILE': ['self._leaderFileList','str','mandatory'],
'IMAGEFILE': ['self._imageFileList','str','mandatory'],
'OUTPUT': ['self.output','str','optional']}
self.frame = Frame()
self.frame.configure()
# Constants are from
# J. J. Mohr and S. N. Madsen. Geometric calibration of ERS satellite
# SAR images. IEEE T. Geosci. Remote, 39(4):842-850, Apr. 2001.
self.constants = {'polarization': 'VV',
'antennaLength': 10,
'lookDirection': 'RIGHT',
'chirpPulseBandwidth': 15.50829e6,
'rangeSamplingRate': 18.962468e6,
'delayTime':6.622e-6,
'iBias': 15.5,
'qBias': 15.5}
return None
def getFrame(self):
return self.frame
def parse(self):
self.leaderFile = LeaderFile(file=self._leaderFile)
self.leaderFile.parse()
self.imageFile = ImageFile(self)
self.imageFile.parse()
self.populateMetadata()
def populateMetadata(self):
"""
Create the appropriate metadata objects from our CEOSFormat metadata
"""
self._populatePlatform()
self._populateInstrument()
self._populateFrame()
if (self._orbitType == 'ODR'):
self._populateDelftOrbits()
elif (self._orbitType == 'PRC'):
self._populatePRCOrbits()
elif (self._orbitType == 'PDS'):
self._populatePDSOrbits()
else:
self._populateHeaderOrbit()
def _populatePlatform(self):
"""
Populate the platform object with metadata
"""
platform = self.frame.getInstrument().getPlatform()
platform.setMission(self.leaderFile.sceneHeaderRecord.metadata[
'Sensor platform mission identifier'])
platform.setAntennaLength(self.constants['antennaLength'])
platform.setPointingDirection(-1)
platform.setPlanet(Planet('Earth'))
def _populateInstrument(self):
"""Populate the instrument object with metadata"""
instrument = self.frame.getInstrument()
pri = self.imageFile.firstPri
rangeSamplingRate = self.constants['rangeSamplingRate']
#rangeSamplingRate = self.leaderFile.sceneHeaderRecord.metadata[
# 'Range sampling rate']*1e6
rangePixelSize = Const.c/(2.0*rangeSamplingRate)
pulseInterval = 4.0/rangeSamplingRate*(pri+2.0)
prf = 1.0/pulseInterval
instrument.setRadarWavelength(
self.leaderFile.sceneHeaderRecord.metadata['Radar wavelength'])
instrument.setIncidenceAngle(
self.leaderFile.sceneHeaderRecord.metadata[
'Incidence angle at scene centre'])
instrument.setPulseRepetitionFrequency(prf)
instrument.setRangeSamplingRate(rangeSamplingRate)
instrument.setRangePixelSize(rangePixelSize)
instrument.setPulseLength(self.leaderFile.sceneHeaderRecord.metadata[
'Range pulse length']*1e-6)
instrument.setChirpSlope(self.constants['chirpPulseBandwidth']/
(self.leaderFile.sceneHeaderRecord.metadata['Range pulse length']*
1e-6))
instrument.setInPhaseValue(self.constants['iBias'])
instrument.setQuadratureValue(self.constants['qBias'])
def _populateFrame(self):
"""Populate the scene object with metadata"""
rangeSamplingRate = self.constants['rangeSamplingRate']
#rangeSamplingRate = self.leaderFile.sceneHeaderRecord.metadata[
# 'Range sampling rate']*1e6
rangePixelSize = Const.c/(2.0*rangeSamplingRate)
pulseInterval = 1.0/self.frame.getInstrument().getPulseRepetitionFrequency()
frame = self._decodeSceneReferenceNumber(
self.leaderFile.sceneHeaderRecord.metadata[
'Scene reference number'])
startingRange = (9*pulseInterval + self.imageFile.minSwst*4/rangeSamplingRate-self.constants['delayTime'])*Const.c/2.0
farRange = startingRange + self.imageFile.width*rangePixelSize
# Use the Scene center time to get the date, then use the ICU on board time from the image for the rest
centerLineTime = datetime.datetime.strptime(self.leaderFile.sceneHeaderRecord.metadata['Scene centre time'],"%Y%m%d%H%M%S%f")
first_line_utc = datetime.datetime(year=centerLineTime.year, month=centerLineTime.month, day=centerLineTime.day)
if(self.leaderFile.sceneHeaderRecord.metadata['Processing facility identifier'] in ('CRDC_SARDPF','GTS - ERS')):
first_line_utc = first_line_utc + datetime.timedelta(milliseconds=self.imageFile.startTime)
else:
deltaSeconds = (self.imageFile.startTime - self.leaderFile.sceneHeaderRecord.metadata['Satellite encoded binary time code'])* 1/256.0
# Sometimes, the ICU on board clock is corrupt, if the time suggested by the on board clock is more than
# 5 days from the satellite clock time, assume its bogus and use the low-precision scene centre time
if (math.fabs(deltaSeconds) > 5*86400):
self.logger.warn("ICU on board time appears to be corrupt, resorting to low precision clock")
first_line_utc = centerLineTime - datetime.timedelta(microseconds=pulseInterval*(self.imageFile.length/2.0)*1e6)
else:
satelliteClockTime = datetime.datetime.strptime(self.leaderFile.sceneHeaderRecord.metadata['Satellite clock time'],"%Y%m%d%H%M%S%f")
first_line_utc = satelliteClockTime + datetime.timedelta(microseconds=int(deltaSeconds*1e6))
mid_line_utc = first_line_utc + datetime.timedelta(microseconds=pulseInterval*(self.imageFile.length/2.0)*1e6)
last_line_utc = first_line_utc + datetime.timedelta(microseconds=pulseInterval*self.imageFile.length*1e6)
self.logger.debug("Frame UTC start, mid, end times: %s %s %s" % (first_line_utc,mid_line_utc,last_line_utc))
self.frame.setFrameNumber(frame)
self.frame.setOrbitNumber(self.leaderFile.sceneHeaderRecord.metadata['Orbit number'])
self.frame.setStartingRange(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(self.constants['polarization'])
self.frame.setNumberOfLines(self.imageFile.length)
self.frame.setNumberOfSamples(self.imageFile.width)
self.frame.setSensingStart(first_line_utc)
self.frame.setSensingMid(mid_line_utc)
self.frame.setSensingStop(last_line_utc)
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)
def _populateDelftOrbits(self):
"""Populate an orbit object with the Delft orbits"""
from isceobj.Orbit.ODR import ODR, Arclist
self.logger.info("Using Delft Orbits")
arclist = Arclist(os.path.join(self._orbitDir,'arclist'))
arclist.parse()
orbitFile = arclist.getOrbitFile(self.frame.getSensingStart())
odr = ODR(file=os.path.join(self._orbitDir,orbitFile))
#jng it seem that for this tipe of orbit points are separated by 60 sec. In ODR at least 9 state vectors are needed to compute the velocities. add
# extra time before and after to allow interpolation, but do not do it for all data points. too slow
startTimePreInterp = self.frame.getSensingStart() - datetime.timedelta(minutes=60)
stopTimePreInterp = self.frame.getSensingStop() + datetime.timedelta(minutes=60)
odr.parseHeader(startTimePreInterp,stopTimePreInterp)
startTime = self.frame.getSensingStart() - datetime.timedelta(minutes=5)
stopTime = self.frame.getSensingStop() + datetime.timedelta(minutes=5)
self.logger.debug("Extracting orbits between %s and %s" % (startTime,stopTime))
orbit = odr.trimOrbit(startTime,stopTime)
self.frame.setOrbit(orbit)
def _populatePRCOrbits(self):
"""Populate an orbit object the D-PAF PRC orbits"""
from isceobj.Orbit.PRC import PRC, Arclist
self.logger.info("Using PRC Orbits")
arclist = Arclist(os.path.join(self._orbitDir,'arclist'))
arclist.parse()
orbitFile = arclist.getOrbitFile(self.frame.getSensingStart())
self.logger.debug("Using file %s" % (orbitFile))
prc = PRC(file=os.path.join(self._orbitDir,orbitFile))
prc.parse()
startTime = self.frame.getSensingStart() - datetime.timedelta(minutes=5)
stopTime = self.frame.getSensingStop() + datetime.timedelta(minutes=5)
self.logger.debug("Extracting orbits between %s and %s" % (startTime,stopTime))
fullOrbit = prc.getOrbit()
orbit = fullOrbit.trimOrbit(startTime,stopTime)
self.frame.setOrbit(orbit)
def _populatePDSOrbits(self):
"""
Populate an orbit object using the ERS-2 PDS format
"""
from isceobj.Orbit.PDS import PDS
self.logger.info("Using PDS Orbits")
pds = PDS(file=self._orbitFile)
pds.parse()
startTime = self.frame.getSensingStart() - datetime.timedelta(minutes=5)
stopTime = self.frame.getSensingStop() + datetime.timedelta(minutes=5)
self.logger.debug("Extracting orbits between %s and %s" % (startTime,stopTime))
fullOrbit = pds.getOrbit()
orbit = fullOrbit.trimOrbit(startTime,stopTime)
self.frame.setOrbit(orbit)
def extractImage(self):
import array
import math
# just in case there was only one image and it was passed as a str instead of a list with only one element
if(isinstance(self._imageFileList,str)):
self._imageFileList = [self._imageFileList]
self._leaderFileList = [self._leaderFileList]
if(len(self._imageFileList) != len(self._leaderFileList)):
self.logger.error("Number of leader files different from number of image files.")
raise Exception
self.frameList = []
for i in range(len(self._imageFileList)):
appendStr = "_" + str(i)
#if only one file don't change the name
if(len(self._imageFileList) == 1):
appendStr = ''
self.frame = Frame()
self.frame.configure()
self._leaderFile = self._leaderFileList[i]
self._imageFile = self._imageFileList[i]
self.leaderFile = LeaderFile(file=self._leaderFile)
self.leaderFile.parse()
self.imageFile = ImageFile(self)
try:
outputNow = self.output + appendStr
out = open(outputNow,'wb')
except IOError as strerr:
self.logger.error("IOError: %s" % strerr)
return
self.imageFile.extractImage(output=out)
out.close()
rawImage = isceobj.createRawImage()
rawImage.setByteOrder('l')
rawImage.setAccessMode('read')
rawImage.setFilename(outputNow)
rawImage.setWidth(self.imageFile.width)
rawImage.setXmin(0)
rawImage.setXmax(self.imageFile.width)
self.frame.setImage(rawImage)
self.populateMetadata()
self.frameList.append(self.frame)
#jng Howard Z at this point adjusts the sampling starting time for imagery generated from CRDC_SARDPF facility.
# for now create the orbit aux file based in starting time and prf
prf = self.frame.getInstrument().getPulseRepetitionFrequency()
senStart = self.frame.getSensingStart()
numPulses = int(math.ceil(DTU.timeDeltaToSeconds(self.frame.getSensingStop()-senStart)*prf))
# the aux files has two entries per line. day of the year and microseconds in the day
musec0 = (senStart.hour*3600 + senStart.minute*60 + senStart.second)*10**6 + senStart.microsecond
maxMusec = (24*3600)*10**6#use it to check if we went across a day. very rare
day0 = (datetime.datetime(senStart.year,senStart.month,senStart.day) - datetime.datetime(senStart.year,1,1)).days + 1
outputArray = array.array('d',[0]*2*numPulses)
self.frame.auxFile = outputNow + '.aux'
fp = open(self.frame.auxFile,'wb')
j = -1
for i1 in range(numPulses):
j += 1
musec = round((j/prf)*10**6) + musec0
if musec >= maxMusec:
day0 += 1
musec0 = musec%maxMusec
musec = musec0
j = 0
outputArray[2*i1] = day0
outputArray[2*i1+1] = musec
outputArray.tofile(fp)
fp.close()
tk = Track()
if(len(self._imageFileList) > 1):
self.frame = tk.combineFrames(self.output,self.frameList)
for i in range(len(self._imageFileList)):
try:
os.remove(self.output + "_" + str(i))
except OSError:
print("Error. Cannot remove temporary file",self.output + "_" + str(i))
raise OSError
def _decodeSceneReferenceNumber(self,referenceNumber):
frameNumber = referenceNumber.split('=')
if (len(frameNumber) > 2):
frameNumber = frameNumber[2].strip()
else:
frameNumber = frameNumber[0]
return frameNumber
class Radarsat1(Sensor):
"""
Code to read CEOSFormat leader files for Radarsat-1 SAR data.
The tables used to create this parser are based on document number
ER-IS-EPO-GS-5902.1 from the European Space Agency.
"""
family = 'radarsat1'
logging_name = 'isce.sensor.radarsat1'
parameter_list = (LEADERFILE, IMAGEFILE, PARFILE) + Sensor.parameter_list
auxLength = 50
@logged
def __init__(self, name=''):
super().__init__(family=self.__class__.family, name=name)
self.imageFile = None
self.leaderFile = None
#####Soecific doppler functions for RSAT1
self.doppler_ref_range = None
self.doppler_ref_azi = None
self.doppler_predict = None
self.doppler_DAR = None
self.doppler_coeff = None
self.frame = Frame()
self.frame.configure()
self.constants = {'polarization': 'HH', 'antennaLength': 15}
def getFrame(self):
return self.frame
def parse(self):
self.leaderFile = LeaderFile(self, file=self._leaderFile)
self.leaderFile.parse()
self.imageFile = ImageFile(self, file=self._imageFile)
self.imageFile.parse()
self.populateMetadata()
if self._parFile:
self.parseParFile()
else:
self.populateCEOSOrbit()
def populateMetadata(self):
"""
Create the appropriate metadata objects from our CEOSFormat metadata
"""
frame = self._decodeSceneReferenceNumber(
self.leaderFile.sceneHeaderRecord.
metadata['Scene reference number'])
try:
rangePixelSize = Const.c / (2 * self.leaderFile.sceneHeaderRecord.
metadata['Range sampling rate'] * 1e6)
except ZeroDivisionError:
rangePixelSize = 0
ins = self.frame.getInstrument()
platform = ins.getPlatform()
platform.setMission(self.leaderFile.sceneHeaderRecord.
metadata['Sensor platform mission identifier'])
platform.setAntennaLength(self.constants['antennaLength'])
platform.setPointingDirection(-1)
platform.setPlanet(Planet(pname='Earth'))
ins.setRadarWavelength(
self.leaderFile.sceneHeaderRecord.metadata['Radar wavelength'])
ins.setIncidenceAngle(self.leaderFile.sceneHeaderRecord.
metadata['Incidence angle at scene centre'])
##RSAT-1 does not have PRF for raw data in leader file.
# self.frame.getInstrument().setPulseRepetitionFrequency(self.leaderFile.sceneHeaderRecord.metadata['Pulse Repetition Frequency'])
ins.setRangePixelSize(rangePixelSize)
ins.setPulseLength(
self.leaderFile.sceneHeaderRecord.metadata['Range pulse length'] *
1e-6)
chirpPulseBandwidth = 15.50829e6 # Is this really not in the CEOSFormat Header?
ins.setChirpSlope(
chirpPulseBandwidth /
(self.leaderFile.sceneHeaderRecord.metadata['Range pulse length'] *
1e-6))
ins.setInPhaseValue(7.5)
ins.setQuadratureValue(7.5)
self.frame.setFrameNumber(frame)
self.frame.setOrbitNumber(
self.leaderFile.sceneHeaderRecord.metadata['Orbit number'])
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(self.constants['polarization'])
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')
self.frame.getOrbit().setOrbitQuality(
self.leaderFile.platformPositionRecord.
metadata['Orbital elements designator'])
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 extractImage(self):
import isceobj
if (self.imageFile is None) or (self.leaderFile is None):
self.parse()
try:
out = open(self.output, 'wb')
except IOError as strerr:
self.logger.error("IOError: %s" % strerr)
self.imageFile.extractImage(output=out)
out.close()
####RSAT1 is weird. Contains all useful info in RAW data and not leader.
ins = self.frame.getInstrument()
ins.setPulseRepetitionFrequency(self.imageFile.prf)
ins.setPulseLength(self.imageFile.pulseLength)
ins.setRangeSamplingRate(self.imageFile.rangeSamplingRate)
ins.setRangePixelSize(Const.c / (2 * self.imageFile.rangeSamplingRate))
ins.setChirpSlope(self.imageFile.chirpSlope)
######
self.frame.setSensingStart(self.imageFile.sensingStart)
sensingStop = self.imageFile.sensingStart + datetime.timedelta(
seconds=((self.frame.getNumberOfLines() - 1) / self.imageFile.prf))
sensingMid = self.imageFile.sensingStart + datetime.timedelta(
seconds=0.5 *
(sensingStop - self.imageFile.sensingStart).total_seconds())
self.frame.setSensingStop(sensingStop)
self.frame.setSensingMid(sensingMid)
self.frame.setNumberOfSamples(self.imageFile.width)
self.frame.setStartingRange(self.imageFile.startingRange)
farRange = self.imageFile.startingRange + ins.getRangePixelSize(
) * self.imageFile.width * 0.5
self.frame.setFarRange(farRange)
rawImage = isceobj.createRawImage()
rawImage.setByteOrder('l')
rawImage.setAccessMode('read')
rawImage.setFilename(self.output)
rawImage.setWidth(self.imageFile.width)
rawImage.setXmin(0)
rawImage.setXmax(self.imageFile.width)
rawImage.renderHdr()
self.frame.setImage(rawImage)
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 extractDoppler(self):
'''
Evaluate the doppler polynomial and return the average value for now.
'''
rmin = self.frame.getStartingRange()
rmax = self.frame.getFarRange()
rmid = 0.5 * (rmin + rmax)
delr = Const.c / (2 * self.frame.instrument.rangeSamplingRate)
azmid = secondsSinceMidnight(self.frame.getSensingMid())
print(rmid, self.doppler_coeff.getMeanRange())
print(azmid, self.doppler_coeff.getMeanAzimuth())
if self.doppler_coeff is None:
raise Exception(
'ASF PARFILE was not provided. Cannot determine default doppler.'
)
dopav = self.doppler_coeff(azmid, rmid)
prf = self.frame.getInstrument().getPulseRepetitionFrequency()
quadratic = {}
quadratic['a'] = dopav / prf
quadratic['b'] = 0.
quadratic['c'] = 0.
######Set up the doppler centroid computation just like CSK at mid azimuth
order = self.doppler_coeff._rangeOrder
rng = np.linspace(rmin, rmax, num=(order + 2))
pix = (rng - rmin) / delr
val = [self.doppler_coeff(azmid, x) for x in rng]
print(rng, val)
print(delr, pix)
fit = np.polyfit(pix, val, order)
self.frame._dopplerVsPixel = list(fit[::-1])
# self.frame._dopplerVsPixel = [dopav,0.,0.,0.]
return quadratic
def _decodeSceneReferenceNumber(self, referenceNumber):
return referenceNumber
class JERS(Component):
"""
Code to read CEOSFormat leader files for ERS-1/2 SAR data.
The tables used to create this parser are based on document
number ER-IS-EPO-GS-5902.1 from the European Space Agency.
"""
#Parsers.CEOS.CEOSFormat.ceosTypes['text'] = {'typeCode': 63, 'subtypeCode': [18,18,18]}
#Parsers.CEOS.CEOSFormat.ceosTypes['leaderFile'] = {'typeCode': 192, 'subtypeCode': [63,18,18]}
#Parsers.CEOS.CEOSFormat.ceosTypes['dataSetSummary'] = {'typeCode': 10, 'subtypeCode': [10,31,20]}
#Parsers.CEOS.CEOSFormat.ceosTypes['platformPositionData'] = {'typeCode': 30, 'subtypeCode': [10,31,20]}
#Parsers.CEOS.CEOSFormat.ceosTypes['facilityData'] = {'typeCode': 200, 'subtypeCode': [10,31,50]}
#Parsers.CEOS.CEOSFormat.ceosTypes['datafileDescriptor'] = {'typeCode': 192, 'subtypeCode':[63,18,18]}
#Parsers.CEOS.CEOSFormat.ceosTypes['signalData'] = {'typeCode': 10, 'subtypeCode': [50,31,20]}
#Parsers.CEOS.CEOSFormat.ceosTypes['nullFileDescriptor'] = {'typeCode': 192, 'subtypeCode': [192,63,18]}
def __init__(self):
Component.__init__(self)
self._leaderFile = None
self._imageFile = None
self.output = None
self.frame = Frame()
self.frame.configure()
self.constants = {'polarization': 'HH',
'antennaLength': 12}
self.descriptionOfVariables = {}
self.dictionaryOfVariables = {'LEADERFILE': ['self._leaderFile','str','mandatory'],
'IMAGEFILE': ['self._imageFile','str','mandatory'],
'OUTPUT': ['self.output','str','optional']}
def getFrame(self):
return self.frame
def parse(self):
self.leaderFile = LeaderFile(file=self._leaderFile)
self.leaderFile.parse()
self.imageFile = ImageFile(file=self._imageFile)
self.imageFile.parse()
self.populateMetadata()
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 extractImage(self):
raise NotImplementedError()
def _decodeSceneReferenceNumber(self,referenceNumber):
return referenceNumber
class Radarsat1(Component):
"""
Code to read CEOSFormat leader files for Radarsat-1 SAR data. The tables used to create
this parser are based on document number ER-IS-EPO-GS-5902.1 from the European
Space Agency.
"""
auxLength = 50
def __init__(self):
Component.__init__(self)
self._leaderFile = None
self._imageFile = None
self._parFile = None
self.output = None
self.imageFile = None
self.leaderFile = None
#####Soecific doppler functions for RSAT1
self.doppler_ref_range = None
self.doppler_ref_azi = None
self.doppler_predict = None
self.doppler_DAR = None
self.doppler_coeff = None
self.frame = Frame()
self.frame.configure()
self.constants = {'polarization': 'HH', 'antennaLength': 15}
self.descriptionOfVariables = {}
self.dictionaryOfVariables = {
'LEADERFILE': ['self._leaderFile', 'str', 'mandatory'],
'IMAGEFILE': ['self._imageFile', 'str', 'mandatory'],
'PARFILE': ['self._parFile', 'str', 'optional'],
'OUTPUT': ['self.output', 'str', 'optional']
}
def getFrame(self):
return self.frame
def parse(self):
self.leaderFile = LeaderFile(self, file=self._leaderFile)
self.leaderFile.parse()
self.imageFile = ImageFile(self, file=self._imageFile)
self.imageFile.parse()
self.populateMetadata()
def populateMetadata(self):
"""
Create the appropriate metadata objects from our CEOSFormat metadata
"""
frame = self._decodeSceneReferenceNumber(
self.leaderFile.sceneHeaderRecord.
metadata['Scene reference number'])
try:
rangePixelSize = Const.c / (2 * self.leaderFile.sceneHeaderRecord.
metadata['Range sampling rate'] * 1e6)
except ZeroDivisionError:
rangePixelSize = 0
ins = self.frame.getInstrument()
platform = ins.getPlatform()
platform.setMission(self.leaderFile.sceneHeaderRecord.
metadata['Sensor platform mission identifier'])
platform.setAntennaLength(self.constants['antennaLength'])
platform.setPointingDirection(-1)
platform.setPlanet(Planet('Earth'))
ins.setRadarWavelength(
self.leaderFile.sceneHeaderRecord.metadata['Radar wavelength'])
ins.setIncidenceAngle(self.leaderFile.sceneHeaderRecord.
metadata['Incidence angle at scene centre'])
##RSAT-1 does not have PRF for raw data in leader file.
# self.frame.getInstrument().setPulseRepetitionFrequency(self.leaderFile.sceneHeaderRecord.metadata['Pulse Repetition Frequency'])
ins.setRangePixelSize(rangePixelSize)
ins.setPulseLength(
self.leaderFile.sceneHeaderRecord.metadata['Range pulse length'] *
1e-6)
chirpPulseBandwidth = 15.50829e6 # Is this really not in the CEOSFormat Header?
ins.setChirpSlope(
chirpPulseBandwidth /
(self.leaderFile.sceneHeaderRecord.metadata['Range pulse length'] *
1e-6))
ins.setInPhaseValue(7.5)
ins.setQuadratureValue(7.5)
self.frame.setFrameNumber(frame)
self.frame.setOrbitNumber(
self.leaderFile.sceneHeaderRecord.metadata['Orbit number'])
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(self.constants['polarization'])
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')
self.frame.getOrbit().setOrbitQuality(
self.leaderFile.platformPositionRecord.
metadata['Orbital elements designator'])
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.
convOrb = ECI2ECEF(orb, eci='ECI_TOD')
wgsorb = convOrb.convert()
orb = self.frame.getOrbit()
for sv in wgsorb:
orb.addStateVector(sv)
self.parseParFile()
def extractImage(self):
import isceobj
if (self.imageFile is None) or (self.leaderFile is None):
self.parse()
try:
out = open(self.output, 'wb')
except IOError as strerr:
self.logger.error("IOError: %s" % strerr)
self.imageFile.extractImage(output=out)
out.close()
####RSAT1 is weird. Contains all useful info in RAW data and not leader.
ins = self.frame.getInstrument()
ins.setPulseRepetitionFrequency(self.imageFile.prf)
ins.setPulseLength(self.imageFile.pulseLength)
ins.setRangeSamplingRate(self.imageFile.rangeSamplingRate)
ins.setRangePixelSize(Const.c / (2 * self.imageFile.rangeSamplingRate))
ins.setChirpSlope(self.imageFile.chirpSlope)
######
self.frame.setSensingStart(self.imageFile.sensingStart)
sensingStop = self.imageFile.sensingStart + datetime.timedelta(
seconds=((self.frame.getNumberOfLines() - 1) / self.imageFile.prf))
sensingMid = self.imageFile.sensingStart + datetime.timedelta(
seconds=0.5 *
(sensingStop - self.imageFile.sensingStart).total_seconds())
self.frame.setSensingStop(sensingStop)
self.frame.setSensingMid(sensingMid)
self.frame.setNumberOfSamples(self.imageFile.width)
self.frame.setStartingRange(self.imageFile.startingRange)
farRange = self.imageFile.startingRange + ins.getRangePixelSize(
) * self.imageFile.width * 0.5
self.frame.setFarRange(farRange)
rawImage = isceobj.createRawImage()
rawImage.setByteOrder('l')
rawImage.setAccessMode('read')
rawImage.setFilename(self.output)
rawImage.setWidth(self.imageFile.width)
rawImage.setXmin(0)
rawImage.setXmax(self.imageFile.width)
rawImage.renderHdr()
self.frame.setImage(rawImage)
def parseParFile(self):
'''Parse the par file if any is available.'''
if self._parFile not in (None, ''):
par = ParFile(self._parFile)
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'])
azOrder = int(coeff['number_of_coefficients_second_dimension'])
self.doppler_coeff = Polynomial(rangeOrder=rngOrder,
azimuthOrder=azOrder)
self.doppler_coeff.setMeanRange(self.doppler_ref_range)
self.doppler_coeff.setMeanAzimuth(
secondsSinceMidnight(self.doppler_ref_azi))
for ii in range(azOrder):
for jj in range(rngOrder):
key = 'a%d%d' % (ii, jj)
val = float(coeff[key])
self.doppler_coeff.setCoeff(ii, jj, val)
def extractDoppler(self):
'''
Evaluate the doppler polynomial and return the average value for now.
'''
rmin = self.frame.getStartingRange()
rmax = self.frame.getFarRange()
rmid = 0.5 * (rmin + rmax)
azmid = secondsSinceMidnight(self.frame.getSensingMid())
print(rmid, self.doppler_coeff.getMeanRange())
print(azmid, self.doppler_coeff.getMeanAzimuth())
if self.doppler_coeff is None:
raise Exception(
'ASF PARFILE was not provided. Cannot determine default doppler.'
)
dopav = self.doppler_coeff(azmid, rmid)
prf = self.frame.getInstrument().getPulseRepetitionFrequency()
quadratic = {}
quadratic['a'] = dopav / prf
quadratic['b'] = 0.
quadratic['c'] = 0.
return quadratic
def _decodeSceneReferenceNumber(self, referenceNumber):
return referenceNumber
class ALOS_SLC(Sensor):
"""
Code to read CEOSFormat leader files for ALOS SLC data.
"""
parameter_list = (WAVELENGTH,
LEADERFILE,
IMAGEFILE) + Sensor.parameter_list
family = 'alos_slc'
logging_name = 'isce.sensor.ALOS_SLC'
#Orbital Elements (Quality) Designator
#ALOS-2/PALSAR-2 Level 1.1/1.5/2.1/3.1 CEOS SAR Product Format Description
#PALSAR-2_xx_Format_CEOS_E_r.pdf
orbitElementsDesignator = {'0': 'preliminary',
'1': 'decision',
'2': 'high precision'}
def __init__(self, name=''):
super().__init__(family=self.__class__.family, name=name)
self.imageFile = None
self.leaderFile = None
# Specific doppler functions for ALOS
self.doppler_coeff = None
self.azfmrate_coeff = None
self.lineDirection = None
self.pixelDirection = None
self.frame = Frame()
self.frame.configure()
self.constants = {'antennaLength': 15}
def getFrame(self):
return self.frame
def parse(self):
self.leaderFile = LeaderFile(self, file=self._leaderFile)
self.leaderFile.parse()
self.imageFile = ImageFile(self, file=self._imageFile)
self.imageFile.parse()
self.populateMetadata()
self._populateExtras()
def populateMetadata(self):
"""
Create the appropriate metadata objects from our CEOSFormat metadata
"""
frame = self._decodeSceneReferenceNumber(self.leaderFile.sceneHeaderRecord.metadata['Scene reference number'])
fsamplookup = self.leaderFile.sceneHeaderRecord.metadata['Range sampling rate in MHz']*1.0e6
rangePixelSize = Const.c/(2*fsamplookup)
ins = self.frame.getInstrument()
platform = ins.getPlatform()
platform.setMission(self.leaderFile.sceneHeaderRecord.metadata['Sensor platform mission identifier'])
platform.setAntennaLength(self.constants['antennaLength'])
platform.setPointingDirection(1)
platform.setPlanet(Planet(pname='Earth'))
if self.wavelength:
ins.setRadarWavelength(float(self.wavelength))
else:
ins.setRadarWavelength(self.leaderFile.sceneHeaderRecord.metadata['Radar wavelength'])
ins.setIncidenceAngle(self.leaderFile.sceneHeaderRecord.metadata['Incidence angle at scene centre'])
self.frame.getInstrument().setPulseRepetitionFrequency(self.leaderFile.sceneHeaderRecord.metadata['Pulse Repetition Frequency in mHz']*1.0e-3)
ins.setRangePixelSize(rangePixelSize)
ins.setRangeSamplingRate(fsamplookup)
ins.setPulseLength(self.leaderFile.sceneHeaderRecord.metadata['Range pulse length in microsec']*1.0e-6)
chirpSlope = self.leaderFile.sceneHeaderRecord.metadata['Nominal range pulse (chirp) amplitude coefficient linear term']
chirpPulseBandwidth = abs(chirpSlope * self.leaderFile.sceneHeaderRecord.metadata['Range pulse length in microsec']*1.0e-6)
ins.setChirpSlope(chirpSlope)
ins.setInPhaseValue(7.5)
ins.setQuadratureValue(7.5)
self.lineDirection = self.leaderFile.sceneHeaderRecord.metadata['Time direction indicator along line direction'].strip()
self.pixelDirection = self.leaderFile.sceneHeaderRecord.metadata['Time direction indicator along pixel direction'].strip()
######ALOS includes this information in clock angle
clockAngle = self.leaderFile.sceneHeaderRecord.metadata['Sensor clock angle']
if clockAngle == 90.0:
platform.setPointingDirection(-1)
elif clockAngle == -90.0:
platform.setPointingDirection(1)
else:
raise Exception('Unknown look side. Clock Angle = {0}'.format(clockAngle))
self.frame.setFrameNumber(frame)
self.frame.setOrbitNumber(self.leaderFile.sceneHeaderRecord.metadata['Orbit number'])
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.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.instrument.setAzimuthPixelSize(self.leaderFile.dataQualitySummaryRecord.metadata['Azimuth resolution'])
######
orb = self.frame.getOrbit()
orb.setOrbitSource('Header')
orb.setOrbitQuality(
self.orbitElementsDesignator[
self.leaderFile.platformPositionRecord.metadata['Orbital elements designator']
]
)
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
deltaT = self.leaderFile.platformPositionRecord.metadata['Time interval between data points']
numPts = self.leaderFile.platformPositionRecord.metadata['Number of data points']
orb = self.frame.getOrbit()
for i in range(numPts):
vec = StateVector()
t = t0 + datetime.timedelta(seconds=i*deltaT)
vec.setTime(t)
dataPoints = self.leaderFile.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)
self.doppler_coeff = [self.leaderFile.sceneHeaderRecord.metadata['Cross track Doppler frequency centroid constant term'],
self.leaderFile.sceneHeaderRecord.metadata['Cross track Doppler frequency centroid linear term'],
self.leaderFile.sceneHeaderRecord.metadata['Cross track Doppler frequency centroid quadratic term']]
self.azfmrate_coeff = [self.leaderFile.sceneHeaderRecord.metadata['Cross track Doppler frequency rate constant term'],
self.leaderFile.sceneHeaderRecord.metadata['Cross track Doppler frequency rate linear term'],
self.leaderFile.sceneHeaderRecord.metadata['Cross track Doppler frequency rate quadratic term']]
def _populateExtras(self):
dataset = self.leaderFile.radiometricRecord.metadata
print("Record Number: %d" % (dataset["Record Number"]))
print("First Record Subtype: %d" % (dataset["First Record Subtype"]))
print("Record Type Code: %d" % (dataset["Record Type Code"]))
print("Second Record Subtype: %d" % (dataset["Second Record Subtype"]))
print("Third Record Subtype: %d" % (dataset["Third Record Subtype"]))
print("Record Length: %d" % (dataset["Record Length"]))
print("SAR channel indicator: %d" % (dataset["SAR channel indicator"]))
print("Number of data sets: %d" % (dataset["Number of data sets"]))
numPts = dataset['Number of data sets']
for i in range(numPts):
if i > 1:
break
print('Radiometric record field: %d' % (i+1))
dataset = self.leaderFile.radiometricRecord.metadata[
'Radiometric data sets'][i]
DT11 = complex(dataset['Real part of DT 1,1'],
dataset['Imaginary part of DT 1,1'])
DT12 = complex(dataset['Real part of DT 1,2'],
dataset['Imaginary part of DT 1,2'])
DT21 = complex(dataset['Real part of DT 2,1'],
dataset['Imaginary part of DT 2,1'])
DT22 = complex(dataset['Real part of DT 2,2'],
dataset['Imaginary part of DT 2,2'])
DR11 = complex(dataset['Real part of DR 1,1'],
dataset['Imaginary part of DR 1,1'])
DR12 = complex(dataset['Real part of DR 1,2'],
dataset['Imaginary part of DR 1,2'])
DR21 = complex(dataset['Real part of DR 2,1'],
dataset['Imaginary part of DR 2,1'])
DR22 = complex(dataset['Real part of DR 2,2'],
dataset['Imaginary part of DR 2,2'])
print("Calibration factor [dB]: %f" %
(dataset["Calibration factor"]))
print('Distortion matrix Trasmission [DT11, DT12, DT21, DT22]: '
'[%s, %s, %s, %s]' %
(str(DT11), str(DT12), str(DT21), str(DT22)))
print('Distortion matrix Reception [DR11, DR12, DR21, DR22]: '
'[%s, %s, %s, %s]' %
(str(DR11), str(DR12), str(DR21), str(DR22)))
self.transmit = Distortion(DT12, DT21, DT22)
self.receive = Distortion(DR12, DR21, DR22)
self.calibrationFactor = float(
dataset['Calibration factor'])
def extractImage(self):
import isceobj
if (self.imageFile is None) or (self.leaderFile is None):
self.parse()
try:
out = open(self.output, 'wb')
except IOError as strerr:
self.logger.error("IOError: %s" % strerr)
self.imageFile.extractImage(output=out)
out.close()
self.frame.setSensingStart(self.imageFile.sensingStart)
self.frame.setSensingStop(self.imageFile.sensingStop)
sensingMid = self.imageFile.sensingStart + datetime.timedelta(seconds = 0.5* (self.imageFile.sensingStop - self.imageFile.sensingStart).total_seconds())
self.frame.setSensingMid(sensingMid)
try:
rngGate= Const.c*0.5*self.leaderFile.sceneHeaderRecord.metadata['Range gate delay in microsec']*1e-6
except:
rngGate = None
if (rngGate is None) or (rngGate == 0.0):
rngGate = self.imageFile.nearRange
self.frame.setStartingRange(rngGate)
self.frame.getInstrument().setPulseRepetitionFrequency(self.imageFile.prf)
pixelSize = self.frame.getInstrument().getRangePixelSize()
farRange = self.imageFile.nearRange + (pixelSize-1) * self.imageFile.width
self.frame.setFarRange(farRange)
self.frame.setPolarization(self.imageFile.current_polarization)
rawImage = isceobj.createSlcImage()
rawImage.setByteOrder('l')
rawImage.setAccessMode('read')
rawImage.setFilename(self.output)
rawImage.setWidth(self.imageFile.width)
rawImage.setXmin(0)
rawImage.setXmax(self.imageFile.width)
rawImage.renderHdr()
self.frame.setImage(rawImage)
return
def extractDoppler(self):
'''
Evaluate the doppler polynomial and return the average value for now.
'''
midwidth = self.frame.getNumberOfSamples() / 2.0
dop = 0.0
prod = 1.0
for ind, kk in enumerate(self.doppler_coeff):
dop += kk * prod
prod *= midwidth
print ('Average Doppler: {0}'.format(dop))
####For insarApp
quadratic = {}
quadratic['a'] = dop / self.frame.getInstrument().getPulseRepetitionFrequency()
quadratic['b'] = 0.
quadratic['c'] = 0.
####For roiApp
####More accurate
####CEOS already provides function vs pixel
self.frame._dopplerVsPixel = self.doppler_coeff
return quadratic
def _decodeSceneReferenceNumber(self,referenceNumber):
return referenceNumber
class ERS_SLC(Sensor):
family = 'ers_slc'
logging_name = 'isce.sensor.ers_slc'
parameter_list = (IMAGEFILE,
LEADERFILE,
ORBIT_TYPE,
ORBIT_DIRECTORY,
ORBIT_FILE) + Sensor.parameter_list
@logged
def __init__(self, name=''):
super().__init__(family=self.__class__.family, name=name)
self.frame = Frame()
self.frame.configure()
self.dopplerRangeTime = None
# Constants are from
# J. J. Mohr and S. N. Madsen. Geometric calibration of ERS satellite
# SAR images. IEEE T. Geosci. Remote, 39(4):842-850, Apr. 2001.
self.constants = {'polarization': 'VV',
'antennaLength': 10,
'lookDirection': 'RIGHT',
'chirpPulseBandwidth': 15.50829e6,
'rangeSamplingRate': 18.962468e6,
'delayTime':6.622e-6,
'iBias': 15.5,
'qBias': 15.5}
return None
def getFrame(self):
return self.frame
def parse(self):
self.leaderFile = LeaderFile(file=self._leaderFile)
self.leaderFile.parse()
self.imageFile = ImageFile(self)
self.imageFile.parse()
self.populateMetadata()
def populateMetadata(self):
"""
Create the appropriate metadata objects from our CEOSFormat metadata
"""
self._populatePlatform()
self._populateInstrument()
self._populateFrame()
if (self._orbitType == 'ODR'):
self._populateDelftOrbits()
elif (self._orbitType == 'PRC'):
self._populatePRCOrbits()
elif (self._orbitType == 'PDS'):
self._populatePDSOrbits()
else:
self._populateHeaderOrbit()
self._populateDoppler()
def _populatePlatform(self):
"""
Populate the platform object with metadata
"""
platform = self.frame.getInstrument().getPlatform()
platform.setMission(self.leaderFile.sceneHeaderRecord.metadata[
'Sensor platform mission identifier'])
platform.setAntennaLength(self.constants['antennaLength'])
platform.setPointingDirection(-1)
platform.setPlanet(Planet(pname='Earth'))
def _populateInstrument(self):
"""Populate the instrument object with metadata"""
instrument = self.frame.getInstrument()
prf = self.leaderFile.sceneHeaderRecord.metadata['Pulse Repetition Frequency']
rangeSamplingRate = self.leaderFile.sceneHeaderRecord.metadata['Range sampling rate']*1.0e6
rangePixelSize = Const.c/(2.0*rangeSamplingRate)
instrument.setRadarWavelength(
self.leaderFile.sceneHeaderRecord.metadata['Radar wavelength'])
instrument.setIncidenceAngle(
self.leaderFile.sceneHeaderRecord.metadata[
'Incidence angle at scene centre'])
instrument.setPulseRepetitionFrequency(prf)
instrument.setRangeSamplingRate(rangeSamplingRate)
instrument.setRangePixelSize(rangePixelSize)
instrument.setPulseLength(self.leaderFile.sceneHeaderRecord.metadata[
'Range pulse length']*1e-6)
instrument.setChirpSlope(self.constants['chirpPulseBandwidth']/
(self.leaderFile.sceneHeaderRecord.metadata['Range pulse length']*
1e-6))
instrument.setInPhaseValue(self.constants['iBias'])
instrument.setQuadratureValue(self.constants['qBias'])
def _populateFrame(self):
"""Populate the scene object with metadata"""
rangeSamplingRate = self.constants['rangeSamplingRate']
rangePixelSize = Const.c/(2.0*rangeSamplingRate)
pulseInterval = 1.0/self.frame.getInstrument().getPulseRepetitionFrequency()
frame = self._decodeSceneReferenceNumber(
self.leaderFile.sceneHeaderRecord.metadata[
'Scene reference number'])
prf = self.frame.instrument.getPulseRepetitionFrequency()
tau0 = self.leaderFile.sceneHeaderRecord.metadata['Zero-doppler range time of first range pixel']*1.0e-3
startingRange = tau0*Const.c/2.0
farRange = startingRange + self.imageFile.width*rangePixelSize
first_line_utc = datetime.datetime.strptime(self.leaderFile.sceneHeaderRecord.metadata['Zero-doppler azimuth time of first azimuth pixel'], "%d-%b-%Y %H:%M:%S.%f")
mid_line_utc = first_line_utc + datetime.timedelta(seconds = (self.imageFile.length-1) * 0.5 / prf)
last_line_utc = first_line_utc + datetime.timedelta(seconds = (self.imageFile.length-1)/prf)
self.logger.debug("Frame UTC start, mid, end times: %s %s %s" % (first_line_utc,mid_line_utc,last_line_utc))
self.frame.setFrameNumber(frame)
self.frame.setOrbitNumber(self.leaderFile.sceneHeaderRecord.metadata['Orbit number'])
self.frame.setStartingRange(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(self.constants['polarization'])
self.frame.setNumberOfLines(self.imageFile.length)
self.frame.setNumberOfSamples(self.imageFile.width)
self.frame.setSensingStart(first_line_utc)
self.frame.setSensingMid(mid_line_utc)
self.frame.setSensingStop(last_line_utc)
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)
def _populateDelftOrbits(self):
"""Populate an orbit object with the Delft orbits"""
from isceobj.Orbit.ODR import ODR, Arclist
self.logger.info("Using Delft Orbits")
arclist = Arclist(os.path.join(self._orbitDir,'arclist'))
arclist.parse()
orbitFile = arclist.getOrbitFile(self.frame.getSensingStart())
odr = ODR(file=os.path.join(self._orbitDir,orbitFile))
startTimePreInterp = self.frame.getSensingStart() - datetime.timedelta(minutes=60)
stopTimePreInterp = self.frame.getSensingStop() + datetime.timedelta(minutes=60)
odr.parseHeader(startTimePreInterp,stopTimePreInterp)
startTime = self.frame.getSensingStart() - datetime.timedelta(minutes=5)
stopTime = self.frame.getSensingStop() + datetime.timedelta(minutes=5)
self.logger.debug("Extracting orbits between %s and %s" % (startTime,stopTime))
orbit = odr.trimOrbit(startTime,stopTime)
self.frame.setOrbit(orbit)
def _populatePRCOrbits(self):
"""Populate an orbit object the D-PAF PRC orbits"""
from isceobj.Orbit.PRC import PRC, Arclist
self.logger.info("Using PRC Orbits")
arclist = Arclist(os.path.join(self._orbitDir,'arclist'))
arclist.parse()
orbitFile = arclist.getOrbitFile(self.frame.getSensingStart())
self.logger.debug("Using file %s" % (orbitFile))
prc = PRC(file=os.path.join(self._orbitDir,orbitFile))
prc.parse()
startTime = self.frame.getSensingStart() - datetime.timedelta(minutes=5)
stopTime = self.frame.getSensingStop() + datetime.timedelta(minutes=5)
self.logger.debug("Extracting orbits between %s and %s" % (startTime,stopTime))
fullOrbit = prc.getOrbit()
orbit = fullOrbit.trimOrbit(startTime,stopTime)
self.frame.setOrbit(orbit)
def _populatePDSOrbits(self):
"""
Populate an orbit object using the ERS-2 PDS format
"""
from isceobj.Orbit.PDS import PDS
self.logger.info("Using PDS Orbits")
pds = PDS(file=self._orbitFile)
pds.parse()
startTime = self.frame.getSensingStart() - datetime.timedelta(minutes=5)
stopTime = self.frame.getSensingStop() + datetime.timedelta(minutes=5)
self.logger.debug("Extracting orbits between %s and %s" % (startTime,stopTime))
fullOrbit = pds.getOrbit()
orbit = fullOrbit.trimOrbit(startTime,stopTime)
self.frame.setOrbit(orbit)
def _populateDoppler(self):
'''
Extract doppler from the CEOS file.
'''
prf = self.frame.instrument.getPulseRepetitionFrequency()
#####ERS provides doppler as a function of slant range time in seconds
d0 = self.leaderFile.sceneHeaderRecord.metadata['Cross track Doppler frequency centroid constant term']
d1 = self.leaderFile.sceneHeaderRecord.metadata['Cross track Doppler frequency centroid linear term']
d2 = self.leaderFile.sceneHeaderRecord.metadata['Cross track Doppler frequency centroid quadratic term']
self.dopplerRangeTime = [d0, d1, d2]
return
def extractDoppler(self):
width = self.frame.getNumberOfSamples()
prf = self.frame.instrument.getPulseRepetitionFrequency()
midtime = 0.5*width/self.frame.instrument.getRangeSamplingRate()
fd_mid = 0.0
x = 1.0
for ind, coeff in enumerate(self.dopplerRangeTime):
fd_mid += coeff * x
x *= midtime
####For insarApp
quadratic = {}
quadratic['a'] = fd_mid / prf
quadratic['b'] = 0.0
quadratic['c'] = 0.0
###For roiApp more accurate
####Convert stuff to pixel wise coefficients
dr = self.frame.getInstrument().getRangePixelSize()
norm = 0.5*Const.c/dr
dcoeffs = []
for ind, val in enumerate(self.dopplerRangeTime):
dcoeffs.append( val / (norm**ind))
self.frame._dopplerVsPixel = dcoeffs
print('Doppler Fit: ', fit[::-1])
return quadratic
def extractImage(self):
import array
import math
self.parse()
try:
out = open(self.output, 'wb')
except:
raise Exception('Cannot open output file: %s'%(self.output))
self.imageFile.extractImage(output=out)
out.close()
rawImage = isceobj.createSlcImage()
rawImage.setByteOrder('l')
rawImage.setAccessMode('read')
rawImage.setFilename(self.output)
rawImage.setWidth(self.imageFile.width)
rawImage.setXmin(0)
rawImage.setXmax(self.imageFile.width)
self.frame.setImage(rawImage)
prf = self.frame.getInstrument().getPulseRepetitionFrequency()
senStart = self.frame.getSensingStart()
numPulses = int(math.ceil(DTU.timeDeltaToSeconds(self.frame.getSensingStop()-senStart)*prf))
musec0 = (senStart.hour*3600 + senStart.minute*60 + senStart.second)*10**6 + senStart.microsecond
maxMusec = (24*3600)*10**6#use it to check if we went across a day. very rare
day0 = (datetime.datetime(senStart.year,senStart.month,senStart.day) - datetime.datetime(senStart.year,1,1)).days + 1
outputArray = array.array('d',[0]*2*numPulses)
self.frame.auxFile = self.output + '.aux'
fp = open(self.frame.auxFile,'wb')
j = -1
for i1 in range(numPulses):
j += 1
musec = round((j/prf)*10**6) + musec0
if musec >= maxMusec:
day0 += 1
musec0 = musec%maxMusec
musec = musec0
j = 0
outputArray[2*i1] = day0
outputArray[2*i1+1] = musec
outputArray.tofile(fp)
fp.close()
def _decodeSceneReferenceNumber(self,referenceNumber):
frameNumber = referenceNumber.split('=')
if (len(frameNumber) > 2):
frameNumber = frameNumber[2].strip()
else:
frameNumber = frameNumber[0]
return frameNumber
