bitmap_image.hpp File Reference

#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <iterator>
#include <limits>
#include <string>
#include <vector>

Include dependency graph for bitmap_image.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	bitmap_image
struct	rgb_t
class	image_drawer
class	cartesian_canvas
class	response_image< T >

Macros
#define	round(d)   std::floor(d + 0.5)

Enumerations
enum	palette_name {   e_red, e_scarlet, e_vermilion, e_tangelo,   e_orange, e_gamboge, e_amber, e_gold,   e_yellow, e_apple_green, e_lime_green, e_spring_bud,   e_chartreuse_green, e_pistachio, e_harlequin, e_sap_green,   e_green, e_emerald_green, e_malachite_green, e_sea_green,   e_spring_green, e_aquamarine, e_turquoise, e_opal,   e_cyan, e_arctic_blue, e_cerulean, e_cornflower_blue,   e_azure, e_cobalt_blue, e_sapphire_blue, e_phthalo_blue,   e_blue, e_persian_blue, e_indigo, e_blue_violet,   e_violet, e_purple, e_mulberry, e_heliotrope,   e_magenta, e_orchid, e_fuchsia, e_cerise,   e_rose, e_raspberry, e_crimson, e_amaranth,   e_white, e_black }

Functions
bool	operator== (const rgb_t &c0, const rgb_t &c1)
bool	operator!= (const rgb_t &c0, const rgb_t &c1)
std::size_t	hamming_distance (const rgb_t &c0, const rgb_t &c1)
rgb_t	make_colour (const unsigned int &red, const unsigned int &green, const unsigned int &blue)
template<typename OutputIterator >
void	generate_colours (const std::size_t &steps, const rgb_t c0, const rgb_t &c1, OutputIterator out)
template<typename ResponseImage , typename Palette >
std::size_t	convert_rsp_to_image (const ResponseImage &resp_image, const Palette &palette, bitmap_image &image)
void	rgb_to_ycbcr (const unsigned int &length, double *red, double *green, double *blue, double *y, double *cb, double *cr)
void	ycbcr_to_rgb (const unsigned int &length, double *y, double *cb, double *cr, double *red, double *green, double *blue)
void	subsample (const unsigned int &width, const unsigned int &height, const double *source, unsigned int &w, unsigned int &h, double *&dest)
void	upsample (const unsigned int &width, const unsigned int &height, const double *source, unsigned int &w, unsigned int &h, double *&dest)
void	checkered_pattern (const unsigned int x_width, const unsigned int y_width, const unsigned char value, const bitmap_image::color_plane color, bitmap_image &image)
void	checkered_pattern (const unsigned int x_width, const unsigned int y_width, const unsigned char red, const unsigned char green, const unsigned char blue, bitmap_image &image)
void	plasma (bitmap_image &image, const double &x, const double &y, const double &width, const double &height, const double &c1, const double &c2, const double &c3, const double &c4, const double &roughness=3.0, const rgb_t colormap[]=0)
void	plasma (bitmap_image &image, const double &c1, const double &c2, const double &c3, const double &c4, const double &roughness=3.0, const rgb_t colormap[]=0)
double	psnr_region (const unsigned int &x, const unsigned int &y, const unsigned int &width, const unsigned int &height, const bitmap_image &image1, const bitmap_image &image2)
void	hierarchical_psnr_r (const double &x, const double &y, const double &width, const double &height, const bitmap_image &image1, bitmap_image &image2, const double &threshold, const rgb_t colormap[])
void	hierarchical_psnr (bitmap_image &image1, bitmap_image &image2, const double threshold, const rgb_t colormap[])
rgb_t	convert_wave_length_nm_to_rgb (const double wave_length_nm)
double	weighted_distance (const unsigned char r0, const unsigned char g0, const unsigned char b0, const unsigned char r1, const unsigned char g1, const unsigned char b1)
double	weighted_distance (const rgb_t c0, const rgb_t c1)
template<typename Iterator >
rgb_t	find_nearest_color (const rgb_t &c, const Iterator begin, const Iterator end)
template<template< typename, typename > class Sequence, typename Allocator >
rgb_t	find_nearest_color (const rgb_t &c, const Sequence< rgb_t, Allocator > &seq)
template<std::size_t N>
rgb_t	find_nearest_color (const rgb_t &c, const rgb_t(&colors)[N])
double	find_nearest_wave_length (const rgb_t &c, const double increment=0.001)
void	sobel_operator (const bitmap_image &src_image, bitmap_image &dst_image, const double threshold=0.0)

Variables
const rgb_t	palette_colormap []
const rgb_t	autumn_colormap [1000]
const rgb_t	copper_colormap [1000]
const rgb_t	gray_colormap [1000]
const rgb_t	hot_colormap [1000]
const rgb_t	hsv_colormap [1000]
const rgb_t	jet_colormap [1000]
const rgb_t	prism_colormap [1000]
const rgb_t	vga_colormap [1000]
const rgb_t	yarg_colormap [1000]

Macro Definition Documentation

round

#define round

(

d

)

std::floor(d + 0.5)

Referenced by convert_wave_length_nm_to_rgb().

Enumeration Type Documentation

palette_name

enum palette_name

Enumerator
e_red
e_scarlet
e_vermilion
e_tangelo
e_orange
e_gamboge
e_amber
e_gold
e_yellow
e_apple_green
e_lime_green
e_spring_bud
e_chartreuse_green
e_pistachio
e_harlequin
e_sap_green
e_green
e_emerald_green
e_malachite_green
e_sea_green
e_spring_green
e_aquamarine
e_turquoise
e_opal
e_cyan
e_arctic_blue
e_cerulean
e_cornflower_blue
e_azure
e_cobalt_blue
e_sapphire_blue
e_phthalo_blue
e_blue
e_persian_blue
e_indigo
e_blue_violet
e_violet
e_purple
e_mulberry
e_heliotrope
e_magenta
e_orchid
e_fuchsia
e_cerise
e_rose
e_raspberry
e_crimson
e_amaranth
e_white
e_black

Definition at line 3115 of file bitmap_image.hpp.

{
  e_red,           e_scarlet,      e_vermilion,        e_tangelo,         e_orange,
  e_gamboge,       e_amber,        e_gold,             e_yellow,          e_apple_green,
  e_lime_green,    e_spring_bud,   e_chartreuse_green, e_pistachio,       e_harlequin,
  e_sap_green,     e_green,        e_emerald_green,    e_malachite_green, e_sea_green,
  e_spring_green,  e_aquamarine,   e_turquoise,        e_opal,            e_cyan,
  e_arctic_blue,   e_cerulean,     e_cornflower_blue,  e_azure,           e_cobalt_blue,
  e_sapphire_blue, e_phthalo_blue, e_blue,             e_persian_blue,    e_indigo,
  e_blue_violet,   e_violet,       e_purple,           e_mulberry,        e_heliotrope,
  e_magenta,       e_orchid,       e_fuchsia,          e_cerise,          e_rose,
  e_raspberry,     e_crimson,      e_amaranth,         e_white,           e_black
};

Function Documentation

checkered_pattern() [1/2]

void checkered_pattern ( const unsigned int  x_width, const unsigned int  y_width, const unsigned char  value, const bitmap_image::color_plane  color, bitmap_image &  image  )

inline

Definition at line 1847 of file bitmap_image.hpp.

References bitmap_image::bytes_per_pixel(), bitmap_image::height(), bitmap_image::offset(), bitmap_image::row(), and bitmap_image::width().

Referenced by test14().

{
   if (
        (x_width >= image.width ()) ||
        (y_width >= image.height())
      )
   {
      return;
   }

   bool setter_x = false;
   bool setter_y = true;

   const unsigned int color_plane_offset = image.offset(color);
   const unsigned int height = image.height();
   const unsigned int width  = image.width();

   for (unsigned int y = 0; y < height; ++y)
   {
      if (0 == (y % y_width))
      {
         setter_y = !setter_y;
      }

      unsigned char* row = image.row(y) + color_plane_offset;

      for (unsigned int x = 0; x < width; ++x, row += image.bytes_per_pixel())
      {
         if (0 == (x % x_width))
         {
            setter_x = !setter_x;
         }

         if (setter_x ^ setter_y)
         {
            *row = value;
         }
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

checkered_pattern() [2/2]

void checkered_pattern ( const unsigned int  x_width, const unsigned int  y_width, const unsigned char  red, const unsigned char  green, const unsigned char  blue, bitmap_image &  image  )

inline

Definition at line 1892 of file bitmap_image.hpp.

References bitmap_image::bytes_per_pixel(), bitmap_image::height(), bitmap_image::row(), and bitmap_image::width().

{
   if (
        (x_width >= image.width ()) ||
        (y_width >= image.height())
      )
   {
      return;
   }

   bool setter_x = false;
   bool setter_y = true;

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

   for (unsigned int y = 0; y < height; ++y)
   {
      if (0 == (y % y_width))
      {
         setter_y = !setter_y;
      }

      unsigned char* row = image.row(y);

      for (unsigned int x = 0; x < width; ++x, row += image.bytes_per_pixel())
      {
         if (0 == (x % x_width))
         {
            setter_x = !setter_x;
         }

         if (setter_x ^ setter_y)
         {
            *(row + 0) = blue;
            *(row + 1) = green;
            *(row + 2) = red;
         }
      }
   }
}

Here is the call graph for this function:

convert_rsp_to_image()

template<typename ResponseImage , typename Palette >

std::size_t convert_rsp_to_image ( const ResponseImage &  resp_image, const Palette &  palette, bitmap_image &  image  )

inline

Definition at line 1673 of file bitmap_image.hpp.

References bitmap_image::height(), bitmap_image::set_pixel(), and bitmap_image::width().

{
   if (
        (resp_image.width () > image.width ()) ||
        (resp_image.height() > image.height())
      )
      return 0;

   for (std::size_t y = 0; y < resp_image.height(); ++y)
   {
      for (std::size_t x = 0; x < resp_image.width(); ++x)
      {
         const double v = resp_image(x,y);

         unsigned int index = static_cast<unsigned int>((v < 0) ? 0 : v > (palette.size()) ? (palette.size() - 1) : v);

         image.set_pixel(x,y,palette[index]);
      }
   }

   return (resp_image.width() * resp_image.height());
}

Here is the call graph for this function:

convert_wave_length_nm_to_rgb()

rgb_t convert_wave_length_nm_to_rgb ( const double  wave_length_nm )

inline

Definition at line 2831 of file bitmap_image.hpp.

References rgb_t::blue, rgb_t::green, rgb_t::red, and round.

Referenced by find_nearest_wave_length().

{
   // Credits: Dan Bruton http://www.physics.sfasu.edu/astro/color.html
   double red   = 0.0;
   double green = 0.0;
   double blue  = 0.0;

   if ((380.0 <= wave_length_nm) && (wave_length_nm <= 439.0))
   {
      red   = -(wave_length_nm - 440.0) / (440.0 - 380.0);
      green = 0.0;
      blue  = 1.0;
   }
   else if ((440.0 <= wave_length_nm) && (wave_length_nm <= 489.0))
   {
      red   = 0.0;
      green = (wave_length_nm - 440.0) / (490.0 - 440.0);
      blue  = 1.0;
   }
   else if ((490.0 <= wave_length_nm) && (wave_length_nm <= 509.0))
   {
      red   = 0.0;
      green = 1.0;
      blue  = -(wave_length_nm - 510.0) / (510.0 - 490.0);
   }
   else if ((510.0 <= wave_length_nm) && (wave_length_nm <= 579.0))
   {
      red   = (wave_length_nm - 510.0) / (580.0 - 510.0);
      green = 1.0;
      blue  = 0.0;
   }
   else if ((580.0 <= wave_length_nm) && (wave_length_nm <= 644.0))
   {
      red   = 1.0;
      green = -(wave_length_nm - 645.0) / (645.0 - 580.0);
      blue  = 0.0;
   }
   else if ((645.0 <= wave_length_nm) && (wave_length_nm <= 780.0))
   {
      red   = 1.0;
      green = 0.0;
      blue  = 0.0;
   }

   double factor = 0.0;

   if ((380.0 <= wave_length_nm) && (wave_length_nm <= 419.0))
      factor = 0.3 + 0.7 * (wave_length_nm - 380.0) / (420.0 - 380.0);
   else if ((420.0 <= wave_length_nm) && (wave_length_nm <= 700.0))
      factor = 1.0;
   else if ((701.0 <= wave_length_nm) && (wave_length_nm <= 780.0))
      factor = 0.3 + 0.7 * (780.0 - wave_length_nm) / (780.0 - 700.0);
   else
      factor = 0.0;

   rgb_t result;

   const double gamma         =   0.8;
   const double intensity_max = 255.0;

   #define round(d) std::floor(d + 0.5)

   result.red   = static_cast<unsigned char>((red   == 0.0) ? red   : round(intensity_max * std::pow(red   * factor, gamma)));
   result.green = static_cast<unsigned char>((green == 0.0) ? green : round(intensity_max * std::pow(green * factor, gamma)));
   result.blue  = static_cast<unsigned char>((blue  == 0.0) ? blue  : round(intensity_max * std::pow(blue  * factor, gamma)));

   #undef round

   return result;
}

Here is the caller graph for this function:

find_nearest_color() [1/3]

template<typename Iterator >

rgb_t find_nearest_color ( const rgb_t &  c, const Iterator  begin, const Iterator  end  )

inline

Definition at line 2919 of file bitmap_image.hpp.

References weighted_distance().

Referenced by find_nearest_color().

{
   if (0 == std::distance(begin,end))
      return c;

   double min_d = std::numeric_limits<double>::max();
   rgb_t result = *begin;

   for (Iterator itr = begin; itr != end; ++itr)
   {
      if (c == (*itr))
      {
         return (*itr);
      }

      double curr_d = weighted_distance(c,*itr);

      if (curr_d < min_d)
      {
          min_d = curr_d;
         result = *itr;
      }
   }

   return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_nearest_color() [2/3]

template<template< typename, typename > class Sequence, typename Allocator >

rgb_t find_nearest_color ( const rgb_t &  c, const Sequence< rgb_t, Allocator > &  seq  )

inline

Definition at line 2948 of file bitmap_image.hpp.

References find_nearest_color().

{
   return find_nearest_color(c, seq.begin(),seq.end());
}

Here is the call graph for this function:

find_nearest_color() [3/3]

template<std::size_t N>

rgb_t find_nearest_color ( const rgb_t &  c, const rgb_t(&)  colors[N]  )

inline

Definition at line 2954 of file bitmap_image.hpp.

References find_nearest_color().

{
   return find_nearest_color(c, colors, colors + N);
}

Here is the call graph for this function:

find_nearest_wave_length()

double find_nearest_wave_length ( const rgb_t &  c, const double  increment = 0.001  )

inline

Definition at line 2959 of file bitmap_image.hpp.

References convert_wave_length_nm_to_rgb(), and weighted_distance().

{
   const double max_wave_length = 800.0; //800nm

   double min_wave_length = 0.0;
   double min_d           = std::numeric_limits<double>::max();

   for (double i = 0.0; i < max_wave_length; i += increment)
   {
      rgb_t  curr_rgb = convert_wave_length_nm_to_rgb(i);

      if (c == curr_rgb)
      {
         return i;
      }

      const double curr_d = weighted_distance(c, curr_rgb);

      if (curr_d <= min_d)
      {
         min_wave_length = i;
         min_d = curr_d;
      }
   }

   return min_wave_length;
}

Here is the call graph for this function:

generate_colours()

template<typename OutputIterator >

void generate_colours ( const std::size_t &  steps, const rgb_t  c0, const rgb_t &  c1, OutputIterator  out  )

inline

Definition at line 1654 of file bitmap_image.hpp.

References rgb_t::blue, rgb_t::green, and rgb_t::red.

{
   double dr = ((double)c1.red   -  (double)c0.red   ) / steps;
   double dg = ((double)c1.green -  (double)c0.green ) / steps;
   double db = ((double)c1.blue  -  (double)c0.blue  ) / steps;

   for (std::size_t i = 0; i < steps; ++i)
   {
      rgb_t c;

      c.red   = static_cast<unsigned char>(c0.red   + (i * dr));
      c.green = static_cast<unsigned char>(c0.green + (i * dg));
      c.blue  = static_cast<unsigned char>(c0.blue  + (i * db));

      *(out++) = c;
   }
}

hamming_distance()

std::size_t hamming_distance ( const rgb_t &  c0, const rgb_t &  c1  )

inline

Definition at line 1631 of file bitmap_image.hpp.

References rgb_t::blue, rgb_t::green, and rgb_t::red.

{
   std::size_t result = 0;

   if (c0.red   != c1  .red) ++result;
   if (c0.green != c1.green) ++result;
   if (c0.blue  != c1 .blue) ++result;

   return result;
}

hierarchical_psnr()

void hierarchical_psnr ( bitmap_image &  image1, bitmap_image &  image2, const double  threshold, const rgb_t  colormap[]  )

inline

Definition at line 2076 of file bitmap_image.hpp.

References bitmap_image::height(), hierarchical_psnr_r(), bitmap_image::psnr(), psnr_region(), and bitmap_image::width().

{
   if (
        (image1.width()  != image2.width ()) ||
        (image1.height() != image2.height())
      )
   {
      return;
   }

   double psnr = psnr_region(0,0,image1.width(),image1.height(),image1,image2);

   if (psnr < threshold)
   {
      hierarchical_psnr_r(0, 0, image1.width(), image1.height(),
                          image1, image2,
                          threshold, colormap);
   }
}

Here is the call graph for this function:

hierarchical_psnr_r()

void hierarchical_psnr_r ( const double &  x, const double &  y, const double &  width, const double &  height, const bitmap_image &  image1, bitmap_image &  image2, const double &  threshold, const rgb_t  colormap[]  )

inline

Definition at line 2034 of file bitmap_image.hpp.

References rgb_t::blue, rgb_t::green, bitmap_image::psnr(), psnr_region(), rgb_t::red, and bitmap_image::set_region().

Referenced by hierarchical_psnr().

{
   if ((width <= 4.0) || (height <= 4.0))
   {
      double psnr = psnr_region(
                                 static_cast<unsigned int>(x),
                                 static_cast<unsigned int>(y),
                                 static_cast<unsigned int>(width),
                                 static_cast<unsigned int>(height),
                                 image1, image2
                               );

      if (psnr < threshold)
      {
         rgb_t c = colormap[static_cast<unsigned int>(1000.0 * (1.0 - (psnr / threshold)))];

         image2.set_region(
                            static_cast<unsigned int>(x),
                            static_cast<unsigned int>(y),
                            static_cast<unsigned int>(width + 1),
                            static_cast<unsigned int>(height + 1),
                            c.red, c.green, c.blue
                          );
      }
   }
   else
   {
      double half_width  = ( width / 2.0);
      double half_height = (height / 2.0);

      hierarchical_psnr_r(x             , y              , half_width, half_height, image1, image2, threshold, colormap);
      hierarchical_psnr_r(x + half_width, y              , half_width, half_height, image1, image2, threshold, colormap);
      hierarchical_psnr_r(x + half_width, y + half_height, half_width, half_height, image1, image2, threshold, colormap);
      hierarchical_psnr_r(x             , y + half_height, half_width, half_height, image1, image2, threshold, colormap);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

make_colour()

rgb_t make_colour ( const unsigned int &  red, const unsigned int &  green, const unsigned int &  blue  )

inline

Definition at line 1642 of file bitmap_image.hpp.

References rgb_t::blue, rgb_t::green, and rgb_t::red.

{
   rgb_t result;

   result.red   = static_cast<unsigned char>(red  );
   result.green = static_cast<unsigned char>(green);
   result.blue  = static_cast<unsigned char>(blue );

   return result;
}

operator!=()

bool operator!= ( const rgb_t &  c0, const rgb_t &  c1  )

inline

Definition at line 1624 of file bitmap_image.hpp.

References rgb_t::blue, rgb_t::green, and rgb_t::red.

{
   return (c0.red   != c1  .red) ||
          (c0.green != c1.green) ||
          (c0.blue  != c1 .blue);
}

operator==()

bool operator== ( const rgb_t &  c0, const rgb_t &  c1  )

inline

Definition at line 1617 of file bitmap_image.hpp.

References rgb_t::blue, rgb_t::green, and rgb_t::red.

{
   return (c0.red   == c1  .red) &&
          (c0.green == c1.green) &&
          (c0.blue  == c1 .blue);
}

plasma() [1/2]

void plasma ( bitmap_image &  image, const double &  x, const double &  y, const double &  width, const double &  height, const double &  c1, const double &  c2, const double &  c3, const double &  c4, const double &  roughness = 3.0, const rgb_t  colormap[] = 0  )

inline

Definition at line 1939 of file bitmap_image.hpp.

References bitmap_image::height(), bitmap_image::set_pixel(), and bitmap_image::width().

Referenced by plasma(), test15(), test16(), and test17().

{
   // Note: c1,c2,c3,c4 -> [0.0,1.0]

   double half_width  = ( width / 2.0);
   double half_height = (height / 2.0);

   if ((width >= 1.0) || (height >= 1.0))
   {
      double corner1 = (c1 + c2) / 2.0;
      double corner2 = (c2 + c3) / 2.0;
      double corner3 = (c3 + c4) / 2.0;
      double corner4 = (c4 + c1) / 2.0;
      double center  = (c1 + c2 + c3 + c4) / 4.0 +
                       ((1.0 * ::rand() /(1.0 * RAND_MAX))  - 0.5) * // should use a better rng
                       ((1.0 * half_width + half_height) / (image.width() + image.height()) * roughness);

      center = std::min<double>(std::max<double>(0.0,center),1.0);

      plasma(image, x,                            y, half_width, half_height,      c1, corner1,  center, corner4,roughness,colormap);
      plasma(image, x + half_width,               y, half_width, half_height, corner1,      c2, corner2,  center,roughness,colormap);
      plasma(image, x + half_width, y + half_height, half_width, half_height,  center, corner2,      c3, corner3,roughness,colormap);
      plasma(image, x,              y + half_height, half_width, half_height, corner4,  center, corner3,      c4,roughness,colormap);
   }
   else
   {
      rgb_t color = colormap[static_cast<unsigned int>(1000.0 * ((c1 + c2 + c3 + c4) / 4.0)) % 1000];

      image.set_pixel(static_cast<unsigned int>(x),static_cast<unsigned int>(y),color);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

plasma() [2/2]

void plasma ( bitmap_image &  image, const double &  c1, const double &  c2, const double &  c3, const double &  c4, const double &  roughness = 3.0, const rgb_t  colormap[] = 0  )

inline

Definition at line 1977 of file bitmap_image.hpp.

References bitmap_image::height(), plasma(), and bitmap_image::width().

{
   plasma
   (
     image, 0, 0, image.width(), image.height(),
     c1, c2, c3, c4,
     roughness, colormap
   );
}

Here is the call graph for this function:

psnr_region()

double psnr_region ( const unsigned int &  x, const unsigned int &  y, const unsigned int &  width, const unsigned int &  height, const bitmap_image &  image1, const bitmap_image &  image2  )

inline

Definition at line 1991 of file bitmap_image.hpp.

References bitmap_image::bytes_per_pixel(), bitmap_image::height(), bitmap_image::row(), and bitmap_image::width().

Referenced by hierarchical_psnr(), and hierarchical_psnr_r().

{
   if (
        (image1.width()  != image2.width ()) ||
        (image1.height() != image2.height())
      )
   {
      return 0.0;
   }

   if ((x + width ) > image1.width() ) { return 0.0; }
   if ((y + height) > image1.height()) { return 0.0; }

   double mse = 0.0;

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

      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 * 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:

rgb_to_ycbcr()

void rgb_to_ycbcr ( const unsigned int &  length, double *  red, double *  green, double *  blue, double *  y, double *  cb, double *  cr  )

inline

Definition at line 1696 of file bitmap_image.hpp.

{
   unsigned int i = 0;

   while (i < length)
   {
      ( *y) =   16.0 + (  65.481 * (*red) +  128.553 * (*green) +  24.966 * (*blue));
      (*cb) =  128.0 + ( -37.797 * (*red) +  -74.203 * (*green) + 112.000 * (*blue));
      (*cr) =  128.0 + ( 112.000 * (*red) +  -93.786 * (*green) -  18.214 * (*blue));

      ++i;
      ++red; ++green; ++blue;
      ++y;   ++cb;    ++cr;
   }
}

sobel_operator()

void sobel_operator ( const bitmap_image &  src_image, bitmap_image &  dst_image, const double  threshold = 0.0  )

inline

Definition at line 3069 of file bitmap_image.hpp.

References bitmap_image::export_gray_scale_response_image(), bitmap_image::height(), response_image< T >::height(), bitmap_image::import_gray_scale_clamped(), response_image< T >::row(), bitmap_image::setwidth_height(), bitmap_image::width(), and response_image< T >::width().

{
   typedef double T;

   response_image<T> im0(src_image.width(), src_image.height(), 0.0);
   response_image<T> im1(src_image.width(), src_image.height(), 0.0);

   src_image.export_gray_scale_response_image(&im0(0,0));

   for (std::size_t y = 1; y < im0.height() - 1; ++y)
   {
      const T* itr0 = im0.row(y - 1);
      const T* itr1 = im0.row(y    );
      const T* itr2 = im0.row(y + 1);
            T* out  = im1.row(y    ) + 1;

      for (std::size_t x = 1; x < im0.width() - 1; ++x)
      {
         const T c0 = *(itr0 + x - 1);   const T c1 = *(itr0 + x);   const T c2 = *(itr0 + x + 1);
         const T c3 = *(itr1 + x - 1); /*const T c4 = *(itr1 + x);*/ const T c5 = *(itr1 + x + 1);
         const T c6 = *(itr2 + x - 1);   const T c7 = *(itr2 + x);   const T c8 = *(itr2 + x + 1);

         const T gx = (2.0 * (c5 - c3)) + (c2 - c0) + (c8 - c6);
         const T gy = (2.0 * (c1 - c7)) + (c0 - c6) + (c2 - c8);

         *(out++) = std::sqrt((gx * gx) + (gy * gy));
      }
   }

   if (threshold > 0.0)
   {
      const T* end = im1.row(0) + (im1.width() * im1.height());

      for (T* itr = im1.row(0); itr != end; ++itr)
      {
         T& v = *itr;
         if (v <= threshold) v = 0;
      }
   }

   dst_image.setwidth_height(im1.width(), im1.height());
   dst_image.import_gray_scale_clamped(&im1(0,0));
}

Here is the call graph for this function:

subsample()

void subsample ( const unsigned int &  width, const unsigned int &  height, const double *  source, unsigned int &  w, unsigned int &  h, double *&  dest  )

inline

Definition at line 1734 of file bitmap_image.hpp.

References bitmap_image::width().

{
   /*  Single channel.  */

   w = 0;
   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 = new double[w * h];

         double* s_itr = dest;
   const double* itr1  = source;
   const double* itr2  = source + width;

   for (unsigned int j = 0; j < vertical_upper; ++j)
   {
      for (unsigned int i = 0; i < horizontal_upper; ++i, ++s_itr)
      {
          (*s_itr)  = *(itr1++);
          (*s_itr) += *(itr1++);
          (*s_itr) += *(itr2++);
          (*s_itr) += *(itr2++);
          (*s_itr) /=  4.0;
      }

      if (odd_width)
      {
         (*(s_itr++)) = ((*itr1++) + (*itr2++)) / 2.0;
      }

      itr1 += width;

      if (j != (vertical_upper -1))
      {
         itr2 += width;
      }
   }

   if (odd_height)
   {
      for (unsigned int i = 0; i < horizontal_upper; ++i, ++s_itr)
      {
         (*s_itr) += (*(itr1++));
         (*s_itr) += (*(itr1++));
         (*s_itr) /= 2.0;
      }

      if (odd_width)
      {
         (*(s_itr++)) = (*itr1);
      }
   }
}

Here is the call graph for this function:

upsample()

void upsample ( const unsigned int &  width, const unsigned int &  height, const double *  source, unsigned int &  w, unsigned int &  h, double *&  dest  )

inline

Definition at line 1814 of file bitmap_image.hpp.

References bitmap_image::height(), and bitmap_image::width().

{
   /* Single channel. */

   w = 2 * width;
   h = 2 * height;

   dest = new double[w * h];

   const double* s_itr = source;
         double* itr1  = dest;
         double* itr2  = dest + w;

   for (unsigned int j = 0; j < height; ++j)
   {
      for (unsigned int i = 0; i < width; ++i, ++s_itr)
      {
          *(itr1++) = (*s_itr);
          *(itr1++) = (*s_itr);
          *(itr2++) = (*s_itr);
          *(itr2++) = (*s_itr);
      }

      itr1 += w;
      itr2 += w;
   }
}

Here is the call graph for this function:

weighted_distance() [1/2]

double weighted_distance ( const unsigned char  r0, const unsigned char  g0, const unsigned char  b0, const unsigned char  r1, const unsigned char  g1, const unsigned char  b1  )

inline

Definition at line 2902 of file bitmap_image.hpp.

Referenced by find_nearest_color(), find_nearest_wave_length(), and weighted_distance().

{
   const double diff_r = /*0.30 */ (r0 - r1);
   const double diff_g = /*0.59 */ (g0 - g1);
   const double diff_b = /*0.11 */ (b0 - b1);

   return std::sqrt((diff_r * diff_r) + (diff_g * diff_g) + (diff_b * diff_b));
}

Here is the caller graph for this function:

weighted_distance() [2/2]

double weighted_distance ( const rgb_t  c0, const rgb_t  c1  )

inline

Definition at line 2912 of file bitmap_image.hpp.

References rgb_t::blue, rgb_t::green, rgb_t::red, and weighted_distance().

{
   return weighted_distance(c0.red, c0.green, c0.blue,
                            c1.red, c1.green, c1.blue);
}

Here is the call graph for this function:

ycbcr_to_rgb()

void ycbcr_to_rgb ( const unsigned int &  length, double *  y, double *  cb, double *  cr, double *  red, double *  green, double *  blue  )

inline

Definition at line 1713 of file bitmap_image.hpp.

{
   unsigned int i = 0;

   while (i < length)
   {
      double y_  =  (*y) -  16.0;
      double cb_ = (*cb) - 128.0;
      double cr_ = (*cr) - 128.0;

        (*red) = 0.000456621 * y_                    + 0.00625893 * cr_;
      (*green) = 0.000456621 * y_ - 0.00153632 * cb_ - 0.00318811 * cr_;
       (*blue) = 0.000456621 * y_                    + 0.00791071 * cb_;

      ++i;
      ++red; ++green; ++blue;
      ++y;   ++cb;    ++cr;
   }
}

Variable Documentation

autumn_colormap

const rgb_t autumn_colormap[1000]

Definition at line 3142 of file bitmap_image.hpp.

Referenced by test18().

copper_colormap

const rgb_t copper_colormap[1000]

Definition at line 3345 of file bitmap_image.hpp.

Referenced by test18().

gray_colormap

const rgb_t gray_colormap[1000]

Definition at line 3548 of file bitmap_image.hpp.

Referenced by test18().

hot_colormap

const rgb_t hot_colormap[1000]

Definition at line 3751 of file bitmap_image.hpp.

Referenced by test18().

hsv_colormap

const rgb_t hsv_colormap[1000]

Definition at line 3954 of file bitmap_image.hpp.

Referenced by test18(), and test20().

jet_colormap

const rgb_t jet_colormap[1000]

Definition at line 4157 of file bitmap_image.hpp.

Referenced by test09(), test15(), test16(), test17(), test18(), and test20().

palette_colormap

const rgb_t palette_colormap[]

Initial value:

= {
   {255,   0,   0}, {255,  31,   0}, {255,  63,   0}, {255,  95,   0}, {255, 127,   0},
   {255, 159,   0}, {255, 191,   0}, {255, 223,   0}, {255, 255,   0}, {223, 255,   0},
   {191, 255,   0}, {159, 255,   0}, {127, 255,   0}, { 95, 255,   0}, { 63, 255,   0},
   { 31, 255,   0}, {  0, 255,   0}, {  0, 255,  31}, {  0, 255,  63}, {  0, 255,  95},
   {  0, 255, 127}, {  0, 255, 159}, {  0, 255, 191}, {  0, 255, 223}, {  0, 255, 255},
   {  0, 223, 255}, {  0, 191, 255}, {  0, 159, 255}, {  0, 127, 255}, {  0,  95, 255},
   {  0,  63, 255}, {  0,  31, 255}, {  0,   0, 255}, { 31,   0, 255}, { 63,   0, 255},
   { 95,   0, 255}, {127,   0, 255}, {159,   0, 255}, {191,   0, 255}, {223,   0, 255},
   {255,   0, 255}, {255,   0, 223}, {255,   0, 191}, {255,   0, 159}, {255,   0, 127},
   {255,   0,  95}, {255,   0,  63}, {255,   0,  31}, {255, 255, 255}, {  0,   0,   0}
}

Definition at line 3129 of file bitmap_image.hpp.

Referenced by test18(), and test19().

prism_colormap

const rgb_t prism_colormap[1000]

Definition at line 4360 of file bitmap_image.hpp.

Referenced by test18(), and test20().

vga_colormap

const rgb_t vga_colormap[1000]

Definition at line 4563 of file bitmap_image.hpp.

Referenced by test18(), and test20().

yarg_colormap

const rgb_t yarg_colormap[1000]

Definition at line 4766 of file bitmap_image.hpp.

Referenced by test18().