def runEstimateHeights(self):
from isceobj.Catalog import recordInputsAndOutputs
chv = []
for frame, orbit, tag in zip((self._insar.getMasterFrame(),
self._insar.getSlaveFrame()),
(self.insar.masterOrbit,
self.insar.slaveOrbit),
('master', 'slave')):
(time, position, velocity, offset) = orbit._unpackOrbit()
half = len(position)//2 - 1
xyz = position[half]
import math
sch = frame._ellipsoid.xyz_to_sch(xyz)
chv.append(stdproc.createCalculateFdHeights())
chv[-1].height = sch[2]
recordInputsAndOutputs(self.procDoc, chv[-1],
"runEstimateHeights.CHV_"+tag, logger,
"runEstimateHeights.CHV_"+tag)
self.insar.fdH1, self.insar.fdH2 = [item.height for item in chv]
return None
def runOrbit2sch_new(self):
from isceobj.Catalog import recordInputsAndOutputs
logger.info("Converting the orbit to SCH coordinates")
pegHAvg = self.insar.averageHeight
peg = self.insar.peg
planet = self.insar.planet
masterOrbit = self.insar.masterOrbit
slaveOrbit = self.insar.slaveOrbit
objOrbit2sch1 = stdproc.createOrbit2sch(averageHeight=pegHAvg)
objOrbit2sch1.stdWriter = self.stdWriter.set_file_tags(
"orbit2sch", "log", "err", "log")
objOrbit2sch2 = stdproc.createOrbit2sch(averageHeight=pegHAvg)
objOrbit2sch2.stdWriter = self.stdWriter
## loop over master/slave orbits
for obj, orb, tag in zip((objOrbit2sch1, objOrbit2sch2),
(self.insar.masterOrbit, self.insar.slaveOrbit),
('master', 'slave')):
obj(planet=planet, orbit=orb, peg=peg)
recordInputsAndOutputs(self.insar.procDoc, obj, "runOrbit2sch." + tag,
logger, "runOrbit2sch." + tag)
self.insar.masterOrbit = objOrbit2sch1.orbit
self.insar.slaveOrbit = objOrbit2sch2.orbit
return None
def runOrbit2sch(self):
from isceobj.Catalog import recordInputsAndOutputs
import numpy
logger.info("Converting the orbit to SCH coordinates")
# Piyush
####We don't know the correct SCH heights yet.
####Not computing average peg height yet.
peg = self.insar.peg
pegHavg = self.insar.averageHeight
planet = self.insar.planet
# if self.pegSelect.upper() == 'MASTER':
# pegHavg = self.insar.getFirstAverageHeight()
# elif self.pegSelect.upper() == 'SLAVE':
# pegHavg = self.insar.getSecondAverageHeight()
# elif self.pegSelect.upper() == 'AVERAGE':
# pegHavg = self.insar.averageHeight
# else:
# raise Exception('Unknown peg selection method: ', self.pegSelect)
masterOrbit = self.insar.masterOrbit
slaveOrbit = self.insar.slaveOrbit
objOrbit2sch1 = stdproc.createOrbit2sch(averageHeight=pegHavg)
objOrbit2sch1.stdWriter = self.stdWriter.set_file_tags("orbit2sch",
"log",
"err",
"log")
objOrbit2sch2 = stdproc.createOrbit2sch(averageHeight=pegHavg)
objOrbit2sch2.stdWriter = self.stdWriter
## loop over master/slave orbits
for obj, orb, tag, order in zip((objOrbit2sch1, objOrbit2sch2),
(self.insar.masterOrbit, self.insar.slaveOrbit),
('master', 'slave'),
('First', 'Second')):
obj(planet=planet, orbit=orb, peg=peg)
recordInputsAndOutputs(self.insar.procDoc, obj,
"runOrbit2sch." + tag,
logger,
"runOrbit2sch." + tag)
#equivalent to self.insar.masterOrbit =
setattr(self.insar,'%sOrbit'%(tag), obj.orbit)
#Piyush
####The heights and the velocities need to be updated now.
(ttt, ppp, vvv, rrr) = obj.orbit._unpackOrbit()
#equivalent to self.insar.setFirstAverageHeight()
# SCH heights replacing the earlier llh heights
# getattr(self.insar,'set%sAverageHeight'%(order))(numpy.sum(numpy.array(ppp),axis=0)[2] /(1.0*len(ppp)))
#equivalent to self.insar.setFirstProcVelocity()
getattr(self.insar,'set%sProcVelocity'%(order))(vvv[len(vvv)//2][0])
return None
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 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 runEstimateHeights(self):
from isceobj.Catalog import recordInputsAndOutputs
chv = []
for frame, orbit, tag in zip(
(self._insar.getMasterFrame(), self._insar.getSlaveFrame()),
(self.insar.masterOrbit, self.insar.slaveOrbit), ('master', 'slave')):
chv.append(stdproc.createCalculateFdHeights())
chv[-1](frame=frame, orbit=orbit, planet=self.planet)
recordInputsAndOutputs(self.procDoc, chv[-1],
"runEstimateHeights.CHV_" + tag, logger,
"runEstimateHeights.CHV_" + tag)
self.insar.fdH1, self.insar.fdH2 = [item.height for item in chv]
return None
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 runOffoutliers(self, distance, errorLimit=100):
#offoutliers returns a list of modified locations
#the list of lists is
#list[0] = location across
#list[1] = location across offset
#list[2] = location down
#list[3] = location down offset
#list[4] = snr
#list[5] = sig
logger.info('Error limit = %d' % (errorLimit))
warnLimit = errorLimit * 3
logger.info("Culling offset field outliers")
rgOffsets = self._insar.getRefinedOffsetField()
logger.info('Number of input offsets: %d' % (len(rgOffsets._offsets)))
logger.info('Distance: %f' % (distance))
objOff = isceobj.createOffoutliers()
objOff.wireInputPort(name='offsets', object=rgOffsets)
objOff.setSNRThreshold(2.0)
objOff.setDistance(distance)
#set the tag used in the outfile. each message is precided by this tag
#is the writer is not of "file" type the call has no effect
self._stdWriter.setFileTag("offoutliers", "log")
self._stdWriter.setFileTag("offoutliers", "err")
self._stdWriter.setFileTag("offoutliers", "out")
objOff.setStdWriter(self._stdWriter)
objOff.offoutliers()
# Record the inputs and outputs
from isceobj.Catalog import recordInputsAndOutputs
recordInputsAndOutputs(self._insar.procDoc, objOff, "runOffoutliers",
logger, "runOffoutliers")
refinedOffsets = objOff.getRefinedOffsetField()
lenOut = len(refinedOffsets._offsets)
logger.info('Number of offsets left after culling: %d' % (lenOut))
if lenOut < errorLimit:
logger.error(
'Small number of output Offsets after culling: %d .\n Increase number of windows (or) window sizes (or) provide gross offset manually.'
% (lenOut))
raise Exception('Offset estimation Failed.')
elif lenOut < warnLimit:
logger.warn(
'Number of output offsets after culling are low: %d. Might be ok to continue.'
% (lenOut))
self._insar.setRefinedOffsetField(refinedOffsets)
def runMocompbaseline(self):
logger.info("Calculating Baseline")
ellipsoid = self._insar.getMasterFrame().getInstrument().getPlatform(
).getPlanet().get_elp()
# schPositions computed in orbit2sch
# objFormSlc's created during formSlc
h = self.insar.averageHeight
objFormSlc1 = self.insar.formSLC1
objFormSlc2 = self.insar.formSLC2
mocompPosition1 = objFormSlc1.getMocompPosition()
mocompIndex1 = objFormSlc1.getMocompIndex()
mocompPosition2 = objFormSlc2.getMocompPosition()
mocompIndex2 = objFormSlc2.getMocompIndex()
objMocompbaseline = stdproc.createMocompbaseline()
objMocompbaseline.setMocompPosition1(mocompPosition1[posIndx])
objMocompbaseline.setMocompPositionIndex1(mocompIndex1)
objMocompbaseline.setMocompPosition2(mocompPosition2[posIndx])
objMocompbaseline.setMocompPositionIndex2(mocompIndex2)
objMocompbaseline.wireInputPort(name='masterOrbit',
object=self.insar.masterOrbit)
objMocompbaseline.wireInputPort(name='slaveOrbit',
object=self.insar.slaveOrbit)
objMocompbaseline.wireInputPort(name='ellipsoid', object=ellipsoid)
objMocompbaseline.wireInputPort(name='peg', object=self.insar.peg)
objMocompbaseline.setHeight(h)
#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("mocompbaseline", "log")
self._stdWriter.setFileTag("mocompbaseline", "err")
self._stdWriter.setFileTag("mocompbaseline", "out")
objMocompbaseline.setStdWriter(self._stdWriter)
objMocompbaseline.mocompbaseline()
# Record the inputs and outputs
from isceobj.Catalog import recordInputsAndOutputs
recordInputsAndOutputs(self._insar.procDoc, objMocompbaseline,
"runMocompbaseline", logger, "runMocompbaseline")
self.insar.mocompBaseline = objMocompbaseline
return None
def runSetmocomppath_new(self, peg=None):
from isceobj.Location.Peg import Peg
from stdproc.orbit.pegManipulator import averagePeg
from isceobj.Catalog import recordInputsAndOutputs
logger.info("Selecting individual peg points")
planet = self._insar.getMasterFrame().getInstrument().getPlatform(
).getPlanet()
masterOrbit = self._insar.getMasterOrbit()
slaveOrbit = self._insar.getSlaveOrbit()
pegpts = []
for orbitObj, order in zip((masterOrbit, slaveOrbit), ('First', 'Second')):
objGetpeg = stdproc.createGetpeg()
if peg:
objGetpeg.setPeg(peg)
objGetpeg.wireInputPort(name='planet', object=planet)
objGetpeg.wireInputPort(name='Orbit', object=orbitObj)
self._stdWriter.setFileTag("getpeg", "log")
self._stdWriter.setFileTag("getpeg", "err")
self._stdWriter.setFileTag("getpeg", "out")
objGetpeg.setStdWriter(self._stdWriter)
logger.info('Peg points are computed for individual SAR scenes.')
objGetpeg.estimatePeg()
pegpts.append(objGetpeg.getPeg())
recordInputsAndOutputs(self._insar.procDoc, objGetpeg, "getpeg", \
logger, "runSetmocomppath")
#Piyush
# I set these values here for the sake of continuity, but they need to be updated
# in orbit2sch as the correct peg point is not yet known
getattr(self._insar,
'set%sAverageHeight' % (order))(objGetpeg.getAverageHeight())
getattr(self._insar,
'set%sProcVelocity' % (order))(objGetpeg.getProcVelocity())
logger.info('Combining individual peg points.')
peg = averagePeg(pegpts, planet)
self._insar.setPeg(peg)
def runSetmocomppath_old(self, peg=None):
logger.info("Selecting Peg Points")
objSetmocomppath = stdproc.createSetmocomppath()
if peg:
objSetmocomppath.setPeg(peg)
planet = self._insar.getMasterFrame().getInstrument().getPlatform(
).getPlanet()
masterOrbit = self._insar.getMasterOrbit()
slaveOrbit = self._insar.getSlaveOrbit()
objSetmocomppath.wireInputPort(name='planet', object=planet)
objSetmocomppath.wireInputPort(name='masterOrbit', object=masterOrbit)
objSetmocomppath.wireInputPort(name='slaveOrbit', object=slaveOrbit)
#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("setmocomppath", "log")
self._stdWriter.setFileTag("setmocomppath", "err")
self._stdWriter.setFileTag("setmocomppath", "out")
objSetmocomppath.setStdWriter(self._stdWriter)
objSetmocomppath.setmocomppath()
# Record the inputs and outputs
from isceobj.Catalog import recordInputsAndOutputs
recordInputsAndOutputs(self._insar.procDoc, objSetmocomppath, "setmocomppath", \
logger, "runSetmocomppath")
# Set peg information in the self._insar object
peg = objSetmocomppath.getPeg()
h1 = objSetmocomppath.getFirstAverageHeight()
h2 = objSetmocomppath.getSecondAverageHeight()
v1 = objSetmocomppath.getFirstProcVelocity()
v2 = objSetmocomppath.getSecondProcVelocity()
self._insar.setPeg(peg)
self._insar.setFirstAverageHeight(h1)
self._insar.setSecondAverageHeight(h2)
self._insar.setFirstProcVelocity(v1)
self._insar.setSecondProcVelocity(v2)
def runOrbit2sch_old(self):
from isceobj.Catalog import recordInputsAndOutputs
logger.info("Converting the orbit to SCH coordinates")
pegHAvg = self.insar.averageHeight
peg = self.insar.peg
planet = self.insar.planet
masterOrbit = self.insar.masterOrbit
slaveOrbit = self.insar.slaveOrbit
objOrbit2sch1 = stdproc.createOrbit2sch(averageHeight=pegHAvg)
objOrbit2sch1.stdWriter = self.stdWriter.set_file_tags(
"orbit2sch", "log", "err", "log")
objOrbit2sch1(planet=planet, orbit=masterOrbit, peg=peg)
# Record the inputs and outputs
recordInputsAndOutputs(self.insar.procDoc, objOrbit2sch1,
"runOrbit2sch.master", logger,
"runOrbit2sch.master")
objOrbit2sch2 = stdproc.createOrbit2sch(averageHeight=pegHAvg)
objOrbit2sch2.stdWriter = self.stdWriter
# objOrbit2sch2.wireInputPort(name='planet', object=planet)
# objOrbit2sch2.wireInputPort(name='orbit', object=slaveOrbit)
# objOrbit2sch2.wireInputPort(name='peg', object=peg)
objOrbit2sch2(planet=planet, orbit=slaveOrbit, peg=peg)
# Record the inputs and outputs
recordInputsAndOutputs(self.insar.procDoc, objOrbit2sch2,
"runOrbit2sch.slave", logger, "runOrbit2sch.slave")
self.insar.masterOrbit = objOrbit2sch1.orbit
self.insar.slaveOrbit = objOrbit2sch2.orbit
return None
def runRgoffset(self):
numLocationAcross = self._insar.getNumberLocationAcrossPrf()
numLocationDown = self._insar.getNumberLocationDownPrf()
firstAc = self._insar.getFirstSampleAcrossPrf()
firstDown = self._insar.getFirstSampleDownPrf()
#Fake amplitude image as a complex image
imageAmp = self._insar.getResampAmpImage()
objAmp = isceobj.createImage()
objAmp.setAccessMode('read')
objAmp.dataType = 'CFLOAT'
objAmp.bands = 1
objAmp.setFilename(imageAmp.filename)
objAmp.setWidth(imageAmp.width)
objAmp.createImage()
widthAmp = objAmp.getWidth()
intLength = objAmp.getLength()
imageSim = self._insar.getSimAmpImage()
objSim = isceobj.createImage()
objSim.setFilename(imageSim.filename)
objSim.setWidth(imageSim.width)
objSim.dataType = 'FLOAT'
objSim.setAccessMode('read')
objSim.createImage()
simWidth = imageSim.getWidth()
simLength = imageSim.getLength()
fs1 = self._insar.getReferenceFrame().getInstrument().getRangeSamplingRate(
) ##check
delRg1 = CN.SPEED_OF_LIGHT / (2 * fs1) ## if it's correct
objAmpcor = Ampcor(name='insarapp_intsim_ampcor')
objAmpcor.configure()
objAmpcor.setImageDataType1('real')
objAmpcor.setImageDataType2('mag')
####Adjust first and last values using window sizes
xMargin = 2 * objAmpcor.searchWindowSizeWidth + objAmpcor.windowSizeWidth
yMargin = 2 * objAmpcor.searchWindowSizeHeight + objAmpcor.windowSizeHeight
if not objAmpcor.acrossGrossOffset:
coarseAcross = 0
else:
coarseAcross = objAmpcor.acrossGrossOffset
if not objAmpcor.downGrossOffset:
coarseDown = 0
else:
coarseDown = objAmpcor.downGrossOffset
offAc = max(firstAc, -coarseAcross) + xMargin + 1
offDn = max(firstDown, -coarseDown) + yMargin + 1
lastAc = int(min(widthAmp, simWidth - offAc) - xMargin - 1)
lastDn = int(min(intLength, simLength - offDn) - yMargin - 1)
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(lastDn)
if not objAmpcor.numberLocationDown:
objAmpcor.setNumberLocationDown(numLocationDown)
#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")
objAmpcor.setStdWriter(self._stdWriter)
prf = self._insar.getReferenceFrame().getInstrument(
).getPulseRepetitionFrequency()
objAmpcor.setFirstPRF(prf)
objAmpcor.setSecondPRF(prf)
if not objAmpcor.acrossGrossOffset:
objAmpcor.setAcrossGrossOffset(coarseAcross)
if not objAmpcor.downGrossOffset:
objAmpcor.setDownGrossOffset(coarseDown)
objAmpcor.setFirstRangeSpacing(delRg1)
objAmpcor.setSecondRangeSpacing(delRg1)
objAmpcor.ampcor(objSim, objAmp)
# Record the inputs and outputs
from isceobj.Catalog import recordInputsAndOutputs
recordInputsAndOutputs(self._insar.procDoc, objAmpcor, "runRgoffset_ampcor", \
logger, "runRgoffset_ampcor")
self._insar.setOffsetField(objAmpcor.getOffsetField())
self._insar.setRefinedOffsetField(objAmpcor.getOffsetField())
objAmp.finalizeImage()
objSim.finalizeImage()
def runTopo(self):
from zerodop.topozero import createTopozero
from isceobj.Planet.Planet import Planet
logger.info("Running topo")
#IU.copyAttributes(demImage, objDem)
objDem = self.insar.demImage.clone()
info = self.insar.masterFrame
slc = self.insar.formSLC1
intImage = slc.slcImage
planet = info.getInstrument().getPlatform().getPlanet()
topo = createTopozero()
topo.slantRangePixelSpacing = 0.5 * SPEED_OF_LIGHT / info.rangeSamplingRate
topo.prf = info.PRF
topo.radarWavelength = info.radarWavelegth
topo.orbit = info.orbit
topo.width = intImage.getWidth()
topo.length = intImage.getLength()
topo.wireInputPort(name='dem', object=objDem)
topo.wireInputPort(name='planet', object=planet)
topo.numberRangeLooks = 1
topo.numberAzimuthLooks = 1
topo.lookSide = info.getInstrument().getPlatform().pointingDirection
topo.sensingStart = slc.slcSensingStart
topo.rangeFirstSample = slc.startingRange
topo.demInterpolationMethod='BIQUINTIC'
topo.latFilename = self.insar.latFilename
topo.lonFilename = self.insar.lonFilename
topo.losFilename = self.insar.losFilename
topo.heightFilename = self.insar.heightFilename
# topo.incFilename = os.path.join(info.outdir, 'inc.rdr')
# topo.maskFilename = os.path.join(info.outdir, 'mask.rdr')
####Doppler adjustment
dop = info._dopplerVsPixel[::-1]
xx = np.linspace(0, (topo.width-1), num=len(dop)+ 1)
x = (topo.rangeFirstSample - info.startingRange)/topo.slantRangePixelSpacing + xx * topo.numberRangeLooks
v = np.polyval(dop, x)
p = np.polyfit(xx, v, len(dop)-1)[::-1]
doppler = Poly2D()
doppler.setWidth(topo.width)
doppler.setLength(topo.length)
doppler.initPoly(rangeOrder = len(dop)-1, azimuthOrder=0, coeffs=[list(p)])
topo.polyDoppler = doppler
topo.topo()
# Record the inputs and outputs
from isceobj.Catalog import recordInputsAndOutputs
recordInputsAndOutputs(self._insar.procDoc, topo, "runTopo",
logger, "runTopo")
self._insar.setTopo(topo)
return topo
def runResamp(self):
logger.info("Resampling interferogram")
imageSlc1 = self.insar.referenceSlcImage
imageSlc2 = self.insar.secondarySlcImage
resampName = self.insar.resampImageName
resampAmp = resampName + '.amp'
resampInt = resampName + '.int'
azLooks = self.insar.numberAzimuthLooks
rLooks = self.insar.numberRangeLooks
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 = max(imageSlc1.getWidth(), imageSlc2.getWidth())
slcWidth = imageSlc1.getWidth()
intWidth = int(slcWidth / rLooks)
dataType = 'CFLOAT'
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()
self.insar.resampIntImage = imageInt
self.insar.resampAmpImage = imageAmp
instrument = self.insar.referenceFrame.getInstrument()
offsetField = self.insar.refinedOffsetField
lines = self.insar.numberResampLines
####Modified to deal with secondary PRF correctly
dopplerCoeff = self.insar.dopplerCentroid.getDopplerCoefficients(inHz=True)
for num in range(len(dopplerCoeff)):
dopplerCoeff[num] /= self.insar.secondaryFrame.getInstrument(
).getPulseRepetitionFrequency()
numFitCoeff = self.insar.numberFitCoefficients
# pixelSpacing = self.insar.slantRangePixelSpacing
fS = self._insar.getSecondaryFrame().getInstrument().getRangeSamplingRate()
pixelSpacing = CN.SPEED_OF_LIGHT / (2. * fS)
objResamp = stdproc.createResamp()
objResamp.setNumberLines(lines)
objResamp.setNumberFitCoefficients(numFitCoeff)
objResamp.setNumberAzimuthLooks(azLooks)
objResamp.setNumberRangeLooks(rLooks)
objResamp.setSlantRangePixelSpacing(pixelSpacing)
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
objResamp.stdWriter = self._writer_set_file_tags("resamp", "log", "err",
"out")
objResamp.resamp(objSlc1, objSlc2, objInt, objAmp)
# Record the inputs and outputs
from isceobj.Catalog import recordInputsAndOutputs
recordInputsAndOutputs(self._insar.procDoc, objResamp, "runResamp", logger,
"runResamp")
objInt.finalizeImage()
objAmp.finalizeImage()
objSlc1.finalizeImage()
objSlc2.finalizeImage()
return None
def runSetmocomppath(self, peg=None):
from isceobj.Location.Peg import Peg
from stdproc.orbit.pegManipulator import averagePeg
from isceobj.Catalog import recordInputsAndOutputs
logger.info("Selecting individual peg points")
planet = self._insar.getReferenceFrame().getInstrument().getPlatform().getPlanet()
referenceOrbit = self._insar.getReferenceOrbit()
secondaryOrbit = self._insar.getSecondaryOrbit()
if peg:
self._insar.setPeg(peg)
logger.info("Using the given peg = %r", peg)
self._insar.setFirstAverageHeight(
averageHeightAboveElp(planet, peg, referenceOrbit))
self._insar.setSecondAverageHeight(
averageHeightAboveElp(planet, peg, secondaryOrbit))
self._insar.setFirstProcVelocity(
sVelocityAtMidOrbit(planet, peg, referenceOrbit))
self._insar.setSecondProcVelocity(
sVelocityAtMidOrbit(planet, peg, secondaryOrbit))
return
pegpts = []
for orbitObj, order in zip((referenceOrbit, secondaryOrbit)
,('First', 'Second')):
objGetpeg = stdproc.createGetpeg()
if peg:
objGetpeg.setPeg(peg)
objGetpeg.wireInputPort(name='planet', object=planet)
objGetpeg.wireInputPort(name='Orbit', object=orbitObj)
self._stdWriter.setFileTag("getpeg", "log")
self._stdWriter.setFileTag("getpeg", "err")
self._stdWriter.setFileTag("getpeg", "out")
objGetpeg.setStdWriter(self._stdWriter)
logger.info('Peg points are computed for individual SAR scenes.')
objGetpeg.estimatePeg()
pegpts.append(objGetpeg.getPeg())
recordInputsAndOutputs(self._insar.procDoc, objGetpeg, "getpeg", \
logger, "runSetmocomppath")
#Piyush
# I set these values here for the sake of continuity, but they need to be updated
# in orbit2sch as the correct peg point is not yet known
getattr(self._insar,'set%sAverageHeight'%(order))(objGetpeg.getAverageHeight())
getattr(self._insar,'set%sProcVelocity'%(order))(objGetpeg.getProcVelocity())
logger.info('Combining individual peg points.')
peg = averagePeg(pegpts, planet)
if self.pegSelect.upper() == 'REFERENCE':
logger.info('Using reference info for peg point')
self._insar.setPeg(pegpts[0])
elif self.pegSelect.upper() == 'SECONDARY':
logger.info('Using secondary infor for peg point')
self._insar.setPeg(pegpts[1])
elif self.pegSelect.upper() == 'AVERAGE':
logger.info('Using average peg point')
self._insar.setPeg(peg)
else:
raise Exception('Unknown peg selection method')
def runTopo(self):
from zerodop.topozero import createTopozero
from isceobj.Planet.Planet import Planet
logger.info("Running topo")
#IU.copyAttributes(demImage, objDem)
geometryDir = self.insar.geometryDirname
os.makedirs(geometryDir, exist_ok=True)
demFilename = self.verifyDEM()
objDem = isceobj.createDemImage()
objDem.load(demFilename + '.xml')
info = self._insar.loadProduct(self._insar.masterSlcCropProduct)
intImage = info.getImage()
planet = info.getInstrument().getPlatform().getPlanet()
topo = createTopozero()
topo.slantRangePixelSpacing = 0.5 * SPEED_OF_LIGHT / info.rangeSamplingRate
topo.prf = info.PRF
topo.radarWavelength = info.radarWavelegth
topo.orbit = info.orbit
topo.width = intImage.getWidth()
topo.length = intImage.getLength()
topo.wireInputPort(name='dem', object=objDem)
topo.wireInputPort(name='planet', object=planet)
topo.numberRangeLooks = 1
topo.numberAzimuthLooks = 1
topo.lookSide = info.getInstrument().getPlatform().pointingDirection
topo.sensingStart = info.getSensingStart()
topo.rangeFirstSample = info.startingRange
topo.demInterpolationMethod = 'BIQUINTIC'
topo.latFilename = os.path.join(geometryDir,
self.insar.latFilename + '.full')
topo.lonFilename = os.path.join(geometryDir,
self.insar.lonFilename + '.full')
topo.losFilename = os.path.join(geometryDir,
self.insar.losFilename + '.full')
topo.heightFilename = os.path.join(geometryDir,
self.insar.heightFilename + '.full')
# topo.incFilename = os.path.join(info.outdir, 'inc.rdr')
# topo.maskFilename = os.path.join(info.outdir, 'mask.rdr')
####Doppler adjustment
dop = [x / 1.0 for x in info._dopplerVsPixel]
doppler = Poly2D()
doppler.setWidth(topo.width // topo.numberRangeLooks)
doppler.setLength(topo.length // topo.numberAzimuthLooks)
if self._insar.masterGeometrySystem.lower().startswith('native'):
doppler.initPoly(rangeOrder=len(dop) - 1, azimuthOrder=0, coeffs=[dop])
else:
doppler.initPoly(rangeOrder=0, azimuthOrder=0, coeffs=[[0.]])
topo.polyDoppler = doppler
topo.topo()
# Record the inputs and outputs
from isceobj.Catalog import recordInputsAndOutputs
recordInputsAndOutputs(self._insar.procDoc, topo, "runTopo", logger,
"runTopo")
self._insar.estimatedBbox = [
topo.minimumLatitude, topo.maximumLatitude, topo.minimumLongitude,
topo.maximumLongitude
]
return topo
def runTopo(self):
logger.info("Running topo")
objMocompbaseline = self.insar.mocompBaseline
objFormSlc1 = self.insar.formSLC1
#objDem = isceobj.createDemImage()
#demImage = self.insar.demImage
#IU.copyAttributes(demImage, objDem)
objDem = self.insar.demImage.clone()
topoIntImage = self._insar.getTopoIntImage()
#intImage = isceobj.createIntImage()
#IU.copyAttributes(topoIntImage, intImage)
intImage = topoIntImage.clone()
intImage.setAccessMode('read')
posIndx = 1
mocompPosition1 = objFormSlc1.getMocompPosition()
planet = self.insar.masterFrame.getInstrument().getPlatform().getPlanet()
prf1 = self.insar.masterFrame.getInstrument().getPulseRepetitionFrequency()
objTopo = stdproc.createTopo()
objTopo.wireInputPort(name='peg', object=self.insar.peg)
objTopo.wireInputPort(name='frame', object=self.insar.masterFrame)
objTopo.wireInputPort(name='planet', object=planet)
objTopo.wireInputPort(name='dem', object=objDem)
objTopo.wireInputPort(name='interferogram', object=intImage)
objTopo.wireInputPort(name='masterslc',
object=self.insar.formSLC1) #Piyush
centroid = self.insar.dopplerCentroid.getDopplerCoefficients(inHz=False)[0]
objTopo.setDopplerCentroidConstantTerm(centroid)
v = self.insar.procVelocity
h = self.insar.averageHeight
objTopo.setBodyFixedVelocity(v)
objTopo.setSpacecraftHeight(h)
objTopo.setReferenceOrbit(mocompPosition1[posIndx])
# Options
objTopo.setNumberRangeLooks(self.insar.numberRangeLooks)
objTopo.setNumberAzimuthLooks(self.insar.numberAzimuthLooks)
objTopo.setNumberIterations(self.insar.topophaseIterations)
objTopo.setHeightSchFilename(self.insar.heightSchFilename)
objTopo.setHeightRFilename(self.insar.heightFilename)
objTopo.setLatFilename(self.insar.latFilename)
objTopo.setLonFilename(self.insar.lonFilename)
objTopo.setLosFilename(self.insar.losFilename)
if self.insar.is_mocomp is None:
self.insar.get_is_mocomp()
objTopo.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
objTopo.stdWriter = self._writer_set_file_tags("topo", "log", "err", "out")
objTopo.setLookSide(self.insar._lookSide)
objTopo.topo()
# Record the inputs and outputs
from isceobj.Catalog import recordInputsAndOutputs
recordInputsAndOutputs(self._insar.procDoc, objTopo, "runTopo", logger,
"runTopo")
self._insar.setTopo(objTopo)
if self.insar.applyWaterMask:
sw = SWBDStitcher()
sw.toRadar(self.insar.wbdImage.filename, self.insar.latFilename,
self.insar.lonFilename, self.insar.waterMaskImageName)
return objTopo
def runRgoffset(self):
firstAc = self._insar.getFirstSampleAcross()
firstDown = self._insar.getFirstSampleDown()
numLocationAcross = self._insar.getNumberLocationAcross()
numLocationDown = self._insar.getNumberLocationDown()
imageAmp = self._insar.getResampAmpImage()
objAmp = isceobj.createIntImage()
IU.copyAttributes(imageAmp, objAmp)
objAmp.setAccessMode('read')
objAmp.createImage()
widthAmp = objAmp.getWidth()
intLength = objAmp.getLength()
lastAc = widthAmp - firstAc
lastDown = intLength - firstDown
imageSim = self._insar.getSimAmpImage()
objSim = isceobj.createImage()
IU.copyAttributes(imageSim, objSim)
objSim.setAccessMode('read')
objSim.createImage()
objOffset = isceobj.createEstimateOffsets(name='insarapp_intsim_estoffset')
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(self.offsetSearchWindowSize,
self.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)
#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.getMasterFrame().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)
# Record the inputs and outputs
from isceobj.Catalog import recordInputsAndOutputs
recordInputsAndOutputs(self._insar.procDoc, objOffset, "runRgoffset", \
logger, "runRgoffset")
self._insar.setOffsetField(objOffset.getOffsetField())
self._insar.setRefinedOffsetField(objOffset.getOffsetField())
objAmp.finalizeImage()
objSim.finalizeImage()
def runResamp_image(self):
imageSlc = self._insar.getMasterSlcImage()
widthSlc = max(self._insar.getMasterSlcImage().getWidth(),
self._insar.getSlaveSlcImage().getWidth())
offsetField = self._insar.getRefinedOffsetField()
instrument = self._insar.getMasterFrame().getInstrument()
dopplerCoeff = self._insar.getDopplerCentroid().getDopplerCoefficients(
inHz=False)
pixelSpacing = self._insar.getSlantRangePixelSpacing()
looks = self._insar.getNumberLooks()
lines = self._insar.getNumberResampLines()
numFitCoeff = self._insar.getNumberFitCoefficients()
offsetFilename = self._insar.getOffsetImageName()
offsetAz = 'azimuth' + offsetFilename.capitalize()
offsetRn = 'range' + offsetFilename.capitalize()
widthOffset = int(widthSlc / looks)
imageAz = isceobj.createOffsetImage()
imageAz.setFilename(offsetAz)
imageAz.setWidth(widthOffset)
imageRn = isceobj.createOffsetImage()
imageRn.setFilename(offsetRn)
imageRn.setWidth(widthOffset)
self._insar.setOffsetAzimuthImage(imageAz)
self._insar.setOffsetRangeImage(imageRn)
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
self._stdWriter.setFileTag("resamp_image", "log")
self._stdWriter.setFileTag("resamp_image", "err")
self._stdWriter.setFileTag("resamp_image", "out")
objResamp_image.setStdWriter(self._stdWriter)
objResamp_image.resamp_image(objRn, objAz)
# Record the inputs and outputs
from isceobj.Catalog import recordInputsAndOutputs
recordInputsAndOutputs(self._insar.procDoc, objResamp_image, "runResamp_image", \
logger, "runResamp_image")
objRn.finalizeImage()
objAz.finalizeImage()
def runGeocode(self, prodlist, unwrapflag, bbox):
'''Generalized geocoding of all the files listed above.'''
from isceobj.Catalog import recordInputsAndOutputs
logger.info("Geocoding Image")
insar = self.insar
if isinstance(prodlist,str):
from isceobj.Util.StringUtils import StringUtils as SU
tobeGeocoded = SU.listify(prodlist)
else:
tobeGeocoded = prodlist
#remove files that have not been processed
for toGeo in tobeGeocoded:
if not os.path.exists(toGeo):
tobeGeocoded.remove(toGeo)
print('Number of products to geocode: ', len(tobeGeocoded))
stdWriter = create_writer("log", "", True, filename="geo.log")
v,h = insar.vh()
planet = insar.masterFrame._instrument._platform._planet
if bbox is None:
snwe = insar.topo.snwe
else:
snwe = list(bbox)
if len(snwe) != 4:
raise ValueError('Bounding box should be a list/tuple of length 4')
#####Geocode one by one
first = False
ge = Geocodable()
for prod in tobeGeocoded:
objGeo = stdproc.createGeocode('insarapp_geocode_' + os.path.basename(prod).replace('.',''))
objGeo.configure()
####IF statements to check for user configuration
if objGeo.minimumLatitude is None:
objGeo.minimumLatitude = snwe[0]
if objGeo.maximumLatitude is None:
objGeo.maximumLatitude = snwe[1]
if objGeo.minimumLongitude is None:
objGeo.minimumLongitude = snwe[2]
if objGeo.maximumLongitude is None:
objGeo.maximumLongitude = snwe[3]
if objGeo.demCropFilename is None:
objGeo.demCropFilename = insar.demCropFilename
objGeo.referenceOrbit = insar.formSLC1.getMocompPosition(1)
if objGeo.dopplerCentroidConstantTerm is None:
objGeo.dopplerCentroidConstantTerm = insar.dopplerCentroid.getDopplerCoefficients(inHz=False)[0]
if objGeo.bodyFixedVelocity is None:
objGeo.bodyFixedVelocity = v
if objGeo.spacecraftHeight is None:
objGeo.spacecraftHeight = h
if objGeo.numberRangeLooks is None:
objGeo.numberRangeLooks = insar.numberRangeLooks
if objGeo.numberAzimuthLooks is None:
objGeo.numberAzimuthLooks = insar.numberAzimuthLooks
if objGeo.isMocomp is None:
objGeo.isMocomp = insar.is_mocomp
objGeo.stdWriter = stdWriter
#create the instance of the input image and the appropriate
#geocode method
inImage,method = ge.create(prod)
if objGeo.method is None:
objGeo.method = method
if(inImage):
#demImage = isceobj.createDemImage()
#IU.copyAttributes(insar.demImage, demImage)
demImage = insar.demImage.clone()
objGeo(peg=insar.peg, frame=insar.masterFrame,
planet=planet, dem=demImage, tobegeocoded=inImage,
geoPosting=None, masterslc=insar.formSLC1)
recordInputsAndOutputs(self._insar.procDoc, objGeo, "runGeocode",
logger, "runGeocode")
stdWriter.finalize()
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
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 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.getFirstProcVelocity()
h = self.insar.averageHeight
imageSlc1 = self.insar.masterRawImage
imSlc1 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc1, imSlc1)
imSlc1.setAccessMode('read')
imSlc1.createImage()
formSlc1 = stdproc.createFormSLC()
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.masterFrame)
formSlc1.wireInputPort(name='orbit', object=self.insar.masterOrbit)
formSlc1.wireInputPort(name='rawImage', object=None)
formSlc1.wireInputPort(
name='planet',
object=self.insar.masterFrame.instrument.platform.planet)
for item in formSlc1.inputPorts:
item()
formSlc1.slcWidth = imSlc1.getWidth()
formSlc1.startingRange = formSlc1.rangeFirstSample
formSlc1.rangeChirpExtensionPoints = 0
formSlc1.slcSensingStart = self.insar.masterFrame.getSensingStart()
formSlc1.outOrbit = self.insar.masterOrbit
self._stdWriter.setFileTag("formslcISCE", "log")
self._stdWriter.setFileTag("formslcISCE", "err")
self._stdWriter.setFileTag("formslcISCE", "out")
formSlc1.setStdWriter(self._stdWriter)
formSlc1.setLookSide(self.insar._lookSide)
# self.insar.setMasterSlcImage(formSlc1.formslc())
# self.insar.masterSlcImage = formSlc1()
self.insar.formSLC1 = formSlc1
self.insar.masterSlcImage = imSlc1
time, position, velocity, relTo = self.insar.masterOrbit._unpackOrbit()
mocomp_array = [[], []]
for (t, p) in zip(time, position):
mocomp_array[0].append(t - time[0])
mocomp_array[1].append(p[0])
self.insar.formSLC1.mocompPosition = mocomp_array
self.insar.formSLC1.mocompIndx = list(range(1, len(time) + 1))
formSlc1.dim1_mocompPosition = 2
formSlc1.dim2_mocompPosition = len(time)
formSlc1.dim1_mocompIndx = len(time)
imageSlc2 = self.insar.slaveRawImage
imSlc2 = isceobj.createSlcImage()
IU.copyAttributes(imageSlc2, imSlc2)
imSlc2.setAccessMode('read')
imSlc2.createImage()
formSlc2 = stdproc.createFormSLC()
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.slaveFrame)
formSlc2.wireInputPort(name='orbit', object=self.insar.slaveOrbit)
formSlc2.wireInputPort(name='rawImage', object=None)
formSlc2.wireInputPort(
name='planet', object=self.insar.slaveFrame.instrument.platform.planet)
for item in formSlc2.inputPorts:
item()
formSlc2.slcWidth = imSlc2.getWidth()
formSlc2.startingRange = formSlc2.rangeFirstSample
formSlc2.rangeChirpExtensionPoints = 0
formSlc2.slcSensingStart = self.insar.slaveFrame.getSensingStart()
formSlc2.outOrbit = self.insar.slaveOrbit
self._stdWriter.setFileTag("formslcISCE", "log")
self._stdWriter.setFileTag("formslcISCE", "err")
self._stdWriter.setFileTag("formslcISCE", "out")
formSlc2.setStdWriter(self._stdWriter)
formSlc2.setLookSide(self.insar._lookSide)
# self.insar.setSlaveSlcImage(formSlc2.formslc())
self.insar.formSLC2 = formSlc2
self.insar.slaveSlcImage = imSlc2
time, position, velocity, relTo = self.insar.slaveOrbit._unpackOrbit()
mocomp_array = [[], []]
for (t, p) in zip(time, position):
mocomp_array[0].append(t - time[0])
mocomp_array[1].append(p[0])
self.insar.formSLC2.mocompPosition = mocomp_array
self.insar.formSLC2.mocompIndx = list(range(1, len(time) + 1))
formSlc2.dim1_mocompPosition = 2
formSlc2.dim2_mocompPosition = len(time)
formSlc2.dim1_mocompIndx = len(time)
self.insar.setNumberPatches(imSlc1.getLength() /
float(self.insar.numberValidPulses))
imSlc1.finalizeImage()
imSlc2.finalizeImage()
recordInputsAndOutputs(self.insar.procDoc, formSlc1, "runFormSLC.master",
logger, "runFormSLC.master")
recordInputsAndOutputs(self.insar.procDoc, formSlc2, "runFormSLC.slave",
logger, "runFormSLC.slave")
self.insar.setFormSLC1(formSlc1)
self.insar.setFormSLC2(formSlc2)
