SensorManager.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2012 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
#ifndef _GAZEBO_SENSORMANAGER_HH_
#define _GAZEBO_SENSORMANAGER_HH_
 
#include <boost/thread.hpp>
#include <string>
#include <vector>
#include <list>
#include <map>
#include <condition_variable>
 
#include <sdf/sdf.hh>
 
#include "gazebo/physics/PhysicsTypes.hh"
#include "gazebo/common/SingletonT.hh"
#include "gazebo/common/UpdateInfo.hh"
#include "gazebo/sensors/SensorTypes.hh"
#include "gazebo/sensors/Sensor.hh"
#include "gazebo/util/system.hh"
 
GZ_SINGLETON_DECLARE(GZ_SENSORS_VISIBLE, gazebo, sensors, SensorManager)
 
namespace gazebo
{
  namespace sensors
  {
    class GZ_SENSORS_VISIBLE SimTimeEvent
    {
      public: common::Time time;
 
      public: boost::condition_variable *condition;
    };
 
    class GZ_SENSORS_VISIBLE SimTimeEventHandler
    {
      public: SimTimeEventHandler();
 
      public: virtual ~SimTimeEventHandler();
 
      public: void AddRelativeEvent(const common::Time &_time,
                  boost::condition_variable *_var);
 
      private: void OnUpdate(const common::UpdateInfo &_info);
 
      private: boost::mutex mutex;
 
      private: std::list<SimTimeEvent*> events;
 
      private: event::ConnectionPtr updateConnection;
    };
 
    class GZ_SENSORS_VISIBLE SensorManager : public SingletonT<SensorManager>
    {
      private: SensorManager();
 
      private: virtual ~SensorManager();
 
      public: void Update(bool _force = false);
 
      public: double NextRequiredTimestamp();
 
      public: void Init();
 
      public: void RunThreads();
 
      public: void Stop();
 
      public: void Fini();
 
      public: bool Running() const;
 
      public: void GetSensorTypes(std::vector<std::string> &_types) const;
 
      public: std::string CreateSensor(sdf::ElementPtr _elem,
                                       const std::string &_worldName,
                                       const std::string &_parentName,
                                       uint32_t _parentId);
 
      public: void OnCreateSensor(sdf::ElementPtr _elem,
                                  const std::string &_worldName,
                                  const std::string &_parentName,
                                  const uint32_t _parentId);
 
      public: SensorPtr GetSensor(const std::string &_name) const;
 
      public: Sensor_V GetSensors() const;
 
      public: void RemoveSensor(const std::string &_name);
 
      public: void RemoveSensors();
 
      public: bool SensorsInitialized();
 
      public: void ResetLastUpdateTimes();
 
      private: void WaitForSensors(double _clk, double _dt);
 
      private: bool WaitForPrerendered(double _timeoutsec);
 
      private: void AddSensor(SensorPtr _sensor);
 
      private: class SensorContainer
               {
                 public: SensorContainer();
 
                 public: virtual ~SensorContainer();
 
                 public: void Init();
 
                 public: void Fini();
 
                 public: void Run();
 
                 public: void Stop();
 
                 public: bool Running() const;
 
                 public: virtual void Update(bool _force = false);
 
                 public: void AddSensor(SensorPtr _sensor);
 
                 public: SensorPtr GetSensor(const std::string &_name,
                                             bool _useLeafName = false) const;
 
                 public: bool RemoveSensor(const std::string &_name);
 
                 public: void RemoveSensors();
 
                 public: void ResetLastUpdateTimes();
 
                 private: void RunLoop();
 
                 public: Sensor_V sensors;
 
                 private: bool stop;
 
                 private: bool initialized;
 
                 private: boost::thread *runThread;
 
                 private: mutable boost::recursive_mutex mutex;
 
                 private: boost::condition_variable runCondition;
               };
 
      private: class ImageSensorContainer : public SensorContainer
               {
                 public: bool WaitForPrerendered(double _timeoutsec);
 
                 public: virtual void Update(bool _force = false);
 
                 private: std::condition_variable conditionPrerendered;
               };
 
      private: bool initialized;
 
      private: bool removeAllSensors;
 
      private: mutable boost::recursive_mutex mutex;
 
      private: Sensor_V initSensors;
 
      private: std::vector<std::string> removeSensors;
 
      private: typedef std::vector<SensorContainer*> SensorContainer_V;
 
      private: SensorContainer_V sensorContainers;
 
      private: friend class SingletonT<SensorManager>;
 
      private: friend class SensorContainer;
 
      private: SimTimeEventHandler *simTimeEventHandler;
 
      private: std::map<std::string, physics::WorldPtr> worlds;
 
      private: event::ConnectionPtr timeResetConnection;
 
      private: event::ConnectionPtr createSensorConnection;
 
      private: event::ConnectionPtr removeSensorConnection;
    };
  }
}
#endif