GDAL 代表着 采用空间数据抽象库 是一把真正的“瑞士军刀”的地理信息系统数据功能。gdal的一个子集是 `OGR`_ _简单功能库，专门以各种标准格式读取和写入矢量地理数据。
geodjango为ogr的一些功能提供了一个高级的python接口，包括矢量空间数据的读取和坐标转换，以及对gdal关于栅格（图像）数据的功能的最小支持。
备注
尽管模块的名称为 gdal ，geodjango目前只支持ogr和gdal的一些栅格功能。
这里描述的GDAL/OGR工具旨在帮助您读取您的地理空间数据，为了使它们中的大多数有用，您必须有一些数据可用。如果您刚开始，并且还没有自己的任何数据可用，GeoDjango测试包含许多可用于测试的数据集。您可以在此处下载它们：
$ wget https://raw.githubusercontent.com/django/django/main/tests/gis_tests/data/cities/cities.{shp,prj,shx,dbf}
$ wget https://raw.githubusercontent.com/django/django/main/tests/gis_tests/data/rasters/raster.tif
DataSource¶DataSource 是OGR数据源对象的包装器，它支持使用一致的接口从各种OGR支持的地理空间文件格式和数据源读取数据。每个数据源由 DataSource 包含一个或多个数据层的对象。每层，用 Layer 对象，包含一些地理特征 (Feature ，有关该层中包含的功能类型（例如点、多边形等）以及任何附加字段的名称和类型的信息。 (Field ）与该层中的每个特征关联的数据。
的构造函数 DataSource 只需要一个参数：要读取的文件的路径。但是，OGR还支持各种更复杂的数据源，包括数据库，可以通过传递特殊的名称字符串而不是路径来访问这些数据源。有关详细信息，请参阅 `OGR Vector Formats`_ _文件。这个 name A的性质 DataSource 实例提供它正在使用的基础数据源的OGR名称。
可选的 encoding 参数允许您指定源中字符串的非标准编码。当您获得 DjangoUnicodeDecodeError 读取字段值时出现异常。
一旦您创建了您的 DataSource ，您可以通过访问 layer_count 属性，或(等效地)使用 len() 功能。有关访问数据层本身的信息，请参阅下一节：
>>> from django.contrib.gis.gdal import DataSource
>>> ds = DataSource("/path/to/your/cities.shp")
>>> ds.name
'/path/to/your/cities.shp'
>>> ds.layer_count # This file only contains one layer
1
返回数据源中的层数。
返回数据源的名称。
Layer¶Layer 是数据层的包装 DataSource 对象。你从不创造 Layer 直接对象。相反，您可以从 DataSource 对象，它本质上是 Layer 对象。例如，您可以通过其索引（例如 ds[0] 访问第一层），或者可以在 for 循环。这个 Layer 它本身充当几何特征的容器。
通常，给定图层中的所有要素都具有相同的几何图形类型。这个 geom_type 属性是一个 OGRGeomType 标识要素类型的。我们可以使用它打印出关于每个层的一些基本信息 DataSource ：
>>> for layer in ds:
... print('Layer "%s": %i %ss' % (layer.name, len(layer), layer.geom_type.name))
...
Layer "cities": 3 Points
示例输出来自上面加载的Cities数据源，该数据源显然包含一个名为 "cities" ，它包含三个点要素。为简单起见，以下示例假定您已将该图层存储在变量中 layer ：
>>> layer = ds[0]
返回数据源中此层的名称。
>>> layer.name
'cities'
返回图层中的要素数。相同于 len(layer) ：
>>> layer.num_feat
3
返回层的几何类型，形式为 OGRGeomType 对象：
>>> layer.geom_type.name
'Point'
返回该图层中的字段数，即与该图层中的每个要素关联的数据字段数：
>>> layer.num_fields
4
返回此层中每个字段的名称列表：
>>> layer.fields
['Name', 'Population', 'Density', 'Created']
返回此层中每个字段的数据类型列表。这些是的子类 Field ，讨论如下：
>>> [ft.__name__ for ft in layer.field_types]
['OFTString', 'OFTReal', 'OFTReal', 'OFTDate']
返回此层中每个字段的最大字段宽度列表：
>>> layer.field_widths
[80, 11, 24, 10]
返回此层中每个字段的数字精度列表。对于非数字字段，这是没有意义的(并且设置为零)：
>>> layer.field_precisions
[0, 0, 15, 0]
返回此层的空间范围，形式为 Envelope 对象：
>>> layer.extent.tuple
(-104.609252, 29.763374, -95.23506, 38.971823)
属性，它返回 SpatialReference 与该层关联：
>>> print(layer.srs)
GEOGCS["GCS_WGS_1984",
DATUM["WGS_1984",
SPHEROID["WGS_1984",6378137,298.257223563]],
PRIMEM["Greenwich",0],
UNIT["Degree",0.017453292519943295]]
如果 Layer 没有与之关联的空间引用信息， None 返回。
属性，该属性可用于检索或设置此层的空间过滤器。空间过滤器只能使用 OGRGeometry 实例、4元组区或 None 。当用其他东西设置时 None 在层上迭代时，只会返回与过滤器相交的要素：
>>> print(layer.spatial_filter)
None
>>> print(len(layer))
3
>>> [feat.get("Name") for feat in layer]
['Pueblo', 'Lawrence', 'Houston']
>>> ks_extent = (-102.051, 36.99, -94.59, 40.00) # Extent for state of Kansas
>>> layer.spatial_filter = ks_extent
>>> len(layer)
1
>>> [feat.get("Name") for feat in layer]
['Lawrence']
>>> layer.spatial_filter = None
>>> len(layer)
3
返回图层中每个要素的给定字段的值列表的方法：
>>> layer.get_fields("Name")
['Pueblo', 'Lawrence', 'Houston']
返回包含图层中每个要素的几何图形的列表的方法。如果可选参数 geos 设置为 True 然后将几何图形转换为 GEOSGeometry 物体。否则，它们将作为 OGRGeometry 对象：
>>> [pt.tuple for pt in layer.get_geoms()]
[(-104.609252, 38.255001), (-95.23506, 38.971823), (-95.363151, 29.763374)]
返回一个布尔值，指示此层是否支持给定的功能（字符串）。有效功能字符串的示例包括： 'RandomRead' ， 'SequentialWrite' ， 'RandomWrite' ， 'FastSpatialFilter' ， 'FastFeatureCount' ， 'FastGetExtent' ， 'CreateField' ， 'Transactions' ， 'DeleteFeature' 和 'FastSetNextByIndex' .
Feature¶Feature 包装一个食人魔功能。你从不创造 Feature 直接对象。相反，您可以从 Layer 对象。每个特征都由一个几何图形和一组包含其他特性的字段组成。字段的几何图形可以通过 geom 属性，它返回 OGRGeometry 对象。一 Feature 其行为类似于其字段的标准python容器，返回为 Field 对象：您可以直接通过字段的索引或名称访问字段，或者可以迭代功能的字段，例如 for 循环。
返回此要素的几何，作为 OGRGeometry 对象：
>>> city.geom.tuple
(-104.609252, 38.255001)
返回此功能的给定字段(由名称指定)的值的方法， not 一个 Field 包装器对象：
>>> city.get("Population")
102121
返回此功能的几何图形类型，作为 OGRGeomType 对象。这对于给定层中的所有功能都是相同的，并且相当于 Layer.geom_type 性质 Layer 对象该功能的来源。
返回与功能关联的数据字段数。这对于给定层中的所有功能都是相同的，并且相当于 Layer.num_fields 性质 Layer 对象该功能的来源。
返回与功能关联的数据字段的名称列表。这对于给定层中的所有功能都是相同的，并且相当于 Layer.fields 性质 Layer 对象该功能的来源。
返回图层内的要素标识符：
>>> city.fid
0
返回对象的名称 Layer 这个特写是从哪里来的。对于给定图层中的所有要素，这将是相同的：
>>> city.layer_name
'cities'
返回给定字段名的索引的方法。对于给定图层中的所有要素，这将是相同的：
>>> city.index("Population")
1
Field¶返回此字段的名称：
>>> city["Name"].name
'Name'
以整数形式返回此字段的OGR类型。这个 FIELD_CLASSES 字典将这些值映射到 Field ：
>>> city["Density"].type
2
返回具有此字段数据类型名称的字符串：
>>> city["Name"].type_name
'String'
返回此字段的值。这个 Field 类本身以字符串形式返回值，但每个子类都以最合适的形式返回值：
>>> city["Population"].value
102121
返回此字段的宽度：
>>> city["Name"].width
80
返回此字段的数字精度。对于非数字字段，这是没有意义的(并且设置为零)：
>>> city["Density"].precision
15
以双精度(浮点型)形式返回字段的值：
>>> city["Density"].as_double()
874.7
以整数形式返回字段的值：
>>> city["Population"].as_int()
102121
以字符串形式返回字段的值：
>>> city["Name"].as_string()
'Pueblo'
以日期和时间组件的元组形式返回字段的值：
>>> city["Created"].as_datetime()
(c_long(1999), c_long(5), c_long(23), c_long(0), c_long(0), c_long(0), c_long(0))
Driver¶这个 Driver 类在内部用于包装OGR DataSource 驱动程序。
返回当前注册的OGR矢量驱动程序数。
OGRGeometry¶OGRGeometry 对象与共享相似的功能 GEOSGeometry 对象，并且是OGR内部几何体表示的薄包装器。因此，它们允许在使用时更高效地访问数据 DataSource 。与GEOS不同的是， OGRGeometry 支持空间参考系和坐标转换：
>>> from django.contrib.gis.gdal import OGRGeometry
>>> polygon = OGRGeometry("POLYGON((0 0, 5 0, 5 5, 0 5))")
此对象是 `OGR Geometry`_ 类。这些对象直接从给定的 geom_input 参数，可以是包含wkt、hex、geojson、a的字符串 buffer 包含WKB数据，或 OGRGeomType 对象。这些对象也从 Feature.geom 属性，当从 Layer （依次是 DataSource ）
构建一个 OGRGeometry 来自给定的GML字符串。
构建一个 Polygon 来自给定的边界框（4元组）。
返回 LineString ，中的环数 Polygon 或 GeometryCollection . 不适用于其他几何图形类型。
循环访问 LineString 把戒指放在 Polygon 或中的几何图形 GeometryCollection . 不适用于其他几何图形类型。
返回指定索引处的点 LineString ，位于指定索引处的内环 Polygon 或中指定索引处的几何图形 GeometryCollection . 不适用于其他几何图形类型。
返回几何体的坐标尺寸数，即0表示点，1表示直线，依此类推：
>>> polygon.dimension
2
返回或设置此几何图形的坐标尺寸。例如，二维几何图形的值为2。
返回此几何图形中的元素数：
>>> polygon.geom_count
1
返回用于描述此几何图形的点数：
>>> polygon.point_count
4
Alias point_count .
Alias point_count .
返回此几何图形的类型，作为 OGRGeomType 对象。
返回此几何图形的类型的名称：
>>> polygon.geom_name
'POLYGON'
返回此几何图形的面积，如果几何图形不包含面积，则返回0：
>>> polygon.area
25.0
返回此几何图形的信封，作为 Envelope 对象。
将此几何图形的包络作为四元组返回，而不是作为 Envelope 对象：
>>> point.extent
(0.0, 0.0, 5.0, 5.0)
此属性控制此几何图形的空间参考，或 None 如果没有为其指定空间参考系。如果赋值，则访问此属性将返回 SpatialReference 对象。它可以和另一个设置在一起 SpatialReference 对象，或任何输入 SpatialReference 接受。示例：
>>> city.geom.srs.name
'GCS_WGS_1984'
返回或设置与 SpatialReference 这几何学。退换商品 None 如果没有与此几何图形关联的空间参考信息，或者无法确定SRID。
返回A GEOSGeometry 与此几何图形对应的对象。
以GML格式返回此几何图形的字符串表示形式：
>>> OGRGeometry("POINT(1 2)").gml
'<gml:Point><gml:coordinates>1,2</gml:coordinates></gml:Point>'
以十六进制WKB格式返回此几何图形的字符串表示形式：
>>> OGRGeometry("POINT(1 2)").hex
'0101000000000000000000F03F0000000000000040'
以JSON格式返回此几何图形的字符串表示形式：
>>> OGRGeometry("POINT(1 2)").json
'{ "type": "Point", "coordinates": [ 1.000000, 2.000000 ] }'
以kml格式返回此几何图形的字符串表示形式。
返回保存此几何体的WKB表示所需的WKB缓冲区的大小：
>>> OGRGeometry("POINT(1 2)").wkb_size
21
返回A buffer 包含此几何图形的WKB表示。
以WKT格式返回此几何图形的字符串表示形式。
返回此几何图形的EWKT表示形式。
返回新的 OGRGeometry 此几何图形对象的复制。
如果此几何图形内有任何尚未闭合的环，此例程将通过将起点添加到末端来完成此操作：
>>> triangle = OGRGeometry("LINEARRING (0 0,0 1,1 0)")
>>> triangle.close_rings()
>>> triangle.wkt
'LINEARRING (0 0,0 1,1 0,0 0)'
将此几何图形转换为不同的空间参考系统。可能采取 CoordTransform 对象，A SpatialReference 对象或接受的任何其他输入 SpatialReference （包括空间参照WKT和PROJ字符串，或整数SRID）。
默认情况下，不返回任何内容，几何图形将在适当位置进行转换。但是，如果 clone 关键字设置为 True 然后返回该几何体的已转换复制。
返回 True 如果此几何图形与其他几何图形相交，则返回 False .
返回 True 如果此几何图形与另一几何图形等效，则返回 False .
返回 True 如果此几何体在空间上与另一几何体不相交（即不相交），则返回 False .
返回 True 如果此几何图形与另一几何图形接触，则返回 False .
返回 True 如果此几何图形与其他几何图形交叉，则返回 False .
返回 True 如果此几何图形包含在另一个几何图形中，则返回 False .
返回 True 如果此几何图形包含其他几何图形，则返回 False .
返回 True 如果此几何图形与其他几何图形重叠，则返回 False .
这个几何体的边界，作为一个新的 OGRGeometry 对象。
包含此几何图形的最小凸多边形，作为新的 OGRGeometry 对象。
作为新的 OGRGeometry 对象。
作为新的 OGRGeometry 对象。
作为新的 OGRGeometry 对象。
返回由此几何图形和另一个几何图形的并集组成的区域，作为新的 OGRGeometry 对象。
以元组形式返回点几何图形的坐标，以元组形式返回线几何图形的坐标，依此类推：
>>> OGRGeometry("POINT (1 2)").tuple
(1.0, 2.0)
>>> OGRGeometry("LINESTRING (1 2,3 4)").tuple
((1.0, 2.0), (3.0, 4.0))
的别名 tuple .
返回该点的X坐标：
>>> OGRGeometry("POINT (1 2)").x
1.0
返回该点的Y坐标：
>>> OGRGeometry("POINT (1 2)").y
2.0
返回该点的Z坐标，或 None 如果该点没有Z坐标：
>>> OGRGeometry("POINT (1 2 3)").z
3.0
返回此行中的X坐标列表：
>>> OGRGeometry("LINESTRING (1 2,3 4)").x
[1.0, 3.0]
返回此行中的Y坐标列表：
>>> OGRGeometry("LINESTRING (1 2,3 4)").y
[2.0, 4.0]
返回此行中的Z坐标列表，或 None 如果直线没有Z坐标：
>>> OGRGeometry("LINESTRING (1 2 3,4 5 6)").z
[3.0, 6.0]
OGRGeomType¶此类允许以以下任一方式表示OGR几何图形类型：
>>> from django.contrib.gis.gdal import OGRGeomType
>>> gt1 = OGRGeomType(3) # Using an integer for the type
>>> gt2 = OGRGeomType("Polygon") # Using a string
>>> gt3 = OGRGeomType("POLYGON") # It's case-insensitive
>>> print(gt1 == 3, gt1 == "Polygon") # Equivalence works w/non-OGRGeomType objects
True True
返回OGR几何体类型的速记字符串形式：
>>> gt1.name
'Polygon'
返回与OGR几何图形类型对应的数字：
>>> gt1.num
3
返回用于存储此OGR类型的Django字段类型(GeometryField子类)，或 None 如果没有合适的Django类型：
>>> gt1.django
'PolygonField'
Envelope¶SpatialReference¶空间引用对象在给定的 srs_input ，可以是以下之一：
OGC已知文本（WKT）（字符串）
EPSG代码（整数或字符串）
项目字符串
著名标准的简写字符串 ('WGS84' ， 'WGS72' ， 'NAD27' ， 'NAD83' ）
示例：
>>> wgs84 = SpatialReference("WGS84") # shorthand string
>>> wgs84 = SpatialReference(4326) # EPSG code
>>> wgs84 = SpatialReference("EPSG:4326") # EPSG string
>>> proj = "+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs "
>>> wgs84 = SpatialReference(proj) # PROJ string
>>> wgs84 = SpatialReference(
... """GEOGCS["WGS 84",
... DATUM["WGS_1984",
... SPHEROID["WGS 84",6378137,298.257223563,
... AUTHORITY["EPSG","7030"]],
... AUTHORITY["EPSG","6326"]],
... PRIMEM["Greenwich",0,
... AUTHORITY["EPSG","8901"]],
... UNIT["degree",0.01745329251994328,
... AUTHORITY["EPSG","9122"]],
... AUTHORITY["EPSG","4326"]]"""
... ) # OGC WKT
返回给定字符串属性节点的值， None 如果该节点不存在。也可以将元组作为参数(目标，子级)，其中，子级是属性在WKT中的索引。例如：
>>> wkt = 'GEOGCS["WGS 84", DATUM["WGS_1984, ... AUTHORITY["EPSG","4326"]]'
>>> srs = SpatialReference(wkt) # could also use 'WGS84', or 4326
>>> print(srs["GEOGCS"])
WGS 84
>>> print(srs["DATUM"])
WGS_1984
>>> print(srs["AUTHORITY"])
EPSG
>>> print(srs["AUTHORITY", 1]) # The authority value
4326
>>> print(srs["TOWGS84", 4]) # the fourth value in this wkt
0
>>> print(srs["UNIT|AUTHORITY"]) # For the units authority, have to use the pipe symbol.
EPSG
>>> print(srs["UNIT|AUTHORITY", 1]) # The authority value for the units
9122
给定目标节点的属性值（例如 'PROJCS' ）index关键字指定要返回的子节点的索引。
返回给定字符串目标节点的颁发机构名称。
返回给定字符串目标节点的授权代码。
返回此空间引用对象的复制。
此方法检查此 SpatialReference 并将在EPSG标识符适用的地方添加EPSG权限节点。
将此空间引用从esri的格式变形为epsg
将此空间引用变形为ESRI的格式。
检查给定的空间引用是否有效，否则将引发异常。
从EPSG代码导入空间引用。
从项目字符串导入空间参照。
从WKT导入空间引用。
从XML导入空间引用。
返回此空间引用的名称。
返回顶级权限的SRID，或者 None 如果未定义。
返回线性单位的名称。
返回线性单位的值。
返回角度单位的名称。“
返回角度单位的值。
返回单位值和单位名称的2元组，并自动确定是返回线性单位还是角度单位。
返回此空间引用的椭球参数的元组：（半长轴、半短轴和反向展平）。
返回此空间引用的椭圆体的半长轴。
返回此空间引用的椭圆体的半短轴。
返回此空间引用的椭球体的反向展平。
返回 True 如果此空间引用是地理的（根节点是 GEOGCS ）
返回 True 如果此空间引用是本地的（根节点是 LOCAL_CS ）
返回 True 如果该空间参考是投影坐标系（根节点是 PROJCS ）
返回此空间引用的WKT表示形式。
返回wkt的“漂亮”表示形式。
返回此空间参照的项目表示形式。
Alias SpatialReference.proj .
返回此空间引用的XML表示形式。
CoordTransform¶表示坐标系变换。它是用两个 SpatialReference ，分别表示源坐标系和目标坐标系。在不同的几何体上重复执行相同的坐标变换时，应使用这些对象：
>>> ct = CoordTransform(SpatialReference("WGS84"), SpatialReference("NAD83"))
>>> for feat in layer:
... geom = feat.geom # getting clone of feature geometry
... geom.transform(ct) # transforming
...
GDALRaster¶GDALRaster 是GDAL栅格源对象的包装器，它支持使用一致的接口从各种GDAL支持的地理空间文件格式和数据源读取数据。每个数据源由 GDALRaster 对象，其中包含一个或多个名为Bands的数据层。每个波段，由一个 GDALBand 对象，包含地理参考图像数据。例如，一个RGB图像表示为三个波段：一个代表红色，一个代表绿色，一个代表蓝色。
备注
对于栅格数据，栅格实例与其数据源之间没有区别。与几何体对象不同， GDALRaster 对象始终是数据源。临时栅格可以使用相应的驱动程序在内存中实例化，但它们与基于文件的栅格源属于同一类。
的构造函数 GDALRaster 接受两个参数。第一个参数定义栅格源，第二个参数定义是否应在写入模式下打开栅格。对于新创建的栅格，第二个参数将被忽略，并且新栅格始终以写入模式创建。
第一个参数可以采用三种形式：字符串或 Path 表示文件路径(文件系统或GDAL虚拟文件系统)、具有定义新栅格的值的字典或表示栅格文件的字节对象。
如果输入是文件路径，则从那里打开栅格。如果输入是字典中的原始数据，则参数 width ， height 和 srid 是必需的。如果输入是bytes对象，则将使用gdal虚拟文件系统打开它。
有关如何使用字典输入创建栅格的详细说明，请参见 从数据创建栅格 . 有关如何在虚拟文件系统中创建栅格的详细说明，请参阅 使用gdal的虚拟文件系统 .
以下示例显示如何从不同的输入源（使用来自geodjango测试的示例数据）创建栅格；另请参见 样本数据 部分）。
>>> from django.contrib.gis.gdal import GDALRaster
>>> rst = GDALRaster("/path/to/your/raster.tif", write=False)
>>> rst.name
'/path/to/your/raster.tif'
>>> rst.width, rst.height # This file has 163 x 174 pixels
(163, 174)
>>> rst = GDALRaster(
... { # Creates an in-memory raster
... "srid": 4326,
... "width": 4,
... "height": 4,
... "datatype": 1,
... "bands": [
... {
... "data": (2, 3),
... "offset": (1, 1),
... "size": (2, 2),
... "shape": (2, 1),
... "nodata_value": 5,
... }
... ],
... }
... )
>>> rst.srs.srid
4326
>>> rst.width, rst.height
(4, 4)
>>> rst.bands[0].data()
array([[5, 5, 5, 5],
[5, 2, 3, 5],
[5, 2, 3, 5],
[5, 5, 5, 5]], dtype=uint8)
>>> rst_file = open("/path/to/your/raster.tif", "rb")
>>> rst_bytes = rst_file.read()
>>> rst = GDALRaster(rst_bytes)
>>> rst.is_vsi_based
True
>>> rst.name # Stored in a random path in the vsimem filesystem.
'/vsimem/da300bdb-129d-49a8-b336-e410a9428dad'
源的名称，相当于输入文件路径或实例化时提供的名称。
>>> GDALRaster({"width": 10, "height": 10, "name": "myraster", "srid": 4326}).name
'myraster'
用于处理输入文件的gdal驱动程序的名称。为了 GDALRaster 从文件创建时，将自动检测驱动程序类型。默认情况下，从头开始创建栅格是内存中的栅格 ('MEM' ，但可以根据需要进行更改。例如，使用 GTiff 对于一个 GeoTiff 文件。有关文件类型的列表，请参见 `GDAL Raster Formats`_ 名单。
内存中的栅格是通过以下示例创建的：
>>> GDALRaster({"width": 10, "height": 10, "srid": 4326}).driver.name
'MEM'
通过以下示例创建基于文件的geotiff栅格：
>>> import tempfile
>>> rstfile = tempfile.NamedTemporaryFile(suffix=".tif")
>>> rst = GDALRaster(
... {
... "driver": "GTiff",
... "name": rstfile.name,
... "srid": 4326,
... "width": 255,
... "height": 255,
... "nr_of_bands": 1,
... }
... )
>>> rst.name
'/tmp/tmp7x9H4J.tif' # The exact filename will be different on your computer
>>> rst.driver.name
'GTiff'
源的宽度（以像素为单位）（X轴）。
>>> GDALRaster({"width": 10, "height": 20, "srid": 4326}).width
10
源的高度（以像素为单位）（Y轴）。
>>> GDALRaster({"width": 10, "height": 20, "srid": 4326}).height
20
栅格的空间参考系，如 SpatialReference 实例。SRS可以通过将其设置为其他 SpatialReference 或提供 SpatialReference 建造师。
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.srs.srid
4326
>>> rst.srs = 3086
>>> rst.srs.srid
3086
栅格的空间参考系统标识符（SRID）。此属性是通过 srs 属性。
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.srid
4326
>>> rst.srid = 3086
>>> rst.srid
3086
>>> rst.srs.srid # This is equivalent
3086
用于对源进行地理参考的仿射变换矩阵，作为六个系数的元组，使用以下关系将像素/线坐标映射到地理参考空间：
Xgeo = GT(0) + Xpixel * GT(1) + Yline * GT(2)
Ygeo = GT(3) + Xpixel * GT(4) + Yline * GT(5)
通过访问 origin （指数0和3） scale （指数1和5）和 skew （索引2和4）属性。
默认值为 [0.0, 1.0, 0.0, 0.0, 0.0, -1.0] .
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.geotransform
[0.0, 1.0, 0.0, 0.0, 0.0, -1.0]
源空间参考系中栅格左上角原点的坐标，作为点对象 x 和 y 成员。
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.origin
[0.0, 0.0]
>>> rst.origin.x = 1
>>> rst.origin
[1.0, 0.0]
像素宽度和高度，用于对栅格进行地理参考，作为具有 x 和 y 成员。见 geotransform 更多信息。
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.scale
[1.0, -1.0]
>>> rst.scale.x = 2
>>> rst.scale
[2.0, -1.0]
倾斜系数用于地理参考栅格，作为点对象 x 和 y 成员。对于北向上图像，这些系数都是 0 .
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.skew
[0.0, 0.0]
>>> rst.skew.x = 3
>>> rst.skew
[3.0, 0.0]
栅格源的范围（边界值），作为4元组 (xmin, ymin, xmax, ymax) 在源的空间参考系中。
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.extent
(0.0, -20.0, 10.0, 0.0)
>>> rst.origin.x = 100
>>> rst.extent
(100.0, -20.0, 110.0, 0.0)
源的所有带区列表，如 GDALBand 实例。
>>> rst = GDALRaster(
... {
... "width": 1,
... "height": 2,
... "srid": 4326,
... "bands": [{"data": [0, 1]}, {"data": [2, 3]}],
... }
... )
>>> len(rst.bands)
2
>>> rst.bands[1].data()
array([[ 2., 3.]], dtype=float32)
返回此栅格的扭曲版本。
翘曲参数可以通过 ds_input 参数。使用 ds_input 类似于类构造函数的相应参数。它是一本具有目标栅格特征的词典。允许的字典键值包括宽度、高度、srid、原点、比例、倾斜、数据类型、驱动程序和名称（文件名）。
默认情况下，扭曲函数将大多数参数保持等于原始源栅格的值，因此只需要指定应更改的参数。请注意，这包括驱动程序，因此对于基于文件的栅格，warp函数将在磁盘上创建一个新的栅格。
唯一与源栅格设置不同的参数是名称。栅格名称的默认值是附加有 '_copy' + source_driver_name . 对于基于文件的栅格，建议提供目标栅格的文件路径。
用于翘曲的重采样算法可以用 resampling 参数。默认值为 NearestNeighbor ，其他允许值为 Bilinear ， Cubic ， CubicSpline ， Lanczos ， Average 和 Mode .
这个 max_error 参数可用于指定在近似转换时允许的以输入像素测量的最大误差。对于精确计算，默认值为0.0。
对于熟悉 GDAL ，此函数的功能与 gdalwarp 命令行实用程序。
例如，翘曲函数可用于将栅格聚合到其原始像素比例的两倍：
>>> rst = GDALRaster(
... {
... "width": 6,
... "height": 6,
... "srid": 3086,
... "origin": [500000, 400000],
... "scale": [100, -100],
... "bands": [{"data": range(36), "nodata_value": 99}],
... }
... )
>>> target = rst.warp({"scale": [200, -200], "width": 3, "height": 3})
>>> target.bands[0].data()
array([[ 7., 9., 11.],
[ 19., 21., 23.],
[ 31., 33., 35.]], dtype=float32)
将此栅格转换为不同的空间参考系统 (srs )，可能是 SpatialReference 对象或接受的任何其他输入 SpatialReference （包括空间参照WKT和PROJ字符串，或整数SRID）。
它计算新空间参考系统中当前栅格的边界和比例，并使用 warp 功能。
默认情况下，将使用源栅格的驱动程序，并且栅格的名称是附加的原始名称 '_copy' + source_driver_name . 可以使用指定其他驱动程序或名称 driver 和 name 参数。
默认的重采样算法是 NearestNeighbour 但可以使用 resampling 参数。重新采样的默认最大允许错误为0.0，可以使用 max_error 参数。查阅 warp 有关这些参数的详细信息的文档。
>>> rst = GDALRaster(
... {
... "width": 6,
... "height": 6,
... "srid": 3086,
... "origin": [500000, 400000],
... "scale": [100, -100],
... "bands": [{"data": range(36), "nodata_value": 99}],
... }
... )
>>> target_srs = SpatialReference(4326)
>>> target = rst.transform(target_srs)
>>> target.origin
[-82.98492744885776, 27.601924753080144]
返回带有栅格摘要的字符串。这相当于 `gdalinfo`_ _命令行实用程序。
此栅格的元数据，表示为嵌套字典。第一级密钥是元数据域。第二个级别包含来自每个域的元数据项名称和值。
要设置或更新元数据项，请使用上面描述的嵌套结构将相应的元数据项传递给方法。仅更新指定字典中的键；其余元数据保持不变。
要删除元数据项，请使用 None 作为元数据值。
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.metadata
{}
>>> rst.metadata = {"DEFAULT": {"OWNER": "Django", "VERSION": "1.0"}}
>>> rst.metadata
{'DEFAULT': {'OWNER': 'Django', 'VERSION': '1.0'}}
>>> rst.metadata = {"DEFAULT": {"OWNER": None, "VERSION": "2.0"}}
>>> rst.metadata
{'DEFAULT': {'VERSION': '2.0'}}
A bytes 此栅格的表示。退换商品 None 对于不存储在gdal的虚拟文件系统中的raster。
一个布尔值，指示该栅格是否存储在gdal的虚拟文件系统中。
GDALBand¶GDALBand 实例不是显式创建的，而是从 GDALRaster 对象，通过它 bands 属性。gdablands包含栅格的实际像素值。
乐队的名称或描述（如果有的话）。
带区的宽度（以像素为单位）（X轴）。
带的高度（以像素为单位）（Y轴）。
此波段中的像素总数。等于 width * height .
计算该波段像素值的统计信息。返回值是具有以下结构的元组： (minimum, maximum, mean, standard deviation) .
如果 approximate 参数设置为 True ，统计信息可以基于概述或图像块的子集进行计算。
如果 refresh 参数设置为 True ，将直接从数据中计算统计信息，并使用结果更新缓存。
如果找到持久缓存值，则返回该值。对于使用持久辅助元数据（PAM）服务的栅格格式，统计信息可能缓存在辅助文件中。在某些情况下，此元数据可能与像素值不同步，或者导致返回以前调用的值，而这些值不反映 approximate 参数。在这种情况下，使用 refresh 获取更新值并将其存储在缓存中的参数。
对于空带区（其中所有像素值都是“无数据”），所有统计信息都返回为 None .
波段的最小像素值（不包括“无数据”值）。
波段的最大像素值（不包括“无数据”值）。
带区所有像素值的平均值（不包括“无数据”值）。
波段所有像素值的标准偏差（不包括“无数据”值）。
波段的“无数据”值通常是用于标记无效数据像素的特殊标记值。通常不应显示此类像素，也不应有助于分析操作。
若要删除现有的“no data”值，请将此属性设置为 None 。
波段中包含的数据类型，为介于0(未知)和14之间的整数常量。如果 as_string 是 True ，则以字符串形式返回数据类型。中的“GDAL像素类型”专栏 datatype value table 获取可能的值。
波段的颜色解释，以0到16之间的整数表示。如果 as_string 是 True ，数据类型以字符串的形式返回，其中可能包含以下值： GCI_Undefined ， GCI_GrayIndex ， GCI_PaletteIndex ， GCI_RedBand ， GCI_GreenBand ， GCI_BlueBand ， GCI_AlphaBand ， GCI_HueBand ， GCI_SaturationBand ， GCI_LightnessBand ， GCI_CyanBand ， GCI_MagentaBand ， GCI_YellowBand ， GCI_BlackBand ， GCI_YCbCr_YBand ， GCI_YCbCr_CbBand 和 GCI_YCbCr_CrBand . GCI_YCbCr_CrBand 也代表 GCI_Max 因为两者都对应于整数16，但仅 GCI_YCbCr_CrBand 作为字符串返回。
像素值的访问器 GDALBand . 如果未提供参数，则返回完整的数据数组。可以通过将偏移量和块大小指定为元组来请求像素数组的子集。
如果numpy可用，数据将作为numpy数组返回。出于性能原因，强烈建议使用numpy。
数据写入 GDALBand 如果 data 提供了参数。输入可以是以下类型之一-压缩字符串、缓冲区、列表、数组和numpy数组。输入中的项目数通常应与带区中的像素总数相对应，或者与特定像素值块的像素数相对应，如果 offset 和 size 提供参数。
如果输入中的项目数不同于目标像素块，则 shape 必须指定参数。该形状是一个以像素为单位指定输入数据的宽度和高度的元组。然后复制数据以更新所选块的像素值。例如，这对于用单个值填充整个带区很有用。
例如：
>>> rst = GDALRaster(
... {"width": 4, "height": 4, "srid": 4326, "datatype": 1, "nr_of_bands": 1}
... )
>>> bnd = rst.bands[0]
>>> bnd.data(range(16))
>>> bnd.data()
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]], dtype=int8)
>>> bnd.data(offset=(1, 1), size=(2, 2))
array([[ 5, 6],
[ 9, 10]], dtype=int8)
>>> bnd.data(data=[-1, -2, -3, -4], offset=(1, 1), size=(2, 2))
>>> bnd.data()
array([[ 0, 1, 2, 3],
[ 4, -1, -2, 7],
[ 8, -3, -4, 11],
[12, 13, 14, 15]], dtype=int8)
>>> bnd.data(data="\x9d\xa8\xb3\xbe", offset=(1, 1), size=(2, 2))
>>> bnd.data()
array([[ 0, 1, 2, 3],
[ 4, -99, -88, 7],
[ 8, -77, -66, 11],
[ 12, 13, 14, 15]], dtype=int8)
>>> bnd.data([1], shape=(1, 1))
>>> bnd.data()
array([[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]], dtype=uint8)
>>> bnd.data(range(4), shape=(1, 4))
array([[0, 0, 0, 0],
[1, 1, 1, 1],
[2, 2, 2, 2],
[3, 3, 3, 3]], dtype=uint8)
此乐队的元数据。功能与 GDALRaster.metadata .
本节介绍如何使用 ds_input 参数。
当 dict 传递给 GDALRaster 构造函数。字典包含新栅格的定义参数，如原点、大小或空间参考系统。字典还可以包含像素数据和有关新栅格格式的信息。因此，生成的栅格可以基于文件或基于内存，具体取决于指定的驱动程序。
没有在字典或JSON风格中描述栅格数据的标准。字典输入到的定义 GDALRaster 因此类是特定于Django的。它的灵感来自 `geojson`_ _格式，但是 geojson 标准目前仅限于矢量格式。
创建栅格时使用不同键的示例可以在文档中找到 GDALRaster 和 GDALBand 类。
ds_input 词典¶在 ds_input 创建栅格的字典： width ， height 和 srid . 所有其他参数都有默认值（见下表）。可以在 ds_input 字典是密切相关的，但与 GDALRaster 性质。许多参数直接映射到这些属性；其他参数如下所述。
下表说明了可以在 ds_input 字典。
键 |
违约 |
使用 |
|---|---|---|
|
必修的 |
映射到 |
|
必修的 |
映射到 |
|
必修的 |
映射到 |
|
|
映射到 |
|
|
见下文 |
|
|
映射到 |
|
|
映射到 |
|
|
映射到 |
|
|
见下文 |
|
|
见下文 |
|
|
见下文 |
|
|
见下文 |
表示栅格名称的字符串。创建基于文件的栅格时，此参数必须是新栅格的文件路径。如果名称以开头 /vsimem/ ，栅格在gdal的虚拟文件系统中创建。
表示所有带区的数据类型的整数。默认为 6 （浮选32）。新栅格的所有带区都必须具有相同的数据类型。值映射为：
价值 |
GDAL像素类型 |
描述 |
|---|---|---|
1 |
GDT_Byte |
8位无符号整数 |
2 |
GDT_UInt16 |
16位无符号整数 |
3 |
GDT_Int16 |
16位带符号整数 |
4 |
GDT_UInt32 |
32位无符号整数 |
5 |
GDT_Int32 |
32位带符号整数 |
6 |
GDT_Float32 |
32位浮点 |
7 |
GDT_Float64 |
64位浮点 |
12 |
GDT_UInt64 |
64位无符号整数(GDAL 3.5+) |
13 |
GDT_Int64 |
64位带符号整数(GDAL 3.5+) |
14 |
GDT_Int8 |
8位带符号整数(GDAL 3.7+) |
表示栅格带数的整数。创建栅格时无需传递带数据。如果未指定波段数，则会根据 bands 输入。创建后无法更改带区数。
列表 band_input 带输入数据的字典。产生的波段指数与提供的列表中的相同。频带输入字典的定义如下。如果未提供波段数据，栅格波段值将被实例化为一个零数组，“无数据”值设置为 None .
带有栅格创建选项的字典。输入字典的键值对在创建栅格时传递给驱动程序。
可用选项是特定于驱动程序的，并在每个驱动程序的文档中进行了描述。
字典中的值不区分大小写，并且在创建时自动转换为正确的字符串格式。
下面的示例使用了一些可用于 `GTiff driver`__. 结果是一个带有内部平铺方案的压缩栅格。内部瓷砖的块大小为23 x 23：
>>> GDALRaster(
... {
... "driver": "GTiff",
... "name": "/path/to/new/file.tif",
... "srid": 4326,
... "width": 255,
... "height": 255,
... "nr_of_bands": 1,
... "papsz_options": {
... "compress": "packbits",
... "tiled": "yes",
... "blockxsize": 23,
... "blockysize": 23,
... },
... }
... )
band_input 词典¶这个 bands 关键在 ds_input 字典是 band_input 字典。各 band_input 字典可以包含像素值和要在新栅格条带上设置的“无数据”值。数据数组可以具有新栅格的完整大小，也可以更小。对于小于完整栅格的阵列，将 size ， shape 和 offset 键控制像素值。相应的键传递给 data() 方法。它们的功能与使用该方法设置波段数据相同。下表介绍了可以使用的键。
键 |
违约 |
使用 |
|---|---|---|
|
|
映射到 |
|
等同于 |
传递给 |
|
|
传递给 |
|
大小相同 |
传递给 |
|
|
传递给 |
GDAL可以访问存储在文件系统中的文件，但也支持虚拟文件系统抽象访问其他类型的文件，如压缩、加密或远程文件。
gdal有一个基于内存的内部文件系统，它允许将内存块视为文件。它可以读写 GDALRaster 与二进制文件缓冲区之间的对象。
这在Web环境中很有用，在这种情况下，可以从远程存储中获取栅格作为缓冲区，或者从视图返回栅格而不写入磁盘。
GDALRaster 当 bytes 对象作为输入提供，或者当文件路径以 /vsimem/ .
提供的输入为 bytes 必须是文件的全二进制表示形式。例如：
# Read a raster as a file object from a remote source.
>>> from urllib.request import urlopen
>>> dat = urlopen("https://example.com/raster.tif").read()
# Instantiate a raster from the bytes object.
>>> rst = GDALRaster(dat)
# The name starts with /vsimem/, indicating that the raster lives in the
# virtual filesystem.
>>> rst.name
'/vsimem/da300bdb-129d-49a8-b336-e410a9428dad'
要从头创建新的基于虚拟文件的栅格，请使用 ds_input 字典表示并提供 name 以…开头的论点 /vsimem/ （有关字典表示的详细信息，请参见 从数据创建栅格 ）对于基于虚拟文件的栅格， vsi_buffer 属性返回 bytes 栅格的表示。
下面介绍如何创建栅格并将其作为文件在 HttpResponse ：
>>> from django.http import HttpResponse
>>> rst = GDALRaster(
... {
... "name": "/vsimem/temporarymemfile",
... "driver": "tif",
... "width": 6,
... "height": 6,
... "srid": 3086,
... "origin": [500000, 400000],
... "scale": [100, -100],
... "bands": [{"data": range(36), "nodata_value": 99}],
... }
... )
>>> HttpResponse(rast.vsi_buffer, "image/tiff")
根据GDAL的本地构建，可能还支持其他虚拟文件系统。您可以通过在提供的路径前添加适当的 /vsi*/ 前缀。请参阅 GDAL Virtual Filesystems documentation 了解更多详细信息。
与解压缩文件并实例化生成的栅格不同，GDAL可以使用 /vsizip/ ， /vsigzip/ ，或 /vsitar/ 虚拟文件系统：
>>> from django.contrib.gis.gdal import GDALRaster
>>> rst = GDALRaster("/vsizip/path/to/your/file.zip/path/to/raster.tif")
>>> rst = GDALRaster("/vsigzip/path/to/your/file.gz")
>>> rst = GDALRaster("/vsitar/path/to/your/file.tar/path/to/raster.tif")
GDAL可以透明地支持在线资源和存储提供商。只要它具备这样的能力就行。
要在不进行身份验证的情况下访问公共栅格文件，可以使用 /vsicurl/ ：
>>> from django.contrib.gis.gdal import GDALRaster
>>> rst = GDALRaster("/vsicurl/https://example.com/raster.tif")
>>> rst.name
'/vsicurl/https://example.com/raster.tif'
对于商业存储提供商(例如 /vsis3/ )系统应预先针对身份验证和可能的其他设置进行配置(请参阅 GDAL Virtual Filesystems documentation 有关可用选项的信息)。
GDAL_LIBRARY_PATH¶指定gdal库位置的字符串。通常，此设置仅在gdal库位于非标准位置（例如， /home/john/lib/libgdal.so ）
12月 18, 2023