Device.h

Go to the documentation of this file.

#ifndef _DEVICE_H_
#define _DEVICE_H_

#pragma once

#include <map>
#include <vector>
#include <string>
#include <memory>
#include <sstream>

#include "LumiverseCoreConfig.h"
#include "Logger.h"
#include "LumiverseType.h"
#include "types/LumiverseFloat.h"
#include "types/LumiverseEnum.h"
#include "types/LumiverseColor.h"
#include "types/LumiverseTypeUtils.h"
#include "lib/libjson/libjson.h"
#include "lib/Eigen/Dense"
using namespace std;

namespace Lumiverse {
  struct FocusPalette {
    FocusPalette() { }
    FocusPalette(string name, float pan, float tilt, string area, string system, string image) :
      _name(name), _pan(pan), _tilt(tilt), _area(area), _system(system), _image(image) {}

    string _name;
    float _pan;
    float _tilt;
    string _area;
    string _system;
    string _image;
  };

  class Device
  {
  public:
    Device(string id, unsigned int channel, string type);

    Device(string id, const JSONNode data);

    Device(const Device& other);

    Device(Device* other);

    Device(string id, Device* other);

    ~Device();

    std::ostream & operator<< (std::ostream &str) {
      str << toString();
      return str;
    };

    inline string getId() { return m_id; }

    inline unsigned int getChannel() { return m_channel; }
    
    inline void setChannel(unsigned int newChan) { m_channel = newChan; }

    inline string getType() { return m_type; }

    inline void setType(string newType) { m_type = newType; }

    template <class T>
    T* getParam(string param);

    bool getParam(string param, float& val);

    LumiverseType* getParam(string param);

    LumiverseFloat* getFloat(string param);

    LumiverseEnum* getEnum(string param);

    LumiverseColor* getColor(string param = "color");

    LumiverseOrientation* getOri(string param);

    bool setParam(string param, LumiverseType* val);

    bool setParam(string param, LumiverseFloat* val) { return setParam(param, (LumiverseType*)val); }

    bool setParam(string param, LumiverseEnum* val) { return setParam(param, (LumiverseType*)val); }
    
    bool setParam(string param, LumiverseColor* val) { return setParam(param, (LumiverseType*)val); }
    
    bool setParam(string param, LumiverseOrientation* val) { return setParam(param, (LumiverseType*)val); }

    // Mainly used for the python version of Lumiverse. 
    //bool setParam(string param, shared_ptr<LumiverseFloat>* val);
    //bool setParam(string param, shared_ptr<LumiverseEnum>* val);
    //bool setParam(string param, shared_ptr<LumiverseColor>* val);
    //bool setParam(string param, shared_ptr<LumiverseOrientation>* val);

    bool setParam(string param, float val);

    bool setParam(string param, string val, float val2 = -1.0f);

    bool setParam(string param, string val, float val2, LumiverseEnum::Mode mode, LumiverseEnum::InterpolationMode interpMode);

    bool setParam(string param, string channel, double val);

    bool setParam(string param, double x, double y, double weight = 1.0);

    bool addFloatParam(string name, float val, float def, float max = 1.0f, float min = 0.0f);

    bool addColorParam(string name, int m);

    bool setColorRGBRaw(string param, double r, double g, double b, double weight = 1.0);

    bool setColorRGB(string param, double r, double g, double b, double weight = 1.0, RGBColorSpace cs = sRGB);

    bool setColorHSV(string param, double H, double S, double V, double weight = 1.0);

    bool setColorWeight(string param, double weight);

    bool setRGBRaw(double r, double g, double b, double weight = 1.0);

    bool setIntensity(float val) { return setParam("intensity", val); }

    LumiverseFloat* getIntensity();

    bool setColorChannel(string param, string channel, double val);

      
    // Will need additional overloads for each new type. Which kinda sucks.
      
    void copyParamByValue(string param, LumiverseType* source);
      
    bool paramExists(string param);

    size_t numParams();

    vector<string> getParamNames();

    bool metadataExists(string key);

    bool getMetadata(string key, string& val);

    string getMetadata(string key);

    bool setMetadata(string key, string val);

    void deleteMetadata(string key);

    void deleteParameter(string key);

    void clearMetadataValues();

    void clearAllMetadata();

    size_t numMetadataKeys();

    vector<string> getMetadataKeyNames();

    void reset();

    string toString();

    JSONNode toJSON();

    unordered_map<string, LumiverseType*>& getRawParameters() { return m_parameters; }
      
    typedef function<void(Device*)> DeviceCallbackFunction;
    
    int addParameterChangedCallback(DeviceCallbackFunction func);
    
    int addMetadataChangedCallback(DeviceCallbackFunction func);

    void deleteParameterChangedCallback(int id);

    void deleteMetadataChangedCallback(int id);

    bool isIdentical(Device* d);

    Eigen::Vector3d getGelColor();

    void addFocusPalette(FocusPalette fp);

    FocusPalette* getFocusPalette(string name);

    void deleteFocusPalette(string name);

    void setFocusPalette(string name);

    vector<string> getFocusPaletteNames();

    FocusPalette* closestPalette();
      
  private:
    void setId(string newId) { m_id = newId; }

    void loadJSON(const JSONNode data);

    void loadParams(const JSONNode data);

    JSONNode parametersToJSON();

    JSONNode metadataToJSON();

    void onParameterChanged();
      
    void onMetadataChanged();
      
    // TODO: This should be built in to the set ID function at some point
    // Uniqueness isn't quite enforceable at the device level.
    string m_id;

    unsigned int m_channel;

    string m_type;

    // Type may change in the future as more specialized datatypes come up.
    unordered_map<string, LumiverseType*> m_parameters;

    map<string, string> m_metadata;
    
    map<int, DeviceCallbackFunction> m_onParameterChangedFunctions;
      
    map<int, DeviceCallbackFunction> m_onMetadataChangedFunctions;

    map<string, FocusPalette> m_fp;
  };

  // Template definition
  template <class T>
  T* Device::getParam(string param) {
    return dynamic_cast<T*>(getParam(param));
  }
}

#endif