update a lot of things

backend/app/core/elaboracao/core.py

@@ -5,6 +5,7 @@ Contém: carregamento de dados, estatísticas, transformações, modelo OLS, dia
 """
 
 import os
+import re
 import pandas as pd
 # Desabilita StringDtype para compatibilidade entre versões do pandas
 pd.set_option('future.infer_string', False)
@@ -660,6 +661,87 @@ def detectar_percentuais(df, colunas):
 # VERIFICAÇÃO DE MULTICOLINEARIDADE
 # ============================================================
 
+def _coluna_binaria_01(serie):
+    """Retorna True quando a coluna contém apenas 0/1 (com tolerância numérica)."""
+    try:
+        valores = pd.to_numeric(serie, errors='coerce').dropna().to_numpy(dtype=float)
+    except Exception:
+        return False
+
+    if valores.size == 0:
+        return False
+    return bool(np.all(np.isclose(valores, 0.0) | np.isclose(valores, 1.0)))
+
+
+def _detectar_grupos_dummy_sem_base(X_df):
+    """Detecta grupos de dummies com soma=1 em todas as linhas (dummy trap com intercepto)."""
+    if X_df is None or X_df.empty:
+        return []
+
+    colunas = [str(c) for c in X_df.columns]
+    colunas_binarias = [c for c in colunas if _coluna_binaria_01(X_df[c])]
+    if len(colunas_binarias) < 2:
+        return []
+
+    grupos = []
+    usadas = set()
+
+    # Heurística explícita para grupos de ano (ex.: a2019, a2020, ...).
+    colunas_ano = [c for c in colunas_binarias if re.match(r"^(a|ano_?)\d{4}$", c.lower())]
+    if len(colunas_ano) >= 2:
+        soma_ano = pd.to_numeric(X_df[colunas_ano].sum(axis=1), errors='coerce').fillna(0.0).to_numpy()
+        if bool(np.all(np.isclose(soma_ano, 1.0))):
+            grupos.append({
+                "tipo": "ano_sem_base",
+                "colunas": sorted(colunas_ano),
+                "linhas": int(len(X_df)),
+            })
+            usadas.update(colunas_ano)
+
+    # Heurística genérica para blocos dicotômicos mutuamente exclusivos.
+    restantes = [c for c in colunas_binarias if c not in usadas]
+    if len(restantes) >= 2:
+        valores = {
+            c: pd.to_numeric(X_df[c], errors='coerce').fillna(0.0).to_numpy(dtype=float)
+            for c in restantes
+        }
+        adj = {c: set() for c in restantes}
+        for i, col_a in enumerate(restantes):
+            va = valores[col_a]
+            for col_b in restantes[i + 1:]:
+                vb = valores[col_b]
+                # Nunca assumem 1 simultaneamente -> potencial grupo de categorias.
+                if bool(np.all((va * vb) == 0)):
+                    adj[col_a].add(col_b)
+                    adj[col_b].add(col_a)
+
+        visitadas = set()
+        for origem in restantes:
+            if origem in visitadas:
+                continue
+            pilha = [origem]
+            componente = []
+            while pilha:
+                atual = pilha.pop()
+                if atual in visitadas:
+                    continue
+                visitadas.add(atual)
+                componente.append(atual)
+                pilha.extend([viz for viz in adj[atual] if viz not in visitadas])
+
+            if len(componente) < 2:
+                continue
+
+            soma_comp = pd.to_numeric(X_df[componente].sum(axis=1), errors='coerce').fillna(0.0).to_numpy()
+            if bool(np.all(np.isclose(soma_comp, 1.0))):
+                grupos.append({
+                    "tipo": "dummy_sem_base",
+                    "colunas": sorted(componente),
+                    "linhas": int(len(X_df)),
+                })
+
+    return grupos
+
 def verificar_multicolinearidade(df, colunas_x):
     """Verifica multicolinearidade na matriz de regressoras (dados brutos, sem transformação).
 
@@ -673,11 +755,24 @@ def verificar_multicolinearidade(df, colunas_x):
         'vars_alta': list — variáveis com VIF > 10
         'posto': int — posto efetivo da matriz aumentada
         'ncolunas': int — número de colunas da matriz aumentada
+        'colunas_problematicas': list — colunas associadas ao problema
+        'pares_perfeitos': list[tuple[col_a, col_b, corr]] — pares ~linearmente dependentes
+        'grupos_dummy_sem_base': list[dict] — grupos dicotômicos com soma=1 (dummy trap)
     """
     from statsmodels.stats.outliers_influence import variance_inflation_factor
 
     n_vars = len(colunas_x)
-    vazio = {'perfeita': False, 'alta': False, 'vif': {}, 'vars_alta': [], 'posto': 0, 'ncolunas': 0}
+    vazio = {
+        'perfeita': False,
+        'alta': False,
+        'vif': {},
+        'vars_alta': [],
+        'posto': 0,
+        'ncolunas': 0,
+        'colunas_problematicas': [],
+        'pares_perfeitos': [],
+        'grupos_dummy_sem_base': [],
+    }
 
     if n_vars < 2:
         return vazio
@@ -688,8 +783,9 @@ def verificar_multicolinearidade(df, colunas_x):
             return vazio
         X = X_df.values.astype(float)
 
-        # Remove colunas com variância zero (constantes puras — capturadas como dependência com intercepto)
+        # Remove colunas com variância zero (constantes puras — dependentes com intercepto)
         std = X.std(axis=0)
+        cols_constantes = [c for c, s in zip(colunas_x, std) if s == 0]
         X = X[:, std > 0]
         cols_validas = [c for c, s in zip(colunas_x, std) if s > 0]
 
@@ -701,9 +797,36 @@ def verificar_multicolinearidade(df, colunas_x):
         ncolunas = X_const.shape[1]
 
         if posto < ncolunas:
+            pares_perfeitos = []
+            if X.shape[1] >= 2:
+                try:
+                    corr = np.corrcoef(X, rowvar=False)
+                    for i in range(len(cols_validas)):
+                        for j in range(i + 1, len(cols_validas)):
+                            c = float(corr[i, j])
+                            if np.isfinite(c) and abs(c) >= 0.9999:
+                                pares_perfeitos.append((cols_validas[i], cols_validas[j], c))
+                except Exception:
+                    pares_perfeitos = []
+
+            colunas_problematicas = sorted(
+                set(cols_constantes + [a for a, _, _ in pares_perfeitos] + [b for _, b, _ in pares_perfeitos])
+            )
+            if not colunas_problematicas:
+                colunas_problematicas = list(cols_validas)
+
+            grupos_dummy_sem_base = _detectar_grupos_dummy_sem_base(X_df[cols_validas])
+
             return {
-                'perfeita': True, 'alta': True, 'vif': {}, 'vars_alta': [],
-                'posto': posto, 'ncolunas': ncolunas,
+                'perfeita': True,
+                'alta': True,
+                'vif': {},
+                'vars_alta': [],
+                'posto': posto,
+                'ncolunas': ncolunas,
+                'colunas_problematicas': colunas_problematicas,
+                'pares_perfeitos': pares_perfeitos,
+                'grupos_dummy_sem_base': grupos_dummy_sem_base,
             }
 
         # Calcula VIF apenas quando n > k (amostra suficiente)
@@ -723,9 +846,15 @@ def verificar_multicolinearidade(df, colunas_x):
             vars_inf = [c for c, v in vif.items() if np.isinf(v)]
             vif_finito = {c: v for c, v in vif.items() if not np.isinf(v)}
             return {
-                'perfeita': True, 'alta': True,
-                'vif': vif_finito, 'vars_alta': vars_inf,
-                'posto': posto, 'ncolunas': ncolunas,
+                'perfeita': True,
+                'alta': True,
+                'vif': vif_finito,
+                'vars_alta': vars_inf,
+                'posto': posto,
+                'ncolunas': ncolunas,
+                'colunas_problematicas': sorted(set(cols_constantes + vars_inf)),
+                'pares_perfeitos': [],
+                'grupos_dummy_sem_base': [],
             }
 
         vars_alta = [c for c, v in vif.items() if v > 10]
@@ -736,6 +865,9 @@ def verificar_multicolinearidade(df, colunas_x):
             'vars_alta': vars_alta,
             'posto': posto,
             'ncolunas': ncolunas,
+            'colunas_problematicas': sorted(set(cols_constantes + vars_alta)),
+            'pares_perfeitos': [],
+            'grupos_dummy_sem_base': [],
         }
     except Exception:
         return vazio

backend/app/core/elaboracao/formatadores.py

@@ -220,7 +220,7 @@ def _renderizar_secao_micro(titulo, resultados_dict, secao_tipo="padrao"):
     card_extra_class = " micro-card-codigo" if is_codigo else ""
     msg_grid_class = "micro-msg-grid micro-msg-grid-codigo" if is_codigo else "micro-msg-grid"
 
-    html = f'<div class="section-title-orange">{titulo}</div>'
+    html = f'<div class="section-title-orange micro-group-title">{titulo}</div>'
     html += f'<div class="{grid_class}">'
 
     for coluna, info in resultados_dict.items():
@@ -713,9 +713,55 @@ def formatar_aviso_multicolinearidade(resultado):
     if not resultado or (not resultado.get('perfeita') and not resultado.get('alta')):
         return "", False
 
+    colunas_problematicas = [str(c) for c in (resultado.get('colunas_problematicas') or [])]
+    colunas_problematicas_html = ", ".join(f"<strong>{c}</strong>" for c in colunas_problematicas)
+
     if resultado.get('perfeita'):
         posto = resultado.get('posto', '?')
         ncolunas = resultado.get('ncolunas', '?')
+        pares = resultado.get('pares_perfeitos') or []
+        grupos_dummy = resultado.get('grupos_dummy_sem_base') or []
+
+        detalhe_colunas = (
+            f'<br><span style="font-size:0.93em;">Colunas envolvidas: {colunas_problematicas_html}.</span>'
+            if colunas_problematicas_html else ""
+        )
+
+        if pares:
+            pares_fmt = []
+            for a, b, corr in pares[:8]:
+                try:
+                    corr_txt = f"{float(corr):.4f}"
+                except Exception:
+                    corr_txt = "?"
+                pares_fmt.append(f"<strong>{a}</strong> × <strong>{b}</strong> (r={corr_txt})")
+            detalhe_pares = (
+                '<br><span style="font-size:0.93em;">Pares com correlação praticamente perfeita: '
+                + "; ".join(pares_fmt)
+                + ".</span>"
+            )
+        else:
+            detalhe_pares = ""
+
+        if grupos_dummy:
+            causas = []
+            for grupo in grupos_dummy[:4]:
+                cols = [str(c) for c in (grupo.get('colunas') or [])]
+                cols_html = ", ".join(f"<strong>{c}</strong>" for c in cols[:10])
+                if len(cols) > 10:
+                    cols_html += ", …"
+                if grupo.get('tipo') == 'ano_sem_base':
+                    causas.append(f"grupo de anos sem categoria base: {cols_html}")
+                else:
+                    causas.append(f"grupo dicotômico sem categoria base: {cols_html}")
+            detalhe_causa = (
+                '<br><span style="font-size:0.93em;">Causa provável detectada: '
+                + "; ".join(causas)
+                + '. Remova ao menos uma dummy de cada grupo (categoria base) antes da estimação.</span>'
+            )
+        else:
+            detalhe_causa = ""
+
         html = (
             '<div style="margin-top:12px; padding:12px 16px; background:#fdecea; '
             'border-left:4px solid #c0392b; border-radius:6px; color:#7b1a1a;">'
@@ -724,6 +770,9 @@ def formatar_aviso_multicolinearidade(resultado):
             f'(posto {posto} &lt; {ncolunas} colunas). '
             'O modelo OLS <strong>não poderá ser estimado</strong> com as variáveis selecionadas. '
             'Verifique se há dummies em excesso, variáveis redundantes ou combinações lineares exatas.</span>'
+            f'{detalhe_colunas}'
+            f'{detalhe_pares}'
+            f'{detalhe_causa}'
             '</div>'
         )
         return html, True
@@ -731,16 +780,27 @@ def formatar_aviso_multicolinearidade(resultado):
     # Alta (VIF > 10)
     vif = resultado.get('vif', {})
     vars_alta = resultado.get('vars_alta', [])
-    itens = ", ".join(
-        f"<strong>{c}</strong> (VIF={vif[c]:.1f})" for c in vars_alta if c in vif
+    itens = []
+    for c in vars_alta:
+        if c in vif:
+            itens.append(f"<strong>{c}</strong> (VIF={vif[c]:.1f})")
+        else:
+            itens.append(f"<strong>{c}</strong>")
+    itens_html = ", ".join(itens) if itens else "não identificado"
+
+    detalhe_colunas = (
+        f'<br><span style="font-size:0.93em;">Colunas com problema: {colunas_problematicas_html}.</span>'
+        if colunas_problematicas_html else ""
     )
+
     html = (
         '<div style="margin-top:12px; padding:12px 16px; background:#fff8e1; '
         'border-left:4px solid #f39c12; border-radius:6px; color:#7d5a00;">'
         '<strong>⚠️ Multicolinearidade Alta Detectada</strong><br>'
-        f'<span style="font-size:0.93em;">Variáveis com VIF &gt; 10: {itens}. '
+        f'<span style="font-size:0.93em;">Variáveis com VIF &gt; 10: {itens_html}. '
         'A alta colinearidade pode causar instabilidade nos coeficientes estimados. '
         'Considere remover variáveis redundantes antes da estimação.</span>'
+        f'{detalhe_colunas}'
         '</div>'
     )
     return html, True

backend/app/core/elaboracao/geocodificacao.py

@@ -23,6 +23,36 @@ _SHAPEFILE = os.path.join(_BASE, "dados", "EixosLogradouros.shp")
 _gdf_eixos = None
 
 
+def obter_serie_coluna(df: pd.DataFrame, coluna: str) -> pd.Series:
+    """Retorna uma Series 1D para uma coluna, mesmo com nomes duplicados.
+
+    Quando há colunas duplicadas com o mesmo nome, pandas retorna DataFrame em
+    `df[coluna]`. Nesse caso escolhemos a versão com maior quantidade de
+    valores convertíveis para número (heurística robusta para lat/lon/número).
+    """
+    selecionada = df.loc[:, coluna]
+    if isinstance(selecionada, pd.Series):
+        return selecionada
+
+    if isinstance(selecionada, pd.DataFrame):
+        if selecionada.shape[1] == 0:
+            return pd.Series(index=df.index, dtype="object")
+        if selecionada.shape[1] == 1:
+            return selecionada.iloc[:, 0]
+
+        melhor = selecionada.iloc[:, 0]
+        melhor_score = -1
+        for idx in range(selecionada.shape[1]):
+            serie = selecionada.iloc[:, idx]
+            score = int(pd.to_numeric(serie, errors="coerce").notna().sum())
+            if score > melhor_score:
+                melhor_score = score
+                melhor = serie
+        return melhor
+
+    return pd.Series(selecionada, index=df.index)
+
+
 def carregar_eixos():
     """Carrega e cacheia o GeoDataFrame dos eixos de logradouros.
 
@@ -76,12 +106,12 @@ def verificar_coords(df):
             col_lon = colunas_lower[nome]
             break
 
-    if col_lat is None or col_lon is None:
+    if col_lat is None or col_lon is None or col_lat == col_lon:
         return False, None, None
 
     # Verifica se há ao menos 1 valor não-nulo em cada coluna
-    lat_ok = pd.to_numeric(df[col_lat], errors="coerce").notna().any()
-    lon_ok = pd.to_numeric(df[col_lon], errors="coerce").notna().any()
+    lat_ok = pd.to_numeric(obter_serie_coluna(df, col_lat), errors="coerce").notna().any()
+    lon_ok = pd.to_numeric(obter_serie_coluna(df, col_lon), errors="coerce").notna().any()
 
     if lat_ok and lon_ok:
         return True, col_lat, col_lon
@@ -99,19 +129,17 @@ def padronizar_coords(df, col_lat, col_lon):
     Retorna:
         DataFrame com colunas 'lat' e 'lon' padronizadas.
     """
-    df = df.copy()
+    lat_series = pd.to_numeric(obter_serie_coluna(df, col_lat), errors="coerce")
+    lon_series = pd.to_numeric(obter_serie_coluna(df, col_lon), errors="coerce")
 
-    if col_lat != "lat":
-        df["lat"] = pd.to_numeric(df[col_lat], errors="coerce")
-        df = df.drop(columns=[col_lat])
-    else:
-        df["lat"] = pd.to_numeric(df["lat"], errors="coerce")
+    df = df.copy()
+    cols_drop = [nome for nome in (col_lat, col_lon) if nome in df.columns]
+    if cols_drop:
+        # Remove todas as ocorrências dos nomes originais (inclusive duplicadas).
+        df = df.drop(columns=list(dict.fromkeys(cols_drop)), errors="ignore")
 
-    if col_lon != "lon":
-        df["lon"] = pd.to_numeric(df[col_lon], errors="coerce")
-        df = df.drop(columns=[col_lon])
-    else:
-        df["lon"] = pd.to_numeric(df["lon"], errors="coerce")
+    df["lat"] = lat_series
+    df["lon"] = lon_series
 
     return df
 
@@ -183,7 +211,8 @@ def geocodificar(df, col_cdlog, col_num, auto_200=False):
     if "_idx" not in df.columns:
         df["_idx"] = range(len(df))
 
-    df[col_num] = pd.to_numeric(df[col_num], errors="coerce").fillna(0).astype(int)
+    df["__geo_cdlog"] = obter_serie_coluna(df, col_cdlog)
+    df["__geo_num"] = pd.to_numeric(obter_serie_coluna(df, col_num), errors="coerce").fillna(0).astype(int)
 
     lats = []
     lons = []
@@ -192,8 +221,8 @@ def geocodificar(df, col_cdlog, col_num, auto_200=False):
 
     for _, row in df.iterrows():
         idx = row["_idx"]
-        cdlog = row[col_cdlog]
-        numero = int(row[col_num])
+        cdlog = row["__geo_cdlog"]
+        numero = int(row["__geo_num"])
 
         # --- Passo 1: buscar segmentos do CDLOG ---
         segmentos = gdf_eixos[gdf_eixos["CDLOG"] == cdlog]
@@ -347,6 +376,8 @@ def geocodificar(df, col_cdlog, col_num, auto_200=False):
         # Nunca falha o fluxo principal por causa desse ajuste.
         pass
 
+    df = df.drop(columns=["__geo_cdlog", "__geo_num"], errors="ignore")
+
     df_falhas = pd.DataFrame(
         falhas,
         columns=["_idx", "cdlog", "numero_atual", "motivo", "sugestoes", "numero_corrigido"]

backend/app/services/elaboracao_service.py

@@ -100,6 +100,77 @@ def _selection_context(session: SessionState) -> dict[str, Any]:
     }
 
 
+def _resumo_faltantes_variaveis(df: pd.DataFrame, colunas: list[str]) -> dict[str, Any]:
+    if df is None or not colunas:
+        return {"has_missing": False, "rows_missing": 0, "total_rows": 0, "columns": [], "rows_preview": []}
+
+    colunas_validas = [c for c in colunas if c in df.columns]
+    if not colunas_validas:
+        return {"has_missing": False, "rows_missing": 0, "total_rows": int(len(df)), "columns": [], "rows_preview": []}
+
+    sub = df[colunas_validas]
+    mask_nulos = sub.isna()
+
+    # Compatível com versões novas do pandas (sem DataFrame.applymap)
+    # e robusto com colunas duplicadas (acesso por posição).
+    mask_brancos = pd.DataFrame(False, index=sub.index, columns=sub.columns)
+    for idx_col in range(sub.shape[1]):
+        serie = sub.iloc[:, idx_col]
+        if pd.api.types.is_object_dtype(serie) or pd.api.types.is_string_dtype(serie):
+            mask_brancos.iloc[:, idx_col] = serie.astype(str).str.strip().eq("").to_numpy()
+        else:
+            mask_brancos.iloc[:, idx_col] = False
+
+    mask_faltantes = (mask_nulos | mask_brancos).astype(bool)
+
+    linhas_com_faltante = mask_faltantes.any(axis=1)
+    linhas_idx = df.index[linhas_com_faltante].tolist()
+
+    faltantes_por_nome: dict[str, bool] = {}
+    for idx_col, nome in enumerate(sub.columns):
+        nome_str = str(nome)
+        tem_faltante = bool(mask_faltantes.iloc[:, idx_col].any())
+        faltantes_por_nome[nome_str] = bool(faltantes_por_nome.get(nome_str, False) or tem_faltante)
+
+    colunas_com_faltante = [col for col in colunas_validas if faltantes_por_nome.get(col, False)]
+
+    return {
+        "has_missing": len(linhas_idx) > 0,
+        "rows_missing": len(linhas_idx),
+        "total_rows": int(len(df)),
+        "columns": colunas_com_faltante,
+        "rows_preview": [int(i) if isinstance(i, (int, np.integer)) else str(i) for i in linhas_idx[:25]],
+    }
+
+
+def _formatar_aviso_faltantes(info: dict[str, Any]) -> str:
+    if not info.get("has_missing"):
+        return ""
+
+    rows_missing = int(info.get("rows_missing") or 0)
+    total_rows = int(info.get("total_rows") or 0)
+    colunas = [str(c) for c in (info.get("columns") or [])]
+    preview = [str(i) for i in (info.get("rows_preview") or [])]
+
+    colunas_txt = ", ".join(f"<strong>{c}</strong>" for c in colunas) if colunas else "não identificado"
+    preview_txt = ", ".join(preview)
+    detalhe_preview = (
+        f'<br><span style="font-size:0.93em;">Primeiros índices com problema: {preview_txt}</span>'
+        if preview_txt else ""
+    )
+
+    return (
+        '<div style="margin-top:12px; padding:12px 16px; background:#fff7ed; '
+        'border-left:4px solid #f28c28; border-radius:6px; color:#7a4a00;">'
+        '<strong>⚠️ Verificação de nulos/brancos</strong><br>'
+        f'<span style="font-size:0.93em;">Foram encontradas <strong>{rows_missing}</strong> linha(s) com valores nulos ou em branco '
+        f'em Y/X selecionadas (total analisado: {total_rows}).</span>'
+        f'<br><span style="font-size:0.93em;">Colunas afetadas: {colunas_txt}.</span>'
+        f'{detalhe_preview}'
+        '</div>'
+    )
+
+
 def _render_mapa_if_enabled(session: SessionState, df: pd.DataFrame | None, **kwargs: Any) -> str:
     if not session.mapa_habilitado or df is None:
         return ""
@@ -280,6 +351,8 @@ def load_dai_for_elaboracao(session: SessionState, caminho_arquivo: str) -> dict
     session.outliers_anteriores = _clean_int_list(outliers_excluidos)
 
     base = _set_dataframe_base(session, df, clear_models=True)
+    session.transformacao_y = str(transformacao_y or "(x)")
+    session.transformacoes_x = {str(k): str(v) for k, v in (transformacoes_x or {}).items()}
 
     selection_payload = apply_selection(
         session,
@@ -384,6 +457,8 @@ def apply_selection(
 
     resultado_multi = verificar_multicolinearidade(df_filtrado, colunas_x_validas)
     aviso_multi_html, aviso_multi_visivel = formatar_aviso_multicolinearidade(resultado_multi)
+    faltantes_info = _resumo_faltantes_variaveis(df_filtrado, [coluna_y] + colunas_x_validas)
+    aviso_faltantes_html = _formatar_aviso_faltantes(faltantes_info)
 
     n_out = len(outliers)
     resumo_outliers = f"Excluidos: {n_out} | A excluir: 0 | A reincluir: 0 | Total: {n_out}"
@@ -416,6 +491,11 @@ def apply_selection(
             "html": aviso_multi_html,
             "visible": aviso_multi_visivel,
         },
+        "aviso_faltantes": {
+            "html": aviso_faltantes_html,
+            "visible": bool(faltantes_info.get("has_missing")),
+            "info": sanitize_value(faltantes_info),
+        },
         "transformacao_y": session.transformacao_y,
         "transform_fields": transform_fields,
         "mapa_html": _render_mapa_if_enabled(session, df_filtrado),
@@ -578,6 +658,13 @@ def fit_model(
 
     return {
         "diagnosticos_html": diagnosticos_html,
+        "transformacao_y": session.transformacao_y,
+        "transformacoes_x": sanitize_value(session.transformacoes_x),
+        "transformacoes_aplicadas": {
+            "coluna_y": session.coluna_y,
+            "transformacao_y": session.transformacao_y,
+            "transformacoes_x": sanitize_value(session.transformacoes_x),
+        },
         "tabela_coef": dataframe_to_payload(resultado["tabela_coef"], decimals=4),
         "tabela_obs_calc": dataframe_to_payload(resultado["tabela_obs_calc"], decimals=4),
         "grafico_dispersao_modelo": figure_to_payload(fig_dispersao_transf),
@@ -994,8 +1081,8 @@ def mapear_coordenadas_manualmente(session: SessionState, col_lat: str, col_lon:
     if n_total == 0:
         raise HTTPException(status_code=400, detail="DataFrame vazio")
 
-    lat_num = pd.to_numeric(df[col_lat], errors="coerce")
-    lon_num = pd.to_numeric(df[col_lon], errors="coerce")
+    lat_num = pd.to_numeric(geocodificacao.obter_serie_coluna(df, col_lat), errors="coerce")
+    lon_num = pd.to_numeric(geocodificacao.obter_serie_coluna(df, col_lon), errors="coerce")
     lat_vals = lat_num.dropna()
     lon_vals = lon_num.dropna()
 

frontend/src/components/ElaboracaoTab.jsx

@@ -56,10 +56,30 @@ function formatConselhoRegistro(elaborador) {
 
 function formatTransformacaoBadge(transformacao) {
   const valor = String(transformacao || '').trim()
-  if (!valor || valor === '(x)' || valor === '(y)' || valor === 'x' || valor === 'y') return ''
+  if (!valor || valor === '(x)' || valor === '(y)' || valor === 'x' || valor === 'y') return '(x)'
   return valor
 }
 
+function buildLoadedModelInfo(resp) {
+  const tipo = String(resp?.tipo || '').toLowerCase()
+  if (tipo !== 'dai') return null
+
+  const contexto = resp?.contexto || {}
+  const fit = resp?.fit || {}
+  const colunaY = String(contexto.coluna_y || '').trim()
+  const colunasX = Array.isArray(contexto.colunas_x) ? contexto.colunas_x.map((item) => String(item)) : []
+  const transformacoesX = fit && typeof fit.transformacoes_x === 'object' && fit.transformacoes_x !== null
+    ? fit.transformacoes_x
+    : {}
+
+  return {
+    coluna_y: colunaY,
+    colunas_x: colunasX,
+    transformacao_y: fit.transformacao_y || contexto.transformacao_y || '(x)',
+    transformacoes_x: transformacoesX,
+  }
+}
+
 function formatGeoColLabel(coluna, kind = 'default') {
   const valor = String(coluna || '')
   if (kind === 'cdlog' && valor.toUpperCase() === 'CTM') return 'CTM'
@@ -91,16 +111,24 @@ function parseSugestoes(raw) {
     .filter(Boolean)
 }
 
+function obterLabelGrau(listaGraus, valor) {
+  const n = Number(valor)
+  const item = (listaGraus || []).find((g) => Number(g.value) === n)
+  return item?.label || 'Sem enquadramento'
+}
+
 export default function ElaboracaoTab({ sessionId }) {
   const [loading, setLoading] = useState(false)
   const [error, setError] = useState('')
   const [status, setStatus] = useState('')
 
   const [uploadedFile, setUploadedFile] = useState(null)
+  const [uploadDragOver, setUploadDragOver] = useState(false)
   const [requiresSheet, setRequiresSheet] = useState(false)
   const [sheetOptions, setSheetOptions] = useState([])
   const [selectedSheet, setSelectedSheet] = useState('')
   const [elaborador, setElaborador] = useState(null)
+  const [modeloCarregadoInfo, setModeloCarregadoInfo] = useState(null)
 
   const [dados, setDados] = useState(null)
   const [mapaHtml, setMapaHtml] = useState('')
@@ -136,7 +164,10 @@ export default function ElaboracaoTab({ sessionId }) {
 
   const [transformacaoY, setTransformacaoY] = useState('(x)')
   const [transformacoesX, setTransformacoesX] = useState({})
+  const [transformacoesAplicadas, setTransformacoesAplicadas] = useState(null)
+  const [origemTransformacoes, setOrigemTransformacoes] = useState(null)
   const [section8Open, setSection8Open] = useState(false)
+  const [section10ManualOpen, setSection10ManualOpen] = useState(false)
   const [section11Open, setSection11Open] = useState(false)
 
   const [fit, setFit] = useState(null)
@@ -162,6 +193,7 @@ export default function ElaboracaoTab({ sessionId }) {
   const marcarTodasXRef = useRef(null)
   const classificarXReqRef = useRef(0)
   const deleteConfirmTimersRef = useRef({})
+  const uploadInputRef = useRef(null)
 
   const mapaChoices = useMemo(() => ['Visualização Padrão', ...colunasNumericas], [colunasNumericas])
   const colunasXDisponiveis = useMemo(
@@ -181,13 +213,46 @@ export default function ElaboracaoTab({ sessionId }) {
     if (!elaborador) return []
     return [elaborador.cargo, conselhoRegistro, elaborador.matricula_sem_digito ? `Matricula ${elaborador.matricula_sem_digito}` : '', elaborador.lotacao].filter(Boolean)
   }, [elaborador, conselhoRegistro])
-  const transformacaoYBadge = useMemo(() => formatTransformacaoBadge(transformacaoY), [transformacaoY])
-  const variaveisIndependentesBadge = useMemo(() => {
-    return colunasX.map((coluna) => ({
+  const transformacaoYModeloBadge = useMemo(
+    () => formatTransformacaoBadge(modeloCarregadoInfo?.transformacao_y),
+    [modeloCarregadoInfo],
+  )
+  const variaveisIndependentesModeloBadge = useMemo(() => {
+    const colunas = modeloCarregadoInfo?.colunas_x || []
+    const transformacoes = modeloCarregadoInfo?.transformacoes_x || {}
+    return colunas.map((coluna) => ({
       coluna,
-      transformacao: formatTransformacaoBadge(transformacoesX[coluna]),
+      transformacao: formatTransformacaoBadge(transformacoes[coluna]),
     }))
-  }, [colunasX, transformacoesX])
+  }, [modeloCarregadoInfo])
+  const transformacaoAplicadaYBadge = useMemo(
+    () => formatTransformacaoBadge(transformacoesAplicadas?.transformacao_y),
+    [transformacoesAplicadas],
+  )
+  const transformacoesAplicadasXBadge = useMemo(() => {
+    const mapaX = transformacoesAplicadas?.transformacoes_x || {}
+    const ordemX = colunasX.length > 0 ? colunasX : Object.keys(mapaX)
+    return ordemX.map((coluna) => ({
+      coluna,
+      transformacao: formatTransformacaoBadge(mapaX[coluna]),
+    }))
+  }, [transformacoesAplicadas, colunasX])
+  const origemTransformacoesTexto = useMemo(() => {
+    if (!origemTransformacoes?.origem) return ''
+    if (origemTransformacoes.origem === 'modelo_original') {
+      return 'Origem: transformação original do modelo carregado.'
+    }
+    if (origemTransformacoes.origem === 'manual') {
+      return 'Origem: ajuste manual do usuário.'
+    }
+    if (origemTransformacoes.origem === 'sugestao') {
+      const numero = Number(origemTransformacoes.sugestao_numero || 0)
+      const grauCoefLabel = obterLabelGrau(GRAUS_COEF, origemTransformacoes.grau_coef)
+      const grauFLabel = obterLabelGrau(GRAUS_F, origemTransformacoes.grau_f)
+      return `Origem: sugestão #${Number.isFinite(numero) && numero > 0 ? numero : '?'} (Grau mínimo coef.: ${grauCoefLabel}; Grau mínimo teste F: ${grauFLabel}).`
+    }
+    return ''
+  }, [origemTransformacoes])
   const showCoordsPanel = Boolean(
     coordsInfo && (
       !coordsInfo.tem_coords ||
@@ -320,6 +385,8 @@ export default function ElaboracaoTab({ sessionId }) {
       setPercentuais([])
       setTransformacaoY('(x)')
       setTransformacoesX({})
+      setTransformacoesAplicadas(null)
+      setOrigemTransformacoes(null)
       setOutliersAnteriores([])
       setIteracao(1)
       setSelection(null)
@@ -344,13 +411,19 @@ export default function ElaboracaoTab({ sessionId }) {
     }
 
     if (resp.fit && !resetXSelection) {
-      applyFitResponse(resp.fit)
+      const meta = String(resp.tipo || '').toLowerCase() === 'dai'
+        ? { origem: 'modelo_original' }
+        : null
+      applyFitResponse(resp.fit, meta)
     }
   }
 
   function applySelectionResponse(resp) {
     setSelection(resp)
     setSection8Open(false)
+    setSection10ManualOpen(false)
+    setTransformacoesAplicadas(null)
+    setOrigemTransformacoes(null)
     if (resp.transformacao_y) {
       setTransformacaoY(resp.transformacao_y)
     }
@@ -378,9 +451,29 @@ export default function ElaboracaoTab({ sessionId }) {
     }
   }
 
-  function applyFitResponse(resp) {
+  function applyFitResponse(resp, origemMeta = null) {
     setFit(resp)
     setSection11Open(false)
+    if (resp.transformacao_y) {
+      setTransformacaoY(resp.transformacao_y)
+    }
+    if (resp.transformacoes_x) {
+      setTransformacoesX(resp.transformacoes_x)
+    }
+    if (resp.transformacoes_aplicadas) {
+      setTransformacoesAplicadas(resp.transformacoes_aplicadas)
+    } else if (resp.transformacao_y || resp.transformacoes_x) {
+      setTransformacoesAplicadas({
+        coluna_y: colunaY,
+        transformacao_y: resp.transformacao_y || transformacaoY,
+        transformacoes_x: resp.transformacoes_x || transformacoesX,
+      })
+    }
+    if (origemMeta && origemMeta.origem) {
+      setOrigemTransformacoes(origemMeta)
+    } else if (resp.origem_transformacoes?.origem) {
+      setOrigemTransformacoes(resp.origem_transformacoes)
+    }
     setResumoOutliers(resp.resumo_outliers || resumoOutliers)
     setCamposAvaliacao(resp.avaliacao_campos || [])
     const init = {}
@@ -394,22 +487,24 @@ export default function ElaboracaoTab({ sessionId }) {
     setBaseValue('')
   }
 
-  async function onUploadClick() {
-    if (!uploadedFile || !sessionId) return
+  async function onUploadClick(arquivo = null) {
+    const arquivoUpload = arquivo || uploadedFile
+    if (!arquivoUpload || !sessionId) return
     await withBusy(async () => {
       setMapaGerado(false)
       setMapaHtml('')
       setGeoAuto200(true)
-      const nomeArquivo = String(uploadedFile?.name || '').toLowerCase()
+      const nomeArquivo = String(arquivoUpload?.name || '').toLowerCase()
       const uploadEhDai = nomeArquivo.endsWith('.dai')
       setTipoFonteDados(uploadEhDai ? 'dai' : 'tabular')
-      const resp = await api.uploadElaboracaoFile(sessionId, uploadedFile)
+      const resp = await api.uploadElaboracaoFile(sessionId, arquivoUpload)
       setManualMapError('')
       setGeoProcessError('')
       setGeoStatusHtml('')
       setGeoFalhasHtml('')
       setGeoCorrecoes([])
       setElaborador(resp.elaborador || null)
+      setModeloCarregadoInfo(buildLoadedModelInfo(resp))
       setAvaliadorSelecionado(resp.elaborador?.nome_completo || '')
       setRequiresSheet(Boolean(resp.requires_sheet))
       setSheetOptions(resp.sheets || [])
@@ -429,6 +524,8 @@ export default function ElaboracaoTab({ sessionId }) {
         setPercentuais([])
         setTransformacaoY('(x)')
         setTransformacoesX({})
+        setTransformacoesAplicadas(null)
+        setOrigemTransformacoes(null)
         setCamposAvaliacao([])
         valoresAvaliacaoRef.current = {}
         setAvaliacaoFormVersion((prev) => prev + 1)
@@ -438,6 +535,37 @@ export default function ElaboracaoTab({ sessionId }) {
     })
   }
 
+  function onUploadInputChange(event) {
+    const input = event.target
+    const file = input.files?.[0] ?? null
+    setUploadedFile(file)
+    input.value = ''
+    if (!file || loading) return
+    void onUploadClick(file)
+  }
+
+  function onUploadDropZoneDragOver(event) {
+    event.preventDefault()
+    event.dataTransfer.dropEffect = 'copy'
+    setUploadDragOver(true)
+  }
+
+  function onUploadDropZoneDragLeave(event) {
+    event.preventDefault()
+    if (!event.currentTarget.contains(event.relatedTarget)) {
+      setUploadDragOver(false)
+    }
+  }
+
+  function onUploadDropZoneDrop(event) {
+    event.preventDefault()
+    setUploadDragOver(false)
+    const file = event.dataTransfer?.files?.[0]
+    if (!file || loading) return
+    setUploadedFile(file)
+    void onUploadClick(file)
+  }
+
   async function onConfirmSheet() {
     if (!selectedSheet || !sessionId) return
     await withBusy(async () => {
@@ -452,6 +580,7 @@ export default function ElaboracaoTab({ sessionId }) {
       setGeoFalhasHtml('')
       setGeoCorrecoes([])
       setElaborador(resp.elaborador || null)
+      setModeloCarregadoInfo(null)
       setAvaliadorSelecionado(resp.elaborador?.nome_completo || '')
       setRequiresSheet(false)
       applyBaseResponse(resp, { resetXSelection: true })
@@ -590,9 +719,28 @@ export default function ElaboracaoTab({ sessionId }) {
   async function onAdoptSuggestion(idx) {
     if (!sessionId) return
     await withBusy(async () => {
-      const resp = await api.adoptSuggestion(sessionId, idx)
-      setTransformacaoY(resp.transformacao_y || '(x)')
-      setTransformacoesX(resp.transformacoes_x || {})
+      const adopted = await api.adoptSuggestion(sessionId, idx)
+      const transformacaoYAdotada = adopted.transformacao_y || '(x)'
+      const transformacoesXAdotadas = adopted.transformacoes_x || {}
+      const sugestao = selection?.busca?.resultados?.[idx] || null
+      const sugestaoNumero = Number(sugestao?.rank ?? idx + 1)
+      setTransformacaoY(transformacaoYAdotada)
+      setTransformacoesX(transformacoesXAdotadas)
+
+      const fitResp = await api.fitModel({
+        session_id: sessionId,
+        transformacao_y: transformacaoYAdotada,
+        transformacoes_x: transformacoesXAdotadas,
+        dicotomicas,
+        codigo_alocado: codigoAlocado,
+        percentuais,
+      })
+      applyFitResponse(fitResp, {
+        origem: 'sugestao',
+        sugestao_numero: Number.isFinite(sugestaoNumero) ? sugestaoNumero : null,
+        grau_coef: grauCoef,
+        grau_f: grauF,
+      })
     })
   }
 
@@ -607,7 +755,7 @@ export default function ElaboracaoTab({ sessionId }) {
         codigo_alocado: codigoAlocado,
         percentuais,
       })
-      applyFitResponse(resp)
+      applyFitResponse(resp, { origem: 'manual' })
     })
   }
 
@@ -659,6 +807,8 @@ export default function ElaboracaoTab({ sessionId }) {
       setOutliersTexto('')
       setReincluirTexto('')
       setFit(null)
+      setTransformacoesAplicadas(null)
+      setOrigemTransformacoes(null)
       setResultadoAvaliacaoHtml('')
       setResumoOutliers(resp.resumo_outliers || resumoOutliers)
       if (typeof window !== 'undefined') {
@@ -678,6 +828,8 @@ export default function ElaboracaoTab({ sessionId }) {
       setIteracao(1)
       setSelection(null)
       setFit(null)
+      setTransformacoesAplicadas(null)
+      setOrigemTransformacoes(null)
       setCamposAvaliacao([])
       valoresAvaliacaoRef.current = {}
       setAvaliacaoFormVersion((prev) => prev + 1)
@@ -852,9 +1004,33 @@ export default function ElaboracaoTab({ sessionId }) {
         <div className="section1-groups">
           <div className="subpanel section1-group">
             <h4>Carregar modelo</h4>
-            <div className="row">
-              <input type="file" onChange={(e) => setUploadedFile(e.target.files?.[0] ?? null)} />
-              <button onClick={onUploadClick} disabled={!uploadedFile || loading || !sessionId}>Carregar arquivo</button>
+            <div
+              className={`upload-dropzone${uploadDragOver ? ' is-dragover' : ''}`}
+              onDragOver={onUploadDropZoneDragOver}
+              onDragEnter={onUploadDropZoneDragOver}
+              onDragLeave={onUploadDropZoneDragLeave}
+              onDrop={onUploadDropZoneDrop}
+            >
+              <input
+                ref={uploadInputRef}
+                type="file"
+                className="upload-hidden-input"
+                onChange={onUploadInputChange}
+              />
+              <div className="row upload-dropzone-main">
+                <button
+                  type="button"
+                  className="btn-upload-select"
+                  onClick={() => uploadInputRef.current?.click()}
+                  disabled={loading}
+                >
+                  Selecionar arquivo
+                </button>
+              </div>
+              <div className="upload-dropzone-hint">Ou arraste e solte aqui para carregar automaticamente.</div>
+              <div className="upload-dropzone-file">
+                {uploadedFile ? `Arquivo selecionado: ${uploadedFile.name}` : 'Nenhum arquivo selecionado.'}
+              </div>
             </div>
 
             {requiresSheet ? (
@@ -871,38 +1047,42 @@ export default function ElaboracaoTab({ sessionId }) {
 
           <div className="subpanel section1-group">
             <h4>Informações do modelo</h4>
-            {elaborador?.nome_completo ? (
+            {modeloCarregadoInfo ? (
               <div className="modelo-info-card">
                 <div className="modelo-info-split">
                   <div className="modelo-info-col">
                     <div className="elaborador-badge-title">Modelo elaborado por:</div>
-                    <div className="elaborador-badge-name">{elaborador.nome_completo}</div>
-                    {elaboradorMeta.length > 0 ? (
+                    {elaborador?.nome_completo ? (
+                      <div className="elaborador-badge-name">{elaborador.nome_completo}</div>
+                    ) : (
+                      <div className="section1-empty-hint">Elaborador não informado no arquivo.</div>
+                    )}
+                    {elaboradorMeta.length > 0 && elaborador?.nome_completo ? (
                       <div className="elaborador-badge-meta">{elaboradorMeta.join(' | ')}</div>
                     ) : null}
                   </div>
 
                   <div className="modelo-info-col modelo-info-col-vars">
                     <div className="elaborador-badge-title">Variáveis do modelo carregado</div>
-                    {colunaY ? (
+                    {modeloCarregadoInfo.coluna_y ? (
                       <div className="variavel-badge-line">
                         <span className="variavel-badge-label">Dependente:</span>
-                        <span className="variavel-chip variavel-chip-y">
-                          {colunaY}
-                          {transformacaoYBadge ? <span className="variavel-chip-transform">{` ${transformacaoYBadge}`}</span> : null}
+                        <span className="variavel-chip variavel-chip-y variavel-chip-inline">
+                          {modeloCarregadoInfo.coluna_y}
+                          <span className="variavel-chip-transform">{` ${transformacaoYModeloBadge}`}</span>
                         </span>
                       </div>
                     ) : (
                       <div className="section1-empty-hint">Variável dependente não encontrada no modelo carregado.</div>
                     )}
-                    {variaveisIndependentesBadge.length > 0 ? (
+                    {variaveisIndependentesModeloBadge.length > 0 ? (
                       <div className="variavel-badge-line">
                         <span className="variavel-badge-label">Independentes:</span>
                         <div className="variavel-chip-wrap">
-                          {variaveisIndependentesBadge.map((item) => (
+                          {variaveisIndependentesModeloBadge.map((item) => (
                             <span key={`ind-${item.coluna}`} className="variavel-chip">
                               {item.coluna}
-                              {item.transformacao ? <span className="variavel-chip-transform">{` ${item.transformacao}`}</span> : null}
+                              <span className="variavel-chip-transform">{` ${item.transformacao}`}</span>
                             </span>
                           ))}
                         </div>
@@ -1280,6 +1460,12 @@ export default function ElaboracaoTab({ sessionId }) {
             <div className="row">
               <button onClick={onApplySelection} disabled={loading || !colunaY || colunasX.length === 0}>Aplicar seleção</button>
             </div>
+            {selection?.aviso_multicolinearidade?.visible ? (
+              <div dangerouslySetInnerHTML={{ __html: selection.aviso_multicolinearidade.html }} />
+            ) : null}
+            {selection?.aviso_faltantes?.visible ? (
+              <div dangerouslySetInnerHTML={{ __html: selection.aviso_faltantes.html || '' }} />
+            ) : null}
           </SectionBlock>
         </>
       ) : null}
@@ -1292,9 +1478,6 @@ export default function ElaboracaoTab({ sessionId }) {
 
           <SectionBlock step="7" title="Teste de Micronumerosidade" subtitle="Validação de amostra mínima para variáveis selecionadas.">
             <div dangerouslySetInnerHTML={{ __html: selection.micronumerosidade_html || '' }} />
-            {selection.aviso_multicolinearidade?.visible ? (
-              <div dangerouslySetInnerHTML={{ __html: selection.aviso_multicolinearidade.html }} />
-            ) : null}
           </SectionBlock>
 
           <SectionBlock step="8" title="Gráficos de Dispersão das Variáveis Independentes" subtitle="Leitura visual entre X e Y no conjunto filtrado.">
@@ -1337,10 +1520,19 @@ export default function ElaboracaoTab({ sessionId }) {
                   <div key={`sug-${item.rank || idx + 1}`} className="transform-suggestion-card">
                     <div className="transform-suggestion-head">
                       <span className="transform-suggestion-rank">#{item.rank || idx + 1}</span>
-                      <span className="transform-suggestion-r2">R² = {Number(item.r2 ?? 0).toFixed(4)}</span>
+                      <div className="transform-suggestion-metrics">
+                        <span className="transform-suggestion-r2">R² = {Number(item.r2 ?? 0).toFixed(4)}</span>
+                        <span className={grauBadgeClass(Number(item.grau_f ?? 0))}>
+                          Teste F: {GRAU_LABEL_CURTO[Number(item.grau_f ?? 0)] || 'Sem enq.'}
+                        </span>
+                      </div>
                     </div>
-                    <div className="transform-suggestion-line"><strong>Y:</strong> {item.transformacao_y}</div>
                     <div className="transform-suggestion-list">
+                      <div className="transform-suggestion-item transform-suggestion-item-y">
+                        <span className="transform-suggestion-col">{`${colunaY || 'Y'} (Y)`}</span>
+                        <span className="transform-suggestion-fn">{item.transformacao_y || '(x)'}</span>
+                        <span className="transform-suggestion-item-note">Dependente</span>
+                      </div>
                       {Object.entries(item.transformacoes_x || {}).map(([coluna, transf]) => {
                         const grau = Number(item.graus_coef?.[coluna] ?? 0)
                         return (
@@ -1352,13 +1544,8 @@ export default function ElaboracaoTab({ sessionId }) {
                         )
                       })}
                     </div>
-                    <div className="transform-suggestion-foot">
-                      <span className={grauBadgeClass(Number(item.grau_f ?? 0))}>
-                        Teste F: {GRAU_LABEL_CURTO[Number(item.grau_f ?? 0)] || 'Sem enq.'}
-                      </span>
-                    </div>
-                    <button onClick={() => onAdoptSuggestion(idx)} disabled={loading}>
-                      Adotar sugestão #{item.rank || idx + 1}
+                    <button className="btn-adopt-model" onClick={() => onAdoptSuggestion(idx)} disabled={loading}>
+                      Adotar e Ajustar Modelo
                     </button>
                   </div>
                 ))}
@@ -1369,33 +1556,79 @@ export default function ElaboracaoTab({ sessionId }) {
           </SectionBlock>
 
           <SectionBlock step="10" title="Aplicação das Transformações" subtitle="Configuração manual para ajuste do modelo.">
-            <div className="row">
-              <label>Transformação de Y</label>
-              <select value={transformacaoY} onChange={(e) => setTransformacaoY(e.target.value)}>
-                {['(x)', '1/(x)', 'ln(x)', 'exp(x)', '(x)^2', 'raiz(x)', '1/raiz(x)'].map((item) => (
-                  <option key={`y-${item}`} value={item}>{item}</option>
-                ))}
-              </select>
+            <div className="manual-transform-toggle">
+              <button
+                type="button"
+                className={section10ManualOpen ? 'btn-manual-toggle active' : 'btn-manual-toggle'}
+                onClick={() => setSection10ManualOpen((prev) => !prev)}
+              >
+                {section10ManualOpen ? 'Ocultar ajustes manuais de transformação' : 'Proceceder com as transformações manualmente'}
+              </button>
             </div>
 
-            <div className="transform-grid">
-              {(selection.transform_fields || []).map((field) => (
-                <div key={`tf-${field.coluna}`} className="transform-card">
-                  <span>{field.coluna}</span>
-                  <select
-                    value={transformacoesX[field.coluna] || '(x)'}
-                    onChange={(e) => setTransformacoesX((prev) => ({ ...prev, [field.coluna]: e.target.value }))}
-                    disabled={field.locked}
-                  >
-                    {(field.choices || []).map((choice) => (
-                      <option key={`${field.coluna}-${choice}`} value={choice}>{choice}</option>
+            {section10ManualOpen ? (
+              <>
+                <div className="row">
+                  <label>Transformação de Y</label>
+                  <select value={transformacaoY} onChange={(e) => setTransformacaoY(e.target.value)}>
+                    {['(x)', '1/(x)', 'ln(x)', 'exp(x)', '(x)^2', 'raiz(x)', '1/raiz(x)'].map((item) => (
+                      <option key={`y-${item}`} value={item}>{item}</option>
                     ))}
                   </select>
                 </div>
-              ))}
-            </div>
 
-            <button onClick={onFitModel} disabled={loading}>Aplicar transformações e ajustar modelo</button>
+                <div className="transform-grid">
+                  {(selection.transform_fields || []).map((field) => (
+                    <div key={`tf-${field.coluna}`} className="transform-card">
+                      <span>{field.coluna}</span>
+                      <select
+                        value={transformacoesX[field.coluna] || '(x)'}
+                        onChange={(e) => setTransformacoesX((prev) => ({ ...prev, [field.coluna]: e.target.value }))}
+                        disabled={field.locked}
+                      >
+                        {(field.choices || []).map((choice) => (
+                          <option key={`${field.coluna}-${choice}`} value={choice}>{choice}</option>
+                        ))}
+                      </select>
+                    </div>
+                  ))}
+                </div>
+
+                <button className="btn-fit-model" onClick={onFitModel} disabled={loading}>Aplicar transformações e ajustar modelo</button>
+              </>
+            ) : null}
+            {transformacoesAplicadas?.coluna_y ? (
+              <div className="transformacoes-aplicadas-wrap">
+                <div className="modelo-info-card transformacoes-aplicadas-badge-card">
+                  <div className="modelo-info-col">
+                    <div className="elaborador-badge-title">Escalas / Transformações aplicadas</div>
+                    {origemTransformacoesTexto ? (
+                      <div className="transformacao-origem-info">{origemTransformacoesTexto}</div>
+                    ) : null}
+                    <div className="variavel-badge-line">
+                      <span className="variavel-badge-label">Dependente:</span>
+                      <span className="variavel-chip variavel-chip-y variavel-chip-inline">
+                        {transformacoesAplicadas.coluna_y}
+                        <span className="variavel-chip-transform">{` ${transformacaoAplicadaYBadge}`}</span>
+                      </span>
+                    </div>
+                    {transformacoesAplicadasXBadge.length > 0 ? (
+                      <div className="variavel-badge-line">
+                        <span className="variavel-badge-label">Independentes:</span>
+                        <div className="variavel-chip-wrap">
+                          {transformacoesAplicadasXBadge.map((item) => (
+                            <span key={`tx-apl-${item.coluna}`} className="variavel-chip">
+                              {item.coluna}
+                              <span className="variavel-chip-transform">{` ${item.transformacao}`}</span>
+                            </span>
+                          ))}
+                        </div>
+                      </div>
+                    ) : null}
+                  </div>
+                </div>
+              </div>
+            ) : null}
           </SectionBlock>
         </>
       ) : null}

frontend/src/components/VisualizacaoTab.jsx

@@ -25,6 +25,7 @@ export default function VisualizacaoTab({ sessionId }) {
   const [badgeHtml, setBadgeHtml] = useState('')
 
   const [uploadedFile, setUploadedFile] = useState(null)
+  const [uploadDragOver, setUploadDragOver] = useState(false)
 
   const [dados, setDados] = useState(null)
   const [estatisticas, setEstatisticas] = useState(null)
@@ -53,6 +54,7 @@ export default function VisualizacaoTab({ sessionId }) {
 
   const [activeInnerTab, setActiveInnerTab] = useState('mapa')
   const deleteConfirmTimersRef = useRef({})
+  const uploadInputRef = useRef(null)
 
   function resetConteudoVisualizacao() {
     setDados(null)
@@ -126,11 +128,12 @@ export default function VisualizacaoTab({ sessionId }) {
     }
   }
 
-  async function onUploadModel() {
-    if (!sessionId || !uploadedFile) return
+  async function onUploadModel(arquivo = null) {
+    const arquivoUpload = arquivo || uploadedFile
+    if (!sessionId || !arquivoUpload) return
     await withBusy(async () => {
       resetConteudoVisualizacao()
-      const uploadResp = await api.uploadVisualizacaoFile(sessionId, uploadedFile)
+      const uploadResp = await api.uploadVisualizacaoFile(sessionId, arquivoUpload)
       setStatus(uploadResp.status || '')
       setBadgeHtml(uploadResp.badge_html || '')
 
@@ -139,6 +142,37 @@ export default function VisualizacaoTab({ sessionId }) {
     })
   }
 
+  function onUploadInputChange(event) {
+    const input = event.target
+    const file = input.files?.[0] ?? null
+    setUploadedFile(file)
+    input.value = ''
+    if (!file || loading) return
+    void onUploadModel(file)
+  }
+
+  function onUploadDropZoneDragOver(event) {
+    event.preventDefault()
+    event.dataTransfer.dropEffect = 'copy'
+    setUploadDragOver(true)
+  }
+
+  function onUploadDropZoneDragLeave(event) {
+    event.preventDefault()
+    if (!event.currentTarget.contains(event.relatedTarget)) {
+      setUploadDragOver(false)
+    }
+  }
+
+  function onUploadDropZoneDrop(event) {
+    event.preventDefault()
+    setUploadDragOver(false)
+    const file = event.dataTransfer?.files?.[0]
+    if (!file || loading) return
+    setUploadedFile(file)
+    void onUploadModel(file)
+  }
+
   async function onMapChange(value) {
     setMapaVar(value)
     if (!sessionId) return
@@ -242,9 +276,34 @@ export default function VisualizacaoTab({ sessionId }) {
   return (
     <div className="tab-content">
       <SectionBlock step="1" title="Carregar Modelo .dai" subtitle="Carregue o arquivo e o conteúdo será exibido automaticamente.">
-        <div className="row">
-          <input type="file" onChange={(e) => setUploadedFile(e.target.files?.[0] ?? null)} />
-          <button onClick={onUploadModel} disabled={!uploadedFile || loading || !sessionId}>Carregar Modelo</button>
+        <div
+          className={`upload-dropzone${uploadDragOver ? ' is-dragover' : ''}`}
+          onDragOver={onUploadDropZoneDragOver}
+          onDragEnter={onUploadDropZoneDragOver}
+          onDragLeave={onUploadDropZoneDragLeave}
+          onDrop={onUploadDropZoneDrop}
+        >
+          <input
+            ref={uploadInputRef}
+            type="file"
+            className="upload-hidden-input"
+            accept=".dai"
+            onChange={onUploadInputChange}
+          />
+          <div className="row upload-dropzone-main">
+            <button
+              type="button"
+              className="btn-upload-select"
+              onClick={() => uploadInputRef.current?.click()}
+              disabled={loading}
+            >
+              Selecionar arquivo
+            </button>
+          </div>
+          <div className="upload-dropzone-hint">Ou arraste e solte aqui para carregar automaticamente.</div>
+          <div className="upload-dropzone-file">
+            {uploadedFile ? `Arquivo selecionado: ${uploadedFile.name}` : 'Nenhum arquivo selecionado.'}
+          </div>
         </div>
         {status ? <div className="status-line">{status}</div> : null}
         {badgeHtml ? <div dangerouslySetInnerHTML={{ __html: badgeHtml }} /> : null}

frontend/src/styles.css

@@ -520,6 +520,49 @@ button:disabled {
   background: #fff;
 }
 
+.upload-dropzone {
+  border: 1px dashed #c5d5e5;
+  border-radius: 12px;
+  background: linear-gradient(180deg, #f9fcff 0%, #f4f9ff 100%);
+  padding: 11px 12px;
+  transition: border-color 0.15s ease, background 0.15s ease, box-shadow 0.15s ease;
+}
+
+.upload-dropzone.is-dragover {
+  border-color: #3b7fb8;
+  background: linear-gradient(180deg, #f3f9ff 0%, #ebf4ff 100%);
+  box-shadow: 0 0 0 1px rgba(59, 127, 184, 0.12);
+}
+
+.upload-hidden-input {
+  display: none;
+}
+
+.upload-dropzone-main {
+  margin-bottom: 6px;
+}
+
+button.btn-upload-select {
+  --btn-bg-start: #4a90c8;
+  --btn-bg-end: #3978ab;
+  --btn-border: #346f9f;
+  --btn-shadow-soft: rgba(53, 113, 157, 0.2);
+  --btn-shadow-strong: rgba(53, 113, 157, 0.25);
+}
+
+.upload-dropzone-hint {
+  color: #4d647b;
+  font-size: 0.83rem;
+}
+
+.upload-dropzone-file {
+  margin-top: 4px;
+  color: #2f4358;
+  font-size: 0.84rem;
+  font-weight: 700;
+  word-break: break-word;
+}
+
 .coords-section-groups {
   display: grid;
   gap: 14px;
@@ -684,6 +727,12 @@ button:disabled {
   color: #1f4e7b;
 }
 
+.variavel-chip-inline {
+  justify-self: start;
+  width: fit-content;
+  max-width: 100%;
+}
+
 .variavel-chip-transform {
   color: #6a7f94;
   font-weight: 600;
@@ -823,15 +872,15 @@ button:disabled {
 }
 
 .compact-option-group {
-  margin: 12px 0 14px;
-  padding: 11px 12px;
+  margin: 14px 0 18px;
+  padding: 12px 13px;
   border: 1px solid #dbe6f1;
   border-radius: 12px;
   background: #fbfdff;
 }
 
 .compact-option-group + .compact-option-group {
-  margin-top: 16px;
+  margin-top: 24px;
 }
 
 .compact-option-group h4 {
@@ -942,9 +991,17 @@ button:disabled {
 
 .transform-suggestion-head {
   display: flex;
-  align-items: center;
+  align-items: flex-start;
   justify-content: space-between;
   gap: 8px;
+  margin-bottom: 16px;
+}
+
+.transform-suggestion-metrics {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-end;
+  gap: 7px;
 }
 
 .transform-suggestion-rank {
@@ -971,7 +1028,24 @@ button:disabled {
 
 .transform-suggestion-list {
   display: grid;
-  gap: 6px;
+  gap: 8px;
+  margin-top: 2px;
+}
+
+.manual-transform-toggle {
+  margin: 8px 0 10px;
+}
+
+.btn-manual-toggle {
+  min-width: 320px;
+}
+
+.btn-manual-toggle.active {
+  --btn-bg-start: #6b7f93;
+  --btn-bg-end: #586b7d;
+  --btn-border: #4a5c6e;
+  --btn-shadow-soft: rgba(86, 105, 122, 0.18);
+  --btn-shadow-strong: rgba(86, 105, 122, 0.24);
 }
 
 .transform-suggestion-item {
@@ -985,6 +1059,11 @@ button:disabled {
   background: #f9fbfd;
 }
 
+.transform-suggestion-item.transform-suggestion-item-y {
+  border-color: #cfe1f4;
+  background: #edf5fe;
+}
+
 .transform-suggestion-col {
   color: #2e4358;
   font-weight: 700;
@@ -1000,6 +1079,13 @@ button:disabled {
   font-family: 'JetBrains Mono', monospace;
 }
 
+.transform-suggestion-item-note {
+  color: #4f6880;
+  font-size: 0.74rem;
+  font-weight: 700;
+  white-space: nowrap;
+}
+
 .transform-suggestion-foot {
   padding-top: 3px;
   border-top: 1px solid #e9eef4;
@@ -1047,6 +1133,16 @@ button:disabled {
   justify-content: center;
 }
 
+.transform-suggestion-card button.btn-adopt-model {
+  --btn-bg-start: #6b7f93;
+  --btn-bg-end: #586b7d;
+  --btn-border: #4a5c6e;
+  --btn-shadow-soft: rgba(86, 105, 122, 0.19);
+  --btn-shadow-strong: rgba(86, 105, 122, 0.25);
+  font-size: 0.84rem;
+  padding: 7px 12px;
+}
+
 .plot-grid-2 {
   display: grid;
   grid-template-columns: repeat(auto-fit, minmax(350px, 1fr));
@@ -1333,6 +1429,27 @@ button:disabled {
   margin-bottom: 10px;
 }
 
+.transformacoes-aplicadas-wrap {
+  margin-top: 12px;
+}
+
+.transformacoes-aplicadas-badge-card {
+  margin-top: 0;
+}
+
+.btn-fit-model {
+  margin-top: 14px;
+  margin-bottom: 16px;
+}
+
+.transformacao-origem-info {
+  margin-top: 6px;
+  margin-bottom: 4px;
+  color: #4e6378;
+  font-size: 0.83rem;
+  font-weight: 600;
+}
+
 .geo-correcoes {
   display: grid;
   grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
@@ -1635,6 +1752,11 @@ button:disabled {
   margin-top: 12px;
 }
 
+.micro-group-title {
+  margin-top: 22px;
+  margin-bottom: 18px;
+}
+
 .micro-card {
   margin: 0;
   padding: 10px 11px;
@@ -1655,7 +1777,7 @@ button:disabled {
   align-items: center;
   justify-content: flex-start;
   gap: 6px;
-  margin-bottom: 9px;
+  margin-bottom: 13px;
 }
 
 .micro-title {