在XY平面上找到附近的矩形

Question

I have few rectangles on an xy plane.There is a reference rectangle . The reference rectangle's position is changeable. I need efficient way to find the

• first rectangle that is found on the LEFT side of the reference rectangle.
• first rectangle that is found on the RIGHT side of the reference rectangle.
• first rectangle that is found on the TOP side of the reference rectangle.
• first rectangle that is found on the BOTTOM side of the reference rectangle.

Pseudo-code or Java code is fine. Emphasis is given on the faster code than space consumed .
Solving one side will solve the other 3 sides. Let's say, we need to find the list of nearest rectangles that fall on the left side of the "REFERENCE RECT" . The "REFERENCE RECT" is movable. All other rectangles are stationary at the time of calculating.

PS. Each box can be the "REFERENCE RECT". Boxes are added to the XY plane one at a time.

Answer 1

This pseudo-code may not be fast during setup (O(N^2)), but once NearestBoxes has been built, it will beat anything else (since it won't have to recalculate anything). Beware of typos - I haven't tested this.

public enum RPos { Up, Down, Left, Right };

public class Box {
    int x1, x2, y1, y2;        
    boolean isRelative(b, RPos rp) {
       // returns true if b can be said to be "rp" 
       // (say, left) of this box
    }
    double dist(Box b, RPos rp) {
       // assumes non-overlapping
       // add some simple trig here:
       //   if boxes adjacent in chosen direction, distance 
       //      (if Right, then x2-p.x1, ...)
       //   if boxes not adjacent, then euclidean distance between 
       //   nearest corners.
    }
}

class NearestBoxes {    

    HashMap<RPos, HashMap<Box, TreeMap<Double, ArrayList<Box>>>> 
        = new HashMap<>();

    public NearestBoxes(List<Box> boxes) {
       for (RPos rp : RPos.values) {
          nearest.put(rp, 
             new HashMap<Box, TreeMap<Double, ArrayList<Box>>>();
          for (Box a : boxes) {
             TreeMap<Double, ArrayList<Box>> n = 
                new TreeMap<Double, ArrayList<Box>>());
             nearest.get(rp).put(a, n);                    
             for (Box b : boxes) {
                 if (a.isRelative(b, rp)) {
                    double d = a.dist(b, rp);                        
                    if (d == n.firstKey()) {
                       n.get(d).add(b);
                    } else if (d < n.firstKey()) {
                       n.put(d, new ArrayList());
                       n.get(d).add(b);
                    }
                 }
             }
          }
       }
    }

    public List<Box> getNearest(Box b, RPos rp) {
       TreeMap<Double, ArrayList<Box>> n = nearest.get(rp).get(b);
       return (n.isEmpty()) ? new ArrayList<Box>() 
                            : n.get(n.firstKey());           
    }
}

Answer 2

Feel free to comment and show logic depicting that it can produce false positive.

The key concept of searching in Nearest Neighbour Search is to split the domain to minimize searching and quit the search as early as the nearest neighbour is found.

Assuming that the boxes have an id and they have x,y coordinates. I want to utilize the xy coordinate information to find the nearest rect. This solution initially splits the whole xy plane into considerably smaller domain to search in .

Solve LEFT:

The equation of vertical lines are x=b.Save the right edge of each rectangle as they are added to the xy plane. TreeMap<Integer x,ArrayList<Integer>> rightEdgeMap; The value ArrayList<Integer> holds ids of boxes, So the search domain is dramatically decreased. Now split and search in the decreased XY plane marked with blue color, untill the nearest rect is found.

How to search?

Make a searching bounding box and consider it to be grow-able on XY plane. Since any right edge falling within the height of the reference rect is the nearest possibility, start searching there.[ Look at the first searching box in the image ].

search only within the new growth of the searching box. If more than one rect found in searching box, measure distance:

• If the right edge falls within the height of the referenceRect, take horizontal distance from referenceRect or searchingBoxRightEdge.

  • Other wise take distance from the bottom of the edge to the nearest corner of the referenceRect.

  Alternatively, for simplicity you can accept the highest x valued edge within the the searching box. For fine grained solution, use above 2 methods.

Flatten the searching box by adding 1/5th of smallest box pixels on x axis and y axis until any axis or both of them are reached to the end. 1/5th is an assumption , it can be solid 20 or 30 pixels . The constraint is to add same amount of pixels on both x and y axis in searching box. Taking too many pixels will result in searching longer and wait longer to finish calculation. You don't need to flatten the searching box after the first match, since that's the END of searching.

When any box is resized or adding a new box, update rightEdgeMap appropriately. You will need another map<Integer,Integer> boxIdToRightEdgeMap; where key is id of box and value is the rightEdge x value. Whenever adding a new box/resize is done on any box, use boxIdToRightEdgeMap to locate the rightEdge value in the rightEdgeMap .

Use case box 4 is resized:

int xValOfRightEdge=boxIdToRightEdgeMap.get(4);

remove 4 from rightEdgeMap's value arrayList using xValOfRightEdge . And insert 4 in appropriate rightEdgeMap's value-arryList.

Query within searching box:

One way could be, to store the edges in a NavigableMap<Integer,List<Integer>> , where key= Y coordinate of rightEdge , value= list of rightEdges that fall in that Y coordinate. Now get subMap( minY ,MaxY) . minY and MaxY refers to searchingBox's min and max Y values. Sorting this submap decendingly you get the first entry as answer.

Use case box 4 is moved: No need to change in any map.

Observation: The time complexity is noticeably less.

Answer 3

Maybe you can store all rectangles in an array and match the nearest coordinates of other rectangles:

Suppose array of rectangles is: Rectangle[][4] rectangles = {{left, top, right, bottom}, {left, top, right, bottom}}

Now if you need to find the first rectangle on the left side, simple compare right of each rectangle in the array with the left of reference rectangle. Largest value of right of rectangle will give you the first rectangle on left side.

Rectangle referenceRectangle[4] = {rrl, rrt, rrr, rrb}
int max = 0;
for(i = 0 ; i < rectangles.length ; i++)
{
  if(rectangles[0][2] < referenceRectangle[0])
  {
    if(rectangles[0][2] > max)
    {
      max = rectangles[0][2];
      //Note the Index or maintain the list of rectangles.
    }   
  }
}

Similarly, other rectangles can be found out.