ArServerHandlerCamera.h

Go to the documentation of this file.

/*
MobileRobots Advanced Robotics Interface for Applications (ARIA)
Copyright (C) 2004, 2005 ActivMedia Robotics LLC
Copyright (C) 2006, 2007 MobileRobots Inc.

     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.

     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.

     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

If you wish to redistribute ARIA under different terms, contact 
MobileRobots for information about a commercial version of ARIA at 
robots@mobilerobots.com or 
MobileRobots Inc, 19 Columbia Drive, Amherst, NH 03031; 800-639-9481
*/

#ifndef ARSERVERHANDLERCAMERA_H
#define ARSERVERHANDLERCAMERA_H

#include "Aria.h"

#include "ArNetworking.h"

class ArServerHandlerCamera : public ArCameraCollectionItem
{
private:
  static const char *CONTROL_COMMAND_GROUP;
  static const char *INFO_COMMAND_GROUP;
  static const char *NO_ARGS;
public:


  AREXPORT ArServerHandlerCamera(const char *cameraName,
                                 ArServerBase *server,
                                 ArRobot *robot,
                                 ArPTZ *camera,
                                 ArCameraCollection *collection);


  AREXPORT ArServerHandlerCamera(ArServerBase *server, 
                                 ArRobot *robot, 
                                                         ArPTZ *camera);

  AREXPORT virtual ~ArServerHandlerCamera();

  // -----------------------------------------------------------------------------
  // ArCameraCollectionItem Interface:
  // -----------------------------------------------------------------------------

  AREXPORT void setCameraAbs(double pan, double tilt, double zoom, 
                               bool lockRobot = true);

  AREXPORT void setCameraRel(double pan, double tilt, double zoom, 
                             bool lockRobot = true);

  AREXPORT void setCameraPct(double panPct, double tiltPct, 
                             bool lockRobot = true);

  AREXPORT void resetCamera(bool lockRobot = true);

  AREXPORT void cameraModeLookAtGoal(void);

  AREXPORT void cameraModeLookAtPoint(ArPose pose);

  AREXPORT void cameraModeLookAtGoalSetGoal(ArPose pose);
  AREXPORT void cameraModeLookAtGoalClearGoal(void);

  AREXPORT void cameraModePosition(void);







  AREXPORT const char *getCameraName();


  AREXPORT virtual void addToCameraCollection(ArCameraCollection &collection);


  // -----------------------------------------------------------------------------
  // Packet Handlers:
  // -----------------------------------------------------------------------------

  // New methods that send/receive "double"s


  AREXPORT void handleGetCameraData(ArServerClient *client, ArNetPacket *packet);


  AREXPORT void handleGetCameraInfo(ArServerClient *client, ArNetPacket *packet);


  AREXPORT void handleSetCameraAbs(ArServerClient *client, ArNetPacket *packet);


  AREXPORT void handleSetCameraPct(ArServerClient *client, ArNetPacket *packet);


  AREXPORT void handleSetCameraRel(ArServerClient *client, ArNetPacket *packet);


  AREXPORT void handleGetCameraModeList(ArServerClient *client, ArNetPacket *packet);


  AREXPORT void handleCameraModeUpdated(ArServerClient *client, 
                                                                      ArNetPacket *packet);


  AREXPORT void handleSetCameraMode(ArServerClient *client, 
                                                            ArNetPacket *packet);


  AREXPORT void handleResetCamera(ArServerClient *client, 
                                                          ArNetPacket *packet);
  // Old methods that send/receive ints

  AREXPORT void camera(ArServerClient *client, ArNetPacket *packet);
  AREXPORT void cameraAbs(ArServerClient *client, ArNetPacket *packet);
  AREXPORT void cameraPct(ArServerClient *client, ArNetPacket *packet);
  AREXPORT void cameraUpdate(ArServerClient *client, ArNetPacket *packet);
  AREXPORT void cameraInfo(ArServerClient *client, ArNetPacket *packet);

protected:


  // -----------------------------------------------------------------------------
  // Helper Methods:
  // -----------------------------------------------------------------------------

  enum {
    DOUBLE_FACTOR = 100 
  };


  AREXPORT void addDoubleToPacket(double val,
                                  ArNetPacket &packet)
  {
    // TODO: Does this need to be rounded? Any error/overflow checking?
    packet.byte2ToBuf((ArTypes::Byte2) (val * DOUBLE_FACTOR));
  }
  


  AREXPORT double getDoubleFromPacket(ArNetPacket &packet)
  {
    int tempVal = packet.bufToByte2();
    return ((double) tempVal / (double) DOUBLE_FACTOR);
  }

  AREXPORT double getCurrentZoomRatio()
  {
    if (myCamera->getMaxZoom() != myCamera->getMinZoom()) {

     return ((double)(myCamera->getZoom() -  myCamera->getMinZoom()))
             / ((double)(myCamera->getMaxZoom() - myCamera->getMinZoom()));
    }
    else {
      return 0;
    }
  } // end method getCurrentZoomRatio
 

  AREXPORT double getZoomRatio(double absZoom)
  {
    if (myCamera->getMaxZoom() != myCamera->getMinZoom()) {

      return ((double)(absZoom - myCamera->getMinZoom()))
              / ((double)(myCamera->getMaxZoom() - myCamera->getMinZoom()));
    }
    else {
      return 0;
    }
  } // end method getZoomRatio


  AREXPORT double getZoomRange()
  {
    return myCamera->getMaxZoom() - myCamera->getMinZoom();

  } // end method getZoomRange


private:
  
  void init();

  void createCommandNames();

  void createCommandCBs();

  void addAllCommandsToServer();
  
  void addCommandToServer(const char *command, 
                          const char *description,
                                                  const char *argumentDescription,
                                                  const char *returnDescription,
                          const char *commandGroup);

  void removeCommand(const char *command);

  void doAddToCameraCollection(ArCameraCollection &collection);

protected:

  ArRobot *myRobot;
  ArServerBase *myServer;
  ArPTZ *myCamera;

  std::string myCameraName;
  ArCameraCollection *myCameraCollection;

  std::map<std::string, std::string> myCommandToPacketNameMap;
  std::map<std::string, int> myCommandToIntervalMap;

  std::map<std::string, ArFunctor2<ArServerClient *, ArNetPacket *> *> myCommandToCBMap;

  enum CameraMode
  {
    CAMERA_MODE_POSITION,
    CAMERA_MODE_LOOK_AT_GOAL,
    CAMERA_MODE_LOOK_AT_POINT
  };
  
  ArMutex myModeMutex;
  CameraMode myCameraMode;
  std::map<CameraMode, std::string> myCameraModeNameMap;
  ArNetPacket myCameraModePacket;
  ArPose myLookAtPoint;
  bool myPointResetZoom;
  ArPose myGoal;
  bool myGoalAchieved;
  bool myGoalAchievedLast;
  bool myGoalResetZoom;


  void userTask(void);
  void buildModePacket(void);

  ArFunctorC<ArServerHandlerCamera> myUserTaskCB;

  // Leaving these just in case they are used by someone... 


  ArFunctor2C<ArServerHandlerCamera, 
      ArServerClient *, ArNetPacket *> myCameraCB;

  ArFunctor2C<ArServerHandlerCamera, 
      ArServerClient *, ArNetPacket *> myCameraAbsCB;

  ArFunctor2C<ArServerHandlerCamera, 
      ArServerClient *, ArNetPacket *> myCameraUpdateCB;

  ArFunctor2C<ArServerHandlerCamera, 
      ArServerClient *, ArNetPacket *> myCameraInfoCB;

}; // end class ArServerHandlerCamera

#endif 

---