sudo apt update
sudo apt full-upgrade -y
sudo reboot

sudo apt-get install linux-headers-$(uname -r)

wget -qO- https://developer.memryx.com/deb/memryx.asc | sudo tee /etc/apt/trusted.gpg.d/memryx.asc >/dev/null

echo 'deb https://developer.memryx.com/deb stable main' | sudo tee /etc/apt/sources.list.d/memryx.list >/dev/null

sudo apt-get update && sudo apt-get install memx-drivers memx-accl

sudo mx_arm_setup

sudo reboot

cat /sys/memx0/temperature

apt policy memx-drivers

sudo apt-get install memx-accl-plugins memx-utils-gui

curl -LsSf https://astral.sh/uv/install.sh | sh
source $HOME/.local/bin/env

# install 3.12
uv python install 3.12

# Create the environment and include pip
uv venv --seed --python 3.12 ~/mx

# activate the venv
source ~/mx/bin/activate

# Upgrade the packaging tools
python -m pip install --upgrade pip wheel

# clear shell's command lookup cache
hash -r

sudo apt-get update && sudo apt-get install libhdf5-dev python3-dev cmake python3-venv build-essential

uv pip install --index-url https://developer.memryx.com/pip --extra-index-url https://pypi.org/simple memryx

mx_nc --version

git clone --recursive https://github.com/memryx/memryx_examples.git

source ~/mx/bin/activate

cd
cd memryx_examples/video_inference/mediapipe_hands/

uv pip install opencv-python==4.11.0.86

mkdir models
wget https://developer.memryx.com/example_files/2p2/mediapipe_hands.zip
unzip mediapipe_hands.zip -d models

mx_nc -v -m path/to/model

cd src/python
python3 run.py

cd
cd memryx_examples/open_vocabulary/yoloe

uv pip install -r requirements.txt

wget https://developer.memryx.com/example_files/2p2/YoloE-v8s-seg_640_640_3_onnx.zip
mkdir -p models
unzip YoloE-v8s-seg_640_640_3_onnx.zip -d models

mx_nc -v -m model

cd src/python
python3 demo.py  # default video path /dev/video0

pip3 uninstall RPi.GPIO
pip3 install rpi-lgpio

nano led_on_off.py

import RPi.GPIO as GPIO
import time

LED_PIN = 12

GPIO.setmode(GPIO.BCM)
GPIO.setup(LED_PIN, GPIO.OUT)

try:
    while True:
        GPIO.output(LED_PIN, GPIO.HIGH)
        print("LED ON")
        time.sleep(1)

        GPIO.output(LED_PIN, GPIO.LOW)
        print("LED OFF")
        time.sleep(1)

except KeyboardInterrupt:
    print("Stopped")

finally:
    GPIO.cleanup()

python3 led_on_off.py

cd memryx_examples/video_inference/mediapipe_hands/src/python

nano led_hand_toggle.py

import threading
import cv2
import sys
import os
import numpy as np
from pathlib import Path
from MxHandPose import MxHandPose
import time

import RPi.GPIO as GPIO


LED_PIN = 12  # BCM GPIO12, physical pin 32


class MediapipeHandsDemo:

    def __init__(self, mxpose, **kwargs):
        self.mxpose = mxpose

        # GPIO LED setup
        GPIO.setmode(GPIO.BCM)
        GPIO.setup(LED_PIN, GPIO.OUT)
        GPIO.output(LED_PIN, GPIO.LOW)

        self.led_on = False

        # Used so one touch toggles only once
        self.touching_box = False

        # Threading
        self.stop_event = threading.Event()
        self.camera_read_thread = threading.Thread(target=self.camera_read, daemon=True)
        self.display_thread = threading.Thread(target=self.and_display, daemon=True)

        self.cam_width = 0
        self.cam_height = 0
        self.cap = self.video_capture()

        # Start threads
        self.camera_read_thread.start()
        self.display_thread.start()

        # Keep main thread alive
        self.camera_read_thread.join()
        self.display_thread.join()

    ##############################################################################################################
    # LED control
    ##############################################################################################################

    def toggle_led(self):
        self.led_on = not self.led_on

        if self.led_on:
            GPIO.output(LED_PIN, GPIO.HIGH)
            print("LED ON")
        else:
            GPIO.output(LED_PIN, GPIO.LOW)
            print("LED OFF")

    def cleanup(self):
        try:
            GPIO.output(LED_PIN, GPIO.LOW)
            GPIO.cleanup()
        except Exception:
            pass

    ##############################################################################################################
    # Camera capture and display
    ##############################################################################################################

    def video_capture(self):
        camera = cv2.VideoCapture(0)
        camera.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc(*'MJPG'))
        camera.set(cv2.CAP_PROP_FPS, 30)

        self.cam_width = int(camera.get(cv2.CAP_PROP_FRAME_WIDTH))
        self.cam_height = int(camera.get(cv2.CAP_PROP_FRAME_HEIGHT))

        return camera

    def camera_read(self):
        if not self.cap.isOpened():
            print("Error: Could not open camera.")
            self.cleanup()
            return

        while not self.stop_event.is_set():
            ret, frame = self.cap.read()

            if not ret:
                print("Error: Could not read frame.")
                break

            if not self.mxpose.full():
                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                self.mxpose.put(frame)

        self.mxpose.stop()
        self.cap.release()
        self.cleanup()
        os._exit(0)

    def and_display(self):
        cv2.namedWindow('MediapipeHands', cv2.WINDOW_NORMAL)
        cv2.resizeWindow('MediapipeHands', self.cam_width + 20, self.cam_height + 20)

        while not self.stop_event.is_set():

            if cv2.getWindowProperty('MediapipeHands', cv2.WND_PROP_VISIBLE) < 1:
                self.stop_event.set()
                break

            if not self.mxpose.empty():
                annotated_frame = self.mxpose.get()

                frame = self.draw(annotated_frame)

                frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)

                cv2.imshow('MediapipeHands', frame)

                key = cv2.waitKey(1) & 0xFF
                if key == ord('q') or key == 27:
                    self.stop_event.set()
                    break

        cv2.destroyAllWindows()
        self.cleanup()
        os._exit(0)

    ##############################################################################################################
    # Drawing and interaction
    ##############################################################################################################

    def draw(self, annotated_frame):
        handkeypoints_lst, handtype_lst = self.get_handkeypoints_handtype(annotated_frame)
        img = annotated_frame.image

        currently_touching = False

        # Draw hand/finger landmarks again
        for i, hand_points in enumerate(handkeypoints_lst):
            is_left = False

            if i < len(handtype_lst):
                is_left = str(handtype_lst[i]).lower() == "left"

            img = self.drawLandmarks(img, [hand_points], is_left)

            # Index fingertip is landmark 8
            fingertip = hand_points[8]

            if self.check_box_touch(fingertip):
                currently_touching = True

        # Toggle only when finger first enters the box
        if currently_touching and not self.touching_box:
            self.toggle_led()

        self.touching_box = currently_touching

        # Draw the toggle box
        img = self.draw_toggle_box(img)


        '''
        # Show LED state text
        state_text = "LED: ON" if self.led_on else "LED: OFF"
        state_color = (0, 255, 0) if self.led_on else (255, 0, 0)

        cv2.putText(
            img,
            state_text,
            (20, 110),
            cv2.FONT_HERSHEY_SIMPLEX,
            0.9,
            state_color,
            2,
            cv2.LINE_AA
        )
        '''

        return img

    def get_handkeypoints_handtype(self, annotated_frame):
        handkeypoints_lst = []
        handtype_lst = []

        for handpose in annotated_frame.handposes:
            hp_reshaped = handpose.landmarks.reshape(21, 3).astype(np.int32)
            singlehand_keypoints = [(int(x), int(y)) for x, y, z in hp_reshaped]

            handkeypoints_lst.append(singlehand_keypoints)
            handtype_lst.append(handpose.handedness)

        return handkeypoints_lst, handtype_lst

    ##############################################################################################################
    # One toggle box
    ##############################################################################################################

    def get_toggle_box_region(self):
        return {
            "name": "TOGGLE",
            "x1": 20,
            "y1": 20,
            "x2": 170,
            "y2": 80,
        }

    def check_box_touch(self, fingertip):
        x, y = fingertip
        box = self.get_toggle_box_region()

        return box["x1"] <= x <= box["x2"] and box["y1"] <= y <= box["y2"]

    def draw_toggle_box(self, frame):
        box = self.get_toggle_box_region()

        x1 = box["x1"]
        y1 = box["y1"]
        x2 = box["x2"]
        y2 = box["y2"]

        if self.led_on:
            fill_color = (0, 255, 0)      # green in RGB
            text_color = (0, 0, 0)
            label = "ON"
        else:
            fill_color = (255, 0, 0)      # red in RGB
            text_color = (255, 255, 255)
            label = "OFF"

        # Filled box
        cv2.rectangle(frame, (x1, y1), (x2, y2), fill_color, -1)

        # Border
        cv2.rectangle(frame, (x1, y1), (x2, y2), (255, 255, 255), 3)

        # Text
        cv2.putText(
            frame,
            f"TOGGLE {label}",
            (x1 + 10, y1 + 38),
            cv2.FONT_HERSHEY_SIMPLEX,
            0.7,
            text_color,
            2,
            cv2.LINE_AA
        )

        return frame

    ##############################################################################################################
    # Hand landmark drawing
    ##############################################################################################################

    def drawLandmarks(self, frame, data, is_left):
        allhands = data

        if is_left:
            color = (255, 0, 255)
        else:
            color = (0, 255, 255)

        for myHand in allhands:
            cv2.line(frame, (myHand[0][0], myHand[0][1]), (myHand[1][0], myHand[1][1]), color, 2)
            cv2.line(frame, (myHand[1][0], myHand[1][1]), (myHand[2][0], myHand[2][1]), color, 2)
            cv2.line(frame, (myHand[2][0], myHand[2][1]), (myHand[3][0], myHand[3][1]), color, 2)
            cv2.line(frame, (myHand[3][0], myHand[3][1]), (myHand[4][0], myHand[4][1]), color, 2)

            cv2.line(frame, (myHand[0][0], myHand[0][1]), (myHand[5][0], myHand[5][1]), color, 2)
            cv2.line(frame, (myHand[5][0], myHand[5][1]), (myHand[6][0], myHand[6][1]), color, 2)
            cv2.line(frame, (myHand[6][0], myHand[6][1]), (myHand[7][0], myHand[7][1]), color, 2)
            cv2.line(frame, (myHand[7][0], myHand[7][1]), (myHand[8][0], myHand[8][1]), color, 2)

            cv2.line(frame, (myHand[0][0], myHand[0][1]), (myHand[17][0], myHand[17][1]), color, 2)
            cv2.line(frame, (myHand[17][0], myHand[17][1]), (myHand[18][0], myHand[18][1]), color, 2)
            cv2.line(frame, (myHand[18][0], myHand[18][1]), (myHand[19][0], myHand[19][1]), color, 2)
            cv2.line(frame, (myHand[19][0], myHand[19][1]), (myHand[20][0], myHand[20][1]), color, 2)

            cv2.line(frame, (myHand[5][0], myHand[5][1]), (myHand[9][0], myHand[9][1]), color, 2)
            cv2.line(frame, (myHand[9][0], myHand[9][1]), (myHand[13][0], myHand[13][1]), color, 2)
            cv2.line(frame, (myHand[13][0], myHand[13][1]), (myHand[17][0], myHand[17][1]), color, 2)

            cv2.line(frame, (myHand[9][0], myHand[9][1]), (myHand[10][0], myHand[10][1]), color, 2)
            cv2.line(frame, (myHand[10][0], myHand[10][1]), (myHand[11][0], myHand[11][1]), color, 2)
            cv2.line(frame, (myHand[11][0], myHand[11][1]), (myHand[12][0], myHand[12][1]), color, 2)

            cv2.line(frame, (myHand[13][0], myHand[13][1]), (myHand[14][0], myHand[14][1]), color, 2)
            cv2.line(frame, (myHand[14][0], myHand[14][1]), (myHand[15][0], myHand[15][1]), color, 2)
            cv2.line(frame, (myHand[15][0], myHand[15][1]), (myHand[16][0], myHand[16][1]), color, 2)

            for point in myHand:
                cv2.circle(frame, (point[0], point[1]), 4, (23, 90, 10), 1)

            for point in myHand:
                cv2.circle(frame, (point[0], point[1]), 3, (255, 255, 125), -1)

            # Highlight index fingertip clearly
            fingertip = myHand[8]
            cv2.circle(frame, (fingertip[0], fingertip[1]), 8, (0, 255, 0), 2)

        return frame


if __name__ == '__main__':

    project_dir = Path(__file__).resolve().parents[2]
    mx_modeldir = project_dir / 'models'

    try:
        mx_pose = MxHandPose(mx_modeldir=mx_modeldir, num_hands=2)
        paint = MediapipeHandsDemo(mxpose=mx_pose)

    except (FileNotFoundError, RuntimeError) as exc:
        print(f"Failed to start Mediapipe Hands: {exc}", file=sys.stderr)
        GPIO.cleanup()
        sys.exit(1)

    except KeyboardInterrupt:
        print("Stopped")
        GPIO.cleanup()
        sys.exit(0)

python3 led_hand_toggle.py