RGBMatrixEmulator 0.12.0__py2.py3-none-any.whl

RGBMatrixEmulator/emulation/options.py

@@ -0,0 +1,213 @@
+import json, os, pprint, sys
+
+from RGBMatrixEmulator.adapters import ADAPTER_TYPES
+from RGBMatrixEmulator.logger import Logger
+
+
+class RGBMatrixOptions:
+    def __init__(self):
+        self.hardware_mapping = "EMULATED"
+        self.rows = 32
+        self.cols = 32
+        self.chain_length = 1
+        self.parallel = 1
+        self.row_address_type = 0
+        self.multiplexing = 0
+        self.pwm_bits = 0
+        self.brightness = 100
+        self.pwm_lsb_nanoseconds = 130
+        self.led_rgb_sequence = "RGB-EMULATED"
+        self.show_refresh_rate = 0
+        self.gpio_slowdown = None
+        self.disable_hardware_pulsing = False
+
+        emulator_config = RGBMatrixEmulatorConfig()
+
+        if emulator_config.display_adapter.lower() in ADAPTER_TYPES:
+            self.display_adapter = ADAPTER_TYPES[
+                emulator_config.display_adapter.lower()
+            ]
+        elif len(ADAPTER_TYPES.keys()) > 0:
+            adapter_types = ", ".join(
+                '"{}"'.format(key) for key in ADAPTER_TYPES.keys()
+            )
+
+            # Try to set it to the emulator default, but if it failed to load, pick the first one that did.
+            if emulator_config.DEFAULT_CONFIG.get("display_adapter") in ADAPTER_TYPES:
+                default_adapter = emulator_config.DEFAULT_CONFIG.get("display_adapter")
+            else:
+                default_adapter = list(ADAPTER_TYPES.keys())[0]
+
+            Logger.warning(
+                '"{}" display adapter option not recognized. Valid adapters are {}. Defaulting to "{}"...'.format(
+                    emulator_config.display_adapter, adapter_types, default_adapter
+                )
+            )
+            self.display_adapter = ADAPTER_TYPES[default_adapter]
+        else:
+            Logger.critical(
+                "Failed to find a valid display adapter to load! Check that you have installed dependencies required for your configured adapter."
+            )
+
+            sys.exit(1)
+
+        self.pixel_style = emulator_config.DEFAULT_CONFIG.get("pixel_style")
+        config_pixel_style = emulator_config.pixel_style.lower()
+
+        if config_pixel_style in emulator_config.VALID_PIXEL_STYLES:
+            if config_pixel_style != self.pixel_style:
+                if self.display_adapter.SUPPORTS_ALTERNATE_PIXEL_STYLE:
+                    self.pixel_style = emulator_config.pixel_style
+                else:
+                    Logger.warning(
+                        '"{}" pixel style option is not supported by adapter "{}". Defaulting to "square"...'.format(
+                            config_pixel_style, emulator_config.display_adapter.lower()
+                        )
+                    )
+        else:
+            Logger.warning(
+                '"{}" pixel style option not recognized. Valid options are "square", "circle". Defaulting to "square"...'.format(
+                    config_pixel_style
+                )
+            )
+
+        self.pixel_size = emulator_config.pixel_size
+        self.pixel_outline = emulator_config.DEFAULT_CONFIG["pixel_outline"]
+        self.pixel_outline = emulator_config.pixel_outline
+        self.browser = emulator_config.browser
+
+        if emulator_config.suppress_font_warnings:
+            import bdfparser
+
+            bdfparser.warnings.simplefilter("ignore")
+
+    def window_size(self):
+        return (
+            self.cols * self.pixel_size * self.chain_length,
+            self.rows * self.pixel_size * self.parallel,
+        )
+
+    def window_size_str(self, pixel_text=""):
+        width, height = self.window_size()
+
+        return f"{width} x {height} {pixel_text}"
+
+
+class RGBMatrixEmulatorConfig:
+    __CONFIG_PATH = "emulator_config.json"
+
+    VALID_PIXEL_STYLES = ["square", "circle"]
+    DEFAULT_CONFIG = {
+        "pixel_outline": 0,
+        "pixel_size": 16,
+        "pixel_style": "square",
+        "display_adapter": "browser",
+        "suppress_font_warnings": False,
+        "suppress_adapter_load_errors": False,
+        "browser": {
+            "_comment": "For use with the browser adapter only.",
+            "port": 8888,
+            "target_fps": 24,
+            "fps_display": False,
+            "quality": 70,
+            "image_border": True,
+            "debug_text": False,
+            "image_format": "JPEG",
+        },
+        "log_level": "info",
+    }
+
+    def __init__(self):
+        self.config = self.__load_config()
+        self.default_config = self.DEFAULT_CONFIG
+
+        RGBMatrixEmulatorConfig.Utils.set_attributes(self)
+
+    def __load_config(self):
+        if os.path.exists(self.__CONFIG_PATH):
+            with open(self.__CONFIG_PATH) as f:
+                config = json.load(f)
+
+            return config
+
+        with open(self.__CONFIG_PATH, "w") as f:
+            json.dump(self.DEFAULT_CONFIG, f, indent=4)
+
+        return self.DEFAULT_CONFIG
+
+    def __str__(self):
+        return RGBMatrixEmulatorConfig.Utils.to_str(self)
+
+    class ChildConfig:
+        def __init__(self, config, default_config):
+            self.config = config
+            self.default_config = default_config
+
+            RGBMatrixEmulatorConfig.Utils.set_attributes(self)
+
+        def __str__(self):
+            return RGBMatrixEmulatorConfig.Utils.to_str(self)
+
+    class Utils:
+        def to_str(obj):
+            """
+            Pretty prints the config object from dict.
+            """
+            printer = pprint.PrettyPrinter(sort_dicts=False)
+            return "\n".join(
+                [
+                    obj.__repr__(),
+                    printer.pformat(RGBMatrixEmulatorConfig.Utils.to_dict(obj)),
+                ]
+            )
+
+        def to_dict(obj):
+            """
+            Recursively recreates the config dict from child config objects.
+            """
+            config = {}
+            for key in obj.__dict__.keys():
+                if key in ["config", "default_config"] or key[0] == "_":
+                    continue
+
+                value = obj.__dict__.get(key)
+
+                if isinstance(value, RGBMatrixEmulatorConfig.ChildConfig):
+                    value = RGBMatrixEmulatorConfig.Utils.to_dict(value)
+
+                config[key] = value
+
+            return config
+
+        def set_attributes(obj):
+            """
+            Dynamically set attributes loaded into config and default config variables.
+
+            Numbers, strings, and arrays are stored natively. Nested dicts are parsed into RGBMatrixEmulatorChildConfig objects recursively.
+            """
+            for key in obj.default_config.keys():
+                if key in obj.config:
+                    value = obj.config.get(key)
+                    default = obj.default_config.get(key)
+                else:
+                    value = obj.default_config.get(key)
+                    default = value
+
+                    Logger.warning(
+                        "Emulator config is missing key '{}', falling back to default '{}'. Consider adding this to your emulator config file.".format(
+                            key, value
+                        )
+                    )
+
+                RGBMatrixEmulatorConfig.Utils.set_attribute(obj, key, value, default)
+
+        def set_attribute(obj, key, value, default):
+            """
+            Store the value as an attribute or delegate to the RGBMatrixEmulatorChildConfig to parse into a new node.
+            """
+            if isinstance(value, dict):
+                obj.__setattr__(
+                    key, RGBMatrixEmulatorConfig.ChildConfig(value, default)
+                )
+            else:
+                obj.__setattr__(key, value)

RGBMatrixEmulator/graphics/__init__.py

@@ -0,0 +1,169 @@
+from RGBMatrixEmulator.graphics.color import Color
+from RGBMatrixEmulator.graphics.font import Font
+
+
+def DrawText(canvas, font, x, y, color, text):
+    # Early return for empty string prevents bugs in bdfparser library
+    # and makes good sense anyway
+    if len(text) == 0:
+        return
+
+    # Support multiple spacings based on device width
+    character_widths = [__actual_width(font, letter) for letter in text]
+    first_char_width = character_widths[0]
+    max_char_width = max(character_widths)
+    total_width = sum(character_widths)
+
+    # Offscreen to the left, adjust by first character width
+    if x < 0:
+        adjustment = abs(x + first_char_width) // first_char_width
+        text = text[adjustment:]
+        if adjustment:
+            x += first_char_width * adjustment
+
+    # Offscreen to the right, rough adjustment by max width
+    if (total_width + x) > canvas.width:
+        text = text[: ((canvas.width + 1) // max_char_width) + 2]
+
+    # Draw the text!
+    if len(text) != 0:
+        # Ensure text doesn't get drawn as multiple lines
+        linelimit = len(text) * (font.headers["fbbx"] + 1)
+
+        text_map = font.bdf_font.draw(
+            text, linelimit, missing=font.default_character
+        ).todata(2)
+        font_y_offset = -(font.headers["fbby"] + font.headers["fbbyoff"])
+
+        for y2, row in enumerate(text_map):
+            for x2, value in enumerate(row):
+                if value == 1:
+                    if isinstance(color, tuple):
+                        canvas.SetPixel(x + x2, y + y2 + font_y_offset, *color)
+                    else:
+                        canvas.SetPixel(
+                            x + x2,
+                            y + y2 + font_y_offset,
+                            color.red,
+                            color.green,
+                            color.blue,
+                        )
+
+    return total_width
+
+
+def DrawLine(canvas, x1, y1, x2, y2, color):
+    int_points = __coerce_int(x1, y1, x2, y2)
+    rows, cols = __line(*int_points)
+
+    for point in zip(rows, cols):
+        if isinstance(color, tuple):
+            canvas.SetPixel(*point, *color)
+        else:
+            canvas.SetPixel(*point, color.red, color.green, color.blue)
+
+
+def DrawCircle(canvas, x, y, r, color):
+    int_points = __coerce_int(x, y)
+    rows, cols = __circle_perimeter(*int_points, r)
+
+    for point in zip(rows, cols):
+        if isinstance(color, tuple):
+            canvas.SetPixel(*point, *color)
+        else:
+            canvas.SetPixel(*point, color.red, color.green, color.blue)
+
+
+def __actual_width(font, letter):
+    """
+    Returns the actual width of the letter in the font. If the font doesn't contain a glyph for this letter, it falls back to
+    the width of the default character (?) to prevent division by 0.
+    """
+    width = font.CharacterWidth(ord(letter))
+
+    if width > 0:
+        return width
+
+    return font.CharacterWidth(font.default_character.cp())
+
+
+def __coerce_int(*values):
+    return [int(value) for value in values]
+
+
+def __line(x1, y1, x2, y2):
+    """
+    Line drawing algorithm
+
+    Extracted from scikit-image:
+    https://github.com/scikit-image/scikit-image/blob/00177e14097237ef20ed3141ed454bc81b308f82/skimage/draw/_draw.pyx#L44
+    """
+    steep = 0
+    r = x1
+    c = y1
+    dr = abs(x2 - x1)
+    dc = abs(y2 - y1)
+
+    rr = [0] * (max(dc, dr) + 1)
+    cc = [0] * (max(dc, dr) + 1)
+
+    if (y2 - c) > 0:
+        sc = 1
+    else:
+        sc = -1
+    if (x2 - r) > 0:
+        sr = 1
+    else:
+        sr = -1
+    if dr > dc:
+        steep = 1
+        c, r = r, c
+        dc, dr = dr, dc
+        sc, sr = sr, sc
+    d = (2 * dr) - dc
+
+    for i in range(dc):
+        if steep:
+            rr[i] = c
+            cc[i] = r
+        else:
+            rr[i] = r
+            cc[i] = c
+        while d >= 0:
+            r = r + sr
+            d = d - (2 * dc)
+        c = c + sc
+        d = d + (2 * dr)
+
+    rr[dc] = x2
+    cc[dc] = y2
+
+    return (rr, cc)
+
+
+def __circle_perimeter(x, y, radius):
+    """
+    Bresenham circle algorithm
+
+    Extracted from scikit-image
+    https://github.com/scikit-image/scikit-image/blob/00177e14097237ef20ed3141ed454bc81b308f82/skimage/draw/_draw.pyx#L248
+    """
+    rr = list()
+    cc = list()
+
+    c = 0
+    r = radius
+    d = 3 - 2 * radius
+
+    while r >= c:
+        rr.extend([_ + x for _ in [r, -r, r, -r, c, -c, c, -c]])
+        cc.extend([_ + y for _ in [c, c, -c, -c, r, r, -r, -r]])
+
+        if d < 0:
+            d += 4 * c + 6
+        else:
+            d += 4 * (c - r) + 10
+            r -= 1
+        c += 1
+
+    return (rr, cc)

RGBMatrixEmulator/graphics/color.py

@@ -0,0 +1,32 @@
+class Color:
+    def __init__(self, r=0, g=0, b=0):
+        self.red = r
+        self.green = g
+        self.blue = b
+
+    @classmethod
+    def adjust_brightness(cls, pixel, alpha, to_int=False):
+        if to_int:
+            return tuple(int(channel) for channel in pixel)
+
+        return tuple(channel * alpha for channel in pixel)
+
+    @classmethod
+    def to_hex(cls, pixel):
+        return "#%02x%02x%02x" % pixel
+
+    @classmethod
+    def BLACK(cls):
+        return (0, 0, 0)
+
+    @classmethod
+    def RED(cls):
+        return (255, 0, 0)
+
+    @classmethod
+    def GREEN(cls):
+        return (0, 255, 0)
+
+    @classmethod
+    def BLUE(cls):
+        return (0, 0, 255)

RGBMatrixEmulator/graphics/font.py

@@ -0,0 +1,36 @@
+import bdfparser
+
+
+class Font:
+    def __init__(self):
+        self.bdf_font = None
+        self.headers = {}
+        self.spacing = {}
+
+    def LoadFont(self, path):
+        self.bdf_font = bdfparser.Font(path)
+        self.headers = self.bdf_font.headers
+        self.props = self.bdf_font.props
+
+        # All rpi-rgb-led-matrix fonts have a character at 0xFFFD to represent a missing character
+        # Cache this for use later so we don't have to constantly look it up
+        self.default_character = self.bdf_font.glyphbycp(0xFFFD)
+
+    def CharacterWidth(self, char):
+        # Missing glyphs return 0 width in rpi-rgb-led-matrix
+        if self.bdf_font == None or not self.bdf_font.glyphbycp(char):
+            return 0
+
+        return self.bdf_font.glyphbycp(char).meta["dwx0"]
+
+    @property
+    def height(self):
+        if self.bdf_font is None:
+            return -1
+        return self.headers["fbby"]
+
+    @property
+    def baseline(self):
+        if self.bdf_font is None:
+            return 0
+        return self.headers["fbby"] + self.headers["fbbyoff"]

RGBMatrixEmulator/logger.py

@@ -0,0 +1,28 @@
+import json, logging
+
+# Try to load the config from file. (Default: INFO)
+try:
+    with open("emulator_config.json") as config_file:
+        log_level_name = json.load(config_file).get("log_level", "INFO").upper()
+        log_level = getattr(logging, log_level_name)
+except:
+    log_level = logging.INFO
+
+# Create a Logger
+Logger = logging.getLogger("RGBME")
+Logger.setLevel(log_level)
+
+# Create console handler and set the log level
+ch = logging.StreamHandler()
+ch.setLevel(log_level)
+
+# Create formatter
+formatter = logging.Formatter(
+    "[%(asctime)s] [%(name)s] [%(levelname)s]: %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
+)
+
+# Add formatter to console handler
+ch.setFormatter(formatter)
+
+# Add console handler to Logger
+Logger.addHandler(ch)

RGBMatrixEmulator/version.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+
+# package version
+__version__ = "0.12.0"
+"""Installed version of RGBMatrixEmulator."""

rgbmatrixemulator-0.12.0.data/data/RGBMatrixEmulator/client.js

@@ -0,0 +1,91 @@
+function init() {
+    const WS_RETRY_DELAY = 2000;
+    const FPS_DEFAULT    = 24;
+
+    let img       = document.getElementById("liveImg");
+    let fpsText   = document.getElementById("fps");
+    let fpsTarget = parseInt(document.getElementById("targetFps").value) || FPS_DEFAULT;
+
+    let requestStartTime = performance.now();
+    let startTime = performance.now();
+    let time = 0;
+    let requestTime = 0;
+    let timeSmoothing = 0.9;           // larger=more smoothing
+    let requestTimeSmoothing = 0.2;    // larger=more smoothing
+    let targetTime = 1000 / fpsTarget;
+
+    let socket = generateSocket();
+
+    function requestImage() {
+        requestStartTime = performance.now();
+        socket.send('more');
+    }
+
+    function generateSocket() {
+        let path = location.pathname;
+
+        if (path.endsWith("index.html")) {
+            path = path.substring(0, path.length - "index.html".length);
+        }
+
+        if(!path.endsWith("/")) {
+            path = path + "/";
+        }
+
+        let wsProtocol = (location.protocol === "https:") ? "wss://" : "ws://";
+        let ws = new WebSocket(wsProtocol + location.host + path + "websocket");
+
+        ws.binaryType = 'arraybuffer';
+
+        ws.onopen = function() {
+            console.log("RGBME WebSocket connection established!");
+            startTime = performance.now();
+            requestImage();
+        };
+
+        ws.onclose = function() {
+            // Handle retries by recreating the connection to websocket.
+            console.warn(`RGBME WebSocket connection lost. Retrying in ${WS_RETRY_DELAY / 1000}s.`)
+            setTimeout(function() {
+                // We generate socket with a timeout to make sure server has time to recover.
+                socket = generateSocket();
+            }, WS_RETRY_DELAY);
+        }
+
+        ws.onerror = function() {
+            ws.close();
+        }
+
+        ws.onmessage = function(evt) {
+            let arrayBuffer = evt.data;
+            let blob  = new Blob([new Uint8Array(arrayBuffer)], {type: "image/jpeg"});
+            let old_img = img.src.slice()
+            img.src   = window.URL.createObjectURL(blob);
+            window.URL.revokeObjectURL(old_img);
+
+            let endTime = performance.now();
+            let currentTime = endTime - startTime;
+            // smooth with moving average
+            time = (time * timeSmoothing) + (currentTime * (1.0 - timeSmoothing));
+            startTime = endTime;
+            let fps = Math.round(1000 / time);
+
+            if (fpsText) {
+                fpsText.textContent = fps;
+            }
+
+            let currentRequestTime = performance.now() - requestStartTime;
+            // smooth with moving average
+            requestTime = (requestTime * requestTimeSmoothing) + (currentRequestTime * (1.0 - requestTimeSmoothing));
+            let timeout = Math.max(0, targetTime - requestTime);
+
+            setTimeout(requestImage, timeout);
+        };
+
+        return ws;
+    }
+
+    console.log(`TARGET FPS: ${fpsTarget}`);
+};
+
+init();