def createRawImage(self): # Check file name width = self.lineLength objRaw = isceobj.createRawImage() objRaw.initImage(self.rawFilename, 'read', width) objRaw.createImage() return objRaw
def loadImage(fname): ''' Load into appropriate image object. ''' try: import iscesys import isceobj from iscesys.Parsers.FileParserFactory import createFileParser except: raise ImportError('ISCE has not been installed or is not importable') if not fname.endswith('.xml'): dataName = fname metaName = fname + '.xml' else: metaName = fname dataName = os.path.splitext(fname)[0] parser = createFileParser('xml') prop,fac,misc = parser.parse(metaName) if 'reference' in prop: img=isceobj.createDemImage() img.init(prop,fac,misc) elif 'number_good_bytes' in prop: img = isceobj.createRawImage() img.init(prop,fac,misc) else: img = isceobj.createImage() img.init(prop,fac,misc) img.setAccessMode('READ') return img, dataName, metaName
def extractRaw(self, output=None): #if (self.numberOfSarChannels == 1): # print "Single Pol Data Found" # self.extractSinglePolImage(output=output) #elif (self.numberOfSarChannels == 3): # print "Dual Pol Data Found" #elif (self.numberOfSarChannels == 6): # print "Quad Pol Data Found" if self.parent.leaderFile.sceneHeaderRecord.metadata[ 'Processing facility identifier'] == 'ERSDAC': prmDict = alos.alose_Py(self.parent._leaderFile, self.parent._imageFile, output) else: prmDict = alos.alos_Py(self.parent._leaderFile, self.parent._imageFile, output) pass # updated 07/24/2012 self.width = prmDict['NUMBER_BYTES_PER_LINE'] self.length = self.imageFDR.metadata['Number of lines per data set'] self.start_time = self._parseClockTime(prmDict['SC_CLOCK_START']) self.stop_time = self._parseClockTime(prmDict['SC_CLOCK_STOP']) self.startingRange = prmDict['NEAR_RANGE'] self.prf = prmDict['PRF'] rawImage = isceobj.createRawImage() rawImage.setFilename(output) rawImage.setAccessMode('read') rawImage.setWidth(self.width) rawImage.setXmax(prmDict['NUMBER_BYTES_PER_LINE']) rawImage.setXmin(2 * prmDict['FIRST_SAMPLE']) self.parent.getFrame().setImage(rawImage) # updated 07/24/2012 return None
def readOrbitPulse(self, leader, raw, width): from isceobj.Sensor import readOrbitPulse as ROP rawImage = isceobj.createRawImage() leaImage = isceobj.createStreamImage() auxImage = isceobj.createImage() rawImage.initImage(raw, 'read', width) rawImage.createImage() rawAccessor = rawImage.getImagePointer() leaImage.initImage(leader, 'read') leaImage.createImage() leaAccessor = leaImage.getImagePointer() widthAux = 2 auxName = raw + '.aux' self.frame.auxFile = auxName auxImage.initImage(auxName, 'write', widthAux, type='DOUBLE') auxImage.createImage() auxAccessor = auxImage.getImagePointer() length = rawImage.getLength() ROP.setNumberBitesPerLine_Py(width) ROP.setNumberLines_Py(length) ROP.readOrbitPulse_Py(leaAccessor, rawAccessor, auxAccessor) rawImage.finalizeImage() leaImage.finalizeImage() auxImage.finalizeImage() return None
def extractImage(self): try: file = h5py.File(self._hdf5File, 'r') except Exception as strerror: self.logger.error("IOError: %s" % strerror) return size = file['Frame'].shape dtype = self._translateDataType(file['Frame'].attrs['Image Type']) length = size[0] width = size[1] data = numpy.memmap(self.output, dtype=dtype, mode='w+', shape=(length, width, 2)) data[:, :, :] = file['Frame'][:, :, :] del data rawImage = isceobj.createRawImage() rawImage.setByteOrder('l') rawImage.setAccessMode('r') rawImage.setFilename(self.output) rawImage.setWidth(2 * width) rawImage.setXmin(0) rawImage.setXmax(2 * width) self.frame.setImage(rawImage) self.populateMetadata(file) file.close()
def readOrbitPulse(self, leader, raw, width): ''' No longer used. Can't rely on raw data headers. Should be done as part of extract Image. ''' from isceobj.Sensor import readOrbitPulse as ROP print('TTTT') rawImage = isceobj.createRawImage() leaImage = isceobj.createStreamImage() auxImage = isceobj.createImage() rawImage.initImage(raw, 'read', width) rawImage.renderVRT() rawImage.createImage() rawAccessor = rawImage.getImagePointer() leaImage.initImage(leader, 'read') leaImage.createImage() leaAccessor = leaImage.getImagePointer() widthAux = 2 auxName = raw + '.aux' self.frame.auxFile = auxName auxImage.initImage(auxName, 'write', widthAux, type='DOUBLE') auxImage.createImage() auxAccessor = auxImage.getImagePointer() length = rawImage.getLength() ROP.setNumberBitesPerLine_Py(width) ROP.setNumberLines_Py(length) ROP.readOrbitPulse_Py(leaAccessor, rawAccessor, auxAccessor) rawImage.finalizeImage() leaImage.finalizeImage() auxImage.finalizeImage() return None
def populateImage(self, filename): rawImage = isceobj.createRawImage() rawImage.setByteOrder('l') rawImage.setFilename(filename) rawImage.setAccessMode('read') rawImage.setWidth(2 * self.frame.getNumberOfSamples()) rawImage.setXmax(2 * self.frame.getNumberOfSamples()) rawImage.setXmin(0) self.getFrame().setImage(rawImage)
def populateImage(self): mdict = self.constants rawImage = isceobj.createRawImage() rawImage.setByteOrder('l') rawImage.setFilename(self.rawFile) rawImage.setAccessMode('read') rawImage.setWidth(2 * self.frame.getNumberOfSamples()) rawImage.setXmax(2 * self.frame.getNumberOfSamples()) rawImage.setXmin(int(mdict['XMIN'])) self.getFrame().setImage(rawImage)
def _populateImage(self, outname): width = self._imageFileData['width'] # Create a RawImage object rawImage = isceobj.createRawImage() rawImage.setFilename(outname) rawImage.setAccessMode('read') rawImage.setByteOrder('l') rawImage.setXmin(0) rawImage.setXmax(width) rawImage.setWidth(width) self.frame.setImage(rawImage)
def extractImage(self): import isceobj if (self.imageFile is None) or (self.leaderFile is None): self.parse() try: out = open(self.output, 'wb') except IOError as strerr: self.logger.error("IOError: %s" % strerr) self.imageFile.extractImage(output=out) out.close() self.frame.setSensingStart(self.imageFile.sensingStart) self.frame.setSensingStop(self.imageFile.sensingStop) sensingMid = self.imageFile.sensingStart + datetime.timedelta( seconds=0.5 * (self.imageFile.sensingStop - self.imageFile.sensingStart).total_seconds()) self.frame.setSensingMid(sensingMid) dr = self.frame.instrument.rangePixelSize self.frame.setStartingRange(self.imageFile.nearRange) self.frame.setFarRange(self.imageFile.nearRange + (self.imageFile.width - 1) * dr) self.doppler_coeff = self.imageFile.dopplerCoeff self.frame.getInstrument().setPulseRepetitionFrequency( self.imageFile.prf) self.frame.instrument.setPulseLength(self.imageFile.chirpLength) print('Pulse length: ', self.imageFile.chirpLength) print('Roll angle: ', self.imageFile.roll) if self.imageFile.roll > 0.: self.frame.instrument.platform.setPointingDirection(1) else: self.frame.instrument.platform.setPointingDirection(-1) rawImage = isceobj.createRawImage() rawImage.setByteOrder('l') rawImage.setAccessMode('read') rawImage.setFilename(self.output) rawImage.setWidth(self.imageFile.width * 2) rawImage.setXmin(0) rawImage.setXmax(self.imageFile.width * 2) rawImage.renderHdr() self.frame.setImage(rawImage) return
def extractImage(self): import isceobj if (self.imageFile is None) or (self.leaderFile is None): self.parse() try: out = open(self.output, 'wb') except IOError as strerr: self.logger.error("IOError: %s" % strerr) self.imageFile.extractImage(output=out) out.close() ####RSAT1 is weird. Contains all useful info in RAW data and not leader. ins = self.frame.getInstrument() ins.setPulseRepetitionFrequency(self.imageFile.prf) ins.setPulseLength(self.imageFile.pulseLength) ins.setRangeSamplingRate(self.imageFile.rangeSamplingRate) ins.setRangePixelSize(Const.c / (2 * self.imageFile.rangeSamplingRate)) ins.setChirpSlope(self.imageFile.chirpSlope) ###### self.frame.setSensingStart(self.imageFile.sensingStart) sensingStop = self.imageFile.sensingStart + datetime.timedelta( seconds=((self.frame.getNumberOfLines() - 1) / self.imageFile.prf)) sensingMid = self.imageFile.sensingStart + datetime.timedelta( seconds=0.5 * (sensingStop - self.imageFile.sensingStart).total_seconds()) self.frame.setSensingStop(sensingStop) self.frame.setSensingMid(sensingMid) self.frame.setNumberOfSamples(self.imageFile.width) self.frame.setStartingRange(self.imageFile.startingRange) farRange = self.imageFile.startingRange + ins.getRangePixelSize( ) * self.imageFile.width * 0.5 self.frame.setFarRange(farRange) rawImage = isceobj.createRawImage() rawImage.setByteOrder('l') rawImage.setAccessMode('read') rawImage.setFilename(self.output) rawImage.setWidth(self.imageFile.width) rawImage.setXmin(0) rawImage.setXmax(self.imageFile.width) rawImage.renderHdr() self.frame.setImage(rawImage)
def runMain(insar, frame): tStart = time.time() if frame == 'master': rawFrame = insar.masterFrame else: rawFrame = insar.slaveFrame rawName = rawFrame.image.filename print('\nInput raw image:', rawName) # Processed raw image will simply be xxx.raw -> xxx.processed.raw for simplicity processedName = rawName.split('.') processedName.append(processedName[-1]) processedName[-2] = 'processed' processedName = '.'.join(processedName) print('Output raw image name:', processedName) maskName = '.'.join(rawName.split('.')[:-1]) + '_RFImasks.bil' print('Final masks name:', maskName) print('\nGenerating raw image:') iBias = insar.instrument.inPhaseValue qBias = insar.instrument.quadratureValue rngStart = rawFrame.image.xmin print('iBias:', iBias) print('qBias:', qBias) print('Image x-min:', rngStart) rawImg = genRawImg( rawName, iBias, qBias, rngStart) # Raw image does not have mag-squared transformation rawTransImg = np.abs( rawImg)**2 # Transformed image has line-by-line mag-squared xfrm imWidth = int((rawFrame.image.width - rngStart) / 2) slope = np.abs(insar.instrument.chirpSlope) pulseDir = insar.instrument.pulseLength bwidth = slope * pulseDir kwidth = (bwidth * imWidth) / insar.instrument.rangeSamplingRate chop = (imWidth - kwidth) / 2 print('Processing TSNB components') processTsnbBlock(rawTransImg, chop) print('Processing TVWB components') processTvwbBlock(rawTransImg, chop) del rawTransImg # Save space! print('Finished generating masks. Combining and processing masks...') finalMask, tsnbTot, tvwbTot = genFinalMask(maskName, imWidth) # IU.copyattributes() ? print('Writing new filtered raw image') img = isceobj.createRawImage() img.setFilename(processedName) img.setXmin(rngStart) img.setWidth(rngStart + (2 * len(rawImg[0]))) img.setLength(len(rawImg)) lcount = 0 psum = 0 header = np.zeros(rngStart, dtype=np.uint8) outline = np.zeros(2 * len(rawImg[0])) with open(processedName, 'wb') as fid: for i in range(len(rawImg)): notchLine = (finalMask[i] == 0).astype( float ) # Aggressive masking (all RFI signals removed completely) if np.any(notchLine == 0): lcount += 1 psum += (len(notchLine) - sum(notchLine)) notchLine[0] = 0. # Mask DC value to 0 ln = rawImg[i] * notchLine # Mask the matching line of image header.tofile(fid) line = np.fft.ifft(np.fft.ifftshift(ln)) * len( ln ) # Inverse shift/FFT line and restore magnitude before writing outline[0::2] = line.real + iBias outline[1::2] = line.imag + qBias outline.astype(np.uint8).tofile(fid) img.renderHdr() tEnd = time.time() tstring = str(int( (tEnd - tStart) / 60)) + 'm ' + str(round( (tEnd - tStart) % 60, 2)) + 's' aLines = round(100. * lcount / len(rawImg), 2) fSize = len(rawImg) * len(rawImg[0]) aPix = round(100. * psum / fSize, 2) mTSNB = round(100. * (100. * tsnbTot / fSize) / aPix, 2) mTVWB = round(100. * (100. * tvwbTot / fSize) / aPix, 2) print('\nTotal run-time:', tstring) print('Affected lines in image (%):', aLines) print('Affected pixels in image (%):', aPix) print('Amount of TSNB RFI in image (%):', mTSNB) print('Amount of TVWB RFI in image (%):', mTVWB, '\n') return processedName
def createTrack(self, output): import os from operator import itemgetter from isceobj import Constants as CN from ctypes import cdll, c_char_p, c_int, c_ubyte, byref lib = cdll.LoadLibrary(os.path.dirname(__file__) + '/concatenate.so') # Perhaps we should check to see if Xmin is 0, if it is not, strip off the header self.logger.info( "Adjusting Sampling Window Start Times for all Frames") # Iterate over each frame object, and calculate the number of samples with which to pad it on the left and right outputs = [] totalWidth = 0 auxList = [] for frame in self._frames: # Calculate the amount of padding thisNearRange = frame.getStartingRange() thisFarRange = frame.getFarRange() left_pad = int( round((thisNearRange - self._nearRange) * frame.getInstrument().getRangeSamplingRate() / (CN.SPEED_OF_LIGHT / 2.0))) * 2 right_pad = int( round((self._farRange - thisFarRange) * frame.getInstrument().getRangeSamplingRate() / (CN.SPEED_OF_LIGHT / 2.0))) * 2 width = frame.getImage().getXmax() if width - int(width) != 0: raise ValueError("frame Xmax is not an integer") else: width = int(width) input = frame.getImage().getFilename() # tempOutput = os.path.basename(os.tmpnam()) # Some temporary filename with tempfile.NamedTemporaryFile(dir='.') as f: tempOutput = f.name pad_value = int(frame.getInstrument().getInPhaseValue()) if totalWidth < left_pad + width + right_pad: totalWidth = left_pad + width + right_pad # Resample this frame with swst_resample input_c = c_char_p(bytes(input, 'utf-8')) output_c = c_char_p(bytes(tempOutput, 'utf-8')) width_c = c_int(width) left_pad_c = c_int(left_pad) right_pad_c = c_int(right_pad) pad_value_c = c_ubyte(pad_value) lib.swst_resample(input_c, output_c, byref(width_c), byref(left_pad_c), byref(right_pad_c), byref(pad_value_c)) outputs.append(tempOutput) auxList.append(frame.auxFile) #this step construct the aux file withe the pulsetime info for the all set of frames self.createAuxFile(auxList, output + '.aux') # This assumes that all of the frames to be concatenated are sampled at the same PRI prf = self._frames[0].getInstrument().getPulseRepetitionFrequency() # Calculate the starting output line of each scene i = 0 lineSort = [] # the listSort has 2 elements: a line start number which is the position of that specific frame # computed from acquisition time and the corresponding file name for frame in self._frames: startLine = int( round( DTU.timeDeltaToSeconds(frame.getSensingStart() - self._startTime) * prf)) lineSort.append([startLine, outputs[i]]) i += 1 sortedList = sorted( lineSort, key=itemgetter(0)) # sort by line number i.e. acquisition time startLines, outputs = self.reAdjustStartLine(sortedList, totalWidth) self.logger.info("Concatenating Frames along Track") # this is a hack since the length of the file could be actually different from the one computed using start and stop time. it only matters the last frame added import os fileSize = os.path.getsize(outputs[-1]) numLines = fileSize // totalWidth + startLines[-1] totalLines_c = c_int(numLines) # Next, call frame_concatenate width_c = c_int( totalWidth ) # Width of each frame (with the padding added in swst_resample) numberOfFrames_c = c_int(len(self._frames)) inputs_c = (c_char_p * len(outputs))( ) # These are the inputs to frame_concatenate, but the outputs from swst_resample for kk in range(len(outputs)): inputs_c[kk] = bytes(outputs[kk], 'utf-8') output_c = c_char_p(bytes(output, 'utf-8')) startLines_c = (c_int * len(startLines))() startLines_c[:] = startLines lib.frame_concatenate(output_c, byref(width_c), byref(totalLines_c), byref(numberOfFrames_c), inputs_c, startLines_c) # Clean up the temporary output files from swst_resample for file in outputs: os.unlink(file) orbitNum = self._frames[0].getOrbitNumber() first_line_utc = self._startTime last_line_utc = self._stopTime centerTime = DTU.timeDeltaToSeconds(last_line_utc - first_line_utc) / 2.0 center_line_utc = first_line_utc + datetime.timedelta( microseconds=int(centerTime * 1e6)) procFac = self._frames[0].getProcessingFacility() procSys = self._frames[0].getProcessingSystem() procSoft = self._frames[0].getProcessingSoftwareVersion() pol = self._frames[0].getPolarization() xmin = self._frames[0].getImage().getXmin() self._frame.setOrbitNumber(orbitNum) self._frame.setSensingStart(first_line_utc) self._frame.setSensingMid(center_line_utc) self._frame.setSensingStop(last_line_utc) self._frame.setStartingRange(self._nearRange) self._frame.setFarRange(self._farRange) self._frame.setProcessingFacility(procFac) self._frame.setProcessingSystem(procSys) self._frame.setProcessingSoftwareVersion(procSoft) self._frame.setPolarization(pol) self._frame.setNumberOfLines(numLines) self._frame.setNumberOfSamples(width) # add image to frame rawImage = isceobj.createRawImage() rawImage.setByteOrder('l') rawImage.setFilename(output) rawImage.setAccessMode('r') rawImage.setWidth(totalWidth) rawImage.setXmax(totalWidth) rawImage.setXmin(xmin) self._frame.setImage(rawImage)
def focus(self, mr, fd): """ Focus SAR data @param mr (\a make_raw) a make_raw instance @param fd (\a float) Doppler centroid for focusing """ import stdproc import isceobj #from isceobj.Sensor.Generic import Generic # Extract some useful variables frame = mr.getFrame() orbit = frame.getOrbit() planet = frame.getInstrument().getPlatform().getPlanet() # Calculate Peg Point self.logger.info("Calculating Peg Point") peg = self.calculatePegPoint(frame, orbit, planet) V, H = self.calculateProcessingVelocity(frame, peg) # Interpolate orbit self.logger.info("Interpolating Orbit") pt = stdproc.createPulsetiming() pt.wireInputPort(name='frame', object=frame) pt.pulsetiming() orbit = pt.getOrbit() # Convert orbit to SCH coordinates self.logger.info("Converting orbit reference frame") o2s = stdproc.createOrbit2sch() o2s.wireInputPort(name='planet', object=planet) o2s.wireInputPort(name='orbit', object=orbit) o2s.wireInputPort(name='peg', object=peg) o2s.setAverageHeight(H) o2s.orbit2sch() # Create Raw Image rawImage = isceobj.createRawImage() filename = frame.getImage().getFilename() bytesPerLine = frame.getImage().getXmax() goodBytes = bytesPerLine - frame.getImage().getXmin() rawImage.setAccessMode('read') rawImage.setByteOrder(frame.getImage().byteOrder) rawImage.setFilename(filename) rawImage.setNumberGoodBytes(goodBytes) rawImage.setWidth(bytesPerLine) rawImage.setXmin(frame.getImage().getXmin()) rawImage.setXmax(bytesPerLine) rawImage.createImage() # Create SLC Image slcImage = isceobj.createSlcImage() rangeSamplingRate = frame.getInstrument().getRangeSamplingRate() rangePulseDuration = frame.getInstrument().getPulseLength() chirpSize = int(rangeSamplingRate * rangePulseDuration) chirpExtension = 0 #0.5*chirpSize numberRangeBins = int(goodBytes / 2) - chirpSize + chirpExtension slcImage.setFilename(filename.replace('.raw', '.slc')) slcImage.setByteOrder(frame.getImage().byteOrder) slcImage.setAccessMode('write') slcImage.setDataType('CFLOAT') slcImage.setWidth(numberRangeBins) slcImage.createImage() # Calculate motion compenstation correction for Doppler centroid self.logger.info("Correcting Doppler centroid for motion compensation") fdmocomp = stdproc.createFdMocomp() fdmocomp.wireInputPort(name='frame', object=frame) fdmocomp.wireInputPort(name='peg', object=peg) fdmocomp.wireInputPort(name='orbit', object=o2s.getOrbit()) fdmocomp.setWidth(numberRangeBins) fdmocomp.setSatelliteHeight(H) fdmocomp.setDopplerCoefficients([fd[0], 0.0, 0.0, 0.0]) fdmocomp.fdmocomp() fd[0] = fdmocomp.getDopplerCentroid() self.logger.info("Updated Doppler centroid: %s" % (fd)) # Calculate the motion compensation Doppler centroid correction plus rate #self.logger.info("Testing new Doppler code") #frate = stdproc.createFRate() #frate.wireInputPort(name='frame',object=frame) #frate.wireInputPort(name='peg', object=peg) #frate.wireInputPort(name='orbit',object=o2s.getOrbit()) #frate.wireInputPort(name='planet',object=planet) #frate.setWidth(numberRangeBins) #frate.frate() #fd = frate.getDopplerCentroid() #fdrate = frate.getDopplerRate() #self.logger.info("Updated Doppler centroid and rate: %s %s" % (fd,fdrate)) synthetic_aperature_length = self._calculateSyntheticAperatureLength( frame, V) patchSize = self.nextpow2(2 * synthetic_aperature_length) valid_az_samples = patchSize - synthetic_aperature_length rawFileSize = rawImage.getLength() * rawImage.getWidth() linelength = rawImage.getXmax() overhead = patchSize - valid_az_samples numPatches = (1 + int( (rawFileSize / float(linelength) - overhead) / valid_az_samples)) # Focus image self.logger.info("Focusing image") focus = stdproc.createFormSLC() focus.wireInputPort(name='rawImage', object=rawImage) focus.wireInputPort(name='slcImage', object=slcImage) focus.wireInputPort(name='orbit', object=o2s.getOrbit()) focus.wireInputPort(name='frame', object=frame) focus.wireInputPort(name='peg', object=peg) focus.wireInputPort(name='planet', object=planet) focus.setDebugFlag(96) focus.setBodyFixedVelocity(V) focus.setSpacecraftHeight(H) focus.setAzimuthPatchSize(patchSize) focus.setNumberValidPulses(valid_az_samples) focus.setSecondaryRangeMigrationFlag('n') focus.setNumberAzimuthLooks(1) focus.setNumberPatches(numPatches) focus.setDopplerCentroidCoefficients(fd) #focus.setDopplerCentroidCoefficients([fd[0], 0.0, 0.0]) focus.formslc() mocompPos = focus.getMocompPosition() fp = open('position.sch', 'w') for i in range(len(mocompPos[0])): fp.write("%f %f\n" % (mocompPos[0][i], mocompPos[1][i])) fp.close() slcImage.finalizeImage() rawImage.finalizeImage() # Recreate the SLC image slcImage = isceobj.createSlcImage() slcImage.setFilename(filename.replace('.raw', '.slc')) slcImage.setAccessMode('read') slcImage.setDataType('CFLOAT') slcImage.setWidth(numberRangeBins) slcImage.createImage() width = int(slcImage.getWidth()) length = int(slcImage.getLength()) # Create a frame object and write it out using the Generic driver frame.setImage(slcImage) frame.setOrbit(o2s.getOrbit()) #writer = Generic() #writer.frame = frame #writer.write('test.h5',compression='gzip') slcImage.finalizeImage() self.width = width self.length = length
def extractImage(self): import array import math # just in case there was only one image and it was passed as a str instead of a list with only one element if(isinstance(self._imageFileList,str)): self._imageFileList = [self._imageFileList] self._leaderFileList = [self._leaderFileList] if(len(self._imageFileList) != len(self._leaderFileList)): self.logger.error("Number of leader files different from number of image files.") raise Exception self.frameList = [] for i in range(len(self._imageFileList)): appendStr = "_" + str(i) #if only one file don't change the name if(len(self._imageFileList) == 1): appendStr = '' self.frame = Frame() self.frame.configure() self._leaderFile = self._leaderFileList[i] self._imageFile = self._imageFileList[i] self.leaderFile = LeaderFile(file=self._leaderFile) self.leaderFile.parse() self.imageFile = ImageFile(self) try: outputNow = self.output + appendStr out = open(outputNow,'wb') except IOError as strerr: self.logger.error("IOError: %s" % strerr) return self.imageFile.extractImage(output=out) out.close() rawImage = isceobj.createRawImage() rawImage.setByteOrder('l') rawImage.setAccessMode('read') rawImage.setFilename(outputNow) rawImage.setWidth(self.imageFile.width) rawImage.setXmin(0) rawImage.setXmax(self.imageFile.width) self.frame.setImage(rawImage) self.populateMetadata() self.frameList.append(self.frame) #jng Howard Z at this point adjusts the sampling starting time for imagery generated from CRDC_SARDPF facility. # for now create the orbit aux file based in starting time and prf prf = self.frame.getInstrument().getPulseRepetitionFrequency() senStart = self.frame.getSensingStart() numPulses = int(math.ceil(DTU.timeDeltaToSeconds(self.frame.getSensingStop()-senStart)*prf)) # the aux files has two entries per line. day of the year and microseconds in the day musec0 = (senStart.hour*3600 + senStart.minute*60 + senStart.second)*10**6 + senStart.microsecond maxMusec = (24*3600)*10**6#use it to check if we went across a day. very rare day0 = (datetime.datetime(senStart.year,senStart.month,senStart.day) - datetime.datetime(senStart.year,1,1)).days + 1 outputArray = array.array('d',[0]*2*numPulses) self.frame.auxFile = outputNow + '.aux' fp = open(self.frame.auxFile,'wb') j = -1 for i1 in range(numPulses): j += 1 musec = round((j/prf)*10**6) + musec0 if musec >= maxMusec: day0 += 1 musec0 = musec%maxMusec musec = musec0 j = 0 outputArray[2*i1] = day0 outputArray[2*i1+1] = musec outputArray.tofile(fp) fp.close() tk = Track() if(len(self._imageFileList) > 1): self.frame = tk.combineFrames(self.output,self.frameList) for i in range(len(self._imageFileList)): try: os.remove(self.output + "_" + str(i)) except OSError: print("Error. Cannot remove temporary file",self.output + "_" + str(i)) raise OSError
def focus(self,mr,fd): """ Focus SAR data @param mr (\a make_raw) a make_raw instance @param fd (\a float) Doppler centroid for focusing """ import stdproc import isceobj # Extract some useful variables frame = mr.getFrame() orbit = frame.getOrbit() planet = frame.getInstrument().getPlatform().getPlanet() # Calculate Peg Point self.logger.info("Calculating Peg Point") peg,H,V = self.calculatePegPoint(frame,orbit,planet) # Interpolate orbit self.logger.info("Interpolating Orbit") pt = stdproc.createPulsetiming() pt.wireInputPort(name='frame',object=frame) pt.pulsetiming() orbit = pt.getOrbit() # Convert orbit to SCH coordinates self.logger.info("Converting orbit reference frame") o2s = stdproc.createOrbit2sch() o2s.wireInputPort(name='planet',object=planet) o2s.wireInputPort(name='orbit',object=orbit) o2s.wireInputPort(name='peg',object=peg) o2s.setAverageHeight(H) # updated 07/24/2012 o2s.stdWriter = self._writer_set_file_tags( "orbit2sch", "log", "err", "out" ) # updated 07/24/2012 o2s.orbit2sch() # Create Raw Image rawImage = isceobj.createRawImage() filename = frame.getImage().getFilename() bytesPerLine = frame.getImage().getXmax() goodBytes = bytesPerLine - frame.getImage().getXmin() rawImage.setAccessMode('read') rawImage.setByteOrder(frame.getImage().byteOrder) rawImage.setFilename(filename) rawImage.setNumberGoodBytes(goodBytes) rawImage.setWidth(bytesPerLine) rawImage.setXmin(frame.getImage().getXmin()) rawImage.setXmax(bytesPerLine) rawImage.createImage() self.logger.info("Sensing Start: %s" % (frame.getSensingStart())) # Focus image self.logger.info("Focusing image") focus = stdproc.createFormSLC() focus.wireInputPort(name='rawImage',object=rawImage) #2013-06-03 Kosal: slcImage is not part of ports anymore (see formslc) #it is returned by formscl() rangeSamplingRate = frame.getInstrument().getRangeSamplingRate() rangePulseDuration = frame.getInstrument().getPulseLength() chirpSize = int(rangeSamplingRate*rangePulseDuration) chirpExtension = 0 #0.5*chirpSize numberRangeBin = int(goodBytes/2) - chirpSize + chirpExtension focus.setNumberRangeBin(numberRangeBin) #Kosal focus.wireInputPort(name='orbit',object=o2s.getOrbit()) focus.wireInputPort(name='frame',object=frame) focus.wireInputPort(name='peg',object=peg) focus.setBodyFixedVelocity(V) focus.setSpacecraftHeight(H) focus.setAzimuthPatchSize(8192) focus.setNumberValidPulses(2048) focus.setSecondaryRangeMigrationFlag('n') focus.setNumberAzimuthLooks(1) focus.setNumberPatches(12) focus.setDopplerCentroidCoefficients([fd,0.0,0.0,0.0]) # updated 07/24/2012 focus.stdWriter = self._writer_set_file_tags( "formslc", "log", "err", "out" ) # update 07/24/2012 #2013-06-04 Kosal: slcImage is returned slcImage = focus.formslc() #Kosal rawImage.finalizeImage() width = int(slcImage.getWidth()) length = int(slcImage.getLength()) self.logger.debug("Width: %s" % (width)) self.logger.debug("Length: %s" % (length)) slcImage.finalizeImage() self.width = width self.length = length
def focus(frame, outname, amb=0.0): from isceobj.Catalog import recordInputsAndOutputs from iscesys.ImageUtil.ImageUtil import ImageUtil as IU from isceobj.Constants import SPEED_OF_LIGHT raw_r0 = frame.startingRange raw_dr = frame.getInstrument().getRangePixelSize() img = frame.getImage() dop = frame._dopplerVsPixel #dop = [x/frame.PRF for x in frame._dopplerVsPixel] #####Velocity/ acceleration etc planet = frame.instrument.platform.planet elp = copy.copy(planet.ellipsoid) svmid = frame.orbit.interpolateOrbit(frame.sensingMid, method='hermite') xyz = svmid.getPosition() vxyz = svmid.getVelocity() llh = elp.xyz_to_llh(xyz) heading = frame.orbit.getENUHeading(frame.sensingMid) print('Heading: ', heading) elp.setSCH(llh[0], llh[1], heading) sch, schvel = elp.xyzdot_to_schdot(xyz, vxyz) vel = np.linalg.norm(schvel) hgt = sch[2] radius = elp.pegRadCur ####Computation of acceleration dist = np.linalg.norm(xyz) r_spinvec = np.array([0., 0., planet.spin]) r_tempv = np.cross(r_spinvec, xyz) inert_acc = np.array([-planet.GM * x / (dist**3) for x in xyz]) r_tempa = np.cross(r_spinvec, vxyz) r_tempvec = np.cross(r_spinvec, r_tempv) r_bodyacc = inert_acc - 2 * r_tempa - r_tempvec schbasis = elp.schbasis(sch) schacc = np.dot(schbasis.xyz_to_sch, r_bodyacc).tolist()[0] print('SCH velocity: ', schvel) print('SCH acceleration: ', schacc) print('Body velocity: ', vel) print('Height: ', hgt) print('Radius: ', radius) #####Setting up formslc form = FormSLC() form.configure() ####Width form.numberBytesPerLine = img.getWidth() ###Includes header form.numberGoodBytes = img.getWidth() ####First Sample form.firstSample = img.getXmin() // 2 ####Starting range form.rangeFirstSample = frame.startingRange ####Azimuth looks form.numberAzimuthLooks = 1 ####debug form.debugFlag = False ####PRF form.prf = frame.PRF form.sensingStart = frame.sensingStart ####Bias form.inPhaseValue = frame.getInstrument().inPhaseValue form.quadratureValue = frame.getInstrument().quadratureValue ####Resolution form.antennaLength = frame.instrument.platform.antennaLength form.azimuthResolution = 0.6 * form.antennaLength #85% of max bandwidth ####Sampling rate form.rangeSamplingRate = frame.getInstrument().rangeSamplingRate ####Chirp parameters form.chirpSlope = frame.getInstrument().chirpSlope form.rangePulseDuration = frame.getInstrument().pulseLength ####Wavelength form.radarWavelength = frame.getInstrument().radarWavelength ####Secondary range migration form.secondaryRangeMigrationFlag = False ###pointing direction form.pointingDirection = frame.instrument.platform.pointingDirection print('Lookside: ', form.pointingDirection) ####Doppler centroids cfs = [amb, 0., 0., 0.] for ii in range(min(len(dop), 4)): cfs[ii] += dop[ii] / form.prf form.dopplerCentroidCoefficients = cfs ####Create raw image rawimg = isceobj.createRawImage() rawimg.load(img.filename + '.xml') rawimg.setAccessMode('READ') rawimg.createImage() form.rawImage = rawimg ####All the orbit parameters form.antennaSCHVelocity = schvel form.antennaSCHAcceleration = schacc form.bodyFixedVelocity = vel form.spacecraftHeight = hgt form.planetLocalRadius = radius ###Create SLC image slcImg = isceobj.createSlcImage() slcImg.setFilename(outname) form.slcImage = slcImg form.formslc() ####Populate frame metadata for SLC width = form.slcImage.getWidth() length = form.slcImage.getLength() prf = frame.PRF delr = frame.instrument.getRangePixelSize() ####Start creating an SLC frame to work with slcFrame = copy.deepcopy(frame) slcFrame.setStartingRange(form.startingRange) slcFrame.setFarRange(form.startingRange + (width - 1) * delr) tstart = form.slcSensingStart tmid = tstart + datetime.timedelta(seconds=0.5 * length / prf) tend = tstart + datetime.timedelta(seconds=(length - 1) / prf) slcFrame.sensingStart = tstart slcFrame.sensingMid = tmid slcFrame.sensingStop = tend form.slcImage.setAccessMode('READ') form.slcImage.setXmin(0) form.slcImage.setXmax(width) slcFrame.setImage(form.slcImage) slcFrame.setNumberOfSamples(width) slcFrame.setNumberOfLines(length) #####Adjust the doppler polynomial dop = frame._dopplerVsPixel[::-1] xx = np.linspace(0, (width - 1), num=len(dop) + 1) x = (slcFrame.startingRange - frame.startingRange) / delr + xx v = np.polyval(dop, x) p = np.polyfit(xx, v, len(dop) - 1)[::-1] slcFrame._dopplerVsPixel = list(p) slcFrame._dopplerVsPixel[0] += amb * prf return slcFrame
def focus(frame, amb=0.0, dop=None): from isceobj.Catalog import recordInputsAndOutputs from iscesys.ImageUtil.ImageUtil import ImageUtil as IU from isceobj.Constants import SPEED_OF_LIGHT raw_r0 = frame.startingRange raw_dr = frame.getInstrument().getRangePixelSize() img = frame.getImage() if dop is None: dop = frame._dopplerVsPixel print('dop', dop) #####Velocity/ acceleration etc planet = frame.instrument.platform.planet elp = copy.copy(planet.ellipsoid) svmid = frame.orbit.interpolateOrbit(frame.sensingMid, method='hermite') xyz = svmid.getPosition() vxyz = svmid.getVelocity() llh = elp.xyz_to_llh(xyz) heading = frame.orbit.getENUHeading(frame.sensingMid) print('Heading: ', heading) elp.setSCH(llh[0], llh[1], heading) sch, schvel = elp.xyzdot_to_schdot(xyz, vxyz) vel = np.linalg.norm(schvel) hgt = sch[2] radius = elp.pegRadCur ####Computation of acceleration dist = np.linalg.norm(xyz) r_spinvec = np.array([0., 0., planet.spin]) r_tempv = np.cross(r_spinvec, xyz) inert_acc = np.array([-planet.GM * x / (dist**3) for x in xyz]) r_tempa = np.cross(r_spinvec, vxyz) r_tempvec = np.cross(r_spinvec, r_tempv) r_bodyacc = inert_acc - 2 * r_tempa - r_tempvec schbasis = elp.schbasis(sch) schacc = np.dot(schbasis.xyz_to_sch, r_bodyacc).tolist()[0] print('SCH velocity: ', schvel) print('SCH acceleration: ', schacc) print('Body velocity: ', vel) print('Height: ', hgt) print('Radius: ', radius) #####Setting up formslc form = FormSLC() form.configure() ####Width form.numberBytesPerLine = img.getWidth() ###Includes header form.numberGoodBytes = img.getWidth() ####Different chirp extensions # form.nearRangeChirpExtFrac = 0.0 # form.farRangeChirpExtFrac = 0.0 # form.earlyAzimuthChirpExtFrac = 0.0 # form.lateAzimuthChirpExtrFrac = 0.0 ###First Line - set with defaults ###Depending on extensions # form.firstLine = 0 ####First Sample form.firstSample = img.getXmin() // 2 ####Start range bin - set with defaults ###Depending on extensions # form.startRangeBin = 1 ####Starting range form.rangeFirstSample = frame.startingRange ####Number range bin ###Determined in FormSLC.py using chirp extensions # form.numberRangeBin = img.getWidth() // 2 - 1000 ####Azimuth looks form.numberAzimuthLooks = 1 ####debug form.debugFlag = False ####PRF form.prf = frame.PRF form.sensingStart = frame.sensingStart ####Bias form.inPhaseValue = frame.getInstrument().inPhaseValue form.quadratureValue = frame.getInstrument().quadratureValue ####Resolution form.antennaLength = frame.instrument.platform.antennaLength form.azimuthResolution = 0.6 * form.antennaLength #85% of max bandwidth ####Sampling rate form.rangeSamplingRate = frame.getInstrument().rangeSamplingRate ####Chirp parameters form.chirpSlope = frame.getInstrument().chirpSlope form.rangePulseDuration = frame.getInstrument().pulseLength ####Wavelength form.radarWavelength = frame.getInstrument().radarWavelength ####Secondary range migration form.secondaryRangeMigrationFlag = False ###pointing direction form.pointingDirection = frame.instrument.platform.pointingDirection print('Lookside: ', form.pointingDirection) ####Doppler centroids cfs = [amb, 0., 0., 0.] for ii in range(min(len(dop), 4)): cfs[ii] += dop[ii] / form.prf form.dopplerCentroidCoefficients = cfs ####Create raw image rawimg = isceobj.createRawImage() rawimg.load(img.filename + '.xml') rawimg.setAccessMode('READ') rawimg.createImage() form.rawImage = rawimg ####All the orbit parameters form.antennaSCHVelocity = schvel form.antennaSCHAcceleration = schacc form.bodyFixedVelocity = vel form.spacecraftHeight = hgt form.planetLocalRadius = radius ###Create SLC image slcImg = isceobj.createSlcImage() slcImg.setFilename(img.filename + '.slc') form.slcImage = slcImg form.formslc() return form