259 lines
11 KiB
Python
259 lines
11 KiB
Python
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
# Copyright 2013 California Institute of Technology. ALL RIGHTS RESERVED.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
#
|
|
# United States Government Sponsorship acknowledged. This software is subject to
|
|
# U.S. export control laws and regulations and has been classified as 'EAR99 NLR'
|
|
# (No [Export] License Required except when exporting to an embargoed country,
|
|
# end user, or in support of a prohibited end use). By downloading this software,
|
|
# the user agrees to comply with all applicable U.S. export laws and regulations.
|
|
# The user has the responsibility to obtain export licenses, or other export
|
|
# authority as may be required before exporting this software to any 'EAR99'
|
|
# embargoed foreign country or citizen of those countries.
|
|
#
|
|
# Authors: Kosal Khun, Marco Lavalle
|
|
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
|
|
|
# Comment: Adapted from InsarProc/runPreprocessor.py
|
|
import os
|
|
import sys
|
|
import logging
|
|
import isceobj
|
|
from make_raw import make_raw
|
|
from isceobj import Doppler, Sensor
|
|
from isceobj.Image import createSlcImage
|
|
from isceobj.Image import createRawImage
|
|
from mroipac.baseline.Baseline import Baseline
|
|
|
|
logger = logging.getLogger('isce.isceProc.runPreprocessor')
|
|
|
|
def runPreprocessor(self):
|
|
doppler = Doppler.createDoppler(self.dopplerMethod)
|
|
sensorname = self.sensorName
|
|
|
|
for sceneid in self._isce.selectedScenes:
|
|
scene = self._isce.srcFiles[sceneid]
|
|
self._isce.frames[sceneid] = {}
|
|
self._isce.dopplers[sceneid] = {}
|
|
self._isce.rawImages[sceneid] = {}
|
|
self._isce.iqImages[sceneid] = {}
|
|
self._isce.squints[sceneid] = {}
|
|
for pol in self._isce.selectedPols:
|
|
sid = self._isce.formatname(sceneid, pol)
|
|
rawfile = os.path.join(self.getoutputdir(sceneid),
|
|
self._isce.formatname(sceneid, pol, 'raw'))
|
|
|
|
if not 'uavsar_rpi' in sensorname.lower():
|
|
sensor = getsensorobj(scene, pol, rawfile, sensorname, sceneid)
|
|
else:
|
|
#uavsar_rpi requires that we name a 'reference' and a 'secondary'
|
|
#this sensor is strictly pairwise processing
|
|
name = 'reference' if sceneid == self._isce.refScene else 'secondary'
|
|
sensor = getsensorobj(scene, pol, rawfile, sensorname, name)
|
|
|
|
catalog = isceobj.Catalog.createCatalog(self._isce.procDoc.name)
|
|
rawobj = run(sensor, doppler, catalog=catalog, sceneid=sid) ##actual processing
|
|
self._isce.frames[sceneid][pol] = rawobj.getFrame() ##add frames to main object
|
|
self._isce.dopplers[sceneid][pol] = rawobj.getDopplerValues() ##add dopplers to main object
|
|
self._isce.squints[sceneid][pol] = rawobj.getSquint()
|
|
|
|
self._isce.procDoc.addAllFromCatalog(catalog)
|
|
|
|
rawimage = initRawImage(rawobj)
|
|
if rawobj.frame.image.imageType == 'slc': ##it's a slc image
|
|
slcfile = rawfile[:-3] + 'raw' #ML 21-8-2014 changed slc to raw
|
|
os.system("ln -s "+os.path.join(os.getcwd(), rawobj.frame.image.filename)+" "+slcfile)
|
|
# os.rename(rawfile, slcfile)
|
|
self._isce.slcImages[sceneid] = {} #ML 21-8-2014
|
|
self._isce.slcImages[sceneid][pol] = rawimage
|
|
else: ##it's a real raw image
|
|
self._isce.rawImages[sceneid][pol] = rawimage ##add raw images to main object
|
|
self._isce.iqImages[sceneid][pol] = rawobj.getIQImage() ##add iqImages to main object
|
|
|
|
# KK 2013-12-12: calculate baselines for selected pairs
|
|
for sceneid1, sceneid2 in self._isce.selectedPairs:
|
|
pair = (sceneid1, sceneid2)
|
|
frame1 = self._isce.frames[sceneid1][self._isce.refPol]
|
|
frame2 = self._isce.frames[sceneid2][self._isce.refPol]
|
|
sid = self._isce.formatname(pair)
|
|
catalog = isceobj.Catalog.createCatalog(self._isce.procDoc.name)
|
|
getBaseline(frame1, frame2, catalog=catalog, sceneid=sid)
|
|
self._isce.procDoc.addAllFromCatalog(catalog)
|
|
# KK
|
|
|
|
# KK 2013-12-12: get refFrame from refScene/refPol
|
|
refFrame = self._isce.frames[self._isce.refScene][self._isce.refPol]
|
|
self._isce.numberRangeBins = refFrame.numberRangeBins
|
|
self._isce.lookSide = refFrame.getInstrument().getPlatform().pointingDirection
|
|
# KK
|
|
|
|
if sensorname == 'ALOS':
|
|
self._isce.transmit = sensor.transmit
|
|
self._isce.receive = sensor.receive
|
|
|
|
|
|
# KK 2013-12-12: calculate baselines between 2 frames
|
|
def getBaseline(frame1, frame2, catalog=None, sceneid='NO_ID'):
|
|
optlist = ['all', 'top', 'middle', 'bottom']
|
|
success = False
|
|
baseLocation = None
|
|
for option in optlist:
|
|
baseObj = Baseline()
|
|
baseObj.configure()
|
|
baseObj.baselineLocation = option
|
|
baseObj.wireInputPort(name='referenceFrame',object=frame1)
|
|
baseObj.wireInputPort(name='secondaryFrame',object=frame2)
|
|
try:
|
|
baseObj.baseline()
|
|
success = True
|
|
baseLocation = option
|
|
except:
|
|
logger.debug(('runPreprocessor.getBaseline '+
|
|
'option "{0}" failed'.format(option)))
|
|
pass
|
|
if success:
|
|
logger.debug(('runPreprocessor.getBaseline: '+
|
|
'option "{0}" success'.format(option)))
|
|
break
|
|
if not success:
|
|
raise Exception('Baseline computation failed with all possible options. Images may not overlap.')
|
|
|
|
if catalog is not None:
|
|
catalog.addItem('horizontal_baseline_top', baseObj.hBaselineTop, sceneid)
|
|
catalog.addItem('horizontal_baseline_rate', baseObj.hBaselineRate, sceneid)
|
|
catalog.addItem('horizontal_baseline_acc', baseObj.hBaselineAcc, sceneid)
|
|
catalog.addItem('vertical_baseline_top', baseObj.vBaselineTop, sceneid)
|
|
catalog.addItem('vertical_baseline_rate', baseObj.vBaselineRate, sceneid)
|
|
catalog.addItem('vertical_baseline_acc', baseObj.vBaselineAcc, sceneid)
|
|
catalog.addItem('perp_baseline_top', baseObj.pBaselineTop, sceneid)
|
|
catalog.addItem('perp_baseline_bottom', baseObj.pBaselineBottom, sceneid)
|
|
# KK
|
|
|
|
|
|
def getsensorobj(scene, pol, output, sensorname, name):
|
|
polkey = reformatscene(scene, pol, sensorname) ##change pol key to imagefile/xml/hdf5 depending on sensor
|
|
#scene['output'] = output
|
|
sensor = Sensor.createSensor(sensorname, name)
|
|
sensor._ignoreMissing = True
|
|
sensor.catalog = scene
|
|
sensor.configure()
|
|
setattr(sensor, polkey, scene[polkey]) #ML 21-8-2014
|
|
setattr(sensor, 'output', output) #ML 21-8-2014
|
|
#sensor.initRecursive(scene, {}) ##populate sensor
|
|
del scene[polkey]
|
|
#del scene['output']
|
|
return sensor
|
|
|
|
|
|
def reformatscene(scenedict, pol, sensorname):
|
|
imageKey = { ##key corresponding to the image file, according to each sensor's dictionaryOfVariables
|
|
'ALOS': 'imagefile',
|
|
'COSMO_SKYMED': 'hdf5',
|
|
'ENVISAT': 'imagefile',
|
|
'ERS': 'imagefile', #KK 2013-11-16
|
|
'JERS': 'imagefile',
|
|
'RADARSAT1': 'imagefile',
|
|
'RADARSAT2': 'xml',
|
|
'TERRASARX': 'xml',
|
|
'GENERIC': 'hdf5',
|
|
'ERS_ENVI': 'imagefile', #KK 2013-11-26 (ers in envi format)
|
|
'UAVSAR_RPI':'annotationfile',
|
|
'UAVSAR_STACK':'annotationfile',
|
|
'SENTINEL1A':'tiff',
|
|
'SAOCOM':'tiff'
|
|
}
|
|
try:
|
|
key = imageKey[sensorname.upper()]
|
|
except KeyError:
|
|
sys.exit("Unknown sensorname '%s'" % sensorname)
|
|
else:
|
|
scenedict[key] = scenedict[pol]
|
|
return key
|
|
|
|
|
|
|
|
def run(sensor, doppler, catalog=None, sceneid='NO_ID'):
|
|
"""
|
|
Extract raw image from sensor.
|
|
"""
|
|
|
|
objMakeRaw = make_raw()
|
|
objMakeRaw(sensor=sensor, doppler=doppler)
|
|
|
|
if catalog is not None:
|
|
rawImage = initRawImage(objMakeRaw)
|
|
|
|
frame = objMakeRaw.getFrame()
|
|
instrument = frame.getInstrument()
|
|
platform = instrument.getPlatform()
|
|
orbit = frame.getOrbit()
|
|
|
|
planet = platform.getPlanet()
|
|
catalog.addInputsFrom(planet, 'planet')
|
|
catalog.addInputsFrom(planet.get_elp(), 'planet.ellipsoid')
|
|
|
|
catalog.addInputsFrom(sensor, 'sensor')
|
|
catalog.addItem('width', rawImage.getWidth(), sceneid)
|
|
catalog.addItem('xmin', rawImage.getXmin(), sceneid)
|
|
catalog.addItem('iBias', instrument.getInPhaseValue(), sceneid)
|
|
catalog.addItem('qBias', instrument.getQuadratureValue(), sceneid)
|
|
catalog.addItem('range_sampling_rate', instrument.getRangeSamplingRate(), sceneid)
|
|
catalog.addItem('prf', instrument.getPulseRepetitionFrequency(), sceneid)
|
|
catalog.addItem('pri', 1.0/instrument.getPulseRepetitionFrequency(), sceneid)
|
|
catalog.addItem('pulse_length', instrument.getPulseLength(), sceneid)
|
|
catalog.addItem('chirp_slope', instrument.getChirpSlope(), sceneid)
|
|
catalog.addItem('wavelength', instrument.getRadarWavelength(), sceneid)
|
|
catalog.addItem('lookSide', platform.pointingDirection, sceneid) #KK 2013-12-12
|
|
catalog.addInputsFrom(frame, '%s.frame' % sceneid)
|
|
catalog.addInputsFrom(instrument, '%s.instrument' % sceneid)
|
|
catalog.addInputsFrom(platform, '%s.platform' % sceneid)
|
|
catalog.addInputsFrom(orbit, '%s.orbit' % sceneid)
|
|
|
|
catalog.printToLog(logger, "runPreprocessor: %s" % sceneid)
|
|
|
|
return objMakeRaw
|
|
|
|
|
|
def initRawImage(makeRawObj):
|
|
"""
|
|
Create a rawImage object from a makeRaw object.
|
|
"""
|
|
#the "raw" image in some cases is an slc.
|
|
#probably need to make this a factory
|
|
#instantiated based on the sensor type
|
|
imageType = makeRawObj.frame.getImage()
|
|
if isinstance(imageType, createRawImage().__class__):
|
|
filename = makeRawObj.frame.getImage().getFilename()
|
|
bytesPerLine = makeRawObj.frame.getImage().getXmax()
|
|
goodBytes = makeRawObj.frame.getImage().getXmax() - makeRawObj.frame.getImage().getXmin()
|
|
logger.debug("bytes_per_line: %s" % (bytesPerLine))
|
|
logger.debug("good_bytes_per_line: %s" % (goodBytes))
|
|
objRaw = createRawImage()
|
|
objRaw.setFilename(filename)
|
|
objRaw.setNumberGoodBytes(goodBytes)
|
|
objRaw.setWidth(bytesPerLine)
|
|
objRaw.setXmin(makeRawObj.frame.getImage().getXmin())
|
|
objRaw.setXmax(bytesPerLine)
|
|
elif(isinstance(imageType,createSlcImage().__class__)):
|
|
objRaw = createSlcImage()
|
|
filename = makeRawObj.frame.getImage().getFilename()
|
|
bytesPerLine = makeRawObj.frame.getImage().getXmax()
|
|
objRaw.setFilename(filename)
|
|
objRaw.setWidth(bytesPerLine)
|
|
objRaw.setXmin(makeRawObj.frame.getImage().getXmin())
|
|
objRaw.setXmax(bytesPerLine)
|
|
return objRaw
|