AdvancedMarkerGridDetector.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLMarkers/src/ICLMarkers/AdvancedMarkerGridDetector.h **
** Module : ICLMarkers                                             **
** Authors: Christof Elbrechter                                    **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.LGPL **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

#pragma once

#include <ICLMarkers/MarkerGridDetector.h>
#include <ICLUtils/Array2D.h>
#include <ICLUtils/ParamList.h>
#include <ICLUtils/VisualizationDescription.h>
#include <ICLMarkers/Fiducial.h>

namespace icl{
  namespace markers{

          class ICLMarkers_API AdvancedMarkerGridDetector : public MarkerGridDetector{
      public:
      typedef MarkerGridDetector Super;

          class ICLMarkers_API AdvancedGridDefinition : public Super::GridDefinition{
        utils::Size32f markerBounds; 


        utils::Size32f gridBounds;

        public:
        // empty constructor
        AdvancedGridDefinition(){}

        AdvancedGridDefinition(const utils::Size &numCells,
                               const utils::Size32f &markerBounds,
                               const utils::Size32f &gridBounds,
                               const std::vector<int> &markerIDs=std::vector<int>(),
                               const std::string &markerType="bch") ;

        const utils::Size32f &getMarkerBounds() const {
          return markerBounds;
        }
        const utils::Size32f &getGridBounds() const {
          return gridBounds;
        }

        utils::Rect32f getBounds(int x, int y) const;

      };

          class ICLMarkers_API Marker{
        int id;      
        bool found;  
        public:

        struct ICLMarkers_API KeyPoints{
          utils::Point32f ur;     
          utils::Point32f lr;     
          utils::Point32f ll;     
          utils::Point32f ul;     
          utils::Point32f center; 

          void setup(const utils::Point32f corners[4], const utils::Point32f &center);

          // internally used function that concatenates all points
          std::vector<utils::Point32f> data() const;

          // internally used function that concatenates all points (without the center point)
          std::vector<utils::Point32f> corners() const;

          void appendCornersTo(std::vector<utils::Point32f> &dst) const;

        };

        private:
        KeyPoints imagePts;
        KeyPoints gridPts;

        public:
        Marker();

        Marker(int id, const utils::Point32f gridPoints[4], const utils::Point32f &center);

        void setImagePoints(const utils::Point32f corners[4],
                            const utils::Point32f &center=utils::Point32f::null);

                inline bool operator<(const Marker &m) const { return id < m.id; }

        void setFound(bool found){
          this->found = found;
        }

        bool wasFound() const {
          return found;
        }

        const KeyPoints &getImagePoints() const{
          return imagePts;
        }
        const KeyPoints &getGridPoints() const {
          return gridPts;
        }

        KeyPoints &getImagePoints() {
          return imagePts;
        }


        void visTo(utils::VisualizationDescription &vd) const;

        void getImagePointsTo(utils::Point32f *dst) const;

        template<class Transform>
        inline void transformImagePointsTo(Marker &dst, Transform t) const{
          dst.imagePts.ur = t(imagePts.ur);
          dst.imagePts.lr = t(imagePts.lr);
          dst.imagePts.ll = t(imagePts.ll);
          dst.imagePts.ul = t(imagePts.ul);
          dst.imagePts.center = t(imagePts.center);
        }
      };

          class ICLMarkers_API MarkerGrid : public utils::Array2D<Marker>{
        typedef utils::Array2D<Marker> Super; 
        AdvancedGridDefinition gridDef;       

        public:
        MarkerGrid();

        MarkerGrid(const AdvancedGridDefinition &def);

        void init(const AdvancedGridDefinition &def);

        void update(const MarkerGridDetector::Result &r);

        const AdvancedGridDefinition &getGridDef() const {
          return gridDef;
        }

        const Marker &getMarker(int id) const ;

        utils::VisualizationDescription vis() const;

        template<class Transform>
        inline void transformImagePointsTo(MarkerGrid &dst, Transform t) const{
          if(getSize() != dst.getSize()){
            dst = MarkerGrid(gridDef);
          }
          for(int i=0;i<getDim();++i){
            operator[](i).transformImagePointsTo(dst[i],t);
          }
        }
      };

      AdvancedMarkerGridDetector();

      AdvancedMarkerGridDetector(const AdvancedGridDefinition &def);

      void init(const AdvancedGridDefinition &def);

      const MarkerGrid &detect(const core::ImgBase *image);

      const MarkerGrid *getMarkerGrid() const { return &grid; }

      private:
      MarkerGrid grid; 
    };
  }
}