int test_Client(const std::string &host, const unsigned &port)
{
try {
using Motion::SDK::Client;
using Motion::SDK::Format;
// Open connection to the data server.
Client client(host, port);
std::cout << "Connected to " << host << ":" << port << std::endl;
if (client.waitForData()) {
std::size_t sample_count = 0;
// Read data samples in a loop. This is a blocking call so
// we can simply wait on an open connection until a data
// sample comes in.
Client::data_type data;
while ((sample_count++ < NSample) && client.readData(data)) {
if (PortPreview == port) {
typedef Format::preview_service_type map_type;
map_type preview = Format::Preview(data.begin(), data.end());
if (!preview.empty()) {
std::cout << Format::PreviewElement::Name << ": " << preview.size();
for (map_type::iterator itr=preview.begin(); itr!=preview.end();
++itr) {
Format::PreviewElement::data_type q =
itr->second.getQuaternion(false);
std::cout
<< " q(" << itr->first << ") = (" << q[0] << ", " << q[1]
<< ", " << q[2] << ", " << q[3] << ")"
<< std::endl;
}
}
}
if (PortSensor == port) {
typedef Format::sensor_service_type map_type;
map_type sensor = Format::Sensor(data.begin(), data.end());
if (!sensor.empty()) {
std::cout << Format::SensorElement::Name << ": " << sensor.size();
for (map_type::iterator itr=sensor.begin(); itr!=sensor.end();
++itr) {
Format::SensorElement::data_type acc =
itr->second.getAccelerometer();
std::cout
<< " a(" << itr->first << ") = " << acc[0] << " " << acc[1]
<< " " << acc[2]
<< std::endl;
}
}
}
if (PortRaw == port) {
typedef Format::raw_service_type map_type;
map_type raw = Format::Raw(data.begin(), data.end());
if (!raw.empty()) {
std::cout << Format::RawElement::Name << ": "<< raw.size();
for (map_type::iterator itr=raw.begin(); itr!=raw.end(); ++itr) {
Format::RawElement::data_type acc =
itr->second.getAccelerometer();
std::cout
<< " a(" << itr->first << ") = " << acc[0] << " " << acc[1]
<< " " << acc[2]
<< std::endl;
}
}
}
}
} else {
std::cout << "No current data available, giving up" << std::endl;
}
std::string message;
if (client.getErrorString(message)) {
std::cerr << "Error: " << message << std::endl;
}
} catch (std::runtime_error &e) {
std::cerr << e.what() << std::endl;
return 1;
}
return 0;
}
int test_Configurable(const std::string &host, const unsigned &port)
{
try {
using Motion::SDK::Client;
using Motion::SDK::Format;
// Open connection to the data server.
Client client(host, port);
std::cout << "Connected to " << host << ":" << port << std::endl;
// The Configurable data service requires an XML definition of the
// requested channel names.
{
Client::data_type xml_definition;
{
std::ifstream fin("../../test_data/configurable.xml",
std::ios_base::binary | std::ios_base::in);
if (fin.is_open()) {
fin.seekg(0, std::ios_base::end);
int num_bytes = fin.tellg();
fin.seekg(0, std::ios_base::beg);
if (num_bytes > 0) {
xml_definition.resize(num_bytes);
if (fin.read(&xml_definition[0], num_bytes)) {
} else {
xml_definition.clear();
}
}
}
}
// Make a default definition here, in case we could not find our file.
// Access the global quaternion and calibrated accelerometer streams.
if (xml_definition.empty()) {
std::string xml_string =
"<?xml version=\"1.0\"?>"
"<configurable>"
"<preview><Gq/></preview>"
"<sensor><a/></sensor>"
"</configurable>";
xml_definition.assign(xml_string.begin(), xml_string.end());
}
if (!xml_definition.empty() && client.writeData(xml_definition)) {
std::cout
<< "Sent active channel definition to Configurable service"
<< std::endl;
}
}
if (client.waitForData()) {
std::size_t sample_count = 0;
// Read data samples in a loop. This is a blocking call so
// we can simply wait on an open connection until a data
// sample comes in.
Client::data_type data;
while ((sample_count++ < NSample) && client.readData(data)) {
typedef Format::configurable_service_type map_type;
map_type container = Format::Configurable(data.begin(), data.end());
if (!container.empty()) {
std::cout
<< Format::ConfigurableElement::Name << ": " << container.size();
for (map_type::iterator itr=container.begin(); itr!=container.end();
++itr) {
std::cout << " data(" << itr->first << ") = ";
for (std::size_t i=0; i<itr->second.size(); i++) {
std::cout << itr->second[i] << " ";
}
std::cout << std::endl;
}
}
std::cout << std::endl;
}
} else {
std::cout << "No current data available, giving up" << std::endl;
}
std::string message;
if (client.getErrorString(message)) {
std::cerr << "Error: " << message << std::endl;
}
} catch (std::runtime_error &e) {
std::cerr << e.what() << std::endl;
return 1;
}
return 0;
}
/**
Thread function. Make a connection to the remote Host:Port and read
Preview data in a loop.
*/
bool operator()()
{
using Motion::SDK::Client;
using Motion::SDK::Format;
try {
// Open a connection to the Motion Service Preview stream running
// on Host:Port.
Client client(Host, Port);
std::cout << "Connected to " << Host << ":" << Port << std::endl;
bool quit_thread = false;
while (!quit_thread) {
// Make a check for the quit flag here.
{
sdl_mutex_lock lock(m_mutex);
if (m_quit) {
quit_thread = true;
}
}
// Block on this call until a single data sample arrives from the
// remote service. Use default time out of 5 seconds.
if (client.waitForData()) {
// The Client#readData method will time out after 1 second. Then
// just go back to the blocking Client#waitForData method to wait
// for more incoming data.
Client::data_type data;
while (!quit_thread && client.readData(data)) {
// We have a message from the remote Preview service. Use the
// Format::Preview method to create a std::map<integer,Format::PreviewElement>
// of all active device connections.
std::vector<float> transform;
std::vector<float> euler;
{
// Iterate through Nodes, but just grab the first one.
Format::preview_service_type preview = Format::Preview(data.begin(), data.end());
for (Format::preview_service_type::iterator itr=preview.begin(); itr!=preview.end(); ++itr) {
transform = itr->second.getMatrix(false);
euler = itr->second.getEuler();
break;
}
}
// Copy the new transformation matrix into the mutex protected
// state. The drawing thread reads this.
{
sdl_mutex_lock lock(m_mutex);
if (transform.size() == m_transform.size()) {
m_transform = transform;
}
if (euler.size() == m_euler.size()) {
m_euler = euler;
}
if (m_quit) {
quit_thread = true;
break;
}
}
}
}
}
} catch (std::exception &e) {
std::cerr << e.what() << std::endl;
return false;
}
std::cout << "Leaving client thread" << std::endl;
return true;
}