Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# 3D-Punktwolkeneingabedaten
Um einen 3D-Punktwolken-Kennzeichnungsauftrag zu erstellen, müssen Sie eine Eingabemanifestdatei erstellen. In diesem Thema erfahren Sie mehr über die Formatierungsanforderungen der Eingabemanifestdatei für jeden Aufgabentyp. Informationen über die von Ground Truth akzeptierten Rohdatenformate für 3D-Punktwolkenbeschriftungsaufträge finden Sie im Abschnitt [Akzeptierte 3D-Rohdatenformate](sms-point-cloud-raw-data-types.md).
Verwenden Sie den [Aufgabentyp der Labeling-Aufgabe](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-point-cloud-task-types.html), um Themen zu [Eingabemanifestdateien für 3D-Punktwolken-Kennzeichnungsaufträge](sms-point-cloud-input-manifest.md) auszuwählen, in denen Sie mehr über die Formatierungsanforderungen für jede Zeile Ihrer Eingabemanifestdatei erfahren können.
**Topics**
+ [Akzeptierte 3D-Rohdatenformate](sms-point-cloud-raw-data-types.md)
+ [Eingabemanifestdateien für 3D-Punktwolken-Kennzeichnungsaufträge](sms-point-cloud-input-manifest.md)
+ [Grundlegendes zu Koordinatensystemen und Sensorfusion](sms-point-cloud-sensor-fusion-details.md)
# Akzeptierte 3D-Rohdatenformate
Ground Truth verwendet Ihre 3D-Punktwolkendaten, um eine 3D-Szene zu rendern, die von den Auftragnehmern mit Anmerkungen versehen wird. In diesem Abschnitt werden die Rohdatenformate beschrieben, die für Punktwolkendaten und Sensorfusionsdaten für einen Punktwolkenframe akzeptiert werden. Informationen zum Erstellen einer Eingabemanifestdatei zur Verbindung Ihrer Roheingabedatendateien mit Ground Truth finden Sie unter [Eingabemanifestdateien für 3D-Punktwolken-Kennzeichnungsaufträge](sms-point-cloud-input-manifest.md).
Ground Truth unterstützt für jedes Bild Compact Binary Pack Format (.bin) und ASCII (.txt) Dateien. Diese Dateien enthalten Informationen über die Position (`x`-, – `y`und `z`-Koordinaten) aller Punkte, aus denen dieser Frame besteht, und optional Informationen zur Pixelfarbe jedes Punktes für farbige Punktwolken. Wenn Sie eine Eingabemanifestdatei für 3D-Punktwolken-Kennzeichnungsaufträge erstellen, können Sie das Format der Rohdaten im Parameter `format` angeben.
In der folgenden Tabelle sind Elemente aufgeführt, die Ground Truth in Punktwolken-Rahmendateien zur Beschreibung einzelner Punkte unterstützt.
****
| Symbol | Wert |
| --- | --- |
| `x` | Die x-Koordinate des Punktes. |
| `y` | Die y-Koordinate des Punktes. |
| `z` | Die z-Koordinate des Punktes. |
| `i` | Die Intensität des Punktes. |
| `r` | Die rote Farbkanalkomponente. Ein 8-Bit-Wert (0-255). |
| `g` | Die grüne Farbkanalkomponente. Ein 8-Bit-Wert (0-255) |
| `b` | Die blaue Farbkanalkomponente. Ein 8-Bit-Wert (0-255) |
Ground Truth geht von den folgenden Annahmen über Ihre Eingabedaten aus:
+ Alle Positionskoordinaten (x, y, z) sind in Metern angegeben.
+ Alle Posenfahrkurse (qx, qy, qz, qw) werden in räumlichen [Quaternionen](https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation) gemessen.
## Compact Binary Pack-Format
Das Compact Binary Pack-Format stellt eine Punktwolke als geordnete Menge eines Streams von Punkten dar. Jeder Punkt im Stream ist ein geordnetes Binärpaket von 4-Byte-Gleitkommawerten in einer Variante der Form `xyzirgb`. Die Elemente `x`, `y` und `z` sind erforderlich und zusätzliche Informationen zu diesem Pixel können auf verschiedene Arten mit `i`, `r`, `g` und `b` einbezogen werden.
Um eine Binärdatei zur Eingabe von Punktwolken-Rahmendaten in einen Ground Truth 3D-Punktwolken-Beschriftungsauftrag zu verwenden, geben Sie in den Parameter `format` für Ihre Eingabemanifestdatei `binary/` ein und ersetzen Sie `` durch die Reihenfolge der Elemente in jedem Binärpaket. Sie können z. B. eine der folgenden Optionen für den Parameter `format` eingeben.
+ `binary/xyzi` – Wenn Sie dieses Format verwenden, wird Ihr Punktelement-Stream in der folgenden Reihenfolge angezeigt: `x1y1z1i1x2y2z2i2...`
+ `binary/xyzrgb` – Wenn Sie dieses Format verwenden, wird Ihr Punktelement-Stream in der folgenden Reihenfolge angezeigt: `x1y1z1r1g1b1x2y2z2r2g2b2...`
+ `binary/xyzirgb` – Wenn Sie dieses Format verwenden, wird Ihr Punktelement-Stream in der folgenden Reihenfolge angezeigt: `x1y1z1i1r1g1b1x2y2z2i2r2g2b2...`
Wenn Sie eine Binärdatei für die Punktwolkenframedaten verwenden und keinen Wert für `format` eingeben, wird das Standardpaketformat `binary/xyzi` verwendet.
## ASCII-Format
Das ASCII-Format verwendet eine Textdatei, um eine Punktwolke darzustellen, wobei jede Zeile in der ASCII-Punktwolkendatei einen einzelnen Punkt darstellt. Jeder Punkt ist eine Zeile der Textdatei und enthält durch Leerzeichen getrennte Werte, von denen jeder ein 4-Byte-ASCII-Gleitkommawert ist. Die Elemente `x`, `y` und `z` sind für jeden Punkt erforderlich und zusätzliche Informationen zu diesem Punkt können auf verschiedene Arten mit `i`, `r`, `g` und `b` einbezogen werden.
Um eine Textdatei zur Eingabe von Punktwolken-Rahmendaten in einen Ground Truth 3D-Punktwolken-Beschriftungsauftrag zu verwenden, geben Sie `text/` in den `format`-Parameter für Ihre Eingabemanifestdatei ein und ersetzen Sie `` durch die Reihenfolge der Punktelemente in jeder Zeile.
Wenn Sie beispielsweise `text/xyzi` für `format` eingeben, sollte Ihre Textdatei für jeden Punktwolkenframe wie folgt aussehen:
```
x1 y1 z1 i1
x2 y2 z2 i2
...
...
```
Wenn Sie `text/xyzrgb` eingeben, sollte Ihre Textdatei wie folgt aussehen:
```
x1 y1 z1 r1 g1 b1
x2 y2 z2 r2 g2 b1
...
...
```
Wenn Sie eine Textdatei für die Punktwolkenframedaten verwenden und keinen Wert für `format` eingeben, wird das Standardformat `text/xyzi` verwendet.
## Grenzwerte für Punktwolkenauflösung
Ground Truth hat keine Auflösungsbeschränkung für 3D-Punktwolkenframes. Es wird jedoch empfohlen, jeden Punktwolkenframe auf 500.000 Punkte zu begrenzen, um eine optimale Leistung zu erzielen. Wenn Ground Truth die 3D-Punktwolkenvisualisierung rendert, muss sie auf den Computern Ihrer Auftragnehmer angezeigt werden können, was von der Computerhardware der Auftragnehmer abhängt. Punktwolkenframes, die größer als 1 Million Punkte sind, werden möglicherweise nicht auf Standardcomputern gerendert oder es dauert zu lange, bis sie geladen werden.
# Eingabemanifestdateien für 3D-Punktwolken-Kennzeichnungsaufträge
Wenn Sie einen Kennzeichnungsauftrag erstellen, stellen Sie eine Eingabemanifestdatei bereit, in der jede Zeile des Manifests eine Aufgabeneinheit beschreibt, die von Erstellern von Anmerkungen abgeschlossen werden soll. Das Format der Eingabemanifestdatei hängt von Ihrem Aufgabentyp ab.
+ Wenn Sie einen Kennzeichnungsauftrag der 3D-Punktwolken-**Objekterkennung** oder **semantischen Segmentierung** erstellen, enthält jede Zeile in Ihrer Eingabemanifestdatei Informationen über einen einzelnen 3D-Punktwolkenframe. Dies wird als *Punktwolkenframe-Eingabemanifest* bezeichnet. Weitere Informationen hierzu finden Sie unter [Erstellen einer Punktwolkenframe-Eingabemanifestdatei](sms-point-cloud-single-frame-input-data.md).
+ Wenn Sie einen Kennzeichnungsauftrag der 3D-Punktwolken-**Objektverfolgung** erstellen, enthält jede Zeile Ihrer Eingabemanifestdatei eine Sequenz von 3D-Punktwolkenframes und zugehörigen Daten. Dies wird als *Punktwolkensequenz-Eingabemanifest* bezeichnet. Weitere Informationen hierzu finden Sie unter [Erstellen eines Eingabemanifests für Punktwolkensequenzen](sms-point-cloud-multi-frame-input-data.md).
# Erstellen einer Punktwolkenframe-Eingabemanifestdatei
Das Manifest ist eine UTF-8-kodierte Datei, in der jede Zeile ein vollständiges und gültiges JSON-Objekt ist. Jede Zeile wird durch einen Standardzeilenumbruch getrennt, \$1n oder \$1r\$1n. Da jede Zeile ein gültiges JSON-Objekt sein muss, sind Zeilenumbruchzeichen, die nicht durch Escape-Zeichen geschützt sind, nicht zulässig. In der Einzelframe-Eingabemanifestdatei enthält jede Zeile im Manifest Daten für einen einzelnen Punktwolkenframe. Die Punktwolkenframedaten können entweder im Binär- oder ASCII-Format gespeichert werden (siehe [Akzeptierte 3D-Rohdatenformate](sms-point-cloud-raw-data-types.md)). Dies ist die Manifestdateiformatierung, die für die 3D-Punktwolken-Objekterkennung und die semantische Segmentierung erforderlich ist. Optional können Sie auch Kamerasensorfusionsdaten für jeden Punktwolkenframe bereitstellen.
Ground Truth unterstützt die Fusion von Punktwolken- und Videokamerasensoren im [Weltkoordinatensystem](sms-point-cloud-sensor-fusion-details.md#sms-point-cloud-world-coordinate-system) für alle Modalitäten. Wenn Sie Ihre extrinsische 3D-Sensor-Matrix erhalten können (wie eine extrinsische LiDAR-Matrix), empfehlen wir, 3D-Punktwolkenframes mithilfe der extrinsischen Matrix in das Weltkoordinatensystem umzuwandeln. Weitere Informationen finden Sie unter [Sensorfusion](sms-point-cloud-sensor-fusion-details.md#sms-point-cloud-sensor-fusion).
Wenn Sie jedoch keine Punktwolke im Weltkoordinatensystem erhalten können, können Sie Koordinaten im ursprünglichen Koordinatensystem angeben, in dem die Daten erfasst wurden. Wenn Sie Kameradaten für die Sensorfusion bereitstellen, wird empfohlen, dass Sie LiDAR-Sensor- und Kameraposen im Weltkoordinatensystem bereitstellen.
Zum Erstellen einer Einzelframe-Eingabemanifestdatei identifizieren Sie den Speicherort jedes Punktwolkenframes, den die Auftragnehmer mithilfe des Schlüssels `source-ref` beschriften sollen. Darüber hinaus müssen Sie den Schlüssel `source-ref-metadata` verwenden, um das Format des Datensatzes, einen Zeitstempel für diesen Frame und optional Sensorfusionsdaten und Videokamerabilder zu identifizieren.
Im folgenden Beispiel wird die Syntax veranschaulicht, die für eine Eingabemanifestdatei für einen Einzelframe-Punktwolken-Kennzeichnungsauftrag verwendet wird. Das Beispiel enthält zwei Punktwolkenframes. Einzelheiten zu den einzelnen Parametern finden Sie in der Tabelle nach diesem Beispiel.
**Wichtig**
Jede Zeile in Ihrer Eingabemanifestdatei muss im Format [JSON Lines](http://jsonlines.org/) sein. Der folgende Codeblock zeigt eine Eingabe-Manifestdatei mit zwei JSON-Objekten. Jedes JSON-Objekt wird verwendet, um auf einen einzelnen Punktwolkenrahmen zu verweisen und Details zu diesem bereitzustellen. Die JSON-Objekte wurden aus Gründen der besseren Lesbarkeit erweitert, aber Sie müssen jedes JSON-Objekt so minimieren, dass es in eine einzige Zeile passt, wenn Sie eine Eingabe-Manifestdatei erstellen. Ein Beispiel finden Sie unter diesem Codeblock.
```
{
"source-ref": "s3://amzn-s3-demo-bucket/examplefolder/frame1.bin",
"source-ref-metadata":{
"format": "binary/xyzi",
"unix-timestamp": 1566861644.759115,
"ego-vehicle-pose":{
"position": {
"x": -2.7161461413869947,
"y": 116.25822288149078,
"z": 1.8348751887989483
},
"heading": {
"qx": -0.02111296123795955,
"qy": -0.006495469416730261,
"qz": -0.008024565904865688,
"qw": 0.9997181192298087
}
},
"prefix": "s3://amzn-s3-demo-bucket/lidar_singleframe_dataset/someprefix/",
"images": [
{
"image-path": "images/frame300.bin_camera0.jpg",
"unix-timestamp": 1566861644.759115,
"fx": 847.7962624528487,
"fy": 850.0340893791985,
"cx": 576.2129134707038,
"cy": 317.2423573573745,
"k1": 0,
"k2": 0,
"k3": 0,
"k4": 0,
"p1": 0,
"p2": 0,
"skew": 0,
"position": {
"x": -2.2722515189268138,
"y": 116.86003310568965,
"z": 1.454614668542299
},
"heading": {
"qx": 0.7594754093069037,
"qy": 0.02181790885672969,
"qz": -0.02461725233103356,
"qw": -0.6496916273040025
},
"camera-model": "pinhole"
}]
}
}
{
"source-ref": "s3://amzn-s3-demo-bucket/examplefolder/frame2.bin",
"source-ref-metadata":{
"format": "binary/xyzi",
"unix-timestamp": 1566861632.759133,
"ego-vehicle-pose":{
"position": {
"x": -2.7161461413869947,
"y": 116.25822288149078,
"z": 1.8348751887989483
},
"heading": {
"qx": -0.02111296123795955,
"qy": -0.006495469416730261,
"qz": -0.008024565904865688,
"qw": 0.9997181192298087
}
},
"prefix": "s3://amzn-s3-demo-bucket/lidar_singleframe_dataset/someprefix/",
"images": [
{
"image-path": "images/frame300.bin_camera0.jpg",
"unix-timestamp": 1566861644.759115,
"fx": 847.7962624528487,
"fy": 850.0340893791985,
"cx": 576.2129134707038,
"cy": 317.2423573573745,
"k1": 0,
"k2": 0,
"k3": 0,
"k4": 0,
"p1": 0,
"p2": 0,
"skew": 0,
"position": {
"x": -2.2722515189268138,
"y": 116.86003310568965,
"z": 1.454614668542299
},
"heading": {
"qx": 0.7594754093069037,
"qy": 0.02181790885672969,
"qz": -0.02461725233103356,
"qw": -0.6496916273040025
},
"camera-model": "pinhole"
}]
}
}
```
Wenn Sie eine Eingabemanifestdatei erstellen, müssen Sie Ihre JSON-Objekte so reduzieren, dass sie in eine einzige Zeile passen. Der obige Codeblock würde beispielsweise in einer Eingabemanifestdatei wie folgt aussehen:
```
{"source-ref":"s3://amzn-s3-demo-bucket/examplefolder/frame1.bin","source-ref-metadata":{"format":"binary/xyzi","unix-timestamp":1566861644.759115,"ego-vehicle-pose":{"position":{"x":-2.7161461413869947,"y":116.25822288149078,"z":1.8348751887989483},"heading":{"qx":-0.02111296123795955,"qy":-0.006495469416730261,"qz":-0.008024565904865688,"qw":0.9997181192298087}},"prefix":"s3://amzn-s3-demo-bucket/lidar_singleframe_dataset/someprefix/","images":[{"image-path":"images/frame300.bin_camera0.jpg","unix-timestamp":1566861644.759115,"fx":847.7962624528487,"fy":850.0340893791985,"cx":576.2129134707038,"cy":317.2423573573745,"k1":0,"k2":0,"k3":0,"k4":0,"p1":0,"p2":0,"skew":0,"position":{"x":-2.2722515189268138,"y":116.86003310568965,"z":1.454614668542299},"heading":{"qx":0.7594754093069037,"qy":0.02181790885672969,"qz":-0.02461725233103356,"qw":-0.6496916273040025},"camera-model":"pinhole"}]}}
{"source-ref":"s3://amzn-s3-demo-bucket/examplefolder/frame2.bin","source-ref-metadata":{"format":"binary/xyzi","unix-timestamp":1566861632.759133,"ego-vehicle-pose":{"position":{"x":-2.7161461413869947,"y":116.25822288149078,"z":1.8348751887989483},"heading":{"qx":-0.02111296123795955,"qy":-0.006495469416730261,"qz":-0.008024565904865688,"qw":0.9997181192298087}},"prefix":"s3://amzn-s3-demo-bucket/lidar_singleframe_dataset/someprefix/","images":[{"image-path":"images/frame300.bin_camera0.jpg","unix-timestamp":1566861644.759115,"fx":847.7962624528487,"fy":850.0340893791985,"cx":576.2129134707038,"cy":317.2423573573745,"k1":0,"k2":0,"k3":0,"k4":0,"p1":0,"p2":0,"skew":0,"position":{"x":-2.2722515189268138,"y":116.86003310568965,"z":1.454614668542299},"heading":{"qx":0.7594754093069037,"qy":0.02181790885672969,"qz":-0.02461725233103356,"qw":-0.6496916273040025},"camera-model":"pinhole"}]}}
```
Die folgende Tabelle zeigt die Parameter, die Sie in Ihre Eingabemanifestdatei aufnehmen können:
****
| Parameter | Erforderlich | Akzeptierte Werte | Description |
| --- | --- | --- | --- |
| `source-ref` | Ja | Zeichenfolge **Format für akzeptierte Zeichenfolgenwerte**: `s3:////point-cloud-frame-file` | Der Amazon S3-Speicherort eines einzelnen Punktwolken-Frames. |
| `source-ref-metadata` | Ja | JSON-Objekt **Akzeptierte Parameter**: `format`, `unix-timestamp`, `ego-vehicle-pose`, `position`, `prefix`, `images` | Verwenden Sie diesen Parameter, um zusätzliche Informationen über die Punktwolke in `source-ref` aufzunehmen und Kameradaten für die Sensorfusion bereitzustellen. |
| `format` | Nein | Zeichenfolge **Akzeptierte Zeichenfolgenwerte**: `"binary/xyz"`, `"binary/xyzi"`, `"binary/xyzrgb"`, `"binary/xyzirgb"`, `"text/xyz"`, `"text/xyzi"`, `"text/xyzrgb"`, `"text/xyzirgb"` **Standardwerte**: Wenn die in `source-ref` identifizierte Datei die Erweiterung .bin aufweist, `binary/xyzi` Wenn die in `source-ref` identifizierte Datei die Erweiterung .txt aufweist, `text/xyzi` | Verwenden Sie diesen Parameter, um das Format der Punktwolkendaten anzugeben. Weitere Informationen finden Sie unter [Akzeptierte 3D-Rohdatenformate](sms-point-cloud-raw-data-types.md). |
| `unix-timestamp` | Ja | Zahl Ein Unix-Zeitstempel. | Der Unix-Zeitstempel ist die Anzahl der Sekunden seit dem 1. Januar 1970 bis zum UTC-Zeitpunkt, zu dem die Daten von einem Sensor erfasst wurden. |
| `ego-vehicle-pose` | Nein | JSON-Objekt | Die Pose des Geräts, das zum Sammeln der Punktwolkendaten verwendet wird. Weitere Informationen zu diesem Parameter finden Sie unter [Aufnehmen von Fahrzeugposeninformationen in Ihr Eingabemanifest](#sms-point-cloud-single-frame-ego-vehicle-input). |
| `prefix` | Nein | Zeichenfolge **Format für akzeptierte Zeichenfolgenwerte**: `s3:////` | Der Speicherort in Amazon S3, an dem Ihre Metadaten, z. B. Kamerabilder, für dieses Frame gespeichert sind. Das Präfix muss mit einem Schrägstrich enden: `/`. |
| `images` | Nein | Auflisten | Eine Liste der Parameter, die Farbkamerabilder beschreiben, die für die Sensorfusion verwendet werden. Sie können bis zu 8 Bilder in diese Liste aufnehmen. Weitere Informationen zu den für jedes Bild erforderlichen Parametern finden Sie unter [Einschließen der Kameradaten in das Eingabemanifest](#sms-point-cloud-single-frame-image-input). |
## Aufnehmen von Fahrzeugposeninformationen in Ihr Eingabemanifest
Verwenden Sie den Standort des Ego-Fahrzeugs, um Informationen über den Standort des Fahrzeugs zu erhalten, die zur Erfassung der Punktwolkendaten verwendet werden. Ground Truth verwendet diese Informationen, um die extrinsische LiDAR-Matrix zu berechnen.
Ground Truth verwendet extrinsische Matrizen, um Beschriftungen auf und von der 3D-Szene und den 2D-Bildern zu projizieren. Weitere Informationen finden Sie unter [Sensorfusion](sms-point-cloud-sensor-fusion-details.md#sms-point-cloud-sensor-fusion).
In der folgenden Tabelle finden Sie weitere Informationen zu den Parametern `position` und Ausrichtung (`heading`), die erforderlich sind, wenn Sie Ego-Fahrzeuginformationen bereitstellen.
****
| Parameter | Erforderlich | Akzeptierte Werte | Description |
| --- | --- | --- | --- |
| `position` | Ja | JSON-Objekt **Erforderliche Parameter**: `x`, `y` und `z`. Geben Sie Zahlen für diese Parameter ein. | Der Translationsvektor des Ego-Fahrzeugs im Weltkoordinatensystem. |
| `heading` | Ja | JSON-Objekt **Erforderliche Parameter**: `qx`, `qy`, `qz` und `qw`. Geben Sie Zahlen für diese Parameter ein. | Die Ausrichtung des Bezugsrahmens des auf dem Fahrzeug montierten Geräts oder Sensors, das bzw. der die Umgebung erfasst, gemessen in [Quaternionen](https://en.wikipedia.org/wiki/Quaternion), (`qx`, `qy`, `qz`, `qw`), im Koordinatensystem. |
## Einschließen der Kameradaten in das Eingabemanifest
Wenn Sie Videokameradaten in einen Frame einschließen möchten, verwenden Sie die folgenden Parameter, um Informationen zu jedem Bild bereitzustellen. Die Spalte **Erforderlich** unten gilt, wenn der Parameter `images` in der Eingabemanifestdatei unter `source-ref-metadata` enthalten ist. Sie müssen keine Bilder in Ihre Eingabemanifestdatei aufnehmen.
Wenn Sie Kamerabilder einschließen, müssen Sie Informationen über `position` und `heading` der Kamera einschließen, die zum Erfassen der Bilder im Weltkoordinatensystem verwendet werden.
Wenn Ihre Bilder verzerrt sind, kann Ground Truth sie automatisch entzerren, indem es Informationen verwendet, die Sie über das Bild in Ihrer manifesten Eingabedatei bereitstellen, einschließlich der Verzerrungskoeffizienten (`k1`, `k2`, `k3`, `k4`, `p1`, `p1`), des Kameramodells und der kameraintrinsischen Matrix. Die intrinsische Matrix besteht aus Brennweite (`fx`, `fy`) und dem Hauptpunkt (`cx`, `cy)`). Weitere Informationen dazu, wie Ground Truth die intrinsische Matrix der Kamera verwendet, finden Sie unter [Intrinsische Matrix](sms-point-cloud-sensor-fusion-details.md#sms-point-cloud-intrinsic). Wenn keine Verzeichnungskoeffizienten enthalten sind, wird ein Bild durch Ground Truth nicht unverzerrt.
****
| Parameter | Erforderlich | Akzeptierte Werte | Description |
| --- | --- | --- | --- |
| `image-path` | Ja | Zeichenfolge **Beispiel für Format**: `/` | Der relative Speicherort Ihrer Bilddatei in Amazon S3. Dieser relative Pfad wird an den Pfad angehängt, den Sie in `prefix` angeben. |
| `unix-timestamp` | Ja | Zahl | Der Unix-Zeitstempel ist die Anzahl der Sekunden seit dem 1. Januar 1970 bis zum UTC-Zeitpunkt, zu dem die Daten von einer Kamera erfasst wurden. |
| `camera-model` | Nein | Zeichenfolge: **Akzeptierte Werte**: `"pinhole"`, `"fisheye"` **Standard:** `"pinhole"` | Das Modell der Kamera, mit der das Bild erfasst wird. Diese Informationen werden verwendet, um Kamerabilder zu entzerren. |
| `fx, fy` | Ja | Zahlen | Die Brennweite der Kamera in x (`fx`)- und y (`fy`)-Richtungen. |
| `cx, cy` | Ja | Zahlen | Die x (`cx`)- und y (`cy`)-Koordinaten des Hauptpunkts. |
| `k1, k2, k3, k4` | Nein | Zahl | Radiale Verzeichnungskoeffizienten. Unterstützt sowohl für **Fischaugen-** als auch **Lochkameramodelle**. |
| `p1, p2` | Nein | Zahl | Tangentiale Verzeichnungskoeffizienten. Unterstützt für **Lochkameramodelle**. |
| `skew` | Nein | Zahl | Ein Parameter, um die Neigung eines Bildes zu messen. |
| `position` | Ja | JSON-Objekt **Erforderliche Parameter**: `x`, `y` und `z`. Geben Sie Zahlen für diese Parameter ein. | Die Position oder der Ursprung des Bezugsrahmens der Kamera, die auf dem Fahrzeug montiert ist und Bilder erfasst. |
| `heading` | Ja | JSON-Objekt **Erforderliche Parameter**: `qx`, `qy`, `qz` und `qw`. Geben Sie Zahlen für diese Parameter ein. | Die Ausrichtung des Bezugsrahmens der auf dem Fahrzeug montierten Kamera, die Bilder erfasst, gemessen mit [Quaternionen](https://en.wikipedia.org/wiki/Quaternion), (`qx`, `qy`, `qz`, `qw`), im Weltkoordinatensystem. |
## Grenzwerte für Punktwolkenframes
Sie können bis zu 100.000 Punktwolkenframes in Ihre Eingabemanifestdatei aufnehmen. 3D-Punktwolken-Labeling-Aufgaben haben längere Vorverarbeitungszeiten als andere Ground Truth-Aufgaben. Weitere Informationen finden Sie unter [Vorverarbeitungszeit der Jobs](sms-point-cloud-general-information.md#sms-point-cloud-job-creation-time).
# Erstellen eines Eingabemanifests für Punktwolkensequenzen
Das Manifest ist eine UTF-8-kodierte Datei, in der jede Zeile ein vollständiges und gültiges JSON-Objekt ist. Jede Zeile wird durch einen Standardzeilenumbruch getrennt, \$1n oder \$1r\$1n. Da jede Zeile ein gültiges JSON-Objekt sein muss, sind Zeilenumbruchzeichen, die nicht durch Escape-Zeichen geschützt sind, nicht zulässig. In der Eingabemanifestdatei der Punktwolkensequenz enthält jede Zeile im Manifest eine Sequenz von Punktwolkenframes. Die Punktwolkendaten für jeden Frame in der Sequenz können entweder im binären oder im ASCII-Format gespeichert werden. Weitere Informationen finden Sie unter [Akzeptierte 3D-Rohdatenformate](sms-point-cloud-raw-data-types.md). Dies ist die Manifestdateiformatierung, die für die 3D-Punktwolken-Objektverfolgung erforderlich ist. Optional können Sie auch Punktattribut- und Kamerasensorfusionsdaten für jeden Punktwolkenframe bereitstellen. Wenn Sie eine Sequenz-Eingabemanifestdatei erstellen, müssen Sie LiDAR- und Videokamera-Sensorfusionsdaten in einem [Weltkoordinatensystem](sms-point-cloud-sensor-fusion-details.md#sms-point-cloud-world-coordinate-system) bereitstellen.
Das folgende Beispiel veranschaulicht die Syntax, die für eine Eingabemanifestdatei verwendet wird, wenn jede Zeile im Manifest eine Sequenzdatei ist. Jede Zeile in Ihrer Eingabemanifestdatei muss im Format [JSON Lines](http://jsonlines.org/) sein.
```
{"source-ref": "s3://amzn-s3-demo-bucket/example-folder/seq1.json"}
{"source-ref": "s3://amzn-s3-demo-bucket/example-folder/seq2.json"}
```
Die Daten für jede Sequenz von Punktwolkenframes müssen in einem JSON-Datenobjekt gespeichert werden. Im Folgenden finden Sie ein Beispiel für das Format, das Sie für eine Sequenzdatei verwenden. Informationen zu jedem Frame sind als JSON-Objekt enthalten und werden in der `frames`-Liste aufgeführt. Dies ist ein Beispiel für eine Sequenzdatei mit zwei Punktwolken-Frame-Dateien, `frame300.bin` und `frame303.bin`. Das *...* wird verwendet, um anzugeben, wo Sie Informationen für zusätzliche Frames einfügen sollten. Fügen Sie für jeden Frame in der Sequenz ein JSON-Objekt hinzu.
Der folgende Codeblock enthält ein JSON-Objekt für eine einzelne Sequenzdatei. Das JSON-Objekt wurde aus Gründen der Lesbarkeit erweitert.
```
{
"seq-no": 1,
"prefix": "s3://amzn-s3-demo-bucket/example_lidar_sequence_dataset/seq1/",
"number-of-frames": 100,
"frames":[
{
"frame-no": 300,
"unix-timestamp": 1566861644.759115,
"frame": "example_lidar_frames/frame300.bin",
"format": "binary/xyzi",
"ego-vehicle-pose":{
"position": {
"x": -2.7161461413869947,
"y": 116.25822288149078,
"z": 1.8348751887989483
},
"heading": {
"qx": -0.02111296123795955,
"qy": -0.006495469416730261,
"qz": -0.008024565904865688,
"qw": 0.9997181192298087
}
},
"images": [
{
"image-path": "example_images/frame300.bin_camera0.jpg",
"unix-timestamp": 1566861644.759115,
"fx": 847.7962624528487,
"fy": 850.0340893791985,
"cx": 576.2129134707038,
"cy": 317.2423573573745,
"k1": 0,
"k2": 0,
"k3": 0,
"k4": 0,
"p1": 0,
"p2": 0,
"skew": 0,
"position": {
"x": -2.2722515189268138,
"y": 116.86003310568965,
"z": 1.454614668542299
},
"heading": {
"qx": 0.7594754093069037,
"qy": 0.02181790885672969,
"qz": -0.02461725233103356,
"qw": -0.6496916273040025
},
"camera-model": "pinhole"
}]
},
{
"frame-no": 303,
"unix-timestamp": 1566861644.759115,
"frame": "example_lidar_frames/frame303.bin",
"format": "text/xyzi",
"ego-vehicle-pose":{...},
"images":[{...}]
},
...
]
}
```
Die folgende Tabelle enthält Einzelheiten zu den Parametern der obersten Ebene einer Sequenzdatei. Ausführliche Informationen zu den Parametern, die für einzelne Frames in der Sequenzdatei erforderlich sind, finden Sie unter [Parameter für einzelne Punktwolkenframes](#sms-point-cloud-multi-frame-input-single-frame).
****
| Parameter | Erforderlich | Akzeptierte Werte | Description |
| --- | --- | --- | --- |
| `seq-no` | Ja | Ganzzahl | Die geordnete Nummer der Sequenz. |
| `prefix` | Ja | Zeichenfolge **Akzeptierte Werte**: `s3:////` | Der Amazon S3-Speicherort, an dem sich die Sequenzdateien befinden. Das Präfix muss mit einem Schrägstrich enden: `/`. |
| `number-of-frames` | Ja | Ganzzahl | Die Gesamtzahl der Frames, die in der Sequenzdatei enthalten sind. Diese Zahl muss mit der Gesamtzahl der Frames übereinstimmen, die im Parameter `frames` in der nächsten Zeile aufgeführt sind. |
| `frames` | Ja | Liste der JSON-Objekte | Eine Liste der Framedaten. Die Länge der Liste muss gleich `number-of-frames` sein. In der Benutzeroberfläche für Auftragnehmer sind Frames in einer Sequenz identisch mit der Reihenfolge der Frames in diesem Array. Weitere Informationen zum Format der einzelnen Frames finden Sie unter [Parameter für einzelne Punktwolkenframes](#sms-point-cloud-multi-frame-input-single-frame). |
## Parameter für einzelne Punktwolkenframes
Die folgende Tabelle zeigt die Parameter, die Sie in die Eingabemanifestdatei aufnehmen können.
****
| Parameter | Erforderlich | Akzeptierte Werte | Description |
| --- | --- | --- | --- |
| `frame-no` | Nein | Ganzzahl | Eine Framenummer. Dies ist eine optionale Kennung, die vom Kunden angegeben wird, um den Frame innerhalb einer Sequenz zu identifizieren. Diese wird von Ground Truth nicht verwendet. |
| `unix-timestamp` | Ja | Zahl | Der Unix-Zeitstempel ist die Anzahl der Sekunden seit dem 1. Januar 1970 bis zum UTC-Zeitpunkt, zu dem die Daten von einem Sensor erfasst wurden. Der Zeitstempel für jeden Frame muss unterschiedlich sein und die Zeitstempel müssen sequentiell sein, da sie für die quaderförmige Interpolation verwendet werden. Idealerweise sollte dies der tatsächliche Zeitstempel sein, zu dem die Daten erfasst wurden. Wenn dies nicht verfügbar ist, müssen Sie eine inkrementelle Sequenz von Zeitstempeln verwenden, wobei der erste Frame in Ihrer Sequenzdatei dem ersten Zeitstempel in der Sequenz entspricht. |
| `frame` | Ja | Zeichenfolge **Beispiel für Format** `/` | Der relative Speicherort Ihrer Sequenzdatei in Amazon S3. Dieser relative Pfad wird an den Pfad angehängt, den Sie in `prefix` angeben. |
| `format` | Nein | Zeichenfolge **Akzeptierte Zeichenfolgenwerte**: `"binary/xyz"`, `"binary/xyzi"`, `"binary/xyzrgb"`, `"binary/xyzirgb"`, `"text/xyz"`, `"text/xyzi"`, `"text/xyzrgb"`, `"text/xyzirgb"` **Standardwerte**: Wenn die in `source-ref` identifizierte Datei die Erweiterung .bin aufweist, `binary/xyzi` Wenn die in `source-ref` identifizierte Datei die Erweiterung .txt aufweist, `text/xyzi` | Verwenden Sie diesen Parameter, um das Format der Punktwolkendaten anzugeben. Weitere Informationen finden Sie unter [Akzeptierte 3D-Rohdatenformate](sms-point-cloud-raw-data-types.md). |
| `ego-vehicle-pose` | Nein | JSON-Objekt | Die Pose des Geräts, das zum Sammeln der Punktwolkendaten verwendet wird. Weitere Informationen zu diesem Parameter finden Sie unter [Aufnehmen von Fahrzeugposeninformationen in Ihr Eingabemanifest](#sms-point-cloud-multi-frame-ego-vehicle-input). |
| `prefix` | Nein | Zeichenfolge **Format für akzeptierte Zeichenfolgenwerte**: `s3:////` | Der Speicherort in Amazon S3, an dem Ihre Metadaten, z. B. Kamerabilder, für dieses Frame gespeichert sind. Das Präfix muss mit einem Schrägstrich enden: `/`. |
| `images` | Nein | Auflisten | Eine Liste der Parameter, die Farbkamerabilder beschreiben, die für die Sensorfusion verwendet werden. Sie können bis zu 8 Bilder in diese Liste aufnehmen. Weitere Informationen zu den für jedes Bild erforderlichen Parametern finden Sie unter [Einschließen der Kameradaten in das Eingabemanifest](#sms-point-cloud-multi-frame-image-input). |
## Aufnehmen von Fahrzeugposeninformationen in Ihr Eingabemanifest
Verwenden Sie den Standort des Ego-Fahrzeugs, um Informationen über die Pose des Fahrzeugs zu erhalten, das zur Erfassung der Punktwolkendaten verwendet wird. Ground Truth verwendet diese Informationen, um extrinsische LiDAR-Matrizen zu berechnen.
Ground Truth verwendet extrinsische Matrizen, um Beschriftungen auf und von der 3D-Szene und den 2D-Bildern zu projizieren. Weitere Informationen finden Sie unter [Sensorfusion](sms-point-cloud-sensor-fusion-details.md#sms-point-cloud-sensor-fusion).
In der folgenden Tabelle finden Sie weitere Informationen zu den Parametern `position` und Ausrichtung (`heading`), die erforderlich sind, wenn Sie Ego-Fahrzeuginformationen bereitstellen.
****
| Parameter | Erforderlich | Akzeptierte Werte | Description |
| --- | --- | --- | --- |
| `position` | Ja | JSON-Objekt **Erforderliche Parameter**: `x`, `y` und `z`. Geben Sie Zahlen für diese Parameter ein. | Der Translationsvektor des Ego-Fahrzeugs im Weltkoordinatensystem. |
| `heading` | Ja | JSON-Objekt **Erforderliche Parameter**: `qx`, `qy`, `qz` und `qw`. Geben Sie Zahlen für diese Parameter ein. | Die Ausrichtung des Bezugsrahmens des auf dem Fahrzeug montierten Geräts oder Sensors, das bzw. der die Umgebung erfasst, gemessen in [Quaternionen](https://en.wikipedia.org/wiki/Quaternion), (`qx`, `qy`, `qz`, `qw`), im Koordinatensystem. |
## Einschließen der Kameradaten in das Eingabemanifest
Wenn Sie Farbkameradaten in einen Frame einschließen möchten, verwenden Sie die folgenden Parameter, um Informationen zu den einzelnen Bildern bereitzustellen. Die Spalte **Erforderlich** in der folgenden Tabelle gilt, wenn der Parameter `images` in der Eingabemanifestdatei enthalten ist. Sie müssen keine Bilder in Ihre Eingabemanifestdatei aufnehmen.
Wenn Sie Kamerabilder einschließen, müssen Sie Informationen über die `position` und Ausrichtung (`heading`) der Kamera angeben, die für die Erfassung der Bilder verwendet wurde.
Wenn Ihre Bilder verzerrt sind, kann Ground Truth sie automatisch entzerren, indem es Informationen verwendet, die Sie über das Bild in Ihrer manifesten Eingabedatei bereitstellen, einschließlich der Verzerrungskoeffizienten (`k1`, `k2`, `k3`, `k4`, `p1`, `p1`), des Kameramodells und der Brennweite (`fx`, `fy`), und des Hauptpunkts (`cx`, `cy)`. Weitere Informationen zu diesen Koeffizienten und dem Entzerren von Bildern finden Sie unter [Kamerakalibrierung mit OpenCV](https://docs.opencv.org/2.4.13.7/doc/tutorials/calib3d/camera_calibration/camera_calibration.html). Wenn keine Verzeichnungskoeffizienten enthalten sind, wird ein Bild durch Ground Truth nicht unverzerrt.
****
| Parameter | Erforderlich | Akzeptierte Werte | Description |
| --- | --- | --- | --- |
| `image-path` | Ja | Zeichenfolge **Beispiel für Format**: `/` | Der relative Speicherort Ihrer Bilddatei in Amazon S3. Dieser relative Pfad wird an den Pfad angehängt, den Sie in `prefix` angeben. |
| `unix-timestamp` | Ja | Zahl | Der Zeitstempel des Bildes. |
| `camera-model` | Nein | Zeichenfolge: **Akzeptierte Werte**: `"pinhole"`, `"fisheye"` **Standard:** `"pinhole"` | Das Modell der Kamera, mit der das Bild erfasst wird. Diese Informationen werden verwendet, um Kamerabilder zu entzerren. |
| `fx, fy` | Ja | Zahlen | Die Brennweite der Kamera in x (`fx`)- und y (`fy`)-Richtungen. |
| `cx, cy` | Ja | Zahlen | Die x (`cx`)- und y (`cy`)-Koordinaten des Hauptpunkts. |
| `k1, k2, k3, k4` | Nein | Zahl | Radiale Verzeichnungskoeffizienten. Unterstützt sowohl für **Fischaugen-** als auch **Lochkameramodelle**. |
| `p1, p2` | Nein | Zahl | Tangentiale Verzeichnungskoeffizienten. Unterstützt für **Lochkameramodelle**. |
| `skew` | Nein | Zahl | Ein Parameter, mit dem alle bekannten Neigungen im Bild gemessen werden können. |
| `position` | Ja | JSON-Objekt **Erforderliche Parameter**: `x`, `y` und `z`. Geben Sie Zahlen für diese Parameter ein. | Die Position oder der Ursprung des Bezugsrahmens der Kamera, die auf dem Fahrzeug montiert ist und Bilder erfasst. |
| `heading` | Ja | JSON-Objekt **Erforderliche Parameter**: `qx`, `qy`, `qz` und `qw`. Geben Sie Zahlen für diese Parameter ein. | Die Ausrichtung des Bezugsrahmens der auf dem Fahrzeug montierten Kamera, die Bilder erfasst, gemessen mit [Quaternionen](https://en.wikipedia.org/wiki/Quaternion), (`qx`, `qy`, `qz`, `qw`). |
## Grenzwerte für Sequenzdateien und Punktwolkenframes
Sie können bis zu 100.000 Punktwolkenframesequenzen in Ihre Eingabemanifestdatei aufnehmen. Sie können bis zu 500 Punktwolkenframes in jede Sequenzdatei aufnehmen.
Beachten Sie, dass 3D-Punktwolken-Beschriftungsaufträge längere Vorverarbeitungszeiten haben als andere Ground Truth-Aufgabentypen. Weitere Informationen finden Sie unter [Vorverarbeitungszeit der Jobs](sms-point-cloud-general-information.md#sms-point-cloud-job-creation-time).
# Grundlegendes zu Koordinatensystemen und Sensorfusion
Punktwolkendaten befinden sich immer in einem Koordinatensystem. Dieses Koordinatensystem kann für das Fahrzeug oder Gerät, das die Umgebung erkennt, lokal sein oder es kann sich um ein Weltkoordinatensystem handeln. Bei der Verwendung von Ground-Truth-3D-Punktwolkenbeschriftungsaufträgen werden alle Anmerkungen unter Verwendung des Koordinatensystems Ihrer Eingabedaten erstellt. Bei einigen Aufgabentypen und Funktionen der Kennzeichnungsaufträge müssen Sie Daten in einem Weltkoordinatensystem bereitstellen.
In diesem Thema erfahren Sie Folgendes:
+ Wenn Sie Eingabedaten in einem Weltkoordinatensystem oder einem globalen Referenzrahmen *angeben müssen*.
+ Was eine Weltkoordinate ist und wie Sie Punktwolkendaten in ein Weltkoordinatensystem konvertieren können.
+ Wie Sie Ihre extrinsischen Sensor- und Kameramatrizen verwenden können, um Posendaten bereitzustellen, wenn Sie die Sensorfusion verwenden.
## Koordinatensystemanforderungen für Kennzeichnungsaufträge
Wenn Ihre Punktwolkendaten in einem lokalen Koordinatensystem erfasst wurden, können Sie eine extrinsische Matrix des Sensors verwenden, der zum Sammeln der Daten verwendet wird, um sie in ein Weltkoordinatensystem oder globalen Referenzrahmen zu konvertieren. Wenn Sie keine extrinsische Matrix für Ihre Punktwolkendaten erhalten können und daher keine Punktwolken in einem Weltkoordinatensystem abrufen können, können Sie Punktwolkendaten in einem lokalen Koordinatensystem für Aufgabentypen der 3D-Punktwolkenobjekterkennung und semantischen Segmentierung bereitstellen.
Für die Objektverfolgung müssen Sie Punktwolkendaten in einem Weltkoordinatensystem bereitstellen. Dies liegt daran, dass, wenn Sie Objekte über mehrere Frames verfolgen, sich das Ego-Fahrzeug selbst in der Welt bewegt und daher alle Frames einen Bezugspunkt benötigen.
Wenn Sie Kameradaten für die Sensorfusion einschließen, empfiehlt es sich, Kameraposen im selben Weltkoordinatensystem wie der 3D-Sensor (z. B. ein LiDAR-Sensor) bereitzustellen.
## Verwenden von Punktwolkendaten in einem Weltkoordinatensystem
In diesem Abschnitt wird erläutert, was ein Weltkoordinatensystem (WKS), auch als *globaler Referenzrahmen* bezeichnet, ist, und erläutert, wie Sie Punktwolkendaten in einem Weltkoordinatensystem bereitstellen können.
### Was ist ein Weltkoordinatensystem?
Ein WKS oder globaler Referenzrahmen ist ein festes universelles Koordinatensystem, in dem Fahrzeug- und Sensorkoordinatensysteme platziert werden. Wenn sich beispielsweise mehrere Punktwolkenframes in verschiedenen Koordinatensystemen befinden, weil sie von zwei Sensoren erfasst wurden, kann ein WKS verwendet werden, um alle Koordinaten in diesen Punktwolkenframes in ein einzelnes Koordinatensystem zu verschieben, wobei alle Frames denselben Ursprung haben (0,0,0). Diese Transformation erfolgt, indem der Ursprung jedes Frames mit einem Translationsvektor in den Ursprung des WKS verschoben und die drei Achsen (typischerweise x, y und z) mithilfe einer Rotationsmatrix in die richtige Ausrichtung gedreht werden. Diese starre Körpertransformation wird als *homogene Transformation* bezeichnet.
Ein Weltkoordinatensystem ist wichtig für die globale Pfadplanung, Lokalisierung, Kartierung und Simulation von Fahrszenarien. Ground Truth verwendet das kartesische Weltkoordinatensystem für Rechtshänder, wie es in [ISO 8855](https://www.iso.org/standard/51180.html) definiert ist, bei dem die X-Achse nach vorne in Richtung der Fahrzeugbewegung verläuft, die Y-Achse nach links verläuft und die Z-Achse vom Boden nach oben zeigt.
Der globale Referenzrahmen hängt von den Daten ab. Einige Datensätze verwenden die LiDAR-Position im ersten Frame als Ursprung. In diesem Szenario verwenden alle Frames den ersten Frame als Referenz und der Fahrkurs und die Position des Geräts befinden sich in der Nähe des Ursprungs im ersten Frame. Beispielsweise haben KITTI-Datensätze den ersten Frame als Referenz für Weltkoordinaten. Andere Datensätze verwenden eine Geräteposition, die vom Ursprung abweicht.
Beachten Sie, dass dies nicht das GPS/IMU Koordinatensystem ist, das normalerweise um 90 Grad entlang der Z-Achse gedreht wird. Wenn sich Ihre Punktwolkendaten in einem GPS/IMU Koordinatensystem befinden (wie OxTS im Open-Source-AV KITTI-Datensatz), müssen Sie den Ursprung in ein Weltkoordinatensystem transformieren (normalerweise das Referenzkoordinatensystem des Fahrzeugs). Sie wenden diese Transformation an, indem Sie Ihre Daten mit Transformationsmetriken (Rotationsmatrix und Translationsvektor) multiplizieren. Dadurch werden die Daten vom ursprünglichen Koordinatensystem in ein globales Referenzkoordinatensystem transformiert. Weitere Informationen zu dieser Transformation finden Sie im nächsten Abschnitt.
### Konvertieren von 3D-Punktwolkendaten in ein WKS
Ground Truth geht davon aus, dass Ihre Punktwolkendaten bereits in ein Referenzkoordinatensystem Ihrer Wahl transformiert worden sind. Sie können beispielsweise das Referenzkoordinatensystem des Sensors (z. B. LiDAR) als globales Referenzkoordinatensystem auswählen. Sie können auch Punktwolken von verschiedenen Sensoren nehmen und sie von der Sensoransicht in die Referenzkoordinatensystemansicht des Fahrzeugs transformieren. Sie verwenden die extrinsische Matrix eines Sensors, bestehend aus einer Rotationsmatrix und einem Translationsvektor, um Ihre Punktwolkendaten in ein WKS oder einen globalen Referenzrahmen zu konvertieren.
Zusammenfassend können der Translationsvektor und die Rotationsmatrix verwendet werden, um eine *extrinsische Matrix* zu bilden, die verwendet werden kann, um Daten aus einem lokalen Koordinatensystem in ein WKS zu konvertieren. Beispielsweise kann Ihre extrinsische LiDAR-Matrix wie folgt zusammengesetzt werden, wobei `R` die Rotationsmatrix und `T` der Translationsvektor ist:
```
LiDAR_extrinsic = [R T;0 0 0 1]
```
Das KITTI-Datensatz für autonomes Fahren enthält beispielsweise eine Rotationsmatrix und einen Translationsvektor für die extrinsische LiDAR-Transformationsmatrix für jeden Frame. Das [pykitti](https://github.com/utiasSTARS/pykitti)-Python-Modul kann zum Laden der KITTI-Daten verwendet werden, und im Datensatz stellt `dataset.oxts[i].T_w_imu` die extrinsische LiDAR-Transformation für den `i`. Frame bereit und kann mit Punkten in diesem Frame multipliziert werden, um sie in ein festes Referenzsystem zu konvertieren – `np.matmul(lidar_transform_matrix, points)`. Wenn Sie einen Punkt im LiDAR-Frame mit einer extrinsischen LiDAR-Matrix multiplizieren, wird er in Weltkoordinaten umgewandelt. Wenn Sie einen Punkt im festen Referenzsystem mit der extrinsischen Matrix der Kamera multiplizieren, werden die Punktkoordinaten im Referenzrahmen der Kamera angezeigt.
Im folgenden Codebeispiel wird veranschaulicht, wie Sie Punktwolkenframes aus dem KITTI-Datensatz in ein WKS konvertieren können.
```
import pykitti
import numpy as np
basedir = '/Users/nameofuser/kitti-data'
date = '2011_09_26'
drive = '0079'
# The 'frames' argument is optional - default: None, which loads the whole dataset.
# Calibration, timestamps, and IMU data are read automatically.
# Camera and velodyne data are available via properties that create generators
# when accessed, or through getter methods that provide random access.
data = pykitti.raw(basedir, date, drive, frames=range(0, 50, 5))
# i is frame number
i = 0
# lidar extrinsic for the ith frame
lidar_extrinsic_matrix = data.oxts[i].T_w_imu
# velodyne raw point cloud in lidar scanners own coordinate system
points = data.get_velo(i)
# transform points from lidar to global frame using lidar_extrinsic_matrix
def generate_transformed_pcd_from_point_cloud(points, lidar_extrinsic_matrix):
tps = []
for point in points:
transformed_points = np.matmul(lidar_extrinsic_matrix, np.array([point[0], point[1], point[2], 1], dtype=np.float32).reshape(4,1)).tolist()
if len(point) > 3 and point[3] is not None:
tps.append([transformed_points[0][0], transformed_points[1][0], transformed_points[2][0], point[3]])
return tps
# customer transforms points from lidar to global frame using lidar_extrinsic_matrix
transformed_pcl = generate_transformed_pcd_from_point_cloud(points, lidar_extrinsic_matrix)
```
## Sensorfusion
Ground Truth unterstützt die Sensorfusion von Punktwolkendaten mit bis zu 8 Videokameraeingängen. Diese Funktion ermöglicht es menschlichen Kennzeichnern, das 3D-Punktwolkenbild side-by-side mit dem synchronisierten Videobild zu betrachten. Neben der Bereitstellung von mehr visuellem Kontext für die Beschriftung ermöglicht die Sensorfusion den Auftragnehmern, Anmerkungen in der 3D-Szene und in 2D-Bildern anzupassen, und die Anpassung wird in die andere Ansicht projiziert. Das folgende Video zeigt einen 3D-Punktwolken-Kennzeichnungsauftrag mit LiDAR und der Kamerasensorfusion.
![\[GIF, das einen 3D-Punktwolken-Kennzeichnungsauftrag mit LiDAR und der Kamerasensorfusion zeigt\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/pointcloud/gifs/object_tracking/sensor-fusion.gif)
Um optimale Ergebnisse zu erzielen, sollte sich Ihre Punktwolke bei Verwendung der Sensorfusion in einem WKS befinden. Ground Truth verwendet Ihren Sensor (wie LiDAR), Ihre Kamera und die Poseninformationen Ihres Ego-Fahrzeugs, um extrinsische und intrinsische Matrizen für die Sensorfusion zu berechnen.
### Extrinsische Matrix
Ground Truth verwendet die extrinsischen und intrinsischen Matrizen des Sensors (z. B. LiDAR) und der Kamera, um Objekte aus dem Referenzrahmen der Punktwolkendaten auf den Referenzrahmen der Kamera zu projizieren.
Um beispielsweise eine Beschriftung aus der 3D-Punktwolke auf die Kamerabildebene zu projizieren, transformiert Ground Truth die 3D-Punkte aus dem LiDAR-Koordinatensystem in das Koordinatensystem der Kamera. Dazu werden in der Regel zunächst 3D-Punkte mithilfe der extrinsischen LiDAR-Matrix aus dem eigenen LiDAR-Koordinatensystem in ein Weltkoordinatensystem (oder einen globalen Referenzrahmen) transformiert. Ground Truth verwendet dann die inverse extrinsische Kamera (die Punkte von einem globalen Referenzrahmen in den Referenzrahmen der Kamera umwandelt), um die 3D-Punkte aus dem Weltkoordinatensystem, die im vorherigen Schritt erhalten wurden, in die Kamerabildebene zu transformieren. Die extrinsische LiDAR-Matrix kann auch verwendet werden, um 3D-Daten in ein Weltkoordinatensystem zu transformieren. Wenn Ihre 3D-Daten bereits in ein Weltkoordinatensystem umgewandelt werden, hat die erste Transformation keine Auswirkungen auf die Beschriftungstranslation, und die Beschriftungstranslation hängt nur von der inversen extrinsischen Matrix der Kamera ab. Eine Ansichtsmatrix wird verwendet, um projizierte Beschriftungen zu visualisieren. Weitere Informationen zu diesen Transformationen und der Ansichtsmatrix finden Sie unter [Transformationen zur Fusion von Ground-Truth-Sensoren](#sms-point-cloud-extrinsic-intrinsic-explanation).
Ground Truth berechnet diese extrinsischen Matrizen anhand von LiDAR- und *Kamerapositionsdaten*, die Sie zur Verfügung stellen: `heading` ( in Quaternionen: `qx`, `qy`, `qz`, und `qw`) und `position` (`x`, `y`, `z`). Für das Fahrzeug werden normalerweise der Fahrkurs und die Position im Referenzrahmen des Fahrzeugs in einem Weltkoordinatensystem beschrieben und werden als *Ego-Fahrzeugpose* bezeichnet. Für jede extrinsische Matrix der Kamera können Sie Poseninformationen für diese Kamera hinzufügen. Weitere Informationen finden Sie unter [Pose](#sms-point-cloud-pose).
### Intrinsische Matrix
Ground Truth verwendet die extrinsischen und intrinsischen Matrizen der Kamera, um Ansichtsmetriken zu berechnen, um Beschriftungen von und zur 3D-Szene in Kamerabilder umzuwandeln. Ground Truth berechnet die kamerainterne Matrix anhand der von Ihnen angegebenen Kamerabrennweite (`fx`,`fy`) und der optischen Mittelpunktkoordinaten (`cx`,`cy`). Weitere Informationen finden Sie unter [Intrinsische Matrix und Verzeichnung](#sms-point-cloud-camera-intrinsic-distortion).
### Bildverzeichnung
Bildverzeichnungen können aus einer Vielzahl von Gründen auftreten. Beispielsweise können Bilder aufgrund von Tonnen- oder Fischaugeneffekten verzerrt sein. Ground Truth verwendet intrinsische Parameter zusammen mit einem Verzerrungskoeffizienten, um verzerrte Bilder zu korrigieren, die Sie bei der Erstellung von 3D-Punktwolken-Beschriftungsaufträgen bereitstellen. Wenn ein Kamerabild bereits unverzerrt ist, sollten alle Verzeichnungskoeffizienten auf 0 gesetzt werden.
Weitere Informationen zu den Transformationen, die Ground Truth durchführt, um Bilder zu entzerren, finden Sie unter [Kamerakalibrierungen: extrinsisch, intrinsisch und Verzeichnung](#sms-point-cloud-extrinsic-camera-explanation).
### Ego-Fahrzeug
Um Daten für autonome Fahranwendungen zu sammeln, werden die Messungen zur Generierung von Punktwolkendaten von Sensoren entnommen, die an einem Fahrzeug oder dem *Ego-Fahrzeug* montiert sind. Um Beschriftungsanpassungen auf die 3D-Szene und 2D-Bilder zu projizieren, benötigt Ground Truth die Ego-Fahrzeugpose in einem Weltkoordinatensystem. Die Ego-Fahrzeugpose besteht aus Positionskoordinaten und dem Ausrichtungsquaternion.
Ground Truth verwendet die Ego-Fahrzeugpose Ihres Fahrzeugs zur Berechnung von Rotations- und Transformationsmatrizen. Rotationen in 3 Dimensionen können durch eine Folge von 3 Rotationen um eine Folge von Achsen dargestellt werden. Theoretisch reichen drei Achsen aus, die sich über den dreidimensionalen euklidischen Raum erstrecken. In der Praxis werden die Rotationsachsen als Basisvektoren gewählt. Es wird erwartet, dass sich die drei Rotationen in einem globalen Referenzrahmen (extrinsisch) befinden. Ground Truth unterstützt kein körperzentriertes Referenzsystem (intrinsisch), das an dem Objekt befestigt ist und sich mit diesem bewegt, wenn es sich dreht. Um Objekte zu verfolgen, muss die Bodenwahrheit von einer globalen Referenz aus gemessen werden, in der sich alle Fahrzeuge bewegen. Bei der Verwendung von Ground-Truth-3D-Punktwolkenbeschriftungsaufträgen gibt z die Rotationsachse (extrinsische Rotation) und die Gier-Euler-Winkel in Radiant (Rotationswinkel) an.
### Pose
Ground Truth verwendet Pose-Informationen für 3D-Visualisierungen und Sensor-Fusion. Poseninformationen, die Sie über Ihre Manifestdatei eingeben, werden verwendet, um extrinsische Matrizen zu berechnen. Wenn Sie bereits über eine extrinsische Matrix verfügen, können Sie diese verwenden, um Sensor- und Kameraposendaten zu extrahieren.
Beispielsweise kann im KITTI-Datensatz für autonomes Fahren das [pykitti](https://github.com/utiasSTARS/pykitti)-Python-Modul zum Laden der KITTI-Daten verwendet werden. Im Datensatz stellt `dataset.oxts[i].T_w_imu` die extrinsische LiDAR-Transformation für den `i`. Frame bereit und kann mit den Punkten multipliziert werden, um sie in ein festes Referenzsystem einzufügen – `matmul(lidar_transform_matrix, points)`. Diese Transformation kann für das Eingabemanifestdatei-JSON-Format in LiDAR-Position (Translationsvektor) und -Fahrkurs (in Quaternion) umgewandelt werden. Die extrinsische Kameratransformation für `cam0` im `i`. Frame kann von `inv(matmul(dataset.calib.T_cam0_velo, inv(dataset.oxts[i].T_w_imu)))` berechnet werden und dies kann in Fahrkurs und Position für `cam0` umgewandelt werden.
```
import numpy
rotation = [[ 9.96714314e-01, -8.09890350e-02, 1.16333982e-03],
[ 8.09967396e-02, 9.96661051e-01, -1.03090934e-02],
[-3.24531964e-04, 1.03694477e-02, 9.99946183e-01]]
origin= [1.71104606e+00,
5.80000039e-01,
9.43144935e-01]
from scipy.spatial.transform import Rotation as R
# position is the origin
position = origin
r = R.from_matrix(np.asarray(rotation))
# heading in WCS using scipy
heading = r.as_quat()
print(f"pose:{position}\nheading: {heading}")
```
**Position**
`position` bezieht sich in der Eingabemanifestdatei auf die Position des Sensors in Bezug auf ein festes Referenzsystem. Wenn Sie die Geräteposition nicht in ein Weltkoordinatensystem einfügen können, können Sie LiDAR-Daten mit lokalen Koordinaten verwenden. Ebenso können Sie bei montierten Videokameras Position und Fahrkurs in einem Weltkoordinatensystem angeben. Wenn Sie für die Kamera keine Positionsinformationen haben, verwenden Sie bitte (0, 0, 0).
Im Folgenden sind die Felder im Positionsobjekt aufgeführt:
1. `x` (float) – x-Koordinate der Ego-Fahrzeug-, Sensor- oder Kameraposition in Metern.
1. `y` (float) – y-Koordinate der Ego-Fahrzeug-, Sensor- oder Kameraposition in Metern.
1. `z` (float) – z-Koordinate der Ego-Fahrzeug-, Sensor- oder Kameraposition in Metern.
Nachfolgend finden Sie ein Beispiel für ein `position`-JSON-Objekt:
```
{
"position": {
"y": -152.77584902657554,
"x": 311.21505956090624,
"z": -10.854137529636024
}
}
```
**Heading**
In der Eingabemanifestdatei ist `heading` ein Objekt, das die Ausrichtung eines Geräts in Bezug auf ein festes Referenzsystem darstellt. Fahrkurswerte sollten in Quaternion vorliegen. Ein [Quaternion](https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation) ist eine Darstellung der Ausrichtung, die mit geodätischen sphärischen Eigenschaften konsistent ist. Wenn Sie den Sensorfahrkurs nicht in die Weltkoordinaten einfügen können, verwenden Sie bitte das Identitätsquaternion `(qx = 0, qy = 0, qz = 0, qw = 1)`. In ähnlicher Weise geben Sie bei Kameras den Fahrkurs in Quaternionen an. Wenn Sie keine extrinsischen Kamerakalibrierungsparameter erhalten können, verwenden Sie bitte auch das Identitätsquaternion.
Felder im Objekt `heading` lauten wie folgt:
1. `qx` (Gleitkommazahl) – x-Komponente der Ego-Fahrzeug-, Sensor- oder Kameraausrichtung.
1. `qy` (Gleitkommazahl) – y-Komponente der Ego-Fahrzeug-, Sensor- oder Kameraausrichtung.
1. `qz` (Gleitkommazahl) – z-Komponente der Ego-Fahrzeug-, Sensor- oder Kameraausrichtung.
1. `qw` (Gleitkommazahl) – w-Komponente der Ego-Fahrzeug-, Sensor- oder Kameraausrichtung.
Nachfolgend finden Sie ein Beispiel für ein `heading`-JSON-Objekt:
```
{
"heading": {
"qy": -0.7046155108831117,
"qx": 0.034278837280808494,
"qz": 0.7070617895701465,
"qw": -0.04904659893885366
}
}
```
Weitere Informationen hierzu finden Sie unter [Berechnen von Ausrichtungsquaternionen und Position](#sms-point-cloud-ego-vehicle-orientation).
## Berechnen von Ausrichtungsquaternionen und Position
Die Ground Truth erfordert, dass alle Orientierungs- oder Kursdaten in Quaternionen angegeben werden. Bei [Quaternionen](https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation) handelt es sich um eine Darstellung der Ausrichtung, die mit geodätischen sphärischen Eigenschaften konsistent ist, die zur Annäherung der Rotation verwendet werden können. Im Vergleich zu [Euler-Winkeln](https://en.wikipedia.org/wiki/Euler_angles) sind sie einfacher zusammenzustellen und vermeiden das Problem der [Gimbal-Sperre](https://en.wikipedia.org/wiki/Gimbal_lock). Im Vergleich zu Rotationsmatrizen sind sie kompakter, numerisch stabiler und effizienter.
Sie können Quaternionen aus einer Rotationsmatrix oder einer Transformationsmatrix berechnen.
Wenn Sie eine Rotationsmatrix (bestehend aus den Achsenrotierungen) und einen Translationsvektor (oder Ursprung) im Weltkoordinatensystem anstelle einer einzelnen starren 4x4-Transformationsmatrix haben, können Sie direkt die Rotationsmatrix und den Translationsvektor verwenden, um Quaternionen zu berechnen. Bibliotheken wie [scipy](https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.transform.Rotation.html) und [pyqaternion](http://kieranwynn.github.io/pyquaternion/#explicitly-by-rotation-or-transformation-matrix) können helfen. Der folgende Codeblock zeigt ein Beispiel, in dem diese Bibliotheken verwendet werden, um Quaternionen aus einer Rotationsmatrix zu berechnen.
```
import numpy
rotation = [[ 9.96714314e-01, -8.09890350e-02, 1.16333982e-03],
[ 8.09967396e-02, 9.96661051e-01, -1.03090934e-02],
[-3.24531964e-04, 1.03694477e-02, 9.99946183e-01]]
origin = [1.71104606e+00,
5.80000039e-01,
9.43144935e-01]
from scipy.spatial.transform import Rotation as R
# position is the origin
position = origin
r = R.from_matrix(np.asarray(rotation))
# heading in WCS using scipy
heading = r.as_quat()
print(f"position:{position}\nheading: {heading}")
```
Ein Benutzeroberflächen-Tool wie [3D Rotation Converter](https://www.andre-gaschler.com/rotationconverter/) kann auch nützlich sein.
Wenn Sie eine extrinsische 4x4-Transformationsmatrix haben, beachten Sie, dass die Transformationsmatrix die Form `[R T; 0 0 0 1]` hat, wobei `R` die Rotationsmatrix und `T` der Translationsvektor des Ursprungs ist. Das bedeutet, dass Sie die Rotationsmatrix und den Translationsvektor wie folgt aus der Transformationsmatrix extrahieren können.
```
import numpy as np
transformation
= [[ 9.96714314e-01, -8.09890350e-02, 1.16333982e-03, 1.71104606e+00],
[ 8.09967396e-02, 9.96661051e-01, -1.03090934e-02, 5.80000039e-01],
[-3.24531964e-04, 1.03694477e-02, 9.99946183e-01, 9.43144935e-01],
[ 0, 0, 0, 1]]
transformation = np.array(transformation )
rotation = transformation[0:3,0:3]
translation= transformation[0:3,3]
from scipy.spatial.transform import Rotation as R
# position is the origin translation
position = translation
r = R.from_matrix(np.asarray(rotation))
# heading in WCS using scipy
heading = r.as_quat()
print(f"position:{position}\nheading: {heading}")
```
Mit Ihrem eigenen Setup können Sie eine extrinsische Transformationsmatrix anhand der GPS/IMU Position und Ausrichtung (Breitengrad, Längengrad, Höhe und Rollwinkel, Neigung, Gierneigung) in Bezug auf den LiDAR-Sensor am Ego-Fahrzeug berechnen. Sie können z. B. Posen aus KITTI-Rohdaten mithilfe von `pose = convertOxtsToPose(oxts)` berechnen, um die OxTS-Daten in lokale euklidische Posen umzuwandeln, die durch starre 4x4-Transformationsmatrizen angegeben werden. Anschließend können Sie diese Posentransformationsmatrix mithilfe der Referenzrahmen-Transformationsmatrix im Weltkoordinatensystem in einen globalen Referenzrahmen transformieren.
```
struct Quaternion
{
double w, x, y, z;
};
Quaternion ToQuaternion(double yaw, double pitch, double roll) // yaw (Z), pitch (Y), roll (X)
{
// Abbreviations for the various angular functions
double cy = cos(yaw * 0.5);
double sy = sin(yaw * 0.5);
double cp = cos(pitch * 0.5);
double sp = sin(pitch * 0.5);
double cr = cos(roll * 0.5);
double sr = sin(roll * 0.5);
Quaternion q;
q.w = cr * cp * cy + sr * sp * sy;
q.x = sr * cp * cy - cr * sp * sy;
q.y = cr * sp * cy + sr * cp * sy;
q.z = cr * cp * sy - sr * sp * cy;
return q;
}
```
## Transformationen zur Fusion von Ground-Truth-Sensoren
In den folgenden Abschnitten werden die Ground-Truth-Sensorfusionstransformationen, die anhand der von Ihnen bereitgestellten Pose-Daten durchgeführt werden, genauer erläutert.
### Extrinsische LiDAR-Matrix
Um zu und von einer 3D-LiDAR-Szene auf ein 2D-Kamerabild zu projizieren, berechnet Ground Truth die starren Transformationsprojektionsmetriken anhand der Pose und der Richtung des Ego-Fahrzeugs. Ground Truth berechnet die Rotation und Translation von Weltkoordinaten in die 3D-Ebene, indem eine einfache Abfolge von Rotationen und Translationen ausgeführt wird.
Ground Truth berechnet die Rotationsmetriken unter Verwendung der Kursquaternionen wie folgt:
![\[Gleichung: Metriken zur Rotation von Ground-Truth-Punktwolken\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/pointcloud/sms-point-cloud-rotation-matrix.png)
`[x, y, z, w]`Dies entspricht den Parametern im `heading` JSON-Objekt,. `[qx, qy, qz, qw]` Ground Truth berechnet den Übersetzungsspaltenvektor als`T = [poseX, poseY, poseZ]`. Dann sind die extrinsischen Metriken einfach wie folgt:
```
LiDAR_extrinsic = [R T;0 0 0 1]
```
### Kamerakalibrierungen: extrinsisch, intrinsisch und Verzeichnung
Die *geometrische Kamerakalibrierung*, auch als *Kamera-Resektionierung* bezeichnet, schätzt die Parameter eines Objektivs und eines Bildsensors einer Bild- oder Videokamera. Sie können diese Parameter verwenden, um Objektivverzeichnungen zu korrigieren, die Größe eines Objekts in Welteinheiten zu messen oder die Position der Kamera in der Szene zu bestimmen. Kameraparameter umfassen intrinsische Matrizen und Verzeichnungskoeffizienten.
#### Extrinsische Matrix der Kamera
Wenn die Kameraposition gegeben ist, berechnet Ground Truth die Kameraextrinsik auf der Grundlage einer starren Transformation von der 3D-Ebene in die Kameraebene. Die Berechnung ist die gleiche wie die für [Extrinsische LiDAR-Matrix](#sms-point-cloud-extrinsic-lidar-explanation), außer dass Ground Truth die Kamerapose (`position` und `heading`) verwendet und die inverse Extrinsik berechnet.
```
camera_inverse_extrinsic = inv([Rc Tc;0 0 0 1]) #where Rc and Tc are camera pose components
```
#### Intrinsische Matrix und Verzeichnung
Bei einigen Kameras, z. B. Lochkameras oder Fischaugenkameras, kann es zu erheblichen Verzerrungen bei Fotos kommen. Diese Verzerrung kann mithilfe von Verzerrungskoeffizienten und der Brennweite der Kamera korrigiert werden. Weitere Informationen finden Sie unter [Kamerakalibrierung mit OpenCV](https://docs.opencv.org/2.4.13.7/doc/tutorials/calib3d/camera_calibration/camera_calibration.html) in der OpenCV-Dokumentation.
Es gibt zwei Arten von Verzerrungen, die Ground Truth korrigieren kann: radiale Verzerrung und tangentiale Verzerrung.
*Radiale Verzeichnung* tritt auf, wenn Lichtstrahlen sich mehr in der Nähe der Kanten einer Linse biegen als in ihrer optischen Mitte. Je kleiner das Objektiv, desto größer die Verzeichnung. Das Vorhandensein der radialen Verzerrung manifestiert sich in Form des *Tonnen*- oder *Fischaugen*-effekts, und Ground Truth verwendet die Formel 1, um ihn zu entzerren.
**Formel 1:**
![\[Formel 1: Gleichungen für x_{korrigiert} und y_{korrigiert}, um radiale Verzerrungen rückgängig zu machen\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/pointcloud/sms-point-cloud-camera-distortion-1.png)
Die *tangentiale Verzerrung* entsteht, weil die Objektive, mit denen die Bilder aufgenommen werden, nicht perfekt parallel zur Bildebene liegen. Dies kann mit der Formel 2 korrigiert werden.
**Formel 2:**
![\[Formel 2: Gleichungen für x_{korrigiert} und y_{korrigiert}, um tangentiale Verzerrungen zu korrigieren\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/pointcloud/sms-point-cloud-camera-distortion-2.png)
In der manifesten Eingabedatei können Sie Verzeichnungskoeffizienten angeben, und die Ground Truth wird Ihre Bilder unverzerrt darstellen. Alle Verzeichnungskoeffizienten sind Gleitkommazahlen.
+ `k1`, `k2`, `k3`, `k4` – Radialer Verzeichnungskoeffizient. Unterstützt sowohl für Fischaugen- als auch Lochkameramodelle.
+ `p1` ,`p2` – Tangentiale Verzeichnungskoeffizienten. Unterstützt für Lochkameramodelle.
Wenn Bilder bereits unverzerrt sind, sollten alle Verzeichnungskoeffizienten in Ihrem Eingabemanifest 0 sein.
Um das korrigierte Bild korrekt zu rekonstruieren, führt Ground Truth eine Einheitenumrechnung der Bilder auf der Grundlage von Brennweiten durch. Wenn eine gemeinsame Brennweite mit einem bestimmten Seitenverhältnis für beide Achsen verwendet wird, z. B. 1, haben wir in der oberen Formel eine einzige Brennweite. Die Matrix, die diese vier Parameter enthält, wird als die *kamerainterne intrinsische Kalibrierungsmatrix* bezeichnet.
![\[Die kamerainterne intrinsische Kalibrierungsmatrix\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/pointcloud/sms-point-cloud-camera-intrinsic.png)
Obwohl die Verzeichnungskoeffizienten unabhängig von den verwendeten Kameraauflösungen gleich sind, sollten diese mit der aktuellen Auflösung aus der kalibrierten Auflösung skaliert werden.
Die folgenden Werte sind Gleitkommawerte.
+ `fx` – Brennweite in x-Richtung.
+ `fy` – Brennweite in y-Richtung.
+ `cx` – x-Koordinate des Hauptpunkts.
+ `cy` – y-Koordinate des Hauptpunkts.
Ground Truth verwendet die Kameraextrinsik und Kameraintrinsik zur Berechnung von Ansichtsmetriken, wie im folgenden Codeblock gezeigt, um Bezeichnungen zwischen der 3D-Szene und 2D-Bildern zu transformieren.
```
def generate_view_matrix(intrinsic_matrix, extrinsic_matrix):
intrinsic_matrix = np.c_[intrinsic_matrix, np.zeros(3)]
view_matrix = np.matmul(intrinsic_matrix, extrinsic_matrix)
view_matrix = np.insert(view_matrix, 2, np.array((0, 0, 0, 1)), 0)
return view_matrix
```