Schnellstart: Erstellen einer Azure Kinect-Anwendung zum Body Tracking
Machen Sie Ihre ersten Schritte mit dem Body Tracking SDK? Mit dieser Schnellstartanleitung gehen Sie beim Body Tracking gut gerüstet an den Start! Weitere Beispiele finden Sie in diesem Azure-Kinect-Beispielrepository.
Voraussetzungen
- Schnellstart: Einrichten Ihres Azure Kinect DK-Geräts
- Einrichten des Body Tracking SDK
- Exemplarische Schnellstart-Vorgehensweise zum Erstellen Ihrer ersten Azure Kinect-Anwendung.
- Machen Sie sich mit den folgenden Sensor SDK-Funktionen vertraut:
- Lesen Sie die Dokumentation zu den folgenden Body Tracking SDK-Funktionen:
Header
Die Nachverfolgung von Körpern (Body Tracking) verwendet einen einzelnen Header, k4abt.h. Schließen Sie diesen Header zusätzlich zu k4a.h ein. Achten Sie darauf, dass der Compiler Ihrer Wahl für die Ordner lib und include sowohl des Sensor SDK als auch des Body Tracking SDK eingerichtet ist. Ferner müssen Sie eine Verknüpfung zu den Dateien k4a.lib und k4abt.lib herstellen. Zum Ausführen der Anwendung müssen sich k4a.dll, k4abt.dll, onnxruntime.dll und dnn_model.onnx im Ausführungspfad der Anwendung befinden.
#include <k4a/k4a.h>
#include <k4abt.h>
Öffnen des Geräts und Starten der Kamera
Für Ihre erste Anwendung zur Nachverfolgung von Körpern gehen wir von einem einzelnen Azure Kinect-Gerät aus, das mit dem PC verbunden ist.
Die Nachverfolgung von Körpern baut auf dem Sensor SDK auf. Um Body Tracking zu verwenden, müssen Sie das Gerät zunächst öffnen und konfigurieren. Verwenden Sie die Funktion k4a_device_open(), um das Gerät zu öffnen und es dann mit einem k4a_device_configuration_t-Objekt zu konfigurieren. Legen Sie für optimale Ergebnisse den Tiefenmodus auf K4A_DEPTH_MODE_NFOV_UNBINNED oder K4A_DEPTH_MODE_WFOV_2X2BINNED fest. Body Tracking kann nicht ausgeführt werden, wenn der Tiefenmodus auf K4A_DEPTH_MODE_OFF oder K4A_DEPTH_MODE_PASSIVE_IR festgelegt ist.
Weitere Informationen zum Auffinden und Öffnen des Geräts finden Sie auf dieser Seite.
Sie finden weitere Informationen zu den Tiefenmodi von Azure Kinect auf diesen Seiten: Hardwarespezifikation- und k4a_depth_mode_t-Enumeration.
k4a_device_t device = NULL;
k4a_device_open(0, &device);
// Start camera. Make sure depth camera is enabled.
k4a_device_configuration_t deviceConfig = K4A_DEVICE_CONFIG_INIT_DISABLE_ALL;
deviceConfig.depth_mode = K4A_DEPTH_MODE_NFOV_UNBINNED;
deviceConfig.color_resolution = K4A_COLOR_RESOLUTION_OFF;
k4a_device_start_cameras(device, &deviceConfig);
Erstellen der Nachverfolgung
Der erste Schritt zum Abrufen von Ergebnissen der Nachverfolgung von Körpern besteht im Erstellen eines Body Trackers (Modul zur Körpernachverfolgung). Dafür ist die Sensorkalibirierungs-Struktur k4a_calibration_t erforderlich. Die Sensorkalibrierung kann mithilfe der Funktion k4a_device_get_calibration() abgefragt werden.
k4a_calibration_t sensor_calibration;
k4a_device_get_calibration(device, deviceConfig.depth_mode, deviceConfig.color_resolution, &sensor_calibration);
k4abt_tracker_t tracker = NULL;
k4abt_tracker_configuration_t tracker_config = K4ABT_TRACKER_CONFIG_DEFAULT;
k4abt_tracker_create(&sensor_calibration, tracker_config, &tracker);
Abrufen von Aufzeichnungen vom Azure Kinect-Gerät
Weitere Informationen zum Abrufen von Bilddaten finden Sie auf dieser Seite.
// Capture a depth frame
k4a_capture_t sensor_capture;
k4a_device_get_capture(device, &sensor_capture, TIMEOUT_IN_MS);
Einstellen der Aufzeichnung in die Warteschlange und Abrufen der Ergebnisse
Die Nachverfolgung verwaltet intern eine Eingabewarteschlange und eine Ausgabewarteschlange, um die asynchrone Verarbeitung der Azure Kinect DK-Aufzeichnungen effizienter durchzuführen. Der nächste Schritt besteht im Verwenden der Funktion k4abt_tracker_enqueue_capture() zum Hinzufügen einer neuen Aufzeichnung zur Eingabewarteschlange. Verwenden Sie die Funktion k4abt_tracker_pop_result(), um ein Ergebnis aus der Ausgabewarteschlange abzurufen. Der Timeoutwert hängt von der Anwendung ab und steuert die Wartezeit in der Warteschlange.
Ihre erste Anwendung zur Nachverfolgung von Körpern verwendet die Echtzeit-Verarbeitungsplattform. Eine detaillierte Erläuterung der weiteren Muster finden Sie unter Abrufen der Body Tracking-Ergebnisse.
k4a_wait_result_t queue_capture_result = k4abt_tracker_enqueue_capture(tracker, sensor_capture, K4A_WAIT_INFINITE);
k4a_capture_release(sensor_capture); // Remember to release the sensor capture once you finish using it
if (queue_capture_result == K4A_WAIT_RESULT_FAILED)
{
printf("Error! Adding capture to tracker process queue failed!\n");
break;
}
k4abt_frame_t body_frame = NULL;
k4a_wait_result_t pop_frame_result = k4abt_tracker_pop_result(tracker, &body_frame, K4A_WAIT_INFINITE);
if (pop_frame_result == K4A_WAIT_RESULT_SUCCEEDED)
{
// Successfully popped the body tracking result. Start your processing
...
k4abt_frame_release(body_frame); // Remember to release the body frame once you finish using it
}
Zugriff auf die Body Tracking-Ergebnisdaten
Die Ergebnisse des Body Trackings für die einzelnen Sensoraufzeichnungen sind in einer Body Frame-Struktur k4abt_frame_t gespeichert. Jeder Body Frame enthält drei Hauptkomponenten: eine Sammlung von Körperstrukturen, eine 2D-Indexkarte und die Eingabeaufzeichnung.
Ihre erste Anwendung zum Nachverfolgen von Körpern greift nur auf die Anzahl der erkannten Körper zu. Eine detaillierte Erläuterung der Daten in einem Body-Frame finden Sie unter Zugreifen auf Daten im Body-Frame.
size_t num_bodies = k4abt_frame_get_num_bodies(body_frame);
printf("%zu bodies are detected!\n", num_bodies);
Bereinigung
Der letzte Schritt besteht im Herunterfahren des Body Trackings und im Freigeben des Body Tracking-Objekts. Außerdem müssen Sie das Gerät beenden und schließen.
k4abt_tracker_shutdown(tracker);
k4abt_tracker_destroy(tracker);
k4a_device_stop_cameras(device);
k4a_device_close(device);
Vollständige Quelle
#include <stdio.h>
#include <stdlib.h>
#include <k4a/k4a.h>
#include <k4abt.h>
#define VERIFY(result, error) \
if(result != K4A_RESULT_SUCCEEDED) \
{ \
printf("%s \n - (File: %s, Function: %s, Line: %d)\n", error, __FILE__, __FUNCTION__, __LINE__); \
exit(1); \
} \
int main()
{
k4a_device_t device = NULL;
VERIFY(k4a_device_open(0, &device), "Open K4A Device failed!");
// Start camera. Make sure depth camera is enabled.
k4a_device_configuration_t deviceConfig = K4A_DEVICE_CONFIG_INIT_DISABLE_ALL;
deviceConfig.depth_mode = K4A_DEPTH_MODE_NFOV_UNBINNED;
deviceConfig.color_resolution = K4A_COLOR_RESOLUTION_OFF;
VERIFY(k4a_device_start_cameras(device, &deviceConfig), "Start K4A cameras failed!");
k4a_calibration_t sensor_calibration;
VERIFY(k4a_device_get_calibration(device, deviceConfig.depth_mode, deviceConfig.color_resolution, &sensor_calibration),
"Get depth camera calibration failed!");
k4abt_tracker_t tracker = NULL;
k4abt_tracker_configuration_t tracker_config = K4ABT_TRACKER_CONFIG_DEFAULT;
VERIFY(k4abt_tracker_create(&sensor_calibration, tracker_config, &tracker), "Body tracker initialization failed!");
int frame_count = 0;
do
{
k4a_capture_t sensor_capture;
k4a_wait_result_t get_capture_result = k4a_device_get_capture(device, &sensor_capture, K4A_WAIT_INFINITE);
if (get_capture_result == K4A_WAIT_RESULT_SUCCEEDED)
{
frame_count++;
k4a_wait_result_t queue_capture_result = k4abt_tracker_enqueue_capture(tracker, sensor_capture, K4A_WAIT_INFINITE);
k4a_capture_release(sensor_capture); // Remember to release the sensor capture once you finish using it
if (queue_capture_result == K4A_WAIT_RESULT_TIMEOUT)
{
// It should never hit timeout when K4A_WAIT_INFINITE is set.
printf("Error! Add capture to tracker process queue timeout!\n");
break;
}
else if (queue_capture_result == K4A_WAIT_RESULT_FAILED)
{
printf("Error! Add capture to tracker process queue failed!\n");
break;
}
k4abt_frame_t body_frame = NULL;
k4a_wait_result_t pop_frame_result = k4abt_tracker_pop_result(tracker, &body_frame, K4A_WAIT_INFINITE);
if (pop_frame_result == K4A_WAIT_RESULT_SUCCEEDED)
{
// Successfully popped the body tracking result. Start your processing
size_t num_bodies = k4abt_frame_get_num_bodies(body_frame);
printf("%zu bodies are detected!\n", num_bodies);
k4abt_frame_release(body_frame); // Remember to release the body frame once you finish using it
}
else if (pop_frame_result == K4A_WAIT_RESULT_TIMEOUT)
{
// It should never hit timeout when K4A_WAIT_INFINITE is set.
printf("Error! Pop body frame result timeout!\n");
break;
}
else
{
printf("Pop body frame result failed!\n");
break;
}
}
else if (get_capture_result == K4A_WAIT_RESULT_TIMEOUT)
{
// It should never hit time out when K4A_WAIT_INFINITE is set.
printf("Error! Get depth frame time out!\n");
break;
}
else
{
printf("Get depth capture returned error: %d\n", get_capture_result);
break;
}
} while (frame_count < 100);
printf("Finished body tracking processing!\n");
k4abt_tracker_shutdown(tracker);
k4abt_tracker_destroy(tracker);
k4a_device_stop_cameras(device);
k4a_device_close(device);
return 0;
}