ArTkMarker.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
 
-----------------------------------------------------------------------------
*/
 
/*
 Toolkit based on OpenCV library
 First version : dec 2010
 Author : Bastien BOURINEAU
*/
 
#ifndef __BTK_ARTKMARKER_H__
#define __BTK_ARTKMARKER_H__
 
#include <vector>
#include <iostream>
#include "cameraparameters.h"
#include "ArMarker.h"
#include "Prerequisites.h"
#include <boost/thread.hpp>
#include <iostream>
 
#include <KPM/kpm.h>
#include <AR2/tracking.h>
#include <AR/arFilterTransMat.h>
 
class ArTkMarker : public ArMarker
{
protected:
  cv::Mat m_image;
  bool m_isTracked;
  bool m_isTrained;
public:
  std::vector<cv::Point2f> m_lastCorner;
 
  ArTkMarker(std::string filePath, unsigned int nid, float size, unsigned int maxFeatures = 600);
  
  ArTkMarker(cv::Mat tpl, unsigned int mid, float size, unsigned int maxFeatures = 600);
 
  ~ArTkMarker();
 
  void SetTrackedImage(cv::Mat tpl);
 
  void RegisterNextFrame(cv::Point point, cv::Size size);
  
  bool GetWarpedMarker(cv::Mat &image);
 
  bool RegisterCurrentFrame(const cv::Mat &frame, cv::Size camsize, float tscale = 1.0f);
  bool TrackFrame(AR2HandleT* ar2handle, const cv::Mat &color, const cv::Mat &frame, ArCameraParam &camParams, const bool &reverse);
  void StartTracking(cv::Mat color, const float camPose[3][4], ArCameraParam &camParams, const bool &reverse);
 
  int GetPageNum();
  void SetPageNum(int page);
  KpmRefDataSet* GetDataSet();
 
  bool SaveData(std::string path);
  bool IsTracked();
  bool IsTrained();
private:
  boost::recursive_mutex m_mutex;
  boost::recursive_mutex m_dataMutex;
  boost::recursive_mutex m_trainningMutex;
  boost::thread m_trainingThread;
  float mCamPose[3][4];
  ARdouble mTackingPos[3][4];
  int mNumGoodTracking;
  int m_pageNum;
  unsigned int m_maxFeatures;
  std::string m_file;
  cv::Mat m_warped;
 
  KpmRefDataSet* m_refDataSet;
  AR2SurfaceSetT* m_surfaceSet;
  AR2FeatureSetT* m_featureSet;
  ARFilterTransMatInfo* m_ftmi;
  bool m_cancelTrainning;
  std::vector<cv::Point2f> m_pcorners;
  cv::Size m_lastFrameSize;
 
  bool m_registerNextFrame;
  cv::Point m_cropPos;
  cv::Size m_cropSize;
  cv::Size m_imageSize;
  FilterDoubleExponentialDouble m_CornerSmoothers;
 
  bool initTrackingPicture();
 
  void CommonConstructor();
 
  void SetTracked(bool state);
 
  void SetTrainned(bool state);
 
  void ComputeMatrix(ArCameraParam &camParams, bool reverse);
 
  void WarpMarkerImage(cv::Mat color);
 
  bool LoadData(std::string filename);
};
 
class NFTDataLoader
{
public:
  NFTDataLoader(){};
  ~NFTDataLoader(){};
 
  bool LoadData(boost::filesystem::path path, KpmRefDataSet** refDataSetPtr, AR2SurfaceSetT** surfaceSetPtr);
private:
  bool LoadRefDataSet(boost::filesystem::path path, KpmRefDataSet** refDataSetPtr);
  bool LoadFeatureSet(boost::filesystem::path path, AR2SurfaceSetT** surfaceSetPtr);
  AR2FeatureSetT* ReadFeatureSet(boost::filesystem::path path);
  AR2ImageT* GetImageLayer(AR2ImageT* src, float dpi);
  AR2ImageSetT* GetImageSet(boost::filesystem::path path);
  AR2ImageSetT* LoadRawImageSet(FILE* fp);
};
 
#endif