vpAROgre.h

/****************************************************************************
 *
 * $Id: vpAROgre.h 3677 2012-04-06 13:17:57Z bdelabar $
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2012 by INRIA. All rights reserved.
 * 
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * ("GPL") version 2 as published by the Free Software Foundation.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact INRIA about acquiring a ViSP Professional 
 * Edition License.
 *
 * See http://www.irisa.fr/lagadic/visp/visp.html for more information.
 * 
 * This software was developed at:
 * INRIA Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 * http://www.irisa.fr/lagadic
 *
 * If you have questions regarding the use of this file, please contact
 * INRIA at visp@inria.fr
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *
 * Description:
 * Augmented Reality viewer using Ogre3D.
 *
 * Authors:
 * Bertrand Delabarre
 *
 *****************************************************************************/

#ifndef __VP_AROGRE__
#define __VP_AROGRE__

#include <visp/vpConfig.h>

#ifdef VISP_HAVE_OGRE
#include <list>

#include <visp/vpImage.h>
#include <visp/vpImageConvert.h>
#include <visp/vpRGBa.h>

#include <visp/vpImageTools.h>
#include <visp/vpHomogeneousMatrix.h>
#include <visp/vpRotationMatrix.h>
#include <visp/vpRxyzVector.h>

#include <Ogre.h>
#include <OgreFrameListener.h>

#ifdef VISP_HAVE_OIS
#  include <OIS/OIS.h>
#endif

class VISP_EXPORT vpAROgre : public Ogre::FrameListener, public Ogre::WindowEventListener
#ifdef VISP_HAVE_OIS
               , public OIS::KeyListener
#endif
{
 public:    
  vpAROgre(const vpCameraParameters &cam = vpCameraParameters(), 
       unsigned int width = 640, unsigned int height = 480,
       const char* resourcePath = 
#ifdef VISP_HAVE_OGRE_RESOURCES_PATH
       VISP_HAVE_OGRE_RESOURCES_PATH,
#else
       ".",
#endif
       const char* pluginsPath = 
#ifdef VISP_HAVE_OGRE_PLUGINS_PATH
       VISP_HAVE_OGRE_PLUGINS_PATH
#else
       "."
#endif
       );
    
  virtual void init(vpImage<unsigned char> &I, bool bufferedKeys=false);
  virtual void init(vpImage<vpRGBa> &I, bool bufferedKeys=false);

  virtual ~vpAROgre(void);

  virtual bool customframeStarted(const Ogre::FrameEvent& evt);

  virtual bool customframeEnded(const Ogre::FrameEvent& evt);
    
#ifdef VISP_HAVE_OIS

  virtual bool keyPressed( const OIS::KeyEvent & /*e*/) { return true; }
  virtual bool keyReleased( const OIS::KeyEvent & /*e*/) {  return true; }
#endif

  virtual void windowClosed(Ogre::RenderWindow* rw);

  virtual void display(const vpImage<unsigned char> &I, 
           const vpHomogeneousMatrix &cMw);

  virtual void display(const vpImage<vpRGBa> &I, 
           const vpHomogeneousMatrix &cMw);

  void setCameraParameters(const vpCameraParameters &cameraP);

  void load(const std::string &name, const std::string &model);

  void setPosition(const std::string &name,
       const vpTranslationVector &wTo);
  void setPosition(const std::string &name, const vpHomogeneousMatrix &wMo);

  vpTranslationVector getPosition(const std::string &name)const;

  void setRotation(const std::string &name, const vpRotationMatrix &wRo);

  void addRotation(const std::string &name, const vpRotationMatrix &wRo);


  void setVisibility(const std::string &name, bool isVisible);

  void setScale(const std::string &name, const float factorx, const float factory, const float factorz);

  bool continueRendering(void);

  void getRenderingOutput(vpImage<vpRGBa> &I, vpHomogeneousMatrix &cMo);
  inline void setImageWidth(const unsigned int width){
    mWidth =width;
  }
  
  inline void setImageHeight(const unsigned int height){
    mHeight = height;
  }
  
  inline void setShowConfigDialog(const bool showConfigDialog){
    mshowConfigDialog = showConfigDialog;
  }

  inline void setResourcePath(const char* resourcePath){
    mResourcePath = resourcePath;
  }

  inline void setPluginsPath(const char* pluginsPath){
    mPluginsPath = pluginsPath;
  }


  inline void addResource(const std::string& resourceLocation){
    mOptionnalResourceLocation.push_back(resourceLocation);
  }
  
  inline void setWindowPosition(const unsigned int win_x, const unsigned int win_y){
    if(mWindow == NULL){
      throw vpException(vpException::notInitialized, "Window not initialised, cannot set its position");
    }
    mWindow->reposition(static_cast<int>(win_x), static_cast<int>(win_y));
  }
  
 protected:

  virtual void init(bool bufferedKeys=false);
  virtual void createCamera(void);

  virtual void createScene(void){};

  virtual void closeOIS(void);

  virtual bool updateScene(const Ogre::FrameEvent & /*evt*/) {return true;};

  virtual bool processInputEvent(const Ogre::FrameEvent & /*evt*/) {return true;};

  virtual bool destroyScene(void) {return true;};

  virtual void updateCameraProjection(void);

  virtual void updateBackgroundTexture(const vpImage<unsigned char> &I);

  virtual void updateBackgroundTexture(const vpImage<vpRGBa> &I);

  virtual void updateCameraParameters (const vpHomogeneousMatrix &cMo);

 private:

  void createBackground(vpImage<unsigned char> &I);
  void createBackground(vpImage<vpRGBa> &I);

  bool frameStarted(const Ogre::FrameEvent& evt);

  bool frameEnded( const Ogre::FrameEvent& evt);

  bool stopTest(const Ogre::FrameEvent& evt);

 protected:
  // Attributes

  // OGRE 3D System
  Ogre::Root*       mRoot;                         
  Ogre::Camera*     mCamera;                   
  Ogre::SceneManager* mSceneMgr;                 
  Ogre::RenderWindow* mWindow;                   
  Ogre::String      mResourcePath;             
  Ogre::String      mPluginsPath;             
#ifdef VISP_HAVE_OIS
  // OIS Input manager and devices
  OIS::InputManager* mInputManager;
  OIS::Keyboard*       mKeyboard;
#endif

  // ViSP AR System
  bool keepOn;                                   
  vpImage<vpRGBa> mImageRGBA;                    
  vpImage<unsigned char> mImage;                 
  Ogre::HardwarePixelBufferSharedPtr mPixelBuffer;   
  Ogre::Rectangle2D* mBackground;                
  unsigned int mHeight;                                   
  unsigned int mWidth;                                    
  // Camera calculations
  vpCameraParameters mcam;                       
  bool mshowConfigDialog;                         
  std::list<std::string> mOptionnalResourceLocation;  
};

#endif // VISP_HAVE_OGRE

#endif