alnaosim.h

#ifndef ALNAOSIM_H
#define ALNAOSIM_H
#include <qi/macro.hpp>

#ifdef alnaosim_EXPORTS
# define ALNAOSIM_API QI_EXPORT_API
#elif defined(alnaosim_IMPORTS)
# define ALNAOSIM_API QI_IMPORT_API
#else
# define ALNAOSIM_API
#endif

#include <string>
#include <vector>
#include "alnaosim_camera_definitions.h"

namespace Sim
{

  class AngleActuator;
  class AngleSensor;
  class AngleSpeedActuator;
  class AngleSpeedSensor;
  class ArrayDepthSensor;
  class BaseCamera;
  class BumperSensor;
  class TactileSensor;
  class CameraDepthSensor;
  class CameraSensor;
  class CameraDepthSensor;
  class CoupledActuator;
  class CoupledSensor;
  class FSRSensor;
  class InertialSensor;
  class SonarSensor;
  class Model;
  class TorqueActuator;
  class TorqueSensor;
  class WheelTorqueActuator;
  class WheelVelocityActuator;
  class WheelVelocitySensor;
  class LEDActuator;
  class SingleDepthSensor;

  typedef SingleDepthSensor DepthInfraredSensor;

class ALNAOSIM_API HALInterface
{
  public:
    HALInterface(const Model* model, int NAOqiId = 9559);
    ~HALInterface();

    float fetchAngleActuatorValue(const AngleActuator* angleActuator);
    float fetchCoupledActuatorValue(const CoupledActuator* coupledActuator);
    float fetchTorqueActuatorValue(const TorqueActuator* torqueActuator);
    float fetchAngleSpeedActuatorValue(
      const AngleSpeedActuator* angleSpeedActuator);
    float fetchWheelTorqueActuatorValue(
      const WheelTorqueActuator* wheelTorqueActuator);
    float fetchWheelVelocityActuatorValue(
      const WheelVelocityActuator* wheelVelocityActuator);
    float fetchLEDActuatorValue(const LEDActuator* ledActuator);

    float fetchAngleActuatorStiffness(const AngleActuator* angleActuator);
    float fetchCoupledActuatorStiffness(const CoupledActuator* coupledActuator);
    float fetchTorqueActuatorStiffness(const TorqueActuator* torqueActuator);
    float fetchAngleSpeedActuatorStiffness(
      const AngleSpeedActuator* angleSpeedActuator);
    float fetchWheelTorqueActuatorStiffness(
      const WheelTorqueActuator* wheelTorqueActuator);
    float fetchWheelVelocityActuatorStiffness(
      const WheelVelocityActuator* wheelVelocityActuator);

    bool sendAngleSensorValue(
      const AngleSensor* angleSensor, float value);
    bool sendCoupledSensorValue(
      const CoupledSensor* coupledSensor, float value);
    bool sendTorqueSensorValue(
      const TorqueSensor* torqueSensor, float value);
    bool sendAngleSpeedSensorValue(
      const AngleSpeedSensor* angleSpeedSensor, float value);
    bool sendWheelVelocitySensorValue(
      const WheelVelocitySensor* wheelVelocitySensor, float value);

    bool sendCameraSensorValue(
      const CameraSensor* cameraSensor, const unsigned char* img);
    bool sendCameraSensorValue(
      const CameraSensor* cameraSensor,
      const unsigned char* img,
      CameraResolution camResolution,
      CameraColorSpace camColorSpace);

    bool sendCameraDepthSensorValue(
      const CameraDepthSensor* cameraDepthSensor,
      const float* buffer);
    bool sendCameraDepthSensorValue(
      const CameraDepthSensor* cameraDepthSensor,
      const float* buffer,
      CameraResolution camResolution,
      CameraColorSpace camColorSpace);

    bool sendFSRSensorValue(
      const FSRSensor* fsrSensor, float value);
    bool sendBumperSensorValue(
      const BumperSensor* bumperSensor, float value);
    bool sendTactileSensorValue(
      const TactileSensor* tactileSensor, float value);
    bool sendDepthInfraredSensorValue(
      const DepthInfraredSensor* depthInfraredSensor, float value);
    bool sendSingleDepthSensorValue(
      const SingleDepthSensor* singleDepthSensor, float value);

    bool sendInertialSensorValues(
      const InertialSensor* inertialSensor, const std::vector<float>& values);
    bool sendSonarSensorValues(
      const SonarSensor* sonarSensor, const std::vector<float>& values);
    bool sendSonarSensorValue(const SonarSensor* sonarSensor, float value);

    bool sendArrayDepthSensorValues(
      const ArrayDepthSensor* arrayDepthSensor,
      const std::vector<float>& values);

    void cameraBufferSize(
      const CameraSensor* camera,
      int* cameraBufferSize,
      int* width,
      int* height);
    int cameraBufferSize(const CameraSensor* camera);

    void cameraDepthBufferSize(
      const CameraDepthSensor* camera,
      int* cameraBufferSize,
      int* width,
      int* height);

    CameraResolution cameraResolution(const BaseCamera* camera) const;
    CameraColorSpace cameraColorSpace(const BaseCamera* camera) const;

    class HALInterfaceImpl* a_impl;
};


void ALNAOSIM_API cameraResolution(CameraResolution camRes, int* width, int* height);

}
#endif // ALNAOSIM_H