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