ImageSpace

using ImageSpace.Storage;

sealed class FolderStorage(string folder) : IEditorStorage
{
    private string Recovery => Path.Combine(folder, "recovery.imagespace");

    public Task<OpenedFile?> OpenAsync(CancellationToken cancellationToken = default) =>
        Task.FromResult<OpenedFile?>(null); // show a host file picker here

    public async Task<bool> SaveAsync(string name, byte[] bytes, string contentType, CancellationToken cancellationToken = default)
    {
        await File.WriteAllBytesAsync(Path.Combine(folder, name), bytes, cancellationToken);
        return true; // return false when the user cancels
    }

    public async Task<byte[]?> ReadRecoveryAsync(CancellationToken cancellationToken = default) =>
        File.Exists(Recovery) ? await File.ReadAllBytesAsync(Recovery, cancellationToken) : null;

    public Task WriteRecoveryAsync(byte[] bytes, CancellationToken cancellationToken = default) =>
        File.WriteAllBytesAsync(Recovery, bytes, cancellationToken);

    public Task ClearRecoveryAsync(CancellationToken cancellationToken = default)
    {
        File.Delete(Recovery);
        return Task.CompletedTask;
    }
}

using System.Numerics;
using ImageSpace.Core;
using ImageSpace.Imaging;

var document = new ImageDocument(800, 600);
var layer = Layer.Raster("Paint", 800, 600);
document.Layers.Add(layer);
document.ActiveLayerId = layer.Id;

// Edits respect the document selection's coverage.
var ellipse = Selections.Rectangle(800, 600, new Vector2(100, 100), new Vector2(500, 400), ellipse: true);
document.Selection = SelectionMorphology.Apply(ellipse, SelectionModification.Smooth, radius: 4);
PixelEdits.Gradient(document, layer, new(100, 100), new(500, 400), Rgba32.Parse("#FF8A3D"), Rgba32.Parse("#3D7BFF"));

var brush = new BrushEngine();
brush.Begin(layer.Pixels!, Vector2.Zero);
foreach (var x in new[] { 150f, 250f, 350f })
    brush.Paint(document, layer, new Vector2(x, 250), 0.8f, new BrushSettings(Size: 24), Rgba32.White, PaintMode.Brush);
brush.End();

int[] histogram = RasterOperations.Histogram(layer.Pixels!);

using ImageSpace.Core;
using ImageSpace.Filters;

PixelSurface blurred = FilterEngine.Blur(source, sigma: 3);
PixelSurface sepia = FilterEngine.Apply(source, FilterKind.Sepia);
PixelSurface punchy = FilterEngine.Apply(source, FilterKind.BrightnessContrast, amount: 10, secondary: 20);

var levels = new LevelsAdjustment
{
    Rgb = new LevelsChannel { InputBlack = 16, InputWhite = 240, Gamma = 1.2 },
    Blue = new LevelsChannel { Gamma = 0.95 }
};
PixelSurface toned = ToneFilterEngine.Apply(source, RgbLookupTables.FromLevels(levels), cancellationToken);

using ImageSpace.Core;
using ImageSpace.Filters;
using ImageSpace.WebGpu;

static async Task<PixelSurface> ApplyAsync(IComputeFilterBackend gpu, PixelSurface source, FilterKind kind, float amount)
{
    if (GpuKernels.Supports(kind))
    {
        GpuCapabilities caps = await gpu.GetCapabilitiesAsync();
        if (caps.Available && await gpu.ApplyAsync(source, kind, amount, 0) is { } output)
            return output;
    }
    return FilterEngine.Apply(source, kind, amount); // deterministic CPU fallback
}

using ImageSpace.Core;
using ImageSpace.Editing;
using ImageSpace.Filters;

var session = new EditorSession(new ImageDocument(1600, 1000, "Untitled"));
session.Changed += (_, _) => Console.WriteLine($"Revision {session.Revision}");

session.AddLayer("Paint");                             // one history entry
session.FillPixels(new Rgba32(54, 145, 230));
session.ApplyFilter(FilterKind.GaussianBlur, amount: 4);

session.Execute("Add Curves", document =>              // arbitrary edit, one undo step
{
    var adjustment = new Layer
    {
        Name = "Contrast", Kind = LayerKind.Adjustment, Adjustment = AdjustmentKind.Curves,
        Width = document.Width, Height = document.Height,
        Curves = new CurvesAdjustment { Rgb = new ToneCurve { Points = [new(0, 0), new(64, 38), new(192, 218), new(255, 255)] } }
    };
    document.Layers.Add(adjustment);
    document.ActiveLayerId = adjustment.Id;
});
session.Undo();

using ImageSpace.Core;
using ImageSpace.Documents;
using ImageSpace.Skia;

PsdCodec.ImportResult imported = PsdCodec.Load(File.ReadAllBytes("artwork.psd"), "artwork");
foreach (var warning in imported.Warnings)
    Console.WriteLine(warning);

// Lossless native archive (.imagespace) roundtrip.
byte[] archive = DocumentArchive.Save(imported.Document);
ImageDocument reopened = DocumentArchive.Load(archive);

// PSD export needs rasterized layers and a composite, e.g. from ImageSpace.Skia.
using var renderer = new ImageRenderer();
byte[] psd = PsdCodec.Save(reopened, layer => renderer.RasterizeLayer(reopened, layer),
    renderer.Rasterize(reopened), PsdCompression.Zip);

using ImageSpace.Core;
using ImageSpace.Skia;
using SkiaSharp;

using var renderer = new ImageRenderer();

// Composite into any SKCanvas (an Uno SKCanvasElement, an SKSurface, ...).
using var surface = SKSurface.Create(new SKImageInfo(document.Width, document.Height));
renderer.Draw(surface.Canvas, document);

File.WriteAllBytes("poster.webp", renderer.Export(document, SKEncodedImageFormat.Webp, quality: 90));
PixelSurface preview = renderer.RasterizePreview(document, maximumEdge: 256);
PixelSurface decoded = ImageRenderer.Decode(File.ReadAllBytes("photo.jpg"));

using ImageSpace.Controls;
using ImageSpace.Core;
using Microsoft.UI.Xaml.Controls;

var curve = new CurveEditor { Curve = new ToneCurve { Points = [new(0, 0), new(128, 150), new(255, 255)] } };
curve.CurveChanged += value => ShowPreview(value);     // live, uncommitted
curve.EditCompleted += () => Commit(curve.Curve);
curve.EditCanceled += RevertPreview;

var levels = new LevelsControl { Value = new LevelsChannel { InputBlack = 12, Gamma = 1.1 } };
levels.ValueChanged += channel => ShowPreview(channel);

var opacity = new NumericField("Opacity", 100, 0, 100);
opacity.ValueChanged += value => SetOpacity((float)(value / 100));

window.Content = new StackPanel
{
    Spacing = 8,
    Children = { curve, levels, opacity, new StudioButton("Reset", ResetAll, icon: "undo") }
};

using ImageSpace.Core;
using ImageSpace.Editing;
using ImageSpace.Editor;
using ImageSpace.Imaging;

var session = new EditorSession(new ImageDocument(1600, 1000, "Untitled"));
session.AddLayer("Paint");
var viewport = new ImageViewport(session)
{
    Tool = EditorTool.Brush,
    Brush = new BrushSettings(Size: 24, Hardness: 0.9f),
    Foreground = new Rgba32(54, 145, 230)
};
viewport.ColorPicked += color => viewport.Foreground = color;
window.Content = viewport;

using ImageSpace.Documents;
using ImageSpace.Editing;
using ImageSpace.Imaging;
using ImageSpace.Storage;
using ImageSpace.Workbench;

IEditorStorage storage = new FolderStorage(dataFolder); // see ImageSpace.Storage
var document = await storage.ReadRecoveryAsync() is { } saved
    ? DocumentArchive.Load(saved)
    : SampleDocument.Create();

var workbench = new StudioWorkbench(new EditorSession(document), storage);
window.Content = workbench;
window.Closed += (_, _) => workbench.Dispose();