alteracoes generalizadas de mapas e residuos

backend/app/api/elaboracao.py

@@ -36,6 +36,7 @@ class GeocodePayload(SessionPayload):
 
 class CorrecaoGeo(BaseModel):
     linha: int
+    cdlog_corrigido: str | None = None
     numero_corrigido: str | None = None
 
 
@@ -77,7 +78,10 @@ class FitModelPayload(SessionPayload):
 
 
 class DispersaoPayload(SessionPayload):
-    tipo: str
+    eixo_x: str = "transformado"
+    eixo_y_tipo: str = "y_transformado"
+    eixo_y_residuo: str | None = None
+    eixo_y_coluna: str | None = None
 
 
 class TransformPreviewPayload(SessionPayload):
@@ -128,6 +132,7 @@ class ExportModeloPayload(SessionPayload):
 
 class UpdateMapaPayload(SessionPayload):
     variavel_mapa: str | None = None
+    modo_mapa: str | None = None
 
 
 class ColunaDataMercadoPayload(SessionPayload):
@@ -270,7 +275,13 @@ def fit_model(payload: FitModelPayload) -> dict[str, Any]:
 @router.post("/model-dispersao")
 def model_dispersao(payload: DispersaoPayload) -> dict[str, Any]:
     session = session_store.get(payload.session_id)
-    return elaboracao_service.gerar_grafico_dispersao_modelo(session, payload.tipo)
+    return elaboracao_service.gerar_grafico_dispersao_modelo(
+        session,
+        eixo_x=payload.eixo_x,
+        eixo_y_tipo=payload.eixo_y_tipo,
+        eixo_y_residuo=payload.eixo_y_residuo,
+        eixo_y_coluna=payload.eixo_y_coluna,
+    )
 
 
 @router.post("/transform-preview")
@@ -427,7 +438,13 @@ def export_base(session_id: str, filtered: bool = True) -> FileResponse:
 @router.post("/map/update")
 def map_update(payload: UpdateMapaPayload) -> dict[str, Any]:
     session = session_store.get(payload.session_id)
-    return elaboracao_service.atualizar_mapa(session, payload.variavel_mapa)
+    return elaboracao_service.atualizar_mapa(session, payload.variavel_mapa, payload.modo_mapa)
+
+
+@router.post("/residuos/map/update")
+def residuos_map_update(payload: UpdateMapaPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.atualizar_mapa_residuos(session, payload.variavel_mapa, payload.modo_mapa)
 
 
 @router.post("/market-date/preview")

backend/app/core/elaboracao/charts.py

@@ -8,10 +8,13 @@ import pandas as pd
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 from scipy import stats
+from scipy.interpolate import griddata
+from scipy.spatial import ConvexHull, QhullError
 import folium
 from folium import plugins
 import branca.colormap as cm
 from branca.element import Element
+from html import escape
 
 # ============================================================
 # CONSTANTES DE ESTILO
@@ -568,7 +571,272 @@ def criar_painel_diagnostico(resultado_modelo):
 # MAPA FOLIUM
 # ============================================================
 
-def criar_mapa(df, lat_col="lat", lon_col="lon", cor_col=None, indice_destacado=None, tamanho_col=None):
+
+def _contorno_convexo_lng_lat(lons: np.ndarray, lats: np.ndarray) -> np.ndarray | None:
+    pontos = np.column_stack([lons, lats])
+    if pontos.shape[0] < 3:
+        return None
+    pontos_unicos = np.unique(np.round(pontos, 10), axis=0)
+    if pontos_unicos.shape[0] < 3:
+        return None
+    try:
+        hull = ConvexHull(pontos_unicos)
+    except QhullError:
+        return None
+    return pontos_unicos[hull.vertices]
+
+
+def _mascara_dentro_poligono(x_grid: np.ndarray, y_grid: np.ndarray, poligono: np.ndarray | None) -> np.ndarray:
+    if poligono is None or len(poligono) < 3:
+        return np.ones_like(x_grid, dtype=bool)
+
+    xv = poligono[:, 0]
+    yv = poligono[:, 1]
+    inside = np.zeros_like(x_grid, dtype=bool)
+    x_prev = xv[-1]
+    y_prev = yv[-1]
+
+    for x_cur, y_cur in zip(xv, yv):
+        cruzou = ((y_cur > y_grid) != (y_prev > y_grid))
+        x_intersec = (x_prev - x_cur) * (y_grid - y_cur) / ((y_prev - y_cur) + 1e-12) + x_cur
+        inside ^= cruzou & (x_grid < x_intersec)
+        x_prev, y_prev = x_cur, y_cur
+
+    return inside
+
+
+def _normalizar_stops_cor(
+    cor_stops: list[float] | None,
+    colors: list[str],
+    vmin: float,
+    vmax: float,
+) -> list[float] | None:
+    if not isinstance(cor_stops, list) or len(cor_stops) != len(colors):
+        return None
+    try:
+        stops = [float(item) for item in cor_stops]
+    except (TypeError, ValueError):
+        return None
+    if any(not np.isfinite(item) for item in stops):
+        return None
+    if any(stops[i] > stops[i + 1] for i in range(len(stops) - 1)):
+        return None
+    if np.isfinite(vmin) and np.isfinite(vmax) and vmax > vmin:
+        stops = [min(max(item, vmin), vmax) for item in stops]
+        for idx in range(1, len(stops)):
+            if stops[idx] < stops[idx - 1]:
+                stops[idx] = stops[idx - 1]
+        stops[0] = vmin
+        stops[-1] = vmax
+    return stops
+
+
+def _adicionar_legenda_personalizada(
+    m: folium.Map,
+    caption: str,
+    colormap: cm.LinearColormap,
+    tick_values: list[float],
+    tick_labels: list[str],
+) -> None:
+    if len(tick_values) != len(tick_labels) or len(tick_values) == 0:
+        return
+
+    vmin = float(min(tick_values))
+    vmax = float(max(tick_values))
+    if np.isclose(vmin, vmax):
+        vmax = vmin + 1.0
+
+    grad_parts = []
+    for pct in range(0, 101, 2):
+        valor = vmin + (vmax - vmin) * (pct / 100.0)
+        grad_parts.append(f"{colormap(float(valor))} {pct}%")
+    grad_css = ", ".join(grad_parts)
+
+    ticks_html = []
+    for idx, (valor, label) in enumerate(zip(tick_values, tick_labels)):
+        left = (float(valor) - vmin) / (vmax - vmin) * 100.0
+        if idx == 0:
+            transform = "translateX(0)"
+        elif idx == len(tick_values) - 1:
+            transform = "translateX(-100%)"
+        else:
+            transform = "translateX(-50%)"
+        ticks_html.append(
+            f"<div style='position:absolute; left:{left:.4f}%; top:0; transform:{transform}; font-size:10px; "
+            f"line-height:1; color:#2b3a4a; white-space:nowrap;'>{escape(str(label))}</div>"
+        )
+
+    legenda_html = (
+        "<div style='position:fixed; top:14px; right:14px; z-index:9999;"
+        " background:rgba(255,255,255,0.96); border:1px solid #b7c8d8; border-radius:10px;"
+        " box-shadow:0 2px 10px rgba(0,0,0,0.12); padding:8px 10px;'>"
+        "<div style='width:360px; max-width:40vw;'>"
+        "<div style='position:relative; height:12px; margin-bottom:4px;'>"
+        f"{''.join(ticks_html)}"
+        "</div>"
+        f"<div title='{escape(caption)}' style='height:12px; border-radius:6px; border:1px solid #8aa1b6; "
+        f"background:linear-gradient(90deg, {grad_css});'></div>"
+        "</div>"
+        "</div>"
+    )
+    m.get_root().html.add_child(Element(legenda_html))
+
+
+def _adicionar_superficie_continua(
+    m: folium.Map,
+    df_mapa: pd.DataFrame,
+    lat_col: str,
+    lon_col: str,
+    valor_col: str,
+    cor_vmin: float | None = None,
+    cor_vmax: float | None = None,
+    cor_caption: str | None = None,
+    cor_colors: list[str] | None = None,
+    cor_stops: list[float] | None = None,
+    adicionar_legenda: bool = True,
+) -> bool:
+    lats = pd.to_numeric(df_mapa[lat_col], errors="coerce").to_numpy(dtype=float)
+    lons = pd.to_numeric(df_mapa[lon_col], errors="coerce").to_numpy(dtype=float)
+    valores = pd.to_numeric(df_mapa[valor_col], errors="coerce").to_numpy(dtype=float)
+    mask_valid = np.isfinite(lats) & np.isfinite(lons) & np.isfinite(valores)
+
+    if mask_valid.sum() < 6:
+        return False
+
+    lats = lats[mask_valid]
+    lons = lons[mask_valid]
+    valores = valores[mask_valid]
+
+    contorno = _contorno_convexo_lng_lat(lons, lats)
+    if contorno is None:
+        return False
+
+    lon_min = float(np.min(contorno[:, 0]))
+    lon_max = float(np.max(contorno[:, 0]))
+    lat_min = float(np.min(contorno[:, 1]))
+    lat_max = float(np.max(contorno[:, 1]))
+    if np.isclose(lon_min, lon_max) or np.isclose(lat_min, lat_max):
+        return False
+
+    n_obs = len(valores)
+    if n_obs <= 400:
+        n_grid = 46
+    elif n_obs <= 1200:
+        n_grid = 40
+    else:
+        n_grid = 34
+
+    grid_lon = np.linspace(lon_min, lon_max, n_grid)
+    grid_lat = np.linspace(lat_min, lat_max, n_grid)
+    mesh_lon, mesh_lat = np.meshgrid(grid_lon, grid_lat)
+
+    pontos = np.column_stack([lons, lats])
+    try:
+        superficie = griddata(pontos, valores, (mesh_lon, mesh_lat), method="linear")
+    except Exception:
+        return False
+
+    if superficie is None:
+        return False
+
+    superficie = np.asarray(superficie, dtype=float)
+    if np.isnan(superficie).all():
+        try:
+            superficie = griddata(pontos, valores, (mesh_lon, mesh_lat), method="nearest")
+        except Exception:
+            return False
+        if superficie is None:
+            return False
+        superficie = np.asarray(superficie, dtype=float)
+    elif np.isnan(superficie).any():
+        try:
+            nearest = griddata(pontos, valores, (mesh_lon, mesh_lat), method="nearest")
+        except Exception:
+            nearest = None
+        if nearest is not None:
+            nearest = np.asarray(nearest, dtype=float)
+            superficie = np.where(np.isfinite(superficie), superficie, nearest)
+
+    mascara = _mascara_dentro_poligono(mesh_lon, mesh_lat, contorno)
+    superficie = np.where(mascara, superficie, np.nan)
+    if not np.isfinite(superficie).any():
+        return False
+
+    vmin = float(cor_vmin) if cor_vmin is not None and np.isfinite(cor_vmin) else float(np.nanmin(superficie))
+    vmax = float(cor_vmax) if cor_vmax is not None and np.isfinite(cor_vmax) else float(np.nanmax(superficie))
+    if not np.isfinite(vmin) or not np.isfinite(vmax):
+        return False
+    if np.isclose(vmin, vmax):
+        vmax = vmin + 1.0
+
+    colors = cor_colors if isinstance(cor_colors, list) and len(cor_colors) >= 2 else ["#2ecc71", "#a8e06c", "#f1c40f", "#e67e22", "#e74c3c"]
+    color_index = _normalizar_stops_cor(cor_stops, colors, vmin, vmax)
+    caption = str(cor_caption or f"{valor_col} (superfície)")
+    colormap_kwargs = dict(
+        colors=colors,
+        vmin=vmin,
+        vmax=vmax,
+        caption=caption,
+    )
+    if color_index is not None:
+        colormap_kwargs["index"] = color_index
+    colormap = cm.LinearColormap(**colormap_kwargs)
+    if adicionar_legenda:
+        colormap.add_to(m)
+
+    centros_lon = (grid_lon[:-1] + grid_lon[1:]) / 2.0
+    centros_lat = (grid_lat[:-1] + grid_lat[1:]) / 2.0
+    centro_mesh_lon, centro_mesh_lat = np.meshgrid(centros_lon, centros_lat)
+    mascara_centros = _mascara_dentro_poligono(centro_mesh_lon, centro_mesh_lat, contorno)
+
+    valores_celula = (
+        superficie[:-1, :-1]
+        + superficie[1:, :-1]
+        + superficie[:-1, 1:]
+        + superficie[1:, 1:]
+    ) / 4.0
+
+    camada_superficie = folium.FeatureGroup(name="Superfície contínua", show=True)
+    for i in range(valores_celula.shape[0]):
+        for j in range(valores_celula.shape[1]):
+            if not mascara_centros[i, j]:
+                continue
+            valor = valores_celula[i, j]
+            if not np.isfinite(valor):
+                continue
+            cor = colormap(float(valor))
+            valor_fmt = f"{float(valor):.3f}".replace(".", ",")
+            folium.Rectangle(
+                bounds=[
+                    [float(grid_lat[i]), float(grid_lon[j])],
+                    [float(grid_lat[i + 1]), float(grid_lon[j + 1])],
+                ],
+                stroke=False,
+                fill=True,
+                fill_color=cor,
+                fill_opacity=0.6,
+                tooltip=folium.Tooltip(f"Resíduo interpolado: {valor_fmt}", sticky=False),
+            ).add_to(camada_superficie)
+
+    camada_superficie.add_to(m)
+    return True
+
+def criar_mapa(
+    df,
+    lat_col="lat",
+    lon_col="lon",
+    cor_col=None,
+    indice_destacado=None,
+    tamanho_col=None,
+    modo="pontos",
+    cor_vmin: float | None = None,
+    cor_vmax: float | None = None,
+    cor_caption: str | None = None,
+    cor_colors: list[str] | None = None,
+    cor_stops: list[float] | None = None,
+    cor_tick_values: list[float] | None = None,
+    cor_tick_labels: list[str] | None = None,
+):
     """
     Cria mapa Folium com os dados.
 
@@ -579,6 +847,7 @@ def criar_mapa(df, lat_col="lat", lon_col="lon", cor_col=None, indice_destacado=
         cor_col: coluna para colorir os pontos (opcional)
         indice_destacado: índice do ponto a destacar (opcional)
         tamanho_col: coluna numérica para dimensionar os círculos (opcional)
+        modo: "pontos", "calor" (heatmap) ou "superficie" (interpolada)
 
     Retorna:
         HTML do mapa
@@ -639,8 +908,20 @@ def criar_mapa(df, lat_col="lat", lon_col="lon", cor_col=None, indice_destacado=
     )
 
     # Camadas base
-    folium.TileLayer(tiles="OpenStreetMap", name="OpenStreetMap", control=True).add_to(m)
-    folium.TileLayer(tiles="CartoDB positron", name="Positron", control=True).add_to(m)
+    folium.TileLayer(tiles="OpenStreetMap", name="OpenStreetMap", control=True, show=True).add_to(m)
+    folium.TileLayer(tiles="CartoDB positron", name="Positron", control=True, show=False).add_to(m)
+
+    modo_normalizado = str(modo or "pontos").strip().lower()
+    modo_calor = (
+        modo_normalizado == "calor"
+        and tamanho_col is not None
+        and tamanho_col in df_mapa.columns
+    )
+    modo_superficie = (
+        modo_normalizado == "superficie"
+        and tamanho_col is not None
+        and tamanho_col in df_mapa.columns
+    )
 
     # Se tamanho_col fornecido mas cor_col não, usa mesma variável para cor
     if tamanho_col and not cor_col:
@@ -648,16 +929,34 @@ def criar_mapa(df, lat_col="lat", lon_col="lon", cor_col=None, indice_destacado=
 
     # Colormap se houver coluna de cor (verde → vermelho)
     colormap = None
-    if cor_col and cor_col in df_mapa.columns:
-        vmin = df_mapa[cor_col].min()
-        vmax = df_mapa[cor_col].max()
-        colormap = cm.LinearColormap(
-            colors=["#2ecc71", "#a8e06c", "#f1c40f", "#e67e22", "#e74c3c"],
+    colors = cor_colors if isinstance(cor_colors, list) and len(cor_colors) >= 2 else ["#2ecc71", "#a8e06c", "#f1c40f", "#e67e22", "#e74c3c"]
+    usar_legenda_personalizada = (
+        isinstance(cor_tick_values, list)
+        and isinstance(cor_tick_labels, list)
+        and len(cor_tick_values) > 0
+        and len(cor_tick_values) == len(cor_tick_labels)
+    )
+    if not modo_calor and not modo_superficie and cor_col and cor_col in df_mapa.columns:
+        vmin = float(cor_vmin) if cor_vmin is not None and np.isfinite(cor_vmin) else pd.to_numeric(df_mapa[cor_col], errors="coerce").min()
+        vmax = float(cor_vmax) if cor_vmax is not None and np.isfinite(cor_vmax) else pd.to_numeric(df_mapa[cor_col], errors="coerce").max()
+        if not np.isfinite(vmin):
+            vmin = pd.to_numeric(df_mapa[cor_col], errors="coerce").min()
+        if not np.isfinite(vmax):
+            vmax = pd.to_numeric(df_mapa[cor_col], errors="coerce").max()
+        if np.isclose(vmin, vmax):
+            vmax = float(vmin) + 1.0
+        color_index = _normalizar_stops_cor(cor_stops, colors, float(vmin), float(vmax))
+        colormap_kwargs = dict(
+            colors=colors,
             vmin=vmin,
             vmax=vmax,
-            caption=cor_col
+            caption=str(cor_caption or cor_col)
         )
-        colormap.add_to(m)
+        if color_index is not None:
+            colormap_kwargs["index"] = color_index
+        colormap = cm.LinearColormap(**colormap_kwargs)
+        if not usar_legenda_personalizada:
+            colormap.add_to(m)
 
     # Escala de tamanho proporcional
     raio_min, raio_max = 3, 18
@@ -671,82 +970,199 @@ def criar_mapa(df, lat_col="lat", lon_col="lon", cor_col=None, indice_destacado=
             tamanho_func = lambda v: (raio_min + raio_max) / 2
 
     # Camada de índices (oculta por padrão, ativável pelo controle de camadas)
-    mostrar_indices = len(df_mapa) <= 800
+    mostrar_indices = (not modo_calor and not modo_superficie) and len(df_mapa) <= 800
     camada_indices = folium.FeatureGroup(name="Índices", show=False) if mostrar_indices else None
 
-    # Adiciona pontos
-    for idx, row in df_mapa.iterrows():
-        # Cor do ponto
-        if colormap and cor_col:
-            cor = colormap(row[cor_col])
+    if modo_superficie:
+        superficie_ok = _adicionar_superficie_continua(
+            m,
+            df_mapa,
+            lat_real,
+            lon_real,
+            tamanho_col,
+            cor_vmin=cor_vmin,
+            cor_vmax=cor_vmax,
+            cor_caption=cor_caption,
+            cor_colors=cor_colors,
+            cor_stops=cor_stops,
+            adicionar_legenda=not usar_legenda_personalizada,
+        )
+        if not superficie_ok:
+            modo_superficie = False
+            modo_calor = True
+
+    if modo_calor:
+        pesos = pd.to_numeric(df_mapa[tamanho_col], errors="coerce")
+        mask_pesos = np.isfinite(pesos.to_numpy())
+        df_calor = df_mapa.loc[mask_pesos, [lat_real, lon_real]].copy()
+        if not df_calor.empty:
+            pesos_validos = pesos.loc[df_calor.index].to_numpy(dtype=float)
+            fixed_scale = (
+                cor_vmin is not None
+                and cor_vmax is not None
+                and np.isfinite(cor_vmin)
+                and np.isfinite(cor_vmax)
+                and float(cor_vmax) > float(cor_vmin)
+            )
+            if fixed_scale:
+                peso_min = float(cor_vmin)
+                peso_max = float(cor_vmax)
+                pesos_clip = np.clip(pesos_validos, peso_min, peso_max)
+                pesos_norm = (pesos_clip - peso_min) / (peso_max - peso_min)
+            else:
+                peso_min = float(np.min(pesos_validos))
+                peso_max = float(np.max(pesos_validos))
+                if np.isfinite(peso_min) and np.isfinite(peso_max):
+                    if peso_max > peso_min:
+                        pesos_norm = 0.1 + 0.9 * (pesos_validos - peso_min) / (peso_max - peso_min)
+                    else:
+                        pesos_norm = np.ones_like(pesos_validos)
+                else:
+                    pesos_norm = np.ones_like(pesos_validos)
+            heat_data = np.column_stack([
+                df_calor[lat_real].to_numpy(dtype=float),
+                df_calor[lon_real].to_numpy(dtype=float),
+                pesos_norm,
+            ]).tolist()
         else:
-            cor = COR_PRINCIPAL
-
-        # Calcula raio
-        if idx == indice_destacado:
-            raio = raio_max + 4
-        elif tamanho_func:
-            raio = tamanho_func(row[tamanho_col])
+            heat_data = df_mapa[[lat_real, lon_real]].to_numpy(dtype=float).tolist()
+
+        gradient = None
+        if (
+            cor_vmin is not None
+            and cor_vmax is not None
+            and np.isfinite(cor_vmin)
+            and np.isfinite(cor_vmax)
+            and float(cor_vmax) > float(cor_vmin)
+            and len(colors) >= 2
+        ):
+            color_index = _normalizar_stops_cor(cor_stops, colors, float(cor_vmin), float(cor_vmax))
+            if color_index is not None:
+                grad_pairs = []
+                for stop, color in zip(color_index, colors):
+                    ratio = (float(stop) - float(cor_vmin)) / (float(cor_vmax) - float(cor_vmin))
+                    grad_pairs.append((float(np.clip(ratio, 0.0, 1.0)), color))
+                grad_pairs.append((0.0, colors[0]))
+                grad_pairs.append((1.0, colors[-1]))
+                gradient = {}
+                for key, color in sorted(grad_pairs, key=lambda item: item[0]):
+                    gradient[key] = color
+            elif len(colors) == 2:
+                gradient = {0.0: colors[0], 1.0: colors[1]}
+            else:
+                gradient = {i / (len(colors) - 1): colors[i] for i in range(len(colors))}
+        if gradient is None:
+            plugins.HeatMap(
+                heat_data,
+                name="Mapa de calor",
+                radius=20,
+                blur=18,
+                min_opacity=0.28,
+                max_zoom=17,
+            ).add_to(m)
         else:
-            raio = 4
-        peso = 3 if idx == indice_destacado else 1
-
-        # Popup com informações
-        popup_html = f"<b>Índice: {idx}</b><br>"
-        if len(df_mapa) <= 1200:
-            for col in df_mapa.columns:
-                if str(col).lower() not in ['lat', 'latitude', 'lon', 'longitude']:
-                    val = row[col]
-                    if isinstance(val, (int, float)):
-                        popup_html += f"{col}: {val:.2f}<br>"
-                    else:
-                        popup_html += f"{col}: {val}<br>"
-        elif tamanho_col and tamanho_col in df_mapa.columns:
-            val = row[tamanho_col]
-            val_str = f"{val:.2f}" if isinstance(val, (int, float)) else str(val)
-            popup_html += f"{tamanho_col}: {val_str}<br>"
-
-        # Tooltip (hover): índice + variável selecionada no dropdown
-        tooltip_html = (
-            "<div style='font-family:\"Segoe UI\",Arial,sans-serif; font-size:14px;"
-            " line-height:1.7; padding:2px 4px;'>"
-            f"<b>Índice {idx}</b>"
-        )
-        if tamanho_col and tamanho_col in df_mapa.columns:
-            val_t = row[tamanho_col]
-            val_str = f"{val_t:.2f}" if isinstance(val_t, (int, float)) else str(val_t)
-            tooltip_html += (
-                f"<br><span style='color:#555;'>{tamanho_col}:</span>"
-                f" <b>{val_str}</b>"
+            plugins.HeatMap(
+                heat_data,
+                name="Mapa de calor",
+                radius=20,
+                blur=18,
+                min_opacity=0.28,
+                max_zoom=17,
+                gradient=gradient,
+            ).add_to(m)
+    elif not modo_superficie:
+        # Adiciona pontos
+        for idx, row in df_mapa.iterrows():
+            # Cor do ponto
+            if colormap and cor_col:
+                cor = colormap(row[cor_col])
+            else:
+                cor = COR_PRINCIPAL
+
+            # Calcula raio
+            if idx == indice_destacado:
+                raio = raio_max + 4
+            elif tamanho_func:
+                raio = tamanho_func(row[tamanho_col])
+            else:
+                raio = 4
+            peso = 3 if idx == indice_destacado else 1
+
+            # Popup com informações
+            popup_html = f"<b>Índice: {idx}</b><br>"
+            if len(df_mapa) <= 1200:
+                for col in df_mapa.columns:
+                    if str(col).lower() not in ['lat', 'latitude', 'lon', 'longitude']:
+                        val = row[col]
+                        if isinstance(val, (int, float)):
+                            popup_html += f"{col}: {val:.2f}<br>"
+                        else:
+                            popup_html += f"{col}: {val}<br>"
+            elif tamanho_col and tamanho_col in df_mapa.columns:
+                val = row[tamanho_col]
+                val_str = f"{val:.2f}" if isinstance(val, (int, float)) else str(val)
+                popup_html += f"{tamanho_col}: {val_str}<br>"
+
+            # Tooltip (hover): índice + variável selecionada no dropdown
+            tooltip_html = (
+                "<div style='font-family:\"Segoe UI\",Arial,sans-serif; font-size:14px;"
+                " line-height:1.7; padding:2px 4px;'>"
+                f"<b>Índice {idx}</b>"
             )
-        tooltip_html += "</div>"
-
-        folium.CircleMarker(
-            location=[row[lat_real], row[lon_real]],
-            radius=raio,
-            popup=folium.Popup(popup_html, max_width=300),
-            tooltip=folium.Tooltip(tooltip_html, sticky=True),
-            color='black',
-            weight=peso,
-            fill=True,
-            fillColor=cor,
-            fillOpacity=0.8 if idx == indice_destacado else 0.6
-        ).add_to(m)
-
-        # Label com índice (na camada togglável)
-        if mostrar_indices and camada_indices is not None:
-            folium.Marker(
-                location=[row[lat_real], row[lon_real]],
-                icon=folium.DivIcon(
-                    html=f'<div style="font-size:16px; font-weight:bold; color:#333; text-align:center; line-height:{int(raio*2)}px; width:{int(raio*2)}px; margin-left:-{int(raio)}px; margin-top:-{int(raio)}px;">{idx}</div>',
-                    icon_size=(int(raio*2), int(raio*2)),
-                    icon_anchor=(int(raio), int(raio))
+            if tamanho_col and tamanho_col in df_mapa.columns:
+                val_t = row[tamanho_col]
+                val_str = f"{val_t:.2f}" if isinstance(val_t, (int, float)) else str(val_t)
+                tooltip_html += (
+                    f"<br><span style='color:#555;'>{tamanho_col}:</span>"
+                    f" <b>{val_str}</b>"
                 )
-            ).add_to(camada_indices)
+            tooltip_html += "</div>"
+
+            folium.CircleMarker(
+                location=[row[lat_real], row[lon_real]],
+                radius=raio,
+                popup=folium.Popup(popup_html, max_width=300, auto_pan=False),
+                tooltip=folium.Tooltip(tooltip_html, sticky=True),
+                color='black',
+                weight=peso,
+                fill=True,
+                fillColor=cor,
+                fillOpacity=0.8 if idx == indice_destacado else 0.6
+            ).add_to(m)
+
+            # Label com índice (na camada togglável)
+            if mostrar_indices and camada_indices is not None:
+                folium.Marker(
+                    location=[row[lat_real], row[lon_real]],
+                    icon=folium.DivIcon(
+                        html=f'<div style="font-size:16px; font-weight:bold; color:#333; text-align:center; line-height:{int(raio*2)}px; width:{int(raio*2)}px; margin-left:-{int(raio)}px; margin-top:-{int(raio)}px;">{idx}</div>',
+                        icon_size=(int(raio*2), int(raio*2)),
+                        icon_anchor=(int(raio), int(raio))
+                    )
+                ).add_to(camada_indices)
 
     if mostrar_indices and camada_indices is not None:
         camada_indices.add_to(m)
 
+    if usar_legenda_personalizada and cor_col and cor_col in df_mapa.columns:
+        vmin_leg = float(cor_vmin) if cor_vmin is not None and np.isfinite(cor_vmin) else pd.to_numeric(df_mapa[cor_col], errors="coerce").min()
+        vmax_leg = float(cor_vmax) if cor_vmax is not None and np.isfinite(cor_vmax) else pd.to_numeric(df_mapa[cor_col], errors="coerce").max()
+        if np.isclose(vmin_leg, vmax_leg):
+            vmax_leg = float(vmin_leg) + 1.0
+        color_index_leg = _normalizar_stops_cor(cor_stops, colors, float(vmin_leg), float(vmax_leg))
+        legenda_kwargs = dict(
+            colors=colors,
+            vmin=vmin_leg,
+            vmax=vmax_leg,
+            caption=str(cor_caption or cor_col),
+        )
+        if color_index_leg is not None:
+            legenda_kwargs["index"] = color_index_leg
+        colormap_legenda = cm.LinearColormap(**legenda_kwargs)
+        tick_values = [float(v) for v in cor_tick_values]
+        tick_labels = [str(v) for v in cor_tick_labels]
+        _adicionar_legenda_personalizada(m, str(cor_caption or cor_col), colormap_legenda, tick_values, tick_labels)
+
     # Controles
     folium.LayerControl().add_to(m)
     plugins.Fullscreen().add_to(m)

backend/app/core/elaboracao/geocodificacao.py

@@ -227,6 +227,25 @@ def geocodificar(df, col_cdlog, col_num, auto_200=False):
     falhas = []
     ajustados = []
 
+    def _geom_interpolavel(geom) -> bool:
+        if geom is None or not hasattr(geom, "interpolate"):
+            return False
+        try:
+            comprimento = float(geom.length)
+        except Exception:
+            return False
+        return np.isfinite(comprimento) and comprimento > 0
+
+    def _primeira_posicao_com_geom(segmentos_df: pd.DataFrame, posicoes: np.ndarray) -> int | None:
+        for pos in posicoes:
+            try:
+                geom = segmentos_df.iloc[int(pos)].geometry
+            except Exception:
+                continue
+            if _geom_interpolavel(geom):
+                return int(pos)
+        return None
+
     for idx, cdlog, numero_raw in df[["_idx", "__geo_cdlog", "__geo_num"]].itertuples(index=False, name=None):
         numero = int(numero_raw)
         segmentos = segmentos_por_cdlog.get(cdlog)
@@ -270,7 +289,20 @@ def geocodificar(df, col_cdlog, col_num, auto_200=False):
         cond = valid_mask & (ini_vals <= numero) & (fim_vals >= numero)
 
         if cond.any():
-            pos = int(np.flatnonzero(cond)[0])
+            posicoes_cond = np.flatnonzero(cond)
+            pos = _primeira_posicao_com_geom(segmentos, posicoes_cond)
+            if pos is None:
+                lats.append(None)
+                lons.append(None)
+                falhas.append({
+                    "_idx": idx,
+                    "cdlog": cdlog,
+                    "numero_atual": numero,
+                    "motivo": "Segmento sem geometria válida",
+                    "sugestoes": "",
+                    "numero_corrigido": "",
+                })
+                continue
             linha = segmentos.iloc[pos]
             geom = linha.geometry
             ini = ini_vals[pos]
@@ -283,7 +315,7 @@ def geocodificar(df, col_cdlog, col_num, auto_200=False):
 
             frac = (numero - ini) / (fim - ini)
             frac = max(0.0, min(1.0, frac))
-            ponto = geom.interpolate(geom.length * frac)
+            ponto = geom.interpolate(float(geom.length) * frac)
             lons.append(ponto.x)
             lats.append(ponto.y)
             continue
@@ -324,9 +356,26 @@ def geocodificar(df, col_cdlog, col_num, auto_200=False):
         if numero_para_interpolar is not None and min_pos is not None:
             cond2 = valid_mask & (ini_vals <= numero_para_interpolar) & (fim_vals >= numero_para_interpolar)
             if cond2.any():
-                pos2 = int(np.flatnonzero(cond2)[0])
+                pos2 = _primeira_posicao_com_geom(segmentos, np.flatnonzero(cond2))
             else:
-                pos2 = min_pos
+                pos2 = None
+
+            if pos2 is None and min_pos is not None:
+                pos2 = _primeira_posicao_com_geom(segmentos, np.array([min_pos], dtype=int))
+            if pos2 is None:
+                pos2 = _primeira_posicao_com_geom(segmentos, valid_positions)
+            if pos2 is None:
+                lats.append(None)
+                lons.append(None)
+                falhas.append({
+                    "_idx": idx,
+                    "cdlog": cdlog,
+                    "numero_atual": numero,
+                    "motivo": "Segmento sem geometria válida",
+                    "sugestoes": sugestoes_str,
+                    "numero_corrigido": "",
+                })
+                continue
 
             linha = segmentos.iloc[pos2]
             geom = linha.geometry
@@ -339,7 +388,7 @@ def geocodificar(df, col_cdlog, col_num, auto_200=False):
             else:
                 frac = (numero_para_interpolar - ini_v) / (fim_v - ini_v)
                 frac = max(0.0, min(1.0, frac))
-                ponto = geom.interpolate(geom.length * frac)
+                ponto = geom.interpolate(float(geom.length) * frac)
                 lons.append(ponto.x)
                 lats.append(ponto.y)
             continue
@@ -392,12 +441,22 @@ def geocodificar(df, col_cdlog, col_num, auto_200=False):
 
     df = df.drop(columns=["__geo_cdlog", "__geo_num"], errors="ignore")
 
-    df_falhas = pd.DataFrame(
-        falhas,
-        columns=["_idx", "cdlog", "numero_atual", "motivo", "sugestoes", "numero_corrigido"]
-    ) if falhas else pd.DataFrame(
-        columns=["_idx", "cdlog", "numero_atual", "motivo", "sugestoes", "numero_corrigido"]
-    )
+    colunas_falhas = [
+        "_idx",
+        "cdlog",
+        "numero_atual",
+        "motivo",
+        "sugestoes",
+        "cdlog_corrigido",
+        "numero_corrigido",
+    ]
+    df_falhas = pd.DataFrame(falhas, columns=colunas_falhas) if falhas else pd.DataFrame(columns=colunas_falhas)
+    if "cdlog_corrigido" not in df_falhas.columns:
+        df_falhas["cdlog_corrigido"] = ""
+    if "numero_corrigido" not in df_falhas.columns:
+        df_falhas["numero_corrigido"] = ""
+    df_falhas["cdlog_corrigido"] = df_falhas["cdlog_corrigido"].fillna("").astype(str)
+    df_falhas["numero_corrigido"] = df_falhas["numero_corrigido"].fillna("").astype(str)
 
     return df, df_falhas, ajustados
 
@@ -407,7 +466,7 @@ def aplicar_correcoes_e_regeodificar(df_original, df_falhas, col_cdlog, col_num,
 
     Args:
         df_original:  DataFrame acumulado da rodada anterior (com coluna _idx e col_num já corrigido)
-        df_falhas:    DataFrame editável com coluna 'numero_corrigido' preenchida pelo usuário
+        df_falhas:    DataFrame editável com colunas 'cdlog_corrigido' e/ou 'numero_corrigido'
         col_cdlog:    Nome da coluna CDLOG
         col_num:      Nome da coluna número predial
         auto_200:     Repassado para geocodificar()
@@ -423,22 +482,52 @@ def aplicar_correcoes_e_regeodificar(df_original, df_falhas, col_cdlog, col_num,
         df["_idx"] = range(len(df))
 
     # Aplica correções de forma vetorizada por _idx.
-    manuais: list[int] = []
+    manuais_set: set[int] = set()
     if isinstance(df_falhas, pd.DataFrame) and not df_falhas.empty and "_idx" in df_falhas.columns:
-        correcoes = df_falhas.loc[:, ["_idx", "numero_corrigido"]].copy()
-        correcoes["__novo_num"] = pd.to_numeric(correcoes["numero_corrigido"], errors="coerce")
-        correcoes = correcoes.dropna(subset=["_idx", "__novo_num"])
-        if not correcoes.empty:
-            correcoes["__novo_num"] = correcoes["__novo_num"].astype(int)
-            manuais = correcoes["_idx"].tolist()
-
-            mapa = correcoes.drop_duplicates(subset=["_idx"], keep="last").set_index("_idx")["__novo_num"]
-            novos = df["_idx"].map(mapa)
-            mask = novos.notna()
-            if mask.any():
-                df.loc[mask, col_num] = novos[mask].astype(int).to_numpy()
+        if "cdlog_corrigido" in df_falhas.columns:
+            correcoes_cdlog = df_falhas.loc[:, ["_idx", "cdlog_corrigido"]].copy()
+            correcoes_cdlog["__novo_cdlog"] = correcoes_cdlog["cdlog_corrigido"].fillna("").astype(str).str.strip()
+            correcoes_cdlog = correcoes_cdlog[
+                correcoes_cdlog["_idx"].notna() & correcoes_cdlog["__novo_cdlog"].ne("")
+            ].copy()
+            if not correcoes_cdlog.empty:
+                serie_cdlog = obter_serie_coluna(df, col_cdlog)
+                if pd.api.types.is_numeric_dtype(serie_cdlog):
+                    cdlog_num = pd.to_numeric(correcoes_cdlog["__novo_cdlog"], errors="coerce")
+                    correcoes_cdlog = correcoes_cdlog.loc[cdlog_num.notna()].copy()
+                    correcoes_cdlog["__novo_cdlog"] = cdlog_num.loc[cdlog_num.notna()].astype(int).to_numpy()
+
+                if not correcoes_cdlog.empty:
+                    mapa_cdlog = (
+                        correcoes_cdlog
+                        .drop_duplicates(subset=["_idx"], keep="last")
+                        .set_index("_idx")["__novo_cdlog"]
+                    )
+                    novos_cdlog = df["_idx"].map(mapa_cdlog)
+                    mask_cdlog = novos_cdlog.notna()
+                    if mask_cdlog.any():
+                        df.loc[mask_cdlog, col_cdlog] = novos_cdlog[mask_cdlog].to_numpy()
+                        manuais_set.update(int(v) for v in mapa_cdlog.index.tolist())
+
+        if "numero_corrigido" in df_falhas.columns:
+            correcoes_num = df_falhas.loc[:, ["_idx", "numero_corrigido"]].copy()
+            correcoes_num["__novo_num"] = pd.to_numeric(correcoes_num["numero_corrigido"], errors="coerce")
+            correcoes_num = correcoes_num.dropna(subset=["_idx", "__novo_num"])
+            if not correcoes_num.empty:
+                correcoes_num["__novo_num"] = correcoes_num["__novo_num"].astype(int)
+                mapa_num = (
+                    correcoes_num
+                    .drop_duplicates(subset=["_idx"], keep="last")
+                    .set_index("_idx")["__novo_num"]
+                )
+                novos_num = df["_idx"].map(mapa_num)
+                mask_num = novos_num.notna()
+                if mask_num.any():
+                    df.loc[mask_num, col_num] = novos_num[mask_num].astype(int).to_numpy()
+                    manuais_set.update(int(v) for v in mapa_num.index.tolist())
 
     df_resultado, df_falhas_novas, ajustados = geocodificar(df, col_cdlog, col_num, auto_200)
+    manuais = sorted(manuais_set)
     return df_resultado, df_falhas_novas, ajustados, manuais
 
 
@@ -485,7 +574,7 @@ def formatar_status_geocodificacao(df_resultado, df_falhas, ajustados, manuais=N
     if n_falhas > 0:
         linhas.append(
             f'<span style="color:#c0392b">✘ {n_falhas} com falha — '
-            f'preencha "Nº Corrigido" na tabela abaixo e aplique as correções</span>'
+            f'preencha "Código Corrigido" e/ou "Nº Corrigido" na tabela abaixo e aplique as correções</span>'
         )
     else:
         linhas.append('<span style="color:#1a7a1a">Nenhuma falha restante.</span>')
@@ -502,10 +591,10 @@ def preparar_display_falhas(df_falhas):
 
     Retorna:
         html_str:     Tabela HTML legível (read-only) com as falhas
-        df_correcoes: DataFrame com colunas ["Nº Linha", "Nº Corrigido"] para edição pelo usuário
+        df_correcoes: DataFrame com colunas para edição pelo usuário
     """
     if df_falhas is None or df_falhas.empty:
-        return "", pd.DataFrame(columns=["Nº Linha", "Nº Corrigido"])
+        return "", pd.DataFrame(columns=["Nº Linha", "Motivo", "Código Atual", "Código Corrigido", "Nº Corrigido", "Sugestões"])
 
     linhas = [
         '<div style="overflow-x:auto;margin-top:8px">',
@@ -530,9 +619,17 @@ def preparar_display_falhas(df_falhas):
         )
     linhas.append('</tbody></table></div>')
 
+    if "cdlog_corrigido" not in df_falhas.columns:
+        df_falhas["cdlog_corrigido"] = ""
+    if "numero_corrigido" not in df_falhas.columns:
+        df_falhas["numero_corrigido"] = ""
+
     df_correcoes = pd.DataFrame({
         "Nº Linha": df_falhas["_idx"].tolist(),
-        "Nº Corrigido": [""] * len(df_falhas),
+        "Motivo": df_falhas["motivo"].fillna("").astype(str).tolist(),
+        "Código Atual": df_falhas["cdlog"].fillna("").astype(str).tolist(),
+        "Código Corrigido": df_falhas["cdlog_corrigido"].fillna("").astype(str).tolist(),
+        "Nº Corrigido": df_falhas["numero_corrigido"].fillna("").astype(str).tolist(),
         "Sugestões": df_falhas["sugestoes"].fillna("").astype(str).tolist(),
     })
 

backend/app/core/visualizacao/app.py

@@ -739,8 +739,8 @@ def criar_mapa(df, lat_col="lat", lon_col="lon", cor_col=None, tamanho_col=None,
     )
 
     # Camadas base
-    folium.TileLayer(tiles="OpenStreetMap", name="OpenStreetMap", control=True).add_to(m)
-    folium.TileLayer(tiles="CartoDB positron", name="Positron", control=True).add_to(m)
+    folium.TileLayer(tiles="OpenStreetMap", name="OpenStreetMap", control=True, show=True).add_to(m)
+    folium.TileLayer(tiles="CartoDB positron", name="Positron", control=True, show=False).add_to(m)
 
     # Se tamanho_col fornecido mas cor_col não, usa mesma variável para cor
     if tamanho_col and tamanho_col != "Visualização Padrão" and not cor_col:

backend/app/services/elaboracao_service.py

@@ -684,7 +684,7 @@ def load_dai_for_elaboracao(session: SessionState, caminho_arquivo: str) -> dict
         raise HTTPException(status_code=400, detail=msg)
 
     session.elaborador = elaborador
-    session.outliers_anteriores = _clean_int_list(outliers_excluidos)
+    outliers_carregados = _clean_int_list(outliers_excluidos)
     periodo_normalizado = _normalizar_periodo_dados_mercado(periodo_dados_mercado)
 
     base = _set_dataframe_base(session, df, clear_models=True)
@@ -693,6 +693,7 @@ def load_dai_for_elaboracao(session: SessionState, caminho_arquivo: str) -> dict
     session.periodo_dados_mercado_fim = periodo_normalizado["data_final"]
     session.transformacao_y = str(transformacao_y or "(x)")
     session.transformacoes_x = {str(k): str(v) for k, v in (transformacoes_x or {}).items()}
+    session.outliers_anteriores = outliers_carregados
 
     selection_payload = apply_selection(
         session,
@@ -701,7 +702,7 @@ def load_dai_for_elaboracao(session: SessionState, caminho_arquivo: str) -> dict
         dicotomicas=[str(c) for c in (dicotomicas or [])],
         codigo_alocado=[str(c) for c in (codigo_alocado or [])],
         percentuais=[str(c) for c in (percentuais or [])],
-        outliers_anteriores=session.outliers_anteriores,
+        outliers_anteriores=outliers_carregados,
         grau_min_coef=0,
         grau_min_f=0,
     )
@@ -1112,37 +1113,88 @@ def _montar_tabela_outliers_excluidos(session: SessionState) -> dict[str, Any] |
     return dataframe_to_payload(tabela_df, decimals=4)
 
 
-def gerar_grafico_dispersao_modelo(session: SessionState, tipo: str) -> dict[str, Any]:
+def gerar_grafico_dispersao_modelo(
+    session: SessionState,
+    eixo_x: str = "transformado",
+    eixo_y_tipo: str = "y_transformado",
+    eixo_y_residuo: str | None = None,
+    eixo_y_coluna: str | None = None,
+) -> dict[str, Any]:
     if not session.resultado_modelo:
         raise HTTPException(status_code=400, detail="Ajuste um modelo primeiro")
 
+    resultado = session.resultado_modelo or {}
+    x_transformado = resultado.get("X_transformado")
+    y_transformado = resultado.get("y_transformado")
+    tabela_obs_calc = resultado.get("tabela_obs_calc")
+    df_base = session.df_filtrado if session.df_filtrado is not None else session.df_original
+
+    if x_transformado is None or getattr(x_transformado, "empty", True):
+        return {"grafico": None}
+
+    eixo_x_norm = str(eixo_x or "transformado").strip().lower()
+    eixo_y_norm = str(eixo_y_tipo or "y_transformado").strip().lower()
+    eixo_residuo_norm = str(eixo_y_residuo or "residuo_pad").strip().lower()
+
+    indices_modelo = list(x_transformado.index)
+    colunas_x_validas = [col for col in (session.colunas_x or []) if col in x_transformado.columns]
+
+    x_base = x_transformado
+    if eixo_x_norm in {"nao_transformado", "não_transformado"} and df_base is not None:
+        cols_origem = [col for col in (session.colunas_x or []) if col in df_base.columns]
+        if cols_origem:
+            x_base = df_base.reindex(indices_modelo)
+            x_base = x_base.loc[:, cols_origem]
+
     try:
-        if "Nao Transformadas" in tipo or "Não Transformadas" in tipo:
-            tabela = session.resultado_modelo.get("tabela_obs_calc")
-            residuos = tabela["Resíduo Pad."].values if tabela is not None and "Resíduo Pad." in tabela.columns else None
-            indices = list(session.resultado_modelo.get("indices_usados", []) or [])
-            if session.df_filtrado is not None and session.colunas_x:
-                if indices:
-                    x_base = session.df_filtrado.reindex(indices)
+        if eixo_y_norm == "residuo":
+            residuos_map = {
+                "residuo_pad": "Resíduo Pad.",
+                "residuo_stud": "Resíduo Stud.",
+                "cook": "Cook",
+            }
+            col_residuo = residuos_map.get(eixo_residuo_norm, "Resíduo Pad.")
+            residuos = None
+            if tabela_obs_calc is not None and col_residuo in tabela_obs_calc.columns:
+                if "Índice" in tabela_obs_calc.columns:
+                    serie_res = tabela_obs_calc.set_index("Índice")[col_residuo]
+                    residuos = serie_res.reindex(x_base.index).to_numpy()
                 else:
-                    x_base = session.df_filtrado
-                x_base = x_base.loc[:, [c for c in session.colunas_x if c in x_base.columns]]
-            else:
-                x_base = session.resultado_modelo["X_transformado"]
+                    residuos = tabela_obs_calc[col_residuo].to_numpy()
             fig = charts.criar_graficos_dispersao_residuos(x_base, residuos)
-        elif "Residuo" in tipo or "Resíduo" in tipo:
-            tabela = session.resultado_modelo.get("tabela_obs_calc")
-            residuos = tabela["Resíduo Pad."].values if tabela is not None and "Resíduo Pad." in tabela.columns else None
-            fig = charts.criar_graficos_dispersao_residuos(session.resultado_modelo["X_transformado"], residuos)
+        elif eixo_y_norm in {"y_nao_transformado", "y_nao_transf", "y_original"}:
+            y_base = None
+            if df_base is not None and session.coluna_y and session.coluna_y in df_base.columns:
+                y_base = df_base.reindex(x_base.index)[session.coluna_y].copy()
+                y_base.name = f"{session.coluna_y} (não transformado)"
+            elif y_transformado is not None:
+                y_base = y_transformado
+            fig = charts.criar_graficos_dispersao(x_base, y_base)
+        elif eixo_y_norm == "coluna_original":
+            coluna = str(eixo_y_coluna or "").strip()
+            y_base = None
+            if coluna and df_base is not None and coluna in df_base.columns:
+                y_base = df_base.reindex(x_base.index)[coluna].copy()
+                y_base.name = coluna
+            fig = charts.criar_graficos_dispersao(x_base, y_base)
         else:
-            fig = charts.criar_graficos_dispersao(
-                session.resultado_modelo["X_transformado"],
-                session.resultado_modelo["y_transformado"],
-            )
+            y_base = y_transformado
+            if isinstance(y_base, pd.Series):
+                y_base = y_base.copy()
+                nome_y = session.coluna_y or str(y_base.name or "Y")
+                y_base.name = f"{nome_y} (transformado)"
+            fig = charts.criar_graficos_dispersao(x_base, y_base)
     except Exception:
         fig = None
 
-    return {"grafico": figure_to_payload(fig)}
+    return {
+        "grafico": figure_to_payload(fig),
+        "eixo_x_aplicado": "nao_transformado" if eixo_x_norm in {"nao_transformado", "não_transformado"} else "transformado",
+        "eixo_y_tipo_aplicado": eixo_y_norm,
+        "eixo_y_residuo_aplicado": eixo_residuo_norm if eixo_y_norm == "residuo" else None,
+        "eixo_y_coluna_aplicado": str(eixo_y_coluna or "").strip() if eixo_y_norm == "coluna_original" else None,
+        "colunas_x_aplicadas": sanitize_value(list(x_base.columns)) if hasattr(x_base, "columns") else sanitize_value(colunas_x_validas),
+    }
 
 
 def apply_outlier_filters(session: SessionState, filtros: list[dict[str, Any]]) -> dict[str, Any]:
@@ -1720,17 +1772,53 @@ def exportar_equacao(session: SessionState, mode: str) -> tuple[str, str]:
     return caminho, nome
 
 
-def atualizar_mapa(session: SessionState, var_mapa: str | None) -> dict[str, Any]:
+def atualizar_mapa(session: SessionState, var_mapa: str | None, modo_mapa: str | None = None) -> dict[str, Any]:
     df = session.df_filtrado if session.df_filtrado is not None else session.df_original
     if df is None:
         raise HTTPException(status_code=400, detail="Carregue dados primeiro")
 
     tamanho_col = None if not var_mapa or var_mapa == "Visualizacao Padrao" or var_mapa == "Visualização Padrão" else var_mapa
+    modo = str(modo_mapa or "pontos").strip().lower()
+    if tamanho_col is None:
+        modo = "pontos"
     session.mapa_habilitado = True
-    mapa_html = charts.criar_mapa(df, tamanho_col=tamanho_col)
+    mapa_html = charts.criar_mapa(df, tamanho_col=tamanho_col, modo=modo)
     return {"mapa_html": mapa_html}
 
 
+def atualizar_mapa_residuos(session: SessionState, var_mapa: str | None, modo_mapa: str | None = None) -> dict[str, Any]:
+    tabela_metricas = session.tabela_metricas_estado
+    if tabela_metricas is None or tabela_metricas.empty:
+        raise HTTPException(status_code=400, detail="Ajuste o modelo para gerar métricas de resíduos")
+
+    df = tabela_metricas.copy()
+    var_escolhida = "Resíduo Pad."
+    if var_escolhida not in df.columns:
+        raise HTTPException(status_code=400, detail="Coluna 'Resíduo Pad.' não disponível para mapear")
+
+    modo = str(modo_mapa or "pontos").strip().lower()
+    if modo not in {"pontos", "calor", "superficie"}:
+        modo = "pontos"
+
+    mapa_html = charts.criar_mapa(
+        df,
+        tamanho_col=var_escolhida,
+        modo=modo,
+        cor_vmin=-5.0,
+        cor_vmax=5.0,
+        cor_caption="Resíduo Pad. (escala fixa -5 a +5)",
+        cor_colors=["#0b5d1e", "#1f8f3a", "#58b96b", "#f1c40f", "#f1c40f", "#f39c12", "#d04a2f", "#8b0000"],
+        cor_stops=[-5.0, -2.6, -2.0, -1.5, 1.5, 2.0, 2.6, 5.0],
+        cor_tick_values=[-5.0, -4.0, -3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0],
+        cor_tick_labels=["-5", "-4", "-3", "-2", "-1", "0", "1", "2", "3", "4", "5"],
+    )
+    return {
+        "mapa_html": mapa_html,
+        "variavel_mapa": var_escolhida,
+        "modo_mapa": modo,
+    }
+
+
 def mapear_coordenadas_manualmente(session: SessionState, col_lat: str, col_lon: str) -> dict[str, Any]:
     df = session.df_original
     if df is None:
@@ -1901,21 +1989,36 @@ def aplicar_correcoes_geocodificacao(
         raise HTTPException(status_code=400, detail="Contexto de geocodificacao ausente")
 
     df_falhas = session.geo_falhas_df.copy()
-    mapa_correcao = {
+    mapa_correcao_numero = {
         int(item.get("linha")): str(item.get("numero_corrigido", "")).strip()
         for item in correcoes
         if item.get("linha") is not None
     }
+    mapa_correcao_cdlog = {
+        int(item.get("linha")): str(item.get("cdlog_corrigido", "")).strip()
+        for item in correcoes
+        if item.get("linha") is not None
+    }
 
     if "numero_corrigido" not in df_falhas.columns:
         df_falhas["numero_corrigido"] = ""
-    if mapa_correcao:
+    if "cdlog_corrigido" not in df_falhas.columns:
+        df_falhas["cdlog_corrigido"] = ""
+
+    if mapa_correcao_numero:
         linhas_ref = pd.to_numeric(df_falhas["_idx"], errors="coerce")
-        valores_corrigidos = linhas_ref.map(mapa_correcao).fillna("")
+        valores_corrigidos = linhas_ref.map(mapa_correcao_numero).fillna("")
         df_falhas["numero_corrigido"] = valores_corrigidos.astype(str)
     else:
         df_falhas["numero_corrigido"] = ""
 
+    if mapa_correcao_cdlog:
+        linhas_ref = pd.to_numeric(df_falhas["_idx"], errors="coerce")
+        valores_corrigidos = linhas_ref.map(mapa_correcao_cdlog).fillna("")
+        df_falhas["cdlog_corrigido"] = valores_corrigidos.astype(str)
+    else:
+        df_falhas["cdlog_corrigido"] = ""
+
     try:
         df_resultado, df_falhas_novas, ajustados, manuais = geocodificacao.aplicar_correcoes_e_regeodificar(
             session.df_original,

backend/app/services/pesquisa_service.py

@@ -442,8 +442,10 @@ def gerar_mapa_modelos(modelos_ids: list[str], limite_pontos_por_modelo: int = 4
         location=[centro_lat, centro_lon],
         zoom_start=12,
         control_scale=True,
-        tiles="CartoDB positron",
+        tiles=None,
     )
+    folium.TileLayer(tiles="OpenStreetMap", name="OpenStreetMap", control=True, show=True).add_to(mapa)
+    folium.TileLayer(tiles="CartoDB positron", name="Positron", control=True, show=False).add_to(mapa)
 
     total_pontos = 0
     for modelo in modelos_plotados:

frontend/src/api.js

@@ -155,7 +155,10 @@ export const api = {
     return postJson('/api/elaboracao/fit-model', payload)
   },
 
-  updateModelDispersao: (sessionId, tipo) => postJson('/api/elaboracao/model-dispersao', { session_id: sessionId, tipo }),
+  updateModelDispersao: (sessionId, payload) => postJson('/api/elaboracao/model-dispersao', {
+    session_id: sessionId,
+    ...(payload || {}),
+  }),
   previewTransformElab: (sessionId, transformacaoY, transformacoesX) => postJson('/api/elaboracao/transform-preview', {
     session_id: sessionId,
     transformacao_y: transformacaoY,
@@ -207,7 +210,16 @@ export const api = {
     return response.blob()
   },
   exportBase: (sessionId, filtered = true) => getBlob(`/api/elaboracao/export-base?session_id=${encodeURIComponent(sessionId)}&filtered=${String(filtered)}`),
-  updateElaboracaoMap: (sessionId, variavelMapa) => postJson('/api/elaboracao/map/update', { session_id: sessionId, variavel_mapa: variavelMapa }),
+  updateElaboracaoMap: (sessionId, variavelMapa, modoMapa = 'pontos') => postJson('/api/elaboracao/map/update', {
+    session_id: sessionId,
+    variavel_mapa: variavelMapa,
+    modo_mapa: modoMapa,
+  }),
+  updateElaboracaoResiduosMap: (sessionId, variavelMapa, modoMapa = 'pontos') => postJson('/api/elaboracao/residuos/map/update', {
+    session_id: sessionId,
+    variavel_mapa: variavelMapa,
+    modo_mapa: modoMapa,
+  }),
   previewMarketDateColumn: (sessionId, colunaData) => postJson('/api/elaboracao/market-date/preview', { session_id: sessionId, coluna_data: colunaData }),
   applyMarketDateColumn: (sessionId, colunaData) => postJson('/api/elaboracao/market-date/apply', { session_id: sessionId, coluna_data: colunaData }),
   getContext: (sessionId) => getJson(`/api/elaboracao/context?session_id=${encodeURIComponent(sessionId)}`),

frontend/src/components/ElaboracaoTab.jsx

@@ -27,6 +27,11 @@ const GRAU_LABEL_CURTO = {
   2: 'Grau II',
   3: 'Grau III',
 }
+const MAPA_VARIAVEL_PADRAO = 'Visualização Padrão'
+const MAPA_MODO_PONTOS = 'pontos'
+const MAPA_MODO_CALOR = 'calor'
+const MAPA_MODO_SUPERFICIE = 'superficie'
+const MAPA_RESIDUOS_VARIAVEL = 'Resíduo Pad.'
 const OUTLIER_RECURSIVO_TOOLTIP = 'Aplicar com recursividade executa os mesmos filtros em ciclos sucessivos: nos bastidores, simula a exclusão dos índices encontrados, recalcula o ajuste do modelo e as métricas de outlier e reaplica os filtros, repetindo até não surgir nenhum índice novo. Para você, o resultado prático é que o campo "A excluir" é preenchido automaticamente com o conjunto total de índices encontrados nessa simulação recursiva.'
 
 function grauBadgeClass(value) {
@@ -552,7 +557,11 @@ function buildArquivoCarregadoInfo(resp, options = {}) {
   const extMatch = fileName.match(/\.([^.]+)$/)
   const tipoArquivo = extMatch?.[1] ? String(extMatch[1]).toUpperCase() : '-'
   const sheetName = String(options.sheetName || resp?.sheet_selected || '').trim()
-  const totalLinhas = Array.isArray(resp?.dados?.rows) ? resp.dados.rows.length : null
+  const totalLinhas = Number.isFinite(Number(resp?.dados?.total_rows))
+    ? Number(resp.dados.total_rows)
+    : Array.isArray(resp?.dados?.rows)
+      ? resp.dados.rows.length
+      : null
   const totalColunas = Array.isArray(resp?.dados?.columns) ? resp.dados.columns.length : null
   const totalAbas = Array.isArray(resp?.sheets) ? resp.sheets.length : 0
 
@@ -628,8 +637,12 @@ export default function ElaboracaoTab({ sessionId }) {
 
   const [dados, setDados] = useState(null)
   const [mapaHtml, setMapaHtml] = useState('')
-  const [mapaVariavel, setMapaVariavel] = useState('Visualização Padrão')
+  const [mapaVariavel, setMapaVariavel] = useState(MAPA_VARIAVEL_PADRAO)
+  const [mapaModo, setMapaModo] = useState(MAPA_MODO_PONTOS)
   const [mapaGerado, setMapaGerado] = useState(false)
+  const [mapaResiduosHtml, setMapaResiduosHtml] = useState('')
+  const [mapaResiduosModo, setMapaResiduosModo] = useState(MAPA_MODO_PONTOS)
+  const [mapaResiduosGerado, setMapaResiduosGerado] = useState(false)
 
   const [coordsInfo, setCoordsInfo] = useState(null)
   const [manualLat, setManualLat] = useState('')
@@ -678,7 +691,10 @@ export default function ElaboracaoTab({ sessionId }) {
   const [section6EditOpen, setSection6EditOpen] = useState(true)
 
   const [fit, setFit] = useState(null)
-  const [tipoDispersao, setTipoDispersao] = useState('Variáveis Independentes Transformadas X Variável Dependente Transformada')
+  const [dispersaoEixoX, setDispersaoEixoX] = useState('transformado')
+  const [dispersaoEixoYTipo, setDispersaoEixoYTipo] = useState('y_transformado')
+  const [dispersaoEixoYResiduo, setDispersaoEixoYResiduo] = useState('residuo_pad')
+  const [dispersaoEixoYColuna, setDispersaoEixoYColuna] = useState('')
 
   const [filtros, setFiltros] = useState(defaultFiltros())
   const [outliersTexto, setOutliersTexto] = useState('')
@@ -713,7 +729,8 @@ export default function ElaboracaoTab({ sessionId }) {
   const [disabledHint, setDisabledHint] = useState(null)
   const [sectionsMountKey, setSectionsMountKey] = useState(0)
 
-  const mapaChoices = useMemo(() => ['Visualização Padrão', ...colunasNumericas], [colunasNumericas])
+  const mapaChoices = useMemo(() => [MAPA_VARIAVEL_PADRAO, ...colunasNumericas], [colunasNumericas])
+  const mapaModoDisponivel = mapaVariavel !== MAPA_VARIAVEL_PADRAO
   const colunasXDisponiveis = useMemo(
     () => (colunaY ? colunasNumericas.filter((coluna) => coluna !== colunaY) : []),
     [colunasNumericas, colunaY],
@@ -919,15 +936,37 @@ export default function ElaboracaoTab({ sessionId }) {
     () => Math.max(1, Math.min(3, graficosSecao9.length || 1)),
     [graficosSecao9.length],
   )
+  const colunasOriginaisDispersao = useMemo(() => {
+    const cols = Array.isArray(dados?.columns) ? dados.columns : []
+    return cols
+      .map((item) => String(item || '').trim())
+      .filter((item) => item && item !== '_index')
+  }, [dados])
+  const colunaYComRotulo = useMemo(
+    () => (colunaY ? `${colunaY} (Y)` : 'Y'),
+    [colunaY],
+  )
+  const yLabelSecao13 = useMemo(() => {
+    if (dispersaoEixoYTipo === 'residuo') {
+      if (dispersaoEixoYResiduo === 'residuo_stud') return 'Resíduo Studentizado'
+      if (dispersaoEixoYResiduo === 'cook') return 'Distância de Cook'
+      return 'Resíduo Padronizado'
+    }
+    if (dispersaoEixoYTipo === 'y_nao_transformado') {
+      return `${colunaYComRotulo} não transformado`
+    }
+    if (dispersaoEixoYTipo === 'coluna_original') {
+      return dispersaoEixoYColuna || 'Outra coluna'
+    }
+    return `${colunaYComRotulo} transformado`
+  }, [dispersaoEixoYTipo, dispersaoEixoYResiduo, dispersaoEixoYColuna, colunaYComRotulo])
   const graficosSecao12 = useMemo(
     () => buildScatterPanels(fit?.grafico_dispersao_modelo, {
       singleLabel: 'Dispersão do modelo',
       height: 360,
-      yLabel: tipoDispersao.includes('Resíduo')
-        ? 'Resíduo Padronizado'
-        : `${colunaY || 'Y'} (transformada)`,
+      yLabel: yLabelSecao13,
     }),
-    [fit?.grafico_dispersao_modelo, tipoDispersao, colunaY],
+    [fit?.grafico_dispersao_modelo, yLabelSecao13],
   )
   const colunasGraficosSecao12 = useMemo(
     () => Math.max(1, Math.min(3, graficosSecao12.length || 1)),
@@ -1029,6 +1068,22 @@ export default function ElaboracaoTab({ sessionId }) {
     }
   }, [algumaXMarcada, todasXMarcadas])
 
+  useEffect(() => {
+    if (mapaChoices.includes(mapaVariavel)) return
+    setMapaVariavel(MAPA_VARIAVEL_PADRAO)
+    setMapaModo(MAPA_MODO_PONTOS)
+  }, [mapaChoices, mapaVariavel])
+
+  useEffect(() => {
+    if (colunasOriginaisDispersao.length === 0) {
+      if (dispersaoEixoYColuna) setDispersaoEixoYColuna('')
+      return
+    }
+    if (!dispersaoEixoYColuna || !colunasOriginaisDispersao.includes(dispersaoEixoYColuna)) {
+      setDispersaoEixoYColuna(colunasOriginaisDispersao[0])
+    }
+  }, [colunasOriginaisDispersao, dispersaoEixoYColuna])
+
   useEffect(() => {
     if (!sessionId || tipoFonteDados === 'dai') return undefined
 
@@ -1168,11 +1223,20 @@ export default function ElaboracaoTab({ sessionId }) {
     if (!table?.rows) return []
     return table.rows.map((row) => {
       const linha = row['Nº Linha'] ?? row['No Linha'] ?? row['linha'] ?? row['_index']
+      const motivo = String(row['Motivo'] ?? row['motivo'] ?? '').trim()
+      const motivoNormalizado = motivo
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
       const sugestoes = parseSugestoes(row['Sugestões'] ?? row['Sugestoes'] ?? row['sugestoes'] ?? '')
       const sugestaoProxima = sugestoes[0] || ''
       return {
         linha: Number(linha),
+        motivo,
+        cdlog_atual: String(row['Código Atual'] ?? row['Codigo Atual'] ?? row['CDLOG'] ?? row['cdlog'] ?? '').trim(),
+        cdlog_corrigido: String(row['Código Corrigido'] ?? row['Codigo Corrigido'] ?? row['cdlog_corrigido'] ?? '').trim(),
         numero_corrigido: row['Nº Corrigido'] ?? row['No Corrigido'] ?? '',
+        exige_cdlog: motivoNormalizado.includes('cdlog'),
         sugestoes,
         sugestao_proxima: sugestaoProxima,
       }
@@ -1371,6 +1435,12 @@ export default function ElaboracaoTab({ sessionId }) {
 
   function applyFitResponse(resp, origemMeta = null) {
     setFit(resp)
+    setDispersaoEixoX('transformado')
+    setDispersaoEixoYTipo('y_transformado')
+    setDispersaoEixoYResiduo('residuo_pad')
+    setMapaResiduosModo(MAPA_MODO_PONTOS)
+    setMapaResiduosHtml('')
+    setMapaResiduosGerado(false)
     const transformacaoYAplicada = resp.transformacao_y || transformacaoY
     const transformacoesXAplicadas = resp.transformacoes_x || transformacoesX
     if (resp.transformacao_y) {
@@ -1496,6 +1566,11 @@ export default function ElaboracaoTab({ sessionId }) {
     await withBusy(async () => {
       setMapaGerado(false)
       setMapaHtml('')
+      setMapaVariavel(MAPA_VARIAVEL_PADRAO)
+      setMapaModo(MAPA_MODO_PONTOS)
+      setMapaResiduosGerado(false)
+      setMapaResiduosHtml('')
+      setMapaResiduosModo(MAPA_MODO_PONTOS)
       setGeoAuto200(true)
       setSelectedSheet('')
       setRequiresSheet(false)
@@ -1521,6 +1596,11 @@ export default function ElaboracaoTab({ sessionId }) {
     await withBusy(async () => {
       setMapaGerado(false)
       setMapaHtml('')
+      setMapaVariavel(MAPA_VARIAVEL_PADRAO)
+      setMapaModo(MAPA_MODO_PONTOS)
+      setMapaResiduosGerado(false)
+      setMapaResiduosHtml('')
+      setMapaResiduosModo(MAPA_MODO_PONTOS)
       setGeoAuto200(true)
       setSelectedSheet('')
       setRequiresSheet(false)
@@ -1575,6 +1655,11 @@ export default function ElaboracaoTab({ sessionId }) {
     await withBusy(async () => {
       setMapaGerado(false)
       setMapaHtml('')
+      setMapaVariavel(MAPA_VARIAVEL_PADRAO)
+      setMapaModo(MAPA_MODO_PONTOS)
+      setMapaResiduosGerado(false)
+      setMapaResiduosHtml('')
+      setMapaResiduosModo(MAPA_MODO_PONTOS)
       setGeoAuto200(true)
       const resp = await api.confirmSheet(sessionId, selectedSheet)
       setTipoFonteDados('tabular')
@@ -1800,7 +1885,7 @@ export default function ElaboracaoTab({ sessionId }) {
   }
 
   function onLimparCorrecoesGeo() {
-    setGeoCorrecoes((prev) => prev.map((item) => ({ ...item, numero_corrigido: '' })))
+    setGeoCorrecoes((prev) => prev.map((item) => ({ ...item, cdlog_corrigido: '', numero_corrigido: '' })))
   }
 
   async function onApplySelection() {
@@ -1888,11 +1973,25 @@ export default function ElaboracaoTab({ sessionId }) {
     })
   }
 
-  async function onTipoDispersaoChange(nextTipo) {
-    setTipoDispersao(nextTipo)
+  async function onDispersaoConfigChange(nextConfig) {
+    const eixoX = String(nextConfig?.eixoX || dispersaoEixoX || 'transformado')
+    const eixoYTipo = String(nextConfig?.eixoYTipo || dispersaoEixoYTipo || 'y_transformado')
+    const eixoYResiduo = String(nextConfig?.eixoYResiduo || dispersaoEixoYResiduo || 'residuo_pad')
+    const eixoYColuna = String(nextConfig?.eixoYColuna || dispersaoEixoYColuna || '')
+
+    setDispersaoEixoX(eixoX)
+    setDispersaoEixoYTipo(eixoYTipo)
+    setDispersaoEixoYResiduo(eixoYResiduo)
+    setDispersaoEixoYColuna(eixoYColuna)
+
     if (!sessionId) return
     await withBusy(async () => {
-      const resp = await api.updateModelDispersao(sessionId, nextTipo)
+      const resp = await api.updateModelDispersao(sessionId, {
+        eixo_x: eixoX,
+        eixo_y_tipo: eixoYTipo,
+        eixo_y_residuo: eixoYTipo === 'residuo' ? eixoYResiduo : null,
+        eixo_y_coluna: eixoYTipo === 'coluna_original' ? eixoYColuna : null,
+      })
       setFit((prev) => ({ ...prev, grafico_dispersao_modelo: resp.grafico }))
     })
   }
@@ -2191,22 +2290,57 @@ export default function ElaboracaoTab({ sessionId }) {
 
   async function onMapVarChange(value) {
     setMapaVariavel(value)
+    const nextModo = value === MAPA_VARIAVEL_PADRAO ? MAPA_MODO_PONTOS : mapaModo
+    if (nextModo !== mapaModo) {
+      setMapaModo(nextModo)
+    }
     if (!sessionId || !mapaGerado) return
     await withBusy(async () => {
-      const resp = await api.updateElaboracaoMap(sessionId, value)
+      const resp = await api.updateElaboracaoMap(sessionId, value, nextModo)
+      setMapaHtml(resp.mapa_html || '')
+    })
+  }
+
+  async function onMapModeChange(value) {
+    setMapaModo(value)
+    if (!sessionId || !mapaGerado) return
+    await withBusy(async () => {
+      const resp = await api.updateElaboracaoMap(sessionId, mapaVariavel, value)
       setMapaHtml(resp.mapa_html || '')
     })
   }
 
   async function onGerarMapa() {
     if (!sessionId) return
+    const modoAtual = mapaVariavel === MAPA_VARIAVEL_PADRAO ? MAPA_MODO_PONTOS : mapaModo
+    if (modoAtual !== mapaModo) {
+      setMapaModo(modoAtual)
+    }
     await withBusy(async () => {
-      const resp = await api.updateElaboracaoMap(sessionId, mapaVariavel)
+      const resp = await api.updateElaboracaoMap(sessionId, mapaVariavel, modoAtual)
       setMapaHtml(resp.mapa_html || '')
       setMapaGerado(true)
     })
   }
 
+  async function onMapaResiduosModoChange(value) {
+    setMapaResiduosModo(value)
+    if (!sessionId || !mapaResiduosGerado) return
+    await withBusy(async () => {
+      const resp = await api.updateElaboracaoResiduosMap(sessionId, MAPA_RESIDUOS_VARIAVEL, value)
+      setMapaResiduosHtml(resp.mapa_html || '')
+    })
+  }
+
+  async function onGerarMapaResiduos() {
+    if (!sessionId) return
+    await withBusy(async () => {
+      const resp = await api.updateElaboracaoResiduosMap(sessionId, MAPA_RESIDUOS_VARIAVEL, mapaResiduosModo)
+      setMapaResiduosHtml(resp.mapa_html || '')
+      setMapaResiduosGerado(true)
+    })
+  }
+
   function onDownloadTableCsv(table, fileNameBase) {
     const blob = tableToCsvBlob(table)
     if (!blob) {
@@ -2251,6 +2385,15 @@ export default function ElaboracaoTab({ sessionId }) {
     downloadBlob(blob, 'secao3_mapa_dados_mercado.html')
   }
 
+  function onDownloadMapaSecao16() {
+    if (!mapaResiduosHtml) {
+      setError('Mapa de resíduos padronizados indisponível para download.')
+      return
+    }
+    const blob = new Blob([mapaResiduosHtml], { type: 'text/html;charset=utf-8;' })
+    downloadBlob(blob, 'secao16_mapa_residuos.html')
+  }
+
   async function exportFigureAsPng(figure, fileNameBase, options = {}) {
     const payload = buildFigureForExport(figure, Boolean(options.forceHideLegend))
     if (!payload) {
@@ -2780,6 +2923,26 @@ export default function ElaboracaoTab({ sessionId }) {
                             {geoCorrecoes.map((item, idx) => (
                               <div className="geo-correcao-item" key={`cor-${item.linha}-${idx}`}>
                                 <span className="geo-correcao-linha">Linha {item.linha}</span>
+                                {item.motivo ? (
+                                  <div className="geo-correcao-motivo">{item.motivo}</div>
+                                ) : null}
+                                {item.exige_cdlog ? (
+                                  <>
+                                    {item.cdlog_atual ? (
+                                      <div className="geo-correcao-atual">Código atual: {item.cdlog_atual}</div>
+                                    ) : null}
+                                    <input
+                                      type="text"
+                                      value={item.cdlog_corrigido || ''}
+                                      onChange={(e) => {
+                                        const next = [...geoCorrecoes]
+                                        next[idx] = { ...next[idx], cdlog_corrigido: e.target.value }
+                                        setGeoCorrecoes(next)
+                                      }}
+                                      placeholder="Código corrigido (CDLOG/CTM)"
+                                    />
+                                  </>
+                                ) : null}
                                 <input
                                   type="text"
                                   value={item.numero_corrigido || ''}
@@ -2877,13 +3040,25 @@ export default function ElaboracaoTab({ sessionId }) {
               ) : (
                 <details className="dados-mapa-details" open>
                   <summary>Mapa</summary>
-                  <div className="row compact dados-mapa-controls">
-                    <label>Variável no mapa</label>
-                    <select value={mapaVariavel} onChange={(e) => onMapVarChange(e.target.value)}>
-                      {mapaChoices.map((choice) => (
-                        <option key={choice} value={choice}>{choice}</option>
-                      ))}
-                    </select>
+                  <div className="dados-mapa-controls">
+                    <div className="dados-mapa-control-field">
+                      <label>Variável no mapa</label>
+                      <select value={mapaVariavel} onChange={(e) => onMapVarChange(e.target.value)}>
+                        {mapaChoices.map((choice) => (
+                          <option key={choice} value={choice}>{choice}</option>
+                        ))}
+                      </select>
+                    </div>
+                    {mapaModoDisponivel ? (
+                      <div className="dados-mapa-control-field">
+                        <label>Visualização</label>
+                        <select value={mapaModo} onChange={(e) => onMapModeChange(e.target.value)}>
+                          <option value={MAPA_MODO_PONTOS}>Pontos</option>
+                          <option value={MAPA_MODO_CALOR}>Mapa de calor</option>
+                          <option value={MAPA_MODO_SUPERFICIE}>Superfície contínua</option>
+                        </select>
+                      </div>
+                    ) : null}
                   </div>
                   <div className="download-actions-bar">
                     <button
@@ -3421,14 +3596,76 @@ export default function ElaboracaoTab({ sessionId }) {
 
       {fit ? (
         <>
-          <SectionBlock step="13" title="Gráficos de Dispersão (Variáveis Transformadas)" subtitle="Dispersão com variáveis já transformadas.">
-            <div className="row">
-              <label>Tipo de dispersão</label>
-              <select value={tipoDispersao} onChange={(e) => onTipoDispersaoChange(e.target.value)}>
-                <option value="Variáveis Independentes Transformadas X Variável Dependente Transformada">X transformado x Y transformado</option>
-                <option value="Variáveis Independentes Transformadas X Resíduo Padronizado">X transformado x Resíduo</option>
-                <option value="Variáveis Independentes Não Transformadas X Resíduo Padronizado">X não transformado x Resíduo</option>
-              </select>
+          <SectionBlock step="13" title="Visualizar Mapa dos Dados de Mercado" subtitle="Escolha livre dos eixos para análise gráfica do modelo.">
+            <div className="row dispersao-config-row">
+              <div className="dispersao-config-field">
+                <label>Eixo X</label>
+                <select
+                  value={dispersaoEixoX}
+                  onChange={(e) => {
+                    void onDispersaoConfigChange({ eixoX: e.target.value })
+                  }}
+                  disabled={loading}
+                >
+                  <option value="transformado">X transformado</option>
+                  <option value="nao_transformado">X não transformado</option>
+                </select>
+              </div>
+              <div className="dispersao-config-field">
+                <label>Eixo Y</label>
+                <select
+                  value={dispersaoEixoYTipo}
+                  onChange={(e) => {
+                    const nextTipo = e.target.value
+                    const nextColuna = nextTipo === 'coluna_original'
+                      ? (dispersaoEixoYColuna || colunasOriginaisDispersao[0] || '')
+                      : dispersaoEixoYColuna
+                    void onDispersaoConfigChange({ eixoYTipo: nextTipo, eixoYColuna: nextColuna })
+                  }}
+                  disabled={loading}
+                >
+                  <option value="y_transformado">{`${colunaYComRotulo} transformado`}</option>
+                  <option value="y_nao_transformado">{`${colunaYComRotulo} não transformado`}</option>
+                  <option value="residuo">Resíduo</option>
+                  <option value="coluna_original">Outra coluna</option>
+                </select>
+              </div>
+              {dispersaoEixoYTipo === 'residuo' ? (
+                <div className="dispersao-config-field">
+                  <label>Tipo de resíduo</label>
+                  <select
+                    value={dispersaoEixoYResiduo}
+                    onChange={(e) => {
+                      void onDispersaoConfigChange({ eixoYResiduo: e.target.value })
+                    }}
+                    disabled={loading}
+                  >
+                    <option value="residuo_pad">Resíduo Padronizado</option>
+                    <option value="residuo_stud">Resíduo Studentizado</option>
+                    <option value="cook">Resíduo de Cook</option>
+                  </select>
+                </div>
+              ) : null}
+              {dispersaoEixoYTipo === 'coluna_original' ? (
+                <div className="dispersao-config-field dispersao-config-field-wide">
+                  <label>Coluna de Y (dados originais)</label>
+                  <select
+                    value={dispersaoEixoYColuna}
+                    onChange={(e) => {
+                      void onDispersaoConfigChange({ eixoYColuna: e.target.value })
+                    }}
+                    disabled={loading || colunasOriginaisDispersao.length === 0}
+                  >
+                    {colunasOriginaisDispersao.length === 0 ? (
+                      <option value="">Sem colunas disponíveis</option>
+                    ) : (
+                      colunasOriginaisDispersao.map((col) => (
+                        <option key={`eixo-y-col-${col}`} value={col}>{col}</option>
+                      ))
+                    )}
+                  </select>
+                </div>
+              ) : null}
             </div>
             <div className="download-actions-bar">
               {graficosSecao12.length > 1 ? <span className="download-actions-label">Fazer download:</span> : null}
@@ -3604,7 +3841,44 @@ export default function ElaboracaoTab({ sessionId }) {
             </div>
           </SectionBlock>
 
-          <SectionBlock step="16" title="Analisar Outliers" subtitle="Métricas para identificação de observações influentes.">
+          <SectionBlock step="16" title="Analisar Resíduos" subtitle="Métricas para identificação de observações influentes.">
+            <details className="dados-mapa-details">
+              <summary>Mapa de resíduos padronizados</summary>
+              {!mapaResiduosGerado ? (
+                <div className="empty-box">
+                  <div className="row">
+                    <button type="button" className="btn-gerar-mapa" onClick={onGerarMapaResiduos} disabled={loading}>
+                      Gerar Mapa de Resíduos Padronizados
+                    </button>
+                  </div>
+                  <div className="section1-empty-hint">O mapa de resíduos padronizados será carregado somente após solicitação explícita.</div>
+                </div>
+              ) : (
+                <>
+                  <div className="dados-mapa-controls">
+                    <div className="dados-mapa-control-field">
+                      <label>Visualização</label>
+                      <select value={mapaResiduosModo} onChange={(e) => onMapaResiduosModoChange(e.target.value)}>
+                        <option value={MAPA_MODO_PONTOS}>Pontos</option>
+                        <option value={MAPA_MODO_CALOR}>Mapa de calor</option>
+                        <option value={MAPA_MODO_SUPERFICIE}>Superfície contínua</option>
+                      </select>
+                    </div>
+                  </div>
+                  <div className="download-actions-bar">
+                    <button
+                      type="button"
+                      className="btn-download-subtle"
+                      onClick={onDownloadMapaSecao16}
+                      disabled={loading || downloadingAssets || !mapaResiduosHtml}
+                    >
+                      Fazer download
+                    </button>
+                  </div>
+                  <MapFrame html={mapaResiduosHtml} />
+                </>
+              )}
+            </details>
             <div className="download-actions-bar">
               <button
                 type="button"

frontend/src/styles.css

@@ -761,16 +761,25 @@ textarea {
 
 .dados-mapa-controls {
   display: flex;
-  align-items: center;
+  align-items: flex-end;
   flex-wrap: wrap;
-  column-gap: 14px;
-  row-gap: 8px;
+  column-gap: 16px;
+  row-gap: 12px;
   margin-bottom: 18px;
 }
 
-.dados-mapa-controls label {
-  margin-right: 0;
-  min-width: 118px;
+.dados-mapa-control-field {
+  display: grid;
+  gap: 6px;
+  min-width: 220px;
+}
+
+.dados-mapa-control-field label {
+  margin: 0;
+}
+
+.dados-mapa-control-field select {
+  width: 100%;
 }
 
 .dados-mapa-controls + .map-frame,
@@ -778,6 +787,33 @@ textarea {
   margin-top: 6px;
 }
 
+.dispersao-config-row {
+  align-items: flex-end;
+  gap: 14px;
+}
+
+.dispersao-config-field {
+  display: grid;
+  gap: 6px;
+  min-width: 240px;
+  max-width: 360px;
+  flex: 1 1 240px;
+}
+
+.dispersao-config-field.dispersao-config-field-wide {
+  min-width: 320px;
+  max-width: 520px;
+  flex: 2 1 320px;
+}
+
+.dispersao-config-field label {
+  margin: 0;
+}
+
+.dispersao-config-field select {
+  width: 100%;
+}
+
 .visualizacao-mapa-controls {
   margin-bottom: 28px;
 }
@@ -3357,6 +3393,18 @@ button.btn-download-subtle {
   color: #46617a;
 }
 
+.geo-correcao-motivo {
+  color: #6a7f94;
+  font-size: 0.76rem;
+  line-height: 1.25;
+}
+
+.geo-correcao-atual {
+  color: #4d6379;
+  font-size: 0.76rem;
+  font-weight: 700;
+}
+
 .geo-correcao-sugestoes {
   color: #607990;
   font-size: 0.78rem;