rect_filler.H

Go to the documentation of this file.

#ifndef CAJUN_RECT_FILLER_H
#define CAJUN_RECT_FILLER_H


#include <deque>
#include <vector>


namespace cajun
{


class rect_filler_t
{
public:
        template <class filler_t>
        void fill (filler_t &filler_,
                   double x0_, double y0_,
                   double x1_, double y1_, double size_)
        {
                init_et (x0_, y0_, x1_, y1_, size_);

                int y = m_et[0].y_min;

                while (update_et (y))
                {
                        for (unsigned e = 0; e < m_aet.size (); e += 2)
                                filler_.fill (m_aet[e].x, y,
                                              m_aet[e + 1].x - m_aet[e].x + 1);
                        update_edges (++y);
                }
        }

        struct pt_t
        {
                double x;
                double y;
        };

        template <class filler_t>
        void fill (filler_t &filler_, std::vector<pt_t> const &pts_)
        {
                init_et (pts_);

                int y = m_et[0].y_min;

                while (update_et (y))
                {
                        for (unsigned e = 0; e < m_aet.size (); e += 2)
                                filler_.fill (m_aet[e].x, y,
                                              m_aet[e + 1].x - m_aet[e].x + 1);
                        update_edges (++y);
                }
        }

protected:
        struct edge_t
        {
                bool init (double x0_, double y0_,
                           double x1_, double y1_);

                int y_min;
                int y_max;
                int dx;
                int dy;
                int x;
                int px;
        };

        struct x_sort_t
        {
                bool operator () (edge_t const &v1_,
                                  edge_t const &v2_) const
                        { return v1_.x < v2_.x; }
        };
        struct y_sort_t
        {
                bool operator () (edge_t const &v1_,
                                  edge_t const &v2_) const
                        { return v1_.y_min < v2_.y_min; }
        };
        struct y_max_equal_t
        {
                y_max_equal_t (int y_) : y (y_) {}

                bool operator () (edge_t const &v_) const
                        { return v_.y_max == y; }

                int y;
        };

        std::deque<edge_t> m_et;
        std::deque<edge_t> m_aet;

        void init_et (double x0_, double y0_,
                      double x1_, double y1_, double size_);
        void init_et (std::vector<pt_t> const &pts_);

        bool update_et (int y_);
        void update_edges (int y_);
};


};


#endif

---