def extract_tops_metadata(xml_file):
"""Read metadata from xml file for Sentinel-1/TOPS
Parameters: xml_file : str, path of the .xml file, i.e. master/IW1.xml
Returns: meta : dict, metadata
"""
import isce
from isceobj.Planet.Planet import Planet
obj = load_product(xml_file)
burst = obj.bursts[0]
burstEnd = obj.bursts[-1]
metadata = {}
metadata['prf'] = burst.prf
metadata['startUTC'] = burst.burstStartUTC
metadata['stopUTC'] = burstEnd.burstStopUTC
metadata['radarWavelength'] = burst.radarWavelength
metadata['rangePixelSize'] = burst.rangePixelSize
metadata['startingRange'] = burst.startingRange
metadata['passDirection'] = burst.passDirection
metadata['polarization'] = burst.polarization
metadata['trackNumber'] = burst.trackNumber
metadata['orbitNumber'] = burst.orbitNumber
time_seconds = (burst.burstStartUTC.hour * 3600.0 +
burst.burstStartUTC.minute * 60.0 +
burst.burstStartUTC.second)
metadata['CENTER_LINE_UTC'] = time_seconds
orbit = burst.orbit
peg = orbit.interpolateOrbit(burst.sensingMid, method='hermite')
Vs = np.linalg.norm(peg.getVelocity())
metadata['satelliteSpeed'] = Vs
metadata['azimuthPixelSize'] = Vs*burst.azimuthTimeInterval
refElp = Planet(pname='Earth').ellipsoid
llh = refElp.xyz_to_llh(peg.getPosition())
refElp.setSCH(llh[0], llh[1], orbit.getENUHeading(burst.sensingMid))
metadata['earthRadius'] = refElp.pegRadCur
metadata['altitude'] = llh[2]
# for Sentinel-1
metadata['beam_mode'] = 'IW'
metadata['swathNumber'] = burst.swathNumber
# 1. multipel subswaths
xml_files = glob.glob(os.path.join(os.path.dirname(xml_file), 'IW*.xml'))
if len(xml_files) > 1:
swath_num = [load_product(fname).bursts[0].swathNumber for fname in xml_files]
metadata['swathNumber'] = ''.join(str(i) for i in sorted(swath_num))
# 2. calculate ASF frame number for Sentinel-1
metadata['firstFrameNumber'] = int(0.2 * (burst.burstStartUTC - obj.ascendingNodeTime).total_seconds())
metadata['lastFrameNumber'] = int(0.2 * (burstEnd.burstStopUTC - obj.ascendingNodeTime).total_seconds())
return metadata
def extract_stripmap_metadata(meta_file):
"""Read metadata from shelve file for StripMap stack from ISCE
Parameters: meta_file : str, path of the shelve file, i.e. masterShelve/data.dat
Returns: meta : dict, metadata
"""
import isce
import isceobj
import isceobj.StripmapProc.StripmapProc as St
from isceobj.Planet.Planet import Planet
if os.path.basename(meta_file) == "data.dat": #shelve file from stripmapStack
fbase = os.path.splitext(meta_file)[0]
with shelve.open(fbase, flag='r') as mdb:
frame = mdb['frame']
elif meta_file.endswith(".xml"): #XML file from stripmapApp
frame = load_product(meta_file)
metadata = {}
metadata['prf'] = frame.PRF
metadata['startUTC'] = frame.sensingStart
metadata['stopUTC'] = frame.sensingStop
metadata['radarWavelength'] = frame.radarWavelegth
metadata['rangePixelSize'] = frame.instrument.rangePixelSize
metadata['startingRange'] = frame.startingRange
metadata['polarization'] = frame.polarization.replace('/', '')
if metadata['polarization'].startswith("b'"):
metadata['polarization'] = metadata['polarization'][2:4]
metadata['trackNumber'] = frame.trackNumber
metadata['orbitNumber'] = frame.orbitNumber
time_seconds = (frame.sensingStart.hour*3600.0 +
frame.sensingStart.minute*60.0 +
frame.sensingStart.second)
metadata['CENTER_LINE_UTC'] = time_seconds
orbit = frame.orbit
peg = orbit.interpolateOrbit(frame.sensingMid, method='hermite')
Vs = np.linalg.norm(peg.getVelocity())
metadata['satelliteSpeed'] = Vs
metadata['azimuthPixelSize'] = Vs/frame.PRF
refElp = Planet(pname='Earth').ellipsoid
llh = refElp.xyz_to_llh(peg.getPosition())
refElp.setSCH(llh[0], llh[1], orbit.getENUHeading(frame.sensingMid))
metadata['earthRadius'] = refElp.pegRadCur
metadata['altitude'] = llh[2]
# for StripMap
metadata['beam_mode'] = 'SM'
return metadata
def _populatePlatform(self, **kwargs):
platform = self.frame.getInstrument().getPlatform()
platform.setMission('UAVSAR')
platform.setPointingDirection(
self.lookMap[self.metadata['Look Direction'].upper()])
platform.setPlanet(Planet(pname="Earth"))
platform.setAntennaLength(self.metadata['Antenna Length'])
return
def _populatePlatform(self):
"""Populate the platform object with metadata"""
platform = self.frame.getInstrument().getPlatform()
platform.setMission("ERS" + str(self._imageFileData['PRODUCT'][61]))
platform.setAntennaLength(self.constants['antennaLength'])
platform.setPointingDirection(-1)
platform.setPlanet(Planet(pname='Earth'))
def _populatePlatform(self):
platform = self.frame.getInstrument().getPlatform()
platform.setMission(self.leaderFile.sceneHeaderRecord.metadata[
'Sensor platform mission identifier'])
platform.setPointingDirection(self.constants.pointing_direction)
platform.setAntennaLength(self.constants.antenna_length)
platform.setPlanet(Planet(pname='Earth'))
def runTopoCPU(info, demImage, dop=None, nativedop=False, legendre=False):
from zerodop.topozero import createTopozero
from isceobj.Planet.Planet import Planet
if not os.path.isdir(info.outdir):
os.makedirs(info.outdir)
#####Run Topo
planet = Planet(pname='Earth')
topo = createTopozero()
topo.slantRangePixelSpacing = info.slantRangePixelSpacing
topo.prf = info.prf
topo.radarWavelength = info.radarWavelength
topo.orbit = info.orbit
topo.width = info.width // info.numberRangeLooks
topo.length = info.length // info.numberAzimuthLooks
topo.wireInputPort(name='dem', object=demImage)
topo.wireInputPort(name='planet', object=planet)
topo.numberRangeLooks = info.numberRangeLooks
topo.numberAzimuthLooks = info.numberAzimuthLooks
topo.lookSide = info.lookSide
topo.sensingStart = info.sensingStart + datetime.timedelta(seconds=(
(info.numberAzimuthLooks - 1) / 2) / info.prf)
topo.rangeFirstSample = info.rangeFirstSample + (
(info.numberRangeLooks - 1) / 2) * info.slantRangePixelSpacing
topo.demInterpolationMethod = 'BIQUINTIC'
if legendre:
topo.orbitInterpolationMethod = 'LEGENDRE'
topo.latFilename = info.latFilename
topo.lonFilename = info.lonFilename
topo.losFilename = info.losFilename
topo.heightFilename = info.heightFilename
topo.incFilename = info.incFilename
topo.maskFilename = info.maskFilename
if nativedop and (dop is not None):
try:
coeffs = dop._coeffs
except:
coeffs = dop
doppler = Poly2D()
doppler.setWidth(info.width // info.numberRangeLooks)
doppler.setLength(info.length // info.numberAzimuthLooks)
doppler.initPoly(rangeOrder=len(coeffs) - 1,
azimuthOrder=0,
coeffs=[coeffs])
else:
print('Zero doppler')
doppler = None
topo.polyDoppler = doppler
topo.topo()
return
def _populatePlatform(self):
mdict = self.constants
platform = self.frame.getInstrument().getPlatform()
platform.setMission(mdict['PLATFORM'])
platform.setPlanet(Planet(pname="Earth"))
platform.setPointingDirection(int(mdict['ANTENNA_SIDE']))
platform.setAntennaLength(float(mdict['ANTENNA_LENGTH']))
def _populatePlatform(self):
"""Populate the platform object with metadata"""
platform = self.frame.getInstrument().getPlatform()
# Populate the Platform and Scene objects
platform.setMission("Envisat")
platform.setPointingDirection(-1)
platform.setAntennaLength(self.constants['antennaLength'])
platform.setPlanet(Planet(pname="Earth"))
def runGeo2rdrCPU(info, latImage, lonImage, demImage, outdir,
dop=None, nativedop=False, legendre=False,
azoff=0.0, rgoff=0.0,
alks=1, rlks=1):
from zerodop.geo2rdr import createGeo2rdr
from isceobj.Planet.Planet import Planet
#####Run Geo2rdr
planet = Planet(pname='Earth')
grdr = createGeo2rdr()
grdr.configure()
grdr.slantRangePixelSpacing = info.getInstrument().getRangePixelSize()
grdr.prf = info.getInstrument().getPulseRepetitionFrequency()
grdr.radarWavelength = info.getInstrument().getRadarWavelength()
grdr.orbit = info.getOrbit()
grdr.width = info.getImage().getWidth()
grdr.length = info.getImage().getLength()
grdr.wireInputPort(name='planet', object=planet)
grdr.lookSide = info.instrument.platform.pointingDirection
print(info.sensingStart - datetime.timedelta(seconds = (azoff-(alks-1)/2)/grdr.prf))
print(grdr.prf)
print(info.getStartingRange() - (rgoff - (rlks-1)/2)*grdr.slantRangePixelSpacing)
#print(stop)
grdr.setSensingStart(info.sensingStart - datetime.timedelta(seconds = (azoff-(alks-1)/2)/grdr.prf))
grdr.rangeFirstSample = info.getStartingRange() - (rgoff - (rlks-1)/2)*grdr.slantRangePixelSpacing
grdr.numberRangeLooks = alks
grdr.numberAzimuthLooks = rlks
if nativedop and (dop is not None):
try:
coeffs = [x/grdr.prf for x in dop._coeffs]
except:
coeffs = [x/grdr.prf for x in dop]
grdr.dopplerCentroidCoeffs = coeffs
else:
print('Zero doppler')
grdr.dopplerCentroidCoeffs = [0.]
##### grdr.fmrateCoeffs = [0.] # DOES NOT LOOK to be defined
grdr.rangeOffsetImageName = os.path.join(outdir, 'range.off')
grdr.azimuthOffsetImageName= os.path.join(outdir, 'azimuth.off')
grdr.demImage = demImage
grdr.latImage = latImage
grdr.lonImage = lonImage
grdr.outputPrecision = 'DOUBLE'
if legendre:
grdr.orbitInterpolationMethod = 'LEGENDRE'
grdr.geo2rdr()
return
def _populatePlatform(self):
"""Populate the platform object with metadata"""
platform = self.frame.getInstrument().getPlatform()
# Populate the Platform and Scene objects
platform.setMission(self._xmlFileParser.sensorName)
platform.setPointingDirection(self.lookMap[self._xmlFileParser.sideLooking])
platform.setAntennaLength(9.968)
platform.setPlanet(Planet(pname="Earth"))
def runGeo(frame,
demImage,
inImage,
looks=(1, 1),
doppler=None,
nativedop=False,
bbox=None,
method='nearest'):
from zerodop.geozero import createGeozero
from isceobj.Planet.Planet import Planet
#####Run Topo
planet = Planet(pname='Earth')
topo = createGeozero()
topo.configure()
alooks = looks[0]
rlooks = looks[1]
tStart = frame.sensingStart
topo.slantRangePixelSpacing = frame.getInstrument().getRangePixelSize()
topo.prf = frame.getInstrument().getPulseRepetitionFrequency()
topo.radarWavelength = frame.getInstrument().getRadarWavelength()
topo.orbit = frame.orbit
topo.width = inImage.getWidth()
topo.length = inImage.getLength()
topo.wireInputPort(name='dem', object=demImage)
topo.wireInputPort(name='planet', object=planet)
topo.wireInputPort(name='tobegeocoded', object=inImage)
topo.numberRangeLooks = rlooks
topo.numberAzimuthLooks = alooks
topo.lookSide = frame.instrument.platform.pointingDirection()
topo.setSensingStart(tStart)
topo.rangeFirstSample = frame.startingRange
topo.method = method
topo.demCropFilename = 'crop.dem'
topo.geoFilename = inImage.filename + '.geo'
if inps.nativedop and (doppler is not None):
try:
topo.dopplerCentroidCoeffs = [
x / topo.prf for x in doppler._coeffs
]
except:
topo.dopplerCentroidCoeffs = [x / topo.prf for x in doppler]
else:
topo.dopplerCentroidCoeffs = [0.]
topo.snwe = bbox
topo.geocode()
print('South: ', topo.minimumGeoLatitude)
print('North: ', topo.maximumGeoLatitude)
print('West: ', topo.minimumGeoLongitude)
print('East: ', topo.maximumGeoLongitude)
return
def _populatePlatform(self, **kwargs):
# print("UAVSAR_RPI._populatePlatform")
platform = self.frame.getInstrument().getPlatform()
platform.setMission('UAVSAR')
platform.setPointingDirection(
self.lookMap[self.metadata['Radar Look Direction'].upper()])
platform.setPlanet(Planet(pname="Earth"))
platform.setAntennaLength(1.5) # Thierry Michel
return
def setUp(self):
# These are the state vectors for ERS-1 track 113 frame 2745 from 1993 01 09 near the scene start time
self.pos = [-2503782.263, -4652987.799, 4829281.081]
self.vel = [-4002.34200000018, -3450.91900000069, -5392.36600000039]
self.range = 831929.866545593
self.squint = 0.298143953340833
planet = Planet(pname='Earth')
self.geolocate = Geolocate()
self.geolocate.wireInputPort(name='planet', object=planet)
def extractIsceMetadata(shelveFile):
with shelve.open(shelveFile, flag='r') as mdb:
burst = mdb['frame']
#reference = ut.loadProduct(shelveFile)
#burst = reference.bursts[0]
#burstEnd = reference.bursts[-1]
metadata = {}
metadata['radarWavelength'] = burst.radarWavelegth
metadata['rangePixelSize'] = burst.instrument.rangePixelSize
metadata['prf'] = burst.PRF
metadata['startUTC'] = burst.sensingStart
metadata['stopUTC'] = burst.sensingStop
metadata['startingRange'] = burst.startingRange
time_seconds = burst.sensingStart.hour * 3600.0 + burst.sensingStart.minute * 60.0 + burst.sensingStart.second
metadata['CENTER_LINE_UTC'] = time_seconds
Vs = np.linalg.norm(
burst.orbit.interpolateOrbit(burst.sensingMid,
method='hermite').getVelocity())
metadata['satelliteSpeed'] = Vs
metadata['azimuthTimeInterval'] = 1. / burst.PRF #azimuthTimeInterval
metadata['azimuthPixelSize'] = Vs * metadata[
'azimuthTimeInterval'] #burst.azimuthTimeInterval
#metadata['azimuthPixelSize'] = burst.instrument.azimuthPixelSize
tstart = burst.sensingStart
tend = burst.sensingStop
tmid = tstart + 0.5 * (tend - tstart)
orbit = burst.orbit
peg = orbit.interpolateOrbit(tmid, method='hermite')
refElp = Planet(pname='Earth').ellipsoid
llh = refElp.xyz_to_llh(peg.getPosition())
hdg = orbit.getENUHeading(tmid)
refElp.setSCH(llh[0], llh[1], hdg)
metadata['earthRadius'] = refElp.pegRadCur
metadata['altitude'] = llh[2]
return metadata
def runGeo2rdr(info, rdict, misreg_az=0.0, misreg_rg=0.0, virtual=False):
from zerodop.geo2rdr import createGeo2rdr
from isceobj.Planet.Planet import Planet
latImage = isceobj.createImage()
latImage.load(rdict['lat'] + '.xml')
latImage.setAccessMode('READ')
latImage.createImage()
lonImage = isceobj.createImage()
lonImage.load(rdict['lon'] + '.xml')
lonImage.setAccessMode('READ')
lonImage.createImage()
demImage = isceobj.createImage()
demImage.load(rdict['hgt'] + '.xml')
demImage.setAccessMode('READ')
demImage.createImage()
delta = datetime.timedelta(seconds=misreg_az)
logger.info('Additional time offset applied in geo2rdr: {0} secs'.format(
misreg_az))
logger.info(
'Additional range offset applied in geo2rdr: {0} m'.format(misreg_rg))
#####Run Geo2rdr
planet = Planet(pname='Earth')
grdr = createGeo2rdr()
grdr.configure()
grdr.slantRangePixelSpacing = info.rangePixelSize
grdr.prf = 1.0 / info.azimuthTimeInterval
grdr.radarWavelength = info.radarWavelength
grdr.orbit = info.orbit
grdr.width = info.numberOfSamples
grdr.length = info.numberOfLines
grdr.demLength = demImage.getLength()
grdr.demWidth = demImage.getWidth()
grdr.wireInputPort(name='planet', object=planet)
grdr.numberRangeLooks = 1
grdr.numberAzimuthLooks = 1
grdr.lookSide = -1
grdr.setSensingStart(info.sensingStart - delta)
grdr.rangeFirstSample = info.startingRange - misreg_rg
grdr.dopplerCentroidCoeffs = [0.] ###Zero doppler
grdr.rangeOffsetImageName = rdict['rangeOffName']
grdr.azimuthOffsetImageName = rdict['azOffName']
grdr.demImage = demImage
grdr.latImage = latImage
grdr.lonImage = lonImage
grdr.geo2rdr()
return
def runGeo(frame, demImage, inImage, bbox, rlks, alks, method, outputName, aff,
topShift, leftShift):
from zerodop.geozero import createGeozero
from isceobj.Planet.Planet import Planet
#####Run Topo
planet = Planet(pname='Earth')
topo = createGeozero()
topo.configure()
topo.slantRangePixelSpacing = 0.5 * SPEED_OF_LIGHT / frame.rangeSamplingRate
topo.prf = frame.PRF #should be changed to reciprocal of azimuth time interval for burst mode!!!
topo.radarWavelength = frame.radarWavelegth
topo.orbit = frame.getOrbit()
topo.width = frame.getNumberOfSamples()
topo.length = frame.getNumberOfLines()
topo.wireInputPort(name='dem', object=demImage)
topo.wireInputPort(name='planet', object=planet)
topo.wireInputPort(name='tobegeocoded', object=inImage)
topo.numberRangeLooks = rlks
topo.numberAzimuthLooks = alks
#topo.lookSide = -1
topo.lookSide = frame.getInstrument().getPlatform().pointingDirection
topo.setSensingStart(frame.getSensingStart())
topo.rangeFirstSample = frame.startingRange
topo.method = method
topo.demCropFilename = 'crop.dem'
topo.geoFilename = outputName
topo.dopplerCentroidCoeffs = [0.]
topo.snwe = bbox
##############
topo.ATCa = aff.a
topo.ATCb = aff.b
topo.ATCc = aff.c
topo.ATCd = aff.d
topo.ATCe = aff.e
topo.ATCf = aff.f
topo.ATCrlks = aff.rlks
topo.ATCalks = aff.alks
##############
##consider the shifts
topo.rangeFirstSample += leftShift * topo.slantRangePixelSpacing
topo.setSensingStart(frame.getSensingStart() +
datetime.timedelta(seconds=(topShift / topo.prf)))
topo.geocode()
print('South: ', topo.minimumGeoLatitude)
print('North: ', topo.maximumGeoLatitude)
print('West: ', topo.minimumGeoLongitude)
print('East: ', topo.maximumGeoLongitude)
return
def geocode(track, demFile, inputFile, bbox, numberRangeLooks, numberAzimuthLooks, interpMethod, topShift, leftShift, addMultilookOffset=True):
import datetime
from zerodop.geozero import createGeozero
from isceobj.Planet.Planet import Planet
pointingDirection = {'right': -1, 'left' :1}
demImage = isceobj.createDemImage()
demImage.load(demFile + '.xml')
demImage.setAccessMode('read')
inImage = isceobj.createImage()
inImage.load(inputFile + '.xml')
inImage.setAccessMode('read')
planet = Planet(pname='Earth')
topo = createGeozero()
topo.configure()
topo.slantRangePixelSpacing = numberRangeLooks * track.rangePixelSize
topo.prf = 1.0 / (numberAzimuthLooks*track.azimuthLineInterval)
topo.radarWavelength = track.radarWavelength
topo.orbit = track.orbit
topo.width = inImage.width
topo.length = inImage.length
topo.wireInputPort(name='dem', object=demImage)
topo.wireInputPort(name='planet', object=planet)
topo.wireInputPort(name='tobegeocoded', object=inImage)
topo.numberRangeLooks = 1
topo.numberAzimuthLooks = 1
topo.lookSide = pointingDirection[track.pointingDirection]
sensingStart = track.sensingStart + datetime.timedelta(seconds=topShift*track.azimuthLineInterval)
rangeFirstSample = track.startingRange + leftShift * track.rangePixelSize
if addMultilookOffset:
sensingStart += datetime.timedelta(seconds=(numberAzimuthLooks-1.0)/2.0*track.azimuthLineInterval)
rangeFirstSample += (numberRangeLooks-1.0)/2.0*track.rangePixelSize
topo.setSensingStart(sensingStart)
topo.rangeFirstSample = rangeFirstSample
topo.method=interpMethod
topo.demCropFilename = 'crop.dem'
#looks like this does not work
#topo.geoFilename = outputName
topo.dopplerCentroidCoeffs = [0.]
#snwe list <class 'list'>
topo.snwe = bbox
topo.geocode()
print('South: ', topo.minimumGeoLatitude)
print('North: ', topo.maximumGeoLatitude)
print('West: ', topo.minimumGeoLongitude)
print('East: ', topo.maximumGeoLongitude)
return
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 __init__(self, name='', num=None, order=None, planet=None):
super(OrbitExtender,self).__init__(family=self.__class__.family, name=name)
if num is not None:
self._newPoints = int(num)
if order is not None:
self._polyOrder = int(order)
if planet is not None:
self._planet = planet
else:
self._planet = Planet('Earth')
def geo2RdrCPU(secondaryTrack, numberRangeLooks, numberAzimuthLooks, latFile,
lonFile, hgtFile, rangeOffsetFile, azimuthOffsetFile):
import datetime
from zerodop.geo2rdr import createGeo2rdr
from isceobj.Planet.Planet import Planet
pointingDirection = {'right': -1, 'left': 1}
latImage = isceobj.createImage()
latImage.load(latFile + '.xml')
latImage.setAccessMode('read')
lonImage = isceobj.createImage()
lonImage.load(lonFile + '.xml')
lonImage.setAccessMode('read')
demImage = isceobj.createDemImage()
demImage.load(hgtFile + '.xml')
demImage.setAccessMode('read')
planet = Planet(pname='Earth')
topo = createGeo2rdr()
topo.configure()
#set parameters
topo.slantRangePixelSpacing = numberRangeLooks * secondaryTrack.rangePixelSize
topo.prf = 1.0 / (numberAzimuthLooks * secondaryTrack.azimuthLineInterval)
topo.radarWavelength = secondaryTrack.radarWavelength
topo.orbit = secondaryTrack.orbit
topo.width = secondaryTrack.numberOfSamples
topo.length = secondaryTrack.numberOfLines
topo.demLength = demImage.length
topo.demWidth = demImage.width
topo.wireInputPort(name='planet', object=planet)
topo.numberRangeLooks = 1 #
topo.numberAzimuthLooks = 1 # must be set to be 1
topo.lookSide = pointingDirection[secondaryTrack.pointingDirection]
topo.setSensingStart(secondaryTrack.sensingStart + datetime.timedelta(
seconds=(numberAzimuthLooks - 1.0) / 2.0 *
secondaryTrack.azimuthLineInterval))
topo.rangeFirstSample = secondaryTrack.startingRange + (
numberRangeLooks - 1.0) / 2.0 * secondaryTrack.rangePixelSize
topo.dopplerCentroidCoeffs = [0.] # we are using zero doppler geometry
#set files
topo.latImage = latImage
topo.lonImage = lonImage
topo.demImage = demImage
topo.rangeOffsetImageName = rangeOffsetFile
topo.azimuthOffsetImageName = azimuthOffsetFile
#run it
topo.geo2rdr()
return
def testConvertSCHdot(self):
elp = Planet("Earth").get_elp()
elp.setSCH(66.0, -105.0, 36.0)
#From for_ellipsoid_test.F
#convert_schdot_to_xyzdot, sch_to_xyz
r_sch = [1468.0, -234.0, 7000.0]
r_schdot = [800.0, -400.0, 100.0]
r_xyz = [-672788.46258740244, -2514950.4839521507, 5810769.7976823179]
r_xyzdot = [853.73728655948685, 118.98447071885982, 258.79594191185748]
posXYZ, velXYZ = elp.schdot_to_xyzdot(r_sch, r_schdot)
for (a, b) in zip(r_xyz, posXYZ):
self.assertAlmostEqual(a, b, places=3)
for (a, b) in zip(r_xyzdot, velXYZ):
self.assertAlmostEqual(a, b, places=3)
#convert_schdot_to_xyzdot, xyz_to_sch
r_xyz = [-672100.0, -2514000.0, 5811000.0]
r_xyzdot = [800.0, -400.0, 100.0]
r_sch = [2599.1237664792707, 70.396218844576666, 6764.7576835183427]
r_schdot = [
415.39842327248573, -781.28909619852459, 164.41258499283407
]
posSCH, velSCH = elp.xyzdot_to_schdot(r_xyz, r_xyzdot)
for (a, b) in zip(r_sch, posSCH):
self.assertAlmostEqual(a, b, places=3)
for (a, b) in zip(r_schdot, velSCH):
self.assertAlmostEqual(a, b, delta=0.1)
def extractInfo(xmlName, inps):
'''
Extract required information from pickle file.
'''
from isceobj.Planet.Planet import Planet
from isceobj.Util.geo.ellipsoid import Ellipsoid
frame = ut.loadProduct(xmlName)
burst = frame.bursts[0]
planet = Planet(pname='Earth')
elp = Ellipsoid(planet.ellipsoid.a, planet.ellipsoid.e2, 'WGS84')
data = {}
data['wavelength'] = burst.radarWavelength
tstart = frame.bursts[0].sensingStart
tend = frame.bursts[-1].sensingStop
#tmid = tstart + 0.5*(tend - tstart)
tmid = tstart
orbit = burst.orbit
peg = orbit.interpolateOrbit(tmid, method='hermite')
refElp = Planet(pname='Earth').ellipsoid
llh = refElp.xyz_to_llh(peg.getPosition())
hdg = orbit.getENUHeading(tmid)
refElp.setSCH(llh[0], llh[1], hdg)
earthRadius = refElp.pegRadCur
altitude = llh[2]
#sv = burst.orbit.interpolateOrbit(tmid, method='hermite')
#pos = sv.getPosition()
#llh = elp.ECEF(pos[0], pos[1], pos[2]).llh()
data['altitude'] = altitude #llh.hgt
#hdg = burst.orbit.getHeading()
data['earthRadius'] = earthRadius #elp.local_radius_of_curvature(llh.lat, hdg)
#azspacing = burst.azimuthTimeInterval * sv.getScalarVelocity()
#azres = 20.0
#corrfile = os.path.join(self._insar.mergedDirname, self._insar.coherenceFilename)
rangeLooks = inps.rglooks
azimuthLooks = inps.azlooks
azfact = 0.8
rngfact = 0.8
corrLooks = rangeLooks * azimuthLooks/(azfact*rngfact)
data['corrlooks'] = corrLooks #inps.rglooks * inps.azlooks * azspacing / azres
data['rglooks'] = inps.rglooks
data['azlooks'] = inps.azlooks
return data
def extractIsceMetadata(xmlFile):
master = ut.loadProduct(xmlFile)
burst = master.bursts[0]
burstEnd = master.bursts[-1]
metadata = {}
metadata['radarWavelength'] = burst.radarWavelength
metadata['rangePixelSize'] = burst.rangePixelSize
metadata['prf'] = burst.prf
metadata['startUTC'] = burst.burstStartUTC
metadata['stopUTC'] = burstEnd.burstStopUTC
metadata['startingRange'] = burst.startingRange
time_seconds = burst.burstStartUTC.hour * 3600.0 + burst.burstStartUTC.minute * 60.0 + burst.burstStartUTC.second
metadata['CENTER_LINE_UTC'] = time_seconds
Vs = np.linalg.norm(
burst.orbit.interpolateOrbit(burst.sensingMid,
method='hermite').getVelocity())
metadata['satelliteSpeed'] = Vs
metadata['azimuthTimeInterval'] = burst.azimuthTimeInterval
metadata['azimuthPixelSize'] = Vs * burst.azimuthTimeInterval
tstart = burst.sensingStart
tend = burstEnd.sensingStop
tmid = tstart + 0.5 * (tend - tstart)
orbit = burst.orbit
peg = orbit.interpolateOrbit(tmid, method='hermite')
refElp = Planet(pname='Earth').ellipsoid
llh = refElp.xyz_to_llh(peg.getPosition())
hdg = orbit.getENUHeading(tmid)
refElp.setSCH(llh[0], llh[1], hdg)
metadata['earthRadius'] = refElp.pegRadCur
metadata['altitude'] = llh[2]
return metadata
def create_georectified_lat_lon(swathList, reference, outdir, demZero,
load_function):
""" export geo rectified latitude and longitude """
for swath in swathList:
reference = load_function(
os.path.join(reference, 'IW{0}.xml'.format(swath)))
###Check if geometry directory already exists.
dirname = os.path.join(outdir, 'IW{0}'.format(swath))
if os.path.isdir(dirname):
print('Geometry directory {0} already exists.'.format(dirname))
else:
os.makedirs(dirname)
###For each burst
for ind in range(reference.numberOfBursts):
burst = reference.bursts[ind]
latname = os.path.join(dirname, 'lat_%02d.rdr' % (ind + 1))
lonname = os.path.join(dirname, 'lon_%02d.rdr' % (ind + 1))
hgtname = os.path.join(dirname, 'hgt_%02d.rdr' % (ind + 1))
losname = os.path.join(dirname, 'los_%02d.rdr' % (ind + 1))
if not (os.path.exists(latname + '.xml')
or os.path.exists(lonname + '.xml')):
#####Run Topo
planet = Planet(pname='Earth')
topo = createTopozero()
topo.slantRangePixelSpacing = burst.rangePixelSize
topo.prf = 1.0 / burst.azimuthTimeInterval
topo.radarWavelength = burst.radarWavelength
topo.orbit = burst.orbit
topo.width = burst.numberOfSamples
topo.length = burst.numberOfLines
topo.wireInputPort(name='dem', object=demZero)
topo.wireInputPort(name='planet', object=planet)
topo.numberRangeLooks = 1
topo.numberAzimuthLooks = 1
topo.lookSide = -1
topo.sensingStart = burst.sensingStart
topo.rangeFirstSample = burst.startingRange
topo.demInterpolationMethod = 'BIQUINTIC'
topo.latFilename = latname
topo.lonFilename = lonname
topo.heightFilename = hgtname
topo.losFilename = losname
topo.topo()
return
def _populatePlatform(self, file):
platform = self.frame.getInstrument().getPlatform()
platform.setMission(
file['/science/LSAR/identification'].get('missionId')[(
)].decode('utf-8'))
platform.setPointingDirection(
self.lookMap[file['/science/LSAR/identification'].get(
'lookDirection')[()].decode('utf-8')])
platform.setPlanet(Planet(pname="Earth"))
# We are not using this value anywhere. Let's fix it for now.
platform.setAntennaLength(12.0)
def computeBaseline(trackReference, trackSecondary, azimuthTime,
rangeDistance):
import numpy as np
from isceobj.Planet.Planet import Planet
#modify Piyush's code for computing baslines
refElp = Planet(pname='Earth').ellipsoid
#for x in points:
referenceSV = trackReference.orbit.interpolate(azimuthTime,
method='hermite')
target = trackReference.orbit.rdr2geo(azimuthTime, rangeDistance)
slvTime, slvrng = trackSecondary.orbit.geo2rdr(target)
secondarySV = trackSecondary.orbit.interpolateOrbit(slvTime,
method='hermite')
targxyz = np.array(
refElp.LLH(target[0], target[1], target[2]).ecef().tolist())
mxyz = np.array(referenceSV.getPosition())
mvel = np.array(referenceSV.getVelocity())
sxyz = np.array(secondarySV.getPosition())
#to fix abrupt change near zero in baseline grid. JUN-05-2020
mvelunit = mvel / np.linalg.norm(mvel)
sxyz = sxyz - np.dot(sxyz - mxyz, mvelunit) * mvelunit
aa = np.linalg.norm(sxyz - mxyz)
costheta = (rangeDistance * rangeDistance + aa * aa -
slvrng * slvrng) / (2. * rangeDistance * aa)
Bpar = aa * costheta
perp = aa * np.sqrt(1 - costheta * costheta)
direction = np.sign(np.dot(np.cross(targxyz - mxyz, sxyz - mxyz), mvel))
Bperp = direction * perp
return (Bpar, Bperp)
def topo(burst, time, Range, doppler=0, wvl=0.056):
'''Function that return the lon lat information for a given time, range, and doppler'''
###Planet parameters
elp = Planet(pname='Earth').ellipsoid
# Provide a zero doppler polygon in case 0 is given
if doppler is 0:
doppler = Poly2D()
doppler.initPoly(rangeOrder=1, azimuthOrder=0, coeffs=[[0, 0]])
# compute the lonlat grid
latlon = burst.orbit.rdr2geo(time, Range, doppler=doppler, wvl=wvl)
return latlon
def _populatePlatform(self, file):
platform = self.frame.getInstrument().getPlatform()
platform.setMission(file['satellite_name'][()])
platform.setPointingDirection(
self.lookMap[file['look_side'][()].upper()])
platform.setPlanet(Planet(pname="Earth"))
####This is an approximation for spotlight mode
####In spotlight mode, antenna length changes with azimuth position
platform.setAntennaLength(2 * file['azimuth_ground_spacing'][()])
assert (file['range_looks'][()] == 1)
assert (file['azimuth_looks'][()] == 1)
class PegInfoFactory:
@staticmethod
def createPegInfo(band, track, dire, latS, latE, pegLat, pegLon, hdg):
PI = PegInfo()
PI._pegBandIndx = band
PI._track = track
PI._direction = dire
PI._latStart = latS
PI._latEnd = latE
PI._peg = PegFactory.fromEllipsoid(Coordinate(pegLat, pegLon), hdg,
PegInfoFactory._Planet.get_elp())
return PI
_Planet = Planet(pname='Earth')
def runGeo2rdr(frame,
latImage,
lonImage,
demImage,
rgoffName='range.off',
azoffName='azimuth.off',
rlks=1,
alks=1):
from zerodop.geo2rdr import createGeo2rdr
from isceobj.Planet.Planet import Planet
#create topo
planet = Planet(pname='Earth')
topo = createGeo2rdr()
topo.configure()
#set parameters
topo.slantRangePixelSpacing = rlks * 0.5 * SPEED_OF_LIGHT / frame.rangeSamplingRate
topo.prf = frame.PRF / alks #!!!should be changed to azimuth time interval for burst mode
topo.radarWavelength = frame.radarWavelegth
topo.orbit = frame.getOrbit()
topo.width = int(frame.getNumberOfSamples() / rlks)
topo.length = int(frame.getNumberOfLines() / alks)
topo.demLength = demImage.length
topo.demWidth = demImage.width
topo.wireInputPort(name='planet', object=planet)
topo.numberRangeLooks = 1 #
topo.numberAzimuthLooks = 1 # must be set to be 1
#topo.lookSide = -1
topo.lookSide = frame.getInstrument().getPlatform().pointingDirection
topo.setSensingStart(frame.getSensingStart() +
datetime.timedelta(seconds=(alks - 1.0) / 2.0 *
(1.0 / frame.PRF)))
topo.rangeFirstSample = frame.startingRange + (rlks - 1.0) / 2.0 * (
0.5 * SPEED_OF_LIGHT / frame.rangeSamplingRate)
topo.dopplerCentroidCoeffs = [0.] # we are using zero doppler geometry
#set files
topo.demImage = demImage
topo.latImage = latImage
topo.lonImage = lonImage
topo.rangeOffsetImageName = rgoffName
topo.azimuthOffsetImageName = azoffName
#run it
topo.geo2rdr()
return
def _populatePlatform(self, file=None):
platform = self.frame.getInstrument().getPlatform()
if np.isnan(file['S01'].attrs['Equivalent First Column Time']) and (
len(file['S01/B001'].attrs['Range First Times']) > 1):
raise NotImplementedError(
'Current CSK reader does not handle RAW data not adjusted for SWST shifts'
)
platform.setMission(
file.attrs['Satellite ID']) # Could use Mission ID as well
platform.setPlanet(Planet(pname="Earth"))
platform.setPointingDirection(
self.lookMap[file.attrs['Look Side'].decode('utf-8')])
platform.setAntennaLength(file.attrs['Antenna Length'])
def _populatePlatform(self, file):
platform = self.frame.getInstrument().getPlatform()
platform.setMission(file.attrs['Satellite ID'])
platform.setPointingDirection(self.lookMap[file.attrs['Look Side'].decode('utf-8')])
platform.setPlanet(Planet("Earth"))
####This is an approximation for spotlight mode
####In spotlight mode, antenna length changes with azimuth position
platform.setAntennaLength(file.attrs['Antenna Length'])
try:
if file.attrs['Multi-Beam ID'].startswith('ES'):
platform.setAntennaLength(16000.0/file['S01/SBI'].attrs['Line Time Interval'])
except:
pass
