def run(imageSlc1, imageSlc2, offsetField, instrument, dopplerCentroid, looks, lines, numFitCoeff, pixelSpacing, offsetFilename, stdWriter, catalog=None, sceneid='NO_ID'):
widthSlc = max(imageSlc1.getWidth(), imageSlc2.getWidth())
dopplerCoeff = dopplerCentroid.getDopplerCoefficients(inHz=False)
path, filename = os.path.split(offsetFilename)
offsetAz = os.path.join(path, 'azimuth_' + filename)
offsetRn = os.path.join(path, 'range_' + filename)
widthOffset = int(widthSlc / looks)
imageAz = isceobj.createOffsetImage()
imageAz.setFilename(offsetAz)
imageAz.setWidth(widthOffset)
imageRn = isceobj.createOffsetImage()
imageRn.setFilename(offsetRn)
imageRn.setWidth(widthOffset)
objAz = isceobj.createOffsetImage()
objRn = isceobj.createOffsetImage()
IU.copyAttributes(imageAz, objAz)
IU.copyAttributes(imageRn, objRn)
objAz.setAccessMode('write')
objAz.createImage()
objRn.setAccessMode('write')
objRn.createImage()
objResamp_image = stdproc.createResamp_image()
objResamp_image.wireInputPort(name='offsets', object=offsetField)
objResamp_image.wireInputPort(name='instrument', object=instrument)
objResamp_image.setSlantRangePixelSpacing(pixelSpacing)
objResamp_image.setDopplerCentroidCoefficients(dopplerCoeff)
objResamp_image.setNumberLooks(looks)
objResamp_image.setNumberLines(lines)
objResamp_image.setNumberRangeBin(widthSlc)
objResamp_image.setNumberFitCoefficients(numFitCoeff)
#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_image.stdWriter = stdWriter.set_file_tags("resamp_image",
"log",
"err",
"out")
objResamp_image.resamp_image(objRn, objAz)
if catalog is not None:
# Record the inputs and outputs
isceobj.Catalog.recordInputsAndOutputs(catalog, objResamp_image,
"runResamp_image.%s" % sceneid,
logger,
"runResamp_image.%s" % sceneid)
objRn.finalizeImage()
objAz.finalizeImage()
return imageAz, imageRn
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 run(method, ampImage, widthInt, infos, stdWriter, catalog=None, sceneid='NO_ID'):
logger.info("Calculating Coherence: %s" % sceneid)
# Initialize the flattened inteferogram
topoflatIntFilename = infos['outputPath'] + '.' + infos['topophaseFlatFilename']
intImage = isceobj.createIntImage()
intImage.setFilename(topoflatIntFilename)
intImage.setWidth(widthInt)
intImage.setAccessMode('read')
intImage.createImage()
# Create the coherence image
cohFilename = topoflatIntFilename.replace('.flat', '.cor')
cohImage = isceobj.createOffsetImage()
cohImage.setFilename(cohFilename)
cohImage.setWidth(widthInt)
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)
try:
CORRELATION_METHOD[method](cor)
except KeyError:
print("Unrecognized correlation method")
sys.exit(1)
pass
return None
def computeCoherence(slc1name, slc2name, corname, virtual=True):
slc1 = isceobj.createImage()
slc1.load(slc1name + '.xml')
slc1.createImage()
slc2 = isceobj.createImage()
slc2.load(slc2name + '.xml')
slc2.createImage()
cohImage = isceobj.createOffsetImage()
cohImage.setFilename(corname)
cohImage.setWidth(slc1.getWidth())
cohImage.setAccessMode('write')
cohImage.createImage()
cor = Correlation()
cor.configure()
cor.wireInputPort(name='slc1', object=slc1)
cor.wireInputPort(name='slc2', object=slc2)
cor.wireOutputPort(name='correlation', object=cohImage)
cor.coregisteredSlcFlag = True
cor.calculateCorrelation()
cohImage.finalizeImage()
slc1.finalizeImage()
slc2.finalizeImage()
return
def runCoherence(self, method="phase_gradient"):
logger.info("Calculating Coherence")
# Initialize the amplitude
# resampAmpImage = self.insar.resampAmpImage
# ampImage = isceobj.createAmpImage()
# IU.copyAttributes(resampAmpImage, ampImage)
# ampImage.setAccessMode('read')
# ampImage.createImage()
# ampImage = self.insar.getResampOnlyAmp().copy(access_mode='read')
ampImage = isceobj.createImage()
ampImage.load(self.insar.getResampOnlyAmp().filename + '.xml')
ampImage.setAccessMode('READ')
ampImage.createImage()
# Initialize the flattened inteferogram
topoflatIntFilename = self.insar.topophaseFlatFilename
intImage = isceobj.createImage()
intImage.load(self.insar.topophaseFlatFilename + '.xml')
intImage.setAccessMode('READ')
intImage.createImage()
# widthInt = self.insar.resampIntImage.getWidth()
# intImage.setFilename(topoflatIntFilename)
# intImage.setWidth(widthInt)
# intImage.setAccessMode('read')
# intImage.createImage()
# Create the coherence image
cohFilename = topoflatIntFilename.replace('.flat', '.cor')
cohImage = isceobj.createOffsetImage()
cohImage.setFilename(cohFilename)
cohImage.setWidth(intImage.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)
cohImage.finalizeImage()
intImage.finalizeImage()
ampImage.finalizeImage()
cor.calculateCorrelation()
# try:
# CORRELATION_METHOD[method](cor)
# except KeyError:
# print("Unrecognized correlation method")
# sys.exit(1)
# pass
return None
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 main(iargs=None):
'''
'''
inps = cmdLineParse(iargs)
os.makedirs(os.path.dirname(inps.coherence), exist_ok=True)
#The orginal coherence calculated by topsApp.py is not good at all, use the following coherence instead
#lowerintfile = os.path.join(ionParam.ionDirname, ionParam.lowerDirname, ionParam.mergedDirname, self._insar.mergedIfgname)
#upperintfile = os.path.join(ionParam.ionDirname, ionParam.upperDirname, ionParam.mergedDirname, self._insar.mergedIfgname)
#corfile = os.path.join(ionParam.ionDirname, ionParam.lowerDirname, ionParam.mergedDirname, self._insar.correlationFilename)
img = isceobj.createImage()
img.load(inps.lower + '.xml')
width = img.width
length = img.length
lowerint = np.fromfile(inps.lower,
dtype=np.complex64).reshape(length, width)
upperint = np.fromfile(inps.upper,
dtype=np.complex64).reshape(length, width)
if (inps.nrlks != 1) or (inps.nalks != 1):
width = np.int(width / inps.nrlks)
length = np.int(length / inps.nalks)
lowerint = multilook(lowerint, inps.nalks, inps.nrlks)
upperint = multilook(upperint, inps.nalks, inps.nrlks)
#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((length * 2, width), dtype=np.float32)
cor[0:length * 2:2, :] = np.sqrt(
(np.absolute(lowerint) + np.absolute(upperint)) / 2.0)
cor[1:length * 2:2, :] = cord
cor.astype(np.float32).tofile(inps.coherence)
#create xml and vrt
#img.scheme = 'BIL'
#img.bands = 2
#img.filename = corfile
#img.renderHdr()
#img = isceobj.Image.createUnwImage()
img = isceobj.createOffsetImage()
img.setFilename(inps.coherence)
img.extraFilename = inps.coherence + '.vrt'
img.setWidth(width)
img.setLength(length)
img.renderHdr()
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 runResamp_image(self):
imageSlc = self._insar.getMasterSlcImage()
widthSlc = max(self._insar.getMasterSlcImage().getWidth(),
self._insar.getSlaveSlcImage().getWidth())
offsetField = self._insar.getRefinedOffsetField()
instrument = self._insar.getMasterFrame().getInstrument()
dopplerCoeff = self._insar.getDopplerCentroid().getDopplerCoefficients(
inHz=False)
pixelSpacing = self._insar.getSlantRangePixelSpacing()
looks = self._insar.getNumberLooks()
lines = self._insar.getNumberResampLines()
numFitCoeff = self._insar.getNumberFitCoefficients()
offsetFilename = self._insar.getOffsetImageName()
offsetAz = 'azimuth' + offsetFilename.capitalize()
offsetRn = 'range' + offsetFilename.capitalize()
widthOffset = int(widthSlc / looks)
imageAz = isceobj.createOffsetImage()
imageAz.setFilename(offsetAz)
imageAz.setWidth(widthOffset)
imageRn = isceobj.createOffsetImage()
imageRn.setFilename(offsetRn)
imageRn.setWidth(widthOffset)
self._insar.setOffsetAzimuthImage(imageAz)
self._insar.setOffsetRangeImage(imageRn)
objAz = isceobj.createOffsetImage()
objRn = isceobj.createOffsetImage()
IU.copyAttributes(imageAz, objAz)
IU.copyAttributes(imageRn, objRn)
objAz.setAccessMode('write')
objAz.createImage()
objRn.setAccessMode('write')
objRn.createImage()
objResamp_image = stdproc.createResamp_image()
objResamp_image.wireInputPort(name='offsets', object=offsetField)
objResamp_image.wireInputPort(name='instrument', object=instrument)
objResamp_image.setSlantRangePixelSpacing(pixelSpacing)
objResamp_image.setDopplerCentroidCoefficients(dopplerCoeff)
objResamp_image.setNumberLooks(looks)
objResamp_image.setNumberLines(lines)
objResamp_image.setNumberRangeBin(widthSlc)
objResamp_image.setNumberFitCoefficients(numFitCoeff)
#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_image", "log")
self._stdWriter.setFileTag("resamp_image", "err")
self._stdWriter.setFileTag("resamp_image", "out")
objResamp_image.setStdWriter(self._stdWriter)
objResamp_image.resamp_image(objRn, objAz)
# Record the inputs and outputs
from isceobj.Catalog import recordInputsAndOutputs
recordInputsAndOutputs(self._insar.procDoc, objResamp_image, "runResamp_image", \
logger, "runResamp_image")
objRn.finalizeImage()
objAz.finalizeImage()
def runCoherence(self, method="phase_gradient"):
logger.info("Calculating Coherence")
import os
resampAmpImage = os.path.join(self.insar.ifgDirname,
self.insar.ifgFilename)
topoflatIntFilename = os.path.join(self.insar.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'
# Initialize the amplitude
# resampAmpImage = self.insar.resampAmpImage
# ampImage = isceobj.createAmpImage()
# IU.copyAttributes(resampAmpImage, ampImage)
# ampImage.setAccessMode('read')
# ampImage.createImage()
# ampImage = self.insar.getResampOnlyAmp().copy(access_mode='read')
ampImage = isceobj.createImage()
ampImage.load(resampAmpImage + '.xml')
ampImage.setAccessMode('READ')
ampImage.createImage()
# Initialize the flattened inteferogram
# topoflatIntFilename = self.insar.topophaseFlatFilename
intImage = isceobj.createImage()
intImage.load(topoflatIntFilename + '.xml')
intImage.setAccessMode('READ')
intImage.createImage()
# widthInt = self.insar.resampIntImage.getWidth()
# intImage.setFilename(topoflatIntFilename)
# intImage.setWidth(widthInt)
# intImage.setAccessMode('read')
# intImage.createImage()
# Create the coherence image
cohFilename = topoflatIntFilename.replace('.flat', '.cor')
cohImage = isceobj.createOffsetImage()
cohImage.setFilename(cohFilename)
cohImage.setWidth(intImage.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)
cohImage.finalizeImage()
intImage.finalizeImage()
ampImage.finalizeImage()
cor.calculateCorrelation()
# NEW COMMANDS added by YL --start
import subprocess
subprocess.getoutput(
'MULTILOOK_FILTER_ISCE.py -a ./interferogram/topophase.amp -c ./interferogram/topophase.cor'
)
subprocess.getoutput(
'CROP_ISCE_stripmapApp.py -a ./interferogram/topophase.amp -c ./interferogram/topophase.cor'
)
subprocess.getoutput(
'imageMath.py -e="a_0;a_1" --a ./interferogram/topophase.amp -o ./interferogram/resampOnlyImage1.amp -s BIL -t FLOAT'
)
self.geocode_list += ['./interferogram/resampOnlyImage1.amp']
# NEW COMMANDS added by YL --end
# try:
# CORRELATION_METHOD[method](cor)
# except KeyError:
# print("Unrecognized correlation method")
# sys.exit(1)
# pass
return None
def runAutorift(I1, I2, xGrid, yGrid, Dx0, Dy0, noDataMask):
'''
Wire and run geogrid.
'''
import isce
from components.contrib.geoAutorift.autorift.Autorift import Autorift
import numpy as np
import isceobj
import time
obj = Autorift()
obj.configure()
# #uncomment if starting from preprocessed images
# I1 = I1.astype(np.uint8)
# I2 = I2.astype(np.uint8)
obj.I1 = I1
obj.I2 = I2
######### mask out nodata
if xGrid is not None:
xGrid[noDataMask] = 0
yGrid[noDataMask] = 0
obj.xGrid = xGrid
obj.yGrid = yGrid
obj.SearchLimitX = obj.SearchLimitX * np.logical_not(noDataMask)
obj.SearchLimitY = obj.SearchLimitY * np.logical_not(noDataMask)
if Dx0 is not None:
Dx0[noDataMask] = 0
Dy0[noDataMask] = 0
Dy0 = -1 * Dy0
obj.Dx0 = np.round(Dx0 / 100.0)
obj.Dy0 = np.round(Dy0 / 100.0)
obj.zeroMask = 1
######## preprocessing
t1 = time.time()
print("Pre-process Start!!!")
obj.preprocess_filt_hps()
# obj.I1 = np.abs(I1)
# obj.I2 = np.abs(I2)
print("Pre-process Done!!!")
print(time.time() - t1)
t1 = time.time()
# obj.DataType = 0
obj.uniform_data_type()
print("Uniform Data Type Done!!!")
print(time.time() - t1)
# pdb.set_trace()
# obj.sparseSearchSampleRate = 16
########## export preprocessed images to files
t1 = time.time()
I1 = obj.I1
I2 = obj.I2
length, width = I1.shape
filename1 = 'I1_uint8_hpsnew.off'
slcFid = open(filename1, 'wb')
for yy in range(length):
data = I1[yy, :]
data.astype(np.float32).tofile(slcFid)
slcFid.close()
img = isceobj.createOffsetImage()
img.setFilename(filename1)
img.setBands(1)
img.setWidth(width)
img.setLength(length)
img.setAccessMode('READ')
img.renderHdr()
filename2 = 'I2_uint8_hpsnew.off'
slcFid = open(filename2, 'wb')
for yy in range(length):
data = I2[yy, :]
data.astype(np.float32).tofile(slcFid)
slcFid.close()
img = isceobj.createOffsetImage()
img.setFilename(filename2)
img.setBands(1)
img.setWidth(width)
img.setLength(length)
img.setAccessMode('READ')
img.renderHdr()
print("output Done!!!")
print(time.time() - t1)
# pdb.set_trace()
########## run Autorift
t1 = time.time()
print("AutoRIFT Start!!!")
obj.runAutorift()
print("AutoRIFT Done!!!")
print(time.time() - t1)
# pdb.set_trace()
return obj.Dx, obj.Dy, obj.InterpMask, obj.ChipSizeX
