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

# DWVO-Aufzeichnungen lesen

> Wiedergabe, Export und Parsen von .dwvo-Aufzeichnungen mit Python und OpenCV.

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

<Tooltip tip="DeepWater Video Object">`.dwvo`</Tooltip> ist unser Mehrkamera-Aufzeichnungscontainer, der beim Aufzeichnen in Discovery erstellt wird. Die Nutzdaten sind MJPEG, sodass jedes Bild in der Datei bereits ein vollständiges JPEG ist – die Wiedergabe erfolgt mit einem einzigen `cv2.imdecode`, und der Export ist eine Byte-Kopie ohne erneute Kodierung oder Qualitätsverlust.

<Card title="DWVO in Discovery aufzeichnen" icon="video" href="/de/discovery/misc/dwvo-support" horizontal>
  Neu bei DWVO? Beginnen Sie hier, um `.dwvo`-Dateien zu streamen und aufzuzeichnen.
</Card>

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

## Voraussetzungen

* Python (Version 3.x)
* `opencv-python`, `numpy` und `pillow`
* Eine `.dwvo`-Aufzeichnung – die Beispiele unten verwenden `test.dwvo`

## Einrichtung

Klonen Sie das OpenCV-Guides-Repository und öffnen Sie den Ordner für diese Anleitung, erstellen Sie dann eine virtuelle Umgebung und installieren Sie die Abhängigkeiten:

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

## Wiedergabe

`main.py` dekodiert jede Kamera und zeigt sie nebeneinander in einem OpenCV-Fenster an.

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

| Argument / Taste |                                                             |
| ---------------- | ----------------------------------------------------------- |
| `--fps N`        | Wiedergaberate. Standardmäßig die im Header angegebene FPS. |
| `--loop`         | Am Ende der Datei neu starten.                              |
| `space`          | Pause / Fortsetzen.                                         |
| `q` / `esc`      | Beenden.                                                    |

<Note>
  Die Wiedergabe folgt einem festen Zeitplan: Wenn das Dekodieren um einen ganzen Frame in Rückstand gerät, wird dieser Frame verworfen anstatt verspätet angezeigt, sodass das Video in Echtzeit läuft.
</Note>

## Export als JPEGs

Da DWVO bereits MJPEG speichert, kopiert `export.py` jedes Bild direkt auf die Festplatte – ohne Dekodierung und ohne Qualitätsverlust.

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

# jeden fünften Frame behalten
python export.py file.dwvo output-folder --step 5
```

| Argument          |                                                                               |
| ----------------- | ----------------------------------------------------------------------------- |
| `--step N`        | Jeden N-ten Frame behalten.                                                   |
| `--start-frame N` | Erster Ausgabeindex, um die Nummerierung einer früheren Sequenz fortzusetzen. |

Die Ausgabe erfolgt in einem Verzeichnis pro Kamera, nummeriert im KITTI-Stil:

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

## Verlustfreies PNG (KITTI-Datensatz)

`dwvo_to_kitti.py` erzeugt dasselbe Layout, dekodiert jedoch über Pillow, sodass es verlustfreies PNG ausgeben kann. Verwenden Sie es, wenn ein nachgelagertes Tool JPEG nicht akzeptiert; andernfalls ist `export.py` schneller.

```bash theme={null}
python dwvo_to_kitti.py test.dwvo out          # PNG
python dwvo_to_kitti.py test.dwvo out --jpeg   # gleiches Zero-Copy-JPEG wie export.py
```

## DWVO programmatisch lesen

In `dwvo.py` iteriert `DWVOReader` über die Zeitstempel-Blöcke, `DWVOWriter` schreibt sie, und `combine_dwvos()` verkettet Aufzeichnungen, die denselben Header haben.

```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="Warum ist das Video langsamer als das, was ich aufgezeichnet habe?">
    In Discovery erfordern einige Kameras, dass die FPS manuell eingestellt werden. Wenn sie auf 30 FPS eingestellt waren, während das Video mit 60 FPS gestreamt wurde, verzeichnet die `.dwvo`-Datei 30 FPS in ihren Metadaten und weist Anwendungen an, mit 30 FPS zu lesen. Überschreiben Sie dies bei der Wiedergabe mit `--fps`.
  </Accordion>
</AccordionGroup>

## Weitere Informationen

Für zusätzliche Details, Beispiele in anderen Sprachen und den vollständigen Quellcode der oben genannten Skripte siehe das OpenCV-Guides-Repository.

<Card title="OpenCV-Guides-Repository" icon="Github" href="https://github.com/DeepWaterExploration/opencv-guides">
  Quellcode für DWVO-Reader, Wiedergabe, Export und KITTI-Konvertierung.
</Card>