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 runUnwrapSnaphu(self): '''unwrap filtered interferogram ''' catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name) self.updateParamemetersFromUser() masterTrack = self._insar.loadTrack(master=True) #slaveTrack = self._insar.loadTrack(master=False) insarDir = 'insar' os.makedirs(insarDir, exist_ok=True) os.chdir(insarDir) ############################################################ # STEP 1. unwrap interferogram ############################################################ if shutil.which('snaphu') != None: print('\noriginal snaphu program found') print( 'unwrap {} using original snaphu, rather than that in ISCE'.format( self._insar.filteredInterferogram)) snaphuUnwrapOriginal(self._insar.filteredInterferogram, self._insar.multilookPhsig, self._insar.multilookAmplitude, self._insar.unwrappedInterferogram, costMode='s', initMethod='mcf') else: tmid = masterTrack.sensingStart + datetime.timedelta( seconds=(self._insar.numberAzimuthLooks1 - 1.0) / 2.0 * masterTrack.azimuthLineInterval + masterTrack.numberOfLines / 2.0 * self._insar.numberAzimuthLooks1 * masterTrack.azimuthLineInterval) snaphuUnwrap( masterTrack, tmid, self._insar.filteredInterferogram, self._insar.multilookPhsig, self._insar.unwrappedInterferogram, self._insar.numberRangeLooks1 * self._insar.numberRangeLooks2, self._insar.numberAzimuthLooks1 * self._insar.numberAzimuthLooks2, costMode='SMOOTH', initMethod='MCF', defomax=2, initOnly=True) ############################################################ # STEP 2. mask using connected components ############################################################ cmd = "imageMath.py -e='a_0*(b>0);a_1*(b>0)' --a={} --b={} -s BIL -t float -o={}".format( self._insar.unwrappedInterferogram, self._insar.unwrappedInterferogram + '.conncomp', self._insar.unwrappedMaskedInterferogram) runCmd(cmd) ############################################################ # STEP 3. mask using water body ############################################################ if self.waterBodyMaskStartingStep == 'unwrap': wbdImage = isceobj.createImage() wbdImage.load(self._insar.multilookWbdOut + '.xml') width = wbdImage.width length = wbdImage.length if not os.path.exists(self._insar.multilookWbdOut): catalog.addItem( 'warning message', 'requested masking interferogram with water body, but water body does not exist', 'runUnwrapSnaphu') else: wbd = np.fromfile(self._insar.multilookWbdOut, dtype=np.int8).reshape(length, width) unw = np.memmap(self._insar.unwrappedInterferogram, dtype='float32', mode='r+', shape=(length * 2, width)) (unw[0:length * 2:2, :])[np.nonzero(wbd == -1)] = 0 (unw[1:length * 2:2, :])[np.nonzero(wbd == -1)] = 0 del unw unw = np.memmap(self._insar.unwrappedMaskedInterferogram, dtype='float32', mode='r+', shape=(length * 2, width)) (unw[0:length * 2:2, :])[np.nonzero(wbd == -1)] = 0 (unw[1:length * 2:2, :])[np.nonzero(wbd == -1)] = 0 del unw, wbd os.chdir('../') catalog.printToLog(logger, "runUnwrapSnaphu") self._insar.procDoc.addAllFromCatalog(catalog)
def runDownloadDem(self): '''download DEM and water body ''' catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name) self.updateParamemetersFromUser() masterTrack = self._insar.loadTrack(master=True) slaveTrack = self._insar.loadTrack(master=False) bboxGeo = getBboxGeo(masterTrack) bbox = np.array(bboxGeo) bboxStr = '{} {} {} {}'.format(np.int(np.floor(bbox[0])), np.int(np.ceil(bbox[1])), np.int(np.floor(bbox[2])), np.int(np.ceil(bbox[3]))) #get 1 arcsecond dem for coregistration if self.dem == None: demDir = 'dem_1_arcsec' os.makedirs(demDir, exist_ok=True) os.chdir(demDir) downloadUrl = 'http://e4ftl01.cr.usgs.gov/MEASURES/SRTMGL1.003/2000.02.11' cmd = 'dem.py -a stitch -b {} -k -s 1 -c -f -u {}'.format( bboxStr, downloadUrl) runCmd(cmd) cmd = 'fixImageXml.py -i demLat_*_*_Lon_*_*.dem.wgs84 -f' runCmd(cmd) cmd = 'rm *.hgt* *.log demLat_*_*_Lon_*_*.dem demLat_*_*_Lon_*_*.dem.vrt demLat_*_*_Lon_*_*.dem.xml' runCmd(cmd) os.chdir('../') self.dem = glob.glob( os.path.join(demDir, 'demLat_*_*_Lon_*_*.dem.wgs84'))[0] #get 3 arcsecond dem for geocoding if self.demGeo == None: demGeoDir = 'dem_3_arcsec' os.makedirs(demGeoDir, exist_ok=True) os.chdir(demGeoDir) downloadUrl = 'http://e4ftl01.cr.usgs.gov/MEASURES/SRTMGL3.003/2000.02.11' cmd = 'dem.py -a stitch -b {} -k -s 3 -c -f -u {}'.format( bboxStr, downloadUrl) runCmd(cmd) cmd = 'fixImageXml.py -i demLat_*_*_Lon_*_*.dem.wgs84 -f' runCmd(cmd) cmd = 'rm *.hgt* *.log demLat_*_*_Lon_*_*.dem demLat_*_*_Lon_*_*.dem.vrt demLat_*_*_Lon_*_*.dem.xml' runCmd(cmd) os.chdir('../') self.demGeo = glob.glob( os.path.join(demGeoDir, 'demLat_*_*_Lon_*_*.dem.wgs84'))[0] #get water body for masking interferogram if self.wbd == None: wbdDir = 'wbd_1_arcsec' os.makedirs(wbdDir, exist_ok=True) os.chdir(wbdDir) #cmd = 'wbd.py {}'.format(bboxStr) #runCmd(cmd) download_wbd(np.int(np.floor(bbox[0])), np.int(np.ceil(bbox[1])), np.int(np.floor(bbox[2])), np.int(np.ceil(bbox[3]))) cmd = 'fixImageXml.py -i swbdLat_*_*_Lon_*_*.wbd -f' runCmd(cmd) cmd = 'rm *.log' runCmd(cmd) os.chdir('../') self.wbd = glob.glob(os.path.join(wbdDir, 'swbdLat_*_*_Lon_*_*.wbd'))[0] self._insar.dem = self.dem self._insar.demGeo = self.demGeo self._insar.wbd = self.wbd catalog.printToLog(logger, "runDownloadDem") 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 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 runRdrDemOffset(self): '''estimate between radar image and dem ''' catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name) self.updateParamemetersFromUser() masterTrack = self._insar.loadTrack(master=True) demFile = os.path.abspath(self._insar.dem) insarDir = 'insar' os.makedirs(insarDir, exist_ok=True) os.chdir(insarDir) rdrDemDir = 'rdr_dem_offset' os.makedirs(rdrDemDir, exist_ok=True) os.chdir(rdrDemDir) ################################################################################################## #compute dem pixel size demImage = isceobj.createDemImage() demImage.load(demFile + '.xml') #DEM pixel size in meters (appoximate value) demDeltaLon = abs( demImage.getDeltaLongitude()) / 0.0002777777777777778 * 30.0 demDeltaLat = abs( demImage.getDeltaLatitude()) / 0.0002777777777777778 * 30.0 #number of looks to take in range if self._insar.numberRangeLooksSim == None: if self._insar.numberRangeLooks1 * masterTrack.rangePixelSize > demDeltaLon: self._insar.numberRangeLooksSim = 1 else: self._insar.numberRangeLooksSim = int( demDeltaLon / (self._insar.numberRangeLooks1 * masterTrack.rangePixelSize) + 0.5) #number of looks to take in azimuth if self._insar.numberAzimuthLooksSim == None: if self._insar.numberAzimuthLooks1 * masterTrack.azimuthPixelSize > demDeltaLat: self._insar.numberAzimuthLooksSim = 1 else: self._insar.numberAzimuthLooksSim = int( demDeltaLat / (self._insar.numberAzimuthLooks1 * masterTrack.azimuthPixelSize) + 0.5) #simulate a radar image using dem simulateRadar(os.path.join('../', self._insar.height), self._insar.sim, scale=3.0, offset=100.0) sim = isceobj.createImage() sim.load(self._insar.sim + '.xml') #take looks if (self._insar.numberRangeLooksSim == 1) and (self._insar.numberAzimuthLooksSim == 1): simLookFile = self._insar.sim ampLookFile = 'amp_{}rlks_{}alks.float'.format( self._insar.numberRangeLooksSim * self._insar.numberRangeLooks1, self._insar.numberAzimuthLooksSim * self._insar.numberAzimuthLooks1) cmd = "imageMath.py -e='sqrt(a_0*a_0+a_1*a_1)' --a={} -o {} -t float".format( os.path.join('../', self._insar.amplitude), ampLookFile) runCmd(cmd) else: simLookFile = 'sim_{}rlks_{}alks.float'.format( self._insar.numberRangeLooksSim * self._insar.numberRangeLooks1, self._insar.numberAzimuthLooksSim * self._insar.numberAzimuthLooks1) ampLookFile = 'amp_{}rlks_{}alks.float'.format( self._insar.numberRangeLooksSim * self._insar.numberRangeLooks1, self._insar.numberAzimuthLooksSim * self._insar.numberAzimuthLooks1) ampTmpFile = 'amp_tmp.float' look(self._insar.sim, simLookFile, sim.width, self._insar.numberRangeLooksSim, self._insar.numberAzimuthLooksSim, 2, 0, 1) look(os.path.join('../', self._insar.amplitude), ampTmpFile, sim.width, self._insar.numberRangeLooksSim, self._insar.numberAzimuthLooksSim, 4, 1, 1) width = int(sim.width / self._insar.numberRangeLooksSim) length = int(sim.length / self._insar.numberAzimuthLooksSim) create_xml(simLookFile, width, length, 'float') create_xml(ampTmpFile, width, length, 'amp') cmd = "imageMath.py -e='sqrt(a_0*a_0+a_1*a_1)' --a={} -o {} -t float".format( ampTmpFile, ampLookFile) runCmd(cmd) os.remove(ampTmpFile) os.remove(ampTmpFile + '.vrt') os.remove(ampTmpFile + '.xml') #initial number of offsets to use numberOfOffsets = 800 #compute land ratio to further determine the number of offsets to use wbd = np.memmap(os.path.join('../', self._insar.wbdOut), dtype='byte', mode='r', shape=(sim.length, sim.width)) landRatio = np.sum(wbd[0:sim.length:10, 0:sim.width:10] != -1) / int( sim.length / 10) / int(sim.width / 10) del wbd if (landRatio <= 0.00125): print( '\n\nWARNING: land area too small for estimating offsets between radar and dem' ) print('do not estimate offsets between radar and dem\n\n') self._insar.radarDemAffineTransform = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0] catalog.addItem( 'warning message', 'land area too small for estimating offsets between radar and dem', 'runRdrDemOffset') os.chdir('../../') catalog.printToLog(logger, "runRdrDemOffset") self._insar.procDoc.addAllFromCatalog(catalog) return #total number of offsets to use numberOfOffsets /= landRatio #allocate number of offsets in range/azimuth according to image width/length width = int(sim.width / self._insar.numberRangeLooksSim) length = int(sim.length / self._insar.numberAzimuthLooksSim) #number of offsets to use in range/azimuth numberOfOffsetsRange = int(np.sqrt(numberOfOffsets * width / length)) numberOfOffsetsAzimuth = int(length / width * np.sqrt(numberOfOffsets * width / length)) #this should be better? numberOfOffsetsRange = int(np.sqrt(numberOfOffsets)) numberOfOffsetsAzimuth = int(np.sqrt(numberOfOffsets)) if numberOfOffsetsRange > int(width / 2): numberOfOffsetsRange = int(width / 2) if numberOfOffsetsAzimuth > int(length / 2): numberOfOffsetsAzimuth = int(length / 2) if numberOfOffsetsRange < 10: numberOfOffsetsRange = 10 if numberOfOffsetsAzimuth < 10: numberOfOffsetsAzimuth = 10 catalog.addItem('number of range offsets', '{}'.format(numberOfOffsetsRange), 'runRdrDemOffset') catalog.addItem('number of azimuth offsets', '{}'.format(numberOfOffsetsAzimuth), 'runRdrDemOffset') #matching ampcor = Ampcor(name='insarapp_slcs_ampcor') ampcor.configure() mMag = isceobj.createImage() mMag.load(ampLookFile + '.xml') mMag.setAccessMode('read') mMag.createImage() sMag = isceobj.createImage() sMag.load(simLookFile + '.xml') sMag.setAccessMode('read') sMag.createImage() ampcor.setImageDataType1('real') ampcor.setImageDataType2('real') ampcor.setMasterSlcImage(mMag) ampcor.setSlaveSlcImage(sMag) #MATCH REGION rgoff = 0 azoff = 0 #it seems that we cannot use 0, haven't look into the problem if rgoff == 0: rgoff = 1 if azoff == 0: azoff = 1 firstSample = 1 if rgoff < 0: firstSample = int(35 - rgoff) firstLine = 1 if azoff < 0: firstLine = int(35 - azoff) ampcor.setAcrossGrossOffset(rgoff) ampcor.setDownGrossOffset(azoff) ampcor.setFirstSampleAcross(firstSample) ampcor.setLastSampleAcross(width) ampcor.setNumberLocationAcross(numberOfOffsetsRange) ampcor.setFirstSampleDown(firstLine) ampcor.setLastSampleDown(length) ampcor.setNumberLocationDown(numberOfOffsetsAzimuth) #MATCH PARAMETERS ampcor.setWindowSizeWidth(64) ampcor.setWindowSizeHeight(64) #note this is the half width/length of search area, so number of resulting correlation samples: 8*2+1 ampcor.setSearchWindowSizeWidth(16) ampcor.setSearchWindowSizeHeight(16) #REST OF THE STUFF ampcor.setAcrossLooks(1) ampcor.setDownLooks(1) ampcor.setOversamplingFactor(64) ampcor.setZoomWindowSize(16) #1. The following not set #Matching Scale for Sample/Line Directions (-) = 1. 1. #should add the following in Ampcor.py? #if not set, in this case, Ampcor.py'value is also 1. 1. #ampcor.setScaleFactorX(1.) #ampcor.setScaleFactorY(1.) #MATCH THRESHOLDS AND DEBUG DATA #2. The following not set #in roi_pac the value is set to 0 1 #in isce the value is set to 0.001 1000.0 #SNR and Covariance Thresholds (-) = {s1} {s2} #should add the following in Ampcor? #THIS SHOULD BE THE ONLY THING THAT IS DIFFERENT FROM THAT OF ROI_PAC #ampcor.setThresholdSNR(0) #ampcor.setThresholdCov(1) ampcor.setDebugFlag(False) ampcor.setDisplayFlag(False) #in summary, only two things not set which are indicated by 'The following not set' above. #run ampcor ampcor.ampcor() offsets = ampcor.getOffsetField() ampcorOffsetFile = 'ampcor.off' cullOffsetFile = 'cull.off' affineTransformFile = 'affine_transform.txt' writeOffset(offsets, ampcorOffsetFile) #finalize image, and re-create it #otherwise the file pointer is still at the end of the image mMag.finalizeImage() sMag.finalizeImage() # #cull offsets # import io # from contextlib import redirect_stdout # f = io.StringIO() # with redirect_stdout(f): # fitoff(ampcorOffsetFile, cullOffsetFile, 1.5, .5, 50) # s = f.getvalue() # #print(s) # with open(affineTransformFile, 'w') as f: # f.write(s) #cull offsets import subprocess proc = subprocess.Popen([ "python3", "-c", "import isce; from contrib.alos2proc_f.alos2proc_f import fitoff; fitoff('ampcor.off', 'cull.off', 1.5, .5, 50)" ], stdout=subprocess.PIPE) out = proc.communicate()[0] with open(affineTransformFile, 'w') as f: f.write(out.decode('utf-8')) #check number of offsets left with open(cullOffsetFile, 'r') as f: numCullOffsets = sum(1 for linex in f) if numCullOffsets < 50: print('\n\nWARNING: too few points left after culling, {} left'.format( numCullOffsets)) print('do not estimate offsets between radar and dem\n\n') self._insar.radarDemAffineTransform = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0] catalog.addItem( 'warning message', 'too few points left after culling, {} left'.format( numCullOffsets), 'runRdrDemOffset') os.chdir('../../') catalog.printToLog(logger, "runRdrDemOffset") self._insar.procDoc.addAllFromCatalog(catalog) return #read affine transform parameters with open(affineTransformFile) as f: lines = f.readlines() i = 0 for linex in lines: if 'Affine Matrix ' in linex: m11 = float(lines[i + 2].split()[0]) m12 = float(lines[i + 2].split()[1]) m21 = float(lines[i + 3].split()[0]) m22 = float(lines[i + 3].split()[1]) t1 = float(lines[i + 7].split()[0]) t2 = float(lines[i + 7].split()[1]) break i += 1 self._insar.radarDemAffineTransform = [m11, m12, m21, m22, t1, t2] ################################################################################################## os.chdir('../../') catalog.printToLog(logger, "runRdrDemOffset") self._insar.procDoc.addAllFromCatalog(catalog)
def runIonUwrap(self): '''unwrap subband interferograms ''' catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name) self.updateParamemetersFromUser() if not self.doIon: catalog.printToLog(logger, "runIonUwrap") self._insar.procDoc.addAllFromCatalog(catalog) return masterTrack = self._insar.loadTrack(master=True) slaveTrack = self._insar.loadTrack(master=False) from isceobj.Alos2Proc.runIonSubband import defineIonDir ionDir = defineIonDir() subbandPrefix = ['lower', 'upper'] ionCalDir = os.path.join(ionDir['ion'], ionDir['ionCal']) if not os.path.exists(ionCalDir): os.makedirs(ionCalDir) os.chdir(ionCalDir) ############################################################ # STEP 1. take looks ############################################################ from isceobj.Alos2Proc.Alos2ProcPublic import create_xml from contrib.alos2proc.alos2proc import look ml2 = '_{}rlks_{}alks'.format(self._insar.numberRangeLooks1*self._insar.numberRangeLooksIon, self._insar.numberAzimuthLooks1*self._insar.numberAzimuthLooksIon) for k in range(2): fullbandDir = os.path.join('../../', ionDir['insar']) subbandDir = os.path.join('../', ionDir['subband'][k], ionDir['insar']) prefix = subbandPrefix[k] amp = isceobj.createImage() amp.load(os.path.join(subbandDir, self._insar.amplitude)+'.xml') width = amp.width length = amp.length width2 = int(width / self._insar.numberRangeLooksIon) length2 = int(length / self._insar.numberAzimuthLooksIon) #take looks look(os.path.join(subbandDir, self._insar.differentialInterferogram), prefix+ml2+'.int', width, self._insar.numberRangeLooksIon, self._insar.numberAzimuthLooksIon, 4, 0, 1) create_xml(prefix+ml2+'.int', width2, length2, 'int') look(os.path.join(subbandDir, self._insar.amplitude), prefix+ml2+'.amp', width, self._insar.numberRangeLooksIon, self._insar.numberAzimuthLooksIon, 4, 1, 1) create_xml(prefix+ml2+'.amp', width2, length2, 'amp') # #water body # if k == 0: # wbdOutFile = os.path.join(fullbandDir, self._insar.wbdOut) # if os.path.isfile(wbdOutFile): # look(wbdOutFile, 'wbd'+ml2+'.wbd', width, self._insar.numberRangeLooksIon, self._insar.numberAzimuthLooksIon, 0, 0, 1) # create_xml('wbd'+ml2+'.wbd', width2, length2, 'byte') ############################################################ # STEP 2. compute coherence ############################################################ from isceobj.Alos2Proc.Alos2ProcPublic import cal_coherence lowerbandInterferogramFile = subbandPrefix[0]+ml2+'.int' upperbandInterferogramFile = subbandPrefix[1]+ml2+'.int' lowerbandAmplitudeFile = subbandPrefix[0]+ml2+'.amp' upperbandAmplitudeFile = subbandPrefix[1]+ml2+'.amp' lowerbandCoherenceFile = subbandPrefix[0]+ml2+'.cor' upperbandCoherenceFile = subbandPrefix[1]+ml2+'.cor' coherenceFile = 'diff'+ml2+'.cor' lowerint = np.fromfile(lowerbandInterferogramFile, dtype=np.complex64).reshape(length2, width2) upperint = np.fromfile(upperbandInterferogramFile, dtype=np.complex64).reshape(length2, width2) loweramp = np.fromfile(lowerbandAmplitudeFile, dtype=np.float32).reshape(length2, width2*2) upperamp = np.fromfile(upperbandAmplitudeFile, dtype=np.float32).reshape(length2, width2*2) #compute coherence only using interferogram #here I use differential interferogram of lower and upper band interferograms #so that coherence is not affected by fringes cord = cal_coherence(lowerint*np.conjugate(upperint), win=3, edge=4) cor = np.zeros((length2*2, width2), dtype=np.float32) cor[0:length2*2:2, :] = np.sqrt( (np.absolute(lowerint)+np.absolute(upperint))/2.0 ) cor[1:length2*2:2, :] = cord cor.astype(np.float32).tofile(coherenceFile) create_xml(coherenceFile, width2, length2, 'cor') #create lower and upper band coherence files #lower amp1 = loweramp[:, 0:width2*2:2] amp2 = loweramp[:, 1:width2*2:2] cor[1:length2*2:2, :] = np.absolute(lowerint)/(amp1+(amp1==0))/(amp2+(amp2==0))*(amp1!=0)*(amp2!=0) cor.astype(np.float32).tofile(lowerbandCoherenceFile) create_xml(lowerbandCoherenceFile, width2, length2, 'cor') #upper amp1 = upperamp[:, 0:width2*2:2] amp2 = upperamp[:, 1:width2*2:2] cor[1:length2*2:2, :] = np.absolute(upperint)/(amp1+(amp1==0))/(amp2+(amp2==0))*(amp1!=0)*(amp2!=0) cor.astype(np.float32).tofile(upperbandCoherenceFile) create_xml(upperbandCoherenceFile, width2, length2, 'cor') ############################################################ # STEP 3. filtering subband interferograms ############################################################ from contrib.alos2filter.alos2filter import psfilt1 from isceobj.Alos2Proc.Alos2ProcPublic import runCmd from isceobj.Alos2Proc.Alos2ProcPublic import create_xml from mroipac.icu.Icu import Icu if self.filterSubbandInt: for k in range(2): toBeFiltered = 'tmp.int' if self.removeMagnitudeBeforeFilteringSubbandInt: cmd = "imageMath.py -e='a/(abs(a)+(a==0))' --a={} -o {} -t cfloat -s BSQ".format(subbandPrefix[k]+ml2+'.int', toBeFiltered) else: #scale the inteferogram, otherwise its magnitude is too large for filtering cmd = "imageMath.py -e='a/100000.0' --a={} -o {} -t cfloat -s BSQ".format(subbandPrefix[k]+ml2+'.int', toBeFiltered) runCmd(cmd) intImage = isceobj.createIntImage() intImage.load(toBeFiltered + '.xml') width = intImage.width length = intImage.length windowSize = self.filterWinsizeSubbandInt stepSize = self.filterStepsizeSubbandInt psfilt1(toBeFiltered, 'filt_'+subbandPrefix[k]+ml2+'.int', width, self.filterStrengthSubbandInt, windowSize, stepSize) create_xml('filt_'+subbandPrefix[k]+ml2+'.int', width, length, 'int') os.remove(toBeFiltered) os.remove(toBeFiltered + '.vrt') os.remove(toBeFiltered + '.xml') #create phase sigma for phase unwrapping #recreate filtered image filtImage = isceobj.createIntImage() filtImage.load('filt_'+subbandPrefix[k]+ml2+'.int' + '.xml') filtImage.setAccessMode('read') filtImage.createImage() #amplitude image ampImage = isceobj.createAmpImage() ampImage.load(subbandPrefix[k]+ml2+'.amp' + '.xml') ampImage.setAccessMode('read') ampImage.createImage() #phase sigma correlation image phsigImage = isceobj.createImage() phsigImage.setFilename(subbandPrefix[k]+ml2+'.phsig') phsigImage.setWidth(width) phsigImage.dataType='FLOAT' phsigImage.bands = 1 phsigImage.setImageType('cor') phsigImage.setAccessMode('write') phsigImage.createImage() icu = Icu(name='insarapp_filter_icu') icu.configure() icu.unwrappingFlag = False icu.icu(intImage = filtImage, ampImage=ampImage, phsigImage=phsigImage) phsigImage.renderHdr() filtImage.finalizeImage() ampImage.finalizeImage() phsigImage.finalizeImage() ############################################################ # STEP 4. phase unwrapping ############################################################ from isceobj.Alos2Proc.Alos2ProcPublic import snaphuUnwrap for k in range(2): tmid = masterTrack.sensingStart + datetime.timedelta(seconds=(self._insar.numberAzimuthLooks1-1.0)/2.0*masterTrack.azimuthLineInterval+ masterTrack.numberOfLines/2.0*self._insar.numberAzimuthLooks1*masterTrack.azimuthLineInterval) if self.filterSubbandInt: toBeUnwrapped = 'filt_'+subbandPrefix[k]+ml2+'.int' coherenceFile = subbandPrefix[k]+ml2+'.phsig' else: toBeUnwrapped = subbandPrefix[k]+ml2+'.int' coherenceFile = 'diff'+ml2+'.cor' snaphuUnwrap(masterTrack, tmid, toBeUnwrapped, coherenceFile, subbandPrefix[k]+ml2+'.unw', self._insar.numberRangeLooks1*self._insar.numberRangeLooksIon, self._insar.numberAzimuthLooks1*self._insar.numberAzimuthLooksIon, costMode = 'SMOOTH',initMethod = 'MCF', defomax = 2, initOnly = True) os.chdir('../../') catalog.printToLog(logger, "runIonUwrap") self._insar.procDoc.addAllFromCatalog(catalog)
def runUnwrapSnaphuSd(self): '''unwrap filtered interferogram ''' catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name) self.updateParamemetersFromUser() masterTrack = self._insar.loadTrack(master=True) #slaveTrack = self._insar.loadTrack(master=False) sdDir = 'sd' if not os.path.exists(sdDir): os.makedirs(sdDir) os.chdir(sdDir) ############################################################ # STEP 1. unwrap interferogram ############################################################ nsd = len(self._insar.filteredInterferogramSd) img = isceobj.createImage() img.load(self._insar.filteredInterferogramSd[0] + '.xml') width = img.width length = img.length if shutil.which('snaphu') != None: print( '\noriginal snaphu program found, use it for unwrapping interferograms' ) useOriginalSnaphu = True #create an amplitude for use # amplitude = os.path.join('../insar', self._insar.amplitude) # amplitudeMultilook = 'tmp.amp' # img = isceobj.createImage() # img.load(amplitude+'.xml') # look(amplitude, amplitudeMultilook, img.width, self._insar.numberRangeLooksSd, self._insar.numberAzimuthLooksSd, 4, 1, 1) else: useOriginalSnaphu = False for sdCoherence, sdInterferogramFilt, sdInterferogramUnwrap in zip( self._insar.multilookCoherenceSd, self._insar.filteredInterferogramSd, self._insar.unwrappedInterferogramSd): if useOriginalSnaphu: amplitudeMultilook = 'tmp.amp' cmd = "imageMath.py -e='sqrt(abs(a));sqrt(abs(a))' --a={} -o {} -t float -s BSQ".format( sdInterferogramFilt, amplitudeMultilook) runCmd(cmd) snaphuUnwrapOriginal(sdInterferogramFilt, sdCoherence, amplitudeMultilook, sdInterferogramUnwrap, costMode='s', initMethod='mcf') os.remove(amplitudeMultilook) os.remove(amplitudeMultilook + '.vrt') os.remove(amplitudeMultilook + '.xml') else: tmid = masterTrack.sensingStart + datetime.timedelta( seconds=(self._insar.numberAzimuthLooks1 - 1.0) / 2.0 * masterTrack.azimuthLineInterval + masterTrack.numberOfLines / 2.0 * self._insar.numberAzimuthLooks1 * masterTrack.azimuthLineInterval) snaphuUnwrap(masterTrack, tmid, sdInterferogramFilt, sdCoherence, sdInterferogramUnwrap, self._insar.numberRangeLooks1 * self._insar.numberRangeLooksSd, self._insar.numberAzimuthLooks1 * self._insar.numberAzimuthLooksSd, costMode='SMOOTH', initMethod='MCF', defomax=2, initOnly=True) #if useOriginalSnaphu: # os.remove(amplitudeMultilook) ############################################################ # STEP 2. mask using connected components ############################################################ for sdInterferogramUnwrap, sdInterferogramUnwrapMasked in zip( self._insar.unwrappedInterferogramSd, self._insar.unwrappedMaskedInterferogramSd): cmd = "imageMath.py -e='a_0*(b>0);a_1*(b>0)' --a={} --b={} -s BIL -t float -o={}".format( sdInterferogramUnwrap, sdInterferogramUnwrap + '.conncomp', sdInterferogramUnwrapMasked) runCmd(cmd) ############################################################ # STEP 3. mask using water body ############################################################ if self.waterBodyMaskStartingStepSd == 'unwrap': wbd = np.fromfile(self._insar.multilookWbdOutSd, dtype=np.int8).reshape(length, width) for sdInterferogramUnwrap, sdInterferogramUnwrapMasked in zip( self._insar.unwrappedInterferogramSd, self._insar.unwrappedMaskedInterferogramSd): unw = np.memmap(sdInterferogramUnwrap, dtype='float32', mode='r+', shape=(length * 2, width)) (unw[0:length * 2:2, :])[np.nonzero(wbd == -1)] = 0 (unw[1:length * 2:2, :])[np.nonzero(wbd == -1)] = 0 unw = np.memmap(sdInterferogramUnwrapMasked, dtype='float32', mode='r+', shape=(length * 2, width)) (unw[0:length * 2:2, :])[np.nonzero(wbd == -1)] = 0 (unw[1:length * 2:2, :])[np.nonzero(wbd == -1)] = 0 ############################################################ # STEP 4. convert to azimuth deformation ############################################################ #burst cycle in s burstCycleLength = masterTrack.frames[0].swaths[ 0].burstCycleLength / masterTrack.frames[0].swaths[0].prf #compute azimuth fmrate #stack all azimuth fmrates index = np.array([], dtype=np.float64) ka = np.array([], dtype=np.float64) for frame in masterTrack.frames: for swath in frame.swaths: startingRangeMultilook = masterTrack.frames[0].swaths[0].startingRange + \ (self._insar.numberRangeLooks1*self._insar.numberRangeLooksSd-1.0)/2.0*masterTrack.frames[0].swaths[0].rangePixelSize rangePixelSizeMultilook = self._insar.numberRangeLooks1 * self._insar.numberRangeLooksSd * masterTrack.frames[ 0].swaths[0].rangePixelSize index0 = (swath.startingRange + np.arange(swath.numberOfSamples) * swath.rangePixelSize - startingRangeMultilook) / rangePixelSizeMultilook ka0 = np.polyval(swath.azimuthFmrateVsPixel[::-1], np.arange(swath.numberOfSamples)) index = np.concatenate((index, index0)) ka = np.concatenate((ka, ka0)) p = np.polyfit(index, ka, 3) #new ka ka = np.polyval(p, np.arange(width)) #compute radar beam footprint velocity at middle track tmid = masterTrack.sensingStart + datetime.timedelta( seconds=(self._insar.numberAzimuthLooks1 - 1.0) / 2.0 * masterTrack.azimuthLineInterval + masterTrack.numberOfLines / 2.0 * self._insar.numberAzimuthLooks1 * masterTrack.azimuthLineInterval) svmid = masterTrack.orbit.interpolateOrbit(tmid, method='hermite') #earth radius in meters r = 6371 * 1000.0 #radar footprint velocity veln = np.linalg.norm(svmid.getVelocity()) * r / np.linalg.norm( svmid.getPosition()) print('radar beam footprint velocity at middle track: %8.2f m/s' % veln) #phase to defo factor factor = -1.0 * veln / (2.0 * np.pi * ka * burstCycleLength) #process unwrapped without mask sdunw_out = np.zeros((length * 2, width)) flag = np.zeros((length, width)) wgt = np.zeros((length, width)) for i in range(nsd): sdunw = np.fromfile(self._insar.unwrappedInterferogramSd[i], dtype=np.float32).reshape(length * 2, width) sdunw[1:length * 2:2, :] *= factor[None, :] / (i + 1.0) sdunw.astype(np.float32).tofile(self._insar.azimuthDeformationSd[i]) create_xml(self._insar.azimuthDeformationSd[i], width, length, 'rmg') flag += (sdunw[1:length * 2:2, :] != 0) #since the interferogram is filtered, we only use this light weight wgt0 = (i + 1)**2 wgt += wgt0 * (sdunw[1:length * 2:2, :] != 0) sdunw_out[0:length * 2:2, :] += (sdunw[0:length * 2:2, :])**2 sdunw_out[1:length * 2:2, :] += wgt0 * sdunw[1:length * 2:2, :] #output weighting average index = np.nonzero(flag != 0) (sdunw_out[0:length * 2:2, :])[index] = np.sqrt( (sdunw_out[0:length * 2:2, :])[index] / flag[index]) (sdunw_out[1:length * 2:2, :] )[index] = (sdunw_out[1:length * 2:2, :])[index] / wgt[index] if not self.unionSd: (sdunw_out[0:length * 2:2, :])[np.nonzero(flag < nsd)] = 0 (sdunw_out[1:length * 2:2, :])[np.nonzero(flag < nsd)] = 0 sdunw_out.astype(np.float32).tofile(self._insar.azimuthDeformationSd[-1]) create_xml(self._insar.azimuthDeformationSd[-1], width, length, 'rmg') #process unwrapped with mask sdunw_out = np.zeros((length * 2, width)) flag = np.zeros((length, width)) wgt = np.zeros((length, width)) for i in range(nsd): sdunw = np.fromfile(self._insar.unwrappedMaskedInterferogramSd[i], dtype=np.float32).reshape(length * 2, width) sdunw[1:length * 2:2, :] *= factor[None, :] / (i + 1.0) sdunw.astype(np.float32).tofile( self._insar.maskedAzimuthDeformationSd[i]) create_xml(self._insar.maskedAzimuthDeformationSd[i], width, length, 'rmg') flag += (sdunw[1:length * 2:2, :] != 0) #since the interferogram is filtered, we only use this light weight wgt0 = (i + 1)**2 wgt += wgt0 * (sdunw[1:length * 2:2, :] != 0) sdunw_out[0:length * 2:2, :] += (sdunw[0:length * 2:2, :])**2 sdunw_out[1:length * 2:2, :] += wgt0 * sdunw[1:length * 2:2, :] #output weighting average index = np.nonzero(flag != 0) (sdunw_out[0:length * 2:2, :])[index] = np.sqrt( (sdunw_out[0:length * 2:2, :])[index] / flag[index]) (sdunw_out[1:length * 2:2, :] )[index] = (sdunw_out[1:length * 2:2, :])[index] / wgt[index] if not self.unionSd: (sdunw_out[0:length * 2:2, :])[np.nonzero(flag < nsd)] = 0 (sdunw_out[1:length * 2:2, :])[np.nonzero(flag < nsd)] = 0 sdunw_out.astype(np.float32).tofile( self._insar.maskedAzimuthDeformationSd[-1]) create_xml(self._insar.maskedAzimuthDeformationSd[-1], width, length, 'rmg') os.chdir('../') catalog.printToLog(logger, "runUnwrapSnaphuSd") self._insar.procDoc.addAllFromCatalog(catalog)
def runDenseOffsetCPU(self): ''' Estimate dense offset field between a pair of SLCs. ''' from mroipac.ampcor.DenseAmpcor import DenseAmpcor from isceobj.Alos2Proc.Alos2ProcPublic import runCmd ####For this module currently, we need to create an actual file on disk for infile in [self._insar.referenceSlc, self._insar.secondarySlcCoregistered]: if os.path.isfile(infile): continue cmd = 'gdal_translate -of ENVI {0}.vrt {0}'.format(infile) runCmd(cmd) m = isceobj.createSlcImage() m.load(self._insar.referenceSlc + '.xml') m.setAccessMode('READ') s = isceobj.createSlcImage() s.load(self._insar.secondarySlcCoregistered + '.xml') s.setAccessMode('READ') #objOffset.numberThreads = 1 print('\n************* dense offset estimation parameters *************') print('reference SLC: %s' % (self._insar.referenceSlc)) print('secondary SLC: %s' % (self._insar.secondarySlcCoregistered)) print('dense offset estimation window width: %d' % (self.offsetWindowWidth)) print('dense offset estimation window hight: %d' % (self.offsetWindowHeight)) print('dense offset search window width: %d' % (self.offsetSearchWindowWidth)) print('dense offset search window hight: %d' % (self.offsetSearchWindowHeight)) print('dense offset skip width: %d' % (self.offsetSkipWidth)) print('dense offset skip hight: %d' % (self.offsetSkipHeight)) print('dense offset covariance surface oversample factor: %d' % (self.offsetCovarianceOversamplingFactor)) print('dense offset covariance surface oversample window size: %d\n' % (self.offsetCovarianceOversamplingWindowsize)) objOffset = DenseAmpcor(name='dense') objOffset.configure() if m.dataType.startswith('C'): objOffset.setImageDataType1('complex') else: objOffset.setImageDataType1('real') if s.dataType.startswith('C'): objOffset.setImageDataType2('complex') else: objOffset.setImageDataType2('real') objOffset.offsetImageName = self._insar.denseOffset objOffset.snrImageName = self._insar.denseOffsetSnr objOffset.covImageName = self._insar.denseOffsetCov objOffset.setWindowSizeWidth(self.offsetWindowWidth) objOffset.setWindowSizeHeight(self.offsetWindowHeight) #NOTE: actual number of resulting correlation pixels: self.offsetSearchWindowWidth*2+1 objOffset.setSearchWindowSizeWidth(self.offsetSearchWindowWidth) objOffset.setSearchWindowSizeHeight(self.offsetSearchWindowHeight) objOffset.setSkipSampleAcross(self.offsetSkipWidth) objOffset.setSkipSampleDown(self.offsetSkipHeight) objOffset.setOversamplingFactor(self.offsetCovarianceOversamplingFactor) objOffset.setZoomWindowSize(self.offsetCovarianceOversamplingWindowsize) objOffset.setAcrossGrossOffset(0) objOffset.setDownGrossOffset(0) #these are azimuth scaling factor #Matching Scale for Sample/Line Directions (-) = 1.000000551500 1.000002373200 objOffset.setFirstPRF(1.0) objOffset.setSecondPRF(1.0) objOffset.denseampcor(m, s) ### Store params for later self._insar.offsetImageTopoffset = objOffset.locationDown[0][0] self._insar.offsetImageLeftoffset = objOffset.locationAcross[0][0] #change band order width=objOffset.offsetCols length=objOffset.offsetLines offset1 = np.fromfile(self._insar.denseOffset, dtype=np.float32).reshape(length*2, width) offset2 = np.zeros((length*2, width), dtype=np.float32) offset2[0:length*2:2, :] = offset1[1:length*2:2, :] offset2[1:length*2:2, :] = offset1[0:length*2:2, :] os.remove(self._insar.denseOffset) os.remove(self._insar.denseOffset+'.vrt') os.remove(self._insar.denseOffset+'.xml') offset2.astype(np.float32).tofile(self._insar.denseOffset) outImg = isceobj.createImage() outImg.setDataType('FLOAT') outImg.setFilename(self._insar.denseOffset) outImg.setBands(2) outImg.scheme = 'BIL' outImg.setWidth(width) outImg.setLength(length) outImg.addDescription('two-band pixel offset file. 1st band: range offset, 2nd band: azimuth offset') outImg.setAccessMode('read') outImg.renderHdr() return (objOffset.offsetCols, objOffset.offsetLines)
def runLook(self): '''take looks ''' catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name) self.updateParamemetersFromUser() #masterTrack = self._insar.loadTrack(master=True) #slaveTrack = self._insar.loadTrack(master=False) wbdFile = os.path.abspath(self._insar.wbd) insarDir = 'insar' os.makedirs(insarDir, exist_ok=True) os.chdir(insarDir) amp = isceobj.createImage() amp.load(self._insar.amplitude + '.xml') width = amp.width length = amp.length width2 = int(width / self._insar.numberRangeLooks2) length2 = int(length / self._insar.numberAzimuthLooks2) if not ((self._insar.numberRangeLooks2 == 1) and (self._insar.numberAzimuthLooks2 == 1)): #take looks look(self._insar.differentialInterferogram, self._insar.multilookDifferentialInterferogram, width, self._insar.numberRangeLooks2, self._insar.numberAzimuthLooks2, 4, 0, 1) look(self._insar.amplitude, self._insar.multilookAmplitude, width, self._insar.numberRangeLooks2, self._insar.numberAzimuthLooks2, 4, 1, 1) look(self._insar.latitude, self._insar.multilookLatitude, width, self._insar.numberRangeLooks2, self._insar.numberAzimuthLooks2, 3, 0, 1) look(self._insar.longitude, self._insar.multilookLongitude, width, self._insar.numberRangeLooks2, self._insar.numberAzimuthLooks2, 3, 0, 1) look(self._insar.height, self._insar.multilookHeight, width, self._insar.numberRangeLooks2, self._insar.numberAzimuthLooks2, 3, 0, 1) #creat xml create_xml(self._insar.multilookDifferentialInterferogram, width2, length2, 'int') create_xml(self._insar.multilookAmplitude, width2, length2, 'amp') create_xml(self._insar.multilookLatitude, width2, length2, 'double') create_xml(self._insar.multilookLongitude, width2, length2, 'double') create_xml(self._insar.multilookHeight, width2, length2, 'double') #los has two bands, use look program in isce instead cmd = "looks.py -i {} -o {} -r {} -a {}".format( self._insar.los, self._insar.multilookLos, self._insar.numberRangeLooks2, self._insar.numberAzimuthLooks2) runCmd(cmd) #water body #this looking operation has no problems where there is only water and land, but there is also possible no-data area #look(self._insar.wbdOut, self._insar.multilookWbdOut, width, self._insar.numberRangeLooks2, self._insar.numberAzimuthLooks2, 0, 0, 1) #create_xml(self._insar.multilookWbdOut, width2, length2, 'byte') #use waterBodyRadar instead to avoid the problems of no-data pixels in water body waterBodyRadar(self._insar.multilookLatitude, self._insar.multilookLongitude, wbdFile, self._insar.multilookWbdOut) os.chdir('../') catalog.printToLog(logger, "runLook") self._insar.procDoc.addAllFromCatalog(catalog)
'filt_ion_*rlks_*alks.ion'))[0] diff = glob.glob( os.path.join(idir, ipair, 'ion', 'ion_cal', 'diff_{}_*rlks_*alks.int'.format(ipair)))[0] if wbdMsk: wbd = glob.glob( os.path.join(idir, ipair, 'ion', 'ion_cal', 'wbd_*rlks_*alks.wbd'))[0] wbdArguments = ' {} -s {} -i1 -cmap grey -percent 100'.format( wbd, width) else: wbdArguments = '' runCmd( 'mdx {} -s {} -c8pha -cmap cmy -wrap 6.283185307179586 -addr -3.141592653589793{} -P -workdir {}' .format(diffOriginal, width, wbdArguments, odir)) runCmd('mv {} {}'.format(os.path.join(odir, 'out.ppm'), os.path.join(odir, 'out1.ppm'))) runCmd( 'mdx {} -s {} -cmap cmy -wrap 6.283185307179586 -addr -3.141592653589793{} -P -workdir {}' .format(ion, width, wbdArguments, odir)) runCmd('mv {} {}'.format(os.path.join(odir, 'out.ppm'), os.path.join(odir, 'out2.ppm'))) runCmd( 'mdx {} -s {} -c8pha -cmap cmy -wrap 6.283185307179586 -addr -3.141592653589793{} -P -workdir {}' .format(diff, width, wbdArguments, odir)) runCmd('mv {} {}'.format(os.path.join(odir, 'out.ppm'), os.path.join(odir, 'out3.ppm'))) runCmd( "montage -pointsize {} -label 'original' {} -label 'ionosphere' {} -label 'corrected' {} -geometry +{} -compress LZW{} {}.tif"
def runIonCorrect(self): '''resample original ionosphere and ionospheric correction ''' 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, "runIonCorrect") self._insar.procDoc.addAllFromCatalog(catalog) return referenceTrack = self._insar.loadTrack(reference=True) secondaryTrack = self._insar.loadTrack(reference=False) from isceobj.Alos2Proc.runIonSubband import defineIonDir ionDir = defineIonDir() subbandPrefix = ['lower', 'upper'] ionCalDir = os.path.join(ionDir['ion'], ionDir['ionCal']) os.makedirs(ionCalDir, exist_ok=True) os.chdir(ionCalDir) ############################################################ # STEP 3. resample ionospheric phase ############################################################ from contrib.alos2proc_f.alos2proc_f import rect from isceobj.Alos2Proc.Alos2ProcPublic import create_xml from scipy.interpolate import interp1d import shutil ################################################# #SET PARAMETERS HERE #interpolation method interpolationMethod = 1 ################################################# print('\ninterpolate ionosphere') ml2 = '_{}rlks_{}alks'.format( self._insar.numberRangeLooks1 * self._insar.numberRangeLooksIon, self._insar.numberAzimuthLooks1 * self._insar.numberAzimuthLooksIon) ml3 = '_{}rlks_{}alks'.format( self._insar.numberRangeLooks1 * self._insar.numberRangeLooks2, self._insar.numberAzimuthLooks1 * self._insar.numberAzimuthLooks2) ionfiltfile = 'filt_ion' + ml2 + '.ion' #ionrectfile = 'filt_ion'+ml3+'.ion' ionrectfile = self._insar.multilookIon img = isceobj.createImage() img.load(ionfiltfile + '.xml') width2 = img.width length2 = img.length img = isceobj.createImage() img.load( os.path.join('../../', ionDir['insar'], self._insar.multilookDifferentialInterferogram) + '.xml') width3 = img.width length3 = img.length #number of range looks output nrlo = self._insar.numberRangeLooks1 * self._insar.numberRangeLooks2 #number of range looks input nrli = self._insar.numberRangeLooks1 * self._insar.numberRangeLooksIon #number of azimuth looks output nalo = self._insar.numberAzimuthLooks1 * self._insar.numberAzimuthLooks2 #number of azimuth looks input nali = self._insar.numberAzimuthLooks1 * self._insar.numberAzimuthLooksIon if (self._insar.numberRangeLooks2 != self._insar.numberRangeLooksIon) or \ (self._insar.numberAzimuthLooks2 != self._insar.numberAzimuthLooksIon): #this should be faster using fortran if interpolationMethod == 0: rect(ionfiltfile, ionrectfile, width2, length2, width3, length3, nrlo / nrli, 0.0, 0.0, nalo / nali, (nrlo - nrli) / (2.0 * nrli), (nalo - nali) / (2.0 * nali), 'REAL', 'Bilinear') #finer, but slower method else: ionfilt = np.fromfile(ionfiltfile, dtype=np.float32).reshape(length2, width2) index2 = np.linspace(0, width2 - 1, num=width2, endpoint=True) index3 = np.linspace(0, width3 - 1, num=width3, endpoint=True ) * nrlo / nrli + (nrlo - nrli) / (2.0 * nrli) ionrect = np.zeros((length3, width3), dtype=np.float32) for i in range(length2): f = interp1d(index2, ionfilt[i, :], kind='cubic', fill_value="extrapolate") ionrect[i, :] = f(index3) index2 = np.linspace(0, length2 - 1, num=length2, endpoint=True) index3 = np.linspace(0, length3 - 1, num=length3, endpoint=True ) * nalo / nali + (nalo - nali) / (2.0 * nali) for j in range(width3): f = interp1d(index2, ionrect[0:length2, j], kind='cubic', fill_value="extrapolate") ionrect[:, j] = f(index3) ionrect.astype(np.float32).tofile(ionrectfile) del ionrect create_xml(ionrectfile, width3, length3, 'float') os.rename(ionrectfile, os.path.join('../../insar', ionrectfile)) os.rename(ionrectfile + '.vrt', os.path.join('../../insar', ionrectfile) + '.vrt') os.rename(ionrectfile + '.xml', os.path.join('../../insar', ionrectfile) + '.xml') os.chdir('../../insar') else: shutil.copyfile(ionfiltfile, os.path.join('../../insar', ionrectfile)) os.chdir('../../insar') create_xml(ionrectfile, width3, length3, 'float') #now we are in 'insar' ############################################################ # STEP 4. correct interferogram ############################################################ from isceobj.Alos2Proc.Alos2ProcPublic import renameFile from isceobj.Alos2Proc.Alos2ProcPublic import runCmd if self.applyIon: print('\ncorrect interferogram') if os.path.isfile( self._insar.multilookDifferentialInterferogramOriginal): print( 'original interferogram: {} is already here, do not rename: {}' .format(self._insar.multilookDifferentialInterferogramOriginal, self._insar.multilookDifferentialInterferogram)) else: print('renaming {} to {}'.format( self._insar.multilookDifferentialInterferogram, self._insar.multilookDifferentialInterferogramOriginal)) renameFile(self._insar.multilookDifferentialInterferogram, self._insar.multilookDifferentialInterferogramOriginal) cmd = "imageMath.py -e='a*exp(-1.0*J*b)' --a={} --b={} -s BIP -t cfloat -o {}".format( self._insar.multilookDifferentialInterferogramOriginal, self._insar.multilookIon, self._insar.multilookDifferentialInterferogram) runCmd(cmd) else: print( '\nionospheric phase estimation finished, but correction of interfeorgram not requested' ) os.chdir('../') catalog.printToLog(logger, "runIonCorrect") self._insar.procDoc.addAllFromCatalog(catalog)
def runFilt(self): '''filter interferogram ''' catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name) self.updateParamemetersFromUser() #masterTrack = self._insar.loadTrack(master=True) #slaveTrack = self._insar.loadTrack(master=False) insarDir = 'insar' if not os.path.exists(insarDir): os.makedirs(insarDir) os.chdir(insarDir) ############################################################ # STEP 1. filter interferogram ############################################################ print('\nfilter interferogram: {}'.format( self._insar.multilookDifferentialInterferogram)) toBeFiltered = self._insar.multilookDifferentialInterferogram if self.removeMagnitudeBeforeFiltering: toBeFiltered = 'tmp.int' cmd = "imageMath.py -e='a/(abs(a)+(a==0))' --a={} -o {} -t cfloat -s BSQ".format( self._insar.multilookDifferentialInterferogram, toBeFiltered) runCmd(cmd) #if shutil.which('psfilt1') != None: if True: intImage = isceobj.createIntImage() intImage.load(toBeFiltered + '.xml') width = intImage.width length = intImage.length # cmd = "psfilt1 {int} {filtint} {width} {filterstrength} 64 16".format( # int = toBeFiltered, # filtint = self._insar.filteredInterferogram, # width = width, # filterstrength = self.filterStrength # ) # runCmd(cmd) windowSize = self.filterWinsize stepSize = self.filterStepsize psfilt1(toBeFiltered, self._insar.filteredInterferogram, width, self.filterStrength, windowSize, stepSize) create_xml(self._insar.filteredInterferogram, width, length, 'int') else: #original intImage = isceobj.createIntImage() intImage.load(toBeFiltered + '.xml') intImage.setAccessMode('read') intImage.createImage() width = intImage.width length = intImage.length #filtered filtImage = isceobj.createIntImage() filtImage.setFilename(self._insar.filteredInterferogram) filtImage.setWidth(width) filtImage.setAccessMode('write') filtImage.createImage() #looks like the ps filtering program keep the original interferogram magnitude, which is bad for phase unwrapping? filters = Filter() filters.wireInputPort(name='interferogram', object=intImage) filters.wireOutputPort(name='filtered interferogram', object=filtImage) filters.goldsteinWerner(alpha=self.filterStrength) intImage.finalizeImage() filtImage.finalizeImage() del intImage, filtImage, filters if self.removeMagnitudeBeforeFiltering: os.remove(toBeFiltered) os.remove(toBeFiltered + '.vrt') os.remove(toBeFiltered + '.xml') #restore original magnitude tmpFile = 'tmp.int' renameFile(self._insar.filteredInterferogram, tmpFile) cmd = "imageMath.py -e='a*abs(b)' --a={} --b={} -o {} -t cfloat -s BSQ".format( tmpFile, self._insar.multilookDifferentialInterferogram, self._insar.filteredInterferogram) runCmd(cmd) os.remove(tmpFile) os.remove(tmpFile + '.vrt') os.remove(tmpFile + '.xml') ############################################################ # STEP 2. create phase sigma using filtered interferogram ############################################################ print('\ncreate phase sigma using: {}'.format( self._insar.filteredInterferogram)) #recreate filtered image filtImage = isceobj.createIntImage() filtImage.load(self._insar.filteredInterferogram + '.xml') filtImage.setAccessMode('read') filtImage.createImage() #amplitude image ampImage = isceobj.createAmpImage() ampImage.load(self._insar.multilookAmplitude + '.xml') ampImage.setAccessMode('read') ampImage.createImage() #phase sigma correlation image phsigImage = isceobj.createImage() phsigImage.setFilename(self._insar.multilookPhsig) phsigImage.setWidth(width) phsigImage.dataType = 'FLOAT' phsigImage.bands = 1 phsigImage.setImageType('cor') phsigImage.setAccessMode('write') phsigImage.createImage() icu = Icu(name='insarapp_filter_icu') icu.configure() icu.unwrappingFlag = False icu.icu(intImage=filtImage, ampImage=ampImage, phsigImage=phsigImage) phsigImage.renderHdr() filtImage.finalizeImage() ampImage.finalizeImage() phsigImage.finalizeImage() del filtImage del ampImage del phsigImage del icu ############################################################ # STEP 3. mask filtered interferogram using water body ############################################################ print('\nmask filtered interferogram using: {}'.format( self._insar.multilookWbdOut)) if self.waterBodyMaskStartingStep == 'filt': if not os.path.exists(self._insar.multilookWbdOut): catalog.addItem( 'warning message', 'requested masking interferogram with water body, but water body does not exist', 'runFilt') else: wbd = np.fromfile(self._insar.multilookWbdOut, dtype=np.int8).reshape(length, width) phsig = np.memmap(self._insar.multilookPhsig, dtype='float32', mode='r+', shape=(length, width)) phsig[np.nonzero(wbd == -1)] = 0 del phsig filt = np.memmap(self._insar.filteredInterferogram, dtype='complex64', mode='r+', shape=(length, width)) filt[np.nonzero(wbd == -1)] = 0 del filt del wbd os.chdir('../') catalog.printToLog(logger, "runFilt") 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 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] 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 #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 #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=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( 'frame {} {} band subswath phase diff input'.format( frameNumber, ionDir['subband'][k]), phaseDiff[1:], 'runIonSubband') catalog.addItem( 'frame {} {} band subswath phase diff estimated'.format( frameNumber, ionDir['subband'][k]), phaseDiffEst[1:], 'runIonSubband') catalog.addItem( 'frame {} {} band subswath phase diff used'.format( frameNumber, ionDir['subband'][k]), phaseDiffUsed[1:], 'runIonSubband') catalog.addItem( 'frame {} {} band subswath phase diff used source'.format( frameNumber, ionDir['subband'][k]), phaseDiffSource[1:], 'runIonSubband') catalog.addItem( 'frame {} {} band subswath 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 subswath 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') 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 (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') 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)
#os.makedirs(insarDir, exist_ok=True) os.chdir(insarDir) if not os.path.isfile(ionosphereReference): raise Exception( 'ionospheric phase file: {} of reference date does not exist in {}.\n' .format(os.path.basename(ionosphereReference), ion_dir)) if not os.path.isfile(ionosphereSecondary): raise Exception( 'ionospheric phase file: {} of secondary date does not exist in {}.\n' .format(os.path.basename(ionosphereSecondary), ion_dir)) #correct interferogram if os.path.isfile(multilookDifferentialInterferogramOriginal): print('original interferogram: {} is already here, do not rename: {}'. format(multilookDifferentialInterferogramOriginal, multilookDifferentialInterferogram)) else: print('renaming {} to {}'.format( multilookDifferentialInterferogram, multilookDifferentialInterferogramOriginal)) renameFile(multilookDifferentialInterferogram, multilookDifferentialInterferogramOriginal) cmd = "imageMath.py -e='a*exp(-1.0*J*(b-c))' --a={} --b={} --c={} -s BIP -t cfloat -o {}".format( multilookDifferentialInterferogramOriginal, ionosphereReference, ionosphereSecondary, multilookDifferentialInterferogram) runCmd(cmd) os.chdir('../')
img = isceobj.createImage() img.load(os.path.join(idir, pairs[0], 'ion_cal', 'filt.ion.xml')) width = img.width length = img.length widthMax = 600 if width >= widthMax: ratio = widthMax / width resize = ' -resize {}%'.format(ratio*100.0) else: ratio = 1.0 resize = '' for ipair in pairs: ion = os.path.join(idir, ipair, 'ion_cal', 'filt.ion') runCmd('mdx {} -s {} -rhdr {} -cmap cmy -wrap 6.283185307179586 -addr -3.141592653589793 -P -workdir {}'.format(ion, width, width*4, odir)) runCmd("montage -pointsize {} -label '{}' {} -geometry +{} -compress LZW{} {}.tif".format( int((ratio*width)/111*9+0.5), ipair, os.path.join(odir, 'out.ppm'), int((ratio*width)/111*5+0.5), resize, os.path.join(odir, ipair))) runCmd('rm {}'.format(os.path.join(odir, 'out.ppm'))) #create colorbar width_colorbar = 100 length_colorbar = 20 colorbar = np.ones((length_colorbar, width_colorbar), dtype=np.float32) * \ (np.linspace(-np.pi, np.pi, num=width_colorbar,endpoint=True,dtype=np.float32))[None,:]
def runDenseOffsetGPU(self): ''' Estimate dense offset field between a pair of SLCs. ''' from contrib.PyCuAmpcor import PyCuAmpcor from isceobj.Alos2Proc.Alos2ProcPublic import runCmd from isceobj.Alos2Proc.Alos2ProcPublic import create_xml ############################################################################################ # #different from minyan's script: cuDenseOffsets.py: deramp method (0: mag, 1: complex) # objOffset.derampMethod = 2 # # #varying-gross-offset parameters not set # #not set in minyan's script: cuDenseOffsets.py # objOffset.corrSurfaceZoomInWindow # objOffset.grossOffsetAcrossStatic = 0 # objOffset.grossOffsetDownStatic = 0 ############################################################################################ ####For this module currently, we need to create an actual file on disk for infile in [self._insar.referenceSlc, self._insar.secondarySlcCoregistered]: if os.path.isfile(infile): continue cmd = 'gdal_translate -of ENVI {0}.vrt {0}'.format(infile) runCmd(cmd) m = isceobj.createSlcImage() m.load(self._insar.referenceSlc + '.xml') m.setAccessMode('READ') s = isceobj.createSlcImage() s.load(self._insar.secondarySlcCoregistered + '.xml') s.setAccessMode('READ') print('\n************* dense offset estimation parameters *************') print('reference SLC: %s' % (self._insar.referenceSlc)) print('secondary SLC: %s' % (self._insar.secondarySlcCoregistered)) print('dense offset estimation window width: %d' % (self.offsetWindowWidth)) print('dense offset estimation window hight: %d' % (self.offsetWindowHeight)) print('dense offset search window width: %d' % (self.offsetSearchWindowWidth)) print('dense offset search window hight: %d' % (self.offsetSearchWindowHeight)) print('dense offset skip width: %d' % (self.offsetSkipWidth)) print('dense offset skip hight: %d' % (self.offsetSkipHeight)) print('dense offset covariance surface oversample factor: %d' % (self.offsetCovarianceOversamplingFactor)) objOffset = PyCuAmpcor.PyCuAmpcor() objOffset.algorithm = 0 objOffset.derampMethod = 1 # 1=linear phase ramp, 0=take mag, 2=skip objOffset.referenceImageName = self._insar.referenceSlc objOffset.referenceImageHeight = m.length objOffset.referenceImageWidth = m.width objOffset.secondaryImageName = self._insar.secondarySlcCoregistered objOffset.secondaryImageHeight = s.length objOffset.secondaryImageWidth = s.width objOffset.offsetImageName = self._insar.denseOffset objOffset.grossOffsetImageName = self._insar.denseOffset + ".gross" objOffset.snrImageName = self._insar.denseOffsetSnr objOffset.covImageName = self._insar.denseOffsetCov objOffset.windowSizeWidth = self.offsetWindowWidth objOffset.windowSizeHeight = self.offsetWindowHeight objOffset.halfSearchRangeAcross = self.offsetSearchWindowWidth objOffset.halfSearchRangeDown = self.offsetSearchWindowHeight objOffset.skipSampleDown = self.offsetSkipHeight objOffset.skipSampleAcross = self.offsetSkipWidth #Oversampling method for correlation surface(0=fft,1=sinc) objOffset.corrSurfaceOverSamplingMethod = 0 objOffset.corrSurfaceOverSamplingFactor = self.offsetCovarianceOversamplingFactor # set gross offset objOffset.grossOffsetAcrossStatic = 0 objOffset.grossOffsetDownStatic = 0 # set the margin margin = 0 # adjust the margin margin = max(margin, abs(objOffset.grossOffsetAcrossStatic), abs(objOffset.grossOffsetDownStatic)) # set the starting pixel of the first reference window objOffset.referenceStartPixelDownStatic = margin + self.offsetSearchWindowHeight objOffset.referenceStartPixelAcrossStatic = margin + self.offsetSearchWindowWidth # find out the total number of windows objOffset.numberWindowDown = (m.length - 2*margin - 2*self.offsetSearchWindowHeight - self.offsetWindowHeight) // self.offsetSkipHeight objOffset.numberWindowAcross = (m.width - 2*margin - 2*self.offsetSearchWindowWidth - self.offsetWindowWidth) // self.offsetSkipWidth # gpu job control objOffset.deviceID = 0 objOffset.nStreams = 2 objOffset.numberWindowDownInChunk = 1 objOffset.numberWindowAcrossInChunk = 64 objOffset.mmapSize = 16 # pass/adjust the parameters objOffset.setupParams() # set up the starting pixels for each window, based on the gross offset objOffset.setConstantGrossOffset(objOffset.grossOffsetAcrossStatic, objOffset.grossOffsetDownStatic) # check whether all pixels are in image range (optional) objOffset.checkPixelInImageRange() print('\n======================================') print('Running PyCuAmpcor...') print('======================================\n') objOffset.runAmpcor() ### Store params for later # location of the center of the first reference window self._insar.offsetImageTopoffset = objOffset.referenceStartPixelDownStatic + (objOffset.windowSizeHeight-1)//2 self._insar.offsetImageLeftoffset = objOffset.referenceStartPixelAcrossStatic +(objOffset.windowSizeWidth-1)//2 # offset image dimension, the number of windows width = objOffset.numberWindowAcross length = objOffset.numberWindowDown # convert the offset image from BIP to BIL offsetBIP = np.fromfile(objOffset.offsetImageName, dtype=np.float32).reshape(length, width*2) offsetBIL = np.zeros((length*2, width), dtype=np.float32) offsetBIL[0:length*2:2, :] = offsetBIP[:, 1:width*2:2] offsetBIL[1:length*2:2, :] = offsetBIP[:, 0:width*2:2] os.remove(objOffset.offsetImageName) offsetBIL.astype(np.float32).tofile(objOffset.offsetImageName) # generate offset image description files outImg = isceobj.createImage() outImg.setDataType('FLOAT') outImg.setFilename(objOffset.offsetImageName) outImg.setBands(2) outImg.scheme = 'BIL' outImg.setWidth(objOffset.numberWindowAcross) outImg.setLength(objOffset.numberWindowDown) outImg.addDescription('two-band pixel offset file. 1st band: range offset, 2nd band: azimuth offset') outImg.setAccessMode('read') outImg.renderHdr() # gross offset image is not needed, since all zeros # generate snr image description files snrImg = isceobj.createImage() snrImg.setFilename( objOffset.snrImageName) snrImg.setDataType('FLOAT') snrImg.setBands(1) snrImg.setWidth(objOffset.numberWindowAcross) snrImg.setLength(objOffset.numberWindowDown) snrImg.setAccessMode('read') snrImg.renderHdr() # generate cov image description files # covariance of azimuth/range offsets. # 1st band: cov(az, az), 2nd band: cov(rg, rg), 3rd band: cov(az, rg) covImg = isceobj.createImage() covImg.setFilename(objOffset.covImageName) covImg.setDataType('FLOAT') covImg.setBands(3) covImg.scheme = 'BIP' covImg.setWidth(objOffset.numberWindowAcross) covImg.setLength(objOffset.numberWindowDown) outImg.addDescription('covariance of azimuth/range offsets') covImg.setAccessMode('read') covImg.renderHdr() return (objOffset.numberWindowAcross, objOffset.numberWindowDown)
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)
def runIonFilt(self): '''compute and filter ionospheric phase ''' catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name) self.updateParamemetersFromUser() if not self.doIon: catalog.printToLog(logger, "runIonFilt") self._insar.procDoc.addAllFromCatalog(catalog) return masterTrack = self._insar.loadTrack(master=True) slaveTrack = self._insar.loadTrack(master=False) from isceobj.Alos2Proc.runIonSubband import defineIonDir ionDir = defineIonDir() subbandPrefix = ['lower', 'upper'] ionCalDir = os.path.join(ionDir['ion'], ionDir['ionCal']) if not os.path.exists(ionCalDir): os.makedirs(ionCalDir) os.chdir(ionCalDir) ############################################################ # STEP 1. compute ionospheric phase ############################################################ from isceobj.Constants import SPEED_OF_LIGHT from isceobj.Alos2Proc.Alos2ProcPublic import create_xml ################################### #SET PARAMETERS HERE #THESE SHOULD BE GOOD ENOUGH, NO NEED TO SET IN setup(self) corThresholdAdj = 0.85 ################################### print('\ncomputing ionosphere') #get files ml2 = '_{}rlks_{}alks'.format(self._insar.numberRangeLooks1*self._insar.numberRangeLooksIon, self._insar.numberAzimuthLooks1*self._insar.numberAzimuthLooksIon) lowerUnwfile = subbandPrefix[0]+ml2+'.unw' upperUnwfile = subbandPrefix[1]+ml2+'.unw' corfile = 'diff'+ml2+'.cor' #use image size from lower unwrapped interferogram img = isceobj.createImage() img.load(lowerUnwfile + '.xml') width = img.width length = img.length lowerUnw = (np.fromfile(lowerUnwfile, dtype=np.float32).reshape(length*2, width))[1:length*2:2, :] upperUnw = (np.fromfile(upperUnwfile, dtype=np.float32).reshape(length*2, width))[1:length*2:2, :] cor = (np.fromfile(corfile, dtype=np.float32).reshape(length*2, width))[1:length*2:2, :] #amp = (np.fromfile(corfile, dtype=np.float32).reshape(length*2, width))[0:length*2:2, :] #masked out user-specified areas if self.maskedAreasIon != None: maskedAreas = reformatMaskedAreas(self.maskedAreasIon, length, width) for area in maskedAreas: lowerUnw[area[0]:area[1], area[2]:area[3]] = 0 upperUnw[area[0]:area[1], area[2]:area[3]] = 0 cor[area[0]:area[1], area[2]:area[3]] = 0 #compute ionosphere fl = SPEED_OF_LIGHT / self._insar.subbandRadarWavelength[0] fu = SPEED_OF_LIGHT / self._insar.subbandRadarWavelength[1] adjFlag = 1 ionos = computeIonosphere(lowerUnw, upperUnw, cor, fl, fu, adjFlag, corThresholdAdj, 0) #dump ionosphere ionfile = 'ion'+ml2+'.ion' # ion = np.zeros((length*2, width), dtype=np.float32) # ion[0:length*2:2, :] = amp # ion[1:length*2:2, :] = ionos # ion.astype(np.float32).tofile(ionfile) # img.filename = ionfile # img.extraFilename = ionfile + '.vrt' # img.renderHdr() ionos.astype(np.float32).tofile(ionfile) create_xml(ionfile, width, length, 'float') ############################################################ # STEP 2. filter ionospheric phase ############################################################ ################################################# #SET PARAMETERS HERE #if applying polynomial fitting #False: no fitting, True: with fitting fit = self.fitIon #gaussian filtering window size size_max = self.filteringWinsizeMaxIon size_min = self.filteringWinsizeMinIon #THESE SHOULD BE GOOD ENOUGH, NO NEED TO SET IN setup(self) corThresholdIon = 0.85 ################################################# print('\nfiltering ionosphere') ionfile = 'ion'+ml2+'.ion' corfile = 'diff'+ml2+'.cor' ionfiltfile = 'filt_ion'+ml2+'.ion' img = isceobj.createImage() img.load(ionfile + '.xml') width = img.width length = img.length #ion = (np.fromfile(ionfile, dtype=np.float32).reshape(length*2, width))[1:length*2:2, :] ion = np.fromfile(ionfile, dtype=np.float32).reshape(length, width) cor = (np.fromfile(corfile, dtype=np.float32).reshape(length*2, width))[1:length*2:2, :] #amp = (np.fromfile(ionfile, dtype=np.float32).reshape(length*2, width))[0:length*2:2, :] #masked out user-specified areas if self.maskedAreasIon != None: maskedAreas = reformatMaskedAreas(self.maskedAreasIon, length, width) for area in maskedAreas: ion[area[0]:area[1], area[2]:area[3]] = 0 cor[area[0]:area[1], area[2]:area[3]] = 0 #remove possible wired values in coherence cor[np.nonzero(cor<0)] = 0.0 cor[np.nonzero(cor>1)] = 0.0 # #applying water body mask here # waterBodyFile = 'wbd'+ml2+'.wbd' # if os.path.isfile(waterBodyFile): # print('applying water body mask to coherence used to compute ionospheric phase') # wbd = np.fromfile(waterBodyFile, dtype=np.int8).reshape(length, width) # cor[np.nonzero(wbd!=0)] = 0.00001 if fit: ion_fit = weight_fitting(ion, cor, width, length, 1, 1, 1, 1, 2, corThresholdIon) ion -= ion_fit * (ion!=0) #minimize the effect of low coherence pixels #cor[np.nonzero( (cor<0.85)*(cor!=0) )] = 0.00001 #filt = adaptive_gaussian(ion, cor, size_max, size_min) #cor**14 should be a good weight to use. 22-APR-2018 filt = adaptive_gaussian(ion, cor**14, size_max, size_min) if fit: filt += ion_fit * (filt!=0) # ion = np.zeros((length*2, width), dtype=np.float32) # ion[0:length*2:2, :] = amp # ion[1:length*2:2, :] = filt # ion.astype(np.float32).tofile(ionfiltfile) # img.filename = ionfiltfile # img.extraFilename = ionfiltfile + '.vrt' # img.renderHdr() filt.astype(np.float32).tofile(ionfiltfile) create_xml(ionfiltfile, width, length, 'float') ############################################################ # STEP 3. resample ionospheric phase ############################################################ from contrib.alos2proc_f.alos2proc_f import rect from isceobj.Alos2Proc.Alos2ProcPublic import create_xml from scipy.interpolate import interp1d import shutil ################################################# #SET PARAMETERS HERE #interpolation method interpolationMethod = 1 ################################################# print('\ninterpolate ionosphere') ml3 = '_{}rlks_{}alks'.format(self._insar.numberRangeLooks1*self._insar.numberRangeLooks2, self._insar.numberAzimuthLooks1*self._insar.numberAzimuthLooks2) ionfiltfile = 'filt_ion'+ml2+'.ion' #ionrectfile = 'filt_ion'+ml3+'.ion' ionrectfile = self._insar.multilookIon img = isceobj.createImage() img.load(ionfiltfile + '.xml') width2 = img.width length2 = img.length img = isceobj.createImage() img.load(os.path.join('../../', ionDir['insar'], self._insar.multilookDifferentialInterferogram) + '.xml') width3 = img.width length3 = img.length #number of range looks output nrlo = self._insar.numberRangeLooks1*self._insar.numberRangeLooks2 #number of range looks input nrli = self._insar.numberRangeLooks1*self._insar.numberRangeLooksIon #number of azimuth looks output nalo = self._insar.numberAzimuthLooks1*self._insar.numberAzimuthLooks2 #number of azimuth looks input nali = self._insar.numberAzimuthLooks1*self._insar.numberAzimuthLooksIon if (self._insar.numberRangeLooks2 != self._insar.numberRangeLooksIon) or \ (self._insar.numberAzimuthLooks2 != self._insar.numberAzimuthLooksIon): #this should be faster using fortran if interpolationMethod == 0: rect(ionfiltfile, ionrectfile, width2,length2, width3,length3, nrlo/nrli, 0.0, 0.0, nalo/nali, (nrlo-nrli)/(2.0*nrli), (nalo-nali)/(2.0*nali), 'REAL','Bilinear') #finer, but slower method else: ionfilt = np.fromfile(ionfiltfile, dtype=np.float32).reshape(length2, width2) index2 = np.linspace(0, width2-1, num=width2, endpoint=True) index3 = np.linspace(0, width3-1, num=width3, endpoint=True) * nrlo/nrli + (nrlo-nrli)/(2.0*nrli) ionrect = np.zeros((length3, width3), dtype=np.float32) for i in range(length2): f = interp1d(index2, ionfilt[i,:], kind='cubic', fill_value="extrapolate") ionrect[i, :] = f(index3) index2 = np.linspace(0, length2-1, num=length2, endpoint=True) index3 = np.linspace(0, length3-1, num=length3, endpoint=True) * nalo/nali + (nalo-nali)/(2.0*nali) for j in range(width3): f = interp1d(index2, ionrect[0:length2, j], kind='cubic', fill_value="extrapolate") ionrect[:, j] = f(index3) ionrect.astype(np.float32).tofile(ionrectfile) del ionrect create_xml(ionrectfile, width3, length3, 'float') os.rename(ionrectfile, os.path.join('../../insar', ionrectfile)) os.rename(ionrectfile+'.vrt', os.path.join('../../insar', ionrectfile)+'.vrt') os.rename(ionrectfile+'.xml', os.path.join('../../insar', ionrectfile)+'.xml') os.chdir('../../insar') else: shutil.copyfile(ionfiltfile, os.path.join('../../insar', ionrectfile)) os.chdir('../../insar') create_xml(ionrectfile, width3, length3, 'float') #now we are in 'insar' ############################################################ # STEP 4. correct interferogram ############################################################ from isceobj.Alos2Proc.Alos2ProcPublic import renameFile from isceobj.Alos2Proc.Alos2ProcPublic import runCmd if self.applyIon: print('\ncorrect interferogram') if os.path.isfile(self._insar.multilookDifferentialInterferogramOriginal): print('original interferogram: {} is already here, do not rename: {}'.format(self._insar.multilookDifferentialInterferogramOriginal, self._insar.multilookDifferentialInterferogram)) else: print('renaming {} to {}'.format(self._insar.multilookDifferentialInterferogram, self._insar.multilookDifferentialInterferogramOriginal)) renameFile(self._insar.multilookDifferentialInterferogram, self._insar.multilookDifferentialInterferogramOriginal) cmd = "imageMath.py -e='a*exp(-1.0*J*b)' --a={} --b={} -s BIP -t cfloat -o {}".format( self._insar.multilookDifferentialInterferogramOriginal, self._insar.multilookIon, self._insar.multilookDifferentialInterferogram) runCmd(cmd) else: print('\nionospheric phase estimation finished, but correction of interfeorgram not requested') os.chdir('../') catalog.printToLog(logger, "runIonFilt") self._insar.procDoc.addAllFromCatalog(catalog)
def ionUwrap(self, referenceTrack, latLonDir=None): wbdFile = os.path.abspath(self._insar.wbd) from isceobj.Alos2Proc.runIonSubband import defineIonDir ionDir = defineIonDir() subbandPrefix = ['lower', 'upper'] ionCalDir = os.path.join(ionDir['ion'], ionDir['ionCal']) os.makedirs(ionCalDir, exist_ok=True) os.chdir(ionCalDir) ############################################################ # STEP 1. take looks ############################################################ from isceobj.Alos2Proc.Alos2ProcPublic import create_xml from contrib.alos2proc.alos2proc import look from isceobj.Alos2Proc.Alos2ProcPublic import waterBodyRadar ml2 = '_{}rlks_{}alks'.format( self._insar.numberRangeLooks1 * self._insar.numberRangeLooksIon, self._insar.numberAzimuthLooks1 * self._insar.numberAzimuthLooksIon) for k in range(2): fullbandDir = os.path.join('../../', ionDir['insar']) subbandDir = os.path.join('../', ionDir['subband'][k], ionDir['insar']) prefix = subbandPrefix[k] amp = isceobj.createImage() amp.load(os.path.join(subbandDir, self._insar.amplitude) + '.xml') width = amp.width length = amp.length width2 = int(width / self._insar.numberRangeLooksIon) length2 = int(length / self._insar.numberAzimuthLooksIon) #take looks look(os.path.join(subbandDir, self._insar.differentialInterferogram), prefix + ml2 + '.int', width, self._insar.numberRangeLooksIon, self._insar.numberAzimuthLooksIon, 4, 0, 1) create_xml(prefix + ml2 + '.int', width2, length2, 'int') look(os.path.join(subbandDir, self._insar.amplitude), prefix + ml2 + '.amp', width, self._insar.numberRangeLooksIon, self._insar.numberAzimuthLooksIon, 4, 1, 1) create_xml(prefix + ml2 + '.amp', width2, length2, 'amp') # #water body # if k == 0: # wbdOutFile = os.path.join(fullbandDir, self._insar.wbdOut) # if os.path.isfile(wbdOutFile): # look(wbdOutFile, 'wbd'+ml2+'.wbd', width, self._insar.numberRangeLooksIon, self._insar.numberAzimuthLooksIon, 0, 0, 1) # create_xml('wbd'+ml2+'.wbd', width2, length2, 'byte') #water body if k == 0: if latLonDir is None: latFile = os.path.join(fullbandDir, self._insar.latitude) lonFile = os.path.join(fullbandDir, self._insar.longitude) else: latFile = os.path.join('../../', latLonDir, self._insar.latitude) lonFile = os.path.join('../../', latLonDir, self._insar.longitude) look(latFile, 'lat' + ml2 + '.lat', width, self._insar.numberRangeLooksIon, self._insar.numberAzimuthLooksIon, 3, 0, 1) look(lonFile, 'lon' + ml2 + '.lon', width, self._insar.numberRangeLooksIon, self._insar.numberAzimuthLooksIon, 3, 0, 1) create_xml('lat' + ml2 + '.lat', width2, length2, 'double') create_xml('lon' + ml2 + '.lon', width2, length2, 'double') waterBodyRadar('lat' + ml2 + '.lat', 'lon' + ml2 + '.lon', wbdFile, 'wbd' + ml2 + '.wbd') ############################################################ # STEP 2. compute coherence ############################################################ from isceobj.Alos2Proc.Alos2ProcPublic import cal_coherence lowerbandInterferogramFile = subbandPrefix[0] + ml2 + '.int' upperbandInterferogramFile = subbandPrefix[1] + ml2 + '.int' lowerbandAmplitudeFile = subbandPrefix[0] + ml2 + '.amp' upperbandAmplitudeFile = subbandPrefix[1] + ml2 + '.amp' lowerbandCoherenceFile = subbandPrefix[0] + ml2 + '.cor' upperbandCoherenceFile = subbandPrefix[1] + ml2 + '.cor' coherenceFile = 'diff' + ml2 + '.cor' lowerint = np.fromfile(lowerbandInterferogramFile, dtype=np.complex64).reshape(length2, width2) upperint = np.fromfile(upperbandInterferogramFile, dtype=np.complex64).reshape(length2, width2) loweramp = np.fromfile(lowerbandAmplitudeFile, dtype=np.float32).reshape(length2, width2 * 2) upperamp = np.fromfile(upperbandAmplitudeFile, dtype=np.float32).reshape(length2, width2 * 2) #compute coherence only using interferogram #here I use differential interferogram of lower and upper band interferograms #so that coherence is not affected by fringes cord = cal_coherence(lowerint * np.conjugate(upperint), win=3, edge=4) cor = np.zeros((length2 * 2, width2), dtype=np.float32) cor[0:length2 * 2:2, :] = np.sqrt( (np.absolute(lowerint) + np.absolute(upperint)) / 2.0) cor[1:length2 * 2:2, :] = cord cor.astype(np.float32).tofile(coherenceFile) create_xml(coherenceFile, width2, length2, 'cor') #create lower and upper band coherence files #lower amp1 = loweramp[:, 0:width2 * 2:2] amp2 = loweramp[:, 1:width2 * 2:2] cor[1:length2 * 2:2, :] = np.absolute(lowerint) / (amp1 + (amp1 == 0)) / ( amp2 + (amp2 == 0)) * (amp1 != 0) * (amp2 != 0) cor.astype(np.float32).tofile(lowerbandCoherenceFile) create_xml(lowerbandCoherenceFile, width2, length2, 'cor') #upper amp1 = upperamp[:, 0:width2 * 2:2] amp2 = upperamp[:, 1:width2 * 2:2] cor[1:length2 * 2:2, :] = np.absolute(upperint) / (amp1 + (amp1 == 0)) / ( amp2 + (amp2 == 0)) * (amp1 != 0) * (amp2 != 0) cor.astype(np.float32).tofile(upperbandCoherenceFile) create_xml(upperbandCoherenceFile, width2, length2, 'cor') ############################################################ # STEP 3. filtering subband interferograms ############################################################ from contrib.alos2filter.alos2filter import psfilt1 from isceobj.Alos2Proc.Alos2ProcPublic import runCmd from isceobj.Alos2Proc.Alos2ProcPublic import create_xml from mroipac.icu.Icu import Icu for k in range(2): #1. filtering subband interferogram if self.filterSubbandInt: toBeFiltered = 'tmp.int' if self.removeMagnitudeBeforeFilteringSubbandInt: cmd = "imageMath.py -e='a/(abs(a)+(a==0))' --a={} -o {} -t cfloat -s BSQ".format( subbandPrefix[k] + ml2 + '.int', toBeFiltered) else: #scale the inteferogram, otherwise its magnitude is too large for filtering cmd = "imageMath.py -e='a/100000.0' --a={} -o {} -t cfloat -s BSQ".format( subbandPrefix[k] + ml2 + '.int', toBeFiltered) runCmd(cmd) intImage = isceobj.createIntImage() intImage.load(toBeFiltered + '.xml') width = intImage.width length = intImage.length windowSize = self.filterWinsizeSubbandInt stepSize = self.filterStepsizeSubbandInt psfilt1(toBeFiltered, 'filt_' + subbandPrefix[k] + ml2 + '.int', width, self.filterStrengthSubbandInt, windowSize, stepSize) create_xml('filt_' + subbandPrefix[k] + ml2 + '.int', width, length, 'int') os.remove(toBeFiltered) os.remove(toBeFiltered + '.vrt') os.remove(toBeFiltered + '.xml') toBeUsedInPhsig = 'filt_' + subbandPrefix[k] + ml2 + '.int' else: toBeUsedInPhsig = subbandPrefix[k] + ml2 + '.int' #2. create phase sigma for phase unwrapping #recreate filtered image filtImage = isceobj.createIntImage() filtImage.load(toBeUsedInPhsig + '.xml') filtImage.setAccessMode('read') filtImage.createImage() #amplitude image ampImage = isceobj.createAmpImage() ampImage.load(subbandPrefix[k] + ml2 + '.amp' + '.xml') ampImage.setAccessMode('read') ampImage.createImage() #phase sigma correlation image phsigImage = isceobj.createImage() phsigImage.setFilename(subbandPrefix[k] + ml2 + '.phsig') phsigImage.setWidth(filtImage.width) phsigImage.dataType = 'FLOAT' phsigImage.bands = 1 phsigImage.setImageType('cor') phsigImage.setAccessMode('write') phsigImage.createImage() icu = Icu(name='insarapp_filter_icu') icu.configure() icu.unwrappingFlag = False icu.icu(intImage=filtImage, ampImage=ampImage, phsigImage=phsigImage) phsigImage.renderHdr() filtImage.finalizeImage() ampImage.finalizeImage() phsigImage.finalizeImage() ############################################################ # STEP 4. phase unwrapping ############################################################ from isceobj.Alos2Proc.Alos2ProcPublic import snaphuUnwrap from isceobj.Alos2Proc.Alos2ProcPublic import snaphuUnwrapOriginal for k in range(2): tmid = referenceTrack.sensingStart + datetime.timedelta( seconds=(self._insar.numberAzimuthLooks1 - 1.0) / 2.0 * referenceTrack.azimuthLineInterval + referenceTrack.numberOfLines / 2.0 * self._insar.numberAzimuthLooks1 * referenceTrack.azimuthLineInterval) if self.filterSubbandInt: toBeUnwrapped = 'filt_' + subbandPrefix[k] + ml2 + '.int' coherenceFile = subbandPrefix[k] + ml2 + '.phsig' else: toBeUnwrapped = subbandPrefix[k] + ml2 + '.int' coherenceFile = 'diff' + ml2 + '.cor' #if shutil.which('snaphu') != None: #do not use original snaphu now if False: print('\noriginal snaphu program found') print('unwrap {} using original snaphu, rather than that in ISCE'. format(toBeUnwrapped)) snaphuUnwrapOriginal(toBeUnwrapped, subbandPrefix[k] + ml2 + '.phsig', subbandPrefix[k] + ml2 + '.amp', subbandPrefix[k] + ml2 + '.unw', costMode='s', initMethod='mcf', snaphuConfFile='{}_snaphu.conf'.format( subbandPrefix[k])) else: snaphuUnwrap(referenceTrack, tmid, toBeUnwrapped, coherenceFile, subbandPrefix[k] + ml2 + '.unw', self._insar.numberRangeLooks1 * self._insar.numberRangeLooksIon, self._insar.numberAzimuthLooks1 * self._insar.numberAzimuthLooksIon, costMode='SMOOTH', initMethod='MCF', defomax=2, initOnly=True)
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 runDenseOffsetGPU(self): ''' Estimate dense offset field between a pair of SLCs. ''' from contrib.PyCuAmpcor import PyCuAmpcor from isceobj.Alos2Proc.Alos2ProcPublic import runCmd from isceobj.Alos2Proc.Alos2ProcPublic import create_xml ############################################################################################ # #different from minyan's script: cuDenseOffsets.py: deramp method (0: mag, 1: complex) # objOffset.derampMethod = 2 # # #varying-gross-offset parameters not set # #not set in minyan's script: cuDenseOffsets.py # objOffset.corrSurfaceZoomInWindow # objOffset.grossOffsetAcrossStatic = 0 # objOffset.grossOffsetDownStatic = 0 ############################################################################################ ####For this module currently, we need to create an actual file on disk for infile in [self._insar.masterSlc, self._insar.slaveSlcCoregistered]: if os.path.isfile(infile): continue cmd = 'gdal_translate -of ENVI {0}.vrt {0}'.format(infile) runCmd(cmd) m = isceobj.createSlcImage() m.load(self._insar.masterSlc + '.xml') m.setAccessMode('READ') s = isceobj.createSlcImage() s.load(self._insar.slaveSlcCoregistered + '.xml') s.setAccessMode('READ') print('\n************* dense offset estimation parameters *************') print('master SLC: %s' % (self._insar.masterSlc)) print('slave SLC: %s' % (self._insar.slaveSlcCoregistered)) print('dense offset estimation window width: %d' % (self.offsetWindowWidth)) print('dense offset estimation window hight: %d' % (self.offsetWindowHeight)) print('dense offset search window width: %d' % (self.offsetSearchWindowWidth)) print('dense offset search window hight: %d' % (self.offsetSearchWindowHeight)) print('dense offset skip width: %d' % (self.offsetSkipWidth)) print('dense offset skip hight: %d' % (self.offsetSkipHeight)) print('dense offset covariance surface oversample factor: %d' % (self.offsetCovarianceOversamplingFactor)) print('dense offset covariance surface oversample window size: %d\n' % (self.offsetCovarianceOversamplingWindowsize)) objOffset = PyCuAmpcor.PyCuAmpcor() objOffset.algorithm = 0 objOffset.deviceID = -1 objOffset.nStreams = 2 #original ampcor program in roi_pac uses phase gradient to deramp objOffset.derampMethod = 2 objOffset.masterImageName = self._insar.masterSlc objOffset.masterImageHeight = m.length objOffset.masterImageWidth = m.width objOffset.slaveImageName = self._insar.slaveSlcCoregistered objOffset.slaveImageHeight = s.length objOffset.slaveImageWidth = s.width objOffset.offsetImageName = self._insar.denseOffset objOffset.snrImageName = self._insar.denseOffsetSnr objOffset.windowSizeWidth = self.offsetWindowWidth objOffset.windowSizeHeight = self.offsetWindowHeight #objOffset.halfSearchRangeAcross = int(self.offsetSearchWindowWidth / 2 + 0.5) #objOffset.halfSearchRangeDown = int(self.offsetSearchWindowHeight / 2 + 0.5) objOffset.halfSearchRangeAcross = self.offsetSearchWindowWidth objOffset.halfSearchRangeDown = self.offsetSearchWindowHeight objOffset.skipSampleDown = self.offsetSkipHeight objOffset.skipSampleAcross = self.offsetSkipWidth #Oversampling method for correlation surface(0=fft,1=sinc) objOffset.corrSufaceOverSamplingMethod = 0 objOffset.corrSurfaceOverSamplingFactor = self.offsetCovarianceOversamplingFactor objOffset.corrSurfaceZoomInWindow = self.offsetCovarianceOversamplingWindowsize objOffset.grossOffsetAcrossStatic = 0 objOffset.grossOffsetDownStatic = 0 objOffset.masterStartPixelDownStatic = self.offsetWindowHeight//2 objOffset.masterStartPixelAcrossStatic = self.offsetWindowWidth//2 objOffset.numberWindowDown = (m.length - 2*self.offsetSearchWindowHeight - self.offsetWindowHeight) // self.offsetSkipHeight objOffset.numberWindowAcross = (m.width - 2*self.offsetSearchWindowWidth - self.offsetWindowWidth) // self.offsetSkipWidth # generic control objOffset.numberWindowDownInChunk = 8 objOffset.numberWindowAcrossInChunk = 8 objOffset.mmapSize = 16 objOffset.setupParams() objOffset.setConstantGrossOffset(0, 0) objOffset.checkPixelInImageRange() objOffset.runAmpcor() ### Store params for later self._insar.offsetImageTopoffset = objOffset.halfSearchRangeDown self._insar.offsetImageLeftoffset = objOffset.halfSearchRangeAcross width = objOffset.numberWindowAcross length = objOffset.numberWindowDown offsetBIP = np.fromfile(objOffset.offsetImageName.decode('utf-8'), dtype=np.float32).reshape(length, width*2) offsetBIL = np.zeros((length*2, width), dtype=np.float32) offsetBIL[0:length*2:2, :] = offsetBIP[:, 1:width*2:2] offsetBIL[1:length*2:2, :] = offsetBIP[:, 0:width*2:2] os.remove(objOffset.offsetImageName.decode('utf-8')) offsetBIL.astype(np.float32).tofile(objOffset.offsetImageName.decode('utf-8')) outImg = isceobj.createImage() outImg.setDataType('FLOAT') outImg.setFilename(objOffset.offsetImageName.decode('utf-8')) outImg.setBands(2) outImg.scheme = 'BIL' outImg.setWidth(objOffset.numberWindowAcross) outImg.setLength(objOffset.numberWindowDown) outImg.addDescription('two-band pixel offset file. 1st band: range offset, 2nd band: azimuth offset') outImg.setAccessMode('read') outImg.renderHdr() snrImg = isceobj.createImage() snrImg.setFilename( objOffset.snrImageName.decode('utf8')) snrImg.setDataType('FLOAT') snrImg.setBands(1) snrImg.setWidth(objOffset.numberWindowAcross) snrImg.setLength(objOffset.numberWindowDown) snrImg.setAccessMode('read') snrImg.renderHdr() return (objOffset.numberWindowAcross, objOffset.numberWindowDown)