-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy path03-interfazusuario.Rmd
251 lines (201 loc) · 15.5 KB
/
03-interfazusuario.Rmd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
\newpage
# Interfaz de usuario
Dentro de GEE hay un grupo de funciones que permiten interactuar con los objetos, y obtener información sobre sus características o propiedades, y visualizarlos o exportarlos para trabajar con ellos en un entorno distinto a GEE. A este conjunto de funciones le llamaremos funciones de interfaz de usuario. Estas funciones resultan muy útiles para ayudar al usuario a entender los procesos que está programando, así como para verificar que los procesos realicen la tarea deseada. Dentro de este grupo de funciones se distinguen, a continuación, cuatro grupos de funciones.
## Impresión en consola
\index{print}
La función más sencilla de la interfaz es la de imprimir objetos en la consola, lo cual se realiza mediante la función `r colorize2("print")` (imprimir). Al llamar esta función e indicar cualquier objeto como argumento, este se evalúa y se imprime su estructura en la consola. Esta función permite obtener información básica de los objetos como el tipo de objeto, número de registros, características y propiedades de los elementos que lo conforman. Además, esta función resulta muy útil para rastrear errores de programación (*bugs*) en los códigos. El resultado de la siguiente línea de código se puede apreciar en la `r colorize("Fig.")` \@ref(fig:f31).
```{js, echo = T}
print('Hola Mundo');
```
```{r f31, echo = F, out.width="80%", fig.cap="Ejemplo del uso de la función print para imprimir en la consola."}
knitr::include_graphics("Img/holaMundo.png")
```
:::: {.bluebox2 data-latex=""}
::: {.awesomeblock data-latex="{5pt}{\faLightbulb}{darkblue}"}
Se recomienda utilizar varias impresiones en la consola (mediante `r colorize2("print")`), por programa, para verificar el resultado de procesos intermedios.
:::
::::
## Interacción con la pantalla de mapa
Este grupo de funciones permiten agregar objetos del lado del servidor a la pantalla de mapa, así como controlar algunos parámetros de dicha pantalla. Todas las funciones encargadas del manejo de la pantalla de mapa se encuentran dentro de la biblioteca `r colorize2("Map")`.
:::: {.bluebox2 data-latex=""}
::: {.awesomeblock data-latex="{5pt}{\faLightbulb}{darkblue}"}
Para revisar todas las funciones disponibles para la interfaz del usuario, ver la sección de **Code Editor** en la siguiente liga: <https://developers.google.com/earth-engine/apidocs>. Además, en esta sección se indican los argumentos que acepta cada función, así como el tipo de objeto de la salida.
:::
::::
#### Map.addLayer {-}
\index{Map.addLayer}
`r colorize2("Map.addLayer")` permite mostrar elementos en la pantalla de mapa de la API. Por lo tanto, permite mostrar objetos de tipo vector (`r colorize2("ee.Feature")`) o imagen (`r colorize2("ee.Image")`; estos objetos se presentan con mayor detalle más adelante). Los argumentos de la función `r colorize2("Map.addLayer")` incluyen el objeto a añadir a la pantalla de mapa, seguido de un diccionario con información para el despliegue de la capa. Por último, se puede indicar el nombre de la capa con el que se desea mostrar la capa en la pantalla de mapa.
Al utilizar `r colorize2("Map.addLayer")` sobre una imagen se pueden indicar los siguientes argumentos: `bands` (bandas), `min` y `max` (valores mínimos y máximos para visualizar la información). Estos se deben pasar dentro de un par de llaves `{}` como un diccionario (ver Capítulo 5 para una descripción de lo que es un diccionario). La función ofrece la opción de visualizar en modo monobanda o en compuesto RGB (del inglés Red, Green, Blue). En el caso de optar por el primero, permite asignar colores mediante el argumento de palette (paleta de colores); mientras que en el segundo se deben agregar las bandas en orden, es decir, primero la banda que corresponde al canal rojo, seguida del verde y del azul (`r colorize("Fig.")` \@ref(fig:f32)).
```{js, echo = T}
Map.addLayer(image, {bands: ['B4', 'B3', 'B2'],
min: 0, max: 2000},
'RGB');
```
```{r f32, echo = F, out.width="95%", fig.cap="Ejemplo de visualización de un compuesto RGB de una imagen Landsat 8 sobre Laguna de Términos, México."}
knitr::include_graphics("Img/LTerminos.png")
```
:::: {.bluebox2 data-latex=""}
::: {.awesomeblock data-latex="{5pt}{\faLightbulb}{darkblue}"}
En algunas ocasiones, al intentar cargar objetos en la pantalla de mapa, que sean producto de procesamientos demandantes, la consola puede mostrar un error indicando que se superó el tiempo de espera o el límite de memoria disponible. En estos casos, se sugiere exportar el resultado en lugar de tratar de cargarlo en la pantalla de mapa y después visualizarlo de manera local en algún SIG o *software* similar (por ejemplo, QGIS).
La proyección por defecto para mostrar la información en la pantalla de mapa corresponde a EPSG:3857. Los códigos EPSG se pueden consultar en el siguiente enlace: https://epsg.io/. Dicha proyección únicamente se hace para poder visualizar la información, mas no transforma la información con la que el usuario trabaja.
:::
::::
Para el caso de los vectores (`r colorize2("ee.Feature")`) se puede realizar una operación similar a las imágenes, aunque el único argumento válido es `color` (`r colorize("Fig.")` \@ref(fig:f33)):
```{js, echo = T}
Map.addLayer(feature, {color: 'FF0000'}, 'featuresColored');
```
```{r f33, echo = F, out.width="95%", fig.cap="Ejemplo de visualización de un vector con los límites políticos de los países de Sudamérica donde se indica su color."}
knitr::include_graphics("Img/SAmerica.png")
```
:::: {.bluebox2 data-latex=""}
::: {.awesomeblock data-latex="{5pt}{\faLightbulb}{darkblue}"}
El código de los colores pasados al argumento de `palette` o `color` corresponden a códigos hexadecimales. Estos pueden ser consultados en el siguiente enlace: https://htmlcolorcodes.com/es/
:::
::::
#### Map.centerObject {-}
\index{Map.centerObject}
Esta función permite centrar la pantalla de mapa en algún objeto o coordenada (longitud, latitud). Además, se puede indicar el zoom con el cual se quiere centrar el objeto.
```{js, echo = T}
Map.setCenter(-39.86, 20.52, 5)
```
## Creación de gráficos
Este grupo de funciones permiten realizar gráficos de diversos tipos; sin embargo, cada tipo de gráfico contiene argumentos válidos diferentes. Todas estas funciones se encuentran agrupadas dentro de la biblioteca `r colorize2("ui.Chart")`. Los objetos básicos que permite graficar GEE son: vectores (`r colorize2("ee.Feature")`), colecciones de vectores (`r colorize2("ee.FeatureCollection")`), imágenes (`r colorize2("ee.Image")`), colecciones de imágenes (`r colorize2("ee.ImageCollection")`), arreglos (`r colorize2("ee.Array")`) y listas (`r colorize2("ee.List")`). Además, para indicar los colores a utilizar en el gráfico o el título del mismo se puede utilizar el método `r colorize2(".setOptions")` sobre el objeto de tipo gráfico.
#### ui.Chart.feature {-}
\index{ui.Chart.feature}
Este conjunto de funciones permite obtener distintos tipos de gráficos a partir de un vector o una colección de vectores y mostrar su resultado al imprimirlos en la consola (mediante la función `r colorize2("print")`). Algunas de las funciones disponibles son:
* `r colorize2("ui.Chart.feature.byFeature")`.
* `r colorize2("ui.Chart.feature.byProperty")`.
* `r colorize2("ui.Chart.feature.groups")`.
* `r colorize2("ui.Chart.feature.histogram")`.
Por ejemplo:
```{js, echo = T}
ui.Chart.feature.byProperty({
// Indicar el vector o colección de atributos a partir del cual se
// va a hacer el gráfico
feature: coleccionAtributos,
// La propiedad a colocar en el eje de las x
xProperties: 'Clase',
})
```
#### ui.Chart.image {-}
\index{ui.Chart.image}
Este conjunto de funciones permite obtener distintos tipos de gráficos a partir de una imagen o colección de imágenes. Algunas de las funciones que se encuentran disponibles son:
* `r colorize2("ui.Chart.image.byClass")`.
* `r colorize2("ui.Chart.image.byRegion")`.
* `r colorize2("ui.Chart.image.doySeries")`.
* `r colorize2("ui.Chart.image.histogram")`.
* `r colorize2("ui.Chart.image.seriesByRegion")`.
Por ejemplo, para graficar una serie de tiempo a partir de una colección de imágenes se utiliza la función `r colorize2("ui.Chart.image.seriesByRegion")` (`r colorize("Fig.")` \@ref(fig:f34)).
```{js, echo = T}
ui.Chart.image.seriesByRegion({
// Definir la colección de imágenes a graficar
imageCollection: coleccionImagenes,
// Definir las regiones sobre las cuales se va a extraer la
// información para el gráfico
regions: areas.filter(ee.Filter.eq('Tipo','Bosque')),
// El reductor a utilizar para resumir la información de la
// colección de imágenes en las regiones indicadas
reducer: ee.Reducer.mean(),
// La banda sobre la cual se quiere construir el gráfico
band: 'NDVI',
// Tamaño en m del píxel para obtener la información
scale: 30,
// Propiedad para nombrar a cada serie
seriesProperty: 'Tipo'
})
.setOptions({
title: 'Bosque',
colors: ['#EE3A19']
});
```
```{r f34, echo = F, out.width="95%", fig.cap="Ejemplo de un gráfico que muestra los perfiles temporales de un índice de vegetación (NDVI) en tres tipos de áreas: deforestación, permanencia de bosque y permanencia de no bosque."}
knitr::include_graphics("Img/chartEjemplo.png")
```
:::: {.bluebox2 data-latex=""}
::: {.awesomeblock data-latex="{5pt}{\faLightbulb}{darkblue}"}
Los nombres de las funciones para generar gráficos en GEE dan una idea del tipo de gráfica que se puede generar con dicha función y el tipo de insumos que requiere cada tipo de gráfico.
:::
::::
## Exportación de objetos fuera de GEE
Este grupo de funciones permite exportar algún resultado fuera de GEE para ser manejado en otro programa. Todas estas funciones se encuentran dentro de la biblioteca `r colorize2("Export")`. Sin embargo, solo existen cuatro formatos válidos para exportar desde GEE: ráster (`r colorize2("ee.Image")`), vector (`r colorize2("ee.FeatureCollection")`), mapa y video.
#### Export.image {-}
\index{Export.image}
En el caso de las imágenes (ráster, `r colorize2("ee.Image")`), la función para exportarlas es `r colorize2("Export.image")`. Dentro de GEE hay tres opciones para exportar los resultados de una imagen:
* `r colorize2("Export.image.toAsset")`.
* `r colorize2("Export.image.toDrive")`.
* `r colorize2("Export.image.toCloudStorage")`.
La primera permite exportar la imagen (ráster) a la sección de **Assets**, es decir, la sección donde el usuario puede subir su información a GEE. Esta opción es útil cuando el resultado se va a utilizar en otro procedimiento de GEE. La segunda opción permite exportarla al Google Drive de la cuenta con la que se tiene acceso a GEE. Esta opción es útil para trabajar con las imágenes (rásters) en algún entorno local, como algún SIG. La última opción permite exportar la imagen al Google Cloud Storage para utilizarla en algún otro proceso a realizar en Google Cloud Platform. La opción que consideramos es más común para cualquier usuario será la de `r colorize2("Export.image.toDrive")`. Al exportar información de GEE al Google Drive, se recomienda utilizar distintas carpetas para organizarla y definir su nombre en el argumento de `folder`.
:::: {.bluebox2 data-latex=""}
::: {.awesomeblock data-latex="{5pt}{\faLightbulb}{darkblue}"}
Solo se pueden exportar imágenes en formato `r colorize2("ee.Image")`. Sin embargo, no siempre resulta obvio el formato de las imágenes, ya que algunas veces se pueden convertir a un formato de arreglo (`r colorize2("ee.Array")`), tras lo cual hay que volver a convertir la información a formato de imagen (`r colorize2("ee.Image")`) para poder exportarla. La aplicación permite exportar únicamente en formato GeoTiff o TFRecord (tensores), siendo la primera la opción por defecto.
:::
::::
Un ejemplo de cómo exportar una imagen se presenta a continuación.
```{js echo = T}
Export.image.toDrive({
// Definir la imagen a exportar
image: imgDiff,
// Especificar el nombre con el cual se va a guardar la imagen en
// el Google Drive
description: 'DiferenciaNDVI_2016-2017',
// Determinar el tamaño del píxel en m de la imagen a exportar
scale: 30,
// Exportar la imagen en formato GeoTIFF
fileFormat: 'GeoTIFF',
// Definir la carpeta del Google Drive en la que se va a exportar
// la imagen
folder: 'DiferenciaNDVIL8'
});
```
:::: {.bluebox2 data-latex=""}
::: {.awesomeblock data-latex="{5pt}{\faLightbulb}{darkblue}"}
En GEE muchas operaciones utilizan el término de `scale`, sin embargo, este no se refiere a la escala de trabajo en un sentido tradicional (por ejemplo, 1:50000), sino que se refiere al tamaño de píxel expresado en metros.
En algunas ocasiones, al intentar exportar una imagen muy grande (mayor a 10 000 000 de píxeles), la consola puede mostrar un error indicando que el objeto a exportar tiene un número muy alto de píxeles. En este caso, se debe aumentar el número de píxeles máximo permitido para la exportación. Esto se logra indicando el argumento `maxPixels` dentro del diccionario que se pasa a `r colorize2("Export.image.toDrive")`. Por ejemplo, `maxPixels: 1e10`, lo cual permite exportar una imagen con hasta 1 x 10^10 píxeles.
:::
::::
#### Export.table {-}
\index{Export.table}
Por su parte, el formato vector (`r colorize2("ee.Feature")`) permite exportar información vector y tablas sin información geográfica (o sin geometría). De nuevo, para poder exportar en el formato vector, el objeto exportado debe estar en formato de colección de vectores (`r colorize2("ee.FeatureCollection")`). Al igual que en el caso de las imágenes, dentro de GEE hay tres opciones para exportar objetos de tipo vector:
* `r colorize2("Export.table.toAsset")`.
* `r colorize2("Export.table.toDrive")`.
* `r colorize2("Export.table.toCloudStorage")`.
Para el caso de las tablas sin información geográfica asociada, se debe definir el objeto como un objeto vector sin geometría (es decir, `null`) y en la tabla de atributos anexar la información deseada. Un ejemplo del uso de esta función se presenta a continuación:
```{js echo = T}
Export.table.toDrive({
// Definir la colección de vectores a exportar
collection: feature,
// Especificar el nombre con el que se va a guardar el
// archivo en el Google Drive
description: 'nombreArchivo',
// Determinar la carpeta dentro de Google Drive donde
// se va a guardar el archivo
folder: 'mifolder',
// Exportar la información en formato csv (valores
// delimitados por comas)
fileFormat: 'CSV'
});
```
:::: {.bluebox2 data-latex=""}
::: {.awesomeblock data-latex="{5pt}{\faLightbulb}{darkblue}"}
GEE permite exportar información contenida en vectores solo en formatos CSV, GeoJSON, KML, KMZ, SHP o TFRecord. El primer formato es el predeterminado.
:::
::::
#### Export.video {-}
\index{Export.video}
Esta opción permite exportar una colección de imágenes como video, ya sea al almacenamiento de la nube de Google o al Drive.
* `r colorize2("Export.video.toCloudStorage")`.
* `r colorize2("Export.video.toDrive")`.
Esta función puede resultar atractiva para observar los cambios de un área de interés a través del tiempo. A continuación se muestra cómo exportar una colección de imágenes en video:
```{js echo = T}
Export.video.toDrive({
// Definir la colección de imágenes a exportar
collection: coleccionImgs,
// Especificar el nombre con el que se va a guardar el video
// en el Google Drive
description: 'videoTimelapse',
// Definir la carpeta donde se va a exportar el video
folder: 'mifolder',
// Determinar el número de cuadros por segundo
framesPerSecond: 24
});
```