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 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 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 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 runGeo2rdr(self):
from zerodop.geo2rdr import createGeo2rdr
from isceobj.Planet.Planet import Planet
logger.info("Running geo2rdr")
info = self._insar.loadProduct(self._insar.secondarySlcCropProduct)
offsetsDir = self.insar.offsetsDirname
os.makedirs(offsetsDir, exist_ok=True)
grdr = createGeo2rdr()
grdr.configure()
planet = info.getInstrument().getPlatform().getPlanet()
grdr.slantRangePixelSpacing = info.getInstrument().getRangePixelSize()
grdr.prf = info.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
grdr.setSensingStart(info.getSensingStart())
grdr.rangeFirstSample = info.startingRange
grdr.numberRangeLooks = 1
grdr.numberAzimuthLooks = 1
if self.insar.secondaryGeometrySystem.lower().startswith('native'):
p = [x / info.PRF for x in info._dopplerVsPixel]
else:
p = [0.]
grdr.dopplerCentroidCoeffs = p
grdr.fmrateCoeffs = [0.]
###Input and output files
grdr.rangeOffsetImageName = os.path.join(offsetsDir,
self.insar.rangeOffsetFilename)
grdr.azimuthOffsetImageName = os.path.join(
offsetsDir, self.insar.azimuthOffsetFilename)
latFilename = os.path.join(self.insar.geometryDirname,
self.insar.latFilename + '.full')
lonFilename = os.path.join(self.insar.geometryDirname,
self.insar.lonFilename + '.full')
heightFilename = os.path.join(self.insar.geometryDirname,
self.insar.heightFilename + '.full')
demImg = isceobj.createImage()
demImg.load(heightFilename + '.xml')
demImg.setAccessMode('READ')
grdr.demImage = demImg
latImg = isceobj.createImage()
latImg.load(latFilename + '.xml')
latImg.setAccessMode('READ')
grdr.latImage = latImg
lonImg = isceobj.createImage()
lonImg.load(lonFilename + '.xml')
lonImg.setAccessMode('READ')
grdr.lonImage = lonImg
grdr.outputPrecision = 'DOUBLE'
grdr.geo2rdr()
return
def geo2rdr(swath,
track,
latFile,
lonFile,
hgtFile,
rangeOffsetFile,
azimuthOffsetFile,
numberRangeLooks=1,
numberAzimuthLooks=1,
multilookTimeOffset=True):
import datetime
import isceobj
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')
hgtImage = isceobj.createDemImage()
hgtImage.load(hgtFile + '.xml')
hgtImage.setAccessMode('read')
planet = Planet(pname='Earth')
topo = createGeo2rdr()
topo.configure()
topo.slantRangePixelSpacing = numberRangeLooks * swath.rangePixelSize
topo.prf = 1.0 / (numberAzimuthLooks * swath.azimuthLineInterval)
topo.radarWavelength = track.radarWavelength
topo.orbit = track.orbit
topo.width = int(swath.numberOfSamples / numberRangeLooks)
topo.length = int(swath.numberOfLines / numberAzimuthLooks)
topo.demLength = hgtImage.length
topo.demWidth = hgtImage.width
topo.wireInputPort(name='planet', object=planet)
topo.numberRangeLooks = 1
topo.numberAzimuthLooks = 1 #must be set to be 1
topo.lookSide = pointingDirection[track.pointingDirection]
if multilookTimeOffset == True:
topo.sensingStart = swath.sensingStart + datetime.timedelta(
seconds=(numberAzimuthLooks - 1.0) / 2.0 *
swath.azimuthLineInterval)
topo.rangeFirstSample = swath.startingRange + (
numberRangeLooks - 1.0) / 2.0 * swath.rangePixelSize
else:
topo.setSensingStart(swath.sensingStart)
topo.rangeFirstSample = swath.startingRange
topo.dopplerCentroidCoeffs = [0.] #we are using zero doppler geometry
topo.demImage = hgtImage
topo.latImage = latImage
topo.lonImage = lonImage
topo.rangeOffsetImageName = rangeOffsetFile
topo.azimuthOffsetImageName = azimuthOffsetFile
topo.geo2rdr()
return
def runGeo2rdr(self):
from zerodop.geo2rdr import createGeo2rdr
from isceobj.Planet.Planet import Planet
logger.info("Running geo2rdr")
info = self.insar.slaveFrame
slc = self.insar.formSLC2
intImage = slc.slcImage
topo = createGeo2rdr()
topo.configure()
planet = info.getInstrument().getPlatform().getPlanet()
topo.slantRangePixelSpacing = info.getInstrument().getRangePixelSize()
topo.prf = info.getInstrument().getPulseRepetitionFrequency()
topo.radarWavelength = info.getInstrument().getRadarWavelength()
topo.orbit = info.getOrbit()
topo.width = intImage.getWidth()
topo.length = intImage.getLength()
topo.wireInputPort(name='planet', object=planet)
topo.lookSide = info.instrument.platform.pointingDirection
topo.setSensingStart(slc.slcSensingStart)
topo.rangeFirstSample = slc.startingRange
topo.numberRangeLooks = 1
topo.numberAzimuthLooks = 1
if 'native' in self.insar.slaveGeometrySystem.lower():
print('Native doppler')
dop = info._dopplerVsPixel[::-1]
xx = np.linspace(0, (topo.width - 1), num=len(dop) + 1)
x = (topo.rangeFirstSample - info.startingRange
) / topo.slantRangePixelSpacing + xx * topo.numberRangeLooks
v = np.polyval(dop, x)
p = np.polyfit(xx, v, len(dop) - 1)[::-1] / topo.prf
p = list(p)
else:
print('Zero doppler')
p = [0.]
topo.dopplerCentroidCoeffs = p
topo.fmrateCoeffs = [0.]
###Input and output files
topo.rangeOffsetImageName = self.insar.rangeOffsetImageName
topo.azimuthOffsetImageName = self.insar.azimuthOffsetImageName
demImg = isceobj.createImage()
demImg.load(self.insar.heightFilename + '.xml')
demImg.setAccessMode('READ')
topo.demImage = demImg
latImg = isceobj.createImage()
latImg.load(self.insar.latFilename + '.xml')
latImg.setAccessMode('READ')
topo.latImage = latImg
lonImg = isceobj.createImage()
lonImg.load(self.insar.lonFilename + '.xml')
lonImg.setAccessMode('READ')
topo.lonImage = lonImg
topo.geo2rdr()
return
def runCorrect(self):
from zerodop.geo2rdr import createGeo2rdr
logger.info("Running correct")
info = self._insar.slaveFrame
slc = self.insar.formSLC2
intImage = self.insar.topoIntImage.clone()
planet = info.instrument.platform.planet
correct = createGeo2rdr()
correct.configure()
correct.slantRangePixelSpacing = 0.5 * SPEED_OF_LIGHT / info.rangeSamplingRate
correct.prf = info.instrument.PRF
correct.radarWavelength = info.instrument.radarWavelength
correct.orbit = info.orbit
correct.wireInputPort(name='planet', object=planet)
correct.numberRangeLooks = self.insar.numberRangeLooks
correct.numberAzimuthLooks = self.insar.numberAzimuthLooks
correct.lookSide = info.instrument.platform.pointingDirection
correct.fmrateCoeffs = [0.]
correct.setSensingStart(slc.slcSensingStart + datetime.timedelta(
seconds=0.5 * (self.insar.numberAzimuthLooks - 1) / correct.prf))
correct.rangeFirstSample = slc.startingRange + 0.5 * (
self.insar.numberRangeLooks - 1) * correct.slantRangePixelSpacing
demImage = isceobj.createImage()
demImage.load(self.insar.heightFilename + '.xml')
demImage.setAccessMode('READ')
latImage = isceobj.createImage()
latImage.load(self.insar.latFilename + '.xml')
latImage.setAccessMode('READ')
lonImage = isceobj.createImage()
lonImage.load(self.insar.lonFilename + '.xml')
lonImage.setAccessMode('READ')
correct.width = latImage.getWidth()
correct.length = latImage.getLength()
correct.demImage = demImage
correct.latImage = latImage
correct.lonImage = lonImage
correct.rangeOffsetImageName = 'range.off'
####Compute the native doppler polynomial
dop = info._dopplerVsPixel[::-1]
xx = np.linspace(0, (slc.slcImage.width - 1), num=len(dop) + 1)
x = (slc.startingRange -
info.startingRange) / correct.slantRangePixelSpacing + xx
v = np.polyval(dop, x)
p = np.polyfit(xx, v, len(dop) - 1)[::-1]
print(p)
correct.dopplerCentroidCoeffs = list(p)
correct.geo2rdr()
flattenWithOffsets(intImage.filename, 'range.off',
self.insar.topophaseFlatFilename, info,
correct.numberRangeLooks)
return correct
