def test_kml(data, tmp_path):
input_file = data / 'simple.tiff'
output_dir = tmp_path / 'tiles'
output_dir.mkdir()
generate_tiles(str(input_file), str(output_dir), profile='raster', kml=True)
assert (output_dir / 'doc.kml').exists()
def tiles(input_vrt, output_dir, zoom_levels="8-10"):
"""
Generate PNG tiles from a VRT
"""
# Make sure input vrt is in byte format
path = pathlib.Path(input_vrt)
gdal2tiles.generate_tiles(str(input_vrt),
output_dir,
zoom=zoom_levels,
verbose=True)
def main():
options = {
'webviewer': 'none',
'profile': 'mercator',
'webviewer': 'none',
'nb_processes': 4,
'verbose': True
}
if sys.argv[3] == "" or sys.argv[3] == "undefined":
options['srcnodata'] = None
else:
options['srcnodata'] = sys.argv[3]
gdal2tiles.generate_tiles(sys.argv[1], sys.argv[2], **options)
def tiles(input_vrt, output_dir, zoom_levels="8-14"):
"""
Generate PNG tiles from a VRT
"""
path = pathlib.Path(input_vrt)
intermediate = f"{path.parent}/{path.resolve().stem}-byte.vrt"
subprocess.call(
["gdal_translate", "-ot", "Byte", input_vrt, f'{intermediate}'])
gdal2tiles.generate_tiles(f"{intermediate}",
output_dir,
zoom=zoom_levels,
verbose=True,
tile_size=1056)
def test_basic(data, tmp_path):
"""Basic sanity check"""
input_file = data / 'simple.tiff'
output_dir = tmp_path / 'tiles'
output_dir.mkdir()
generate_tiles(str(input_file), str(output_dir))
# ensure a tilemapresource.xml was created
with (output_dir / 'tilemapresource.xml').open('r') as f:
tiles_info = xmltodict.parse(f.read())
assert 'TileMap' in tiles_info
# ensure some PNG images were created
tiles_created = list(output_dir.rglob("*.png"))
assert len(tiles_created) > 0
def test_tile_size(data, tmp_path):
"""
Test if tiles are generated with correct size based on ``tile_size`` parameter
"""
input_file = data / 'simple.tiff'
output_dir = tmp_path / 'tiles'
sizes = [128, 256, 512]
for size in sizes:
generate_tiles(str(input_file), str(output_dir), tile_size=size)
tiles_dir = output_dir / str(size)
for tile_path in tiles_dir.rglob("*.png"):
tile_image = Image.open(tile_path)
tile_width, tile_height = tile_image.size
assert tile_width == size
assert tile_height == size
def gdal2tiles_utility(self, task, zoom_levels):
options = {
'resampling': self.__config['gdal']['resampling'],
'tmscompatible': self.__config['gdal']['tms_compatible'],
'profile': self.__config['gdal']['profile'],
'nb_processes': self.__config['gdal']['process_count'],
'srcnodata': self.__config['gdal']['src_nodata'],
'zoom': zoom_levels,
'verbose': self.__config['gdal']['verbose']
}
discreteId = task['parameters']['discreteId']
layerRelativePath = task['parameters']['layerRelativePath']
tiles_path = '{0}/{1}'.format(self.tiles_folder_location, layerRelativePath)
self.log.info("Starting process GDAL2TILES on {0} and zoom-levels: {1}"
.format(utilities.task_format_log(task), zoom_levels))
generate_tiles(self.vrt_file_location(discreteId), tiles_path, **options)
def rgb_tiles(tci_img, tile_root_folder, aoi):
temp_img = os.path.join(tile_root_folder, os.path.basename(tci_img))
p_aoi = proj_check(tci_img, aoi)
with rasterio.open(tci_img) as src:
out_image, out_transform = rasterio.mask.mask(
src, p_aoi, crop=True, all_touched=True)
out_meta = src.meta.copy()
out_meta.update({"driver": "GTiff",
"height": out_image.shape[1],
"width": out_image.shape[2],
"transform": out_transform})
with rasterio.open(temp_img, "w", **out_meta) as dest:
dest.write(out_image)
options = {'zoom': (8, 18), 'resampling': 'near', 'webviewer': 'none'}
basemap_folder = os.path.join(tile_root_folder, "BASEMAP")
if not os.path.exists(basemap_folder):
os.makedirs(basemap_folder)
gdal2tiles.generate_tiles(temp_img, basemap_folder, **options)
os.remove(temp_img)
return
def create_tiles(raster_file, dir_tiles):
"""
Create tiles from a raster file (using GDAL)
Parameters
----------
raster_file : Pathstr
the filename of a raster
dir_tiles : Path
the path to the directory where tiles will be saved
"""
# Check if the tiles directory is empty, else clean it
if not isinstance(dir_tiles, PurePath):
dir_tiles = Path(dir_tiles)
is_empty = not any(dir_tiles.iterdir())
if not is_empty:
utils.rm_tree(dir_tiles)
options = {"webviewer": WEBVIEWER}
gdal2tiles.generate_tiles(raster_file, dir_tiles, **options)
def tiler(in_raster, out_raster, ramp, folder):
options = {'zoom': (8, 18), 'resampling': 'near', 'webviewer': 'none'}
rend = renderer(in_raster, out_raster, ramp)
gdal2tiles.generate_tiles(rend, folder, **options)
return
def gdal_generate_tiles(input_file, output_dir, option):
# 参数：
# input_file （str）：输入文件的路径。
# output_folder （str）：输出文件夹的路径。
# options：图块生成选项。
gdal2tiles.generate_tiles(input_file, output_dir, **option)
def gen_tiles_wrapper(sat_img):
generate_tiles(sat_img, sat_img.split(".")[0], zoom="6-11")
dst = dst_path + filename
createGeoTiff(b, g, r, a, bbox, gsd, boundary_rows,
boundary_cols, dst)
print("--- %s seconds ---" % (time.time() - start_time))
file_list.append(dst + '.tif')
print('*** Processing time per each image')
print("--- %s seconds ---" %
(time.time() - image_start_time + read_time))
# 10. Mosaic individual orthophotos for each band
working_path1 = './OTB-7.0.0-Linux64/'
working_path2 = './bin/'
set_env = './otbenv.profile'
mosaic_execution = './otbcli_Mosaic'
os.chdir(working_path1) # change path
# https://stackoverflow.com/questions/13702425/source-command-not-found-in-sh-shell/13702876
subprocess.call(set_env, shell=True)
os.chdir(working_path2)
subprocess.call(mosaic_execution + ' -il ' + ' '.join(file_list) +
' -out ' + dst_path + '/IMG_RGB.tif',
shell=True)
# 12. Generate tiles
options = {'zoom': (14, 21)}
gdal2tiles.generate_tiles(dst_path + '/IMG_RGB.tif', dst_path + '/tiles/',
**options)
import gdal
import gdal2tiles
from glob import glob
hsy_photos = glob('./HSL_GK25_2500m_converted/*.tif')
mml_photos = glob('./mml_orthophotos/*.tif')
for photo in hsy_photos:
gdal2tiles.generate_tiles(photo, './tiles', s_srs='EPSG:3879')
for photo in mml_photos:
gdal2tiles.generate_tiles(photo,
'./tiles/',
s_srs='EPSG:3067',
options={'resume': True})
def test_gdal_useexceptions():
"""Ensure GDAL raises Exceptions instead of Error values"""
with pytest.raises(RuntimeError):
generate_tiles('/dummy/file.tiff', '/tmp/gdal2tiles/tests/dummy')
def main():
gdal2tiles.generate_tiles(
'/home/aortiz/research_projects/glacier_mapping/web_tool/tiles/hkh_byte.tif',
'/home/aortiz/research_projects/glacier_mapping/web_tool/tiles/hkh/',
zoom='15-17')