Construir una celda temporal que contiene una celda sobre un valor de tiempo

tcell(cell,timestamptz) → tcellInst
tcell(cell,tstzset) → tcellDiscSeq
tcell(cell,tstzspan) → tcellSeq
tcell(cell,tstzspanset) → tcellSeqSet

SELECT th3index(h3index '871fa4418ffffff', timestamptz '2001-01-01');
-- 871fa4418ffffff@2001-01-01
SELECT th3index(h3index '871fa4418ffffff', tstzspan '[2001-01-01, 2001-01-03]');
-- [871fa4418ffffff@2001-01-01, 871fa4418ffffff@2001-01-03]
SELECT tquadbin(quadbin '48a6227affffffff', timestamptz '2001-01-01');
-- 48a6227affffffff@2001-01-01
SELECT tquadbin(quadbin '48a6227affffffff', tstzspan '[2001-01-01, 2001-01-03]');
-- [48a6227affffffff@2001-01-01, 48a6227affffffff@2001-01-03]
SELECT ts2cell(s2cell '47c3c', timestamptz '2001-01-01');
-- 47c3c@2001-01-01
SELECT ts2cell(s2cell '47c3c', tstzspan '[2001-01-01, 2001-01-03]');
-- [47c3c@2001-01-01, 47c3c@2001-01-03]

Construir una celda temporal de un subtipo dado a partir de sus componentes

tcellInst(tcell) → tcellInst
tcellSeq(tcell[],interp text='step') → tcellSeq
tcellSeqSet(tcell[]) → tcellSeqSet

SELECT th3indexSeq(ARRAY[th3index '871fa4418ffffff@2001-01-01',
  th3index '871fa44a8ffffff@2001-01-02'], 'step');
-- [871fa4418ffffff@2001-01-01, 871fa44a8ffffff@2001-01-02]
SELECT tquadbinSeq(ARRAY[tquadbin '48a6227affffffff@2001-01-01',
  tquadbin '485623ffffffffff@2001-01-02'], 'step');
-- [48a6227affffffff@2001-01-01, 485623ffffffffff@2001-01-02]
SELECT ts2cellSeq(ARRAY[ts2cell '47c3c@2001-01-01', ts2cell '47c4@2001-01-02'], 'step');
-- [47c3c@2001-01-01, 47c4@2001-01-02]

Construye una tesela ráster Raquet a partir de sus bytes de píxeles, dimensiones, celda QUADBIN y tipo de píxel

raquet(bytea,width integer,height integer,quadbin,pixtype text,
  nodata float) → raquet

Empaqueta un arreglo de píxeles pixels de banda única en orden de fila mayor de width × height píxeles de tipo pixtype (uno de uint8, int8, uint16, int16, uint32, int32, uint64, int64, float16, float32 o float64), georreferenciado por la celda quadbin, en un único valor raquet autodescriptivo. El argumento nodata es opcional; cuando se omite (NULL) la tesela no lleva valor centinela de nodata. Se genera un error cuando el arreglo pixels es menor que width × height × el tamaño del píxel. Los píxeles de más de un byte son little-endian, que es el orden de bytes que les da la especificación RaQuet sea cual sea el orden de bytes del servidor, de modo que una tesela conserva sus valores cuando se lee en otra máquina. Un raquet es un valor de longitud variable, libre de GDAL, con una representación portátil en texto Hex-WKB y binaria, distinto de y coexistente con el tipo raster de PostGIS usado por rasterValue. Una tabla Raquet indica las dimensiones, el tipo de píxel y el valor nodata de sus teselas una sola vez, en la fila de metadatos en block = 0, que la consulta siguiente lee y deja fuera de las teselas: 0 no es un índice QUADBIN, por lo que la conversión a quadbin lo rechaza. El constructor lee los bytes de píxel tal como están, por lo que las bandas de un archivo Raquet cuyos metadatos indican una compresión gzip se descomprimen antes de llegar a él.

-- Package the tiles of a Raquet table, whose band_1 column is uncompressed,
-- into raquet values keyed by their QUADBIN cell
CREATE TABLE elevation_tiles AS
SELECT r.block::quadbin AS quadbin, raquet(r.band_1,
    (m.meta->'tiling'->>'block_width')::integer,
    (m.meta->'tiling'->>'block_height')::integer, r.block::quadbin,
    m.meta->'bands'->0->>'type', (m.meta->'bands'->0->>'nodata')::float8) AS tile
FROM elevation_raquet r,
  (SELECT metadata::jsonb AS meta FROM elevation_raquet WHERE block = 0 LIMIT 1) m
WHERE r.block <> 0;
-- A 2 x 2 UINT8 tile with no nodata
SELECT raquet('\x01020304'::bytea, 2, 2, quadbin '4817ffffffffffff', 'uint8');

Construye un ráster de una banda a partir de los bytes de sus píxeles y de su georreferenciación

raster(pixels bytea,width integer,height integer,upperleftx float,upperlefty float,
  scalex float,scaley float,skewx float,skewy float,srid integer,pixeltype text,
  nodataval float=NULL) → raster

El gemelo del constructor raquet para un raster de PostGIS, en el que la georreferenciación de un ráster ocupa el lugar de la celda QUADBIN de una tesela. Los pixels son los que devuelve pixels: fila a fila, cada uno en los bytes de su tipo, en little-endian cuando ocupa más de un byte, y un byte para los tipos 1BB, 2BUI y 4BUI, que acotan un píxel a menos de un byte. El pixeltype se nombra como lo nombra PostGIS, 8BUI, 16BSI, 32BF, etc., o como lo devuelve bandPixelType, donde el nombre uint8 designa 8BUI. Una banda ráster no tiene flotante de 16 bits ni entero de 64 bits, por lo que se rechazan float16, int64 y uint64, así como unos bytes de otro número que el que ocupan los píxeles y un byte que supera la cota de un tipo que acota un píxel a menos de un byte. El nodataval es opcional; cuando se omite, la banda no indica valor nodata. Un ráster de una banda es el ráster construido a partir de sus propios píxeles y su georreferenciación, raster(pixels(r), width(r), height(r), upperLeftX(r), upperLeftY(r), scaleX(r), scaleY(r), skewX(r), skewY(r), SRID(r), bandPixelType(r), bandNoDataValue(r)), y conserva exactamente cada valor que contiene. Una banda de 1BB, 2BUI o 4BUI ocupa un byte por píxel, como una de 8BUI, y bandPixelType la nombra uint8, por lo que se reconstruye como 8BUI con los mismos bytes, siendo la cota que indica su nombre lo único que pierde. Las demás bandas se añaden con addBand.

SELECT dumpValues(raster('\x0100feff2c010080'::bytea, 2, 2, 0, 2, 1, -1, 0, 0,
  3857, '16BSI'), 1);
-- {{1,-2},{300,-32768}}

Construye un ráster sin banda

makeEmptyRaster(width integer,height integer,upperleftx float,upperlefty float,
  scalex float,scaley float,skewx float,skewy float,srid integer=0) → raster

El ráster que devuelve ST_MakeEmptyRaster de PostGIS: una cuadrícula de width × height píxeles, cada dimensión de 0 a 65535, georreferenciada por su esquina superior izquierda, su escala y su sesgo en el sistema de referencia espacial srid.

SELECT width(r), height(r), numBands(r), scaleX(r)
FROM (SELECT makeEmptyRaster(3, 2, 10, 20, 2, -1, 0, 0, 3857) AS r) t;
-- 3 | 2 | 0 | 2

Añade una banda a un ráster

addBand(rast raster,index integer,pixeltype text,initialvalue float=0,
  nodataval float=NULL) → raster
addBand(torast raster,fromrast raster,fromband integer=1,
  torastindex integer=NULL) → raster

El ráster que devuelve ST_AddBand de PostGIS. La primera forma añade una banda de tipo pixeltype, nombrado como lo lee raster, en la que cada píxel contiene initialvalue, y que indica el valor nodata nodataval o ninguno cuando se omite. La segunda forma añade una copia de la banda fromband de fromrast, un ráster del mismo ancho y alto. La banda toma el número index o torastindex, de 1 a uno más que el número de bandas del ráster, y se añade tras la última banda cuando el número es NULL, escrito NULL::integer en la primera forma para que no se lea como un ráster de la segunda. Se rechazan un número fuera de ese rango, una banda que fromrast no tiene y un ráster de otro tamaño, allí donde PostGIS añade la banda en otro lugar o devuelve el ráster sin cambios.

SELECT numBands(r), bandPixelType(r, 1), bandNoDataValue(r, 2)
FROM (SELECT addBand(addBand(makeEmptyRaster(2, 2, 0, 2, 1, -1, 0, 0, 3857),
  NULL::integer, '8BUI', 1), 1, '32BF', 0, -9999) AS r) t;
-- 2 | float32 | NULL
SELECT numBands(addBand(r, r))
FROM (SELECT addBand(makeEmptyRaster(2, 2, 0, 2, 1, -1, 0, 0, 3857),
  NULL::integer, '8BUI', 1) AS r) t;
-- 2

Decodifica un archivo ráster en una tesela ráster Raquet mediante GDAL

raquetRead(bytea,quadbin) → raquet
raquetRead(text,quadbin) → raquet

Lee los bytes de rasterfile, un ráster en cualquier formato compatible con GDAL (GeoTIFF, PNG, …), a través del sistema de archivos virtual /vsimem/ de GDAL, y empaqueta su primera banda, en orden de fila mayor, en un único valor raquet autodescriptivo georreferenciado por la celda quadbin. El tipo de datos de la banda debe ser uno de Byte, Int16, Int32, Float32 o Float64; el valor de nodata de la banda, cuando está definido, se traslada a la tesela. Como el archivo se suministra como bytes, no se requiere acceso a archivos del lado del servidor. GDAL realiza la decodificación, por lo que el controlador de formato del ráster debe estar permitido por la configuración postgis.gdal_enabled_drivers de PostGIS (que deshabilita todos los controladores de forma predeterminada); habilítelo con, por ejemplo, SET postgis.gdal_enabled_drivers = 'ENABLE_ALL'. Esta es la contraparte de ingesta del constructor raquet, que construye una tesela a partir de bytes de píxeles ya decodificados. Cuando se omite quadbin o es NULL, el identificador de la tesela se deriva de la georreferenciación del ráster: el ráster debe llevar una referencia espacial EPSG:3857 (Web-Mercator) y una geotransformación alineada con los ejes que describa una única tesela QUADBIN. Un ráster sin referencia espacial, uno que no esté en EPSG:3857, o una geotransformación rotada o no alineada con la cuadrícula de teselas provoca un error en lugar de ser forzado. La forma que recibe text lee en su lugar el archivo ráster del servidor en esa ruta, allí donde PostGIS permite leer una banda ráster almacenada fuera de la base de datos, como indica rasterValue.

-- Decode a GeoTIFF stored in a bytea column into a raquet tile
SELECT raquetRead(file_bytes, quadbin) AS tile FROM elevation_files;
-- Derive the QUADBIN cell from an EPSG:3857 GeoTIFF's georeferencing
SELECT raquetRead(file_bytes) AS tile FROM elevation_files;