fix(scan): recognize current inventory icons

src/ScanEngine/IconManager.cs

@@ -230,9 +230,12 @@ private Dictionary<Vector2, Dictionary<string, Mat>> LoadNewIcons(
                                     return;
 
                                 var useCache = _config.ProcessingConfig.UseCache;
+                                var sourceFile = new FileInfo(iconPath);
+                                var cacheIdentity =
+                                    $"{iconKey}|{sourceFile.Length}|{sourceFile.LastWriteTimeUtc.Ticks}";
                                 var cacheIconPath = Path.Combine(
                                     _cacheDirectory,
-                                    $"{iconKey.CacheKey(configHash)}.bmp"
+                                    $"{cacheIdentity.CacheKey(configHash)}.bmp"
                                 );
                                 icon = useCache ? TryLoadCachedIcon(cacheIconPath) : null;
                                 var cacheHit = icon != null;
@@ -242,6 +245,11 @@ private Dictionary<Vector2, Dictionary<string, Mat>> LoadNewIcons(
                                     using var mat = Cv2.ImRead(iconPath, ImreadModes.Unchanged);
                                     if (mat.Empty())
                                         throw new InvalidDataException("The icon image is empty or unreadable.");
+                                    if (!HasVisibleIconContent(mat))
+                                    {
+                                        Logger.LogDebug("Skipping icon without visible pixels: " + iconPath);
+                                        return;
+                                    }
                                     icon = GetIconWithBackground(mat, item);
                                 }
 
@@ -303,6 +311,18 @@ private Dictionary<Vector2, Dictionary<string, Mat>> LoadNewIcons(
             return loadedIcons;
         }
 
+        private static bool HasVisibleIconContent(Mat icon)
+        {
+            if (icon.Channels() == 4)
+            {
+                using var alpha = icon.ExtractChannel(3);
+                return Cv2.CountNonZero(alpha) > 0;
+            }
+
+            using var gray = icon.Channels() == 1 ? icon.Clone() : icon.CvtColor(ColorConversionCodes.BGR2GRAY);
+            return Cv2.CountNonZero(gray) > 0;
+        }
+
         private static bool IsRecoverableIconLoadException(Exception exception) =>
             IsRecoverableFileSystemException(exception)
             || exception is ArgumentException or OpenCVException or OpenCvSharpException;

src/ScanEngine/Processing/Icon.cs

@@ -16,6 +16,9 @@ namespace RatEye.Processing
     /// </summary>
     public class Icon : IDisposable
     {
+        private const float OcrVerificationThreshold = 0.7f;
+        private static readonly Regex OcrShortNameSanitizer = new(@"[^\p{L}\p{N} \-.]");
+
         private readonly Config _config;
         private readonly Bitmap _icon;
         private Bitmap _scaledIcon;
@@ -163,6 +166,7 @@ private void SatisfyState(State targetState)
                             TemplateMatch();
                             if (IconConfig.ScanRotatedIcons)
                                 TemplateMatch(true);
+                            VerifyLowConfidenceTemplateMatchWithOcr();
                         }
                         else if (IconConfig.ScanMode == Config.Processing.Icon.ScanModes.OCR)
                             OCR();
@@ -351,6 +355,85 @@ private void OCR()
             }
         }
 
+        private void VerifyLowConfidenceTemplateMatchWithOcr()
+        {
+            if (_detectionConfidence >= OcrVerificationThreshold)
+                return;
+
+            var langCode = ProcessingConfig.Language.ToISO3Code();
+            var trainedDataPath = System.IO.Path.Combine(PathConfig.TrainedData, $"{langCode}.traineddata");
+            if (!System.IO.File.Exists(trainedDataPath))
+                return;
+
+            Bitmap ocrIcon = _icon.Rescale(ProcessingConfig.InverseScale * 2);
+            try
+            {
+                var titleHeight = Math.Min(
+                    ocrIcon.Height,
+                    (int)Math.Round(ProcessingConfig.BaseSlotSize * (40f / 63f))
+                );
+                var titleLeft = Math.Min(ocrIcon.Width - 1, (int)Math.Floor(ocrIcon.Width * 0.55f));
+                using var title = ocrIcon.Crop(titleLeft, 0, ocrIcon.Width - titleLeft, titleHeight);
+                using var titleMat = title.ToMat();
+                using var gray =
+                    titleMat.Channels() == 1 ? titleMat.Clone() : titleMat.CvtColor(ColorConversionCodes.BGR2GRAY);
+                using var binary = gray.Threshold(110, 255, ThresholdTypes.Binary);
+                Cv2.BitwiseNot(binary, binary);
+                using var enlarged = binary.Resize(new OpenCvSharp.Size(), 3, 3, InterpolationFlags.Cubic);
+                using var filteredBitmap = enlarged.ToBitmap();
+                using var pix = PixConverter.ToPix(filteredBitmap);
+
+                string text;
+                var tesseractEngine = GetTesseractEngine();
+                lock (tesseractEngine)
+                {
+                    using var result = tesseractEngine.Process(pix, PageSegMode.SingleLine);
+                    text = result.GetText();
+                }
+
+                var slotSize = IconSlotSize();
+                var items = _config.RatStashDB.GetItems(item =>
+                {
+                    var size = new Vector2(item.GetSlotSize());
+                    return size == slotSize || size == slotSize.Flipped;
+                });
+                var verifiedItem = FindUniqueExactShortName(items, text);
+                if (verifiedItem == null)
+                    return;
+
+                _item = verifiedItem;
+                _itemExtraInfo = null;
+                _detectionConfidence = 1;
+                _rotated = new Vector2(verifiedItem.GetSlotSize()) != slotSize;
+                Logger.LogDebug(
+                    $"Verified low-confidence template match as '{verifiedItem.ShortName}' using icon title OCR."
+                );
+            }
+            finally
+            {
+                if (!ReferenceEquals(ocrIcon, _icon))
+                    ocrIcon.Dispose();
+            }
+        }
+
+        internal static Item FindUniqueExactShortName(IEnumerable<Item> items, string ocrText)
+        {
+            var normalizedText = NormalizeOcrShortName(ocrText);
+            if (string.IsNullOrWhiteSpace(normalizedText))
+                return null;
+
+            var matches = items.Where(item => NormalizeOcrShortName(item.ShortName) == normalizedText).Take(2).ToList();
+            return matches.Count == 1 ? matches[0] : null;
+        }
+
+        internal static string NormalizeOcrShortName(string value)
+        {
+            if (string.IsNullOrWhiteSpace(value))
+                return "";
+
+            return OcrShortNameSanitizer.Replace(value.CyrillicToLatin().Trim(), "").Trim().ToLowerInvariant();
+        }
+
         /// <summary>
         /// Set the item to one, best matching the scanned title
         /// </summary>

src/ScanEngine/Processing/Inventory.cs

@@ -13,6 +13,7 @@ public class Inventory : IDisposable
     {
         private readonly Config _config;
         private readonly Mat _image;
+        private Mat _normalGridMask;
         private Mat _grid;
         private Mat _vertGrid;
         private List<Rect> _boundingBoxes = new();
@@ -113,6 +114,7 @@ private void DetectInventoryGridNormal()
             var maxGridScalar = new Scalar(maxHue, maxSaturation, maxValue);
             using var hsv = _image.CvtColor(ColorConversionCodes.BGR2HSV_FULL);
             using var colorFilter = hsv.InRange(minGridScalar, maxGridScalar);
+            _normalGridMask = colorFilter.Clone();
 
             Logger.LogDebugMat(colorFilter, "inventory/colorFilter");
 
@@ -217,6 +219,8 @@ private void ParseInventoryGridNormal()
                 }
             }
 
+            AddContourIconsFromNormalGrid();
+
             // Quarter of the normal sized slot
             var overlapThreshold = scaledSlotSize / 2;
 
@@ -251,6 +255,56 @@ private void ParseInventoryGridNormal()
             }
         }
 
+        private void AddContourIconsFromNormalGrid()
+        {
+            if (_normalGridMask == null || _normalGridMask.Empty())
+                return;
+
+            using var contourSource = _normalGridMask.Clone();
+            var contours = contourSource.FindContoursAsArray(
+                RetrievalModes.List,
+                ContourApproximationModes.ApproxSimple
+            );
+            var scaledSlotSize = (int)ProcessingConfig.ScaledSlotSize;
+            var tolerance = Math.Max(3, (int)Math.Ceiling(scaledSlotSize * 0.08));
+            var imageBounds = new Rect(0, 0, _image.Width, _image.Height);
+
+            using var image = _image.ToBitmap();
+            foreach (var contour in contours)
+            {
+                var rect = Cv2.BoundingRect(contour);
+                if (
+                    !IsSlotAlignedDimension(rect.Width, scaledSlotSize, tolerance)
+                    || !IsSlotAlignedDimension(rect.Height, scaledSlotSize, tolerance)
+                )
+                    continue;
+
+                var scaledSlotSizeVec = new Vector2(scaledSlotSize, scaledSlotSize);
+                var topLeft = new Vector2(rect.Location) - scaledSlotSizeVec / 8;
+                var size = new Vector2(rect.Size) + scaledSlotSizeVec / 4;
+                var paddedRect = new Rect(topLeft, size).Intersect(imageBounds);
+                if (paddedRect.Width <= 0 || paddedRect.Height <= 0)
+                    continue;
+
+                topLeft = new Vector2(paddedRect.Location);
+                size = new Vector2(paddedRect.Size);
+                if (_icons.Any(icon => icon.Position == topLeft && icon.Size == size))
+                    continue;
+
+                var iconImage = image.Crop(topLeft.X, topLeft.Y, size.X, size.Y);
+                _icons.Add(new Icon(iconImage, topLeft, size, _config));
+            }
+        }
+
+        private static bool IsSlotAlignedDimension(int pixels, int slotSize, int tolerance)
+        {
+            if (pixels < slotSize - tolerance)
+                return false;
+
+            var slots = Math.Max(1, (int)Math.Round(pixels / (double)slotSize));
+            return Math.Abs(pixels - slots * slotSize) <= tolerance;
+        }
+
         /// <summary>
         /// Creates the stride-aware fast indexer used by the grid hot path.
         /// </summary>
@@ -550,6 +604,7 @@ public void Dispose()
             foreach (Icon icon in _icons)
                 icon.Dispose();
             _image.Dispose();
+            _normalGridMask?.Dispose();
             _grid?.Dispose();
             _vertGrid?.Dispose();
             _disposed = true;

tests/RatScanner.Tests/OpenCvPipelineTests.cs

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Drawing;
 using System.IO;
+using System.Linq;
 using OpenCvSharp;
 using OpenCvSharp.Extensions;
 using RatEye;
@@ -140,6 +141,57 @@ public void Normal_inventory_rejects_a_slot_scale_too_small_for_safe_edge_walkin
         Assert.Contains("at least two pixels", exception.Message, StringComparison.Ordinal);
     }
 
+    [Theory]
+    [InlineData("F-1/", "f-1")]
+    [InlineData(" F-1[\r\n", "f-1")]
+    [InlineData("", "")]
+    public void Icon_OCR_short_name_normalization_removes_UI_noise(string source, string expected) =>
+        Assert.Equal(expected, RatEye.Processing.Icon.NormalizeOcrShortName(source));
+
+    [Fact]
+    public void Icon_OCR_short_name_verification_requires_a_unique_exact_match()
+    {
+        RatStash.Item expected = new() { Id = "f1", ShortName = "F-1" };
+        RatStash.Item other = new() { Id = "other", ShortName = "Other" };
+
+        Assert.Same(expected, RatEye.Processing.Icon.FindUniqueExactShortName([expected, other], "F-1/"));
+        Assert.Null(
+            RatEye.Processing.Icon.FindUniqueExactShortName(
+                [expected, new RatStash.Item { Id = "duplicate", ShortName = "F-1" }],
+                "F-1"
+            )
+        );
+    }
+
+    [Fact]
+    public void Inventory_locates_adjacent_current_ui_cells_from_one_pixel_borders()
+    {
+        using Bitmap source = new(250, 150);
+        using (Graphics graphics = Graphics.FromImage(source))
+        {
+            graphics.Clear(System.Drawing.Color.Black);
+            using Pen gridPen = new(System.Drawing.Color.FromArgb(73, 81, 84), 1);
+            graphics.DrawRectangle(gridPen, 11, 36, 84, 84);
+            graphics.DrawRectangle(gridPen, 95, 36, 84, 84);
+        }
+
+        Config config = new()
+        {
+            ProcessingConfig = new Config.Processing
+            {
+                Scale = 4f / 3f,
+                InventoryConfig = new Config.Processing.Inventory { OptimizeHighlighted = false },
+            },
+        };
+
+        using RatEyeEngine engine = new(config, RatStash.Database.FromItems([]));
+        using RatEye.Processing.Inventory inventory = engine.NewInventory(source);
+
+        Assert.Equal(2, inventory.Icons.Count());
+        Assert.NotNull(inventory.LocateIcon(new Vector2(53, 79)));
+        Assert.NotNull(inventory.LocateIcon(new Vector2(137, 79)));
+    }
+
     [Fact]
     public void Blank_inspection_is_a_low_confidence_failure_without_ocr()
     {
@@ -245,6 +297,8 @@ public void Static_icon_template_matching_identifies_an_exact_generated_fixture(
                 using Mat iconMat = BitmapConverter.ToMat(iconSource);
                 Assert.True(Cv2.ImWrite(iconPath, iconMat));
             }
+            using (Bitmap blankSource = new(64, 64))
+                blankSource.Save(Path.Combine(root, "blank.png"), System.Drawing.Imaging.ImageFormat.Png);
             File.WriteAllText(Path.Combine(root, "broken.png"), "not an image");
 
             RatStash.Item expected = new()
@@ -263,12 +317,20 @@ public void Static_icon_template_matching_identifies_an_exact_generated_fixture(
                 Width = 1,
                 Height = 1,
             };
+            RatStash.Item blank = new()
+            {
+                Id = "blank",
+                Name = "Blank fixture",
+                ShortName = "Blank",
+                Width = 1,
+                Height = 1,
+            };
             Config config = CreateProcessingConfig(optimizeHighlighted: false);
             config.PathConfig.StaticIcons = root;
             config.ProcessingConfig.IconConfig.UseStaticIcons = true;
             config.ProcessingConfig.IconConfig.ScanRotatedIcons = false;
 
-            using RatEyeEngine engine = new(config, RatStash.Database.FromItems([expected, broken]));
+            using RatEyeEngine engine = new(config, RatStash.Database.FromItems([expected, broken, blank]));
             engine.Config.IconManager.EnsureStaticIconsLoaded(new Vector2(1, 1));
             KeyValuePair<string, Mat> loaded = Assert.Single(engine.Config.IconManager.StaticIcons[new Vector2(1, 1)]);
             Assert.EndsWith("fixture.png", loaded.Key, StringComparison.Ordinal);

tests/RatScanner.Tests/PresentationServicesTests.cs

@@ -285,6 +285,11 @@ public void Static_icons_are_loaded_one_slot_size_at_a_time()
     private static void WriteIcon(string path, int width, int height)
     {
         using System.Drawing.Bitmap bitmap = new(width, height);
+        using (System.Drawing.Graphics graphics = System.Drawing.Graphics.FromImage(bitmap))
+        {
+            using System.Drawing.Brush brush = new System.Drawing.SolidBrush(System.Drawing.Color.White);
+            graphics.FillEllipse(brush, width / 4, height / 4, width / 2, height / 2);
+        }
         bitmap.Save(path, System.Drawing.Imaging.ImageFormat.Png);
     }
 }