Python math 模块，pi() 实例源码
我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用math.pi()。
def neighbor_circle(location, pos, shift=False, factor=1.0):
pos = pos % 6
latrad = location[0] * pi / 180
x_un = factor * safety / earth_Rrect / cos(latrad) * 180 / pi
y_un = factor * safety / earth_Rrect * 180 / pi
if not shift:
y_un = y_un * (3.0 ** 0.5) / 2.0 * HEX_R
x_un = x_un * HEX_R * 1.5
yvals = [-2, -1, 1, 2, 1, -1]
xvals = [0, 1, 1, 0, -1, -1]
else:
y_un = y_un * HEX_R * 1.5
x_un = x_un * (3.0 ** 0.5) / 2.0 * HEX_R
yvals = [-1, 0, 1, 1, 0, -1]
xvals = [1, 2, 1, -1, -2, -1]
newlat = location[0] + y_un * yvals[pos]
newlng = ((location[1] + x_un * xvals[pos] + 180) % 360) - 180
return (newlat, newlng)
def getBestCircularMatch(n):
bestc = n*2
bestr = 0
bestrp = 0.0
minr = int(math.sqrt(n / math.pi))
for rp in range(0,10):
rpf = float(rp)/10.0
for r in range(minr,minr+3):
rlim = (r+rpf)*(r+rpf)
c = 0
for y in range(-r,r+1):
yy = y*y
for x in range(-r,r+1):
if x*x+yy<rlim:
c+=1
if c == n:
return r,rpf,c
if c>n and c < bestc:
bestrp = rpf
bestr = r
bestc = c
return bestr,bestrp,bestc
def flow_orientation(orientation):
""" Currently not use anymore """
# Boolean map
_greater_pi = orientation > math.pi/2
_less_minuspi = orientation < -math.pi/2
_remaining_part = ~(_greater_pi & _less_minuspi)
# orientation map
greater_pi = orientation*_greater_pi
less_minuspi = orientation*_less_minuspi
remaining_part = orientation*_remaining_part
pi_map = math.pi * np.ones(orientation.shape)
# converted orientation map
convert_greater_pi = pi_map*_greater_pi - greater_pi
convert_less_minuspi = -pi_map*_less_minuspi - less_minuspi
new_orient = remaining_part + convert_greater_pi + convert_less_minuspi
return new_orient
def angle_wrap(angle,radians=False):
'''
Wraps the input angle to 360.0 degrees.
if radians is True: input is assumed to be in radians, output is also in
radians
'''
if radians:
wrapped = angle % (2.0*PI)
if wrapped < 0.0:
wrapped = 2.0*PI + wrapped
else:
wrapped = angle % 360.0
if wrapped < 0.0:
wrapped = 360.0 + wrapped
return wrapped
def _compute(self):
"""Compute r min max and labels position"""
delta = 2 * pi / self._len if self._len else 0
self._x_pos = [.5 * pi + i * delta for i in range(self._len + 1)]
for serie in self.all_series:
serie.points = [
(v, self._x_pos[i])
for i, v in enumerate(serie.values)]
if self.interpolate:
extended_x_pos = (
[.5 * pi - delta] + self._x_pos)
extended_vals = (serie.values[-1:] +
serie.values)
serie.interpolated = list(
map(tuple,
map(reversed,
self._interpolate(
extended_x_pos, extended_vals))))
# x labels space
self._box.margin *= 2
self._rmin = self.zero
self._rmax = self._max or 1
self._box.set_polar_box(self._rmin, self._rmax)
self._self_close = True
def spectralBlackBody(Lambda=0.7, T=5800):
""" here is the explanation of this function"""
import math
c0 = 2.9979*10**8 #m/s speed of light in vacuum
h_Plank=6.626069*10**-34 #J.s Plank's Constant
sigma_stefan_Boltzmann= 5.67*10**-8 #Stefan-Boltzmann Constant
n=1 #the index of refraction of that medium
c=c0/n# the speed of propagation of a wave in the medium
F=c/Lambda #the frequency of the wave
e_wave=h_Plank*F
E_blackBody = sigma_stefan_Boltzmann*T**4
k_Boltzmann=1.38065*10**-23 #J/K Boltzmann Constant
#Plank's Law:
C1=2*math.pi*h_Plank*c0**2*(10**24)#J*s*m^2/s^2--W*m2 --->W
C2=h_Plank*c0/k_Boltzmann*(10**6) #microm m/K
EmissiveSpectral= C1/(Lambda**5*(math.exp(C2/(Lambda*T))-1))
outPut = {"EmissiveSpectral":EmissiveSpectral,"E_blackBody":E_blackBody}
return outPut
def get_directed_hausdorff_distance(self, other):
if other.contains(self):
return 0.0
if other.is_empty():
return math.pi
other_complement_center = other.get_complement_center()
if self.contains(other_complement_center):
return self.__class__.positive_distance(other.hi(),
other_complement_center)
else:
if self.__class__(other.hi(), other_complement_center) \
.contains(self.hi()):
hi_hi = self.__class__.positive_distance(other.hi(), self.hi())
else:
hi_hi = 0
if self.__class__(other_complement_center, other.lo()) \
.contains(self.lo()):
lo_lo = self.__class__.positive_distance(self.lo(), other.lo())
else:
lo_lo = 0
assert hi_hi > 0 or lo_lo > 0
return max(hi_hi, lo_lo)
def testConstructorsAndAccessors(self):
self.assertEqual(self.quad12.lo(), 0)
self.assertEqual(self.quad12.hi(), math.pi)
self.assertEqual(self.quad34.bound(0), math.pi)
self.assertEqual(self.quad34.bound(1), 0)
self.assertEqual(self.pi.lo(), math.pi)
self.assertEqual(self.pi.hi(), math.pi)
# Check that [-Pi, -Pi] is normalized to [Pi, Pi].
self.assertEqual(self.mipi.lo(), math.pi)
self.assertEqual(self.mipi.hi(), math.pi)
self.assertEqual(self.quad23.lo(), math.pi / 2.0)
self.assertEqual(self.quad23.hi(), -math.pi / 2.0)
default_empty = SphereInterval()
self.assertTrue(default_empty.is_valid())
self.assertTrue(default_empty.is_empty())
self.assertEqual(self.empty.lo(), default_empty.lo())
self.assertEqual(self.empty.hi(), default_empty.hi())
# Should check intervals can be modified here
def testSimplePredicates(self):
# is_valid(), is_empty(), is_full(), is_inverted()
self.assertTrue(self.zero.is_valid() and
not self.zero.is_empty() and
not self.zero.is_full())
self.assertTrue(self.empty.is_valid() and
self.empty.is_empty() and
not self.empty.is_full())
self.assertTrue(self.empty.is_inverted())
self.assertTrue(self.full.is_valid() and
not self.full.is_empty() and
self.full.is_full())
self.assertTrue(not self.quad12.is_empty() and
not self.quad12.is_full() and
not self.quad12.is_inverted())
self.assertTrue(not self.quad23.is_empty() and
not self.quad23.is_full() and
self.quad23.is_inverted())
self.assertTrue(self.pi.is_valid() and
not self.pi.is_empty() and
not self.pi.is_inverted())
self.assertTrue(self.mipi.is_valid() and
not self.mipi.is_empty() and
not self.mipi.is_inverted())
def testApproxEquals(self):
self.assertTrue(self.empty.approx_equals(self.empty))
self.assertTrue(self.zero.approx_equals(self.empty) and
self.empty.approx_equals(self.zero))
self.assertTrue(self.pi.approx_equals(self.empty) and
self.empty.approx_equals(self.pi))
self.assertTrue(self.mipi.approx_equals(self.empty) and
self.empty.approx_equals(self.mipi))
self.assertTrue(self.pi.approx_equals(self.mipi) and
self.mipi.approx_equals(self.pi))
self.assertTrue(self.pi.union(self.mipi).approx_equals(self.pi))
self.assertTrue(self.mipi.union(self.pi).approx_equals(self.pi))
self.assertTrue(self.pi.union(
self.mid12).union(self.zero).approx_equals(self.quad12))
self.assertTrue(self.quad2.intersection(
self.quad3).approx_equals(self.pi))
self.assertTrue(self.quad3.intersection(
self.quad2).approx_equals(self.pi))
def testGetVertex(self):
r1 = LatLngRect(LineInterval(0, math.pi / 2.0),
SphereInterval(-math.pi, 0))
self.assertEqual(r1.get_vertex(0), LatLng.from_radians(0, math.pi))
self.assertEqual(r1.get_vertex(1), LatLng.from_radians(0, 0))
self.assertEqual(r1.get_vertex(2),
LatLng.from_radians(math.pi / 2.0, 0))
self.assertEqual(r1.get_vertex(3),
LatLng.from_radians(math.pi / 2.0, math.pi))
# Make sure the get_vertex() returns vertices in CCW order.
for i in range(4):
lat = math.pi / 4.0 * (i - 2)
lng = math.pi / 2.0 * (i - 2) + 0.2
r = LatLngRect(LineInterval(lat, lat + math.pi / 4.0),
SphereInterval(s2sphere.drem(lng, 2 * math.pi),
s2sphere.drem(lng + math.pi / 2.0, 2 * math.pi)))
for k in range(4):
self.assertTrue(
s2sphere.simple_ccw(r.get_vertex((k - 1) & 3).to_point(),
r.get_vertex(k).to_point(),
r.get_vertex((k + 1) & 3).to_point())
)
def get_angle_formed_by(p1,p2,p3): # angle formed by three positions in space
# based on code submitted by Paul Sherwood
r1 = distance(p1,p2)
r2 = distance(p2,p3)
r3 = distance(p1,p3)
small = 1.0e-10
if (r1 + r2 - r3) < small:
# This seems to happen occasionally for 180 angles
theta = math.pi
else:
theta = math.acos( (r1*r1 + r2*r2 - r3*r3) / (2.0 * r1*r2) )
return theta;
#------------------------------------------------------------------------------
def mitsuta_mean(self, angles_array):
# Function meant to work with degrees, covert inputs
# from radians to degrees and output from degrees to radians
D = math.degrees(angles_array[0])
mysum = D
for val in angles_array[1:]:
val = math.degrees(val)
delta = val - D
if delta < -180.0:
D = D + delta + 360.0
elif delta < 180.0:
D = D + delta
else:
D = D + delta - 360.0
mysum = mysum + D
m = mysum / len(angles_array)
avg = math.radians((m + 360.0) % 360.0)
# make sure avg is between -pi and pi
if avg > math.pi:
avg = avg - 2.0 * math.pi
elif avg < -math.pi:
avg = avg + 2.0 * math.pi
return avg
def distance(latitude_1, longitude_1, elevation_1, latitude_2, longitude_2, elevation_2,
haversine=None):
""" Distance between two points """
# If points too distant -- compute haversine distance:
if haversine or (abs(latitude_1 - latitude_2) > .2 or abs(longitude_1 - longitude_2) > .2):
return haversine_distance(latitude_1, longitude_1, latitude_2, longitude_2)
coef = math.cos(latitude_1 / 180. * math.pi)
#pylint: disable=invalid-name
x = latitude_1 - latitude_2
y = (longitude_1 - longitude_2) * coef
distance_2d = math.sqrt(x * x + y * y) * ONE_DEGREE
if elevation_1 is None or elevation_2 is None or elevation_1 == elevation_2:
return distance_2d
return math.sqrt(distance_2d ** 2 + (elevation_1 - elevation_2) ** 2)
def ComputeCoverage(sigma_points, bias):
def ang(p):
v = rotvecquat(vector.sub(p.compass, bias), vec2vec2quat(p.down, [0, 0, 1]))
return math.atan2(v[1], v[0])
angles = sorted(map(ang, sigma_points))
#print 'angles', angles
max_diff = 0
for i in range(len(angles)):
diff = -angles[i]
j = i+1
if j == len(angles):
diff += 2*math.pi
j = 0
diff += angles[j]
max_diff = max(max_diff, diff)
return max_diff
def onMouseEventsBoatPlot( self, event ):
self.BoatPlot.SetFocus()
pos = event.GetPosition()
if event.LeftDown():
self.lastmouse = pos
if event.Dragging():
dx, dy = pos[0] - self.lastmouse[0], pos[1] - self.lastmouse[1]
q = pypilot.quaternion.angvec2quat((dx**2 + dy**2)**.4/180*math.pi, [dy, dx, 0])
self.boat_plot.Q = pypilot.quaternion.multiply(q, self.boat_plot.Q)
self.BoatPlot.Refresh()
self.lastmouse = pos
rotation = event.GetWheelRotation() / 60
if rotation:
self.BoatPlot.Refresh()
while rotation > 0:
self.boat_plot.Scale /= .9
rotation -= 1
while rotation < 0:
self.boat_plot.Scale *= .9
rotation += 1
def __init__(self,seed):
random.seed(seed)
self.ISLAND_FACTOR = 1.13 # 1.0 means no small islands; 2.0 leads to a lot
self.bumps = random.randrange(1,7)
self.startAngle = random.uniform(0,2*math.pi)
self.dipAngle = random.uniform(0,2*math.pi)
self.dipWidth = random.uniform(0.2,0.7)
def __init__(self):
self.ser = serial.Serial('/dev/ttyACM0', 9600)
#geometrical calibration
self.rs = [50, 50, 50]
self.ls = [95, 130, 95]
self.pot_rad_per_unit = 1./3000.*math.pi
angles = [2./3.*math.pi, 0., -2./3.*math.pi]
#placements of the 3 joysticks
self.placements = []
#attach point on the ball
self.attach_ps = []
for r,l,a in zip(self.rs, self.ls, angles):
p_init = pose.exp(col([0, 0, 0, 0, 0, -(r+l)]))
p_rot = pose.exp(col([0, a, 0, 0, 0, 0]))
placement = p_rot * p_init
self.placements.append(placement)
attach_p = placement * col([0, 0, l])
self.attach_ps.append(attach_p)
#last calculated pose in logarithmic coordinates
self.last_x = col([0, 0, 0, 0, 0, 0])
#definition of the numerical solver
f = lambda x: self.getValuesFromPose(pose.exp(x))
self.solver = solver.Solver(f)
def __init__(self, model, action_size=1, init_value=0.0, *args, **kwargs):
super(DiagonalGaussianPolicy, self).__init__(model, *args, **kwargs)
self.init_value = init_value
self.logstd = th.zeros((1, action_size)) + self.init_value
self.logstd = P(self.logstd)
self.halflog2pie = V(T([2 * pi * exp(1)])) * 0.5
self.halflog2pi = V(T([2.0 * pi])) * 0.5
self.pi = V(T([pi]))
def _normal(self, x, mean, logstd):
std = logstd.exp()
std_sq = std.pow(2)
a = (-(x - mean).pow(2) / (2 * std_sq)).exp()
b = (2 * std_sq * self.pi.expand_as(std_sq)).sqrt()
return a / b
def rokuro_add_euler(euler, r):
props = bpy.context.window_manager.rokuro
if props.rotate_direction:
if (euler + r) < 0:
new_euler = euler + r + (2.0 * math.pi)
else:
new_euler = euler + r
else:
if (euler + r) > (2.0 * math.pi):
new_euler = euler + r - (2.0 * math.pi)
else:
new_euler = euler + r
return new_euler
def rokuro_proc(scene):
props = bpy.context.window_manager.rokuro
r = props.rotate_step * 2.0 * math.pi / (scene.frame_end - scene.frame_start)
if props.rotate_direction:
r *= -1.0
if props.rotate_axis_x:
bpy.context.object.rotation_euler[0] = rokuro_add_euler(bpy.context.object.rotation_euler[0], r)
if props.rotate_axis_y:
bpy.context.object.rotation_euler[1] = rokuro_add_euler(bpy.context.object.rotation_euler[1], r)
if props.rotate_axis_z:
bpy.context.object.rotation_euler[2] = rokuro_add_euler(bpy.context.object.rotation_euler[2], r)
def drag_bone(self,context, event ,bone=None):
### math.atan2(0.5, 0.5)*180/math.pi
if bone != None:
bone.hide = False
mouse_vec_norm = (self.cursor_location - self.mouse_click_vec).normalized()
mouse_vec = (self.cursor_location - self.mouse_click_vec)
angle = (math.atan2(mouse_vec_norm[0], mouse_vec_norm[2])*180/math.pi)
cursor_local = self.armature.matrix_world.inverted() * self.cursor_location
cursor_local[1] = 0
if event.shift:
if angle > -22.5 and angle < 22.5:
### up
bone.tail = Vector((bone.head[0],cursor_local[1],cursor_local[2]))
elif angle > 22.5 and angle < 67.5:
### up right
bone.tail = (bone.head + Vector((mouse_vec[0],0,mouse_vec[0])))
elif angle > 67.5 and angle < 112.5:
### right
bone.tail = Vector((cursor_local[0],cursor_local[1],bone.head[2]))
elif angle > 112.5 and angle < 157.5:
### down right
bone.tail = (bone.head + Vector((mouse_vec[0],0,-mouse_vec[0])))
elif angle > 157.5 or angle < -157.5:
### down
bone.tail = Vector((bone.head[0],cursor_local[1],cursor_local[2]))
elif angle > -157.5 and angle < -112.5:
### down left
bone.tail = (bone.head + Vector((mouse_vec[0],0,mouse_vec[0])))
elif angle > -112.5 and angle < -67.5:
### left
bone.tail = Vector((cursor_local[0],cursor_local[1],bone.head[2]))
elif angle > -67.5 and angle < -22.5:
### left up
bone.tail = (bone.head + Vector((mouse_vec[0],0,-mouse_vec[0])))
else:
bone.tail = cursor_local
def get_bone_angle(armature,bone,relative=True):
loc, rot, scale = get_bone_matrix(armature,bone,relative).decompose()
compat_euler = Euler((0.0,0.0,math.pi),"XYZ")
angle = -rot.to_euler().z # negate angle to fit dragonbones angle
return round(math.degrees(angle),2)
def get_mesh(self, bend, base_shape, index):
"""produce leaf mesh at position of this leaf given base mesh as input"""
# calculate angles to transform mesh to align with desired direction
trf = self.direction.to_track_quat('Z', 'Y')
right_t = self.right.rotated(trf.inverted())
spin_ang = pi - right_t.angle(Vector([1, 0, 0]))
# calculate bend transform if needed
if bend > 0:
bend_trf_1, bend_trf_2 = self.calc_bend_trf(bend)
else:
bend_trf_1 = bend_trf_2 = None
vertices = []
for vertex in base_shape[0]:
# rotate to correct direction
vertex = vertex.copy()
vertex.rotate(Quaternion(Vector([0, 0, 1]), spin_ang))
vertex.rotate(trf)
# apply bend if needed
if bend > 0:
vertex.rotate(bend_trf_1)
vertex.rotate(bend_trf_2)
# move to right position
vertex += self.position
# add to vertex array
vertices.append(vertex)
# set face to refer to vertices at correct offset in big vertex list
index *= len(vertices)
faces = deepcopy(base_shape[1])
for face in faces:
for ind, elem in enumerate(face):
face[ind] = elem + index
return vertices, faces
def calc_bend_trf(self, bend):
"""calculate the transformations required to 'bend' the leaf out/up from WP"""
normal = self.direction.cross(self.right)
theta_pos = atan2(self.position.y, self.position.x)
theta_bend = theta_pos - atan2(normal.y, normal.x)
bend_trf_1 = Quaternion(Vector([0, 0, 1]), theta_bend * bend)
self.direction.rotate(bend_trf_1)
self.right.rotate(bend_trf_1)
normal = self.direction.cross(self.right)
phi_bend = normal.declination()
if phi_bend > pi / 2:
phi_bend = phi_bend - pi
bend_trf_2 = Quaternion(self.right, phi_bend * bend)
return bend_trf_1, bend_trf_2
def calc_helix_points(turtle, rad, pitch):
""" calculates required points to produce helix bezier curve with given radius and pitch in direction of turtle"""
# alpha = radians(90)
# pit = pitch/(2*pi)
# a_x = rad*cos(alpha)
# a_y = rad*sin(alpha)
# a = pit*alpha*(rad - a_x)*(3*rad - a_x)/(a_y*(4*rad - a_x)*tan(alpha))
# b_0 = Vector([a_x, -a_y, -alpha*pit])
# b_1 = Vector([(4*rad - a_x)/3, -(rad - a_x)*(3*rad - a_x)/(3*a_y), -a])
# b_2 = Vector([(4*rad - a_x)/3, (rad - a_x)*(3*rad - a_x)/(3*a_y), a])
# b_3 = Vector([a_x, a_y, alpha*pit])
# axis = Vector([0, 0, 1])
# simplifies greatly for case inc_angle = 90
points = [Vector([0, -rad, -pitch / 4]),
Vector([(4 * rad) / 3, -rad, 0]),
Vector([(4 * rad) / 3, rad, 0]),
Vector([0, rad, pitch / 4])]
# align helix points to turtle direction and randomize rotation around axis
trf = turtle.dir.to_track_quat('Z', 'Y')
spin_ang = rand_in_range(0, 2 * pi)
for p in points:
p.rotate(Quaternion(Vector([0, 0, 1]), spin_ang))
p.rotate(trf)
return points[1] - points[0], points[2] - points[0], points[3] - points[0], turtle.dir.copy()
def points_for_floor_split(self):
"""Calculate Poissonly distributed points for stem start points"""
array = []
# calculate approx spacing radius for dummy stem
self.tree_scale = self.param.g_scale + self.param.g_scale_v
stem = Stem(0, None)
stem.length = self.calc_stem_length(stem)
rad = 2.5 * self.calc_stem_radius(stem)
# generate points
for _ in range(self.param.floor_splits + 1):
point_ok = False
while not point_ok:
# distance from center proportional for number of splits, tree scale and stem radius
dis = sqrt(rand_in_range(0, 1) * self.param.floor_splits / 2.5 * self.param.g_scale * self.param.ratio)
# angle random in circle
theta = rand_in_range(0, 2 * pi)
pos = Vector([dis * cos(theta), dis * sin(theta), 0])
# test point against those already in array to ensure it will not intersect
point_m_ok = True
for point in array:
if (point[0] - pos).magnitude < rad:
point_m_ok = False
break
if point_m_ok:
point_ok = True
array.append((pos, theta))
return array
def shape_ratio(self, shape, ratio):
"""Calculate shape ratio as defined in paper"""
if shape == 1: # spherical
result = 0.2 + 0.8 * sin(pi * ratio)
elif shape == 2: # hemispherical
result = 0.2 + 0.8 * sin(0.5 * pi * ratio)
elif shape == 3: # cylindrical
result = 1.0
elif shape == 4: # tapered cylindrical
result = 0.5 + 0.5 * ratio
elif shape == 5: # flame
if ratio <= 0.7:
result = ratio / 0.7
else:
result = (1.0 - ratio) / 0.3
elif shape == 6: # inverse conical
result = 1.0 - 0.8 * ratio
elif shape == 7: # tend flame
if ratio <= 0.7:
result = 0.5 + 0.5 * ratio / 0.7
else:
result = 0.5 + 0.5 * (1.0 - ratio) / 0.3
elif shape == 8: # envelope
if ratio < 0 or ratio > 1:
result = 0.0
elif ratio < 1 - self.param.prune_width_peak:
result = pow(ratio / (1 - self.param.prune_width_peak),
self.param.prune_power_high)
else:
result = pow((1 - ratio) / (1 - self.param.prune_width_peak),
self.param.prune_power_low)
else: # conical (0)
result = 0.2 + 0.8 * ratio
return result
def get_border_cell(s2_id):
locs = []
s2_cell = Cell(s2_id)
for i in [0, 1]:
for j in [0, 1]:
locs.append([s2_cell.get_latitude(i, j) * 180 / pi, s2_cell.get_longitude(i, j) * 180 / pi])
output = [locs[0], locs[1], locs[3], locs[2], locs[0]]
return output
def init_lats(self):
latrad = 0.0
lats = []
c = 0.5 * self.r_sight * self.safety
while latrad < pi / 2:
lats.append(latrad)
latrad += c / self.earth_R
return lats
def init_grid(self):
grid_all = []
lats = self.init_lats()
c = 2 * pi / (3 ** 0.5 * self.r_sight * self.safety) * self.earth_R
even_lng = True
strip_amount = int(ceil(c))
grid_all.append((0, strip_amount, even_lng))
ind_lat = 2
while ind_lat < len(lats):
amount = int(ceil(c * cos(lats[ind_lat])))
if amount < strip_amount - (sin(lats[ind_lat]*2)*self.param_shift+self.param_stretch):
ind_lat -= 1
strip_amount = int(ceil(c * cos(lats[ind_lat])))
else:
even_lng = not even_lng
if ind_lat + 1 < len(lats):
lat = lats[ind_lat + 1] * 180 / pi
grid_all.append((lat, strip_amount, even_lng))
ind_lat += 3
grid_all.append((90.0, 1, True)) # pole
return grid_all
def cover_circle(self,loc,radius):
lat,lng = loc
output = []
r_lat = radius / earth_Rrect*180/pi
r_lng = r_lat /cos(min(abs(lat)+r_lat,90.0)*pi/180)
locations = self.cover_region((lat-r_lat,lng-r_lng),(lat+r_lat,lng+r_lng))
for location in locations:
dist = get_distance(loc,location)
if dist < radius:
output.append(location)
return output
def getCircularBounds(fitCloud=None,width=64,height=64,smoothing=0.01):
circumference = 2*(width+height)
if not fitCloud is None:
cx = np.mean(fitCloud[:,0])
cy = np.mean(fitCloud[:,1])
r = 0.5* max( np.max(fitCloud[:,0])- np.min(fitCloud[:,0]),np.max(fitCloud[:,1])- np.min(fitCloud[:,1]))
else:
r = circumference /(2.0*math.pi)
cx = cy = r
perimeterPoints = np.zeros((circumference,2),dtype=float)
for i in range(circumference):
angle = (2.0*math.pi)*float(i) / circumference - math.pi * 0.5
perimeterPoints[i][0] = cx + r * math.cos(angle)
perimeterPoints[i][1] = cy + r * math.sin(angle)
bounds = {'top':perimeterPoints[0:width],
'right':perimeterPoints[width-1:width+height-1],
'bottom':perimeterPoints[width+height-2:2*width+height-2],
'left':perimeterPoints[2*width+height-3:]}
bounds['s_top'],u = interpolate.splprep([bounds['top'][:,0], bounds['top'][:,1]],s=smoothing)
bounds['s_right'],u = interpolate.splprep([bounds['right'][:,0],bounds['right'][:,1]],s=smoothing)
bounds['s_bottom'],u = interpolate.splprep([bounds['bottom'][:,0],bounds['bottom'][:,1]],s=smoothing)
bounds['s_left'],u = interpolate.splprep([bounds['left'][:,0],bounds['left'][:,1]],s=smoothing)
return bounds
def test_import(self):
self.assert_ok("""\
import math
print(math.pi, math.e)
from math import sqrt
print(sqrt(2))
""")
def test_FileSourceTimecodeType2000Complex(self):
# Create a test file with frequency on the X-axis and time on the
# Y-axis (as one might see from an FFT)
subsize = 200
xdelta = 2.0*math.pi/subsize
ydelta = 0.125
hdr = bluefile.header(2000, 'CF', subsize=subsize)
hdr['xstart'] = -math.pi/2.0
hdr['xdelta'] = xdelta
hdr['xunits'] = 3 # frequency
hdr['ydelta'] = ydelta
hdr['yunits'] = 1 # time
data = numpy.arange(1000, dtype=numpy.complex64).reshape((-1,subsize))
self._check_FileSourceTimecode(hdr, data, subsize*2, ydelta)
def rotate(self, degrees):
# Cairo uses radians, let's be more convenient.
self.ctx.rotate(degrees * math.pi / 180)
def circle(self, xc, yc, radius):
self.arc(xc, yc, radius, 0, math.pi * 2)
def angle(self, n):
# ?? n???? ???????????
r = math.sqrt(sum(x * x for x in self[n:]))
a = math.atan2(r, self[n - 1])
if (n == len(self)) and (self[-1] < 0):
return math.pi * 2 - a
else:
return a
def createLabels(X, y, labels, cameraObj=None):
labelIndices = set(y)
objects = []
# Draw labels
for labelIdx in labelIndices:
center = np.sum([x for x, idx in zip(X, y) \
if idx == labelIdx], axis=0)
counts = (y == labelIdx).sum()
center = Vector(center) / counts
label = labels[labelIdx]
fontCurve = bpy.data.curves.new(type="FONT", name=label)
fontCurve.body = label
fontCurve.align_x = 'CENTER'
fontCurve.align_y = 'BOTTOM'
fontCurve.size = 0.6
obj = bpy.data.objects.new("Label {}".format(label), fontCurve)
obj.location = center + Vector((0, 0, 0.8))
obj.rotation_mode = 'AXIS_ANGLE'
obj.rotation_axis_angle = (pi/2, 1, 0, 0)
bpy.context.scene.objects.link(obj)
if cameraObj is not None:
constraint = obj.constraints.new('LOCKED_TRACK')
constraint.target = cameraObj
constraint.track_axis = 'TRACK_Z'
constraint.lock_axis = 'LOCK_Y'
objects.append(obj)
bpy.context.scene.update()
return objects
def __init__(self, scene):
self.n, self.m = 40, 30
self.r0, self.r1, self.r2 = 10, 2, 2
self.h0, self.h1 = 10, 3
self.frames = scene.frame_end - scene.frame_start + 1
# Calculate and compensate for angle offset for infinite animation
self.offset = (self.frames * goldenAngle) % TAU
if self.offset > pi: self.offset -= TAU
# Create object
mesh = bpy.data.meshes.new('PhyllotaxisFlower')
self.obj = bpy.data.objects.new('PhyllotaxisFlower', mesh)
# Create mesh
bm = self.geometry()
bm.to_mesh(mesh)
mesh.update()
bm.free()
# Link object to scene
scene.objects.link(self.obj)
scene.update()
# Append new frame change handler to redraw geometry
# for each frame change
bpy.app.handlers.frame_change_pre.append(self.__frameChangeHandler)
def geometry(self, frame=0):
t = frame / self.frames
Rot = Matrix.Rotation(0.5*pi, 4, 'Y')
bm = bmesh.new()
for i in range(self.n):
t0 = i / self.n
r0, theta = t0*self.r0, i*goldenAngle - frame*goldenAngle + t*self.offset
x = r0*cos(theta)
y = r0*sin(theta)
z = self.h0/2 - (self.h0 / (self.r0*self.r0))*r0*r0
p0 = Vector((x, y, z))
T0, N0, B0 = getTNBfromVector(p0)
M0 = Matrix([T0, B0, N0]).to_4x4().transposed()
for j in range(self.m):
t1 = j / self.m
t2 = 0.4 + 0.6*t0
r1, theta = t2*t1*self.r1, j*goldenAngle #- frame*goldenAngle + t*self.offset
x = r1*cos(theta)
y = r1*sin(theta)
z = self.h1 - (self.h1 / (self.r1*self.r1))*r1*r1
p1 = Vector((x, y, z))
T1, N1, B1 = getTNBfromVector(p1)
M1 = Matrix([T1, B1, N1]).to_4x4().transposed()
p = p0 + M0*p1
r2 = t2*t1*self.r2
T = Matrix.Translation(p)
bmesh.ops.create_cone(bm,
cap_ends=True, segments=6,
diameter1=r2, diameter2=r2,
depth=0.1*r2, matrix=T*M0*M1*Rot)
return bm
def __log_likelihood_factor__(self, samples_q, v_noise, X, wb, y):
# Account for occasions where we're optimizing the latent weighting distributions
if wb.shape[0] == 1:
if wb.shape[1] > self.num_latent_params: # Further account
# Reshape the wb to be a full matrix and build full latent array
Wb = np.reshape(wb, [-1,self.num_latent_params])
latent_weights = np.array([Wb[int(X[tt,-1]),:] for tt in range(X.shape[0])])
outputs = self.__predict__(samples_q, np.hstack([X[:,:-1], latent_weights]))
else:
outputs = self.__predict__(samples_q, np.hstack([X, np.tile(wb,(X.shape[0],1))]))
else:
outputs = self.__predict__(samples_q, np.hstack([X, wb]))
return (-0.5*np.log(2*math.pi*v_noise)) - (0.5*(np.tile(np.expand_dims(y,axis=0), (self.num_weight_samples,1,1))-outputs)**2)/v_noise
def __log_normalizer__(self, q):
return np.sum(0.5*np.log(q['v']*2*math.pi) + 0.5*q['m']**2/q['v'])
def __log_Z_prior__(self):
return self.num_weights * 0.5 * np.log(self.v_prior*2*math.pi)
def get_error_and_ll(self, X, y, location, scale):
v_noise = np.exp(self.parser.get(self.weights, 'log_v_noise')[0,0]) * scale**2
q = self.__get_parameters_q__()
samples_q = self.__draw_samples__(q)
outputs = self.__predict__(samples_q, X)
log_factor = -0.5*np.log(2*math.pi*v_noise) - 0.5*(np.tile(np.expand_dims(y,axis=0), (self.num_weight_samples,1,1))-np.array(outputs))**2/v_noise
ll = np.mean(logsumexp(np.sum(log_factor,2)-np.log(self.num_weight_samples), 0))
error = np.sqrt(np.mean((y-np.mean(outputs, axis=0))**2))
return error, ll
def show_result(hists, bin_edges):
""" check results """
for b_edge in bin_edges/math.pi*180:
print '{0:.2f}\t'.format(round(b_edge)),
print
for hist in hists:
print '{0:.2f}\t'.format(hist),
print
def gradient_histogram(flow_img, binsize=12):
""" calculate histogram """
assert len(flow_img.shape) == 3, "Wrong flow image."
# NOTE the frame is in RGB, while cv2 is in BGR, so do REMEMBER to reverse it.
img_mag, img_v, img_u = np.split(flow_img, 3, 2)
# NOTE the role reversal: the "y-coordinate" is the first function parameter, the "x-coordinate" is the second.
# NOTE that we use same axis configure as image axis(x is larger to the right, y is larger to the bottom),
# so add a minus sign before img_v, to make the two axis align.
orientation = np.arctan2(-img_v, img_u)
# Original result not applicable
# Directly use full 360 degree
new_orient = orientation
# Prune zero motion
_mag_greater_zero = img_mag > 0.0
pruned_orient = new_orient[_mag_greater_zero]
# Histogram of optical flow
hofbins = np.arange(-math.pi, math.pi+1e-6, 2*math.pi/binsize)
hist, bin_edges = np.histogram(pruned_orient.flatten(), bins= hofbins) #, density=True)
# Normalize
hist = hist.astype(np.float32) / (np.sum(_mag_greater_zero) + 1e-6)
return hist, bin_edges
def cart2polar(x, y, degrees=True):
"""
Convert cartesian X and Y to polar RHO and THETA.
:param x: x cartesian coordinate
:param y: y cartesian coordinate
:param degrees: True = return theta in degrees, False = return theta in
radians. [default: True]
:return: r, theta
"""
rho = ma.sqrt(x ** 2 + y ** 2)
theta = ma.arctan2(y, x)
if degrees:
theta *= (180 / math.pi)
return rho, theta