> ## 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.

# Lecture des enregistrements DWVO

> Lisez, exportez et analysez des enregistrements .dwvo avec Python et OpenCV.

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

<Tooltip tip="DeepWater Video Object">`.dwvo`</Tooltip> est notre conteneur d'enregistrement multi-caméras, produit lorsque vous enregistrez dans Discovery. Le contenu est au format MJPEG, donc chaque image du fichier est déjà un JPEG complet — la lecture ne nécessite qu'un seul `cv2.imdecode`, et l'exportation est une copie d'octets sans réencodage ni perte de qualité.

<Card title="Enregistrement DWVO dans Discovery" icon="video" href="/fr/discovery/misc/dwvo-support" horizontal>
  Nouveau sur DWVO ? Commencez ici pour diffuser et enregistrer des fichiers `.dwvo`.
</Card>

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

## Prérequis

* Python (version 3.x)
* `opencv-python`, `numpy` et `pillow`
* Un enregistrement `.dwvo` — les exemples ci-dessous utilisent `test.dwvo`

## Configuration

Clonez le dépôt OpenCV Guides et ouvrez le dossier de ce guide, puis créez un environnement virtuel et installez les dépendances :

<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>

## Lecture

`main.py` décode chaque caméra et les affiche côte à côte dans une seule fenêtre OpenCV.

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

| Argument / touche |                                                                    |
| ----------------- | ------------------------------------------------------------------ |
| `--fps N`         | Cadence de lecture. Utilise par défaut la valeur fps de l'en-tête. |
| `--loop`          | Redémarre à la fin du fichier.                                     |
| `space`           | Pause / reprise.                                                   |
| `q` / `esc`       | Quitter.                                                           |

<Note>
  La lecture est calée sur un rythme fixe : si le décodage prend un retard équivalent à une image complète, cette image est ignorée plutôt qu'affichée en retard, afin que la vidéo reste à la vitesse de l'horloge murale.
</Note>

## Exportation en JPEG

Comme DWVO stocke déjà du MJPEG, `export.py` copie chaque image directement sur le disque — sans décodage ni perte de qualité.

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

# conserver une image sur cinq
python export.py file.dwvo output-folder --step 5
```

| Argument          |                                                                                             |
| ----------------- | ------------------------------------------------------------------------------------------- |
| `--step N`        | Conserver une image sur N.                                                                  |
| `--start-frame N` | Premier index de sortie, pour continuer la numérotation à partir d'une séquence précédente. |

La sortie est un répertoire par caméra, numéroté au format KITTI :

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

## PNG sans perte (jeu de données KITTI)

`dwvo_to_kitti.py` produit la même arborescence mais décode via Pillow afin de pouvoir générer du PNG sans perte. Utilisez-le lorsqu'un outil en aval n'accepte pas le JPEG ; sinon `export.py` est plus rapide.

```bash theme={null}
python dwvo_to_kitti.py test.dwvo out          # PNG
python dwvo_to_kitti.py test.dwvo out --jpeg   # same zero-copy JPEG as export.py
```

## Lire du DWVO par programmation

Dans `dwvo.py`, `DWVOReader` itère sur les blocs d'horodatage, `DWVOWriter` les écrit, et `combine_dwvos()` concatène les enregistrements qui partagent un même en-tête.

```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
```

## FAQ

<AccordionGroup>
  <Accordion title="Pourquoi la vidéo est-elle plus lente que ce que j'ai enregistré ?">
    Dans Discovery, certaines caméras nécessitent de définir le FPS manuellement. S'il était réglé à 30 FPS alors que la vidéo était diffusée à 60 FPS, le fichier `.dwvo` enregistre 30 FPS dans ses métadonnées et indique aux applications de lire à 30 FPS. Remplacez cette valeur lors de la lecture avec `--fps`.
  </Accordion>
</AccordionGroup>

## Informations supplémentaires

Pour plus de détails, des exemples dans d'autres langages, et le code source complet des scripts ci-dessus, consultez le dépôt OpenCV Guides.

<Card title="Dépôt OpenCV Guides" icon="Github" href="https://github.com/DeepWaterExploration/opencv-guides">
  Code source du lecteur DWVO, de la lecture, de l'exportation et de la conversion KITTI.
</Card>