Camera.hh

/*
 * Copyright 2011 Nate Koenig & Andrew Howard
 *
 * 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.
 *
*/
/* Desc: A persepective OGRE Camera
 * Author: Nate Koenig
 * Date: 15 July 2003
 */

#ifndef RENDERING_CAMERA_HH
#define RENDERING_CAMERA_HH

#include <boost/enable_shared_from_this.hpp>

#include "common/Event.hh"
#include "common/Time.hh"

#include "math/Angle.hh"
#include "math/Pose.hh"
#include "math/Vector2i.hh"

#include "msgs/MessageTypes.hh"
#include "rendering/RenderTypes.hh"
#include "sdf/sdf.h"

// Forward Declarations
namespace Ogre
{
  class Texture;
  class RenderTarget;
  class Camera;
  class Viewport;
  class SceneNode;
}

namespace gazebo
{
    namespace rendering
  {
    class MouseEvent;
    class ViewController;
    class Scene;


    class Camera : public boost::enable_shared_from_this<Camera>
    {
      public: Camera(const std::string &namePrefix, Scene *scene,
                     bool _autoRender=true);
    
      public: virtual ~Camera();
    
      public: void Load( sdf::ElementPtr &_sdf );

      public: void Load();
  
      public: void Init();

      public: void SetRenderRate(double _hz);

      public: void Render();
      protected: virtual void RenderImpl();
  
      public: virtual void PostRender();
  
      public: virtual void Update();
    
      public: void Fini();

      public: void SetWindowId( unsigned int windowId );

      public: unsigned int GetWindowId() const;

      public: void SetScene( Scene *scene );
  
      public: math::Pose GetWorldPose();
  
      public: math::Vector3 GetWorldPosition() const;

      public: math::Quaternion GetWorldRotation() const;
  
      public: void SetWorldPose(const math::Pose &_pose);
  
      public: void SetWorldPosition(const math::Vector3 &_pos);
  
      public: void SetWorldRotation(const math::Quaternion &_quant);
  
    
      public: void Translate( const math::Vector3 &direction );
    
      public: void RotateYaw( float angle );
    
      public: void RotatePitch( float angle );
  
      public: void SetClipDist(float near, float far);

      public: void SetClipDist();
  
      public: void SetHFOV(float radians);
  
      public: math::Angle GetHFOV() const;
  
      public: math::Angle GetVFOV() const;
  
      public: void SetImageSize(unsigned int _w, unsigned int _h);

      public: void SetImageWidth( unsigned int _w );

      public: void SetImageHeight( unsigned int _h );

      public: unsigned int GetImageWidth() const;
    
      public: unsigned int GetTextureWidth() const;
    
      public: unsigned int GetImageHeight() const;
    
      public: unsigned int GetImageDepth() const;
  
      public: std::string GetImageFormat() const;
  
      public: unsigned int GetTextureHeight() const;
    
      public: size_t GetImageByteSize() const;

      public: static size_t GetImageByteSize(unsigned int _width, 
                                      unsigned int _height, 
                                      const std::string &_format);

      public: double GetZValue(int x, int y);
    
      public: double GetNearClip();
    
      public: double GetFarClip();
    
      public: void EnableSaveFrame(bool enable);
   
      public: void SetSaveFramePathname(const std::string &pathname);
  
      public: Ogre::Camera *GetOgreCamera() const;

      public: Ogre::Viewport *GetViewport() const;
  
      public: unsigned int GetViewportWidth() const;
  
      public: unsigned int GetViewportHeight() const;
  
      public: math::Vector3 GetUp();
  
      public: math::Vector3 GetRight();
  
      public: virtual float GetAvgFPS() { return 0;}
  
      public: virtual unsigned int GetTriangleCount() {return 0;}
  
      public: void SetAspectRatio( float ratio );

      public: float GetAspectRatio() const;

      public: void SetSceneNode( Ogre::SceneNode *node );
  
      public: Ogre::SceneNode *GetSceneNode() const;
  
      public: virtual const unsigned char *GetImageData(unsigned int i=0);
  
      public: std::string GetName() const;
  
      public: void SetName( const std::string &name );
             
      public: void ToggleShowWireframe();
  
      public: void ShowWireframe(bool s);

      public: void GetCameraToViewportRay(int screenx, int screeny,
                                          math::Vector3 &origin,
                                          math::Vector3 &dir);
  
      public: void SetCaptureData( bool value );
  
      public: void CreateRenderTexture( const std::string &textureName );
  
      public: Scene *GetScene() const;
  
      public: bool GetWorldPointOnPlane(int _x, int _y, 
                  const math::Vector3 &_planeNorm, double _d, 
                  math::Vector3 &_result);
  
      public: virtual void SetRenderTarget( Ogre::RenderTarget *target );

      public: void AttachToVisual( const std::string &_visualName, 
                  bool _inheritOrientation,
                  double _minDist=0, double _maxDist=0 );

      public: void TrackVisual( const std::string &_visualName);

      public: Ogre::Texture *GetRenderTexture() const;

      public: math::Vector3 GetDirection() const;

      public: template<typename T>
              event::ConnectionPtr ConnectNewImageFrame( T subscriber )
              { return newImageFrame.Connect(subscriber); }
  
      public: void DisconnectNewImageFrame( event::ConnectionPtr &c )
              { newImageFrame.Disconnect(c); }

      public: static void SaveFrame(const unsigned char *_image,
                  unsigned int _width, unsigned int _height, int _depth,
                  const std::string &_format,
                  const std::string &_filename);


      public: common::Time GetLastRenderWallTime();

      public: bool IsVisible(VisualPtr _visual);

      public: bool IsVisible(const std::string &_visualName);

      public: bool GetInitialized() const;

      protected: bool TrackVisualImpl( const std::string &_visualName);

      protected: virtual bool TrackVisualImpl( VisualPtr _visual );

      protected: virtual bool AttachToVisualImpl( const std::string &_name,
                     bool _inheritOrientation,
                     double _minDist=0, double _maxDist=0 );

      protected: virtual bool AttachToVisualImpl( VisualPtr _visual,
                     bool _inheritOrientation,
                     double _minDist=0, double _maxDist=0 );

      private: void ConvertRGBToBAYER(unsigned char* dst, unsigned char* src,
                                      std::string format,int width, int height);

      private: static int GetOgrePixelFormat( const std::string &_format );
  
      // Save the camera frame
      protected: virtual void SaveFrame();

      // Create the ogre camera
      private: void CreateCamera();
  
      private: std::string name;
      protected: sdf::ElementPtr sdf;

      protected: unsigned int windowId;
  
      protected: unsigned int textureWidth, textureHeight;
    
      protected: Ogre::Camera *camera;
      protected: Ogre::Viewport *viewport;
      protected: Ogre::SceneNode *origParentNode;
      protected: Ogre::SceneNode *sceneNode;
      protected: Ogre::SceneNode *pitchNode;
    
    
      // Info for saving images
      protected: unsigned char *saveFrameBuffer;
      protected: unsigned char *bayerFrameBuffer;
      protected: unsigned int saveCount;
   
      protected: int imageFormat;
      protected: int imageWidth, imageHeight;
  
      protected: Ogre::RenderTarget *renderTarget;
  
      protected: Ogre::Texture *renderTexture;
  
      private: static unsigned int cameraCounter;
      private: unsigned int myCount;
  
      protected: bool captureData;
  
      protected: bool newData;
  
      protected: common::Time lastRenderWallTime;

      protected: Scene *scene;

      protected: event::EventT<void(const unsigned char *,
                     unsigned int, unsigned int, unsigned int,
                     const std::string &)> newImageFrame;

      protected: std::vector<event::ConnectionPtr> connections;
      protected: std::list<msgs::Request> requests;
      private: friend class Scene;

      private: sdf::ElementPtr imageElem;

      public: bool initialized;
    };
    
  }
}
#endif