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

# -s use srid 4326
# -I create spatial index
# -C use standard raster constraints
# -M vacuum analyze after load
# *.tif load all these files
# -F include a filename column in the raster table
# -t tile the output 100x100
# public.demelevation load into this table
raster2pgsql -s 4326 -I -C -M -F -t 100x100 *.tif public.demelevation 
> elev.sql

# -d connect to this database
# -f read this file after connecting
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:

raster2pgsql -s 4326 -I -C -M *.tif -F -t 100x100 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.

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

--get a list of raster types supported:
raster2pgsql -G

Kommandot -G ger en lista ungefär som

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 skulle ringa nedanstående med

http://mywebserver/test_raster.php?srid=2249

för att få rasterbilden i Massachusetts state plane feet.

<?php
/** contents of test_raster.php **/
$conn_str ='dbname=mydb host=localhost port=5432 user=myuser password=mypwd';
$dbconn = pg_connect($conn_str);
header('Content-Type: image/png');
/**If a particular projection was requested use it otherwise use mass state plane meters **/
if (!empty( $_REQUEST['srid'] ) &amp;&amp; is_numeric( $_REQUEST['srid']) ){
                $input_srid = intval($_REQUEST['srid']);
}
else { $input_srid = 26986; }
/** The set bytea_output may be needed for PostgreSQL 9.0+, but not for 8.4 **/
$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 det här avsnittet visar vi hur man använder Npgsql PostgreSQL .NET-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.

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 Section 10.3.1, “PHP-exempel Utdata med ST_AsPNG i kombination med andra rasterfunktioner” men implementerat i C#.

Du skulle ringa nedanstående med

http://mywebserver/TestRaster.ashx?srid=2249

för att få rasterbilden i Massachusetts state plane feet.

 -- web.config connection string section --
<connectionStrings>
    <add name="DSN"
        connectionString="server=localhost;database=mydb;Port=5432;User Id=myuser;password=mypwd"/>
</connectionStrings>

// Code for 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 {
                    using (NpgsqlConnection conn = new NpgsqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["DSN"].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 hjälp av ett kommando ungefär som:

set env CLASSPATH .:..\postgresql-9.0-801.jdbc4.jar
javac SaveQueryImage.java
jar cfm SaveQueryImage.jar Manifest.txt *.class

Och anropa den från kommandoraden med något i stil med

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

// Code for 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;

--write out 5 images to the PostgreSQL server in varying sizes
-- note the postgresql daemon account needs to have write access to folder
-- this echos back the file names created;
 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 inte lättanvänd inbyggd funktionalitet för att mata ut binärer. Det här är lite av ett hack som piggy backar på PostgreSQL något äldre stort objektstöd. För att använda först starta din psql-kommandorad ansluten till din databas.

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);
-- you'll get an output something like --
   oid   | num_bytes
---------+-----------
 2630819 |     74860

-- next note the oid and do this replacing the c:/test.png to file path location
-- on your local computer
 \lo_export 2630819 'C:/temp/aerial_samp.png'

-- this deletes the file from large object storage on db
SELECT lo_unlink(2630819);