def test_combinig_hillshades_arrays(self):
"""test combining arrays (band calculator)
"""
dem_array = raster_funs.raster_2_array(self.input_dem)
hillshade_1_array = hillshade.hillshade(
dem_array, self.hill_params['azimuth1'],
self.hill_params['angle_altitude1'])
hillshade_2_array = hillshade.hillshade(
dem_array, self.hill_params['azimuth2'],
self.hill_params['angle_altitude2'])
hillshade_3_array = hillshade.hillshade(
dem_array, self.hill_params['azimuth3'],
self.hill_params['angle_altitude3'])
combined_array = bandCalc.merge_arrays(
[hillshade_1_array, hillshade_2_array, hillshade_3_array], [
self.hill_params['transparency1'],
self.hill_params['transparency2'],
self.hill_params['transparency3']
])
output_folder = os.path.join(tempfile.mkdtemp(), 'hillshader_results')
if not os.path.exists(output_folder):
os.mkdir(output_folder)
out_put = os.path.join(output_folder, 'combined_hillshade.tif')
raster_funs.array_2_raster(combined_array, self.input_dem, out_put)
self.assertTrue(os.path.exists(out_put))
self.assertNotAlmostEquals(0, combined_array.any())
self.assertEqual(combined_array.shape, (100, 100))
self.assertAlmostEqual(int(combined_array.max()), 255)
self.assertAlmostEqual(int(combined_array.min()), 0)
self.assertAlmostEqual(int(combined_array.mean()), 255 / 2)
def createAlgsList(self):
# First we populate the list of algorithms with those created
# extending GeoAlgorithm directly (those that execute GDAL
# using the console)
self.preloadedAlgs = [nearblack(), information(), warp(), translate(),
rgb2pct(), pct2rgb(), merge(), buildvrt(), polygonize(), gdaladdo(),
ClipByExtent(), ClipByMask(), contour(), rasterize(), proximity(),
sieve(), fillnodata(), ExtractProjection(), gdal2xyz(),
hillshade(), slope(), aspect(), tri(), tpi(), roughness(),
ColorRelief(), GridInvDist(), GridAverage(), GridNearest(),
GridDataMetrics(), gdaltindex(), gdalcalc(), rasterize_over(),
# ----- OGR tools -----
OgrInfo(), Ogr2Ogr(), Ogr2OgrClip(), Ogr2OgrClipExtent(),
Ogr2OgrToPostGis(), Ogr2OgrToPostGisList(), Ogr2OgrPointsOnLines(),
Ogr2OgrBuffer(), Ogr2OgrDissolve(), Ogr2OgrOneSideBuffer(),
Ogr2OgrTableToPostGisList(), OgrSql(),
]
# And then we add those that are created as python scripts
folder = self.scriptsFolder()
if os.path.exists(folder):
for descriptionFile in os.listdir(folder):
if descriptionFile.endswith('py'):
try:
fullpath = os.path.join(self.scriptsFolder(),
descriptionFile)
alg = GdalScriptAlgorithm(fullpath)
self.preloadedAlgs.append(alg)
except WrongScriptException as e:
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR, e.msg)
def createAlgsList(self):
# First we populate the list of algorithms with those created
# extending GeoAlgorithm directly (those that execute GDAL
# using the console)
self.preloadedAlgs = [nearblack(), information(), warp(), translate(),
rgb2pct(), pct2rgb(), merge(), polygonize(), gdaladdo(),
ClipByExtent(), ClipByMask(), contour(), rasterize(), proximity(),
sieve(), fillnodata(), ExtractProjection(), gdal2xyz(),
hillshade(), slope(), aspect(), tri(), tpi(), roughness(),
ColorRelief(), GridInvDist(), GridAverage(), GridNearest(),
GridDataMetrics(),
# ----- OGR tools -----
OgrInfo(), Ogr2Ogr(), OgrSql(),
]
# And then we add those that are created as python scripts
folder = self.scriptsFolder()
if os.path.exists(folder):
for descriptionFile in os.listdir(folder):
if descriptionFile.endswith('py'):
try:
fullpath = os.path.join(self.scriptsFolder(),
descriptionFile)
alg = GdalScriptAlgorithm(fullpath)
self.preloadedAlgs.append(alg)
except WrongScriptException, e:
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR, e.msg)
def test_generating_hillshades_array(self):
"""test generating partial hillshades arrays from dem
"""
dem_array = raster_funs.raster_2_array(self.input_dem)
hillshade_1 = hillshade.hillshade(dem_array,
self.hill_params['azimuth1'],
self.hill_params['angle_altitude1'])
hillshade_2 = hillshade.hillshade(dem_array,
self.hill_params['azimuth2'],
self.hill_params['angle_altitude2'])
hillshade_3 = hillshade.hillshade(dem_array,
self.hill_params['azimuth3'],
self.hill_params['angle_altitude3'])
self.assertIsNotNone(hillshade_1)
self.assertIsNotNone(hillshade_2)
self.assertIsNotNone(hillshade_3)
def createAlgsList(self):
# First we populate the list of algorithms with those created
# extending GeoAlgorithm directly (those that execute GDAL
# using the console)
self.preloadedAlgs = [
nearblack(),
information(),
warp(),
translate(),
rgb2pct(),
pct2rgb(),
merge(),
buildvrt(),
polygonize(),
gdaladdo(),
ClipByExtent(),
ClipByMask(),
contour(),
rasterize(),
proximity(),
sieve(),
fillnodata(),
ExtractProjection(),
gdal2xyz(),
hillshade(),
slope(),
aspect(),
tri(),
tpi(),
roughness(),
ColorRelief(),
GridInvDist(),
GridAverage(),
GridNearest(),
GridDataMetrics(),
gdaltindex(),
gdalcalc(),
rasterize_over(),
retile(),
gdal2tiles(),
# ----- OGR tools -----
OgrInfo(),
Ogr2Ogr(),
Ogr2OgrClip(),
Ogr2OgrClipExtent(),
Ogr2OgrToPostGis(),
Ogr2OgrToPostGisList(),
Ogr2OgrPointsOnLines(),
Ogr2OgrBuffer(),
Ogr2OgrDissolve(),
Ogr2OgrOneSideBuffer(),
Ogr2OgrTableToPostGisList(),
OgrSql(),
]
def createAlgsList(self):
# First we populate the list of algorithms with those created
# extending GeoAlgorithm directly (those that execute GDAL
# using the console)
self.preloadedAlgs = [
nearblack(),
information(),
warp(),
translate(),
rgb2pct(),
pct2rgb(),
merge(),
buildvrt(),
polygonize(),
gdaladdo(),
ClipByExtent(),
ClipByMask(),
contour(),
rasterize(),
proximity(),
sieve(),
fillnodata(),
ExtractProjection(),
gdal2xyz(),
hillshade(),
slope(),
aspect(),
tri(),
tpi(),
roughness(),
ColorRelief(),
GridInvDist(),
GridAverage(),
GridNearest(),
GridDataMetrics(),
gdaltindex(),
gdalcalc(),
rasterize_over(),
retile(),
gdal2tiles(),
# ----- OGR tools -----
OgrInfo(),
Ogr2Ogr(),
Ogr2OgrClip(),
Ogr2OgrClipExtent(),
Ogr2OgrToPostGis(),
Ogr2OgrToPostGisList(),
Ogr2OgrPointsOnLines(),
Ogr2OgrBuffer(),
Ogr2OgrDissolve(),
Ogr2OgrOneSideBuffer(),
Ogr2OgrTableToPostGisList(),
OgrSql(),
]
def gacode(post, pre, az, al):
#matrix_x variable is for entering the width of matrix
matrix_x = 40
#matrix_y variable is for entering the height of matrix
matrix_y = 40
#importin predtm and postdtm
#predtm= load_workbook(filename='D:\Study\sem 4\scope\matlb_landslide\postdtm.xlsx')
#postdtm= load_workbook(filename='D:\Study\sem 4\scope\matlb_landslide\predtm.xlsx')
predtm = pd.read_excel(pre, header=None, index_col=None)
predtm.as_matrix()
postdtm = pd.read_excel(post, header=None, index_col=None)
postdtm.as_matrix()
#azimuth
if az == -1:
az = 135
if int(al) == -1:
al = 100
ar = np.arange(0, 40)
arx = np.arange(0, matrix_x)
ary = np.arange(0, matrix_y)
postimg = hillshade(postdtm, az, al, -1)
pcsumxy = matrix_y * matrix_x - 3
generations = 20
populations = 30
rang = int(100)
delta = np.zeros((matrix_x, matrix_y, populations))
for i in range(0, populations):
delta[:, :, i] = np.random.rand(matrix_y, matrix_x) * rang * 2 - rang
best = np.zeros(generations)
for i in range(0, generations):
# now_generations_count=i
pctime = 0
# pc variable refers to the probability of crossover
pc = 0.8
if (pc > np.random.rand()):
# pcrandnew1 variable and pcrandnew2 variable are the places for new chromosomes
pcrandnew1 = 20
pcrandnew2 = 21
# each crossover supplies two new chromosomes
for j in range(18, 20):
delta[:, :,
j] = np.random.rand(matrix_y, matrix_x) * rang * 2 - rang
#each crossover produces two new chromosomes
while (pctime < 5):
pcrandbest1 = round(np.random.rand() * (19))
pcrandbest2 = round(np.random.rand() * (19))
pcrandpoint1 = 1 + round(np.random.rand() * (pcsumxy))
pcrandpoint2 = 1 + round(np.random.rand() * (pcsumxy))
selecttemp1 = delta[:, :, pcrandbest1]
selecttemp2 = delta[:, :, pcrandbest2]
selecttemp3 = np.zeros((matrix_x * matrix_y, ))
selecttemp4 = np.zeros((matrix_x * matrix_y, ))
j = 0
for k in range(0, matrix_x * matrix_y, matrix_x):
blk1 = selecttemp1[j]
blk2 = selecttemp2[j]
selecttemp3[k:k + matrix_x] = np.asarray(blk1)
selecttemp4[k:k + matrix_x] = np.asarray(blk2)
j = j + 1
selecttemp1 = np.transpose(selecttemp3)
selecttemp2 = np.transpose(selecttemp4)
if (pcrandpoint1 > pcrandpoint2):
pctemp = pcrandpoint2
pcrandpoint2 = pcrandpoint1
pcrandpoint1 = pctemp
for j in range(pcrandpoint1, pcrandpoint2 + 1):
pctemp = selecttemp1[j]
selecttemp1[j] = selecttemp2[j]
selecttemp2[j] = pctemp
delta[:, :, pcrandnew1] = np.reshape(selecttemp1,
(matrix_y, matrix_x))
delta[:, :, pcrandnew2] = np.reshape(selecttemp2,
(matrix_y, matrix_x))
pcrandnew1 = pcrandnew1 + 2
pcrandnew2 = pcrandnew2 + 2
pctime = (pctime + 1)
pmtime = 0
#pm variable refers to the probability of mutation
pm = 0.06
t = np.zeros(18)
for j in range(1, 18):
t[j] = np.random.rand()
if (pm > t[j]):
pmx = round(np.random.rand() * (matrix_x - 1))
pmy = round(np.random.rand() * (matrix_y - 1))
pmvolue = delta[pmy, pmx,
j] + (np.random.rand() * rang * 2 - rang)
while (abs(pmvolue) > rang):
pmvolue = delta[pmy, pmx,
j] + (np.random.rand(1) * rang * 2 - rang)
delta[pmy, pmx, j] = pmvolue
shadow = np.zeros((matrix_x, matrix_y, populations))
for j in range(0, populations):
shadow[:, :, j] = hillshade(np.add(predtm, delta[:, :, j]), az, al,
-1)
F = np.zeros(populations)
#calculates fitness function
for j in range(0, populations):
F[j] = corr2(shadow[:, :, j], postimg)
indexF = np.argsort(F)
delta_temp = np.zeros((matrix_x, matrix_y, populations))
shadow_temp = np.zeros((matrix_x, matrix_y, populations))
for j in range(0, populations):
delta_temp[:, :, j] = delta[:, :, indexF[populations - j - 1]]
shadow_temp[:, :, j] = shadow[:, :, indexF[populations - j - 1]]
for j in range(0, populations):
delta[:, :, j] = delta_temp[:, :, j]
shadow[:, :, j] = shadow_temp[:, :, j]
best[i] = np.max(F)
if i % 10000 == 0:
print(i)
bestrange = delta[:, :, 1]
#filter
bestdtm = np.add(predtm, bestrange)
print(bestdtm.shape)
bestrange_filter = np.zeros(bestdtm.shape)
for i in range(0, bestdtm.shape[0], 12):
for j in range(0, bestdtm.shape[1], 12):
block = bestdtm.iloc[i:i + 12, j:j + 12]
bestrange_filter[i:i + 12, j:j +
12] = np.median(block) * np.ones(block.shape)
for y in range(0, matrix_y):
for x in range(0, matrix_x):
if (bestrange_filter[y, x] == 0):
bestrange_filter[y, x] = bestdtm[y, x]
end_predtm = np.zeros((matrix_y - 6, matrix_x - 6))
end_postdtm = np.zeros((matrix_y - 6, matrix_x - 6))
end_filter = np.zeros((matrix_y - 6, matrix_x - 6))
end_bestrange = np.zeros((matrix_y - 6, matrix_x - 6))
for y in range(3, matrix_y - 3):
for x in range(3, matrix_x - 3):
end_bestrange[y - 3, x - 3] = bestrange[y, x]
for y in range(3, matrix_y - 3):
for x in range(3, matrix_x - 3):
end_filter[y - 3, x - 3] = bestrange_filter[y, x]
for y in range(3, matrix_y - 3):
for x in range(3, matrix_x - 3):
end_predtm[y - 3, x - 3] = predtm.iloc[y, x]
for y in range(3, matrix_y - 3):
for x in range(3, matrix_x - 3):
end_postdtm[y - 3, x - 3] = postdtm.iloc[y, x]
X_estimate = end_filter[16, :]
X_predtm = end_predtm[16, :]
X_postdtm = end_postdtm[16, :]
Y_estimate = end_filter[:, 16]
Y_predtm = end_predtm[:, 16]
Y_postdtm = end_postdtm[:, 16]
truedepth_del = 0
truedepth_add = 0
estimatedepth_del = 0
estimatedepth_add = 0
for y in range(0, matrix_y - 6):
for x in range(0, matrix_x - 6):
if (end_predtm[y, x] > end_postdtm[y, x]):
truedepth = end_predtm[y, x] - end_postdtm[y, x]
truedepth_del = truedepth + truedepth_del
if (end_predtm[y, x] < end_postdtm[y, x]):
truedepth = end_postdtm[y, x] - end_predtm[y, x]
truedepth_add = truedepth + truedepth_add
volume_true_del = ((truedepth_del))
volume_true_add = ((truedepth_add))
for y in range(0, matrix_y - 6):
for x in range(0, matrix_x - 6):
if (end_predtm[y, x] > end_filter[y, x]):
estimatedepth = end_predtm[y, x] - end_filter[y, x]
estimatedepth_del = estimatedepth + estimatedepth_del
if (end_predtm[y, x] < end_filter[y, x]):
estimatedepth = end_filter[y, x] - end_predtm[y, x]
estimatedepth_add = estimatedepth + estimatedepth_add
volume_estimate_del = ((estimatedepth_del))
volume_estimate_add = ((estimatedepth_add))
#output result
best_h = hillshade(np.add(predtm, bestrange), az, al, -1)
new_h = hillshade(postdtm, az, al, -1)
#convert postimg,best_h,new_h to img and show
'''
img1 = PIL.Image.fromarray(postimg)
img2 = PIL.Image.fromarray(best_h)
img3 = PIL.Image.fromarray(new_h)
cv2.imshow("post-event remote sensing image",img1)
cv2.imshow("estimate result shadow image",img2)
cv2.imshow("post-event DTM shadow image",img3)
'''
imageio.imwrite("post-eventDTM.png", new_h)
imageio.imwrite("estimate-result.png", best_h)
error = (abs(volume_true_del - volume_estimate_del) /
volume_true_del) * 100
error1 = 100 - corr2(best_h, new_h) * 100
row = [generations, volume_estimate_del, error1]
change = predtm - postdtm
with open('data.csv', 'a') as csvFile:
writer = csv.writer(csvFile)
writer.writerow(row)
csvFile.close()
return (volume_estimate_del, error1, change)
gt = DEM.GetGeoTransform()
dx = gt[1]
cellsize = dx
DEM = np.array(
DEM.GetRasterBand(1).ReadAsArray()) #convert gdal obj into np array
del (gt)
#import meta data regarding raster, for eventual exporting of filtered DEM
import rasterio as rio
with rio.open(dem_path) as src:
Meta = src.profile
#%% Visualize the imported DEM to confirm it appears as you expect
# the hillshade produced will be rather dark.
hs_array = hillshade(DEM)
#Plot hillshade
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.imshow(hs_array, cmap='Greys', alpha=0.9)
ax.plot()
#%% TEST 1: CWT
# This test requires patches of both the landslide and non-landslide to compare the power spectra between the two pieces of the landscape.
# This methodology follows Booth et al., (2009).
#### IMPORTANTLY!!! #### EACH TEST PATCH MUST BE CLIPPED SQUARE!
#This code is heavily adapted from code available here: http://web.pdx.edu/~boothad/tools.html
# It was originally writen in Matlab, but I have now adapted it for Python.
#%% os.chdir(r'U:\GHP\Projects\NSF - Morris Landslides\Code\Developmemnt') matplotlib.rcParams['figure.figsize'] = (8, 5.5) dem_path = os.path.join(os.getcwd(), 'sb_less_steep.tif') sbDEM = gdal.Open(dem_path) sbDEM = np.array(demFLD.GetRasterBand(1).ReadAsArray()) sbDEM[sbDEM == -9999.0] = np.nan sbDEM[sbDEM == -32767] = np.nan #View hillshade of the DEM from hillshade import hillshade hs_array = hillshade(demFLD) plt.imshow(hs_array, cmap='Greys') plt.show() #%% Now convolve landscape with the MexH at the appropriate scales from conv2_mexh2 import conv2_mexh2 [C2, _, _] = conv2_mexh2(sbDEM, 13, dx) [C3, _, _] = conv2_mexh2(sbDEM, 11, dx) [C4, _, _] = conv2_mexh2(sbDEM, 9, dx) [C5, _, _] = conv2_mexh2(sbDEM, 7, dx) [C6, _, _] = conv2_mexh2(sbDEM, 5, dx) [C7, _, _] = conv2_mexh2(sbDEM, 4, dx) [C8, _, _] = conv2_mexh2(sbDEM, 3, dx)
