def test_get_lat_lon(self):
from utilities.nctools import get_lat_lon
pixelwidth = 0.045
pixelheight = 0.055
extent = [145.00, -13.00, 146.00, -14.00]
expect_lat = [
-13.0275, -13.0825, -13.1375, -13.1925, -13.2475, -13.3025,
-13.3575, -13.4125, -13.4675, -13.5225, -13.5775, -13.6325,
-13.6875, -13.7425, -13.7975, -13.8525, -13.9075, -13.9625
]
expect_lon = [
145.0225, 145.0675, 145.1125, 145.1575, 145.2025, 145.2475,
145.2925, 145.3375, 145.3825, 145.4275, 145.4725, 145.5175,
145.5625, 145.6075, 145.6525, 145.6975, 145.7425, 145.7875,
145.8325, 145.8775, 145.9225, 145.9675
]
lon, lat = get_lat_lon(extent, pixelwidth, pixelheight)
assert_almost_equal(expect_lon, lon, decimal=2)
assert_almost_equal(expect_lat, lat, decimal=2)
def convo_combine(ms_orig, slope_array, aspect_array):
"""
Apply convolution to the orginal shielding factor for each direction and
call the :term:`combine` module to consider the slope and aspect and remove
conservitism to get final shielding multiplier values
:param ms_orig: `file` the original shidelding factor map
:param slope_array: :class:`numpy.ndarray` the input slope values
:param aspect_array_reclassify: :class:`numpy.ndarray` input aspect values
"""
# import pdb
# pdb.set_trace()
ms_orig_ds = gdal.Open(ms_orig)
# get image size, format, projection
cols = ms_orig_ds.RasterXSize
rows = ms_orig_ds.RasterYSize
geotransform = ms_orig_ds.GetGeoTransform()
x_left = geotransform[0]
y_upper = -geotransform[3]
pixelwidth = geotransform[1]
pixelheight = -geotransform[5]
lon, lat = get_lat_lon(x_left, y_upper, pixelwidth, pixelheight, cols, rows)
band = ms_orig_ds.GetRasterBand(1)
data = band.ReadAsArray(0, 0, cols, rows)
if ms_orig_ds is None:
log.info('Could not open {0}'.format(ms_orig))
sys.exit(1)
x_m_array, y_m_array = get_pixel_size_grids(ms_orig_ds)
pixelwidth = 0.5 * (np.mean(x_m_array) + np.mean(y_m_array))
log.info('pixelwidth is {0}'.format(pixelwidth))
ms_folder = os.path.dirname(ms_orig)
nc_folder = pjoin(ms_folder, 'netcdf')
file_name = os.path.basename(ms_orig)
dire = ['w', 'e', 'n', 's', 'nw', 'ne', 'se', 'sw']
for one_dir in dire:
log.info(one_dir)
kernel_size = int(100.0 / pixelwidth)
# if one_dir in ['w', 'e', 'n', 's']:
# kernel_size = int(100.0 / pixelwidth)
# else:
# kernel_size = int(100.0 / pixelwidth)
log.info('convolution kernel size is {0}'.format(str(kernel_size)))
# if the resolution size is bigger than 100 m, no covolution just copy
# the initial shielding factor to each direction
if kernel_size > 0:
outdata = np.zeros((rows, cols), np.float32)
kern_dir = globals()['kern_' + one_dir]
mask = kern_dir(kernel_size)
outdata = blur_image(data, mask)
else:
outdata = data
result = combine(outdata, slope_array, aspect_array, one_dir)
del outdata
# output format as netCDF4
tile_nc = pjoin(
nc_folder,
os.path.splitext(file_name)[0] +
'_' +
one_dir +
'.nc')
log.info("Saving terrain multiplier in netCDF file")
save_multiplier('Ms', result, lat, lon, tile_nc)
del result
ms_orig_ds = None
def terrain(temp_tile, tile_extents_nobuffer):
"""
Performs core calculations to derive the terrain multiplier
:param temp_tile: `file` the image file of the input tile of the land cover
:param tile_extents_nobuffer: `tuple` the input tile extent without buffer
"""
# open the tile
temp_dataset = gdal.Open(temp_tile)
# get image size, format, projection
cols = temp_dataset.RasterXSize
rows = temp_dataset.RasterYSize
bands = temp_dataset.RasterCount
log.info('Input raster format is %s' % temp_dataset.GetDriver().ShortName +
'/ %s' % temp_dataset.GetDriver().LongName)
log.info('Image size is %s' % cols + 'x %s' % rows + 'x %s' % bands)
# get georeference info
geotransform = temp_dataset.GetGeoTransform()
x_left = geotransform[0]
y_upper = -geotransform[3]
pixelwidth = geotransform[1]
pixelheight = -geotransform[5]
# get the tile's longitude and latitude values used to save output in
# netcdf
lon, lat = get_lat_lon(tile_extents_nobuffer, pixelwidth, pixelheight)
# get the average grid size in metre of the tile
x_m_array, y_m_array = get_pixel_size_grids(temp_dataset)
gridwidth = 0.5 * (np.mean(x_m_array) + np.mean(y_m_array))
log.info('gridwidth is {0}'.format(gridwidth))
# produce the original terrain multiplier from the input terrain map
log.info(
'Reclassify the terrain classes into initial terrain multipliers ...')
band = temp_dataset.GetRasterBand(1)
data = band.ReadAsArray(0, 0, cols, rows)
nodata_value = band.GetNoDataValue()
#if nodata_value is not None:
# data[np.where(data == nodata_value)] = np.nan
#else:
# data[np.where(data is None)] = np.nan
mz_init = get_terrain_table()
reclassified_array = terrain_class2mz_orig(data, mz_init)
# if the value is 0, it is nodata, if all 0s, empty tile
if np.max(reclassified_array) == 0:
log.info('Terrain dataset is all zeros. Terrain classification'
'will be skipped')
return
else:
reclassified_array[reclassified_array == 0] = np.nan
# assign nodata area as water with multiplier value 1
mask = np.isnan(reclassified_array)
reclassified_array[mask] = 1.0
# convoulution of the original terrain multipler into different directions
log.info('Moving average for each direction ...')
dire = ['w', 'e', 'n', 's', 'nw', 'ne', 'se', 'sw']
# set avearage and lag distance used for convolution as per
# AS/NZ 1170.2 (2011) including amendments
avg_dist = 500.
lag_dist = 200.
for one_dir in dire:
log.info(one_dir)
if one_dir in ['w', 'e', 'n', 's']:
avg_width = int(np.around(avg_dist / gridwidth))
lag_width = int(np.around(lag_dist / gridwidth))
else:
# for the diagonal directions, the avg_width is the same for x and
# y component of the diagonal distance (avg_dist). lag_width is
# the same principle as the avg_width
avg_width = int(avg_dist / (gridwidth * 1.414))
lag_width = int(lag_dist / (gridwidth * 1.414))
# if the tile is smaller than the lag distance, no convolultion
if lag_width > reclassified_array.shape[0]:
outdata = reclassified_array
else:
# if the tile is smaller than the upwind buffer, all the tile is in
# buffer
if (avg_width + lag_width) > reclassified_array.shape[0]:
avg_width = reclassified_array.shape[0] - lag_width
log.info('convolution average width ' + str(avg_width))
outdata = convo(one_dir, reclassified_array, avg_width, lag_width)
outdata[mask] = np.nan
# find output folder
tile_folder = os.path.dirname(temp_tile)
file_name = os.path.basename(temp_tile)
# output format as netCDF4
mz_folder = pjoin(tile_folder, 'terrain')
tile_nc = pjoin(
mz_folder,
os.path.splitext(file_name)[0] +
'_mz_' +
one_dir +
'.nc')
log.info("Saving terrain multiplier in netCDF file")
outdata_nobuffer = clip_array(outdata, x_left, y_upper, pixelwidth,
pixelheight, tile_extents_nobuffer)
save_multiplier('Mz', outdata_nobuffer, lat, lon, tile_nc)
del outdata
temp_dataset = None
log.info(
'finish terrain multiplier computation for this tile successfully')
def convo_combine(ms_orig, slope_array, aspect_array, tile_extents_nobuffer):
"""
Apply convolution to the orginal shielding factor for each direction and
call the :term:`combine` module to consider the slope and aspect and remove
conservitism to get final shielding multiplier values
:param ms_orig: `file` the original shidelding factor map
:param slope_array: :class:`numpy.ndarray` the input slope values
:param aspect_array: :class:`numpy.ndarray` the input aspect values
:param tile_extents_nobuffer: `tuple` the input tile extent without buffer
"""
ms_orig_ds = gdal.Open(ms_orig)
if ms_orig_ds is None:
log.info('Could not open ' + ms_orig)
sys.exit(1)
log.info('ms_orig is {0}'.format(ms_orig))
# get image size, format, projection
cols = ms_orig_ds.RasterXSize
rows = ms_orig_ds.RasterYSize
geotransform = ms_orig_ds.GetGeoTransform()
x_left = geotransform[0]
y_upper = -geotransform[3]
pixelwidth = geotransform[1]
pixelheight = -geotransform[5]
lon, lat = get_lat_lon(tile_extents_nobuffer, pixelwidth, pixelheight)
band = ms_orig_ds.GetRasterBand(1)
data = band.ReadAsArray(0, 0, cols, rows)
if ms_orig_ds is None:
log.info('Could not open {0}'.format(ms_orig))
sys.exit(1)
x_m_array, y_m_array = get_pixel_size_grids(ms_orig_ds)
gridwidth = 0.5 * (np.mean(x_m_array) + np.mean(y_m_array))
log.info('gridwidth is {0}'.format(gridwidth))
ms_folder = os.path.dirname(ms_orig)
file_name = os.path.basename(ms_orig)
dire = ['w', 'e', 'n', 's', 'nw', 'ne', 'se', 'sw']
for one_dir in dire:
log.info(one_dir)
kernel_size = int(100.0 / gridwidth)
log.info('convolution kernel size is {0}'.format(str(kernel_size)))
# if the resolution size is bigger than 100 m, no covolution just copy
# the initial shielding factor to each direction
if kernel_size > 0:
outdata = np.zeros((rows, cols), np.float32)
kern_dir = globals()['kern_' + one_dir]
mask = kern_dir(kernel_size)
outdata = blur_image(data, mask)
else:
outdata = data
result = combine(outdata, slope_array, aspect_array, one_dir)
del outdata
# output format as netCDF4
tile_nc = pjoin(ms_folder,
os.path.splitext(file_name)[0] + '_' + one_dir + '.nc')
log.info("Saving shielding multiplier in netCDF file")
result_nobuffer = clip_array(result, x_left, y_upper, pixelwidth,
pixelheight, tile_extents_nobuffer)
save_multiplier('Ms', result_nobuffer, lat, lon, tile_nc)
del result
ms_orig_ds = None
os.remove(ms_orig)
os.chdir(ms_folder)
filelist = glob.glob('*.xml')
log.debug("useless xml files: {0}".format(repr(filelist)))
if len(filelist) != 0:
for f in filelist:
try:
os.remove(f)
except OSError:
pass
def topomult(input_dem, tile_extents_nobuffer):
"""
Executes core topographic multiplier functionality
:param input_dem: `file` the input tile of the DEM
:param tile_extents_nobuffer: `tuple` the input tile extent without buffer
"""
# find output folder
mh_folder = pjoin(os.path.dirname(input_dem), 'topographic')
file_name = os.path.basename(input_dem)
ds = gdal.Open(input_dem)
nc = ds.RasterXSize
nr = ds.RasterYSize
geotransform = ds.GetGeoTransform()
x_left = geotransform[0]
y_upper = -geotransform[3]
pixelwidth = geotransform[1]
pixelheight = -geotransform[5]
lon, lat = get_lat_lon(tile_extents_nobuffer, pixelwidth, pixelheight)
band = ds.GetRasterBand(1)
elevation_array = band.ReadAsArray(0, 0, nc, nr)
nodata_value = band.GetNoDataValue()
if nodata_value is not None:
elevation_array[np.where(elevation_array == nodata_value)] = np.nan
else:
elevation_array[np.where(elevation_array is None)] = np.nan
elevation_array_tran = np.transpose(elevation_array)
data = elevation_array_tran.flatten()
x_m_array, y_m_array = get_pixel_size_grids(ds)
cellsize = 0.5 * (np.mean(x_m_array) + np.mean(y_m_array))
# Compute the starting positions along the boundaries depending on dir
# Together, the direction and the starting position determines a line.
# Note that the starting positions are defined
# in terms of the 1-d index of the array.
directions = ['n', 's', 'e', 'w', 'ne', 'nw', 'se', 'sw']
for direction in directions:
log.info(direction)
if len(direction) == 2:
data_spacing = cellsize * math.sqrt(2)
else:
data_spacing = cellsize
mhdata = np.ones(data.shape)
strt_idx = []
if direction.find('n') >= 0:
strt_idx = np.append(strt_idx, list(range(0, nr * nc, nr)))
if direction.find('s') >= 0:
strt_idx = np.append(strt_idx, list(range(nr - 1, nr * nc, nr)))
if direction.find('e') >= 0:
strt_idx = np.append(strt_idx, list(range((nc - 1) * nr, nr * nc)))
if direction.find('w') >= 0:
strt_idx = np.append(strt_idx, list(range(0, nr)))
# For the diagonal directions the corner will have been counted twice
# so get rid of the duplicates then loop over the data lines
# (i.e. over the starting positions)
strt_idx = np.unique(strt_idx)
for ctr, idx in enumerate(strt_idx):
log.debug('Processing path %3i' % ctr + ' of %3i' % len(strt_idx) +
', index %5i.' % idx)
# Get a line of the data
# path is a 1-d vector which gives the indices of the data
path = make_path.make_path(nr, nc, idx, direction)
line = data[path]
line[np.isnan(line)] = 0.
m = multiplier_calc.multiplier_calc(line, data_spacing)
# write the line back to the data array
m = np.transpose(m)
mhdata[path] = m[0, ].flatten()
# Reshape the result to matrix like
mhdata = np.reshape(mhdata, (nc, nr))
mhdata = np.transpose(mhdata)
# Remove the conservatism as described in the Reference
mhdata = remove_conservatism(mhdata)
# consider the Tasmania factor
if x_left > 143.0 and y_upper > 40.0:
mhdata = tasmania(mhdata, elevation_array)
# smooth
g = np.ones((3, 3)) / 9.
mhsmooth = signal.convolve(mhdata, g, mode='same')
mhsmooth[np.isnan(elevation_array)] = np.nan
del mhdata
# output format as netCDF4
tile_nc = pjoin(
mh_folder,
os.path.splitext(file_name)[0][:-4] + '_mt_' + direction + '.nc')
mhsmooth_nobuffer = clip_array(mhsmooth, x_left, y_upper, pixelwidth,
pixelheight, tile_extents_nobuffer)
save_multiplier('Mt', mhsmooth_nobuffer, lat, lon, tile_nc)
del mhsmooth
log.info('Finished direction {0}'.format(direction))
ds = None
def terrain(cyclone_area, temp_tile):
"""
Performs core calculations to derive the terrain multiplier
:param cyclone_area: none or `file` input tile of the cyclone area file.
:param temp_tile: `file` the image file of the input tile of the land cover
"""
# open the tile
temp_dataset = gdal.Open(temp_tile)
# get image size, format, projection
cols = temp_dataset.RasterXSize
rows = temp_dataset.RasterYSize
bands = temp_dataset.RasterCount
log.info('Input raster format is %s' % temp_dataset.GetDriver().ShortName +
'/ %s' % temp_dataset.GetDriver().LongName)
log.info('Image size is %s' % cols + 'x %s' % rows + 'x %s' % bands)
# get georeference info
geotransform = temp_dataset.GetGeoTransform()
x_left = geotransform[0]
y_upper = -geotransform[3]
pixelwidth = geotransform[1]
pixelheight = -geotransform[5]
# get the tile's longitude and latitude values used to save output in
# netcdf
lon, lat = get_lat_lon(x_left, y_upper, pixelwidth, pixelheight, cols, rows)
# get the average grid size in metre of the tile
x_m_array, y_m_array = get_pixel_size_grids(temp_dataset)
pixelwidth = 0.5 * (np.mean(x_m_array) + np.mean(y_m_array))
log.info('pixelwidth is {0}'.format(pixelwidth))
# produce the original terrain multiplier from the input terrain map
log.info(
'Reclassfy the terrain classes into initial terrain multipliers ...')
band = temp_dataset.GetRasterBand(1)
data = band.ReadAsArray(0, 0, cols, rows)
reclassified_array = terrain_class2mz_orig(cyclone_area, data)
# if the value is 0, it is nodata
reclassified_array[reclassified_array == 0] = np.nan
# assign nodata area as average non-cycl multiplier value
mask = np.isnan(reclassified_array)
reclassified_array[mask] = 0.931
# convoulution of the original terrain multipler into different directions
log.info('Moving average for each direction ...')
dire = ['w', 'e', 'n', 's', 'nw', 'ne', 'se', 'sw']
# set the terrain buffer used for convolution as per AS/NZ 1170.2 (2011)
terrain_buffer = 1000.
for one_dir in dire:
log.info(one_dir)
if one_dir in ['w', 'e', 'n', 's']:
filter_width = int(terrain_buffer / pixelwidth)
else:
filter_width = int(terrain_buffer / (pixelwidth * 1.414))
# if the tile is smaller than the upwind buffer, all the tile is in
# buffer
if filter_width > reclassified_array.shape[0]:
filter_width = reclassified_array.shape[0]
log.info('convolution filter width ' + str(filter_width))
convo_dir = globals()['convo_' + one_dir]
outdata = convo_dir(reclassified_array, filter_width)
outdata[mask] = np.nan
# find output folder
tile_folder = os.path.dirname(temp_tile)
file_name = os.path.basename(temp_tile)
# output format as netCDF4
nc_folder = pjoin(pjoin(tile_folder, 'terrain'), 'netcdf')
tile_nc = pjoin(
nc_folder,
os.path.splitext(file_name)[0] +
'_mz_' +
one_dir +
'.nc')
log.info("Saving terrain multiplier in netCDF file")
save_multiplier('Mz', outdata, lat, lon, tile_nc)
del outdata
temp_dataset = None
log.info(
'finish terrain multiplier computation for this tile successfully')
def convo_combine(ms_orig, slope_array, aspect_array, tile_extents_nobuffer):
"""
Apply convolution to the orginal shielding factor for each direction and
call the :term:`combine` module to consider the slope and aspect and remove
conservitism to get final shielding multiplier values
:param ms_orig: `file` the original shidelding factor map
:param slope_array: :class:`numpy.ndarray` the input slope values
:param aspect_array: :class:`numpy.ndarray` the input aspect values
:param tile_extents_nobuffer: `tuple` the input tile extent without buffer
"""
ms_orig_ds = gdal.Open(ms_orig)
if ms_orig_ds is None:
log.info('Could not open ' + ms_orig)
sys.exit(1)
log.info('ms_orig is {0}'.format(ms_orig))
# get image size, format, projection
cols = ms_orig_ds.RasterXSize
rows = ms_orig_ds.RasterYSize
geotransform = ms_orig_ds.GetGeoTransform()
x_left = geotransform[0]
y_upper = -geotransform[3]
pixelwidth = geotransform[1]
pixelheight = -geotransform[5]
lon, lat = get_lat_lon(tile_extents_nobuffer, pixelwidth, pixelheight)
band = ms_orig_ds.GetRasterBand(1)
data = band.ReadAsArray(0, 0, cols, rows)
if ms_orig_ds is None:
log.info('Could not open {0}'.format(ms_orig))
sys.exit(1)
x_m_array, y_m_array = get_pixel_size_grids(ms_orig_ds)
gridwidth = 0.5 * (np.mean(x_m_array) + np.mean(y_m_array))
log.info('gridwidth is {0}'.format(gridwidth))
ms_folder = os.path.dirname(ms_orig)
file_name = os.path.basename(ms_orig)
dire = ['w', 'e', 'n', 's', 'nw', 'ne', 'se', 'sw']
for one_dir in dire:
log.info(one_dir)
kernel_size = int(100.0 / gridwidth)
log.info('convolution kernel size is {0}'.format(str(kernel_size)))
# if the resolution size is bigger than 100 m, no covolution just copy
# the initial shielding factor to each direction
if kernel_size > 0:
outdata = np.zeros((rows, cols), np.float32)
kern_dir = globals()['kern_' + one_dir]
mask = kern_dir(kernel_size)
outdata = blur_image(data, mask)
else:
outdata = data
result = combine(outdata, slope_array, aspect_array, one_dir)
log.debug('Maximum shielding value is {0}'.format(result.max()))
log.debug('Minimum shielding value is {0}'.format(result.min()))
del outdata
# output format as netCDF4
tile_nc = pjoin(
ms_folder,
os.path.splitext(file_name)[0] +
'_' +
one_dir +
'.nc')
log.info("Saving shielding multiplier in netCDF file")
result_nobuffer = clip_array(result, x_left, y_upper, pixelwidth,
pixelheight, tile_extents_nobuffer)
save_multiplier('Ms', result_nobuffer, lat, lon, tile_nc)
del result
ms_orig_ds = None
try:
os.remove(ms_orig)
except:
pass
os.chdir(ms_folder)
filelist = glob.glob('*.xml')
log.debug("useless xml files: {0}".format(repr(filelist)))
if len(filelist) != 0:
for f in filelist:
try:
os.remove(f)
except OSError:
pass
def topomult(input_dem):
"""
Executes core topographic multiplier functionality
:param input_dem: `file` the input tile of the DEM
"""
# find output folder
mh_folder = pjoin(os.path.dirname(input_dem), 'topographic')
file_name = os.path.basename(input_dem)
nc_folder = pjoin(mh_folder, 'netcdf')
ds = gdal.Open(input_dem)
nc = ds.RasterXSize
nr = ds.RasterYSize
geotransform = ds.GetGeoTransform()
x_left = geotransform[0]
y_upper = -geotransform[3]
pixelwidth = geotransform[1]
pixelheight = -geotransform[5]
lon, lat = get_lat_lon(x_left, y_upper, pixelwidth, pixelheight, nc, nr)
band = ds.GetRasterBand(1)
elevation_array = band.ReadAsArray(0, 0, nc, nr)
elevation_array[np.where(elevation_array < -0.001)] = np.nan
elevation_array_tran = np.transpose(elevation_array)
data = elevation_array_tran.flatten()
x_m_array, y_m_array = get_pixel_size_grids(ds)
cellsize = 0.5 * (np.mean(x_m_array) + np.mean(y_m_array))
# Compute the starting positions along the boundaries depending on dir
# Together, the direction and the starting position determines a line.
# Note that the starting positions are defined
# in terms of the 1-d index of the array.
directions = ['n', 's', 'e', 'w', 'ne', 'nw', 'se', 'sw']
for direction in directions:
log.info(direction)
if len(direction) == 2:
data_spacing = cellsize * math.sqrt(2)
else:
data_spacing = cellsize
mhdata = np.ones(data.shape)
strt_idx = []
if direction.find('n') >= 0:
strt_idx = np.append(strt_idx, list(range(0, nr * nc, nr)))
if direction.find('s') >= 0:
strt_idx = np.append(strt_idx, list(range(nr - 1, nr * nc, nr)))
if direction.find('e') >= 0:
strt_idx = np.append(strt_idx, list(range((nc - 1) * nr, nr * nc)))
if direction.find('w') >= 0:
strt_idx = np.append(strt_idx, list(range(0, nr)))
# For the diagonal directions the corner will have been counted twice
# so get rid of the duplicates then loop over the data lines
# (i.e. over the starting positions)
strt_idx = np.unique(strt_idx)
for ctr, idx in enumerate(strt_idx):
log.debug('Processing path %3i' % ctr + ' of %3i' % len(strt_idx)
+ ', index %5i.' % idx)
# Get a line of the data
# path is a 1-d vector which gives the indices of the data
path = make_path.make_path(nr, nc, idx, direction)
line = data[path]
line[np.isnan(line)] = 0.
m = multiplier_calc.multiplier_calc(line, data_spacing)
# write the line back to the data array
m = np.transpose(m)
mhdata[path] = m[0, ].flatten()
# Reshape the result to matrix like
mhdata = np.reshape(mhdata, (nc, nr))
mhdata = np.transpose(mhdata)
# smooth
g = np.ones((3, 3)) / 9.
mhsmooth = signal.convolve(mhdata, g, mode='same')
mhsmooth[np.isnan(elevation_array)] = np.nan
del mhdata
# output format as netCDF4
tile_nc = pjoin(nc_folder, os.path.splitext(file_name)[0][:-4] + '_mt_' +
direction + '.nc')
save_multiplier('Mt', mhsmooth, lat, lon, tile_nc)
del mhsmooth
log.info('Finished direction {0}'.format(direction))
ds = None