Joshua Moerman
12 years ago
5 changed files with 433 additions and 5 deletions
@ -0,0 +1,109 @@ |
|||||
|
//
|
||||
|
// basics.hpp
|
||||
|
// ImageStreams
|
||||
|
//
|
||||
|
// Created by Joshua Moerman on 9/7/12.
|
||||
|
// Copyright (c) 2012 Vadovas. All rights reserved.
|
||||
|
//
|
||||
|
|
||||
|
#ifndef ImageStreams_basics_hpp |
||||
|
#define ImageStreams_basics_hpp |
||||
|
|
||||
|
/*
|
||||
|
A PixelFormat p should have the following constructors (depending on number |
||||
|
of colors): |
||||
|
p(int r, int g, int b, int a) |
||||
|
p(double r, double g, double b, double a) |
||||
|
|
||||
|
p(int v) |
||||
|
p(double v) |
||||
|
|
||||
|
It should be trivially writable with memcpy (TODO: check exact requirement) |
||||
|
|
||||
|
Furthermore it should have a static constexpr size_t num_colors indicating the |
||||
|
number of colors and a static constexpr size_t bit_per_color indicating the |
||||
|
number of bits per color (TODO: what to do with encodings like 565 ?) |
||||
|
*/ |
||||
|
|
||||
|
namespace pixel_formats { |
||||
|
inline uint8_t clamp(int n){ |
||||
|
return std::min(255, std::max(0, n)); |
||||
|
} |
||||
|
|
||||
|
struct Gray { |
||||
|
static constexpr size_t num_colors = 1; |
||||
|
static constexpr size_t bits_per_color = 8; |
||||
|
|
||||
|
Gray() : value(0) {} |
||||
|
Gray(double intensity) : value(clamp(255*intensity)) {} |
||||
|
Gray(int intensity) : value(clamp(intensity)) {} |
||||
|
|
||||
|
private: |
||||
|
uint8_t value; |
||||
|
}; |
||||
|
|
||||
|
struct RGB { |
||||
|
static constexpr size_t num_colors = 3; |
||||
|
static constexpr size_t bits_per_color = 8; |
||||
|
|
||||
|
RGB() |
||||
|
: red(0) |
||||
|
, green(0) |
||||
|
, blue(0) |
||||
|
{} |
||||
|
|
||||
|
RGB(double red, double green, double blue) |
||||
|
: red(clamp(255*red)) |
||||
|
, green(clamp(255*green)) |
||||
|
, blue(clamp(255*blue)) |
||||
|
{} |
||||
|
|
||||
|
RGB(int red, int green, int blue) |
||||
|
: red(clamp(red)) |
||||
|
, green(clamp(green)) |
||||
|
, blue(clamp(blue)) |
||||
|
{} |
||||
|
|
||||
|
private: |
||||
|
uint8_t red; |
||||
|
uint8_t green; |
||||
|
uint8_t blue; |
||||
|
}; |
||||
|
|
||||
|
struct BGR{ |
||||
|
static constexpr size_t num_colors = 3; |
||||
|
static constexpr size_t bits_per_color = 8; |
||||
|
|
||||
|
BGR() |
||||
|
: blue(0) |
||||
|
, green(0) |
||||
|
, red(0) |
||||
|
{} |
||||
|
|
||||
|
BGR(double red, double green, double blue) |
||||
|
: blue(clamp(255*blue)) |
||||
|
, green(clamp(255*green)) |
||||
|
, red(clamp(255*red)) |
||||
|
{} |
||||
|
|
||||
|
BGR(int red, int green, int blue) |
||||
|
: blue(clamp(blue)) |
||||
|
, green(clamp(green)) |
||||
|
, red(clamp(red)) |
||||
|
{} |
||||
|
|
||||
|
private: |
||||
|
uint8_t blue; |
||||
|
uint8_t green; |
||||
|
uint8_t red; |
||||
|
}; |
||||
|
|
||||
|
template <typename PixelType> |
||||
|
struct traits { |
||||
|
static constexpr size_t num_colors = PixelType::num_colors; |
||||
|
static constexpr size_t bits_per_color = PixelType::bits_per_color; |
||||
|
static constexpr size_t bits_per_pixel = num_colors * bits_per_color; |
||||
|
}; |
||||
|
} |
||||
|
|
||||
|
#endif |
||||
@ -0,0 +1,150 @@ |
|||||
|
//
|
||||
|
// bmp.hpp
|
||||
|
// ImageStreams
|
||||
|
//
|
||||
|
// Created by Joshua Moerman on 9/7/12.
|
||||
|
// Copyright (c) 2012 Vadovas. All rights reserved.
|
||||
|
//
|
||||
|
|
||||
|
#ifndef ImageStreams_bmp_hpp |
||||
|
#define ImageStreams_bmp_hpp |
||||
|
|
||||
|
#include <ostream> |
||||
|
#include <fstream> |
||||
|
#include <stdexcept> |
||||
|
#include <algorithm> |
||||
|
#include "basics.hpp" |
||||
|
|
||||
|
namespace bmp { |
||||
|
// file header
|
||||
|
struct bitmap_file_header { |
||||
|
uint32_t filesize; // the size of the BMP file in bytes
|
||||
|
uint16_t creator1; // reserved
|
||||
|
uint16_t creator2; // reserved
|
||||
|
uint32_t bmp_offset; // starting offset of image data
|
||||
|
|
||||
|
template <typename DIBT, typename CT> |
||||
|
bitmap_file_header(DIBT dib_header, CT color_table) |
||||
|
: filesize(dib_header.bytes() + dib_header.header_sz + color_table.size() + 12 + 2) |
||||
|
, creator1(0) |
||||
|
, creator2(0) |
||||
|
, bmp_offset(dib_header.header_sz + color_table.size() + 12 + 2) {} |
||||
|
|
||||
|
void write(std::ostream& out) const { |
||||
|
out << "BM"; |
||||
|
out.write(reinterpret_cast<const char*>(this), 12); |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
// the very basic bitmapcoreheader, no alpha supported
|
||||
|
struct bitmapcoreheader { |
||||
|
uint32_t header_sz; |
||||
|
uint16_t width; |
||||
|
uint16_t height; |
||||
|
uint16_t nplanes; |
||||
|
uint16_t bitspp; |
||||
|
|
||||
|
bitmapcoreheader(uint16_t width, uint16_t height, uint16_t bitspp) |
||||
|
: header_sz(sizeof(bitmapcoreheader)) |
||||
|
, width(width) |
||||
|
, height(height) |
||||
|
, nplanes(1) |
||||
|
, bitspp(bitspp) {} |
||||
|
|
||||
|
void write(std::ostream& out) const { |
||||
|
out.write(reinterpret_cast<const char*>(this), header_sz); |
||||
|
} |
||||
|
|
||||
|
uint32_t bytes() const { |
||||
|
return width*height*bitspp/8; |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
// empty color table
|
||||
|
struct no_color_table { |
||||
|
uint32_t size() const { |
||||
|
return 0; |
||||
|
}; |
||||
|
|
||||
|
void write(std::ostream& out) const {} |
||||
|
}; |
||||
|
|
||||
|
// gray color table without alpha channel (eg for bitmapcoreheader)
|
||||
|
template <size_t N> |
||||
|
struct gray_color_table { |
||||
|
uint32_t size() const { |
||||
|
// 2^N entries of 3 bytes
|
||||
|
return (2 << (N-1)) * 3; |
||||
|
} |
||||
|
|
||||
|
void write(std::ostream& out) const { |
||||
|
for(unsigned int i = 0; i < (2 << (N-1)); ++i){ |
||||
|
const char v = i; |
||||
|
// more or less b g r.
|
||||
|
const char arr[3] = {v, v, v}; |
||||
|
out.write(arr, 3); |
||||
|
} |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
// when bpp > 8 there should be no color table, else there should be
|
||||
|
template <typename P> |
||||
|
struct default_color_table : public std::conditional<pixel_formats::traits<P>::bits_per_pixel <= 8, gray_color_table<pixel_formats::traits<P>::bits_per_pixel>, no_color_table>::type |
||||
|
{}; |
||||
|
|
||||
|
template <typename P = pixel_formats::BGR, typename CT = default_color_table<P>> |
||||
|
struct bitmap_stream { |
||||
|
typedef P pixel; |
||||
|
typedef CT color_table; |
||||
|
|
||||
|
bitmap_stream() = delete; |
||||
|
bitmap_stream(bitmap_stream const &) = delete; |
||||
|
bitmap_stream & operator=(bitmap_stream const &) = delete; |
||||
|
|
||||
|
// TODO: make this template on class level?
|
||||
|
// You can't use them in a ctor without template argument deduction...
|
||||
|
template <typename DIBT = bitmapcoreheader> |
||||
|
bitmap_stream(uint16_t width, uint16_t height, std::string filename) |
||||
|
: file(filename.c_str()) |
||||
|
, width(width) |
||||
|
, height(height) |
||||
|
, x(0) |
||||
|
, y(0) |
||||
|
{ |
||||
|
if(!file) throw std::runtime_error("bitmap file could not be opened."); |
||||
|
|
||||
|
DIBT dib_header(width, height, pixel_formats::traits<P>::bits_per_pixel); |
||||
|
color_table ct; |
||||
|
bitmap_file_header header(dib_header, ct); |
||||
|
|
||||
|
header.write(file); |
||||
|
dib_header.write(file); |
||||
|
ct.write(file); |
||||
|
} |
||||
|
|
||||
|
bitmap_stream& operator<<(pixel const & p){ |
||||
|
if (y >= height) throw std::out_of_range("Writing BMP image out of bounds."); |
||||
|
|
||||
|
file.write((char const *)&p, sizeof(pixel)); |
||||
|
++x; |
||||
|
if (x >= width){ |
||||
|
x = 0; |
||||
|
++y; |
||||
|
} |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
// TODO: destructor with checking / padding?
|
||||
|
|
||||
|
private: |
||||
|
std::ofstream file; |
||||
|
|
||||
|
uint16_t width; |
||||
|
uint16_t height; |
||||
|
|
||||
|
uint16_t x; |
||||
|
uint16_t y; |
||||
|
}; |
||||
|
} |
||||
|
|
||||
|
#endif |
||||
@ -0,0 +1,92 @@ |
|||||
|
//
|
||||
|
// png.hpp
|
||||
|
// ImageStreams
|
||||
|
//
|
||||
|
// Created by Joshua Moerman on 9/7/12.
|
||||
|
// Copyright (c) 2012 Vadovas. All rights reserved.
|
||||
|
//
|
||||
|
|
||||
|
#ifndef ImageStreams_png_hpp |
||||
|
#define ImageStreams_png_hpp |
||||
|
|
||||
|
#include <stdio.h> |
||||
|
#include <stdexcept> |
||||
|
#include <vector> |
||||
|
#include <png.h> |
||||
|
#include "basics.hpp" |
||||
|
|
||||
|
namespace png{ |
||||
|
template <typename P> |
||||
|
int color_type(){ |
||||
|
int num_colors = pixel_formats::traits<P>::num_colors; |
||||
|
switch (num_colors) { |
||||
|
case 1: return PNG_COLOR_TYPE_GRAY; |
||||
|
case 2: return PNG_COLOR_TYPE_GRAY_ALPHA; |
||||
|
case 3: return PNG_COLOR_TYPE_RGB; |
||||
|
case 4: return PNG_COLOR_TYPE_RGB_ALPHA; |
||||
|
default: return PNG_COLOR_TYPE_RGB; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
template <typename P = pixel_formats::RGB> |
||||
|
struct png_stream{ |
||||
|
typedef P pixel; |
||||
|
|
||||
|
png_stream() = delete; |
||||
|
png_stream(png_stream const &) = delete; |
||||
|
png_stream & operator=(png_stream const &) = delete; |
||||
|
|
||||
|
png_stream(uint32_t width, uint32_t height, std::string filename) |
||||
|
: fp(0) |
||||
|
, png_ptr(0) |
||||
|
, info_ptr(0) |
||||
|
, row(width) |
||||
|
, x(0) |
||||
|
{ |
||||
|
fp = fopen(filename.c_str(), "wb"); |
||||
|
if(!fp) throw std::runtime_error("Could not open file"); |
||||
|
|
||||
|
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0); |
||||
|
if(!png_ptr) throw std::runtime_error("PNG structure could not be allocated"); |
||||
|
|
||||
|
info_ptr = png_create_info_struct(png_ptr); |
||||
|
if(!info_ptr) throw std::runtime_error("PNG information structure could not be allocated"); |
||||
|
|
||||
|
png_init_io(png_ptr, fp); |
||||
|
|
||||
|
png_set_IHDR(png_ptr, info_ptr, width, height, pixel_formats::traits<pixel>::bits_per_color, color_type<pixel>(), PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); |
||||
|
|
||||
|
png_set_compression_level(png_ptr, 9); |
||||
|
|
||||
|
png_write_info(png_ptr, info_ptr); |
||||
|
} |
||||
|
|
||||
|
~png_stream(){ |
||||
|
// NOTE: the pnglib already checks for us whether all pixels are written
|
||||
|
png_write_end(png_ptr, info_ptr); |
||||
|
png_destroy_info_struct(png_ptr, &info_ptr); |
||||
|
fclose(fp); |
||||
|
} |
||||
|
|
||||
|
png_stream& operator<<(pixel const & p){ |
||||
|
row[x] = p; |
||||
|
++x; |
||||
|
if(x >= row.size()){ |
||||
|
png_write_row(png_ptr, reinterpret_cast<unsigned char const*>(row.data())); |
||||
|
x = 0; |
||||
|
} |
||||
|
|
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
FILE* fp; |
||||
|
png_structp png_ptr; |
||||
|
png_infop info_ptr; |
||||
|
|
||||
|
std::vector<pixel> row; |
||||
|
uint32_t x; |
||||
|
}; |
||||
|
} |
||||
|
|
||||
|
#endif |
||||
Reference in new issue