/************************************************************************************
HumanFollow RT-Component
Copyright (c) 2010, Segway Japan, Ltd.
All rights reserved.

Contact us if you use this software for sell.
If you use this software not for sell, you can use this software under BSD lisence.
See the files LICENSE.TXT and LICENSE-BSD.TXT for more details.                     
************************************************************************************/
#ifndef HUMANFOLLOW_H
#define HUMANFOLLOW_H

#include <rtm/Manager.h>
#include <rtm/DataFlowComponentBase.h>
#include <rtm/CorbaPort.h>
#include <rtm/DataInPort.h>
#include <rtm/DataOutPort.h>
#include <rtm/idl/BasicDataTypeSkel.h>


#include <list>
#include "intellirobotStub.h"

#ifndef WIN32
#include "x11win.h"
#endif

// Service implementation headers
// <rtc-template block="service_impl_h">

// </rtc-template>

// Service Consumer stub headers
// <rtc-template block="consumer_stub_h">

// </rtc-template>

using namespace RTC;

class HumanFollow
  : public RTC::DataFlowComponentBase
{
 public:
  HumanFollow(RTC::Manager* manager);
  ~HumanFollow();

  // <rtc-template block="public_attribute">
  
  // </rtc-template>

  // <rtc-template block="public_operation">
  
  // </rtc-template>

  // The initialize action (on CREATED->ALIVE transition)
  // formaer rtc_init_entry() 
   virtual RTC::ReturnCode_t onInitialize();

  // The finalize action (on ALIVE->END transition)
  // formaer rtc_exiting_entry()
  // virtual RTC::ReturnCode_t onFinalize();

  // The startup action when ExecutionContext startup
  // former rtc_starting_entry()
  // virtual RTC::ReturnCode_t onStartup(RTC::UniqueId ec_id);

  // The shutdown action when ExecutionContext stop
  // former rtc_stopping_entry()
  // virtual RTC::ReturnCode_t onShutdown(RTC::UniqueId ec_id);

  // The activated action (Active state entry action)
  // former rtc_active_entry()
  virtual RTC::ReturnCode_t onActivated(RTC::UniqueId ec_id);

  // The deactivated action (Active state exit action)
  // former rtc_active_exit()
  virtual RTC::ReturnCode_t onDeactivated(RTC::UniqueId ec_id);

  // The execution action that is invoked periodically
  // former rtc_active_do()
  virtual RTC::ReturnCode_t onExecute(RTC::UniqueId ec_id);

  // The aborting action when main logic error occurred.
  // former rtc_aborting_entry()
  // virtual RTC::ReturnCode_t onAborting(RTC::UniqueId ec_id);

  // The error action in ERROR state
  // former rtc_error_do()
  // virtual RTC::ReturnCode_t onError(RTC::UniqueId ec_id);

  // The reset action that is invoked resetting
  // This is same but different the former rtc_init_entry()
  // virtual RTC::ReturnCode_t onReset(RTC::UniqueId ec_id);
  
  // The state update action that is invoked after onExecute() action
  // no corresponding operation exists in OpenRTm-aist-0.2.0
  // virtual RTC::ReturnCode_t onStateUpdate(RTC::UniqueId ec_id);

  // The action that is invoked when execution context's rate is changed
  // no corresponding operation exists in OpenRTm-aist-0.2.0
  // virtual RTC::ReturnCode_t onRateChanged(RTC::UniqueId ec_id);


 protected:
  // <rtc-template block="protected_attribute">
  
  // </rtc-template>

  // <rtc-template block="protected_operation">
  
  // </rtc-template>

  // Configuration variable declaration
  // <rtc-template block="config_declare">
  double m_Kspeed;
  double m_Kturn;
  double m_MAXspeed;
  double m_MAXturn;
  double m_Distance;
  int m_Mode;
  double m_Kcurve_svec;
  double m_Kcurve_evec;
  double m_PathVel;
  double m_PathTargetR;
  double m_PathTurn;
  double m_PathStopR;
  double m_PathTime;
  double m_IntervalTime;
  int m_imagew;
  int m_imageh;
  // </rtc-template>

  // DataInPort declaration
  // <rtc-template block="inport_declare">
  IIS::TimedPose2D m_HumanPose2DIIS;
  InPort<IIS::TimedPose2D> m_HumanPose2DIISIn;
  IIS::TimedPose2D m_RobotPose2DIIS;
  InPort<IIS::TimedPose2D> m_RobotPose2DIISIn;
  
  // </rtc-template>


  // DataOutPort declaration
  // <rtc-template block="outport_declare">
  TimedVelocity m_Velocity;
  OutPort<TimedVelocity> m_VelocityOut;
  IIS::TimedVelocity2D m_Velocity2DIIS;
  OutPort<IIS::TimedVelocity2D> m_Velocity2DIISOut;
  
  // </rtc-template>

  // CORBA Port declaration
  // <rtc-template block="corbaport_declare">
  
  // </rtc-template>

  // Service declaration
  // <rtc-template block="service_declare">
  
  // </rtc-template>

  // Consumer declaration
  // <rtc-template block="consumer_declare">
  
  // </rtc-template>

 private:
  int dummy;
  // <rtc-template block="private_attribute">
  
  // </rtc-template>

  // <rtc-template block="private_operation">
  
  // </rtc-template>

#ifndef WIN32
  x11win win;
#endif

  void ExecFOLLOW(double& front, double& steer);

  bool IsIntervalTime();
  void PathTRACE();
  void ExecTRACE(double& front, double& steer);
  void drawpath();

  //case of HumanPosIIS
  enum {
    MODE_FOLLOW   = 0,
    MODE_TRACE    = 1,
  };


  bool ready_robotpos;
  bool ready_humanpos;
  
  class path_point
  {
  public:
    double x;
    double y;
    double theta;

    path_point()
    {
      x = 0.0;
      y = 0.0;
      theta = 0.0;
    }
  };


  //laser
  const static int imagew = 640;
  const static int imageh = 480;
  unsigned long *image;

  const static int PIXEL_PER_METER = 50;


  int followid;

  std::list<path_point> pointlist;
  std::list<path_point>::iterator targetit;

  coil::TimeValue curtime;
  coil::TimeValue prevtime;
};


extern "C"
{
  void HumanFollowInit(RTC::Manager* manager);
};

#endif // HUMANFOLLOW_H
