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

Выделил переиспользуемые модули из проекта.

Browse source
This commit is contained in:
Евгений Титаренко 2024-04-19 22:25:12 +03:00
parent 3fe2a87e35
commit 7c83d9c93e
15 changed files with 287 additions and 207 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
CMakeLists.txt
View file

@ -3,8 +3,15 @@ project(image_test_cpp)
set(CMAKE_CXX_STANDARD 17)
add_executable(image_test_cpp main.cpp
bmpimage.h
bmpimage.cpp
psf.cpp
psf.h)
add_subdirectory(font-lib)
add_subdirectory(image-lib)
add_subdirectory(utils-lib)
add_executable(image_test_cpp main.cpp)
target_link_libraries(image_test_cpp
PRIVATE
font-lib
image-lib
utils-lib
)

18
font-lib/CMakeLists.txt Normal file
View file

@ -0,0 +1,18 @@
add_library(font-lib STATIC "")
set(FONT_LIB_HEADERS
psf.h
)
set(FONT_LIB_SOURCES
psf.cpp
)
target_sources(font-lib
PRIVATE
${FONT_LIB_SOURCES}
PUBLIC
FILE_SET HEADERS
BASE_DIRS ${PROJECT_SOURCE_DIR}
FILES ${FONT_LIB_HEADERS}
)

13
psf.cpp → font-lib/psf.cpp
View file

@ -1,7 +1,3 @@
//
// Created by Evgenij on 09.04.2024.
//
#include <locale>
#include <codecvt>
#include <vector>
@ -25,15 +21,15 @@ Font readPSF(const std::string &filename) {
throw std::runtime_error("Invalid font file");
ifs.read((char *) &psf2Header, sizeof(psf2Header));
auto font = Font(psf2Header.numberOfGlyphs, psf2Header.glyphWidth, psf2Header.glyphHeight);
Glyph glyphs[psf2Header.numberOfGlyphs];
std::vector<std::shared_ptr<Glyph>> glyphs(psf2Header.numberOfGlyphs);
for (int i = 0; i < psf2Header.numberOfGlyphs; ++i) {
auto glyph = Glyph(psf2Header.glyphWidth, psf2Header.glyphHeight);
auto glyph = std::make_shared<Glyph>(psf2Header.glyphWidth, psf2Header.glyphHeight);
char glyphBytes[psf2Header.bytesPerGlyph];
ifs.read((char *) &glyphBytes, psf2Header.bytesPerGlyph);
for (int j = 0; j < psf2Header.bytesPerGlyph; ++j) {
for (int k = 0; k < 8; ++k) {
uint8_t bit = (glyphBytes[j] & (1 << k)) != 0; // Получить к-ый бит
glyph.glyph[(j * 8 + k) / psf2Header.glyphWidth][psf2Header.glyphWidth - 1 -
glyph->glyph[(j * 8 + k) / psf2Header.glyphWidth][psf2Header.glyphWidth - 1 -
(j * 8 + k) % psf2Header.glyphWidth] = bit;
}
}
@ -79,9 +75,6 @@ Glyph::Glyph(uint32_t width, uint32_t height) {
this->height = height;
}
Glyph::Glyph() {
}
Font::Font(uint32_t glyphsCount, uint32_t glyphWidth, uint32_t glyphHeight) {
this->glyphsCount = glyphsCount;

4
psf.h → font-lib/psf.h
View file

@ -4,6 +4,7 @@
#include <fstream>
#include <cstdint>
#include <map>
#include <memory>
#pragma pack(push, 1)
struct PSF1Header {
@ -34,12 +35,11 @@ public:
Glyph(uint32_t width, uint32_t height);
Glyph();
};
class Font {
public:
std::map<char16_t, Glyph> _glyphs;
std::map<char16_t, std::shared_ptr<Glyph>> _glyphs;
uint32_t glyphWidth;
uint32_t glyphHeight;
uint32_t glyphsCount;

28
image-lib/CMakeLists.txt Normal file
View file

@ -0,0 +1,28 @@
add_library(image-lib STATIC ""
pixelarray.cpp
pixelarray.h
filters.cpp
filters.h)
set(IMAGE_LIB_HEADERS
bmpimage.h
)
set(IMAGE_LIB_SOURCES
bmpimage.cpp
)
target_sources(image-lib
PRIVATE
${IMAGE_LIB_SOURCES}
PUBLIC
FILE_SET HEADERS
BASE_DIRS ${PROJECT_SOURCE_DIR}
FILES ${IMAGE_LIB_HEADERS}
)
target_link_libraries(image-lib
PUBLIC
font-lib
utils-lib
)

120
bmpimage.cpp → image-lib/bmpimage.cpp
View file

@ -178,19 +178,6 @@ BMPImage readBMPImage(const std::string &filename) {
return {bitmapFileHeader, bitmapInfoHeader, pixelArray};
}
Pixel operator+(const Pixel &p1, const Pixel &p2) {
const uint8_t r = ui8_clamp((int) p1.r + p2.r);
const uint8_t g = ui8_clamp((int) p1.g + p2.g);
const uint8_t b = ui8_clamp((int) p1.b + p2.b);
return {r, g, b};
}
Pixel operator/(const Pixel &p1, const uint8_t &n) {
const uint8_t r = p1.r / n;
const uint8_t g = p1.g / n;
const uint8_t b = p1.b / n;
return {r, g, b};
}
BMPImage grayscale(BMPImage &img) {
auto pixels = img.pixels_copy();
@ -203,22 +190,6 @@ BMPImage grayscale(BMPImage &img) {
return {img.fileHeader_copy(), img.infoHeader_copy(), pixels};
}
Pixel operator*(const Pixel &p, const int &n) {
uint8_t r = ui8_clamp(n * p.r);
uint8_t g = ui8_clamp(n * p.g);
uint8_t b = ui8_clamp(n * p.b);
return {r, g, b};
}
uint8_t ui8_clamp(int value, uint8_t min, uint8_t max) {
if (value < min) {
return min;
}
if (value > max) {
return max;
}
return value;
}
BMPImage invertColors(BMPImage &img) {
auto pixels = img.pixels_copy();
@ -230,20 +201,6 @@ BMPImage invertColors(BMPImage &img) {
return {img.fileHeader_copy(), img.infoHeader_copy(), pixels};
}
Pixel operator-(const uint8_t &n, const Pixel &p) {
uint8_t r = ui8_clamp(n - p.r);
uint8_t g = ui8_clamp(n - p.g);
uint8_t b = ui8_clamp(n - p.b);
return {r, g, b};
}
Pixel operator-(const Pixel &p, const uint8_t &n) {
uint8_t r = ui8_clamp(p.r - n);
uint8_t g = ui8_clamp(p.g - n);
uint8_t b = ui8_clamp(p.b - n);
return {r, g, b};
}
BMPImage upscale2x(BMPImage &img) {
auto oldPixels = img.pixels();
const uint32_t newHeight = img.height() * 2;
@ -327,7 +284,7 @@ BMPImage textImg(const std::u16string &str, Font *font, uint8_t scale, Pixel bac
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])
if (glyph->glyph[j / scale][l / scale])
pixels(j, glyphWidth * scale * i + l) = font_color;
else
pixels(j, glyphWidth * scale * i + l) = background_color;
@ -384,13 +341,6 @@ BMPImage upscale1_5x_ver2(BMPImage &img) {
return {newPixelArray};
}
Pixel operator-(const Pixel &p1, const Pixel &p2) {
auto r = ui8_clamp((int) p1.r - p2.r);
auto g = ui8_clamp((int) p1.g - p2.g);
auto b = ui8_clamp((int) p1.b - p2.b);
return {r, g, b};
}
BMPImage upscale2x_ver2(BMPImage &img) {
auto oldPixels = img.pixels();
const uint32_t newHeight = img.height() * 2;
@ -434,71 +384,3 @@ BMPImage upscale2x_ver2(BMPImage &img) {
return {newPixelArray};
}
uint8_t medianFilter(std::array<int, 9> &pixels) {
std::sort(pixels.begin(), pixels.end());
return ui8_clamp(pixels[5]);
}
uint8_t averageFilter(std::array<int, 9> &pixels) {
return ui8_clamp((pixels[0] * AVERAGE_MASK[0] + pixels[1] * AVERAGE_MASK[1] + pixels[2] * AVERAGE_MASK[2] +
pixels[3] * AVERAGE_MASK[3] + pixels[4] * AVERAGE_MASK[4] + pixels[5] * AVERAGE_MASK[5] +
pixels[6] * AVERAGE_MASK[6] + pixels[7] * AVERAGE_MASK[7] + pixels[8] * AVERAGE_MASK[8]) / 9);
}
uint8_t prewittDXFilter(std::array<int, 9> &pixels) {
return ui8_clamp(pixels[0] * PREWITT_MASK_DX[0] + pixels[1] * PREWITT_MASK_DX[1] + pixels[2] * PREWITT_MASK_DX[2] +
pixels[3] * PREWITT_MASK_DX[3] + pixels[4] * PREWITT_MASK_DX[4] + pixels[5] * PREWITT_MASK_DX[5] +
pixels[6] * PREWITT_MASK_DX[6] + pixels[7] * PREWITT_MASK_DX[7] + pixels[8] * PREWITT_MASK_DX[8]);
}
uint8_t prewittDYFilter(std::array<int, 9> &pixels) {
return ui8_clamp(pixels[0] * PREWITT_MASK_DY[0] + pixels[1] * PREWITT_MASK_DY[1] + pixels[2] * PREWITT_MASK_DY[2] +
pixels[3] * PREWITT_MASK_DY[3] + pixels[4] * PREWITT_MASK_DY[4] + pixels[5] * PREWITT_MASK_DY[5] +
pixels[6] * PREWITT_MASK_DY[6] + pixels[7] * PREWITT_MASK_DY[7] + pixels[8] * PREWITT_MASK_DY[8]);
}
uint8_t sobelDXFilter(std::array<int, 9> &pixels) {
return ui8_clamp(pixels[0] * SOBEL_MASK_DX[0] + pixels[1] * SOBEL_MASK_DX[1] + pixels[2] * SOBEL_MASK_DX[2] +
pixels[3] * SOBEL_MASK_DX[3] + pixels[4] * SOBEL_MASK_DX[4] + pixels[5] * SOBEL_MASK_DX[5] +
pixels[6] * SOBEL_MASK_DX[6] + pixels[7] * SOBEL_MASK_DX[7] + pixels[8] * SOBEL_MASK_DX[8]);
}
uint8_t sobelDYFilter(std::array<int, 9> &pixels) {
return ui8_clamp(pixels[0] * SOBEL_MASK_DY[0] + pixels[1] * SOBEL_MASK_DY[1] + pixels[2] * SOBEL_MASK_DY[2] +
pixels[3] * SOBEL_MASK_DY[3] + pixels[4] * SOBEL_MASK_DY[4] + pixels[5] * SOBEL_MASK_DY[5] +
pixels[6] * SOBEL_MASK_DY[6] + pixels[7] * SOBEL_MASK_DY[7] + pixels[8] * SOBEL_MASK_DY[8]);
}
PixelArray::PixelArray(uint32_t width, uint32_t height) {
this->_width = width;
this->_height = height;
this->array = new Pixel *[height];
for (int i = 0; i < height; ++i) {
this->array[i] = new Pixel[width];
}
}
Pixel &PixelArray::operator()(const uint32_t &i, const uint32_t &j) {
return this->array[i][j];
}
PixelArray::~PixelArray() {
// for (int i = 0; i < this->_height; ++i) {
// delete[] this->array[i];
// }
// delete[] this->array;
}
PixelArray::PixelArray(const PixelArray &pA) {
this->_width = pA.width();
this->_height = pA.height();
this->array = pA.array;
}
Pixel *&PixelArray::operator()(const uint32_t &i) {
return this->array[i];
}
const uint32_t &PixelArray::width() const { return this->_width; }
const uint32_t &PixelArray::height() const { return this->_height; }

67
bmpimage.h → image-lib/bmpimage.h
View file

@ -5,15 +5,10 @@
#include <fstream>
#include <array>
#include <functional>
#include "psf.h"
#include <font-lib/psf.h>
#include "pixelarray.h"
const char PADDING_ZEROES[3] = {0, 0, 0};
const int AVERAGE_MASK[9] = {1, 1, 1, 1, 1, 1, 1, 1, 1};
const int PREWITT_MASK_DX[9] = {-1, 0, 1, -1, 0, 1, -1, 0, 1};
const int PREWITT_MASK_DY[9] = {-1, -1, -1, 0, 0, 0, 1, 1, 1};
const int SOBEL_MASK_DX[9] = {-1, 0, 1, -2, 0, 2, -1, 0, 1};
const int SOBEL_MASK_DY[9] = {-1, -2, -1, 0, 0, 0, 1, 2, 1};
#pragma pack(push, 1)
struct BitmapFileHeader {
@ -41,36 +36,6 @@ struct BITMAPINFOHEADER {
};
#pragma pack(pop)
#pragma pack(push, 1)
struct Pixel {
uint8_t r = 255;
uint8_t g = 0;
uint8_t b = 255;
};
#pragma pack(pop)
class PixelArray {
Pixel **array;
uint32_t _width;
uint32_t _height;
public:
PixelArray(uint32_t width, uint32_t height);
PixelArray(const PixelArray &);
~PixelArray();
[[nodiscard]] const uint32_t &width() const;
[[nodiscard]] const uint32_t &height() const;
// Pixel operator()(const uint32_t &, const uint32_t &);
// Pixel* operator()(const uint32_t &);
Pixel &operator()(const uint32_t &, const uint32_t &);
Pixel *&operator()(const uint32_t &);
};
class BMPImage {
BitmapFileHeader fileHeader;
BITMAPINFOHEADER infoHeader;
@ -105,18 +70,6 @@ public:
BMPImage readBMPImage(const std::string &filename);
Pixel operator/(const Pixel &, const uint8_t &);
Pixel operator+(const Pixel &, const Pixel &);
Pixel operator*(const Pixel &, const int &);
Pixel operator-(const Pixel &, const uint8_t &);
Pixel operator-(const uint8_t &, const Pixel &);
Pixel operator-(const Pixel &, const Pixel &);
BMPImage grayscale(BMPImage &);
BMPImage invertColors(BMPImage &);
@ -132,18 +85,4 @@ BMPImage upscale1_5x_ver2(BMPImage &); // TODO: BAD
BMPImage upscale2x_ver2(BMPImage &); // TODO: BAD
BMPImage textImg(const std::u16string &, Font *font, uint8_t scale = 1, Pixel background_color = Pixel{0, 0, 0},
Pixel font_color = Pixel{255, 255, 255});
uint8_t ui8_clamp(int value, uint8_t min = 0, uint8_t max = 255);
uint8_t medianFilter(std::array<int, 9> &);
uint8_t averageFilter(std::array<int, 9> &);
uint8_t prewittDXFilter(std::array<int, 9> &);
uint8_t prewittDYFilter(std::array<int, 9> &);
uint8_t sobelDXFilter(std::array<int, 9> &);
uint8_t sobelDYFilter(std::array<int, 9> &);
Pixel font_color = Pixel{255, 255, 255});

38
image-lib/filters.cpp Normal file
View file

@ -0,0 +1,38 @@
#include <algorithm>
#include "filters.h"
#include <utils-lib/utils.h>
uint8_t medianFilter(std::array<int, 9> &pixels) {
std::sort(pixels.begin(), pixels.end());
return ui8_clamp(pixels[5]);
}
uint8_t averageFilter(std::array<int, 9> &pixels) {
return ui8_clamp((pixels[0] * AVERAGE_MASK[0] + pixels[1] * AVERAGE_MASK[1] + pixels[2] * AVERAGE_MASK[2] +
pixels[3] * AVERAGE_MASK[3] + pixels[4] * AVERAGE_MASK[4] + pixels[5] * AVERAGE_MASK[5] +
pixels[6] * AVERAGE_MASK[6] + pixels[7] * AVERAGE_MASK[7] + pixels[8] * AVERAGE_MASK[8]) / 9);
}
uint8_t prewittDXFilter(std::array<int, 9> &pixels) {
return ui8_clamp(pixels[0] * PREWITT_MASK_DX[0] + pixels[1] * PREWITT_MASK_DX[1] + pixels[2] * PREWITT_MASK_DX[2] +
pixels[3] * PREWITT_MASK_DX[3] + pixels[4] * PREWITT_MASK_DX[4] + pixels[5] * PREWITT_MASK_DX[5] +
pixels[6] * PREWITT_MASK_DX[6] + pixels[7] * PREWITT_MASK_DX[7] + pixels[8] * PREWITT_MASK_DX[8]);
}
uint8_t prewittDYFilter(std::array<int, 9> &pixels) {
return ui8_clamp(pixels[0] * PREWITT_MASK_DY[0] + pixels[1] * PREWITT_MASK_DY[1] + pixels[2] * PREWITT_MASK_DY[2] +
pixels[3] * PREWITT_MASK_DY[3] + pixels[4] * PREWITT_MASK_DY[4] + pixels[5] * PREWITT_MASK_DY[5] +
pixels[6] * PREWITT_MASK_DY[6] + pixels[7] * PREWITT_MASK_DY[7] + pixels[8] * PREWITT_MASK_DY[8]);
}
uint8_t sobelDXFilter(std::array<int, 9> &pixels) {
return ui8_clamp(pixels[0] * SOBEL_MASK_DX[0] + pixels[1] * SOBEL_MASK_DX[1] + pixels[2] * SOBEL_MASK_DX[2] +
pixels[3] * SOBEL_MASK_DX[3] + pixels[4] * SOBEL_MASK_DX[4] + pixels[5] * SOBEL_MASK_DX[5] +
pixels[6] * SOBEL_MASK_DX[6] + pixels[7] * SOBEL_MASK_DX[7] + pixels[8] * SOBEL_MASK_DX[8]);
}
uint8_t sobelDYFilter(std::array<int, 9> &pixels) {
return ui8_clamp(pixels[0] * SOBEL_MASK_DY[0] + pixels[1] * SOBEL_MASK_DY[1] + pixels[2] * SOBEL_MASK_DY[2] +
pixels[3] * SOBEL_MASK_DY[3] + pixels[4] * SOBEL_MASK_DY[4] + pixels[5] * SOBEL_MASK_DY[5] +
pixels[6] * SOBEL_MASK_DY[6] + pixels[7] * SOBEL_MASK_DY[7] + pixels[8] * SOBEL_MASK_DY[8]);
}

22
image-lib/filters.h Normal file
View file

@ -0,0 +1,22 @@
#pragma once
#include <cstdint>
#include <array>
const int AVERAGE_MASK[9] = {1, 1, 1, 1, 1, 1, 1, 1, 1};
const int PREWITT_MASK_DX[9] = {-1, 0, 1, -1, 0, 1, -1, 0, 1};
const int PREWITT_MASK_DY[9] = {-1, -1, -1, 0, 0, 0, 1, 1, 1};
const int SOBEL_MASK_DX[9] = {-1, 0, 1, -2, 0, 2, -1, 0, 1};
const int SOBEL_MASK_DY[9] = {-1, -2, -1, 0, 0, 0, 1, 2, 1};
uint8_t medianFilter(std::array<int, 9> &);
uint8_t averageFilter(std::array<int, 9> &);
uint8_t prewittDXFilter(std::array<int, 9> &);
uint8_t prewittDYFilter(std::array<int, 9> &);
uint8_t sobelDXFilter(std::array<int, 9> &);
uint8_t sobelDYFilter(std::array<int, 9> &);

77
image-lib/pixelarray.cpp Normal file
View file

@ -0,0 +1,77 @@
#include "pixelarray.h"
Pixel operator+(const Pixel &p1, const Pixel &p2) {
const uint8_t r = ui8_clamp((int) p1.r + p2.r);
const uint8_t g = ui8_clamp((int) p1.g + p2.g);
const uint8_t b = ui8_clamp((int) p1.b + p2.b);
return {r, g, b};
}
Pixel operator/(const Pixel &p1, const uint8_t &n) {
const uint8_t r = p1.r / n;
const uint8_t g = p1.g / n;
const uint8_t b = p1.b / n;
return {r, g, b};
}
Pixel operator*(const Pixel &p, const int &n) {
uint8_t r = ui8_clamp(n * p.r);
uint8_t g = ui8_clamp(n * p.g);
uint8_t b = ui8_clamp(n * p.b);
return {r, g, b};
}
Pixel operator-(const uint8_t &n, const Pixel &p) {
uint8_t r = ui8_clamp(n - p.r);
uint8_t g = ui8_clamp(n - p.g);
uint8_t b = ui8_clamp(n - p.b);
return {r, g, b};
}
Pixel operator-(const Pixel &p, const uint8_t &n) {
uint8_t r = ui8_clamp(p.r - n);
uint8_t g = ui8_clamp(p.g - n);
uint8_t b = ui8_clamp(p.b - n);
return {r, g, b};
}
Pixel operator-(const Pixel &p1, const Pixel &p2) {
auto r = ui8_clamp((int) p1.r - p2.r);
auto g = ui8_clamp((int) p1.g - p2.g);
auto b = ui8_clamp((int) p1.b - p2.b);
return {r, g, b};
}
PixelArray::PixelArray(uint32_t width, uint32_t height) {
this->_width = width;
this->_height = height;
this->array = new Pixel *[height];
for (int i = 0; i < height; ++i) {
this->array[i] = new Pixel[width];
}
}
Pixel &PixelArray::operator()(const uint32_t &i, const uint32_t &j) {
return this->array[i][j];
}
PixelArray::~PixelArray() {
// for (int i = 0; i < this->_height; ++i) {
// delete[] this->array[i];
// }
// delete[] this->array;
}
PixelArray::PixelArray(const PixelArray &pA) {
this->_width = pA.width();
this->_height = pA.height();
this->array = pA.array;
}
Pixel *&PixelArray::operator()(const uint32_t &i) {
return this->array[i];
}
const uint32_t &PixelArray::width() const { return this->_width; }
const uint32_t &PixelArray::height() const { return this->_height; }

43
image-lib/pixelarray.h Normal file
View file

@ -0,0 +1,43 @@
#pragma once
#include <cstdint>
#include <utils-lib/utils.h>
#pragma pack(push, 1)
struct Pixel {
uint8_t r = 255;
uint8_t g = 0;
uint8_t b = 255;
};
#pragma pack(pop)
class PixelArray {
Pixel **array;
uint32_t _width;
uint32_t _height;
public:
PixelArray(uint32_t width, uint32_t height);
PixelArray(const PixelArray &);
~PixelArray();
[[nodiscard]] const uint32_t &width() const;
[[nodiscard]] const uint32_t &height() const;
Pixel &operator()(const uint32_t &, const uint32_t &);
Pixel *&operator()(const uint32_t &);
};
Pixel operator/(const Pixel &, const uint8_t &);
Pixel operator+(const Pixel &, const Pixel &);
Pixel operator*(const Pixel &, const int &);
Pixel operator-(const Pixel &, const uint8_t &);
Pixel operator-(const uint8_t &, const Pixel &);
Pixel operator-(const Pixel &, const Pixel &);

14
main.cpp
View file

@ -1,6 +1,6 @@
#include <iostream>
#include "bmpimage.h"
#include "psf.h"
#include <image-lib/bmpimage.h>
#include <image-lib/filters.h>
auto font = readPSF("../fonts/ruscii_8x16_2.psf");
@ -190,11 +190,11 @@ void test2() {
auto background_color = Pixel{0, 0, 0};
auto font_color = Pixel{255, 255, 255};
auto glyph = font._glyphs[u'б'];
auto w = glyph.width;
auto h = glyph.height;
auto w = glyph->width;
auto h = glyph->height;
uint32_t imgWidth = 16 * glyph.width;
uint32_t imgHeight = 16 * glyph.height;
uint32_t imgWidth = 16 * glyph->width;
uint32_t imgHeight = 16 * glyph->height;
PixelArray test(imgWidth, imgHeight);
std::u16string str = u"Hello, World! Привет, Мир!";
uint32_t k = 0;
@ -205,7 +205,7 @@ void test2() {
glyph = it.second;
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
if (glyph.glyph[i][j])
if (glyph->glyph[i][j])
test((k / 16) * h + i, (k % 16) * w + j) = font_color;
else
test((k / 16) * h + i, (k % 16) * w + j) = background_color;

18
utils-lib/CMakeLists.txt Normal file
View file

@ -0,0 +1,18 @@
add_library(utils-lib STATIC "")
set(UTILS_LIB_HEADERS
utils.h
)
set(UTILS_LIB_SOURCES
utils.cpp
)
target_sources(utils-lib
PRIVATE
${UTILS_LIB_SOURCES}
PUBLIC
FILE_SET HEADERS
BASE_DIRS ${PROJECT_SOURCE_DIR}
FILES ${UTILS_LIB_HEADERS}
)

11
utils-lib/utils.cpp Normal file
View file

@ -0,0 +1,11 @@
#include "utils.h"
uint8_t ui8_clamp(int value, uint8_t min, uint8_t max) {
if (value < min) {
return min;
}
if (value > max) {
return max;
}
return value;
}

4
utils-lib/utils.h Normal file
View file

@ -0,0 +1,4 @@
#pragma once
#include <cstdint>
uint8_t ui8_clamp(int value, uint8_t min = 0, uint8_t max = 255);