cartesian_canvas Class Reference

#include <bitmap_image.hpp>

Public Member Functions
	cartesian_canvas (const double x_length, const double y_length)
bool	operator! ()
void	rectangle (double x1, double y1, double x2, double y2)
void	triangle (double x1, double y1, double x2, double y2, double x3, double y3)
void	quadix (double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
void	line_segment (double x1, double y1, double x2, double y2)
void	horiztonal_line_segment (double x1, double x2, double y)
void	vertical_line_segment (double y1, double y2, double x)
void	ellipse (double centerx, double centery, double a, double b)
void	circle (double centerx, double centery, double radius)
void	fill_rectangle (double x1, double y1, double x2, double y2)
void	fill_triangle (double x1, double y1, double x2, double y2, double x3, double y3)
void	fill_quadix (double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
void	fill_circle (double cx, double cy, double radius)
void	plot_pen_pixel (double x, double y)
void	plot_pixel (double x, double y)
void	pen_width (const unsigned int &width)
void	pen_color (const unsigned char &red, const unsigned char &green, const unsigned char &blue)
template<typename RGB >
void	pen_color (const RGB colour)
const bitmap_image &	image () const
bitmap_image &	image ()
void	set_widthheight (const double x_length, const double y_length)
double	min_x () const
double	min_y () const
double	max_x () const
double	max_y () const

Detailed Description

Definition at line 2379 of file bitmap_image.hpp.

Constructor & Destructor Documentation

cartesian_canvas()

cartesian_canvas::cartesian_canvas ( const double  x_length, const double  y_length  )

inline

Definition at line 2383 of file bitmap_image.hpp.

   : width_div2_ (0.0),
     height_div2_(0.0),
     min_x_      (0.0),
     min_y_      (0.0),
     max_x_      (0.0),
     max_y_      (0.0),
     draw_       (image_)
   {
      setup_canvas(x_length,y_length);
   }

Member Function Documentation

circle()

void cartesian_canvas::circle ( double  centerx, double  centery, double  radius  )

inline

Definition at line 2471 of file bitmap_image.hpp.

Referenced by test19().

   {
      const int sc_cx = static_cast<int>(cart_to_screen_x(centerx));
      const int sc_cy = static_cast<int>(cart_to_screen_y(centery));

      draw_.circle(sc_cx, sc_cy, static_cast<int>(radius));
   }

Here is the caller graph for this function:

ellipse()

void cartesian_canvas::ellipse ( double  centerx, double  centery, double  a, double  b  )

inline

Definition at line 2462 of file bitmap_image.hpp.

   {

      const int sc_cx = static_cast<int>(cart_to_screen_x(centerx));
      const int sc_cy = static_cast<int>(cart_to_screen_y(centery));

      draw_.ellipse(sc_cx, sc_cy, static_cast<int>(a), static_cast<int>(b));
   }

fill_circle()

void cartesian_canvas::fill_circle ( double  cx, double  cy, double  radius  )

inline

Definition at line 2590 of file bitmap_image.hpp.

   {
      const double delta = 1.0;
      double  x = radius;
      double  y = 0.0;
      double dx = delta - (2.0 * delta * radius);
      double dy = 0.0;
      double dr = 0.0;

      while (x >= y)
      {
         for (double i = cx - x; i <= cx + x; i += delta)
         {
            horiztonal_line_segment(cx - x, cx + x, cy + y);
            horiztonal_line_segment(cx - x, cx + x, cy - y);
         }

         for (double i = cx - y; i <= cx + y; i += delta)
         {
            horiztonal_line_segment(cx - y, cx + y, cy + x);
            horiztonal_line_segment(cx - y, cx + y, cy - x);
         }

         y += delta;

         dr += dy;
         dy += 2.0 * delta;

         if ((2.0 * delta * dr + dx) > 0)
         {
             x -= delta;
            dr +=  dx;
            dx += 2.0 * delta;
         }
      }
   }

fill_quadix()

void cartesian_canvas::fill_quadix ( double  x1, double  y1, double  x2, double  y2, double  x3, double  y3, double  x4, double  y4  )

inline

Definition at line 2584 of file bitmap_image.hpp.

   {
      fill_triangle(x1, y1, x2, y2, x3, y3);
      fill_triangle(x1, y1, x3, y3, x4, y4);
   }

fill_rectangle()

void cartesian_canvas::fill_rectangle ( double  x1, double  y1, double  x2, double  y2  )

inline

Definition at line 2479 of file bitmap_image.hpp.

   {
      if (y1 > y2)
         std::swap(y1, y2);

      for (double y = y1; y <= y2; y += 0.5)
      {
        line_segment(x1, y, x2, y);
      }
   }

fill_triangle()

void cartesian_canvas::fill_triangle ( double  x1, double  y1, double  x2, double  y2, double  x3, double  y3  )

inline

Definition at line 2490 of file bitmap_image.hpp.

References horiztonal_line_segment(), and bitmap_image::operator=().

   {
      typedef std::pair<double,double> point_t;

      std::vector<point_t> p;

      p.push_back(std::make_pair(x1,y1));
      p.push_back(std::make_pair(x2,y2));
      p.push_back(std::make_pair(x3,y3));

      if (p[0].second > p[1].second)
         std::swap(p[0],p[1]);
      if (p[0].second > p[2].second)
         std::swap(p[0],p[2]);
      if (p[1].second > p[2].second)
         std::swap(p[1],p[2]);

      class draw_modes
      {
      private:

         cartesian_canvas& canvas;

         // Needed for incompetent and broken msvc compiler versions
         #ifdef _MSC_VER
            #pragma warning(push)
            #pragma warning(disable: 4822)
         #endif
         draw_modes& operator=(const draw_modes&);
         #ifdef _MSC_VER
            #pragma warning(pop)
         #endif

      public:

         draw_modes(cartesian_canvas& c)
         : canvas(c)
         {}

         void bottom(const point_t& p0, const point_t& p1, const point_t& p2)
         {
            double m0 = (p1.first - p0.first) / (2.0 * (p1.second - p0.second));
            double m1 = (p2.first - p0.first) / (2.0 * (p2.second - p0.second));

            double x0 = p0.first;
            double x1 = p0.first;

            for (double y = p0.second; y <= p1.second; y += 0.5)
            {
               canvas.horiztonal_line_segment(x0, x1, y);

               x0 += m0;
               x1 += m1;
            }
         }

         void top(const point_t& p0, const point_t& p1, const point_t& p2)
         {
            double m0 = (p2.first - p0.first) / (2.0 * (p2.second - p0.second));
            double m1 = (p2.first - p1.first) / (2.0 * (p2.second - p1.second));

            double x0 = p2.first;
            double x1 = p2.first;

            for (double y = p2.second; y >= p0.second; y -= 0.5)
            {
               canvas.horiztonal_line_segment(x0, x1, y);

               x0 -= m0;
               x1 -= m1;
            }
         }
      };

      draw_modes dm(*this);

      const double eps = 0.00001;

      if (std::abs(p[1].second - p[2].second) < eps)
         dm.bottom(p[0], p[1], p[2]);
      else if (std::abs(p[0].second - p[1].second) < eps)
         dm.top(p[0], p[1], p[2]);
      else
      {
         point_t p3;

         p3.first  = (p[0].first + ((p[1].second - p[0].second) / (p[2].second - p[0].second)) * (p[2].first - p[0].first));
         p3.second = p[1].second;

         dm.bottom(p[0], p[1],   p3);
         dm.top   (p[1],   p3, p[2]);
      }
   }

Here is the call graph for this function:

horiztonal_line_segment()

void cartesian_canvas::horiztonal_line_segment ( double  x1, double  x2, double  y  )

inline

Definition at line 2436 of file bitmap_image.hpp.

Referenced by fill_triangle(), and test19().

   {
      x1 = clamp_x(x1);
      x2 = clamp_x(x2);
      y  = clamp_y( y);

      const int sc_x1 = static_cast<int>(cart_to_screen_x(x1));
      const int sc_x2 = static_cast<int>(cart_to_screen_x(x2));
      const int sc_y  = static_cast<int>(cart_to_screen_y(y ));

      draw_.horiztonal_line_segment(sc_x1, sc_x2, sc_y);
   }

Here is the caller graph for this function:

image() [1/2]

const bitmap_image& cartesian_canvas::image ( ) const

inline

Definition at line 2667 of file bitmap_image.hpp.

Referenced by test19().

   {
      return image_;
   }

Here is the caller graph for this function:

image() [2/2]

bitmap_image& cartesian_canvas::image ( )

inline

Definition at line 2672 of file bitmap_image.hpp.

   {
      return image_;
   }

line_segment()

void cartesian_canvas::line_segment ( double  x1, double  y1, double  x2, double  y2  )

inline

Definition at line 2423 of file bitmap_image.hpp.

Referenced by test19().

   {
      if (clip(x1, y1, x2, y2))
      {
         const int sc_x1 = static_cast<int>(cart_to_screen_x(x1));
         const int sc_x2 = static_cast<int>(cart_to_screen_x(x2));
         const int sc_y1 = static_cast<int>(cart_to_screen_y(y1));
         const int sc_y2 = static_cast<int>(cart_to_screen_y(y2));

         draw_.line_segment(sc_x1, sc_y1, sc_x2, sc_y2);
      }
   }

Here is the caller graph for this function:

max_x()

double cartesian_canvas::max_x ( ) const

inline

Definition at line 2684 of file bitmap_image.hpp.

Referenced by test19().

{ return max_x_; }

Here is the caller graph for this function:

max_y()

double cartesian_canvas::max_y ( ) const

inline

Definition at line 2685 of file bitmap_image.hpp.

References bitmap_image::operator=().

Referenced by test19().

{ return max_y_; }

Here is the call graph for this function:

Here is the caller graph for this function:

min_x()

double cartesian_canvas::min_x ( ) const

inline

Definition at line 2682 of file bitmap_image.hpp.

Referenced by test19().

{ return min_x_; }

Here is the caller graph for this function:

min_y()

double cartesian_canvas::min_y ( ) const

inline

Definition at line 2683 of file bitmap_image.hpp.

Referenced by test19().

{ return min_y_; }

Here is the caller graph for this function:

operator!()

bool cartesian_canvas::operator! ( )

inline

Definition at line 2395 of file bitmap_image.hpp.

   {
      return !image_;
   }

pen_color() [1/2]

void cartesian_canvas::pen_color ( const unsigned char &  red, const unsigned char &  green, const unsigned char &  blue  )

inline

Definition at line 2654 of file bitmap_image.hpp.

Referenced by test19().

   {
      draw_.pen_color(red,green,blue);
   }

Here is the caller graph for this function:

pen_color() [2/2]

template<typename RGB >

void cartesian_canvas::pen_color ( const RGB  colour )

inline

Definition at line 2662 of file bitmap_image.hpp.

   {
      draw_.pen_color(colour);
   }

pen_width()

void cartesian_canvas::pen_width ( const unsigned int &  width )

inline

Definition at line 2649 of file bitmap_image.hpp.

Referenced by test19().

   {
      draw_.pen_width(width);
   }

Here is the caller graph for this function:

plot_pen_pixel()

void cartesian_canvas::plot_pen_pixel ( double  x, double  y  )

inline

Definition at line 2627 of file bitmap_image.hpp.

   {
      if ((x < min_x_) || (x > max_x_)) return;
      if ((y < min_y_) || (y > max_y_)) return;

      const int sc_x = static_cast<int>(cart_to_screen_x(x));
      const int sc_y = static_cast<int>(cart_to_screen_y(y));

      draw_.plot_pen_pixel(sc_x, sc_y);
   }

plot_pixel()

void cartesian_canvas::plot_pixel ( double  x, double  y  )

inline

Definition at line 2638 of file bitmap_image.hpp.

   {
      if ((x < min_x_) || (x > max_x_)) return;
      if ((y < min_y_) || (y > max_y_)) return;

      const int sc_x = static_cast<int>(cart_to_screen_x(x));
      const int sc_y = static_cast<int>(cart_to_screen_y(y));

      draw_.plot_pixel(sc_x, sc_y);
   }

quadix()

void cartesian_canvas::quadix ( double  x1, double  y1, double  x2, double  y2, double  x3, double  y3, double  x4, double  y4  )

inline

Definition at line 2415 of file bitmap_image.hpp.

   {
      line_segment(x1, y1, x2, y2);
      line_segment(x2, y2, x3, y3);
      line_segment(x3, y3, x4, y4);
      line_segment(x4, y4, x1, y1);
   }

rectangle()

void cartesian_canvas::rectangle ( double  x1, double  y1, double  x2, double  y2  )

inline

Definition at line 2400 of file bitmap_image.hpp.

Referenced by test19().

   {
      line_segment(x1, y1, x2, y1);
      line_segment(x2, y1, x2, y2);
      line_segment(x2, y2, x1, y2);
      line_segment(x1, y2, x1, y1);
   }

Here is the caller graph for this function:

set_widthheight()

void cartesian_canvas::set_widthheight ( const double  x_length, const double  y_length  )

inline

Definition at line 2677 of file bitmap_image.hpp.

   {
      setup_canvas(x_length, y_length);
   }

triangle()

void cartesian_canvas::triangle ( double  x1, double  y1, double  x2, double  y2, double  x3, double  y3  )

inline

Definition at line 2408 of file bitmap_image.hpp.

   {
      line_segment(x1, y1, x2, y2);
      line_segment(x2, y2, x3, y3);
      line_segment(x3, y3, x1, y1);
   }

vertical_line_segment()

void cartesian_canvas::vertical_line_segment ( double  y1, double  y2, double  x  )

inline

Definition at line 2449 of file bitmap_image.hpp.

   {
      y1 = clamp_y(y1);
      y2 = clamp_y(y2);
      x  = clamp_x( x);

      const int sc_y1 = static_cast<int>(cart_to_screen_y(y1));
      const int sc_y2 = static_cast<int>(cart_to_screen_y(y2));
      const int sc_x  = static_cast<int>(cart_to_screen_x(x ));

      draw_.vertical_line_segment(sc_y1, sc_y2, sc_x);
   }

---

The documentation for this class was generated from the following file:

• bitmap/bitmap_image.hpp