Как получить растровые угловые координаты, используя привязки Python GDAL?

30

Есть ли способ получить угловые координаты (в градусах широта / длина) из растрового файла, используя привязки Python от gdal?

Несколько поисковых запросов в Интернете убедили меня, что нет, поэтому я разработал обходной путь, анализируя вывод gdalinfo, он несколько простой, но я подумал, что это может сэкономить время для людей, которые могут быть менее знакомы с python. Это также работает, только если gdalinfo содержит географические координаты вместе с угловыми координатами, что, как мне кажется, не всегда так.

Вот мой обходной путь, у кого-нибудь есть лучшие решения?

gdalinfo на соответствующем растре приводит к чему-то вроде этого на полпути:

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)

Этот код будет работать с файлами, которые gdalinfo выглядят так. Я считаю, что иногда координаты будут в градусах и десятичных числах, а не градусах, минутах и ​​секундах; это должно быть тривиально, чтобы настроить код для этой ситуации.

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

И это дает мне:

[-4.33429444 -5.82895833 -4.33429444 -5.82895833 -5.081625  ] 
[ 137.12275833  137.12203333  137.74633889  137.74706111  137.43454722]
EddyTheB
источник
Может быть связано: gis.stackexchange.com/questions/33330/…
AndreJ

Ответы:

29

Вот еще один способ сделать это без вызова внешней программы.

Это позволяет получить координаты четырех углов из геотрансформации и перепроектировать их в lon / lat с помощью 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)

Некоторый код из metageta проекта, osr.CoordinateTransformation идея от этого ответа

user2856
источник
Круто, спасибо. И это работает независимо от того, существуют ли соответствующие строки в выводе gdalinfo.
EddyTheB
Я думаю, что это будет лучше с tgt_srs = src_srs.CloneGeogCS (). Мои первоначальные растры - это изображения Марса, поэтому использование EPSG (4326) не идеально, но CloneGeogCS (), похоже, просто меняет проекцию на географические координаты.
EddyTheB
Точно. Я обновил ответ, чтобы использовать CloneGeogCS. Однако я просто пытался продемонстрировать использование функций GetExtent и ReprojectCoords. Вы можете использовать все, что вы хотите в качестве целевого srs.
user2856
Да, спасибо, я бы никогда не нашел их иначе.
EddyTheB
Что если у вас есть набор данных, который не имеет проекции и указывает RPC? Сбой импорта из функции wkt. Можно рассчитать экстент, используя трансформатор, но мне было интересно, был ли способ с помощью метода выше?
Томас
41

Это может быть сделано в гораздо меньшем количестве строк кода

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верхний левый угол lrx, lryнижний правый угол

Библиотека osr (часть gdal) может использоваться для преобразования точек в любую систему координат. Для одной точки:

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)

Чтобы перепроецировать все растровое изображение будет гораздо более сложным делом, но GDAL> = 2.0 предлагает простое решение для этого тоже: gdal.Warp.

Джеймс
источник
Это ответ Pythonic для степени - одинаково Pythonic решение для репроекции было бы потрясающим, Тем не менее, я использую результаты в PostGIS, поэтому я просто пропускаю нетрансформированный экстент и ST_Transform(ST_SetSRID(ST_MakeBox2D([результаты] ),28355),4283)его. (Одно замечание - буква «Т» src.GetGeoTransform()должна быть написана заглавными буквами).
GT.
@GT. Добавил пример
Джеймс
1

Я сделал это ... это немного жестко запрограммировано, но если с gdalinfo ничего не изменится, это сработает для проецируемых изображений 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]
Эмилиано
источник
2
Это довольно хрупкое решение, поскольку оно зависит как gdalinfoот доступности пути пользователя (не всегда так, особенно в окнах), так и от анализа печатного вывода, который не имеет строгого интерфейса - то есть полагается на эти «магические числа» для правильного интервала. Это не нужно, когда gdal предоставляет всеобъемлющие привязки Python, которые могут сделать это более явным и надежным способом
Джеймс
1

Если ваш растр вращается, математика становится немного сложнее, так как вам необходимо учитывать каждый из шести коэффициентов аффинного преобразования. Рассмотрите возможность использования аффинного для преобразования повернутого аффинного преобразования / геотрансформации:

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|

Теперь вы можете сгенерировать четыре пары угловых координат:

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

И если вам также нужны сеточные границы (xmin, ymin, xmax, ymax):

xs = (c0x, c1x, c2x, c3x)
ys = (c0y, c1y, c2y, c3y)
bounds = min(xs), min(ys), max(xs), max(ys)
Майк Т
источник
0

Я полагаю, что в более поздних версиях модуля OSGEO / GDAL для python можно напрямую вызывать утилиты GDAL из кода без привлечения системных вызовов. например, вместо использования подпроцесса для вызова:

gdalinfo можно вызвать gdal.Info (the_name_of_the_file), чтобы получить доступ к метаданным / аннотации файла

или вместо использования подпроцесса для вызова: gdalwarp можно вызвать gdal.Warp, чтобы сделать деформацию растра.

Список утилит GDAL, доступных в настоящее время как внутренняя функция: http://erouault.blogspot.com/2015/10/gdal-and-ogr-utilities-as-library.html

Sinooshka
источник