Frundle/cpp-bmp-reader
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
cpp-bmp-reader/image-lib/bmpimage.cpp

386 lines
14 KiB
C++
Raw Blame History

#include <cmath>
#include <memory>
#include <algorithm>
#include "bmpimage.h"
BMPImage::BMPImage(const BitmapFileHeader &fileHeader, const BITMAPINFOHEADER &infoHeader, const PixelArray &pixelArray)
: pixelArray(pixelArray) {
this->fileHeader = fileHeader;
this->infoHeader = infoHeader;
}
//BMPImage::BMPImage(const BitmapFileHeader &fileHeader, const BITMAPINFOHEADER &infoHeader, PixelArray pixelArray) {
//
//}
const uint32_t &BMPImage::width() const { return this->infoHeader.BitmapWidth; }
const uint32_t &BMPImage::height() const { return this->infoHeader.BitmapHeight; }
void BMPImage::save(const std::string &filename) {
{
std::ofstream ofs(filename, std::ios_base::binary);
ofs.write((char *) &this->fileHeader, sizeof(this->fileHeader));
ofs.write((char *) &this->infoHeader, sizeof(this->infoHeader));
uint32_t byteByRow = this->infoHeader.BitmapWidth * 3;
uint8_t padding = (4 - byteByRow % 4) % 4;
for (auto i = (int) this->infoHeader.BitmapHeight - 1; i > -1; --i) {
ofs.write((char *) pixelArray(i), byteByRow);
if (padding != 4) ofs.write(PADDING_ZEROES, padding); // Write padding
}
}
}
PixelArray BMPImage::pixels() {
return this->pixelArray;
}
PixelArray BMPImage::pixels_copy() {
// Pixel **newPixelArray;
PixelArray newPixelArray(this->infoHeader.BitmapWidth, this->infoHeader.BitmapHeight);
// newPixelArray = new Pixel *[this->infoHeader.BitmapHeight];
for (int i = 0; i < this->infoHeader.BitmapHeight; ++i) {
// newPixelArray[i] = new Pixel[this->infoHeader.BitmapWidth];
// std::copy(this->pixelArray(i), this->pixelArray(i) + this->infoHeader.BitmapWidth, newPixelArray(i)); // TODO
for (int j = 0; j < this->infoHeader.BitmapWidth; ++j) {
newPixelArray(i, j) = this->pixelArray(i, j);
}
}
return newPixelArray;
}
BitmapFileHeader BMPImage::fileHeader_copy() {
return this->fileHeader;
}
BITMAPINFOHEADER BMPImage::infoHeader_copy() {
return this->infoHeader;
}
BMPImage::~BMPImage() {
// delete pixelArray;
// for (int i = 0; i < this->infoHeader.BitmapHeight; ++i) {
// delete[] this->pixelArray(i);
// }
// delete[] this->pixelArray;
}
BMPImage::BMPImage(const PixelArray &pixelArray) : pixelArray(pixelArray) {
uint32_t width = pixelArray.width();
uint32_t height = pixelArray.height();
BitmapFileHeader _fileHeader;
BITMAPINFOHEADER _infoHeader;
_infoHeader.BitmapWidth = width;
_infoHeader.BitmapHeight = height;
_infoHeader.ImageSize = width * height * 3 + ((4 - (width * 3) % 4) % 4) * height;
_fileHeader.fileSize = _infoHeader.ImageSize + _fileHeader.imageDataOffset;
this->infoHeader = _infoHeader;
this->fileHeader = _fileHeader;
// this->pixelArray = pixelArray;
}
BMPImage BMPImage::appendRight(BMPImage &img) {
uint32_t newHeight = std::max(this->infoHeader.BitmapHeight, img.height());
uint32_t newWidth = this->infoHeader.BitmapWidth + img.width();
// Pixel **newPixelArray;
PixelArray newPixelArray(newWidth, newHeight);
// std::shared_ptr<PixelArray> newPixelArray = std::make_shared<PixelArray>(newWidth, newHeight);
// newPixelArray = new Pixel *[newHeight];
for (int i = 0; i < this->infoHeader.BitmapHeight; ++i) {
// newPixelArray[i] = new Pixel[newWidth];
std::copy(this->pixelArray(i), this->pixelArray(i) + this->infoHeader.BitmapWidth, newPixelArray(i));
}
for (int i = 0; i < img.height(); ++i) {
std::copy(img.pixels()(i), img.pixelArray(i) + img.width(), newPixelArray(i) + this->infoHeader.BitmapWidth);
}
return {newPixelArray};
}
BMPImage BMPImage::overlay(BMPImage &img, uint32_t pos_x, uint32_t pos_y) {
if (pos_x + img.width() > this->width() || pos_y + img.height() > this->height())
throw std::runtime_error("The overlaid image is outside the image");
auto pixels = this->pixels_copy();
for (int i = 0; i < img.height(); ++i) {
std::copy(img.pixels()(i), img.pixels()(i) + img.width(), pixels(pos_y + i) + pos_x);
}
return {pixels};
}
BMPImage BMPImage::applyFilter(const std::function<uint8_t(std::array<int, 9> &)> &filter) {
auto origPixels = this->pixels_copy();
PixelArray pixels(this->width(), this->height());
for (int y = 1; y < this->height() - 1; ++y) {
for (int x = 1; x < this->width() - 1; ++x) {
auto p1 = origPixels(y - 1, x - 1);
auto p2 = origPixels(y - 1, x);
auto p3 = origPixels(y - 1, x + 1);
auto p4 = origPixels(y, x - 1);
auto p5 = origPixels(y, x);
auto p6 = origPixels(y, x + 1);
auto p7 = origPixels(y + 1, x - 1);
auto p8 = origPixels(y + 1, x);
auto p9 = origPixels(y + 1, x + 1);
std::array<int, 9> red_channel = {p1.r, p2.r, p3.r, p4.r, p5.r, p6.r, p7.r, p8.r, p9.r};
std::array<int, 9> green_channel = {p1.g, p2.g, p3.g, p4.g, p5.g, p6.g, p7.g, p8.g, p9.g};
std::array<int, 9> blue_channel = {p1.b, p2.b, p3.b, p4.b, p5.b, p6.b, p7.b, p8.b, p9.b};
auto r = filter(red_channel);
auto g = filter(green_channel);
auto b = filter(blue_channel);
pixels(y, x) = {r, g, b};
}
}
return {pixels};
}
BMPImage readBMPImage(const std::string &filename) {
BitmapFileHeader bitmapFileHeader;
BITMAPINFOHEADER bitmapInfoHeader;
uint32_t DIB_Header_Size;
{
std::ifstream ifs(filename, std::ios_base::binary);
if (!ifs.good()) {
throw std::runtime_error("File read error");
}
ifs.seekg(0, std::ios::beg);
ifs.read((char *) &bitmapFileHeader, sizeof(bitmapFileHeader));
ifs.read((char *) &DIB_Header_Size, sizeof(DIB_Header_Size));
}
if (DIB_Header_Size != 40) {
throw std::runtime_error("Invalid header");
}
{
std::ifstream ifs(filename, std::ios_base::binary);
if (!ifs.good()) {
throw std::runtime_error("File read error");
}
ifs.seekg(14, std::ios::beg);
ifs.read((char *) &bitmapInfoHeader, sizeof(bitmapInfoHeader));
}
PixelArray pixelArray = PixelArray(bitmapInfoHeader.BitmapWidth, bitmapInfoHeader.BitmapHeight);
// pixelArray = new Pixel *[bitmapInfoHeader.BitmapHeight];
{
std::ifstream ifs(filename, std::ios_base::binary);
if (!ifs.good()) {
throw std::runtime_error("File read error");
}
ifs.seekg(bitmapFileHeader.imageDataOffset, std::ios::beg);
uint32_t byteByRow = bitmapInfoHeader.BitmapWidth * 3;
uint8_t padding = (4 - byteByRow % 4) % 4;
for (auto i = (int) bitmapInfoHeader.BitmapHeight - 1; i > -1; --i) {
// pixelArray(i) = new Pixel[bitmapInfoHeader.BitmapWidth];
ifs.read((char *) pixelArray(i), byteByRow);
if (padding != 4) ifs.seekg(padding, std::ios_base::cur); // Skip padding
}
}
return {bitmapFileHeader, bitmapInfoHeader, pixelArray};
}
BMPImage grayscale(BMPImage &img) {
auto pixels = img.pixels_copy();
for (int i = 0; i < img.height(); ++i) {
for (int j = 0; j < img.width(); ++j) {
uint8_t gray = pixels(i, j).r / 3 + pixels(i, j).g / 3 + pixels(i, j).b / 3;
pixels(i, j) = {gray, gray, gray};
}
}
return {img.fileHeader_copy(), img.infoHeader_copy(), pixels};
}
BMPImage invertColors(BMPImage &img) {
auto pixels = img.pixels_copy();
for (int i = 0; i < img.height(); ++i) {
for (int j = 0; j < img.width(); ++j) {
pixels(i, j) = 255 - pixels(i, j);
}
}
return {img.fileHeader_copy(), img.infoHeader_copy(), pixels};
}
BMPImage upscale2x(BMPImage &img) {
auto oldPixels = img.pixels();
const uint32_t newHeight = img.height() * 2;
const uint32_t newWidth = img.width() * 2;
PixelArray newPixelArray(newWidth, newHeight);
for (int i = 0; i < newHeight; i += 2) {
for (int j = 0; j < newWidth; ++j) {
if (j % 2 == 0)
newPixelArray(i, j) = oldPixels(i / 2, j / 2);
else if (j == newWidth - 1)
newPixelArray(i, j) = oldPixels(i / 2, j / 2) / 2;
else
newPixelArray(i, j) = oldPixels(i / 2, j / 2) / 2 + oldPixels(i / 2, j / 2 + 1) / 2;
}
}
for (int i = 1; i < newHeight; i += 2) {
if (i == newHeight - 1)
for (int j = 0; j < newWidth; ++j) {
newPixelArray(i, j) = newPixelArray(i - 1, j) / 2;
}
else
for (int j = 0; j < newWidth; ++j) {
newPixelArray(i, j) = newPixelArray(i - 1, j) / 2 + newPixelArray(i + 1, j) / 2;
}
}
return {newPixelArray};
}
BMPImage downscale2x(BMPImage &img) {
auto oldPixels = img.pixels_copy();
const uint32_t newHeight = img.height() / 2;
const uint32_t newWidth = img.width() / 2;
PixelArray newPixelArray(newWidth, newHeight);
for (int i = 0; i < newHeight; ++i) {
for (int j = 0; j < newWidth; ++j) {
newPixelArray(i, j) = oldPixels(i * 2, j * 2);
}
}
return {newPixelArray};
}
BMPImage upscale1_5x(BMPImage &img) {
auto oldPixels = img.pixels();
const uint32_t newHeight = img.height() * 3 / 2;
const uint32_t newWidth = img.width() * 3 / 2;
PixelArray newPixelArray(newWidth, newHeight);
for (int i = 0; i < newHeight; ++i) {
if ((i + 1) % 3 == 0) continue;
for (int j = 0; j < newWidth; ++j) {
int oldi = i * 2 / 3;
int oldj = j * 2 / 3;
if ((j + 1) % 3 != 0)
newPixelArray(i, j) = oldPixels(oldi, oldj);
else if (j == newWidth - 1)
newPixelArray(i, j) = oldPixels(oldi, oldj) / 2;
else
newPixelArray(i, j) = oldPixels(oldi, oldj) / 2 + oldPixels(oldi, oldj + 1) / 2;
}
}
for (int i = 2; i < newHeight; i += 3) {
if (i == newHeight - 1)
for (int j = 0; j < newWidth; ++j) {
newPixelArray(i, j) = newPixelArray(i - 1, j) / 2;
}
else
for (int j = 0; j < newWidth; ++j) {
newPixelArray(i, j) = newPixelArray(i - 1, j) / 2 + newPixelArray(i + 1, j) / 2;
}
}
return {newPixelArray};
}
BMPImage textImg(const std::u16string &str, Font *font, uint8_t scale, Pixel background_color, Pixel font_color) {
auto strSize = str.size();
uint32_t glyphHeight = font->glyphHeight;
uint32_t glyphWidth = font->glyphWidth;
uint32_t imgWidth = strSize * glyphWidth * scale;
uint32_t imgHeight = glyphHeight * scale;
PixelArray pixels(imgWidth, imgHeight);
for (int i = 0; i < strSize; ++i) {
auto glyph = font->_glyphs[str[i]];
for (int j = 0; j < glyphHeight * scale; ++j) {
for (int l = 0; l < glyphWidth * scale; ++l) {
if (glyph->glyph[j / scale][l / scale])
pixels(j, glyphWidth * scale * i + l) = font_color;
else
pixels(j, glyphWidth * scale * i + l) = background_color;
}
}
}
return {pixels};
}
BMPImage upscale1_5x_ver2(BMPImage &img) {
auto oldPixels = img.pixels();
const uint32_t newHeight = img.height() * 3 / 2;
const uint32_t newWidth = img.width() * 3 / 2;
PixelArray newPixelArray(newWidth, newHeight);
for (int i = 0; i < newHeight; ++i) {
int oldi = std::round(i * 2 / 3.);
if ((i + 1) % 3 == 0) {
if (i == newHeight - 1)
newPixelArray(i, 0) = oldPixels(oldi, 0) / 2;
else {
newPixelArray(i, 0) = oldPixels(oldi, 0) / 2 + oldPixels(oldi + 1, 0) / 2;
}
continue;
}
for (int j = 0; j < newWidth; ++j) {
int oldj = std::round(j * 2 / 3.);
if ((j + 1) % 3 != 0)
newPixelArray(i, j) = oldPixels(oldi, oldj);
else if (j == newWidth - 1)
newPixelArray(i, j) = oldPixels(oldi, oldj) / 2;
else
newPixelArray(i, j) = oldPixels(oldi, oldj) / 2 + oldPixels(oldi, oldj + 1) / 2;
}
}
for (int i = 2; i < newHeight; i += 3) {
if (i == newHeight - 1)
for (int j = 0; j < newWidth; ++j) {
newPixelArray(i, j) = newPixelArray(i - 1, j) / 2;
}
else
for (int j = 1; j < newWidth; ++j) {
if (j == newWidth - 1) {
newPixelArray(i, j) = newPixelArray(i, j - 1) / 2;
continue;
}
auto f00 = newPixelArray(i - 1, j - 1);
auto f10 = newPixelArray(i - 1, j + 1);
auto f01 = newPixelArray(i + 1, j - 1);
auto f11 = newPixelArray(i + 1, j + 1);
newPixelArray(i, j) = f10 / 4 + f00 / 4 + f01 / 4 + f11 / 4;
}
}
return {newPixelArray};
}
BMPImage upscale2x_ver2(BMPImage &img) {
auto oldPixels = img.pixels();
const uint32_t newHeight = img.height() * 2;
const uint32_t newWidth = img.width() * 2;
PixelArray newPixelArray(newWidth, newHeight);
for (int i = 0; i < newHeight; ++i) {
if ((i + 1) % 2 == 0) {
if (i == newHeight - 1)
newPixelArray(i, 0) = oldPixels(i / 2, 0) / 2;
else
newPixelArray(i, 0) = oldPixels(i / 2, 0) / 2 + oldPixels(i / 2 + 1, 0) / 2;
continue;
}
for (int j = 0; j < newWidth; ++j) {
if (j % 2 == 0)
newPixelArray(i, j) = oldPixels(i / 2, j / 2);
else if (j == newWidth - 1)
newPixelArray(i, j) = oldPixels(i / 2, j / 2) / 2;
else
newPixelArray(i, j) = oldPixels(i / 2, j / 2) / 2 + oldPixels(i / 2, j / 2 + 1) / 2;
}
}
for (int i = 1; i < newHeight; i += 2) {
if (i == newHeight - 1)
for (int j = 1; j < newWidth; ++j) {
newPixelArray(i, j) = newPixelArray(i - 1, j) / 2;
}
else
for (int j = 1; j < newWidth; ++j) {
if (j == newWidth - 1) {
newPixelArray(i, j) = newPixelArray(i, j - 1) / 2;
continue;
}
auto f00 = newPixelArray(i - 1, j - 1);
auto f10 = newPixelArray(i - 1, j + 1);
auto f01 = newPixelArray(i + 1, j - 1);
auto f11 = newPixelArray(i + 1, j + 1);
newPixelArray(i, j) = f10 / 4 + f00 / 4 + f01 / 4 + f11 / 4;
}
}
return {newPixelArray};
}
Reference in a new issue View git blame Copy permalink