'Find all points within distance r of point(s) x.
Parameters
x : array_like, shape tuple + (self.m,)
The point or points to search for neighbors of.
r : positive float
The radius of points to return.
p : float, optional
Which Minkowski p-norm to use.  Should be in the range [1, inf].
eps : nonnegative float, optional
Approximate search. Branches of the tree are not explored if their
nearest points are further than ``r / (1 + eps)``, and branches are
added in bulk if their furthest points are nearer than
``r * (1 + eps)``.
Returns
results : list or array of lists
If `x` is a single point, returns a list of the indices of the
neighbors of `x`. If `x` is an array of points, returns an object
array of shape tuple containing lists of neighbors.
Notes
If you have many points whose neighbors you want to find, you may save
substantial amounts of time by putting them in a KDTree and using
query_ball_tree.
Examples
>>> from scipy import spatial
>>> x, y = np.mgrid[0:5, 0:5]
>>> points = np.c_[x.ravel(), y.ravel()]
>>> tree = spatial.KDTree(points)
>>> tree.query_ball_point([2, 0], 1)
[5, 10, 11, 15]
Query multiple points and plot the results:
>>> import matplotlib.pyplot as plt
>>> points = np.asarray(points)
>>> plt.plot(points[:,0], points[:,1], \'.\')
>>> for results in tree.query_ball_point(([2, 0], [3, 3]), 1):
...     nearby_points = points[results]
...     plt.plot(nearby_points[:,0], nearby_points[:,1], \'o\')
>>> plt.margins(0.1, 0.1)
>>> plt.show()'

def query_ball_point(self, x, r, p=2.0, eps=0):

    x = np.asarray(x)
    if (x.shape[(-1)] != self.m):
        raise ValueError(('Searching    for    a    %d-dimensional    point    in    a    %d-dimensional    KDTree' % (x.shape[(-1)], self.m)))
    if (len(x.shape) == 1):
        return self.__query_ball_point(x, r, p, eps)
    else:
        retshape = x.shape[:(-1)]
        result = np.empty(retshape, dtype=object)
        for c in np.ndindex(retshape):
            result[c] = self.__query_ball_point(x[c], r, p=p, eps=eps)
        return result
