Kapitel 10. Rasterdatahantering, frågor och applikationer

Raster2pgsql är en körbar rasterläsa inre som läsa inr GDAL-stödda rasterformat till SQL som lämpar sig för laddning i en PostGIS-rastertabell. Den kan läsa in mappar med rasterfiler samt skapa översikter över raster.

Eftersom raster2pgsql oftast kompileras som en del av PostGIS (om du inte kompilerar ditt eget GDAL-bibliotek), kommer de rastertyper som stöds av den körbara filen att vara desamma som de som kompileras i GDAL-beroendebiblioteket. För att få en lista över rastertyper som just din raster2pgsql stöder, använd -G-omkopplaren.

	När du skapar översikter över en viss faktor från en uppsättning raster som är anpassade är det möjligt att översikterna inte är anpassade. Besök http://trac.osgeo.org/postgis/ticket/1764 för ett exempel där översikterna inte är i linje.

10.1.1.1. Exempel på användning

Ett exempel på en session där laddaren används för att skapa en inmatningsfil och ladda upp den i 100x100 bitar kan se ut så här:

Inläsaren tilldelar SRID 4326, skapar ett index och standardbegränsningar, analyserar den inlästa tabellen, registrerar källfilnamn och lagrar indatarastren i rutor på 100×100 pixlar.

Kod

Kopiera

raster2pgsql -s 4326 -I -C -M -F -t 100x100 *.tif public.demelevation 
> elev.sql
psql -d gisdb -f elev.sql

	Om du inte anger schemat som en del av måltabellens namn kommer tabellen att skapas i standardschemat för den databas eller användare som du ansluter till.

En konvertering och uppladdning kan göras i ett steg med hjälp av UNIX pipes:

Kod

Kopiera

raster2pgsql -s 4326 -I -C -M -F -t 100x100 \
  *.tif public.demelevation |
  psql -d gisdb

Läs in raster Massachusetts statliga planmätare flygplattor i ett schema som heter aerial och skapa en fullständig vy, 2 och 4 nivå översiktstabeller, använd kopieringsläge för att infoga (ingen mellanliggande fil bara direkt till db) och -e tvingar inte allt i en transaktion (bra om du vill se data i tabeller direkt utan att vänta). Dela upp rastren i 128x128 pixelplattor och tillämpa rasterbegränsningar. Använd kopieringsläge i stället för tabellinsättning. (-F) Inkludera ett fält som heter filename för att innehålla namnet på filen som plattorna klipptes ut från.

Kod

Kopiera

raster2pgsql -I -C -e -Y -F -s 26986 -t 128x128 -l 2,4 \
  bostonaerials2008/*.jpg aerials.boston |
  psql -U postgres -d gisdb -h localhost -p 5432

Lista de rasterformat som stöds av det här bygget:

Kod

Kopiera

raster2pgsql -G

Kommandot -G matar ut en lista som liknar:

Utdata

Available GDAL raster formats:
  Virtual Raster
  GeoTIFF
  National Imagery Transmission Format
  Raster Product Format TOC format
  ECRG TOC format
  Erdas Imagine Images (.img)
  CEOS SAR Image
  CEOS Image
  ...
  Arc/Info Export E00 GRID
  ZMap Plus Grid
  NOAA NGS Geoid Height Grids

Vid många tillfällen vill du skapa raster och rastertabeller direkt i databasen. Det finns en uppsjö av funktioner för att göra det. De allmänna stegen att följa.

Verktyget raster2pgsql använder GDAL för att få åtkomst till rasterdata och kan dra nytta av en viktig GDAL-funktion: möjligheten att läsa från raster som lagras på distans i molnbaserade "objektlager" (t.ex. AWS S3, Google Cloud Storage).

Effektiv användning av molnlagrade raster kräver att man använder ett "molnoptimerat" format. Det mest välkända och använda är det"molnoptimerade GeoTIFF"-formatet. Om du använder ett format som inte är molnbaserat, t.ex. JPEG eller en TIFF som inte är kaklad, får du mycket dåliga prestanda eftersom systemet måste ladda ner hela rastret varje gång det behöver komma åt en delmängd.

Först laddar du ditt raster i den molnlagring du väljer. När den har laddats kommer du att ha en URI för att komma åt den, antingen en "http"-URI eller ibland en URI som är specifik för tjänsten. (t.ex. "s3://bucket/object"). Om du vill komma åt icke-offentliga buckets måste du ange GDAL-konfigurationsalternativ för att autentisera din anslutning. Observera att det här kommandot läser från molnrastret och skriver till databasen.

AWS_ACCESS_KEY_ID=xxxxxxxxxxxxxxxxxxxx \
AWS_SECRET_ACCESS_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \
raster2pgsql \
  -s 990000 \
  -t 256x256 \
  -I \
  -R \
  /vsis3/your.bucket.com/your_file.tif \
  your_table \
  | psql your_db

När tabellen har laddats måste du ge databasen behörighet att läsa från fjärraster genom att ange två behörigheter, postgis.enable_outdb_rasters och postgis.gdal_enabled_drivers.

SET postgis.enable_outdb_rasters = true;
SET postgis.gdal_enabled_drivers TO 'ENABLE_ALL';
    

För att ändringarna ska bli bestående kan du göra dem direkt i din databas. Du måste återansluta för att uppleva de nya inställningarna.

ALTER DATABASE your_db SET postgis.enable_outdb_rasters = true;
ALTER DATABASE your_db SET postgis.gdal_enabled_drivers TO 'ENABLE_ALL';
    

För icke-publika raster kan du behöva ange åtkomstnycklar för att läsa från molnrastern. Samma nycklar som du använde för att skriva raster2pgsql-anropet kan ställas in för användning i databasen med postgis.gdal_vsi_options -konfigurationen. Observera att flera alternativ kan ställas in genom att mellanslag separerar nyckel=värde-paren.

SET postgis.gdal_vsi_options = 'AWS_ACCESS_KEY_ID=xxxxxxxxxxxxxxxxxxxx
AWS_SECRET_ACCESS_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';

När du har laddat data och ställt in behörigheter kan du interagera med rastertabellen som med vilken annan rastertabell som helst och använda samma funktioner. Databasen hanterar all mekanik för att ansluta till molndata när den behöver läsa pixeldata.

Raster_columns är en katalog över alla kolumner i rastertabeller i databasen som är av typen raster. Det är en vy som utnyttjar begränsningarna i tabellerna så att informationen alltid är konsekvent även om du återställer en rastertabell från en säkerhetskopia av en annan databas. Följande kolumner finns i katalogen raster_columns.

Om du inte skapade dina tabeller med inläsningsprogrammet eller glömde att ange flaggan -C under inläsningen kan du genomdriva begränsningarna i efterhand med hjälp av AddRasterConstraints så att raster_columns-katalogen registrerar den gemensamma informationen om dina rasterplattor.

raster_overviews katalogiserar information om rastertabellkolumner som används för översikter och ytterligare information om dem som är bra att känna till när man använder översikter. Översiktstabeller katalogiseras i både raster_columns och raster_overviews eftersom de är rastertabeller i sig själva men också har ett särskilt syfte, nämligen att vara en karikatyr med lägre upplösning av en tabell med högre upplösning. Dessa genereras tillsammans med huvudrastertabellen när du använder -l-omkopplaren i rasterladdningen eller kan genereras manuellt med AddOverviewConstraints.

Översiktstabeller innehåller samma begränsningar som andra rastertabeller samt ytterligare begränsningar som endast gäller information och som är specifika för översikter.

	Informationen i raster_overviews duplicerar inte informationen i raster_columns. Om du behöver information om en översiktstabell som finns i raster_columns kan du koppla ihop raster_overviews och raster_columns för att få den fullständiga information du behöver.

Två huvudskäl till översikter är:

Katalogen raster_overviews innehåller följande kolumner med information.

I det här avsnittet kommer vi att visa hur man använder PHP PostgreSQL-drivrutinen och ST_AsGDALRaster -familjen av funktioner för att mata ut band 1,2,3 av en raster till en PHP-förfrågningsström som sedan kan bäddas in i en img src html-tagg.

Exempelfrågan visar hur man kombinerar ett helt gäng rasterfunktioner tillsammans för att ta tag i alla plattor som skär en viss wgs 84 avgränsningsbox och sedan förenar med ST_Union de korsande plattorna tillsammans och returnerar alla band, transformerar till användarens angivna projektion med ST_Transform och sedan matar ut resultaten som en png med ST_AsPNG.

Du anropar skriptet med http://mywebserver/test_raster.php?srid=2249 för att få rasterbilden i Massachusetts State Plane-fot.

<?php
$conn_str = 'dbname=mydb host=localhost port=5432 user=myuser password=mypwd';
$dbconn = pg_connect($conn_str);
header('Content-Type: image/png');

if (!empty($_REQUEST['srid']) &amp;&amp; is_numeric($_REQUEST['srid'])) {
    $input_srid = intval($_REQUEST['srid']);
} else {
    $input_srid = 26986;
}

$sql = "SET bytea_output = 'escape';
SELECT ST_AsPNG(
    ST_Transform(
        ST_AddBand(
            ST_Union(rast, 1),
            ARRAY[ST_Union(rast, 2), ST_Union(rast, 3)]
        ),
        $input_srid
    )
) AS new_rast
FROM aerials.boston
WHERE ST_Intersects(
    rast,
    ST_Transform(
        ST_MakeEnvelope(-71.1217, 42.227, -71.1210, 42.218, 4326),
        26986
    )
)";

$result = pg_query($sql);
$row = pg_fetch_row($result);
pg_free_result($result);
if ($row === false) return;
echo pg_unescape_bytea($row[0]);
?>

I detta avsnitt visar vi hur Npgsql PostgreSQL .NET-drivrutinen och funktionsfamiljen ST_AsGDALRaster kan användas för att mata ut band 1, 2 och 3 i ett raster till HTTP-svarsströmmen så att det kan bäddas in i en img-tagg.

Du behöver npgsql .NET PostgreSQL-drivrutinen för den här övningen som du kan få det senaste från http://npgsql.projects.postgresql.org/. Ladda bara ner det senaste och släpp in i din ASP.NET bin-mapp så är du redo att gå.

Exempelfrågan visar hur man kombinerar ett helt gäng rasterfunktioner tillsammans för att ta tag i alla plattor som skär en viss wgs 84 avgränsningsbox och sedan förenar med ST_Union de korsande plattorna tillsammans och returnerar alla band, transformerar till användarens angivna projektion med ST_Transform och sedan matar ut resultaten som en png med ST_AsPNG.

Detta är samma exempel som Avsnitt 10.4.1, ”PHP-exempel Utdata med ST_AsPNG i kombination med andra rasterfunktioner” men implementerat i C#.

Du anropar hanteraren med http://mywebserver/TestRaster.ashx?srid=2249 för att få rasterbilden i Massachusetts State Plane-fot.

Avsnittet för anslutningssträng i web.config:

<connectionStrings>
    <add name="DSN"
        connectionString="server=localhost;database=mydb;Port=5432;User Id=myuser;password=mypwd"/>
</connectionStrings>

Kod för TestRaster.ashx:

<%@ WebHandler Language="C#" Class="TestRaster" %>
using System;
using System.Data;
using System.Web;
using Npgsql;

public class TestRaster : IHttpHandler
{
    public void ProcessRequest(HttpContext context)
    {
        context.Response.ContentType = "image/png";
        context.Response.BinaryWrite(GetResults(context));
    }

    public bool IsReusable {
        get { return false; }
    }

    public byte[] GetResults(HttpContext context)
    {
        byte[] result = null;
        NpgsqlCommand command;
        string sql = null;
        int input_srid = 26986;
        try {
            string connectionString = System.Configuration.ConfigurationManager
                .ConnectionStrings["DSN"].ConnectionString;
            using (NpgsqlConnection conn = new NpgsqlConnection(connectionString)) {
                conn.Open();

                if (context.Request["srid"] != null)
                {
                    input_srid = Convert.ToInt32(context.Request["srid"]);
                }
                sql = @"SELECT ST_AsPNG(
                            ST_Transform(
                                ST_AddBand(
                                    ST_Union(rast, 1),
                                    ARRAY[ST_Union(rast, 2), ST_Union(rast, 3)]
                                ),
                                :input_srid
                            )
                        ) As new_rast
                        FROM aerials.boston
                        WHERE ST_Intersects(
                            rast,
                            ST_Transform(
                                ST_MakeEnvelope(
                                    -71.1217, 42.227,
                                    -71.1210, 42.218,
                                    4326
                                ),
                                26986
                            )
                        )";
                command = new NpgsqlCommand(sql, conn);
                command.Parameters.Add(new NpgsqlParameter("input_srid", input_srid));


                result = (byte[]) command.ExecuteScalar();
                conn.Close();
            }

        }
        catch (Exception ex)
        {
            result = null;
            context.Response.Write(ex.Message.Trim());
        }
        return result;
    }
}

Detta är en enkel java-konsolapp som tar en fråga som returnerar en bild och matar ut till den angivna filen.

Du kan ladda ner de senaste PostgreSQL JDBC-drivrutinerna från http://jdbc.postgresql.org/download.html

Du kan kompilera följande kod med kommandon som:

CLASSPATH=".:../postgresql.jar" javac SaveQueryImage.java
jar cfm SaveQueryImage.jar Manifest.txt *.class

Och anropa den från kommandoraden med något som:

java -jar SaveQueryImage.jar \
  "SELECT ST_AsPNG(ST_AsRaster(ST_Buffer(ST_Point(1, 5), 10, 'quad_segs=2'), 150, 150, '8BUI', 100));" \
  "test.png"

Manifest.txt:

Class-Path: postgresql-9.0-801.jdbc4.jar
Main-Class: SaveQueryImage

Kod för SaveQueryImage.java:

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.io.*;

public class SaveQueryImage {
  public static void main(String[] argv) {
      System.out.println("Checking if Driver is registered with DriverManager.");

      try {
        //java.sql.DriverManager.registerDriver (new org.postgresql.Driver());
        Class.forName("org.postgresql.Driver");
      }
      catch (ClassNotFoundException cnfe) {
        System.out.println("Couldn't find the driver!");
        cnfe.printStackTrace();
        System.exit(1);
      }

      Connection conn = null;

      try {
        conn = DriverManager.getConnection("jdbc:postgresql://localhost:5432/mydb", "myuser", "mypwd");
        conn.setAutoCommit(false);

        PreparedStatement sGetImg = conn.prepareStatement(argv[0]);

        ResultSet rs = sGetImg.executeQuery();

        FileOutputStream fout;
        try
        {
            rs.next();
            /** Output to file name requested by user **/
            fout = new FileOutputStream(new File(argv[1]) );
            fout.write(rs.getBytes(1));
            fout.close();
        }
        catch(Exception e)
        {
            System.out.println("Can't create file");
            e.printStackTrace();
        }

        rs.close();
        sGetImg.close();
        conn.close();
      }
      catch (SQLException se) {
        System.out.println("Couldn't connect: print out a stack trace and exit.");
        se.printStackTrace();
        System.exit(1);
      }
  }
}

Detta är en plpython-lagrad funktion som skapar en fil i serverkatalogen för varje post. Kräver att du har plpython installerat. Bör fungera bra med både plpythonu och plpython3u.

CREATE OR REPLACE FUNCTION write_file (param_bytes bytea, param_filepath text)
RETURNS text
AS $$
f = open(param_filepath, 'wb+')
f.write(param_bytes)
return param_filepath
$$ LANGUAGE plpythonu;

Skriv ut 5 bilder till PostgreSQL-servern i varierande storlekar. PostgreSQL-demonens konto behöver skrivåtkomst till mappen; detta ekar tillbaka de skapade filnamnen.

SELECT write_file(
    ST_AsPNG(
        ST_AsRaster(
            ST_Buffer(ST_Point(1, 5), j * 5, 'quad_segs=2'),
            150 * j,
            150 * j,
            '8BUI',
            100
        )
    ),
    'C:/temp/slices' || j || '.png'
)
FROM generate_series(1, 5) AS j;

write_file
---------------------
 C:/temp/slices1.png
 C:/temp/slices2.png
 C:/temp/slices3.png
 C:/temp/slices4.png
 C:/temp/slices5.png

Tyvärr har PSQL ingen lättanvänd inbyggd funktion för att mata ut binärdata. Detta är ett slags hack som bygger på PostgreSQL:s något äldre stöd för stora objekt. För att använda det startar du först kommandoraden psql ansluten till databasen.

Till skillnad från pythonmetoden skapas filen här på din lokala dator.

SELECT
    oid,
    lowrite(lo_open(oid, 131072), png) AS num_bytes
FROM (VALUES (
    lo_create(0),
    ST_AsPNG((SELECT rast FROM aerials.boston WHERE rid = 1))
)) AS v(oid, png);

oid   | num_bytes
---------+-----------
 2630819 |     74860

Notera OID för det stora objektet och exportera det till en fil på den lokala datorn. Ersätt exempelsökvägen med den önskade filsökvägen.

\lo_export 2630819 'C:/temp/aerial_samp.png'

Detta tar bort filen från lagringen för stora objekt i databasen.

SELECT lo_unlink(2630819);