annotations/Azaion.Annotator/GalleryManager.cs

using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.IO;
using Azaion.Annotator.DTO;
using Microsoft.Extensions.Logging;
using Color = System.Drawing.Color;
using Size = System.Windows.Size;

namespace Azaion.Annotator;

public class GalleryManager(Config config, ILogger<GalleryManager> logger) : IGalleryManager
{
    public int ThumbnailsCount { get; set; }
    public int ImagesCount { get; set; }

    private DirectoryInfo? _thumbnailsDirectory;
    private DirectoryInfo ThumbnailsDirectory
    {
        get
        {
            if (_thumbnailsDirectory != null)
                return _thumbnailsDirectory;

            var dir = new DirectoryInfo(config.ThumbnailsDirectory);
            if (!dir.Exists)
                Directory.CreateDirectory(config.ThumbnailsDirectory);
            _thumbnailsDirectory = new DirectoryInfo(config.ThumbnailsDirectory);
            return _thumbnailsDirectory;
        }
    }

    public async Task RefreshThumbnails()
    {
        var prefixLen = Config.ThumbnailPrefix.Length;

        var thumbnails = ThumbnailsDirectory.GetFiles()
            .Select(x => Path.GetFileNameWithoutExtension(x.Name)[..^prefixLen])
            .GroupBy(x => x)
            .Select(gr => gr.Key)
            .ToHashSet();
        ThumbnailsCount = thumbnails.Count;

        var files = new DirectoryInfo(config.ImagesDirectory).GetFiles();
        ImagesCount = files.Length;

        foreach (var img in files)
        {
            var imgName = Path.GetFileNameWithoutExtension(img.Name);
            if (thumbnails.Contains(imgName))
                continue;
            try
            {
                await CreateThumbnail(img.FullName);
            }
            catch (Exception e)
            {
                logger.LogError(e, $"Failed to generate thumbnail for {img.Name}");
            }

            ThumbnailsCount++;
        }
    }

    public async Task CreateThumbnail(string imgPath)
    {
        var bitmap = await GenerateThumbnail(imgPath);
        if (bitmap != null)
        {
            var thumbnailName = Path.Combine(ThumbnailsDirectory.FullName, $"{Path.GetFileNameWithoutExtension(imgPath)}{Config.ThumbnailPrefix}.jpg");
            bitmap.Save(thumbnailName, ImageFormat.Jpeg);
        }
    }

    private async Task<Bitmap?> GenerateThumbnail(string imgPath)
    {
        var width = (int)config.ThumbnailConfig.Size.Width;
        var height = (int)config.ThumbnailConfig.Size.Height;

        var imgName = Path.GetFileName(imgPath);
        var labelName = Path.Combine(config.LabelsDirectory, $"{Path.GetFileNameWithoutExtension(imgPath)}.txt");

        var originalImage = Image.FromStream(new MemoryStream(await File.ReadAllBytesAsync(imgPath)));

        var bitmap = new Bitmap(width, height);

        using var g = Graphics.FromImage(bitmap);
        g.CompositingQuality = CompositingQuality.HighSpeed;
        g.SmoothingMode = SmoothingMode.HighSpeed;
        g.InterpolationMode = InterpolationMode.Default;

        var size = new Size(originalImage.Width, originalImage.Height);
        if (!File.Exists(labelName))
        {
            File.Move(imgPath, Path.Combine(config.UnknownImages, imgName));
            logger.LogInformation($"No labels found for image {imgName}! Moved image to the {config.UnknownImages} folder.");
            return null;
        }
        var labels = (await YoloLabel.ReadFromFile(labelName))
            .Select(x => new CanvasLabel(x, size, size))
            .ToList();

        var thumbWhRatio = width / (float)height;
        var border = config.ThumbnailConfig.Border;

        var frameX = 0.0;
        var frameY = 0.0;
        var frameHeight = size.Height;
        var frameWidth = size.Width;

        if (labels.Any())
        {
            var labelsMinX = labels.Min(x => x.X);
            var labelsMaxX = labels.Max(x => x.X + x.Width);

            var labelsMinY = labels.Min(x => x.Y);
            var labelsMaxY = labels.Max(x => x.Y + x.Height);

            var labelsHeight = labelsMaxY - labelsMinY + 2 * border;
            var labelsWidth = labelsMaxX - labelsMinX + 2 * border;

            if (labelsWidth / labelsHeight > thumbWhRatio)
            {
                frameWidth = labelsWidth;
                frameHeight = Math.Min(labelsWidth / thumbWhRatio, size.Height);
                frameX = Math.Max(0, labelsMinX - border);
                frameY = Math.Max(0, 0.5 * (labelsMinY + labelsMaxY - frameHeight) - border);
            }
            else
            {
                frameHeight = labelsHeight;
                frameWidth = Math.Min(labelsHeight * thumbWhRatio, size.Width);
                frameY = Math.Max(0, labelsMinY - border);
                frameX = Math.Max(0, 0.5 * (labelsMinX + labelsMaxX - frameWidth) - border);
            }
        }

        var scale = frameHeight / height;
        g.DrawImage(originalImage, new Rectangle(0, 0, width, height), new RectangleF((float)frameX, (float)frameY, (float)frameWidth, (float)frameHeight), GraphicsUnit.Pixel);

        foreach (var label in labels)
        {
            var color = config.AnnotationClassesDict[label.ClassNumber].Color;
            var brush = new SolidBrush(Color.FromArgb(color.A, color.R, color.G, color.B));

            var rectangle = new RectangleF((float)((label.X - frameX) / scale), (float)((label.Y - frameY) / scale), (float)(label.Width / scale), (float)(label.Height / scale));
            g.FillRectangle(brush, rectangle);
        }
        return bitmap;
    }
}

public interface IGalleryManager
{
    int ThumbnailsCount { get; set; }
    int ImagesCount { get; set; }
    Task CreateThumbnail(string imgPath);
    Task RefreshThumbnails();
}