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 try: newOrbit = self.selectStateVectors(time, 4, 5) except LookupError as e: return None 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, ansPos, ansVel)
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)] 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, position, velocity)
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: 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, ansPos_C[:], ansVel_C[:])
def _populateFrame(self, **kwargs): 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.setSensingStart(tStart) frame.setSensingStop(tStop) frame.setSensingMid(tMid) frame.setNumberOfLines(int(self.metadata['slc_mag.set_rows'])) frame.setNumberOfSamples(int(self.metadata['slc_mag.set_cols'])) frame.C0 = self.metadata['slc_mag.col_addr'] frame.S0 = self.metadata['slc_mag.row_addr'] self.extractDoppler() frame.setStartingRange(self.startingRange) frame.platformHeight = self.platformHeight width = frame.getNumberOfSamples() deltaRange = frame.instrument.getRangePixelSize() nearRange = frame.getStartingRange() frame.setFarRange(nearRange + width * deltaRange) frame._ellipsoid = self.elp frame.peg = self.peg frame.procVelocity = self.velocity 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)
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 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 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 _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 _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 _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