def runFilter(infile, outfile, filterStrength):
from mroipac.filter.Filter import Filter
logger.info("Applying power-spectral filter")
# Initialize the flattened interferogram
topoflatIntFilename = infile
intImage = isceobj.createIntImage()
intImage.load(infile + '.xml')
intImage.setAccessMode('read')
intImage.createImage()
# Create the filtered interferogram
filtImage = isceobj.createIntImage()
filtImage.setFilename(outfile)
filtImage.setWidth(intImage.getWidth())
filtImage.setAccessMode('write')
filtImage.createImage()
objFilter = Filter()
objFilter.wireInputPort(name='interferogram', object=intImage)
objFilter.wireOutputPort(name='filtered interferogram', object=filtImage)
objFilter.goldsteinWerner(alpha=filterStrength)
intImage.finalizeImage()
filtImage.finalizeImage()
def runFilter_gaussian(infile, outfile, filterStrength):
from isceobj import Filter
logger.info("Applying power-spectral filter")
# Initialize the flattened interferogram
topoflatIntFilename = infile
intImage = isceobj.createIntImage()
intImage.load(infile + '.xml')
intImage.setAccessMode('read')
intImage.createImage()
# Create the filtered interferogram
filtImage = isceobj.createIntImage()
filtImage.setFilename(outfile)
filtImage.setWidth(intImage.getWidth())
filtImage.setAccessMode('write')
filtImage.createImage()
objFilter = Filter()
objFilter.wireInputPort(name='interferogram', object=intImage)
objFilter.wireOutputPort(name='filtered interferogram', object=filtImage)
objFilter.gaussianFilter(filterWidth=10, filterHeight=10, sigma=1)
intImage.finalizeImage()
filtImage.finalizeImage()
def filter_ifg(ifgFilename, outname=None, filterStrength=0.5):
ifgDirname = os.path.dirname(ifgFilename)
filename_only = os.path.split(ifgFilename)[1]
if outname is None:
outname = os.path.join(ifgDirname, "filt_" + filename_only)
img1 = isceobj.createImage()
img1.load(ifgFilename + ".xml")
widthInt = img1.getWidth()
intImage = isceobj.createIntImage()
intImage.setFilename(ifgFilename)
intImage.setWidth(widthInt)
intImage.setAccessMode("read")
intImage.createImage()
# Create the filtered interferogram
filtImage = isceobj.createIntImage()
filtImage.setFilename(outname)
filtImage.setWidth(widthInt)
filtImage.setAccessMode("write")
filtImage.createImage()
objFilter = Filter()
objFilter.wireInputPort(name="interferogram", object=intImage)
objFilter.wireOutputPort(name="filtered interferogram", object=filtImage)
objFilter.goldsteinWerner(alpha=filterStrength)
intImage.finalizeImage()
filtImage.finalizeImage()
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'
os.makedirs(insarDir, exist_ok=True)
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 runFilter(self, filterStrength):
logger.info("Applying power-spectral filter")
# Initialize the flattened interferogram
topoflatIntFilename = self.insar.topophaseFlatFilename
intImage = isceobj.createIntImage()
widthInt = self.insar.resampIntImage.width
intImage.setFilename(topoflatIntFilename)
intImage.setWidth(widthInt)
intImage.setAccessMode('read')
intImage.createImage()
# Create the filtered interferogram
filtIntFilename = 'filt_' + topoflatIntFilename
filtImage = isceobj.createIntImage()
filtImage.setFilename(filtIntFilename)
filtImage.setWidth(widthInt)
filtImage.setAccessMode('write')
filtImage.createImage()
objFilter = Filter()
objFilter.wireInputPort(name='interferogram', object=intImage)
objFilter.wireOutputPort(name='filtered interferogram', object=filtImage)
if filterStrength is not None:
self.insar.filterStrength = filterStrength
objFilter.goldsteinWerner(alpha=self.insar.filterStrength)
intImage.finalizeImage()
filtImage.finalizeImage()
del filtImage
#Create phase sigma correlation file here
filtImage = isceobj.createIntImage()
filtImage.setFilename(filtIntFilename)
filtImage.setWidth(widthInt)
filtImage.setAccessMode('read')
filtImage.createImage()
phsigImage = isceobj.createImage()
phsigImage.dataType = 'FLOAT'
phsigImage.bands = 1
phsigImage.setWidth(widthInt)
phsigImage.setFilename(self.insar.phsigFilename)
phsigImage.setAccessMode('write')
phsigImage.setImageType(
'cor'
) #the type in this case is not for mdx.py displaying but for geocoding method
phsigImage.createImage()
ampImage = isceobj.createAmpImage()
IU.copyAttributes(self.insar.resampAmpImage, ampImage)
ampImage.setAccessMode('read')
ampImage.createImage()
icuObj = Icu(name='insarapp_filter_icu')
icuObj.configure()
icuObj.unwrappingFlag = False
icuObj.icu(intImage=filtImage, ampImage=ampImage, phsigImage=phsigImage)
filtImage.finalizeImage()
phsigImage.finalizeImage()
ampImage.finalizeImage()
phsigImage.renderHdr()
# Set the filtered image to be the one geocoded
self.insar.topophaseFlatFilename = filtIntFilename
def run(resampAmpImage, widthInt, infos, catalog=None, sceneid='NO_ID'):
logger.info("Applying power-spectral filter: %s" % sceneid)
# Initialize the flattened interferogram
topoflatIntFilename = infos['outputPath'] + '.' + infos['topophaseFlatFilename']
intImage = isceobj.createIntImage()
intImage.setFilename(topoflatIntFilename)
intImage.setWidth(widthInt)
intImage.setAccessMode('read')
intImage.createImage()
# Create the filtered interferogram
filtIntFilename = infos['outputPath'] + '.' + infos['filt_topophaseFlatFilename']
filtImage = isceobj.createIntImage()
filtImage.setFilename(filtIntFilename)
filtImage.setWidth(widthInt)
filtImage.setAccessMode('write')
filtImage.createImage()
objFilter = Filter()
objFilter.wireInputPort(name='interferogram',object=intImage)
objFilter.wireOutputPort(name='filtered interferogram',object=filtImage)
objFilter.goldsteinWerner(alpha=infos['filterStrength'])
intImage.finalizeImage()
filtImage.finalizeImage()
#Create phase sigma correlation file here
filtImage = isceobj.createIntImage()
filtImage.setFilename(filtIntFilename)
filtImage.setWidth(widthInt)
filtImage.setAccessMode('read')
filtImage.createImage()
phsigFilename = infos['outputPath'] + '.' + infos['phsigFilename']
phsigImage = isceobj.createImage()
phsigImage.dataType='FLOAT'
phsigImage.bands = 1
phsigImage.setWidth(widthInt)
phsigImage.setFilename(phsigFilename)
phsigImage.setAccessMode('write')
phsigImage.setImageType('cor')#the type in this case is not for mdx.py displaying but for geocoding method
phsigImage.createImage()
ampImage = isceobj.createAmpImage()
IU.copyAttributes(resampAmpImage, ampImage)
ampImage.setAccessMode('read')
ampImage.createImage()
icuObj = Icu(name='insarapp_filter_icu')
icuObj.configure()
icuObj.filteringFlag = False
icuObj.unwrappingFlag = False
icuObj.initCorrThreshold = 0.1
icuObj.icu(intImage=filtImage, ampImage=ampImage, phsigImage=phsigImage)
filtImage.finalizeImage()
phsigImage.finalizeImage()
phsigImage.renderHdr()
ampImage.finalizeImage()
def runFilter(self):
if not self.doInSAR:
return
logger.info("Applying power-spectral filter")
mergedir = self._insar.mergedDirname
filterStrength = self.filterStrength
# Initialize the flattened interferogram
inFilename = os.path.join(mergedir, self._insar.mergedIfgname)
intImage = isceobj.createIntImage()
intImage.load(inFilename + '.xml')
intImage.setAccessMode('read')
intImage.createImage()
widthInt = intImage.getWidth()
# Create the filtered interferogram
filtIntFilename = os.path.join(mergedir, self._insar.filtFilename)
filtImage = isceobj.createIntImage()
filtImage.setFilename(filtIntFilename)
filtImage.setWidth(widthInt)
filtImage.setAccessMode('write')
filtImage.createImage()
objFilter = Filter()
objFilter.wireInputPort(name='interferogram', object=intImage)
objFilter.wireOutputPort(name='filtered interferogram', object=filtImage)
objFilter.goldsteinWerner(alpha=filterStrength)
intImage.finalizeImage()
filtImage.finalizeImage()
del filtImage
#Create phase sigma correlation file here
filtImage = isceobj.createIntImage()
filtImage.setFilename(filtIntFilename)
filtImage.setWidth(widthInt)
filtImage.setAccessMode('read')
filtImage.createImage()
phsigImage = isceobj.createImage()
phsigImage.dataType = 'FLOAT'
phsigImage.bands = 1
phsigImage.setWidth(widthInt)
phsigImage.setFilename(
os.path.join(mergedir, self._insar.coherenceFilename))
phsigImage.setAccessMode('write')
phsigImage.setImageType(
'cor'
) #the type in this case is not for mdx.py displaying but for geocoding method
phsigImage.createImage()
icuObj = Icu(name='topsapp_filter_icu')
icuObj.configure()
icuObj.unwrappingFlag = False
icuObj.useAmplitudeFlag = False
icuObj.icu(intImage=filtImage, phsigImage=phsigImage)
filtImage.finalizeImage()
phsigImage.finalizeImage()
phsigImage.renderHdr()
def runFilter(self, filterStrength, igramSpectrum = "full"):
logger.info("Applying power-spectral filter")
if igramSpectrum == "full":
logger.info("Filtering the full-band interferogram")
ifgDirname = self.insar.ifgDirname
elif igramSpectrum == "low":
if not self.doDispersive:
print('Estimating dispersive phase not requested ... skipping sub-band interferograms')
return
logger.info("Filtering the low-band interferogram")
ifgDirname = os.path.join(self.insar.ifgDirname, self.insar.lowBandSlcDirname)
elif igramSpectrum == "high":
if not self.doDispersive:
print('Estimating dispersive phase not requested ... skipping sub-band interferograms')
return
logger.info("Filtering the high-band interferogram")
ifgDirname = os.path.join(self.insar.ifgDirname, self.insar.highBandSlcDirname)
topoflatIntFilename = os.path.join(ifgDirname , self.insar.ifgFilename)
img1 = isceobj.createImage()
img1.load(topoflatIntFilename + '.xml')
widthInt = img1.getWidth()
intImage = isceobj.createIntImage()
intImage.setFilename(topoflatIntFilename)
intImage.setWidth(widthInt)
intImage.setAccessMode('read')
intImage.createImage()
# Create the filtered interferogram
filtIntFilename = os.path.join(ifgDirname , 'filt_' + self.insar.ifgFilename)
filtImage = isceobj.createIntImage()
filtImage.setFilename(filtIntFilename)
filtImage.setWidth(widthInt)
filtImage.setAccessMode('write')
filtImage.createImage()
objFilter = Filter()
objFilter.wireInputPort(name='interferogram',object=intImage)
objFilter.wireOutputPort(name='filtered interferogram',object=filtImage)
if filterStrength is not None:
self.insar.filterStrength = filterStrength
objFilter.goldsteinWerner(alpha=self.insar.filterStrength)
intImage.finalizeImage()
filtImage.finalizeImage()
del filtImage
#Create phase sigma correlation file here
filtImage = isceobj.createIntImage()
filtImage.setFilename(filtIntFilename)
filtImage.setWidth(widthInt)
filtImage.setAccessMode('read')
filtImage.createImage()
phsigImage = isceobj.createImage()
phsigImage.dataType='FLOAT'
phsigImage.bands = 1
phsigImage.setWidth(widthInt)
phsigImage.setFilename(os.path.join(ifgDirname , self.insar.coherenceFilename))
phsigImage.setAccessMode('write')
phsigImage.setImageType('cor')#the type in this case is not for mdx.py displaying but for geocoding method
phsigImage.createImage()
resampAmpImage = os.path.join(ifgDirname , self.insar.ifgFilename)
if '.flat' in resampAmpImage:
resampAmpImage = resampAmpImage.replace('.flat', '.amp')
elif '.int' in resampAmpImage:
resampAmpImage = resampAmpImage.replace('.int', '.amp')
else:
resampAmpImage += '.amp'
ampImage = isceobj.createAmpImage()
ampImage.setWidth(widthInt)
ampImage.setFilename(resampAmpImage)
#IU.copyAttributes(self.insar.resampAmpImage, ampImage)
#IU.copyAttributes(resampAmpImage, ampImage)
ampImage.setAccessMode('read')
ampImage.createImage()
icuObj = Icu(name='stripmapapp_filter_icu')
icuObj.configure()
icuObj.unwrappingFlag = False
icuObj.icu(intImage = filtImage, ampImage=ampImage, phsigImage=phsigImage)
filtImage.finalizeImage()
phsigImage.finalizeImage()
phsigImage.renderHdr()
ampImage.finalizeImage()
def runFilter(inps):
logger.info("Applying power-spectral filter")
#get width from the header file of input interferogram
width = getWidth(inps.intf + '.xml')
length = getLength(inps.intf + '.xml')
if shutil.which('psfilt1') != None:
cmd = "psfilt1 {int} {filtint} {width} {filterstrength} 64 16".format(
int = inps.intf,
filtint = inps.fintf,
width = width,
filterstrength = inps.alpha
)
runCmd(cmd)
#get xml file for interferogram
create_xml(inps.fintf, width, length, 'int')
else:
#create flattened interferogram
intImage = isceobj.createIntImage()
intImage.setFilename(inps.intf)
intImage.setWidth(width)
intImage.setAccessMode('read')
intImage.createImage()
#create the filtered interferogram
filtImage = isceobj.createIntImage()
filtImage.setFilename(inps.fintf)
filtImage.setWidth(width)
filtImage.setAccessMode('write')
filtImage.createImage()
#create filter and run it
objFilter = Filter()
objFilter.wireInputPort(name='interferogram',object=intImage)
objFilter.wireOutputPort(name='filtered interferogram',object=filtImage)
objFilter.goldsteinWerner(alpha=inps.alpha)
intImage.finalizeImage()
filtImage.finalizeImage()
del filtImage
#recreate filt image to read
filtImage = isceobj.createIntImage()
filtImage.setFilename(inps.fintf)
filtImage.setWidth(width)
filtImage.setAccessMode('read')
filtImage.createImage()
#create amplitude image
ampImage = isceobj.createAmpImage()
ampImage.setFilename(inps.amp)
ampImage.setWidth(width)
ampImage.setAccessMode('read')
ampImage.createImage()
#create phase sigma correlation file here
phsig_tmp = 'tmp.phsig'
phsigImage = isceobj.createImage()
phsigImage.setFilename(phsig_tmp)
phsigImage.setWidth(width)
phsigImage.dataType='FLOAT'
phsigImage.bands = 1
phsigImage.setImageType('cor')#the type in this case is not for mdx.py displaying but for geocoding method
phsigImage.setAccessMode('write')
phsigImage.createImage()
#create icu and run it
icuObj = Icu(name='insarapp_filter_icu')
icuObj.configure()
icuObj.unwrappingFlag = False
icuObj.icu(intImage = filtImage, ampImage=ampImage, phsigImage=phsigImage)
phsigImage.renderHdr()
filtImage.finalizeImage()
ampImage.finalizeImage()
phsigImage.finalizeImage()
# #add an amplitude channel to phsig file
# cmd = "imageMath.py -e='sqrt(a_0*a_1)*(b!=0);b' --a={amp} --b={phsig_tmp} -o {phsig} -s BIL".format(
# amp = inps.amp,
# phsig_tmp = phsig_tmp,
# phsig = inps.phsig
# )
#add an amplitude channel to phsig file
cmd = "imageMath.py -e='sqrt(a_0*a_1)*(b!=0);b' --a={amp} --b={phsig_tmp} -o {phsig} -s BIL".format(
amp = inps.amp,
phsig_tmp = phsig_tmp,
phsig = inps.phsig
)
runCmd(cmd)
#remove the original phsig file
os.remove(phsig_tmp)
os.remove(phsig_tmp + '.xml')
os.remove(phsig_tmp + '.vrt')
#rename original filtered interferogram
filt_tmp = 'filt_tmp.int'
os.rename(inps.fintf, filt_tmp)
os.rename(inps.fintf + '.xml', filt_tmp + '.xml')
os.rename(inps.fintf + '.vrt', filt_tmp + '.vrt')
#do the numpy calculations
#replace the magnitude of the filtered interferogram with magnitude of original interferogram
#mask output file using layover mask (values 2 and 3).
# cmd = "imageMath.py -e='a/(abs(a)+(abs(a)==0))*abs(b)*(c<2)' --a={0} --b={1} --c={2} -t CFLOAT -o={3}".format(
# filt_tmp,
# inps.intf,
# inps.msk,
# inps.fintf
# )
#replacing magnitude is not good for phase unwrapping using snaphu
cmd = "imageMath.py -e='a*(b<2)' --a={0} --b={1} -t CFLOAT -o={2}".format(
filt_tmp,
inps.msk,
inps.fintf
)
runCmd(cmd)
#remove the original filtered interferogram
os.remove(filt_tmp)
os.remove(filt_tmp + '.xml')
os.remove(filt_tmp + '.vrt')