矩形之间的最小距离

Question

我目前正在处理一个涉及矩形的项目，我想创建一个公共方法，它将另一个矩形作为定义并返回它们之间的最小可能距离。 （可以通过分别在每个轴上的每个投影的较小可能距离来计算）。

我还需要另一种方法，它返回两个矩形之间最大可能的距离。我对所需的复杂性感到困惑，不确定如何构建它，并希望得到一些帮助。

这是一个例子：限定

class Rectangle { 
    private int dimensionality; 
    private double[] lowerBound; 
    private double[] upperBound; 

    public Rectangle(int dimensionality){ 
     this.dimensionality = dimensionality; 
     lowerBound = new double[dimensionality]; 
     upperBound = new double[dimensionality]; 
    } 
} 

Answer 1

这是一个简单的解决方案，让你2个矩形之间的最小距离的一个示例：http://imgur.com/IcHTGII

下面是用于开发它的基本构造在你的问题。我不计算这里的最大距离，但扩展我的例子应该相当简单。这可能是一种更有效的方法，但至少我会给你一些启动的东西。

下面是Rectangle类

public class Rectangle { 
    final public Point upperLeftCorner; 
    final public Point upperRightCorner; 
    final public Point lowerLeftCorner; 
    final public Point lowerRightCorner; 
    final public double height; 
    final public double length; 

    public Rectangle(double upper_left_x, double upper_left_y, double height, double length) 
    { 
     upperLeftCorner = new Point(upper_left_x, upper_left_y); 
     upperRightCorner = new Point(upper_left_x + length, upper_left_y); 
     lowerLeftCorner = new Point(upper_left_x, upper_left_y - height); 
     lowerRightCorner = new Point(upper_left_x + length, upper_left_y - height); 
     this.height = height; 
     this.length = length; 
    } 

    //returns true if this and r overlap on the horizontal axis 
    public boolean overlapsHorizontally(Rectangle r) 
    { 
     return Math.abs(upperLeftCorner.x - r.upperLeftCorner.x) <= Math.max(length, r.length); 
    } 

    //returns true if this and r overlap on the vertical axis 
    public boolean overlapsVertically(Rectangle r) 
    { 
     return Math.abs(upperLeftCorner.y - r.lowerLeftCorner.y) <= Math.max(height, r.height); 
    } 

    public double minDistanceFrom(Rectangle r) 
    { 
     //If same rectangle 
     if(this == r) 
     { 
      return 0; 
     } 

     //if they overlap in both directions then they actually overlap, so distance is 0 
     if(overlapsHorizontally(r) && overlapsVertically(r)) 
     { 
      return 0; 
     } 

     if(overlapsHorizontally(r)) 
     { 
      //we know they don't overlap vertically so the result is simply the vertical distance between the 2 closest horizontal sides 
      if(upperLeftCorner.y > r.upperLeftCorner.y) 
      { 
       return lowerLeftCorner.y - r.upperLeftCorner.y; 
      } 
      return r.lowerLeftCorner.y - upperLeftCorner.y; 
     } 
     else if(overlapsVertically(r)) 
     { 
      //we know they don't overlap horizontally so the result is simply the horizontal distance between the 2 closest vertical sides 
      if(upperLeftCorner.x < r.upperLeftCorner.x) 
      { 
       return r.upperLeftCorner.x - upperRightCorner.x; 
      } 
      return upperLeftCorner.x - r.upperRightCorner.x; 
     } 
     else //shitty case where they don't overlap in any direction 
     { 
      //this is above r 
      if(upperLeftCorner.y > r.upperLeftCorner.y) 
      { 
       //this is above and to the left of r 
       if(upperLeftCorner.x < r.upperLeftCorner.x) 
       { 
        return lowerRightCorner.getDistanceFrom(r.upperLeftCorner); 
       } 
       else //this is above and to the right of r 
       { 
        return lowerLeftCorner.getDistanceFrom(r.upperRightCorner); 
       } 
      } 
      else //this is below r 
      { 
       //this is below and to the left of r 
       if(upperLeftCorner.x < r.upperLeftCorner.x) 
       { 
        return upperRightCorner.getDistanceFrom(r.lowerLeftCorner); 
       } 
       else //this is below and to the right of r 
       { 
        return upperLeftCorner.getDistanceFrom(r.lowerRightCorner); 
       } 
      } 
     } 
    } 
} 

和Point类

public class Point 
{ 
    final public double x; 
    final public double y; 

    public Point(double _x, double _y) 
    { 
     x = _x; 
     y = _y; 
    } 

    public double getDistanceFrom(Point p) 
    { 
     double distance = Math.sqrt(Math.pow(x - p.x, 2) + Math.pow(y - p.y, 2)); 
     return distance; 
    } 
} 

祝你好运与您的项目。