def runSimamp(outdir, hname='z.rdr'):
from iscesys.StdOEL.StdOELPy import create_writer
#####Run simamp
stdWriter = create_writer("log", "", True, filename='sim.log')
objShade = isceobj.createSimamplitude()
objShade.setStdWriter(stdWriter)
hgtImage = isceobj.createImage()
hgtImage.load(os.path.join(outdir, hname) + '.xml')
hgtImage.setAccessMode('read')
hgtImage.createImage()
simImage = isceobj.createImage()
simImage.setFilename(os.path.join(outdir, 'simamp.rdr'))
simImage.dataType = 'FLOAT'
simImage.setAccessMode('write')
simImage.setWidth(hgtImage.getWidth())
simImage.createImage()
objShade.simamplitude(hgtImage, simImage, shade=3.0)
simImage.renderHdr()
hgtImage.finalizeImage()
simImage.finalizeImage()
return
def computePeg(self):
shortOrb = Orbit()
for i in range(-10, 10):
time = self.tMid + datetime.timedelta(
seconds=(old_div(i, self.prf)))
sv = self.orbVec.interpolateOrbit(time, method='hermite')
shortOrb.addStateVector(sv)
objPeg = stdproc.createGetpeg()
objPeg.wireInputPort(name='planet', object=self.planet)
objPeg.wireInputPort(name='Orbit', object=shortOrb)
stdWriter = create_writer("log", "", True, filename="orbitInfo.log")
stdWriter.setFileTag("getpeg", "log")
stdWriter.setFileTag("getpeg", "err")
stdWriter.setFileTag("getpeg", "log")
objPeg.setStdWriter(stdWriter)
objPeg.estimatePeg()
self.peg = objPeg.getPeg()
self.rds = objPeg.getPegRadiusOfCurvature()
self.hgt = objPeg.getAverageHeight()
return
def fitOffsets(field, azrgOrder=0, azazOrder=0, rgrgOrder=0, rgazOrder=0, snr=5.0):
'''
Estimate constant range and azimuth shifts.
'''
stdWriter = create_writer("log","",True,filename='off.log')
for distance in [10,5,3,1]:
inpts = len(field._offsets)
objOff = isceobj.createOffoutliers()
objOff.wireInputPort(name='offsets', object=field)
objOff.setSNRThreshold(snr)
objOff.setDistance(distance)
objOff.setStdWriter(stdWriter)
objOff.offoutliers()
field = objOff.getRefinedOffsetField()
outputs = len(field._offsets)
print('%d points left'%(len(field._offsets)))
aa, dummy = field.getFitPolynomials(azimuthOrder=azazOrder, rangeOrder=azrgOrder, usenumpy=True)
dummy, rr = field.getFitPolynomials(azimuthOrder=rgazOrder, rangeOrder=rgrgOrder, usenumpy=True)
azshift = aa._coeffs[0][0]
rgshift = rr._coeffs[0][0]
print('Estimated az shift: ', azshift)
print('Estimated rg shift: ', rgshift)
return (aa, rr), field
def checkWindows(self):
'''Ensure that the window sizes are valid for the code to work.'''
if (self.windowSizeWidth%2 == 1):
raise ValueError('Window size width needs to be an even number.')
if (self.windowSizeHeight%2 == 1):
raise ValueError('Window size height needs to be an even number.')
if not is_power2(self.zoomWindowSize):
raise ValueError('Zoom window size needs to be a power of 2.')
if not is_power2(self.oversamplingFactor):
raise ValueError('Oversampling factor needs to be a power of 2.')
if self.searchWindowSizeWidth >= 2*self.windowSizeWidth :
raise ValueError('Search Window Size Width should be < 2 * Window Size Width')
if self.searchWindowSizeHeight >= 2*self.windowSizeHeight :
raise ValueError('Search Window Size Height should be < 2 * Window Size Height')
if self.zoomWindowSize >= min(self.searchWindowSizeWidth, self.searchWindowSizeHeight):
raise ValueError('Zoom window size should be <= Search window size')
if self._stdWriter is None:
self._stdWriter = create_writer("log", "", True, filename="denseampcor.log")
self.pixLocOffAc = self.windowSizeWidth//2 + self.searchWindowSizeWidth - 1
self.pixLocOffDn = self.windowSizeHeight//2 + self.searchWindowSizeHeight - 1
def __init__(self, family='', name='', cmdline=None):
import isceobj
super().__init__(family=family, name=name, cmdline=cmdline)
from isceobj.StripmapProc import StripmapProc
from iscesys.StdOEL.StdOELPy import create_writer
self._stdWriter = create_writer("log", "", True, filename="roi.log")
self._add_methods()
self._insarProcFact = StripmapProc
return None
def run(tobeGeocoded,
frame1,
formSLC1,
velocity,
height,
snwe,
infos,
catalog=None,
sceneid='NO_ID'):
logger.info("Geocoding Image: %s" % sceneid)
stdWriter = create_writer("log",
"",
True,
filename=infos['ouputPath'] + ".geo.log")
planet = frame1.getInstrument().getPlatform().getPlanet()
referenceOrbit = formSLC1.getMocompPosition(posIndx)
doppler = dopplerCentroid.getDopplerCoefficients(inHz=False)[0]
#####Geocode one by one
ge = Geocodable()
for prod in tobeGeocoded:
objGeo = stdproc.createGeocode(
snwe=snwe,
demCropFilename=infos['outputPath'] + '.' +
infos['demCropFilename'],
referenceOrbit=referenceOrbit,
dopplerCentroidConstantTerm=doppler,
bodyFixedVelocity=velocity,
spacecraftHeight=height,
numberRangeLooks=infos['numberRangeLooks'],
numberAzimuthLooks=infos['numberAzimuthLooks'],
isMocomp=infos['is_mocomp'])
objGeo.stdWriter = stdWriter
#create the instance of the image and return the method is supposed to use
inImage, objGeo.method = ge.create(infos['outputPath'] + '.' + prod)
if inImage:
demImage = isceobj.createDemImage()
IU.copyAttributes(infos['demImage'], demImage)
objGeo(peg=infos['peg'],
frame=frame1,
planet=planet,
dem=demImage,
tobegeocoded=inImage,
geoPosting=None,
masterslc=formSLC1)
if catalog is not None:
isceobj.Catalog.recordInputsAndOutputs(
catalog, objGeo, "runGeocode.%s" % sceneid, logger,
"runGeocode.%s" % sceneid)
stdWriter.finalize()
def runGeocode(self, prodlist, unwrapflag, bbox):
'''Generalized geocoding of all the files listed above (in prodlist).'''
if isinstance(prodlist, str):
from isceobj.Util.StringUtils import StringUtils as SU
tobeGeocoded = SU.listify(prodlist)
else:
tobeGeocoded = prodlist
#####Remove the unwrapped interferogram if no unwrapping is done
if not unwrapflag:
try:
tobeGeocoded.remove(self._isce.unwrappedIntFilename)
except ValueError:
pass
print('Number of products to geocode: ', len(tobeGeocoded))
stdWriter = create_writer("log", "", True, filename="geo.log")
velocity, height = self._isce.vh()
if bbox is not None:
snwe = list(bbox)
if len(snwe) != 4:
raise valueError('Bounding box should be a list/tuple of length 4')
else:
snwe = self._isce.topo.snwe
infos = {}
for attribute in [
'demCropFilename', 'numberRangeLooks', 'numberAzimuthLooks',
'is_mocomp', 'demImage', 'peg', 'dopplerCentroid'
]:
infos[attribute] = getattr(self._isce, attribute)
for sceneid1, sceneid2 in self._isce.selectedPairs:
pair = (sceneid1, sceneid2)
for pol in self._isce.selectedPols:
frame1 = self._isce.frames[sceneid1][pol]
formSLC1 = self._isce.formSLCs[sceneid1][pol]
sid = self._isce.formatname(pair, pol)
infos['outputPath'] = os.path.join(
self.getoutputdir(sceneid1, sceneid2), sid)
catalog = isceobj.Catalog.createCatalog(self._isce.procDoc.name)
run(tobeGeocoded,
frame1,
formSLC1,
velocity,
height,
snwe,
infos,
catalog=catalog,
sceneid=sid)
self._isce.procDoc.addAllFromCatalog(catalog)
def __init__(self, family='', name='', cmdline=None):
import isceobj
from isceobj.RtcProc import RtcProc
from iscesys.StdOEL.StdOELPy import create_writer
super().__init__(family=family if family else self.__class__.family,
name=name,
cmdline=cmdline)
self._stdWriter = create_writer("log", "", True, filename="grdsar.log")
self._add_methods()
self._insarProcFact = RtcProc
return None
def cullOffset(offsets, distances, numCullOffsetsLimits):
import os
import isce
import isceobj
from iscesys.StdOEL.StdOELPy import create_writer
#offsets: offsets from ampcor
#distances: tuple
#numCullOffsetsLimits: tuple
refinedOffsets = offsets
for i, (distance, numCullOffsetsLimit) in enumerate(
zip(distances, numCullOffsetsLimits)):
cullOff = isceobj.createOffoutliers()
cullOff.wireInputPort(name='offsets', object=refinedOffsets)
cullOff.setSNRThreshold(2.0)
cullOff.setDistance(distance)
#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
logfile = "offoutliers.log"
stdWriter = create_writer("log", "", True, filename=logfile)
stdWriter.setFileTag("offoutliers", "log")
stdWriter.setFileTag("offoutliers", "err")
stdWriter.setFileTag("offoutliers", "out")
cullOff.setStdWriter(stdWriter)
try:
cullOff.offoutliers()
refinedOffsets = cullOff.getRefinedOffsetField()
numLeft = len(refinedOffsets._offsets)
print('Number of offsets left after %2dth culling: %5d' %
(i, numLeft))
if numLeft < numCullOffsetsLimit:
print(
'*******************************************************')
print('WARNING: Too few points left after culling: {} left'.
format(numLeft))
print(
'*******************************************************')
return None
except:
print('*******************************************************')
print('WARNING: unsuccessful offset culling')
print('*******************************************************')
return None
os.remove(logfile)
return refinedOffsets
def __init__(self, stdWriter=None):
super(Correct_geoid_i2_srtm, self).__init__()
self._inputFilename = ''
#if not provided it assumes that we want to overwrite the input
self._outputFilename = ''
self._overwriteInputFileFlag = False
self._width = None
self._startLatitude = None
self._startLongitude = None
self._deltaLatitude = None
self._deltaLongitude = None
self._numberLines = None
self._conversionType = -1 #1 ellipsoid (WGS84)->geoid (EGM96), -1 vice versa
self._image = None
self._reference = None
if (stdWriter):
self._stdWriter = stdWriter
else:
from iscesys.StdOEL.StdOELPy import create_writer
self._stdWriter = create_writer("log",
"",
True,
filename="insar.log")
self._dataType = None
self._dem = None
self._dataTypeBindings = 'FLOAT'
demImagePort = Port(name='demImage', method=self.addDemImage)
self._inputPorts.add(demImagePort)
#make sure that the .dat file is in the executing directory
self._geoidFilename = os.path.join(
os.path.dirname(os.path.abspath(__file__)), 'egm96geoid.dat')
self.dictionaryOfVariables = { \
'WIDTH' : ['width', 'int','mandatory'], \
'INPUT_FILENAME' : ['inputFilename', 'str','mandatory'], \
'OUTPUT_FILENAME' : ['outputFilename', 'str','optional'], \
'OVERWRITE_INPUT_FILE_FLAG' : ['overwriteInputFileFlag', 'str','optional'], \
'START_LATITUDE' : ['startLatitude', 'float','mandatory'], \
'START_LONGITUDE' : ['startLongitude', 'float','mandatory'], \
'DELTA_LATITUDE' : ['deltaLatitude', 'float','mandatory'], \
'DELTA_LONGITUDE' : ['deltaLongitude', 'float','mandatory'], \
'CONVERSION_TYPE' : ['conversionType', 'int','mandatory'], \
'GEOID_FILENAME' : ['geoidFilename', 'str','mandatory'] \
}
self.dictionaryOfOutputVariables = {}
self.descriptionOfVariables = {}
self.mandatoryVariables = []
self.optionalVariables = []
self.initOptionalAndMandatoryLists()
return
def wgs84_to_sch(orbit, peg, pegHavg, planet):
'''
Convert WGS84 orbits to SCH orbits and return it.
'''
import stdproc
from iscesys.StdOEL.StdOELPy import create_writer
import copy
stdWriter = create_writer("log","",True,filename='orb.log')
orbSch = stdproc.createOrbit2sch(averageHeight=pegHavg)
orbSch.setStdWriter(stdWriter)
orbSch(planet=planet, orbit=orbit, peg=peg)
schOrigOrbit = copy.copy(orbSch.orbit)
return schOrigOrbit
def getXYZOrbit(self, orbit, peg, hdg):
'''
Convert an input SCH orbit to XYZ coords.
'''
llh = [peg.lat, peg.lon, peg.hgt]
radius = self._planet.ellipsoid.radiusOfCurvature(llh, hdg=hdg)
midPeg = Peg(latitude=peg.lat,
longitude=peg.lon,
heading=hdg,
radiusOfCurvature=radius)
writer = create_writer("log", "", True, filename='orbit_extender.log')
orbxyz = stdproc.createSch2orbit()
orbxyz.radiusOfCurvature = radius
orbxyz.setStdWriter(writer)
orbxyz(planet=self._planet, orbit=orbit, peg=midPeg)
return orbxyz.orbit
def setDefaults(self):
'''
Set up default values.
'''
if (self._xFactor is None) and (self._yFactor is None):
raise Exception('Oversampling factors not defined.')
if self._xFactor and (self._yFactor is None):
print('YFactor not defined. Set same as XFactor.')
self._yFactor = self._xFactor
if self.yFactor and (self.xFactor is None):
print('XFactor not defined. Set same as YFactor.')
self._xFactor = self._yFactor
if (self._xFactor == 1) and (self._yFactor == 1):
raise Exception('No oversampling requested.')
if self._outputFilename is None:
self._outputFilename = self._inputFilename + '_ovs_%d_%d' % (
self._yFactor, self._xFactor)
if (self._width is None) or (self._numberLines is None):
raise Exception('Input Dimensions undefined.')
self._outWidth = (self._width - 1) * self._xFactor + 1
self._outNumberLines = (self._numberLines - 1) * self._yFactor + 1
if self._stdWriter is None:
self._stdWriter = create_writer("log",
"",
True,
filename="upsampledem.log")
if self.method is None:
self.method = 'BIQUINTIC'
else:
if self.method.upper() not in list(
self.interpolationMethods.keys()):
raise Exception('Interpolation method must be one of ' +
str(list(self.interpolationMethods.keys())))
return
def __init__(self, family='', name='', cmdline=None):
import isceobj
super(_InsarBase, self).__init__(family=family,
name=name,
cmdline=cmdline)
from iscesys.StdOEL.StdOELPy import create_writer
self._stdWriter = create_writer("log", "", True, filename="insar.log")
self._add_methods()
procDoc = isceobj.createCatalog('insarProc')
self._insar = InsarProc.InsarProc(name='insarApp_conf',
procDoc=procDoc)
self.insar.procDoc._addItem(
"ISCE_VERSION", "Release: %s, svn-%s, %s. Current svn-%s" %
(isce.release_version, isce.release_svn_revision,
isce.release_date, isce.svn_revision), ["insarProc"])
return None
def __init__(self, stdWriter=None,family='',name=''):
super(Correct_geoid_i2_srtm, self).__init__(family if family else self.__class__.family, name=name)
#if not provided it assumes that we want to overwrite the input
self._numberLines = None
self._image = None
self._reference = None
if(stdWriter):
self._stdWriter = stdWriter
else:
from iscesys.StdOEL.StdOELPy import create_writer
self._stdWriter = create_writer("log", "", True, filename="insar.log")
self._dataType = None
self._dem = None
self._dataTypeBindings = 'FLOAT'
demImagePort = Port(name='demImage', method=self.addDemImage)
self._inputPorts.add(demImagePort)
#make sure that the .dat file is in the executing directory
self.initOptionalAndMandatoryLists()
return
def __init__(self, family='', name='', cmdline=None):
"""
Initialize the application: read the xml file and prepare the application.
"""
super().__init__(family=family if family else self.__class__.family,
name=name,
cmdline=cmdline)
now = datetime.datetime.now()
##add timestamp to isceProc.xml file, so that they don't overwrite themselves
self._isce = IsceProc.IsceProc(
procDoc=isceobj.createCatalog('isceProc_%s' %
now.strftime('%Y%m%d%H%M%S')))
self._isce.procDoc._addItem(
"ISCE_VERSION", "Release: %s, svn-%s, %s. Current svn-%s" %
(isce.release_version, isce.release_svn_revision,
isce.release_date, isce.svn_revision), ["isceProc"])
self._stdWriter = create_writer("log", "", True, filename="isce.log")
self._add_methods()
self.pairsToCoreg = [] ##pairs to coregister
self.intromsg = '' ##intro message
self.peg = None
def getSCHOrbit(self, orbit, peg, hdg):
'''
Accepts a WGS-84 orbit and converts it to SCH.
'''
writer = create_writer("log", "", True, filename='orbit_extender.log')
llh = [peg.lat, peg.lon, peg.hgt]
####Local radius
radius = self._planet.ellipsoid.radiusOfCurvature(llh, hdg=hdg)
#midPeg is a Location.Peg object
midPeg = Peg(latitude=peg.lat,
longitude=peg.lon,
heading=hdg,
radiusOfCurvature=radius)
orbSch = stdproc.createOrbit2sch(averageHeight=peg.hgt)
orbSch.setStdWriter(writer)
orbSch(planet=self._planet, orbit=orbit, peg=midPeg)
return orbSch.orbit
def runEstamb(insar):
import copy
stdWriter = create_writer("log", "", True, filename="estamb.log")
objRaw = insar.referenceRawImage.copy(access_mode='read')
v, h = insar.vh()
objFormSlc = stdproc.createestamb()
objFormSlc.minAmb = -3
objFormSlc.maxAmb = 3
# objFormSlc.setAzimuthPatchSize(8192)
# objFormSlc.setNumberValidPulses(6144)
objFormSlc.setBodyFixedVelocity(v)
objFormSlc.setSpacecraftHeight(h)
objFormSlc.setFirstLine(5000)
objFormSlc.setNumberPatches(1)
objFormSlc.setNumberRangeBin(insar._referenceFrame.numberRangeBins)
objFormSlc.setLookSide(insar._lookSide)
doppler = copy.deepcopy(insar.referenceDoppler)
# doppler.fractionalCentroid = 0.39
doppler.linearTerm = 0.
doppler.quadraticTerm = 0.
doppler.cubicTerm = 0.
print("Focusing Reference image")
objFormSlc.stdWriter = stdWriter
entropy, Amb = objFormSlc(
rawImage=objRaw,
orbit=insar.referenceOrbit,
frame=insar.referenceFrame,
planet=insar.referenceFrame.instrument.platform.planet,
doppler=doppler,
peg=insar.peg)
objRaw.finalizeImage()
stdWriter.finalize()
print('Input Doppler: ', doppler.fractionalCentroid)
print('Doppler Ambiguity: ', Amb)
def cullOffsets(offsets):
import isceobj
from iscesys.StdOEL.StdOELPy import create_writer
distances = (10, 5, 3, 3, 3, 3, 3, 3)
#numCullOffsetsLimits = (100, 75, 50, 50, 50, 50, 50, 50)
numCullOffsetsLimits = (50, 40, 30, 30, 30, 30, 30, 30)
refinedOffsets = offsets
for i, (distance, numCullOffsetsLimit) in enumerate(
zip(distances, numCullOffsetsLimits)):
cullOff = isceobj.createOffoutliers()
cullOff.wireInputPort(name='offsets', object=refinedOffsets)
cullOff.setSNRThreshold(2.0)
cullOff.setDistance(distance)
#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
stdWriter = create_writer("log", "", True, filename="offoutliers.log")
stdWriter.setFileTag("offoutliers", "log")
stdWriter.setFileTag("offoutliers", "err")
stdWriter.setFileTag("offoutliers", "out")
cullOff.setStdWriter(stdWriter)
#run it
cullOff.offoutliers()
refinedOffsets = cullOff.getRefinedOffsetField()
numLeft = len(refinedOffsets._offsets)
print('Number of offsets left after %2dth culling: %5d' % (i, numLeft))
if numLeft < numCullOffsetsLimit:
refinedOffsets = None
stdWriter.finalize()
return refinedOffsets
def setDefaults(self):
'''
Set up default values.
'''
if (self._xFactor is None) and (self._yFactor is None):
raise Exception('Oversampling factors not defined.')
if self._xFactor and (self._yFactor is None):
print('YFactor not defined. Set same as XFactor.')
self._yFactor = self._xFactor
if self.yFactor and (self.xFactor is None):
print('XFactor not defined. Set same as YFactor.')
self._xFactor = self._yFactor
if (self._xFactor == 1) and (self._yFactor == 1):
raise Exception('No oversampling requested.')
if self._outputFilename is None:
self._outputFilename = self._inputFilename + '_ovs_%d_%d' % (
self._yFactor, self._xFactor)
if (self._width is None) or (self._numberLines is None):
raise Exception('Input Dimensions undefined.')
self._outWidth = (self._width - 1) * self._xFactor + 1
self._outNumberLines = (self._numberLines - 1) * self._yFactor + 1
print(self._outWidth, self._outNumberLines)
if self._stdWriter is None:
self._stdWriter = create_writer("log",
"",
True,
filename="upsampledem.log")
return
def fitOffsets(field):
'''
Estimate constant range and azimith shifs.
'''
stdWriter = create_writer("log","",True,filename='off.log')
for distance in [10,5,3]:
inpts = len(field._offsets)
objOff = isceobj.createOffoutliers()
objOff.wireInputPort(name='offsets', object=field)
objOff.setSNRThreshold(2.0)
objOff.setDistance(distance)
objOff.setStdWriter(stdWriter)
objOff.offoutliers()
field = objOff.getRefinedOffsetField()
outputs = len(field._offsets)
print('%d points left'%(len(field._offsets)))
wt = np.array([x.snr for x in field])
dx = np.array([x.dx for x in field])
dy = np.array([y.dy for y in field])
azshift = np.dot(wt,dy) / np.sum(wt)
rgshift = np.dot(wt,dx) / np.sum(wt)
print('Estimated az shift: ', azshift)
print('Estimated rg shift: ', rgshift)
return (azshift, rgshift), field
distances = (10,5,3,3,3,3,3,3)
numCullOffsetsLimits = (100, 75, 50, 50, 50, 50, 50, 50)
refinedOffsets = offsets
for i, (distance, numCullOffsetsLimit) in enumerate(zip(distances, numCullOffsetsLimits)):
cullOff = isceobj.createOffoutliers()
cullOff.wireInputPort(name='offsets', object=refinedOffsets)
cullOff.setSNRThreshold(2.0)
cullOff.setDistance(distance)
#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
stdWriter = create_writer("log", "", True, filename="offoutliers.log")
stdWriter.setFileTag("offoutliers", "log")
stdWriter.setFileTag("offoutliers", "err")
stdWriter.setFileTag("offoutliers", "out")
cullOff.setStdWriter(stdWriter)
#run it
cullOff.offoutliers()
refinedOffsets = cullOff.getRefinedOffsetField()
numLeft = len(refinedOffsets._offsets)
print('Number of offsets left after %2dth culling: %5d'%(i, numLeft))
if numLeft < numCullOffsetsLimit:
print('******************************************************************')
print('WARNING: There are not enough offsets left, so we are forced to')
####Copy the peg information needed for conversion
pegHavg = copy.copy(iObj.averageHeight)
planet = copy.copy(iObj.planet)
###Copy the orbits
schOrbit = copy.copy(iObj.referenceOrbit)
del iObj
print('Line-by-Line SCH interpolated')
print('Number of state vectors: %d'%len(schOrbit._stateVectors))
print('Time interval: %s %s'%(str(schOrbit._minTime),
str(schOrbit._maxTime)))
######Now convert the original state vectors to SCH coordinates
###stdWriter logging mechanism for some fortran modules
stdWriter = create_writer("log","",True,filename='orb.log')
print('*********************')
orbSch = stdproc.createOrbit2sch(averageHeight=pegHavg)
orbSch.setStdWriter(stdWriter)
orbSch(planet=planet, orbit=origOrbit, peg=peg)
print('*********************')
schOrigOrbit = copy.copy(orbSch.orbit)
del orbSch
print('Original WGS84 vectors to SCH')
print('Number of state vectors: %d'%len(schOrigOrbit._stateVectors))
print('Time interval: %s %s'%(str(schOrigOrbit._minTime),
str(schOrigOrbit._maxTime)))
print(str(schOrigOrbit._stateVectors[0]))
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 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 createStdWriter(self):
from iscesys.StdOEL.StdOELPy import create_writer
self._stdWriter = create_writer("log", "", True,
"insar.log").set_file_tags(
"formslcTSX", "log", "err", "out")
return None
def run(tobeGeocoded,
frame1,
formSLC1,
velocity,
height,
snwe,
infos,
catalog=None,
sceneid='NO_ID'):
logger.info("Geocoding Image: %s" % sceneid)
stdWriter = create_writer("log",
"",
True,
filename=infos['outputPath'] + ".geo.log")
planet = frame1.getInstrument().getPlatform().getPlanet()
doppler = infos['dopplerCentroid'].getDopplerCoefficients(inHz=False)[0]
#####Geocode one by one
for prod in tobeGeocoded:
prodPath = infos['outputPath'] + '.' + prod
if not os.path.isfile(prodPath):
logger.info(
"File not found. Skipping %s" %
prodPath) #KK some prods are only in refScene folder! (tbd)
continue
#else:
objGeo = stdproc.createGeocode('insarapp_geocode_' +
os.path.basename(prod).replace('.', ''))
objGeo.configure()
objGeo.referenceOrbit = formSLC1.getMocompPosition(posIndx)
####IF statements to check for user configuration
if objGeo.minimumLatitude is None:
objGeo.minimumLatitude = snwe[0]
if objGeo.maximumLatitude is None:
objGeo.maximumLatitude = snwe[1]
if objGeo.minimumLongitude is None:
objGeo.minimumLongitude = snwe[2]
if objGeo.maximumLongitude is None:
objGeo.maximumLongitude = snwe[3]
if objGeo.demCropFilename is None:
objGeo.demCropFilename = infos['outputPath'] + '.' + infos[
'demCropFilename']
if objGeo.dopplerCentroidConstantTerm is None:
objGeo.dopplerCentroidConstantTerm = doppler
if objGeo.bodyFixedVelocity is None:
objGeo.bodyFixedVelocity = velocity
if objGeo.spacecraftHeight is None:
objGeo.spacecraftHeight = height
if objGeo.numberRangeLooks is None:
objGeo.numberRangeLooks = infos['numberRangeLooks']
if objGeo.numberAzimuthLooks is None:
objGeo.numberAzimuthLooks = infos['numberAzimuthLooks']
if objGeo.isMocomp is None:
objGeo.isMocomp = infos['is_mocomp']
objGeo.stdWriter = stdWriter
#create the instance of the image and return the method is supposed to use
ge = Geocodable()
inImage, objGeo.method = ge.create(prodPath)
if objGeo.method is None:
objGeo.method = method
if inImage:
demImage = isceobj.createDemImage()
IU.copyAttributes(infos['demImage'], demImage)
objGeo(peg=infos['peg'],
frame=frame1,
planet=planet,
dem=demImage,
tobegeocoded=inImage,
geoPosting=None,
referenceslc=formSLC1)
if catalog is not None:
isceobj.Catalog.recordInputsAndOutputs(
catalog, objGeo, "runGeocode.%s.%s" % (sceneid, prodPath),
logger, "runGeocode.%s.%s" % (sceneid, prodPath))
stdWriter.finalize()
#!/usr/bin/env python3
from __future__ import print_function
import argparse
import isce
from make_raw import makeRawApp
import numpy as np
import os
import itertools
from isceobj.XmlUtil.XmlUtil import XmlUtil
from isceobj.Orbit.Orbit import Orbit, StateVector
from iscesys.StdOEL.StdOELPy import create_writer
#import sarxml
import stdproc
import datetime
stdWriter = create_writer("log", "", True, filename="prepareStack.log")
def pulseTiming(frame):
#From runPulseTiming() in InsarProc
numberOfLines = frame.getNumberOfLines()
prf = frame.getInstrument().getPulseRepetitionFrequency()
pri = 1.0 / prf
startTime = frame.getSensingStart()
orbit = frame.getOrbit()
pulseOrbit = Orbit()
startTimeUTC0 = (
startTime -
datetime.datetime(startTime.year, startTime.month, startTime.day))
timeVec = [
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 runGeocode(self, prodlist, unwrapflag, bbox):
'''Generalized geocoding of all the files listed above.'''
from isceobj.Catalog import recordInputsAndOutputs
logger.info("Geocoding Image")
insar = self.insar
if isinstance(prodlist,str):
from isceobj.Util.StringUtils import StringUtils as SU
tobeGeocoded = SU.listify(prodlist)
else:
tobeGeocoded = prodlist
#remove files that have not been processed
for toGeo in tobeGeocoded:
if not os.path.exists(toGeo):
tobeGeocoded.remove(toGeo)
print('Number of products to geocode: ', len(tobeGeocoded))
stdWriter = create_writer("log", "", True, filename="geo.log")
v,h = insar.vh()
planet = insar.masterFrame._instrument._platform._planet
if bbox is None:
snwe = insar.topo.snwe
else:
snwe = list(bbox)
if len(snwe) != 4:
raise ValueError('Bounding box should be a list/tuple of length 4')
#####Geocode one by one
first = False
ge = Geocodable()
for prod in tobeGeocoded:
objGeo = stdproc.createGeocode('insarapp_geocode_' + os.path.basename(prod).replace('.',''))
objGeo.configure()
####IF statements to check for user configuration
if objGeo.minimumLatitude is None:
objGeo.minimumLatitude = snwe[0]
if objGeo.maximumLatitude is None:
objGeo.maximumLatitude = snwe[1]
if objGeo.minimumLongitude is None:
objGeo.minimumLongitude = snwe[2]
if objGeo.maximumLongitude is None:
objGeo.maximumLongitude = snwe[3]
if objGeo.demCropFilename is None:
objGeo.demCropFilename = insar.demCropFilename
objGeo.referenceOrbit = insar.formSLC1.getMocompPosition(1)
if objGeo.dopplerCentroidConstantTerm is None:
objGeo.dopplerCentroidConstantTerm = insar.dopplerCentroid.getDopplerCoefficients(inHz=False)[0]
if objGeo.bodyFixedVelocity is None:
objGeo.bodyFixedVelocity = v
if objGeo.spacecraftHeight is None:
objGeo.spacecraftHeight = h
if objGeo.numberRangeLooks is None:
objGeo.numberRangeLooks = insar.numberRangeLooks
if objGeo.numberAzimuthLooks is None:
objGeo.numberAzimuthLooks = insar.numberAzimuthLooks
if objGeo.isMocomp is None:
objGeo.isMocomp = insar.is_mocomp
objGeo.stdWriter = stdWriter
#create the instance of the input image and the appropriate
#geocode method
inImage,method = ge.create(prod)
if objGeo.method is None:
objGeo.method = method
if(inImage):
#demImage = isceobj.createDemImage()
#IU.copyAttributes(insar.demImage, demImage)
demImage = insar.demImage.clone()
objGeo(peg=insar.peg, frame=insar.masterFrame,
planet=planet, dem=demImage, tobegeocoded=inImage,
geoPosting=None, masterslc=insar.formSLC1)
recordInputsAndOutputs(self._insar.procDoc, objGeo, "runGeocode",
logger, "runGeocode")
stdWriter.finalize()
