Upload 2 files

depth_interactive_map_alpha.R

@@ -1116,8 +1116,10 @@ WEB_SPEC <- list(
            # Variant legends shown when the matching categorical chip is active.
            # data-variant-key on each wrap is matched by setPATPType in JS.
            legend_extras = list(
-             pr_pred_loc_rur  = list(type = "cats", pal = "patp_rural"),
-             delitos_fc_b_j_a = list(type = "cats", pal = "patp_delito")
+             pr_pred_loc_rur  = list(type = "cats", pal = "patp_rural",
+                                     filterable = "patp_rural"),
+             delitos_fc_b_j_a = list(type = "cats", pal = "patp_delito",
+                                     filterable = "patp_delito")
            )),
       list(kind = "radios", group = "patp"),
       list(kind = "layer", value = "pobreza-choro",
@@ -1497,6 +1499,20 @@ LUCIDE_JS <- tags$head(
           }
         }
       });
+      // Server sends `temporal_range` whenever the most-recent temporal layer
+      // changes; payload is the layer's actual ym data span. Resize the
+      // slider, reset the handles to the new full range, and clear any
+      // residual map filter so the user sees the whole layer immediately.
+      Shiny.addCustomMessageHandler('temporal_range', function(msg) {
+        if (!msg) return;
+        var startEl = document.getElementById('temporal-start');
+        var endEl   = document.getElementById('temporal-end');
+        if (!startEl || !endEl) return;
+        var lo = parseInt(msg.min, 10), hi = parseInt(msg.max, 10);
+        startEl.min = lo; startEl.max = hi; startEl.value = lo;
+        endEl.min   = lo; endEl.max   = hi; endEl.value   = hi;
+        onTemporalSliderInput();
+      });
     }
 
     // -- Temporal strip: bottom-of-map month-year range filter ------------------
@@ -1598,6 +1614,11 @@ LUCIDE_JS <- tags$head(
       }
     }
 
+    // Server-side filter (PAM polygon re-aggregation) is heavy: each call runs
+    // a 2475-row SQL query + remove/re-add of the WebGL layer. Dragging the
+    // slider would otherwise queue dozens of these. Client-side point filters
+    // are cheap (setFilter on existing features) and stay synchronous.
+    var _temporalServerTimer = null;
     function pushTemporalFilter() {
       var startEl = document.getElementById('temporal-start');
       var endEl   = document.getElementById('temporal-end');
@@ -1606,16 +1627,22 @@ LUCIDE_JS <- tags$head(
       var ymHi = parseInt(endEl.value,   10);
       if (ymLo > ymHi) { var t = ymLo; ymLo = ymHi; ymHi = t; }
       _temporal.ymLo = ymLo; _temporal.ymHi = ymHi;
-      // Client: apply for each active POINT layer
+      // Client: apply for each active POINT layer (cheap, every tick).
       _temporal.active.forEach(function(id) {
         if (TEMPORAL_POINT_COL[id]) applyTemporalFilterClient(id, ymLo, ymHi);
       });
-      // Server: send range so PAM can re-query if it's active
-      if (typeof Shiny !== 'undefined') {
-        Shiny.setInputValue('temporal_filter', {
-          start: ymLo, end: ymHi, active: _temporal.active, ts: Date.now()
-        }, { priority: 'event' });
-      }
+      // Server: debounce so PAM re-aggregation only runs after the user
+      // pauses for 200ms. Always send the latest range when the timer fires.
+      if (_temporalServerTimer) clearTimeout(_temporalServerTimer);
+      _temporalServerTimer = setTimeout(function() {
+        _temporalServerTimer = null;
+        if (typeof Shiny !== 'undefined') {
+          Shiny.setInputValue('temporal_filter', {
+            start: _temporal.ymLo, end: _temporal.ymHi,
+            active: _temporal.active, ts: Date.now()
+          }, { priority: 'event' });
+        }
+      }, 200);
     }
 
     function onTemporalSliderInput() {
@@ -4186,6 +4213,40 @@ server <- function(input, output, session) {
     }
   }, ignoreInit = TRUE, ignoreNULL = TRUE)
 
+  # --- Legend filter: PATP-CONEVAL categorical chips --------------------------
+  # Same pattern as infra: clicking a swatch toggles its category off; the
+  # filter is applied to the muni-level `patp-choro` layer on the column that
+  # matches the variant (pr_pred_loc_rur for rural problem, delitos_fc_b_j_a
+  # for crime focus). Grid-mode patp layers are not filtered -- they aggregate
+  # per cell and don't carry the raw categorical column.
+  apply_patp_cat_filter <- function(col_name, pal_cats, visible) {
+    if (!isTRUE(lazy_added$patp)) return()
+    prx <- maplibre_proxy("map")
+    if (length(visible) == 0) {
+      prx |> set_filter("patp-choro", list("==", list("get", col_name), "__none__"))
+    } else if (length(visible) >= length(pal_cats)) {
+      prx |> set_filter("patp-choro", NULL)
+    } else {
+      prx |> set_filter("patp-choro",
+        list("in", list("get", col_name),
+             list("literal", as.list(visible))))
+    }
+  }
+  observeEvent(input$patp_rural_filter, {
+    pl <- input$patp_rural_filter
+    if (is.null(pl)) return()
+    apply_patp_cat_filter("pr_pred_loc_rur",
+                          PATP_RURAL_PROBLEM_PAL,
+                          as.character(pl$cats %||% character(0)))
+  }, ignoreInit = TRUE, ignoreNULL = TRUE)
+  observeEvent(input$patp_delito_filter, {
+    pl <- input$patp_delito_filter
+    if (is.null(pl)) return()
+    apply_patp_cat_filter("delitos_fc_b_j_a",
+                          PATP_DELITO_PAL,
+                          as.character(pl$cats %||% character(0)))
+  }, ignoreInit = TRUE, ignoreNULL = TRUE)
+
   # --- Nav-bar search: fly to picked result -----------------------------------
   observeEvent(input$search_flyto, {
     pt <- input$search_flyto
@@ -4428,9 +4489,9 @@ server <- function(input, output, session) {
   output$temporal_ged   <- make_temporal_yr("ged_events",   "year", COL_LIGHT_BLUE)
 
   # --- Temporal strip chart (bottom-of-map month-year range filter) -----------
-  # Honeycomb-style: monthly bars across the full timespan, dim outside the
-  # selected window and saturated inside it. Single layer (most-recently
-  # toggled). No y-axis, no legend, compact theme.
+  # Honeycomb-style: monthly bars across the layer's actual data span, dim
+  # outside the selected window and saturated inside it. Single layer
+  # (most-recently toggled). No y-axis, no legend, compact theme.
   output$temporal_strip_chart <- renderPlot({
     active <- input$temporal_active %||% character(0)
     if (length(active) == 0) return(NULL)
@@ -4440,17 +4501,23 @@ server <- function(input, output, session) {
     info <- TEMPORAL_LAYERS[[primary_id]]
     bar_color <- info$color
 
-    ym_range <- TEMPORAL_RANGE
+    # X-axis spans the layer's actual data range, not the global slider span.
+    ym_data_lo <- min(df_all$ym, na.rm = TRUE)
+    ym_data_hi <- max(df_all$ym, na.rm = TRUE)
     pl <- input$temporal_filter
-    ym_lo <- if (is.null(pl)) ym_range[1] else (pl$start %||% ym_range[1])
-    ym_hi <- if (is.null(pl)) ym_range[2] else (pl$end   %||% ym_range[2])
+    ym_lo <- if (is.null(pl)) ym_data_lo else (pl$start %||% ym_data_lo)
+    ym_hi <- if (is.null(pl)) ym_data_hi else (pl$end   %||% ym_data_hi)
     df_all$in_win <- df_all$ym >= ym_lo & df_all$ym <= ym_hi
 
-    # Year-only x ticks across the full slider span.
-    yr_lo <- ym_range[1] %/% 12L
-    yr_hi <- ym_range[2] %/% 12L
-    yr_seq <- seq(yr_lo, yr_hi,
-                  by = if (yr_hi - yr_lo > 12) 2L else 1L)
+    # Year-only x ticks scaled to the actual data span. Pick a step that
+    # produces 5-9 labels so they don't crowd on short spans.
+    yr_lo <- ym_data_lo %/% 12L
+    yr_hi <- ym_data_hi %/% 12L
+    yr_span <- yr_hi - yr_lo
+    yr_step <- if (yr_span <= 6) 1L
+               else if (yr_span <= 14) 2L
+               else 3L
+    yr_seq <- seq(yr_lo, yr_hi, by = yr_step)
     yr_breaks <- yr_seq * 12L
     yr_labels <- as.character(yr_seq)
 
@@ -4459,7 +4526,7 @@ server <- function(input, output, session) {
       scale_fill_manual(values = c(`FALSE` = "#ffffff22",
                                     `TRUE`  = bar_color)) +
       scale_x_continuous(breaks = yr_breaks, labels = yr_labels,
-                         limits = c(ym_range[1] - 0.5, ym_range[2] + 0.5),
+                         limits = c(ym_data_lo - 0.5, ym_data_hi + 0.5),
                          expand = expansion(mult = c(0, 0))) +
       scale_y_continuous(expand = expansion(mult = c(0, 0.05))) +
       labs(x = NULL, y = NULL) +
@@ -4475,9 +4542,28 @@ server <- function(input, output, session) {
             plot.margin      = margin(0, 4, 0, 4))
   }, bg = "transparent", res = 110)
 
+  # When the active temporal layer changes (most-recent toggled), push that
+  # layer's actual data span to the JS slider so the handles + x-axis labels
+  # bracket only the months that have data. Switching from OCVED (2010-2018)
+  # to GED (2019-2024) re-scopes both the slider and the chart in one step.
+  observeEvent(input$temporal_active, {
+    ids <- input$temporal_active %||% character(0)
+    if (length(ids) == 0) return()
+    primary <- ids[1]
+    df <- .APP_CACHE$temporal[[primary]]
+    if (is.null(df) || nrow(df) == 0) return()
+    session$sendCustomMessage("temporal_range", list(
+      min = as.integer(min(df$ym, na.rm = TRUE)),
+      max = as.integer(max(df$ym, na.rm = TRUE))
+    ))
+  }, ignoreInit = TRUE)
+
   # PAM month-window re-aggregation: when the strip range changes and PAM is
   # active, re-query src_pam_ym + push the new fill via the proxy. The current
-  # layer is removed and re-added with the ym-filtered source.
+  # layer is removed and re-added with the ym-filtered source. The observer is
+  # JS-debounced (200ms) so dragging the slider doesn't queue dozens of heavy
+  # re-aggregations. Full-range windows short-circuit -- the unfiltered layer
+  # already on the map IS the answer for the full range, no re-query needed.
   observeEvent(input$temporal_filter, {
     pl <- input$temporal_filter
     if (is.null(pl)) return()
@@ -4485,6 +4571,17 @@ server <- function(input, output, session) {
     if (!("pam-choro" %in% active) || !isTRUE(lazy_added$pam)) return()
     ym_lo <- pl$start %||% TEMPORAL_RANGE[1]
     ym_hi <- pl$end   %||% TEMPORAL_RANGE[2]
+    # Short-circuit: full-range (relative to PAM's actual data span) = no
+    # filtering = leave the unfiltered layer alone. This is what prevents
+    # PAM-on freezing the app: the very first syncTemporalStrip after
+    # lazy_add_fill fires temporal_filter with the default full range, and
+    # without this guard the heavy 2475-row aggregate ran a second time
+    # and triggered a remove+re-add on a layer still being committed to
+    # the MapLibre source.
+    df_pam <- .APP_CACHE$temporal[["pam-choro"]]
+    pam_data_lo <- if (!is.null(df_pam)) min(df_pam$ym) else TEMPORAL_RANGE[1]
+    pam_data_hi <- if (!is.null(df_pam)) max(df_pam$ym) else TEMPORAL_RANGE[2]
+    if (ym_lo <= pam_data_lo && ym_hi >= pam_data_hi) return()
     sf_data <- tryCatch({
       DBI::dbGetQuery(con,
         web_sql("src_pam_ym", ym_lo = ym_lo, ym_hi = ym_hi)) |>