# Django 6.0.7 documentation

# GDAL API

## Översikt

GDAL stands for Geospatial Data Abstraction Library, and is a veritable ”Swiss army knife” of GIS data functionality. A subset of GDAL is the OGR Simple Features Library, which specializes in reading and writing vector geographic data in a variety of standard formats.

GeoDjango tillhandahåller ett Python-gränssnitt på hög nivå för några av funktionerna i OGR, inklusive läsning och koordinattransformation av vektorbaserade rumsliga data och minimalt stöd för GDAL:s funktioner med avseende på rasterdata (bilddata).

Observera

Även om modulen heter `gdal` stöder GeoDjango bara några av funktionerna i OGR och GDALs rasterfunktioner för närvarande.

### Exempeldata

The GDAL/OGR tools described here are designed to help you read in your geospatial data, in order for most of them to be useful you have to have some data to work with. If you’re starting out and don’t yet have any data of your own to use, GeoDjango tests contain a number of data sets that you can use for testing. You can download them here:

    $ 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

## Objekt för vektordatakälla

### `DataSource`

`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` object which contains one or more layers of data. Each layer, represented by a `Layer` object, contains some number of geographic features (`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`) of data that may be associated with each feature in that layer.

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

  Konstruktören för `DataSource` kräver bara en parameter: sökvägen till den fil du vill läsa. OGR stöder dock också en mängd mer komplexa datakällor, inklusive databaser, som kan nås genom att skicka en speciell namnsträng istället för en sökväg. För mer information, se dokumentationen OGR Vector Formats. Egenskapen `name` för en `DataSource`-instans ger OGR-namnet på den underliggande datakällan som den använder.

  Med den valfria parametern `encoding` kan du ange en icke-standardiserad kodning av strängarna i källan. Detta är vanligtvis användbart när du får `DjangoUnicodeDecodeError`-undantag när du läser fältvärden.

  När du har skapat din `DataSource` kan du ta reda på hur många datalager den innehåller genom att använda egenskapen `layer_count` eller (på motsvarande sätt) genom att använda funktionen `len()`. Information om hur du kommer åt själva datalagren finns i nästa avsnitt:

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

  Returnerar antalet lager i datakällan.

  name

  Returnerar namnet på datakällan.

### `Lager`

class Layer

  `Layer` är ett omslag för ett lager av data i ett `DataSource`-objekt. Du skapar aldrig ett `Layer`-objekt direkt. Istället hämtar du dem från ett `DataSource`-objekt, som i huvudsak är en standard Python-behållare för `Layer`-objekt. Du kan till exempel komma åt ett specifikt lager genom dess index (t.ex. `ds[0]` för att komma åt det första lagret), eller så kan du iterera över alla lager i behållaren i en `for`-loop. Själva `Layer` fungerar som en behållare för geometriska egenskaper.

  Vanligtvis har alla objekt i ett visst skikt samma geometrityp. Egenskapen `geom_type` för ett skikt är en `OGRGeomType` som identifierar funktionstypen. Vi kan använda den för att skriva ut grundläggande information om varje lager i en `DataSource`:

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

  Exemplet är från datakällan cities, som laddades ovan och som uppenbarligen innehåller ett skikt, kallat `"cities"`, som innehåller tre punktfunktioner. För enkelhetens skull antar exemplen nedan att du har lagrat det skiktet i variabeln `layer`:

      >>> layer = ds[0]

  name

  Returnerar namnet på detta lager i datakällan.

      >>> layer.name
      'cities'

  num_feat

  Returnerar antalet funktioner i lagret. Samma som `len(layer)`:

      >>> layer.num_feat
      3

  geom_type

  Returnerar geometritypen för skiktet, som ett `OGRGeomType`-objekt:

      >>> layer.geom_type.name
      'Point'

  num_fields

  Returnerar antalet fält i skiktet, dvs. antalet fält med data som är associerade med varje funktion i skiktet:

      >>> layer.num_fields
      4

  fields

  Returnerar en lista med namnen på alla fält i detta skikt:

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

  Returnerar en lista med datatyperna för varje fält i detta skikt. Dessa är subklasser till `Field`, som beskrivs nedan:

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

  field_widths

  Returnerar en lista med de maximala fältbredderna för varje fält i detta skikt:

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

  field_precisions

  Returnerar en lista med de numeriska precisionsvärdena för varje fält i detta skikt. Detta är meningslöst (och sätts till noll) för icke-numeriska fält:

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

  extent

  Returnerar den rumsliga utbredningen av detta lager, som ett `Envelope`-objekt:

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

  srs

  Egenskap som returnerar den `SpatialReference` som är associerad med detta lager:

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

  Om `Layer` inte har någon spatial referensinformation associerad med sig, returneras `None`.

  spatial_filter

  Egenskap som kan användas för att hämta eller ställa in ett rumsligt filter för detta skikt. Ett rumsligt filter kan endast ställas in med en `OGRGeometry`-instans, en 4-tupel extent eller `None`. När det anges med något annat än `None` kommer endast objekt som skär filtret att returneras vid iterering över skiktet:

      >>> 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()

  En metod som returnerar en lista med värdena för ett visst fält för varje objekt i skiktet:

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

  get_geoms(geos=False)

  En metod som returnerar en lista som innehåller geometrin för varje objekt i skiktet. Om det valfria argumentet `geos` är satt till `True` konverteras geometrierna till `GEOSGeometry`-objekt. Annars returneras de som `OGRGeometry`-objekt:

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

  test_capability(capability)

  Returns a boolean indicating whether this layer supports the given capability (a string). Examples of valid capability strings include: `'RandomRead'`, `'SequentialWrite'`, `'RandomWrite'`, `'FastSpatialFilter'`, `'FastFeatureCount'`, `'FastGetExtent'`, `'CreateField'`, `'Transactions'`, `'DeleteFeature'`, and `'FastSetNextByIndex'`.

### `Funktion`

class Feature

  `Feature` omsluter en OGR-funktion. Du skapar aldrig ett `Feature`-objekt direkt. Istället hämtar du dem från ett `Layer`-objekt. Varje feature består av en geometri och en uppsättning fält som innehåller ytterligare egenskaper. Geometrin för ett fält är tillgänglig via dess egenskap `geom`, som returnerar ett `OGRGeometry`-objekt. En `Feature` beter sig som en standard Python-behållare för sina fält, som den returnerar som `Field`-objekt: du kan komma åt ett fält direkt via dess index eller namn, eller så kan du iterera över en features fält, t.ex. i en `for`-loop.

  geom

  Returnerar geometrin för den här funktionen som ett `OGRGeometry`-objekt:

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

  get

  En metod som returnerar värdet för det angivna fältet (specificerat med namn) för denna funktion, inte ett `Field` omslagsobjekt:

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

  geom_type

  Returnerar geometritypen för den här funktionen, som ett `OGRGeomType`-objekt. Detta kommer att vara detsamma för alla objekt i ett visst skikt och motsvarar egenskapen `Layer.geom_type` i objektet `Layer` som objektet kommer från.

  num_fields

  Returnerar antalet datafält som är associerade med objektet. Detta kommer att vara detsamma för alla funktioner i ett visst skikt och motsvarar egenskapen `Layer.num_fields` i objektet `Layer` som funktionen kommer från.

  fields

  Returnerar en lista med namnen på de datafält som är associerade med objektet. Detta kommer att vara detsamma för alla objekt i ett visst skikt och motsvarar egenskapen `Layer.fields` i objektet `Layer` som objektet kommer från.

  fid

  Returnerar identifieraren för objektet i skiktet:

      >>> city.fid
      0

  layer_name

  Returnerar namnet på `Layer` som objektet kommer från. Detta kommer att vara detsamma för alla funktioner i ett visst lager:

      >>> city.layer_name
      'cities'

  index

  En metod som returnerar indexet för det angivna fältnamnet. Detta kommer att vara detsamma för alla objekt i ett visst lager:

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

### `Fält`

class Field
  name

  Returnerar namnet på detta fält:

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

  type

  Returnerar OGR-typen för detta fält, som ett heltal. Ordboken `FIELD_CLASSES` mappar dessa värden till subklasser av `Field`:

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

  type_name

  Returnerar en sträng med namnet på datatypen för detta fält:

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

  value

  Returnerar värdet för detta fält. Klassen `Field` returnerar själv värdet som en sträng, men varje underklass returnerar värdet i den mest lämpliga formen:

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

  width

  Returnerar bredden på detta fält:

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

  precision

  Returnerar den numeriska precisionen för detta fält. Detta är meningslöst (och sätts till noll) för icke-numeriska fält:

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

  as_double()

  Returnerar fältets värde som en dubbel (float):

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

  as_int()

  Returnerar fältets värde som ett heltal:

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

  as_string()

  Returnerar fältets värde som en sträng:

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

  as_datetime()

  Returnerar fältets värde som en tupel av datum- och tidskomponenter:

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

### `Drivrutin`

class Driver(dr_input)

  Klassen `Driver` används internt för att omsluta en OGR `DataSource`-drivrutin.

  driver_count

  Returnerar antalet OGR-vektorförare som för närvarande är registrerade.

## OGR Geometrier

### `OGRGeometri`

`OGRGeometry`-objekt delar liknande funktionalitet med `GEOSGeometry`-objekt och är tunna omslag runt OGR:s interna geometrirepresentation. De möjliggör således effektivare åtkomst till data när man använder `DataSource`. Till skillnad från sin GEOS-motsvarighet har `OGRGeometry` stöd för rumsliga referenssystem och koordinattransformation:

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

class OGRGeometry(geom_input, srs=None)

  Detta objekt är en omslagsform för klassen OGR Geometry. Dessa objekt instansieras direkt från den givna parametern `geom_input`, som kan vara en sträng som innehåller WKT, HEX, GeoJSON, en `buffer` som innehåller WKB-data, eller ett `OGRGeomType`-objekt. Dessa objekt returneras också från attributet `Feature.geom` när vektordata läses från `Layer` (som i sin tur är en del av en `DataSource`).

  classmethod from_gml(gml_string)

  Konstruerar en `OGRGeometry` från den givna GML-strängen.

  classmethod from_bbox(bbox)

  Konstruerar en `Polygon` från den givna bounding-boxen (en 4-tupel).

  __len__()

  Returnerar antalet punkter i en `LineString`, antalet ringar i en `Polygon` eller antalet geometrier i en `GeometryCollection`. Gäller inte för andra geometrityper.

  __iter__()

  Itererar över punkterna i en `LineString`, ringarna i en `Polygon` eller geometrierna i en `GeometryCollection`. Gäller inte för andra geometrityper.

  __getitem__()

  Returnerar punkten vid det angivna indexet för en `LineString`, den inre ringen vid det angivna indexet för en `Polygon`, eller geometrin vid det angivna indexet i en `GeometryCollection`. Gäller inte för andra geometrityper.

  dimension

  Returnerar antalet koordinerade dimensioner i geometrin, dvs. 0 för punkter, 1 för linjer osv:

      >>> polygon.dimension
      2

  is_3d

  En boolean som anger om geometrin har Z-koordinater.

  set_3d(value)

  En metod som lägger till eller tar bort Z-koordinatdimensionen.

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

  is_measured

  En boolean som anger om geometrin har M-koordinater.

  set_measured(value)

  En metod för att lägga till eller ta bort M-koordinatdimensionen.

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

  geom_count

  Returnerar antalet element i denna geometri:

      >>> polygon.geom_count
      1

  has_curve

  En boolean som anger om geometrin är eller innehåller en kurvgeometri.

  get_linear_geometry()

  Returnerar en linjär version av geometrin. Om ingen konvertering kan göras returneras originalgeometrin.

  get_curve_geometry()

  Returnerar en krökt version av geometrin. Om ingen konvertering kan göras returneras originalgeometrin.

  point_count

  Returnerar antalet punkter som används för att beskriva denna geometri:

      >>> polygon.point_count
      4

  num_points

  Alias för `point_count`.

  num_coords

  Alias för `point_count`.

  geom_type

  Returnerar typen av denna geometri, som ett `OGRGeomType`-objekt.

  geom_name

  Returnerar namnet på typen för denna geometri:

      >>> polygon.geom_name
      'POLYGON'

  area

  Returnerar arean för denna geometri, eller 0 för geometrier som inte innehåller någon area:

      >>> polygon.area
      25.0

  envelope

  Returnerar kuvertet för denna geometri, som ett `Envelope`-objekt.

  extent

  Returnerar kuvertet för denna geometri som en 4-tupel, istället för som ett `Envelope`-objekt:

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

  srs

  This property controls the spatial reference for this geometry, or `None` if no spatial reference system has been assigned to it. If assigned, accessing this property returns a `SpatialReference` object. It may be set with another `SpatialReference` object, or any input that `SpatialReference` accepts. Example:

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

  srid

  Returns or sets the spatial reference identifier corresponding to `SpatialReference` of this geometry. Returns `None` if there is no spatial reference information associated with this geometry, or if an SRID cannot be determined.

  geos

  Returnerar ett `GEOSGeometry`-objekt som motsvarar denna geometri.

  gml

  Returnerar en strängrepresentation av denna geometri i GML-format:

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

  hex

  Returnerar en strängrepresentation av denna geometri i HEX WKB-format:

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

  json

  Returnerar en strängrepresentation av denna geometri i JSON-format:

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

  kml

  Returnerar en strängrepresentation av denna geometri i KML-format.

  wkb_size

  Returnerar storleken på den WKB-buffert som behövs för att hålla en WKB-representation av denna geometri:

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

  wkb

  Returnerar en `buffer` som innehåller en WKB-representation av denna geometri.

  wkt

  Returnerar en strängrepresentation av denna geometri i WKT-format.

  ewkt

  Returnerar EWKT-representationen av denna geometri.

  clone()

  Returnerar en ny `OGRGeometry`-klon av detta geometriobjekt.

  close_rings()

  Om det finns några ringar inom denna geometri som inte har stängts, kommer denna rutin att göra det genom att lägga till startpunkten till slutet:

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

  Transformerar denna geometri till ett annat rumsligt referenssystem. Kan ta ett `CoordTransform`-objekt, ett `SpatialReference`-objekt, eller någon annan indata som accepteras av `SpatialReference` (inklusive rumsliga referens WKT- och PROJ-strängar, eller ett heltal SRID).

  Som standard returneras ingenting och geometrin transformeras på plats. Men om nyckelordet `clone` är satt till `True` returneras istället en transformerad klon av denna geometri.

  intersects(other)

  Returnerar `True` om denna geometri skär den andra, annars returneras `False`.

  equals(other)

  Returnerar `True` om denna geometri är likvärdig med den andra, annars returneras `False`.

  disjoint(other)

  Returnerar `True` om denna geometri är rumsligt disjunkt med (dvs. inte skär) den andra, annars returneras `False`.

  touches(other)

  Returnerar `True` om denna geometri berör den andra, annars returneras `False`.

  crosses(other)

  Returnerar `True` om denna geometri korsar den andra, annars returneras `False`.

  within(other)

  Returnerar `True` om denna geometri är innesluten i den andra, annars returneras `False`.

  contains(other)

  Returnerar `True` om denna geometri innehåller den andra, annars returneras `False`.

  overlaps(other)

  Returnerar `True` om denna geometri överlappar den andra, annars returneras `False`.

  boundary()

  Gränsen för denna geometri, som ett nytt `OGRGeometry`-objekt.

  convex_hull

  Den minsta konvexa polygonen som innehåller denna geometri, som ett nytt `OGRGeometry`-objekt.

  difference()

  Returnerar regionen som består av skillnaden mellan den här geometrin och den andra, som ett nytt `OGRGeometry`-objekt.

  intersection()

  Returnerar regionen som består av skärningspunkten mellan denna geometri och den andra, som ett nytt `OGRGeometry`-objekt.

  sym_difference()

  Returnerar den region som består av den symmetriska skillnaden mellan denna geometri och den andra, som ett nytt `OGRGeometry`-objekt.

  union()

  Returnerar den region som består av föreningen av denna geometri och den andra, som ett nytt `OGRGeometry`-objekt.

  centroid

  Returnerar en `Point` som representerar geometrins centroid.

  tuple

  Returnerar koordinaterna för en punktgeometri som en tupel, koordinaterna för en linjegeometri som en tupel av tuplar osv:

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

  Ett alias för `tuple`.

class Point
  x

  Returnerar X-koordinaten för denna punkt:

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

  y

  Returnerar Y-koordinaten för denna punkt:

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

  z

  Returnerar Z-koordinaten för denna punkt, eller `None` om punkten inte har någon Z-koordinat:

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

  m

  Returnerar M-koordinaten för denna punkt, eller `None` om Point inte har någon M-koordinat:

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

class LineString
  x

  Returnerar en lista med X-koordinater i denna linje:

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

  y

  Returnerar en lista med Y-koordinater i denna linje:

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

  z

  Returnerar en lista med Z-koordinater i linjen, eller `None` om linjen inte har några Z-koordinater:

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

  m

  Returnerar en lista med M-koordinater i den här linjen eller `None` om linjen inte har M-koordinater:

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

class Polygon
  shell

  Returnerar skalet eller den yttre ringen för denna polygon, som en `LinearRing` geometri.

  exterior_ring

  Ett alias för `shell`.

class GeometryCollection
  add(geom)

  Lägger till en geometri till denna geometrisamling. Gäller inte för andra geometrityper.

### `OGRGeomType`

class OGRGeomType(type_input)

  Denna klass gör det möjligt att representera en OGR-geometrityp på flera olika sätt:

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

  Returnerar en kortfattad strängform av OGR Geometry-typen:

      >>> gt1.name
      'Polygon'

  num

  Returnerar det nummer som motsvarar OGR-geometritypen:

      >>> gt1.num
      3

  django

  Returnerar Django-fälttypen (en underklass till GeometryField) som ska användas för att lagra denna OGR-typ, eller `None` om det inte finns någon lämplig Django-typ:

      >>> gt1.django
      'PolygonField'

### `Kuvert`

class Envelope(*args)

  Representerar en OGR Envelope-struktur som innehåller de lägsta och högsta X- och Y-koordinaterna för en rektangels begränsningsbox. Namngivningen av variablerna är kompatibel med OGR Envelope C-strukturen.

  min_x

  Värdet på den minsta X-koordinaten.

  min_y

  Värdet på den maximala X-koordinaten.

  max_x

  Värdet på den minsta Y-koordinaten.

  max_y

  Värdet på den maximala Y-koordinaten.

  ur

  Den övre högra koordinaten, som en tupel.

  ll

  Den nedre vänstra koordinaten, som en tupel.

  tuple

  En tupel som representerar kuvertet.

  wkt

  En sträng som representerar detta kuvert som en polygon i WKT-format.

  expand_to_include(*args)

## Objekt i koordinatsystem

### `SpatialReference`

class SpatialReference(srs_input)

  Rumsliga referensobjekt initialiseras på den givna `srs_input`, som kan vara en av följande:

  - OGC Välkänd text (WKT) (en sträng)

  - EPSG-kod (heltal eller sträng)

  - PROJ sträng

  - En kortfattad sträng för välkända standarder (`'WGS84'`, `'WGS72'`, `'NAD27'`, `'NAD83'`)

  Exempel:

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

  Returnerar värdet för den angivna strängattributnoden, `None` om noden inte finns. Kan också ta en tupel som parameter, (target, child), där child är attributets index i WKT. Till exempel: (target)

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

  Attributvärdet för den angivna målnoden (t.ex. `'PROJCS'`). Nyckelordet index anger ett index för den underordnade nod som ska returneras.

  auth_name(target)

  Returnerar auktoritetsnamnet för den givna strängens målnod.

  auth_code(target)

  Returnerar auktoritetskoden för den givna strängens målnod.

  clone()

  Returnerar en klon av detta rumsliga referensobjekt.

  identify_epsg()

  Denna metod inspekterar WKT för denna `SpatialReference` och lägger till EPSG-auktoritetsnoder där en EPSG-identifierare är tillämplig.

  from_esri()

  Omvandlar denna SpatialReference från ESRI:s format till EPSG

  to_esri()

  Morphar denna SpatialReference till ESRI:s format.

  validate()

  Kontrollerar om den angivna rumsliga referensen är giltig, om så inte är fallet kommer ett undantag att uppstå.

  import_epsg(epsg)

  Importera rumslig referens från EPSG-kod.

  import_proj(proj)

  Importera rumslig referens från PROJ-sträng.

  import_user_input(user_input)
  import_wkt(wkt)

  Importera rumslig referens från WKT.

  import_xml(xml)

  Importera rumslig referens från XML.

  name

  Returnerar namnet på denna rumsliga referens.

  srid

  Returnerar SRID för högsta nivåns auktoritet, eller `None` om den inte är definierad.

  linear_name

  Returnerar namnet på de linjära enheterna.

  linear_units

  Returnerar värdet för de linjära enheterna.

  angular_name

  Returnerar namnet på vinkelenheterna.”

  angular_units

  Returnerar värdet för vinkelenheterna.

  units

  Returnerar en 2-tupel av enhetsvärdet och enhetsnamnet och avgör automatiskt om det är linjära enheter eller vinkelenheter som ska returneras.

  ellipsoid

  Returnerar en tupel av ellipsoidparametrarna för denna rumsliga referens: (semimajoraxel, semiminoraxel och invers avplaning).

  semi_major

  Returnerar ellipsoidens halva huvudaxel för denna rumsliga referens.

  semi_minor

  Returnerar ellipsoidens halva mindre axel för denna rumsliga referens.

  inverse_flattening

  Returnerar ellipsoidens inversa tillplattning för denna rumsliga referens.

  geographic

  Returnerar `True` om denna rumsliga referens är geografisk (rotnoden är `GEOGCS`).

  local

  Returnerar `True` om denna rumsliga referens är lokal (rotnoden är `LOCAL_CS`).

  projected

  Returnerar `True` om denna rumsliga referens är ett projicerat koordinatsystem (rotnoden är `PROJCS`).

  wkt

  Returnerar WKT-representationen av denna rumsliga referens.

  pretty_wkt

  Returnerar den ”vackra” representationen av WKT.

  proj

  Returnerar PROJ-representationen för denna rumsliga referens.

  proj4

  Alias för `SpatialReference.proj`.

  xml

  Returnerar XML-representationen av denna rumsliga referens.

### `CoordTransform`

class CoordTransform(source, target)

Representerar en koordinatsystemtransformation. Den initialiseras med två `SpatialReference`, som representerar käll- respektive målkoordinatsystemen. Dessa objekt bör användas när samma koordinattransformation utförs upprepade gånger på olika geometrier:

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

## Objekt för rasterdata

### `GDALRaster`

`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` object which contains one or more layers of data named bands. Each band, represented by a `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.

Observera

För rasterdata är det ingen skillnad mellan en rasterinstans och dess datakälla. Till skillnad från Geometry-objekten är `GDALRaster`-objekt alltid en datakälla. Temporära raster kan instansieras i minnet med hjälp av motsvarande drivrutin, men de kommer att vara av samma klass som filbaserade rasterkällor.

class GDALRaster(ds_input, write=False)

  Konstruktören för `GDALRaster` accepterar två parametrar. Den första parametern definierar rasterkällan och den andra parametern definierar om ett raster ska öppnas i skrivläge. För nyskapade raster ignoreras den andra parametern och det nya rastret skapas alltid i skrivläge.

  Den första parametern kan ha tre former: en sträng eller `Path` som representerar en filsökväg (filsystem eller GDAL:s virtuella filsystem), en ordbok med värden som definierar ett nytt raster eller ett bytesobjekt som representerar en rasterfil.

  Om indata är en sökväg till en fil öppnas rastret därifrån. Om indata är rådata i en ordbok krävs parametrarna `width`, `height` och `rid`. Om indata är ett bytesobjekt kommer det att öppnas med hjälp av ett virtuellt GDAL-filsystem.

  För en detaljerad beskrivning av hur man skapar raster med hjälp av ordboksinmatning, se Skapa raster från data. För en detaljerad beskrivning av hur man skapar raster i det virtuella filsystemet, se Använda GDAL:s virtuella filsystem.

  Följande exempel visar hur raster kan skapas från olika ingångskällor (med hjälp av exempeldata från GeoDjango-testerna; se även avsnittet Exempeldata).

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

    Namnet på källan, vilket motsvarar sökvägen till indatafilen eller det namn som anges vid instansiering.

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

  driver

    Namnet på den GDAL-drivrutin som används för att hantera indatafilen. För `GDALRaster` som skapas från en fil identifieras drivrutinstypen automatiskt. När raster skapas från grunden är standardinställningen ett raster i minnet (`'MEM`), men det kan ändras efter behov. Använd t.ex. `GTiff` för en `GeoTiff`-fil. För en lista över filtyper, se även listan GDAL Raster Formats.

    Ett raster i minnet skapas med hjälp av följande exempel:

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

    Ett filbaserat GeoTiff-raster skapas med hjälp av följande exempel:

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

    Källans bredd i pixlar (X-axeln).

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

  height

    Källans höjd i pixlar (Y-axeln).

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

  srs

    Rastrets rumsliga referenssystem, som en `SpatialReference`-instans. SRS kan ändras genom att ställa in det till en annan `SpatialReference` eller genom att tillhandahålla någon indata som accepteras av `SpatialReference` konstruktören.

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

  srid

    Rastrets SRID (Spatial Reference System Identifier). Denna egenskap är en genväg till att hämta eller ställa in SRID genom attributet `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

  geotransform

    Den affina transformationsmatris som används för att georeferera källan, som en tupel av sex koefficienter som mappar pixel-/linjekoordinater till georefererat utrymme med hjälp av följande relation:

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

    Samma värden kan hämtas genom att använda egenskaperna `origin` (index 0 och 3), `scale` (index 1 och 5) och `skew` (index 2 och 4).

    Standardvärdet är `[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]

  origin

    Koordinater för rastrets övre vänstra ursprung i källans rumsliga referenssystem, som ett punktobjekt med `x` och `y` medlemmar.

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

    Pixelbredd och -höjd som används för georeferering av rastret, som ett punktobjekt med `x` och `y` medlemmar. Se `geotransform` för mer information.

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

    Skevhetskoefficienter som används för att georeferera rastret, som ett punktobjekt med `x` och `y` medlemmar. När det gäller bilder från norr är båda dessa koefficienter `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]

  extent

    Rasterkällans utbredning (gränsvärden), som en 4-tupel `(xmin, ymin, xmax, ymax)` i källans rumsliga referenssystem.

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

    Lista över alla band i källan, som `GDALBand`-instanser.

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

    Returnerar en förvrängd version av detta raster.

    Warpingparametrarna kan specificeras genom argumentet `ds_input`. Användningen av `ds_input` är analog med motsvarande argument i klasskonstruktorn. Det är en ordbok med egenskaperna hos målrastret. Tillåtna nyckelvärden i ordboken är bredd, höjd, SRID, ursprung, skala, skevhet, datatyp, drivrutin och namn (filnamn).

    Som standard behåller warp-funktionen de flesta parametrar till samma värden som i det ursprungliga källrastret, så endast parametrar som ska ändras behöver anges. Observera att detta inkluderar drivrutinen, så för filbaserade raster skapar warp-funktionen ett nytt raster på disken.

    Den enda parameter som skiljer sig från källrastret är namnet. Standardvärdet för rasternamnet är namnet på källrastret med tillägget `'_copy' + source_driver_name`. För filbaserade raster rekommenderas att man anger filvägen till målrastret.

    Den resamplingsalgoritm som används för warping kan specificeras med argumentet `resampling`. Standardvärdet är `NearestNeighbor` och de andra tillåtna värdena är `Bilinear`, `Cubic`, `CubicSpline`, `Lanczos`, `Average` och `Mode`.

    Argumentet `max_error` kan användas för att ange det maximala felet mätt i ingående pixlar som tillåts vid approximering av transformationen. Standardvärdet är 0,0 för exakta beräkningar.

    För användare som är bekanta med `GDAL` har denna funktion en liknande funktionalitet som kommandoradsverktyget `gdalwarp`.

    Warp-funktionen kan t.ex. användas för att aggregera ett raster till det dubbla av den ursprungliga pixelskalan:

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

    Transformerar detta raster till ett annat rumsligt referenssystem (`srs`), som kan vara ett `SpatialReference`-objekt, eller någon annan indata som accepteras av `SpatialReference` (inklusive rumsliga referens WKT- och PROJ-strängar, eller ett heltal SRID).

    Den beräknar gränserna och skalan för det aktuella rastret i det nya rumsliga referenssystemet och förvränger rastret med hjälp av funktionen `warp`.

    Som standard används drivrutinen för källrastret och namnet på rastret är det ursprungliga namnet med tillägget `'_copy' + source_driver_name`. En annan drivrutin eller ett annat namn kan anges med argumenten `driver` och `name`.

    Standardalgoritmen för omsampling är `NearestNeighbour` men kan ändras med argumentet `resampling`. Det högsta tillåtna standardfelet för omsampling är 0,0 och kan ändras med argumentet `max_error`. Se dokumentationen `warp` för mer information om dessa argument.

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

    Returnerar en sträng med en sammanfattning av rastret. Detta motsvarar kommandoradsverktyget gdalinfo.

  metadata

    Metadata för detta raster, representerat som en nästlad ordbok. Nyckeln på första nivån är metadatadomänen. Den andra nivån innehåller metadataelementens namn och värden från varje domän.

    För att ställa in eller uppdatera ett metadataobjekt skickar du motsvarande metadataobjekt till metoden med hjälp av den nästlade struktur som beskrivs ovan. Endast nycklar som finns i den angivna ordlistan uppdateras; resten av metadata förblir oförändrade.

    Om du vill ta bort ett metadataobjekt använder du `None` som metadatavärde.

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

    En `bytes``representation av detta raster. Returnerar ``None` för raster som inte lagras i GDAL:s virtuella filsystem.

  is_vsi_based

    En boolean som anger om detta raster lagras i GDAL:s virtuella filsystem.

### `GDALBand`

class GDALBand

  instanser av `GDALBand` skapas inte explicit utan erhålls från ett `GDALRaster`-objekt genom dess `bands`-attribut. GDALBands innehåller de faktiska pixelvärdena i rastret.

  description

    Namn eller beskrivning av bandet, om sådant finns.

  width

    Bandets bredd i pixlar (X-axeln).

  height

    Bandets höjd i pixlar (Y-axeln).

  pixel_count

    Det totala antalet pixlar i detta band. Är lika med `bredd * höjd`.

  statistics(refresh=False, approximate=False)

    Beräknar statistik över pixelvärdena i detta band. Returvärdet är en tupel med följande struktur: `(minimum, maximum, mean, standard deviation)`.

    Om argumentet `approximate` är inställt på `True` kan statistiken beräknas baserat på översikter eller en delmängd av bildplattor.

    Om argumentet `refresh` är satt till `True`, kommer statistiken att beräknas direkt från data och cachen kommer att uppdateras med resultatet.

    Om det finns ett värde i den permanenta cachen returneras det värdet. För rasterformat som använder PAM-tjänster (Persistent Auxiliary Metadata) kan statistiken cachelagras i en hjälpfil. I vissa fall kan dessa metadata vara osynkroniserade med pixelvärdena eller leda till att värden från ett tidigare anrop returneras som inte återspeglar värdet på argumentet `approximate`. I sådana fall ska du använda argumentet `refresh` för att hämta uppdaterade värden och lagra dem i cacheminnet.

    För tomma band (där alla pixelvärden är ”inga data”) returneras all statistik som `None`.

    Statistiken kan också hämtas direkt genom att använda egenskaperna `min`, `max`, `mean` och `std`.

  min

    Bandets lägsta pixelvärde (exklusive värdet för ”inga data”).

  max

    Det maximala pixelvärdet för bandet (exklusive värdet ”inga data”).

  mean

    Medelvärdet av alla pixelvärden i bandet (exklusive värdet ”inga data”).

  std

    Standardavvikelsen för alla pixelvärden i bandet (exklusive värdet ”inga data”).

  nodata_value

    Värdet ”no data” för ett band är i allmänhet ett speciellt markörvärde som används för att markera pixlar som inte är giltiga data. Sådana pixlar ska i allmänhet inte visas och inte heller bidra till analysoperationer.

    För att ta bort ett befintligt ”no data”-värde, sätt denna egenskap till `None`.

  datatype(as_string=False)

    Den datatyp som bandet innehåller, som en heltalskonstant mellan 0 (okänd) och 14. Om `as_string` är `True` returneras datatypen som en sträng. Kolla in kolumnen ”GDAL Pixel Type” i datatype value table för möjliga värden.

  color_interp(as_string=False)

    The color interpretation for the band, as an integer between 0 and 16. If `as_string` is `True`, the data type is returned as a string with the following possible values: `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`, and `GCI_YCbCr_CrBand`. `GCI_YCbCr_CrBand` also represents `GCI_Max` because both correspond to the integer 16, but only `GCI_YCbCr_CrBand` is returned as a string.

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

    Åtkomst till pixelvärdena i `GDALBand`. Returnerar den fullständiga dataarrayen om inga parametrar anges. En delmängd av pixelmatrisen kan begäras genom att ange en offset och blockstorlek som tupler.

    Om NumPy är tillgängligt returneras data som en NumPy-array. Av prestandaskäl rekommenderas det starkt att använda NumPy.

    Data skrivs till `GDALBand` om parametern `data` anges. Indata kan vara av någon av följande typer - packad sträng, buffert, lista, array och NumPy-array. Antalet objekt i indata bör normalt motsvara det totala antalet pixlar i bandet, eller antalet pixlar för ett specifikt block av pixelvärden om parametrarna `offset` och `size` anges.

    Om antalet objekt i indata skiljer sig från målpixelblocket måste parametern `shape` anges. Formen är en tupel som anger bredden och höjden på indata i pixlar. Data replikeras sedan för att uppdatera pixelvärdena i det valda blocket. Detta är användbart om man t.ex. vill fylla ett helt band med ett enda värde.

    Till exempel:

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

    Metadata för detta band. Funktionaliteten är identisk med `GDALRaster.metadata`.

### Skapa raster från data

I detta avsnitt beskrivs hur du skapar raster från grunden med hjälp av parametern `ds_input`.

Ett nytt raster skapas när en `dict` skickas till `GDALRaster`-konstruktören. Dictionariet innehåller definierande parametrar för det nya rastret, t.ex. ursprung, storlek eller rumsligt referenssystem. Dictionariet kan också innehålla pixeldata och information om formatet för det nya rastret. Det resulterande rastret kan därför vara filbaserat eller minnesbaserat, beroende på vilken drivrutin som anges.

Det finns ingen standard för att beskriva rasterdata i en ordbok eller JSON-smak. Definitionen av ordboksinmatningen till `GDALRaster`-klassen är därför specifik för Django. Den är inspirerad av geojson-formatet, men `geojson`-standarden är för närvarande begränsad till vektorformat.

Exempel på hur man använder de olika nycklarna när man skapar raster finns i dokumentationen för motsvarande attribut och metoder i klasserna `GDALRaster` och `GDALBand`.

#### Ordboken ”dds_input

Endast ett fåtal nycklar krävs i `ds_input`-ordlistan för att skapa ett raster: `width`, `height` och `rid`. Alla andra parametrar har standardvärden (se tabellen nedan). Listan över nycklar som kan anges i ordlistan `ds_input` är nära besläktad men inte identisk med egenskaperna för `GDALRaster`. Många av parametrarna mappas direkt till dessa egenskaper; de övriga beskrivs nedan.

I följande tabell beskrivs alla nycklar som kan ställas in i ordlistan `ds_input`.

Nyckel | Standard | Användning
--- | --- | ---
`srid` | obligatoriskt | Mappad till attributet `srid`
`bredd` | obligatoriskt | Mappad till attributet `width`
`höjd` | obligatoriskt | Mappad till attributet `height`
`drivrutin` | `MEM` | Mappad till attributet `driver`
`namn` | `''` | Se nedan
`ursprung` | `0` | Mappad till attributet `origin`
`skala` | `0` | Mappad till attributet `scale`
`skew` | `0` | Mappad till attributet `width`
`band` | `[]` | Se nedan
”antal äkta makar | `0` | Se nedan
`datatyp` | `6` | Se nedan
`papsz_options` | `{}` | Se nedan

name

  Sträng som representerar namnet på rastret. När du skapar ett filbaserat raster måste denna parameter vara filsökvägen för det nya rastret. Om namnet börjar med `/vsimem/` skapas rastret i GDAL:s virtuella filsystem.

datatype

  Heltal som representerar datatypen för alla band. Standardvärdet är `6` (Float32). Alla band i ett nytt raster måste ha samma datatyp. Värdemappningen är:

  Värde | GDAL Pixeltyp | Beskrivning
  --- | --- | ---
  1 | GDT_Byte | 8 bitars osignerat heltal
  2 | GDT_UInt16 | 16 bitars osignerat heltal
  3 | GDT_Int16 | 16 bitars signerat heltal
  4 | GDT_UInt32 | 32 bitars osignerat heltal
  5 | GDT_Int32 | 32 bitars signerat heltal
  6 | GDT_Float32 | 32 bitars flyttal
  7 | GDT_Float64 | 64 bitars flyttal
  12 | GDT_UInt64 | 64 bitars osignerat heltal (GDAL 3.5+)
  13 | GDT_Int64 | 64 bitars signerat heltal (GDAL 3.5+)
  14 | GDT_Int8 | 8 bitars signerat heltal (GDAL 3.7+)

nr_of_bands

  Heltal som representerar antalet band i rastret. Ett raster kan skapas utan att banddata överförs vid skapandet. Om antalet band inte anges beräknas det automatiskt utifrån längden på indata `bands`. Antalet band kan inte ändras efter skapandet.

bands

  En lista över `band_input` dictionaries med bandinmatningsdata. De resulterande bandindexen är desamma som i den tillhandahållna listan. Definitionen av ordlistan för bandinmatning ges nedan. Om banddata inte tillhandahålls instansieras rasterbandvärdena som en array med nollor och värdet ”no data” sätts till `None`.

papsz_options

  En ordbok med alternativ för skapande av raster. Nyckel-värdeparen i den inmatade ordlistan skickas till drivrutinen när rastret skapas.

  De tillgängliga alternativen är drivrutinsspecifika och beskrivs i dokumentationen för respektive drivrutin.

  Värdena i ordlistan är inte skiftlägeskänsliga och konverteras automatiskt till rätt strängformat när de skapas.

  I följande exempel används några av de alternativ som finns tillgängliga för GTiff-drivrutinen. Resultatet är ett komprimerat raster med ett internt tilesystem. De interna plattorna har en blockstorlek på 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,
      ...         },
      ...     }
      ... )

#### Ordboken `band_input` (bandinmatning)

Nyckeln `bands` i ordlistan `ds_input` är en lista över ordlistor med `band_input`. Varje `band_input`-ordbok kan innehålla pixelvärden och värdet ”no data” som skall ställas in på banden i det nya rastret. Dataarrayen kan ha samma storlek som det nya rastret eller vara mindre. För matriser som är mindre än hela rastret styr nycklarna `size`, `shape` och `offset` pixelvärdena. Motsvarande nycklar skickas till metoden `data()`. Deras funktion är densamma som att ställa in banddata med den metoden. I följande tabell beskrivs de nycklar som kan användas.

Nyckel | Standard | Användning
--- | --- | ---
`nodata_värde` | `Ingen` | Mappad till attributet `nodata_value`
`data` | Samma som `nodata_value` eller `0` | Överförs till metoden `data()`
`storlek` | `(med, höjd)` av raster | Överförs till metoden `data()`
`form` | Samma som storlek | Överförs till metoden `data()`
`offset` | `(0, 0)` | Överförs till metoden `data()`

### Använda GDAL:s virtuella filsystem

GDAL kan komma åt filer som lagras i filsystemet, men stöder också virtuella filsystem för att abstrahera åtkomst till andra typer av filer, t.ex. komprimerade, krypterade eller fjärrfiler.

#### Använda minnesbaserat virtuellt filsystem

GDAL har ett internt minnesbaserat filsystem, som gör det möjligt att behandla minnesblock som filer. Det kan användas för att läsa och skriva `GDALRaster`-objekt till och från binära filbuffertar.

Detta är användbart i webbsammanhang där rasters kan hämtas som en buffert från ett fjärrlager eller returneras från en vy utan att skrivas till disk.

`GDALRaster`-objekt skapas i det virtuella filsystemet när ett `bytes`-objekt tillhandahålls som indata, eller när filsökvägen börjar med `/vsimem/`.

Indata som tillhandahålls som `bytes` måste vara en fullständig binär representation av en fil. Till exempel:

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

För att skapa ett nytt virtuellt filbaserat raster från början, använd ordboksrepresentationen `ds_input` och ange ett `name` argument som börjar med `/vsimem/` (för detaljer om ordboksrepresentationen, se gdal-raster-ds-input`). För virtuella filbaserade raster returnerar attributet `vsi_buffer` `bytes`-representationen av rastret.

Så här skapar du ett raster och returnerar det som en fil i en `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")

#### Använda andra virtuella filsystem

Beroende på den lokala versionen av GDAL kan andra virtuella filsystem stödjas. Du kan använda dem genom att prefixera den angivna sökvägen med lämpligt prefix `/vsi*/`. Se GDAL Virtual Filesystems documentation för mer information.

Varning

Rasters with names starting with `/vsi*/` will be treated as rasters from the GDAL virtual filesystems. Django doesn’t perform any extra validation.

##### Komprimerade raster

Instead of decompressing the file and instantiating the resulting raster, GDAL can directly access compressed files using the `/vsizip/`, `/vsigzip/`, or `/vsitar/` virtual filesystems:

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

##### Nätverksraster

GDAL kan stödja online-resurser och lagringsleverantörer på ett transparent sätt. Så länge den är byggd med sådana funktioner.

Om du vill komma åt en publik rasterfil utan autentisering kan du använda `/vsicurl/`:

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

För kommersiella lagringsleverantörer (t.ex. `/vsis3/`) bör systemet vara konfigurerat i förväg för autentisering och eventuellt andra inställningar (se GDAL Virtual Filesystems documentation för tillgängliga alternativ).

#### Security considerations

Since `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 prevent `str`, `pathlib.Path`, and `dict` values from reaching `GDALRaster` altogether. To use these types with lookups, wrap them explicitly with `GDALRaster`, indicating that the value is trusted. Bytes are accepted without being wrapped in `GDALRaster` because they are opened through GDAL’s memory-based virtual filesystem.

This protection applies only to spatial lookups. Assigning a `dict` value to a `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` 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.

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.

## Inställningar

### `GDAL_BIBLIOTEK_VÄG`

A string specifying the location of the GDAL library. Typically, this setting is only used if the GDAL library is in a non-standard location (e.g., `/home/john/lib/libgdal.so`).

## Undantag

exception GDALException

  Det grundläggande GDAL-undantaget, som indikerar ett GDAL-relaterat fel.

exception SRSException

  Ett undantag som uppstår när ett fel inträffar vid konstruktion eller användning av ett objekt i det rumsliga referenssystemet.