> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dwe.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Lectura de grabaciones DWVO

> Reproduce, exporta y analiza grabaciones .dwvo con Python y OpenCV.

<div style={{ marginTop: '-40px' }} />

<Tooltip tip="DeepWater Video Object">`.dwvo`</Tooltip> es nuestro contenedor de grabación multicámara, generado cuando grabas en Discovery. La carga útil es MJPEG, por lo que cada fotograma del archivo ya es un JPEG completo: la reproducción es un único `cv2.imdecode`, y la exportación es una copia de bytes sin recodificación ni pérdida de calidad.

<Card title="Grabación DWVO en Discovery" icon="video" href="/es/discovery/misc/dwvo-support" horizontal>
  ¿Nuevo en DWVO? Empieza aquí para transmitir y grabar archivos `.dwvo`.
</Card>

```
DWE.ai | header: nCameras, width, height, pixelFormat, fps | ext data
block:   uint32 timestamp | per camera: busID\0, uint32 length, JPEG bytes
block:   ...
```

## Requisitos previos

* Python (versión 3.x)
* `opencv-python`, `numpy` y `pillow`
* Una grabación `.dwvo`; los ejemplos siguientes usan `test.dwvo`

## Configuración

Clona el repositorio de guías de OpenCV y abre la carpeta de esta guía, luego crea un entorno virtual e instala las dependencias:

<CodeGroup>
  ```bash macOS / Linux theme={null}
  git clone https://github.com/DeepWaterExploration/opencv-guides.git
  cd opencv-guides/4-dwvo-read/python

  python3 -m venv venv
  source venv/bin/activate
  pip install -r requirements.txt
  ```

  ```bash Windows theme={null}
  git clone https://github.com/DeepWaterExploration/opencv-guides.git
  cd opencv-guides\4-dwvo-read\python

  python3 -m venv venv
  venv\Scripts\activate
  pip install -r requirements.txt
  ```
</CodeGroup>

## Reproducción

`main.py` decodifica todas las cámaras y las muestra una al lado de la otra en una sola ventana de OpenCV.

```bash theme={null}
python main.py test.dwvo
python main.py test.dwvo --fps 60 --loop
```

| Argumento / tecla |                                                                    |
| ----------------- | ------------------------------------------------------------------ |
| `--fps N`         | Velocidad de reproducción. Por defecto usa los fps del encabezado. |
| `--loop`          | Reinicia al llegar al final del archivo.                           |
| `space`           | Pausar / reanudar.                                                 |
| `q` / `esc`       | Salir.                                                             |

<Note>
  La reproducción está anclada a una programación fija: si la decodificación se retrasa un fotograma completo, ese fotograma se descarta en lugar de mostrarse tarde, de modo que el video se mantiene a la velocidad del reloj real.
</Note>

## Exportar a JPEG

Como DWVO ya almacena MJPEG, `export.py` copia cada fotograma directamente al disco: sin decodificación ni pérdida de calidad.

```bash theme={null}
python export.py file.dwvo output-folder

# conserva uno de cada cinco fotogramas
python export.py file.dwvo output-folder --step 5
```

| Argumento         |                                                                                     |
| ----------------- | ----------------------------------------------------------------------------------- |
| `--step N`        | Conserva uno de cada N fotogramas.                                                  |
| `--start-frame N` | Primer índice de salida, para continuar la numeración desde una secuencia anterior. |

La salida es un directorio por cámara, numerado al estilo KITTI:

```
out/
  image_0/000000.jpg, 000001.jpg, ...
  image_1/000000.jpg, 000001.jpg, ...
  times.txt
```

## PNG sin pérdida (conjunto de datos KITTI)

`dwvo_to_kitti.py` genera el mismo diseño, pero decodifica a través de Pillow para poder emitir PNG sin pérdida. Úsalo cuando una herramienta posterior no acepte JPEG; de lo contrario, `export.py` es más rápido.

```bash theme={null}
python dwvo_to_kitti.py test.dwvo out          # PNG
python dwvo_to_kitti.py test.dwvo out --jpeg   # mismo JPEG sin copias que export.py
```

## Lectura de DWVO mediante programación

En `dwvo.py`, `DWVOReader` itera bloques de marca de tiempo, `DWVOWriter` los escribe y `combine_dwvos()` concatena grabaciones que comparten encabezado.

```python theme={null}
from pathlib import Path
from dwvo import DWVOReader

with DWVOReader(Path("test.dwvo")) as reader:
    print(reader.header.n_cameras, reader.header.width, reader.header.height)
    for block in reader.iter_blocks():
        for frame in block.video_frames:   # one per camera
            frame.bus_id, frame.data       # "0" / "1", raw JPEG bytes
```

## Preguntas frecuentes

<AccordionGroup>
  <Accordion title="¿Por qué el video es más lento de lo que grabé?">
    En Discovery, algunas cámaras requieren establecer los FPS manualmente. Si se configuró a 30 FPS mientras el video se transmitía a 60 FPS, el archivo `.dwvo` registra 30 FPS en sus metadatos e indica a las aplicaciones que lo lean a 30 FPS. Anúlalo durante la reproducción con `--fps`.
  </Accordion>
</AccordionGroup>

## Información adicional

Para más detalles, ejemplos en otros lenguajes y el código fuente completo de los scripts anteriores, consulta el repositorio de guías de OpenCV.

<Card title="Repositorio de guías de OpenCV" icon="Github" href="https://github.com/DeepWaterExploration/opencv-guides">
  Código fuente del lector DWVO, reproducción, exportación y conversión a KITTI.
</Card>