def runIonSubband(self):
'''create subband interferograms
'''
catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name)
self.updateParamemetersFromUser()
if not self.doIon:
catalog.printToLog(logger, "runIonSubband")
self._insar.procDoc.addAllFromCatalog(catalog)
return
referenceTrack = self._insar.loadTrack(reference=True)
secondaryTrack = self._insar.loadTrack(reference=False)
#using 1/3, 1/3, 1/3 band split
radarWavelength = referenceTrack.radarWavelength
rangeBandwidth = referenceTrack.frames[0].swaths[0].rangeBandwidth
rangeSamplingRate = referenceTrack.frames[0].swaths[0].rangeSamplingRate
radarWavelengthLower = SPEED_OF_LIGHT / (SPEED_OF_LIGHT / radarWavelength -
rangeBandwidth / 3.0)
radarWavelengthUpper = SPEED_OF_LIGHT / (SPEED_OF_LIGHT / radarWavelength +
rangeBandwidth / 3.0)
subbandRadarWavelength = [radarWavelengthLower, radarWavelengthUpper]
subbandBandWidth = [
rangeBandwidth / 3.0 / rangeSamplingRate,
rangeBandwidth / 3.0 / rangeSamplingRate
]
subbandFrequencyCenter = [
-rangeBandwidth / 3.0 / rangeSamplingRate,
rangeBandwidth / 3.0 / rangeSamplingRate
]
subbandPrefix = ['lower', 'upper']
'''
ionDir = {
ionDir['swathMosaic'] : 'mosaic',
ionDir['insar'] : 'insar',
ionDir['ion'] : 'ion',
ionDir['subband'] : ['lower', 'upper'],
ionDir['ionCal'] : 'ion_cal'
}
'''
#define upper level directory names
ionDir = defineIonDir()
self._insar.subbandRadarWavelength = subbandRadarWavelength
############################################################
# STEP 1. create directories
############################################################
#create and enter 'ion' directory
#after finishing each step, we are in this directory
os.makedirs(ionDir['ion'], exist_ok=True)
os.chdir(ionDir['ion'])
#create insar processing directories
for k in range(2):
subbandDir = ionDir['subband'][k]
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
for j, swathNumber in enumerate(
range(self._insar.startingSwath,
self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
fullDir = os.path.join(subbandDir, frameDir, swathDir)
os.makedirs(fullDir, exist_ok=True)
#create ionospheric phase directory
os.makedirs(ionDir['ionCal'])
############################################################
# STEP 2. create subband interferograms
############################################################
import shutil
import numpy as np
from contrib.alos2proc.alos2proc import rg_filter
from isceobj.Alos2Proc.Alos2ProcPublic import resampleBursts
from isceobj.Alos2Proc.Alos2ProcPublic import mosaicBurstAmplitude
from isceobj.Alos2Proc.Alos2ProcPublic import mosaicBurstInterferogram
from isceobj.Alos2Proc.Alos2ProcPublic import create_xml
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
for j, swathNumber in enumerate(
range(self._insar.startingSwath, self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
#filter reference and secondary images
for burstPrefix, swath in zip([
self._insar.referenceBurstPrefix,
self._insar.secondaryBurstPrefix
], [
referenceTrack.frames[i].swaths[j],
secondaryTrack.frames[i].swaths[j]
]):
slcDir = os.path.join('../', frameDir, swathDir, burstPrefix)
slcLowerDir = os.path.join(ionDir['subband'][0], frameDir,
swathDir, burstPrefix)
slcUpperDir = os.path.join(ionDir['subband'][1], frameDir,
swathDir, burstPrefix)
os.makedirs(slcLowerDir, exist_ok=True)
os.makedirs(slcUpperDir, exist_ok=True)
for k in range(swath.numberOfBursts):
print('processing burst: %02d' % (k + 1))
slc = os.path.join(slcDir,
burstPrefix + '_%02d.slc' % (k + 1))
slcLower = os.path.join(
slcLowerDir, burstPrefix + '_%02d.slc' % (k + 1))
slcUpper = os.path.join(
slcUpperDir, burstPrefix + '_%02d.slc' % (k + 1))
rg_filter(slc, 2, [slcLower, slcUpper], subbandBandWidth,
subbandFrequencyCenter, 257, 2048, 0.1, 0, 0.0)
#resample
for l in range(2):
os.chdir(os.path.join(ionDir['subband'][l], frameDir,
swathDir))
#recreate xml file to remove the file path
#can also use fixImageXml.py?
for burstPrefix, swath in zip([
self._insar.referenceBurstPrefix,
self._insar.secondaryBurstPrefix
], [
referenceTrack.frames[i].swaths[j],
secondaryTrack.frames[i].swaths[j]
]):
os.chdir(burstPrefix)
for k in range(swath.numberOfBursts):
slc = burstPrefix + '_%02d.slc' % (k + 1)
img = isceobj.createSlcImage()
img.load(slc + '.xml')
img.setFilename(slc)
img.extraFilename = slc + '.vrt'
img.setAccessMode('READ')
img.renderHdr()
os.chdir('../')
#############################################
#1. form interferogram
#############################################
referenceSwath = referenceTrack.frames[i].swaths[j]
secondarySwath = secondaryTrack.frames[i].swaths[j]
#set up resampling parameters
width = referenceSwath.numberOfSamples
length = referenceSwath.numberOfLines
polyCoeff = self._insar.rangeResidualOffsetCc[i][j]
rgIndex = (np.arange(width) -
polyCoeff[-1][0]) / polyCoeff[-1][1]
azIndex = (np.arange(length) -
polyCoeff[-1][2]) / polyCoeff[-1][3]
rangeOffset = polyCoeff[0][0] + polyCoeff[0][1]*rgIndex[None,:] + polyCoeff[0][2]*rgIndex[None,:]**2 + \
(polyCoeff[1][0] + polyCoeff[1][1]*rgIndex[None,:]) * azIndex[:, None] + \
polyCoeff[2][0] * azIndex[:, None]**2
azimuthOffset = self._insar.azimuthResidualOffsetCc[i][j]
secondaryBurstResampledDir = self._insar.secondaryBurstPrefix + '_2_coreg_cc'
interferogramDir = 'burst_interf_2_coreg_cc'
interferogramPrefix = self._insar.referenceBurstPrefix + '-' + self._insar.secondaryBurstPrefix
resampleBursts(
referenceSwath,
secondarySwath,
self._insar.referenceBurstPrefix,
self._insar.secondaryBurstPrefix,
secondaryBurstResampledDir,
interferogramDir,
self._insar.referenceBurstPrefix,
self._insar.secondaryBurstPrefix,
self._insar.secondaryBurstPrefix,
interferogramPrefix,
os.path.join(
'../../../../{}/{}'.format(frameDir, swathDir),
self._insar.rangeOffset),
os.path.join(
'../../../../{}/{}'.format(frameDir, swathDir),
self._insar.azimuthOffset),
rangeOffsetResidual=rangeOffset,
azimuthOffsetResidual=azimuthOffset)
os.chdir(self._insar.referenceBurstPrefix)
mosaicBurstAmplitude(referenceSwath,
self._insar.referenceBurstPrefix,
self._insar.referenceMagnitude,
numberOfLooksThreshold=4)
os.chdir('../')
os.chdir(secondaryBurstResampledDir)
mosaicBurstAmplitude(referenceSwath,
self._insar.secondaryBurstPrefix,
self._insar.secondaryMagnitude,
numberOfLooksThreshold=4)
os.chdir('../')
os.chdir(interferogramDir)
mosaicBurstInterferogram(referenceSwath,
interferogramPrefix,
self._insar.interferogram,
numberOfLooksThreshold=4)
os.chdir('../')
amp = np.zeros((referenceSwath.numberOfLines,
2 * referenceSwath.numberOfSamples),
dtype=np.float32)
amp[0:, 1:referenceSwath.numberOfSamples*2:2] = np.fromfile(os.path.join(secondaryBurstResampledDir, self._insar.secondaryMagnitude), \
dtype=np.float32).reshape(referenceSwath.numberOfLines, referenceSwath.numberOfSamples)
amp[0:, 0:referenceSwath.numberOfSamples*2:2] = np.fromfile(os.path.join(self._insar.referenceBurstPrefix, self._insar.referenceMagnitude), \
dtype=np.float32).reshape(referenceSwath.numberOfLines, referenceSwath.numberOfSamples)
amp.astype(np.float32).tofile(self._insar.amplitude)
create_xml(self._insar.amplitude,
referenceSwath.numberOfSamples,
referenceSwath.numberOfLines, 'amp')
os.rename(
os.path.join(interferogramDir, self._insar.interferogram),
self._insar.interferogram)
os.rename(
os.path.join(interferogramDir,
self._insar.interferogram + '.vrt'),
self._insar.interferogram + '.vrt')
os.rename(
os.path.join(interferogramDir,
self._insar.interferogram + '.xml'),
self._insar.interferogram + '.xml')
#############################################
#2. delete subband slcs
#############################################
shutil.rmtree(self._insar.referenceBurstPrefix)
shutil.rmtree(self._insar.secondaryBurstPrefix)
shutil.rmtree(secondaryBurstResampledDir)
shutil.rmtree(interferogramDir)
os.chdir('../../../')
############################################################
# STEP 3. mosaic swaths
############################################################
from isceobj.Alos2Proc.runSwathMosaic import swathMosaic
from isceobj.Alos2Proc.Alos2ProcPublic import create_xml
for k in range(2):
os.chdir(ionDir['subband'][k])
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
os.chdir(frameDir)
mosaicDir = 'mosaic'
os.makedirs(mosaicDir, exist_ok=True)
os.chdir(mosaicDir)
if self._insar.endingSwath - self._insar.startingSwath + 1 == 1:
import shutil
swathDir = 's{}'.format(
referenceTrack.frames[i].swaths[0].swathNumber)
# if not os.path.isfile(self._insar.interferogram):
# os.symlink(os.path.join('../', swathDir, self._insar.interferogram), self._insar.interferogram)
# shutil.copy2(os.path.join('../', swathDir, self._insar.interferogram+'.vrt'), self._insar.interferogram+'.vrt')
# shutil.copy2(os.path.join('../', swathDir, self._insar.interferogram+'.xml'), self._insar.interferogram+'.xml')
# if not os.path.isfile(self._insar.amplitude):
# os.symlink(os.path.join('../', swathDir, self._insar.amplitude), self._insar.amplitude)
# shutil.copy2(os.path.join('../', swathDir, self._insar.amplitude+'.vrt'), self._insar.amplitude+'.vrt')
# shutil.copy2(os.path.join('../', swathDir, self._insar.amplitude+'.xml'), self._insar.amplitude+'.xml')
os.rename(
os.path.join('../', swathDir, self._insar.interferogram),
self._insar.interferogram)
os.rename(
os.path.join('../', swathDir,
self._insar.interferogram + '.vrt'),
self._insar.interferogram + '.vrt')
os.rename(
os.path.join('../', swathDir,
self._insar.interferogram + '.xml'),
self._insar.interferogram + '.xml')
os.rename(os.path.join('../', swathDir, self._insar.amplitude),
self._insar.amplitude)
os.rename(
os.path.join('../', swathDir,
self._insar.amplitude + '.vrt'),
self._insar.amplitude + '.vrt')
os.rename(
os.path.join('../', swathDir,
self._insar.amplitude + '.xml'),
self._insar.amplitude + '.xml')
os.chdir('../')
os.chdir('../')
continue
#choose offsets
numberOfFrames = len(referenceTrack.frames)
numberOfSwaths = len(referenceTrack.frames[i].swaths)
if self.swathOffsetMatching:
#no need to do this as the API support 2-d list
#rangeOffsets = (np.array(self._insar.swathRangeOffsetMatchingReference)).reshape(numberOfFrames, numberOfSwaths)
#azimuthOffsets = (np.array(self._insar.swathAzimuthOffsetMatchingReference)).reshape(numberOfFrames, numberOfSwaths)
rangeOffsets = self._insar.swathRangeOffsetMatchingReference
azimuthOffsets = self._insar.swathAzimuthOffsetMatchingReference
else:
#rangeOffsets = (np.array(self._insar.swathRangeOffsetGeometricalReference)).reshape(numberOfFrames, numberOfSwaths)
#azimuthOffsets = (np.array(self._insar.swathAzimuthOffsetGeometricalReference)).reshape(numberOfFrames, numberOfSwaths)
rangeOffsets = self._insar.swathRangeOffsetGeometricalReference
azimuthOffsets = self._insar.swathAzimuthOffsetGeometricalReference
rangeOffsets = rangeOffsets[i]
azimuthOffsets = azimuthOffsets[i]
#list of input files
inputInterferograms = []
inputAmplitudes = []
phaseDiff = [None]
for j, swathNumber in enumerate(
range(self._insar.startingSwath,
self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
inputInterferograms.append(
os.path.join('../', swathDir, self._insar.interferogram))
inputAmplitudes.append(
os.path.join('../', swathDir, self._insar.amplitude))
#compute phase needed to be compensated using startingRange
if j >= 1:
#phaseDiffSwath1 = -4.0 * np.pi * (referenceTrack.frames[i].swaths[j-1].startingRange - secondaryTrack.frames[i].swaths[j-1].startingRange)/subbandRadarWavelength[k]
#phaseDiffSwath2 = -4.0 * np.pi * (referenceTrack.frames[i].swaths[j].startingRange - secondaryTrack.frames[i].swaths[j].startingRange)/subbandRadarWavelength[k]
phaseDiffSwath1 = +4.0 * np.pi * referenceTrack.frames[i].swaths[j-1].startingRange * (1.0/radarWavelength - 1.0/subbandRadarWavelength[k]) \
-4.0 * np.pi * secondaryTrack.frames[i].swaths[j-1].startingRange * (1.0/radarWavelength - 1.0/subbandRadarWavelength[k])
phaseDiffSwath2 = +4.0 * np.pi * referenceTrack.frames[i].swaths[j].startingRange * (1.0/radarWavelength - 1.0/subbandRadarWavelength[k]) \
-4.0 * np.pi * secondaryTrack.frames[i].swaths[j].startingRange * (1.0/radarWavelength - 1.0/subbandRadarWavelength[k])
if referenceTrack.frames[i].swaths[j-1].startingRange - secondaryTrack.frames[i].swaths[j-1].startingRange == \
referenceTrack.frames[i].swaths[j].startingRange - secondaryTrack.frames[i].swaths[j].startingRange:
#phaseDiff.append(phaseDiffSwath2 - phaseDiffSwath1)
#if reference and secondary versions are all before or after version 2.025 (starting range error < 0.5 m),
#it should be OK to do the above.
#see results in neom where it meets the above requirement, but there is still phase diff
#to be less risky, we do not input values here
phaseDiff.append(None)
else:
phaseDiff.append(None)
#note that frame parameters are updated after mosaicking
#mosaic amplitudes
swathMosaic(referenceTrack.frames[i],
inputAmplitudes,
self._insar.amplitude,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
resamplingMethod=0)
#mosaic interferograms
#These are for ALOS-2, may need to change for ALOS-4!
phaseDiffFixed = [
0.0, 0.4754024578084084, 0.9509913179406437,
1.4261648478671614, 2.179664007520499, 2.6766909968024932,
3.130810857
]
snapThreshold = 0.2
#the above preparetions only applies to 'self._insar.modeCombination == 21'
#looks like it also works for 31 (scansarNominalModes-stripmapModes)
if self._insar.modeCombination != 21:
phaseDiff = None
phaseDiffFixed = None
snapThreshold = None
(phaseDiffEst, phaseDiffUsed,
phaseDiffSource) = swathMosaic(referenceTrack.frames[i],
inputInterferograms,
self._insar.interferogram,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateFrame=False,
phaseCompensation=True,
phaseDiff=phaseDiff,
phaseDiffFixed=phaseDiffFixed,
snapThreshold=snapThreshold,
pcRangeLooks=1,
pcAzimuthLooks=3,
filt=False,
resamplingMethod=1)
#the first item is meaningless for all the following list, so only record the following items
if phaseDiff == None:
phaseDiff = [
None for iii in range(self._insar.startingSwath,
self._insar.endingSwath + 1)
]
catalog.addItem(
'{} subswath phase difference input'.format(
ionDir['subband'][k]), phaseDiff[1:], 'runIonSubband')
catalog.addItem(
'{} subswath phase difference estimated'.format(
ionDir['subband'][k]), phaseDiffEst[1:], 'runIonSubband')
catalog.addItem(
'{} subswath phase difference used'.format(
ionDir['subband'][k]), phaseDiffUsed[1:], 'runIonSubband')
catalog.addItem(
'{} subswath phase difference used source'.format(
ionDir['subband'][k]), phaseDiffSource[1:],
'runIonSubband')
#check if there is value around 3.130810857, which may not be stable
phaseDiffUnstableExist = False
for xxx in phaseDiffUsed:
if abs(abs(xxx) - 3.130810857) < 0.2:
phaseDiffUnstableExist = True
catalog.addItem(
'{} subswath phase difference unstable exists'.format(
ionDir['subband'][k]), phaseDiffUnstableExist,
'runIonSubband')
create_xml(self._insar.amplitude,
referenceTrack.frames[i].numberOfSamples,
referenceTrack.frames[i].numberOfLines, 'amp')
create_xml(self._insar.interferogram,
referenceTrack.frames[i].numberOfSamples,
referenceTrack.frames[i].numberOfLines, 'int')
os.chdir('../')
os.chdir('../')
os.chdir('../')
############################################################
# STEP 4. mosaic frames
############################################################
from isceobj.Alos2Proc.runFrameMosaic import frameMosaic
from isceobj.Alos2Proc.Alos2ProcPublic import create_xml
for k in range(2):
os.chdir(ionDir['subband'][k])
mosaicDir = 'insar'
os.makedirs(mosaicDir, exist_ok=True)
os.chdir(mosaicDir)
numberOfFrames = len(referenceTrack.frames)
if numberOfFrames == 1:
import shutil
frameDir = os.path.join('f1_{}/mosaic'.format(
self._insar.referenceFrames[0]))
# if not os.path.isfile(self._insar.interferogram):
# os.symlink(os.path.join('../', frameDir, self._insar.interferogram), self._insar.interferogram)
# #shutil.copy2() can overwrite
# shutil.copy2(os.path.join('../', frameDir, self._insar.interferogram+'.vrt'), self._insar.interferogram+'.vrt')
# shutil.copy2(os.path.join('../', frameDir, self._insar.interferogram+'.xml'), self._insar.interferogram+'.xml')
# if not os.path.isfile(self._insar.amplitude):
# os.symlink(os.path.join('../', frameDir, self._insar.amplitude), self._insar.amplitude)
# shutil.copy2(os.path.join('../', frameDir, self._insar.amplitude+'.vrt'), self._insar.amplitude+'.vrt')
# shutil.copy2(os.path.join('../', frameDir, self._insar.amplitude+'.xml'), self._insar.amplitude+'.xml')
os.rename(os.path.join('../', frameDir, self._insar.interferogram),
self._insar.interferogram)
os.rename(
os.path.join('../', frameDir,
self._insar.interferogram + '.vrt'),
self._insar.interferogram + '.vrt')
os.rename(
os.path.join('../', frameDir,
self._insar.interferogram + '.xml'),
self._insar.interferogram + '.xml')
os.rename(os.path.join('../', frameDir, self._insar.amplitude),
self._insar.amplitude)
os.rename(
os.path.join('../', frameDir, self._insar.amplitude + '.vrt'),
self._insar.amplitude + '.vrt')
os.rename(
os.path.join('../', frameDir, self._insar.amplitude + '.xml'),
self._insar.amplitude + '.xml')
else:
#choose offsets
if self.frameOffsetMatching:
rangeOffsets = self._insar.frameRangeOffsetMatchingReference
azimuthOffsets = self._insar.frameAzimuthOffsetMatchingReference
else:
rangeOffsets = self._insar.frameRangeOffsetGeometricalReference
azimuthOffsets = self._insar.frameAzimuthOffsetGeometricalReference
#list of input files
inputInterferograms = []
inputAmplitudes = []
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
inputInterferograms.append(
os.path.join('../', frameDir, 'mosaic',
self._insar.interferogram))
inputAmplitudes.append(
os.path.join('../', frameDir, 'mosaic',
self._insar.amplitude))
#note that track parameters are updated after mosaicking
#mosaic amplitudes
frameMosaic(referenceTrack,
inputAmplitudes,
self._insar.amplitude,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateTrack=False,
phaseCompensation=False,
resamplingMethod=0)
#mosaic interferograms
frameMosaic(referenceTrack,
inputInterferograms,
self._insar.interferogram,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateTrack=False,
phaseCompensation=True,
resamplingMethod=1)
create_xml(self._insar.amplitude, referenceTrack.numberOfSamples,
referenceTrack.numberOfLines, 'amp')
create_xml(self._insar.interferogram,
referenceTrack.numberOfSamples,
referenceTrack.numberOfLines, 'int')
os.chdir('../')
os.chdir('../')
############################################################
# STEP 5. clear frame processing files
############################################################
import shutil
from isceobj.Alos2Proc.Alos2ProcPublic import runCmd
for k in range(2):
os.chdir(ionDir['subband'][k])
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
shutil.rmtree(frameDir)
#cmd = 'rm -rf {}'.format(frameDir)
#runCmd(cmd)
os.chdir('../')
############################################################
# STEP 6. create differential interferograms
############################################################
import numpy as np
from isceobj.Alos2Proc.Alos2ProcPublic import runCmd
for k in range(2):
os.chdir(ionDir['subband'][k])
insarDir = ionDir['insar']
os.makedirs(insarDir, exist_ok=True)
os.chdir(insarDir)
rangePixelSize = self._insar.numberRangeLooks1 * referenceTrack.rangePixelSize
radarWavelength = subbandRadarWavelength[k]
rectRangeOffset = os.path.join('../../../', insarDir,
self._insar.rectRangeOffset)
cmd = "imageMath.py -e='a*exp(-1.0*J*b*4.0*{}*{}/{}) * (b!=0)' --a={} --b={} -o {} -t cfloat".format(
np.pi, rangePixelSize, radarWavelength, self._insar.interferogram,
rectRangeOffset, self._insar.differentialInterferogram)
runCmd(cmd)
os.chdir('../../')
os.chdir('../')
catalog.printToLog(logger, "runIonSubband")
self._insar.procDoc.addAllFromCatalog(catalog)
def runSwathMosaic(self):
'''mosaic subswaths
'''
catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name)
self.updateParamemetersFromUser()
referenceTrack = self._insar.loadTrack(reference=True)
secondaryTrack = self._insar.loadTrack(reference=False)
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i+1, frameNumber)
os.chdir(frameDir)
mosaicDir = 'mosaic'
os.makedirs(mosaicDir, exist_ok=True)
os.chdir(mosaicDir)
if self._insar.endingSwath-self._insar.startingSwath+1 == 1:
import shutil
swathDir = 's{}'.format(referenceTrack.frames[i].swaths[0].swathNumber)
if not os.path.isfile(self._insar.interferogram):
os.symlink(os.path.join('../', swathDir, self._insar.interferogram), self._insar.interferogram)
shutil.copy2(os.path.join('../', swathDir, self._insar.interferogram+'.vrt'), self._insar.interferogram+'.vrt')
shutil.copy2(os.path.join('../', swathDir, self._insar.interferogram+'.xml'), self._insar.interferogram+'.xml')
if not os.path.isfile(self._insar.amplitude):
os.symlink(os.path.join('../', swathDir, self._insar.amplitude), self._insar.amplitude)
shutil.copy2(os.path.join('../', swathDir, self._insar.amplitude+'.vrt'), self._insar.amplitude+'.vrt')
shutil.copy2(os.path.join('../', swathDir, self._insar.amplitude+'.xml'), self._insar.amplitude+'.xml')
# os.rename(os.path.join('../', swathDir, self._insar.interferogram), self._insar.interferogram)
# os.rename(os.path.join('../', swathDir, self._insar.interferogram+'.vrt'), self._insar.interferogram+'.vrt')
# os.rename(os.path.join('../', swathDir, self._insar.interferogram+'.xml'), self._insar.interferogram+'.xml')
# os.rename(os.path.join('../', swathDir, self._insar.amplitude), self._insar.amplitude)
# os.rename(os.path.join('../', swathDir, self._insar.amplitude+'.vrt'), self._insar.amplitude+'.vrt')
# os.rename(os.path.join('../', swathDir, self._insar.amplitude+'.xml'), self._insar.amplitude+'.xml')
#update frame parameters
#########################################################
frame = referenceTrack.frames[i]
infImg = isceobj.createImage()
infImg.load(self._insar.interferogram+'.xml')
#mosaic size
frame.numberOfSamples = infImg.width
frame.numberOfLines = infImg.length
#NOTE THAT WE ARE STILL USING SINGLE LOOK PARAMETERS HERE
#range parameters
frame.startingRange = frame.swaths[0].startingRange
frame.rangeSamplingRate = frame.swaths[0].rangeSamplingRate
frame.rangePixelSize = frame.swaths[0].rangePixelSize
#azimuth parameters
frame.sensingStart = frame.swaths[0].sensingStart
frame.prf = frame.swaths[0].prf
frame.azimuthPixelSize = frame.swaths[0].azimuthPixelSize
frame.azimuthLineInterval = frame.swaths[0].azimuthLineInterval
#update frame parameters, secondary
#########################################################
frame = secondaryTrack.frames[i]
#mosaic size
frame.numberOfSamples = int(frame.swaths[0].numberOfSamples/self._insar.numberRangeLooks1)
frame.numberOfLines = int(frame.swaths[0].numberOfLines/self._insar.numberAzimuthLooks1)
#NOTE THAT WE ARE STILL USING SINGLE LOOK PARAMETERS HERE
#range parameters
frame.startingRange = frame.swaths[0].startingRange
frame.rangeSamplingRate = frame.swaths[0].rangeSamplingRate
frame.rangePixelSize = frame.swaths[0].rangePixelSize
#azimuth parameters
frame.sensingStart = frame.swaths[0].sensingStart
frame.prf = frame.swaths[0].prf
frame.azimuthPixelSize = frame.swaths[0].azimuthPixelSize
frame.azimuthLineInterval = frame.swaths[0].azimuthLineInterval
os.chdir('../')
#save parameter file
self._insar.saveProduct(referenceTrack.frames[i], self._insar.referenceFrameParameter)
self._insar.saveProduct(secondaryTrack.frames[i], self._insar.secondaryFrameParameter)
os.chdir('../')
continue
#choose offsets
numberOfFrames = len(referenceTrack.frames)
numberOfSwaths = len(referenceTrack.frames[i].swaths)
if self.swathOffsetMatching:
#no need to do this as the API support 2-d list
#rangeOffsets = (np.array(self._insar.swathRangeOffsetMatchingReference)).reshape(numberOfFrames, numberOfSwaths)
#azimuthOffsets = (np.array(self._insar.swathAzimuthOffsetMatchingReference)).reshape(numberOfFrames, numberOfSwaths)
rangeOffsets = self._insar.swathRangeOffsetMatchingReference
azimuthOffsets = self._insar.swathAzimuthOffsetMatchingReference
else:
#rangeOffsets = (np.array(self._insar.swathRangeOffsetGeometricalReference)).reshape(numberOfFrames, numberOfSwaths)
#azimuthOffsets = (np.array(self._insar.swathAzimuthOffsetGeometricalReference)).reshape(numberOfFrames, numberOfSwaths)
rangeOffsets = self._insar.swathRangeOffsetGeometricalReference
azimuthOffsets = self._insar.swathAzimuthOffsetGeometricalReference
rangeOffsets = rangeOffsets[i]
azimuthOffsets = azimuthOffsets[i]
#list of input files
inputInterferograms = []
inputAmplitudes = []
for j, swathNumber in enumerate(range(self._insar.startingSwath, self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
inputInterferograms.append(os.path.join('../', swathDir, self._insar.interferogram))
inputAmplitudes.append(os.path.join('../', swathDir, self._insar.amplitude))
#note that frame parameters are updated after mosaicking
#mosaic amplitudes
swathMosaic(referenceTrack.frames[i], inputAmplitudes, self._insar.amplitude,
rangeOffsets, azimuthOffsets, self._insar.numberRangeLooks1, self._insar.numberAzimuthLooks1, resamplingMethod=0)
#mosaic interferograms
swathMosaic(referenceTrack.frames[i], inputInterferograms, self._insar.interferogram,
rangeOffsets, azimuthOffsets, self._insar.numberRangeLooks1, self._insar.numberAzimuthLooks1, updateFrame=True, resamplingMethod=1)
create_xml(self._insar.amplitude, referenceTrack.frames[i].numberOfSamples, referenceTrack.frames[i].numberOfLines, 'amp')
create_xml(self._insar.interferogram, referenceTrack.frames[i].numberOfSamples, referenceTrack.frames[i].numberOfLines, 'int')
#update secondary frame parameters here
#no matching for secondary, always use geometry
rangeOffsets = self._insar.swathRangeOffsetGeometricalSecondary
azimuthOffsets = self._insar.swathAzimuthOffsetGeometricalSecondary
rangeOffsets = rangeOffsets[i]
azimuthOffsets = azimuthOffsets[i]
swathMosaicParameters(secondaryTrack.frames[i], rangeOffsets, azimuthOffsets, self._insar.numberRangeLooks1, self._insar.numberAzimuthLooks1)
os.chdir('../')
#save parameter file
self._insar.saveProduct(referenceTrack.frames[i], self._insar.referenceFrameParameter)
self._insar.saveProduct(secondaryTrack.frames[i], self._insar.secondaryFrameParameter)
os.chdir('../')
#mosaic spectral diversity interferograms
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i+1, frameNumber)
os.chdir(frameDir)
mosaicDir = 'mosaic'
os.makedirs(mosaicDir, exist_ok=True)
os.chdir(mosaicDir)
if self._insar.endingSwath-self._insar.startingSwath+1 == 1:
import shutil
swathDir = 's{}'.format(referenceTrack.frames[i].swaths[0].swathNumber)
for sdFile in self._insar.interferogramSd:
if not os.path.isfile(sdFile):
os.symlink(os.path.join('../', swathDir, 'spectral_diversity', sdFile), sdFile)
shutil.copy2(os.path.join('../', swathDir, 'spectral_diversity', sdFile+'.vrt'), sdFile+'.vrt')
shutil.copy2(os.path.join('../', swathDir, 'spectral_diversity', sdFile+'.xml'), sdFile+'.xml')
os.chdir('../')
os.chdir('../')
continue
#choose offsets
numberOfFrames = len(referenceTrack.frames)
numberOfSwaths = len(referenceTrack.frames[i].swaths)
if self.swathOffsetMatching:
#no need to do this as the API support 2-d list
#rangeOffsets = (np.array(self._insar.swathRangeOffsetMatchingReference)).reshape(numberOfFrames, numberOfSwaths)
#azimuthOffsets = (np.array(self._insar.swathAzimuthOffsetMatchingReference)).reshape(numberOfFrames, numberOfSwaths)
rangeOffsets = self._insar.swathRangeOffsetMatchingReference
azimuthOffsets = self._insar.swathAzimuthOffsetMatchingReference
else:
#rangeOffsets = (np.array(self._insar.swathRangeOffsetGeometricalReference)).reshape(numberOfFrames, numberOfSwaths)
#azimuthOffsets = (np.array(self._insar.swathAzimuthOffsetGeometricalReference)).reshape(numberOfFrames, numberOfSwaths)
rangeOffsets = self._insar.swathRangeOffsetGeometricalReference
azimuthOffsets = self._insar.swathAzimuthOffsetGeometricalReference
rangeOffsets = rangeOffsets[i]
azimuthOffsets = azimuthOffsets[i]
#list of input files
inputSd = [[], [], []]
for j, swathNumber in enumerate(range(self._insar.startingSwath, self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
for k, sdFile in enumerate(self._insar.interferogramSd):
inputSd[k].append(os.path.join('../', swathDir, 'spectral_diversity', sdFile))
#mosaic spectral diversity interferograms
for inputSdList, outputSdFile in zip(inputSd, self._insar.interferogramSd):
swathMosaic(referenceTrack.frames[i], inputSdList, outputSdFile,
rangeOffsets, azimuthOffsets, self._insar.numberRangeLooks1, self._insar.numberAzimuthLooks1, updateFrame=False, phaseCompensation=True, pcRangeLooks=5, pcAzimuthLooks=5, filt=True, resamplingMethod=1)
for sdFile in self._insar.interferogramSd:
create_xml(sdFile, referenceTrack.frames[i].numberOfSamples, referenceTrack.frames[i].numberOfLines, 'int')
os.chdir('../')
os.chdir('../')
catalog.printToLog(logger, "runSwathMosaic")
self._insar.procDoc.addAllFromCatalog(catalog)
def runIonSubband(self):
'''create subband interferograms
'''
catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name)
self.updateParamemetersFromUser()
if not self.doIon:
catalog.printToLog(logger, "runIonSubband")
self._insar.procDoc.addAllFromCatalog(catalog)
return
masterTrack = self._insar.loadTrack(master=True)
slaveTrack = self._insar.loadTrack(master=False)
#using 1/3, 1/3, 1/3 band split
radarWavelength = masterTrack.radarWavelength
rangeBandwidth = masterTrack.frames[0].swaths[0].rangeBandwidth
rangeSamplingRate = masterTrack.frames[0].swaths[0].rangeSamplingRate
radarWavelengthLower = SPEED_OF_LIGHT / (SPEED_OF_LIGHT / radarWavelength -
rangeBandwidth / 3.0)
radarWavelengthUpper = SPEED_OF_LIGHT / (SPEED_OF_LIGHT / radarWavelength +
rangeBandwidth / 3.0)
subbandRadarWavelength = [radarWavelengthLower, radarWavelengthUpper]
subbandBandWidth = [
rangeBandwidth / 3.0 / rangeSamplingRate,
rangeBandwidth / 3.0 / rangeSamplingRate
]
subbandFrequencyCenter = [
-rangeBandwidth / 3.0 / rangeSamplingRate,
rangeBandwidth / 3.0 / rangeSamplingRate
]
subbandPrefix = ['lower', 'upper']
'''
ionDir = {
ionDir['swathMosaic'] : 'mosaic',
ionDir['insar'] : 'insar',
ionDir['ion'] : 'ion',
ionDir['subband'] : ['lower', 'upper'],
ionDir['ionCal'] : 'ion_cal'
}
'''
#define upper level directory names
ionDir = defineIonDir()
self._insar.subbandRadarWavelength = subbandRadarWavelength
############################################################
# STEP 1. create directories
############################################################
#create and enter 'ion' directory
#after finishing each step, we are in this directory
if not os.path.exists(ionDir['ion']):
os.makedirs(ionDir['ion'])
os.chdir(ionDir['ion'])
#create insar processing directories
for k in range(2):
subbandDir = ionDir['subband'][k]
for i, frameNumber in enumerate(self._insar.masterFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
for j, swathNumber in enumerate(
range(self._insar.startingSwath,
self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
fullDir = os.path.join(subbandDir, frameDir, swathDir)
if not os.path.exists(fullDir):
os.makedirs(fullDir)
#create ionospheric phase directory
if not os.path.exists(ionDir['ionCal']):
os.makedirs(ionDir['ionCal'])
############################################################
# STEP 2. create subband interferograms
############################################################
import numpy as np
import stdproc
from iscesys.StdOEL.StdOELPy import create_writer
from isceobj.Alos2Proc.Alos2ProcPublic import readOffset
from contrib.alos2proc.alos2proc import rg_filter
for i, frameNumber in enumerate(self._insar.masterFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
for j, swathNumber in enumerate(
range(self._insar.startingSwath, self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
#filter master and slave images
for slcx in [self._insar.masterSlc, self._insar.slaveSlc]:
slc = os.path.join('../', frameDir, swathDir, slcx)
slcLower = os.path.join(ionDir['subband'][0], frameDir,
swathDir, slcx)
slcUpper = os.path.join(ionDir['subband'][1], frameDir,
swathDir, slcx)
rg_filter(slc, 2, [slcLower, slcUpper], subbandBandWidth,
subbandFrequencyCenter, 257, 2048, 0.1, 0, 0.0)
#resample
for k in range(2):
os.chdir(os.path.join(ionDir['subband'][k], frameDir,
swathDir))
#recreate xml file to remove the file path
#can also use fixImageXml.py?
for x in [self._insar.masterSlc, self._insar.slaveSlc]:
img = isceobj.createSlcImage()
img.load(x + '.xml')
img.setFilename(x)
img.extraFilename = x + '.vrt'
img.setAccessMode('READ')
img.renderHdr()
#############################################
#1. form interferogram
#############################################
masterSwath = masterTrack.frames[i].swaths[j]
slaveSwath = slaveTrack.frames[i].swaths[j]
refinedOffsets = readOffset(
os.path.join('../../../../', frameDir, swathDir,
'cull.off'))
intWidth = int(masterSwath.numberOfSamples /
self._insar.numberRangeLooks1)
intLength = int(masterSwath.numberOfLines /
self._insar.numberAzimuthLooks1)
dopplerVsPixel = [
i / slaveSwath.prf for i in slaveSwath.dopplerVsPixel
]
#master slc
mSLC = isceobj.createSlcImage()
mSLC.load(self._insar.masterSlc + '.xml')
mSLC.setAccessMode('read')
mSLC.createImage()
#slave slc
sSLC = isceobj.createSlcImage()
sSLC.load(self._insar.slaveSlc + '.xml')
sSLC.setAccessMode('read')
sSLC.createImage()
#interferogram
interf = isceobj.createIntImage()
interf.setFilename(self._insar.interferogram)
interf.setWidth(intWidth)
interf.setAccessMode('write')
interf.createImage()
#amplitdue
amplitude = isceobj.createAmpImage()
amplitude.setFilename(self._insar.amplitude)
amplitude.setWidth(intWidth)
amplitude.setAccessMode('write')
amplitude.createImage()
#create a writer for resamp
stdWriter = create_writer("log",
"",
True,
filename="resamp.log")
stdWriter.setFileTag("resamp", "log")
stdWriter.setFileTag("resamp", "err")
stdWriter.setFileTag("resamp", "out")
#set up resampling program now
#The setting has been compared with resamp_roi's setting in ROI_pac item by item.
#The two kinds of setting are exactly the same. The number of setting items are
#exactly the same
objResamp = stdproc.createResamp()
objResamp.wireInputPort(name='offsets', object=refinedOffsets)
objResamp.stdWriter = stdWriter
objResamp.setNumberFitCoefficients(6)
objResamp.setNumberRangeBin1(masterSwath.numberOfSamples)
objResamp.setNumberRangeBin2(slaveSwath.numberOfSamples)
objResamp.setStartLine(1)
objResamp.setNumberLines(masterSwath.numberOfLines)
objResamp.setFirstLineOffset(1)
objResamp.setDopplerCentroidCoefficients(dopplerVsPixel)
objResamp.setRadarWavelength(subbandRadarWavelength[k])
objResamp.setSlantRangePixelSpacing(slaveSwath.rangePixelSize)
objResamp.setNumberRangeLooks(self._insar.numberRangeLooks1)
objResamp.setNumberAzimuthLooks(
self._insar.numberAzimuthLooks1)
objResamp.setFlattenWithOffsetFitFlag(0)
objResamp.resamp(mSLC, sSLC, interf, amplitude)
#finialize images
mSLC.finalizeImage()
sSLC.finalizeImage()
interf.finalizeImage()
amplitude.finalizeImage()
stdWriter.finalize()
#############################################
#2. trim amplitude
#############################################
#using memmap instead, which should be faster, since we only have a few pixels to change
amp = np.memmap(self._insar.amplitude,
dtype='complex64',
mode='r+',
shape=(intLength, intWidth))
index = np.nonzero((np.real(amp) == 0) + (np.imag(amp) == 0))
amp[index] = 0
#Deletion flushes memory changes to disk before removing the object:
del amp
#############################################
#3. delete subband slcs
#############################################
os.remove(self._insar.masterSlc)
os.remove(self._insar.masterSlc + '.vrt')
os.remove(self._insar.masterSlc + '.xml')
os.remove(self._insar.slaveSlc)
os.remove(self._insar.slaveSlc + '.vrt')
os.remove(self._insar.slaveSlc + '.xml')
os.chdir('../../../')
############################################################
# STEP 3. mosaic swaths
############################################################
from isceobj.Alos2Proc.runSwathMosaic import swathMosaic
from isceobj.Alos2Proc.Alos2ProcPublic import create_xml
for k in range(2):
os.chdir(ionDir['subband'][k])
for i, frameNumber in enumerate(self._insar.masterFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
os.chdir(frameDir)
mosaicDir = ionDir['swathMosaic']
if not os.path.exists(mosaicDir):
os.makedirs(mosaicDir)
os.chdir(mosaicDir)
if not (
((self._insar.modeCombination == 21) or \
(self._insar.modeCombination == 22) or \
(self._insar.modeCombination == 31) or \
(self._insar.modeCombination == 32))
and
(self._insar.endingSwath-self._insar.startingSwath+1 > 1)
):
import shutil
swathDir = 's{}'.format(
masterTrack.frames[i].swaths[0].swathNumber)
# if not os.path.isfile(self._insar.interferogram):
# os.symlink(os.path.join('../', swathDir, self._insar.interferogram), self._insar.interferogram)
# shutil.copy2(os.path.join('../', swathDir, self._insar.interferogram+'.vrt'), self._insar.interferogram+'.vrt')
# shutil.copy2(os.path.join('../', swathDir, self._insar.interferogram+'.xml'), self._insar.interferogram+'.xml')
# if not os.path.isfile(self._insar.amplitude):
# os.symlink(os.path.join('../', swathDir, self._insar.amplitude), self._insar.amplitude)
# shutil.copy2(os.path.join('../', swathDir, self._insar.amplitude+'.vrt'), self._insar.amplitude+'.vrt')
# shutil.copy2(os.path.join('../', swathDir, self._insar.amplitude+'.xml'), self._insar.amplitude+'.xml')
os.rename(
os.path.join('../', swathDir, self._insar.interferogram),
self._insar.interferogram)
os.rename(
os.path.join('../', swathDir,
self._insar.interferogram + '.vrt'),
self._insar.interferogram + '.vrt')
os.rename(
os.path.join('../', swathDir,
self._insar.interferogram + '.xml'),
self._insar.interferogram + '.xml')
os.rename(os.path.join('../', swathDir, self._insar.amplitude),
self._insar.amplitude)
os.rename(
os.path.join('../', swathDir,
self._insar.amplitude + '.vrt'),
self._insar.amplitude + '.vrt')
os.rename(
os.path.join('../', swathDir,
self._insar.amplitude + '.xml'),
self._insar.amplitude + '.xml')
#no need to update frame parameters here
os.chdir('../')
#no need to save parameter file here
os.chdir('../')
continue
#choose offsets
numberOfFrames = len(masterTrack.frames)
numberOfSwaths = len(masterTrack.frames[i].swaths)
if self.swathOffsetMatching:
#no need to do this as the API support 2-d list
#rangeOffsets = (np.array(self._insar.swathRangeOffsetMatchingMaster)).reshape(numberOfFrames, numberOfSwaths)
#azimuthOffsets = (np.array(self._insar.swathAzimuthOffsetMatchingMaster)).reshape(numberOfFrames, numberOfSwaths)
rangeOffsets = self._insar.swathRangeOffsetMatchingMaster
azimuthOffsets = self._insar.swathAzimuthOffsetMatchingMaster
else:
#rangeOffsets = (np.array(self._insar.swathRangeOffsetGeometricalMaster)).reshape(numberOfFrames, numberOfSwaths)
#azimuthOffsets = (np.array(self._insar.swathAzimuthOffsetGeometricalMaster)).reshape(numberOfFrames, numberOfSwaths)
rangeOffsets = self._insar.swathRangeOffsetGeometricalMaster
azimuthOffsets = self._insar.swathAzimuthOffsetGeometricalMaster
rangeOffsets = rangeOffsets[i]
azimuthOffsets = azimuthOffsets[i]
#list of input files
inputInterferograms = []
inputAmplitudes = []
for j, swathNumber in enumerate(
range(self._insar.startingSwath,
self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
inputInterferograms.append(
os.path.join('../', swathDir, self._insar.interferogram))
inputAmplitudes.append(
os.path.join('../', swathDir, self._insar.amplitude))
#note that frame parameters are updated after mosaicking, here no need to update parameters
#mosaic amplitudes
swathMosaic(masterTrack.frames[i],
inputAmplitudes,
self._insar.amplitude,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
resamplingMethod=0)
#mosaic interferograms
swathMosaic(masterTrack.frames[i],
inputInterferograms,
self._insar.interferogram,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateFrame=False,
phaseCompensation=True,
resamplingMethod=1)
create_xml(self._insar.amplitude,
masterTrack.frames[i].numberOfSamples,
masterTrack.frames[i].numberOfLines, 'amp')
create_xml(self._insar.interferogram,
masterTrack.frames[i].numberOfSamples,
masterTrack.frames[i].numberOfLines, 'int')
#update slave frame parameters here, here no need to update parameters
os.chdir('../')
#save parameter file, here no need to save parameter file
os.chdir('../')
os.chdir('../')
############################################################
# STEP 4. mosaic frames
############################################################
from isceobj.Alos2Proc.runFrameMosaic import frameMosaic
from isceobj.Alos2Proc.Alos2ProcPublic import create_xml
for k in range(2):
os.chdir(ionDir['subband'][k])
mosaicDir = ionDir['insar']
if not os.path.exists(mosaicDir):
os.makedirs(mosaicDir)
os.chdir(mosaicDir)
numberOfFrames = len(masterTrack.frames)
if numberOfFrames == 1:
import shutil
frameDir = os.path.join('f1_{}/mosaic'.format(
self._insar.masterFrames[0]))
# if not os.path.isfile(self._insar.interferogram):
# os.symlink(os.path.join('../', frameDir, self._insar.interferogram), self._insar.interferogram)
# #shutil.copy2() can overwrite
# shutil.copy2(os.path.join('../', frameDir, self._insar.interferogram+'.vrt'), self._insar.interferogram+'.vrt')
# shutil.copy2(os.path.join('../', frameDir, self._insar.interferogram+'.xml'), self._insar.interferogram+'.xml')
# if not os.path.isfile(self._insar.amplitude):
# os.symlink(os.path.join('../', frameDir, self._insar.amplitude), self._insar.amplitude)
# shutil.copy2(os.path.join('../', frameDir, self._insar.amplitude+'.vrt'), self._insar.amplitude+'.vrt')
# shutil.copy2(os.path.join('../', frameDir, self._insar.amplitude+'.xml'), self._insar.amplitude+'.xml')
os.rename(os.path.join('../', frameDir, self._insar.interferogram),
self._insar.interferogram)
os.rename(
os.path.join('../', frameDir,
self._insar.interferogram + '.vrt'),
self._insar.interferogram + '.vrt')
os.rename(
os.path.join('../', frameDir,
self._insar.interferogram + '.xml'),
self._insar.interferogram + '.xml')
os.rename(os.path.join('../', frameDir, self._insar.amplitude),
self._insar.amplitude)
os.rename(
os.path.join('../', frameDir, self._insar.amplitude + '.vrt'),
self._insar.amplitude + '.vrt')
os.rename(
os.path.join('../', frameDir, self._insar.amplitude + '.xml'),
self._insar.amplitude + '.xml')
#update track parameters, no need to update track parameters here
else:
#choose offsets
if self.frameOffsetMatching:
rangeOffsets = self._insar.frameRangeOffsetMatchingMaster
azimuthOffsets = self._insar.frameAzimuthOffsetMatchingMaster
else:
rangeOffsets = self._insar.frameRangeOffsetGeometricalMaster
azimuthOffsets = self._insar.frameAzimuthOffsetGeometricalMaster
#list of input files
inputInterferograms = []
inputAmplitudes = []
for i, frameNumber in enumerate(self._insar.masterFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
inputInterferograms.append(
os.path.join('../', frameDir, 'mosaic',
self._insar.interferogram))
inputAmplitudes.append(
os.path.join('../', frameDir, 'mosaic',
self._insar.amplitude))
#note that track parameters are updated after mosaicking
#mosaic amplitudes
frameMosaic(masterTrack,
inputAmplitudes,
self._insar.amplitude,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateTrack=False,
phaseCompensation=False,
resamplingMethod=0)
#mosaic interferograms
frameMosaic(masterTrack,
inputInterferograms,
self._insar.interferogram,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateTrack=False,
phaseCompensation=True,
resamplingMethod=1)
create_xml(self._insar.amplitude, masterTrack.numberOfSamples,
masterTrack.numberOfLines, 'amp')
create_xml(self._insar.interferogram, masterTrack.numberOfSamples,
masterTrack.numberOfLines, 'int')
#update slave parameters here, no need to update slave parameters here
os.chdir('../')
#save parameter file, no need to save parameter file here
os.chdir('../')
############################################################
# STEP 5. clear frame processing files
############################################################
import shutil
from isceobj.Alos2Proc.Alos2ProcPublic import runCmd
for k in range(2):
os.chdir(ionDir['subband'][k])
for i, frameNumber in enumerate(self._insar.masterFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
shutil.rmtree(frameDir)
#cmd = 'rm -rf {}'.format(frameDir)
#runCmd(cmd)
os.chdir('../')
############################################################
# STEP 6. create differential interferograms
############################################################
import numpy as np
from isceobj.Alos2Proc.Alos2ProcPublic import runCmd
for k in range(2):
os.chdir(ionDir['subband'][k])
insarDir = ionDir['insar']
if not os.path.exists(insarDir):
os.makedirs(insarDir)
os.chdir(insarDir)
rangePixelSize = self._insar.numberRangeLooks1 * masterTrack.rangePixelSize
radarWavelength = subbandRadarWavelength[k]
rectRangeOffset = os.path.join('../../../', insarDir,
self._insar.rectRangeOffset)
cmd = "imageMath.py -e='a*exp(-1.0*J*b*4.0*{}*{}/{}) * (b!=0)' --a={} --b={} -o {} -t cfloat".format(
np.pi, rangePixelSize, radarWavelength, self._insar.interferogram,
rectRangeOffset, self._insar.differentialInterferogram)
runCmd(cmd)
os.chdir('../../')
os.chdir('../')
catalog.printToLog(logger, "runIonSubband")
self._insar.procDoc.addAllFromCatalog(catalog)
def runIonSubband(self, referenceTrack, idir, dateReferenceStack,
dateReference, dateSecondary):
'''create subband interferograms
'''
#catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name)
#self.updateParamemetersFromUser()
#if not self.doIon:
# catalog.printToLog(logger, "runIonSubband")
# self._insar.procDoc.addAllFromCatalog(catalog)
# return
#referenceTrack = self._insar.loadTrack(reference=True)
#secondaryTrack = self._insar.loadTrack(reference=False)
#using 1/3, 1/3, 1/3 band split
radarWavelength = referenceTrack.radarWavelength
rangeBandwidth = referenceTrack.frames[0].swaths[0].rangeBandwidth
rangeSamplingRate = referenceTrack.frames[0].swaths[0].rangeSamplingRate
radarWavelengthLower = SPEED_OF_LIGHT / (SPEED_OF_LIGHT / radarWavelength -
rangeBandwidth / 3.0)
radarWavelengthUpper = SPEED_OF_LIGHT / (SPEED_OF_LIGHT / radarWavelength +
rangeBandwidth / 3.0)
subbandRadarWavelength = [radarWavelengthLower, radarWavelengthUpper]
subbandBandWidth = [
rangeBandwidth / 3.0 / rangeSamplingRate,
rangeBandwidth / 3.0 / rangeSamplingRate
]
subbandFrequencyCenter = [
-rangeBandwidth / 3.0 / rangeSamplingRate,
rangeBandwidth / 3.0 / rangeSamplingRate
]
subbandPrefix = ['lower', 'upper']
'''
ionDir = {
ionDir['swathMosaic'] : 'mosaic',
ionDir['insar'] : 'insar',
ionDir['ion'] : 'ion',
ionDir['subband'] : ['lower', 'upper'],
ionDir['ionCal'] : 'ion_cal'
}
'''
#define upper level directory names
ionDir = defineIonDir()
#self._insar.subbandRadarWavelength = subbandRadarWavelength
############################################################
# STEP 1. create directories
############################################################
#create and enter 'ion' directory
#after finishing each step, we are in this directory
os.makedirs(ionDir['ion'], exist_ok=True)
os.chdir(ionDir['ion'])
#create insar processing directories
for k in range(2):
subbandDir = ionDir['subband'][k]
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
for j, swathNumber in enumerate(
range(self._insar.startingSwath,
self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
fullDir = os.path.join(subbandDir, frameDir, swathDir)
os.makedirs(fullDir, exist_ok=True)
#create ionospheric phase directory
os.makedirs(ionDir['ionCal'], exist_ok=True)
############################################################
# STEP 2. create subband interferograms
############################################################
#import numpy as np
#import stdproc
#from iscesys.StdOEL.StdOELPy import create_writer
#from isceobj.Alos2Proc.Alos2ProcPublic import readOffset
#from contrib.alos2proc.alos2proc import rg_filter
from StackPulic import formInterferogram
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
for j, swathNumber in enumerate(
range(self._insar.startingSwath, self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
#skip this time consuming process, if interferogram already exists
if os.path.isfile(os.path.join(ionDir['subband'][0], frameDir, swathDir, self._insar.interferogram)) and \
os.path.isfile(os.path.join(ionDir['subband'][0], frameDir, swathDir, self._insar.interferogram+'.vrt')) and \
os.path.isfile(os.path.join(ionDir['subband'][0], frameDir, swathDir, self._insar.interferogram+'.xml')) and \
os.path.isfile(os.path.join(ionDir['subband'][0], frameDir, swathDir, self._insar.amplitude)) and \
os.path.isfile(os.path.join(ionDir['subband'][0], frameDir, swathDir, self._insar.amplitude+'.vrt')) and \
os.path.isfile(os.path.join(ionDir['subband'][0], frameDir, swathDir, self._insar.amplitude+'.xml')) and \
os.path.isfile(os.path.join(ionDir['subband'][1], frameDir, swathDir, self._insar.interferogram)) and \
os.path.isfile(os.path.join(ionDir['subband'][1], frameDir, swathDir, self._insar.interferogram+'.vrt')) and \
os.path.isfile(os.path.join(ionDir['subband'][1], frameDir, swathDir, self._insar.interferogram+'.xml')) and \
os.path.isfile(os.path.join(ionDir['subband'][1], frameDir, swathDir, self._insar.amplitude)) and \
os.path.isfile(os.path.join(ionDir['subband'][1], frameDir, swathDir, self._insar.amplitude+'.vrt')) and \
os.path.isfile(os.path.join(ionDir['subband'][1], frameDir, swathDir, self._insar.amplitude+'.xml')):
print('interferogram already exists at swath {}, frame {}'.
format(swathNumber, frameNumber))
continue
# #filter reference and secondary images
# for slcx in [self._insar.referenceSlc, self._insar.secondarySlc]:
# slc = os.path.join('../', frameDir, swathDir, slcx)
# slcLower = os.path.join(ionDir['subband'][0], frameDir, swathDir, slcx)
# slcUpper = os.path.join(ionDir['subband'][1], frameDir, swathDir, slcx)
# rg_filter(slc, 2,
# [slcLower, slcUpper],
# subbandBandWidth,
# subbandFrequencyCenter,
# 257, 2048, 0.1, 0, 0.0)
#resample
for k in range(2):
os.chdir(os.path.join(ionDir['subband'][k], frameDir,
swathDir))
slcReference = os.path.join(
'../../../../', idir, dateReference, frameDir, swathDir,
dateReference + '_{}.slc'.format(ionDir['subband'][k]))
slcSecondary = os.path.join(
'../../../../', idir, dateSecondary, frameDir, swathDir,
dateSecondary + '_{}.slc'.format(ionDir['subband'][k]))
formInterferogram(slcReference, slcSecondary,
self._insar.interferogram,
self._insar.amplitude,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1)
os.chdir('../../../')
############################################################
# STEP 3. mosaic swaths
############################################################
from isceobj.Alos2Proc.runSwathMosaic import swathMosaic
from isceobj.Alos2Proc.Alos2ProcPublic import create_xml
#log output info
log = 'mosaic swaths in {} at {}\n'.format(os.path.basename(__file__),
datetime.datetime.now())
log += '================================================================================================\n'
for k in range(2):
os.chdir(ionDir['subband'][k])
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
os.chdir(frameDir)
mosaicDir = ionDir['swathMosaic']
os.makedirs(mosaicDir, exist_ok=True)
os.chdir(mosaicDir)
if not (self._insar.endingSwath - self._insar.startingSwath >= 1):
import shutil
swathDir = 's{}'.format(
referenceTrack.frames[i].swaths[0].swathNumber)
# if not os.path.isfile(self._insar.interferogram):
# os.symlink(os.path.join('../', swathDir, self._insar.interferogram), self._insar.interferogram)
# shutil.copy2(os.path.join('../', swathDir, self._insar.interferogram+'.vrt'), self._insar.interferogram+'.vrt')
# shutil.copy2(os.path.join('../', swathDir, self._insar.interferogram+'.xml'), self._insar.interferogram+'.xml')
# if not os.path.isfile(self._insar.amplitude):
# os.symlink(os.path.join('../', swathDir, self._insar.amplitude), self._insar.amplitude)
# shutil.copy2(os.path.join('../', swathDir, self._insar.amplitude+'.vrt'), self._insar.amplitude+'.vrt')
# shutil.copy2(os.path.join('../', swathDir, self._insar.amplitude+'.xml'), self._insar.amplitude+'.xml')
os.rename(
os.path.join('../', swathDir, self._insar.interferogram),
self._insar.interferogram)
os.rename(
os.path.join('../', swathDir,
self._insar.interferogram + '.vrt'),
self._insar.interferogram + '.vrt')
os.rename(
os.path.join('../', swathDir,
self._insar.interferogram + '.xml'),
self._insar.interferogram + '.xml')
os.rename(os.path.join('../', swathDir, self._insar.amplitude),
self._insar.amplitude)
os.rename(
os.path.join('../', swathDir,
self._insar.amplitude + '.vrt'),
self._insar.amplitude + '.vrt')
os.rename(
os.path.join('../', swathDir,
self._insar.amplitude + '.xml'),
self._insar.amplitude + '.xml')
#no need to update frame parameters here
os.chdir('../')
#no need to save parameter file here
os.chdir('../')
continue
#choose offsets
numberOfFrames = len(referenceTrack.frames)
numberOfSwaths = len(referenceTrack.frames[i].swaths)
# if self.swathOffsetMatching:
# #no need to do this as the API support 2-d list
# #rangeOffsets = (np.array(self._insar.swathRangeOffsetMatchingReference)).reshape(numberOfFrames, numberOfSwaths)
# #azimuthOffsets = (np.array(self._insar.swathAzimuthOffsetMatchingReference)).reshape(numberOfFrames, numberOfSwaths)
# rangeOffsets = self._insar.swathRangeOffsetMatchingReference
# azimuthOffsets = self._insar.swathAzimuthOffsetMatchingReference
# else:
# #rangeOffsets = (np.array(self._insar.swathRangeOffsetGeometricalReference)).reshape(numberOfFrames, numberOfSwaths)
# #azimuthOffsets = (np.array(self._insar.swathAzimuthOffsetGeometricalReference)).reshape(numberOfFrames, numberOfSwaths)
# rangeOffsets = self._insar.swathRangeOffsetGeometricalReference
# azimuthOffsets = self._insar.swathAzimuthOffsetGeometricalReference
# rangeOffsets = rangeOffsets[i]
# azimuthOffsets = azimuthOffsets[i]
#compute swath offset using reference stack
#geometrical offset is enough now
offsetReferenceStack = swathOffset(referenceTrack.frames[i],
dateReference + '.slc',
'swath_offset_' +
dateReference + '.txt',
crossCorrelation=False,
numberOfAzimuthLooks=10)
#we can faithfully make it integer.
#this can also reduce the error due to floating point computation
rangeOffsets = [float(round(x)) for x in offsetReferenceStack[0]]
azimuthOffsets = [float(round(x)) for x in offsetReferenceStack[1]]
#list of input files
inputInterferograms = []
inputAmplitudes = []
#phaseDiff = [None]
swathPhaseDiffIon = [
self.swathPhaseDiffLowerIon, self.swathPhaseDiffUpperIon
]
phaseDiff = swathPhaseDiffIon[k]
if swathPhaseDiffIon[k] is None:
phaseDiff = None
else:
phaseDiff = swathPhaseDiffIon[k][i]
phaseDiff.insert(0, None)
for j, swathNumber in enumerate(
range(self._insar.startingSwath,
self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
inputInterferograms.append(
os.path.join('../', swathDir, self._insar.interferogram))
inputAmplitudes.append(
os.path.join('../', swathDir, self._insar.amplitude))
# #compute phase needed to be compensated using startingRange
# if j >= 1:
# #phaseDiffSwath1 = -4.0 * np.pi * (referenceTrack.frames[i].swaths[j-1].startingRange - secondaryTrack.frames[i].swaths[j-1].startingRange)/subbandRadarWavelength[k]
# #phaseDiffSwath2 = -4.0 * np.pi * (referenceTrack.frames[i].swaths[j].startingRange - secondaryTrack.frames[i].swaths[j].startingRange)/subbandRadarWavelength[k]
# phaseDiffSwath1 = +4.0 * np.pi * referenceTrack.frames[i].swaths[j-1].startingRange * (1.0/radarWavelength - 1.0/subbandRadarWavelength[k]) \
# -4.0 * np.pi * secondaryTrack.frames[i].swaths[j-1].startingRange * (1.0/radarWavelength - 1.0/subbandRadarWavelength[k])
# phaseDiffSwath2 = +4.0 * np.pi * referenceTrack.frames[i].swaths[j].startingRange * (1.0/radarWavelength - 1.0/subbandRadarWavelength[k]) \
# -4.0 * np.pi * secondaryTrack.frames[i].swaths[j].startingRange * (1.0/radarWavelength - 1.0/subbandRadarWavelength[k])
# if referenceTrack.frames[i].swaths[j-1].startingRange - secondaryTrack.frames[i].swaths[j-1].startingRange == \
# referenceTrack.frames[i].swaths[j].startingRange - secondaryTrack.frames[i].swaths[j].startingRange:
# #phaseDiff.append(phaseDiffSwath2 - phaseDiffSwath1)
# #if reference and secondary versions are all before or after version 2.025 (starting range error < 0.5 m),
# #it should be OK to do the above.
# #see results in neom where it meets the above requirement, but there is still phase diff
# #to be less risky, we do not input values here
# phaseDiff.append(None)
# else:
# phaseDiff.append(None)
#note that frame parameters are updated after mosaicking, here no need to update parameters
#mosaic amplitudes
swathMosaic(referenceTrack.frames[i],
inputAmplitudes,
self._insar.amplitude,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
resamplingMethod=0)
#mosaic interferograms
#These are for ALOS-2, may need to change for ALOS-4!
phaseDiffFixed = [
0.0, 0.4754024578084084, 0.9509913179406437,
1.4261648478671614, 2.179664007520499, 2.6766909968024932,
3.130810857
]
#if (referenceTrack.frames[i].processingSoftwareVersion == '2.025' and secondaryTrack.frames[i].processingSoftwareVersion == '2.023') or \
# (referenceTrack.frames[i].processingSoftwareVersion == '2.023' and secondaryTrack.frames[i].processingSoftwareVersion == '2.025'):
# # changed value number of samples to estimate new value new values estimate area
# ###########################################################################################################################
# # 2.6766909968024932-->2.6581660335779866 1808694 d169-f2850, north CA
# # 2.179664007520499 -->2.204125866652153 131120 d169-f2850, north CA
# phaseDiffFixed = [0.0, 0.4754024578084084, 0.9509913179406437, 1.4261648478671614, 2.204125866652153, 2.6581660335779866, 3.130810857]
snapThreshold = 0.2
#the above preparetions only applies to 'self._insar.modeCombination == 21'
#looks like it also works for 31 (scansarNominalModes-stripmapModes)
# if self._insar.modeCombination != 21:
# phaseDiff = None
# phaseDiffFixed = None
# snapThreshold = None
#whether snap for each swath
if self.swathPhaseDiffSnapIon == None:
snapSwath = [[True for jjj in range(numberOfSwaths - 1)]
for iii in range(numberOfFrames)]
else:
snapSwath = self.swathPhaseDiffSnapIon
if len(snapSwath) != numberOfFrames:
raise Exception(
'please specify each frame for parameter: swath phase difference snap to fixed values'
)
for iii in range(numberOfFrames):
if len(snapSwath[iii]) != (numberOfSwaths - 1):
raise Exception(
'please specify correct number of swaths for parameter: swath phase difference snap to fixed values'
)
(phaseDiffEst, phaseDiffUsed, phaseDiffSource,
numberOfValidSamples) = swathMosaic(
referenceTrack.frames[i],
inputInterferograms,
self._insar.interferogram,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateFrame=False,
phaseCompensation=True,
phaseDiff=phaseDiff,
phaseDiffFixed=phaseDiffFixed,
snapThreshold=snapThreshold,
snapSwath=snapSwath[i],
pcRangeLooks=1,
pcAzimuthLooks=4,
filt=False,
resamplingMethod=1)
#the first item is meaningless for all the following list, so only record the following items
if phaseDiff == None:
phaseDiff = [
None for iii in range(self._insar.startingSwath,
self._insar.endingSwath + 1)
]
#catalog.addItem('frame {} {} band swath phase diff input'.format(frameNumber, ionDir['subband'][k]), phaseDiff[1:], 'runIonSubband')
#catalog.addItem('frame {} {} band swath phase diff estimated'.format(frameNumber, ionDir['subband'][k]), phaseDiffEst[1:], 'runIonSubband')
#catalog.addItem('frame {} {} band swath phase diff used'.format(frameNumber, ionDir['subband'][k]), phaseDiffUsed[1:], 'runIonSubband')
#catalog.addItem('frame {} {} band swath phase diff used source'.format(frameNumber, ionDir['subband'][k]), phaseDiffSource[1:], 'runIonSubband')
#catalog.addItem('frame {} {} band swath phase diff samples used'.format(frameNumber, ionDir['subband'][k]), numberOfValidSamples[1:], 'runIonSubband')
log += 'frame {} {} band swath phase diff input: {}\n'.format(
frameNumber, ionDir['subband'][k], phaseDiff[1:])
log += 'frame {} {} band swath phase diff estimated: {}\n'.format(
frameNumber, ionDir['subband'][k], phaseDiffEst[1:])
log += 'frame {} {} band swath phase diff used: {}\n'.format(
frameNumber, ionDir['subband'][k], phaseDiffUsed[1:])
log += 'frame {} {} band swath phase diff used source: {}\n'.format(
frameNumber, ionDir['subband'][k], phaseDiffSource[1:])
log += 'frame {} {} band swath phase diff samples used: {}\n'.format(
frameNumber, ionDir['subband'][k], numberOfValidSamples[1:])
#check if there is value around 3.130810857, which may not be stable
phaseDiffUnstableExist = False
for xxx in phaseDiffUsed:
if abs(abs(xxx) - 3.130810857) < 0.2:
phaseDiffUnstableExist = True
#catalog.addItem('frame {} {} band swath phase diff unstable exists'.format(frameNumber, ionDir['subband'][k]), phaseDiffUnstableExist, 'runIonSubband')
log += 'frame {} {} band swath phase diff unstable exists: {}\n'.format(
frameNumber, ionDir['subband'][k], phaseDiffUnstableExist)
log += '\n'
create_xml(self._insar.amplitude,
referenceTrack.frames[i].numberOfSamples,
referenceTrack.frames[i].numberOfLines, 'amp')
create_xml(self._insar.interferogram,
referenceTrack.frames[i].numberOfSamples,
referenceTrack.frames[i].numberOfLines, 'int')
#update secondary frame parameters here, here no need to update parameters
os.chdir('../')
#save parameter file, here no need to save parameter file
os.chdir('../')
os.chdir('../')
############################################################
# STEP 4. mosaic frames
############################################################
from isceobj.Alos2Proc.runFrameMosaic import frameMosaic
from isceobj.Alos2Proc.Alos2ProcPublic import create_xml
log += 'mosaic frames in {} at {}\n'.format(os.path.basename(__file__),
datetime.datetime.now())
log += '================================================================================================\n'
spotlightModes, stripmapModes, scansarNominalModes, scansarWideModes, scansarModes = acquisitionModesAlos2(
)
for k in range(2):
os.chdir(ionDir['subband'][k])
mosaicDir = ionDir['insar']
os.makedirs(mosaicDir, exist_ok=True)
os.chdir(mosaicDir)
numberOfFrames = len(referenceTrack.frames)
if numberOfFrames == 1:
import shutil
frameDir = os.path.join('f1_{}/mosaic'.format(
self._insar.referenceFrames[0]))
# if not os.path.isfile(self._insar.interferogram):
# os.symlink(os.path.join('../', frameDir, self._insar.interferogram), self._insar.interferogram)
# #shutil.copy2() can overwrite
# shutil.copy2(os.path.join('../', frameDir, self._insar.interferogram+'.vrt'), self._insar.interferogram+'.vrt')
# shutil.copy2(os.path.join('../', frameDir, self._insar.interferogram+'.xml'), self._insar.interferogram+'.xml')
# if not os.path.isfile(self._insar.amplitude):
# os.symlink(os.path.join('../', frameDir, self._insar.amplitude), self._insar.amplitude)
# shutil.copy2(os.path.join('../', frameDir, self._insar.amplitude+'.vrt'), self._insar.amplitude+'.vrt')
# shutil.copy2(os.path.join('../', frameDir, self._insar.amplitude+'.xml'), self._insar.amplitude+'.xml')
os.rename(os.path.join('../', frameDir, self._insar.interferogram),
self._insar.interferogram)
os.rename(
os.path.join('../', frameDir,
self._insar.interferogram + '.vrt'),
self._insar.interferogram + '.vrt')
os.rename(
os.path.join('../', frameDir,
self._insar.interferogram + '.xml'),
self._insar.interferogram + '.xml')
os.rename(os.path.join('../', frameDir, self._insar.amplitude),
self._insar.amplitude)
os.rename(
os.path.join('../', frameDir, self._insar.amplitude + '.vrt'),
self._insar.amplitude + '.vrt')
os.rename(
os.path.join('../', frameDir, self._insar.amplitude + '.xml'),
self._insar.amplitude + '.xml')
#update track parameters, no need to update track parameters here
else:
# #choose offsets
# if self.frameOffsetMatching:
# rangeOffsets = self._insar.frameRangeOffsetMatchingReference
# azimuthOffsets = self._insar.frameAzimuthOffsetMatchingReference
# else:
# rangeOffsets = self._insar.frameRangeOffsetGeometricalReference
# azimuthOffsets = self._insar.frameAzimuthOffsetGeometricalReference
if referenceTrack.operationMode in scansarModes:
matchingMode = 0
else:
matchingMode = 1
#geometrical offset is enough
offsetReferenceStack = frameOffset(referenceTrack,
dateReference + '.slc',
'frame_offset_' +
dateReference + '.txt',
crossCorrelation=False,
matchingMode=matchingMode)
#we can faithfully make it integer.
#this can also reduce the error due to floating point computation
rangeOffsets = [float(round(x)) for x in offsetReferenceStack[0]]
azimuthOffsets = [float(round(x)) for x in offsetReferenceStack[1]]
#list of input files
inputInterferograms = []
inputAmplitudes = []
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
inputInterferograms.append(
os.path.join('../', frameDir, 'mosaic',
self._insar.interferogram))
inputAmplitudes.append(
os.path.join('../', frameDir, 'mosaic',
self._insar.amplitude))
#note that track parameters are updated after mosaicking
#mosaic amplitudes
frameMosaic(referenceTrack,
inputAmplitudes,
self._insar.amplitude,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateTrack=False,
phaseCompensation=False,
resamplingMethod=0)
#mosaic interferograms
(phaseDiffEst, phaseDiffUsed, phaseDiffSource,
numberOfValidSamples) = frameMosaic(
referenceTrack,
inputInterferograms,
self._insar.interferogram,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateTrack=False,
phaseCompensation=True,
resamplingMethod=1)
create_xml(self._insar.amplitude, referenceTrack.numberOfSamples,
referenceTrack.numberOfLines, 'amp')
create_xml(self._insar.interferogram,
referenceTrack.numberOfSamples,
referenceTrack.numberOfLines, 'int')
#if multiple frames, remove frame amplitudes/inteferograms to save space
for x in inputAmplitudes:
os.remove(x)
os.remove(x + '.vrt')
os.remove(x + '.xml')
for x in inputInterferograms:
os.remove(x)
os.remove(x + '.vrt')
os.remove(x + '.xml')
#catalog.addItem('{} band frame phase diff estimated'.format(ionDir['subband'][k]), phaseDiffEst[1:], 'runIonSubband')
#catalog.addItem('{} band frame phase diff used'.format(ionDir['subband'][k]), phaseDiffUsed[1:], 'runIonSubband')
#catalog.addItem('{} band frame phase diff used source'.format(ionDir['subband'][k]), phaseDiffSource[1:], 'runIonSubband')
#catalog.addItem('{} band frame phase diff samples used'.format(ionDir['subband'][k]), numberOfValidSamples[1:], 'runIonSubband')
log += '{} band frame phase diff estimated: {}\n'.format(
ionDir['subband'][k], phaseDiffEst[1:])
log += '{} band frame phase diff used: {}\n'.format(
ionDir['subband'][k], phaseDiffUsed[1:])
log += '{} band frame phase diff used source: {}\n'.format(
ionDir['subband'][k], phaseDiffSource[1:])
log += '{} band frame phase diff samples used: {}\n'.format(
ionDir['subband'][k], numberOfValidSamples[1:])
log += '\n'
#update secondary parameters here, no need to update secondary parameters here
os.chdir('../')
#save parameter file, no need to save parameter file here
os.chdir('../')
############################################################
# STEP 5. clear frame processing files
############################################################
import shutil
from isceobj.Alos2Proc.Alos2ProcPublic import runCmd
for k in range(2):
os.chdir(ionDir['subband'][k])
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
#keep subswath interferograms
#shutil.rmtree(frameDir)
#cmd = 'rm -rf {}'.format(frameDir)
#runCmd(cmd)
os.chdir('../')
############################################################
# STEP 6. create differential interferograms
############################################################
import numpy as np
from isceobj.Alos2Proc.Alos2ProcPublic import runCmd
for k in range(2):
os.chdir(ionDir['subband'][k])
insarDir = ionDir['insar']
os.makedirs(insarDir, exist_ok=True)
os.chdir(insarDir)
rangePixelSize = self._insar.numberRangeLooks1 * referenceTrack.rangePixelSize
radarWavelength = subbandRadarWavelength[k]
ml1 = '_{}rlks_{}alks'.format(self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1)
if dateReference == dateReferenceStack:
rectRangeOffset = os.path.join(
'../../../', idir, dateSecondary, 'insar',
dateSecondary + ml1 + '_rg_rect.off')
cmd = "imageMath.py -e='a*exp(-1.0*J*b*4.0*{}*{}/{})*(b!=0)' --a={} --b={} -o {} -t cfloat".format(
np.pi, rangePixelSize, radarWavelength,
self._insar.interferogram, rectRangeOffset,
self._insar.differentialInterferogram)
elif dateSecondary == dateReferenceStack:
rectRangeOffset = os.path.join(
'../../../', idir, dateReference, 'insar',
dateReference + ml1 + '_rg_rect.off')
cmd = "imageMath.py -e='a*exp(1.0*J*b*4.0*{}*{}/{})*(b!=0)' --a={} --b={} -o {} -t cfloat".format(
np.pi, rangePixelSize, radarWavelength,
self._insar.interferogram, rectRangeOffset,
self._insar.differentialInterferogram)
else:
rectRangeOffset1 = os.path.join(
'../../../', idir, dateReference, 'insar',
dateReference + ml1 + '_rg_rect.off')
rectRangeOffset2 = os.path.join(
'../../../', idir, dateSecondary, 'insar',
dateSecondary + ml1 + '_rg_rect.off')
cmd = "imageMath.py -e='a*exp(1.0*J*(b-c)*4.0*{}*{}/{})*(b!=0)*(c!=0)' --a={} --b={} --c={} -o {} -t cfloat".format(
np.pi, rangePixelSize, radarWavelength,
self._insar.interferogram, rectRangeOffset1, rectRangeOffset2,
self._insar.differentialInterferogram)
runCmd(cmd)
os.chdir('../../')
os.chdir('../')
return log
def runIonSubband(self):
'''create subband interferograms
'''
catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name)
self.updateParamemetersFromUser()
if not self.doIon:
catalog.printToLog(logger, "runIonSubband")
self._insar.procDoc.addAllFromCatalog(catalog)
return
masterTrack = self._insar.loadTrack(master=True)
slaveTrack = self._insar.loadTrack(master=False)
#using 1/3, 1/3, 1/3 band split
radarWavelength = masterTrack.radarWavelength
rangeBandwidth = masterTrack.frames[0].swaths[0].rangeBandwidth
rangeSamplingRate = masterTrack.frames[0].swaths[0].rangeSamplingRate
radarWavelengthLower = SPEED_OF_LIGHT / (SPEED_OF_LIGHT / radarWavelength -
rangeBandwidth / 3.0)
radarWavelengthUpper = SPEED_OF_LIGHT / (SPEED_OF_LIGHT / radarWavelength +
rangeBandwidth / 3.0)
subbandRadarWavelength = [radarWavelengthLower, radarWavelengthUpper]
subbandBandWidth = [
rangeBandwidth / 3.0 / rangeSamplingRate,
rangeBandwidth / 3.0 / rangeSamplingRate
]
subbandFrequencyCenter = [
-rangeBandwidth / 3.0 / rangeSamplingRate,
rangeBandwidth / 3.0 / rangeSamplingRate
]
subbandPrefix = ['lower', 'upper']
'''
ionDir = {
ionDir['swathMosaic'] : 'mosaic',
ionDir['insar'] : 'insar',
ionDir['ion'] : 'ion',
ionDir['subband'] : ['lower', 'upper'],
ionDir['ionCal'] : 'ion_cal'
}
'''
#define upper level directory names
ionDir = defineIonDir()
self._insar.subbandRadarWavelength = subbandRadarWavelength
############################################################
# STEP 1. create directories
############################################################
#create and enter 'ion' directory
#after finishing each step, we are in this directory
if not os.path.exists(ionDir['ion']):
os.makedirs(ionDir['ion'])
os.chdir(ionDir['ion'])
#create insar processing directories
for k in range(2):
subbandDir = ionDir['subband'][k]
for i, frameNumber in enumerate(self._insar.masterFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
for j, swathNumber in enumerate(
range(self._insar.startingSwath,
self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
fullDir = os.path.join(subbandDir, frameDir, swathDir)
if not os.path.exists(fullDir):
os.makedirs(fullDir)
#create ionospheric phase directory
if not os.path.exists(ionDir['ionCal']):
os.makedirs(ionDir['ionCal'])
############################################################
# STEP 2. create subband interferograms
############################################################
import shutil
import numpy as np
from contrib.alos2proc.alos2proc import rg_filter
from isceobj.Alos2Proc.Alos2ProcPublic import resampleBursts
from isceobj.Alos2Proc.Alos2ProcPublic import mosaicBurstAmplitude
from isceobj.Alos2Proc.Alos2ProcPublic import mosaicBurstInterferogram
from isceobj.Alos2Proc.Alos2ProcPublic import create_xml
for i, frameNumber in enumerate(self._insar.masterFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
for j, swathNumber in enumerate(
range(self._insar.startingSwath, self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
#filter master and slave images
for burstPrefix, swath in zip(
[self._insar.masterBurstPrefix, self._insar.slaveBurstPrefix],
[
masterTrack.frames[i].swaths[j],
slaveTrack.frames[i].swaths[j]
]):
slcDir = os.path.join('../', frameDir, swathDir, burstPrefix)
slcLowerDir = os.path.join(ionDir['subband'][0], frameDir,
swathDir, burstPrefix)
slcUpperDir = os.path.join(ionDir['subband'][1], frameDir,
swathDir, burstPrefix)
if not os.path.exists(slcLowerDir):
os.makedirs(slcLowerDir)
if not os.path.exists(slcUpperDir):
os.makedirs(slcUpperDir)
for k in range(swath.numberOfBursts):
print('processing burst: %02d' % (k + 1))
slc = os.path.join(slcDir,
burstPrefix + '_%02d.slc' % (k + 1))
slcLower = os.path.join(
slcLowerDir, burstPrefix + '_%02d.slc' % (k + 1))
slcUpper = os.path.join(
slcUpperDir, burstPrefix + '_%02d.slc' % (k + 1))
rg_filter(slc, 2, [slcLower, slcUpper], subbandBandWidth,
subbandFrequencyCenter, 257, 2048, 0.1, 0, 0.0)
#resample
for l in range(2):
os.chdir(os.path.join(ionDir['subband'][l], frameDir,
swathDir))
#recreate xml file to remove the file path
#can also use fixImageXml.py?
for burstPrefix, swath in zip([
self._insar.masterBurstPrefix,
self._insar.slaveBurstPrefix
], [
masterTrack.frames[i].swaths[j],
slaveTrack.frames[i].swaths[j]
]):
os.chdir(burstPrefix)
for k in range(swath.numberOfBursts):
slc = burstPrefix + '_%02d.slc' % (k + 1)
img = isceobj.createSlcImage()
img.load(slc + '.xml')
img.setFilename(slc)
img.extraFilename = slc + '.vrt'
img.setAccessMode('READ')
img.renderHdr()
os.chdir('../')
#############################################
#1. form interferogram
#############################################
masterSwath = masterTrack.frames[i].swaths[j]
slaveSwath = slaveTrack.frames[i].swaths[j]
#set up resampling parameters
width = masterSwath.numberOfSamples
length = masterSwath.numberOfLines
polyCoeff = self._insar.rangeResidualOffsetCc[i][j]
rgIndex = (np.arange(width) -
polyCoeff[-1][0]) / polyCoeff[-1][1]
azIndex = (np.arange(length) -
polyCoeff[-1][2]) / polyCoeff[-1][3]
rangeOffset = polyCoeff[0][0] + polyCoeff[0][1]*rgIndex[None,:] + polyCoeff[0][2]*rgIndex[None,:]**2 + \
(polyCoeff[1][0] + polyCoeff[1][1]*rgIndex[None,:]) * azIndex[:, None] + \
polyCoeff[2][0] * azIndex[:, None]**2
azimuthOffset = self._insar.azimuthResidualOffsetCc[i][j]
slaveBurstResampledDir = self._insar.slaveBurstPrefix + '_2_coreg_cc'
interferogramDir = 'burst_interf_2_coreg_cc'
interferogramPrefix = self._insar.masterBurstPrefix + '-' + self._insar.slaveBurstPrefix
resampleBursts(
masterSwath,
slaveSwath,
self._insar.masterBurstPrefix,
self._insar.slaveBurstPrefix,
slaveBurstResampledDir,
interferogramDir,
self._insar.masterBurstPrefix,
self._insar.slaveBurstPrefix,
self._insar.slaveBurstPrefix,
interferogramPrefix,
os.path.join(
'../../../../{}/{}'.format(frameDir, swathDir),
self._insar.rangeOffset),
os.path.join(
'../../../../{}/{}'.format(frameDir, swathDir),
self._insar.azimuthOffset),
rangeOffsetResidual=rangeOffset,
azimuthOffsetResidual=azimuthOffset)
os.chdir(self._insar.masterBurstPrefix)
mosaicBurstAmplitude(masterSwath,
self._insar.masterBurstPrefix,
self._insar.masterMagnitude,
numberOfLooksThreshold=4)
os.chdir('../')
os.chdir(slaveBurstResampledDir)
mosaicBurstAmplitude(masterSwath,
self._insar.slaveBurstPrefix,
self._insar.slaveMagnitude,
numberOfLooksThreshold=4)
os.chdir('../')
os.chdir(interferogramDir)
mosaicBurstInterferogram(masterSwath,
interferogramPrefix,
self._insar.interferogram,
numberOfLooksThreshold=4)
os.chdir('../')
amp = np.zeros((masterSwath.numberOfLines,
2 * masterSwath.numberOfSamples),
dtype=np.float32)
amp[0:, 1:masterSwath.numberOfSamples*2:2] = np.fromfile(os.path.join(slaveBurstResampledDir, self._insar.slaveMagnitude), \
dtype=np.float32).reshape(masterSwath.numberOfLines, masterSwath.numberOfSamples)
amp[0:, 0:masterSwath.numberOfSamples*2:2] = np.fromfile(os.path.join(self._insar.masterBurstPrefix, self._insar.masterMagnitude), \
dtype=np.float32).reshape(masterSwath.numberOfLines, masterSwath.numberOfSamples)
amp.astype(np.float32).tofile(self._insar.amplitude)
create_xml(self._insar.amplitude, masterSwath.numberOfSamples,
masterSwath.numberOfLines, 'amp')
os.rename(
os.path.join(interferogramDir, self._insar.interferogram),
self._insar.interferogram)
os.rename(
os.path.join(interferogramDir,
self._insar.interferogram + '.vrt'),
self._insar.interferogram + '.vrt')
os.rename(
os.path.join(interferogramDir,
self._insar.interferogram + '.xml'),
self._insar.interferogram + '.xml')
#############################################
#2. delete subband slcs
#############################################
shutil.rmtree(self._insar.masterBurstPrefix)
shutil.rmtree(self._insar.slaveBurstPrefix)
shutil.rmtree(slaveBurstResampledDir)
shutil.rmtree(interferogramDir)
os.chdir('../../../')
############################################################
# STEP 3. mosaic swaths
############################################################
from isceobj.Alos2Proc.runSwathMosaic import swathMosaic
from isceobj.Alos2Proc.Alos2ProcPublic import create_xml
for k in range(2):
os.chdir(ionDir['subband'][k])
for i, frameNumber in enumerate(self._insar.masterFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
os.chdir(frameDir)
mosaicDir = 'mosaic'
if not os.path.exists(mosaicDir):
os.makedirs(mosaicDir)
os.chdir(mosaicDir)
if self._insar.endingSwath - self._insar.startingSwath + 1 == 1:
import shutil
swathDir = 's{}'.format(
masterTrack.frames[i].swaths[0].swathNumber)
# if not os.path.isfile(self._insar.interferogram):
# os.symlink(os.path.join('../', swathDir, self._insar.interferogram), self._insar.interferogram)
# shutil.copy2(os.path.join('../', swathDir, self._insar.interferogram+'.vrt'), self._insar.interferogram+'.vrt')
# shutil.copy2(os.path.join('../', swathDir, self._insar.interferogram+'.xml'), self._insar.interferogram+'.xml')
# if not os.path.isfile(self._insar.amplitude):
# os.symlink(os.path.join('../', swathDir, self._insar.amplitude), self._insar.amplitude)
# shutil.copy2(os.path.join('../', swathDir, self._insar.amplitude+'.vrt'), self._insar.amplitude+'.vrt')
# shutil.copy2(os.path.join('../', swathDir, self._insar.amplitude+'.xml'), self._insar.amplitude+'.xml')
os.rename(
os.path.join('../', swathDir, self._insar.interferogram),
self._insar.interferogram)
os.rename(
os.path.join('../', swathDir,
self._insar.interferogram + '.vrt'),
self._insar.interferogram + '.vrt')
os.rename(
os.path.join('../', swathDir,
self._insar.interferogram + '.xml'),
self._insar.interferogram + '.xml')
os.rename(os.path.join('../', swathDir, self._insar.amplitude),
self._insar.amplitude)
os.rename(
os.path.join('../', swathDir,
self._insar.amplitude + '.vrt'),
self._insar.amplitude + '.vrt')
os.rename(
os.path.join('../', swathDir,
self._insar.amplitude + '.xml'),
self._insar.amplitude + '.xml')
os.chdir('../')
os.chdir('../')
continue
#choose offsets
numberOfFrames = len(masterTrack.frames)
numberOfSwaths = len(masterTrack.frames[i].swaths)
if self.swathOffsetMatching:
#no need to do this as the API support 2-d list
#rangeOffsets = (np.array(self._insar.swathRangeOffsetMatchingMaster)).reshape(numberOfFrames, numberOfSwaths)
#azimuthOffsets = (np.array(self._insar.swathAzimuthOffsetMatchingMaster)).reshape(numberOfFrames, numberOfSwaths)
rangeOffsets = self._insar.swathRangeOffsetMatchingMaster
azimuthOffsets = self._insar.swathAzimuthOffsetMatchingMaster
else:
#rangeOffsets = (np.array(self._insar.swathRangeOffsetGeometricalMaster)).reshape(numberOfFrames, numberOfSwaths)
#azimuthOffsets = (np.array(self._insar.swathAzimuthOffsetGeometricalMaster)).reshape(numberOfFrames, numberOfSwaths)
rangeOffsets = self._insar.swathRangeOffsetGeometricalMaster
azimuthOffsets = self._insar.swathAzimuthOffsetGeometricalMaster
rangeOffsets = rangeOffsets[i]
azimuthOffsets = azimuthOffsets[i]
#list of input files
inputInterferograms = []
inputAmplitudes = []
for j, swathNumber in enumerate(
range(self._insar.startingSwath,
self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
inputInterferograms.append(
os.path.join('../', swathDir, self._insar.interferogram))
inputAmplitudes.append(
os.path.join('../', swathDir, self._insar.amplitude))
#note that frame parameters are updated after mosaicking
#mosaic amplitudes
swathMosaic(masterTrack.frames[i],
inputAmplitudes,
self._insar.amplitude,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
resamplingMethod=0)
#mosaic interferograms
swathMosaic(masterTrack.frames[i],
inputInterferograms,
self._insar.interferogram,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateFrame=False,
phaseCompensation=True,
resamplingMethod=1)
create_xml(self._insar.amplitude,
masterTrack.frames[i].numberOfSamples,
masterTrack.frames[i].numberOfLines, 'amp')
create_xml(self._insar.interferogram,
masterTrack.frames[i].numberOfSamples,
masterTrack.frames[i].numberOfLines, 'int')
os.chdir('../')
os.chdir('../')
os.chdir('../')
############################################################
# STEP 4. mosaic frames
############################################################
from isceobj.Alos2Proc.runFrameMosaic import frameMosaic
from isceobj.Alos2Proc.Alos2ProcPublic import create_xml
for k in range(2):
os.chdir(ionDir['subband'][k])
mosaicDir = 'insar'
if not os.path.exists(mosaicDir):
os.makedirs(mosaicDir)
os.chdir(mosaicDir)
numberOfFrames = len(masterTrack.frames)
if numberOfFrames == 1:
import shutil
frameDir = os.path.join('f1_{}/mosaic'.format(
self._insar.masterFrames[0]))
# if not os.path.isfile(self._insar.interferogram):
# os.symlink(os.path.join('../', frameDir, self._insar.interferogram), self._insar.interferogram)
# #shutil.copy2() can overwrite
# shutil.copy2(os.path.join('../', frameDir, self._insar.interferogram+'.vrt'), self._insar.interferogram+'.vrt')
# shutil.copy2(os.path.join('../', frameDir, self._insar.interferogram+'.xml'), self._insar.interferogram+'.xml')
# if not os.path.isfile(self._insar.amplitude):
# os.symlink(os.path.join('../', frameDir, self._insar.amplitude), self._insar.amplitude)
# shutil.copy2(os.path.join('../', frameDir, self._insar.amplitude+'.vrt'), self._insar.amplitude+'.vrt')
# shutil.copy2(os.path.join('../', frameDir, self._insar.amplitude+'.xml'), self._insar.amplitude+'.xml')
os.rename(os.path.join('../', frameDir, self._insar.interferogram),
self._insar.interferogram)
os.rename(
os.path.join('../', frameDir,
self._insar.interferogram + '.vrt'),
self._insar.interferogram + '.vrt')
os.rename(
os.path.join('../', frameDir,
self._insar.interferogram + '.xml'),
self._insar.interferogram + '.xml')
os.rename(os.path.join('../', frameDir, self._insar.amplitude),
self._insar.amplitude)
os.rename(
os.path.join('../', frameDir, self._insar.amplitude + '.vrt'),
self._insar.amplitude + '.vrt')
os.rename(
os.path.join('../', frameDir, self._insar.amplitude + '.xml'),
self._insar.amplitude + '.xml')
else:
#choose offsets
if self.frameOffsetMatching:
rangeOffsets = self._insar.frameRangeOffsetMatchingMaster
azimuthOffsets = self._insar.frameAzimuthOffsetMatchingMaster
else:
rangeOffsets = self._insar.frameRangeOffsetGeometricalMaster
azimuthOffsets = self._insar.frameAzimuthOffsetGeometricalMaster
#list of input files
inputInterferograms = []
inputAmplitudes = []
for i, frameNumber in enumerate(self._insar.masterFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
inputInterferograms.append(
os.path.join('../', frameDir, 'mosaic',
self._insar.interferogram))
inputAmplitudes.append(
os.path.join('../', frameDir, 'mosaic',
self._insar.amplitude))
#note that track parameters are updated after mosaicking
#mosaic amplitudes
frameMosaic(masterTrack,
inputAmplitudes,
self._insar.amplitude,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateTrack=False,
phaseCompensation=False,
resamplingMethod=0)
#mosaic interferograms
frameMosaic(masterTrack,
inputInterferograms,
self._insar.interferogram,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateTrack=False,
phaseCompensation=True,
resamplingMethod=1)
create_xml(self._insar.amplitude, masterTrack.numberOfSamples,
masterTrack.numberOfLines, 'amp')
create_xml(self._insar.interferogram, masterTrack.numberOfSamples,
masterTrack.numberOfLines, 'int')
os.chdir('../')
os.chdir('../')
############################################################
# STEP 5. clear frame processing files
############################################################
import shutil
from isceobj.Alos2Proc.Alos2ProcPublic import runCmd
for k in range(2):
os.chdir(ionDir['subband'][k])
for i, frameNumber in enumerate(self._insar.masterFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
shutil.rmtree(frameDir)
#cmd = 'rm -rf {}'.format(frameDir)
#runCmd(cmd)
os.chdir('../')
############################################################
# STEP 6. create differential interferograms
############################################################
import numpy as np
from isceobj.Alos2Proc.Alos2ProcPublic import runCmd
for k in range(2):
os.chdir(ionDir['subband'][k])
insarDir = ionDir['insar']
if not os.path.exists(insarDir):
os.makedirs(insarDir)
os.chdir(insarDir)
rangePixelSize = self._insar.numberRangeLooks1 * masterTrack.rangePixelSize
radarWavelength = subbandRadarWavelength[k]
rectRangeOffset = os.path.join('../../../', insarDir,
self._insar.rectRangeOffset)
cmd = "imageMath.py -e='a*exp(-1.0*J*b*4.0*{}*{}/{}) * (b!=0)' --a={} --b={} -o {} -t cfloat".format(
np.pi, rangePixelSize, radarWavelength, self._insar.interferogram,
rectRangeOffset, self._insar.differentialInterferogram)
runCmd(cmd)
os.chdir('../../')
os.chdir('../')
catalog.printToLog(logger, "runIonSubband")
self._insar.procDoc.addAllFromCatalog(catalog)
def runIonSubband(self):
'''create subband interferograms
'''
if hasattr(self, 'doInSAR'):
if not self.doInSAR:
return
catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name)
self.updateParamemetersFromUser()
if not self.doIon:
catalog.printToLog(logger, "runIonSubband")
self._insar.procDoc.addAllFromCatalog(catalog)
return
referenceTrack = self._insar.loadTrack(reference=True)
secondaryTrack = self._insar.loadTrack(reference=False)
#using 1/3, 1/3, 1/3 band split
radarWavelength = referenceTrack.radarWavelength
rangeBandwidth = referenceTrack.frames[0].swaths[0].rangeBandwidth
rangeSamplingRate = referenceTrack.frames[0].swaths[0].rangeSamplingRate
radarWavelengthLower = SPEED_OF_LIGHT / (SPEED_OF_LIGHT / radarWavelength -
rangeBandwidth / 3.0)
radarWavelengthUpper = SPEED_OF_LIGHT / (SPEED_OF_LIGHT / radarWavelength +
rangeBandwidth / 3.0)
subbandRadarWavelength = [radarWavelengthLower, radarWavelengthUpper]
subbandBandWidth = [
rangeBandwidth / 3.0 / rangeSamplingRate,
rangeBandwidth / 3.0 / rangeSamplingRate
]
subbandFrequencyCenter = [
-rangeBandwidth / 3.0 / rangeSamplingRate,
rangeBandwidth / 3.0 / rangeSamplingRate
]
subbandPrefix = ['lower', 'upper']
'''
ionDir = {
ionDir['swathMosaic'] : 'mosaic',
ionDir['insar'] : 'insar',
ionDir['ion'] : 'ion',
ionDir['subband'] : ['lower', 'upper'],
ionDir['ionCal'] : 'ion_cal'
}
'''
#define upper level directory names
ionDir = defineIonDir()
self._insar.subbandRadarWavelength = subbandRadarWavelength
############################################################
# STEP 1. create directories
############################################################
#create and enter 'ion' directory
#after finishing each step, we are in this directory
os.makedirs(ionDir['ion'], exist_ok=True)
os.chdir(ionDir['ion'])
#create insar processing directories
for k in range(2):
subbandDir = ionDir['subband'][k]
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
for j, swathNumber in enumerate(
range(self._insar.startingSwath,
self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
fullDir = os.path.join(subbandDir, frameDir, swathDir)
os.makedirs(fullDir, exist_ok=True)
#create ionospheric phase directory
os.makedirs(ionDir['ionCal'], exist_ok=True)
############################################################
# STEP 2. create subband interferograms
############################################################
import numpy as np
import stdproc
from iscesys.StdOEL.StdOELPy import create_writer
from isceobj.Alos2Proc.Alos2ProcPublic import readOffset
from contrib.alos2proc.alos2proc import rg_filter
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
for j, swathNumber in enumerate(
range(self._insar.startingSwath, self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
#skip this time consuming process, if interferogram already exists
if os.path.isfile(os.path.join(ionDir['subband'][0], frameDir, swathDir, self._insar.interferogram)) and \
os.path.isfile(os.path.join(ionDir['subband'][0], frameDir, swathDir, self._insar.interferogram+'.vrt')) and \
os.path.isfile(os.path.join(ionDir['subband'][0], frameDir, swathDir, self._insar.interferogram+'.xml')) and \
os.path.isfile(os.path.join(ionDir['subband'][0], frameDir, swathDir, self._insar.amplitude)) and \
os.path.isfile(os.path.join(ionDir['subband'][0], frameDir, swathDir, self._insar.amplitude+'.vrt')) and \
os.path.isfile(os.path.join(ionDir['subband'][0], frameDir, swathDir, self._insar.amplitude+'.xml')) and \
os.path.isfile(os.path.join(ionDir['subband'][1], frameDir, swathDir, self._insar.interferogram)) and \
os.path.isfile(os.path.join(ionDir['subband'][1], frameDir, swathDir, self._insar.interferogram+'.vrt')) and \
os.path.isfile(os.path.join(ionDir['subband'][1], frameDir, swathDir, self._insar.interferogram+'.xml')) and \
os.path.isfile(os.path.join(ionDir['subband'][1], frameDir, swathDir, self._insar.amplitude)) and \
os.path.isfile(os.path.join(ionDir['subband'][1], frameDir, swathDir, self._insar.amplitude+'.vrt')) and \
os.path.isfile(os.path.join(ionDir['subband'][1], frameDir, swathDir, self._insar.amplitude+'.xml')):
print('interferogram already exists at swath {}, frame {}'.
format(swathNumber, frameNumber))
continue
#filter reference and secondary images
for slcx in [self._insar.referenceSlc, self._insar.secondarySlc]:
slc = os.path.join('../', frameDir, swathDir, slcx)
slcLower = os.path.join(ionDir['subband'][0], frameDir,
swathDir, slcx)
slcUpper = os.path.join(ionDir['subband'][1], frameDir,
swathDir, slcx)
rg_filter(slc, 2, [slcLower, slcUpper], subbandBandWidth,
subbandFrequencyCenter, 257, 2048, 0.1, 0, 0.0)
#resample
for k in range(2):
os.chdir(os.path.join(ionDir['subband'][k], frameDir,
swathDir))
#recreate xml file to remove the file path
#can also use fixImageXml.py?
for x in [self._insar.referenceSlc, self._insar.secondarySlc]:
img = isceobj.createSlcImage()
img.load(x + '.xml')
img.setFilename(x)
img.extraFilename = x + '.vrt'
img.setAccessMode('READ')
img.renderHdr()
#############################################
#1. form interferogram
#############################################
referenceSwath = referenceTrack.frames[i].swaths[j]
secondarySwath = secondaryTrack.frames[i].swaths[j]
refinedOffsets = readOffset(
os.path.join('../../../../', frameDir, swathDir,
'cull.off'))
intWidth = int(referenceSwath.numberOfSamples /
self._insar.numberRangeLooks1)
intLength = int(referenceSwath.numberOfLines /
self._insar.numberAzimuthLooks1)
dopplerVsPixel = [
i / secondarySwath.prf
for i in secondarySwath.dopplerVsPixel
]
#reference slc
mSLC = isceobj.createSlcImage()
mSLC.load(self._insar.referenceSlc + '.xml')
mSLC.setAccessMode('read')
mSLC.createImage()
#secondary slc
sSLC = isceobj.createSlcImage()
sSLC.load(self._insar.secondarySlc + '.xml')
sSLC.setAccessMode('read')
sSLC.createImage()
#interferogram
interf = isceobj.createIntImage()
interf.setFilename(self._insar.interferogram)
interf.setWidth(intWidth)
interf.setAccessMode('write')
interf.createImage()
#amplitdue
amplitude = isceobj.createAmpImage()
amplitude.setFilename(self._insar.amplitude)
amplitude.setWidth(intWidth)
amplitude.setAccessMode('write')
amplitude.createImage()
#create a writer for resamp
stdWriter = create_writer("log",
"",
True,
filename="resamp.log")
stdWriter.setFileTag("resamp", "log")
stdWriter.setFileTag("resamp", "err")
stdWriter.setFileTag("resamp", "out")
#set up resampling program now
#The setting has been compared with resamp_roi's setting in ROI_pac item by item.
#The two kinds of setting are exactly the same. The number of setting items are
#exactly the same
objResamp = stdproc.createResamp()
objResamp.wireInputPort(name='offsets', object=refinedOffsets)
objResamp.stdWriter = stdWriter
objResamp.setNumberFitCoefficients(6)
objResamp.setNumberRangeBin1(referenceSwath.numberOfSamples)
objResamp.setNumberRangeBin2(secondarySwath.numberOfSamples)
objResamp.setStartLine(1)
objResamp.setNumberLines(referenceSwath.numberOfLines)
objResamp.setFirstLineOffset(1)
objResamp.setDopplerCentroidCoefficients(dopplerVsPixel)
objResamp.setRadarWavelength(subbandRadarWavelength[k])
objResamp.setSlantRangePixelSpacing(
secondarySwath.rangePixelSize)
objResamp.setNumberRangeLooks(self._insar.numberRangeLooks1)
objResamp.setNumberAzimuthLooks(
self._insar.numberAzimuthLooks1)
objResamp.setFlattenWithOffsetFitFlag(0)
objResamp.resamp(mSLC, sSLC, interf, amplitude)
#finialize images
mSLC.finalizeImage()
sSLC.finalizeImage()
interf.finalizeImage()
amplitude.finalizeImage()
stdWriter.finalize()
#############################################
#2. trim amplitude
#############################################
#using memmap instead, which should be faster, since we only have a few pixels to change
amp = np.memmap(self._insar.amplitude,
dtype='complex64',
mode='r+',
shape=(intLength, intWidth))
index = np.nonzero((np.real(amp) == 0) + (np.imag(amp) == 0))
amp[index] = 0
#Deletion flushes memory changes to disk before removing the object:
del amp
#############################################
#3. delete subband slcs
#############################################
os.remove(self._insar.referenceSlc)
os.remove(self._insar.referenceSlc + '.vrt')
os.remove(self._insar.referenceSlc + '.xml')
os.remove(self._insar.secondarySlc)
os.remove(self._insar.secondarySlc + '.vrt')
os.remove(self._insar.secondarySlc + '.xml')
os.chdir('../../../')
############################################################
# STEP 3. mosaic swaths
############################################################
from isceobj.Alos2Proc.runSwathMosaic import swathMosaic
from isceobj.Alos2Proc.Alos2ProcPublic import create_xml
for k in range(2):
os.chdir(ionDir['subband'][k])
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
os.chdir(frameDir)
mosaicDir = ionDir['swathMosaic']
os.makedirs(mosaicDir, exist_ok=True)
os.chdir(mosaicDir)
if not (
((self._insar.modeCombination == 21) or \
(self._insar.modeCombination == 22) or \
(self._insar.modeCombination == 31) or \
(self._insar.modeCombination == 32))
and
(self._insar.endingSwath-self._insar.startingSwath+1 > 1)
):
import shutil
swathDir = 's{}'.format(
referenceTrack.frames[i].swaths[0].swathNumber)
# if not os.path.isfile(self._insar.interferogram):
# os.symlink(os.path.join('../', swathDir, self._insar.interferogram), self._insar.interferogram)
# shutil.copy2(os.path.join('../', swathDir, self._insar.interferogram+'.vrt'), self._insar.interferogram+'.vrt')
# shutil.copy2(os.path.join('../', swathDir, self._insar.interferogram+'.xml'), self._insar.interferogram+'.xml')
# if not os.path.isfile(self._insar.amplitude):
# os.symlink(os.path.join('../', swathDir, self._insar.amplitude), self._insar.amplitude)
# shutil.copy2(os.path.join('../', swathDir, self._insar.amplitude+'.vrt'), self._insar.amplitude+'.vrt')
# shutil.copy2(os.path.join('../', swathDir, self._insar.amplitude+'.xml'), self._insar.amplitude+'.xml')
os.rename(
os.path.join('../', swathDir, self._insar.interferogram),
self._insar.interferogram)
os.rename(
os.path.join('../', swathDir,
self._insar.interferogram + '.vrt'),
self._insar.interferogram + '.vrt')
os.rename(
os.path.join('../', swathDir,
self._insar.interferogram + '.xml'),
self._insar.interferogram + '.xml')
os.rename(os.path.join('../', swathDir, self._insar.amplitude),
self._insar.amplitude)
os.rename(
os.path.join('../', swathDir,
self._insar.amplitude + '.vrt'),
self._insar.amplitude + '.vrt')
os.rename(
os.path.join('../', swathDir,
self._insar.amplitude + '.xml'),
self._insar.amplitude + '.xml')
#no need to update frame parameters here
os.chdir('../')
#no need to save parameter file here
os.chdir('../')
continue
#choose offsets
numberOfFrames = len(referenceTrack.frames)
numberOfSwaths = len(referenceTrack.frames[i].swaths)
if self.swathOffsetMatching:
#no need to do this as the API support 2-d list
#rangeOffsets = (np.array(self._insar.swathRangeOffsetMatchingReference)).reshape(numberOfFrames, numberOfSwaths)
#azimuthOffsets = (np.array(self._insar.swathAzimuthOffsetMatchingReference)).reshape(numberOfFrames, numberOfSwaths)
rangeOffsets = self._insar.swathRangeOffsetMatchingReference
azimuthOffsets = self._insar.swathAzimuthOffsetMatchingReference
else:
#rangeOffsets = (np.array(self._insar.swathRangeOffsetGeometricalReference)).reshape(numberOfFrames, numberOfSwaths)
#azimuthOffsets = (np.array(self._insar.swathAzimuthOffsetGeometricalReference)).reshape(numberOfFrames, numberOfSwaths)
rangeOffsets = self._insar.swathRangeOffsetGeometricalReference
azimuthOffsets = self._insar.swathAzimuthOffsetGeometricalReference
rangeOffsets = rangeOffsets[i]
azimuthOffsets = azimuthOffsets[i]
#list of input files
inputInterferograms = []
inputAmplitudes = []
#phaseDiff = [None]
swathPhaseDiffIon = [
self.swathPhaseDiffLowerIon, self.swathPhaseDiffUpperIon
]
phaseDiff = swathPhaseDiffIon[k]
if swathPhaseDiffIon[k] is None:
phaseDiff = None
else:
phaseDiff = swathPhaseDiffIon[k][i]
phaseDiff.insert(0, None)
for j, swathNumber in enumerate(
range(self._insar.startingSwath,
self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
inputInterferograms.append(
os.path.join('../', swathDir, self._insar.interferogram))
inputAmplitudes.append(
os.path.join('../', swathDir, self._insar.amplitude))
if False:
#compute phase needed to be compensated using startingRange
if j >= 1:
#phaseDiffSwath1 = -4.0 * np.pi * (referenceTrack.frames[i].swaths[j-1].startingRange - secondaryTrack.frames[i].swaths[j-1].startingRange)/subbandRadarWavelength[k]
#phaseDiffSwath2 = -4.0 * np.pi * (referenceTrack.frames[i].swaths[j].startingRange - secondaryTrack.frames[i].swaths[j].startingRange)/subbandRadarWavelength[k]
phaseDiffSwath1 = +4.0 * np.pi * referenceTrack.frames[i].swaths[j-1].startingRange * (1.0/radarWavelength - 1.0/subbandRadarWavelength[k]) \
-4.0 * np.pi * secondaryTrack.frames[i].swaths[j-1].startingRange * (1.0/radarWavelength - 1.0/subbandRadarWavelength[k])
phaseDiffSwath2 = +4.0 * np.pi * referenceTrack.frames[i].swaths[j].startingRange * (1.0/radarWavelength - 1.0/subbandRadarWavelength[k]) \
-4.0 * np.pi * secondaryTrack.frames[i].swaths[j].startingRange * (1.0/radarWavelength - 1.0/subbandRadarWavelength[k])
if referenceTrack.frames[i].swaths[j-1].startingRange - secondaryTrack.frames[i].swaths[j-1].startingRange == \
referenceTrack.frames[i].swaths[j].startingRange - secondaryTrack.frames[i].swaths[j].startingRange:
#phaseDiff.append(phaseDiffSwath2 - phaseDiffSwath1)
#if reference and secondary versions are all before or after version 2.025 (starting range error < 0.5 m),
#it should be OK to do the above.
#see results in neom where it meets the above requirement, but there is still phase diff
#to be less risky, we do not input values here
phaseDiff.append(None)
else:
phaseDiff.append(None)
#note that frame parameters are updated after mosaicking, here no need to update parameters
#mosaic amplitudes
swathMosaic(referenceTrack.frames[i],
inputAmplitudes,
self._insar.amplitude,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
resamplingMethod=0)
#mosaic interferograms
#These are for ALOS-2, may need to change for ALOS-4!
phaseDiffFixed = [
0.0, 0.4754024578084084, 0.9509913179406437,
1.4261648478671614, 2.179664007520499, 2.6766909968024932,
3.130810857
]
if False:
if (referenceTrack.frames[i].processingSoftwareVersion == '2.025' and secondaryTrack.frames[i].processingSoftwareVersion == '2.023') or \
(referenceTrack.frames[i].processingSoftwareVersion == '2.023' and secondaryTrack.frames[i].processingSoftwareVersion == '2.025'):
# changed value number of samples to estimate new value new values estimate area
###########################################################################################################################
# 2.6766909968024932-->2.6581660335779866 1808694 d169-f2850, north CA
# 2.179664007520499 -->2.204125866652153 131120 d169-f2850, north CA
phaseDiffFixed = [
0.0, 0.4754024578084084, 0.9509913179406437,
1.4261648478671614, 2.204125866652153,
2.6581660335779866, 3.130810857
]
snapThreshold = 0.2
#the above preparetions only applies to 'self._insar.modeCombination == 21'
#looks like it also works for 31 (scansarNominalModes-stripmapModes)
if self._insar.modeCombination != 21:
phaseDiff = None
phaseDiffFixed = None
snapThreshold = None
#whether snap for each swath
if self.swathPhaseDiffSnapIon == None:
snapSwath = [[True for jjj in range(numberOfSwaths - 1)]
for iii in range(numberOfFrames)]
else:
snapSwath = self.swathPhaseDiffSnapIon
if len(snapSwath) != numberOfFrames:
raise Exception(
'please specify each frame for parameter: swath phase difference snap to fixed values'
)
for iii in range(numberOfFrames):
if len(snapSwath[iii]) != (numberOfSwaths - 1):
raise Exception(
'please specify correct number of swaths for parameter: swath phase difference snap to fixed values'
)
(phaseDiffEst, phaseDiffUsed, phaseDiffSource,
numberOfValidSamples) = swathMosaic(
referenceTrack.frames[i],
inputInterferograms,
self._insar.interferogram,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateFrame=False,
phaseCompensation=True,
phaseDiff=phaseDiff,
phaseDiffFixed=phaseDiffFixed,
snapThreshold=snapThreshold,
snapSwath=snapSwath[i],
pcRangeLooks=1,
pcAzimuthLooks=4,
filt=False,
resamplingMethod=1)
#the first item is meaningless for all the following list, so only record the following items
if phaseDiff == None:
phaseDiff = [
None for iii in range(self._insar.startingSwath,
self._insar.endingSwath + 1)
]
catalog.addItem(
'frame {} {} band swath phase diff input'.format(
frameNumber, ionDir['subband'][k]), phaseDiff[1:],
'runIonSubband')
catalog.addItem(
'frame {} {} band swath phase diff estimated'.format(
frameNumber, ionDir['subband'][k]), phaseDiffEst[1:],
'runIonSubband')
catalog.addItem(
'frame {} {} band swath phase diff used'.format(
frameNumber, ionDir['subband'][k]), phaseDiffUsed[1:],
'runIonSubband')
catalog.addItem(
'frame {} {} band swath phase diff used source'.format(
frameNumber, ionDir['subband'][k]), phaseDiffSource[1:],
'runIonSubband')
catalog.addItem(
'frame {} {} band swath phase diff samples used'.format(
frameNumber, ionDir['subband'][k]),
numberOfValidSamples[1:], 'runIonSubband')
#check if there is value around 3.130810857, which may not be stable
phaseDiffUnstableExist = False
for xxx in phaseDiffUsed:
if abs(abs(xxx) - 3.130810857) < 0.2:
phaseDiffUnstableExist = True
catalog.addItem(
'frame {} {} band swath phase diff unstable exists'.format(
frameNumber, ionDir['subband'][k]), phaseDiffUnstableExist,
'runIonSubband')
create_xml(self._insar.amplitude,
referenceTrack.frames[i].numberOfSamples,
referenceTrack.frames[i].numberOfLines, 'amp')
create_xml(self._insar.interferogram,
referenceTrack.frames[i].numberOfSamples,
referenceTrack.frames[i].numberOfLines, 'int')
#update secondary frame parameters here, here no need to update parameters
os.chdir('../')
#save parameter file, here no need to save parameter file
os.chdir('../')
os.chdir('../')
############################################################
# STEP 4. mosaic frames
############################################################
from isceobj.Alos2Proc.runFrameMosaic import frameMosaic
from isceobj.Alos2Proc.Alos2ProcPublic import create_xml
for k in range(2):
os.chdir(ionDir['subband'][k])
mosaicDir = ionDir['insar']
os.makedirs(mosaicDir, exist_ok=True)
os.chdir(mosaicDir)
numberOfFrames = len(referenceTrack.frames)
if numberOfFrames == 1:
import shutil
frameDir = os.path.join('f1_{}/mosaic'.format(
self._insar.referenceFrames[0]))
# if not os.path.isfile(self._insar.interferogram):
# os.symlink(os.path.join('../', frameDir, self._insar.interferogram), self._insar.interferogram)
# #shutil.copy2() can overwrite
# shutil.copy2(os.path.join('../', frameDir, self._insar.interferogram+'.vrt'), self._insar.interferogram+'.vrt')
# shutil.copy2(os.path.join('../', frameDir, self._insar.interferogram+'.xml'), self._insar.interferogram+'.xml')
# if not os.path.isfile(self._insar.amplitude):
# os.symlink(os.path.join('../', frameDir, self._insar.amplitude), self._insar.amplitude)
# shutil.copy2(os.path.join('../', frameDir, self._insar.amplitude+'.vrt'), self._insar.amplitude+'.vrt')
# shutil.copy2(os.path.join('../', frameDir, self._insar.amplitude+'.xml'), self._insar.amplitude+'.xml')
os.rename(os.path.join('../', frameDir, self._insar.interferogram),
self._insar.interferogram)
os.rename(
os.path.join('../', frameDir,
self._insar.interferogram + '.vrt'),
self._insar.interferogram + '.vrt')
os.rename(
os.path.join('../', frameDir,
self._insar.interferogram + '.xml'),
self._insar.interferogram + '.xml')
os.rename(os.path.join('../', frameDir, self._insar.amplitude),
self._insar.amplitude)
os.rename(
os.path.join('../', frameDir, self._insar.amplitude + '.vrt'),
self._insar.amplitude + '.vrt')
os.rename(
os.path.join('../', frameDir, self._insar.amplitude + '.xml'),
self._insar.amplitude + '.xml')
#update track parameters, no need to update track parameters here
else:
#choose offsets
if self.frameOffsetMatching:
rangeOffsets = self._insar.frameRangeOffsetMatchingReference
azimuthOffsets = self._insar.frameAzimuthOffsetMatchingReference
else:
rangeOffsets = self._insar.frameRangeOffsetGeometricalReference
azimuthOffsets = self._insar.frameAzimuthOffsetGeometricalReference
#list of input files
inputInterferograms = []
inputAmplitudes = []
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
inputInterferograms.append(
os.path.join('../', frameDir, 'mosaic',
self._insar.interferogram))
inputAmplitudes.append(
os.path.join('../', frameDir, 'mosaic',
self._insar.amplitude))
#note that track parameters are updated after mosaicking
#mosaic amplitudes
frameMosaic(referenceTrack,
inputAmplitudes,
self._insar.amplitude,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateTrack=False,
phaseCompensation=False,
resamplingMethod=0)
#mosaic interferograms
(phaseDiffEst, phaseDiffUsed, phaseDiffSource,
numberOfValidSamples) = frameMosaic(
referenceTrack,
inputInterferograms,
self._insar.interferogram,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateTrack=False,
phaseCompensation=True,
resamplingMethod=1)
create_xml(self._insar.amplitude, referenceTrack.numberOfSamples,
referenceTrack.numberOfLines, 'amp')
create_xml(self._insar.interferogram,
referenceTrack.numberOfSamples,
referenceTrack.numberOfLines, 'int')
catalog.addItem(
'{} band frame phase diff estimated'.format(
ionDir['subband'][k]), phaseDiffEst[1:], 'runIonSubband')
catalog.addItem(
'{} band frame phase diff used'.format(ionDir['subband'][k]),
phaseDiffUsed[1:], 'runIonSubband')
catalog.addItem(
'{} band frame phase diff used source'.format(
ionDir['subband'][k]), phaseDiffSource[1:],
'runIonSubband')
catalog.addItem(
'{} band frame phase diff samples used'.format(
ionDir['subband'][k]), numberOfValidSamples[1:],
'runIonSubband')
#update secondary parameters here, no need to update secondary parameters here
os.chdir('../')
#save parameter file, no need to save parameter file here
os.chdir('../')
############################################################
# STEP 5. clear frame processing files
############################################################
import shutil
from isceobj.Alos2Proc.Alos2ProcPublic import runCmd
for k in range(2):
os.chdir(ionDir['subband'][k])
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
#keep subswath interferograms
#shutil.rmtree(frameDir)
#cmd = 'rm -rf {}'.format(frameDir)
#runCmd(cmd)
os.chdir('../')
############################################################
# STEP 6. create differential interferograms
############################################################
import numpy as np
from isceobj.Alos2Proc.Alos2ProcPublic import runCmd
for k in range(2):
os.chdir(ionDir['subband'][k])
insarDir = ionDir['insar']
os.makedirs(insarDir, exist_ok=True)
os.chdir(insarDir)
rangePixelSize = self._insar.numberRangeLooks1 * referenceTrack.rangePixelSize
radarWavelength = subbandRadarWavelength[k]
rectRangeOffset = os.path.join('../../../', insarDir,
self._insar.rectRangeOffset)
cmd = "imageMath.py -e='a*exp(-1.0*J*b*4.0*{}*{}/{}) * (b!=0)' --a={} --b={} -o {} -t cfloat".format(
np.pi, rangePixelSize, radarWavelength, self._insar.interferogram,
rectRangeOffset, self._insar.differentialInterferogram)
runCmd(cmd)
os.chdir('../../')
os.chdir('../')
catalog.printToLog(logger, "runIonSubband")
self._insar.procDoc.addAllFromCatalog(catalog)
#list of input files
inputInterferograms = []
inputAmplitudes = []
for j, swathNumber in enumerate(range(swaths[0], swaths[-1] + 1)):
swathDir = 's{}'.format(swathNumber)
inputInterferograms.append(
os.path.join('../', swathDir, interferogram))
inputAmplitudes.append(os.path.join('../', swathDir,
amplitude))
#note that frame parameters do not need to be updated after mosaicking
#mosaic amplitudes
swathMosaic(trackReferenceStack.frames[i],
inputAmplitudes,
amplitude,
rangeOffsets,
azimuthOffsets,
numberRangeLooks1,
numberAzimuthLooks1,
resamplingMethod=0)
#mosaic interferograms
swathMosaic(trackReferenceStack.frames[i],
inputInterferograms,
interferogram,
rangeOffsets,
azimuthOffsets,
numberRangeLooks1,
numberAzimuthLooks1,
resamplingMethod=1)
create_xml(amplitude,
trackReferenceStack.frames[i].numberOfSamples,