# move throuch Sinus and Cosinus terrain
#
# 21 Mar 2025 - @pagong
# Uses Raspberry-Pi Pico with a 16x16 NeoPixel LED matrix

import time
import board
import random
import neopixel
import rainbowio

import neomatrix

#####################

# for RPi-Pico with 16x16 NeoPixel-Matrix
NUM_COLS  = 16
NUM_CELLS = 16

NUM_PIXELS = (NUM_COLS * NUM_CELLS)  # Update this to match the number of LEDs.
SPEED = 0.01       # Increase to slow down the animation. Decrease to speed it up.
BRIGHTNESS = 0.1   # A number between 0.0 and 1.0, where 0.0 is off, and 1.0 is max.
PIN = board.GP28   # This is the default pin on RPi-Pico with 16x16 NeoPixel matrix

matrixType = (  neomatrix.NEO_MATRIX_BOTTOM + neomatrix.NEO_MATRIX_LEFT +
                neomatrix.NEO_MATRIX_ROWS + neomatrix.NEO_MATRIX_ZIGZAG   )

leds   = neopixel.NeoPixel(PIN, NUM_PIXELS, brightness=BRIGHTNESS, auto_write=False)
matrix = neomatrix.NeoMatrix( leds, NUM_COLS, NUM_CELLS, 1, 1, matrixType )
grid   = matrix._grid

#####################

# prepare rainbow palette
palette = []
for k in range(256):
    palette.append(rainbowio.colorwheel(k))

# change direction of movement
def change_direction():
    xs, ys = 0, 0
    while (abs(xs) + abs(ys) == 0):
        xs = random.randint(-1, 1)
        ys = random.randint(-1, 1)
    return float(xs), float(ys)

def do_frame():
    for i in range(NUM_COLS):           # for each pixel row
        x2 = (start_x + step*i - center_x)**2
        pxl = grid[i]
        for j in range(NUM_CELLS):      # for each pixel column
            y2 = (start_y + step*j - center_y)**2
            r = math.sqrt(x2 + y2)
            val = 1.0 + math.sin(r)
            col = int(val * 127.5)      # scale it from -1 - +1 -> 0 - 255
            pxl[j] = palette[col]       # convert hue to rainbow color

#####################

import math
step = (2.5 * math.pi) / float(NUM_COLS)
start_x = 0.0
start_y = 0.0

incr = 0.1
xsign = 0.0
ysign = 1.0

center_x = (NUM_COLS / 2) - 0.5
center_y = (NUM_CELLS / 2) - 0.5

Debug = True

while True:
    t1 = time.monotonic_ns()
    do_frame()
    t2 = time.monotonic_ns()

    grid.show()
    t3 = time.monotonic_ns()

    if Debug:
        d1 = (t2 - t1) / 1000000.0
        print(f"Compute {d1} ms", end=" +\t")
        d2 = (t3 - t2) / 1000000.0
        print(f"Display {d2} ms", end=" =\t")
        print(f"Total {d1+d2} ms", end=" -->\t")
        print(f"{1000.0/(d1+d2)} fps")

    # move around in noise space
    start_x += incr * xsign
    start_y += incr * ysign
    if (random.randint(0, 99) == 8):
        xsign, ysign = change_direction()

    time.sleep(SPEED)
    #break