Contiene funciones que agregan valores sobre capas y campos.
Devuelve un valor agregado calculado usando objetos de otra capa.
aggregate
(
layer
,
aggregate
,
expression
[,
filter
][,
concatenator
][,
order_by
])
| layer | Una cadena que represente el nombre o la ID de una capa |
| aggregate |
a string corresponding to the aggregate to calculate. Valid options are:
|
| expression | sub expresión o nombre de campo a agregar |
| filter | expresión de filtrado opcional para limitar los objetos usados para calcular el agregado. Los campos y geometrías son de los objetos de la capa unida. Se puede acceder al objeto de origen con la variable @parent. |
| concatenator | cadena opcional a usar para unir valores para el agregado 'concatenar' |
| order_by | optional filter expression to order the features used for calculating the aggregate. Fields and geometry are from the features on the joined layer. |
aggregate(layer:='rail_stations',aggregate:='sum',expression:="passengers")
→
suma de todos los valores del campo passengers de la capa rail_stations
aggregate('rail_stations','sum', "passengers"/7)
→
calcula una media diaria de "passengers" dividiendo el campo "passengers" por 7 antes de sumar los valores
aggregate(layer:='rail_stations',aggregate:='sum',expression:="passengers",filter:="class">3)
→
suma todos los valores del campo "passengers" de los objetos en los que el atributo "class" es mayor que 3
aggregate(layer:='rail_stations',aggregate:='concatenate', expression:="name", concatenator:=',')
→
lista separada por comas del campo name para todos los objetos de la capa rail_stations
aggregate(layer:='países', aggregate:='max', expression:="código", filter:=intersects( $geometry, geometry(@parent) ) )
→
El código del país de un país que intersecte en la capa 'países'
Devuelve una matriz de valores agregados a partir de un campo o expresión.
array_agg
(
expression
[,
group_by
][,
filter
][,
order_by
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
| order_by | optional expression to use to order features used to calculate aggregate |
array_agg("name",group_by:="state")
→
lista de nombres, agrupados por campo de estado
Devuelve la geometría multiparte de geometrías agregadas a partir una expresión.
collect
(
expression
[,
group_by
][,
filter
])
| expression | expresión de geometría a agregar. |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
collect( $geometry )
→
geometría multiparte de geometrías agregadas
Returns all aggregated strings from a field or expression joined by a delimiter.
concatenate
(
expression
[,
group_by
][,
filter
][,
concatenator
][,
order_by
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
| concatenator | cadena opcional a usar para unir valores |
| order_by | optional expression to use to order features used to calculate aggregate |
concatenar("nombre_ciudad",agrupar_por:="estado",concatenador:=',')
→
lista separada por comas de nombres_ciudad, agrupados por el campo estado
Returns all unique strings from a field or expression joined by a delimiter.
concatenate_unique
(
expression
[,
group_by
][,
filter
][,
concatenator
][,
order_by
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
| concatenator | cadena opcional a usar para unir valores |
| order_by | optional expression to use to order features used to calculate aggregate |
concatenar("nombre_ciudad",agrupar_por:="estado",concatenador:=',')
→
comma separated list of unique town_names, grouped by state field
Devuelve el recuento de objetos coincidentes.
count
(
expression
[,
group_by
][,
filter
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
contar("estaciones",agrupar_por:="estado")
→
cuenta de estaciones, agrupados por el campo estado
Devuelve el recuento de valores distintos.
count_distinct
(
expression
[,
group_by
][,
filter
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
contar_distintos("estaciones",agrupar_por:="estado")
→
cuenta de valores distintos de estaciones, agrupados por el campo estado
Devuelve el recuento de valores que faltan (nulo).
count_missing
(
expression
[,
group_by
][,
filter
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
contar_faltantes("estaciones",agrupar_por:="estado")
→
cuenta de valores que faltan (nulos) de estaciones, agrupados por el campo estado
Devuelve el rango de intercuartil calculado a partir de un campo o expresión.
iqr
(
expression
[,
group_by
][,
filter
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
iqr("population",group_by:="state")
→
rango de intercuartil del valor de población, agrupado por el campo estado
Devuelve la mayoría agregada de los valores (valores que aparecen de forma más común) de un campo o expresión.
majority
(
expression
[,
group_by
][,
filter
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
mayoría("clase",agrupar_por:="estado")
→
valor de clase que ocurre con más frecuencia, agrupado por el campo estado
Devuelve la longitud máxima de cadenas a partir de un campo o expresión.
max_length
(
expression
[,
group_by
][,
filter
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
longitud_max("nombre_ciudad",agrupar_por:="estado")
→
longitud máxima de nombre_ciudad, agrupada por el campo estado
Devuelve el valor máximo agregado a partir de un campo o expresión.
maximum
(
expression
[,
group_by
][,
filter
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
máximo("población",agrupar_por:="estado")
→
valor máximo de población, agrupado por el campo estado
Devuelve el valor medio agregado a partir de un campo o expresión.
mean
(
expression
[,
group_by
][,
filter
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
media("población",agrupar_por:="estado")
→
valor medio de población, agrupado por el campo estado
Devuelve el valor de la mediana agregada a partir de un campo o expresión.
median
(
expression
[,
group_by
][,
filter
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
mediana("población",agrupar_por:="estado")
→
valor mediana de población, agrupado por el campo estado
Devuelve la longitud mínima de cadenas a partir de un campo o expresión.
min_length
(
expression
[,
group_by
][,
filter
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
longitud_min("nombre_ciudad",agrupar_por:="estado")
→
longitud mínima de nombre_ciudad, agrupada por el campo estado
Devuelve el valor mínimo agregado a partir de un campo o expresión.
minimum
(
expression
[,
group_by
][,
filter
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
mínimo("población",agrupar_por:="estado")
→
valor mínimo de población, agrupado por el campo estado
Devuelve la minoría agregada de valores (valor que ocurre con menos frecuencia) a partir de un campo o expresión.
minority
(
expression
[,
group_by
][,
filter
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
mayoría("clase",agrupar_por:="estado")
→
valor de clase que ocurre con menos frecuencia, agrupado por el campo estado
Devuelve el primer cuartil calculado a partir de un campo o expresión.
q1
(
expression
[,
group_by
][,
filter
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
q1("población",agrupar_por:="estado")
→
primer cuartil del valor de población, agrupado por el campo estado
Devuelve el tercer cuartil calculado a partir de un campo o expresión.
q3
(
expression
[,
group_by
][,
filter
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
q3("población",agrupar_por:="estado")
→
tercer cuartil del valor de población, agrupado por el campo estado
Devuelve el rango agregado de valores (máximo - mínimo) de un campo o expresión.
range
(
expression
[,
group_by
][,
filter
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
rango("población",agrupar_por:="estado")
→
rango de valores de población, agrupado por el campo estado
Devuelve un valor agregado calculado usando todos los objetos hijos coincidentes de una relación de capas.
relation_aggregate
(
relation
,
aggregate
,
expression
[,
concatenator
][,
order_by
])
| relation | una cadena que representa una ID de relación |
| aggregate |
a string corresponding to the aggregate to calculate. Valid options are:
|
| expression | sub expresión o nombre de campo a agregar |
| concatenator | cadena opcional a usar para unir valores para el agregado 'concatenar' |
| order_by | optional expression to order the features used for calculating the aggregate. Fields and geometry are from the features on the joined layer. |
relation_aggregate(relation:='my_relation',aggregate:='mean',expression:="passengers")
→
valor medio de todos los objetos hijos coincidentes usando la relación 'mi_relación'
relation_aggregate('my_relation','sum', "passengers"/7)
→
suma del campo pasajeros dividido por 7 de todos los objetos hijos coincidentes usando la relación 'mi_relación'
relation_aggregate('my_relation','concatenate', "towns", concatenator:=',')
→
lista separada por coma del campo ciudades para todos los objetos hijos coincidentes usando la relación 'mi_relación'
relation_aggregate('my_relation','array_agg', "id")
→
array of the id field from all matching child features using the 'my_relation' relation
Devuelve la desviación estándar agregada a partir de un campo o expresión.
stdev
(
expression
[,
group_by
][,
filter
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
desv_est("población",agrupar_por:="estado")
→
desviación estándar del valor de población, agrupado por el campo estado
Devuelve el valor sumado agregado a partir de un campo o expresión.
sum
(
expression
[,
group_by
][,
filter
])
| expression | subexpresión de campo a agregar |
| group_by | expresión opcional a usar para agrupar cálculos de agregados |
| filter | expresión opcional a usar para filtrar objetos utilizados para calcular el agregado |
suma("población",agrupar_por:="estado")
→
valor de población sumado, agrupado por el campo estado
Este grupo contiene funciones de expresiones para la creación y manipulación de matrices (también conocidas como estructuras de datos en lista). El orden de los valores dentro de la matriz importa, a diferencia de la estructura de datos de "mapa", en donde el orden de pares clave-valor es irrelevante y los valores se identifican por sus claves.
Devuelve una matriz que contiene todos los valores pasados como parámetros.
array
(
value1
,
value2
…)
| value | un valor |
array(2,10)
→
[ 2, 10 ]
Returns true if an array contains all the values of a given array.
array_all
(
array_a
,
array_b
)
| array_a | una matriz |
| array_b | the array of values to search |
array_all(array(1,2,3),array(2,3))
→
verdadero
array_all(array(1,2,3),array(1,2,4))
→
falso
Devuelve una matriz con el valor dado añadido al final.
array_append
(
array
,
value
)
| array | una matriz |
| value | el valor a añadir |
array_append(array(1,2,3),4)
→
[ 1, 2, 3, 4 ]
Devuelve una matriz que contiene todas las matrices dadas concatenadas.
array_cat
(
array1
,
array2
…)
| array | una matriz |
array_cat(array(1,2),array(2,3))
→
[ 1, 2, 2, 3 ]
Devuelve verdadero si una matriz contiene el valor dado.
array_contains
(
array
,
value
)
| array | una matriz |
| value | el valor a buscar |
array_contains(array(1,2,3),2)
→
verdadero
Devuelve una matriz que contiene los valores distintos de la matriz dada.
array_distinct
(
array
)
| array | una matriz |
array_distinct(array(1,2,3,2,1))
→
[ 1, 2, 3 ]
Devuelve una matriz con sólo los ítems para los cuales la expresión evalúa a verdadero.
array_filter
(
array
,
expression
)
| array | una matriz |
| expression | an expression to evaluate on each item. The variable `@element` will be replaced by the current value. |
array_filter(array(1,2,3),@element < 3)
→
[ 1, 2 ]
Devuelve el índice de un valor dentro de una matriz (0 para el primero). Devuelve -1 si no se encuentra el valor.
array_find
(
array
,
value
)
| array | una matriz |
| value | el valor a buscar |
array_find(array(1,2,3),2)
→
1
Devuelve el primer valor de una matriz.
array_first
(
array
)
| array | una matriz |
array_first(array('a','b','c'))
→
'a'
Returns an array with the given expression evaluated on each item.
array_foreach
(
array
,
expression
)
| array | una matriz |
| expression | an expression to evaluate on each item. The variable `@element` will be replaced by the current value. |
array_foreach(array('a','b','c'),upper(@element))
→
[ 'A', 'B', 'C' ]
array_foreach(array(1,2,3),@element + 10)
→
[ 11, 12, 13 ]
Devuelve el valor N de una matriz (0 para el primero).
array_get
(
array
,
index
)
| array | una matriz |
| index | el índica a obtener (basado en 0) |
array_get(array('a','b','c'),1)
→
'b'
Devuelve una matriz con el valor dado añadido en la posición indicada.
array_insert
(
array
,
pos
,
value
)
| array | una matriz |
| pos | la posición en la que añadir (basado en 0) |
| value | el valor a añadir |
array_insert(array(1,2,3),1,100)
→
[ 1, 100, 2, 3 ]
Devuelve verdadero si un elemento de la matriz1 está presente en la matriz2.
array_intersect
(
array1
,
array2
)
| array1 | una matriz |
| array2 | otra matriz |
array_intersect(array(1,2,3,4),array(4,0,2,5))
→
verdadero
Devuelve el último valor de una matriz.
array_last
(
array
)
| array | una matriz |
array_last(array('a','b','c'))
→
'c'
Devuelve el número de elementos de una matriz.
array_length
(
array
)
| array | una matriz |
array_length(array(1,2,3))
→
3
Devuelve una matriz con el valor dado añadido al principio.
array_prepend
(
array
,
value
)
| array | una matriz |
| value | el valor a añadir |
array_prepend(array(1,2,3),0)
→
[ 0, 1, 2, 3 ]
Devuelve una matriz con todas las entradas del valor dado eliminadas.
array_remove_all
(
array
,
value
)
| array | una matriz |
| value | los valores a eliminar |
array_remove_all(array('a','b','c','b'),'b')
→
[ 'a', 'c' ]
Devuelve una matriz con el índice dado eliminado.
array_remove_at
(
array
,
pos
)
| array | una matriz |
| pos | la posición a eliminar (basado en 0) |
array_remove_at(array(1,2,3),1)
→
[ 1, 3 ]
Devuelve la matriz dada con los valores de la matriz en orden inverso.
array_reverse
(
array
)
| array | una matriz |
array_reverse(array(2,4,0,10))
→
[ 10, 0, 4, 2 ]
Devuelve una porción de la matriz. El fragmento es definido por los argumentos start_pos y end_pos.
array_slice
(
array
,
start_pos
,
end_pos
)
| array | una matriz |
| start_pos | el índice de la posición inicial del fragmento (basado en 0). El índice de start_pos se incluye en el fragmento. Si se usa una start_pos negativa, el índice se cuenta desde el final de la lista (basado en -1). |
| end_pos | el índice de la posición final del fragmento (basado en 0). El índice de end_pos se incluye en el fragmento. Si se usa una end_pos negativa, el índice se cuenta desde el final de la lista (basado en -1). |
array_slice(array(1,2,3,4,5),0,3)
→
[ 1, 2, 3, 4 ]
array_slice(array(1,2,3,4,5),0,-1)
→
[ 1, 2, 3, 4, 5 ]
array_slice(array(1,2,3,4,5),-5,-1)
→
[ 1, 2, 3, 4, 5 ]
array_slice(array(1,2,3,4,5),0,0)
→
[ 1 ]
array_slice(array(1,2,3,4,5),-2,-1)
→
[ 4, 5 ]
array_slice(array(1,2,3,4,5),-1,-1)
→
[ 5 ]
array_slice(array('Dufour','Valmiera','Chugiak','Brighton'),1,2)
→
[ 'Valmiera', 'Chugiak' ]
array_slice(array_slice(array('Dufour','Valmiera','Chugiak','Brighton'),-2,-1)
→
[ 'Chugiak', 'Brighton' ]
Returns the provided array with its elements sorted.
array_sort
(
array
[,
ascending=true
])
| array | una matriz |
| ascending | set this parameter to false to sort the array in descending order |
array_sort(array(3,2,1))
→
[ 1, 2, 3 ]
Concatenates array elements into a string separated by a delimiter and using optional string for empty values.
array_to_string
(
array
[,
delimiter=','
][,
empty_value=''
])
| array | la matriz de entrada |
| delimiter | el delimitador de cadena utilizado para separa los elementos de la matriz concatenados |
| empty_value | la cadena opcional usada como reemplazo para coincidencias vacías (longitud cero) |
array_to_string(array('1','2','3'))
→
'1,2,3'
array_to_string(array(1,2,3),'-')
→
'1-2-3'
array_to_string(array('1','','3'),',','0')
→
'1,0,3'
Creates an array containing a sequence of numbers.
generate_series
(
start
,
stop
[,
step=1
])
| start | first value of the sequence |
| stop | value that ends the sequence once reached |
| step | value used as the increment between values |
generate_series(1,5)
→
[ 1, 2, 3, 4, 5 ]
generate_series(5,1,-1)
→
[ 5, 4, 3, 2, 1 ]
Devuelve una matriz de todas las cadenas capturadas por grupos de captura, en el orden en el que los propios grupos aparecen en la expresión regular proporcionada contra la cadena.
regexp_matches
(
string
,
regex
[,
empty_value=''
])
| string | la cadena para capturar grupos desde la expresión regular |
| regex | la expresión regular usada para capturar grupos |
| empty_value | la cadena opcional usada como reemplazo para coincidencias vacías (longitud cero) |
regexp_matches('QGIS=>rocks','(.*)=>(.*)')
→
[ 'QGIS', 'rocks' ]
regexp_matches('key=>','(.*)=>(.*)','empty value')
→
[ 'key', 'empty value' ]
Divide una cadena en una matriz usando el delimitador proporcionado y una cadena opcional para valores vacíos.
string_to_array
(
string
[,
delimiter=','
][,
empty_value=''
])
| string | la cadena de entrada |
| delimiter | el delimitador de cadena utilizado para dividir la cadena de entrada |
| empty_value | la cadena opcional usada como reemplazo para coincidencias vacías (longitud cero) |
string_to_array('1,2,3',',')
→
[ '1', '2', '3' ]
string_to_array('1,,3',',','0')
→
[ '1', '0', '3' ]
Este grupo contiene funciones para manipular colores
Devuelve una representación en forma de cadena de un color en base a sus componentes cian, magenta, amarillo y negro
color_cmyk
(
cyan
,
magenta
,
yellow
,
black
)
| cyan | componente cian del color, como un valor entero de porcentaje de 0 a 100 |
| magenta | componente magenta del color, como un valor entero de porcentaje de 0 a 100 |
| yellow | componente amarillo del color, como un valor entero de porcentaje de 0 a 100 |
| black | componente negro del color, como un valor entero de porcentaje de 0 a 100 |
color_cmyk(100,50,0,10)
→
0,115,230
Devuelve una representación en forma de cadena de un color en base a sus componentes cian, magenta, amarillo, negro y alfa (transparencia)
color_cmyka
(
cyan
,
magenta
,
yellow
,
black
,
alpha
)
| cyan | componente cian del color, como un valor entero de porcentaje de 0 a 100 |
| magenta | componente magenta del color, como un valor entero de porcentaje de 0 a 100 |
| yellow | componente amarillo del color, como un valor entero de porcentaje de 0 a 100 |
| black | componente negro del color, como un valor entero de porcentaje de 0 a 100 |
| alpha | componente alfa como un valor entero de 0 (completamente transparente) a 255 (opaco). |
color_cmyk(100,50,0,10,200)
→
0,115,230,200
Applies a grayscale filter and returns a string representation from a provided color.
color_grayscale_average
(
color
)
| color | una cadena de color |
color_grayscale_average('255,100,50')
→
127,127,127,255
Devuelve una representación en forma de cadena de un color en base a sus atributos de matiz, saturación y luminosidad.
color_hsl
(
hue
,
saturation
,
lightness
)
| hue | matiz de un color, como un entero de 0 a 360 |
| saturation | porcentaje de saturación del color, como un valor entero de 0 a 100 |
| lightness | porcentaje de luminosidad del color, como un valor entero de 0 a 100 |
color_hsl(100,50,70)
→
166,217,140
Devuelve una representación en forma de cadena de un color en base a sus atributos de matiz, saturación, luminosidad y canal alfa (transparencia).
color_hsla
(
hue
,
saturation
,
lightness
,
alpha
)
| hue | matiz de un color, como un entero de 0 a 360 |
| saturation | porcentaje de saturación del color, como un valor entero de 0 a 100 |
| lightness | porcentaje de luminosidad del color, como un valor entero de 0 a 100 |
| alpha | componente alfa como un valor entero de 0 (completamente transparente) a 255 (opaco). |
color_hsla(100,50,70,200)
→
166,217,140,200
Devuelve una representación en forma de cadena de un color en base a sus atributos de matiz, saturación y valor.
color_hsv
(
hue
,
saturation
,
value
)
| hue | matiz de un color, como un entero de 0 a 360 |
| saturation | porcentaje de saturación del color, como un valor entero de 0 a 100 |
| value | porcentaje de valor del color, como un valor entero de 0 a 100 |
color_hsv(40,100,100)
→
255,170,0
Devuelve una representación en forma de cadena de un color en base a sus atributos de matiz, saturación, valor y canal alfa (transparencia).
color_hsva
(
hue
,
saturation
,
value
,
alpha
)
| hue | matiz de un color, como un entero de 0 a 360 |
| saturation | porcentaje de saturación del color, como un valor entero de 0 a 100 |
| value | porcentaje de valor del color, como un valor entero de 0 a 100 |
| alpha | componente alfa como un valor entero de 0 (completamente transparente) a 255 (opaco) |
color_hsva(40,100,100,200)
→
255,170,0,200
Returns a string representing a color mixing the red, green, blue, and alpha values of two provided colors based on a given ratio.
color_mix_rgb
(
color1
,
color2
,
ratio
)
| color1 | una cadena de color |
| color2 | una cadena de color |
| ratio | una relación |
color_mix_rgb('0,0,0','255,255,255',0.5)
→
127,127,127,255
Devuelve un componente específico de una cadena de color, por ejemplo el componente rojo o el alfa.
color_part
(
color
,
component
)
| color | una cadena de color |
| component |
una cadena que corresponde al componente del color a devolver. Las opciones válidas son:
|
color_part('200,10,30','green')
→
10
Devuelve una representación en forma de cadena de un color en base a sus componentes rojo, verde y azul.
color_rgb
(
red
,
green
,
blue
)
| red | componente rojo del color, como un valor entero de 0 a 255 |
| green | componente verde del color, como un valor entero de 0 a 255 |
| blue | componente azul del color, como un valor entero de 0 a 255 |
color_rgb(255,127,0)
→
255,127,0
Devuelve una representación en forma de cadena de un color en base a sus componentes rojo, verde, azul y alfa (transparencia).
color_rgba
(
red
,
green
,
blue
,
alpha
)
| red | componente rojo del color, como un valor entero de 0 a 255 |
| green | componente verde del color, como un valor entero de 0 a 255 |
| blue | componente azul del color, como un valor entero de 0 a 255 |
| alpha | componente alfa como un valor entero de 0 (completamente transparente) a 255 (opaco). |
color_rgba(255,127,0,200)
→
255,127,0,200
Devuelve una rampa de gradiente de un mapa de colores y pasos.
create_ramp
(
map
[,
discrete
])
| map | a map of color strings and steps |
| discrete | declarar si la rampa de color es discreta |
ramp_color(create_array(map(0,'0,0,0',1,'255,0,0')),1)
→
'255,0,0,255'
Devuelve una cadena de color más oscura (o más clara)
darker
(
color
,
factor
)
| color | una cadena de color |
| factor |
un número entero que corresponde al factor de oscurecimiento:
|
darker('200,10,30',300)
→
'66,3,10,255'
Devuelve una cadena de color más clara (o más oscura)
lighter
(
color
,
factor
)
| color | una cadena de color |
| factor |
un número entero que corresponde al factor de aclarado:
|
lighter('200,10,30',200)
→
'255,158,168,255'
Devuelve un color del esquema de color del proyecto.
project_color
(
name
)
| name | el nombre de un color |
project_color('Logo color')
→
20,140,50
Devuelve una cadena que representa un color de una rampa de color.
ramp_color
(
ramp_name
,
value
)
| ramp_name | el nombre de la rampa de color como una cadena, por ejemplo 'Spectral' |
| value | la posición en la rampa de la que seleccionar el color, como un número real entre 0 y 1 |
ramp_color('Spectral',0.3)
→
'253,190,115,255'
Las rampas de color disponibles varían entre instalaciones de QGIS. Esta función puede no dar el resultado esperado su mueve su proyecto de QGIS entre instalaciones.
ramp_color
(
ramp
,
value
)
| ramp | la rampa de color |
| value | la posición en la rampa de la que seleccionar el color, como un número real entre 0 y 1 |
ramp_color(create_ramp(map(0,'0,0,0',1,'255,0,0')),1)
→
'255,0,0,255'
Establece el componente de un color específico para la cadena de un color, por ejemplo el componente rojo o el alfa.
set_color_part
(
color
,
component
,
value
)
| color | una cadena de color |
| component |
una cadena que corresponde al componente del color a establecer. Las opciones válidas son:
|
| value | valor nuevo para el componente de color, restetando los rangos listados arriba |
set_color_part('200,10,30','green',50)
→
200,50,30
Este grupo contiene funciones para realizar comprobaciones condicionales en expresiones.
Devuelve el primer valor no-NULO de la lista de expresiones
Esta función puede tomar cualquier número de argumentos.
coalesce
(
expression1
,
expression2
…)
| expression | cualquier expresión o valor válidos, sin importar el tipo. |
coalesce(NULO, 2)
→
2
coalesce(NULO, 2, 3)
→
2
coalesce(7, NULO, 3*2)
→
7
coalesce("campoA", "fallbackField", 'ERROR')
→
el valor del campoA si no es NULO, de lo contrario el valor de "fallbackField" o la cadena 'ERROR' si ambos son NULO
Prueba una condición y devuelve un resultado diferente dependiendo de la comprobación condicional.
if
(
condition
,
result_when_true
,
result_when_false
)
| condition | la condición que se debe evaluar |
| result_when_true | el resultado que se devolverá cuando la condición sea verdadera u otro valor que no convierta a falso. |
| result_when_false | el resultado que se devolverá cuando la condición sea falsa u otro valor que convierta a falso como 0 o ". NULO también se convertirá a falso. |
if( 1+1=2, 'Yes', 'No' )
→
'Sí'
if( 1+1=3, 'Yes', 'No' )
→
'No'
if( 5 > 3, 1, 0)
→
1
if( '', 'It is true (not empty)', 'It is false (empty)' )
→
'It is false (empty)'
if( ' ', 'It is true (not empty)', 'It is false (empty)' )
→
'It is true (not empty)'
if( 0, 'One', 'Zero' )
→
'Cero'
if( 10, 'One', 'Zero' )
→
'Uno'
Returns a null value if value1 equals value2; otherwise it returns value1. This can be used to conditionally substitute values with NULL.
nullif
(
value1
,
value2
)
| value1 | The value that should either be used or substituted with NULL. |
| value2 | The control value that will trigger the NULL substitution. |
nullif('(none)', '(none)')
→
NULO
nullif('text', '(none)')
→
'text'
nullif("name", '')
→
NULL, if name is an empty string (or already NULL), the name in any other case.
Devuelve la primera posición que coincide con una expresión regular dentro de una cadena o 0 si no se encuentra la subcadena.
regexp_match
(
input_string
,
regex
)
| input_string | La cadena a probar frente a la expresión regular |
| regex | La expresión regular frente a la que probar. El carácter barra invertida se debe escapar doblemente (ej.: "\\s" para capturar un carácter espacio en blanco). |
regexp_match('QGIS ROCKS','\\sROCKS')
→
4
Intenta ejecutar una expresión y devuelve su valor si está libre de error. Si la expresión devuelve un error, se regresará un valor alternativo cuando se proporcione, de otro modo devolverá nulo.
try
(
expression
[,
alternative
])
| expression | la expresión que debe utilizarse |
| alternative | el resultado que será devuelto si la expresión regresa un error. |
try( to_int( '1' ), 0 )
→
1
try( to_int( 'a' ), 0 )
→
0
try( to_date( 'invalid_date' ) )
→
NULO
Este grupo contiene funciones para convertir unos tipos de datos en otros, por ejemplo cadena a entero o entero a cadena.
Decodes a string in the Base64 encoding into a binary value.
from_base64
(
string
)
| string | the string to decode |
from_base64('UUdJUw==')
→
'QGIS'
Creates a hash from a string with a given method.
hash
(
string
,
method
)
| string | the string to hash |
| method | The hash method among 'md4', 'md5', 'sha1', 'sha224', 'sha384', 'sha512', 'sha3_224', 'sha3_256', 'sha3_384', 'sha3_512', 'keccak_224', 'keccak_256', 'keccak_384', 'keccak_512' |
hash('QGIS', md4)
→
'c0fc71c241cdebb6e888cbac0e2b68eb'
hash('QGIS', md5)
→
'57470aaa9e22adaefac7f5f342f1c6da'
hash('QGIS', sha1)
→
'f87cfb2b74cdd5867db913237024e7001e62b114'
hash('QGIS', sha224)
→
'4093a619ada631c770f44bc643ead18fb393b93d6a6af1861fcfece0'
hash('QGIS', sha256)
→
'eb045cba7a797aaa06ac58830846e40c8e8c780bc0676d3393605fae50c05309'
hash('QGIS', sha384)
→
'91c1de038cc3d09fdd512e99f9dd9922efadc39ed21d3922e69a4305cc25506033aee388e554b78714c8734f9cd7e610'
hash('QGIS', sha512)
→
'c2c092f2ab743bf8edbeb6d028a745f30fc720408465ed369421f0a4e20fa5e27f0c90ad72d3f1d836eaa5d25cd39897d4cf77e19984668ef58da6e3159f18ac'
hash('QGIS', sha3_224)
→
'467f49a5039e7280d5d42fd433e80d203439e338eaabd701f0d6c17d'
hash('QGIS', sha3_256)
→
'540f7354b6b8a6e735f2845250f15f4f3ba4f666c55574d9e9354575de0e980f'
hash('QGIS', sha3_384)
→
'96052da1e77679e9a65f60d7ead961b287977823144786386eb43647b0901fd8516fa6f1b9d243fb3f28775e6dde6107'
hash('QGIS', sha3_512)
→
'900d079dc69761da113980253aa8ac0414a8bd6d09879a916228f8743707c4758051c98445d6b8945ec854ff90655005e02aceb0a2ffc6a0ebf818745d665349'
hash('QGIS', keccak_224)
→
'5b0ce6acef8b0a121d4ac4f3eaa8503c799ad4e26a3392d1fb201478'
hash('QGIS', keccak_256)
→
'991c520aa6815392de24087f61b2ae0fd56abbfeee4a8ca019c1011d327c577e'
hash('QGIS', keccak_384)
→
'c57a3aed9d856fa04e5eeee9b62b6e027cca81ba574116d3cc1f0d48a1ef9e5886ff463ea8d0fac772ee473bf92f810d'
keccak_512('QGIS')
→
'6f0f751776b505e317de222508fa5d3ed7099d8f07c74fed54ccee6e7cdc6b89b4a085e309f2ee5210c9'
Creates a md5 hash from a string.
md5
(
string
)
| string | the string to hash |
md5('QGIS')
→
'57470aaa9e22adaefac7f5f342f1c6da'
Creates a sha256 hash from a string.
sha256
(
string
)
| string | the string to hash |
sha256('QGIS')
→
'eb045cba7a797aaa06ac58830846e40c8e8c780bc0676d3393605fae50c05309'
Encodes a binary value into a string, using the Base64 encoding.
to_base64
(
value
)
| value | the binary value to encode |
to_base64('QGIS')
→
'UUdJUw=='
Convierte una cadena de caracteres en un objeto fecha. Una cadena opcional de formato puede proporcionarse para formatear la cadena; ver QDate::fromString para documentación adicional sobre el formato.
to_date
(
string
[,
format
][,
language
])
| string | cadena que representa un valor de fecha |
| format | format used to convert the string into a date |
| language | idioma (minúsculas, dos- o tres-letras, código de idioma ISO 639) usado para convertir la cadena a fecha |
to_date('2012-05-04')
→
2012-05-04
to_date('June 29, 2019','MMMM d, yyyy')
→
2019-06-29
to_date('29 juin, 2019','d MMMM, yyyy','fr')
→
2019-06-29
Convierte una cadena de caracteres en un objeto fecha-hora. Una cadena opcional de formato puede proporcionarse para formatear la cadena; ver QDate::fromString para documentación adicional sobre el formato.
to_datetime
(
string
[,
format
][,
language
])
| string | cadena que representa un valor de fecha y hora |
| format | formato usado para convertir la cadena a fecha-hora |
| language | idioma (minúsculas, dos- o tres-letras, código de idioma ISO 639) usado para convertir la cadena a fecha-hora |
to_datetime('2012-05-04 12:50:00')
→
2012-05-04T12:50:00
to_datetime('June 29, 2019 @ 12:34','MMMM d, yyyy @ HH:mm')
→
2019-06-29T12:34
to_datetime('29 juin, 2019 @ 12:34','d MMMM, yyyy @ HH:mm','fr')
→
2019-06-29T12:34
Convertir una coordenada a grados, minutos.
to_dm
(
coordinate
,
axis
,
precision
[,
formatting
])
| coordinate | Un valor de latitud o longitud. |
| axis | El eje de la coordenada. Ya sea 'x' o 'y'. |
| precision | Número de decimales. |
| formatting | Designa el tipo de formato. Valores aceptables son NULL, 'aligned' o 'suffix'. |
to_dm(6.3545681, 'x', 3)
→
6°21.274′
to_dm(6.3545681, 'y', 4, 'suffix')
→
6°21.2741′N
Convertir una coordenada a grados, minutos, segundos.
to_dms
(
coordinate
,
axis
,
precision
[,
formatting
])
| coordinate | Un valor de latitud o longitud. |
| axis | El eje de la coordenada. Ya sea 'x' o 'y'. |
| precision | Número de decimales. |
| formatting | Designa el tipo de formato. Valores aceptables son NULL, 'aligned' o 'suffix'. |
to_dms(6.3545681, 'x', 3)
→
6°21′16.445″
to_dms(6.3545681, 'y', 4, 'suffix')
→
6°21′16.4452″N
Convierte una cadena a número entero. No devuelve nada si un valor no se puede convertir a entero (ej.: '123asd' no es válido).
to_int
(
string
)
| string | cadena a convertir a número entero |
to_int('123')
→
123
Converts a string to a interval type. Can be used to take days, hours, month, etc of a date.
to_interval
(
string
)
| string | una cadena que representa un intervalo. Los formatos permitidos incluyen {n} días {n} horas {n} meses. |
to_datetime('2012-05-05 12:00:00') - to_interval('1 día 2 horas')
→
2012-05-04T10:00:00
Convierte una cadena a número real. No devuelve nada si un valor no se puede convertir a real (ej.: '123.56asd' no es válido). Los números se redondean después de guardar los cambios si la precisión es menor que el resultado de la conversión.
to_real
(
string
)
| string | cadena a convertir a número real |
to_real('123.45')
→
123.45
Convierte un número en cadena.
to_string
(
number
)
| number | Valor entero o real. El número a convertir en cadena. |
to_string(123)
→
'123'
Converts a string into a time object. An optional format string can be provided to parse the string; see QTime::fromString for additional documentation on the format.
to_time
(
string
[,
format
][,
language
])
| string | cadena que representa un valor hora |
| format | formato utilizado para convertir la cadena a hora |
| language | idioma (minúsculas, dos- o tres-letras, código de idioma ISO 639) usado para convertir la cadena a hora |
to_time('12:30:01')
→
12:30:01
to_time('12:34','HH:mm')
→
12:34:00
to_time('12:34','HH:mm','fr')
→
12:34:00
Este grupo contiene funciones para manipular datos de fecha y hora.
Devuelve la diferencia entre dos fechas o fechas y horas.
La diferencia se devuelve como un
Intervalo
y es necesario usarla con una de las siguientes funciones para extraer información útil:
año
mes
semana
día
hora
minuto
segundo
age
(
datetime1
,
datetime2
)
| datetime1 | una cadena, fecha o fecha y hora que representa la fecha posterior |
| datetime2 | una cadena, fecha o fecha y hora que representa la fecha anterior |
day(age('2012-05-12','2012-05-02'))
→
10
hour(age('2012-05-12','2012-05-02'))
→
240
Returns a datetime whose date and time are the number of milliseconds, msecs, that have passed since 1970-01-01T00:00:00.000, Coordinated Universal Time (Qt.UTC), and converted to Qt.LocalTime.
datetime_from_epoch
(
int
)
| int | number (milliseconds) |
datetime_from_epoch(1483225200000)
→
2017-01-01T00:00:00
Extracts the day from a date, or the number of days from an interval.
day
(
date
)
| date | una fecha o fecha y hora |
day('2012-05-12')
→
12
day
(
interval
)
| interval | intervalo del que devolver el número de días |
day(to_interval('3 days'))
→
3
day(to_interval('3 weeks 2 days'))
→
23
day(age('2012-01-01','2010-01-01'))
→
730
Devuelve el día de la semana para una fecha o fecha y hora especificadas. El valor devuelto varía entre 0 y 6, donde 0 corresponde a domingo y 6 a sábado.
day_of_week
(
date
)
| date | una fecha o fecha y hora |
day_of_week(to_date('2015-09-21'))
→
1
Returns the interval in milliseconds between the unix epoch and a given date value.
epoch
(
date
)
| date | una fecha o fecha y hora |
epoch(to_date('2017-01-01'))
→
1483203600000
Formats a date type or string into a custom string format. Uses Qt date/time format strings. See QDateTime::toString .
format_date
(
datetime
,
format
[,
language
])
| datetime | valor de fecha, hora o fecha y hora | ||||||||||||||||||||||||||||||||||||||||||||||||
| format |
String template used to format the string.
These expressions may be used for the time part of the format string:
|
||||||||||||||||||||||||||||||||||||||||||||||||
| language | language (lowercase, two- or three-letter, ISO 639 language code) used to format the date into a custom string |
format_date('2012-05-15','dd.MM.yyyy')
→
'15.05.2012'
format_date('2012-05-15','d MMMM yyyy','fr')
→
'15 juin 2012'
Extracts the hour part from a datetime or time, or the number of hours from an interval.
hour
(
datetime
)
| datetime | un valor de hora o fecha y hora |
hour('2012-07-22T13:24:57')
→
13
hour
(
interval
)
| interval | intervalo del que devolver el número de horas |
hour(tointerval('3 horas'))
→
3
hour(age('2012-07-22T13:00:00','2012-07-22T10:00:00'))
→
3
hour(age('2012-01-01','2010-01-01'))
→
17520
Creates a date value from year, month and day numbers.
make_date
(
year
,
month
,
day
)
| year | Year number. Years 1 to 99 are interpreted as is. Year 0 is invalid. |
| month | Month number, where 1=January |
| day | Day number, beginning with 1 for the first day in the month |
make_date(2020,5,4)
→
date value 2020-05-04
Creates a datetime value from year, month, day, hour, minute and second numbers.
make_datetime
(
year
,
month
,
day
,
hour
,
minute
,
second
)
| year | Year number. Years 1 to 99 are interpreted as is. Year 0 is invalid. |
| month | Month number, where 1=January |
| day | Day number, beginning with 1 for the first day in the month |
| hour | Hour number |
| minute | Minutes |
| second | Seconds (fractional values include milliseconds) |
make_datetime(2020,5,4,13,45,30.5)
→
datetime value 2020-05-04 13:45:30.500
Creates an interval value from year, month, weeks, days, hours, minute and seconds values.
make_interval
([
years=0
][,
months=0
][,
weeks=0
][,
days=0
][,
hours=0
][,
minutes=0
][,
seconds=0
])
| years | Number of years (assumes a 365.25 day year length). |
| months | Number of months (assumes a 30 day month length) |
| weeks | Number of weeks |
| days | Number of days |
| hours | Number of hours |
| minutes | Number of minutes |
| seconds | Number of seconds |
make_interval(hours:=3)
→
3 hour interval
make_interval(days:=2, hours:=3)
→
2 day, 3 hour interval
Creates a time value from hour, minute and second numbers.
make_time
(
hour
,
minute
,
second
)
| hour | Hour number |
| minute | Minutes |
| second | Seconds (fractional values include milliseconds) |
make_time(13,45,30.5)
→
time value 13:45:30.500
Extracts the minutes part from a datetime or time, or the number of minutes from an interval.
minute
(
datetime
)
| datetime | un valor de hora o fecha y hora |
minute('2012-07-22T13:24:57')
→
24
minute
(
interval
)
| interval | intervalo del que devolver el número de minutos |
minute(tointerval('3 minutos'))
→
3
minute(age('2012-07-22T00:20:00','2012-07-22T00:00:00'))
→
20
minute(age('2012-01-01','2010-01-01'))
→
1051200
Extracts the month part from a date, or the number of months from an interval.
month
(
date
)
| date | una fecha o fecha y hora |
month('2012-05-12')
→
05
month
(
interval
)
| interval | intervalo del que devolver el número de meses |
month(to_interval('3 meses'))
→
3
month(age('2012-01-01','2010-01-01'))
→
4.03333
Returns the current date and time. The function is static and will return consistent results while evaluating. The time returned is the time when the expression is prepared.
now
()
now()
→
2012-07-22T13:24:57
Extracts the seconds part from a datetime or time, or the number of seconds from an interval.
second
(
datetime
)
| datetime | un valor de hora o fecha y hora |
second('2012-07-22T13:24:57')
→
57
second
(
interval
)
| interval | intervalo del que devolver el número de segundos |
second(age('2012-07-22T00:20:00','2012-07-22T00:00:00'))
→
1200
second(age('2012-01-01','2010-01-01'))
→
63072000
Convierte una cadena de caracteres en un objeto fecha. Una cadena opcional de formato puede proporcionarse para formatear la cadena; ver QDate::fromString para documentación adicional sobre el formato.
to_date
(
string
[,
format
][,
language
])
| string | cadena que representa un valor de fecha |
| format | format used to convert the string into a date |
| language | idioma (minúsculas, dos- o tres-letras, código de idioma ISO 639) usado para convertir la cadena a fecha |
to_date('2012-05-04')
→
2012-05-04
to_date('June 29, 2019','MMMM d, yyyy')
→
2019-06-29
to_date('29 juin, 2019','d MMMM, yyyy','fr')
→
2019-06-29
Convierte una cadena de caracteres en un objeto fecha-hora. Una cadena opcional de formato puede proporcionarse para formatear la cadena; ver QDate::fromString para documentación adicional sobre el formato.
to_datetime
(
string
[,
format
][,
language
])
| string | cadena que representa un valor de fecha y hora |
| format | formato usado para convertir la cadena a fecha-hora |
| language | idioma (minúsculas, dos- o tres-letras, código de idioma ISO 639) usado para convertir la cadena a fecha-hora |
to_datetime('2012-05-04 12:50:00')
→
2012-05-04T12:50:00
to_datetime('June 29, 2019 @ 12:34','MMMM d, yyyy @ HH:mm')
→
2019-06-29T12:34
to_datetime('29 juin, 2019 @ 12:34','d MMMM, yyyy @ HH:mm','fr')
→
2019-06-29T12:34
Converts a string to a interval type. Can be used to take days, hours, month, etc of a date.
to_interval
(
string
)
| string | una cadena que representa un intervalo. Los formatos permitidos incluyen {n} días {n} horas {n} meses. |
to_datetime('2012-05-05 12:00:00') - to_interval('1 día 2 horas')
→
2012-05-04T10:00:00
Converts a string into a time object. An optional format string can be provided to parse the string; see QTime::fromString for additional documentation on the format.
to_time
(
string
[,
format
][,
language
])
| string | cadena que representa un valor hora |
| format | formato utilizado para convertir la cadena a hora |
| language | idioma (minúsculas, dos- o tres-letras, código de idioma ISO 639) usado para convertir la cadena a hora |
to_time('12:30:01')
→
12:30:01
to_time('12:34','HH:mm')
→
12:34:00
to_time('12:34','HH:mm','fr')
→
12:34:00
Extracts the week number from a date, or the number of weeks from an interval.
week
(
date
)
| date | una fecha o fecha y hora |
week('2012-05-12')
→
19
week
(
interval
)
| interval | intervalo del que devolver el número de meses |
week(to_interval('3 weeks'))
→
3
week(age('2012-01-01','2010-01-01'))
→
104.285
Extracts the year part from a date, or the number of years from an interval.
year
(
date
)
| date | una fecha o fecha y hora |
year('2012-05-12')
→
2012
year
(
interval
)
| interval | intervalo del que devolver el número de años |
year(to_interval('3 años'))
→
3
year(age('2012-01-01','2010-01-01'))
→
1.9986
Contains functions which manipulate file and path names.
Returns the base name of the file without the directory or file suffix.
base_file_name
(
path
)
| path | a file path |
base_file_name('/home/qgis/data/country_boundaries.shp')
→
'country_boundaries'
Returns true if a file path exists.
file_exists
(
path
)
| path | a file path |
file_exists('/home/qgis/data/country_boundaries.shp')
→
verdadero
Returns the name of a file (including the file extension), excluding the directory.
file_name
(
path
)
| path | a file path |
file_name('/home/qgis/data/country_boundaries.shp')
→
'country_boundaries.shp'
Returns the directory component of a file path. This does not include the file name.
file_path
(
path
)
| path | a file path |
file_path('/home/qgis/data/country_boundaries.shp')
→
'/home/qgis/data'
Returns the size (in bytes) of a file.
file_size
(
path
)
| path | a file path |
file_size('/home/qgis/data/country_boundaries.geojson')
→
5674
Returns the file suffix (extension) from a file path.
file_suffix
(
path
)
| path | a file path |
file_suffix('/home/qgis/data/country_boundaries.shp')
→
'shp'
Returns true if a path corresponds to a directory.
is_directory
(
path
)
| path | a file path |
is_directory('/home/qgis/data/country_boundaries.shp')
→
falso
is_directory('/home/qgis/data/')
→
verdadero
Returns true if a path corresponds to a file.
is_file
(
path
)
| path | a file path |
is_file('/home/qgis/data/country_boundaries.shp')
→
verdadero
is_file('/home/qgis/data/')
→
falso
Only usable in an embedded form context, this function returns the current, unsaved value of a field in the parent form currently being edited. This will differ from the parent feature's actual attribute values for features which are currently being edited or have not yet been added to a parent layer. When used in a value-relation widget filter expression, this function should be wrapped into a 'coalesce()' that can retrieve the actual parent feature from the layer when the form is not used in an embedded context.
current_parent_value
(
field_name
)
| field_name | a field name in the current parent form |
current_parent_value( 'FIELD_NAME' )
→
The current value of a field 'FIELD_NAME' in the parent form.
Returns the current, unsaved value of a field in the form or table row currently being edited. This will differ from the feature's actual attribute values for features which are currently being edited or have not yet been added to a layer.
current_value
(
field_name
)
| field_name | a field name in the current form or table row |
current_value( 'FIELD_NAME' )
→
The current value of field 'FIELD_NAME'.
Este grupo contiene funciones para comparaciones simples entre valores.
Devuelve la distancia de Hamming entre dos cadenas. Esto es igual al número de caracteres en las posiciones correspondientes dentro de las cadenas de entrada donde los caracteres son diferentes. Las cadenas de entrada deben tener la misma longitud y la comparación es sensible a mayúsculas.
hamming_distance
(
string1
,
string2
)
| string1 | una cadena |
| string2 | una cadena |
hamming_distance('abc','xec')
→
2
hamming_distance('abc','ABc')
→
2
hamming_distance(upper('abc'),upper('ABC'))
→
0
Devuelve la distancia de edición de Levenshtein entre dos cadenas. Esto es el número mínimo de ediciones de caracteres (inserciones, borrados o sustituciones) necesario para convertir una cadena en otra.
La distancia de Levenshtein es una medida de la similitud entre dos cadenas. Distancias menores significan que las cadenas son más parecidas y distancias mayores indican más diferencia entre las cadenas. La distancia distingue entre mayúsculas y minúsculas.
levenshtein
(
string1
,
string2
)
| string1 | una cadena |
| string2 | una cadena |
levenshtein('mínimo','máximo')
→
2
levenshtein('Mínimo','mínimo')
→
1
levenshtein(upper('Mínimo'),upper('mínimo'))
→
0
Devuelve la subcadena común más larga entre dos cadenas. Esta subcadena es la más larga que es una subcadena de las dos cadenas de entrada. Por ejemplo, la subcadena más larga común de "ABABC" y "BABCA" es "ABC". La subcadena distingue mayúsculas/minúsculas.
longest_common_substring
(
string1
,
string2
)
| string1 | una cadena |
| string2 | una cadena |
longest_common_substring('ABABC','BABCA')
→
'ABC'
longest_common_substring('abcDeF','abcdef')
→
'abc'
longest_common_substring(upper('abcDeF'),upper('abcdex'))
→
'ABCDE'
Devuelve la representación Soundex de una cadena. Soundex es un algoritmo de coincidencia fonética, de forma que cadenas con sonidos similares deben representarse por el mismo código Soundex.
soundex
(
string
)
| string | una cadena |
soundex('robert')
→
'R163'
soundex('rupert')
→
'R163'
soundex('rubin')
→
'R150'
Este grupo contiene funciones generales variadas.
Obtiene una variable de entorno y devuelve su contenido como cadena. Si la variable no se encuentra devuelve "NULO". Esto es útil para introducir configuraciones específicas del sistema, como la letra de unidad o prefijos de rutas. La definición de variables de entorno depende del sistema operativo, por favor consulte cómo se puede establecer con el administrador de su equipo o en la documentación del sistema operativo.
env
(
name
)
| name | El nombre de la variable de entorno que de debe recuperar. |
env( 'LANG' )
→
'en_US.UTF-8'
env( 'MY_OWN_PREFIX_VAR' )
→
'Z:'
env( 'I_DO_NOT_EXIST' )
→
NULO
Evalúa una expresión que es pasada en una cadena. Útil para expandir parámetros dinámicos pasados como variables de contexto o campos.
eval
(
expression
)
| expression | una cadena de expresión |
eval(''nice'')
→
'nice'
eval(@expression_var)
→
[whatever the result of evaluating @expression_var might be…]
Evaluates a template which is passed in a string. Useful to expand dynamic parameters passed as context variables or fields.
eval_template
(
template
)
| template | a template string |
eval_template('QGIS [% upper(\'rocks\') %]')
→
QGIS ROCKS
Devuelve verdadero si la capa especificada es visible.
is_layer_visible
(
layer
)
| layer | Una cadena que represente el nombre o la ID de una capa |
is_layer_visible('baseraster')
→
Verdadero
Devuelve el valor de una propiedad o metadato de una capa.
layer_property
(
layer
,
property
)
| layer | Una cadena que represente el nombre o la ID de una capa |
| property |
a string corresponding to the property to return. Valid options are:
|
layer_property('calles','title')
→
'Mapa base de calles'
layer_property('aeropuertos','feature_count')
→
120
layer_property('landsat','crs')
→
'EPSG:4326'
Devuelve el valor guardado dentro de una variable especificada.
var
(
name
)
| name | un nombre de variable |
var('qgis_version')
→
'2.12'
Esta función establece una variable para el código de cualquier expresión que se proporcionará como tercer argumento. Esto solo es útil para expresiones complejas, en las que se necesita usar el mismo valor calculado en diferentes sitios.
with_variable
(
name
,
value
,
expression
)
| name | el nombre de la variable a establecer |
| value | el valor a establecer |
| expression | la expresión para la que estará disponible la variable |
with_variable('my_sum', 1 + 2 + 3, @my_sum * 2 + @my_sum * 5)
→
42
Este grupo contiene funciones que operan sobre elementos de geometría, como longitud o área.
Devuelve el área del objeto actual. El área calculada por esta función respeta tanto la configuración del elipsoide del proyecto actual como la de las unidades de área. Por ejemplo, si se ha establecido un elipsoide para el proyecto, entonces el área calculada será elipsoidal y si no se ha establecido ningún elipsoide, entonces el área calculada será planimétrica.
$area
$area
→
42
Devuelve la geometría del objeto actual. Se puede usar para procesos con otras funciones.
$geometry
geomToWKT( $geometry )
→
PUNTO(6 50)
Devuelve la longitud de una cadena de líneas. Si necesita la longitud del contorno de un polígono, utilice mejor $perimeter. La longitud calculada por esta función respeta tanto la configuración del elipsoide del proyecto actual como la de las unidades de longitud. Por ejemplo, si se ha establecido un elipsoide para el proyecto, entonces la longitud calculada será elipsoidal y si no se ha establecido ningún elipsoide, entonces la longitud calculada será planimétrica.
$length
$length
→
42.4711
Devuelve la longitud del perímetro del objeto actual. El perímetro calculado por esta función respeta tanto la configuración del elipsoide del proyecto actual como la de las unidades de distancia. Por ejemplo, si se ha establecido un elipsoide para el proyecto, entonces el perímetro calculado será elipsoidal y si no se ha establecido ningún elipsoide, entonces el perímetro calculado será planimétrico.
$perimeter
$perimeter
→
42
Obtiene una coordenada X de la geometría del objeto actual.
$x_at
(
i
)
| i | index of point of a line (indices start at 0; negative values apply from the last index, starting at -1) |
$x_at(1)
→
5
Obtiene una coordenada Y de la geometría del objeto actual.
$y_at
(
i
)
| i | index of point of a line (indices start at 0; negative values apply from the last index, starting at -1) |
$y_at(1)
→
2
Devuelve un ángulo bisectriz (ángulo medio) a la geometría para un vértice especificado en una geometría de cadena de línea. Los ángulos están en grados en sentido horario a partir del norte.
angle_at_vertex
(
geometry
,
vertex
)
| geometry | una geometría de cadena de línea |
| vertex | vertex index, starting from 0; if the value is negative, the selected vertex index will be its total count minus the absolute value |
angle_at_vertex(geometry:=geom_from_wkt('LineString(0 0, 10 0, 10 10)'),vertex:=1)
→
45.0
Devuelve el área de un objeto de geometría de tipo polígono. Los cálculos siempre son planimétricos en el Sistema de Rerefencia Espacial (SRE) de esta geometría y las unidades del área devuelta coincidirán con las unidades del SRE. Esto difiere de los cálculos hechos por la función $area, que hará cálculos elipsoidales basados en el elipsoide del proyecto y la configuración de las unidades de superficie.
area
(
geometry
)
| geometry | objeto de geometría poligonal |
area(geom_from_wkt('POLYGON((0 0, 4 0, 4 2, 0 2, 0 0))'))
→
8.0
Devuelve el azimut basado en el Norte como el ángulo en radianes medido en sentido horario desde la vertical en el punto_A al Punto_b.
azimuth
(
point_a
,
point_b
)
| point_a | geometría de punto |
| point_b | geometría de punto |
degrees( azimuth( make_point(25, 45), make_point(75, 100) ) )
→
42.273689
degrees( azimuth( make_point(75, 100), make_point(25,45) ) )
→
222.273689
Devuelve el cierre del límite combinatorio de la geometría (es decir, el límite topológico de la geometría). Por ejemplo, una geometría de polígono tendrá un límite que consta de líneas para cada anillo en el polígono. Algunos tipos de geometría no tienen un límite definido, por ejemplo, puntos o colecciones de geometrías, y se devolverán nulos.
boundary
(
geometry
)
| geometry | una geometría |
geom_to_wkt(boundary(geom_from_wkt('Polygon((1 1, 0 0, -1 1, 1 1))')))
→
'LineString(1 1,0 0,-1 1,1 1)'
Devuelve una geometría que representa el recuadro delimitador de una geometría de entrada. Los cálculos están en el Sistema de Referencia Espacial de esta geometría.
bounds
(
geom
)
| geom | una geometría |
bounds($geometry)
→
recuadro delimitador de $geometry
Devuelve la altura del recuadro delimitador de una geometría. Los cálculos están en el Sistema de Referencia Espacial de esta geometría.
bounds_height
(
geom
)
| geom | una geometría |
bounds_height($geometry)
→
altura del recuadro delimitador de $geometry
Devuelve la anchura del recuadro delimitador de una geometría. Los cálculos están en el Sistema de Referencia Espacial de esta geometría.
bounds_width
(
geom
)
| geom | una geometría |
bounds_width($geometry)
→
anchura del recuadro delimitador de $geometry
Devuelve una geometría que representa todos los puntos cuya distancia desde esta geometría es menor o igual que distancia. Los cálculos están en el Sistema de Referencia Espacial de esta geometría.
buffer
(
geom
,
distance
[,
segments=8
])
| geom | una geometría |
| distance | distancia de buffer en unidades de la capa |
| segments | número de segmentos a usar para representar un cuarto de círculo cuando se utilice un estilo de unión redondo. Un número mayor da como resultado un buffer más suave con más nodos. |
buffer($geometry, 10.5)
→
polígono de $geometry con un buffer de 10.5 unidades
Creates a buffer along a line geometry where the buffer diameter varies according to the m-values at the line vertices.
buffer_by_m
(
geometry
[,
segments=8
])
| geometry | geometría de entrada. Debe ser una geometría (de varias líneas) con valores m. |
| segments | número de segmentos para aproximar las curvas del un cuarto de círculo en el buffer. |
buffer_by_m(geometry:=geom_from_wkt('LINESTRINGM(1 2 0.5, 4 2 0.2)'),segments:=8)
→
Un búfer de ancho variable que comienza con un diámetro de 0.5 y termina con un diámetro de 0.2 a lo largo de la geometría lineal.
Devuelve el centro geométrico de una geometría.
centroid
(
geom
)
| geom | una geometría |
centroid($geometry)
→
una geometría de punto
Returns a closed line string of the input line string by appending the first point to the end of the line, if it is not already closed. If the geometry is not a line string or multi line string then the result will be null.
close_line
(
geometry
)
| geometry | una geometría de cadena de línea |
geom_to_wkt(close_line(geom_from_wkt('LINESTRING(0 0, 1 0, 1 1)')))
→
LineString (0 0, 1 0, 1 1, 0 0)
geom_to_wkt(close_line(geom_from_wkt('LINESTRING(0 0, 1 0, 1 1, 0 0)')))
→
LineString (0 0, 1 0, 1 1, 0 0)
Returns the point on geometry1 that is closest to geometry2.
closest_point
(
geometry1
,
geometry2
)
| geometry1 | geometría en la que encontrar el punto más cercano |
| geometry2 | geometría a la que encontrar el punto más cercano |
geom_to_wkt(closest_point(geom_from_wkt('LINESTRING (20 80, 98 190, 110 180, 50 75 )'),geom_from_wkt('POINT(100 100)')))
→
Point(73.0769 115.384)
Collects a set of geometries into a multi-part geometry object.
collect_geometries
(
geometry1
,
geometry2
…)
| geometry | una geometría |
geom_to_wkt(collect_geometries(make_point(1,2), make_point(3,4), make_point(5,6)))
→
'MultiPoint ((1 2),(3 4),(5 6))'
collect_geometries
(
array
)
| array | array of geometry objects |
geom_to_wkt(collect_geometries(array(make_point(1,2), make_point(3,4), make_point(5,6))))
→
'MultiPoint ((1 2),(3 4),(5 6))'
Devuelve la combinación de dos geometrías.
combine
(
geometry1
,
geometry2
)
| geometry1 | una geometría |
| geometry2 | una geometría |
geom_to_wkt( combine( geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 2 1)' ) ) )
→
MULTILINESTRING((4 4, 2 1), (3 3, 4 4), (4 4, 5 5))
geom_to_wkt( combine( geom_from_wkt( 'LINESTRING(3 3, 4 4)' ), geom_from_wkt( 'LINESTRING(3 3, 6 6, 2 1)' ) ) )
→
LINESTRING(3 3, 4 4, 6 6, 2 1)
Comprueba si una geometría contiene a otra. Devuelve verdadero si y solo si ningún punto de la geometría b cae en el exterior de la geometría a y al menos un punto del interior de b cae en el interior de a.
contains
(
geometry a
,
geometry b
)
| geometry a | una geometría |
| geometry b | una geometría |
contains( geom_from_wkt( 'POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))' ), geom_from_wkt( 'POINT(0.5 0.5 )' ) )
→
verdadero
contains( geom_from_wkt( 'POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ) )
→
falso
Devuelve la envolvente convexa de una geometría. Representa la geometría convexa mínima que encierra todas las geometrías del conjunto.
convex_hull
(
geometry
)
| geometry | una geometría |
geom_to_wkt( convex_hull( geom_from_wkt( 'LINESTRING(3 3, 4 4, 4 10)' ) ) )
→
POLYGON((3 3,4 10,4 4,3 3))
Comprueba si una geometría cruza otra. Devuelve verdadero si las geometrías proporcionadas tienen algún punto interior en común, pero no todos.
crosses
(
geometry a
,
geometry b
)
| geometry a | una geometría |
| geometry b | una geometría |
crosses( geom_from_wkt( 'LINESTRING(3 5, 4 4, 5 3)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ) )
→
verdadero
crosses( geom_from_wkt( 'POINT(4 5)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ) )
→
falso
Devuelve una geometría que representa la parte de la geometría_a que no interseca con la geometría_b.
difference
(
geometry_a
,
geometry_b
)
| geometry_a | una geometría |
| geometry_b | una geometría |
geom_to_wkt( difference( geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4)' ) ) )
→
LINESTRING(4 4, 5 5)
Comprueba si las geometría no se intersecan espacialmente. Devuelve verdadero si las geometrías no comparten ningún espacio en común.
disjoint
(
geometry a
,
geometry b
)
| geometry a | una geometría |
| geometry b | una geometría |
disjoint( geom_from_wkt( 'POLYGON((0 0, 0 1, 1 1, 1 0, 0 0 ))' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ) )
→
verdadero
disjoint( geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ), geom_from_wkt( 'POINT(4 4)' ))
→
falso
Devuelve la distancia mínima (basada en la referencia espacial) entre dos geometrías en unidades proyectadas.
distance
(
geometry a
,
geometry b
)
| geometry a | una geometría |
| geometry b | una geometría |
distance( geom_from_wkt( 'POINT(4 4)' ), geom_from_wkt( 'POINT(4 8)' ) )
→
4
Devuelve la distancia a lo largo de la geometría a un vértice especificado.
distance_to_vertex
(
geometry
,
vertex
)
| geometry | una geometría de cadena de línea |
| vertex | vertex index, starting from 0; if the value is negative, the selected vertex index will be its total count minus the absolute value |
distance_to_vertex(geometry:=geom_from_wkt('LineString(0 0, 10 0, 10 10)'),vertex:=1)
→
10.0
Devuelve el último nodo de una geometría.
end_point
(
geometry
)
| geometry | objeto de geometría |
geom_to_wkt(end_point(geom_from_wkt('LINESTRING(4 0, 4 2, 0 2)')))
→
'Point (0 2)'
Extiende el inicio y final de una geometría de cadena de líneas en una cantidad especificada. Las líneas se extienden usando el rumbo del primer y último segmentos de la línea. Las distancias están el Sistema de Referencia Espacial de esta geometría.
extend
(
geometry
,
start_distance
,
end_distance
)
| geometry | una geometría de (multi)cadena de líneas |
| start_distance | distancia a extender el inicio de la línea |
| end_distance | distancia a extender el final de la línea. |
geom_to_wkt(extend(geom_from_wkt('LineString(0 0, 1 0, 1 1)'),1,2))
→
LineString (-1 0, 1 0, 1 3)
Devuelve una cadena de línea que representa el anillo exterior de una geometría de tipo polígono. Si la geometría no es un polígono entonces el resultado será nulo.
exterior_ring
(
geom
)
| geom | una geometría de polígono |
geom_to_wkt(exterior_ring(geom_from_wkt('POLYGON((-1 -1, 4 0, 4 2, 0 2, -1 -1),( 0.1 0.1, 0.1 0.2, 0.2 0.2, 0.2, 0.1, 0.1 0.1))')))
→
'LineString (-1 -1, 4 0, 4 2, 0 2, -1 -1)'
Devuelve una versión extruida de la geometría de entrada (multi)curva o (multi)línea, con una extensión especificada por X e Y.
extrude
(
geom
,
x
,
y
)
| geom | una geometría de polígono |
| x | extensión X, valor numérico |
| y | extensión Y, valor numérico |
extrude(geom_from_wkt('LineString(1 2, 3 2, 4 3)'), 1, 2)
→
Polygon ((1 2, 3 2, 4 3, 5 5, 4 4, 2 4, 1 2))
extrude(geom_from_wkt('MultiLineString((1 2, 3 2), (4 3, 8 3)'), 1, 2)
→
MultiPolygon (((1 2, 3 2, 4 4, 2 4, 1 2)),((4 3, 8 3, 9 5, 5 5, 4 3)))
Returns a copy of the geometry with the x and y coordinates swapped. Useful for repairing geometries which have had their latitude and longitude values reversed.
flip_coordinates
(
geom
)
| geom | una geometría |
geom_to_wkt(flip_coordinates(make_point(1, 2)))
→
Point (2 1)
Forces a geometry to respect the Right-Hand-Rule, in which the area that is bounded by a polygon is to the right of the boundary. In particular, the exterior ring is oriented in a clockwise direction and the interior rings in a counter-clockwise direction.
force_rhr
(
geom
)
| geom | a geometry. Any non-polygon geometries are returned unchanged. |
geom_to_wkt(force_rhr(geometry:=geom_from_wkt('POLYGON((-1 -1, 4 0, 4 2, 0 2, -1 -1))')))
→
Polygon ((-1 -1, 0 2, 4 2, 4 0, -1 -1))
Devuelve una geometría a partir de una representación GML de geometría.
geom_from_gml
(
gml
)
| gml | Representación GML de una geometría como una cadena |
geom_from_gml('<gml:LineString srsName="EPSG:4326"><gml:coordinates>4,4 5,5 6,6</gml:coordinates></gml:LineString>')
→
a line geometry object
Returns a geometry created from a Well-Known Binary (WKB) representation.
geom_from_wkb
(
binary
)
| binary | Well-Known Binary (WKB) representation of a geometry (as a binary blob) |
geom_from_wkb( geom_to_wkb( make_point(4,5) ) )
→
a point geometry object
Devuelve una geometría creada a partir de una representación WKT (Texto Bien Conocido).
geom_from_wkt
(
text
)
| text | Representación WKT (Texto Bien Conocido) de una geometría |
geom_from_wkt( 'POINT(4 5)' )
→
un objeto de geometría
Returns the Well-Known Binary (WKB) representation of a geometry
geom_to_wkb
(
geometry
)
| geometry | una geometría |
geom_to_wkb( $geometry )
→
binary blob containing a geometry object
Devuelve una representación WKT (Texto Bien Conocido) de la geometría sin metadatos SRID.
geom_to_wkt
(
geometry
[,
precision
])
| geometry | una geometría |
| precision | numeric precision |
geom_to_wkt( $geometry )
→
PUNTO(6 50)
Devuelve la geometría de un objeto.
geometry
(
feature
)
| feature | un objeto espacial |
geom_to_wkt( geometry( get_feature( capa, campo, valor ) ) )
→
'PUNTO(6 50)'
intersects( $geometry, geometry( get_feature( capa, campo, valor ) ) )
→
verdadero
Devuelve una geometría específica a partir de una colección de geometrías o nulo si la geometría de entrada no es una colección.
geometry_n
(
geometry
,
index
)
| geometry | colección de geometrías |
| index | índice de la geometría a devolver, donde 1 es la primera geometría de la colección |
geom_to_wkt(geometry_n(geom_from_wkt('GEOMETRYCOLLECTION(POINT(0 1), POINT(0 0), POINT(1 0), POINT(1 1))'),3))
→
'Point (1 0)'
Devuelve la distancia de Hausdorff entre dos geometrías. Esto es básicamente una medida de cómo de similares o diferentes son dos geometrías, con una distancia menor indicando geometrías más parecidas.
La función se puede ejecutar con un argumento fracción de densificación opcional. Si no se especifica se usará una aproximación de la distancia estándar de Hausdorff. Esta aproximación es exacta o suficientemente aproximada para un gran subconjunto de casos útiles. Ejemplos de esto son:
hausdorff_distance
(
geometry a
,
geometry b
[,
densify_fraction
])
| geometry a | una geometría |
| geometry b | una geometría |
| densify_fraction | Densificar la cantidad de fracciones |
hausdorff_distance( geometry1:= geom_from_wkt('LINESTRING (0 0, 2 1)'),geometry2:=geom_from_wkt('LINESTRING (0 0, 2 0)'))
→
2
hausdorff_distance( geom_from_wkt('LINESTRING (130 0, 0 0, 0 150)'),geom_from_wkt('LINESTRING (10 10, 10 150, 130 10)'))
→
14.142135623
hausdorff_distance( geom_from_wkt('LINESTRING (130 0, 0 0, 0 150)'),geom_from_wkt('LINESTRING (10 10, 10 150, 130 10)'),0.5)
→
70.0
Devuelve la inclinación medida desde el cénit (0) al nadir (180) en el punto A al punto B.
inclination
(
point_a
,
point_b
)
| point_a | geometría de punto |
| point_b | geometría de punto |
inclination( make_point( 5, 10, 0 ), make_point( 5, 10, 5 ) )
→
0.0
inclination( make_point( 5, 10, 0 ), make_point( 5, 10, 0 ) )
→
90.0
inclination( make_point( 5, 10, 0 ), make_point( 50, 100, 0 ) )
→
90.0
inclination( make_point( 5, 10, 0 ), make_point( 5, 10, -5 ) )
→
180.0
Devuelve un anillo interior específico de una geometría de tipo polígono o nulo si la geometría no es un polígono.
interior_ring_n
(
geometry
,
index
)
| geometry | geometría de tipo polígono |
| index | índice del interior a devolver, donde 1 es el primer anillo interior |
geom_to_wkt(interior_ring_n(geom_from_wkt('POLYGON((-1 -1, 4 0, 4 2, 0 2, -1 -1),(-0.1 -0.1, 0.4 0, 0.4 0.2, 0 0.2, -0.1 -0.1),(-1 -1, 4 0, 4 2, 0 2, -1 -1))'),1))
→
'LineString (-0.1 -0.1, 0.4 0, 0.4 0.2, 0 0.2, -0.1 -0.1))'
Devuelve una geometría que representa la parte compartida de dos geometrías.
intersection
(
geometry1
,
geometry2
)
| geometry1 | una geometría |
| geometry2 | una geometría |
geom_to_wkt( intersection( geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4)' ) ) )
→
LINESTRING(3 3, 4 4)
Comprueba si una geometría se interseca con otra. Devuelve verdadero si las geometrías se intersecan espacialmente (comparten alguna porción de espacio) y falso en caso contrario.
intersects
(
geometry a
,
geometry b
)
| geometry a | una geometría |
| geometry b | una geometría |
intersects( geom_from_wkt( 'POINT(4 4)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ) )
→
verdadero
intersects( geom_from_wkt( 'POINT(4 5)' ), geom_from_wkt( 'POINT(5 5)' ) )
→
falso
Comprueba si el recuadro delimitador de una geometría solapa con el de otra geometría. Devuelve verdadero si los recuadros delimitadores de las geometrías se intersecan espacialmente y falso en caso contrario.
intersects_bbox
(
geometry
,
geometry
)
| geometry | una geometría |
| geometry | una geometría |
intersects_bbox( geom_from_wkt( 'POINT(4 5)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ) )
→
verdadero
intersects_bbox( geom_from_wkt( 'POINT(6 5)' ), geom_from_wkt( 'POLYGON((3 3, 4 4, 5 5, 3 3))' ) )
→
falso
Devuelve verdadero si una cadena de línea está cerrada (los puntos de inicio y final coinciden) o falso si la cadena de línea no está cerrada. Si la geometría no es una cadena de línea entonces el resultado será nulo.
is_closed
(
geom
)
| geom | una geometría de cadena de línea |
is_closed(geom_from_wkt('LINESTRING(0 0, 1 1, 2 2)'))
→
falso
is_closed(geom_from_wkt('LINESTRING(0 0, 1 1, 2 2, 0 0)'))
→
verdadero
Returns true if a geometry is empty (without coordinates), false if the geometry is not empty and NULL if there is no geometry. See also `is_empty_or_null`.
is_empty
(
geom
)
| geom | una geometría |
is_empty(geom_from_wkt('LINESTRING(0 0, 1 1, 2 2)'))
→
falso
is_empty(geom_from_wkt('LINESTRING EMPTY'))
→
verdadero
is_empty(geom_from_wkt('POINT(7 4)'))
→
falso
is_empty(geom_from_wkt('POINT EMPTY'))
→
verdadero
Returns true if a geometry is NULL or empty (without coordinates) or false otherwise. This function is like the expression '$geometry IS NULL or is_empty($geometry)'
is_empty_or_null
(
geom
)
| geom | una geometría |
is_empty_or_null(NULL)
→
verdadero
is_empty_or_null(geom_from_wkt('LINESTRING(0 0, 1 1, 2 2)'))
→
falso
is_empty_or_null(geom_from_wkt('LINESTRING EMPTY'))
→
verdadero
is_empty_or_null(geom_from_wkt('POINT(7 4)'))
→
falso
is_empty_or_null(geom_from_wkt('POINT EMPTY'))
→
verdadero
Returns true if the geometry is of Multi type.
is_multipart
(
geometry
)
| geometry | una geometría |
is_multipart(geom_from_wkt('MULTIPOINT ((0 0),(1 1),(2 2))'))
→
verdadero
is_multipart(geom_from_wkt('POINT (0 0)'))
→
falso
Returns true if a geometry is valid; if it is well-formed in 2D according to the OGC rules.
is_valid
(
geom
)
| geom | una geometría |
is_valid(geom_from_wkt('LINESTRING(0 0, 1 1, 2 2, 0 0)'))
→
verdadero
is_valid(geom_from_wkt('LINESTRING(0 0)'))
→
falso
Devuelve el número de caracteres de una cadena o la longitud de la cadena que define una geometría.
length
(
string
)
| string | cadena de la que medir la longitud |
length('hola')
→
5
length
(
geometry
)
| geometry | objeto de geometría lineal |
length(geom_from_wkt('LINESTRING(0 0, 4 0)'))
→
4.0
Devuelve el ángulo paralelo a la geometría a una distancia especificada a lo largo de una geometría cadena de líneas (linestring). Los ángulos están en grados en sentido horario desde el Norte.
line_interpolate_angle
(
geometry
,
distance
)
| geometry | una geometría de cadena de línea |
| distance | distancia a lo largo de la línea a la que interpolar el ángulo |
line_interpolate_angle(geometry:=geom_from_wkt('LineString(0 0, 10 0)'),distance:=5)
→
90.0
Devuelve el punto interpolado a una distancia especificada a lo largo de una geometría cadena de líneas (linestring).
line_interpolate_point
(
geometry
,
distance
)
| geometry | una geometría de cadena de línea |
| distance | distancia a lo largo de la línea a la que interpolar |
geom_to_wkt(line_interpolate_point(geometry:=geom_from_wkt('LineString(0 0, 10 0)'),distance:=5))
→
'Point (5 0)'
Devuelve la distancia a lo largo de un cadena de líneas que corresponde a la posición más cercana a la que llega la línea de una geometría de punto especificada.
line_locate_point
(
geometry
,
point
)
| geometry | una geometría de cadena de línea |
| point | geometría de punto a la que encontrar la posición más cercana desde la cadena de líneas |
line_locate_point(geometry:=geom_from_wkt('LineString(0 0, 10 0)'),point:=geom_from_wkt('Point(5 0)'))
→
5.0
Devuelve una cadena de líneas o multicadena de líneas en la que cualquier cadena de líneas conectada desde la geometría de entrada se ha combinado en una única cadena de líneas. Esta función devolverá nulo si se pasa una geometría que no es una cadena de líneas/multicadena de líneas.
line_merge
(
geometry
)
| geometry | una geometría cadena de líneas/multicadena de líneas |
geom_to_wkt(line_merge(geom_from_wkt('MULTILINESTRING((0 0, 1 1),(1 1, 2 2))')))
→
'LineString(0 0,1 1,2 2)'
geom_to_wkt(line_merge(geom_from_wkt('MULTILINESTRING((0 0, 1 1),(11 1, 21 2))')))
→
'MultiLineString((0 0, 1 1),(11 1, 21 2)'
Returns the portion of a line (or curve) geometry which falls between the specified start and end distances (measured from the beginning of the line). Z and M values are linearly interpolated from existing values.
line_substring
(
geometry
,
start_distance
,
end_distance
)
| geometry | a linestring or curve geometry |
| start_distance | distancia al inicio de la subcadena |
| end_distance | distancia al final de la subcadena |
geom_to_wkt(line_substring(geometry:=geom_from_wkt('LineString(0 0, 10 0)'),start_distance:=2,end_distance=6))
→
'LineString (2 0,6 0)'
Devuelve el valor m de una geometría de punto.
m
(
geom
)
| geom | una geometría de punto |
m( geom_from_wkt( 'POINTM(2 5 4)' ) )
→
4
Returns the maximum m (measure) value of a geometry.
m_max
(
geometry
)
| geometry | a geometry containing m values |
m_max( make_point_m( 0,0,1 ) )
→
1
m_max(make_line( make_point_m( 0,0,1 ), make_point_m( -1,-1,2 ), make_point_m( -2,-2,0 ) ) )
→
2
Returns the minimum m (measure) value of a geometry.
m_min
(
geometry
)
| geometry | a geometry containing m values |
m_min( make_point_m( 0,0,1 ) )
→
1
m_min(make_line( make_point_m( 0,0,1 ), make_point_m( -1,-1,2 ), make_point_m( -2,-2,0 ) ) )
→
0
Crea un polígono circular.
make_circle
(
center
,
radius
[,
segment=36
]…)
| center | punto centro del círculo |
| radius | radio del círculo |
| segment | argumento opcional para la segmentación de polígonos. Por omisión, este valor es 36. |
geom_to_wkt(make_circle(make_point(10,10), 5, 4))
→
'Polygon ((10 15, 15 10, 10 5, 5 10, 10 15))'
geom_to_wkt(make_circle(make_point(10,10,5), 5, 4))
→
'PolygonZ ((10 15 5, 15 10 5, 10 5 5, 5 10 5, 10 15 5))'
geom_to_wkt(make_circle(make_point(10,10,5,30), 5, 4))
→
'PolygonZM ((10 15 5 30, 15 10 5 30, 10 5 5 30, 5 10 5 30, 10 15 5 30))'
Crea un polígono elíptico.
make_ellipse
(
center
,
semi_major_axis
,
semi_minor_axis
,
azimuth
[,
segment=36
]…)
| center | punto centro de la elipse |
| semi_major_axis | semieje mayor de la elipse |
| semi_minor_axis | semieje menor de la elipse |
| azimuth | orientación de la elipse |
| segment | argumento opcional para la segmentación de polígonos. Por omisión, este valor es 36. |
geom_to_wkt(make_ellipse(make_point(10,10), 5, 2, 90, 4))
→
'Polygon ((15 10, 10 8, 5 10, 10 12, 15 10))'
geom_to_wkt(make_ellipse(make_point(10,10,5), 5, 2, 90, 4))
→
'PolygonZ ((15 10 5, 10 8 5, 5 10 5, 10 12 5, 15 10 5))'
geom_to_wkt(make_ellipse(make_point(10,10,5,30), 5, 2, 90, 4))
→
'PolygonZM ((15 10 5 30, 10 8 5 30, 5 10 5 30, 10 12 5 30, 15 10 5 30))'
Crea una geometría de línea a partir de una serie de geometrías de puntos.
make_line
(
point1
,
point2
…)
| point | a point geometry (or array of points) |
geom_to_wkt(make_line(make_point(2,4),make_point(3,5)))
→
'LineString (2 4, 3 5)'
geom_to_wkt(make_line(make_point(2,4),make_point(3,5),make_point(9,7)))
→
'LineString (2 4, 3 5, 9 7)'
make_line
(
array
)
| array | array of points |
geom_to_wkt(make_line(array(make_point(2,4),make_point(3,5),make_point(9,7))))
→
'LineString (2 4, 3 5, 9 7)'
Crea una geometría de punto a partir de unos valores de X e Y (y opcionalmente Z).
make_point
(
x
,
y
[,
z
][,
m
])
| x | Coordenada X del punto |
| y | Coordenada Y del punto |
| z | coordenada Z opcional del punto |
| m | valor m opcional de punto |
geom_to_wkt(make_point(2,4))
→
'Point (2 4)'
geom_to_wkt(make_point(2,4,6))
→
'PointZ (2 4 6)'
geom_to_wkt(make_point(2,4,6,8))
→
'PointZM (2 4 6 8)'
Crea una geometría de punto a partir de una coordenada X, Y y un valor m.
make_point_m
(
x
,
y
,
m
)
| x | Coordenada X del punto |
| y | Coordenada Y del punto |
| m | valor m de punto |
geom_to_wkt(make_point_m(2,4,6))
→
'PointM (2 4 6)'
Crea una geometría de polígono a partir de un anillo exterior y series opcionales de geometrías interiores de anillo.
make_polygon
(
outerRing
[,
innerRing1
][,
innerRing2
]…)
| outerRing | geometría de línea cerrada para anillo exterior del polígono |
| innerRing | geometría de línea cerrada opcional para anillo interior |
geom_to_wkt(make_polygon(geom_from_wkt('LINESTRING( 0 0, 0 1, 1 1, 1 0, 0 0 )')))
→
'Polygon ((0 0, 0 1, 1 1, 1 0, 0 0))'
geom_to_wkt(make_polygon(geom_from_wkt('LINESTRING( 0 0, 0 1, 1 1, 1 0, 0 0 )'),geom_from_wkt('LINESTRING( 0.1 0.1, 0.1 0.2, 0.2 0.2, 0.2 0.1, 0.1 0.1 )'),geom_from_wkt('LINESTRING( 0.8 0.8, 0.8 0.9, 0.9 0.9, 0.9 0.8, 0.8 0.8 )')))
→
'Polygon ((0 0, 0 1, 1 1, 1 0, 0 0),(0.1 0.1, 0.1 0.2, 0.2 0.2, 0.2 0.1, 0.1 0.1),(0.8 0.8, 0.8 0.9, 0.9 0.9, 0.9 0.8, 0.8 0.8))'
Creates a rectangle from 3 points.
make_rectangle_3points
(
point1
,
point2
,
point3
[,
option=0
]…)
| point1 | Primer punto. |
| point2 | Segundo punto. |
| point3 | Tercer punto. |
| option | An optional argument to construct the rectangle. By default this value is 0. Value can be 0 (distance) or 1 (projected). Option distance: Second distance is equal to the distance between 2nd and 3rd point. Option projected: Second distance is equal to the distance of the perpendicular projection of the 3rd point on the segment or its extension. |
geom_to_wkt(make_rectangle(make_point(0, 0), make_point(0,5), make_point(5, 5), 0)))
→
'Polygon ((0 0, 0 5, 5 5, 5 0, 0 0))'
geom_to_wkt(make_rectangle(make_point(0, 0), make_point(0,5), make_point(5, 3), 1)))
→
'Polygon ((0 0, 0 5, 5 5, 5 0, 0 0))'
Crea un polígono regular.
make_regular_polygon
(
center
,
radius
,
number_sides
[,
circle=0
]…)
| center | centro del polígono regular |
| radius | segundo punto. El primero si el polígono regular es inscrito. El punto central de la primera cara si el polígono regular es circunscrito. |
| number_sides | Número de caras/bordes del polígono regular |
| circle | Argumento opcional para construir el polígono regular. Por omisión este valor es 0. El valor puede ser 0 (inscrito) o 1 (circunscrito). |
geom_to_wkt(make_regular_polygon(make_point(0,0), make_point(0,5), 5))
→
'Polygon ((0 5, 4.76 1.55, 2.94 -4.05, -2.94 -4.05, -4.76 1.55, 0 5))'
geom_to_wkt(make_regular_polygon(make_point(0,0), project(make_point(0,0), 4.0451, radians(36)), 5))
→
'Polygon ((0 5, 4.76 1.55, 2.94 -4.05, -2.94 -4.05, -4.76 1.55, 0 5))'
Creates a square from a diagonal.
make_square
(
point1
,
point2
…)
| point1 | First point of the regular polygon |
| point2 | Segundo punto |
geom_to_wkt(make_square( make_point(0,0), make_point(5,5)))
→
'Polygon ((0 0, -0 5, 5 5, 5 0, 0 0))'
geom_to_wkt(make_square( make_point(5,0), make_point(5,5)))
→
'Polygon ((5 0, 2.5 2.5, 5 5, 7.5 2.5, 5 0))'
Crea un polígono triangular.
make_triangle
(
point 1
,
point 2
,
point 3
)
| point 1 | primer punto del triángulo |
| point 2 | segundo punto del triángulo |
| point 3 | tercer punto del triángulo |
geom_to_wkt(make_triangle(make_point(0,0), make_point(5,5), make_point(0,10)))
→
'Triangle ((0 0, 5 5, 0 10, 0 0))'
geom_to_wkt(boundary(make_triangle(make_point(0,0), make_point(5,5), make_point(0,10))))
→
'LineString (0 0, 5 5, 0 10, 0 0)'
Devuelve el círculo envolvente mínimo de una geometría. Representa el círculo mínimo que encierra todas las geometrías del conjunto.
minimal_circle
(
geometry
[,
segment=36
])
| geometry | una geometría |
| segment | argumento opcional para la segmentación de polígonos. Por omisión, este valor es 36. |
geom_to_wkt( minimal_circle( geom_from_wkt( 'LINESTRING(0 5, 0 -5, 2 1)' ), 4 ) )
→
Polygon ((0 5, 5 -0, -0 -5, -5 0, 0 5))
geom_to_wkt( minimal_circle( geom_from_wkt( 'MULTIPOINT(1 2, 3 4, 3 2)' ), 4 ) )
→
Polygon ((3 4, 3 2, 1 2, 1 4, 3 4))
Devuelve una geometría multipunto consistente en cada nodo de la geometría de entrada.
nodes_to_points
(
geometry
[,
ignore_closing_nodes=false
])
| geometry | objeto de geometría |
| ignore_closing_nodes | argumento opcional que especifica si incluir nodos duplicados que cierran líneas o anillos de polígonos. El valor predeterminado es falso, establecer a verdadero para evitar incluir estos nodos duplicados en la colección de salida. |
geom_to_wkt(nodes_to_points(geom_from_wkt('LINESTRING(0 0, 1 1, 2 2)')))
→
'MultiPoint ((0 0),(1 1),(2 2))'
geom_to_wkt(nodes_to_points(geom_from_wkt('POLYGON((-1 -1, 4 0, 4 2, 0 2, -1 -1))'),true))
→
'MultiPoint ((-1 -1),(4 0),(4 2),(0 2))'
Devuelve el número de geometrías en una colección de geometrías o nulo si la geometría de entrada no es una colección.
num_geometries
(
geometry
)
| geometry | colección de geometrías |
num_geometries(geom_from_wkt('GEOMETRYCOLLECTION(POINT(0 1), POINT(0 0), POINT(1 0), POINT(1 1))'))
→
4
Devuelve el número de anillos interiores de un polígono o una colección de geometrías o nulo si la geometría de entrada no es un polígono o una colección.
num_interior_rings
(
geometry
)
| geometry | geometría de entrada |
num_interior_rings(geom_from_wkt('POLYGON((-1 -1, 4 0, 4 2, 0 2, -1 -1),(-0.1 -0.1, 0.4 0, 0.4 0.2, 0 0.2, -0.1 -0.1))'))
→
1
Devuelve el número de vértices de una geometría.
num_points
(
geom
)
| geom | una geometría |
num_points($geometry)
→
número de vértices en $geometry
Devuelve el número de anillos (incluidos los anillos exteriores) de un polígono o una colección de geometrías o nulo si la geometría de entrada no es un polígono o una colección.
num_rings
(
geometry
)
| geometry | geometría de entrada |
num_rings(geom_from_wkt('POLYGON((-1 -1, 4 0, 4 2, 0 2, -1 -1),(-0.1 -0.1, 0.4 0, 0.4 0.2, 0 0.2, -0.1 -0.1))'))
→
2
Devuelve una geometría formada desplazando una geometría de línea hacia un lado. Las distancias están en el Sistema de Referencia Espacial de esta geometría.
offset_curve
(
geometry
,
distance
[,
segments=8
][,
join=1
][,
miter_limit=2.0
])
| geometry | una geometría de (multi)cadena de líneas |
| distance | distancia de desplazamiento. Para valores positivos se hará un buffer a la izquierda de las líneas y para valores negativos para la derecha. |
| segments | número de segmentos a usar para representar un cuarto de círculo cuando se utilice un estilo de unión redondo. Un número mayor da como resultado una línea más suave con más nodos. |
| join | estilo de unión para esquinas, donde 1 = redondo, 2 = inglete y 3 = bisel |
| miter_limit | límite en el radio del inglete utilizado para esquinas muy agudas (solamente al utilizar uniones en inglete) |
offset_curve($geometry, 10.5)
→
desplazamiento de línea a la izquierda en 10,5 unidades
offset_curve($geometry, -10.5)
→
desplazamiento de línea a la derecha en 10,5 unidades
offset_curve($geometry, 10.5, segments=16, join=1)
→
desplazamiento de línea a la izquierda en 10,5 unidades, usando más segmentos para obtener una curva más suave
offset_curve($geometry, 10.5, join=3)
→
desplazamiento de línea a la izquierda por 10.5 unidades, usando una unión en bisel
Ordena las partes de una MultiGeometría por los criterios dados
order_parts
(
geom
,
orderby
,
ascending
)
| geom | una geometría multi tipo |
| orderby | una cadena de expresión que define los criterios de ordenación |
| ascending | lógico, Verdadero para ascendente, Falso para descendente |
order_parts(geom_from_wkt('MultiPolygon (((1 1, 5 1, 5 5, 1 5, 1 1)),((1 1, 9 1, 9 9, 1 9, 1 1)))'), 'area($geometry)', False)
→
MultiPolygon (((1 1, 9 1, 9 9, 1 9, 1 1)),((1 1, 5 1, 5 5, 1 5, 1 1)))
order_parts(geom_from_wkt('LineString(1 2, 3 2, 4 3)'), '1', True)
→
LineString(1 2, 3 2, 4 3)
Devuelve una geometría que representa el recuadro delimitador orientado mínimo de una geometría de entrada.
oriented_bbox
(
geom
)
| geom | una geometría |
geom_to_wkt( oriented_bbox( geom_from_wkt( 'MULTIPOINT(1 2, 3 4, 3 2)' ) ) )
→
Polygon ((1 4, 1 2, 3 2, 3 4, 1 4))
Comprueba si una geometría solapa con otra. Devuelve verdadero si las geometrías comparten espacio, son de la misma dimensión, pero no están contenidas en la otra.
overlaps
(
geometry a
,
geometry b
)
| geometry a | una geometría |
| geometry b | una geometría |
overlaps( geom_from_wkt( 'LINESTRING(3 5, 4 4, 5 5, 5 3)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ) )
→
verdadero
overlaps( geom_from_wkt( 'LINESTRING(0 0, 1 1)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ) )
→
falso
Devuelve el perímetro de un objeto de geometría de tipo polígono. Los cálculos siempre son planimétricos en el Sistema de Rerefencia Espacial (SRE) de esta geometría y las unidades del perímetro devuelto coincidirán con las unidades del SRE. Esto difiere de los cálculos hechos por la función $perimeter, que hará cálculos elipsoidales basados en el elipsoide del proyecto y la configuración de las unidades de distancia.
perimeter
(
geometry
)
| geometry | objeto de geometría poligonal |
perimeter(geom_from_wkt('POLYGON((0 0, 4 0, 4 2, 0 2, 0 0))'))
→
12.0
Devuelve un nodo específico de una geometría.
point_n
(
geometry
,
index
)
| geometry | objeto de geometría |
| index | index of node to return, where 1 is the first node; if the value is negative, the selected vertex index will be its total count minus the absolute value |
geom_to_wkt(point_n(geom_from_wkt('POLYGON((0 0, 4 0, 4 2, 0 2, 0 0))'),2))
→
'Point (4 0)'
Devuelve un punto garantizando que cae en la superficie de una geometría.
point_on_surface
(
geom
)
| geom | una geometría |
point_on_surface($geometry)
→
una geometría de punto
Calcula el polo aproximado de inaccesibilidad para una superficie, que es el punto interno de una superficie más distante del borde de la superficie. Esta función usa el algoritmo "polylabel" (Vladimir Agafonkin, 2016), que es una aproximación iterativa que garantiza encontrar el polo real de inaccesibilidad dentro de una tolerancia especificada. Tolerancias más precisas requieren más iteraciones y llevará más tiempo calcularlas.
pole_of_inaccessibility
(
geometry
,
tolerance
)
| geometry | una geometría |
| tolerance | distancia máxima entre el punto devuelto y la localización del polo verdadero |
geom_to_wkt(pole_of_inaccessibility( geom_from_wkt('POLYGON((0 1,0 9,3 10,3 3, 10 3, 10 1, 0 1))'), 0.1))
→
Point(1.55, 1.55)
Returns a point projected from a start point using a distance, a bearing (azimuth) and an elevation in radians.
project
(
point
,
distance
,
azimuth
[,
elevation
])
| point | punto de inicio |
| distance | distancia a proyectar |
| azimuth | azimuth in radians clockwise, where 0 corresponds to north |
| elevation | angle of inclination in radians |
geom_to_wkt(project(make_point(1, 2), 3, radians(270)))
→
Point(-2, 2)
Prueba la representación del Modelo de Intersección 9 Extendido Dimensional (DE-9IM) de la relación entre dos geometrías.
relate
(
geometry
,
geometry
)
| geometry | una geometría |
| geometry | una geometría |
relate( geom_from_wkt( 'LINESTRING(40 40,120 120)' ), geom_from_wkt( 'LINESTRING(40 40,60 120)' ) )
→
'FF1F00102'
relate
(
geometry
,
geometry
,
pattern
)
| geometry | una geometría |
| geometry | una geometría |
| pattern | Patrón DE-9IM con el que coincidir |
relate( geom_from_wkt( 'LINESTRING(40 40,120 120)' ), geom_from_wkt( 'LINESTRING(40 40,60 120)' ), '**1F001**' )
→
Verdadero
Cambia el sentido de una línea invirtiendo el orden de sus vértices.
reverse
(
geom
)
| geom | una geometría |
geom_to_wkt(reverse(geom_from_wkt('LINESTRING(0 0, 1 1, 2 2)')))
→
'LINESTRING(2 2, 1 1, 0 0)'
Returns a rotated version of a geometry. Calculations are in the Spatial Reference System of this geometry.
rotate
(
geom
,
rotation
[,
point
])
| geom | una geometría |
| rotation | clockwise rotation in degrees |
| point | rotation center point. If not specified, the center of the geometry's bounding box is used. |
rotate($geometry, 45, make_point(4, 5))
→
geometry rotated 45 degrees clockwise around the (4, 5) point
rotate($geometry, 45)
→
geometry rotated 45 degrees clockwise around the center of its bounding box
Devuelve una geometría multilínea que consiste en una línea para cada segmento de la geometría de entrada.
segments_to_lines
(
geometry
)
| geometry | objeto de geometría |
geom_to_wkt(segments_to_lines(geom_from_wkt('LINESTRING(0 0, 1 1, 2 2)')))
→
'MultiLineString ((0 0, 1 1),(1 1, 2 2))'
Returns the shortest line joining geometry1 to geometry2. The resultant line will start at geometry1 and end at geometry2.
shortest_line
(
geometry1
,
geometry2
)
| geometry1 | geometría desde la que encontrar la línea más corta |
| geometry2 | geometría hasta la que encontrar la línea más corta |
geom_to_wkt(shortest_line(geom_from_wkt('LINESTRING (20 80, 98 190, 110 180, 50 75 )'),geom_from_wkt('POINT(100 100)')))
→
LineString(73.0769 115.384, 100 100)
Simplifica una geometría eliminando nodos usando un margen basado en distancia (esto es, el algoritmo Douglas Peucker). El algoritmo conserva grandes desviaciones de las geometrías y reduce el número de vértices en segmentos prácticamente rectos.
simplify
(
geometry
,
tolerance
)
| geometry | una geometría |
| tolerance | desviación máxima de segmentos rectos para eliminar puntos |
geom_to_wkt(simplify(geometry:=geom_from_wkt('LineString(0 0, 5 0.1, 10 0)'),tolerance:=5))
→
'LineString(0 0, 10 0)'
Simplifica una geometría eliminando nodos usando un margen basado en área (esto es, el algoritmo Visvalingam-Whyatt). El algoritmo elimina vértices que crean pequeñas áreas en las geometrías, por ejemplo salientes estrechos o segmentos prácticamente rectos.
simplify_vw
(
geometry
,
tolerance
)
| geometry | una geometría |
| tolerance | una medida del área máxima creada por un nodo para eliminar el nodo |
geom_to_wkt(simplify_vw(geometry:=geom_from_wkt('LineString(0 0, 5 0, 5.01 10, 5.02 0, 10 0)'),tolerance:=5))
→
'LineString(0 0, 10 0)'
Devuelve una geometría formada haciendo un buffer de una geometría de línea hacia un lado. Las distancias están en el Sistema de Referencia Espacial de esta geometría.
single_sided_buffer
(
geometry
,
distance
[,
segments=8
][,
join=1
][,
miter_limit=2.0
])
| geometry | una geometría de (multi)cadena de líneas |
| distance | distancia de buffer. Para valores positivos se hará un buffer a la izquierda de las líneas y para valores negativos a la derecha. |
| segments | número de segmentos a usar para representar un cuarto de círculo cuando se utilice un estilo de unión redondo. Un número mayor da como resultado un buffer más suave con más nodos. |
| join | estilo de unión para esquinas, donde 1 = redondo, 2 = inglete y 3 = bisel |
| miter_limit | límite en el radio del inglete utilizado para esquinas muy agudas (solamente al utilizar uniones en inglete) |
single_sided_buffer($geometry, 10.5)
→
línea hecha buffer a la izquierda en 10,5 unidades
single_sided_buffer($geometry, -10.5)
→
línea hecha buffer a la derecha en 10,5 unidades
single_sided_buffer($geometry, 10.5, segments=16, join=1)
→
buffer de línea a la izquierda en 10.5 unidades, usando más segmentos para obtener un buffer más suabe.
single_sided_buffer($geometry, 10.5, join=3)
→
línea hecha buffer a la izquierda por 10.5 unidades, usando una unión en bisel
Smooths a geometry by adding extra nodes which round off corners in the geometry. If input geometries contain Z or M values, these will also be smoothed and the output geometry will retain the same dimensionality as the input geometry.
smooth
(
geometry
[,
iterations
][,
offset
][,
min_length
][,
max_angle
])
| geometry | una geometría |
| iterations | número de iteraciones de suavizado a aplicar. Números grandes dan lugar a geometrías más suaves, pero más complejas. |
| offset | valor entre 0 y 0,5 que controla hasta qué punto se ajusta la geometría suavizada a la original. Número pequeños dan lugar a un suavizado más ajustado, mientras que números mayores dan lugar a un ajustado más laxo. |
| min_length | longitud mínima de segmento a la que aplicar el suavizado. Este parámetro se puede usar para evitar colocar un número excesivo de nodos adicionales en los segmentos más cortos de la geometría. |
| max_angle | ángulo máximo en el nodo para aplicar suavizado (0-180). Disminuyendo el ángulo máximo se pueden conservar esquinas intencionadamente agudas de la geometría. Por ejemplo, un valor de 80 grados conservará los ángulos rectos de la geometría. |
geom_to_wkt(smooth(geometry:=geom_from_wkt('LineString(0 0, 5 0, 5 5)'),iterations:=1,offset:=0.2,min_length:=-1,max_angle:=180))
→
'LineString (0 0, 4 0, 5 1, 5 5)'
Devuelve el primer nodo de una geometría.
start_point
(
geometry
)
| geometry | objeto de geometría |
geom_to_wkt(start_point(geom_from_wkt('LINESTRING(4 0, 4 2, 0 2)')))
→
'Point (4 0)'
Devuelve una geometría que representa las partes de dos geometrías que no se intersecan.
sym_difference
(
geometry1
,
geometry2
)
| geometry1 | una geometría |
| geometry2 | una geometría |
geom_to_wkt( sym_difference( geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ), geom_from_wkt( 'LINESTRING(3 3, 8 8)' ) ) )
→
LINESTRING(5 5, 8 8)
Crea un búfer a lo largo de una geometría lineal donde el diámetro del búfer varía uniformemente sobre la longitud de la línea.
tapered_buffer
(
geometry
,
start_width
,
end_width
[,
segments=8
])
| geometry | geometría de entrada. Debe ser una geometría de (varias) líneas. |
| start_width | ancho del búfer al inicio de la línea, |
| end_width | ancho del búfer al final de la línea. |
| segments | número de segmentos para aproximar las curvas del un cuarto de círculo en el buffer. |
tapered_buffer(geometry:=geom_from_wkt('LINESTRING(1 2, 4 2)'),start_width:=1,end_width:=2,segments:=8)
→
Un búfer estrechado comenzando con un diámetro de 1 y terminando con un diámetro de 2 a lo largo de una geometría de cadena de líneas.
Comprueba si una geometría toca a otra. Devuelve verdadero si las geometrías tienen al menos un punto en común, pero sus interiores no se intersecan.
touches
(
geometry a
,
geometry b
)
| geometry a | una geometría |
| geometry b | una geometría |
touches( geom_from_wkt( 'LINESTRING(5 3, 4 4)' ), geom_from_wkt( 'LINESTRING(3 3, 4 4, 5 5)' ) )
→
verdadero
touches( geom_from_wkt( 'POINT(4 4)' ), geom_from_wkt( 'POINT(5 5)' ) )
→
falso
Devuelve la geometría transformada desde un SRC de origen a otro de destino.
transform
(
geom
,
source_auth_id
,
dest_auth_id
)
| geom | una geometría |
| source_auth_id | ID del SRC de origen |
| dest_auth_id | ID del SRC de destino |
geom_to_wkt( transform( $geometry, 'EPSG:2154', 'EPSG:4326' ) )
→
POINT(0 51)
Devuelve una versión convertida de una geometría. Los cálculos se hacen en el Sistema de Referencia Espacial de la geometría.
translate
(
geom
,
dx
,
dy
)
| geom | una geometría |
| dx | delta x |
| dy | delta y |
convertir($geometría,5,10)
→
una geometría del mismo tipo que la original
Devuelve una geometría que representa el conjunto unión de los puntos de las geometrías.
union
(
geometry1
,
geometry2
)
| geometry1 | una geometría |
| geometry2 | una geometría |
geom_to_wkt( union( geom_from_wkt( 'POINT(4 4)' ), geom_from_wkt( 'POINT(5 5)' ) ) )
→
MULTIPOINT(4 4, 5 5)
Regresa un búfer en forma de cuña originado de una geometría de punto.
wedge_buffer
(
center
,
azimuth
,
width
,
outer_radius
[,
inner_radius=0.0
])
| center | punto central (origen) del buffer. Debe ser una geometría de punto. |
| azimuth | ángulo (en grados) desde la mitad de la cuña a un punto. |
| width | ancho de búfer (en grados). Note que la cuña se extenderá a la mitad de la anchura angular por ambos lados en la dirección azimutal. |
| outer_radius | radio exterior para los buffers |
| inner_radius | radio interno opcional para buffers |
wedge_buffer(center:=geom_from_wkt('POINT(1 2)'),azimuth:=90,width:=180,outer_radius:=1)
→
Un búfer en forma de cuña centrado en el punto (1,2), apuntando hacia el Este, con un ancho de 180 grados y radio externo de 1.
Comprueba si una geometría está dentro de otra. Devuelve verdadero si la geometría a está completamente dentro de la geometría b.
within
(
geometry a
,
geometry b
)
| geometry a | una geometría |
| geometry b | una geometría |
within( geom_from_wkt( 'POINT( 0.5 0.5)' ), geom_from_wkt( 'POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))' ) )
→
verdadero
within( geom_from_wkt( 'POINT( 5 5 )' ), geom_from_wkt( 'POLYGON((0 0, 0 1, 1 1, 1 0, 0 0 ))' ) )
→
falso
Devuelve la coordenada X de una geometría de tipo punto o la coordenada X del centroide de una geometría que no sea de puntos.
x
(
geom
)
| geom | una geometría |
x( geom_from_wkt( 'POINT(2 5)' ) )
→
2
x( $geometría)
→
coordenada X del centroide del objeto actual
Devuelve la coordenada X máxima de una geometría. Los cálculos están en el Sistema de Referencia Espacial de esta geometría.
x_max
(
geom
)
| geom | una geometría |
x_max( geom_from_wkt( 'LINESTRING(2 5, 3 6, 4 8)') )
→
4
Devuelve la coordenada X mínima de una geometría. Los cálculos están en el Sistema de Referencia Espacial de esta geometría.
x_min
(
geom
)
| geom | una geometría |
x_min( geom_from_wkt( 'LINESTRING(2 5, 3 6, 4 8)') )
→
2
Devuelve la coordenada Y de una geometría de tipo punto o la coordenada Y del centroide de una geometría que no sea de puntos.
y
(
geom
)
| geom | una geometría |
y( geom_from_wkt( 'POINT(2 5)' ) )
→
5
y( $geometría )
→
coordenada Y del centroide del objeto actual
Devuelve la coordenada Y máxima de una geometría. Los cálculos están en el Sistema de Referencia Espacial de esta geometría.
y_max
(
geom
)
| geom | una geometría |
y_max( geom_from_wkt( 'LINESTRING(2 5, 3 6, 4 8)') )
→
8
Devuelve la coordenada Y mínima de una geometría. Los cálculos están en el Sistema de Referencia Espacial de esta geometría.
y_min
(
geom
)
| geom | una geometría |
y_min( geom_from_wkt( 'LINESTRING(2 5, 3 6, 4 8)') )
→
5
Devuelve la coordenada Z de una geometría de punto.
z
(
geom
)
| geom | una geometría de punto |
z( geom_from_wkt( 'POINTZ(2 5 7)' ) )
→
7
Returns the maximum z coordinate of a geometry.
z_max
(
geometry
)
| geometry | a geometry with z coordinate |
z_max( geom_from_wkt( 'POINT ( 0 0 1 )' ) )
→
1
z_max( make_line( make_point( 0,0,0 ), make_point( -1,-1,-2 ) ) )
→
0
Returns the minimum z coordinate of a geometry.
z_min
(
geometry
)
| geometry | a geometry with z coordinate |
z_min( geom_from_wkt( 'POINT ( 0 0 1 )' ) )
→
1
z_min( make_line( make_point( 0,0,0 ), make_point( -1,-1,-2 ) ) )
→
-2
Devuelve un mapa de variables a partir de un elemento del diseñador dentro de esta composición.
item_variables
(
id
)
| id | ID del elemento del diseñador |
map_get(item_variables('mapa_principal'), 'escala_de_mapa')
→
2000
Contiene una lista de capas de mapa disponibles en el proyecto actual.
Takes a layer and decodes the uri of the underlying data provider. It depends on the dataprovider, which data is available.
decode_uri
(
layer
[,
part
])
| layer | The layer for which the uri should be decoded. |
| part | The part of the uri to return. If unspecified, a map with all uri parts will be returned. |
decode_uri(@layer)
→
{'layerId': '0', 'layerName': '', 'path': '/home/qgis/shapefile.shp'}
decode_uri(@layer)
→
{'layerId': NULL, 'layerName': 'layer', 'path': '/home/qgis/geopackage.gpkg'}
decode_uri(@layer, 'path')
→
'C:\my_data\qgis\shape.shp'
Este grupo contiene funciones de expresiones para la creación y manipulación de estructuras de datos de "mapa" (también conocidos como objetos de diccionario, pares clave-valor o matrices asociativas). Se pueden asignar valores a las claves dadas. El orden de los pares clave-valor en el objeto de mapa es irrelevante.
Loads a JSON formatted string.
from_json
(
string
)
| string | JSON texto |
from_json('{"qgis":"rocks"}')
→
{ "qgis" : "rocks" }
from_json('[1,2,3]')
→
[1,2,3]
Creates a map from a hstore-formatted string.
hstore_to_map
(
string
)
| string | la cadena de entrada |
hstore_to_map('qgis=>rocks')
→
{ "qgis" : "rocks" }
Creates a map from a json-formatted string.
json_to_map
(
string
)
| string | la cadena de entrada |
json_to_map('{"qgis":"rocks"}')
→
{ "qgis" : "rocks" }
Devuelve un mapa que contiene todas las claves y valores pasados como pares de parámetros.
map
(
key1
,
value1
,
key2
,
value2
…)
| key | una clave (cadena) |
| value | un valor |
map('1','uno','2', 'dos')
→
{ '1': 'uno', '2': 'dos' }
Devuelve todas las claves de un mapa como una matriz.
map_akeys
(
map
)
| map | un mapa |
map_akeys(map('1','uno','2','dos'))
→
[ '1', '2' ]
Devuelve todos los valores de un mapa como una matriz.
map_avals
(
map
)
| map | un mapa |
map_avals(map('1','uno','2','dos'))
→
[ 'uno', 'dos' ]
Devuelve un mapa que contiene todas las entradas de los mapas dados. Si dos mapas contienen la misma clave, se toma el valor del segundo mapa.
map_concat
(
map1
,
map2
…)
| map | un mapa |
map_concat(map('1','uno', '2','sobreescrito'),map('2','dos', '3','tres'))
→
{ '1': 'uno, '2': 'dos', '3': 'tres' }
Devuelve un mapa con las claves dadas y sus valores correspondientes borrados.
map_delete
(
map
,
key
)
| map | un mapa |
| key | la clave a borrar |
map_delete(map('1','uno','2','dos'),'2')
→
{ '1': 'uno' }
Devuelve verdadero si la clave dada existe en el mapa.
map_exist
(
map
,
key
)
| map | un mapa |
| key | la clave a buscar |
map_exist(map('1','uno','2','dos'),'3')
→
falso
Devuelve el valor de un mapa, dada su clave.
map_get
(
map
,
key
)
| map | un mapa |
| key | la clave a buscar |
map_get(map('1','uno','2','dos'),'2')
→
'dos'
Devuelve un mapa con una clave/valor añadidos.
map_insert
(
map
,
key
,
value
)
| map | un mapa |
| key | la clave a añadir |
| value | el valor a añadir |
map_insert(map('1','uno'),'3','tres')
→
{ '1': 'uno', '3': 'tres' }
Merge map elements into a hstore-formatted string.
map_to_hstore
(
map
)
| map | el mapa de entrada |
map_to_hstore(map('qgis','rocks'))
→
"qgis"=>"rocks"}
Merge map elements into a json-formatted string.
map_to_json
(
map
)
| map | el mapa de entrada |
map_to_json(map('qgis','rocks'))
→
{"qgis":"rocks"}
Crear una cadena en formato JSON a partir de un mapa, arreglo u otro valor.
to_json
(
value
)
| value | El valor de entrada |
to_json(map('qgis','rocks'))
→
{"qgis":"rocks"}
to_json(array(1,2,3))
→
[1,2,3]
Este grupo contiene funciones matemáticas, por ejemplo raíz cuadrada, seno y coseno
Devuelve el valor absoluto de un número.
abs
(
value
)
| value | un número |
abs(-2)
→
2
Devuelve el arco coseno de un valor en radianes.
acos
(
value
)
| value | coseno de un ángulo en radianes |
acos(0.5)
→
1.0471975511966
Devuelve el arcoseno de un valor en radianes.
asin
(
value
)
| value | seno de un ángulo en radianes |
arcsen(1.0)
→
1.5707963267949
Devuelve la arcotangente de un valor en radianes.
atan
(
value
)
| value | tangente de un ángulo en radianes |
arctan(0.5)
→
0.463647609000806
Devuelve la arcotangente de dy/dx usandi los signos de los dos argumentos para determinar el cuadrante del resultado.
atan2
(
dy
,
dx
)
| dy | diferencia de la coordenada Y |
| dx | diferencia de la coordenada Y |
arctan2(1.0, 1.732)
→
0.523611477769969
Devuelve el azimut basado en el Norte como el ángulo en radianes medido en sentido horario desde la vertical en el punto_A al Punto_b.
azimuth
(
point_a
,
point_b
)
| point_a | geometría de punto |
| point_b | geometría de punto |
degrees( azimuth( make_point(25, 45), make_point(75, 100) ) )
→
42.273689
degrees( azimuth( make_point(75, 100), make_point(25,45) ) )
→
222.273689
Redondea un número por arriba.
ceil
(
value
)
| value | un número |
ceil(4.9)
→
5
ceil(-4.9)
→
-4
Restringe un valor de entrada a un rango especificado.
clamp
(
minimum
,
input
,
maximum
)
| minimum | el valor más pequeño que puede tomar entrada . |
| input | un valor que se puede restringir al intervalo especificado por mínimo y máximo |
| maximum | el valor más grande que puede tomar entrada . |
clamp(1,5,10)
→
5
(
entrada
está entre 1 y 10 así que se devuelve sin cambio)
clamp(1,0,10)
→
1
(
entrada
es menor que el valor mínimo de 1, así que la función devuelve 1)
clamp(1,11,10)
→
10
(
entrada
es mayor que el valor máximo de 10, así que la función devuelve 10)
Devuelve el coseno de un ángulo.
cos
(
angle
)
| angle | ángulo en radianes |
cos(1.571)
→
0.000796326710733263
Convierte de radianes a grados.
degrees
(
radians
)
| radians | valor numérico |
degrees(3.14159)
→
180
grados(1)
→
57.2958
Devuelve la exponencial de un valor.
exp
(
value
)
| value | número del que devolver la exponencial |
exp(1.0)
→
2.71828182845905
Redondea un número por abajo.
floor
(
value
)
| value | un número |
floor(4.9)
→
4
floor(-4.9)
→
-5
Devuelve la inclinación medida desde el cénit (0) al nadir (180) en el punto A al punto B.
inclination
(
point_a
,
point_b
)
| point_a | geometría de punto |
| point_b | geometría de punto |
inclination( make_point( 5, 10, 0 ), make_point( 5, 10, 5 ) )
→
0.0
inclination( make_point( 5, 10, 0 ), make_point( 5, 10, 0 ) )
→
90.0
inclination( make_point( 5, 10, 0 ), make_point( 50, 100, 0 ) )
→
90.0
inclination( make_point( 5, 10, 0 ), make_point( 5, 10, -5 ) )
→
180.0
Devuelve el logaritmo neperiano de un valor.
ln
(
value
)
| value | valor numérico |
ln(1)
→
0
ln(2.7182818284590452354)
→
1
Devuelve el logaritmo del valor y la base pasados.
log
(
base
,
value
)
| base | cualquier número positivo |
| value | cualquier número positivo |
log(2, 32)
→
5
log(0.5, 32)
→
-5
Devuelve el logaritmo en base 10 de la expresión pasada.
log10
(
value
)
| value | cualquier número positivo |
log10(1)
→
0
log10(100)
→
2
Devuelve el valor más grande de un conjunto de valores.
max
(
value1
,
value2
…)
| value | un número |
max(2,10.2,5.5)
→
10.2
max(20.5,NULL,6.2)
→
20.5
Devuelve el valor más pequeño de un conjunto de valores.
min
(
value1
,
value2
…)
| value | un número |
min(20.5,10,6.2)
→
6.2
min(2,-10.3,NULL)
→
-10.3
Convierte de grados a radianes.
radians
(
degrees
)
| degrees | valor numérico |
radianes(180)
→
3.14159
radianes(57.2958)
→
1
Returns a random integer within the range specified by the minimum and maximum argument (inclusive). If a seed is provided, the returned will always be the same, depending on the seed.
rand
(
min
,
max
[,
seed=null
])
| min | un entero que representa el menor número aleatorio posible deseado |
| max | un entero que representa el mayor número aleatorio posible deseado |
| seed | any value to use as seed |
rand(1, 10)
→
8
Returns a random float within the range specified by the minimum and maximum argument (inclusive). If a seed is provided, the returned will always be the same, depending on the seed.
randf
([
min=0.0
][,
max=1.0
][,
seed=null
])
| min | un número de coma flotante que representa el menor número aleatorio posible deseado |
| max | un número de coma flotante que representa el mayor número aleatorio posible deseado |
| seed | any value to use as seed |
randf(1, 10)
→
4.59258286403147
Redondea un número al número de posiciones decimales.
round
(
value
[,
places=0
])
| value | número decimal a redondear |
| places | Entero opcional que representa el número de posiciones decimales al que redondear. Puede ser negativo. |
round(1234.567, 2)
→
1234.57
round(1234.567)
→
1235
Transforma un valor dado de un dominio de entrada a un rango de salida usando una curva exponencial. Esta función se puede usar para facilitar valores dentro o fuera del rango de salida especificado.
scale_exp
(
val
,
domain_min
,
domain_max
,
range_min
,
range_max
,
exponent
)
| val | Un valor del dominio de entrada. La función devolverá un valor escalado correspondiente en el rango de salida. |
| domain_min | Especifica el valor mínimo del dominio de entrada, el valor más pequeño que debería tomar el valor de entrada. |
| domain_max | Especifica el valor máximo del dominio de entrada, el valor más grande que debería tomar el valor de entrada. |
| range_min | Especifica el valor mínimo del dominio de salida, el valor más pequeño que debería producir la función. |
| range_max | Especifica el valor máximo del dominio de salida, el valor más grande que debería producir la función. |
| exponent | Un valor positivo (mayor que 0) que dicta la forma en la que los valores de entrada son trasladados al rango de salida. Exponentes grandes harán que los valores de salida "converjan", comenzando lentamente antes de acelerar a medida que los valores de entrada se acercan al máximo del dominio. Exponentes más pequeños (menores que 1) harán que los valores de salida "diverjan", de forma que el traslado comienza rápidamente pero se ralentiza a medida que se aproxima al máximo del dominio. |
scale_exp(5,0,10,0,100,2)
→
25
("convergiendo", usando un exponente de 2)
scale_exp(3,0,10,0,100,0.5)
→
54.772
("divergiendo", usando un exponente de 0,5)
Transforma un valor dado de un dominio de entrada a un rango de salida usando interpolación lineal.
scale_linear
(
val
,
domain_min
,
domain_max
,
range_min
,
range_max
)
| val | Un valor del dominio de entrada. La función devolverá un valor escalado correspondiente en el rango de salida. |
| domain_min | Especifica el valor mínimo del dominio de entrada, el valor más pequeño que debería tomar el valor de entrada. |
| domain_max | Especifica el valor máximo del dominio de entrada, el valor más grande que debería tomar el valor de entrada. |
| range_min | Especifica el valor mínimo del dominio de salida, el valor más pequeño que debería producir la función. |
| range_max | Especifica el valor máximo del dominio de salida, el valor más grande que debería producir la función. |
scale_linear(5,0,10,0,100)
→
50
scale_linear(0.2,0,1,0,360)
→
72
(escalando un valor entre 0 y 1 a un ángulo entre 0 y 360)
scale_linear(1500,1000,10000,9,20)
→
9.6111111
(escalando una poblacion que varía entre 1000 y 10000 a un tamaño de letra entre 9 y 20)
Devuelve el seno de un ángulo.
sin
(
angle
)
| angle | ángulo en radianes |
sin(1.571)
→
0.999999682931835
Devuelve la raíz cuadrada de un valor.
sqrt
(
value
)
| value | un número |
sqrt(9)
→
3
Devuelve la tangente de un ángulo.
tan
(
angle
)
| angle | ángulo en radianes |
tan(1.0)
→
1.5574077246549
Devuelve el valor del parámetro de entrada de un algoritmo de procesos
parameter
(
name
)
| name | nombre del parámetro de entrada correspondiente |
parameter('BUFFER_SIZE')
→
5.6
falta la ayuda de la función para $mask_geometry
falta la ayuda de la función para in_mask
Contains functions which calculate raster statistics and values.
Devuelve estadísticas de una capa ráster.
raster_statistic
(
layer
,
band
,
property
)
| layer | una cadena que representa bien el nombre de una capa ráster o el ID de la capa |
| band | entero que representa el número de banda de la capa ráster, comenzando por 1 |
| property |
una cadena que corresponde a la propiedad a devolver. Las opciones válidas son:
|
raster_statistic('lc',1,'avg')
→
Valor promedio de la banda 1 de la capa ráster 'lc'
raster_statistic('ac2010',3,'min')
→
Valor mínimo de la banda 3 de la capa ráster 'ac2010'
Devuelve el valor ráster encontrado en el punto suministrado.
raster_value
(
layer
,
band
,
point
)
| layer | el nombre o id de una capa ráster |
| band | the band number to sample the value from. |
| point | point geometry (for multipart geometries having more than one part, a null value will be returned) |
raster_value('dem', 1, make_point(1,1))
→
25
Este grupo contiene funciones que operan sobre identificadores de registros.
Devuelve el objeto espacial que está siendo evaluado. Se puede usar con la función 'attribute' para evaluar los valores de atributo del objeto actual.
$currentfeature
attribute( $currentfeature, 'nombre' )
→
valor guardado en el atributo 'nombre' del objeto actual
Returns an attribute from a feature.
attribute
(
attribute_name
)
| attribute_name | nombre del atributo a devolver |
attribute( 'name' )
→
valor guardado en el atributo 'nombre' del objeto actual
attribute
(
feature
,
attribute_name
)
| feature | un objeto espacial |
| attribute_name | nombre del atributo a devolver |
attribute( @atlas_feature, 'nombre' )
→
valor guardado en el atributo 'nombre' del objeto de atlas actual
Returns a map containing all attributes from a feature, with field names as map keys.
attributes
()
attributes()['name']
→
valor guardado en el atributo 'nombre' del objeto actual
attributes
(
feature
)
| feature | un objeto espacial |
attributes( @atlas_feature )['name']
→
valor guardado en el atributo 'nombre' del objeto de atlas actual
Returns the display expression for a given feature in a layer. If called with no parameters, it evaluates the current feature. The expression is evaluated by default.
display_expression
([
feature=current feature
][,
layer=current layer
][,
evaluate=true
])
| feature | The feature which should be evaluated. |
| layer | The layer (or its id or name). |
| evaluate | If the expression must be evaluated. If false, the expression will be returned as a string literal only (which could potentially be later evaluated using the 'eval' function). |
display_expression()
→
The display expression of the current feature.
display_expression(get_feature_by_id('streets', 1), 'streets')
→
The display expression of the feature with the ID 1 on the layer 'streets'.
display_expression('a_layer_id', $currentfeature, 'False')
→
The display expression of the given feature not evaluated.
Devuelve el primer objeto de una capa que coincide con un valor de atributo dado.
get_feature
(
layer
,
attribute
,
value
)
| layer | nombre o ID de capa |
| attribute | nombre del atributo |
| value | valor de atributo con el que coincidir |
get_feature('calles','nombre','calle principal')
→
primer objeto encontrado en la capa "calles" con el valor "calle principal" en el campo "nombre"
Devuelve el objeto de una capa con una ID.
get_feature_by_id
(
layer
,
feature_id
)
| layer | capa, nombre de capa o ID de capa |
| feature_id | la ID del objeto que se debe devolver |
get_feature('calles', 1)
→
el objeto con ID 1 de la capa "calles"
Returns True if a feature is selected. Can be used with zero, one or two arguments, see below for details.
is_selected
()
está_seleccionado()
→
True if the current feature in the current layer is selected.
is_selected
(
feature
)
| feature | El objeto que se debería comprobar si está o no seleccionado. |
is_selected(@atlas_feature)
→
True if the current atlas feature is selected.
is_selected
(
layer
,
feature
)
| layer | The layer (or its ID or name) on which the selection will be checked. |
| feature | El objeto que se debería comprobar si está o no seleccionado. |
is_selected( 'streets', get_feature('streets', 'name', "street_name"))
→
True if the current building's street is selected (assuming the building layer has a field named 'street_name' and the 'streets' layer has a field called 'name').
Returns the maptip for a given feature in a layer. If called with no parameters, it evaluates the current feature. The maptip is evaluated by default.
maptip
([
feature=current feature
][,
layer=current layer
][,
evaluate=true
])
| feature | The feature which should be evaluated. |
| layer | The layer (or its id or name). |
| evaluate | If the expression must be evaluated. If false, the expression will be returned as a string literal only (which could potentially be later evaluated using the 'eval_template' function). |
maptip()
→
The maptip of the current feature.
maptip(get_feature('streets', 1), 'streets')
→
The maptip of the feature with the ID 1 on the layer 'streets'.
maptip('a_layer_id', $currentfeature, 'False')
→
The maptip of the given feature not evaluated.
Devuelve el número de objetos seleccionados de una capa dada. Por omisión se aplica a la capa en la que se evalúa la expresión.
num_selected
([
layer=current layer
])
| layer | La capa (o su ID o nombre) sobre la que se comprobará la selección. |
num_selected()
→
El número de objetos seleccionados de la capa actual.
num_selected('calles')
→
El ńumero de objetos seleccionados de la capa calles
Returns the configured representation value for a field value. It depends on the configured widget type. Often, this is useful for 'Value Map' widgets.
represent_value
(
value
,
fieldName
)
| value | El valor que se debe resolver. Probablemente un campo. |
| fieldName | El nombre de campo para el que se debe cargar la configuración del control. (Opcional). |
represent_value("field_with_value_map")
→
Descripción para valor
represent_value('static value', 'field_name')
→
Descripción para valor estático
Manage autoincrementing values in sqlite databases.
SQlite default values can only be applied on insert and not prefetched.
This makes it impossible to acquire an incremented primary key via AUTO_INCREMENT before creating the row in the database. Sidenote: with postgres, this works via the option evaluate default values .
When adding new features with relations, it is really nice to be able to already add children for a parent, while the parents form is still open and hence the parent feature uncommitted.
To get around this limitation, this function can be used to manage sequence values in a separate table on sqlite based formats like gpkg.
The sequence table will be filtered for a sequence id (filter_attribute and filter_value) and the current value of the id_field will be incremented by 1 and the incremented value returned.
If additional columns require values to be specified, the default_value map can be used for this purpose.
Note
This function modifies the target sqlite table. It is intended for usage with default value configurations for attributes.
When the database parameter is a layer and the layer is in transaction mode, the value will only be retrieved once during the lifetime of a transaction and cached and incremented. This makes it unsafe to work on the same database from several processes in parallel.
sqlite_fetch_and_increment
(
database
,
table
,
id_field
,
filter_attribute
,
filter_value
[,
default_values
])
| database | Path to the sqlite file or geopackage layer |
| table | Name of the table that manages the sequences |
| id_field | Name of the field that contains the current value |
| filter_attribute | Name the field that contains a unique identifier for this sequence. Must have a UNIQUE index. |
| filter_value | Name of the sequence to use. |
| default_values | Map with default values for additional columns on the table. The values need to be fully quoted. Functions are allowed. |
sqlite_fetch_and_increment(@layer, 'sequence_table', 'last_unique_id', 'sequence_id', 'global', map('last_change','date(''now'')','user','''' || @user_account_name || ''''))
→
0
sqlite_fetch_and_increment(layer_property(@layer, 'path'), 'sequence_table', 'last_unique_id', 'sequence_id', 'global', map('last_change','date(''now'')','user','''' || @user_account_name || ''''))
→
0
Genera un Identificador Universal Único (UUID) para cada fila usando el método QUuid::createUuid de Qt. Cada UUID tiene 38 caracteres de longitud.
uuid
()
uuid()
→
'{0bd2f60f-f157-4a6d-96af-d4ba4cb366a1}'
Este grupo contiene funciones que operan sobre cadenas, por ejemplo reemplazar, convertir a mayúsculas.
Returns the unicode code associated with the first character of a string.
ascii
(
string
)
| string | the string to convert to unicode code |
ascii('Q')
→
81
Devuelve el carácter asociado con un código unicode.
char
(
code
)
| code | un número de código unicode |
char(81)
→
'Q'
Concatena varias cadenas en una. Los valores NULO se convierten a cadenas vacías. Otros valores (como números) se convierten en cadenas.
concat
(
string1
,
string2
…)
| string | un valor de cadena |
concat('para', 'sol')
→
'parasol'
concat('a','b','c','d','e')
→
'abcde'
concat('Año ', 1984)
→
'Año 1984'
concat('El Muro', NULO)
→
'El Muro'
Da formato a una cadena usando los argumentos proporcionados.
format
(
string
,
arg1
,
arg2
…)
| string | Una cadena con localizadores de posición para los argumentos. Utilice %1, %2, etc. para los localizadores de posición. Los localizadores se pueden repetir. |
| arg | Cualquier tipo. Cualquier número de argumentos. |
format('Esto %1 una %2','es', 'prueba')
→
'Esto es una prueba'
Formats a date type or string into a custom string format. Uses Qt date/time format strings. See QDateTime::toString .
format_date
(
datetime
,
format
[,
language
])
| datetime | valor de fecha, hora o fecha y hora | ||||||||||||||||||||||||||||||||||||||||||||||||
| format |
String template used to format the string.
These expressions may be used for the time part of the format string:
|
||||||||||||||||||||||||||||||||||||||||||||||||
| language | language (lowercase, two- or three-letter, ISO 639 language code) used to format the date into a custom string |
format_date('2012-05-15','dd.MM.yyyy')
→
'15.05.2012'
format_date('2012-05-15','d MMMM yyyy','fr')
→
'15 juin 2012'
Returns a number formatted with the locale separator for thousands. Also truncates the decimal places to the number of supplied places.
format_number
(
number
,
places
[,
language
])
| number | número al que aplicar el formato |
| places | entero que representa el número de posiciones decimales al que truncar la cadena. |
| language | language (lowercase, two- or three-letter, ISO 639 language code) used to format the number into a string |
format_number(10000000.332,2)
→
'10.000.000.33'
Devuelve una subcadena que contiene los n caracteres más a la izquierda de la cadena.
left
(
string
,
length
)
| string | una cadena |
| length | Entero. El número de caracteres a devolver desde la izquierda de la cadena. |
left('Hola Mundo',4)
→
'Hola'
Devuelve el número de caracteres de una cadena o la longitud de la cadena que define una geometría.
length
(
string
)
| string | cadena de la que medir la longitud |
length('hola')
→
5
length
(
geometry
)
| geometry | objeto de geometría lineal |
length(geom_from_wkt('LINESTRING(0 0, 4 0)'))
→
4.0
Convierte una cadena a letras minúsculas.
lower
(
string
)
| string | la cadena a convertir a minúsculas |
lower('HOLA Mundo')
→
'hola mundo'
Returns a string padded on the left to the specified width, using a fill character. If the target width is smaller than the string's length, the string is truncated.
lpad
(
string
,
width
,
fill
)
| string | cadena a ampliar |
| width | longitud de la nueva cadena |
| fill | carácter con el que rellenar los espacios restantes |
lpad('Hola', 10, 'x')
→
'xxxxxxHola'
lpad('Hola', 3, 'x')
→
'Hel'
Devuelve la primera posición que coincide con una expresión regular dentro de una cadena o 0 si no se encuentra la subcadena.
regexp_match
(
input_string
,
regex
)
| input_string | La cadena a probar frente a la expresión regular |
| regex | La expresión regular frente a la que probar. El carácter barra invertida se debe escapar doblemente (ej.: "\\s" para capturar un carácter espacio en blanco). |
regexp_match('QGIS ROCKS','\\sROCKS')
→
4
Devuelve una cadena en la que se ha remplazado la expresión regular proporcionada.
regexp_replace
(
input_string
,
regex
,
replacement
)
| input_string | la cadena a remplazar en las coincidencias |
| regex | La expresión regular a reemplazar. El carácter barra invertida se debe escapar doblemente (ej.: "\\s" para capturar un carácter espacio en blanco). |
| replacement | La cadena que remplazará cualquier coincidencia con la expresión regular. Los grupos capturados se pueden insertar en la cadena de remplazo usando \\1, \\2, etc. |
regexp_replace('QGIS SERÍA GUAY','\\sSERÍA\\s',' ES ')
→
'QGIS ES GUAY'
Devuelve la parte de una cadena que coincide con una expresión regular proporcionada.
regexp_substr
(
input_string
,
regex
)
| input_string | la cadena en la que encontrar coincidencias |
| regex | La expresión regular frente a la que coincidir. El carácter barra invertida se debe escapar doblemente (ej.: "\\s" para capturar un carácter espacio en blanco). |
regexp_substr('abc123','(\\d+)')
→
'123'
Devuelve una cadena con la cadena, matriz o mapa de cadenas proporcionados reemplazados.
replace
(
string
,
before
,
after
)
| string | la cadena de entrada |
| before | la cadena o matriz de cadenas a reemplazar |
| after | la cadena o matriz de cadenas a usar como reemplazo |
replace('QGIS SERÍA GUAY','SERÍA','ES')
→
'QGIS ES GUAY'
replace('QGIS ABC',array('A','B','C'),array('X','Y','Z'))
→
'QGIS XYZ'
replace('QGIS',array('Q','S'),'')
→
'GI'
replace
(
string
,
map
)
| string | la cadena de entrada |
| map | el mapa que contiene claves y valores |
replace('APP SERÍA GUAY',map('APP','QGIS','SERÍA','ES'))
→
'QGIS ES GUAY'
Devuelve una subcadena que contiene los n caracteres más a la derecha de la cadena.
right
(
string
,
length
)
| string | una cadena |
| length | Entero. El número de caracteres a devolver desde la derecha de la cadena. |
right('Hola Mundo',5)
→
'Mundo'
Returns a string padded on the right to the specified width, using a fill character. If the target width is smaller than the string's length, the string is truncated.
rpad
(
string
,
width
,
fill
)
| string | cadena a ampliar |
| width | longitud de la nueva cadena |
| fill | carácter con el que rellenar los espacios restantes |
rpad('Hola', 10, 'x')
→
'Holaxxxxxx'
rpad('Hola', 3, 'x')
→
'Hel'
Devuelve la primera posición coincidente de una subcadena dentro de otra cadena o 0 si no se encuentra la subcadena.
strpos
(
haystack
,
needle
)
| haystack | cadena en la que buscar |
| needle | cadena a buscar |
strpos('ADIÓS MUNDO','MUNDO')
→
7
strpos('HOLA MUNDO','ADIÓS')
→
0
Devuelve una parte de una cadena.
substr
(
string
,
start
[,
length
])
| string | la cadena de entrada completa |
| start | integer representing start position to extract beginning with 1; if start is negative, the return string will begin at the end of the string minus the start value |
| length | entero que representa la longitud de cadena a extraer; si la longitud es negativa, la cadena devuelta omitirá la longitud de caracteres indicada desde el final de la cadena |
substr('HOLA MUNDO'',3,5)
→
'LA MU'
substr('HOLA MUNDO',6)
→
' MUNDO'
substr('HOLA MUNDO',-5)
→
'MUNDO'
substr('HOLA',3,-1)
→
'LL'
substr('HOLA MUNDO',-5,2)
→
'MU'
substr('HOLA MUNDO',-5,-1)
→
'MUND'
Convierte todas las palabras de una cadena a formato de título (todas las palabras en minúscula con la primera letra en mayúscula).
title
(
string
)
| string | la cadena a convertir a formato de título |
title('hola MUndo')
→
'Hola Mundo'
Convierte un número en cadena.
to_string
(
number
)
| number | Valor entero o real. El número a convertir en cadena. |
to_string(123)
→
'123'
Elimina todos los espacios en blanco (espacios, tabuladores, etc.) de comienzo y final de una cadena.
trim
(
string
)
| string | cadena a limpiar |
trim(' hola mundo ')
→
'hola mundo'
Convierte una cadena a letras mayúsculas.
upper
(
string
)
| string | la cadena a convertir a mayúsculas |
upper('hola MUndo')
→
'HOLA MUNDO'
Devuelve una cadena ajustada un número de caracteres máximo/mínimo
wordwrap
(
string
,
wrap_length
[,
delimiter_string
])
| string | la cadena a ajustar |
| wrap_length | un entero. Si wrap_lenght es positivo el número representa el número máximo ideal de caracteres a ajustar; si es negativo, el número representa el número mínimo de caracteres a ajustar. |
| delimiter_string | Optional delimiter string to wrap to a new line. |
wordwrap('UNIVERSIDAD DE QGIS',14)
→
'UNIVERSIDAD DE
QGIS'
wordwrap('UNIVERSIDAD DE QGIS',-3)
→
'UNIVERSIDAD
DE QGIS'