def testLargeArrayConversion(self): """ Test that we don't get segmentation fault: 11 on large (1MM points) arrays using Ctypes """ # UK bounding box N = 55.811741 E = 1.768960 S = 49.871159 W = -6.379880 num_coords = 1000000 lon_ls = list(np.random.uniform(W, E, [num_coords])) lat_ls = list(np.random.uniform(S, N, [num_coords])) convert_bng(lon_ls, lat_ls)
def testNumpyConversion(self): """ Test lon, lat --> BNG conversion of numpy arrays """ # UK bounding box N = 55.811741 E = 1.768960 S = 49.871159 W = -6.379880 num_coords = 1000 lon_arr = np.random.uniform(W, E, [num_coords]) lat_arr = np.random.uniform(S, N, [num_coords]) convert_bng(lon_arr, lat_arr)
def testConvertLonLat(self): """ Test multithreaded lon, lat --> BNG function """ expected = ([516274.46, 398915.554], [173141.101, 521544.09]) result = convert_bng([-0.32824866, -2.0183041005533306], [51.44533267, 54.589097162646141]) self.assertEqual(expected, result)
def get_nearest_in_area(X, Y, points, radius=10, n_points=10, latlon=True, json_output=True): # If input is in lat long (WGS84), convert to metre (BGS36) if latlon == True: result = convert_bng(X, Y) X, Y = [elem[0] for elem in result] # Limit search area. Not really 10 metre radius, but close. This makes the code # run faster as limit distance computations cond = (points['X'] < X + radius)\ & (points['X'] > X - radius)\ & (points['Y'] < Y + radius)\ & (points['Y'] > Y - radius) # Compute distance from the requested points to all points in the search space in_radius = points[cond].copy() in_radius['distance'] = np.sqrt((in_radius['X'] - X)**2 + (in_radius['Y'] - Y)**2) # Get n closest points, order by distance, nearest first selected = in_radius.sort_values('distance').head(n_points) # select only relevant columns selected = selected[['ID', 'X', 'Y', 'distance', 'elevation', 'SewerUsage']] # # Give json string to feed to other apps if json_output: selected = selected.to_json(orient='records') return selected
def do_GET(self): split = parse.urlsplit(self.path) print('path = ', split.path) params = parse.parse_qs(split.query) if params.get('test') is not None: self.serve_test_page() elif (split.path == '/map' or split.path == '/map/') and params.get( 'northing') is not None and params.get('easting') is not None: self.serve_map_page(params['easting'], params['northing'], True, float(params['tempmin'][0]), float(params['tempmax'][0]), float(params['tempmean'][0]), float(params['rainfall'][0]), params['date'][0]) elif (split.path == '/map' or split.path == '/map/'): if params.get('latitude') is not None and params.get( 'longitude') is not None: centre = convert_bng([float(params['longitude'][0])], [float(params['latitude'][0])]) self.serve_map_page(centre[0], centre[1], True, float(params['tempmin'][0]), float(params['tempmax'][0]), float(params['tempmean'][0]), float(params['rainfall'][0]), params['date'][0]) else: self.serve_map_page([888887], [777773], False, 0, 0, 0, 0, '') elif split.path == '/home' or split.path == '/home/': self.serve_home_page() else: self.serve_default_page(params)
def testGenerator(self): """ Test that the lon, lat -> BNG function can consume generators """ expected = ([516274.46, 398915.554], [173141.101, 521544.09]) inp = [[-0.32824866, -2.0183041005533306], [51.44533267, 54.589097162646141]] lon_generator = (n for n in inp[0]) lat_generator = (n for n in inp[1]) result = convert_bng(lon_generator, lat_generator) self.assertEqual(expected, result)
def testCythonConsistency(self): """ Ensure Ctypes and Cython give same results """ # London bounding box N = 51.691874116909894 E = 0.3340155643740321 S = 51.28676016315085 W = -0.5103750689005356 num_coords = 100 rand = randrange(0, 100) lon_ls = np.random.uniform(W, E, [num_coords]) lat_ls = np.random.uniform(S, N, [num_coords]) # result is a list, so convert to an array. Ugh. res_ctypes = np.array(convert_bng(lon_ls, lat_ls)[0][rand]) res_cython = cconvert_bng(lon_ls, lat_ls)[0][rand] self.assertEqual(res_ctypes, res_cython)
def lat_lon_to_north_east(lat, lon): """ The Geo::Coordinates::OSGB description of ll_to_grid, which was used in the original implementation of this function: ll_to_grid translates a latitude and longitude pair into a grid easting and northing pair. The arguments should be supplied as real numbers representing decimal degrees. Following the normal mathematical convention, positive arguments mean North or East, negative South or West. Assumes that the lat/long are WGS84. :param lat: latitude in decimal degrees :param lon: longitude in decimal degrees :return: (n, e) grid easting and northing pair as a 2-tuple """ # Convert from lat/lon into OSGB easts, norths = convert_bng(lon, lat) return norths[0], easts[0]
def plot_maps(self, number_of_systems=None, _title="25,000 Systems", version=0, scale=500): """Plot map of passiv systems""" if number_of_systems is None: _data = self.data else: _data = self.data.sample(number_of_systems) _data.sort_values(by="kwp", axis=0, inplace=True) res_list = convert_bng(_data.longitude.values.tolist(), _data.latitude.values.tolist()) fig, ax = plt.subplots(figsize=(6, 12)) ax = plt.axes(projection=ccrs.OSGB()) ax.set_extent([1393.0196, 671196.3657, 13494.9764, 1230275.0454], crs=ccrs.OSGB()) ax.coastlines(resolution='50m') ax.gridlines() ax.set_title(_title, fontsize=18) marker_scale = _data.kwp.values sc = ax.scatter(res_list[0], res_list[1], c=marker_scale, s=10, marker="o", cmap="Spectral") clb = plt.colorbar(sc) clb.ax.set_title("kWp") fig_name = "../graphs/passiv_map_{}_{}.png".format( number_of_systems, version) fig.savefig(fig_name, bbbbox_inches="tight", dpi=600, transparent=True) plt.show() return fig
def getEastingNorthing(lat, long): return convert_bng(long, lat)
def testConvertArray(self): """ Test lon, lat --> BNG conversion of array.array """ expected = ([651409.804], [313177.45]) result = convert_bng(array.array("d", [1.716073973]), array.array("d", [52.658007833])) self.assertEqual(expected, result)
def testConvertIterable(self): """ Test lon, lat --> BNG conversion of tuples """ expected = ([651409.804], [313177.45]) result = convert_bng(iter([1.7160739736]), iter([52.658007833])) self.assertEqual(expected, result)
def testConvertString(self): """ Test that an error is thrown for incorrect types """ with self.assertRaises(ArgumentError) as result: convert_bng(["Foo"], ["Bar"])
def testConvertTuple(self): """ Test lon, lat --> BNG conversion of tuples """ expected = ([651409.804], [313177.45]) result = convert_bng((1.716073973,), (52.658007833,)) self.assertEqual(expected, result)
def testConvertLonLatSingle(self): """ Test lon, lat --> BNG conversion of single values """ expected = ([651409.804], [313177.45]) result = convert_bng(1.716073973, 52.658007833) self.assertEqual(expected, result)
def testConvertString(self): """ Test that an error is thrown for incorrect types """ with self.assertRaises(ArgumentError) as result: convert_bng(['Foo'], ['Bar'])
def lola2en(lon: list, lat: list): lon = np.array(lon) lat = np.array(lat) return convert_bng(lon, lat)
def testConvertArray(self): """ Test lon, lat --> BNG conversion of array.array """ expected = ([651409.804], [313177.45]) result = convert_bng(array.array('d', [1.716073973]), array.array('d', [52.658007833])) self.assertEqual(expected, result)
import numpy as np from convertbng.util import convert_bng # London bounding box N = 51.691874116909894 E = 0.3340155643740321 S = 51.28676016315085 W = -0.5103750689005356 num_coords = 1000000 lon_ls = np.random.uniform(W, E, [num_coords]) lat_ls = np.random.uniform(S, N, [num_coords]) if __name__ == "__main__": for x in xrange(50): convert_bng(lon_ls, lat_ls)
def testConvertTuple(self): """ Test lon, lat --> BNG conversion of tuples """ expected = ([651409.804], [313177.45]) result = convert_bng((1.716073973, ), (52.658007833, )) self.assertEqual(expected, result)