Upload 7 files

Celsia.py

@@ -0,0 +1,186 @@
+import cv2
+import numpy as np
+from sklearn import svm
+import os
+import random
+from concurrent.futures import ThreadPoolExecutor
+from joblib import dump, load
+import pytesseract
+from tqdm import tqdm
+
+pytesseract.pytesseract.tesseract_cmd = '/opt/homebrew/bin/tesseract'
+dir_names = []
+
+try:
+    clf = load('contour.joblib')
+except:
+    def load_data(batch_size=100):
+        global dir_names
+        img_shape = (300, 700)
+        dir_names = ['organized_spectrograms/' + d for d in os.listdir('organized_spectrograms') if not d == ".DS_Store" and not '.py' in d]
+        X, y = [], []
+
+        def load_and_resize_image(f):
+            return cv2.resize(cv2.imread(os.path.join(dir_name, f), 0), img_shape)
+
+        for i, dir_name in tqdm(enumerate(dir_names), desc="Loading Directories", total=len(dir_names)):
+            with ThreadPoolExecutor(max_workers=20) as executor:
+                images = list(executor.map(load_and_resize_image, [f for f in os.listdir(dir_name) if f.endswith('.jpg') or f.endswith('.png')]))
+
+            if not images:
+                print(f'Error: No images found in {dir_name}')
+                continue
+
+            X.extend([img.flatten() for img in images])
+            y.extend([i] * len(images))
+
+            if len(X) >= batch_size:
+                yield np.array(X), np.array(y)
+                X, y = [], []
+
+        if X and y:
+            yield np.array(X), np.array(y)
+
+    def train_classifier_in_batches(batch_generator, batch_size=100):
+        clf = svm.SVC()
+
+        for X_batch, y_batch in tqdm(batch_generator, desc="Training SVM in Batches"):
+            if X_batch.size > 0 and y_batch.size > 0:
+                clf.fit(X_batch, y_batch)
+
+        dump(clf, 'contour.joblib')
+
+    def process_image(clf, dir_names, min_size, max_size, image_path, num_classes_to_detect):
+        img_shape = (300, 700)  # This is the shape used during training
+
+        # Load the image from the file
+        screenshot = cv2.imread(image_path)
+        screenshot_gray = cv2.cvtColor(screenshot, cv2.COLOR_BGR2GRAY)
+
+        _, thresh = cv2.threshold(screenshot_gray, 127, 255, 0)
+        contours, _ = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+
+        avg_scores = np.zeros(len(dir_names))
+        num_rois, drawn_boxes, details = 0, [], []
+
+        def process_contour(contour):
+            nonlocal avg_scores, num_rois, drawn_boxes
+
+            x, y, w, h = cv2.boundingRect(contour)
+            if min_size <= w * h <= max_size:
+                roi = screenshot_gray[y:y + h, x:x + w]
+
+                # Resize the ROI to match the training shape
+                roi_resized = cv2.resize(roi, img_shape).flatten().reshape(1, -1)
+                scores = clf.decision_function(roi_resized)[0]
+
+                # Get the indices of the top-N classes
+                top_indices = np.argsort(scores)[-num_classes_to_detect:]
+                for idx in top_indices:
+                    avg_scores[idx] += scores[idx]
+
+                num_rois += 1
+
+                max_score_index = np.argmax(scores)
+                color_str = dir_names[max_score_index]
+                color_hash = hash(color_str) & 0xffffff
+                color_bgr = ((color_hash >> 16) & 0xff), ((color_hash >> 8) & 0xff), (color_hash & 0xff)
+                cv2.rectangle(screenshot, (x, y), (x + w, y + h), color_bgr, 2)
+                drawn_boxes.append({'x': x, 'y': y, 'w': w, 'h': h})
+
+                negative_dir_name = f"{dir_names[max_score_index]}_negative"
+                if not os.path.exists(negative_dir_name):
+                    os.makedirs(negative_dir_name)
+                cv2.imwrite(os.path.join(negative_dir_name, str(random.randint(1, 999999999)) + '.png'), roi)
+
+        with ThreadPoolExecutor(max_workers=5) as executor:
+            executor.map(process_contour, contours)
+
+        if num_rois > 0:
+            avg_scores /= num_rois
+        else:
+            print('Warning: No ROIs were processed')
+
+        return screenshot, avg_scores, details
+
+    def draw_menu(screenshot, detected_classes, max_menu_width=200, item_height=30, font_scale=0.5):
+        # Determine the dimensions of the screenshot
+        screenshot_height, screenshot_width = screenshot.shape[:2]
+
+        # Calculate menu height based on the number of detected classes
+        num_items = len(detected_classes)
+        menu_height = num_items * item_height + 20  # Additional space for padding
+
+        # Set menu width to be the smaller of the max_menu_width or a portion of the screenshot width
+        menu_width = min(max_menu_width, screenshot_width // 4)
+
+        # Create blank menu image with the determined size
+        menu_img = np.zeros((menu_height, menu_width, 3), dtype=np.uint8)
+
+        for i, class_name in enumerate(detected_classes):
+            # Generate color based on the detected class name using hash function
+            color_hash = hash(class_name) & 0xffffff
+            color_bgr = ((color_hash >> 16) & 0xff), ((color_hash >> 8) & 0xff), (color_hash & 0xff)
+
+            # Draw color swatch and class name on menu image
+            cv2.rectangle(menu_img, (10, i * item_height + 10), (40, i * item_height + item_height), color_bgr, -1)
+            cv2.putText(menu_img, class_name, (50, i * item_height + item_height // 2 + 5), cv2.FONT_HERSHEY_SIMPLEX, font_scale, (255, 255, 255), 1, cv2.LINE_AA)
+
+        # Adjust total dimensions to fit the menu
+        total_height = max(screenshot.shape[0], menu_height)
+        total_width = screenshot.shape[1] + menu_width
+
+        # Create a new blank image with the required size
+        new_image = np.zeros((total_height, total_width, 3), dtype=np.uint8)
+
+        # Place the original screenshot in the new image
+        new_image[:screenshot.shape[0], :screenshot.shape[1]] = screenshot
+
+        # Place the menu at the right side of the new image
+        new_image[:menu_height, -menu_width:] = menu_img
+
+        return new_image
+
+
+def save_image(image, file_path):
+    """Saves the given image to the specified file path."""
+    cv2.imwrite(file_path, image)
+    print(f"Image saved to {file_path}")
+
+
+def display_image(image):
+    save_image(image,'finalle.png')
+    cv2.imshow('Processed Image', image)
+    key = cv2.waitKey(0)
+    return key
+
+
+
+# Load data in batches and train classifiers
+batch_generator = load_data(batch_size=100)  # Adjust batch size as needed
+train_classifier_in_batches(batch_generator)
+
+# Load the trained model
+clf = load('contour.joblib')
+
+menu_height = 10
+menu_width = 10
+
+while True:
+    num_classes_to_detect = int(input('Enter the number of top classes to detect: '))
+    min_size = int(input('Enter minimum size for ROIs (width*height): '))
+    max_size = int(input('Enter maximum size for ROIs (width*height): '))
+    image_path = input('Enter the path of the image you want to process: ')
+    screenshot, avg_scores, details = process_image(clf, dir_names, min_size, max_size, image_path, num_classes_to_detect)
+
+    # Only display the detected classes
+    top_indices = np.argsort(avg_scores)[-num_classes_to_detect:]
+    detected_classes = [dir_names[i] for i in top_indices]
+
+    screenshot = draw_menu(screenshot, detected_classes, menu_height, menu_width)
+    key = display_image(screenshot)
+
+    if key == ord('r'):
+        continue
+    else:
+        break

clustering.py

@@ -0,0 +1,31 @@
+import os
+from shutil import copyfile
+from tqdm import tqdm  # Import tqdm for progress bars
+
+def organize_images_by_class(input_folder, output_folder):
+    # Create output folder if it doesn't exist
+    if not os.path.exists(output_folder):
+        os.makedirs(output_folder)
+
+    # Get a list of all spectrogram images
+    spectrogram_files = [f for f in os.listdir(input_folder) if f.endswith('.png')]
+
+    # Organize files by class names
+    print("Organizing files by class names...")
+    for file in tqdm(spectrogram_files, desc="Copying Files"):
+        # Extract class name from the filename
+        class_name = " ".join(file.split(" ")[:-1])  # Assuming class name is everything except the last part
+        class_folder = os.path.join(output_folder, class_name)
+
+        # Create class folder if it doesn't exist
+        if not os.path.exists(class_folder):
+            os.makedirs(class_folder)
+
+        # Copy the file to the respective class folder
+        copyfile(os.path.join(input_folder, file), os.path.join(class_folder, file))
+
+if __name__ == "__main__":
+    input_folder = 'spectrograms'  # Input folder containing spectrogram images
+    output_folder = 'organized_spectrograms'  # Output folder for organized images
+
+    organize_images_by_class(input_folder, output_folder)

contour.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4c78563286a55ff397879c5d1cdc0b7119114462767c8311f8a687ee11a97014
+size 158002621

inference.py

@@ -1,21 +1,85 @@
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.io import wavfile
+from scipy import signal
+from PIL import Image
 
-# Example usage
-if __name__ == "__main__":
-    # Load model and label encoder
-    def load_model_and_encoder(model_path, label_encoder_path):
-        model = tf.keras.models.load_model(model_path)
-        classes = np.load(label_encoder_path, allow_pickle=True)
-        label_encoder = LabelEncoder()
-        label_encoder.classes_ = classes
-        return model, label_encoder
+def create_spectrogram(wav_file, output_folder):
+    # Read the wav file
+    sample_rate, data = wavfile.read(wav_file)
+    
+    # Convert data to mono if it's stereo
+    if data.ndim == 2:
+        data = np.mean(data, axis=1)
+    
+    # Create the spectrogram
+    frequencies, times, spectrogram = signal.spectrogram(data, sample_rate)
+    
+    # Create the figure
+    plt.figure(figsize=(10, 4))
+    
+    # Plot the spectrogram
+    plt.pcolormesh(times, frequencies, 10 * np.log10(spectrogram), shading='gouraud', cmap='inferno')
+    
+    # Set the y-axis limit to the Nyquist frequency
+    plt.ylim(0, sample_rate / 2)
+
+    # Remove axes and labels
+    plt.axis('off')
+    
+    # Get the current axis
+    ax = plt.gca()
+    
+    # Set the x-axis limits to start from 0 to the last time point
+    ax.set_xlim(0, times[-1])
+    
+    # Fill the area to the right of the spectrogram with black
+    ax.add_patch(plt.Rectangle((times[-1], 0), 10, sample_rate / 2, facecolor='black', edgecolor='none'))
+
+    # Save the spectrogram image
+    filename = os.path.splitext(os.path.basename(wav_file))[0] + '.png'
+    plt.savefig(os.path.join(output_folder, filename), bbox_inches='tight', pad_inches=0)
+    plt.close()
+
+    # Convert white pixels to black
+    convert_white_to_black(os.path.join(output_folder, filename))
 
-    model_path = 'sound_classification_model.h5'
-    label_encoder_path = 'label_encoder.npy'
-    audio_path = 'Emmi Elliott - Face to Face.wav'
+def convert_white_to_black(image_path):
+    # Open the image
+    img = Image.open(image_path)
+    
+    # Convert the image to RGB (if not already in that mode)
+    img = img.convert("RGB")
+    
+    # Get the data of the image
+    data = np.array(img)
 
-    model, label_encoder = load_model_and_encoder(model_path, label_encoder_path)
+    # Create a mask for white pixels
+    white_pixels = (data[:, :, 0] == 255) & (data[:, :, 1] == 255) & (data[:, :, 2] == 255)
 
-    sound_identifications = classify_audio(audio_path, model, label_encoder)
+    # Change white pixels to black
+    data[white_pixels] = [0, 0, 0]
 
-    for time, label in sound_identifications:
-        print(f'[{time:.2f} seconds] Class: {label}')
+    # Create a new image from the modified data
+    new_img = Image.fromarray(data)
+    
+    # Save the modified image
+    new_img.save(image_path)
+
+def convert_wav_to_spectrograms(input_folder, output_folder):
+    # Create output folder if it doesn't exist
+    if not os.path.exists(output_folder):
+        os.makedirs(output_folder)
+
+    # Iterate through all files in the input folder
+    for file in os.listdir(input_folder):
+        if file.endswith('.wav'):
+            wav_file_path = os.path.join(input_folder, file)
+            create_spectrogram(wav_file_path, output_folder)
+            print(f"Converted {file} to spectrogram.")
+
+if __name__ == "__main__":
+    input_folder = 'dataset'  # Input folder containing WAV files
+    output_folder = 'spectrograms'  # Output folder for spectrogram images
+    convert_wav_to_spectrograms(input_folder, output_folder)

spectrograms.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7b5205e9692cf341d2616c815d9c33e7e2bc23bccd42d5fad97bc74efd80104c
+size 320872300