GDAL API¶
gDAL står för Geospatial Data Abstraction Library och är en veritabel ”schweizisk armékniv” för GIS-datafunktioner. En delmängd av GDAL är `OGR`__ Simple Features Library, som är specialiserat på att läsa och skriva geografiska vektordata i en mängd olika standardformat.
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.
Översikt¶
Exempeldata¶
GDAL/OGR-verktygen som beskrivs här är utformade för att hjälpa dig att läsa in dina geospatiala data, för att de flesta av dem ska vara användbara måste du ha några data att arbeta med. Om du börjar och ännu inte har några egna data att använda, innehåller GeoDjango-tester ett antal datauppsättningar som du kan använda för testning. Du kan ladda ner dem här:
$ 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
är ett omslag för OGR:s datakällsobjekt som stöder läsning av data från en mängd olika OGR-stödda geospatiala filformat och datakällor med hjälp av ett konsekvent gränssnitt. Varje datakälla representeras av ett DataSource
-objekt som innehåller ett eller flera datalager. Varje skikt, som representeras av ett Layer
-objekt, innehåller ett antal geografiska egenskaper (Feature
), information om vilken typ av egenskaper som finns i skiktet (t.ex. punkter, polygoner etc.) samt namn och typ för eventuella ytterligare datafält (Field
) som kan associeras med varje egenskap i skiktet.
- class DataSource(ds_input, encoding='utf-8')[source]¶
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`__. Egenskapenname
för enDataSource
-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årDjangoUnicodeDecodeError
-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 egenskapenlayer_count
eller (på motsvarande sätt) genom att använda funktionenlen()
. 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
Returnerar antalet lager i datakällan.
Returnerar namnet på datakällan.
Lager
¶
- class Layer¶
Layer
är ett omslag för ett lager av data i ettDataSource
-objekt. Du skapar aldrig ettLayer
-objekt direkt. Istället hämtar du dem från ettDataSource
-objekt, som i huvudsak är en standard Python-behållare förLayer
-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 enfor
-loop. SjälvaLayer
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 enOGRGeomType
som identifierar funktionstypen. Vi kan använda den för att skriva ut grundläggande information om varje lager i enDataSource
:>>> 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 variabelnlayer
:>>> 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, returnerasNone
.- 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 ellerNone
. När det anges med något annat änNone
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 tillTrue
konverteras geometrierna tillGEOSGeometry
-objekt. Annars returneras de somOGRGeometry
-objekt:>>> [pt.tuple for pt in layer.get_geoms()] [(-104.609252, 38.255001), (-95.23506, 38.971823), (-95.363151, 29.763374)]
- test_capability(capability)¶
Returnerar ett booleanskt värde som anger om lagret stöder den angivna egenskapen (en sträng). Exempel på giltiga kapacitetssträngar är:
'RandomRead'
,'SequentialWrite'
,'RandomWrite'
,'FastSpatialFilter'
,'FastFeatureCount'
,'FastGetExtent'
,'CreateField'
,'Transactions'
,'DeleteFeature'
och'FastSetNextByIndex'
.
Funktion
¶
- class Feature¶
Feature
omsluter en OGR-funktion. Du skapar aldrig ettFeature
-objekt direkt. Istället hämtar du dem från ettLayer
-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 egenskapgeom
, som returnerar ettOGRGeometry
-objekt. EnFeature
beter sig som en standard Python-behållare för sina fält, som den returnerar somField
-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 enfor
-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 egenskapenLayer.geom_type
i objektetLayer
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 objektetLayer
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 objektetLayer
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 avField
:>>> 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)[source]¶
Klassen
Driver
används internt för att omsluta en OGRDataSource
-drivrutin.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)[source]¶
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, enbuffer
som innehåller WKB-data, eller ettOGRGeomType
-objekt. Dessa objekt returneras också från attributetFeature.geom
när vektordata läses frånLayer
(som i sin tur är en del av enDataSource
).Konstruerar en
OGRGeometry
från den givna GML-strängen.Konstruerar en
Polygon
från den givna bounding-boxen (en 4-tupel).- __len__()¶
Returnerar antalet punkter i en
LineString
, antalet ringar i enPolygon
eller antalet geometrier i enGeometryCollection
. Gäller inte för andra geometrityper.- __iter__()¶
Itererar över punkterna i en
LineString
, ringarna i enPolygon
eller geometrierna i enGeometryCollection
. 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 enPolygon
, eller geometrin vid det angivna indexet i enGeometryCollection
. Gäller inte för andra geometrityper.Returnerar antalet koordinerade dimensioner i geometrin, dvs. 0 för punkter, 1 för linjer osv:
>>> polygon.dimension 2
Returnerar koordinatdimensionen för denna geometri. Värdet är t.ex. 2 för tvådimensionella geometrier.
Ersatt sedan version 5.1: Settern
coord_dim
är föråldrad. Användset_3d()
istället.New in Django 5.1.En boolean som anger om geometrin har Z-koordinater.
New in Django 5.1.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)"
New in Django 5.1.En boolean som anger om geometrin har M-koordinater.
New in Django 5.1.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)"
Returnerar antalet element i denna geometri:
>>> polygon.geom_count 1
New in Django 5.2.En boolean som anger om geometrin är eller innehåller en kurvgeometri.
New in Django 5.2.Returnerar en linjär version av geometrin. Om ingen konvertering kan göras returneras originalgeometrin.
New in Django 5.2.Returnerar en krökt version av geometrin. Om ingen konvertering kan göras returneras originalgeometrin.
Returnerar antalet punkter som används för att beskriva denna geometri:
>>> polygon.point_count 4
Alias för
point_count
.Alias för
point_count
.Returnerar typen av denna geometri, som ett
OGRGeomType
-objekt.Returnerar namnet på typen för denna geometri:
>>> polygon.geom_name 'POLYGON'
Returnerar arean för denna geometri, eller 0 för geometrier som inte innehåller någon area:
>>> polygon.area 25.0
Returnerar kuvertet för denna geometri, som ett
Envelope
-objekt.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¶
Denna egenskap styr den rumsliga referensen för denna geometri, eller
None
om inget rumsligt referenssystem har tilldelats den. Om den är tilldelad returnerar åtkomst till denna egenskap ettSpatialReference
-objekt. Den kan ställas in med ett annatSpatialReference
-objekt, eller någon annan indata somSpatialReference
accepterar. Exempel på detta:>>> city.geom.srs.name 'GCS_WGS_1984'
- srid¶
Returnerar eller anger den identifierare för rumslig referens som motsvarar
SpatialReference
för denna geometri. ReturnerarNone
om det inte finns någon rumslig referensinformation associerad med denna geometri, eller om en SRID inte kan fastställas.Returnerar ett
GEOSGeometry
-objekt som motsvarar denna geometri.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>'
Returnerar en strängrepresentation av denna geometri i HEX WKB-format:
>>> OGRGeometry("POINT(1 2)").hex '0101000000000000000000F03F0000000000000040'
Returnerar en strängrepresentation av denna geometri i JSON-format:
>>> OGRGeometry("POINT(1 2)").json '{ "type": "Point", "coordinates": [ 1.000000, 2.000000 ] }'
Returnerar en strängrepresentation av denna geometri i KML-format.
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
Returnerar en
buffer
som innehåller en WKB-representation av denna geometri.Returnerar en strängrepresentation av denna geometri i WKT-format.
Returnerar EWKT-representationen av denna geometri.
Returnerar en ny
OGRGeometry
-klon av detta geometriobjekt.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)'
Transformerar denna geometri till ett annat rumsligt referenssystem. Kan ta ett
CoordTransform
-objekt, ettSpatialReference
-objekt, eller någon annan indata som accepteras avSpatialReference
(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 tillTrue
returneras istället en transformerad klon av denna geometri.Returnerar
True
om denna geometri skär den andra, annars returnerasFalse
.Returnerar
True
om denna geometri är likvärdig med den andra, annars returnerasFalse
.Returnerar
True
om denna geometri är rumsligt disjunkt med (dvs. inte skär) den andra, annars returnerasFalse
.Returnerar
True
om denna geometri berör den andra, annars returnerasFalse
.Returnerar
True
om denna geometri korsar den andra, annars returnerasFalse
.Returnerar
True
om denna geometri är innesluten i den andra, annars returnerasFalse
.Returnerar
True
om denna geometri innehåller den andra, annars returnerasFalse
.Returnerar
True
om denna geometri överlappar den andra, annars returnerasFalse
.Gränsen för denna geometri, som ett nytt
OGRGeometry
-objekt.Den minsta konvexa polygonen som innehåller denna geometri, som ett nytt
OGRGeometry
-objekt.Returnerar regionen som består av skillnaden mellan den här geometrin och den andra, som ett nytt
OGRGeometry
-objekt.Returnerar regionen som består av skärningspunkten mellan denna geometri och den andra, som ett nytt
OGRGeometry
-objekt.Returnerar den region som består av den symmetriska skillnaden mellan denna geometri och den andra, som ett nytt
OGRGeometry
-objekt.Returnerar den region som består av föreningen av denna geometri och den andra, som ett nytt
OGRGeometry
-objekt.Returnerar en
Point
som representerar geometrins centroid.Changed in Django 5.1:centroid
har flyttats från att vara ett attribut förPolygon
till att vara tillgängligt för alla geometrityper.- 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¶
New in Django 5.1.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¶
New in Django 5.1.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]
OGRGeomType
¶
- class OGRGeomType(type_input)[source]¶
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
Returnerar en kortfattad strängform av OGR Geometry-typen:
>>> gt1.name 'Polygon'
- num¶
Returnerar det nummer som motsvarar OGR-geometritypen:
>>> gt1.num 3
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)[source]¶
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.
Värdet på den minsta X-koordinaten.
Värdet på den maximala X-koordinaten.
Värdet på den minsta Y-koordinaten.
Värdet på den maximala Y-koordinaten.
Den övre högra koordinaten, som en tupel.
Den nedre vänstra koordinaten, som en tupel.
En tupel som representerar kuvertet.
En sträng som representerar detta kuvert som en polygon i WKT-format.
Objekt i koordinatsystem¶
SpatialReference
¶
- class SpatialReference(srs_input)[source]¶
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
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
Attributvärdet för den angivna målnoden (t.ex.
'PROJCS'
). Nyckelordet index anger ett index för den underordnade nod som ska returneras.Returnerar auktoritetsnamnet för den givna strängens målnod.
Returnerar auktoritetskoden för den givna strängens målnod.
Returnerar en klon av detta rumsliga referensobjekt.
Denna metod inspekterar WKT för denna
SpatialReference
och lägger till EPSG-auktoritetsnoder där en EPSG-identifierare är tillämplig.Omvandlar denna SpatialReference från ESRI:s format till EPSG
Morphar denna SpatialReference till ESRI:s format.
Kontrollerar om den angivna rumsliga referensen är giltig, om så inte är fallet kommer ett undantag att uppstå.
Importera rumslig referens från EPSG-kod.
Importera rumslig referens från PROJ-sträng.
Importera rumslig referens från WKT.
Importera rumslig referens från XML.
Returnerar namnet på denna rumsliga referens.
Returnerar SRID för högsta nivåns auktoritet, eller
None
om den inte är definierad.Returnerar namnet på de linjära enheterna.
Returnerar värdet för de linjära enheterna.
Returnerar namnet på vinkelenheterna.”
Returnerar värdet för vinkelenheterna.
Returnerar en 2-tupel av enhetsvärdet och enhetsnamnet och avgör automatiskt om det är linjära enheter eller vinkelenheter som ska returneras.
Returnerar en tupel av ellipsoidparametrarna för denna rumsliga referens: (semimajoraxel, semiminoraxel och invers avplaning).
Returnerar ellipsoidens halva huvudaxel för denna rumsliga referens.
Returnerar ellipsoidens halva mindre axel för denna rumsliga referens.
Returnerar ellipsoidens inversa tillplattning för denna rumsliga referens.
Returnerar
True
om denna rumsliga referens är geografisk (rotnoden ärGEOGCS
).Returnerar
True
om denna rumsliga referens är lokal (rotnoden ärLOCAL_CS
).Returnerar
True
om denna rumsliga referens är ett projicerat koordinatsystem (rotnoden ärPROJCS
).Returnerar WKT-representationen av denna rumsliga referens.
Returnerar den ”vackra” representationen av WKT.
Returnerar PROJ-representationen för denna rumsliga referens.
Alias för
SpatialReference.proj
.Returnerar XML-representationen av denna rumsliga referens.
CoordTransform
¶
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
är ett omslag för GDAL:s rasterkällobjekt som stöder läsning av data från en mängd olika GDAL-stödda geospatiala filformat och datakällor med hjälp av ett konsekvent gränssnitt. Varje datakälla representeras av ett GDALRaster
-objekt som innehåller ett eller flera datalager som kallas band. Varje band, som representeras av ett GDALBand
-objekt, innehåller georefererade bilddata. En RGB-bild representeras t.ex. av tre band: ett för rött, ett för grönt och ett för blått.
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)[source]¶
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
ochrid
. 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[source]¶
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[source]¶
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 enGeoTiff
-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[source]¶
Källans bredd i pixlar (X-axeln).
>>> GDALRaster({"width": 10, "height": 20, "srid": 4326}).width 10
- height[source]¶
Källans höjd i pixlar (Y-axeln).
>>> GDALRaster({"width": 10, "height": 20, "srid": 4326}).height 20
- srs[source]¶
Rastrets rumsliga referenssystem, som en
SpatialReference
-instans. SRS kan ändras genom att ställa in det till en annanSpatialReference
eller genom att tillhandahålla någon indata som accepteras avSpatialReference
konstruktören.>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326}) >>> rst.srs.srid 4326 >>> rst.srs = 3086 >>> rst.srs.srid 3086
- srid[source]¶
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[source]¶
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) ochskew
(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[source]¶
Koordinater för rastrets övre vänstra ursprung i källans rumsliga referenssystem, som ett punktobjekt med
x
ochy
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[source]¶
Pixelbredd och -höjd som används för georeferering av rastret, som ett punktobjekt med
x
ochy
medlemmar. Segeotransform
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[source]¶
Skevhetskoefficienter som används för att georeferera rastret, som ett punktobjekt med
x
ochy
medlemmar. När det gäller bilder från norr är båda dessa koefficienter0
.>>> 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[source]¶
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[source]¶
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)[source]¶
Returnerar en förvrängd version av detta raster.
Warpingparametrarna kan specificeras genom argumentet
ds_input
. Användningen avds_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 ärNearestNeighbor
och de andra tillåtna värdena ärBilinear
,Cubic
,CubicSpline
,Lanczos
,Average
ochMode
.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 kommandoradsverktygetgdalwarp
.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)[source]¶
Transformerar detta raster till ett annat rumsligt referenssystem (
srs
), som kan vara ettSpatialReference
-objekt, eller någon annan indata som accepteras avSpatialReference
(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 argumentendriver
ochname
.Standardalgoritmen för omsampling är
NearestNeighbour
men kan ändras med argumentetresampling
. Det högsta tillåtna standardfelet för omsampling är 0,0 och kan ändras med argumentetmax_error
. Se dokumentationenwarp
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[source]¶
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'}}
GDALBand
¶
- class GDALBand¶
instanser av
GDALBand
skapas inte explicit utan erhålls från ettGDALRaster
-objekt genom dessbands
-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 tillTrue
, 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 argumentetrefresh
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
ochstd
.
- 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
ärTrue
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)¶
Färgtolkningen för bandet, som ett heltal mellan 0 och 16. Om
as_string
ärTrue
returneras datatypen som en sträng med följande möjliga värden: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
ochGCI_YCbCr_CrBand
.GCI_YCbCr_CrBand
representerar ocksåGCI_Max
eftersom båda motsvarar heltalet 16, men endastGCI_YCbCr_CrBand
returneras som en sträng.
- 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 parameterndata
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 parametrarnaoffset
ochsize
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 |
---|---|---|
|
obligatoriskt |
Mappad till attributet |
|
obligatoriskt |
Mappad till attributet |
|
obligatoriskt |
Mappad till attributet |
|
|
Mappad till attributet |
|
|
Se nedan |
|
|
Mappad till attributet |
|
|
Mappad till attributet |
|
|
Mappad till attributet |
|
|
Se nedan |
”antal äkta makar |
|
Se nedan |
|
|
Se nedan |
|
|
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 tillNone
.
- 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 |
---|---|---|
|
|
Mappad till attributet |
|
Samma som |
Överförs till metoden |
|
|
Överförs till metoden |
|
Samma som storlek |
Överförs till metoden |
|
|
Överförs till metoden |
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.
Komprimerade raster¶
Istället för att dekomprimera filen och instansiera det resulterande rastret kan GDAL direkt komma åt komprimerade filer med hjälp av de virtuella filsystemen /vsizip/
, /vsigzip/
eller /vsitar/
:
>>> from django.contrib.gis.gdal import GDALRaster
>>> rst = GDALRaster("/vsizip/path/to/your/file.zip/path/to/raster.tif")
>>> rst = GDALRaster("/vsigzip/path/to/your/file.gz")
>>> rst = GDALRaster("/vsitar/path/to/your/file.tar/path/to/raster.tif")
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).
Inställningar¶
GDAL_BIBLIOTEK_VÄG
¶
En sträng som anger platsen för GDAL-biblioteket. Vanligtvis används denna inställning endast om GDAL-biblioteket finns på en plats som inte är standard (t.ex. /home/john/lib/libgdal.so
).