def test_arr_parameter():
"""Raise an AttributeError if an array is not provided."""
with pytest.raises(
AttributeError, match="Input arr should be a numpy array"
):
ep.plot_bands(arr=(1, 2))
plt.close()
def NDVI(bands, year):
"""Normalized Difference Vegetation Index (NDVI)"""
#ndvi = es.normalized_diff(band4, band3) # (band4-band3)/(band4+band3)
ndvi = es.normalized_diff(bands[3], bands[2]) # (band4-band3)/(band4+band3)
titles = ['Normalized Difference Vegetation Index (NDVI) Year: %s' %year]
# Turn off bytescale scaling due to float values for NDVI
ep.plot_bands(ndvi, cmap="RdYlGn", cols=1, title=titles, vmin=-1, vmax=1)
# Create classes and apply to NDVI results
ndvi_class_bins = [-np.inf, 0, 0.25, 0.5, 0.75, np.inf]
ndvi_landsat_class = np.digitize(ndvi, ndvi_class_bins)
# Define color map and class names
ndvi_colors = ListedColormap(['gray', 'y', 'yellowgreen', 'g', 'darkgreen'])
ndvi_names = ['0.00 No Vegetation','0.25 Bare Area','0.50 Low Vegetation','0.75 Moderate Vegetation','1.00 High Vegetation']
# Get list of classes
classes = np.unique(ndvi_landsat_class).tolist()
fig, ax = plt.subplots(figsize=(8, 8))
im = ax.imshow(ndvi_landsat_class, cmap=ndvi_colors)
ep.draw_legend(im_ax=im, classes=classes, titles=ndvi_names)
ax.set_title('Normalized Difference Vegetation Index (NDVI) Classes. \nYear: %s' %yr,fontsize=14)
ax.set_axis_off(); plt.tight_layout()
plt.show()
def plot_cropped_raster():
# Plot your data
ep.plot_bands(raster_crop[2],
extent=raster_extent,
cmap='Greys',
title="Cropped Raster Dataset",
scale=False)
plt.show()
def show_map(self):
print("Huglin Index of combined Hemispheres")
ep.plot_bands(self.south_huglin_dataset,
cmap='PiYG',
scale=False,
vmin=self.south_huglin_min,
vmax=self.south_huglin_max)
return
def test_num_titles(image_array_2bands):
"""Test the number of titles.
If a user provides two titles for a single band array, the function
should raise an error OR if the title list is a different length than
the array it should also raise an errors.
"""
single_band = image_array_2bands[0]
with pytest.raises(ValueError):
ep.plot_bands(arr=single_band, title=["Title1", "Title2"])
with pytest.raises(ValueError):
ep.plot_bands(arr=image_array_2bands,
title=["Title1", "Title2", "Title3"])
def plot_crop_overlayed_on_raster():
fig, ax = plt.subplots(figsize=(10, 8))
ep.plot_bands(raster.read(1),
cmap='terrain',
extent=plotting_extent(raster),
ax=ax,
title="Raster Layer with Shapefile Overlayed",
cbar=False)
crop_extent.plot(ax=ax, alpha=.8)
ax.set_axis_off()
plt.show()
def test_multi_panel_single_band(one_band_3dims):
"""Test that multi panel works with single band arr."""
title1 = "Title axis one"
title2 = "Title axis two"
f, (ax1, ax2) = plt.subplots(2, 1)
ep.plot_bands(one_band_3dims, title=title1, ax=ax1)
ep.plot_bands(one_band_3dims, title=title2, ax=ax2)
# get all axis subplot elements - note this returns subplots and axes
all_axes = f.axes
assert len(all_axes) == 4
assert all_axes[0].get_title() == title1
assert all_axes[1].get_title() == title2
def test_custom_plot_title(image_array_2bands):
"""Test that the custom title is applied for a 2 band array plot."""
ax = ep.plot_bands(image_array_2bands, title=["Red Band", "Green Band"])
num_plts = image_array_2bands.shape[0]
all_titles = [ax[i].get_title() for i in range(num_plts)]
assert all_titles == ["Red Band", "Green Band"]
plt.close()
def test_norm_scale_unset(image_array_2bands):
"""Test that the norm param returns a plot with the correct norm boundaries."""
norm_bounds = colors.BoundaryNorm([0, 1], 2)
norm_ax = ep.plot_bands(image_array_2bands, cols=2, norm=norm_bounds)
for axes in norm_ax:
assert norm_bounds.boundaries[0] == axes.get_images()[0].norm.vmin
assert norm_bounds.boundaries[1] == axes.get_images()[0].norm.vmax
def test_two_plot_title(image_array_2bands):
"""Test that the default title is provided for a 2 band array plot."""
ax = ep.plot_bands(image_array_2bands)
num_plts = image_array_2bands.shape[0]
all_titles = [ax[i].get_title() for i in range(num_plts)]
assert all_titles == ["Band 1", "Band 2"]
plt.close()
def test_str_for_title(image_array_2bands):
"""Test that a single string title renders properly."""
single_band = image_array_2bands[0]
ax = ep.plot_bands(arr=single_band, title="my title")
plot_title = ax.get_title()
assert "my title" in plot_title
plt.close()
def test_num_axes(image_array_2bands):
"""Test the number of axes.
If provided with a 2 band array, plot_bands should return 3 axes.
"""
f, ax = ep.plot_bands(image_array_2bands)
assert len(f.axes) == 3
plt.close(f)
def test_single_band_3dims(one_band_3dims):
"""Test single band plot with three dimensions.
If you provide a single band array with 3 dimensions (shape[0]==1
test that it still plots and only returns a single axis.
"""
ax = ep.plot_bands(one_band_3dims)
arr = ax.get_images()[0].get_array()
assert arr.ndim == 2
assert len(ax.get_images()) == 1
plt.close()
def test_cbar_param(one_band_3dims):
"""Test that the colorbar param works for a single band arr"""
one_band_2dims = one_band_3dims[0]
ax = ep.plot_bands(one_band_2dims, scale=True)
arr = ax.get_images()[0].get_array()
c_bar = ax.images[0].colorbar
# Return arr should be scaled by default between 0-255
assert arr.min() == 0 and arr.max() == 255
# A cbar should be drawn in this plot
assert c_bar
plt.close()
def tif_2index(file,output,vindex):
naip_data = rxr.open_rasterio(file)
# View shape of the data
print(naip_data.shape)
if naip_data.[3] is not None:
NIR = naip_data[3]
else:
pass
R = naip_data[0]
G = naip_data[1]
B = naip_data[2]
if vindex == 'NDVI':
naip_ndvi = NDVI_index(NIR, R)
elif vindex == 'VARI' or 'RGBVI' or 'NGRDI':
naip_ndvi = VARI_index(R,G,B,vindex)
#Plot bands
ep.plot_bands(naip_ndvi,
cmap='PiYG',
scale=False,
vmin=-1, vmax=1,
title=" Vegetation Index plot")
plt.show()
#Plot histogram
# ep.hist(naip_ndvi.values,
# figsize=(12, 6),
# title=["NDVI: Distribution of pixels\n NAIP 2015 Cold Springs fire site"])
# plt.show()
type(naip_ndvi), naip_ndvi.dtype
# Write your the ndvi raster object
naip_ndvi.rio.to_raster(output)
def test_single_band_2dims(one_band_3dims):
"""Test single band plot with two dimensions
If you provide a single band array with 3 dimensions (shape[0] == 1)
test that it still plots and only returns a single axis.
"""
single_band_2dims = one_band_3dims[0]
ax = ep.plot_bands(single_band_2dims)
# Get array from mpl figure
arr = ax.get_images()[0].get_array()
assert arr.ndim == 2
assert len(ax.get_images()) == 1
plt.close()
def test_num_axes(image_array_2bands):
"""Test the number of axes.
If provided with a 2 band array, plot_bands should return 3 axes.
And 2 colorbars
"""
ax = ep.plot_bands(image_array_2bands)
ax = list(ax)
cb = [a.images[0].colorbar for a in ax if a.images]
assert len(ax) == 3
assert len(cb) == 2
plt.close()
def test_not_scaled_multi_band(image_array_2bands):
"""Test if the user turns off scaling for multi bands the data vals should remain intact.
"""
im = image_array_2bands
ax = ep.plot_bands(im, scale=False)
# Get all arrays to be plotted
all_arrs = [a.get_images()[0].get_array() for a in ax if a.get_images()]
all_arrs_flat = np.concatenate(all_arrs, axis=0)
# Return arr is unscaled for plotting
assert all_arrs_flat.min() == im.min() and all_arrs_flat.max() == im.max()
plt.close()
def test_vmin_vmax_single_band(one_band_3dims):
"""Test vmin and max apply properly
If the data are scaled between -10 and 10 the cbar vals should reflect that.
"""
one_band_2dims = one_band_3dims[0]
vmin = 0
vmax = 10
ax = ep.plot_bands(one_band_2dims, vmin=vmin, vmax=vmax, scale=False)
c_bar = ax.images[0].colorbar
# Cbar should be scaled between the vmin and vmax vals
assert c_bar.vmin == vmin and c_bar.vmax == vmax
plt.close()
def main():
all_landsat_post_bands = glob('AOI/cana_band*.tif')
#'AOI/arroz_band*.tif')
all_landsat_post_bands.sort()
landsat_img = []
landsat_data = []
band_vectors = []
cana_bottom_limits = [181, 243, 531, 339, 2281, 1339, 558]
cana_top_limits = [567, 658, 960, 1081, 3812, 2644, 1982]
arroz_bottom_limits = [27, 158, 354, 168, 696, 175, 115]
arroz_top_limits = [720, 830, 1123, 1430, 4060, 3363, 2236]
for i in range(len(all_landsat_post_bands)):
landsat_img.append(Image.open(all_landsat_post_bands[i]))
landsat_data.append(np.array(landsat_img[i]))
#band_vectors.append(matrix2vector(landsat_data[i], cana_bottom_limits[i], cana_top_limits[i]))
#band_vectors.append(matrix2vector(landsat_data[i], arroz_bottom_limits[i], arroz_top_limits[i]))
NIR = matrix3D2matrix2D(landsat_data[3], cana_bottom_limits[3],
cana_top_limits[3])
VIS = matrix3D2matrix2D(landsat_data[0], cana_bottom_limits[0],
cana_bottom_limits[0])
naip_ndvi = es.normalized_diff(NIR, VIS)
ep.plot_bands(naip_ndvi, cmap="PiYG", scale=False, vmin=-1, vmax=1)
plt.show()
def test_not_scaled_single_band(one_band_3dims):
"""Test if user turns off scaling and cbar the data vals remain intact.
Also if no cbar is specified it should not render.
"""
one_band_2dims = one_band_3dims[0]
ax = ep.plot_bands(one_band_2dims, cbar=False)
arr = ax.get_images()[0].get_array()
c_bar = ax.images[0].colorbar
# Return arr is unscaled for plotting
assert (arr.min() == one_band_2dims.min()
and arr.max() == one_band_2dims.max())
# A cbar should not be drawn in this plot
assert not c_bar
plt.close()
def test_extent(one_band_3dims):
"""Test that extent param returns a plot with the correct extent."""
one_band_2dims = one_band_3dims[0]
# shift extents by 10
xmin = one_band_2dims.shape[1]
xmax = one_band_2dims.shape[1] + xmin
ymin = one_band_2dims.shape[0]
ymax = one_band_2dims.shape[0] + ymin
ext = [xmin, xmax, ymin, ymax]
ax = ep.plot_bands(one_band_2dims, extent=ext)
pl_extent = list(ax.get_xlim() + ax.get_ylim())
# Cbar should be scaled between the vmin and vmax vals
assert pl_extent == ext
plt.close()
def test_vmin_vmax_multi_band(image_array_2bands):
"""Test vmin and max apply properly in multi band images
If the data are scaled between -10 and 10 the cbar vals should reflect that.
"""
one_band_2dims = image_array_2bands
vmin = -10
vmax = 10
ax = ep.plot_bands(one_band_2dims, vmin=vmin, vmax=vmax, scale=False)
# Get all cbars - the min and max vals for all cbars should be -10 and 10
cb_max = [a.images[0].colorbar.vmax for a in ax if a.images]
cb_min = [a.images[0].colorbar.vmin for a in ax if a.images]
assert all(map(lambda x: x == vmin, cb_min))
assert all(map(lambda x: x == vmax, cb_max))
plt.close()
landsat_path.sort() array_stack, meta_data = es.stack(landsat_path, nodata=-9999) ############################################################################### # Plot All Bands in a Stack # -------------------------- # # When you give ``ep.plot_bands()`` a three dimensional numpy array, # it will plot all layers in the numpy array. You can create unique titles for # each image by providing a list of titles using the ``title=`` parameter. # The list must contain the same number of strings as there are bands in the # stack. titles = ["Ultra Blue", "Blue", "Green", "Red", "NIR", "SWIR 1", "SWIR 2"] # sphinx_gallery_thumbnail_number = 1 ep.plot_bands(array_stack, title=titles) plt.show() ############################################################################### # Plot One Band in a Stack # ------------------------ # # If you give ``ep.plot_bands()`` a one dimensional numpy array, # it will only plot that single band. You can turn off the # colorbar using the ``cbar`` parameter (``cbar=False``). ep.plot_bands(array_stack[4], cbar=False) plt.show() ############################################################################### # Turn On Scaling
fileopen = netCDF4.Dataset(ds, "r") #Finds the group for data science = fileopen.groups["science_data"] #Opens variables for red and blue bands arr_blue = science.variables["sci_blue"] arr = science.variables["sci_red"] #transforms the lists into np arrays for better library functions arr = np.array(arr) #Transposes array, from (X, Band, Y) to (Band, X, Y) arr = arr.transpose(1, 0, 2) arr_blue = np.array(arr_blue) arr_blue = arr_blue.transpose(1, 0, 2) #Plot tool used for debugging and viewing data fig, ax = plt.subplots(figsize=(6, 6)) ep.plot_bands(arr[10], cmap="Spectral", ax=ax) #Varaible Initialization xaxis = list(range(0, fileopen.dimensions["red_bands"].size)) bmean = [] bstd = [] bmin = [] bmax = [] brange = [] mean = [] std = [] mini = [] maxi = [] rrange = [] #Goes through each red band, and computes the values for each measure, then adds it to array.
print(("\nNow doing some data science (running PCA, "
"then finding your city's nearest neighbors)...\n"))
pca = PCA(n_components=19)
pcs = pca.fit_transform(bioclim_data)
# find nearest neighbor of last row (i.e. target city)
kdt = KDTree(pcs[:-1, ], leaf_size=30, metric='euclidean')
analog_idxs = kdt.query(pcs[-1].reshape((1, pcs.shape[1])), k=50)[1].ravel()
analogs = cities.iloc[analog_idxs][['CITY_NAME', 'CNTRY_NAME']]
print("Here are your top 50 climate sister cities:\n")
print(analogs)
# plot
fig, ax = plt.subplots(figsize=(10, 10))
ep.plot_bands(clim[0, :, :],
extent=plotting_extent(clim_src),
cmap='Greys',
title='%s and its climate sister cities' % target,
scale=False,
ax=ax)
cities.iloc[analog_idxs, :].plot(ax=ax,
marker='o',
markersize=100,
cmap='YlGn_r')
cities[cities.CITY_NAME == target].plot(ax=ax,
marker='*',
markersize=100,
color='purple')
ax.set_axis_off()
plt.show()
def test_alpha(image_array_2bands):
"""Test that the alpha param returns a plot with the correct alpha."""
alpha_val = 0.5
alpha_ax = ep.plot_bands(image_array_2bands, cols=2, alpha=alpha_val)
for i in range(len(alpha_ax)):
assert alpha_ax[i].get_images()[0].get_alpha() == alpha_val
# Set the home directory and get the data for the exercise
os.chdir(os.path.join(et.io.HOME, "earth-analytics"))
dtm = "data/vignette-elevation/pre_DTM.tif"
# Open the DEM with Rasterio
with rio.open(dtm) as src:
elevation = src.read(1)
# Set masked values to np.nan
elevation[elevation < 0] = np.nan
# Plot the data
ep.plot_bands(
elevation,
scale=False,
cmap="gist_earth",
title="DTM Without Hillshade",
figsize=(10, 6),
)
plt.show()
####################################################################################
# Create the Hillshade
# --------------------
# Once the DEM is read in, call ``es.hillshade()`` to create the hillshade.
# Create and plot the hillshade with earthpy
hillshade = es.hillshade(elevation)
ep.plot_bands(
hillshade,
import rasterio as rio
import geopandas as gpd
import earthpy as et
import earthpy.spatial as es
import earthpy.plot as ep
# Download data and set working directory
data = et.data.get_data('cold-springs-fire')
os.chdir(os.path.join(et.io.HOME, 'earth-analytics'))
naip_data_path = os.path.join("data", "cold-springs-fire", "naip",
"m_3910505_nw_13_1_20150919", "crop",
"m_3910505_nw_13_1_20150919_crop.tif")
with rio.open(naip_data_path) as src:
naip_data = src.read()
# View shape of the data
naip_data.shape
naip_ndvi = es.normalized_diff(naip_data[3], naip_data[0])
ep.plot_bands(
naip_ndvi,
cmap='PiYG',
scale=False,
vmin=-1,
vmax=1,
title="NAIP Derived NDVI\n 19 September 2015 - Cold Springs Fire, Colorado"
)
plt.show()
#should line up to World Geodetic System (WGS) 1984 (EPSG: 4326), since I did not reproject this to another project system
# converting the ESPG string over to a proj4 string:
proj4 = et.epsg['4326']
print(proj4) #confirms that this is a WGS84 DEM (straight from STRM, prior to reprojection)
#raster resolution:
src.res #should show(0.0008333333333333333, 0.0008333333333333332), which reflects the number of DEGREES shown in each raster cell
# Plotting the Rasters in Different Ways
#
# First, plotting the normal raster!
ep.plot_bands(lidar_dem_im,
cmap='Greys',
extent=spatial_extent,
title="Digital Elevation Model (DEM), \n Shuttle Radar Topography Mission (SRTM), NASA \n Western Uganda",
cbar=False) #think about removing cmap statement and plotting straight black-white raster
plt.show()
#similar plot, using both matplotlib and earthpy, to create an extra color bar and adding extra titles
fig, ax = plt.subplots(figsize=(12, 10))
ep.plot_bands(lidar_dem_im,
cmap='Greys',
extent=spatial_extent,
scale=False,
ax=ax)
ax.set_title("Digital Elevation Model \n Shuttle Radar Topography Mission (SRTM), NASA \n , Western Uganda", fontsize=24)
plt.show()
