Como obter coordenadas de canto raster usando ligações Python GDAL?

30

Existe uma maneira de obter as coordenadas dos cantos (em graus lat / long) de um arquivo rasterizado usando as ligações Python do gdal?

Algumas pesquisas on-line me convenceram de que não há, então desenvolvi uma solução alternativa analisando a saída do gdalinfo, é um pouco básico, mas achei que poderia economizar algum tempo para as pessoas que poderiam se sentir menos à vontade com o python. Também funciona apenas se o gdalinfo contiver as coordenadas geográficas juntamente com as coordenadas dos cantos, o que não acredito que seja sempre o caso.

Aqui está minha solução alternativa: alguém tem alguma solução melhor?

O gdalinfo em uma varredura apropriada resulta em algo assim no meio da saída:

Corner Coordinates:
Upper Left  (  -18449.521, -256913.934) (137d 7'21.93"E,  4d20'3.46"S)
Lower Left  (  -18449.521, -345509.683) (137d 7'19.32"E,  5d49'44.25"S)
Upper Right (   18407.241, -256913.934) (137d44'46.82"E,  4d20'3.46"S)
Lower Right (   18407.241, -345509.683) (137d44'49.42"E,  5d49'44.25"S)
Center      (     -21.140, -301211.809) (137d26'4.37"E,  5d 4'53.85"S)

Esse código funcionará em arquivos com aparência semelhante à do gdalinfo. Acredito que algumas vezes as coordenadas serão em graus e decimais, em vez de graus, minutos e segundos; deve ser trivial ajustar o código para essa situação.

import numpy as np
import subprocess

def GetCornerCoordinates(FileName):
    GdalInfo = subprocess.check_output('gdalinfo {}'.format(FileName), shell=True)
    GdalInfo = GdalInfo.split('/n') # Creates a line by line list.
    CornerLats, CornerLons = np.zeros(5), np.zeros(5)
    GotUL, GotUR, GotLL, GotLR, GotC = False, False, False, False, False
    for line in GdalInfo:
        if line[:10] == 'Upper Left':
            CornerLats[0], CornerLons[0] = GetLatLon(line)
            GotUL = True
        if line[:10] == 'Lower Left':
            CornerLats[1], CornerLons[1] = GetLatLon(line)
            GotLL = True
        if line[:11] == 'Upper Right':
            CornerLats[2], CornerLons[2] = GetLatLon(line)
            GotUR = True
        if line[:11] == 'Lower Right':
            CornerLats[3], CornerLons[3] = GetLatLon(line)
            GotLR = True
        if line[:6] == 'Center':
            CornerLats[4], CornerLons[4] = GetLatLon(line)
            GotC = True
        if GotUL and GotUR and GotLL and GotLR and GotC:
            break
    return CornerLats, CornerLons 

def GetLatLon(line):
    coords = line.split(') (')[1]
    coords = coords[:-1]
    LonStr, LatStr = coords.split(',')
    # Longitude
    LonStr = LonStr.split('d')    # Get the degrees, and the rest
    LonD = int(LonStr[0])
    LonStr = LonStr[1].split('\'')# Get the arc-m, and the rest
    LonM = int(LonStr[0])
    LonStr = LonStr[1].split('"') # Get the arc-s, and the rest
    LonS = float(LonStr[0])
    Lon = LonD + LonM/60. + LonS/3600.
    if LonStr[1] in ['W', 'w']:
        Lon = -1*Lon
    # Same for Latitude
    LatStr = LatStr.split('d')
    LatD = int(LatStr[0])
    LatStr = LatStr[1].split('\'')
    LatM = int(LatStr[0])
    LatStr = LatStr[1].split('"')
    LatS = float(LatStr[0])
    Lat = LatD + LatM/60. + LatS/3600.
    if LatStr[1] in ['S', 's']:
        Lat = -1*Lat
    return Lat, Lon

FileName = Image.cub
# Mine's an ISIS3 cube file.
CornerLats, CornerLons = GetCornerCoordinates(FileName)
# UpperLeft, LowerLeft, UpperRight, LowerRight, Centre
print CornerLats
print CornerLons

E isso me dá:

[-4.33429444 -5.82895833 -4.33429444 -5.82895833 -5.081625  ] 
[ 137.12275833  137.12203333  137.74633889  137.74706111  137.43454722]
EddyTheB
fonte
Talvez relacionado: gis.stackexchange.com/questions/33330/…
AndreJ

Respostas:

29

Aqui está outra maneira de fazer isso sem chamar um programa externo.

O que isso faz é obter as coordenadas dos quatro cantos da geotransformação e reprojetá-las para lon / lat usando osr.CoordinateTransformation.

from osgeo import gdal,ogr,osr

def GetExtent(gt,cols,rows):
    ''' Return list of corner coordinates from a geotransform

        @type gt:   C{tuple/list}
        @param gt: geotransform
        @type cols:   C{int}
        @param cols: number of columns in the dataset
        @type rows:   C{int}
        @param rows: number of rows in the dataset
        @rtype:    C{[float,...,float]}
        @return:   coordinates of each corner
    '''
    ext=[]
    xarr=[0,cols]
    yarr=[0,rows]

    for px in xarr:
        for py in yarr:
            x=gt[0]+(px*gt[1])+(py*gt[2])
            y=gt[3]+(px*gt[4])+(py*gt[5])
            ext.append([x,y])
            print x,y
        yarr.reverse()
    return ext

def ReprojectCoords(coords,src_srs,tgt_srs):
    ''' Reproject a list of x,y coordinates.

        @type geom:     C{tuple/list}
        @param geom:    List of [[x,y],...[x,y]] coordinates
        @type src_srs:  C{osr.SpatialReference}
        @param src_srs: OSR SpatialReference object
        @type tgt_srs:  C{osr.SpatialReference}
        @param tgt_srs: OSR SpatialReference object
        @rtype:         C{tuple/list}
        @return:        List of transformed [[x,y],...[x,y]] coordinates
    '''
    trans_coords=[]
    transform = osr.CoordinateTransformation( src_srs, tgt_srs)
    for x,y in coords:
        x,y,z = transform.TransformPoint(x,y)
        trans_coords.append([x,y])
    return trans_coords

raster=r'somerasterfile.tif'
ds=gdal.Open(raster)

gt=ds.GetGeoTransform()
cols = ds.RasterXSize
rows = ds.RasterYSize
ext=GetExtent(gt,cols,rows)

src_srs=osr.SpatialReference()
src_srs.ImportFromWkt(ds.GetProjection())
#tgt_srs=osr.SpatialReference()
#tgt_srs.ImportFromEPSG(4326)
tgt_srs = src_srs.CloneGeogCS()

geo_ext=ReprojectCoords(ext,src_srs,tgt_srs)

Algum código do metageta projeto, ideia osr.CoordinateTransformation de esta resposta

user2856
fonte
Incrível, obrigado. E funciona independentemente da existência de linhas apropriadas na saída do gdalinfo.
EddyTheB
Eu acho que isso será melhor com tgt_srs = src_srs.CloneGeogCS (). Meus rasters iniciais são imagens de Marte, portanto, usar EPSG (4326) não é o ideal, mas CloneGeogCS () parece mudar apenas das coordenadas projetadas para as coordenadas geográficas.
EddyTheB
Com certeza. Atualizei a resposta para usar o CloneGeogCS. No entanto, eu estava apenas tentando demonstrar o uso das funções GetExtent e ReprojectCoords. Você pode usar o que quiser como srs de destino.
usar o seguinte comando
Sim, obrigado, eu nunca teria encontrado esses de outra maneira.
EddyTheB
E se você tiver um conjunto de dados que não tem projeção e especifique RPCs? A importação da função wkt falha. É possível calcular a extensão usando um transformador, mas eu queria saber se havia uma maneira com o método acima?
Thomas
41

Isso pode ser feito em muito menos linhas de código

src = gdal.Open(path goes here)
ulx, xres, xskew, uly, yskew, yres  = src.GetGeoTransform()
lrx = ulx + (src.RasterXSize * xres)
lry = uly + (src.RasterYSize * yres)

ulx, ulyÉ o canto superior esquerdo, lrx, lryé o canto inferior direito

A biblioteca osr (parte do gdal) pode ser usada para transformar os pontos em qualquer sistema de coordenadas. Para um único ponto:

from osgeo import ogr
from osgeo import osr

# Setup the source projection - you can also import from epsg, proj4...
source = osr.SpatialReference()
source.ImportFromWkt(src.GetProjection())

# The target projection
target = osr.SpatialReference()
target.ImportFromEPSG(4326)

# Create the transform - this can be used repeatedly
transform = osr.CoordinateTransformation(source, target)

# Transform the point. You can also create an ogr geometry and use the more generic `point.Transform()`
transform.TransformPoint(ulx, uly)

Reprojetar uma imagem raster inteiro seria uma questão muito mais complicada, mas GDAL> = 2.0 oferece uma solução fácil para isso também: gdal.Warp.

James
fonte
Esta é a resposta pitônica para a extensão - uma solução igualmente pitônica para a reprojeção teria sido incrível, Dito isto - eu uso os resultados no PostGIS, então apenas passo a extensão não transformada e ST_Transform(ST_SetSRID(ST_MakeBox2D([os resultados] ),28355),4283). (Uma queixa - o 'T' in src.GetGeoTransform()deve ser maiúsculo).
GT.
@GT. Adicionado um exemplo
James
1

Eu fiz dessa maneira ... é um pouco codificado, mas se nada mudar com o gdalinfo, ele funcionará para imagens projetadas em UTM!

imagefile= /pathto/image
p= subprocess.Popen(["gdalinfo", "%s"%imagefile], stdout=subprocess.PIPE)
out,err= p.communicate()
ul= out[out.find("Upper Left")+15:out.find("Upper Left")+38]
lr= out[out.find("Lower Right")+15:out.find("Lower Right")+38]
Emiliano
fonte
2
Isso é bastante frágil, pois depende de gdalinfoestar disponível no caminho do usuário (nem sempre, especialmente no Windows) e de analisar uma saída impressa que não possui interface rígida - ou seja, confiar nesses 'números mágicos' para o espaçamento correto. É desnecessário quando gdal fornece vínculos python abrangentes que pode fazer isso de uma forma mais explícita e robusto
James
1

Se sua varredura é rotacionada, a matemática fica um pouco mais complicada, pois você precisa considerar cada um dos seis coeficientes de transformação afins. Considere usar affine para transformar uma transformação / geotransformação afim girada:

from affine import Affine

# E.g., from a GDAL DataSet object:
# gt = ds.GetGeoTransform()
# ncol = ds.RasterXSize
# nrow = ds.RasterYSize

# or to work with a minimal example
gt = (100.0, 17.320508075688775, 5.0, 200.0, 10.0, -8.660254037844387)
ncol = 10
nrow = 15

transform = Affine.from_gdal(*gt)
print(transform)
# | 17.32, 5.00, 100.00|
# | 10.00,-8.66, 200.00|
# | 0.00, 0.00, 1.00|

Agora você pode gerar os quatro pares de coordenadas de canto:

c0x, c0y = transform.c, transform.f  # upper left
c1x, c1y = transform * (0, nrow)     # lower left
c2x, c2y = transform * (ncol, nrow)  # lower right
c3x, c3y = transform * (ncol, 0)     # upper right

E se você também precisar dos limites baseados na grade (xmin, ymin, xmax, ymax):

xs = (c0x, c1x, c2x, c3x)
ys = (c0y, c1y, c2y, c3y)
bounds = min(xs), min(ys), max(xs), max(ys)
Mike T
fonte
0

Acredito que em versões mais recentes do módulo OSGEO / GDAL para python, é possível chamar diretamente os utilitários GDAL a partir do código sem envolver chamadas do sistema. por exemplo, em vez de usar o subprocesso para chamar:

gdalinfo pode-se chamar gdal.Info (nome_do_arquivo) para ter uma exposição dos metadados / anotações do arquivo

ou em vez de usar o subprocesso para chamar: gdalwarp, pode-se chamar gdal.Warp para fazer a distorção em uma varredura.

A lista de utilitários GDAL atualmente disponíveis como uma função interna: http://erouault.blogspot.com/2015/10/gdal-and-ogr-utilities-as-library.html

Sinooshka
fonte