class Formslc(Component):
family = 'formslc'
logging_name = 'isce.formslc'
dont_pickle_me = ()
parameter_list = (NUMBER_GOOD_BYTES,
NUMBER_BYTES_PER_LINE,
FIRST_LINE,
NUMBER_VALID_PULSES,
FIRST_SAMPLE,
NUMBER_PATCHES,
START_RANGE_BIN,
NUMBER_RANGE_BIN,
NUMBER_AZIMUTH_LOOKS,
RANGE_CHIRP_EXTENSION_POINTS,
AZIMUTH_PATCH_SIZE,
OVERLAP,
RAN_FFTOV,
RAN_FFTIQ,
DEBUG_FLAG,
CALTONE_LOCATION,
PLANET_LOCAL_RADIUS,
BODY_FIXED_VELOCITY,
SPACECRAFT_HEIGHT,
PRF,
INPHASE_VALUE,
QUADRATURE_VALUE,
AZIMUTH_RESOLUTION,
RANGE_SAMPLING_RATE,
CHIRP_SLOPE,
RANGE_PULSE_DURATION,
RADAR_WAVELENGTH,
RANGE_FIRST_SAMPLE,
RANGE_SPECTRAL_WEIGHTING,
SPECTRAL_SHIFT_FRACTION,
IQ_FLIP,
DESKEW_FLAG,
SECONDARY_RANGE_MIGRATION_FLAG,
POSITION,
TIME,
DOPPLER_CENTROID_COEFFICIENTS,
MOCOMP_POSITION,
MOCOMP_INDEX,
STARTING_RANGE,
SHIFT, ##KK,ML 2013-07-15
SENSING_START,
SLC_SENSING_START,
MOCOMP_RANGE,
LOOK_SIDE
)
facility_list = (
SLC_IMAGE,
RAW_IMAGE,
ORBIT,
MOCOMP_ORBIT,
)
## maxAzPatchSize is defined in case the user specifies an unusually
## large number of valid pulses to save but no patch size on input.
maxAzPatchSize = 32768
def formslc(self):
for item in self.inputPorts:
item()
self.computeRangeParams()
try:
self.rawImage.setCaster('read','CFLOAT')
self.rawImage.setExtraInfo()
self.rawImage.createImage()
self.rawAccessor = self.rawImage.getImagePointer()
self.slcAccessor = self.slcImage.getImagePointer()
except AttributeError:
self.logger.error("Error in accessing image pointers")
raise AttributeError
self.computePatchParams()
self.allocateArrays()
self.setState()
###New changes
cOrbit = self.inOrbit.exportToC()
formslc.setOrbit_Py(cOrbit)
formslc.setSensingStart_Py(
DTU.seconds_since_midnight(self.sensingStart)
)
####Create an empty/dummy orbit of same length as input orbit
mOrbit = copy.copy(self.inOrbit).exportToC()
formslc.setMocompOrbit_Py(mOrbit)
formslc.formslc_Py(self.rawAccessor, self.slcAccessor)
###Freeing Orbit
combinedlibmodule.freeCOrbit(cOrbit)
self.outOrbit = Orbit()
self.outOrbit.configure()
self.outOrbit.importFromC(mOrbit,
datetime.datetime.combine(self.sensingStart.date(),
datetime.time(0)
)
)
combinedlibmodule.freeCOrbit(mOrbit)
#the size of this vectors where unknown until the end of the run
posSize = formslc.getMocompPositionSize_Py()
self.dim1_mocompPosition = 2
self.dim2_mocompPosition = posSize
self.dim1_mocompIndx = posSize
self.getState()
self.deallocateArrays()
self.slcImage.finalizeImage()
self.slcImage.renderHdr()
return self.slcImage
@staticmethod
def nxPower(num):
power=0
k=0
while power < num:
k+=1
power=2**k
return k
def computeRangeParams(self):
'''Ensure that the given range parameters are valid.'''
from isceobj.Constants import SPEED_OF_LIGHT
import isceobj
chirpLength = int(self.rangeSamplingRate * self.rangePulseDuration)
halfChirpLength = chirpLength // 2
#Add a half-chirp to the user requested extension.
#To decrease the extension relative to the halfChirpLength
#the user would have to set rangeCHirpExtensionPoints to a negative
#value; however, the resulting value must be greater than 0.
self.logger.info('Default near range chirp extension '+
'(half the chirp length): %d' % (halfChirpLength))
self.logger.info('Extra Chirp Extension requested: '+
'%d' % (self.rangeChirpExtensionPoints))
self.rangeChirpExtensionPoints = (self.rangeChirpExtensionPoints +
halfChirpLength)
if self.rangeChirpExtensionPoints >= 0:
self.logger.info('Extending range line by '+
'%d pixels' % (self.rangeChirpExtensionPoints))
elif self.rangeChirpExtensionPoints < 0:
raise ValueError('Range Chirp Extension cannot be negative.')
#startRangeBin must be positive.
#It is an index into the raw data range line
if self.startRangeBin <= 0:
raise ValueError('startRangeBin must be positive ')
self.logger.info('Number of Range Bins: %d'%self.numberRangeBin)
self.slcWidth = (self.numberRangeBin + self.rangeChirpExtensionPoints +
halfChirpLength + self.startRangeBin - 1)
delr = self.rangeSamplingRate
#Will be set here and passed on to Fortran. - Piyush
self.startingRange = (self.rangeFirstSample + (self.startRangeBin - 1 -
self.rangeChirpExtensionPoints) *
SPEED_OF_LIGHT*0.5/self.rangeSamplingRate)
self.logger.info('Raw Starting Range: %f'%(self.rangeFirstSample))
self.logger.info('SLC Starting Range: %f'%(self.startingRange))
self.logger.info('SLC width: %f'%(self.slcWidth))
#Set width of the SLC image here .
self.slcImage = isceobj.createSlcImage()
self.logger.info('Debug fname : %s'%(self.rawImage.getFilename()))
self.slcImage.setFilename(
self.rawImage.getFilename().replace('.raw','.slc'))
self.slcImage.setWidth(self.slcWidth)
self.slcImage.setAccessMode('write')
self.slcImage.createImage()
## set the patch size and number of valid pulses based on the computed
## synthetic aperture length
def computePatchParams(self):
from isceobj.Constants import SPEED_OF_LIGHT
chunksize=1024
rawFileSize = self.rawImage.getLength() * self.rawImage.getWidth()
linelength = int(self.rawImage.getXmax())
synthApertureSamps = (
self.radarWavelength* (self.startingRange +
self.slcWidth*SPEED_OF_LIGHT*0.5/self.rangeSamplingRate)*
self.prf/(self.antennaLength*self.bodyFixedVelocity))
nSAS = int((synthApertureSamps-1)/chunksize)+1
chunkedSAS = chunksize*nSAS
nxP = self.nxPower(nSAS)
azP = chunksize*2*(2**nxP) #Patchsize
nV = azP-chunkedSAS #Numbervalid
if self.azimuthPatchSize:
if self.azimuthPatchSize != 2**self.nxPower(self.azimuthPatchSize):
self.azimuthPatchSize = 2**self.nxPower(self.azimuthPatchSize)
self.logger.info(
"Patch size must equal power of 2. Resetting to %d" %
self.azimuthPatchSize
)
if self.azimuthPatchSize and self.numberValidPulses:
if (self.azimuthPatchSize < self.numberValidPulses or
self.azimuthPatchSize < chunkedSAS+chunksize):
self.azimuthPatchSize = azP
self.numberValidPulses = nV
elif self.numberValidPulses > self.azimuthPatchSize-chunkedSAS:
msg = ("Number of valid pulses specified is too large "+
"for full linear convolution. ")
msg += ("Should be less than %d" %
(self.azimuthPatchSize-chunkedSAS))
self.logger.info(msg)
self.logger.info(
"Continuing with specified value of %d" %
self.numberValidPulses
)
elif self.azimuthPatchSize and not self.numberValidPulses:
if self.azimuthPatchSize < chunkedSAS+chunksize:
self.azimuthPatchSize = azP
self.numberValidPulses = nV
else:
self.numberValidPulses = self.azimuthPatchSize-chunkedSAS
if self.numberValidPulses > self.azimuthPatchSize-chunkedSAS:
msg = ("Number of valid pulses specified is too large "+
"for full linear convolution. ")
msg += ("Should be less than %d" %
(self.azimuthPatchSize-chunkedSAS))
self.logger.info(msg)
self.logger.info(
"Continuing with specified value of %d" %
self.numberValidPulses
)
elif not self.azimuthPatchSize and self.numberValidPulses:
self.azimuthPatchSize=2**self.nxPower(self.numberValidPulses+
synthApertureSamps)
if self.azimuthPatchSize > self.maxAzPatchSize:
msg = ("%d is a rather large patch size. " %
self.azimuthPatchSize)
msg += ("Check that the number of valid pulses is in a "+
"reasonable range. Proceeding anyway...")
self.logger.info(msg)
elif not self.azimuthPatchSize and not self.numberValidPulses:
self.azimuthPatchSize=azP
self.numberValidPulses=nV
overhead = self.azimuthPatchSize - self.numberValidPulses
if not self.numberPatches:
self.numberPatches = (
1+int(
(rawFileSize/float(linelength)-overhead)/
self.numberValidPulses
)
)
def getState(self):
self.mocompPosition = formslc.getMocompPosition_Py(
self.dim1_mocompPosition, self.dim2_mocompPosition
)
self.mocompIndx = formslc.getMocompIndex_Py(self.dim1_mocompIndx)
self.startingRange = formslc.getStartingRange_Py()
self.mocompRange = formslc.getMocompRange_Py()
slcSensingStart = formslc.getSlcSensingStart_Py()
self.slcSensingStart = datetime.datetime.combine( self.sensingStart.date(), datetime.time(0)) + datetime.timedelta(seconds=slcSensingStart)
def setState(self):
formslc.setStdWriter_Py(int(self.stdWriter))
formslc.setNumberGoodBytes_Py(int(self.numberGoodBytes))
formslc.setNumberBytesPerLine_Py(int(self.numberBytesPerLine))
formslc.setFirstLine_Py(int(self.firstLine))
formslc.setNumberValidPulses_Py(int(self.numberValidPulses))
formslc.setFirstSample_Py(int(self.firstSample))
formslc.setNumberPatches_Py(int(self.numberPatches))
formslc.setStartRangeBin_Py(int(self.startRangeBin))
formslc.setNumberRangeBin_Py(int(self.numberRangeBin))
formslc.setNumberAzimuthLooks_Py(int(self.numberAzimuthLooks))
formslc.setRangeChirpExtensionPoints_Py(
int(self.rangeChirpExtensionPoints)
)
formslc.setAzimuthPatchSize_Py(int(self.azimuthPatchSize))
formslc.setOverlap_Py(int(self.overlap))
formslc.setRanfftov_Py(int(self.ranfftov))
formslc.setRanfftiq_Py(int(self.ranfftiq))
formslc.setDebugFlag_Py(int(self.debugFlag))
formslc.setCaltoneLocation_Py(float(self.caltoneLocation))
formslc.setPlanetLocalRadius_Py(float(self.planetLocalRadius))
formslc.setBodyFixedVelocity_Py(float(self.bodyFixedVelocity))
formslc.setSpacecraftHeight_Py(float(self.spacecraftHeight))
formslc.setPRF_Py(float(self.prf))
formslc.setInPhaseValue_Py(float(self.inPhaseValue))
formslc.setQuadratureValue_Py(float(self.quadratureValue))
formslc.setAzimuthResolution_Py(float(self.azimuthResolution))
formslc.setRangeSamplingRate_Py(float(self.rangeSamplingRate))
formslc.setChirpSlope_Py(float(self.chirpSlope))
formslc.setRangePulseDuration_Py(float(self.rangePulseDuration))
formslc.setRadarWavelength_Py(float(self.radarWavelength))
formslc.setRangeFirstSample_Py(float(self.rangeFirstSample))
formslc.setRangeSpectralWeighting_Py(
float(self.rangeSpectralWeighting))
formslc.setSpectralShiftFraction_Py(float(self.spectralShiftFraction))
formslc.setIMRC1_Py(int(self.imrc1Accessor))
formslc.setIMMocomp_Py(int(self.immocompAccessor))
formslc.setIMRCAS1_Py(int(self.imrcas1Accessor))
formslc.setIMRCRM1_Py(int(self.imrcrm1Accessor))
formslc.setTransDat_Py(int(self.transAccessor))
formslc.setIQFlip_Py(self.IQFlip)
formslc.setDeskewFlag_Py(self.deskewFlag)
formslc.setSecondaryRangeMigrationFlag_Py(
self.secondaryRangeMigrationFlag
)
formslc.setPosition_Py(self.position,
self.dim1_position,
self.dim2_position)
formslc.setVelocity_Py(self.velocity,
self.dim1_velocity,
self.dim2_velocity)
formslc.setTime_Py(self.time,
self.dim1_time)
formslc.setDopplerCentroidCoefficients_Py(
self.dopplerCentroidCoefficients,
self.dim1_dopplerCentroidCoefficients
)
formslc.setPegPoint_Py(np.radians(self.pegLatitude),
np.radians(self.pegLongitude),
np.radians(self.pegHeading))
formslc.setPlanet_Py(self.spin, self.gm)
formslc.setEllipsoid_Py(self.a, self.e2)
formslc.setSlcWidth_Py(self.slcWidth)
formslc.setStartingRange_Py(self.startingRange)
formslc.setLookSide_Py(self.lookSide)
formslc.setShift_Py(self.shift) ##KK,ML 2013-07-15
def getMocompPosition(self, index=None):
return self.mocompPosition[index] if index else self.mocompPosition
def getMocompIndex(self):
return self.mocompIndx
def getStartingRange(self):
return self.startingRange
def setRawImage(self, raw):
self.rawImage = raw
def setSlcImage(self, slc):
self.slcImage = slc
def setNumberGoodBytes(self, var):
self.numberGoodBytes = int(var)
def setNumberBytesPerLine(self, var):
self.numberBytesPerLine = int(var)
def setFirstLine(self, var):
self.firstLine = int(var)
def setLookSide(self, var):
self.lookSide = int(var)
@set_if_true
def setNumberValidPulses(self, var):
self.numberValidPulses = int(var)
def setFirstSample(self, var):
self.firstSample = int(var)
@set_if_true
def setNumberPatches(self,var):
self.numberPatches = int(var)
def setStartRangeBin(self, var):
self.startRangeBin = int(var)
def setStartingRange(self, var):
self.startingRange = float(var)
def setNumberRangeBin(self, var):
self.numberRangeBin = int(var)
def setNumberAzimuthLooks(self, var):
self.numberAzimuthLooks = int(var)
def setRangeChirpExtensionPoints(self, var):
self.rangeChirpExtensionPoints = int(var)
@set_if_true
def setAzimuthPatchSize(self, var):
self.azimuthPatchSize = int(var)
def setOverlap(self, var):
self.overlap = int(var)
def setRanfftov(self, var):
self.ranfftov = int(var)
def setRanfftiq(self, var):
self.ranfftiq = int(var)
def setDebugFlag(self, var):
self.debugFlag = int(var)
def setCaltoneLocation(self, var):
self.caltoneLocation = float(var)
def setPlanetLocalRadius(self, var):
self.planetLocalRadius = float(var)
def setBodyFixedVelocity(self, var):
self.bodyFixedVelocity = float(var)
def setSpacecraftHeight(self, var):
self.spacecraftHeight = float(var)
def setPRF(self, var):
self.prf = float(var)
def setInPhaseValue(self, var):
self.inPhaseValue = float(var)
def setQuadratureValue(self, var):
self.quadratureValue = float(var)
def setAzimuthResolution(self, var):
self.azimuthResolution = float(var)
def setRangeSamplingRate(self, var):
self.rangeSamplingRate = float(var)
def setChirpSlope(self, var):
self.chirpSlope = float(var)
def setRangePulseDuration(self, var):
self.rangePulseDuration = float(var)
def setRadarWavelength(self, var):
self.radarWavelength = float(var)
def setRangeFirstSample(self, var):
self.rangeFirstSample = float(var)
def setRangeSpectralWeighting(self, var):
self.rangeSpectralWeighting = float(var)
def setSpectralShiftFraction(self, var):
self.spectralShiftFraction = float(var)
def setIQFlip(self, var):
self.IQFlip = str(var)
def setDeskewFlag(self, var):
self.deskewFlag = str(var)
def setSecondaryRangeMigrationFlag(self, var):
self.secondaryRangeMigrationFlag = str(var)
def setPosition(self, var):
self.position = var
def setVelocity(self, var):
self.velocity = var
def setTime(self, var):
self.time = var
def setSlcWidth(self, var):
self.slcWidth = var
def setDopplerCentroidCoefficients(self, var):
self.dopplerCentroidCoefficients = var
##KK,ML 2013-0-15
def setShift(self, var):
self.shift = var
##KK,ML
def _testArraySize(self,*args):
"""Test for array dimesions that are zero or smaller"""
for dimension in args:
if (dimension <= 0):
self.logger.error("Error, trying to allocate zero size array")
raise ValueError
def allocateArrays(self):
# Set array sizes from their arrays
try:
self.dim1_position = len(self.position)
self.dim2_position = len(self.position[0])
self.dim1_velocity = len(self.velocity)
self.dim2_velocity = len(self.velocity[0])
self.dim1_time = len(self.time)
self.dim1_dopplerCentroidCoefficients = len(
self.dopplerCentroidCoefficients)
except TypeError:
self.logger.error("Some input arrays were not set")
raise TypeError
# Test that the arrays have a size greater than zero
self._testArraySize(self.dim1_position,self.dim2_position)
self._testArraySize(self.dim1_velocity,self.dim2_velocity)
self._testArraySize(self.dim1_time)
self._testArraySize(self.dim1_dopplerCentroidCoefficients)
# Allocate the arrays
formslc.allocate_sch_Py(self.dim1_position, self.dim2_position)
formslc.allocate_vsch_Py(self.dim1_velocity, self.dim2_velocity)
formslc.allocate_time_Py(self.dim1_time)
formslc.allocate_dopplerCoefficients_Py(
self.dim1_dopplerCentroidCoefficients)
def deallocateArrays(self):
formslc.deallocate_sch_Py()
formslc.deallocate_vsch_Py()
formslc.deallocate_time_Py()
formslc.deallocate_dopplerCoefficients_Py()
pass
def addRawImage(self):
image = self.inputPorts['rawImage']
if image:
if isinstance(image, Image):
self.rawImage = image
self.numberBytesPerLine = 2*self.rawImage.getWidth()
self.numberGoodBytes = 2*self.rawImage.getNumberGoodSamples()
self.firstSample = self.rawImage.getXmin()
else:
self.logger.error(
"Object %s must be an instance of Image" % image
)
raise TypeError
def addOrbit(self):
orbit = self.inputPorts['orbit']
if orbit:
try:
time,position,velocity,offset = orbit._unpackOrbit()
self.time = time
self.position = position
self.velocity = velocity
except AttributeError:
self.logger.error(
"Object %s requires an _unpackOrbit() method" %
orbit.__class__
)
raise AttributeError
def addFrame(self):
frame = self.inputPorts['frame']
if frame:
try:
self.rangeFirstSample = frame.getStartingRange()
self.rangeLastSample = frame.getFarRange()
instrument = frame.getInstrument()
self.inPhaseValue = instrument.getInPhaseValue()
self.quadratureValue = instrument.getQuadratureValue()
self.rangeSamplingRate = instrument.getRangeSamplingRate()
self.chirpSlope = instrument.getChirpSlope()
self.rangePulseDuration = instrument.getPulseLength()
self.radarWavelength = instrument.getRadarWavelength()
self.prf = instrument.getPulseRepetitionFrequency()
self.antennaLength = instrument.getPlatform().getAntennaLength()
if self.azimuthResolution is None:
self.azimuthResolution = self.antennaLength/2.0
self.numberRangeBin = frame.numberRangeBins
self.inOrbit = frame.orbit
self.sensingStart = frame.sensingStart
except AttributeError as strerr:
self.logger.error(strerr)
raise AttributeError
def addPlanet(self):
planet = self.inputPorts['planet']
if planet:
try:
self.spin = planet.spin
self.gm = planet.GM
ellipsoid = planet.ellipsoid
self.a = ellipsoid.a
self.e2 = ellipsoid.e2
except AttributeError as strerr:
self.logger.error(strerr)
raise AttributeError
def addPeg(self):
peg = self.inputPorts['peg']
if peg:
try:
self.pegLatitude = peg.getLatitude()
self.pegLongitude = peg.getLongitude()
self.pegHeading = peg.getHeading()
self.planetLocalRadius = peg.getRadiusOfCurvature()
except AttributeError as strerr:
self.logger.error(strerr)
raise AttributeError
def addDoppler(self):
doppler = self.inputPorts['doppler']
if doppler:
try:
self.dopplerCentroidCoefficients = (
doppler.getDopplerCoefficients(inHz=True)
)
for num in range(len(self.dopplerCentroidCoefficients)):
self.dopplerCentroidCoefficients[num] /= self.prf
self.dim1_dopplerCentroidCoefficients = len(
self.dopplerCentroidCoefficients
)
except AttributeError as strerr:
self.logger.error(strerr)
raise AttributeError
'''
def _facilities(self):
self.slcImage = self.facility('slcImage',
public_name='slcImage',
module='isceobj.Image',
factory='createSlcImage',
mandatory=True,
doc='Single Look Complex Image object'
)
self.rawImage = self.facility('rawImage',
public_name='rawImage',
module='isceobj.Image',
factory='createRawIQImage',
mandatory=True,
doc='Raw Image object'
)
'''
def createPorts(self):
## 2012/2/12: now using PortIterator.__setitem__
self.inputPorts['rawImage'] = self.addRawImage
self.inputPorts['orbit'] = self.addOrbit
self.inputPorts['frame'] = self.addFrame
self.inputPorts['peg'] = self.addPeg
self.inputPorts['planet'] = self.addPlanet
self.inputPorts['doppler'] = self.addDoppler
return None
def adaptToRender(self):
import copy
# make a copy of the stateVectors to restore it after dumping
self._times = [copy.copy(self.sensingStart),copy.copy(self.slcSensingStart)]
self.sensingStart = self.sensingStart.strftime(self._fmt)
self.slcSensingStart = self.slcSensingStart.strftime(self._fmt)
def restoreAfterRendering(self):
self.sensingStart = self._times[0]
self.slcSensingStart = self._times[1]
def initProperties(self,catalog):
keys = ['SENSING_START','SLC_SENSING_START']
for k in keys:
kl = k.lower()
if kl in catalog:
v = catalog[kl]
attrname = getattr(globals()[k],'attrname')
val = datetime.datetime.strptime(v,self._fmt)
setattr(self,attrname,val)
catalog.pop(kl)
super().initProperties(catalog)
def __init__(self, name=''):
super(Formslc, self).__init__(self.__class__.family, name)
self.configure()
#Non-parameter defaults
self.slcImage = None
self.rawImage = None
# Planet information
# the code does not actually uses the ones set to -9999,
## but they are passed so they
# need to be set
self.a = -9999
self.e2 = -9999
self.spin = -9999
self.gm = -9999
# Peg Information
self.pegLatitude = -9999#see comment above
self.pegLongitude = -9999
self.pegHeading = -9999
# Orbit Information
self.dim1_position = None
self.dim2_position = None
self.velocity = []
self.dim1_velocity = None
self.dim2_velocity = None
self.dim1_time = None
# Doppler Information
self.dim1_dopplerCentroidCoefficients = None
# Accessors
self.imrc1Accessor = 0
self.immocompAccessor = 0
self.imrcas1Accessor = 0
self.imrcrm1Accessor = 0
self.transAccessor = 0
self.rawAccessor = 0
self.slcAccessor = 0
self.slcWidth = 0
####Short orbits
self.inOrbit = None
self.outOrbit = None
self.sensingStart = None
self.slcSensingStart = None
####For dumping and loading
self._times = []
self._fmt = '%Y-%m-%dT%H:%M:%S.%f'
return None
class MocompTSX(Component):
def mocomptsx(self):
for port in self.inputPorts:
port()
try:
self.inAccessor = self.slcInImage.getImagePointer()
except AttributeError:
self.logger.error("Error in accessing image pointers")
raise AttributeError("Error in accessing image pointers")
if self.stdWriter is None:
self.createStdWriter()
self.createOutSlcImage()
self.outAccessor = self.slcOutImage.getImagePointer()
self.allocateArrays()
self.setState()
###New changes
cOrbit = self.inOrbit.exportToC()
mocompTSX.setOrbit_Py(cOrbit)
mocompTSX.setSensingStart_Py(
DTU.seconds_since_midnight(self.sensingStart))
####Create an empty/dummy orbit of same length as input orbit
mOrbit = copy.copy(self.inOrbit).exportToC()
mocompTSX.setMocompOrbit_Py(mOrbit)
mocompTSX.mocompTSX_Py(self.inAccessor, self.outAccessor)
###Freeing Orbit
combinedlibmodule.freeCOrbit(cOrbit)
self.outOrbit = Orbit()
self.outOrbit.configure()
self.outOrbit.importFromC(
mOrbit,
datetime.datetime.combine(self.sensingStart.date(),
datetime.time(0)))
combinedlibmodule.freeCOrbit(mOrbit)
self.mocompPositionSize = mocompTSX.getMocompPositionSize_Py()
self.dim1_mocompPosition = 2
self.dim2_mocompPosition = self.mocompPositionSize
self.dim1_mocompIndex = self.mocompPositionSize
self.getState()
self.deallocateArrays()
self.slcOutImage.finalizeImage()
self.slcOutImage.renderHdr()
return self.slcOutImage
def createStdWriter(self):
from iscesys.StdOEL.StdOELPy import create_writer
self._stdWriter = create_writer("log", "", True,
"insar.log").set_file_tags(
"mocompTSX", "log", "err", "out")
return None
## TODO: use slcInImage's method to make new image.
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 = self.slcInImage.getFilename().capitalize(
) + '.mocomp' #ML 2014-08-21
self.slcOutImage.setFilename(name)
self.slcOutImage.setAccessMode('write')
self.slcOutImage.createImage()
return None
def setState(self):
mocompTSX.setStdWriter_Py(int(self.stdWriter))
mocompTSX.setNumberRangeBins_Py(int(self.numberRangeBins))
mocompTSX.setNumberAzLines_Py(int(self.numberAzLines))
mocompTSX.setDopplerCentroidCoefficients_Py(
self.dopplerCentroidCoefficients,
self.dim1_dopplerCentroidCoefficients)
mocompTSX.setTime_Py(self.time, self.dim1_time)
mocompTSX.setPosition_Py(self.position, self.dim1_position,
self.dim2_position)
mocompTSX.setPlanetLocalRadius_Py(float(self.planetLocalRadius))
mocompTSX.setBodyFixedVelocity_Py(float(self.bodyFixedVelocity))
mocompTSX.setSpacecraftHeight_Py(float(self.spacecraftHeight))
mocompTSX.setPRF_Py(float(self.prf))
mocompTSX.setRangeSamplingRate_Py(float(self.rangeSamplingRate))
mocompTSX.setRadarWavelength_Py(float(self.radarWavelength))
mocompTSX.setRangeFisrtSample_Py(float(self.rangeFirstSample))
mocompTSX.setLookSide_Py(int(self.lookSide))
#new stuff for estMocomporbit
mocompTSX.setPlanet_Py(self.spin, self.gm)
mocompTSX.setEllipsoid_Py(self.a, self.e2)
mocompTSX.setPegPoint_Py(numpy.radians(self.pegLatitude),
numpy.radians(self.pegLongitude),
numpy.radians(self.pegHeading))
return None
def setSlcInImage(self, img):
self.slcInImage = img
def setSlcOutImageName(self, name):
self.slcOutImageName = name
def setNumberRangeBins(self, var):
self.numberRangeBins = int(var)
return
def setNumberAzLines(self, var):
self.numberAzLines = int(var)
return
def setLookSide(self, var):
self.lookSide = int(var)
return
def setDopplerCentroidCoefficients(self, var):
self.dopplerCentroidCoefficients = var
return
def setTime(self, var):
self.time = var
return
def setPosition(self, var):
self.position = var
return
def setPlanetLocalRadius(self, var):
self.planetLocalRadius = float(var)
return
def setBodyFixedVelocity(self, var):
self.bodyFixedVelocity = float(var)
return
def setSpacecraftHeight(self, var):
self.spacecraftHeight = float(var)
return
def setPRF(self, var):
self.prf = float(var)
return
def setRangeSamplingRate(self, var):
self.rangeSamplingRate = float(var)
return
def setRadarWavelength(self, var):
self.radarWavelength = float(var)
return
def setRangeFisrtSample(self, var):
self.rangeFirstSample = float(var)
return
def getState(self):
self.mocompIndex = mocompTSX.getMocompIndex_Py(self.dim1_mocompIndex)
self.mocompPosition = mocompTSX.getMocompPosition_Py(
self.dim1_mocompPosition, self.dim2_mocompPosition)
self.startingRange = mocompTSX.getStartingRange_Py()
self.mocompRange = mocompTSX.getMocompRange_Py()
slcSensingStart = mocompTSX.getSlcSensingStart_Py()
self.slcSensingStart = datetime.datetime.combine(
self.sensingStart.date(),
datetime.time(0)) + datetime.timedelta(seconds=slcSensingStart)
return None
def getMocompIndex(self):
return self.mocompIndex
def getMocompPosition(self, index=None):
return self.mocompPosition[index] if index else self.mocompPosition
def getMocompPositionSize(self):
return self.mocompPositionSize
def getMocompImage(self):
return self.slcOutImage
def allocateArrays(self):
if (self.dim1_dopplerCentroidCoefficients == None):
self.dim1_dopplerCentroidCoefficients = len(
self.dopplerCentroidCoefficients)
if (not self.dim1_dopplerCentroidCoefficients):
print("Error. Trying to allocate zero size array")
raise Exception
mocompTSX.allocate_dopplerCentroidCoefficients_Py(
self.dim1_dopplerCentroidCoefficients)
if (self.dim1_time == None):
self.dim1_time = len(self.time)
if (not self.dim1_time):
print("Error. Trying to allocate zero size array")
raise Exception
mocompTSX.allocate_time_Py(self.dim1_time)
if (self.dim1_position == None):
self.dim1_position = len(self.position)
self.dim2_position = len(self.position[0])
if (not self.dim1_position) or (not self.dim2_position):
print("Error. Trying to allocate zero size array")
raise Exception
mocompTSX.allocate_sch_Py(self.dim1_position, self.dim2_position)
return None
def deallocateArrays(self):
mocompTSX.deallocate_dopplerCentroidCoefficients_Py()
mocompTSX.deallocate_time_Py()
mocompTSX.deallocate_sch_Py()
return None
def addOrbit(self):
orbit = self._inputPorts.getPort('orbit').getObject()
if (orbit):
try:
(time, position, velocity, offset) = orbit._unpackOrbit()
self.time = time
self.position = position
except AttributeError:
self.logger.error(
"Object %s requires an _unpackOrbit() method" %
(orbit.__class__))
raise AttributeError
def addDoppler(self):
doppler = self._inputPorts.getPort('doppler').getObject()
if (doppler):
try:
self.dopplerCentroidCoefficients = doppler.getDopplerCoefficients(
inHz=False)
self.dim1_dopplerCentroidCoefficients = len(
self.dopplerCentroidCoefficients)
except AttributeError as strerr:
self.logger.error(strerr)
raise AttributeError
def addSlcInImage(self):
image = self._inputPorts.getPort('slcInImage').getObject()
#check only if it is an instance of Image which is the base class
if (image):
if (isinstance(image, Image)):
self.slcInImage = image
self.numberRangeBins = self.slcInImage.getWidth()
self.numberAzLines = self.slcInImage.getLength()
else:
self.logger.error("Object %s must be an instance of Image" %
(image))
def addFrame(self):
frame = self._inputPorts.getPort('frame').getObject()
if (frame):
try:
self.rangeFirstSample = frame.getStartingRange()
instrument = frame.getInstrument()
self.rangeSamplingRate = instrument.getRangeSamplingRate()
self.radarWavelength = instrument.getRadarWavelength()
self.prf = instrument.getPulseRepetitionFrequency()
#new stuff for estMocompOrbit
self.sensingStart = frame.sensingStart
self.inOrbit = frame.orbit
except AttributeError as strerr:
self.logger.error(strerr)
raise AttributeError
def addPeg(self):
peg = self._inputPorts.getPort('peg').getObject()
if (peg):
try:
self.pegLatitude = peg.getLatitude()
self.pegLongitude = peg.getLongitude()
self.pegHeading = peg.getHeading()
self.planetLocalRadius = peg.getRadiusOfCurvature()
except AttributeError as strerr:
self.logger.error(strerr)
raise AttributeError
pass
return None
def addPlanet(self):
planet = self.inputPorts['planet']
if planet:
try:
self.spin = planet.spin
self.gm = planet.GM
ellipsoid = planet.ellipsoid
self.a = ellipsoid.a
self.e2 = ellipsoid.e2
except AttributeError as strerr:
self.logger.error(strerr)
raise AttributeError
logging_name = 'isce.mocompTSX'
def __init__(self):
super(MocompTSX, self).__init__()
self.inAccessor = None
self.outAccessor = None
self.numberRangeBins = None
self.numberAzLines = None
self.dopplerCentroidCoefficients = []
self.dim1_dopplerCentroidCoefficients = None
self.time = []
self.dim1_time = None
self.position = []
self.dim1_position = None
self.dim2_position = None
self.planetLocalRadius = None
self.bodyFixedVelocity = None
self.spacecraftHeight = None
self.prf = None
self.rangeSamplingRate = None
self.radarWavelength = None
self.rangeFirstSample = None
self.startingRange = None
self.mocompIndex = []
self.dim1_mocompIndex = None
self.mocompPositionSize = None
self.slcOutImageName = ""
self.slcInImage = None
self.slcOutImage = None
self.lookSide = -1 #Right looking by default
# self.logger = logging.getLogger('isce.mocompTSX')
# self.createPorts()
self.dictionaryOfVariables = {
'STD_WRITER': ['stdWriter', 'int', 'optional'],
'NUMBER_RANGE_BINS': ['numberRangeBins', 'int', 'optional'],
'NUMBER_AZ_LINES': ['numberAzLines', 'int', 'optional'],
'DOPPLER_CENTROID_COEFFICIENTS':
['dopplerCentroidCoefficients', 'float', 'mandatory'],
'TIME': ['time', 'float', 'mandatory'],
'POSITION': ['position', '', 'mandatory'],
'PLANET_LOCAL_RADIUS': ['planetLocalRadius', 'float', 'mandatory'],
'BODY_FIXED_VELOCITY': ['bodyFixedVelocity', 'float', 'mandatory'],
'SPACECRAFT_HEIGHT': ['spacecraftHeight', 'float', 'mandatory'],
'PRF': ['prf', 'float', 'mandatory'],
'RANGE_SAMPLING_RATE': ['rangeSamplingRate', 'float', 'mandatory'],
'RADAR_WAVELENGTH': ['radarWavelength', 'float', 'mandatory'],
'RANGE_FIRST_SAMPLE': ['rangeFirstSample', 'float', 'mandatory']
}
self.dictionaryOfOutputVariables = {
'MOCOMP_INDEX': 'mocompIndex',
'MOCOMP_POSITION': 'mocompPosition',
'MOCOMP_POSITION_SIZE': 'mocompPositionSize'
}
self.descriptionOfVariables = {}
self.mandatoryVariables = []
self.optionalVariables = []
self.initOptionalAndMandatoryLists()
return None
def createPorts(self):
slcInImagePort = Port(name='slcInImage', method=self.addSlcInImage)
pegPort = Port(name='peg', method=self.addPeg)
framePort = Port(name='frame', method=self.addFrame)
dopplerPort = Port(name='doppler', method=self.addDoppler)
orbitPort = Port(name='orbit', method=self.addOrbit)
planetPort = Port(name='planet', method=self.addPlanet)
self._inputPorts.add(slcInImagePort)
self._inputPorts.add(pegPort)
self._inputPorts.add(dopplerPort)
self._inputPorts.add(framePort)
self._inputPorts.add(orbitPort)
self._inputPorts.add(planetPort)
return None
