Schnellstart: Erstellen einer Azure Kinect Body Tracking-Anwendung

Erste Schritte mit dem Body Tracking SDK? Diese Schnellstartanleitung bringt Sie mit body tracking auf den Laufenden! Weitere Beispiele finden Sie in diesem Azure-Kinect-Sample-Repository.

Voraussetzungen

Überschriften

Die Körperverfolgung verwendet einen einzelnen Header k4abt.h. Fügen Sie diese Kopfzeile zusätzlich zu k4a.hhinzu. Stellen Sie sicher, dass Ihr Compiler für das Sensor SDK und das Body Tracking SDK sowie die Ordner lib und include eingerichtet ist. Außerdem müssen Sie eine Verknüpfung mit k4a.lib und k4abt.lib Dateien herstellen. Zum Ausführen der Anwendung müssen k4a.dll, k4abt.dll, onnxruntime.dllund dnn_model.onnx sich im Ausführungspfad der Anwendungen befinden.

#include <k4a/k4a.h>
#include <k4abt.h>

Öffnen des Geräts und Starten der Kamera

Ihre erste Body Tracking-Anwendung geht davon aus, dass ein einzelnes Azure Kinect-Gerät mit dem PC verbunden ist.

Body-Tracking baut auf dem Sensor-SDK auf. Um die Körperverfolgung zu verwenden, müssen Sie zuerst das Gerät öffnen und konfigurieren. Verwenden Sie die k4a_device_open()-Funktion, um das Gerät zu öffnen und es dann mit einem k4a_device_configuration_t-Objekt zu konfigurieren. Um optimale Ergebnisse zu erzielen, legen Sie den Tiefenmodus auf K4A_DEPTH_MODE_NFOV_UNBINNED oder K4A_DEPTH_MODE_WFOV_2X2BINNEDfest. Der Body-Tracker funktioniert nicht, wenn der Tiefenmodus auf K4A_DEPTH_MODE_OFF oder K4A_DEPTH_MODE_PASSIVE_IRfestgelegt ist.

Weitere Informationen zum Suchen und Öffnen des Geräts finden Sie auf dieser Seite.

Weitere Informationen zu Azure Kinect-Tiefenmodi finden Sie auf diesen Seiten: Hardwarespezifikation und k4a_depth_mode_t Enumerationen.

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

Der erste Schritt beim Abrufen von Body Tracking-Ergebnissen besteht darin, einen Body-Tracker zu erstellen. Sie benötigt die Struktur der Sensorkalibrierung k4a_calibration_t. Die Sensorkalibrierung kann mithilfe der k4a_device_get_calibration()-Funktion 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);

Die Erfassung einreihen und die Ergebnisse herausnehmen

Der Tracker verwaltet intern eine Eingabewarteschlange und eine Ausgabewarteschlange, um die Azure Kinect DK-Erfassungen effizienter zu verarbeiten. Der nächste Schritt besteht darin, die k4abt_tracker_enqueue_capture()-Funktion zu verwenden, um der Eingabewarteschlange eine neue Erfassung hinzuzufügen. Verwenden Sie die k4abt_tracker_pop_result()-Funktion, um ein Ergebnis aus der Ausgabewarteschlange zu entfernen. Der Timeoutwert hängt von der Anwendung ab und steuert die Wartezeit in der Warteschlange.

Ihre erste Body Tracking-Anwendung verwendet das Echtzeitverarbeitungsmuster. Weitere Informationen zu den anderen Mustern finden Sie unter Körper-Tracking-Ergebnisse abrufen.

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 Ergebnisdaten der Körperverfolgung

Die Ergebnisse des Körper-Trackings für jede Sensorerfassung werden in einer Körperrahmenstruktur k4abt_frame_t gespeichert. Jeder Körperrahmen enthält drei Hauptkomponenten: eine Sammlung von Körper-Strukturen, eine 2D-Body-Index-Zuordnung und die Erfassung der Eingaben.

Ihre erste Body Tracking-Anwendung greift nur auf die Anzahl der erkannten Körper zu. Ausführliche Erläuterungen zu Daten in einem Textrahmen finden Sie in Zugriffsdaten im Textrahmen.

size_t num_bodies = k4abt_frame_get_num_bodies(body_frame);
printf("%zu bodies are detected!\n", num_bodies);

Aufräumen

Der letzte Schritt besteht darin, den Body-Tracker herunterzufahren und das Body Tracking-Objekt freizugeben. Sie müssen das Gerät auch stoppen 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;
}

Nächste Schritte

Ergebnisse für die Körperverfolgung abrufen

  • Last updated on