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