mask.h

Go to the documentation of this file.

#ifndef ED_MASK_H_
#define ED_MASK_H_
 
#include <rgbd/types.h>
#include <opencv2/core/core.hpp>
 
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
#include <cassert>
 
namespace ed
{
 
class ImageMask {
 
public:
 
    ImageMask() {}
 
    ImageMask(int width, int height) : width_(width), height_(height)
    {
    }
 
    inline void setSize(int width, int height)
    {
        width_ = width;
        height_ = height;
    }
 
    inline void clear()
    {
        points_.clear();
    }
 
    inline int getSize() const { return points_.size(); }
 
    inline int width() const { return width_; }
 
    inline int height() const { return height_; }
 
    inline void addPoint(const cv::Point2i& p)
    {
         points_.push_back(p);
    }
 
    inline void addPoint(int x, int y)
    {
        addPoint(cv::Point2i(x, y));
    }
 
    inline void addPoint(int idx)
    {
        addPoint(idx % width_, idx / width_);
    }
 
    inline void addPoints(const std::vector<cv::Point2i>& ps)
    {
        for(std::vector<cv::Point2i>::const_iterator it = ps.begin(); it != ps.end(); ++it)
        {
            addPoint(*it);
        }
    }
 
    class const_iterator
    {
    public:
        const_iterator(const std::vector<cv::Point2i> &points, size_t index, int factor)
            : points_(points), index_(index), dx_(0), dy_(0), factor_(factor)
        {
        }
 
        // post increment operator
        inline const_iterator operator++(int)
        {
            const_iterator i(*this);
            ++*this;
            return i;
        }
 
        inline const_iterator& operator++()
        {
            ++dx_;
 
            // If reached end of the scan line of a sub-image, jump to next scan line.
            if (dx_ == factor_)
            {
                dy_++;
                dx_ = 0;
            }
 
            // Reached underneath the last scan line, jump back to the start.
            if (dy_ == factor_)
            {
                dx_ = 0;
                dy_ = 0;
                ++index_;
            }
            return *this;
        }
 
        inline cv::Point2i operator()()
        {
            const cv::Point2i &pt = points_[index_];
            return cv::Point2i(pt.x * factor_ + dx_, pt.y * factor_ + dy_);
        }
 
        // Note: iterator equality only checks base-point index, and not dx/dy
        // sub-image position.
        inline bool operator==(const const_iterator& rhs) { return index_ == rhs.index_; }
        inline bool operator!=(const const_iterator& rhs) { return index_ != rhs.index_; }
    private:
 
        const std::vector<cv::Point2i> &points_; 
        size_t index_;  
        int dx_, dy_;   
        int factor_;    
    };
 
    const_iterator begin(int width = 0) const
    {
        if (width <= 0)
            return const_iterator(points_, 0, 1);
 
        return const_iterator(points_, 0, width / width_);
    }
 
    const_iterator end() const
    {
        return const_iterator(points_, points_.size(), 0);
    }
 
private:
    int width_;  
    int height_; 
    std::vector<cv::Point2i> points_; 
};
 
} // end namespace ed
 
#endif