def test_stack_invalid_out_paths_raise_errors():
""" If users provide an output path that doesn't exist, raise error. """
with pytest.raises(ValueError, match="not exist"):
es.stack(
band_paths=["fname1.tif", "fname2.tif"],
out_path="nonexistent_directory/output.tif",
)
def compositeImages(root_dir):
# walk over directory to find scene packages
regex = re.compile("^L.08")
out_path_list = []
directory_list = list()
for root, dirs, files in os.walk(root_dir, topdown=False):
for name in dirs:
if regex.match(name):
directory_list.append(os.path.join(root, name))
image_path_list = []
for folder in directory_list:
image_path_list.append(natsort.natsorted(glob(
os.path.join(folder, "*B*.TIF")
)))
composite_dir = folder + "/composite_folder"
os.makedirs(composite_dir, exist_ok=True)
out_raster_name = os.path.join(composite_dir, "composite_bands.tif")
out_path_list.append(out_raster_name)
for image in image_path_list:
if str(image) not in out_raster_name:
es.stack(image, out_raster_name)
return out_path_list
def foret(inPathFeuillus, inPathConiferes, inPathInconnu, dir):
# Création de Strings représentant les chemins vers de nouveaux fichiers créés.
pathAll = os.path.join(dir, "NFI_MODIS250m_2011_kNN_SpeciesGroups_All_Spp_v1_resample_30.tif")
pathClass = os.path.join(dir, "NFI_MODIS250m_2011_kNN_SpeciesGroups_Class_Spp_v1_resample_30.tif")
# Si la fusion des trois rasters n'a pas déjà été faite.
if not os.path.exists(pathAll):
fileName = os.path.basename(pathAll)
print(" Création du raster fusionné " + fileName + "...")
# Création d'une liste des fichiers raster pertinents.
list = [inPathFeuillus, inPathConiferes, inPathInconnu]
# Fusionner les rasters contenus dans la liste.
es.stack(list, pathAll) # 2 = Feuillus, 1 = Conifères, 0 = Inconnu.
# Si la classification n'a pas été faite.
if not os.path.exists(pathClass):
fileName = os.path.basename(pathClass)
print(" Classification du raster " + fileName + "...")
# Ouverture des données.
rasterAll = gdal.Open(pathAll, gdal.GA_ReadOnly)
rasterAllBand0 = rasterAll.GetRasterBand(1).ReadAsArray()
rasterAllBand1 = rasterAll.GetRasterBand(2).ReadAsArray()
rasterAllBand2 = rasterAll.GetRasterBand(3).ReadAsArray()
for i in range(rasterAll.RasterYSize):
for j in range(rasterAll.RasterXSize):
if rasterAllBand0[i, j] == 0 and rasterAllBand1[i, j] == 0 and rasterAllBand2[i, j] == 0: # Aucune forêt
rasterAllBand0[i, j] = 0
elif rasterAllBand0[i, j] > 50: # Feuillus
rasterAllBand0[i, j] = 1
elif rasterAllBand1[i, j] > 50: # Conifères
rasterAllBand0[i, j] = 2
elif rasterAllBand2[i, j] > 50: # Inconnu
rasterAllBand0[i, j] = 0
else: # Mixte
rasterAllBand0[i, j] = 3
rasterClass = gdal.GetDriverByName("GTiff").Create(pathClass, rasterAll.RasterXSize, rasterAll.RasterYSize, 1)
rasterClass.GetRasterBand(1).WriteArray(rasterAllBand0)
rasterClass.SetProjection(rasterAll.GetProjection())
rasterClass.SetGeoTransform(rasterAll.GetGeoTransform())
rasterClass.FlushCache()
return pathClass
def test_stack_nodata(in_paths, out_path):
"""Test nodata parameter for masking stacked array."""
stack_arr, stack_prof = es.stack(in_paths, out_path, nodata=0)
# basic_image has 91 0 values, which should be masked
assert 0 not in stack_arr and np.sum(stack_arr.mask) == 91 * len(in_paths)
def test_stack_return_array(in_paths):
""" Test returning only array."""
# Test valid use case of just getting back the array.
n_bands = len(in_paths)
stack_arr, stack_prof = es.stack(in_paths)
assert stack_arr.shape[0] == n_bands and stack_prof["count"] == n_bands
def viewhist(self): # Function to display the histogram in the frame and save it in the specified directory
if self.display.winfo_exists():
self.display.grid_forget()
self.display.destroy()
self.display = ttk.Frame(self)
self.display.grid(row = 0, column = 4,rowspan=2, sticky = 'nwes')
frame=self.display
band_path=[]
for file in self.histfiles:
band_path.append(file)
# dir = self.dir[0]
# band_path = glob.glob(os.path.join(dir,"*.tif"))
# band_path = glob.glob(os.path.join(dir,"*.TIF"))
band_path.sort()
band_stack, meta_data = es.stack(band_path, nodata=-9999)
size = len(band_path)
color_list = ["Indigo","Blue","Green","Yellow","Red","Maroon","Purple","Violet"]
titles = []
for i in range(size):
titles.append("File"+str(i+1))
self.figure,self.plot = ep.hist(band_stack, title = titles,figsize = (6,4))
self.canvas = FigureCanvasTkAgg(self.figure,frame)
self.toolbar = NavigationToolbar2Tk(self.canvas,frame)
self.toolbar.update()
self.canvas.get_tk_widget().pack()
def test_stack_outputfile(in_paths, out_path):
"""Test successful creation of output file."""
# Test valid use case specifying output file.
stack_arr, stack_prof = es.stack(in_paths, out_path)
assert os.path.exists(out_path)
def test_stack_nodata_outfile(in_paths, out_path):
"""Test nodata parameter for masking stacked array and writing output file."""
stack_arr, stack_prof = es.stack(in_paths, out_path, nodata=0)
# basic_image has 91 0 values, which should be masked
assert 0 not in stack_arr and np.sum(stack_arr.mask) == 91 * len(in_paths)
assert os.path.exists(out_path)
def test_stack_out_format(in_paths):
"""Test that output format matches input format."""
# Test that the output file format is same as inputs
# This can be flexible but for now forcing the same format
out_fi = "test_stack.jp2"
with pytest.raises(ValueError, match="Source"):
stack_arr, stack_prof = es.stack(in_paths, out_path=out_fi)
def create_stacked_image(self, HOME_DIR, stacked_file_output, paths_list):
'''
Generates stacked image from all bands
void
'''
stack_data, metadata = es.stack(paths_list[:7],
HOME_DIR + stacked_file_output)
def test_stack_no_file_ext(in_paths):
"""Test for error raised when no file extension provided in output file."""
# Test that out_path needs a file extension to be valid
out_fi = "test_stack"
with pytest.raises(ValueError,
match="Please specify a valid file name for output."):
stack_arr, stack_prof = es.stack(in_paths, out_path=out_fi)
def create_stacked_image(self, HOME_DIR, stacked_file_output, paths_list):
'''
Generates stacked image from all bands
void
'''
logging.info("Generating stacked image from bands")
if os.path.isfile(HOME_DIR + stacked_file_output):
logging.info("Stacked image already exists. Skipping")
else:
stack_data, metadata = es.stack(paths_list[:7],
HOME_DIR + stacked_file_output)
def create_raster_stack(self):
"""Stacks all provided raster files by the GIS object (gh) into a single raster stack, where each band
corresponds to one environmental variable.
:param self: a class instance of RasterStack
:return: None. Does not return value or object, instead writes away the raster stack to a new (.tif) file.
"""
for _ in tqdm.tqdm([0], desc='Creating raster stack' +
(29 * ' ')) if self.verbose else [0]:
if not os.path.isdir(self.gh.stack):
os.makedirs(self.gh.stack, exist_ok=True)
# WARNING: this can cause errors if raster layers with different affine transformations / spatial extent or
# resolutions are detected and used by the model, THIS ALSO INCLUDES THE FILE 'empty_land_map.tif'. This
# means that the input raster files should match the spatial extent (Longitude_max = 180, Longitude_
# min = -180, Latitude_max = 90, Latitude_min = -60) of the already existing 'empty_land_map.tif' included
# in the repository. Alternatively the included 'empty_land_map.tif' can be edited to match the affine
# transformation of the users raster files.
es.stack(self.gh.variables,
self.gh.stack + '/stacked_env_variables.tif')
def test_stack_raster(basic_image_tif):
"""Unit tests for raster stacking with es.stack()."""
# Create list of 4 basic_image_tif files (filepaths)
band_files = [basic_image_tif] * 4
# Test that out_path needs a file extension to be valid
out_fi = "test_stack"
with pytest.raises(ValueError,
match="Please specify a valid file name for output."):
stack_arr, stack_prof = es.stack(band_files, out_path=out_fi)
# Test that out_path needs a file extension to be valid
out_fi = "test_stack.tif"
with pytest.raises(ValueError, match="The list of"):
stack_arr, stack_prof = es.stack([], out_path=out_fi)
# Test that the output file format is same as inputs
# This can be flexible but for now forcing the same format
out_fi = "test_stack.jp2"
with pytest.raises(ValueError, match="Source"):
stack_arr, stack_prof = es.stack(band_files, out_path=out_fi)
# Test valid use case specifying output file.
# Make sure the output file exists and then clean it up
out_fi = "test_stack.tif"
stack_arr, stack_prof = es.stack(band_files, out_path=out_fi)
assert os.path.exists(out_fi)
if os.path.exists(out_fi):
os.remove(out_fi)
# Test valid use case of just getting back the array.
stack_arr, stack_prof = es.stack(band_files)
assert stack_arr.shape[0] == len(band_files)
assert stack_prof["count"] == len(band_files)
def showImage(self): # Function to display the image in frame
# directory = os.getcwd()
# now = datetime.now()
# dt_string = now.strftime("%d_%m_%Y_%H:%M:%S")
# outdir = directory + '/img_STACK' + dt_string + '.tiff'
outdir = 'OutputImages/' + self.out_name.get() + '.tiff'
frame = self.frame
self.band_fnames = [self.file1, self.file2, self.file3]
arr_st, meta = es.stack(self.band_fnames, out_path=outdir, nodata=0)
self.figure = Figure(figsize=(10, 6), dpi=100)
self.plot = self.figure.add_subplot(1, 1, 1)
ep.plot_rgb((arr_st), stretch=True, str_clip=0.5, ax=self.plot)
self.canvas = FigureCanvasTkAgg(self.figure, frame)
self.toolbar = NavigationToolbar2Tk(self.canvas, frame)
self.toolbar.update()
self.canvas.get_tk_widget().pack()
def test_stack_yes_file_ext(out_path):
"""Test for valid file extension."""
# Test that out_path needs a file extension to be valid
with pytest.raises(ValueError, match="The list of"):
stack_arr, stack_prof = es.stack([], out_path=out_path)
import earthpy.plot as ep
import gdal
import sys
get_ipython().system('{sys.executable} -m pip install fastai')
import glob
from arcgis.gis import GIS
from arcgis.raster import ImageryLayer
from sentinelhub import SHConfig, MimeType, CRS, BBox, SentinelHubRequest, SentinelHubDownloadClient, DataSource, bbox_to_dimensions, DownloadRequest, BBoxSplitter, OsmSplitter, TileSplitter, CustomGridSplitter, UtmZoneSplitter, UtmGridSplitter
import itertools
# In[3]:
epaths = glob.glob("Sentinel/*.jp2")
epaths.sort()
epath = ("Sentinel/T11SMT_20200717T182921_B01_60m.jp2")
arr_stack, metadata = es.stack(epaths)
ep.plot_rgb(arr_stack, rgb=[4, 3, 1], stretch=True, figsize=(20, 20))
plt.savefig('edata')
# In[2]:
#sentinel2 processing
config = SHConfig()
CLIENT_SECRET = 'm*JW}?-76bBH)PjZp:-sW,3ISibK)mfh0GPc])n^'
CLIENT_ID = 'edb4f750-7cb2-475c-b190-3406e33de291'
config.sh_client_id = CLIENT_ID
config.sh_client_secret = CLIENT_SECRET
usa_bbox = -118.572693, 34.002581, -118.446350, 34.057211
resolution = 60
bbox = BBox(bbox=usa_bbox, crs=CRS.WGS84)
# -------------------
#
# To get started, make sure your directory is set. Then, create a stack from all of
# the Landsat .tif files (one per band). The nodata value for Landsat 8 is
# ``-9999`` so you can use the ``nodata=`` parameter when you call the
# ``stack()`` function.
os.chdir(os.path.join(et.io.HOME, "earth-analytics"))
# Stack the Landsat 8 bands
# This creates a numpy array with each "layer" representing a single band
landsat_path = glob(
"data/vignette-landsat/LC08_L1TP_034032_20160621_20170221_01_T1_sr_band*_crop.tif"
)
landsat_path.sort()
arr_st, meta = es.stack(landsat_path, nodata=-9999)
###############################################################################
# Calculate Normalized Difference Vegetation Index (NDVI)
# -------------------------------------------------------
#
# You can calculate NDVI for your dataset using the
# ``normalized_diff`` function from the ``earthpy.spatial`` module.
# Math will be calculated (b1-b2) / (b1 + b2).
# Landsat 8 red band is band 4 at [3]
# Landsat 8 near-infrared band is band 5 at [4]
ndvi = es.normalized_diff(arr_st[4], arr_st[3])
raster_out_path = os.path.join(output_dir, "raster.tiff") #################################################################################### # Stack the Bands # --------------------------- # The stack function has an optional output argument, where you can write the raster # to a tiff file in a folder. If you want to use this functionality, make sure there # is a folder to write your tiff file to. # The Stack function also returns two object, an array and a RasterIO profile. Make # sure to be catch both in variables. # 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
# Next, you will load and plot landsat data. If you are completing the earth analytics course, you have worked with these data already in your homework.
#
# +
landsat_paths_pre_path = os.path.join(
"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()
###############################################################################
# Import Example Data
# ------------------------------
# To get started, make sure your directory is set. Create a stack from all of the
# Landsat .tif files (one per band) and import the ``landsat_qa`` layer which provides
# the locations of cloudy and shadowed pixels in the scene.
os.chdir(os.path.join(et.io.HOME, "earth-analytics"))
# Stack the landsat bands
# This creates a numpy array with each "layer" representing a single band
landsat_paths_pre = glob(
"data/cold-springs-fire/landsat_collect/LC080340322016070701T1-SC20180214145604/crop/*band*.tif"
)
landsat_paths_pre.sort()
arr_st, meta = es.stack(landsat_paths_pre)
# Import the landsat qa layer
with rio.open(
"data/cold-springs-fire/landsat_collect/LC080340322016070701T1-SC20180214145604/crop/LC08_L1TP_034032_20160707_20170221_01_T1_pixel_qa_crop.tif"
) as landsat_pre_cl:
landsat_qa = landsat_pre_cl.read(1)
landsat_ext = plotting_extent(landsat_pre_cl)
###############################################################################
# Plot Histogram of Each Band in Your Data
# ----------------------------------------
# You can view a histogram for each band in your dataset by using the
# ``hist()`` function from the ``earthpy.plot`` module.
ep.hist(arr_st)
def test_stack_array_size_mismatch(in_paths_mismatch):
""" Test for error raised when array dimensions (nrows, ncols) are not all equal. """
with pytest.raises(ValueError, match="same dimensions"):
es.stack(in_paths_mismatch)
#
# To get started, make sure your directory is set. Then, create a stack from all
# of the Landsat .tif files (one per band).
# Get data for example
data = et.data.get_data("vignette-landsat")
# Set working directory
os.chdir(os.path.join(et.io.HOME, "earth-analytics"))
# Stack the Landsat 8 bands
# This creates a numpy array with each "layer" representing a single band
# You can use the nodata parameter to mask nodata values
landsat_path = glob(os.path.join("data", "vignette-landsat", "*band*.tif"))
landsat_path.sort()
array_stack, meta_data = es.stack(landsat_path, nodata=-9999)
###############################################################################
# Plot All Histograms in a Stack With Custom Titles and Colors
# -------------------------------------------------------------
#
# You can create histograms for each band with unique colors and titles by
# first creating a list of colors and titles that will be provided to the
# ep.hist() function. The list for titles must contain the same number of
# strings as there are bands in the stack. You can also modify the colors for
# each image with a list of Matplotlib colors. If one color is provided in
# the list, every band will inherit that color. Otherwise, the list must
# contain the same number of strings as there are bands in the stack.
# Create the list of color names for each band
colors_list = [
def test_stack_Affine_mismatch(in_paths_Affine_mismatch):
""" Test for error raised when raster Affine transform are not all equal. """
with pytest.raises(ValueError, match="same affine transform"):
es.stack(in_paths_Affine_mismatch)
def test_stack_CRS_mismatch(in_paths_CRS_mismatch):
""" Test for error raised when raster CRS are not all equal. """
with pytest.raises(ValueError, match="same CRS"):
es.stack(in_paths_CRS_mismatch)
# If you are running this script on a Windows system, there is a
# known bug with ``.to_crs()``, which is used in this script. If an error
# occurs, you have to reset your os environment with the command
# ``os.environ["PROJ_LIB"] = r"path-to-share-folder-in-environment"``.
# Get sample data from EarthPy and set working directory
data_path = et.data.get_data("vignette-landsat")
os.chdir(os.path.join(et.io.HOME, "earth-analytics"))
# Get list of bands and sort by ascending band number
landsat_bands_data_path = "data/vignette-landsat/LC08_L1TP_034032_20160621_20170221_01_T1_sr_band*[1-7]*.tif"
stack_band_paths = glob(landsat_bands_data_path)
stack_band_paths.sort()
# Create image stack and apply nodata value for Landsat
arr_st, meta = es.stack(stack_band_paths, nodata=-9999)
###############################################################################
# Plot RGB Composite Image
# --------------------------
# You can use the ``plot_rgb()`` function from the ``earthpy.plot`` module to quickly
# plot three band composite images. For RGB composite images, you will plot the red,
# green, and blue bands, which are bands 4, 3, and 2, respectively, in the image
# stack you created. Python uses a zero-based index system, so you need to subtract
# a value of 1 from each index. Thus, the index for the red band is 3, green is 2,
# and blue is 1. These index values are provided to the ``rgb`` argument to identify
# the bands for the composite image.
# Create figure with one plot
fig, ax = plt.subplots(figsize=(12, 12))
'C:/Users/Hadi Askari/Desktop/Sentinel 2/S2A_MSIL1C_20200301T054741_N0209_R048_T43SCT_20200301T085541.SAFE/GRANULE/L1C_T43SCT_A024498_20200301T055331/IMG_DATA/FaiziGreen.tif',
'C:/Users/Hadi Askari/Desktop/Sentinel 2/S2A_MSIL1C_20200301T054741_N0209_R048_T43SCT_20200301T085541.SAFE/GRANULE/L1C_T43SCT_A024498_20200301T055331/IMG_DATA/FaiziBlue.tif'
]
croppedbands = [rgbjp2s[0], rgbjp2s[1], rgbjp2s[2]]
outputstackpath = 'C:/Users/Hadi Askari/Desktop/Sentinel 2/S2A_MSIL1C_20200301T054741_N0209_R048_T43SCT_20200301T085541.SAFE/GRANULE/L1C_T43SCT_A024498_20200301T055331/IMG_DATA/stack.tif'
with rio.open(rgbjp2s[0]) as f:
checkred = f.read(1, masked=True)
with rio.open(rgbjp2s[1]) as f:
checkgreen = f.read(1, masked=True)
with rio.open(rgbjp2s[2]) as f:
checkblue = f.read(1, masked=True)
croppedbands_stack, croppedbands_meta = es.stack(croppedbands, outputstackpath)
print(croppedbands_stack.shape)
imgred = cv2.normalize(checkred,
0,
0,
255,
norm_type=cv2.NORM_MINMAX,
dtype=cv2.CV_8UC1)
equred = cv2.equalizeHist(imgred)
imggreen = cv2.normalize(checkgreen,
0,
0,
255,
norm_type=cv2.NORM_MINMAX,
