Upload 3 files

10.11_draw_query_indicators_v10_HF.R

@@ -65,8 +65,8 @@ COL_COUNT  <- "#374151"
 COL_RED    <- "#b91c2e"
 COL_YEL    <- "#DEB406"
 COL_AMBER  <- "#405162"
-COL_PURPLE <- COL_RISK
-COL_GREEN  <- COL_INFRA
+COL_PURPLE <- "#94579D"
+COL_GREEN  <- "#337F5E"
 COL_BLUE   <- COL_RISK
 COL_LIGHT_BLUE   <- "#009BC1"
 
@@ -337,9 +337,14 @@ web_sql_qbreaks <- function(tbl, col, n_colors, filter_zero = TRUE) {
 
 # Dynamic: unified per-nivel grid join (mirrors load_grid_unified). niv 4..8.
 # grid_crosswalk has codigo_n4..codigo_n8, so the equi-join always applies.
-web_sql_grid_unified <- function(niv, has_fosas, limit = NULL) {
+# simplify_tol: degrees of simplification applied to g.wkt at query time
+# (0 = no simplification; default 0.005 deg ~= 500 m, suitable for N4-N6).
+web_sql_grid_unified <- function(niv, has_fosas, limit = NULL, simplify_tol = 0.005) {
   col_n        <- paste0("codigo_n", niv)
   limit_clause <- if (!is.null(limit)) paste0("\nLIMIT ", limit) else ""
+  wkt_expr     <- if (simplify_tol > 0)
+    paste0("ST_AsText(ST_SimplifyPreserveTopology(ST_GeomFromText(g.wkt), ", simplify_tol, "))")
+  else "g.wkt"
   fosas_cols <- if (has_fosas)
     ",\n                  COALESCE(CAST(f.fosas_total   AS INTEGER), 0) AS fosas_total,\n                  COALESCE(CAST(f.cuerpos_total AS INTEGER), 0) AS cuerpos_total"
   else
@@ -387,7 +392,7 @@ web_sql_grid_unified <- function(niv, has_fosas, limit = NULL) {
          ) all_pts
          GROUP BY {col_n}
        )
-       SELECT g.codigo, g.CVEGEO, g.wkt,
+       SELECT g.codigo, g.CVEGEO, {wkt_expr} AS wkt,
               CAST(c.homicidio       AS DOUBLE) AS homicidio,
               CAST(c.robo            AS DOUBLE) AS robo,
               CAST(c.secuestro       AS DOUBLE) AS secuestro,
@@ -410,6 +415,50 @@ web_sql_grid_unified <- function(niv, has_fosas, limit = NULL) {
   )
 }
 
+# HF-only: wrap any WEB_SQL template to simplify its wkt column at query time.
+# Avoids modifying WEB_SQL_TEMPLATES (shared with the docs converter which reads
+# pre-simplified Parquet from HuggingFace; double-simplifying would degrade quality).
+# tol: degrees (0.008 deg ~= 800 m -- invisible at municipality choropleth zoom).
+web_sql_simplified <- function(name, tol = 0.008, ...) {
+  inner <- web_sql(name, ...)
+  paste0(
+    "SELECT * REPLACE (",
+    "ST_AsText(ST_SimplifyPreserveTopology(ST_GeomFromText(wkt), ", tol, ")) AS wkt",
+    ") FROM (", inner, ") __q__"
+  )
+}
+
+# App-level cache: crime_sf and quantile breaks loaded ONCE at startup and
+# shared across all sessions. Safe because the DuckDB is read_only and baked
+# into the Docker image -- the data never changes between sessions.
+.load_app_cache <- function() {
+  con <- tryCatch(
+    ddb_connect(DB_PATH, read_only = TRUE),
+    error = function(e) { message("[cache] connect: ", e$message); NULL }
+  )
+  if (is.null(con)) return(list(crime_sf = NULL, qb = list()))
+  on.exit(try(DBI::dbDisconnect(con, shutdown = TRUE), silent = TRUE))
+  qbq <- function(tbl, col, n) tryCatch(
+    as.numeric(DBI::dbGetQuery(con, web_sql_qbreaks(tbl, col, n))[1L, ]),
+    error = function(e) seq_len(n - 1L)
+  )
+  list(
+    crime_sf = tryCatch(
+      DBI::dbGetQuery(con, web_sql_simplified("src_crime", tol = 0.005)) |>
+        sf::st_as_sf(wkt = "wkt", crs = 4326) |>
+        dplyr::select(-wkt),
+      error = function(e) { message("[cache] crime_sf: ", e$message); NULL }
+    ),
+    qb = list(
+      crime = lapply(CRIME_COLS, function(info)
+        qbq("crime_mun", info$col, length(CRIME_STEP_PAL))),
+      desap = qbq("dim_desap_mun", "final_desap_nl_per_100k", length(DESAP_PAL)),
+      pam   = qbq("dim_pam_mun",   "pam_n",                   length(PAM_PAL))
+    )
+  )
+}
+.APP_CACHE <- .load_app_cache()
+
 #######################################################################################
 # WEB_SPEC -- declarative layer / accordion / panel / palette config.
 #   Single source consumed by the Shiny UI AND the docs converter so the two
@@ -1408,8 +1457,9 @@ server <- function(input, output, session) {
     temporal_filter_wkt = NULL
   )
 
-  # Mutable quantile-break cache; populated once in renderMaplibre()
-  qb <- list()
+  # Quantile-break cache: pre-populated from the app-level cache (loaded at startup).
+  # Falls back to an empty list if the cache failed; compute_qbreaks() fills gaps lazily.
+  qb <- .APP_CACHE$qb
 
   # Compute n_colors-1 quantile thresholds from a DuckDB table column
   compute_qbreaks <- function(tbl, col, n_colors, filter_zero = TRUE) {
@@ -1761,27 +1811,27 @@ server <- function(input, output, session) {
   output$map <- renderMaplibre({
     req(con)
 
-    # Compute quantile breaks from actual data (populate qb cache)
-    qb$crime <- lapply(CRIME_COLS, function(info) {
-      compute_qbreaks("crime_mun", info$col, length(CRIME_STEP_PAL))
-    })
-    qb$desap <- compute_qbreaks("dim_desap_mun", "final_desap_nl_per_100k",
-                                length(DESAP_PAL))
-    qb$pam   <- compute_qbreaks("dim_pam_mun", "pam_n", length(PAM_PAL))
+    # qb already populated from .APP_CACHE at server startup -- no DB queries here.
+    # Fill any gaps (e.g. if the cache failed at startup) via compute_qbreaks().
+    if (length(qb$crime) == 0)
+      qb$crime <- lapply(CRIME_COLS, function(info)
+        compute_qbreaks("crime_mun", info$col, length(CRIME_STEP_PAL)))
+    if (is.null(qb$desap))
+      qb$desap <- compute_qbreaks("dim_desap_mun", "final_desap_nl_per_100k", length(DESAP_PAL))
+    if (is.null(qb$pam))
+      qb$pam   <- compute_qbreaks("dim_pam_mun", "pam_n", length(PAM_PAL))
 
     g  <- function(col) list("get", col)
     ts <- function(col) list("to-string", list("get", col))
 
-    crime_sf <- tryCatch({
-      DBI::dbGetQuery(con, web_sql("src_crime")) |>
-        sf::st_as_sf(wkt = "wkt", crs = 4326) |>
-        dplyr::select(-wkt)
-    }, error = function(e) { message("crime_mun: ", e$message); NULL })
+    # crime_sf from app-level cache (loaded once at startup, shared across sessions).
+    crime_sf <- .APP_CACHE$crime_sf
 
     load_grid_unified <- function(niv, limit = NULL) {
+      nv_tol <- if (niv >= 7L) 0.002 else 0.005
       tryCatch({
         DBI::dbGetQuery(con,
-          web_sql_grid_unified(niv, has_fosas_tbl, limit)) |>
+          web_sql_grid_unified(niv, has_fosas_tbl, limit, simplify_tol = nv_tol)) |>
           sf::st_as_sf(wkt = "wkt", crs = 4326) |>
           dplyr::select(-wkt)
       }, error = function(e) { message("grid_nivel", niv, ": ", e$message); NULL })
@@ -1976,7 +2026,7 @@ server <- function(input, output, session) {
   observeEvent(input$grid_nivel, {
     req(input$grid_nivel == "7", !grid7_loaded(), !is.null(con))
     grid7_sf <<- tryCatch({
-      DBI::dbGetQuery(con, web_sql_grid_unified(7, has_fosas_tbl)) |>
+      DBI::dbGetQuery(con, web_sql_grid_unified(7, has_fosas_tbl, simplify_tol = 0.002)) |>
         sf::st_as_sf(wkt = "wkt", crs = 4326) |>
         dplyr::select(-wkt)
     }, error = function(e) { message("N7 lazy load: ", e$message); NULL })
@@ -1990,7 +2040,7 @@ server <- function(input, output, session) {
   lazy_add_fill <- function(key, sql_name, id, make_layer_fn) {
     if (isTRUE(lazy_added[[key]]) || is.null(con)) return()
     sf_data <- tryCatch({
-      DBI::dbGetQuery(con, web_sql(sql_name)) |>
+      DBI::dbGetQuery(con, web_sql_simplified(sql_name)) |>
         sf::st_as_sf(wkt = "wkt", crs = 4326) |>
         dplyr::select(-wkt)
     }, error = function(e) { message("lazy ", id, ": ", e$message); NULL })
@@ -2018,8 +2068,15 @@ server <- function(input, output, session) {
   lazy_add_grid <- function(nv_chr) {
     key <- paste0("grid", nv_chr)
     if (isTRUE(lazy_added[[key]]) || is.null(con)) return()
+    # Use pre-materialised TEMP TABLE if ready; fall back to full CTE otherwise.
+    pre_tbl  <- paste0("grid_pre_n", nv_chr)
+    has_pre  <- tryCatch(DBI::dbExistsTable(con, pre_tbl), error = function(e) FALSE)
+    nv_tol   <- if (nv_chr == "7") 0.002 else 0.005
+    sql      <- if (has_pre) paste("SELECT * FROM", pre_tbl)
+                else web_sql_grid_unified(as.integer(nv_chr), has_fosas_tbl,
+                                          simplify_tol = nv_tol)
     sf_data <- tryCatch({
-      DBI::dbGetQuery(con, web_sql_grid_unified(as.integer(nv_chr), has_fosas_tbl)) |>
+      DBI::dbGetQuery(con, sql) |>
         sf::st_as_sf(wkt = "wkt", crs = 4326) |>
         dplyr::select(-wkt)
     }, error = function(e) { message("lazy grid n", nv_chr, ": ", e$message); NULL })
@@ -2124,6 +2181,19 @@ server <- function(input, output, session) {
     )
     updateSelectInput(session, "state_select",
                       choices = c("Choose a state..." = "", state_ch))
+    # Pre-materialise grid joins for N4/N5/N6 into session TEMP TABLEs.
+    # Runs after national totals so the sidebar populates first.
+    # lazy_add_grid() will use these tables instead of re-running the full CTE.
+    for (.nv in c("4", "5", "6")) {
+      nv_tol <- 0.005
+      tryCatch(
+        DBI::dbExecute(con, paste0(
+          "CREATE TEMP TABLE IF NOT EXISTS grid_pre_n", .nv, " AS ",
+          web_sql_grid_unified(as.integer(.nv), has_fosas_tbl, simplify_tol = nv_tol)
+        )),
+        error = function(e) message("grid_pre_n", .nv, ": ", e$message)
+      )
+    }
   }, once = TRUE)
 
   observeEvent(input$grid_icon_click, {

Dockerfile

@@ -9,7 +9,7 @@ FROM rocker/geospatial:4.4
 #       $(cat /run/secrets/hf_token)" -fL "${DDB_URL}" -o /app/depth_mexico.duckdb
 ARG DDB_URL=https://huggingface.co/datasets/edgarodriguez/depth_alpha/resolve/main/depth_mexico.duckdb
 
-RUN install2.r --error --skipinstalled \
+RUN install2.r --error --skipinstalled --no-docs --no-test --ncpus 4 \
       shiny bslib DBI duckdb dplyr jsonlite htmltools glue writexl ggplot2 stringr \
  && R -e "install.packages('mapgl', repos = c('https://walkerke.r-universe.dev', 'https://cloud.r-project.org'))" \
  && R -e "library(mapgl); library(duckdb); library(sf); library(shiny)"

helpers.R

@@ -46,6 +46,11 @@ ddb_connect <- function(path = ":memory:", remote = FALSE, read_only = FALSE) {
       DBI::dbExecute(con, "LOAD spatial")
     }
   )
+  # Allow DuckDB to use multiple cores and up to 4 GB RAM per connection.
+  tryCatch({
+    DBI::dbExecute(con, "SET threads = 4")
+    DBI::dbExecute(con, "SET memory_limit = '4GB'")
+  }, error = function(e) invisible(NULL))
   if (remote) {
     tryCatch(
       DBI::dbExecute(con, "LOAD httpfs"),