inclusao de coordenadas do avaliando e modificacao do mapa

backend/app/api/pesquisa.py

@@ -8,6 +8,7 @@ from app.services.pesquisa_service import (
     gerar_mapa_modelos,
     listar_modelos,
     obter_admin_config_pesquisa,
+    resolver_localizacao_avaliando,
     salvar_admin_config_pesquisa,
 )
 
@@ -23,6 +24,17 @@ def _split_csv(value: str | None) -> list[str]:
 
 class MapaModelosPayload(BaseModel):
     modelos_ids: list[str]
+    avaliando_lat: float | None = None
+    avaliando_lon: float | None = None
+    modo_exibicao: str | None = "pontos"
+
+
+class LocalizacaoAvaliandoPayload(BaseModel):
+    latitude: float | None = None
+    longitude: float | None = None
+    logradouro: str | None = None
+    numero: float | None = None
+    cdlog: int | None = None
 
 
 class PesquisaAdminConfigPayload(BaseModel):
@@ -42,6 +54,7 @@ def pesquisar_admin_config_salvar(payload: PesquisaAdminConfigPayload) -> dict:
 @router.get("/modelos")
 def pesquisar_modelos(
     somente_contexto: bool = Query(False),
+    somente_versoes_atuais: bool = Query(True),
     otica: str = Query("avaliando"),
     nome: str | None = Query(None),
     autor: str | None = Query(None),
@@ -83,6 +96,8 @@ def pesquisar_modelos(
     aval_valor_unitario_colunas: str | None = Query(None),
     aval_valor_total: float | None = Query(None),
     aval_valor_total_colunas: str | None = Query(None),
+    aval_lat: float | None = Query(None),
+    aval_lon: float | None = Query(None),
     limite: int = Query(300, ge=1, le=2000),
 ) -> dict:
     filtros = PesquisaFiltros(
@@ -127,10 +142,29 @@ def pesquisar_modelos(
         aval_valor_unitario_colunas=_split_csv(aval_valor_unitario_colunas),
         aval_valor_total=aval_valor_total,
         aval_valor_total_colunas=_split_csv(aval_valor_total_colunas),
+        aval_lat=aval_lat,
+        aval_lon=aval_lon,
+        somente_versoes_atuais=somente_versoes_atuais,
     )
     return listar_modelos(filtros=filtros, limite=limite, somente_contexto=somente_contexto)
 
 
+@router.post("/localizar-avaliando")
+def pesquisar_localizar_avaliando(payload: LocalizacaoAvaliandoPayload) -> dict:
+    return resolver_localizacao_avaliando(
+        latitude=payload.latitude,
+        longitude=payload.longitude,
+        logradouro=payload.logradouro,
+        numero=payload.numero,
+        cdlog=payload.cdlog,
+    )
+
+
 @router.post("/mapa-modelos")
 def pesquisar_mapa_modelos(payload: MapaModelosPayload) -> dict:
-    return gerar_mapa_modelos(payload.modelos_ids)
+    return gerar_mapa_modelos(
+        payload.modelos_ids,
+        avaliando_lat=payload.avaliando_lat,
+        avaliando_lon=payload.avaliando_lon,
+        modo_exibicao=payload.modo_exibicao,
+    )

backend/app/services/pesquisa_service.py

@@ -16,6 +16,7 @@ import pandas as pd
 from fastapi import HTTPException
 from joblib import load
 
+from app.core.elaboracao import geocodificacao
 from app.core.elaboracao.core import _migrar_pacote_v1_para_v2, normalizar_observacao_modelo
 from app.core.map_layers import add_bairros_layer, add_indice_marker, add_zoom_responsive_circle_markers
 from app.services import model_repository
@@ -144,6 +145,9 @@ MAP_COLORS = [
     "#7f7f7f",
 ]
 
+DISTANCIA_METRIC_CRS = "EPSG:31982"
+VERSAO_MODELO_RE = re.compile(r"^(?P<base>.*?)(?P<sufixo>[A-Za-z])$")
+
 
 @dataclass(frozen=True)
 class PesquisaFiltros:
@@ -188,6 +192,9 @@ class PesquisaFiltros:
     aval_valor_unitario_colunas: list[str] | None = None
     aval_valor_total: float | None = None
     aval_valor_total_colunas: list[str] | None = None
+    aval_lat: float | None = None
+    aval_lon: float | None = None
+    somente_versoes_atuais: bool = True
 
 
 _CACHE_LOCK = Lock()
@@ -195,6 +202,7 @@ _CACHE: dict[str, dict[str, Any]] = {}
 _ADMIN_CONFIG_LOCK = Lock()
 _CACHE_SOURCE_SIGNATURE: str | None = None
 _ADMIN_FONTES_SESSION: dict[str, list[str]] = {}
+_CATALOGO_VIAS_CACHE: list[dict[str, Any]] | None = None
 
 
 def _resolver_repositorio_modelos() -> model_repository.ModelRepositoryResolution:
@@ -259,6 +267,8 @@ def listar_modelos(filtros: PesquisaFiltros, limite: int | None = None, somente_
     colunas_filtro = _montar_config_colunas_filtro(todos)
     admin_fontes = _carregar_fontes_admin(colunas_filtro)
     sugestoes = _extrair_sugestoes(todos, admin_fontes)
+    aval_lat, aval_lon = _normalizar_coordenadas_avaliando(filtros_exec.aval_lat, filtros_exec.aval_lon)
+    ids_versoes_antigas = _ids_versoes_antigas(todos) if filtros_exec.somente_versoes_atuais else set()
 
     if somente_contexto:
         return sanitize_value(
@@ -313,6 +323,9 @@ def listar_modelos(filtros: PesquisaFiltros, limite: int | None = None, somente_
                     "aval_valor_unitario_colunas": filtros.aval_valor_unitario_colunas or [],
                     "aval_valor_total": filtros.aval_valor_total,
                     "aval_valor_total_colunas": filtros.aval_valor_total_colunas or [],
+                    "aval_lat": aval_lat,
+                    "aval_lon": aval_lon,
+                    "somente_versoes_atuais": bool(filtros_exec.somente_versoes_atuais),
                 },
             }
         )
@@ -323,6 +336,19 @@ def listar_modelos(filtros: PesquisaFiltros, limite: int | None = None, somente_
         filtrados = [_anexar_avaliando_info(item, filtros_exec, admin_fontes) for item in filtrados]
         filtrados = [item for item in filtrados if item.get("avaliando", {}).get("aceito")]
 
+    if ids_versoes_antigas:
+        filtrados = [item for item in filtrados if str(item.get("id") or "") not in ids_versoes_antigas]
+
+    if aval_lat is not None and aval_lon is not None:
+        filtrados = [_anexar_distancia_modelo(item, aval_lat, aval_lon) for item in filtrados]
+        filtrados.sort(
+            key=lambda item: (
+                item.get("distancia_km") is None,
+                float(item.get("distancia_km") or 0.0),
+                str(item.get("nome_modelo") or item.get("arquivo") or item.get("id") or "").lower(),
+            )
+        )
+
     if limite and limite > 0:
         filtrados = filtrados[:limite]
 
@@ -380,12 +406,144 @@ def listar_modelos(filtros: PesquisaFiltros, limite: int | None = None, somente_
                 "aval_valor_unitario_colunas": filtros.aval_valor_unitario_colunas or [],
                 "aval_valor_total": filtros.aval_valor_total,
                 "aval_valor_total_colunas": filtros.aval_valor_total_colunas or [],
+                "aval_lat": aval_lat,
+                "aval_lon": aval_lon,
+                "somente_versoes_atuais": bool(filtros_exec.somente_versoes_atuais),
             },
         }
     )
 
 
-def gerar_mapa_modelos(modelos_ids: list[str], limite_pontos_por_modelo: int = 0) -> dict[str, Any]:
+def resolver_localizacao_avaliando(
+    *,
+    latitude: float | None = None,
+    longitude: float | None = None,
+    logradouro: str | None = None,
+    numero: Any = None,
+    cdlog: Any = None,
+) -> dict[str, Any]:
+    lat, lon = _normalizar_coordenadas_avaliando(latitude, longitude)
+    if lat is not None and lon is not None:
+        return sanitize_value(
+            {
+                "lat": lat,
+                "lon": lon,
+                "origem": "coordenadas",
+                "status": f"Coordenadas do avaliando definidas em {lat:.6f}, {lon:.6f}.",
+            }
+        )
+
+    numero_int = _to_int_or_none(numero)
+    if numero_int is None or numero_int <= 0:
+        raise HTTPException(status_code=400, detail="Informe um numero valido para localizar o avaliando")
+
+    cdlog_int = _to_int_or_none(cdlog)
+    via_resolvida = None
+    if cdlog_int is None:
+        via_resolvida = _resolver_via_por_logradouro(logradouro)
+        cdlog_int = via_resolvida["cdlog"]
+    else:
+        via_resolvida = _resolver_via_por_cdlog(cdlog_int)
+
+    df_base = pd.DataFrame([{"CDLOG": cdlog_int, "NUMERO": numero_int}])
+    df_geo, df_falhas, ajustados = geocodificacao.geocodificar(df_base, "CDLOG", "NUMERO", auto_200=False)
+    lat = _to_float_or_none(df_geo.iloc[0].get("lat")) if not df_geo.empty else None
+    lon = _to_float_or_none(df_geo.iloc[0].get("lon")) if not df_geo.empty else None
+    lat, lon = _normalizar_coordenadas_avaliando(lat, lon)
+    if lat is None or lon is None:
+        sugestoes = ""
+        motivo = "Nao foi possivel localizar o endereco informado nos eixos."
+        if not df_falhas.empty:
+            linha_falha = df_falhas.iloc[0]
+            sugestoes = str(linha_falha.get("sugestoes") or "").strip()
+            motivo = str(linha_falha.get("motivo") or motivo).strip() or motivo
+        detalhe = motivo
+        if sugestoes:
+            detalhe = f"{motivo} Sugestoes de numeracao: {sugestoes}."
+        raise HTTPException(status_code=400, detail=detalhe)
+
+    numero_usado = numero_int
+    if ajustados:
+        try:
+            numero_usado = int(ajustados[0].get("numero_usado") or numero_int)
+        except Exception:
+            numero_usado = numero_int
+
+    logradouro_resolvido = str(via_resolvida.get("logradouro") or "").strip()
+    status = f"Endereco localizado em {logradouro_resolvido}, {numero_usado}."
+    if numero_usado != numero_int:
+        status += f" Numero interpolado mais proximo: {numero_usado}."
+
+    return sanitize_value(
+        {
+            "lat": lat,
+            "lon": lon,
+            "origem": "eixos",
+            "cdlog": cdlog_int,
+            "logradouro": logradouro_resolvido,
+            "numero_informado": numero_int,
+            "numero_usado": numero_usado,
+            "status": status,
+        }
+    )
+
+
+def _ids_versoes_antigas(modelos: list[dict[str, Any]]) -> set[str]:
+    grupos: dict[str, list[tuple[str, str]]] = {}
+
+    for modelo in modelos:
+        versao_info = _extrair_info_versao_modelo(modelo)
+        if versao_info is None:
+            continue
+        base_norm, sufixo, modelo_id = versao_info
+        grupos.setdefault(base_norm, []).append((sufixo, modelo_id))
+
+    ids_antigos: set[str] = set()
+    for itens in grupos.values():
+        if len(itens) < 2:
+            continue
+        sufixos_distintos = {sufixo for sufixo, _modelo_id in itens}
+        if len(sufixos_distintos) < 2:
+            continue
+        ultimo_sufixo = max(sufixos_distintos)
+        for sufixo, modelo_id in itens:
+            if sufixo != ultimo_sufixo:
+                ids_antigos.add(modelo_id)
+
+    return ids_antigos
+
+
+def _extrair_info_versao_modelo(modelo: dict[str, Any]) -> tuple[str, str, str] | None:
+    modelo_id = _str_or_none(modelo.get("id"))
+    if not modelo_id:
+        return None
+
+    candidatos = [
+        _texto_nome_modelo_sugestao(modelo.get("nome_modelo")),
+        _texto_nome_modelo_sugestao(modelo.get("arquivo")),
+        _texto_nome_modelo_sugestao(modelo.get("id")),
+    ]
+    for candidato in candidatos:
+        if not candidato:
+            continue
+        match = VERSAO_MODELO_RE.match(candidato)
+        if not match:
+            continue
+        base = _normalize(match.group("base"))
+        sufixo = str(match.group("sufixo") or "").upper()
+        if not base or not sufixo:
+            continue
+        return (base, sufixo, modelo_id)
+    return None
+
+
+def gerar_mapa_modelos(
+    modelos_ids: list[str],
+    limite_pontos_por_modelo: int = 0,
+    avaliando_lat: float | None = None,
+    avaliando_lon: float | None = None,
+    modo_exibicao: str | None = "pontos",
+) -> dict[str, Any]:
     ids = [str(item).strip() for item in (modelos_ids or []) if str(item).strip()]
     if not ids:
         raise HTTPException(status_code=400, detail="Selecione ao menos um modelo para gerar o mapa")
@@ -407,8 +565,13 @@ def gerar_mapa_modelos(modelos_ids: list[str], limite_pontos_por_modelo: int = 0
     if not selecionados:
         raise HTTPException(status_code=404, detail="Nenhum modelo selecionado foi encontrado na pasta de pesquisa")
 
+    modo_exibicao_norm = _normalizar_modo_exibicao_mapa(modo_exibicao)
+
     modelos_plotados: list[dict[str, Any]] = []
     bounds: list[list[float]] = []
+    aval_lat, aval_lon = _normalizar_coordenadas_avaliando(avaliando_lat, avaliando_lon)
+    if aval_lat is not None and aval_lon is not None:
+        bounds.append([aval_lat, aval_lon])
 
     for idx, (modelo_id, caminho) in enumerate(selecionados):
         resumo = _carregar_resumo_com_cache(caminho)
@@ -420,8 +583,10 @@ def gerar_mapa_modelos(modelos_ids: list[str], limite_pontos_por_modelo: int = 0
         if not pontos:
             continue
 
+        geometria = _carregar_geometria_modelo_com_cache(caminho)
         cor = MAP_COLORS[idx % len(MAP_COLORS)]
         nome = str(resumo.get("nome_modelo") or modelo_id)
+        distancia_info = _calcular_distancia_geometria_cache(geometria, aval_lat, aval_lon)
 
         modelos_plotados.append(
             {
@@ -430,9 +595,13 @@ def gerar_mapa_modelos(modelos_ids: list[str], limite_pontos_por_modelo: int = 0
                 "cor": cor,
                 "total_pontos": len(pontos),
                 "pontos": pontos,
+                "geometria": geometria,
+                "distancia_km": distancia_info.get("distancia_km"),
+                "distancia_label": distancia_info.get("distancia_label"),
             }
         )
         bounds.extend([[ponto["lat"], ponto["lon"]] for ponto in pontos])
+        bounds.extend(_extrair_bounds_geometria_wgs84(geometria))
 
     if not modelos_plotados:
         raise HTTPException(
@@ -440,6 +609,62 @@ def gerar_mapa_modelos(modelos_ids: list[str], limite_pontos_por_modelo: int = 0
             detail="Nao foi possivel gerar o mapa: os modelos selecionados nao possuem coordenadas validas",
         )
 
+    total_pontos = 0
+    for modelo in modelos_plotados:
+        total_pontos += int(modelo["total_pontos"])
+    mapas_html = {
+        "pontos": _renderizar_mapa_modelos(modelos_plotados, bounds, aval_lat, aval_lon, "pontos"),
+        "cobertura": _renderizar_mapa_modelos(modelos_plotados, bounds, aval_lat, aval_lon, "cobertura"),
+    }
+
+    return sanitize_value(
+        {
+            "mapa_html": mapas_html[modo_exibicao_norm],
+            "mapa_html_pontos": mapas_html["pontos"],
+            "mapa_html_cobertura": mapas_html["cobertura"],
+            "total_modelos_plotados": len(modelos_plotados),
+            "total_pontos": total_pontos,
+            "modelos_plotados": [
+                {
+                    "id": modelo["id"],
+                    "nome": modelo["nome"],
+                    "cor": modelo["cor"],
+                    "total_pontos": modelo["total_pontos"],
+                    "distancia_km": modelo.get("distancia_km"),
+                    "distancia_label": modelo.get("distancia_label"),
+                }
+                for modelo in modelos_plotados
+            ],
+            "avaliando": {
+                "lat": aval_lat,
+                "lon": aval_lon,
+                "ativo": bool(aval_lat is not None and aval_lon is not None),
+            },
+            "modo_exibicao": modo_exibicao_norm,
+            "status": (
+                f"Mapas de pontos e cobertura gerados com {len(modelos_plotados)} modelo(s) e {total_pontos} ponto(s)"
+                + (" com avaliando destacado." if aval_lat is not None and aval_lon is not None else ".")
+            ),
+        }
+    )
+
+
+def _normalizar_modo_exibicao_mapa(value: Any) -> str:
+    modo = str(value or "").strip().lower()
+    if modo == "cobertura":
+        return "cobertura"
+    return "pontos"
+
+
+def _renderizar_mapa_modelos(
+    modelos_plotados: list[dict[str, Any]],
+    bounds: list[list[float]],
+    aval_lat: float | None,
+    aval_lon: float | None,
+    modo_exibicao: str,
+) -> str:
+    renderizar_pontos = modo_exibicao == "pontos"
+    renderizar_cobertura = modo_exibicao == "cobertura"
     centro_lat = sum(coord[0] for coord in bounds) / len(bounds)
     centro_lon = sum(coord[1] for coord in bounds) / len(bounds)
 
@@ -453,38 +678,59 @@ def gerar_mapa_modelos(modelos_ids: list[str], limite_pontos_por_modelo: int = 0
     folium.TileLayer(tiles="CartoDB positron", name="Positron", control=True, show=False).add_to(mapa)
     add_bairros_layer(mapa, show=True)
 
-    total_pontos = 0
-    mostrar_indices = sum(int(modelo["total_pontos"]) for modelo in modelos_plotados) <= 800
+    mostrar_indices = renderizar_pontos and sum(int(modelo["total_pontos"]) for modelo in modelos_plotados) <= 800
     camada_indices = folium.FeatureGroup(name="Índices", show=False) if mostrar_indices else None
-    for modelo in modelos_plotados:
-        total_pontos += int(modelo["total_pontos"])
-        camada = folium.FeatureGroup(name=f'{modelo["nome"]} ({modelo["total_pontos"]})', show=True)
-        for ponto in modelo["pontos"]:
-            marcador = folium.CircleMarker(
-                location=[ponto["lat"], ponto["lon"]],
-                radius=3,
-                color=modelo["cor"],
-                fill=True,
-                fill_color=modelo["cor"],
-                fill_opacity=0.72,
-                opacity=0.9,
-                weight=1,
-                tooltip=modelo["nome"],
-            ).add_to(camada)
-            marcador.options["mesaBaseRadius"] = 3.0
-            if mostrar_indices and camada_indices is not None and ponto.get("indice") is not None:
-                add_indice_marker(
-                    camada_indices,
-                    lat=float(ponto["lat"]),
-                    lon=float(ponto["lon"]),
-                    indice=ponto["indice"],
-                )
-        camada.add_to(mapa)
+    camada_pontos = folium.FeatureGroup(name="Dados de mercado", show=True) if renderizar_pontos else None
+    camada_poligonos = folium.FeatureGroup(name="Cobertura dos modelos", show=True) if renderizar_cobertura else None
+    camada_avaliando = folium.FeatureGroup(name="Avaliando", show=True)
+    camada_distancias = folium.FeatureGroup(name="Distancias", show=False) if renderizar_cobertura else None
 
+    for modelo in modelos_plotados:
+        tooltip_modelo = modelo["nome"]
+        if modelo.get("distancia_label"):
+            tooltip_modelo = f'{tooltip_modelo} • Distancia: {modelo["distancia_label"]}'
+
+        if renderizar_pontos and camada_pontos is not None:
+            for ponto in modelo["pontos"]:
+                marcador = folium.CircleMarker(
+                    location=[ponto["lat"], ponto["lon"]],
+                    radius=3,
+                    color=modelo["cor"],
+                    fill=True,
+                    fill_color=modelo["cor"],
+                    fill_opacity=0.72,
+                    opacity=0.9,
+                    weight=1,
+                    tooltip=tooltip_modelo,
+                ).add_to(camada_pontos)
+                marcador.options["mesaBaseRadius"] = 3.0
+                if mostrar_indices and camada_indices is not None and ponto.get("indice") is not None:
+                    add_indice_marker(
+                        camada_indices,
+                        lat=float(ponto["lat"]),
+                        lon=float(ponto["lon"]),
+                        indice=ponto["indice"],
+                    )
+
+        if renderizar_cobertura and camada_poligonos is not None:
+            _adicionar_geometria_modelo_no_mapa(camada_poligonos, camada_distancias, modelo, aval_lat, aval_lon)
+
+    if camada_pontos is not None:
+        camada_pontos.add_to(mapa)
     if mostrar_indices and camada_indices is not None:
         camada_indices.add_to(mapa)
+    if camada_poligonos is not None:
+        camada_poligonos.add_to(mapa)
+    if aval_lat is not None and aval_lon is not None:
+        folium.Marker(
+            location=[aval_lat, aval_lon],
+            tooltip="Avaliando",
+            icon=folium.Icon(color="red", icon="home", prefix="glyphicon"),
+        ).add_to(camada_avaliando)
+        camada_avaliando.add_to(mapa)
+    if camada_distancias is not None and any(modelo.get("distancia_km") not in (None, "") for modelo in modelos_plotados):
+        camada_distancias.add_to(mapa)
 
-    folium.LayerControl(collapsed=False).add_to(mapa)
     plugins.Fullscreen().add_to(mapa)
     add_zoom_responsive_circle_markers(mapa)
     if bounds:
@@ -502,23 +748,7 @@ def gerar_mapa_modelos(modelos_ids: list[str], limite_pontos_por_modelo: int = 0
             lon_max += lon_delta
         mapa.fit_bounds([[lat_min, lon_min], [lat_max, lon_max]], padding=(48, 48), max_zoom=18)
 
-    return sanitize_value(
-        {
-            "mapa_html": mapa.get_root().render(),
-            "total_modelos_plotados": len(modelos_plotados),
-            "total_pontos": total_pontos,
-            "modelos_plotados": [
-                {
-                    "id": modelo["id"],
-                    "nome": modelo["nome"],
-                    "cor": modelo["cor"],
-                    "total_pontos": modelo["total_pontos"],
-                }
-                for modelo in modelos_plotados
-            ],
-            "status": f"Mapa gerado com {len(modelos_plotados)} modelo(s) e {total_pontos} ponto(s)",
-        }
-    )
+    return mapa.get_root().render()
 
 
 def _carregar_resumo_com_cache(caminho_modelo: Path) -> dict[str, Any]:
@@ -541,6 +771,25 @@ def _carregar_resumo_com_cache(caminho_modelo: Path) -> dict[str, Any]:
     return dict(resumo)
 
 
+def _carregar_geometria_modelo_com_cache(caminho_modelo: Path) -> dict[str, Any] | None:
+    assinatura = _assinatura_arquivos(caminho_modelo)
+    cache_key = str(caminho_modelo)
+
+    with _CACHE_LOCK:
+        cached = _CACHE.get(cache_key)
+        if cached and cached.get("assinatura") == assinatura and "geometria" in cached:
+            return cached.get("geometria")
+
+    geometria = _construir_geometria_modelo(caminho_modelo)
+
+    with _CACHE_LOCK:
+        entry = _CACHE.setdefault(cache_key, {})
+        entry["assinatura"] = assinatura
+        entry["geometria"] = geometria
+
+    return geometria
+
+
 def _assinatura_arquivos(caminho_modelo: Path) -> tuple[int, int]:
     stat_modelo = caminho_modelo.stat()
     return (stat_modelo.st_mtime_ns, stat_modelo.st_size)
@@ -579,6 +828,7 @@ def _construir_resumo_modelo(caminho_modelo: Path) -> dict[str, Any]:
         "_texto_colunas_index": {},
         "_faixa_colunas_index": {},
         "_faixa_variaveis_index": {},
+        "_caminho_modelo": str(caminho_modelo),
     }
 
     try:
@@ -870,6 +1120,37 @@ def _coletar_pontos_modelo(df_modelo: pd.DataFrame, limite_pontos: int) -> list[
     ]
 
 
+def _construir_geometria_modelo(caminho_modelo: Path) -> dict[str, Any] | None:
+    df_modelo = _carregar_dataframe_modelo(caminho_modelo)
+    pontos = _coletar_pontos_modelo(df_modelo, 0)
+    if not pontos:
+        return None
+
+    try:
+        from shapely.geometry import MultiPoint
+    except ImportError:
+        return None
+
+    coordenadas = [(float(item["lon"]), float(item["lat"])) for item in pontos]
+    if not coordenadas:
+        return None
+
+    try:
+        hull = MultiPoint(coordenadas).convex_hull
+    except Exception:
+        return None
+    if hull is None or getattr(hull, "is_empty", False):
+        return None
+
+    geom_metric = _transformar_geometria_para_metrico(hull)
+    return {
+        "geom_wgs84": hull,
+        "geom_metric": geom_metric,
+        "geom_type": str(getattr(hull, "geom_type", "") or ""),
+        "total_pontos": len(pontos),
+    }
+
+
 def _formatar_indice_mapa(indice: Any) -> str:
     if isinstance(indice, (int, np.integer)):
         return str(int(indice))
@@ -886,6 +1167,290 @@ def _identificar_coluna_por_alias(colunas: Any, aliases: list[str]) -> str | Non
     return None
 
 
+def _normalizar_coordenadas_avaliando(lat_raw: Any, lon_raw: Any) -> tuple[float | None, float | None]:
+    lat = _to_float_or_none(lat_raw)
+    lon = _to_float_or_none(lon_raw)
+    if lat is None or lon is None:
+        return None, None
+    if not (-90.0 <= lat <= 90.0) or not (-180.0 <= lon <= 180.0):
+        return None, None
+    return float(lat), float(lon)
+
+
+def _anexar_distancia_modelo(modelo: dict[str, Any], aval_lat: float, aval_lon: float) -> dict[str, Any]:
+    item = dict(modelo)
+    caminho_texto = str(item.get("_caminho_modelo") or "").strip()
+    if not caminho_texto:
+        item["distancia_km"] = None
+        item["distancia_label"] = "-"
+        item["avaliando_dentro_cobertura"] = None
+        return item
+
+    geometria = _carregar_geometria_modelo_com_cache(Path(caminho_texto))
+    distancia = _calcular_distancia_geometria_cache(geometria, aval_lat, aval_lon)
+    item["distancia_km"] = distancia.get("distancia_km")
+    item["distancia_label"] = distancia.get("distancia_label")
+    item["avaliando_dentro_cobertura"] = distancia.get("avaliando_dentro_cobertura")
+    return item
+
+
+def _calcular_distancia_geometria_cache(
+    geometria: dict[str, Any] | None,
+    aval_lat: float | None,
+    aval_lon: float | None,
+) -> dict[str, Any]:
+    if geometria is None or aval_lat is None or aval_lon is None:
+        return {"distancia_km": None, "distancia_label": "-", "avaliando_dentro_cobertura": None}
+
+    geom_metric = geometria.get("geom_metric")
+    if geom_metric is None:
+        return {"distancia_km": None, "distancia_label": "-", "avaliando_dentro_cobertura": None}
+
+    ponto_metric = _criar_ponto_metrico(aval_lat, aval_lon)
+    if ponto_metric is None:
+        return {"distancia_km": None, "distancia_label": "-", "avaliando_dentro_cobertura": None}
+
+    try:
+        distancia_m = float(ponto_metric.distance(geom_metric))
+    except Exception:
+        return {"distancia_km": None, "distancia_label": "-", "avaliando_dentro_cobertura": None}
+
+    if not np.isfinite(distancia_m):
+        return {"distancia_km": None, "distancia_label": "-", "avaliando_dentro_cobertura": None}
+
+    distancia_km = max(0.0, distancia_m / 1000.0)
+    return {
+        "distancia_km": float(distancia_km),
+        "distancia_label": _formatar_distancia_km(distancia_km),
+        "avaliando_dentro_cobertura": bool(distancia_m <= 1e-6),
+    }
+
+
+def _formatar_distancia_km(distancia_km: float | None) -> str:
+    if distancia_km is None or not np.isfinite(distancia_km):
+        return "-"
+    return f"{float(distancia_km):,.2f} km".replace(",", "X").replace(".", ",").replace("X", ".")
+
+
+def _transformar_geometria_para_metrico(geom: Any) -> Any:
+    if geom is None:
+        return None
+    try:
+        from pyproj import Transformer
+        from shapely.ops import transform
+    except ImportError:
+        return None
+
+    try:
+        transformer = Transformer.from_crs("EPSG:4326", DISTANCIA_METRIC_CRS, always_xy=True)
+        return transform(transformer.transform, geom)
+    except Exception:
+        return None
+
+
+def _criar_ponto_metrico(lat: float, lon: float) -> Any:
+    try:
+        from shapely.geometry import Point
+    except ImportError:
+        return None
+    ponto = Point(float(lon), float(lat))
+    return _transformar_geometria_para_metrico(ponto)
+
+
+def _adicionar_geometria_modelo_no_mapa(
+    camada_poligonos: folium.FeatureGroup,
+    camada_distancias: folium.FeatureGroup,
+    modelo: dict[str, Any],
+    aval_lat: float | None,
+    aval_lon: float | None,
+) -> None:
+    geometria = modelo.get("geometria") or {}
+    geom_wgs84 = geometria.get("geom_wgs84")
+    if geom_wgs84 is None:
+        return
+
+    tooltip = str(modelo.get("nome") or "").strip() or "Modelo"
+    if modelo.get("distancia_label"):
+        tooltip = f'{tooltip} • Distancia: {modelo["distancia_label"]}'
+
+    geom_type = str(geometria.get("geom_type") or "")
+    cor = str(modelo.get("cor") or "#1f77b4")
+
+    try:
+        if geom_type == "Polygon":
+            coords = [[float(lat), float(lon)] for lon, lat in list(geom_wgs84.exterior.coords)]
+            folium.Polygon(
+                locations=coords,
+                color=cor,
+                fill=True,
+                fill_color=cor,
+                fill_opacity=0.12,
+                weight=2,
+                tooltip=tooltip,
+            ).add_to(camada_poligonos)
+        elif geom_type == "LineString":
+            coords = [[float(lat), float(lon)] for lon, lat in list(geom_wgs84.coords)]
+            folium.PolyLine(locations=coords, color=cor, weight=3, opacity=0.8, tooltip=tooltip).add_to(camada_poligonos)
+        elif geom_type == "Point":
+            folium.CircleMarker(
+                location=[float(geom_wgs84.y), float(geom_wgs84.x)],
+                radius=6,
+                color=cor,
+                fill=True,
+                fill_color=cor,
+                fill_opacity=0.7,
+                tooltip=tooltip,
+            ).add_to(camada_poligonos)
+    except Exception:
+        return
+
+    if aval_lat is None or aval_lon is None:
+        return
+
+    try:
+        from shapely.geometry import Point
+        from shapely.ops import nearest_points
+    except ImportError:
+        return
+
+    try:
+        aval_point = Point(float(aval_lon), float(aval_lat))
+        _, nearest_geom = nearest_points(aval_point, geom_wgs84)
+        distancia_km = _to_float_or_none(modelo.get("distancia_km"))
+        if nearest_geom is None or distancia_km is None or distancia_km <= 0:
+            return
+        folium.PolyLine(
+            locations=[
+                [float(aval_point.y), float(aval_point.x)],
+                [float(nearest_geom.y), float(nearest_geom.x)],
+            ],
+            color=cor,
+            weight=2,
+            opacity=0.65,
+            dash_array="6,6",
+            tooltip=f'Ligacao de distancia • {tooltip}',
+        ).add_to(camada_distancias)
+    except Exception:
+        return
+
+
+def _extrair_bounds_geometria_wgs84(geometria: dict[str, Any] | None) -> list[list[float]]:
+    if geometria is None or geometria.get("geom_wgs84") is None:
+        return []
+    try:
+        min_x, min_y, max_x, max_y = geometria["geom_wgs84"].bounds
+    except Exception:
+        return []
+    return [[float(min_y), float(min_x)], [float(max_y), float(max_x)]]
+
+
+def _resolver_via_por_cdlog(cdlog: int) -> dict[str, Any]:
+    catalogo = _carregar_catalogo_vias()
+    for item in catalogo:
+        if int(item["cdlog"]) == int(cdlog):
+            return item
+    raise HTTPException(status_code=404, detail="CDLOG informado nao foi encontrado nos eixos")
+
+
+def _resolver_via_por_logradouro(logradouro: str | None) -> dict[str, Any]:
+    texto = str(logradouro or "").strip()
+    if not texto:
+        raise HTTPException(status_code=400, detail="Informe o logradouro para localizar o avaliando")
+
+    consulta = _normalize(texto)
+    catalogo = _carregar_catalogo_vias()
+    melhores: list[tuple[int, dict[str, Any]]] = []
+    for item in catalogo:
+        score = _score_logradouro(consulta, item)
+        if score <= 0:
+            continue
+        melhores.append((score, item))
+
+    if not melhores:
+        raise HTTPException(status_code=404, detail="Nenhum logradouro compativel foi encontrado nos eixos")
+
+    melhores.sort(key=lambda entry: (-entry[0], str(entry[1].get("logradouro") or "").lower(), int(entry[1].get("cdlog") or 0)))
+    melhor_score, melhor_item = melhores[0]
+    if melhor_score < 60:
+        sugestoes = ", ".join(str(item.get("logradouro") or "") for _, item in melhores[:5])
+        detalhe = "Nao foi possivel identificar com seguranca o logradouro informado."
+        if sugestoes:
+            detalhe += f" Sugestoes: {sugestoes}."
+        raise HTTPException(status_code=400, detail=detalhe)
+    return melhor_item
+
+
+def _carregar_catalogo_vias() -> list[dict[str, Any]]:
+    global _CATALOGO_VIAS_CACHE
+    if _CATALOGO_VIAS_CACHE is not None:
+        return list(_CATALOGO_VIAS_CACHE)
+
+    gdf = geocodificacao.carregar_eixos()
+    if gdf is None or gdf.empty:
+        raise HTTPException(status_code=500, detail="Base de eixos indisponivel para localizar o avaliando")
+
+    cols = {str(col).upper(): col for col in gdf.columns}
+    cdlog_col = cols.get("CDLOG")
+    nome_col = cols.get("NMIDELOG")
+    prefixo_col = cols.get("NMIDEPRE")
+    abreviado_col = cols.get("NMIDEABR")
+    if cdlog_col is None or nome_col is None:
+        raise HTTPException(status_code=500, detail="Base de eixos sem colunas necessarias para localizar o avaliando")
+
+    vistos: set[int] = set()
+    catalogo: list[dict[str, Any]] = []
+    for _, row in gdf.iterrows():
+        cdlog = _to_int_or_none(row.get(cdlog_col))
+        if cdlog is None or cdlog in vistos:
+            continue
+        vistos.add(cdlog)
+        nome = str(row.get(nome_col) or "").strip()
+        prefixo = str(row.get(prefixo_col) or "").strip() if prefixo_col else ""
+        abreviado = str(row.get(abreviado_col) or "").strip() if abreviado_col else ""
+        logradouro = " ".join(item for item in [prefixo, nome] if item).strip() or nome or abreviado
+        aliases = _dedupe_strings([logradouro, nome, abreviado])
+        catalogo.append(
+            {
+                "cdlog": cdlog,
+                "logradouro": logradouro,
+                "_aliases_norm": [_normalize(item) for item in aliases if _normalize(item)],
+            }
+        )
+    _CATALOGO_VIAS_CACHE = list(catalogo)
+    return list(catalogo)
+
+
+def _score_logradouro(consulta: str, item: dict[str, Any]) -> int:
+    if not consulta:
+        return 0
+    aliases = [str(alias or "").strip() for alias in item.get("_aliases_norm") or [] if str(alias or "").strip()]
+    if not aliases:
+        return 0
+    melhor = 0
+    consulta_tokens = [tok for tok in consulta.split() if tok]
+    for alias in aliases:
+        if alias == consulta:
+            melhor = max(melhor, 120)
+            continue
+        if alias.startswith(consulta):
+            melhor = max(melhor, 100)
+            continue
+        if consulta in alias:
+            melhor = max(melhor, 82)
+        if consulta_tokens and all(tok in alias for tok in consulta_tokens):
+            melhor = max(melhor, 72)
+    return melhor
+
+
+def _to_int_or_none(value: Any) -> int | None:
+    if _is_empty(value):
+        return None
+    try:
+        return int(float(str(value).strip()))
+    except Exception:
+        return None
+
+
 def _extrair_bairros(df: pd.DataFrame) -> list[str]:
     candidatos = [col for col in df.columns if _has_alias(str(col), BAIRRO_ALIASES)]
     bairros: list[str] = []
@@ -1319,6 +1884,7 @@ def _extrair_sugestoes(
     finalidades: list[str] = []
     bairros: list[str] = []
     enderecos: list[str] = []
+    logradouros_eixos: list[str] = []
     tipos_modelo: list[str] = []
     zonas_avaliacao: list[str] = []
 
@@ -1341,12 +1907,21 @@ def _extrair_sugestoes(
         tipos_modelo.append(str(_tipo_modelo_modelo(modelo) or ""))
         zonas_avaliacao.extend(_zonas_avaliacao_modelo(modelo))
 
+    try:
+        logradouros_eixos = [
+            str(item.get("logradouro") or "").strip()
+            for item in _carregar_catalogo_vias()
+        ]
+    except HTTPException:
+        logradouros_eixos = []
+
     return {
         "nomes_modelo": _lista_textos_unicos(nomes, limite),
         "autores": _lista_textos_unicos(autores, limite),
         "finalidades": _lista_textos_unicos(finalidades, limite),
         "bairros": _lista_textos_unicos(bairros, limite),
         "enderecos": _lista_textos_unicos(enderecos, limite),
+        "logradouros_eixos": _lista_textos_unicos(logradouros_eixos, None),
         "tipos_modelo": _lista_textos_unicos(tipos_modelo, limite),
         "zonas_avaliacao": _lista_zonas_unicas(zonas_avaliacao, limite),
     }
@@ -1819,7 +2394,7 @@ def _indexar_faixas_variaveis(estat_df: pd.DataFrame | None, variaveis_modelo: l
     return indice
 
 
-def _lista_textos_unicos(valores: list[str], limite: int) -> list[str]:
+def _lista_textos_unicos(valores: list[str], limite: int | None) -> list[str]:
     unicos: list[str] = []
     vistos = set()
     for valor in valores:
@@ -1831,9 +2406,10 @@ def _lista_textos_unicos(valores: list[str], limite: int) -> list[str]:
             continue
         vistos.add(chave)
         unicos.append(texto)
-        if len(unicos) >= limite:
-            break
-    return sorted(unicos, key=lambda item: item.lower())
+    ordenados = sorted(unicos, key=lambda item: item.lower())
+    if limite is None or limite <= 0:
+        return ordenados
+    return ordenados[:limite]
 
 
 def _aceita_valor_na_faixa(faixa: dict[str, Any] | None, valor: Any) -> bool:

frontend/src/api.js

@@ -174,8 +174,16 @@ export const api = {
     const query = params.toString()
     return getJson(query ? `/api/pesquisa/modelos?${query}` : '/api/pesquisa/modelos')
   },
-  pesquisarMapaModelos(modelosIds = []) {
-    return postJson('/api/pesquisa/mapa-modelos', { modelos_ids: modelosIds })
+  pesquisarLocalizacaoAvaliando(payload = {}) {
+    return postJson('/api/pesquisa/localizar-avaliando', payload)
+  },
+  pesquisarMapaModelos(modelosIds = [], avaliando = null, modoExibicao = 'pontos') {
+    return postJson('/api/pesquisa/mapa-modelos', {
+      modelos_ids: modelosIds,
+      avaliando_lat: avaliando?.lat ?? null,
+      avaliando_lon: avaliando?.lon ?? null,
+      modo_exibicao: modoExibicao,
+    })
   },
 
   uploadElaboracaoFile(sessionId, file) {

frontend/src/components/PesquisaTab.jsx

@@ -8,6 +8,7 @@ import MapFrame from './MapFrame'
 import PlotFigure from './PlotFigure'
 import PesquisaAdminConfigPanel from './PesquisaAdminConfigPanel'
 import SectionBlock from './SectionBlock'
+import SinglePillAutocomplete from './SinglePillAutocomplete'
 import { getFaixaDataRecencyInfo } from '../modelRecency'
 
 const EMPTY_FILTERS = {
@@ -16,6 +17,7 @@ const EMPTY_FILTERS = {
   negociacaoModelo: '',
   dataMin: '',
   dataMax: '',
+  versionamentoModelos: 'atuais',
   avalFinalidade: '',
   avalZona: '',
   avalBairro: '',
@@ -23,6 +25,14 @@ const EMPTY_FILTERS = {
   avalRh: '',
 }
 
+const EMPTY_LOCATION_INPUTS = {
+  latitude: '',
+  longitude: '',
+  logradouro: '',
+  numero: '',
+  cdlog: '',
+}
+
 const RESULT_INITIAL = {
   modelos: [],
   sugestoes: {},
@@ -79,6 +89,12 @@ function formatCount(value) {
   return String(value)
 }
 
+function formatDistanceKm(value) {
+  const number = Number(value)
+  if (!Number.isFinite(number)) return '-'
+  return `${number.toLocaleString('pt-BR', { minimumFractionDigits: 2, maximumFractionDigits: 2 })} km`
+}
+
 function formatDateBrIfIso(value) {
   const text = String(value ?? '').trim()
   if (!text) return '-'
@@ -469,8 +485,8 @@ function formatTipoImovel(modelo) {
   return mapped || text
 }
 
-function buildApiFilters(filters) {
-  return {
+function buildApiFilters(filters, localizacaoResolvida = null) {
+  const payload = {
     otica: 'avaliando',
     nome: filters.nomeModelo,
     tipo_modelo: filters.tipoModelo,
@@ -480,9 +496,17 @@ function buildApiFilters(filters) {
     aval_bairro: filters.avalBairro,
     data_min: filters.dataMin,
     data_max: filters.dataMax,
+    somente_versoes_atuais: filters.versionamentoModelos !== 'incluir_antigos',
     aval_area: filters.avalArea,
     aval_rh: filters.avalRh,
   }
+  const lat = Number(localizacaoResolvida?.lat)
+  const lon = Number(localizacaoResolvida?.lon)
+  if (Number.isFinite(lat) && Number.isFinite(lon)) {
+    payload.aval_lat = lat
+    payload.aval_lon = lon
+  }
+  return payload
 }
 
 function toInputName(field) {
@@ -788,6 +812,12 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
 
   const [filters, setFilters] = useState(EMPTY_FILTERS)
   const [result, setResult] = useState(RESULT_INITIAL)
+  const [localizacaoModo, setLocalizacaoModo] = useState('endereco')
+  const [localizacaoInputs, setLocalizacaoInputs] = useState(EMPTY_LOCATION_INPUTS)
+  const [localizacaoResolvida, setLocalizacaoResolvida] = useState(null)
+  const [localizacaoLoading, setLocalizacaoLoading] = useState(false)
+  const [localizacaoError, setLocalizacaoError] = useState('')
+  const [localizacaoStatus, setLocalizacaoStatus] = useState('')
 
   const [selectedIds, setSelectedIds] = useState([])
   const selectAllRef = useRef(null)
@@ -795,8 +825,10 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
   const [mapaLoading, setMapaLoading] = useState(false)
   const [mapaError, setMapaError] = useState('')
   const [mapaStatus, setMapaStatus] = useState('')
-  const [mapaHtml, setMapaHtml] = useState('')
+  const [mapaHtmls, setMapaHtmls] = useState({ pontos: '', cobertura: '' })
   const [mapaLegendas, setMapaLegendas] = useState([])
+  const [mapaModoExibicao, setMapaModoExibicao] = useState('pontos')
+  const [mapaIdsVisiveis, setMapaIdsVisiveis] = useState([])
 
   const [modeloAbertoMeta, setModeloAbertoMeta] = useState(null)
   const [modeloAbertoLoading, setModeloAbertoLoading] = useState(false)
@@ -830,6 +862,8 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
   const modoModeloAberto = Boolean(modeloAbertoMeta)
   const todosSelecionados = resultIds.length > 0 && resultIds.every((id) => selectedIds.includes(id))
   const algunsSelecionados = resultIds.some((id) => selectedIds.includes(id))
+  const localizacaoAtiva = Number.isFinite(Number(localizacaoResolvida?.lat)) && Number.isFinite(Number(localizacaoResolvida?.lon))
+  const mapaHtmlAtual = mapaHtmls[mapaModoExibicao] || ''
 
   function scrollToElementTop(el, behavior = 'smooth', offsetPx = 0) {
     if (!el || typeof window === 'undefined') return
@@ -856,11 +890,51 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
     })
   }
 
-  async function buscarModelos(nextFilters = filters) {
+  function resetMapaPesquisa() {
+    setMapaHtmls({ pontos: '', cobertura: '' })
+    setMapaStatus('')
+    setMapaLegendas([])
+    setMapaError('')
+    setMapaModoExibicao('pontos')
+    setMapaIdsVisiveis([])
+  }
+
+  async function carregarMapaPesquisa(ids, { atualizarLegendas = false } = {}) {
+    const idsValidos = (ids || []).map((item) => String(item || '').trim()).filter(Boolean)
+
+    if (!idsValidos.length) {
+      setMapaHtmls({ pontos: '', cobertura: '' })
+      setMapaStatus('Nenhum modelo marcado para exibição no mapa.')
+      setMapaError('')
+      setMapaIdsVisiveis([])
+      return
+    }
+
+    setMapaLoading(true)
+    setMapaError('')
+    try {
+      const response = await api.pesquisarMapaModelos(idsValidos, localizacaoResolvida)
+      setMapaHtmls({
+        pontos: response.mapa_html_pontos || '',
+        cobertura: response.mapa_html_cobertura || '',
+      })
+      setMapaStatus(response.status || '')
+      setMapaIdsVisiveis(idsValidos)
+      if (atualizarLegendas) {
+        setMapaLegendas(response.modelos_plotados || [])
+      }
+    } catch (err) {
+      setMapaError(err.message)
+    } finally {
+      setMapaLoading(false)
+    }
+  }
+
+  async function buscarModelos(nextFilters = filters, nextLocalizacao = localizacaoResolvida) {
     setLoading(true)
     setError('')
     try {
-      const response = await api.pesquisarModelos(buildApiFilters(nextFilters))
+      const response = await api.pesquisarModelos(buildApiFilters(nextFilters, nextLocalizacao))
       const modelos = response.modelos || []
       const idsNovos = new Set(modelos.map((item) => item.id))
 
@@ -873,10 +947,7 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
 
       setSelectedIds((current) => current.filter((id) => idsNovos.has(id)))
 
-      setMapaHtml('')
-      setMapaStatus('')
-      setMapaLegendas([])
-      setMapaError('')
+      resetMapaPesquisa()
       setPesquisaInicializada(true)
       setSugestoesInicializadas(true)
     } catch (err) {
@@ -899,10 +970,7 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
         sugestoes: response.sugestoes || {},
       })
       setSelectedIds([])
-      setMapaHtml('')
-      setMapaStatus('')
-      setMapaLegendas([])
-      setMapaError('')
+      resetMapaPesquisa()
       setPesquisaInicializada(false)
       setSugestoesInicializadas(true)
     } catch (err) {
@@ -923,14 +991,36 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
   }, [algunsSelecionados, todosSelecionados])
 
   function onFieldChange(event) {
+    const { value, checked, type, dataset, name } = event.target
+    const field = dataset.field || name
+    if (!field) return
+    setFilters((prev) => ({ ...prev, [field]: type === 'checkbox' ? checked : value }))
+  }
+
+  function onLocalizacaoFieldChange(event) {
     const { value, dataset, name } = event.target
     const field = dataset.field || name
     if (!field) return
-    setFilters((prev) => ({ ...prev, [field]: value }))
+    atualizarCampoLocalizacao(field, value)
+  }
+
+  function atualizarCampoLocalizacao(field, value) {
+    if (!field) return
+    setLocalizacaoInputs((prev) => ({ ...prev, [field]: value }))
+    if (localizacaoResolvida) {
+      setLocalizacaoResolvida(null)
+    }
+    setLocalizacaoError('')
+    setLocalizacaoStatus('')
+    resetMapaPesquisa()
   }
 
   async function onLimparFiltros() {
     setFilters(EMPTY_FILTERS)
+    setLocalizacaoInputs(EMPTY_LOCATION_INPUTS)
+    setLocalizacaoResolvida(null)
+    setLocalizacaoError('')
+    setLocalizacaoStatus('')
     await carregarContextoInicial()
   }
 
@@ -1049,26 +1139,93 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
       return
     }
 
-    setMapaLoading(true)
-    setMapaError('')
+    setMapaModoExibicao('pontos')
+    await carregarMapaPesquisa(selectedIds, { atualizarLegendas: true })
+  }
+
+  async function onToggleLegendaMapa(modeloId) {
+    const modeloIdNorm = String(modeloId || '').trim()
+    if (!modeloIdNorm || mapaLoading) return
+
+    const ativosAtuais = mapaIdsVisiveis.length
+      ? mapaIdsVisiveis
+      : mapaLegendas.map((item) => item.id)
+    const nextIds = ativosAtuais.includes(modeloIdNorm)
+      ? ativosAtuais.filter((id) => id !== modeloIdNorm)
+      : [...ativosAtuais, modeloIdNorm]
+
+    await carregarMapaPesquisa(nextIds, { atualizarLegendas: false })
+  }
+
+  async function onAdminConfigSalva() {
+    if (pesquisaInicializada) {
+      await buscarModelos(filters, localizacaoResolvida)
+      return
+    }
+    await carregarContextoInicial()
+  }
+
+  async function onResolverLocalizacao() {
+    setLocalizacaoError('')
+    setLocalizacaoStatus('')
+    if (localizacaoModo === 'coords') {
+      const lat = Number(localizacaoInputs.latitude)
+      const lon = Number(localizacaoInputs.longitude)
+      if (!Number.isFinite(lat) || !Number.isFinite(lon)) {
+        setLocalizacaoError('Informe latitude e longitude válidas para localizar o avaliando.')
+        return
+      }
+    } else {
+      if (!String(localizacaoInputs.logradouro || '').trim()) {
+        setLocalizacaoError('Informe o logradouro para localizar o avaliando.')
+        return
+      }
+      const numero = Number(localizacaoInputs.numero)
+      if (!Number.isFinite(numero) || numero <= 0) {
+        setLocalizacaoError('Informe um número válido para localizar o avaliando.')
+        return
+      }
+    }
+
+    setLocalizacaoLoading(true)
     try {
-      const response = await api.pesquisarMapaModelos(selectedIds)
-      setMapaHtml(response.mapa_html || '')
-      setMapaStatus(response.status || '')
-      setMapaLegendas(response.modelos_plotados || [])
+      const response = await api.pesquisarLocalizacaoAvaliando({
+        latitude: localizacaoModo === 'coords' ? Number(localizacaoInputs.latitude) : null,
+        longitude: localizacaoModo === 'coords' ? Number(localizacaoInputs.longitude) : null,
+        logradouro: localizacaoModo === 'endereco' ? String(localizacaoInputs.logradouro || '').trim() : null,
+        numero: localizacaoModo === 'endereco' ? Number(localizacaoInputs.numero) : null,
+        cdlog: localizacaoModo === 'endereco' && String(localizacaoInputs.cdlog || '').trim()
+          ? Number(localizacaoInputs.cdlog)
+          : null,
+      })
+      const resolvida = {
+        ...response,
+        lat: Number(response?.lat),
+        lon: Number(response?.lon),
+      }
+      setLocalizacaoResolvida(resolvida)
+      setLocalizacaoStatus(response?.status || 'Localização do avaliando definida.')
+      resetMapaPesquisa()
+      if (pesquisaInicializada) {
+        await buscarModelos(filters, resolvida)
+      }
     } catch (err) {
-      setMapaError(err.message)
+      setLocalizacaoError(err.message || 'Falha ao localizar o avaliando.')
+      setLocalizacaoResolvida(null)
     } finally {
-      setMapaLoading(false)
+      setLocalizacaoLoading(false)
     }
   }
 
-  async function onAdminConfigSalva() {
+  async function onLimparLocalizacao() {
+    setLocalizacaoInputs(EMPTY_LOCATION_INPUTS)
+    setLocalizacaoResolvida(null)
+    setLocalizacaoError('')
+    setLocalizacaoStatus('')
+    resetMapaPesquisa()
     if (pesquisaInicializada) {
-      await buscarModelos()
-      return
+      await buscarModelos(filters, null)
     }
-    await carregarContextoInicial()
   }
 
   if (modoModeloAberto) {
@@ -1285,18 +1442,177 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
           </div>
         </div>
 
-        <div className="pesquisa-field-pair pesquisa-avaliando-periodo-pair">
-          <span className="pesquisa-field-pair-title">Período mínimo desejado</span>
-          <label className="pesquisa-field">
-            Data inicial
-            <DateFieldInput field="dataMin" value={filters.dataMin} onChange={onFieldChange} />
-          </label>
-          <label className="pesquisa-field">
-            Data final
-            <DateFieldInput field="dataMax" value={filters.dataMax} onChange={onFieldChange} />
+        <div className="pesquisa-periodo-versoes-grid">
+          <div className="pesquisa-periodo-fields">
+            <label className="pesquisa-field">
+              Data inicial
+              <DateFieldInput field="dataMin" value={filters.dataMin} onChange={onFieldChange} />
+            </label>
+            <label className="pesquisa-field">
+              Data final
+              <DateFieldInput field="dataMax" value={filters.dataMax} onChange={onFieldChange} />
+            </label>
+          </div>
+
+          <label className="pesquisa-field pesquisa-versionamento-field">
+            Versionamento dos modelos
+            <select
+              data-field="versionamentoModelos"
+              name={toInputName('versionamentoModelos')}
+              value={filters.versionamentoModelos}
+              onChange={onFieldChange}
+              autoComplete="off"
+            >
+              <option value="atuais">Exibir somente versões mais atuais</option>
+              <option value="incluir_antigos">Incluir também modelos substituídos</option>
+            </select>
           </label>
         </div>
 
+        <div className="pesquisa-field-pair pesquisa-localizacao-group">
+          <span className="pesquisa-field-pair-title">Localização do avaliando (opcional)</span>
+          <div className="pesquisa-localizacao-optional-hint">
+            O preenchimento deste grupo não é obrigatório. Se você não informar localização, a pesquisa continua normal e apenas a distância espacial dos modelos não será calculada.
+          </div>
+
+          {localizacaoModo === 'coords' ? (
+            <div className="pesquisa-localizacao-grid pesquisa-localizacao-grid-coords">
+              <label className="pesquisa-field">
+                Forma de localização
+                <select
+                  data-field="localizacaoModo"
+                  name={toInputName('localizacaoModo')}
+                  value={localizacaoModo}
+                  onChange={(event) => setLocalizacaoModo(event.target.value)}
+                  autoComplete="off"
+                >
+                  <option value="endereco">Endereço</option>
+                  <option value="coords">Coordenadas</option>
+                </select>
+              </label>
+              <label className="pesquisa-field">
+                Latitude
+                <NumberFieldInput field="latitude" value={localizacaoInputs.latitude} onChange={onLocalizacaoFieldChange} placeholder="-30.000000" />
+              </label>
+              <label className="pesquisa-field">
+                Longitude
+                <NumberFieldInput field="longitude" value={localizacaoInputs.longitude} onChange={onLocalizacaoFieldChange} placeholder="-51.000000" />
+              </label>
+              <div className="pesquisa-localizacao-actions-inline">
+                <button
+                  type="button"
+                  className="pesquisa-localizacao-action pesquisa-localizacao-action-ok"
+                  onClick={() => void onResolverLocalizacao()}
+                  disabled={localizacaoLoading}
+                >
+                  {localizacaoLoading ? 'Buscando...' : 'Buscar'}
+                </button>
+                <button
+                  type="button"
+                  className="pesquisa-localizacao-action pesquisa-localizacao-action-reset"
+                  onClick={() => void onLimparLocalizacao()}
+                  disabled={localizacaoLoading}
+                >
+                  Limpar
+                </button>
+              </div>
+            </div>
+          ) : (
+            <div className="pesquisa-localizacao-grid pesquisa-localizacao-grid-endereco">
+              <label className="pesquisa-field">
+                Forma de localização
+                <select
+                  data-field="localizacaoModo"
+                  name={toInputName('localizacaoModo')}
+                  value={localizacaoModo}
+                  onChange={(event) => setLocalizacaoModo(event.target.value)}
+                  autoComplete="off"
+                >
+                  <option value="endereco">Endereço</option>
+                  <option value="coords">Coordenadas</option>
+                </select>
+              </label>
+              <label className="pesquisa-field">
+                CDLOG
+                <NumberFieldInput field="cdlog" value={localizacaoInputs.cdlog} onChange={onLocalizacaoFieldChange} placeholder="Opcional" />
+              </label>
+              <label className="pesquisa-field pesquisa-localizacao-logradouro-field">
+                Logradouro
+                <SinglePillAutocomplete
+                  value={localizacaoInputs.logradouro}
+                  onChange={(nextValue) => atualizarCampoLocalizacao('logradouro', nextValue)}
+                  options={sugestoes.logradouros_eixos || []}
+                  placeholder="Digite ou selecione um logradouro dos eixos"
+                  panelTitle="Logradouros dos eixos"
+                  emptyMessage="Nenhum logradouro encontrado nos eixos."
+                  loading={loading && !sugestoesInicializadas}
+                  inputName={toInputName('logradouroEixosPesquisa')}
+                  inputAutoComplete="new-password"
+                />
+              </label>
+              <label className="pesquisa-field">
+                Número
+                <NumberFieldInput field="numero" value={localizacaoInputs.numero} onChange={onLocalizacaoFieldChange} placeholder="0" />
+              </label>
+              <div className="pesquisa-localizacao-actions-inline">
+                <button
+                  type="button"
+                  className="pesquisa-localizacao-action pesquisa-localizacao-action-ok"
+                  onClick={() => void onResolverLocalizacao()}
+                  disabled={localizacaoLoading}
+                >
+                  {localizacaoLoading ? 'Buscando...' : 'Buscar'}
+                </button>
+                <button
+                  type="button"
+                  className="pesquisa-localizacao-action pesquisa-localizacao-action-reset"
+                  onClick={() => void onLimparLocalizacao()}
+                  disabled={localizacaoLoading}
+                >
+                  Limpar
+                </button>
+              </div>
+            </div>
+          )}
+
+          {localizacaoStatus && !localizacaoAtiva ? <div className="status-line">{localizacaoStatus}</div> : null}
+          {localizacaoError ? <div className="error-line inline-error">{localizacaoError}</div> : null}
+
+          {localizacaoAtiva ? (
+            <div className="pesquisa-localizacao-summary">
+              {localizacaoResolvida?.logradouro ? (
+                <div className="pesquisa-localizacao-summary-row">
+                  <span className="pesquisa-localizacao-summary-label">Endereço</span>
+                  <span className="pesquisa-localizacao-summary-value">
+                    {localizacaoResolvida.logradouro}
+                    {localizacaoResolvida?.numero_usado ? `, ${localizacaoResolvida.numero_usado}` : ''}
+                  </span>
+                </div>
+              ) : null}
+              {localizacaoResolvida?.cdlog ? (
+                <div className="pesquisa-localizacao-summary-row">
+                  <span className="pesquisa-localizacao-summary-label">CDLOG</span>
+                  <span className="pesquisa-localizacao-summary-value">{localizacaoResolvida.cdlog}</span>
+                </div>
+              ) : null}
+              <div className="pesquisa-localizacao-summary-row">
+                <span className="pesquisa-localizacao-summary-label">Latitude</span>
+                <span className="pesquisa-localizacao-summary-value">{Number(localizacaoResolvida.lat).toFixed(6)}</span>
+              </div>
+              <div className="pesquisa-localizacao-summary-row">
+                <span className="pesquisa-localizacao-summary-label">Longitude</span>
+                <span className="pesquisa-localizacao-summary-value">{Number(localizacaoResolvida.lon).toFixed(6)}</span>
+              </div>
+              <div className="pesquisa-localizacao-summary-row">
+                <span className="pesquisa-localizacao-summary-label">Origem</span>
+                <span className="pesquisa-localizacao-summary-value">
+                  {localizacaoResolvida?.origem === 'eixos' ? 'Eixos de logradouro' : 'Coordenadas informadas'}
+                </span>
+              </div>
+            </div>
+          ) : null}
+        </div>
+
         <div className="row pesquisa-actions pesquisa-actions-primary">
           <button type="button" onClick={() => void buscarModelos()} disabled={loading}>
             {loading ? 'Pesquisando...' : 'Pesquisar'}
@@ -1370,6 +1686,7 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
                     </div>
                     <div className="pesquisa-card-body">
                       <div className="pesquisa-card-dados-list">
+                        <div><strong>Distância:</strong> {String(modelo.distancia_label || '').trim() || formatDistanceKm(modelo.distancia_km)}</div>
                         <div><strong>Tipo:</strong> {formatTipoImovel(modelo)}</div>
                         <div><strong>Autor:</strong> {modelo.autor || '-'}</div>
                         <div><strong>Dados:</strong> {formatCount(modelo.total_dados)}</div>
@@ -1424,12 +1741,21 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
         </SectionBlock>
       </div>
 
-      <SectionBlock step="3" title="Mapa" subtitle="Plote os modelos selecionados com cores distintas e legenda.">
+      <SectionBlock
+        step="3"
+        title="Mapa"
+        subtitle={localizacaoAtiva
+          ? 'Plote os modelos selecionados com dados de mercado ou cobertura dos modelos, com o avaliando destacado.'
+          : 'Plote os modelos selecionados com dados de mercado ou cobertura dos modelos.'}
+      >
         <div className="pesquisa-summary-line">
           <strong>{formatCount(selectedIds.length)}</strong> modelo(s) selecionado(s) para plotagem.
         </div>
+        <div className="pesquisa-summary-line">
+          <strong>Localização do avaliando:</strong> {localizacaoAtiva ? 'ativa' : 'não definida'}
+        </div>
 
-        <div className="row pesquisa-actions">
+        <div className="row pesquisa-actions pesquisa-mapa-actions">
           <button type="button" onClick={() => void onGerarMapaSelecionados()} disabled={mapaLoading || !selectedIds.length}>
             {mapaLoading ? 'Gerando mapa...' : 'Plotar mapa dos selecionados'}
           </button>
@@ -1438,18 +1764,46 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
         {mapaStatus ? <div className="status-line">{mapaStatus}</div> : null}
         {mapaError ? <div className="error-line inline-error">{mapaError}</div> : null}
 
+        {mapaHtmlAtual ? (
+          <div className="row pesquisa-actions pesquisa-mapa-actions">
+            <label className="pesquisa-field pesquisa-mapa-modo-field">
+              Exibição do mapa
+              <select
+                value={mapaModoExibicao}
+                onChange={(event) => setMapaModoExibicao(event.target.value)}
+                autoComplete="off"
+              >
+                <option value="pontos">Pontos representando dados de mercado</option>
+                <option value="cobertura">Cobertura dos modelos</option>
+              </select>
+            </label>
+          </div>
+        ) : null}
+
         {mapaLegendas.length ? (
           <div className="pesquisa-legenda-grid">
             {mapaLegendas.map((item) => (
-              <div key={item.id} className="pesquisa-legenda-item">
+              <label
+                key={item.id}
+                className={`pesquisa-legenda-item${mapaIdsVisiveis.includes(item.id) ? '' : ' is-disabled'}`}
+              >
+                <input
+                  type="checkbox"
+                  checked={mapaIdsVisiveis.includes(item.id)}
+                  onChange={() => void onToggleLegendaMapa(item.id)}
+                  disabled={mapaLoading}
+                />
                 <span className="pesquisa-legenda-color" style={{ backgroundColor: item.cor }} />
-                <span>{item.nome} ({item.total_pontos})</span>
-              </div>
+                <span>
+                  {item.nome} ({item.total_pontos})
+                  {String(item?.distancia_label || '').trim() ? ` • ${item.distancia_label}` : ''}
+                </span>
+              </label>
             ))}
           </div>
         ) : null}
 
-        {mapaHtml ? <MapFrame html={mapaHtml} /> : <div className="empty-box">Nenhum mapa gerado ainda.</div>}
+        {mapaHtmlAtual ? <MapFrame html={mapaHtmlAtual} /> : <div className="empty-box">Nenhum mapa gerado ainda.</div>}
       </SectionBlock>
 
       <LoadingOverlay show={modeloAbertoLoading} label="Carregando modelo..." />

frontend/src/components/SinglePillAutocomplete.jsx

@@ -22,6 +22,25 @@ function normalizeOption(option) {
   return { value, label, secondary }
 }
 
+function scoreOptionMatch(option, queryNormalized) {
+  if (!queryNormalized) return 1
+
+  const labelNorm = normalizeSearchText(option?.label || '')
+  const secondaryNorm = normalizeSearchText(option?.secondary || '')
+  const labelTokens = labelNorm.split(/\s+/).filter(Boolean)
+  const secondaryTokens = secondaryNorm.split(/\s+/).filter(Boolean)
+
+  if (labelNorm === queryNormalized) return 400
+  if (labelTokens.includes(queryNormalized)) return 320
+  if (labelNorm.startsWith(queryNormalized)) return 280
+  if (labelTokens.some((token) => token.startsWith(queryNormalized))) return 220
+  if (labelNorm.includes(queryNormalized)) return 180
+  if (secondaryNorm === queryNormalized) return 160
+  if (secondaryTokens.includes(queryNormalized)) return 140
+  if (secondaryNorm.includes(queryNormalized)) return 120
+  return 0
+}
+
 export default function SinglePillAutocomplete({
   value,
   onChange,
@@ -32,6 +51,8 @@ export default function SinglePillAutocomplete({
   loading = false,
   disabled = false,
   onOpenChange = null,
+  inputName = '',
+  inputAutoComplete = 'off',
 }) {
   const rootRef = useRef(null)
   const inputRef = useRef(null)
@@ -63,10 +84,13 @@ export default function SinglePillAutocomplete({
     if (loading) return []
     if (!queryNormalized) return normalizedOptions.slice(0, 160)
     return normalizedOptions
-      .filter((item) => (
-        normalizeSearchText(item.label).includes(queryNormalized)
-        || normalizeSearchText(item.secondary).includes(queryNormalized)
-      ))
+      .map((item, index) => ({ item, index, score: scoreOptionMatch(item, queryNormalized) }))
+      .filter((entry) => entry.score > 0)
+      .sort((a, b) => {
+        if (b.score !== a.score) return b.score - a.score
+        return a.index - b.index
+      })
+      .map((entry) => entry.item)
       .slice(0, 160)
   }, [loading, normalizedOptions, queryNormalized])
 
@@ -203,16 +227,19 @@ export default function SinglePillAutocomplete({
           ref={inputRef}
           type="text"
           className="chip-autocomplete-single-input"
+          name={inputName || undefined}
           value={query}
           onChange={onInputChange}
           onFocus={onInputFocus}
           onKeyDown={onInputKeyDown}
           placeholder={selectedOption ? '' : placeholder}
-          autoComplete="off"
+          autoComplete={inputAutoComplete}
           autoCorrect="off"
           autoCapitalize="none"
           spellCheck={false}
           disabled={disabled}
+          data-lpignore="true"
+          data-1p-ignore="true"
         />
       </div>
 

frontend/src/styles.css

@@ -22,6 +22,7 @@
   --radius-lg: 16px;
   --radius-md: 12px;
   --radius-sm: 9px;
+  --pesquisa-localizacao-control-height: 40px;
 }
 
 * {
@@ -1676,9 +1677,23 @@ button.pesquisa-otica-btn.active:hover {
   align-items: start;
 }
 
-.pesquisa-avaliando-periodo-pair {
+.pesquisa-periodo-versoes-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 16px 14px;
+  align-items: start;
+  margin-bottom: 12px;
+}
+
+.pesquisa-periodo-fields {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 16px 14px;
+  align-items: start;
+}
+
+.pesquisa-versionamento-field {
   margin: 0;
-  height: auto;
   align-self: start;
 }
 
@@ -1697,6 +1712,150 @@ button.pesquisa-otica-btn.active:hover {
   min-width: 0;
 }
 
+.pesquisa-localizacao-grid {
+  grid-column: 1 / -1;
+  display: grid;
+  gap: 16px 14px;
+  margin-bottom: 12px;
+  align-items: start;
+}
+
+.pesquisa-localizacao-grid-coords {
+  grid-template-columns: minmax(120px, 0.54fr) minmax(0, 1fr) minmax(0, 1fr) auto;
+  align-items: start;
+}
+
+.pesquisa-localizacao-grid-endereco {
+  grid-template-columns: minmax(120px, 0.54fr) minmax(120px, 0.55fr) minmax(0, 1.7fr) minmax(110px, 0.5fr) auto;
+  align-items: start;
+}
+
+.pesquisa-localizacao-logradouro-field {
+  min-width: 0;
+}
+
+.pesquisa-localizacao-logradouro-field .chip-autocomplete,
+.pesquisa-localizacao-logradouro-field .chip-autocomplete-single {
+  width: 100%;
+}
+
+.pesquisa-localizacao-logradouro-field .chip-autocomplete-single-control {
+  min-height: var(--pesquisa-localizacao-control-height);
+  height: var(--pesquisa-localizacao-control-height);
+  padding: 0 10px;
+  flex-wrap: nowrap;
+  align-items: center;
+}
+
+.pesquisa-localizacao-logradouro-field .chip-autocomplete-single-input {
+  min-height: calc(var(--pesquisa-localizacao-control-height) - 4px);
+  height: calc(var(--pesquisa-localizacao-control-height) - 4px);
+  padding: 0;
+}
+
+.pesquisa-localizacao-grid .pesquisa-field {
+  min-width: 0;
+}
+
+.pesquisa-localizacao-grid .pesquisa-field input,
+.pesquisa-localizacao-grid .pesquisa-field select {
+  width: 100%;
+  min-height: var(--pesquisa-localizacao-control-height);
+  height: var(--pesquisa-localizacao-control-height);
+}
+
+.pesquisa-localizacao-group {
+  margin-top: 2px;
+}
+
+.pesquisa-localizacao-optional-hint {
+  grid-column: 1 / -1;
+  font-size: 0.82rem;
+  color: #55708a;
+  line-height: 1.45;
+}
+
+.pesquisa-localizacao-action {
+  min-width: 86px;
+  min-height: var(--pesquisa-localizacao-control-height);
+  height: var(--pesquisa-localizacao-control-height);
+  padding: 0 14px;
+  border-radius: 10px;
+  font-weight: 800;
+  box-shadow: none;
+  white-space: nowrap;
+}
+
+.pesquisa-localizacao-action:hover {
+  transform: none;
+  box-shadow: none;
+}
+
+.pesquisa-localizacao-action-ok {
+  background: #2e8b57;
+  border-color: #2e8b57;
+  color: #ffffff;
+}
+
+.pesquisa-localizacao-action-reset {
+  background: #edf1f5;
+  border-color: #cfd8e2;
+  color: #647588;
+}
+
+.pesquisa-localizacao-actions-inline {
+  align-self: start;
+  display: inline-flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 8px;
+  min-height: var(--pesquisa-localizacao-control-height);
+  height: var(--pesquisa-localizacao-control-height);
+  margin-top: 27px;
+}
+
+.pesquisa-localizacao-summary {
+  grid-column: 1 / -1;
+  display: grid;
+  gap: 0;
+  border: 1px solid #d6e3ef;
+  border-radius: 10px;
+  background: #fbfdff;
+  overflow: hidden;
+}
+
+.pesquisa-localizacao-summary-row {
+  display: grid;
+  grid-template-columns: minmax(130px, 0.9fr) minmax(0, 2fr);
+  border-top: 1px solid #e6eef5;
+}
+
+.pesquisa-localizacao-summary-row:first-child {
+  border-top: none;
+}
+
+.pesquisa-localizacao-summary-label,
+.pesquisa-localizacao-summary-value {
+  padding: 8px 12px;
+  font-size: 0.83rem;
+  line-height: 1.4;
+}
+
+.pesquisa-localizacao-summary-label {
+  background: #f3f7fb;
+  color: #46627d;
+  font-weight: 700;
+}
+
+.pesquisa-localizacao-summary-value {
+  color: #35526b;
+}
+
+.pesquisa-localizacao-group .status-line,
+.pesquisa-localizacao-group .error-line {
+  grid-column: 1 / -1;
+}
+
 .pesquisa-avaliando-bottom-grid .pesquisa-field-pair {
   grid-column: auto;
   margin: 0;
@@ -1841,6 +2000,21 @@ button.pesquisa-coluna-remove:hover {
   justify-content: flex-end;
 }
 
+.pesquisa-mapa-actions {
+  align-items: flex-end;
+  gap: 12px;
+}
+
+.status-line + .pesquisa-mapa-actions {
+  margin-top: 14px;
+}
+
+.pesquisa-mapa-modo-field {
+  min-width: min(420px, 100%);
+  max-width: 520px;
+  margin: 0;
+}
+
 .pesquisa-status {
   margin-top: 2px;
 }
@@ -2458,6 +2632,17 @@ button.pesquisa-coluna-remove:hover {
   color: #3f566b;
   font-size: 0.8rem;
   font-weight: 700;
+  cursor: pointer;
+}
+
+.pesquisa-legenda-item input {
+  margin: 0;
+}
+
+.pesquisa-legenda-item.is-disabled {
+  opacity: 0.52;
+  background: #f5f8fb;
+  color: #708396;
 }
 
 .pesquisa-legenda-color {
@@ -5499,6 +5684,7 @@ button.btn-download-subtle {
   .pesquisa-filtros-grid,
   .pesquisa-avaliando-grid-v2,
   .pesquisa-fields-grid,
+  .pesquisa-localizacao-grid,
   .pesquisa-card-grid,
   .pesquisa-compare-grid,
   .pesquisa-compat-row {
@@ -5515,10 +5701,19 @@ button.btn-download-subtle {
     grid-template-columns: 1fr;
   }
 
+  .pesquisa-localizacao-summary-row {
+    grid-template-columns: 1fr;
+  }
+
   .pesquisa-avaliando-bottom-grid {
     grid-template-columns: 1fr;
   }
 
+  .pesquisa-periodo-versoes-grid,
+  .pesquisa-periodo-fields {
+    grid-template-columns: 1fr;
+  }
+
   .pesquisa-area-rh-grid {
     grid-template-columns: 1fr;
   }