def runBurstIfg(self):
'''Create burst interferograms.
'''
virtual = self.useVirtualFiles
swathList = self._insar.getValidSwathList(self.swaths)
for swath in swathList:
minBurst, maxBurst = self._insar.commonReferenceBurstLimits(swath - 1)
nBurst = maxBurst - minBurst
if nBurst == 0:
continue
ifgdir = os.path.join(self._insar.fineIfgDirname,
'IW{0}'.format(swath))
os.makedirs(ifgdir, exist_ok=True)
####Load relevant products
reference = self._insar.loadProduct(
os.path.join(self._insar.referenceSlcProduct,
'IW{0}.xml'.format(swath)))
secondary = self._insar.loadProduct(
os.path.join(self._insar.fineCoregDirname,
'IW{0}.xml'.format(swath)))
coregdir = os.path.join(self._insar.fineOffsetsDirname,
'IW{0}'.format(swath))
fineIfg = createTOPSSwathSLCProduct()
fineIfg.configure()
for ii in range(minBurst, maxBurst):
jj = ii - minBurst
####Process the top bursts
masBurst = reference.bursts[ii]
slvBurst = secondary.bursts[jj]
referencename = masBurst.image.filename
secondaryname = slvBurst.image.filename
rdict = {
'rangeOff': os.path.join(coregdir,
'range_%02d.off' % (ii + 1)),
'azimuthOff': os.path.join(coregdir,
'azimuth_%02d.off' % (ii + 1))
}
adjustValidLineSample(masBurst, slvBurst)
if self.doInSAR:
intname = os.path.join(ifgdir,
'%s_%02d.int' % ('burst', ii + 1))
fact = 4 * np.pi * slvBurst.rangePixelSize / slvBurst.radarWavelength
intimage = multiply(referencename,
secondaryname,
intname,
rdict['rangeOff'],
fact,
masBurst,
flatten=True,
alks=self.numberAzimuthLooks,
rlks=self.numberRangeLooks,
virtual=virtual)
burst = masBurst.clone()
if self.doInSAR:
burst.image = intimage
fineIfg.bursts.append(burst)
if self.doInSAR:
####Estimate coherence
corname = os.path.join(ifgdir,
'%s_%02d.cor' % ('burst', ii + 1))
computeCoherence(referencename, secondaryname, corname)
fineIfg.numberOfBursts = len(fineIfg.bursts)
self._insar.saveProduct(
fineIfg,
os.path.join(self._insar.fineIfgDirname,
'IW{0}.xml'.format(swath)))
def runSubsetOverlaps(self):
'''
Create geometry files corresponding to burst overlaps.
'''
virtual = self.useVirtualFiles
if not self.doESD:
return
catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name)
swathList = self._insar.getValidSwathList(self.swaths)
for swath in swathList:
if self._insar.numberOfCommonBursts[swath - 1] < 2:
print('Skipping subset overlap for swath IW{0}'.format(swath))
continue
####Load master metadata
mFrame = self._insar.loadProduct(
os.path.join(self._insar.masterSlcProduct,
'IW{0}.xml'.format(swath)))
####Output directory for overlap geometry images
geomdir = os.path.join(self._insar.geometryDirname,
'IW{0}'.format(swath))
outdir = os.path.join(self._insar.geometryDirname,
self._insar.overlapsSubDirname,
'IW{0}'.format(swath))
submasterdir = os.path.join(self._insar.masterSlcProduct,
self._insar.overlapsSubDirname,
'IW{0}'.format(swath))
os.makedirs(outdir, exist_ok=True)
os.makedirs(submasterdir, exist_ok=True)
###Azimuth time interval
dt = mFrame.bursts[0].azimuthTimeInterval
topFrame = createTOPSSwathSLCProduct()
topFrame.configure()
bottomFrame = createTOPSSwathSLCProduct()
bottomFrame.configure()
numCommon = self._insar.numberOfCommonBursts[swath - 1]
startIndex = self._insar.commonBurstStartMasterIndex[swath - 1]
###For each overlap
for ii in range(numCommon - 1):
ind = ii + startIndex
topBurst = mFrame.bursts[ind]
botBurst = mFrame.bursts[ind + 1]
overlap_start_time = botBurst.sensingStart
overlap_end_time = topBurst.sensingStop
catalog.addItem(
'Overlap {0} start time - IW-{1}'.format(ind, swath),
overlap_start_time, 'subset')
catalog.addItem(
'Overlap {0} stop time - IW-{1}'.format(ind, swath),
overlap_end_time, 'subset')
nLinesOverlap = int(
np.round(
(overlap_end_time - overlap_start_time).total_seconds() /
dt)) + 1
catalog.addItem(
'Overlap {0} number of lines - IW-{1}'.format(ind, swath),
nLinesOverlap, 'subset')
length = topBurst.numberOfLines
width = topBurst.numberOfSamples
topStart = int(
np.round((botBurst.sensingStart - topBurst.sensingStart
).total_seconds() / dt)) + botBurst.firstValidLine
overlapLen = topBurst.firstValidLine + topBurst.numValidLines - topStart
catalog.addItem(
'Overlap {0} number of valid lines - IW-{1}'.format(
ind, swath), overlapLen, 'subset')
###Create slice objects for overlaps
topslicey = slice(topStart, topStart + overlapLen)
topslicex = slice(0, width)
botslicey = slice(botBurst.firstValidLine,
botBurst.firstValidLine + overlapLen)
botslicex = slice(0, width)
for prefix in ['lat', 'lon', 'hgt']:
infile = os.path.join(geomdir,
prefix + '_%02d.rdr' % (ind + 2))
outfile = os.path.join(
outdir, prefix + '_%02d_%02d.rdr' % (ind + 1, ind + 2))
subset(infile, outfile, botslicey, botslicex, virtual=virtual)
masname1 = topBurst.image.filename
masname2 = botBurst.image.filename
master_outname1 = os.path.join(
submasterdir, 'burst_top_%02d_%02d.slc' % (ind + 1, ind + 2))
master_outname2 = os.path.join(
submasterdir, 'burst_bot_%02d_%02d.slc' % (ind + 1, ind + 2))
subset(masname1,
master_outname1,
topslicey,
topslicex,
virtual=virtual)
subset(masname2,
master_outname2,
botslicey,
botslicex,
virtual=virtual)
####TOP frame
# burst = copy.deepcopy(topBurst)
burst = topBurst.clone()
burst.firstValidLine = 0
burst.numberOfLines = overlapLen
burst.numValidLines = overlapLen
burst.sensingStart = topBurst.sensingStart + datetime.timedelta(
0, topStart * dt) # topStart*dt
burst.sensingStop = topBurst.sensingStart + datetime.timedelta(
0,
(topStart + overlapLen - 1) * dt) # (topStart+overlapLen-1)*dt
###Replace file name in image
burst.image.filename = master_outname1
burst.image._accessor = None
burst.image.setLength(overlapLen)
burst.image.setWidth(width)
topFrame.bursts.append(burst)
burst = None
####BOTTOM frame
# burst = copy.deepcopy(botBurst)
burst = botBurst.clone()
burst.firstValidLine = 0
burst.numberOfLines = overlapLen
burst.numValidLines = overlapLen
burst.sensingStart = botBurst.sensingStart + datetime.timedelta(
seconds=botBurst.firstValidLine * dt)
burst.sensingStop = botBurst.sensingStart + datetime.timedelta(
seconds=(botBurst.firstValidLine + overlapLen - 1) * dt)
###Replace file name in image
burst.image.filename = master_outname2
burst.image.setLength(overlapLen)
burst.image.setWidth(width)
bottomFrame.bursts.append(burst)
burst = None
print('Top: ', [x.image.filename for x in topFrame.bursts])
print('Bottom: ', [x.image.filename for x in bottomFrame.bursts])
topFrame.numberOfBursts = len(topFrame.bursts)
bottomFrame.numberOfBursts = len(bottomFrame.bursts)
self._insar.saveProduct(
topFrame,
os.path.join(self._insar.masterSlcOverlapProduct,
'top_IW{0}.xml'.format(swath)))
self._insar.saveProduct(
bottomFrame,
os.path.join(self._insar.masterSlcOverlapProduct,
'bottom_IW{0}.xml'.format(swath)))
catalog.printToLog(logger, "runSubsetOverlaps")
self._insar.procDoc.addAllFromCatalog(catalog)
def runCoarseResamp(self):
'''
Create coregistered overlap slaves.
'''
if not self.doESD:
return
swathList = self._insar.getValidSwathList(self.swaths)
for swath in swathList:
if self._insar.numberOfCommonBursts[swath - 1] < 2:
print('Skipping coarse resamp for swath IW{0}'.format(swath))
continue
####Load slave metadata
master = self._insar.loadProduct(
os.path.join(self._insar.masterSlcProduct,
'IW{0}.xml'.format(swath)))
slave = self._insar.loadProduct(
os.path.join(self._insar.slaveSlcProduct,
'IW{0}.xml'.format(swath)))
masterTop = self._insar.loadProduct(
os.path.join(self._insar.masterSlcOverlapProduct,
'top_IW{0}.xml'.format(swath)))
masterBottom = self._insar.loadProduct(
os.path.join(self._insar.masterSlcOverlapProduct,
'bottom_IW{0}.xml'.format(swath)))
dt = slave.bursts[0].azimuthTimeInterval
dr = slave.bursts[0].rangePixelSize
###Output directory for coregistered SLCs
outdir = os.path.join(self._insar.coarseCoregDirname,
self._insar.overlapsSubDirname,
'IW{0}'.format(swath))
if not os.path.isdir(outdir):
os.makedirs(outdir)
###Directory with offsets
offdir = os.path.join(self._insar.coarseOffsetsDirname,
self._insar.overlapsSubDirname,
'IW{0}'.format(swath))
####Indices w.r.t master
minBurst, maxBurst = self._insar.commonMasterBurstLimits(swath - 1)
slaveBurstStart, slaveBurstEnd = self._insar.commonSlaveBurstLimits(
swath - 1)
relShifts = getRelativeShifts(master, slave, minBurst, maxBurst,
slaveBurstStart)
maxBurst = maxBurst - 1 ###For overlaps
print('Shifts for swath IW-{0}: {1}'.format(swath, relShifts))
####Can corporate known misregistration here
apoly = Poly2D()
apoly.initPoly(rangeOrder=0, azimuthOrder=0, coeffs=[[0.]])
rpoly = Poly2D()
rpoly.initPoly(rangeOrder=0, azimuthOrder=0, coeffs=[[0.]])
topCoreg = createTOPSSwathSLCProduct()
topCoreg.configure()
botCoreg = createTOPSSwathSLCProduct()
botCoreg.configure()
for ii in range(minBurst, maxBurst):
jj = slaveBurstStart + ii - minBurst
topBurst = masterTop.bursts[ii - minBurst]
botBurst = masterBottom.bursts[ii - minBurst]
slvBurst = slave.bursts[jj]
#####Top burst processing
try:
offset = relShifts[jj]
except:
raise Exception(
'Trying to access shift for slave burst index {0}, which may not overlap with master - IW-{1}'
.format(jj, swath))
outname = os.path.join(
outdir, 'burst_top_%02d_%02d.slc' % (ii + 1, ii + 2))
####Setup initial polynomials
### If no misregs are given, these are zero
### If provided, can be used for resampling without running to geo2rdr again for fast results
rdict = {
'azpoly':
apoly,
'rgpoly':
rpoly,
'rangeOff':
os.path.join(offdir,
'range_top_%02d_%02d.off' % (ii + 1, ii + 2)),
'azimuthOff':
os.path.join(offdir,
'azimuth_top_%02d_%02d.off' % (ii + 1, ii + 2))
}
###For future - should account for azimuth and range misreg here .. ignoring for now.
azCarrPoly, dpoly = slave.estimateAzimuthCarrierPolynomials(
slvBurst, offset=-1.0 * offset)
rdict['carrPoly'] = azCarrPoly
rdict['doppPoly'] = dpoly
outimg = resampSlave(topBurst, slvBurst, rdict, outname)
copyBurst = copy.deepcopy(topBurst)
adjustValidSampleLine(copyBurst, slvBurst)
copyBurst.image.filename = outimg.filename
print('After: ', copyBurst.firstValidLine, copyBurst.numValidLines)
topCoreg.bursts.append(copyBurst)
#######################################################
slvBurst = slave.bursts[jj + 1]
outname = os.path.join(
outdir, 'burst_bot_%02d_%02d.slc' % (ii + 1, ii + 2))
####Setup initial polynomials
### If no misregs are given, these are zero
### If provided, can be used for resampling without running to geo2rdr again for fast results
rdict = {
'azpoly':
apoly,
'rgpoly':
rpoly,
'rangeOff':
os.path.join(offdir,
'range_bot_%02d_%02d.off' % (ii + 1, ii + 2)),
'azimuthOff':
os.path.join(offdir,
'azimuth_bot_%02d_%02d.off' % (ii + 1, ii + 2))
}
azCarrPoly, dpoly = slave.estimateAzimuthCarrierPolynomials(
slvBurst, offset=-1.0 * offset)
rdict['carrPoly'] = azCarrPoly
rdict['doppPoly'] = dpoly
outimg = resampSlave(botBurst, slvBurst, rdict, outname)
copyBurst = copy.deepcopy(botBurst)
adjustValidSampleLine(copyBurst, slvBurst)
copyBurst.image.filename = outimg.filename
print('After: ', copyBurst.firstValidLine, copyBurst.numValidLines)
botCoreg.bursts.append(copyBurst)
#######################################################
topCoreg.numberOfBursts = len(topCoreg.bursts)
botCoreg.numberOfBursts = len(botCoreg.bursts)
self._insar.saveProduct(
topCoreg,
os.path.join(self._insar.coregOverlapProduct,
'top_IW{0}.xml'.format(swath)))
self._insar.saveProduct(
botCoreg,
os.path.join(self._insar.coregOverlapProduct,
'bottom_IW{0}.xml'.format(swath)))
def runFineResamp(self):
'''
Create coregistered overlap slaves.
'''
swathList = self._insar.getValidSwathList(self.swaths)
for swath in swathList:
####Load slave metadata
master = self._insar.loadProduct( os.path.join(self._insar.masterSlcProduct, 'IW{0}.xml'.format(swath)))
slave = self._insar.loadProduct( os.path.join(self._insar.slaveSlcProduct, 'IW{0}.xml'.format(swath)))
dt = slave.bursts[0].azimuthTimeInterval
dr = slave.bursts[0].rangePixelSize
###Output directory for coregistered SLCs
outdir = os.path.join(self._insar.fineCoregDirname, 'IW{0}'.format(swath))
if not os.path.isdir(outdir):
os.makedirs(outdir)
###Directory with offsets
offdir = os.path.join(self._insar.fineOffsetsDirname, 'IW{0}'.format(swath))
####Indices w.r.t master
minBurst, maxBurst = self._insar.commonMasterBurstLimits(swath-1)
slaveBurstStart, slaveBurstEnd = self._insar.commonSlaveBurstLimits(swath-1)
if minBurst == maxBurst:
print('Skipping processing of swath {0}'.format(swath))
continue
relShifts = getRelativeShifts(master, slave, minBurst, maxBurst, slaveBurstStart)
print('Shifts IW-{0}: '.format(swath), relShifts)
####Can corporate known misregistration here
apoly = Poly2D()
apoly.initPoly(rangeOrder=0,azimuthOrder=0,coeffs=[[0.]])
rpoly = Poly2D()
rpoly.initPoly(rangeOrder=0,azimuthOrder=0,coeffs=[[0.]])
misreg_az = self._insar.slaveTimingCorrection / dt
misreg_rg = self._insar.slaveRangeCorrection / dr
coreg = createTOPSSwathSLCProduct()
coreg.configure()
for ii in range(minBurst, maxBurst):
jj = slaveBurstStart + ii - minBurst
masBurst = master.bursts[ii]
slvBurst = slave.bursts[jj]
try:
offset = relShifts[jj]
except:
raise Exception('Trying to access shift for slave burst index {0}, which may not overlap with master for swath {1}'.format(jj, swath))
outname = os.path.join(outdir, 'burst_%02d.slc'%(ii+1))
####Setup initial polynomials
### If no misregs are given, these are zero
### If provided, can be used for resampling without running to geo2rdr again for fast results
rdict = {'azpoly' : apoly,
'rgpoly' : rpoly,
'rangeOff' : os.path.join(offdir, 'range_%02d.off'%(ii+1)),
'azimuthOff': os.path.join(offdir, 'azimuth_%02d.off'%(ii+1))}
###For future - should account for azimuth and range misreg here .. ignoring for now.
azCarrPoly, dpoly = slave.estimateAzimuthCarrierPolynomials(slvBurst, offset = -1.0 * offset)
rdict['carrPoly'] = azCarrPoly
rdict['doppPoly'] = dpoly
outimg = resampSlave(masBurst, slvBurst, rdict, outname)
minAz, maxAz, minRg, maxRg = getValidLines(slvBurst, rdict, outname,
misreg_az = misreg_az - offset, misreg_rng = misreg_rg)
# copyBurst = copy.deepcopy(masBurst)
copyBurst = masBurst.clone()
adjustValidSampleLine(copyBurst, slvBurst,
minAz=minAz, maxAz=maxAz,
minRng=minRg, maxRng=maxRg)
copyBurst.image.filename = outimg.filename
print('After: ', copyBurst.firstValidLine, copyBurst.numValidLines)
coreg.bursts.append(copyBurst)
#######################################################
coreg.numberOfBursts = len(coreg.bursts)
self._insar.saveProduct(coreg, os.path.join(self._insar.fineCoregDirname, 'IW{0}.xml'.format(swath)))
def runOverlapIfg(self):
'''Create overlap interferograms.
'''
virtual = self.useVirtualFiles
if not self.doESD:
return
swathList = self._insar.getValidSwathList(self.swaths)
for swath in swathList:
if self._insar.numberOfCommonBursts[swath-1] < 2:
print('Skipping overlap ifg for swath IW{0}'.format(swath))
continue
minBurst = self._insar.commonBurstStartMasterIndex[swath-1]
maxBurst = minBurst + self._insar.numberOfCommonBursts[swath-1]
nBurst = maxBurst - minBurst
ifgdir = os.path.join( self._insar.coarseIfgDirname, self._insar.overlapsSubDirname, 'IW{0}'.format(swath))
if not os.path.exists(ifgdir):
os.makedirs(ifgdir)
####All indexing is w.r.t stack master for overlaps
maxBurst = maxBurst - 1
####Load relevant products
topMaster = self._insar.loadProduct(os.path.join(self._insar.masterSlcOverlapProduct, 'top_IW{0}.xml'.format(swath)))
botMaster = self._insar.loadProduct(os.path.join(self._insar.masterSlcOverlapProduct, 'bottom_IW{0}.xml'.format(swath)))
topCoreg = self._insar.loadProduct( os.path.join(self._insar.coregOverlapProduct,'top_IW{0}.xml'.format(swath)))
botCoreg = self._insar.loadProduct( os.path.join(self._insar.coregOverlapProduct, 'bottom_IW{0}.xml'.format(swath)))
coregdir = os.path.join(self._insar.coarseOffsetsDirname, self._insar.overlapsSubDirname, 'IW{0}'.format(swath))
topIfg = createTOPSSwathSLCProduct()
topIfg.configure()
botIfg = createTOPSSwathSLCProduct()
botIfg.configure()
for ii in range(minBurst, maxBurst):
jj = ii - minBurst
####Process the top bursts
master = topMaster.bursts[jj]
slave = topCoreg.bursts[jj]
mastername = master.image.filename
slavename = slave.image.filename
rdict = {'rangeOff' : os.path.join(coregdir, 'range_top_%02d_%02d.off'%(ii+1,ii+2)),
'azimuthOff': os.path.join(coregdir, 'azimuth_top_%02d_%02d.off'%(ii+1,ii+2))}
adjustValidLineSample(master,slave)
intname = os.path.join(ifgdir, '%s_top_%02d_%02d.int'%('burst',ii+1,ii+2))
fact = 4 * np.pi * slave.rangePixelSize / slave.radarWavelength
intimage = multiply(mastername, slavename, intname,
rdict['rangeOff'], fact, master, flatten=True,
alks = self.numberAzimuthLooks, rlks=self.numberRangeLooks)
burst = copy.deepcopy(master)
burst.image = intimage
topIfg.bursts.append(burst)
####Process the bottom bursts
master = botMaster.bursts[jj]
slave = botCoreg.bursts[jj]
mastername = master.image.filename
slavename = slave.image.filename
rdict = {'rangeOff' : os.path.join(coregdir, 'range_bot_%02d_%02d.off'%(ii+1,ii+2)),
'azimuthOff': os.path.join(coregdir, 'azimuth_bot_%02d_%02d.off'%(ii+1,ii+2))}
adjustValidLineSample(master,slave)
intname = os.path.join(ifgdir, '%s_bot_%02d_%02d.int'%('burst',ii+1,ii+2))
fact = 4 * np.pi * slave.rangePixelSize / slave.radarWavelength
intimage = multiply(mastername, slavename, intname,
rdict['rangeOff'], fact, master, flatten=True,
alks = self.numberAzimuthLooks, rlks=self.numberRangeLooks,
virtual=virtual)
burst = copy.deepcopy(master)
burst.image = intimage
botIfg.bursts.append(burst)
topIfg.numberOfBursts = len(topIfg.bursts)
botIfg.numberOfBursts = len(botIfg.bursts)
self._insar.saveProduct(topIfg, os.path.join(self._insar.coarseIfgOverlapProduct, 'top_IW{0}.xml'.format(swath)))
self._insar.saveProduct(botIfg, os.path.join(self._insar.coarseIfgOverlapProduct, 'bottom_IW{0}.xml'.format(swath)))
def main(iargs=None):
'''
check overlap among all acquistions, only keep the bursts that in the common overlap,
and then renumber the bursts.
'''
inps = cmdLineParse(iargs)
referenceDir = inps.reference
secondaryDir = sorted(glob.glob(os.path.join(inps.secondarys, '*')))
acquistionDir = [referenceDir] + secondaryDir
invalidSwath = []
for i in [1, 2, 3]:
for x in acquistionDir:
if not (os.path.isdir(os.path.join(x, 'IW{}'.format(i))) and os.path.isfile(os.path.join(x, 'IW{}.xml'.format(i)))):
invalidSwath.append(i)
break
if invalidSwath == [1, 2, 3]:
raise Exception('there are no common swaths among the acquistions')
else:
validSwath = [i for i in [1, 2, 3] if i not in invalidSwath]
print('valid swath from scanning acquistion directory: {}'.format(validSwath))
invalidSwath2 = []
for swath in validSwath:
referenceSwath = ut.loadProduct(os.path.join(referenceDir, 'IW{0}.xml'.format(swath)))
burstoffsetAll = []
minBurstAll = []
maxBurstAll = []
secondarySwathAll = []
for secondaryDirX in secondaryDir:
secondarySwath = ut.loadProduct(os.path.join(secondaryDirX, 'IW{0}.xml'.format(swath)))
secondarySwathAll.append(secondarySwath)
burstoffset, minBurst, maxBurst = referenceSwath.getCommonBurstLimits(secondarySwath)
burstoffsetAll.append(burstoffset)
minBurstAll.append(minBurst)
maxBurstAll.append(maxBurst)
minBurst = max(minBurstAll)
maxBurst = min(maxBurstAll)
numBurst = maxBurst - minBurst
if minBurst >= maxBurst:
invalidSwath2.append(swath)
else:
#add reference
swathAll = [referenceSwath] + secondarySwathAll
burstoffsetAll = [0] + burstoffsetAll
for dirx, swathx, burstoffsetx in zip(acquistionDir, swathAll, burstoffsetAll):
swathTmp = createTOPSSwathSLCProduct()
swathTmp.configure()
#change reserved burst properties and remove non-overlap bursts
for jj in range(len(swathx.bursts)):
ii = jj - burstoffsetx
#burstFileName = os.path.join(os.path.abspath(dirx), 'IW{}'.format(swath), os.path.basename(swathx.bursts[jj].image.filename))
burstFileName = os.path.join(os.path.abspath(dirx), 'IW{}'.format(swath), 'burst_%02d'%(jj+1) + '.slc')
if minBurst <= ii < maxBurst:
kk = ii - minBurst
#change burst properties
swathx.bursts[jj].burstNumber = kk + 1
swathx.bursts[jj].image.filename = os.path.join(os.path.dirname(swathx.bursts[jj].image.filename), 'burst_%02d'%(kk+1) + '.slc')
swathTmp.bursts.append(swathx.bursts[jj])
else:
#remove non-overlap bursts
#os.remove(burstFileName)
os.remove(burstFileName+'.vrt')
os.remove(burstFileName+'.xml')
#remove geometry files accordingly if provided
if dirx == referenceDir:
if inps.geom_reference is not None:
for fileType in ['hgt', 'incLocal', 'lat', 'lon', 'los', 'shadowMask']:
geomFileName = os.path.join(os.path.abspath(inps.geom_reference), 'IW{}'.format(swath), fileType + '_%02d'%(jj+1) + '.rdr')
os.remove(geomFileName)
os.remove(geomFileName+'.vrt')
os.remove(geomFileName+'.xml')
#change reserved burst file names
for jj in range(len(swathx.bursts)):
ii = jj - burstoffsetx
#burstFileName = os.path.join(os.path.abspath(dirx), 'IW{}'.format(swath), os.path.basename(swathx.bursts[jj].image.filename))
burstFileName = os.path.join(os.path.abspath(dirx), 'IW{}'.format(swath), 'burst_%02d'%(jj+1) + '.slc')
if minBurst <= ii < maxBurst:
kk = ii - minBurst
burstFileNameNew = os.path.join(os.path.abspath(dirx), 'IW{}'.format(swath), 'burst_%02d'%(kk+1) + '.slc')
if burstFileName != burstFileNameNew:
img = isceobj.createImage()
img.load(burstFileName + '.xml')
img.setFilename(burstFileNameNew)
#img.extraFilename = burstFileNameNew+'.vrt'
img.renderHdr()
#still use original vrt
os.remove(burstFileName+'.xml')
os.remove(burstFileNameNew+'.vrt')
os.rename(burstFileName+'.vrt', burstFileNameNew+'.vrt')
#change geometry file names accordingly if provided
if dirx == referenceDir:
if inps.geom_reference is not None:
for fileType in ['hgt', 'incLocal', 'lat', 'lon', 'los', 'shadowMask']:
geomFileName = os.path.join(os.path.abspath(inps.geom_reference), 'IW{}'.format(swath), fileType + '_%02d'%(jj+1) + '.rdr')
geomFileNameNew = os.path.join(os.path.abspath(inps.geom_reference), 'IW{}'.format(swath), fileType + '_%02d'%(kk+1) + '.rdr')
if geomFileName != geomFileNameNew:
renameFile(geomFileName, geomFileNameNew)
#change swath properties
swathx.bursts = swathTmp.bursts
swathx.numberOfBursts = numBurst
#remove original and write new
os.remove( os.path.join(dirx, 'IW{}.xml'.format(swath)) )
ut.saveProduct(swathx, os.path.join(dirx, 'IW{}.xml'.format(swath)))
#remove invalid swaths
invalidSwath3 = list(sorted(set(invalidSwath+invalidSwath2)))
for swath in invalidSwath3:
for dirx in acquistionDir:
iwdir = os.path.join(dirx, 'IW{}'.format(swath))
iwxml = os.path.join(dirx, 'IW{}.xml'.format(swath))
if os.path.isdir(iwdir):
shutil.rmtree(iwdir)
if os.path.isfile(iwxml):
os.remove(iwxml)
