def createImages(self):
if self.demCropFilename:
self.demCropImage = createDemImage()
demAccessMode = 'write'
demWidth = self.computeGeoImageWidth()
self.demCropImage.initImage(self.demCropFilename, demAccessMode,
demWidth)
self.demCropImage.createImage()
self.demCropAccessor = self.demCropImage.getImagePointer()
else:
self.demCropAccessor = 0
if self.geoFilename is None:
raise ValueError('Output geoFilename not specified')
#the topophase files have the same format as the int file. just reuse the previous info
self.geoImage = createIntImage()
IU.copyAttributes(self.inputImage, self.geoImage)
self.geoImage.imageType = self.inputImage.imageType
self.geoImage.setFilename(self.geoFilename)
self.geoImage.setAccessMode('write')
self.geoImage.setWidth(demWidth)
if not self.geoImage.dataType.upper().count('FLOAT'):
self.geoImage.setCaster('write', 'FLOAT')
self.geoImage.createImage()
self.geoAccessor = self.geoImage.getImagePointer()
self.polyDopplerAccessor = self.polyDoppler.exportToC()
def run(imageAmp,
imageSim,
prf,
infos,
stdWriter,
catalog=None,
sceneid='NO_ID'):
logger.info("Running Rgoffset: %s" % sceneid)
firstAc = infos['firstSampleAcross']
firstDown = infos['firstSampleDown']
numLocationAcross = infos['numberLocationAcross']
numLocationDown = infos['numberLocationDown']
objAmp = isceobj.createIntImage()
IU.copyAttributes(imageAmp, objAmp)
objAmp.setAccessMode('read')
objAmp.createImage()
widthAmp = objAmp.getWidth()
intLength = objAmp.getLength()
lastAc = widthAmp - firstAc
lastDown = intLength - firstDown
objSim = isceobj.createImage()
IU.copyAttributes(imageSim, objSim)
objSim.setAccessMode('read')
objSim.createImage()
objOffset = isceobj.createEstimateOffsets()
objOffset.setSearchWindowSize(infos['offsetSearchWindowSize'],
infos['sensorName'])
objOffset.setFirstSampleAcross(firstAc)
objOffset.setLastSampleAcross(lastAc)
objOffset.setNumberLocationAcross(numLocationAcross)
objOffset.setFirstSampleDown(firstDown)
objOffset.setLastSampleDown(lastDown)
objOffset.setNumberLocationDown(numLocationDown)
#set the tag used in the outfile. each message is precided by this tag
#if the writer is not of "file" type the call has no effect
objOffset.stdWriter = stdWriter.set_file_tags("rgoffset", "log", "err",
"out")
objOffset.setFirstPRF(prf)
objOffset.setSecondPRF(prf)
objOffset.setAcrossGrossOffset(0)
objOffset.setDownGrossOffset(0)
objOffset.estimateoffsets(image1=objSim, image2=objAmp, band1=0, band2=0)
if catalog is not None:
# Record the inputs and outputs
isceobj.Catalog.recordInputsAndOutputs(catalog, objOffset,
"runRgoffset.%s" % sceneid,
logger,
"runRgoffset.%s" % sceneid)
objAmp.finalizeImage()
objSim.finalizeImage()
return objOffset.getOffsetField()
def addSlc(self):
from isceobj.Util import Poly2D
from isceobj.Constants import SPEED_OF_LIGHT
formslc = self._inputPorts['slc']
if (formslc):
####Set up azimuth carrier information
coeffs = []
coeffs.append([
2 * np.pi * val for val in formslc.dopplerCentroidCoefficients
])
self.dopplerPoly = Poly2D.Poly2D()
self.dopplerPoly.initPoly(
rangeOrder=len(formslc.dopplerCentroidCoefficients) - 1,
azimuthOrder=0,
coeffs=coeffs)
######Setup range carrier information
delr = 0.5 * SPEED_OF_LIGHT / formslc.rangeSamplingRate
self.slantRangePixelSpacing = delr
self.radarWavelength = formslc.radarWavelength
# coeffs = [[0.0, -4 * np.pi * delr/self.radarWavelength]]
# self.rangeCarrierPoly = Poly2D.Poly2D()
# self.rangeCarrierPoly.initPoly(rangeOrder=1, azimuthOrder=0, coeffs=coeffs)
img = isceobj.createImage()
IU.copyAttributes(formslc.slcImage, img)
img.setAccessMode('read')
self.imageIn = img
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 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 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 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 run(imageSlc1, imageSlc2, offsetField, instrument, dopplerCentroid, looks, lines, numFitCoeff, pixelSpacing, offsetFilename, stdWriter, catalog=None, sceneid='NO_ID'):
widthSlc = max(imageSlc1.getWidth(), imageSlc2.getWidth())
dopplerCoeff = dopplerCentroid.getDopplerCoefficients(inHz=False)
path, filename = os.path.split(offsetFilename)
offsetAz = os.path.join(path, 'azimuth_' + filename)
offsetRn = os.path.join(path, 'range_' + filename)
widthOffset = int(widthSlc / looks)
imageAz = isceobj.createOffsetImage()
imageAz.setFilename(offsetAz)
imageAz.setWidth(widthOffset)
imageRn = isceobj.createOffsetImage()
imageRn.setFilename(offsetRn)
imageRn.setWidth(widthOffset)
objAz = isceobj.createOffsetImage()
objRn = isceobj.createOffsetImage()
IU.copyAttributes(imageAz, objAz)
IU.copyAttributes(imageRn, objRn)
objAz.setAccessMode('write')
objAz.createImage()
objRn.setAccessMode('write')
objRn.createImage()
objResamp_image = stdproc.createResamp_image()
objResamp_image.wireInputPort(name='offsets', object=offsetField)
objResamp_image.wireInputPort(name='instrument', object=instrument)
objResamp_image.setSlantRangePixelSpacing(pixelSpacing)
objResamp_image.setDopplerCentroidCoefficients(dopplerCoeff)
objResamp_image.setNumberLooks(looks)
objResamp_image.setNumberLines(lines)
objResamp_image.setNumberRangeBin(widthSlc)
objResamp_image.setNumberFitCoefficients(numFitCoeff)
#set the tag used in the outfile. each message is precided by this tag
#is the writer is not of "file" type the call has no effect
objResamp_image.stdWriter = stdWriter.set_file_tags("resamp_image",
"log",
"err",
"out")
objResamp_image.resamp_image(objRn, objAz)
if catalog is not None:
# Record the inputs and outputs
isceobj.Catalog.recordInputsAndOutputs(catalog, objResamp_image,
"runResamp_image.%s" % sceneid,
logger,
"runResamp_image.%s" % sceneid)
objRn.finalizeImage()
objAz.finalizeImage()
return imageAz, imageRn
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 createImages(self):
demWidth = self.computeGeoImageWidth()
demLength = self.computeGeoImageLength()
if self.demCropFilename:
self.demCropImage = createDemImage()
demAccessMode = 'write'
self.demCropImage.initImage(self.demCropFilename, demAccessMode,
demWidth)
self.demCropImage.createImage()
self.demCropAccessor = self.demCropImage.getImagePointer()
else:
self.demCropAccessor = 0
if self.geoFilename is None:
raise ValueError('Output geoFilename not specified')
#the topophase files have the same format as the int file. just reuse the previous info
self.geoImage = createIntImage()
IU.copyAttributes(self.inputImage, self.geoImage)
self.geoImage.imageType = self.inputImage.imageType
self.geoImage.setFilename(self.geoFilename)
self.geoImage.setAccessMode('write')
self.geoImage.setWidth(demWidth)
self.geoImage.coord1.coordEnd = None
self.geoImage.coord2.coordEnd = None
if not self.geoImage.dataType.upper().count('FLOAT'):
self.geoImage.setCaster('write', 'FLOAT')
self.geoImage.createImage()
self.geoImage.createFile(demLength)
self.geoAccessor = self.geoImage.getImagePointer()
if (self.losImage == None and self.losFilename not in ('', None)):
self.losImage = createImage()
accessMode = 'write'
dataType = 'FLOAT'
bands = 2
scheme = 'BIL'
width = demWidth
self.losImage.initImage(self.losFilename,
accessMode,
width,
dataType,
bands=bands,
scheme=scheme)
self.losImage.createImage()
self.losAccessor = self.losImage.getImagePointer()
self.polyDopplerAccessor = self.polyDoppler.exportToC()
def run(rawImage,
frame,
dopplerCentroid,
orbit,
peg,
velocity,
height,
infos,
stdWriter,
catalog=None,
sceneid='NO_ID'):
logger.info("Forming SLC: %s" % sceneid)
# objRaw = rawImage.copy(access_mode='read')
objRaw = rawImage.clone()
objRaw.accessMode = 'read'
objFormSlc = stdproc.createFormSLC()
objFormSlc.setBodyFixedVelocity(velocity)
objFormSlc.setSpacecraftHeight(height)
objFormSlc.setAzimuthPatchSize(infos['patchSize'])
objFormSlc.setNumberValidPulses(infos['numberValidPulses'])
objFormSlc.setNumberPatches(infos['numberPatches'])
objFormSlc.setNumberRangeBin(frame.numberRangeBins)
objFormSlc.setLookSide(infos['lookSide'])
objFormSlc.setShift(infos['azShiftPixels'])
logger.info("Shift in azimuth: %f pixels" % infos['azShiftPixels'])
objFormSlc.setNumberAzimuthLooks(infos['numberAzimuthLooks'])
logger.info("Focusing image %s" % sceneid)
objFormSlc.stdWriter = stdWriter
objSlc = objFormSlc(rawImage=objRaw,
orbit=orbit,
frame=frame,
planet=frame.instrument.platform.planet,
doppler=dopplerCentroid,
peg=peg)
imageSlc = isceobj.createSlcImage()
IU.copyAttributes(objSlc, imageSlc)
imageSlc.setAccessMode('read')
objSlc.finalizeImage()
objRaw.finalizeImage()
if catalog is not None:
isceobj.Catalog.recordInputsAndOutputs(catalog, objFormSlc,
"runFormSLC.%s" % sceneid,
logger,
"runFormSLC.%s" % sceneid)
logger.info('New Width = %d' % (imageSlc.getWidth()))
return imageSlc, objFormSlc
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 runShadecpx2rg(self):
imageAmp = self._insar.getResampAmpImage()
widthAmp = imageAmp.getWidth()
endian = self._insar.getMachineEndianness()
filenameSimAmp = self._insar.getSimAmpImageName()
objSimAmp = isceobj.createImage()
widthSimAmp = widthAmp
objSimAmp.initImage(filenameSimAmp, 'read', widthSimAmp, 'FLOAT')
imageSimAmp = isceobj.createImage()
IU.copyAttributes(objSimAmp, imageSimAmp)
self._insar.setSimAmpImage(imageSimAmp)
objSimAmp.setAccessMode('write')
objSimAmp.createImage()
filenameHt = self._insar.getHeightFilename()
widthHgtImage = widthAmp # they have same width by construction
objHgtImage = isceobj.createImage()
objHgtImage.initImage(filenameHt, 'read', widthHgtImage, 'FLOAT')
imageHgt = isceobj.createImage()
IU.copyAttributes(objHgtImage, imageHgt)
self._insar.setHeightTopoImage(imageHgt)
objHgtImage.createImage()
logger.info("Running Shadecpx2rg")
objShade = isceobj.createSimamplitude()
#set the tag used in the outfile. each message is precided by this tag
#is the writer is not of "file" type the call has no effect
self._stdWriter.setFileTag("simamplitude", "log")
self._stdWriter.setFileTag("simamplitude", "err")
self._stdWriter.setFileTag("simamplitude", "out")
objShade.setStdWriter(self._stdWriter)
shade = self._insar.getShadeFactor()
objShade.simamplitude(objHgtImage, objSimAmp, shade=shade)
# Record the inputs and outputs
from isceobj.Catalog import recordInputsAndOutputs
recordInputsAndOutputs(self._insar.procDoc, objShade, "runSimamplitude", \
logger, "runSimamplitude")
objHgtImage.finalizeImage()
objSimAmp.finalizeImage()
objSimAmp.renderHdr()
def run(widthAmp, infos, stdWriter, catalog=None, sceneid='NO_ID'):
logger.info("Running shadecpx2rg: %s" % sceneid)
endian = infos['machineEndianness']
filenameSimAmp = infos['outputPath'] + '.' + infos['simAmpImageName']
filenameHt = infos['outputPath'] + '.' + infos['heightFilename']
shade = infos['shadeFactor']
objSimAmp = isceobj.createImage()
widthSimAmp = widthAmp
objSimAmp.initImage(filenameSimAmp, 'read', widthSimAmp, 'FLOAT')
imageSimAmp = isceobj.createImage()
IU.copyAttributes(objSimAmp, imageSimAmp)
objSimAmp.setAccessMode('write')
objSimAmp.createImage()
widthHgtImage = widthAmp # they have same width by construction
objHgtImage = isceobj.createImage()
objHgtImage.initImage(filenameHt, 'read', widthHgtImage, 'FLOAT')
imageHgt = isceobj.createImage()
IU.copyAttributes(objHgtImage, imageHgt)
objHgtImage.createImage()
objShade = isceobj.createSimamplitude()
#set the tag used in the outfile. each message is precided by this tag
#if the writer is not of "file" type the call has no effect
objShade.stdWriter = stdWriter.set_file_tags("simamplitude", "log", "err",
"out")
objShade.simamplitude(objHgtImage, objSimAmp, shade=shade)
if catalog is not None:
# Record the inputs and outputs
isceobj.Catalog.recordInputsAndOutputs(catalog, objShade,
"runSimamplitude.%s" % sceneid,
logger,
"runSimamplitude.%s" % sceneid)
objHgtImage.finalizeImage()
objSimAmp.finalizeImage()
objSimAmp.renderHdr()
return imageSimAmp, imageHgt
def runCorrect(self):
refScene = self._isce.refScene
velocity, height = self._isce.vh()
infos = {}
for attribute in [
'dopplerCentroid', 'peg', 'lookSide', 'numberRangeLooks',
'numberAzimuthLooks', 'topophaseMphFilename',
'topophaseFlatFilename', 'heightSchFilename', 'is_mocomp'
]:
infos[attribute] = getattr(self._isce, attribute)
infos['refOutputPath'] = os.path.join(self.getoutputdir(refScene),
refScene)
stdWriter = self._stdWriter
refScene = self._isce.refScene
refPol = self._isce.refPol
refPair = self._isce.selectedPairs[0] #ML 2014-09-26
topoIntImage = self._isce.topoIntImages[refPair][refPol]
for sceneid1, sceneid2 in self._isce.selectedPairs:
pair = (sceneid1, sceneid2)
objMocompbaseline = self._isce.mocompBaselines[pair]
for pol in self._isce.selectedPols:
frame1 = self._isce.frames[sceneid1][pol]
objFormSLC1 = self._isce.formSLCs[sceneid1][pol]
topoIntImage = self._isce.topoIntImages[pair][pol] #ML 2014-09-26
intImage = isceobj.createIntImage()
IU.copyAttributes(topoIntImage, intImage)
intImage.setAccessMode('read')
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(frame1,
objFormSLC1,
objMocompbaseline,
intImage,
velocity,
height,
infos,
stdWriter,
catalog=catalog,
sceneid=sid)
def createOutSlcImage(self):
"""
Create the output SCL image based on the input image information.
If self.slcOutImageName is not set that the default is the input image name
preceded by 'mocomp'.
"""
import isceobj
self.slcOutImage = isceobj.createSlcImage()
IU.copyAttributes(self.slcInImage, self.slcOutImage)
if self.slcOutImageName:
name = self.slcOutImageName
else:
name = 'mocomp' + self.slcInImage.getFilename().capitalize()
self.slcOutImage.setFilename(name)
self.slcOutImage.setAccessMode('write')
self.slcOutImage.createImage()
return None
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 runTopo(self):
v, h = self._isce.vh()
if self._isce.is_mocomp is None:
self._isce.is_mocomp = self._isce.get_is_mocomp()
infos = {}
for attribute in [
'dopplerCentroid', 'peg', 'demImage', 'numberRangeLooks',
'numberAzimuthLooks', 'topophaseIterations', 'is_mocomp',
'heightSchFilename', 'heightFilename', 'latFilename',
'lonFilename', 'losFilename', 'lookSide'
]:
infos[attribute] = getattr(self._isce, attribute)
stdWriter = self._stdWriter
refScene = self._isce.refScene
refPol = self._isce.refPol
imgSlc1 = self._isce.slcImages[refScene][refPol]
infos['intWidth'] = int(imgSlc1.getWidth() / infos['numberRangeLooks'])
infos['intLength'] = int(imgSlc1.getLength() / infos['numberAzimuthLooks'])
objFormSlc1 = self._isce.formSLCs[refScene][refPol]
frame1 = self._isce.frames[refScene][refPol]
infos['outputPath'] = os.path.join(self.getoutputdir(refScene), refScene)
catalog = isceobj.Catalog.createCatalog(self._isce.procDoc.name)
sid = self._isce.formatname(refScene)
refPair = self._isce.selectedPairs[0] #ML 2014-09-26
topoIntImage = self._isce.topoIntImages[refPair][refPol]
intImage = isceobj.createIntImage()
IU.copyAttributes(topoIntImage, intImage)
intImage.setAccessMode('read')
objTopo = run(objFormSlc1,
intImage,
frame1,
v,
h,
infos,
stdWriter,
catalog=catalog,
sceneid=sid)
self._isce.topo = objTopo
def simamplitude(self,
topoImage,
simampImage,
shade=None,
width=None,
length=None):
if shade is not None: self.shadeScale = shade
if width is not None: self.width = width
if length is not None: self.length = length
self.topoImage = isceobj.createImage()
IU.copyAttributes(topoImage, self.topoImage)
self.topoImage.setCaster('read', 'FLOAT')
self.topoImage.createImage()
self.simampImage = simampImage
topoAccessor = self.topoImage.getImagePointer()
simampAccessor = self.simampImage.getImagePointer()
self.setDefaults()
self.setState()
simamplitude.simamplitude_Py(topoAccessor, simampAccessor)
return
def runShadecpx2rg(self):
width = self.insar.formSLC1.slcImage.getWidth()
filenameSimAmp = self._insar.getSimAmpImageName()
objSimAmp = isceobj.createImage()
widthSimAmp = width
objSimAmp.initImage(filenameSimAmp,'read',widthSimAmp,'FLOAT')
imageSimAmp = isceobj.createImage()
IU.copyAttributes(objSimAmp, imageSimAmp)
self._insar.setSimAmpImage(imageSimAmp)
objSimAmp.setAccessMode('write')
objSimAmp.createImage()
filenameHt = self._insar.getHeightFilename()
widthHgtImage = width # they have same width by construction
objHgtImage = isceobj.createImage()
objHgtImage.initImage(filenameHt,'read',widthHgtImage,'DOUBLE')
imageHgt = isceobj.createImage()
IU.copyAttributes(objHgtImage, imageHgt)
self._insar.setHeightTopoImage(imageHgt)
objHgtImage.setCaster('read','FLOAT')
objHgtImage.createImage()
logger.info("Running Shadecpx2rg")
objShade = isceobj.createSimamplitude()
#set the tag used in the outfile. each message is precided by this tag
#is the writer is not of "file" type the call has no effect
self._stdWriter.setFileTag("simamplitude", "log")
self._stdWriter.setFileTag("simamplitude", "err")
self._stdWriter.setFileTag("simamplitude", "out")
objShade.setStdWriter(self._stdWriter)
shade = self._insar.getShadeFactor()
objShade.simamplitude(objHgtImage, objSimAmp, shade=shade)
objHgtImage.finalizeImage()
objSimAmp.finalizeImage()
objSimAmp.renderHdr()
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 runOffsetprf(self):
from isceobj.Catalog import recordInputs
logger.info("Calculate offset between slcs using ampcor")
masterFrame = self._insar.getMasterFrame()
slaveFrame = self._insar.getSlaveFrame()
masterOrbit = self._insar.getMasterOrbit()
slaveOrbit = self._insar.getSlaveOrbit()
prf1 = masterFrame.getInstrument().getPulseRepetitionFrequency()
prf2 = slaveFrame.getInstrument().getPulseRepetitionFrequency()
nearRange1 = self.insar.formSLC1.startingRange
nearRange2 = self.insar.formSLC2.startingRange
fs1 = masterFrame.getInstrument().getRangeSamplingRate()
fs2 = slaveFrame.getInstrument().getRangeSamplingRate()
###There seems to be no other way of determining image length - Piyush
patchSize = self._insar.getPatchSize()
numPatches = self._insar.getNumberPatches()
valid_az_samples = self._insar.getNumberValidPulses()
firstAc = self._insar.getFirstSampleAcrossPrf()
firstDown = self._insar.getFirstSampleDownPrf()
numLocationAcross = self._insar.getNumberLocationAcrossPrf()
numLocationDown = self._insar.getNumberLocationDownPrf()
delRg1 = CN.SPEED_OF_LIGHT / (2 * fs1)
delRg2 = CN.SPEED_OF_LIGHT / (2 * fs2)
coarseRange = (nearRange1 - nearRange2) / delRg2
coarseAcross = int(coarseRange + 0.5)
if (coarseRange <= 0):
coarseAcross = int(coarseRange - 0.5)
pass
if self.grossRg is not None:
coarseAcross = self.grossRg
pass
s1 = self.insar.formSLC1.mocompPosition[1][0]
s1_2 = self.insar.formSLC1.mocompPosition[1][1]
s2 = self.insar.formSLC2.mocompPosition[1][0]
s2_2 = self.insar.formSLC2.mocompPosition[1][1]
coarseAz = int((s1 - s2) / (s2_2 - s2) + prf2 * (1 / prf1 - 1 / prf2) *
(patchSize - valid_az_samples) / 2)
coarseDown = int(coarseAz + 0.5)
if (coarseAz <= 0):
coarseDown = int(coarseAz - 0.5)
pass
if self.grossAz is not None:
coarseDown = self.grossAz
pass
coarseAcross = 0 + coarseAcross
coarseDown = 0 + coarseDown
mSlcImage = self._insar.getMasterSlcImage()
mSlc = isceobj.createSlcImage()
IU.copyAttributes(mSlcImage, mSlc)
accessMode = 'read'
mSlc.setAccessMode(accessMode)
mSlc.createImage()
masterWidth = mSlc.getWidth()
masterLength = mSlc.getLength()
sSlcImage = self._insar.getSlaveSlcImage()
sSlc = isceobj.createSlcImage()
IU.copyAttributes(sSlcImage, sSlc)
accessMode = 'read'
sSlc.setAccessMode(accessMode)
sSlc.createImage()
slaveWidth = sSlc.getWidth()
slaveLength = sSlc.getLength()
objAmpcor = Ampcor(name='insarapp_slcs_ampcor')
objAmpcor.configure()
objAmpcor.setImageDataType1('complex')
objAmpcor.setImageDataType2('complex')
if objAmpcor.acrossGrossOffset:
coarseAcross = objAmpcor.acrossGrossOffset
if objAmpcor.downGrossOffset:
coarseDown = objAmpcor.downGrossOffset
logger.debug("Gross Across: %s" % (coarseAcross))
logger.debug("Gross Down: %s" % (coarseDown))
xMargin = 2 * objAmpcor.searchWindowSizeWidth + objAmpcor.windowSizeWidth
yMargin = 2 * objAmpcor.searchWindowSizeHeight + objAmpcor.windowSizeHeight
#####Compute image positions
offAc = max(firstAc, -coarseAcross) + xMargin
offDn = max(firstDown, -coarseDown) + yMargin
offAcmax = int(coarseAcross + ((fs2 / fs1) - 1) * masterWidth)
logger.debug("Gross Max Across: %s" % (offAcmax))
lastAc = int(min(masterWidth, slaveWidth - offAcmax) - xMargin)
offDnmax = int(coarseDown + ((prf2 / prf1) - 1) * masterLength)
logger.debug("Gross Max Down: %s" % (offDnmax))
lastDown = int(min(masterLength, slaveLength - offDnmax) - yMargin)
if not objAmpcor.firstSampleAcross:
objAmpcor.setFirstSampleAcross(offAc)
if not objAmpcor.lastSampleAcross:
objAmpcor.setLastSampleAcross(lastAc)
if not objAmpcor.numberLocationAcross:
objAmpcor.setNumberLocationAcross(numLocationAcross)
if not objAmpcor.firstSampleDown:
objAmpcor.setFirstSampleDown(offDn)
if not objAmpcor.lastSampleDown:
objAmpcor.setLastSampleDown(lastDown)
if not objAmpcor.numberLocationDown:
objAmpcor.setNumberLocationDown(numLocationDown)
#####Override gross offsets if not provided
if not objAmpcor.acrossGrossOffset:
objAmpcor.setAcrossGrossOffset(coarseAcross)
if not objAmpcor.downGrossOffset:
objAmpcor.setDownGrossOffset(coarseDown)
#####User inputs are overriden here
objAmpcor.setFirstPRF(prf1)
objAmpcor.setSecondPRF(prf2)
objAmpcor.setFirstRangeSpacing(delRg1)
objAmpcor.setSecondRangeSpacing(delRg2)
# Record the inputs
recordInputs(self._insar.procDoc, objAmpcor, "runOffsetprf", logger,
"runOffsetprf")
objAmpcor.ampcor(mSlc, sSlc)
# Record the outputs
from isceobj.Catalog import recordOutputs
recordOutputs(self._insar.procDoc, objAmpcor, "runOffsetprf", logger,
"runOffsetprf")
mSlc.finalizeImage()
sSlc.finalizeImage()
# save the input offset field for the record
self._insar.setOffsetField(objAmpcor.getOffsetField())
self._insar.setRefinedOffsetField(objAmpcor.getOffsetField())
def run(frame1,
frame2,
orbit1,
orbit2,
formSlc1,
formSlc2,
imSlc1,
imSlc2,
infos,
catalog=None,
sceneid='NO_ID'):
logger.info("Calculate offset between slcs: %s" % sceneid)
prf1 = frame1.getInstrument().getPulseRepetitionFrequency()
prf2 = frame2.getInstrument().getPulseRepetitionFrequency()
nearRange1 = formSlc1.startingRange
nearRange2 = formSlc2.startingRange
fs1 = frame1.getInstrument().getRangeSamplingRate()
###There seems to be no other way of determining image length - Piyush
patchSize = infos['patchSize']
numPatches = infos['numberPatches']
valid_az_samples = infos['numberValidPulses']
firstAc = infos['firstSampleAcrossPrf']
firstDown = infos['firstSampleDownPrf']
numLocationAcross = infos['numberLocationAcrossPrf']
numLocationDown = infos['numberLocationDownPrf']
widthSlc = imSlc1.getWidth()
coarseRange = (nearRange1 - nearRange2) / (CN.SPEED_OF_LIGHT / (2 * fs1))
coarseAcross = int(coarseRange + 0.5)
if (coarseRange <= 0):
coarseAcross = int(coarseRange - 0.5)
grossRg = infos['grossRg']
print("gross Rg: ", grossRg)
if grossRg is not None:
coarseAcross = grossRg
time1, schPosition1, schVelocity1, offset1 = orbit1._unpackOrbit()
time2, schPosition2, schVelocity2, offset2 = orbit2._unpackOrbit()
s1 = schPosition1[0][0]
s1_2 = schPosition1[1][0]
s2 = schPosition2[0][0]
s2_2 = schPosition2[1][0]
coarseAz = int((s1 - s2) / (s2_2 - s2) + prf1 * (1 / prf1 - 1 / prf2) *
(patchSize - valid_az_samples) / 2)
coarseDown = int(coarseAz + 0.5)
if (coarseAz <= 0):
coarseDown = int(coarseAz - 0.5)
grossAz = infos['grossAz']
print("gross Az: ", grossAz)
if grossAz is not None:
coarseDown = grossAz
coarseAcross = 0 + coarseAcross
coarseDown = 0 + coarseDown
logger.debug("Gross Across: %s" % (coarseAcross))
logger.debug("Gross Down: %s" % (coarseDown))
offAc = max(firstAc, coarseAcross)
offDn = max(firstDown, coarseDown)
lastAc = widthSlc - offAc
lastDown = (numPatches * valid_az_samples) - offDn
mSlc = isceobj.createSlcImage()
IU.copyAttributes(imSlc1, mSlc)
accessMode = 'read'
mSlc.setAccessMode(accessMode)
mSlc.createImage()
sSlc = isceobj.createSlcImage()
IU.copyAttributes(imSlc2, sSlc)
accessMode = 'read'
sSlc.setAccessMode(accessMode)
sSlc.createImage()
objOffset = isceobj.createEstimateOffsets()
objOffset.setSearchWindowSize(infos['offsetSearchWindowSize'],
infos['sensorName'])
objOffset.setFirstSampleAcross(offAc)
objOffset.setLastSampleAcross(lastAc)
objOffset.setNumberLocationAcross(numLocationAcross)
objOffset.setFirstSampleDown(offDn)
objOffset.setLastSampleDown(lastDown)
objOffset.setNumberLocationDown(numLocationDown)
objOffset.setAcrossGrossOffset(coarseAcross)
objOffset.setDownGrossOffset(coarseDown)
objOffset.setFirstPRF(prf1)
objOffset.setSecondPRF(prf2)
if catalog is not None:
# Record the inputs
isceobj.Catalog.recordInputs(catalog, objOffset,
"runOffsetprf.%s" % sceneid, logger,
"runOffsetprf.%s" % sceneid)
objOffset.estimateoffsets(image1=mSlc, image2=sSlc, band1=0, band2=0)
if catalog is not None:
# Record the outputs
isceobj.Catalog.recordOutputs(catalog, objOffset,
"runOffsetprf.%s" % sceneid, logger,
"runOffsetprf.%s" % sceneid)
mSlc.finalizeImage()
sSlc.finalizeImage()
return objOffset.getOffsetField()
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
self.is_mocomp = self.insar.get_is_mocomp
v = self.insar.procVelocity
h = self.insar.averageHeight
imageSlc1 = self.insar.referenceRawImage
imSlc1 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc1, imSlc1)
imSlc1.setAccessMode('read')
imSlc1.createImage()
formSlc1 = stdproc.createFormSLC(self.sensorName)
formSlc1.setBodyFixedVelocity(v)
formSlc1.setSpacecraftHeight(h)
formSlc1.wireInputPort(name='doppler', object=self.insar.dopplerCentroid)
formSlc1.wireInputPort(name='peg', object=self.insar.peg)
formSlc1.wireInputPort(name='frame', object=self.insar.referenceFrame)
formSlc1.wireInputPort(name='orbit', object=self.insar.referenceOrbit)
formSlc1.wireInputPort(name='slcInImage', object=imSlc1)
formSlc1.wireInputPort(
name='planet',
object=self.insar.referenceFrame.instrument.platform.planet)
self._stdWriter.setFileTag("formslcTSX", "log")
self._stdWriter.setFileTag("formslcTSX", "err")
self._stdWriter.setFileTag("formslcTSX", "out")
formSlc1.setStdWriter(self._stdWriter)
formSlc1.setLookSide(self.insar._lookSide)
# self.insar.setReferenceSlcImage(formSlc1.formslc())
self.insar.referenceSlcImage = formSlc1()
imageSlc2 = self.insar.secondaryRawImage
imSlc2 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc2, imSlc2)
imSlc2.setAccessMode('read')
imSlc2.createImage()
formSlc2 = stdproc.createFormSLC(self.sensorName)
formSlc2.setBodyFixedVelocity(v)
formSlc2.setSpacecraftHeight(h)
formSlc2.wireInputPort(name='doppler', object=self.insar.dopplerCentroid)
formSlc2.wireInputPort(name='peg', object=self.insar.peg)
formSlc2.wireInputPort(name='frame', object=self.insar.secondaryFrame)
formSlc2.wireInputPort(name='orbit', object=self.insar.secondaryOrbit)
formSlc2.wireInputPort(name='slcInImage', object=imSlc2)
formSlc2.wireInputPort(
name='planet',
object=self.insar.secondaryFrame.instrument.platform.planet)
self._stdWriter.setFileTag("formslcTSX", "log")
self._stdWriter.setFileTag("formslcTSX", "err")
self._stdWriter.setFileTag("formslcTSX", "out")
formSlc2.setStdWriter(self._stdWriter)
formSlc2.setLookSide(self.insar._lookSide)
# self.insar.setSecondarySlcImage(formSlc2.formslc())
self.insar.secondarySlcImage = formSlc2()
self.insar.setNumberPatches(imSlc1.getLength() /
float(self.insar.numberValidPulses))
imSlc1.finalizeImage()
imSlc2.finalizeImage()
self.insar.setFormSLC1(formSlc1)
self.insar.setFormSLC2(formSlc2)
def run(imageAmp,
imageSim,
prf,
infos,
stdWriter,
catalog=None,
sceneid='NO_ID'):
logger.info("Running Rgoffset: %s" % sceneid)
firstAc = infos['firstSampleAcross']
firstDown = infos['firstSampleDown']
numLocationAcross = infos['numberLocationAcross']
numLocationDown = infos['numberLocationDown']
objAmp = isceobj.createIntImage()
IU.copyAttributes(imageAmp, objAmp)
objAmp.setAccessMode('read')
objAmp.createImage()
widthAmp = objAmp.getWidth()
intLength = objAmp.getLength()
lastAc = widthAmp - firstAc
lastDown = intLength - firstDown
objSim = isceobj.createImage()
IU.copyAttributes(imageSim, objSim)
objSim.setAccessMode('read')
objSim.createImage()
# Start modify from here ML 2014-08-05
#objOffset = isceobj.createEstimateOffsets()
objOffset = isceobj.createEstimateOffsets(
name='insarapp_intsim_estoffset') #ML 2014-08-05
objOffset.configure()
if objOffset.acrossGrossOffset is not None:
coarseAcross = objOffset.acrossGrossOffset
else:
coarseAcross = 0
if objOffset.downGrossOffset is not None:
coarseDown = objOffset.downGrossOffset
else:
coarseDown = 0
if objOffset.searchWindowSize is None:
objOffset.setSearchWindowSize(infos['offsetSearchWindowSize'],
infos['sensorName'])
margin = 2 * objOffset.searchWindowSize + objOffset.windowSize
simWidth = objSim.getWidth()
simLength = objSim.getLength()
firAc = max(firstAc, -coarseAcross) + margin + 1
firDn = max(firstDown, -coarseDown) + margin + 1
lastAc = int(min(widthAmp, simWidth - coarseAcross) - margin - 1)
lastDn = int(min(intLength, simLength - coarseDown) - margin - 1)
if not objOffset.firstSampleAcross:
objOffset.setFirstSampleAcross(firAc)
if not objOffset.lastSampleAcross:
objOffset.setLastSampleAcross(lastAc)
if not objOffset.numberLocationAcross:
objOffset.setNumberLocationAcross(numLocationAcross)
if not objOffset.firstSampleDown:
objOffset.setFirstSampleDown(firDn)
if not objOffset.lastSampleDown:
objOffset.setLastSampleDown(lastDn)
if not objOffset.numberLocationDown:
objOffset.setNumberLocationDown(numLocationDown)
# # old isceApp --- from here down
# objOffset.setSearchWindowSize(infos['offsetSearchWindowSize'], infos['sensorName'])
# objOffset.setFirstSampleAcross(firstAc)
# objOffset.setLastSampleAcross(lastAc)
# objOffset.setNumberLocationAcross(numLocationAcross)
# objOffset.setFirstSampleDown(firstDown)
# objOffset.setLastSampleDown(lastDown)
# objOffset.setNumberLocationDown(numLocationDown)
# #set the tag used in the outfile. each message is precided by this tag
# #if the writer is not of "file" type the call has no effect
objOffset.stdWriter = stdWriter.set_file_tags("rgoffset", "log", "err",
"out")
# objOffset.setFirstPRF(prf)
# objOffset.setSecondPRF(prf)
# objOffset.setAcrossGrossOffset(0)
# objOffset.setDownGrossOffset(0)
# objOffset.estimateoffsets(image1=objSim, image2=objAmp, band1=0, band2=0)
##set the tag used in the outfile. each message is precided by this tag
##is the writer is not of "file" type the call has no effect
##self._stdWriter.setFileTag("rgoffset", "log")
##self._stdWriter.setFileTag("rgoffset", "err")
##self._stdWriter.setFileTag("rgoffset", "out")
##objOffset.setStdWriter(self._stdWriter)
##prf = self._insar.getReferenceFrame().getInstrument().getPulseRepetitionFrequency()
objOffset.setFirstPRF(prf)
objOffset.setSecondPRF(prf)
if not objOffset.acrossGrossOffset:
objOffset.setAcrossGrossOffset(0)
if not objOffset.downGrossOffset:
objOffset.setDownGrossOffset(0)
objOffset.estimateoffsets(image1=objSim, image2=objAmp, band1=0, band2=0)
if catalog is not None:
# Record the inputs and outputs
isceobj.Catalog.recordInputsAndOutputs(catalog, objOffset,
"runRgoffset.%s" % sceneid,
logger,
"runRgoffset.%s" % sceneid)
objAmp.finalizeImage()
objSim.finalizeImage()
return objOffset.getOffsetField()
def run(frame1,
objFormSLC1,
objMocompbaseline,
topoIntImage,
velocity,
height,
infos,
stdWriter,
catalog=None,
sceneid='NO_ID'):
logger.info("Running correct: %s" % sceneid)
intImage = isceobj.createIntImage()
#just pass the image object to Correct and it will handle the creation
# and deletion of the actual image pointer
IU.copyAttributes(topoIntImage, intImage)
posIndx = 1
mocompPosition1 = objFormSLC1.mocompPosition
centroid = infos['dopplerCentroid'].getDopplerCoefficients(inHz=False)[0]
planet = frame1.instrument.platform.planet
prf1 = frame1.instrument.PRF
objCorrect = stdproc.createCorrect()
objCorrect.wireInputPort(name='peg', object=infos['peg'])
objCorrect.wireInputPort(name='frame', object=frame1)
objCorrect.wireInputPort(name='planet', object=planet)
objCorrect.wireInputPort(name='interferogram', object=intImage)
objCorrect.wireInputPort(name='masterslc', object=objFormSLC1) #Piyush
objCorrect.setDopplerCentroidConstantTerm(centroid)
# Average velocity and height measurements
objCorrect.setBodyFixedVelocity(velocity)
objCorrect.setSpacecraftHeight(height)
# Need the reference orbit from Formslc
objCorrect.setReferenceOrbit(mocompPosition1[posIndx])
objCorrect.setMocompBaseline(objMocompbaseline.baseline)
sch12 = objMocompbaseline.getSchs()
objCorrect.setSch1(sch12[0])
objCorrect.setSch2(sch12[1])
sc = objMocompbaseline.sc
objCorrect.setSc(sc)
midpoint = objMocompbaseline.midpoint
objCorrect.setMidpoint(midpoint)
objCorrect.setLookSide(infos['lookSide'])
objCorrect.setNumberRangeLooks(infos['numberRangeLooks'])
objCorrect.setNumberAzimuthLooks(infos['numberAzimuthLooks'])
objCorrect.setTopophaseMphFilename(infos['outputPath'] + '.' +
infos['topophaseMphFilename'])
objCorrect.setTopophaseFlatFilename(infos['outputPath'] + '.' +
infos['topophaseFlatFilename'])
objCorrect.setHeightSchFilename(infos['refOutputPath'] + '.' +
infos['heightSchFilename'])
objCorrect.setISMocomp(infos['is_mocomp'])
#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
objCorrect.stdWriter = stdWriter.set_file_tags("correct", "log", "err",
"out")
objCorrect() #.correct()
if catalog is not None:
# Record the inputs and outputs
isceobj.Catalog.recordInputsAndOutputs(catalog, objCorrect,
"runCorrect.%s" % sceneid,
logger,
"runCorrect.%s" % sceneid)
return objCorrect
def _run_ampcor(self, firstAc, lastAc, firstDn, lastDn, numAc, numDn,
firstind, lastind):
'''
Individual calls to ampcor.
'''
os.environ['VRT_SHARED_SOURCE'] = "0"
objAmpcor = Ampcor()
objAmpcor.setWindowSizeWidth(self.windowSizeWidth)
objAmpcor.setWindowSizeHeight(self.windowSizeHeight)
objAmpcor.setSearchWindowSizeWidth(self.searchWindowSizeWidth)
objAmpcor.setSearchWindowSizeHeight(self.searchWindowSizeHeight)
objAmpcor.setImageDataType1(self.imageDataType1)
objAmpcor.setImageDataType2(self.imageDataType2)
objAmpcor.setFirstSampleAcross(firstAc)
objAmpcor.setLastSampleAcross(lastAc)
objAmpcor.setNumberLocationAcross(numAc)
objAmpcor.setFirstSampleDown(firstDn)
objAmpcor.setLastSampleDown(lastDn)
objAmpcor.setNumberLocationDown(numDn)
objAmpcor.setAcrossGrossOffset(self.acrossGrossOffset)
objAmpcor.setDownGrossOffset(self.downGrossOffset)
objAmpcor.setFirstPRF(self.prf1)
objAmpcor.setSecondPRF(self.prf2)
objAmpcor.setFirstRangeSpacing(self.rangeSpacing1)
objAmpcor.setSecondRangeSpacing(self.rangeSpacing2)
objAmpcor.thresholdSNR = 1.0e-6
objAmpcor.thresholdCov = self.thresholdCov
objAmpcor.oversamplingFactor = self.oversamplingFactor
mSlc = isceobj.createImage()
IU.copyAttributes(self.slcImage1, mSlc)
mSlc.setAccessMode('read')
mSlc.createImage()
sSlc = isceobj.createImage()
IU.copyAttributes(self.slcImage2, sSlc)
sSlc.setAccessMode('read')
sSlc.createImage()
objAmpcor.ampcor(mSlc, sSlc)
mSlc.finalizeImage()
sSlc.finalizeImage()
j = 0
length = len(objAmpcor.locationDown)
for i in range(lastind - firstind):
acInd = firstAc + self.pixLocOffAc + (
i % numAc) * self.skipSampleAcross
downInd = firstDn + self.pixLocOffDn + (
i // numAc) * self.skipSampleDown
if j < length and objAmpcor.locationDown[
j] == downInd and objAmpcor.locationAcross[j] == acInd:
self.locationDown[firstind + i] = objAmpcor.locationDown[j]
self.locationDownOffset[firstind +
i] = objAmpcor.locationDownOffset[j]
self.locationAcross[firstind + i] = objAmpcor.locationAcross[j]
self.locationAcrossOffset[
firstind + i] = objAmpcor.locationAcrossOffset[j]
self.snr[firstind + i] = objAmpcor.snrRet[j]
self.cov1[firstind + i] = objAmpcor.cov1Ret[j]
self.cov2[firstind + i] = objAmpcor.cov2Ret[j]
self.cov3[firstind + i] = objAmpcor.cov3Ret[j]
j += 1
else:
self.locationDown[firstind + i] = downInd
self.locationDownOffset[firstind + i] = -10000.
self.locationAcross[firstind + i] = acInd
self.locationAcrossOffset[firstind + i] = -10000.
self.snr[firstind + i] = 0.
self.cov1[firstind + i] = 999.
self.cov2[firstind + i] = 999.
self.cov3[firstind + i] = 999.
return
def runResamp_only(self):
imageInt = self._insar.getResampIntImage()
imageAmp = self._insar.getResampAmpImage()
objInt = isceobj.createIntImage()
objIntOut = isceobj.createIntImage()
IU.copyAttributes(imageInt, objInt)
IU.copyAttributes(imageInt, objIntOut)
outIntFilename = self._insar.getResampOnlyImageName()
objInt.setAccessMode('read')
objIntOut.setFilename(outIntFilename)
self._insar.setResampOnlyImage(objIntOut)
objIntOut.setAccessMode('write')
objInt.createImage()
objIntOut.createImage()
objAmp = isceobj.createAmpImage()
objAmpOut = isceobj.createAmpImage()
IU.copyAttributes(imageAmp, objAmp)
IU.copyAttributes(imageAmp, objAmpOut)
outAmpFilename = self.insar.resampOnlyAmpName
objAmp.setAccessMode('read')
objAmpOut.setFilename(outAmpFilename)
self._insar.setResampOnlyAmp(objAmpOut)
objAmpOut.setAccessMode('write')
objAmp.createImage()
objAmpOut.createImage()
numRangeBin = objInt.getWidth()
lines = objInt.getLength()
instrument = self._insar.getMasterFrame().getInstrument()
offsetField = self._insar.getRefinedOffsetField()
dopplerCoeff = self._insar.getDopplerCentroid().getDopplerCoefficients(
inHz=False)
numFitCoeff = self._insar.getNumberFitCoefficients()
pixelSpacing = self._insar.getSlantRangePixelSpacing()
objResamp = stdproc.createResamp_only()
objResamp.setNumberLines(lines)
objResamp.setNumberFitCoefficients(numFitCoeff)
objResamp.setSlantRangePixelSpacing(pixelSpacing)
objResamp.setNumberRangeBin(numRangeBin)
objResamp.setDopplerCentroidCoefficients(dopplerCoeff)
objResamp.wireInputPort(name='offsets', object=offsetField)
objResamp.wireInputPort(name='instrument', object=instrument)
#set the tag used in the outfile. each message is precided by this tag
#is the writer is not of "file" type the call has no effect
self._stdWriter.setFileTag("resamp_only", "log")
self._stdWriter.setFileTag("resamp_only", "err")
self._stdWriter.setFileTag("resamp_only", "out")
objResamp.setStdWriter(self._stdWriter)
objResamp.resamp_only(objInt, objIntOut, objAmp, objAmpOut)
# Record the inputs and outputs
from isceobj.Catalog import recordInputsAndOutputs
recordInputsAndOutputs(self._insar.procDoc, objResamp, "runResamp_only", \
logger, "runResamp_only")
objInt.finalizeImage()
objIntOut.finalizeImage()
objAmp.finalizeImage()
objAmpOut.finalizeImage()
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()
def runCorrect(self):
logger.info("Running correct")
objMocompbaseline = self.insar.mocompBaseline
objFormSlc1 = self.insar.formSLC1
topoIntImage = self.insar.topoIntImage
intImage = isceobj.createIntImage()
#just pass the image object to Correct and it will handle the creation
# and deletion of the actual image pointer
IU.copyAttributes(topoIntImage, intImage)
posIndx = 1
mocompPosition1 = objFormSlc1.mocompPosition
planet = self.insar.masterFrame.instrument.platform.planet
prf1 = self.insar.masterFrame.instrument.PRF
objCorrect = stdproc.createCorrect()
objCorrect.wireInputPort(name='peg', object=self.insar.peg)
objCorrect.wireInputPort(name='frame', object=self.insar.masterFrame)
objCorrect.wireInputPort(name='planet', object=planet)
objCorrect.wireInputPort(name='interferogram', object=intImage)
objCorrect.wireInputPort(name='masterslc', object=self.insar.formSLC1) #Piyush
# Average velocity and height measurements
v = self.insar.procVelocity
h = self.insar.averageHeight
objCorrect.setBodyFixedVelocity(v)
objCorrect.setSpacecraftHeight(h)
# Need the reference orbit from Formslc
objCorrect.setReferenceOrbit(mocompPosition1[posIndx])
objCorrect.setMocompBaseline(objMocompbaseline.baseline)
sch12 = objMocompbaseline.getSchs()
objCorrect.setSch1(sch12[0])
objCorrect.setSch2(sch12[1])
sc = objMocompbaseline.sc
objCorrect.setSc(sc)
midpoint = objMocompbaseline.midpoint
objCorrect.setMidpoint(midpoint)
objCorrect.setLookSide(self.insar._lookSide)
objCorrect.setNumberRangeLooks(self.insar.numberRangeLooks)
objCorrect.setNumberAzimuthLooks(self.insar.numberAzimuthLooks)
objCorrect.setTopophaseMphFilename(self.insar.topophaseMphFilename)
objCorrect.setTopophaseFlatFilename(self.insar.topophaseFlatFilename)
objCorrect.setHeightSchFilename(self.insar.heightSchFilename)
objCorrect.setISMocomp(self.insar.is_mocomp)
#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
objCorrect.stdWriter = self._writer_set_file_tags("correct",
"log", "err", "out")
objCorrect()#.correct()
# Record the inputs and outputs
from isceobj.Catalog import recordInputsAndOutputs
recordInputsAndOutputs(self.insar.procDoc, objCorrect, "runCorrect",
logger, "runCorrect")
return objCorrect