PyPI - RGBMatrixEmulator - Versions diffs - 0.12.0__py2.py3-none-any.whl - Mend

RGBMatrixEmulator 0.12.0__py2.py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (42) hide show

RGBMatrixEmulator/__init__.py +5 -0
RGBMatrixEmulator/adapters/__init__.py +72 -0
RGBMatrixEmulator/adapters/base.py +109 -0
RGBMatrixEmulator/adapters/browser_adapter/README.md +89 -0
RGBMatrixEmulator/adapters/browser_adapter/__init__.py +0 -0
RGBMatrixEmulator/adapters/browser_adapter/adapter.py +51 -0
RGBMatrixEmulator/adapters/browser_adapter/request_handlers/__init__.py +7 -0
RGBMatrixEmulator/adapters/browser_adapter/request_handlers/image.py +12 -0
RGBMatrixEmulator/adapters/browser_adapter/request_handlers/image_web_socket.py +34 -0
RGBMatrixEmulator/adapters/browser_adapter/request_handlers/main.py +9 -0
RGBMatrixEmulator/adapters/browser_adapter/server.py +86 -0
RGBMatrixEmulator/adapters/browser_adapter/static/assets/client.js +91 -0
RGBMatrixEmulator/adapters/browser_adapter/static/assets/icon.ico +0 -0
RGBMatrixEmulator/adapters/browser_adapter/static/assets/styles.css +25 -0
RGBMatrixEmulator/adapters/browser_adapter/static/index.html +144 -0
RGBMatrixEmulator/adapters/pygame_adapter.py +59 -0
RGBMatrixEmulator/adapters/sixel_adapter.py +90 -0
RGBMatrixEmulator/adapters/terminal_adapter.py +34 -0
RGBMatrixEmulator/adapters/tkinter_adapter.py +83 -0
RGBMatrixEmulator/adapters/turtle_adapter.py +97 -0
RGBMatrixEmulator/emulation/__init__.py +0 -0
RGBMatrixEmulator/emulation/canvas.py +71 -0
RGBMatrixEmulator/emulation/matrix.py +62 -0
RGBMatrixEmulator/emulation/options.py +213 -0
RGBMatrixEmulator/graphics/__init__.py +169 -0
RGBMatrixEmulator/graphics/color.py +32 -0
RGBMatrixEmulator/graphics/font.py +36 -0
RGBMatrixEmulator/icon.ico +0 -0
RGBMatrixEmulator/icon.png +0 -0
RGBMatrixEmulator/logger.py +28 -0
RGBMatrixEmulator/version.py +5 -0
rgbmatrixemulator-0.12.0.data/data/RGBMatrixEmulator/client.js +91 -0
rgbmatrixemulator-0.12.0.data/data/RGBMatrixEmulator/icon.ico +0 -0
rgbmatrixemulator-0.12.0.data/data/RGBMatrixEmulator/icon.png +0 -0
rgbmatrixemulator-0.12.0.data/data/RGBMatrixEmulator/index.html +144 -0
rgbmatrixemulator-0.12.0.data/data/RGBMatrixEmulator/styles.css +25 -0
rgbmatrixemulator-0.12.0.data/data/docs/LICENSE +9 -0
rgbmatrixemulator-0.12.0.data/data/docs/README.md +160 -0
rgbmatrixemulator-0.12.0.dist-info/METADATA +186 -0
rgbmatrixemulator-0.12.0.dist-info/RECORD +43 -0
rgbmatrixemulator-0.12.0.dist-info/WHEEL +5 -0
rgbmatrixemulator-0.12.0.dist-info/licenses/LICENSE +9 -0

RGBMatrixEmulator/adapters/browser_adapter/static/index.html ADDED Viewed

@@ -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>

RGBMatrixEmulator/adapters/pygame_adapter.py ADDED Viewed

@@ -0,0 +1,59 @@
+import os
+import sys
+# Try to suppress the pygame load warning if able.
+try:
+    os.environ["PYGAME_HIDE_SUPPORT_PROMPT"] = "hide"
+except Exception:
+    pass
+import pygame
+from pygame.locals import QUIT
+from RGBMatrixEmulator.adapters.base import BaseAdapter
+from RGBMatrixEmulator.logger import Logger
+class PygameAdapter(BaseAdapter):
+    SUPPORTS_ALTERNATE_PIXEL_STYLE = True
+    def __init__(self, width, height, options):
+        super().__init__(width, height, options)
+        self.__surface = None
+    def load_emulator_window(self):
+        if self.loaded:
+            return
+        Logger.info("Loading {}".format(self.emulator_details_text()))
+        self.__surface = pygame.display.set_mode(self.options.window_size())
+        pygame.init()
+        self.__set_emulator_icon()
+        pygame.display.set_caption(self.emulator_details_text())
+        self.loaded = True
+    def draw_to_screen(self, pixels):
+        image = self._get_masked_image(pixels)
+        pygame_surface = pygame.image.fromstring(
+            image.tobytes(), self.options.window_size(), "RGB"
+        )
+        self.__surface.blit(pygame_surface, (0, 0))
+        pygame.display.flip()
+    def check_for_quit_event(self):
+        # We don't have events, but this will keep the emulator from appearing as if it's not responding.
+        # This also enables closing the window to kill the emulator
+        for event in pygame.event.get():
+            if event.type == QUIT:
+                pygame.quit()
+                sys.exit()
+    def __set_emulator_icon(self):
+        emulator_path = os.path.abspath(os.path.dirname(__file__))
+        icon_path = os.path.join(emulator_path, "..", "icon.png")
+        icon = pygame.image.load(os.path.normpath(icon_path))
+        pygame.display.set_icon(icon)

RGBMatrixEmulator/adapters/sixel_adapter.py ADDED Viewed

@@ -0,0 +1,90 @@
+import os
+import platform
+import sys
+import io
+import libsixel as sixel
+from PIL import Image, ImageDraw, ImageEnhance
+from typing import List
+from RGBMatrixEmulator.adapters.base import BaseAdapter
+from RGBMatrixEmulator.graphics.color import Color
+class SixelAdapter(BaseAdapter):
+    SUPPORTS_ALTERNATE_PIXEL_STYLE = True
+    def draw_to_screen(self, pixels):
+        sixel = self.__encode_sixels(
+            pixels, scale=self.options.pixel_size, outline=self.options.pixel_outline
+        )
+        output = f"\033[H\n{sixel}\n"
+        sys.stdout.write(output)
+    def load_emulator_window(self):
+        os.system("cls||clear")
+        if platform.system() == "Windows":
+            os.system(
+                "mode con: cols={} lines={}".format(self.width * 2 + 5, self.height + 3)
+            )
+        else:
+            os.system(
+                "stty columns {} rows {}".format(self.width * 2 + 5, self.height + 3)
+            )
+    def __enlarge_pixels(
+        self, pixels: List[List[Color]], scale: int, outline: int
+    ) -> Image.Image:
+        outline_color = "#000000"
+        w, h = len(pixels[0]), len(pixels)
+        iw, ih = w * scale, h * scale
+        i = Image.new("RGBA", (iw, ih))
+        d = ImageDraw.Draw(i)
+        for y, row in enumerate(pixels):
+            for x, pixel in enumerate(row):
+                rx, ry = x * scale, y * scale
+                ex, ey = rx + (scale - 1), ry + (scale - 1)
+                if self.options.pixel_style == "circle":
+                    d.ellipse(
+                        [(rx, ry), (ex, ey)],
+                        fill=pixel,
+                        outline=outline_color,
+                        width=outline,
+                    )
+                else:
+                    d.rectangle(
+                        [(rx, ry), (ex, ey)],
+                        fill=pixel,
+                        outline=outline_color,
+                        width=outline,
+                    )
+        brightness = ImageEnhance.Brightness(i)
+        i = brightness.enhance(1.5)
+        contrast = ImageEnhance.Contrast(i)
+        i = contrast.enhance(0.8)
+        return i
+    def __encode_sixels(self, pixels: List[List[Color]], scale=4, outline=1) -> str:
+        """Encodes given Image to a sixel string."""
+        img = self.__enlarge_pixels(pixels, scale, outline)
+        img_data = img.convert("RGB").tobytes()
+        width = img.width
+        height = img.height
+        with io.BytesIO() as buf:
+            output = sixel.sixel_output_new(
+                lambda data, buffer: buffer.write(data), buf
+            )
+            dither = sixel.sixel_dither_new(256)
+            sixel.sixel_dither_initialize(
+                dither, img_data, width, height, sixel.SIXEL_PIXELFORMAT_RGB888
+            )
+            sixel.sixel_encode(img_data, width, height, 1, dither, output)
+            encoded = buf.getvalue().decode("ascii")
+            sixel.sixel_dither_unref(dither)
+            sixel.sixel_output_unref(output)
+        return encoded

RGBMatrixEmulator/adapters/terminal_adapter.py ADDED Viewed

@@ -0,0 +1,34 @@
+import os
+import sys
+from RGBMatrixEmulator.adapters.base import BaseAdapter
+class TerminalAdapter(BaseAdapter):
+    SUPPORTS_ALTERNATE_PIXEL_STYLE = True
+    SYMBOLS = {"circle": " ●", "square": "██"}
+    def __init__(self, width, height, options):
+        super().__init__(width, height, options)
+        self.__symbol = self.SYMBOLS.get(self.options.pixel_style)
+    def draw_to_screen(self, pixels):
+        output = "\033[H\n"  # Move the cursor to the home position, add a little border
+        for pixel_row in pixels:
+            output += "  "  # Add a bit of border in case cursor causes line to wrap
+            for pixel in pixel_row:
+                output += "\033[38;2;{};{};{}m".format(
+                    *pixel
+                )  # Set the cell to the pixel color
+                output += self.__symbol  # Draw the pixel
+                output += "\033[37m"  # Reset the color
+            output += " \n"
+        sys.stdout.write(output)
+    def load_emulator_window(self):
+        os.system("cls||clear")
+        os.system(
+            "mode con: cols={} lines={}".format(self.width * 2 + 5, self.height + 3)
+        )

RGBMatrixEmulator/adapters/tkinter_adapter.py ADDED Viewed

@@ -0,0 +1,83 @@
+import tkinter
+import os
+from RGBMatrixEmulator.adapters.base import BaseAdapter
+from RGBMatrixEmulator.graphics import Color
+from RGBMatrixEmulator.logger import Logger
+class TkinterAdapter(BaseAdapter):
+    SUPPORTS_ALTERNATE_PIXEL_STYLE = True
+    def __init__(self, width, height, options):
+        super().__init__(width, height, options)
+        self.__root = None
+        self.__canvas = None
+        self.__pixels = None
+    def load_emulator_window(self):
+        if self.loaded:
+            return
+        Logger.info("Loading {}".format(self.emulator_details_text()))
+        self.__root = tkinter.Tk()
+        self.__set_emulator_icon()
+        self.__root.title(self.emulator_details_text())
+        window_size = self.options.window_size()
+        self.__root.geometry("{}x{}".format(*window_size))
+        self.__canvas = tkinter.Canvas(
+            self.__root,
+            width=window_size[0],
+            height=window_size[1],
+            bd=0,
+            highlightthickness=0,
+            bg="black",
+        )
+        self.__initialize_bitmap()
+        self.__root.update()
+        self.loaded = True
+    def draw_to_screen(self, pixels):
+        for row, pixel_row in enumerate(pixels):
+            for col, pixel in enumerate(pixel_row):
+                shape_id = self.__pixels[row][col]
+                self.__canvas.itemconfig(shape_id, fill=Color.to_hex(pixel))
+        self.__canvas.pack()
+        self.__root.update()
+    def __initialize_bitmap(self):
+        self.__pixels = []
+        for row in range(0, self.height):
+            new_row = []
+            for col in range(0, self.width):
+                coords = self.__pixel_dimensions(col, row)
+                if self.options.pixel_style == "circle":
+                    id = self.__canvas.create_oval(coords, width=0)
+                else:
+                    id = self.__canvas.create_rectangle(coords, width=0)
+                new_row.append(id)
+            self.__pixels.append(new_row)
+    def __pixel_dimensions(self, col, row):
+        size = self.options.pixel_size
+        start, stop = (col * size, row * size)
+        return (start, stop, start + size, stop + size)
+    def __set_emulator_icon(self):
+        emulator_path = os.path.abspath(os.path.dirname(__file__))
+        raw_icon_path = os.path.join(emulator_path, "..", "icon.png")
+        icon_path = os.path.normpath(raw_icon_path)
+        icon = tkinter.PhotoImage(file=icon_path)
+        self.__root.tk.call("wm", "iconphoto", self.__root._w, icon)

RGBMatrixEmulator/adapters/turtle_adapter.py ADDED Viewed

@@ -0,0 +1,97 @@
+import os
+import tkinter
+import turtle
+from RGBMatrixEmulator.adapters.base import BaseAdapter
+from RGBMatrixEmulator.graphics.color import Color
+from RGBMatrixEmulator.logger import Logger
+class TurtleAdapter(BaseAdapter):
+    def __init__(self, width, height, options):
+        super().__init__(width, height, options)
+        self.__pen = None
+        self.__screen = None
+    def draw_to_screen(self, pixels):
+        self.__pen.clear()
+        for row, pixel_row in enumerate(pixels):
+            self.__move_pen_to_row_start(row)
+            for _col, pixel in enumerate(pixel_row):
+                self.__draw_pixel(pixel)
+                self.__move_pen_next_pixel()
+        self.__screen.update()
+    def load_emulator_window(self):
+        if self.loaded:
+            return
+        Logger.info("Loading {}".format(self.emulator_details_text()))
+        turtle.setup(*self.options.window_size())
+        turtle.title(self.emulator_details_text())
+        self.__pen = turtle.Turtle(visible=False)
+        self.__screen = self.__pen.getscreen()
+        self.__set_emulator_icon()
+        self.__screen.bgcolor(Color.BLACK())
+        turtle.tracer(0, 0)
+        turtle.colormode(255)
+        self.loaded = True
+    def __draw_pixel(self, pixel):
+        self.__pen.color(*pixel)
+        self.__pen.begin_fill()
+        if self.options.pixel_style == "circle":
+            self.__draw_circle_pixel()
+        else:
+            self.__draw_square_pixel()
+        self.__pen.end_fill()
+        self.__pen.setheading(0)
+    def __draw_square_pixel(self):
+        for _ in range(0, 4):
+            self.__pen.forward(self.options.pixel_size)
+            self.__pen.left(90)
+    def __draw_circle_pixel(self):
+        self.__pen.pendown()
+        self.__pen.dot(self.options.pixel_size)
+        self.__pen.penup()
+        # Apparently dots cannot overlap, so set movement to the smallest increment possible
+        self.__pen.forward(1)
+    def __move_pen_next_pixel(self):
+        self.__pen.penup()
+        self.__pen.forward(self.options.pixel_size)
+        self.__pen.pendown()
+    def __move_pen_to_row_start(self, row_number):
+        self.__reset_pen_position()
+        self.__pen.penup()
+        self.__pen.setheading(270)
+        self.__pen.forward(self.options.pixel_size * row_number)
+        self.__pen.setheading(0)
+        self.__pen.pendown()
+    def __reset_pen_position(self):
+        self.__pen.penup()
+        self.__pen.goto(
+            self.options.pixel_size / 2 - self.__screen.window_width() / 2,
+            self.__screen.window_height() / 2 - self.options.pixel_size / 2,
+        )
+        self.__pen.pendown()
+    def __set_emulator_icon(self):
+        emulator_path = os.path.abspath(os.path.dirname(__file__))
+        raw_icon_path = os.path.join(emulator_path, "..", "icon.png")
+        icon_path = os.path.normpath(raw_icon_path)
+        icon_image = tkinter.Image("photo", file=icon_path)
+        self.__screen._root.iconphoto(True, icon_image)

RGBMatrixEmulator/emulation/__init__.py ADDED Viewed

File without changes

RGBMatrixEmulator/emulation/canvas.py ADDED Viewed

@@ -0,0 +1,71 @@
+import numpy as np
+from PIL import Image, ImageEnhance
+from RGBMatrixEmulator.graphics.color import Color
+class Canvas:
+    def __init__(self, options):
+        self.options = options
+        self.width = options.cols * options.chain_length
+        self.height = options.rows * options.parallel
+        # 3D numpy array -- w, h, 3-tuple RGB
+        self.__pdims = (self.width, self.height, 3)
+        self.display_adapter = options.display_adapter.get_instance(
+            self.width, self.height, options
+        )
+        self.Clear()
+        self.display_adapter.load_emulator_window()
+    def Clear(self):
+        self.__pixels = np.full(
+            self.__pdims, self.__create_pixel(Color.BLACK()), dtype=np.uint8
+        )
+    def Fill(self, r, g, b):
+        self.__pixels = np.full(
+            self.__pdims, self.__create_pixel((r, g, b)), dtype=np.uint8
+        )
+    def SetPixel(self, x, y, r, g, b):
+        if self.display_adapter.pixel_out_of_bounds(x, y):
+            return
+        self.__pixels[int(y)][int(x)] = (r, g, b) * self.brightness
+    def SetImage(self, image, offset_x=0, offset_y=0, *other):
+        enhancer = ImageEnhance.Brightness(image)
+        image = enhancer.enhance(self.brightness / 100.0)
+        original = Image.fromarray(self.__pixels, "RGB")
+        original.paste(image, (offset_x, offset_y))
+        self.__pixels = np.copy(original)
+    @property
+    def brightness(self):
+        return self.options.brightness
+    @brightness.setter
+    def brightness(self, value):
+        if not isinstance(value, (int, float)):
+            raise ValueError(f"brightness must be a numeric value, received '{value}'")
+        elif value < 0 or value > 100:
+            raise ValueError(
+                f"brightness must be a number between 0 and 100, received '{value}'"
+            )
+        self.options.brightness = value
+    def __create_pixel(self, pixel):
+        return Color.adjust_brightness(tuple(pixel), self.brightness / 100.0)
+    # These are delegated to the display adapter to handle specific implementation.
+    def draw_to_screen(self):
+        self.display_adapter.draw_to_screen(self.__pixels)
+    def check_for_quit_event(self):
+        self.display_adapter.check_for_quit_event()

RGBMatrixEmulator/emulation/matrix.py ADDED Viewed

@@ -0,0 +1,62 @@
+from RGBMatrixEmulator.emulation.canvas import Canvas
+class RGBMatrix:
+    def __init__(self, options={}):
+        self.options = options
+        self.width = options.cols * options.chain_length
+        self.height = options.rows * options.parallel
+        self.canvas = None
+    def CreateFrameCanvas(self):
+        self.canvas = Canvas(options=self.options)
+        return self.canvas
+    def SwapOnVSync(self, canvas):
+        canvas.check_for_quit_event()
+        canvas.draw_to_screen()
+        self.canvas = canvas
+        return self.canvas
+    def Clear(self):
+        self.__sync_canvas()
+        self.canvas.Clear()
+        self.SwapOnVSync(self.canvas)
+    def Fill(self, r, g, b):
+        self.__sync_canvas()
+        self.canvas.Fill(r, g, b)
+        self.SwapOnVSync(self.canvas)
+    def SetPixel(self, x, y, r, g, b):
+        self.__sync_canvas()
+        self.canvas.SetPixel(x, y, r, g, b)
+        self.SwapOnVSync(self.canvas)
+    def SetImage(self, image, offset_x=0, offset_y=0, *other):
+        self.__sync_canvas()
+        self.canvas.SetImage(image, offset_x, offset_y, *other)
+        self.SwapOnVSync(self.canvas)
+    def __sync_canvas(self):
+        if not self.canvas:
+            self.canvas = Canvas(options=self.options)
+    @property
+    def brightness(self):
+        return self.options.brightness
+    @brightness.setter
+    def brightness(self, value):
+        if not isinstance(value, (int, float)):
+            raise ValueError(f"brightness must be a numeric value, received '{value}'")
+        elif value < 0 or value > 100:
+            raise ValueError(
+                f"brightness must be a number between 0 and 100, received '{value}'"
+            )
+        self.options.brightness = value