Initial commit

Author: amrishparmar

config.py

@@ -0,0 +1,22 @@
+class AppConfig:
+    """Configuration information for the application"""
+
+    TITLE = 'DesktopVisualiser'
+    DESCRIPTION = 'An application for visualising the user desktop'
+    AUTHOR_NAME = 'Amrish Parmar'
+    AUTHOR_CONTACT = 'aparm_dev@outlook.com'
+    DEVICE_SUPPORTED = ['keyboard']
+    CATEGORY = 'application'
+
+    def to_dict(self):
+        """Return a dictionary representation of the JSON required by the Razer SDK"""
+        return {
+            'title': self.TITLE,
+            'description': self.DESCRIPTION,
+            'author': {
+                'name': self.AUTHOR_NAME,
+                'contact': self.AUTHOR_CONTACT,
+            },
+            'device_supported': self.DEVICE_SUPPORTED,
+            'category': 'application',
+        }

image_process.py

@@ -0,0 +1,51 @@
+from PIL import ImageGrab
+from ctypes import windll
+
+
+# enable DPI-aware behaviour for Pillow functions
+user32 = windll.user32
+user32.SetProcessDPIAware()
+
+
+class ImageProcessor:
+    """A collection of functions for turning images into Razer SDK keyboard-friendly representations"""
+
+    @staticmethod
+    def _get_resized_screen_pixels(columns=22, rows=6):
+        """Grab a screenshot and resize to keyboard-friendly dimensions
+
+        :param columns: An integer, the number of columns on the keyboard
+        :param rows: An integer, the number of rows on the keyboard
+        :return: An Image object, the resized image
+        """
+        img = ImageGrab.grab()
+        img = img.resize((columns, rows))
+        return img
+
+    @staticmethod
+    def get_keyboard_pixels():
+        """Take a screenshot of the display, resize it and convert to a 6 x 22 list of BGR integers
+
+        :return: A 6 x 22 list of lists of BGR integers
+        """
+        img = ImageProcessor._get_resized_screen_pixels()
+
+        pixel_list = []
+
+        for r in range(img.height):
+            row = []
+            for c in range(img.width):
+                p = ImageProcessor._rgb_to_bgr_int(img.getpixel((c, r)))
+                row.append(p)
+            pixel_list.append(row)
+
+        return pixel_list
+
+    @staticmethod
+    def _rgb_to_bgr_int(rgb):
+        """Convert an rgb tuple into a corresponding BGR integer
+
+        :param rgb: A tuple in the format (R, G, B) where R, G, B are 0 - 255
+        :return: An integer, a BGR integer representation
+        """
+        return rgb[0] * pow(2, 0) + rgb[1] * pow(2, 8) + rgb[2] * pow(2, 16)

sdk_connection.py

@@ -0,0 +1,50 @@
+import logging
+from threading import Thread
+from time import sleep
+import requests
+
+
+class RazerApp:
+    """Handle connections to the SDK server"""
+
+    def __init__(self, payload):
+        r = requests.post("http://localhost:54235/razer/chromasdk", json=payload)
+        self.uri = r.json()['uri']  # assign the uri from the SDK server response
+        self.alive = True
+        self._start_heartbeat()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.disconnect()
+
+    def disconnect(self):
+        """End connection to the SDK server"""
+        logging.getLogger('Terminating connection to SDK server')
+        self.alive = False
+        self._hb_thread.join()
+        requests.delete(self.uri)
+
+    def _heartbeat(self):
+        """Send a heartbeat to the SDK every second"""
+        while self.alive:
+            requests.put(self.uri + '/heartbeat')
+            sleep(1)
+
+    def _start_heartbeat(self):
+        """Start the heartbeat thread to keep the SDK server connection alive"""
+        self._hb_thread = Thread(target=self._heartbeat)
+        self._hb_thread.start()
+
+    def set_colour(self, values):
+        """Update the colours on the keyboard with new values
+
+        :param values: A 6 x 22 list of lists of BGR integers
+        """
+        payload = {
+            'effect': 'CHROMA_CUSTOM',
+            'param': values,
+        }
+
+        requests.put(self.uri + '/keyboard', json=payload)

visualiser.py

@@ -0,0 +1,41 @@
+import logging
+import signal
+import sys
+from config import AppConfig
+from sdk_connection import RazerApp
+from image_process import ImageProcessor
+
+
+# set up the logger
+logger = logging.getLogger(__name__)
+logging.basicConfig(format='%(asctime)s %(levelname)-8s %(message)s', level=logging.INFO)
+
+
+def quit_program(sig, frame):
+    """Callback for when program is quit"""
+    logger.warning('Quitting program')
+    sys.exit()
+
+
+def main():
+    """Main function"""
+    signal.signal(signal.SIGINT, quit_program)
+
+    logging.info('Initialising connection to SDK server')
+    config = AppConfig()
+    with RazerApp(config.to_dict()) as app:
+        logging.info('Connected to the the SDK server')
+        logging.info('Beginning screen capture (Press Ctrl-C to quit)')
+
+        while True:
+            try:
+                pixels = ImageProcessor.get_keyboard_pixels()
+            except OSError as ose:
+                logger.error(f'Error grabbing screenshot: {ose.strerror}')
+                continue
+
+            app.set_colour(pixels)
+
+
+if __name__ == '__main__':
+    main()