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')