Advanced Image Processor

A professional-grade JavaFX application featuring 8 sophisticated image processing filters with high-performance tile-based processing, real-time feedback, and intuitive user interface.

Table of Contents

• Application Screenshots
• Features Overview
• System Requirements
• Quick Start Guide
• User Guide
• Architecture & Technical Details
• Advanced Configuration
• Testing & Validation
• Troubleshooting
• Development & Extension
• Performance Metrics
• Security & Reliability
• API Reference
• Use Cases
• Future Roadmap
• Changelog
• Contributing
• Support & Community
• License & Attribution
• Acknowledgments
• Success Stories

---

Application Screenshots

<div align="center"> <h3>Main Application Interface</h3> <img src="/screenshots/image.png" width="800" alt="Main Application Interface"> <h3>Filter Demonstration - Original Image</h3> <img src="/screenshots/original.png" width="600" alt="Original Image"> <h3>Grayscale Filter Applied</h3> <img src="/screenshots/grayscalex.png" width="600" alt="Grayscale Filter"> <h3>Sepia Filter Dropdown</h3> <img src="/screenshots/image2.png" width="600" alt="Sepia Filter"> <h3>Sepia Filter Applied</h3> <img src="/screenshots/sepia.png" width="600" alt="Sepia Filter"> <h3>Sharpen Filter</h3> <img src="/screenshots/sharpen.png" width="600" alt="Color Boost Filter"> </div>

---

Features Overview

Core Capabilities

• 8 Professional Image Filters - Industry-standard image processing algorithms
• High-Performance Processing - Tile-based parallel processing with sub-second results
• Real-time Feedback - Live processing status and performance metrics
• Dual Processing Modes - Asynchronous (recommended) and synchronous processing
• Multiple Sample Images - Built-in test images for immediate experimentation
• Professional UI - Clean, intuitive JavaFX interface with instant response

Advanced Filters Available

1. Grayscale - Classic black and white conversion using luminance weighting
2. Sepia - Vintage sepia tone effect with warm brown tones
3. Blur - Gaussian blur with customizable intensity and kernel size
4. Sharpen - Image sharpening enhancement using convolution matrix
5. Edge Detection - Sobel operator-based edge detection algorithm
6. Emboss - 3D embossed effect with directional lighting simulation
7. Vintage - Retro look with color grading and vignette effect
8. Color Boost - HSV-based saturation enhancement for vivid colors

User Interface Features

• Filter Dropdown - Easy selection from 8 professional filters
• Processing Controls - Async/Sync toggle and tile size adjustment (20-100px)
• Sample Image Buttons - Quick switching between test images
• Real-time Log - Detailed processing feedback and timing information
• Progress Indicators - Visual feedback during image processing
• Performance Metrics - Processing time and efficiency measurements

---

System Requirements

Prerequisites

• Java Development Kit (JDK) 21+ (Oracle JDK or OpenJDK)
• Maven 3.6+ (Maven wrapper included - no separate installation needed)
• Operating System: macOS (ARM64/Intel), Linux, or Windows 10+
• Memory: 2GB RAM minimum (4GB+ recommended for large images)
• Display: 800x600 minimum resolution

Verified Compatibility

• ✅ macOS 12+ (Apple Silicon & Intel)
• ✅ Ubuntu 20.04+ / CentOS 8+
• ✅ Windows 10 / Windows 11
• ✅ OpenJDK 21 / Oracle JDK 21

---

Quick Start Guide

1. Download and Setup

# Clone the repository
git clone https://github.com/sandyp025/ImageProcessorApp.git
cd ImageProcessorApp

# Verify Java version (should be 21+)
java --version

# Build and run in one command
./mvnw clean compile javafx:run

2. Expected Startup Sequence

When you run ./mvnw javafx:run, you should see:

Starting Advanced Image Processor...
Advanced Image Processor - Starting...
Default image loaded: quino-al-mBQIfKlvowM-unsplash.jpg
Application started successfully!

3. Application Window

The JavaFX window opens with:

• Title: "Advanced Image Processor - Made in India by Sandip Mandal"
• Current Image Info: Shows loaded image name and dimensions
• Filter Selection: Dropdown with 8 professional filters
• Processing Controls: Async/Sync toggle and tile size slider
• Sample Image Buttons: Landscape, City, Portrait, Original
• Processing Log: Real-time status updates and performance metrics

---

User Guide

Basic Workflow (2-Minute Quick Start)

1. Launch Application: Run ./mvnw javafx:run
2. Select Filter: Choose from the dropdown (e.g., "Sepia")
3. Click "Apply Filter": Process the default image
4. Check Output: See results in output/ directory
5. Try Different Images: Click sample image buttons to switch

Step-by-Step Image Processing

1. Choose Image Source:

   • Click Landscape for nature scenes
   • Click City for urban photography
   • Click Portrait for people photos
   • Click Original for the default demo image

2. Select Processing Filter:

   • Grayscale - Perfect for classic black & white
   • Sepia - Ideal for vintage/nostalgic effects
   • Blur - Great for background softening
   • Sharpen - Enhance image clarity and details
   • Edge Detection - Highlight boundaries and contours
   • Emboss - Create 3D relief effects
   • Vintage - Apply retro color grading
   • Color Boost - Make colors more vibrant

3. Configure Processing (Optional):

   • Asynchronous Processing ✅ (Recommended - keeps UI responsive)
   • Tile Size: 20-100px (smaller = more parallel processing)

4. Apply Filter:

   • Click "Apply Filter" button
   • Watch real-time progress in the log area
   • Processing typically completes in 200-500ms

5. Review Results:

   • Check the processing log for completion status
   • Find output files in the output/ directory
   • Files are named: filtered_[filter]_[original_name].png

Output Management

All processed images are automatically saved to:

ImageProcessorApp/output/
├── filtered_sepia_quino-al-mBQIfKlvowM-unsplash.jpg.png
├── filtered_grayscale_landscape.jpg.png
├── filtered_edge_detection_city.jpg.png
└── filtered_blur_portrait.jpg.png

Sample Images Included

• quino-al-mBQIfKlvowM-unsplash.jpg - Original demo image (loaded by default)
• landscape.jpg - Natural landscape photography
• city.jpg - Urban cityscape
• portrait.jpg - Portrait photography
• painting-mountain-lake-with-mountain-background.jpg - Artistic landscape

Performance Tips

• Use Async Processing for better UI responsiveness
• Smaller tile sizes (20-30px) = more parallelism but higher overhead
• Larger tile sizes (60-100px) = less overhead but reduced parallelism
• Default tile size (40px) is optimized for most scenarios

---

Architecture & Technical Details

Current Application Structure

src/main/java/com/my/app/
├── WorkingHelloApplication.java   # Main production JavaFX application
├── HelloApplication.java          # Advanced UI version (full-featured)  
├── SimpleTestApp.java             # Minimal test application
├── filters/
│   ├── ImageFilter.java          # Core filter interface
│   ├── FilterFactory.java        # Centralized filter registry
│   └── impl/                     # Professional filter implementations
│       ├── GreyScaleFilter.java     # Luminance-based B&W conversion
│       ├── SepiaFilter.java         # Vintage sepia tone effect
│       ├── BlurFilter.java          # Gaussian blur with custom kernels
│       ├── SharpenFilter.java       # Convolution-based sharpening
│       ├── EdgeDetectionFilter.java # Sobel operator edge detection
│       ├── EmbossFilter.java        # 3D emboss with directional lighting
│       ├── VintageFilter.java       # Color grading + vignette effect
│       └── ColorBoostFilter.java    # HSV saturation enhancement
├── processor/
│   └── ImageProcessor.java       # High-performance tile-based engine
├── io/
│   ├── ImageFileIO.java         # Multi-format I/O operations
│   └── ImageOperations.java     # File operation interface
└── image/
    ├── ImageData.java           # Image metadata handling
    └── DrawMultipleImagesOnCanvas.java # Canvas rendering

src/main/resources/              # Sample images (5 high-quality test images)
output/                         # Processed image output directory

Architecture Diagram

<h3></h3> <img src="/screenshots/arc.png" width="600" alt="Color Boost Filter">

Performance Architecture

Tile-based Parallel Processing

• Dynamic Tile Sizing: Configurable 20-100px tiles for optimal performance
• Multi-threading: ExecutorService with CPU core-optimized thread pools
• Memory Efficiency: Processes large images without memory overflow
• Load Balancing: Automatic work distribution across available cores

Real-world Performance Results

Based on testing with the current application:

Image: 1920×1080 (2MP)  | Tile Size