---
title: "GDAL API"
version: 5.2
locale: ga
source: https://docs.djangoproject.com/ga/5.2/ref/contrib/gis/gdal/
canonical: https://djangodocs.dev/ga/5.2/ref/contrib/gis/gdal/
---
# GDAL API

Seasann  d'**Leabharlann Aistrithe Sonraí Geospásúil**, agus is fíor-“ scian arm na hEilvéise” é de fheidhmiúlacht sonraí GIS. Is fo-thacar de GDAL ná Leabharlann Gnéithe Simple , a dhéanann speisialtóireacht ar shonraí geografacha veicteora a léamh agus a scríobh i bhformáidí caighdeánacha éagsúla.

Soláthraíonn GeodJango comhéadan Python ardleibhéil do chuid de chumais OGR, lena n-áirítear claochlú léitheoireachta agus comhordaithe sonraí spásúla veicteora agus tacaíocht íosta do ghnéithe GDAL maidir le sonraí raster (íomhá).

> **Note**
>
> Cé go dtugtar “gdal” ar an modúl, ní thacaíonn GeoDjango ach le cuid de chumais gnéithe raster OGR agus GDAL ag an am seo.

## Forbhreathnú

### Sonraí Samplacha

Tá na huirlisí GDAL/OGR a thuairiscítear anseo deartha chun cabhrú leat do shonraí geospásúla a léamh, d'fhonn go mbeidh an chuid is mó díobh úsáideach caithfidh roinnt sonraí a bheith agat le hoibriú leo. Má tá tú ag tosú amach agus mura bhfuil aon sonraí féin agat le húsáid fós, tá roinnt tacar sonraí i dtástálacha GeodJango is féidir leat a úsáid le haghaidh tástála. Is féidir leat iad a íoslódáil anseo:

```shell
$ 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
```

## Rudaí Foinse Sonraí Veicteora

### `Sonraí Sonraí`

[`DataSource`](#django.contrib.gis.gdal.DataSource) is a wrapper for the OGR data source object that
supports reading data from a variety of OGR-supported geospatial file
formats and data sources using a consistent interface.  Each
data source is represented by a [`DataSource`](#django.contrib.gis.gdal.DataSource) object which contains
one or more layers of data.  Each layer, represented by a [`Layer`](#django.contrib.gis.gdal.Layer)
object, contains some number of geographic features ([`Feature`](#django.contrib.gis.gdal.Feature)),
information about the type of features contained in that layer (e.g.
points, polygons, etc.), as well as the names and types of any
additional fields ([`Field`](#django.contrib.gis.gdal.Field)) of data that may be associated with
each feature in that layer.

#### `class DataSource(ds_input, encoding='utf-8')`

Ní theastaíonn ach paraiméadar amháin ar an tógálaí do DataSource\`: cosán an chomhaid is mian leat a léamh. Mar sin féin, tacaíonn OGR le réimse foinsí sonraí níos casta, lena n-áirítear bunachair sonraí, ar féidir rochtain a fháil orthu trí shreang ainm speisialta a rith in ionad cosán. Le haghaidh tuilleadh faisnéise, féach an doiciméadú . Tugann maoin: Attr: ainm de shampla `Datasource` ainm OGR an fhoinse sonraí bunúsach atá á úsáid aige.

Ligeann an paraiméadar roghnach “ionchódú” duit ionchódú neamhchaighdeánach de na teaghráin sa fhoinse a shonrú. Is gnách go mbíonn sé seo úsáideach nuair a fhaigheann tú eisceachtaí `DjangounicodeDecodeError` agus tú ag léamh luachanna réimse.

Nuair a bheidh do Dataource\` cruthaithe agat, is féidir leat a fháil amach cé mhéad sraitheanna sonraí atá ann trí rochtain a fháil ar an maoin: attr: layer\_count, nó (go coibhéiseach) tríd an bhfeidhm len () a úsáid. Le haghaidh faisnéise maidir le rochtain a fháil ar na sraitheanna sonraí féin, féach an chéad chuid eile:

```pycon
>>> 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_count`

Tugann sé líon na sraitheanna san fhoinse sonraí ar ais.

#### `name`

Tugann ainm na foinse sonraí ar ais.

### Sraith \`\`

#### `class Layer`

Is é `Layer` fillteán do chiseal sonraí i réad `DataSource`. Ní chruthaíonn tú réad `Layer` go díreach riamh. Ina áit sin, aisghabhann tú iad ó a: class: DataSource réad, atá go bunúsach ina choimeádán caighdeánach Python de rudaí ```Layer`. Mar shampla, is féidir leat rochtain a fháil ar chiseal ar leith trína innéacs (m.sh. `ds [0] ``chun rochtain a fháil ar an gcéad chiseal), nó is féidir leat athrá thar na sraitheanna go léir sa choimeádán i lúb ``for```. Feidhmíonn an `Layer` féin mar choimeádán do ghnéithe geoiméadracha.

De ghnáth, bíonn an cineál céanna céanna ag na gnéithe go léir i gciseal áirithe. Is é maoin: attr: geom\_type ciseal ná: class: ogrGeomType a aithníonn an cineál gné. Is féidir linn é a úsáid chun roinnt faisnéise bunúsach a phriontáil faoi gach ciseal in a:class: DataSource:

```pycon
>>> for layer in ds:
...     print('Layer "%s": %i %ss' % (layer.name, len(layer), layer.geom_type.name))
...
Layer "cities": 3 Points
```

Tá an t-aschur sampla ó fhoinse sonraí na gcathracha, luchtaithe thuas, ina léir go bhfuil ciseal amháin, ar a dtugtar "cathracha” , ina bhfuil trí ghné phointe ann. Ar mhaithe le simplíocht, glacann na samplaí thíos leis gur stóráil tú an ciseal sin san athróg sraith :

```pycon
>>> layer = ds[0]
```

#### `name`

Tugann ainm an chiseal seo ar ais san fhoinse sonraí.

```pycon
>>> layer.name
'cities'
```

#### `num_feat`

Tugann sé líon na ngnéithe sa chiseal ar ais. Mar an gcéanna le len (ciseal) \`:

```pycon
>>> layer.num_feat
3
```

#### `geom_type`

Tugann sé cineál geoiméadrach an chiseal ar ais, mar réad: class: ogrGeomType:

```pycon
>>> layer.geom_type.name
'Point'
```

#### `num_fields`

Tugann sé líon na réimsí sa chiseal ar ais, ie líon na réimsí sonraí a bhaineann le gach gné sa chiseal:

```pycon
>>> layer.num_fields
4
```

#### `fields`

Tugann liosta ar ais d'ainmneacha gach ceann de na réimsí sa chiseal seo:

```pycon
>>> layer.fields
['Name', 'Population', 'Density', 'Created']
```

Tugann liosta de na cineálacha sonraí gach ceann de na réimsí sa chiseal seo ar ais. Is fo-aicmí iad seo de Field, a phléitear thíos:

```pycon
>>> [ft.__name__ for ft in layer.field_types]
['OFTString', 'OFTReal', 'OFTReal', 'OFTDate']
```

#### `field_widths`

Tugann liosta de na leithead réimse uasta do gach ceann de na réimsí sa chiseal seo ar ais:

```pycon
>>> layer.field_widths
[80, 11, 24, 10]
```

#### `field_precisions`

Tugann liosta de na cruinneas uimhriúla ar ais do gach ceann de na réimsí sa chiseal seo. Tá sé seo gan brí (agus socraithe go nialas) do réimsí neamh-uimhriúla:

```pycon
>>> layer.field_precisions
[0, 0, 15, 0]
```

#### `extent`

Tugann sé ar ais méid spásúil an chiseal seo, mar réad an:class: Envelope:

```pycon
>>> layer.extent.tuple
(-104.609252, 29.763374, -95.23506, 38.971823)
```

#### `srs`

Maoin a thugann air:class: spatialReference a bhaineann leis an gciseal seo:

```pycon
>>> print(layer.srs)
GEOGCS["GCS_WGS_1984",
    DATUM["WGS_1984",
        SPHEROID["WGS_1984",6378137,298.257223563]],
    PRIMEM["Greenwich",0],
    UNIT["Degree",0.017453292519943295]]
```

Mura bhfuil aon fhaisnéis tagartha spásúil ag an:class: Layer a bhaineann leis, cuirtear None ar ais.

#### `spatial_filter`

Maoin a d'fhéadfaí a úsáid chun scagaire spásúil a aisghabháil nó a shocrú don chiseal seo. Ní féidir scagaire spásúil a shocrú ach amháin le sampla: class: OgrGeometry, méid 4 tuipéil, nó `None`. Nuair a bheidh sé socraithe le rud éigin seachas None , ní thabharfar ach gnéithe a thrasnaíonn an scagaire ar ais agus iad ag athrú thar an gciseal:

```pycon
>>> 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
```

#### `get_fields()`

Modh a thugann liosta de luachanna réimse ar leith ar fáil do gach gné sa chiseal:

```pycon
>>> layer.get_fields("Name")
['Pueblo', 'Lawrence', 'Houston']
```

#### `get_geoms(geos=False)`

Modh a thugann liosta ar ais ina bhfuil geoiméadacht gach gné sa chiseal. Má tá an argóint roghnach `geos` socraithe go `True` ansin déantar na geoiméadrachtaí a thiontú go rudaí:class: ~django.contrib.gis.geos.geosgeometry. Seachas sin, cuirtear ar ais iad mar: class: ogrGeometry rudaí:

```pycon
>>> [pt.tuple for pt in layer.get_geoms()]
[(-104.609252, 38.255001), (-95.23506, 38.971823), (-95.363151, 29.763374)]
```

#### `test_capability(capability)`

Filleann boolean a thugann le fios an dtacaíonn an gciseal seo leis an gcumas a thugtar (sreang). I measc samplaí de theagáin chumais bailí tá: `'RandomRead'`, `SequentialWrite'`, ``` `RandomWrite'`, ``FastSpatialFilter' ```, ```FastFeatureCount'`, ``FastGetExtent'```, `CreateField'`, `Transactions`, Delete Feature', agus FastSetNextByIndex'.

### `Gnéithe`

#### `class Feature`

Fillteann `Feature` gné OGR. Ní chruthaíonn tú réad `Feature` go díreach riamh. Ina áit sin, aisghabhann tú iad ó réad a: class: Layer. Is éard atá i ngach gné geoiméadracht agus sraith réimsí ina bhfuil airíonna breise. Tá geoiméadracht réimse inrochtana tríd a mhaoin `geom`, a thugann ruda:class: ogrGeometry ar ais. Iompraíonn `Feature` cosúil le coimeádán caighdeánach Python dá réimsí, a thugann sé ar ais mar ruda:class: Field: is féidir leat rochtain a fháil ar réimse go díreach trína innéacs nó ainm, nó is féidir leat athrá thar réimsí gné, m.sh. i lúb for\`.

#### `geom`

Tugann sé an geoiméadracht don ghné seo ar ais, mar réad Ogrgeoiméadr\`:

```pycon
>>> city.geom.tuple
(-104.609252, 38.255001)
```

#### `get`

Modh a thugann luach an réimse tugtha ar ais (sonraithe de réir ainm) don ghné seo, **ní** réad fillte Réimse :

```pycon
>>> city.get("Population")
102121
```

#### `geom_type`

Tugann sé an cineál céimeadra don ghné seo ar ais, mar réad: class: ogrGeomType. Beidh sé seo mar an gcéanna do gach gné i gciseal ar leith agus tá sé coibhéiseach leis an maoin: attr: Layer.geom\_TYPE den réad :class: Layer as a tháinig an ghné.

#### `num_fields`

Tugann sé líon na réimsí sonraí a bhaineann leis an ngné ar ais. Beidh sé seo mar an gcéanna do gach gné i gciseal ar leith agus tá sé coibhéiseach leis an maoin: attr: Layer.num\_Fields den réad: Class: Layer as a tháinig an ghné.

#### `fields`

Tugann liosta ar ais d'ainmneacha na réimsí sonraí a bhaineann leis an ngné. Beidh sé seo mar an gcéanna do gach gné i gciseal ar leith agus tá sé coibhéiseach leis an maoin: attr: Layer.Fields den réad: Class: Layer as a tháinig an ghné.

#### `fid`

Tugann an t-aitheantas gné ar ais laistigh den chiseal:

```pycon
>>> city.fid
0
```

#### `layer_name`

Tugann ainm an: class: Layer as a tháinig an ghné ar ais. Beidh sé seo mar an gcéanna le haghaidh gach gné i gciseal ar leith:

```pycon
>>> city.layer_name
'cities'
```

#### `index`

Modh a thugann innéacs an ainm réimse tugtha ar ais. Beidh sé seo mar an gcéanna do gach gné i gciseal ar leith:

```pycon
>>> city.index("Population")
1
```

### `Réimse`

#### `class Field`

#### `name`

Tugann ainm an réimse seo ar ais:

```pycon
>>> city["Name"].name
'Name'
```

#### `type`

Tugann sé an cineál OGR den réimse seo ar ais, mar shláimhir. Déanann an foclóir FIELD\_CLASSES\` na luachanna seo a léarscáil ar fho-aicmí `Field`:

```pycon
>>> city["Density"].type
2
```

#### `type_name`

Tugann teaghrán ar ais le hainm an chineál sonraí an réimse seo:

```pycon
>>> city["Name"].type_name
'String'
```

#### `value`

Tugann luach an réimse seo ar ais. Tugann an rang `Field` féin an luach ar ais mar shreang, ach filleann gach fo-aicme an luach sa fhoirm is oiriúnaí:

```pycon
>>> city["Population"].value
102121
```

#### `width`

Tugann sé leithead an réimse seo ar ais:

```pycon
>>> city["Name"].width
80
```

#### `precision`

Tugann cruinneas uimhriúil an réimse seo ar ais. Tá sé seo gan brí (agus socraithe go nialas) do réimsí neamh-uimhriúla:

```pycon
>>> city["Density"].precision
15
```

#### `as_double()`

Tugann luach an réimse ar ais mar dhúbailte (snámhphointe):

```pycon
>>> city["Density"].as_double()
874.7
```

#### `as_int()`

Tugann luach an réimse ar ais mar shláimhir:

```pycon
>>> city["Population"].as_int()
102121
```

#### `as_string()`

Tugann luach an réimse ar ais mar shreang:

```pycon
>>> city["Name"].as_string()
'Pueblo'
```

#### `as_datetime()`

Tugann luach an réimse ar ais mar thiúpla de chomhpháirteanna dáta agus ama:

```pycon
>>> 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))
```

### `Tiomána`

#### `class Driver(dr_input)`

Úsáidtear an rang `Tiomána` go hinmheánach chun tiománaí OGR:Class: DataSource a fhilleadh.

#### `driver_count`

Filleann líon na dtiománaithe veicteora OGR atá cláraithe faoi láthair.

## Geoiméadrachtaí OGR

### Geoiméadracht \`\`

[`OGRGeometry`](#django.contrib.gis.gdal.OGRGeometry) objects share similar functionality with
[`GEOSGeometry`](/ga/5.2/ref/contrib/gis/geos/#django.contrib.gis.geos.GEOSGeometry) objects and are thin wrappers
around OGR's internal geometry representation. Thus, they allow for more
efficient access to data when using [`DataSource`](#django.contrib.gis.gdal.DataSource). Unlike its GEOS
counterpart, [`OGRGeometry`](#django.contrib.gis.gdal.OGRGeometry) supports spatial reference systems and
coordinate transformation:

```pycon
>>> from django.contrib.gis.gdal import OGRGeometry
>>> polygon = OGRGeometry("POLYGON((0 0, 5 0, 5 5, 0 5))")
```

#### `class OGRGeometry(geom_input, srs=None)`

Is fillteán é an réad seo don rang Geoiméadracht OGR \`\_\_. Déantar na rudaí seo a thionscnamh go díreach ón bparaiméadar \`\`geom\_input\` a thugtar, ar d'fhéadfadh a bheith ina sreang ina bhfuil WKT, HEX, GeoJSON, maolán \`\`ina bhfuil sonraí WKB, nó ruda:class: \`ogrGeomType. Cuirtear na rudaí seo ar ais freisin ón tréith: :class: Feature.geom, agus sonraí veicteora á léamh ó:class: Layer (atá ina chuid de a:class: DataSource).

#### `classmethod from_gml(gml_string)`

Tógann sé an:aicme: OgGeoiméadrach ón sreang GML tugtha.

#### `classmethod from_bbox(bbox)`

Tógann a: aicme: Polygon ón mbosca teorainn a thugtar (4-tuple).

#### `__len__()`

Tugann sé ar ais líon na bpointí in a:aicme: Linestring, líon na bhfáinní in a:aicme: Polygon, nó líon na ngeoiméadrachtaí in a:class: GeometryCollection. Ní bhaineann le cineálacha geoiméadrachta eile.

#### `__iter__()`

Athraigh thar na pointí in a: aicme: Linestring, na fáinní i a: aicme: Polygon, nó na geoiméadrachtaí in a:class: GeometryCollection. Ní bhaineann le cineálacha geoiméadrachta eile.

#### `__getitem__()`

Tugann an pointe ar ais ag an innéacs sonraithe le haghaidh a: aicme: LíneString, an fáinne istigh ag an innéacs sonraithe do a:class: Polygon, nó an geoiméadra ag an innéacs sonraithe in a:class: GeometryCollection. Ní bhaineann le cineálacha geoiméadrachta eile.

#### `dimension`

Tugann sé líon toisí comhordaithe an ghéiméadrachta ar ais, ie 0 do phointí, 1 do línte, agus mar sin de:

```pycon
>>> polygon.dimension
2
```

#### `coord_dim`

Filleann sé gné comhordaithe an ghéiméadracht seo. Mar shampla, bheadh an luach 2 le haghaidh geoiméadraí déthoiseach.

> **Deprecated since Django 5.1**
>
> Deprecated since version 5.1: Tá an socraithe `coord_dim` a dhíchur. Úsáid: Meth: .set\_3d ina ionad.

#### `is_3d`

> **New in Django 5.1**

Boolean a léiríonn an bhfuil comhordanáidí Z ag an gcéimseadra seo.

#### `set_3d(value)`

> **New in Django 5.1**

Modh a chuireann nó a bhaineann an toise comhordaithe Z.

```pycon
>>> p = OGRGeometry("POINT (1 2 3)")
>>> p.is_3d
True
>>> p.set_3d(False)
>>> p.wkt
"POINT (1 2)"
```

#### `is_measured`

> **New in Django 5.1**

Boolean a léiríonn an bhfuil comhordanáidí M ag an gcéimseadra seo.

#### `set_measured(value)`

> **New in Django 5.1**

Modh chun an toise comhordaithe M a chur leis nó a bhaint.

```pycon
>>> p = OGRGeometry("POINT (1 2)")
>>> p.is_measured
False
>>> p.set_measured(True)
>>> p.wkt
"POINT M (1 2 0)"
```

#### `geom_count`

Tugann sé líon na n-eilimintí sa geoiméadra seo ar ais:

```pycon
>>> polygon.geom_count
1
```

#### `has_curve`

> **New in Django 5.2**

A boolean indicating if this geometry is or contains a curve geometry.

#### `get_linear_geometry()`

> **New in Django 5.2**

Returns a linear version of the geometry. If no conversion can be made, the
original geometry is returned.

#### `get_curve_geometry()`

> **New in Django 5.2**

Returns a curved version of the geometry. If no conversion can be made, the
original geometry is returned.

#### `point_count`

Tugann sé líon na bpointí a úsáidtear chun cur síos a dhéanamh ar an geoiméad

```pycon
>>> polygon.point_count
4
```

#### `num_points`

Alias le haghaidh: attr: point\_count.

#### `num_coords`

Alias le haghaidh: attr: point\_count.

#### `geom_type`

Tugann sé an cineál céimeadra seo ar ais, mar réad: class: ogrGeomType.

#### `geom_name`

Tugann ainm an chineál céiméadra seo ar ais:

```pycon
>>> polygon.geom_name
'POLYGON'
```

#### `area`

Tugann sé limistéar an geoiméadra seo ar ais, nó 0 le haghaidh geoiméadraí nach bhfuil limistéar ann:

```pycon
>>> polygon.area
25.0
```

#### `envelope`

Tugann clúdach an ghéiméadracht seo ar ais, mar réad: aicme: Envelop.

#### `extent`

Tugann clúdach an ghéiméadracht seo ar ais mar 4-tuple, in ionad mar réad an:class: Envelope:

```pycon
>>> point.extent
(0.0, 0.0, 5.0, 5.0)
```

#### `srs`

Rialaíonn an maoin seo an tagairt spásúil don ghéiméadracht seo, nó `None` mura bhfuil aon chóras tagartha spásúil sannta dó. Má shanntar é, tugann rochtain a fháil ar an maoin seo a: aicme: SpatialReference réad. Féadfar é a shocrú le réad eile: class: SpatialReference, nó aon ionchur a ghlacann le: class: SpatialReference. Sampla:

```pycon
>>> city.geom.srs.name
'GCS_WGS_1984'
```

#### `srid`

Tugann sé nó socraíonn sé an t-aitheantóir tagartha spásúil a fhreagraíonn do:class: SpatialReference den ghéiméadracht seo. Tugann sé ar ais `None` mura bhfuil aon fhaisnéis tagartha spásúil a bhaineann leis an gcéiméadra seo, nó mura féidir SRID a chinneadh.

#### `geos`

Tuairisceáin a:class: ~django.contrib.gis.geos.geosgeometry réad a fhreagraíonn don ghéiméadracht seo.

#### `gml`

Tugann sé léiriú teaghrán den ghéiméadracht seo ar ais i bhformáid GML:

```pycon
>>> OGRGeometry("POINT(1 2)").gml
'<gml:Point><gml:coordinates>1,2</gml:coordinates></gml:Point>'
```

#### `hex`

Tugann sé léiriú teaghrán den ghéiméadracht seo ar ais i bhformáid HEX WKB:

```pycon
>>> OGRGeometry("POINT(1 2)").hex
'0101000000000000000000F03F0000000000000040'
```

#### `json`

Filleann sé léiriú teaghrán den ghéimseata seo i bhformáid JSON:

```pycon
>>> OGRGeometry("POINT(1 2)").json
'{ "type": "Point", "coordinates": [ 1.000000, 2.000000 ] }'
```

#### `kml`

Filleann sé léiriú teaghrán den ghéiméadracht seo i bhformáid KML.

#### `wkb_size`

Tugann sé ar ais méid an maoláin WKB a theastaíonn chun léiriú WKB a shealbhú den ghéiméadracht seo:

```pycon
>>> OGRGeometry("POINT(1 2)").wkb_size
21
```

#### `wkb`

Tugann sé “maolán” ar ais ina bhfuil léiriú WKB den ghéiméadracht seo.

#### `wkt`

Filleann sé léiriú teaghrán den ghéiméadracht seo i bhformáid WKT.

#### `ewkt`

Tugann ionadaíocht EWKT an geoiméadra seo ar ais.

#### `clone()`

Filleann clón nua:class: ogrGeometry den réad geoiméadrach seo.

#### `close_rings()`

Má tá aon fáinní laistigh den ghéiméadracht seo nár dúnadh, déanfaidh an gnáthamh seo amhlaidh tríd an bpointe tosaigh a chur leis an deireadh:

```pycon
>>> triangle = OGRGeometry("LINEARRING (0 0,0 1,1 0)")
>>> triangle.close_rings()
>>> triangle.wkt
'LINEARRING (0 0,0 1,1 0,0 0)'
```

#### `transform(coord_trans, clone=False)`

Athraíonn sé an geoiméadracht seo go córas tagartha spásúil difriúil. Féadfaidh sé a: aicme: CoordTransform réad, a:class: SpatialReference a thógáil, nó aon ionchur eile a nglactar leis ar:class: SpatialReference (lena n-áirítear tagairt spásúil WKT agus teaghráin PROJ, nó SRID sláimhir).

De réir réamhshocraithe ní thugtar aon rud ar ais agus déantar an geoiméadracht a athrú go Mar sin féin, má tá an eochairfhocal `clone` socraithe go `True` ansin cuirtear clón claochlaithe den ghéimseadracht seo ar ais ina ionad.

#### `intersects(other)`

Tugann sé ar ais `True` má thrasnaíonn an geoiméadacht seo an ceann eile, ar shlí eile filleann sé `False`.

#### `equals(other)`

Tugann sé ar ais `True` má tá an geoiméadacht seo coibhéiseach leis an gceann eile, seachas sin filleann sé `False`.

#### `disjoint(other)`

Tugann sé ar ais `True` má tá an geoiméadacht seo dícheangailte go spásúil leis an gceann eile (i.e. ní thrasnaíonn sé), ar shlí eile filleann sé `False`.

#### `touches(other)`

Tugann sé `True` má chuireann an geoiméadacht seo i dteagmháil leis an gceann eile, seachas sin filleann sé `False`.

#### `crosses(other)`

Tugann sé ar ais `True` má thrasnaíonn an geoiméadacht seo an ceann eile, ar shlí eile filleann sé `False`.

#### `within(other)`

Tugann sé `True` má tá an geoiméadacht seo laistigh den chéad cheann eile, seachas sin filleann sé `False`.

#### `contains(other)`

Tugann sé `True` má tá an ceann eile sa geoiméadacht seo, ar shlí eile filleann sé `False`.

#### `overlaps(other)`

Tugann sé ar ais `True` má fhorluíonn an geoiméadacht seo an ceann eile, ar shlí eile filleann sé `False`.

#### `boundary()`

Teorainn an ghéiméadracht seo, mar réad nua:class: OgrGeometry.

#### `convex_hull`

An polagán doimhneach is lú ina bhfuil an geoiméadacht seo, mar réad nua:class: ogrGeometry.

#### `difference()`

Filleann sé an réigiún ina bhfuil difríocht an geoiméadra seo agus an ceann eile, mar réad nua:class: ogrGeometry.

#### `intersection()`

Tugann sé ar ais an réigiún ina bhfuil trasna an ghéiméadracht seo agus an ceann eile, mar réad nua:class: ogrGeometry.

#### `sym_difference()`

Tugann sé ar ais an réigiún ina bhfuil difríocht shioméadrach an ghéiméadracht seo agus an ceann eile, mar réad nua:class: ogrGeometry.

#### `union()`

Tugann sé ar ais an réigiún ina bhfuil aontas an geoiméadair seo agus an ceann eile, mar réad nua:class: ogrGeometry.

#### `centroid`

Tuairisceáin a: aicme: Point a léiríonn lárnach an geoiméadair seo.

> **Changed in Django 5.1**
>
> Cuireadh `centroid` chun cinn ó a: aicme: .Polygon ach tréith a bheith ar fáil ar gach cineál geoiméadrachta.

#### `tuple`

Tugann comhordanáidí geoiméadracht pointe ar ais mar thiúpla, comhordanáidí céiméadra líne mar thiúpla de thiúpla, agus mar sin de:

```pycon
>>> OGRGeometry("POINT (1 2)").tuple
(1.0, 2.0)
>>> OGRGeometry("LINESTRING (1 2,3 4)").tuple
((1.0, 2.0), (3.0, 4.0))
```

#### `coords`

Ainm le haghaidh: attr: tuple.

#### `class Point`

#### `x`

Tugann comhordú X an phointe seo ar ais:

```pycon
>>> OGRGeometry("POINT (1 2)").x
1.0
```

#### `y`

Tugann comhordú Y an phointe seo ar ais:

```pycon
>>> OGRGeometry("POINT (1 2)").y
2.0
```

#### `z`

Tugann comhordú Z an phointe seo ar ais, nó `None` mura bhfuil comhordú Z ag an bpointe:

```pycon
>>> OGRGeometry("POINT (1 2 3)").z
3.0
```

#### `m`

> **New in Django 5.1**

Tugann comhordú M an phointe seo ar ais, nó `None` mura bhfuil comhordú M ag an bPointe:

```pycon
>>> OGRGeometry("POINT ZM (1 2 3 4)").m
4.0
```

#### `class LineString`

#### `x`

Tugann liosta de chomhordanáidí X ar ais sa líne seo:

```pycon
>>> OGRGeometry("LINESTRING (1 2,3 4)").x
[1.0, 3.0]
```

#### `y`

Tugann liosta de chomhordanáidí Y ar ais sa líne seo:

```pycon
>>> OGRGeometry("LINESTRING (1 2,3 4)").y
[2.0, 4.0]
```

#### `z`

Tugann liosta de chomhordanáidí Z ar ais sa líne seo, nó None mura bhfuil comhordanáidí Z ag an líne:

```pycon
>>> OGRGeometry("LINESTRING (1 2 3,4 5 6)").z
[3.0, 6.0]
```

#### `m`

> **New in Django 5.1**

Tugann liosta de chomhordanáidí M sa líne seo nó `None` mura bhfuil comhordanáidí M ag an líne:

```pycon
>>> OGRGeometry("LINESTRING(0 1 2 10, 1 2 3 11, 2 3 4 12)").m
[10.0, 11.0, 12.0]
```

#### `class Polygon`

#### `shell`

Tugann an bhlaosc nó an fáinne taobh amuigh den pholagán seo ar ais, mar gheoiméadra `Línear`.

#### `exterior_ring`

Ainm le haghaidh: attr: shell.

#### `class GeometryCollection`

#### `add(geom)`

Cuireann sé geoiméadra leis an mbailiúchán geoiméad Ní bhaineann le cineálacha geoiméadrachta eile.

### `OgrGeomType`

#### `class OGRGeomType(type_input)`

Ceadaíonn an rang seo cineál geoiméadrachta OGR a léiriú ar aon cheann de bhealaí éagsúla:

```pycon
>>> 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
```

#### `name`

Tugann foirm teaghrán gearr-láimhe de chineál Geoimseachta OGR ar ais:

```pycon
>>> gt1.name
'Polygon'
```

#### `num`

Tugann an uimhir a fhreagraíonn don chineál geoiméadachta OGR ar ais:

```pycon
>>> gt1.num
3
```

#### `django`

Filleann sé cineál réimse Django (fo-aicme de GeometryField) le húsáid chun an cineál OGR seo a stóráil, nó None mura bhfuil aon chineál Django oiriúnach ann:

```pycon
>>> gt1.django
'PolygonField'
```

### `` `Imbléad ``

#### `class Envelope(*args)`

Léiríonn sé struchtúr Clúdach OGR ina bhfuil na comhordanáidí X, Y íosta agus uasta do bhosca teorainn dronuilleogach. Tá ainmniú na n-athróg comhoiriúnach le struchtúr Clúdach OGR C.

#### `min_x`

Luach an chomhordaithe X íosta.

#### `min_y`

Luach an chomhordaithe X uasta.

#### `max_x`

Luach an chomhordaithe íosta Y.

#### `max_y`

Luach an chomhordaithe uasta Y.

#### `ur`

An comhordú uachtarach ar dheis, mar tuple.

#### `ll`

An comhordú ar chlé íochtarach, mar chlúdach.

#### `tuple`

Tuple a léiríonn an clúdach.

#### `wkt`

Sreang a léiríonn an clúdach seo mar pholgún i bhformáid WKT.

#### `expand_to_include(*args)`

## Rudaí Córais Comhordaithe

### `Tagairt spáis`

#### `class SpatialReference(srs_input)`

Cuirtear rudaí tagartha spásúla a thionscnamh ar an srs\_input\` a thugtar, a d'fhéadfadh a bheith ar cheann de na nithe seo a leanas:

- Téacs Aitheanta OGC (WKT) (sreang)
- Cód EPSG (sláimhir nó sreang)
- Proj teaghrán
- Teagán gearrthréimhe do chaighdeáin aitheanta (`'WGS84'`, ```WGS72'`, ``NAD27'`, ``NAD83'```)

Sampla:

```pycon
>>> 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
```

#### `__getitem__(target)`

Tugann sé luach an nód tréith teaghrán a thugtar, None mura bhfuil an nód ann. Is féidir le tuple a ghlacadh mar pharaiméadar freisin, (sprioc, leanbh), áit a bhfuil an leanbh innéacs an tréith sa WKT. Mar shampla:

```pycon
>>> 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
```

#### `attr_value(target, index=0)`

An luach tréithe don spriocnód tugtha (m.sh. PROJCS'). Sonraíonn an eochairfhocal innéacs den nód linbh le filleadh.

#### `auth_name(target)`

Tugann ainm an údaráis ar ais don sprioc-nód sreangán a thugtar.

#### `auth_code(target)`

Tugann an cód údaráis ar ais don sprioc-nód sreangán a thugtar.

#### `clone()`

Tugann clón den réad tagartha spásúil seo ar ais.

#### `identify_epsg()`

Déanann an modh seo iniúchadh ar WKT an `SpatialReference` seo agus cuirfidh sé nóid údaráis EPSG leis nuair a bhíonn aitheantóir EPSG infheidhme.

#### `from_esri()`

Déanann an Tagairt spásúil seo a mhorgáil ó fhormáid ESRI go EPSG

#### `to_esri()`

Morphaíonn an spásúil seoTagairt d'fhormáid ESRI.

#### `validate()`

Seiceálacha chun a fháil amach an bhfuil an tagairt spásúil a thugtar bailí, mura n-ardófar eisceacht.

#### `import_epsg(epsg)`

Tagairt spásúil a iompórtáil ó chód EPSG.

#### `import_proj(proj)`

Tagairt spásúil a iompórtáil ó sreang PROJ.

#### `import_user_input(user_input)`

#### `import_wkt(wkt)`

Tagairt spásúil a iompórtáil ó WKT.

#### `import_xml(xml)`

Tagairt spásúil a iompórtáil ó XML.

#### `name`

Tugann ainm an Tagartha Spásúil seo ar ais.

#### `srid`

Tugann an SRID d'údarás barrleibhéil ar ais, nó `None` mura bhfuil sainmhínithe.

#### `linear_name`

Tugann ainm na n-aonad líneach ar ais.

#### `linear_units`

Tugann luach na n-aonad líneach ar ais.

#### `angular_name`

Tugann ainm na n-aonad uilleach ar ais.”

#### `angular_units`

Tugann luach na n-aonad uilleach ar ais.

#### `units`

Filleann sé 2-tuple de luach na haonaid agus ainm na n-aonaid agus cinneoidh sé go huathoibríoch an gcuirfear na haonaid líneacha nó uilleacha ar ais.

#### `ellipsoid`

Filleann sé tuple de na paraiméadair ellipsoid don tagairt spásúil seo: (ais semimajor, ais semiminor, agus comhréiteach inbhéartha).

#### `semi_major`

Filleann ais leathmhór an ellipsoid don tagairt spásúil seo.

#### `semi_minor`

Filleann ais leathbheag an ellipsoid don tagairt spásúil seo.

#### `inverse_flattening`

Tugann sé comhréiteach inbhéartha an ellipsoid ar ais don tagairt spásúil seo.

#### `geographic`

Tugann sé ar ais `True` má tá an tagairt spásúil seo geografach (is é GEOGCS fréimhnód).

#### `local`

Tugann sé ar ais `True` má tá an tagairt spásúil seo áitiúil (is é LOCAL\_CS\` fréimhe ná `LOCAL_CS`).

#### `projected`

Tugann sé ar ais `True` más córas comhordaithe réamh-mheasta é an tagairt spásúil seo (is é PROJCS nód fréimhe).

#### `wkt`

Tugann sé ionadaíocht WKT ar an tagairt spásúil seo ar ais.

#### `pretty_wkt`

Tugann sé ionadaíocht 'deas' an WKT ar ais.

#### `proj`

Tugann sé ionadaíocht PROJ ar ais don tagairt spásúil seo.

#### `proj4`

Alias le haghaidh: attr: spatialReference.proj.

#### `xml`

Tugann sé ionadaíocht XML an tagartha spásúil seo ar ais.

### `CoordTransform`

#### `class CoordTransform(source, target)`

Léiríonn sé athrú córais chomhordaithe. Tosaítear é le dhá: aicme: SpatialReference, a léiríonn na córais comhordaithe foinse agus spriocchórais, faoi seach. Ba chóir na rudaí seo a úsáid agus an claochlú comhordaithe céanna á ndéanamh arís agus arís eile ar geoiméadraí

```pycon
>>> ct = CoordTransform(SpatialReference("WGS84"), SpatialReference("NAD83"))
>>> for feat in layer:
...     geom = feat.geom  # getting clone of feature geometry
...     geom.transform(ct)  # transforming
...
```

## Cuspóirí Sonraí Raster

### `Gdalraster`

[`GDALRaster`](#django.contrib.gis.gdal.GDALRaster) is a wrapper for the GDAL raster source object that
supports reading data from a variety of GDAL-supported geospatial file
formats and data sources using a consistent interface.  Each
data source is represented by a [`GDALRaster`](#django.contrib.gis.gdal.GDALRaster) object which contains
one or more layers of data named bands.  Each band, represented by a
[`GDALBand`](#django.contrib.gis.gdal.GDALBand) object, contains georeferenced image data. For example, an RGB
image is represented as three bands: one for red, one for green, and one for
blue.

> **Note**
>
> Maidir le sonraí raster níl aon difríocht idir sampla raster agus a fhoinse sonraí. Murab ionann agus do na rudaí Coiméadrachta, is foinse sonraí iad rudaí :class: GdalRaster i gcónaí. Is féidir rastróirí sealadacha a chur i gcuimhne ag baint úsáide as an tiománaí comhfhreagrach, ach beidh siad den rang céanna le foinsí raster comhbhunaithe.

#### `class GDALRaster(ds_input, write=False)`

Glacann an tógálaí le haghaidh `Gdalraster` dhá pharaiméadar. Sainmhíníonn an chéad pharaiméadar an fhoinse raster, agus sainmhíníonn an dara paraiméadar an gcaithfear raster a oscailt i mód scríbhneoireachta. Maidir le rasters nua-chruthaithe, déantar neamhaird ar an dara paraiméadar agus cruthaítear an raster nua i gcónaí i mód scríbhneoireachta.

Is féidir leis an gcéad pharaiméadar trí fhoirm a ghlacadh: teaghrán nó:class: ~pathlib.path a léiríonn cosán comhaid (córas comhaid nó córas comhaid fíorúil GDAL), foclóir le luachanna a shainníonn raster nua, nó réad beáit a léiríonn comhad raster.

Más cosán comhad é an t-ionchur, osclaítear an raster as sin. Más sonraí amh i bhfoclóir iad an t-ionchur, teastaíonn na paraiméadair ``leithead`, `airde``, agus `srid`. Más réad bytes é an t-ionchur, osclófar é ag baint úsáide as córas comhaid fíorúil GDAL.

Le haghaidh tuairisc mhionsonraithe ar conas rasters a chruthú ag baint úsáide as ionchur foclóra, féach:ref: gdal-raster-ds-input. Le haghaidh tuairisc mhionsonraithe ar conas rasters a chruthú sa chóras comhaid fíorúil, féach:ref: gdal-raster-vsimem.

Taispeánann an sampla seo a leanas conas is féidir rasters a chruthú ó fhoinsí ionchuir éagsúla (ag baint úsáide as na sonraí samplacha ó na tástálacha GeoDjango; féach freisin roinn:ref: gdal\_sample\_data).

```pycon
>>> 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'
```

#### `name`

Ainm na foinse atá coibhéiseach leis an gcosán comhaid ionchuir nó an t-ainm a chuirtear ar fáil nuair a chuirtear isteach.

```pycon
>>> GDALRaster({"width": 10, "height": 10, "name": "myraster", "srid": 4326}).name
'myraster'
```

#### `driver`

Ainm an tiománaí GDAL a úsáidtear chun an comhad ionchuir a láimhseáil. Maidir le `Gdalraster`s a cruthaíodh ó chomhad, braithtear an cineál tiománaí go huathoibríoch. Is raster in-chuimhne é cruthú rasters ón tús de réir réamhshocraithe (`MEM'`), ach is féidir é a athrú de réir mar is gá. Mar shampla, bain úsáid as `GTIFF` le haghaidh comhad `GeoTiff`. Le haghaidh liosta de chineálacha comhaid, féach freisin an liosta .

Cruthaítear raster in-chuimhne tríd an sampla seo a leanas:

```pycon
>>> GDALRaster({"width": 10, "height": 10, "srid": 4326}).driver.name
'MEM'
```

Cruthaítear raster GeoTIFF bunaithe ar chomhad tríd an sampla seo a leanas:

```pycon
>>> 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'
```

#### `width`

Leithead na foinse i bpicteilíní (X-ais).

```pycon
>>> GDALRaster({"width": 10, "height": 20, "srid": 4326}).width
10
```

#### `height`

Airde na foinse i bpicteilíní (ais Y).

```pycon
>>> GDALRaster({"width": 10, "height": 20, "srid": 4326}).height
20
```

#### `srs`

Córas tagartha spásúil an raster, mar shampla a:class: SpatialReference. Is féidir an SRS a athrú tríd é a shocrú go dtí: class: SpatialReference eile nó aon ionchur a ghlacann an tógálaí:class: SpatialReference a sholáthar.

```pycon
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.srs.srid
4326
>>> rst.srs = 3086
>>> rst.srs.srid
3086
```

#### `srid`

Aitheantóir an Chórais Tagartha Spásúil (SRID) an raster. Is aicearra í an maoin seo chun an SRID a fháil nó a shocrú tríd an tréith: attr: srs.

```pycon
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.srid
4326
>>> rst.srid = 3086
>>> rst.srid
3086
>>> rst.srs.srid  # This is equivalent
3086
```

#### `geotransform`

Úsáidtear an maitrís claochlaithe affine chun an fhoinse a ghearradh, mar thiúpla de sé chomhéifeacht a mhapálann comhordanáidí picteilín/líne isteach i spás georeferencithe ag baint úsáide as an gcaidreamh seo a leanas:

```
Xgeo = GT(0) + Xpixel * GT(1) + Yline * GT(2)
Ygeo = GT(3) + Xpixel * GT(4) + Yline * GT(5)
```

Is féidir na luachanna céanna a aisghabháil trí rochtain a fháil ar airíonna: attr: origin (innéacsanna 0 agus 3), :attr: scale (innéacsanna 1 agus 5) agus:attr: sque (innéacsanna 2 agus 4).

Is é an réamhshocrú `[0.0, 1.0, 0.0, 0.0, 0.0, -1.0]`.

```pycon
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.geotransform
[0.0, 1.0, 0.0, 0.0, 0.0, -1.0]
```

#### `origin`

Comhordanáidí bunús barr ar chlé an raster i gcóras tagartha spásúil na foinse, mar réad pointe le baill `x` agus `y`.

```pycon
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.origin
[0.0, 0.0]
>>> rst.origin.x = 1
>>> rst.origin
[1.0, 0.0]
```

#### `scale`

Leithead agus airde picteilín a úsáidtear chun an raster a gheoreferenciú, mar réad pointe le baill `x` agus `y`. Féach: attr: geotransform le haghaidh tuilleadh faisnéise.

```pycon
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.scale
[1.0, -1.0]
>>> rst.scale.x = 2
>>> rst.scale
[2.0, -1.0]
```

#### `skew`

Comhéifeachtaí sceitheacha a úsáidtear chun an raster a ghearradh, mar réad pointe le baill `x` agus `y`. I gcás íomhánna ó thuaidh suas, is iad na comhéifeachtaí seo `0`.

```pycon
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.skew
[0.0, 0.0]
>>> rst.skew.x = 3
>>> rst.skew
[3.0, 0.0]
```

#### `extent`

Méid (luachanna teorann) na foinse raster, mar 4-tupól `(xmin, ymin, xmax, ymax)` i gcóras tagartha spásúil na foinse.

```pycon
>>> 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)
```

#### `bands`

Liosta de na bandaí go léir den fhoinse, mar shama:class: GdalBand cásanna.

```pycon
>>> 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)
```

#### `warp(ds_input, resampling='NearestNeighbour', max_error=0.0)`

Tugann sé leagan chearrtha den raster seo ar ais.

Is féidir na paraiméadair warping a shonrú tríd an argóint ds\_input\`. Tá úsáid `ds_input` cosúil leis an argóint chomhfhreagrach de thógálaí an aicme. Is foclóir é le tréithe an sprioc-raster. Is iad príomhluachanna foclóra ceadaithe ná leithead, airde, SRID, bunús, scála, scála, cineál sonraí, tiománaí, agus ainm (ainm comhaid).

De réir réamhshocraithe, coinníonn na feidhmeanna warp an chuid is mó de na paraiméadair cothrom le luachanna an raster foinse bunaidh, mar sin ní gá ach paraiméadair ba chóir a athrú a shonrú. Tabhair faoi deara go n-áirítear leis seo an tiománaí, mar sin do rasters comhadbhunaithe cruthóidh an fheidhm warp raster nua ar dhiosca.

Is é an t-aon pharaiméadar atá socraithe ar bhealach difriúil ón raster foinse ná an t-ainm. Is é luach réamhshocraithe an ainm raster ainm an raster foinse atá curtha leis `'_copy'+source_driver_name`. Maidir le rasters comhadbhunaithe moltar cosán comhaid an sprioc-raster a sholáthar.

Is féidir an algartam athshamplála a úsáidtear le haghaidh warping a shonrú leis an argóint `athshampling`. Is é an réamhshocraithe `Comharsanacht is gaire`, agus is iad na luachanna ceadaithe eile `Bilinear`, Cubic\`, Cubicspline\`, Lanczos\`, Meán\`, agus `Mod`.

Is féidir an argóint max\_error\` a úsáid chun an earráid uasta a thomhaistear i bpicteilíní ionchuir a cheadaítear chun an claochlú a chomhshonrú a shonrú. Is é an réamhshocrú 0.0 le haghaidh ríomhanna cruinne.

Maidir le húsáideoirí atá eolach ar `GDAL`, tá feidhmiúlacht chosúil ag an bhfeidhm seo leis an bhfóntais líne ordaithe `gdalwarp`.

Mar shampla, is féidir an fheidhm warp a úsáid chun raster a chomhiomlánú go dúbailte a scála picteilín bunaidh:

```pycon
>>> 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)
```

#### `transform(srs, driver=None, name=None, resampling='NearestNeighbour', max_error=0.0)`

Déanann an raster seo a athrú go córas tagartha spásúil difriúil (srs\`), a d'fhéadfadh a bheith ina réad a:class: SpatialReference, nó aon ionchur eile a nglactar leis ar:class: SpatialReference (lena n-áirítear tagairt spásúil WKT agus PROJ, nó SRID sláimhir).

Ríomhann sé teorainneacha agus scála an raster reatha sa chóras tagartha spásúil nua agus cuireann sé an raster ag baint úsáide as an bhfeidhm: attr: ~gdalraster.warp.

De réir réamhshocraithe, úsáidtear tiománaí an raster foinse agus is é ainm an raster an t-ainm bunaidh atá curtha leis `'_copy'+source_driver_name`. Is féidir tiománaí nó ainm difriúil a shonrú leis na hargóintí `tiomána` agus ainm .

Is é an algartam athshamplú réamhshocraithe ```NearestNeighbour' ach is féidir é a athrú ag baint úsáide as an argóint ``athshampling```. Is é 0.0 an earráid réamhshocraithe a cheadaítear le haghaidh athshamplú agus is féidir é a athrú ag baint úsáide as an argóint `max_error`. Téigh i gcomhairle le cáipéisíocht: attr: ~gdalraster.warp le haghaidh mionsonraí faoi na hargóintí sin.

```pycon
>>> 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]
```

#### `info`

Tugann teaghrán ar ais le achoimre ar an raster. Tá sé seo comhionann leis an bhfóntais líne ordaithe .

#### `metadata`

Meiteashonraí an raster seo, a léirítear mar fhoclóir neadaithe. Is é an eochair chéad leibhéil an fearainn meiteashonraí. Tá ainmneacha agus luachanna na míreanna meiteashonraí ó gach fearann sa dara leibhéal.

Chun mír meiteashonraí a shocrú nó a nuashonrú, cuir an mír meiteashonraí comhfhreagrach ar an modh ag baint úsáide as an struchtúr neadaithe Ní dhéantar ach eochracha atá sa bhfoclóir sonraithe a nuashonrú; fanann an chuid eile de na meiteashonraí gan athrú.

Chun mír meiteashonraí a bhaint, bain úsáid as `None` mar an luach meiteashonraí.

```pycon
>>> 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'}}
```

#### `vsi_buffer`

Léiriú `bytes` den raster seo. Tugann sé “None” ar ais do rastróirí nach stóráiltear i gcóras comhaid fíorúil GDAL.

#### `is_vsi_based`

Boolean a léiríonn an bhfuil an raster seo stóráilte i gcóras comhaid fíorúil GDAL.

### `Gdalband`

#### `class GDALBand`

Ní chruthaítear cásanna `GdalBand` go sainráite, ach a fhaightear ó a: class: GdalRaster réad, trínaí:attr: ~gdalraster.bands tréith. Tá luachanna picteilín iarbhír an raster sna GDALBands.

#### `description`

Ainm nó cur síos ar an mbanna, más ann.

#### `width`

Leithead an bhanda i bpicteilíní (X-ais).

#### `height`

Airde an bhanda i bpicteilíní (ais Y).

#### `pixel_count`

An líon iomlán na bpicteilíní sa bhanda seo. Tá sé comhionann le leithead\* airde .

#### `statistics(refresh=False, approximate=False)`

Ríomh staitisticí ar luachanna picteilín an bhanda seo. Is é an luach tuairisceáin ná tiúpla leis an struchtúr seo a leanas: `(íosta, uasmhéid, meán, diall caighdeánach)`.

Má shocraítear an argóint ```thart ``True```, féadfar na staitisticí a ríomh bunaithe ar léargas nó ar fho-thacar tíleanna íomhá.

Má shocraítear an argóint ```refresh ``go `True```, ríomhfar na staitisticí ó na sonraí go díreach, agus déanfar an taisce a nuashonrú leis an toradh.

Má aimsítear luach taisce leanúnach, cuirtear an luach sin ar ais. Maidir le formáidí raster a úsáideann seirbhísí Meiteashonraí Cúnta Marthanacha (PAM), d'fhéadfadh na staitisticí a stóráil i gcomhad cúnta. I gcásanna áirithe d'fhéadfadh an meiteashonraí seo a bheith as comhshoncronú leis na luachanna picteilín nó go gcuirfí faoi deara luachanna ó ghlao roimhe seo a thabhairt ar ais nach léiríonn luach na hargóintí thart . I gcásanna den sórt sin, bain úsáid as an argóint refresh chun luachanna nuashonraithe a fháil agus iad a stóráil sa taisce.

Maidir le bandaí folmha (áit nach “aon sonraí” iad na luachanna picteilín go léir), cuirtear gach staitisticí ar ais mar None .

Is féidir na staitisticí a aisghabháil go díreach freisin trí rochtain a fháil ar airíonna: attr: min, :attr: max, :attr: mean, agus:attr: std.

#### `min`

Luach picteilín íosta an bhanda (gan an luach “gan sonraí” a áireamh).

#### `max`

Luach picteilín uasta an bhanda (gan an luach “gan sonraí” a áireamh).

#### `mean`

Meán luachanna picteilín uile an bhanda (gan an luach “gan sonraí” a áireamh).

#### `std`

Diall caighdeánach luachanna picteilín uile an bhanda (gan an luach “gan sonraí” a áireamh).

#### `nodata_value`

De ghnáth is luach marcóra speisialta é an luach “gan sonraí” do bhanda a úsáidtear chun picteilíní nach sonraí bailí iad a mharcáil. De ghnáth níor chóir picteilíní den sórt sin a thaispeáint, ná cur le hoibríochtaí an

Chun luach “gan sonraí” atá ann cheana a scriosadh, socraigh an maoin seo go `None`.

#### `datatype(as_string=False)`

An cineál sonraí atá sa bhanda, mar shlámhshláir tairiseach idir 0 (Anaithnid) agus 14. Más é `as_string` `True`, cuirtear an cineál sonraí ar ais mar shreang. \<gdal-raster-datatype\>Amharc ar an gcolún “GDAL Pixel Type” sa tábla luacha:ref: datetype luach le haghaidh luachanna féideartha.

#### `color_interp(as_string=False)`

An léirmhíniú datha don bhanda, mar shláimhir idir 0 agus 16. Má tá `as_string` `True`, cuirtear an cineál sonraí ar ais mar shreang leis na luachanna féideartha seo a leanas: GCI\_Undefined\`, GCI\_GrayIndex\`, GCI\_PaletteIndex\`, GCI\_Redband\`, GCI\_Greenband\`, GCI\_Blueband\`, `GCI_Blueband`, `` `GCI_Blueband ``, `` `GCI_Blueband ``, `` `GCI_Blueband ``, `` `GCI_Blueband ``, `` `GCI_Blueband ``, `` `GCI_Blueband ``, `` `GCIGCI_Alphaband ``, GCI\_Hueband\`, GCI\_SaturationBanda \`, GCI\_LightnessBanda\`, GCI\_Cyanband\`, GCI\_Magentaband\`, `GCI_Yellowband`, GCI\_Banda Dubha\`, GCI\_YCBCR\_YB\`\` , \`GCI\_YCBCR\_CBBand\`, agus `GCI_YCBCR_CRBAND`. Léiríonn `GCI_YCBCR_CrBand` `GCI_max` freisin toisc go bhfreagraíonn an dá cheann don sláimhir 16, ach ní chuirtear ach GCI\_YCBCR\_Crband\` ar ais mar shreang.

#### `data(data=None, offset=None, size=None, shape=None)`

An rochtain ar luachanna picteilín an `Gdalband`. Filleann sé an sraith sonraí iomlán mura gcuirtear aon pharaiméadair ar fáil. Is féidir fo-thacar den eagar picteilín a iarraidh trí fhritháireamh agus méid bloc a shonrú mar thiúpla.

Má tá NumPy ar fáil, cuirtear na sonraí ar ais mar eagar NumPy. Ar chúiseanna feidhmíochta, moltar go mór NumPy a úsáid.

Scríobhtar sonraí chuig an Gdalband\` má chuirtear an paraiméadar ```sonraí ``ar fáil. Is féidir leis an ionchur a bheith ar cheann de na cineálacha seo a leanas - sreang pacáilte, maolán, liosta, eagar, agus eagar NumPy. Ba chóir go bhfreagraíonn líon na míreanna san ionchur de ghnáth do líon iomlán na bpicteilín sa bhanda, nó do líon na bpicteilíní le haghaidh bloc sonrach luachanna picteilín má sholáthraítear na paraiméadair ``offset``` agus méide\`.

Má tá líon na míreanna san ionchur difriúil ón mbloc picteilín sprioc, caithfear an paraiméadar cruth\` a shonrú. Is tuple é an cruth a shonraíonn leithead agus airde na sonraí ionchuir i bpicteilíní. Déantar na sonraí a mhacasamhlú ansin chun luachanna picteilín an bhloc roghnaithe a nuashonrú. Tá sé seo úsáideach chun banna iomlán a líonadh le luach amháin, mar shampla.

Mar shampla:

```pycon
>>> 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)
```

#### `metadata`

Meiteashonraí an bhanda seo. Tá an fheidhmiúlacht comhionann len:attr: gdalraster.metadata.

### Rasters a chruthú ó shonraí

Déanann an chuid seo cur síos ar conas rasters a chruthú ón tús ag baint úsáide as an paraiméadar `ds_input`.

Cruthaítear raster nua nuair a chuirtear `dict` chuig an tógálaí:class: GdalRaster. Tá paraiméadair shainmhínithe an raster nua sa fhoclóir, amhail an tionscnamh, méid nó an córas tagartha spásúil. Is féidir sonraí picteilín agus faisnéis faoi fhormáid an raster nua a bheith san fhoclóir freisin. Dá bhrí sin is féidir leis an raster atá mar thoradh air a bheith bunaithe ar chomhad nó cuimhne, ag brath ar an tiománaí a shonraítear.

Níl aon chaighdeán ann chun cur síos a dhéanamh ar shonraí raster i bhfoclóir nó i mblas JSON. Dá bhrí sin tá an sainmhíniú ar ionchur an fhoclóra chuig aicme:class: GdalRaster go sonrach do Django. Tá sé spreagtha ag an bhformáid , ach tá an caighdeán geojson teoranta faoi láthair do fhormáidí veicteora.

Is féidir samplaí de úsáid na heochracha éagsúla agus rasters á gcruthú agat a fháil i ndoiciméadú na dtréithe agus na modhanna comhfhreagracha de na haicm:class: GdalRaster agus:class: GdalBand.

#### An foclóir `ds_input`

Níl ach cúpla eochair ag teastáil sa fhoclóir `ds_input` chun raster a chruthú: `leithead`, aird\`, agus `srid`. Tá luachanna réamhshocraithe ag gach paraiméadar eile (féach an tábla thíos). Tá dlúthbhaint ag liosta na n-eochracha is féidir a rith sa fhoclóir ds\_input\` ach níl siad comhionann leis na hairíonna: class: GdalRaster. Déantar go leor de na paraiméadair a mhapáil go díreach leis na hairíonna sin; déantar cur síos ar na cinn eile thíos.

Déanann an tábla seo a leanas cur síos ar gach eochracha is féidir a shocrú sa fhoclóir ds\_input\`.

| Eochair | Réamhshocraithe | Úsáid |
| --- | --- | --- |
| `Srid` | riachtanach | Mapáilte leis an tréith: attr: ~gdalraster.srid |
| `leithead` | riachtanach | Mapáilte leis an tréith: attr: ~gdalraster.width |
| `airde` | riachtanach | Mapáilte leis an tréith: attr: ~gdalraster.height |
| `Tiomána` | `MEM` | Mapáilte leis an tréith: attr: ~gdalraster.driver |
| ainm \` | `"` | Féach thíos |
| `` `bunaidh `` | `0` | Mapáilte leis an tréith: attr: ~gdalraster.origin |
| scála \`\` | `0` | Mapáilte leis an tréith: attr: ~gdalraster.scale |
| `` `sciob `` | `0` | Mapáilte leis an tréith: attr: ~gdalraster.width |
| `banna` | `[]` | Féach thíos |
| `nr_of_banna` | `0` | Féach thíos |
| `Cineál sonraí` | `6` | Féach thíos |
| `roghanna papsz` | `{}` | Féach thíos |

#### `name`

Teagán a léiríonn ainm an raster. Agus raster comhbhunaithe á chruthú agat, caithfidh an paraiméadar seo gurb é an cosán comhaid don raster nua. Má thosaíonn an t-ainm le `/vsimem/`, cruthaítear an raster i gcóras comhaid fíorúil GDAL.

#### `datatype`

Sláimhir a léiríonn an cineál sonraí do na bandaí go léir. Réamhshocraithe go `6` (Float32). Ceanglaítear go mbeadh an cineál sonraí céanna ag gach banna de raster nua. Is é an mapáil luachanna:

| Luach | Cineál Picteilín GDAL | Cur síos |
| --- | --- | --- |
| 1 | GDT\_byte | 8 giotán sláimhir neamhshínithe |
| 2 | GDT\_uInt16 | 16 giotán sláimhir neamhshínithe |
| 3 | GDT\_Int16 | Sláimhir sínithe 16 giotán |
| 4 | GDT\_uInt32 | Sláimhir 32 giotán gan shíniú |
| 5 | GDT\_Int32 | Sláimhir sínithe 32 giotán |
| 6 | GDT\_Float32 | Pointe snámh 32 giotán |
| 7 | GDT\_Float64 | Pointe snámh 64 giotán |
| 12 | GDT\_uInt64 | Sláimhir neamhshínithe 64 giotán (GDAL 3.5+) |
| 13 | GDT\_Int64 | Sláimhir shínithe 64 giotán (GDAL 3.5+) |
| 14 | GDT\_Int8 | Sláimhir shínithe 8 giotán (GDAL 3.7+) |

#### `nr_of_bands`

Sláimhir a léiríonn líon na mbannaí den raster. Is féidir raster a chruthú gan sonraí banna a chur ar aghaidh nuair a chruthaítear iad. Mura sonraítear líon na mbannaí, ríomhtar é go huathoibríoch ó fhad na n-ionchur `banda`. Ní féidir líon na mbannaí a athrú tar éis a chruthú.

#### `bands`

Liosta de fhoclóirí `band_input` le sonraí ionchuir banna. Tá na hinnéacsanna banna mar thoradh air mar an gcéanna leis an liosta a chuirtear ar fáil. Tá an sainmhíniú ar an bhfoclóir ionchuir banna tugtar thíos. Mura gcuirtear sonraí banna ar fáil, déantar luachanna na mbannaí raster a ionchasadh mar shraith nialas agus socraítear an luach “gan aon sonraí” go None .

#### `papsz_options`

Foclóir le roghanna cruthaithe raster. Cuirtear péirí luach eochair an fhoclóra ionchuir chuig an tiománaí nuair a chruthaítear an raster.

Tá na roghanna atá ar fáil sainiúil don tiománaí agus déantar cur síos orthu i ndoiciméadú gach tiománaí.

Níl na luachanna sa fhoclóir cás-íogair agus déantar iad a thiontú go huathoibríoch go formáid sreinge ceart nuair a chruthaítear iad

Úsáideann an sampla seo a leanas cuid de na roghanna atá ar fáil don tiománaí GTIFF \_\_. Is é an toradh ná raster comhbhrúite le scéim tíleála inmheánach. Tá méid bloc 23 ag 23 ag na tíleanna inmheánacha:

```pycon
>>> 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,
...         },
...     }
... )
```

#### An foclóir `band_input`

Is é an eochair `bands` sa fhoclóir ds\_input\` liosta de fhoclóirí `band_input`. Is féidir luachanna picteilín a bheith i ngach foclóir `band_input` agus an luach “gan sonraí” atá le socrú ar bannaí an raster nua. Féadfaidh méid iomlán an raster nua a bheith ag an eagar sonraí nó a bheith níos lú. Maidir le eagair atá níos lú ná an raster iomlán, rialaíonn na heochracha ``` `méid ``, `cruth ```, agus `offset` na luachanna picteilín. Cuirtear na heochracha comhfhreagracha ar aghaidh chuig an modh: meth: ~Gdalband.data. Tá a bhfeidhmiúlacht mar an gcéanna le sonraí na mbanna a shocrú leis an modh sin. Déanann an tábla seo a leanas cur síos ar na heochracha is féidir a úsáid.

| Eochair | Réamhshocraithe | Úsáid |
| --- | --- | --- |
| `luach_nodata` | `` `Aon cheann `` | Mapáilte leis an tréith: attr: ~gdalband.nodata\_value |
| sonraí \`\` | Mar an gcéanna le `nodata_value` nó `0` | Rinneadh chuig an modh: meth: ~Gdalband.data |
| Méid \`\` | `(le, airde)` de raster | Rinneadh chuig an modh: meth: ~Gdalband.data |
| `cruth` | Mar an gcéanna leis an méid | Rinneadh chuig an modh: meth: ~Gdalband.data |
| `offset` | `(0, 0)` | Rinneadh chuig an modh: meth: ~Gdalband.data |

### Ag baint úsáide as Córas Comhad Fíorúil GDAL

Is féidir le GDAL rochtain a fháil ar chomhaid atá stóráilte sa chóras comhaid, ach tacaíonn sé freisin le córais chomhad fíorúla chun rochtain teibí a fháil ar chineál eile comhaid, mar shampla comhaid chomhbhrúite, criptithe nó iargúlta.

#### Córas Comhad Fíorúil bunaithe ar chuimhne a úsáid

Tá córas comhaid bunaithe ar chuimhne inmheánach ag GDAL, a cheadaíonn bloic cuimhne a chóireáil mar chomhaid. Is féidir é a úsáid chun rudaí: aicme: GdalRaster a léamh agus a scríobh chuig agus ó mhaoláin comhaid dénártha.

Tá sé seo úsáideach i gcomhthéacsanna gréasáin ina bhféadfaí rasters a fháil mar mhaolán ó stóráil iargúlta nó a thabhairt ar ais ó radharc gan iad a scríobh ar dhiosca.

[`GDALRaster`](#django.contrib.gis.gdal.GDALRaster) objects are created in the virtual filesystem when a
`bytes` object is provided as input, or when the file path starts with
`/vsimem/`.

Caithfidh ionchur a sholáthraítear mar “bytes” a bheith ina léiriú dénártha iomlán ar chomhad. Mar shampla:

```pycon
# 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'
```

Chun raster fíorúil nua atá bunaithe ar chomhad a chruthú ón tús, bain úsáid as ionadaíocht foclóra ds\_input\` agus tabhair argóint ```ainm ``a thosaíonn le ``/vsimem/``` (le haghaidh mionsonraithe an fhoclóra, féach:ref: gdal-raster-ds-input). Maidir le rastróirí fíorúla comhad-bhunaithe, tugann an tréith: attr: ~gdalraster.vsi\_buffer léiriú `bytes` an raster ar ais.

Seo conas raster a chruthú agus é a thabhairt ar ais mar chomhad in an:class: ~django.http.httpResponse:

```pycon
>>> 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")
```

#### Ag baint úsáide as córas comhaid fíorúla eile

Ag brath ar thógáil áitiúil GDAL d'fhéadfaí tacú le córais chomhad fíorúla eile. Is féidir leat iad a úsáid tríd an gcosán a chuirtear ar fáil réamhfheidhmiú leis an réimír chuí `/vsi*/`. Féach an doiciméadú Córais Comhad Fíorúla GDAL \_ le haghaidh tuilleadh sonraí.

##### Rasters comhbhrúite

Ina áit sin an comhad a dhíchumasú agus an raster mar thoradh air a thionscnamh, is féidir le GDAL rochtain a fháil go díreach ar chomhaid chomhbhrúite ag baint úsáide as na córais comhaid fíorúla `/vsizip/`, /vsigzip/\`, nó `/vsitar/`:

```pycon
>>> 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")
```

##### Rosters líonra

Is féidir le GDAL tacú le hacmhainní ar líne agus soláthraithe stórála go trédhearcach Chomh fada agus a thógtar é le cumais den sórt sin.

Chun rochtain a fháil ar chomhad raster poiblí gan aon fhíordheimhniú, is féidir leat `/vsicurl/` a úsáid:

```pycon
>>> from django.contrib.gis.gdal import GDALRaster
>>> rst = GDALRaster("/vsicurl/https://example.com/raster.tif")
>>> rst.name
'/vsicurl/https://example.com/raster.tif'
```

Maidir le soláthraithe stórála tráchtála (m.sh. `/vsis3/`) ba chóir an córas a chumrú roimhe seo le haghaidh fíordheimhnithe agus socruithe eile b'fhéidir (féach doiciméadú GDAL Virtual Filesystems \_ le haghaidh na roghanna atá ar fáil).

#### Security considerations

Since [`GDALRaster`](#django.contrib.gis.gdal.GDALRaster) always opens new rasters in write mode, it is
essential to prevent instantiating one from untrusted input. Otherwise, an
attacker might gain the ability to write a file or make a network request.

To mitigate this, [spatial lookups](/ga/5.2/ref/contrib/gis/db-api/#spatial-lookups-intro) prevent
`str`, [`pathlib.Path`](https://docs.python.org/3/library/pathlib.html#pathlib.Path), and `dict` values from reaching
[`GDALRaster`](#django.contrib.gis.gdal.GDALRaster) altogether. To use these types with lookups, wrap them
explicitly with [`GDALRaster`](#django.contrib.gis.gdal.GDALRaster), indicating that the value is trusted.
Bytes are accepted without being wrapped in [`GDALRaster`](#django.contrib.gis.gdal.GDALRaster) because they
are opened through GDAL's memory-based [virtual filesystem](#gdal-raster-vsimem).

This protection applies only to spatial lookups. Assigning a `dict` value to
a [`RasterField`](/ga/5.2/ref/contrib/gis/model-api/#django.contrib.gis.db.models.RasterField) will still open a new
raster, and assigning a `str` or `Path` will still fetch and open the
referenced raster.

When validating geometry inputs, the
[`GeometryField`](/ga/5.2/ref/contrib/gis/forms-api/#django.contrib.gis.forms.GeometryField) form field will reject raster
values. When validating raster inputs, you should write custom validation.

For defense-in-depth strategies for limiting the available raster drivers, see
[GDAL security considerations](https://gdal.org/user/security.html).

> **Changed in Django 5.2.17**
>
> In earlier versions, spatial lookups accepted `str` and `dict` types
> for new rasters, allowing file writes and network fetches.

## Socruithe

### `BÓTHAIR_LEABHARLANNA_GDAL`

Sreang a shonraíonn suíomh leabharlann GDAL. De ghnáth, ní úsáidtear an socrú seo ach amháin má tá leabharlann GDAL in áit neamhchaighdeánach (m.sh., /home/john/lib/libgdal.so ).

## Eisceachtaí

#### `exception GDALException`

An buneisceacht GDAL, ag léiriú earráid a bhaineann le GDAL.

#### `exception SRSException`

Eisceacht a ardaítear nuair a tharlaíonn earráid agus réad córais tagartha spásúil á thógáil nó ag úsáid.