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)
