alteracoes generalizadas

backend/app/api/elaboracao.py

@@ -36,6 +36,11 @@ class MapCoordsPayload(SessionPayload):
     col_lon: str
 
 
+class MapaPopupPayload(SessionPayload):
+    row_id: int
+    source: str | None = None
+
+
 class GeocodePayload(SessionPayload):
     col_cdlog: str
     col_num: str
@@ -562,6 +567,12 @@ def map_update(payload: UpdateMapaPayload) -> dict[str, Any]:
     return elaboracao_service.atualizar_mapa(session, payload.variavel_mapa, payload.modo_mapa)
 
 
+@router.post("/map/popup")
+def map_popup(payload: MapaPopupPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.carregar_popup_ponto_mapa(session, payload.row_id, payload.source)
+
+
 @router.post("/residuos/map/update")
 def residuos_map_update(payload: UpdateMapaPayload) -> dict[str, Any]:
     session = session_store.get(payload.session_id)

backend/app/api/pesquisa.py

@@ -55,6 +55,7 @@ class MapaModelosPayload(BaseModel):
     avaliando_lon: Any = None
     avaliandos: list[AvaliandoGeoPayload] | None = None
     modo_exibicao: Any = "pontos"
+    agrupar_pontos_mercado: Any = False
     criterio_espacial: Any = None
     trabalhos_tecnicos_modelos_modo: Any = None
     trabalhos_tecnicos_proximidade_modo: Any = None
@@ -217,6 +218,7 @@ def pesquisar_mapa_modelos(payload: MapaModelosPayload) -> dict:
         avaliando_lon=payload.avaliando_lon,
         avaliandos=[item.model_dump() for item in (payload.avaliandos or [])],
         modo_exibicao=payload.modo_exibicao,
+        agrupar_pontos_mercado=payload.agrupar_pontos_mercado,
         criterio_espacial=payload.criterio_espacial,
         trabalhos_tecnicos_modelos_modo=modelos_modo,
         trabalhos_tecnicos_proximidade_modo=proximidade_modo,

backend/app/core/elaboracao/charts.py

@@ -17,6 +17,7 @@ import branca.colormap as cm
 from branca.element import Element
 from html import escape
 from typing import Any
+from app.core.map_jitter import aplicar_jitter_dados_mercado as _aplicar_jitter_sobrepostos
 from app.core.map_layers import (
     add_bairros_layer,
     add_indice_marker,
@@ -622,72 +623,6 @@ def _mascara_dentro_poligono(x_grid: np.ndarray, y_grid: np.ndarray, poligono: n
     return inside
 
 
-def _aplicar_jitter_sobrepostos(
-    df_mapa: pd.DataFrame,
-    lat_col: str,
-    lon_col: str,
-    lat_plot_col: str,
-    lon_plot_col: str,
-) -> pd.DataFrame:
-    """
-    Aplica jitter visual apenas em pontos com coordenadas idênticas.
-    Mantém as coordenadas originais intactas para cálculos e filtros.
-    """
-    df_plot = df_mapa.copy()
-    df_plot[lat_plot_col] = pd.to_numeric(df_plot[lat_col], errors="coerce")
-    df_plot[lon_plot_col] = pd.to_numeric(df_plot[lon_col], errors="coerce")
-
-    if len(df_plot) <= 1:
-        return df_plot
-
-    chave_lat = df_plot[lat_col].round(7)
-    chave_lon = df_plot[lon_col].round(7)
-    grupos = df_plot.groupby([chave_lat, chave_lon], sort=False)
-
-    passo_metros = 4.0
-    max_raio_metros = 22.0
-    metros_por_grau_lat = 111_320.0
-
-    lat_plot_pos = int(df_plot.columns.get_loc(lat_plot_col))
-    lon_plot_pos = int(df_plot.columns.get_loc(lon_plot_col))
-
-    for _, idx_labels in grupos.indices.items():
-        posicoes = np.asarray(idx_labels, dtype=int)
-        if posicoes.size <= 1:
-            continue
-        base_lat = float(df_plot.iat[int(posicoes[0]), lat_plot_pos])
-        base_lon = float(df_plot.iat[int(posicoes[0]), lon_plot_pos])
-        if not np.isfinite(base_lat) or not np.isfinite(base_lon):
-            continue
-
-        seed_val = int((abs(base_lat) * 1_000_000.0) + (abs(base_lon) * 1_000_000.0) * 3.0) % 360
-        angulo_base = math.radians(seed_val)
-        cos_lat = max(abs(math.cos(math.radians(base_lat))), 1e-6)
-        metros_por_grau_lon = metros_por_grau_lat * cos_lat
-
-        for pos, pos_idx in enumerate(posicoes):
-            if pos == 0:
-                continue
-
-            pos_ring = pos - 1
-            ring = 1
-            while pos_ring >= (6 * ring):
-                pos_ring -= 6 * ring
-                ring += 1
-
-            slots_ring = max(6 * ring, 1)
-            angulo = angulo_base + (2.0 * math.pi * (pos_ring / slots_ring))
-            raio_m = min(ring * passo_metros, max_raio_metros)
-
-            delta_lat = (raio_m * math.sin(angulo)) / metros_por_grau_lat
-            delta_lon = (raio_m * math.cos(angulo)) / metros_por_grau_lon
-
-            df_plot.iat[int(pos_idx), lat_plot_pos] = base_lat + delta_lat
-            df_plot.iat[int(pos_idx), lon_plot_pos] = base_lon + delta_lon
-
-    return df_plot
-
-
 def _montar_popup_registro_em_colunas(
     idx: Any,
     row: pd.Series,
@@ -1100,8 +1035,8 @@ def criar_mapa(
     )
 
     # Camadas base
-    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)
+    folium.TileLayer(tiles="CartoDB positron", name="Positron", control=True, show=True).add_to(m)
+    folium.TileLayer(tiles="OpenStreetMap", name="OpenStreetMap", control=True, show=False).add_to(m)
     add_bairros_layer(m, show=True)
 
     modo_normalizado = str(modo or "pontos").strip().lower()

backend/app/core/elaboracao/formatadores.py

@@ -7,6 +7,7 @@ Sem dependência de Gradio.
 """
 
 import os
+import re
 from html import escape
 import numpy as np
 import pandas as pd
@@ -23,11 +24,44 @@ TITULO = """
 ---
 """
 
+CURVA_NORMAL_PERCENTUAL_FAIXAS = (
+    (64, 75),
+    (88, 95),
+    (95, 100),
+)
+
 
 # ============================================================
 # FUNÇÕES DE FORMATAÇÃO
 # ============================================================
 
+def _formatar_percentuais_curva_normal_html(perc_resid):
+    texto = str(perc_resid or "").strip()
+    if not texto:
+        return "-"
+
+    partes = [parte.strip() for parte in texto.split(",") if parte.strip()]
+    if not partes:
+        return escape(texto)
+
+    formatados = []
+    for idx, parte in enumerate(partes):
+        parte_html = escape(parte)
+        faixa = CURVA_NORMAL_PERCENTUAL_FAIXAS[idx] if idx < len(CURVA_NORMAL_PERCENTUAL_FAIXAS) else None
+        match = re.search(r"-?\d+(?:[.,]\d+)?", parte)
+        valor = None
+        if match:
+            try:
+                valor = float(match.group(0).replace(",", "."))
+            except Exception:
+                valor = None
+        fora_da_faixa = faixa is not None and valor is not None and (valor < faixa[0] or valor > faixa[1])
+        if fora_da_faixa:
+            parte_html = f'<span style="color:#b42318;font-weight:800;">{parte_html}</span>'
+        formatados.append(parte_html)
+
+    return ", ".join(formatados)
+
 def arredondar_df(df, decimais=4):
     """Arredonda apenas colunas numéricas de um DataFrame e adiciona coluna Índice."""
     if df is None:
@@ -143,7 +177,8 @@ def formatar_diagnosticos_html(diagnosticos):
 
     # Teste de Normalidade (Curva Normal)
     html += '<div class="section-title-orange">Teste de Normalidade (Comparação com a Curva Normal)</div>'
-    html += f'''<div class="field-row"><span class="field-row-label">Percentuais Atingidos</span><span class="field-row-value">{diagnosticos["perc_resid"]}</span></div>'''
+    perc_resid_html = _formatar_percentuais_curva_normal_html(diagnosticos.get("perc_resid"))
+    html += f'''<div class="field-row"><span class="field-row-label">Percentuais Atingidos</span><span class="field-row-value">{perc_resid_html}</span></div>'''
     html += '<div class="interpretation-label">Interpretação</div>'
     html += '<div class="interpretation-item">• Ideal 68% → aceitável entre 64% e 75%</div>'
     html += '<div class="interpretation-item">• Ideal 90% → aceitável entre 88% e 95%</div>'

backend/app/core/map_jitter.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import math
+
+import numpy as np
+import pandas as pd
+
+
+JITTER_MERCADO_PASSO_METROS = 5.0
+JITTER_MERCADO_MAX_RAIO_METROS = 28.0
+
+
+def aplicar_jitter_dados_mercado(
+    df_mapa: pd.DataFrame,
+    lat_col: str,
+    lon_col: str,
+    lat_plot_col: str = "__mesa_lat_plot__",
+    lon_plot_col: str = "__mesa_lon_plot__",
+    *,
+    precisao: int = 7,
+    passo_metros: float = JITTER_MERCADO_PASSO_METROS,
+    max_raio_metros: float = JITTER_MERCADO_MAX_RAIO_METROS,
+) -> pd.DataFrame:
+    """
+    Aplica jitter visual determinístico apenas em pontos de mercado sobrepostos.
+
+    As coordenadas originais permanecem nas colunas de entrada; as coordenadas
+    deslocadas são gravadas em lat_plot_col/lon_plot_col.
+    """
+    df_plot = df_mapa.copy()
+    df_plot[lat_plot_col] = pd.to_numeric(df_plot[lat_col], errors="coerce")
+    df_plot[lon_plot_col] = pd.to_numeric(df_plot[lon_col], errors="coerce")
+
+    if len(df_plot) <= 1:
+        return df_plot
+
+    chave_lat = df_plot[lat_col].round(precisao)
+    chave_lon = df_plot[lon_col].round(precisao)
+    grupos = df_plot.groupby([chave_lat, chave_lon], sort=False)
+
+    metros_por_grau_lat = 111_320.0
+    lat_plot_pos = int(df_plot.columns.get_loc(lat_plot_col))
+    lon_plot_pos = int(df_plot.columns.get_loc(lon_plot_col))
+
+    for _, idx_labels in grupos.indices.items():
+        posicoes = np.asarray(idx_labels, dtype=int)
+        if posicoes.size <= 1:
+            continue
+
+        base_lat = float(df_plot.iat[int(posicoes[0]), lat_plot_pos])
+        base_lon = float(df_plot.iat[int(posicoes[0]), lon_plot_pos])
+        if not np.isfinite(base_lat) or not np.isfinite(base_lon):
+            continue
+
+        seed_val = int((abs(base_lat) * 1_000_000.0) + (abs(base_lon) * 1_000_000.0) * 3.0) % 360
+        angulo_base = math.radians(seed_val)
+        cos_lat = max(abs(math.cos(math.radians(base_lat))), 1e-6)
+        metros_por_grau_lon = metros_por_grau_lat * cos_lat
+
+        for pos, pos_idx in enumerate(posicoes):
+            if pos == 0:
+                continue
+
+            pos_ring = pos - 1
+            ring = 1
+            while pos_ring >= (6 * ring):
+                pos_ring -= 6 * ring
+                ring += 1
+
+            slots_ring = max(6 * ring, 1)
+            angulo = angulo_base + (2.0 * math.pi * (pos_ring / slots_ring))
+            raio_m = min(ring * passo_metros, max_raio_metros)
+            delta_lat = (raio_m * math.sin(angulo)) / metros_por_grau_lat
+            delta_lon = (raio_m * math.cos(angulo)) / metros_por_grau_lon
+
+            df_plot.iat[int(pos_idx), lat_plot_pos] = base_lat + delta_lat
+            df_plot.iat[int(pos_idx), lon_plot_pos] = base_lon + delta_lon
+
+    return df_plot

backend/app/core/map_layers.py

@@ -292,6 +292,201 @@ def apply_marker_payload_jitter(
     return payloads
 
 
+def _marker_payload_coord_key(item: dict[str, Any], lat_key: str = "lat", lon_key: str = "lon") -> tuple[float, float] | None:
+    try:
+        lat = float(item.get(lat_key))
+        lon = float(item.get(lon_key))
+    except Exception:
+        return None
+    if not math.isfinite(lat) or not math.isfinite(lon):
+        return None
+    return (round(lat, 7), round(lon, 7))
+
+
+def _dedupe_ordered(values: list[Any]) -> list[str]:
+    resultado: list[str] = []
+    vistos: set[str] = set()
+    for value in values:
+        texto = str(value or "").strip()
+        if not texto or texto in vistos:
+            continue
+        vistos.add(texto)
+        resultado.append(texto)
+    return resultado
+
+
+def _trabalho_tecnico_group_sort_key(item: dict[str, Any]) -> tuple[str, str, str]:
+    return (
+        str(item.get("trabalho_nome") or "").strip().casefold(),
+        str(item.get("endereco_texto") or "").strip().casefold(),
+        str(item.get("trabalho_id") or "").strip().casefold(),
+    )
+
+
+def _trabalho_tecnico_group_marker_html(total: int, marker_style: str) -> str:
+    total_label = "99+" if total > 99 else str(total)
+    return (
+        "<div style='display:flex;align-items:center;justify-content:center;"
+        "width:24px;height:24px;box-sizing:border-box;border-radius:999px;"
+        "background:#c62828;border:2px solid #ffffff;color:#fff;"
+        "box-shadow:0 0 0 1px rgba(22,38,52,0.22),0 4px 12px rgba(21,35,50,0.28);"
+        "font-family:\"Segoe UI\",Arial,sans-serif;font-size:11px;font-weight:800;line-height:1;'>"
+        "<span style='display:block;min-width:14px;padding:1px 2px;text-align:center;"
+        "pointer-events:none;text-shadow:0 1px 2px rgba(0,0,0,0.45);'>"
+        f"{escape(total_label)}"
+        "</span></div>"
+    )
+
+
+def _trabalho_tecnico_single_marker_html() -> str:
+    return (
+        "<div style='display:flex;align-items:center;justify-content:center;"
+        "width:14px;height:14px;box-sizing:border-box;border-radius:999px;background:#c62828;"
+        "border:2px solid #ffffff;box-shadow:0 0 0 1px rgba(22,38,52,0.22),0 3px 9px rgba(21,35,50,0.24);'>"
+        "</div>"
+    )
+
+
+def _trabalho_tecnico_link_html(item: dict[str, Any]) -> str:
+    trabalho_id = str(item.get("trabalho_id") or "").strip()
+    trabalho_nome = str(item.get("trabalho_nome") or trabalho_id or "Trabalho tecnico").strip()
+    origem = str(item.get("origem") or "pesquisa_mapa").strip() or "pesquisa_mapa"
+    if not trabalho_id:
+        return f"<span style='font-weight:700; color:#7d5a00;'>{escape(trabalho_nome)}</span>"
+    payload_json = json.dumps(
+        {"type": "mesa:open-trabalho-tecnico", "trabalhoId": trabalho_id, "origem": origem},
+        ensure_ascii=True,
+    )
+    return (
+        "<a href='#' "
+        "style='color:#7d5a00;text-decoration:underline;font-weight:700;' "
+        f"onclick='try{{(window.parent || window).postMessage({payload_json}, \"*\");}}catch(_error){{}} return false;'>"
+        f"{escape(trabalho_nome)}"
+        "</a>"
+    )
+
+
+def _trabalho_tecnico_group_tooltip_html(itens: list[dict[str, Any]]) -> str:
+    total = len(itens)
+    preview = itens[:8]
+    linhas = []
+    for item in preview:
+        nome = str(item.get("trabalho_nome") or item.get("trabalho_id") or "Trabalho tecnico").strip()
+        endereco = str(item.get("endereco_texto") or "").strip()
+        linhas.append(
+            "<li style='margin:2px 0;'>"
+            f"<strong>{escape(nome)}</strong>"
+            + (f"<br><span style='color:#666;'>{escape(endereco)}</span>" if endereco else "")
+            + "</li>"
+        )
+    restante = total - len(preview)
+    if restante > 0:
+        linhas.append(f"<li style='margin:2px 0;color:#666;'>+ {restante} trabalho(s)</li>")
+    return (
+        "<div style='font-family:\"Segoe UI\",Arial,sans-serif; font-size:13px; line-height:1.45; min-width:260px;'>"
+        f"<div style='margin-bottom:6px;'><b>{total} trabalhos técnicos neste local</b></div>"
+        "<ul style='margin:0;padding-left:16px;'>"
+        + "".join(linhas)
+        + "</ul></div>"
+    )
+
+
+def _trabalho_tecnico_group_popup_html(itens: list[dict[str, Any]]) -> str:
+    total = len(itens)
+    linhas = []
+    for item in itens:
+        endereco = str(item.get("endereco_texto") or "Endereco nao informado").strip()
+        tipo_label = str(item.get("tipo_label") or "").strip()
+        distancia = str(item.get("distancia_min_label") or "").strip()
+        modelos = str(item.get("modelos_texto") or "").strip()
+        linhas.append(
+            "<div style='padding:9px 0;border-top:1px solid #e6edf3;'>"
+            f"<div style='margin-bottom:4px;'>{_trabalho_tecnico_link_html(item)}</div>"
+            f"<div><span style='color:#666;'>Endereço:</span> {escape(endereco)}</div>"
+            + (f"<div><span style='color:#666;'>Tipo:</span> {escape(tipo_label)}</div>" if tipo_label else "")
+            + (f"<div><span style='color:#666;'>Menor distância:</span> {escape(distancia)}</div>" if distancia else "")
+            + (f"<div><span style='color:#666;'>Modelos:</span> {escape(modelos)}</div>" if modelos else "")
+            + "</div>"
+        )
+    lista_style = (
+        "max-height:260px;overflow-y:auto;padding-right:6px;"
+        if total >= 3
+        else ""
+    )
+    return (
+        "<div style='font-family:\"Segoe UI\",Arial,sans-serif; font-size:13px; line-height:1.5; min-width:320px; max-width:430px;'>"
+        f"<div style='margin-bottom:8px;'><b>{total} trabalhos técnicos neste local</b></div>"
+        f"<div style='{lista_style}'>"
+        + "".join(linhas)
+        + "</div>"
+        + "</div>"
+    )
+
+
+def _agrupar_trabalhos_tecnicos_marker_payloads(
+    payloads: list[dict[str, Any]],
+    *,
+    marker_style: str = "estrela",
+) -> list[dict[str, Any]]:
+    if len(payloads) <= 1:
+        return payloads
+
+    grupos: dict[tuple[float, float], list[dict[str, Any]]] = {}
+    ordem: list[tuple[float, float]] = []
+    for item in payloads:
+        chave = _marker_payload_coord_key(item)
+        if chave is None:
+            continue
+        if chave not in grupos:
+            ordem.append(chave)
+        grupos.setdefault(chave, []).append(item)
+
+    if not grupos:
+        return payloads
+
+    resultado: list[dict[str, Any]] = []
+    agrupados = {chave for chave, itens in grupos.items() if len(itens) > 1}
+    for item in payloads:
+        chave = _marker_payload_coord_key(item)
+        if chave not in agrupados:
+            resultado.append(item)
+
+    for chave in ordem:
+        itens = grupos.get(chave) or []
+        if len(itens) <= 1:
+            continue
+        itens_ordenados = sorted(itens, key=_trabalho_tecnico_group_sort_key)
+        base = itens_ordenados[0]
+        source_overlay_ids = _dedupe_ordered(
+            [
+                source_id
+                for item in itens_ordenados
+                for source_id in (item.get("source_overlay_ids") or [])
+            ]
+        )
+        resultado.append(
+            {
+                "lat": float(base["lat"]),
+                "lon": float(base["lon"]),
+                "trabalho_id": "",
+                "trabalho_nome": f"{len(itens_ordenados)} trabalhos técnicos",
+                "tooltip_html": _trabalho_tecnico_group_tooltip_html(itens_ordenados),
+                "tooltip_sticky": False,
+                "popup_html": _trabalho_tecnico_group_popup_html(itens_ordenados),
+                "popup_max_width": 460,
+                "source_overlay_ids": source_overlay_ids,
+                "marker_html": _trabalho_tecnico_group_marker_html(len(itens_ordenados), marker_style),
+                "marker_style": f"{str(marker_style or 'estrela').strip().lower()}-grupo",
+                "ignore_bounds": all(bool(item.get("ignore_bounds")) for item in itens_ordenados),
+                "icon_size": [24, 24],
+                "icon_anchor": [12, 12],
+                "class_name": "mesa-trabalho-tecnico-marker mesa-trabalho-tecnico-group-marker",
+            }
+        )
+
+    return resultado
+
+
 def build_trabalhos_tecnicos_marker_payloads(
     trabalhos: list[dict[str, Any]] | None,
     *,
@@ -299,6 +494,7 @@ def build_trabalhos_tecnicos_marker_payloads(
     marker_style: str = "estrela",
     ignore_bounds: bool = True,
     apply_jitter: bool = True,
+    group_overlaps: bool = True,
 ) -> list[dict[str, Any]]:
     payloads: list[dict[str, Any]] = []
     for item in trabalhos or []:
@@ -337,24 +533,13 @@ def build_trabalhos_tecnicos_marker_payloads(
         )
         distancia_min_label = str(item.get("distancia_label_min") or "").strip()
 
-        if trabalho_id:
-            payload_json = json.dumps(
-                {"type": "mesa:open-trabalho-tecnico", "trabalhoId": trabalho_id, "origem": origem},
-                ensure_ascii=True,
-            )
-            trabalho_nome_html = (
-                "<a href='#' "
-                "style='color:#7d5a00;text-decoration:underline;font-weight:700;' "
-                f"onclick='try{{(window.parent || window).postMessage({payload_json}, \"*\");}}catch(_error){{}} return false;'>"
-                f"{escape(trabalho_nome)}"
-                "</a>"
-            )
-        else:
-            trabalho_nome_html = (
-                "<span style='font-weight:700; color:#7d5a00;'>"
-                f"{escape(trabalho_nome)}"
-                "</span>"
-            )
+        trabalho_nome_html = _trabalho_tecnico_link_html(
+            {
+                "trabalho_id": trabalho_id,
+                "trabalho_nome": trabalho_nome,
+                "origem": origem,
+            }
+        )
 
         detalhes_html = (
             "<div style='font-family:\"Segoe UI\",Arial,sans-serif; font-size:13px; line-height:1.55; min-width:260px;'>"
@@ -375,58 +560,34 @@ def build_trabalhos_tecnicos_marker_payloads(
             + "</div>"
         )
 
-        if str(marker_style or "").strip().lower() != "ponto":
-            marker_html = (
-                "<div style='display:flex;align-items:center;justify-content:center;"
-                "width:14px;height:14px;'>"
-                "<svg width='14' height='14' viewBox='0 0 24 24' aria-hidden='true'>"
-                "<polygon points='12,1.8 15.2,8.2 22.2,9.2 17.1,14.1 18.3,21.1 "
-                "12,17.8 5.7,21.1 6.9,14.1 1.8,9.2 8.8,8.2' "
-                "fill='#c62828' stroke='#000000' stroke-width='1.4' stroke-linejoin='round'/>"
-                "</svg></div>"
-            )
-            payloads.append(
-                {
-                    "lat": lat,
-                    "lon": lon,
-                    "trabalho_id": trabalho_id,
-                    "trabalho_nome": trabalho_nome,
-                    "tooltip_html": detalhes_html,
-                    "popup_html": detalhes_html,
-                    "source_overlay_ids": modelos_origem_ids,
-                    "marker_html": marker_html,
-                    "marker_style": "estrela",
-                    "ignore_bounds": bool(ignore_bounds),
-                    "icon_size": [14, 14],
-                    "icon_anchor": [7, 7],
-                    "class_name": "mesa-trabalho-tecnico-marker",
-                }
-            )
-            continue
-
-        marker_html = (
-            "<div style='display:flex;align-items:center;justify-content:center;"
-            "width:8px;height:8px;border-radius:999px;background:#1f6fb2;"
-            "border:1px solid #ffffff;box-shadow:0 0 0 1px rgba(20,42,66,0.20);'></div>"
-        )
+        marker_html = _trabalho_tecnico_single_marker_html()
+        marker_style_norm = str(marker_style or "ponto").strip().lower() or "ponto"
         payloads.append(
             {
                 "lat": lat,
                 "lon": lon,
                 "trabalho_id": trabalho_id,
                 "trabalho_nome": trabalho_nome,
+                "origem": origem,
+                "tipo_label": tipo_label,
+                "endereco_texto": endereco_texto,
+                "distancia_min_label": distancia_min_label,
+                "modelos_texto": modelos_texto,
                 "tooltip_html": detalhes_html,
                 "popup_html": detalhes_html,
                 "source_overlay_ids": modelos_origem_ids,
                 "marker_html": marker_html,
-                "marker_style": "ponto",
+                "marker_style": marker_style_norm,
                 "ignore_bounds": bool(ignore_bounds),
-                "icon_size": [8, 8],
-                "icon_anchor": [4, 4],
-                "class_name": "mesa-trabalho-tecnico-marker mesa-trabalho-tecnico-marker-dot",
+                "icon_size": [14, 14],
+                "icon_anchor": [7, 7],
+                "class_name": "mesa-trabalho-tecnico-marker mesa-trabalho-tecnico-marker-circle",
             }
         )
 
+    if group_overlaps:
+        return _agrupar_trabalhos_tecnicos_marker_payloads(payloads, marker_style=marker_style)
+
     if apply_jitter:
         apply_marker_payload_jitter(payloads)
 
@@ -440,8 +601,8 @@ def add_marker_payloads(
     for item in payloads or []:
         marcador = folium.Marker(
             location=[float(item["lat"]), float(item["lon"])],
-            tooltip=folium.Tooltip(str(item.get("tooltip_html") or ""), sticky=True),
-            popup=folium.Popup(str(item.get("popup_html") or ""), max_width=360),
+            tooltip=folium.Tooltip(str(item.get("tooltip_html") or ""), sticky=item.get("tooltip_sticky") is not False),
+            popup=folium.Popup(str(item.get("popup_html") or ""), max_width=int(item.get("popup_max_width") or 360)),
             icon=folium.DivIcon(
                 html=str(item.get("marker_html") or ""),
                 icon_size=tuple(item.get("icon_size") or [14, 14]),
@@ -461,6 +622,7 @@ def add_trabalhos_tecnicos_markers(
     marker_style: str = "estrela",
     ignore_bounds: bool = True,
     apply_jitter: bool = True,
+    group_overlaps: bool = True,
 ) -> None:
     payloads = build_trabalhos_tecnicos_marker_payloads(
         trabalhos,
@@ -468,6 +630,7 @@ def add_trabalhos_tecnicos_markers(
         marker_style=marker_style,
         ignore_bounds=ignore_bounds,
         apply_jitter=apply_jitter,
+        group_overlaps=group_overlaps,
     )
     add_marker_payloads(camada, payloads)
 

backend/app/core/visualizacao/app.py

@@ -15,6 +15,7 @@ from folium import plugins
 from scipy import stats
 from statsmodels.stats.outliers_influence import OLSInfluence
 
+from app.core.map_jitter import aplicar_jitter_dados_mercado as _aplicar_jitter_sobrepostos
 from app.core.map_layers import (
     add_bairros_layer,
     add_indice_marker,
@@ -163,7 +164,7 @@ def _criar_histograma_residuos(residuos):
         return None
 
 
-def _criar_grafico_cook(modelos_sm):
+def _criar_grafico_cook(modelos_sm, indices=None):
     try:
         if modelos_sm is None:
             return None
@@ -171,15 +172,16 @@ def _criar_grafico_cook(modelos_sm):
         influence = OLSInfluence(modelos_sm)
         cooks_d = influence.cooks_distance[0]
         n = len(cooks_d)
-        indices = np.arange(1, n + 1)
+        indices_reais = np.array(indices) if indices is not None and len(indices) == n else np.arange(1, n + 1)
+        posicoes = np.arange(1, n + 1)
         limite = 4 / n
 
         fig = go.Figure()
-        for idx, valor in zip(indices, cooks_d):
+        for posicao, valor in zip(posicoes, cooks_d):
             cor = COR_LINHA if valor > limite else COR_PRINCIPAL
             fig.add_trace(
                 go.Scatter(
-                    x=[idx, idx],
+                    x=[posicao, posicao],
                     y=[0, valor],
                     mode="lines",
                     line=dict(color=cor, width=1.5),
@@ -191,12 +193,13 @@ def _criar_grafico_cook(modelos_sm):
         cores_pontos = [COR_LINHA if v > limite else COR_PRINCIPAL for v in cooks_d]
         fig.add_trace(
             go.Scatter(
-                x=indices,
+                x=posicoes,
                 y=cooks_d,
                 mode="markers",
                 marker=dict(color=cores_pontos, size=8, line=dict(color="black", width=1)),
                 name="Distância de Cook",
-                hovertemplate="Obs: %{x}<br>Cook: %{y:.4f}<extra></extra>",
+                customdata=indices_reais,
+                hovertemplate="<b>Índice:</b> %{customdata}<br><b>Cook:</b> %{y:.4f}<extra></extra>",
             )
         )
         fig.add_hline(
@@ -208,12 +211,12 @@ def _criar_grafico_cook(modelos_sm):
         )
         fig.update_layout(
             title=dict(text="Distância de Cook", x=0.5),
-            xaxis_title="Observação",
+            xaxis_title="Observação (ver índice no hover)",
             yaxis_title="Distância de Cook",
             plot_bgcolor="white",
             margin=dict(l=60, r=40, t=60, b=60),
         )
-        fig.update_xaxes(showgrid=True, gridcolor="lightgray", showline=True, linecolor="black")
+        fig.update_xaxes(showgrid=True, gridcolor="lightgray", showline=True, linecolor="black", showticklabels=False)
         fig.update_yaxes(showgrid=True, gridcolor="lightgray", showline=True, linecolor="black")
         return fig
     except Exception as exc:
@@ -371,7 +374,7 @@ def gerar_todos_graficos(pacote):
     if residuos is not None:
         graficos["hist"] = _criar_histograma_residuos(residuos)
     if modelos_sm is not None:
-        graficos["cook"] = _criar_grafico_cook(modelos_sm)
+        graficos["cook"] = _criar_grafico_cook(modelos_sm, indices)
         graficos["corr"] = _criar_grafico_correlacao(modelos_sm, nome_y=nome_y)
 
     return graficos
@@ -524,59 +527,6 @@ def formatar_escalas_html(escalas_raw):
     )
 
 
-def _aplicar_jitter_sobrepostos(df_mapa, lat_col, lon_col, lat_plot_col, lon_plot_col):
-    df_plot = df_mapa.copy()
-    df_plot[lat_plot_col] = pd.to_numeric(df_plot[lat_col], errors="coerce")
-    df_plot[lon_plot_col] = pd.to_numeric(df_plot[lon_col], errors="coerce")
-
-    if len(df_plot) <= 1:
-        return df_plot
-
-    chave_lat = df_plot[lat_col].round(7)
-    chave_lon = df_plot[lon_col].round(7)
-    grupos = df_plot.groupby([chave_lat, chave_lon], sort=False)
-
-    passo_metros = 4.0
-    max_raio_metros = 22.0
-    metros_por_grau_lat = 111_320.0
-    lat_plot_pos = int(df_plot.columns.get_loc(lat_plot_col))
-    lon_plot_pos = int(df_plot.columns.get_loc(lon_plot_col))
-
-    for _, idx_labels in grupos.indices.items():
-        posicoes = np.asarray(idx_labels, dtype=int)
-        if posicoes.size <= 1:
-            continue
-        base_lat = float(df_plot.iat[int(posicoes[0]), lat_plot_pos])
-        base_lon = float(df_plot.iat[int(posicoes[0]), lon_plot_pos])
-        if not np.isfinite(base_lat) or not np.isfinite(base_lon):
-            continue
-
-        seed_val = int((abs(base_lat) * 1_000_000.0) + (abs(base_lon) * 1_000_000.0) * 3.0) % 360
-        angulo_base = math.radians(seed_val)
-        cos_lat = max(abs(math.cos(math.radians(base_lat))), 1e-6)
-        metros_por_grau_lon = metros_por_grau_lat * cos_lat
-
-        for pos, pos_idx in enumerate(posicoes):
-            if pos == 0:
-                continue
-            pos_ring = pos - 1
-            ring = 1
-            while pos_ring >= (6 * ring):
-                pos_ring -= 6 * ring
-                ring += 1
-
-            slots_ring = max(6 * ring, 1)
-            angulo = angulo_base + (2.0 * math.pi * (pos_ring / slots_ring))
-            raio_m = min(ring * passo_metros, max_raio_metros)
-            delta_lat = (raio_m * math.sin(angulo)) / metros_por_grau_lat
-            delta_lon = (raio_m * math.cos(angulo)) / metros_por_grau_lon
-
-            df_plot.iat[int(pos_idx), lat_plot_pos] = base_lat + delta_lat
-            df_plot.iat[int(pos_idx), lon_plot_pos] = base_lon + delta_lon
-
-    return df_plot
-
-
 def _montar_popup_registro_paginado(itens, popup_uid, max_itens_pagina=8):
     def _limitar_texto(valor: str, limite: int) -> str:
         txt = str(valor)
@@ -787,8 +737,8 @@ def criar_mapa(
         prefer_canvas=True,
         control_scale=True,
     )
-    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)
+    folium.TileLayer(tiles="CartoDB positron", name="Positron", control=True, show=True).add_to(mapa)
+    folium.TileLayer(tiles="OpenStreetMap", name="OpenStreetMap", control=True, show=False).add_to(mapa)
     add_bairros_layer(mapa, show=True)
 
     if tamanho_col and tamanho_col != "Visualização Padrão" and not cor_col:

backend/app/core/visualizacao/map_payload.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from html import escape
 from typing import Any
 
 import branca.colormap as cm
@@ -10,18 +11,27 @@ from scipy.interpolate import griddata
 from app.core.elaboracao.charts import (
     _contorno_convexo_lng_lat,
     _mascara_dentro_poligono,
-    _montar_popup_registro_em_colunas,
     _normalizar_stops_cor,
 )
 from app.core.map_layers import build_trabalhos_tecnicos_marker_payloads
-from app.core.visualizacao.app import COR_PRINCIPAL, _aplicar_jitter_sobrepostos, formatar_monetario
+from app.core.visualizacao.app import COR_PRINCIPAL, formatar_monetario
 
 
 _LAT_ALIASES = {"lat", "latitude", "siat_latitude"}
 _LON_ALIASES = {"lon", "longitude", "long", "siat_longitude"}
 _TILE_LAYERS = [
-    {"id": "osm", "label": "OpenStreetMap", "url": "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png"},
-    {"id": "positron", "label": "Positron", "url": "https://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}{r}.png"},
+    {
+        "id": "positron",
+        "label": "Positron",
+        "url": "https://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}{r}.png",
+        "attribution": "© OpenStreetMap contributors © CARTO",
+    },
+    {
+        "id": "osm",
+        "label": "OpenStreetMap",
+        "url": "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
+        "attribution": "© OpenStreetMap contributors",
+    },
 ]
 
 
@@ -59,6 +69,42 @@ def _formatar_tooltip_valor(coluna: str | None, valor: Any) -> str:
     return str(valor)
 
 
+def _formatar_valor_resumo_mapa(coluna: str | None, valor: Any) -> str:
+    return _formatar_tooltip_valor(coluna, valor)
+
+
+def _formatar_indices_tooltip(indices: list[Any]) -> str:
+    return ", ".join(str(item) for item in indices)
+
+
+def _formatar_indices_badge(indices: list[Any], limite: int = 28) -> str:
+    texto = ", ".join(str(item) for item in indices)
+    if len(texto) <= limite:
+        return texto
+    return texto[: max(0, limite - 1)].rstrip(" ,") + "…"
+
+
+def _tooltip_html_grupo_mercado(indices: list[Any], label: str | None = None, valores: list[str] | None = None) -> str:
+    total = len(indices)
+    indices_txt = escape(_formatar_indices_tooltip(indices))
+    titulo = f"{total} dados neste local" if total != 1 else "1 dado neste local"
+    html = (
+        "<div style='font-family:\"Segoe UI\",Arial,sans-serif; font-size:14px; line-height:1.7; padding:2px 4px;'>"
+        f"<b>{escape(titulo)}</b>"
+        f"<br><span style='color:#555;'>Índices:</span> <b>{indices_txt}</b>"
+    )
+    valores_limpos = [str(item) for item in valores or [] if str(item).strip()]
+    if label and valores_limpos:
+        unicos = list(dict.fromkeys(valores_limpos))
+        if len(unicos) == 1:
+            resumo = unicos[0]
+        else:
+            resumo = "valores diferentes"
+        html += f"<br><span style='color:#555;'>{escape(str(label))}:</span> <b>{escape(str(resumo))}</b>"
+    html += "</div>"
+    return html
+
+
 def _resolver_bounds(df_mapa: pd.DataFrame, lat_key: str, lon_key: str) -> list[list[float]]:
     df_bounds = df_mapa
     if len(df_mapa) >= 8:
@@ -217,6 +263,7 @@ def build_elaboracao_map_payload(
     cor_tick_values: list[float] | None = None,
     cor_tick_labels: list[str] | None = None,
     bairros_geojson_url: str = "/api/visualizacao/map/bairros.geojson",
+    popup_source: str | None = "mercado",
 ) -> dict[str, Any] | None:
     modo_normalizado = str(modo or "pontos").strip().lower()
 
@@ -237,7 +284,10 @@ def build_elaboracao_map_payload(
     if lat_real is None or lon_real is None:
         return None
 
+    row_id_col = "__mesa_row_id__"
     df_mapa = df.copy()
+    if popup_source and row_id_col not in df_mapa.columns:
+        df_mapa[row_id_col] = np.arange(len(df_mapa), dtype=int)
     df_mapa[lat_real] = pd.to_numeric(df_mapa[lat_real], errors="coerce")
     df_mapa[lon_real] = pd.to_numeric(df_mapa[lon_real], errors="coerce")
     df_mapa = df_mapa.dropna(subset=[lat_real, lon_real])
@@ -327,13 +377,9 @@ def build_elaboracao_map_payload(
     lat_plot_col = "__mesa_lat_plot__"
     lon_plot_col = "__mesa_lon_plot__"
     if not modo_calor and not modo_superficie:
-        df_plot_pontos = _aplicar_jitter_sobrepostos(
-            df_mapa,
-            lat_col=str(lat_real),
-            lon_col=str(lon_real),
-            lat_plot_col=lat_plot_col,
-            lon_plot_col=lon_plot_col,
-        )
+        df_plot_pontos = df_mapa.copy()
+        df_plot_pontos[lat_plot_col] = df_plot_pontos[lat_real]
+        df_plot_pontos[lon_plot_col] = df_plot_pontos[lon_real]
     else:
         df_plot_pontos = df_mapa.copy()
         df_plot_pontos[lat_plot_col] = df_plot_pontos[lat_real]
@@ -538,72 +584,112 @@ def build_elaboracao_map_payload(
                                             }
                                         )
     else:
-        popup_cols: list[str]
-        if len(df_plot_pontos) <= 1200:
-            popup_cols = [str(c) for c in df_plot_pontos.columns]
-        elif tamanho_col and tamanho_col in df_plot_pontos.columns:
-            popup_cols = [str(tamanho_col)]
-        else:
-            popup_cols = []
-
         market_points: list[dict[str, Any]] = []
         indices_markers: list[dict[str, Any]] = []
-        for marker_ordem, (idx, row) in enumerate(df_plot_pontos.iterrows()):
-            idx_display = int(idx) if isinstance(idx, (int, np.integer)) else marker_ordem + 1
-            popup_html, popup_width = _montar_popup_registro_em_colunas(
-                idx_display,
-                row,
-                popup_cols,
-                max_itens_coluna=8,
-                popup_uid=f"mesa-pop-elab-{marker_ordem}",
-            )
-            tooltip_html = (
+        grupos_coord = df_plot_pontos.groupby(
+            [df_plot_pontos[lat_real].round(7), df_plot_pontos[lon_real].round(7)],
+            sort=False,
+        ).indices
+        for marker_ordem, posicoes_raw in enumerate(grupos_coord.values()):
+            posicoes = list(posicoes_raw)
+            rows_grupo = [df_plot_pontos.iloc[int(pos)] for pos in posicoes]
+            row = rows_grupo[0]
+            idx = row.name
+            registros_grupo: list[dict[str, Any]] = []
+            indices_display: list[Any] = []
+            valores_tooltip: list[str] = []
+            cores_grupo: list[str] = []
+            raios_grupo: list[float] = []
+            destaque_grupo = False
+
+            for pos in posicoes:
+                row_item = df_plot_pontos.iloc[int(pos)]
+                idx_item = row_item.name
+                idx_display_item = int(idx_item) if isinstance(idx_item, (int, np.integer)) else int(pos) + 1
+                indices_display.append(idx_display_item)
+                valor_texto = ""
+                if tamanho_col and tamanho_col in df_plot_pontos.columns:
+                    valor_texto = _formatar_valor_resumo_mapa(str(tamanho_col), row_item[tamanho_col])
+                    valores_tooltip.append(valor_texto)
+
+                cor_item = COR_PRINCIPAL
+                if colormap and cor_col_resolvida and cor_col_resolvida in df_mapa.columns:
+                    valor_cor = pd.to_numeric(pd.Series([row_item.get(cor_col_resolvida)]), errors="coerce").iloc[0]
+                    if pd.notna(valor_cor):
+                        cor_item = str(colormap(float(valor_cor)))
+                cores_grupo.append(cor_item)
+
+                if idx_item == indice_destacado:
+                    raio_item = raio_max + 4.0
+                    destaque_grupo = True
+                elif tamanho_func and tamanho_col and tamanho_col in row_item.index and pd.notna(row_item[tamanho_col]):
+                    raio_item = float(tamanho_func(float(row_item[tamanho_col])))
+                else:
+                    raio_item = 4.0
+                raios_grupo.append(float(max(1.0, raio_item)))
+
+                row_id_raw_item = row_item[row_id_col] if popup_source and row_id_col in row_item.index else None
+                popup_request_item = None
+                if row_id_raw_item is not None and pd.notna(row_id_raw_item):
+                    popup_request_item = {
+                        "kind": "elaboracao_row",
+                        "row_id": int(row_id_raw_item),
+                        "source": str(popup_source),
+                    }
+                registros_grupo.append(
+                    {
+                        "indice": idx_display_item,
+                        "label": f"Índice {idx_display_item}",
+                        "value_label": str(tamanho_col or ""),
+                        "value": valor_texto,
+                        "popup_request": popup_request_item,
+                    }
+                )
+
+            cor = cores_grupo[0] if cores_grupo else COR_PRINCIPAL
+            raio = max(raios_grupo) if raios_grupo else 4.0
+            stroke_weight = 3.0 if destaque_grupo else 1.0
+            fill_opacity = 0.8 if destaque_grupo else 0.6
+            is_grouped = len(rows_grupo) > 1
+            idx_display = indices_display[0] if indices_display else marker_ordem + 1
+            tooltip_html = _tooltip_html_grupo_mercado(
+                indices_display,
+                label=str(tamanho_col or "") if tamanho_col else None,
+                valores=valores_tooltip,
+            ) if is_grouped else (
                 "<div style='font-family:\"Segoe UI\",Arial,sans-serif; font-size:14px; line-height:1.7; padding:2px 4px;'>"
                 f"<b>Índice {idx_display}</b>"
-            )
-            if tamanho_col and tamanho_col in df_plot_pontos.columns:
-                valor_tooltip = row[tamanho_col]
-                valor_texto = (
-                    f"{float(valor_tooltip):.2f}"
-                    if isinstance(valor_tooltip, (int, float, np.integer, np.floating)) and np.isfinite(float(valor_tooltip))
-                    else str(valor_tooltip)
+                + (
+                    f"<br><span style='color:#555;'>{escape(str(tamanho_col))}:</span> <b>{escape(valores_tooltip[0])}</b>"
+                    if tamanho_col and valores_tooltip
+                    else ""
                 )
-                tooltip_html += (
-                    f"<br><span style='color:#555;'>{str(tamanho_col)}:</span> "
-                    f"<b>{valor_texto}</b>"
+                + "</div>"
+            )
+
+            point_payload = {
+                "lat": float(row[lat_plot_col]),
+                "lon": float(row[lon_plot_col]),
+                "indice": _formatar_indices_badge(indices_display) if is_grouped else idx_display,
+                "color": cor,
+                "base_radius": float(max(1.0, raio)),
+                "stroke_color": "#243746" if is_grouped else "#000000",
+                "stroke_weight": float(max(stroke_weight, 2.0) if is_grouped else stroke_weight),
+                "fill_opacity": float(0.74 if is_grouped else fill_opacity),
+                "tooltip_html": tooltip_html,
+            }
+            if is_grouped:
+                point_payload.update(
+                    {
+                        "grouped": True,
+                        "count": len(rows_grupo),
+                        "group_title": f"{len(rows_grupo)} dados neste local",
+                        "group_items": registros_grupo,
+                    }
                 )
-            tooltip_html += "</div>"
-
-            cor = COR_PRINCIPAL
-            if colormap and cor_col_resolvida and cor_col_resolvida in df_mapa.columns:
-                valor_cor = pd.to_numeric(pd.Series([row.get(cor_col_resolvida)]), errors="coerce").iloc[0]
-                if pd.notna(valor_cor):
-                    cor = str(colormap(float(valor_cor)))
-
-            if idx == indice_destacado:
-                raio = raio_max + 4.0
-            elif tamanho_func and tamanho_col and tamanho_col in row.index and pd.notna(row[tamanho_col]):
-                raio = float(tamanho_func(float(row[tamanho_col])))
             else:
-                raio = 4.0
-            stroke_weight = 3.0 if idx == indice_destacado else 1.0
-            fill_opacity = 0.8 if idx == indice_destacado else 0.6
-
-            market_points.append(
-                {
-                    "lat": float(row[lat_plot_col]),
-                    "lon": float(row[lon_plot_col]),
-                    "indice": idx_display,
-                    "color": cor,
-                    "base_radius": float(max(1.0, raio)),
-                    "stroke_color": "#000000",
-                    "stroke_weight": float(stroke_weight),
-                    "fill_opacity": float(fill_opacity),
-                    "tooltip_html": tooltip_html,
-                    "popup_html": popup_html,
-                    "popup_max_width": int(popup_width),
-                }
-            )
+                point_payload["popup_request"] = registros_grupo[0].get("popup_request") if registros_grupo else None
+            market_points.append(point_payload)
 
             if mostrar_indices:
                 indices_markers.append(
@@ -615,10 +701,10 @@ def build_elaboracao_map_payload(
                             + 'border: 1px solid rgba(28, 45, 66, 0.45);border-radius: 10px;padding: 1px 6px;font-size: 11px;'
                             + 'font-weight: 700;line-height: 1.2;color: #1f2f44;white-space: nowrap;box-shadow: 0 1px 2px rgba(0, 0, 0, 0.18);'
                             + 'pointer-events: none;">'
-                            + f"{idx_display}"
+                            + escape(_formatar_indices_badge(indices_display))
                             + "</div>"
                         ),
-                        "icon_size": [72, 24],
+                        "icon_size": [96 if is_grouped else 72, 24],
                         "icon_anchor": [0, 0],
                         "class_name": "mesa-indice-label",
                         "interactive": False,
@@ -749,13 +835,9 @@ def build_visualizacao_map_payload(
     show_indices = False
     lat_plot_key = "__mesa_lat_plot__"
     lon_plot_key = "__mesa_lon_plot__"
-    df_plot_pontos = _aplicar_jitter_sobrepostos(
-        df_mapa,
-        lat_col=lat_key,
-        lon_col=lon_key,
-        lat_plot_col=lat_plot_key,
-        lon_plot_col=lon_plot_key,
-    )
+    df_plot_pontos = df_mapa.copy()
+    df_plot_pontos[lat_plot_key] = df_plot_pontos[lat_key]
+    df_plot_pontos[lon_plot_key] = df_plot_pontos[lon_key]
 
     tooltip_col = None
     tooltip_key = None
@@ -774,35 +856,96 @@ def build_visualizacao_map_payload(
     raio_padrao = 4.0 if total_pontos_plot <= 2500 else 3.0
 
     market_points: list[dict[str, Any]] = []
-    for idx, row in df_plot_pontos.iterrows():
-        cor = colormap(row[cor_key]) if colormap and cor_key and pd.notna(row[cor_key]) else COR_PRINCIPAL
-        if tamanho_func and tamanho_key and pd.notna(row[tamanho_key]):
-            raio = float(tamanho_func(row[tamanho_key]))
-        else:
-            raio = raio_padrao
+    grupos_coord = df_plot_pontos.groupby(
+        [df_plot_pontos[lat_key].round(7), df_plot_pontos[lon_key].round(7)],
+        sort=False,
+    ).indices
+    for marker_ordem, posicoes_raw in enumerate(grupos_coord.values()):
+        posicoes = list(posicoes_raw)
+        rows_grupo = [df_plot_pontos.iloc[int(pos)] for pos in posicoes]
+        row = rows_grupo[0]
+        indices_display: list[Any] = []
+        registros_grupo: list[dict[str, Any]] = []
+        valores_tooltip: list[str] = []
+        cores_grupo: list[str] = []
+        raios_grupo: list[float] = []
+
+        for pos in posicoes:
+            row_item = df_plot_pontos.iloc[int(pos)]
+            idx_item = row_item.name
+            idx_display_item = int(row_item["index"]) if "index" in row_item.index else int(idx_item)
+            indices_display.append(idx_display_item)
+
+            valor_texto = (
+                _formatar_tooltip_valor(str(tooltip_col or ""), row_item[tooltip_key])
+                if tooltip_col and tooltip_key and tooltip_key in row_item.index
+                else ""
+            )
+            if valor_texto:
+                valores_tooltip.append(valor_texto)
 
-        idx_display = int(row["index"]) if "index" in row.index else int(idx)
+            cor_item = colormap(row_item[cor_key]) if colormap and cor_key and pd.notna(row_item[cor_key]) else COR_PRINCIPAL
+            cores_grupo.append(str(cor_item))
+            if tamanho_func and tamanho_key and pd.notna(row_item[tamanho_key]):
+                raio_item = float(tamanho_func(row_item[tamanho_key]))
+            else:
+                raio_item = raio_padrao
+            raios_grupo.append(float(max(1.0, raio_item)))
+
+            row_id_raw_item = row_item["__mesa_row_id__"] if "__mesa_row_id__" in row_item.index else None
+            row_id_item = int(row_id_raw_item) if row_id_raw_item is not None and pd.notna(row_id_raw_item) else None
+            registros_grupo.append(
+                {
+                    "indice": idx_display_item,
+                    "label": f"Índice {idx_display_item}",
+                    "value_label": str(tooltip_col or ""),
+                    "value": valor_texto,
+                    "popup_request": (
+                        {"kind": "visualizacao_row", "row_id": row_id_item}
+                        if row_id_item is not None
+                        else None
+                    ),
+                }
+            )
+
+        is_grouped = len(rows_grupo) > 1
+        idx_display = indices_display[0] if indices_display else marker_ordem
+        cor = cores_grupo[0] if cores_grupo else COR_PRINCIPAL
+        raio = max(raios_grupo) if raios_grupo else raio_padrao
         tooltip_payload = {
             "title": f"Índice {idx_display}",
             "label": str(tooltip_col or ""),
-            "value": (
-                _formatar_tooltip_valor(str(tooltip_col or ""), row[tooltip_key])
-                if tooltip_col and tooltip_key and tooltip_key in row.index
-                else ""
-            ),
+            "value": valores_tooltip[0] if valores_tooltip else "",
         }
         row_id_raw = row["__mesa_row_id__"] if "__mesa_row_id__" in row.index else None
-        market_points.append(
-            {
-                "lat": float(row[lat_plot_key]),
-                "lon": float(row[lon_plot_key]),
-                "indice": idx_display,
-                "row_id": int(row_id_raw) if row_id_raw is not None and pd.notna(row_id_raw) else None,
-                "color": str(cor),
-                "base_radius": float(max(1.0, raio)),
-                "tooltip": tooltip_payload,
-            }
-        )
+        point_payload = {
+            "lat": float(row[lat_plot_key]),
+            "lon": float(row[lon_plot_key]),
+            "indice": _formatar_indices_badge(indices_display) if is_grouped else idx_display,
+            "row_id": int(row_id_raw) if (not is_grouped and row_id_raw is not None and pd.notna(row_id_raw)) else None,
+            "color": str(cor),
+            "base_radius": float(max(1.0, raio)),
+        }
+        if is_grouped:
+            point_payload.update(
+                {
+                    "grouped": True,
+                    "count": len(rows_grupo),
+                    "stroke_color": "#243746",
+                    "stroke_weight": 2.0,
+                    "fill_opacity": 0.74,
+                    "tooltip_html": _tooltip_html_grupo_mercado(
+                        indices_display,
+                        label=str(tooltip_col or "") if tooltip_col else None,
+                        valores=valores_tooltip,
+                    ),
+                    "group_title": f"{len(rows_grupo)} dados neste local",
+                    "group_items": registros_grupo,
+                }
+            )
+        else:
+            point_payload["tooltip"] = tooltip_payload
+        market_points.append(point_payload)
 
     return {
         "type": "mesa_leaflet_payload",

backend/app/services/elaboracao_service.py

@@ -54,6 +54,7 @@ from app.core.elaboracao.formatadores import (
     formatar_micronumerosidade_html,
     formatar_outliers_anteriores_html,
 )
+from app.core.visualizacao import app as visualizacao_app
 from app.core.visualizacao.map_payload import build_elaboracao_map_payload
 from app.models.session import SessionState
 from app.runtime_paths import resolve_core_path
@@ -2107,7 +2108,11 @@ def apply_outlier_filters(session: SessionState, filtros: list[dict[str, Any]])
 
     indices = _coletar_indices_outliers(metricas, filtros)
     outliers_propostos = sorted(set(_clean_int_list(session.outliers_anteriores) + indices))
-    _validar_outliers_micronumerosidade_geral(session, outliers_propostos)
+    _validar_outliers_micronumerosidade_geral(
+        session,
+        outliers_propostos,
+        orientacao="Ajuste os filtros de outliers.",
+    )
     texto = ", ".join(str(i) for i in indices)
     return {
         "indices": indices,
@@ -2213,7 +2218,10 @@ def _info_micronumerosidade_geral_outliers(session: SessionState, outliers_base:
     }
 
 
-def _formatar_erro_micronumerosidade_geral(limite_info: dict[str, Any] | None) -> str:
+def _formatar_erro_micronumerosidade_geral(
+    limite_info: dict[str, Any] | None,
+    orientacao: str | None = None,
+) -> str:
     if not limite_info:
         return "A exclusão ultrapassa a micronumerosidade mínima do modelo."
     n_final = int(limite_info.get("n_final_atual") or 0)
@@ -2221,15 +2229,20 @@ def _formatar_erro_micronumerosidade_geral(limite_info: dict[str, Any] | None) -
     k = int(limite_info.get("k") or 0)
     total = int(limite_info.get("n_total") or 0)
     excluidos = int(limite_info.get("excluidos_presentes") or 0)
+    orientacao_final = str(orientacao or "Ajuste os filtros de outliers.").strip()
     return (
         "A exclusão ultrapassa a micronumerosidade mínima: "
         f"restariam {n_final} observações de {total}, mas o modelo precisa manter pelo menos {minimo} "
         f"(n >= 3(k+1), k={k}). "
-        f"A seleção atual excluiria {excluidos} observação(ões). Reinclua dados ou ajuste os filtros de outliers."
+        f"A seleção atual excluiria {excluidos} observação(ões). {orientacao_final}"
     )
 
 
-def _validar_outliers_micronumerosidade_geral(session: SessionState, outliers: list[int]) -> None:
+def _validar_outliers_micronumerosidade_geral(
+    session: SessionState,
+    outliers: list[int],
+    orientacao: str | None = None,
+) -> None:
     info = _info_micronumerosidade_geral_outliers(session, outliers)
     n_final = int(info.get("n_final_atual") or 0)
     minimo = int(info.get("min_observacoes") or 0)
@@ -2241,7 +2254,7 @@ def _validar_outliers_micronumerosidade_geral(session: SessionState, outliers: l
 
     raise HTTPException(
         status_code=400,
-        detail=_formatar_erro_micronumerosidade_geral(info),
+        detail=_formatar_erro_micronumerosidade_geral(info, orientacao=orientacao),
     )
 
 
@@ -2358,7 +2371,11 @@ def apply_outlier_filters_recursive(
         novos_iteracao = [idx for idx in indices_iteracao if idx not in outliers_atuais and idx not in novos_set]
         if novos_iteracao:
             outliers_propostos = sorted(set(outliers_atuais + novos_iteracao))
-            _validar_outliers_micronumerosidade_geral(session, outliers_propostos)
+            _validar_outliers_micronumerosidade_geral(
+                session,
+                outliers_propostos,
+                orientacao="Ajuste os filtros de outliers antes de aplicar com recursividade.",
+            )
             iteracoes += 1
             novos_acumulados.extend(novos_iteracao)
             novos_set.update(novos_iteracao)
@@ -2392,7 +2409,11 @@ def apply_outlier_filters_recursive(
             break
 
         outliers_propostos = sorted(set(outliers_atuais + novos_iteracao))
-        _validar_outliers_micronumerosidade_geral(session, outliers_propostos)
+        _validar_outliers_micronumerosidade_geral(
+            session,
+            outliers_propostos,
+            orientacao="Ajuste os filtros de outliers antes de aplicar com recursividade.",
+        )
         iteracoes += 1
         novos_acumulados.extend(novos_iteracao)
         novos_set.update(novos_iteracao)
@@ -2453,7 +2474,11 @@ def reiniciar_iteracao(
 
     anteriores_atualizados = [i for i in session.outliers_anteriores if i not in reincluir]
     outliers_combinados = sorted(set(anteriores_atualizados + novos))
-    _validar_outliers_micronumerosidade_geral(session, outliers_combinados)
+    _validar_outliers_micronumerosidade_geral(
+        session,
+        outliers_combinados,
+        orientacao="Modifique a lista de exclusões ou ajuste os filtros de outliers.",
+    )
 
     transformacao_y_atual = str(session.transformacao_y or "(x)")
     transformacoes_x_atuais = {
@@ -3124,6 +3149,40 @@ def atualizar_mapa(session: SessionState, var_mapa: str | None, modo_mapa: str |
     return {"mapa_html": mapa_html, "mapa_payload": mapa_payload}
 
 
+def carregar_popup_ponto_mapa(session: SessionState, row_id: int, source: str | None = None) -> dict[str, Any]:
+    source_norm = str(source or "mercado").strip().lower()
+    if source_norm in {"residuo", "residuos", "resíduos"}:
+        df = session.tabela_metricas_estado
+        mensagem_vazia = "Ajuste o modelo antes de abrir os detalhes do ponto"
+        popup_source = "residuos"
+    else:
+        df = session.df_filtrado if session.df_filtrado is not None else session.df_original
+        mensagem_vazia = "Carregue dados antes de abrir os detalhes do ponto"
+        popup_source = "mercado"
+
+    if df is None or df.empty:
+        raise HTTPException(status_code=400, detail=mensagem_vazia)
+
+    try:
+        row_id_int = int(row_id)
+    except (TypeError, ValueError) as exc:
+        raise HTTPException(status_code=400, detail="Identificador de ponto invalido") from exc
+
+    if row_id_int < 0 or row_id_int >= len(df.index):
+        raise HTTPException(status_code=404, detail="Ponto nao encontrado para esta sessao")
+
+    row = df.iloc[row_id_int]
+    popup_html, popup_width = visualizacao_app.montar_popup_registro_html(
+        row,
+        popup_uid=f"mesa-popup-elab-{popup_source}-{row_id_int}",
+        max_itens_pagina=8,
+    )
+    return {
+        "popup_html": popup_html,
+        "popup_width": int(popup_width),
+    }
+
+
 def _normalizar_extremo_abs_residuos(valor: float | None) -> float | None:
     if valor is None:
         return None
@@ -3209,6 +3268,7 @@ def atualizar_mapa_residuos(
         cor_colors=["#2e7d32", "#f1c40f", "#ffffff", "#f1c40f", "#c62828"],
         cor_tick_values=ticks_valores,
         cor_tick_labels=ticks_labels,
+        popup_source="residuos",
     )
     return {
         "mapa_html": mapa_html,

backend/app/services/pesquisa_service.py

@@ -25,7 +25,6 @@ from app.core.elaboracao.core import _migrar_pacote_v1_para_v2, normalizar_obser
 from app.core.map_layers import (
     add_bairros_layer,
     add_marker_payloads,
-    apply_marker_payload_jitter,
     build_trabalhos_tecnicos_marker_payloads,
     add_zoom_responsive_circle_markers,
 )
@@ -922,6 +921,7 @@ def gerar_mapa_modelos(
     avaliando_lon: float | None = None,
     avaliandos: list[dict[str, Any]] | None = None,
     modo_exibicao: str | None = "pontos",
+    agrupar_pontos_mercado: Any = False,
     criterio_espacial: str | None = CRITERIO_ESPACIAL_PADRAO,
     trabalhos_tecnicos_modelos_modo: str | None = TRABALHOS_TECNICOS_MODELOS_SELECIONADOS,
     trabalhos_tecnicos_proximidade_modo: str | None = TRABALHOS_TECNICOS_PROXIMIDADE_DESATIVADA,
@@ -949,6 +949,7 @@ def gerar_mapa_modelos(
         raise HTTPException(status_code=404, detail="Nenhum modelo selecionado foi encontrado na pasta de pesquisa")
 
     modo_exibicao_norm = _normalizar_modo_exibicao_mapa(modo_exibicao)
+    agrupar_pontos_mercado_norm = _normalizar_agrupar_pontos_mercado_mapa(agrupar_pontos_mercado)
     trabalhos_tecnicos_modelos_modo_norm = _normalizar_modo_trabalhos_tecnicos_modelos_mapa(trabalhos_tecnicos_modelos_modo)
     trabalhos_tecnicos_proximidade_modo_norm = _normalizar_modo_trabalhos_tecnicos_proximidade_mapa(
         trabalhos_tecnicos_proximidade_modo
@@ -1069,6 +1070,7 @@ def gerar_mapa_modelos(
         bounds,
         avaliandos_geo,
         modo_exibicao_norm,
+        agrupar_pontos_mercado=agrupar_pontos_mercado_norm,
         avaliandos_tecnicos_proximos=avaliandos_tecnicos_proximos,
         trabalhos_tecnicos_raio_m=trabalhos_tecnicos_raio_m_norm,
     )
@@ -1135,6 +1137,7 @@ def gerar_mapa_modelos(
             "avaliandos": avaliandos_geo,
             "criterio_espacial": criterio_espacial_norm,
             "modo_exibicao": modo_exibicao_norm,
+            "agrupar_pontos_mercado": agrupar_pontos_mercado_norm,
             "trabalhos_tecnicos_modelos_modo": trabalhos_tecnicos_modelos_modo_norm,
             "trabalhos_tecnicos_proximidade_modo": trabalhos_tecnicos_proximidade_modo_norm,
             "trabalhos_tecnicos_raio_m": trabalhos_tecnicos_raio_m_norm,
@@ -1160,6 +1163,13 @@ def _normalizar_modo_exibicao_mapa(value: Any) -> str:
     return "pontos"
 
 
+def _normalizar_agrupar_pontos_mercado_mapa(value: Any) -> bool:
+    if isinstance(value, bool):
+        return value
+    texto = _normalize(str(value or "")).strip()
+    return texto in {"1", "true", "sim", "s", "yes", "y", "agrupar", "agrupado", "agrupados"}
+
+
 def _normalizar_modo_trabalhos_tecnicos_modelos_mapa(value: Any) -> str:
     modo = str(value or "").strip().lower()
     if modo in {
@@ -1217,6 +1227,95 @@ def _tooltip_mapa_modelo_html(modelo: dict[str, Any]) -> str:
     )
 
 
+def _tooltip_mapa_modelo_ponto_html(modelo: dict[str, Any], total_no_local: int) -> str:
+    tooltip = _tooltip_mapa_modelo_html(modelo)
+    if total_no_local <= 1:
+        return tooltip
+    detalhe = f"<br><span style='color:#555;'>Dados neste local:</span> <b>{total_no_local}</b>"
+    if tooltip.endswith("</div>"):
+        return f"{tooltip[:-6]}{detalhe}</div>"
+    return f"{tooltip}{detalhe}"
+
+
+def _chave_coordenada_ponto(ponto: dict[str, Any], precisao: int = 7) -> tuple[float, float] | None:
+    try:
+        lat = float(ponto["lat"])
+        lon = float(ponto["lon"])
+    except (KeyError, TypeError, ValueError):
+        return None
+    if not math.isfinite(lat) or not math.isfinite(lon):
+        return None
+    return (round(lat, precisao), round(lon, precisao))
+
+
+def _contagens_coordenadas_modelos(modelos_plotados: list[dict[str, Any]]) -> dict[tuple[float, float], int]:
+    contagens: dict[tuple[float, float], int] = {}
+    for modelo in modelos_plotados:
+        for ponto in modelo.get("pontos") or []:
+            chave = _chave_coordenada_ponto(ponto)
+            if chave is None:
+                continue
+            contagens[chave] = contagens.get(chave, 0) + 1
+    return contagens
+
+
+def _ponto_mapa_modelo_payload_item(
+    modelo: dict[str, Any],
+    ponto: dict[str, Any],
+    total_no_local: int = 1,
+) -> dict[str, Any]:
+    cor = str(modelo.get("cor") or "#1f77b4")
+    item: dict[str, Any] = {
+        "lat": float(ponto["lat"]),
+        "lon": float(ponto["lon"]),
+        "color": cor,
+        "base_radius": 3.0,
+        "stroke_color": cor,
+        "stroke_weight": 1.0,
+        "fill_opacity": 0.72,
+        "tooltip_html": _tooltip_mapa_modelo_ponto_html(modelo, total_no_local),
+    }
+    if total_no_local > 1:
+        item.update(
+            {
+                "grouped": True,
+                "count": total_no_local,
+                "group_title": f"{total_no_local} dados neste local",
+                "pane": "mesa-market-group-pane",
+                "tooltip_sticky": False,
+            }
+        )
+    return item
+
+
+def _pontos_mapa_modelo_payload(
+    modelo: dict[str, Any],
+    contagens_coordenadas: dict[tuple[float, float], int] | None = None,
+    agrupar_pontos_mercado: bool = False,
+) -> list[dict[str, Any]]:
+    if not agrupar_pontos_mercado:
+        pontos_payload: list[dict[str, Any]] = []
+        for ponto in modelo.get("pontos") or []:
+            if _chave_coordenada_ponto(ponto) is None:
+                continue
+            pontos_payload.append(_ponto_mapa_modelo_payload_item(modelo, ponto))
+        return pontos_payload
+
+    grupos: dict[tuple[float, float], list[dict[str, Any]]] = {}
+    for ponto in modelo.get("pontos") or []:
+        chave = _chave_coordenada_ponto(ponto)
+        if chave is None:
+            continue
+        grupos.setdefault(chave, []).append(ponto)
+
+    pontos_payload: list[dict[str, Any]] = []
+    for chave, pontos_no_local in grupos.items():
+        ponto = pontos_no_local[0]
+        total_no_local = max(len(pontos_no_local), int((contagens_coordenadas or {}).get(chave) or 0))
+        pontos_payload.append(_ponto_mapa_modelo_payload_item(modelo, ponto, total_no_local))
+    return pontos_payload
+
+
 def _marker_payloads_avaliandos(avaliandos_geo: list[dict[str, Any]]) -> list[dict[str, Any]]:
     payloads: list[dict[str, Any]] = []
     for idx, avaliando in enumerate(avaliandos_geo):
@@ -1335,6 +1434,7 @@ def _build_mapa_modelos_payload(
     bounds: list[list[float]],
     avaliandos_geo: list[dict[str, Any]],
     modo_exibicao: str,
+    agrupar_pontos_mercado: bool = False,
     avaliandos_tecnicos_proximos: list[dict[str, Any]] | None = None,
     trabalhos_tecnicos_raio_m: int | None = None,
 ) -> dict[str, Any] | None:
@@ -1362,8 +1462,11 @@ def _build_mapa_modelos_payload(
         if avaliandos_tecnicos_proximos is not None
         else []
     )
-    if trabalhos_tecnicos_modelos_markers or trabalhos_tecnicos_proximos_markers:
-        apply_marker_payload_jitter([*trabalhos_tecnicos_modelos_markers, *trabalhos_tecnicos_proximos_markers])
+    contagens_pontos = (
+        _contagens_coordenadas_modelos(modelos_plotados)
+        if modo_exibicao == "pontos" and agrupar_pontos_mercado
+        else {}
+    )
 
     for modelo in modelos_plotados:
         layer: dict[str, Any] = {
@@ -1373,20 +1476,11 @@ def _build_mapa_modelos_payload(
             "hover_highlight_group": "pesquisa-modelos",
         }
         if modo_exibicao == "pontos":
-            tooltip_html = _tooltip_mapa_modelo_html(modelo)
-            layer["points"] = [
-                {
-                    "lat": float(ponto["lat"]),
-                    "lon": float(ponto["lon"]),
-                    "color": str(modelo.get("cor") or "#1f77b4"),
-                    "base_radius": 3.0,
-                    "stroke_color": str(modelo.get("cor") or "#1f77b4"),
-                    "stroke_weight": 1.0,
-                    "fill_opacity": 0.72,
-                    "tooltip_html": tooltip_html,
-                }
-                for ponto in (modelo.get("pontos") or [])
-            ]
+            layer["points"] = _pontos_mapa_modelo_payload(
+                modelo,
+                contagens_pontos,
+                agrupar_pontos_mercado=agrupar_pontos_mercado,
+            )
         else:
             layer["shapes"] = _shapes_modelo_payload(modelo, aval_lat, aval_lon)
         overlay_layers.append(layer)
@@ -1478,8 +1572,8 @@ def _renderizar_mapa_modelos(
         control_scale=True,
         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)
+    folium.TileLayer(tiles="CartoDB positron", name="Positron", control=True, show=True).add_to(mapa)
+    folium.TileLayer(tiles="OpenStreetMap", name="OpenStreetMap", control=True, show=False).add_to(mapa)
     add_bairros_layer(mapa, show=True)
     nome_camada_avaliando = "Avaliando" if len(avaliandos_geo) == 1 else "Avaliandos"
     camada_avaliando = folium.FeatureGroup(name=nome_camada_avaliando, show=True)
@@ -1503,8 +1597,6 @@ def _renderizar_mapa_modelos(
         if avaliandos_tecnicos_proximos is not None
         else []
     )
-    if trabalhos_tecnicos_modelos_markers or trabalhos_tecnicos_proximos_markers:
-        apply_marker_payload_jitter([*trabalhos_tecnicos_modelos_markers, *trabalhos_tecnicos_proximos_markers])
     camada_trabalhos_modelos = (
         folium.FeatureGroup(name="Trabalhos tecnicos dos modelos", show=True)
         if trabalhos_tecnicos_modelos
@@ -4415,13 +4507,15 @@ def _parse_datetime(texto: str) -> datetime | None:
 
 
 def _contains_any(candidatos: list[Any], consulta: str) -> bool:
-    alvo = _normalize(consulta)
-    if not alvo:
+    alvos = [_normalize(termo) for termo in re.split(r"\s*\|\|\s*|[;|]", str(consulta or ""))]
+    alvos = [alvo for alvo in alvos if alvo]
+    if not alvos:
         return True
     for item in candidatos:
         if item is None:
             continue
-        if alvo in _normalize(str(item)):
+        item_norm = _normalize(str(item))
+        if any(alvo in item_norm for alvo in alvos):
             return True
     return False
 

backend/app/services/trabalhos_tecnicos_service.py

@@ -1539,8 +1539,8 @@ def gerar_mapa_trabalhos(
         prefer_canvas=True,
         control_scale=True,
     )
-    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)
+    folium.TileLayer(tiles="CartoDB positron", name="Positron", control=True, show=True).add_to(mapa)
+    folium.TileLayer(tiles="OpenStreetMap", name="OpenStreetMap", control=True, show=False).add_to(mapa)
     add_bairros_layer(mapa, show=True)
 
     camada = folium.FeatureGroup(name="Trabalhos tecnicos", show=True)
@@ -1631,8 +1631,8 @@ def _criar_mapa_trabalho(nome_trabalho: str, imoveis: list[dict[str, Any]]) -> s
         prefer_canvas=True,
         control_scale=True,
     )
-    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)
+    folium.TileLayer(tiles="CartoDB positron", name="Positron", control=True, show=True).add_to(mapa)
+    folium.TileLayer(tiles="OpenStreetMap", name="OpenStreetMap", control=True, show=False).add_to(mapa)
     add_bairros_layer(mapa, show=True)
 
     camada = folium.FeatureGroup(name="Imoveis do trabalho", show=True)

backend/app/services/visualizacao_service.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import base64
+import json
 from html import escape
 from pathlib import Path
 from time import sleep
@@ -14,6 +16,7 @@ from folium import plugins
 from joblib import load
 
 from app.core.visualizacao import app as viz_app
+from app.core.map_jitter import aplicar_jitter_dados_mercado
 from app.core.map_layers import (
     add_bairros_layer,
     add_popup_pagination_handlers,
@@ -87,6 +90,98 @@ def _to_dataframe(value: Any) -> pd.DataFrame | None:
     return None
 
 
+def _trace_mode_includes_markers(mode: Any) -> bool:
+    return "markers" in str(mode or "").strip().lower()
+
+
+def _extrair_sequencia_payload(valores: Any) -> list[Any]:
+    if isinstance(valores, list):
+        return valores
+    if isinstance(valores, tuple):
+        return list(valores)
+    if isinstance(valores, dict):
+        dtype_text = str(valores.get("dtype") or "").strip()
+        bdata_text = str(valores.get("bdata") or "").strip()
+        if dtype_text and bdata_text:
+            try:
+                buffer = base64.b64decode(bdata_text)
+                array = np.frombuffer(buffer, dtype=np.dtype(dtype_text))
+                return array.tolist()
+            except Exception:
+                return []
+        return []
+    try:
+        return list(valores)
+    except Exception:
+        return []
+
+
+def _coletar_rotulos_indices_trace_payload(trace: dict[str, Any] | None) -> list[str]:
+    if not isinstance(trace, dict):
+        return []
+    if not _trace_mode_includes_markers(trace.get("mode")):
+        return []
+
+    for source_key in ("customdata", "ids", "text"):
+        valores = _extrair_sequencia_payload(trace.get(source_key))
+        if not valores:
+            continue
+        rotulos: list[str] = []
+        for item in valores:
+            if isinstance(item, (list, tuple)):
+                texto = next((str(sub).strip() for sub in item if str(sub).strip()), "")
+            elif isinstance(item, dict):
+                texto = str(
+                    item.get("indice")
+                    or item.get("Indice")
+                    or item.get("Índice")
+                    or "",
+                ).strip()
+            else:
+                texto = str(item or "").strip()
+            rotulos.append(texto)
+        if any(rotulos):
+            return rotulos
+    return []
+
+
+def _payload_grafico_com_indices(payload: Any) -> dict[str, Any] | None:
+    payload_sanitizado = sanitize_value(payload)
+    if not isinstance(payload_sanitizado, dict):
+        return None
+
+    clone = json.loads(json.dumps(payload_sanitizado))
+    data = clone.get("data")
+    if not isinstance(data, list):
+        return None
+
+    alterado = False
+    for trace in data:
+        if not isinstance(trace, dict):
+            continue
+        rotulos = _coletar_rotulos_indices_trace_payload(trace)
+        if not rotulos:
+            continue
+        mode_parts = [part.strip() for part in str(trace.get("mode") or "markers").split("+") if part.strip()]
+        if "text" not in mode_parts:
+            mode_parts.append("text")
+        if "markers" not in mode_parts:
+            mode_parts.append("markers")
+        trace["mode"] = "+".join(mode_parts)
+        trace["text"] = rotulos
+        trace["textposition"] = trace.get("textposition") or "top center"
+        base_textfont = trace.get("textfont") if isinstance(trace.get("textfont"), dict) else {}
+        trace["textfont"] = {
+            "size": 10,
+            "color": "#243746",
+            **base_textfont,
+        }
+        trace["cliponaxis"] = False
+        alterado = True
+
+    return clone if alterado else None
+
+
 def _is_rh_col(coluna: str) -> bool:
     return str(coluna or "").strip().upper() == "RH"
 
@@ -247,8 +342,8 @@ def _criar_mapa_knn_destaque(
         prefer_canvas=True,
         control_scale=True,
     )
-    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)
+    folium.TileLayer(tiles="CartoDB positron", name="Positron", control=True, show=True).add_to(mapa)
+    folium.TileLayer(tiles="OpenStreetMap", name="OpenStreetMap", control=True, show=False).add_to(mapa)
     add_bairros_layer(mapa, show=True)
 
     posicoes_set = {int(v) for v in (posicoes_knn or [])}
@@ -621,7 +716,7 @@ def _aplicar_jitter_pontos_knn(dados: pd.DataFrame) -> pd.DataFrame:
     if dados is None or dados.empty:
         return dados
     try:
-        return viz_app._aplicar_jitter_sobrepostos(
+        return aplicar_jitter_dados_mercado(
             dados,
             lat_col="__lat__",
             lon_col="__lon__",
@@ -711,7 +806,7 @@ def _criar_payload_mapa_avaliacao_localizacao(
         return None
 
     try:
-        dados_plot = viz_app._aplicar_jitter_sobrepostos(
+        dados_plot = aplicar_jitter_dados_mercado(
             dados,
             lat_col="__lat__",
             lon_col="__lon__",
@@ -1118,12 +1213,21 @@ def _payload_modelo_graficos(session: SessionState) -> dict[str, Any]:
         return cached
 
     figs = viz_app.gerar_todos_graficos(session.pacote_visualizacao)
+    grafico_obs_calc = figure_to_payload(figs.get("obs_calc"))
+    grafico_residuos = figure_to_payload(figs.get("residuos"))
+    grafico_histograma = figure_to_payload(figs.get("hist"))
+    grafico_cook = figure_to_payload(figs.get("cook"))
+    grafico_correlacao = figure_to_payload(figs.get("corr"))
     payload = {
-        "grafico_obs_calc": figure_to_payload(figs.get("obs_calc")),
-        "grafico_residuos": figure_to_payload(figs.get("residuos")),
-        "grafico_histograma": figure_to_payload(figs.get("hist")),
-        "grafico_cook": figure_to_payload(figs.get("cook")),
-        "grafico_correlacao": figure_to_payload(figs.get("corr")),
+        "grafico_obs_calc": grafico_obs_calc,
+        "grafico_obs_calc_com_indices": _payload_grafico_com_indices(grafico_obs_calc),
+        "grafico_residuos": grafico_residuos,
+        "grafico_residuos_com_indices": _payload_grafico_com_indices(grafico_residuos),
+        "grafico_histograma": grafico_histograma,
+        "grafico_histograma_com_indices": _payload_grafico_com_indices(grafico_histograma),
+        "grafico_cook": grafico_cook,
+        "grafico_cook_com_indices": _payload_grafico_com_indices(grafico_cook),
+        "grafico_correlacao": grafico_correlacao,
     }
     tabs_cache["graficos"] = payload
     return payload

frontend/src/api.js

@@ -210,6 +210,7 @@ export const api = {
     trabalhosTecnicosModelosModo = 'selecionados',
     trabalhosTecnicosProximidadeModo = 'sem_proximidade',
     trabalhosTecnicosRaioM = 1000,
+    agruparPontosMercado = false,
   ) {
     const avaliandos = Array.isArray(avaliando) ? avaliando : []
     const avaliandoUnico = !avaliandos.length && avaliando && typeof avaliando === 'object' ? avaliando : null
@@ -223,6 +224,7 @@ export const api = {
       trabalhos_tecnicos_modelos_modo: trabalhosTecnicosModelosModo,
       trabalhos_tecnicos_proximidade_modo: trabalhosTecnicosProximidadeModo,
       trabalhos_tecnicos_raio_m: trabalhosTecnicosRaioM,
+      agrupar_pontos_mercado: Boolean(agruparPontosMercado),
     })
   },
 

frontend/src/components/AvaliacaoTab.jsx

@@ -596,6 +596,7 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
   const [confirmarLimpezaAvaliacoes, setConfirmarLimpezaAvaliacoes] = useState(false)
   const [confirmarExclusaoCardId, setConfirmarExclusaoCardId] = useState('')
   const [avaliacaoPopup, setAvaliacaoPopup] = useState(null)
+  const [avaliacaoInfoModal, setAvaliacaoInfoModal] = useState(null)
   const [knnDetalheAberto, setKnnDetalheAberto] = useState(false)
   const [knnDetalheLoading, setKnnDetalheLoading] = useState(false)
   const [knnDetalheErro, setKnnDetalheErro] = useState('')
@@ -1230,6 +1231,20 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
     setAvaliacaoPopup(null)
   }
 
+  function onAbrirInfoAvaliacao(titulo, html) {
+    const conteudo = String(html || '').trim()
+    if (!conteudo) return
+    setAvaliacaoPopup(null)
+    setAvaliacaoInfoModal({
+      titulo: String(titulo || 'Detalhes do enquadramento'),
+      html: conteudo,
+    })
+  }
+
+  function onFecharInfoAvaliacao() {
+    setAvaliacaoInfoModal(null)
+  }
+
   async function onAbrirDetalheKnn(card, indice) {
     if (!sessionId || !card?.avaliacao?.valores_x) return
     setKnnDetalheAberto(true)
@@ -1955,6 +1970,7 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
                                   onMouseLeave={onPopupLeave}
                                   onFocus={(event) => onPopupEnter(event, popupPrecisaoHtml(aval))}
                                   onBlur={onPopupLeave}
+                                  onClick={() => onAbrirInfoAvaliacao('Detalhes da precisão', popupPrecisaoHtml(aval))}
                                 >
                                   ⓘ
                                 </button>
@@ -1972,6 +1988,7 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
                                   onMouseLeave={onPopupLeave}
                                   onFocus={(event) => onPopupEnter(event, popupFundamentacaoHtml(aval))}
                                   onBlur={onPopupLeave}
+                                  onClick={() => onAbrirInfoAvaliacao('Detalhes da fundamentação', popupFundamentacaoHtml(aval))}
                                 >
                                   ⓘ
                                 </button>
@@ -2001,6 +2018,27 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
           dangerouslySetInnerHTML={{ __html: avaliacaoPopup.html }}
         />
       ) : null}
+      {avaliacaoInfoModal?.html ? (
+        <div className="pesquisa-modal-backdrop" onClick={(event) => {
+          if (event.target === event.currentTarget) onFecharInfoAvaliacao()
+        }}
+        >
+          <div className="pesquisa-modal avaliacao-info-modal">
+            <div className="pesquisa-modal-head">
+              <div>
+                <h4>{avaliacaoInfoModal.titulo || 'Detalhes do enquadramento'}</h4>
+              </div>
+              <button type="button" className="pesquisa-modal-close" onClick={onFecharInfoAvaliacao}>
+                Fechar
+              </button>
+            </div>
+            <div
+              className="pesquisa-modal-body avaliacao-info-modal-body"
+              dangerouslySetInnerHTML={{ __html: avaliacaoInfoModal.html }}
+            />
+          </div>
+        </div>
+      ) : null}
       {avaliandoMapaAberto ? (
         <div className="pesquisa-modal-backdrop" onClick={(event) => {
           if (event.target === event.currentTarget) onFecharMapaAvaliando()

frontend/src/components/ElaboracaoTab.jsx

@@ -240,13 +240,56 @@ function formatCurrencyBr(value) {
   return num.toLocaleString('pt-BR', { style: 'currency', currency: 'BRL' })
 }
 
+const CURVA_NORMAL_PERCENTUAL_FAIXAS = [
+  { min: 64, max: 75 },
+  { min: 88, max: 95 },
+  { min: 95, max: 100 },
+]
+
+function parseCurvaNormalPercentual(value) {
+  const match = String(value || '').replace(',', '.').match(/-?\d+(?:\.\d+)?/)
+  if (!match) return null
+  const numero = Number(match[0])
+  return Number.isFinite(numero) ? numero : null
+}
+
+function formatCurvaNormalPercentuais(value) {
+  const raw = String(value || '').trim()
+  if (!raw || raw === '-') return raw || '-'
+
+  const partes = raw.split(',').map((item) => item.trim()).filter(Boolean)
+  if (!partes.length) return raw
+
+  return (
+    <span className="section14-curva-normal-percentuais">
+      {partes.map((parte, index) => {
+        const faixa = CURVA_NORMAL_PERCENTUAL_FAIXAS[index]
+        const percentual = parseCurvaNormalPercentual(parte)
+        const foraDaFaixa = Boolean(
+          faixa
+          && percentual !== null
+          && (percentual < faixa.min || percentual > faixa.max),
+        )
+        return (
+          <React.Fragment key={`curva-normal-percentual-${index}-${parte}`}>
+            {index > 0 ? <span>, </span> : null}
+            <span className={foraDaFaixa ? 'section14-percentual-fora-faixa' : undefined}>
+              {parte}
+            </span>
+          </React.Fragment>
+        )
+      })}
+    </span>
+  )
+}
+
 function Section14MetricRows({ rows }) {
   return (
     <div className="section14-field-grid">
       {(rows || []).map((row) => (
         <div key={row.label} className="section14-field-row">
           <span className="section14-field-label">{row.label}</span>
-          <span className="section14-field-value">{row.value}</span>
+          <span className="section14-field-value">{row.valueNode ?? row.value}</span>
         </div>
       ))}
     </div>
@@ -1656,6 +1699,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
   const [tabelaOutliersExcluidos, setTabelaOutliersExcluidos] = useState(null)
   const [outlierLimitWarning, setOutlierLimitWarning] = useState('')
   const [outlierUpdateWarning, setOutlierUpdateWarning] = useState('')
+  const [outlierUpdateWarningKind, setOutlierUpdateWarningKind] = useState('')
 
   const [camposAvaliacao, setCamposAvaliacao] = useState([])
   const valoresAvaliacaoRef = useRef({})
@@ -2019,7 +2063,11 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
         id: 'curva',
         label: 'Curva normal',
         rows: [
-          { label: 'Percentuais atingidos', value: diagnosticos.perc_resid || '-' },
+          {
+            label: 'Percentuais atingidos',
+            value: diagnosticos.perc_resid || '-',
+            valueNode: formatCurvaNormalPercentuais(diagnosticos.perc_resid),
+          },
           { label: 'Ideal 68%', value: 'aceitável entre 64% e 75%' },
           { label: 'Ideal 90%', value: 'aceitável entre 88% e 95%' },
           { label: 'Ideal 95%', value: 'aceitável entre 95% e 100%' },
@@ -3100,6 +3148,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     setTabelaOutliersExcluidos(null)
     setOutlierLimitWarning('')
     setOutlierUpdateWarning('')
+    setOutlierUpdateWarningKind('')
     setOutliersAnteriores([])
     setIteracao(1)
     setOutlierFiltrosAplicadosSnapshot(buildFiltrosSnapshot(defaultFiltros()))
@@ -3231,6 +3280,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
       setTabelaOutliersExcluidos(null)
       setOutlierLimitWarning('')
       setOutlierUpdateWarning('')
+      setOutlierUpdateWarningKind('')
       setCamposAvaliacao([])
       valoresAvaliacaoRef.current = {}
       setAvaliacaoFormVersion((prev) => prev + 1)
@@ -3328,6 +3378,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     setFit(resp)
     setOutlierLimitWarning('')
     setOutlierUpdateWarning('')
+    setOutlierUpdateWarningKind('')
     setSecao13InterativoFigura(null)
     setSecao13InterativoFiguraComIndices(null)
     setSecao13InterativoSelecionado('none')
@@ -3497,6 +3548,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     setTabelaOutliersExcluidos(null)
     setOutlierLimitWarning('')
     setOutlierUpdateWarning('')
+    setOutlierUpdateWarningKind('')
     setOutliersAnteriores([])
     setIteracao(1)
     setOutlierFiltrosAplicadosSnapshot(buildFiltrosSnapshot(defaultFiltros()))
@@ -3881,6 +3933,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     setTabelaOutliersExcluidos(null)
     setOutlierLimitWarning('')
     setOutlierUpdateWarning('')
+    setOutlierUpdateWarningKind('')
     setOutliersTexto('')
     setReincluirTexto('')
     setBaseChoices([])
@@ -4034,6 +4087,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
       setOutlierTextosAplicadosSnapshot(buildOutlierTextSnapshot('', ''))
       setOutlierLimitWarning('')
       setOutlierUpdateWarning('')
+      setOutlierUpdateWarningKind('')
       setCamposAvaliacao([])
       valoresAvaliacaoRef.current = {}
       setAvaliacaoFormVersion((prev) => prev + 1)
@@ -4210,6 +4264,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     if (!sessionId) return
     setOutlierLimitWarning('')
     setOutlierUpdateWarning('')
+    setOutlierUpdateWarningKind('')
     await withBusy(
       async () => {
         const filtrosValidos = (filtros || [])
@@ -4241,6 +4296,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     if (!sessionId) return
     setOutlierLimitWarning('')
     setOutlierUpdateWarning('')
+    setOutlierUpdateWarningKind('')
     await withBusy(
       async () => {
         const filtrosValidos = (filtros || [])
@@ -4328,6 +4384,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     if (!sessionId) return
     setOutlierLimitWarning('')
     setOutlierUpdateWarning('')
+    setOutlierUpdateWarningKind('')
     await withBusy(
       async () => {
         const resp = await api.restartOutlierIteration(sessionId, outliersInput, reincluirInput, grauCoef, grauF)
@@ -4350,6 +4407,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
             mensagemRegressao ||
             'Outliers atualizados, mas a regressão não fechou. Reinclua dados ou ajuste os filtros antes de continuar.',
           )
+          setOutlierUpdateWarningKind('regressao')
           setSection14Tab('diagnosticos')
           if (typeof window !== 'undefined') {
             window.setTimeout(() => {
@@ -4375,6 +4433,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
           mensagemRegressao ||
           'Outliers atualizados. Volte ao passo 12, Aplicação das Transformações, para ajustar novamente o modelo.',
         )
+        setOutlierUpdateWarningKind('success')
         await sleep(0)
         if (typeof window !== 'undefined') {
           window.setTimeout(() => {
@@ -4386,7 +4445,8 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
         suppressError: isOutlierLimitError,
         onError: (err) => {
           if (isOutlierLimitError(err)) {
-            setOutlierLimitWarning(getErrorMessage(err))
+            setOutlierUpdateWarning(getErrorMessage(err))
+            setOutlierUpdateWarningKind('micronumerosidade')
           }
         },
       },
@@ -4445,6 +4505,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
       setTabelaOutliersExcluidos(null)
       setOutlierLimitWarning('')
       setOutlierUpdateWarning('')
+      setOutlierUpdateWarningKind('')
       setOutlierFiltrosAplicadosSnapshot(buildFiltrosSnapshot(defaultFiltros()))
       setOutlierTextosAplicadosSnapshot(buildOutlierTextSnapshot('', ''))
       syncPeriodoDataMercadoFromContext(resp.contexto)
@@ -6072,7 +6133,13 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
                   Fazer download
                 </button>
               </div>
-              <DataTable table={dados} maxHeight={320} />
+              <DataTable
+                table={dados}
+                maxHeight={320}
+                highlightedRowIndices={outliersAnteriores}
+                highlightIndexColumn="_index"
+                highlightClassName="table-row-outlier-excluded"
+              />
             </div>
           </SectionBlock>
 
@@ -6674,7 +6741,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
                 {section10ManualOpen ? 'Ocultar ajustes manuais de transformação' : 'Proceder com as transformações manualmente'}
               </button>
             </div>
-            {!fit && outlierUpdateWarning ? (
+            {!fit && outlierUpdateWarning && outlierUpdateWarningKind === 'success' ? (
               <div className="outlier-update-warning">{outlierUpdateWarning}</div>
             ) : null}
             {!fit && outliersAnteriores.length > 0 && tabelaOutliersExcluidosAtual ? (
@@ -7063,7 +7130,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
           </SectionBlock>
 
           <SectionBlock step="14" title="Diagnóstico de Modelo" subtitle="Resumo diagnóstico e tabelas principais do ajuste.">
-            {outlierUpdateWarning && fit ? (
+            {outlierUpdateWarning && fit && outlierUpdateWarningKind === 'regressao' ? (
               <div className="outlier-update-warning">{outlierUpdateWarning}</div>
             ) : null}
             <div className="section14-tabs" role="tablist" aria-label="Conteúdos do diagnóstico do modelo">
@@ -7545,7 +7612,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
                   Reiniciar Modelo (Reincluir Todos)
                 </button>
               </div>
-              {outlierUpdateWarning && fit ? (
+              {outlierUpdateWarning && fit && ['regressao', 'micronumerosidade'].includes(outlierUpdateWarningKind) ? (
                 <div className="outlier-update-warning">{outlierUpdateWarning}</div>
               ) : null}
             </div>

frontend/src/components/LeafletMapFrame.jsx

@@ -1,4 +1,4 @@
-import React, { forwardRef, useEffect, useImperativeHandle, useRef, useState } from 'react'
+import React, { forwardRef, useCallback, useEffect, useImperativeHandle, useRef, useState } from 'react'
 import L from 'leaflet'
 import 'leaflet.fullscreen'
 import 'leaflet.heat'
@@ -37,6 +37,42 @@ function buildPopupErrorHtml(message) {
   )
 }
 
+function normalizeCssColor(value, fallback = '#607d8b') {
+  const text = String(value || '').trim()
+  if (/^#[0-9a-fA-F]{3,8}$/.test(text)) return text
+  if (/^rgba?\(\s*[\d.\s%,]+\)$/.test(text)) return text
+  return fallback
+}
+
+function buildGroupedMarketMarkerHtml(item, size = 22) {
+  const count = Math.max(2, Number(item?.count) || 2)
+  const color = normalizeCssColor(item?.color || item?.fill_color || '#607d8b')
+  const markerSize = Math.max(14, Math.min(38, Number(size) || 22))
+  const fontSize = Math.max(9, Math.min(12, markerSize * 0.38))
+  const borderSize = markerSize >= 24 ? 3 : 2
+  const haloSize = markerSize >= 24 ? 4 : 2
+  return (
+    `<div class="mesa-market-group-marker" style="--mesa-group-color:${color};--mesa-group-size:${markerSize}px;--mesa-group-font:${fontSize}px;--mesa-group-border:${borderSize}px;--mesa-group-halo:${haloSize}px;">`
+    + `<span>${escapeHtml(count > 99 ? '99+' : count)}</span>`
+    + '</div>'
+  )
+}
+
+function buildGroupedMarketIcon(item, size = 22) {
+  const markerSize = Math.max(14, Math.min(38, Number(size) || 22))
+  return L.divIcon({
+    html: buildGroupedMarketMarkerHtml(item, markerSize),
+    iconSize: [markerSize, markerSize],
+    iconAnchor: [markerSize / 2, markerSize / 2],
+    className: 'mesa-market-group-icon',
+  })
+}
+
+function hasValidRowId(value) {
+  if (value === null || value === undefined || value === '') return false
+  return Number.isInteger(Number(value)) && Number(value) >= 0
+}
+
 function parseFiniteCoordinate(value, min, max) {
   if (value === null || value === undefined) return null
   const text = String(value).trim().replace(',', '.')
@@ -336,7 +372,7 @@ function buildLegacyOverlayLayers(payload) {
       show: true,
       points: payload.market_points.map((item) => ({
         ...item,
-        popup_request: Number.isFinite(Number(item?.row_id))
+        popup_request: !item?.grouped && hasValidRowId(item?.row_id)
           ? { kind: 'visualizacao_row', row_id: Number(item.row_id) }
           : null,
       })),
@@ -685,10 +721,12 @@ async function buildHighResolutionSelectionBlob({
 
     const bairrosPane = exportMap.createPane('mesa-bairros-pane')
     const marketPane = exportMap.createPane('mesa-market-pane')
+    const marketGroupPane = exportMap.createPane('mesa-market-group-pane')
     const trabalhosPane = exportMap.createPane('mesa-trabalhos-pane')
     const indicesPane = exportMap.createPane('mesa-indices-pane')
     bairrosPane.style.zIndex = '410'
     marketPane.style.zIndex = '420'
+    marketGroupPane.style.zIndex = '425'
     trabalhosPane.style.zIndex = '430'
     indicesPane.style.zIndex = '440'
 
@@ -745,6 +783,20 @@ async function buildHighResolutionSelectionBlob({
       items.forEach((item) => {
         const latlng = parseLatLonPair(item?.lat, item?.lon)
         if (!latlng) return
+        if (item?.grouped) {
+          const marker = L.marker(latlng, {
+            icon: buildGroupedMarketIcon(item, 16),
+            pane: String(item?.pane || 'mesa-market-group-pane'),
+            interactive: false,
+            keyboard: false,
+            bubblingMouseEvents: false,
+          })
+          marker.options.mesaBaseRadius = Number(item?.base_radius) || 4
+          marker.options.mesaGroupedMarketMarker = true
+          marker.options.mesaGroupedMarketItem = item
+          layerGroup.addLayer(marker)
+          return
+        }
         const marker = L.circleMarker(latlng, {
           renderer: canvasRenderer,
           pane: String(item?.pane || 'mesa-market-pane'),
@@ -971,7 +1023,10 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
   const mapRef = useRef(null)
   const payloadRef = useRef(payload)
   const popupCacheRef = useRef(new Map())
+  const popupLoaderRef = useRef(null)
+  const groupSelectionMarkerRef = useRef(null)
   const [runtimeError, setRuntimeError] = useState('')
+  const [groupSelection, setGroupSelection] = useState(null)
 
   payloadRef.current = payload
 
@@ -1016,10 +1071,26 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
     },
   }), [])
 
+  const closeGroupSelection = useCallback(() => {
+    setGroupSelection(null)
+    groupSelectionMarkerRef.current = null
+  }, [])
+
+  const selectGroupedMarketItem = useCallback((item) => {
+    const popupRequest = item?.popup_request
+    const marker = groupSelectionMarkerRef.current
+    const loader = popupLoaderRef.current
+    if (!popupRequest || !marker || !loader) return
+    setGroupSelection(null)
+    void loader(popupRequest, marker)
+  }, [])
+
   useEffect(() => {
     if (!hostRef.current || !payload) return undefined
     let disposed = false
     setRuntimeError('')
+    setGroupSelection(null)
+    groupSelectionMarkerRef.current = null
     hostRef.current.innerHTML = ''
 
     const map = L.map(hostRef.current, {
@@ -1030,10 +1101,12 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
     let restoreMapInteractions = null
     const bairrosPane = map.createPane('mesa-bairros-pane')
     const marketPane = map.createPane('mesa-market-pane')
+    const marketGroupPane = map.createPane('mesa-market-group-pane')
     const trabalhosPane = map.createPane('mesa-trabalhos-pane')
     const indicesPane = map.createPane('mesa-indices-pane')
     bairrosPane.style.zIndex = '410'
     marketPane.style.zIndex = '420'
+    marketGroupPane.style.zIndex = '425'
     trabalhosPane.style.zIndex = '430'
     indicesPane.style.zIndex = '440'
 
@@ -1046,9 +1119,7 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
 
     ;(payload.tile_layers || []).forEach((layerDef, index) => {
       const tileLayer = L.tileLayer(String(layerDef?.url || ''), {
-        attribution: index === 0
-          ? '&copy; OpenStreetMap contributors'
-          : '&copy; OpenStreetMap contributors &copy; CARTO',
+        attribution: String(layerDef?.attribution || '&copy; OpenStreetMap contributors'),
         crossOrigin: 'anonymous',
         detectRetina: true,
       })
@@ -1101,17 +1172,29 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
       responsivePointContainers.forEach((container) => {
         if (!container || typeof container.eachLayer !== 'function') return
         container.eachLayer((layer) => {
-          if (typeof layer.setRadius !== 'function') return
           const base = Number(layer.options?.mesaBaseRadius || layer.options?.radius || 4)
           const dynamicMin = Math.max(minRadius, base * floorScale)
           const dynamicMax = Math.max(dynamicMin + 0.1, Math.min(maxRadius, base * 8.0))
-          layer.setRadius(clamp(base * expFactor, dynamicMin, dynamicMax))
+          const radius = clamp(base * expFactor, dynamicMin, dynamicMax)
+          if (layer.options?.mesaGroupedMarketMarker && typeof layer.setIcon === 'function') {
+            const iconSize = Math.max(16, Math.min(36, Math.round(radius * 2.35)))
+            layer.setIcon(buildGroupedMarketIcon(layer.options.mesaGroupedMarketItem || {}, iconSize))
+            return
+          }
+          if (typeof layer.setRadius !== 'function') return
+          layer.setRadius(radius)
         })
       })
     }
 
-    async function carregarPopupVisualizacao(rowId, layer) {
-      const cacheKey = String(rowId)
+    async function carregarPopupRegistro(popupRequest, layer) {
+      const kind = String(popupRequest?.kind || '').trim()
+      const rowId = Number(popupRequest?.row_id)
+      const source = String(popupRequest?.source || '').trim()
+      const endpoint = kind === 'elaboracao_row'
+        ? '/api/elaboracao/map/popup'
+        : '/api/visualizacao/map/popup'
+      const cacheKey = `${kind || 'visualizacao_row'}:${source || 'default'}:${rowId}`
       const cached = popupCacheRef.current.get(cacheKey)
       if (cached) {
         const cachedHtml = typeof cached === 'string' ? cached : String(cached?.html || '')
@@ -1131,16 +1214,20 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
       ).openPopup()
 
       try {
-        const response = await fetch(apiUrl('/api/visualizacao/map/popup'), {
+        const body = {
+          session_id: sessionId,
+          row_id: rowId,
+        }
+        if (source) {
+          body.source = source
+        }
+        const response = await fetch(apiUrl(endpoint), {
           method: 'POST',
           headers: {
             'Content-Type': 'application/json',
             ...(getAuthToken() ? { 'X-Auth-Token': getAuthToken() } : {}),
           },
-          body: JSON.stringify({
-            session_id: sessionId,
-            row_id: rowId,
-          }),
+          body: JSON.stringify(body),
         })
         const payloadResp = await readJsonSafely(response)
         if (!response.ok) {
@@ -1167,6 +1254,8 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
       }
     }
 
+    popupLoaderRef.current = carregarPopupRegistro
+
     function bindPointPopup(marker, item) {
       const popupHtml = String(item?.popup_html || '').trim()
       if (popupHtml) {
@@ -1175,9 +1264,14 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
       }
 
       const popupRequest = item?.popup_request
-      if (popupRequest?.kind === 'visualizacao_row' && Number.isFinite(Number(popupRequest?.row_id)) && sessionId) {
+      const popupKind = String(popupRequest?.kind || '').trim()
+      if (
+        ['visualizacao_row', 'elaboracao_row'].includes(popupKind)
+        && Number.isFinite(Number(popupRequest?.row_id))
+        && sessionId
+      ) {
         marker.on('click', () => {
-          void carregarPopupVisualizacao(Number(popupRequest.row_id), marker)
+          void carregarPopupRegistro(popupRequest, marker)
         })
       }
     }
@@ -1378,6 +1472,36 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
       items.forEach((item) => {
         const latlng = parseLatLonPair(item?.lat, item?.lon)
         if (!latlng) return
+        if (item?.grouped) {
+          const marker = L.marker(latlng, {
+            icon: buildGroupedMarketIcon(item, 16),
+            pane: String(item?.pane || 'mesa-market-group-pane'),
+            interactive: item?.interactive !== false,
+            keyboard: item?.keyboard !== false,
+            bubblingMouseEvents: false,
+          })
+          marker.options.mesaBaseRadius = Number(item?.base_radius) || 4
+          marker.options.mesaGroupedMarketMarker = true
+          marker.options.mesaGroupedMarketItem = item
+          const tooltipHtml = String(item?.tooltip_html || '').trim()
+          if (tooltipHtml) {
+            marker.bindTooltip(tooltipHtml, { sticky: item?.tooltip_sticky !== false })
+          }
+          marker.on('click', () => {
+            map.closePopup()
+            marker.unbindPopup()
+            const groupItems = Array.isArray(item?.group_items) ? item.group_items : []
+            if (!groupItems.length) return
+            groupSelectionMarkerRef.current = marker
+            setGroupSelection({
+              title: String(item?.group_title || `${groupItems.length} dados neste local`),
+              count: Number(item?.count) || groupItems.length,
+              items: groupItems,
+            })
+          })
+          layerGroup.addLayer(marker)
+          return
+        }
         const marker = L.circleMarker(latlng, {
           renderer: canvasRenderer,
           pane: String(item?.pane || 'mesa-market-pane'),
@@ -1937,6 +2061,10 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
       }
       disposed = true
       restoreMapInteractions?.()
+      if (popupLoaderRef.current === carregarPopupRegistro) {
+        popupLoaderRef.current = null
+      }
+      groupSelectionMarkerRef.current = null
       if (mapRef.current === map) {
         mapRef.current = null
       }
@@ -1948,6 +2076,47 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
     <div className="map-frame leaflet-map-host">
       <div ref={hostRef} className="leaflet-map-canvas" />
       {runtimeError ? <div className="leaflet-map-runtime-error">{runtimeError}</div> : null}
+      {groupSelection ? (
+        <div className="leaflet-market-group-modal-backdrop" onClick={closeGroupSelection}>
+          <div
+            className="leaflet-market-group-modal"
+            role="dialog"
+            aria-modal="true"
+            aria-label="Selecionar dado de mercado"
+            onClick={(event) => event.stopPropagation()}
+          >
+            <div className="leaflet-market-group-modal-head">
+              <div>
+                <strong>{groupSelection.title}</strong>
+                <span>{Number(groupSelection.count) || groupSelection.items?.length || 0} registros sobrepostos</span>
+              </div>
+              <button type="button" onClick={closeGroupSelection} aria-label="Fechar">×</button>
+            </div>
+            <div className="leaflet-market-group-list">
+              {(groupSelection.items || []).map((item, index) => {
+                const disabled = !item?.popup_request
+                return (
+                  <button
+                    key={`${item?.indice ?? index}-${index}`}
+                    type="button"
+                    className="leaflet-market-group-option"
+                    onClick={() => selectGroupedMarketItem(item)}
+                    disabled={disabled}
+                  >
+                    <span>{item?.label || `Índice ${item?.indice ?? index + 1}`}</span>
+                    {item?.value ? (
+                      <small>
+                        {item?.value_label ? `${item.value_label}: ` : ''}
+                        {item.value}
+                      </small>
+                    ) : null}
+                  </button>
+                )
+              })}
+            </div>
+          </div>
+        </div>
+      ) : null}
     </div>
   )
 })

frontend/src/components/PesquisaTab.jsx

@@ -1015,6 +1015,7 @@ export default function PesquisaTab({
   const [mapaHtmls, setMapaHtmls] = useState({ pontos: '', cobertura: '' })
   const [mapaPayloads, setMapaPayloads] = useState({ pontos: null, cobertura: null })
   const [mapaModoExibicao, setMapaModoExibicao] = useState('pontos')
+  const [mapaAgruparPontosMercado, setMapaAgruparPontosMercado] = useState(false)
   const [mapaTrabalhosTecnicosModelosModo, setMapaTrabalhosTecnicosModelosModo] = useState('selecionados_e_outras_versoes')
   const [mapaTrabalhosTecnicosProximidadeModo, setMapaTrabalhosTecnicosProximidadeModo] = useState('sem_proximidade')
   const [mapaTrabalhosTecnicosRaio, setMapaTrabalhosTecnicosRaio] = useState(1000)
@@ -1039,9 +1040,13 @@ export default function PesquisaTab({
   const [modeloAbertoTrabalhosTecnicosModelosModo, setModeloAbertoTrabalhosTecnicosModelosModo] = useState(MODELO_ABERTO_TRABALHOS_TECNICOS_PADRAO)
   const [modeloAbertoTrabalhosTecnicos, setModeloAbertoTrabalhosTecnicos] = useState([])
   const [modeloAbertoPlotObsCalc, setModeloAbertoPlotObsCalc] = useState(null)
+  const [modeloAbertoPlotObsCalcIndices, setModeloAbertoPlotObsCalcIndices] = useState(null)
   const [modeloAbertoPlotResiduos, setModeloAbertoPlotResiduos] = useState(null)
+  const [modeloAbertoPlotResiduosIndices, setModeloAbertoPlotResiduosIndices] = useState(null)
   const [modeloAbertoPlotHistograma, setModeloAbertoPlotHistograma] = useState(null)
+  const [modeloAbertoPlotHistogramaIndices, setModeloAbertoPlotHistogramaIndices] = useState(null)
   const [modeloAbertoPlotCook, setModeloAbertoPlotCook] = useState(null)
+  const [modeloAbertoPlotCookIndices, setModeloAbertoPlotCookIndices] = useState(null)
   const [modeloAbertoPlotCorr, setModeloAbertoPlotCorr] = useState(null)
   const [modeloAbertoLoadedTabs, setModeloAbertoLoadedTabs] = useState({})
   const [modeloAbertoLoadingTabs, setModeloAbertoLoadingTabs] = useState({})
@@ -1136,6 +1141,7 @@ export default function PesquisaTab({
     setMapaStatus('')
     setMapaError('')
     setMapaModoExibicao('pontos')
+    setMapaAgruparPontosMercado(false)
     mapaTrabalhosTecnicosConfigRef.current = ''
   }
 
@@ -1166,6 +1172,7 @@ export default function PesquisaTab({
   async function carregarMapaPesquisa(ids, overrides = {}) {
     const idsValidos = (ids || []).map((item) => String(item || '').trim()).filter(Boolean)
     const modoExibicaoSolicitado = String(overrides.modoExibicao || mapaModoExibicao || 'pontos')
+    const agruparPontosMercadoSolicitado = Boolean(overrides.agruparPontosMercado ?? mapaAgruparPontosMercado)
     const trabalhosTecnicosConfig = getMapaTrabalhosTecnicosRequestConfig(overrides)
 
     if (!idsValidos.length) {
@@ -1188,6 +1195,7 @@ export default function PesquisaTab({
         trabalhosTecnicosConfig.modelosModo,
         trabalhosTecnicosConfig.proximidadeModo,
         trabalhosTecnicosConfig.raio,
+        agruparPontosMercadoSolicitado,
       )
       const mapaHtmlSolicitado = String(
         response.mapa_html
@@ -1491,9 +1499,13 @@ export default function PesquisaTab({
     setModeloAbertoTrabalhosTecnicosModelosModo(MODELO_ABERTO_TRABALHOS_TECNICOS_PADRAO)
     setModeloAbertoTrabalhosTecnicos([])
     setModeloAbertoPlotObsCalc(null)
+    setModeloAbertoPlotObsCalcIndices(null)
     setModeloAbertoPlotResiduos(null)
+    setModeloAbertoPlotResiduosIndices(null)
     setModeloAbertoPlotHistograma(null)
+    setModeloAbertoPlotHistogramaIndices(null)
     setModeloAbertoPlotCook(null)
+    setModeloAbertoPlotCookIndices(null)
     setModeloAbertoPlotCorr(null)
     setModeloAbertoLoadedTabs({})
     setModeloAbertoLoadingTabs({})
@@ -1529,9 +1541,13 @@ export default function PesquisaTab({
     }
     if (key === 'graficos') {
       setModeloAbertoPlotObsCalc(resp?.grafico_obs_calc || null)
+      setModeloAbertoPlotObsCalcIndices(resp?.grafico_obs_calc_com_indices || null)
       setModeloAbertoPlotResiduos(resp?.grafico_residuos || null)
+      setModeloAbertoPlotResiduosIndices(resp?.grafico_residuos_com_indices || null)
       setModeloAbertoPlotHistograma(resp?.grafico_histograma || null)
+      setModeloAbertoPlotHistogramaIndices(resp?.grafico_histograma_com_indices || null)
       setModeloAbertoPlotCook(resp?.grafico_cook || null)
+      setModeloAbertoPlotCookIndices(resp?.grafico_cook_com_indices || null)
       setModeloAbertoPlotCorr(resp?.grafico_correlacao || null)
       return
     }
@@ -1723,6 +1739,18 @@ export default function PesquisaTab({
     void carregarMapaPesquisa(selectedIds, { modoExibicao: nextModo })
   }
 
+  function onMapaAgrupamentoPontosChange(event) {
+    const nextAgrupar = String(event?.target?.value || 'individual') === 'agrupado'
+    setMapaAgruparPontosMercado(nextAgrupar)
+    setMapaHtmls((prev) => ({ ...prev, pontos: '' }))
+    setMapaPayloads((prev) => ({ ...prev, pontos: null }))
+    if (!mapaFoiGerado || mapaLoading || !selectedIds.length || mapaModoExibicao !== 'pontos') return
+    void carregarMapaPesquisa(selectedIds, {
+      modoExibicao: 'pontos',
+      agruparPontosMercado: nextAgrupar,
+    })
+  }
+
   async function onAdminConfigSalva() {
     if (pesquisaInicializada) {
       await buscarModelos(filters, avaliandosGeolocalizados)
@@ -1942,10 +1970,31 @@ export default function PesquisaTab({
               modeloAbertoLoadedTabs.graficos ? (
                 <>
                 <div className="plot-grid-2-fixed">
-                  <PlotFigure figure={modeloAbertoPlotObsCalc} title="Obs x Calc" />
-                  <PlotFigure figure={modeloAbertoPlotResiduos} title="Resíduos" />
-                  <PlotFigure figure={modeloAbertoPlotHistograma} title="Histograma" />
-                  <PlotFigure figure={modeloAbertoPlotCook} title="Cook" forceHideLegend />
+                  <PlotFigure
+                    figure={modeloAbertoPlotObsCalc}
+                    indexedFigure={modeloAbertoPlotObsCalcIndices}
+                    title="Obs x Calc"
+                    showPointIndexToggle={Boolean(modeloAbertoPlotObsCalcIndices)}
+                  />
+                  <PlotFigure
+                    figure={modeloAbertoPlotResiduos}
+                    indexedFigure={modeloAbertoPlotResiduosIndices}
+                    title="Resíduos"
+                    showPointIndexToggle={Boolean(modeloAbertoPlotResiduosIndices)}
+                  />
+                  <PlotFigure
+                    figure={modeloAbertoPlotHistograma}
+                    indexedFigure={modeloAbertoPlotHistogramaIndices}
+                    title="Histograma"
+                    showPointIndexToggle={Boolean(modeloAbertoPlotHistogramaIndices)}
+                  />
+                  <PlotFigure
+                    figure={modeloAbertoPlotCook}
+                    indexedFigure={modeloAbertoPlotCookIndices}
+                    title="Cook"
+                    forceHideLegend
+                    showPointIndexToggle={Boolean(modeloAbertoPlotCookIndices)}
+                  />
                 </div>
                 <div className="plot-full-width">
                   <PlotFigure figure={modeloAbertoPlotCorr} title="Correlação" className="plot-correlation-card" />
@@ -2454,6 +2503,21 @@ export default function PesquisaTab({
                 </select>
               </label>
 
+              {mapaModoExibicao === 'pontos' ? (
+                <label className="pesquisa-field pesquisa-mapa-agrupamento-field">
+                  Pontos sobrepostos
+                  <select
+                    {...buildSelectAutofillProps('mapaAgrupamentoPontos')}
+                    value={mapaAgruparPontosMercado ? 'agrupado' : 'individual'}
+                    onChange={onMapaAgrupamentoPontosChange}
+                    disabled={mapaLoading || !selectedIds.length}
+                  >
+                    <option value="individual">Mostrar individualmente</option>
+                    <option value="agrupado">Agrupar por coordenada</option>
+                  </select>
+                </label>
+              ) : null}
+
               <label className="pesquisa-field pesquisa-mapa-trabalhos-field">
                 Exibição dos trabalhos técnicos
                 <select

frontend/src/components/RepositorioTab.jsx

@@ -180,9 +180,13 @@ export default function RepositorioTab({
   const [modeloAbertoTrabalhosTecnicosModelosModo, setModeloAbertoTrabalhosTecnicosModelosModo] = useState(MODELO_ABERTO_TRABALHOS_TECNICOS_PADRAO)
   const [modeloAbertoTrabalhosTecnicos, setModeloAbertoTrabalhosTecnicos] = useState([])
   const [modeloAbertoPlotObsCalc, setModeloAbertoPlotObsCalc] = useState(null)
+  const [modeloAbertoPlotObsCalcIndices, setModeloAbertoPlotObsCalcIndices] = useState(null)
   const [modeloAbertoPlotResiduos, setModeloAbertoPlotResiduos] = useState(null)
+  const [modeloAbertoPlotResiduosIndices, setModeloAbertoPlotResiduosIndices] = useState(null)
   const [modeloAbertoPlotHistograma, setModeloAbertoPlotHistograma] = useState(null)
+  const [modeloAbertoPlotHistogramaIndices, setModeloAbertoPlotHistogramaIndices] = useState(null)
   const [modeloAbertoPlotCook, setModeloAbertoPlotCook] = useState(null)
+  const [modeloAbertoPlotCookIndices, setModeloAbertoPlotCookIndices] = useState(null)
   const [modeloAbertoPlotCorr, setModeloAbertoPlotCorr] = useState(null)
   const [modeloAbertoLoadedTabs, setModeloAbertoLoadedTabs] = useState({})
   const [modeloAbertoLoadingTabs, setModeloAbertoLoadingTabs] = useState({})
@@ -356,9 +360,13 @@ export default function RepositorioTab({
     setModeloAbertoTrabalhosTecnicosModelosModo(MODELO_ABERTO_TRABALHOS_TECNICOS_PADRAO)
     setModeloAbertoTrabalhosTecnicos([])
     setModeloAbertoPlotObsCalc(null)
+    setModeloAbertoPlotObsCalcIndices(null)
     setModeloAbertoPlotResiduos(null)
+    setModeloAbertoPlotResiduosIndices(null)
     setModeloAbertoPlotHistograma(null)
+    setModeloAbertoPlotHistogramaIndices(null)
     setModeloAbertoPlotCook(null)
+    setModeloAbertoPlotCookIndices(null)
     setModeloAbertoPlotCorr(null)
     setModeloAbertoLoadedTabs({})
     setModeloAbertoLoadingTabs({})
@@ -394,9 +402,13 @@ export default function RepositorioTab({
     }
     if (secaoNormalizada === 'graficos') {
       setModeloAbertoPlotObsCalc(resp?.grafico_obs_calc || null)
+      setModeloAbertoPlotObsCalcIndices(resp?.grafico_obs_calc_com_indices || null)
       setModeloAbertoPlotResiduos(resp?.grafico_residuos || null)
+      setModeloAbertoPlotResiduosIndices(resp?.grafico_residuos_com_indices || null)
       setModeloAbertoPlotHistograma(resp?.grafico_histograma || null)
+      setModeloAbertoPlotHistogramaIndices(resp?.grafico_histograma_com_indices || null)
       setModeloAbertoPlotCook(resp?.grafico_cook || null)
+      setModeloAbertoPlotCookIndices(resp?.grafico_cook_com_indices || null)
       setModeloAbertoPlotCorr(resp?.grafico_correlacao || null)
       return
     }
@@ -755,10 +767,31 @@ export default function RepositorioTab({
               activeTabLoaded ? (
                 <>
                   <div className="plot-grid-2-fixed">
-                    <PlotFigure figure={modeloAbertoPlotObsCalc} title="Obs x Calc" />
-                    <PlotFigure figure={modeloAbertoPlotResiduos} title="Resíduos" />
-                    <PlotFigure figure={modeloAbertoPlotHistograma} title="Histograma" />
-                    <PlotFigure figure={modeloAbertoPlotCook} title="Cook" forceHideLegend />
+                    <PlotFigure
+                      figure={modeloAbertoPlotObsCalc}
+                      indexedFigure={modeloAbertoPlotObsCalcIndices}
+                      title="Obs x Calc"
+                      showPointIndexToggle={Boolean(modeloAbertoPlotObsCalcIndices)}
+                    />
+                    <PlotFigure
+                      figure={modeloAbertoPlotResiduos}
+                      indexedFigure={modeloAbertoPlotResiduosIndices}
+                      title="Resíduos"
+                      showPointIndexToggle={Boolean(modeloAbertoPlotResiduosIndices)}
+                    />
+                    <PlotFigure
+                      figure={modeloAbertoPlotHistograma}
+                      indexedFigure={modeloAbertoPlotHistogramaIndices}
+                      title="Histograma"
+                      showPointIndexToggle={Boolean(modeloAbertoPlotHistogramaIndices)}
+                    />
+                    <PlotFigure
+                      figure={modeloAbertoPlotCook}
+                      indexedFigure={modeloAbertoPlotCookIndices}
+                      title="Cook"
+                      forceHideLegend
+                      showPointIndexToggle={Boolean(modeloAbertoPlotCookIndices)}
+                    />
                   </div>
                   <div className="plot-full-width">
                     <PlotFigure figure={modeloAbertoPlotCorr} title="Correlação" className="plot-correlation-card" />

frontend/src/styles.css

@@ -191,7 +191,7 @@ textarea {
 .tab-pill {
   text-align: center;
   border: 1px solid #d2deea;
-  border-radius: 10px;
+  border-radius: 8px;
   background: linear-gradient(180deg, #f7fafd 0%, #edf3f8 100%);
   padding: 8px 12px;
   color: #32475d;
@@ -3125,6 +3125,12 @@ button.pesquisa-coluna-remove:hover {
   margin: 0;
 }
 
+.pesquisa-mapa-agrupamento-field {
+  min-width: 0;
+  max-width: none;
+  margin: 0;
+}
+
 .pesquisa-mapa-trabalhos-field {
   min-width: 0;
   max-width: none;
@@ -4261,12 +4267,17 @@ button.pesquisa-coluna-remove:hover {
   display: inline-flex;
   align-items: center;
   justify-content: center;
-  cursor: help;
+  cursor: pointer;
   font-size: 0.85em;
   line-height: 1;
   opacity: 0.7;
 }
 
+.avaliacao-popup-trigger:hover,
+.avaliacao-popup-trigger:focus-visible {
+  opacity: 1;
+}
+
 .avaliacao-popup-overlay {
   position: fixed;
   z-index: 3600;
@@ -4287,6 +4298,18 @@ button.pesquisa-coluna-remove:hover {
   pointer-events: none;
 }
 
+.avaliacao-info-modal {
+  width: min(680px, 100%);
+}
+
+.avaliacao-info-modal-body {
+  color: #333;
+  font-size: 12px;
+  font-weight: 400;
+  line-height: 1.4;
+  text-align: left;
+}
+
 .avaliacao-knn-modal {
   width: min(1180px, 100%);
 }
@@ -5595,6 +5618,11 @@ button.import-preview-clear-btn {
   text-align: right;
 }
 
+.section14-percentual-fora-faixa {
+  color: var(--danger);
+  font-weight: 800;
+}
+
 .section14-table-head {
   display: flex;
   align-items: center;
@@ -5645,6 +5673,136 @@ button.import-preview-clear-btn {
   z-index: 600;
 }
 
+.mesa-market-group-icon {
+  background: transparent;
+  border: 0;
+}
+
+.mesa-market-group-marker {
+  width: var(--mesa-group-size, 22px);
+  height: var(--mesa-group-size, 22px);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border: var(--mesa-group-border, 2px) solid #243746;
+  border-radius: 50%;
+  background: var(--mesa-group-color, #607d8b);
+  color: #fff;
+  box-shadow: 0 0 0 var(--mesa-group-halo, 2px) rgba(36, 55, 70, 0.18), 0 6px 16px rgba(23, 39, 55, 0.26);
+  font-size: var(--mesa-group-font, 10px);
+  font-weight: 800;
+  line-height: 1;
+}
+
+.mesa-market-group-marker span {
+  min-width: calc(var(--mesa-group-size, 22px) * 0.48);
+  padding: 1px 2px;
+  border-radius: 999px;
+  background: rgba(20, 33, 45, 0.42);
+  pointer-events: none;
+  text-align: center;
+}
+
+.leaflet-market-group-modal-backdrop {
+  position: absolute;
+  inset: 0;
+  z-index: 900;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 24px;
+  background: rgba(18, 30, 42, 0.24);
+}
+
+.leaflet-market-group-modal {
+  width: min(420px, 100%);
+  max-height: min(460px, calc(100% - 32px));
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  border: 1px solid rgba(186, 201, 214, 0.95);
+  border-radius: 8px;
+  background: #fff;
+  box-shadow: 0 18px 46px rgba(22, 39, 58, 0.26);
+}
+
+.leaflet-market-group-modal-head {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 16px;
+  padding: 14px 16px;
+  border-bottom: 1px solid #e3ebf2;
+  background: #f6f9fc;
+  color: #243746;
+}
+
+.leaflet-market-group-modal-head strong,
+.leaflet-market-group-modal-head span {
+  display: block;
+}
+
+.leaflet-market-group-modal-head strong {
+  font-size: 0.92rem;
+}
+
+.leaflet-market-group-modal-head span {
+  margin-top: 3px;
+  color: #627487;
+  font-size: 0.78rem;
+}
+
+.leaflet-market-group-modal-head button {
+  width: 28px;
+  height: 28px;
+  border: 1px solid #cbd8e4;
+  border-radius: 50%;
+  background: #fff;
+  color: #40576d;
+  cursor: pointer;
+  font-size: 20px;
+  line-height: 1;
+}
+
+.leaflet-market-group-list {
+  overflow-y: auto;
+  padding: 8px;
+}
+
+.leaflet-market-group-option {
+  width: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 9px 10px;
+  border: 0;
+  border-bottom: 1px solid #edf2f6;
+  background: #fff;
+  color: #243746;
+  cursor: pointer;
+  text-align: left;
+}
+
+.leaflet-market-group-option:hover {
+  background: #eef5fb;
+}
+
+.leaflet-market-group-option span {
+  font-weight: 700;
+}
+
+.leaflet-market-group-option small {
+  color: #627487;
+  font-size: 0.74rem;
+  text-align: right;
+}
+
+.leaflet-market-group-option:disabled {
+  cursor: not-allowed;
+  opacity: 0.5;
+}
+
 .mesa-leaflet-legend {
   min-width: 168px;
   border-radius: 12px;
@@ -6052,7 +6210,7 @@ button.import-preview-clear-btn {
 }
 
 .table-wrapper tr:hover td {
-  background: #fff8ef;
+  background: #eef4fa;
 }
 
 .table-wrapper tr.table-row-highlight td {
@@ -6063,6 +6221,16 @@ button.import-preview-clear-btn {
   background: #ffe882;
 }
 
+.table-wrapper tr.table-row-outlier-excluded td {
+  background: #fde8e6;
+  color: #8a1f17;
+  font-weight: 600;
+}
+
+.table-wrapper tr.table-row-outlier-excluded:hover td {
+  background: #fbd3cf;
+}
+
 .table-cell-clamp,
 .avaliacao-knn-table-cell {
   display: -webkit-box;