Enhance avaliacao map and KNN interactions

backend/app/api/pesquisa.py

@@ -85,7 +85,7 @@ def pesquisar_admin_config_salvar(payload: PesquisaAdminConfigPayload) -> dict:
 
 
 @router.get("/logradouros-eixos")
-def pesquisar_logradouros_eixos(limite: int = Query(2000, ge=1, le=20000)) -> dict:
+def pesquisar_logradouros_eixos(limite: int = Query(20000, ge=1, le=20000)) -> dict:
     return listar_logradouros_eixos(limite=limite)
 
 

backend/app/api/visualizacao.py

@@ -51,6 +51,11 @@ class AvaliacaoKnnDetalhesPayload(SessionPayload):
     avaliando_lon: float | None = None
 
 
+class AvaliacaoMapaLocalizacaoPayload(SessionPayload):
+    avaliando_lat: float | None = None
+    avaliando_lon: float | None = None
+
+
 class AvaliacaoDeletePayload(SessionPayload):
     indice: str | None = None
     indice_base: str | None = None
@@ -209,6 +214,17 @@ def evaluation_knn_details(payload: AvaliacaoKnnDetalhesPayload, request: Reques
     return resposta
 
 
+@router.post("/evaluation/location-map")
+def evaluation_location_map(payload: AvaliacaoMapaLocalizacaoPayload, request: Request) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    auth_service.require_user(request)
+    return visualizacao_service.mapa_localizacao_avaliacao(
+        session,
+        payload.avaliando_lat,
+        payload.avaliando_lon,
+    )
+
+
 @router.post("/evaluation/clear")
 def evaluation_clear(payload: SessionPayload) -> dict[str, Any]:
     session = session_store.get(payload.session_id)

backend/app/services/pesquisa_service.py

@@ -2986,11 +2986,12 @@ def _carregar_catalogo_vias() -> list[dict[str, Any]]:
             prefixo = str(row.get("NMIDEPRE") or "").strip()
             abreviado = str(row.get("NMIDEABR") or "").strip()
             categoria = str(row.get("CDIDECAT") or "").strip()
-            logradouro, aliases = _montar_logradouro_catalogo(nome, prefixo, abreviado, categoria)
+            logradouro, aliases, display_label = _montar_logradouro_catalogo(nome, prefixo, abreviado, categoria)
             catalogo_local.append(
                 {
                     "cdlog": cdlog,
                     "logradouro": logradouro,
+                    "display_label": display_label,
                     "_aliases_norm": [_normalize(item) for item in aliases if _normalize(item)],
                 }
             )
@@ -3028,11 +3029,12 @@ def _carregar_catalogo_vias() -> list[dict[str, Any]]:
         prefixo = str(row.get(prefixo_col) or "").strip() if prefixo_col else ""
         abreviado = str(row.get(abreviado_col) or "").strip() if abreviado_col else ""
         categoria = str(row.get(categoria_col) or "").strip() if categoria_col else ""
-        logradouro, aliases = _montar_logradouro_catalogo(nome, prefixo, abreviado, categoria)
+        logradouro, aliases, display_label = _montar_logradouro_catalogo(nome, prefixo, abreviado, categoria)
         catalogo.append(
             {
                 "cdlog": cdlog,
                 "logradouro": logradouro,
+                "display_label": display_label,
                 "_aliases_norm": [_normalize(item) for item in aliases if _normalize(item)],
             }
         )
@@ -3068,7 +3070,7 @@ def _montar_logradouro_catalogo(
     prefixo: str,
     abreviado: str,
     categoria: str,
-) -> tuple[str, list[str]]:
+) -> tuple[str, list[str], str]:
     nome_limpo = str(nome or "").strip()
     prefixo_limpo = str(prefixo or "").strip()
     abreviado_limpo = re.sub(r"\s+", " ", str(abreviado or "").strip())
@@ -3079,17 +3081,22 @@ def _montar_logradouro_catalogo(
 
     partes_base = [item for item in [tipo_abrev, prefixo_limpo, nome_limpo] if item]
     partes_extenso = [item for item in [tipo_expandido, prefixo_limpo, nome_limpo] if item]
-    logradouro = " ".join(partes_base).strip() or abreviado_limpo or nome_limpo
+    logradouro = abreviado_limpo or " ".join(partes_base).strip() or nome_limpo
+    display_label = abreviado_limpo or logradouro
+    if nome_limpo and _normalize(nome_limpo) not in {_normalize(display_label), _normalize(logradouro)}:
+        display_label = f"{display_label} ({nome_limpo})"
 
     aliases = _dedupe_strings(
         [
             logradouro,
+            display_label,
+            abreviado_limpo,
+            " ".join(partes_base).strip(),
             " ".join(partes_extenso).strip(),
             nome_limpo,
-            abreviado_limpo,
         ]
     )
-    return logradouro, aliases
+    return logradouro, aliases, display_label
 
 
 def _to_int_or_none(value: Any) -> int | None:
@@ -3581,18 +3588,25 @@ def _extrair_sugestoes(
 
 def listar_logradouros_eixos(limite: int | None = None) -> dict[str, Any]:
     try:
-        logradouros = [
-            str(item.get("logradouro") or "").strip()
-            for item in _carregar_catalogo_vias()
-        ]
+        opcoes: list[dict[str, str]] = []
+        vistos: set[str] = set()
+        for item in _carregar_catalogo_vias():
+            value = str(item.get("logradouro") or "").strip()
+            if not value or value in vistos:
+                continue
+            vistos.add(value)
+            label = str(item.get("display_label") or value).strip() or value
+            opcoes.append({"value": value, "label": label})
     except HTTPException:
-        logradouros = []
+        opcoes = []
 
-    itens = _lista_textos_unicos(logradouros, limite)
+    opcoes.sort(key=lambda item: (str(item.get("label") or "").casefold(), str(item.get("value") or "").casefold()))
+    if limite is not None and limite > 0:
+        opcoes = opcoes[:limite]
     return sanitize_value(
         {
-            "logradouros_eixos": itens,
-            "total_logradouros": len(itens),
+            "logradouros_eixos": opcoes,
+            "total_logradouros": len(opcoes),
         }
     )
 

backend/app/services/visualizacao_service.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from html import escape
 from pathlib import Path
 from time import sleep
 from threading import Lock, Thread
@@ -46,6 +47,26 @@ COORD_LON_NAMES = {"lon", "long", "longitude", "siat_longitude"}
 TRABALHOS_TECNICOS_MODELOS_MODO_PADRAO = pesquisa_service.TRABALHOS_TECNICOS_MODELOS_SELECIONADOS_E_OUTRAS_VERSOES
 _MAP_SUPPORT_WARMUP_LOCK = Lock()
 _MAP_SUPPORT_WARMUP_SIGNATURE: str | None = None
+_KNN_DEFAULT_RADIUS = 2.6
+_KNN_RADIUS_MIN = 1.8
+_KNN_RADIUS_MAX = 6.0
+_KNN_FILL_OPACITY = 0.72
+_AVALIACAO_MAPA_MERCADO_RADIUS = 2.45
+_AVALIACAO_MAPA_AVALIANDO_RADIUS = 4.6
+_KNN_AVALIANDO_MARKER_HTML = (
+    "<div style='display:flex;align-items:center;justify-content:center;"
+    "width:30px;height:30px;filter:drop-shadow(0 2px 6px rgba(0,0,0,0.22));'>"
+    "<div style='display:flex;align-items:center;justify-content:center;"
+    "width:24px;height:24px;border-radius:999px;background:rgba(255,255,255,0.97);"
+    "box-shadow:0 0 0 1.4px rgba(255,255,255,0.98),0 0 0 2.5px rgba(0,0,0,0.74);'>"
+    "<svg viewBox='0 0 24 24' width='20' height='20' aria-hidden='true'>"
+    "<path d='M12 3.2L3.9 10v10.1h5.4v-5.3h5.4v5.3h5.4V10L12 3.2Z' "
+    "fill='#c62828' stroke='rgba(255,255,255,0.96)' stroke-width='1.2' stroke-linejoin='round'/>"
+    "<rect x='10.1' y='15.2' width='3.8' height='4.9' rx='0.5' fill='rgba(255,255,255,0.96)'/>"
+    "</svg>"
+    "</div>"
+    "</div>"
+)
 
 
 def _to_dataframe(value: Any) -> pd.DataFrame | None:
@@ -212,6 +233,8 @@ def _criar_mapa_knn_destaque(
 
     if dados.empty:
         return "<p>Sem coordenadas validas para exibir o mapa KNN.</p>"
+    dados, tamanho_key, tamanho_func = _preparar_escala_raio_knn(dados, coluna_y)
+    dados_plot = _aplicar_jitter_pontos_knn(dados)
 
     aval_lat, aval_lon = _normalizar_coordenadas_avaliando(avaliando_lat, avaliando_lon)
     centro_lat = float(dados["__lat__"].median())
@@ -233,11 +256,14 @@ def _criar_mapa_knn_destaque(
     camada_knn = folium.FeatureGroup(name="Selecionados KNN", show=True)
     camada_avaliando = folium.FeatureGroup(name="Avaliando", show=True) if aval_lat is not None and aval_lon is not None else None
 
-    for _, row in dados.iterrows():
+    for _, row in dados_plot.iterrows():
         pos = int(row["__pos_base__"])
         selecionado = pos in posicoes_set
         col_y_val = row.get(coluna_y)
         valor_tooltip = _formatar_tooltip_valor(coluna_y, col_y_val)
+        lat_plot = row["__lat_plot__"] if "__lat_plot__" in row.index and pd.notna(row["__lat_plot__"]) else row["__lat__"]
+        lon_plot = row["__lon_plot__"] if "__lon_plot__" in row.index and pd.notna(row["__lon_plot__"]) else row["__lon__"]
+        raio = _resolver_raio_ponto_knn(row, tamanho_key=tamanho_key, tamanho_func=tamanho_func)
         tooltip_html = (
             "<div style='font-family:\"Segoe UI\",Arial,sans-serif; font-size:13px; line-height:1.5;'>"
             f"<b>Indice {row['__indice_base__']}</b>"
@@ -246,23 +272,28 @@ def _criar_mapa_knn_destaque(
         )
 
         marcador = folium.CircleMarker(
-            location=[float(row["__lat__"]), float(row["__lon__"])],
-            radius=8 if selecionado else 5,
+            location=[float(lat_plot), float(lon_plot)],
+            radius=raio,
             tooltip=folium.Tooltip(tooltip_html, sticky=True),
             color="#ffffff",
             weight=0.9,
             fill=True,
             fillColor="#d7263d" if selecionado else "#4f6d8a",
-            fillOpacity=0.92 if selecionado else 0.52,
+            fillOpacity=_KNN_FILL_OPACITY,
         )
-        marcador.options["mesaBaseRadius"] = 8.0 if selecionado else 5.0
+        marcador.options["mesaBaseRadius"] = raio
         (camada_knn if selecionado else camada_mercado).add_child(marcador)
 
     if camada_avaliando is not None:
         marcador_avaliando = folium.Marker(
             location=[float(aval_lat), float(aval_lon)],
             tooltip="Avaliando",
-            icon=folium.Icon(color="red", icon="home", prefix="glyphicon"),
+            icon=folium.DivIcon(
+                html=_KNN_AVALIANDO_MARKER_HTML,
+                icon_size=(30, 30),
+                icon_anchor=(15, 15),
+                class_name="mesa-avaliando-marker",
+            ),
         )
         camada_avaliando.add_child(marcador_avaliando)
 
@@ -328,6 +359,8 @@ def _criar_payload_knn_destaque(
     ].copy()
     if dados.empty:
         return None
+    dados, tamanho_key, tamanho_func = _preparar_escala_raio_knn(dados, coluna_y)
+    dados_plot = _aplicar_jitter_pontos_knn(dados)
 
     aval_lat, aval_lon = _normalizar_coordenadas_avaliando(avaliando_lat, avaliando_lon)
     posicoes_set = {int(v) for v in (posicoes_knn or [])}
@@ -335,21 +368,22 @@ def _criar_payload_knn_destaque(
     points_knn: list[dict[str, Any]] = []
     bounds: list[list[float]] = []
 
-    for _, row in dados.iterrows():
-        lat = float(row["__lat__"])
-        lon = float(row["__lon__"])
+    for _, row in dados_plot.iterrows():
+        lat = float(row["__lat_plot__"]) if "__lat_plot__" in row.index and pd.notna(row["__lat_plot__"]) else float(row["__lat__"])
+        lon = float(row["__lon_plot__"]) if "__lon_plot__" in row.index and pd.notna(row["__lon_plot__"]) else float(row["__lon__"])
         pos = int(row["__pos_base__"])
         selecionado = pos in posicoes_set
         col_y_val = row.get(coluna_y)
         valor_tooltip = _formatar_tooltip_valor(coluna_y, col_y_val)
+        raio = _resolver_raio_ponto_knn(row, tamanho_key=tamanho_key, tamanho_func=tamanho_func)
         point_payload = {
             "lat": lat,
             "lon": lon,
             "color": "#d7263d" if selecionado else "#4f6d8a",
-            "base_radius": 8.0 if selecionado else 5.0,
+            "base_radius": raio,
             "stroke_color": "#ffffff",
             "stroke_weight": 0.9,
-            "fill_opacity": 0.92 if selecionado else 0.52,
+            "fill_opacity": _KNN_FILL_OPACITY,
             "tooltip_html": (
                 "<div style='font-family:\"Segoe UI\",Arial,sans-serif; font-size:13px; line-height:1.5;'>"
                 f"<b>Índice {escape(str(row['__indice_base__']))}</b>"
@@ -376,13 +410,9 @@ def _criar_payload_knn_destaque(
                         "lat": float(aval_lat),
                         "lon": float(aval_lon),
                         "tooltip_html": "Avaliando",
-                        "marker_html": (
-                            "<div style='display:flex;align-items:center;justify-content:center;"
-                            "width:18px;height:18px;border-radius:999px;background:#dc3545;"
-                            "border:2px solid rgba(255,255,255,0.95);box-shadow:0 1px 4px rgba(0,0,0,0.2);'></div>"
-                        ),
-                        "icon_size": [18, 18],
-                        "icon_anchor": [9, 9],
+                        "marker_html": _KNN_AVALIANDO_MARKER_HTML,
+                        "icon_size": [30, 30],
+                        "icon_anchor": [15, 15],
                         "class_name": "mesa-avaliando-marker",
                     }
                 ],
@@ -587,6 +617,166 @@ def _normalizar_coordenadas_avaliando(lat_raw: Any, lon_raw: Any) -> tuple[float
     return float(lat), float(lon)
 
 
+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(
+            dados,
+            lat_col="__lat__",
+            lon_col="__lon__",
+            lat_plot_col="__lat_plot__",
+            lon_plot_col="__lon_plot__",
+        )
+    except Exception:
+        dados_plot = dados.copy()
+        dados_plot["__lat_plot__"] = dados_plot["__lat__"]
+        dados_plot["__lon_plot__"] = dados_plot["__lon__"]
+        return dados_plot
+
+
+def _preparar_escala_raio_knn(
+    dados: pd.DataFrame,
+    coluna_y: str,
+) -> tuple[pd.DataFrame, str | None, Any]:
+    if dados is None or dados.empty:
+        return dados, None, None
+
+    dados_escalados = dados.copy()
+    tamanho_key = None
+    tamanho_func = None
+
+    if coluna_y and coluna_y in dados_escalados.columns:
+        serie_tamanho = _primeira_serie_por_nome(dados_escalados, coluna_y)
+        if serie_tamanho is not None:
+            tamanho_key = "__knn_tamanho__"
+            dados_escalados[tamanho_key] = pd.to_numeric(serie_tamanho, errors="coerce")
+            serie_valida = dados_escalados[tamanho_key].replace([np.inf, -np.inf], np.nan).dropna()
+            if not serie_valida.empty:
+                t_min = float(serie_valida.min())
+                t_max = float(serie_valida.max())
+                if t_max > t_min:
+                    tamanho_func = (
+                        lambda v, _min=t_min, _max=t_max: _KNN_RADIUS_MIN
+                        + (float(v) - _min) / (_max - _min) * (_KNN_RADIUS_MAX - _KNN_RADIUS_MIN)
+                    )
+                else:
+                    tamanho_func = lambda _v: (_KNN_RADIUS_MIN + _KNN_RADIUS_MAX) / 2.0
+
+    return dados_escalados, tamanho_key, tamanho_func
+
+
+def _resolver_raio_ponto_knn(
+    row: pd.Series,
+    *,
+    tamanho_key: str | None,
+    tamanho_func: Any,
+) -> float:
+    if tamanho_func and tamanho_key and tamanho_key in row.index and pd.notna(row[tamanho_key]):
+        try:
+            return float(max(1.0, tamanho_func(float(row[tamanho_key]))))
+        except Exception:
+            pass
+    return float(_KNN_DEFAULT_RADIUS)
+
+
+def _criar_payload_mapa_avaliacao_localizacao(
+    df_base: pd.DataFrame,
+    avaliando_lat: float | None = None,
+    avaliando_lon: float | None = None,
+) -> dict[str, Any] | None:
+    if df_base is None or df_base.empty:
+        return None
+
+    lat_col = _detectar_coluna_coord(df_base, COORD_LAT_NAMES)
+    lon_col = _detectar_coluna_coord(df_base, COORD_LON_NAMES)
+    if not lat_col or not lon_col:
+        return None
+
+    lat_serie = _primeira_serie_por_nome(df_base, lat_col)
+    lon_serie = _primeira_serie_por_nome(df_base, lon_col)
+    if lat_serie is None or lon_serie is None:
+        return None
+
+    dados = df_base.copy()
+    dados["__lat__"] = pd.to_numeric(lat_serie, errors="coerce")
+    dados["__lon__"] = pd.to_numeric(lon_serie, errors="coerce")
+    dados = dados[
+        np.isfinite(dados["__lat__"])
+        & np.isfinite(dados["__lon__"])
+        & (np.abs(dados["__lat__"]) <= 90.0)
+        & (np.abs(dados["__lon__"]) <= 180.0)
+    ].copy()
+    if dados.empty:
+        return None
+
+    try:
+        dados_plot = viz_app._aplicar_jitter_sobrepostos(
+            dados,
+            lat_col="__lat__",
+            lon_col="__lon__",
+            lat_plot_col="__lat_plot__",
+            lon_plot_col="__lon_plot__",
+        )
+    except Exception:
+        dados_plot = dados.copy()
+        dados_plot["__lat_plot__"] = dados_plot["__lat__"]
+        dados_plot["__lon_plot__"] = dados_plot["__lon__"]
+
+    bounds: list[list[float]] = []
+    mercado_points: list[dict[str, Any]] = []
+    for _, row in dados_plot.iterrows():
+        lat = float(row["__lat_plot__"]) if "__lat_plot__" in row.index and pd.notna(row["__lat_plot__"]) else float(row["__lat__"])
+        lon = float(row["__lon_plot__"]) if "__lon_plot__" in row.index and pd.notna(row["__lon_plot__"]) else float(row["__lon__"])
+        mercado_points.append(
+            {
+                "lat": lat,
+                "lon": lon,
+                "color": "#f28c28",
+                "base_radius": _AVALIACAO_MAPA_MERCADO_RADIUS,
+                "stroke_color": "#000000",
+                "stroke_weight": 0.38,
+                "fill_opacity": 0.86,
+                "interactive": False,
+            }
+        )
+        bounds.append([lat, lon])
+
+    overlay_layers: list[dict[str, Any]] = [
+        {
+            "id": "mercado_avaliacao",
+            "label": "Dados de mercado",
+            "show": True,
+            "points": mercado_points,
+        }
+    ]
+
+    aval_lat, aval_lon = _normalizar_coordenadas_avaliando(avaliando_lat, avaliando_lon)
+    if aval_lat is not None and aval_lon is not None:
+        overlay_layers.append(
+            {
+                "id": "avaliando",
+                "label": "Avaliando",
+                "show": True,
+                "points": [
+                    {
+                        "lat": float(aval_lat),
+                        "lon": float(aval_lon),
+                        "color": "#d7263d",
+                        "base_radius": _AVALIACAO_MAPA_AVALIANDO_RADIUS,
+                        "stroke_color": "#ffffff",
+                        "stroke_weight": 1.1,
+                        "fill_opacity": 0.98,
+                        "tooltip_html": "Avaliando",
+                    }
+                ],
+            }
+        )
+        bounds.append([float(aval_lat), float(aval_lon)])
+
+    return build_leaflet_payload(bounds=bounds, overlay_layers=overlay_layers, show_bairros=True)
+
+
 def _montar_valores_knn(
     valores_x: dict[str, float],
     avaliando_lat: Any = None,
@@ -1044,6 +1234,30 @@ def exibir_contexto_avaliacao(session: SessionState) -> dict[str, Any]:
     }
 
 
+def mapa_localizacao_avaliacao(
+    session: SessionState,
+    avaliando_lat: float | None = None,
+    avaliando_lon: float | None = None,
+) -> dict[str, Any]:
+    aval_lat, aval_lon = _normalizar_coordenadas_avaliando(avaliando_lat, avaliando_lon)
+    if aval_lat is None or aval_lon is None:
+        raise HTTPException(status_code=400, detail="Informe coordenadas válidas para exibir o avaliando no mapa.")
+
+    core = _obter_visualizacao_core(session)
+    mapa_payload = _criar_payload_mapa_avaliacao_localizacao(
+        core["dados"],
+        avaliando_lat=aval_lat,
+        avaliando_lon=aval_lon,
+    )
+    if mapa_payload is None:
+        raise HTTPException(status_code=400, detail="O modelo carregado não possui coordenadas válidas para montar o mapa.")
+
+    return {
+        "mapa_html": "",
+        "mapa_payload": mapa_payload,
+    }
+
+
 def exibir_modelo(
     session: SessionState,
     trabalhos_tecnicos_modelos_modo: Any = None,

frontend/src/api.js

@@ -186,7 +186,7 @@ export const api = {
 
   pesquisaAdminConfig: () => getJson('/api/pesquisa/admin-config'),
   pesquisaAdminConfigSalvar: (campos = {}) => postJson('/api/pesquisa/admin-config', { campos }),
-  pesquisarLogradourosEixos: (limite = 2000) => getJson(`/api/pesquisa/logradouros-eixos?limite=${encodeURIComponent(String(limite))}`),
+  pesquisarLogradourosEixos: (limite = 20000) => getJson(`/api/pesquisa/logradouros-eixos?limite=${encodeURIComponent(String(limite))}`),
 
   pesquisarModelos(filtros = {}) {
     const params = new URLSearchParams()
@@ -394,6 +394,11 @@ export const api = {
     avaliando_lat: avaliando?.lat ?? null,
     avaliando_lon: avaliando?.lon ?? null,
   }),
+  evaluationLocationMapViz: (sessionId, avaliando = null) => postJson('/api/visualizacao/evaluation/location-map', {
+    session_id: sessionId,
+    avaliando_lat: avaliando?.lat ?? null,
+    avaliando_lon: avaliando?.lon ?? null,
+  }),
   evaluationClearViz: (sessionId) => postJson('/api/visualizacao/evaluation/clear', { session_id: sessionId }),
   evaluationDeleteViz: (sessionId, indice, indiceBase) => postJson('/api/visualizacao/evaluation/delete', {
     session_id: sessionId,

frontend/src/components/AvaliacaoTab.jsx

@@ -211,6 +211,40 @@ function obterRotulosKnnAvaliacao(aval) {
   return ['Estimativa KNN', '']
 }
 
+function montarNomeArquivoMapaAvaliando() {
+  const agora = new Date()
+  const pad = (value) => String(value).padStart(2, '0')
+  return [
+    'mapa-avaliando-',
+    agora.getFullYear(),
+    pad(agora.getMonth() + 1),
+    pad(agora.getDate()),
+    '_',
+    pad(agora.getHours()),
+    pad(agora.getMinutes()),
+    pad(agora.getSeconds()),
+    '.png',
+  ].join('')
+}
+
+function clampSelectionCoordinate(value, max) {
+  return Math.max(0, Math.min(Number.isFinite(value) ? value : 0, max))
+}
+
+function buildDownloadSelectionRect(startPoint, endPoint, bounds) {
+  const widthMax = Math.max(0, Number(bounds?.width) || 0)
+  const heightMax = Math.max(0, Number(bounds?.height) || 0)
+  const startX = clampSelectionCoordinate(Number(startPoint?.x), widthMax)
+  const startY = clampSelectionCoordinate(Number(startPoint?.y), heightMax)
+  const endX = clampSelectionCoordinate(Number(endPoint?.x), widthMax)
+  const endY = clampSelectionCoordinate(Number(endPoint?.y), heightMax)
+  const left = Math.min(startX, endX)
+  const top = Math.min(startY, endY)
+  const width = Math.abs(endX - startX)
+  const height = Math.abs(endY - startY)
+  return { left, top, width, height }
+}
+
 function obterValorKnnPrincipal(aval) {
   if (!aval?.knn_disponivel) return null
   const tipo = normalizarTipoY(aval?.tipo_y)
@@ -491,10 +525,34 @@ const EMPTY_LOCATION_INPUTS = {
   cdlog: '',
 }
 
+function parseCoordinateValue(value) {
+  if (value === null || value === undefined) return null
+  const text = String(value).trim().replace(',', '.')
+  if (!text) return null
+  const parsed = Number(text)
+  return Number.isFinite(parsed) ? parsed : null
+}
+
+function normalizeLogradouroOption(item) {
+  if (typeof item === 'string') {
+    const text = String(item || '').trim()
+    return text ? { value: text, label: text } : null
+  }
+  if (!item || typeof item !== 'object') return null
+  const value = String(item.value ?? item.logradouro ?? '').trim()
+  if (!value) return null
+  const label = String(item.label ?? item.display_label ?? value).trim() || value
+  return {
+    value,
+    label,
+    secondary: String(item.secondary ?? '').trim(),
+  }
+}
+
 function obterCoordenadasResolvidas(localizacao) {
-  const lat = Number(localizacao?.lat)
-  const lon = Number(localizacao?.lon)
-  if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null
+  const lat = parseCoordinateValue(localizacao?.lat)
+  const lon = parseCoordinateValue(localizacao?.lon)
+  if (lat === null || lon === null) return null
   if (lat < -90 || lat > 90 || lon < -180 || lon > 180) return null
   return { lat, lon }
 }
@@ -543,9 +601,21 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
   const [knnDetalheAvaliando, setKnnDetalheAvaliando] = useState([])
   const [knnDetalheTabela, setKnnDetalheTabela] = useState(null)
   const [knnDetalheInfo, setKnnDetalheInfo] = useState(null)
+  const [avaliandoMapaAberto, setAvaliandoMapaAberto] = useState(false)
+  const [avaliandoMapaLoading, setAvaliandoMapaLoading] = useState(false)
+  const [avaliandoMapaErro, setAvaliandoMapaErro] = useState('')
+  const [avaliandoMapaHtml, setAvaliandoMapaHtml] = useState('')
+  const [avaliandoMapaPayload, setAvaliandoMapaPayload] = useState(null)
+  const [avaliandoMapaDownloadLoading, setAvaliandoMapaDownloadLoading] = useState(false)
+  const [avaliandoMapaDownloadErro, setAvaliandoMapaDownloadErro] = useState('')
+  const [avaliandoMapaSelecao, setAvaliandoMapaSelecao] = useState(null)
+  const [avaliandoMapaSelecionando, setAvaliandoMapaSelecionando] = useState(false)
 
   const uploadInputRef = useRef(null)
   const quickLoadHandledRef = useRef('')
+  const avaliandoMapaDownloadRef = useRef(null)
+  const avaliandoMapaSelectionWrapRef = useRef(null)
+  const avaliandoMapaSelectionStartRef = useRef(null)
 
   const repoModeloOptions = useMemo(
     () => (repoModelos || []).map((item) => ({
@@ -570,6 +640,83 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
     }, {})
   }, [knnDetalheTabela])
 
+  useEffect(() => {
+    if (!avaliandoMapaAberto || !avaliandoMapaPayload) return undefined
+    const timerId = window.setTimeout(() => {
+      avaliandoMapaDownloadRef.current?.fitToPayloadBounds?.(112)
+    }, 80)
+    return () => {
+      window.clearTimeout(timerId)
+    }
+  }, [avaliandoMapaAberto, avaliandoMapaPayload])
+
+  function obterPontoSelecaoMapa(clientX, clientY) {
+    const wrap = avaliandoMapaSelectionWrapRef.current
+    if (!wrap) return null
+    const rect = wrap.getBoundingClientRect()
+    if (!rect.width || !rect.height) return null
+    return {
+      x: clampSelectionCoordinate(clientX - rect.left, rect.width),
+      y: clampSelectionCoordinate(clientY - rect.top, rect.height),
+      width: rect.width,
+      height: rect.height,
+    }
+  }
+
+  function onIniciarSelecaoMapa(event) {
+    if (!avaliandoMapaSelecionando) return
+    const point = obterPontoSelecaoMapa(event.clientX, event.clientY)
+    if (!point) return
+    avaliandoMapaSelectionStartRef.current = {
+      x: point.x,
+      y: point.y,
+      pointerId: event.pointerId,
+      width: point.width,
+      height: point.height,
+    }
+    setAvaliandoMapaSelecao({ left: point.x, top: point.y, width: 0, height: 0 })
+    setAvaliandoMapaDownloadErro('')
+    event.preventDefault()
+    event.currentTarget.setPointerCapture?.(event.pointerId)
+  }
+
+  function onMoverSelecaoMapa(event) {
+    const start = avaliandoMapaSelectionStartRef.current
+    if (!start) return
+    const point = obterPontoSelecaoMapa(event.clientX, event.clientY)
+    if (!point) return
+    setAvaliandoMapaSelecao(buildDownloadSelectionRect(start, point, start))
+    event.preventDefault()
+  }
+
+  function finalizarSelecaoMapa(event) {
+    const start = avaliandoMapaSelectionStartRef.current
+    if (!start) return
+    const point = obterPontoSelecaoMapa(event.clientX, event.clientY) || start
+    const nextSelection = buildDownloadSelectionRect(start, point, start)
+    avaliandoMapaSelectionStartRef.current = null
+    if (event.currentTarget.hasPointerCapture?.(event.pointerId)) {
+      event.currentTarget.releasePointerCapture?.(event.pointerId)
+    }
+    if (nextSelection.width < 24 || nextSelection.height < 24) {
+      setAvaliandoMapaSelecao(null)
+      setAvaliandoMapaDownloadErro('Selecione um retangulo um pouco maior para gerar o PNG.')
+      setAvaliandoMapaSelecionando(false)
+      return
+    }
+    setAvaliandoMapaSelecao(nextSelection)
+    setAvaliandoMapaSelecionando(false)
+  }
+
+  function onCancelarSelecaoMapa(event) {
+    if (!avaliandoMapaSelectionStartRef.current) return
+    avaliandoMapaSelectionStartRef.current = null
+    if (event.currentTarget.hasPointerCapture?.(event.pointerId)) {
+      event.currentTarget.releasePointerCapture?.(event.pointerId)
+    }
+    setAvaliandoMapaSelecionando(false)
+  }
+
   function resolverModeloIdRepositorio(chaveBruta, modelosOverride = null) {
     const chave = String(chaveBruta || '').trim()
     if (!chave) return ''
@@ -809,7 +956,7 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
     try {
       const response = await api.pesquisarLogradourosEixos()
       const opcoes = Array.isArray(response?.logradouros_eixos)
-        ? response.logradouros_eixos.map((item) => String(item || '').trim()).filter(Boolean)
+        ? response.logradouros_eixos.map(normalizeLogradouroOption).filter(Boolean)
         : []
       setAvaliandoLogradouroOptions(opcoes)
       setAvaliandoLogradouroLoaded(true)
@@ -965,8 +1112,8 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
       })
       const resolvida = {
         ...response,
-        lat: Number(response?.lat),
-        lon: Number(response?.lon),
+        lat: parseCoordinateValue(response?.lat),
+        lon: parseCoordinateValue(response?.lon),
       }
       setAvaliandoLocalizacaoResolvida(resolvida)
       setAvaliandoLocalizacaoStatus(response?.status || 'Localização do avaliando definida.')
@@ -1117,6 +1264,71 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
     setKnnDetalheErro('')
   }
 
+  async function onAbrirMapaAvaliando() {
+    const avaliandoCoords = obterCoordenadasResolvidas(avaliandoLocalizacaoResolvida)
+    if (!sessionId || !avaliandoCoords) return
+    setAvaliandoMapaAberto(true)
+    setAvaliandoMapaLoading(true)
+    setAvaliandoMapaErro('')
+    setAvaliandoMapaDownloadErro('')
+    setAvaliandoMapaSelecao(null)
+    setAvaliandoMapaSelecionando(false)
+    avaliandoMapaSelectionStartRef.current = null
+    setAvaliandoMapaHtml('')
+    setAvaliandoMapaPayload(null)
+    try {
+      const resp = await api.evaluationLocationMapViz(sessionId, avaliandoCoords)
+      setAvaliandoMapaHtml(String(resp?.mapa_html || ''))
+      setAvaliandoMapaPayload(resp?.mapa_payload || null)
+    } catch (err) {
+      setAvaliandoMapaErro(err?.message || 'Falha ao montar o mapa simplificado do avaliando.')
+    } finally {
+      setAvaliandoMapaLoading(false)
+    }
+  }
+
+  function onFecharMapaAvaliando() {
+    setAvaliandoMapaAberto(false)
+    setAvaliandoMapaLoading(false)
+    setAvaliandoMapaErro('')
+    setAvaliandoMapaDownloadLoading(false)
+    setAvaliandoMapaDownloadErro('')
+    setAvaliandoMapaSelecao(null)
+    setAvaliandoMapaSelecionando(false)
+    avaliandoMapaSelectionStartRef.current = null
+  }
+
+  function onAtivarSelecaoMapaAvaliando() {
+    setAvaliandoMapaDownloadErro('')
+    setAvaliandoMapaSelecao(null)
+    setAvaliandoMapaSelecionando(true)
+    avaliandoMapaSelectionStartRef.current = null
+  }
+
+  function onLimparSelecaoMapaAvaliando() {
+    setAvaliandoMapaSelecao(null)
+    setAvaliandoMapaSelecionando(false)
+    setAvaliandoMapaDownloadErro('')
+    avaliandoMapaSelectionStartRef.current = null
+  }
+
+  async function onBaixarMapaAvaliandoPng() {
+    if (!avaliandoMapaSelecao) {
+      setAvaliandoMapaDownloadErro('Selecione com um retangulo a area que deseja baixar.')
+      return
+    }
+    if (!avaliandoMapaDownloadRef.current?.downloadSelectionPng) return
+    setAvaliandoMapaDownloadLoading(true)
+    setAvaliandoMapaDownloadErro('')
+    try {
+      await avaliandoMapaDownloadRef.current.downloadSelectionPng(avaliandoMapaSelecao, montarNomeArquivoMapaAvaliando())
+    } catch (err) {
+      setAvaliandoMapaDownloadErro(err?.message || 'Falha ao exportar o mapa em PNG.')
+    } finally {
+      setAvaliandoMapaDownloadLoading(false)
+    }
+  }
+
   function calcularComparacaoBase(avaliacao) {
     if (!baseCard || !baseCard.avaliacao) return '—'
     const baseEstimado = Number(baseCard.avaliacao.estimado)
@@ -1460,8 +1672,20 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
 
                   {avaliandoLocalizacaoAtiva ? (
                     <div className="pesquisa-localizacao-registered">
-                      <div className="pesquisa-localizacao-registered-copy">
-                        <strong>Geolocalização registrada</strong>
+                      <div className="pesquisa-localizacao-registered-head">
+                        <div className="pesquisa-localizacao-registered-copy">
+                          <strong>Geolocalização registrada</strong>
+                        </div>
+                        <div className="pesquisa-localizacao-registered-actions">
+                          <button
+                            type="button"
+                            className="pesquisa-localizacao-action"
+                            onClick={() => void onAbrirMapaAvaliando()}
+                            disabled={avaliandoMapaLoading}
+                          >
+                            {avaliandoMapaLoading ? 'Carregando mapa...' : 'Ver no mapa'}
+                          </button>
+                        </div>
                       </div>
                       <div className="pesquisa-localizacao-summary">
                         {avaliandoLocalizacaoResolvida?.logradouro ? (
@@ -1780,6 +2004,88 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
           dangerouslySetInnerHTML={{ __html: avaliacaoPopup.html }}
         />
       ) : null}
+      {avaliandoMapaAberto ? (
+        <div className="pesquisa-modal-backdrop" onClick={(event) => {
+          if (event.target === event.currentTarget) onFecharMapaAvaliando()
+        }}
+        >
+          <div className="pesquisa-modal avaliacao-localizacao-download-modal">
+            <div className="pesquisa-modal-head">
+              <div>
+                <h4>Ajustar recorte para PNG</h4>
+                <p>Ajuste zoom e posição, depois desenhe um retângulo sobre a área que deseja baixar.</p>
+              </div>
+              <div className="avaliacao-localizacao-map-modal-actions">
+                <button
+                  type="button"
+                  className={`pesquisa-localizacao-action avaliacao-download-toggle-btn${avaliandoMapaSelecao || avaliandoMapaSelecionando ? ' is-clear' : ' is-select'}`}
+                  onClick={avaliandoMapaSelecao || avaliandoMapaSelecionando ? onLimparSelecaoMapaAvaliando : onAtivarSelecaoMapaAvaliando}
+                  disabled={!avaliandoMapaPayload || avaliandoMapaDownloadLoading}
+                >
+                  {avaliandoMapaSelecao || avaliandoMapaSelecionando ? 'Limpar recorte' : 'Selecionar retângulo'}
+                </button>
+                <button
+                  type="button"
+                  className="pesquisa-localizacao-action"
+                  onClick={() => void onBaixarMapaAvaliandoPng()}
+                  disabled={!avaliandoMapaPayload || !avaliandoMapaSelecao || avaliandoMapaDownloadLoading}
+                >
+                  {avaliandoMapaDownloadLoading ? 'Baixando PNG...' : 'Baixar PNG'}
+                </button>
+                <button type="button" className="pesquisa-modal-close" onClick={onFecharMapaAvaliando}>
+                  Fechar
+                </button>
+              </div>
+            </div>
+            <div className="pesquisa-modal-body">
+              {avaliandoMapaLoading ? (
+                <div className="empty-box">Carregando mapa do modelo...</div>
+              ) : null}
+              {avaliandoMapaErro ? (
+                <div className="error-line">{avaliandoMapaErro}</div>
+              ) : null}
+              {!avaliandoMapaLoading && !avaliandoMapaErro ? (
+                <>
+              <div className="avaliacao-knn-legenda">
+                <span><b>Qualidade:</b> PNG de alta resolução só da área selecionada</span>
+                <span><b>Como usar:</b> clique em selecionar retângulo e arraste no mapa</span>
+              </div>
+              <div className="avaliacao-localizacao-download-status">
+                {avaliandoMapaSelecao
+                  ? `Recorte selecionado: ${Math.round(avaliandoMapaSelecao.width)} × ${Math.round(avaliandoMapaSelecao.height)} px`
+                  : (avaliandoMapaSelecionando ? 'Desenhe o retângulo sobre o mapa.' : 'Nenhum recorte selecionado ainda.')}
+              </div>
+              {avaliandoMapaDownloadErro ? (
+                <div className="error-line">{avaliandoMapaDownloadErro}</div>
+              ) : null}
+              <div ref={avaliandoMapaSelectionWrapRef} className={`avaliacao-localizacao-download-map-wrap${avaliandoMapaSelecionando ? ' is-selecting' : ''}`}>
+                <MapFrame ref={avaliandoMapaDownloadRef} html={avaliandoMapaHtml} payload={avaliandoMapaPayload} sessionId={sessionId} />
+                <div
+                  className={`avaliacao-download-selection-layer${avaliandoMapaSelecionando ? ' is-active' : ''}`}
+                  onPointerDown={onIniciarSelecaoMapa}
+                  onPointerMove={onMoverSelecaoMapa}
+                  onPointerUp={finalizarSelecaoMapa}
+                  onPointerCancel={onCancelarSelecaoMapa}
+                >
+                  {avaliandoMapaSelecao ? (
+                    <div
+                      className="avaliacao-download-selection-rect"
+                      style={{
+                        left: `${avaliandoMapaSelecao.left}px`,
+                        top: `${avaliandoMapaSelecao.top}px`,
+                        width: `${avaliandoMapaSelecao.width}px`,
+                        height: `${avaliandoMapaSelecao.height}px`,
+                      }}
+                    />
+                  ) : null}
+                </div>
+              </div>
+                </>
+              ) : null}
+            </div>
+          </div>
+        </div>
+      ) : null}
       {knnDetalheAberto ? (
         <div className="pesquisa-modal-backdrop" onClick={(event) => {
           if (event.target === event.currentTarget) onFecharDetalheKnn()

frontend/src/components/LeafletMapFrame.jsx

@@ -1,8 +1,8 @@
-import React, { useEffect, useRef, useState } from 'react'
+import React, { forwardRef, useEffect, useImperativeHandle, useRef, useState } from 'react'
 import L from 'leaflet'
 import 'leaflet.fullscreen'
 import 'leaflet.heat'
-import { apiUrl, getAuthToken } from '../api'
+import { apiUrl, downloadBlob, getAuthToken } from '../api'
 
 let bairrosGeojsonCache = null
 let bairrosGeojsonPromise = null
@@ -37,6 +37,23 @@ function buildPopupErrorHtml(message) {
   )
 }
 
+function parseFiniteCoordinate(value, min, max) {
+  if (value === null || value === undefined) return null
+  const text = String(value).trim().replace(',', '.')
+  if (!text) return null
+  const parsed = Number(text)
+  if (!Number.isFinite(parsed)) return null
+  if (parsed < min || parsed > max) return null
+  return parsed
+}
+
+function parseLatLonPair(rawLat, rawLon) {
+  const lat = parseFiniteCoordinate(rawLat, -90, 90)
+  const lon = parseFiniteCoordinate(rawLon, -180, 180)
+  if (lat === null || lon === null) return null
+  return [lat, lon]
+}
+
 function ensurePopupPager(root) {
   if (!root || root.dataset.mesaPagerBound === '1') return
   root.dataset.mesaPagerBound = '1'
@@ -363,11 +380,638 @@ async function readJsonSafely(response) {
   }
 }
 
-export default function LeafletMapFrame({ payload, sessionId }) {
+function waitForNextPaint() {
+  return new Promise((resolve) => {
+    window.requestAnimationFrame(() => {
+      window.requestAnimationFrame(resolve)
+    })
+  })
+}
+
+function isDrawableVisible(rect, hostRect) {
+  if (!rect || !hostRect) return false
+  if (rect.width <= 0 || rect.height <= 0) return false
+  return (
+    rect.right > hostRect.left
+    && rect.left < hostRect.right
+    && rect.bottom > hostRect.top
+    && rect.top < hostRect.bottom
+  )
+}
+
+function parseBorderRadiusPx(element) {
+  if (!element) return 0
+  const computed = window.getComputedStyle(element)
+  const raw = String(computed.borderTopLeftRadius || computed.borderRadius || '0')
+  const parsed = Number.parseFloat(raw)
+  return Number.isFinite(parsed) ? Math.max(0, parsed) : 0
+}
+
+function clipRoundedRect(ctx, width, height, radius) {
+  const corner = Math.max(0, Math.min(radius, Math.min(width, height) / 2))
+  if (!corner) {
+    ctx.beginPath()
+    ctx.rect(0, 0, width, height)
+    ctx.clip()
+    return
+  }
+  ctx.beginPath()
+  ctx.moveTo(corner, 0)
+  ctx.lineTo(width - corner, 0)
+  ctx.quadraticCurveTo(width, 0, width, corner)
+  ctx.lineTo(width, height - corner)
+  ctx.quadraticCurveTo(width, height, width - corner, height)
+  ctx.lineTo(corner, height)
+  ctx.quadraticCurveTo(0, height, 0, height - corner)
+  ctx.lineTo(0, corner)
+  ctx.quadraticCurveTo(0, 0, corner, 0)
+  ctx.closePath()
+  ctx.clip()
+}
+
+function collectVisibleMapDrawables(container, hostRect) {
+  const drawables = []
+  let sequence = 0
+  const register = (element, kind) => {
+    if (!element) return
+    const rect = element.getBoundingClientRect()
+    if (!isDrawableVisible(rect, hostRect)) return
+    const pane = element.closest('.leaflet-pane')
+    const paneZ = Number.parseInt(String(window.getComputedStyle(pane || element).zIndex || '0'), 10)
+    drawables.push({
+      element,
+      kind,
+      rect,
+      paneZ: Number.isFinite(paneZ) ? paneZ : 0,
+      sequence,
+    })
+    sequence += 1
+  }
+
+  Array.from(container.querySelectorAll('.leaflet-tile-pane img.leaflet-tile')).forEach((element) => register(element, 'image'))
+  Array.from(container.querySelectorAll('.leaflet-pane canvas')).forEach((element) => register(element, 'canvas'))
+  Array.from(container.querySelectorAll('.leaflet-pane svg')).forEach((element) => register(element, 'svg'))
+
+  drawables.sort((left, right) => {
+    if (left.paneZ !== right.paneZ) return left.paneZ - right.paneZ
+    return left.sequence - right.sequence
+  })
+  return drawables
+}
+
+function serializeSvgElement(element, width, height) {
+  const clone = element.cloneNode(true)
+  clone.setAttribute('xmlns', 'http://www.w3.org/2000/svg')
+  clone.setAttribute('xmlns:xlink', 'http://www.w3.org/1999/xlink')
+  clone.setAttribute('width', String(width))
+  clone.setAttribute('height', String(height))
+  if (!clone.getAttribute('viewBox')) {
+    clone.setAttribute('viewBox', `0 0 ${width} ${height}`)
+  }
+  return new XMLSerializer().serializeToString(clone)
+}
+
+function loadSvgImage(svgMarkup) {
+  return new Promise((resolve, reject) => {
+    const blob = new Blob([svgMarkup], { type: 'image/svg+xml;charset=utf-8' })
+    const objectUrl = URL.createObjectURL(blob)
+    const image = new Image()
+    image.decoding = 'async'
+    image.onload = () => {
+      URL.revokeObjectURL(objectUrl)
+      resolve(image)
+    }
+    image.onerror = () => {
+      URL.revokeObjectURL(objectUrl)
+      reject(new Error('Nao foi possivel desenhar uma camada vetorial do mapa.'))
+    }
+    image.src = objectUrl
+  })
+}
+
+function canvasToBlob(canvas) {
+  return new Promise((resolve, reject) => {
+    try {
+      canvas.toBlob((blob) => {
+        if (blob) {
+          resolve(blob)
+          return
+        }
+        reject(new Error('Nao foi possivel gerar a imagem PNG do mapa.'))
+      }, 'image/png')
+    } catch (error) {
+      reject(error)
+    }
+  })
+}
+
+function clampNumber(value, min, max) {
+  return Math.max(min, Math.min(max, value))
+}
+
+function normalizeFitPadding(value, fallback = 48) {
+  const numeric = Number(value)
+  const resolved = Number.isFinite(numeric) && numeric >= 0 ? numeric : fallback
+  return [resolved, resolved]
+}
+
+function normalizeSelectionRect(selectionRect, containerWidth, containerHeight) {
+  const rawLeft = Number(selectionRect?.left ?? selectionRect?.x)
+  const rawTop = Number(selectionRect?.top ?? selectionRect?.y)
+  const rawWidth = Number(selectionRect?.width)
+  const rawHeight = Number(selectionRect?.height)
+  if (![rawLeft, rawTop, rawWidth, rawHeight].every(Number.isFinite)) return null
+  if (rawWidth <= 0 || rawHeight <= 0) return null
+
+  const left = clampNumber(rawLeft, 0, containerWidth)
+  const top = clampNumber(rawTop, 0, containerHeight)
+  const right = clampNumber(rawLeft + rawWidth, 0, containerWidth)
+  const bottom = clampNumber(rawTop + rawHeight, 0, containerHeight)
+  const width = right - left
+  const height = bottom - top
+  if (width < 12 || height < 12) return null
+  return {
+    left,
+    top,
+    width,
+    height,
+    right,
+    bottom,
+  }
+}
+
+function intersectRectangles(leftRect, rightRect) {
+  const left = Math.max(leftRect.left, rightRect.left)
+  const top = Math.max(leftRect.top, rightRect.top)
+  const right = Math.min(leftRect.right, rightRect.right)
+  const bottom = Math.min(leftRect.bottom, rightRect.bottom)
+  if (right <= left || bottom <= top) return null
+  return {
+    left,
+    top,
+    right,
+    bottom,
+    width: right - left,
+    height: bottom - top,
+  }
+}
+
+function resolveDrawableSourceSize(element, kind, drawWidth, drawHeight) {
+  if (kind === 'image') {
+    return {
+      width: Number(element?.naturalWidth) || drawWidth,
+      height: Number(element?.naturalHeight) || drawHeight,
+    }
+  }
+  if (kind === 'canvas') {
+    return {
+      width: Number(element?.width) || drawWidth,
+      height: Number(element?.height) || drawHeight,
+    }
+  }
+  return { width: drawWidth, height: drawHeight }
+}
+
+function computeSelectionExportScale(selectionRect) {
+  const longestEdge = Math.max(selectionRect?.width || 0, selectionRect?.height || 0, 1)
+  const deviceScale = Number(window.devicePixelRatio) || 1
+  const preferredScale = Math.max(3, deviceScale * 2.5)
+  const boundedScale = 3600 / longestEdge
+  return Math.max(2, Math.min(5, preferredScale, boundedScale))
+}
+
+function fitMapToPayloadBounds(map, payload, padding = 48) {
+  if (!map) return false
+  const bounds = Array.isArray(payload?.bounds) ? payload.bounds : null
+  if (bounds && bounds.length === 2) {
+    map.fitBounds(bounds, { padding: normalizeFitPadding(padding), maxZoom: 18, animate: false })
+    return true
+  }
+  if (Array.isArray(payload?.center) && payload.center.length === 2) {
+    map.setView(payload.center, 12, { animate: false })
+    return true
+  }
+  return false
+}
+
+async function waitForTileLayerLoad(tileLayer, timeoutMs = 6500) {
+  if (!tileLayer) return
+  await new Promise((resolve) => {
+    let settled = false
+    const finalize = () => {
+      if (settled) return
+      settled = true
+      window.clearTimeout(timerId)
+      tileLayer.off('load', finalize)
+      resolve()
+    }
+    const timerId = window.setTimeout(finalize, timeoutMs)
+    tileLayer.on('load', finalize)
+    if (!tileLayer._loading) {
+      window.setTimeout(finalize, 180)
+    }
+  })
+}
+
+function resolveActiveTileLayerConfig(sourceMap, payload) {
+  const definitions = Array.isArray(payload?.tile_layers) ? payload.tile_layers : []
+  if (!sourceMap || !definitions.length) return definitions[0] || null
+
+  const activeUrls = new Set()
+  sourceMap.eachLayer((layer) => {
+    if (layer instanceof L.TileLayer && sourceMap.hasLayer(layer)) {
+      const url = String(layer?._url || '').trim()
+      if (url) activeUrls.add(url)
+    }
+  })
+  return definitions.find((item) => activeUrls.has(String(item?.url || '').trim())) || definitions[0] || null
+}
+
+async function buildHighResolutionSelectionBlob({
+  sourceMap,
+  sourceContainer,
+  payload,
+  selectionRect,
+}) {
+  if (!sourceMap || !sourceContainer) {
+    throw new Error('Mapa indisponivel para exportacao.')
+  }
+
+  const hostRect = sourceContainer.getBoundingClientRect()
+  const containerWidth = Math.round(hostRect.width)
+  const containerHeight = Math.round(hostRect.height)
+  const normalizedSelection = normalizeSelectionRect(selectionRect, containerWidth, containerHeight)
+  if (!normalizedSelection) {
+    throw new Error('Selecione um retangulo valido no mapa antes de baixar.')
+  }
+
+  const exportScale = computeSelectionExportScale(normalizedSelection)
+  const exportWidth = Math.max(480, Math.round(normalizedSelection.width * exportScale))
+  const exportHeight = Math.max(480, Math.round(normalizedSelection.height * exportScale))
+  const selectionCenter = sourceMap.containerPointToLatLng([
+    normalizedSelection.left + (normalizedSelection.width / 2),
+    normalizedSelection.top + (normalizedSelection.height / 2),
+  ])
+  const sourceZoom = Number(sourceMap.getZoom?.() ?? 0)
+  const exportZoom = sourceZoom + Math.log2(exportScale)
+
+  const mount = document.createElement('div')
+  mount.style.position = 'fixed'
+  mount.style.left = '-20000px'
+  mount.style.top = '0'
+  mount.style.width = `${exportWidth}px`
+  mount.style.height = `${exportHeight}px`
+  mount.style.opacity = '0'
+  mount.style.pointerEvents = 'none'
+  mount.style.background = '#ffffff'
+  mount.style.overflow = 'hidden'
+  document.body.appendChild(mount)
+
+  let exportMap = null
+  try {
+    exportMap = L.map(mount, {
+      zoomControl: false,
+      attributionControl: false,
+      preferCanvas: true,
+      dragging: false,
+      scrollWheelZoom: false,
+      doubleClickZoom: false,
+      boxZoom: false,
+      keyboard: false,
+      touchZoom: false,
+      tapHold: false,
+    })
+
+    const bairrosPane = exportMap.createPane('mesa-bairros-pane')
+    const marketPane = exportMap.createPane('mesa-market-pane')
+    const trabalhosPane = exportMap.createPane('mesa-trabalhos-pane')
+    const indicesPane = exportMap.createPane('mesa-indices-pane')
+    bairrosPane.style.zIndex = '360'
+    marketPane.style.zIndex = '420'
+    trabalhosPane.style.zIndex = '430'
+    indicesPane.style.zIndex = '440'
+
+    const canvasRenderer = L.canvas({ padding: 0.5, pane: 'mesa-market-pane' })
+    const overlaySpecs = Array.isArray(payload?.overlay_layers) && payload.overlay_layers.length
+      ? payload.overlay_layers
+      : buildLegacyOverlayLayers(payload)
+    const responsivePointContainers = []
+    const radiusBehavior = payload?.radius_behavior || {}
+    const minRadius = Number(radiusBehavior.min_radius) || 1.6
+    const maxRadius = Number(radiusBehavior.max_radius) || 52.0
+    const referenceZoom = Number(radiusBehavior.reference_zoom) || 12.0
+    const growthFactor = Number(radiusBehavior.growth_factor) || 0.2
+
+    const activeTileLayerConfig = resolveActiveTileLayerConfig(sourceMap, payload)
+    let tileLayer = null
+    if (activeTileLayerConfig?.url) {
+      tileLayer = L.tileLayer(String(activeTileLayerConfig.url || ''), {
+        attribution: String(activeTileLayerConfig?.attribution || ''),
+        crossOrigin: 'anonymous',
+        detectRetina: true,
+      }).addTo(exportMap)
+    }
+
+    const applyResponsiveRadius = () => {
+      const zoom = typeof exportMap.getZoom === 'function' ? exportMap.getZoom() : referenceZoom
+      const zoomDelta = zoom - referenceZoom
+      const expFactor = 2 ** (zoomDelta * growthFactor)
+      let floorScale = 1.0
+      if (zoomDelta >= 0) {
+        floorScale = 1 + zoomDelta * 0.22
+        if (zoom >= 15) {
+          floorScale += (zoom - 14) * 0.30
+        }
+      } else {
+        floorScale = Math.max(0.28, 1 + zoomDelta * 0.20)
+      }
+
+      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(clampNumber(base * expFactor, dynamicMin, dynamicMax))
+        })
+      })
+    }
+
+    const addPointMarkers = (layerGroup, items) => {
+      if (!Array.isArray(items) || !items.length) return
+      responsivePointContainers.push(layerGroup)
+      items.forEach((item) => {
+        const latlng = parseLatLonPair(item?.lat, item?.lon)
+        if (!latlng) return
+        const marker = L.circleMarker(latlng, {
+          renderer: canvasRenderer,
+          pane: String(item?.pane || 'mesa-market-pane'),
+          radius: Number(item?.base_radius) || 4,
+          color: String(item?.stroke_color || '#000000'),
+          weight: Number.isFinite(Number(item?.stroke_weight))
+            ? Number(item.stroke_weight)
+            : (Number(item?.base_radius) > 4 ? 1 : 0.8),
+          fill: item?.fill !== false,
+          fillColor: String(item?.color || item?.fill_color || '#FF8C00'),
+          fillOpacity: Number.isFinite(Number(item?.fill_opacity)) ? Number(item.fill_opacity) : 0.68,
+          interactive: false,
+          bubblingMouseEvents: false,
+        })
+        marker.options.mesaBaseRadius = Number(item?.base_radius) || 4
+        layerGroup.addLayer(marker)
+      })
+    }
+
+    const addShapeOverlays = (layerGroup, shapes) => {
+      if (!Array.isArray(shapes) || !shapes.length) return
+      shapes.forEach((shape) => {
+        const shapeType = String(shape?.type || shape?.shape_type || '').trim().toLowerCase()
+        const style = {
+          color: String(shape?.color || '#1f6fb2'),
+          weight: Number.isFinite(Number(shape?.weight)) ? Number(shape.weight) : 2,
+          opacity: Number.isFinite(Number(shape?.opacity)) ? Number(shape.opacity) : 0.8,
+          fill: shape?.fill === true,
+          fillColor: String(shape?.fill_color || shape?.color || '#1f6fb2'),
+          fillOpacity: Number.isFinite(Number(shape?.fill_opacity)) ? Number(shape.fill_opacity) : 0.12,
+          dashArray: shape?.dash_array ? String(shape.dash_array) : undefined,
+          pane: String(shape?.pane || 'mesa-bairros-pane'),
+          interactive: false,
+        }
+        let layer = null
+
+        if (shapeType === 'circle' && Array.isArray(shape?.center) && shape.center.length === 2) {
+          const center = parseLatLonPair(shape.center[0], shape.center[1])
+          if (center) {
+            layer = L.circle(center, { ...style, radius: Number(shape?.radius_m) || 0 })
+          }
+        } else if (shapeType === 'polyline' && Array.isArray(shape?.coords) && shape.coords.length) {
+          layer = L.polyline(shape.coords, style)
+        } else if (shapeType === 'polygon' && Array.isArray(shape?.coords) && shape.coords.length) {
+          layer = L.polygon(shape.coords, style)
+        } else if (shapeType === 'circlemarker' && Array.isArray(shape?.center) && shape.center.length === 2) {
+          const center = parseLatLonPair(shape.center[0], shape.center[1])
+          if (center) {
+            layer = L.circleMarker(center, { ...style, radius: Number(shape?.radius) || 6 })
+          }
+        }
+
+        if (layer) {
+          layerGroup.addLayer(layer)
+        }
+      })
+    }
+
+    const addGeoJsonOverlay = async (layerGroup, spec) => {
+      const geojsonLayer = L.geoJSON(null, {
+        pane: String(spec?.geojson_pane || 'mesa-bairros-pane'),
+        style: () => ({
+          color: String(spec?.geojson_style?.color || '#4c6882'),
+          weight: Number.isFinite(Number(spec?.geojson_style?.weight)) ? Number(spec.geojson_style.weight) : 1.0,
+          fillColor: String(spec?.geojson_style?.fillColor || '#f39c12'),
+          fillOpacity: Number.isFinite(Number(spec?.geojson_style?.fillOpacity))
+            ? Number(spec.geojson_style.fillOpacity)
+            : 0.04,
+          interactive: false,
+        }),
+      })
+      layerGroup.addLayer(geojsonLayer)
+
+      if (spec?.geojson_data) {
+        geojsonLayer.addData(spec.geojson_data)
+        return
+      }
+      if (!spec?.geojson_url) return
+      try {
+        const geojson = await carregarBairrosGeojson(spec.geojson_url)
+        if (geojson) {
+          geojsonLayer.addData(geojson)
+        }
+      } catch {
+        // Camada opcional; manter o download funcional mesmo sem bairros.
+      }
+    }
+
+    const addHeatmapOverlay = (layerGroup, heatmapSpec) => {
+      if (!heatmapSpec || typeof L.heatLayer !== 'function') return
+      const points = Array.isArray(heatmapSpec?.points)
+        ? heatmapSpec.points
+          .map((item) => {
+            const latlng = parseLatLonPair(item?.lat, item?.lon)
+            const weight = Number(item?.weight)
+            if (!latlng) return null
+            if (Number.isFinite(weight)) return [latlng[0], latlng[1], weight]
+            return latlng
+          })
+          .filter(Boolean)
+        : []
+      if (!points.length) return
+      const layer = L.heatLayer(points, {
+        radius: Number(heatmapSpec?.radius) || 20,
+        blur: Number(heatmapSpec?.blur) || 18,
+        minOpacity: Number.isFinite(Number(heatmapSpec?.min_opacity)) ? Number(heatmapSpec.min_opacity) : 0.28,
+        maxZoom: Number(heatmapSpec?.max_zoom) || 17,
+        gradient: heatmapSpec?.gradient || undefined,
+      })
+      layerGroup.addLayer(layer)
+    }
+
+    const overlayPromises = overlaySpecs.map(async (spec) => {
+      if (spec?.show === false) return
+      const layerGroup = L.layerGroup().addTo(exportMap)
+      if (spec?.geojson_url || spec?.geojson_data) {
+        await addGeoJsonOverlay(layerGroup, spec)
+      }
+      addHeatmapOverlay(layerGroup, spec?.heatmap)
+      addShapeOverlays(layerGroup, spec?.shapes)
+      addPointMarkers(layerGroup, spec?.points)
+    })
+
+    exportMap.setView(selectionCenter, exportZoom, { animate: false })
+    applyResponsiveRadius()
+    exportMap.on('zoomend', applyResponsiveRadius)
+
+    await Promise.all(overlayPromises)
+    await waitForTileLayerLoad(tileLayer)
+    await waitForNextPaint()
+    await waitForNextPaint()
+
+    const blob = await captureContainerRegionBlob(mount, null, 1)
+    exportMap.off('zoomend', applyResponsiveRadius)
+    return blob
+  } finally {
+    if (exportMap) {
+      exportMap.remove()
+    }
+    mount.remove()
+  }
+}
+
+async function captureContainerRegionBlob(container, selectionRect = null, scaleOverride = null) {
+  const hostRect = container.getBoundingClientRect()
+  const containerWidth = Math.round(hostRect.width)
+  const containerHeight = Math.round(hostRect.height)
+  const normalizedSelection = selectionRect
+    ? normalizeSelectionRect(selectionRect, containerWidth, containerHeight)
+    : {
+        left: 0,
+        top: 0,
+        width: containerWidth,
+        height: containerHeight,
+        right: containerWidth,
+        bottom: containerHeight,
+      }
+
+  if (!normalizedSelection || normalizedSelection.width <= 0 || normalizedSelection.height <= 0) {
+    throw new Error('Nao foi possivel montar a area de exportacao do mapa.')
+  }
+
+  const scale = Number.isFinite(Number(scaleOverride)) && Number(scaleOverride) > 0
+    ? Number(scaleOverride)
+    : computeSelectionExportScale(normalizedSelection)
+  const canvas = document.createElement('canvas')
+  canvas.width = Math.max(1, Math.round(normalizedSelection.width * scale))
+  canvas.height = Math.max(1, Math.round(normalizedSelection.height * scale))
+
+  const ctx = canvas.getContext('2d')
+  if (!ctx) {
+    throw new Error('O navegador nao conseguiu montar o canvas de exportacao.')
+  }
+
+  ctx.scale(scale, scale)
+  ctx.imageSmoothingEnabled = true
+  ctx.imageSmoothingQuality = 'high'
+  ctx.fillStyle = '#ffffff'
+  ctx.fillRect(0, 0, normalizedSelection.width, normalizedSelection.height)
+
+  const drawables = collectVisibleMapDrawables(container, hostRect)
+  for (const drawable of drawables) {
+    const { element, kind, rect } = drawable
+    const drawableRect = {
+      left: rect.left - hostRect.left,
+      top: rect.top - hostRect.top,
+      right: rect.right - hostRect.left,
+      bottom: rect.bottom - hostRect.top,
+      width: rect.width,
+      height: rect.height,
+    }
+    const overlap = intersectRectangles(drawableRect, normalizedSelection)
+    if (!overlap) continue
+
+    const sourceWidth = Math.max(1, drawableRect.width)
+    const sourceHeight = Math.max(1, drawableRect.height)
+    const sourceSize = resolveDrawableSourceSize(element, kind, sourceWidth, sourceHeight)
+    const ratioX = sourceSize.width / sourceWidth
+    const ratioY = sourceSize.height / sourceHeight
+    const sx = (overlap.left - drawableRect.left) * ratioX
+    const sy = (overlap.top - drawableRect.top) * ratioY
+    const sw = overlap.width * ratioX
+    const sh = overlap.height * ratioY
+    const dx = overlap.left - normalizedSelection.left
+    const dy = overlap.top - normalizedSelection.top
+
+    let source = element
+    if (kind === 'svg') {
+      const svgMarkup = serializeSvgElement(element, sourceWidth, sourceHeight)
+      source = await loadSvgImage(svgMarkup)
+    }
+
+    ctx.drawImage(source, sx, sy, sw, sh, dx, dy, overlap.width, overlap.height)
+  }
+
+  return canvasToBlob(canvas)
+}
+
+const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId }, ref) {
   const hostRef = useRef(null)
+  const mapRef = useRef(null)
+  const payloadRef = useRef(payload)
   const popupCacheRef = useRef(new Map())
   const [runtimeError, setRuntimeError] = useState('')
 
+  payloadRef.current = payload
+
+  useImperativeHandle(ref, () => ({
+    fitToPayloadBounds(padding = 48) {
+      const map = mapRef.current
+      if (!map) return false
+      return fitMapToPayloadBounds(map, payloadRef.current, padding)
+    },
+    async downloadSelectionPng(selectionRect, fileName = 'mapa-recorte.png') {
+      const container = hostRef.current
+      const blob = await buildHighResolutionSelectionBlob({
+        sourceMap: mapRef.current,
+        sourceContainer: container,
+        payload: payloadRef.current,
+        selectionRect,
+      })
+      downloadBlob(blob, fileName)
+      return true
+    },
+    async downloadVisiblePng(fileName = 'mapa.png') {
+      const container = hostRef.current
+      if (!container) {
+        throw new Error('Mapa indisponivel para exportacao.')
+      }
+
+      mapRef.current?.invalidateSize?.(false)
+      await waitForNextPaint()
+
+      const hostRect = container.getBoundingClientRect()
+      const width = Math.round(hostRect.width)
+      const height = Math.round(hostRect.height)
+      if (width <= 0 || height <= 0) {
+        throw new Error('O mapa ainda nao terminou de renderizar para exportacao.')
+      }
+
+      const deviceScale = Number(window.devicePixelRatio) || 1
+      const scale = Math.max(3, Math.min(5, deviceScale * 2))
+      const blob = await captureContainerRegionBlob(container, null, scale)
+      downloadBlob(blob, fileName)
+      return true
+    },
+  }), [])
+
   useEffect(() => {
     if (!hostRef.current || !payload) return undefined
     let disposed = false
@@ -378,6 +1022,7 @@ export default function LeafletMapFrame({ payload, sessionId }) {
       zoomControl: true,
       preferCanvas: true,
     })
+    mapRef.current = map
     let restoreMapInteractions = null
     const bairrosPane = map.createPane('mesa-bairros-pane')
     const marketPane = map.createPane('mesa-market-pane')
@@ -399,6 +1044,8 @@ export default function LeafletMapFrame({ payload, sessionId }) {
         attribution: index === 0
           ? '&copy; OpenStreetMap contributors'
           : '&copy; OpenStreetMap contributors &copy; CARTO',
+        crossOrigin: 'anonymous',
+        detectRetina: true,
       })
       const label = String(layerDef?.label || layerDef?.id || `Base ${index + 1}`)
       baseLayers[label] = tileLayer
@@ -523,7 +1170,9 @@ export default function LeafletMapFrame({ payload, sessionId }) {
       if (!Array.isArray(items) || !items.length) return
       responsivePointContainers.push(layerGroup)
       items.forEach((item) => {
-        const marker = L.circleMarker([Number(item.lat), Number(item.lon)], {
+        const latlng = parseLatLonPair(item?.lat, item?.lon)
+        if (!latlng) return
+        const marker = L.circleMarker(latlng, {
           renderer: canvasRenderer,
           pane: String(item?.pane || 'mesa-market-pane'),
           radius: Number(item?.base_radius) || 4,
@@ -552,13 +1201,15 @@ export default function LeafletMapFrame({ payload, sessionId }) {
     function addMarkerOverlays(layerGroup, items) {
       if (!Array.isArray(items) || !items.length) return
       items.forEach((item) => {
+        const latlng = parseLatLonPair(item?.lat, item?.lon)
+        if (!latlng) return
         const icon = L.divIcon({
           html: String(item?.marker_html || ''),
           iconSize: Array.isArray(item?.icon_size) ? item.icon_size : [14, 14],
           iconAnchor: Array.isArray(item?.icon_anchor) ? item.icon_anchor : [7, 7],
           className: String(item?.class_name || 'mesa-map-marker'),
         })
-        const marker = L.marker([Number(item.lat), Number(item.lon)], {
+        const marker = L.marker(latlng, {
           icon,
           pane: String(item?.pane || (String(item?.class_name || '').includes('indice') ? 'mesa-indices-pane' : 'mesa-trabalhos-pane')),
           bubblingMouseEvents: item?.bubbling_mouse_events === true,
@@ -635,13 +1286,19 @@ export default function LeafletMapFrame({ payload, sessionId }) {
         let layer = null
 
         if (shapeType === 'circle' && Array.isArray(shape?.center) && shape.center.length === 2) {
-          layer = L.circle(shape.center, { ...style, radius: Number(shape?.radius_m) || 0 })
+          const center = parseLatLonPair(shape.center[0], shape.center[1])
+          if (center) {
+            layer = L.circle(center, { ...style, radius: Number(shape?.radius_m) || 0 })
+          }
         } else if (shapeType === 'polyline' && Array.isArray(shape?.coords) && shape.coords.length) {
           layer = L.polyline(shape.coords, style)
         } else if (shapeType === 'polygon' && Array.isArray(shape?.coords) && shape.coords.length) {
           layer = L.polygon(shape.coords, style)
         } else if (shapeType === 'circlemarker' && Array.isArray(shape?.center) && shape.center.length === 2) {
-          layer = L.circleMarker(shape.center, { ...style, radius: Number(shape?.radius) || 6 })
+          const center = parseLatLonPair(shape.center[0], shape.center[1])
+          if (center) {
+            layer = L.circleMarker(center, { ...style, radius: Number(shape?.radius) || 6 })
+          }
         }
 
         if (!layer) return
@@ -701,12 +1358,11 @@ export default function LeafletMapFrame({ payload, sessionId }) {
       const points = Array.isArray(heatmapSpec?.points)
         ? heatmapSpec.points
           .map((item) => {
-            const lat = Number(item?.lat)
-            const lon = Number(item?.lon)
+            const latlng = parseLatLonPair(item?.lat, item?.lon)
             const weight = Number(item?.weight)
-            if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null
-            if (Number.isFinite(weight)) return [lat, lon, weight]
-            return [lat, lon]
+            if (!latlng) return null
+            if (Number.isFinite(weight)) return [latlng[0], latlng[1], weight]
+            return latlng
           })
           .filter(Boolean)
         : []
@@ -1038,12 +1694,7 @@ export default function LeafletMapFrame({ payload, sessionId }) {
     map.on('zoomend overlayadd overlayremove', applyResponsiveRadius)
     applyResponsiveRadius()
 
-    const bounds = Array.isArray(payload.bounds) ? payload.bounds : null
-    if (bounds && bounds.length === 2) {
-      map.fitBounds(bounds, { padding: [48, 48], maxZoom: 18, animate: false })
-    } else if (Array.isArray(payload.center) && payload.center.length === 2) {
-      map.setView(payload.center, 12)
-    } else {
+    if (!fitMapToPayloadBounds(map, payload, 48)) {
       setRuntimeError('Falha ao montar mapa interativo.')
     }
 
@@ -1054,6 +1705,9 @@ export default function LeafletMapFrame({ payload, sessionId }) {
       }
       disposed = true
       restoreMapInteractions?.()
+      if (mapRef.current === map) {
+        mapRef.current = null
+      }
       map.remove()
     }
   }, [payload, sessionId])
@@ -1064,4 +1718,6 @@ export default function LeafletMapFrame({ payload, sessionId }) {
       {runtimeError ? <div className="leaflet-map-runtime-error">{runtimeError}</div> : null}
     </div>
   )
-}
+})
+
+export default LeafletMapFrame

frontend/src/components/MapFrame.jsx

@@ -1,4 +1,4 @@
-import React, { useCallback, useEffect, useMemo, useRef } from 'react'
+import React, { forwardRef, useCallback, useEffect, useImperativeHandle, useMemo, useRef } from 'react'
 import LeafletMapFrame from './LeafletMapFrame'
 
 function hashHtml(value) {
@@ -11,8 +11,9 @@ function hashHtml(value) {
   return `${value.length}-${Math.abs(hash)}`
 }
 
-export default function MapFrame({ html, payload = null, sessionId = '' }) {
+const MapFrame = forwardRef(function MapFrame({ html, payload = null, sessionId = '' }, ref) {
   const iframeRef = useRef(null)
+  const leafletRef = useRef(null)
   const timersRef = useRef([])
   const frameKey = useMemo(() => hashHtml(html || ''), [html])
 
@@ -130,8 +131,29 @@ export default function MapFrame({ html, payload = null, sessionId = '' }) {
     }
   }, [clearTimers])
 
+  useImperativeHandle(ref, () => ({
+    fitToPayloadBounds(padding = 48) {
+      if (leafletRef.current?.fitToPayloadBounds) {
+        return leafletRef.current.fitToPayloadBounds(padding)
+      }
+      return false
+    },
+    async downloadSelectionPng(selectionRect, fileName = 'mapa-recorte.png') {
+      if (leafletRef.current?.downloadSelectionPng) {
+        return leafletRef.current.downloadSelectionPng(selectionRect, fileName)
+      }
+      throw new Error('A exportacao em PNG esta disponivel apenas para mapas interativos.')
+    },
+    async downloadVisiblePng(fileName = 'mapa.png') {
+      if (leafletRef.current?.downloadVisiblePng) {
+        return leafletRef.current.downloadVisiblePng(fileName)
+      }
+      throw new Error('A exportacao em PNG esta disponivel apenas para mapas interativos.')
+    },
+  }), [])
+
   if (payload && payload.type === 'mesa_leaflet_payload') {
-    return <LeafletMapFrame payload={payload} sessionId={sessionId} />
+    return <LeafletMapFrame ref={leafletRef} payload={payload} sessionId={sessionId} />
   }
 
   if (!html) {
@@ -149,4 +171,6 @@ export default function MapFrame({ html, payload = null, sessionId = '' }) {
       onLoad={scheduleRecenter}
     />
   )
-}
+})
+
+export default MapFrame

frontend/src/components/PesquisaTab.jsx

@@ -120,17 +120,41 @@ function formatAvaliandoGeoLabel(index) {
   return `A${index + 1}`
 }
 
+function parseCoordinateValue(value) {
+  if (value === null || value === undefined) return null
+  const text = String(value).trim().replace(',', '.')
+  if (!text) return null
+  const parsed = Number(text)
+  return Number.isFinite(parsed) ? parsed : null
+}
+
+function normalizeLogradouroOption(item) {
+  if (typeof item === 'string') {
+    const text = String(item || '').trim()
+    return text ? { value: text, label: text } : null
+  }
+  if (!item || typeof item !== 'object') return null
+  const value = String(item.value ?? item.logradouro ?? '').trim()
+  if (!value) return null
+  const label = String(item.label ?? item.display_label ?? value).trim() || value
+  return {
+    value,
+    label,
+    secondary: String(item.secondary ?? '').trim(),
+  }
+}
+
 function buildAvaliandosGeoPayload(entries = []) {
   return (entries || []).map((item, index) => ({
     id: String(item?.id || `avaliando-${index + 1}`),
     label: formatAvaliandoGeoLabel(index),
-    lat: Number(item?.lat),
-    lon: Number(item?.lon),
+    lat: parseCoordinateValue(item?.lat),
+    lon: parseCoordinateValue(item?.lon),
     logradouro: item?.logradouro || null,
     numero_usado: item?.numero_usado || null,
     cdlog: item?.cdlog ?? null,
     origem: item?.origem || null,
-  })).filter((item) => Number.isFinite(item.lat) && Number.isFinite(item.lon))
+  })).filter((item) => item.lat !== null && item.lon !== null)
 }
 
 function getResumoEspacialValor(resumo, criterio) {
@@ -187,8 +211,8 @@ function createLocalizacaoEntry(resolvida, id) {
   return {
     ...resolvida,
     id,
-    lat: Number(resolvida?.lat),
-    lon: Number(resolvida?.lon),
+    lat: parseCoordinateValue(resolvida?.lat),
+    lon: parseCoordinateValue(resolvida?.lon),
   }
 }
 
@@ -1069,13 +1093,13 @@ export default function PesquisaTab({
       pesquisaExecutada: true,
       avaliandos: avaliandosGeolocalizados.map((item, index) => ({
         id: String(item?.id || `avaliando-${index + 1}`),
-        lat: Number(item?.lat),
-        lon: Number(item?.lon),
+        lat: parseCoordinateValue(item?.lat),
+        lon: parseCoordinateValue(item?.lon),
         logradouro: String(item?.logradouro || ''),
         numero_usado: String(item?.numero_usado || ''),
         cdlog: item?.cdlog ?? null,
         origem: String(item?.origem || 'coords'),
-      })).filter((item) => Number.isFinite(item.lat) && Number.isFinite(item.lon)),
+      })).filter((item) => item.lat !== null && item.lon !== null),
     }
   }
 
@@ -1269,7 +1293,7 @@ export default function PesquisaTab({
     try {
       const response = await api.pesquisarLogradourosEixos()
       const opcoes = Array.isArray(response?.logradouros_eixos)
-        ? response.logradouros_eixos.map((item) => String(item || '').trim()).filter(Boolean)
+        ? response.logradouros_eixos.map(normalizeLogradouroOption).filter(Boolean)
         : []
       setLogradouroOptions(opcoes)
       setLogradouroOptionsLoaded(true)
@@ -1300,9 +1324,9 @@ export default function PesquisaTab({
     const rawAvaliandos = Array.isArray(routeRequest?.avaliandos) ? routeRequest.avaliandos : []
     let nextEntries = rawAvaliandos
       .map((item, index) => {
-        const lat = Number(item?.lat)
-        const lon = Number(item?.lon)
-        if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null
+        const lat = parseCoordinateValue(item?.lat)
+        const lon = parseCoordinateValue(item?.lon)
+        if (lat === null || lon === null) return null
         return createLocalizacaoEntry({
           lat,
           lon,
@@ -1313,9 +1337,9 @@ export default function PesquisaTab({
         }, String(item?.id || `avaliando-${localizacaoIdCounterRef.current + index}`))
       })
       .filter(Boolean)
-    const lat = Number(routeRequest?.avaliando?.lat)
-    const lon = Number(routeRequest?.avaliando?.lon)
-    const possuiAvaliando = Number.isFinite(lat) && Number.isFinite(lon)
+    const lat = parseCoordinateValue(routeRequest?.avaliando?.lat)
+    const lon = parseCoordinateValue(routeRequest?.avaliando?.lon)
+    const possuiAvaliando = lat !== null && lon !== null
     if (!nextEntries.length && possuiAvaliando) {
       nextEntries = [createLocalizacaoEntry({
         lat,
@@ -1763,8 +1787,8 @@ export default function PesquisaTab({
       })
       const resolvida = {
         ...response,
-        lat: Number(response?.lat),
-        lon: Number(response?.lon),
+        lat: parseCoordinateValue(response?.lat),
+        lon: parseCoordinateValue(response?.lon),
       }
       const nextEntry = createLocalizacaoEntry(
         resolvida,

frontend/src/deepLinks.js

@@ -144,7 +144,7 @@ export function hasMesaDeepLink(intent) {
     || trimValue(intent.trabalhoId)
     || trimValue(intent.subtab)
     || hasPesquisaFilters(intent.filters)
-    || (intent.avaliando && Number.isFinite(Number(intent.avaliando.lat)) && Number.isFinite(Number(intent.avaliando.lon))),
+    || (intent.avaliando && parseFiniteNumber(intent.avaliando.lat) !== null && parseFiniteNumber(intent.avaliando.lon) !== null),
   )
 }
 

frontend/src/styles.css

@@ -4121,6 +4121,42 @@ button.pesquisa-coluna-remove:hover {
   width: min(1180px, 100%);
 }
 
+.avaliacao-localizacao-map-modal {
+  width: min(980px, 100%);
+}
+
+.avaliacao-localizacao-download-modal {
+  width: min(1180px, 100%);
+}
+
+.avaliacao-localizacao-map-modal-actions {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+}
+
+.avaliacao-download-toggle-btn {
+  color: #ffffff;
+}
+
+.avaliacao-download-toggle-btn.is-select {
+  --btn-bg-start: #2f80cf;
+  --btn-bg-end: #2368af;
+  --btn-border: #1f5f9f;
+  background: linear-gradient(180deg, var(--btn-bg-start) 0%, var(--btn-bg-end) 100%);
+  border-color: var(--btn-border);
+}
+
+.avaliacao-download-toggle-btn.is-clear {
+  --btn-bg-start: #8d98a5;
+  --btn-bg-end: #778290;
+  --btn-border: #687380;
+  background: linear-gradient(180deg, var(--btn-bg-start) 0%, var(--btn-bg-end) 100%);
+  border-color: var(--btn-border);
+}
+
 .avaliacao-knn-legenda {
   display: flex;
   flex-wrap: wrap;
@@ -4130,11 +4166,58 @@ button.pesquisa-coluna-remove:hover {
   margin-bottom: 2px;
 }
 
+.avaliacao-localizacao-map-wrap .map-frame,
+.avaliacao-localizacao-download-map-wrap .map-frame,
 .avaliacao-knn-map-wrap .map-frame {
   min-height: 420px;
   height: 420px;
 }
 
+.avaliacao-localizacao-download-map-wrap .map-frame {
+  min-height: 560px;
+  height: 560px;
+}
+
+.avaliacao-localizacao-download-status {
+  font-size: 0.84rem;
+  color: #4d6479;
+}
+
+.avaliacao-localizacao-download-map-wrap {
+  position: relative;
+}
+
+.avaliacao-localizacao-download-map-wrap.is-selecting .map-frame {
+  pointer-events: none;
+}
+
+.avaliacao-download-selection-layer {
+  position: absolute;
+  inset: 0;
+  pointer-events: none;
+  z-index: 1400;
+}
+
+.avaliacao-download-selection-layer.is-active {
+  pointer-events: auto;
+  cursor: crosshair;
+  touch-action: none;
+}
+
+.avaliacao-download-selection-layer.is-active::before {
+  content: '';
+  position: absolute;
+  inset: 0;
+  background: rgba(9, 18, 28, 0.06);
+}
+
+.avaliacao-download-selection-rect {
+  position: absolute;
+  border: 2px dashed rgba(215, 38, 61, 0.96);
+  background: rgba(255, 255, 255, 0.16);
+  box-shadow: 0 0 0 1px rgba(255, 255, 255, 0.72);
+}
+
 .avaliacao-knn-detalhes-box {
   margin-bottom: 0;
 }
@@ -4217,6 +4300,7 @@ button.pesquisa-coluna-remove:hover {
 }
 
 @media (max-width: 900px) {
+  .avaliacao-localizacao-map-wrap .map-frame,
   .avaliacao-knn-map-wrap .map-frame {
     min-height: 340px;
     height: 340px;
@@ -7310,6 +7394,11 @@ button.btn-download-subtle {
     flex-direction: column;
   }
 
+  .avaliacao-localizacao-map-modal-actions {
+    width: 100%;
+    justify-content: flex-end;
+  }
+
   .pesquisa-card-values-modal-actions {
     width: 100%;
     justify-content: flex-end;