Improve FillMaskWithTiledImage

Author: selfdocumentingcode

.github/workflows/build.yml

@@ -62,7 +62,7 @@ jobs:
           arguments: '/updateprojectfiles'
 
       - name: Test
-        run: dotnet test
+        run: dotnet test --filter TestCategory\!=ShittyTests
 
       - name: Log in to the Container registry
         uses: docker/login-action@v3

src/Kattbot/Services/Images/ImageEffects.cs

@@ -275,14 +275,196 @@ public static Image FillMaskWithTiledImage(
         Image<Rgba32> result = targetImage.Clone();
         var random = new Random();
 
-        // Resize tile image based on target image width ratio (1/40 for 32px tiles on 1280px width)
-        const double tileRatio = 1.0 / 40.0;
-        var desiredTileSize = (int)(targetImage.Width * tileRatio);
+        // Calculate average color of tile image for background fill
+        Rgba32 averageColor = CalculateAverageColor(tileImage);
+
+        // Apply brightness reduction to the average color for Layer 1
+        const float baseLayerBrightness = 0.8f;
+        var darkenedAverageColor = new Rgba32(
+            (byte)(averageColor.R * baseLayerBrightness),
+            (byte)(averageColor.G * baseLayerBrightness),
+            (byte)(averageColor.B * baseLayerBrightness),
+            averageColor.A);
+
+        // Layer 1: Fill entire masked area with darkened average color using pixel-level processing
+        for (var y = 0; y < Math.Min(result.Height, maskImage.Height); y++)
+        {
+            for (var x = 0; x < Math.Min(result.Width, maskImage.Width); x++)
+            {
+                Rgba32 maskPixel = maskImage[x, y];
+                if (maskPixel is { R: > 200, G: > 200, B: > 200 })
+                {
+                    result[x, y] = darkenedAverageColor;
+                }
+            }
+        }
+
+        // Layer 2: Texture-like coverage with reduced brightness (depth effect)
+        const double textureLayerTileRatio = 1.0 / 34.0;
+        const float textureLayerBrightness = 0.9f;
+        const float textureLayerSpacingMultiplier = 0.3f;
+
+        ApplyTextureLayer(
+            result,
+            maskImage,
+            tileImage,
+            random,
+            textureLayerTileRatio,
+            textureLayerBrightness,
+            textureLayerSpacingMultiplier);
+
+        // Layer 3: Higher tile ratio with original brightness and increased spacing
+        const double tileLayerTileRatio = 1.0 / 30.0;
+        const float tileLayerBrightness = 1.0f;
+        const float tileLayerSpacingMultiplier = 0.65f;
+
+        ApplyTileLayer(
+            result,
+            maskImage,
+            tileImage,
+            random,
+            tileLayerTileRatio,
+            tileLayerBrightness,
+            tileLayerSpacingMultiplier);
+
+        return result;
+    }
+
+    private static void ApplyTextureLayer(
+        Image<Rgba32> result,
+        Image<Rgba32> maskImage,
+        Image<Rgba32> tileImage,
+        Random random,
+        double tileRatio,
+        float brightness,
+        float spacingMultiplier)
+    {
+        var desiredTileSize = (int)(result.Width * tileRatio);
+
+        // Resize the tile image to maintain square aspect ratio
+        using Image<Rgba32> resizedTileImage = tileImage.Clone(ctx =>
+            ctx.Resize(desiredTileSize, desiredTileSize, KnownResamplers.Hermite));
+
+        int tileWidth = resizedTileImage.Width;
+        int tileHeight = resizedTileImage.Height;
+        int maxJitterX = tileWidth / 4; // Reduced jitter for more consistent coverage
+        int maxJitterY = tileHeight / 4;
+
+        // Create a grid that ensures complete coverage with some overlap
+        var gridSpacingX = (int)(tileWidth * spacingMultiplier);
+        var gridSpacingY = (int)(tileHeight * spacingMultiplier);
+
+        // Start with slight negative offset to ensure edge coverage
+        int startX = -tileWidth / 2;
+        int startY = -tileHeight / 2;
+
+        for (int gridY = startY; gridY < maskImage.Height + tileHeight; gridY += gridSpacingY)
+        {
+            for (int gridX = startX; gridX < maskImage.Width + tileWidth; gridX += gridSpacingX)
+            {
+                // Add small random jitter to avoid perfect grid pattern
+                int jitterX = random.Next(-maxJitterX, maxJitterX);
+                int jitterY = random.Next(-maxJitterY, maxJitterY);
+
+                int tileX = gridX + jitterX;
+                int tileY = gridY + jitterY;
+
+                // Check if this tile position overlaps with the mask
+                var overlapsMask = false;
+                int checkRadius = Math.Max(tileWidth, tileHeight) / 2;
+
+                for (int checkY = Math.Max(val1: 0, tileY);
+                     checkY < Math.Min(maskImage.Height, tileY + tileHeight) && !overlapsMask;
+                     checkY += checkRadius / 2)
+                {
+                    for (int checkX = Math.Max(val1: 0, tileX);
+                         checkX < Math.Min(maskImage.Width, tileX + tileWidth) && !overlapsMask;
+                         checkX += checkRadius / 2)
+                    {
+                        if (checkX < maskImage.Width && checkY < maskImage.Height)
+                        {
+                            Rgba32 pixel = maskImage[checkX, checkY];
+                            if (pixel is { R: > 200, G: > 200, B: > 200 })
+                            {
+                                overlapsMask = true;
+                            }
+                        }
+                    }
+                }
+
+                if (overlapsMask)
+                {
+                    // Draw the tile image cropped to the mask boundaries using direct pixel access
+                    for (var y = 0; y < tileHeight; y++)
+                    {
+                        int resultY = tileY + y;
+                        if (resultY < 0 || resultY >= result.Height) continue;
+
+                        for (var x = 0; x < tileWidth; x++)
+                        {
+                            int resultX = tileX + x;
+                            if (resultX < 0 || resultX >= result.Width) continue;
+
+                            // Check if this position is within the mask
+                            if (resultX < maskImage.Width && resultY < maskImage.Height)
+                            {
+                                Rgba32 maskPixel = maskImage[resultX, resultY];
+                                if (maskPixel is { R: > 200, G: > 200, B: > 200 })
+                                {
+                                    // Draw tile pixels within the mask, including semi-transparent ones for smooth edges
+                                    Rgba32 tilePixel = resizedTileImage[x, y];
+                                    if (tilePixel.A > 0) // Include all non-fully-transparent pixels
+                                    {
+                                        // Apply brightness reduction per-pixel to preserve edge anti-aliasing
+                                        var adjustedPixel = new Rgba32(
+                                            (byte)(tilePixel.R * brightness),
+                                            (byte)(tilePixel.G * brightness),
+                                            (byte)(tilePixel.B * brightness),
+                                            tilePixel.A); // Keep original alpha
+
+                                        // Blend with existing pixel using alpha blending
+                                        Rgba32 existingPixel = result[resultX, resultY];
+                                        float alpha = adjustedPixel.A / 255f;
+                                        float invAlpha = 1f - alpha;
+
+                                        var blendedPixel = new Rgba32(
+                                            (byte)((adjustedPixel.R * alpha) + (existingPixel.R * invAlpha)),
+                                            (byte)((adjustedPixel.G * alpha) + (existingPixel.G * invAlpha)),
+                                            (byte)((adjustedPixel.B * alpha) + (existingPixel.B * invAlpha)),
+                                            Math.Max(adjustedPixel.A, existingPixel.A));
+
+                                        result[resultX, resultY] = blendedPixel;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private static void ApplyTileLayer(
+        Image<Rgba32> result,
+        Image<Rgba32> maskImage,
+        Image<Rgba32> tileImage,
+        Random random,
+        double tileRatio,
+        float brightness,
+        float spacingMultiplier)
+    {
+        var desiredTileSize = (int)(result.Width * tileRatio);
 
         // Resize the tile image to maintain square aspect ratio
-        Image<Rgba32> resizedTileImage = tileImage.Clone(ctx =>
+        using Image<Rgba32> resizedTileImage = tileImage.Clone(ctx =>
             ctx.Resize(desiredTileSize, desiredTileSize, KnownResamplers.Hermite));
 
+        // Adjust brightness if needed
+        if (Math.Abs(brightness - 1.0f) > 0.001f)
+        {
+            resizedTileImage.Mutate(ctx => ctx.Brightness(brightness));
+        }
+
         // Calculate tile placement parameters
         int tileWidth = resizedTileImage.Width;
         int tileHeight = resizedTileImage.Height;
@@ -293,16 +475,19 @@ public static Image FillMaskWithTiledImage(
         var maskRegions = new List<Point>();
 
         // Scan for white pixels in the mask (sampling at intervals)
-        for (var y = 0; y < maskImage.Height; y += tileHeight / 2)
+        var spacingY = (int)(tileHeight * spacingMultiplier);
+        var spacingX = (int)(tileWidth * spacingMultiplier);
+
+        for (var y = 0; y < maskImage.Height; y += spacingY)
         {
-            for (var x = 0; x < maskImage.Width; x += tileWidth / 2)
+            for (var x = 0; x < maskImage.Width; x += spacingX)
             {
                 if (x < maskImage.Width && y < maskImage.Height)
                 {
                     Rgba32 pixel = maskImage[x, y];
 
                     // Check if pixel is white (high RGB values)
-                    if (pixel.R > 200 && pixel.G > 200 && pixel.B > 200)
+                    if (pixel is { R: > 200, G: > 200, B: > 200 })
                     {
                         maskRegions.Add(new Point(x, y));
                     }
@@ -329,19 +514,48 @@ public static Image FillMaskWithTiledImage(
                 centerY >= 0 && centerY < maskImage.Height)
             {
                 Rgba32 centerPixel = maskImage[centerX, centerY];
-                if (centerPixel.R > 200 && centerPixel.G > 200 && centerPixel.B > 200)
+                if (centerPixel is { R: > 200, G: > 200, B: > 200 })
                 {
-                    // Ensure tile placement is within target image bounds
-                    tileX = Math.Max(val1: 0, Math.Min(tileX, targetImage.Width - tileWidth));
-                    tileY = Math.Max(val1: 0, Math.Min(tileY, targetImage.Height - tileHeight));
-
-                    // Draw the tile image at the calculated position
+                    // Allow tiles to extend beyond image bounds for natural edge effect
+                    // Draw the tile image at the calculated position (can go partially offscreen)
                     result.Mutate(ctx => { ctx.DrawImage(resizedTileImage, new Point(tileX, tileY), opacity: 1f); });
                 }
             }
         }
+    }
 
-        resizedTileImage.Dispose();
-        return result;
+    private static Rgba32 CalculateAverageColor(Image<Rgba32> image)
+    {
+        long totalR = 0, totalG = 0, totalB = 0, totalA = 0;
+        var pixelCount = 0;
+
+        image.ProcessPixelRows(accessor =>
+        {
+            for (var y = 0; y < accessor.Height; y++)
+            {
+                Span<Rgba32> pixelRow = accessor.GetRowSpan(y);
+                for (var x = 0; x < pixelRow.Length; x++)
+                {
+                    Rgba32 pixel = pixelRow[x];
+                    if (pixel.A > 0) // Only count non-transparent pixels
+                    {
+                        totalR += pixel.R;
+                        totalG += pixel.G;
+                        totalB += pixel.B;
+                        totalA += pixel.A;
+                        pixelCount++;
+                    }
+                }
+            }
+        });
+
+        if (pixelCount == 0)
+            return new Rgba32(r: 0, g: 0, b: 0, a: 0);
+
+        return new Rgba32(
+            (byte)(totalR / pixelCount),
+            (byte)(totalG / pixelCount),
+            (byte)(totalB / pixelCount),
+            (byte)(totalA / pixelCount));
     }
 }

tests/Kattbot.Tests/EmoteParserTests.cs

@@ -18,21 +18,21 @@ public void Initialize()
     [TestMethod]
     public void ParseEmotes_WithMessageContaingEmotes_ReturnEmote()
     {
-        var testMessage = "Some text <:emoji_1:123123123>";
+        const string testMessage = "Some text <:emoji_1:123123123>";
 
         List<string> emotes = _sut.ExtractEmotesFromMessage(testMessage);
 
-        Assert.AreEqual(emotes.Count, 1);
+        Assert.AreEqual(emotes.Count, actual: 1);
         Assert.AreEqual(emotes[0], "<:emoji_1:123123123>");
     }
 
     [TestMethod]
     public void ParseEmotes_WithMessageContaingThreeEmotes_ReturnThreeEmotes()
     {
-        var testMessage = "Some text <:emoji_1:123123123> other <:emoji_2:123123123><:emoji_3:123123123>";
+        const string testMessage = "Some text <:emoji_1:123123123> other <:emoji_2:123123123><:emoji_3:123123123>";
 
         List<string> emotes = _sut.ExtractEmotesFromMessage(testMessage);
 
-        Assert.AreEqual(emotes.Count, 3);
+        Assert.AreEqual(emotes.Count, actual: 3);
     }
 }

tests/Kattbot.Tests/ImageServiceTests.cs

@@ -1,19 +1,22 @@
 using System.IO;
 using System.Linq;
-using System.Net.Http;
 using System.Threading.Tasks;
 using Kattbot.Services.Images;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using NSubstitute;
 using SixLabors.ImageSharp;
-using SixLabors.ImageSharp.Formats;
 
 namespace Kattbot.Tests;
 
 [TestClass]
-[Ignore] // Can't save to /tmp on GitHub Actions. TODO: fix
 public class ImageServiceTests
 {
+    private readonly TestContext _testContext;
+
+    public ImageServiceTests(TestContext testContext)
+    {
+        _testContext = testContext;
+    }
+
     [TestMethod]
     [DataRow("cute_cat.jpg")]
     [DataRow("froge.png")]
@@ -23,13 +26,13 @@ public async Task EnsureMaxSize_DownscalesImageIfNeeded(string inputFilename)
 
         string inputFile = Path.Combine("Resources", inputFilename);
 
-        Image inputImage = await Image.LoadAsync(inputFile);
+        Image inputImage = await Image.LoadAsync(inputFile, _testContext.CancellationTokenSource.Token);
 
         Image resizedImage = await ImageService.EnsureMaxImageFileSize(inputImage, maxSizeMb);
 
         double resizedImageSize = await ImageService.GetImageSizeInMb(resizedImage);
 
-        Assert.IsTrue(resizedImageSize <= maxSizeMb);
+        Assert.IsLessThanOrEqualTo(maxSizeMb, resizedImageSize);
     }
 
     [TestMethod]
@@ -46,7 +49,7 @@ public async Task EnsureSupportedImageFormatOrPng_ConvertsToPngIfFormatIsNotSupp
 
         string inputFile = Path.Combine("Resources", inputFilename);
 
-        Image inputImage = await Image.LoadAsync(inputFile);
+        Image inputImage = await Image.LoadAsync(inputFile, _testContext.CancellationTokenSource.Token);
 
         Image convertedImage = await ImageService.EnsureSupportedImageFormatOrPng(inputImage, supportedFileTypes);