Python math 模块，hypot() 实例源码
我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用math.hypot()。
def warpImage(src, theta, phi, gamma, scale, fovy):
halfFovy = fovy * 0.5
d = math.hypot(src.shape[1], src.shape[0])
sideLength = scale * d / math.cos(deg2Rad(halfFovy))
sideLength = np.int32(sideLength)
M = warpMatrix(src.shape[1], src.shape[0], theta, phi, gamma, scale, fovy)
dst = cv2.warpPerspective(src, M, (sideLength, sideLength))
mid_x = mid_y = dst.shape[0] // 2
target_x = target_y = src.shape[0] // 2
offset = (target_x % 2)
if len(dst.shape) == 3:
dst = dst[mid_y - target_y:mid_y + target_y + offset,
mid_x - target_x:mid_x + target_x + offset,
:]
else:
dst = dst[mid_y - target_y:mid_y + target_y + offset,
mid_x - target_x:mid_x + target_x + offset]
return dst
def gen_adj_mat(longs, lats, prob_edge=.2,
additional_length=lambda: np.random.exponential(20,1)):
'''Get an adjacency matrix for the cities whose longitudes and latitudes
are passed. Each entry will either be a number somewhat greater than the
crow-flies distance between the two cities (with probability prob_edge),
or math.inf. The matrix will consist of floats, and be symmetric. The
diagonal will be all zeroes. The "somewhat greater" is controlled by the
additional_length parameter, a function returning a random amount.'''
# Generate full nxn Bernoulli's, even though we'll only use the upper
# triangle.
edges = np.random.binomial(1, prob_edge, size=(len(longs),len(longs)))
am = np.zeros((len(longs),len(longs)))
for i in range(len(longs)):
for j in range(len(longs)):
if i==j:
am[i,i] = 0
elif i < j:
if edges[i,j] == 1:
am[i,j] = (math.hypot(longs[i]-longs[j],lats[i]-lats[j])
+ additional_length())
am[j,i] = am[i,j]
else:
am[i,j] = am[j,i] = math.inf
return np.around(am,1)
def get_camera_params(box, size, view_angle):
box_size = box.size()
size_diagonal = math.hypot(*size)
if view_angle is None:
focal_length = size_diagonal # Normal lens by default
else:
focal_length = size_diagonal / (2 * math.tan(math.radians(view_angle) / 2))
distance = focal_length * max(_zero_if_inf(box_size.x) / size[0],
_zero_if_inf(box_size.z) / size[1])
if distance == 0:
distance = 1
distance *= 1.2 # 20% margin around the object
origin = box.midpoint() - util.Vector(0, distance + _zero_if_inf(box_size.y) / 2, 0)
direction = util.Vector(0, 1, 0)
up = util.Vector(0, 0, 1)
return (origin, direction, up, focal_length)
def get_camera_params(box, size, view_angle):
box_size = box.size()
size_diagonal = math.hypot(*size)
if view_angle is None:
focal_length = size_diagonal # Normal lens by default
else:
focal_length = size_diagonal / (2 * math.tan(math.radians(view_angle) / 2))
distance = focal_length * max(_zero_if_inf(box_size.x) / size[0],
_zero_if_inf(box_size.z) / size[1])
if distance == 0:
distance = 1
distance *= 1.2 # 20% margin around the object
origin = box.midpoint() - util.Vector(0, distance + _zero_if_inf(box_size.y) / 2, 0)
direction = util.Vector(0, 1, 0)
up = util.Vector(0, 0, 1)
return (origin, direction, up, focal_length)
def drawBallVelocity(self, painter):
ballPos = self.ballOdom.pose.pose.position
ballVel = self.ballOdom.twist.twist.linear
if math.hypot(ballVel.x, ballVel.y) < 1.0:
return
angleOfSpeed = math.atan2(ballVel.y, ballVel.x)
paintDist = 10.0
velPosX = paintDist * math.cos(angleOfSpeed) + ballPos.x
velPosY = paintDist * math.sin(angleOfSpeed) + ballPos.y
ballPosPoint = self.convertToDrawWorld(ballPos.x, ballPos.y)
velPosPoint = self.convertToDrawWorld(velPosX, velPosY)
painter.setPen(QPen(QColor(102,0,255),2))
painter.drawLine(ballPosPoint, velPosPoint)
def setup_xy(self, p1_world, p2_world, p1_ucs, p2_ucs):
""" setup an UCS given by the points p1 and p2
only xy-plane, z' = z
"""
ucs_angle_to_x_axis = get_angle(p1_ucs, p2_ucs)
world_angle_to_x_axis = get_angle(p1_world, p2_world)
rotation = normalize_angle(world_angle_to_x_axis - ucs_angle_to_x_axis)
self._xaxis = (math.cos(rotation), math.sin(rotation), 0.)
self._yaxis = (math.cos(rotation+HALF_PI), math.sin(rotation+HALF_PI), 0.)
self._zaxis = (0., 0., 1.)
ucs_angle_to_x_axis = get_angle((0., 0.), p1_ucs)
world_angle_to_x_axis = rotation + ucs_angle_to_x_axis
distance_from_ucs_origin = math.hypot(p1_ucs[0], p1_ucs[1])
delta_x = distance_from_ucs_origin * math.cos(world_angle_to_x_axis)
delta_y = distance_from_ucs_origin * math.sin(world_angle_to_x_axis)
self._origin = (p1_world[0] - delta_x, p1_world[1] - delta_y, 0.)
def manipulate_frame(self, frame_image, faces, index):
# Instantiates a client
googly_eye = Image.open(self.__class__.get_os_path('overlays/eye.png'))
for face in faces:
for side in ('left', 'right'):
((lcx, lcy), (ex, ey), (rcx, rcy)) = face.get_eye_coords(side)
ew = int(1.5 * math.hypot(rcx - lcx, rcy - lcy))
pasted = googly_eye.rotate(random.randint(0, 360), Image.BICUBIC).resize((ew, ew), Image.BICUBIC)
frame_image.paste(pasted, (int(ex - ew/2), int(ey - ew/2)), pasted)
return frame_image
def cry_frame(self, frame_image, faces, index):
# Instantiates a client
tear = Image.open(self.__class__.get_os_path('overlays/tearblood.png'))
lowest = 0
for face in faces:
for side in ('left', 'right'):
((lcx, lcy), (ex, ey), (rcx, rcy)) = face.get_eye_coords(side)
ew = int(1.25 * math.hypot(rcx - lcx, rcy - lcy))
pasted = tear.resize((ew, ew), Image.BICUBIC)
left_y = int(lcy + (index * ew * 1.5) + (ew * .75))
right_y = int(rcy + (index * ew * 1.5) + (ew * .5) )
frame_image.paste(pasted, (int(lcx - ew/2), left_y), pasted)
frame_image.paste(pasted, (int(rcx - ew/2), right_y), pasted)
lowest = max(left_y, right_y)
return lowest
def cry_frame(self, frame_image, faces, index):
# Instantiates a client
tear = Image.open(self.__class__.get_os_path('overlays/tear.png'))
lowest = 0
for face in faces:
for side in ('left', 'right'):
((lcx, lcy), (ex, ey), (rcx, rcy)) = face.get_eye_coords(side)
ew = int(1.25 * math.hypot(rcx - lcx, rcy - lcy))
pasted = tear.resize((ew, ew), Image.BICUBIC).rotate(face.angles.tilt, Image.BICUBIC)
left_y = int(lcy + (index * ew * 1.5) + (ew * .5))
right_y = int(rcy + (index * ew * 1.5) + (ew * .75) )
frame_image.paste(pasted, (int(lcx - ew/2), left_y), pasted)
frame_image.paste(pasted, (int(rcx - ew/2), right_y), pasted)
lowest = max(left_y, right_y)
return lowest
def __init__(self, dot_widget, target_x, target_y):
MoveToAnimation.__init__(self, dot_widget, target_x, target_y)
self.source_zoom = dot_widget.zoom_ratio
self.target_zoom = self.source_zoom
self.extra_zoom = 0
middle_zoom = 0.5 * (self.source_zoom + self.target_zoom)
distance = math.hypot(self.source_x - self.target_x,
self.source_y - self.target_y)
rect = self.dot_widget.get_allocation()
visible = min(rect.width, rect.height) / self.dot_widget.zoom_ratio
visible *= 0.9
if distance > 0:
desired_middle_zoom = visible / distance
self.extra_zoom = min(0, 4 * (desired_middle_zoom - middle_zoom))
def arcMidPoint(self, prev_vertex, vertex, angle):
if len(prev_vertex) == 3:
[x1, y1, z1] = prev_vertex
else:
[x1, y1] = prev_vertex
if len(vertex) == 3:
[x2, y2, z2] = vertex
else:
[x2, y2] = vertex
angle = radians(angle / 2)
basic_angle = atan2(y2 - y1, x2 - x1) - pi / 2
shift = (1 - cos(angle)) * hypot(y2 - y1, x2 - x1) / 2 / sin(angle)
midpoint = [(x2 + x1) / 2 + shift * cos(basic_angle), (y2 + y1) / 2 + shift * sin(basic_angle)]
return midpoint
def __init__(self, dot_widget, target_x, target_y):
MoveToAnimation.__init__(self, dot_widget, target_x, target_y)
self.source_zoom = dot_widget.zoom_ratio
self.target_zoom = self.source_zoom
self.extra_zoom = 0
middle_zoom = 0.5 * (self.source_zoom + self.target_zoom)
distance = math.hypot(self.source_x - self.target_x,
self.source_y - self.target_y)
rect = self.dot_widget.get_allocation()
visible = min(rect.width, rect.height) / self.dot_widget.zoom_ratio
visible *= 0.9
if distance > 0:
desired_middle_zoom = visible / distance
self.extra_zoom = min(0, 4 * (desired_middle_zoom - middle_zoom))
def dft(self, data, typecode='h'):
if type(data) is str:
a = array.array(typecode, data)
for index, value in enumerate(a):
self.real_input[index] = float(value)
elif type(data) is array.array:
for index, value in enumerate(data):
self.real_input[index] = float(value)
self.fftwf_execute(self.fftwf_plan)
for i in range(len(self.amplitude)):
self.amplitude[i] = math.hypot(self.complex_output[i * 2], self.complex_output[i * 2 + 1])
# self.phase[i] = math.atan2(self.complex_output[i * 2 + 1], self.complex_output[i * 2])
return self.amplitude # , self.phase
def start(self, route=[], v=10):
r = route
self.TopSpeed = v
self.Route = r
# Calculating position and velocity vector according to route points
if len(route) > 1:
self.CurrentRoute += 1
self.Position = Vector3(r[0]['X'], r[0]['Y'], self.Position.Z)
ddash = math.hypot(self.Position.X-r[1]['X'], self.Position.Y-r[1]['Y'])
self.Velocity = Vector3((v/ddash) * (r[1]['X']-self.Position.X), (v/ddash) * (r[1]['Y']-self.Position.Y), 0)
else:
self.Position = Vector3(0, 0, self.Position.Z)
self.Velocity = Vector3(0, 0, 0)
def animate(self):
self.angle += (math.pi / 30)
xs = 200 * math.sin(self.angle) - 40 + 25
ys = 200 * math.cos(self.angle) - 40 + 25
self.m_lightSource.setPos(xs, ys)
for item in self.m_items:
effect = item.graphicsEffect()
delta = QPointF(item.x() - xs, item.y() - ys)
effect.setOffset(QPointF(delta.toPoint() / 30))
dd = math.hypot(delta.x(), delta.y())
color = effect.color()
color.setAlphaF(max(0.4, min(1 - dd / 200.0, 0.7)))
effect.setColor(color)
self.m_scene.update()
def __init__(self):
super(StickMan, self).__init__()
self.m_sticks = True
self.m_isDead = False
self.m_pixmap = QPixmap('images/head.png')
self.m_penColor = QColor(Qt.white)
self.m_fillColor = QColor(Qt.black)
# Set up start position of limbs.
self.m_nodes = []
for x, y in Coords:
node = Node(QPointF(x, y), self)
node.positionChanged.connect(self.childPositionChanged)
self.m_nodes.append(node)
self.m_perfectBoneLengths = []
for n1, n2 in Bones:
node1 = self.m_nodes[n1]
node2 = self.m_nodes[n2]
dist = node1.pos() - node2.pos()
self.m_perfectBoneLengths.append(math.hypot(dist.x(), dist.y()))
self.startTimer(10)
def stabilize(self):
threshold = 0.001
for i, (n1, n2) in enumerate(Bones):
node1 = self.m_nodes[n1]
node2 = self.m_nodes[n2]
pos1 = node1.pos()
pos2 = node2.pos()
dist = pos1 - pos2
length = math.hypot(dist.x(), dist.y())
diff = (length - self.m_perfectBoneLengths[i]) / length
p = dist * (0.5 * diff)
if p.x() > threshold and p.y() > threshold:
pos1 -= p
pos2 += p
node1.setPos(pos1)
node2.setPos(pos2)
def __init__(self, initial_velocity, firing_angle, time_step, velocity_of_wind, angle_of_wind):
self.x = [0]
self.y = [0]
self.theta = firing_angle
self.alpha = angle_of_wind
self.v_x = [initial_velocity * math.cos(self.theta / 180 * math.pi)]
self.v_y = [initial_velocity * math.sin(self.theta / 180 * math.pi)]
self.v0 = initial_velocity
self.v = initial_velocity
self.v_w = velocity_of_wind
self.v_w_x = self.v_w * math.cos(self.alpha / 180 * math.pi)
self.v_w_y = self.v_w * math.sin(self.alpha / 180 * math.pi)
self.v_rel_x = self.v_x[0] - self.v_w_x
self.v_rel_y = self.v_y[0] - self.v_w_y
self.v_rel_module = math.hypot(self.v_rel_x, self.v_rel_y)
self.C = 0
self.B_2 = 0
self.g = 9.8
self.dt = time_step
def calculate(self):
i = 0
while(True):
self.B_2 = 0.0039 + 0.0058 / (1 + math.exp((self.v - 35) / 5))
self.C = math.pow(1 - 0.0065 * self.y[i] / 273, 2.5)
self.x.append(self.x[i] + self.v_x[i] * self.dt)
self.y.append(self.y[i] + self.v_y[i] * self.dt)
self.v_x.append(self.v_x[i] - self.C * self.B_2 * self.v_rel_module * self.v_rel_x * self.dt)
self.v_y.append(self.v_y[i] - self.g * self.dt - self.C * self.B_2 * self.v_rel_module * self.v_rel_y * self.dt)
self.v = math.hypot(self.v_x[i + 1], self.v_y[i + 1])
self.v_rel_x = self.v_x[i + 1] - self.v_w_x
self.v_rel_y = self.v_y[i + 1] - self.v_w_y
self.v_rel_module = math.hypot(self.v_rel_x, self.v_rel_y)
i += 1
if self.y[i] <= -100:
break
self.x[-1]=((-100 - self.y[-1])*(self.x[-1] - self.x[-2]) / (self.y[-1] - self.y[-2])) + self.x[-1]
self.y[i] = -100
global a
a = self.x[-1]
def calculate(self):
i = 0
while(True):
self.C = 4E-2 * math.pow(1 - 6.5 * self.y[i] / 300, 2.5)
self.g.append(self.G * self.M_E / (self.R_E + self.y[i]) ** 2)
self.x.append(self.x[i] + self.v_x[i] * self.dt)
self.y.append(self.y[i] + self.v_y[i] * self.dt)
self.v_x.append(self.v_x[i] - self.C * math.hypot(self.v_x[i], self.v_y[i]) * self.v_x[i] * self.dt)
self.v_y.append(self.v_y[i] - self.g[i-1] * self.dt - self.C * math.hypot(self.v_x[i], self.v_y[i]) * self.v_y[i] * self.dt)
i += 1
if self.y[i] < 0:
break
#For the falling point
self.x[i] = - self.y[i-1] * (self.x[i] - self.x[i-1]) / (self.y[i] - self.y[i-1]) + self.x[i-1]
self.y[i] = 0
#Maxmize the range and find the corresponding firing angle
def __init__(self, dot_widget, target_x, target_y):
MoveToAnimation.__init__(self, dot_widget, target_x, target_y)
self.source_zoom = dot_widget.zoom_ratio
self.target_zoom = self.source_zoom
self.extra_zoom = 0
middle_zoom = 0.5 * (self.source_zoom + self.target_zoom)
distance = math.hypot(self.source_x - self.target_x,
self.source_y - self.target_y)
rect = self.dot_widget.get_allocation()
visible = min(rect.width, rect.height) / self.dot_widget.zoom_ratio
visible *= 0.9
if distance > 0:
desired_middle_zoom = visible / distance
self.extra_zoom = min(0, 4 * (desired_middle_zoom - middle_zoom))
def __init__(self, dot_widget, target_x, target_y):
MoveToAnimation.__init__(self, dot_widget, target_x, target_y)
self.source_zoom = dot_widget.zoom_ratio
self.target_zoom = self.source_zoom
self.extra_zoom = 0
middle_zoom = 0.5 * (self.source_zoom + self.target_zoom)
distance = math.hypot(self.source_x - self.target_x,
self.source_y - self.target_y)
rect = self.dot_widget.get_allocation()
visible = min(rect.width, rect.height) / self.dot_widget.zoom_ratio
visible *= 0.9
if distance > 0:
desired_middle_zoom = visible / distance
self.extra_zoom = min(0, 4 * (desired_middle_zoom - middle_zoom))
def animate(self):
self.angle += (math.pi / 30)
xs = 200 * math.sin(self.angle) - 40 + 25
ys = 200 * math.cos(self.angle) - 40 + 25
self.m_lightSource.setPos(xs, ys)
for item in self.m_items:
effect = item.graphicsEffect()
delta = QPointF(item.x() - xs, item.y() - ys)
effect.setOffset(QPointF(delta.toPoint() / 30))
dd = math.hypot(delta.x(), delta.y())
color = effect.color()
color.setAlphaF(max(0.4, min(1 - dd / 200.0, 0.7)))
effect.setColor(color)
self.m_scene.update()
def __init__(self):
super(StickMan, self).__init__()
self.m_sticks = True
self.m_isDead = False
self.m_pixmap = QPixmap('images/head.png')
self.m_penColor = QColor(Qt.white)
self.m_fillColor = QColor(Qt.black)
# Set up start position of limbs.
self.m_nodes = []
for x, y in Coords:
node = Node(QPointF(x, y), self)
node.positionChanged.connect(self.childPositionChanged)
self.m_nodes.append(node)
self.m_perfectBoneLengths = []
for n1, n2 in Bones:
node1 = self.m_nodes[n1]
node2 = self.m_nodes[n2]
dist = node1.pos() - node2.pos()
self.m_perfectBoneLengths.append(math.hypot(dist.x(), dist.y()))
self.startTimer(10)
def stabilize(self):
threshold = 0.001
for i, (n1, n2) in enumerate(Bones):
node1 = self.m_nodes[n1]
node2 = self.m_nodes[n2]
pos1 = node1.pos()
pos2 = node2.pos()
dist = pos1 - pos2
length = math.hypot(dist.x(), dist.y())
diff = (length - self.m_perfectBoneLengths[i]) / length
p = dist * (0.5 * diff)
if p.x() > threshold and p.y() > threshold:
pos1 -= p
pos2 += p
node1.setPos(pos1)
node2.setPos(pos2)
def _log(z):
abs_x = abs(z.real)
abs_y = abs(z.imag)
if abs_x > _LARGE_INT or abs_y > _LARGE_INT:
return complex(math.log(math.hypot(abs_x/2, abs_y/2)) + _LOG_2,
math.atan2(z.imag, z.real))
if abs_x < _DBL_MIN and abs_y < _DBL_MIN:
if abs_x > 0 or abs_y > 0:
return complex(math.log(math.hypot(math.ldexp(abs_x, _DBL_MANT_DIG),
math.ldexp(abs_y, _DBL_MANT_DIG)))
- _DBL_MANT_DIG * _LOG_2,
math.atan2(z.imag, z.real))
raise ValueError
rad, phi = polar(z)
return complex(math.log(rad), phi)
def __init__(self,x1,y1,x2,y2,x3,y3,sector,endpoint):
self.x_m=x1; self.x=x2; self.x_p=x3; self.y_m=y1; self.y=y2; self.y_p=y3;
self.length_m = math.hypot(self.x_m-self.x, self.y_m-self.y)
self.length_p = math.hypot(self.x_p-self.x, self.y_p-self.y)
self.length_secant = math.hypot(self.x_p-self.x_m, self.y_p-self.y_m)
self.length = (self.length_m+self.length_p)/2
self.sector = sector;
if endpoint:
self.curvature = 0
else:
p = (self.length_m+self.length_p+self.length_secant)/2
#print(p, self.length_m, self.length_p, self.length_secant)
try:
area = math.sqrt(p*(p-self.length_m)*(p-self.length_p)*(p-self.length_secant))
except ValueError:
area=0
self.curvature = 4*area/(self.length_m*self.length_p*self.length_secant)
def __init__(self, dot_widget, target_x, target_y):
MoveToAnimation.__init__(self, dot_widget, target_x, target_y)
self.source_zoom = dot_widget.zoom_ratio
self.target_zoom = self.source_zoom
self.extra_zoom = 0
middle_zoom = 0.5 * (self.source_zoom + self.target_zoom)
distance = math.hypot(self.source_x - self.target_x,
self.source_y - self.target_y)
rect = self.dot_widget.get_allocation()
visible = min(rect.width, rect.height) / self.dot_widget.zoom_ratio
visible *= 0.9
if distance > 0:
desired_middle_zoom = visible / distance
self.extra_zoom = min(0, 4 * (desired_middle_zoom - middle_zoom))
def CursorClosestTo(verts, allowedError = 0.025):
ratioX, ratioY = ImageRatio()
#any length that is certantly not smaller than distance of the closest
min = 1000
minV = verts[0]
for v in verts:
if v is None: continue
for area in bpy.context.screen.areas:
if area.type == 'IMAGE_EDITOR':
loc = area.spaces[0].cursor_location
hyp = hypot(loc.x/ratioX -v.uv.x, loc.y/ratioY -v.uv.y)
if (hyp < min):
min = hyp
minV = v
if min is not 1000: return minV
return None
def __init__(self, dot_widget, target_x, target_y):
MoveToAnimation.__init__(self, dot_widget, target_x, target_y)
self.source_zoom = dot_widget.zoom_ratio
self.target_zoom = self.source_zoom
self.extra_zoom = 0
middle_zoom = 0.5 * (self.source_zoom + self.target_zoom)
distance = math.hypot(self.source_x - self.target_x,
self.source_y - self.target_y)
rect = self.dot_widget.get_allocation()
visible = min(rect.width, rect.height) / self.dot_widget.zoom_ratio
visible *= 0.9
if distance > 0:
desired_middle_zoom = visible / distance
self.extra_zoom = min(0, 4 * (desired_middle_zoom - middle_zoom))
def setup_xy(self, p1_world, p2_world, p1_ucs, p2_ucs):
""" setup an UCS given by the points p1 and p2
only xy-plane, z' = z
"""
ucs_angle_to_x_axis = get_angle(p1_ucs, p2_ucs)
world_angle_to_x_axis = get_angle(p1_world, p2_world)
rotation = normalize_angle(world_angle_to_x_axis - ucs_angle_to_x_axis)
self._xaxis = (math.cos(rotation), math.sin(rotation), 0.)
self._yaxis = (math.cos(rotation + HALF_PI), math.sin(rotation + HALF_PI), 0.)
self._zaxis = (0., 0., 1.)
ucs_angle_to_x_axis = get_angle((0., 0.), p1_ucs)
world_angle_to_x_axis = rotation + ucs_angle_to_x_axis
distance_from_ucs_origin = math.hypot(p1_ucs[0], p1_ucs[1])
delta_x = distance_from_ucs_origin * math.cos(world_angle_to_x_axis)
delta_y = distance_from_ucs_origin * math.sin(world_angle_to_x_axis)
self._origin = (p1_world[0] - delta_x, p1_world[1] - delta_y, 0.)
def CursorClosestTo(verts, allowedError = 0.025):
ratioX, ratioY = ImageRatio()
#any length that is certantly not smaller than distance of the closest
min = 1000
minV = verts[0]
for v in verts:
if v is None: continue
for area in bpy.context.screen.areas:
if area.type == 'IMAGE_EDITOR':
loc = area.spaces[0].cursor_location
hyp = hypot(loc.x/ratioX -v.uv.x, loc.y/ratioY -v.uv.y)
if (hyp < min):
min = hyp
minV = v
if min is not 1000: return minV
return None
def placeLeak(self, leak):
tooClose = True
attempts = 0
while tooClose and attempts < self._MAX_TRIES:
attempts += 1
locator = self.locators[random.randint(0, len(self.locators) - 1)]
relative = self.getRelativePoint(self.board, Point3(locator.getX(), 0, locator.getZ()))
x = relative.getX()
z = relative.getZ()
tooClose = False
for otherLeak in self.activeLeaks:
dist = math.hypot(otherLeak.getX() - x, otherLeak.getZ() - z)
if dist < self._MIN_DIST:
tooClose = True
continue
for otherLeak in self.patchedLeaks:
dist = math.hypot(otherLeak.getX() - x, otherLeak.getZ() - z)
if dist < self._MIN_DIST:
tooClose = True
continue
leak.repositionTo(x, z)
def diversity(first_front, first, last):
"""Given a Pareto front `first_front` and the two extreme points of the
optimal Pareto front, this function returns a metric of the diversity
of the front as explained in the original NSGA-II article by K. Deb.
The smaller the value is, the better the front is.
"""
df = hypot(first_front[0].fitness.values[0] - first[0],
first_front[0].fitness.values[1] - first[1])
dl = hypot(first_front[-1].fitness.values[0] - last[0],
first_front[-1].fitness.values[1] - last[1])
dt = [hypot(first.fitness.values[0] - second.fitness.values[0],
first.fitness.values[1] - second.fitness.values[1])
for first, second in zip(first_front[:-1], first_front[1:])]
if len(first_front) == 1:
return df + dl
dm = sum(dt)/len(dt)
di = sum(abs(d_i - dm) for d_i in dt)
delta = (df + dl + di)/(df + dl + len(dt) * dm )
return delta
def find_retreat_positions(self):
total_num_position = 1
retreat_positions = []
current_segment = -1
offset_distance = 1
current_retrace_length = 0
while offset_distance < total_num_position + 1:
length = math.hypot(self.computed_path[current_segment][0] - self.computed_path[current_segment - 1][0],
self.computed_path[current_segment][1] - self.computed_path[current_segment - 1][1])
while offset_distance < current_retrace_length + length and offset_distance < total_num_position + 1:
proportion = (offset_distance - current_retrace_length) / length
new_position = list(self.computed_path[current_segment]
+ (np.array(self.computed_path[current_segment - 1])
- self.computed_path[current_segment]) * proportion)
retreat_positions.append(new_position)
offset_distance += 1
current_retrace_length += length
return retreat_positions
def test_hypo(points):
dfz = Defuzzer(ndigits=0)
dfz_points = [dfz.defuzz(pt) for pt in points]
# The output values should all be in the inputs.
assert all(pt in points for pt in dfz_points)
# No two unequal output values should be too close together.
if len(points) > 1:
for a, b in all_pairs(dfz_points):
if a == b:
continue
distance = math.hypot(a[0] - b[0], a[1] - b[1])
assert distance > .5
def distance(self, other):
"""Compute the distance from this Point to another Point."""
assert isinstance(other, Point)
x1, y1 = self
x2, y2 = other
return math.hypot(x2 - x1, y2 - y1)
def offset(self, distance):
"""Create another Line `distance` from this one."""
(x1, y1), (x2, y2) = self
dx = x2 - x1
dy = y2 - y1
hyp = math.hypot(dx, dy)
offx = dy / hyp * distance
offy = -dx / hyp * distance
return Line(Point(x1 + offx, y1 + offy), Point(x2 + offx, y2 + offy))
def __abs__(self): # ??
return math.hypot(self.x, self.y)
def __abs__(self): # ??
return math.hypot(self.x, self.y)
def __abs__(self): # ??
return math.hypot(self.x, self.y)
def _distance(p0, p1):
return math.hypot(p0[0] - p1[0], p0[1] - p1[1])
def dist(cls, p1, p2):
(x1, y1), (x2, y2) = p1, p2
return math.hypot(x1 - x2, y1 - y2)
def __init__(self, start, point=None, vector=None):
"Create a line or line segment"
self.pos = start
if point:
ux = point[0] - start[0]
uy = point[1] - start[1]
elif type(vector) in (int, float):
ux = 1
uy = vector
else: ux, uy = vector
self._size = abs(ux), abs(uy)
u = hypot(ux, uy)
self.length = u #if point else None
self.u = ux / u, uy / u
def ondraw(self):
# Calculate electric force
sk = self.sketch
dr = delta(self.pos, sk["blue"].pos)
r = hypot(*dr) / sk.scale / 100
F = delta(dr, mag = 8.99e-3 * sk.q1 * sk.q2 / (r * r))
# Add electric plus gravitational forces
F = F[0], F[1] + sk.mass * 9.81e-3
# Tangential acceleration
s = sk["string"]
u = s.u
t = 1 / sk.frameRate
F = (F[0] * u[1] - F[1] * u[0]) / (sk.mass / 1000) * (sk.scale / 100) / t ** 2
ax, ay = F * u[1], -F * u[0]
# Kinematics
v1x, v1y = tuple(0.95 * v for v in self.vel)
v2x = v1x + ax * t
v2y = v1y + ay * t
self.vel = v2x, v2y
x, y = self.pos
x += (v1x + v2x) * t / 2
y += (v1y + v2y) * t / 2
x, y = delta((x,y), s.pos, 20 * sk.scale)
self.pos = s.pos[0] + x, s.pos[1] + y
s.__init__(s.pos, self.pos)
# Protractor
if s.u[1] > 0:
a = round(2 * degrees(asin(s.u[0]))) / 2
a = "Angle = {:.1f}° ".format(abs(a))
else: a = "Angle = ? "
sk["angle"].config(data=a)
def checkFront(self):
"Update the front color sensor"
# Get sensor position
pos = delta(self.pos, vec2d(-self.radius, self.angle))
# Sensor distance to edge of sketch
sk = self.sketch
if sk.weight:
obj = sk
prox = _distToWall(pos, self.angle, self.sensorWidth, *sk.size)
else: obj = prox = None
# Find closest object within sensor width
u = vec2d(1, self.angle)
sw = self.sensorWidth * DEG
for gr in self.sensorObjects(sk):
if gr is not self and gr.avgColor and hasattr(gr, "rect"):
dr = delta(gr.rect.center, pos)
d = hypot(*dr)
r = gr.radius
if r >= d:
prox = 0
obj = gr
elif prox is None or d - r < prox:
minDot = cos(min(sw + asin(r/d), pi / 2))
x = (1 - sprod(u, dr) / d) / (1 - minDot)
if x < 1:
obj = gr
prox = (d - r) * (1 - x) + x * sqrt(d*d-r*r)
# Save data
self.closestObject = obj
c = rgba(sk.border if obj is sk
else obj.avgColor if obj else (0,0,0))
self.sensorFront = noise(divAlpha(c), self.sensorNoise, 255)
self.proximity = None if prox is None else round(prox)
def dist(p1, p2):
"Distance between two points"
return hypot(p2[0] - p1[0], p2[1] - p1[1])
def polar2d(vx, vy, deg=True):
"2D Cartesian to Polar conversion"
a = atan2(vy, vx)
return hypot(vx, vy), (a / DEG if deg else a)
def elasticCircles(mass1, mass2):
"Set final velocities for an elastic collision between two circles"
# Calculate the normal vector at contact point
x1, y1 = mass1.rect.center
x2, y2 = mass2.rect.center
nx = x2 - x1
ny = y2 - y1
r = hypot(nx, ny)
if r >= mass1.radius + mass2.radius or r == 0:
return # No contact!
nx /= r
ny /= r
# Calculate initial momenta
m1 = mass1.mass
m2 = mass2.mass
v1x, v1y = mass1.vel
v2x, v2y = mass2.vel
p1x = m1 * v1x
p1y = m1 * v1y
p2x = m2 * v2x
p2y = m2 * v2y
# Calculate impulse and final velocities
impulse = 2 * (m2 * (p1x * nx + p1y * ny) - m1 * (p2x * nx + p2y * ny)) / (m1 + m2)
if impulse > 0:
mass1.vel = (p1x - impulse * nx) / m1, (p1y - impulse * ny) / m1
mass2.vel = (p2x + impulse * nx) / m2, (p2y + impulse * ny) / m2
return True