Upload 45 files

.gitattributes

@@ -32,3 +32,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+R/.RData filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,42 @@
+FROM rocker/shiny:latest
+
+RUN apt-get update -qq && apt-get -y --no-install-recommends install \
+	libgdal-dev \
+	libproj-dev \
+	libgeos-dev \
+	default-libmysqlclient-dev \
+	libmysqlclient-dev \
+	libudunits2-dev \
+	netcdf-bin \
+	libxml2-dev \
+	libcairo2-dev \
+    libsqlite3-dev \
+#  libmariadbd-dev \
+    libpq-dev \
+    libssh2-1-dev \
+    unixodbc-dev \
+    libcurl4-openssl-dev \
+    libssl-dev
+    
+RUN apt-get install pandoc
+
+RUN apt-get update && \
+    apt-get upgrade -y && \
+    apt-get clean
+
+RUN R -e "install.packages(pkgs=c('shiny','tidyverse','flexdashboard', 'highcharter', 'leaflet', 'sf', 'ggalluvial', 'plotly', 'rmarkdown'), repos='https://cran.rstudio.com/')" 
+
+RUN R -e "install.packages(pkgs=c('devtools'), repos='https://cran.rstudio.com/')" 
+
+RUN R -e  "devtools::install_github('rstudio/leaflet')"
+
+
+RUN mkdir /root/app
+
+COPY R /root/shiny_save
+
+EXPOSE 3838
+
+# run app
+CMD ["R", "-e", "rmarkdown::run('/root/shiny_save/dash_v2.Rmd', shiny_args=list(host='0.0.0.0', port=3838))"]
+

R/.RData

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bd29f7629805f70aacee0888f94ddf67c8c41dd48158991ebe2e623e7239c45e
+size 21106130

R/.Rhistory

@@ -0,0 +1,6 @@
+load("dash_data_v17.RData")
+distancias_medias["city"]
+input$city_sel == FALSE)
+input$city_sel == FALSE
+remotes::install_github("JohnCoene/firebase")
+devtools::install_github('rstudio/leaflet')

R/.Rproj.user/E43CA360/pcs/files-pane.pper

@@ -0,0 +1,9 @@
+{
+    "sortOrder": [
+        {
+            "columnIndex": 2,
+            "ascending": true
+        }
+    ],
+    "path": "~/Desktop/docker/R"
+}

R/.Rproj.user/E43CA360/pcs/source-pane.pper

@@ -0,0 +1,3 @@
+{
+    "activeTab": 2
+}

R/.Rproj.user/E43CA360/pcs/windowlayoutstate.pper

@@ -0,0 +1,14 @@
+{
+    "left": {
+        "splitterpos": 327,
+        "topwindowstate": "NORMAL",
+        "panelheight": 780,
+        "windowheight": 818
+    },
+    "right": {
+        "splitterpos": 490,
+        "topwindowstate": "NORMAL",
+        "panelheight": 780,
+        "windowheight": 818
+    }
+}

R/.Rproj.user/E43CA360/pcs/workbench-pane.pper

@@ -0,0 +1,5 @@
+{
+    "TabSet1": 0,
+    "TabSet2": 0,
+    "TabZoom": {}
+}

R/.Rproj.user/E43CA360/rmd-outputs

@@ -0,0 +1,10 @@
+
+/private/var/folders/nx/8wln4st11wn5q689p5s4lzwr0000gn/T/RtmpbRUrYS/preview-44f41ff77ab3.html
+/private/var/folders/nx/8wln4st11wn5q689p5s4lzwr0000gn/T/RtmpbRUrYS/preview-43f61d793f60.html
+/private/var/folders/nx/8wln4st11wn5q689p5s4lzwr0000gn/T/RtmpbRUrYS/preview-441519b1c75b.html
+/private/var/folders/nx/8wln4st11wn5q689p5s4lzwr0000gn/T/RtmpbRUrYS/preview-4486538c10bc.html
+
+
+
+
+

R/.Rproj.user/E43CA360/saved_source_markers

@@ -0,0 +1 @@
+{"active_set":"","sets":[]}

R/.Rproj.user/E43CA360/sources/per/t/21382A5A

@@ -0,0 +1,26 @@
+{
+    "id": "21382A5A",
+    "path": "~/Desktop/docker/R/github.md",
+    "project_path": "github.md",
+    "type": "markdown",
+    "hash": "2534523926",
+    "contents": "",
+    "dirty": false,
+    "created": 1654631295448.0,
+    "source_on_save": false,
+    "relative_order": 5,
+    "properties": {
+        "source_window_id": "",
+        "Source": "Source",
+        "cursorPosition": "199,0",
+        "scrollLine": "183"
+    },
+    "folds": "",
+    "lastKnownWriteTime": 1654631250,
+    "encoding": "UTF-8",
+    "collab_server": "",
+    "source_window": "",
+    "last_content_update": 1654631250,
+    "read_only": false,
+    "read_only_alternatives": []
+}

R/.Rproj.user/E43CA360/sources/per/t/21382A5A-contents

@@ -0,0 +1,199 @@
+Dockerizando Shiny
+================
+
+## Introducción
+
+Muchas veces, la versión estándar de los servidores gratuitos de Shiny
+no alcanzan para nuestras hermosas creaciones en R. La limitación que
+más me molestaba era la de las 5 instancias activas simultáneamente.
+Para entornos de test quizá no estaba mal, pero una vez que la
+aplicación llega a ámbitos más profesionales donde probablemente más
+personas utilicen la app al mismo tiempo es más difícil.
+
+En este breve tutorial llevaremos una apliación de Shiny a un
+repositorio Docker y de allí mismo haremos un deploy a un servicio de
+Google Cloud con más RAM y CPUs disponibles.
+
+## Ingredientes
+
+-   Una aplicación Shiny, .Rmd, flexdashboard (como en este ejemplo),
+    etc.
+-   Docker y una cuenta Docker para subir la imagen a un repositorio.
+-   Cuenta en Google Cloud y las APIs básicas activas (el proceso es
+    bastante intuitivo).
+
+## Instalando Docker
+
+Para instalar Docker, se obtiene el archivo desde la página oficial y se
+instala normalmente. En OSX, como es mi caso, después de descargar el
+.dmg se instala de la siguiente manera desde la terminal:
+
+``` bash
+sudo hdiutil attach Docker.dmg
+sudo /Volumes/Docker/Docker.app/Contents/MacOS/install
+sudo hdiutil detach /Volumes/Docker
+```
+
+## Creando el Dockerfile
+
+El archivo Dockerfile es un conjunto de líneas de texto que configuran
+los paquetes que Docker va a utilizar para generar el entorno de nuestra
+aplicación y es donde también le daremos “órdenes” para ejecutar la app.
+
+En mi caso, creé una carpeta que se llama “Docker” con dos elementos:
+una carpeta llamada “R” donde está todo lo relacionado a la aplicación
+Shiny y el propio archivo “Dockerfile” (así, sin puntos, ni extensiones,
+ni cosas raras).
+
+En mi caso, el archivo Dockerfile contiene las siguientes líneas,
+comentadas punto a punto para entender mejor:
+
+``` bash
+FROM rocker/shiny:latest # Se instala el entorno Shiny y R
+
+RUN apt-get update -qq && apt-get -y --no-install-recommends install \ # Se instalan librerías necesarias 
+    libgdal-dev \ # Ojo que probablemente necesites más o menos
+    libproj-dev \ # depende de los paquetes que uses
+    libgeos-dev \
+    default-libmysqlclient-dev \
+    libmysqlclient-dev \
+    libudunits2-dev \
+    netcdf-bin \
+    libxml2-dev \
+    libcairo2-dev \
+    libsqlite3-dev \
+    libpq-dev \
+    libssh2-1-dev \
+    unixodbc-dev \
+    libcurl4-openssl-dev \
+    libssl-dev
+    
+RUN apt-get install pandoc # Tenía problemas con Pandoc e instalarlo por separado lo solucionó
+
+RUN apt-get update && \       # Actualizar paquetes y limpiar
+    apt-get upgrade -y && \
+    apt-get clean
+
+# Se instalan los paquetes necesarios
+# notar que ya estamos ejecutando COMANDOS DE R dentro del Docker
+
+RUN R -e "install.packages(pkgs=c('shiny','tidyverse',
+'flexdashboard', 'leaflet', 'sf', 'ggalluvial', 
+'plotly', 'rmarkdown'), repos='https://cran.rstudio.com/')" 
+
+RUN R -e "install.packages(pkgs=c('devtools'), 
+repos='https://cran.rstudio.com/')" 
+
+RUN R -e  "devtools::install_github('rstudio/leaflet')"
+
+RUN mkdir /root/app # Creamos la carpeta de la app
+
+COPY R /root/shiny_save # Copia la carpeta "R" a la carpeta shiny_save
+ 
+EXPOSE 3838 #Importantísimo: asignarle un puerto de comunicación a la app.
+#Después no vamos a poder hacer nada si no se expone el puerto
+
+# Se corre la app (en este caso, al ser un flexdashboard 
+# tengo que ejecutarlo con rmarkdown, si no sería shiny::runApp(...)). 
+# Como argumento extra le paso el puerto abierto.
+CMD ["R", "-e", "rmarkdown::run('/root/shiny_save/dash_v2.Rmd', 
+shiny_args=list(host='0.0.0.0', port=3838))"] 
+```
+
+## Construcción de la imagen
+
+Una vez que tengamos el dockerfile y la carpeta con todos los archivos
+que necesita la app para correr, pasamos a construir la imagen de Docker
+propiamente dicha. Para esto, abrimos la consola y ejecutamos:
+
+``` bash
+docker login
+```
+
+Nos pedirá el usuario y la contraseña de Docker. La escribimos y luego:
+
+``` bash
+docker build -t nombreapp .
+```
+
+Ese comando construirá una imagen llamada “nombreapp” con los parámetros
+del dockerfile (para eso el punto al final). Esta imagen contiene el
+entorno R y todo el código que hemos usado, dentro de un sistema
+Linux.  
+Es por esto que probablemente tarde bastante en ejecutarse la primera
+vez (a mí me lleva aproximadamente 3 horas), obviamente dependiendo la
+complejidad de la app. Si hacemos modificaciones al código de R de la
+aplicación y pusheamos los cambios (ejecutando los mismos parámetros),
+la construcción tarda muchísimo menos ya que la mayoría de las capas del
+entorno son las mismas y no se modifican. Esto es algo que me encanta de
+Docker. El trabajo se divide en “capas”, por lo que si corregís una
+parte pequeña del código, el build y el push de la app tardan segundos.
+
+``` bash
+docker tag nombreapp usuario/nombreapp:latest
+```
+
+“Tagueamos” la app dentro del repositorio público que estamos por crear.
+Es como decir que lo estamos “seleccionando” para subirlo. El
+repositorio se llamará usuario/nombreapp. La última parte “:latest” es
+un nombre que podemos poner para identificar a la última versión de la
+app. Lo podemos ir modificando para cada versión.
+
+``` bash
+docker push usuario/nombreapp:latest
+```
+
+Se pushea la imagen al repositorio, tal como si fuera GitHub.
+
+## Deploy en Google Cloud
+
+Una vez creado el proyecto, procedemos a abrir la consola de comandos
+dentro de la misma Web de Google. Lo primero que debemos hacer es
+loguearnos con nuestras credenciales de Docker.
+
+``` bash
+docker login
+```
+
+Posteriormente, “traemos” la imagen del Docker a nuestro proyecto de
+Google Cloud con los últimos cambios.
+
+``` bash
+docker pull usuario/nombreapp:latest
+```
+
+Luego, análogamente a lo que hacíamos en Docker, se “taguea” la imagen a
+pushear, lo único es que esta vez no pusheamos al repo de Docker sino al
+container de imágenes de Google Cloud. Reemplazá PROJECT_ID por el ID de
+tu proyecto.
+
+``` bash
+docker tag usuario/nombreapp:latest gcr.io/PROJECT_ID/usuario/nombreapp:latest
+```
+
+Por último, pusheamos la imagen.
+
+``` bash
+docker push gcr.io/PROJECT_ID/usuario/nombreapp:latest
+```
+
+## Creación de la instancia del servicio
+
+Ya casi terminamos. Luego de pusheada la imagen, en la pestaña de Google
+Cloud Run clickeás “Crear Servicio”. Esto nos habilitará una máquina
+virtual para hacer el deploy y que podamos compartir la app a un montón
+de gente.
+
+Donde dice “Url de la imagen” poné seleccionar y se van a desplegar las
+opciones de imagen. Nos va a aparecer la imagen “nombreapp” con la
+versión “latest”. Usamos esa y completamos los parámetros con lo que
+necesite el proyecto.
+
+**IMPORTANTE:** En la parte de más abajo donde dice “CONTENEDOR”,
+completá dentro del campo “Puerto del contenedor” el puerto 3838 o el
+que hayas elegido en la construcción del Dockerfile, ya que sin esto
+Google va a enrutar mal el puerto generando errores.
+
+Esperás unos segundos a que Google cree la instancia y listo! Ya está la
+app deployada en Google Cloud Run. Cualquiera va a poder acceder a ella
+a través de la URL que te muestra arriba del panel.

R/.Rproj.user/E43CA360/sources/per/t/7215F060

@@ -0,0 +1,26 @@
+{
+    "id": "7215F060",
+    "path": "~/Desktop/docker/Dockerfile",
+    "project_path": null,
+    "type": "dockerfile",
+    "hash": "393467562",
+    "contents": "",
+    "dirty": false,
+    "created": 1654610279179.0,
+    "source_on_save": false,
+    "relative_order": 3,
+    "properties": {
+        "source_window_id": "",
+        "Source": "Source",
+        "cursorPosition": "0,0",
+        "scrollLine": "0"
+    },
+    "folds": "",
+    "lastKnownWriteTime": 1654610286,
+    "encoding": "UTF-8",
+    "collab_server": "",
+    "source_window": "",
+    "last_content_update": 1654610286,
+    "read_only": false,
+    "read_only_alternatives": []
+}

R/.Rproj.user/E43CA360/sources/per/t/7215F060-contents

@@ -0,0 +1,42 @@
+FROM rocker/shiny:latest
+
+RUN apt-get update -qq && apt-get -y --no-install-recommends install \
+	libgdal-dev \
+	libproj-dev \
+	libgeos-dev \
+	default-libmysqlclient-dev \
+	libmysqlclient-dev \
+	libudunits2-dev \
+	netcdf-bin \
+	libxml2-dev \
+	libcairo2-dev \
+    libsqlite3-dev \
+#  libmariadbd-dev \
+    libpq-dev \
+    libssh2-1-dev \
+    unixodbc-dev \
+    libcurl4-openssl-dev \
+    libssl-dev
+    
+RUN apt-get install pandoc
+
+RUN apt-get update && \
+    apt-get upgrade -y && \
+    apt-get clean
+
+RUN R -e "install.packages(pkgs=c('shiny','tidyverse','flexdashboard', 'leaflet', 'sf', 'ggalluvial', 'plotly', 'rmarkdown'), repos='https://cran.rstudio.com/')" 
+
+RUN R -e "install.packages(pkgs=c('devtools'), repos='https://cran.rstudio.com/')" 
+
+RUN R -e  "devtools::install_github('rstudio/leaflet')"
+
+
+RUN mkdir /root/app
+
+COPY R /root/shiny_save
+
+EXPOSE 3838
+
+# run app
+CMD ["R", "-e", "rmarkdown::run('/root/shiny_save/dash_v2.Rmd', shiny_args=list(host='0.0.0.0', port=3838))"]
+

R/.Rproj.user/E43CA360/sources/per/t/74244C1E

@@ -0,0 +1,27 @@
+{
+    "id": "74244C1E",
+    "path": "~/Desktop/docker/R/github.Rmd",
+    "project_path": "github.Rmd",
+    "type": "r_markdown",
+    "hash": "1314225375",
+    "contents": "",
+    "dirty": false,
+    "created": 1654628306321.0,
+    "source_on_save": false,
+    "relative_order": 4,
+    "properties": {
+        "tempName": "Untitled1",
+        "source_window_id": "",
+        "Source": "Source",
+        "cursorPosition": "143,22",
+        "scrollLine": "119"
+    },
+    "folds": "",
+    "lastKnownWriteTime": 1654631249,
+    "encoding": "UTF-8",
+    "collab_server": "",
+    "source_window": "",
+    "last_content_update": 1654631249388,
+    "read_only": false,
+    "read_only_alternatives": []
+}

R/.Rproj.user/E43CA360/sources/per/t/74244C1E-contents

@@ -0,0 +1,158 @@
+---
+title: "Dockerizando Shiny"
+output: github_document
+---
+
+```{r setup, include=FALSE}
+knitr::opts_chunk$set(echo = TRUE)
+```
+
+## Introducción
+
+Muchas veces, la versión estándar de los servidores gratuitos de Shiny no alcanzan para nuestras hermosas creaciones en R. La limitación que más me molestaba era la de las 5 instancias activas simultáneamente. Para entornos de test quizá no estaba mal, pero una vez que la aplicación llega a ámbitos más profesionales donde probablemente más personas utilicen la app al mismo tiempo es más difícil.  
+
+En este breve tutorial llevaremos una apliación de Shiny a un repositorio Docker y de allí mismo haremos un deploy a un servicio de Google Cloud con más RAM y CPUs disponibles.
+
+## Ingredientes
+
+- Una aplicación Shiny, .Rmd, flexdashboard (como en este ejemplo), etc.
+- Docker y una cuenta Docker para subir la imagen a un repositorio.
+- Cuenta en Google Cloud y las APIs básicas activas (el proceso es bastante intuitivo).
+
+## Instalando Docker
+
+Para instalar Docker, se obtiene el archivo desde la página oficial y se instala normalmente. En OSX, como es mi caso, después de descargar el .dmg se instala de la siguiente manera desde la terminal:
+
+```{bash, eval = FALSE}
+sudo hdiutil attach Docker.dmg
+sudo /Volumes/Docker/Docker.app/Contents/MacOS/install
+sudo hdiutil detach /Volumes/Docker
+```
+
+## Creando el Dockerfile
+
+El archivo Dockerfile es un conjunto de líneas de texto que configuran los paquetes que Docker va a utilizar para generar el entorno de nuestra aplicación y es donde también le daremos "órdenes" para ejecutar la app.
+
+En mi caso, creé una carpeta que se llama "Docker" con dos elementos: una carpeta llamada "R" donde está todo lo relacionado a la aplicación Shiny y el propio archivo "Dockerfile" (así, sin puntos, ni extensiones, ni cosas raras).
+
+En mi caso, el archivo Dockerfile contiene las siguientes líneas, comentadas punto a punto para entender mejor:
+
+```{bash, eval = FALSE}
+FROM rocker/shiny:latest # Se instala el entorno Shiny y R
+
+RUN apt-get update -qq && apt-get -y --no-install-recommends install \ # Se instalan librerías necesarias 
+	libgdal-dev \ # Ojo que probablemente necesites más o menos
+	libproj-dev \ # depende de los paquetes que uses
+	libgeos-dev \
+	default-libmysqlclient-dev \
+	libmysqlclient-dev \
+	libudunits2-dev \
+	netcdf-bin \
+	libxml2-dev \
+	libcairo2-dev \
+    libsqlite3-dev \
+    libpq-dev \
+    libssh2-1-dev \
+    unixodbc-dev \
+    libcurl4-openssl-dev \
+    libssl-dev
+    
+RUN apt-get install pandoc # Tenía problemas con Pandoc e instalarlo por separado lo solucionó
+
+RUN apt-get update && \       # Actualizar paquetes y limpiar
+    apt-get upgrade -y && \
+    apt-get clean
+
+# Se instalan los paquetes necesarios
+# notar que ya estamos ejecutando COMANDOS DE R dentro del Docker
+
+RUN R -e "install.packages(pkgs=c('shiny','tidyverse',
+'flexdashboard', 'leaflet', 'sf', 'ggalluvial', 
+'plotly', 'rmarkdown'), repos='https://cran.rstudio.com/')" 
+
+RUN R -e "install.packages(pkgs=c('devtools'), 
+repos='https://cran.rstudio.com/')" 
+
+RUN R -e  "devtools::install_github('rstudio/leaflet')"
+
+RUN mkdir /root/app # Creamos la carpeta de la app
+
+COPY R /root/shiny_save # Copia la carpeta "R" a la carpeta shiny_save
+ 
+EXPOSE 3838 #Importantísimo: asignarle un puerto de comunicación a la app.
+#Después no vamos a poder hacer nada si no se expone el puerto
+
+# Se corre la app (en este caso, al ser un flexdashboard 
+# tengo que ejecutarlo con rmarkdown, si no sería shiny::runApp(...)). 
+# Como argumento extra le paso el puerto abierto.
+CMD ["R", "-e", "rmarkdown::run('/root/shiny_save/dash_v2.Rmd', 
+shiny_args=list(host='0.0.0.0', port=3838))"] 
+
+```
+
+## Construcción de la imagen
+
+Una vez que tengamos el dockerfile y la carpeta con todos los archivos que necesita la app para correr, pasamos a construir la imagen de Docker propiamente dicha. Para esto, abrimos la consola y ejecutamos:
+
+```{bash, eval = FALSE}
+docker login
+```
+Nos pedirá el usuario y la contraseña de Docker. La escribimos y luego:
+
+```{bash, eval = FALSE}
+docker build -t nombreapp .
+```
+
+Ese comando construirá una imagen llamada "nombreapp" con los parámetros del dockerfile (para eso el punto al final). Esta imagen contiene el entorno R y todo el código que hemos usado, dentro de un sistema Linux.  
+Es por esto que probablemente tarde bastante en ejecutarse la primera vez (a mí me lleva aproximadamente 3 horas), obviamente dependiendo la complejidad de la app. Si hacemos modificaciones al código de R de la aplicación y pusheamos los cambios (ejecutando los mismos parámetros), la construcción tarda muchísimo menos ya que la mayoría de las capas  del entorno son las mismas y no se modifican. Esto es algo que me encanta de Docker. El trabajo se divide en "capas", por lo que si corregís una parte pequeña del código, el build y el push de la app tardan segundos.
+
+
+```{bash, eval = FALSE}
+docker tag nombreapp usuario/nombreapp:latest
+```
+
+"Tagueamos" la app dentro del repositorio público que estamos por crear. Es como decir que lo estamos "seleccionando" para subirlo. El repositorio se llamará usuario/nombreapp. La última parte ":latest" es un nombre que podemos poner para identificar a la última versión de la app. Lo podemos ir modificando para cada versión.
+
+```{bash, eval = FALSE}
+docker push usuario/nombreapp:latest
+```
+
+Se pushea la imagen al repositorio, tal como si fuera GitHub.
+
+## Deploy en Google Cloud 
+
+  Una vez creado el proyecto, procedemos a abrir la consola de comandos dentro de la misma Web de Google.
+  Lo primero que debemos hacer es loguearnos con nuestras credenciales de Docker. 
+
+```{bash, eval = FALSE}
+docker login
+```
+
+  Posteriormente, "traemos" la imagen del Docker a nuestro proyecto de Google Cloud con los últimos cambios.
+  
+```{bash, eval = FALSE}
+docker pull usuario/nombreapp:latest
+```
+Luego, análogamente a lo que hacíamos en Docker, se "taguea" la imagen a pushear, lo único es que esta vez no pusheamos al repo de Docker sino al container de imágenes de Google Cloud. Reemplazá PROJECT_ID por el ID de tu proyecto.
+
+```{bash, eval = FALSE}
+docker tag usuario/nombreapp:latest gcr.io/PROJECT_ID/usuario/nombreapp:latest
+```
+
+Por último, pusheamos la imagen. 
+
+```{bash, eval = FALSE}
+docker push gcr.io/PROJECT_ID/usuario/nombreapp:latest
+```
+
+## Creación de la instancia del servicio
+
+Ya casi terminamos. Luego de pusheada la imagen, en la pestaña de Google Cloud Run clickeás "Crear Servicio". Esto nos habilitará una máquina virtual para hacer el deploy y que podamos compartir la app a un montón de gente.  
+
+Donde dice "Url de la imagen" poné seleccionar y se van a desplegar las opciones de imagen. Nos va a aparecer la imagen "nombreapp" con la versión "latest". Usamos esa y completamos los parámetros con lo que necesite el proyecto.
+
+**IMPORTANTE:** En la parte de más abajo donde dice "CONTENEDOR", completá dentro del campo "Puerto del contenedor" el puerto 3838 o el que hayas elegido en la construcción del Dockerfile, ya que sin esto Google va a enrutar mal el puerto generando errores.
+
+Esperás unos segundos a que Google cree la instancia y listo! Ya está la app deployada en Google Cloud Run. Cualquiera va a poder acceder a ella a través de la URL que te muestra arriba del panel. 
+
+

R/.Rproj.user/E43CA360/sources/per/t/EB610EE9

@@ -0,0 +1,26 @@
+{
+    "id": "EB610EE9",
+    "path": "~/Desktop/docker/R/global.R",
+    "project_path": "global.R",
+    "type": "r_source",
+    "hash": "3877315401",
+    "contents": "",
+    "dirty": false,
+    "created": 1654609389102.0,
+    "source_on_save": false,
+    "relative_order": 2,
+    "properties": {
+        "source_window_id": "",
+        "Source": "Source",
+        "cursorPosition": "0,1",
+        "scrollLine": "0"
+    },
+    "folds": "",
+    "lastKnownWriteTime": 1654609392,
+    "encoding": "UTF-8",
+    "collab_server": "",
+    "source_window": "",
+    "last_content_update": 1654609392337,
+    "read_only": false,
+    "read_only_alternatives": []
+}

R/.Rproj.user/E43CA360/sources/per/t/EB610EE9-contents

@@ -0,0 +1 @@
+#load("/root/shiny_save/data_def_v5.RData")

R/.Rproj.user/E43CA360/sources/per/t/FDAA923B

@@ -0,0 +1,28 @@
+{
+    "id": "FDAA923B",
+    "path": "~/Desktop/docker/R/dash_v2.Rmd",
+    "project_path": "dash_v2.Rmd",
+    "type": "r_markdown",
+    "hash": "916050268",
+    "contents": "",
+    "dirty": false,
+    "created": 1654609377835.0,
+    "source_on_save": false,
+    "relative_order": 1,
+    "properties": {
+        "source_window_id": "",
+        "Source": "Source",
+        "cursorPosition": "72,91",
+        "scrollLine": "61",
+        "docOutlineVisible": "1",
+        "rmdVisualCollapsedChunks": ""
+    },
+    "folds": "",
+    "lastKnownWriteTime": 1654621409,
+    "encoding": "UTF-8",
+    "collab_server": "",
+    "source_window": "",
+    "last_content_update": 1654621409523,
+    "read_only": false,
+    "read_only_alternatives": []
+}

R/.Rproj.user/E43CA360/sources/per/t/FDAA923B-contents

@@ -0,0 +1,523 @@
+---
+title: "Dashboard Patrones de Movilidad"
+output: 
+  flexdashboard::flex_dashboard:
+    orientation: rows
+    #logo: "omu.png"
+runtime: shiny
+---
+
+```{r setup, include=FALSE}
+library(flexdashboard)
+library(shiny)
+library(leaflet)
+library(tidyverse)
+library(sf)
+library(plotly)
+library(ggalluvial)
+library(scales)
+
+load("data_def_v5.RData")
+
+```
+
+Sidebar {.sidebar}
+=====================================
+
+```{r}
+
+city_sel <- reactive(input$city_sel)
+fecha_sel <- reactive(input$date1)
+
+  tags$style(HTML(".js-irs-0 .irs-single, .js-irs-0 .irs-bar-edge, .js-irs-0 .irs-bar {background: black}"))
+  tags$style(HTML(".js-irs-1 .irs-single, .js-irs-1 .irs-bar-edge, .js-irs-1 .irs-bar {background: black}"))
+  tags$style(HTML(".js-irs-2 .irs-single, .js-irs-2 .irs-bar-edge, .js-irs-2 .irs-bar {background: black}"))
+
+selectInput("city_sel", label = "Ciudad seleccionada:", 
+    choices = list(
+      Argentina = c("Buenos Aires", "Rosario"),
+      Brasil = c("Belo Horizonte", 
+                 "Brasilia", 
+                 "Florianopolis", 
+                 "Porto Alegre", 
+                 "Rio de Janeiro", 
+                 "Sao Paulo"),
+     Colombia = c("Barranquilla", "Bogota", "Cali", "Medellín"),
+      Otros = c("Santiago","Mexico", "Montevideo", "Lima","Panama")
+    ), 
+    selected = "Buenos Aires")
+    dateInput("date1", "Fecha:", value = "2022-04-18", min = "2022-04-18",
+              max = "2022-05-15")
+    checkboxInput("tiles", label = "Cambiar de formato distrito a grilla", value = FALSE)
+    sliderInput("alpha", label = "Opacidad de las capas", min = 0, 
+        max = 1, value = 0.85)
+    h4("Histogramas y dist. medias")
+    sliderInput("top_n", label = "Cantidad de distritos", min = 1,
+        max = 30, value = 8)
+    h4("Matriz Origen y Destino")
+    sliderInput("tolerance", label = "Tolerancia",
+             min = 100, max=60000, value = 4000)
+checkboxInput("mismodest", label = "No incluir flujos intradistrito", value = TRUE)
+  
+#, value = fecha_inicio,
+#           min = fecha_inicio, max = fecha_fin)
+
+ # observe({
+    # We'll use the input$controller variable multiple times, so save it as x
+    # for convenience.
+   #  x <- input$city_sel
+   #  y <- input$date1
+   # if(isTRUE(y %in% as.Date(distancias_medias[which(distancias_medias$city == x),2]))){
+   #   updateDateInput(session, "date1",
+   #    min = as.Date(distancias_medias[min(which(distancias_medias$city == x)), 2]),
+   #    max = as.Date(distancias_medias[max(which(distancias_medias$city == x)), 2]))}else{
+   #    updateDateInput(session, "date1",
+   #    value = as.Date(distancias_medias[min(which(distancias_medias$city == x)), 2]), 
+   #    min = as.Date(distancias_medias[min(which(distancias_medias$city == x)), 2]),
+   #    max = as.Date(distancias_medias[max(which(distancias_medias$city == x)), 2]))
+   #    }
+   #    
+  #     
+  #   
+  # })
+
+```
+
+
+<!-- Información recolectada desde los datasets de **Facebook Disaster Maps** y del Mapa de Población de Alta Definición de Facebook. También se utiliza información de **Open Street Maps** y **GADM**.   -->
+
+<!-- Para más información, consultar la solapa "Metodología".   -->
+
+<div>
+
+```{r picture omu, echo = F, out.width = '95%'}
+knitr::include_graphics("omu.png")
+```
+</div>
+
+<div>
+
+```{r picture caf, echo = F, out.width = '100%'}
+knitr::include_graphics("caf.png")
+```
+
+</div>
+
+<div>
+
+```{r picture bid, echo = F, out.width = '95%'}
+knitr::include_graphics("bid.png")
+```
+
+</div>
+
+<!-- __Juan Ignacio Fulponi__, _2022_.   -->
+ 
+Mapas
+===================================== 
+
+## Row
+
+### Distancia media {.value-box}
+
+```{r}
+
+# Emit the download rate
+renderValueBox({
+histo_data <- viajes %>% 
+                  filter(city == input$city_sel, date == input$date1) %>% 
+                  rename(Partido=start_polygon_name)
+mean_dist <- weighted.mean(histo_data$length_km, histo_data$viajes)
+  valueBox(value = paste0(round(mean(mean_dist), 2), " km."), icon = "fa-road")
+})
+```
+
+### Distancia mediana {.value-box}
+
+```{r}
+
+renderValueBox({
+histo_data <- viajes %>% 
+                  filter(city == input$city_sel, date == input$date1) %>% 
+                  rename(Partido=start_polygon_name)
+median_dist <- median(histo_data$length_km)
+  valueBox(value = paste0(round(mean(median_dist), 2), " km."), icon = "fa-bus", color = "darkgreen")
+})
+```
+
+### Cantidad de pers. que viajan {.value-box}
+
+```{r}
+# Emit the download count
+renderValueBox({
+  count <- viajes %>% 
+  dplyr::filter(city == input$city_sel, date == input$date1) 
+  valueBox(value = paste0(round(sum(count$viajes, na.rm = T)/1000000,2), " mill."), icon = "fa-users", color = "purple")
+})
+```
+
+## Column {data-width="650"}
+
+### Análisis geoespacial
+
+```{r}
+city_sel <- reactive(input$city_sel)
+fecha_sel <- reactive(input$date1)
+
+renderLeaflet({
+     if (input$tiles){
+ grafico <- tiles %>% 
+   dplyr::filter(city == input$city_sel, 
+          date == input$date1)
+if (input$city_sel == "Sao Paulo"){
+   grafico <- st_crop(grafico, xmin = -51.307504, ymin = -25.675336,
+                      xmax= -44.528940, ymax=-21.671866)}
+
+data_points <- grafico %>% st_centroid()
+
+grafico$colors <- as.numeric(cut(grafico$mean_distance, breaks=c(0,3,4,5,6,7,8,9,10,11,12, max(grafico$mean_distance))))
+
+data_points$rescaled_val <- scales::rescale(data_points$n_crisis, to = c(100,1400))
+
+                  
+pal <- colorNumeric("viridis", grafico$mean_distance)
+pal2 <- colorNumeric("PuRd", grafico$n_crisis, reverse = F)
+
+leaflet(grafico) %>% 
+  addProviderTiles(providers$Stamen.Toner) %>% 
+  addPolygons(color = pal(grafico$mean_distance), stroke = NA,
+              fillOpacity = input$alpha, smoothFactor = 0.4, 
+              label = paste0(round(grafico$mean_distance, 2), " km."),
+              group = "Distancias Medias") %>% 
+  addLegend(pal = pal, values = ~grafico$mean_distance, title = "Km.",
+            group = "Distancias Medias") %>% 
+  addCircles(data = data_points, radius = ~rescaled_val, color = pal(grafico$mean_distance), stroke = NA, fillOpacity = input$alpha,
+             label = ~paste0(start_polygon_name, " - Personas que viajan: ", n_crisis*12, " - Distancia media: ", round(mean_distance, 2), " km."),
+              group = "Combinado en puntos") %>% 
+  addPolygons(color = pal2(grafico$n_crisis), stroke = NA,
+              fillOpacity = input$alpha, smoothFactor = 0.4, 
+              label = paste0(round(grafico$n_crisis*12)),
+              group= "Generación de Pers. que viajan") %>% 
+   addLegend(pal = pal2, values = ~grafico$n_crisis, title = "Cant.",
+            group = "Generación de Pers. que viajan", 
+            position = c("topleft")) %>% 
+   addLayersControl(
+    baseGroups=c("Combinado en puntos", "Distancias Medias", "Generación de Pers. que viajan"),
+    position = "bottomleft",
+    options = layersControlOptions(collapsed = FALSE))
+} 
+  else {
+ grafico <- distancias_medias %>%
+   dplyr::filter(city == input$city_sel,
+          date == input$date1) %>% left_join(
+            viajes %>% group_by(start_polygon_name, date, city) %>% 
+              summarise(viajes = sum(viajes))
+          )
+ 
+grafico$colors2 <- as.numeric(cut(grafico$distancia_media, breaks=c(0,3,4,5,6,7,8,9,10,11,12, max(grafico$distancia_media))))
+
+pal_2 <- colorNumeric("viridis", grafico$distancia_media)
+pal_r <- colorNumeric("PuRd", grafico$viajes, reverse = F)
+grafico %>%
+  left_join(geo) %>%
+  st_as_sf() %>% 
+  leaflet() %>%
+  addProviderTiles(providers$Stamen.Toner) %>%
+  addPolygons(color = ~pal_2(distancia_media), stroke = NA,
+              fillOpacity = input$alpha, smoothFactor = 0.4,
+              label = paste0(grafico$start_polygon_name, " - ",
+                             round(grafico$distancia_media, 2), " km."), group = "Distancias Medias") %>%
+  addLegend(pal = pal_2, values = ~distancia_media, title = "Km.", group = "Distancias Medias") %>% 
+    addPolygons(color = pal_r(grafico$viajes), stroke = NA,
+              fillOpacity = input$alpha, smoothFactor = 0.4,
+              label = paste0(grafico$start_polygon_name, " - ",
+                             round(grafico$viajes), " viajes"),
+              group = "Generación de Pers. que viajan") %>%
+   addLegend(pal = pal_r, values = ~grafico$viajes, title = "Cant.",
+            group = "Generación de Pers. que viajan", 
+            position = c("topleft")) %>% 
+   addLayersControl(
+    baseGroups=c("Distancias Medias", "Generación de Pers. que viajan"),
+    position = "bottomleft",
+    options = layersControlOptions(collapsed = FALSE))
+}
+})
+
+```
+
+# Análisis estadístico
+
+## Column {data-width="650"}
+
+### Distancias medias (en km.) de los distritos con más pers. que viajan
+
+```{r}
+city_sel <- reactive(input$city_sel)
+fecha_sel <- reactive(input$date1)
+renderPlotly({
+
+munis <- viajes %>%
+  dplyr::filter(city == input$city_sel) %>%
+    group_by(start_polygon_name) %>%
+    summarise(viajes=sum(viajes, na.rm=T)) %>%
+    top_n(n=input$top_n) %>% dplyr::select(start_polygon_name)
+
+plot_ly(distancias_medias %>% right_join(munis) %>% filter(distancia_media>0), x = ~date, y = ~distancia_media, color = ~start_polygon_name)  %>% add_lines() %>%
+  layout(xaxis = list(zerolinecolor = '#ffff',
+                      gridcolor = 'ffff',
+                      autotick = T, title = ""),
+         yaxis = list(zerolinecolor = '#ffff',
+                      gridcolor = 'ffff', title = "Km."),
+         plot_bgcolor='#e5ecf6') %>%
+layout(legend = list(orientation = "h"))             # put legend in center of x-axis
+
+})
+
+```
+
+### Histograma de pers. que viajan
+
+```{r}
+city_sel <- reactive(input$city_sel)
+fecha_sel <- reactive(input$date1)
+renderPlotly({
+
+Salientes <- viajes %>%
+  dplyr::filter(city == input$city_sel, date == input$date1,
+                start_polygon_name!=end_polygon_name) %>%
+  filter(start_polygon_name!=end_polygon_name) %>%
+  group_by(start_polygon_name) %>%
+  summarise(Salientes=sum(viajes, na.rm=T)) %>%
+  dplyr::top_n(n=input$top_n) %>%
+ # filter(salientes>1000) %>%
+  filter(start_polygon_name!="Dagua")
+
+Entrantes <- viajes %>%
+  dplyr::filter(city == input$city_sel, date == input$date1,
+                start_polygon_name!=end_polygon_name) %>%
+  filter(end_polygon_name %in% Salientes$start_polygon_name) %>%
+  group_by(end_polygon_name) %>%
+  summarise(Entrantes=sum(viajes, na.rm=T)) %>%
+  #filter(entrantes>1000)  %>%
+  filter(end_polygon_name!="Dagua")
+
+Salientes <- Salientes %>%
+  filter(start_polygon_name %in% Entrantes$end_polygon_name)
+
+bind_cols(Entrantes, Salientes) %>% dplyr::select(-end_polygon_name) %>%
+  pivot_longer(cols = c(Entrantes, Salientes)) %>%
+  plot_ly(
+    x = ~start_polygon_name,
+    y = ~value, color = ~name,
+    type = "bar") %>%
+  layout(xaxis = list(zerolinecolor = '#ffff',
+                      gridcolor = 'ffff',
+                      categoryorder = "total descending", title = ""),
+         yaxis = list(zerolinecolor = '#ffff',
+                      gridcolor = 'ffff', title = "Cantidad de pers. que viajan"
+                      ),  barmode = 'stack',
+         plot_bgcolor='#e5ecf6',
+           showlegend = T, legend = list(orientation = 'h',
+                     xanchor = "center",
+                     x = 0.5, y=-0.4))
+})
+
+```
+
+## Column {data-width="650"}
+
+### Histograma de distancias medias entre los distritos
+
+```{r corrplot}
+city_sel <- reactive(input$city_sel)
+fecha_sel <- reactive(input$date1)
+renderPlotly({
+
+histo_data <- viajes %>% 
+                  filter(city == input$city_sel, date == input$date1) %>% 
+                  rename(Distrito=start_polygon_name)
+mean_dist <- weighted.mean(histo_data$length_km, histo_data$viajes)
+median_dist <- median(histo_data$length_km, na.rm = T)
+
+ggplotly(ggplot(histo_data) +
+           geom_histogram(aes(as.numeric(length_km), 
+                              #y = ..density..#, 
+                              #weight = viajes
+                              #fill = Partido
+                              ), bins = 100) +
+           geom_vline(xintercept=mean_dist, size=1, color="red")+
+           geom_vline(xintercept=median_dist, 
+                      size=1, color="blue", linetype = 2)+
+           xlim(c(0,50))+
+           theme(legend.position = "none") + 
+           labs(x = "Distancias medias, en km.", y = "Ocurrencia de distritos", title = paste0("Distancia Media: ", round(mean_dist, 2), " km. - Distancia Mediana: ", round(median_dist, 2), " km.")), tooltip="Distrito"
+)%>%
+  layout(xaxis = list(autorange = TRUE),
+         yaxis = list(autorange = TRUE))
+
+})
+
+
+```
+
+### Flujos Inter e Intradistrito 
+
+```{r}
+city_sel <- reactive(input$city_sel)
+fecha_sel <- reactive(input$date1)
+
+renderPlotly({ 
+  plotly_viajes <- viajes %>% filter(city == input$city_sel) %>% 
+  group_by(date, start_polygon_name, end_polygon_name) %>% 
+  summarise(viajes = sum(viajes)) %>% 
+  mutate(intrap = if_else(start_polygon_name==end_polygon_name, 
+                          "Flujo Intradistrito", 
+                          "Flujo Interdistrito")) %>% 
+  group_by(date, intrap) %>% 
+  summarise(viajes = sum(viajes))  
+
+ggplotly(ggplot(plotly_viajes) + 
+  geom_line(aes(date, viajes/1000, color = intrap)) + 
+  labs(color = NULL, x = NULL, y = "Pers. que viajan (en miles)"),
+        tooltip="viajes/1000")})
+```
+
+
+# Matriz Origen y Destino
+
+## Column {data-width="350"}
+
+### Matriz origen y destino
+
+```{r}
+
+city_sel <- reactive(input$city_sel)
+fecha_sel <- reactive(input$date1)
+
+renderPlot({
+  if (input$mismodest){
+  plot <- viajes %>% 
+  dplyr::filter(city == input$city_sel, date == input$date1) %>%
+  dplyr::filter(start_polygon_name != end_polygon_name) %>% 
+  group_by(start_polygon_name, end_polygon_name) %>% 
+  summarize(viajes = sum(viajes, na.rm=T)) %>% 
+  filter(viajes > input$tolerance)
+  }else{
+    plot <- viajes %>% 
+  dplyr::filter(city == input$city_sel, date == input$date1) %>%
+  group_by(start_polygon_name, end_polygon_name) %>% 
+  summarize(viajes = sum(viajes, na.rm=T)) %>% 
+  filter(viajes > input$tolerance)
+  }
+  
+ggplot(plot, aes(y = viajes/1000000, axis1=start_polygon_name, axis2=end_polygon_name))+
+  geom_alluvium(aes(fill=start_polygon_name))+
+  geom_stratum() +
+  geom_text(stat = "stratum",
+            aes(label = after_stat(stratum))) +
+  scale_x_discrete(limits = c("Origen", "Destino"),
+                   expand = c(0.15, 0.05)) +
+  labs(fill = "", y = "Oers. que viajan (en mill.)") +
+  theme(legend.position = "none")
+
+  })
+```
+
+
+### Pares origen y destino
+
+```{r}
+
+city_sel <- reactive(input$city_sel)
+fecha_sel <- reactive(input$date1)
+
+renderPlotly({
+ arrows <- viajes %>% filter(!is.na(geometry),
+                             city == input$city_sel, 
+                             date == input$date1, 
+                             start_polygon_name != end_polygon_name,
+                             viajes > input$tolerance) %>% 
+  mutate(geometry = gsub("LINESTRING \\(", "", geometry), 
+         geometry = gsub(",", "", geometry),
+         geometry = gsub(")", "", geometry),
+         lonlats = strsplit(geometry, "\\s+"))
+
+arrows$xstart <- sapply(arrows$lonlats,"[[",1) %>% as.numeric
+arrows$ystart <- sapply(arrows$lonlats,"[[",2) %>% as.numeric
+arrows$xend <- sapply(arrows$lonlats,"[[",3) %>% as.numeric
+arrows$yend <- sapply(arrows$lonlats,"[[",4) %>% as.numeric
+
+geo_sf <- geo[which(geo$city==input$city_sel),]
+bbox <- st_bbox(geo_sf)
+
+p <- ggplot(arrows)+
+           geom_sf(data = geo_sf, fill = NA, size = .3) +
+            geom_segment(aes(x=xstart, y=ystart, xend=xend, yend=yend, size = viajes, text = paste0(start_polygon_name, " - ", end_polygon_name, " - ", round(viajes), " viajes.")), color = NA) +
+           scale_size(range=c(.5,1.5)) +
+                    xlim(bbox$xmin, bbox$xmax) +
+                    ylim(bbox$ymin, bbox$ymax) +
+                    theme_void() + theme(legend.position = "none",
+                                                 axis.line = element_blank()) 
+
+mypal <- colorRampPalette(c("white", "darkblue"))(30)
+map2color<-function(x,pal,limits=NULL){
+    if(is.null(limits)) limits=range(x)
+    pal[findInterval(x,seq(limits[1],limits[2],length.out=length(pal)+1), all.inside=TRUE)]
+}
+
+
+g <- ggplotly(p, tooltip = c("text")) %>%
+  add_annotations( x = ~arrows$xend,
+                   y = ~arrows$yend,
+                   xref = "x", yref = "y",
+                   axref = "x", ayref = "y",
+                   text = "",
+                   showarrow = T,
+                   ax = ~arrows$xstart,
+                   ay = ~arrows$ystart,
+                   arrowcolor = ~map2color(log(arrows$viajes), mypal),
+                   arrowwidth = ~rescale(arrows$viajes, 2, 20),
+                   borderwidth = ~rescale(arrows$viajes, 0, 10))
+
+g
+})
+
+
+```
+
+# Metodología
+
+## Column {data-width="650"}
+
+### Metodología aplicada en el presente trabajo
+
+Toda la información presentada es recolectada desde los datasets de **Facebook Disaster Maps** y del Mapa de Población de Alta Definición de Facebook. También se utiliza información de **Open Street Maps** y **GADM**.
+
+
+Cuando las personas usan la aplicación de Facebook con los servicios de ubicación habilitados, sus latitudes y longitudes se reciben en intervalos regulares. La información de ubicación se usa de varias maneras, como ofrecer una función desde la aplicación o contenido que sea más relevante para las personas. Los __Facebook disaster maps__ brindan información sobre dónde se encuentran las personas y cómo se mueven. La información se presenta en dos niveles: por tile (cuadrados) o por región administrativa (como los censos poblacionales).
+
+La región se divide en una grilla (tiles) de 2 km. Facebook detecta las coordenadas de las personas y las clasifica según el tile en el que ha estado más tiempo en las ocho horas anteriores al tiempo de la toma de datos. Por ejemplo, si el conjunto de datos es referido a las 8 a. m. y la persona estaba en su casa, Facebook clasificará a esa persona en ese tile y le asignará "origen". Si la persona pasó la mayor parte de las próximas ocho horas en otro Tile, esa persona aparecerá en los datos agregados del segundo cuadrado como "destino". Si aparece en el mismo tile, el destino será ese mismo tile.
+
+__Sesgo de población__
+
+Desde el punto de vista de las regiones administrativas, es posible que existan diferencias en cuanto al uso de las aplicaciones de Facebook y/o la aceptación del uso de la localización geoespacial. Por lo tanto, tratamos de eliminar ese sesgo tomando sumas de todos los viajes de cada uno de los orígenes y comparándolos geoespacialmente con la población correspondiente de cada región provieniente del dataset de High Resolution Density Maps.
+
+De allí se extraen factores de expansión o pesos que aplicamos a los viajes de cada región administrativa para tener una noción más “real” de los flujos de personas entre partidos o municipios.
+
+__Viajes cortos o nulos__
+
+También se quitan del análisis, para tener un dato más cercano a la realidad de las personas que "no se movieron", aquellas personas que viajan que comienzan y terminan su viaje en el mismo tile. Para esto, se toman las personas que tienen como origen y como destino la misma región administrativa pero distinto tile. Luego, se aplican dos factores de expansión: el primero de acuerdo a la cantidad de personas que viajan intrapartido que figura en el dataset de Movement Between Administrative Regions y el segundo según la población (como en el caso anterior), para luego sumarse a la cantidad de personas que viajan interpartido entre regiones administrativas
+
+El flujo de trabajo se puede representar de la siguiente manera, para cada uno de los partidos o municipios (más técnicamente llamados regiones administrativas), pertenecientes a la zona de las ciudades analizadas.
+
+
+<div>
+
+```{r picture3, echo = F, fig.cap = "Flujograma", out.width = '100%', fig.pos="H"}
+knitr::include_graphics("flujograma.png")
+```
+
+</div>
+
+
+

R/.Rproj.user/E43CA360/sources/prop/79CB3A6C

@@ -0,0 +1,7 @@
+{
+    "tempName": "Untitled1",
+    "source_window_id": "",
+    "Source": "Source",
+    "cursorPosition": "143,22",
+    "scrollLine": "119"
+}

R/.Rproj.user/E43CA360/sources/prop/7DEF3E17

@@ -0,0 +1,6 @@
+{
+    "source_window_id": "",
+    "Source": "Source",
+    "cursorPosition": "0,0",
+    "scrollLine": "0"
+}

R/.Rproj.user/E43CA360/sources/prop/B3A3F0F6

@@ -0,0 +1,6 @@
+{
+    "source_window_id": "",
+    "Source": "Source",
+    "cursorPosition": "0,1",
+    "scrollLine": "0"
+}

R/.Rproj.user/E43CA360/sources/prop/D2B7D434

@@ -0,0 +1,6 @@
+{
+    "source_window_id": "",
+    "Source": "Source",
+    "cursorPosition": "199,0",
+    "scrollLine": "183"
+}

R/.Rproj.user/E43CA360/sources/prop/E88E6722

@@ -0,0 +1,8 @@
+{
+    "source_window_id": "",
+    "Source": "Source",
+    "cursorPosition": "72,91",
+    "scrollLine": "61",
+    "docOutlineVisible": "1",
+    "rmdVisualCollapsedChunks": ""
+}

R/.Rproj.user/E43CA360/sources/prop/INDEX

@@ -0,0 +1,5 @@
+~%2FDesktop%2Fdocker%2FDockerfile="7DEF3E17"
+~%2FDesktop%2Fdocker%2FR%2Fdash_v2.Rmd="E88E6722"
+~%2FDesktop%2Fdocker%2FR%2Fgithub.Rmd="79CB3A6C"
+~%2FDesktop%2Fdocker%2FR%2Fgithub.md="D2B7D434"
+~%2FDesktop%2Fdocker%2FR%2Fglobal.R="B3A3F0F6"

R/.Rproj.user/shared/notebooks/09ED8104-dash_v2/1/E43CA360937CAF11/chunks.json

@@ -0,0 +1 @@
+{"chunk_definitions":[],"doc_write_time":1654609442}

R/.Rproj.user/shared/notebooks/09ED8104-dash_v2/1/s/chunks.json

@@ -0,0 +1 @@
+{"chunk_definitions":[],"doc_write_time":1654609442}

R/.Rproj.user/shared/notebooks/AE375184-github/1/E43CA360937CAF11/chunks.json

@@ -0,0 +1 @@
+{"chunk_definitions":[],"doc_write_time":1654628376}

R/.Rproj.user/shared/notebooks/AE375184-github/1/s/chunks.json

@@ -0,0 +1 @@
+{"chunk_definitions":[],"doc_write_time":1654628376}

R/.Rproj.user/shared/notebooks/paths

@@ -0,0 +1,2 @@
+/Users/juanignaciofulponi/Desktop/docker/R/dash_v2.Rmd="09ED8104"
+/Users/juanignaciofulponi/Desktop/docker/R/github.Rmd="AE375184"

R/Dash BID CAF.Rproj

@@ -0,0 +1,13 @@
+Version: 1.0
+
+RestoreWorkspace: Default
+SaveWorkspace: Default
+AlwaysSaveHistory: Default
+
+EnableCodeIndexing: Yes
+UseSpacesForTab: Yes
+NumSpacesForTab: 2
+Encoding: UTF-8
+
+RnwWeave: Sweave
+LaTeX: pdfLaTeX

R/dash_v2.Rmd

@@ -0,0 +1,516 @@
+---
+title: "Dashboard Patrones de Movilidad"
+output: 
+  flexdashboard::flex_dashboard:
+    orientation: rows
+    #logo: "omu.png"
+runtime: shiny
+---
+
+```{r setup, include=FALSE}
+library(flexdashboard)
+library(shiny)
+library(leaflet)
+library(tidyverse)
+library(sf)
+library(plotly)
+library(ggalluvial)
+library(scales)
+library(highcharter)
+
+load("data_def_v5.RData")
+
+```
+
+Sidebar {.sidebar}
+=====================================
+
+```{r}
+
+city_sel <- reactive(input$city_sel)
+fecha_sel <- reactive(input$date1)
+
+  tags$style(HTML(".js-irs-0 .irs-single, .js-irs-0 .irs-bar-edge, .js-irs-0 .irs-bar {background: black}"))
+  tags$style(HTML(".js-irs-1 .irs-single, .js-irs-1 .irs-bar-edge, .js-irs-1 .irs-bar {background: black}"))
+  tags$style(HTML(".js-irs-2 .irs-single, .js-irs-2 .irs-bar-edge, .js-irs-2 .irs-bar {background: black}"))
+
+selectInput("city_sel", label = "Ciudad seleccionada:", 
+    choices = list(
+      Argentina = c("Buenos Aires", "Rosario"),
+      Brasil = c("Belo Horizonte", 
+                 "Brasilia", 
+                 "Florianopolis", 
+                 "Porto Alegre", 
+                 "Rio de Janeiro", 
+                 "Sao Paulo"),
+     Colombia = c("Barranquilla", "Bogota", "Cali", "Medellín"),
+      Otros = c("Santiago","Mexico", "Montevideo", "Lima","Panama")
+    ), 
+    selected = "Buenos Aires")
+    dateInput("date1", "Fecha:", value = "2022-04-18", min = "2022-04-18",
+              max = "2022-05-15")
+    checkboxInput("tiles", label = "Cambiar de formato distrito a grilla", value = FALSE)
+    sliderInput("alpha", label = "Opacidad de las capas", min = 0, 
+        max = 1, value = 0.85)
+    h4("Histogramas y dist. medias")
+    sliderInput("top_n", label = "Cantidad de distritos", min = 1,
+        max = 30, value = 8)
+    h4("Matriz Origen y Destino")
+    sliderInput("tolerance", label = "Tolerancia",
+             min = 100, max=60000, value = 4000)
+checkboxInput("mismodest", label = "No incluir flujos intradistrito", value = TRUE)
+  
+#, value = fecha_inicio,
+#           min = fecha_inicio, max = fecha_fin)
+
+ # observe({
+    # We'll use the input$controller variable multiple times, so save it as x
+    # for convenience.
+   #  x <- input$city_sel
+   #  y <- input$date1
+   # if(isTRUE(y %in% as.Date(distancias_medias[which(distancias_medias$city == x),2]))){
+   #   updateDateInput(session, "date1",
+   #    min = as.Date(distancias_medias[min(which(distancias_medias$city == x)), 2]),
+   #    max = as.Date(distancias_medias[max(which(distancias_medias$city == x)), 2]))}else{
+   #    updateDateInput(session, "date1",
+   #    value = as.Date(distancias_medias[min(which(distancias_medias$city == x)), 2]), 
+   #    min = as.Date(distancias_medias[min(which(distancias_medias$city == x)), 2]),
+   #    max = as.Date(distancias_medias[max(which(distancias_medias$city == x)), 2]))
+   #    }
+   #    
+  #     
+  #   
+  # })
+
+```
+
+
+<!-- Información recolectada desde los datasets de **Facebook Disaster Maps** y del Mapa de Población de Alta Definición de Facebook. También se utiliza información de **Open Street Maps** y **GADM**.   -->
+
+<!-- Para más información, consultar la solapa "Metodología".   -->
+
+<div>
+
+```{r picture omu, echo = F, out.width = '95%'}
+knitr::include_graphics("omu.png")
+```
+</div>
+
+<div>
+
+```{r picture caf, echo = F, out.width = '100%'}
+knitr::include_graphics("caf.png")
+```
+
+</div>
+
+<div>
+
+```{r picture bid, echo = F, out.width = '95%'}
+knitr::include_graphics("bid.png")
+```
+
+</div>
+
+<!-- __Juan Ignacio Fulponi__, _2022_.   -->
+ 
+Mapas
+===================================== 
+
+## Row
+
+### Distancia media {.value-box}
+
+```{r}
+
+# Emit the download rate
+renderValueBox({
+histo_data <- viajes %>% 
+                  filter(city == input$city_sel, date == input$date1) %>% 
+                  rename(Partido=start_polygon_name)
+mean_dist <- weighted.mean(histo_data$length_km, histo_data$viajes)
+  valueBox(value = paste0(round(mean(mean_dist), 2), " km."), icon = "fa-road")
+})
+```
+
+### Distancia mediana {.value-box}
+
+```{r}
+
+renderValueBox({
+histo_data <- viajes %>% 
+                  filter(city == input$city_sel, date == input$date1) %>% 
+                  rename(Partido=start_polygon_name)
+median_dist <- median(histo_data$length_km)
+  valueBox(value = paste0(round(mean(median_dist), 2), " km."), icon = "fa-bus", color = "darkgreen")
+})
+```
+
+### Cantidad de pers. que viajan {.value-box}
+
+```{r}
+# Emit the download count
+renderValueBox({
+  count <- viajes %>% 
+  dplyr::filter(city == input$city_sel, date == input$date1) 
+  valueBox(value = paste0(round(sum(count$viajes, na.rm = T)/1000000,2), " mill."), icon = "fa-users", color = "purple")
+})
+```
+
+## Column {data-width="650"}
+
+### Análisis geoespacial
+
+```{r}
+city_sel <- reactive(input$city_sel)
+fecha_sel <- reactive(input$date1)
+
+renderLeaflet({
+     if (input$tiles){
+ grafico <- tiles %>% 
+   dplyr::filter(city == input$city_sel, 
+          date == input$date1)
+if (input$city_sel == "Sao Paulo"){
+   grafico <- st_crop(grafico, xmin = -51.307504, ymin = -25.675336,
+                      xmax= -44.528940, ymax=-21.671866)}
+
+data_points <- grafico %>% st_centroid()
+
+grafico$colors <- as.numeric(cut(grafico$mean_distance, breaks=c(0,3,4,5,6,7,8,9,10,11,12, max(grafico$mean_distance))))
+
+data_points$rescaled_val <- scales::rescale(data_points$n_crisis, to = c(100,1400))
+
+                  
+pal <- colorNumeric("viridis", grafico$mean_distance)
+pal2 <- colorNumeric("PuRd", grafico$n_crisis, reverse = F)
+
+leaflet(grafico) %>% 
+  addProviderTiles(providers$Stamen.Toner) %>% 
+  addPolygons(color = pal(grafico$mean_distance), stroke = NA,
+              fillOpacity = input$alpha, smoothFactor = 0.4, 
+              label = paste0(round(grafico$mean_distance, 2), " km."),
+              group = "Distancias Medias") %>% 
+  addLegend(pal = pal, values = ~grafico$mean_distance, title = "Km.",
+            group = "Distancias Medias") %>% 
+  addCircles(data = data_points, radius = ~rescaled_val, color = pal(grafico$mean_distance), stroke = NA, fillOpacity = input$alpha,
+             label = ~paste0(start_polygon_name, " - Personas que viajan: ", n_crisis*12, " - Distancia media: ", round(mean_distance, 2), " km."),
+              group = "Combinado en puntos") %>% 
+  addPolygons(color = pal2(grafico$n_crisis), stroke = NA,
+              fillOpacity = input$alpha, smoothFactor = 0.4, 
+              label = paste0(round(grafico$n_crisis*12)),
+              group= "Generación de Pers. que viajan") %>% 
+   addLegend(pal = pal2, values = ~grafico$n_crisis, title = "Cant.",
+            group = "Generación de Pers. que viajan", 
+            position = c("topleft")) %>% 
+   addLayersControl(
+    baseGroups=c("Combinado en puntos", "Distancias Medias", "Generación de Pers. que viajan"),
+    position = "bottomleft",
+    options = layersControlOptions(collapsed = FALSE))
+} 
+  else {
+ grafico <- distancias_medias %>%
+   dplyr::filter(city == input$city_sel,
+          date == input$date1) %>% left_join(
+            viajes %>% group_by(start_polygon_name, date, city) %>% 
+              summarise(viajes = sum(viajes))
+          )
+ 
+grafico$colors2 <- as.numeric(cut(grafico$distancia_media, breaks=c(0,3,4,5,6,7,8,9,10,11,12, max(grafico$distancia_media))))
+
+pal_2 <- colorNumeric("viridis", grafico$distancia_media)
+pal_r <- colorNumeric("PuRd", grafico$viajes, reverse = F)
+grafico %>%
+  left_join(geo) %>%
+  st_as_sf() %>% 
+  leaflet() %>%
+  addProviderTiles(providers$Stamen.Toner) %>%
+  addPolygons(color = ~pal_2(distancia_media), stroke = NA,
+              fillOpacity = input$alpha, smoothFactor = 0.4,
+              label = paste0(grafico$start_polygon_name, " - ",
+                             round(grafico$distancia_media, 2), " km."), group = "Distancias Medias") %>%
+  addLegend(pal = pal_2, values = ~distancia_media, title = "Km.", group = "Distancias Medias") %>% 
+    addPolygons(color = pal_r(grafico$viajes), stroke = NA,
+              fillOpacity = input$alpha, smoothFactor = 0.4,
+              label = paste0(grafico$start_polygon_name, " - ",
+                             round(grafico$viajes), " viajes"),
+              group = "Generación de Pers. que viajan") %>%
+   addLegend(pal = pal_r, values = ~grafico$viajes, title = "Cant.",
+            group = "Generación de Pers. que viajan", 
+            position = c("topleft")) %>% 
+   addLayersControl(
+    baseGroups=c("Distancias Medias", "Generación de Pers. que viajan"),
+    position = "bottomleft",
+    options = layersControlOptions(collapsed = FALSE))
+}
+})
+
+```
+
+# Análisis estadístico
+
+## Column {data-width="650"}
+
+### Distancias medias (en km.) de los distritos con más pers. que viajan
+
+```{r}
+city_sel <- reactive(input$city_sel)
+fecha_sel <- reactive(input$date1)
+renderPlotly({
+
+munis <- viajes %>%
+  dplyr::filter(city == input$city_sel) %>%
+    group_by(start_polygon_name) %>%
+    summarise(viajes=sum(viajes, na.rm=T)) %>%
+    top_n(n=input$top_n) %>% dplyr::select(start_polygon_name)
+
+plot_ly(distancias_medias %>% right_join(munis) %>% filter(distancia_media>0), x = ~date, y = ~distancia_media, color = ~start_polygon_name)  %>% add_lines() %>%
+  layout(xaxis = list(zerolinecolor = '#ffff',
+                      gridcolor = 'ffff',
+                      autotick = T, title = ""),
+         yaxis = list(zerolinecolor = '#ffff',
+                      gridcolor = 'ffff', title = "Km."),
+         plot_bgcolor='#e5ecf6') %>%
+layout(legend = list(orientation = "h"))             # put legend in center of x-axis
+
+})
+
+```
+
+### Histograma de pers. que viajan
+
+```{r}
+city_sel <- reactive(input$city_sel)
+fecha_sel <- reactive(input$date1)
+renderPlotly({
+
+Salientes <- viajes %>%
+  dplyr::filter(city == input$city_sel, date == input$date1,
+                start_polygon_name!=end_polygon_name) %>%
+  filter(start_polygon_name!=end_polygon_name) %>%
+  group_by(start_polygon_name) %>%
+  summarise(Salientes=sum(viajes, na.rm=T)) %>%
+  dplyr::top_n(n=input$top_n) %>%
+ # filter(salientes>1000) %>%
+  filter(start_polygon_name!="Dagua")
+
+Entrantes <- viajes %>%
+  dplyr::filter(city == input$city_sel, date == input$date1,
+                start_polygon_name!=end_polygon_name) %>%
+  filter(end_polygon_name %in% Salientes$start_polygon_name) %>%
+  group_by(end_polygon_name) %>%
+  summarise(Entrantes=sum(viajes, na.rm=T)) %>%
+  #filter(entrantes>1000)  %>%
+  filter(end_polygon_name!="Dagua")
+
+Salientes <- Salientes %>%
+  filter(start_polygon_name %in% Entrantes$end_polygon_name)
+
+bind_cols(Entrantes, Salientes) %>% dplyr::select(-end_polygon_name) %>%
+  pivot_longer(cols = c(Entrantes, Salientes)) %>%
+  plot_ly(
+    x = ~start_polygon_name,
+    y = ~value, color = ~name,
+    type = "bar") %>%
+  layout(xaxis = list(zerolinecolor = '#ffff',
+                      gridcolor = 'ffff',
+                      categoryorder = "total descending", title = ""),
+         yaxis = list(zerolinecolor = '#ffff',
+                      gridcolor = 'ffff', title = "Cantidad de pers. que viajan"
+                      ),  barmode = 'stack',
+         plot_bgcolor='#e5ecf6',
+           showlegend = T, legend = list(orientation = 'h',
+                     xanchor = "center",
+                     x = 0.5, y=-0.4))
+})
+
+```
+
+## Column {data-width="650"}
+
+### Histograma de distancias medias entre los distritos
+
+```{r corrplot}
+city_sel <- reactive(input$city_sel)
+fecha_sel <- reactive(input$date1)
+renderPlotly({
+
+histo_data <- viajes %>% 
+                  filter(city == input$city_sel, date == input$date1) %>% 
+                  rename(Distrito=start_polygon_name)
+mean_dist <- weighted.mean(histo_data$length_km, histo_data$viajes)
+median_dist <- median(histo_data$length_km, na.rm = T)
+
+ggplotly(ggplot(histo_data) +
+           geom_histogram(aes(as.numeric(length_km), 
+                              #y = ..density..#, 
+                              #weight = viajes
+                              #fill = Partido
+                              ), bins = 100) +
+           geom_vline(xintercept=mean_dist, size=1, color="red")+
+           geom_vline(xintercept=median_dist, 
+                      size=1, color="blue", linetype = 2)+
+           xlim(c(0,50))+
+           theme(legend.position = "none") + 
+           labs(x = "Distancias medias, en km.", y = "Ocurrencia de distritos", title = paste0("Distancia Media: ", round(mean_dist, 2), " km. - Distancia Mediana: ", round(median_dist, 2), " km.")), tooltip="Distrito"
+)%>%
+  layout(xaxis = list(autorange = TRUE),
+         yaxis = list(autorange = TRUE))
+
+})
+
+
+```
+
+### Flujos Inter e Intradistrito 
+
+```{r}
+city_sel <- reactive(input$city_sel)
+fecha_sel <- reactive(input$date1)
+
+renderPlotly({ 
+  plotly_viajes <- viajes %>% filter(city == input$city_sel) %>% 
+  group_by(date, start_polygon_name, end_polygon_name) %>% 
+  summarise(viajes = sum(viajes)) %>% 
+  mutate(intrap = if_else(start_polygon_name==end_polygon_name, 
+                          "Flujo Intradistrito", 
+                          "Flujo Interdistrito")) %>% 
+  group_by(date, intrap) %>% 
+  summarise(viajes = sum(viajes))  
+
+ggplotly(ggplot(plotly_viajes) + 
+  geom_line(aes(date, viajes/1000, color = intrap)) + 
+  labs(color = NULL, x = NULL, y = "Pers. que viajan (en miles)"),
+        tooltip="viajes/1000")})
+```
+
+
+# Matriz Origen y Destino
+
+## Column {data-width="350"}
+
+### Matriz origen y destino
+
+```{r}
+
+city_sel <- reactive(input$city_sel)
+fecha_sel <- reactive(input$date1)
+
+highcharter::renderHighchart({
+  if (input$mismodest){
+  plot <- viajes %>% 
+  dplyr::filter(city == input$city_sel, date == input$date1) %>%
+  dplyr::filter(start_polygon_name != end_polygon_name) %>% 
+  group_by(start_polygon_name, end_polygon_name) %>% 
+  summarize(viajes = sum(viajes, na.rm=T)) %>% 
+  filter(viajes > input$tolerance)
+  }else{
+    plot <- viajes %>% 
+  dplyr::filter(city == input$city_sel, date == input$date1) %>%
+  group_by(start_polygon_name, end_polygon_name) %>% 
+  summarize(viajes = sum(viajes, na.rm=T)) %>% 
+  filter(viajes > input$tolerance)
+  }
+  
+plot %>% mutate(viajes = round(viajes)) %>% uncount(viajes) %>%  data_to_sankey() %>% mutate(to = paste(" ", to)) %>% hchart(type = "sankey")
+})
+
+```
+
+
+### Pares origen y destino
+
+```{r}
+
+city_sel <- reactive(input$city_sel)
+fecha_sel <- reactive(input$date1)
+
+renderPlotly({
+ arrows <- viajes %>% filter(!is.na(geometry),
+                             city == input$city_sel, 
+                             date == input$date1, 
+                             start_polygon_name != end_polygon_name,
+                             viajes > input$tolerance) %>% 
+  mutate(geometry = gsub("LINESTRING \\(", "", geometry), 
+         geometry = gsub(",", "", geometry),
+         geometry = gsub(")", "", geometry),
+         lonlats = strsplit(geometry, "\\s+"))
+
+arrows$xstart <- sapply(arrows$lonlats,"[[",1) %>% as.numeric
+arrows$ystart <- sapply(arrows$lonlats,"[[",2) %>% as.numeric
+arrows$xend <- sapply(arrows$lonlats,"[[",3) %>% as.numeric
+arrows$yend <- sapply(arrows$lonlats,"[[",4) %>% as.numeric
+
+geo_sf <- geo[which(geo$city==input$city_sel),]
+bbox <- st_bbox(geo_sf)
+
+p <- ggplot(arrows)+
+           geom_sf(data = geo_sf, fill = NA, size = .3) +
+            geom_segment(aes(x=xstart, y=ystart, xend=xend, yend=yend, size = viajes, text = paste0(start_polygon_name, " - ", end_polygon_name, " - ", round(viajes), " viajes.")), color = NA) +
+           scale_size(range=c(.5,1.5)) +
+                    xlim(bbox$xmin, bbox$xmax) +
+                    ylim(bbox$ymin, bbox$ymax) +
+                    theme_void() + theme(legend.position = "none",
+                                                 axis.line = element_blank()) 
+
+mypal <- colorRampPalette(c("white", "darkblue"))(30)
+map2color<-function(x,pal,limits=NULL){
+    if(is.null(limits)) limits=range(x)
+    pal[findInterval(x,seq(limits[1],limits[2],length.out=length(pal)+1), all.inside=TRUE)]
+}
+
+
+g <- ggplotly(p, tooltip = c("text")) %>%
+  add_annotations( x = ~arrows$xend,
+                   y = ~arrows$yend,
+                   xref = "x", yref = "y",
+                   axref = "x", ayref = "y",
+                   text = "",
+                   showarrow = T,
+                   ax = ~arrows$xstart,
+                   ay = ~arrows$ystart,
+                   arrowcolor = ~map2color(log(arrows$viajes), mypal),
+                   arrowwidth = ~rescale(arrows$viajes, 2, 20),
+                   borderwidth = ~rescale(arrows$viajes, 0, 10))
+
+g
+})
+
+
+```
+
+# Metodología
+
+## Column {data-width="650"}
+
+### Metodología aplicada en el presente trabajo
+
+Toda la información presentada es recolectada desde los datasets de **Facebook Disaster Maps** y del Mapa de Población de Alta Definición de Facebook. También se utiliza información de **Open Street Maps** y **GADM**.
+
+
+Cuando las personas usan la aplicación de Facebook con los servicios de ubicación habilitados, sus latitudes y longitudes se reciben en intervalos regulares. La información de ubicación se usa de varias maneras, como ofrecer una función desde la aplicación o contenido que sea más relevante para las personas. Los __Facebook disaster maps__ brindan información sobre dónde se encuentran las personas y cómo se mueven. La información se presenta en dos niveles: por tile (cuadrados) o por región administrativa (como los censos poblacionales).
+
+La región se divide en una grilla (tiles) de 2 km. Facebook detecta las coordenadas de las personas y las clasifica según el tile en el que ha estado más tiempo en las ocho horas anteriores al tiempo de la toma de datos. Por ejemplo, si el conjunto de datos es referido a las 8 a. m. y la persona estaba en su casa, Facebook clasificará a esa persona en ese tile y le asignará "origen". Si la persona pasó la mayor parte de las próximas ocho horas en otro Tile, esa persona aparecerá en los datos agregados del segundo cuadrado como "destino". Si aparece en el mismo tile, el destino será ese mismo tile.
+
+__Sesgo de población__
+
+Desde el punto de vista de las regiones administrativas, es posible que existan diferencias en cuanto al uso de las aplicaciones de Facebook y/o la aceptación del uso de la localización geoespacial. Por lo tanto, tratamos de eliminar ese sesgo tomando sumas de todos los viajes de cada uno de los orígenes y comparándolos geoespacialmente con la población correspondiente de cada región provieniente del dataset de High Resolution Density Maps.
+
+De allí se extraen factores de expansión o pesos que aplicamos a los viajes de cada región administrativa para tener una noción más “real” de los flujos de personas entre partidos o municipios.
+
+__Viajes cortos o nulos__
+
+También se quitan del análisis, para tener un dato más cercano a la realidad de las personas que "no se movieron", aquellas personas que viajan que comienzan y terminan su viaje en el mismo tile. Para esto, se toman las personas que tienen como origen y como destino la misma región administrativa pero distinto tile. Luego, se aplican dos factores de expansión: el primero de acuerdo a la cantidad de personas que viajan intrapartido que figura en el dataset de Movement Between Administrative Regions y el segundo según la población (como en el caso anterior), para luego sumarse a la cantidad de personas que viajan interpartido entre regiones administrativas
+
+El flujo de trabajo se puede representar de la siguiente manera, para cada uno de los partidos o municipios (más técnicamente llamados regiones administrativas), pertenecientes a la zona de las ciudades analizadas.
+
+
+<div>
+
+```{r picture3, echo = F, fig.cap = "Flujograma", out.width = '100%', fig.pos="H"}
+knitr::include_graphics("flujograma.png")
+```
+
+</div>
+
+
+

R/github.Rmd

@@ -0,0 +1,158 @@
+---
+title: "Dockerizando Shiny"
+output: github_document
+---
+
+```{r setup, include=FALSE}
+knitr::opts_chunk$set(echo = TRUE)
+```
+
+## Introducción
+
+Muchas veces, la versión estándar de los servidores gratuitos de Shiny no alcanzan para nuestras hermosas creaciones en R. La limitación que más me molestaba era la de las 5 instancias activas simultáneamente. Para entornos de test quizá no estaba mal, pero una vez que la aplicación llega a ámbitos más profesionales donde probablemente más personas utilicen la app al mismo tiempo es más difícil.  
+
+En este breve tutorial llevaremos una apliación de Shiny a un repositorio Docker y de allí mismo haremos un deploy a un servicio de Google Cloud con más RAM y CPUs disponibles.
+
+## Ingredientes
+
+- Una aplicación Shiny, .Rmd, flexdashboard (como en este ejemplo), etc.
+- Docker y una cuenta Docker para subir la imagen a un repositorio.
+- Cuenta en Google Cloud y las APIs básicas activas (el proceso es bastante intuitivo).
+
+## Instalando Docker
+
+Para instalar Docker, se obtiene el archivo desde la página oficial y se instala normalmente. En OSX, como es mi caso, después de descargar el .dmg se instala de la siguiente manera desde la terminal:
+
+```{bash, eval = FALSE}
+sudo hdiutil attach Docker.dmg
+sudo /Volumes/Docker/Docker.app/Contents/MacOS/install
+sudo hdiutil detach /Volumes/Docker
+```
+
+## Creando el Dockerfile
+
+El archivo Dockerfile es un conjunto de líneas de texto que configuran los paquetes que Docker va a utilizar para generar el entorno de nuestra aplicación y es donde también le daremos "órdenes" para ejecutar la app.
+
+En mi caso, creé una carpeta que se llama "Docker" con dos elementos: una carpeta llamada "R" donde está todo lo relacionado a la aplicación Shiny y el propio archivo "Dockerfile" (así, sin puntos, ni extensiones, ni cosas raras).
+
+En mi caso, el archivo Dockerfile contiene las siguientes líneas, comentadas punto a punto para entender mejor:
+
+```{bash, eval = FALSE}
+FROM rocker/shiny:latest # Se instala el entorno Shiny y R
+
+RUN apt-get update -qq && apt-get -y --no-install-recommends install \ # Se instalan librerías necesarias 
+	libgdal-dev \ # Ojo que probablemente necesites más o menos
+	libproj-dev \ # depende de los paquetes que uses
+	libgeos-dev \
+	default-libmysqlclient-dev \
+	libmysqlclient-dev \
+	libudunits2-dev \
+	netcdf-bin \
+	libxml2-dev \
+	libcairo2-dev \
+    libsqlite3-dev \
+    libpq-dev \
+    libssh2-1-dev \
+    unixodbc-dev \
+    libcurl4-openssl-dev \
+    libssl-dev
+    
+RUN apt-get install pandoc # Tenía problemas con Pandoc e instalarlo por separado lo solucionó
+
+RUN apt-get update && \       # Actualizar paquetes y limpiar
+    apt-get upgrade -y && \
+    apt-get clean
+
+# Se instalan los paquetes necesarios
+# notar que ya estamos ejecutando COMANDOS DE R dentro del Docker
+
+RUN R -e "install.packages(pkgs=c('shiny','tidyverse',
+'flexdashboard', 'leaflet', 'sf', 'ggalluvial', 
+'plotly', 'rmarkdown'), repos='https://cran.rstudio.com/')" 
+
+RUN R -e "install.packages(pkgs=c('devtools'), 
+repos='https://cran.rstudio.com/')" 
+
+RUN R -e  "devtools::install_github('rstudio/leaflet')"
+
+RUN mkdir /root/app # Creamos la carpeta de la app
+
+COPY R /root/shiny_save # Copia la carpeta "R" a la carpeta shiny_save
+ 
+EXPOSE 3838 #Importantísimo: asignarle un puerto de comunicación a la app.
+#Después no vamos a poder hacer nada si no se expone el puerto
+
+# Se corre la app (en este caso, al ser un flexdashboard 
+# tengo que ejecutarlo con rmarkdown, si no sería shiny::runApp(...)). 
+# Como argumento extra le paso el puerto abierto.
+CMD ["R", "-e", "rmarkdown::run('/root/shiny_save/dash_v2.Rmd', 
+shiny_args=list(host='0.0.0.0', port=3838))"] 
+
+```
+
+## Construcción de la imagen
+
+Una vez que tengamos el dockerfile y la carpeta con todos los archivos que necesita la app para correr, pasamos a construir la imagen de Docker propiamente dicha. Para esto, abrimos la consola y ejecutamos:
+
+```{bash, eval = FALSE}
+docker login
+```
+Nos pedirá el usuario y la contraseña de Docker. La escribimos y luego:
+
+```{bash, eval = FALSE}
+docker build -t nombreapp .
+```
+
+Ese comando construirá una imagen llamada "nombreapp" con los parámetros del dockerfile (para eso el punto al final). Esta imagen contiene el entorno R y todo el código que hemos usado, dentro de un sistema Linux.  
+Es por esto que probablemente tarde bastante en ejecutarse la primera vez (a mí me lleva aproximadamente 3 horas), obviamente dependiendo la complejidad de la app. Si hacemos modificaciones al código de R de la aplicación y pusheamos los cambios (ejecutando los mismos parámetros), la construcción tarda muchísimo menos ya que la mayoría de las capas  del entorno son las mismas y no se modifican. Esto es algo que me encanta de Docker. El trabajo se divide en "capas", por lo que si corregís una parte pequeña del código, el build y el push de la app tardan segundos.
+
+
+```{bash, eval = FALSE}
+docker tag nombreapp usuario/nombreapp:latest
+```
+
+"Tagueamos" la app dentro del repositorio público que estamos por crear. Es como decir que lo estamos "seleccionando" para subirlo. El repositorio se llamará usuario/nombreapp. La última parte ":latest" es un nombre que podemos poner para identificar a la última versión de la app. Lo podemos ir modificando para cada versión.
+
+```{bash, eval = FALSE}
+docker push usuario/nombreapp:latest
+```
+
+Se pushea la imagen al repositorio, tal como si fuera GitHub.
+
+## Deploy en Google Cloud 
+
+  Una vez creado el proyecto, procedemos a abrir la consola de comandos dentro de la misma Web de Google.
+  Lo primero que debemos hacer es loguearnos con nuestras credenciales de Docker. 
+
+```{bash, eval = FALSE}
+docker login
+```
+
+  Posteriormente, "traemos" la imagen del Docker a nuestro proyecto de Google Cloud con los últimos cambios.
+  
+```{bash, eval = FALSE}
+docker pull usuario/nombreapp:latest
+```
+Luego, análogamente a lo que hacíamos en Docker, se "taguea" la imagen a pushear, lo único es que esta vez no pusheamos al repo de Docker sino al container de imágenes de Google Cloud. Reemplazá PROJECT_ID por el ID de tu proyecto.
+
+```{bash, eval = FALSE}
+docker tag usuario/nombreapp:latest gcr.io/PROJECT_ID/usuario/nombreapp:latest
+```
+
+Por último, pusheamos la imagen. 
+
+```{bash, eval = FALSE}
+docker push gcr.io/PROJECT_ID/usuario/nombreapp:latest
+```
+
+## Creación de la instancia del servicio
+
+Ya casi terminamos. Luego de pusheada la imagen, en la pestaña de Google Cloud Run clickeás "Crear Servicio". Esto nos habilitará una máquina virtual para hacer el deploy y que podamos compartir la app a un montón de gente.  
+
+Donde dice "Url de la imagen" poné seleccionar y se van a desplegar las opciones de imagen. Nos va a aparecer la imagen "nombreapp" con la versión "latest". Usamos esa y completamos los parámetros con lo que necesite el proyecto.
+
+**IMPORTANTE:** En la parte de más abajo donde dice "CONTENEDOR", completá dentro del campo "Puerto del contenedor" el puerto 3838 o el que hayas elegido en la construcción del Dockerfile, ya que sin esto Google va a enrutar mal el puerto generando errores.
+
+Esperás unos segundos a que Google cree la instancia y listo! Ya está la app deployada en Google Cloud Run. Cualquiera va a poder acceder a ella a través de la URL que te muestra arriba del panel. 
+
+

R/github.md

@@ -0,0 +1,199 @@
+Dockerizando Shiny
+================
+
+## Introducción
+
+Muchas veces, la versión estándar de los servidores gratuitos de Shiny
+no alcanzan para nuestras hermosas creaciones en R. La limitación que
+más me molestaba era la de las 5 instancias activas simultáneamente.
+Para entornos de test quizá no estaba mal, pero una vez que la
+aplicación llega a ámbitos más profesionales donde probablemente más
+personas utilicen la app al mismo tiempo es más difícil.
+
+En este breve tutorial llevaremos una apliación de Shiny a un
+repositorio Docker y de allí mismo haremos un deploy a un servicio de
+Google Cloud con más RAM y CPUs disponibles.
+
+## Ingredientes
+
+-   Una aplicación Shiny, .Rmd, flexdashboard (como en este ejemplo),
+    etc.
+-   Docker y una cuenta Docker para subir la imagen a un repositorio.
+-   Cuenta en Google Cloud y las APIs básicas activas (el proceso es
+    bastante intuitivo).
+
+## Instalando Docker
+
+Para instalar Docker, se obtiene el archivo desde la página oficial y se
+instala normalmente. En OSX, como es mi caso, después de descargar el
+.dmg se instala de la siguiente manera desde la terminal:
+
+``` bash
+sudo hdiutil attach Docker.dmg
+sudo /Volumes/Docker/Docker.app/Contents/MacOS/install
+sudo hdiutil detach /Volumes/Docker
+```
+
+## Creando el Dockerfile
+
+El archivo Dockerfile es un conjunto de líneas de texto que configuran
+los paquetes que Docker va a utilizar para generar el entorno de nuestra
+aplicación y es donde también le daremos “órdenes” para ejecutar la app.
+
+En mi caso, creé una carpeta que se llama “Docker” con dos elementos:
+una carpeta llamada “R” donde está todo lo relacionado a la aplicación
+Shiny y el propio archivo “Dockerfile” (así, sin puntos, ni extensiones,
+ni cosas raras).
+
+En mi caso, el archivo Dockerfile contiene las siguientes líneas,
+comentadas punto a punto para entender mejor:
+
+``` bash
+FROM rocker/shiny:latest # Se instala el entorno Shiny y R
+
+RUN apt-get update -qq && apt-get -y --no-install-recommends install \ # Se instalan librerías necesarias 
+    libgdal-dev \ # Ojo que probablemente necesites más o menos
+    libproj-dev \ # depende de los paquetes que uses
+    libgeos-dev \
+    default-libmysqlclient-dev \
+    libmysqlclient-dev \
+    libudunits2-dev \
+    netcdf-bin \
+    libxml2-dev \
+    libcairo2-dev \
+    libsqlite3-dev \
+    libpq-dev \
+    libssh2-1-dev \
+    unixodbc-dev \
+    libcurl4-openssl-dev \
+    libssl-dev
+    
+RUN apt-get install pandoc # Tenía problemas con Pandoc e instalarlo por separado lo solucionó
+
+RUN apt-get update && \       # Actualizar paquetes y limpiar
+    apt-get upgrade -y && \
+    apt-get clean
+
+# Se instalan los paquetes necesarios
+# notar que ya estamos ejecutando COMANDOS DE R dentro del Docker
+
+RUN R -e "install.packages(pkgs=c('shiny','tidyverse',
+'flexdashboard', 'leaflet', 'sf', 'ggalluvial', 
+'plotly', 'rmarkdown'), repos='https://cran.rstudio.com/')" 
+
+RUN R -e "install.packages(pkgs=c('devtools'), 
+repos='https://cran.rstudio.com/')" 
+
+RUN R -e  "devtools::install_github('rstudio/leaflet')"
+
+RUN mkdir /root/app # Creamos la carpeta de la app
+
+COPY R /root/shiny_save # Copia la carpeta "R" a la carpeta shiny_save
+ 
+EXPOSE 3838 #Importantísimo: asignarle un puerto de comunicación a la app.
+#Después no vamos a poder hacer nada si no se expone el puerto
+
+# Se corre la app (en este caso, al ser un flexdashboard 
+# tengo que ejecutarlo con rmarkdown, si no sería shiny::runApp(...)). 
+# Como argumento extra le paso el puerto abierto.
+CMD ["R", "-e", "rmarkdown::run('/root/shiny_save/dash_v2.Rmd', 
+shiny_args=list(host='0.0.0.0', port=3838))"] 
+```
+
+## Construcción de la imagen
+
+Una vez que tengamos el dockerfile y la carpeta con todos los archivos
+que necesita la app para correr, pasamos a construir la imagen de Docker
+propiamente dicha. Para esto, abrimos la consola y ejecutamos:
+
+``` bash
+docker login
+```
+
+Nos pedirá el usuario y la contraseña de Docker. La escribimos y luego:
+
+``` bash
+docker build -t nombreapp .
+```
+
+Ese comando construirá una imagen llamada “nombreapp” con los parámetros
+del dockerfile (para eso el punto al final). Esta imagen contiene el
+entorno R y todo el código que hemos usado, dentro de un sistema
+Linux.  
+Es por esto que probablemente tarde bastante en ejecutarse la primera
+vez (a mí me lleva aproximadamente 3 horas), obviamente dependiendo la
+complejidad de la app. Si hacemos modificaciones al código de R de la
+aplicación y pusheamos los cambios (ejecutando los mismos parámetros),
+la construcción tarda muchísimo menos ya que la mayoría de las capas del
+entorno son las mismas y no se modifican. Esto es algo que me encanta de
+Docker. El trabajo se divide en “capas”, por lo que si corregís una
+parte pequeña del código, el build y el push de la app tardan segundos.
+
+``` bash
+docker tag nombreapp usuario/nombreapp:latest
+```
+
+“Tagueamos” la app dentro del repositorio público que estamos por crear.
+Es como decir que lo estamos “seleccionando” para subirlo. El
+repositorio se llamará usuario/nombreapp. La última parte “:latest” es
+un nombre que podemos poner para identificar a la última versión de la
+app. Lo podemos ir modificando para cada versión.
+
+``` bash
+docker push usuario/nombreapp:latest
+```
+
+Se pushea la imagen al repositorio, tal como si fuera GitHub.
+
+## Deploy en Google Cloud
+
+Una vez creado el proyecto, procedemos a abrir la consola de comandos
+dentro de la misma Web de Google. Lo primero que debemos hacer es
+loguearnos con nuestras credenciales de Docker.
+
+``` bash
+docker login
+```
+
+Posteriormente, “traemos” la imagen del Docker a nuestro proyecto de
+Google Cloud con los últimos cambios.
+
+``` bash
+docker pull usuario/nombreapp:latest
+```
+
+Luego, análogamente a lo que hacíamos en Docker, se “taguea” la imagen a
+pushear, lo único es que esta vez no pusheamos al repo de Docker sino al
+container de imágenes de Google Cloud. Reemplazá PROJECT_ID por el ID de
+tu proyecto.
+
+``` bash
+docker tag usuario/nombreapp:latest gcr.io/PROJECT_ID/usuario/nombreapp:latest
+```
+
+Por último, pusheamos la imagen.
+
+``` bash
+docker push gcr.io/PROJECT_ID/usuario/nombreapp:latest
+```
+
+## Creación de la instancia del servicio
+
+Ya casi terminamos. Luego de pusheada la imagen, en la pestaña de Google
+Cloud Run clickeás “Crear Servicio”. Esto nos habilitará una máquina
+virtual para hacer el deploy y que podamos compartir la app a un montón
+de gente.
+
+Donde dice “Url de la imagen” poné seleccionar y se van a desplegar las
+opciones de imagen. Nos va a aparecer la imagen “nombreapp” con la
+versión “latest”. Usamos esa y completamos los parámetros con lo que
+necesite el proyecto.
+
+**IMPORTANTE:** En la parte de más abajo donde dice “CONTENEDOR”,
+completá dentro del campo “Puerto del contenedor” el puerto 3838 o el
+que hayas elegido en la construcción del Dockerfile, ya que sin esto
+Google va a enrutar mal el puerto generando errores.
+
+Esperás unos segundos a que Google cree la instancia y listo! Ya está la
+app deployada en Google Cloud Run. Cualquiera va a poder acceder a ella
+a través de la URL que te muestra arriba del panel.

R/global.R

@@ -0,0 +1 @@
+#load("/root/shiny_save/data_def_v5.RData")