Python utm.from_latlon函数代码示例

def circle(latlng_origin=None, pid_origin=None, radius=15):
    """
    Returns a validator function for a Panorama. which Returns True if
    the Panorama is inside a circle of the radius r around the center
    point latlng_0.
    :param latlng_0: tuple (lat, lng) - center GPS
    :param r: float - radius in meters
    :return: validator(panorama) - given Panorama it returns True
             if the Panorama is inside the circle
    """
    if latlng_origin:
        (easting, northing, z_number, z_letter) = utm.from_latlon(latlng_origin[0], latlng_origin[1])
    elif pid_origin:
        latlng_origin = Panorama(pid_origin).getGPS()
        (easting, northing, z_number, z_letter) = utm.from_latlon(latlng_origin[0], latlng_origin[1])
    else:
        raise ValueError("One of the arguments 'latlang_origin' or 'pid_origin' must be given.")

    def isClose(p):
        ll = p.getGPS()
        (est, nth, zn, zl) = utm.from_latlon(ll[0], ll[1], force_zone_number=z_number)
        x, y = est-easting, nth-northing
        d = sqrt(x**2+y**2)
        return d < radius
    return isClose

 def test_force_zone(self):
     # test forcing zone ranges
     # NYC should be zone 18T
     self.assert_zone_equal(UTM.from_latlon(40.71435, -74.00597, 19, 'T'), 19, 'T')
     self.assert_zone_equal(UTM.from_latlon(40.71435, -74.00597, 17, 'T'), 17, 'T')
     self.assert_zone_equal(UTM.from_latlon(40.71435, -74.00597, 18, 'u'), 18, 'U')
     self.assert_zone_equal(UTM.from_latlon(40.71435, -74.00597, 18, 'S'), 18, 'S')

def global_to_local(origin, lon, lat, heading=0.0):
    """
    Converts from the WGS84 lon/lat global frame into the local
    frame in meters.  Note that heading is in degrees!

    @param origin (lon, lat, heading)
    @return (x, y, theta) in WGS84
    """
    # Create local transformation frame.
    import utm
    ox, oy, zone, hemi = utm.from_latlon(origin[1], origin[0])
    o_theta = (90 - origin[2]) * (math.pi/180.0)

    # Convert global point into local frame.
    px, py, zone, hemi = utm.from_latlon(lat, lon)
    p_theta = math.pi/2.0 - heading

    # Translate and rotate point to origin.
    point = shapely.geometry.Point(px - ox, py - oy)
    point = shapely.affinity.rotate(point, -o_theta,
                                    origin=ORIGIN, use_radians=True)
    theta = p_theta - o_theta

    # Return transformed point.
    return point.x, point.y, theta

    def test_from_latlon_range_checks(self):
        '''from_latlon should fail with out-of-bounds input'''
        self.assertRaises(UTM.OutOfRangeError, UTM.from_latlon, -100, 0)
        self.assertRaises(UTM.OutOfRangeError, UTM.from_latlon, -80.1, 0)
        for i in range(-8000, 8400):
            UTM.from_latlon(i / 100.0, 0)
        self.assertRaises(UTM.OutOfRangeError, UTM.from_latlon, 84.1, 0)
        self.assertRaises(UTM.OutOfRangeError, UTM.from_latlon, 100, 0)

        self.assertRaises(UTM.OutOfRangeError, UTM.from_latlon, 0, -300)
        self.assertRaises(UTM.OutOfRangeError, UTM.from_latlon, 0, -180.1)
        for i in range(-18000, 18000):
            UTM.from_latlon(0, i / 100.0)
        self.assertRaises(UTM.OutOfRangeError, UTM.from_latlon, 0, 180.1)
        self.assertRaises(UTM.OutOfRangeError, UTM.from_latlon, 0, 300)

        self.assertRaises(UTM.OutOfRangeError, UTM.from_latlon, -100, -300)
        self.assertRaises(UTM.OutOfRangeError, UTM.from_latlon, 100, -300)
        self.assertRaises(UTM.OutOfRangeError, UTM.from_latlon, -100, 300)
        self.assertRaises(UTM.OutOfRangeError, UTM.from_latlon, 100, 300)

        # test forcing zone ranges
        # NYC should be zone 18T
        self.assertRaises(UTM.OutOfRangeError, UTM.from_latlon, 40.71435, -74.00597, 70, 'T')
        self.assertRaises(UTM.OutOfRangeError, UTM.from_latlon, 40.71435, -74.00597, 18, 'A')

def optimize_rotate_UTMconvert(angle,df,base):
	import numpy as np
	import math
	import utm
	from HCF_functions import rotate_xy
	import matplotlib.pyplot as plt

	sum = 0
	pick = np.isfinite(df['gps_lat'])
	k = utm.from_latlon(df.loc[base]['y_working'],df.loc[base]['x_working'])
	x0 = k[0]
	y0 = k[1]
	for index, row in df[pick].iterrows():
		i = utm.from_latlon(row['y_working'], row['x_working'])
		j = utm.from_latlon(row['gps_lat'], row['gps_lon'])
		gpsX, gpsY = j[0], j[1]
		newX, newY = rotate_xy(i[0],i[1],x0,y0, angle * math.pi / 180)

		a = newX - gpsX
		b = newY - gpsY
		c = np.square(a) + np.square(b)
		misfit = np.sqrt(c)
		misfit = np.sqrt(c) / row['gps_horiz_acc']
		sum = sum + misfit
		# print angle, index, misfit
	plt.scatter(df['x_working'], df['y_working'], color='orange')
	print angle, sum
	return sum

def box(latlng_origin=None, pid_origin=None, width=15, height=15):
    """
    Returns a validator function of Panorama that returns True is
    the Panorama is inside a box of the size w,h around center
    point latlng_0.
    :param latlng_origin: tuple (lat, lng) - center GPS
    :param w: float - width in meters
    :param h: float - height in meters
    :return: validator(Panorama) - given a Panorama it returns True
             if the panorama is inside the box
    """
    if latlng_origin:
        (easting, northing, z_number, z_letter) = utm.from_latlon(latlng_origin[0], latlng_origin[1])
    elif pid_origin:
        latlng_origin = Panorama(pid_origin).getGPS()
        (easting, northing, z_number, z_letter) = utm.from_latlon(latlng_origin[0], latlng_origin[1])
    else:
        raise ValueError("One of the arguments 'latlang_origin' or 'pid_origin' must be given.")


    def isClose(p):
        ll = p.getGPS()
        (est, nth, zn, zl) = utm.from_latlon(ll[0], ll[1], force_zone_number=z_number)
        x, y = est-easting, nth-northing
        return abs(x) < w/2 and abs(y) < h/2
    return isClose

def distance_2d(lon1, lat1, lon2, lat2):
    ym1, xm1, _, _ = utm.from_latlon(lat1, lon1)
    ym2, xm2, _, _ = utm.from_latlon(lat2, lon2)

    arr1 = numpy.array((xm1, ym1))
    arr2 = numpy.array((xm2, ym2))

    dist = numpy.linalg.norm(arr1-arr2)
    return dist

def latlon_to_meters(coord_list, origin):
    # Convert coord_list to UTM
    coord_list[:] = [utm.from_latlon(*coord) for coord in coord_list]

    # Convert origin to UTM
    origin = utm.from_latlon(*origin)

    # Convert coord_list to meters relative to origin
    coord_list[:] = [(coord[0] - origin[0], coord[1] - origin[1])
                     for coord in coord_list]

def calc_utm_distance(lat1, lon1, lat2, lon2):
	"""
	Returns distance in millimeters
	"""
	point1 = utm.from_latlon(lat1, lon1)
	point2 = utm.from_latlon(lat2, lon2)
	
	x = point2[1]-point1[1]
	y = point2[2]-point1[2]
	
	return 1000*math.sqrt(x*x+y*y)

def getPolygon(row,coordinateDir,coordinateFileName):
    polygonData = openCSVFile(coordinateDir+coordinateFileName)   
    UTM1 = utm.from_latlon(float(polygonData[row][0]),float(polygonData[row][1]))
    UTM1 = [UTM1[0],UTM1[1]]
    UTM2 = utm.from_latlon(float(polygonData[row][2]),float(polygonData[row][3]))
    UTM2 = [UTM2[0],UTM2[1]]
    UTM3 = utm.from_latlon(float(polygonData[row][4]),float(polygonData[row][5]))
    UTM3 = [UTM3[0],UTM3[1]]
    UTM4 = utm.from_latlon(float(polygonData[row][6]),float(polygonData[row][7]))
    UTM4 = [UTM4[0],UTM4[1]]
    return Polygon([(UTM1[0],UTM1[1]),(UTM2[0],UTM2[1]),(UTM3[0],UTM3[1]),(UTM4[0],UTM4[1])])

def events():
  """Gets isc data."""
  missing_params = []
  for p in ['lat', 'lon', 'distance', 'start', 'end', 'mag', 'catalog']:
    if p not in request.args:
      missing_params.append(p)
  if missing_params:
    return 'Missing parameters: {}'.format(','.join(missing_params))

  start = datetime.datetime.strptime(request.args.get('start'),
                                     DATE_FORMAT)
  end = datetime.datetime.strptime(request.args.get('end'),
                                   DATE_FORMAT)
  time_delta = end - start
  logging.info('Start Time {}'.format(start))
  logging.info('End Time {}'.format(end))
  logging.info('Time Delta {}'.format(time_delta))

  # Read the isc data.
  isc_data = isc.ReadISCData('gs://clouddfe-cfs/isc',
                             request.args.get('catalog'),
                             start, abs(time_delta.days),
                             (long(request.args.get('lat')),
                              long(request.args.get('lon'))),
                             int(request.args.get('distance')))

  # Prepare the ISC data by:
  #   1) Filtering out magnitude events smaller than specified.
  #   2) Projecting the lat/lon to UTM.
  ret = []
  _, _, num, let = utm.from_latlon(float(request.args.get('lat')),
                                   float(request.args.get('lon')))
  proj = lambda lat, lon: utm.from_latlon(lat, lon, num)[0:2]
  mag = float(request.args.get('mag'))
  num_filtered = 0
  for data in isc_data:
    if data['magnitude'] < mag:
      num_filtered += 1
      continue
    x, y = proj(data['lat'], data['lon'])
    ret.append({
        'lat': data['lat'],
        'lon': data['lon'],
        'utm_x': x,
        'utm_y': y,
        'depth': data['depth'],
        'mag': data['magnitude'],
        'date': data['date_time'].isoformat(' '),  # YYYY-MM-DD HH:MM:SS
    })
  logging.info('Filtered (%d) ISC events due to magnitude', num_filtered)

  if 'callback' in request.args:
    return '{}({})'.format(request.args.get('callback'), json.dumps(ret))
  return json.dumps(ret)

def get_distance(origin_lat, origin_lng, dest_lat, dest_lng):	
	xy = utm.from_latlon(origin_lat, origin_lng) # convert origin from lat-lng to xy
	originXY = point(float(xy[0]), float(xy[1]))
	
	xy = utm.from_latlon(dest_lat, dest_lng) # convert destination from lat-lng to xy
	destinationXY = point(float(xy[0]), float(xy[1]))

	distance = math.sqrt((originXY.x - destinationXY.x) ** 2 + (originXY.y - destinationXY.y) ** 2)
	res = [(destinationXY.x - originXY.x) * 4, (destinationXY.y - originXY.y) * 4]
	# print res
	return res # return the distance vector

def calc_utm_distance(lat1, lon1, lat2, lon2):
	"""
	Returns distance in millimeters
	This is not currently used in any of the code. Left for now in case needed
	"""
	point1 = utm.from_latlon(lat1, lon1)
	point2 = utm.from_latlon(lat2, lon2)

	x = point2[1]-point1[1]
	y = point2[2]-point1[2]

	return 1000*math.sqrt(x*x+y*y)

def calc_list_core( l_points, EP, func_fretch ):
    npos1 = 0
    npos2 = 0
    npos3 = 0
    list_count = len(l_points)

    ret_list = {}
    ret_list[3]=[]
    ret_list[5]=[]

    while npos1 < list_count - 2:
        try:
            la1, lo1, dis1 = func_fretch(l_points[npos1])
            npos1 = npos1 + 1
            if not la1 or not lo1 or not dis1:
                continue
            u1 = utm_point(*utm.from_latlon(la1,lo1), r=int(dis1))
        except Exception as e:
            continue

        npos2 = npos1
        while npos2 < list_count - 1:
            try:
                la2, lo2, dis2 = func_fretch(l_points[npos2])
                npos2 = npos2 + 1
                if not la2 or not lo2 or not dis2:
                    continue
                u2 = utm_point( *utm.from_latlon(la2,lo2), r=int(dis2))
            except Exception as e:
                continue

            s, p1, p2 = calc_cross_point(u1, u2)
            if not p1 or not p2:
                continue



            npos3 = npos2
            while npos3 < list_count:
                try:
                    la3, lo3, dis3 = func_fretch(l_points[npos3])
                    npos3 = npos3 + 1
                    if not la3 or not lo3 or not dis3:
                        continue
                    u3 = utm_point( *utm.from_latlon(la3,lo3), r=int(dis3))
                except Exception as e:
                    continue
                
                ret, level = calc_list_core_cross_point(s, p1, p2, u3, EP)
                if ret:
                    return ret, level
    return None, 0

def calc( latitude1, longitude1, r1,
              latitude2, longitude2, r2,
              latitude3, longitude3, r3, EP = global_EP):
    try:
        u1 = utm_point( *utm.from_latlon(latitude1,longitude1), r=r1)
        u2 = utm_point( *utm.from_latlon(latitude2,longitude2), r=r2)
        u3 = utm_point( *utm.from_latlon(latitude3,longitude3), r=r3)
    except Exception as e:
        return None

    pr = calc_distance_utm(u1,u2,u3, EP)
    if pr:
        latitude, longitude = utm.to_latlon(pr.x, pr.y, pr.zone, pr.mark)
        return latitude, longitude, pr.r
    return None