CameraInputOpenCV.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser 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 Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser 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, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#include "CameraInputOpenCV.h"
 
#include <stdexcept>
 
#ifdef APPLE_IOS
  #include <QGuiApplication>
  #include <QScreen>
#endif
 
#ifdef ANDROID
static cv::Size calc_optimal_camera_resolution(const char* supported, int width, int height)
{
  int frame_width = 0;
  int frame_height = 0;
 
  size_t prev_idx = 0;
  size_t idx = 0;
  float min_diff = FLT_MAX;
 
  do
  {
    int tmp_width;
    int tmp_height;
 
    prev_idx = idx;
    while ((supported[idx] != '\0') && (supported[idx] != ','))
      idx++;
 
    sscanf(&supported[prev_idx], "%dx%d", &tmp_width, &tmp_height);
 
    int w_diff = width - tmp_width;
    int h_diff = height - tmp_height;
    if ((h_diff >= 0) && (w_diff >= 0))
    {
      if ((h_diff <= min_diff) && (tmp_height <= 720))
      {
        frame_width = tmp_width;
        frame_height = tmp_height;
        min_diff = h_diff;
      }
    }
 
    idx++; // to skip comma symbol
 
  } while (supported[idx - 1] != '\0');
 
  return cv::Size(frame_width, frame_height);
}
#endif
 
CameraInputOpenCV::CameraInputOpenCV(int index)
  : ICameraInput(index)
{
  mAutoUpdate = false;
  mUpdated = false;
  mVI = new cv::VideoCapture();
 
#ifdef APPLE_IOS
  mVI->set(cv::CAP_PROP_FORMAT, CV_8UC3);
  //mVI->set(cv::CAP_PROP_CONVERT_RGB, 1);
#endif
 
#ifdef USE_RASPICAM
  mPI = new raspicam::RaspiCam_Cv();
  mPI->set(cv::CAP_PROP_FORMAT, CV_8UC3);
  mPI->set(cv::CAP_PROP_CONVERT_RGB, 1);
#endif
 
  mBufferSize = cv::Size(640, 480);
}
 
bool CameraInputOpenCV::Initialize()
{
  bool ret = false;
 
#ifdef _WIN32
  ret = mVI->open(mIndex + cv::CAP_DSHOW);
#else
  ret = mVI->open(mIndex);
#endif
 
#ifdef USE_RASPICAM
  if (!ret)
    ret = mPI->open();
#endif
 
  if (ret)
  {
    // init default size (Pass the webcam in preview mode !!)
    SetSize(mBufferSize.width, mBufferSize.height);
  }
 
  return ret;
}
 
void CameraInputOpenCV::Close()
{
  mAutoUpdate = false;
  if (mThread.joinable())
    mThread.join();
 
#ifdef USE_RASPICAM
  mPI->release();
#endif
 
  mVI->release();
}
 
CameraInputOpenCV::~CameraInputOpenCV()
{
  Close();
  SAFE_DELETE(mVI);
 
#ifdef USE_RASPICAM
  SAFE_DELETE(mPI);
#endif
}
 
bool CameraInputOpenCV::IsOpened()
{
#ifdef USE_RASPICAM
  if (mPI->isOpened())
    return true;
#endif
  return mVI->isOpened();
}
 
void CameraInputOpenCV::UpdateThread()
{
  while (mAutoUpdate)
  {
    double tick = (double)cv::getTickCount();
    bool valid = false;
#ifdef USE_RASPICAM
    if (mPI->isOpened())
      valid = mPI->read(mBuffer);
    else
#endif
      valid = mVI->read(mBuffer);
 
    if (valid)
    {
      boost::upgrade_lock< boost::shared_mutex > lock(mMutex);
 
#ifdef APPLE_IOS
      QScreen* screen = QGuiApplication::primaryScreen();
      Qt::ScreenOrientation rotation = screen->orientation();
 
      //image mirror for front view is managed by user
      if ((rotation == Qt::LandscapeOrientation) && (mIndex == 0))
      {
        cv::transpose(mBuffer, mCachedFrame);
        cv::flip(mCachedFrame, mCachedFrame, 0);
      }
      else if ((rotation == Qt::LandscapeOrientation) && (mIndex == 1))
      {
        cv::transpose(mBuffer, mCachedFrame);
      }
      else if ((rotation == Qt::PortraitOrientation) && (mIndex == 1))
      {
        cv::flip(mBuffer, mCachedFrame, 1);
      }
      else if ((rotation == Qt::InvertedPortraitOrientation) && (mIndex == 0))
      {
        cv::flip(mBuffer, mCachedFrame, -1);
      }
      else if ((rotation == Qt::InvertedPortraitOrientation) && (mIndex == 1))
      {
        cv::flip(mBuffer, mCachedFrame, 0);
      }
      else if ((rotation == Qt::InvertedLandscapeOrientation) && (mIndex == 0))
      {
        cv::transpose(mBuffer, mCachedFrame);
        cv::flip(mCachedFrame, mCachedFrame, 1);
      }
      else if ((rotation == Qt::InvertedLandscapeOrientation) && (mIndex == 1))
      {
        cv::transpose(mBuffer, mCachedFrame);
        cv::flip(mCachedFrame, mCachedFrame, -1);
      }
      else
      {
        if (mBuffer.rows == mCachedFrame.rows && mBuffer.cols == mCachedFrame.cols)
          memcpy(mCachedFrame.data, mBuffer.data, mBuffer.rows * mBuffer.cols * 3);
        else
          mBuffer.copyTo(mCachedFrame);
      }
#else
      if (!mCachedFrame.empty() && (mBuffer.rows == mCachedFrame.rows && mBuffer.cols == mCachedFrame.cols))
        memcpy(mCachedFrame.data, mBuffer.data, mBuffer.rows * mBuffer.cols * 3);
      else
        mBuffer.copyTo(mCachedFrame);
#endif
      mUpdated = true;
      lock.unlock();
    }
    else
    {
      boost::upgrade_lock< boost::shared_mutex > lock(mMutex);
      mCachedFrame.release();
      lock.unlock();
    }
 
    //prevent cpu burn
    tick = ((double)cv::getTickCount() - tick) / cv::getTickFrequency();
    boost::this_thread::sleep_for(boost::chrono::milliseconds(std::max(16 - (int)(tick * 1000), 0))); //DO not burn too much CPU
  }
}
 
cv::Mat CameraInputOpenCV::UpdateImage()
{
  if (!IsOpened())
    throw std::logic_error("Device not initialised");
 
  boost::upgrade_lock< boost::shared_mutex > lock(mMutex);
  if (!mUpdated || mCachedFrame.empty())
  {
    mUpdated = false;
 
    lock.unlock();
    throw std::logic_error("Device has bad pixel buffer");
  }
 
  mUpdated = false;
 
  //OpenCV 2.4
  /*
#ifdef ANDROID
  if (!mVI->retrieve(frame, CV_CAP_ANDROID_COLOR_FRAME_BGR) || frame.empty())
    throw std::logic_error("frame is empty");
#else
  if (!mVI->retrieve(frame) || frame.empty())
    throw std::logic_error("frame is empty");
#endif
  */
 
  if (mRetrieveBuffer.rows == mCachedFrame.rows && mRetrieveBuffer.cols == mCachedFrame.cols)
    memcpy(mRetrieveBuffer.data, mCachedFrame.data, mCachedFrame.rows * mCachedFrame.cols * 3);
  else
    mCachedFrame.copyTo(mRetrieveBuffer);
 
  lock.unlock();
  return mRetrieveBuffer;
}
 
int CameraInputOpenCV::GetWidth()
{
  if (IsOpened())
  {
#ifdef APPLE_IOS
    QScreen* screen = QGuiApplication::primaryScreen();
    if (screen->primaryOrientation() == Qt::PortraitOrientation)
      return mBufferSize.height;
    else
      return mBufferSize.width;
#else
    return mBufferSize.width;
#endif
  }
  else
    return 0;
}
 
int CameraInputOpenCV::GetHeight()
{
  if (IsOpened())
  {
#ifdef APPLE_IOS
    QScreen* screen = QGuiApplication::primaryScreen();
    if (screen->primaryOrientation() == Qt::PortraitOrientation)
      return mBufferSize.width;
    else
      return mBufferSize.height;
#else
    return mBufferSize.height;
#endif
  }
  else
    return 0;
}
 
void CameraInputOpenCV::SetSize(int width, int height)
{
#ifdef APPLE_IOS
  //Iphone are too slowwwwwwww
  QScreen* screen = QGuiApplication::primaryScreen();
  if (screen->primaryOrientation() == Qt::PortraitOrientation)
  {
    int ow = width;
    width = height;
    height = ow;
  }
#endif
 
  if (IsOpened())
  {
    mAutoUpdate = false;
    mThread.join();
 
#ifdef RPI
    mBufferSize = cv::Size(width - (width % 320), height - (height % 240));
#else
    mBufferSize = cv::Size(width, height);
#endif
 
    if ((mBufferSize.width != 0) && (mBufferSize.height != 0))
    {
      try
      {
#ifdef USE_RASPICAM
        if (mPI->isOpened())
        {
          mPI->release();
          mPI->set(cv::CAP_PROP_FRAME_WIDTH, mBufferSize.width);
          mPI->set(cv::CAP_PROP_FRAME_HEIGHT, mBufferSize.height);
          mPI->open();
        }
        else
        {
#endif
          mVI->set(cv::CAP_PROP_FRAME_WIDTH, mBufferSize.width);
          mVI->set(cv::CAP_PROP_FRAME_HEIGHT, mBufferSize.height);
 
#ifdef USE_RASPICAM
        }
#endif
      }
      catch (std::exception &)
      {
        mBufferSize = cv::Size(640, 480);
      }
    }
    else
    {
      mBufferSize = cv::Size(640, 480);
    }
 
    //get real setted size
#ifdef USE_RASPICAM
    if (mPI->isOpened())
    {
      mBufferSize.width = mPI->get(cv::CAP_PROP_FRAME_WIDTH);
      mBufferSize.height = mPI->get(cv::CAP_PROP_FRAME_HEIGHT);
    }
    else
    {
#endif
    mBufferSize.width = mVI->get(cv::CAP_PROP_FRAME_WIDTH);
    mBufferSize.height = mVI->get(cv::CAP_PROP_FRAME_HEIGHT);
 
#ifdef USE_RASPICAM
    }
#endif
 
    MMechostr(MSKRUNTIME, "CameraInputOpenCV::SetSize: Creating output buffer with size %dx%d\n", mBufferSize.width, mBufferSize.height);
#ifdef APPLE_IOS
    mBuffer = cv::Mat(mBufferSize.width, mBufferSize.height, CV_8UC3);
#else
    mBuffer = cv::Mat(mBufferSize.height, mBufferSize.width, CV_8UC3);
#endif
 
    mAutoUpdate = true;
    mThread = boost::thread(boost::bind(&CameraInputOpenCV::UpdateThread, this));
  }
  else
  {
    mBufferSize = cv::Size(width, height);
#ifdef APPLE_IOS
    mBuffer = cv::Mat(mBufferSize.width, mBufferSize.height, CV_8UC3);
#else
    mBuffer = cv::Mat(mBufferSize.height, mBufferSize.width, CV_8UC3);
#endif
  }
 
  mCachedFrame.release();
  mUpdated = false;
}
 
bool CameraInputOpenCV::TakeSnapshot(std::string path)
{
  if (!IsOpened())
    return false;
 
  cv::Mat frame = UpdateImage();
  if (frame.empty())
    return false;
 
  if (!cv::imwrite(path, frame))
    return false;
 
  MMechostr(MSKRUNTIME, ">> Frame written to : %s\n", path.c_str());
  return true;
}