代码示例

如果您使用vs2013版本, 请下载适用于vs2013 的开发包，在samples/vs2013文件夹中可以找到astra-samples.sln。

如果您使用vs2015或以上版本，请下载适用于vs2015的开发包，在samples/vs2015文件夹中可以找到找到astra-samples.sln。

您还可以从CMakeLists.txt中生成astra-samples.sln。在此文件夹中，运行“cmake”，使用“ -G”设置Visual Studio版本，并使用“ -A”设置平台。

示例清单:

Name	Language	Description
Color Reader Poll	C	此示例演示了如何使用Astra SDK读取彩色流数据。
Depth Reader Poll	C	此示例演示了如何使用Astra SDK读取深度流数据。
Infrared Reader Poll	C	此示例演示了如何使用Astra SDK读取红外流数据。
Body Reader Poll	C	此示例演示了如何使用Astra SDK读取人体骨架和手部的流数据。
Color Reader Event	C	此示例演示了如何通过事件使用Astra SDK读取彩色流数据。
Depth Reader Event	C	此示例演示了如何通过事件使用Astra SDK读取深度流数据。
Infrared Reader Event	C	此示例演示了如何通过事件使用Astra SDK读取红外流数据。
Infrared Color Reader Event	C	此示例演示了如何通过事件使用Astra SDK读取红外和彩色流数据。
Color Reader Event CPP	C++	此示例演示了如何使用C ++通过事件使用Astra SDK读取彩色流数据。
Depth Reader Event CPP	C++	此示例演示了如何使用C ++通过事件使用Astra SDK读取深度流数据。
SimpleColorViewer-SFML	C++	此示例演示了如何使用SFML显示彩色流数据。
SimpleDepthViewer-SFML	C++	此示例演示了如何使用SFML显示深度流数据。
SimpleBodyViewer-SFML	C++	此示例演示了如何使用SFML显示人体骨架流数据。
SimpleStreamViewer-SFML	C++	此示例演示了如何使用SFML显示深度和彩色流数据。
ColorizedBodyViewer-SFML	C++	此示例演示了如何使用SFML显示分割后的人体深度流数据。
MaskedColorViewer-SFML	C++	此示例演示了如何使用SFML显示抠图处理后的人体彩色流数据。
MultiSensorViewer-SFML	C++	此示例演示了如何使用SFML显示多相机深度和彩色流数据。
RotatedBodyViewer-SFML	C++	此示例演示了如何使用SFML显示旋转的人体骨架流数据。
Color View	Java	此示例演示了如何在安卓平台上使用Astra SDK读取彩色流数据。
Depth View	Java	此示例演示了如何在安卓平台上使用Astra SDK读取深度流数据。
Colorized Body View(人体分割)	Java	此示例演示了如何在安卓平台上显示分割后的人体深度流数据。
Masked Color View(彩色抠图)	Java	此示例演示了如何在安卓平台上显示抠图处理后的人体彩色流数据。
Body View(骨架跟踪)	Java	此示例演示了如何在安卓平台上显示人体骨架流数据。

Color Reader

概述

此示例演示了如何使用Astra SDK读取彩色流。

预期输出

代码概述

我们提供了C/C++版的基于轮询和事件两种不同的方式来访问彩色流的示例，分别如下所示：你可以使用下述方法来执行此操作：

C

轮询方式

此示例演示了如何通过Astra SDK 轮询来读取色彩流。

首先，我们加入头文件。

#include <astra/capi/astra.h>

下一步，我们需初始化Astra SDK，打开相机并创建读取工具以读取彩色流。

//initialize astra sdk
astra_initialize();
 
astra_streamsetconnection_t sensor;
 
//open default sensor
astra_streamset_open("device/default", &sensor);
 
//create stream reader
astra_reader_t reader;
astra_reader_create(sensor, &reader);
 
//get color stream
astra_depthstream_t colorStream;
astra_reader_get_colorstream(reader, &colorStream);
 
//start color stream
astra_stream_start(colorStream);

现在，我们一起看如何获取彩色流数据帧

//wait a new frame
astra_update();
 
astra_reader_frame_t frame;
//get one frame of color stream
astra_status_t rc = astra_reader_open_frame(reader, 0, &frame);
//check result status
if (rc == ASTRA_STATUS_SUCCESS)
{
    astra_colorframe_t colorFrame;
    //get color frame
    astra_frame_get_colorframe(frame, &colorFrame);
 
    astra_frame_index_t newFrameIndex;
    //get frame index
    astra_colorframe_get_frameindex(colorFrame, &newFrameIndex);
 
    if (lastFrameIndex == newFrameIndex)
    {
        printf("duplicate frame index: %d\n", lastFrameIndex);
    }
    lastFrameIndex = newFrameIndex;
    //print color frame info
    print_color(colorFrame);
    //release frame
    astra_reader_close_frame(&frame);
}

最后，我们需要释放所有资源。

//destroy reader
astra_reader_destroy(&reader);
//close sensor
astra_streamset_close(&sensor);
//terminate astra sdk
astra_terminate();

事件方式

此示例演示了如何通过事件使用Astra SDK读取彩色流。

首先，我们加入头文件

#include <astra/capi/astra.h>

下一步，我们需初始化Astra SDK，打开相机并创建读取工具以读取彩色流。

//initialize astra sdk
astra_initialize();
 
astra_streamsetconnection_t sensor;
 
//open default sensor
astra_streamset_open("device/default", &sensor);
 
//create stream reader
astra_reader_t reader;
astra_reader_create(sensor, &reader);
 
//get color stream
astra_depthstream_t colorStream;
astra_reader_get_colorstream(reader, &colorStream);
 
//start color stream
astra_stream_start(colorStream);

设置回调函数以接收彩色帧

//register frame callback
astra_reader_callback_id_t callbackId;
astra_reader_register_frame_ready_callback(reader, &frame_ready, NULL, &callbackId);

调用更新

astra_update();

一旦我们不再需要接收帧，请注销回调

astra_reader_unregister_frame_ready_callback(&callbackId);

最后，释放所有资源。

//destroy reader
astra_reader_destroy(&reader);
//close sensor
astra_streamset_close(&sensor);
//terminate astra sdk
astra_terminate();

C++

事件方式

此示例演示了如何用C++通过事件方式使用Astra SDK读取彩色流。

首先，我们加入头文件

#include <astra/astra.hpp>

下一步，我们需初始化Astra SDK，打开相机并创建读取工具以读取彩色流

//initialize astra sdk
astra::initialize();
 
//create stream set and reader
astra::StreamSet streamSet;
astra::StreamReader reader = streamSet.create_reader();
 
//create listener and start color stream
SampleFrameListener listener;
reader.stream<astra::ColorStream>().start();
reader.add_listener(listener);

调用更新

astra_update();

一旦我们不在需要接受帧，请删除侦听器

reader.remove_listener(listener);

最后，释放所有资源。

//terminate astra sdk
astra::terminate();

Depth Reader

概述

此示例演示了如何使用Astra SDK读取深度流。

预期输出

代码概述

我们提供了C/C++版的基于轮询和事件两种不同的方式来访问深度流的示例，分别如下所示：

C

轮询方式

此示例演示了如何使用Astra SDK来轮询读取彩色流。

首先，我们加入头文件

#include <astra/capi/astra.h>

下一步，我们需初始化Astra SDK，打开相机并创建读取工具以读取深度流

//initialize astra sdk
astra_initialize();
 
astra_streamsetconnection_t sensor;
 
//open default sensor
astra_streamset_open("device/default", &sensor);
 
//create stream reader
astra_reader_t reader;
astra_reader_create(sensor, &reader);
 
//get depth stream
astra_depthstream_t depthStream;
astra_reader_get_depthstream(reader, &depthStream);
 
//get depth stream fov
float hFov, vFov;
astra_depthstream_get_hfov(depthStream, &hFov);
astra_depthstream_get_vfov(depthStream, &vFov);
printf("depth sensor -- hFov: %f radians vFov: %f radians\n", hFov, vFov);
 
//get serialnumber
char serialnumber[128];
astra_depthstream_get_serialnumber(depthStream,serialnumber,128);
printf("depth sensor -- serial number: %s\n", serialnumber);
 
//get chipId
const uint32_t chipId;
astra_depthstream_get_chip_id(depthStream, &chipId);
 
//start depth stream
astra_stream_start(depthStream);

现在，我们一起看如何获取深度流数据帧

//wait a new frame
astra_update();
 
astra_reader_frame_t frame;
//get one frame of depth stream
astra_status_t rc = astra_reader_open_frame(reader, 0, &frame);
//check result status
if (rc == ASTRA_STATUS_SUCCESS)
{
    astra_depthframe_t depthFrame;
    //get depthFrame frame
    astra_frame_get_depthframe(frame, &depthFrame);
 
    astra_frame_index_t newFrameIndex;
    //get frame index
    astra_depthFrame_get_frameindex(depthFrame, &newFrameIndex);
 
    if (lastFrameIndex == newFrameIndex)
    {
        printf("duplicate frame index: %d\n", lastFrameIndex);
    }
    lastFrameIndex = newFrameIndex;
    //print depth frame info
    print_depthFrame(depthFrame);
    //release frame
    astra_reader_close_frame(&frame);
}

最后，我们需要释放所有资源。

//destroy reader
astra_reader_destroy(&reader);
//close sensor
astra_streamset_close(&sensor);
//terminate astra sdk
astra_terminate();

事件方式

此示例演示了如何通过事件方式使用 Astra SDK 读取彩色流。

首先，我们加入头文件

#include <astra/capi/astra.h>

下一步，我们需初始化 OpenNI2 SDK，获取传感器并创建读取器以读取深度流

//initialize astra sdk
astra_initialize();
 
astra_streamsetconnection_t sensor;
 
//open default sensor
astra_streamset_open("device/default", &sensor);
 
//create stream reader
astra_reader_t reader;
astra_reader_create(sensor, &reader);
 
//get depth stream
astra_depthstream_t depthStream;
astra_reader_get_depthstream(reader, &depthStream);
 
//start depth stream
astra_stream_start(depthStream);

然后，我们注册一个回调来接收深度流数据帧

//register frame callback
astra_reader_callback_id_t callbackId;
astra_reader_register_frame_ready_callback(reader, &frame_ready, NULL, &callbackId);

接着调用更新

astra_update();

一旦我们不再需要接收帧，请注销回调

astra_reader_unregister_frame_ready_callback(&callbackId);

最后，我们需要释放所有资源。

//destroy reader
astra_reader_destroy(&reader);
//close sensor
astra_streamset_close(&sensor);
//terminate astra sdk
astra_terminate();

C++

事件方式

此示例演示了如何通过事件方式使用 Astra SDK 读取深度流。

首先，我们加入头文件

#include <astra/astra.hpp>

下一步，我们需初始化 OpenNI2 SDK，获取传感器并创建读取器以读取深度流。注册一个回调来接收深度流数据帧

//initialize astra sdk
astra::initialize();
 
//create stream set and reader
astra::StreamSet streamSet;
astra::StreamReader reader = streamSet.create_reader();
 
//create listener and start depth stream
SampleFrameListener listener;
reader.stream<astra::depthStream>().start();
//get serial number
char serialnumber[256];
depthStream.serial_number(serialnumber, 256);
//get chipId
const uint32_t chipId = depthStream.chip_id();
//get usb info
const astra_usb_info_t usbinfo = depthStream.usb_info();
reader.add_listener(listener);

接着调用更新

astra_update();

当我们不再需要接收帧的时候，请注销回调

reader.remove_listener(listener);

最后，我们需要释放所有资源。

//terminate astra sdk
astra::terminate();

Infrared Reader

概述

此示例演示了如何使用 Astra SDK 读取红外流.

预期输出

代码概述

我们提供了C版的基于轮询和事件两种不同的方式来访问彩色流的示例，分别如下所示：

轮询方式

此示例用于说明如何通过轮询方式使用 Astra SDK 读取红外流。

首先，我们加入头文件

#include <astra/capi/astra.h>

下一步，我们需初始化Astra SDK，获取传感器并创建读取器以读取红外流

//initialize astra sdk
astra_initialize();
 
astra_streamsetconnection_t sensor;
 
//open default sensor
astra_streamset_open("device/default", &sensor);
 
//create stream reader
astra_reader_t reader;
astra_reader_create(sensor, &reader);
 
//get infrared stream
astra_infraredstream_t infraredStream;
astra_reader_get_infraredstream(reader, &infraredStream);
 
//get infrared image mode
astra_imagestream_mode_t mode;
mode.width = 640;
mode.height = 480;
mode.pixelFormat = ASTRA_PIXEL_FORMAT_GRAY16;
mode.fps = 30;
astra_imagestream_set_mode(infraredStream, &mode);
 
//start infrared stream
astra_stream_start(infraredStream);

现在，我们一起看如何获取红外流数据帧

//wait a new frame
astra_update();
 
astra_reader_frame_t frame;
//get one frame of infrared stream
astra_status_t rc = astra_reader_open_frame(reader, 0, &frame);
//check result status
if (rc == ASTRA_STATUS_SUCCESS)
{
    astra_infraredframe_t infraredFrame;
    //get infrared frame
    astra_frame_get_infraredframe(frame, &infraredFrame);
    //print infrared frame info
    print_infrared(infraredFrame);
    //release frame
    astra_reader_close_frame(&frame);
}

最后，我们需要释放所有资源。

//destroy reader
astra_reader_destroy(&reader);
//close sensor
astra_streamset_close(&sensor);
//terminate astra sdk
astra_terminate();

事件方式

此示例演示了如何通过事件方式使用 Astra SDK 读取红外流。

首先，我们加入头文件

#include <astra/capi/astra.h>

下一步，我们需初始化 Astra SDK，获取传感器并创建读取器以读取红外流

//initialize astra sdk
astra_initialize();
 
astra_streamsetconnection_t sensor;
 
//open default sensor
astra_streamset_open("device/default", &sensor);
 
//create stream reader
astra_reader_t reader;
astra_reader_create(sensor, &reader);
 
//get infrared stream
astra_infraredstream_t infraredStream;
astra_reader_get_infraredstream(reader, &infraredStream);
 
//set infrared image mode
astra_imagestream_mode_t mode;
mode.width = 640;
mode.height = 480;
mode.pixelFormat = ASTRA_PIXEL_FORMAT_GRAY16;
mode.fps = 30;
astra_imagestream_set_mode(infraredStream, &mode);
 
//start infrared stream
astra_stream_start(infraredStream);

然后，我们注册一个回调来接收红外流数据帧

//register frame callback
astra_reader_callback_id_t callbackId;
astra_reader_register_frame_ready_callback(reader, &frame_ready, NULL, &callbackId);

接着调用更新

astra_update();

当我们不再需要接收帧的时候，请注销回调

astra_reader_unregister_frame_ready_callback(&callbackId);

最后，我们需要释放所有资源。

//destroy reader
astra_reader_destroy(&reader);
//close sensor
astra_streamset_close(&sensor);
//terminate astra sdk
astra_terminate();

Body Reader

概述

此示例演示了如何使用 Astra SDK 读取人体数据。

预期输出

代码概述

首先，我们需要加入头文件

#include <astra/capi/astra.h>

下一步，我们需初始化Astra SDK，获取传感器并创建读取器以读取人体数据

//initialize astra sdk
astra_initialize();
 
//to use body tracking, you must set license after initialize
const char* licenseString = "<INSERT LICENSE KEY HERE>";
orbbec_body_tracking_set_license(licenseString);
 
astra_streamsetconnection_t sensor;
 
//open default sensor
astra_streamset_open("device/default", &sensor);
 
//create stream reader
astra_reader_t reader;
astra_reader_create(sensor, &reader);
 
//get body stream
astra_bodystream_t bodyStream;
astra_reader_get_bodystream(reader, &bodyStream);
 
//start body stream
astra_stream_start(bodyStream);

现在，我们一起看如何获取人体数据帧

//wait a new frame
astra_update();
 
astra_reader_frame_t frame;
//get one frame of body stream
astra_status_t rc = astra_reader_open_frame(reader, 0, &frame);
//check result status
if (rc == ASTRA_STATUS_SUCCESS)
{
    astra_bodyframe_t bodyFrame;
    //get body frame
    astra_frame_get_bodyframe(frame, &bodyFrame);
    //get body frame index
    astra_frame_index_t frameIndex;
    astra_bodyframe_get_frameindex(bodyFrame, &frameIndex);
    //print body frame info
    output_bodyframe(bodyFrame);
    //release frame
    astra_reader_close_frame(&frame);
}

最后，我们需要释放所有资源。

//destroy reader
astra_reader_destroy(&reader);
//close sensor
astra_streamset_close(&sensor);
//terminate astra sdk
astra_terminate();

Infrared Color Reader

概述

此示例演示了如何使用 Astra SDK 读取红外、彩色流。

预期输出

代码概述

首先，我们加入头文件

#include <astra/capi/astra.h>

下一步，我们需初始化Astra SDK，获取传感器并创建读取器以读取红外、彩色流

//initialize astra sdk
astra_initialize();
 
astra_streamsetconnection_t sensor;
 
//open default sensor
astra_streamset_open("device/default", &sensor);
 
//create stream reader
astra_reader_t reader;
astra_reader_create(sensor, &reader);
 
//get infrared and stream
astra_infraredstream_t infraredStream;
astra_reader_get_infraredstream(reader, &infraredStream);
astra_colorstream_t colorStream;
astra_reader_get_colorstream(reader, &colorStream);
 
//start infrared and stream
astra_stream_start(infraredStream);
astra_stream_start(colorStream);

然后，我们注册一个回调来接收红外、彩色流数据帧

//register frame callback
astra_reader_callback_id_t callbackId;
astra_reader_register_frame_ready_callback(reader, &frame_ready, NULL, &callbackId);

接着调用更新

astra_update();

一旦我们不再需要接收帧，请注销回调

astra_reader_unregister_frame_ready_callback(&callbackId);

最后，我们需要释放所有资源。

//destroy reader
astra_reader_destroy(&reader);
//close sensor
astra_streamset_close(&sensor);
//terminate astra sdk
astra_terminate();

SFML Sample(C++)

SimpleDepthViewer-SFML

概述

此示例演示了如何使用SFML显示深度流数据。

预期输出

SimpleColorViewer-SFML

概述

此示例演示了如何使用SFML显示彩色流数据。

预期输出

SimpleBodyViewer-SFML

概述

此示例演示了如何使用SFML来显示人体骨架。

预期输出

SimpleStreamViewer-SFML

概述

此示例演示了如何使用SFML显示深度和彩色流数据。

预期输出

ColorizedBodyViewer-SFML

概述

此示例演示了如何使用SFML来显示彩色的人体抠图流数据。

预期输出

MaskedColorViewer-SFML

概述

此示例演示了如何使用SFML显示人体抠图加彩色流数据。

预期输出

MultiSensorViewer-SFML

概述

此示例演示了如何使用SFML显示多相机深度和彩色流数据。

预期输出

RotatedBodyViewer-SFML

概述

此示例演示了如何使用SFML显示旋转的人体数据。

预期输出

Android Sample (Java)

Color View

首先你需要创建 astra context 并设置设备事件监听, 所以你需要实现 AstraDeviceManagerListener, 然后获取相机权限, 你可以在Activity的 onCreate 中来做这些:

//Create Astra context and set device listener
mAstraContext = new AstraAndroidContext(this, this);
 
//Request camera permission
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    if (checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
        requestPermissions(new String[]{Manifest.permission.CAMERA}, 0);
    } else{
        initDevice();
    }
} else {
    initDevice();
}

一旦获取了权限, 初始化 astra sdk 并打开设备

mAstraContext.initialize();
mAstraContext.openAllDevices();

在设备打开后, 你可以读取帧, 为了读取帧你需要创建流读取器和帧的监听器, 并注册监听器到流读取器中

//Open streamset and create stream reader
mStreamSet = StreamSet.open();
mStreamReader = mStreamSet.createReader();
 
mFrameListener = (streamReader, readerFrame) -> {
    //Get color frame
    ColorFrame colorFrame = ColorFrame.get(readerFrame);
    if(colorFrame != null) {
        //do somthing
    }
};
 
//Register frame listener to receive frame
mStreamReader.addFrameListener(mFrameListener);

如果你想要自定义彩色流模式 , 你可以枚举所有的彩色流模式然后设置你需要的模式

//Get color stream and set color mode with width to 640 and fps to 30
mColorStream = ColorStream.get(mStreamReader);
Iterable<ImageStreamMode> modes = mColorStream.getAvailableModes();
for (ImageStreamMode mode : modes) {
    if(mode.getWidth() == 640 && mode.getFramesPerSecond() == 30) {
        mColorStream.setMode(mode);
        break;
    }
}

最后打开彩色流

//Start color stream
mColorStream.start();

还有一件重要的事情是你需要做的就是在一个while循环中更新 astra sdk 的数据, 为了避免阻塞ui线程, 最好在一个新的线程里做这些

//Create a thread to update astra sdk
mThread = new Thread(new Runnable() {
    @Override
    public void run() {
        while (!isExit) {
            Astra.update();
            try {
                Thread.sleep(30);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
});
mThread.start();

预期输出

Depth View

首先你需要创建 astra context 并设置设备事件监听, 所以你需要实现 AstraDeviceManagerListener, 然后获取相机权限, 你可以在Activity的 onCreate 中来做这些:

//Create Astra context and set device listener
mAstraContext = new AstraAndroidContext(this, this);
 
//Request camera permission
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    if (checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
        requestPermissions(new String[]{Manifest.permission.CAMERA}, 0);
    } else{
        initDevice();
    }
} else {
    initDevice();
}

一旦获取了权限, 初始化 astra sdk 并打开设备

mAstraContext.initialize();
mAstraContext.openAllDevices();

在设备打开后, 你可以读取帧, 为了读取帧你需要创建流读取器和帧的监听器, 并注册监听器到流读取器中

//Open streamset and create stream reader
mStreamSet = StreamSet.open();
mStreamReader = mStreamSet.createReader();
 
mFrameListener = (streamReader, readerFrame) -> {
    //Get depth frame
    DepthFrame depthFrame = DepthFrame.get(readerFrame);
    if(depthFrame != null) {
        //do somthing
    }
};
 
//Register frame listener to receive frame
mStreamReader.addFrameListener(mFrameListener);

如果你想要自定义深度流模式 , 你可以枚举所有的深度流模式然后设置你需要的模式

//Get depth stream and set depth mode with width to 640 and fps to 30
mDepthStream = DepthStream.get(mStreamReader);
Iterable<ImageStreamMode> modes = mDepthStream.getAvailableModes();
for (ImageStreamMode mode : modes) {
    if(mode.getWidth() == 640 && mode.getFramesPerSecond() == 30) {
        mDepthStream.setMode(mode);
        break;
    }
}

最后打开深度流

//Start depth stream
mDepthStream.start();

还有一件重要的事情是你需要做的就是在一个while循环中更新 astra sdk 的数据, 为了避免阻塞ui线程, 最好在一个新的线程里做这些

//Create a thread to update astra sdk
mThread = new Thread(new Runnable() {
    @Override
    public void run() {
        while (!isExit) {
            Astra.update();
            try {
                Thread.sleep(30);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
});
mThread.start();

预期输出

Colorized Body View

首先你需要创建 astra context 并设置设备事件监听, 所以你需要实现 AstraDeviceManagerListener, 然后获取相机权限, 你可以在Activity的 onCreate 中来做这些:

//Create Astra context and set device listener
mAstraContext = new AstraAndroidContext(this, this);
 
//Request camera permission
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    if (checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
        requestPermissions(new String[]{Manifest.permission.CAMERA}, 0);
    } else{
        initDevice();
    }
} else {
    initDevice();
}

一旦获取了权限, 初始化 astra sdk 并打开设备

mAstraContext.initialize();
mAstraContext.openAllDevices();

在设备打开后, 你可以读取帧, 为了读取帧你需要创建流读取器和帧的监听器, 并注册监听器到流读取器中

//Open streamset and create stream reader
mStreamSet = StreamSet.open();
mStreamReader = mStreamSet.createReader();
 
mFrameListener = (streamReader, readerFrame) -> {
    //Get colorizedBody frame
    ColorizedBodyFrame colorizedBodyFrame = ColorizedBodyFrame.get(readerFrame);
    if(colorizedBodyFrame != null) {
        //do somthing
    }
};
 
//Register frame listener to receive frame
mStreamReader.addFrameListener(mFrameListener);

获取 colorized body 流并打开流

//Get colorizedBody stream
mColorizedBodyStream = ColorizedBodyStream.get(mStreamReader);
//Start colorizedBody stream
mColorizedBodyStream.start();

还有一件重要的事情是你需要做的就是在一个while循环中更新 astra sdk 的数据, 为了避免阻塞ui线程, 最好在一个新的线程里完成这些

//Create a thread to update astra sdk
mThread = new Thread(new Runnable() {
    @Override
    public void run() {
        while (!isExit) {
            Astra.update();
            try {
                Thread.sleep(30);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
});
mThread.start();

预期输出

Masked Color View

首先你需要创建 astra context 并设置设备事件监听, 所以你需要实现 AstraDeviceManagerListener, 然后获取相机权限, 你可以在Activity的 onCreate 中来做这些:

//Create Astra context and set device listener
mAstraContext = new AstraAndroidContext(this, this);
 
//Request camera permission
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    if (checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
        requestPermissions(new String[]{Manifest.permission.CAMERA}, 0);
    } else{
        initDevice();
    }
} else {
    initDevice();
}

一旦获取了权限, 初始化 astra sdk 并打开设备

mAstraContext.initialize();
mAstraContext.openAllDevices();

在设备打开后, 你可以读取帧, 为了读取帧你需要创建流读取器和帧的监听器, 并注册监听器到流读取器中

//Open streamset and create stream reader
mStreamSet = StreamSet.open();
mStreamReader = mStreamSet.createReader();
 
mFrameListener = (streamReader, readerFrame) -> {
    //Get maskedColor frame
    MaskedColorFrame maskedColorFrame = MaskedColorFrame.get(readerFrame);
    if(maskedColorFrame != null) {
        //do somthing
    }
};
 
//Register frame listener to receive frame
mStreamReader.addFrameListener(mFrameListener);

获取 masked color 流并打开流

//Get maskedColor stream
mMaskedColorStream = MaskedColorStream.get(mStreamReader);
//Start maskedColor stream
mMaskedColorStream.start();

还有一件重要的事情是你需要做的就是在一个while循环中更新 astra sdk 的数据, 为了避免阻塞ui线程, 最好在一个新的线程里做这些

//Create a thread to update astra sdk
mThread = new Thread(new Runnable() {
    @Override
    public void run() {
        while (!isExit) {
            Astra.update();
            try {
                Thread.sleep(30);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
});
mThread.start();

预期输出

Body View

首先你需要创建 astra context 并设置设备事件监听, 所以你需要实现 AstraDeviceManagerListener, 然后获取相机权限, 你可以在Activity的 onCreate 中来做这些:

//Create Astra context and set device listener
mAstraContext = new AstraAndroidContext(this, this);
 
//Request camera permission
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    if (checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
        requestPermissions(new String[]{Manifest.permission.CAMERA}, 0);
    } else{
        initDevice();
    }
} else {
    initDevice();
}

一旦获取了权限, 初始化 astra sdk 并打开设备

mAstraContext.initialize();
mAstraContext.openAllDevices();

在设备打开后, 你可以读取帧, 为了读取帧你需要创建流读取器和帧的监听器, 并注册监听器到流读取器中, 如果你想要使用完整版的骨架特性，请在打开stream set之前设置License

//Set license to use body tracking
BodyTracking.setLicense("<Your license string>");
 
//Open streamset and create stream reader
mStreamSet = StreamSet.open();
mStreamReader = mStreamSet.createReader();
 
mFrameListener = (streamReader, readerFrame) -> {
    //Get body frame
    BodyFrame bodyFrame = BodyFrame.get(readerFrame);
    if(bodyFrame != null) {
        //do somthing
    }
};
 
//Register frame listener to receive frame
mStreamReader.addFrameListener(mFrameListener);

获取Body流并打开流

//Get body stream
mBodyStream = BodyStream.get(mStreamReader);
//Start body stream
mBodyStream.start();

还有一件重要的事情是你需要做的就是在一个while循环中更新 astra sdk 的数据, 为了避免阻塞ui线程, 最好在一个新的线程里做这些

//Create a thread to update astra sdk
mThread = new Thread(new Runnable() {
    @Override
    public void run() {
        while (!isExit) {
            Astra.update();
            try {
                Thread.sleep(30);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
});
mThread.start();

注意：如需完整地使用人体分割、彩色抠图、骨架跟踪的能力，都需要仿照Body View的示例进行License设置。

预期输出