Create app.py

app.py

@@ -0,0 +1,610 @@
+# 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
+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")
+
+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   = "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")
+}
+
+# ─── 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}
+
+wqi_bins   = [0, 20, 35, 50, 70, 100]
+wqi_labels = ["Pobre", "Marginal", "Regular", "Buena", "Excelente"]
+wqi_colors = ["red", "olive", "purple", "green", "blue"]
+
+# 2) Extrae el GeoDataFrame de WQI y conviértelo a numérico
+g_wqi = caps_amb["WQI"].copy()
+g_wqi["wqi_val"] = pd.to_numeric(g_wqi["wqi"], errors="coerce")
+
+# 3) Crea la categoría
+g_wqi["wqi_cat"] = pd.cut(
+    g_wqi["wqi_val"],
+    bins=wqi_bins,
+    labels=wqi_labels,
+    include_lowest=True
+)
+
+# 4) Construye el colormap por pasos
+WQI_COLORMAP = branca.colormap.StepColormap(
+    colors=wqi_colors,
+    index=wqi_bins,
+    vmin=wqi_bins[0],
+    vmax=wqi_bins[-1],
+    caption="WQI"
+)
+
+# 5) Guarda de nuevo en caps_amb
+caps_amb["WQI"] = g_wqi
+# ─── 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 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 ───────────────────────────────────────────
+# ─── 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)
+
+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:
+        # 1) Saltar el heatmap aquí
+        if capa == "Heatmap pacientes":
+            continue
+
+        # 2) WQI: paso discreto + leyenda
+        if capa == "WQI":
+            # Añadir la leyenda de WQI (continua o en pasos, como prefieras)
+            WQI_COLORMAP.add_to(m)
+
+            folium.GeoJson(
+                caps_amb["WQI"],
+                name="WQI (valor y categoría)",
+                style_function=lambda f: {
+                    "color":       WQI_COLORMAP(f["properties"]["wqi_val"]),
+                    "fillColor":   WQI_COLORMAP(f["properties"]["wqi_val"]),
+                    "weight":      3,
+                    "fillOpacity": 0.7
+                },
+                tooltip=folium.GeoJsonTooltip(
+                    fields=["nombre",      # nombre del río
+                            "tramo",       # identificador de tramo
+                            "wqi_val"],    # valor numérico de WQI
+                    aliases=["Río",        # alias para nombre
+                             "Tramo",      # alias para tramo
+                             "WQI (valor)"],  # alias para wqi_val
+                    sticky=True
+                )
+            ).add_to(m)
+            continue    # no volver a procesar esta capa
+
+        # 3) Resto de capas: color continuo con tu choropleth genérico
+        gdf = caps_amb.get(capa)
+        val, uni, cmap, zfield, zalias = META_CAPAS[capa]
+        if gdf is not None and val in gdf.columns:
+            choropleth(
+                m,
+                gdf,
+                val,
+                f"{capa}{' ('+uni+')' if uni else ''}",
+                cmap,
+                zfield,
+                zalias
+            )
+
+    # 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)
+
+    # 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=(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)
+
+    # 5) Capa de clústeres opcional
+    if ver_cluster:
+        capa_clusters(m, d_filt)
+
+    folium.LayerControl(collapsed=False).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 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(d, x=col, color=col, text_auto=True, title=var)
+    fig.update_layout(bargap=0.1)
+    return fig
+
+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.scatter(
+            d,
+            x=cx,
+            y=cy,
+            trendline="ols",
+            labels={cx: x, cy: y},
+            title=f"{x} vs {y}"
+        )
+
+    fig.update_layout(bargap=0.1)
+    return fig
+# ─── 8. Interfaz Gradio ───────────────────────────────────
+def interfaz():
+    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():
+            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"):
+            ui_var = gr.Dropdown(vars_all, label="Variable")
+            btn_uni = gr.Button("Graficar")
+            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"):
+            ui_x  = gr.Dropdown(vars_all, label="Variable X")
+            ui_y  = gr.Dropdown(vars_all, label="Variable Y")
+            btn_bi = gr.Button("Graficar")
+            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()
+
+
+
+if __name__ == "__main__":
+    interfaz()