Dividir imagem .tif em vários blocos? [fechadas]

Eu tenho uma imagem do tamanho 1GB (.tif), com a largura e altura 94000x71680. Gostaria de dividir esta imagem em blocos de 20000X20000 para que eu possa processá-los.

Como posso fazer isso?

Proponho duas soluções: a primeira usando QGIS, a segunda usando Python (GDAL).

Solução usando QGIS

No QGIS, você pode criar um mosaico VRT.

Por favor, siga este procedimento (veja a imagem abaixo):

1. Carregue a varredura no painel Camadas ;
2. Clique com o botão direito do mouse e escolha Save As...;
3. Marque a Create VRTopção;
4. Escolha a pasta onde suas saídas serão salvas;
5. Defina a extensão (se você quiser trabalhar em toda a varredura, não modifique nada);
6. Escolha se estiver usando a resolução atual (sugiro deixá-la como padrão);
7. Defina o número máximo de colunas e linhas (no seu caso, deve ser 20000 colunas e 2000 linhas);
8. Pressione o OKbotão

Por exemplo, o uso dos parâmetros na caixa de diálogo acima nesta amostra de varredura (os parâmetros que eu defini são escolhidos aleatoriamente):

irá gerar 100 blocos no caminho especificado na etapa 4:

Carregando-os no QGIS, eles ficam assim:

Como @ bugmenot123 disse corretamente nos comentários, o resultado parece estranho apenas porque o estilo de cada imagem se encaixa na distribuição de valores por imagem (mas os dados estão perfeitamente corretos).

Solução usando Python (GDAL)

Outra maneira de obter o mesmo resultado é o uso de GDAL ( gdal_translate ).

Com referência ao mesmo exemplo descrito acima, você pode usar este script:

import os, gdal

in_path = 'C:/Users/Marco/Desktop/'
input_filename = 'dtm_5.tif'

out_path = 'C:/Users/Marco/Desktop/output_folder/'
output_filename = 'tile_'

tile_size_x = 50
tile_size_y = 70

ds = gdal.Open(in_path + input_filename)
band = ds.GetRasterBand(1)
xsize = band.XSize
ysize = band.YSize

for i in range(0, xsize, tile_size_x):
    for j in range(0, ysize, tile_size_y):
        com_string = "gdal_translate -of GTIFF -srcwin " + str(i)+ ", " + str(j) + ", " + str(tile_size_x) + ", " + str(tile_size_y) + " " + str(in_path) + str(input_filename) + " " + str(out_path) + str(output_filename) + str(i) + "_" + str(j) + ".tif"
        os.system(com_string)

Obviamente, você precisa adaptar os valores ao seu caso específico.

Não divida

Você gdalbuildvrt , você pode criar telhas virtuais que só vai usar alguns bytes em seu disco. Então você pode usar a maioria dos softwares que levarão seus vrt's como entrada para executar seu processamento.

Como alternativa, prefiro procurar uma ferramenta que possa trabalhar com uma imagem de 1 Gb do que dividir e mesclar uma imagem. Por exemplo, o OTB possui a maioria dos recursos para processamento de imagens padrão (e algumas vezes avançado) com imagens grandes. Você pode agrupar o OTB para Python ou executá-lo no QGIS ou nas linhas de comando.

Usando a ferramenta Split Raster , você pode dividir uma varredura em blocos com base em alguns métodos de divisão, incluindo o tamanho de cada bloco ou o número de blocos .

Veja também Splitting Raster no ArcGIS

Outra solução usando o GDAL é a ferramenta gdal_retile.py :

mkdir image_tiles
gdal_retile.py -v -r bilinear -levels 1 -ps 20000 20000 -co "TILED=YES" -co "COMPRESS=JPEG" -targetDir image_tiles big_input_image.tif

Para mais informações, consulte: http://www.gdal.org/gdal_retile.html