【レビュー】Raspberry Pi 5購入前に知っておくべき5つのこと

from gpiozero import LED
import time

led = LED(18)

while True:    
    led.on()
    
    time.sleep(1.0)
    
    led.off()
    
    time.sleep(1.0)

python3 -m venv myenv

source myenv/bin/activate

pip install picamera2

sudo apt install libcap-dev

python3 -m venv ~/mp --system-site-packages

source ~/mp/bin/activate

git clone https://github.com/googlesamples/mediapipe.git

cd mediapipe/examples/object_detection/raspberry_pi

sh setup.sh

nano detect_test.py

# Copyright 2023 The MediaPipe Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import argparse
import sys
import time
import cv2
import mediapipe as mp
from picamera2 import Picamera2
from libcamera import controls
from mediapipe.tasks import python
from mediapipe.tasks.python import vision
from utils import visualize

# Initial configuration of the camera
picam2 = Picamera2()
picam2.configure(picam2.create_preview_configuration(
    main={"format": 'XRGB8888', "size": (640, 480)}))
picam2.start()
picam2.set_controls({"AfMode": controls.AfModeEnum.Continuous})

# Global variables to calculate FPS
COUNTER, FPS = 0, 0
START_TIME = time.time()

def run(model: str, max_results: int, score_threshold: float,
        width: int, height: int) -> None:
            
    global is_inference_in_flight
    global latest_detection_result

    # Initialize global variables here
    is_inference_in_flight = False
    latest_detection_result = None            

    def save_result(result: vision.ObjectDetectorResult,
                    unused_output_image: mp.Image,
                    timestamp_ms: int):
        """Callback when the detection is done."""
        global is_inference_in_flight, latest_detection_result, COUNTER, START_TIME, FPS

        # Mark that inference has finished, so we can send another frame
        is_inference_in_flight = False

        # Update FPS
        if COUNTER % fps_avg_frame_count == 0:
            current_time = time.time()
            FPS = fps_avg_frame_count / (current_time - START_TIME)
            START_TIME = current_time

        latest_detection_result = result
        COUNTER += 1

    # Initialize the object detection model
    base_options = python.BaseOptions(model_asset_path=model)
    options = vision.ObjectDetectorOptions(
        base_options=base_options,
        running_mode=vision.RunningMode.LIVE_STREAM,
        max_results=max_results,
        score_threshold=score_threshold,
        result_callback=save_result
    )
    detector = vision.ObjectDetector.create_from_options(options)

    # Visualization parameters
    row_size = 50  # pixels
    left_margin = 24  # pixels
    text_color = (0, 0, 0)  # black
    font_size = 1
    font_thickness = 1
    fps_avg_frame_count = 10

    # Create a window to display the detection results
    cv2.namedWindow('object_detection', cv2.WINDOW_NORMAL)
    cv2.resizeWindow('object_detection', 800, 600)

    while True:
        frame = picam2.capture_array()
        if frame is None:
            break

        # Resize and convert for inference
        image = cv2.resize(frame, (width, height))
        rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb_image)

        # If the previous inference is done, start a new one
        if not is_inference_in_flight:
            detector.detect_async(mp_image, time.time_ns() // 1_000_000)
            is_inference_in_flight = True
        else:
            # If inference is still in flight,
            # we do NOT enqueue a new frame to avoid backlog
            pass

        # Draw FPS
        fps_text = 'FPS = {:.1f}'.format(FPS)
        text_location = (left_margin, row_size)
        cv2.putText(image, fps_text, text_location, cv2.FONT_HERSHEY_DUPLEX,
                    font_size, text_color, font_thickness, cv2.LINE_AA)

        # Visualize the latest detection result (if it exists)
        if latest_detection_result is not None:
            image = visualize(image, latest_detection_result)

        cv2.imshow('object_detection', image)

        # Stop if ESC is pressed
        if cv2.waitKey(1) == 27:
            break

    detector.close()
    picam2.stop()
    cv2.destroyAllWindows()

def main():
    parser = argparse.ArgumentParser(
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser.add_argument('--model', help='Path of the object detection model.',
                        required=False, default='efficientdet.tflite')
    parser.add_argument('--maxResults', help='Max number of detection results.',
                        required=False, default=5)
    parser.add_argument('--scoreThreshold',
                        help='The score threshold of detection results.',
                        required=False, type=float, default=0.25)
    parser.add_argument('--cameraId', help='Id of camera.',
                        required=False, type=int, default=0)
    parser.add_argument('--frameWidth',
                        help='Width of frame to capture from camera.',
                        required=False, type=int, default=1280)
    parser.add_argument('--frameHeight',
                        help='Height of frame to capture from camera.',
                        required=False, type=int, default=720)
    args = parser.parse_args()

    run(args.model, int(args.maxResults), args.scoreThreshold,
        args.frameWidth, args.frameHeight)

if __name__ == '__main__':
    main()

python3 detect_test.py

cd

cd mediapipe/examples/gesture_recognizer/raspberry_pi

sh setup.sh

nano recognize_test.py

# Copyright 2023 The MediaPipe Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import argparse
import sys
import time
import cv2
import mediapipe as mp
from mediapipe.tasks import python
from mediapipe.tasks.python import vision
from mediapipe.framework.formats import landmark_pb2
import numpy as np
from picamera2 import Picamera2
from libcamera import controls

mp_hands = mp.solutions.hands
mp_drawing = mp.solutions.drawing_utils
mp_drawing_styles = mp.solutions.drawing_styles

# Initial configuration of the camera
picam2 = Picamera2()
picam2.configure(picam2.create_preview_configuration(main={"format": 'XRGB8888', "size": (320, 240)}))
picam2.start()
picam2.set_controls({"AfMode": controls.AfModeEnum.Continuous})

# Global variables to calculate FPS and control inference
COUNTER, FPS = 0, 0
START_TIME = time.time()
is_inference_in_flight = False  # Flag to control inference execution
latest_recognition_result = None  # Variable to store the latest recognition result

def run(model: str, num_hands: int, min_hand_detection_confidence: float,
        min_hand_presence_confidence: float, min_tracking_confidence: float,
        camera_id: int, width: int, height: int) -> None:
    global is_inference_in_flight, latest_recognition_result

    def save_result(result: vision.GestureRecognizerResult,
                    unused_output_image: mp.Image, timestamp_ms: int):
        """Callback when the gesture recognition is done."""
        global is_inference_in_flight, latest_recognition_result, COUNTER, START_TIME, FPS

        # Mark that inference has finished
        is_inference_in_flight = False

        # Update FPS
        if COUNTER % fps_avg_frame_count == 0:
            current_time = time.time()
            FPS = fps_avg_frame_count / (current_time - START_TIME)
            START_TIME = current_time

        latest_recognition_result = result
        COUNTER += 1

    # Initialize the gesture recognizer model
    base_options = python.BaseOptions(model_asset_path=model)
    options = vision.GestureRecognizerOptions(
        base_options=base_options,
        running_mode=vision.RunningMode.LIVE_STREAM,
        num_hands=num_hands,
        min_hand_detection_confidence=min_hand_detection_confidence,
        min_hand_presence_confidence=min_hand_presence_confidence,
        min_tracking_confidence=min_tracking_confidence,
        result_callback=save_result
    )
    recognizer = vision.GestureRecognizer.create_from_options(options)

    # Visualization parameters
    row_size = 50  # pixels
    left_margin = 24  # pixels
    text_color = (0, 0, 0)  # black
    font_size = 1
    font_thickness = 1
    fps_avg_frame_count = 10
    label_text_color = (0, 0, 0)  # black
    label_background_color = (255, 255, 255)  # white
    label_font_size = 1
    label_thickness = 2
    label_padding_width = 100  # pixels

    # Create a window to display the recognition results
    cv2.namedWindow("Gesture Recognition", cv2.WINDOW_NORMAL)
    cv2.resizeWindow("Gesture Recognition", 800, 600)

    while True:
        # Capture frame from the camera
        frame = picam2.capture_array()
        if not isinstance(frame, np.ndarray):
            print("Frame is not a numpy array.")
            return

        # Resize and preprocess the frame
        image = frame[:, :, :3]
        image_resized = cv2.resize(image, (width, height))
        rgb_image = cv2.cvtColor(image_resized, cv2.COLOR_BGR2RGB)
        mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb_image)

        # Start a new inference if the previous one is done
        if not is_inference_in_flight:
            recognizer.recognize_async(mp_image, time.time_ns() // 1_000_000)
            is_inference_in_flight = True

        # Show the FPS on the frame
        fps_text = 'FPS = {:.1f}'.format(FPS)
        text_location = (left_margin, row_size)
        current_frame = image_resized
        cv2.putText(current_frame, fps_text, text_location, cv2.FONT_HERSHEY_DUPLEX,
                    font_size, text_color, font_thickness, cv2.LINE_AA)
                    
        # Draw the latest hand landmarks if available
        if latest_recognition_result is not None:
            for hand_landmarks in latest_recognition_result.hand_landmarks:
                hand_landmarks_proto = landmark_pb2.NormalizedLandmarkList()
                hand_landmarks_proto.landmark.extend([
                    landmark_pb2.NormalizedLandmark(x=landmark.x, y=landmark.y, z=landmark.z)
                    for landmark in hand_landmarks
                ])
                mp_drawing.draw_landmarks(
                    current_frame,
                    hand_landmarks_proto,
                    mp_hands.HAND_CONNECTIONS,
                    mp_drawing_styles.get_default_hand_landmarks_style(),
                    mp_drawing_styles.get_default_hand_connections_style()
                )

            # Show the gesture classification if available
            gestures = latest_recognition_result.gestures
            if gestures:
                category_name = gestures[0][0].category_name
                score = round(gestures[0][0].score, 2)
                result_text = category_name + ' (' + str(score) + ')'

                # Compute text size
                text_size = cv2.getTextSize(result_text, cv2.FONT_HERSHEY_DUPLEX, label_font_size,
                                            label_thickness)[0]
                text_width, text_height = text_size

                # Compute centered x, y coordinates
                legend_x = (current_frame.shape[1] - text_width) // 2
                legend_y = current_frame.shape[0] - (label_padding_width - text_height) // 2

                # Draw the text
                cv2.putText(current_frame, result_text, (legend_x, legend_y),
                            cv2.FONT_HERSHEY_DUPLEX, label_font_size,
                            label_text_color, label_thickness, cv2.LINE_AA)

        # Expand the frame to show the labels
        current_frame = cv2.copyMakeBorder(current_frame, 0, label_padding_width, 0, 0,
                                           cv2.BORDER_CONSTANT, None, label_background_color)

        cv2.imshow("Gesture Recognition", current_frame)

        # Stop the program if the ESC key is pressed
        if cv2.waitKey(1) == 27:
            break

    recognizer.close()
    picam2.stop()
    cv2.destroyAllWindows()

def main():
    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser.add_argument('--model', help='Name of gesture recognition model.',
                        required=False, default='gesture_recognizer.task')
    parser.add_argument('--numHands', help='Max number of hands that can be detected by the recognizer.',
                        required=False, default=1)
    parser.add_argument('--minHandDetectionConfidence', help='The minimum confidence score for hand detection.',
                        required=False, default=0.5)
    parser.add_argument('--minHandPresenceConfidence', help='The minimum confidence score of hand presence.',
                        required=False, default=0.5)
    parser.add_argument('--minTrackingConfidence', help='The minimum confidence score for hand tracking.',
                        required=False, default=0.5)
    parser.add_argument('--cameraId', help='Id of camera.', required=False, default=0)
    parser.add_argument('--frameWidth', help='Width of frame to capture from camera.',
                        required=False, default=640)
    parser.add_argument('--frameHeight', help='Height of frame to capture from camera.',
                        required=False, default=480)
    args = parser.parse_args()

    run(args.model, int(args.numHands), args.minHandDetectionConfidence,
        args.minHandPresenceConfidence, args.minTrackingConfidence,
        int(args.cameraId), args.frameWidth, args.frameHeight)


if __name__ == '__main__':
    main()                    

python3 recognize_test.py