601 lines
30 KiB
Python
601 lines
30 KiB
Python
#
|
|
# Author: Cunren Liang
|
|
# Copyright 2015-present, NASA-JPL/Caltech
|
|
#
|
|
|
|
import os
|
|
import glob
|
|
import logging
|
|
import datetime
|
|
import numpy as np
|
|
|
|
import isceobj
|
|
import isceobj.Sensor.MultiMode as MultiMode
|
|
from isceobj.Planet.Planet import Planet
|
|
from isceobj.Alos2Proc.Alos2ProcPublic import runCmd
|
|
from isceobj.Alos2Proc.Alos2ProcPublic import getBboxRdr
|
|
from isceobj.Alos2Proc.Alos2ProcPublic import getBboxGeo
|
|
|
|
logger = logging.getLogger('isce.alos2insar.runPreprocessor')
|
|
|
|
def runPreprocessor(self):
|
|
'''Extract images.
|
|
'''
|
|
catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name)
|
|
|
|
|
|
#find files
|
|
#actually no need to use absolute path any longer, since we are able to find file from vrt now. 27-JAN-2020, CRL.
|
|
#denseoffset may still need absolute path when making links
|
|
self.referenceDir = os.path.abspath(self.referenceDir)
|
|
self.secondaryDir = os.path.abspath(self.secondaryDir)
|
|
|
|
ledFilesReference = sorted(glob.glob(os.path.join(self.referenceDir, 'LED-ALOS2*-*-*')))
|
|
imgFilesReference = sorted(glob.glob(os.path.join(self.referenceDir, 'IMG-{}-ALOS2*-*-*'.format(self.referencePolarization.upper()))))
|
|
|
|
ledFilesSecondary = sorted(glob.glob(os.path.join(self.secondaryDir, 'LED-ALOS2*-*-*')))
|
|
imgFilesSecondary = sorted(glob.glob(os.path.join(self.secondaryDir, 'IMG-{}-ALOS2*-*-*'.format(self.secondaryPolarization.upper()))))
|
|
|
|
firstFrameReference = ledFilesReference[0].split('-')[-3][-4:]
|
|
firstFrameSecondary = ledFilesSecondary[0].split('-')[-3][-4:]
|
|
firstFrameImagesReference = sorted(glob.glob(os.path.join(self.referenceDir, 'IMG-{}-ALOS2*{}-*-*'.format(self.referencePolarization.upper(), firstFrameReference))))
|
|
firstFrameImagesSecondary = sorted(glob.glob(os.path.join(self.secondaryDir, 'IMG-{}-ALOS2*{}-*-*'.format(self.secondaryPolarization.upper(), firstFrameSecondary))))
|
|
|
|
|
|
#determin operation mode
|
|
referenceMode = os.path.basename(ledFilesReference[0]).split('-')[-1][0:3]
|
|
secondaryMode = os.path.basename(ledFilesSecondary[0]).split('-')[-1][0:3]
|
|
spotlightModes = ['SBS']
|
|
stripmapModes = ['UBS', 'UBD', 'HBS', 'HBD', 'HBQ', 'FBS', 'FBD', 'FBQ']
|
|
scansarNominalModes = ['WBS', 'WBD', 'WWS', 'WWD']
|
|
scansarWideModes = ['VBS', 'VBD']
|
|
scansarModes = ['WBS', 'WBD', 'WWS', 'WWD', 'VBS', 'VBD']
|
|
|
|
#usable combinations
|
|
if (referenceMode in spotlightModes) and (secondaryMode in spotlightModes):
|
|
self._insar.modeCombination = 0
|
|
elif (referenceMode in stripmapModes) and (secondaryMode in stripmapModes):
|
|
self._insar.modeCombination = 1
|
|
elif (referenceMode in scansarNominalModes) and (secondaryMode in scansarNominalModes):
|
|
self._insar.modeCombination = 21
|
|
elif (referenceMode in scansarWideModes) and (secondaryMode in scansarWideModes):
|
|
self._insar.modeCombination = 22
|
|
elif (referenceMode in scansarNominalModes) and (secondaryMode in stripmapModes):
|
|
self._insar.modeCombination = 31
|
|
elif (referenceMode in scansarWideModes) and (secondaryMode in stripmapModes):
|
|
self._insar.modeCombination = 32
|
|
else:
|
|
print('\n\nthis mode combination is not possible')
|
|
print('note that for ScanSAR-stripmap, ScanSAR must be reference\n\n')
|
|
raise Exception('mode combination not supported')
|
|
|
|
# pixel size from real data processing. azimuth pixel size may change a bit as
|
|
# the antenna points to a different swath and therefore uses a different PRF.
|
|
|
|
# MODE RANGE PIXEL SIZE (LOOKS) AZIMUTH PIXEL SIZE (LOOKS)
|
|
# -------------------------------------------------------------------
|
|
# SPT [SBS]
|
|
# 1.4304222392897463 (2) 0.9351804642158579 (4)
|
|
# SM1 [UBS,UBD]
|
|
# 1.4304222392897463 (2) 1.8291988125114438 (2)
|
|
# SM2 [HBS,HBD,HBQ]
|
|
# 2.8608444785794984 (2) 3.0672373839847196 (2)
|
|
# SM3 [FBS,FBD,FBQ]
|
|
# 4.291266717869248 (2) 3.2462615913656667 (4)
|
|
|
|
# WD1 [WBS,WBD] [WWS,WWD]
|
|
# 8.582533435738496 (1) 2.6053935830031887 (14)
|
|
# 8.582533435738496 (1) 2.092362043327227 (14)
|
|
# 8.582533435738496 (1) 2.8817632034495717 (14)
|
|
# 8.582533435738496 (1) 3.054362492601842 (14)
|
|
# 8.582533435738496 (1) 2.4582084463356977 (14)
|
|
|
|
# WD2 [VBS,VBD]
|
|
# 8.582533435738496 (1) 2.9215796012950728 (14)
|
|
# 8.582533435738496 (1) 3.088859074497863 (14)
|
|
# 8.582533435738496 (1) 2.8792293071133073 (14)
|
|
# 8.582533435738496 (1) 3.0592146044234854 (14)
|
|
# 8.582533435738496 (1) 2.8818767752199137 (14)
|
|
# 8.582533435738496 (1) 3.047038521027477 (14)
|
|
# 8.582533435738496 (1) 2.898816222039108 (14)
|
|
|
|
#determine default number of looks:
|
|
self._insar.numberRangeLooks1 = self.numberRangeLooks1
|
|
self._insar.numberAzimuthLooks1 = self.numberAzimuthLooks1
|
|
self._insar.numberRangeLooks2 = self.numberRangeLooks2
|
|
self._insar.numberAzimuthLooks2 = self.numberAzimuthLooks2
|
|
#the following two will be automatically determined by runRdrDemOffset.py
|
|
self._insar.numberRangeLooksSim = self.numberRangeLooksSim
|
|
self._insar.numberAzimuthLooksSim = self.numberAzimuthLooksSim
|
|
self._insar.numberRangeLooksIon = self.numberRangeLooksIon
|
|
self._insar.numberAzimuthLooksIon = self.numberAzimuthLooksIon
|
|
|
|
if self._insar.numberRangeLooks1 == None:
|
|
if referenceMode in ['SBS']:
|
|
self._insar.numberRangeLooks1 = 2
|
|
elif referenceMode in ['UBS', 'UBD']:
|
|
self._insar.numberRangeLooks1 = 2
|
|
elif referenceMode in ['HBS', 'HBD', 'HBQ']:
|
|
self._insar.numberRangeLooks1 = 2
|
|
elif referenceMode in ['FBS', 'FBD', 'FBQ']:
|
|
self._insar.numberRangeLooks1 = 2
|
|
elif referenceMode in ['WBS', 'WBD']:
|
|
self._insar.numberRangeLooks1 = 1
|
|
elif referenceMode in ['WWS', 'WWD']:
|
|
self._insar.numberRangeLooks1 = 2
|
|
elif referenceMode in ['VBS', 'VBD']:
|
|
self._insar.numberRangeLooks1 = 1
|
|
else:
|
|
raise Exception('unknow acquisition mode')
|
|
|
|
if self._insar.numberAzimuthLooks1 == None:
|
|
if referenceMode in ['SBS']:
|
|
self._insar.numberAzimuthLooks1 = 4
|
|
elif referenceMode in ['UBS', 'UBD']:
|
|
self._insar.numberAzimuthLooks1 = 2
|
|
elif referenceMode in ['HBS', 'HBD', 'HBQ']:
|
|
self._insar.numberAzimuthLooks1 = 2
|
|
elif referenceMode in ['FBS', 'FBD', 'FBQ']:
|
|
self._insar.numberAzimuthLooks1 = 4
|
|
elif referenceMode in ['WBS', 'WBD']:
|
|
self._insar.numberAzimuthLooks1 = 14
|
|
elif referenceMode in ['WWS', 'WWD']:
|
|
self._insar.numberAzimuthLooks1 = 14
|
|
elif referenceMode in ['VBS', 'VBD']:
|
|
self._insar.numberAzimuthLooks1 = 14
|
|
else:
|
|
raise Exception('unknow acquisition mode')
|
|
|
|
if self._insar.numberRangeLooks2 == None:
|
|
if referenceMode in spotlightModes:
|
|
self._insar.numberRangeLooks2 = 4
|
|
elif referenceMode in stripmapModes:
|
|
self._insar.numberRangeLooks2 = 4
|
|
elif referenceMode in scansarModes:
|
|
self._insar.numberRangeLooks2 = 5
|
|
else:
|
|
raise Exception('unknow acquisition mode')
|
|
|
|
if self._insar.numberAzimuthLooks2 == None:
|
|
if referenceMode in spotlightModes:
|
|
self._insar.numberAzimuthLooks2 = 4
|
|
elif referenceMode in stripmapModes:
|
|
self._insar.numberAzimuthLooks2 = 4
|
|
elif referenceMode in scansarModes:
|
|
self._insar.numberAzimuthLooks2 = 2
|
|
else:
|
|
raise Exception('unknow acquisition mode')
|
|
|
|
if self._insar.numberRangeLooksIon == None:
|
|
if referenceMode in spotlightModes:
|
|
self._insar.numberRangeLooksIon = 16
|
|
elif referenceMode in stripmapModes:
|
|
self._insar.numberRangeLooksIon = 16
|
|
elif referenceMode in scansarModes:
|
|
self._insar.numberRangeLooksIon = 40
|
|
else:
|
|
raise Exception('unknow acquisition mode')
|
|
|
|
if self._insar.numberAzimuthLooksIon == None:
|
|
if referenceMode in spotlightModes:
|
|
self._insar.numberAzimuthLooksIon = 16
|
|
elif referenceMode in stripmapModes:
|
|
self._insar.numberAzimuthLooksIon = 16
|
|
elif referenceMode in scansarModes:
|
|
self._insar.numberAzimuthLooksIon = 16
|
|
else:
|
|
raise Exception('unknow acquisition mode')
|
|
|
|
|
|
#define processing file names
|
|
self._insar.referenceDate = os.path.basename(ledFilesReference[0]).split('-')[2]
|
|
self._insar.secondaryDate = os.path.basename(ledFilesSecondary[0]).split('-')[2]
|
|
self._insar.setFilename(referenceDate=self._insar.referenceDate, secondaryDate=self._insar.secondaryDate, nrlks1=self._insar.numberRangeLooks1, nalks1=self._insar.numberAzimuthLooks1, nrlks2=self._insar.numberRangeLooks2, nalks2=self._insar.numberAzimuthLooks2)
|
|
|
|
|
|
#find frame numbers
|
|
if (self._insar.modeCombination == 31) or (self._insar.modeCombination == 32):
|
|
if (self.referenceFrames == None) or (self.secondaryFrames == None):
|
|
raise Exception('for ScanSAR-stripmap inteferometry, you must set reference and secondary frame numbers')
|
|
#if not set, find frames automatically
|
|
if self.referenceFrames == None:
|
|
self.referenceFrames = []
|
|
for led in ledFilesReference:
|
|
frameNumber = os.path.basename(led).split('-')[1][-4:]
|
|
if frameNumber not in self.referenceFrames:
|
|
self.referenceFrames.append(frameNumber)
|
|
if self.secondaryFrames == None:
|
|
self.secondaryFrames = []
|
|
for led in ledFilesSecondary:
|
|
frameNumber = os.path.basename(led).split('-')[1][-4:]
|
|
if frameNumber not in self.secondaryFrames:
|
|
self.secondaryFrames.append(frameNumber)
|
|
#sort frames
|
|
self.referenceFrames = sorted(self.referenceFrames)
|
|
self.secondaryFrames = sorted(self.secondaryFrames)
|
|
#check number of frames
|
|
if len(self.referenceFrames) != len(self.secondaryFrames):
|
|
raise Exception('number of frames in reference dir is not equal to number of frames \
|
|
in secondary dir. please set frame number manually')
|
|
|
|
|
|
#find swath numbers (if not ScanSAR-ScanSAR, compute valid swaths)
|
|
if (self._insar.modeCombination == 0) or (self._insar.modeCombination == 1):
|
|
self.startingSwath = 1
|
|
self.endingSwath = 1
|
|
|
|
if self._insar.modeCombination == 21:
|
|
if self.startingSwath == None:
|
|
self.startingSwath = 1
|
|
if self.endingSwath == None:
|
|
self.endingSwath = 5
|
|
|
|
if self._insar.modeCombination == 22:
|
|
if self.startingSwath == None:
|
|
self.startingSwath = 1
|
|
if self.endingSwath == None:
|
|
self.endingSwath = 7
|
|
|
|
#determine starting and ending swaths for ScanSAR-stripmap, user's settings are overwritten
|
|
#use first frame to check overlap
|
|
if (self._insar.modeCombination == 31) or (self._insar.modeCombination == 32):
|
|
if self._insar.modeCombination == 31:
|
|
numberOfSwaths = 5
|
|
else:
|
|
numberOfSwaths = 7
|
|
overlapSubswaths = []
|
|
for i in range(numberOfSwaths):
|
|
overlapRatio = check_overlap(ledFilesReference[0], firstFrameImagesReference[i], ledFilesSecondary[0], firstFrameImagesSecondary[0])
|
|
if overlapRatio > 1.0 / 4.0:
|
|
overlapSubswaths.append(i+1)
|
|
if overlapSubswaths == []:
|
|
raise Exception('There is no overlap area between the ScanSAR-stripmap pair')
|
|
self.startingSwath = int(overlapSubswaths[0])
|
|
self.endingSwath = int(overlapSubswaths[-1])
|
|
|
|
#save the valid frames and swaths for future processing
|
|
self._insar.referenceFrames = self.referenceFrames
|
|
self._insar.secondaryFrames = self.secondaryFrames
|
|
self._insar.startingSwath = self.startingSwath
|
|
self._insar.endingSwath = self.endingSwath
|
|
|
|
|
|
##################################################
|
|
#1. create directories and read data
|
|
##################################################
|
|
self.reference.configure()
|
|
self.secondary.configure()
|
|
self.reference.track.configure()
|
|
self.secondary.track.configure()
|
|
for i, (referenceFrame, secondaryFrame) in enumerate(zip(self._insar.referenceFrames, self._insar.secondaryFrames)):
|
|
#frame number starts with 1
|
|
frameDir = 'f{}_{}'.format(i+1, referenceFrame)
|
|
os.makedirs(frameDir, exist_ok=True)
|
|
os.chdir(frameDir)
|
|
|
|
#attach a frame to reference and secondary
|
|
frameObjReference = MultiMode.createFrame()
|
|
frameObjSecondary = MultiMode.createFrame()
|
|
frameObjReference.configure()
|
|
frameObjSecondary.configure()
|
|
self.reference.track.frames.append(frameObjReference)
|
|
self.secondary.track.frames.append(frameObjSecondary)
|
|
|
|
#swath number starts with 1
|
|
for j in range(self._insar.startingSwath, self._insar.endingSwath+1):
|
|
print('processing frame {} swath {}'.format(referenceFrame, j))
|
|
|
|
swathDir = 's{}'.format(j)
|
|
os.makedirs(swathDir, exist_ok=True)
|
|
os.chdir(swathDir)
|
|
|
|
#attach a swath to reference and secondary
|
|
swathObjReference = MultiMode.createSwath()
|
|
swathObjSecondary = MultiMode.createSwath()
|
|
swathObjReference.configure()
|
|
swathObjSecondary.configure()
|
|
self.reference.track.frames[-1].swaths.append(swathObjReference)
|
|
self.secondary.track.frames[-1].swaths.append(swathObjSecondary)
|
|
|
|
#setup reference
|
|
self.reference.leaderFile = sorted(glob.glob(os.path.join(self.referenceDir, 'LED-ALOS2*{}-*-*'.format(referenceFrame))))[0]
|
|
if referenceMode in scansarModes:
|
|
self.reference.imageFile = sorted(glob.glob(os.path.join(self.referenceDir, 'IMG-{}-ALOS2*{}-*-*-F{}'.format(self.referencePolarization.upper(), referenceFrame, j))))[0]
|
|
else:
|
|
self.reference.imageFile = sorted(glob.glob(os.path.join(self.referenceDir, 'IMG-{}-ALOS2*{}-*-*'.format(self.referencePolarization.upper(), referenceFrame))))[0]
|
|
self.reference.outputFile = self._insar.referenceSlc
|
|
self.reference.useVirtualFile = self.useVirtualFile
|
|
#read reference
|
|
(imageFDR, imageData)=self.reference.readImage()
|
|
(leaderFDR, sceneHeaderRecord, platformPositionRecord, facilityRecord)=self.reference.readLeader()
|
|
self.reference.setSwath(leaderFDR, sceneHeaderRecord, platformPositionRecord, facilityRecord, imageFDR, imageData)
|
|
self.reference.setFrame(leaderFDR, sceneHeaderRecord, platformPositionRecord, facilityRecord, imageFDR, imageData)
|
|
self.reference.setTrack(leaderFDR, sceneHeaderRecord, platformPositionRecord, facilityRecord, imageFDR, imageData)
|
|
|
|
#setup secondary
|
|
self.secondary.leaderFile = sorted(glob.glob(os.path.join(self.secondaryDir, 'LED-ALOS2*{}-*-*'.format(secondaryFrame))))[0]
|
|
if secondaryMode in scansarModes:
|
|
self.secondary.imageFile = sorted(glob.glob(os.path.join(self.secondaryDir, 'IMG-{}-ALOS2*{}-*-*-F{}'.format(self.secondaryPolarization.upper(), secondaryFrame, j))))[0]
|
|
else:
|
|
self.secondary.imageFile = sorted(glob.glob(os.path.join(self.secondaryDir, 'IMG-{}-ALOS2*{}-*-*'.format(self.secondaryPolarization.upper(), secondaryFrame))))[0]
|
|
self.secondary.outputFile = self._insar.secondarySlc
|
|
self.secondary.useVirtualFile = self.useVirtualFile
|
|
#read secondary
|
|
(imageFDR, imageData)=self.secondary.readImage()
|
|
(leaderFDR, sceneHeaderRecord, platformPositionRecord, facilityRecord)=self.secondary.readLeader()
|
|
self.secondary.setSwath(leaderFDR, sceneHeaderRecord, platformPositionRecord, facilityRecord, imageFDR, imageData)
|
|
self.secondary.setFrame(leaderFDR, sceneHeaderRecord, platformPositionRecord, facilityRecord, imageFDR, imageData)
|
|
self.secondary.setTrack(leaderFDR, sceneHeaderRecord, platformPositionRecord, facilityRecord, imageFDR, imageData)
|
|
|
|
os.chdir('../')
|
|
self._insar.saveProduct(self.reference.track.frames[-1], self._insar.referenceFrameParameter)
|
|
self._insar.saveProduct(self.secondary.track.frames[-1], self._insar.secondaryFrameParameter)
|
|
os.chdir('../')
|
|
self._insar.saveProduct(self.reference.track, self._insar.referenceTrackParameter)
|
|
self._insar.saveProduct(self.secondary.track, self._insar.secondaryTrackParameter)
|
|
|
|
|
|
##################################################
|
|
#2. compute burst synchronization
|
|
##################################################
|
|
#burst synchronization may slowly change along a track as a result of the changing relative speed of the two flights
|
|
#in one frame, real unsynchronized time is the same for all swaths
|
|
unsynTime = 0
|
|
#real synchronized time/percentage depends on the swath burst length (synTime = burstlength - abs(unsynTime))
|
|
#synTime = 0
|
|
synPercentage = 0
|
|
|
|
numberOfFrames = len(self._insar.referenceFrames)
|
|
numberOfSwaths = self._insar.endingSwath - self._insar.startingSwath + 1
|
|
|
|
for i, frameNumber in enumerate(self._insar.referenceFrames):
|
|
for j, swathNumber in enumerate(range(self._insar.startingSwath, self._insar.endingSwath + 1)):
|
|
referenceSwath = self.reference.track.frames[i].swaths[j]
|
|
secondarySwath = self.secondary.track.frames[i].swaths[j]
|
|
#using Piyush's code for computing range and azimuth offsets
|
|
midRange = referenceSwath.startingRange + referenceSwath.rangePixelSize * referenceSwath.numberOfSamples * 0.5
|
|
midSensingStart = referenceSwath.sensingStart + datetime.timedelta(seconds = referenceSwath.numberOfLines * 0.5 / referenceSwath.prf)
|
|
llh = self.reference.track.orbit.rdr2geo(midSensingStart, midRange)
|
|
slvaz, slvrng = self.secondary.track.orbit.geo2rdr(llh)
|
|
###Translate to offsets
|
|
#note that secondary range pixel size and prf might be different from reference, here we assume there is a virtual secondary with same
|
|
#range pixel size and prf
|
|
rgoff = ((slvrng - secondarySwath.startingRange) / referenceSwath.rangePixelSize) - referenceSwath.numberOfSamples * 0.5
|
|
azoff = ((slvaz - secondarySwath.sensingStart).total_seconds() * referenceSwath.prf) - referenceSwath.numberOfLines * 0.5
|
|
|
|
#compute burst synchronization
|
|
#burst parameters for ScanSAR wide mode not estimed yet
|
|
if self._insar.modeCombination == 21:
|
|
scburstStartLine = (referenceSwath.burstStartTime - referenceSwath.sensingStart).total_seconds() * referenceSwath.prf + azoff
|
|
#secondary burst start times corresponding to reference burst start times (100% synchronization)
|
|
scburstStartLines = np.arange(scburstStartLine - 100000*referenceSwath.burstCycleLength, \
|
|
scburstStartLine + 100000*referenceSwath.burstCycleLength, \
|
|
referenceSwath.burstCycleLength)
|
|
dscburstStartLines = -((secondarySwath.burstStartTime - secondarySwath.sensingStart).total_seconds() * secondarySwath.prf - scburstStartLines)
|
|
#find the difference with minimum absolute value
|
|
unsynLines = dscburstStartLines[np.argmin(np.absolute(dscburstStartLines))]
|
|
if np.absolute(unsynLines) >= secondarySwath.burstLength:
|
|
synLines = 0
|
|
if unsynLines > 0:
|
|
unsynLines = secondarySwath.burstLength
|
|
else:
|
|
unsynLines = -secondarySwath.burstLength
|
|
else:
|
|
synLines = secondarySwath.burstLength - np.absolute(unsynLines)
|
|
|
|
unsynTime += unsynLines / referenceSwath.prf
|
|
synPercentage += synLines / referenceSwath.burstLength * 100.0
|
|
|
|
catalog.addItem('burst synchronization of frame {} swath {}'.format(frameNumber, swathNumber), '%.1f%%'%(synLines / referenceSwath.burstLength * 100.0), 'runPreprocessor')
|
|
|
|
############################################################################################
|
|
#illustration of the sign of the number of unsynchronized lines (unsynLines)
|
|
#The convention is the same as ampcor offset, that is,
|
|
# secondaryLineNumber = referenceLineNumber + unsynLines
|
|
#
|
|
# |-----------------------| ------------
|
|
# | | ^
|
|
# | | |
|
|
# | | | unsynLines < 0
|
|
# | | |
|
|
# | | \ /
|
|
# | | |-----------------------|
|
|
# | | | |
|
|
# | | | |
|
|
# |-----------------------| | |
|
|
# Reference Burst | |
|
|
# | |
|
|
# | |
|
|
# | |
|
|
# | |
|
|
# |-----------------------|
|
|
# Secondary Burst
|
|
#
|
|
#
|
|
############################################################################################
|
|
|
|
##burst parameters for ScanSAR wide mode not estimed yet
|
|
elif self._insar.modeCombination == 31:
|
|
#scansar is reference
|
|
scburstStartLine = (referenceSwath.burstStartTime - referenceSwath.sensingStart).total_seconds() * referenceSwath.prf + azoff
|
|
#secondary burst start times corresponding to reference burst start times (100% synchronization)
|
|
for k in range(-100000, 100000):
|
|
saz_burstx = scburstStartLine + referenceSwath.burstCycleLength * k
|
|
st_burstx = secondarySwath.sensingStart + datetime.timedelta(seconds=saz_burstx / referenceSwath.prf)
|
|
if saz_burstx >= 0.0 and saz_burstx <= secondarySwath.numberOfLines -1:
|
|
secondarySwath.burstStartTime = st_burstx
|
|
secondarySwath.burstLength = referenceSwath.burstLength
|
|
secondarySwath.burstCycleLength = referenceSwath.burstCycleLength
|
|
secondarySwath.swathNumber = referenceSwath.swathNumber
|
|
break
|
|
#unsynLines = 0
|
|
#synLines = referenceSwath.burstLength
|
|
#unsynTime += unsynLines / referenceSwath.prf
|
|
#synPercentage += synLines / referenceSwath.burstLength * 100.0
|
|
catalog.addItem('burst synchronization of frame {} swath {}'.format(frameNumber, swathNumber), '%.1f%%'%(100.0), 'runPreprocessor')
|
|
else:
|
|
pass
|
|
|
|
#overwrite original frame parameter file
|
|
if self._insar.modeCombination == 31:
|
|
frameDir = 'f{}_{}'.format(i+1, frameNumber)
|
|
self._insar.saveProduct(self.secondary.track.frames[i], os.path.join(frameDir, self._insar.secondaryFrameParameter))
|
|
|
|
#getting average
|
|
if self._insar.modeCombination == 21:
|
|
unsynTime /= numberOfFrames*numberOfSwaths
|
|
synPercentage /= numberOfFrames*numberOfSwaths
|
|
elif self._insar.modeCombination == 31:
|
|
unsynTime = 0.
|
|
synPercentage = 100.
|
|
else:
|
|
pass
|
|
|
|
#record results
|
|
if (self._insar.modeCombination == 21) or (self._insar.modeCombination == 31):
|
|
self._insar.burstUnsynchronizedTime = unsynTime
|
|
self._insar.burstSynchronization = synPercentage
|
|
catalog.addItem('burst synchronization averaged', '%.1f%%'%(synPercentage), 'runPreprocessor')
|
|
|
|
|
|
##################################################
|
|
#3. compute baseline
|
|
##################################################
|
|
#only compute baseline at four corners and center of the reference track
|
|
bboxRdr = getBboxRdr(self.reference.track)
|
|
|
|
rangeMin = bboxRdr[0]
|
|
rangeMax = bboxRdr[1]
|
|
azimuthTimeMin = bboxRdr[2]
|
|
azimuthTimeMax = bboxRdr[3]
|
|
|
|
azimuthTimeMid = azimuthTimeMin+datetime.timedelta(seconds=(azimuthTimeMax-azimuthTimeMin).total_seconds()/2.0)
|
|
rangeMid = (rangeMin + rangeMax) / 2.0
|
|
|
|
points = [[azimuthTimeMin, rangeMin],
|
|
[azimuthTimeMin, rangeMax],
|
|
[azimuthTimeMax, rangeMin],
|
|
[azimuthTimeMax, rangeMax],
|
|
[azimuthTimeMid, rangeMid]]
|
|
|
|
Bpar = []
|
|
Bperp = []
|
|
#modify Piyush's code for computing baslines
|
|
refElp = Planet(pname='Earth').ellipsoid
|
|
for x in points:
|
|
referenceSV = self.reference.track.orbit.interpolate(x[0], method='hermite')
|
|
target = self.reference.track.orbit.rdr2geo(x[0], x[1])
|
|
|
|
slvTime, slvrng = self.secondary.track.orbit.geo2rdr(target)
|
|
secondarySV = self.secondary.track.orbit.interpolateOrbit(slvTime, method='hermite')
|
|
|
|
targxyz = np.array(refElp.LLH(target[0], target[1], target[2]).ecef().tolist())
|
|
mxyz = np.array(referenceSV.getPosition())
|
|
mvel = np.array(referenceSV.getVelocity())
|
|
sxyz = np.array(secondarySV.getPosition())
|
|
|
|
#to fix abrupt change near zero in baseline grid. JUN-05-2020
|
|
mvelunit = mvel / np.linalg.norm(mvel)
|
|
sxyz = sxyz - np.dot ( sxyz-mxyz, mvelunit) * mvelunit
|
|
|
|
aa = np.linalg.norm(sxyz-mxyz)
|
|
costheta = (x[1]*x[1] + aa*aa - slvrng*slvrng)/(2.*x[1]*aa)
|
|
|
|
Bpar.append(aa*costheta)
|
|
|
|
perp = aa * np.sqrt(1 - costheta*costheta)
|
|
direction = np.sign(np.dot( np.cross(targxyz-mxyz, sxyz-mxyz), mvel))
|
|
Bperp.append(direction*perp)
|
|
|
|
catalog.addItem('parallel baseline at upperleft of reference track', Bpar[0], 'runPreprocessor')
|
|
catalog.addItem('parallel baseline at upperright of reference track', Bpar[1], 'runPreprocessor')
|
|
catalog.addItem('parallel baseline at lowerleft of reference track', Bpar[2], 'runPreprocessor')
|
|
catalog.addItem('parallel baseline at lowerright of reference track', Bpar[3], 'runPreprocessor')
|
|
catalog.addItem('parallel baseline at center of reference track', Bpar[4], 'runPreprocessor')
|
|
|
|
catalog.addItem('perpendicular baseline at upperleft of reference track', Bperp[0], 'runPreprocessor')
|
|
catalog.addItem('perpendicular baseline at upperright of reference track', Bperp[1], 'runPreprocessor')
|
|
catalog.addItem('perpendicular baseline at lowerleft of reference track', Bperp[2], 'runPreprocessor')
|
|
catalog.addItem('perpendicular baseline at lowerright of reference track', Bperp[3], 'runPreprocessor')
|
|
catalog.addItem('perpendicular baseline at center of reference track', Bperp[4], 'runPreprocessor')
|
|
|
|
|
|
##################################################
|
|
#4. compute bounding box
|
|
##################################################
|
|
referenceBbox = getBboxGeo(self.reference.track)
|
|
secondaryBbox = getBboxGeo(self.secondary.track)
|
|
|
|
catalog.addItem('reference bounding box', referenceBbox, 'runPreprocessor')
|
|
catalog.addItem('secondary bounding box', secondaryBbox, 'runPreprocessor')
|
|
|
|
|
|
catalog.printToLog(logger, "runPreprocessor")
|
|
self._insar.procDoc.addAllFromCatalog(catalog)
|
|
|
|
|
|
|
|
def check_overlap(ldr_m, img_m, ldr_s, img_s):
|
|
from isceobj.Constants import SPEED_OF_LIGHT
|
|
|
|
rangeSamplingRateReference, widthReference, nearRangeReference = read_param_for_checking_overlap(ldr_m, img_m)
|
|
rangeSamplingRateSecondary, widthSecondary, nearRangeSecondary = read_param_for_checking_overlap(ldr_s, img_s)
|
|
|
|
farRangeReference = nearRangeReference + (widthReference-1) * 0.5 * SPEED_OF_LIGHT / rangeSamplingRateReference
|
|
farRangeSecondary = nearRangeSecondary + (widthSecondary-1) * 0.5 * SPEED_OF_LIGHT / rangeSamplingRateSecondary
|
|
|
|
#This should be good enough, although precise image offsets are not used.
|
|
if farRangeReference <= nearRangeSecondary:
|
|
overlapRatio = 0.0
|
|
elif farRangeSecondary <= nearRangeReference:
|
|
overlapRatio = 0.0
|
|
else:
|
|
# 0 1 2 3
|
|
ranges = np.array([nearRangeReference, farRangeReference, nearRangeSecondary, farRangeSecondary])
|
|
rangesIndex = np.argsort(ranges)
|
|
overlapRatio = ranges[rangesIndex[2]]-ranges[rangesIndex[1]] / (farRangeReference-nearRangeReference)
|
|
|
|
return overlapRatio
|
|
|
|
|
|
def read_param_for_checking_overlap(leader_file, image_file):
|
|
from isceobj.Sensor import xmlPrefix
|
|
import isceobj.Sensor.CEOS as CEOS
|
|
|
|
#read from leader file
|
|
fsampConst = { 104: 1.047915957140240E+08,
|
|
52: 5.239579785701190E+07,
|
|
34: 3.493053190467460E+07,
|
|
17: 1.746526595233730E+07 }
|
|
|
|
fp = open(leader_file,'rb')
|
|
leaderFDR = CEOS.CEOSDB(xml=os.path.join(xmlPrefix,'alos2_slc/leader_file.xml'),dataFile=fp)
|
|
leaderFDR.parse()
|
|
fp.seek(leaderFDR.getEndOfRecordPosition())
|
|
sceneHeaderRecord = CEOS.CEOSDB(xml=os.path.join(xmlPrefix,'alos2_slc/scene_record.xml'),dataFile=fp)
|
|
sceneHeaderRecord.parse()
|
|
fp.seek(sceneHeaderRecord.getEndOfRecordPosition())
|
|
|
|
fsamplookup = int(sceneHeaderRecord.metadata['Range sampling rate in MHz'])
|
|
rangeSamplingRate = fsampConst[fsamplookup]
|
|
fp.close()
|
|
#print('{}'.format(rangeSamplingRate))
|
|
|
|
#read from image file
|
|
fp = open(image_file, 'rb')
|
|
imageFDR = CEOS.CEOSDB(xml=os.path.join(xmlPrefix,'alos2_slc/image_file.xml'), dataFile=fp)
|
|
imageFDR.parse()
|
|
fp.seek(imageFDR.getEndOfRecordPosition())
|
|
imageData = CEOS.CEOSDB(xml=os.path.join(xmlPrefix,'alos2_slc/image_record.xml'), dataFile=fp)
|
|
imageData.parseFast()
|
|
|
|
width = imageFDR.metadata['Number of pixels per line per SAR channel']
|
|
near_range = imageData.metadata['Slant range to 1st data sample']
|
|
fp.close()
|
|
#print('{}'.format(width))
|
|
#print('{}'.format(near_range))
|
|
|
|
return (rangeSamplingRate, width, near_range)
|
|
|
|
|