inclusao de equacoes para excel

backend/app/api/elaboracao.py

@@ -355,6 +355,17 @@ def evaluation_export(session_id: str) -> FileResponse:
     )
 
 
+@router.get("/equation/export")
+def equation_export(session_id: str, mode: str = "excel") -> FileResponse:
+    session = session_store.get(session_id)
+    caminho, nome = elaboracao_service.exportar_equacao(session, mode)
+    return FileResponse(
+        path=caminho,
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        filename=nome,
+    )
+
+
 @router.get("/avaliadores")
 def listar_avaliadores() -> dict[str, Any]:
     return {"avaliadores": elaboracao_service.list_avaliadores()}

backend/app/api/visualizacao.py

@@ -145,6 +145,17 @@ def evaluation_export(session_id: str) -> FileResponse:
     )
 
 
+@router.get("/equation/export")
+def equation_export(session_id: str, mode: str = "excel") -> FileResponse:
+    session = session_store.get(session_id)
+    caminho, nome = visualizacao_service.exportar_equacao(session, mode)
+    return FileResponse(
+        path=caminho,
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        filename=nome,
+    )
+
+
 @router.post("/clear")
 def clear(payload: SessionPayload) -> dict[str, Any]:
     session = session_store.get(payload.session_id)

backend/app/core/elaboracao/formatadores.py

@@ -158,10 +158,6 @@ def formatar_diagnosticos_html(diagnosticos):
     html += f'''<div class="field-row"><span class="field-row-label">P-valor</span><span class="field-row-value">{diagnosticos["bp_p"]:.4f}</span></div>'''
     html += f'''<div class="field-row"><span class="field-row-label">Interpretação</span><span class="field-row-value">{diagnosticos["interp_BP"]}</span></div>'''
 
-    # Equação do Modelo
-    html += '<div class="section-title-orange">Equação do Modelo</div>'
-    html += f'<div class="equation-box">{diagnosticos["equacao"]}</div>'
-
     html += '</div>'
     return html
 

backend/app/core/visualizacao/app.py

@@ -636,12 +636,6 @@ def formatar_resumo_html(resumo_reorganizado):
             if teste.get("interpretacao"):
                 linhas_html.append(criar_linha_interpretacao(teste["interpretacao"]))
 
-    # Equação
-    equacao = resumo_reorganizado.get("equacao")
-    if equacao:
-        linhas_html.append(criar_titulo_secao("Equação do Modelo"))
-        linhas_html.append(f'<div class="equation-box">{equacao}</div>')
-
     return f"""<div class="dai-card scrollable-container">{"".join(linhas_html)}</div>"""
 
 # ============================================================

backend/app/services/elaboracao_service.py

@@ -41,6 +41,7 @@ from app.core.elaboracao.formatadores import (
 )
 from app.models.session import SessionState
 from app.services import model_repository
+from app.services.equacao_service import build_equacoes_payload, exportar_planilha_equacao
 from app.services.serializers import dataframe_to_payload, figure_to_payload, sanitize_value
 
 _AVALIADORES_PATH = Path(__file__).resolve().parent.parent / "core" / "elaboracao" / "avaliadores.json"
@@ -768,6 +769,14 @@ def fit_model(
     session.avaliacoes_elaboracao = []
 
     diagnosticos_html = formatar_diagnosticos_html(resultado["diagnosticos"])
+    equacoes = build_equacoes_payload(
+        modelo_sm=resultado.get("modelo_sm"),
+        coluna_y=session.coluna_y or str(resultado.get("coluna_y") or ""),
+        transformacao_y=session.transformacao_y,
+        transformacoes_x=session.transformacoes_x,
+        colunas_x=session.colunas_x,
+        equacao_visual=str(resultado.get("diagnosticos", {}).get("equacao") or ""),
+    )
 
     try:
         fig_dispersao_transf = charts.criar_graficos_dispersao(
@@ -827,6 +836,7 @@ def fit_model(
             "transformacao_y": session.transformacao_y,
             "transformacoes_x": sanitize_value(session.transformacoes_x),
         },
+        "equacoes": sanitize_value(equacoes),
         "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),
@@ -1277,6 +1287,26 @@ def exportar_base(session: SessionState, usar_filtrado: bool = True) -> str:
     return caminho
 
 
+def exportar_equacao(session: SessionState, mode: str) -> tuple[str, str]:
+    if session.resultado_modelo is None:
+        raise HTTPException(status_code=400, detail="Ajuste um modelo antes de exportar a equacao")
+    if not session.coluna_y or not session.colunas_x:
+        raise HTTPException(status_code=400, detail="Modelo sem variaveis para montar equacao")
+
+    diagnosticos = session.resultado_modelo.get("diagnosticos", {}) or {}
+    caminho, nome = exportar_planilha_equacao(
+        mode=mode,
+        modelo_sm=session.resultado_modelo.get("modelo_sm"),
+        coluna_y=session.coluna_y,
+        transformacao_y=session.transformacao_y,
+        transformacoes_x=session.transformacoes_x,
+        colunas_x=session.colunas_x,
+        equacao_visual=str(diagnosticos.get("equacao") or ""),
+        nome_base="equacao_modelo",
+    )
+    return caminho, nome
+
+
 def atualizar_mapa(session: SessionState, var_mapa: str | None) -> dict[str, Any]:
     df = session.df_filtrado if session.df_filtrado is not None else session.df_original
     if df is None:

backend/app/services/equacao_service.py

@@ -0,0 +1,548 @@
+from __future__ import annotations
+
+import math
+import os
+import tempfile
+import uuid
+from typing import Any, Callable
+
+from fastapi import HTTPException
+from openpyxl import Workbook
+from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
+
+
+_E_CONST_BR = "2,718281828459045"
+_E_CONST_DOT = "2.718281828459045"
+_MODE_EXCEL = "excel"
+_MODE_EXCEL_SAB = "excel_sab"
+
+
+def _normalize_mode(mode: str | None) -> str:
+    value = str(mode or "").strip().lower()
+    if value in {"excel", "formato_excel"}:
+        return _MODE_EXCEL
+    if value in {"excel_sab", "sab", "estilo_sab", "formato_excel_sab"}:
+        return _MODE_EXCEL_SAB
+    raise HTTPException(status_code=400, detail="Modo de equacao invalido. Use 'excel' ou 'excel_sab'.")
+
+
+def _format_number_br(value: Any) -> str:
+    try:
+        num = float(value)
+    except Exception:
+        num = 0.0
+    if not math.isfinite(num):
+        num = 0.0
+    text = f"{num:.12f}".rstrip("0").rstrip(".")
+    if text in {"", "-0"}:
+        text = "0"
+    return text.replace(".", ",")
+
+
+def _normalize_transform(value: Any) -> str:
+    return str(value or "(x)").strip() or "(x)"
+
+
+def _format_number_calc(value: Any) -> str:
+    try:
+        num = float(value)
+    except Exception:
+        num = 0.0
+    if not math.isfinite(num):
+        num = 0.0
+    text = f"{num:.12f}".rstrip("0").rstrip(".")
+    if text in {"", "-0"}:
+        text = "0"
+    return text
+
+
+def _resolve_const(params: Any) -> float:
+    if params is None:
+        return 0.0
+    for key in ("const", "Intercept", "intercept", "(Intercept)"):
+        try:
+            if key in params:
+                return float(params[key])
+        except Exception:
+            continue
+    try:
+        if hasattr(params, "iloc") and len(params) > 0:
+            return float(params.iloc[0])
+    except Exception:
+        pass
+    return 0.0
+
+
+def _resolve_coef(params: Any, column: str) -> float:
+    if params is None:
+        return 0.0
+    try:
+        return float(params[column])
+    except Exception:
+        return 0.0
+
+
+def _term_expr_excel(transformacao: str, var_expr: str, mode: str) -> str:
+    transf = _normalize_transform(transformacao)
+    if transf == "ln(x)":
+        if mode == _MODE_EXCEL_SAB:
+            return f"LOG({var_expr};{_E_CONST_BR})"
+        return f"LN({var_expr})"
+    if transf == "exp(x)":
+        if mode == _MODE_EXCEL_SAB:
+            return f"({_E_CONST_BR}^({var_expr}))"
+        return f"EXP({var_expr})"
+    if transf == "1/(x)":
+        return f"(1/({var_expr}))"
+    if transf == "(x)^2":
+        return f"(({var_expr})^2)"
+    if transf == "raiz(x)":
+        return f"RAIZ({var_expr})"
+    if transf == "1/raiz(x)":
+        return f"(1/RAIZ({var_expr}))"
+    return var_expr
+
+
+def _term_expr_calc(transformacao: str, var_expr: str, mode: str) -> str:
+    transf = _normalize_transform(transformacao)
+    if transf == "ln(x)":
+        if mode == _MODE_EXCEL_SAB:
+            return f"LOG({var_expr},{_E_CONST_DOT})"
+        return f"LN({var_expr})"
+    if transf == "exp(x)":
+        if mode == _MODE_EXCEL_SAB:
+            return f"({_E_CONST_DOT}^({var_expr}))"
+        return f"EXP({var_expr})"
+    if transf == "1/(x)":
+        return f"(1/({var_expr}))"
+    if transf == "(x)^2":
+        return f"(({var_expr})^2)"
+    if transf == "raiz(x)":
+        return f"SQRT({var_expr})"
+    if transf == "1/raiz(x)":
+        return f"(1/SQRT({var_expr}))"
+    return var_expr
+
+
+def _compose_linear_expression(
+    *,
+    params: Any,
+    colunas_x: list[str],
+    transformacoes_x: dict[str, str],
+    var_resolver: Callable[[str], str],
+    mode: str,
+    include_ln_terms: bool = True,
+) -> str:
+    const_value = _resolve_const(params)
+    expr = _format_number_br(const_value)
+    for coluna in colunas_x:
+        coef = _resolve_coef(params, coluna)
+        if abs(coef) < 1e-15:
+            continue
+        transf = _normalize_transform(transformacoes_x.get(coluna, "(x)"))
+        if not include_ln_terms and transf == "ln(x)":
+            continue
+        termo = _term_expr_excel(transf, var_resolver(coluna), mode)
+        sinal = "+" if coef >= 0 else "-"
+        expr += f"{sinal}{_format_number_br(abs(coef))}*{termo}"
+    return expr
+
+
+def _compose_linear_expression_calc(
+    *,
+    params: Any,
+    colunas_x: list[str],
+    transformacoes_x: dict[str, str],
+    var_resolver: Callable[[str], str],
+    mode: str,
+    include_ln_terms: bool = True,
+) -> str:
+    const_value = _resolve_const(params)
+    expr = _format_number_calc(const_value)
+    for coluna in colunas_x:
+        coef = _resolve_coef(params, coluna)
+        if abs(coef) < 1e-15:
+            continue
+        transf = _normalize_transform(transformacoes_x.get(coluna, "(x)"))
+        if not include_ln_terms and transf == "ln(x)":
+            continue
+        termo = _term_expr_calc(transf, var_resolver(coluna), mode)
+        sinal = "+" if coef >= 0 else "-"
+        expr += f"{sinal}{_format_number_calc(abs(coef))}*{termo}"
+    return expr
+
+
+def _invert_y_expr(expr: str, transformacao_y: str, mode: str) -> str:
+    transf_y = _normalize_transform(transformacao_y)
+    if transf_y == "(x)":
+        return f"({expr})"
+    if transf_y == "ln(x)":
+        if mode == _MODE_EXCEL_SAB:
+            return f"({_E_CONST_BR}^({expr}))"
+        return f"EXP({expr})"
+    if transf_y == "1/(x)":
+        return f"(1/({expr}))"
+    if transf_y == "(x)^2":
+        return f"RAIZ({expr})"
+    if transf_y == "raiz(x)":
+        return f"(({expr})^2)"
+    if transf_y == "1/raiz(x)":
+        return f"(1/(({expr})^2))"
+    if transf_y == "exp(x)":
+        if mode == _MODE_EXCEL_SAB:
+            return f"LOG({expr};{_E_CONST_BR})"
+        return f"LN({expr})"
+    return f"({expr})"
+
+
+def _invert_y_expr_calc(expr: str, transformacao_y: str, mode: str) -> str:
+    transf_y = _normalize_transform(transformacao_y)
+    if transf_y == "(x)":
+        return f"({expr})"
+    if transf_y == "ln(x)":
+        if mode == _MODE_EXCEL_SAB:
+            return f"({_E_CONST_DOT}^({expr}))"
+        return f"EXP({expr})"
+    if transf_y == "1/(x)":
+        return f"(1/({expr}))"
+    if transf_y == "(x)^2":
+        return f"SQRT({expr})"
+    if transf_y == "raiz(x)":
+        return f"(({expr})^2)"
+    if transf_y == "1/raiz(x)":
+        return f"(1/(({expr})^2))"
+    if transf_y == "exp(x)":
+        if mode == _MODE_EXCEL_SAB:
+            return f"LOG({expr},{_E_CONST_DOT})"
+        return f"LN({expr})"
+    return f"({expr})"
+
+
+def _build_formula_excel(
+    *,
+    params: Any,
+    transformacao_y: str,
+    transformacoes_x: dict[str, str],
+    colunas_x: list[str],
+    var_resolver: Callable[[str], str],
+) -> str:
+    linear = _compose_linear_expression(
+        params=params,
+        colunas_x=colunas_x,
+        transformacoes_x=transformacoes_x,
+        var_resolver=var_resolver,
+        mode=_MODE_EXCEL,
+    )
+    return "=" + _invert_y_expr(linear, transformacao_y, _MODE_EXCEL)
+
+
+def _build_formula_excel_sab(
+    *,
+    params: Any,
+    transformacao_y: str,
+    transformacoes_x: dict[str, str],
+    colunas_x: list[str],
+    var_resolver: Callable[[str], str],
+) -> str:
+    transf_y = _normalize_transform(transformacao_y)
+    # Forma direta sem EXP/LN quando y esta em log.
+    if transf_y == "ln(x)":
+        base_linear = _compose_linear_expression(
+            params=params,
+            colunas_x=colunas_x,
+            transformacoes_x=transformacoes_x,
+            var_resolver=var_resolver,
+            mode=_MODE_EXCEL_SAB,
+            include_ln_terms=False,
+        )
+        expr = f"({_E_CONST_BR}^({base_linear}))"
+        for coluna in colunas_x:
+            transf = _normalize_transform(transformacoes_x.get(coluna, "(x)"))
+            if transf != "ln(x)":
+                continue
+            coef = _resolve_coef(params, coluna)
+            if abs(coef) < 1e-15:
+                continue
+            expr += f"*(({var_resolver(coluna)})^{_format_number_br(coef)})"
+        return "=" + expr
+
+    linear = _compose_linear_expression(
+        params=params,
+        colunas_x=colunas_x,
+        transformacoes_x=transformacoes_x,
+        var_resolver=var_resolver,
+        mode=_MODE_EXCEL_SAB,
+    )
+    return "=" + _invert_y_expr(linear, transformacao_y, _MODE_EXCEL_SAB)
+
+
+def _build_formula_calc_excel(
+    *,
+    params: Any,
+    transformacao_y: str,
+    transformacoes_x: dict[str, str],
+    colunas_x: list[str],
+    var_resolver: Callable[[str], str],
+) -> str:
+    linear = _compose_linear_expression_calc(
+        params=params,
+        colunas_x=colunas_x,
+        transformacoes_x=transformacoes_x,
+        var_resolver=var_resolver,
+        mode=_MODE_EXCEL,
+    )
+    return "=" + _invert_y_expr_calc(linear, transformacao_y, _MODE_EXCEL)
+
+
+def _build_formula_calc_excel_sab(
+    *,
+    params: Any,
+    transformacao_y: str,
+    transformacoes_x: dict[str, str],
+    colunas_x: list[str],
+    var_resolver: Callable[[str], str],
+) -> str:
+    transf_y = _normalize_transform(transformacao_y)
+    if transf_y == "ln(x)":
+        base_linear = _compose_linear_expression_calc(
+            params=params,
+            colunas_x=colunas_x,
+            transformacoes_x=transformacoes_x,
+            var_resolver=var_resolver,
+            mode=_MODE_EXCEL_SAB,
+            include_ln_terms=False,
+        )
+        expr = f"({_E_CONST_DOT}^({base_linear}))"
+        for coluna in colunas_x:
+            transf = _normalize_transform(transformacoes_x.get(coluna, "(x)"))
+            if transf != "ln(x)":
+                continue
+            coef = _resolve_coef(params, coluna)
+            if abs(coef) < 1e-15:
+                continue
+            expr += f"*(({var_resolver(coluna)})^{_format_number_calc(coef)})"
+        return "=" + expr
+
+    linear = _compose_linear_expression_calc(
+        params=params,
+        colunas_x=colunas_x,
+        transformacoes_x=transformacoes_x,
+        var_resolver=var_resolver,
+        mode=_MODE_EXCEL_SAB,
+    )
+    return "=" + _invert_y_expr_calc(linear, transformacao_y, _MODE_EXCEL_SAB)
+
+
+def _build_formula_by_mode(
+    *,
+    mode: str,
+    params: Any,
+    transformacao_y: str,
+    transformacoes_x: dict[str, str],
+    colunas_x: list[str],
+    var_resolver: Callable[[str], str],
+) -> str:
+    mode_norm = _normalize_mode(mode)
+    if mode_norm == _MODE_EXCEL:
+        return _build_formula_excel(
+            params=params,
+            transformacao_y=transformacao_y,
+            transformacoes_x=transformacoes_x,
+            colunas_x=colunas_x,
+            var_resolver=var_resolver,
+        )
+    return _build_formula_excel_sab(
+        params=params,
+        transformacao_y=transformacao_y,
+        transformacoes_x=transformacoes_x,
+        colunas_x=colunas_x,
+        var_resolver=var_resolver,
+    )
+
+
+def _build_formula_calc_by_mode(
+    *,
+    mode: str,
+    params: Any,
+    transformacao_y: str,
+    transformacoes_x: dict[str, str],
+    colunas_x: list[str],
+    var_resolver: Callable[[str], str],
+) -> str:
+    mode_norm = _normalize_mode(mode)
+    if mode_norm == _MODE_EXCEL:
+        return _build_formula_calc_excel(
+            params=params,
+            transformacao_y=transformacao_y,
+            transformacoes_x=transformacoes_x,
+            colunas_x=colunas_x,
+            var_resolver=var_resolver,
+        )
+    return _build_formula_calc_excel_sab(
+        params=params,
+        transformacao_y=transformacao_y,
+        transformacoes_x=transformacoes_x,
+        colunas_x=colunas_x,
+        var_resolver=var_resolver,
+    )
+
+
+def _set_formula_as_text(cell: Any, formula_text: str) -> None:
+    cell.value = str(formula_text or "")
+    cell.data_type = "s"
+    cell.number_format = "@"
+
+
+def build_equacoes_payload(
+    *,
+    modelo_sm: Any,
+    coluna_y: str,
+    transformacao_y: str,
+    transformacoes_x: dict[str, str] | None,
+    colunas_x: list[str] | None,
+    equacao_visual: str | None = None,
+) -> dict[str, str]:
+    if modelo_sm is None:
+        return {
+            "visual_apresentacao": str(equacao_visual or "").strip(),
+            "excel": "",
+            "excel_sab": "",
+        }
+
+    params = getattr(modelo_sm, "params", None)
+    if params is None:
+        return {
+            "visual_apresentacao": str(equacao_visual or "").strip(),
+            "excel": "",
+            "excel_sab": "",
+        }
+
+    lista_x = [str(c) for c in (colunas_x or [])]
+    mapa_transf = {str(k): _normalize_transform(v) for k, v in (transformacoes_x or {}).items()}
+    visual = str(equacao_visual or "").strip()
+    if not visual:
+        visual = f"{coluna_y} = {str(_build_formula_excel(params=params, transformacao_y=transformacao_y, transformacoes_x=mapa_transf, colunas_x=lista_x, var_resolver=lambda c: c)).lstrip('=')}"
+
+    formula_excel = _build_formula_excel(
+        params=params,
+        transformacao_y=transformacao_y,
+        transformacoes_x=mapa_transf,
+        colunas_x=lista_x,
+        var_resolver=lambda c: c,
+    )
+    formula_excel_sab = _build_formula_excel_sab(
+        params=params,
+        transformacao_y=transformacao_y,
+        transformacoes_x=mapa_transf,
+        colunas_x=lista_x,
+        var_resolver=lambda c: c,
+    )
+    return {
+        "visual_apresentacao": visual,
+        "excel": formula_excel,
+        "excel_sab": formula_excel_sab,
+    }
+
+
+def exportar_planilha_equacao(
+    *,
+    mode: str,
+    modelo_sm: Any,
+    coluna_y: str,
+    transformacao_y: str,
+    transformacoes_x: dict[str, str] | None,
+    colunas_x: list[str] | None,
+    equacao_visual: str | None = None,
+    nome_base: str = "equacao_modelo",
+) -> tuple[str, str]:
+    mode_norm = _normalize_mode(mode)
+    lista_x = [str(c) for c in (colunas_x or [])]
+    mapa_transf = {str(k): _normalize_transform(v) for k, v in (transformacoes_x or {}).items()}
+
+    if modelo_sm is None or getattr(modelo_sm, "params", None) is None:
+        raise HTTPException(status_code=400, detail="Modelo sem parametros para gerar equacao.")
+
+    params = modelo_sm.params
+    equacoes = build_equacoes_payload(
+        modelo_sm=modelo_sm,
+        coluna_y=coluna_y,
+        transformacao_y=transformacao_y,
+        transformacoes_x=mapa_transf,
+        colunas_x=lista_x,
+        equacao_visual=equacao_visual,
+    )
+    formula_texto = equacoes["excel"] if mode_norm == _MODE_EXCEL else equacoes["excel_sab"]
+
+    inicio_linhas = 2
+    mapa_refs = {coluna: f"B{inicio_linhas + idx}" for idx, coluna in enumerate(lista_x)}
+    formula_celulas_exec = _build_formula_calc_by_mode(
+        mode=mode_norm,
+        params=params,
+        transformacao_y=transformacao_y,
+        transformacoes_x=mapa_transf,
+        colunas_x=lista_x,
+        var_resolver=lambda c: mapa_refs[c],
+    )
+
+    wb = Workbook()
+    ws = wb.active
+    ws.title = "Equacao"
+
+    ws["A1"] = "Variável"
+    ws["B1"] = "Valor"
+    ws["D1"] = "Variável dependente"
+    ws["E1"] = str(coluna_y or "")
+    ws["D2"] = "Fórmula utilizada"
+    _set_formula_as_text(ws["E2"], formula_texto)
+    ws["D3"] = "Fórmula aplicada"
+    ws["E3"] = formula_celulas_exec
+
+    for idx, coluna in enumerate(lista_x):
+        row = inicio_linhas + idx
+        ws[f"A{row}"] = coluna
+        ws[f"B{row}"] = 1
+
+    for cell in ("A1", "B1", "D1", "D2", "D3"):
+        ws[cell].font = Font(bold=True)
+
+    section_fill = PatternFill(fill_type="solid", start_color="EEF5FC", end_color="EEF5FC")
+    table_header_fill = PatternFill(fill_type="solid", start_color="E6EEF8", end_color="E6EEF8")
+    border = Border(
+        left=Side(style="thin", color="D8E2EE"),
+        right=Side(style="thin", color="D8E2EE"),
+        top=Side(style="thin", color="D8E2EE"),
+        bottom=Side(style="thin", color="D8E2EE"),
+    )
+
+    for col in ("A1", "B1"):
+        ws[col].fill = table_header_fill
+        ws[col].border = border
+        ws[col].alignment = Alignment(horizontal="center", vertical="top")
+
+    for row in range(inicio_linhas, inicio_linhas + len(lista_x)):
+        ws[f"A{row}"].border = border
+        ws[f"B{row}"].border = border
+        ws[f"A{row}"].alignment = Alignment(vertical="top")
+        ws[f"B{row}"].alignment = Alignment(horizontal="center", vertical="top")
+
+    for row in (1, 2, 3):
+        ws[f"D{row}"].fill = section_fill
+        ws[f"D{row}"].border = border
+        ws[f"D{row}"].alignment = Alignment(vertical="top")
+        ws[f"E{row}"].border = border
+        ws[f"E{row}"].alignment = Alignment(wrap_text=True, vertical="top")
+
+    ws.column_dimensions["A"].width = 32
+    ws.column_dimensions["B"].width = 64
+    ws.column_dimensions["D"].width = 28
+    ws.column_dimensions["E"].width = 74
+    ws.freeze_panes = "A2"
+
+    modo_sufixo = "excel" if mode_norm == _MODE_EXCEL else "excel_estilo_sab"
+    safe_nome = "".join(ch if ch.isalnum() or ch in {"-", "_"} else "_" for ch in (nome_base or "equacao_modelo")).strip("_")
+    if not safe_nome:
+        safe_nome = "equacao_modelo"
+    file_name = f"{safe_nome}_{modo_sufixo}.xlsx"
+    caminho = os.path.join(tempfile.gettempdir(), f"{safe_nome}_{modo_sufixo}_{uuid.uuid4().hex[:8]}.xlsx")
+    wb.save(caminho)
+    return caminho, file_name

backend/app/services/visualizacao_service.py

@@ -13,6 +13,7 @@ from app.core.elaboracao.core import _migrar_pacote_v1_para_v2, avaliar_imovel,
 from app.core.elaboracao.formatadores import formatar_avaliacao_html
 from app.models.session import SessionState
 from app.services import model_repository
+from app.services.equacao_service import build_equacoes_payload, exportar_planilha_equacao
 from app.services.serializers import dataframe_to_payload, figure_to_payload, sanitize_value
 
 
@@ -141,6 +142,15 @@ def exibir_modelo(session: SessionState) -> dict[str, Any]:
     figs = viz_app.gerar_todos_graficos(pacote)
 
     info = _extrair_modelo_info(pacote)
+    diagnosticos = pacote.get("modelo", {}).get("diagnosticos", {}) if isinstance(pacote.get("modelo"), dict) else {}
+    equacoes = build_equacoes_payload(
+        modelo_sm=pacote.get("modelo", {}).get("sm"),
+        coluna_y=info["nome_y"],
+        transformacao_y=info["transformacao_y"],
+        transformacoes_x=info["transformacoes_x"],
+        colunas_x=info["colunas_x"],
+        equacao_visual=str(diagnosticos.get("equacao") or ""),
+    )
     mapa_html = viz_app.criar_mapa(dados, col_y=info["nome_y"])
 
     colunas_numericas = [
@@ -169,6 +179,7 @@ def exibir_modelo(session: SessionState) -> dict[str, Any]:
         "mapa_choices": choices_mapa,
         "campos_avaliacao": campos_avaliacao(session),
         "meta_modelo": sanitize_value(info),
+        "equacoes": sanitize_value(equacoes),
     }
 
 
@@ -397,6 +408,26 @@ def exportar_avaliacoes(session: SessionState) -> str:
     return caminho
 
 
+def exportar_equacao(session: SessionState, mode: str) -> tuple[str, str]:
+    pacote = session.pacote_visualizacao
+    if pacote is None:
+        raise HTTPException(status_code=400, detail="Carregue um modelo primeiro")
+
+    info = _extrair_modelo_info(pacote)
+    diagnosticos = pacote.get("modelo", {}).get("diagnosticos", {}) if isinstance(pacote.get("modelo"), dict) else {}
+    caminho, nome = exportar_planilha_equacao(
+        mode=mode,
+        modelo_sm=pacote.get("modelo", {}).get("sm"),
+        coluna_y=info["nome_y"],
+        transformacao_y=info["transformacao_y"],
+        transformacoes_x=info["transformacoes_x"],
+        colunas_x=info["colunas_x"],
+        equacao_visual=str(diagnosticos.get("equacao") or ""),
+        nome_base="equacao_modelo",
+    )
+    return caminho, nome
+
+
 def limpar_tudo_visualizacao(session: SessionState) -> dict[str, Any]:
     session.reset_visualizacao()
     return {

frontend/src/api.js

@@ -190,6 +190,7 @@ export const api = {
     indice_base: indiceBase,
   }),
   exportEvaluationElab: async (sessionId) => getBlob(`/api/elaboracao/evaluation/export?session_id=${encodeURIComponent(sessionId)}`),
+  exportEquationElab: async (sessionId, mode = 'excel') => getBlob(`/api/elaboracao/equation/export?session_id=${encodeURIComponent(sessionId)}&mode=${encodeURIComponent(String(mode || 'excel'))}`),
   exportModel: async (sessionId, nomeArquivo, elaborador) => {
     const response = await fetch(`${API_BASE}/api/elaboracao/export-model`, {
       method: 'POST',
@@ -232,6 +233,7 @@ export const api = {
     indice_base: indiceBase,
   }),
   exportEvaluationViz: (sessionId) => getBlob(`/api/visualizacao/evaluation/export?session_id=${encodeURIComponent(sessionId)}`),
+  exportEquationViz: (sessionId, mode = 'excel') => getBlob(`/api/visualizacao/equation/export?session_id=${encodeURIComponent(sessionId)}&mode=${encodeURIComponent(String(mode || 'excel'))}`),
   clearVisualizacao: (sessionId) => postJson('/api/visualizacao/clear', { session_id: sessionId }),
 
   repositorioListar: () => getJson('/api/repositorio/modelos'),

frontend/src/components/ElaboracaoTab.jsx

@@ -2,6 +2,7 @@ import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { api, downloadBlob } from '../api'
 import Plotly from 'plotly.js-dist-min'
 import DataTable from './DataTable'
+import EquationFormatsPanel from './EquationFormatsPanel'
 import LoadingOverlay from './LoadingOverlay'
 import MapFrame from './MapFrame'
 import PlotFigure from './PlotFigure'
@@ -1876,6 +1877,21 @@ export default function ElaboracaoTab({ sessionId }) {
     })
   }
 
+  async function onDownloadEquacao(mode) {
+    if (!sessionId || !mode) return
+    setDownloadingAssets(true)
+    setError('')
+    try {
+      const blob = await api.exportEquationElab(sessionId, mode)
+      const sufixo = String(mode) === 'excel_sab' ? 'estilo_sab' : 'excel'
+      downloadBlob(blob, `equacao_modelo_${sufixo}.xlsx`)
+    } catch (err) {
+      setError(err.message || 'Falha ao baixar equacao.')
+    } finally {
+      setDownloadingAssets(false)
+    }
+  }
+
   async function onMapVarChange(value) {
     setMapaVariavel(value)
     if (!sessionId || !mapaGerado) return
@@ -3078,6 +3094,14 @@ export default function ElaboracaoTab({ sessionId }) {
 
           <SectionBlock step="13" title="Diagnóstico de Modelo" subtitle="Resumo diagnóstico e tabelas principais do ajuste.">
             <div dangerouslySetInnerHTML={{ __html: fit.diagnosticos_html || '' }} />
+            <div className="equation-formats-section">
+              <h4>Equações do Modelo</h4>
+              <EquationFormatsPanel
+                equacoes={fit.equacoes}
+                onDownload={(mode) => void onDownloadEquacao(mode)}
+                disabled={loading || downloadingAssets}
+              />
+            </div>
             <div className="download-actions-bar">
               <span className="download-actions-label">Fazer download:</span>
               <button

frontend/src/components/EquationFormatsPanel.jsx

@@ -0,0 +1,96 @@
+import React, { useMemo, useState } from 'react'
+
+const GROUPS = [
+  { key: 'visual_apresentacao', label: 'Formato para Apresentação', canExport: false },
+  { key: 'excel', label: 'Formato Excel', canExport: true, exportMode: 'excel' },
+  { key: 'excel_sab', label: 'Formato Excel (estilo SAB)', canExport: true, exportMode: 'excel_sab' },
+]
+
+function fallbackCopy(text) {
+  const area = document.createElement('textarea')
+  area.value = text
+  area.setAttribute('readonly', '')
+  area.style.position = 'fixed'
+  area.style.opacity = '0'
+  area.style.pointerEvents = 'none'
+  document.body.appendChild(area)
+  area.focus()
+  area.select()
+  try {
+    document.execCommand('copy')
+  } finally {
+    area.remove()
+  }
+}
+
+async function copyText(text) {
+  const value = String(text || '').trim()
+  if (!value) return false
+  try {
+    if (navigator?.clipboard?.writeText) {
+      await navigator.clipboard.writeText(value)
+      return true
+    }
+  } catch {
+    // fallback below
+  }
+  try {
+    fallbackCopy(value)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export default function EquationFormatsPanel({ equacoes, onDownload, disabled = false }) {
+  const [lastCopied, setLastCopied] = useState('')
+  const groups = useMemo(() => GROUPS, [])
+
+  async function onCopy(value, key) {
+    const ok = await copyText(value)
+    setLastCopied(ok ? key : '')
+    if (ok) {
+      window.setTimeout(() => setLastCopied(''), 1800)
+    }
+  }
+
+  return (
+    <div className="equation-formats-wrap">
+      {groups.map((group) => {
+        const value = String(equacoes?.[group.key] || '').trim()
+        const hasValue = Boolean(value)
+        return (
+          <div key={group.key} className="equation-format-card">
+            <div className="equation-format-head">
+              <h5>{group.label}</h5>
+              {group.canExport ? (
+                <div className="equation-format-actions">
+                  <button
+                    type="button"
+                    className="btn-download-subtle"
+                    onClick={() => void onCopy(value, group.key)}
+                    disabled={disabled || !hasValue}
+                  >
+                    {lastCopied === group.key ? 'Copiado' : 'Copiar fórmula'}
+                  </button>
+                  <button
+                    type="button"
+                    className="btn-download-subtle"
+                    onClick={() => onDownload?.(group.exportMode)}
+                    disabled={disabled || !hasValue || typeof onDownload !== 'function'}
+                  >
+                    Baixar Excel
+                  </button>
+                </div>
+              ) : null}
+            </div>
+            <div className="equation-box equation-box-plain">
+              {hasValue ? value : 'Equação indisponível.'}
+            </div>
+          </div>
+        )
+      })}
+    </div>
+  )
+}
+

frontend/src/components/VisualizacaoTab.jsx

@@ -1,6 +1,7 @@
 import React, { useEffect, useRef, useState } from 'react'
 import { api, downloadBlob } from '../api'
 import DataTable from './DataTable'
+import EquationFormatsPanel from './EquationFormatsPanel'
 import LoadingOverlay from './LoadingOverlay'
 import MapFrame from './MapFrame'
 import PlotFigure from './PlotFigure'
@@ -37,6 +38,7 @@ export default function VisualizacaoTab({ sessionId }) {
   const [escalasHtml, setEscalasHtml] = useState('')
   const [dadosTransformados, setDadosTransformados] = useState(null)
   const [resumoHtml, setResumoHtml] = useState('')
+  const [equacoes, setEquacoes] = useState(null)
   const [coeficientes, setCoeficientes] = useState(null)
   const [obsCalc, setObsCalc] = useState(null)
 
@@ -67,6 +69,7 @@ export default function VisualizacaoTab({ sessionId }) {
     setEscalasHtml('')
     setDadosTransformados(null)
     setResumoHtml('')
+    setEquacoes(null)
     setCoeficientes(null)
     setObsCalc(null)
 
@@ -96,6 +99,7 @@ export default function VisualizacaoTab({ sessionId }) {
     setEscalasHtml(resp.escalas_html || '')
     setDadosTransformados(resp.dados_transformados || null)
     setResumoHtml(resp.resumo_html || '')
+    setEquacoes(resp.equacoes || null)
     setCoeficientes(resp.coeficientes || null)
     setObsCalc(resp.obs_calc || null)
 
@@ -359,6 +363,15 @@ export default function VisualizacaoTab({ sessionId }) {
     })
   }
 
+  async function onDownloadEquacao(mode) {
+    if (!sessionId || !mode) return
+    await withBusy(async () => {
+      const blob = await api.exportEquationViz(sessionId, mode)
+      const sufixo = String(mode) === 'excel_sab' ? 'estilo_sab' : 'excel'
+      downloadBlob(blob, `equacao_modelo_${sufixo}.xlsx`)
+    })
+  }
+
   return (
     <div className="tab-content">
       <SectionBlock step="1" title="Carregar Modelo .dai" subtitle="Carregue o arquivo e o conteúdo será exibido automaticamente.">
@@ -468,7 +481,17 @@ export default function VisualizacaoTab({ sessionId }) {
             ) : null}
 
             {activeInnerTab === 'resumo' ? (
-              <div dangerouslySetInnerHTML={{ __html: resumoHtml }} />
+              <>
+                <div className="equation-formats-section">
+                  <h4>Equações do Modelo</h4>
+                  <EquationFormatsPanel
+                    equacoes={equacoes}
+                    onDownload={(mode) => void onDownloadEquacao(mode)}
+                    disabled={loading}
+                  />
+                </div>
+                <div dangerouslySetInnerHTML={{ __html: resumoHtml }} />
+              </>
             ) : null}
 
             {activeInnerTab === 'coeficientes' ? (

frontend/src/styles.css

@@ -3006,6 +3006,56 @@ button.btn-download-subtle {
   word-break: break-word;
 }
 
+.equation-box-plain {
+  margin-top: 0;
+  background: #fff;
+  border-color: #dbe7f1;
+  border-left-color: #b9ccde;
+}
+
+.equation-formats-section {
+  margin: 14px 0 10px;
+}
+
+.equation-formats-section h4 {
+  margin: 0 0 8px;
+  color: #2d4358;
+}
+
+.equation-formats-wrap {
+  display: grid;
+  gap: 10px;
+}
+
+.equation-format-card {
+  border: 1px solid #dbe6f0;
+  border-radius: 10px;
+  background: #fbfdff;
+  padding: 10px;
+}
+
+.equation-format-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+  flex-wrap: wrap;
+  margin-bottom: 8px;
+}
+
+.equation-format-head h5 {
+  margin: 0;
+  color: #355067;
+  font-size: 0.9rem;
+}
+
+.equation-format-actions {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+
 .busca-container,
 .dai-cards-grid {
   display: grid;