ArCameraParam.h

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
 
-----------------------------------------------------------------------------
*/
 
#ifndef __BTK_ARCAMERAPARAM_H__
#define __BTK_ARCAMERAPARAM_H__
 
#include "Prerequisites.h"
#include <aruco.h>
#include <AR/ar.h>
 
 
struct ArImuData
{
  ArImuData() : m_gry(Vector3(0.0, 0.0, 0.0)), m_acc(Vector3(0.0, 0.0, 0.0)), m_delta(0.0) {};
  ArImuData(Vector3 _gry, Vector3 _acc, double delta) : m_gry(Vector3(_gry)), m_acc(Vector3(_acc)), m_delta(delta) {};
  Vector3 m_gry;
  Vector3 m_acc;
  double m_delta;
};
 
class ArCameraParam
{
        // Variable
        public :    
        protected:
 
        private:
                cv::Size bitmapSize;
                cv::Point2f clipping;
 
        //Functions
        public :
    ArCameraParam() {};
                ArCameraParam(int width, int height, float nearclip, float farclip, std::string yamlfile);
    ArCameraParam(int width, int height, float nearclip, float farclip, Vector2 &flength, Vector2 &center);
                ~ArCameraParam();
 
    ArCameraParam(const ArCameraParam& CI);
 
    aruco::CameraParameters GetCameraParameter();
 
                void SetCameraParameter(std::string yamlfile);
 
                cv::Size GetBitmapSize();
                void SetBitmapSize(int width, int height);
 
                cv::Point2f GetClipping();
                void SetClipping(float nearclip, float farclip);
 
                void GetProjectionMatrix(double m_proj[16], cv::Size screensize);
 
    void SetCameraQuat(BtQuaternion quat);
    BtQuaternion GetCameraQuat();
 
    void AddCameraImu(Vector3 gyro, Vector3 accel, double delta);
    std::vector<ArImuData> GetCameraImu() const;
    void ResetCameraImu();
 
    Vector3 GetCameraOffset();
    void SetCameraOffset(Vector3 offset);
 
        protected:
    BtQuaternion mCamQuat;
    std::vector<ArImuData> mImuData;
    Vector3 mCamOffset;
 
  public:
    aruco::CameraParameters camParam;
};
 
class LASTDATA
{
public:
  LASTDATA() : reversedBitmap(false), timeStamp(0.0), delta(0.0) {};
 
  LASTDATA(const LASTDATA &CI)
  {
    arCamParam = ArCameraParam(CI.arCamParam);
    reversedBitmap = CI.reversedBitmap;
    timeStamp = CI.timeStamp;
    delta = CI.delta;
 
    if (!CI.image.empty())
      CI.image.copyTo(image);
 
    if (!CI.gray.empty())
      CI.gray.copyTo(gray);
  }
 
  LASTDATA(cv::Mat &frm, ArCameraParam* camparam, bool reverse, double _timestamp, double _delta)
  {
    reversedBitmap = reverse;
    timeStamp = _timestamp;
    delta = _delta;
    arCamParam = ArCameraParam(*camparam);
 
    try
    {
      if (frm.channels() != 1)
        cv::cvtColor(frm, gray, cv::COLOR_BGR2GRAY);
      else
        frm.copyTo(gray);
 
      frm.copyTo(image);
    }
    catch(std::exception &)
    {
      // bad bitmap format
    }
  };
 
  ~LASTDATA()
  {
    image.release();
    gray.release();
  };
 
  bool reversedBitmap;
  double timeStamp;
  double delta;
  ArCameraParam arCamParam;
  cv::Mat image;
  cv::Mat gray;
};
 
 
#endif