Update TheImaniPulator.java

README.md

@@ -0,0 +1,187 @@
+# Image Processor Documentation
+
+## Project Overview
+A JavaFX-based image processing application that provides various image manipulation features, color analysis, and special effects including Game of Life simulation and image-to-music conversion. The application demonstrates advanced Java concepts while maintaining a user-friendly interface.
+
+## Core Concepts Used
+
+### Object-Oriented Programming
+- Inheritance: Main application extends `Application` class (`TheImaniPulator.java`)
+- Encapsulation: Private fields and methods throughout classes
+- Polymorphism: Method overriding (`ColorCount.compareTo()`)
+- Inner Classes: `ColorCount` class inside `TheImaniPulator`
+
+### JavaFX Concepts
+* Scene Graph Architecture: Hierarchical layout using `VBox`, `HBox`, `GridPane`
+* Event Handling: Button actions and mouse events
+* Property Binding: Image and effect bindings
+* UI Controls: `Button`, `Label`, `ImageView`, etc.
+* Custom Styling: CSS-like styling through Java
+* Animation: `FadeTransition`, `Timeline` for Game of Life
+
+### Advanced Java Concepts
+* Concurrency: `ExecutorService`, `ConcurrentHashMap` in color analysis
+* Lambda Expressions: Event handlers and thread operations
+* Stream API: Collection processing
+* Thread Management: `Platform.runLater()` for UI updates
+* Atomic Operations: `AtomicReference` in Game of Life
+* Resource Management: Image loading/saving operations
+
+### Core Java Features
+* **Generics**
+  - Parameterized collections (`LinkedList<String>`, `PriorityQueue<ColorCount>`)
+  - Type-safe operations in collections
+
+* **Collections Framework**
+  - `PriorityQueue` for color sorting
+  - `ConcurrentHashMap` for thread-safe color counting
+  - `LinkedList` for storing analysis results
+
+* **I/O Operations**
+  - `ImageIO` for image reading/writing
+  - `File` handling with exception management
+  - Buffered operations for efficient I/O
+
+* **Exception Handling**
+  - Custom error dialogs using `Alert`
+  - Try-catch blocks with specific handling
+  - Resource management with try-with-resources
+
+## Features and Implementation
+
+### Core Features
+1. **Image Loading and Display**
+   - File chooser dialog for image selection
+   - Responsive image display with preservation ratio
+
+2. **Image Filters**
+   - Blur: `GaussianBlur` with bloom effects
+   - Grayscale: `ColorAdjust` with saturation manipulation
+   - Sepia: `SepiaTone` with custom parameters
+   - Vignette: Custom shadow effects
+
+3. **Color Analysis**
+   - Parallel processing of image pixels
+   - Frequency analysis of colors
+   - Top 10 colors display with pixel counts
+
+4. **Game of Life**
+   - Image conversion to binary state
+   - Cellular automaton implementation
+   - Chunked processing for performance
+   - Animated transitions between states
+
+5. **Image to Music**
+   - Pixel data conversion to audio signals
+   - Real-time playback capabilities
+
+## Technical Implementation Details
+
+### Memory Management
+```java
+// Efficient image scaling
+int width = 640;
+int height = (int) (source.getHeight() * (640.0 / source.getWidth()));
+```
+- Dynamic memory allocation based on image size
+- Automatic garbage collection consideration
+- Resource cleanup in image processing
+
+### Parallel Processing
+```java
+ExecutorService executor = Executors.newFixedThreadPool(numThreads);
+int rowsPerThread = height / numThreads;
+```
+- Thread pool management
+- Work distribution strategies
+- Synchronization mechanisms
+
+### Event Dispatch
+```java
+Platform.runLater(() -> {
+    Alert alert = new Alert(AlertType.INFORMATION);
+    // UI updates
+});
+```
+- JavaFX Application Thread management
+- Event queue handling
+- UI thread safety
+
+### Threading Model
+- Main UI thread for interface responsiveness
+- Background threads for heavy processing
+- Thread synchronization for shared resources
+- Thread pool management for parallel operations
+
+### Data Flow
+```java
+// Example of data pipeline
+Image -> PixelReader -> Processing -> WritableImage -> ImageView
+```
+- Efficient data transformation
+- Minimal copying of large data structures
+- Stream-based processing where applicable
+
+### State Management
+```java
+private Button activeButton = null;
+private Image originalImage;
+```
+- Clear state tracking
+- Atomic operations for thread safety
+- Consistent state management
+
+### Optimization Techniques
+* **Lazy Loading**
+  - Deferred initialization of heavy resources
+  - On-demand processing
+  - Cached results where appropriate
+
+* **Memory Usage**
+  - Image scaling before processing
+  - Efficient data structures
+  - Resource cleanup and management
+
+* **Processing Pipeline**
+  - Chunked processing for large images
+  - Parallel processing where beneficial
+  - Cancelable operations
+
+## Design Patterns
+* MVC-like Structure: Separation of UI and processing logic
+* Factory Pattern: Scene creation methods
+* Observer Pattern: Event handling implementation
+
+## Project Structure
+- `TheImaniPulator.java`: Main application class
+- `WelcomeScreen.java`: Initial welcome interface
+- `ImageProcessor.java`: Core image processing functionality
+- `GameOfLifeProcessor.java`: Game of Life implementation
+- Supporting classes for specific features
+
+### Notable High Effort Feature: Reset Button Implementation
+```java
+resetButton.setOnAction(e -> {
+    if (originalImage != null) {
+        GameOfLifeProcessor.stopGameOfLife();
+        setActiveButton(null);
+        imageView.setImage(originalImage);
+        imageView.setEffect(null);
+        updateStatus("Image Processor");
+    }
+});
+```
+The reset button implements a comprehensive state restoration mechanism. When triggered, it first checks if there's an original image to revert to. It then stops any running Game of Life simulation to prevent resource conflicts, clears the active button state for UI consistency, restores the original image to the ImageView, removes any applied effects (filters, animations, etc.), and updates the status label. This implementation ensures a clean slate by properly releasing resources and resetting all visual modifications while maintaining the original image data. The reset functionality is crucial for user experience, allowing users to undo all modifications without reloading the image.
+
+### Package Organization
+The project utilizes a well-structured package hierarchy to maintain code organization and separation of concerns. The root package `jfxlabproj` contains the main application classes, while specialized features are organized into sub-packages. For instance, `jfxlabproj.gameoflife` encapsulates the Game of Life functionality, and `jfxlabproj.musicplayer` contains music conversion and playback logic. This package structure not only improves code maintainability but also provides clear boundaries between different components of the application. Import statements are organized to clearly show dependencies between JavaFX components (`javafx.*`), utility classes (`java.util.*`), and project-specific implementations, making the codebase more navigable and reducing potential naming conflicts.
+
+## Conclusion
+This project demonstrates advanced Java and JavaFX concepts while maintaining clean code architecture and efficient processing methods. The modular design allows for easy extension and modification while ensuring robust performance and resource management.
+
+[Note: The implementation emphasizes both functionality and performance, utilizing modern Java features and best practices in software design.]
+
+
+## To run
+Compile: `javac -d bin --module-path lib --add-modules javafx.controls,javafx.graphics,javafx.base src/jfxlabproj/*.java`
+Run: `java --module-path lib --add-modules javafx.controls,javafx.graphics,javafx.base -cp bin jfxlabproj.TheImaniPulator`

lib/dependencies.md

@@ -0,0 +1 @@
+dependencies

lib/javafx.properties

@@ -0,0 +1,3 @@
+javafx.version=23.0.1
+javafx.runtime.version=23.0.1+4
+javafx.runtime.build=4

src/MusicPlayer.java

@@ -1,82 +0,0 @@
-package jfxlabproj.musicplayer;
-
-import java.util.Random;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-import javafx.scene.image.Image;
-import javafx.scene.image.PixelReader;
-import javafx.scene.paint.Color;
-import javax.sound.sampled.*;
-
-public class MusicPlayer {
-
-    private static final int BASE_NOTE = 262; // C4 note
-    private ScheduledExecutorService executor;
-    private volatile boolean isPlaying = false;
-
-    public void playImageAsMusic(Image image) {
-        if (image == null) return;
-        if (isPlaying) return; // Prevent starting multiple playbacks simultaneously
-
-        PixelReader reader = image.getPixelReader();
-        int width = (int) image.getWidth();
-        int height = (int) image.getHeight();
-
-        executor = Executors.newScheduledThreadPool(1);
-        isPlaying = true;
-        executor.scheduleAtFixedRate(
-            () -> {
-                Random random = new Random();
-                for (int y = 0; y < height; y++) {
-                    for (int x = 0; x < width; x++) {
-                        if (!isPlaying) return; // Stop processing if paused
-
-                        Color color = reader.getColor(x, y);
-                        double brightness = color.getBrightness();
-                        int note = BASE_NOTE + (int) (brightness * 300); // Vary note based on brightness, reduced range for smoother sound
-                        int duration = 150 + random.nextInt(150); // Randomize duration between 150ms and 300ms
-                        playTone(note, duration, 0.2f); // Reduce volume
-                    }
-                }
-            },
-            0,
-            300,
-            TimeUnit.MILLISECONDS
-        );
-    }
-
-    public void pauseMusic() {
-        if (executor != null) {
-            isPlaying = false;
-            executor.shutdown();
-        }
-    }
-
-    private void playTone(int hz, int duration, float volume) {
-        try {
-            byte[] buf = new byte[1];
-            AudioFormat audioFormat = new AudioFormat(44100, 8, 1, true, false);
-            SourceDataLine sdl = AudioSystem.getSourceDataLine(audioFormat);
-            sdl.open(audioFormat);
-            sdl.start();
-
-            FloatControl volumeControl = (FloatControl) sdl.getControl(
-                FloatControl.Type.MASTER_GAIN
-            );
-            volumeControl.setValue(20f * (float) Math.log10(volume)); // Set volume level
-
-            for (int i = 0; i < (duration * 44100) / 1000; i++) {
-                double angle = (i / (44100.0 / hz)) * 2.0 * Math.PI;
-                buf[0] = (byte) (Math.sin(angle) * 100.0); // Reduce amplitude for a softer sound
-                sdl.write(buf, 0, 1);
-            }
-
-            sdl.drain();
-            sdl.stop();
-            sdl.close();
-        } catch (LineUnavailableException e) {
-            e.printStackTrace();
-        }
-    }
-}

src/jfxlabproj/ImageProcessor.java

@@ -38,18 +38,23 @@ public class ImageProcessor {
         }
     }
 
-    public static void applyInvert(ImageView imageView) {
+    public static void applyVignette(ImageView imageView) {
         if (imageView.getImage() != null) {
-            ColorAdjust colorAdjust = new ColorAdjust();
-            colorAdjust.setBrightness(-1.0);
-            colorAdjust.setContrast(0);
-            colorAdjust.setHue(1.0);
-            colorAdjust.setSaturation(-1.0);
+            // Create radial gradient for vignette effect
+            double width = imageView.getImage().getWidth();
+            double height = imageView.getImage().getHeight();
+            double radius = Math.max(width, height) * 0.7; // Adjust this value to control vignette size
 
             InnerShadow innerShadow = new InnerShadow();
-            innerShadow.setRadius(5.0);
-            innerShadow.setColor(Color.rgb(255, 255, 255, 0.3));
-            innerShadow.setInput(colorAdjust);
+            innerShadow.setRadius(radius * 0.3);
+            innerShadow.setChoke(0.2);
+            innerShadow.setColor(Color.rgb(0, 0, 0, 0.7));
+
+            DropShadow dropShadow = new DropShadow();
+            dropShadow.setRadius(radius * 0.2);
+            dropShadow.setSpread(0.4);
+            dropShadow.setColor(Color.rgb(0, 0, 0, 0.6));
+            dropShadow.setInput(innerShadow);
 
             FadeTransition ft = new FadeTransition(
                 Duration.millis(300),
@@ -58,7 +63,7 @@ public class ImageProcessor {
             ft.setFromValue(0.7);
             ft.setToValue(1.0);
 
-            imageView.setEffect(innerShadow);
+            imageView.setEffect(dropShadow);
             ft.play();
         }
     }

src/jfxlabproj/MusicPlayer.java

@@ -0,0 +1,317 @@
+package jfxlabproj.musicplayer;
+
+import javafx.animation.AnimationTimer;
+import javafx.application.Platform;
+import javafx.scene.Scene;
+import javafx.scene.canvas.Canvas;
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.control.TextArea;
+import javafx.scene.image.Image;
+import javafx.scene.image.PixelReader;
+import javafx.scene.layout.VBox;
+import javafx.scene.paint.Color;
+import javafx.stage.Stage;
+import javafx.stage.StageStyle;
+import javax.sound.sampled.*;
+
+public class MusicPlayer {
+
+    private static final int SAMPLE_RATE = 44100;
+    private static final int SAMPLE_SIZE = 16;
+    private static final int CHANNELS = 2;
+    private static final boolean SIGNED = true;
+    private static final boolean BIG_ENDIAN = true;
+    private static final int VISUALIZER_WIDTH = 200;
+    private static final int VISUALIZER_HEIGHT = 80;
+    private static final int BUFFER_SIZE = 4096;
+    private static final int PIXEL_SKIP = 100; // Skip factor for pixel processing
+
+    private SourceDataLine line;
+    private boolean isPlaying = false;
+    private Thread playThread;
+    private byte[] audioBuffer;
+
+    private TextArea infoBox;
+    private Stage musicInfoStage;
+    private double progress = 0;
+    private Canvas visualizer;
+    private GraphicsContext gc;
+    private double[] audioData = new double[100];
+    private int audioDataIndex = 0;
+    private AnimationTimer visualizerTimer;
+    private double lastFrequency = 0;
+
+    public MusicPlayer() {
+        initializeUIComponents();
+        setupAudioLine();
+        audioBuffer = new byte[BUFFER_SIZE];
+    }
+
+    private void initializeUIComponents() {
+        visualizer = new Canvas(VISUALIZER_WIDTH, VISUALIZER_HEIGHT);
+        gc = visualizer.getGraphicsContext2D();
+        gc.setStroke(Color.web("#007AFF"));
+        gc.setLineWidth(2);
+
+        infoBox = new TextArea();
+        infoBox.setEditable(false);
+        infoBox.setWrapText(true);
+        infoBox.setPrefRowCount(6);
+        infoBox.setPrefColumnCount(30);
+        infoBox.setStyle(
+            "-fx-font-family: 'SF Pro Text'; -fx-font-size: 14px;"
+        );
+        infoBox.setText(
+            "Image to Music Conversion:\n\n" +
+            "1. RGB to frequency mapping\n" +
+            "2. Brightness controls volume\n" +
+            "3. Frequency ranges:\n" +
+            "   R: 20-400Hz | G: 400-4000Hz | B: 4000-20000Hz\n\n" +
+            "Currently processing: Initializing..."
+        );
+
+        VBox infoContainer = new VBox(10);
+        infoContainer.setStyle(
+            "-fx-padding: 10px; -fx-background-color: white;" +
+            "-fx-background-radius: 10px; -fx-effect: dropshadow(gaussian, rgba(0,0,0,0.1), 10, 0, 0, 5);"
+        );
+        infoContainer.getChildren().addAll(visualizer, infoBox);
+
+        musicInfoStage = new Stage(StageStyle.DECORATED);
+        musicInfoStage.setTitle("Music Generation");
+        musicInfoStage.setScene(new Scene(infoContainer));
+        musicInfoStage.setAlwaysOnTop(true);
+        musicInfoStage.setResizable(false);
+
+        visualizerTimer = new AnimationTimer() {
+            @Override
+            public void handle(long now) {
+                drawVisualizer();
+            }
+        };
+    }
+
+    private void drawVisualizer() {
+        gc.setFill(Color.WHITE);
+        gc.fillRect(0, 0, VISUALIZER_WIDTH, VISUALIZER_HEIGHT);
+
+        gc.beginPath();
+        gc.moveTo(0, VISUALIZER_HEIGHT / 2);
+
+        for (int i = 0; i < audioData.length; i++) {
+            double x = i * (VISUALIZER_WIDTH / (audioData.length - 1));
+            double y =
+                VISUALIZER_HEIGHT / 2 + (audioData[i] * VISUALIZER_HEIGHT) / 3;
+            gc.lineTo(x, y);
+        }
+
+        gc.stroke();
+    }
+
+    private void setupAudioLine() {
+        try {
+            AudioFormat format = new AudioFormat(
+                SAMPLE_RATE,
+                SAMPLE_SIZE,
+                CHANNELS,
+                SIGNED,
+                BIG_ENDIAN
+            );
+            DataLine.Info info = new DataLine.Info(
+                SourceDataLine.class,
+                format
+            );
+
+            if (!AudioSystem.isLineSupported(info)) {
+                throw new LineUnavailableException("Audio line not supported");
+            }
+
+            line = (SourceDataLine) AudioSystem.getLine(info);
+            line.open(format, BUFFER_SIZE);
+        } catch (LineUnavailableException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void playImageAsMusic(Image image) {
+        if (isPlaying) return;
+
+        musicInfoStage.show();
+        isPlaying = true;
+        line.start();
+        visualizerTimer.start();
+
+        playThread = new Thread(() -> {
+            try {
+                PixelReader pixelReader = image.getPixelReader();
+                int width = (int) image.getWidth();
+                int height = (int) image.getHeight();
+                int bufferIndex = 0;
+
+                for (int y = 0; y < height && isPlaying; y += PIXEL_SKIP) {
+                    for (int x = 0; x < width && isPlaying; x += PIXEL_SKIP) {
+                        Color color = pixelReader.getColor(x, y);
+
+                        // Map colors to pentatonic scale frequencies
+                        double baseFreq = 220.0; // A3
+                        int[] pentatonic = { 0, 2, 4, 7, 9, 12 }; // Pentatonic scale intervals
+                        int noteIndex = (int) (color.getRed() * 5);
+                        double redFreq =
+                            baseFreq *
+                            Math.pow(2, pentatonic[noteIndex] / 12.0);
+
+                        noteIndex = (int) (color.getGreen() * 5);
+                        double greenFreq =
+                            (baseFreq * 2) *
+                            Math.pow(2, pentatonic[noteIndex] / 12.0);
+
+                        noteIndex = (int) (color.getBlue() * 5);
+                        double blueFreq =
+                            (baseFreq * 4) *
+                            Math.pow(2, pentatonic[noteIndex] / 12.0);
+
+                        double targetFreq =
+                            (redFreq + greenFreq + blueFreq) / 3.0;
+
+                        // Slower, smoother transition
+                        lastFrequency =
+                            lastFrequency + (targetFreq - lastFrequency) * 0.1;
+                        double amplitude = color.getBrightness() * 0.3; // Reduced volume further
+
+                        audioData[audioDataIndex] = amplitude;
+                        audioDataIndex =
+                            (audioDataIndex + 1) % audioData.length;
+
+                        byte[] soundLeft = generateTone(
+                            lastFrequency,
+                            50,
+                            amplitude
+                        );
+                        byte[] soundRight = generateTone(
+                            lastFrequency * 1.003,
+                            50,
+                            amplitude * 0.95
+                        );
+                        byte[] stereoSound = mergeStereoChannels(
+                            soundLeft,
+                            soundRight
+                        );
+
+                        for (byte b : stereoSound) {
+                            audioBuffer[bufferIndex++] = b;
+                            if (bufferIndex == BUFFER_SIZE) {
+                                line.write(audioBuffer, 0, BUFFER_SIZE);
+                                bufferIndex = 0;
+                            }
+                        }
+
+                        final double currentProgress =
+                            (y * width + x) / (double) (width * height);
+                        final int currentY = y;
+                        Platform.runLater(() -> {
+                            progress = currentProgress;
+                            infoBox.setText(
+                                infoBox
+                                    .getText()
+                                    .replaceAll(
+                                        "Currently processing:.*",
+                                        String.format(
+                                            "Processing: Row %d of %d (%.1f%%)",
+                                            currentY,
+                                            height,
+                                            currentProgress * 100
+                                        )
+                                    )
+                            );
+                        });
+
+                        Thread.sleep(20); // Add slight delay between notes
+                    }
+                }
+
+                if (bufferIndex > 0) {
+                    line.write(audioBuffer, 0, bufferIndex);
+                }
+                line.drain();
+
+                Platform.runLater(() -> {
+                    infoBox.appendText("\n\nMusic generation complete!");
+                    visualizerTimer.stop();
+                });
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        });
+
+        playThread.start();
+    }
+
+    private byte[] mergeStereoChannels(byte[] left, byte[] right) {
+        byte[] stereo = new byte[left.length * 2];
+        for (int i = 0, j = 0; i < left.length; i += 2, j += 4) {
+            stereo[j] = left[i];
+            stereo[j + 1] = left[i + 1];
+            stereo[j + 2] = right[i];
+            stereo[j + 3] = right[i + 1];
+        }
+        return stereo;
+    }
+
+    private byte[] generateTone(
+        double frequency,
+        int duration,
+        double amplitude
+    ) {
+        int numSamples = (duration * SAMPLE_RATE) / 1000;
+        byte[] buffer = new byte[2 * numSamples];
+
+        for (int i = 0; i < numSamples; i++) {
+            double angle = (2.0 * Math.PI * i * frequency) / SAMPLE_RATE;
+            double sample =
+                Math.sin(angle) * 0.5 + // fundamental
+                Math.sin(2 * angle) * 0.1 + // second harmonic
+                Math.sin(4 * angle) * 0.05 + // fourth harmonic
+                Math.sin(angle / 2) * 0.1; // subharmonic
+
+            // Apply envelope for smoother sound
+            double envelope = Math.sin((Math.PI * i) / numSamples);
+            short value = (short) (amplitude *
+                Short.MAX_VALUE *
+                sample *
+                envelope);
+
+            buffer[2 * i] = (byte) (value >> 8);
+            buffer[2 * i + 1] = (byte) (value & 0xFF);
+        }
+
+        return buffer;
+    }
+
+    private void updateProgress(double value) {
+        progress = value;
+    }
+
+    public void pauseMusic() {
+        isPlaying = false;
+        visualizerTimer.stop();
+        if (line != null) {
+            line.stop();
+            line.flush();
+        }
+        if (playThread != null) {
+            playThread.interrupt();
+        }
+        musicInfoStage.hide();
+    }
+
+    public double getProgress() {
+        return progress;
+    }
+
+    public void cleanup() {
+        if (line != null) {
+            line.close();
+        }
+        visualizerTimer.stop();
+    }
+}

src/jfxlabproj/TheImaniPulator.java

@@ -3,7 +3,16 @@ package jfxlabproj;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.IOException;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.PriorityQueue;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
 import javafx.application.Application;
+import javafx.application.Platform;
 import javafx.embed.swing.SwingFXUtils;
 import javafx.geometry.Insets;
 import javafx.geometry.Pos;
@@ -14,6 +23,7 @@ import javafx.scene.control.Button;
 import javafx.scene.control.Label;
 import javafx.scene.image.Image;
 import javafx.scene.image.ImageView;
+import javafx.scene.image.PixelReader;
 import javafx.scene.layout.GridPane;
 import javafx.scene.layout.HBox;
 import javafx.scene.layout.VBox;
@@ -33,6 +43,99 @@ public class TheImaniPulator extends Application {
     private Button activeButton = null;
     private Label statusLabel;
 
+    // Store color frequency analysis results
+    private LinkedList<String> topColors;
+
+    // Helper class to store color counts for sorting
+    private class ColorCount implements Comparable<ColorCount> {
+
+        String hexColor;
+        int count;
+
+        ColorCount(String hexColor, int count) {
+            this.hexColor = hexColor;
+            this.count = count;
+        }
+
+        @Override
+        public int compareTo(ColorCount other) {
+            return other.count - this.count; // For descending order
+        }
+    }
+
+    // Method to analyze color frequencies in image
+    private void analyzeColors() {
+        if (originalImage == null) return;
+
+        // Use ConcurrentHashMap for thread safety
+        Map<String, Integer> colorFrequency = new ConcurrentHashMap<>();
+
+        // Get PixelReader to read image colors
+        PixelReader pixelReader = originalImage.getPixelReader();
+
+        int height = (int) originalImage.getHeight();
+        int width = (int) originalImage.getWidth();
+        int numThreads = Runtime.getRuntime().availableProcessors();
+        ExecutorService executor = Executors.newFixedThreadPool(numThreads);
+
+        // Split image into rows for parallel processing
+        int rowsPerThread = height / numThreads;
+
+        for (int i = 0; i < numThreads; i++) {
+            final int startY = i * rowsPerThread;
+            final int endY = (i == numThreads - 1)
+                ? height
+                : (i + 1) * rowsPerThread;
+
+            executor.submit(() -> {
+                for (int y = startY; y < endY; y++) {
+                    for (int x = 0; x < width; x++) {
+                        Color color = pixelReader.getColor(x, y);
+                        String hex = String.format(
+                            "#%02X%02X%02X",
+                            (int) (color.getRed() * 255),
+                            (int) (color.getGreen() * 255),
+                            (int) (color.getBlue() * 255)
+                        );
+                        colorFrequency.merge(hex, 1, Integer::sum);
+                    }
+                }
+            });
+        }
+
+        executor.shutdown();
+        try {
+            executor.awaitTermination(30, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            return;
+        }
+
+        // Priority queue to find top 10 colors
+        PriorityQueue<ColorCount> pq = new PriorityQueue<>();
+        for (Map.Entry<String, Integer> entry : colorFrequency.entrySet()) {
+            pq.offer(new ColorCount(entry.getKey(), entry.getValue()));
+        }
+
+        // Get top 10 colors
+        topColors = new LinkedList<>();
+        for (int i = 0; i < 10 && !pq.isEmpty(); i++) {
+            ColorCount cc = pq.poll();
+            topColors.add(
+                String.format("%s: %d pixels", cc.hexColor, cc.count)
+            );
+        }
+
+        // Show results in alert on JavaFX thread
+        Platform.runLater(() -> {
+            Alert alert = new Alert(AlertType.INFORMATION);
+            alert.setTitle("Color Analysis");
+            alert.setHeaderText("Top 10 Most Common Colors in this image:");
+            alert.setContentText(String.join("\n", topColors));
+            alert.showAndWait();
+        });
+    }
+
     @Override
     public void start(Stage primaryStage) {
         primaryStage.setTitle("Image Processor");
@@ -40,6 +143,12 @@ public class TheImaniPulator extends Application {
         Scene welcomeScene = WelcomeScreen.createScene(primaryStage);
         primaryStage.setScene(welcomeScene);
 
+        primaryStage.setOnCloseRequest(e -> {
+            if (musicPlayer != null) {
+                musicPlayer.pauseMusic();
+            }
+        });
+
         primaryStage.show();
     }
 
@@ -71,9 +180,13 @@ public class TheImaniPulator extends Application {
         );
 
         Button loadButton = new Button("Choose Image");
+        Button analyzeButton = new Button("Analyze Colors"); // New button for color analysis
         styleButton(loadButton);
+        styleButton(analyzeButton);
 
-        leftSide.getChildren().addAll(imageView, loadButton, statusLabel);
+        leftSide
+            .getChildren()
+            .addAll(imageView, loadButton, analyzeButton, statusLabel);
 
         VBox rightSide = new VBox(15);
         rightSide.setAlignment(Pos.TOP_CENTER);
@@ -93,11 +206,13 @@ public class TheImaniPulator extends Application {
         Label saveLabel = new Label("Save Options");
         Label specialLabel = new Label("Special Effects");
         Label musicLabel = new Label("Music Controls");
+        Label resetLabel = new Label("Reset Options");
 
         filterLabel.setStyle("-fx-font-weight: bold; -fx-font-size: 16px;");
         saveLabel.setStyle("-fx-font-weight: bold; -fx-font-size: 16px;");
         specialLabel.setStyle("-fx-font-weight: bold; -fx-font-size: 16px;");
         musicLabel.setStyle("-fx-font-weight: bold; -fx-font-size: 16px;");
+        resetLabel.setStyle("-fx-font-weight: bold; -fx-font-size: 16px;");
 
         Button blurButton = new Button("Blur");
         Button grayscaleButton = new Button("Grayscale");
@@ -109,21 +224,31 @@ public class TheImaniPulator extends Application {
         Button gameOfLifeButton = new Button("Game of Life");
         Button playMusicButton = new Button("Play as Music");
         Button pauseMusicButton = new Button("Pause Music");
-        Button invertButton = new Button("Invert Colors");
+        Button vignetteButton = new Button("Vignette");
+
+        // Style reset button differently
+        resetButton.setStyle(
+            "-fx-background-color: black;" +
+            "-fx-text-fill: white;" +
+            "-fx-font-family: 'SF Pro Text';" +
+            "-fx-font-size: 16px;" +
+            "-fx-padding: 12px 20px;" +
+            "-fx-background-radius: 10px;" +
+            "-fx-cursor: hand;"
+        );
 
         int buttonWidth = 150;
         for (Button btn : new Button[] {
             blurButton,
             grayscaleButton,
             sepiaButton,
-            resetButton,
             saveAsJpegButton,
             saveAsPngButton,
             saveAsHeifButton,
             gameOfLifeButton,
             playMusicButton,
             pauseMusicButton,
-            invertButton,
+            vignetteButton,
         }) {
             styleButton(btn);
             btn.setPrefWidth(buttonWidth);
@@ -136,8 +261,12 @@ public class TheImaniPulator extends Application {
         filterGrid.add(blurButton, 0, 0);
         filterGrid.add(grayscaleButton, 1, 0);
         filterGrid.add(sepiaButton, 0, 1);
-        filterGrid.add(resetButton, 1, 1);
-        filterGrid.add(invertButton, 0, 2);
+        filterGrid.add(vignetteButton, 0, 2);
+
+        GridPane resetGrid = new GridPane();
+        resetGrid.setHgap(10);
+        resetGrid.setVgap(10);
+        resetGrid.add(resetButton, 0, 0);
 
         GridPane saveGrid = new GridPane();
         saveGrid.setHgap(10);
@@ -155,6 +284,13 @@ public class TheImaniPulator extends Application {
         musicGrid.add(playMusicButton, 0, 0);
         musicGrid.add(pauseMusicButton, 1, 0);
 
+        analyzeButton.setOnAction(e -> {
+            if (originalImage != null) {
+                analyzeColors();
+                updateStatus("Analyzing Colors");
+            }
+        });
+
         blurButton.setOnAction(e -> {
             if (originalImage != null) {
                 setActiveButton(blurButton);
@@ -179,11 +315,11 @@ public class TheImaniPulator extends Application {
             }
         });
 
-        invertButton.setOnAction(e -> {
+        vignetteButton.setOnAction(e -> {
             if (originalImage != null) {
-                setActiveButton(invertButton);
-                ImageProcessor.applyInvert(imageView);
-                updateStatus("Invert Colors");
+                setActiveButton(vignetteButton);
+                ImageProcessor.applyVignette(imageView);
+                updateStatus("Vignette");
             }
         });
 
@@ -198,7 +334,7 @@ public class TheImaniPulator extends Application {
         });
 
         saveAsJpegButton.setOnAction(e -> {
-            saveImage(primaryStage, "jpeg");
+            saveImage(primaryStage, "jpg"); // Changed from jpeg to jpg
             updateStatus("Saving as JPEG");
         });
 
@@ -225,7 +361,10 @@ public class TheImaniPulator extends Application {
                 setActiveButton(playMusicButton);
                 musicPlayer = new MusicPlayer();
                 musicPlayer.playImageAsMusic(originalImage);
-                updateStatus("Playing Music");
+                updateStatus(
+                    "Playing Music - " +
+                    String.format("%.1f%%", musicPlayer.getProgress() * 100)
+                );
             }
         });
 
@@ -266,6 +405,8 @@ public class TheImaniPulator extends Application {
                 titleLabel,
                 filterLabel,
                 filterGrid,
+                resetLabel,
+                resetGrid,
                 saveLabel,
                 saveGrid,
                 specialLabel,
@@ -321,10 +462,29 @@ public class TheImaniPulator extends Application {
             File file = fileChooser.showSaveDialog(stage);
             if (file != null) {
                 try {
-                    BufferedImage bufferedImage = SwingFXUtils.fromFXImage(
-                        imageView.getImage(),
-                        null
+                    // Get the original image directly instead of taking a snapshot
+                    Image image = imageView.getImage();
+                    int width = (int) image.getWidth();
+                    int height = (int) image.getHeight();
+
+                    BufferedImage bufferedImage = new BufferedImage(
+                        width,
+                        height,
+                        BufferedImage.TYPE_INT_RGB
                     );
+
+                    PixelReader reader = image.getPixelReader();
+                    for (int x = 0; x < width; x++) {
+                        for (int y = 0; y < height; y++) {
+                            Color color = reader.getColor(x, y);
+                            int rgb =
+                                ((int) (color.getRed() * 255) << 16) |
+                                ((int) (color.getGreen() * 255) << 8) |
+                                ((int) (color.getBlue() * 255));
+                            bufferedImage.setRGB(x, y, rgb);
+                        }
+                    }
+
                     ImageIO.write(bufferedImage, format, file);
                 } catch (IOException ex) {
                     Alert alert = new Alert(AlertType.ERROR);