Update app.py

app.py

@@ -1,277 +1,547 @@
-# app.py
-import gradio as gr
-import pandas as pd
-import numpy as np
-import geopandas as gpd
-import plotly.express as px
-import plotly.graph_objects as go
-import folium
-from folium.plugins import HeatMap
+# app.py  – Explorador geoespacial Vasculitis ANCA (Bogotá)
+# ─────────────────────────────────────────────────────────────
+# • Carga el Excel “Vasculitis…2025‑04‑16_1949 (1).xlsx”.
+# • Normaliza los nombres de columna a snake_case ASCII.
+# • Renombra dinámicamente latitud / longitud.
+# • Deriva:
+#     – edad_cat (quinquenios)
+#     – flags de antecedentes
+#     – patrón de biopsia resumido
+# • Filtros completos por género, edad, localidad, ANCA, MPO, PR3,
+#   antecedentes, patrón de biopsia y compromiso renal.
+# • Mapa Folium con:
+#     – coroplético pacientes / localidad
+#     – capas ambientales (PM10, PM2.5, Ozono, Temp, Precip, Viento, WQI)
+#     – heatmap opcional
+#     – una sola capa de clústeres 1 km con pop‑ups resumidos
+# • Gráficos Univariado y Bivariado que aceptan TODAS las variables
+#   (numéricas → histograma / dispersión; categóricas → barras / box‑plot).
+# • Toda etiqueta de biopsia u antecedente usa la forma corta
+#   (p.ej. “Crescéntica”, “Vasculitis + glom.”, “Hipertensión”, “EPOC”…).
+
+import re, unicodedata, warnings, branca, folium, gradio as gr
+import pandas as pd, geopandas as gpd, numpy as np
 from shapely.geometry import Point
-import warnings
+from folium.plugins import HeatMap
+from sklearn.cluster import DBSCAN
+import plotly.express as px, plotly.graph_objects as go
+import pandas.api.types as ptypes
+import math
+
 warnings.filterwarnings("ignore")
 
-# ======================
-# 1. CARGA DE DATOS
-# ======================
-data = pd.read_excel("Vasculitis_Versión_Excel.xlsx")
-data.columns = data.columns.str.strip().str.lower()
-
-# Coordenadas
-data = data.rename(columns={
-    "coordenada de residencia-latitud": "latitud",
-    "coordenada de residencia-longitud": "longitud"
-})
-
-data = data.dropna(subset=["latitud", "longitud"])
-data["geometry"] = data.apply(lambda row: Point(row["longitud"], row["latitud"]), axis=1)
-data = gpd.GeoDataFrame(data, geometry="geometry", crs="EPSG:4326")
-
-# ======================
-# 2. GEOLOCALIZACIÓN
-# ======================
-geo_localidades = gpd.read_file("loca.json")
-geo_localidades.columns = geo_localidades.columns.str.lower()
-geo_localidades = geo_localidades.rename(columns={"locnombre": "localidad"})
-geo_localidades['localidad'] = geo_localidades['localidad'].str.upper()
-data = gpd.sjoin(data.to_crs(geo_localidades.crs), geo_localidades[['localidad', 'geometry']], how='left', predicate='within')
-data.drop(columns='index_right', inplace=True)
-
-# ======================
-# 3. CAPAS AMBIENTALES
-# ======================
-def cargar_geojson(path):
-    gdf = gpd.read_file(path).to_crs("EPSG:4326")
-    for col in gdf.columns:
-        if pd.api.types.is_datetime64_any_dtype(gdf[col]):
-            gdf[col] = gdf[col].astype(str)
-    return gdf
-
-capas_ambientales = {
-    "PM2.5": cargar_geojson("pm25_prom_anual_2023.geojson"),
-    "Ozono": cargar_geojson("ozono_prom_anual_2022.geojson"),
-    "Temperatura": cargar_geojson("temp_anualprom_2023.geojson"),
-    "Precipitación": cargar_geojson("precip_anualacum_2023.geojson"),
-    "Viento": cargar_geojson("vel_viento_0_23h_anual_2023.geojson"),
-    "Estaciones de calidad del aire": cargar_geojson("estacion_calidad_aire.geojson")
+def snake(cols):
+    out = []
+    for col in cols:
+        txt = unicodedata.normalize("NFKD", col)
+        txt = txt.encode("ascii", "ignore").decode("utf-8")
+        txt = re.sub(r"[^\w]+", "_", txt.strip().lower())
+        out.append(txt.strip("_"))
+    return out
+
+DATA_XLSX   = "/content/VasculitisAsociadasA-Bdd3_DATA_LABELS_2025-04-16_1949 (1).xlsx"
+LOCALIDADES = "loca.json"
+GEO_AMBIENTALES = {
+    "PM10": "pm10_prom_anual.geojson",
+    "PM2.5": "pm25_prom_anual_2023 (2).geojson",
+    "Ozono": "ozono_prom_anual_2022 (2).geojson",
+    "Temperatura": "temp_anualprom_2023 (2).geojson",
+    "Precipitación": "precip_anualacum_2023 (2).geojson",
+    "Viento": "vel_viento_0_23h_anual_2023.geojson",
+    "WQI": "tramo_wqi.geojson",
+    "Heatmap pacientes": None
+}
+META_CAPAS = {
+    "PM10": ("conc_pm10", "µg/m³", branca.colormap.linear.OrRd_09, "id", "Zona"),
+    "PM2.5": ("conc_pm25", "µg/m³", branca.colormap.linear.Reds_09, "id", "Zona"),
+    "Ozono": ("conc_ozono", "ppb", branca.colormap.linear.PuBuGn_09, "id", "Zona"),
+    "Temperatura": ("temperatur", "°C", branca.colormap.linear.YlOrBr_09, "id", "Zona"),
+    "Precipitación": ("precip_per", "mm", branca.colormap.linear.Blues_09, "id", "Zona"),
+    "Viento": ("velocidad", "m/s", branca.colormap.linear.GnBu_09, "id", "Zona"),
+    "WQI": ("wqi", "", branca.colormap.linear.Greens_09, "tramo", "Tramo")
 }
 
-# ======================
-# 4. VARIABLES DERIVADAS
-# ======================
-data["genero_cat"] = data["género"]
-data["edad"] = data["edad en años del paciente"]
-data["estrato_cat"] = data["estrato socioeconómico"]
-data["anca_cat"] = data["ancas"]
-data["mpo_cat"] = data["mpo"]
-data["pr3_cat"] = data["pr3"]
-data["sindrome_renal"] = data["síndrome renal al ingreso"]
-data["manifestaciones_extrarrenales"] = data["manifestaciones extrarenales"]
-data["proteinuria"] = data["proteinuria"]
-data["creatinina"] = data["creatinina"]
-
-# Antecedentes
-antecedentes = {
-    "diabetes": "antecedente personal de diabetes",
-    "falla_cardiaca": "antecedente personal de falla cardíaca",
-    "epoc": "antecedente personal de epoc",
-    "hta": "antecedente personal de hipertensión arterial",
-    "vih": "antecedente personal de vih",
-    "autoinmune": "antecedente personal de otra enfermedad autoinmune",
-    "cáncer": "antecedente personal de cáncer"
+# ─── 1. Pacientes ────────────────────────────────────────
+df = pd.read_excel(DATA_XLSX, dtype=str)
+df.columns = snake(df.columns)
+
+col_lat = next(c for c in df.columns if "residencia" in c and "latitud" in c)
+col_lon = next(c for c in df.columns if "residencia" in c and "longitud" in c)
+df = df.rename(columns={col_lat:"latitud", col_lon:"longitud"})
+df["latitud"]  = pd.to_numeric(df["latitud"].str.replace(",", "."), errors="coerce")
+df["longitud"] = pd.to_numeric(df["longitud"].str.replace(",", "."), errors="coerce")
+df = df.dropna(subset=["latitud","longitud"])
+df["geometry"] = df.apply(lambda r: Point(r["longitud"], r["latitud"]), axis=1)
+df = gpd.GeoDataFrame(df, geometry="geometry", crs="EPSG:4326")
+
+# ─── 2. Localidades ─────────────────────────────────────
+geo_loc = gpd.read_file(LOCALIDADES).to_crs("EPSG:4326")
+geo_loc.columns = snake(geo_loc.columns)
+loc_col = next(c for c in geo_loc.columns if "localidad" in c or "locnombre" in c)
+geo_loc = geo_loc.rename(columns={loc_col:"localidad"})
+geo_loc["localidad"] = geo_loc["localidad"].str.upper()
+df = gpd.sjoin(df, geo_loc[["localidad","geometry"]], how="left", predicate="within") \
+       .drop(columns="index_right")
+
+# ─── 3. Capas ambientales ───────────────────────────────
+def load_gjson(path):
+    g = gpd.read_file(path).to_crs("EPSG:4326")
+    g.columns = snake(g.columns)
+    for c in g.columns:
+        if ptypes.is_datetime64_any_dtype(g[c].dtype):
+            g[c] = g[c].astype(str)
+        elif g[c].dtype == object:
+            txt = g[c].str.strip()
+            if txt.str.match(r"^-?\d+(\.\d+)?$").all():
+                g[c] = txt.astype(float)
+            else:
+                g[c] = txt
+    return g
+
+caps_amb = {k: load_gjson(v) for k,v in GEO_AMBIENTALES.items() if v}
+
+# ─── 4. Derivadas y flags ───────────────────────────────
+df["genero_cat"]  = df.get("genero","").str.capitalize()
+df["estrato_cat"] = df.get("estrato_socioeconomico","").str.capitalize()
+
+df["edad"] = pd.to_numeric(df.get("edad_en_anos_del_paciente","").str.replace(",", "."), errors="coerce")
+bins = list(range(0,105,5))
+labels = [f"{b}-{b+4}" for b in bins[:-1]]
+df["edad_cat"] = pd.cut(df["edad"], bins=bins, labels=labels, right=False)
+
+df["anca_cat"] = df.get("ancas")
+df["mpo_cat"]  = df.get("mpo")
+df["pr3_cat"]  = df.get("pr3")
+
+df["sindrome_renal"]               = df.get("sindrome_renal_al_ingreso","").str.capitalize()
+df["manifestaciones_extrarenales"] = df.get("manifestaciones_extrarenales","").str.capitalize()
+df["proteinuria"]                  = df.get("proteinuria","").str.capitalize()
+df["creatinina"]                   = pd.to_numeric(df.get("creatinina","").str.replace(",", "."), errors="coerce")
+
+ante_cols = {
+    "diabetes":"antecedente_personal_de_diabetes",
+    "falla_cardiaca":"antecedente_personal_de_falla_cardiaca",
+    "epoc":"antecedente_personal_de_epoc",
+    "hipertension":"antecedente_personal_de_hipertension_arterial",
+    "vih":"antecedente_personal_de_vih",
+    "autoinmune":"antecedente_personal_de_otra_enfermedad_autoinmune",
+    "cancer":"antecedente_personal_de_cancer"
+}
+resumen_ante = {
+    "diabetes":"Diabetes",
+    "falla_cardiaca":"Falla cardíaca",
+    "epoc":"EPOC",
+    "hipertension":"Hipertensión",
+    "vih":"VIH",
+    "autoinmune":"Enf. autoinmune",
+    "cancer":"Cáncer"
 }
-for clave, col in antecedentes.items():
-    data[clave] = data[col].map({"Si": 1, "No": 0})
-
-# Hallazgos histológicos
-biopsia_cols = [col for col in data.columns if col.startswith("hallazgos histológicos en biopsia")]
-data["biopsia_positiva"] = data[biopsia_cols].apply(lambda row: "Si" if "Checked" in row.values else "No", axis=1)
-
-data = data.rename(columns={
-    "hallazgos histológicos en biopsia (choice=sin alteraciones)": "Biopsia_SinAlteraciones",
-    "hallazgos histológicos en biopsia (choice=presencia de cualquier número de glomérulos con lesiones necrozantes en cualquier fase de desarrollo sin proliferación extracapilar.)": "Biopsia_NecrosisPura",
-    "hallazgos histológicos en biopsia (choice=presencia de cualquier número de glomérulos con lesiones necrotizantes con proliferación extracapilar en cualquier fase de desarrollo en menos del 50% de los glomérulos (focal).)": "Biopsia_Focal",
-    "hallazgos histológicos en biopsia (choice=presencia de cualquier número de glomérulos con lesiones necrotizantes con proliferación extracapilar en cualquier fase de desarrollo (clase mixta).)": "Biopsia_Mixta",
-    "hallazgos histológicos en biopsia (choice=presencia de glomérulonefritis necrotizante con proliferación extracapilar en cualquier fase de desarrollo en más del 50% de los glomérulos (clase crescéntica).)": "Biopsia_Crescentica",
-    "hallazgos histológicos en biopsia (choice=vasculitis (compromiso de arteriolas o arterias musculares con vasculitis o necrosis fibrinoide) sin compromiso glomerular.)": "Biopsia_VasculitisSinGlom",
-    "hallazgos histológicos en biopsia (choice=vasculitis (compromiso de arteriolas o arterias musculares con vasculitis o necrosis fibrinoide) con compromiso glomerular.)": "Biopsia_VasculitisConGlom",
-    "hallazgos histológicos en biopsia (choice=sin dato)": "Biopsia_SinDato"
-})
-
-
-# Categorías edad (quinquenios)
-bins = list(range(0, 105, 5))
-labels = [f"{i}-{i+4}" for i in bins[:-1]]
-data["edad_cat"] = pd.cut(data["edad en años del paciente"], bins=bins, labels=labels, right=False)
-# ======================
-# 5. FUNCIONES FILTRADO Y VISUALIZACIÓN
-# ======================
-def aplicar_filtros(df, genero, edades, localidades, compromiso_renal, antecedentes_selec):
-    df_filtrado = df.copy()
-    if genero != "Todos":
-        df_filtrado = df_filtrado[df_filtrado["genero_cat"] == genero]
-    if edades:
-        df_filtrado = df_filtrado[df_filtrado["edad_cat"].isin(edades)]
-    if localidades:
-        df_filtrado = df_filtrado[df_filtrado["localidad"].isin(localidades)]
-    if compromiso_renal != "Todos":
-        df_filtrado = df_filtrado[df_filtrado["biopsia_positiva"] == compromiso_renal]
-    for ant in antecedentes_selec:
-        if ant in df_filtrado.columns:
-            df_filtrado = df_filtrado[df_filtrado[ant] == 1]
-    return df_filtrado
-
-# Mapa coroplético
-def generar_mapa_coropletico(df, capas):
-    df_grouped = df.groupby('localidad').size().reset_index(name='casos')
-    geo_local_copy = geo_localidades.merge(df_grouped, on='localidad', how='left').fillna({'casos': 0})
-    m = folium.Map(location=[4.65, -74.1], zoom_start=11)
-    folium.Choropleth(
-        geo_data=geo_local_copy,
-        name='Casos por localidad',
-        data=geo_local_copy,
-        columns=['localidad', 'casos'],
-        key_on='feature.properties.localidad',
-        fill_color='YlOrRd',
-        fill_opacity=0.7,
-        line_opacity=0.3,
-        legend_name='Número de casos'
+for key,col in ante_cols.items():
+    df[key] = (df.get(col,"0").astype(str).str.lower()
+                  .map({"si":1,"sí":1,"checked":1,"1":1})
+                  .fillna(0).astype(int)
+               )
+
+bio_raw = [c for c in df.columns if c.startswith("hallazgos_histologicos_en_biopsia")]
+ren_bio = {c:f"bio_{i}" for i,c in enumerate(bio_raw,1)}
+df = df.rename(columns=ren_bio)
+bio_cols = list(ren_bio.values())
+
+BIO_REGEX = [
+    (r"sin_alteraciones$",  "Sin alteraciones"),
+    (r"sin_proliferacion_extracapilar", "Necrosis sin PC"),
+    (r"menos_del_50.*focal", "Focal"),
+    (r"clase_mixta",         "Mixta"),
+    (r"mas_del_50.*cresc",   "Crescéntica"),
+    (r"sin_compromiso_glomerular$", "Vasculitis sin glom."),
+    (r"con_compromiso_glomerular$", "Vasculitis + glom."),
+    (r"sin_dato$",           "Sin dato")
+]
+# crear un dict raw_col → short
+raw2short = {}
+for patt, short in BIO_REGEX:
+    raw = next(c for c in bio_raw if re.search(patt, c))
+    raw2short[raw] = short
+
+def patron_bio(row):
+    for raw, flag in ren_bio.items():
+        if str(row[flag]).strip().lower() in ("si","sí","checked","1"):
+            return raw2short.get(raw, "Sin dato")
+    return "Sin dato"
+
+df["biopsia_patron"]   = df.apply(patron_bio, axis=1)
+df["biopsia_positiva"] = np.where(df["biopsia_patron"]=="Sin dato","No","Si")
+
+# ─── 5. Filtrado ────────────────────────────────────────
+def filtrar(d, gen, edades, locs, renal, ants, bios, anca, mpo, pr3):
+    d2 = d.copy()
+    if gen!="Todos":      d2 = d2[d2["genero_cat"]==gen]
+    if edades:            d2 = d2[d2["edad_cat"].isin(edades)]
+    if locs:              d2 = d2[d2["localidad"].isin(locs)]
+    if renal!="Todos":    d2 = d2[d2["biopsia_positiva"]==renal]
+    if bios and bios!=["Todos"]:
+        d2 = d2[d2["biopsia_patron"].isin(bios)]
+    if anca!="Todos":     d2 = d2[d2["anca_cat"]==anca]
+    if mpo!="Todos":      d2 = d2[d2["mpo_cat"]==mpo]
+    if pr3!="Todos":      d2 = d2[d2["pr3_cat"]==pr3]
+    for ant in ants:
+        if ant=="Todos": continue
+        key = next(k for k,v in resumen_ante.items() if v==ant)
+        d2 = d2[d2[key]==1]
+    return d2
+
+# ─── 6. Mapas ───────────────────────────────────────────
+def choropleth(m, g, val, title, cmap, zfield, zalias):
+    g = g.copy()
+    g[val] = pd.to_numeric(g[val], errors="coerce")
+    vmin, vmax = g[val].min(), g[val].max()
+    cm = cmap.scale(vmin, vmax)
+    cm.caption = title
+    cm.add_to(m)
+
+    is_line = g.geometry.iloc[0].geom_type.startswith("Line")
+    style = (
+        lambda f,vc=val: {"color":cm(f["properties"][vc]),"weight":4,"opacity":0.9}
+    ) if is_line else (
+        lambda f,vc=val: {"fillColor":cm(f["properties"][vc]),"fillOpacity":0.8,
+                          "color":"black","weight":0.3}
+    )
+
+    fields  = [zfield, val]
+    aliases = [zalias, title]
+    for extra in ("nombre","rio"):
+        if extra in g.columns:
+            fields.append(extra); aliases.append("Río"); break
+
+    folium.GeoJson(
+        g, name=title,
+        style_function=style,
+        highlight_function=lambda f: {"weight":2,"color":"#444","fillOpacity":0.95},
+        tooltip=folium.GeoJsonTooltip(fields=fields, aliases=aliases, sticky=True)
     ).add_to(m)
 
-    for _, row in geo_local_copy.iterrows():
-        folium.Marker(
-            location=row['geometry'].centroid.coords[0][::-1],
-            popup=f"{row['localidad']}: {int(row['casos'])} casos",
-            icon=folium.Icon(color='blue', icon='info-sign')
+def capa_clusters(m, d):
+    """
+    Añade al mapa m una capa de clústeres de pacientes (DBSCAN 1 km),
+    con popups que muestran género, edad (si existe), patrón biopsia y antecedentes.
+    """
+    if d.empty:
+        return
+    coords = np.radians(d[["latitud", "longitud"]].astype(float))
+    if len(coords) < 3:
+        return
+    labels = DBSCAN(eps=1/6371, min_samples=3, metric="haversine").fit_predict(coords)
+    d = d.copy()
+    d["cluster"] = labels
+
+    pal = branca.colormap.linear.Set1_09
+    fg = folium.FeatureGroup(name="Clústeres (1 km)", overlay=True)
+
+    for cl in sorted([c for c in d["cluster"].unique() if c != -1]):
+        color = pal(cl / max(1, d["cluster"].nunique() - 1))
+        for _, r in d[d["cluster"] == cl].iterrows():
+            # Edad segura
+            if pd.notna(r["edad"]) and not math.isnan(r["edad"]):
+                edad_txt = f"{int(r['edad'])} años"
+            else:
+                edad_txt = "Sin dato edad"
+
+            # Antecedentes resumidos
+            ant = [v for k, v in resumen_ante.items() if r.get(k) == 1]
+            ants_txt = "; ".join(ant) if ant else "Ninguno"
+
+            popup = (
+                f"Clúster #{cl}<br>"
+                f"Género: {r['genero_cat']}<br>"
+                f"Edad: {edad_txt}<br>"
+                f"Biopsia: {r['biopsia_patron']}<br>"
+                f"Antecedentes: {ants_txt}"
+            )
+            folium.CircleMarker(
+                location=(r["latitud"], r["longitud"]),
+                radius=6,
+                color=color,
+                fill=True, fill_color=color, fill_opacity=0.9,
+                weight=1,
+                popup=popup
+            ).add_to(fg)
+
+    fg.add_to(m)
+
+
+def crear_mapa(d_filt, capas, ver_cluster):
+    """
+    Construye el mapa completo:
+     - coroplético de pacientes por localidad
+     - capas ambientales
+     - heatmap de puntos
+     - marcadores individuales con popups seguros
+     - clústeres si ver_cluster=True
+    """
+    # 1) Coroplético por localidad
+    g = d_filt.groupby("localidad").size().reset_index(name="pacientes")
+    geo = geo_loc.merge(g, on="localidad", how="left").fillna({"pacientes": 0})
+
+    m = folium.Map(location=[4.65, -74.1], zoom_start=11, tiles="CartoDB positron")
+    choropleth(
+        m, geo, "pacientes", "Pacientes por localidad (N)",
+        branca.colormap.linear.Reds_09, "localidad", "Localidad"
+    )
+
+    # 2) Capas ambientales
+    for capa in capas:
+        if capa == "Heatmap pacientes":
+            continue
+        gdf = caps_amb.get(capa)
+        val, uni, cmap, zf, za = META_CAPAS[capa]
+        if gdf is not None and val in gdf.columns:
+            choropleth(
+                m, gdf, val,
+                f"{capa}{' ('+uni+')' if uni else ''}",
+                cmap, zf, za
+            )
+
+    # 3) Heatmap de puntos
+    if "Heatmap pacientes" in capas and not d_filt.empty:
+        HeatMap(
+            d_filt[["latitud", "longitud"]].astype(float).values,
+            radius=18, name="Heatmap pacientes"
         ).add_to(m)
 
-    for _, row in df.iterrows():
+    # 4) Marcadores individuales
+    fg_pts = folium.FeatureGroup(name="Puntos pacientes", overlay=True)
+    for _, r in d_filt.iterrows():
+        # Edad segura
+        if pd.notna(r["edad"]) and not math.isnan(r["edad"]):
+            edad_txt = f"{int(r['edad'])} años"
+        else:
+            edad_txt = "Sin dato edad"
+
+        # Antecedentes resumidos
+        ant = [v for k, v in resumen_ante.items() if r.get(k) == 1]
+        ants_txt = "<br>".join(ant) if ant else "Ninguno"
+
+        popup_html = (
+            f"Localidad: {r['localidad']}<br>"
+            f"Edad: {edad_txt}<br>"
+            f"Género: {r['genero_cat']}<br>"
+            f"Biopsia: {r['biopsia_patron']}<br>"
+            f"Antecedentes:<br>{ants_txt}"
+        )
         folium.CircleMarker(
-            location=(row['latitud'], row['longitud']),
-            radius=4,
-            popup=f"Edad: {row['edad']}, Género: {row['genero_cat']}, Estrato: {row['estrato_cat']}, Creatinina: {row.get('creatinina', '')}",
-            color='black', fill=True, fill_opacity=0.6
-        ).add_to(m)
+            location=(r["latitud"], r["longitud"]),
+            radius=5,
+            color="#c00",
+            fill=True, fill_color="white",
+            fill_opacity=0.85, weight=1,
+            popup=popup_html
+        ).add_to(fg_pts)
+    fg_pts.add_to(m)
 
-    for capa in capas:
-        if capa in capas_ambientales:
-            gdf = capas_ambientales[capa]
-            folium.GeoJson(gdf, name=capa, tooltip=folium.GeoJsonTooltip(fields=gdf.columns[:2].tolist())).add_to(m)
+    # 5) Capa de clústeres opcional
+    if ver_cluster:
+        capa_clusters(m, d_filt)
 
-    folium.LayerControl().add_to(m)
+    folium.LayerControl(collapsed=False).add_to(m)
     return m._repr_html_()
 
-# Mapa calor
-def generar_mapa_calor(df):
-    m = folium.Map(location=[4.65, -74.1], zoom_start=11)
-    if df.empty:
-        return m._repr_html_()
-    heat_data = df[['latitud', 'longitud']].dropna().values.tolist()
-    HeatMap(heat_data, radius=14).add_to(m)
-    return m._repr_html_()
+# ─── 7. Gráficos ─────────────────────────────────────────
+def col_of(v):
+    """Mapea nombre legible a columna interna."""
+    if v in resumen_ante.values():
+        return next(k for k,val in resumen_ante.items() if val==v)
+    if v in raw2short.values() or v=="Patrón biopsia":
+        return "biopsia_patron"
+    return v
 
-def generar_univariado(var, df):
-    if df.empty: return go.Figure()
-    if df[var].dtype == "object":
-        fig = px.histogram(df, x=var, color=var, text_auto=True)
+def g_uni(var, d):
+    if d.empty:
+        return go.Figure()
+    col = col_of(var)
+    # 1) Flags de antecedentes (0/1) → barras de conteo "No"/"Si"
+    if var in resumen_ante.values():
+        s = d[col].map({0:"No",1:"Si"})
+        fig = px.histogram(s, x=s,
+                           category_orders={col:["No","Si"]},
+                           text_auto=True,
+                           title=var)
+    # 2) Patrón biopsia → barras de conteo de cada categoría
+    elif var=="Patrón biopsia" or var in raw2short.values():
+        fig = px.histogram(d, x="biopsia_patron",
+                           category_orders={"biopsia_patron": list(raw2short.values())},
+                           text_auto=True,
+                           title="Patrón biopsia")
+    # 3) Variables numéricas → histograma
+    elif d[col].dtype.kind in "if":
+        fig = px.histogram(d, x=col, nbins=20, title=var)
+    # 4) Resto categóricas → barras de conteo con color
     else:
-        fig = px.histogram(df, x=var)
-    fig.update_layout(title=f"Distribución de {var}", xaxis_title=var, yaxis_title="Frecuencia")
+        fig = px.histogram(d, x=col, color=col, text_auto=True, title=var)
+    fig.update_layout(bargap=0.1)
     return fig
 
-def generar_bivariado(x, y, df):
-    if x not in df.columns or y not in df.columns:
-        return None
-    if pd.api.types.is_numeric_dtype(df[x]) and pd.api.types.is_numeric_dtype(df[y]):
-        fig = px.scatter(df, x=x, y=y, title=f"{x} vs {y}")
-    elif pd.api.types.is_numeric_dtype(df[x]) or pd.api.types.is_numeric_dtype(df[y]):
-        fig = px.box(df, x=x, y=y, points="all", title=f"{x} vs {y}")
+def g_bi(x, y, d):
+    """
+    Gráfico bivariado:
+     - num vs num   → scatter con trendline
+     - num vs cat   → boxplot
+     - cat vs cat   → barras agrupadas
+    Reconoce correctamente:
+      • Patrones de biopsia (incluida la etiqueta "Patrón biopsia")
+      • Etiquetas de antecedentes.
+    """
+    if d.empty:
+        return go.Figure()
+
+    # Mapeo de la variable de UI al nombre real de columna en df
+    def map_var(v):
+        # Dropdown de patrón de biopsia (UI) → columna biop_patron
+        if v == "Patrón biopsia":
+            return "biopsia_patron"
+        # Cualquier etiqueta corta de biopsia
+        if v in resumen_bio_map.values():
+            return "biopsia_patron"
+        # Etiqueta de antecedente → nombre de flag en df
+        for key, lab in resumen_ante.items():
+            if v == lab:
+                return key
+        # Variables numéricas o de texto sin transformar
+        return v
+
+    cx = map_var(x)
+    cy = map_var(y)
+
+    # Determinar si cada una es categórica (flags, biopsia o texto)
+    is_cat = {}
+    for var in (cx, cy):
+        is_cat[var] = (
+            var == "biopsia_patron"
+            or var in resumen_ante.keys()
+            or d[var].dtype == object
+        )
+
+    # 1) cat vs cat → histograma agrupado
+    if is_cat[cx] and is_cat[cy]:
+        fig = px.histogram(
+            d,
+            x=cx,
+            color=cy,
+            barmode="group",
+            category_orders={
+                cx: list(resumen_bio_map.values()) if cx=="biopsia_patron" else list(resumen_ante.values()),
+                cy: list(resumen_bio_map.values()) if cy=="biopsia_patron" else list(resumen_ante.values()),
+            },
+            labels={cx: x, cy: y},
+            title=f"{x} vs {y}"
+        )
+
+    # 2) num vs cat → boxplot
+    elif is_cat[cx] ^ is_cat[cy]:
+        # uno es categórico, otro numérico
+        if is_cat[cx]:
+            fig = px.box(
+                d,
+                x=cx,
+                y=cy,
+                points="all",
+                category_orders={cx: list(resumen_bio_map.values()) if cx=="biopsia_patron" else list(resumen_ante.values())},
+                labels={cx: x, cy: y},
+                title=f"{x} vs {y}"
+            )
+        else:
+            fig = px.box(
+                d,
+                x=cy,
+                y=cx,
+                points="all",
+                category_orders={cy: list(resumen_bio_map.values()) if cy=="biopsia_patron" else list(resumen_ante.values())},
+                labels={cx: x, cy: y},
+                title=f"{x} vs {y}"
+            )
+
+    # 3) num vs num → scatter + trendline
     else:
-        fig = px.histogram(df, x=x, color=y, barmode="group", title=f"{x} vs {y}")
-    fig.update_layout(height=400)
-    return fig
+        fig = px.scatter(
+            d,
+            x=cx,
+            y=cy,
+            trendline="ols",
+            labels={cx: x, cy: y},
+            title=f"{x} vs {y}"
+        )
 
-# ======================
-# 6. INTERFAZ GRADIO
-# ======================
+    fig.update_layout(bargap=0.1)
+    return fig
+# ─── 8. Interfaz Gradio ───────────────────────────────────
 def interfaz():
-    with gr.Blocks() as demo:
-        gr.Markdown("## Estudio Geoespacial: Vasculitis ANCA")
+    gen   = ["Todos"] + sorted(df["genero_cat"].dropna().unique())
+    ages  = sorted(df["edad_cat"].dropna().unique())
+    locs  = sorted(df["localidad"].dropna().unique())
+    ancas = ["Todos"] + sorted(df["anca_cat"].dropna().unique())
+    mpos  = ["Todos"] + sorted(df["mpo_cat"].dropna().unique())
+    pr3s  = ["Todos"] + sorted(df["pr3_cat"].dropna().unique())
+
+    vars_cat = [
+        "genero_cat","estrato_cat","edad_cat","sindrome_renal",
+        "manifestaciones_extrarenales","proteinuria",
+        "anca_cat","mpo_cat","pr3_cat"
+    ] + ["Patrón biopsia"] + list(resumen_ante.values())
+    vars_num = ["edad","creatinina"]
+    vars_all = vars_cat + vars_num
+
+    with gr.Blocks(title="Vasculitis ANCA Bogotá") as demo:
+        gr.Markdown("## Explorador geoespacial – Vasculitis ANCA (Bogotá)")
 
         with gr.Row():
-            genero = gr.Dropdown(["Todos", "Femenino", "Masculino"], label="Género", value="Todos")
-            edad_cat = gr.CheckboxGroup(label="Rango Etario (Quinquenios)", choices=sorted(data["edad_cat"].dropna().unique().astype(str)))
-
-        localidades = gr.Dropdown(label="Localidades", choices=sorted(data["localidad"].dropna().unique()), multiselect=True)
-        compromiso = gr.Dropdown(["Todos", "Si", "No"], label="Compromiso Renal", value="Todos")
-        antecedentes_ui = gr.CheckboxGroup(label="Antecedentes", choices=list(antecedentes.keys()))
-
-        with gr.Tab("Mapa Coroplético"):
-            capas = gr.CheckboxGroup(label="Capas Ambientales", choices=list(capas_ambientales.keys()))
-            btn = gr.Button("Mostrar")
-            mapa = gr.HTML()
-            btn.click(fn=lambda g, e, l, c, a, cap: generar_mapa_coropletico(aplicar_filtros(data,g, e, l, c, a), cap),
-                        inputs=[genero, edad_cat, localidades, compromiso, antecedentes_ui, capas], outputs=mapa)
-
-        with gr.Tab("Mapa de Calor"):
-            btn2 = gr.Button("Mostrar")
-            salida = gr.HTML()
-            btn2.click(fn=lambda g, e, l, c, a: generar_mapa_calor(aplicar_filtros(data, g, e, l, c, a)),
-                         inputs=[genero, edad_cat, localidades, compromiso, antecedentes_ui], outputs=salida)
+            ui_gen = gr.Dropdown(gen, label="Género", value="Todos")
+            ui_age = gr.CheckboxGroup(ages, label="Edad (quinquenios)")
+        ui_loc   = gr.Dropdown(locs, multiselect=True, label="Localidades")
+        ui_renal = gr.Dropdown(["Todos","Si","No"], value="Todos", label="Compromiso renal")
+        ui_ant   = gr.CheckboxGroup(["Todos"]+list(resumen_ante.values()), label="Antecedentes")
+        ui_bio   = gr.CheckboxGroup(["Todos"]+list(raw2short.values()), label="Patrón biopsia")
+        with gr.Row():
+            ui_anca = gr.Dropdown(ancas, label="ANCA", value="Todos")
+            ui_mpo  = gr.Dropdown(mpos, label="MPO", value="Todos")
+            ui_pr3  = gr.Dropdown(pr3s, label="PR3", value="Todos")
+
+        ui_capas = gr.CheckboxGroup(list(GEO_AMBIENTALES.keys()), label="Capas mapa")
+        ui_clu   = gr.Checkbox(label="Mostrar clústeres (1 km)")
+
+        with gr.Tab("Mapa"):
+            btn_map = gr.Button("Generar mapa")
+            out_map = gr.HTML()
+            btn_map.click(
+                lambda *i: crear_mapa(filtrar(df,*i[:-2]), i[-2], i[-1]),
+                inputs=[ui_gen,ui_age,ui_loc,ui_renal,
+                        ui_ant,ui_bio,ui_anca,ui_mpo,ui_pr3,
+                        ui_capas,ui_clu],
+                outputs=out_map
+            )
 
         with gr.Tab("Univariado"):
-            var_uni = gr.Dropdown(label="Variable", choices=["genero_cat", "estrato_cat", "edad_cat", "proteinuria", "sindrome_renal", "manifestaciones_extrarrenales",
-    "Biopsia_SinAlteraciones",
-    "Biopsia_NecrosisPura",
-    "Biopsia_Focal",
-    "Biopsia_Mixta",
-    "Biopsia_Crescentica",
-    "Biopsia_VasculitisSinGlom",
-    "Biopsia_VasculitisConGlom",
-    "Biopsia_SinDato"
-])
+            ui_var = gr.Dropdown(vars_all, label="Variable")
             btn_uni = gr.Button("Graficar")
-            plot1 = gr.Plot()
-            btn_uni.click(fn=lambda v, g, e, l, c, a: generar_univariado(v, aplicar_filtros(data, g, e, l, c, a)),
-                          inputs=[var_uni, genero, edad_cat, localidades, compromiso, antecedentes_ui],
-                          outputs=plot1)
+            out_uni = gr.Plot()
+            btn_uni.click(
+                lambda v,*i: g_uni(v, filtrar(df,*i)),
+                inputs=[ui_var,ui_gen,ui_age,ui_loc,ui_renal,
+                        ui_ant,ui_bio,ui_anca,ui_mpo,ui_pr3],
+                outputs=out_uni
+            )
 
         with gr.Tab("Bivariado"):
-            var_x = gr.Dropdown(label="Variable X", choices=["genero_cat", "estrato_cat", "edad", "edad_cat", "sindrome_renal", "manifestaciones_extrarrenales", "proteinuria", "mpo_cat", "pr3_cat",
-    "Biopsia_SinAlteraciones",
-    "Biopsia_NecrosisPura",
-    "Biopsia_Focal",
-    "Biopsia_Mixta",
-    "Biopsia_Crescentica",
-    "Biopsia_VasculitisSinGlom",
-    "Biopsia_VasculitisConGlom",
-    "Biopsia_SinDato"
-])
-            var_y = gr.Dropdown(label="Variable Y", choices=["edad_cat","genero_cat", "anca_cat", "biopsia_positiva", "proteinuria", "creatinina", "edad", "sindrome_renal",
-    "Biopsia_SinAlteraciones",
-    "Biopsia_NecrosisPura",
-    "Biopsia_Focal",
-    "Biopsia_Mixta",
-    "Biopsia_Crescentica",
-    "Biopsia_VasculitisSinGlom",
-    "Biopsia_VasculitisConGlom",
-    "Biopsia_SinDato"
-])
+            ui_x  = gr.Dropdown(vars_all, label="Variable X")
+            ui_y  = gr.Dropdown(vars_all, label="Variable Y")
             btn_bi = gr.Button("Graficar")
-            plot2 = gr.Plot()
-            btn_bi.click(fn=lambda x, y, g, e, l, c, a: generar_bivariado(x, y, aplicar_filtros(data, g, e, l, c, a)),
-                         inputs=[var_x, var_y, genero, edad_cat, localidades, compromiso, antecedentes_ui],
-                         outputs=plot2)
-
-        with gr.Tab("Ayuda"):
-            gr.Markdown("""
-            **Instrucciones**  
-            - Selecciona filtros por género, edad, localidad, compromiso renal o antecedentes.  
-            - Visualiza mapas con capas ambientales.  
-            - Explora distribución de variables univariadas y relaciones bivariadas.  
-            - Los hallazgos de biopsia se visualizan como variables categóricas con valores *Checked / Unchecked*.
-            """)
-
-    demo.launch()
-
-interfaz()
+            out_bi = gr.Plot()
+            btn_bi.click(
+                lambda x,y,*i: g_bi(x,y, filtrar(df,*i)),
+                inputs=[ui_x,ui_y,ui_gen,ui_age,ui_loc,ui_renal,
+                        ui_ant,ui_bio,ui_anca,ui_mpo,ui_pr3],
+                outputs=out_bi
+            )
+
+    demo.launch(debug=True)
+
+if __name__ == "__main__":
+    interfaz()