一组圆的边界圆

Question

我正在尝试在 Java 中实现以下内容。

给定一个不同大小（可能）和位置的圆的列表，确定一个正好包含所有圆的大圆（位置和大小）。

public class Circle {
    public int x, y, radius;
}

有什么想法吗？

Answer 1

你可以找到最大边界（xmin，xmax，ymin，ymax），然后在两个轴上取最大值，然后让 java 在那个正方形上画一个椭圆，或者取它的中心和边作为直径。

没有？

问候， 斯蒂芬

Answer 2

有两个圆圈很容易。一条穿过两个中心的线将到达一个包围圈与它们接触的周边。

对于更多的圆圈，您需要在每个周边点上应用 FEM（有限元分析-http://en.wikipedia.org/wiki/Finite_element_method），并有可能成为与外圈的接触点。例如，这排除了那些面向其他圆圈的部分。当您继续对您的点应用不同的半径时，计算仍然相当大，直到您找到与所有其他点相交的最小半径 - 您的封闭圆的中心。

Answer 3

糟糕，以下内容不起作用，如 cmets 中所述：

首先解决 3 个圆圈的问题。在这种情况下，外接圆将接触三个内圆中的每一个，您可以找到它的中心作为两条双曲线的交点。 （到两个固定点的距离具有给定差异的点的轨迹是双曲线）。经过一点代数，这归结为一个二次方程。

现在通过归纳添加更多内圈。在每一步开始时，您都知道包含所有旧圆的最小圆；它将触及三个特定的旧“角”圈。如果新圈子在那个圈子之内，则无事可做。如果不是，则将新圆与所有三种方法结合以选择两个旧角圆并计算每个三元组的外接圆。其中一个应该包括第四个，现在它不再是一个角圈了。

继续操作，直到添加完所有圈子。

这给出了一个有界舍入误差的线性时间算法（因为每个外接圆都是从原始输入坐标重新计算的）。

Answer 4

我认为这可以分三步完成：

• 第一个边界圆c1：

  • 中心由 x_c1 = (x_max + x _确定分钟) / 2 和 y_c1 = (y_max + y_min em>) / 2.
  • 对于每个圆，计算其中心到c1 中心的距离加上它的半径（我称之为超距离）。 这些值的最大值是c1 的半径。对应的圆圈是a。

• 第二个边界圆c2： （在此步骤中，您将 c1 的中心尽可能向 a 方向移动。）

  • 对于除 a 之外的每个圆，确定您必须将 c1 的中心向 a 方向移动多少，以使- 从那里到这个圆圈的距离与到 a 的距离相同。其中的最小值决定了 c2 的中心。对应的圆圈是b。到a和b的超距离（两者相同）就是c2的半径。

• 第三个边界圆c3： （在此步骤中，您将 c2 的中心向 a 和 b 之间的方向移动尽可能远。）

  • 确定您可以移动 c2 的方向 v，使得到 a 和 b 的超距离> 保持不变。
  • 对于除 a 和 b 之外的每个圆，确定您必须将 c2 的中心向 v 使得从那里到这个圆的超距离与到 a 和 b 的距离相同。这个最小值决定了 c3 的中心。半径是找到的三个圆的超距离。

我相信 c3 是 解决方案 (edit) 一个很好的初步近似。您可以通过迭代删除第一个圆圈并重复第三步来获得更好的解决方案。如果你到达一组你已经看到的三个圆圈，这应该可能是最终的解决方案。

Answer 5

这是一个非常困难的问题，我只是概述了可能的方法，你必须自己完成它。我假设您想找到最小边界圆。 将您的问题形式化 - 对于 i = 1..N 有 xi, yi, ri，您正在寻找点 [x, y] 使得：

max(distance([x, y], [xi, yi]) + ri)

是最小的。这是一个非平凡的极小极大问题。先看一下这个问题的简单版Smallest circle problem，只是为了分：

max(distance([x, y], [xi, yi]))

所以首先尝试改进上面链接中提出的算法来解决更复杂的情况。如果这种方式无法通过，您可能需要选择 quadratic programming。祝你好运...

Answer 6

我建议的算法与 Svante 的算法相似，但有一些不同。

这个想法是首先创建一个包含所有子圆的圆，然后像气泡一样缩小它，直到它被 1,2 或 3 个圆固定。

第一个近似值：

圆心为 0,0 且半径为 max（距子圆 0,0 的距离 + 子圆的半径）

如果决定圆半径的子圆包围了所有其他子圆，那么它通常是正确的结果，并且可以返回

第二个近似值：

减小在第一次近似中找到的圆的半径，同时保持它与它被“固定”到的子圆相切，将中心移向固定的子圆，直到它与另一个子圆相切。

最终结果：

再次减小圆的半径，使其与上面找到的两个子圆相切，直到另一个子圆与圆相切，或者圆的中心位于两个子圆的中心之间的线上固定到。这应该是最小值，因为如果没有一个子圆“突破”，就无法从这里减小圆的半径

我不确定的算法部分是“减小半径直到另一个子圆变为切线”部分。显然，二分搜索可以在相当长的时间内给出足够好的近似值，但我怀疑你可以将其简化为一个方程。

Answer 7

我认为这本身不是包装问题。这听起来更像凸包。我认为问题是：

在飞机上给你一组圆圈。找出每个圆的每个边界点都位于包含圆的边界内或边界上的最小圆的中心点和半径。

为此，您可以递归运行：找到包含前两个圆的最小圆（并且该圆的中心位于连接两个中心的线上，并且它的半径也应该很容易确定），替换第一个两个圈与新圈，并重复。

这个算法的正确性属于数学。

Answer 8

我会尝试找到最西端的点，然后是最南端的点，然后以这些点为直径做一个圆。 为了找到这些点，我会循环穿过圆的中心和它们的半径。

所以结果是：

 initiate max object and min object to average center of circle and zero radius
 For every circle object
     calculate topmost western point of the circle
     check if further away than current point
     if further, calculate position of topmost western point required to pass over this new point and set as new min object
     calculate down most eastern point of the circle
     do the same as previous step, only for max object
 make a circle with center equals to middle of min-max line and radius equals to half min-max line length

如果您是书呆子类型，好的大学图书馆会收藏以下内容：E.Welzl，最小的封闭磁盘（球和椭圆体），H. Maurer（主编），计算机科学的新结果和新趋势，讲座笔记计算机科学，卷。 555，施普林格出版社，359-37（1991）

如果你想阅读 C++ 代码并将其改编为 Java，http://miniball.sourceforge.net/。 当然，对于圆圈，d=2。

Answer 9

维基百科文章Smallest circle problem 描述了一种线性平均时间算法，用于初始圆的大小相等的情况。将其推广到不同大小的初始圆圈看起来很简单，尽管我不确定复杂性分析会发生什么。

Answer 10

我有一个大约 O(n⁴) 真正的解决方案，我正在用 JavaScript 为产品实现：

• 您需要一个函数来确定解决方案是否有效：准确地说，是一个检查所有圆是否都位于建议的超级圆内的函数。这是相当简单的：对于每个圆 C_i，要求从超级圆的中心到 C_i 的中心的距离加上 C _的半径i 小于等于超圆的半径。

• 然后，从每对和每三组圆中构造一个超级圆。

  • 对于一对，从 C_i 的中心到 C_j 的中心画一条线。将线在每一端延伸相应圆的半径。线的中点为超圆的中心，半径为线长的一半。

  • 对于 3 个圆，这是 Apollonius 的问题：http://mathworld.wolfram.com/ApolloniusProblem.html；请注意，您需要获得正确的标志才能获得包含所有三个圆圈的标志。

• 正确的解是半径最小的有效超圆。

这是我的代码：

'use strict';

/**
 * Epsilon value for floating point equality.
 * @const
 */
var EPSILON = 1E-6;

/**
 * Calculates the minimum bounding circle for a set of circles.
 * O(n^4)
 *
 * @param {Array.<Object.<string, number>>} circles A list of 2+ circles.
 * @return {Object.<string, number>} {cx, cy, radius} of the circle.
 */
function minimumBoundingCircleForCircles(circles) {

    var areAllCirclesInOrOnCircle = function(circle) {
        for (var i = 0; i < circles.length; i++) {
            if (!isCircleInOrOnCircle(circles[i], circle)) return false;
        }
        return true;
    };

    // try every pair and triple
    var best = {radius: 9E9};

    for (var i = 0; i < circles.length; i++) {
        for (var j = i + 1; j < circles.length; j++) {
            var circle = circleFrom2Circles(circles[i], circles[j]);
            if (areAllCirclesInOrOnCircle(circle) &&
                circle.radius < best.radius) {
                best.cx = circle.cx; best.cy = circle.cy;
                best.radius = circle.radius;
            }

            for (var k = j + 1; k < circles.length; k++) {
                var signs = [-1, 1, 1, 1];
                circle = apollonius(circles[i], circles[j], circles[k],
                                    signs);
                if (areAllCirclesInOrOnCircle(circle) &&
                    circle.radius < best.radius) {
                    best.cx = circle.cx; best.cy = circle.cy;
                    best.radius = circle.radius;
                }
            }
        }
    }

    return best;
}


/**
 * Calculates a circle from 2 circles.
 *
 * @param {Object.<string, number>} circle1 The first circle.
 * @param {Object.<string, number>} circle2 The second circle.
 * @return {Object.<string, number>} cx, cy, radius of the circle.
 */
function circleFrom2Circles(circle1, circle2) {

    var angle = Math.atan2(circle1.cy - circle2.cy,
                           circle1.cx - circle2.cx);

    var lineBetweenExtrema = [[circle1.cx + circle1.radius * Math.cos(angle),
                               circle1.cy + circle1.radius * Math.sin(angle)],
                              [circle2.cx - circle2.radius * Math.cos(angle),
                               circle2.cy - circle2.radius * Math.sin(angle)]];

    var center = lineMidpoint(lineBetweenExtrema[0], lineBetweenExtrema[1]);
    return { cx: center[0],
             cy: center[1],
             radius: lineLength(lineBetweenExtrema[0], 
                                lineBetweenExtrema[1]) / 2
           };
}

/**
 * Solve the Problem of Apollonius: a circle tangent to all 3 circles.
 * http://mathworld.wolfram.com/ApolloniusProblem.html
 *
 * @param {Object.<string, number>} circle1 The first circle.
 * @param {Object.<string, number>} circle2 The second circle.
 * @param {Object.<string, number>} circle3 The third circle.
 * @param {Array.<number>} signs The array of signs to use.
 *                               [-1, 1, 1, 1] gives max circle.
 * @return {Object.<string, number>} The tangent circle.
 */
function apollonius(circle1, circle2, circle3, signs) {

    var sqr = function(x) { return x * x };

    var a1 = 2 * (circle1.cx - circle2.cx);
    var a2 = 2 * (circle1.cx - circle3.cx);
    var b1 = 2 * (circle1.cy - circle2.cy);
    var b2 = 2 * (circle1.cy - circle3.cy);
    var c1 = 2 * (signs[0] * circle1.radius + signs[1] * circle2.radius);
    var c2 = 2 * (signs[0] * circle1.radius + signs[2] * circle3.radius);
    var d1 = (sqr(circle1.cx) + sqr(circle1.cy) - sqr(circle1.radius)) -
        (sqr(circle2.cx) + sqr(circle2.cy) - sqr(circle2.radius));
    var d2 = (sqr(circle1.cx) + sqr(circle1.cy) - sqr(circle1.radius)) -
        (sqr(circle3.cx) + sqr(circle3.cy) - sqr(circle3.radius));

    // x = (p+q*r)/s; y = (t+u*r)/s

    var p = b2 * d1 - b1 * d2;
    var q = (- b2 * c1) + (b1 * c2);
    var s = a1 * b2 - b1 * a2;
    var t = - a2 * d1 + a1 * d2;
    var u = a2 * c1 - a1 * c2;

    // you are not expected to understand this.
    // It was generated using Mathematica's Solve function.
    var det = (2 * (-sqr(q) + sqr(s) - sqr(u)));
    var r = (1 / det) * 
        (2 * p * q + 2 * circle1.radius * sqr(s) + 2 * t * u -
         2 * q * s * circle1.cx - 2 * s * u * circle1.cy + signs[3] *
         Math.sqrt(sqr(-2 * p * q - 2 * circle1.radius * sqr(s) - 2 * t * u +
                       2 * q * s * circle1.cx + 2 * s * u * circle1.cy) - 
                   4 * (-sqr(q) + sqr(s) - sqr(u)) * 
                   (-sqr(p) + sqr(circle1.radius) * sqr(s) - sqr(t) +
                    2 * p * s * circle1.cx - sqr(s) * sqr(circle1.cx) + 
                    2 * s * t * circle1.cy - sqr(s) * sqr(circle1.cy))))

    //console.log(r);
    r = Math.abs(r);

    var x = (p + q * r) / s;

    var y = (t + u * r) / s;

    //console.log(x); console.log(y);
    return {cx: x, cy: y, radius: r};
}

/**
 * Is the circle inside/on another circle?
 *
 * @param {Object.<string, number>} innerCircle the inner circle.
 * @param {Object.<string, number>} outerCircle the outer circle.
 * @return {boolean} is the circle inside/on the circle?
 */
function isCircleInOrOnCircle(innerCircle, outerCircle) {
    return ((lineLength([innerCircle.cx, innerCircle.cy],
                        [outerCircle.cx, outerCircle.cy]) +
             innerCircle.radius - EPSILON) < outerCircle.radius);
}


/**
 * Calculates the length of a line.
 * @param {Array.<number>} pt1 The first pt, [x, y].
 * @param {Array.<number>} pt2 The second pt, [x, y].
 * @return {number} The length of the line.
 */
function lineLength(pt1, pt2) {
    return Math.sqrt(Math.pow(pt1[0] - pt2[0], 2) +
                     Math.pow(pt1[1] - pt2[1], 2));
}

/**
 * Calculates the midpoint of a line.
 * @param {Array.<number>} pt1 The first pt, [x, y].
 * @param {Array.<number>} pt2 The second pt, [x, y].
 * @return {Array.<number>} The midpoint of the line, [x, y].
 */
function lineMidpoint(pt1, pt2) {
    return [(pt1[0] + pt2[0]) / 2,
            (pt1[1] + pt2[1]) / 2];
}

Answer 11

例如，"The smallest enclosing ball of balls: combinatorial structure and algorithms" 研究了 迷你球问题。这项研究的一个结果是，至少有一些用于小球问题的算法（如 Welzl 算法）不能轻易地从点推广到球。

上述论文提出了一种O(n)-算法来计算一组球的迷你球（n 是输入球的数量，即在2D）。 Computational Geometry Algorithms Library (CGAL) 中提供了其 C++ 实现。 （您不需要使用所有 CGAL；只需提取所需的头文件和源文件即可。）

注意：我是上述论文的合著者，也是 CGAL Min_sphere_of_spheres 包的作者。