C++ Bitmap Image Reader Writer Library http://partow.net/programming/bitmap/index.html

ArashPartow · ArashPartow · commit 7b671cb89fec · 2017-09-13T21:03:14.000+10:00
diff --git a/bitmap_image.hpp b/bitmap_image.hpp
@@ -119,7 +119,7 @@ class bitmap_image
 
    inline void clear(const unsigned char v = 0x00)
    {
-      std::fill(data_.begin(),data_.end(),v);
+      std::fill(data_.begin(), data_.end(), v);
    }
 
    inline unsigned char red_channel(const unsigned int x, const unsigned int y) const
@@ -160,7 +160,7 @@ class bitmap_image
    inline void get_pixel(const unsigned int x, const unsigned int y,
                          unsigned char& red,
                          unsigned char& green,
-                         unsigned char& blue)
+                         unsigned char& blue) const
    {
       const unsigned int y_offset = y * row_increment_;
       const unsigned int x_offset = x * bytes_per_pixel_;
@@ -171,8 +171,7 @@ class bitmap_image
    }
 
    template <typename RGB>
-   inline void get_pixel(const unsigned int x, const unsigned int y,
-                         RGB& colour)
+   inline void get_pixel(const unsigned int x, const unsigned int y, RGB& colour) const
    {
       get_pixel(x, y, colour.red, colour.green, colour.blue);
    }
@@ -224,7 +223,7 @@ class bitmap_image
          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);
+         std::copy(itr2, itr2_end, itr1);
       }
 
       return true;
@@ -234,7 +233,7 @@ class bitmap_image
                       const unsigned int& y     ,
                       const unsigned int& width ,
                       const unsigned int& height,
-                      bitmap_image& dest_image  )
+                      bitmap_image& dest_image  ) const
    {
       if ((x + width ) > width_ ) { return false; }
       if ((y + height) > height_) { return false; }
@@ -253,7 +252,7 @@ class bitmap_image
          unsigned char* itr1_end = itr1 + (width * bytes_per_pixel_);
          unsigned char* itr2     = dest_image.row(r);
 
-         std::copy(itr1,itr1_end,itr2);
+         std::copy(itr1, itr1_end, itr2);
       }
 
       return true;
@@ -263,7 +262,7 @@ class bitmap_image
                                const unsigned int& cy    ,
                                const unsigned int& width ,
                                const unsigned int& height,
-                               bitmap_image& dest_image  )
+                               bitmap_image& dest_image  ) const
    {
       return region(cx - (width / 2), cy - (height / 2),
                     width, height,
@@ -284,7 +283,7 @@ class bitmap_image
          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);
+         std::fill(itr, itr_end, value);
       }
 
       return true;
@@ -409,7 +408,7 @@ class bitmap_image
 
       if (clear)
       {
-         std::fill(data_.begin(),data_.end(),static_cast<unsigned char>(0x00));
+         std::fill(data_.begin(), data_.end(), static_cast<unsigned char>(0x00));
       }
    }
 
@@ -749,7 +748,7 @@ class bitmap_image
       }
    }
 
-   inline void export_ycbcr(double* y, double* cb, double* cr)
+   inline void export_ycbcr(double* y, double* cb, double* cr) const
    {
       if (bgr_mode != channel_mode_)
          return;
@@ -917,7 +916,7 @@ class bitmap_image
       }
    }
 
-   inline void subsample(bitmap_image& dest)
+   inline void subsample(bitmap_image& dest) const
    {
       /*
          Half sub-sample of original image.
@@ -1045,7 +1044,7 @@ class bitmap_image
       }
    }
 
-   inline void upsample(bitmap_image& dest)
+   inline void upsample(bitmap_image& dest) const
    {
       /*
          2x up-sample of original image.
@@ -1107,9 +1106,9 @@ class bitmap_image
          return;
       }
 
-      unsigned char* itr1       = data();
-      unsigned char* itr1_end   = end();
-      const unsigned char* itr2 = image.data();
+      unsigned char* itr1           = data();
+      const unsigned char* itr1_end = end();
+      const unsigned char* itr2     = image.data();
 
       double alpha_compliment = 1.0 - alpha;
 
@@ -1131,7 +1130,7 @@ class bitmap_image
          return 0.0;
       }
 
-      unsigned char*       itr1 = data();
+      const unsigned char* itr1 = data();
       const unsigned char* itr2 = image.data();
 
       double mse = 0.0;
@@ -1171,9 +1170,9 @@ class bitmap_image
 
       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);
+         const unsigned char* itr1     = row(r + y) + x * bytes_per_pixel_;
+         const unsigned char* itr1_end = itr1 + (width * bytes_per_pixel_);
+         const unsigned char* itr2     = image.row(r);
 
          while (itr1 != itr1_end)
          {
@@ -1195,17 +1194,17 @@ class bitmap_image
       }
    }
 
-   inline void histogram(const color_plane color, double hist[256])
+   inline void histogram(const color_plane color, double hist[256]) const
    {
-      std::fill(hist,hist + 256,0.0);
+      std::fill(hist, hist + 256, 0.0);
 
-      for (unsigned char* itr = (data() + offset(color)); itr < end(); itr += bytes_per_pixel_)
+      for (const unsigned char* itr = (data() + offset(color)); itr < end(); itr += bytes_per_pixel_)
       {
          ++hist[(*itr)];
       }
    }
 
-   inline void histogram_normalized(const color_plane color, double hist[256])
+   inline void histogram_normalized(const color_plane color, double hist[256]) const
    {
       histogram(color,hist);
 
@@ -1219,7 +1218,7 @@ class bitmap_image
       }
    }
 
-   inline unsigned int offset(const color_plane color)
+   inline unsigned int offset(const color_plane color) const
    {
       switch (channel_mode_)
       {
@@ -1303,7 +1302,7 @@ class bitmap_image
 
       void clear()
       {
-         std::memset(this,0x00,sizeof(bitmap_file_header));
+         std::memset(this, 0x00, sizeof(bitmap_file_header));
       }
    };
 
@@ -1338,7 +1337,7 @@ class bitmap_image
 
       void clear()
       {
-         std::memset(this,0x00,sizeof(bitmap_information_header));
+         std::memset(this, 0x00, sizeof(bitmap_information_header));
       }
    };
 
@@ -1430,13 +1429,13 @@ class bitmap_image
 
       if (big_endian())
       {
-         bih.size        = flip(bih.size                 );
-         bih.width       = flip(bih.width                );
-         bih.height      = flip(bih.height               );
-         bih.planes      = flip(bih.planes               );
-         bih.bit_count   = flip(bih.bit_count            );
-         bih.compression = flip(bih.compression          );
-         bih.size_image  = flip(bih.size_image           );
+         bih.size          = flip(bih.size               );
+         bih.width         = flip(bih.width              );
+         bih.height        = flip(bih.height             );
+         bih.planes        = flip(bih.planes             );
+         bih.bit_count     = flip(bih.bit_count          );
+         bih.compression   = flip(bih.compression        );
+         bih.size_image    = flip(bih.size_image         );
          bih.x_pels_per_meter = flip(bih.x_pels_per_meter);
          bih.y_pels_per_meter = flip(bih.y_pels_per_meter);
          bih.clr_used      = flip(bih.clr_used           );
@@ -1476,7 +1475,7 @@ class bitmap_image
       }
    }
 
-   inline std::size_t file_size(const std::string& file_name)
+   inline std::size_t file_size(const std::string& file_name) const
    {
       std::ifstream file(file_name.c_str(),std::ios::in | std::ios::binary);
       if (!file) return 0;
@@ -1588,7 +1587,7 @@ class bitmap_image
    }
 
    template <typename T>
-   inline T clamp(const T& v, const T& lower_range, const T& upper_range)
+   inline T clamp(const T& v, const T& lower_range, const T& upper_range) const
    {
       if (v < lower_range)
          return lower_range;
@@ -2117,25 +2116,25 @@ class image_drawer
 
    void rectangle(int x1, int y1, int x2, int y2)
    {
-      line_segment(x1,y1,x2,y1);
-      line_segment(x2,y1,x2,y2);
-      line_segment(x2,y2,x1,y2);
-      line_segment(x1,y2,x1,y1);
+      line_segment(x1, y1, x2, y1);
+      line_segment(x2, y1, x2, y2);
+      line_segment(x2, y2, x1, y2);
+      line_segment(x1, y2, x1, y1);
    }
 
    void triangle(int x1, int y1, int x2, int y2,int x3, int y3)
    {
-      line_segment(x1,y1,x2,y2);
-      line_segment(x2,y2,x3,y3);
-      line_segment(x3,y3,x1,y1);
+      line_segment(x1, y1, x2, y2);
+      line_segment(x2, y2, x3, y3);
+      line_segment(x3, y3, x1, y1);
    }
 
    void quadix(int x1, int y1, int x2, int y2,int x3, int y3, int x4, int y4)
    {
-      line_segment(x1,y1,x2,y2);
-      line_segment(x2,y2,x3,y3);
-      line_segment(x3,y3,x4,y4);
-      line_segment(x4,y4,x1,y1);
+      line_segment(x1, y1, x2, y2);
+      line_segment(x2, y2, x3, y3);
+      line_segment(x3, y3, x4, y4);
+      line_segment(x4, y4, x1, y1);
    }
 
    void line_segment(int x1, int y1, int x2, int y2)
@@ -2538,8 +2537,8 @@ class cartesian_canvas
 
          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));
+            const double m0 = (p1.first - p0.first) / (2.0 * (p1.second - p0.second));
+            const double m1 = (p2.first - p0.first) / (2.0 * (p2.second - p0.second));
 
             double x0 = p0.first;
             double x1 = p0.first;
@@ -2555,8 +2554,8 @@ class cartesian_canvas
 
          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));
+            const double m0 = (p2.first - p0.first) / (2.0 * (p2.second - p0.second));
+            const double m1 = (p2.first - p1.first) / (2.0 * (p2.second - p1.second));
 
             double x0 = p2.first;
             double x1 = p2.first;
@@ -2975,7 +2974,7 @@ inline double find_nearest_wave_length(const rgb_t& c, const double increment =
 
    for (double i = 0.0; i < max_wave_length; i += increment)
    {
-      rgb_t  curr_rgb = convert_wave_length_nm_to_rgb(i);
+      const rgb_t  curr_rgb = convert_wave_length_nm_to_rgb(i);
 
       if (c == curr_rgb)
       {

Original file line number	Diff line number	Diff line change
`@@ -119,7 +119,7 @@ class bitmap_image`
`119`	`119`
`120`	`120`	`inline void clear(const unsigned char v = 0x00)`
`121`	`121`	`{`
`122`		`- std::fill(data_.begin(),data_.end(),v);`
	`122`	`+ std::fill(data_.begin(), data_.end(), v);`
`123`	`123`	`}`
`124`	`124`
`125`	`125`	`inline unsigned char red_channel(const unsigned int x, const unsigned int y) const`
`@@ -160,7 +160,7 @@ class bitmap_image`
`160`	`160`	`inline void get_pixel(const unsigned int x, const unsigned int y,`
`161`	`161`	`unsigned char& red,`
`162`	`162`	`unsigned char& green,`
`163`		`- unsigned char& blue)`
	`163`	`+ unsigned char& blue) const`
`164`	`164`	`{`
`165`	`165`	`const unsigned int y_offset = y * row_increment_;`
`166`	`166`	`const unsigned int x_offset = x * bytes_per_pixel_;`
`@@ -171,8 +171,7 @@ class bitmap_image`
`171`	`171`	`}`
`172`	`172`
`173`	`173`	`template <typename RGB>`
`174`		`- inline void get_pixel(const unsigned int x, const unsigned int y,`
`175`		`- RGB& colour)`
	`174`	`+ inline void get_pixel(const unsigned int x, const unsigned int y, RGB& colour) const`
`176`	`175`	`{`
`177`	`176`	`get_pixel(x, y, colour.red, colour.green, colour.blue);`
`178`	`177`	`}`
`@@ -224,7 +223,7 @@ class bitmap_image`
`224`	`223`	`const unsigned char* itr2 = source_image.row(y);`
`225`	`224`	`const unsigned char* itr2_end = itr2 + source_image.width_ * bytes_per_pixel_;`
`226`	`225`
`227`		`- std::copy(itr2,itr2_end,itr1);`
	`226`	`+ std::copy(itr2, itr2_end, itr1);`
`228`	`227`	`}`
`229`	`228`
`230`	`229`	`return true;`
`@@ -234,7 +233,7 @@ class bitmap_image`
`234`	`233`	`const unsigned int& y ,`
`235`	`234`	`const unsigned int& width ,`
`236`	`235`	`const unsigned int& height,`
`237`		`- bitmap_image& dest_image )`
	`236`	`+ bitmap_image& dest_image ) const`
`238`	`237`	`{`
`239`	`238`	`if ((x + width ) > width_ ) { return false; }`
`240`	`239`	`if ((y + height) > height_) { return false; }`
`@@ -253,7 +252,7 @@ class bitmap_image`
`253`	`252`	`unsigned char* itr1_end = itr1 + (width * bytes_per_pixel_);`
`254`	`253`	`unsigned char* itr2 = dest_image.row(r);`
`255`	`254`
`256`		`- std::copy(itr1,itr1_end,itr2);`
	`255`	`+ std::copy(itr1, itr1_end, itr2);`
`257`	`256`	`}`
`258`	`257`
`259`	`258`	`return true;`
`@@ -263,7 +262,7 @@ class bitmap_image`
`263`	`262`	`const unsigned int& cy ,`
`264`	`263`	`const unsigned int& width ,`
`265`	`264`	`const unsigned int& height,`
`266`		`- bitmap_image& dest_image )`
	`265`	`+ bitmap_image& dest_image ) const`
`267`	`266`	`{`
`268`	`267`	`return region(cx - (width / 2), cy - (height / 2),`
`269`	`268`	`width, height,`
`@@ -284,7 +283,7 @@ class bitmap_image`
`284`	`283`	`unsigned char* itr = row(r + y) + x * bytes_per_pixel_;`
`285`	`284`	`unsigned char* itr_end = itr + (width * bytes_per_pixel_);`
`286`	`285`
`287`		`- std::fill(itr,itr_end,value);`
	`286`	`+ std::fill(itr, itr_end, value);`
`288`	`287`	`}`
`289`	`288`
`290`	`289`	`return true;`
`@@ -409,7 +408,7 @@ class bitmap_image`
`409`	`408`
`410`	`409`	`if (clear)`
`411`	`410`	`{`
`412`		`- std::fill(data_.begin(),data_.end(),static_cast<unsigned char>(0x00));`
	`411`	`+ std::fill(data_.begin(), data_.end(), static_cast<unsigned char>(0x00));`
`413`	`412`	`}`
`414`	`413`	`}`
`415`	`414`
`@@ -749,7 +748,7 @@ class bitmap_image`
`749`	`748`	`}`
`750`	`749`	`}`
`751`	`750`
`752`		`- inline void export_ycbcr(double* y, double* cb, double* cr)`
	`751`	`+ inline void export_ycbcr(double* y, double* cb, double* cr) const`
`753`	`752`	`{`
`754`	`753`	`if (bgr_mode != channel_mode_)`
`755`	`754`	`return;`
`@@ -917,7 +916,7 @@ class bitmap_image`
`917`	`916`	`}`
`918`	`917`	`}`
`919`	`918`
`920`		`- inline void subsample(bitmap_image& dest)`
	`919`	`+ inline void subsample(bitmap_image& dest) const`
`921`	`920`	`{`
`922`	`921`	`/*`
`923`	`922`	`Half sub-sample of original image.`
`@@ -1045,7 +1044,7 @@ class bitmap_image`
`1045`	`1044`	`}`
`1046`	`1045`	`}`
`1047`	`1046`
`1048`		`- inline void upsample(bitmap_image& dest)`
	`1047`	`+ inline void upsample(bitmap_image& dest) const`
`1049`	`1048`	`{`
`1050`	`1049`	`/*`
`1051`	`1050`	`2x up-sample of original image.`
`@@ -1107,9 +1106,9 @@ class bitmap_image`
`1107`	`1106`	`return;`
`1108`	`1107`	`}`
`1109`	`1108`
`1110`		`- unsigned char* itr1 = data();`
`1111`		`- unsigned char* itr1_end = end();`
`1112`		`- const unsigned char* itr2 = image.data();`
	`1109`	`+ unsigned char* itr1 = data();`
	`1110`	`+ const unsigned char* itr1_end = end();`
	`1111`	`+ const unsigned char* itr2 = image.data();`
`1113`	`1112`
`1114`	`1113`	`double alpha_compliment = 1.0 - alpha;`
`1115`	`1114`
`@@ -1131,7 +1130,7 @@ class bitmap_image`
`1131`	`1130`	`return 0.0;`
`1132`	`1131`	`}`
`1133`	`1132`
`1134`		`- unsigned char* itr1 = data();`
	`1133`	`+ const unsigned char* itr1 = data();`
`1135`	`1134`	`const unsigned char* itr2 = image.data();`
`1136`	`1135`
`1137`	`1136`	`double mse = 0.0;`
`@@ -1171,9 +1170,9 @@ class bitmap_image`
`1171`	`1170`
`1172`	`1171`	`for (unsigned int r = 0; r < height; ++r)`
`1173`	`1172`	`{`
`1174`		`- unsigned char* itr1 = row(r + y) + x * bytes_per_pixel_;`
`1175`		`- unsigned char* itr1_end = itr1 + (width * bytes_per_pixel_);`
`1176`		`- const unsigned char* itr2 = image.row(r);`
	`1173`	`+ const unsigned char* itr1 = row(r + y) + x * bytes_per_pixel_;`
	`1174`	`+ const unsigned char* itr1_end = itr1 + (width * bytes_per_pixel_);`
	`1175`	`+ const unsigned char* itr2 = image.row(r);`
`1177`	`1176`
`1178`	`1177`	`while (itr1 != itr1_end)`
`1179`	`1178`	`{`
`@@ -1195,17 +1194,17 @@ class bitmap_image`
`1195`	`1194`	`}`
`1196`	`1195`	`}`
`1197`	`1196`
`1198`		`- inline void histogram(const color_plane color, double hist[256])`
	`1197`	`+ inline void histogram(const color_plane color, double hist[256]) const`
`1199`	`1198`	`{`
`1200`		`- std::fill(hist,hist + 256,0.0);`
	`1199`	`+ std::fill(hist, hist + 256, 0.0);`
`1201`	`1200`
`1202`		`- for (unsigned char* itr = (data() + offset(color)); itr < end(); itr += bytes_per_pixel_)`
	`1201`	`+ for (const unsigned char* itr = (data() + offset(color)); itr < end(); itr += bytes_per_pixel_)`
`1203`	`1202`	`{`
`1204`	`1203`	`++hist[(*itr)];`
`1205`	`1204`	`}`
`1206`	`1205`	`}`
`1207`	`1206`
`1208`		`- inline void histogram_normalized(const color_plane color, double hist[256])`
	`1207`	`+ inline void histogram_normalized(const color_plane color, double hist[256]) const`
`1209`	`1208`	`{`
`1210`	`1209`	`histogram(color,hist);`
`1211`	`1210`
`@@ -1219,7 +1218,7 @@ class bitmap_image`
`1219`	`1218`	`}`
`1220`	`1219`	`}`
`1221`	`1220`
`1222`		`- inline unsigned int offset(const color_plane color)`
	`1221`	`+ inline unsigned int offset(const color_plane color) const`
`1223`	`1222`	`{`
`1224`	`1223`	`switch (channel_mode_)`
`1225`	`1224`	`{`
`@@ -1303,7 +1302,7 @@ class bitmap_image`
`1303`	`1302`
`1304`	`1303`	`void clear()`
`1305`	`1304`	`{`
`1306`		`- std::memset(this,0x00,sizeof(bitmap_file_header));`
	`1305`	`+ std::memset(this, 0x00, sizeof(bitmap_file_header));`
`1307`	`1306`	`}`
`1308`	`1307`	`};`
`1309`	`1308`
`@@ -1338,7 +1337,7 @@ class bitmap_image`
`1338`	`1337`
`1339`	`1338`	`void clear()`
`1340`	`1339`	`{`
`1341`		`- std::memset(this,0x00,sizeof(bitmap_information_header));`
	`1340`	`+ std::memset(this, 0x00, sizeof(bitmap_information_header));`
`1342`	`1341`	`}`
`1343`	`1342`	`};`
`1344`	`1343`
`@@ -1430,13 +1429,13 @@ class bitmap_image`
`1430`	`1429`
`1431`	`1430`	`if (big_endian())`
`1432`	`1431`	`{`
`1433`		`- bih.size = flip(bih.size );`
`1434`		`- bih.width = flip(bih.width );`
`1435`		`- bih.height = flip(bih.height );`
`1436`		`- bih.planes = flip(bih.planes );`
`1437`		`- bih.bit_count = flip(bih.bit_count );`
`1438`		`- bih.compression = flip(bih.compression );`
`1439`		`- bih.size_image = flip(bih.size_image );`
	`1432`	`+ bih.size = flip(bih.size );`
	`1433`	`+ bih.width = flip(bih.width );`
	`1434`	`+ bih.height = flip(bih.height );`
	`1435`	`+ bih.planes = flip(bih.planes );`
	`1436`	`+ bih.bit_count = flip(bih.bit_count );`
	`1437`	`+ bih.compression = flip(bih.compression );`
	`1438`	`+ bih.size_image = flip(bih.size_image );`
`1440`	`1439`	`bih.x_pels_per_meter = flip(bih.x_pels_per_meter);`
`1441`	`1440`	`bih.y_pels_per_meter = flip(bih.y_pels_per_meter);`
`1442`	`1441`	`bih.clr_used = flip(bih.clr_used );`
`@@ -1476,7 +1475,7 @@ class bitmap_image`
`1476`	`1475`	`}`
`1477`	`1476`	`}`
`1478`	`1477`
`1479`		`- inline std::size_t file_size(const std::string& file_name)`
	`1478`	`+ inline std::size_t file_size(const std::string& file_name) const`
`1480`	`1479`	`{`
`1481`	`1480`	`std::ifstream file(file_name.c_str(),std::ios::in \| std::ios::binary);`
`1482`	`1481`	`if (!file) return 0;`
`@@ -1588,7 +1587,7 @@ class bitmap_image`
`1588`	`1587`	`}`
`1589`	`1588`
`1590`	`1589`	`template <typename T>`
`1591`		`- inline T clamp(const T& v, const T& lower_range, const T& upper_range)`
	`1590`	`+ inline T clamp(const T& v, const T& lower_range, const T& upper_range) const`
`1592`	`1591`	`{`
`1593`	`1592`	`if (v < lower_range)`
`1594`	`1593`	`return lower_range;`
`@@ -2117,25 +2116,25 @@ class image_drawer`
`2117`	`2116`
`2118`	`2117`	`void rectangle(int x1, int y1, int x2, int y2)`
`2119`	`2118`	`{`
`2120`		`- line_segment(x1,y1,x2,y1);`
`2121`		`- line_segment(x2,y1,x2,y2);`
`2122`		`- line_segment(x2,y2,x1,y2);`
`2123`		`- line_segment(x1,y2,x1,y1);`
	`2119`	`+ line_segment(x1, y1, x2, y1);`
	`2120`	`+ line_segment(x2, y1, x2, y2);`
	`2121`	`+ line_segment(x2, y2, x1, y2);`
	`2122`	`+ line_segment(x1, y2, x1, y1);`
`2124`	`2123`	`}`
`2125`	`2124`
`2126`	`2125`	`void triangle(int x1, int y1, int x2, int y2,int x3, int y3)`
`2127`	`2126`	`{`
`2128`		`- line_segment(x1,y1,x2,y2);`
`2129`		`- line_segment(x2,y2,x3,y3);`
`2130`		`- line_segment(x3,y3,x1,y1);`
	`2127`	`+ line_segment(x1, y1, x2, y2);`
	`2128`	`+ line_segment(x2, y2, x3, y3);`
	`2129`	`+ line_segment(x3, y3, x1, y1);`
`2131`	`2130`	`}`
`2132`	`2131`
`2133`	`2132`	`void quadix(int x1, int y1, int x2, int y2,int x3, int y3, int x4, int y4)`
`2134`	`2133`	`{`
`2135`		`- line_segment(x1,y1,x2,y2);`
`2136`		`- line_segment(x2,y2,x3,y3);`
`2137`		`- line_segment(x3,y3,x4,y4);`
`2138`		`- line_segment(x4,y4,x1,y1);`
	`2134`	`+ line_segment(x1, y1, x2, y2);`
	`2135`	`+ line_segment(x2, y2, x3, y3);`
	`2136`	`+ line_segment(x3, y3, x4, y4);`
	`2137`	`+ line_segment(x4, y4, x1, y1);`
`2139`	`2138`	`}`
`2140`	`2139`
`2141`	`2140`	`void line_segment(int x1, int y1, int x2, int y2)`
`@@ -2538,8 +2537,8 @@ class cartesian_canvas`
`2538`	`2537`
`2539`	`2538`	`void bottom(const point_t& p0, const point_t& p1, const point_t& p2)`
`2540`	`2539`	`{`
`2541`		`- double m0 = (p1.first - p0.first) / (2.0 * (p1.second - p0.second));`
`2542`		`- double m1 = (p2.first - p0.first) / (2.0 * (p2.second - p0.second));`
	`2540`	`+ const double m0 = (p1.first - p0.first) / (2.0 * (p1.second - p0.second));`
	`2541`	`+ const double m1 = (p2.first - p0.first) / (2.0 * (p2.second - p0.second));`
`2543`	`2542`
`2544`	`2543`	`double x0 = p0.first;`
`2545`	`2544`	`double x1 = p0.first;`
`@@ -2555,8 +2554,8 @@ class cartesian_canvas`
`2555`	`2554`
`2556`	`2555`	`void top(const point_t& p0, const point_t& p1, const point_t& p2)`
`2557`	`2556`	`{`
`2558`		`- double m0 = (p2.first - p0.first) / (2.0 * (p2.second - p0.second));`
`2559`		`- double m1 = (p2.first - p1.first) / (2.0 * (p2.second - p1.second));`
	`2557`	`+ const double m0 = (p2.first - p0.first) / (2.0 * (p2.second - p0.second));`
	`2558`	`+ const double m1 = (p2.first - p1.first) / (2.0 * (p2.second - p1.second));`
`2560`	`2559`
`2561`	`2560`	`double x0 = p2.first;`
`2562`	`2561`	`double x1 = p2.first;`
`@@ -2975,7 +2974,7 @@ inline double find_nearest_wave_length(const rgb_t& c, const double increment =`
`2975`	`2974`
`2976`	`2975`	`for (double i = 0.0; i < max_wave_length; i += increment)`
`2977`	`2976`	`{`
`2978`		`- rgb_t curr_rgb = convert_wave_length_nm_to_rgb(i);`
	`2977`	`+ const rgb_t curr_rgb = convert_wave_length_nm_to_rgb(i);`
`2979`	`2978`
`2980`	`2979`	`if (c == curr_rgb)`
`2981`	`2980`	`{`