diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8d7af0d..c155afe 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -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
+)
diff --git a/bmpimage.cpp b/bmpimage.cpp
deleted file mode 100644
index b2ba7ec..0000000
--- a/bmpimage.cpp
+++ /dev/null
@@ -1,466 +0,0 @@
-#include <cmath>
-#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);
-//    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 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};
-}
-
-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();
-    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};
-}
-
-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();
-    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};
-}
-
-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;
-    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};
-}
-
-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;
-    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};
-}
-
-BMPImage filter(BMPImage &img, int mask[9], uint8_t modifier) {
-    auto origPixels = img.pixels_copy();
-    PixelArray pixels(img.width(), img.height());
-    for (int y = 1; y < img.height() - 1; ++y) {
-        for (int x = 1; x < img.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);
-            auto r = p1.r * mask[0] + p2.r * mask[1] + p3.r * mask[2] + p4.r * mask[3] + p5.r * mask[4] +
-                     p6.r * mask[5] + p7.r * mask[6] + p8.r * mask[7] + p9.r * mask[8];
-            auto g = p1.g * mask[0] + p2.g * mask[1] + p3.g * mask[2] + p4.g * mask[3] + p5.g * mask[4] +
-                     p6.g * mask[5] + p7.g * mask[6] + p8.g * mask[7] + p9.g * mask[8];
-            auto b = p1.b * mask[0] + p2.b * mask[1] + p3.b * mask[2] + p4.b * mask[3] + p5.b * mask[4] +
-                     p6.b * mask[5] + p7.b * mask[6] + p8.b * mask[7] + p9.b * mask[8];
-            pixels(y, x) = {ui8_clamp(r / modifier), ui8_clamp(g / modifier), ui8_clamp(b / modifier)};
-        }
-    }
-    return {pixels};
-}
-
-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; }
diff --git a/bmpimage.h b/bmpimage.h
deleted file mode 100644
index 77de907..0000000
--- a/bmpimage.h
+++ /dev/null
@@ -1,129 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <string>
-#include <fstream>
-#include "psf.h"
-
-const char PADDING_ZEROES[3] = {0, 0, 0};
-
-#pragma pack(push, 1)
-struct BitmapFileHeader {
-    char signature[2] = {'B', 'M'};
-    uint32_t fileSize = 0;
-    uint16_t reserved1 = 0;
-    uint16_t reserved2 = 0;
-    uint32_t imageDataOffset = 54;
-};
-#pragma pack(pop)
-
-#pragma pack(push, 1)
-struct BITMAPINFOHEADER {
-    uint32_t HeaderSize = 40;
-    uint32_t BitmapWidth = 0;
-    uint32_t BitmapHeight = 0;
-    uint16_t ColorPlanes = 1;
-    uint16_t BitsPerPixel = 24;
-    uint32_t CompressionMethod = 0;
-    uint32_t ImageSize = 0;
-    int32_t HorizontalPixelPerMetre = 0;
-    int32_t VerticalPixelPerMetre = 0;
-    uint32_t NumberOfColors = 0;
-    uint32_t NumberOfImportantColors = 0;
-};
-#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;
-    PixelArray pixelArray;
-public:
-    BMPImage(const BitmapFileHeader &fileHeader, const BITMAPINFOHEADER &infoHeader, const PixelArray &pixelArray);
-
-    BMPImage(const PixelArray &pixelArray);
-
-    ~BMPImage();
-
-    [[nodiscard]] const uint32_t &width() const;
-
-    [[nodiscard]] const uint32_t &height() const;
-
-    [[nodiscard]] PixelArray pixels();
-
-    [[nodiscard]] PixelArray pixels_copy();
-
-    [[nodiscard]] BitmapFileHeader fileHeader_copy();
-
-    [[nodiscard]] BITMAPINFOHEADER infoHeader_copy();
-
-    void save(const std::string &);
-
-    BMPImage appendRight(BMPImage &);
-
-    BMPImage overlay(BMPImage &, uint32_t, uint32_t);
-};
-
-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 &);
-
-BMPImage upscale2x(BMPImage &);
-
-BMPImage downscale2x(BMPImage &);
-
-BMPImage upscale1_5x(BMPImage &);
-
-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);
-
-BMPImage filter(BMPImage &img, int mask[9], uint8_t modifier = 9);
\ No newline at end of file
diff --git a/font-lib/CMakeLists.txt b/font-lib/CMakeLists.txt
new file mode 100644
index 0000000..9da4431
--- /dev/null
+++ b/font-lib/CMakeLists.txt
@@ -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}
+)
\ No newline at end of file
diff --git a/psf.cpp b/font-lib/psf.cpp
similarity index 87%
rename from psf.cpp
rename to font-lib/psf.cpp
index 50d731a..e79e338 100644
--- a/psf.cpp
+++ b/font-lib/psf.cpp
@@ -1,7 +1,3 @@
-//
-// Created by Evgenij on 09.04.2024.
-//
-
 #include <locale>
 #include <codecvt>
 #include <vector>
@@ -11,7 +7,7 @@ std::wstring_convert<std::codecvt_utf8<char16_t>, char16_t> conv_utf8_utf16;
 
 Font readPSF(const std::string &filename) {
     {
-        PSF2Header psf2Header;
+        PSF2Header psf2Header{};
         std::ifstream ifs(filename, std::ios_base::binary);
         if (!ifs.good()) {
             throw std::runtime_error("File read error");
@@ -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;
                 }
             }
@@ -49,7 +45,7 @@ Font readPSF(const std::string &filename) {
             if (curByte != 0xFF) {
                 vectorOfBytes.push_back(curByte);
             } else {
-                unsigned long long int bytesCount = vectorOfBytes.size();
+                auto bytesCount = vectorOfBytes.size();
                 unsigned char bytes[bytesCount];
                 for (int i = 0; i < bytesCount; ++i) {
                     bytes[i] = vectorOfBytes[i];
@@ -79,16 +75,9 @@ 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;
     this->glyphWidth = glyphWidth;
     this->glyphHeight = glyphHeight;
-}
-
-Font::Font() {
-
-}
+}
\ No newline at end of file
diff --git a/psf.h b/font-lib/psf.h
similarity index 87%
rename from psf.h
rename to font-lib/psf.h
index f27dbe3..932affb 100644
--- a/psf.h
+++ b/font-lib/psf.h
@@ -4,7 +4,9 @@
 #include <fstream>
 #include <cstdint>
 #include <map>
+#include <memory>
 
+static_assert(true); //Обход clangd бага
 #pragma pack(push, 1)
 struct PSF1Header {
     char magicNumber[2];
@@ -34,18 +36,15 @@ 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;
 
-    Font();
-
     explicit Font(uint32_t glyphs, uint32_t glyphWidth, uint32_t glyphHeight);
 };
 
diff --git a/image-lib/CMakeLists.txt b/image-lib/CMakeLists.txt
new file mode 100644
index 0000000..979d380
--- /dev/null
+++ b/image-lib/CMakeLists.txt
@@ -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
+)
\ No newline at end of file
diff --git a/image-lib/bmpimage.cpp b/image-lib/bmpimage.cpp
new file mode 100644
index 0000000..c8791b8
--- /dev/null
+++ b/image-lib/bmpimage.cpp
@@ -0,0 +1,383 @@
+#include <cmath>
+#include <memory>
+#include <algorithm>
+#include <utility>
+#include "bmpimage.h"
+
+BMPImage::BMPImage(const BitmapFileHeader &fileHeader, const BITMAPINFOHEADER &infoHeader,
+                   std::shared_ptr<PixelArray> pixelArray) {
+    this->fileHeader = fileHeader;
+    this->infoHeader = infoHeader;
+    this->pixelArray = std::move(pixelArray);
+}
+
+
+//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
+        }
+    }
+}
+
+std::shared_ptr<PixelArray> BMPImage::pixels() const {
+    return this->pixelArray;
+}
+
+std::shared_ptr<PixelArray> BMPImage::pixels_copy() {
+//    Pixel **newPixelArray;
+    std::shared_ptr<PixelArray> newPixelArray = std::make_shared<PixelArray>(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); // TODO: Сделать конструктор копирования в PixelArray
+        }
+    }
+    return newPixelArray;
+}
+
+BitmapFileHeader BMPImage::fileHeader_copy() {
+    return this->fileHeader;
+}
+
+BITMAPINFOHEADER BMPImage::infoHeader_copy() {
+    return this->infoHeader;
+}
+
+BMPImage::BMPImage(std::shared_ptr<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;
+}
+
+std::shared_ptr<BMPImage> BMPImage::appendRight(const std::shared_ptr<const BMPImage>& img) {
+    uint32_t newHeight = std::max(this->infoHeader.BitmapHeight, img->height());
+    uint32_t newWidth = this->infoHeader.BitmapWidth + img->width();
+//    Pixel **newPixelArray;
+    std::shared_ptr<PixelArray> newPixelArray = std::make_shared<PixelArray>(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 std::make_shared<BMPImage>(newPixelArray);
+}
+
+std::shared_ptr<BMPImage> BMPImage::overlay(const std::shared_ptr<const 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 std::make_shared<BMPImage>(pixels);
+}
+
+std::shared_ptr<BMPImage> BMPImage::applyFilter(const std::function<uint8_t(std::array<int, 9> &)> &filter) {
+    auto origPixels = this->pixels_copy();
+    std::shared_ptr<PixelArray> pixels = std::make_shared<PixelArray>(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 std::make_shared<BMPImage>(pixels);
+}
+
+
+std::shared_ptr<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));
+    }
+    std::shared_ptr<PixelArray> pixelArray = std::make_shared<PixelArray>(bitmapInfoHeader.BitmapWidth,
+                                                                          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 std::make_shared<BMPImage>(bitmapFileHeader, bitmapInfoHeader, pixelArray);
+}
+
+
+std::shared_ptr<BMPImage> grayscale(const std::shared_ptr<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 std::make_shared<BMPImage>(img->fileHeader_copy(), img->infoHeader_copy(), pixels);
+}
+
+
+std::shared_ptr<BMPImage> invertColors(const std::shared_ptr<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 std::make_shared<BMPImage>(img->fileHeader_copy(), img->infoHeader_copy(), pixels);
+}
+
+std::shared_ptr<BMPImage> upscale2x(const std::shared_ptr<const BMPImage>& img) {
+    auto oldPixels = img->pixels();
+    const uint32_t newHeight = img->height() * 2;
+    const uint32_t newWidth = img->width() * 2;
+    std::shared_ptr<PixelArray> newPixelArray = std::make_shared<PixelArray>(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 std::make_shared<BMPImage>(newPixelArray);
+}
+
+std::shared_ptr<BMPImage> downscale2x(const std::shared_ptr<const BMPImage>& img) {
+    auto oldPixels = img->pixels();
+    const uint32_t newHeight = img->height() / 2;
+    const uint32_t newWidth = img->width() / 2;
+    std::shared_ptr<PixelArray> newPixelArray = std::make_shared<PixelArray>(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 std::make_shared<BMPImage>(newPixelArray);
+}
+
+std::shared_ptr<BMPImage> upscale1_5x(const std::shared_ptr<const BMPImage>& img) {
+    auto oldPixels = img->pixels();
+    const uint32_t newHeight = img->height() * 3 / 2;
+    const uint32_t newWidth = img->width() * 3 / 2;
+    std::shared_ptr<PixelArray> newPixelArray = std::make_shared<PixelArray>(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 std::make_shared<BMPImage>(newPixelArray);
+}
+
+std::shared_ptr<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;
+    std::shared_ptr<PixelArray> pixels = std::make_shared<PixelArray>(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 std::make_shared<BMPImage>(pixels);
+}
+
+std::shared_ptr<BMPImage> upscale1_5x_ver2(const std::shared_ptr<const BMPImage>& img) {
+    auto oldPixels = img->pixels();
+    const uint32_t newHeight = img->height() * 3 / 2;
+    const uint32_t newWidth = img->width() * 3 / 2;
+    std::shared_ptr<PixelArray> newPixelArray = std::make_shared<PixelArray>(newWidth, newHeight);
+    for (int i = 0; i < newHeight; ++i) {
+        auto oldi = (int)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) {
+            auto oldj = (int)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 std::make_shared<BMPImage>(newPixelArray);
+}
+
+std::shared_ptr<BMPImage> upscale2x_ver2(const std::shared_ptr<const BMPImage>& img) {
+    auto oldPixels = img->pixels();
+    const uint32_t newHeight = img->height() * 2;
+    const uint32_t newWidth = img->width() * 2;
+    std::shared_ptr<PixelArray> newPixelArray = std::make_shared<PixelArray>(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 std::make_shared<BMPImage>(newPixelArray);
+}
+
diff --git a/image-lib/bmpimage.h b/image-lib/bmpimage.h
new file mode 100644
index 0000000..d5078f0
--- /dev/null
+++ b/image-lib/bmpimage.h
@@ -0,0 +1,86 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <fstream>
+#include <array>
+#include <functional>
+#include <font-lib/psf.h>
+#include "pixelarray.h"
+
+const char PADDING_ZEROES[3] = {0, 0, 0};
+
+#pragma pack(push, 1)
+struct BitmapFileHeader {
+    char signature[2] = {'B', 'M'};
+    uint32_t fileSize = 0;
+    uint16_t reserved1 = 0;
+    uint16_t reserved2 = 0;
+    uint32_t imageDataOffset = 54;
+};
+#pragma pack(pop)
+
+#pragma pack(push, 1)
+struct BITMAPINFOHEADER {
+    uint32_t HeaderSize = 40;
+    uint32_t BitmapWidth = 0;
+    uint32_t BitmapHeight = 0;
+    uint16_t ColorPlanes = 1;
+    uint16_t BitsPerPixel = 24;
+    uint32_t CompressionMethod = 0;
+    uint32_t ImageSize = 0;
+    int32_t HorizontalPixelPerMetre = 0;
+    int32_t VerticalPixelPerMetre = 0;
+    uint32_t NumberOfColors = 0;
+    uint32_t NumberOfImportantColors = 0;
+};
+#pragma pack(pop)
+
+class BMPImage {
+    BitmapFileHeader fileHeader;
+    BITMAPINFOHEADER infoHeader;
+    std::shared_ptr<PixelArray> pixelArray;
+public:
+    BMPImage(const BitmapFileHeader &fileHeader, const BITMAPINFOHEADER &infoHeader, std::shared_ptr<PixelArray> pixelArray);
+
+    explicit BMPImage(std::shared_ptr<PixelArray> pixelArray);
+
+    [[nodiscard]] const uint32_t &width() const;
+
+    [[nodiscard]] const uint32_t &height() const;
+
+    [[nodiscard]] std::shared_ptr<PixelArray> pixels() const;
+
+    [[nodiscard]] std::shared_ptr<PixelArray> pixels_copy();
+
+    [[nodiscard]] BitmapFileHeader fileHeader_copy();
+
+    [[nodiscard]] BITMAPINFOHEADER infoHeader_copy();
+
+    void save(const std::string &);
+
+    std::shared_ptr<BMPImage> appendRight(const std::shared_ptr<const BMPImage>&);
+
+    std::shared_ptr<BMPImage> overlay(const std::shared_ptr<const BMPImage>&, uint32_t, uint32_t);
+
+    std::shared_ptr<BMPImage> applyFilter(const std::function<uint8_t (std::array<int,9>&)>& filter);
+};
+
+std::shared_ptr<BMPImage> readBMPImage(const std::string &filename);
+
+std::shared_ptr<BMPImage> grayscale(const std::shared_ptr<BMPImage>&); // TODO: Сделать const BMPImage
+
+std::shared_ptr<BMPImage> invertColors(const std::shared_ptr<BMPImage>&);  // TODO: Сделать const BMPImage
+
+std::shared_ptr<BMPImage> upscale2x(const std::shared_ptr<const BMPImage>&);
+
+std::shared_ptr<BMPImage> downscale2x(const std::shared_ptr<const BMPImage>&);
+
+std::shared_ptr<BMPImage> upscale1_5x(const std::shared_ptr<const BMPImage>&);
+
+std::shared_ptr<BMPImage> upscale1_5x_ver2(const std::shared_ptr<const BMPImage>&); // TODO: BAD
+
+std::shared_ptr<BMPImage> upscale2x_ver2(const std::shared_ptr<const BMPImage>&); // TODO: BAD
+
+std::shared_ptr<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});
\ No newline at end of file
diff --git a/image-lib/filters.cpp b/image-lib/filters.cpp
new file mode 100644
index 0000000..301af5b
--- /dev/null
+++ b/image-lib/filters.cpp
@@ -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]);
+}
\ No newline at end of file
diff --git a/image-lib/filters.h b/image-lib/filters.h
new file mode 100644
index 0000000..b817a28
--- /dev/null
+++ b/image-lib/filters.h
@@ -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> &);
\ No newline at end of file
diff --git a/image-lib/pixelarray.cpp b/image-lib/pixelarray.cpp
new file mode 100644
index 0000000..2535d8a
--- /dev/null
+++ b/image-lib/pixelarray.cpp
@@ -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; }
diff --git a/image-lib/pixelarray.h b/image-lib/pixelarray.h
new file mode 100644
index 0000000..d8759ca
--- /dev/null
+++ b/image-lib/pixelarray.h
@@ -0,0 +1,44 @@
+#pragma once
+#include <cstdint>
+#include <utils-lib/utils.h>
+
+static_assert(true);
+#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 &);
\ No newline at end of file
diff --git a/main.cpp b/main.cpp
index d35987a..b8d15c8 100644
--- a/main.cpp
+++ b/main.cpp
@@ -1,20 +1,17 @@
 #include <iostream>
-#include "bmpimage.h"
-#include "psf.h"
+#include <image-lib/bmpimage.h>
+#include <image-lib/filters.h>
 
-const std::string FILENAME = "../elef.bmp";
-const std::string FILENAME_OUT = "../elef_out.bmp";
 auto font = readPSF("../fonts/ruscii_8x16_2.psf");
 
-//
 void lab01() {
     auto og_image = readBMPImage("../elef.bmp");
-    auto pixels1 = og_image.pixels_copy();
-    auto pixels2 = og_image.pixels_copy();
-    for (int i = 0; i < og_image.height(); ++i) {
-        for (int j = 0; j < og_image.width(); ++j) {
-            pixels1(i, j) = pixels1(i, j) / 2;
-            pixels2(i, j) = pixels2(i, j) * 2;
+    auto pixels1 = og_image->pixels_copy();
+    auto pixels2 = og_image->pixels_copy();
+    for (int i = 0; i < og_image->height(); ++i) {
+        for (int j = 0; j < og_image->width(); ++j) {
+            (*pixels1)(i, j) = (*pixels1)(i, j) / 2;
+            (*pixels2)(i, j) = (*pixels2)(i, j) * 2;
         }
     }
     auto orig_text = textImg(u"Оригинал", &font, 3);
@@ -24,14 +21,14 @@ void lab01() {
     auto grayscale_text = textImg(u"Оттенки серого", &font, 3);
     auto darkenImg = BMPImage(pixels1).overlay(darken_text, 0, 0);
     auto lighterImg = BMPImage(pixels2).overlay(lighter_text, 0, 0);
-    auto invert_img = invertColors(og_image).overlay(invert_text, 0, 0); // TODO
-    auto grayscale_img = grayscale(og_image).overlay(grayscale_text, 0, 0);
+    auto invert_img = invertColors(og_image)->overlay(invert_text, 0, 0); // TODO
+    auto grayscale_img = grayscale(og_image)->overlay(grayscale_text, 0, 0);
 
-    og_image.appendRight(lighterImg).appendRight(darkenImg).appendRight(invert_img).appendRight(grayscale_img).overlay(
-            orig_text, 0, 0).save("../lab01/elef1.bmp");
+    og_image->appendRight(lighterImg)->appendRight(darkenImg)->appendRight(invert_img)->appendRight(
+            grayscale_img)->overlay(
+            orig_text, 0, 0)->save("../lab01/elef1.bmp");
 }
 
-//
 void lab02_01() {
     auto img = readBMPImage("../tea.bmp");
     auto text1024 = textImg(u"1024", &font, 3);
@@ -41,29 +38,28 @@ void lab02_01() {
     auto img_512 = downscale2x(img);
     auto img_256 = downscale2x(img_512);
     auto img_128 = downscale2x(img_256);
-    img_512.overlay(text512, 0, 0).save("../lab02/tea_512.bmp");
-    img_256.overlay(text256, 0, 0).save("../lab02/tea_256.bmp");
-    img_128.overlay(text128, 0, 0).save("../lab02/tea_128.bmp");
-    img.overlay(text1024, 0, 0).appendRight(img_512).overlay(text512, 1024, 0).appendRight(img_256).
-            overlay(text256, 1536, 0).appendRight(img_128).overlay(text128, 1792, 0).save(
-            "../lab02/tea_downscale.bmp");;
-    auto img_from_512 = upscale2x(img_512).overlay(text512, 0, 0);
+    img_512->overlay(text512, 0, 0)->save("../lab02/tea_512.bmp");
+    img_256->overlay(text256, 0, 0)->save("../lab02/tea_256.bmp");
+    img_128->overlay(text128, 0, 0)->save("../lab02/tea_128.bmp");
+    img->overlay(text1024, 0, 0)->appendRight(img_512)->overlay(text512, 1024, 0)->appendRight(img_256)->
+            overlay(text256, 1536, 0)->appendRight(img_128)->overlay(text128, 1792, 0)->save(
+            "../lab02/tea_downscale.bmp");
+    auto img_from_512 = upscale2x(img_512)->overlay(text512, 0, 0);
 ////    auto img_from_256 = upscale2x(upscale2x(img_256));
 ////    auto img_from_128 = upscale2x(upscale2x(upscale2x(img_128)));
     auto tmp = upscale2x(img_256);
-    auto img_from_256 = upscale2x(tmp).overlay(text256, 0, 0);
+    auto img_from_256 = upscale2x(tmp)->overlay(text256, 0, 0);
     auto tmp2 = upscale2x(img_128);
     auto tmp3 = upscale2x(tmp2);
-    auto img_from_128 = upscale2x(tmp3).overlay(text128, 0, 0);
-    img_from_512.save("../lab02/tea_from_512.bmp");
-    img_from_256.save("../lab02/tea_from_256.bmp");
-    img_from_128.save("../lab02/tea_from_128.bmp");
-    img.overlay(text1024, 0, 0).appendRight(img_from_512).appendRight(img_from_256).appendRight(img_from_128).save(
+    auto img_from_128 = upscale2x(tmp3)->overlay(text128, 0, 0);
+    img_from_512->save("../lab02/tea_from_512.bmp");
+    img_from_256->save("../lab02/tea_from_256.bmp");
+    img_from_128->save("../lab02/tea_from_128.bmp");
+    img->overlay(text1024, 0, 0)->appendRight(img_from_512)->appendRight(img_from_256)->appendRight(img_from_128)->save(
             "../lab02/tea_upscale.bmp");
 //    newImg2->save("../lab02/tea_upscale.bmp");
 }
 
-//
 void lab02_02() {
     auto img = readBMPImage("../tea.bmp");
     auto ogText = textImg(u"Оригинал", &font, 3);
@@ -72,38 +68,37 @@ void lab02_02() {
     auto text64 = textImg(u"64 оттенка", &font, 3);
     auto text32 = textImg(u"32 оттенка", &font, 3);
     auto gsImg = grayscale(img);
-    gsImg.overlay(text256, 0, 0).save("../lab02/tea_grayscale_256.bmp");
-    auto gsPixels = gsImg.pixels_copy();
-    auto width = gsImg.width();
-    auto height = gsImg.height();
+    gsImg->overlay(text256, 0, 0)->save("../lab02/tea_grayscale_256.bmp");
+    auto gsPixels = gsImg->pixels_copy();
+    auto width = gsImg->width();
+    auto height = gsImg->height();
     for (int i = 0; i < height; ++i) {
         for (int j = 0; j < width; ++j) {
-            gsPixels(i, j) = (gsPixels(i, j) / 2) * 2;
+            (*gsPixels)(i, j) = ((*gsPixels)(i, j) / 2) * 2;
         }
     }
     auto gsImg128 = BMPImage(gsPixels).overlay(text128, 0, 0);
-    gsPixels = gsImg.pixels_copy();
+    gsPixels = gsImg->pixels_copy();
     for (int i = 0; i < height; ++i) {
         for (int j = 0; j < width; ++j) {
-            gsPixels(i, j) = (gsPixels(i, j) / 4) * 4;
+            (*gsPixels)(i, j) = ((*gsPixels)(i, j) / 4) * 4;
         }
     }
     auto gsImg64 = BMPImage(gsPixels).overlay(text64, 0, 0);
-    gsPixels = gsImg.pixels_copy();
+    gsPixels = gsImg->pixels_copy();
     for (int i = 0; i < height; ++i) {
         for (int j = 0; j < width; ++j) {
-            gsPixels(i, j) = (gsPixels(i, j) / 8) * 8;
+            (*gsPixels)(i, j) = ((*gsPixels)(i, j) / 8) * 8;
         }
     }
     auto gsImg32 = BMPImage(gsPixels).overlay(text32, 0, 0);
-    gsImg128.save("../lab02/tea_grayscale_128.bmp");
-    gsImg64.save("../lab02/tea_grayscale_64.bmp");
-    gsImg32.save("../lab02/tea_grayscale_32.bmp");
-    img.overlay(ogText, 0, 0).appendRight(gsImg).overlay(text256, 1024, 0).appendRight(gsImg128).appendRight(
-            gsImg64).appendRight(gsImg32).save("../lab02/tea_grayscale.bmp");
+    gsImg128->save("../lab02/tea_grayscale_128.bmp");
+    gsImg64->save("../lab02/tea_grayscale_64.bmp");
+    gsImg32->save("../lab02/tea_grayscale_32.bmp");
+    img->overlay(ogText, 0, 0)->appendRight(gsImg)->overlay(text256, 1024, 0)->appendRight(gsImg128)->appendRight(
+            gsImg64)->appendRight(gsImg32)->save("../lab02/tea_grayscale.bmp");
 }
 
-//
 void lab02_03() {
     auto img = readBMPImage("../tea.bmp");
     auto text = textImg(u"Оригинал", &font, 3);
@@ -119,103 +114,97 @@ void lab02_03() {
     auto img_2_ver2 = upscale2x_ver2(img);
     auto img_3 = upscale2x(img_1_5);
     auto img_3_ver2 = upscale2x_ver2(img_1_5_ver2);
-    img_1_5.overlay(text_avrg, 0, 0).appendRight(img_1_5_ver2).overlay(text_lin, 1536, 0).save(
+    img_1_5->overlay(text_avrg, 0, 0)->appendRight(img_1_5_ver2)->overlay(text_lin, 1536, 0)->save(
             "../lab02/lab02_03/tea_x1_5.bmp");
-    img_2.overlay(text_avrg2, 0, 0).appendRight(img_2_ver2).overlay(text_lin2, 2048, 0).save(
+    img_2->overlay(text_avrg2, 0, 0)->appendRight(img_2_ver2)->overlay(text_lin2, 2048, 0)->save(
             "../lab02/lab02_03/tea_x2.bmp");
-    img_3.overlay(text_avrg3, 0, 0).appendRight(img_3_ver2).overlay(text_lin3, 3072, 0).save(
+    img_3->overlay(text_avrg3, 0, 0)->appendRight(img_3_ver2)->overlay(text_lin3, 3072, 0)->save(
             "../lab02/lab02_03/tea_x3.bmp");
-    img.overlay(text, 0, 0).appendRight(img_1_5).overlay(text_avrg, 1024, 0).appendRight(img_2)
-            .overlay(text_avrg2, 2560, 0).appendRight(img_3).overlay(text_avrg3, 4608, 0).save(
+    img->overlay(text, 0, 0)->appendRight(img_1_5)->overlay(text_avrg, 1024, 0)->appendRight(img_2)
+            ->overlay(text_avrg2, 2560, 0)->appendRight(img_3)->overlay(text_avrg3, 4608, 0)->save(
                     "../lab02/lab02_03/tea_upscale.bmp");
-    img.overlay(text, 0, 0).appendRight(img_1_5_ver2).overlay(text_lin, 1024, 0).appendRight(img_2_ver2)
-            .overlay(text_lin, 2560, 0).appendRight(img_3_ver2).overlay(text_lin, 4608, 0).save(
+    img->overlay(text, 0, 0)->appendRight(img_1_5_ver2)->overlay(text_lin, 1024, 0)->appendRight(img_2_ver2)
+            ->overlay(text_lin, 2560, 0)->appendRight(img_3_ver2)->overlay(text_lin, 4608, 0)->save(
                     "../lab02/lab02_03/tea_upscale_ver2.bmp");
 }
 
 void lab03() {
-    auto img = readBMPImage("../tea.bmp");
+    auto img = readBMPImage("../bike.bmp");
     auto imgGS = grayscale(img);
-    int avrg_mask[9] = {1, 1, 1, 1, 1, 1, 1, 1, 1};
-    int previtt_mask1[9] = {-1, 0, 1, -1, 0, 1, -1, 0, 1};
-    int previtt_mask2[9] = {-1, -1, -1, 0, 0, 0, 1, 1, 1};
-    int sobel_mask1[9] = {-1, 0, 1, -2, 0, 2, -1, 0, 1};
-    int sobel_mask2[9] = {-1, -2, -1, 0, 0, 0, 1, 2, 1};
+
     auto avrg_text = textImg(u"Осреднение", &font, 3);
-    auto previtt_text = textImg(u"Фильтр Превитта", &font, 3);
+    auto median_text = textImg(u"Медиана", &font, 3);
+    auto prewitt_text = textImg(u"Фильтр Превитта", &font, 3);
     auto sobel_text = textImg(u"Фильтр Собеля", &font, 3);
     auto text = textImg(u"Оригинал", &font, 3);
-    auto avrg_image = filter(imgGS, avrg_mask).overlay(avrg_text, 0, 0);
-    auto previtt_image1 = filter(imgGS, previtt_mask1, 1);//.overlay(previtt_text, 0, 0);
-    auto previtt_image2 = filter(imgGS, previtt_mask2, 1);//.overlay(previtt_text, 0, 0);
-    previtt_image1.save("../lab03/previtt1.bmp");
-    previtt_image2.save("../lab03/previtt2.bmp");
-    PixelArray previttPixels(previtt_image1.width(), previtt_image1.height());
-    for (int y = 0; y < previtt_image1.height(); ++y) {
-        for (int x = 0; x < previtt_image1.width(); ++x) {
-            previttPixels(y, x) = previtt_image1.pixels()(y, x) + previtt_image2.pixels()(y, x);
+
+    auto avrg_image = imgGS->applyFilter(averageFilter)->overlay(avrg_text, 0, 0);
+    auto median_image = imgGS->applyFilter(medianFilter)->overlay(median_text, 0, 0);
+    auto prewitt_dx_image = imgGS->applyFilter(prewittDXFilter);
+    auto prewitt_dy_image = imgGS->applyFilter(prewittDYFilter);
+    prewitt_dx_image->save("../lab03/prewitt1.bmp");
+    prewitt_dy_image->save("../lab03/prewitt2.bmp");
+    std::shared_ptr<PixelArray> prewittPixels = std::make_shared<PixelArray>(prewitt_dx_image->width(), prewitt_dy_image->height());
+    for (int y = 0; y < prewitt_dx_image->height(); ++y) {
+        for (int x = 0; x < prewitt_dx_image->width(); ++x) {
+            (*prewittPixels)(y, x) = (*prewitt_dx_image->pixels())(y, x) + (*prewitt_dy_image->pixels())(y, x);
         }
     }
-    auto previtt_image = BMPImage(previttPixels).overlay(previtt_text, 0, 0);
-    auto sobel_image1 = filter(imgGS, sobel_mask1, 1).overlay(sobel_text, 0, 0);
-    auto sobel_image2 = filter(imgGS, sobel_mask2, 1).overlay(sobel_text, 0, 0);
-    PixelArray sobelPixels(sobel_image1.width(), sobel_image2.height());
-    for (int y = 0; y < sobel_image1.height(); ++y) {
-        for (int x = 0; x < sobel_image1.width(); ++x) {
-            previttPixels(y, x) = sobel_image1.pixels()(y, x) + sobel_image2.pixels()(y, x);
+    auto prewitt_image = BMPImage(prewittPixels).overlay(prewitt_text, 0, 0);
+    auto sobel_dx_image = imgGS->applyFilter(sobelDXFilter)->overlay(sobel_text, 0, 0);
+    auto sobel_dy_image2 = imgGS->applyFilter(sobelDYFilter)->overlay(sobel_text, 0, 0);
+    std::shared_ptr<PixelArray> sobelPixels = std::make_shared<PixelArray>(sobel_dx_image->width(), sobel_dx_image->height());
+    for (int y = 0; y < sobel_dx_image->height(); ++y) {
+        for (int x = 0; x < sobel_dx_image->width(); ++x) {
+            (*sobelPixels)(y, x) = (*sobel_dx_image->pixels())(y, x) + (*sobel_dy_image2->pixels())(y, x);
         }
     }
-    auto sobel_image = BMPImage(previttPixels).overlay(sobel_text, 0, 0);
-    imgGS.overlay(text, 0, 0).appendRight(avrg_image).save("../lab03/avrg_filter.bmp");
-    imgGS.overlay(text, 0, 0).appendRight(previtt_image).save("../lab03/previtt_filter.bmp");
-    imgGS.overlay(text, 0, 0).appendRight(sobel_image).save("../lab03/sobel_filter.bmp");
+    auto sobel_image = BMPImage(sobelPixels).overlay(sobel_text, 0, 0);
+    imgGS->overlay(text, 0, 0)->appendRight(avrg_image)->appendRight(median_image)->save("../lab03/avrg_median_filter.bmp");
+    imgGS->overlay(text, 0, 0)->appendRight(prewitt_image)->save("../lab03/prewitt_filter.bmp");
+    imgGS->overlay(text, 0, 0)->appendRight(sobel_image)->save("../lab03/sobel_filter.bmp");
 }
 
 void test() {
-//    Pixel **test;
-    PixelArray test(3, 3);
-//    test = new Pixel *[3];
-//    test[0] = new Pixel[3];
-//    test[1] = new Pixel[3];
-//    test[2] = new Pixel[3];
-    test(0, 0) = Pixel{0, 0, 0};
-    test(0, 1) = Pixel{127, 127, 127};
-    test(0, 2) = Pixel{255, 255, 255};
-    test(1, 0) = Pixel{127, 127, 127};
-    test(1, 1) = Pixel{63, 63, 63};
-    test(1, 2) = Pixel{127, 127, 127};
-    test(2, 0) = Pixel{255, 255, 255};
-    test(2, 1) = Pixel{127, 127, 127};
-    test(2, 2) = Pixel{0, 0, 0};
-    auto test_img = BMPImage(test);
-    test_img.save("../test.bmp");
+    std::shared_ptr<PixelArray> test = std::make_shared<PixelArray>(3, 3);
+    (*test)(0, 0) = Pixel{0, 0, 0};
+    (*test)(0, 1) = Pixel{127, 127, 127};
+    (*test)(0, 2) = Pixel{255, 255, 255};
+    (*test)(1, 0) = Pixel{127, 127, 127};
+    (*test)(1, 1) = Pixel{63, 63, 63};
+    (*test)(1, 2) = Pixel{127, 127, 127};
+    (*test)(2, 0) = Pixel{255, 255, 255};
+    (*test)(2, 1) = Pixel{127, 127, 127};
+    (*test)(2, 2) = Pixel{0, 0, 0};
+    auto test_img = std::make_shared<BMPImage>(test);
+    test_img->save("../test.bmp");
     auto test_scale = upscale1_5x_ver2(test_img);
-    test_scale.save("../test_scale.bmp");
+    test_scale->save("../test_scale.bmp");
 }
 
 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;
-    PixelArray test(imgWidth, imgHeight);
+    uint32_t imgWidth = 16 * glyph->width;
+    uint32_t imgHeight = 16 * glyph->height;
+    std::shared_ptr<PixelArray> test = std::make_shared<PixelArray>(imgWidth, imgHeight);
     std::u16string str = u"Hello, World! Привет, Мир!";
     uint32_t k = 0;
-    for (auto it: font._glyphs) {
+    for (const auto &it: font._glyphs) {
         if (k == 256) continue;
 //        glyph = font._glyphs[u'☺'];
 //        glyph = font._glyphs[str[k % str.size()]];
         glyph = it.second;
         for (int i = 0; i < h; ++i) {
             for (int j = 0; j < w; ++j) {
-                if (glyph.glyph[i][j])
-                    test((k / 16) * h + i, (k % 16) * w + j) = font_color;
+                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;
+                    (*test)((k / 16) * h + i, (k % 16) * w + j) = background_color;
             }
         }
         k++;
@@ -224,11 +213,11 @@ void test2() {
 }
 
 void test3() {
-    textImg(u"Привет, Мир!", &font).save("../font_test.bmp");
+    textImg(u"Привет, Мир!", &font)->save("../font_test.bmp");
 }
 
 int main() {
-    //lab01();
+//    lab01();
 //    lab02_01();
 //    lab02_02();
 //    lab02_03();
@@ -236,6 +225,5 @@ int main() {
 //    test();
 //    test2();
 //    test3();
-//    auto t = readBMPImage("../lab02/lab02_03/tea_x3.bmp");
     return 0;
 }
diff --git a/utils-lib/CMakeLists.txt b/utils-lib/CMakeLists.txt
new file mode 100644
index 0000000..93803fe
--- /dev/null
+++ b/utils-lib/CMakeLists.txt
@@ -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}
+)
\ No newline at end of file
diff --git a/utils-lib/utils.cpp b/utils-lib/utils.cpp
new file mode 100644
index 0000000..fbf1d35
--- /dev/null
+++ b/utils-lib/utils.cpp
@@ -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;
+}
\ No newline at end of file
diff --git a/utils-lib/utils.h b/utils-lib/utils.h
new file mode 100644
index 0000000..ee4067b
--- /dev/null
+++ b/utils-lib/utils.h
@@ -0,0 +1,4 @@
+#pragma once
+#include <cstdint>
+
+uint8_t ui8_clamp(int value, uint8_t min = 0, uint8_t max = 255);
\ No newline at end of file