posture_estimator.h

Go to the documentation of this file.

 
#ifndef SRC_POSTURE_ESTIMATOR_H_
#define SRC_POSTURE_ESTIMATOR_H_
 
#include <CppTimer.h>
#include <RemoteNotifyBroadcast.h>
#include <stdio.h>
 
#include <string>
#include <vector>
 
#include "intermediate_structures.h"
#include "opencv2/core.hpp"
#include "opencv2/imgproc.hpp"
 
namespace PostureEstimating {
 
struct ConnectedJoint {
  Joint joint;
  PostProcessing::Coordinate coord;
  float upper_angle;
  float lower_angle;
};
 
std::string stringJoint(Joint joint);
 
struct Pose {
  std::array<ConnectedJoint, JointMax + 1> joints;
};
 
enum PostureState { Good, Bad, Unset, Undefined, UndefinedAndUnset };
 
Pose createPose();
 
struct PoseStatus {
  Pose ideal_pose;
  Pose current_pose;
  Pose pose_changes;
  PostureState posture_state;
};
 
enum Colours { Red, Green, Blue, Grey };
 
class DelayTimer : public CppTimer {
 private:
 public:
  size_t time;  
  bool running =
      false;  
  explicit DelayTimer(size_t time);
  ~DelayTimer();
  void timerEvent();
  void countdown();
};
class MessageTimer : public CppTimer {
 private:
  std::vector<DelayTimer*>
      notificationTimers;  
  RemoteNotify::Broadcast*
      broadcaster;  
  std::string msg;  
 
 public:
  size_t time;  
  bool running =
      false;  
  MessageTimer(std::vector<DelayTimer*> timers,
               RemoteNotify::Broadcast* broadcast, std::string msg,
               size_t time);
  ~MessageTimer();
  void countdown();
  void stopCountdown();
  void timerEvent();
};
 
class StopTimer : public CppTimer {
 private:
  MessageTimer* toStop;  
 
 public:
  size_t time;  
  bool running =
      false;  
  StopTimer(MessageTimer* toStop, size_t time);
  ~StopTimer();
  void countdown();
  void stopCountdown();
  void timerEvent();
};
 
class PostureEstimator {
 private:
  std::array<cv::Scalar, 4> colours = {
      cv::Scalar(255, 0, 0), cv::Scalar(0, 255, 0), cv::Scalar(0, 0, 255),
      cv::Scalar(144, 144, 144)};
 
  RemoteNotify::Broadcast broadcaster;
  DelayTimer badPostureNotificationTimer;
  DelayTimer undefinedPostureNotificationTimer;
  MessageTimer badPostureTimer;
  MessageTimer undefinedPostureTimer;
  StopTimer stopBadPostureTimer;
  StopTimer stopUndefinedPostureTimer;
 
  float getLineAngle(PostProcessing::Coordinate coord1,
                     PostProcessing::Coordinate coord2);
 
  Pose createPoseFromResult(PostProcessing::ProcessedResults results);
 
  void update_current_pose(PostProcessing::ProcessedResults results);
 
  void calculatePoseChanges();
 
  void checkPostureState();
 
  void calculateChangesAndCheckPosture();
 
  PostureEstimating::PostureState updateCurrentPoseAndCheckPosture(
      PostProcessing::ProcessedResults results);
 
  void display_current_pose(PostureEstimating::Pose current_pose,
                            cv::Mat current_frame,
                            PostureEstimating::PostureState posture_state);
  void display_pose_changes_needed(PostureEstimating::Pose pose_changes,
                                   PostureEstimating::Pose current_pose,
                                   cv::Mat current_frame);
 
 public:
  PostureEstimator();
 
  ~PostureEstimator();
 
  Pose current_pose;
 
  Pose ideal_pose;
 
  Pose pose_changes;
 
  float pose_change_threshold;
 
  PostureEstimating::PostureState posture_state = UndefinedAndUnset;
 
  void update_ideal_pose(PostureEstimating::Pose pose);
 
  bool set_pose_change_threshold(float threshold);
 
  float get_pose_change_threshold(void);
 
  PoseStatus runEstimator(PostProcessing::ProcessedResults results);
 
  void analysePosture(PostureEstimating::PoseStatus pose_status,
                      cv::Mat current_frame);
};
}  // namespace PostureEstimating
#endif  // SRC_POSTURE_ESTIMATOR_H_