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 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 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 resampSecondary(burst,
offdir,
outname,
doppler,
azpoly,
rgpoly,
reference=None,
flatten=False,
zero=False,
dims=None):
'''
Resample burst by burst.
'''
if offdir is not None:
rgname = os.path.join(offdir, 'range.off')
azname = os.path.join(offdir, 'azimuth.off')
rngImg = isceobj.createImage()
rngImg.load(rgname + '.xml')
rngImg.setAccessMode('READ')
aziImg = isceobj.createImage()
aziImg.load(azname + '.xml')
aziImg.setAccessMode('READ')
width = rngImg.getWidth()
length = rngImg.getLength()
else:
rngImg = None
aziImg = None
if dims is None:
raise Exception('No offset image / dims provided.')
width = dims[1]
length = dims[0]
inimg = isceobj.createSlcImage()
inimg.load(burst.getImage().filename + '.xml')
inimg.setAccessMode('READ')
prf = burst.getInstrument().getPulseRepetitionFrequency()
if zero:
factor = 0.0
else:
factor = 1.0
try:
print('Polynomial doppler provided')
coeffs = [factor * 2 * np.pi * val / prf for val in doppler._coeffs]
except:
print('List of coefficients provided')
coeffs = [factor * 2 * np.pi * val / prf for val in doppler]
zcoeffs = [0. for val in coeffs]
dpoly = Poly2D()
# dpoly.initPoly(rangeOrder=len(coeffs)-1, azimuthOrder=1, coeffs=[zcoeffs,coeffs])
dpoly.initPoly(rangeOrder=len(coeffs) - 1, azimuthOrder=0, coeffs=[coeffs])
rObj = stdproc.createResamp_slc()
rObj.slantRangePixelSpacing = burst.getInstrument().getRangePixelSize()
rObj.radarWavelength = burst.getInstrument().getRadarWavelength()
rObj.dopplerPoly = dpoly
rObj.azimuthOffsetsPoly = azpoly
rObj.rangeOffsetsPoly = rgpoly
rObj.imageIn = inimg
imgOut = isceobj.createSlcImage()
imgOut.setWidth(width)
outdir = os.path.dirname(outname)
os.makedirs(outdir, exist_ok=True)
if zero:
imgOut.filename = os.path.join(outname)
else:
imgOut.filename = os.path.join(outname)
imgOut.setAccessMode('write')
rObj.flatten = flatten
rObj.outputWidth = width
rObj.outputLines = length
rObj.residualRangeImage = rngImg
rObj.residualAzimuthImage = aziImg
if reference is not None:
rObj.startingRange = burst.startingRange
rObj.referenceStartingRange = reference.startingRange
rObj.referenceSlantRangePixelSpacing = reference.getInstrument(
).getRangePixelSize()
rObj.referenceWavelength = reference.getInstrument(
).getRadarWavelength()
rObj.resamp_slc(imageOut=imgOut)
imgOut.renderHdr()
return imgOut
def resample(self,frame,doppler):
"""
Resample the VH and VV polarizations by 0.5 pixels in azimuth.
@param frame (\a isceobj.Scene.Frame) the Frame object for the SAR data
"""
import isceobj
import stdproc
from isceobj import Constants
from isceobj.Location.Offset import Offset, OffsetField
instrument = frame.instrument
fs = instrument.getRangeSamplingRate()
pixelSpacing = Constants.SPEED_OF_LIGHT/(2.0*fs) #2013-06-03 Kosal: change in constant name
filename = frame.getImage().getFilename()
slcFilename = filename.replace('.raw','.slc')
resampledFilename = filename.replace('.raw','.resampled.slc')
# Create the SLC image
slcImage = isceobj.createSlcImage()
slcImage.setFilename(slcFilename)
slcImage.setAccessMode('read')
slcImage.setDataType('CFLOAT')
slcImage.setWidth(self.width)
slcImage.createImage()
# Create the resampled SLC image
resampledSlcImage = isceobj.createSlcImage()
resampledSlcImage.setFilename(resampledFilename)
resampledSlcImage.setAccessMode('write')
resampledSlcImage.setDataType('CFLOAT')
resampledSlcImage.setWidth(self.width)
resampledSlcImage.createImage()
# Create an offset field with constant 0.5 pixel shifts in azimuth
offsetField = OffsetField()
for i in range(0, self.length,100):
for j in range(0, self.width,100):
dx = 0.0
dy = -0.5
offset = Offset()
offset.setCoordinate(j,i)
offset.setOffset(dx,dy)
offset.setSignalToNoise(10.0)
offsetField.addOffset(offset)
self.logger.debug("width: %s" % (self.width))
self.logger.debug("length: %s" % (self.length))
self.logger.debug("Pixel Spacing: %s" % (pixelSpacing))
self.logger.debug("doppler : %s" % (doppler))
fp = open('offsetField','w')
fp.write(str(offsetField))
fp.close()
#2013-06-03 Kosal: change resamp_only to resamp_slc, which resamples only an SLC
#(took resamp_only from revision 747)
resamp = stdproc.createResamp_slc()
resamp.setNumberLines(self.length)
resamp.setNumberRangeBin(self.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)
# updated 07/24/2012
resamp.stdWriter = self._writer_set_file_tags(
"resamp_slc", "log", "err", "out"
)
# updated 07/24/2012
resamp.resamp_slc(slcImage, resampledSlcImage)
#Kosal
slcImage.finalizeImage()
resampledSlcImage.finalizeImage()
# Rename the resampled slcs
os.rename(resampledFilename,slcFilename)
def runResampleSlc(self, kind='coarse'):
'''
Kind can either be coarse, refined or fine.
'''
if kind not in ['coarse', 'refined', 'fine']:
raise Exception('Unknown operation type {0} in runResampleSlc'.format(kind))
if kind == 'fine':
if not (self.doRubbersheetingRange | self.doRubbersheetingAzimuth): # Modified by V. Brancato 10.10.2019
print('Rubber sheeting not requested, skipping resampling ....')
return
logger.info("Resampling secondary SLC")
secondaryFrame = self._insar.loadProduct( self._insar.secondarySlcCropProduct)
referenceFrame = self._insar.loadProduct( self._insar.referenceSlcCropProduct)
inimg = isceobj.createSlcImage()
inimg.load(secondaryFrame.getImage().filename + '.xml')
inimg.setAccessMode('READ')
prf = secondaryFrame.PRF
doppler = secondaryFrame._dopplerVsPixel
coeffs = [2*np.pi*val/prf for val in doppler]
dpoly = Poly2D()
dpoly.initPoly(rangeOrder=len(coeffs)-1, azimuthOrder=0, coeffs=[coeffs])
rObj = stdproc.createResamp_slc()
rObj.slantRangePixelSpacing = secondaryFrame.getInstrument().getRangePixelSize()
rObj.radarWavelength = secondaryFrame.getInstrument().getRadarWavelength()
rObj.dopplerPoly = dpoly
# for now let's start with None polynomial. Later this should change to
# the misregistration polynomial
misregFile = os.path.join(self.insar.misregDirname, self.insar.misregFilename)
if ((kind in ['refined','fine']) and os.path.exists(misregFile+'_az.xml')):
azpoly = self._insar.loadProduct(misregFile + '_az.xml')
rgpoly = self._insar.loadProduct(misregFile + '_rg.xml')
else:
print(misregFile , " does not exist.")
azpoly = None
rgpoly = None
rObj.azimuthOffsetsPoly = azpoly
rObj.rangeOffsetsPoly = rgpoly
rObj.imageIn = inimg
#Since the app is based on geometry module we expect pixel-by-pixel offset
#field
offsetsDir = self.insar.offsetsDirname
# Modified by V. Brancato 10.10.2019
#rgname = os.path.join(offsetsDir, self.insar.rangeOffsetFilename)
if kind in ['coarse', 'refined']:
azname = os.path.join(offsetsDir, self.insar.azimuthOffsetFilename)
rgname = os.path.join(offsetsDir, self.insar.rangeOffsetFilename)
flatten = True
else:
azname = os.path.join(offsetsDir, self.insar.azimuthRubbersheetFilename)
if self.doRubbersheetingRange:
print('Rubbersheeting in range is turned on, taking the cross-correlation offsets')
print('Setting Flattening to False')
rgname = os.path.join(offsetsDir, self.insar.rangeRubbersheetFilename)
flatten=False
else:
print('Rubbersheeting in range is turned off, taking range geometric offsets')
rgname = os.path.join(offsetsDir, self.insar.rangeOffsetFilename)
flatten=True
rngImg = isceobj.createImage()
rngImg.load(rgname + '.xml')
rngImg.setAccessMode('READ')
aziImg = isceobj.createImage()
aziImg.load(azname + '.xml')
aziImg.setAccessMode('READ')
width = rngImg.getWidth()
length = rngImg.getLength()
# Modified by V. Brancato 10.10.2019
#flatten = True
rObj.flatten = flatten
rObj.outputWidth = width
rObj.outputLines = length
rObj.residualRangeImage = rngImg
rObj.residualAzimuthImage = aziImg
if referenceFrame is not None:
rObj.startingRange = secondaryFrame.startingRange
rObj.referenceStartingRange = referenceFrame.startingRange
rObj.referenceSlantRangePixelSpacing = referenceFrame.getInstrument().getRangePixelSize()
rObj.referenceWavelength = referenceFrame.getInstrument().getRadarWavelength()
# preparing the output directory for coregistered secondary slc
coregDir = self.insar.coregDirname
os.makedirs(coregDir, exist_ok=True)
# output file name of the coregistered secondary slc
img = secondaryFrame.getImage()
if kind == 'coarse':
coregFilename = os.path.join(coregDir , self._insar.coarseCoregFilename)
elif kind == 'refined':
coregFilename = os.path.join(coregDir, self._insar.refinedCoregFilename)
elif kind == 'fine':
coregFilename = os.path.join(coregDir, self._insar.fineCoregFilename)
else:
print('Exception: Should not have gotten to this stage')
imgOut = isceobj.createSlcImage()
imgOut.setWidth(width)
imgOut.filename = coregFilename
imgOut.setAccessMode('write')
rObj.resamp_slc(imageOut=imgOut)
imgOut.renderHdr()
return
def resampleSlc(masterFrame,
slaveFrame,
imageSlc2,
radarWavelength,
coregDir,
azoffname,
rgoffname,
azpoly=None,
rgpoly=None,
misreg=False):
logger.info("Resampling slave SLC")
imageSlc1 = masterFrame.getImage().filename
inimg = isceobj.createSlcImage()
inimg.load(imageSlc2 + '.xml')
inimg.setAccessMode('READ')
prf = slaveFrame.PRF
doppler = slaveFrame._dopplerVsPixel
factor = 1.0 # this should be zero for zero Doppler SLC.
coeffs = [factor * 2 * np.pi * val / prf / prf for val in doppler]
dpoly = Poly2D()
dpoly.initPoly(rangeOrder=len(coeffs) - 1, azimuthOrder=0, coeffs=[coeffs])
rObj = stdproc.createResamp_slc()
rObj.slantRangePixelSpacing = slaveFrame.getInstrument().getRangePixelSize(
)
#rObj.radarWavelength = slaveFrame.getInstrument().getRadarWavelength()
rObj.radarWavelength = radarWavelength
rObj.dopplerPoly = dpoly
# for now let's start with None polynomial. Later this should change to
# the misregistration polynomial
rObj.azimuthOffsetsPoly = azpoly
rObj.rangeOffsetsPoly = rgpoly
rObj.imageIn = inimg
rngImg = isceobj.createImage()
rngImg.load(rgoffname + '.xml')
rngImg.setAccessMode('READ')
aziImg = isceobj.createImage()
aziImg.load(azoffname + '.xml')
aziImg.setAccessMode('READ')
width = rngImg.getWidth()
length = rngImg.getLength()
flatten = True
rObj.flatten = flatten
rObj.outputWidth = width
rObj.outputLines = length
rObj.residualRangeImage = rngImg
rObj.residualAzimuthImage = aziImg
if masterFrame is not None:
rObj.startingRange = slaveFrame.startingRange
rObj.referenceStartingRange = masterFrame.startingRange
rObj.referenceSlantRangePixelSpacing = masterFrame.getInstrument(
).getRangePixelSize()
rObj.referenceWavelength = radarWavelength
# preparing the output directory for coregistered slave slc
#coregDir = self.insar.coregDirname
if os.path.isdir(coregDir):
logger.info('Geometry directory {0} already exists.'.format(coregDir))
else:
os.makedirs(coregDir)
# output file name of the coregistered slave slc
img = slaveFrame.getImage()
coregFilename = os.path.join(coregDir, os.path.basename(img.filename))
imgOut = isceobj.createSlcImage()
imgOut.setWidth(width)
imgOut.filename = coregFilename
imgOut.setAccessMode('write')
rObj.resamp_slc(imageOut=imgOut)
imgOut.renderHdr()
return coregFilename
#checked: no flattenning
#checked: no reading of range and azimuth images
#checked: range/azimuth carrier values: 0, 0
#checked: doppler no problem
# but doppler is computed using reference's coordinate in:
# isce/components/stdproc/stdproc/resamp_slc/src/resamp_slc.f90
# I have fixed it.
for slcInput, slcOutput in zip(slcList, slcListResampled):
inimg = isceobj.createSlcImage()
inimg.load(slcInput + '.xml')
inimg.filename = slcInput
inimg.extraFilename = slcInput + '.vrt'
inimg.setAccessMode('READ')
rObj = stdproc.createResamp_slc()
#the following two items are actually not used, since we are not flattenning?
#but need to set these otherwise the program complains
rObj.slantRangePixelSpacing = swathSecondary.rangePixelSize
rObj.radarWavelength = trackSecondary.radarWavelength
#rObj.azimuthCarrierPoly = azCarrPoly
rObj.dopplerPoly = dpoly
rObj.azimuthOffsetsPoly = azimuthPoly
rObj.rangeOffsetsPoly = rangePoly
rObj.imageIn = inimg
####Setting reference values
#the following four items are actually not used, since we are not flattenning?
#but need to set these otherwise the program complains
rObj.startingRange = swathSecondary.startingRange
def resampleSlc(self,
referenceFrame,
secondaryFrame,
imageSlc2,
radarWavelength,
coregDir,
azoffname,
rgoffname,
azpoly=None,
rgpoly=None,
misreg=False):
logger.info("Resampling secondary SLC")
imageSlc1 = referenceFrame.getImage().filename
inimg = isceobj.createSlcImage()
inimg.load(imageSlc2 + '.xml')
inimg.setAccessMode('READ')
prf = secondaryFrame.PRF
doppler = secondaryFrame._dopplerVsPixel
factor = 1.0 # this should be zero for zero Doppler SLC.
coeffs = [factor * 2 * np.pi * val / prf / prf for val in doppler]
dpoly = Poly2D()
dpoly.initPoly(rangeOrder=len(coeffs) - 1, azimuthOrder=0, coeffs=[coeffs])
rObj = stdproc.createResamp_slc()
rObj.slantRangePixelSpacing = secondaryFrame.getInstrument(
).getRangePixelSize()
#rObj.radarWavelength = secondaryFrame.getInstrument().getRadarWavelength()
rObj.radarWavelength = radarWavelength
rObj.dopplerPoly = dpoly
# for now let's start with None polynomial. Later this should change to
# the misregistration polynomial
rObj.azimuthOffsetsPoly = azpoly
rObj.rangeOffsetsPoly = rgpoly
rObj.imageIn = inimg
rngImg = isceobj.createImage()
rngImg.load(rgoffname + '.xml')
rngImg.setAccessMode('READ')
aziImg = isceobj.createImage()
aziImg.load(azoffname + '.xml')
aziImg.setAccessMode('READ')
width = rngImg.getWidth()
length = rngImg.getLength()
# Modified by V. Brancato on 10.14.2019 (if Rubbersheeting in range is turned on, flatten the interferogram during cross-correlation)
if not self.doRubbersheetingRange:
print(
'Rubber sheeting in range is turned off, flattening the interferogram during resampling'
)
flatten = True
print(flatten)
else:
print(
'Rubber sheeting in range is turned on, flattening the interferogram during interferogram formation'
)
flatten = False
print(flatten)
# end of Modification
rObj.flatten = flatten
rObj.outputWidth = width
rObj.outputLines = length
rObj.residualRangeImage = rngImg
rObj.residualAzimuthImage = aziImg
if referenceFrame is not None:
rObj.startingRange = secondaryFrame.startingRange
rObj.referenceStartingRange = referenceFrame.startingRange
rObj.referenceSlantRangePixelSpacing = referenceFrame.getInstrument(
).getRangePixelSize()
rObj.referenceWavelength = radarWavelength
# preparing the output directory for coregistered secondary slc
#coregDir = self.insar.coregDirname
os.makedirs(coregDir, exist_ok=True)
# output file name of the coregistered secondary slc
img = secondaryFrame.getImage()
coregFilename = os.path.join(coregDir, os.path.basename(img.filename))
imgOut = isceobj.createSlcImage()
imgOut.setWidth(width)
imgOut.filename = coregFilename
imgOut.setAccessMode('write')
rObj.resamp_slc(imageOut=imgOut)
imgOut.renderHdr()
return coregFilename
def resampSlave(burst,
offdir,
outname,
sn,
azpoly,
rgpoly,
method,
master=None,
flatten=False,
zero=False,
dims=None):
'''
Resample burst by burst.
'''
if offdir is not None:
rgname = os.path.join(offdir, 'range.off')
azname = os.path.join(offdir, 'azimuth.off')
rngImg = isceobj.createImage()
rngImg.load(rgname + '.xml')
rngImg.setAccessMode('READ')
aziImg = isceobj.createImage()
aziImg.load(azname + '.xml')
aziImg.setAccessMode('READ')
width = rngImg.getWidth()
length = rngImg.getLength()
#print('offdir (also master) width, length:', width, length)
else:
rngImg = None
aziImg = None
if dims is None:
raise Exception('No offset image / dims provided.')
width = dims[1]
length = dims[0]
#sw = ('HHHH', 'HVHV', 'VVVV')
#if burst._polarization in sw:
# inimg = isceobj.createMlcImage()
# imgOut = isceobj.createMlcImage()
#else:
inimg = isceobj.createSlcImage()
imgOut = isceobj.createSlcImage()
print('inimg:', os.path.join(sn, burst.getImage().filename) + '.xml')
inimg.load(os.path.join(sn, burst.getImage().filename) + '.xml')
inimg.setAccessMode('READ')
prf = burst.getInstrument().getPulseRepetitionFrequency()
if zero:
factor = 0.0
else:
factor = 1.0
# try:
# print('Polynomial doppler provided')
# coeffs = [factor * 2*np.pi*val/prf for val in doppler._coeffs]
# except:
# print('List of coefficients provided')
# coeffs = [factor * 2*np.pi*val/prf for val in doppler]
#
# zcoeffs = [0. for val in coeffs]
# dpoly = Poly2D()
## dpoly.initPoly(rangeOrder=len(coeffs)-1, azimuthOrder=1, coeffs=[zcoeffs,coeffs])
# dpoly.initPoly(rangeOrder=len(coeffs)-1, azimuthOrder=0, coeffs=[coeffs])
rObj = stdproc.createResamp_slc()
rObj.slantRangePixelSpacing = burst.getInstrument().getRangePixelSize()
rObj.radarWavelength = burst.getInstrument().getRadarWavelength()
# rObj.dopplerPoly = dpoly
rObj.dopplerPoly = None
rObj.azimuthOffsetsPoly = azpoly
rObj.rangeOffsetsPoly = rgpoly
rObj.imageIn = inimg
# rObj.method = method #'SINC', 'BILINEAR', 'BICUBIC', 'NEAREST', 'AKIMA', 'BIQUINTIC'
# print('====Interpolation method is %s====' % (rObj.method))
imgOut.setWidth(width)
outdir = os.path.dirname(outname)
if not os.path.exists(outdir):
os.makedirs(outdir)
if zero:
imgOut.filename = os.path.join(outname)
else:
imgOut.filename = os.path.join(outname)
imgOut.setAccessMode('write')
rObj.flatten = flatten
rObj.outputWidth = width
rObj.outputLines = length
rObj.residualRangeImage = rngImg
rObj.residualAzimuthImage = aziImg
if master is not None:
rObj.startingRange = burst.startingRange
rObj.referenceStartingRange = master.startingRange
rObj.referenceSlantRangePixelSpacing = master.getInstrument(
).getRangePixelSize()
rObj.referenceWavelength = master.getInstrument().getRadarWavelength()
rObj.resamp_slc(imageOut=imgOut)
imgOut.renderHdr()
return imgOut
