RGBMatrixEmulator 0.11.4__py2.py3-none-any.whl

RGBMatrixEmulator/emulators/options.py

@@ -0,0 +1,188 @@
+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,155 @@
+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,36 @@
+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):
+        p = tuple(channel * alpha for channel in pixel)
+
+        if to_int:
+            p = tuple(int(channel) for channel in pixel)
+
+        return p
+
+    @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,34 @@
+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,29 @@
+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.11.4'
+"""Installed version of RGBMatrixEmulator."""

rgbmatrixemulator-0.11.4.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();

rgbmatrixemulator-0.11.4.data/data/RGBMatrixEmulator/index.html

@@ -0,0 +1,144 @@
+<html>
+   <head>
+      <title>{{ adapter.emulator_details_text() }}</title>
+      <link rel="shortcut icon" href="assets/icon.ico">
+      <link rel="stylesheet" href="assets/styles.css">
+   </head>
+   <body>
+      <img id="liveImg" class={{ "" if adapter.options.browser.image_border else "no-border" }} />
+
+      {% if adapter.options.browser.fps_display %}
+         <div id="fpsDisplay">
+            Frames per second: <span id="fps">0</span>
+         </div>
+      {% end %}
+
+      {% if adapter.options.browser.debug_text %}
+         <div id="emulatorDetails">
+            <h2>{{ adapter.emulator_details_text() }}</h2>
+            
+            <div class="emulatorDetailsTableRow">
+               <div id="matrixDetails" class="tableContainer">
+                  <h3>Matrix Details:</h3>
+
+                  <table>
+                     <tbody>
+                        <tr>
+                           <td>
+                              Matrix Width:
+                           </td>
+                           <td>
+                              {{ adapter.options.cols }}
+                           </td>
+                        </tr>
+                        <tr>
+                           <td>
+                              Matrix Height:
+                           </td>
+                           <td>
+                              {{ adapter.options.rows }}
+                           </td>
+                        </td>
+                        </tr>
+                        <tr>
+                           <td>
+                              Image Size:
+                           </td>
+                           <td>
+                              {{ adapter.options.window_size_str(pixel_text="px") }}
+                           </td>
+                        </tr>
+                        <tr>
+                           <td>
+                              Chain Length:
+                           </td>
+                           <td>
+                              {{ adapter.options.chain_length }}
+                           </td>
+                        </tr>
+                        <tr>
+                           <td>
+                              Parallel Chains:
+                           </td>
+                           <td>
+                              {{ adapter.options.parallel }}
+                           </td>
+                        </tr>
+                        <tr>
+                           <td>
+                              Pixel Size:
+                           </td>
+                           <td>
+                              {{ adapter.options.pixel_size }}
+                           </td>
+                        </tr>
+                        <tr>
+                           <td>
+                              Pixel Style:
+                           </td>
+                           <td>
+                              {{ adapter.options.pixel_style }}
+                           </td>
+                        </tr>
+                        <tr>
+                           <td>
+                              Adapter:
+                           </td>
+                           <td>
+                              {{ adapter.__class__.__name__ }}
+                           </td>
+                        </tr>
+                     </tbody>
+                  </table>
+               </div>
+
+               <div id="browserDetails" class="tableContainer">
+                  <h3>Browser Details:</h3>
+
+                  <table>
+                     <tbody>
+                        <tr>
+                           <td>
+                              Port:
+                           </td>
+                           <td>
+                              {{ adapter.options.browser.port }}
+                           </td>
+                        </tr>
+                        <tr>
+                           <td>
+                              Target FPS:
+                           </td>
+                           <td>
+                              {{ adapter.options.browser.target_fps }}
+                           </td>
+                        </td>
+                        </tr>
+                        <tr>
+                           <td>
+                              FPS Display Enabled:
+                           </td>
+                           <td>
+                              {{ adapter.options.browser.fps_display }}
+                           </td>
+                        </tr>
+                        <tr>
+                           <td>
+                              Image Quality:
+                           </td>
+                           <td>
+                              {{ adapter.options.browser.quality }}
+                           </td>
+                        </tr>
+                     </tbody>
+                  </table>
+               </div>
+            </div>
+         </div>
+      {% end %}
+
+      <input id="targetFps" type="hidden" value={{ adapter.options.browser.target_fps }} />
+
+      <script type="text/javascript" src="assets/client.js"></script>
+   </body>
+</html>