def generateIgram(imageSlc1, imageSlc2, resampName, azLooks, rgLooks):
objSlc1 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc1, objSlc1)
objSlc1.setAccessMode('read')
objSlc1.createImage()
objSlc2 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc2, objSlc2)
objSlc2.setAccessMode('read')
objSlc2.createImage()
slcWidth = imageSlc1.getWidth()
intWidth = int(slcWidth / rgLooks)
lines = min(imageSlc1.getLength(), imageSlc2.getLength())
if '.flat' in resampName:
resampAmp = resampName.replace('.flat', '.amp')
elif '.int' in resampName:
resampAmp = resampName.replace('.int', '.amp')
else:
resampAmp += '.amp'
resampInt = resampName
objInt = isceobj.createIntImage()
objInt.setFilename(resampInt)
objInt.setWidth(intWidth)
imageInt = isceobj.createIntImage()
IU.copyAttributes(objInt, imageInt)
objInt.setAccessMode('write')
objInt.createImage()
objAmp = isceobj.createAmpImage()
objAmp.setFilename(resampAmp)
objAmp.setWidth(intWidth)
imageAmp = isceobj.createAmpImage()
IU.copyAttributes(objAmp, imageAmp)
objAmp.setAccessMode('write')
objAmp.createImage()
objCrossmul = crossmul.createcrossmul()
objCrossmul.width = slcWidth
objCrossmul.length = lines
objCrossmul.LooksDown = azLooks
objCrossmul.LooksAcross = rgLooks
objCrossmul.crossmul(objSlc1, objSlc2, objInt, objAmp)
for obj in [objInt, objAmp, objSlc1, objSlc2]:
obj.finalizeImage()
return imageInt, imageAmp
def run(imageSlc1, imageSlc2, resampName, azLooks, rgLooks):
objSlc1 = isceobj.createSlcImage()
#right now imageSlc1 and 2 are just text files, need to open them as image
IU.copyAttributes(imageSlc1, objSlc1)
objSlc1.setAccessMode('read')
objSlc1.createImage()
objSlc2 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc2, objSlc2)
objSlc2.setAccessMode('read')
objSlc2.createImage()
slcWidth = imageSlc1.getWidth()
intWidth = int(slcWidth / rgLooks)
lines = min(imageSlc1.getLength(), imageSlc2.getLength())
resampAmp = resampName + '.amp'
resampInt = resampName + '.int'
objInt = isceobj.createIntImage()
objInt.setFilename(resampInt)
objInt.setWidth(intWidth)
imageInt = isceobj.createIntImage()
IU.copyAttributes(objInt, imageInt)
objInt.setAccessMode('write')
objInt.createImage()
objAmp = isceobj.createAmpImage()
objAmp.setFilename(resampAmp)
objAmp.setWidth(intWidth)
imageAmp = isceobj.createAmpImage()
IU.copyAttributes(objAmp, imageAmp)
objAmp.setAccessMode('write')
objAmp.createImage()
objCrossmul = crossmul.createcrossmul()
objCrossmul.width = slcWidth
objCrossmul.length = lines
objCrossmul.LooksDown = azLooks
objCrossmul.LooksAcross = rgLooks
objCrossmul.crossmul(objSlc1, objSlc2, objInt, objAmp)
for obj in [objInt, objAmp, objSlc1, objSlc2]:
obj.finalizeImage()
return imageInt, imageAmp
def create_xml(fileName, width, length, fileType):
import isceobj
if fileType == 'slc':
image = isceobj.createSlcImage()
elif fileType == 'int':
image = isceobj.createIntImage()
elif fileType == 'amp':
image = isceobj.createAmpImage()
elif fileType == 'cor':
image = isceobj.createOffsetImage()
elif fileType == 'rmg' or fileType == 'unw':
image = isceobj.Image.createUnwImage()
elif fileType == 'byte':
image = isceobj.createImage()
image.setDataType('BYTE')
elif fileType == 'float':
image = isceobj.createImage()
image.setDataType('FLOAT')
elif fileType == 'double':
image = isceobj.createImage()
image.setDataType('DOUBLE')
else:
raise Exception('format not supported yet!\n')
image.setFilename(fileName)
image.extraFilename = fileName + '.vrt'
image.setWidth(width)
image.setLength(length)
#image.setAccessMode('read')
#image.createImage()
image.renderHdr()
def coherence(amplitudeFile,
interferogramFile,
coherenceFile,
method="cchz_wave",
windowSize=5):
'''
compute coherence using a window
'''
import operator
from mroipac.correlation.correlation import Correlation
CORRELATION_METHOD = {
'phase_gradient':
operator.methodcaller('calculateEffectiveCorrelation'),
'cchz_wave': operator.methodcaller('calculateCorrelation')
}
ampImage = isceobj.createAmpImage()
ampImage.load(amplitudeFile + '.xml')
ampImage.setAccessMode('read')
ampImage.createImage()
intImage = isceobj.createIntImage()
intImage.load(interferogramFile + '.xml')
intImage.setAccessMode('read')
intImage.createImage()
#there is no coherence image in the isceobj/Image
cohImage = isceobj.createOffsetImage()
cohImage.setFilename(coherenceFile)
cohImage.setWidth(ampImage.width)
cohImage.setAccessMode('write')
cohImage.createImage()
cor = Correlation()
cor.configure()
cor.wireInputPort(name='amplitude', object=ampImage)
cor.wireInputPort(name='interferogram', object=intImage)
cor.wireOutputPort(name='correlation', object=cohImage)
cor.windowSize = windowSize
cohImage.finalizeImage()
intImage.finalizeImage()
ampImage.finalizeImage()
try:
CORRELATION_METHOD[method](cor)
except KeyError:
print("Unrecognized correlation method")
sys.exit(1)
pass
return None
def coherence(inps, method="phase_gradient"):
#logger.info("Calculating Coherence")
#get width from the header file of input interferogram
width = getWidth(inps.intf + '.xml')
# Initialize the amplitude
ampImage = isceobj.createAmpImage()
ampImage.setFilename(inps.amp)
ampImage.setWidth(width)
ampImage.setAccessMode('read')
ampImage.createImage()
#ampImage = self.insar.getResampOnlyAmp().copy(access_mode='read')
# Initialize the flattened inteferogram
intImage = isceobj.createIntImage()
intImage.setFilename(inps.intf)
intImage.setWidth(width)
intImage.setAccessMode('read')
intImage.createImage()
# Create the coherence image
#there is no coherence image in the isceobj/Image
cohImage = isceobj.createOffsetImage()
cohImage.setFilename(inps.cor)
cohImage.setWidth(width)
cohImage.setAccessMode('write')
cohImage.createImage()
cor = Correlation()
cor.configure()
cor.wireInputPort(name='interferogram', object=intImage)
cor.wireInputPort(name='amplitude', object=ampImage)
cor.wireOutputPort(name='correlation', object=cohImage)
cor.windowSize = inps.winsize
cohImage.finalizeImage()
intImage.finalizeImage()
ampImage.finalizeImage()
try:
CORRELATION_METHOD[method](cor)
except KeyError:
print("Unrecognized correlation method")
sys.exit(1)
pass
return None
def create_xml(fileName, width, length, fileType):
if fileType == 'slc':
image = isceobj.createSlcImage()
elif fileType == 'int':
image = isceobj.createIntImage()
elif fileType == 'amp':
image = isceobj.createAmpImage()
elif fileType == 'float':
image = isceobj.createImage()
image.setDataType('FLOAT')
image.setFilename(fileName)
image.setWidth(width)
image.setLength(length)
image.setAccessMode('read')
image.createImage()
image.renderHdr()
image.finalizeImage()
def ampLooks(inps):
inWidth = getWidth(inps.input + '.xml')
inLength = getLength(inps.input + '.xml')
outWidth = int(inWidth / inps.rlks)
outLength = int(inLength / inps.alks)
#run it
#cmd = 'echo -e "{}\n{}\n{} {}\n{} {}\n" | $INSAR_ZERODOP_BIN/rilooks'.format(inps.input, inps.output, inWidth, inLength, inps.rlks, inps.alks)
#it seems that echo does not require -e in this situation, strange
cmd = 'echo "{}\n{}\n{} {}\n{} {}\n" | $INSAR_ZERODOP_BIN/rilooks'.format(
inps.input, inps.output, inWidth, inLength, inps.rlks, inps.alks)
runCmd(cmd)
#get xml file for amplitude image
ampImage = isceobj.createAmpImage()
ampImage.setFilename(inps.output)
ampImage.setWidth(outWidth)
ampImage.setLength(outLength)
ampImage.setAccessMode('read')
#ampImage.createImage()
ampImage.renderVRT()
ampImage.renderHdr()
def estPhaseSigma(insar):
from mroipac.icu.Icu import Icu
intImage = isceobj.createSlcImage() #Filtered file
intImage.setWidth(insar.resampIntImage.width)
intImage.setFilename(insar.topophaseFlatFilename)
intImage.setAccessMode('read')
ampImage = isceobj.createAmpImage()
ampImage.setWidth(insar.resampIntImage.width)
ampImage.setFilename('resampOnlyImage.amp')
ampImage.setAccessMode('read')
outImage = isceobj.createRgImage()
outImage.imageType = 'cor'
outImage.scheme = 'BIL'
outImage.bands = 1
outImage.setWidth(insar.resampIntImage.width)
outImage.setFilename('phsig.cor')
outImage.setAccessMode('write')
intImage.createImage()
ampImage.createImage()
outImage.createImage()
icuObj = Icu()
icuObj.filteringFlag = False
icuObj.unwrappingFlag = False
icuObj.initCorrThreshold = 0.1
icuObj.icu(intImage=intImage, ampImage=ampImage, phsigImage=outImage)
outImage.renderHdr()
intImage.finalizeImage()
ampImage.finalizeImage()
outImage.finalizeImage()
def runUnwrap(self, igramSpectrum="full"):
'''Specific connector from an insarApp object to a Snaphu object.'''
if igramSpectrum == "full":
ifgDirname = self.insar.ifgDirname
elif igramSpectrum == "low":
if not self.doDispersive:
print(
'Estimating dispersive phase not requested ... skipping sub-band interferogram unwrapping'
)
return
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 interferogram unwrapping'
)
return
ifgDirname = os.path.join(self.insar.ifgDirname,
self.insar.highBandSlcDirname)
wrapName = os.path.join(ifgDirname, 'filt_' + self.insar.ifgFilename)
if '.flat' in wrapName:
unwrapName = wrapName.replace('.flat', '.unw')
elif '.int' in wrapName:
unwrapName = wrapName.replace('.int', '.unw')
else:
unwrapName = wrapName + '.unw'
img1 = isceobj.createImage()
img1.load(wrapName + '.xml')
width = img1.getWidth()
# Get amp image name
originalWrapName = os.path.join(ifgDirname, self.insar.ifgFilename)
if '.flat' in originalWrapName:
resampAmpImage = originalWrapName.replace('.flat', '.amp')
elif '.int' in originalWrapName:
resampAmpImage = originalWrapName.replace('.int', '.amp')
else:
resampAmpImage = originalWrapName + '.amp'
ampImage = isceobj.createAmpImage()
ampImage.setWidth(width)
ampImage.setFilename(resampAmpImage)
ampImage.setAccessMode('read')
ampImage.createImage()
#width = ampImage.getWidth()
#intImage
intImage = isceobj.createIntImage()
intImage.initImage(wrapName, 'read', width)
intImage.createImage()
#unwImage
unwImage = isceobj.Image.createUnwImage()
unwImage.setFilename(unwrapName)
unwImage.setWidth(width)
unwImage.imageType = 'unw'
unwImage.bands = 2
unwImage.scheme = 'BIL'
unwImage.dataType = 'FLOAT'
unwImage.setAccessMode('write')
unwImage.createImage()
icuObj = Icu(name='insarapp_icu')
icuObj.configure()
icuObj.filteringFlag = False
#icuObj.useAmplitudeFlag = False
icuObj.singlePatch = True
icuObj.initCorrThreshold = 0.1
icuObj.icu(intImage=intImage, ampImage=ampImage, unwImage=unwImage)
#At least one can query for the name used
self.insar.connectedComponentsFilename = icuObj.conncompFilename
ampImage.finalizeImage()
intImage.finalizeImage()
unwImage.finalizeImage()
unwImage.renderHdr()
return
#end class
if __name__ == "__main__":
import isceobj
from iscesys.ImageUtil.ImageUtil import ImageUtil as IU
wid = 2659
objInt = isceobj.createIntImage()
objInt.initImage('test.int', 'read', wid)
objInt.createImage()
objAmp = isceobj.createAmpImage()
objAmp.initImage('test.amp','read',wid)
objAmp.createImage()
objFilt = isceobj.createIntImage()
objFilt.setFilename('test.filt')
objFilt.setWidth(wid)
objFilt.setAccessMode('write')
objFilt.createImage()
objUnw = isceobj.createAmpImage()
objUnw.bands = 2
objUnw.scheme = 'BIL'
objUnw.setFilename('test.unw')
objUnw.setWidth(wid)
objUnw.setAccessMode('write')
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)
sSLC = isceobj.createSlcImage()
sSLC.setFilename(slave2)
sSLC.setWidth(slaveWidth)
sSLC.setLength(slaveLength)
sSLC.setAccessMode('read')
sSLC.createImage()
#create interferogram
interf = isceobj.createIntImage()
interf.setFilename(inps.interferogram)
interf.setWidth(intWidth)
interf.setAccessMode('write')
interf.createImage()
#create amplitdue
amplitude = isceobj.createAmpImage()
amplitude.setFilename(inps.amplitude)
amplitude.setWidth(intWidth)
amplitude.setAccessMode('write')
amplitude.createImage()
#create a writer for resamp
stdWriter = create_writer("log", "", True, filename="resamp.log")
stdWriter.setFileTag("resamp", "log")
stdWriter.setFileTag("resamp", "err")
stdWriter.setFileTag("resamp", "out")
#open slave frame to get SAR parameters
#with open(inps.slave + '.pck', 'rb') as f:
#slaveFrame = pickle.load(f)
def run(imageInt,
imageAmp,
instrument,
offsetField,
infos,
stdWriter,
catalog=None,
sceneid='NO_ID'):
logger.info("Running Resamp_only: %s" % sceneid)
objInt = isceobj.createIntImage()
objIntOut = isceobj.createIntImage()
IU.copyAttributes(imageInt, objInt)
IU.copyAttributes(imageInt, objIntOut)
outIntFilename = infos['outputPath'] + '.' + infos['resampOnlyImageName']
objInt.setAccessMode('read')
objIntOut.setFilename(outIntFilename)
objIntOut.setAccessMode('write')
objInt.createImage()
objIntOut.createImage()
objAmp = isceobj.createAmpImage()
objAmpOut = isceobj.createAmpImage()
IU.copyAttributes(imageAmp, objAmp)
IU.copyAttributes(imageAmp, objAmpOut)
outAmpFilename = outIntFilename.replace('int', 'amp')
objAmp.setAccessMode('read')
objAmpOut.setFilename(outAmpFilename)
objAmpOut.setAccessMode('write')
objAmp.createImage()
objAmpOut.createImage()
numRangeBin = objInt.getWidth()
lines = objInt.getLength()
dopplerCoeff = infos['dopplerCentroid'].getDopplerCoefficients(inHz=False)
objResamp = stdproc.createResamp_only()
objResamp.setNumberLines(lines)
objResamp.setNumberFitCoefficients(infos['numberFitCoefficients'])
objResamp.setSlantRangePixelSpacing(infos['slantRangePixelSpacing'])
objResamp.setNumberRangeBin(numRangeBin)
objResamp.setDopplerCentroidCoefficients(dopplerCoeff)
objResamp.wireInputPort(name='offsets', object=offsetField)
objResamp.wireInputPort(name='instrument', object=instrument)
#set the tag used in the outfile. each message is precided by this tag
#if the writer is not of "file" type the call has no effect
objResamp.stdWriter = stdWriter.set_file_tags("resamp_only", "log", "err",
"out")
objResamp.resamp_only(objInt, objIntOut, objAmp, objAmpOut)
if catalog is not None:
# Record the inputs and outputs
isceobj.Catalog.recordInputsAndOutputs(catalog, objResamp,
"runResamp_only.%s" % sceneid,
logger,
"runResamp_only.%s" % sceneid)
objInt.finalizeImage()
objIntOut.finalizeImage()
objAmp.finalizeImage()
objAmpOut.finalizeImage()
return objIntOut, objAmpOut
def runResamp(self):
logger.info("Resampling interferogram")
imageSlc1 = self.insar.referenceSlcImage
imageSlc2 = self.insar.secondarySlcImage
resampName = self.insar.resampImageName
resampAmp = resampName + '.amp'
resampInt = resampName + '.int'
azLooks = self.insar.numberAzimuthLooks
rLooks = self.insar.numberRangeLooks
objSlc1 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc1, objSlc1)
objSlc1.setAccessMode('read')
objSlc1.createImage()
objSlc2 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc2, objSlc2)
objSlc2.setAccessMode('read')
objSlc2.createImage()
#slcWidth = max(imageSlc1.getWidth(), imageSlc2.getWidth())
slcWidth = imageSlc1.getWidth()
intWidth = int(slcWidth / rLooks)
dataType = 'CFLOAT'
objInt = isceobj.createIntImage()
objInt.setFilename(resampInt)
objInt.setWidth(intWidth)
imageInt = isceobj.createIntImage()
IU.copyAttributes(objInt, imageInt)
objInt.setAccessMode('write')
objInt.createImage()
objAmp = isceobj.createAmpImage()
objAmp.setFilename(resampAmp)
objAmp.setWidth(intWidth)
imageAmp = isceobj.createAmpImage()
IU.copyAttributes(objAmp, imageAmp)
objAmp.setAccessMode('write')
objAmp.createImage()
self.insar.resampIntImage = imageInt
self.insar.resampAmpImage = imageAmp
instrument = self.insar.referenceFrame.getInstrument()
offsetField = self.insar.refinedOffsetField
lines = self.insar.numberResampLines
####Modified to deal with secondary PRF correctly
dopplerCoeff = self.insar.dopplerCentroid.getDopplerCoefficients(inHz=True)
for num in range(len(dopplerCoeff)):
dopplerCoeff[num] /= self.insar.secondaryFrame.getInstrument(
).getPulseRepetitionFrequency()
numFitCoeff = self.insar.numberFitCoefficients
# pixelSpacing = self.insar.slantRangePixelSpacing
fS = self._insar.getSecondaryFrame().getInstrument().getRangeSamplingRate()
pixelSpacing = CN.SPEED_OF_LIGHT / (2. * fS)
objResamp = stdproc.createResamp()
objResamp.setNumberLines(lines)
objResamp.setNumberFitCoefficients(numFitCoeff)
objResamp.setNumberAzimuthLooks(azLooks)
objResamp.setNumberRangeLooks(rLooks)
objResamp.setSlantRangePixelSpacing(pixelSpacing)
objResamp.setDopplerCentroidCoefficients(dopplerCoeff)
objResamp.wireInputPort(name='offsets', object=offsetField)
objResamp.wireInputPort(name='instrument', object=instrument)
#set the tag used in the outfile. each message is precided by this tag
#is the writer is not of "file" type the call has no effect
objResamp.stdWriter = self._writer_set_file_tags("resamp", "log", "err",
"out")
objResamp.resamp(objSlc1, objSlc2, objInt, objAmp)
# Record the inputs and outputs
from isceobj.Catalog import recordInputsAndOutputs
recordInputsAndOutputs(self._insar.procDoc, objResamp, "runResamp", logger,
"runResamp")
objInt.finalizeImage()
objAmp.finalizeImage()
objSlc1.finalizeImage()
objSlc2.finalizeImage()
return None
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 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)
def generateIgram(self, imageSlc1, imageSlc2, resampName, azLooks, rgLooks,
radarWavelength):
objSlc1 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc1, objSlc1)
objSlc1.setAccessMode('read')
objSlc1.createImage()
objSlc2 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc2, objSlc2)
objSlc2.setAccessMode('read')
objSlc2.createImage()
slcWidth = imageSlc1.getWidth()
if not self.doRubbersheetingRange:
intWidth = int(
slcWidth / rgLooks
) # Modified by V. Brancato intWidth = int(slcWidth / rgLooks)
else:
intWidth = int(slcWidth)
lines = min(imageSlc1.getLength(), imageSlc2.getLength())
if '.flat' in resampName:
resampAmp = resampName.replace('.flat', '.amp')
elif '.int' in resampName:
resampAmp = resampName.replace('.int', '.amp')
else:
resampAmp += '.amp'
if not self.doRubbersheetingRange:
resampInt = resampName
else:
resampInt = resampName + ".full"
objInt = isceobj.createIntImage()
objInt.setFilename(resampInt)
objInt.setWidth(intWidth)
imageInt = isceobj.createIntImage()
IU.copyAttributes(objInt, imageInt)
objInt.setAccessMode('write')
objInt.createImage()
objAmp = isceobj.createAmpImage()
objAmp.setFilename(resampAmp)
objAmp.setWidth(intWidth)
imageAmp = isceobj.createAmpImage()
IU.copyAttributes(objAmp, imageAmp)
objAmp.setAccessMode('write')
objAmp.createImage()
if not self.doRubbersheetingRange:
print(
'Rubbersheeting in range is off, interferogram is already flattened'
)
objCrossmul = crossmul.createcrossmul()
objCrossmul.width = slcWidth
objCrossmul.length = lines
objCrossmul.LooksDown = azLooks
objCrossmul.LooksAcross = rgLooks
objCrossmul.crossmul(objSlc1, objSlc2, objInt, objAmp)
else:
# Modified by V. Brancato 10.09.2019 (added option to add Range Rubber sheet Flat-earth back)
print('Rubbersheeting in range is on, removing flat-Earth phase')
objCrossmul = crossmul.createcrossmul()
objCrossmul.width = slcWidth
objCrossmul.length = lines
objCrossmul.LooksDown = 1
objCrossmul.LooksAcross = 1
objCrossmul.crossmul(objSlc1, objSlc2, objInt, objAmp)
# Remove Flat-Earth component
compute_FlatEarth(self, resampInt, intWidth, lines, radarWavelength)
# Perform Multilook
multilook(resampInt, outname=resampName, alks=azLooks,
rlks=rgLooks) #takeLooks(objAmp,azLooks,rgLooks)
multilook(resampAmp,
outname=resampAmp.replace(".full", ""),
alks=azLooks,
rlks=rgLooks) #takeLooks(objInt,azLooks,rgLooks)
#os.system('rm ' + resampInt+'.full* ' + resampAmp + '.full* ')
# End of modification
for obj in [objInt, objAmp, objSlc1, objSlc2]:
obj.finalizeImage()
return imageInt, imageAmp
def runFormInterferogram(self):
'''form interferograms.
'''
if hasattr(self, 'doInSAR'):
if not self.doInSAR:
return
catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name)
self.updateParamemetersFromUser()
referenceTrack = self._insar.loadTrack(reference=True)
secondaryTrack = self._insar.loadTrack(reference=False)
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
os.chdir(frameDir)
for j, swathNumber in enumerate(
range(self._insar.startingSwath, self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
os.chdir(swathDir)
print('forming interferogram frame {}, swath {}'.format(
frameNumber, swathNumber))
referenceSwath = referenceTrack.frames[i].swaths[j]
secondarySwath = secondaryTrack.frames[i].swaths[j]
#############################################
#1. form interferogram
#############################################
refinedOffsets = readOffset('cull.off')
intWidth = int(referenceSwath.numberOfSamples /
self._insar.numberRangeLooks1)
intLength = int(referenceSwath.numberOfLines /
self._insar.numberAzimuthLooks1)
dopplerVsPixel = [
i / secondarySwath.prf for i in secondarySwath.dopplerVsPixel
]
#reference slc
mSLC = isceobj.createSlcImage()
mSLC.load(self._insar.referenceSlc + '.xml')
mSLC.setAccessMode('read')
mSLC.createImage()
#secondary slc
sSLC = isceobj.createSlcImage()
sSLC.load(self._insar.secondarySlc + '.xml')
sSLC.setAccessMode('read')
sSLC.createImage()
#interferogram
interf = isceobj.createIntImage()
interf.setFilename(self._insar.interferogram)
interf.setWidth(intWidth)
interf.setAccessMode('write')
interf.createImage()
#amplitdue
amplitude = isceobj.createAmpImage()
amplitude.setFilename(self._insar.amplitude)
amplitude.setWidth(intWidth)
amplitude.setAccessMode('write')
amplitude.createImage()
#create a writer for resamp
stdWriter = create_writer("log", "", True, filename="resamp.log")
stdWriter.setFileTag("resamp", "log")
stdWriter.setFileTag("resamp", "err")
stdWriter.setFileTag("resamp", "out")
#set up resampling program now
#The setting has been compared with resamp_roi's setting in ROI_pac item by item.
#The two kinds of setting are exactly the same. The number of setting items are
#exactly the same
objResamp = stdproc.createResamp()
objResamp.wireInputPort(name='offsets', object=refinedOffsets)
objResamp.stdWriter = stdWriter
objResamp.setNumberFitCoefficients(6)
objResamp.setNumberRangeBin1(referenceSwath.numberOfSamples)
objResamp.setNumberRangeBin2(secondarySwath.numberOfSamples)
objResamp.setStartLine(1)
objResamp.setNumberLines(referenceSwath.numberOfLines)
objResamp.setFirstLineOffset(1)
objResamp.setDopplerCentroidCoefficients(dopplerVsPixel)
objResamp.setRadarWavelength(secondaryTrack.radarWavelength)
objResamp.setSlantRangePixelSpacing(secondarySwath.rangePixelSize)
objResamp.setNumberRangeLooks(self._insar.numberRangeLooks1)
objResamp.setNumberAzimuthLooks(self._insar.numberAzimuthLooks1)
objResamp.setFlattenWithOffsetFitFlag(0)
objResamp.resamp(mSLC, sSLC, interf, amplitude)
#finialize images
mSLC.finalizeImage()
sSLC.finalizeImage()
interf.finalizeImage()
amplitude.finalizeImage()
stdWriter.finalize()
#############################################
#2. trim amplitude
#############################################
# tmpAmplitude = 'tmp.amp'
# cmd = "imageMath.py -e='a_0*(a_1>0);a_1*(a_0>0)' --a={} -o={} -s BIP -t float".format(
# self._insar.amplitude,
# tmpAmplitude
# )
# runCmd(cmd)
# os.remove(self._insar.amplitude)
# os.remove(tmpAmplitude+'.xml')
# os.remove(tmpAmplitude+'.vrt')
# os.rename(tmpAmplitude, self._insar.amplitude)
#using memmap instead, which should be faster, since we only have a few pixels to change
amp = np.memmap(self._insar.amplitude,
dtype='complex64',
mode='r+',
shape=(intLength, intWidth))
index = np.nonzero((np.real(amp) == 0) + (np.imag(amp) == 0))
amp[index] = 0
del amp
os.chdir('../')
os.chdir('../')
catalog.printToLog(logger, "runFormInterferogram")
self._insar.procDoc.addAllFromCatalog(catalog)
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 run(imageSlc1,
imageSlc2,
resampName,
azLooks,
rgLooks,
lines,
catalog=None,
sceneid='NO_ID'):
logger.info("Generating interferogram: %s" % sceneid)
objSlc1 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc1, objSlc1)
objSlc1.setAccessMode('read')
objSlc1.createImage()
objSlc2 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc2, objSlc2)
objSlc2.setAccessMode('read')
objSlc2.createImage()
slcWidth = imageSlc1.getWidth()
intWidth = int(slcWidth / rgLooks)
logger.info("Will ouput interferogram and amplitude: %s" % sceneid)
resampAmp = resampName + '.amp'
resampInt = resampName + '.int'
objInt = isceobj.createIntImage()
objInt.setFilename(resampInt)
objInt.setWidth(intWidth)
imageInt = isceobj.createIntImage()
IU.copyAttributes(objInt, imageInt)
objInt.setAccessMode('write')
objInt.createImage()
objAmp = isceobj.createAmpImage()
objAmp.setFilename(resampAmp)
objAmp.setWidth(intWidth)
imageAmp = isceobj.createAmpImage()
IU.copyAttributes(objAmp, imageAmp)
objAmp.setAccessMode('write')
objAmp.createImage()
objCrossmul = crossmul.createcrossmul()
objCrossmul.width = intWidth
objCrossmul.length = lines
objCrossmul.LooksDown = azLooks
objCrossmul.LooksAcross = rgLooks
#set the tag used in the outfile. each message is precided by this tag
#is the writer is not of "file" type the call has no effect
# objCrossmul.stdWriter = stdWriter.set_file_tags("resamp",
# "log",
# "err",
# "out")
objCrossmul.crossmul(objSlc1, objSlc2, objInt, objAmp)
if catalog is not None:
# Record the inputs and outputs
isceobj.Catalog.recordInputsAndOutputs(catalog, objCrossmul,
"runCrossmul.%s" % sceneid,
logger,
"runCrossmul.%s" % sceneid)
for obj in [objInt, objAmp, objSlc1, objSlc2]:
obj.finalizeImage()
return imageInt, imageAmp
def runIonSubband(self):
'''create subband interferograms
'''
if hasattr(self, 'doInSAR'):
if not self.doInSAR:
return
catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name)
self.updateParamemetersFromUser()
if not self.doIon:
catalog.printToLog(logger, "runIonSubband")
self._insar.procDoc.addAllFromCatalog(catalog)
return
referenceTrack = self._insar.loadTrack(reference=True)
secondaryTrack = self._insar.loadTrack(reference=False)
#using 1/3, 1/3, 1/3 band split
radarWavelength = referenceTrack.radarWavelength
rangeBandwidth = referenceTrack.frames[0].swaths[0].rangeBandwidth
rangeSamplingRate = referenceTrack.frames[0].swaths[0].rangeSamplingRate
radarWavelengthLower = SPEED_OF_LIGHT / (SPEED_OF_LIGHT / radarWavelength -
rangeBandwidth / 3.0)
radarWavelengthUpper = SPEED_OF_LIGHT / (SPEED_OF_LIGHT / radarWavelength +
rangeBandwidth / 3.0)
subbandRadarWavelength = [radarWavelengthLower, radarWavelengthUpper]
subbandBandWidth = [
rangeBandwidth / 3.0 / rangeSamplingRate,
rangeBandwidth / 3.0 / rangeSamplingRate
]
subbandFrequencyCenter = [
-rangeBandwidth / 3.0 / rangeSamplingRate,
rangeBandwidth / 3.0 / rangeSamplingRate
]
subbandPrefix = ['lower', 'upper']
'''
ionDir = {
ionDir['swathMosaic'] : 'mosaic',
ionDir['insar'] : 'insar',
ionDir['ion'] : 'ion',
ionDir['subband'] : ['lower', 'upper'],
ionDir['ionCal'] : 'ion_cal'
}
'''
#define upper level directory names
ionDir = defineIonDir()
self._insar.subbandRadarWavelength = subbandRadarWavelength
############################################################
# STEP 1. create directories
############################################################
#create and enter 'ion' directory
#after finishing each step, we are in this directory
os.makedirs(ionDir['ion'], exist_ok=True)
os.chdir(ionDir['ion'])
#create insar processing directories
for k in range(2):
subbandDir = ionDir['subband'][k]
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
for j, swathNumber in enumerate(
range(self._insar.startingSwath,
self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
fullDir = os.path.join(subbandDir, frameDir, swathDir)
os.makedirs(fullDir, exist_ok=True)
#create ionospheric phase directory
os.makedirs(ionDir['ionCal'], exist_ok=True)
############################################################
# STEP 2. create subband interferograms
############################################################
import numpy as np
import stdproc
from iscesys.StdOEL.StdOELPy import create_writer
from isceobj.Alos2Proc.Alos2ProcPublic import readOffset
from contrib.alos2proc.alos2proc import rg_filter
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
for j, swathNumber in enumerate(
range(self._insar.startingSwath, self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
#skip this time consuming process, if interferogram already exists
if os.path.isfile(os.path.join(ionDir['subband'][0], frameDir, swathDir, self._insar.interferogram)) and \
os.path.isfile(os.path.join(ionDir['subband'][0], frameDir, swathDir, self._insar.interferogram+'.vrt')) and \
os.path.isfile(os.path.join(ionDir['subband'][0], frameDir, swathDir, self._insar.interferogram+'.xml')) and \
os.path.isfile(os.path.join(ionDir['subband'][0], frameDir, swathDir, self._insar.amplitude)) and \
os.path.isfile(os.path.join(ionDir['subband'][0], frameDir, swathDir, self._insar.amplitude+'.vrt')) and \
os.path.isfile(os.path.join(ionDir['subband'][0], frameDir, swathDir, self._insar.amplitude+'.xml')) and \
os.path.isfile(os.path.join(ionDir['subband'][1], frameDir, swathDir, self._insar.interferogram)) and \
os.path.isfile(os.path.join(ionDir['subband'][1], frameDir, swathDir, self._insar.interferogram+'.vrt')) and \
os.path.isfile(os.path.join(ionDir['subband'][1], frameDir, swathDir, self._insar.interferogram+'.xml')) and \
os.path.isfile(os.path.join(ionDir['subband'][1], frameDir, swathDir, self._insar.amplitude)) and \
os.path.isfile(os.path.join(ionDir['subband'][1], frameDir, swathDir, self._insar.amplitude+'.vrt')) and \
os.path.isfile(os.path.join(ionDir['subband'][1], frameDir, swathDir, self._insar.amplitude+'.xml')):
print('interferogram already exists at swath {}, frame {}'.
format(swathNumber, frameNumber))
continue
#filter reference and secondary images
for slcx in [self._insar.referenceSlc, self._insar.secondarySlc]:
slc = os.path.join('../', frameDir, swathDir, slcx)
slcLower = os.path.join(ionDir['subband'][0], frameDir,
swathDir, slcx)
slcUpper = os.path.join(ionDir['subband'][1], frameDir,
swathDir, slcx)
rg_filter(slc, 2, [slcLower, slcUpper], subbandBandWidth,
subbandFrequencyCenter, 257, 2048, 0.1, 0, 0.0)
#resample
for k in range(2):
os.chdir(os.path.join(ionDir['subband'][k], frameDir,
swathDir))
#recreate xml file to remove the file path
#can also use fixImageXml.py?
for x in [self._insar.referenceSlc, self._insar.secondarySlc]:
img = isceobj.createSlcImage()
img.load(x + '.xml')
img.setFilename(x)
img.extraFilename = x + '.vrt'
img.setAccessMode('READ')
img.renderHdr()
#############################################
#1. form interferogram
#############################################
referenceSwath = referenceTrack.frames[i].swaths[j]
secondarySwath = secondaryTrack.frames[i].swaths[j]
refinedOffsets = readOffset(
os.path.join('../../../../', frameDir, swathDir,
'cull.off'))
intWidth = int(referenceSwath.numberOfSamples /
self._insar.numberRangeLooks1)
intLength = int(referenceSwath.numberOfLines /
self._insar.numberAzimuthLooks1)
dopplerVsPixel = [
i / secondarySwath.prf
for i in secondarySwath.dopplerVsPixel
]
#reference slc
mSLC = isceobj.createSlcImage()
mSLC.load(self._insar.referenceSlc + '.xml')
mSLC.setAccessMode('read')
mSLC.createImage()
#secondary slc
sSLC = isceobj.createSlcImage()
sSLC.load(self._insar.secondarySlc + '.xml')
sSLC.setAccessMode('read')
sSLC.createImage()
#interferogram
interf = isceobj.createIntImage()
interf.setFilename(self._insar.interferogram)
interf.setWidth(intWidth)
interf.setAccessMode('write')
interf.createImage()
#amplitdue
amplitude = isceobj.createAmpImage()
amplitude.setFilename(self._insar.amplitude)
amplitude.setWidth(intWidth)
amplitude.setAccessMode('write')
amplitude.createImage()
#create a writer for resamp
stdWriter = create_writer("log",
"",
True,
filename="resamp.log")
stdWriter.setFileTag("resamp", "log")
stdWriter.setFileTag("resamp", "err")
stdWriter.setFileTag("resamp", "out")
#set up resampling program now
#The setting has been compared with resamp_roi's setting in ROI_pac item by item.
#The two kinds of setting are exactly the same. The number of setting items are
#exactly the same
objResamp = stdproc.createResamp()
objResamp.wireInputPort(name='offsets', object=refinedOffsets)
objResamp.stdWriter = stdWriter
objResamp.setNumberFitCoefficients(6)
objResamp.setNumberRangeBin1(referenceSwath.numberOfSamples)
objResamp.setNumberRangeBin2(secondarySwath.numberOfSamples)
objResamp.setStartLine(1)
objResamp.setNumberLines(referenceSwath.numberOfLines)
objResamp.setFirstLineOffset(1)
objResamp.setDopplerCentroidCoefficients(dopplerVsPixel)
objResamp.setRadarWavelength(subbandRadarWavelength[k])
objResamp.setSlantRangePixelSpacing(
secondarySwath.rangePixelSize)
objResamp.setNumberRangeLooks(self._insar.numberRangeLooks1)
objResamp.setNumberAzimuthLooks(
self._insar.numberAzimuthLooks1)
objResamp.setFlattenWithOffsetFitFlag(0)
objResamp.resamp(mSLC, sSLC, interf, amplitude)
#finialize images
mSLC.finalizeImage()
sSLC.finalizeImage()
interf.finalizeImage()
amplitude.finalizeImage()
stdWriter.finalize()
#############################################
#2. trim amplitude
#############################################
#using memmap instead, which should be faster, since we only have a few pixels to change
amp = np.memmap(self._insar.amplitude,
dtype='complex64',
mode='r+',
shape=(intLength, intWidth))
index = np.nonzero((np.real(amp) == 0) + (np.imag(amp) == 0))
amp[index] = 0
#Deletion flushes memory changes to disk before removing the object:
del amp
#############################################
#3. delete subband slcs
#############################################
os.remove(self._insar.referenceSlc)
os.remove(self._insar.referenceSlc + '.vrt')
os.remove(self._insar.referenceSlc + '.xml')
os.remove(self._insar.secondarySlc)
os.remove(self._insar.secondarySlc + '.vrt')
os.remove(self._insar.secondarySlc + '.xml')
os.chdir('../../../')
############################################################
# STEP 3. mosaic swaths
############################################################
from isceobj.Alos2Proc.runSwathMosaic import swathMosaic
from isceobj.Alos2Proc.Alos2ProcPublic import create_xml
for k in range(2):
os.chdir(ionDir['subband'][k])
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
os.chdir(frameDir)
mosaicDir = ionDir['swathMosaic']
os.makedirs(mosaicDir, exist_ok=True)
os.chdir(mosaicDir)
if not (
((self._insar.modeCombination == 21) or \
(self._insar.modeCombination == 22) or \
(self._insar.modeCombination == 31) or \
(self._insar.modeCombination == 32))
and
(self._insar.endingSwath-self._insar.startingSwath+1 > 1)
):
import shutil
swathDir = 's{}'.format(
referenceTrack.frames[i].swaths[0].swathNumber)
# if not os.path.isfile(self._insar.interferogram):
# os.symlink(os.path.join('../', swathDir, self._insar.interferogram), self._insar.interferogram)
# shutil.copy2(os.path.join('../', swathDir, self._insar.interferogram+'.vrt'), self._insar.interferogram+'.vrt')
# shutil.copy2(os.path.join('../', swathDir, self._insar.interferogram+'.xml'), self._insar.interferogram+'.xml')
# if not os.path.isfile(self._insar.amplitude):
# os.symlink(os.path.join('../', swathDir, self._insar.amplitude), self._insar.amplitude)
# shutil.copy2(os.path.join('../', swathDir, self._insar.amplitude+'.vrt'), self._insar.amplitude+'.vrt')
# shutil.copy2(os.path.join('../', swathDir, self._insar.amplitude+'.xml'), self._insar.amplitude+'.xml')
os.rename(
os.path.join('../', swathDir, self._insar.interferogram),
self._insar.interferogram)
os.rename(
os.path.join('../', swathDir,
self._insar.interferogram + '.vrt'),
self._insar.interferogram + '.vrt')
os.rename(
os.path.join('../', swathDir,
self._insar.interferogram + '.xml'),
self._insar.interferogram + '.xml')
os.rename(os.path.join('../', swathDir, self._insar.amplitude),
self._insar.amplitude)
os.rename(
os.path.join('../', swathDir,
self._insar.amplitude + '.vrt'),
self._insar.amplitude + '.vrt')
os.rename(
os.path.join('../', swathDir,
self._insar.amplitude + '.xml'),
self._insar.amplitude + '.xml')
#no need to update frame parameters here
os.chdir('../')
#no need to save parameter file here
os.chdir('../')
continue
#choose offsets
numberOfFrames = len(referenceTrack.frames)
numberOfSwaths = len(referenceTrack.frames[i].swaths)
if self.swathOffsetMatching:
#no need to do this as the API support 2-d list
#rangeOffsets = (np.array(self._insar.swathRangeOffsetMatchingReference)).reshape(numberOfFrames, numberOfSwaths)
#azimuthOffsets = (np.array(self._insar.swathAzimuthOffsetMatchingReference)).reshape(numberOfFrames, numberOfSwaths)
rangeOffsets = self._insar.swathRangeOffsetMatchingReference
azimuthOffsets = self._insar.swathAzimuthOffsetMatchingReference
else:
#rangeOffsets = (np.array(self._insar.swathRangeOffsetGeometricalReference)).reshape(numberOfFrames, numberOfSwaths)
#azimuthOffsets = (np.array(self._insar.swathAzimuthOffsetGeometricalReference)).reshape(numberOfFrames, numberOfSwaths)
rangeOffsets = self._insar.swathRangeOffsetGeometricalReference
azimuthOffsets = self._insar.swathAzimuthOffsetGeometricalReference
rangeOffsets = rangeOffsets[i]
azimuthOffsets = azimuthOffsets[i]
#list of input files
inputInterferograms = []
inputAmplitudes = []
#phaseDiff = [None]
swathPhaseDiffIon = [
self.swathPhaseDiffLowerIon, self.swathPhaseDiffUpperIon
]
phaseDiff = swathPhaseDiffIon[k]
if swathPhaseDiffIon[k] is None:
phaseDiff = None
else:
phaseDiff = swathPhaseDiffIon[k][i]
phaseDiff.insert(0, None)
for j, swathNumber in enumerate(
range(self._insar.startingSwath,
self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
inputInterferograms.append(
os.path.join('../', swathDir, self._insar.interferogram))
inputAmplitudes.append(
os.path.join('../', swathDir, self._insar.amplitude))
if False:
#compute phase needed to be compensated using startingRange
if j >= 1:
#phaseDiffSwath1 = -4.0 * np.pi * (referenceTrack.frames[i].swaths[j-1].startingRange - secondaryTrack.frames[i].swaths[j-1].startingRange)/subbandRadarWavelength[k]
#phaseDiffSwath2 = -4.0 * np.pi * (referenceTrack.frames[i].swaths[j].startingRange - secondaryTrack.frames[i].swaths[j].startingRange)/subbandRadarWavelength[k]
phaseDiffSwath1 = +4.0 * np.pi * referenceTrack.frames[i].swaths[j-1].startingRange * (1.0/radarWavelength - 1.0/subbandRadarWavelength[k]) \
-4.0 * np.pi * secondaryTrack.frames[i].swaths[j-1].startingRange * (1.0/radarWavelength - 1.0/subbandRadarWavelength[k])
phaseDiffSwath2 = +4.0 * np.pi * referenceTrack.frames[i].swaths[j].startingRange * (1.0/radarWavelength - 1.0/subbandRadarWavelength[k]) \
-4.0 * np.pi * secondaryTrack.frames[i].swaths[j].startingRange * (1.0/radarWavelength - 1.0/subbandRadarWavelength[k])
if referenceTrack.frames[i].swaths[j-1].startingRange - secondaryTrack.frames[i].swaths[j-1].startingRange == \
referenceTrack.frames[i].swaths[j].startingRange - secondaryTrack.frames[i].swaths[j].startingRange:
#phaseDiff.append(phaseDiffSwath2 - phaseDiffSwath1)
#if reference and secondary versions are all before or after version 2.025 (starting range error < 0.5 m),
#it should be OK to do the above.
#see results in neom where it meets the above requirement, but there is still phase diff
#to be less risky, we do not input values here
phaseDiff.append(None)
else:
phaseDiff.append(None)
#note that frame parameters are updated after mosaicking, here no need to update parameters
#mosaic amplitudes
swathMosaic(referenceTrack.frames[i],
inputAmplitudes,
self._insar.amplitude,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
resamplingMethod=0)
#mosaic interferograms
#These are for ALOS-2, may need to change for ALOS-4!
phaseDiffFixed = [
0.0, 0.4754024578084084, 0.9509913179406437,
1.4261648478671614, 2.179664007520499, 2.6766909968024932,
3.130810857
]
if False:
if (referenceTrack.frames[i].processingSoftwareVersion == '2.025' and secondaryTrack.frames[i].processingSoftwareVersion == '2.023') or \
(referenceTrack.frames[i].processingSoftwareVersion == '2.023' and secondaryTrack.frames[i].processingSoftwareVersion == '2.025'):
# changed value number of samples to estimate new value new values estimate area
###########################################################################################################################
# 2.6766909968024932-->2.6581660335779866 1808694 d169-f2850, north CA
# 2.179664007520499 -->2.204125866652153 131120 d169-f2850, north CA
phaseDiffFixed = [
0.0, 0.4754024578084084, 0.9509913179406437,
1.4261648478671614, 2.204125866652153,
2.6581660335779866, 3.130810857
]
snapThreshold = 0.2
#the above preparetions only applies to 'self._insar.modeCombination == 21'
#looks like it also works for 31 (scansarNominalModes-stripmapModes)
if self._insar.modeCombination != 21:
phaseDiff = None
phaseDiffFixed = None
snapThreshold = None
#whether snap for each swath
if self.swathPhaseDiffSnapIon == None:
snapSwath = [[True for jjj in range(numberOfSwaths - 1)]
for iii in range(numberOfFrames)]
else:
snapSwath = self.swathPhaseDiffSnapIon
if len(snapSwath) != numberOfFrames:
raise Exception(
'please specify each frame for parameter: swath phase difference snap to fixed values'
)
for iii in range(numberOfFrames):
if len(snapSwath[iii]) != (numberOfSwaths - 1):
raise Exception(
'please specify correct number of swaths for parameter: swath phase difference snap to fixed values'
)
(phaseDiffEst, phaseDiffUsed, phaseDiffSource,
numberOfValidSamples) = swathMosaic(
referenceTrack.frames[i],
inputInterferograms,
self._insar.interferogram,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateFrame=False,
phaseCompensation=True,
phaseDiff=phaseDiff,
phaseDiffFixed=phaseDiffFixed,
snapThreshold=snapThreshold,
snapSwath=snapSwath[i],
pcRangeLooks=1,
pcAzimuthLooks=4,
filt=False,
resamplingMethod=1)
#the first item is meaningless for all the following list, so only record the following items
if phaseDiff == None:
phaseDiff = [
None for iii in range(self._insar.startingSwath,
self._insar.endingSwath + 1)
]
catalog.addItem(
'frame {} {} band swath phase diff input'.format(
frameNumber, ionDir['subband'][k]), phaseDiff[1:],
'runIonSubband')
catalog.addItem(
'frame {} {} band swath phase diff estimated'.format(
frameNumber, ionDir['subband'][k]), phaseDiffEst[1:],
'runIonSubband')
catalog.addItem(
'frame {} {} band swath phase diff used'.format(
frameNumber, ionDir['subband'][k]), phaseDiffUsed[1:],
'runIonSubband')
catalog.addItem(
'frame {} {} band swath phase diff used source'.format(
frameNumber, ionDir['subband'][k]), phaseDiffSource[1:],
'runIonSubband')
catalog.addItem(
'frame {} {} band swath phase diff samples used'.format(
frameNumber, ionDir['subband'][k]),
numberOfValidSamples[1:], 'runIonSubband')
#check if there is value around 3.130810857, which may not be stable
phaseDiffUnstableExist = False
for xxx in phaseDiffUsed:
if abs(abs(xxx) - 3.130810857) < 0.2:
phaseDiffUnstableExist = True
catalog.addItem(
'frame {} {} band swath phase diff unstable exists'.format(
frameNumber, ionDir['subband'][k]), phaseDiffUnstableExist,
'runIonSubband')
create_xml(self._insar.amplitude,
referenceTrack.frames[i].numberOfSamples,
referenceTrack.frames[i].numberOfLines, 'amp')
create_xml(self._insar.interferogram,
referenceTrack.frames[i].numberOfSamples,
referenceTrack.frames[i].numberOfLines, 'int')
#update secondary frame parameters here, here no need to update parameters
os.chdir('../')
#save parameter file, here no need to save parameter file
os.chdir('../')
os.chdir('../')
############################################################
# STEP 4. mosaic frames
############################################################
from isceobj.Alos2Proc.runFrameMosaic import frameMosaic
from isceobj.Alos2Proc.Alos2ProcPublic import create_xml
for k in range(2):
os.chdir(ionDir['subband'][k])
mosaicDir = ionDir['insar']
os.makedirs(mosaicDir, exist_ok=True)
os.chdir(mosaicDir)
numberOfFrames = len(referenceTrack.frames)
if numberOfFrames == 1:
import shutil
frameDir = os.path.join('f1_{}/mosaic'.format(
self._insar.referenceFrames[0]))
# if not os.path.isfile(self._insar.interferogram):
# os.symlink(os.path.join('../', frameDir, self._insar.interferogram), self._insar.interferogram)
# #shutil.copy2() can overwrite
# shutil.copy2(os.path.join('../', frameDir, self._insar.interferogram+'.vrt'), self._insar.interferogram+'.vrt')
# shutil.copy2(os.path.join('../', frameDir, self._insar.interferogram+'.xml'), self._insar.interferogram+'.xml')
# if not os.path.isfile(self._insar.amplitude):
# os.symlink(os.path.join('../', frameDir, self._insar.amplitude), self._insar.amplitude)
# shutil.copy2(os.path.join('../', frameDir, self._insar.amplitude+'.vrt'), self._insar.amplitude+'.vrt')
# shutil.copy2(os.path.join('../', frameDir, self._insar.amplitude+'.xml'), self._insar.amplitude+'.xml')
os.rename(os.path.join('../', frameDir, self._insar.interferogram),
self._insar.interferogram)
os.rename(
os.path.join('../', frameDir,
self._insar.interferogram + '.vrt'),
self._insar.interferogram + '.vrt')
os.rename(
os.path.join('../', frameDir,
self._insar.interferogram + '.xml'),
self._insar.interferogram + '.xml')
os.rename(os.path.join('../', frameDir, self._insar.amplitude),
self._insar.amplitude)
os.rename(
os.path.join('../', frameDir, self._insar.amplitude + '.vrt'),
self._insar.amplitude + '.vrt')
os.rename(
os.path.join('../', frameDir, self._insar.amplitude + '.xml'),
self._insar.amplitude + '.xml')
#update track parameters, no need to update track parameters here
else:
#choose offsets
if self.frameOffsetMatching:
rangeOffsets = self._insar.frameRangeOffsetMatchingReference
azimuthOffsets = self._insar.frameAzimuthOffsetMatchingReference
else:
rangeOffsets = self._insar.frameRangeOffsetGeometricalReference
azimuthOffsets = self._insar.frameAzimuthOffsetGeometricalReference
#list of input files
inputInterferograms = []
inputAmplitudes = []
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
inputInterferograms.append(
os.path.join('../', frameDir, 'mosaic',
self._insar.interferogram))
inputAmplitudes.append(
os.path.join('../', frameDir, 'mosaic',
self._insar.amplitude))
#note that track parameters are updated after mosaicking
#mosaic amplitudes
frameMosaic(referenceTrack,
inputAmplitudes,
self._insar.amplitude,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateTrack=False,
phaseCompensation=False,
resamplingMethod=0)
#mosaic interferograms
(phaseDiffEst, phaseDiffUsed, phaseDiffSource,
numberOfValidSamples) = frameMosaic(
referenceTrack,
inputInterferograms,
self._insar.interferogram,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateTrack=False,
phaseCompensation=True,
resamplingMethod=1)
create_xml(self._insar.amplitude, referenceTrack.numberOfSamples,
referenceTrack.numberOfLines, 'amp')
create_xml(self._insar.interferogram,
referenceTrack.numberOfSamples,
referenceTrack.numberOfLines, 'int')
catalog.addItem(
'{} band frame phase diff estimated'.format(
ionDir['subband'][k]), phaseDiffEst[1:], 'runIonSubband')
catalog.addItem(
'{} band frame phase diff used'.format(ionDir['subband'][k]),
phaseDiffUsed[1:], 'runIonSubband')
catalog.addItem(
'{} band frame phase diff used source'.format(
ionDir['subband'][k]), phaseDiffSource[1:],
'runIonSubband')
catalog.addItem(
'{} band frame phase diff samples used'.format(
ionDir['subband'][k]), numberOfValidSamples[1:],
'runIonSubband')
#update secondary parameters here, no need to update secondary parameters here
os.chdir('../')
#save parameter file, no need to save parameter file here
os.chdir('../')
############################################################
# STEP 5. clear frame processing files
############################################################
import shutil
from isceobj.Alos2Proc.Alos2ProcPublic import runCmd
for k in range(2):
os.chdir(ionDir['subband'][k])
for i, frameNumber in enumerate(self._insar.referenceFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
#keep subswath interferograms
#shutil.rmtree(frameDir)
#cmd = 'rm -rf {}'.format(frameDir)
#runCmd(cmd)
os.chdir('../')
############################################################
# STEP 6. create differential interferograms
############################################################
import numpy as np
from isceobj.Alos2Proc.Alos2ProcPublic import runCmd
for k in range(2):
os.chdir(ionDir['subband'][k])
insarDir = ionDir['insar']
os.makedirs(insarDir, exist_ok=True)
os.chdir(insarDir)
rangePixelSize = self._insar.numberRangeLooks1 * referenceTrack.rangePixelSize
radarWavelength = subbandRadarWavelength[k]
rectRangeOffset = os.path.join('../../../', insarDir,
self._insar.rectRangeOffset)
cmd = "imageMath.py -e='a*exp(-1.0*J*b*4.0*{}*{}/{}) * (b!=0)' --a={} --b={} -o {} -t cfloat".format(
np.pi, rangePixelSize, radarWavelength, self._insar.interferogram,
rectRangeOffset, self._insar.differentialInterferogram)
runCmd(cmd)
os.chdir('../../')
os.chdir('../')
catalog.printToLog(logger, "runIonSubband")
self._insar.procDoc.addAllFromCatalog(catalog)
def runResamp_only(self):
imageInt = self._insar.getResampIntImage()
imageAmp = self._insar.getResampAmpImage()
objInt = isceobj.createIntImage()
objIntOut = isceobj.createIntImage()
IU.copyAttributes(imageInt, objInt)
IU.copyAttributes(imageInt, objIntOut)
outIntFilename = self._insar.getResampOnlyImageName()
objInt.setAccessMode('read')
objIntOut.setFilename(outIntFilename)
self._insar.setResampOnlyImage(objIntOut)
objIntOut.setAccessMode('write')
objInt.createImage()
objIntOut.createImage()
objAmp = isceobj.createAmpImage()
objAmpOut = isceobj.createAmpImage()
IU.copyAttributes(imageAmp, objAmp)
IU.copyAttributes(imageAmp, objAmpOut)
outAmpFilename = self.insar.resampOnlyAmpName
objAmp.setAccessMode('read')
objAmpOut.setFilename(outAmpFilename)
self._insar.setResampOnlyAmp(objAmpOut)
objAmpOut.setAccessMode('write')
objAmp.createImage()
objAmpOut.createImage()
numRangeBin = objInt.getWidth()
lines = objInt.getLength()
instrument = self._insar.getMasterFrame().getInstrument()
offsetField = self._insar.getRefinedOffsetField()
dopplerCoeff = self._insar.getDopplerCentroid().getDopplerCoefficients(
inHz=False)
numFitCoeff = self._insar.getNumberFitCoefficients()
pixelSpacing = self._insar.getSlantRangePixelSpacing()
objResamp = stdproc.createResamp_only()
objResamp.setNumberLines(lines)
objResamp.setNumberFitCoefficients(numFitCoeff)
objResamp.setSlantRangePixelSpacing(pixelSpacing)
objResamp.setNumberRangeBin(numRangeBin)
objResamp.setDopplerCentroidCoefficients(dopplerCoeff)
objResamp.wireInputPort(name='offsets', object=offsetField)
objResamp.wireInputPort(name='instrument', object=instrument)
#set the tag used in the outfile. each message is precided by this tag
#is the writer is not of "file" type the call has no effect
self._stdWriter.setFileTag("resamp_only", "log")
self._stdWriter.setFileTag("resamp_only", "err")
self._stdWriter.setFileTag("resamp_only", "out")
objResamp.setStdWriter(self._stdWriter)
objResamp.resamp_only(objInt, objIntOut, objAmp, objAmpOut)
# Record the inputs and outputs
from isceobj.Catalog import recordInputsAndOutputs
recordInputsAndOutputs(self._insar.procDoc, objResamp, "runResamp_only", \
logger, "runResamp_only")
objInt.finalizeImage()
objIntOut.finalizeImage()
objAmp.finalizeImage()
objAmpOut.finalizeImage()
objSlc1.createImage()
wid = objSlc1.getWidth()
lgth = objSlc1.getLength()
objSlc2 = isceobj.createSlcImage()
objSlc2.initImage(iObj.topophaseMphFilename, 'read', wid)
objSlc2.createImage()
objInt = isceobj.createIntImage()
objInt.setFilename('test.int')
objInt.setWidth(wid / rlooks)
objInt.setAccessMode('write')
objInt.createImage()
objAmp = isceobj.createAmpImage()
objAmp.setFilename('test.amp')
objAmp.setWidth(wid / rlooks)
objAmp.setAccessMode('write')
objAmp.createImage()
mul = Crossmul()
mul.width = wid
mul.length = lgth
mul.LooksAcross = rlooks
mul.LooksDown = alooks
mul.scale = 1.0
mul.blocksize = 100
mul.crossmul(objSlc1, objSlc2, objInt, objAmp)
def generateIgram(slcFile1, slcFile2, ifgFile, azLooks, rgLooks, compute_cor=True):
imageSlc1 = isceobj.createImage()
f1 = slcFile1 + ".xml" if not slcFile1.endswith(".xml") else slcFile1
print(f"Loading {f1}")
imageSlc1.load(f1)
imageSlc2 = isceobj.createImage()
f2 = slcFile2 + ".xml" if not slcFile2.endswith(".xml") else slcFile2
print(f"Loading {f2}")
imageSlc2.load(f2)
objSlc1 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc1, objSlc1)
objSlc1.setAccessMode("read")
objSlc1.createImage()
objSlc2 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc2, objSlc2)
objSlc2.setAccessMode("read")
objSlc2.createImage()
slcWidth = imageSlc1.getWidth()
intWidth = slcWidth // rgLooks
lines = min(imageSlc1.getLength(), imageSlc2.getLength())
if ".flat" in ifgFile:
resampAmp = ifgFile.replace(".flat", ".amp")
elif ".int" in ifgFile:
resampAmp = ifgFile.replace(".int", ".amp")
else:
resampAmp = ifgFile + ".amp"
resampInt = ifgFile
objInt = isceobj.createIntImage()
objInt.setFilename(resampInt)
objInt.setWidth(intWidth)
imageInt = isceobj.createIntImage()
IU.copyAttributes(objInt, imageInt)
objInt.setAccessMode("write")
objInt.createImage()
objAmp = isceobj.createAmpImage()
objAmp.setFilename(resampAmp)
objAmp.setWidth(intWidth)
imageAmp = isceobj.createAmpImage()
IU.copyAttributes(objAmp, imageAmp)
objAmp.setAccessMode("write")
objAmp.createImage()
objCrossmul = crossmul.createcrossmul()
objCrossmul.width = slcWidth
objCrossmul.length = lines
objCrossmul.LooksDown = azLooks
objCrossmul.LooksAcross = rgLooks
objCrossmul.crossmul(objSlc1, objSlc2, objInt, objAmp)
for obj in [objInt, objAmp, objSlc1, objSlc2]:
obj.finalizeImage()
if compute_cor:
# Compute the multilooked version of correlation (much quicker than isce's full size)
with rio.open(resampInt) as src:
ifg = src.read(1)
with rio.open(resampAmp) as src:
amp1, amp2 = src.read()
cor_filename = resampAmp.replace(".amp", ".cor")
# Make the isce headers
create_cor_image(cor_filename, ifg.shape, access_mode="write")
# calulate and save (not sure how to just save an array in isce)
cor = np.abs(ifg) / np.sqrt(amp1 ** 2 * amp2 ** 2)
sario.save(cor_filename, np.stack((amp1 * amp2, cor)))
return imageInt, imageAmp
def runIonSubband(self):
'''create subband interferograms
'''
catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name)
self.updateParamemetersFromUser()
if not self.doIon:
catalog.printToLog(logger, "runIonSubband")
self._insar.procDoc.addAllFromCatalog(catalog)
return
masterTrack = self._insar.loadTrack(master=True)
slaveTrack = self._insar.loadTrack(master=False)
#using 1/3, 1/3, 1/3 band split
radarWavelength = masterTrack.radarWavelength
rangeBandwidth = masterTrack.frames[0].swaths[0].rangeBandwidth
rangeSamplingRate = masterTrack.frames[0].swaths[0].rangeSamplingRate
radarWavelengthLower = SPEED_OF_LIGHT / (SPEED_OF_LIGHT / radarWavelength -
rangeBandwidth / 3.0)
radarWavelengthUpper = SPEED_OF_LIGHT / (SPEED_OF_LIGHT / radarWavelength +
rangeBandwidth / 3.0)
subbandRadarWavelength = [radarWavelengthLower, radarWavelengthUpper]
subbandBandWidth = [
rangeBandwidth / 3.0 / rangeSamplingRate,
rangeBandwidth / 3.0 / rangeSamplingRate
]
subbandFrequencyCenter = [
-rangeBandwidth / 3.0 / rangeSamplingRate,
rangeBandwidth / 3.0 / rangeSamplingRate
]
subbandPrefix = ['lower', 'upper']
'''
ionDir = {
ionDir['swathMosaic'] : 'mosaic',
ionDir['insar'] : 'insar',
ionDir['ion'] : 'ion',
ionDir['subband'] : ['lower', 'upper'],
ionDir['ionCal'] : 'ion_cal'
}
'''
#define upper level directory names
ionDir = defineIonDir()
self._insar.subbandRadarWavelength = subbandRadarWavelength
############################################################
# STEP 1. create directories
############################################################
#create and enter 'ion' directory
#after finishing each step, we are in this directory
if not os.path.exists(ionDir['ion']):
os.makedirs(ionDir['ion'])
os.chdir(ionDir['ion'])
#create insar processing directories
for k in range(2):
subbandDir = ionDir['subband'][k]
for i, frameNumber in enumerate(self._insar.masterFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
for j, swathNumber in enumerate(
range(self._insar.startingSwath,
self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
fullDir = os.path.join(subbandDir, frameDir, swathDir)
if not os.path.exists(fullDir):
os.makedirs(fullDir)
#create ionospheric phase directory
if not os.path.exists(ionDir['ionCal']):
os.makedirs(ionDir['ionCal'])
############################################################
# STEP 2. create subband interferograms
############################################################
import numpy as np
import stdproc
from iscesys.StdOEL.StdOELPy import create_writer
from isceobj.Alos2Proc.Alos2ProcPublic import readOffset
from contrib.alos2proc.alos2proc import rg_filter
for i, frameNumber in enumerate(self._insar.masterFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
for j, swathNumber in enumerate(
range(self._insar.startingSwath, self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
#filter master and slave images
for slcx in [self._insar.masterSlc, self._insar.slaveSlc]:
slc = os.path.join('../', frameDir, swathDir, slcx)
slcLower = os.path.join(ionDir['subband'][0], frameDir,
swathDir, slcx)
slcUpper = os.path.join(ionDir['subband'][1], frameDir,
swathDir, slcx)
rg_filter(slc, 2, [slcLower, slcUpper], subbandBandWidth,
subbandFrequencyCenter, 257, 2048, 0.1, 0, 0.0)
#resample
for k in range(2):
os.chdir(os.path.join(ionDir['subband'][k], frameDir,
swathDir))
#recreate xml file to remove the file path
#can also use fixImageXml.py?
for x in [self._insar.masterSlc, self._insar.slaveSlc]:
img = isceobj.createSlcImage()
img.load(x + '.xml')
img.setFilename(x)
img.extraFilename = x + '.vrt'
img.setAccessMode('READ')
img.renderHdr()
#############################################
#1. form interferogram
#############################################
masterSwath = masterTrack.frames[i].swaths[j]
slaveSwath = slaveTrack.frames[i].swaths[j]
refinedOffsets = readOffset(
os.path.join('../../../../', frameDir, swathDir,
'cull.off'))
intWidth = int(masterSwath.numberOfSamples /
self._insar.numberRangeLooks1)
intLength = int(masterSwath.numberOfLines /
self._insar.numberAzimuthLooks1)
dopplerVsPixel = [
i / slaveSwath.prf for i in slaveSwath.dopplerVsPixel
]
#master slc
mSLC = isceobj.createSlcImage()
mSLC.load(self._insar.masterSlc + '.xml')
mSLC.setAccessMode('read')
mSLC.createImage()
#slave slc
sSLC = isceobj.createSlcImage()
sSLC.load(self._insar.slaveSlc + '.xml')
sSLC.setAccessMode('read')
sSLC.createImage()
#interferogram
interf = isceobj.createIntImage()
interf.setFilename(self._insar.interferogram)
interf.setWidth(intWidth)
interf.setAccessMode('write')
interf.createImage()
#amplitdue
amplitude = isceobj.createAmpImage()
amplitude.setFilename(self._insar.amplitude)
amplitude.setWidth(intWidth)
amplitude.setAccessMode('write')
amplitude.createImage()
#create a writer for resamp
stdWriter = create_writer("log",
"",
True,
filename="resamp.log")
stdWriter.setFileTag("resamp", "log")
stdWriter.setFileTag("resamp", "err")
stdWriter.setFileTag("resamp", "out")
#set up resampling program now
#The setting has been compared with resamp_roi's setting in ROI_pac item by item.
#The two kinds of setting are exactly the same. The number of setting items are
#exactly the same
objResamp = stdproc.createResamp()
objResamp.wireInputPort(name='offsets', object=refinedOffsets)
objResamp.stdWriter = stdWriter
objResamp.setNumberFitCoefficients(6)
objResamp.setNumberRangeBin1(masterSwath.numberOfSamples)
objResamp.setNumberRangeBin2(slaveSwath.numberOfSamples)
objResamp.setStartLine(1)
objResamp.setNumberLines(masterSwath.numberOfLines)
objResamp.setFirstLineOffset(1)
objResamp.setDopplerCentroidCoefficients(dopplerVsPixel)
objResamp.setRadarWavelength(subbandRadarWavelength[k])
objResamp.setSlantRangePixelSpacing(slaveSwath.rangePixelSize)
objResamp.setNumberRangeLooks(self._insar.numberRangeLooks1)
objResamp.setNumberAzimuthLooks(
self._insar.numberAzimuthLooks1)
objResamp.setFlattenWithOffsetFitFlag(0)
objResamp.resamp(mSLC, sSLC, interf, amplitude)
#finialize images
mSLC.finalizeImage()
sSLC.finalizeImage()
interf.finalizeImage()
amplitude.finalizeImage()
stdWriter.finalize()
#############################################
#2. trim amplitude
#############################################
#using memmap instead, which should be faster, since we only have a few pixels to change
amp = np.memmap(self._insar.amplitude,
dtype='complex64',
mode='r+',
shape=(intLength, intWidth))
index = np.nonzero((np.real(amp) == 0) + (np.imag(amp) == 0))
amp[index] = 0
#Deletion flushes memory changes to disk before removing the object:
del amp
#############################################
#3. delete subband slcs
#############################################
os.remove(self._insar.masterSlc)
os.remove(self._insar.masterSlc + '.vrt')
os.remove(self._insar.masterSlc + '.xml')
os.remove(self._insar.slaveSlc)
os.remove(self._insar.slaveSlc + '.vrt')
os.remove(self._insar.slaveSlc + '.xml')
os.chdir('../../../')
############################################################
# STEP 3. mosaic swaths
############################################################
from isceobj.Alos2Proc.runSwathMosaic import swathMosaic
from isceobj.Alos2Proc.Alos2ProcPublic import create_xml
for k in range(2):
os.chdir(ionDir['subband'][k])
for i, frameNumber in enumerate(self._insar.masterFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
os.chdir(frameDir)
mosaicDir = ionDir['swathMosaic']
if not os.path.exists(mosaicDir):
os.makedirs(mosaicDir)
os.chdir(mosaicDir)
if not (
((self._insar.modeCombination == 21) or \
(self._insar.modeCombination == 22) or \
(self._insar.modeCombination == 31) or \
(self._insar.modeCombination == 32))
and
(self._insar.endingSwath-self._insar.startingSwath+1 > 1)
):
import shutil
swathDir = 's{}'.format(
masterTrack.frames[i].swaths[0].swathNumber)
# if not os.path.isfile(self._insar.interferogram):
# os.symlink(os.path.join('../', swathDir, self._insar.interferogram), self._insar.interferogram)
# shutil.copy2(os.path.join('../', swathDir, self._insar.interferogram+'.vrt'), self._insar.interferogram+'.vrt')
# shutil.copy2(os.path.join('../', swathDir, self._insar.interferogram+'.xml'), self._insar.interferogram+'.xml')
# if not os.path.isfile(self._insar.amplitude):
# os.symlink(os.path.join('../', swathDir, self._insar.amplitude), self._insar.amplitude)
# shutil.copy2(os.path.join('../', swathDir, self._insar.amplitude+'.vrt'), self._insar.amplitude+'.vrt')
# shutil.copy2(os.path.join('../', swathDir, self._insar.amplitude+'.xml'), self._insar.amplitude+'.xml')
os.rename(
os.path.join('../', swathDir, self._insar.interferogram),
self._insar.interferogram)
os.rename(
os.path.join('../', swathDir,
self._insar.interferogram + '.vrt'),
self._insar.interferogram + '.vrt')
os.rename(
os.path.join('../', swathDir,
self._insar.interferogram + '.xml'),
self._insar.interferogram + '.xml')
os.rename(os.path.join('../', swathDir, self._insar.amplitude),
self._insar.amplitude)
os.rename(
os.path.join('../', swathDir,
self._insar.amplitude + '.vrt'),
self._insar.amplitude + '.vrt')
os.rename(
os.path.join('../', swathDir,
self._insar.amplitude + '.xml'),
self._insar.amplitude + '.xml')
#no need to update frame parameters here
os.chdir('../')
#no need to save parameter file here
os.chdir('../')
continue
#choose offsets
numberOfFrames = len(masterTrack.frames)
numberOfSwaths = len(masterTrack.frames[i].swaths)
if self.swathOffsetMatching:
#no need to do this as the API support 2-d list
#rangeOffsets = (np.array(self._insar.swathRangeOffsetMatchingMaster)).reshape(numberOfFrames, numberOfSwaths)
#azimuthOffsets = (np.array(self._insar.swathAzimuthOffsetMatchingMaster)).reshape(numberOfFrames, numberOfSwaths)
rangeOffsets = self._insar.swathRangeOffsetMatchingMaster
azimuthOffsets = self._insar.swathAzimuthOffsetMatchingMaster
else:
#rangeOffsets = (np.array(self._insar.swathRangeOffsetGeometricalMaster)).reshape(numberOfFrames, numberOfSwaths)
#azimuthOffsets = (np.array(self._insar.swathAzimuthOffsetGeometricalMaster)).reshape(numberOfFrames, numberOfSwaths)
rangeOffsets = self._insar.swathRangeOffsetGeometricalMaster
azimuthOffsets = self._insar.swathAzimuthOffsetGeometricalMaster
rangeOffsets = rangeOffsets[i]
azimuthOffsets = azimuthOffsets[i]
#list of input files
inputInterferograms = []
inputAmplitudes = []
for j, swathNumber in enumerate(
range(self._insar.startingSwath,
self._insar.endingSwath + 1)):
swathDir = 's{}'.format(swathNumber)
inputInterferograms.append(
os.path.join('../', swathDir, self._insar.interferogram))
inputAmplitudes.append(
os.path.join('../', swathDir, self._insar.amplitude))
#note that frame parameters are updated after mosaicking, here no need to update parameters
#mosaic amplitudes
swathMosaic(masterTrack.frames[i],
inputAmplitudes,
self._insar.amplitude,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
resamplingMethod=0)
#mosaic interferograms
swathMosaic(masterTrack.frames[i],
inputInterferograms,
self._insar.interferogram,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateFrame=False,
phaseCompensation=True,
resamplingMethod=1)
create_xml(self._insar.amplitude,
masterTrack.frames[i].numberOfSamples,
masterTrack.frames[i].numberOfLines, 'amp')
create_xml(self._insar.interferogram,
masterTrack.frames[i].numberOfSamples,
masterTrack.frames[i].numberOfLines, 'int')
#update slave frame parameters here, here no need to update parameters
os.chdir('../')
#save parameter file, here no need to save parameter file
os.chdir('../')
os.chdir('../')
############################################################
# STEP 4. mosaic frames
############################################################
from isceobj.Alos2Proc.runFrameMosaic import frameMosaic
from isceobj.Alos2Proc.Alos2ProcPublic import create_xml
for k in range(2):
os.chdir(ionDir['subband'][k])
mosaicDir = ionDir['insar']
if not os.path.exists(mosaicDir):
os.makedirs(mosaicDir)
os.chdir(mosaicDir)
numberOfFrames = len(masterTrack.frames)
if numberOfFrames == 1:
import shutil
frameDir = os.path.join('f1_{}/mosaic'.format(
self._insar.masterFrames[0]))
# if not os.path.isfile(self._insar.interferogram):
# os.symlink(os.path.join('../', frameDir, self._insar.interferogram), self._insar.interferogram)
# #shutil.copy2() can overwrite
# shutil.copy2(os.path.join('../', frameDir, self._insar.interferogram+'.vrt'), self._insar.interferogram+'.vrt')
# shutil.copy2(os.path.join('../', frameDir, self._insar.interferogram+'.xml'), self._insar.interferogram+'.xml')
# if not os.path.isfile(self._insar.amplitude):
# os.symlink(os.path.join('../', frameDir, self._insar.amplitude), self._insar.amplitude)
# shutil.copy2(os.path.join('../', frameDir, self._insar.amplitude+'.vrt'), self._insar.amplitude+'.vrt')
# shutil.copy2(os.path.join('../', frameDir, self._insar.amplitude+'.xml'), self._insar.amplitude+'.xml')
os.rename(os.path.join('../', frameDir, self._insar.interferogram),
self._insar.interferogram)
os.rename(
os.path.join('../', frameDir,
self._insar.interferogram + '.vrt'),
self._insar.interferogram + '.vrt')
os.rename(
os.path.join('../', frameDir,
self._insar.interferogram + '.xml'),
self._insar.interferogram + '.xml')
os.rename(os.path.join('../', frameDir, self._insar.amplitude),
self._insar.amplitude)
os.rename(
os.path.join('../', frameDir, self._insar.amplitude + '.vrt'),
self._insar.amplitude + '.vrt')
os.rename(
os.path.join('../', frameDir, self._insar.amplitude + '.xml'),
self._insar.amplitude + '.xml')
#update track parameters, no need to update track parameters here
else:
#choose offsets
if self.frameOffsetMatching:
rangeOffsets = self._insar.frameRangeOffsetMatchingMaster
azimuthOffsets = self._insar.frameAzimuthOffsetMatchingMaster
else:
rangeOffsets = self._insar.frameRangeOffsetGeometricalMaster
azimuthOffsets = self._insar.frameAzimuthOffsetGeometricalMaster
#list of input files
inputInterferograms = []
inputAmplitudes = []
for i, frameNumber in enumerate(self._insar.masterFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
inputInterferograms.append(
os.path.join('../', frameDir, 'mosaic',
self._insar.interferogram))
inputAmplitudes.append(
os.path.join('../', frameDir, 'mosaic',
self._insar.amplitude))
#note that track parameters are updated after mosaicking
#mosaic amplitudes
frameMosaic(masterTrack,
inputAmplitudes,
self._insar.amplitude,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateTrack=False,
phaseCompensation=False,
resamplingMethod=0)
#mosaic interferograms
frameMosaic(masterTrack,
inputInterferograms,
self._insar.interferogram,
rangeOffsets,
azimuthOffsets,
self._insar.numberRangeLooks1,
self._insar.numberAzimuthLooks1,
updateTrack=False,
phaseCompensation=True,
resamplingMethod=1)
create_xml(self._insar.amplitude, masterTrack.numberOfSamples,
masterTrack.numberOfLines, 'amp')
create_xml(self._insar.interferogram, masterTrack.numberOfSamples,
masterTrack.numberOfLines, 'int')
#update slave parameters here, no need to update slave parameters here
os.chdir('../')
#save parameter file, no need to save parameter file here
os.chdir('../')
############################################################
# STEP 5. clear frame processing files
############################################################
import shutil
from isceobj.Alos2Proc.Alos2ProcPublic import runCmd
for k in range(2):
os.chdir(ionDir['subband'][k])
for i, frameNumber in enumerate(self._insar.masterFrames):
frameDir = 'f{}_{}'.format(i + 1, frameNumber)
shutil.rmtree(frameDir)
#cmd = 'rm -rf {}'.format(frameDir)
#runCmd(cmd)
os.chdir('../')
############################################################
# STEP 6. create differential interferograms
############################################################
import numpy as np
from isceobj.Alos2Proc.Alos2ProcPublic import runCmd
for k in range(2):
os.chdir(ionDir['subband'][k])
insarDir = ionDir['insar']
if not os.path.exists(insarDir):
os.makedirs(insarDir)
os.chdir(insarDir)
rangePixelSize = self._insar.numberRangeLooks1 * masterTrack.rangePixelSize
radarWavelength = subbandRadarWavelength[k]
rectRangeOffset = os.path.join('../../../', insarDir,
self._insar.rectRangeOffset)
cmd = "imageMath.py -e='a*exp(-1.0*J*b*4.0*{}*{}/{}) * (b!=0)' --a={} --b={} -o {} -t cfloat".format(
np.pi, rangePixelSize, radarWavelength, self._insar.interferogram,
rectRangeOffset, self._insar.differentialInterferogram)
runCmd(cmd)
os.chdir('../../')
os.chdir('../')
catalog.printToLog(logger, "runIonSubband")
self._insar.procDoc.addAllFromCatalog(catalog)
def 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(imageSlc1, imageSlc2, instrument, offsetField, resampName, azLooks, rgLooks, lines, dopplerCentroid, numFitCoeff, pixelSpacing, stdWriter, catalog=None, sceneid='NO_ID', output="all"):
logger.info("Resampling interferogram: %s" % sceneid)
output = output.replace(" ", "") #remove all spaces in output
if output == "all":
output = ["intamp", "resamp"]
else:
output = output.split(",") #get a list from comma-separated text
objSlc1 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc1, objSlc1)
objSlc1.setAccessMode('read')
objSlc1.createImage()
objSlc2 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc2, objSlc2)
objSlc2.setAccessMode('read')
objSlc2.createImage()
slcWidth = imageSlc1.getWidth()
intWidth = int(slcWidth / rgLooks)
if "resamp" in output:
logger.info("Will output resampled slc")
objResampSlc2 = isceobj.createSlcImage()
objResampSlc2.setFilename(objSlc2.getFilename().replace('.slc', '.resamp.slc')) #replace .slc by .resamp.slc
objResampSlc2.setWidth(slcWidth)
imageResamp2 = isceobj.createSlcImage()
IU.copyAttributes(objResampSlc2, imageResamp2)
objResampSlc2.setAccessMode('write')
objResampSlc2.createImage()
else:
objResampSlc2 = None
imageResamp2 = None
if "intamp" in output:
logger.info("Will ouput resampled interferogram and amplitude: %s" % sceneid)
resampAmp = resampName + '.amp'
resampInt = resampName + '.int'
objInt = isceobj.createIntImage()
objInt.setFilename(resampInt)
objInt.setWidth(intWidth)
imageInt = isceobj.createIntImage()
IU.copyAttributes(objInt, imageInt)
objInt.setAccessMode('write')
objInt.createImage()
objAmp = isceobj.createAmpImage()
objAmp.setFilename(resampAmp)
objAmp.setWidth(intWidth)
imageAmp = isceobj.createAmpImage()
IU.copyAttributes(objAmp, imageAmp)
objAmp.setAccessMode('write')
objAmp.createImage()
else:
objInt = None
imageInt = None
objAmp = None
imageAmp = None
dopplerCoeff = dopplerCentroid.getDopplerCoefficients(inHz=False)
objResamp = stdproc.createResamp()
objResamp.setNumberLines(lines)
objResamp.setNumberFitCoefficients(numFitCoeff)
objResamp.setNumberAzimuthLooks(azLooks)
objResamp.setNumberRangeLooks(rgLooks)
objResamp.setSlantRangePixelSpacing(pixelSpacing)
objResamp.setDopplerCentroidCoefficients(dopplerCoeff)
objResamp.wireInputPort(name='offsets', object=offsetField)
objResamp.wireInputPort(name='instrument', object=instrument)
#set the tag used in the outfile. each message is precided by this tag
#is the writer is not of "file" type the call has no effect
objResamp.stdWriter = stdWriter.set_file_tags("resamp",
"log",
"err",
"out")
objResamp.resamp(objSlc1, objSlc2, objInt, objAmp, objResampSlc2)
if catalog is not None:
# Record the inputs and outputs
isceobj.Catalog.recordInputsAndOutputs(catalog, objResamp,
"runResamp.%s" % sceneid,
logger,
"runResamp.%s" % sceneid)
for obj in [objInt, objAmp, objSlc1, objSlc2, objResampSlc2]:
if obj is not None:
obj.finalizeImage()
return imageInt, imageAmp, imageResamp2
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')
