bitmap_image Class Reference

#include <bitmap_image.hpp>

Public Types
enum	channel_mode { rgb_mode = 0, bgr_mode = 1 }
enum	color_plane { blue_plane = 0, green_plane = 1, red_plane = 2 }

Public Member Functions
	bitmap_image ()
	bitmap_image (const std::string &filename)
	bitmap_image (const unsigned int width, const unsigned int height)
	bitmap_image (const bitmap_image &image)
bitmap_image &	operator= (const bitmap_image &image)
bool	operator! ()
void	clear (const unsigned char v=0x00)
unsigned char	red_channel (const unsigned int x, const unsigned int y) const
unsigned char	green_channel (const unsigned int x, const unsigned int y) const
unsigned char	blue_channel (const unsigned int x, const unsigned int y) const
void	red_channel (const unsigned int x, const unsigned int y, const unsigned char value)
void	green_channel (const unsigned int x, const unsigned int y, const unsigned char value)
void	blue_channel (const unsigned int x, const unsigned int y, const unsigned char value)
unsigned char *	row (unsigned int row_index) const
void	get_pixel (const unsigned int x, const unsigned int y, unsigned char &red, unsigned char &green, unsigned char &blue)
template<typename RGB >
void	get_pixel (const unsigned int x, const unsigned int y, RGB &colour)
void	set_pixel (const unsigned int x, const unsigned int y, const unsigned char red, const unsigned char green, const unsigned char blue)
template<typename RGB >
void	set_pixel (const unsigned int x, const unsigned int y, const RGB &colour)
bool	copy_from (const bitmap_image &image)
bool	copy_from (const bitmap_image &source_image, const unsigned int &x_offset, const unsigned int &y_offset)
bool	region (const unsigned int &x, const unsigned int &y, const unsigned int &width, const unsigned int &height, bitmap_image &dest_image)
bool	roi_from_center (const unsigned int &cx, const unsigned int &cy, const unsigned int &width, const unsigned int &height, bitmap_image &dest_image)
bool	set_region (const unsigned int &x, const unsigned int &y, const unsigned int &width, const unsigned int &height, const unsigned char &value)
bool	set_region (const unsigned int &x, const unsigned int &y, const unsigned int &width, const unsigned int &height, const color_plane color, const unsigned char &value)
bool	set_region (const unsigned int &x, const unsigned int &y, const unsigned int &width, const unsigned int &height, const unsigned char &red, const unsigned char &green, const unsigned char &blue)
void	reflective_image (bitmap_image &image, const bool include_diagnols=false)
unsigned int	width () const
unsigned int	height () const
unsigned int	bytes_per_pixel () const
unsigned int	pixel_count () const
void	setwidth_height (const unsigned int width, const unsigned int height, const bool clear=false)
void	save_image (const std::string &file_name) const
void	set_all_ith_bits_low (const unsigned int bitr_index)
void	set_all_ith_bits_high (const unsigned int bitr_index)
void	set_all_ith_channels (const unsigned int &channel, const unsigned char &value)
void	set_channel (const color_plane color, const unsigned char &value)
void	ror_channel (const color_plane color, const unsigned int &ror)
void	set_all_channels (const unsigned char &value)
void	set_all_channels (const unsigned char &r_value, const unsigned char &g_value, const unsigned char &b_value)
void	invert_color_planes ()
void	add_to_color_plane (const color_plane color, const unsigned char &value)
void	convert_to_grayscale ()
const unsigned char *	data () const
unsigned char *	data ()
void	bgr_to_rgb ()
void	rgb_to_bgr ()
void	reverse ()
void	horizontal_flip ()
void	vertical_flip ()
void	export_color_plane (const color_plane color, unsigned char *image)
void	export_color_plane (const color_plane color, bitmap_image &image)
void	export_response_image (const color_plane color, double *response_image)
void	export_gray_scale_response_image (double *response_image) const
void	export_rgb (double *red, double *green, double *blue) const
void	export_rgb (float *red, float *green, float *blue) const
void	export_rgb (unsigned char *red, unsigned char *green, unsigned char *blue) const
void	export_ycbcr (double *y, double *cb, double *cr)
void	export_rgb_normal (double *red, double *green, double *blue) const
void	export_rgb_normal (float *red, float *green, float *blue) const
void	import_rgb (double *red, double *green, double *blue)
void	import_rgb (float *red, float *green, float *blue)
void	import_rgb (unsigned char *red, unsigned char *green, unsigned char *blue)
void	import_ycbcr (double *y, double *cb, double *cr)
void	import_gray_scale_clamped (double *gray)
void	import_rgb_clamped (double *red, double *green, double *blue)
void	import_rgb_clamped (float *red, float *green, float *blue)
void	import_rgb_normal (double *red, double *green, double *blue)
void	import_rgb_normal (float *red, float *green, float *blue)
void	subsample (bitmap_image &dest)
void	upsample (bitmap_image &dest)
void	alpha_blend (const double &alpha, const bitmap_image &image)
double	psnr (const bitmap_image &image)
double	psnr (const unsigned int &x, const unsigned int &y, const bitmap_image &image)
void	histogram (const color_plane color, double hist[256])
void	histogram_normalized (const color_plane color, double hist[256])
unsigned int	offset (const color_plane color)
void	incremental ()
void	reverse_channels ()

Detailed Description

Definition at line 37 of file bitmap_image.hpp.

Member Enumeration Documentation

channel_mode

enum bitmap_image::channel_mode

Enumerator
rgb_mode
bgr_mode

Definition at line 41 of file bitmap_image.hpp.

                     {
                        rgb_mode = 0,
                        bgr_mode = 1
                     };

color_plane

enum bitmap_image::color_plane

Enumerator
blue_plane
green_plane
red_plane

Definition at line 46 of file bitmap_image.hpp.

                    {
                       blue_plane  = 0,
                       green_plane = 1,
                       red_plane   = 2
                    };

Constructor & Destructor Documentation

bitmap_image() [1/4]

bitmap_image::bitmap_image ( )

inline

Definition at line 52 of file bitmap_image.hpp.

   : file_name_(""),
     width_          (0),
     height_         (0),
     row_increment_  (0),
     bytes_per_pixel_(3),
     channel_mode_(bgr_mode)
   {}

bitmap_image() [2/4]

bitmap_image::bitmap_image ( const std::string &  filename )

inline

Definition at line 61 of file bitmap_image.hpp.

   : file_name_(filename),
     width_          (0),
     height_         (0),
     row_increment_  (0),
     bytes_per_pixel_(0),
     channel_mode_(bgr_mode)
   {
      load_bitmap();
   }

bitmap_image() [3/4]

bitmap_image::bitmap_image ( const unsigned int  width, const unsigned int  height  )

inline

Definition at line 72 of file bitmap_image.hpp.

   : file_name_(""),
     width_ (width ),
     height_(height),
     row_increment_  (0),
     bytes_per_pixel_(3),
     channel_mode_(bgr_mode)
   {
      create_bitmap();
   }

bitmap_image() [4/4]

bitmap_image::bitmap_image ( const bitmap_image &  image )

inline

Definition at line 83 of file bitmap_image.hpp.

   : file_name_(image.file_name_),
     width_    (image.width_    ),
     height_   (image.height_   ),
     row_increment_  (0),
     bytes_per_pixel_(3),
     channel_mode_(bgr_mode)
   {
      create_bitmap();
      data_ = image.data_;
   }

Member Function Documentation

add_to_color_plane()

void bitmap_image::add_to_color_plane ( const color_plane  color, const unsigned char &  value  )

inline

Definition at line 534 of file bitmap_image.hpp.

References data(), and offset().

Referenced by test11().

   {
      for (unsigned char* itr = (data() + offset(color)); itr < end(); itr += bytes_per_pixel_)
      {
         (*itr) += value;
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

alpha_blend()

void bitmap_image::alpha_blend ( const double &  alpha, const bitmap_image &  image  )

inline

Definition at line 1095 of file bitmap_image.hpp.

References data().

Referenced by test16().

   {
      if (
           (image.width_  != width_ ) ||
           (image.height_ != height_)
         )
      {
         return;
      }

      if ((alpha < 0.0) || (alpha > 1.0))
      {
         return;
      }

      unsigned char* itr1       = data();
      unsigned char* itr1_end   = end();
      const unsigned char* itr2 = image.data();

      double alpha_compliment = 1.0 - alpha;

      while (itr1 != itr1_end)
      {
         *(itr1) = static_cast<unsigned char>((alpha * (*itr2)) + (alpha_compliment * (*itr1)));
         ++itr1;
         ++itr2;
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

bgr_to_rgb()

void bitmap_image::bgr_to_rgb ( )

inline

Definition at line 578 of file bitmap_image.hpp.

References bgr_mode, reverse_channels(), and rgb_mode.

   {
      if ((bgr_mode == channel_mode_) && (3 == bytes_per_pixel_))
      {
         reverse_channels();
         channel_mode_ = rgb_mode;
      }
   }

Here is the call graph for this function:

blue_channel() [1/2]

unsigned char bitmap_image::blue_channel ( const unsigned int  x, const unsigned int  y  ) const

inline

Definition at line 135 of file bitmap_image.hpp.

   {
      return data_[(y * row_increment_) + (x * bytes_per_pixel_ + 0)];
   }

blue_channel() [2/2]

void bitmap_image::blue_channel ( const unsigned int  x, const unsigned int  y, const unsigned char  value  )

inline

Definition at line 150 of file bitmap_image.hpp.

   {
      data_[(y * row_increment_) + (x * bytes_per_pixel_ + 0)] = value;
   }

bytes_per_pixel()

unsigned int bitmap_image::bytes_per_pixel ( ) const

inline

Definition at line 390 of file bitmap_image.hpp.

Referenced by checkered_pattern(), and psnr_region().

   {
      return bytes_per_pixel_;
   }

Here is the caller graph for this function:

clear()

void bitmap_image::clear ( const unsigned char  v = 0x00 )

inline

Definition at line 120 of file bitmap_image.hpp.

Referenced by export_color_plane(), reverse_channels(), setwidth_height(), subsample(), test14(), test15(), test20(), and upsample().

   {
      std::fill(data_.begin(),data_.end(),v);
   }

Here is the caller graph for this function:

convert_to_grayscale()

void bitmap_image::convert_to_grayscale ( )

inline

Definition at line 542 of file bitmap_image.hpp.

References data(), and rgb_mode.

Referenced by test07().

   {
      double r_scaler = 0.299;
      double g_scaler = 0.587;
      double b_scaler = 0.114;

      if (rgb_mode == channel_mode_)
      {
         std::swap(r_scaler, b_scaler);
      }

      for (unsigned char* itr = data(); itr < end(); )
      {
         unsigned char gray_value = static_cast<unsigned char>
                       (
                         (r_scaler * (*(itr + 2))) +
                         (g_scaler * (*(itr + 1))) +
                         (b_scaler * (*(itr + 0)))
                       );

         *(itr++) = gray_value;
         *(itr++) = gray_value;
         *(itr++) = gray_value;
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

copy_from() [1/2]

bool bitmap_image::copy_from ( const bitmap_image &  image )

inline

Definition at line 199 of file bitmap_image.hpp.

Referenced by reflective_image().

   {
      if (
           (image.height_ != height_) ||
           (image.width_  != width_ )
         )
      {
         return false;
      }

      data_ = image.data_;

      return true;
   }

Here is the caller graph for this function:

copy_from() [2/2]

bool bitmap_image::copy_from ( const bitmap_image &  source_image, const unsigned int &  x_offset, const unsigned int &  y_offset  )

inline

Definition at line 214 of file bitmap_image.hpp.

References row().

   {
      if ((x_offset + source_image.width_ ) > width_ ) { return false; }
      if ((y_offset + source_image.height_) > height_) { return false; }

      for (unsigned int y = 0; y < source_image.height_; ++y)
      {
         unsigned char* itr1           = row(y + y_offset) + x_offset * bytes_per_pixel_;
         const unsigned char* itr2     = source_image.row(y);
         const unsigned char* itr2_end = itr2 + source_image.width_ * bytes_per_pixel_;

         std::copy(itr2,itr2_end,itr1);
      }

      return true;
   }

Here is the call graph for this function:

data() [1/2]

const unsigned char* bitmap_image::data ( ) const

inline

Definition at line 568 of file bitmap_image.hpp.

Referenced by add_to_color_plane(), alpha_blend(), convert_to_grayscale(), export_color_plane(), export_gray_scale_response_image(), export_response_image(), export_rgb(), export_rgb_normal(), export_ycbcr(), histogram(), import_gray_scale_clamped(), import_rgb(), import_rgb_clamped(), import_rgb_normal(), import_ycbcr(), incremental(), invert_color_planes(), psnr(), reverse(), reverse_channels(), ror_channel(), set_all_channels(), set_all_ith_bits_high(), set_all_ith_bits_low(), set_all_ith_channels(), set_channel(), subsample(), and upsample().

   {
      return data_.data();
   }

Here is the caller graph for this function:

data() [2/2]

unsigned char* bitmap_image::data ( )

inline

Definition at line 573 of file bitmap_image.hpp.

   {
      return const_cast<unsigned char*>(data_.data());
   }

export_color_plane() [1/2]

void bitmap_image::export_color_plane ( const color_plane  color, unsigned char *  image  )

inline

Definition at line 653 of file bitmap_image.hpp.

References data(), and offset().

Referenced by test06().

   {
      for (unsigned char* itr = (data() + offset(color)); itr < end(); ++image, itr += bytes_per_pixel_)
      {
         (*image) = (*itr);
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

export_color_plane() [2/2]

void bitmap_image::export_color_plane ( const color_plane  color, bitmap_image &  image  )

inline

Definition at line 661 of file bitmap_image.hpp.

References clear(), data(), offset(), and setwidth_height().

   {
      if (
           (width_  != image.width_ ) ||
           (height_ != image.height_)
         )
      {
         image.setwidth_height(width_,height_);
      }

      image.clear();

      unsigned char* itr1     = (data() + offset(color));
      unsigned char* itr1_end = end();
      unsigned char* itr2     = (image.data() + offset(color));

      while (itr1 < itr1_end)
      {
         (*itr2) = (*itr1);

         itr1 += bytes_per_pixel_;
         itr2 += bytes_per_pixel_;
      }
   }

Here is the call graph for this function:

export_gray_scale_response_image()

void bitmap_image::export_gray_scale_response_image ( double *  response_image ) const

inline

Definition at line 696 of file bitmap_image.hpp.

References data().

Referenced by sobel_operator().

   {
      double* resp_itr = response_image;

      for (const unsigned char* itr = data(); itr < end(); itr += bytes_per_pixel_)
      {
         unsigned char gray_value = static_cast<unsigned char>
                       (
                         (0.299 * (*(itr + 2))) +
                         (0.587 * (*(itr + 1))) +
                         (0.114 * (*(itr + 0)))
                       );

         *(resp_itr++) = (1.0 * gray_value) / 256.0;
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

export_response_image()

void bitmap_image::export_response_image ( const color_plane  color, double *  response_image  )

inline

Definition at line 686 of file bitmap_image.hpp.

References data(), and offset().

   {
      double* resp_itr = response_image;

      for (unsigned char* itr = (data() + offset(color)); itr < end(); ++response_image, itr += bytes_per_pixel_)
      {
         *(resp_itr++) = (1.0 * (*itr)) / 256.0;
      }
   }

Here is the call graph for this function:

export_rgb() [1/3]

void bitmap_image::export_rgb ( double *  red, double *  green, double *  blue  ) const

inline

Definition at line 713 of file bitmap_image.hpp.

References bgr_mode, and data().

   {
      if (bgr_mode != channel_mode_)
         return;

      for (const unsigned char* itr = data(); itr < end(); ++red, ++green, ++blue)
      {
         (*blue ) = (1.0 * (*(itr++))) / 256.0;
         (*green) = (1.0 * (*(itr++))) / 256.0;
         (*red  ) = (1.0 * (*(itr++))) / 256.0;
      }
   }

Here is the call graph for this function:

export_rgb() [2/3]

void bitmap_image::export_rgb ( float *  red, float *  green, float *  blue  ) const

inline

Definition at line 726 of file bitmap_image.hpp.

References bgr_mode, and data().

   {
      if (bgr_mode != channel_mode_)
         return;

      for (const unsigned char* itr = data(); itr < end(); ++red, ++green, ++blue)
      {
         (*blue ) = (1.0f * (*(itr++))) / 256.0f;
         (*green) = (1.0f * (*(itr++))) / 256.0f;
         (*red  ) = (1.0f * (*(itr++))) / 256.0f;
      }
   }

Here is the call graph for this function:

export_rgb() [3/3]

void bitmap_image::export_rgb ( unsigned char *  red, unsigned char *  green, unsigned char *  blue  ) const

inline

Definition at line 739 of file bitmap_image.hpp.

References bgr_mode, and data().

   {
      if (bgr_mode != channel_mode_)
         return;

      for (const unsigned char* itr = data(); itr < end(); ++red, ++green, ++blue)
      {
         (*blue ) = *(itr++);
         (*green) = *(itr++);
         (*red  ) = *(itr++);
      }
   }

Here is the call graph for this function:

export_rgb_normal() [1/2]

void bitmap_image::export_rgb_normal ( double *  red, double *  green, double *  blue  ) const

inline

Definition at line 769 of file bitmap_image.hpp.

References bgr_mode, and data().

   {
      if (bgr_mode != channel_mode_)
         return;

      for (const unsigned char* itr = data(); itr < end(); ++red, ++green, ++blue)
      {
         (*blue ) = (1.0 * (*(itr++)));
         (*green) = (1.0 * (*(itr++)));
         (*red  ) = (1.0 * (*(itr++)));
      }
   }

Here is the call graph for this function:

export_rgb_normal() [2/2]

void bitmap_image::export_rgb_normal ( float *  red, float *  green, float *  blue  ) const

inline

Definition at line 782 of file bitmap_image.hpp.

References bgr_mode, and data().

   {
      if (bgr_mode != channel_mode_)
         return;

      for (const unsigned char* itr = data(); itr < end(); ++red, ++green, ++blue)
      {
         (*blue ) = (1.0f * (*(itr++)));
         (*green) = (1.0f * (*(itr++)));
         (*red  ) = (1.0f * (*(itr++)));
      }
   }

Here is the call graph for this function:

export_ycbcr()

void bitmap_image::export_ycbcr ( double *  y, double *  cb, double *  cr  )

inline

Definition at line 752 of file bitmap_image.hpp.

References bgr_mode, and data().

Referenced by test12(), and test13().

   {
      if (bgr_mode != channel_mode_)
         return;

      for (const unsigned char* itr = data(); itr < end(); ++y, ++cb, ++cr)
      {
         const double blue  = (1.0 * (*(itr++)));
         const double green = (1.0 * (*(itr++)));
         const double red   = (1.0 * (*(itr++)));

         ( *y) = clamp<double>( 16.0 + (1.0/256.0) * (  65.738 * red + 129.057 * green +  25.064 * blue),1.0,254);
         (*cb) = clamp<double>(128.0 + (1.0/256.0) * (- 37.945 * red -  74.494 * green + 112.439 * blue),1.0,254);
         (*cr) = clamp<double>(128.0 + (1.0/256.0) * ( 112.439 * red -  94.154 * green -  18.285 * blue),1.0,254);
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

get_pixel() [1/2]

void bitmap_image::get_pixel ( const unsigned int  x, const unsigned int  y, unsigned char &  red, unsigned char &  green, unsigned char &  blue  )

inline

Definition at line 160 of file bitmap_image.hpp.

Referenced by get_pixel().

   {
      const unsigned int y_offset = y * row_increment_;
      const unsigned int x_offset = x * bytes_per_pixel_;

      blue  = data_[y_offset + x_offset + 0];
      green = data_[y_offset + x_offset + 1];
      red   = data_[y_offset + x_offset + 2];
   }

Here is the caller graph for this function:

get_pixel() [2/2]

template<typename RGB >

void bitmap_image::get_pixel ( const unsigned int  x, const unsigned int  y, RGB &  colour  )

inline

Definition at line 174 of file bitmap_image.hpp.

References get_pixel().

   {
      get_pixel(x, y, colour.red, colour.green, colour.blue);
   }

Here is the call graph for this function:

green_channel() [1/2]

unsigned char bitmap_image::green_channel ( const unsigned int  x, const unsigned int  y  ) const

inline

Definition at line 130 of file bitmap_image.hpp.

   {
      return data_[(y * row_increment_) + (x * bytes_per_pixel_ + 1)];
   }

green_channel() [2/2]

void bitmap_image::green_channel ( const unsigned int  x, const unsigned int  y, const unsigned char  value  )

inline

Definition at line 145 of file bitmap_image.hpp.

   {
      data_[(y * row_increment_) + (x * bytes_per_pixel_ + 1)] = value;
   }

height()

unsigned int bitmap_image::height ( ) const

inline

Definition at line 385 of file bitmap_image.hpp.

Referenced by checkered_pattern(), convert_rsp_to_image(), hierarchical_psnr(), plasma(), psnr(), psnr_region(), region(), reverse_channels(), set_region(), setwidth_height(), sobel_operator(), test08(), test15(), test16(), test17(), test18(), and upsample().

   {
      return height_;
   }

Here is the caller graph for this function:

histogram()

void bitmap_image::histogram ( const color_plane  color, double  hist[256]  )

inline

Definition at line 1198 of file bitmap_image.hpp.

References data(), and offset().

Referenced by histogram_normalized().

   {
      std::fill(hist,hist + 256,0.0);

      for (unsigned char* itr = (data() + offset(color)); itr < end(); itr += bytes_per_pixel_)
      {
         ++hist[(*itr)];
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

histogram_normalized()

void bitmap_image::histogram_normalized ( const color_plane  color, double  hist[256]  )

inline

Definition at line 1208 of file bitmap_image.hpp.

References histogram(), and pixel_count().

   {
      histogram(color,hist);

      double* h_itr = hist;
      const double* h_end = hist + 256;
      const double pixel_count = static_cast<double>(width_ * height_);

      while (h_end != h_itr)
      {
         *(h_itr++) /= pixel_count;
      }
   }

Here is the call graph for this function:

horizontal_flip()

void bitmap_image::horizontal_flip ( )

inline

Definition at line 616 of file bitmap_image.hpp.

References row().

Referenced by reflective_image(), and test02().

   {
      for (unsigned int y = 0; y < height_; ++y)
      {
         unsigned char* itr1 = row(y);
         unsigned char* itr2 = itr1 + row_increment_ - bytes_per_pixel_;

         while (itr1 < itr2)
         {
            for (unsigned int i = 0; i < bytes_per_pixel_; ++i)
            {
               unsigned char* p1 = (itr1 + i);
               unsigned char* p2 = (itr2 + i);

               std::swap(*p1,*p2);
            }

            itr1 += bytes_per_pixel_;
            itr2 -= bytes_per_pixel_;
         }
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

import_gray_scale_clamped()

void bitmap_image::import_gray_scale_clamped ( double *  gray )

inline

Definition at line 851 of file bitmap_image.hpp.

References bgr_mode, and data().

Referenced by sobel_operator().

   {
      if (bgr_mode != channel_mode_)
         return;

      for (unsigned char* itr = data(); itr < end(); ++gray)
      {
         unsigned char c = static_cast<unsigned char>(clamp<double>(256.0 * (*gray),0.0,255.0));

         *(itr + 0) = c;
         *(itr + 1) = c;
         *(itr + 2) = c;

         itr += 3;
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

import_rgb() [1/3]

void bitmap_image::import_rgb ( double *  red, double *  green, double *  blue  )

inline

Definition at line 795 of file bitmap_image.hpp.

References bgr_mode, and data().

   {
      if (bgr_mode != channel_mode_)
         return;

      for (unsigned char* itr = data(); itr < end(); ++red, ++green, ++blue)
      {
         *(itr++) = static_cast<unsigned char>(256.0 * (*blue ));
         *(itr++) = static_cast<unsigned char>(256.0 * (*green));
         *(itr++) = static_cast<unsigned char>(256.0 * (*red  ));
      }
   }

Here is the call graph for this function:

import_rgb() [2/3]

void bitmap_image::import_rgb ( float *  red, float *  green, float *  blue  )

inline

Definition at line 808 of file bitmap_image.hpp.

References bgr_mode, and data().

   {
      if (bgr_mode != channel_mode_)
         return;

      for (unsigned char* itr = data(); itr < end(); ++red, ++green, ++blue)
      {
         *(itr++) = static_cast<unsigned char>(256.0f * (*blue ));
         *(itr++) = static_cast<unsigned char>(256.0f * (*green));
         *(itr++) = static_cast<unsigned char>(256.0f * (*red  ));
      }
   }

Here is the call graph for this function:

import_rgb() [3/3]

void bitmap_image::import_rgb ( unsigned char *  red, unsigned char *  green, unsigned char *  blue  )

inline

Definition at line 821 of file bitmap_image.hpp.

References bgr_mode, and data().

   {
      if (bgr_mode != channel_mode_)
         return;

      for (unsigned char* itr = data(); itr < end(); ++red, ++green, ++blue)
      {
         *(itr++) = (*blue );
         *(itr++) = (*green);
         *(itr++) = (*red  );
      }
   }

Here is the call graph for this function:

import_rgb_clamped() [1/2]

void bitmap_image::import_rgb_clamped ( double *  red, double *  green, double *  blue  )

inline

Definition at line 868 of file bitmap_image.hpp.

References bgr_mode, and data().

   {
      if (bgr_mode != channel_mode_)
         return;

      for (unsigned char* itr = data(); itr < end(); ++red, ++green, ++blue)
      {
         *(itr++) = static_cast<unsigned char>(clamp<double>(256.0 * (*blue ),0.0,255.0));
         *(itr++) = static_cast<unsigned char>(clamp<double>(256.0 * (*green),0.0,255.0));
         *(itr++) = static_cast<unsigned char>(clamp<double>(256.0 * (*red  ),0.0,255.0));
      }
   }

Here is the call graph for this function:

import_rgb_clamped() [2/2]

void bitmap_image::import_rgb_clamped ( float *  red, float *  green, float *  blue  )

inline

Definition at line 881 of file bitmap_image.hpp.

References bgr_mode, and data().

   {
      if (bgr_mode != channel_mode_)
         return;

      for (unsigned char* itr = data(); itr < end(); ++red, ++green, ++blue)
      {
         *(itr++) = static_cast<unsigned char>(clamp<double>(256.0f * (*blue ),0.0,255.0));
         *(itr++) = static_cast<unsigned char>(clamp<double>(256.0f * (*green),0.0,255.0));
         *(itr++) = static_cast<unsigned char>(clamp<double>(256.0f * (*red  ),0.0,255.0));
      }
   }

Here is the call graph for this function:

import_rgb_normal() [1/2]

void bitmap_image::import_rgb_normal ( double *  red, double *  green, double *  blue  )

inline

Definition at line 894 of file bitmap_image.hpp.

References bgr_mode, and data().

   {
      if (bgr_mode != channel_mode_)
         return;

      for (unsigned char* itr = data(); itr < end(); ++red, ++green, ++blue)
      {
         *(itr++) = static_cast<unsigned char>(*blue );
         *(itr++) = static_cast<unsigned char>(*green);
         *(itr++) = static_cast<unsigned char>(*red  );
      }
   }

Here is the call graph for this function:

import_rgb_normal() [2/2]

void bitmap_image::import_rgb_normal ( float *  red, float *  green, float *  blue  )

inline

Definition at line 907 of file bitmap_image.hpp.

References bgr_mode, and data().

   {
      if (bgr_mode != channel_mode_)
         return;

      for (unsigned char* itr = data(); itr < end(); ++red, ++green, ++blue)
      {
         *(itr++) = static_cast<unsigned char>(*blue );
         *(itr++) = static_cast<unsigned char>(*green);
         *(itr++) = static_cast<unsigned char>(*red  );
      }
   }

Here is the call graph for this function:

import_ycbcr()

void bitmap_image::import_ycbcr ( double *  y, double *  cb, double *  cr  )

inline

Definition at line 834 of file bitmap_image.hpp.

References bgr_mode, and data().

Referenced by test12(), and test13().

   {
      if (bgr_mode != channel_mode_)
         return;

      for (unsigned char* itr = data(); itr < end(); ++y, ++cb, ++cr)
      {
         double y_  =  (*y);
         double cb_ = (*cb);
         double cr_ = (*cr);

         *(itr++) = static_cast<unsigned char>(clamp((298.082 * y_ + 516.412 * cb_                 ) / 256.0 - 276.836,0.0,255.0));
         *(itr++) = static_cast<unsigned char>(clamp((298.082 * y_ - 100.291 * cb_ - 208.120 * cr_ ) / 256.0 + 135.576,0.0,255.0));
         *(itr++) = static_cast<unsigned char>(clamp((298.082 * y_                 + 408.583 * cr_ ) / 256.0 - 222.921,0.0,255.0));
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

incremental()

void bitmap_image::incremental ( )

inline

Definition at line 1250 of file bitmap_image.hpp.

References data().

   {
      unsigned char current_color = 0;

      for (unsigned char* itr = data(); itr < end();)
      {
         (*itr++) = (current_color);
         (*itr++) = (current_color);
         (*itr++) = (current_color);

         ++current_color;
      }
   }

Here is the call graph for this function:

invert_color_planes()

void bitmap_image::invert_color_planes ( )

inline

Definition at line 529 of file bitmap_image.hpp.

References data().

Referenced by test10().

   {
      for (unsigned char* itr = data(); itr < end(); *itr = ~(*itr), ++itr);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

offset()

unsigned int bitmap_image::offset ( const color_plane  color )

inline

Definition at line 1222 of file bitmap_image.hpp.

References bgr_mode, blue_plane, green_plane, red_plane, and rgb_mode.

Referenced by add_to_color_plane(), checkered_pattern(), export_color_plane(), export_response_image(), histogram(), ror_channel(), set_channel(), and set_region().

   {
      switch (channel_mode_)
      {
         case rgb_mode : {
                            switch (color)
                            {
                               case red_plane   : return 0;
                               case green_plane : return 1;
                               case blue_plane  : return 2;
                               default          : return std::numeric_limits<unsigned int>::max();
                            }
                         }

         case bgr_mode : {
                            switch (color)
                            {
                               case red_plane   : return 2;
                               case green_plane : return 1;
                               case blue_plane  : return 0;
                               default          : return std::numeric_limits<unsigned int>::max();
                            }
                         }

         default       : return std::numeric_limits<unsigned int>::max();
      }
   }

Here is the caller graph for this function:

operator!()

bool bitmap_image::operator! ( )

inline

Definition at line 112 of file bitmap_image.hpp.

   {
      return (data_.size()   == 0) ||
             (width_         == 0) ||
             (height_        == 0) ||
             (row_increment_ == 0);
   }

operator=()

bitmap_image& bitmap_image::operator= ( const bitmap_image &  image )

inline

Definition at line 95 of file bitmap_image.hpp.

Referenced by cartesian_canvas::fill_triangle(), cartesian_canvas::max_y(), and image_drawer::pen_color().

   {
      if (this != &image)
      {
         file_name_       = image.file_name_;
         bytes_per_pixel_ = image.bytes_per_pixel_;
         width_           = image.width_;
         height_          = image.height_;
         row_increment_   = 0;
         channel_mode_    = image.channel_mode_;
         create_bitmap();
         data_ = image.data_;
      }

      return *this;
   }

Here is the caller graph for this function:

pixel_count()

unsigned int bitmap_image::pixel_count ( ) const

inline

Definition at line 395 of file bitmap_image.hpp.

Referenced by histogram_normalized(), test12(), and test13().

   {
      return width_ *  height_;
   }

Here is the caller graph for this function:

psnr() [1/2]

double bitmap_image::psnr ( const bitmap_image &  image )

inline

Definition at line 1124 of file bitmap_image.hpp.

References data().

Referenced by hierarchical_psnr(), and hierarchical_psnr_r().

   {
      if (
           (image.width_  != width_ ) ||
           (image.height_ != height_)
         )
      {
         return 0.0;
      }

      unsigned char*       itr1 = data();
      const unsigned char* itr2 = image.data();

      double mse = 0.0;

      while (itr1 != end())
      {
         const double v = (static_cast<double>(*itr1) - static_cast<double>(*itr2));

         mse += v * v;
         ++itr1;
         ++itr2;
      }

      if (mse <= 0.0000001)
      {
         return 1000000.0;
      }
      else
      {
         mse /= (3.0 * width_ * height_);

         return 20.0 * std::log10(255.0 / std::sqrt(mse));
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

psnr() [2/2]

double bitmap_image::psnr ( const unsigned int &  x, const unsigned int &  y, const bitmap_image &  image  )

inline

Definition at line 1160 of file bitmap_image.hpp.

References height(), row(), and width().

   {
      if ((x + image.width() ) > width_ ) { return 0.0; }
      if ((y + image.height()) > height_) { return 0.0; }

      double mse = 0.0;

      const unsigned int height = image.height();
      const unsigned int width  = image.width();

      for (unsigned int r = 0; r < height; ++r)
      {
         unsigned char* itr1       = row(r + y) + x * bytes_per_pixel_;
         unsigned char* itr1_end   = itr1 + (width * bytes_per_pixel_);
         const unsigned char* itr2 = image.row(r);

         while (itr1 != itr1_end)
         {
            double v = (static_cast<double>(*itr1) - static_cast<double>(*itr2));
            mse += v * v;
            ++itr1;
            ++itr2;
         }
      }

      if (mse <= 0.0000001)
      {
         return 1000000.0;
      }
      else
      {
         mse /= (3.0 * image.width() * image.height());
         return 20.0 * std::log10(255.0 / std::sqrt(mse));
      }
   }

Here is the call graph for this function:

red_channel() [1/2]

unsigned char bitmap_image::red_channel ( const unsigned int  x, const unsigned int  y  ) const

inline

Definition at line 125 of file bitmap_image.hpp.

   {
      return data_[(y * row_increment_) + (x * bytes_per_pixel_ + 2)];
   }

red_channel() [2/2]

void bitmap_image::red_channel ( const unsigned int  x, const unsigned int  y, const unsigned char  value  )

inline

Definition at line 140 of file bitmap_image.hpp.

   {
      data_[(y * row_increment_) + (x * bytes_per_pixel_ + 2)] = value;
   }

reflective_image()

void bitmap_image::reflective_image ( bitmap_image &  image, const bool  include_diagnols = false  )

inline

Definition at line 347 of file bitmap_image.hpp.

References copy_from(), horizontal_flip(), setwidth_height(), and vertical_flip().

   {
      image.setwidth_height(3 * width_, 3 * height_, true);

      image.copy_from(*this, width_, height_);

      vertical_flip();

      image.copy_from(*this, width_,           0);
      image.copy_from(*this, width_, 2 * height_);

      vertical_flip();
      horizontal_flip();

      image.copy_from(*this,          0, height_);
      image.copy_from(*this, 2 * width_, height_);

      horizontal_flip();

      if (include_diagnols)
      {
         bitmap_image tile = *this;

         tile.vertical_flip();
         tile.horizontal_flip();

         image.copy_from(tile,          0,           0);
         image.copy_from(tile, 2 * width_,           0);
         image.copy_from(tile, 2 * width_, 2 * height_);
         image.copy_from(tile, 0         , 2 * height_);
      }
   }

Here is the call graph for this function:

region()

bool bitmap_image::region ( const unsigned int &  x, const unsigned int &  y, const unsigned int &  width, const unsigned int &  height, bitmap_image &  dest_image  )

inline

Definition at line 233 of file bitmap_image.hpp.

References height(), row(), and setwidth_height().

Referenced by roi_from_center(), and test08().

   {
      if ((x + width ) > width_ ) { return false; }
      if ((y + height) > height_) { return false; }

      if (
           (dest_image.width_  < width_ ) ||
           (dest_image.height_ < height_)
         )
      {
         dest_image.setwidth_height(width,height);
      }

      for (unsigned int r = 0; r < height; ++r)
      {
         unsigned char* itr1     = row(r + y) + x * bytes_per_pixel_;
         unsigned char* itr1_end = itr1 + (width * bytes_per_pixel_);
         unsigned char* itr2     = dest_image.row(r);

         std::copy(itr1,itr1_end,itr2);
      }

      return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

reverse()

void bitmap_image::reverse ( )

inline

Definition at line 596 of file bitmap_image.hpp.

References data().

   {
      unsigned char* itr1 = data();
      unsigned char* itr2 = end() - bytes_per_pixel_;

      while (itr1 < itr2)
      {
         for (std::size_t i = 0; i < bytes_per_pixel_; ++i)
         {
            unsigned char* citr1 = itr1 + i;
            unsigned char* citr2 = itr2 + i;

            std::swap(*citr1,*citr2);
         }

         itr1 += bytes_per_pixel_;
         itr2 -= bytes_per_pixel_;
      }
   }

Here is the call graph for this function:

reverse_channels()

void bitmap_image::reverse_channels ( )

inline

Definition at line 1264 of file bitmap_image.hpp.

References clear(), data(), height(), row(), and width().

Referenced by bgr_to_rgb(), and rgb_to_bgr().

   {
      if (3 != bytes_per_pixel_)
         return;

      for (unsigned char* itr = data(); itr < end(); itr += bytes_per_pixel_)
      {
         std::swap(*(itr + 0),*(itr + 2));
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

rgb_to_bgr()

void bitmap_image::rgb_to_bgr ( )

inline

Definition at line 587 of file bitmap_image.hpp.

References bgr_mode, reverse_channels(), and rgb_mode.

   {
      if ((rgb_mode == channel_mode_) && (3 == bytes_per_pixel_))
      {
         reverse_channels();
         channel_mode_ = bgr_mode;
      }
   }

Here is the call graph for this function:

roi_from_center()

bool bitmap_image::roi_from_center ( const unsigned int &  cx, const unsigned int &  cy, const unsigned int &  width, const unsigned int &  height, bitmap_image &  dest_image  )

inline

Definition at line 262 of file bitmap_image.hpp.

References region().

   {
      return region(cx - (width / 2), cy - (height / 2),
                    width, height,
                    dest_image);
   }

Here is the call graph for this function:

ror_channel()

void bitmap_image::ror_channel ( const color_plane  color, const unsigned int &  ror  )

inline

Definition at line 501 of file bitmap_image.hpp.

References data(), and offset().

   {
      for (unsigned char* itr = (data() + offset(color)); itr < end(); itr += bytes_per_pixel_)
      {
         *itr = static_cast<unsigned char>(((*itr) >> ror) | ((*itr) << (8 - ror)));
      }
   }

Here is the call graph for this function:

row()

unsigned char* bitmap_image::row ( unsigned int  row_index ) const

inline

Definition at line 155 of file bitmap_image.hpp.

Referenced by checkered_pattern(), copy_from(), horizontal_flip(), psnr(), psnr_region(), region(), reverse_channels(), set_region(), and vertical_flip().

   {
      return const_cast<unsigned char*>(&data_[(row_index * row_increment_)]);
   }

Here is the caller graph for this function:

save_image()

void bitmap_image::save_image ( const std::string &  file_name ) const

inline

Definition at line 416 of file bitmap_image.hpp.

Referenced by test01(), test02(), test03(), test04(), test05(), test06(), test07(), test08(), test09(), test10(), test11(), test12(), test13(), test14(), test15(), test17(), test18(), test19(), and test20().

   {
      std::ofstream stream(file_name.c_str(),std::ios::binary);

      if (!stream)
      {
         std::cerr << "bitmap_image::save_image(): Error - Could not open file "  << file_name << " for writing!" << std::endl;
         return;
      }

      bitmap_information_header bih;

      bih.width            = width_;
      bih.height           = height_;
      bih.bit_count        = static_cast<unsigned short>(bytes_per_pixel_ << 3);
      bih.clr_important    = 0;
      bih.clr_used         = 0;
      bih.compression      = 0;
      bih.planes           = 1;
      bih.size             = bih.struct_size();
      bih.x_pels_per_meter = 0;
      bih.y_pels_per_meter = 0;
      bih.size_image       = (((bih.width * bytes_per_pixel_) + 3) & 0x0000FFFC) * bih.height;

      bitmap_file_header bfh;

      bfh.type             = 19778;
      bfh.size             = bfh.struct_size() + bih.struct_size() + bih.size_image;
      bfh.reserved1        = 0;
      bfh.reserved2        = 0;
      bfh.off_bits         = bih.struct_size() + bfh.struct_size();

      write_bfh(stream,bfh);
      write_bih(stream,bih);

      unsigned int padding = (4 - ((3 * width_) % 4)) % 4;
      char padding_data[4] = { 0x00, 0x00, 0x00, 0x00 };

      for (unsigned int i = 0; i < height_; ++i)
      {
         const unsigned char* data_ptr = &data_[(row_increment_ * (height_ - i - 1))];

         stream.write(reinterpret_cast<const char*>(data_ptr), sizeof(unsigned char) * bytes_per_pixel_ * width_);
         stream.write(padding_data,padding);
      }

      stream.close();
   }

Here is the caller graph for this function:

set_all_channels() [1/2]

void bitmap_image::set_all_channels ( const unsigned char &  value )

inline

Definition at line 509 of file bitmap_image.hpp.

References data().

Referenced by test19().

   {
      for (unsigned char* itr = data(); itr < end(); )
      {
         *(itr++) = value;
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

set_all_channels() [2/2]

void bitmap_image::set_all_channels ( const unsigned char &  r_value, const unsigned char &  g_value, const unsigned char &  b_value  )

inline

Definition at line 517 of file bitmap_image.hpp.

References data().

   {
      for (unsigned char* itr = (data() + 0); itr < end(); itr += bytes_per_pixel_)
      {
         *(itr + 0) = b_value;
         *(itr + 1) = g_value;
         *(itr + 2) = r_value;
      }
   }

Here is the call graph for this function:

set_all_ith_bits_high()

void bitmap_image::set_all_ith_bits_high ( const unsigned int  bitr_index )

inline

Definition at line 475 of file bitmap_image.hpp.

References data().

   {
      unsigned char mask = static_cast<unsigned char>(1 << bitr_index);

      for (unsigned char* itr = data(); itr != end(); ++itr)
      {
         *itr |= mask;
      }
   }

Here is the call graph for this function:

set_all_ith_bits_low()

void bitmap_image::set_all_ith_bits_low ( const unsigned int  bitr_index )

inline

Definition at line 465 of file bitmap_image.hpp.

References data().

Referenced by test05().

   {
      unsigned char mask = static_cast<unsigned char>(~(1 << bitr_index));

      for (unsigned char* itr = data(); itr != end(); ++itr)
      {
         *itr &= mask;
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

set_all_ith_channels()

void bitmap_image::set_all_ith_channels ( const unsigned int &  channel, const unsigned char &  value  )

inline

Definition at line 485 of file bitmap_image.hpp.

References data().

   {
      for (unsigned char* itr = (data() + channel); itr < end(); itr += bytes_per_pixel_)
      {
         *itr = value;
      }
   }

Here is the call graph for this function:

set_channel()

void bitmap_image::set_channel ( const color_plane  color, const unsigned char &  value  )

inline

Definition at line 493 of file bitmap_image.hpp.

References data(), and offset().

   {
      for (unsigned char* itr = (data() + offset(color)); itr < end(); itr += bytes_per_pixel_)
      {
         *itr = value;
      }
   }

Here is the call graph for this function:

set_pixel() [1/2]

void bitmap_image::set_pixel ( const unsigned int  x, const unsigned int  y, const unsigned char  red, const unsigned char  green, const unsigned char  blue  )

inline

Definition at line 180 of file bitmap_image.hpp.

Referenced by convert_rsp_to_image(), plasma(), set_pixel(), test09(), and test20().

   {
      const unsigned int y_offset = y * row_increment_;
      const unsigned int x_offset = x * bytes_per_pixel_;

      data_[y_offset + x_offset + 0] = blue;
      data_[y_offset + x_offset + 1] = green;
      data_[y_offset + x_offset + 2] = red;
   }

Here is the caller graph for this function:

set_pixel() [2/2]

template<typename RGB >

void bitmap_image::set_pixel ( const unsigned int  x, const unsigned int  y, const RGB &  colour  )

inline

Definition at line 194 of file bitmap_image.hpp.

References set_pixel().

   {
      set_pixel(x, y, colour.red, colour.green, colour.blue);
   }

Here is the call graph for this function:

set_region() [1/3]

bool bitmap_image::set_region ( const unsigned int &  x, const unsigned int &  y, const unsigned int &  width, const unsigned int &  height, const unsigned char &  value  )

inline

Definition at line 273 of file bitmap_image.hpp.

References height(), and row().

Referenced by hierarchical_psnr_r().

   {
      if ((x + width ) > width_ ) { return false; }
      if ((y + height) > height_) { return false; }

      for (unsigned int r = 0; r < height; ++r)
      {
         unsigned char* itr     = row(r + y) + x * bytes_per_pixel_;
         unsigned char* itr_end = itr + (width * bytes_per_pixel_);

         std::fill(itr,itr_end,value);
      }

      return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

set_region() [2/3]

bool bitmap_image::set_region ( const unsigned int &  x, const unsigned int &  y, const unsigned int &  width, const unsigned int &  height, const color_plane  color, const unsigned char &  value  )

inline

Definition at line 293 of file bitmap_image.hpp.

References height(), offset(), and row().

   {
      if ((x + width ) > width_ ) { return false; }
      if ((y + height) > height_) { return false; }

      const unsigned int color_plane_offset = offset(color);

      for (unsigned int r = 0; r < height; ++r)
      {
         unsigned char* itr     = row(r + y) + x * bytes_per_pixel_ + color_plane_offset;
         unsigned char* itr_end = itr + (width * bytes_per_pixel_);

         while (itr != itr_end)
         {
            *itr  = value;
             itr += bytes_per_pixel_;
         }
      }

      return true;
   }

Here is the call graph for this function:

set_region() [3/3]

bool bitmap_image::set_region ( const unsigned int &  x, const unsigned int &  y, const unsigned int &  width, const unsigned int &  height, const unsigned char &  red, const unsigned char &  green, const unsigned char &  blue  )

inline

Definition at line 320 of file bitmap_image.hpp.

References height(), and row().

   {
      if ((x + width ) > width_ ) { return false; }
      if ((y + height) > height_) { return false; }

      for (unsigned int r = 0; r < height; ++r)
      {
         unsigned char* itr     = row(r + y) + x * bytes_per_pixel_;
         unsigned char* itr_end = itr + (width * bytes_per_pixel_);

         while (itr != itr_end)
         {
            *(itr++) =  blue;
            *(itr++) = green;
            *(itr++) =   red;
         }
      }

      return true;
   }

Here is the call graph for this function:

setwidth_height()

void bitmap_image::setwidth_height ( const unsigned int  width, const unsigned int  height, const bool  clear = false  )

inline

Definition at line 400 of file bitmap_image.hpp.

References clear(), height(), and width().

Referenced by export_color_plane(), reflective_image(), region(), sobel_operator(), subsample(), and upsample().

   {
      data_.clear();
      width_  = width;
      height_ = height;

      create_bitmap();

      if (clear)
      {
         std::fill(data_.begin(),data_.end(),0x00);
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

subsample()

void bitmap_image::subsample ( bitmap_image &  dest )

inline

Definition at line 920 of file bitmap_image.hpp.

References clear(), data(), and setwidth_height().

Referenced by test03().

   {
      /*
         Half sub-sample of original image.
      */
      unsigned int w = 0;
      unsigned int h = 0;

      bool odd_width = false;
      bool odd_height = false;

      if (0 == (width_ % 2))
         w = width_ / 2;
      else
      {
         w = 1 + (width_ / 2);
         odd_width = true;
      }

      if (0 == (height_ % 2))
         h = height_ / 2;
      else
      {
         h = 1 + (height_ / 2);
         odd_height = true;
      }

      unsigned int horizontal_upper = (odd_width)  ? (w - 1) : w;
      unsigned int vertical_upper   = (odd_height) ? (h - 1) : h;

      dest.setwidth_height(w,h);
      dest.clear();

            unsigned char* s_itr[3];
      const unsigned char*  itr1[3];
      const unsigned char*  itr2[3];

      s_itr[0] = dest.data() + 0;
      s_itr[1] = dest.data() + 1;
      s_itr[2] = dest.data() + 2;

      itr1[0] = data() + 0;
      itr1[1] = data() + 1;
      itr1[2] = data() + 2;

      itr2[0] = data() + row_increment_ + 0;
      itr2[1] = data() + row_increment_ + 1;
      itr2[2] = data() + row_increment_ + 2;

      unsigned int total = 0;

      for (unsigned int j = 0; j < vertical_upper; ++j)
      {
         for (unsigned int i = 0; i < horizontal_upper; ++i)
         {
            for (unsigned int k = 0; k < bytes_per_pixel_; s_itr[k] += bytes_per_pixel_, ++k)
            {
               total = 0;
               total += *(itr1[k]);
               total += *(itr1[k]);
               total += *(itr2[k]);
               total += *(itr2[k]);

               itr1[k] += bytes_per_pixel_;
               itr1[k] += bytes_per_pixel_;
               itr2[k] += bytes_per_pixel_;
               itr2[k] += bytes_per_pixel_;

               *(s_itr[k]) = static_cast<unsigned char>(total >> 2);
            }
         }

         if (odd_width)
         {
            for (unsigned int k = 0; k < bytes_per_pixel_; s_itr[k] += bytes_per_pixel_, ++k)
            {
               total = 0;
               total += *(itr1[k]);
               total += *(itr2[k]);

               itr1[k] += bytes_per_pixel_;
               itr2[k] += bytes_per_pixel_;

               *(s_itr[k]) = static_cast<unsigned char>(total >> 1);
            }
         }

         for (unsigned int k = 0; k < bytes_per_pixel_; ++k)
         {
            itr1[k] += row_increment_;
         }

         if (j != (vertical_upper - 1))
         {
            for (unsigned int k = 0; k < bytes_per_pixel_; ++k)
            {
               itr2[k] += row_increment_;
            }
         }
      }

      if (odd_height)
      {
         for (unsigned int i = 0; i < horizontal_upper; ++i)
         {
            for (unsigned int k = 0; k < bytes_per_pixel_; s_itr[k] += bytes_per_pixel_, ++k)
            {
               total = 0;
               total += *(itr1[k]);
               total += *(itr2[k]);

               itr1[k] += bytes_per_pixel_;
               itr2[k] += bytes_per_pixel_;

               *(s_itr[k]) = static_cast<unsigned char>(total >> 1);
            }
         }

         if (odd_width)
         {
            for (unsigned int k = 0; k < bytes_per_pixel_; ++k)
            {
               (*(s_itr[k])) = *(itr1[k]);
            }
         }
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

upsample()

void bitmap_image::upsample ( bitmap_image &  dest )

inline

Definition at line 1048 of file bitmap_image.hpp.

References clear(), data(), and setwidth_height().

Referenced by test04().

   {
      /*
         2x up-sample of original image.
      */

      dest.setwidth_height(2 * width_ ,2 * height_);
      dest.clear();

      const unsigned char* s_itr[3];
            unsigned char*  itr1[3];
            unsigned char*  itr2[3];

      s_itr[0] = data() + 0;
      s_itr[1] = data() + 1;
      s_itr[2] = data() + 2;

      itr1[0] = dest.data() + 0;
      itr1[1] = dest.data() + 1;
      itr1[2] = dest.data() + 2;

      itr2[0] = dest.data() + dest.row_increment_ + 0;
      itr2[1] = dest.data() + dest.row_increment_ + 1;
      itr2[2] = dest.data() + dest.row_increment_ + 2;

      for (unsigned int j = 0; j < height_; ++j)
      {
         for (unsigned int i = 0; i < width_; ++i)
         {
            for (unsigned int k = 0; k < bytes_per_pixel_; s_itr[k] += bytes_per_pixel_, ++k)
            {
               *(itr1[k]) = *(s_itr[k]); itr1[k] += bytes_per_pixel_;
               *(itr1[k]) = *(s_itr[k]); itr1[k] += bytes_per_pixel_;

               *(itr2[k]) = *(s_itr[k]); itr2[k] += bytes_per_pixel_;
               *(itr2[k]) = *(s_itr[k]); itr2[k] += bytes_per_pixel_;
            }
         }

         for (unsigned int k = 0; k < bytes_per_pixel_; ++k)
         {
            itr1[k] += dest.row_increment_;
            itr2[k] += dest.row_increment_;
         }
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

vertical_flip()

void bitmap_image::vertical_flip ( )

inline

Definition at line 639 of file bitmap_image.hpp.

References row().

Referenced by reflective_image(), and test02().

   {
      for (unsigned int y = 0; y < (height_ / 2); ++y)
      {
         unsigned char* itr1 = row(y);
         unsigned char* itr2 = row(height_ - y - 1);

         for (std::size_t x = 0; x < row_increment_; ++x)
         {
            std::swap(*(itr1 + x),*(itr2 + x));
         }
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

width()

unsigned int bitmap_image::width ( ) const

inline

Definition at line 380 of file bitmap_image.hpp.

Referenced by checkered_pattern(), convert_rsp_to_image(), hierarchical_psnr(), image_drawer::pen_width(), plasma(), psnr(), psnr_region(), reverse_channels(), setwidth_height(), sobel_operator(), subsample(), test08(), test15(), test16(), test17(), test18(), and upsample().

   {
      return width_;
   }

Here is the caller graph for this function:

---

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

• bitmap/bitmap_image.hpp