...

Author: CursedPrograms

audio_analysis.py

@@ -0,0 +1,42 @@
+from pydub import AudioSegment
+import numpy as np
+
+class AudioAnalyzer:
+    def __init__(self, filepath, num_bars=50):
+        self.audio = AudioSegment.from_file(filepath)
+        self.num_bars = num_bars
+        self.samples = np.array(self.audio.get_array_of_samples())
+
+        # Mono or stereo?
+        if self.audio.channels == 2:
+            self.samples = self.samples.reshape((-1, 2))
+            self.samples = self.samples.mean(axis=1)  # convert to mono
+
+        self.sample_rate = self.audio.frame_rate
+        self.duration = len(self.audio) / 1000.0  # duration in seconds
+
+        # Normalize samples to [-1,1]
+        self.samples = self.samples / np.max(np.abs(self.samples))
+
+        # Precompute chunk size for bars
+        self.chunk_size = len(self.samples) // self.num_bars
+
+    def get_amplitudes(self, current_time):
+        """
+        Given current playback time in seconds, returns a list of amplitudes (0 to 1)
+        for each bar of the waveform visualizer.
+        """
+        start_sample = int(current_time * self.sample_rate)
+        amplitudes = []
+
+        # Avoid overflow
+        if start_sample + self.chunk_size * self.num_bars > len(self.samples):
+            # Loop back to start or clip
+            start_sample = 0
+
+        for i in range(self.num_bars):
+            chunk = self.samples[start_sample + i * self.chunk_size : start_sample + (i+1) * self.chunk_size]
+            amp = np.abs(chunk).mean()
+            amplitudes.append(amp)
+
+        return amplitudes

clear-commits.bat

@@ -1,19 +1,19 @@
-#!/bin/bash
-
-# Switch to a new orphan branch
-git checkout --orphan new_branch
-
-# Stage all changes
-git add .
-
-# Commit changes
-git commit -m "new_commit"
-
-# Delete the old main branch
-git branch -D main
-
-# Rename the new branch to main
-git branch -m main
-
-# Force push to the remote main branch
+#!/bin/bash
+
+# Switch to a new orphan branch
+git checkout --orphan new_branch
+
+# Stage all changes
+git add .
+
+# Commit changes
+git commit -m "new_commit"
+
+# Delete the old main branch
+git branch -D main
+
+# Rename the new branch to main
+git branch -m main
+
+# Force push to the remote main branch
 git push -f origin main

clear-commits.sh

@@ -1,13 +1,14 @@
-{
-    "Config": {
-      "AppName": "TemplateProject",
-      "Description": "",
-      "ProjectStructure": {
-        "MainScript": "main.py",
-        "DependenciesScript": "scripts/install-dependencies.py"
-      },
-      "Scripts": {
-
-      }
-    }
+{
+    "Config": {
+      "AppName": "Gender Age ID",
+      "Description": "",
+      "ProjectStructure": {
+        "MainScript": "main.py",
+        "DependenciesScript": "scripts/install-dependencies.py"
+      },
+      "Scripts": {
+        "MainScript": "main.py",
+        "DependenciesScript": "scripts/install-dependencies.py"
+      }
+    }
   }

config.json

@@ -0,0 +1,41 @@
+import cv2
+import time
+from picamera2 import Picamera2
+
+# Initialize PiCamera2
+cam = Picamera2()
+cam.preview_configuration.main.size = (640, 480)
+cam.preview_configuration.main.format = "RGB888"
+cam.configure("preview")
+cam.start()
+time.sleep(1)  # Let the camera warm up
+
+# Load the Haar Cascade face detector
+face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+
+print("👁️ Press 'q' to quit.")
+
+while True:
+    # Capture frame from PiCamera
+    frame = cam.capture_array()
+
+    # Convert to grayscale for face detection
+    gray = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
+
+    # Detect faces
+    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.3, minNeighbors=5, minSize=(30, 30))
+
+    # Draw rectangles around faces
+    for (x, y, w, h) in faces:
+        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
+
+    # Display the result
+    cv2.imshow('🎥 PiCamera Face Detection', cv2.cvtColor(frame, cv2.COLOR_RGB2BGR))
+
+    # Quit if 'q' is pressed
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+
+# Cleanup
+cv2.destroyAllWindows()
+cam.stop()

face-detection/feed_detection.py

@@ -0,0 +1,50 @@
+import cv2
+from PIL import Image
+import os
+import glob
+import numpy as np 
+import json
+
+def detect_and_mark_faces(input_path, output_dir):
+    # Load the image using PIL to handle various image formats
+    image_pil = Image.open(input_path)
+    image = cv2.cvtColor(np.array(image_pil), cv2.COLOR_RGB2BGR)  # Use np for nump
+
+    # Convert the image to grayscale
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+
+    # Load the pre-trained face detector
+    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+
+    # Detect faces in the image
+    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
+
+    # Draw rectangles around the faces
+    for (x, y, w, h) in faces:
+        cv2.rectangle(image, (x, y), (x+w, y+h), (0, 255, 0), 2)
+
+    # Create an output directory if it doesn't exist
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Save the marked image using PIL to handle various image formats
+    output_path = os.path.join(output_dir, f"marked_{os.path.basename(input_path)}")
+    marked_image_pil = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+    marked_image_pil.save(output_path)
+
+    print(f"Detected {len(faces)} face(s). Marked image saved to {output_path}")
+
+if __name__ == "__main__":
+
+    script_directory = os.path.dirname(os.path.abspath(__file__))
+
+    with open("settings.json", "r") as file:
+        settings = json.load(file)
+
+    input_directory = os.path.join(script_directory, settings["directories"]["input"])
+    output_directory = os.path.join(script_directory, settings["directories"]["output"])
+
+    # Get a list of all image files in the input directory
+    image_files = glob.glob(os.path.join(input_directory, "*"))
+
+    for image_file in image_files:
+        detect_and_mark_faces(image_file, output_directory)

face-detection/image_detection.py

@@ -0,0 +1,2 @@
+sudo apt install python3-rpi.gpio python3-picamera2 ffmpeg
+pip install qrcode[pil] pillow

gpio-requirements.txt

@@ -0,0 +1,92 @@
+import threading
+import numpy
+import spidev
+
+class SPI_WS2812_LEDStrip:
+    def __init__(self, count=8, brightness=255, sequence='GRB', bus=0, device=0):
+        self.set_led_type(sequence)
+        self.set_led_count(count)
+        self.set_led_brightness(brightness)
+        self.led_begin(bus, device)
+        self.set_all_led_color(0, 0, 0)
+        self.lock = threading.Lock()
+
+    def set_led_type(self, rgb_type):
+        led_types = ['RGB', 'RBG', 'GRB', 'GBR', 'BRG', 'BGR']
+        offsets = [0x06, 0x09, 0x12, 0x21, 0x18, 0x24]
+        try:
+            idx = led_types.index(rgb_type)
+            offset = offsets[idx]
+            self.led_red_offset = (offset >> 4) & 3
+            self.led_green_offset = (offset >> 2) & 3
+            self.led_blue_offset = offset & 3
+        except ValueError:
+            self.led_red_offset, self.led_green_offset, self.led_blue_offset = 1, 0, 2
+
+    def set_led_count(self, count):
+        self.led_count = count
+        self.led_color = [0] * (count * 3)
+        self.led_original_color = [0] * (count * 3)
+
+    def set_led_brightness(self, brightness):
+        self.led_brightness = brightness
+        for i in range(self.led_count):
+            self.set_led_rgb_data(i, [0, 0, 0])
+
+    def set_ledpixel(self, index, r, g, b):
+        p = [0, 0, 0]
+        p[self.led_red_offset] = round(r * self.led_brightness / 255)
+        p[self.led_green_offset] = round(g * self.led_brightness / 255)
+        p[self.led_blue_offset] = round(b * self.led_brightness / 255)
+        for i, color in enumerate((r, g, b)):
+            self.led_original_color[index * 3 + i] = color
+        for i in range(3):
+            self.led_color[index * 3 + i] = p[i]
+
+    def set_led_rgb_data(self, index, color):
+        self.set_ledpixel(index, *color)
+
+    def set_all_led_color(self, r, g, b):
+        for i in range(self.led_count):
+            self.set_ledpixel(i, r, g, b)
+        self.show()
+
+    def led_begin(self, bus=0, device=0):
+        self.bus, self.device = bus, device
+        try:
+            self.spi = spidev.SpiDev()
+            self.spi.open(bus, device)
+            self.spi.mode = 0
+            self.led_init_state = 1
+        except OSError:
+            print("SPI init failed. Check config.txt and raspi-config.")
+            self.led_init_state = 0
+
+    def check_spi_state(self):
+        return self.led_init_state
+
+    def show(self):
+        d = numpy.array(self.led_color).ravel()
+        tx = numpy.zeros(len(d) * 8, dtype=numpy.uint8)
+        for ibit in range(8):
+            tx[7 - ibit::8] = ((d >> ibit) & 1) * 0x78 + 0x80
+        if self.led_init_state:
+            speed = int(8 / (1.25e-6 if self.bus == 0 else 1.0e-6))
+            self.spi.xfer(tx.tolist(), speed)
+
+    def led_close(self):
+        self.set_all_led_color(0, 0, 0)
+        self.spi.close()
+
+    def rhythm_wave(self, frame):
+        colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0), (255, 0, 255), (0, 255, 255)]
+        count = self.led_count
+        base = (frame // 20) % len(colors)
+        self.set_all_led_color(0, 0, 0)
+        for i in range(count):
+            phase = (frame + i * 6) % (count * 12)
+            bright = phase / (count * 6) if phase < count * 6 else (count * 12 - phase) / (count * 6)
+            color = colors[(base + i) % len(colors)]
+            scaled = [int(c * bright) for c in color]
+            self.set_ledpixel(i, *scaled)
+        self.show()

led_control.py

@@ -0,0 +1,49 @@
+import pygame
+from gpiozero import Motor
+
+class MotorController:
+    def __init__(self, left_pins=(24, 23), right_pins=(5, 6)):
+        self.left = Motor(forward=left_pins[0], backward=left_pins[1])
+        self.right = Motor(forward=right_pins[0], backward=right_pins[1])
+
+    def stop(self):
+        self.left.stop()
+        self.right.stop()
+
+    def forward(self, speed=1.0):
+        self.left.forward(speed)
+        self.right.forward(speed)
+
+    def backward(self, speed=1.0):
+        self.left.backward(speed)
+        self.right.backward(speed)
+
+    def turn_left(self, speed=1.0):
+        self.left.backward(speed)
+        self.right.forward(speed)
+
+    def turn_right(self, speed=1.0):
+        self.left.forward(speed)
+        self.right.backward(speed)
+
+    def control_mode_2(self, keys, speed):
+        left_active = right_active = False
+        if keys[pygame.K_q]:
+            self.left.forward(speed)
+            left_active = True
+        elif keys[pygame.K_a]:
+            self.left.backward(speed)
+            left_active = True
+        else:
+            self.left.stop()
+
+        if keys[pygame.K_w]:
+            self.right.forward(speed)
+            right_active = True
+        elif keys[pygame.K_s]:
+            self.right.backward(speed)
+            right_active = True
+        else:
+            self.right.stop()
+
+        return left_active, right_active