Still not done or working, but some work in progress

Interpolation etc. moved from paint() into BMP conversion code.

Author: PaintYourDragon

CLUE_Light_Painter/bmp2led.py

@@ -3,6 +3,7 @@
 """
 
 import os
+import ulab
 
 class BMPError(Exception):
     """Used for raising errors in the BMP2LED Class."""
@@ -149,6 +150,24 @@ def scandir(self, path):
 # self.file = None
 # Delete existing tempfile before checking free space.
 
+    def read_row(self, row):
+        """
+        Read one row of pixels from BMP file, clipped to minimum of BMP
+        image width or LED strip length.
+        Arguments:
+            row (int): index of row to read (0 to (image height - 1))
+        Returns: ulab ndarray (uint8 type) containing pixel data in
+        BMP-native order (B,G,R per pixel), no need to reorder to DotStar
+        order until later.
+        """
+        # 'flip' logic is intentionally backwards from typical BMP loader,
+        # this makes BMP image prep an easy 90 degree CCW rotation.
+        if not bmp.flip:
+            row = bmp.height - 1 - row
+        self.file.seek(bmp.image_offset + row * bmp.row_size)
+        return ulab.array(self.file.read(clipped_row_size), dtype=uint8)
+
+
     def process(self, input_filename, output_filename, rows,
              brightness=None, loop=False, callback=None):
         """
@@ -190,16 +209,31 @@ def process(self, input_filename, output_filename, rows,
                  number of rows requested, depending on storage space.
         """
 
+        # Allocate a working buffer for DotStar data, sized for LED strip.
+        # It's formed just like valid strip data (with header, per-pixel
+        # start markers and footer), with colors all '0' to start...these
+        # will be filled later.
+        dotstar_buffer = bytearray([0] * 4 +
+                                   [255, 0, 0, 0] * num_pixels +
+                                   [255] * ((num_pixels + 15) // 16))
+        dotstar_row_size = len(dotstar_buffer)
+
+        # Delete old temporary file, if any
         try:
-            # Delete output file, then gauge available space on filesystem.
             os.remove(output_filename)
-            stats = os.statvfs('/')
-            bytes_free = stats[0] * stats[4] # block size, free blocks
-            # Clip the maximum number of output rows based on free space and
-            # the size (in bytes) of each DotStar row.
-            dotstar_row_size = 4 + num_pixels * 4 + ((num_pixels + 15) // 16)
-            rows = min(rows, bytes_free // dotstar_buffer_size)
+        except OSError:
+            pass
+
+        # Determine free space on drive
+        stats = os.statvfs('/')
+        bytes_free = stats[0] * stats[4] # block size, free blocks
+        if not loop:                       # If not looping, leave space
+            bytes_free -= dotstar_row_size # for 'off' LED data at end.
+        # Clip the maximum number of output rows based on free space and
+        # the size (in bytes) of each DotStar row.
+        rows = min(rows, bytes_free // dotstar_row_size)
 
+        try:
             with open(input_filename, 'rb') as file_in:
                 #print("File opened")
 
@@ -211,63 +245,115 @@ def process(self, input_filename, output_filename, rows,
                 # Constrain row width to pixel strip length
                 clipped_width = min(bmp.width, self.num_pixels)
 
-                # Progress ratio along image ranges from 0.0 to 1.0 (if
-                # looping playback) or a bit under 1.0 (one row relative to
-                # full image height) if not looping.
-                divisor = (bmp.height - 1) if loop else bmp.height
+                # Each output row is interpolated from two BMP rows,
+                # we'll call them 'a' and 'b' here.
+                row_a_data, row_b_data = None, None
+                prev_row_a_index, prev_row_b_index = None
 
                 with open(output_filename, 'wb') as file_out:
-                    for row in range(rows): # For each row...
-                        progress = row / divisor # 0.0 to 1.0-ish
-row_1 = int((bmp.height - 1) * progress)
-row_2 = (row_1 + 1) % bmp.height
-#read row_1 and row_2 data if needed
-
-
-
-# Open input and output files
-# Don't use 'with' with two files, second won't close
-# Look at ExitStack(), or use two nested with's.
-
-        try:
-            print("Loading", filename)
-            with open(filename, "rb") as self.file:
-
-
-
-                # Image is displayed at END (not start) of NeoPixel strip,
-                # this index works incrementally backward in column buffers...
-                idx = (self.num_pixels - 1) * self.bytes_per_pixel
-                for row in range(clipped_height): # For each scanline...
-                    # Seek to start of scanline
-                    if bmp.flip: # Bottom-to-top order (normal BMP)
-                        self.file.seek(bmp.image_offset +
-                                       (bmp.height - 1 - row) * bmp.row_size)
-                    else: # BMP is stored top-to-bottom
-                        self.file.seek(bmp.image_offset + row * bmp.row_size)
-                    for column in columns: # For each pixel of scanline...
-                        # BMP files use BGR color order
-                        bgr = self.file.read(3) # Blue, green, red
-                        # Rearrange into NeoPixel strip's color order,
-                        # while handling brightness & gamma correction:
-                        column[idx + self.blue_index] = lut[bgr[0]]
-                        column[idx + self.green_index] = lut[bgr[1]]
-                        column[idx + self.red_index] = lut[bgr[2]]
-                    idx -= self.bytes_per_pixel # Advance (back) one pixel
-                    if callback:
-                        callback((row + 1) / clipped_height)
-
-                # Add one more column with no color data loaded.  This is used
-                # to turn the strip off at the end of the painting operation.
-                # It's done this way (rather than checking for last column and
-                # clearing LEDs in the painting code) so timing of the last
-                # column is consistent and looks good for photos.
-                if not loop:
-                    columns.append(bytearray(self.num_pixels *
-                                             self.bytes_per_pixel))
+                    for row in range(rows): # For each output row...
+                        position = row / (rows - 1) # 0.0 to 1.0
+                        if callback:
+                            callback(position)
+                        # Scale position into pixel space...
+                        if self.loop: # 0 to image height
+                            position *= len(self.columns)
+                        else:         # 0 to last row
+                            position *= (len(self.columns) - 1)
+
+                        # Separate absolute position into several values:
+                        # integer 'a' and 'b' row indices, floating 'a' and
+                        # 'b' weights (0.0 to 1.0) for interpolation.
+                        row_b_weight, row_a_index = modf(position)
+                        row_a_index = int(row_a_index)
+                        row_b_index = (row_a_index + 1) % bmp.height
+                        row_a_weight = 1.0 - row_b_weight
+
+                        # New data ONLY needs reading if row index changed
+                        # (else do another interp/dither with existing data)
+                        if row_a_index != prev_row_a_index:
+                            # If we've advanced exactly one row, reassign
+                            # old 'b' data to 'a' row, else read new 'a'.
+                            if row_a_index == prev_row_b_index:
+                                row_a_data = row_b_data
+                            else:
+                                row_a_data = self.read(row_a_index)
+                            # Read new 'b' data on any row change
+                            row_b_data = self.read(row_b_index)
+                        prev_row_a_index = row_a_index
+                        prev_row_b_index = row_b_index
+
+                        # Pixel values are stored as bytes from 0-255.
+                        # Gamma correction requires floats from 0.0 to 1.0.
+                        # So there's a scaling operation involved, BUT, as
+                        # configurable brightness is also a thing, we can
+                        # work that into the same operation. Rather than
+                        # dividing pixels by 255, multiply by
+                        # brightness / 255. This reduces the two row
+                        # interpolation weights from 0.0-1.0 to
+                        # 0.0-brightness/255.
+                        row_a_weight *= brightness / 255
+                        row_b_weight *= brightness / 255
+
+                        # 'want' is an ndarray of the idealized (as in,
+                        # floating-point) pixel values resulting from the
+                        # interpolation, with gamma correction applied and
+                        # scaled back up to the 0-255 range.
+                        want = ((row_a_data * row_a_weight +
+                                 row_b_data * row_b_weight) **
+                                self.gamma * 255.001)
+
+                        # 'got' will be an ndarray of the values that get
+                        # issued to the LED strip, formed through several
+                        # operations. First, an 'error term' is added to
+                        # each pixel, representing how 'wrong' the prior
+                        # output was. This is used for error diffusion
+                        # dithering. 'got' is floating-point at this stage.
+                        got = ulab.array(want + err)
+                        # The error term may push some pixel values outside
+                        # the required 0-255 range, so clip the result (aka
+                        # 'saturate'). (Note to future self: requested a
+                        # clip() function in ulab, should be available for
+                        # use soon, would replace these two Python ops).
+                        got[got < 0] = 0
+                        got[got > 255] = 255
+                        # ulab.compare.clip(got, 0, 255)
+                        # Now quantize the floating-point 'got' to uint8
+                        # type. This represents the actual final byte values
+                        # that will be issued to the LED strip.
+                        got = ulab.array(got, dtype=ulab.uint8)
+                        # Make note of the difference...the 'error term'...
+                        # between what we ideally wanted (float) and what we
+                        # actually got (dithered, clipped and quantized).
+                        # This will get used on the next pass through the
+                        # loop. Don't keep 100% of the value, or image
+                        # 'shimmers' too much...dial back slightly.
+                        err = (want - got) * 0.95
+
+                        # Reorder data from BGR to DotStar color order,
+                        # allowing for header and start-of-pixel markers
+                        # in the DotStar data.
+                        for column in range(clipped_width):
+                            bmp_pos = x * 3
+                            dotstar_pos = 5 + x * 4
+                            bgr = data[bmp_pos:bmp_pos + 3]
+                            dotstar_buffer[dotstar_pos + blue_index] = bgr[0]
+                            dotstar_buffer[dotstar_pos + green_index] = bgr[1]
+                            dotstar_buffer[dotstar_pos + red_index] = bgr[2]
+
+                        file_out.write(dotstar_buffer)
+
+                    # If not looping, add an 'all off' row of LED data
+                    # at end to ensure last row timing is consistent.
+                    if not loop:
+                        rows += 1
+                        file_out.write(bytearray([0] * 4 +
+                                                 [255, 0, 0, 0] * num_pixels +
+                                                 [255] * ((num_pixels + 15) //
+                                                          16)))
 
                 #print("Loaded OK!")
-                return columns
+                return rows
 
         except OSError as err:
             if err.args[0] == 28:

CLUE_Light_Painter/bmps-30px/arrow.bmp

@@ -1,6 +1,6 @@
 """
 Light painting project for Adafruit CLUE using DotStar LED strip.
-Images should be in 24-bit BMP format, with height matching the length
+Images should be in 24-bit BMP format, with width matching the length
 of the LED strip. The ulab module is used to assist with interpolation
 and dithering, displayio for a minimal user interface.
 """
@@ -213,7 +213,9 @@ def paint(self):
 
         board.DISPLAY.brightness = 0 # Screen backlight OFF
         painting = False
-        duration = 5.0 - self.speed * 4.5 # 0.5 to 5 seconds
+
+        row_size = 4 + num_leds * 4 + ((num_leds + 15) // 16)
+        # num_rows = was determined during conversion
 
         gc.collect() # Helps make playback a little smoother
 
@@ -224,81 +226,20 @@ def paint(self):
                 if painting:            # If currently painting
                     self.clear_strip()  # Turn LEDs OFF
                 else:
-                    start_time = monotonic()
-                    err = 0 # Clear 'error term' used for dithering
+                    row = 0             # Start at beginning of file
                 painting = not painting # Toggle paint mode on/off
             elif RichButton.HOLD in action_set:
                 return # Exit painting, enter config mode
 
             if painting:
-                elapsed = monotonic() - start_time
-                if self.loop:
-                    elapsed %= duration
-                elif elapsed > duration:
-                    self.clear_strip()
-                    painting = False
-                    continue
-
-                # Current absolute position along image, as floating-point
-                # value from 0.0 (first column) to last column.
-                position = elapsed / duration # 0.0 to 1.0
-                if self.loop:
-                    position *= len(self.columns)       # 0 to image width
-                else:
-                    position *= (len(self.columns) - 1) # 0 to last column
-                # Separate the absolute position into three values:
-                # the relative 'weight' of the subsequent image column
-                # when interpolating between two, the integer index of the
-                # first column and integer index of second column.
-                weight_2, column_1 = modf(position)
-                column_1 = int(column_1)
-                column_2 = (column_1 + 1) % len(self.columns)
-                weight_1 = 1.0 - weight_2
-
-                # Pixel values are stored as bytes from 0-255.
-                # Gamma correction requires floats from 0.0 to 1.0.
-                # So there's going to be a scaling operation involved,
-                # BUT, as configurable LED brightness is also a thing,
-                # we can work that into the same operation. Rather than
-                # dividing pixels by 255, multiply by brightness / 255.
-                # This reduces the two column interpolation weightings
-                # from 0.0-1.0 to 0.0-brightness/255.
-                weight_1 *= self.brightness / 255
-                weight_2 *= self.brightness / 255
-
-                # 'want' is an ndarray of the idealized (as in,
-                # floating-point) pixel values resulting from the
-                # interpolation, with gamma correction applied and
-                # scaled back up to the 0-255 range.
-                want = ((self.columns[column_1] * weight_1 +
-                         self.columns[column_2] * weight_2) **
-                        self.gamma * 255.001)
-                # 'got' will be an ndarray of the values that get issued to
-                # the LED strip, formed through several operations. First,
-                # an 'error term' is added to each pixel, representing how
-                # 'wrong' the prior output was. This is used for error
-                # diffusion dithering. 'got' is floating-point at this stage.
-                got = ulab.array(want + err)
-                # The error term may push some pixel values outside the
-                # required 0-255 range, so clip the result (aka 'saturate').
-                # (Note to future self: requested a clip() function in ulab,
-                #  if that gets added in some future release, that can be
-                #  used here instead of these two Python ops.)
-                got[got < 0] = 0
-                got[got > 255] = 255
-                # Now quantize the floating-point 'got' to uint8 type.
-                # This represents the actual final byte values that will
-                # be issued to the LED strip.
-                got = ulab.array(got, dtype=ulab.uint8)
-                # Make note of the difference...the 'error term'...between
-                # what we ideally wanted (float) and what we actually got
-                # (dithered, clipped and quantized). This will get used on
-                # the next pass through the loop. Don't keep 100% of the
-                # value, or image 'shimmers' too much...dial back slightly.
-                err = (want - got) * 0.9
-
-                # Issue the resulting uint8 'got' data to the LED strip.
-                self.write_func(self.neopixel_pin, got)
+                file.seek(row * row_size)
+                self.spi.write(file.read(row_size))
+                row += 1
+                if row >= num_rows:
+                    if self.loop:
+                        row = 0
+                    else:
+                        painting = False
 
 
     # Each config screen is broken out into its own function...