benscode-StitcherApi/Services/Utilities/ImageProcessor.cs

using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;
using SixLabors.ImageSharp.Processing;

namespace StitcherApi.Services.Utilities;

internal class ImageProcessor
{
    private readonly string _assetPath;
    private const int TILE_SIZE = 720;

    public ImageProcessor(string assetPath)
    {
        _assetPath = assetPath;
    }

    public async Task<byte[]> StitchAndCropAsync(StitchRequest stitchRequest)
    {
        using var finalImage = new Image<Rgba32>(stitchRequest.CropW, stitchRequest.CropH);

        for (var r = stitchRequest.StartTileRow; r <= stitchRequest.EndTileRow; r++)
        {
            for (var c = stitchRequest.StartTileCol; c <= stitchRequest.EndTileCol; c++)
            {
                var tileFileName = TileHelper.GetTileFileName(r, c);
                var tileFilePath = Path.Combine(_assetPath, tileFileName);

                if (!File.Exists(tileFilePath))
                {
                    throw new FileNotFoundException($"Asset not found: {tileFileName}");
                }

                using var tileImage = await Image.LoadAsync(tileFilePath);

                var tileOriginX = (c - stitchRequest.MinCol) * TILE_SIZE;
                var tileOriginY = (r - stitchRequest.MinRow) * TILE_SIZE;

                var srcX = Math.Max(0, stitchRequest.CropX - tileOriginX);
                var srcY = Math.Max(0, stitchRequest.CropY - tileOriginY);
                var destX = Math.Max(0, tileOriginX - stitchRequest.CropX);
                var destY = Math.Max(0, tileOriginY - stitchRequest.CropY);

                var overlapW = Math.Max(
                    0,
                    Math.Min(stitchRequest.CropX + stitchRequest.CropW, tileOriginX + TILE_SIZE)
                        - Math.Max(stitchRequest.CropX, tileOriginX)
                );
                var overlapH = Math.Max(
                    0,
                    Math.Min(stitchRequest.CropY + stitchRequest.CropH, tileOriginY + TILE_SIZE)
                        - Math.Max(stitchRequest.CropY, tileOriginY)
                );

                if (overlapW > 0 && overlapH > 0)
                {
                    var sourceRect = new Rectangle(srcX, srcY, overlapW, overlapH);
                    finalImage.Mutate(ctx =>
                        ctx.DrawImage(
                            tileImage,
                            new Point(destX, destY),
                            sourceRect,
                            new GraphicsOptions()
                        )
                    );
                }
            }
        }

        if (stitchRequest.OutputScale > 0 && stitchRequest.OutputScale < 1.0)
        {
            var newWidth = (int)(stitchRequest.CropW * stitchRequest.OutputScale);
            var newHeight = (int)(stitchRequest.CropH * stitchRequest.OutputScale);
            finalImage.Mutate(x => x.Resize(newWidth, newHeight, KnownResamplers.Bicubic));
        }

        using var memoryStream = new MemoryStream();
        await finalImage.SaveAsPngAsync(memoryStream);
        return memoryStream.ToArray();
    }
}

internal record StitchRequest(
    int MinRow,
    int MinCol,
    int StartTileRow,
    int StartTileCol,
    int EndTileRow,
    int EndTileCol,
    int CropX,
    int CropY,
    int CropW,
    int CropH,
    float OutputScale
);