def createCloudMask(band_array, path):
stacked = np.stack(band_array, -1)
# print(stacked / 10000)
# swapped = np.moveaxis(stacked, 0, 2) # shape (y_pixels, x_pixels, n_bands)
arr4d = np.expand_dims(
stacked / 10000, 0
) # shape (1, y_pixels, x_pixels, n_bands) # s2cloudless requires binary map
cloud_detector = S2PixelCloudDetector(threshold=0.7,
average_over=4,
dilation_size=2)
cloud_prob_map = cloud_detector.get_cloud_probability_maps(np.array(arr4d))
cloud_masks = cloud_detector.get_cloud_masks(np.array(arr4d))
# show files
plt.figure(figsize=(50, 50))
plt.imshow(np.squeeze(
cloud_masks)) # check whz process not stopping, when closing
plt.show()
# save files
template_file = "/home/Usuario/Documents/sentinelHub/S2A_MSIL1C_20190904T140051_N0208_R067_T21LWH_20190904T172119.SAFE/GRANULE/L1C_T21LWH_A021943_20190904T140439/IMG_DATA/T21LWH_20190904T140051_B01.jp2"
print(template_file)
out_prob = path[:-31] + "out_prob.tif"
out_mask = path[:-31] + "out_mask.tif"
output = gdal_array.SaveArray(cloud_prob_map[0, :, :],
out_prob,
format="GTiff",
prototype=template_file)
output = None
output = gdal_array.SaveArray(cloud_masks[0, :, :],
out_mask,
format="GTiff",
prototype=template_file)
output = None
def save_results_to_tif(bfast_array, method, name):
'''
Saves BFAST results to a .tif file
Input:
bfast_array: Array [] with BFAST classifications
method: String "" If Monhtly Images or BAP Images were used and breaks or mean
name: String "" Name of the Index and tile
'''
if name.find('LYH') != -1:
template_file = '/scratch/tmp/s_lech05/hls_data/21LYH/template_file_21LYH.tif'
out_path = '/scratch/tmp/s_lech05/hls_data/21LYH/' + name + method + '_bfast.tif'
output = gdal_array.SaveArray(bfast_array,
out_path,
format="GTiff",
prototype=template_file)
print("saved file to " + out_path)
out_path = None
output = None
bfast_array = None
template_file = None
else:
template_file = '/scratch/tmp/s_lech05/hls_data/21LYG/template_file_21LYG.tif'
out_path = '/scratch/tmp/s_lech05/hls_data/21LYG/' + name + method + '_bfast.tif'
output = gdal_array.SaveArray(bfast_array,
out_path,
format="GTiff",
prototype=template_file)
print("saved file to " + out_path)
out_path = None
output = None
bfast_array = None
template_file = None
def create_mask(band_array, path):
"""Crete the mask."""
stacked = np.stack(band_array, -1)
# shape (1, y_pixels, x_pixels, n_bands)
# s2cloudless requires binary map
arr4d = np.expand_dims(stacked / 10000, 0)
cloud_detector = S2PixelCloudDetector(threshold=0.7,
average_over=4,
dilation_size=2)
cloud_prob_map = cloud_detector.get_cloud_probability_maps(np.array(arr4d))
cloud_masks = cloud_detector.get_cloud_masks(np.array(arr4d))
template_file = [
os.path.join(path, item) for item in os.listdir(path)
if item.endswith("01.jp2")
][0]
# save files
out_prob = os.path.dirname(path) + "_s2cloudless_prob.tif"
out_mask = os.path.dirname(path) + "_s2cloudless_mask.tif"
output = gdal_array.SaveArray(cloud_prob_map[0, :, :],
out_prob,
format="GTiff",
prototype=template_file)
output = None
output = gdal_array.SaveArray(cloud_masks[0, :, :],
out_mask,
format="GTiff",
prototype=template_file)
output = None
return (out_prob, out_mask)
def doit(src_filename, dst_magnitude, dst_phase):
src_ds = gdal.Open(src_filename)
xsize = src_ds.RasterXSize
ysize = src_ds.RasterYSize
print('{} x {}'.format(xsize, ysize))
src_image = src_ds.GetRasterBand(1).ReadAsArray()
mag_image = pow(np.real(src_image) * np.real(src_image) +
np.imag(src_image) * np.imag(src_image), 0.5)
gdal_array.SaveArray(mag_image, dst_magnitude)
phase_image = np.angle(src_image)
gdal_array.SaveArray(phase_image, dst_phase)
return 0
def create_clear_sky_image(path):
hls_dataset = gdal.Open(path)
cloud_mask = gdal.Open(path[:-3] + "/cloud_mask.tif")
if not cloud_mask:
return
cloud_mask_array = cloud_mask.ReadAsArray()
invert_cloud_mask_array = np.zeros_like(cloud_mask_array)
invert_cloud_mask_array[cloud_mask_array == 0] = 1
invert_cloud_mask_array[cloud_mask_array == 1] = 0
clear_sky_paths = []
subdatasets = hls_dataset.GetSubDatasets()
for dataset_path in subdatasets:
dataset = gdal.Open(dataset_path[0])
dataset_array = dataset.ReadAsArray()
clear_sky_array = dataset_array * invert_cloud_mask_array
template_file = dataset
out_path = path[:-3] + "/" + dataset_path[0][-3:] + '_clear_sky.tif'
if (os.path.isfile(out_path)):
clear_sky_paths.append(out_path)
continue
clear_sky_file = gdal_array.SaveArray(clear_sky_array,
out_path,
format="GTiff",
prototype=template_file)
clear_sky_file = None
print(f"Finished creating clear_sky images for file {path}")
return clear_sky_paths
def raster_band2jpeg(infile, band, outfile, format='JPEG'):
''' raster_band2jpeg() - Extract a raster band to a file
Parameters
----------
infile : str
input file name
band : int
image band to process
outfile : str
output file name
format : str, default='JPEG'
output file format
Returns
-------
nothing
'''
from osgeo import gdal_array as gdal_array
srcArray = gdal_array.LoadFile(infile)
band = srcArray[band - 1]
gdal_array.SaveArray(band, outfile, format=format)
return
def save_ind_img(path, array_img, name, tile, overwrite, metadata):
month = extract_sensing_month(metadata)
year = extract_sensing_year(metadata)
day = extract_sensing_day(metadata)
if month < 10:
month = "0" + str(month)
if day < 10:
day = "0" + str(day)
out_path = f"{path}/{name}d{day}m{month}y{year}.tif"
if (os.path.isfile(out_path) and not overwrite):
print(f"file {out_path} already exists")
return
ind_output = gdal_array.SaveArray(
array_img,
out_path,
format="GTiff",
prototype=
f"../../../../scratch/tmp/s_lech05/hls_data/{tile}/template_file_{tile}.tif"
)
print(f"saved file to {out_path}")
daystring = extract_sensing_day_from_filename(out_path)
monthstring = extract_sensing_month_from_filename(out_path)
yearstring = extract_sensing_year_from_filename(out_path)
print(f"day: {daystring}, month:{monthstring} year:{yearstring}")
ind_output = None
def doit(src_filename, dst_filename):
class_defs = [(1, 10, 20),
(2, 20, 30),
(3, 128, 255)]
src_ds = gdal.Open(src_filename)
xsize = src_ds.RasterXSize
ysize = src_ds.RasterYSize
src_image = gdal_array.LoadFile(src_filename)
dst_image = np.zeros((ysize, xsize))
for class_info in class_defs:
class_id = class_info[0]
class_start = class_info[1]
class_end = class_info[2]
class_value = np.ones((ysize, xsize)) * class_id
mask = np.bitwise_and(
np.greater_equal(src_image, class_start),
np.less_equal(src_image, class_end))
dst_image = np.choose(mask, (dst_image, class_value))
gdal_array.SaveArray(dst_image, dst_filename)
def classify(file_path, file_name, classes, lut, start=0):
"""
分类并保存为图片
:param file_path:
:param file_name
:param classes: 分类区间
:param lut: 颜色 RGB 元祖, len(classes)+1
:param start
:return:
"""
# 读取数据
src_arr = read_nc_data(file_path, var='APCP_surface')
# 根据类别数目将直方图分割成5个颜色区间
# classes = gdal_array.numpy.histogram(srcArr, bins=5)[1]
# 创建一个RGB颜色的JPEG输出图片
rgb = gdal_array.numpy.zeros((3, src_arr.shape[0], src_arr.shape[1]), gdal_array.numpy.float32)
# 处理所有类并声明颜色
for i in range(len(classes)):
mask = gdal_array.numpy.logical_and(start <= src_arr, src_arr <= classes[i])
for j in range(len(lut[i])):
rgb[j] = gdal_array.numpy.choose(mask, (rgb[j], lut[i][j]))
start = classes[i] + 0.001 # 0.001 要<=像元值精度
# 保存图片
output = gdal_array.SaveArray(rgb.astype(gdal_array.numpy.uint8), file_name, format='JPEG')
# 取消输出避免在某些平台上损坏文件
output = None
def img_stretch(infile, outfile):
'''img_stretch() - Stretch the color bands of an image
Parameters
----------
infile : str
image file name
outfile : str
modified image output file name
Returns
-------
nothing
'''
from osgeo import gdal_array as gdal_array
from stretch import stretch
arr = gdal_array.LoadFile(infile)
stretched = stretch(arr)
output = gdal_array.SaveArray(arr,
outfile,
format='GTiff',
prototype=infile)
output = None
return
def img_swap_bands(infile, outfile, band1=1, band2=2):
''' img_swap_bands() - Reads a TIFF file, swaps two bands, and saves it
Parameters
----------
infile : str
input image file name
outfile : str
output image file name
band1, band2 : int
bands to be swapped
Return
------
nothing
'''
from osgeo import gdal_array as gdal_array
arr = gdal_array.LoadFile(infile)
output = gdal_array.SaveArray(arr[[band1, 0, 2], :],
outfile,
format='GTIFF',
prototype=infile)
# prototype copies the georeferencing information to output file
output = None # force release from memory
return
def save_ind_img(path, ind, name, template_file):
out_path = path + name + '.tif'
if (os.path.isfile(out_path)):
return
# print(f"saved file to {out_path}")
ind_output = gdal_array.SaveArray(ind, out_path, format="GTiff", prototype=gdal.Open(template_file))
ind_output = None
def classify(file, src_raster):
"""
分类并保存为图片
:param file:
:param src_raster:
:return:
"""
classes = np.array([0, 3, 10, 20, 50, 70, 1000])
lut = [[255, 255, 255], [154, 250, 142], [60, 163, 10], [106, 178, 250],
[8, 21, 255], [70, 251, 247], [111, 13, 10]]
start = 0.0001
# 读取数据
data = gdal_array.LoadFile(src_raster)
data[data == 0] = None
# 根据类别数目将直方图分割成5个颜色区间
# classes = gdal_array.numpy.histogram(srcArr, bins=5)[1]
# 创建一个RGB颜色的JPEG输出图片
rgb = gdal_array.numpy.zeros((3, data.shape[0], data.shape[1]),
gdal_array.numpy.float32)
# 处理所有类并声明颜色
for i in range(len(classes)):
mask = gdal_array.numpy.logical_and(start <= data, data <= classes[i])
for j in range(len(lut[i])):
rgb[j] = gdal_array.numpy.choose(mask, (rgb[j], lut[i][j]))
start = classes[i] + 0.001 # 0.001 要<=像元值精度
# 保存图片
output = gdal_array.SaveArray(rgb.astype(gdal_array.numpy.uint8),
file,
format='PNG')
# 取消输出避免在某些平台上损坏文件
output = None
def array3DToImage(self, imageArray=None, rasterFormat='ERDAS'):
'''
Saves a 3D array to an image file of type HFA.
NOTE. THIS WILL NOT REQUIRE TO OPEN A HOLDER data set.
It will use like_src_dataset
'''
#FIXME:error if the name and out_name are not the same...shijo's problem check in outFileExt...weird...
#FIXME: try to solve the need of outfileExt
def update():
self.out_filename = self.name[:-4] + '_new'
self.outfileExt = self.name[
-4:] # required to test for name duplicates
if self.out_path == None:
self.out_path = 'D://My Docs//working//out_images//'
pass
if imageArray == None:
imageArray = self.asArray()
pass
if self.out_filename == None:
update(
) # It will make a copy of itself if no out filename is given.
if (self.name == (self.out_filename + self.outfileExt)): update()
self.status = None
idriver, fileExt = self.knownRasterFormats[rasterFormat]
self.outfileExt = fileExt
outfilenamePlusPath = self.out_path + self.out_filename + self.outfileExt
oga.SaveArray(imageArray,
outfilenamePlusPath,
format=idriver,
prototype=self.dataset)
self.status = True
pass
def test_on_image(self,
image_dir,
output_dir,
lr_block_size=(20, 20),
metrics=[psnr, r2]):
# Load images
print('loading image pairs from {}'.format(image_dir))
input_images, valid_image = load_image_pairs(image_dir,
scale=self.scale)
assert len(input_images) == 3
name = input_images[-1].filename.name if hasattr(
input_images[-1], 'filename') else ''
print('Predict on image {}'.format(name))
# Generate output image and measure run time
# x_inputs的shape为四数组(数目，长度，宽度，通道数)
x_inputs = [self.validate(img_to_array(im)) for im in input_images]
assert x_inputs[0].shape[1] % lr_block_size[0] == 0
assert x_inputs[0].shape[2] % lr_block_size[1] == 0
x_train, _ = load_test_set((input_images, valid_image),
lr_block_size=lr_block_size,
scale=self.scale)
model = self.compile(self.build_model(*x_train))
if self.model_file.exists():
model.load_weights(str(self.model_file))
t_start = time.perf_counter()
y_preds = model.predict(x_train, batch_size=1) # 结果的shape为四维
# 预测结束后进行恢复
y_pred = np.empty(x_inputs[1].shape[-3:], dtype=np.float32)
row_step = lr_block_size[0] * self.scale
col_step = lr_block_size[1] * self.scale
rows = x_inputs[0].shape[2] // lr_block_size[1]
cols = x_inputs[0].shape[1] // lr_block_size[0]
count = 0
for j in range(rows):
for i in range(cols):
y_pred[i * row_step:(i + 1) * row_step,
j * col_step:(j + 1) * col_step] = y_preds[count]
count += 1
assert count == rows * cols
t_end = time.perf_counter()
# Record metrics
row = pd.Series()
row['name'] = name
row['time'] = t_end - t_start
y_true = self.validate(img_to_array(valid_image))
y_pred = self.validate(y_pred)
for metric in metrics:
row[metric.__name__] = K.eval(metric(y_true, y_pred))
prototype = str(valid_image.filename) if hasattr(
valid_image, 'filename') else None
gdal_array.SaveArray(y_pred[0].squeeze().astype(np.int16),
str(output_dir / name),
prototype=prototype)
return row
def func_standardFakeColor(self, count1, count2, count3):
'''
图像预处理：
假彩色处理（图像变换），对已加载的影像进行假彩色合成处理,用户可自定义红绿蓝三通道分别选取何种波段。
'''
self.showpanel.append(
"当前操作--假彩色变换，请等待--------------------------------")
if self.noPictureWarn() == False: # 处理异常
return
path = self.path
arr = gdal_array.LoadFile("{}".format(path))
prepicture_path = "optimized/standardFakeColor.tif"
output = gdal_array.SaveArray(arr[[count1, count2, count3], :],
prepicture_path,
format="GTiff",
prototype=path)
output = None # 取消输出避免在某些平台上损坏文件
img = cv.imread("{}".format(prepicture_path))
img = cv.cvtColor(img, cv.COLOR_BGR2RGB)
x = img.shape[1]
y = img.shape[0]
self.zoomscale = 1
frame = QImage(img, x, y, QImage.Format_RGB888)
pix = QPixmap.fromImage(frame)
self.item.setPixmap(pix)
self.scene.addItem(self.item)
self.showpanel.append("standard fake color over") #通知栏打印结果
def save_results_to_tif(bfast_array, method, name):
if name.find('LYH') != -1:
template_file = '/data/sarah/pythonscripts/hls/Images/21LYH/2018/L30/HLS.L30.T21LYH.2018019.v1.4/d01_clear_sky.tif'
out_path = '/data/sarah/pythonscripts/hls/Images/21LYH/' + name + method + '_bfast_tif'
output = gdal_array.SaveArray(bfast_array,
out_path,
format="GTiff",
prototype=template_file)
output = None
else:
template_file = '/data/sarah/pythonscripts/hls/Images/21LYG/2016/L30/HLS.L30.T21LYG.2016110.v1.4/d01_clear_sky.tif'
out_path = '/data/sarah/pythonscripts/hls/Images/21LYG/' + name + method + '_bfast_tif'
output = gdal_array.SaveArray(bfast_array,
out_path,
format="GTiff",
prototype=template_file)
output = None
def controller_for_clip(work_dir, input_tif, input_shp, output_tif):
#work_dir 裁剪功能工作目录，定义这个后可基于此调用相对路径
#input_tif 用于裁剪的Tif数据的相对路径
#input_shp 用于裁剪的栅格shp数据的相对路径
#output_tif 输出Tif数据
#下面是一个例子
os.chdir(work_dir)
run = CHANGE()
# 用于裁剪的栅格数据
raster = input_tif
# 用于裁剪的多边形shp文件
shp = input_shp
# 裁剪后的栅格数据
output = output_tif
src_array = gdal_array.LoadFile(raster)
# 同时载入gdal库的图片从而获取geotransform
src_image = gdal.Open(raster)
geo_trans = src_image.GetGeoTransform()
# 使用PyShp库打开shp文件
r = shapefile.Reader("{}.shp".format(shp))
# 将图层扩展转换为图片像素坐标
min_x, min_y, max_x, max_y = r.bbox
ul_x, ul_y = run.world_to_pixel(geo_trans, min_x, max_y)
lr_x, lr_y = run.world_to_pixel(geo_trans, max_x, min_y)
# 计算新图片的尺寸
px_width = int(lr_x - ul_x)
px_height = int(lr_y - ul_y)
clip = src_array[:, ul_y:lr_y, ul_x:lr_x]
# 为图片创建一个新的geomatrix对象以便附加地理参照数据
geo_trans = list(geo_trans)
geo_trans[0] = min_x
geo_trans[3] = max_y
# 在一个空白的8字节黑白掩膜图片上把点映射为像元绘制市县
# 边界线
pixels = []
for p in r.shape(0).points:
pixels.append(run.world_to_pixel(geo_trans, p[0], p[1]))
raster_poly = Image.new("L", (px_width, px_height), 1)
# 使用PIL创建一个空白图片用于绘制多边形
rasterize = ImageDraw.Draw(raster_poly)
rasterize.polygon(pixels, 0)
# 使用PIL图片转换为Numpy掩膜数组
mask = run.image_to_array(raster_poly)
# 根据掩膜图层对图像进行裁剪
clip = gdal_array.numpy.choose(mask,
(clip, 0)).astype(gdal_array.numpy.float)
# 将裁剪结果保存为tiff文件
gdal_array.SaveArray(clip,
"{}.tif".format(output),
format="GTiff",
prototype=raster)
def write_gdal_grid(filename, grid, griddef):
ps_x = (griddef[2] - griddef[0]) / (griddef[4] - 1)
ps_y = (griddef[3] - griddef[1]) / (griddef[5] - 1)
geotransform = (griddef[0] - ps_x * 0.5, ps_x, 0.0,
griddef[1] - ps_y * 0.5, 0.0, ps_y)
grid = grid.astype(numpy.float32)
ds = gdal_array.SaveArray(grid, filename, format='CTable2')
ds.SetGeoTransform(geotransform)
def img_diff(img1, img2, outfile):
''' img_diff() - Perform a simple difference image change detection
on matched 'before' and 'after' images
Parameters
----------
img1 : str
input image file name
img2 : str
input image file name
outfile : str
output image file name
Return
------
nothing
'''
from osgeo import gdal_array as gdal_array
import numpy as np
# Load before and after into arrays
ar1 = gdal_array.LoadFile(img1).astype(np.int8)
ar2 = gdal_array.LoadFile(img2)[1].astype(np.int8)
diff = ar2 - ar1 # Perform a simple array difference on the images
# Set up our classification scheme to try and isolate significant changes
classes = np.histogram(diff, bins=5)[1]
# The color black is repeated to mask insignificant changes
lut = [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 255, 0],
[255, 0, 0]]
start = 1 # Starting value for classification
# Set up the output image
rgb = np.zeros((
3,
diff.shape[0],
diff.shape[1],
), np.int8)
for i in range(len(classes)): # Process all classes and assign colors
mask = np.logical_and(start <= diff, diff <= classes[i])
for j in range(len(lut[i])):
rgb[j] = np.choose(mask, (rgb[j], lut[i][j]))
start = classes[i] + 1
output = gdal_array.SaveArray(rgb, outfile, format='GTiff', prototype=img2)
output = None # explicitly release memory
return
def calculateNdvi(clip_raster, ndvi_raster):
print("calculate NDVI...")
img_array = ga.LoadFile(clip_raster)
a = img_array[3] - img_array[2]
b = img_array[3] + img_array[2]
ndvi_array = a / b
outndvi = ga.SaveArray(ndvi_array,
ndvi_raster,
format="GTiff",
prototype=clip_raster)
outndvi = None
def saveGTiff(ndarray, fileName):
"""
ndarray保存为GTiff格式图片\n
参数：\n
ndarray - (ndarray)图片\n
fileName - (str)文件名\n
返回值：\n
None
"""
ga.SaveArray(ndarray, fileName, format="GTiff")
return
def thumbnail(root_scene, scene_dir, verbose=False):
red_file = '%s/%s_B4.TIF' % (scene_dir, root_scene)
grn_file = '%s/%s_B3.TIF' % (scene_dir, root_scene)
blu_file = '%s/%s_B2.TIF' % (scene_dir, root_scene)
if not os.path.exists(red_file) or not os.path.exists(grn_file) \
or not os.path.exists(blu_file):
print 'Missing one or more of %s, %s and %s, skip thumbnailing.' % (
red_file, grn_file, blu_file)
return
large_thumbnail = numpy.array([
get_band(red_file, 15),
get_band(grn_file, 15),
get_band(blu_file, 15)])
small_thumbnail = numpy.array([
get_band(red_file, 3),
get_band(grn_file, 3),
get_band(blu_file, 3)])
# Set the scale values for both images from the larger one:
scale_min, scale_max = get_scale(large_thumbnail)
large_thumbnail = scale_image(large_thumbnail, scale_min, scale_max)
small_thumbnail = scale_image(small_thumbnail, scale_min, scale_max)
# TODO: Georeference these jpegs
gdal_array.SaveArray(
large_thumbnail,
'%s/%s_thumb_large.jpg' % (scene_dir, root_scene),
format = 'JPEG')
gdal_array.SaveArray(
small_thumbnail,
'%s/%s_thumb_small.jpg' % (scene_dir, root_scene),
format = 'JPEG')
for filename in os.listdir(scene_dir):
if filename.endswith('.aux.xml'):
os.unlink(os.path.join(scene_dir,filename))
def water_from_dem(self):
slope = os.path.join(self.dem_dir, self.tile + "_dem_slope_4326.tif")
slope2 = os.path.join(self.dem_dir,
self.tile + "_dem_slope_4326_2.tif")
data = gdal_array.LoadFile(slope)
# De-speckle
data = scipy.signal.medfilt2d(data, kernel_size=3)
gdal_array.SaveArray(data.astype(numpy.int8),
slope2,
prototype=gdal.Open(slope))
print "saved water from dem", slope2
def runRF(index, path, year, X, y, ts, tile, bap):
'''
Runs RF algorithm
Input:
index: String Name of index for which RF runs
path: String Folder to save the result
year: Int year for which RF runs
X:sample data (pixel values)
y:corresponding labels of pixel
ts: timeseries (3D index array)
bap: Boolean, BAP timeseries?
Output:
saves classification result to .tif file
'''
# Tell GDAL to throw Python exceptions, and register all drivers
gdal.UseExceptions()
gdal.AllRegister()
img = np.asarray(ts)
print('Creating classifier')
# Initialize model with 500 trees
rf = RandomForestClassifier(n_estimators=500, oob_score=True)
# Fit model to training data
rf = rf.fit(X, y)
print('Our OOB prediction of for index {ind} accuracy is: {oob}%'.format(oob=rf.oob_score_ * 100, ind=index))
print(img.shape[2])
new_shape = (img.shape[0] * img.shape[1], img.shape[2])
img_as_array = img.reshape(new_shape)
print('Reshaped from {o} to {n}'.format(o=img.shape,
n=img_as_array.shape))
img_as_array = np.where(np.isnan(img_as_array), -9999, img_as_array.astype('float32'))
img_as_array = np.where(np.isinf(img_as_array), -9999, img_as_array.astype('float32'))
class_prediction = rf.predict(img_as_array)
print(class_prediction.shape)
#Labels: 1 - Forest; 2- Pasture; 3 - Agriculture 4- Deforestation
class_prediction = class_prediction.reshape(img.shape[0], img.shape[1])
# first_img = class_prediction[:, :, 0]
if bap:
out_path = path + 'classified_BAP' + index + str(year) + '.gtif'
else:
out_path = path + 'classified_Months' + index + str(year) + '.gtif'
prediction_file = gdal_array.SaveArray(class_prediction, out_path, format="GTiff",
prototype=path + "template_file_" + tile + '.tif')
print(f"classified TS saved to {out_path}")
prediction_file = None
""" class_prediction = class_prediction.reshape(img[:, :, 0].shape)
def writeBandsAsImages(self, imageArray=None, rasterFormat='ERDAS'):
'''
Reads a GDAL supported image and save each individual band as a new file
in a different or current GDAL image supported formats. It keep when possible
the metadata from the source image.
- outPath should be in the format: D:\\working\\path\\
- outfilename should not have extension.
outFormat:
ERDAS imaging = 'HFA'
Geotiff format = 'GTiff'
Idrisi fomat = 'RST'
Ilwis format = 'ILWIS'
'''
years = [98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8]
months = [4, 5, 6, 7, 8, 9, 10, 11, 12, 1, 2, 3]
day = [1, 2, 3]
names = [
'NDV' + str(iyear).zfill(2) + str(imonth).zfill(2) + str(iday) +
'PL' for iyear in years for imonth in months for iday in day
]
def update():
self.out_filename = self.name[:-4]
if self.out_path == None:
self.out_path = 'D://My Docs//working//out_test//'
pass
if imageArray == None:
imageArray = self.asArray()
pass
if self.out_filename == None:
update(
) # It will make a copy of itself if no out filename is given.
self.status = None
idriver, fileExt = self.knownRasterFormats[rasterFormat]
self.outfileExt = fileExt
for iband in range(imageArray.shape[0]):
#output = self.out_path+self.out_filename+'_b'+str(iband+1).zfill(3)+self.outfileExt
output = self.out_path + names[iband] + self.outfileExt
# Without the prototype will not save properly.
oga.SaveArray(imageArray[iband, :, :],
output,
format=idriver,
prototype=self.dataset,
INTERLEAVE='BIL')
pass
return True
def save_cloud_mask(path, cloud_mask):
out_path = path[:-3] + "/" + "cloud_mask.tif"
if path.find("cirrus") != -1:
path = path[:-6]
if path.find("cloud") != -1:
path = path[:-5]
if path.find("shadow") != -1:
path = path[:-6]
if path.find("adj") != -1:
path = path[:-3]
if path.find('LYH') != -1:
template_file = '/scratch/tmp/s_lech05/hls_data/21LYH/template_file_21LYH.tif'
else:
template_file = '/scratch/tmp/s_lech05/hls_data/21LYG/template_file_21LYG.tif'
output = gdal_array.SaveArray(cloud_mask,
out_path,
format="GTiff",
prototype=template_file)
output = None
def tif_to_mask(model,
sheet: str,
display: bool = False,
threshold=0.5,
output: str = None):
ds = gdal.Open(
'{0}.tif'.format(sheet)
) #get from https://data.linz.govt.nz/layer/51870-wellington-03m-rural-aerial-photos-2012-2013/
ary = np.dstack([ds.GetRasterBand(i).ReadAsArray() for i in range(1, 5)])
print('Input tif has shape:', ary.shape)
# Convert raster array to tiles, need to ensure it is perfectly tiled!!
W_test, excluded = ary_to_tiles(ary, shape=(256, 256))
if excluded > 0:
print((excluded, ), *ary.shape)
raise ValueError('''
Need to ensure perfect tiles to create full mask of input tif!
You have missed {0} tiles from an input raster array of shape ({1},{2})
Try and find common factors for the input shape {1},{2}
to input into the (img_height, img_width) parameters instead of ({4},{5})
'''.format((excluded, ), *ary.shape, 256, 256))
W_hat_test = model.predict(W_test, verbose=1)
#print('Finished predict on {0} tiles of shape ({1},{2}) for: {4}'.format(*W_hat_test.shape + (sheet,)))
W_hat_ary = tiles_to_ary(stacked_ary=W_hat_test, final_shape=ary.shape[:2])
output_ary = W_hat_ary[:, :, 0]
output_ary[output_ary < threshold] = 0
output_ary[output_ary >= threshold] = 1
if output != None:
print('Output to:', output)
out_ds = gdal_array.SaveArray(output_ary,
output,
"gtiff",
prototype=ds)
del out_ds
del ds #close opened tif
return W_hat_ary
def changeDetection(image1, image2, outputname):
ar1 = gdalnumeric.LoadFile(image1).astype(np.int8)
ar2 = gdalnumeric.LoadFile(image2)[1].astype(np.int8)
diff = ar2 - ar1
classes = np.histogram(diff, bins=5)[1]
lut = [[0,0,0], [0,0,0], [0,0,0], [0,0,0], [0,255,0], [255,0,0]]
start = 1
rgb = np.zeros((3, diff.shape[0], diff.shape[1],), np.int8)
for i in range(len(classes)):
mask = np.logical_and(start <= diff, diff <= classes[i])
for j in range(len(lut[i])):
rgb[j] = np.choose(mask, (rgb[j], lut[i][j]))
start = classes[i] + 1
gdal_array.SaveArray(rgb, outputname, format="GTiff")
def segment_by_scene(scene_name):
csv_path = "data/csv/%s.csv" % scene_name
with open(csv_path, 'rb') as csvfile:
reader = csv.reader(csvfile, delimiter=',')
index = 0
for row in reader:
# reading data
filename = "%s_%d" % (scene_name, index)
print("Processing", filename)
d = int(row[2])
if d == 1 or d == 2 or d == 3 or d == 6:
# preparing result folders
directory = 'results/D%d/%s' % (d, filename)
if not os.path.exists(directory):
os.makedirs(directory)
data, size_row, size_column, size_band = read_image(
filename, d)
mode = [(0, 0, np.array([0])), (1, 1, np.array([0])),
(2, 2, np.array([0])), (3, 3, np.array([0])),
(4, 2, np.array([1, 2, 3, 4])),
(5, 2, np.array([0, 1, 2, 3, 4])),
(6, 2, np.array([0, 4]))]
for alg, wmode, band_idx in mode:
"""
Stage 1: coarse candidates selection using abnormality threshold
"""
abnormal, binary_img = calc_binary_img(
data, band_idx, size_column, size_row, wmode)
# save temp results
gdal_array.SaveArray(
abnormal, 'results/D%d/%s/%d.tif' % (d, filename, alg),
"GTiff")
cv2.imwrite('results/D%d/%s/%d.png' % (d, filename, alg),
binary_img)
index += 1
