def test_plotting_extent():
from rasterio.plot import reshape_as_image
expected = (101985.0, 339315.0, 2611485.0, 2826915.0)
with rasterio.open('tests/data/RGB.byte.tif') as src:
assert plotting_extent(src) == expected
assert plotting_extent(
reshape_as_image(src.read()), transform=src.affine) == expected
assert plotting_extent(
src.read(1), transform=src.transform) == expected
# array requires a transform
with pytest.raises(ValueError):
plotting_extent(src.read(1))
def test_plotting_extent():
from rasterio.plot import reshape_as_image
expected = (101985.0, 339315.0, 2611485.0, 2826915.0)
with rasterio.open('tests/data/RGB.byte.tif') as src:
assert plotting_extent(src) == expected
assert plotting_extent(
reshape_as_image(src.read()), transform=src.transform) == expected
assert plotting_extent(
src.read(1), transform=src.transform) == expected
# array requires a transform
with pytest.raises(ValueError):
plotting_extent(src.read(1))
def readingIR_all(ls_path_tif, filetif):
Piren_IR_ls = []
Piren_IR_name = []
mapping_columns = {}
for path_tif in ls_path_tif:
IR_src = rio.open(os.path.join(path_tif))
Piren_IR_array = IR_src.read(1) # Lit la bande 1
Piren_Limits = plotting_extent(IR_src) # Limites
Piren_res = IR_src.res # resolution
Piren_IR_ls.append([Piren_IR_array, Piren_Limits, IR_src])
Piren_IR_name.append(filetif)
Piren_IR = pd.DataFrame(np.array(
[Piren_IR_ls[0][0], Piren_IR_ls[0][1], Piren_IR_ls[0][2]],
dtype=object).T,
index=["IR_array", "Limits", "IR_src"],
columns=['IR_' + filetif[0]])
## Ajout de plusieurs images IR, A modifier
Piren_IR = Piren_IR.assign(IR_7H29=Piren_IR_ls[1])
Piren_IR = Piren_IR.assign(IR_8H22=Piren_IR_ls[2])
Piren_IR = Piren_IR.assign(IR_9H28=Piren_IR_ls[3])
Piren_IR = Piren_IR.assign(IR_10H22=Piren_IR_ls[4])
Piren_IR = Piren_IR.assign(IR_11H27=Piren_IR_ls[5])
Piren_IR = Piren_IR.assign(IR_12H31=Piren_IR_ls[6])
Piren_IR = Piren_IR.assign(IR_13H26=Piren_IR_ls[7])
Piren_IR = Piren_IR.assign(IR_15H59=Piren_IR_ls[8])
Piren_IR = Piren_IR.assign(IR_17H27=Piren_IR_ls[9])
for IR in Piren_IR:
print(IR)
return Piren_IR, Piren_IR_ls
def readingVIS_norm(ls_path_tif, filetif):
#print("ls_path_tif :" , ls_path_tif)
Piren_VIS_ls = []
Piren_VIS_name = []
mapping_columns = {}
for path_tif in ls_path_tif:
VIS_src = rio.open(os.path.join(path_tif))
#print("VIS_src :",VIS_src)
Piren_VIS_array = VIS_src.read()
Piren_Limits = plotting_extent(VIS_src) # Limites
Piren_res = VIS_src.res # resolution
Piren_transform = VIS_src.transform
Piren_VIS_ls.append(
[Piren_VIS_array, Piren_Limits, VIS_src, Piren_transform])
Piren_VIS_name.append(filetif)
Piren_VIS = pd.DataFrame(
np.array([
Piren_VIS_ls[0][0], Piren_VIS_ls[0][1], Piren_VIS_ls[0][2],
Piren_VIS_ls[0][3]
],
dtype=object).T,
index=["VIS_array", "Limits", "VIS_src", "VIS_transform"],
columns=['Phase_1'])
#print("Piren_VIS.loc['VIS_src'][0]:",Piren_VIS.loc["VIS_src"][0])
return Piren_VIS, Piren_VIS_ls
def crop_resize(input_file, target_size_imgpath, output_file, geojson_file, crs, ch=0, normalization=False, rgb_nir=False, output_type=gdal.GDT_Byte):
# create extention
with open(geojson_file, 'r+', encoding="utf-8") as f:
gj = geojson.load(f)
#pol = geometry.Polygon(gj['geometry']['coordinates'][0]) #['features'][-1]
pol = geometry.Polygon(gj['features'][-1]['geometry']['coordinates'][0])
# crop tif image
with rasterio.open(target_size_imgpath) as f: #output_file
chm_crop, chm_crop_affine = mask(f,[pol],crop=True)
if normalization:
if rgb_nir:
chm_crop = from_16_to_8(chm_crop[:-1], width=3)
else:
chm_crop = from_16_to_8(chm_crop, width=3)
chm_extent = plotting_extent(chm_crop[0], chm_crop_affine)
geotransform = (chm_crop_affine[2], chm_crop_affine[0], 0, chm_crop_affine[5], 0,chm_crop_affine[4])
new_img = band_resize(input_file, target_size_imgpath)[0]
print(new_img.shape, chm_crop[0].shape[1], chm_crop[0].shape[0])
# save new cropped image chm_crop[0]
dst_ds = gdal.GetDriverByName('GTiff').Create(output_file, new_img.shape[1], new_img.shape[0], 1, output_type)
dst_ds.SetGeoTransform(geotransform) # specify coords
srs = osr.SpatialReference() # establish encoding
srs.ImportFromEPSG(crs) #32638 4326
dst_ds.SetProjection(srs.ExportToWkt()) # export coords to file
dst_ds.GetRasterBand(1).WriteArray(new_img) # write r-band to the raster
dst_ds.FlushCache() # write to disk
dst_ds = None
def crop_aoi(input_file, output_file, geojson_file, output_type=gdal.GDT_Byte, crs=3857, value=1):
# export from jp2 to tif
in_image = gdal.Open(input_file)
driver = gdal.GetDriverByName("GTiff")
#out_image = driver.CreateCopy(output_file, in_image, 0)
in_image = None
#out_image = None
# create extention
with open(geojson_file, 'r+', encoding="utf-8") as f:
gj = geojson.load(f)
pol = geometry.Polygon(gj['features'][-1]['geometry']['coordinates'][0])
# crop tif image
with rasterio.open(input_file, 'r+') as f: #output_file
chm_crop, chm_crop_affine = mask(f,[pol],crop=True)
chm_extent = plotting_extent(chm_crop[0], chm_crop_affine)
geotransform = (chm_crop_affine[2], chm_crop_affine[0], 0, chm_crop_affine[5], 0,chm_crop_affine[4])
#print(chm_crop.shape)
# save new cropped image
dst_ds = gdal.GetDriverByName('GTiff').Create(output_file, chm_crop[0].shape[1], chm_crop[0].shape[0], 1, output_type) # gdal.GDT_UInt16)
dst_ds.SetGeoTransform(geotransform) # specify coords
srs = osr.SpatialReference() # establish encoding
srs.ImportFromEPSG(crs)
dst_ds.SetProjection(srs.ExportToWkt()) # export coords to file
dst_ds.GetRasterBand(1).WriteArray(chm_crop[0]*value) # write r-band to the raster
dst_ds.FlushCache() # write to disk
dst_ds = None
def cut_tiff(
path_file,
mapped_shapefile,
):
with rio.open(path_file) as src:
crop, crop_affine = mask(src, [mapped_shapefile],
crop=True,
nodata=NODATA)
crop_extent = plotting_extent(crop[0], crop_affine)
return crop, crop_extent
def plot_select_class_prediction(class_prediction, color_map, classes,
figsize=(10,10), fontsize=8, r_obj=None,
save=False, path=None):
# find the highest pixel value in the prediction image
n = int(np.max(class_prediction[:,:,0]))
# create a default white color map using colors as float 0-1
index_colors = [(1.0, 1.0, 1.0) for key in range(0, n )]
# Replace index_color with the one you want to visualize
for cl in classes:
idx = list(color_map[cl].keys())[0]
vals = list(color_map[cl].values())[0]
# Transform 0 - 255 color values from colors as float 0 - 1
_v = [_v / 255.0 for _v in vals]
index_colors[idx] = tuple(_v)
cmap = plt.matplotlib.colors.ListedColormap(index_colors, 'Classification', n)
from matplotlib.patches import Patch
# Create a list of labels sorted by the int of color_map
class_labels = [el[0] for el in sorted(color_map.items(), key=lambda label: label[1].keys())]
# A path is an object drawn by matplotlib. In this case a patch is a box draw on your legend
# Below you create a unique path or box with a unique color - one for each of the labels above
legend_patches = [Patch(color=icolor, label=label)
for icolor, label in zip(index_colors, class_labels)]
# Plot Classification
fig, axs = plt.subplots(1,1,figsize=figsize)
axs.imshow(class_prediction[:,:,0], cmap=cmap, interpolation='none')
if r_obj:
from rasterio.plot import plotting_extent
axs.imshow(class_prediction[:,:,0], extent=plotting_extent(r_obj), cmap=cmap, interpolation='none')
axs.legend(handles=legend_patches,
facecolor="white",
edgecolor="white",
bbox_to_anchor=(1.20, 1),
fontsize=fontsize) # Place legend to the RIGHT of the map
axs.set_axis_off()
plt.show()
if save and path:
fig.savefig(path, bbox_inches='tight')
def show_hist(path_to_raster):
"""
(to be modified)
"""
with rasterio.open(path_to_raster) as dataset:
rasterio.plot.show_hist(dataset.read([1,2,3,4]), bins=50, histtype='stepfilled', lw=0.0, stacked=False, alpha=0.3)
def points_on_layer_plot(src, arr, gdf, n, **kwargs):
cmap, marker, markersize, color, label = kwargs.get('cmap',"pink"), \
kwargs.get('marker',"s"), \
kwargs.get('markersize',30), \
kwargs.get('color',"purple"), \
kwargs.get('label',"classname")
# Plotting
fig = plt.figure(n, figsize=(8, 8))
ax1 = plt.subplot(2, 1, 1)
gdf.plot(ax=ax1,
marker=marker,
markersize=markersize,
color=color,
label=label)
ax1.imshow(
arr,
# Set the spatial extent or else the data will not line up with your geopandas layer
extent=plotting_extent(src),
cmap=cmap)
ax2 = plt.subplot(2, 1, 2, sharex=ax1, sharey=ax1)
ax2.imshow(arr, extent=plotting_extent(src), cmap=cmap)
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 readingIR(ls_path_tif, filetif):
Piren_IR_ls = []
Piren_IR_name = []
mapping_columns = {}
for path_tif in ls_path_tif:
IR_src = rio.open(os.path.join(path_tif))
Piren_IR_array = IR_src.read(1) # Lit la bande 1
Piren_Limits = plotting_extent(IR_src) # Limites
Piren_res = IR_src.res # resolution
Piren_IR_ls.append([Piren_IR_array, Piren_Limits, IR_src])
Piren_IR_name.append(filetif)
Piren_IR = pd.DataFrame(np.array(
[Piren_IR_ls[0][0], Piren_IR_ls[0][1], Piren_IR_ls[0][2]],
dtype=object).T,
index=["IR_array", "Limits", "IR_src"],
columns=['IR_' + filetif[0]])
return Piren_IR, Piren_IR_ls
def alternative_readingIR_all(ls_path_tif, filetif):
Piren_IR_ls = []
Piren_IR_name = []
mapping_columns = {}
dict_IR = {}
for k, path_tif in enumerate(ls_path_tif):
with rio.open(os.path.join(path_tif)) as IR_src:
Piren_IR_array = IR_src.read(1) # Lit la bande 1
Piren_Limits = plotting_extent(IR_src) # Limites
Piren_res = IR_src.res # resolution
dict_IR["IR_" + filetif[k]] = {
"Piren_IR_array": Piren_IR_array,
"Piren_Limits": Piren_Limits,
"Piren_res": Piren_res,
"IR_src": IR_src
}
print("completed :", "IR_" + filetif[k])
return dict_IR
def normalization(input_file, geojson_file, normalization=False, rgb_nir=False, output_type=gdal.GDT_Byte):
bands_10m = ['B02','B03','B04', 'B08']
bands_20m = ['B05','B06','B07','B8A','B11', 'B12']
## change crs
#input_raster = gdal.Open(input_file)#output_file)
#output_raster = output_file
#gdal.Warp(output_raster,input_raster,dstSRS='EPSG:4326')
# create extention
with open(geojson_file, 'r+', encoding="utf-8") as f:
gj = geojson.load(f)
pol = geometry.Polygon(gj['geometry']['coordinates'][0]) #['features'][-1]
with rasterio.open(input_file) as src:
size_x = src.width
size_y = src.height
chm_crop = np.zeros((len(bands_10m + bands_20m), size_y, size_x))
# crop tif image
for ind, band_name in enumerate(bands_10m + bands_20m):
with rasterio.open(input_file[:-11]+band_name+'_10m.tif') as f: #output_file
chm_crop[ind], chm_crop_affine = mask(f,[pol],crop=True)
if normalization:
chm_crop = from_16_to_8(chm_crop, width=3)
chm_extent = plotting_extent(chm_crop[0], chm_crop_affine)
geotransform = (chm_crop_affine[2], chm_crop_affine[0], 0, chm_crop_affine[5], 0,chm_crop_affine[4])
for ind, band_name in enumerate(bands_10m + bands_20m):
# save new cropped image
output_file = input_file[:-11]+band_name+'_10m_norm.tif'
dst_ds = gdal.GetDriverByName('GTiff').Create(output_file, chm_crop[0].shape[1], chm_crop[0].shape[0], 1, output_type)
dst_ds.SetGeoTransform(geotransform) # specify coords
srs = osr.SpatialReference() # establish encoding
srs.ImportFromEPSG(32638) # 4326
dst_ds.SetProjection(srs.ExportToWkt()) # export coords to file
dst_ds.GetRasterBand(1).WriteArray(chm_crop[ind]) # write r-band to the raster
dst_ds.FlushCache() # write to disk
dst_ds = None
def crop(self, src_dir, dest_dir, vmin=0, vmax=1000, plot=False):
status = True
file_name = f'{self.clim_type}_{self.month:02d}'
temp_file = os.path.join(dest_dir, f'{file_name}_temp.{self.ext}')
cropped_file = os.path.join(dest_dir, f'{file_name}.{self.ext}')
# file_out = os.path.join(dest_dir, f'{file_name}_r.{ext}')
try:
# Scans dir and find file_name as substring from dir tree
src_file = util.get_file_in_dir(file_name, src_dir)
clim_data, clim_metadata = self._pre_crop(src_file, SHAPE_FILE)
clim_data_affine = clim_metadata['transform']
# Create spatial plotting extent for the cropped layer
clim_data_extent = plotting_extent(clim_data[0], clim_data_affine)
if plot:
cmap = self._set_negative_color(color='w')
title = '{} {}'.format(self.clim_types[clim_type], self.month)
self._plot(clim_data[0], clim_data_extent, cmap,
title=title, vmin=vmin, vmax=vmax)
self._crop_extent(temp_file, clim_data, clim_metadata, clim_data_affine)
self._warp(temp_file, cropped_file, SHAPE_FILE)
os.remove(temp_file)
except Exception as err:
print(err)
status = False
return status
def rgb_image():
"""Fixture holding an RGB image for plotting"""
with rio.open(path_to_example("rmnp-rgb.tif")) as src:
rgb = src.read()
ext = plotting_extent(src)
return rgb, ext
def plot_objects(obj=None,
img=None,
column=None,
bounds_only=True,
obj_extent=True,
obj_cmap=None,
linewidth=0.5,
alpha=1,
edgecolor='white',
rgb=[4, 2, 1],
band=None,
plot_window=None,
ax=None,
obj_kwargs={},
img_kwargs={}):
"""Plot vector objects on an image
Parameters:
"""
# Create a figure and ax is not provided
if not ax:
fig, ax = plt.subplots(1, 1, figsize=(15, 15))
# Plot the img if provided
if img is not None:
logger.debug('Plotting imagery...')
# If path to image provided, open it, otherwise assumed open rasterio DatasetReader
if isinstance(img, str):
img = rio.open(img)
img_arr = img.read(masked=True)
if obj is not None and obj_extent:
logger.debug('Using objects extent for plotting.')
minx, miny, maxx, maxy = obj.total_bounds
minrow, mincol = geo2pixel(y=maxy, x=minx, img=img)
maxrow, maxcol = geo2pixel(y=miny, x=maxx, img=img)
img_arr = img_arr[:, mincol:maxcol, minrow:maxrow]
logger.debug("Object ext: {} {} {} {}".format(
minx, miny, maxx, maxy))
img_ext = (minx, miny, maxx, maxy)
else:
logger.debug('Using images full extent for plotting.')
# minx, maxx, miny, maxy = plotting_extent(img)
# img_ext = (minx, miny, maxx, maxy)
img_ext = plotting_extent(img)
if not band and img_arr.shape[0] == 1:
band = 1
if band is not None:
ep.plot_bands(img_arr[band - 1],
extent=img_ext,
ax=ax,
**img_kwargs)
else:
ep.plot_rgb(img_arr, rgb=rgb, ax=ax, extent=img_ext, **img_kwargs)
# Plot the objects if provided
if obj is not None:
logger.debug('Plotting objects...')
if img is not None:
obj = obj.to_crs(img.crs)
# If a column is not provided, plot all as the same color
if column is None:
# Create temporary column, ensuring it doesn't exist
logger.debug('Creating a temporary column for plotting')
column = np.random.randint(10000)
while column in list(obj):
column = 'temp_{}'.format(np.random.randint(10000))
obj[column] = 1
if bounds_only:
logger.debug('Plotting objects...')
obj.set_geometry(obj.geometry.boundary).plot(ax=ax,
column=column,
cmap=obj_cmap,
alpha=alpha,
linewidth=linewidth,
**obj_kwargs)
else:
obj.plot(ax=ax,
column=column,
cmap=obj_cmap,
alpha=alpha,
linewidth=linewidth,
edgecolor=edgecolor,
**obj_kwargs)
if plot_window:
logger.debug('Updating to use passed window as extent.')
ax.set_xlim([plot_window[0], plot_window[2]])
ax.set_ylim([plot_window[1], plot_window[3]])
fig.show()
return fig, ax
dir_crop = dir_iii + '\\crop'
list_iii = glob.glob('*.tif')
# iii = list_iii[1]
for iii in list_iii:
with rio.open(iii) as iii_tif:
iii_tif_crop, iii_tif_crop_meta = es.crop_image(
iii_tif, crop_extent)
iii_tif_crop_affine = iii_tif_crop_meta['transform']
# Create spatial plotting extent for the cropped layer
iii_tif_extent = plotting_extent(iii_tif_crop[0],
iii_tif_crop_affine)
# Plot your data
'''
ep.plot_bands(iii_tif_crop[0],
extent = iii_tif_extent,
cmap = 'Greys',
title = "Cropped Raster Dataset",
scale = False)
plt.show()
'''
# Update with the new cropped affine info and the new width and height
iii_tif_crop_meta.update({
'transform': iii_tif_crop_affine,
'height': iii_tif_crop.shape[1],
# Stack Landsat bands
os.chdir(os.path.join(et.io.HOME, "earth-analytics"))
array, raster_prof = es.stack(stack_band_paths, out_path=raster_out_path)
####################################################################################
# Create Extent Object
# --------------------------------
# To get the raster extent, use the ``plotting_extent`` function on the
# array from ``es.stack()`` and the Rasterio profile or metadata object. The function
# needs a single
# layer of a numpy array, which is why we use ``arr[0]``. The function also
# needs the spatial transformation for the Rasterio object, which can be acquired by accessing
# the ``"transform"`` key within the Rasterio Profile.
extent = plotting_extent(array[0], raster_prof["transform"])
################################################################################
# Plot Un-cropped Data
# ------------------------------
# You can see the boundary and the raster before the crop using ``ep.plot_rgb()``
# Notice that the data appear washed out.
fig, ax = plt.subplots(figsize=(12, 12))
ep.plot_rgb(
array,
ax=ax,
stretch=True,
extent=extent,
str_clip=0.5,
title="RGB Image of Un-cropped Raster",
"data", "cold-springs-fire", "landsat_collect",
"LC080340322016070701T1-SC20180214145604", "crop", "*band*.tif")
landsat_paths_pre = glob(landsat_paths_pre_path)
landsat_paths_pre.sort()
# Stack the Landsat pre fire data
landsat_pre_st_path = os.path.join("data", "cold-springs-fire", "outputs",
"landsat_pre_st.tif")
es.stack(landsat_paths_pre, landsat_pre_st_path)
# Read landsat pre fire data
with rio.open(landsat_pre_st_path) as landsat_pre_src:
landsat_pre = landsat_pre_src.read(masked=True)
landsat_extent = plotting_extent(landsat_pre_src)
ep.plot_rgb(
landsat_pre,
rgb=[3, 2, 1],
extent=landsat_extent,
title=
"Landsat True Color Composite Image | 30 meters \n Post Cold Springs Fire \n July 8, 2016"
)
plt.show()
# -
# Notice in the data above there is a large cloud in your scene. This cloud will impact any quantitative analysis that you perform on the data. You can remove cloudy pixels using a mask. Masking "bad" pixels:
#
# 1. Allows you to remove them from any quantitative analysis that you may perform such as calculating NDVI.
def plot_select_class_prediction(class_prediction,
mapping,
color_map,
classes,
figsize=(10, 10),
fontsize=8,
src=None,
save=False,
path=None):
# find the highest pixel value in the prediction image
#n = int(np.max(class_prediction[0,:,:]))
n = len(color_map)
# create a default white color map using colors as float 0-1
index_colors = [(1.0, 1.0, 1.0) for key in range(0, n)]
for cl, val in color_map.items():
# convert the class_prediction values to match the plotting values
class_prediction = np.where(class_prediction == int(mapping[cl]),
[*val][0], class_prediction)
# Replace index_color with the one you want to visualize
for cl in classes:
idx = list(color_map[cl].keys())[0]
vals = list(color_map[cl].values())[0]
# Transform 0 - 255 color values from colors as float 0 - 1
_v = [_v / 255.0 for _v in vals]
index_colors[idx] = tuple(_v)
#pdb.set_trace()
cmap = plt.matplotlib.colors.ListedColormap(index_colors)
from matplotlib.patches import Patch
# Create a list of labels sorted by the int of color_map
class_labels = [
el[0]
for el in sorted(color_map.items(), key=lambda label: label[1].keys())
]
# A path is an object drawn by matplotlib. In this case a patch is a box draw on your legend
# Below you create a unique path or box with a unique color - one for each of the labels above
legend_patches = [
Patch(color=icolor, label=label)
for icolor, label in zip(index_colors, class_labels)
]
# Plot Classification
fig, axs = plt.subplots(1, 1, figsize=figsize)
axs.imshow(class_prediction, cmap=cmap, interpolation='none')
if src:
from rasterio.plot import plotting_extent
axs.imshow(class_prediction,
extent=plotting_extent(src),
cmap=cmap,
interpolation='none')
axs.legend(handles=legend_patches,
facecolor="white",
edgecolor="white",
bbox_to_anchor=(1.20, 1),
fontsize=fontsize) # Place legend to the RIGHT of the map
axs.set_axis_off()
plt.show()
if save and path:
fig.savefig(path, bbox_inches='tight')
def main(fname, band, title, save, vmax, vmin, colorbar):
if title is None:
title = fname
palette = copy(plt.cm.viridis)
palette.set_over('r', 1.0)
palette.set_under('k', 1.0)
#palette.set_bad('#0e0e2c', 1.0)
palette.set_bad('w', 1.0)
src = rasterio.open(fname)
data = read_array(src, band)
if too_big(src):
rmin = data.min()
rmax = data.max()
else:
rmin, rmax = get_min_max(fname)
if vmax is None:
vmax = rmax
if vmin is None:
vmin = rmin
dpi = 100.0
size = [data.shape[2] / dpi, data.shape[1] / dpi]
if colorbar:
size[1] += 70 / dpi
pass
if save:
fig = plt.figure(figsize=size, dpi=dpi)
ax = plt.gca()
show(data,
ax=ax,
cmap=palette,
title=title,
vmin=vmin,
vmax=vmax,
extent=plotting_extent(src))
fig.tight_layout()
#ax.axis('off')
if colorbar:
divider = make_axes_locatable(ax)
cax = divider.append_axes("bottom", size="5%", pad=0.25)
plt.colorbar(ax.images[0], cax=cax, orientation='horizontal')
fig.savefig(save, transparent=False)
plt.show()
else:
fig = plt.figure(figsize=size, dpi=dpi)
ax = plt.gca()
show(data,
ax=ax,
cmap=palette,
title=title,
vmin=vmin,
vmax=vmax,
extent=plotting_extent(src))
if colorbar:
divider = make_axes_locatable(ax)
cax = divider.append_axes("bottom", size="5%", pad=0.25)
plt.colorbar(ax.images[0], cax=cax, orientation='horizontal')
plt.show()
with rio.open(stack_band_paths[0]) as raster_crs:
raster_profile = raster_crs.profile
bound_utm13N = bound.to_crs(raster_profile["crs"])
################################################################################
# Create a Plot With the Boundary overlayed on the RGB Image
# ----------------------------------------------------------
# You can plot a polygon boundary over an image by creating a raster extent
# for the plot using the ``plotting_extent`` function from ``rasterio.plot``.
# The function needs the Rasterio profile of the image and a single layer of a
# numpy array, which can be specified with ``arr_str[0]``. The function also
# needs the spatial transformation for the Rasterio object, which can be acquired
# by accessing the ``"transform"`` key within the Rasterio profile.
# Create raster extent for the plot
extent = plotting_extent(arr_st[0], raster_profile["transform"])
# Create figure with one plot
fig, ax = plt.subplots(figsize=(12, 12))
# Plot boundary with high zorder for contrast
bound_utm13N.boundary.plot(ax=ax, color="black", zorder=10)
# Plot CIR image using the raster extent
ep.plot_rgb(
arr_st,
rgb=(4, 3, 2),
ax=ax,
stretch=True,
extent=extent,
str_clip=0.5,
# Stack Landsat bands
os.chdir(os.path.join(et.io.HOME, "earth-analytics"))
array, raster_prof = es.stack(stack_band_paths, out_path=raster_out_path)
####################################################################################
# Create Extent Object
# --------------------------------
# To get the raster extent, use the ``plotting_extent`` function on the
# array from ``es.stack()`` and the Rasterio profile or metadata object. The function
# needs a single
# layer of a numpy array, which is why we use ``arr[0]``. The function also
# needs the spatial transformation for the Rasterio object, which can be acquired by accessing
# the ``"transform"`` key within the Rasterio Profile.
extent = plotting_extent(array[0], raster_prof["transform"])
################################################################################
# Plot Un-cropped Data
# ------------------------------
# You can see the boundary and the raster before the crop using ``ep.plot_rgb()``
# Notice that the data appear washed out.
fig, ax = plt.subplots(figsize=(12, 12))
ep.plot_rgb(
array,
ax=ax,
stretch=True,
extent=extent,
str_clip=0.5,
title="RGB Image of Un-cropped Raster",
fig, ax = plt.subplots(figsize=(10, 10))
ax.imshow(map_im, cmap='terrain', extent=extent)
cerrado_sh.plot(ax=ax, alpha=.6, color='g')
# +
extent_geojson = mapping(cerrado_sh.geometry[0])
extent_geojson
# +
with rio.open(path_file) as src:
cerrado_crop, cerrado_crop_affine = mask(src, [extent_geojson],
crop=True,
nodata=NODATA)
cerrado_extent = plotting_extent(cerrado_crop[0], cerrado_crop_affine)
# -
cerrado_crop
# Tranformo o array acima em um masked array, para conseguir printar sem os NODATAS
cerrado_masked = np.ma.masked_where(cerrado_crop[0] == NODATA, cerrado_crop[0])
cerrado_masked
# +
plt.figure(figsize=(10, 10))
plt.imshow(cerrado_masked, cmap="terrain", extent=cerrado_extent)
plt.colorbar()
vector = gp.read_file(vfp)
print(vector)
print(vector.crs)
print()
print()
vector = vector.to_crs(raster.crs)
# our crop_extent is the vector
crop_extent = vector
raster_crop, raster_crop_meta = es.crop_image(raster, crop_extent)
raster_crop_affine = raster_crop_meta["transform"]
# Create spatial plotting extent for the cropped layer
raster_extent = plotting_extent(raster_crop[0], raster_crop_affine)
print(crop_extent)
plot_crop_extent()
plot_crop_overlayed_on_raster()
plot_cropped_raster()
raster_meta = raster.profile
raster_meta.update({
'transform': raster_crop_affine,
'height': raster_crop.shape[1],
'width': raster_crop.shape[2],
'nodata': 0.0,
all_landsat_bands.sort()
"""setting our output file path"""
landsat_post_fire_path = "data/cold-springs-fire/outputs/landsat_post_fire.tif"
"""es.stack will stack all bands on top of one another.
making raster values more easily comparable."""
es.stack_raster_tifs(all_landsat_bands, landsat_post_fire_path)
# we can clip the files but in this case we use .read()
"""the next 5 lines will open the file, set up profile, set up bounding box,
our plotting extent, and validates that our data has values assigned to array"""
with rio.open(landsat_post_fire_path) as src:
landsat_post_fire = src.read(masked=True)
landsat_post_meta = src.profile
landsat_post_bounds = src.bounds
landsat_extent = plotting_extent(src)
# Open fire boundary layer and reproject it to match the Landsat data
fire_boundary_path = "data/cold-springs-fire/vector_layers/fire-boundary-geomac/co_cold_springs_20160711_2200_dd83.shp"
fire_boundary = gpd.read_file(fire_boundary_path)
# If the CRS' are not the same be sure to reproject
"""this reprojects the coordinate reference system for the fire boundary"""
fire_bound_utmz13 = fire_boundary.to_crs(landsat_post_meta['crs'])
#calculating NBR postfire and plotting results
"""this calculates postfire NBR"""
landsat_postfire_nbr = (landsat_post_fire[4] - landsat_post_fire[6]) / (
landsat_post_fire[4] + landsat_post_fire[6])
"""sets plot parameters"""
fig, ax = plt.subplots(figsize=(12, 6))
def main(metric, scenario, start, limit, out, dst_crs):
palette = copy(plt.cm.viridis_r)
palette.set_under('y', 1.0)
palette.set_over('r', 1.0)
palette.set_bad('w', 1.0)
fname = '/out/luh2/%s-%s-%d.tif' % (scenario, metric, 2100)
with rasterio.open(fname) as src:
meta = src.meta
end = src.read(1, masked=True)
stack = read_historical(start, 2015, src.bounds, metric)
inc = ma.where(stack < end, 1, 0)
years = inc.sum(axis=0)
years2 = ma.where(end > stack[-1],
ma.where(end > stack[0], start - 1, 2015 - years), 2016)
mask = ma.where((end > limit) & (stack[-1] > limit), True, False)
years2.mask = np.logical_or(years2.mask, mask)
years2.fill_value = src.nodata
if out:
meta_out = meta.copy()
meta_out['dtype'] = 'int32'
with rasterio.open(out.name, 'w', **meta_out) as dst:
dst.write(years2.filled(meta_out['nodata']).astype(np.int32),
indexes=1)
title = 'Year to which BII recovers by 2100'
vmin = start - 2
vmax = 2015
dpi = 100.0
size = [years2.shape[1] / dpi, years2.shape[0] / dpi]
size[1] += 70 / dpi
fig = plt.figure(figsize=size, dpi=dpi)
if dst_crs:
with rasterio.open(out.name) as src:
data = src.read(
1,
masked=True,
window=src.window( #*src.bounds))
*(-180, -90, 180, 90)))
#crs = ccrs.Robinson()
crs = ccrs.Mollweide()
dst_crs = crs.proj4_params
(dst_transform, dst_width, dst_height, dst_data) = project(
dst_crs,
src,
data, #src.bounds)
(-180, -90, 180, 90))
xmin, ymax = dst_transform * (0, 0)
xmax, ymin = dst_transform * (dst_width, dst_height)
#taff = Affine.from_gdal(-18040068.169145808, 25055.6578813187,
# 0.0, 9020047.848073646, 0.0, -25055.6578813187)
#xmin, ymax = taff * (0, 0)
#xmax, ymin = taff * (1436, 728)
ax = plt.axes(projection=crs)
ax.imshow(dst_data,
origin='upper',
extent=[xmin, xmax, ymin, ymax],
cmap=palette,
vmin=vmin,
vmax=vmax)
ax.coastlines()
#ax.set_title(title, fontweight='bold')
sm = matplotlib.cm.ScalarMappable(cmap=palette,
norm=plt.Normalize(1900, 2015))
sm._A = []
cb = plt.colorbar(sm, orientation='vertical')
cb.set_label(title)
else:
ax = plt.gca()
show(years2,
ax=ax,
cmap=palette,
title=title,
vmin=vmin,
vmax=vmax,
extent=plotting_extent(src))
divider = make_axes_locatable(ax)
cax = divider.append_axes("bottom", size="5%", pad=0.25)
plt.colorbar(ax.images[0], cax=cax, orientation='horizontal')
fig.tight_layout()
#ax.axis('off')
if out:
fig.savefig(out.name.replace('.tif', '.png'), transparent=False)
plt.show()
#show(years2, cmap=palette, vmin=start, vmax=2100)
#pdb.set_trace()
pass
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()
ax.set_xlim(p_bbox[0], p_bbox[1])
ax.set_ylim(p_bbox[2], p_bbox[3])
ax.add_artist(ScaleBar(dx=1, box_alpha=0.1, location='lower left'))
print(family)
print(species)
#ax.set_title(family+ " - "+ species)
plt.savefig(output_map + family + "_" + species + ".png", dpi=300)
plt.close('all')
# main
transformer = Transformer.from_crs("epsg:4326", "epsg:3857", always_xy=True)
bbox_all = [28.9, 31, -4.7, -2.2]
raster_data = rxr.open_rasterio(fp, masked=True).rio.reproject("epsg:3857")
raster_data_extent = plotting_extent(raster_data[0],
raster_data.rio.transform())
bbox_1 = transformer.transform(bbox_all[0], bbox_all[2])
bbox_2 = transformer.transform(bbox_all[0], bbox_all[3])
bbox_3 = transformer.transform(bbox_all[1], bbox_all[3])
bbox_4 = transformer.transform(bbox_all[1], bbox_all[2])
bbox_conv = [bbox_1[0], bbox_4[0], bbox_1[1], bbox_3[1]]
xticks = []
jticks = []
xlabels = []
jlabels = []
i = bbox_all[0]
while i <= bbox_all[1]:
#print(i)
