WeArtMessages.h

Go to the documentation of this file.

#pragma once
 
#include "WeArtCommon.h"
#include <string>
#include <vector>
#include <cassert>
#include "json.hpp"
 
static EHandSide StringToHandside(std::string &str) {
    if (str == "LEFT") {
        return EHandSide::Left;
    }
    else if (str == "RIGHT") {
        return EHandSide::Right;
    }
    else {
        assert(false);
        return EHandSide::Left;
    }
};
 
static std::string HandsideToString(EHandSide hs) {
    if (hs == EHandSide::Left) {
        return "LEFT";
    }
    else if (hs == EHandSide::Right) {
        return "RIGHT";
    }
    else {
        assert(false);
        return "";
    }
};
 
static EActuationPoint StringToActuationPoint(std::string& str) {
    if (str == "THUMB") {
        return EActuationPoint::Thumb;
    }
    else if (str == "INDEX") {
        return EActuationPoint::Index;
    }
    else if (str == "MIDDLE") {
        return EActuationPoint::Middle;
    }
    else if (str == "PALM") {
        return EActuationPoint::Palm;
    }
    else {
        assert(false);
        return EActuationPoint::Thumb;
    }
};
 
static std::string ActuationPointToString(EActuationPoint ap) {
    if (ap == EActuationPoint::Thumb) {
        return "THUMB";
    }
    else if (ap == EActuationPoint::Index) {
        return "INDEX";
    }
    else if (ap == EActuationPoint::Middle) {
        return "MIDDLE";
    }
    else if (ap == EActuationPoint::Palm) {
        return "PALM";
    }
    else {
        assert(false);
        return "";
    }
};
 
static TrackingType StringToTrackingType(const std::string& str) {
    if (str == "TrackType1")
        return TrackingType::WEART_HAND;
    return TrackingType::DEFAULT;
}
 
static std::string TrackingTypeToString(TrackingType trackType) {
    switch (trackType) {
    case TrackingType::DEFAULT:
        return "";
    case TrackingType::WEART_HAND:
        return "TrackType1";
    }
    return "";
}
 
static std::string MiddlewareStatusToString(MiddlewareStatus status)
{
    switch (status)
    {
    case MiddlewareStatus::DISCONNECTED:
        return"DISCONNECTED";
    case MiddlewareStatus::IDLE:
        return"IDLE";
    case MiddlewareStatus::STARTING:
        return"STARTING";
    case MiddlewareStatus::RUNNING:
        return"RUNNING";
    case MiddlewareStatus::STOPPING:
        return"STOPPING";
    case MiddlewareStatus::UPLOADING_TEXTURES:
        return"UPLOADING_TEXTURES";
    case MiddlewareStatus::CONNECTING_DEVICE:
        return"CONNECTING_DEVICE";
    case MiddlewareStatus::CALIBRATION:
        return"CALIBRATION";
    }
 
    return "";
}
 
static MiddlewareStatus StringToMiddlewareStatus(const std::string& str) {
    if (str == "DISCONNECTED")
        return MiddlewareStatus::DISCONNECTED;
    if (str == "IDLE")
        return MiddlewareStatus::IDLE;
    if (str == "STARTING")
        return MiddlewareStatus::STARTING;
    if (str == "RUNNING")
        return MiddlewareStatus::RUNNING;
    if (str == "STOPPING")
        return MiddlewareStatus::STOPPING;
    if (str == "UPLOADING_TEXTURES")
        return MiddlewareStatus::UPLOADING_TEXTURES;
    if (str == "CONNECTING_DEVICE")
        return MiddlewareStatus::CONNECTING_DEVICE;
    if (str == "CALIBRATION")
        return MiddlewareStatus::CALIBRATION;
 
    return MiddlewareStatus::DISCONNECTED;
}
 
class WeArtMessage {
 
public:
    virtual std::string getID() = 0;
    //virtual std::vector<std::string> getValues() = 0;
    //virtual void setValues(std::vector<std::string>& values) = 0;
 
    virtual void setHandSide(EHandSide hs) = 0;
    virtual void setActuationPoint(EActuationPoint ap) = 0;
 
    virtual std::string serialize() = 0;
    virtual void deserialize(std::string message) = 0;
};
 
class WeArtCsvMessage : public WeArtMessage {
public:
    const char field_separator = ':';
 
    virtual std::vector<std::string> getValues() = 0;
    virtual void setValues(std::vector<std::string>& values) = 0;
 
    virtual std::string serialize() override;
    virtual void deserialize(std::string message) override;
};
 
class WeArtJsonMessage : public WeArtMessage {
public:
    WeArtJsonMessage();
 
    virtual std::string serialize() override;
    virtual void deserialize(std::string message) override;
    std::uint64_t timestamp() { return _timestamp; }
 
    virtual void setHandSide(EHandSide hs) override {};
    virtual void setActuationPoint(EActuationPoint ap) override {};
 
protected:
    virtual nlohmann::json serializePayload() { return nlohmann::json(); }
    virtual void deserializePayload(nlohmann::json payload) {}
    std::uint64_t _timestamp;
};
 
class WeArtMessageNoParams : public WeArtCsvMessage {
 
public:
    virtual void setHandSide(EHandSide hs) override {};
    virtual void setActuationPoint(EActuationPoint ap) override {};
 
    // This message carries no values.
    virtual std::vector<std::string> getValues() override { return std::vector<std::string>(); };
    virtual void setValues(std::vector<std::string>& values) override {};
};
 
class WeArtMessageObjectSpecific : public WeArtCsvMessage {
 
protected:
    EHandSide handSide;
    EActuationPoint actuationPoint;
public:
    virtual void setHandSide(EHandSide hs) override { handSide = hs; };
    virtual void setActuationPoint(EActuationPoint ap) override { actuationPoint = ap; };
};
 
class StartFromClientMessage : public WeArtMessageNoParams {
 
public:
 
    static constexpr const char* ID = "StartFromClient";
    
    virtual std::string getID() override { return ID; };
 
    virtual std::vector<std::string> getValues() override {
        std::vector<std::string> ret;
        if (_trackType != TrackingType::DEFAULT) {
            ret.push_back(WeArtConstants::WEART_SDK_TYPE);
            ret.push_back(WeArtConstants::WEART_SDK_VERSION);
            ret.push_back(WeArtConstants::WEART_SDK_TRACK_TYPE);
        }
        return ret;
    };
 
    virtual void setValues(std::vector<std::string>& values) override {
        if (values.empty())
            _trackType = TrackingType::DEFAULT;
        else
            _trackType = StringToTrackingType(values[2]);
    };
 
private:
    TrackingType _trackType;
};
 
class StopFromClientMessage : public WeArtMessageNoParams {
 
public:
    static constexpr const char* ID = "StopFromClient";
 
    virtual std::string getID() override { return ID; };
 
};
 
class StartCalibrationMessage : public WeArtMessageNoParams {
 
public:
    static constexpr const char* ID = "StartCalibration";
 
    virtual std::string getID() override { return ID; };
};
 
class StopCalibrationMessage : public WeArtMessageNoParams {
 
public:
    static constexpr const char* ID = "StopCalibration";
 
    virtual std::string getID() override { return ID; };
};
 
class ExitMessage : public WeArtMessageNoParams {
 
public:
    static constexpr const char* ID = "exit";
 
    virtual std::string getID() override { return ID; };
};
 
class DisconnectMessage : public WeArtMessageNoParams {
 
public:
    static constexpr const char* ID = "disconnect";
 
    virtual std::string getID() override { return ID; };
};
 
class SetTemperatureMessage : public WeArtMessageObjectSpecific
{
public:
    SetTemperatureMessage(const float t) : temperature(t) {};
    SetTemperatureMessage() {};
 
    static constexpr const char* ID = "temperature";
 
    virtual std::string getID() override { return ID; };
 
    virtual std::vector<std::string> getValues() override {
        std::vector<std::string> ret;
        ret.push_back(std::to_string(temperature));
        ret.push_back(HandsideToString(handSide));
        ret.push_back(ActuationPointToString(actuationPoint));
        return ret;
    };
 
    virtual void setValues(std::vector<std::string>& values) override {
        assert(values.size() == 3);
        temperature = std::stof(values[0]);
        handSide = StringToHandside(values[1]);
        actuationPoint = StringToActuationPoint(values[2]);
    };
 
protected:
 
    float temperature;
};
 
class StopTemperatureMessage : public WeArtMessageObjectSpecific
{
 
public:
 
    static constexpr const char* ID = "stopTemperature";
 
    virtual std::string getID() override { return ID; };
 
    virtual std::vector<std::string> getValues() override {
        std::vector<std::string> ret;
        ret.push_back(HandsideToString(handSide));
        ret.push_back(ActuationPointToString(actuationPoint));
        return ret;
    };
 
    virtual void setValues(std::vector<std::string>& values) override {
        assert(values.size() == 2);
        handSide = StringToHandside(values[0]);
        actuationPoint = StringToActuationPoint(values[1]);
    };
};
 
class SetForceMessage : public WeArtMessageObjectSpecific
{
 
public:
    SetForceMessage(const float f[3]) : force{ f[0], f[1], f[2] } {};
    SetForceMessage() {};
 
    static constexpr const char* ID = "force";
 
    virtual std::string getID() override { return ID; };
 
    virtual std::vector<std::string> getValues() override {
        std::vector<std::string> ret;
        ret.push_back(std::to_string(force[0]));
        ret.push_back(std::to_string(force[1]));
        ret.push_back(std::to_string(force[2]));
        ret.push_back(HandsideToString(handSide));
        ret.push_back(ActuationPointToString(actuationPoint));
        return ret;
    };
 
    virtual void setValues(std::vector<std::string>& values) override {
        assert(values.size() == 5);
        force[0] = std::stof(values[0]);
        force[1] = std::stof(values[1]);
        force[2] = std::stof(values[2]);
        handSide = StringToHandside(values[3]);
        actuationPoint = StringToActuationPoint(values[4]);
    };
 
protected:
 
    float force[3];
};
 
class StopForceMessage : public WeArtMessageObjectSpecific
{
 
public:
 
    static constexpr const char* ID = "stopForce";
 
    virtual std::string getID() override { return ID; };
 
    virtual std::vector<std::string> getValues() override {
        std::vector<std::string> ret;
        ret.push_back(HandsideToString(handSide));
        ret.push_back(ActuationPointToString(actuationPoint));
        return ret;
    };
 
    virtual void setValues(std::vector<std::string>& values) override {
        assert(values.size() == 2);
        handSide = StringToHandside(values[0]);
        actuationPoint = StringToActuationPoint(values[1]);
    };
};
 
class SetTextureMessage : public WeArtMessageObjectSpecific
{
 
public:
    SetTextureMessage(const int idx, const float vel[3], const float vol) : index(idx), velocity{ vel[0], vel[1], vel[2] }, volume(vol)  {};
    SetTextureMessage() {};
 
    static constexpr const char* ID = "texture";
 
    virtual std::string getID() override { return ID; };
 
    virtual std::vector<std::string> getValues() override {
        std::vector<std::string> ret;
 
        // avoinding texture id out of bounds
        if (index < WeArtConstants::minTextureIndex || index > WeArtConstants::maxTextureIndex) {
            index = WeArtConstants::nullTextureIndex;
        }
 
        ret.push_back(std::to_string(index));
        ret.push_back(std::to_string(velocity[0]));
        ret.push_back(std::to_string(velocity[1]));
        ret.push_back(std::to_string(velocity[2]));
        ret.push_back(std::to_string(volume));
        ret.push_back(HandsideToString(handSide));
        ret.push_back(ActuationPointToString(actuationPoint));
        return ret;
    };
 
    virtual void setValues(std::vector<std::string>& values) override {
        assert(values.size() == 6);
        index = std::stoi(values[0]);
        velocity[0] = std::stof(values[1]);
        velocity[1] = std::stof(values[2]);
        velocity[2] = std::stof(values[3]);
        volume = std::stof(values[4]);
        handSide = StringToHandside(values[5]);
        actuationPoint = StringToActuationPoint(values[6]);
    };
 
protected:
 
    int index;
    float velocity[3];
    float volume;
};
 
class StopTextureMessage : public WeArtMessageObjectSpecific
{
 
public:
 
    static constexpr const char* ID = "stopTexture";
 
    virtual std::string getID() override { return ID; };
 
    virtual std::vector<std::string> getValues() override {
        std::vector<std::string> ret;
        ret.push_back(HandsideToString(handSide));
        ret.push_back(ActuationPointToString(actuationPoint));
        return ret;
    };
 
    virtual void setValues(std::vector<std::string>& values) override {
        assert(values.size() == 2);
        handSide = StringToHandside(values[0]);
        actuationPoint = StringToActuationPoint(values[1]);
    };
};
 
class TrackingMessage : public WeArtMessageNoParams
{
    // Closures
    uint8 RightThumbClosure;
    uint8 RightIndexClosure;
    uint8 RightMiddleClosure;
    uint8 RightPalmClosure;
    uint8 LeftThumbClosure;
    uint8 LeftIndexClosure;
    uint8 LeftMiddleClosure;
    uint8 LeftPalmClosure;
 
    // Abductions
    uint8 RightThumbAbduction;
    uint8 LeftThumbAbduction;
 
    TrackingType _trackingType;
 
public:
 
 
    static constexpr const char* ID = "Tracking";
 
    virtual std::string getID() override { return ID; };
 
    struct Angles {
        float X;
        float Y;
        float Z;
    };
 
    virtual std::vector<std::string> getValues() override {
        std::vector<std::string> ret;
        ret.push_back(std::to_string(RightThumbClosure));
        ret.push_back(std::to_string(RightIndexClosure));
        ret.push_back(std::to_string(RightMiddleClosure));
        ret.push_back(std::to_string(RightPalmClosure));
        ret.push_back(std::to_string(LeftThumbClosure));
        ret.push_back(std::to_string(LeftIndexClosure));
        ret.push_back(std::to_string(LeftMiddleClosure));
        ret.push_back(std::to_string(LeftPalmClosure));
        return ret;
    };
 
    virtual void setValues(std::vector<std::string>& values) override {
        _trackingType = StringToTrackingType(values[0]);
        switch (_trackingType) {
        case TrackingType::DEFAULT:
        {
            assert(values.size() == 8);
            RightThumbClosure = std::stoi(values[0]);
            RightIndexClosure = std::stoi(values[1]);
            RightMiddleClosure = std::stoi(values[2]);
            RightPalmClosure = std::stoi(values[3]);
            LeftThumbClosure = std::stoi(values[4]);
            LeftIndexClosure = std::stoi(values[5]);
            LeftMiddleClosure = std::stoi(values[6]);
            LeftPalmClosure = std::stoi(values[7]);
            break;
        }
        case TrackingType::WEART_HAND:
        {
            assert(values.size() == 9);
            // Right
            RightIndexClosure = std::stoi(values[1]);
            RightThumbClosure = std::stoi(values[2]);
            RightThumbAbduction = std::stoi(values[3]);
            RightMiddleClosure = std::stoi(values[4]);
 
            // Left
            LeftIndexClosure = std::stoi(values[5]);
            LeftThumbClosure = std::stoi(values[6]);
            LeftThumbAbduction = std::stoi(values[7]);
            LeftMiddleClosure = std::stoi(values[8]);
        }
        }
    };
 
    float GetClosure(EHandSide handSide, EActuationPoint actuationPoint) {
        uint8 byteValue = 0x00;
        switch (handSide)
        {
        case EHandSide::Left:
            switch (actuationPoint)
            {
            case EActuationPoint::Thumb:  byteValue = LeftThumbClosure;  break;
            case EActuationPoint::Index:  byteValue = LeftIndexClosure;  break;
            case EActuationPoint::Middle: byteValue = LeftMiddleClosure; break;
            case EActuationPoint::Palm:   byteValue = LeftPalmClosure;   break;
            }
            break;
        case EHandSide::Right:
            switch (actuationPoint)
            {
            case EActuationPoint::Thumb:  byteValue = RightThumbClosure;  break;
            case EActuationPoint::Index:  byteValue = RightIndexClosure;  break;
            case EActuationPoint::Middle: byteValue = RightMiddleClosure; break;
            case EActuationPoint::Palm:   byteValue = RightPalmClosure;   break;
            }
            break;
        }
 
        float num(byteValue);
        float denom(255);
        return num / denom;
    }
 
    float GetAbduction(EHandSide handSide, EActuationPoint actuationPoint) {
        float maxAbductionValue = 255;
        switch (handSide) {
        case EHandSide::Left:
            if (actuationPoint == EActuationPoint::Thumb)  return ((float)LeftThumbAbduction) / maxAbductionValue;
            break;
        case EHandSide::Right:
            if (actuationPoint == EActuationPoint::Thumb)  return ((float)RightThumbAbduction) / maxAbductionValue;
            break;
        }
        return 0.0f;
    }
};
 
class RawDataOn : public WeArtJsonMessage {
public:
    static constexpr const char* ID = "RAW_DATA_ON";
 
    virtual std::string getID() override { return ID; }
    virtual void setHandSide(EHandSide hs) override {}
    virtual void setActuationPoint(EActuationPoint ap) override {}
};
 
class RawDataOff : public WeArtJsonMessage {
public:
    static constexpr const char* ID = "RAW_DATA_OFF";
 
    virtual std::string getID() override { return ID; }
    virtual void setHandSide(EHandSide hs) override {}
    virtual void setActuationPoint(EActuationPoint ap) override {}
};
 
class RawSensorsData : public WeArtJsonMessage {
public:
    static constexpr const char* ID = "RAW_DATA";
 
    virtual std::string getID() override { return ID; };
    virtual void setHandSide(EHandSide hs) override { hand = hs; }
    virtual void setActuationPoint(EActuationPoint ap) override {}
 
    EHandSide getHand() { return hand; }
    bool hasSensor(EActuationPoint ap);
    SensorData getSensor(EActuationPoint ap);
 
protected:
    virtual nlohmann::json serializePayload() override;
    virtual void deserializePayload(nlohmann::json payload) override;
 
    EHandSide hand;
    std::map<EActuationPoint, SensorData> sensors;
};
 
class GetMiddlewareStatus : public WeArtJsonMessage {
public:
    GetMiddlewareStatus() : WeArtJsonMessage() {}
 
    static constexpr const char* ID = "MW_GET_STATUS";
    virtual std::string getID() override { return ID; };
};
 
class MiddlewareStatusMessage : public WeArtJsonMessage {
public:
    MiddlewareStatusMessage() : WeArtJsonMessage() {}
 
    static constexpr const char* ID = "MW_STATUS";
    virtual std::string getID() override { return ID; };
 
    MiddlewareStatusData data() { return _data; }
 
protected:
    virtual nlohmann::json serializePayload() override;
    virtual void deserializePayload(nlohmann::json payload) override;
 
private:
    MiddlewareStatusData _data;
};
 
class GetDevicesStatusMessage : public WeArtJsonMessage {
public:
    GetDevicesStatusMessage() : WeArtJsonMessage() {}
    static constexpr const char* ID = "DEVICES_GET_STATUS";
    virtual std::string getID() override { return ID; };
};
 
class DevicesStatusMessage : public WeArtJsonMessage {
public:
    DevicesStatusMessage() : WeArtJsonMessage() {}
 
    static constexpr const char* ID = "DEVICES_STATUS";
    virtual std::string getID() override { return ID; };
 
    std::vector<ConnectedDeviceStatus> devices() { return _devices; }
 
protected:
    virtual nlohmann::json serializePayload() override;
    virtual void deserializePayload(nlohmann::json payload) override;
 
private:
    std::vector<ConnectedDeviceStatus> _devices;
};