将矩形分成最大大小较小，相等的整数矩形/平铺

Question

我需要以非常大的分辨率创建屏幕截图。 由于分辨率大于渲染器支持的分辨率，因此需要将其拆分为较小的分辨率，然后再将其缝合在一起。

我已经弄清楚了矩形的拼接/渲染部分，但是我一直在努力寻找用于每个图块的最佳矩形分辨率。

我的渲染器的限制为4096x4096。

对于16384x16384之类的分辨率，这很容易弄清楚：4096x4096的4 * 4矩形。

我的输入分辨率并不总是2的幂，但是这样的示例可能是5005x5000，为此，最佳矩形大小将是5 * 2 1001x2500的矩形。

我要寻找的是一个功能，当给定所需的分辨率和最大分辨率时，输出的最大分辨率内的分辨率可以乘以达到所需的分辨率。

像这样：

public IntRect FindOptimalTileSize(IntRect desiredResolution, IntRect maximumTileSize)
{
    //some magic
    return new IntRect(magic.X, magic.Y);
}

连续的输出要求：

• 分辨率x和y必须为整数
• 分辨率x和y必须小于给定的最大x和y
• 分辨率x和y必须是期望分辨率的整数除法
• x和y的分辨率应尽可能高，只要它们满足其他规则
• 无需保留长宽比

我曾尝试在互联网上寻找解决方案，但这些似乎都是针对另一个更常见的用例。

并非总是可以找到一个满足我所有规则的矩形，在这种情况下，我希望函数返回可区分的内容，例如-1x-1

Answer 1

我不是数学专家，但这可能会为您提供一个起点。 此代码是草图。 它尚未投入生产。 它不是beta质量的。 这只是一个草图，您将不得不做很多工作来清理它并使之可用。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1 {
    class Program {
        static void Main(string[] args) {

            int resultX = -1;
            int resultY = -1;
            int sourceX = 5005;
            int sourceY = 5000;
            int targetX = 4096;
            int targetY = 4096;

            if (sourceX <= targetX) { resultX = sourceX; }
            if (sourceY <= targetY) { resultY = sourceY; }
            if (IsValid(resultX, resultY)) {
                //  return the results
                Console.WriteLine($"x={resultX}, y={resultY}");
                return;
            }

            for (int index=targetX; 0 < index; index--) {
                double result = (double)sourceX / index;
                if (0 == result - (int)result) {
                    resultX = index;
                    break;
                }
            }

            for (int index = targetY; 0 < index; index--) {
                double result = (double)sourceY / index;
                if (0 == result - (int)result) {
                    resultY = index;
                    break;
                }
            }

            Console.WriteLine($"x={resultX}, y={resultY}");
            Console.ReadKey(true);
        }


        static bool IsValid(int x, int y) {
            return (-1 != x) && (-1 != y);
        }
    }
}

Answer 2

您的问题可以分解为两个相等的问题：找到整数n的相等整数分区p，其中p <m。

使用扩展方法和一些帮助程序，您可以生成n的素因式分解：

static IEnumerable<int> PotentialPrimes() { // fails once int.MaxValue exceeded
    yield return 2;
    yield return 3;
    var pp = 5;
    for (; ; ) {
        yield return pp;
        yield return pp + 2;
        pp += 6;
    }
}
public static IEnumerable<int> Primes() {
    return PotentialPrimes().Where(p => {
        var sqrt = (int)Math.Floor(Math.Sqrt(p));
        return !PotentialPrimes().TakeWhile(f => f <= sqrt)
                                 .Any(f => p % f == 0);
    });
}

public static IEnumerable<int> PrimeFactors(this int n) {
    var maxDivisor = (int)Math.Floor(Math.Sqrt(n));
    var testDivisors = Primes().TakeWhile(pp => pp < maxDivisor);

    foreach (var f in testDivisors)
        for (; n % f == 0; n /= f)
            yield return f;

    if (n != 1)
        yield return n;
}

现在，使用素数分解，您可以找到小于m的最大p（根据注释，如果n> m，则返回n）：

public static int LargestPartition(this int n, int maxPartitionSize) {
    var factors = n.PrimeFactors().Where(f => f <= maxPartitionSize);
    if (factors.Any()) {
        var flist = factors.OrderByDescending(f => f).ToList();
        var partition = flist.First();
        foreach (var f in flist.Skip(1)) {
            var tp = partition * f;
            if (tp <= maxPartitionSize)
                partition = tp;
        }

        return partition;
    }
    else
        return n;
}

最后，只需将LargestPartition应用于矩形的每一侧：

public IntRect FindOptimalTileSize(IntRect desiredResolution, IntRect maximumTileSize) {
    return new IntRect(desiredResolution.X.LargestPartition(maximumTileSize.X),
                       desiredResolution.Y.LargestPartition(maximumTileSize.Y));
}

注意：我将我的PrimeFactors函数更新为更快，以应对更常见的情况，以防有人遇到此情况。 以前我无法在一小时内将2转换为int.MaxValue ，现在需要36秒。 如果性能仍然是一个问题，可以替换Math.Sqrt ，但是我认为到那时其他开销Math.Sqrt主导地位。