### Install Brightroom via Swift Package Manager

Source: https://github.com/muukii/brightroom/blob/main/README.md

Add the Brightroom dependency to your Package.swift file.

```swift
dependencies: [
    .package(url: "https://github.com/muukii/Brightroom.git", upToNextMajor: "2.2.0")
]
```

--------------------------------

### Initialize and manage EditingStack

Source: https://context7.com/muukii/brightroom/llms.txt

Configure the EditingStack with an ImageProvider and optional preset storage, then start it to enable editing operations.

```swift
import BrightroomEngine

// Basic initialization
let imageProvider = ImageProvider(image: UIImage(named: "photo")!)
let editingStack = EditingStack(imageProvider: imageProvider)

// With custom preset storage for LUT filters
let presetStorage = PresetStorage.default
try presetStorage.loadLUTs(fromBundle: .main)

let editingStack = EditingStack(
    imageProvider: imageProvider,
    presetStorage: presetStorage
)

// Start the editing stack (required before editing)
editingStack.start {
    // Called on main thread when preparation is complete
    print("EditingStack is ready for editing")
}

// Check if stack is loading
if editingStack.state.isLoading {
    print("Still loading image...")
}

// Access loaded state
if let loadedState = editingStack.state.loadedState {
    print("Image size: \(loadedState.imageSize)")
    print("Can undo: \(loadedState.canUndo)")
    print("Has changes: \(loadedState.isDirty)")
}
```

--------------------------------

### Create Grid Overlay for Crop View

Source: https://context7.com/muukii/brightroom/llms.txt

Defines a custom grid overlay using GeometryReader and Path to draw guide lines.

```swift
struct GridOverlay: View {
    var body: some View {
        GeometryReader { geometry in
            Path { path in
                let width = geometry.size.width
                let height = geometry.size.height

                // Vertical lines
                path.move(to: CGPoint(x: width / 3, y: 0))
                path.addLine(to: CGPoint(x: width / 3, y: height))
                path.move(to: CGPoint(x: 2 * width / 3, y: 0))
                path.addLine(to: CGPoint(x: 2 * width / 3, y: height))

                // Horizontal lines
                path.move(to: CGPoint(x: 0, y: height / 3))
                path.addLine(to: CGPoint(x: width, y: height / 3))
                path.move(to: CGPoint(x: 0, y: 2 * height / 3))
                path.addLine(to: CGPoint(x: width, y: 2 * height / 3))
            }
            .stroke(Color.white.opacity(0.5), lineWidth: 1)
        }
    }
}
```

--------------------------------

### Build Demo Apps with Fastlane

Source: https://github.com/muukii/brightroom/blob/main/CLAUDE.md

Builds the demo applications for Brightroom using Fastlane.

```bash
fastlane ios build_demo_apps
```

--------------------------------

### Loading and Applying LUT Filters

Source: https://context7.com/muukii/brightroom/llms.txt

Demonstrates loading .cube files from the app bundle into PresetStorage and applying them via EditingStack. Also shows manual creation of a FilterColorCube.

```swift
import BrightroomEngine

// Create preset storage and load LUTs from bundle
let presetStorage = PresetStorage(presets: [])

do {
    // Loads all .cube files from the main bundle
    try presetStorage.loadLUTs(fromBundle: .main)
    print("Loaded \(presetStorage.presets.count) filter presets")
} catch {
    print("Failed to load LUTs: \(error)")
}

// Use with EditingStack
let editingStack = EditingStack(
    imageProvider: imageProvider,
    presetStorage: presetStorage
)

// Access loaded presets after EditingStack is ready
editingStack.start {
    if let loaded = editingStack.state.loadedState {
        for preset in loaded.previewFilterPresets {
            print("Filter: \(preset.filter.name)")
            // preset.image contains preview with filter applied
        }
    }
}

// Apply a preset filter
editingStack.set(filters: { filters in
    filters.preset = presetStorage.presets.first
})

// Create custom FilterColorCube manually
let lutImage = ImageSource(image: UIImage(named: "MyLUT")!)
let customFilter = FilterColorCube(
    name: "Custom Vintage",
    identifier: "com.app.custom-vintage",
    lutImage: lutImage,
    dimension: 64  // LUT dimension (typically 64)
)

// Adjust filter intensity
var adjustableFilter = customFilter
adjustableFilter.amount = 0.7  // 0.0 to 1.0
```

--------------------------------

### Build Swift Package

Source: https://github.com/muukii/brightroom/blob/main/CLAUDE.md

Builds the Brightroom Swift package using the Swift Package Manager.

```bash
swift build
```

--------------------------------

### Implement Custom Crop View with SwiftUICropView

Source: https://context7.com/muukii/brightroom/llms.txt

Demonstrates basic usage of SwiftUICropView with state management for rotation, aspect ratio, and reset actions.

```swift
import SwiftUI
import BrightroomEngine
import BrightroomUI

struct CustomCropView: View {
    let editingStack: EditingStack

    @State private var rotation: EditingCrop.Rotation? = nil
    @State private var adjustmentAngle: EditingCrop.AdjustmentAngle? = nil
    @State private var aspectRatio: PixelAspectRatio? = nil
    @State private var resetAction = SwiftUICropView.ResetAction()

    var body: some View {
        VStack {
            SwiftUICropView(
                editingStack: editingStack,
                isGuideInteractionEnabled: true,
                isAutoApplyEditingStackEnabled: true,
                areAnimationsEnabled: true,
                stateHandler: { state in
                    // Handle crop state changes
                    if let proposedCrop = state.proposedCrop {
                        rotation = proposedCrop.rotation
                        adjustmentAngle = proposedCrop.adjustmentAngle
                    }
                }
            )
            .rotation(rotation)
            .adjustmentAngle(adjustmentAngle)
            .croppingAspectRatio(aspectRatio)
            .registerResetAction(resetAction)

            // Controls
            HStack {
                Button("Rotate") {
                    rotation = rotation?.next() ?? .angle_90
                }

                Button("Square") {
                    aspectRatio = .square
                }

                Button("16:9") {
                    aspectRatio = PixelAspectRatio(width: 16, height: 9)
                }

                Button("Reset") {
                    resetAction()
                }
            }
        }
        .onAppear {
            editingStack.start()
        }
    }
}
```

--------------------------------

### Open Development Workspace

Source: https://github.com/muukii/brightroom/blob/main/CLAUDE.md

Opens the Brightroom Xcode development workspace.

```bash
open Dev/Brightroom.xcodeproj
```

--------------------------------

### Implement Custom Image Editor

Source: https://github.com/muukii/brightroom/blob/main/CLAUDE.md

Demonstrates how to implement a custom image editor using EditingStack and ClassicImageEditViewController. Requires initializing EditingStack with an image provider and handling the completion of the editing process.

```swift
// 1. Create EditingStack with image
let stack = EditingStack(imageProvider: .init(image: uiImage))

// 2. Use built-in UI or create custom
let editor = ClassicImageEditViewController(editingStack: stack)

// 3. Handle completion
editor.handlers.didEndEditing = { stack in
    let rendered = try! stack.makeRenderer().render().uiImage
}
```

--------------------------------

### Create ImageProvider from various sources

Source: https://context7.com/muukii/brightroom/llms.txt

Initialize an ImageProvider to supply images to the EditingStack from different sources like UIImage, file URLs, remote URLs, or PHAssets.

```swift
import BrightroomEngine
import UIKit

// From UIImage (requires cgImage to be non-nil)
let uiImage = UIImage(named: "photo")!
let imageProvider = ImageProvider(image: uiImage)

// From file URL (most memory efficient)
let fileURL = Bundle.main.url(forResource: "photo", withExtension: "jpg")!
let imageProvider = try ImageProvider(fileURL: fileURL)

// From remote URL (downloads automatically)
let remoteURL = URL(string: "https://example.com/photo.jpg")!
let imageProvider = ImageProvider(editableRemoteURL: remoteURL)

// From image data
let imageData = try Data(contentsOf: fileURL)
let imageProvider = try Data(contentsOf: fileURL)
let imageProvider = try ImageProvider(data: imageData)

// From PHAsset (Photos framework)
import Photos
let asset: PHAsset = // ... fetched from Photos library
let imageProvider = ImageProvider(asset: asset)

// From RAW image data
let rawData = try Data(contentsOf: rawFileURL)
let imageProvider = try ImageProvider(rawData: rawData)
```

--------------------------------

### Implement ClassicImageEditViewController in UIKit

Source: https://context7.com/muukii/brightroom/llms.txt

Configures and presents an image editor with custom options, localized strings, and completion handlers for rendering the final image.

```swift
import UIKit
import BrightroomEngine
import BrightroomUI

class PhotoEditorCoordinator: NSObject {

    func presentEditor(from viewController: UIViewController, with image: UIImage) {
        // Create with ImageProvider
        let imageProvider = ImageProvider(image: image)
        let editor = ClassicImageEditViewController(imageProvider: imageProvider)

        // Or with EditingStack for more control
        let editingStack = EditingStack(imageProvider: imageProvider)
        let editorWithStack = ClassicImageEditViewController(editingStack: editingStack)

        // Configure options
        let options = ClassicImageEditOptions()
        options.croppingAspectRatio = .square  // Lock to square

        // Customize strings
        var strings = ClassicImageEditViewController.LocalizedStrings()
        strings.done = "Save"
        strings.cancel = "Discard"
        strings.editBrightness = "Brightness"
        strings.editContrast = "Contrast"
        strings.editSaturation = "Saturation"

        let customEditor = ClassicImageEditViewController(
            editingStack: editingStack,
            options: options,
            localizedStrings: strings
        )

        // Handle completion
        customEditor.handlers.didEndEditing = { [weak viewController] controller, editingStack in
            do {
                let renderer = try editingStack.makeRenderer()
                let rendered = try renderer.render()
                let editedImage = rendered.uiImage

                // Use the edited image
                print("Edited image: \(editedImage.size)")

                controller.dismiss(animated: true)
            } catch {
                print("Rendering error: \(error)")
            }
        }

        customEditor.handlers.didCancelEditing = { controller in
            controller.dismiss(animated: true)
        }

        // Present in navigation controller
        let nav = UINavigationController(rootViewController: customEditor)
        nav.modalPresentationStyle = .fullScreen
        viewController.present(nav, animated: true)
    }
}
```

--------------------------------

### Add Custom Overlays to SwiftUICropView

Source: https://context7.com/muukii/brightroom/llms.txt

Shows how to implement custom inside and outside overlays for the cropping interface.

```swift
struct CropViewWithOverlays: View {
    let editingStack: EditingStack

    var body: some View {
        SwiftUICropView(
            editingStack: editingStack,
            cropInsideOverlay: { adjustmentKind in
                // Custom inside overlay (grid lines, etc.)
                if adjustmentKind != nil {
                    GridOverlay()
                }
            },
            cropOutsideOverlay: { adjustmentKind in
                // Custom outside overlay
                Color.black.opacity(0.6)
            }
        )
    }
}
```

--------------------------------

### Classic Editor View Controller

Source: https://github.com/muukii/brightroom/blob/main/README.md

Reference to the legacy editor view controller class.

```text
PixelEditViewController
```

--------------------------------

### Implement a Crop View with SwiftUI

Source: https://github.com/muukii/brightroom/blob/main/README.md

Use the PhotosCropRotating component to enable image cropping and rotation in a SwiftUI view.

```swift
import SwiftUI
import BrightroomUIPhotosCrop

struct DemoCropView: View {

  @StateObject var editingStack: EditingStack
  @State var resultImage: ResultImage?

  init(
    editingStack: @escaping () -> EditingStack
  ) {
    self._editingStack = .init(wrappedValue: editingStack())
  }

  var body: some View {
    ZStack {

      VStack {
        PhotosCropRotating(editingStack: { editingStack })

        Button("Done") {
          let image = try! editingStack.makeRenderer().render().cgImage
          self.resultImage = .init(cgImage: image)
        }
      }
    }
    .onAppear {
      editingStack.start()
    }
  }

}
```

--------------------------------

### Initialize EditingCrop

Source: https://context7.com/muukii/brightroom/llms.txt

Initializes an EditingCrop object from an image size. This object manages cropping extent and rotation settings.

```swift
let imageSize = CGSize(width: 4000, height: 3000)
var crop = EditingCrop(imageSize: imageSize)
```

--------------------------------

### SwiftUI Image Cropping with PhotosCropRotating

Source: https://context7.com/muukii/brightroom/llms.txt

Integrate PhotosCropRotating for a Photos-app-style cropping interface in SwiftUI. This view supports rotation, aspect ratio selection, and angle adjustment. Ensure SwiftUI, BrightroomEngine, and BrightroomUIPhotosCrop are imported.

```swift
import SwiftUI
import BrightroomEngine
import BrightroomUIPhotosCrop

struct ImageCropView: View {
    @StateObject var editingStack: EditingStack
    @State var resultImage: UIImage?

    init(image: UIImage) {
        _editingStack = StateObject(wrappedValue: EditingStack(
            imageProvider: ImageProvider(image: image)
        ))
    }

    var body: some View {
        VStack {
            PhotosCropRotating(editingStack: { editingStack })

            HStack {
                Button("Cancel") {
                    editingStack.revertEdit()
                }

                Spacer()

                Button("Done") {
                    // Render the cropped image
                    do {
                        let renderer = try editingStack.makeRenderer()
                        let rendered = try renderer.render()
                        resultImage = rendered.uiImage
                    } catch {
                        print("Error: \(error)")
                    }
                }
            }
            .padding()
        }
        .onAppear {
            editingStack.start()
        }
    }
}

// Preview cropped result
struct ResultView: View {
    let image: UIImage

    var body: some View {
        Image(uiImage: image)
            .resizable()
            .aspectRatio(contentMode: .fit)
    }
}
```

--------------------------------

### Apply Crop to Editing Stack

Source: https://context7.com/muukii/brightroom/llms.txt

Applies the configured crop settings to the editing stack. This method should be called after defining the desired crop extent and rotation.

```swift
editingStack.crop(crop)
```

--------------------------------

### Apply a Preset Filter

Source: https://context7.com/muukii/brightroom/llms.txt

Applies a preset filter, such as a vintage effect, using a FilterPreset object. Custom filters can be included in the 'filters' array.

```swift
editingStack.set(filters: { filters in
    filters.preset = FilterPreset(
        name: "Vintage",
        identifier: "com.app.vintage",
        filters: [/* custom AnyFilter array */],
        userInfo: [:]
    )
})
```

--------------------------------

### Render Images with BrightRoomImageRenderer

Source: https://context7.com/muukii/brightroom/llms.txt

Use BrightRoomImageRenderer to render edited images. Supports synchronous and asynchronous rendering with custom resolution, color space, and export options. Ensure BrightroomEngine is imported.

```swift
import BrightroomEngine

// Create renderer from editing stack
let renderer = try editingStack.makeRenderer()

// Synchronous rendering (can run on background thread)
let rendered = try renderer.render()

// Access rendered image
let cgImage: CGImage = rendered.cgImage
let uiImage: UIImage = rendered.uiImage
let swiftUIImage: SwiftUI.Image = rendered.swiftUIImage
```

```swift
// Render with custom options
let options = BrightRoomImageRenderer.Options(
    resolution: .full,  // or .resize(maxPixelSize: 1920)
    workingFormat: .ARGB8,
    workingColorSpace: CGColorSpace(name: CGColorSpace.displayP3)
)
let renderedWithOptions = try renderer.render(options: options)
```

```swift
// Asynchronous rendering
renderer.render(options: .init(), callbackQueue: .main) { result in
    switch result {
    case .success(let rendered):
        let image = rendered.uiImage
        print("Rendered with engine: \(rendered.engine)")
    case .failure(let error):
        print("Rendering failed: \(error)")
    }
}
```

```swift
// Export optimized data for sharing (handles color space correctly)
let jpegData = rendered.makeOptimizedForSharingData(dataType: .jpeg(quality: 0.9))
let pngData = rendered.makeOptimizedForSharingData(dataType: .png)
```

```swift
// Render at reduced resolution
let thumbnailOptions = BrightRoomImageRenderer.Options(
    resolution: .resize(maxPixelSize: 800)
)
let thumbnail = try renderer.render(options: thumbnailOptions)
```

--------------------------------

### Apply Multiple Filters Simultaneously

Source: https://context7.com/muukii/brightroom/llms.txt

Applies multiple image filters at once, including contrast, saturation, exposure, temperature, highlights, shadows, vignette, sharpen, blur, and fade effects. Ensure filters are within their specified value ranges.

```swift
editingStack.set(filters: { filters in
    // Contrast (-1.0 to 1.0)
    filters.contrast = FilterContrast()
    filters.contrast?.value = 0.2

    // Saturation (0.0 to 2.0)
    filters.saturation = FilterSaturation()
    filters.saturation?.value = 1.3

    // Exposure (-2.0 to 2.0)
    filters.exposure = FilterExposure()
    filters.exposure?.value = 0.5

    // Temperature
    filters.temperature = FilterTemperature()
    filters.temperature?.value = 5000

    // Highlights and Shadows
    filters.highlights = FilterHighlights()
    filters.highlights?.value = 0.5
    filters.shadows = FilterShadows()
    filters.shadows?.value = 0.3

    // Vignette
    filters.vignette = FilterVignette()
    filters.vignette?.value = 0.5

    // Sharpen
    filters.sharpen = FilterSharpen()
    filters.sharpen?.value = 0.4

    // Gaussian Blur
    filters.gaussianBlur = FilterGaussianBlur()
    filters.gaussianBlur?.value = 2.0

    // Fade effect
    filters.fade = FilterFade()
    filters.fade?.value = 0.3
})
```

--------------------------------

### Apply Blur Masking in UIKit and SwiftUI

Source: https://context7.com/muukii/brightroom/llms.txt

Demonstrates programmatic manipulation of blur mask paths using EditingStack and integration of the SwiftUIBlurryMaskingView component.

```swift
import BrightroomEngine
import BrightroomUI

// Set blur mask paths programmatically
let editingStack = EditingStack(imageProvider: imageProvider)
editingStack.start()

// Create a drawn path with brush
let brush = OvalBrush(color: .black, pixelSize: 50)
let bezierPath = UIBezierPath()
bezierPath.move(to: CGPoint(x: 100, y: 100))
bezierPath.addLine(to: CGPoint(x: 200, y: 200))
bezierPath.addLine(to: CGPoint(x: 300, y: 150))

let drawnPath = DrawnPath(brush: brush, path: bezierPath)

// Append to editing stack
editingStack.append(blurringMaskPaths: [drawnPath])

// Or replace all paths
editingStack.set(blurringMaskPaths: [drawnPath])

// SwiftUI masking view
import SwiftUI

struct MaskingView: View {
    let editingStack: EditingStack

    var body: some View {
        SwiftUIBlurryMaskingView(editingStack: editingStack)
            .blushSize(.point(30))  // Brush size in points
            .hideBackdropImageView(false)
            .hideBlurryImageView(false)
            .onAppear {
                editingStack.start()
            }
    }
}
```

--------------------------------

### Update Crop Extent with Custom Rect and Bounding Box

Source: https://context7.com/muukii/brightroom/llms.txt

Allows updating the crop extent using a custom CGRect or a normalized bounding box from frameworks like Vision. The bounding box fitting can respect a specified aspect ratio.

```swift
// Update crop extent with custom rect
crop.updateCropExtent(CGRect(x: 100, y: 100, width: 800, height: 600))

// Use Vision framework bounding box (normalized coordinates)
let faceBoundingBox = CGRect(x: 0.2, y: 0.3, width: 0.4, height: 0.4)
crop.updateCropExtent(
    toFitBoundingBox: faceBoundingBox,
    respectingApectRatio: .square
)
```

--------------------------------

### Manage Editing History

Source: https://context7.com/muukii/brightroom/llms.txt

Provides methods for managing the editing history, including taking snapshots for undo, undoing the last change, reverting all changes, and removing all history.

```swift
editingStack.takeSnapshot()

// Undo the last change
editingStack.undoEdit()

// Revert all changes
editingStack.revertEdit()

// Remove all history
editingStack.removeAllEditsHistory()
```

--------------------------------

### Set Rotation and Adjustment Angle

Source: https://context7.com/muukii/brightroom/llms.txt

Sets the rotation of the crop in 90-degree increments and applies a fine adjustment angle for precise rotation. The aggregated rotation combines both settings.

```swift
crop.rotation = .angle_0   // 0 degrees (default)
crop.rotation = .angle_90  // 90 degrees
crop.rotation = .angle_180 // 180 degrees
crop.rotation = .angle_270 // 270 degrees

// Fine adjustment angle (-45 to +45 degrees)
crop.adjustmentAngle = .degrees(5)

// Get aggregated rotation (rotation + adjustment)
let totalRotation = crop.aggregatedRotation
```

--------------------------------

### Apply Brightness Filter

Source: https://context7.com/muukii/brightroom/llms.txt

Applies a brightness adjustment to the image. The value ranges from -0.2 to 0.2.

```swift
editingStack.set(filters: { filters in
    filters.brightness = FilterBrightness()
    filters.brightness?.value = 0.1
})
```

--------------------------------

### Reset EditingCrop to Initial State

Source: https://context7.com/muukii/brightroom/llms.txt

Resets an EditingCrop object to its initial state, effectively removing any applied cropping or rotation settings.

```swift
crop = crop.makeInitial()
```

--------------------------------

### Update Crop Extent to Fit Aspect Ratio

Source: https://context7.com/muukii/brightroom/llms.txt

Updates the crop extent to fit a specified aspect ratio, such as square, 16:9, 4:3, or 3:2. The crop extent is adjusted to maintain the image's original aspect ratio within the new constraints.

```swift
crop.updateCropExtent(toFitAspectRatio: PixelAspectRatio(width: 16, height: 9))

// Common aspect ratios
crop.updateCropExtent(toFitAspectRatio: .square)  // 1:1
crop.updateCropExtent(toFitAspectRatio: .init(width: 4, height: 3))
crop.updateCropExtent(toFitAspectRatio: .init(width: 3, height: 2))
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.