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
