def extract_tops_metadata(xml_file): """Read metadata from xml file for Sentinel-1/TOPS Parameters: xml_file : str, path of the .xml file, i.e. master/IW1.xml Returns: meta : dict, metadata """ import isce from isceobj.Planet.Planet import Planet obj = load_product(xml_file) burst = obj.bursts[0] burstEnd = obj.bursts[-1] metadata = {} metadata['prf'] = burst.prf metadata['startUTC'] = burst.burstStartUTC metadata['stopUTC'] = burstEnd.burstStopUTC metadata['radarWavelength'] = burst.radarWavelength metadata['rangePixelSize'] = burst.rangePixelSize metadata['startingRange'] = burst.startingRange metadata['passDirection'] = burst.passDirection metadata['polarization'] = burst.polarization metadata['trackNumber'] = burst.trackNumber metadata['orbitNumber'] = burst.orbitNumber time_seconds = (burst.burstStartUTC.hour * 3600.0 + burst.burstStartUTC.minute * 60.0 + burst.burstStartUTC.second) metadata['CENTER_LINE_UTC'] = time_seconds orbit = burst.orbit peg = orbit.interpolateOrbit(burst.sensingMid, method='hermite') Vs = np.linalg.norm(peg.getVelocity()) metadata['satelliteSpeed'] = Vs metadata['azimuthPixelSize'] = Vs*burst.azimuthTimeInterval refElp = Planet(pname='Earth').ellipsoid llh = refElp.xyz_to_llh(peg.getPosition()) refElp.setSCH(llh[0], llh[1], orbit.getENUHeading(burst.sensingMid)) metadata['earthRadius'] = refElp.pegRadCur metadata['altitude'] = llh[2] # for Sentinel-1 metadata['beam_mode'] = 'IW' metadata['swathNumber'] = burst.swathNumber # 1. multipel subswaths xml_files = glob.glob(os.path.join(os.path.dirname(xml_file), 'IW*.xml')) if len(xml_files) > 1: swath_num = [load_product(fname).bursts[0].swathNumber for fname in xml_files] metadata['swathNumber'] = ''.join(str(i) for i in sorted(swath_num)) # 2. calculate ASF frame number for Sentinel-1 metadata['firstFrameNumber'] = int(0.2 * (burst.burstStartUTC - obj.ascendingNodeTime).total_seconds()) metadata['lastFrameNumber'] = int(0.2 * (burstEnd.burstStopUTC - obj.ascendingNodeTime).total_seconds()) return metadata
def extract_stripmap_metadata(meta_file): """Read metadata from shelve file for StripMap stack from ISCE Parameters: meta_file : str, path of the shelve file, i.e. masterShelve/data.dat Returns: meta : dict, metadata """ import isce import isceobj import isceobj.StripmapProc.StripmapProc as St from isceobj.Planet.Planet import Planet if os.path.basename(meta_file) == "data.dat": #shelve file from stripmapStack fbase = os.path.splitext(meta_file)[0] with shelve.open(fbase, flag='r') as mdb: frame = mdb['frame'] elif meta_file.endswith(".xml"): #XML file from stripmapApp frame = load_product(meta_file) metadata = {} metadata['prf'] = frame.PRF metadata['startUTC'] = frame.sensingStart metadata['stopUTC'] = frame.sensingStop metadata['radarWavelength'] = frame.radarWavelegth metadata['rangePixelSize'] = frame.instrument.rangePixelSize metadata['startingRange'] = frame.startingRange metadata['polarization'] = frame.polarization.replace('/', '') if metadata['polarization'].startswith("b'"): metadata['polarization'] = metadata['polarization'][2:4] metadata['trackNumber'] = frame.trackNumber metadata['orbitNumber'] = frame.orbitNumber time_seconds = (frame.sensingStart.hour*3600.0 + frame.sensingStart.minute*60.0 + frame.sensingStart.second) metadata['CENTER_LINE_UTC'] = time_seconds orbit = frame.orbit peg = orbit.interpolateOrbit(frame.sensingMid, method='hermite') Vs = np.linalg.norm(peg.getVelocity()) metadata['satelliteSpeed'] = Vs metadata['azimuthPixelSize'] = Vs/frame.PRF refElp = Planet(pname='Earth').ellipsoid llh = refElp.xyz_to_llh(peg.getPosition()) refElp.setSCH(llh[0], llh[1], orbit.getENUHeading(frame.sensingMid)) metadata['earthRadius'] = refElp.pegRadCur metadata['altitude'] = llh[2] # for StripMap metadata['beam_mode'] = 'SM' return metadata
def _populatePlatform(self, **kwargs): platform = self.frame.getInstrument().getPlatform() platform.setMission('UAVSAR') platform.setPointingDirection( self.lookMap[self.metadata['Look Direction'].upper()]) platform.setPlanet(Planet(pname="Earth")) platform.setAntennaLength(self.metadata['Antenna Length']) return
def _populatePlatform(self): """Populate the platform object with metadata""" platform = self.frame.getInstrument().getPlatform() platform.setMission("ERS" + str(self._imageFileData['PRODUCT'][61])) platform.setAntennaLength(self.constants['antennaLength']) platform.setPointingDirection(-1) platform.setPlanet(Planet(pname='Earth'))
def _populatePlatform(self): platform = self.frame.getInstrument().getPlatform() platform.setMission(self.leaderFile.sceneHeaderRecord.metadata[ 'Sensor platform mission identifier']) platform.setPointingDirection(self.constants.pointing_direction) platform.setAntennaLength(self.constants.antenna_length) platform.setPlanet(Planet(pname='Earth'))
def runTopoCPU(info, demImage, dop=None, nativedop=False, legendre=False): from zerodop.topozero import createTopozero from isceobj.Planet.Planet import Planet if not os.path.isdir(info.outdir): os.makedirs(info.outdir) #####Run Topo planet = Planet(pname='Earth') topo = createTopozero() topo.slantRangePixelSpacing = info.slantRangePixelSpacing topo.prf = info.prf topo.radarWavelength = info.radarWavelength topo.orbit = info.orbit topo.width = info.width // info.numberRangeLooks topo.length = info.length // info.numberAzimuthLooks topo.wireInputPort(name='dem', object=demImage) topo.wireInputPort(name='planet', object=planet) topo.numberRangeLooks = info.numberRangeLooks topo.numberAzimuthLooks = info.numberAzimuthLooks topo.lookSide = info.lookSide topo.sensingStart = info.sensingStart + datetime.timedelta(seconds=( (info.numberAzimuthLooks - 1) / 2) / info.prf) topo.rangeFirstSample = info.rangeFirstSample + ( (info.numberRangeLooks - 1) / 2) * info.slantRangePixelSpacing topo.demInterpolationMethod = 'BIQUINTIC' if legendre: topo.orbitInterpolationMethod = 'LEGENDRE' topo.latFilename = info.latFilename topo.lonFilename = info.lonFilename topo.losFilename = info.losFilename topo.heightFilename = info.heightFilename topo.incFilename = info.incFilename topo.maskFilename = info.maskFilename if nativedop and (dop is not None): try: coeffs = dop._coeffs except: coeffs = dop doppler = Poly2D() doppler.setWidth(info.width // info.numberRangeLooks) doppler.setLength(info.length // info.numberAzimuthLooks) doppler.initPoly(rangeOrder=len(coeffs) - 1, azimuthOrder=0, coeffs=[coeffs]) else: print('Zero doppler') doppler = None topo.polyDoppler = doppler topo.topo() return
def _populatePlatform(self): mdict = self.constants platform = self.frame.getInstrument().getPlatform() platform.setMission(mdict['PLATFORM']) platform.setPlanet(Planet(pname="Earth")) platform.setPointingDirection(int(mdict['ANTENNA_SIDE'])) platform.setAntennaLength(float(mdict['ANTENNA_LENGTH']))
def _populatePlatform(self): """Populate the platform object with metadata""" platform = self.frame.getInstrument().getPlatform() # Populate the Platform and Scene objects platform.setMission("Envisat") platform.setPointingDirection(-1) platform.setAntennaLength(self.constants['antennaLength']) platform.setPlanet(Planet(pname="Earth"))
def runGeo2rdrCPU(info, latImage, lonImage, demImage, outdir, dop=None, nativedop=False, legendre=False, azoff=0.0, rgoff=0.0, alks=1, rlks=1): from zerodop.geo2rdr import createGeo2rdr from isceobj.Planet.Planet import Planet #####Run Geo2rdr planet = Planet(pname='Earth') grdr = createGeo2rdr() grdr.configure() grdr.slantRangePixelSpacing = info.getInstrument().getRangePixelSize() grdr.prf = info.getInstrument().getPulseRepetitionFrequency() grdr.radarWavelength = info.getInstrument().getRadarWavelength() grdr.orbit = info.getOrbit() grdr.width = info.getImage().getWidth() grdr.length = info.getImage().getLength() grdr.wireInputPort(name='planet', object=planet) grdr.lookSide = info.instrument.platform.pointingDirection print(info.sensingStart - datetime.timedelta(seconds = (azoff-(alks-1)/2)/grdr.prf)) print(grdr.prf) print(info.getStartingRange() - (rgoff - (rlks-1)/2)*grdr.slantRangePixelSpacing) #print(stop) grdr.setSensingStart(info.sensingStart - datetime.timedelta(seconds = (azoff-(alks-1)/2)/grdr.prf)) grdr.rangeFirstSample = info.getStartingRange() - (rgoff - (rlks-1)/2)*grdr.slantRangePixelSpacing grdr.numberRangeLooks = alks grdr.numberAzimuthLooks = rlks if nativedop and (dop is not None): try: coeffs = [x/grdr.prf for x in dop._coeffs] except: coeffs = [x/grdr.prf for x in dop] grdr.dopplerCentroidCoeffs = coeffs else: print('Zero doppler') grdr.dopplerCentroidCoeffs = [0.] ##### grdr.fmrateCoeffs = [0.] # DOES NOT LOOK to be defined grdr.rangeOffsetImageName = os.path.join(outdir, 'range.off') grdr.azimuthOffsetImageName= os.path.join(outdir, 'azimuth.off') grdr.demImage = demImage grdr.latImage = latImage grdr.lonImage = lonImage grdr.outputPrecision = 'DOUBLE' if legendre: grdr.orbitInterpolationMethod = 'LEGENDRE' grdr.geo2rdr() return
def _populatePlatform(self): """Populate the platform object with metadata""" platform = self.frame.getInstrument().getPlatform() # Populate the Platform and Scene objects platform.setMission(self._xmlFileParser.sensorName) platform.setPointingDirection(self.lookMap[self._xmlFileParser.sideLooking]) platform.setAntennaLength(9.968) platform.setPlanet(Planet(pname="Earth"))
def runGeo(frame, demImage, inImage, looks=(1, 1), doppler=None, nativedop=False, bbox=None, method='nearest'): from zerodop.geozero import createGeozero from isceobj.Planet.Planet import Planet #####Run Topo planet = Planet(pname='Earth') topo = createGeozero() topo.configure() alooks = looks[0] rlooks = looks[1] tStart = frame.sensingStart topo.slantRangePixelSpacing = frame.getInstrument().getRangePixelSize() topo.prf = frame.getInstrument().getPulseRepetitionFrequency() topo.radarWavelength = frame.getInstrument().getRadarWavelength() topo.orbit = frame.orbit topo.width = inImage.getWidth() topo.length = inImage.getLength() topo.wireInputPort(name='dem', object=demImage) topo.wireInputPort(name='planet', object=planet) topo.wireInputPort(name='tobegeocoded', object=inImage) topo.numberRangeLooks = rlooks topo.numberAzimuthLooks = alooks topo.lookSide = frame.instrument.platform.pointingDirection() topo.setSensingStart(tStart) topo.rangeFirstSample = frame.startingRange topo.method = method topo.demCropFilename = 'crop.dem' topo.geoFilename = inImage.filename + '.geo' if inps.nativedop and (doppler is not None): try: topo.dopplerCentroidCoeffs = [ x / topo.prf for x in doppler._coeffs ] except: topo.dopplerCentroidCoeffs = [x / topo.prf for x in doppler] else: topo.dopplerCentroidCoeffs = [0.] topo.snwe = bbox topo.geocode() print('South: ', topo.minimumGeoLatitude) print('North: ', topo.maximumGeoLatitude) print('West: ', topo.minimumGeoLongitude) print('East: ', topo.maximumGeoLongitude) return
def _populatePlatform(self, **kwargs): # print("UAVSAR_RPI._populatePlatform") platform = self.frame.getInstrument().getPlatform() platform.setMission('UAVSAR') platform.setPointingDirection( self.lookMap[self.metadata['Radar Look Direction'].upper()]) platform.setPlanet(Planet(pname="Earth")) platform.setAntennaLength(1.5) # Thierry Michel return
def setUp(self): # These are the state vectors for ERS-1 track 113 frame 2745 from 1993 01 09 near the scene start time self.pos = [-2503782.263, -4652987.799, 4829281.081] self.vel = [-4002.34200000018, -3450.91900000069, -5392.36600000039] self.range = 831929.866545593 self.squint = 0.298143953340833 planet = Planet(pname='Earth') self.geolocate = Geolocate() self.geolocate.wireInputPort(name='planet', object=planet)
def extractIsceMetadata(shelveFile): with shelve.open(shelveFile, flag='r') as mdb: burst = mdb['frame'] #reference = ut.loadProduct(shelveFile) #burst = reference.bursts[0] #burstEnd = reference.bursts[-1] metadata = {} metadata['radarWavelength'] = burst.radarWavelegth metadata['rangePixelSize'] = burst.instrument.rangePixelSize metadata['prf'] = burst.PRF metadata['startUTC'] = burst.sensingStart metadata['stopUTC'] = burst.sensingStop metadata['startingRange'] = burst.startingRange time_seconds = burst.sensingStart.hour * 3600.0 + burst.sensingStart.minute * 60.0 + burst.sensingStart.second metadata['CENTER_LINE_UTC'] = time_seconds Vs = np.linalg.norm( burst.orbit.interpolateOrbit(burst.sensingMid, method='hermite').getVelocity()) metadata['satelliteSpeed'] = Vs metadata['azimuthTimeInterval'] = 1. / burst.PRF #azimuthTimeInterval metadata['azimuthPixelSize'] = Vs * metadata[ 'azimuthTimeInterval'] #burst.azimuthTimeInterval #metadata['azimuthPixelSize'] = burst.instrument.azimuthPixelSize tstart = burst.sensingStart tend = burst.sensingStop tmid = tstart + 0.5 * (tend - tstart) orbit = burst.orbit peg = orbit.interpolateOrbit(tmid, method='hermite') refElp = Planet(pname='Earth').ellipsoid llh = refElp.xyz_to_llh(peg.getPosition()) hdg = orbit.getENUHeading(tmid) refElp.setSCH(llh[0], llh[1], hdg) metadata['earthRadius'] = refElp.pegRadCur metadata['altitude'] = llh[2] return metadata
def runGeo2rdr(info, rdict, misreg_az=0.0, misreg_rg=0.0, virtual=False): from zerodop.geo2rdr import createGeo2rdr from isceobj.Planet.Planet import Planet latImage = isceobj.createImage() latImage.load(rdict['lat'] + '.xml') latImage.setAccessMode('READ') latImage.createImage() lonImage = isceobj.createImage() lonImage.load(rdict['lon'] + '.xml') lonImage.setAccessMode('READ') lonImage.createImage() demImage = isceobj.createImage() demImage.load(rdict['hgt'] + '.xml') demImage.setAccessMode('READ') demImage.createImage() delta = datetime.timedelta(seconds=misreg_az) logger.info('Additional time offset applied in geo2rdr: {0} secs'.format( misreg_az)) logger.info( 'Additional range offset applied in geo2rdr: {0} m'.format(misreg_rg)) #####Run Geo2rdr planet = Planet(pname='Earth') grdr = createGeo2rdr() grdr.configure() grdr.slantRangePixelSpacing = info.rangePixelSize grdr.prf = 1.0 / info.azimuthTimeInterval grdr.radarWavelength = info.radarWavelength grdr.orbit = info.orbit grdr.width = info.numberOfSamples grdr.length = info.numberOfLines grdr.demLength = demImage.getLength() grdr.demWidth = demImage.getWidth() grdr.wireInputPort(name='planet', object=planet) grdr.numberRangeLooks = 1 grdr.numberAzimuthLooks = 1 grdr.lookSide = -1 grdr.setSensingStart(info.sensingStart - delta) grdr.rangeFirstSample = info.startingRange - misreg_rg grdr.dopplerCentroidCoeffs = [0.] ###Zero doppler grdr.rangeOffsetImageName = rdict['rangeOffName'] grdr.azimuthOffsetImageName = rdict['azOffName'] grdr.demImage = demImage grdr.latImage = latImage grdr.lonImage = lonImage grdr.geo2rdr() return
def runGeo(frame, demImage, inImage, bbox, rlks, alks, method, outputName, aff, topShift, leftShift): from zerodop.geozero import createGeozero from isceobj.Planet.Planet import Planet #####Run Topo planet = Planet(pname='Earth') topo = createGeozero() topo.configure() topo.slantRangePixelSpacing = 0.5 * SPEED_OF_LIGHT / frame.rangeSamplingRate topo.prf = frame.PRF #should be changed to reciprocal of azimuth time interval for burst mode!!! topo.radarWavelength = frame.radarWavelegth topo.orbit = frame.getOrbit() topo.width = frame.getNumberOfSamples() topo.length = frame.getNumberOfLines() topo.wireInputPort(name='dem', object=demImage) topo.wireInputPort(name='planet', object=planet) topo.wireInputPort(name='tobegeocoded', object=inImage) topo.numberRangeLooks = rlks topo.numberAzimuthLooks = alks #topo.lookSide = -1 topo.lookSide = frame.getInstrument().getPlatform().pointingDirection topo.setSensingStart(frame.getSensingStart()) topo.rangeFirstSample = frame.startingRange topo.method = method topo.demCropFilename = 'crop.dem' topo.geoFilename = outputName topo.dopplerCentroidCoeffs = [0.] topo.snwe = bbox ############## topo.ATCa = aff.a topo.ATCb = aff.b topo.ATCc = aff.c topo.ATCd = aff.d topo.ATCe = aff.e topo.ATCf = aff.f topo.ATCrlks = aff.rlks topo.ATCalks = aff.alks ############## ##consider the shifts topo.rangeFirstSample += leftShift * topo.slantRangePixelSpacing topo.setSensingStart(frame.getSensingStart() + datetime.timedelta(seconds=(topShift / topo.prf))) topo.geocode() print('South: ', topo.minimumGeoLatitude) print('North: ', topo.maximumGeoLatitude) print('West: ', topo.minimumGeoLongitude) print('East: ', topo.maximumGeoLongitude) return
def geocode(track, demFile, inputFile, bbox, numberRangeLooks, numberAzimuthLooks, interpMethod, topShift, leftShift, addMultilookOffset=True): import datetime from zerodop.geozero import createGeozero from isceobj.Planet.Planet import Planet pointingDirection = {'right': -1, 'left' :1} demImage = isceobj.createDemImage() demImage.load(demFile + '.xml') demImage.setAccessMode('read') inImage = isceobj.createImage() inImage.load(inputFile + '.xml') inImage.setAccessMode('read') planet = Planet(pname='Earth') topo = createGeozero() topo.configure() topo.slantRangePixelSpacing = numberRangeLooks * track.rangePixelSize topo.prf = 1.0 / (numberAzimuthLooks*track.azimuthLineInterval) topo.radarWavelength = track.radarWavelength topo.orbit = track.orbit topo.width = inImage.width topo.length = inImage.length topo.wireInputPort(name='dem', object=demImage) topo.wireInputPort(name='planet', object=planet) topo.wireInputPort(name='tobegeocoded', object=inImage) topo.numberRangeLooks = 1 topo.numberAzimuthLooks = 1 topo.lookSide = pointingDirection[track.pointingDirection] sensingStart = track.sensingStart + datetime.timedelta(seconds=topShift*track.azimuthLineInterval) rangeFirstSample = track.startingRange + leftShift * track.rangePixelSize if addMultilookOffset: sensingStart += datetime.timedelta(seconds=(numberAzimuthLooks-1.0)/2.0*track.azimuthLineInterval) rangeFirstSample += (numberRangeLooks-1.0)/2.0*track.rangePixelSize topo.setSensingStart(sensingStart) topo.rangeFirstSample = rangeFirstSample topo.method=interpMethod topo.demCropFilename = 'crop.dem' #looks like this does not work #topo.geoFilename = outputName topo.dopplerCentroidCoeffs = [0.] #snwe list <class 'list'> topo.snwe = bbox topo.geocode() print('South: ', topo.minimumGeoLatitude) print('North: ', topo.maximumGeoLatitude) print('West: ', topo.minimumGeoLongitude) print('East: ', topo.maximumGeoLongitude) return
def _populatePlatform(self): """ Populate the platform object with metadata """ platform = self.frame.getInstrument().getPlatform() platform.setMission(self.leaderFile.sceneHeaderRecord.metadata[ 'Sensor platform mission identifier']) platform.setAntennaLength(self.constants['antennaLength']) platform.setPointingDirection(-1) platform.setPlanet(Planet('Earth'))
def __init__(self, name='', num=None, order=None, planet=None): super(OrbitExtender,self).__init__(family=self.__class__.family, name=name) if num is not None: self._newPoints = int(num) if order is not None: self._polyOrder = int(order) if planet is not None: self._planet = planet else: self._planet = Planet('Earth')
def geo2RdrCPU(secondaryTrack, numberRangeLooks, numberAzimuthLooks, latFile, lonFile, hgtFile, rangeOffsetFile, azimuthOffsetFile): import datetime from zerodop.geo2rdr import createGeo2rdr from isceobj.Planet.Planet import Planet pointingDirection = {'right': -1, 'left': 1} latImage = isceobj.createImage() latImage.load(latFile + '.xml') latImage.setAccessMode('read') lonImage = isceobj.createImage() lonImage.load(lonFile + '.xml') lonImage.setAccessMode('read') demImage = isceobj.createDemImage() demImage.load(hgtFile + '.xml') demImage.setAccessMode('read') planet = Planet(pname='Earth') topo = createGeo2rdr() topo.configure() #set parameters topo.slantRangePixelSpacing = numberRangeLooks * secondaryTrack.rangePixelSize topo.prf = 1.0 / (numberAzimuthLooks * secondaryTrack.azimuthLineInterval) topo.radarWavelength = secondaryTrack.radarWavelength topo.orbit = secondaryTrack.orbit topo.width = secondaryTrack.numberOfSamples topo.length = secondaryTrack.numberOfLines topo.demLength = demImage.length topo.demWidth = demImage.width topo.wireInputPort(name='planet', object=planet) topo.numberRangeLooks = 1 # topo.numberAzimuthLooks = 1 # must be set to be 1 topo.lookSide = pointingDirection[secondaryTrack.pointingDirection] topo.setSensingStart(secondaryTrack.sensingStart + datetime.timedelta( seconds=(numberAzimuthLooks - 1.0) / 2.0 * secondaryTrack.azimuthLineInterval)) topo.rangeFirstSample = secondaryTrack.startingRange + ( numberRangeLooks - 1.0) / 2.0 * secondaryTrack.rangePixelSize topo.dopplerCentroidCoeffs = [0.] # we are using zero doppler geometry #set files topo.latImage = latImage topo.lonImage = lonImage topo.demImage = demImage topo.rangeOffsetImageName = rangeOffsetFile topo.azimuthOffsetImageName = azimuthOffsetFile #run it topo.geo2rdr() return
def testConvertSCHdot(self): elp = Planet("Earth").get_elp() elp.setSCH(66.0, -105.0, 36.0) #From for_ellipsoid_test.F #convert_schdot_to_xyzdot, sch_to_xyz r_sch = [1468.0, -234.0, 7000.0] r_schdot = [800.0, -400.0, 100.0] r_xyz = [-672788.46258740244, -2514950.4839521507, 5810769.7976823179] r_xyzdot = [853.73728655948685, 118.98447071885982, 258.79594191185748] posXYZ, velXYZ = elp.schdot_to_xyzdot(r_sch, r_schdot) for (a, b) in zip(r_xyz, posXYZ): self.assertAlmostEqual(a, b, places=3) for (a, b) in zip(r_xyzdot, velXYZ): self.assertAlmostEqual(a, b, places=3) #convert_schdot_to_xyzdot, xyz_to_sch r_xyz = [-672100.0, -2514000.0, 5811000.0] r_xyzdot = [800.0, -400.0, 100.0] r_sch = [2599.1237664792707, 70.396218844576666, 6764.7576835183427] r_schdot = [ 415.39842327248573, -781.28909619852459, 164.41258499283407 ] posSCH, velSCH = elp.xyzdot_to_schdot(r_xyz, r_xyzdot) for (a, b) in zip(r_sch, posSCH): self.assertAlmostEqual(a, b, places=3) for (a, b) in zip(r_schdot, velSCH): self.assertAlmostEqual(a, b, delta=0.1)
def extractInfo(xmlName, inps): ''' Extract required information from pickle file. ''' from isceobj.Planet.Planet import Planet from isceobj.Util.geo.ellipsoid import Ellipsoid frame = ut.loadProduct(xmlName) burst = frame.bursts[0] planet = Planet(pname='Earth') elp = Ellipsoid(planet.ellipsoid.a, planet.ellipsoid.e2, 'WGS84') data = {} data['wavelength'] = burst.radarWavelength tstart = frame.bursts[0].sensingStart tend = frame.bursts[-1].sensingStop #tmid = tstart + 0.5*(tend - tstart) tmid = tstart orbit = burst.orbit peg = orbit.interpolateOrbit(tmid, method='hermite') refElp = Planet(pname='Earth').ellipsoid llh = refElp.xyz_to_llh(peg.getPosition()) hdg = orbit.getENUHeading(tmid) refElp.setSCH(llh[0], llh[1], hdg) earthRadius = refElp.pegRadCur altitude = llh[2] #sv = burst.orbit.interpolateOrbit(tmid, method='hermite') #pos = sv.getPosition() #llh = elp.ECEF(pos[0], pos[1], pos[2]).llh() data['altitude'] = altitude #llh.hgt #hdg = burst.orbit.getHeading() data['earthRadius'] = earthRadius #elp.local_radius_of_curvature(llh.lat, hdg) #azspacing = burst.azimuthTimeInterval * sv.getScalarVelocity() #azres = 20.0 #corrfile = os.path.join(self._insar.mergedDirname, self._insar.coherenceFilename) rangeLooks = inps.rglooks azimuthLooks = inps.azlooks azfact = 0.8 rngfact = 0.8 corrLooks = rangeLooks * azimuthLooks/(azfact*rngfact) data['corrlooks'] = corrLooks #inps.rglooks * inps.azlooks * azspacing / azres data['rglooks'] = inps.rglooks data['azlooks'] = inps.azlooks return data
def extractIsceMetadata(xmlFile): master = ut.loadProduct(xmlFile) burst = master.bursts[0] burstEnd = master.bursts[-1] metadata = {} metadata['radarWavelength'] = burst.radarWavelength metadata['rangePixelSize'] = burst.rangePixelSize metadata['prf'] = burst.prf metadata['startUTC'] = burst.burstStartUTC metadata['stopUTC'] = burstEnd.burstStopUTC metadata['startingRange'] = burst.startingRange time_seconds = burst.burstStartUTC.hour * 3600.0 + burst.burstStartUTC.minute * 60.0 + burst.burstStartUTC.second metadata['CENTER_LINE_UTC'] = time_seconds Vs = np.linalg.norm( burst.orbit.interpolateOrbit(burst.sensingMid, method='hermite').getVelocity()) metadata['satelliteSpeed'] = Vs metadata['azimuthTimeInterval'] = burst.azimuthTimeInterval metadata['azimuthPixelSize'] = Vs * burst.azimuthTimeInterval tstart = burst.sensingStart tend = burstEnd.sensingStop tmid = tstart + 0.5 * (tend - tstart) orbit = burst.orbit peg = orbit.interpolateOrbit(tmid, method='hermite') refElp = Planet(pname='Earth').ellipsoid llh = refElp.xyz_to_llh(peg.getPosition()) hdg = orbit.getENUHeading(tmid) refElp.setSCH(llh[0], llh[1], hdg) metadata['earthRadius'] = refElp.pegRadCur metadata['altitude'] = llh[2] return metadata
def create_georectified_lat_lon(swathList, reference, outdir, demZero, load_function): """ export geo rectified latitude and longitude """ for swath in swathList: reference = load_function( os.path.join(reference, 'IW{0}.xml'.format(swath))) ###Check if geometry directory already exists. dirname = os.path.join(outdir, 'IW{0}'.format(swath)) if os.path.isdir(dirname): print('Geometry directory {0} already exists.'.format(dirname)) else: os.makedirs(dirname) ###For each burst for ind in range(reference.numberOfBursts): burst = reference.bursts[ind] latname = os.path.join(dirname, 'lat_%02d.rdr' % (ind + 1)) lonname = os.path.join(dirname, 'lon_%02d.rdr' % (ind + 1)) hgtname = os.path.join(dirname, 'hgt_%02d.rdr' % (ind + 1)) losname = os.path.join(dirname, 'los_%02d.rdr' % (ind + 1)) if not (os.path.exists(latname + '.xml') or os.path.exists(lonname + '.xml')): #####Run Topo planet = Planet(pname='Earth') topo = createTopozero() topo.slantRangePixelSpacing = burst.rangePixelSize topo.prf = 1.0 / burst.azimuthTimeInterval topo.radarWavelength = burst.radarWavelength topo.orbit = burst.orbit topo.width = burst.numberOfSamples topo.length = burst.numberOfLines topo.wireInputPort(name='dem', object=demZero) topo.wireInputPort(name='planet', object=planet) topo.numberRangeLooks = 1 topo.numberAzimuthLooks = 1 topo.lookSide = -1 topo.sensingStart = burst.sensingStart topo.rangeFirstSample = burst.startingRange topo.demInterpolationMethod = 'BIQUINTIC' topo.latFilename = latname topo.lonFilename = lonname topo.heightFilename = hgtname topo.losFilename = losname topo.topo() return
def _populatePlatform(self, file): platform = self.frame.getInstrument().getPlatform() platform.setMission( file['/science/LSAR/identification'].get('missionId')[( )].decode('utf-8')) platform.setPointingDirection( self.lookMap[file['/science/LSAR/identification'].get( 'lookDirection')[()].decode('utf-8')]) platform.setPlanet(Planet(pname="Earth")) # We are not using this value anywhere. Let's fix it for now. platform.setAntennaLength(12.0)
def computeBaseline(trackReference, trackSecondary, azimuthTime, rangeDistance): import numpy as np from isceobj.Planet.Planet import Planet #modify Piyush's code for computing baslines refElp = Planet(pname='Earth').ellipsoid #for x in points: referenceSV = trackReference.orbit.interpolate(azimuthTime, method='hermite') target = trackReference.orbit.rdr2geo(azimuthTime, rangeDistance) slvTime, slvrng = trackSecondary.orbit.geo2rdr(target) secondarySV = trackSecondary.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 = (rangeDistance * rangeDistance + aa * aa - slvrng * slvrng) / (2. * rangeDistance * aa) Bpar = aa * costheta perp = aa * np.sqrt(1 - costheta * costheta) direction = np.sign(np.dot(np.cross(targxyz - mxyz, sxyz - mxyz), mvel)) Bperp = direction * perp return (Bpar, Bperp)
def topo(burst, time, Range, doppler=0, wvl=0.056): '''Function that return the lon lat information for a given time, range, and doppler''' ###Planet parameters elp = Planet(pname='Earth').ellipsoid # Provide a zero doppler polygon in case 0 is given if doppler is 0: doppler = Poly2D() doppler.initPoly(rangeOrder=1, azimuthOrder=0, coeffs=[[0, 0]]) # compute the lonlat grid latlon = burst.orbit.rdr2geo(time, Range, doppler=doppler, wvl=wvl) return latlon
def _populatePlatform(self, file): platform = self.frame.getInstrument().getPlatform() platform.setMission(file['satellite_name'][()]) platform.setPointingDirection( self.lookMap[file['look_side'][()].upper()]) platform.setPlanet(Planet(pname="Earth")) ####This is an approximation for spotlight mode ####In spotlight mode, antenna length changes with azimuth position platform.setAntennaLength(2 * file['azimuth_ground_spacing'][()]) assert (file['range_looks'][()] == 1) assert (file['azimuth_looks'][()] == 1)
class PegInfoFactory: @staticmethod def createPegInfo(band, track, dire, latS, latE, pegLat, pegLon, hdg): PI = PegInfo() PI._pegBandIndx = band PI._track = track PI._direction = dire PI._latStart = latS PI._latEnd = latE PI._peg = PegFactory.fromEllipsoid(Coordinate(pegLat, pegLon), hdg, PegInfoFactory._Planet.get_elp()) return PI _Planet = Planet(pname='Earth')
def runGeo2rdr(frame, latImage, lonImage, demImage, rgoffName='range.off', azoffName='azimuth.off', rlks=1, alks=1): from zerodop.geo2rdr import createGeo2rdr from isceobj.Planet.Planet import Planet #create topo planet = Planet(pname='Earth') topo = createGeo2rdr() topo.configure() #set parameters topo.slantRangePixelSpacing = rlks * 0.5 * SPEED_OF_LIGHT / frame.rangeSamplingRate topo.prf = frame.PRF / alks #!!!should be changed to azimuth time interval for burst mode topo.radarWavelength = frame.radarWavelegth topo.orbit = frame.getOrbit() topo.width = int(frame.getNumberOfSamples() / rlks) topo.length = int(frame.getNumberOfLines() / alks) topo.demLength = demImage.length topo.demWidth = demImage.width topo.wireInputPort(name='planet', object=planet) topo.numberRangeLooks = 1 # topo.numberAzimuthLooks = 1 # must be set to be 1 #topo.lookSide = -1 topo.lookSide = frame.getInstrument().getPlatform().pointingDirection topo.setSensingStart(frame.getSensingStart() + datetime.timedelta(seconds=(alks - 1.0) / 2.0 * (1.0 / frame.PRF))) topo.rangeFirstSample = frame.startingRange + (rlks - 1.0) / 2.0 * ( 0.5 * SPEED_OF_LIGHT / frame.rangeSamplingRate) topo.dopplerCentroidCoeffs = [0.] # we are using zero doppler geometry #set files topo.demImage = demImage topo.latImage = latImage topo.lonImage = lonImage topo.rangeOffsetImageName = rgoffName topo.azimuthOffsetImageName = azoffName #run it topo.geo2rdr() return
def _populatePlatform(self, file=None): platform = self.frame.getInstrument().getPlatform() if np.isnan(file['S01'].attrs['Equivalent First Column Time']) and ( len(file['S01/B001'].attrs['Range First Times']) > 1): raise NotImplementedError( 'Current CSK reader does not handle RAW data not adjusted for SWST shifts' ) platform.setMission( file.attrs['Satellite ID']) # Could use Mission ID as well platform.setPlanet(Planet(pname="Earth")) platform.setPointingDirection( self.lookMap[file.attrs['Look Side'].decode('utf-8')]) platform.setAntennaLength(file.attrs['Antenna Length'])
def _populatePlatform(self, file): platform = self.frame.getInstrument().getPlatform() platform.setMission(file.attrs['Satellite ID']) platform.setPointingDirection(self.lookMap[file.attrs['Look Side'].decode('utf-8')]) platform.setPlanet(Planet("Earth")) ####This is an approximation for spotlight mode ####In spotlight mode, antenna length changes with azimuth position platform.setAntennaLength(file.attrs['Antenna Length']) try: if file.attrs['Multi-Beam ID'].startswith('ES'): platform.setAntennaLength(16000.0/file['S01/SBI'].attrs['Line Time Interval']) except: pass