Fixes in simulator display and setup script

Author: ffont

README.md

@@ -223,7 +223,7 @@ With `push2_python.constants.FRAME_FORMAT_RGB565` we need to convert the frame t
 push = push2_python.Push2(run_simulator=True)
 ```
 
-And then, while your app is running, point your browser at `localhost:5000`. Here is a screenshot of the simulator in action:
+And then, while your app is running, point your browser at `localhost:6128`. Here is a screenshot of the simulator in action:
 
 <p align="center">
 <img src="simulator.png" title="push2-python simulator" />
@@ -363,15 +363,8 @@ for i in range(0, 20):
 
 # Now crate an extra frame which loads an image from a file. Image must be 960x160 pixels.
 img = Image.open('test_img_960x160.png')
-img_array = numpy.array(img)
-frame = img_array/255  # Convert rgb values to [0.0, 1.0] floats
-
-# Because the pixel format returned by Image.open is not the one required for Push2's display,
-# this frame needs to be prepared before sending it to Push. This conversion takes a bit of 
-# time so we do it offline. Some formats can be converted on the fly by `push2-python` but not 
-# the RGB format retruned by PIL.
-prepared_img_frame = \
-    push.display.prepare_frame(frame, input_format=push2_python.constants.FRAME_FORMAT_RGB)
+frame = numpy.array(img)
+#frame = img_array/255  # Convert rgb values to [0.0, 1.0] floats
 
 # Now lets configure some action handlers which will display frames in Push2's display in 
 # reaction to pad and button presses
@@ -384,7 +377,7 @@ def on_pad_pressed(push, pad_n, pad_ij, velocity):
 @push2_python.on_button_pressed()
 def on_button_pressed(push, button_name):
     # Display the frame with the loaded image
-    push.display.display_prepared_frame(prepared_img_frame)
+    push.display.display_frame(frame, input_format=push2_python.constants.FRAME_FORMAT_RGB)
 
 # Start infinite loop so the app keeps running
 print('App runnnig...')

push2_python/display.py

@@ -28,22 +28,18 @@ def rgb565_to_bgr565(rgb565_frame):
 
 # Non-vectorized function for converting from rgb to bgr565
 def rgb_to_bgr565(rgb_frame):
-    # RGB is defined here as an 2d array with (r, g, b) tuples with values between [0.0, 1.0]
-    # TODO: this is really slow, there are other ways to do this simple (similar to rgb565_to_bgr565)
-    # which will work as well super fast. Need to implement that
-    out_array = numpy.zeros(shape=(rgb_frame.shape[1], rgb_frame.shape[0]), dtype=numpy.uint16)
-    for i in range(0, rgb_frame.shape[0]):
-        for j in range(0, rgb_frame.shape[1]):
-            r = rgb_frame[i][j][0]
-            g = rgb_frame[i][j][1]
-            b = rgb_frame[i][j][2]
-            r = int(round(r * (pow(2, 5) - 1)))
-            g = int(round(g * (pow(2, 6) - 1)))
-            b = int(round(b * (pow(2, 5) - 1)))
-            out_array[j][i] = int(
-                '{b:05b}{g:06b}{r:05b}'.format(r=r, g=g, b=b), 2)
-    return out_array
-
+    rgb_frame *= 255
+    rgb_frame_r = rgb_frame[:, :, 0].astype(numpy.uint16)
+    rgb_frame_g = rgb_frame[:, :, 1].astype(numpy.uint16)
+    rgb_frame_b = rgb_frame[:, :, 2].astype(numpy.uint16)
+    frame_r_filtered = numpy.bitwise_and(rgb_frame_r, int('0000000011111000', 2))
+    frame_r_shifted = numpy.right_shift(frame_r_filtered, 3)
+    frame_g_filtered = numpy.bitwise_and(rgb_frame_g, int('0000000011111100', 2))
+    frame_g_shifted = numpy.left_shift(frame_g_filtered, 3)
+    frame_b_filtered = numpy.bitwise_and(rgb_frame_b, int('0000000011111000', 2))
+    frame_b_shifted = numpy.left_shift(frame_b_filtered, 8)
+    combined = frame_r_shifted + frame_g_shifted + frame_b_shifted  # Combine all channels
+    return combined.transpose()
 
 class Push2Display(AbstractPush2Section):
     """Class to interface with Ableton's Push2 display.
@@ -196,17 +192,11 @@ def send_to_display(self, prepared_frame):
 
 
     def display_frame(self, frame, input_format=FRAME_FORMAT_BGR565):
-        prepared_frame = self.prepare_frame(frame, input_format=input_format)
+        prepared_frame = self.prepare_frame(frame.copy(), input_format=input_format)
         self.send_to_display(prepared_frame)
 
         if self.push.simulator_controller is not None:
-            self.push.simulator_controller.prepare_next_frame_for_display(frame, input_format=input_format)
-
-
-    def display_prepared_frame(self, prepared_frame):
-        # NOTE that using this method frames won't be shown in the simulator
-        self.send_to_display(prepared_frame)
-
+            self.push.simulator_controller.prepare_next_frame_for_display(frame.copy(), input_format=input_format)
 
     def display_last_frame(self):
         self.send_to_display(self.last_prepared_frame)

push2_python/simulator/simulator.py

@@ -7,7 +7,6 @@
 from PIL import Image
 from io import BytesIO
 import time
-import random
 import numpy
 
 app = Flask(__name__)
@@ -67,40 +66,48 @@ def set_element_color(self, midiTrigger, color_idx, animation_idx):
 
     def prepare_next_frame_for_display(self, frame, input_format=push2_python.constants.FRAME_FORMAT_BGR565):
         global latest_prepared_base64_image_to_send, latest_prepared_image_sent
-        
+
         # 'frame' expects a "frame" as in display.display_frame method
         if time.time() - self.last_time_frame_prepared > 1.0/5.0:  # Limit fps to save recources
             self.last_time_frame_prepared = time.time()
-
+            
             # We need to convert the frame to RGBA format first (so Pillow can read it later)
+            if input_format == push2_python.constants.FRAME_FORMAT_RGB:
+                frame = push2_python.display.rgb_to_bgr565(frame)
+
             frame = frame.transpose().flatten()
             rgb_frame = numpy.zeros(shape=(len(frame), 1), dtype=numpy.uint32).flatten()
             rgb_frame[:] = frame[:]
+            
             if input_format == push2_python.constants.FRAME_FORMAT_RGB565:
                 r_filter = int('1111100000000000', 2)
                 g_filter = int('0000011111100000', 2)
                 b_filter = int('0000000000011111', 2)
                 frame_r_filtered = numpy.bitwise_and(rgb_frame, r_filter)
-                frame_r_shifted = numpy.left_shift(frame_r_filtered, 16)  # Shift 16 to left so R starts at bit 32
+                frame_r_shifted = numpy.right_shift(frame_r_filtered, 8)  # Shift 8 to right so R sits in the the 0-7 right-most bits
                 frame_g_filtered = numpy.bitwise_and(rgb_frame, g_filter)
-                frame_g_shifted = numpy.left_shift(frame_g_filtered, 13) # Shift 13 to the left so G start at bit 24
+                frame_g_shifted = numpy.left_shift(frame_g_filtered, 5)  # Shift 5 to the left so G sits at the 8-15 bits
                 frame_b_filtered = numpy.bitwise_and(rgb_frame, b_filter)
-                frame_b_shifted = numpy.left_shift(frame_b_filtered, 11)  # Shift 11 so B starts at bit 16
+                frame_b_shifted = numpy.left_shift(frame_b_filtered, 19)  # Shift 19 to the left so G sits at the 16-23 bits
                 rgb_frame = frame_r_shifted + frame_g_shifted + frame_b_shifted  # Combine all channels
-                rgb_frame = numpy.bitwise_or(rgb_frame, int('00000000000000000000000011111111', 2))  # Set alpha channel to "full!"
-            elif input_format == push2_python.constants.FRAME_FORMAT_BGR565:
+                rgb_frame = numpy.bitwise_or(rgb_frame, int('11111111000000000000000000000000', 2))  # Set alpha channel to "full!" (bits 24-32)
+
+            elif input_format == push2_python.constants.FRAME_FORMAT_BGR565 or input_format == push2_python.constants.FRAME_FORMAT_RGB:
                 r_filter = int('0000000000011111', 2)
                 g_filter = int('0000011111100000', 2)
-                b_filter = int('1111100000000000', 2)
-                frame_r_filtered = numpy.bitwise_and(rgb_frame, r_filter)
-                frame_r_shifted = numpy.left_shift(frame_r_filtered, 27)  # Shift 27 to left so R starts at bit 32
+                b_filter = int('1111100000000000', 2)                
+                frame_r_filtered = numpy.bitwise_and(rgb_frame, r_filter) 
+                frame_r_shifted = numpy.left_shift(frame_r_filtered, 3)  # Shift 3 to left so R sits in the the 0-7 right-most bits
                 frame_g_filtered = numpy.bitwise_and(rgb_frame, g_filter)
-                frame_g_shifted = numpy.left_shift(frame_g_filtered, 13)  # Shift 13 to the left so G start at bit 24
+                frame_g_shifted = numpy.left_shift(frame_g_filtered, 5)  # Shift 5 to the left so G sits at the 8-15 bits
                 frame_b_filtered = numpy.bitwise_and(rgb_frame, b_filter)
-                frame_b_shifted = frame_b_filtered  # No shift, B already starts at 16
+                frame_b_shifted = numpy.left_shift(frame_b_filtered, 8)  # Shift 8 to the left so G sits at the 16-23 bits
                 rgb_frame = frame_r_shifted + frame_g_shifted + frame_b_shifted  # Combine all channels
-                rgb_frame = numpy.bitwise_or(rgb_frame, int('00000000000000000000000011111111', 2))  # Set alpha channel to "full!"
+                rgb_frame = numpy.bitwise_or(rgb_frame, int('11111111000000000000000000000000', 2))  # Set alpha channel to "full!" (bits 24-32)
+
+            '''
             elif input_format == push2_python.constants.FRAME_FORMAT_RGB:
+                
                 r_filter = int('111111110000000000000000', 2)
                 g_filter = int('000000001111111100000000', 2)
                 b_filter = int('000000000000000011111111', 2)
@@ -112,6 +119,7 @@ def prepare_next_frame_for_display(self, frame, input_format=push2_python.consta
                 frame_b_shifted = frame_b_filtered  # No shift, B already starts at 16
                 rgb_frame = frame_r_shifted + frame_g_shifted + frame_b_shifted  # Combine all channels
                 rgb_frame = numpy.bitwise_or(rgb_frame, int('00000000000000000000000011111111', 2))  # Set alpha channel to "full!"
+            '''
 
             img = Image.frombytes('RGBA', (960, 160), rgb_frame.tobytes())
             buffered = BytesIO()
@@ -195,7 +203,7 @@ def index():
 
 
 def run_simulator_in_thread():
-    sim_app.run(app)
+    sim_app.run(app, port=6128)
 
 
 def start_simulator(_push_object):

setup.py

@@ -1,13 +1,15 @@
 from setuptools import setup, find_packages
 
 setup(name='push2-python',
-      version='0.5',
+      version='0.6',
       description='Utils to interface with Ableton\'s Push 2 from Python',
       url='https://github.com/ffont/push2-python',
       author='Frederic Font',
       author_email='frederic.font@gmail.com',
       license='MIT',
       install_requires=['numpy', 'pyusb', 'python-rtmidi', 'mido', 'flask', 'flask-socketio', 'eventlet' , 'pillow'],
       python_requires='>=3',
+      setup_requires=['setuptools_scm'],
+      include_package_data=True,
       packages=find_packages()
       )