Iterate over spots that collide the given point.
978077
def spots_at(self, x, y):
        """"""
        for spot in self.spot.values():
            if spot.collide_point(x, y):
                yield spot
614828
private void removePoints(double x, double y, Collidable collidable)
    {
        final int minX = (int) Math.floor(x / REDUCE_FACTOR);
        final int minY = (int) Math.floor(y / REDUCE_FACTOR);
        final int maxX = (int) Math.floor((x + collidable.getMaxWidth()) / REDUCE_FACTOR);
        final int maxY = (int) Math.floor((y + collidable.getMaxHeight()) / REDUCE_FACTOR);

        removePoints(minX, minY, maxX, maxY, collidable);
    }
126191
function(points, bbox) {
        var result = [];
        for (var i = 0; i < points.length; i++) {
            var point = points[i];
            if (this.bboxContainsPoint(point, bbox)) {
                result.push(point);
            }
        }
        return result;
    }
920230
private static <T> List<T> intersect(T[] first, T[] second) {
    List<T> result = new ArrayList<>();
    for (T a : first) {
      for (T b : second) {
        if (a.equals(b)) {
          result.add(b);
          break;
        }
      }
    }
    return result;
  }
380669
def intersects_all(self, other):
		
		return all(key in self and self[key].intersects(value) for key, value in other.iteritems()) and bool(other)
160457
def coords_intersect(self):
        
        return set.intersection(*map(
            set, (getattr(arr, 'coords_intersect', arr.coords) for arr in self)
            ))
1241974
def intersect(d1, d2):
    """"""
    return dict((k, d1[k]) for k in d1 if k in d2 and d1[k] == d2[k])
465143
function pointRectangleSimple(p, a1, a2) {
    if (!(a1.x > p.x ||
        a2.x < p.x ||
        a1.y > p.y ||
        a2.y < p.y))
        return {result: collision.INSIDE};
    return {result: collision.OUTSIDE};
}
622440
function (event, point, win) {
		var el = elementFromPoint(point, win);
		syn.trigger(el || win, event, point);
		return el;
	}
217432
def multipoint(self, points):
        """"""
        shapeType = MULTIPOINT
        points = [points] # nest the points inside a list to be compatible with the generic shapeparts method
        self._shapeparts(parts=points, shapeType=shapeType)
1013279
private void removePoint(Point point, Collidable collidable)
    {
        final Integer group = collidable.getGroup();
        if (collidables.containsKey(group))
        {
            final Map<Point, Set<Collidable>> elements = collidables.get(group);
            if (elements.containsKey(point))
            {
                removePoint(point, collidable, elements, group);
            }
        }
    }
167466
def collide_point(self, x, y):
        
        if not self.collider:
            return False
        return (x, y) in self.collider
38099
function splatPoints(out, points, weights, radius) {
  doSplat(
    points.hi(points.shape[0], 1),
    ndarray(weights.data,
      [weights.shape[0], 1],
      [weights.stride[0], 0],
      weights.offset),
    out,
    radius,
    dirichlet)
}
1222156
def overlaps_point(self, p):
        
        if self.is_empty():
            return False
        return bool(self.top_node.contains_point(p))
144067
def _points_within_distance(self, pnt1, pnt2):
        """"""
        if self._get_distance(pnt1, pnt2) <= self.distance:
            return True
        return False
143300
def iter_points(self):
        ""
        if not self.is_discrete():
            raise ValueError("Patch is not discrete")
        names = sorted(self.sets.keys())
        icoords = [self.sets[name].iter_members() for name in names]
        for coordinates in product(*icoords):
            yield tuple(zip(names,coordinates))
1368615
def pointlist(points, sr):
    """"""
    assert all(isinstance(pt, Point) or len(pt) == 2 
               for pt in points), "Point(s) not in [x, y] form"
    return [coord if isinstance(coord, Point) 
                  else Point(coord[0], coord[1], sr)
            for coord in points]