def runRdr2Geo(self): '''compute lat/lon/hgt ''' catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name) self.updateParamemetersFromUser() masterTrack = self._insar.loadTrack(master=True) demFile = os.path.abspath(self._insar.dem) wbdFile = os.path.abspath(self._insar.wbd) insarDir = 'insar' os.makedirs(insarDir, exist_ok=True) os.chdir(insarDir) if self.useGPU and self._insar.hasGPU(): topoGPU(masterTrack, self._insar.numberRangeLooks1, self._insar.numberAzimuthLooks1, demFile, self._insar.latitude, self._insar.longitude, self._insar.height, self._insar.los) else: snwe = topoCPU(masterTrack, self._insar.numberRangeLooks1, self._insar.numberAzimuthLooks1, demFile, self._insar.latitude, self._insar.longitude, self._insar.height, self._insar.los) waterBodyRadar(self._insar.latitude, self._insar.longitude, wbdFile, self._insar.wbdOut) os.chdir('../') catalog.printToLog(logger, "runRdr2Geo") self._insar.procDoc.addAllFromCatalog(catalog)
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' if not os.path.exists(insarDir): os.makedirs(insarDir) 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)
def runLookSd(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) sdDir = 'sd' if not os.path.exists(sdDir): os.makedirs(sdDir) os.chdir(sdDir) sd = isceobj.createImage() sd.load(self._insar.interferogramSd[0] + '.xml') width = sd.width length = sd.length width2 = int(width / self._insar.numberRangeLooksSd) length2 = int(length / self._insar.numberAzimuthLooksSd) if not ((self._insar.numberRangeLooksSd == 1) and (self._insar.numberAzimuthLooksSd == 1)): #take looks for sd, sdMultilook in zip(self._insar.interferogramSd, self._insar.multilookInterferogramSd): look(sd, sdMultilook, width, self._insar.numberRangeLooksSd, self._insar.numberAzimuthLooksSd, 4, 0, 1) create_xml(sdMultilook, width2, length2, 'int') look(os.path.join('../insar', self._insar.latitude), self._insar.multilookLatitudeSd, width, self._insar.numberRangeLooksSd, self._insar.numberAzimuthLooksSd, 3, 0, 1) look(os.path.join('../insar', self._insar.longitude), self._insar.multilookLongitudeSd, width, self._insar.numberRangeLooksSd, self._insar.numberAzimuthLooksSd, 3, 0, 1) create_xml(self._insar.multilookLatitudeSd, width2, length2, 'double') create_xml(self._insar.multilookLongitudeSd, width2, length2, 'double') #water body waterBodyRadar(self._insar.multilookLatitudeSd, self._insar.multilookLongitudeSd, wbdFile, self._insar.multilookWbdOutSd) os.chdir('../') catalog.printToLog(logger, "runLookSd") 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 referenceTrack = self._insar.loadTrack(reference=True) secondaryTrack = self._insar.loadTrack(reference=False) 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: look(os.path.join(fullbandDir, self._insar.latitude), 'lat'+ml2+'.lat', width, self._insar.numberRangeLooksIon, self._insar.numberAzimuthLooksIon, 3, 0, 1) look(os.path.join(fullbandDir, self._insar.longitude), '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 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 = 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' 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) os.chdir('../../') catalog.printToLog(logger, "runIonUwrap") self._insar.procDoc.addAllFromCatalog(catalog)
wbdRadarFile = os.path.join(idir, dateSecondaryFirst, frameDir, swathDir, 'wbd.rdr') topo(referenceSwath, referenceTrack, demFile, latFile, lonFile, hgtFile, losFile=losFile, incFile=None, mskFile=None, numberRangeLooks=numberRangeLooks, numberAzimuthLooks=numberAzimuthLooks, multilookTimeOffset=False) waterBodyRadar(latFile, lonFile, wbdFile, wbdRadarFile) wbdImg = isceobj.createImage() wbdImg.load(wbdRadarFile + '.xml') width = wbdImg.width length = wbdImg.length wbd = np.fromfile(wbdRadarFile, dtype=np.byte).reshape(length, width) landRatio = np.sum(wbd == 0) / (length * width) if (landRatio <= 0.00125): print( '\n\nWARNING: land too small for estimating slc offsets at frame {}, swath {}' .format(frameNumber, swathNumber)) print(
numberAzimuthLooks2, 3, 0, 1) #creat xml create_xml(multilookLatitude, width2, length2, 'double') create_xml(multilookLongitude, width2, length2, 'double') create_xml(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) #replace the above system call with function call from mroipac.looks.Looks import Looks from isceobj.Image import createImage inImage = createImage() inImage.load(los + '.xml') lkObj = Looks() lkObj.setDownLooks(numberAzimuthLooks2) lkObj.setAcrossLooks(numberRangeLooks2) lkObj.setInputImage(inImage) lkObj.setOutputFilename(multilookLos) lkObj.looks() #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(multilookLatitude, multilookLongitude, wbdFile, multilookWbdOut) os.chdir('../')
demFile = inps.dem wbdFile = inps.wbd numberRangeLooks1 = inps.nrlks1 numberAzimuthLooks1 = inps.nalks1 useGPU = inps.gpu ####################################################### demFile = os.path.abspath(demFile) wbdFile = os.path.abspath(wbdFile) insarDir = 'insar' os.makedirs(insarDir, exist_ok=True) os.chdir(insarDir) ml1 = '_{}rlks_{}alks'.format(numberRangeLooks1, numberAzimuthLooks1) latitude = date + ml1 + '.lat' longitude = date + ml1 + '.lon' height = date + ml1 + '.hgt' los = date + ml1 + '.los' wbdOut = date + ml1 + '.wbd' track = loadTrack('../', date) if useGPU and hasGPU(): topoGPU(track, numberRangeLooks1, numberAzimuthLooks1, demFile, latitude, longitude, height, los) else: snwe = topoCPU(track, numberRangeLooks1, numberAzimuthLooks1, demFile, latitude, longitude, height, los) waterBodyRadar(latitude, longitude, wbdFile, wbdOut)
def runSlcOffset(self): '''estimate SLC offsets ''' if hasattr(self, 'doInSAR'): if not self.doInSAR: print('\nInSAR processing not requested, skip this and the remaining InSAR steps...') return catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name) self.updateParamemetersFromUser() referenceTrack = self._insar.loadTrack(reference=True) secondaryTrack = self._insar.loadTrack(reference=False) demFile = os.path.abspath(self._insar.dem) wbdFile = os.path.abspath(self._insar.wbd) for i, frameNumber in enumerate(self._insar.referenceFrames): frameDir = 'f{}_{}'.format(i+1, frameNumber) os.chdir(frameDir) for j, swathNumber in enumerate(range(self._insar.startingSwath, self._insar.endingSwath + 1)): swathDir = 's{}'.format(swathNumber) os.chdir(swathDir) print('estimating offset frame {}, swath {}'.format(frameNumber, swathNumber)) referenceSwath = referenceTrack.frames[i].swaths[j] secondarySwath = secondaryTrack.frames[i].swaths[j] ########################################## #1. set number of matching points ########################################## #set initinial numbers if (self._insar.modeCombination == 21) or (self._insar.modeCombination == 22): numberOfOffsetsRange = 10 numberOfOffsetsAzimuth = 40 else: numberOfOffsetsRange = 20 numberOfOffsetsAzimuth = 20 #change the initial numbers using water body if self.useWbdForNumberOffsets and (self._insar.wbd != None): numberRangeLooks=100 numberAzimuthLooks=100 #compute land ratio using topo module topo(referenceSwath, referenceTrack, demFile, 'lat.rdr', 'lon.rdr', 'hgt.rdr', losFile='los.rdr', incFile=None, mskFile=None, numberRangeLooks=numberRangeLooks, numberAzimuthLooks=numberAzimuthLooks, multilookTimeOffset=False) waterBodyRadar('lat.rdr', 'lon.rdr', wbdFile, 'wbd.rdr') wbdImg = isceobj.createImage() wbdImg.load('wbd.rdr.xml') width = wbdImg.width length = wbdImg.length wbd = np.fromfile('wbd.rdr', dtype=np.byte).reshape(length, width) landRatio = np.sum(wbd==0) / (length*width) if (landRatio <= 0.00125): print('\n\nWARNING: land too small for estimating slc offsets at frame {}, swath {}'.format(frameNumber, swathNumber)) print('proceed to use geometric offsets for forming interferogram') print('but please consider not using this swath\n\n') catalog.addItem('warning message', 'land too small for estimating slc offsets at frame {}, swath {}, use geometric offsets'.format(frameNumber, swathNumber), 'runSlcOffset') #compute geomtricla offsets geo2rdr(secondarySwath, secondaryTrack, 'lat.rdr', 'lon.rdr', 'hgt.rdr', 'rg.rdr', 'az.rdr', numberRangeLooks=numberRangeLooks, numberAzimuthLooks=numberAzimuthLooks, multilookTimeOffset=False) reformatGeometricalOffset('rg.rdr', 'az.rdr', 'cull.off', rangeStep=numberRangeLooks, azimuthStep=numberAzimuthLooks, maximumNumberOfOffsets=2000) os.remove('lat.rdr') os.remove('lat.rdr.vrt') os.remove('lat.rdr.xml') os.remove('lon.rdr') os.remove('lon.rdr.vrt') os.remove('lon.rdr.xml') os.remove('hgt.rdr') os.remove('hgt.rdr.vrt') os.remove('hgt.rdr.xml') os.remove('los.rdr') os.remove('los.rdr.vrt') os.remove('los.rdr.xml') os.remove('wbd.rdr') os.remove('wbd.rdr.vrt') os.remove('wbd.rdr.xml') os.remove('rg.rdr') os.remove('rg.rdr.vrt') os.remove('rg.rdr.xml') os.remove('az.rdr') os.remove('az.rdr.vrt') os.remove('az.rdr.xml') os.chdir('../') continue os.remove('lat.rdr') os.remove('lat.rdr.vrt') os.remove('lat.rdr.xml') os.remove('lon.rdr') os.remove('lon.rdr.vrt') os.remove('lon.rdr.xml') os.remove('hgt.rdr') os.remove('hgt.rdr.vrt') os.remove('hgt.rdr.xml') os.remove('los.rdr') os.remove('los.rdr.vrt') os.remove('los.rdr.xml') os.remove('wbd.rdr') os.remove('wbd.rdr.vrt') os.remove('wbd.rdr.xml') #put the results on a grid with a specified interval interval = 0.2 axisRatio = int(np.sqrt(landRatio)/interval)*interval + interval if axisRatio > 1: axisRatio = 1 numberOfOffsetsRange = int(numberOfOffsetsRange/axisRatio) numberOfOffsetsAzimuth = int(numberOfOffsetsAzimuth/axisRatio) else: catalog.addItem('warning message', 'no water mask used to determine number of matching points. frame {} swath {}'.format(frameNumber, swathNumber), 'runSlcOffset') #user's settings if self.numberRangeOffsets != None: numberOfOffsetsRange = self.numberRangeOffsets[i][j] if self.numberAzimuthOffsets != None: numberOfOffsetsAzimuth = self.numberAzimuthOffsets[i][j] catalog.addItem('number of offsets range frame {} swath {}'.format(frameNumber, swathNumber), numberOfOffsetsRange, 'runSlcOffset') catalog.addItem('number of offsets azimuth frame {} swath {}'.format(frameNumber, swathNumber), numberOfOffsetsAzimuth, 'runSlcOffset') ########################################## #2. match using ampcor ########################################## ampcor = Ampcor(name='insarapp_slcs_ampcor') ampcor.configure() mSLC = isceobj.createSlcImage() mSLC.load(self._insar.referenceSlc+'.xml') mSLC.setAccessMode('read') mSLC.createImage() sSLC = isceobj.createSlcImage() sSLC.load(self._insar.secondarySlc+'.xml') sSLC.setAccessMode('read') sSLC.createImage() ampcor.setImageDataType1('complex') ampcor.setImageDataType2('complex') ampcor.setReferenceSlcImage(mSLC) ampcor.setSecondarySlcImage(sSLC) #MATCH REGION #compute an offset at image center to use rgoff, azoff = computeOffsetFromOrbit(referenceSwath, referenceTrack, secondarySwath, secondaryTrack, referenceSwath.numberOfSamples * 0.5, referenceSwath.numberOfLines * 0.5) #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(mSLC.width) ampcor.setNumberLocationAcross(numberOfOffsetsRange) ampcor.setFirstSampleDown(firstLine) ampcor.setLastSampleDown(mSLC.length) ampcor.setNumberLocationDown(numberOfOffsetsAzimuth) #MATCH PARAMETERS #full-aperture mode if (self._insar.modeCombination == 21) or \ (self._insar.modeCombination == 22) or \ (self._insar.modeCombination == 31) or \ (self._insar.modeCombination == 32): ampcor.setWindowSizeWidth(64) ampcor.setWindowSizeHeight(512) #note this is the half width/length of search area, number of resulting correlation samples: 32*2+1 ampcor.setSearchWindowSizeWidth(32) ampcor.setSearchWindowSizeHeight(32) #triggering full-aperture mode matching ampcor.setWinsizeFilt(8) ampcor.setOversamplingFactorFilt(64) #regular mode else: ampcor.setWindowSizeWidth(64) ampcor.setWindowSizeHeight(64) ampcor.setSearchWindowSizeWidth(32) ampcor.setSearchWindowSizeHeight(32) #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' writeOffset(offsets, ampcorOffsetFile) #finalize image, and re-create it #otherwise the file pointer is still at the end of the image mSLC.finalizeImage() sSLC.finalizeImage() ########################################## #3. cull offsets ########################################## refinedOffsets = cullOffsets(offsets) if refinedOffsets == None: print('******************************************************************') print('WARNING: There are not enough offsets left, so we are forced to') print(' use offset without culling. frame {}, swath {}'.format(frameNumber, swathNumber)) print('******************************************************************') catalog.addItem('warning message', 'not enough offsets left, use offset without culling. frame {} swath {}'.format(frameNumber, swathNumber), 'runSlcOffset') refinedOffsets = offsets cullOffsetFile = 'cull.off' writeOffset(refinedOffsets, cullOffsetFile) os.chdir('../') os.chdir('../') catalog.printToLog(logger, "runSlcOffset") self._insar.procDoc.addAllFromCatalog(catalog)
def runCoregGeom(self): '''compute geometric offset ''' catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name) self.updateParamemetersFromUser() masterTrack = self._insar.loadTrack(master=True) slaveTrack = self._insar.loadTrack(master=False) demFile = os.path.abspath(self._insar.dem) wbdFile = os.path.abspath(self._insar.wbd) ############################################################################### for i, frameNumber in enumerate(self._insar.masterFrames): frameDir = 'f{}_{}'.format(i + 1, frameNumber) os.chdir(frameDir) for j, swathNumber in enumerate( range(self._insar.startingSwath, self._insar.endingSwath + 1)): swathDir = 's{}'.format(swathNumber) os.chdir(swathDir) print('processing frame {}, swath {}'.format( frameNumber, swathNumber)) masterSwath = masterTrack.frames[i].swaths[j] slaveSwath = slaveTrack.frames[i].swaths[j] ################################################## # compute geometric offsets ################################################## #set up track parameters just for computing offsets #ALL track parameters are listed here #master #masterTrack.passDirection = #masterTrack.pointingDirection = #masterTrack.operationMode = #masterTrack.radarWavelength = masterTrack.numberOfSamples = masterSwath.numberOfSamples masterTrack.numberOfLines = masterSwath.numberOfLines masterTrack.startingRange = masterSwath.startingRange #masterTrack.rangeSamplingRate = masterTrack.rangePixelSize = masterSwath.rangePixelSize masterTrack.sensingStart = masterSwath.sensingStart #masterTrack.prf = #masterTrack.azimuthPixelSize = masterTrack.azimuthLineInterval = masterSwath.azimuthLineInterval #masterTrack.dopplerVsPixel = #masterTrack.frames = #masterTrack.orbit = #slave slaveTrack.numberOfSamples = slaveSwath.numberOfSamples slaveTrack.numberOfLines = slaveSwath.numberOfLines slaveTrack.startingRange = slaveSwath.startingRange slaveTrack.rangePixelSize = slaveSwath.rangePixelSize slaveTrack.sensingStart = slaveSwath.sensingStart slaveTrack.azimuthLineInterval = slaveSwath.azimuthLineInterval if self.useGPU and self._insar.hasGPU(): topoGPU(masterTrack, 1, 1, demFile, self._insar.latitude, self._insar.longitude, self._insar.height, self._insar.los) geo2RdrGPU(slaveTrack, 1, 1, self._insar.latitude, self._insar.longitude, self._insar.height, self._insar.rangeOffset, self._insar.azimuthOffset) else: topoCPU(masterTrack, 1, 1, demFile, self._insar.latitude, self._insar.longitude, self._insar.height, self._insar.los) geo2RdrCPU(slaveTrack, 1, 1, self._insar.latitude, self._insar.longitude, self._insar.height, self._insar.rangeOffset, self._insar.azimuthOffset) waterBodyRadar(self._insar.latitude, self._insar.longitude, wbdFile, self._insar.wbdOut) #clear up, leaving only range/azimuth offsets os.remove(self._insar.latitude) os.remove(self._insar.latitude + '.vrt') os.remove(self._insar.latitude + '.xml') os.remove(self._insar.longitude) os.remove(self._insar.longitude + '.vrt') os.remove(self._insar.longitude + '.xml') os.remove(self._insar.height) os.remove(self._insar.height + '.vrt') os.remove(self._insar.height + '.xml') os.remove(self._insar.los) os.remove(self._insar.los + '.vrt') os.remove(self._insar.los + '.xml') ################################################## # resample bursts ################################################## slaveBurstResampledDir = self._insar.slaveBurstPrefix + '_1_coreg_geom' #interferogramDir = self._insar.masterBurstPrefix + '-' + self._insar.slaveBurstPrefix + '_coreg_geom' interferogramDir = 'burst_interf_1_coreg_geom' 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, self._insar.rangeOffset, self._insar.azimuthOffset, rangeOffsetResidual=0, azimuthOffsetResidual=0) ################################################## # mosaic burst amplitudes and interferograms ################################################## os.chdir(slaveBurstResampledDir) mosaicBurstAmplitude(masterSwath, self._insar.slaveBurstPrefix, self._insar.slaveMagnitude, numberOfLooksThreshold=4) os.chdir('../') #the interferogram is not good enough, do not mosaic mosaic = False if mosaic: os.chdir(interferogramDir) mosaicBurstInterferogram(masterSwath, interferogramPrefix, self._insar.interferogram, numberOfLooksThreshold=4) os.chdir('../') os.chdir('../') os.chdir('../') ############################################################################### catalog.printToLog(logger, "runCoregGeom") self._insar.procDoc.addAllFromCatalog(catalog)
def runSlcMatch(self): '''match a pair of SLCs ''' if not self.doDenseOffset: return if not ((self._insar.modeCombination == 0) or (self._insar.modeCombination == 1)): return catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name) self.updateParamemetersFromUser() demFile = os.path.abspath(self._insar.dem) wbdFile = os.path.abspath(self._insar.wbd) denseOffsetDir = 'dense_offset' os.makedirs(denseOffsetDir, exist_ok=True) os.chdir(denseOffsetDir) masterTrack = self._insar.loadProduct(self._insar.masterTrackParameter) slaveTrack = self._insar.loadProduct(self._insar.slaveTrackParameter) ######################################################################################### ################################################## # compute geometric offsets ################################################## if self.useGPU and self._insar.hasGPU(): topoGPU(masterTrack, 1, 1, demFile, 'lat.rdr', 'lon.rdr', 'hgt.rdr', 'los.rdr') geo2RdrGPU(slaveTrack, 1, 1, 'lat.rdr', 'lon.rdr', 'hgt.rdr', 'rg.off', 'az.off') else: topoCPU(masterTrack, 1, 1, demFile, 'lat.rdr', 'lon.rdr', 'hgt.rdr', 'los.rdr') geo2RdrCPU(slaveTrack, 1, 1, 'lat.rdr', 'lon.rdr', 'hgt.rdr', 'rg.off', 'az.off') ################################################## # resample SLC ################################################## #SlaveSlcResampled = os.path.splitext(self._insar.slaveSlc)[0]+'_resamp'+os.path.splitext(self._insar.slaveSlc)[1] SlaveSlcResampled = self._insar.slaveSlcCoregistered rangeOffsets2Frac = 0.0 azimuthOffsets2Frac = 0.0 resamp(self._insar.slaveSlc, SlaveSlcResampled, 'rg.off', 'az.off', masterTrack.numberOfSamples, masterTrack.numberOfLines, slaveTrack.prf, slaveTrack.dopplerVsPixel, [rangeOffsets2Frac, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [azimuthOffsets2Frac, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]) create_xml(SlaveSlcResampled, masterTrack.numberOfSamples, masterTrack.numberOfLines, 'slc') if self.estimateResidualOffset: numberOfOffsets = 800 rangeStep = 50 length = masterTrack.numberOfLines width = masterTrack.numberOfSamples waterBodyRadar('lat.rdr', 'lon.rdr', wbdFile, 'wbd.rdr') wbd=np.memmap('wbd.rdr', dtype=np.int8, mode='r', shape=(length, width)) azimuthStep = int(length/width*rangeStep+0.5) landRatio = np.sum(wbd[0:length:azimuthStep,0:width:rangeStep]!=-1)/(int(length/azimuthStep)*int(width/rangeStep)) del wbd if (landRatio <= 0.00125): print('\n\nWARNING: land area too small for estimating residual slc offsets') print('do not estimate residual offsets\n\n') catalog.addItem('warning message', 'land area too small for estimating residual slc offsets', 'runSlcMatch') else: numberOfOffsets /= landRatio #we use equal number of offsets in range and azimuth here numberOfOffsetsRange = int(np.sqrt(numberOfOffsets)+0.5) numberOfOffsetsAzimuth = int(np.sqrt(numberOfOffsets)+0.5) 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 ########################################## #2. match using ampcor ########################################## ampcor = Ampcor(name='insarapp_slcs_ampcor') ampcor.configure() mSLC = isceobj.createSlcImage() mSLC.load(self._insar.masterSlc+'.xml') mSLC.setAccessMode('read') mSLC.createImage() sSLC = isceobj.createSlcImage() sSLC.load(SlaveSlcResampled+'.xml') sSLC.setAccessMode('read') sSLC.createImage() ampcor.setImageDataType1('complex') ampcor.setImageDataType2('complex') ampcor.setMasterSlcImage(mSLC) ampcor.setSlaveSlcImage(sSLC) #MATCH REGION #compute an offset at image center to use rgoff = 0.0 azoff = 0.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(mSLC.width) ampcor.setNumberLocationAcross(numberOfOffsetsRange) ampcor.setFirstSampleDown(firstLine) ampcor.setLastSampleDown(mSLC.length) ampcor.setNumberLocationDown(numberOfOffsetsAzimuth) #MATCH PARAMETERS #full-aperture mode if (self._insar.modeCombination == 21) or \ (self._insar.modeCombination == 22) or \ (self._insar.modeCombination == 31) or \ (self._insar.modeCombination == 32): ampcor.setWindowSizeWidth(64) ampcor.setWindowSizeHeight(512) #note this is the half width/length of search area, number of resulting correlation samples: 32*2+1 ampcor.setSearchWindowSizeWidth(32) ampcor.setSearchWindowSizeHeight(32) #triggering full-aperture mode matching ampcor.setWinsizeFilt(8) ampcor.setOversamplingFactorFilt(64) #regular mode else: ampcor.setWindowSizeWidth(64) ampcor.setWindowSizeHeight(64) 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() mSLC.finalizeImage() sSLC.finalizeImage() #3. cull offsets refinedOffsets = cullOffsetsRoipac(offsets, numThreshold=50) if refinedOffsets == None: print('\n\nWARNING: too few offsets left for slc residual offset estimation') print('do not estimate residual offsets\n\n') catalog.addItem('warning message', 'too few offsets left for slc residual offset estimation', 'runSlcMatch') else: rangeOffset, azimuthOffset = meanOffset(refinedOffsets) os.remove(SlaveSlcResampled) os.remove(SlaveSlcResampled+'.vrt') os.remove(SlaveSlcResampled+'.xml') rangeOffsets2Frac = rangeOffset azimuthOffsets2Frac = azimuthOffset resamp(self._insar.slaveSlc, SlaveSlcResampled, 'rg.off', 'az.off', masterTrack.numberOfSamples, masterTrack.numberOfLines, slaveTrack.prf, slaveTrack.dopplerVsPixel, [rangeOffsets2Frac, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [azimuthOffsets2Frac, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]) create_xml(SlaveSlcResampled, masterTrack.numberOfSamples, masterTrack.numberOfLines, 'slc') catalog.addItem('number of offsets range', numberOfOffsetsRange, 'runSlcMatch') catalog.addItem('number of offsets azimuth', numberOfOffsetsAzimuth, 'runSlcMatch') catalog.addItem('range residual offset after geometric coregistration', rangeOffset, 'runSlcMatch') catalog.addItem('azimuth residual offset after geometric coregistration', azimuthOffset, 'runSlcMatch') if self.deleteGeometryFiles: os.remove('lat.rdr') os.remove('lat.rdr.vrt') os.remove('lat.rdr.xml') os.remove('lon.rdr') os.remove('lon.rdr.vrt') os.remove('lon.rdr.xml') os.remove('hgt.rdr') os.remove('hgt.rdr.vrt') os.remove('hgt.rdr.xml') os.remove('los.rdr') os.remove('los.rdr.vrt') os.remove('los.rdr.xml') # if os.path.isfile('wbd.rdr'): # os.remove('wbd.rdr') # os.remove('wbd.rdr.vrt') # os.remove('wbd.rdr.xml') ######################################################################################### os.chdir('../') catalog.printToLog(logger, "runSlcMatch") self._insar.procDoc.addAllFromCatalog(catalog)
def runLook(self): '''take looks ''' catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name) self.updateParamemetersFromUser() #referenceTrack = self._insar.loadTrack(reference=True) #secondaryTrack = self._insar.loadTrack(reference=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) #replace the above system call with function call from mroipac.looks.Looks import Looks from isceobj.Image import createImage inImage = createImage() inImage.load(self._insar.los + '.xml') lkObj = Looks() lkObj.setDownLooks(self._insar.numberAzimuthLooks2) lkObj.setAcrossLooks(self._insar.numberRangeLooks2) lkObj.setInputImage(inImage) lkObj.setOutputFilename(self._insar.multilookLos) lkObj.looks() #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)