fix: resolver consistencia en filtros dsp, deduplicar dispositivos de audio y actualizar reportes académicos

README.md

@@ -1,123 +1,136 @@
-# DSP Analyzer — Repositorio Monorepo
+# Analizador de Procesamiento Digital de Señales (DSP Lab)
 
-Este repositorio contiene el proyecto integrado para el analizador de procesamiento digital de señales (DSP). Está estructurado como un monorepo que incluye:
-* **`core/dsp/`**: El motor matemático en Python (módulo que se entrega para el Trabajo Práctico de la universidad).
-* **`apps/api/`**: El backend en FastAPI que expone las funciones matemáticas mediante endpoints HTTP.
-* **`apps/desktop/`**: La interfaz gráfica interactiva de escritorio construida con Tauri y Vue 3.
+Este repositorio contiene el entorno integrado para el modelado, filtrado e identificación de sistemas de procesamiento digital de señales (DSP). La arquitectura del proyecto está estructurada como un monorepo que consta de un motor matemático en Python, un servicio backend en FastAPI para la exposición de endpoints numéricos, y una interfaz de usuario interactiva multiplataforma desarrollada en Tauri y Vue 3.
 
 ---
 
-## 🛠️ Ruta 1: Desarrollo del Motor DSP (Solo Python)
-*Recomendado para los integrantes del equipo que trabajarán exclusivamente en las funciones matemáticas de `core/dsp/` y en los Jupyter Notebooks.*
+### Pantalla de Inicio
+![Pantalla de Inicio](apps/desktop/public/home.png)
 
-Esta ruta **no** requiere instalar Node.js, Rust, Docker ni compiladores de C/C++. Solo requiere una instalación estándar de Python.
+### Ejemplo de Análisis de Señales y Coherencia Espectral
+![Análisis de Señales y Coherencia Espectral](apps/desktop/public/senales.png)
 
-### Requisitos previos
-* **Python 3.11 o superior** instalado.
-  * *Nota para Windows:* Al instalar Python desde el instalador oficial, asegúrese de marcar la casilla **"Add python.exe to PATH"** en la primera pantalla.
+---
 
-### Configuración del Entorno de Trabajo
+## 📂 Estructura del Repositorio
 
-1. **Clonar el repositorio:**
-   ```bash
-   git clone <URL_DEL_REPOSITORIO>
-   cd TP-DSP
-   ```
+* **`faculty/`**: Contiene los entregables académicos del proyecto (Jupyter Notebooks, reportes técnicos y funciones de simulación).
+  * **`faculty/preentrega/`**: Primera entrega (Parte 1: generación de señales, convolución en tiempo/frecuencia y análisis de filtros).
+  * **`faculty/final/`**: Entrega final (Parte 2: caracterización e identificación de sistemas desconocidos y coherencia espectral).
+* **`core/dsp/`**: Motor numérico puro implementado en Python (cálculo de transformadas de Fourier, diseño de filtros FIR/IIR y estimaciones espectrales).
+  * **`core/dsp/tests/`**: Suite de pruebas unitarias automatizadas para la validación de los algoritmos y la precisión matemática.
+* **`apps/api/`**: Servidor FastAPI que actúa como puente de comunicación, exponiendo el motor de cálculo en Python mediante una interfaz HTTP.
+* **`apps/desktop/`**: Interfaz de escritorio multiplataforma (HTML/CSS/TS/Vue 3 y Tauri v2) para el análisis dinámico.
 
-2. **Crear un entorno virtual de Python:**
-   ```bash
-   python -m venv .venv
-   ```
+---
 
-3. **Activar el entorno virtual:**
-   * **En Windows (Símbolo del sistema - CMD):**
-     ```cmd
-     .venv\Scripts\activate.bat
-     ```
-   * **En Windows (PowerShell):**
-     ```powershell
-     # Si el sistema bloquea la ejecución de scripts, ejecute primero:
-     Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope Process
-     # Luego active el entorno:
-     .venv\Scripts\Activate.ps1
-     ```
-   * **En Git Bash, Linux o macOS:**
-     ```bash
-     source .venv/bin/activate
-     ```
-
-4. **Instalar las dependencias del proyecto:**
-   ```bash
-   pip install --upgrade pip
-   pip install -e .
-   pip install pytest
-   ```
+## 🛠️ Instrucciones de Configuración y Evaluación
 
-### Ejecutar las Pruebas Unitarias (Tests)
-Una vez activado el entorno virtual, puede validar la correcta implementación matemática de las funciones mediante las pruebas unitarias automatizadas:
+El entorno puede evaluarse e interactuarse mediante dos vías independientes, de acuerdo al nivel de profundidad y alcance requerido:
 
-* **Ejecutar todos los tests:**
-  ```bash
-  pytest
+---
+
+### Vía A: Evaluación del Núcleo Matemático y Reportes (Jupyter Notebooks & Python Core)
+
+*Orientado a la verificación de los desarrollos teóricos, ecuaciones de filtrado, análisis de coherencia espectral y validación del motor numérico sin necesidad de compilar la interfaz de usuario.*
+
+Esta vía requiere únicamente una instalación estándar de Python (versión 3.11 o superior). No requiere compiladores de Rust ni gestores de dependencias web.
+
+#### 1. Aislamiento del Entorno de Ejecución
+Abra una terminal, clone el repositorio y acceda a la carpeta raíz:
+```bash
+git clone https://github.com/Roomwaves/dsp-lab.git
+cd TP-DSP
+```
+
+Inicialice y active un entorno virtual (`venv`):
+* **En Windows (cmd):**
+  ```cmd
+  python -m venv .venv
+  .venv\Scripts\activate.bat
   ```
-* **Ejecutar las pruebas de un archivo específico (ej. filtros):**
-  ```bash
-  pytest core/dsp/tests/test_filters.py
+* **En Windows (PowerShell):**
+  ```powershell
+  python -m venv .venv
+  Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope Process
+  .venv\Scripts\Activate.ps1
   ```
-* **Ejecutar una prueba específica por su nombre:**
+* **En macOS / Linux:**
   ```bash
-  pytest -k "test_dc_preservation"
+  python3 -m venv .venv
+  source .venv/bin/activate
   ```
 
+#### 2. Instalación de Dependencias
+Instale el paquete de DSP local en modo desarrollo/editable junto con los paquetes necesarios para la simulación:
+```bash
+pip install --upgrade pip
+pip install -e .
+pip install jupyter pytest
+```
+
+#### 3. Acceso a los Notebooks Académicos
+Inicie el entorno interactivo de Jupyter:
+```bash
+jupyter notebook
+```
+A través del navegador web, acceda al directorio `faculty/` para examinar el desarrollo y las celdas de simulación:
+* **Preentrega (Parte 1):** [faculty/preentrega/notebook.ipynb](faculty/preentrega/notebook.ipynb) (funciones de soporte en [faculty/preentrega/functions.py](faculty/preentrega/functions.py)).
+* **Entrega Final (Partes 1 y 2):** [faculty/final/notebook.ipynb](faculty/final/notebook.ipynb) (funciones de soporte en [faculty/final/functions.py](faculty/final/functions.py)).
+
+#### 4. Validación Matemática Automatizada
+El núcleo del sistema cuenta con pruebas unitarias (`pytest`) que aseguran la consistencia numérica de las operaciones matemáticas de filtrado, generación de señales y coherencia espectral en [core/dsp/tests/](core/dsp/tests/). Para ejecutarlas, corra:
+```bash
+pytest
+```
+
 ---
 
-## 🚀 Ruta 2: Desarrollo del Sistema Completo (Desktop + API)
-*Recomendado para ejecutar la aplicación de escritorio de forma local y conectar la interfaz de usuario con el motor matemático.*
+### Vía B: Ejecución del Sistema Completo (Aplicación de Escritorio & API)
 
-### Requisitos previos
-* **Node.js (v20 o superior)**
-* **Rust (rustup)** y herramientas de compilación de C++ (Build Tools para Visual Studio en Windows).
-* **uv** (Administrador de paquetes de Python rápido, opcional).
-* **Docker** (opcional, para levantar el servidor de FastAPI en un contenedor).
+*Orientado a la experimentación interactiva de la herramienta completa, permitiendo la manipulación dinámica y en tiempo real de las señales y espectros generados.*
 
-### Configuración Inicial
+#### Requisitos Previos
+* **Node.js (v20 o superior)**.
+* **Rust (rustup)** y herramientas de compilación nativas de C++ (Build Tools para Visual Studio en Windows).
+* **Python (v3.11 o superior)**.
+* **uv** (opcional, administrador de paquetes de Python rápido).
 
-1. **Instalar dependencias de Python y Node.js:**
-   ```bash
-   # Si usa uv (instalación rápida de dependencias de Python):
-   uv sync
+#### Flujo de Ejecución
 
-   # Instalar dependencias del frontend:
+1. **Instalación de Dependencias Generales:**
+   ```bash
+   # Configuración del entorno de Python
+   uv sync  # o bien "pip install -e ." con el entorno virtual activo
+
+   # Configuración del entorno frontend
    cd apps/desktop
    npm install
    cd ../..
    ```
 
-2. **Ejecutar el backend (FastAPI):**
-   * **Opción A (Sin Docker):**
-     ```bash
-     npm run api:dev
-     ```
-   * **Opción B (Con Docker):**
-     ```bash
-     npm run docker:up
-     ```
-
-3. **Ejecutar la aplicación de escritorio (Tauri + Vue):**
-   En una nueva pestaña de la terminal, ejecute:
+2. **Inicialización del Backend de Cálculo (FastAPI):**
+   Inicie la API de cálculo (por defecto en localhost:8000) ejecutando en su terminal:
+   ```bash
+   npm run api:dev
+   ```
+   *(Nota: Alternativamente, si dispone de Docker, puede levantar el servicio mediante `npm run docker:up`)*
+
+3. **Inicialización del Cliente Gráfico (Tauri + Vue 3):**
+   Abra una **nueva terminal** (manteniendo el backend activo), asegúrese de activar su entorno virtual de Python y ejecute:
    ```bash
    npm run dev
    ```
+   El motor de compilación generará la interfaz y abrirá automáticamente la ventana nativa de escritorio del analizador.
 
 ---
 
-## 📂 Estructura del Repositorio
+## 👥 Integrantes
 
-* **`core/dsp/`**: Código fuente de procesamiento de señal en Python.
-  * **`core/dsp/tests/`**: Archivos de prueba unitaria (`test_*.py`).
-* **`faculty/`**: Notebooks de Jupyter e informes académicos para entrega.
-* **`apps/api/`**: Servidor FastAPI (puente de red entre la app de escritorio y las funciones en Python).
-* **`apps/desktop/`**: Interfaz de usuario multiplataforma (HTML/CSS/TS/Vue).
+* Ferreyra, Florencia
+* Gonzalez, Tomás
+* Molina, Lara
+* Scafati, Jerónimo
 
 ---
 ## Intengrantes
@@ -128,4 +141,5 @@ Una vez activado el entorno virtual, puede validar la correcta implementación m
 - Scafati, Jerónimo 
 
 ## 📄 Licencia
+
 Este proyecto se distribuye bajo la licencia PolyForm Noncommercial 1.0.0. No se permite el uso comercial sin autorización previa.

apps/api/main.py

@@ -4,7 +4,7 @@
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
-from .routes import analysis, coherence, filters
+from .routes import analysis, coherence, filters, signals
 from .routes import io as io_routes
 
 ALLOWED_ORIGINS = [
@@ -32,6 +32,7 @@ async def lifespan(app: FastAPI):
 app.include_router(analysis.router)
 app.include_router(coherence.router)
 app.include_router(io_routes.router)
+app.include_router(signals.router)
 
 @app.get("/health")
 def health():

apps/api/routes/analysis.py

@@ -24,7 +24,12 @@
 def fft_endpoint(body: SignalInput) -> FFTOutput:
     try:
         signal = np.array(body.samples)
-        freqs, mags = compute_fft(signal, body.fs)
+        freqs, mags = compute_fft(
+            signal, body.fs,
+            window_size=body.window_size,
+            overlap=body.overlap,
+            window_type=body.window_type
+        )
         return FFTOutput(
             frequencies=freqs.tolist(),
             magnitudes=mags.tolist()
@@ -39,7 +44,12 @@ def frequency_response_endpoint(
     try:
         x = np.array(body.x)
         y = np.array(body.y)
-        freqs, h_complex = compute_frequency_response(x, y, body.fs)
+        freqs, h_complex = compute_frequency_response(
+            x, y, body.fs,
+            window_size=body.window_size,
+            overlap=body.overlap,
+            window_type=body.window_type
+        )
 
         mag_db = compute_magnitude_db(h_complex)
         phase_rad = compute_phase(h_complex)

apps/api/routes/coherence.py

@@ -43,7 +43,13 @@ def coherence_endpoint(body: CoherenceInput) -> CoherenceOutput:
     try:
         x = np.array(body.x)
         y = np.array(body.y)
-        freqs, coherence = compute_coherence(x, y, body.fs, n_segments=body.n_segments)
+        freqs, coherence = compute_coherence(
+            x, y, body.fs,
+            n_segments=body.n_segments,
+            window_size=body.window_size,
+            overlap=body.overlap,
+            window_type=body.window_type
+        )
         return CoherenceOutput(
             frequencies=freqs.tolist(),
             coherence=coherence.tolist()