def setState(self):
'''
Create C object and populate.
'''
from components.contrib.geo_autoRIFT.geogrid import geogrid
from iscesys import DateTimeUtil as DTU
if self._geogrid is not None:
geogrid.destroyGeoGrid_Py(self._geogrid)
self._geogrid = geogrid.createGeoGrid_Py()
geogrid.setRadarImageDimensions_Py( self._geogrid, self.numberOfSamples, self.numberOfLines)
geogrid.setRangeParameters_Py( self._geogrid, self.startingRange, self.rangePixelSize)
geogrid.setAzimuthParameters_Py( self._geogrid, DTU.seconds_since_midnight(self.sensingStart), self.prf)
geogrid.setRepeatTime_Py(self._geogrid, self.repeatTime)
geogrid.setEPSG_Py(self._geogrid, self.epsg)
geogrid.setIncidenceAngle_Py(self._geogrid, self.incidenceAngle)
geogrid.setChipSizeX0_Py(self._geogrid, self.chipSizeX0)
geogrid.setXLimits_Py(self._geogrid, self._xlim[0], self._xlim[1])
geogrid.setYLimits_Py(self._geogrid, self._ylim[0], self._ylim[1])
if self.demname:
geogrid.setDEM_Py(self._geogrid, self.demname)
if (self.dhdxname is not None) and (self.dhdyname is not None):
geogrid.setSlopes_Py(self._geogrid, self.dhdxname, self.dhdyname)
if (self.vxname is not None) and (self.vyname is not None):
geogrid.setVelocities_Py(self._geogrid, self.vxname, self.vyname)
if (self.srxname is not None) and (self.sryname is not None):
geogrid.setSearchRange_Py(self._geogrid, self.srxname, self.sryname)
if (self.csminxname is not None) and (self.csminyname is not None):
geogrid.setChipSizeMin_Py(self._geogrid, self.csminxname, self.csminyname)
if (self.csmaxxname is not None) and (self.csmaxyname is not None):
geogrid.setChipSizeMax_Py(self._geogrid, self.csmaxxname, self.csmaxyname)
if (self.ssmname is not None):
geogrid.setStableSurfaceMask_Py(self._geogrid, self.ssmname)
geogrid.setWindowLocationsFilename_Py( self._geogrid, self.winlocname)
geogrid.setWindowOffsetsFilename_Py( self._geogrid, self.winoffname)
geogrid.setWindowSearchRangeFilename_Py( self._geogrid, self.winsrname)
geogrid.setWindowChipSizeMinFilename_Py( self._geogrid, self.wincsminname)
geogrid.setWindowChipSizeMaxFilename_Py( self._geogrid, self.wincsmaxname)
geogrid.setWindowStableSurfaceMaskFilename_Py( self._geogrid, self.winssmname)
geogrid.setRO2VXFilename_Py( self._geogrid, self.winro2vxname)
geogrid.setRO2VYFilename_Py( self._geogrid, self.winro2vyname)
geogrid.setLookSide_Py(self._geogrid, self.lookSide)
geogrid.setNodataOut_Py(self._geogrid, self.nodata_out)
self._orbit = self.orbit.exportToC()
geogrid.setOrbit_Py(self._geogrid, self._orbit)
def _legendreOrbitInterpolation(self,time):
"""Interpolate a state vector using an 8th order Legendre polynomial.
This method returns None if there are fewer than 9 state vectors in
the orbit.
@type time: datetime.datetime
@param time: the time at which to interpolate a state vector
@rtype: Orbit.StateVector
@return: the state vector at the desired time
"""
if len(self) < 9:
self.logger.error(
"Fewer than 9 state vectors present in orbit, cannot interpolate"
)
return None
seq = [4,5,3,6,2,7,1,8]
found = False
for ind in seq:
rind = 9 - ind
try:
newOrbit = self.selectStateVectors(time, 4, 5)
found = True
except LookupError as e:
pass
if found:
break
if not found:
raise Exception('Could not find state vectors before/after for interpolation')
obsTime, obsPos, obsVel, offset = newOrbit.to_tuple(
relativeTo=self.minTime
)
t = DTU.timeDeltaToSeconds(time-self.minTime)
t0 = DTU.timeDeltaToSeconds(newOrbit.minTime-self.minTime)
tn = DTU.timeDeltaToSeconds(newOrbit.maxTime-self.minTime)
ansPos = self._legendre8(t0, tn, t, obsPos)
ansVel = self._legendre8(t0, tn, t, obsVel)
return StateVector(time=time, position=ansPos, velocity=ansVel)
def formslc(self):
for item in self.inputPorts:
item()
self.computeRangeParams()
try:
self.rawImage.setCaster('read','CFLOAT')
self.rawImage.setExtraInfo()
self.rawImage.createImage()
self.rawAccessor = self.rawImage.getImagePointer()
self.slcAccessor = self.slcImage.getImagePointer()
except AttributeError:
self.logger.error("Error in accessing image pointers")
raise AttributeError
self.computePatchParams()
self.allocateArrays()
self.setState()
###New changes
cOrbit = self.inOrbit.exportToC()
formslc.setOrbit_Py(cOrbit)
formslc.setSensingStart_Py(
DTU.seconds_since_midnight(self.sensingStart)
)
####Create an empty/dummy orbit of same length as input orbit
mOrbit = copy.copy(self.inOrbit).exportToC()
formslc.setMocompOrbit_Py(mOrbit)
formslc.formslc_Py(self.rawAccessor, self.slcAccessor)
###Freeing Orbit
combinedlibmodule.freeCOrbit(cOrbit)
self.outOrbit = Orbit()
self.outOrbit.configure()
self.outOrbit.importFromC(mOrbit,
datetime.datetime.combine(self.sensingStart.date(),
datetime.time(0)
)
)
combinedlibmodule.freeCOrbit(mOrbit)
#the size of this vectors where unknown until the end of the run
posSize = formslc.getMocompPositionSize_Py()
self.dim1_mocompPosition = 2
self.dim2_mocompPosition = posSize
self.dim1_mocompIndx = posSize
self.getState()
self.deallocateArrays()
self.slcImage.finalizeImage()
self.slcImage.renderHdr()
return self.slcImage
def mocomptsx(self):
for port in self.inputPorts:
port()
try:
self.inAccessor = self.slcInImage.getImagePointer()
except AttributeError:
self.logger.error("Error in accessing image pointers")
raise AttributeError("Error in accessing image pointers")
if self.stdWriter is None:
self.createStdWriter()
self.createOutSlcImage()
self.outAccessor = self.slcOutImage.getImagePointer()
self.allocateArrays()
self.setState()
###New changes
cOrbit = self.inOrbit.exportToC()
mocompTSX.setOrbit_Py(cOrbit)
mocompTSX.setSensingStart_Py(
DTU.seconds_since_midnight(self.sensingStart)
)
####Create an empty/dummy orbit of same length as input orbit
mOrbit = copy.copy(self.inOrbit).exportToC()
mocompTSX.setMocompOrbit_Py(mOrbit)
mocompTSX.mocompTSX_Py(self.inAccessor, self.outAccessor)
###Freeing Orbit
combinedlibmodule.freeCOrbit(cOrbit)
self.outOrbit = Orbit()
self.outOrbit.configure()
self.outOrbit.importFromC(mOrbit,
datetime.datetime.combine(self.sensingStart.date(),
datetime.time(0)
)
)
combinedlibmodule.freeCOrbit(mOrbit)
self.mocompPositionSize = mocompTSX.getMocompPositionSize_Py()
self.dim1_mocompPosition = 2
self.dim2_mocompPosition = self.mocompPositionSize
self.dim1_mocompIndex = self.mocompPositionSize
self.getState()
self.deallocateArrays()
self.slcOutImage.finalizeImage()
self.slcOutImage.renderHdr()
return self.slcOutImage
def calculateHeightDt(self):
orbit = self.orbit
ellipsoid = self.ellipsoid
startTime = self.sensingStart
midTime = self.sensingMid
sv0 = orbit.interpolate(startTime)
sv1 = orbit.interpolate(midTime)
startHeight = sv0.calculateHeight(ellipsoid)
midHeight = sv1.calculateHeight(ellipsoid)
self.spacecraftHeight = startHeight
self.heightDt = ((midHeight - startHeight) /
DTU.timeDeltaToSeconds(midTime - startTime))
def exportToC(self):
from isceobj.Util import combinedlibmodule
orb = []
for sv in self._stateVectors:
tim = DTU.seconds_since_midnight(sv.getTime())
pos = sv.getPosition()
vel = sv.getVelocity()
row = [tim] + pos + vel
orb.append(row)
cOrbit = combinedlibmodule.exportOrbitToC(1, orb)
return cOrbit
def calculateHeightDt(self):
orbit = self.orbit
ellipsoid = self.ellipsoid
startTime = self.sensingStart
midTime = self.sensingMid
sv0 = orbit.interpolate(startTime)
sv1 = orbit.interpolate(midTime)
startHeight = sv0.calculateHeight(ellipsoid)
midHeight = sv1.calculateHeight(ellipsoid)
if 'uav' in self.sensor.family.lower():
self.spacecraftHeight = self.sensor.platformHeight
else:
self.spacecraftHeight = startHeight
self.heightDt = ((midHeight - startHeight) /
DTU.timeDeltaToSeconds(midTime - startTime))
def _linearOrbitInterpolation(self,time):
"""
Linearly interpolate a state vector. This method returns None if
there are fewer than 2 state vectors in the orbit.
@type time: datetime.datetime
@param time: the time at which to interpolate a state vector
@rtype: Orbit.StateVector
@return: the state vector at the desired time
"""
if len(self) < 2:
self.logger.error("Fewer than 2 state vectors present in orbit, cannot interpolate")
return None
position = [0.0 for i in range(3)]
velocity = [0.0 for i in range(3)]
newOrbit = self.selectStateVectors(time, 1, 1)
obsTime, obsPos, obsVel, offset = newOrbit.to_tuple(
relativeTo=self.minTime
)
dtime = float(DTU.timeDeltaToSeconds(time-offset))
for i in range(3):
position[i] = (obsPos[0][i] +
(obsPos[1][i]-obsPos[0][i])*
(dtime-obsTime[0])/(obsTime[1]-obsTime[0]))
velocity[i] = (obsVel[0][i] +
(obsVel[1][i]-obsVel[0][i])*
(dtime-obsTime[0])/(obsTime[1]-obsTime[0]))
"""
for sv1 in self.stateVectors:
tmp=1.0
for sv2 in self.stateVectors:
if sv1.time == sv2.time:
continue
numerator = float(DTU.timeDeltaToSeconds(sv2.time-time))
denominator = float(
DTU.timeDeltaToSeconds(sv2.time - sv1.time)
)
tmp = tmp*(numerator)/(denominator)
for i in range(3):
position[i] = position[i] + sv1.getPosition()[i]*tmp
velocity[i] = velocity[i] + sv1.getVelocity()[i]*tmp
"""
return StateVector(time=time, position=position, velocity=velocity)
def setState(self):
geo2rdr.setEllipsoidMajorSemiAxis_Py(float(self.ellipsoidMajorSemiAxis))
geo2rdr.setEllipsoidEccentricitySquared_Py(float(self.ellipsoidEccentricitySquared))
geo2rdr.setRangePixelSpacing_Py(float(self.slantRangePixelSpacing))
geo2rdr.setRangeFirstSample_Py(float(self.rangeFirstSample))
geo2rdr.setDopplerAccessor_Py(self.polyDopplerAccessor)
geo2rdr.setPRF_Py(float(self.prf))
geo2rdr.setRadarWavelength_Py(float(self.radarWavelength))
geo2rdr.setSensingStart_Py(DTU.seconds_since_midnight(self.sensingStart))
geo2rdr.setLength_Py(int(self.length))
geo2rdr.setWidth_Py(int(self.width))
geo2rdr.setNumberRangeLooks_Py(int(self.numberRangeLooks))
geo2rdr.setNumberAzimuthLooks_Py(int(self.numberAzimuthLooks))
geo2rdr.setDemWidth_Py(int(self.demWidth))
geo2rdr.setDemLength_Py(int(self.demLength))
geo2rdr.setLookSide_Py(self.lookSide)
geo2rdr.setBistaticCorrectionFlag_Py(int(self.bistaticDelayCorrectionFlag))
geo2rdr.setOrbitMethod_Py( int( self.orbitMethods[self.orbitInterpolationMethod.upper()]))
def setState(self):
topo.setNumberIterations_Py(int(self.numberIterations))
topo.setDemWidth_Py(int(self.demWidth))
topo.setDemLength_Py(int(self.demLength))
topo.setReferenceOrbit_Py(self.referenceOrbit,
self.dim1_referenceOrbit)
topo.setFirstLatitude_Py(float(self.firstLatitude))
topo.setFirstLongitude_Py(float(self.firstLongitude))
topo.setDeltaLatitude_Py(float(self.deltaLatitude))
topo.setDeltaLongitude_Py(float(self.deltaLongitude))
topo.setISMocomp_Py(int(self.isMocomp))
topo.setEllipsoidMajorSemiAxis_Py(float(self.ellipsoidMajorSemiAxis))
topo.setEllipsoidEccentricitySquared_Py(
float(self.ellipsoidEccentricitySquared))
topo.setLength_Py(int(self.length))
topo.setWidth_Py(int(self.width))
topo.setRangePixelSpacing_Py(float(self.slantRangePixelSpacing))
topo.setRangeFirstSample_Py(float(self.rangeFirstSample))
topo.setSpacecraftHeight_Py(float(self.spacecraftHeight))
topo.setPlanetLocalRadius_Py(float(self.planetLocalRadius))
topo.setBodyFixedVelocity_Py(float(self.bodyFixedVelocity))
topo.setNumberRangeLooks_Py(int(self.numberRangeLooks))
topo.setNumberAzimuthLooks_Py(int(self.numberAzimuthLooks))
topo.setPegLatitude_Py(float(self.pegLatitude))
topo.setPegLongitude_Py(float(self.pegLongitude))
topo.setPegHeading_Py(float(self.pegHeading))
topo.setPRF_Py(float(self.prf))
topo.setRadarWavelength_Py(float(self.radarWavelength))
topo.setLatitudePointer_Py(int(self.latAccessor))
topo.setLongitudePointer_Py(int(self.lonAccessor))
topo.setHeightRPointer_Py(int(self.heightRAccessor))
topo.setHeightSchPointer_Py(int(self.heightSchAccessor))
topo.setIncPointer_Py(int(self.incAccessor))
topo.setLosPointer_Py(int(self.losAccessor))
topo.setLookSide_Py(int(self.lookSide))
tstart = DTU.seconds_since_midnight(self.sensingStart) + (
self.numberAzimuthLooks - 1) / (2.0 * self.prf)
topo.setSensingStart_Py(tstart)
intpKey = self.interpolationMethods[
self.demInterpolationMethod.upper()]
topo.setMethod_Py(int(intpKey))
return None
def _populateFrame(self, polarization='HH', farRange=None):
frame = self._decodeSceneReferenceNumber(
self.leaderFile.sceneHeaderRecord.metadata['Scene reference number']
)
try:
first_line_utc = self.imageFile.start_time
last_line_utc = self.imageFile.stop_time
centerTime = DTUtil.timeDeltaToSeconds(
last_line_utc-first_line_utc
)/2.0
center_line_utc = first_line_utc + datetime.timedelta(
microseconds=int(centerTime*1e6)
)
self.frame.setSensingStart(first_line_utc)
self.frame.setSensingMid(center_line_utc)
self.frame.setSensingStop(last_line_utc)
rangePixelSize = self.frame.getInstrument().getRangePixelSize()
farRange = (
self.imageFile.startingRange +
self.imageFile.width*rangePixelSize
)
except TypeError as strerr:
self.logger.warning(strerr)
self.frame.frameNumber = frame
self.frame.setOrbitNumber(
self.leaderFile.sceneHeaderRecord.metadata['Orbit number']
)
self.frame.setStartingRange(self.imageFile.startingRange)
self.frame.setFarRange(farRange)
self.frame.setProcessingFacility(
self.leaderFile.sceneHeaderRecord.metadata[
'Processing facility identifier'])
self.frame.setProcessingSystem(
self.leaderFile.sceneHeaderRecord.metadata[
'Processing system identifier'])
self.frame.setProcessingSoftwareVersion(
self.leaderFile.sceneHeaderRecord.metadata[
'Processing version identifier'])
self.frame.setPolarization(polarization)
self.frame.setNumberOfLines(self.imageFile.length)
self.frame.setNumberOfSamples(self.imageFile.width)
def setState(self):
topozero.setNumberIterations_Py(int(self.numberIterations))
topozero.setSecondaryIterations_Py(int(self.secondaryIterations))
topozero.setThreshold_Py(float(self.threshold))
topozero.setDemWidth_Py(int(self.demWidth))
topozero.setDemLength_Py(int(self.demLength))
topozero.setFirstLatitude_Py(float(self.firstLatitude))
topozero.setFirstLongitude_Py(float(self.firstLongitude))
topozero.setDeltaLatitude_Py(float(self.deltaLatitude))
topozero.setDeltaLongitude_Py(float(self.deltaLongitude))
topozero.setEllipsoidMajorSemiAxis_Py(
float(self.ellipsoidMajorSemiAxis))
topozero.setEllipsoidEccentricitySquared_Py(
float(self.ellipsoidEccentricitySquared))
topozero.setPegHeading_Py(float(self.pegHeading))
topozero.setLength_Py(int(self.length))
topozero.setWidth_Py(int(self.width))
topozero.setRangePixelSpacing_Py(float(self.slantRangePixelSpacing))
topozero.setRangeFirstSample_Py(float(self.rangeFirstSample))
topozero.setNumberRangeLooks_Py(int(self.numberRangeLooks))
topozero.setNumberAzimuthLooks_Py(int(self.numberAzimuthLooks))
topozero.setPRF_Py(float(self.prf))
topozero.setRadarWavelength_Py(float(self.radarWavelength))
topozero.setLatitudePointer_Py(int(self.latAccessor))
topozero.setLongitudePointer_Py(int(self.lonAccessor))
topozero.setHeightPointer_Py(int(self.heightAccessor))
topozero.setLosPointer_Py(int(self.losAccessor))
topozero.setIncPointer_Py(int(self.incAccessor))
topozero.setMaskPointer_Py(int(self.maskAccessor))
topozero.setLookSide_Py(int(self.lookSide))
topozero.setSensingStart_Py(
DTU.seconds_since_midnight(self.sensingStart))
intpKey = self.interpolationMethods[
self.demInterpolationMethod.upper()]
topozero.setMethod_Py(int(intpKey))
orbitIntpKey = self.orbitInterpolationMethods[
self.orbitInterpolationMethod.upper()]
topozero.setOrbitMethod_Py(int(orbitIntpKey))
return None
def setState(self):
'''
Create C object and populate.
'''
from components.contrib.geoAutorift.geogrid import geogrid
from iscesys import DateTimeUtil as DTU
if self._geogrid is not None:
geogrid.destroyGeoGrid_Py(self._geogrid)
self._geogrid = geogrid.createGeoGrid_Py()
geogrid.setRadarImageDimensions_Py(self._geogrid, self.numberOfSamples,
self.numberOfLines)
geogrid.setRangeParameters_Py(self._geogrid, self.startingRange,
self.rangePixelSize)
geogrid.setAzimuthParameters_Py(
self._geogrid, DTU.seconds_since_midnight(self.sensingStart),
self.prf)
geogrid.setRepeatTime_Py(self._geogrid, self.repeatTime)
geogrid.setEPSG_Py(self._geogrid, self.epsg)
geogrid.setXLimits_Py(self._geogrid, self._xlim[0], self._xlim[1])
geogrid.setYLimits_Py(self._geogrid, self._ylim[0], self._ylim[1])
if self.demname:
geogrid.setDEM_Py(self._geogrid, self.demname)
if (self.dhdxname is not None) and (self.dhdyname is not None):
geogrid.setSlopes_Py(self._geogrid, self.dhdxname, self.dhdyname)
if (self.vxname is not None) and (self.vyname is not None):
geogrid.setVelocities_Py(self._geogrid, self.vxname, self.vyname)
geogrid.setWindowLocationsFilename_Py(self._geogrid, self.winlocname)
geogrid.setWindowOffsetsFilename_Py(self._geogrid, self.winoffname)
geogrid.setRO2VXFilename_Py(self._geogrid, self.winro2vxname)
geogrid.setRO2VYFilename_Py(self._geogrid, self.winro2vyname)
geogrid.setLookSide_Py(self._geogrid, self.lookSide)
self._orbit = self.orbit.exportToC()
geogrid.setOrbit_Py(self._geogrid, self._orbit)
def setState(self):
geozero.setMinimumLatitude_Py(float(self.minimumLatitude))
geozero.setMinimumLongitude_Py(float(self.minimumLongitude))
geozero.setMaximumLatitude_Py(float(self.maximumLatitude))
geozero.setMaximumLongitude_Py(float(self.maximumLongitude))
geozero.setEllipsoidMajorSemiAxis_Py(float(self.ellipsoidMajorSemiAxis))
geozero.setEllipsoidEccentricitySquared_Py(float(self.ellipsoidEccentricitySquared))
geozero.setRangePixelSpacing_Py(float(self.slantRangePixelSpacing))
geozero.setRangeFirstSample_Py(float(self.rangeFirstSample))
geozero.setDopplerAccessor_Py(self.polyDopplerAccessor)
geozero.setPRF_Py(float(self.prf))
geozero.setRadarWavelength_Py(float(self.radarWavelength))
geozero.setSensingStart_Py(DTU.seconds_since_midnight(self.sensingStart))
geozero.setFirstLatitude_Py(float(self.firstLatitude))
geozero.setFirstLongitude_Py(float(self.firstLongitude))
geozero.setDeltaLatitude_Py(float(self.deltaLatitude))
geozero.setDeltaLongitude_Py(float(self.deltaLongitude))
geozero.setLength_Py(int(self.length))
geozero.setWidth_Py(int(self.width))
geozero.setNumberRangeLooks_Py(int(self.numberRangeLooks))
geozero.setNumberAzimuthLooks_Py(int(self.numberAzimuthLooks))
geozero.setDemWidth_Py(int(self.demWidth))
geozero.setDemLength_Py(int(self.demLength))
geozero.setLookSide_Py(self.lookSide)
def _hermiteOrbitInterpolation(self,time):
"""
Interpolate a state vector using Hermite interpolation.
This method returns None if there are fewer than 4 state
vectors in the orbit.
@type time: datetime.datetime
@param time: the time at which to interpolate a state vector
@rtype: Orbit.StateVector
@return: the state vector at the desired time
"""
import os
from ctypes import c_double, cdll,byref
orbitHermite = (
cdll.LoadLibrary(os.path.dirname(__file__)+'/orbitHermite.so')
)
if len(self) < 4:
self.logger.error(
"Fewer than 4 state vectors present in orbit, cannot interpolate"
)
return None
# The Fortran routine assumes that it is getting an array of four
# state vectors
try:
newOrbit = self.selectStateVectors(time, 2, 2)
except LookupError:
try:
newOrbit = self.selectStateVectors(time,1,3)
except LookupError:
try:
newOrbit = self.selectStateVectors(time,3,1)
except LookupError:
self.logger.error("Unable to select 2 state vectors before and after "+
"chosen time %s" % (time))
return None
# For now, assume that time is an array containing the times at which
# we want to interpolate
obsTime, obsPos, obsVel,offset = newOrbit.to_tuple(
relativeTo=self.minTime
)
td = time - self.minTime
ansTime = DTU.timeDeltaToSeconds(td)
flatObsPos = [item for sublist in obsPos for item in sublist]
flatObsVel = [item for sublist in obsVel for item in sublist]
flatAnsPos= [0.,0.,0.]# list([0.0 for i in range(3)])
flatAnsVel= [0.,0.,0.]#list([0.0 for i in range(3)])
obsTime_C = (c_double*len(obsTime))(*obsTime)
obsPos_C = (c_double*len(flatObsPos))(*flatObsPos)
obsVel_C = (c_double*len(flatObsVel))(*flatObsVel)
ansTime_C = c_double(ansTime)
ansPos_C = (c_double*3)(*flatAnsPos)
ansVel_C = (c_double*3)(*flatAnsVel)
# Use the C wrapper to the fortran Hermite interpolator
orbitHermite.orbitHermite_C(obsPos_C,
obsVel_C,
obsTime_C,
byref(ansTime_C),
ansPos_C,
ansVel_C)
return StateVector(time=time, position=ansPos_C[:], velocity=ansVel_C[:])
def rdr2geo(self, aztime, rng, height=0.,
doppler = None, wvl = None,
planet=None, side=-1):
'''
Returns point on ground at given height and doppler frequency.
Never to be used for heavy duty computing.
'''
from isceobj.Planet.Planet import Planet
####Setup doppler for the equations
dopfact = 0.0
hdg = self.getENUHeading(time=aztime)
sv = self.interpolateOrbit(aztime, method='hermite')
pos = sv.getPosition()
vel = sv.getVelocity()
vmag = np.linalg.norm(vel)
if doppler is not None:
dopfact = doppler(DTU.seconds_since_midnight(aztime), rng) * 0.5 * wvl * rng/vmag
if planet is None:
refElp = Planet(pname='Earth').ellipsoid
else:
refElp = planet.ellipsoid
###Convert position and velocity to local tangent plane
satLLH = refElp.xyz_to_llh(pos)
refElp.setSCH(satLLH[0], satLLH[1], hdg)
radius = refElp.pegRadCur
#####Setup ortho normal system right below satellite
satVec = np.array(pos)
velVec = np.array(vel)
###Setup TCN basis
clat = np.cos(np.radians(satLLH[0]))
slat = np.sin(np.radians(satLLH[0]))
clon = np.cos(np.radians(satLLH[1]))
slon = np.sin(np.radians(satLLH[1]))
nhat = np.array([-clat*clon, -clat*slon, -slat])
temp = np.cross(nhat, velVec)
chat = temp / np.linalg.norm(temp)
temp = np.cross(chat, nhat)
that = temp / np.linalg.norm(temp)
vhat = velVec / np.linalg.norm(velVec)
####Solve the range doppler eqns iteratively
####Initial guess
zsch = height
for ii in range(10):
###Near nadir tests
if (satLLH[2]-zsch) >= rng:
return None
a = (satLLH[2] + radius)
b = (radius + zsch)
costheta = 0.5*(a/rng + rng/a - (b/a)*(b/rng))
sintheta = np.sqrt(1-costheta*costheta)
gamma = rng*costheta
alpha = dopfact - gamma*np.dot(nhat,vhat)/np.dot(vhat,that)
beta = -side*np.sqrt(rng*rng*sintheta*sintheta - alpha*alpha)
delta = alpha * that + beta * chat + gamma * nhat
targVec = satVec + delta
targLLH = refElp.xyz_to_llh(list(targVec))
targXYZ = refElp.llh_to_xyz([targLLH[0], targLLH[1], height])
targSCH = refElp.xyz_to_sch(targXYZ)
zsch = targSCH[2]
rdiff = rng - np.linalg.norm(np.array(satVec) - np.array(targXYZ))
return targLLH
def _populateFrameFromPair(self, sip1):
# print("UAVSAR_RPI._populateFrameFromPair: metadatafile = ",
# self.metadataFile)
#Get the Start, Mid, and Stop times
import datetime
tStart = datetime.datetime.strptime(
self.metadata['Start Time of Acquisition for Pass ' + sip1],
"%d-%b-%Y %H:%M:%S %Z")
tStop = datetime.datetime.strptime(
self.metadata['Stop Time of Acquisition for Pass ' + sip1],
"%d-%b-%Y %H:%M:%S %Z")
dtMid = DTU.timeDeltaToSeconds(tStop - tStart) / 2.
# print("dtMid = ", dtMid)
tMid = tStart + datetime.timedelta(microseconds=int(dtMid * 1e6))
# print("tStart = ", tStart)
# print("tMid = ", tMid)
# print("tStop = ", tStop)
frame = self.frame
frame.setSensingStart(tStart)
frame.setSensingStop(tStop)
frame.setSensingMid(tMid)
frame.setNumberOfLines(
int(self.metadata['Single Look Complex Data Azimuth Lines']))
frame.setNumberOfSamples(
int(self.metadata['Single Look Complex Data Range Samples']))
frame.setPolarization(self.metadata['Polarization'])
frame.C0 = self.metadata['Single Look Complex Data at Near Range']
frame.S0 = self.metadata['Single Look Complex Data Starting Azimuth']
frame.nearLookAngle = self.metadata['Average Look Angle in Near Range']
frame.farLookAngle = self.metadata['Average Look Angle in Far Range']
# print("frame.nearLookAngle = ", math.degrees(frame.nearLookAngle))
# frame.setStartingAzimuth(frame.S0)
self.extractDoppler()
frame.setStartingRange(self.startingRange)
frame.platformHeight = self.platformHeight
# print("platformHeight, startingRange = ", self.platformHeight, frame.getStartingRange())
width = frame.getNumberOfSamples()
deltaRange = frame.instrument.getRangePixelSize()
nearRange = frame.getStartingRange()
midRange = nearRange + (width / 2.) * deltaRange
frame.setFarRange(nearRange + width * deltaRange)
frame.peg = self.peg
# print("frame.peg = ", frame.peg)
frame.procVelocity = self.velocity
# print("frame.procVelocity = ", frame.procVelocity)
from isceobj.Location.Coordinate import Coordinate
frame.terrainHeight = self.terrainHeight
frame.upperLeftCorner = Coordinate()
frame.upperLeftCorner.setLatitude(
math.degrees(self.metadata['Approximate Upper Left Latitude']))
frame.upperLeftCorner.setLongitude(
math.degrees(self.metadata['Approximate Upper Left Longitude']))
frame.upperLeftCorner.setHeight(self.terrainHeight)
frame.upperRightCorner = Coordinate()
frame.upperRightCorner.setLatitude(
math.degrees(self.metadata['Approximate Upper Right Latitude']))
frame.upperRightCorner.setLongitude(
math.degrees(self.metadata['Approximate Upper Right Longitude']))
frame.upperRightCorner.setHeight(self.terrainHeight)
frame.lowerRightCorner = Coordinate()
frame.lowerRightCorner.setLatitude(
math.degrees(self.metadata['Approximate Lower Right Latitude']))
frame.lowerRightCorner.setLongitude(
math.degrees(self.metadata['Approximate Lower Right Longitude']))
frame.lowerRightCorner.setHeight(self.terrainHeight)
frame.lowerLeftCorner = Coordinate()
frame.lowerLeftCorner.setLatitude(
math.degrees(self.metadata['Approximate Lower Left Latitude']))
frame.lowerLeftCorner.setLongitude(
math.degrees(self.metadata['Approximate Lower Left Longitude']))
frame.lowerLeftCorner.setHeight(self.terrainHeight)
frame.nearLookAngle = math.degrees(
self.metadata['Average Look Angle in Near Range'])
frame.farLookAngle = math.degrees(
self.metadata['Average Look Angle in Far Range'])
return
def _populateFrame(self):
#Get the Start, Mid, and Stop times
import datetime
tStart = datetime.datetime.strptime(
self.metadata['Start Time of Acquisition'], "%d-%b-%Y %H:%M:%S %Z")
tStop = datetime.datetime.strptime(
self.metadata['Stop Time of Acquisition'], "%d-%b-%Y %H:%M:%S %Z")
dtMid = DTU.timeDeltaToSeconds(tStop - tStart) / 2.
tMid = tStart + datetime.timedelta(microseconds=int(dtMid * 1e6))
frame = self.frame
frame._frameNumber = 1
frame._trackNumber = 1
frame.setSensingStart(tStart)
frame.setSensingStop(tStop)
frame.setSensingMid(tMid)
frame.setNumberOfLines(int(self.metadata['slc_1_1x1_mag.set_rows']))
frame.setNumberOfSamples(int(self.metadata['slc_1_1x1_mag.set_cols']))
frame.setPolarization(self.metadata['Polarization'])
frame.C0 = self.metadata['slc_1_1x1_mag.col_addr']
frame.S0 = self.metadata['Segment {} Data Starting Azimuth'.format(
self.segment_index)]
frame.nearLookAngle = self.metadata['Minimum Look Angle']
frame.farLookAngle = self.metadata['Maximum Look Angle']
frame.setStartingRange(self.startingRange)
frame.platformHeight = self.platformHeight
width = frame.getNumberOfSamples()
deltaRange = frame.instrument.getRangePixelSize()
nearRange = frame.getStartingRange()
midRange = nearRange + (width / 2.) * deltaRange
frame.setFarRange(nearRange + width * deltaRange)
self.extractDoppler()
frame._ellipsoid = self.elp
frame.peg = self.peg
frame.procVelocity = self.velocity
from isceobj.Location.Coordinate import Coordinate
frame.upperLeftCorner = Coordinate()
#The corner latitude, longitudes are given as a pair
#of values in degrees at each corner (without rdf unit specified)
llC = []
for ic in range(1, 5):
key = 'Segment {0} Data Approximate Corner {1}'.format(
self.segment_index, ic)
self.logger.info("key = {}".format(key))
self.logger.info("metadata[key] = {}".format(
self.metadata[key], type(self.metadata[key])))
llC.append(list(map(float, self.metadata[key].split(','))))
frame.terrainHeight = self.terrainHeight
frame.upperLeftCorner.setLatitude(llC[0][0])
frame.upperLeftCorner.setLongitude(llC[0][1])
frame.upperLeftCorner.setHeight(self.terrainHeight)
frame.upperRightCorner = Coordinate()
frame.upperRightCorner.setLatitude(llC[1][0])
frame.upperRightCorner.setLongitude(llC[1][1])
frame.upperRightCorner.setHeight(self.terrainHeight)
frame.lowerRightCorner = Coordinate()
frame.lowerRightCorner.setLatitude(llC[2][0])
frame.lowerRightCorner.setLongitude(llC[2][1])
frame.lowerRightCorner.setHeight(self.terrainHeight)
frame.lowerLeftCorner = Coordinate()
frame.lowerLeftCorner.setLatitude(llC[3][0])
frame.lowerLeftCorner.setLongitude(llC[3][1])
frame.lowerLeftCorner.setHeight(self.terrainHeight)
frame.nearLookAngle = math.degrees(self.metadata['Minimum Look Angle'])
frame.farLookAngle = math.degrees(self.metadata['Maximum Look Angle'])
return
def runTopoGPU(self):
'''
Try with GPU module.
'''
from isceobj.Planet.Planet import Planet
from zerodop.GPUtopozero.GPUtopozero import PyTopozero
from isceobj import Constants as CN
from isceobj.Util.Poly2D import Poly2D
from iscesys import DateTimeUtil as DTU
swathList = self._insar.getValidSwathList(self.swaths)
####Catalog for logging
catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name)
####Load in DEM
demfilename = self.verifyDEM()
catalog.addItem('Dem Used', demfilename, 'topo')
frames = []
swaths = []
swathStarts = []
for swath in swathList:
#####Load the master product
master = self._insar.loadProduct(
os.path.join(self._insar.masterSlcProduct,
'IW{0}.xml'.format(swath)))
numCommon = self._insar.numberOfCommonBursts[swath - 1]
startIndex = self._insar.commonBurstStartMasterIndex[swath - 1]
if numCommon > 0:
catalog.addItem('Number of common bursts IW-{0}'.format(swath),
self._insar.numberOfCommonBursts[swath - 1],
'topo')
master.bursts = master.bursts[startIndex:startIndex + numCommon]
master.numberOfBursts = numCommon
frames.append(master)
swaths.append(swath)
swathStarts.append(startIndex)
if len(frames) == 0:
raise Exception(
'There is no common region between the two dates to process')
topSwath = min(frames, key=lambda x: x.sensingStart)
leftSwath = min(frames, key=lambda x: x.startingRange)
bottomSwath = max(frames, key=lambda x: x.sensingStop)
rightSwath = max(frames, key=lambda x: x.farRange)
r0 = leftSwath.startingRange
rmax = rightSwath.farRange
dr = frames[0].bursts[0].rangePixelSize
t0 = topSwath.sensingStart
tmax = bottomSwath.sensingStop
dt = frames[0].bursts[0].azimuthTimeInterval
wvl = frames[0].bursts[0].radarWavelength
width = int(np.round((rmax - r0) / dr) + 1)
lgth = int(np.round((tmax - t0).total_seconds() / dt) + 1)
polyDoppler = Poly2D(name='topsApp_dopplerPoly')
polyDoppler.setWidth(width)
polyDoppler.setLength(lgth)
polyDoppler.setNormRange(1.0)
polyDoppler.setNormAzimuth(1.0)
polyDoppler.setMeanRange(0.0)
polyDoppler.setMeanAzimuth(0.0)
polyDoppler.initPoly(rangeOrder=0, azimuthOrder=0, coeffs=[[0.]])
polyDoppler.createPoly2D()
slantRangeImage = Poly2D()
slantRangeImage.setWidth(width)
slantRangeImage.setLength(lgth)
slantRangeImage.setNormRange(1.0)
slantRangeImage.setNormAzimuth(1.0)
slantRangeImage.setMeanRange(0.)
slantRangeImage.setMeanAzimuth(0.)
slantRangeImage.initPoly(rangeOrder=1, azimuthOrder=0, coeffs=[[r0, dr]])
slantRangeImage.createPoly2D()
dirname = self._insar.geometryDirname
os.makedirs(dirname, exist_ok=True)
latImage = isceobj.createImage()
latImage.initImage(os.path.join(dirname, 'lat.rdr'), 'write', width,
'DOUBLE')
latImage.createImage()
lonImage = isceobj.createImage()
lonImage.initImage(os.path.join(dirname, 'lon.rdr'), 'write', width,
'DOUBLE')
lonImage.createImage()
losImage = isceobj.createImage()
losImage.initImage(os.path.join(dirname, 'los.rdr'),
'write',
width,
'FLOAT',
bands=2,
scheme='BIL')
losImage.setCaster('write', 'DOUBLE')
losImage.createImage()
heightImage = isceobj.createImage()
heightImage.initImage(os.path.join(dirname, 'hgt.rdr'), 'write', width,
'DOUBLE')
heightImage.createImage()
demImage = isceobj.createDemImage()
demImage.load(demfilename + '.xml')
demImage.setCaster('read', 'FLOAT')
demImage.createImage()
orb = self._insar.getMergedOrbit(frames)
pegHdg = np.radians(orb.getENUHeading(t0))
elp = Planet(pname='Earth').ellipsoid
topo = PyTopozero()
topo.set_firstlat(demImage.getFirstLatitude())
topo.set_firstlon(demImage.getFirstLongitude())
topo.set_deltalat(demImage.getDeltaLatitude())
topo.set_deltalon(demImage.getDeltaLongitude())
topo.set_major(elp.a)
topo.set_eccentricitySquared(elp.e2)
topo.set_rSpace(dr)
topo.set_r0(r0)
topo.set_pegHdg(pegHdg)
topo.set_prf(1.0 / dt)
topo.set_t0(DTU.seconds_since_midnight(t0))
topo.set_wvl(wvl)
topo.set_thresh(.05)
topo.set_demAccessor(demImage.getImagePointer())
topo.set_dopAccessor(polyDoppler.getPointer())
topo.set_slrngAccessor(slantRangeImage.getPointer())
topo.set_latAccessor(latImage.getImagePointer())
topo.set_lonAccessor(lonImage.getImagePointer())
topo.set_losAccessor(losImage.getImagePointer())
topo.set_heightAccessor(heightImage.getImagePointer())
topo.set_incAccessor(0)
topo.set_maskAccessor(0)
topo.set_numIter(25)
topo.set_idemWidth(demImage.getWidth())
topo.set_idemLength(demImage.getLength())
topo.set_ilrl(-1)
topo.set_extraIter(10)
topo.set_length(lgth)
topo.set_width(width)
topo.set_nRngLooks(1)
topo.set_nAzLooks(1)
topo.set_demMethod(5) # BIQUINTIC METHOD
topo.set_orbitMethod(0) # HERMITE
# Need to simplify orbit stuff later
nvecs = len(orb._stateVectors)
topo.set_orbitNvecs(nvecs)
topo.set_orbitBasis(1) # Is this ever different?
topo.createOrbit(
) # Initializes the empty orbit to the right allocated size
count = 0
for sv in orb._stateVectors:
td = DTU.seconds_since_midnight(sv.getTime())
pos = sv.getPosition()
vel = sv.getVelocity()
topo.set_orbitVector(count, td, pos[0], pos[1], pos[2], vel[0], vel[1],
vel[2])
count += 1
topo.runTopo()
latImage.addDescription('Pixel-by-pixel latitude in degrees.')
latImage.finalizeImage()
latImage.renderHdr()
lonImage.addDescription('Pixel-by-pixel longitude in degrees.')
lonImage.finalizeImage()
lonImage.renderHdr()
heightImage.addDescription('Pixel-by-pixel height in meters.')
heightImage.finalizeImage()
heightImage.renderHdr()
descr = '''Two channel Line-Of-Sight geometry image (all angles in degrees). Represents vector drawn from target to platform.
Channel 1: Incidence angle measured from vertical at target (always +ve).
Channel 2: Azimuth angle measured from North in Anti-clockwise direction.'''
losImage.setImageType('bil')
losImage.addDescription(descr)
losImage.finalizeImage()
losImage.renderHdr()
demImage.finalizeImage()
if slantRangeImage:
try:
slantRangeImage.finalizeImage()
except:
pass
####Start creating VRTs to point to global topo output
for swath, frame, istart in zip(swaths, frames, swathStarts):
outname = os.path.join(dirname, 'IW{0}'.format(swath))
os.makedirs(outname, exist_ok=True)
for ind, burst in enumerate(frame.bursts):
top = int(np.rint((burst.sensingStart - t0).total_seconds() / dt))
bottom = top + burst.numberOfLines
left = int(np.rint((burst.startingRange - r0) / dr))
right = left + burst.numberOfSamples
buildVRT(os.path.join(dirname, 'lat.rdr'),
os.path.join(outname,
'lat_%02d.rdr' % (ind + istart + 1)),
[width, lgth], [top, bottom, left, right],
bands=1,
dtype='DOUBLE')
buildVRT(os.path.join(dirname, 'lon.rdr'),
os.path.join(outname,
'lon_%02d.rdr' % (ind + istart + 1)),
[width, lgth], [top, bottom, left, right],
bands=1,
dtype='DOUBLE')
buildVRT(os.path.join(dirname, 'hgt.rdr'),
os.path.join(outname,
'hgt_%02d.rdr' % (ind + istart + 1)),
[width, lgth], [top, bottom, left, right],
bands=1,
dtype='DOUBLE')
buildVRT(os.path.join(dirname, 'los.rdr'),
os.path.join(outname,
'los_%02d.rdr' % (ind + istart + 1)),
[width, lgth], [top, bottom, left, right],
bands=2,
dtype='FLOAT')
catalog.addItem(
'Subset for IW{0}-B{1}'.format(swath, ind + 1 + istart),
'Lines: {0}-{1} out of {2}, Pixels: {3}-{4} out of {5}'.format(
top, bottom, lgth, left, right, width), 'topo')
# print('IW{0}-B{1}: {2} - {3}/ {4}, {5} - {6} /{7}'.format(swath, ind+1+istart, top, bottom, lgth, left, right, width))
catalog.printToLog(logger, "runTopo")
self._insar.procDoc.addAllFromCatalog(catalog)
return
def topoGPU(masterTrack, numberRangeLooks, numberAzimuthLooks, demFile,
latFile, lonFile, hgtFile, losFile):
'''
Try with GPU module.
'''
import datetime
import numpy as np
from isceobj.Planet.Planet import Planet
from zerodop.GPUtopozero.GPUtopozero import PyTopozero
from isceobj.Util.Poly2D import Poly2D
from iscesys import DateTimeUtil as DTU
pointingDirection = {'right': -1, 'left': 1}
#creat poynomials
polyDoppler = Poly2D(name='topsApp_dopplerPoly')
polyDoppler.setWidth(masterTrack.numberOfSamples)
polyDoppler.setLength(masterTrack.numberOfLines)
polyDoppler.setNormRange(1.0)
polyDoppler.setNormAzimuth(1.0)
polyDoppler.setMeanRange(0.0)
polyDoppler.setMeanAzimuth(0.0)
polyDoppler.initPoly(rangeOrder=0, azimuthOrder=0, coeffs=[[0.]])
polyDoppler.createPoly2D()
slantRangeImage = Poly2D()
slantRangeImage.setWidth(masterTrack.numberOfSamples)
slantRangeImage.setLength(masterTrack.numberOfLines)
slantRangeImage.setNormRange(1.0)
slantRangeImage.setNormAzimuth(1.0)
slantRangeImage.setMeanRange(0.)
slantRangeImage.setMeanAzimuth(0.)
slantRangeImage.initPoly(
rangeOrder=1,
azimuthOrder=0,
coeffs=[[
masterTrack.startingRange +
(numberRangeLooks - 1.0) / 2.0 * masterTrack.rangePixelSize,
numberRangeLooks * masterTrack.rangePixelSize
]])
slantRangeImage.createPoly2D()
#creat images
latImage = isceobj.createImage()
latImage.initImage(latFile, 'write', masterTrack.numberOfSamples, 'DOUBLE')
latImage.createImage()
lonImage = isceobj.createImage()
lonImage.initImage(lonFile, 'write', masterTrack.numberOfSamples, 'DOUBLE')
lonImage.createImage()
losImage = isceobj.createImage()
losImage.initImage(losFile,
'write',
masterTrack.numberOfSamples,
'FLOAT',
bands=2,
scheme='BIL')
losImage.setCaster('write', 'DOUBLE')
losImage.createImage()
heightImage = isceobj.createImage()
heightImage.initImage(hgtFile, 'write', masterTrack.numberOfSamples,
'DOUBLE')
heightImage.createImage()
demImage = isceobj.createDemImage()
demImage.load(demFile + '.xml')
demImage.setCaster('read', 'FLOAT')
demImage.createImage()
#compute a few things
t0 = masterTrack.sensingStart + datetime.timedelta(
seconds=(numberAzimuthLooks - 1.0) / 2.0 *
masterTrack.azimuthLineInterval)
orb = masterTrack.orbit
pegHdg = np.radians(orb.getENUHeading(t0))
elp = Planet(pname='Earth').ellipsoid
#call gpu topo
topo = PyTopozero()
topo.set_firstlat(demImage.getFirstLatitude())
topo.set_firstlon(demImage.getFirstLongitude())
topo.set_deltalat(demImage.getDeltaLatitude())
topo.set_deltalon(demImage.getDeltaLongitude())
topo.set_major(elp.a)
topo.set_eccentricitySquared(elp.e2)
topo.set_rSpace(numberRangeLooks * masterTrack.rangePixelSize)
topo.set_r0(masterTrack.startingRange +
(numberRangeLooks - 1.0) / 2.0 * masterTrack.rangePixelSize)
topo.set_pegHdg(pegHdg)
topo.set_prf(1.0 / (numberAzimuthLooks * masterTrack.azimuthLineInterval))
topo.set_t0(DTU.seconds_since_midnight(t0))
topo.set_wvl(masterTrack.radarWavelength)
topo.set_thresh(.05)
topo.set_demAccessor(demImage.getImagePointer())
topo.set_dopAccessor(polyDoppler.getPointer())
topo.set_slrngAccessor(slantRangeImage.getPointer())
topo.set_latAccessor(latImage.getImagePointer())
topo.set_lonAccessor(lonImage.getImagePointer())
topo.set_losAccessor(losImage.getImagePointer())
topo.set_heightAccessor(heightImage.getImagePointer())
topo.set_incAccessor(0)
topo.set_maskAccessor(0)
topo.set_numIter(25)
topo.set_idemWidth(demImage.getWidth())
topo.set_idemLength(demImage.getLength())
topo.set_ilrl(pointingDirection[masterTrack.pointingDirection])
topo.set_extraIter(10)
topo.set_length(masterTrack.numberOfLines)
topo.set_width(masterTrack.numberOfSamples)
topo.set_nRngLooks(1)
topo.set_nAzLooks(1)
topo.set_demMethod(5) # BIQUINTIC METHOD
topo.set_orbitMethod(0) # HERMITE
# Need to simplify orbit stuff later
nvecs = len(orb._stateVectors)
topo.set_orbitNvecs(nvecs)
topo.set_orbitBasis(1) # Is this ever different?
topo.createOrbit(
) # Initializes the empty orbit to the right allocated size
count = 0
for sv in orb._stateVectors:
td = DTU.seconds_since_midnight(sv.getTime())
pos = sv.getPosition()
vel = sv.getVelocity()
topo.set_orbitVector(count, td, pos[0], pos[1], pos[2], vel[0], vel[1],
vel[2])
count += 1
topo.runTopo()
#tidy up
latImage.addDescription('Pixel-by-pixel latitude in degrees.')
latImage.finalizeImage()
latImage.renderHdr()
lonImage.addDescription('Pixel-by-pixel longitude in degrees.')
lonImage.finalizeImage()
lonImage.renderHdr()
heightImage.addDescription('Pixel-by-pixel height in meters.')
heightImage.finalizeImage()
heightImage.renderHdr()
descr = '''Two channel Line-Of-Sight geometry image (all angles in degrees). Represents vector drawn from target to platform.
Channel 1: Incidence angle measured from vertical at target (always +ve).
Channel 2: Azimuth angle measured from North in Anti-clockwise direction.'''
losImage.setImageType('bil')
losImage.addDescription(descr)
losImage.finalizeImage()
losImage.renderHdr()
demImage.finalizeImage()
if slantRangeImage:
try:
slantRangeImage.finalizeImage()
except:
pass
def rdr2geoNew(self, aztime, rng, height=0.,
doppler = None, wvl = None,
planet=None, side=-1):
'''
Returns point on ground at given height and doppler frequency.
Never to be used for heavy duty computing.
'''
from isceobj.Planet.Planet import Planet
####Setup doppler for the equations
dopfact = 0.
sv = self.interpolateOrbit(aztime, method='hermite')
pos = np.array(sv.getPosition())
vel =np.array( sv.getVelocity())
vmag = np.linalg.norm(vel)
if doppler is not None:
dopfact = doppler(DTU.seconds_since_midnight(aztime), rng) * 0.5 * wvl * rng/vmag
if planet is None:
refElp = Planet(pname='Earth').ellipsoid
else:
refElp = planet.ellipsoid
###Convert position and velocity to local tangent plane
major = refElp.a
minor = major * np.sqrt(1 - refElp.e2)
#####Setup ortho normal system right below satellite
satDist = np.linalg.norm(pos)
alpha = 1 / np.linalg.norm(pos/ np.array([major, major, minor]))
radius = alpha * satDist
hgt = (1.0 - alpha) * satDist
###Setup TCN basis - Geocentric
nhat = -pos/satDist
temp = np.cross(nhat, vel)
chat = temp / np.linalg.norm(temp)
temp = np.cross(chat, nhat)
that = temp / np.linalg.norm(temp)
vhat = vel / vmag
####Solve the range doppler eqns iteratively
####Initial guess
zsch = height
for ii in range(10):
###Near nadir tests
if (hgt-zsch) >= rng:
return None
a = satDist
b = (radius + zsch)
costheta = 0.5*(a/rng + rng/a - (b/a)*(b/rng))
sintheta = np.sqrt(1-costheta*costheta)
gamma = rng*costheta
alpha = dopfact - gamma*np.dot(nhat,vhat)/np.dot(vhat,that)
beta = -side*np.sqrt(rng*rng*sintheta*sintheta - alpha*alpha)
delta = alpha * that + beta * chat + gamma * nhat
targVec = pos + delta
targLLH = refElp.xyz_to_llh(list(targVec))
targXYZ = np.array(refElp.llh_to_xyz([targLLH[0], targLLH[1], height]))
zsch = np.linalg.norm(targXYZ) - radius
rdiff = rng - np.linalg.norm(pos - targXYZ)
return targLLH
def geo2RdrGPU(secondaryTrack, numberRangeLooks, numberAzimuthLooks, latFile,
lonFile, hgtFile, rangeOffsetFile, azimuthOffsetFile):
'''
currently we cannot set left/right looking.
works for right looking, but left looking probably not supported.
'''
import datetime
from zerodop.GPUgeo2rdr.GPUgeo2rdr import PyGeo2rdr
from isceobj.Planet.Planet import Planet
from iscesys import DateTimeUtil as DTU
latImage = isceobj.createImage()
latImage.load(latFile + '.xml')
latImage.setAccessMode('READ')
latImage.createImage()
lonImage = isceobj.createImage()
lonImage.load(lonFile + '.xml')
lonImage.setAccessMode('READ')
lonImage.createImage()
demImage = isceobj.createImage()
demImage.load(hgtFile + '.xml')
demImage.setAccessMode('READ')
demImage.createImage()
#####Run Geo2rdr
planet = Planet(pname='Earth')
grdr = PyGeo2rdr()
grdr.setRangePixelSpacing(numberRangeLooks * secondaryTrack.rangePixelSize)
grdr.setPRF(1.0 /
(numberAzimuthLooks * secondaryTrack.azimuthLineInterval))
grdr.setRadarWavelength(secondaryTrack.radarWavelength)
#CHECK IF THIS WORKS!!!
grdr.createOrbit(0, len(secondaryTrack.orbit.stateVectors.list))
count = 0
for sv in secondaryTrack.orbit.stateVectors.list:
td = DTU.seconds_since_midnight(sv.getTime())
pos = sv.getPosition()
vel = sv.getVelocity()
grdr.setOrbitVector(count, td, pos[0], pos[1], pos[2], vel[0], vel[1],
vel[2])
count += 1
grdr.setOrbitMethod(0)
grdr.setWidth(secondaryTrack.numberOfSamples)
grdr.setLength(secondaryTrack.numberOfLines)
grdr.setSensingStart(
DTU.seconds_since_midnight(
secondaryTrack.sensingStart +
datetime.timedelta(seconds=(numberAzimuthLooks - 1.0) / 2.0 *
secondaryTrack.azimuthLineInterval)))
grdr.setRangeFirstSample(secondaryTrack.startingRange +
(numberRangeLooks - 1.0) / 2.0 *
secondaryTrack.rangePixelSize)
grdr.setNumberRangeLooks(1)
grdr.setNumberAzimuthLooks(1)
grdr.setEllipsoidMajorSemiAxis(planet.ellipsoid.a)
grdr.setEllipsoidEccentricitySquared(planet.ellipsoid.e2)
grdr.createPoly(0, 0., 1.)
grdr.setPolyCoeff(0, 0.)
grdr.setDemLength(demImage.getLength())
grdr.setDemWidth(demImage.getWidth())
grdr.setBistaticFlag(0)
rangeOffsetImage = isceobj.createImage()
rangeOffsetImage.setFilename(rangeOffsetFile)
rangeOffsetImage.setAccessMode('write')
rangeOffsetImage.setDataType('FLOAT')
rangeOffsetImage.setCaster('write', 'DOUBLE')
rangeOffsetImage.setWidth(demImage.width)
rangeOffsetImage.createImage()
azimuthOffsetImage = isceobj.createImage()
azimuthOffsetImage.setFilename(azimuthOffsetFile)
azimuthOffsetImage.setAccessMode('write')
azimuthOffsetImage.setDataType('FLOAT')
azimuthOffsetImage.setCaster('write', 'DOUBLE')
azimuthOffsetImage.setWidth(demImage.width)
azimuthOffsetImage.createImage()
grdr.setLatAccessor(latImage.getImagePointer())
grdr.setLonAccessor(lonImage.getImagePointer())
grdr.setHgtAccessor(demImage.getImagePointer())
grdr.setAzAccessor(0)
grdr.setRgAccessor(0)
grdr.setAzOffAccessor(azimuthOffsetImage.getImagePointer())
grdr.setRgOffAccessor(rangeOffsetImage.getImagePointer())
grdr.geo2rdr()
rangeOffsetImage.finalizeImage()
rangeOffsetImage.renderHdr()
azimuthOffsetImage.finalizeImage()
azimuthOffsetImage.renderHdr()
latImage.finalizeImage()
lonImage.finalizeImage()
demImage.finalizeImage()
return
def runTopoGPU(info, demImage, dop=None, nativedop=False, legendre=False):
from isceobj import Constants as CN
from isceobj.Planet.Planet import Planet
from isceobj.Util.Poly2D import Poly2D
from iscesys import DateTimeUtil as DTU
from zerodop.GPUtopozero.GPUtopozero import PyTopozero
## TODO GPU does not support shadow and layover and local inc file generation
full = False
os.makedirs(info.outdir, exist_ok=True)
# define variables to be used later on
r0 = info.rangeFirstSample + (
(info.numberRangeLooks - 1) / 2) * info.slantRangePixelSpacing
tbef = info.sensingStart + datetime.timedelta(seconds=(
(info.numberAzimuthLooks - 1) / 2) / info.prf)
pegHdg = np.radians(info.orbit.getENUHeading(tbef))
width = info.width // info.numberRangeLooks
length = info.length // info.numberAzimuthLooks
dr = info.slantRangePixelSpacing * info.numberRangeLooks
# output file names
latFilename = info.latFilename
lonFilename = info.lonFilename
losFilename = info.losFilename
heightFilename = info.heightFilename
incFilename = info.incFilename
maskFilename = info.maskFilename
# orbit interpolator
if legendre:
omethod = 2 # LEGENDRE INTERPOLATION
else:
omethod = 0 # HERMITE INTERPOLATION
# tracking doppler specifications
if nativedop and (dop is not None):
try:
coeffs = dop._coeffs
except:
coeffs = dop
polyDoppler = Poly2D()
polyDoppler.setWidth(width)
polyDoppler.setLength(length)
polyDoppler.initPoly(rangeOrder=len(coeffs) - 1,
azimuthOrder=0,
coeffs=[coeffs])
else:
print('Zero doppler')
polyDoppler = Poly2D(name='stripmapStack_dopplerPoly')
polyDoppler.setWidth(width)
polyDoppler.setLength(length)
polyDoppler.setNormRange(1.0)
polyDoppler.setNormAzimuth(1.0)
polyDoppler.setMeanRange(0.0)
polyDoppler.setMeanAzimuth(0.0)
polyDoppler.initPoly(rangeOrder=0, azimuthOrder=0, coeffs=[[0.0]])
polyDoppler.createPoly2D()
# dem
demImage.setCaster('read', 'FLOAT')
demImage.createImage()
# slant range file
slantRangeImage = Poly2D()
slantRangeImage.setWidth(width)
slantRangeImage.setLength(length)
slantRangeImage.setNormRange(1.0)
slantRangeImage.setNormAzimuth(1.0)
slantRangeImage.setMeanRange(0.0)
slantRangeImage.setMeanAzimuth(0.0)
slantRangeImage.initPoly(rangeOrder=1, azimuthOrder=0, coeffs=[[r0, dr]])
slantRangeImage.createPoly2D()
# lat file
latImage = isceobj.createImage()
accessMode = 'write'
dataType = 'DOUBLE'
latImage.initImage(latFilename, accessMode, width, dataType)
latImage.createImage()
# lon file
lonImage = isceobj.createImage()
lonImage.initImage(lonFilename, accessMode, width, dataType)
lonImage.createImage()
# LOS file
losImage = isceobj.createImage()
dataType = 'FLOAT'
bands = 2
scheme = 'BIL'
losImage.initImage(losFilename,
accessMode,
width,
dataType,
bands=bands,
scheme=scheme)
losImage.setCaster('write', 'DOUBLE')
losImage.createImage()
# height file
heightImage = isceobj.createImage()
dataType = 'DOUBLE'
heightImage.initImage(heightFilename, accessMode, width, dataType)
heightImage.createImage()
# add inc and mask file if requested
if full:
incImage = isceobj.createImage()
dataType = 'FLOAT'
incImage.initImage(incFilename,
accessMode,
width,
dataType,
bands=bands,
scheme=scheme)
incImage.createImage()
incImagePtr = incImage.getImagePointer()
maskImage = isceobj.createImage()
dataType = 'BYTE'
bands = 1
maskImage.initImage(maskFilename,
accessMode,
width,
dataType,
bands=bands,
scheme=scheme)
maskImage.createImage()
maskImagePtr = maskImage.getImagePointer()
else:
incImagePtr = 0
maskImagePtr = 0
# initalize planet
elp = Planet(pname='Earth').ellipsoid
# initialize topo object and fill with parameters
topo = PyTopozero()
topo.set_firstlat(demImage.getFirstLatitude())
topo.set_firstlon(demImage.getFirstLongitude())
topo.set_deltalat(demImage.getDeltaLatitude())
topo.set_deltalon(demImage.getDeltaLongitude())
topo.set_major(elp.a)
topo.set_eccentricitySquared(elp.e2)
topo.set_rSpace(info.slantRangePixelSpacing)
topo.set_r0(r0)
topo.set_pegHdg(pegHdg)
topo.set_prf(info.prf)
topo.set_t0(DTU.seconds_since_midnight(tbef))
topo.set_wvl(info.radarWavelength)
topo.set_thresh(.05)
topo.set_demAccessor(demImage.getImagePointer())
topo.set_dopAccessor(polyDoppler.getPointer())
topo.set_slrngAccessor(slantRangeImage.getPointer())
topo.set_latAccessor(latImage.getImagePointer())
topo.set_lonAccessor(lonImage.getImagePointer())
topo.set_losAccessor(losImage.getImagePointer())
topo.set_heightAccessor(heightImage.getImagePointer())
topo.set_incAccessor(incImagePtr)
topo.set_maskAccessor(maskImagePtr)
topo.set_numIter(25)
topo.set_idemWidth(demImage.getWidth())
topo.set_idemLength(demImage.getLength())
topo.set_ilrl(info.lookSide)
topo.set_extraIter(10)
topo.set_length(length)
topo.set_width(width)
topo.set_nRngLooks(info.numberRangeLooks)
topo.set_nAzLooks(info.numberAzimuthLooks)
topo.set_demMethod(5) # BIQUINTIC METHOD
topo.set_orbitMethod(omethod)
# Need to simplify orbit stuff later
nvecs = len(info.orbit.stateVectors.list)
topo.set_orbitNvecs(nvecs)
topo.set_orbitBasis(1) # Is this ever different?
topo.createOrbit(
) # Initializes the empty orbit to the right allocated size
count = 0
for sv in info.orbit.stateVectors.list:
td = DTU.seconds_since_midnight(sv.getTime())
pos = sv.getPosition()
vel = sv.getVelocity()
topo.set_orbitVector(count, td, pos[0], pos[1], pos[2], vel[0], vel[1],
vel[2])
count += 1
# run topo
topo.runTopo()
# close the written files and add description etc
# lat file
latImage.addDescription('Pixel-by-pixel latitude in degrees.')
latImage.finalizeImage()
latImage.renderHdr()
# lon file
lonImage.addDescription('Pixel-by-pixel longitude in degrees.')
lonImage.finalizeImage()
lonImage.renderHdr()
# height file
heightImage.addDescription('Pixel-by-pixel height in meters.')
heightImage.finalizeImage()
heightImage.renderHdr()
# los file
descr = '''Two channel Line-Of-Sight geometry image (all angles in degrees). Represents vector drawn from target to platform.
Channel 1: Incidence angle measured from vertical at target (always +ve).
Channel 2: Azimuth angle measured from North in Anti-clockwise direction.'''
losImage.setImageType('bil')
losImage.addDescription(descr)
losImage.finalizeImage()
losImage.renderHdr()
# dem/ height file
demImage.finalizeImage()
# adding in additional files if requested
if full:
descr = '''Two channel angle file.
Channel 1: Angle between ray to target and the vertical at the sensor
Channel 2: Local incidence angle accounting for DEM slope at target'''
incImage.addDescription(descr)
incImage.finalizeImage()
incImage.renderHdr()
descr = 'Radar shadow-layover mask. 1 - Radar Shadow. 2 - Radar Layover. 3 - Both.'
maskImage.addDescription(descr)
maskImage.finalizeImage()
maskImage.renderHdr()
if slantRangeImage:
try:
slantRangeImage.finalizeImage()
except:
pass
def runGeo2rdrGPU(info,latImage, lonImage, demImage, outdir,
dop=None, nativedop=False, legendre=False,
azoff=0.0, rgoff=0.0,
alks=1, rlks=1):
from zerodop.GPUgeo2rdr.GPUgeo2rdr import PyGeo2rdr
from isceobj.Planet.Planet import Planet
from iscesys import DateTimeUtil as DTU
# for GPU the images need to have been created
latImage.createImage()
lonImage.createImage()
demImage.createImage()
#####Run Geo2rdr
planet = Planet(pname='Earth')
grdr = PyGeo2rdr()
grdr.setRangePixelSpacing(info.getInstrument().getRangePixelSize())
grdr.setPRF(info.getInstrument().getPulseRepetitionFrequency())
grdr.setRadarWavelength(info.getInstrument().getRadarWavelength())
# setting the orbit information
grdr.createOrbit(0, len(info.orbit.stateVectors.list))
count = 0
for sv in info.orbit.stateVectors.list:
td = DTU.seconds_since_midnight(sv.getTime())
pos = sv.getPosition()
vel = sv.getVelocity()
# print("time " + str(td))
# print("pos " + str(pos))
# print("vel " + str(vel))
# print("")
grdr.setOrbitVector(count, td, pos[0], pos[1], pos[2], vel[0], vel[1], vel[2])
count += 1
if legendre:
print("Legendre requested")
# see the include/Constants.h for the defined values
grdr.setOrbitMethod(2)
else:
grdr.setOrbitMethod(0)
grdr.setWidth(info.getImage().getWidth())
grdr.setLength(info.getImage().getLength())
grdr.setEllipsoidMajorSemiAxis(planet.ellipsoid.a)
grdr.setEllipsoidEccentricitySquared(planet.ellipsoid.e2)
## TODO Setting lookside in GPU mode
## lookside = info.instrument.platform.pointingDirection
prf = info.getInstrument().getPulseRepetitionFrequency()
delta = datetime.timedelta(seconds = (azoff-(alks-1)/2)/prf)
misreg_rg = (rgoff - (rlks-1)/2)*info.getInstrument().getRangePixelSize()
grdr.setSensingStart(DTU.seconds_since_midnight(info.sensingStart - delta))
grdr.setRangeFirstSample(info.getStartingRange() - misreg_rg)
grdr.setNumberRangeLooks(rlks)
grdr.setNumberAzimuthLooks(alks)
if nativedop and (dop is not None):
try:
coeffs = [x/prf for x in dop._coeffs]
except:
coeffs = [x/prf for x in dop]
print('Native Doppler')
# initialize the doppler polynomial
# the object is defined as (poly_order,poly_mean,poly_norm);
grdr.createPoly(len(coeffs)-1,0.,1.)
index = 0
for coeff in coeffs:
grdr.setPolyCoeff(index, coeff)
index += 1
else:
print('Zero doppler')
grdr.createPoly(0, 0., 1.)
grdr.setPolyCoeff(0, 0.)
grdr.setDemLength(demImage.getLength())
grdr.setDemWidth(demImage.getWidth())
grdr.setBistaticFlag(0)
rangeOffsetFILE = os.path.join(outdir, 'range.off')
rangeOffsetImage = isceobj.createImage()
rangeOffsetImage.setFilename(rangeOffsetFILE)
rangeOffsetImage.setAccessMode('write')
rangeOffsetImage.setDataType('FLOAT')
rangeOffsetImage.setCaster('write', 'DOUBLE')
rangeOffsetImage.setWidth(demImage.width)
rangeOffsetImage.createImage()
azimuthOffsetFILE= os.path.join(outdir, 'azimuth.off')
azimuthOffsetImage = isceobj.createImage()
azimuthOffsetImage.setFilename(azimuthOffsetFILE)
azimuthOffsetImage.setAccessMode('write')
azimuthOffsetImage.setDataType('FLOAT')
azimuthOffsetImage.setCaster('write', 'DOUBLE')
azimuthOffsetImage.setWidth(demImage.width)
azimuthOffsetImage.createImage()
grdr.setLatAccessor(latImage.getImagePointer())
grdr.setLonAccessor(lonImage.getImagePointer())
grdr.setHgtAccessor(demImage.getImagePointer())
grdr.setAzAccessor(0)
grdr.setRgAccessor(0)
grdr.setAzOffAccessor(azimuthOffsetImage.getImagePointer())
grdr.setRgOffAccessor(rangeOffsetImage.getImagePointer())
grdr.geo2rdr()
rangeOffsetImage.finalizeImage()
rangeOffsetImage.renderHdr()
azimuthOffsetImage.finalizeImage()
azimuthOffsetImage.renderHdr()
latImage.finalizeImage()
lonImage.finalizeImage()
demImage.finalizeImage()
return
pass
def runGeo2rdrGPU(info, rdict, misreg_az=0.0, misreg_rg=0.0):
from zerodop.GPUgeo2rdr.GPUgeo2rdr import PyGeo2rdr
from isceobj.Planet.Planet import Planet
from iscesys import DateTimeUtil as DTU
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()
misreg_az = misreg_az*info.azimuthTimeInterval
delta = datetime.timedelta(seconds=misreg_az)
print('Additional time offset applied in geo2rdr: {0} secs'.format(misreg_az))
print('Additional range offset applied in geo2rdr: {0} m'.format(misreg_rg))
#####Run Geo2rdr
planet = Planet(pname='Earth')
grdr = PyGeo2rdr()
grdr.setRangePixelSpacing(info.rangePixelSize)
grdr.setPRF(1.0 / info.azimuthTimeInterval)
grdr.setRadarWavelength(info.radarWavelength)
grdr.createOrbit(0, len(info.orbit.stateVectors.list))
count = 0
for sv in info.orbit.stateVectors.list:
td = DTU.seconds_since_midnight(sv.getTime())
pos = sv.getPosition()
vel = sv.getVelocity()
grdr.setOrbitVector(count, td, pos[0], pos[1], pos[2], vel[0], vel[1], vel[2])
count += 1
grdr.setOrbitMethod(0)
grdr.setWidth(info.numberOfSamples)
grdr.setLength(info.numberOfLines)
grdr.setSensingStart(DTU.seconds_since_midnight(info.sensingStart -delta))
grdr.setRangeFirstSample(info.startingRange - misreg_rg)
grdr.setNumberRangeLooks(1)
grdr.setNumberAzimuthLooks(1)
grdr.setEllipsoidMajorSemiAxis(planet.ellipsoid.a)
grdr.setEllipsoidEccentricitySquared(planet.ellipsoid.e2)
grdr.createPoly(0, 0., 1.)
grdr.setPolyCoeff(0, 0.)
grdr.setDemLength(demImage.getLength())
grdr.setDemWidth(demImage.getWidth())
grdr.setBistaticFlag(0)
rangeOffsetImage = isceobj.createImage()
rangeOffsetImage.setFilename(rdict['rangeOffName'])
rangeOffsetImage.setAccessMode('write')
rangeOffsetImage.setDataType('FLOAT')
rangeOffsetImage.setCaster('write', 'DOUBLE')
rangeOffsetImage.setWidth(demImage.width)
rangeOffsetImage.createImage()
azimuthOffsetImage = isceobj.createImage()
azimuthOffsetImage.setFilename(rdict['azOffName'])
azimuthOffsetImage.setAccessMode('write')
azimuthOffsetImage.setDataType('FLOAT')
azimuthOffsetImage.setCaster('write', 'DOUBLE')
azimuthOffsetImage.setWidth(demImage.width)
azimuthOffsetImage.createImage()
grdr.setLatAccessor(latImage.getImagePointer())
grdr.setLonAccessor(lonImage.getImagePointer())
grdr.setHgtAccessor(demImage.getImagePointer())
grdr.setAzAccessor(0)
grdr.setRgAccessor(0)
grdr.setAzOffAccessor(azimuthOffsetImage.getImagePointer())
grdr.setRgOffAccessor(rangeOffsetImage.getImagePointer())
grdr.geo2rdr()
rangeOffsetImage.finalizeImage()
rangeOffsetImage.renderHdr()
azimuthOffsetImage.finalizeImage()
azimuthOffsetImage.renderHdr()
latImage.finalizeImage()
lonImage.finalizeImage()
demImage.finalizeImage()
return
pass
