src/glove/devices/CyberGlove.hpp

/*************************************************************************************
 * Copyright (c) 2009-2010, Christian Wressnegger
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * The names of its contributors may not be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *************************************************************************************/

#ifndef __GLOVE_CYBERGLOVE_HPP_
#define __GLOVE_CYBERGLOVE_HPP_

#include "../config.hpp"

#include <string>
#include <vector>
#include <bitset>

#include "Device.hpp"

namespace glove {
namespace devices {

class API CyberGlove: public virtual Device {

public:
  enum Finger {
    THUMB = 0, INDEX, MIDDLE, RING, PINKY
  };

  enum Joint {
    METACARPAL = 0, PROXIMAL, DISTAL, ABDUCTION
  };

  enum Sensor {
    THUMB_METACARPAL = 0,
    THUMB_ROTATION = THUMB_METACARPAL,
    THUMB_OPPOSE = THUMB_METACARPAL,
    THUMB_PROXIMAL,
    THUMB_DISTAL,
    THUMB_ABDUCTION,
    INDEX_METACARPAL = 4,
    INDEX_PROXIMAL,
    INDEX_DISTAL,
    INDEX_ABDUCTION,
    MIDDLE_METACARPAL = 8,
    MIDDLE_PROXIMAL,
    MIDDLE_DISTAL,
    MIDDLE_ABDUCTION,
    RING_METACARPAL = 12,
    RING_PROXIMAL,
    RING_DISTAL,
    RING_ABDUCTION,
    PINKY_METACARPAL = 16,
    PINKY_PROXIMAL,
    PINKY_DISTAL,
    PINKY_ABDUCTION,
    PALM_ARCH = 20,
    WRIST_PITCH,
    WRIST_YAW
  };

  static const unsigned int numFingers;
  static const unsigned int maxNumberOfJointsPerFinger;
  static const unsigned int maxNumberOfSensorValues;
  static const unsigned int sensorRecordSize;

  class API Calibration {
  public:
    Calibration();
    virtual ~Calibration();

    virtual double map(const Finger f, const Joint j, const double value);

    virtual double map(const Sensor s, const double value);
    virtual void map(std::vector<double>& values);
  };

  static const std::string DEVICE_ID;

  class sensor_iterator {
    CyberGlove& glove;
    int sensorId;

  public:
    sensor_iterator(CyberGlove& glove);
    virtual ~sensor_iterator();

    sensor_iterator& operator=(const Sensor s);

    sensor_iterator& operator++();
    sensor_iterator operator++(int unused);
    sensor_iterator& operator+=(const unsigned int i);

    unsigned int operator*() const;

    bool operator==(sensor_iterator& itr);
    bool operator!=(sensor_iterator& itr);
  };

private:
  static CyberGlove::Calibration defaultCalib;

protected:
  CyberGlove::Calibration* calib;

public:
  static CyberGlove::Calibration* DEFAULT_CALIB;

  CyberGlove();
  virtual ~CyberGlove();

  virtual const std::bitset<24> getEnabledSensors() = 0;

  virtual unsigned int numSensors() = 0;
  virtual bool isTipless();

  virtual bool isRightHanded() = 0;
  virtual bool isLeftHanded() = 0;

  virtual bool isStreaming() = 0;

  virtual void setCalibration(CyberGlove::Calibration* c);

  virtual const std::vector<double> getValues() = 0;
  virtual double getValue(const Sensor s) = 0;
  virtual double getValue(const Finger f, const Joint j);

  virtual const std::vector<double> getAngles(const bool degree = false);
  virtual double getAngle(const Sensor s, const bool degree = false);
  virtual double getAngle(const Finger f, const Joint j, const bool degree = false);

  static Sensor toSensorId(const Finger f, const Joint j);
  virtual Sensor getSensorId(const Finger f, const Joint j);

  virtual std::string info() = 0;
  virtual std::pair<int, int> version() = 0;

  virtual const std::string& getTypeIdentifier() const;
  static std::string toString(const Finger f, const Joint j);
};

}
}

#endif /* __GLOVE_CYBERGLOVE_HPP_ */

---