🚀 Harbeth: High-Performance Swift Image Processing Library

[yangKJ]

🚀 Harbeth: High-Performance Image Processing Library for Swift

Overview

Harbeth is a powerful Swift library for GPU-accelerated real-time image processing, camera capture, and video processing. Built on Metal technology, it provides developers with a comprehensive solution for creating stunning visual effects with minimal code.

🎨 Key Features

Rich Filter Ecosystem

• 200+ Built-in Filters covering color adjustment, blur effects, blend modes, edge detection, distortion, stylization, and more
• Combination Filters for complex, multi-step effects
• Custom Filter Support using LUTs (1D, 2D, 3D) and Metal shaders
• CoreImage & MPS Integration for maximum flexibility

Cross-Platform Support

• iOS 10.0+
• macOS 10.13+
• tvOS 12.0+
• watchOS 5.0+
• SwiftUI Native Integration

Performance Advantage

• 5x Faster than CPU processing for complex filter chains
• Real-time Capable - Maintain 60 FPS even with multiple filters
• Efficient Memory Usage with automatic texture pooling
• Scalable Performance - GPU time grows slowly with filter complexity

📸 Real-time Filter Effects

Harbeth delivers stunning visual effects with GPU-accelerated real-time processing:

• RGB Shift Glitch - Creates dynamic RGB channel separation with glitch art aesthetics
• Edge Glow Detection - Detects edges and adds neon glow effects in real-time

💻 macOS Support

Harbeth fully supports macOS with native AppKit integration, high-resolution support, and multi-window processing capabilities:

• Native AppKit integration - Works seamlessly with NSImage and AppKit components
• High-resolution support - Optimized for Retina displays and large image processing
• Drag & Drop support - Easy integration with macOS drag and drop functionality
• Performance optimized - Leverages full GPU power available on Mac devices
• Multi-window support - Process multiple images across different windows simultaneously

🚀 Getting Started

Method 1: HarbethIO (Recommended for batch processing)

let filter1 = C7ColorMatrix4x4(matrix: Matrix4x4.Color.sepia)
let filter2 = C7Granularity(grain: 0.8)
let filter3 = C7SoulOut(soul: 0.7)

let filters = [filter1, filter2, filter3]

// Synchronous processing
let dest = HarbethIO(element: originImage, filters: filters)
ImageView.image = try? dest.output()

// Asynchronous processing (recommended for large images)
dest.transmitOutput { result in
    switch result {
    case .success(let image):
        DispatchQueue.main.async {
            self.imageView.image = image
        }
    case .failure(let error):
        print("Processing failed: \(error)")
    }
}

Method 2: Direct Extension (Most concise)

// Apply filters directly to image
ImageView.image = try? originImage.make(filters: filters)

Method 3: Operator Chaining (Most expressive)

// Chain filters with intuitive operators
ImageView.image = originImage ->> filter1 ->> filter2 ->> filter3

🎭 Featured Filters

Artistic Style Filters

• C7PastelDream: Soft pastel dream effect with gentle colors and subtle blur
• C7NeonPunk: Vibrant neon punk style with glowing edges and high contrast
• C7Watercolor: Watercolor painting effect with soft edges and color bleeding
• C7Hologram: Futuristic holographic display with cyan tint and scan lines
• C7VintageFilmGrain: Old film stock simulation with grain and warm tones

Camera Style Filters

• C7FujiNC: Fuji film NC simulation with natural colors
• C7FujiCC: Fuji Classic Chrome style with low saturation and high texture
• C7Polaroid: Polaroid camera effect with border and vintage appearance
• C780sSynthwave: 80s synthwave aesthetic with neon colors and purple-blue tint

📊 Performance Comparison

Key Performance Benefits:

• GPU: 3.2ms → 15.8ms for 1-10 filters
• CPU: 12.5ms → 96.8ms for 1-10 filters
• Maintains 60 FPS (16.67ms threshold) even with 10 filters
• Efficient resource usage with automatic texture pooling

🔧 Integration

CocoaPods

pod 'Harbeth'

Swift Package Manager

dependencies: [
    .package(url: "https://github.com/yangKJ/Harbeth.git", branch: "master"),
]

📱 Use Cases

• Camera Apps: Real-time filter application during capture
• Photo Editors: Professional color grading and artistic effects
• Video Processing: Filtered video playback and editing
• Social Media: Enhanced image sharing with creative effects
• AR Applications: Visual effect enhancement for augmented reality
• Creative Tools: Artistic image manipulation for design applications
• Desktop Apps: High-quality image processing on macOS

🎨 SwiftUI Integration

import SwiftUI
import Harbeth

struct FilteredImageView: View {
    @State private var inputImage: UIImage = UIImage(named: "sample")!
    @State private var intensity: Float = 0.5
    
    var body: some View {
        VStack {
            HarbethView(image: inputImage, filters: [
                CIHighlight(highlight: intensity),
                C7WaterRipple(ripple: intensity),
            ]) { image in
                image
                    .resizable()
                    .aspectRatio(contentMode: .fit)
                    .cornerRadius(12)
                    .shadow(radius: 5)
            }
            
            Slider(value: $intensity, in: 0...1)
                .padding()
        }
        .padding()
    }
}

🌟 Why Harbeth?

• Performance: GPU-accelerated processing for real-time effects
• Simplicity: Intuitive API with chainable operations and operator overloading
• Flexibility: Supports multiple input sources (UIImage, CGImage, CIImage, MTLTexture, CMSampleBuffer, CVPixelBuffer)
• Extensibility: Easy to create custom filters and combination effects
• Documentation: Comprehensive guides and demo projects
• Active Development: Regular updates and improvements
• Cross-platform: Single codebase for all Apple platforms

📚 Documentation & Resources

• GitHub Repository: https://github.com/yangKJ/Harbeth
• Demo App: HarbethDemo
• API Reference: Comprehensive documentation in the repository
• Issue Tracker: GitHub Issues

🤔 FAQ

Q: How does Harbeth compare to other image processing libraries?
A: Harbeth offers better performance through Metal GPU acceleration, a more extensive filter collection, and a more intuitive API compared to many alternatives.

Q: Can I use Harbeth in production apps?
A: Yes, Harbeth is production-ready and used in many apps. It's stable, well-documented, and actively maintained.

Q: How do I create custom filters?
A: You can create custom filters by subclassing C7FilterProtocol or use LUTs for color grading effects.

Q: Does Harbeth support live camera feed processing?
A: Yes, Harbeth provides C7CollectorCamera for real-time camera processing with filters applied at 60 FPS.

Q: Is Harbeth compatible with SwiftUI?
A: Yes, Harbeth includes HarbethView for native SwiftUI integration.

📞 Support

If you have any questions, issues, or feature requests, please feel free to:

• Open an issue on GitHub
• Contact the author: yangkj310@gmail.com
• Follow the project on GitHub for updates

---

Have you used Harbeth in your projects? Share your experience and creative effects in the comments! Let's discuss how we can push the boundaries of image processing together.

#Harbeth #Swift #Metal #ImageProcessing #iOSDev #macOSDev #CreativeCoding