def resampSlave(mas, slv, rdict, outname ):
'''
Resample burst by burst.
'''
azpoly = rdict['azpoly']
rgpoly = rdict['rgpoly']
azcarrpoly = rdict['carrPoly']
dpoly = rdict['doppPoly']
rngImg = isceobj.createImage()
rngImg.load(rdict['rangeOff'] + '.xml')
rngImg.setAccessMode('READ')
aziImg = isceobj.createImage()
aziImg.load(rdict['azimuthOff'] + '.xml')
aziImg.setAccessMode('READ')
inimg = isceobj.createSlcImage()
inimg.load(slv.image.filename + '.xml')
inimg.setAccessMode('READ')
rObj = stdproc.createResamp_slc()
rObj.slantRangePixelSpacing = slv.rangePixelSize
rObj.radarWavelength = slv.radarWavelength
rObj.azimuthCarrierPoly = azcarrpoly
rObj.dopplerPoly = dpoly
rObj.azimuthOffsetsPoly = azpoly
rObj.rangeOffsetsPoly = rgpoly
rObj.imageIn = inimg
####Setting reference values
rObj.startingRange = slv.startingRange
rObj.referenceSlantRangePixelSpacing = mas.rangePixelSize
rObj.referenceStartingRange = mas.startingRange
rObj.referenceWavelength = mas.radarWavelength
width = mas.numberOfSamples
length = mas.numberOfLines
imgOut = isceobj.createSlcImage()
imgOut.setWidth(width)
imgOut.filename = outname
imgOut.setAccessMode('write')
rObj.outputWidth = width
rObj.outputLines = length
rObj.residualRangeImage = rngImg
rObj.residualAzimuthImage = aziImg
rObj.resamp_slc(imageOut=imgOut)
imgOut.renderHdr()
return imgOut
def estimateOffsetField(reference, secondary, inps=None):
'''
Estimate offset field between burst and simamp.
'''
###Loading the secondary image object
sim = isceobj.createSlcImage()
sim.load(secondary+'.xml')
sim.setAccessMode('READ')
sim.createImage()
###Loading the reference image object
sar = isceobj.createSlcImage()
sar.load(reference + '.xml')
sar.setAccessMode('READ')
sar.createImage()
width = sar.getWidth()
length = sar.getLength()
objOffset = DenseAmpcor(name='dense')
objOffset.configure()
# objOffset.numberThreads = 6
objOffset.setWindowSizeWidth(inps.winwidth)
objOffset.setWindowSizeHeight(inps.winhgt)
objOffset.setSearchWindowSizeWidth(inps.srcwidth)
objOffset.setSearchWindowSizeHeight(inps.srchgt)
objOffset.skipSampleAcross = inps.skipwidth
objOffset.skipSampleDown = inps.skiphgt
objOffset.margin = inps.margin
objOffset.oversamplingFactor = inps.oversample
objOffset.setAcrossGrossOffset(inps.rgshift)
objOffset.setDownGrossOffset(inps.azshift)
objOffset.setFirstPRF(1.0)
objOffset.setSecondPRF(1.0)
if sar.dataType.startswith('C'):
objOffset.setImageDataType1('mag')
else:
objOffset.setImageDataType1('real')
if sim.dataType.startswith('C'):
objOffset.setImageDataType2('mag')
else:
objOffset.setImageDataType2('real')
objOffset.offsetImageName = inps.outprefix + '.bil'
objOffset.snrImageName = inps.outprefix +'_snr.bil'
objOffset.denseampcor(sar, sim)
sar.finalizeImage()
sim.finalizeImage()
return objOffset
def generateIgram(imageSlc1, imageSlc2, resampName, azLooks, rgLooks):
objSlc1 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc1, objSlc1)
objSlc1.setAccessMode('read')
objSlc1.createImage()
objSlc2 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc2, objSlc2)
objSlc2.setAccessMode('read')
objSlc2.createImage()
slcWidth = imageSlc1.getWidth()
intWidth = int(slcWidth / rgLooks)
lines = min(imageSlc1.getLength(), imageSlc2.getLength())
if '.flat' in resampName:
resampAmp = resampName.replace('.flat', '.amp')
elif '.int' in resampName:
resampAmp = resampName.replace('.int', '.amp')
else:
resampAmp += '.amp'
resampInt = resampName
objInt = isceobj.createIntImage()
objInt.setFilename(resampInt)
objInt.setWidth(intWidth)
imageInt = isceobj.createIntImage()
IU.copyAttributes(objInt, imageInt)
objInt.setAccessMode('write')
objInt.createImage()
objAmp = isceobj.createAmpImage()
objAmp.setFilename(resampAmp)
objAmp.setWidth(intWidth)
imageAmp = isceobj.createAmpImage()
IU.copyAttributes(objAmp, imageAmp)
objAmp.setAccessMode('write')
objAmp.createImage()
objCrossmul = crossmul.createcrossmul()
objCrossmul.width = slcWidth
objCrossmul.length = lines
objCrossmul.LooksDown = azLooks
objCrossmul.LooksAcross = rgLooks
objCrossmul.crossmul(objSlc1, objSlc2, objInt, objAmp)
for obj in [objInt, objAmp, objSlc1, objSlc2]:
obj.finalizeImage()
return imageInt, imageAmp
def resampSecondary(reference, burst, doppler, azpoly, flatten=False):
'''
Resample burst by burst.
'''
inimg = isceobj.createSlcImage()
base = os.path.basename(reference)
inimg.load(os.path.join(reference, base + '_orig.slc.xml'))
inimg.setAccessMode('READ')
width = inimg.getWidth()
length = inimg.getLength()
prf = burst.getInstrument().getPulseRepetitionFrequency()
coeffs = [2 * np.pi * val / prf for val in doppler._coeffs]
zcoeffs = [0. for val in coeffs]
dpoly = Poly2D()
dpoly.initPoly(rangeOrder=doppler._order,
azimuthOrder=1,
coeffs=[zcoeffs, coeffs])
apoly = Poly2D()
apoly.setMeanRange(azpoly._mean)
apoly.setNormRange(azpoly._norm)
apoly.initPoly(rangeOrder=azpoly._order,
azimuthOrder=0,
coeffs=[azpoly._coeffs])
print('Shifts: ', apoly(1, 1), apoly(10240, 10240))
rObj = stdproc.createResamp_slc()
rObj.slantRangePixelSpacing = burst.getInstrument().getRangePixelSize()
rObj.radarWavelength = burst.getInstrument().getRadarWavelength()
rObj.azimuthCarrierPoly = dpoly
rObj.azimuthOffsetsPoly = apoly
rObj.imageIn = inimg
imgOut = isceobj.createSlcImage()
imgOut.setWidth(width)
imgOut.filename = os.path.join(reference, base + '.slc')
imgOut.setAccessMode('write')
rObj.flatten = flatten
rObj.outputWidth = width
rObj.outputLines = length
rObj.resamp_slc(imageOut=imgOut)
imgOut.renderHdr()
return imgOut
def resampSecondary(ref, sec, rdict, outname, flatten):
'''
Resample burst by burst.
'''
azpoly = rdict['azpoly']
rgpoly = rdict['rgpoly']
azcarrpoly = rdict['carrPoly']
dpoly = rdict['doppPoly']
rngImg = isceobj.createImage()
rngImg.load(rdict['rangeOff'] + '.xml')
rngImg.setAccessMode('READ')
aziImg = isceobj.createImage()
aziImg.load(rdict['azimuthOff'] + '.xml')
aziImg.setAccessMode('READ')
inimg = isceobj.createSlcImage()
inimg.load(sec.image.filename + '.xml')
inimg.setAccessMode('READ')
rObj = stdproc.createResamp_slc()
rObj.slantRangePixelSpacing = sec.rangePixelSize
rObj.radarWavelength = sec.radarWavelength
rObj.azimuthCarrierPoly = azcarrpoly
rObj.dopplerPoly = dpoly
rObj.azimuthOffsetsPoly = azpoly
rObj.rangeOffsetsPoly = rgpoly
rObj.imageIn = inimg
width = ref.numberOfSamples
length = ref.numberOfLines
imgOut = isceobj.createSlcImage()
imgOut.setWidth(width)
imgOut.filename = outname
imgOut.setAccessMode('write')
rObj.outputWidth = width
rObj.outputLines = length
rObj.residualRangeImage = rngImg
rObj.residualAzimuthImage = aziImg
rObj.flatten = flatten
print(rObj.flatten)
rObj.resamp_slc(imageOut=imgOut)
imgOut.renderHdr()
imgOut.renderVRT()
return imgOut
def run(imageSlc1, imageSlc2, resampName, azLooks, rgLooks):
objSlc1 = isceobj.createSlcImage()
#right now imageSlc1 and 2 are just text files, need to open them as image
IU.copyAttributes(imageSlc1, objSlc1)
objSlc1.setAccessMode('read')
objSlc1.createImage()
objSlc2 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc2, objSlc2)
objSlc2.setAccessMode('read')
objSlc2.createImage()
slcWidth = imageSlc1.getWidth()
intWidth = int(slcWidth / rgLooks)
lines = min(imageSlc1.getLength(), imageSlc2.getLength())
resampAmp = resampName + '.amp'
resampInt = resampName + '.int'
objInt = isceobj.createIntImage()
objInt.setFilename(resampInt)
objInt.setWidth(intWidth)
imageInt = isceobj.createIntImage()
IU.copyAttributes(objInt, imageInt)
objInt.setAccessMode('write')
objInt.createImage()
objAmp = isceobj.createAmpImage()
objAmp.setFilename(resampAmp)
objAmp.setWidth(intWidth)
imageAmp = isceobj.createAmpImage()
IU.copyAttributes(objAmp, imageAmp)
objAmp.setAccessMode('write')
objAmp.createImage()
objCrossmul = crossmul.createcrossmul()
objCrossmul.width = slcWidth
objCrossmul.length = lines
objCrossmul.LooksDown = azLooks
objCrossmul.LooksAcross = rgLooks
objCrossmul.crossmul(objSlc1, objSlc2, objInt, objAmp)
for obj in [objInt, objAmp, objSlc1, objSlc2]:
obj.finalizeImage()
return imageInt, imageAmp
def runFormSLC(self, patchSize=None, goodLines=None, numPatches=None):
#NOTE tested the formslc() as a stand alone by passing the same inputs
#computed in Howard terraSAR.py. The differences here arises from the
#differences in the orbits when using the same orbits the results are very
#close jng this will make the second term in coarseAz in offsetprf equal
#zero. we do so since for tsx there is no such a term. Need to ask
#confirmation
self.insar.setPatchSize(self.insar.numberValidPulses)
# the below value is zero because of we just did above, but just want to be
# explicit in the definition of is_mocomp
imageSlc1 = self.insar.masterRawImage
imSlc1 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc1, imSlc1)
imSlc1.setAccessMode('read')
imSlc1.createImage()
formSlc1 = FormSLC()
formSlc1.configure()
formSlc1.slcWidth = imSlc1.getWidth()
formSlc1.startingRange = self.insar.masterFrame.startingRange
formSlc1.sensingStart = self.insar.masterFrame.sensingStart
formSlc1.rangeChirpExtensionPoints = 0
self.insar.formSLC1 = formSlc1
self.insar.masterSlcImage = imSlc1
imageSlc2 = self.insar.slaveRawImage
imSlc2 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc2, imSlc2)
imSlc2.setAccessMode('read')
imSlc2.createImage()
formSlc2 = stdproc.createFormSLC()
formSlc2.slcWidth = imSlc2.getWidth()
formSlc2.startingRange = self.insar.slaveFrame.startingRange
formSlc2.sensingStart = self.insar.slaveFrame.sensingStart
formSlc2.rangeChirpExtensionPoints = 0
self.insar.setNumberPatches(
imSlc1.getLength()/float(self.insar.numberValidPulses)
)
imSlc1.finalizeImage()
imSlc2.finalizeImage()
self.insar.setFormSLC1(formSlc1)
self.insar.setFormSLC2(formSlc2)
def extractImage(self):
import numpy as np
import h5py
self.parse()
fid = h5py.File(self.hdf5, 'r')
si = fid['s_i']
sq = fid['s_q']
nLines = si.shape[0]
spectralShift = 2 * self.frame.getInstrument().getRangePixelSize(
) / self.frame.getInstrument().getRadarWavelength()
spectralShift -= np.floor(spectralShift)
phsShift = np.exp(-1j * 2 * np.pi * spectralShift *
np.arange(si.shape[1]))
with open(self.output, 'wb') as fout:
for ii in range(nLines):
line = (si[ii, :] + 1j * sq[ii, :])
if self.applySlantRangePhase:
line *= phsShift
line.astype(np.complex64).tofile(fout)
fid.close()
slcImage = isceobj.createSlcImage()
slcImage.setFilename(self.output)
slcImage.setXmin(0)
slcImage.setXmax(self.frame.getNumberOfSamples())
slcImage.setWidth(self.frame.getNumberOfSamples())
slcImage.setAccessMode('r')
self.frame.setImage(slcImage)
def run(slcImage,
resampledFilename,
offsetField,
instrument,
pixelSpacing,
doppler,
catalog=None,
sceneid='NO_ID'):
# Create the resampled SLC image
resampledSlcImage = isceobj.createSlcImage()
resampledSlcImage.setFilename(resampledFilename)
resampledSlcImage.setAccessMode('write')
resampledSlcImage.setDataType('CFLOAT')
resampledSlcImage.setWidth(slcImage.width)
resampledSlcImage.createImage()
resamp = stdproc.createResamp_slc()
resamp.setNumberLines(slcImage.length)
resamp.setNumberRangeBin(slcImage.width)
resamp.setNumberFitCoefficients(1)
resamp.setSlantRangePixelSpacing(pixelSpacing)
resamp.setDopplerCentroidCoefficients([doppler, 0.0, 0.0, 0.0])
resamp.wireInputPort(name='offsets', object=offsetField)
resamp.wireInputPort(name='instrument', object=instrument)
resamp.stdWriter = stdWriter.set_file_tags("resamp_slc", "log", "err",
"out")
resamp.resamp_slc(slcImage, resampledSlcImage)
slcImage.finalizeImage()
resampledSlcImage.finalizeImage()
return resampledSlcImage
def getValidLines(secondary, rdict, inname, misreg_az=0.0, misreg_rng=0.0):
'''
Looks at the reference, secondary and azimuth offsets and gets the Interferogram valid lines
'''
import numpy as np
import isce
import isceobj
dimg = isceobj.createSlcImage()
dimg.load(inname + '.xml')
shp = (dimg.length, dimg.width)
az = np.fromfile(rdict['azimuthOff'], dtype=np.float32).reshape(shp)
az += misreg_az
aa = np.zeros(az.shape)
aa[:, :] = az
aa[aa < -10000.0] = np.nan
amin = np.nanmin(aa)
amax = np.nanmax(aa)
rng = np.fromfile(rdict['rangeOff'], dtype=np.float32).reshape(shp)
rng += misreg_rng
rr = np.zeros(rng.shape)
rr[:, :] = rng
rr[rr < -10000.0] = np.nan
rmin = np.nanmin(rr)
rmax = np.nanmax(rr)
return amin, amax, rmin, rmax
def create_xml(fileName, width, length, fileType):
import isceobj
if fileType == 'slc':
image = isceobj.createSlcImage()
elif fileType == 'int':
image = isceobj.createIntImage()
elif fileType == 'amp':
image = isceobj.createAmpImage()
elif fileType == 'cor':
image = isceobj.createOffsetImage()
elif fileType == 'rmg' or fileType == 'unw':
image = isceobj.Image.createUnwImage()
elif fileType == 'byte':
image = isceobj.createImage()
image.setDataType('BYTE')
elif fileType == 'float':
image = isceobj.createImage()
image.setDataType('FLOAT')
elif fileType == 'double':
image = isceobj.createImage()
image.setDataType('DOUBLE')
else:
raise Exception('format not supported yet!\n')
image.setFilename(fileName)
image.extraFilename = fileName + '.vrt'
image.setWidth(width)
image.setLength(length)
#image.setAccessMode('read')
#image.createImage()
image.renderHdr()
def extractImage(self):
import numpy as np
import h5py
self.parse()
fid = h5py.File(self.hdf5, 'r')
ds = fid['/science/LSAR/SLC/swaths/' + self.frequency + '/' +
self.polarization]
nLines = ds.shape[0]
with open(self.output, 'wb') as fout:
for ii in range(nLines):
ds[ii, :].astype(np.complex64).tofile(fout)
fid.close()
slcImage = isceobj.createSlcImage()
slcImage.setFilename(self.output)
slcImage.setXmin(0)
slcImage.setXmax(self.frame.getNumberOfSamples())
slcImage.setWidth(self.frame.getNumberOfSamples())
slcImage.setAccessMode('r')
slcImage.renderHdr()
self.frame.setImage(slcImage)
def extractImage(self):
"""
Exports GeoTiff to ISCE format.
"""
from osgeo import gdal
ds = gdal.Open(self._imageFileName)
metadata = ds.GetMetadata()
geoTs = ds.GetGeoTransform() #GeoTransform
prj = ds.GetProjection() #Projection
dataType = ds.GetRasterBand(1).DataType
gcps = ds.GetGCPs()
sds = ds.ReadAsArray()
# Output raster array to ISCE file
driver = gdal.GetDriverByName('ISCE')
export = driver.Create(self.output, ds.RasterXSize, ds.RasterYSize, 1, dataType)
band = export.GetRasterBand(1)
band.WriteArray(sds)
export.SetGeoTransform(geoTs)
export.SetMetadata(metadata)
export.SetProjection(prj)
export.SetGCPs(gcps,prj)
band.FlushCache()
export.FlushCache()
self.parse()
slcImage = isceobj.createSlcImage()
slcImage.setFilename(self.output)
slcImage.setXmin(0)
slcImage.setXmax(self.frame.getNumberOfSamples())
slcImage.setWidth(self.frame.getNumberOfSamples())
slcImage.setAccessMode('r')
self.frame.setImage(slcImage)
def createSlcImage(slcName, width):
slc = isceobj.createSlcImage()
slc.setWidth(width)
slc.filename = slcName
slc.setAccessMode('write')
slc.renderHdr()
def run(rawImage,
frame,
dopplerCentroid,
orbit,
peg,
velocity,
height,
sensorname,
stdWriter,
catalog=None,
sceneid='NO_ID'):
logger.info("Forming SLC: %s" % sceneid)
imSlc = isceobj.createSlcImage()
IU.copyAttributes(rawImage, imSlc)
imSlc.setAccessMode('read')
imSlc.createImage()
formSlc = stdproc.createFormSLC(sensorname)
formSlc.setBodyFixedVelocity(velocity)
formSlc.setSpacecraftHeight(height)
formSlc.wireInputPort(name='doppler', object=dopplerCentroid)
formSlc.wireInputPort(name='peg', object=peg)
formSlc.wireInputPort(name='frame', object=frame)
formSlc.wireInputPort(name='orbit', object=orbit)
formSlc.wireInputPort(name='slcInImage', object=imSlc)
formSlc.stdWriter = stdWriter.set_file_tags("formslcTSX", "log", "err",
"out")
slcImage = formSlc()
imSlc.finalizeImage()
if catalog is not None:
isceobj.Catalog.recordInputsAndOutputs(catalog, formSlc,
"runFormSLCTSX.%s" % sceneid,
logger,
"runFormSLCTSX.%s" % sceneid)
return slcImage, formSlc
def extractImage(self):
"""
Use gdal python bindings to extract image
"""
try:
from osgeo import gdal
except ImportError:
raise Exception('GDAL python bindings not found. Need this for RSAT2/ TandemX / Sentinel1A.')
self.parse()
width = self.frame.getNumberOfSamples()
lgth = self.frame.getNumberOfLines()
src = gdal.Open(self.tiff.strip(), gdal.GA_ReadOnly)
band = src.GetRasterBand(1)
fid = open(self.output, 'wb')
for ii in range(lgth):
data = band.ReadAsArray(0,ii,width,1)
data.tofile(fid)
fid.close()
src = None
band = None
####
slcImage = isceobj.createSlcImage()
slcImage.setByteOrder('l')
slcImage.setFilename(self.output)
slcImage.setAccessMode('read')
slcImage.setWidth(self.frame.getNumberOfSamples())
slcImage.setLength(self.frame.getNumberOfLines())
slcImage.setXmin(0)
slcImage.setXmax(self.frame.getNumberOfSamples())
self.frame.setImage(slcImage)
def run(rawImage,
frame,
dopplerCentroid,
orbit,
peg,
velocity,
height,
sensorname,
stdWriter,
catalog=None,
sceneid='NO_ID'):
logger.info("Forming SLC: %s" % sceneid)
imSlc = isceobj.createSlcImage()
IU.copyAttributes(rawImage, imSlc)
imSlc.setAccessMode('read')
imSlc.createImage()
formSlc = stdproc.createFormSLC(sensorname)
formSlc.setBodyFixedVelocity(velocity)
formSlc.setSpacecraftHeight(height)
formSlc.wireInputPort(name='doppler', object=dopplerCentroid)
formSlc.wireInputPort(name='peg', object=peg)
formSlc.wireInputPort(name='frame', object=frame)
formSlc.wireInputPort(name='orbit', object=orbit)
formSlc.wireInputPort(name='rawImage', object=None)
formSlc.wireInputPort(name='planet',
object=frame.instrument.platform.planet)
for item in formSlc.inputPorts:
item()
formSlc.slcWidth = imSlc.getWidth()
formSlc.startingRange = formSlc.rangeFirstSample
formSlc.rangeChirpExtensionsPoints = 0
formSlc.setLookSide(frame.platform.pointingDirection)
formSlc.slcSensingStart = frame.getSensingStart()
formSlc.outOrbit = orbit
formSlc.stdWriter = stdWriter.set_file_tags("formslcISCE", "log", "err",
"out")
time, position, vel, relTo = orbit._unpackOrbit()
mocomp_array = [[], []]
for (t, p) in zip(time, position):
mocomp_array[0].append(t - time[0])
mocomp_array[1].append(p[0])
formSlc.mocompPosition = mocomp_array
formSlc.mocompIndx = list(range(1, len(time) + 1))
formSlc.dim1_mocompPosition = 2
formSlc.dim2_mocompPosition = len(time)
formSlc.dim1_mocompIndx = len(time)
# slcImage = formSlc()
imSlc.finalizeImage()
if catalog is not None:
isceobj.Catalog.recordInputsAndOutputs(catalog, formSlc,
"runFormSLCisce.%s" % sceneid,
logger,
"runFormSLCisce.%s" % sceneid)
return imSlc, formSlc
def multiply(masname, slvname, outname, rngname, fact, masterFrame,
flatten=True, alks=3, rlks=7, virtual=True):
masImg = isceobj.createSlcImage()
masImg.load( masname + '.xml')
width = masImg.getWidth()
length = masImg.getLength()
if not virtual:
master = np.memmap(masname, dtype=np.complex64, mode='r', shape=(length,width))
slave = np.memmap(slvname, dtype=np.complex64, mode='r', shape=(length, width))
else:
master = loadVirtualArray(masname + '.vrt')
slave = loadVirtualArray(slvname + '.vrt')
if os.path.exists(rngname):
rng2 = np.memmap(rngname, dtype=np.float32, mode='r', shape=(length,width))
else:
print('No range offsets provided')
rng2 = np.zeros((length,width))
cJ = np.complex64(-1j)
#Zero out anytging outside the valid region:
ifg = np.memmap(outname, dtype=np.complex64, mode='w+', shape=(length,width))
firstS = masterFrame.firstValidSample
lastS = masterFrame.firstValidSample + masterFrame.numValidSamples -1
firstL = masterFrame.firstValidLine
lastL = masterFrame.firstValidLine + masterFrame.numValidLines - 1
for kk in range(firstL,lastL + 1):
ifg[kk,firstS:lastS + 1] = master[kk,firstS:lastS + 1] * np.conj(slave[kk,firstS:lastS + 1])
if flatten:
phs = np.exp(cJ*fact*rng2[kk,firstS:lastS + 1])
ifg[kk,firstS:lastS + 1] *= phs
####
master=None
slave=None
ifg = None
objInt = isceobj.createIntImage()
objInt.setFilename(outname)
objInt.setWidth(width)
objInt.setLength(length)
objInt.setAccessMode('READ')
objInt.renderHdr()
try:
outfile = takeLooks(objInt, alks, rlks)
print('Output: ', outfile)
except:
raise Exception('Failed to multilook ifgs')
return objInt
def runRgoffset(self):
from isceobj.Catalog import recordInputs, recordOutputs
coarseAcross = 0
coarseDown = 0
numLocationAcross = self._insar.getNumberLocationAcross()
numLocationDown = self._insar.getNumberLocationDown()
firstAc = self._insar.getFirstSampleAcross()
firstDn = self._insar.getFirstSampleDown()
ampImage = self._insar.getResampAmpImage()
slaveWidth = ampImage.getWidth()
slaveLength = ampImage.getLength()
objAmp = isceobj.createSlcImage()
objAmp.dataType = 'CFLOAT'
objAmp.bands = 1
objAmp.setFilename(ampImage.getFilename())
objAmp.setAccessMode('read')
objAmp.setWidth(slaveWidth)
objAmp.createImage()
simImage = self._insar.getSimAmpImage()
masterWidth = simImage.getWidth()
objSim = isceobj.createImage()
objSim.setFilename(simImage.getFilename())
objSim.dataType = 'FLOAT'
objSim.setWidth(masterWidth)
objSim.setAccessMode('read')
objSim.createImage()
masterLength = simImage.getLength()
nStageObj = NStage(name='insarapp_intsim_nstage')
nStageObj.configure()
nStageObj.setImageDataType1('real')
nStageObj.setImageDataType2('complex')
if nStageObj.acrossGrossOffset is None:
nStageObj.setAcrossGrossOffset(0)
if nStageObj.downGrossOffset is None:
nStageObj.setDownGrossOffset(0)
# Record the inputs
recordInputs(self._insar.procDoc, nStageObj, "runRgoffset", logger,
"runRgoffset")
nStageObj.nstage(slcImage1=objSim, slcImage2=objAmp)
recordOutputs(self._insar.procDoc, nStageObj, "runRgoffset", logger,
"runRgoffset")
offField = nStageObj.getOffsetField()
# save the input offset field for the record
self._insar.setOffsetField(offField)
self._insar.setRefinedOffsetField(offField)
def master(self, deltaf=None):
from isceobj.Catalog import recordInputsAndOutputs
from iscesys.ImageUtil.ImageUtil import ImageUtil as IU
v,h = self.insar.vh()
objRaw = self.insar.rawMasterIQImage.clone()
objRaw.accessMode = 'read'
objFormSlc = stdproc.createFormSLC(name='insarapp_formslc_master')
objFormSlc.setBodyFixedVelocity(v)
objFormSlc.setSpacecraftHeight(h)
objFormSlc.setAzimuthPatchSize(self.patchSize)
objFormSlc.setNumberValidPulses(self.goodLines)
objFormSlc.setNumberPatches(self.numPatches)
objFormSlc.setLookSide(self.insar._lookSide)
objFormSlc.setNumberAzimuthLooks(self.insar.numberAzimuthLooks)
logger.info("Focusing Master image")
objFormSlc.stdWriter = self.stdWriter
if (deltaf is not None) and (objFormSlc.azimuthResolution is None):
ins = self.insar.masterFrame.getInstrument()
prf = ins.getPulseRepetitionFrequency()
res = ins.getPlatform().getAntennaLength() / 2.0
azbw = min(v/res, prf)
res = v/azbw
factor = 1.0 - (abs(deltaf)/azbw)
logger.info('MASTER AZIMUTH BANDWIDTH FACTOR = %f'%(factor))
azres = res / factor
#jng This is a temporary solution seems it looks that same banding problem
#can be resolved by doubling the azres. The default azResFactor is still one.
objFormSlc.setAzimuthResolution(azres*self.insar.azResFactor)
####newInputs
objSlc = objFormSlc(rawImage=objRaw,
orbit=self.insar.masterOrbit,
frame=self.insar.masterFrame,
planet=self.insar.masterFrame.instrument.platform.planet,
doppler=self.insar.dopplerCentroid,
peg=self.insar.peg)
imageSlc = isceobj.createSlcImage()
IU.copyAttributes(objSlc, imageSlc)
imageSlc.setAccessMode('read')
objSlc.finalizeImage()
objRaw.finalizeImage()
recordInputsAndOutputs(self.insar.procDoc, objFormSlc,
"runFormSLC.master", logger, "runFormSLC.master")
logger.info('New Width = %d'%(imageSlc.getWidth()))
self.insar.masterSlcImage = imageSlc
self.insar.formSLC1 = objFormSlc
return objFormSlc.numberPatches
def extractImage(self):
"""
Use gdal_translate to extract the slc
"""
import tempfile
import subprocess
if (not self.gdal_translate):
raise TypeError(
"The path to executable gdal_translate was not specified")
if (not os.path.exists(self.gdal_translate)):
raise OSError("Could not find gdal_translate in directory %s" %
os.path.dirname(self.gdal_translate))
self.parse()
# Use GDAL to convert the geoTIFF file to an raster image
# There should be a way to do this using the GDAL python api
curdir = os.getcwd()
tempdir = tempfile.mkdtemp(dir=curdir)
# os.rmdir(tempdir) # Wasteful, but if the directory exists, gdal_translate freaks out
#instring = 'RADARSAT_2_CALIB:UNCALIB:%s' % self.xml
#process = subprocess.Popen([self.gdal_translate,'-of','MFF2','-ot','CFloat32',instring,tempdir])
if (self.tiff is None) or (not os.path.exists(self.tiff)):
raise Exception(
'Path to input tiff file: %s is wrong or file doesnt exist.' %
(self.tiff))
process = subprocess.Popen([
self.gdal_translate,
self.tiff.strip(), '-of', 'ENVI', '-ot', 'CFloat32', '-co',
'INTERLEAVE=BIP',
os.path.join(tempdir, 'image_data')
])
process.wait()
# Move the output of the gdal_translate call to a reasonable file name
width = self.frame.getNumberOfSamples()
lgth = self.frame.getNumberOfLines()
os.rename(os.path.join(tempdir, 'image_data'), self.output)
# os.unlink(os.path.join(tempdir,'attrib'))
os.unlink(os.path.join(tempdir, 'image_data.hdr'))
os.rmdir(tempdir)
####
slcImage = isceobj.createSlcImage()
slcImage.setByteOrder('l')
slcImage.setFilename(self.output)
slcImage.setAccessMode('read')
slcImage.setWidth(self.frame.getNumberOfSamples())
slcImage.setLength(self.frame.getNumberOfLines())
slcImage.setXmin(0)
slcImage.setXmax(self.frame.getNumberOfSamples())
self.frame.setImage(slcImage)
def extractImage(self, verbose=True):
'''
Use gdal to extract the slc.
'''
try:
from osgeo import gdal
except ImportError:
raise Exception('GDAL python bindings not found. Need this for RSAT2 / TandemX / Sentinel1A.')
self.parse()
width = self.frame.getNumberOfSamples()
lgth = self.frame.getNumberOfLines()
lineFlip = (self.product.imageAttributes.rasterAttributes.lineTimeOrdering.upper() == 'DECREASING')
pixFlip = (self.product.imageAttributes.rasterAttributes.pixelTimeOrdering.upper() == 'DECREASING')
src = gdal.Open(self.tiff.strip(), gdal.GA_ReadOnly)
cJ = np.complex64(1.0j)
####Images are small enough that we can do it all in one go - Piyush
real = src.GetRasterBand(1).ReadAsArray(0,0,width,lgth)
imag = src.GetRasterBand(2).ReadAsArray(0,0,width,lgth)
if (real is None) or (imag is None):
raise Exception('Input Radarsat2 SLC seems to not be a 2 band Int16 image.')
data = real+cJ*imag
real = None
imag = None
src = None
if lineFlip:
if verbose:
print('Vertically Flipping data')
data = np.flipud(data)
if pixFlip:
if verbose:
print('Horizontally Flipping data')
data = np.fliplr(data)
data.tofile(self.output)
####
slcImage = isceobj.createSlcImage()
slcImage.setByteOrder('l')
slcImage.setFilename(self.output)
slcImage.setAccessMode('read')
slcImage.setWidth(width)
slcImage.setLength(lgth)
slcImage.setXmin(0)
slcImage.setXmax(width)
# slcImage.renderHdr()
self.frame.setImage(slcImage)
def computeRangeParams(self):
'''Ensure that the given range parameters are valid.'''
from isceobj.Constants import SPEED_OF_LIGHT
import isceobj
chirpLength = int(self.rangeSamplingRate * self.rangePulseDuration)
halfChirpLength = chirpLength // 2
#Add a half-chirp to the user requested extension.
#To decrease the extension relative to the halfChirpLength
#the user would have to set rangeCHirpExtensionPoints to a negative
#value; however, the resulting value must be greater than 0.
self.logger.info('Default near range chirp extension ' +
'(half the chirp length): %d' % (halfChirpLength))
self.logger.info('Extra Chirp Extension requested: ' + '%d' %
(self.rangeChirpExtensionPoints))
self.rangeChirpExtensionPoints = (self.rangeChirpExtensionPoints +
halfChirpLength)
if self.rangeChirpExtensionPoints >= 0:
self.logger.info('Extending range line by ' + '%d pixels' %
(self.rangeChirpExtensionPoints))
elif self.rangeChirpExtensionPoints < 0:
raise ValueError('Range Chirp Extension cannot be negative.')
#startRangeBin must be positive.
#It is an index into the raw data range line
if self.startRangeBin <= 0:
raise ValueError('startRangeBin must be positive ')
self.logger.info('Number of Range Bins: %d' % self.numberRangeBin)
self.slcWidth = (self.numberRangeBin + self.rangeChirpExtensionPoints +
halfChirpLength + self.startRangeBin - 1)
delr = self.rangeSamplingRate
#Will be set here and passed on to Fortran. - Piyush
self.startingRange = (
self.rangeFirstSample +
(self.startRangeBin - 1 - self.rangeChirpExtensionPoints) *
SPEED_OF_LIGHT * 0.5 / self.rangeSamplingRate)
self.logger.info('Raw Starting Range: %f' % (self.rangeFirstSample))
self.logger.info('SLC Starting Range: %f' % (self.startingRange))
self.logger.info('SLC width: %f' % (self.slcWidth))
#Set width of the SLC image here .
self.slcImage = isceobj.createSlcImage()
self.logger.info('Debug fname : %s' % (self.rawImage.getFilename()))
self.slcImage.setFilename(self.rawImage.getFilename().replace(
'.raw', '.slc'))
self.slcImage.setWidth(self.slcWidth)
self.slcImage.setAccessMode('write')
self.slcImage.createImage()
def extractImage(self):
self.parse()
slcImage = isceobj.createSlcImage()
self.slcname = self.metadata['slc_{}_1x1'.format(self.segment_index)]
slcImage.setFilename(self.slcname)
slcImage.setXmin(0)
slcImage.setXmax(self.frame.getNumberOfSamples())
slcImage.setWidth(self.frame.getNumberOfSamples())
slcImage.setAccessMode('r')
self.frame.setImage(slcImage)
return
def derampImage(self, offset=0.0, action=True):
'''
Deramp the bursts.
'''
t0 = self.bursts[0].sensingStart
lineOffset = 0
for index, burst in enumerate(self.bursts):
infile = burst.image.filename
derampfile = os.path.join(self.outdir,
'deramp_%02d' % (index + 1) + '.slc')
if action:
data = np.fromfile(infile, dtype=np.complex64).reshape(
(burst.numberOfLines, burst.numberOfSamples))
ramp = self.computeRamp(burst, offset=offset)
#####Write Deramped SLC to file
data *= ramp
print('Burst Number: %d' % (index + 1))
print('Number of Lines: %d' % (burst.numberOfLines))
print('Global Offset: %d' %
(np.round(-(t0 - burst.sensingStart).total_seconds() /
burst.azimuthTimeInterval)))
if index > 0:
boff = (np.round(-(self.bursts[index - 1].sensingStart -
burst.sensingStart).total_seconds() /
burst.azimuthTimeInterval))
lineOffset += boff
print('Burst OFfset: %d' % lineOffset)
fid = open(derampfile, 'wb')
data.tofile(fid)
fid.close()
####Render ISCE XML
slcImage = isceobj.createSlcImage()
slcImage.setByteOrder('l')
slcImage.setFilename(derampfile)
slcImage.setAccessMode('read')
slcImage.setWidth(burst.numberOfSamples)
slcImage.setLength(burst.numberOfLines)
slcImage.setXmin(0)
slcImage.setXmax(burst.numberOfSamples)
slcImage.renderHdr()
burst.derampimage = slcImage
band = None
src = None
def extractImage(self):
import array
import math
self.parse()
try:
out = open(self.output, 'wb')
except:
raise Exception('Cannot open output file: %s' % (self.output))
self.imageFile.extractImage(output=out)
out.close()
rawImage = isceobj.createSlcImage()
rawImage.setByteOrder('l')
rawImage.setAccessMode('read')
rawImage.setFilename(self.output)
rawImage.setWidth(self.imageFile.width)
rawImage.setXmin(0)
rawImage.setXmax(self.imageFile.width)
self.frame.setImage(rawImage)
prf = self.frame.getInstrument().getPulseRepetitionFrequency()
senStart = self.frame.getSensingStart()
numPulses = int(
math.ceil(
DTU.timeDeltaToSeconds(self.frame.getSensingStop() - senStart)
* prf))
musec0 = (senStart.hour * 3600 + senStart.minute * 60 +
senStart.second) * 10**6 + senStart.microsecond
maxMusec = (
24 *
3600) * 10**6 #use it to check if we went across a day. very rare
day0 = (datetime.datetime(senStart.year, senStart.month, senStart.day)
- datetime.datetime(senStart.year, 1, 1)).days + 1
outputArray = array.array('d', [0] * 2 * numPulses)
self.frame.auxFile = self.output + '.aux'
fp = open(self.frame.auxFile, 'wb')
j = -1
for i1 in range(numPulses):
j += 1
musec = round((j / prf) * 10**6) + musec0
if musec >= maxMusec:
day0 += 1
musec0 = musec % maxMusec
musec = musec0
j = 0
outputArray[2 * i1] = day0
outputArray[2 * i1 + 1] = musec
outputArray.tofile(fp)
fp.close()
def extractImage(self, action=True):
"""
Use gdal python bindings to extract image
"""
try:
from osgeo import gdal
except ImportError:
raise Exception('GDAL python bindings not found. Need this for RSAT2/ TandemX / Sentinel1.')
self.parse()
src = gdal.Open(self.tiff.strip(), gdal.GA_ReadOnly)
band = src.GetRasterBand(1)
print('Total Width = %d'%(src.RasterXSize))
print('Total Length = %d'%(src.RasterYSize))
lineOffset = 0
if os.path.isdir(self.outdir):
print('Output directory {0} already exists.'.format(self.outdir))
else:
print('Creating directory {0} '.format(self.outdir))
os.makedirs(self.outdir)
for index, burst in enumerate(self.bursts):
outfile = os.path.join(self.outdir, 'burst_%02d'%(index+1) + '.slc')
if action:
###Write original SLC to file
fid = open(outfile, 'wb')
data = band.ReadAsArray(0, lineOffset, burst.numberOfSamples, burst.numberOfLines)
data.tofile(fid)
fid.close()
####Render ISCE XML
slcImage = isceobj.createSlcImage()
slcImage.setByteOrder('l')
slcImage.setFilename(outfile)
slcImage.setAccessMode('read')
slcImage.setWidth(burst.numberOfSamples)
slcImage.setLength(burst.numberOfLines)
slcImage.setXmin(0)
slcImage.setXmax(burst.numberOfSamples)
slcImage.renderHdr()
burst.image = slcImage
lineOffset += burst.numberOfLines
band = None
src = None
def secondary(self, deltaf=None):
from isceobj.Catalog import recordInputsAndOutputs
from iscesys.ImageUtil.ImageUtil import ImageUtil as IU
v, h = self.insar.vh()
objRaw = self.insar.rawSecondaryIQImage.clone()
objRaw.accessMode = 'read'
objFormSlc = stdproc.createFormSLC(name='insarapp_formslc_secondary')
objFormSlc.setBodyFixedVelocity(v)
objFormSlc.setSpacecraftHeight(h)
objFormSlc.setAzimuthPatchSize(self.patchSize)
objFormSlc.setNumberValidPulses(self.goodLines)
objFormSlc.setNumberPatches(self.numPatches)
objFormSlc.setNumberAzimuthLooks(self.insar.numberAzimuthLooks)
objFormSlc.setLookSide(self.insar._lookSide)
logger.info("Focusing Reference image")
objFormSlc.stdWriter = self.stdWriter
if (deltaf is not None) and (objFormSlc.azimuthResolution is None):
ins = self.insar.secondaryFrame.getInstrument()
prf = ins.getPulseRepetitionFrequency()
res = ins.getPlatform().getAntennaLength() / 2.0
azbw = min(v / res, prf)
res = v / azbw
factor = 1.0 - (abs(deltaf) / azbw)
logger.info('SECONDARY AZIMUTH BANDWIDTH FACTOR = %f' % (factor))
azres = res / factor
objFormSlc.setAzimuthResolution(azres)
objSlc = objFormSlc(
rawImage=objRaw,
orbit=self.insar.secondaryOrbit,
frame=self.insar.secondaryFrame,
planet=self.insar.secondaryFrame.instrument.platform.planet,
doppler=self.insar.dopplerCentroid,
peg=self.insar.peg)
imageSlc = isceobj.createSlcImage()
IU.copyAttributes(objSlc, imageSlc)
imageSlc.setAccessMode('read')
objSlc.finalizeImage()
objRaw.finalizeImage()
recordInputsAndOutputs(self.insar.procDoc, objFormSlc,
"runFormSLC.secondary", logger,
"runFormSLC.secondary")
logger.info('New Width = %d' % (imageSlc.getWidth()))
self.insar.secondarySlcImage = imageSlc
self.insar.formSLC2 = objFormSlc
return objFormSlc.numberPatches
def extract_burst(inputf, outputf, prf, prf_frac, nb, nbg, bsl, kacoeff, dopcoeff, az_ratio, min_line_offset):
'''
see extract_burst.c for usage
'''
img = isceobj.createSlcImage()
img.load(inputf + '.xml')
width = img.getWidth()
length = img.getLength()
inputimage = find_vrt_file(inputf+'.vrt', 'SourceFilename')
byteorder = find_vrt_keyword(inputf+'.vrt', 'ByteOrder')
if byteorder == 'LSB':
byteorder = 0
else:
byteorder = 1
imageoffset = find_vrt_keyword(inputf+'.vrt', 'ImageOffset')
imageoffset = int(imageoffset)
lineoffset = find_vrt_keyword(inputf+'.vrt', 'LineOffset')
lineoffset = int(lineoffset)
if type(kacoeff) != list:
raise Exception('kacoeff must be a python list.\n')
if len(kacoeff) != 4:
raise Exception('kacoeff must have four elements.\n')
if type(dopcoeff) != list:
raise Exception('dopcoeff must be a python list.\n')
if len(dopcoeff) != 4:
raise Exception('dopcoeff must have four elements.\n')
filters = ctypes.cdll.LoadLibrary(os.path.join(os.path.dirname(__file__),'libalos2proc.so'))
filters.extract_burst(
ctypes.c_char_p(bytes(inputimage,'utf-8')),
ctypes.c_char_p(bytes(outputf,'utf-8')),
ctypes.c_int(width),
ctypes.c_int(length),
ctypes.c_float(prf),
ctypes.c_float(prf_frac),
ctypes.c_float(nb),
ctypes.c_float(nbg),
ctypes.c_float(bsl),
(ctypes.c_float * len(kacoeff))(*kacoeff),
(ctypes.c_float * len(dopcoeff))(*dopcoeff),
ctypes.c_float(az_ratio),
ctypes.c_float(min_line_offset),
ctypes.c_int(byteorder),
ctypes.c_long(imageoffset),
ctypes.c_long(lineoffset)
)
def write_xml(shelveFile, slcFile):
with shelve.open(shelveFile,flag='r') as db:
frame = db['frame']
length = frame.numberOfLines
width = frame.numberOfSamples
slc = isceobj.createSlcImage()
slc.setWidth(width)
slc.setLength(length)
slc.filename = slcFile
slc.setAccessMode('write')
slc.renderHdr()
slc.renderVRT()
