Operaciones específicas de ráster

Operaciones específicas de ráster
Anterior	Capítulo 16. Teselaciones temporales	Siguiente

Las secciones anteriores enuncian lo que un ráster comparte con las demás teselaciones. Las operaciones siguientes son propias del ráster: una celda de ráster lleva un valor donde una celda H3, QUADBIN o S2 lleva solo identidad, de modo que una trayectoria leída contra un ráster responde un tfloat en lugar de una celda temporal.

El operador de muestreo de ráster de MobilityDB lee una banda de ráster a lo largo de una trayectoria de punto móvil y devuelve un tfloat. Una posición fuera de la extensión del ráster o sobre un píxel nodata no lleva valor. Los operadores de muestreo son de valor doble sea cual sea el tipo de píxel de la banda, de modo que un tipo de píxel pertenece a la superficie de muestreo cuando todo valor que puede contener es exactamente representable en un número de doble precisión. Eso es lo que permite muestrear una banda de cualquier tipo en un único tfloat, y que una columna con teselas de varios tipos de píxel se lea con una sola consulta. Un tipo de píxel también se acepta con el nombre que le da el ráster de PostGIS, de modo que el tipo de banda que informa una llamada a ST_BandPixelType (8BUI, 16BSI, 32BF, …) se pasa a los constructores de teselas tal cual. El ráster de PostGIS no lleva flotantes de 16 bits ni enteros de 64 bits, así que float16, int64 y uint64 toman la grafía que da su gramática, 16BF, 64BSI y 64BUI. Sus tipos 1BB, 2BUI y 4BUI acotan un píxel a menos de un byte mientras que PostGIS almacena cada uno de ellos a un byte por píxel, de modo que tal banda ya son los bytes de una banda de 8 bits sin signo y los constructores la leen como uint8; la cota es lo único que añade el nombre, y una tesela no la lleva. El nombre que informa una tesela es el que la especificación RaQuet da al tipo. Los tipos uint64 e int64 contienen valores fuera de ese dominio: una tesela de cualquiera de ellos se almacena y se vuelve a leer exactamente, mientras que muestrear un píxel cuyo valor ningún número de doble precisión nombra genera un error en lugar de responder con un valor vecino. Esto permite consultas como ¿qué perfil de elevación siguió cada vehículo? o ¿qué viajes entraron en una banda de umbral de temperatura?

El patrón de consulta típico une una trayectoria con una tabla Raquet en dos pasos:

-- Step 1: identify which tiles the trajectory overlaps
SELECT DISTINCT q FROM unnest(quadbins(traj, 8)) AS q;
-- Step 2: sample each matching tile
SELECT rasterTileValueQuadbin(traj, band_data, width, height, quadbin, 'float32', nodata,
  true) FROM elevation_raquet WHERE quadbin = ANY(quadbins(traj, 8));

Los operadores de restricción y predicado que cierran la sección componen rasterValue con las funciones estándar de restricción temporal y predicado de MobilityDB. Aceptan un argumento opcional band (por defecto 1) e invocan rasterValue exactamente una vez por invocación.

Una función de ráster toma el nombre de su homóloga del ráster de PostGIS sin el prefijo ST_, y los nombres y los valores por defecto de sus argumentos. Una sola signatura responde a cada operación, de modo que una forma de PostGIS que solo fija un argumento de otra se escribe mediante esa otra forma. Un nombre que el estándar SQL reserva toma el tipo como prefijo, de modo que ST_Value es rasterValue, y las funciones de Well-Known Binary toman los nombres que toma todo tipo de MobilityDB.

Ráster de PostGIS	MobilityDB
`ST_Value`	`rasterValue`
`ST_Clip`	`clip`
`ST_Transform`	`transform`
`ST_Rescale`	`rescale`
`ST_Reclass`	`reclass`
`ST_SummaryStats`	`summaryStats`
`ST_DumpAsPolygons`	`dumpAsPolygons`
`ST_NumBands`, `ST_Width`, `ST_Height`, `ST_SRID`	`numBands`, `width`, `height`, `SRID`
`ST_UpperLeftX`, `ST_UpperLeftY`, `ST_ScaleX`, `ST_ScaleY`, `ST_SkewX`, `ST_SkewY`	`upperLeftX`, `upperLeftY`, `scaleX`, `scaleY`, `skewX`, `skewY`
`ST_BandPixelType`, `ST_BandNoDataValue`	`bandPixelType`, `bandNoDataValue`
`ST_AsBinary`, `ST_AsHexWKB`	`asBinary`, `asHexWKB`
`ST_RastFromWKB`, `ST_RastFromHexWKB`	`rasterFromBinary`, `rasterFromHexWKB`

asBinary y asHexWKB toman un orden de bytes donde PostGIS toma outasin, y sin él devuelven los bytes de ST_AsBinary y ST_AsHexWKB.

Lee una banda de ráster a lo largo de una trayectoria
```
rasterValue(tgeompoint,rast raster,band integer=1,exclude_nodata_value boolean=true,
  resample text='nearest') → tfloat
rasterValue(tgeompoint,path text,band integer=1) → tfloat
```
Lee la banda band a lo largo de traj, tomando el valor del píxel en el que cae cada posición. Una trayectoria que no afirma nada entre sus instantes se lee en sus instantes y devuelve un tfloat de conjunto de instantes. Una trayectoria que se mueve entre ellos pasa por los píxeles intermedios, por lo que cada segmento se recorre píxel a píxel, y devuelve un tfloat escalonado que mantiene cada valor desde el instante en que el trayecto alcanza el píxel que lo contiene, incluido un píxel del que el trayecto solo corta una esquina. Una posición fuera del ráster o sobre un píxel sin datos no lleva valor y termina el tramo, por lo que un trayecto que sale y vuelve a entrar en el ráster devuelve una secuencia por visita, y NULL cuando nunca encuentra un píxel con datos. Una banda cuyos píxeles no se pueden leer, como una banda almacenada fuera de la base de datos en un archivo que no se puede abrir, provoca un error en lugar de leerse como una banda sin valores. La forma que recibe path lee un archivo ráster del servidor, en cualquier formato compatible con GDAL, mediante GDAL, allí donde PostGIS permite leer una banda ráster almacenada fuera de la base de datos: postgis.enable_outdb_rasters debe estar activado y postgis.gdal_enabled_drivers debe habilitar el controlador del archivo. Devuelve lo que la forma que recibe un raster devuelve sobre el mismo ráster.
exclude_nodata_value y resample son los de ST_Value de PostGIS: con el primero falso una posición sobre un píxel nodata conserva el valor nodata donde de otro modo se descarta, y el segundo lee el píxel bajo la posición con nearest o bilinear, nombrado sin distinguir mayúsculas de minúsculas. Un valor bilineal varía dentro de un píxel, de modo que a lo largo de una trayectoria que se desplaza entre sus instantes varía cuadráticamente en el tiempo, lo que un tfloat no puede expresar, y tal trayectoria genera un error con bilinear.
```
-- Build a 3x3 synthetic elevation raster (SRID 4326, 1 degree pixels)
WITH rast AS (
  SELECT ST_SetValues(ST_AddBand( ST_MakeEmptyRaster(3, 3, 0.0, 3.0, 1.0, -1.0, 0.0, 0.0,
    4326), '32BF'::text, 0.0::float8, NULL::float8), 1, 1, 1,
    ARRAY[[10.0::float4, 20.0::float4, 30.0::float4],
    [40.0::float4, 50.0::float4, 60.0::float4],
    [70.0::float4, 80.0::float4, 90.0::float4]]) AS r )
SELECT rasterValue(tgeompoint 'SRID=4326;[POINT(0.5 2.5)@2001-01-01,
  POINT(2.5 2.5)@2001-01-02, POINT(0.5 0.5)@2001-01-03]', r)::text FROM rast;
/* Interp=Step;[10@2001-01-01, 20@2001-01-01 06:00:00, 30@2001-01-01 18:00:00,
   50@2001-01-02 06:00:00, 70@2001-01-02 18:00:00, 70@2001-01-03] */
```
Aplicado a un conjunto de datos de trayectorias con un ráster de elevación del terreno:
```
-- Elevation profile per trip (requires a loaded elevation raster)
SELECT tripid, rasterValue(trip, elev) AS elevation FROM trips, elevation_raster;
-- Average elevation per trip
SELECT tripid, avgValue(rasterValue(trip, elev)) AS mean_elev FROM trips,
  elevation_raster;
-- Trips that crossed terrain above 200 m
SELECT tripid FROM trips, elevation_raster
WHERE atSpan(rasterValue(trip, elev), floatspan '[200, 9999]') IS NOT NULL;
```

Devuelve un ráster cuya banda contiene las clases a las que una expresión asigna sus valores

reclass(raster,nband integer,reclassexpr text,pixeltype text,nodataval float8=NULL)
  → raster

La expresión sigue la gramática de ST_Reclass de PostGIS: una lista de asignaciones separadas por comas, cada una un rango de origen y un destino separados por dos puntos, siendo un rango un valor o dos separados por un guion. Un rango escrito sin corchetes incluye su extremo inferior y excluye el superior, mientras que ( excluye el extremo inferior y ] incluye el superior, de modo que 0-50 deja 50 sin asignar mientras que [50-100] lo toma. Un píxel que ningún rango toma contiene el valor nodata de la banda resultante, o cero cuando la banda no declara ninguno. Esa banda tiene el tipo de píxel pixeltype, con el nombre que le da PostGIS raster, como 8BUI, y no declara valor nodata cuando se omite nodataval. El ráster conserva su malla y sus demás bandas, de modo que las clases pueden leerse a lo largo de una trayectoria con rasterValue.

-- Build a 3x3 synthetic elevation raster (SRID 4326, 1 degree pixels)
WITH rast AS (
  SELECT ST_SetValues(ST_AddBand( ST_MakeEmptyRaster(3, 3, 0.0, 3.0, 1.0, -1.0, 0.0, 0.0,
    4326), '32BF'::text, 0.0::float8, NULL::float8), 1, 1, 1,
    ARRAY[[10.0::float4, 20.0::float4, 30.0::float4],
    [40.0::float4, 50.0::float4, 60.0::float4],
    [70.0::float4, 80.0::float4, 90.0::float4]]) AS r )
SELECT ST_DumpValues(reclass(r, 1, '0-50:1, 51-100:2', '8BUI', 0), 1) AS plain,
  ST_DumpValues(reclass(r, 1, '0-50:1, [50-100]:2', '8BUI', 0), 1) AS bracket
FROM rast;
-- {{1,1,1},{1,NULL,2},{2,2,2}} | {{1,1,1},{1,2,2},{2,2,2}}
-- Read the classes along a trajectory
WITH rast AS (
  SELECT ST_SetValues(ST_AddBand( ST_MakeEmptyRaster(3, 3, 0.0, 3.0, 1.0, -1.0, 0.0, 0.0,
    4326), '32BF'::text, 0.0::float8, NULL::float8), 1, 1, 1,
    ARRAY[[10.0::float4, 20.0::float4, 30.0::float4],
    [40.0::float4, 50.0::float4, 60.0::float4],
    [70.0::float4, 80.0::float4, 90.0::float4]]) AS r )
SELECT rasterValue(tgeompoint 'SRID=4326;{POINT(0.5 2.5)@2001-01-01,
  POINT(1.5 1.5)@2001-01-02, POINT(2.5 0.5)@2001-01-03}',
  reclass(r, 1, '0-50:1, [50-100]:2', '8BUI', 0))::text FROM rast;
-- {1@2001-01-01, 2@2001-01-02, 2@2001-01-03}

Devuelve un ráster que conserva los píxeles de otro que una geometría cubre

clip(raster,geom geometry,crop boolean=true,touched boolean=false) → raster
clip(raster,nband integer[],geom geometry,nodataval float8[]=NULL,crop boolean=true,
  touched boolean=false) → raster

Cada banda se lee contra una máscara en la que se graba la geometría, tal como la lee ST_Clip de PostGIS: un píxel que la geometría no cubre devuelve el valor nodata de su banda, y el menor valor que admite su tipo de píxel cuando la banda no declara ninguno. Con crop el resultado conserva la extensión que comparten el ráster y la geometría, y en caso contrario la extensión del ráster. La geometría está en el sistema de referencia del ráster; una en otro sistema genera un error. Con nband el resultado conserva las bandas nombradas, todas cuando es NULL, nodataval declara el valor nodata de los píxeles que la geometría no cubre, uno para todas las bandas o uno por banda, y con touched se conserva un píxel que la geometría toca donde de otro modo solo se conserva uno cuyo centro cubre.

-- Build a 3x3 synthetic elevation raster (SRID 4326, 1 degree pixels)
WITH rast AS (
  SELECT ST_SetValues(ST_AddBand( ST_MakeEmptyRaster(3, 3, 0.0, 3.0, 1.0, -1.0, 0.0, 0.0,
    4326), '32BF'::text, 0.0::float8, -9999::float8), 1, 1, 1,
    ARRAY[[10.0::float4, 20.0::float4, 30.0::float4],
    [40.0::float4, 50.0::float4, 60.0::float4],
    [70.0::float4, 80.0::float4, 90.0::float4]]) AS r )
SELECT ST_DumpValues(clip(r, geometry 'SRID=4326;POLYGON((0 1,2 1,2 3,0 3,0 1))'), 1)
  AS cropped,
  ST_DumpValues(clip(r, geometry 'SRID=4326;POLYGON((0 1,2 1,2 3,0 3,0 1))', false), 1)
  AS kept_extent
FROM rast;
-- {{10,20},{40,50}} | {{10,20,NULL},{40,50,NULL},{NULL,NULL,NULL}}

Devuelve un ráster expresado en otro sistema de referencia espacial
```
transform(raster,srid integer,algorithm text='NearestNeighbour',maxerr float8=0.125,
  scalex float8=0,scaley float8=0) → raster
transform(raster,alignto raster,algorithm text='NearestNeighbour',
  maxerr float8=0.125) → raster
```
Cada banda se lleva al sistema de destino y se remuestrea sobre la malla que implica la reproyección, mediante la misma deformación de GDAL que ST_Transform de PostGIS, de modo que el resultado expresa la misma cobertura leída a través de otro sistema. El algoritmo es uno de NearestNeighbour, Bilinear, Cubic, CubicSpline, Lanczos, Max y Min, nombrado sin distinguir mayúsculas de minúsculas, y maxerr es el error en píxeles de entrada que la deformación puede cometer, 0 para un cálculo exacto. scalex y scaley declaran el tamaño de píxel del resultado, 0 dejando que la deformación lo derive, y alignto toma el sistema de referencia, el tamaño de píxel, el origen de la malla y la inclinación de otro ráster, de modo que el resultado queda sobre su malla.
```
-- Build a 3x3 synthetic elevation raster (SRID 4326, 1 degree pixels)
WITH rast AS (
  SELECT ST_SetValues(ST_AddBand( ST_MakeEmptyRaster(3, 3, 0.0, 3.0, 1.0, -1.0, 0.0, 0.0,
    4326), '32BF'::text, 0.0::float8, -9999::float8), 1, 1, 1,
    ARRAY[[10.0::float4, 20.0::float4, 30.0::float4],
    [40.0::float4, 50.0::float4, 60.0::float4],
    [70.0::float4, 80.0::float4, 90.0::float4]]) AS r )
SELECT SRID(transform(r, 3857)) AS srid, width(transform(r, 3857)) AS width,
  height(transform(r, 3857)) AS height
FROM rast;
-- 3857 | 3 | 3
```

Devuelve un ráster remuestreado a otro tamaño de píxel

rescale(raster,scalex float8,scaley float8,algorithm text='NearestNeighbour',
  maxerr float8=0.125) → raster

El resultado conserva el sistema de referencia y la esquina superior izquierda del ráster y expresa su cobertura sobre una malla del tamaño de píxel pedido, mediante la misma deformación de GDAL que ST_Rescale de PostGIS, de modo que una escala más gruesa lee menos píxeles sobre el mismo terreno. Las escalas están en las unidades del sistema de referencia del ráster, y el algoritmo y el error son los de transform.

-- Build a 3x3 synthetic elevation raster (SRID 4326, 1 degree pixels)
WITH rast AS (
  SELECT ST_SetValues(ST_AddBand( ST_MakeEmptyRaster(3, 3, 0.0, 3.0, 1.0, -1.0, 0.0, 0.0,
    4326), '32BF'::text, 0.0::float8, -9999::float8), 1, 1, 1,
    ARRAY[[10.0::float4, 20.0::float4, 30.0::float4],
    [40.0::float4, 50.0::float4, 60.0::float4],
    [70.0::float4, 80.0::float4, 90.0::float4]]) AS r )
SELECT width(rescale(r, 0.5, -0.5)) AS width,
  height(rescale(r, 0.5, -0.5)) AS height,
  scaleX(rescale(r, 0.5, -0.5)) AS scalex
FROM rast;
-- 6 | 6 | 0.5

Devuelve las estadísticas de los píxeles de una banda de ráster

summaryStats(raster,nband integer=1,exclude_nodata_value boolean=true) → summarystats

La banda se lee una sola vez y devuelve el registro summarystats de PostGIS que devuelve ST_SummaryStats: el número de píxeles contados, y la suma, la media, la desviación estándar, el mínimo y el máximo de sus valores. Se leen todos los píxeles, por lo que la respuesta es exacta y no muestreada; los píxeles que la banda declara como nodata quedan fuera salvo que exclude_nodata_value sea falso, y una banda sin ningún píxel que contar devuelve un recuento de cero y ninguna estadística.

-- Build a 3x3 synthetic elevation raster (SRID 4326, 1 degree pixels)
WITH rast AS (
  SELECT ST_SetValues(ST_AddBand( ST_MakeEmptyRaster(3, 3, 0.0, 3.0, 1.0, -1.0, 0.0, 0.0,
    4326), '32BF'::text, 0.0::float8, -9999::float8), 1, 1, 1,
    ARRAY[[10.0::float4, 20.0::float4, 30.0::float4],
    [40.0::float4, 50.0::float4, 60.0::float4],
    [70.0::float4, 80.0::float4, 90.0::float4]]) AS r )
SELECT (summaryStats(r)).* FROM rast;
-- 9 | 450 | 50 | 25.81988897471611 | 10 | 90

Devuelve los polígonos de una banda de ráster, uno por cada grupo de píxeles que comparten un valor
```
dumpAsPolygons(raster,band integer=1,exclude_nodata_value boolean=true) → {geomval}
```
Una banda declara un valor por píxel, y esta función declara la misma banda como las regiones que cubren esos valores, devolviendo los registros geomval de PostGIS que devuelve ST_DumpAsPolygons. Cada polígono lleva el sistema de referencia del ráster, donde ST_DumpAsPolygons no declara ninguno, de modo que puede compararse con las trayectorias a lo largo de las cuales se lee la cobertura. Los píxeles que la banda declara como nodata quedan fuera salvo que exclude_nodata_value sea falso, una banda cuyos píxeles son todos nodata no cubre nada y no devuelve ninguna fila, y una banda que el ráster no tiene genera un error.
```
-- Classify a 3x3 synthetic elevation raster, then read each class as a region
WITH rast AS (
  SELECT ST_SetValues(ST_AddBand( ST_MakeEmptyRaster(3, 3, 0.0, 3.0, 1.0, -1.0, 0.0, 0.0,
    4326), '32BF'::text, 0.0::float8, -9999::float8), 1, 1, 1,
    ARRAY[[10.0::float4, 20.0::float4, 30.0::float4],
    [40.0::float4, 50.0::float4, 60.0::float4],
    [70.0::float4, 80.0::float4, 90.0::float4]]) AS r )
SELECT val, ST_AsText(geom)
FROM rast, dumpAsPolygons(reclass(r, 1, '0-50:1, [50-100]:2', '8BUI', 0))
ORDER BY val;
-- 1 | POLYGON((0 3,0 1,1 1,1 2,3 2,3 3,0 3))
-- 2 | POLYGON((1 2,1 1,0 1,0 0,3 0,3 2,1 2))
```
Muestrea una tesela ráster raquet a lo largo de una trayectoria
```
rasterTileValue(tgeompoint,rast raquet) → tfloat
```
Lee la tesela a lo largo de traj (SRID 4326) como rasterValue lee un ráster, devolviendo los valores de píxel como un tfloat. Es el equivalente tipado de rasterTileValueQuadbin: las dimensiones, la celda QUADBIN, el tipo de píxel y el tratamiento de nodata se toman del valor raquet en lugar de argumentos separados. Devuelve NULL cuando el trayecto nunca encuentra un píxel de la tesela con datos.
```
-- Sample pre-packaged raquet tiles along ship trajectories
SELECT t.tripid, rasterTileValue(t.trip, r.tile)
FROM trips t JOIN elevation_tiles r ON r.quadbin = ANY(quadbins(t.trip, 8));
```
Muestrea un arreglo de teselas ráster raquet a lo largo de una trayectoria
```
rasterTileValue(tgeompoint,rast raquet[]) → tfloat
```
Lee cada tesela de rast a lo largo de traj (SRID 4326) y devuelve los valores de píxel como un único tfloat. Una trayectoria que sale de una tesela queda cubierta por varias, y cada una responde la parte del trayecto que está sobre ella. Las teselas de un mismo nivel de zoom particionan el plano, de modo que responden tiempos disjuntos. Las teselas de niveles de zoom distintos se solapan, y cuando dos de ellas responden el mismo tiempo se conserva el valor de la tesela de mayor zoom, que es la que tiene la resolución más fina. Devuelve NULL cuando el trayecto nunca encuentra un píxel de una tesela con datos.
```
-- Sample a trajectory across every tile it crosses, in one value
SELECT t.tripid, rasterTileValue(t.trip, array_agg(r.tile)) FROM trips t
JOIN elevation_tiles r ON r.quadbin = ANY(quadbins(t.trip, 8)) GROUP BY t.tripid, t.trip;
```

Muestrea un chip ráster de Raquet a lo largo de una trayectoria usando una celda QUADBIN para la georreferenciación

rasterTileValueQuadbin(tgeompoint,pixels bytea,width integer,height integer,
  quadbin bigint,pixtype text,nodata float8,has_nodata boolean) → tfloat

Lee un arreglo de píxeles de banda única en orden de fila mayor a lo largo de traj (SRID 4326), como rasterValue lee un ráster. La georreferenciación de la tesela (rectángulo delimitador, mapeo de píxel a coordenadas) se deriva únicamente de quadbin mediante la transformada de tesela deslizante Web-Mercator. El argumento pixtype debe ser uno de uint8, int8, uint16, int16, uint32, int32, uint64, int64, float16, float32 o float64. Cuando has_nodata es verdadero, un píxel igual a nodata no lleva valor. Devuelve NULL cuando el trayecto nunca encuentra un píxel con datos.

-- Sample elevation tiles from a Raquet Parquet table for all ship trajectories
SELECT t.tripid, rasterTileValueQuadbin(t.trip, r.band_data, r.width, r.height,
  r.quadbin, 'float32', r.nodata, true) FROM trips t
JOIN elevation_raquet r ON r.quadbin = ANY(quadbins(t.trip, 8));
-- Average sea-surface temperature per trajectory
SELECT t.tripid, avgValue(rasterTileValueQuadbin(t.trip, 
  r.band_data, 256, 256, r.quadbin, 'int16', -9999, true)) AS mean_sst FROM trips t
JOIN sst_raquet r ON r.quadbin = ANY(quadbins(t.trip, 6));

Devuelve la parte de una trayectoria donde el valor ráster que lee cae dentro de un rango de flotante

atRasterValue(tgeompoint,rast raster,vspan floatspan,band integer=1) → tgeompoint
atRasterValue(tgeompoint,path text,vspan floatspan,band integer=1) → tgeompoint

Lee rasterValue a lo largo de traj y devuelve la sub-trayectoria restringida a los tiempos en que el valor del píxel está dentro de vspan. Devuelve NULL cuando ningún tiempo satisface la condición. La forma que recibe path lee un archivo ráster del servidor, como lo hace la forma correspondiente de rasterValue.

WITH rast AS (
  SELECT ST_SetValues(ST_AddBand( ST_MakeEmptyRaster(3, 3, 0.0, 3.0, 1.0, -1.0, 0.0, 0.0,
    4326), '32BF'::text, 0.0::float8, NULL::float8), 1, 1, 1,
    ARRAY[[10.0::float4, 20.0::float4, 30.0::float4],
    [40.0::float4, 50.0::float4, 60.0::float4],
    [70.0::float4, 80.0::float4, 90.0::float4]]) AS r )
SELECT asText(atRasterValue(tgeompoint 'SRID=4326;
  [POINT(0.5 2.5)@2001-01-01, POINT(1.5 1.5)@2001-01-02, POINT(0.5 0.5)@2001-01-03]', r,
  floatspan '[40, 90]')) FROM rast;
/* {[POINT(1 2)@2001-01-01 12:00:00, POINT(1.5 1.5)@2001-01-02,
   POINT(0.5 0.5)@2001-01-03]} */

Devuelve la parte de una trayectoria donde el valor ráster que lee cae fuera de un rango de flotante
```
minusRasterValue(tgeompoint,rast raster,vspan floatspan,band integer=1) → tgeompoint
minusRasterValue(tgeompoint,path text,vspan floatspan,band integer=1) → tgeompoint
```
El complemento de atRasterValue: devuelve la sub-trayectoria restringida a los tiempos en que el valor del píxel está fuera de vspan. Devuelve NULL cuando el valor del píxel está dentro de vspan en todo momento. La forma que recibe path lee un archivo ráster del servidor, como lo hace la forma correspondiente de rasterValue.
```
-- Keep only the instant whose raster value (10) is below 40
SELECT asText(minusRasterValue(traj, elev_raster, floatspan '[40, 9999]')) FROM trips,
  elevation_raster;
```
Devuelve verdadero si la trayectoria alguna vez lee un valor de píxel ráster dentro de un rango de flotante
```
eRasterValue(tgeompoint,rast raster,vspan floatspan,band integer=1) → boolean
eRasterValue(tgeompoint,path text,vspan floatspan,band integer=1) → boolean
```
Devuelve true cuando traj lee alguna vez un valor de píxel dentro de vspan, false en caso contrario. Devuelve NULL únicamente cuando la entrada es NULL. La forma que recibe path lee un archivo ráster del servidor, como lo hace la forma correspondiente de rasterValue.
```
-- Trips that ever crossed terrain above 200 m
SELECT tripid FROM trips,
  elevation_raster WHERE eRasterValue(trip, elev_raster, floatspan '[200, 9999]');
```
Devuelve verdadero si cada valor de píxel que la trayectoria lee sobre el ráster está dentro de un rango de flotante
```
aRasterValue(tgeompoint,rast raster,vspan floatspan,band integer=1) → boolean
aRasterValue(tgeompoint,path text,vspan floatspan,band integer=1) → boolean
```
Devuelve true cuando cada valor de píxel que traj lee sobre el ráster está dentro de vspan, false cuando al menos uno no lo está. Devuelve NULL únicamente cuando la entrada es NULL. La forma que recibe path lee un archivo ráster del servidor, como lo hace la forma correspondiente de rasterValue.
```
-- Trips that stayed entirely below 100 m elevation
SELECT tripid FROM trips,
  elevation_raster WHERE aRasterValue(trip, elev_raster, floatspan '[0, 100]');
```

Para usar los operadores descritos aquí, MobilityDB debe ser compilado con -DRASTER=ON. En tal compilación, el archivo mobilitydb.control generado declara requires = 'postgis, postgis_raster', por lo que un único CASCADE crea la pila completa:

CREATE EXTENSION mobilitydb CASCADE;
-- NOTICE:  installing required extension "postgis"
-- NOTICE:  installing required extension "postgis_raster"

El ráster de PostGIS forma parte del paquete estándar postgresql-N-postgis-3 en Debian/Ubuntu; no se requiere ningún paquete adicional. Pase -DRASTER=ON a CMake:

cmake -DRASTER=ON ..
make -j$(nproc)
sudo make install

Para incluir el ráster en la compilación de cobertura de CI junto con otras familias opcionales, añada -DRASTER=ON a la invocación de cmake en .github/workflows/pgversion.yml.

Anterior	Subir	Siguiente
Operaciones específicas de S2	Inicio	Capítulo 17. Nubes de puntos temporales