File size: 6,859 Bytes
a86bc58
 
 
 
 
d597bbb
 
a86bc58
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
d597bbb
 
 
 
 
 
a86bc58
 
 
 
 
02a03b1
a86bc58
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
02a03b1
a86bc58
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
02a03b1
a86bc58
 
 
 
 
 
 
 
 
 
 
 
 
02a03b1
a86bc58
 
 
02a03b1
 
a86bc58
 
 
 
02a03b1
a86bc58
02a03b1
a86bc58
 
02a03b1
 
 
 
 
 
 
 
a86bc58
02a03b1
 
 
a86bc58
02a03b1
 
a86bc58
02a03b1
 
 
a86bc58
02a03b1
 
a86bc58
02a03b1
 
 
a86bc58
02a03b1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
# modules/studentact/current_situation_interface.py

import streamlit as st
import logging
from ..utils.widget_utils import generate_unique_key
import matplotlib.pyplot as plt
import numpy as np
from ..database.current_situation_mongo_db import store_current_situation_result

from .current_situation_analysis import (
    analyze_text_dimensions, 
    analyze_clarity,
    analyze_reference_clarity,
    analyze_vocabulary_diversity, 
    analyze_cohesion,
    analyze_structure,
    get_dependency_depths, 
    normalize_score, 
    generate_sentence_graphs, 
    generate_word_connections, 
    generate_connection_paths,
    create_vocabulary_network, 
    create_syntax_complexity_graph, 
    create_cohesion_heatmap,     
)

# Configuración del estilo de matplotlib para el gráfico de radar
plt.style.use('seaborn')  # Opcional - da un estilo más moderno
plt.rcParams['font.family'] = 'sans-serif'
plt.rcParams['font.sans-serif'] = ['Arial']


logger = logging.getLogger(__name__)
####################################

def display_current_situation_interface(lang_code, nlp_models, t):
    """
    Interfaz simplificada con gráfico de radar para visualizar métricas.
    """
    try:
        # Inicializar estados si no existen
        if 'text_input' not in st.session_state:
            st.session_state.text_input = ""
        if 'show_results' not in st.session_state:
            st.session_state.show_results = False
        if 'current_doc' not in st.session_state:
            st.session_state.current_doc = None
        if 'current_metrics' not in st.session_state:
            st.session_state.current_metrics = None

        st.markdown("## Análisis Inicial de Escritura")
        
        # Container principal con dos columnas
        with st.container():
            input_col, results_col = st.columns([1,2])
            
            with input_col:
                st.markdown("### Ingresa tu texto")
                
                # Función para manejar cambios en el texto
                def on_text_change():
                    st.session_state.text_input = st.session_state.text_area
                    st.session_state.show_results = False
                
                # Text area con manejo de estado
                text_input = st.text_area(
                    t.get('input_prompt', "Escribe o pega tu texto aquí:"),
                    height=400,
                    key="text_area",
                    value=st.session_state.text_input,
                    on_change=on_text_change,
                    help="Este texto será analizado para darte recomendaciones personalizadas"
                )
                
                if st.button(
                    t.get('analyze_button', "Analizar mi escritura"),
                    type="primary",
                    disabled=not text_input.strip(),
                    use_container_width=True,
                ):
                    try:
                        with st.spinner(t.get('processing', "Analizando...")):
                            doc = nlp_models[lang_code](text_input)
                            metrics = analyze_text_dimensions(doc)
                            
                            # Guardar en MongoDB
                            storage_success = store_current_situation_result(
                                username=st.session_state.username,
                                text=text_input,
                                metrics=metrics,
                                feedback=None
                            )
                            
                            if not storage_success:
                                logger.warning("No se pudo guardar el análisis en la base de datos")
                            
                            st.session_state.current_doc = doc
                            st.session_state.current_metrics = metrics
                            st.session_state.show_results = True
                            st.session_state.text_input = text_input
                            
                    except Exception as e:
                        logger.error(f"Error en análisis: {str(e)}")
                        st.error(t.get('analysis_error', "Error al analizar el texto"))
            
            # Mostrar resultados en la columna derecha
            with results_col:
                if st.session_state.show_results and st.session_state.current_metrics is not None:
                    display_radar_chart(st.session_state.current_metrics)

    except Exception as e:
        logger.error(f"Error en interfaz: {str(e)}")
        st.error("Ocurrió un error. Por favor, intente de nuevo.")

def display_radar_chart(metrics):
    """
    Muestra un gráfico de radar con las cuatro métricas.
    """
    try:
        # Preparar datos para el gráfico de radar
        categories = ['Vocabulario', 'Estructura', 'Cohesión', 'Claridad']
        values = [
            metrics['vocabulary']['normalized_score'],
            metrics['structure']['normalized_score'],
            metrics['cohesion']['normalized_score'],
            metrics['clarity']['normalized_score']
        ]

        # Crear figura
        fig = plt.figure(figsize=(8, 8))
        ax = fig.add_subplot(111, projection='polar')

        # Número de variables
        num_vars = len(categories)

        # Calcular ángulos para cada eje
        angles = [n / float(num_vars) * 2 * np.pi for n in range(num_vars)]
        angles += angles[:1]  # Completar el círculo

        # Extender valores para cerrar el polígono
        values += values[:1]

        # Dibujar las líneas de la cuadrícula principal
        ax.set_xticks(angles[:-1])
        ax.set_xticklabels(categories)

        # Configurar círculos concéntricos y etiquetas
        circle_ticks = np.arange(0, 1.1, 0.1)
        ax.set_yticks(circle_ticks)
        ax.set_yticklabels([f'{tick:.1f}' for tick in circle_ticks])
        ax.set_ylim(0, 1)

        # Dibujar líneas de la cuadrícula
        ax.grid(True)

        # Dibujar el gráfico
        ax.plot(angles, values, 'o-', linewidth=2, label='Métricas')
        ax.fill(angles, values, alpha=0.25)

        # Ajustar el layout y mostrar
        plt.tight_layout()
        st.pyplot(fig)
        plt.close()

        # Mostrar valores numéricos debajo del gráfico
        col1, col2, col3, col4 = st.columns(4)
        with col1:
            st.metric("Vocabulario", f"{values[0]:.2f}")
        with col2:
            st.metric("Estructura", f"{values[1]:.2f}")
        with col3:
            st.metric("Cohesión", f"{values[2]:.2f}")
        with col4:
            st.metric("Claridad", f"{values[3]:.2f}")

    except Exception as e:
        logger.error(f"Error generando gráfico de radar: {str(e)}")
        st.error("Error al generar la visualización")