# Python numpy.hypot() 使用实例

The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.

Example 1

def _vlines(lines, ctrs=None, lengths=None, vecs=None, angle_lo=20, angle_hi=160, ransac_options=RANSAC_OPTIONS):
ctrs = ctrs if ctrs is not None else lines.mean(1)
vecs = vecs if vecs is not None else lines[:, 1, :] - lines[:, 0, :]
lengths = lengths if lengths is not None else np.hypot(vecs[:, 0], vecs[:, 1])

angles = np.degrees(np.arccos(vecs[:, 0] / lengths))
points = np.column_stack([ctrs[:, 0], angles])
point_indices, = np.nonzero((angles > angle_lo) & (angles < angle_hi))
points = points[point_indices]
if len(points) > 2:
model_ransac = linear_model.RANSACRegressor(**ransac_options)
model_ransac.fit(points[:, 0].reshape(-1, 1), points[:, 1].reshape(-1, 1))
else:
valid_lines = []
return valid_lines

Example 2

def _hlines(lines, ctrs=None, lengths=None, vecs=None, angle_lo=20, angle_hi=160, ransac_options=RANSAC_OPTIONS):
ctrs = ctrs if ctrs is not None else lines.mean(1)
vecs = vecs if vecs is not None else lines[:, 1, :] - lines[:, 0, :]
lengths = lengths if lengths is not None else np.hypot(vecs[:, 0], vecs[:, 1])

angles = np.degrees(np.arccos(vecs[:, 1] / lengths))
points = np.column_stack([ctrs[:, 1], angles])
point_indices, = np.nonzero((angles > angle_lo) & (angles < angle_hi))
points = points[point_indices]
if len(points) > 2:
model_ransac = linear_model.RANSACRegressor(**ransac_options)
model_ransac.fit(points[:, 0].reshape(-1, 1), points[:, 1].reshape(-1, 1))
else:
valid_lines = []
return valid_lines

Example 3

def get_ind_under_point(self, event):
"""
get the index of the vertex under point if within epsilon tolerance
:param event: qt event
:return: index of selected point
"""

# display coords
distances = numpy.hypot(event.xdata - self.curData[:, 0],
event.ydata - self.curData[:, 1])
indmin = distances.argmin()

if distances[indmin] >= self.epsilon:
ind = None
else:
ind = indmin
self.lastind = ind
return ind

Example 4

def get_ind_under_point(self, event):
"""
get the index of the vertex under point if within epsilon tolerance
:param event: qt event
:return: index of selected point
"""

# display coords
distances = numpy.hypot(event.xdata - self.curData[:, 0],
event.ydata - self.curData[:, 1])
indmin = distances.argmin()

if distances[indmin] >= self.epsilon:
ind = None
else:
ind = indmin
self.lastind = ind
return ind

Example 5

def calcPi(n):
""" Calculating Pi using Monte Carlo Integration.

Quickly estimates the first 2 decimals, but it is terribly inefficient for estimating other decimals.

Source: http://www.stealthcopter.com/blog/2009/09/python-calculating-pi-using-random-numbers/
"""

inside = 0.0

for i in range(n):
x = np.random.random()
y = np.random.random()

# Calculate the length of hypotenuse given the sides x and y
if np.hypot(x, y) <= 1:
inside += 1

return 4.0*inside/n

# Run the calcPi function without timing

Example 6

def _filter(img, method, k):
sy = cv2.Sobel(img, ddepth=cv2.CV_64F, dx=0, dy=1, ksize=k)
sx = cv2.Sobel(img, ddepth=cv2.CV_64F,dx=1, dy=0, ksize=k)
#             sx = sobel(img, axis=0, mode='constant')
#             sy = sobel(img, axis=1, mode='constant')
return np.hypot(sx, sy)
if method == 'Sobel-H':
return cv2.Sobel(img, ddepth=cv2.CV_64F,dx=0, dy=1, ksize=k)
#sobel(img, axis=0, mode='constant')
if method == 'Sobel-V':
return cv2.Sobel(img, ddepth=cv2.CV_64F,dx=1, dy=0, ksize=k)
#sobel(img, axis=1, mode='constant')
if method == 'Laplace':
return cv2.Laplacian(img, ddepth=cv2.CV_64F,ksize=5)
#laplace(img)

Example 7

def _pixel_select(self, event):

x, y = event.xdata, event.ydata
# get index by assuming even spacing
# TODO use kdtree?
diff = np.hypot((self.x_pos - x), (self.y_pos - y))
y_ind, x_ind = np.unravel_index(np.argmin(diff), diff.shape)

# get the spectrum for this point
new_y_data = self.counts[y_ind, x_ind, :]
self._pixel_txt.set_text(
'pixel: [{:d}, {:d}] ({:.3g}, {:.3g})'.format(
y_ind, x_ind,
self.x_pos[y_ind, x_ind],
self.y_pos[y_ind, x_ind]))

self.spec.set_ydata(new_y_data)
self.ax_spec.relim()
self.ax_spec.autoscale(True, axis='y')
self.fig.canvas.draw_idle()

Example 8

def line_ball_collision_check(line, ball):
# checks if the ball is half the line length from the line middle
if distance_less_equal(line.middle, ball.pos, line.length / 2 + config.ball_radius):
# displacement vector from the first point to the ball
displacement_to_ball = ball.pos - line.line[0]
# displacement vector from the first point to the second point on the
# line
displacement_to_second_point = line.line[1] - line.line[0]
normalised_point_diff_vector = displacement_to_second_point / \
np.hypot(*(displacement_to_second_point))
# distance from the first point on the line to the perpendicular
# projection point from the ball
projected_distance = np.dot(normalised_point_diff_vector, displacement_to_ball)
# closest point on the line to the ball
closest_line_point = projected_distance * normalised_point_diff_vector
perpendicular_vector = np.array(
[-normalised_point_diff_vector[1], normalised_point_diff_vector[0]])
# checking if closest point on the line is actually on the line (which is not always the case when projecting)
# then checking if the distance from that point to the ball is less than the balls radius and finally
# checking if the ball is moving towards the line with the dot product
return -config.ball_radius / 3 <= projected_distance <= \
np.hypot(*(displacement_to_second_point)) + config.ball_radius / 3 and \
np.hypot(*(closest_line_point - ball.pos + line.line[0])) <= \
perpendicular_vector, ball.velocity) <= 0

Example 9

def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]

# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]

a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b)

Example 10

def go_to_with_planner(self, x, y, t):
start = self.position()[:-1]
end = np.array([x, y])
points = self.planner.get_points(start=start, end=end, robot=self)

points = np.array(points)
lens = np.hypot(points[:, 0], points[:, 1])
npoints = np.zeros(shape=(points.shape[0], 3))
npoints[:, :-1] = points
npoints[:, -1] = tpm * lens
return npoints

if not points:
logging.warning("no available path. start=%r, end=%r", start, end)
else:
self.follow(points, t)

Example 11

def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]

# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]

a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b)

Example 12

def dist(apos, bpos):
"""
Angular separation between two points on a sphere.
http://en.wikipedia.org/wiki/Great-circle_distance
"""
(a_ra, a_dec), (b_ra, b_dec) = apos, bpos
lon1 = a_ra / 180 * pi
lat1 = a_dec / 180 * pi
lon2 = b_ra / 180 * pi
lat2 = b_dec / 180 * pi
sdlon = sin(lon2 - lon1)
cdlon = cos(lon2 - lon1)
slat1 = sin(lat1)
slat2 = sin(lat2)
clat1 = cos(lat1)
clat2 = cos(lat2)

num1 = clat2 * sdlon
num2 = clat1 * slat2 - slat1 * clat2 * cdlon
denominator = slat1 * slat2 + clat1 * clat2 * cdlon

return arctan2(hypot(num1, num2), denominator) * 180 / pi

Example 13

def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]

# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]

a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b)

Example 14

def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]

# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]

a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b)

Example 15

def direction_map(dmap: DistanceMap):
r"""Computes normalized gradient of distance map. Not defined when length of

.. math::
\hat{\mathbf{e}}_{S} = -\frac{\nabla S(\mathbf{x})}{\| \nabla S(\mathbf{x}) \|}

Args:
dmap (numpy.ndarray):
Distance map.

Returns:
DirectionMap: Direction map.
"""
l = np.hypot(u, v)
# Avoids zero division
l[l == 0] = np.nan
# Flip order from (row, col) to (x, y)
return v / l, u / l

# Potentials

Example 16

def collide(self, p1, p2):
np = self.np
dx = p1.x - p2.x
dy = p1.y - p2.y
elasticity = 1
dist = np.hypot(dx, dy)
if dist < p1.size + p2.size:
tangent = np.arctan2(dy, dx)
angle = 0.5 * np.pi + tangent

angle1 = 2*tangent - p1.angle
angle2 = 2*tangent - p2.angle
speed1 = p2.speed*elasticity
speed2 = p1.speed*elasticity

(p1.angle, p1.speed) = (angle1, speed1)
(p2.angle, p2.speed) = (angle2, speed2)

p1.x += np.sin(angle)
p1.y -= np.cos(angle)
p2.x -= np.sin(angle)
p2.y += np.cos(angle)

Example 17

def angles_from_sphere(pts):
"""equirectangular projection, ie. map from sphere in R^3 to (0, 2*pi) x (-pi/2, pi/2)
Parameters
----------
pts : array_like (3,...)
pts[0,...], pts[1,...], and pts[2,...] are x,y, and z coordinates
Returns
-------
out : ndarray (2,...)
pts transformed from x,y,z to longitude,latitude
"""
pts = np.asarray(pts) #turn into an ndarray if necessary
x,y,z = pts[0], pts[1], pts[2]
out = np.empty((2,) + pts.shape[1:])
#longitude:
out[0] = np.arctan2(y,x)
out[0] %= 2*pi #wrap negative values around the circle to positive
#latitude:
r = np.hypot(x,y)
out[1] = np.arctan2(z,r)
return out

Example 18

def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]

# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]

a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b)

Example 19

def get_dH2(lab1, lab2):
"""squared hue difference term occurring in deltaE_cmc and deltaE_ciede94

Despite its name, "dH" is not a simple difference of hue values.  We avoid
working directly with the hue value, since differencing angles is
troublesome.  The hue term is usually written as:
c1 = sqrt(a1**2 + b1**2)
c2 = sqrt(a2**2 + b2**2)
term = (a1-a2)**2 + (b1-b2)**2 - (c1-c2)**2
dH = sqrt(term)

However, this has poor roundoff properties when a or b is dominant.
Instead, ab is a vector with elements a and b.  The same dH term can be
re-written as:
|ab1-ab2|**2 - (|ab1| - |ab2|)**2
and then simplified to:
2*|ab1|*|ab2| - 2*dot(ab1, ab2)
"""
lab1 = np.asarray(lab1)
lab2 = np.asarray(lab2)
a1, b1 = np.rollaxis(lab1, -1)[1:3]
a2, b2 = np.rollaxis(lab2, -1)[1:3]

# magnitude of (a, b) is the chroma
C1 = np.hypot(a1, b1)
C2 = np.hypot(a2, b2)

term = (C1 * C2) - (a1 * a2 + b1 * b2)
return 2 * term

Example 20

def _cart2polar_2pi(x, y):
"""convert cartesian coordinates to polar (uses non-standard theta range!)

NON-STANDARD RANGE! Maps to (0, 2*pi) rather than usual (-pi, +pi)
"""
r, t = np.hypot(x, y), np.arctan2(y, x)
t += np.where(t < 0., 2 * np.pi, 0)
return r, t

Example 21

def xy2angles(x,y):
elout = 90-np.hypot(x,y)
azout = np.degrees(np.arctan2(x,y))
return (azout,elout)

Example 22

def parse(fname):
"""
Parse FGM format data *fname*. Return :class:DataFrame
containing all information found in the file.

The FGM file format is used by CARISMA to store data and is
described here:
http://www.carisma.ca/carisma-data/fgm-data-format.
"""
with open(fname) as fid:
siteid, lat, lon, date, pos_format, units, sample_rate = fid.next().split()
dt = []
x = []
y = []
z = []
flag = []
for line in fid:
cols = line.split()
dt.append(datetime.strptime(cols[0], '%Y%m%d%H%M%S'))
x.append(float(cols[1]))
y.append(float(cols[2]))
z.append(float(cols[3]))
if cols[4] == '.':
flag.append(False)
elif cols[4] == 'x':
flag.append(True)
else:
raise ValueError('unknown flag value {} encountered in {}'.format(cols[4], fname))
f = NP.hypot(x, NP.hypot(y, z))
df = PD.DataFrame(data={'x': x, 'y': y, 'z': z, 'f': f, 'flag': flag},
index=dt)
df.siteid = siteid
df.lat = float(lat)
df.lon = float(lon)
df.date = datetime.strptime(date, '%Y%m%d')
df.pos_format = pos_format
df.units = units
df.sample_rate = sample_rate
return df

Example 23

def cart2sph(x, y, z):
'''Converts cartesian coordinates x, y, z to spherical coordinates az, el, r.'''
hxy = _np.hypot(x, y)
r = _np.hypot(hxy, z)
el = _np.arctan2(z, hxy)
az = _np.arctan2(y, x)
return az, el, r

Example 24

def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]

# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]

a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b)

Example 25

def _vh_lines(lines, ctrs=None, lengths=None, vecs=None, angle_lo=20, angle_hi=160,
ransac_options=RANSAC_OPTIONS):
ctrs = ctrs if ctrs is not None else lines.mean(1)
vecs = vecs if vecs is not None else lines[:, 1, :] - lines[:, 0, :]
lengths = lengths if lengths is not None else np.hypot(vecs[:, 0], vecs[:, 1])

return (_vlines(lines, ctrs, lengths, vecs, angle_lo, angle_hi, ransac_options=RANSAC_OPTIONS),
_hlines(lines, ctrs, lengths, vecs, angle_lo, angle_hi, ransac_options=RANSAC_OPTIONS))

Example 26

def distance_between(x1, y1, x2, y2):
"""
Calculates the distance between 2 points.
"""
return np.hypot(x1 - x2, y1 - y2)

Example 27

def make_dist_mat(xy1, xy2, longlat=True):
"""
Return a distance matrix between two set of coordinates.
Use geometric distance (default) or haversine distance (if longlat=True).

Parameters
----------
xy1 : numpy.array
The first set of coordinates as [(x, y), (x, y), (x, y)].
xy2 : numpy.array
The second set of coordinates as [(x, y), (x, y), (x, y)].
longlat : boolean, optionnal
Whether the coordinates are in geographic (longitude/latitude) format
or not (default: False)

Returns
-------
mat_dist : numpy.array
The distance matrix between xy1 and xy2
"""
if longlat:
return hav_dist(xy1[:, None], xy2)
else:
d0 = np.subtract.outer(xy1[:, 0], xy2[:, 0])
d1 = np.subtract.outer(xy1[:, 1], xy2[:, 1])
return np.hypot(d0, d1)

Example 28

def edgedetect(channel):
sobelx = cv2.Sobel(channel, cv2.CV_16S, 1, 0, ksize=3)
sobely = cv2.Sobel(channel, cv2.CV_16S, 0, 1, ksize=3)
sobel = np.hypot(sobelx, sobely)
sobel[sobel > 255] = 255

return sobel

Example 29

def get_pixelist_interp_iq( qp, iq, ring_mask, center):

qind, pixelist = roi.extract_label_indices(  ring_mask  )
#pixely = pixelist%FD.md['nrows'] -center[1]
#pixelx = pixelist//FD.md['nrows'] - center[0]

r= np.hypot(pixelx, pixely)              #leave as float.
#r= np.int_( np.hypot(pixelx, pixely)  +0.5  ) + 0.5
return np.interp( r, qp, iq )

Example 30

def transform(cls, value):
value = np.asarray(value, dtype=np.float64)
assert value.shape[-1] == 2
result = np.empty_like(value)
result[...,0] = np.hypot(value[...,1], value[...,0])
result[...,1] = np.arctan2(value[...,1], value[...,0]) % (2 * np.pi)
return result

Example 31

def transform(cls, value):
value = np.asarray(value, dtype=np.float64)
result = np.empty_like(value)
x, y, z = value.T
xy = np.hypot(x, y)
result[..., 0] = np.hypot(xy, z)
result[..., 1] = np.arctan2(xy, z) % (2 * np.pi)
result[..., 2] = np.arctan2(y, x) % (2 * np.pi)
return result

Example 32

def transform(cls, value):
value = np.asarray(value, dtype=np.float64)
result = np.empty_like(value)
x, y, z = value.T
result[..., 0] = np.hypot(x, y)                     # tho
result[..., 1] = np.arctan2(y, x) % (2 * np.pi)     # phi
result[..., 2] = z
return result

Example 33

def ecef2geodetic(x, y, z):
"""http://www.astro.uni.torun.pl/~kb/Papers/geod/Geod-BG.htm

This algorithm provides a converging solution to the latitude equation in
terms of the parametric or reduced latitude form (v).
This algorithm provides a uniform solution over all latitudes as it does
not involve division by cos(phi) or sin(phi).
"""
ell = {}
ell['a'] = 6378137.
ell['f'] = 1. / 298.2572235630
ell['b'] = ell['a'] * (1 - ell['f'])

ea = ell['a']
eb = ell['b']
# Constant required for Latitude equation
rho = np.arctan2(eb * z, ea * rad)
#Constant required for latitude equation
c = (ea**2 - eb**2) / np.hypot(ea * rad, eb * z)
# Starter for the Newtons Iteration Method
vnew = np.arctan2(ea * z, eb * rad)
# Initializing the parametric latitude
v = 0
count = 0
while (v != vnew).any() and count < 5:
v = vnew.copy()
# Newtons Method for computing iterations
vnew = v - ((2 * np.sin(v - rho) - c * np.sin(2 * v)) /
(2 * (np.cos(v - rho) - c * np.cos(2 * v))))
count += 1

# Computing latitude from the root of the latitude equation
lat = np.arctan2(ea * np.tan(vnew), eb)
lon = np.arctan2(y, x)
alt = ((rad - ea * np.cos(vnew)) * np.cos(lat) +
(z - eb * np.sin(vnew)) * np.sin(lat))

return lat, lon, alt

Example 34

def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]

# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]

a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b)

Example 35

def _cart2polar(x, y, center):
xx = x - center[0]
yy = y - center[1]
phi = np.arctan2(yy, xx)
r = np.hypot(xx, yy)
return r, phi

Example 36

def _grid(self):
tsne_norm = self.tsne_vectors[:, ] / float(self.ratio)
used_imgs = np.equal(self.tsne_vectors[:, 0], None)
image = np.ones((self.output_img_size, self.output_img_size, 3)) * self.background_color
for x in tqdm(range(self.ratio)):
x0 = x * self.each_img_size
x05 = (x + 0.5) * self.each_img_size
for y in range(self.ratio):
y0 = y * self.each_img_size
y05 = (y + 0.5) * self.each_img_size
tmp_tsne = tsne_norm - [x05, y05]
tmp_tsne[used_imgs] = 99999  # don't use the same img twice
tsne_dist = np.hypot(tmp_tsne[:, 0], tmp_tsne[:, 1])
min_index = np.argmin(tsne_dist)
used_imgs[min_index] = True
img_path = self.image_list[min_index]
small_img, x1, y1, dx, dy = get_image(img_path, self.each_img_size)
if small_img is None:
y -= 1
continue
if x < 1 and all(side < self.each_img_size for side in [x1, y1]):
self.each_img_size = min(x1, y1)
dx = int(ceil(x1 / 2))
dy = int(ceil(y1 / 2))
image[x0 + dx:x0 + dx + x1, y0 + dy:y0 + dy + y1] = small_img

return image

Example 37

def on_button(self, event):
# only consider events from the lines Axes
if event.inaxes is not self.ln.axes:
return

# if not the left mouse button or a modifier key
# is held down, bail
if event.button != 1 or event.key not in (None, 'shift'):
print('key+button: {!r}+{!r}'.format(event.key, event.button))
return

if event.key == 'shift':
# compute the distance to each point *in data space*
d = np.hypot(np.asarray(self.xdata) - event.xdata,
np.asarray(self.ydata) - event.ydata)
# find the closest point
ix = np.argmin(d)
# remove that data point
del self.xdata[ix]
del self.ydata[ix]
else:
# get the event location in data-space
# and add to internal data list
self.xdata.append(event.xdata)
self.ydata.append(event.ydata)
# update the line
self._update_line()

Example 38

def point_distance(p1, p2):
dist_diff = p1 - p2
return np.hypot(*dist_diff)

Example 39

def collide_line_ball(line, ball):
displacement_to_second_point = line.line[1] - line.line[0]
normalised_point_diff_vector = displacement_to_second_point / \
np.hypot(*(displacement_to_second_point))
perpendicular_vector = np.array(
[-normalised_point_diff_vector[1], normalised_point_diff_vector[0]])
ball.velocity -= 2 * np.dot(perpendicular_vector,
ball.velocity) * perpendicular_vector

Example 40

def __init__(self, line):
self.line = np.array(line)
self.middle = (self.line[0] + self.line[1]) / 2
self.size = np.round(np.abs(self.line[0] - self.line[1]))
self.length = np.hypot(*self.size)
if np.count_nonzero(self.size) != 2:
# line is perpendicular to y or x axis
if self.size[0] == 0:
self.size[0] += 1
else:
self.size[1] += 1

# draws the yellow part of the table

Example 41

def ball_hit(self):
new_velocity = -(self.displacement - config.ball_radius - config.cue_safe_displacement) * \
config.cue_hit_power * np.array([math.sin(self.angle), math.cos(self.angle)])
change_in_disp = np.hypot(*new_velocity) * 0.1
while self.displacement - change_in_disp > config.ball_radius:
self.displacement -= change_in_disp
self.update()
pygame.display.flip()
self.target_ball.ball.apply_force(new_velocity)
self.visible = False

Example 42

def update(self, *args):
if np.hypot(*self.ball.velocity) != 0:
# updates label circle and number offset
perpendicular_velocity = -np.cross(self.ball.velocity, [0, 0, 1])
# angle formula is angle=((ballspeed*2)/(pi*r*2))*2
rotation_angle = -np.hypot(
*(self.ball.velocity)) * 2 / (config.ball_radius * np.pi)
transformation_matrix = physics.rotation_matrix(
perpendicular_velocity, rotation_angle)
self.label_offset = np.matmul(
self.label_offset, transformation_matrix)
if self.ball_type == BallType.Striped:
self.ball_stripe.update_stripe(transformation_matrix)
self.update_sprite()
self.ball.update()

Example 43

def check_reg(fixed_img, moved_img, scale=15, norm=True, sigma=0.8, **kwargs):
dim = list(moved_img.shape)
# Convert 4D image to 3D or raise error
data = convert_to_3d(moved_img)
# Check normalization
if norm:
data = apply_p2_98(data)
# Set slice axis for mosaic grid
slice_axis, cmap = check_sliceaxis_cmap(data, kwargs)
cmap = 'YlOrRd'
# Set grid shape
data, slice_grid, size = set_mosaic_fig(data, dim, resol, slice_axis, scale)
fig, axes = BrainPlot.mosaic(fixed_img, scale=scale, norm=norm, cmap='bone', **kwargs)
# Applying inversion
invert = check_invert(kwargs)
data = apply_invert(data, *invert)
# Plot image
for i in range(slice_grid[1] * slice_grid[2]):
ax = axes.flat[i]
edge = data[:, :, i]
edge = feature.canny(edge, sigma=sigma)  # edge detection for second image
# edge = ndimage.gaussian_filter(edge, 3)
sx = ndimage.sobel(edge, axis=0, mode='constant')
sy = ndimage.sobel(edge, axis=1, mode='constant')
sob = np.hypot(sx, sy)
m_norm = colors.Normalize(vmin=0, vmax=1.5)
if i < slice_grid[0] and False in np.isnan(mask.flatten()):
ax.imshow(mask.T, origin='lower', interpolation='nearest', cmap=cmap, norm=m_norm, alpha=0.8)
else:
ax.imshow(np.zeros((dim[0], dim[1])).T, origin='lower', interpolation='nearest', cmap='bone')
ax.set_axis_off()
fig.set_facecolor('black')
if notebook_env:
display(fig)
return fig, axes

Example 44

def distance(vertex1, vertex2):
x, y = vertex1 - vertex2
return np.hypot(x, y)

Example 45

def angsep(lon1,lat1,lon2,lat2):
"""
Angular separation (deg) between two sky coordinates.
Borrowed from astropy (www.astropy.org)

Notes
-----
The angular separation is calculated using the Vincenty formula [1],
which is slighly more complex and computationally expensive than
some alternatives, but is stable at at all distances, including the
poles and antipodes.

[1] http://en.wikipedia.org/wiki/Great-circle_distance
"""

sdlon = numpy.sin(lon2 - lon1)
cdlon = numpy.cos(lon2 - lon1)
slat1 = numpy.sin(lat1)
slat2 = numpy.sin(lat2)
clat1 = numpy.cos(lat1)
clat2 = numpy.cos(lat2)

num1 = clat2 * sdlon
num2 = clat1 * slat2 - slat1 * clat2 * cdlon
denominator = slat1 * slat2 + clat1 * clat2 * cdlon

return numpy.degrees(numpy.arctan2(numpy.hypot(num1,num2), denominator))

############################################################

# ADW: Reduce numpy array operations for speed

Example 46

def generate_pattern(self, reference, size):
"""Extracts a pattern from the reference image.

Firstly, the image is transformed to grayscale. A random square from image
is picked. A pattern is extracted using the edge detection (Sobel's filter).

:param reference: Reference image.
:param int size: Size of a pattern (length of its edge).
:returns:
A pattern extracted from the image.
"""
# Import image from reference and convert it to grayscale.
gray = np.mean(img, -1)

# Normalization of data to decimal (0.0 - 1.0) representation
if gray.max() > 1.0:
gray /= 255.0

# Extract a random slice with the pixel size given as parameter
slice_center_x = random.randint(0, len(img[0]) - size - 1)
slice_center_y = random.randint(0, len(img) - size - 1)

slice = gray[slice_center_y: slice_center_y + size, slice_center_x: slice_center_x + size]

# # Detects border to generate the pattern of the brush
dx = ndimage.sobel(slice, 0)  # horizontal derivative
dy = ndimage.sobel(slice, 1)  # vertical derivative
pattern = np.hypot(dx, dy)    # grayscale slice with border detection

# Normalize pattern
if pattern.max() > 1.0:
return pattern / pattern.max()

return pattern

# Test

Example 47

def _deproj(x, y, inc, pa, polar_out=True, polar_in=True, fourier_plan=False):
if polar_in:
y, x = x*np.cos(y), x*np.sin(y)
else:
y, x = x, y
if fourier_plan:
X = (x*np.cos(pa) + y*np.sin(pa))*np.cos(inc)
Y = y*np.cos(pa) - x*np.sin(pa)
else:
X = x*np.cos(pa) + y*np.sin(pa)
Y = (y*np.cos(pa) - x*np.sin(pa))/np.cos(inc)
x, y = np.hypot(Y, X), (np.arctan2(X, Y)-pa) % (2*np.pi)
if not polar_out:
return x*np.cos(y), x*np.sin(y)
return x, y

Example 48

def psf(lOverd, masperpx):
"""
masperpx in mas per px
"""
y, x = np.meshgrid(np.linspace(-1, 1, nbpts), np.linspace(-1, 1, nbpts))
psf = airy(np.hypot(y, x)*2*lOverd+1e-10, 1/lOverd)**2
psf /= psf.sum()
return psf

Example 49

def distance_matrix(x0, y0, x1, y1):
'''Distance matrix for IDW calculation'''
obs = np.vstack((x0, y0)).T
interp = np.vstack((x1, y1)).T

# Make a distance matrix between pairwise observations
# Note: from <http://stackoverflow.com/questions/1871536>
d0 = np.subtract.outer(obs[:,0], interp[:,0])
d1 = np.subtract.outer(obs[:,1], interp[:,1])
return np.hypot(d0, d1)

Example 50

def length(v):
r"""Length of an vector

.. math::
\|\mathbf{v}\|

Args:
v (numpy.ndarray): 2D vector

Returns:
float|numpy.ndarray: Length of the vector in [0, infty)
"""
return np.hypot(v[..., 0], v[..., 1])