ArDetector.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 "ArManager.h"
#include "ArDetector.h"
 
#include <vector>
 
//aruco::DFCMarkerTracker()
ArDetector::ArDetector() : aruco::MarkerDetector(), btopenutils::Thread()
{
  needUpdate = false;
  mSlowUpdateDetected = false;
 
  aruco::MarkerDetector::Params params;
  params.setDetectionMode(aruco::DM_NORMAL, 0.05f);
  //params.setAutoSizeSpeedUp(true);
  params.setCornerRefinementMethod(aruco::CORNER_LINES);
  params.detectEnclosedMarkers(false);
  //params.trackingMinDetections = 3;
  
  /*
  //DFC tracker
  aruco::MarkerDetector &detector = getDetector();
  detector.setParameters(params);
  detector.setDictionary(aruco::Dictionary::ARUCO, 0.2f);
  */
 
  //Classic detector
  setParameters(params);
  setDictionary(aruco::Dictionary::ARUCO, 0.2f);
 
  // Run thread
  StartThreading(boost::bind(&ArDetector::GoThread, this));
}
 
ArDetector::~ArDetector()
{
  StopThreading();
}
 
void ArDetector::GoThread()
{
  while (IsRunning())
  {
    if (needUpdate)
    {
      ArManager* manager = ArManager::GetInstance();
      manager->GetLastData(mLastData);
      needUpdate = false;
      
      //cv::undistort(mLastData.gray, mLastData.gray, mLastData.camParam.CameraMatrix, mLastData.camParam.Distorsion);
 
      /*float scale = 1.0f;
 
      int maxsize = std::max(mLastData.camParam.CamSize.width, mLastData.camParam.CamSize.height);
      if (maxsize > 640)
        scale = 640.0f / (float)maxsize;
 
      cv::Size nsize;
      nsize.width = (int)((float)mLastData.gray.cols * scale);
      nsize.height = (int)((float)mLastData.gray.rows * scale);
      
      mLastData.camParam.resize(nsize);
 
      if (scale != 1.0f)
        cv::resize(mLastData.gray, mLastData.gray, mLastData.camParam.CamSize, 0, 0, cv::INTER_LINEAR);
      */
 
            // List of dectected markers
            std::vector<aruco::Marker> detectedMarkers;
 
      //simple aruco detection
      try
      {
        /*
        //DFC tracker
        setParams(mLastData.arCamParam.camParam, -1);
        estimatePose();
        std::map<int, cv::Ptr<TrackerImpl>> trackers = track(mLastData.gray);
 
        detectedMarkers.clear();
        for (auto m : trackers)
        {
          detectedMarkers.push_back(m.second->getMarker());
        }
        */
 
        //Classic detector
        detectedMarkers = detect(mLastData.gray, mLastData.arCamParam.camParam, -1);
      }
      catch (cv::Exception &e)
      {
        MMechostr(MSKDEBUG, "ArDetector::GoThread() : detect > %s", e.what());
      }
      manager->updateFiducialMarkers(detectedMarkers, mLastData);
    }
    else
    {
      //prevent cpu burn
      boost::this_thread::sleep_for(boost::chrono::milliseconds(1)); //DO not burn too much CPU
    }
  }
}