Marker.h

Go to the documentation of this file.

/*
 * This file is part of ALVAR, A Library for Virtual and Augmented Reality.
 *
 * Copyright 2007-2012 VTT Technical Research Centre of Finland
 *
 * Contact: VTT Augmented Reality Team <alvar.info@vtt.fi>
 *          <http://www.vtt.fi/multimedia/alvar.html>
 *
 * ALVAR 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.1 of the License, or (at your option)
 * any later version.
 *
 * This library 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 ALVAR; if not, see
 * <http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html>.
 */

#ifndef MARKER_H
#define MARKER_H

#include "Alvar.h"
#include <iostream>
#include <algorithm>
#include "Util.h"
#include "Camera.h"
#include "Pose.h"
#include "Bitset.h"
#include <vector>
#include "filter/kinect_filtering.h"
#include <Eigen/StdVector>

namespace alvar {

  class ALVAR_EXPORT Marker
  {
  protected:
    void VisualizeMarkerPose(IplImage *image, Camera *cam, double visualize2d_points[12][2], CvScalar color=CV_RGB(255,0,0)) const;
    virtual void VisualizeMarkerContent(IplImage *image, Camera *cam, double datatext_point[2], double content_point[2]) const;
    virtual void VisualizeMarkerError(IplImage *image, Camera *cam, double errortext_point[2]) const;
    bool UpdateContentBasic(std::vector<Point<CvPoint2D64f> > &_marker_corners_img, IplImage *gray, Camera *cam, int frame_no = 0);

  public:
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW  
    bool valid;

    void CompareCorners(std::vector<Point<CvPoint2D64f> > &_marker_corners_img, int *orientation, double *error);
    void CompareContent(std::vector<Point<CvPoint2D64f> > &_marker_corners_img, IplImage *gray, Camera *cam, int *orientation) const;
    virtual bool UpdateContent(std::vector<Point<CvPoint2D64f> > &_marker_corners_img, IplImage *gray, Camera *cam, int frame_no = 0);
    void UpdatePose(std::vector<Point<CvPoint2D64f> > &_marker_corners_img, Camera *cam, int orientation, int frame_no = 0, bool update_pose = true);
    virtual bool DecodeContent(int *orientation);
        
    CvMat *GetContent() const {
      return marker_content;
    }
    void SaveMarkerImage(const char *filename, int save_res = 0) const;
    void ScaleMarkerToImage(IplImage *image) const;
    void Visualize(IplImage *image, Camera *cam, CvScalar color=CV_RGB(255,0,0)) const;
    void SetMarkerSize(double _edge_length = 0, int _res = 0, double _margin = 0);
    double GetMarkerEdgeLength() const { return edge_length; }
    ~Marker();
    Marker(double _edge_length = 0, int _res = 0, double _margin = 0);
    Marker(const Marker& m);
    virtual unsigned long GetId() const { return 0; }
    virtual void SetId(unsigned long _id) {};

    int GetRes() const { return res; }

    double GetMargin() const { return margin; }

    Pose pose;
    double GetError(int errors = (MARGIN_ERROR | DECODE_ERROR)) const {
      int count = 0;
      double error = 0;
      if (errors & MARGIN_ERROR) {error+=margin_error; count++;}
      if (errors & DECODE_ERROR) {error+=decode_error; count++;}
      if (errors & TRACK_ERROR) {error+=track_error; count++;}
      return error/count;
    }
    void SetError(int error_type, double value) {
      if (error_type == MARGIN_ERROR) margin_error = value;
      else if (error_type == DECODE_ERROR) decode_error = value;
      else if (error_type == TRACK_ERROR) track_error = value;
    }
    static const int MARGIN_ERROR=1;
    static const int DECODE_ERROR=2;
    static const int TRACK_ERROR=4;
  protected:
    double margin_error;
    double decode_error;
    double track_error;
    double edge_length;
    int res;
    double margin;
    CvMat *marker_content;

  public:
      
    std::vector<PointDouble> marker_points;
    std::vector<PointDouble> marker_corners;
    std::vector<PointDouble> marker_corners_img;
    std::vector<PointDouble> ros_marker_points_img;
    ar_track_alvar::ARCloud ros_corners_3D;
    int ros_orientation;
    std::vector<PointDouble> marker_margin_w;
    std::vector<PointDouble> marker_margin_b;
#ifdef VISUALIZE_MARKER_POINTS
    std::vector<PointDouble> marker_allpoints_img;
#endif
  };

  class ALVAR_EXPORT MarkerArtoolkit : public Marker
  {
  protected:
    int default_res() { std::cout<<"MarkerArtoolkit::default_res"<<std::endl; return 3; }
    double default_margin() { return 1.5; }

  public:
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW  
    unsigned long id;
  MarkerArtoolkit(double _edge_length = 0, int _res = 0, double _margin = 0) : 
    Marker(_edge_length, (_res?_res:3), (_margin?_margin:1.5))
      {
      }
    unsigned long GetId() const { return id; }
    void SetId(unsigned long _id) { id = _id; }
    bool DecodeContent(int *orientation);
    void SetContent(unsigned long _id);
  };

  class ALVAR_EXPORT MarkerData : public Marker
  {
  protected:
    virtual void VisualizeMarkerContent(IplImage *image, Camera *cam, double datatext_point[2], double content_point[2]) const;
    void DecodeOrientation(int *error, int *total, int *orientation);
    int DecodeCode(int orientation, BitsetExt *bs, int *erroneous, int *total, unsigned char* content_type);
    void Read6bitStr(BitsetExt *bs, char *s, size_t s_max_len);
    void Add6bitStr(BitsetExt *bs, char *s);
    int UsableDataBits(int marker_res, int hamming);
    bool DetectResolution(std::vector<Point<CvPoint2D64f> > &_marker_corners_img, IplImage *gray, Camera *cam);

  public:
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW  
    static const int MAX_MARKER_STRING_LEN=2048;
    enum MarkerContentType {
      MARKER_CONTENT_TYPE_NUMBER,
      MARKER_CONTENT_TYPE_STRING,
      MARKER_CONTENT_TYPE_FILE,
      MARKER_CONTENT_TYPE_HTTP
    };
    unsigned char       content_type;

    union {
      unsigned long     id;                                                     
      char                      str[MAX_MARKER_STRING_LEN]; 
    } data;

  MarkerData(double _edge_length = 0, int _res = 0, double _margin = 0) : 
    Marker(_edge_length, _res, (_margin?_margin:2))
      {
      }
    unsigned long GetId() const { return data.id; }
    void SetId(unsigned long _id) { data.id = _id; }
    virtual bool UpdateContent(std::vector<Point<CvPoint2D64f> > &_marker_corners_img, IplImage *gray, Camera *cam, int frame_no = 0);
    bool DecodeContent(int *orientation);
    void SetContent(MarkerContentType content_type, unsigned long id, const char *str, bool force_strong_hamming=false, bool verbose=false);
  };

  class ALVAR_EXPORT MarkerIterator : public std::iterator<std::forward_iterator_tag, Marker*> {
  public:
    virtual bool operator==(const MarkerIterator& other) = 0;
    virtual bool operator!=(const MarkerIterator& other) = 0;
    virtual MarkerIterator& operator++() = 0;
    virtual const Marker* operator*() = 0;
    virtual const Marker* operator->() = 0;
    virtual MarkerIterator& reset() = 0;

    void *_data;
  };

  template<typename T>
    class ALVAR_EXPORT MarkerIteratorImpl : public MarkerIterator {
  public:
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW    
  typedef typename std::vector<T, Eigen::aligned_allocator<T> >::const_iterator const_iterator_aligntype;
  MarkerIteratorImpl(const_iterator_aligntype i) : _begin(i), _i(i) {
      _data = this;
    }

    ~MarkerIteratorImpl() {}

    // The assignment and relational operators are straightforward
    MarkerIteratorImpl& operator=(const MarkerIteratorImpl& other) {
      _i = other._i;
      return(*this);
    }

    bool operator==(const MarkerIterator& other) {
      MarkerIteratorImpl* pother = (MarkerIteratorImpl*)other._data;
      return (_i == pother->_i);
    }

    bool operator!=(const MarkerIterator& other) {
      MarkerIteratorImpl* pother = (MarkerIteratorImpl*)other._data;
      return (_i != pother->_i);
    }

    MarkerIterator& operator++() {
      _i++;
      return(*this);
    }

    const Marker* operator*() {
      return &(*_i);
    }

    const Marker* operator->() {
      return &(*_i);
    }

    MarkerIterator& reset() {
      _i = _begin;
      return (*this);
    }

  private:
    const_iterator_aligntype _begin;
    const_iterator_aligntype _i;
  };

} // namespace alvar

#endif