Added bitmap converter

Author: iiNomad23

CMakeLists.txt

@@ -11,7 +11,9 @@ add_executable(LiveStreamClient
         includes/api/WebSocketConnection.h
         includes/api/Server.h
         includes/BrainsBehindScreenshot.h
+        includes/BitmapConverter.h
         src/BrainsBehindScreenshot.cpp
+        src/BitmapConverter.cpp
         src/api/server.cpp
         src/api/WebSocketClient.cpp
         src/api/WebSocketConnection.cpp

includes/BitmapConverter.h

@@ -0,0 +1,24 @@
+//
+// Created by marco on 16/11/2024.
+//
+
+#ifndef BITMAPCONVERTER_H
+#define BITMAPCONVERTER_H
+
+#include <windows.h>
+#include <vector>
+#include <string>
+
+class BitmapConverter {
+public:
+    static std::vector<BYTE> HBitmapToRGB(HBITMAP hBitmap, int width, int height);
+
+    static std::vector<BYTE> ResizeImage(const std::vector<BYTE> &pixels, int originalWidth, int originalHeight,
+                                         int newWidth, int newHeight);
+
+    static std::vector<int> CategorizePixels(const std::vector<BYTE> &pixels, int width, int height);
+
+    static std::string PixelsToString(const std::vector<int> &pixels);
+};
+
+#endif //BITMAPCONVERTER_H

includes/BrainsBehindScreenshot.h

@@ -14,17 +14,22 @@
 class ScreenCapture {
 public:
     ScreenCapture();
+
     ~ScreenCapture();
 
-    static bool CaptureScreen(const std::wstring& filename);
-    static BITMAP CaptureScreenBitmap();
+    static bool CaptureScreen(const std::wstring &filename);
+
+    static HBITMAP CaptureScreenBitmap(int &width, int &height);
 
 private:
     ULONG_PTR gdiplusToken{};
 
     void InitializeGDIPlus();
+
     void ShutdownGDIPlus() const;
-    static void SaveBitmapToFile(HBITMAP hBitmap, const std::wstring& filename);
-    static int GetEncoderClsid(const WCHAR* format, CLSID* pClsid);
+
+    static void SaveBitmapToFile(HBITMAP hBitmap, const std::wstring &filename);
+
+    static int GetEncoderClsid(const WCHAR *format, CLSID *pClsid);
 };
 #endif //BRAINSBEHINDSCREENSHOT_H

includes/api/WebSocketClient.h

@@ -8,6 +8,9 @@
 #include "../../includes/api/WebSocketConnection.h"
 #include <string>
 
+constexpr int MATRIX_WIDTH = 128;
+constexpr int MATRIX_HEIGHT = 64;
+
 class WebSocketClient {
 public:
     WebSocketClient(const std::string &address, const std::string &port, const std::string &path);
@@ -18,7 +21,9 @@ class WebSocketClient {
 
     void reset() const;
 
-    static void startStream();
+    static void takeScreenShot();
+
+    void startStream();
 
     void run();
 

includes/enums/Commands.h

@@ -11,6 +11,7 @@ enum Commands {
     EXIT,
     ALL,
     RESET,
+    TAKE,
     STREAM,
     HELP,
     UNKNOWN
@@ -26,6 +27,9 @@ inline Commands stringToCommand(const std::string &commandStr) {
     if (commandStr == "reset") {
         return RESET;
     }
+    if (commandStr == "take") {
+        return TAKE;
+    }
     if (commandStr == "stream") {
         return STREAM;
     }
@@ -39,6 +43,7 @@ inline void printHelp() {
     std::cout << "Available commands:\n"
               << "  exit   - Terminate the program\n"
               << "  all    - Test all pixels\n"
+              << "  take   - Take a screenshot and save it\n"
               << "  reset  - Turn off all pixels\n"
               << "  stream - Start streaming\n"
               << "  help   - Show this help message\n";

main.cpp

@@ -3,14 +3,8 @@
 //
 
 #include "includes/api/WebSocketClient.h"
-#include "includes/BrainsBehindScreenshot.h"
 
 int main() {
-    // fingers crossed lol
-    ScreenCapture screencapture = ScreenCapture();
-    auto bmp = screencapture.CaptureScreenBitmap();
-
-
     WebSocketClient client("localhost", "8080", "/publisher/matrixMarco");
     client.run();
     return 0;

src/BitmapConverter.cpp

@@ -0,0 +1,88 @@
+//
+// Created by marco on 16/11/2024.
+//
+
+#include "../includes/BitmapConverter.h"
+#include <iostream>
+#include <sstream>
+
+std::vector<BYTE> BitmapConverter::HBitmapToRGB(HBITMAP hBitmap, int width, int height) {
+    BITMAP bmp;
+    GetObject(hBitmap, sizeof(BITMAP), &bmp);
+
+    BITMAPINFOHEADER bi;
+    bi.biSize = sizeof(BITMAPINFOHEADER);
+    bi.biWidth = width;
+    bi.biHeight = -height; // Negative height to avoid flipping
+    bi.biPlanes = 1;
+    bi.biBitCount = 24; // Use 24-bit RGB
+    bi.biCompression = BI_RGB;
+
+    std::vector<BYTE> pixels(width * height * 3);
+    HDC hdc = GetDC(nullptr);
+    GetDIBits(hdc, hBitmap, 0, height, pixels.data(), reinterpret_cast<BITMAPINFO *>(&bi), DIB_RGB_COLORS);
+    ReleaseDC(nullptr, hdc);
+
+    return pixels;
+}
+
+std::vector<BYTE> BitmapConverter::ResizeImage(const std::vector<BYTE> &pixels, const int originalWidth,
+                                               const int originalHeight, const int newWidth, const int newHeight) {
+    std::vector<BYTE> resized(newWidth * newHeight * 3);
+
+    for (int y = 0; y < newHeight; ++y) {
+        for (int x = 0; x < newWidth; ++x) {
+            int nearestX = static_cast<int>(x * (originalWidth / static_cast<float>(newWidth)));
+            int nearestY = static_cast<int>(y * (originalHeight / static_cast<float>(newHeight)));
+
+            int originalIdx = (nearestY * originalWidth + nearestX) * 3;
+            int resizedIdx = (y * newWidth + x) * 3;
+
+            resized[resizedIdx] = pixels[originalIdx];
+            resized[resizedIdx + 1] = pixels[originalIdx + 1];
+            resized[resizedIdx + 2] = pixels[originalIdx + 2];
+        }
+    }
+
+    return resized;
+}
+
+std::vector<int> BitmapConverter::CategorizePixels(const std::vector<BYTE> &pixels, int width, int height) {
+    std::vector<int> categorizedPixels(width * height);
+
+    for (int y = 0; y < height; ++y) {
+        for (int x = 0; x < width; ++x) {
+            int idx = (y * width + x) * 3;
+            BYTE blue = pixels[idx];
+            BYTE green = pixels[idx + 1];
+            BYTE red = pixels[idx + 2];
+
+            // convert to grayscale using the luminance formula
+            BYTE gray = static_cast<BYTE>(0.299 * red + 0.587 * green + 0.114 * blue);
+
+            // categorize based on grayscale value
+            int category;
+            if (gray < 63.75) {
+                category = 0; // Off
+            } else if (gray < 127.5) {
+                category = 1; // Red
+            } else if (gray < 191.25) {
+                category = 3; // Green
+            } else {
+                category = 2; // Orange
+            }
+
+            categorizedPixels[y * width + x] = category;
+        }
+    }
+
+    return categorizedPixels;
+}
+
+std::string BitmapConverter::PixelsToString(const std::vector<int>& pixels) {
+    std::ostringstream oss;
+    for (const int value : pixels) {
+        oss << value;
+    }
+    return oss.str();
+}

src/BrainsBehindScreenshot.cpp

@@ -24,43 +24,32 @@ void ScreenCapture::ShutdownGDIPlus() const {
     GdiplusShutdown(gdiplusToken);
 }
 
-BITMAP ScreenCapture::CaptureScreenBitmap() {
+HBITMAP ScreenCapture::CaptureScreenBitmap(int& width, int& height) {
     // Get screen dimensions
     HDC screenDC = GetDC(nullptr);  // Get the device context of the screen
     HDC memoryDC = CreateCompatibleDC(screenDC);
 
-    int screenWidth = GetSystemMetrics(SM_CXSCREEN);
-    int screenHeight = GetSystemMetrics(SM_CYSCREEN);
+    width = GetSystemMetrics(SM_CXSCREEN);
+    height = GetSystemMetrics(SM_CYSCREEN);
 
     // Create a compatible bitmap
-    HBITMAP hBitmap = CreateCompatibleBitmap(screenDC, screenWidth, screenHeight);
+    HBITMAP hBitmap = CreateCompatibleBitmap(screenDC, width, height);
 
     if (!hBitmap) {
         std::wcerr << L"Failed to create compatible bitmap." << std::endl;
         DeleteDC(memoryDC);
         ReleaseDC(nullptr, screenDC);
-
-        BITMAP emptyBitmap = {0};
-        return emptyBitmap;
+        return nullptr;
     }
 
-    // Select the bitmap into the memory DC
-    auto oldBitmap = (HBITMAP)SelectObject(memoryDC, hBitmap);
-
-    // Copy screen content to the bitmap
-    BitBlt(memoryDC, 0, 0, screenWidth, screenHeight, screenDC, 0, 0, SRCCOPY);
-
-    //Convert HBITMAP to BITMAP
-    BITMAP bmp;
-    GetObject(hBitmap, sizeof(bmp), &bmp);
-
-    // Clean up
+    auto oldBitmap = static_cast<HBITMAP>(SelectObject(memoryDC, hBitmap));
+    BitBlt(memoryDC, 0, 0, width, height, screenDC, 0, 0, SRCCOPY);
     SelectObject(memoryDC, oldBitmap);
-    DeleteObject(hBitmap);
+
     DeleteDC(memoryDC);
     ReleaseDC(nullptr, screenDC);
 
-    return bmp;
+    return hBitmap;
 }
 
 bool ScreenCapture::CaptureScreen(const std::wstring& filename) {

src/api/WebSocketClient.cpp

@@ -4,6 +4,7 @@
 
 #include <iostream>
 #include <sstream>
+#include "../../includes/BitmapConverter.h"
 #include "../../includes/api/WebSocketClient.h"
 #include "../../includes/enums/Commands.h"
 #include "../../includes/BrainsBehindScreenshot.h"
@@ -25,18 +26,36 @@ void WebSocketClient::reset() const {
     connection.sendMessage(R"({"type":"clear"})");
 }
 
-void WebSocketClient::startStream() {
-    ScreenCapture screenCapture;
-
+void WebSocketClient::takeScreenShot() {
     std::wstring filename = L"screenshot.bmp";
 
-    if (screenCapture.CaptureScreen(filename)) {
+    if (ScreenCapture::CaptureScreen(filename)) {
         std::wcout << L"Screenshot saved to " << filename << std::endl;
     } else {
         std::wcerr << L"Failed to capture the screen." << std::endl;
     }
 }
 
+void WebSocketClient::startStream() {
+    int width, height;
+
+    HBITMAP hBitmap = ScreenCapture::CaptureScreenBitmap(width, height);
+    if (hBitmap == nullptr) {
+        std::cerr << "Screen capture failed." << std::endl;
+        return;
+    }
+
+    const auto pixels = BitmapConverter::HBitmapToRGB(hBitmap, width, height);
+    const auto resizedPixels = BitmapConverter::ResizeImage(pixels, width, height, MATRIX_WIDTH, MATRIX_HEIGHT);
+    const auto categorizedPixels = BitmapConverter::CategorizePixels(resizedPixels, MATRIX_WIDTH, MATRIX_HEIGHT);
+
+    const std::string pixelString = BitmapConverter::PixelsToString(categorizedPixels);
+
+    connection.sendMessage(R"({"type":"allpixels","data":")" + pixelString + R"("})");
+
+    DeleteObject(hBitmap);
+}
+
 void WebSocketClient::run() {
     WSADATA wsaData;
     if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {

src/api/WebSocketConnection.cpp

@@ -143,6 +143,7 @@ void WebSocketConnection::sendMessage(const std::string &message) const {
     send(sock, reinterpret_cast<const char *>(frame.data()), frame.size(), 0);
 }
 
+// TODO: check/rework that because it throws an error if the message is too long
 std::string WebSocketConnection::receiveMessage() const {
     char buffer[BUFFER_SIZE];
     int bytes_received = recv(sock, buffer, BUFFER_SIZE, 0);