sharplib/math/GuillotinePacker.cs

// Copyright (c) Xenko contributors (https://xenko.com) and Silicon Studio Corp. (https://www.siliconstudio.co.jp)
// Distributed under the MIT license. See the LICENSE.md file in the project root for more information.

using System;
using System.Collections.Generic;
using System.Runtime.Serialization;

namespace math
{
    /// <summary>
    /// Implementation of a "Guillotine" packer.
    /// More information at http://clb.demon.fi/files/RectangleBinPack.pdf.
    /// </summary>
    public class GuillotinePacker
    {
        private readonly List<Rectangle> freeRectangles = new List<Rectangle>();
        private readonly List<Rectangle> tempFreeRectangles = new List<Rectangle>();

        /// <summary>
        /// A delegate callback used by <see cref="TryInsert"/>
        /// </summary>
        /// <param name="cascadeIndex">The index of the rectangle</param>
        /// <param name="rectangle">The rectangle found</param>
        public delegate void InsertRectangleCallback(int cascadeIndex, ref Rectangle rectangle);

        /// <summary>
        /// Current width used by the packer.
        /// </summary>
        public int Width { get; private set; }

        /// <summary>
        /// Current height used by the packer.
        /// </summary>
        public int Height { get; private set; }

        /// <summary>
        /// Clears the specified region.
        /// </summary>
        /// <param name="width">The width.</param>
        /// <param name="height">The height.</param>
        public void Clear(int width, int height)
        {
            freeRectangles.Clear();
            freeRectangles.Add(new Rectangle { X = 0, Y = 0, Width = width, Height = height });

            Width = width;
            Height = height;
        }

        /// <summary>
        /// Clears the whole region.
        /// </summary>
        public virtual void Clear()
        {
            Clear(Width, Height);
        }

        /// <summary>
        /// Frees the specified old rectangle.
        /// </summary>
        /// <param name="oldRectangle">The old rectangle.</param>
        public void Free(ref Rectangle oldRectangle)
        {
            freeRectangles.Add(oldRectangle);
        }

        /// <summary>
        /// Tries to fit a single rectangle with the specified width and height.
        /// </summary>
        /// <param name="width">Width requested.</param>
        /// <param name="height">Height requested</param>
        /// <param name="bestRectangle">Fill with the rectangle if it was successfully inserted.</param>
        /// <returns><c>true</c> if it was successfully inserted.</returns>
        public bool Insert(int width, int height, ref Rectangle bestRectangle)
        {
            return Insert(width, height, freeRectangles, ref bestRectangle);
        }

        /// <summary>
        /// Tries to fit multiple rectangle with (width, height).
        /// </summary>
        /// <param name="width">Width requested.</param>
        /// <param name="height">Height requested</param>
        /// <param name="count">The number of rectangle to fit.</param>
        /// <param name="inserted">A callback called for each rectangle successfully fitted.</param>
        /// <returns><c>true</c> if all rectangles were successfully fitted.</returns>
        public bool TryInsert(int width, int height, int count, InsertRectangleCallback inserted)
        {
            var bestRectangle = new Rectangle();
            tempFreeRectangles.Clear();
            foreach (var freeRectangle in freeRectangles)
            {
                tempFreeRectangles.Add(freeRectangle);
            }

            for (var i = 0; i < count; ++i)
            {
                if (!Insert(width, height, tempFreeRectangles, ref bestRectangle))
                {
                    tempFreeRectangles.Clear();
                    return false;
                }

                inserted(i, ref bestRectangle);
            }

            // if the insertion went well, use the new configuration
            freeRectangles.Clear();
            foreach (var tempFreeRectangle in tempFreeRectangles)
            {
                freeRectangles.Add(tempFreeRectangle);
            }
            tempFreeRectangles.Clear();

            return true;
        }

        private static bool Insert(int width, int height, List<Rectangle> freeRectanglesList, ref Rectangle bestRectangle)
        {
            // Info on algorithm: http://clb.demon.fi/files/RectangleBinPack.pdf
            int bestScore = int.MaxValue;
            int freeRectangleIndex = -1;

            // Find space for new rectangle
            for (int i = 0; i < freeRectanglesList.Count; ++i)
            {
                var currentFreeRectangle = freeRectanglesList[i];
                if (width == currentFreeRectangle.Width && height == currentFreeRectangle.Height)
                {
                    // Perfect fit
                    bestRectangle.X = currentFreeRectangle.X;
                    bestRectangle.Y = currentFreeRectangle.Y;
                    bestRectangle.Width = width;
                    bestRectangle.Height = height;
                    freeRectangleIndex = i;
                    break;
                }
                if (width <= currentFreeRectangle.Width && height <= currentFreeRectangle.Height)
                {
                    // Can fit inside
                    // Use "BAF" heuristic (best area fit)
                    var score = currentFreeRectangle.Width * currentFreeRectangle.Height - width * height;
                    if (score < bestScore)
                    {
                        bestRectangle.X = currentFreeRectangle.X;
                        bestRectangle.Y = currentFreeRectangle.Y;
                        bestRectangle.Width = width;
                        bestRectangle.Height = height;
                        bestScore = score;
                        freeRectangleIndex = i;
                    }
                }
            }

            // No space could be found
            if (freeRectangleIndex == -1)
                return false;

            var freeRectangle = freeRectanglesList[freeRectangleIndex];

            // Choose an axis to split (trying to minimize the smaller area "MINAS")
            int w = freeRectangle.Width - bestRectangle.Width;
            int h = freeRectangle.Height - bestRectangle.Height;
            var splitHorizontal = (bestRectangle.Width * h > w * bestRectangle.Height);

            // Form the two new rectangles.
            var bottom = new Rectangle { X = freeRectangle.X, Y = freeRectangle.Y + bestRectangle.Height, Width = splitHorizontal ? freeRectangle.Width : bestRectangle.Width, Height = h };
            var right = new Rectangle { X = freeRectangle.X + bestRectangle.Width, Y = freeRectangle.Y, Width = w, Height = splitHorizontal ? bestRectangle.Height : freeRectangle.Height };

            if (bottom.Width > 0 && bottom.Height > 0)
                freeRectanglesList.Add(bottom);
            if (right.Width > 0 && right.Height > 0)
                freeRectanglesList.Add(right);

            // Remove previously selected freeRectangle
            if (freeRectangleIndex != freeRectanglesList.Count - 1)
                freeRectanglesList[freeRectangleIndex] = freeRectanglesList[freeRectanglesList.Count - 1];
            freeRectanglesList.RemoveAt(freeRectanglesList.Count - 1);

            return true;
        }
    }
}