diff options
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | python-global-land-mask.spec | 531 | ||||
| -rw-r--r-- | sources | 1 |
3 files changed, 533 insertions, 0 deletions
@@ -0,0 +1 @@ +/global-land-mask-1.0.0.tar.gz diff --git a/python-global-land-mask.spec b/python-global-land-mask.spec new file mode 100644 index 0000000..0a63a35 --- /dev/null +++ b/python-global-land-mask.spec @@ -0,0 +1,531 @@ +%global _empty_manifest_terminate_build 0 +Name: python-global-land-mask +Version: 1.0.0 +Release: 1 +Summary: Check whether a lat/lon point in on land or on sea +License: MIT License +URL: https://github.com/toddkarin/global-land-mask +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/6e/cd/d06fe252cbe41b85c7a1a54e4d4214c79b770eb5d6c6fa3b03e56371a6da/global-land-mask-1.0.0.tar.gz +BuildArch: noarch + + +%description +# global-land-mask +Check whether a lat/lon point is on land for any point on earth. + +<img src="https://github.com/toddkarin/global-land-mask/blob/master/example_plot_globe_map_us.png" width="200"> + +# Install + +Install using pip: +```bash +pip install global-land-mask +``` + +Requirements: +- numpy + +# Description +This python module, global-land-mask, contains scripts for checking whether a lat/lon point is on land or sea. In order to do this, we use the GLOBE dataset, which samples the entire earth at 1 km resolution. We then simply extract all 'invalid' values from this elevation map and save to file. + +The global mask is of shape (21600, 43200), equating to about 980 mB when saved without compression. This data can be compressed to 2.5 mb using numpy savez_compressed, making for a very compact package. + +The raw elevation data from the GLOBE dataset can be downloaded from +https://www.ngdc.noaa.gov/mgg/topo/gltiles.html +It is not necessary to download this data in order to use the global land mask. However, the user can build a global elevation dataset using the exampel scripts provided. + +This package provides globe.is_land(), an alaternative to Basemap.is_land(). For 10,000 data points, globe.is_land is around 6000 times faster than Basemap.is_land. + +The function globe.is_land uses a nearest-neighbor lookup on a regular grid. + + + +# Simple example + +Here is a simple example showing the use of global_land_mask to check if lat/lon points are on land. +```python +from global_land_mask import globe +import numpy as np + +# Check if a point is on land: +lat = 40 +lon = -120 +is_on_land = globe.is_land(lat, lon) + +print('lat={}, lon={} is on land: {}'.format(lat,lon,is_on_land)) +# lat=40, lon=-120 is on land: True + +# Check if several points are in the ocean +lat = 40 +lon = np.linspace(-150,-110,3) +is_in_ocean = globe.is_ocean(lat, lon) +print('lat={}, lon={} is in ocean: {}'.format(lat,lon,is_in_ocean)) +# lat=40, lon=[-150. -130. -110.] is in ocean: [ True True False] + +``` + +# Speed test + +Compare performance of global_land_mask and Basemap. +```python +from global_land_mask import globe +from mpl_toolkits.basemap import Basemap +import matplotlib +matplotlib.use('TkAgg') +import numpy as np +import time + + +# Lat/lon points to get +lat = np.linspace(-20,50,100) +lon = np.linspace(-130,-70,100) + +# Make a grid +lon_grid, lat_grid = np.meshgrid(lon,lat) + +# Get whether the points are on land using globe.is_land +start_time = time.time() +globe_land_mask = globe.is_land(lat_grid, lon_grid) +globe_run_time = time.time()-start_time +print('Time to run globe.is_land(): {}'.format(globe_run_time)) + +# Get whether the points are on land using Basemap.is_land +# bm = Basemap(projection='cyl',resolution='i') +bm = Basemap(projection='cyl', llcrnrlat=-60, urcrnrlat=90, \ + llcrnrlon=-180, urcrnrlon=180, resolution='c') +f = np.vectorize(bm.is_land) + +start_time = time.time() +xpt, ypt = bm( lon_grid, lat_grid) +basemap_land_mask = f(xpt,ypt) +basemap_run_time = time.time()-start_time +print('Time to run Basemap.is_land(): {}'.format(basemap_run_time)) + +print('Speed up: {}'.format(basemap_run_time/globe_run_time)) + +# Check agreement (note there is a different treatment for lakes +fraction_agreed = np.sum(globe_land_mask == basemap_land_mask)/len(globe_land_mask.flatten()) +print('Fraction agreeing: {}'.format(fraction_agreed)) +``` + +# Example of map over US + +Try running + +```python +from global_land_mask import globe +from mpl_toolkits.basemap import Basemap +import numpy as np +import matplotlib +matplotlib.use('TkAgg') +import matplotlib.pyplot as plt + + +# Lat/lon points to get +lat = np.linspace(-20,90,1000) +lon = np.linspace(-130,-60,1002) + +# Make a grid +lon_grid, lat_grid = np.meshgrid(lon,lat) + +# Get whether the points are on land. +z = globe.is_land(lat_grid, lon_grid) + +# Set up map +fig = plt.figure(0, figsize=(5.5, 4.5)) +plt.clf() +ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) + +m = Basemap(llcrnrlon=-119, llcrnrlat=22, urcrnrlon=-64, urcrnrlat=49, + projection='lcc', lat_1=33, lat_2=45, lon_0=-95, + area_thresh=200, + resolution='i') +m.drawstates(linewidth=0.2) +m.drawcoastlines(linewidth=0.2) +m.drawcountries(linewidth=0.2) + + +cs = m.contourf(lon_grid, lat_grid, z, + levels=[-0.5, 0.5,1.5], + cmap="jet", + latlon=True) +plt.show() + +plt.savefig('example_plot_globe_map_us.png', + bbox_inches='tight', + dpi=400) + +``` + +to create the binary mask for the US, shown in the image below: + + + +Note that lakes are included as "on land" and the resolution isn't perfect, but it's good enough for many purposes! + + + +%package -n python3-global-land-mask +Summary: Check whether a lat/lon point in on land or on sea +Provides: python-global-land-mask +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-global-land-mask +# global-land-mask +Check whether a lat/lon point is on land for any point on earth. + +<img src="https://github.com/toddkarin/global-land-mask/blob/master/example_plot_globe_map_us.png" width="200"> + +# Install + +Install using pip: +```bash +pip install global-land-mask +``` + +Requirements: +- numpy + +# Description +This python module, global-land-mask, contains scripts for checking whether a lat/lon point is on land or sea. In order to do this, we use the GLOBE dataset, which samples the entire earth at 1 km resolution. We then simply extract all 'invalid' values from this elevation map and save to file. + +The global mask is of shape (21600, 43200), equating to about 980 mB when saved without compression. This data can be compressed to 2.5 mb using numpy savez_compressed, making for a very compact package. + +The raw elevation data from the GLOBE dataset can be downloaded from +https://www.ngdc.noaa.gov/mgg/topo/gltiles.html +It is not necessary to download this data in order to use the global land mask. However, the user can build a global elevation dataset using the exampel scripts provided. + +This package provides globe.is_land(), an alaternative to Basemap.is_land(). For 10,000 data points, globe.is_land is around 6000 times faster than Basemap.is_land. + +The function globe.is_land uses a nearest-neighbor lookup on a regular grid. + + + +# Simple example + +Here is a simple example showing the use of global_land_mask to check if lat/lon points are on land. +```python +from global_land_mask import globe +import numpy as np + +# Check if a point is on land: +lat = 40 +lon = -120 +is_on_land = globe.is_land(lat, lon) + +print('lat={}, lon={} is on land: {}'.format(lat,lon,is_on_land)) +# lat=40, lon=-120 is on land: True + +# Check if several points are in the ocean +lat = 40 +lon = np.linspace(-150,-110,3) +is_in_ocean = globe.is_ocean(lat, lon) +print('lat={}, lon={} is in ocean: {}'.format(lat,lon,is_in_ocean)) +# lat=40, lon=[-150. -130. -110.] is in ocean: [ True True False] + +``` + +# Speed test + +Compare performance of global_land_mask and Basemap. +```python +from global_land_mask import globe +from mpl_toolkits.basemap import Basemap +import matplotlib +matplotlib.use('TkAgg') +import numpy as np +import time + + +# Lat/lon points to get +lat = np.linspace(-20,50,100) +lon = np.linspace(-130,-70,100) + +# Make a grid +lon_grid, lat_grid = np.meshgrid(lon,lat) + +# Get whether the points are on land using globe.is_land +start_time = time.time() +globe_land_mask = globe.is_land(lat_grid, lon_grid) +globe_run_time = time.time()-start_time +print('Time to run globe.is_land(): {}'.format(globe_run_time)) + +# Get whether the points are on land using Basemap.is_land +# bm = Basemap(projection='cyl',resolution='i') +bm = Basemap(projection='cyl', llcrnrlat=-60, urcrnrlat=90, \ + llcrnrlon=-180, urcrnrlon=180, resolution='c') +f = np.vectorize(bm.is_land) + +start_time = time.time() +xpt, ypt = bm( lon_grid, lat_grid) +basemap_land_mask = f(xpt,ypt) +basemap_run_time = time.time()-start_time +print('Time to run Basemap.is_land(): {}'.format(basemap_run_time)) + +print('Speed up: {}'.format(basemap_run_time/globe_run_time)) + +# Check agreement (note there is a different treatment for lakes +fraction_agreed = np.sum(globe_land_mask == basemap_land_mask)/len(globe_land_mask.flatten()) +print('Fraction agreeing: {}'.format(fraction_agreed)) +``` + +# Example of map over US + +Try running + +```python +from global_land_mask import globe +from mpl_toolkits.basemap import Basemap +import numpy as np +import matplotlib +matplotlib.use('TkAgg') +import matplotlib.pyplot as plt + + +# Lat/lon points to get +lat = np.linspace(-20,90,1000) +lon = np.linspace(-130,-60,1002) + +# Make a grid +lon_grid, lat_grid = np.meshgrid(lon,lat) + +# Get whether the points are on land. +z = globe.is_land(lat_grid, lon_grid) + +# Set up map +fig = plt.figure(0, figsize=(5.5, 4.5)) +plt.clf() +ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) + +m = Basemap(llcrnrlon=-119, llcrnrlat=22, urcrnrlon=-64, urcrnrlat=49, + projection='lcc', lat_1=33, lat_2=45, lon_0=-95, + area_thresh=200, + resolution='i') +m.drawstates(linewidth=0.2) +m.drawcoastlines(linewidth=0.2) +m.drawcountries(linewidth=0.2) + + +cs = m.contourf(lon_grid, lat_grid, z, + levels=[-0.5, 0.5,1.5], + cmap="jet", + latlon=True) +plt.show() + +plt.savefig('example_plot_globe_map_us.png', + bbox_inches='tight', + dpi=400) + +``` + +to create the binary mask for the US, shown in the image below: + + + +Note that lakes are included as "on land" and the resolution isn't perfect, but it's good enough for many purposes! + + + +%package help +Summary: Development documents and examples for global-land-mask +Provides: python3-global-land-mask-doc +%description help +# global-land-mask +Check whether a lat/lon point is on land for any point on earth. + +<img src="https://github.com/toddkarin/global-land-mask/blob/master/example_plot_globe_map_us.png" width="200"> + +# Install + +Install using pip: +```bash +pip install global-land-mask +``` + +Requirements: +- numpy + +# Description +This python module, global-land-mask, contains scripts for checking whether a lat/lon point is on land or sea. In order to do this, we use the GLOBE dataset, which samples the entire earth at 1 km resolution. We then simply extract all 'invalid' values from this elevation map and save to file. + +The global mask is of shape (21600, 43200), equating to about 980 mB when saved without compression. This data can be compressed to 2.5 mb using numpy savez_compressed, making for a very compact package. + +The raw elevation data from the GLOBE dataset can be downloaded from +https://www.ngdc.noaa.gov/mgg/topo/gltiles.html +It is not necessary to download this data in order to use the global land mask. However, the user can build a global elevation dataset using the exampel scripts provided. + +This package provides globe.is_land(), an alaternative to Basemap.is_land(). For 10,000 data points, globe.is_land is around 6000 times faster than Basemap.is_land. + +The function globe.is_land uses a nearest-neighbor lookup on a regular grid. + + + +# Simple example + +Here is a simple example showing the use of global_land_mask to check if lat/lon points are on land. +```python +from global_land_mask import globe +import numpy as np + +# Check if a point is on land: +lat = 40 +lon = -120 +is_on_land = globe.is_land(lat, lon) + +print('lat={}, lon={} is on land: {}'.format(lat,lon,is_on_land)) +# lat=40, lon=-120 is on land: True + +# Check if several points are in the ocean +lat = 40 +lon = np.linspace(-150,-110,3) +is_in_ocean = globe.is_ocean(lat, lon) +print('lat={}, lon={} is in ocean: {}'.format(lat,lon,is_in_ocean)) +# lat=40, lon=[-150. -130. -110.] is in ocean: [ True True False] + +``` + +# Speed test + +Compare performance of global_land_mask and Basemap. +```python +from global_land_mask import globe +from mpl_toolkits.basemap import Basemap +import matplotlib +matplotlib.use('TkAgg') +import numpy as np +import time + + +# Lat/lon points to get +lat = np.linspace(-20,50,100) +lon = np.linspace(-130,-70,100) + +# Make a grid +lon_grid, lat_grid = np.meshgrid(lon,lat) + +# Get whether the points are on land using globe.is_land +start_time = time.time() +globe_land_mask = globe.is_land(lat_grid, lon_grid) +globe_run_time = time.time()-start_time +print('Time to run globe.is_land(): {}'.format(globe_run_time)) + +# Get whether the points are on land using Basemap.is_land +# bm = Basemap(projection='cyl',resolution='i') +bm = Basemap(projection='cyl', llcrnrlat=-60, urcrnrlat=90, \ + llcrnrlon=-180, urcrnrlon=180, resolution='c') +f = np.vectorize(bm.is_land) + +start_time = time.time() +xpt, ypt = bm( lon_grid, lat_grid) +basemap_land_mask = f(xpt,ypt) +basemap_run_time = time.time()-start_time +print('Time to run Basemap.is_land(): {}'.format(basemap_run_time)) + +print('Speed up: {}'.format(basemap_run_time/globe_run_time)) + +# Check agreement (note there is a different treatment for lakes +fraction_agreed = np.sum(globe_land_mask == basemap_land_mask)/len(globe_land_mask.flatten()) +print('Fraction agreeing: {}'.format(fraction_agreed)) +``` + +# Example of map over US + +Try running + +```python +from global_land_mask import globe +from mpl_toolkits.basemap import Basemap +import numpy as np +import matplotlib +matplotlib.use('TkAgg') +import matplotlib.pyplot as plt + + +# Lat/lon points to get +lat = np.linspace(-20,90,1000) +lon = np.linspace(-130,-60,1002) + +# Make a grid +lon_grid, lat_grid = np.meshgrid(lon,lat) + +# Get whether the points are on land. +z = globe.is_land(lat_grid, lon_grid) + +# Set up map +fig = plt.figure(0, figsize=(5.5, 4.5)) +plt.clf() +ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) + +m = Basemap(llcrnrlon=-119, llcrnrlat=22, urcrnrlon=-64, urcrnrlat=49, + projection='lcc', lat_1=33, lat_2=45, lon_0=-95, + area_thresh=200, + resolution='i') +m.drawstates(linewidth=0.2) +m.drawcoastlines(linewidth=0.2) +m.drawcountries(linewidth=0.2) + + +cs = m.contourf(lon_grid, lat_grid, z, + levels=[-0.5, 0.5,1.5], + cmap="jet", + latlon=True) +plt.show() + +plt.savefig('example_plot_globe_map_us.png', + bbox_inches='tight', + dpi=400) + +``` + +to create the binary mask for the US, shown in the image below: + + + +Note that lakes are included as "on land" and the resolution isn't perfect, but it's good enough for many purposes! + + + +%prep +%autosetup -n global-land-mask-1.0.0 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-global-land-mask -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Wed May 10 2023 Python_Bot <Python_Bot@openeuler.org> - 1.0.0-1 +- Package Spec generated @@ -0,0 +1 @@ +ceca68dd5436bb5876ace2e791d0d70c global-land-mask-1.0.0.tar.gz |