# Python math.degrees() Examples

The following are 30 code examples of math.degrees(). You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may also want to check out all available functions/classes of the module , or try the search function .
Example #1
```def heading_between_points(x1, y1, x2, y2):
"""Returns the angle between 2 points in degrees.

:param x1: x coordinate of point 1
:param y1: y coordinate of point 1
:param x2: x coordinate of point 2
:param y2: y coordinate of point 2
:return: angle in degrees
"""
def angle_trunc(a):
while a < 0.0:
a += math.pi * 2
return a
deltax = x2 - x1
deltay = y2 - y1
return math.degrees(angle_trunc(math.atan2(deltay, deltax))) ```
Example #2
```def opposing_angle(pos1, pos2):
'''
Returns the angle of the other_agent relative to the agent
'''
x_dif = pos2[0] - pos1[0]
y_dif = pos2[1] - pos1[1]
if (x_dif != 0 and y_dif != 0):
if (x_dif > 0):
new_angle = 180 + degrees(atan(y_dif / x_dif))
else:
new_angle = degrees(atan(y_dif / x_dif))
elif (y_dif != 0):
if(y_dif > 0):
new_angle = 270
else:
new_angle = 90
else:
if(x_dif > 0):
new_angle = 180
else:
new_angle = 0
return new_angle ```
Example #3
```def distance(pointA, pointB):
"""
Calculate the great circle distance between two points
on the earth (specified in decimal degrees)

http://stackoverflow.com/questions/15736995/how-can-i-quickly-estimate-the-distance-between-two-latitude-longitude-points
"""
# convert decimal degrees to radians
lon1, lat1, lon2, lat2 = map(math.radians, [pointA[1], pointA[0], pointB[1], pointB[0]])

# haversine formula
dlon = lon2 - lon1
dlat = lat2 - lat1
a = math.sin(dlat/2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2)**2
c = 2 * math.asin(math.sqrt(a))
r = 3956  # Radius of earth in miles. Use 6371 for kilometers
return c * r ```
Example #4
```def rotate_bbox(box, a):
'''Rotate a bounding box 4-tuple by an angle in degrees'''
corners = ( (box[0], box[1]), (box[0], box[3]), (box[2], box[3]), (box[2], box[1]) )
sa = math.sin(a)
ca = math.cos(a)

rot = []
for p in corners:
rx = p[0]*ca + p[1]*sa
ry = -p[0]*sa + p[1]*ca
rot.append((rx,ry))

# Find the extrema of the rotated points
rot = list(zip(*rot))
rx0 = min(rot[0])
rx1 = max(rot[0])
ry0 = min(rot[1])
ry1 = max(rot[1])

#print('## RBB:', box, rot)

return (rx0, ry0, rx1, ry1) ```
Example #5
```def vector_angle_between(vector1, vector2, **kwargs):
""" Computes the angle between the two input vectors.

If the keyword argument ``degrees`` is set to *True*, then the angle will be in degrees. Otherwise, it will be
in radians. By default, ``degrees`` is set to *True*.

:param vector1: vector
:type vector1: list, tuple
:param vector2: vector
:type vector2: list, tuple
:return: angle between the vectors
:rtype: float
"""
degrees = kwargs.get('degrees', True)
magn1 = vector_magnitude(vector1)
magn2 = vector_magnitude(vector2)
acos_val = vector_dot(vector1, vector2) / (magn1 * magn2)
if degrees:
else:
Example #6
```def _view_update_camera(aspect, v3d, rv3d, camera):
zoom = rv3d.view_camera_zoom
z = ((_SQRT2 + zoom / 50) ** 2) / 4

cdata = v3d.camera.data
fit = cdata.sensor_fit
if fit == 'VERTICAL':
sensor = cdata.sensor_height
_sensor = (16 * sensor / 9) / z  # sensor / (18 / 32)
z *= 9 / 16  # 18 / 32
else:
sensor = cdata.sensor_width
_sensor = sensor / z
lens = cdata.lens
camera['fov'] = ('FLOAT', math.degrees(2 * math.atan(_sensor / (2 * lens))))

offset_x, offset_y = rv3d.view_camera_offset
shift_x = cdata.shift_x
shift_y = cdata.shift_y
shx = 2 * z * (2 * offset_x + shift_x)
shy = 2 * z * (2 * offset_y + shift_y * aspect)
camera['screen_window_min'] = ('VECTOR2', (-1, -1))
camera['screen_window_max'] = ('VECTOR2', (1, 1))

return (zoom, fit, sensor, lens, offset_x, offset_y, shift_x, shift_y) ```
Example #7
```def point_from_heading(_x, _y, heading, distance):
"""Calculates a point from a given point, heading and distance.

:param _x: source point x
:param _y: source point y
:param distance: distance from source point
:return: returns a tuple (x, y) of the calculated point
"""

return x, y ```
Example #8
```def visualizeBoneProperties(self, bone, mouse):
color = (0, 0, 0)
x = 10
y = 10

name = bone.name
if bone.mesh:
name += " (%i polygons, %i vertices)" % (len(bone.mesh.indices) // 3, len(bone.mesh.vertices) // 2)
y += self.drawText(name, HEADER_COLOR, (x, y))[1]

y += self.drawText("Translation: (%.1f, %.1f)" % (bone.translation.x,  bone.translation.y), color, (x, y))[1]

degrees = tuple([math.degrees(d) for d in (bone.rotation.x,  bone.rotation.y,  bone.rotation.z)])
y += self.drawText("Rotation:      (%.1f, %.1f, %.1f)" % degrees, color, (x, y))[1]

y += self.drawText("Scale:          (%.1f, %.1f, %.1f)" % (bone.scale.x,  bone.scale.y,  bone.scale.z), color, (x, y))[1]

self.drawText("Z-order:       %i" % bone.zOrder, color, (x, y)) ```
Example #9
```def slope_filter(self, min_slope, max_slope, fuzz):

world = om.MVector(0, 1, 0)

invalid_ids = []
for i, (_, normal, _, _, _) in enumerate(self.point_data):
normal = om.MVector(normal[0], normal[1], normal[2])
angle = math.degrees(normal.angle(world)) + 45 * random.uniform(-fuzz, fuzz)

if angle < min_slope or angle > max_slope:
invalid_ids.append(i)

invalid_ids = sorted(invalid_ids, reverse=True)
[self.point_data.remove(index) for index in invalid_ids]

pass ```
Example #10
```def get_rotation(self, direction, weight, min_rot, max_rot):
""" get rotation from a matrix pointing towards the given direction
slerped by the given weight into the world up vector and added a random
rotation between min and max rotation """

util = om.MScriptUtil()
util.createFromDouble(r_x, r_y, r_z)
rotation_ptr = util.asDoublePtr()

matrix = om.MTransformationMatrix()
matrix.setRotation(rotation_ptr, om.MTransformationMatrix.kXYZ)
world_up = om.MVector(0, 1, 0)
rotation = om.MQuaternion(world_up, direction, weight)
matrix = matrix.asMatrix() * rotation.asMatrix()
rotation = om.MTransformationMatrix(matrix).rotation().asEulerRotation()

return om.MVector(math.degrees(rotation.x),
math.degrees(rotation.y),
math.degrees(rotation.z)) ```
Example #11
```def update(self, delta_time=0):
"""
If the weather animation is true, the new sun position is calculated w.r.t delta_time

Nothing happens if animation or datetime are None.

Args:
delta_time (float): Time passed since self.datetime [seconds].
"""
if not self.animation or not self.datetime:
return

self.datetime = self.datetime + datetime.timedelta(seconds=delta_time)
self._observer_location.date = self.datetime

self._sun.compute(self._observer_location)
self.carla_weather.sun_altitude_angle = math.degrees(self._sun.alt)
self.carla_weather.sun_azimuth_angle = math.degrees(self._sun.az) ```
Example #12
```def add_coco_hp(image, points, color):
for j in range(17):
cv2.circle(image,
(points[j, 0], points[j, 1]), 2, (int(color[0]), int(color[1]), int(color[2])), -1)

stickwidth = 2
cur_canvas = image.copy()
for j, e in enumerate(_kp_connections):
if points[e].min() > 0:
X = [points[e[0], 1], points[e[1], 1]]
Y = [points[e[0], 0], points[e[1], 0]]
mX = np.mean(X)
mY = np.mean(Y)
length = ((X[0] - X[1]) ** 2 + (Y[0] - Y[1]) ** 2) ** 0.5
angle = math.degrees(math.atan2(X[0] - X[1], Y[0] - Y[1]))
polygon = cv2.ellipse2Poly((int(mY),int(mX)), (int(length/2), stickwidth), int(angle), 0, 360, 1)
cv2.fillConvexPoly(cur_canvas, polygon, (int(color[0]), int(color[1]), int(color[2])))
image = cv2.addWeighted(image, 0.5, cur_canvas, 0.5, 0)

return image ```
Example #13
```def add_coco_hp(self, points, points_prob, img_id='default'):
points = np.array(points, dtype=np.int32).reshape(self.num_joints, 2)
points_prob = np.array(points_prob, dtype=np.float32).reshape(self.num_joints)

for j in range(self.num_joints):
if points_prob[j]>0.:
cv2.circle(self.imgs[img_id],
(points[j, 0], points[j, 1]), 2, (255,255,255), -1)

stickwidth = 2
cur_canvas = self.imgs[img_id].copy()
for j, e in enumerate(self.edges):
if points_prob[e[0]] > 0. and points_prob[e[1]] > 0.:
X = [points[e[0], 1], points[e[1], 1]]
Y = [points[e[0], 0], points[e[1], 0]]
mX = np.mean(X)
mY = np.mean(Y)
length = ((X[0] - X[1]) ** 2 + (Y[0] - Y[1]) ** 2) ** 0.5
angle = math.degrees(math.atan2(X[0] - X[1], Y[0] - Y[1]))
polygon = cv2.ellipse2Poly((int(mY),int(mX)), (int(length/2), stickwidth), int(angle), 0, 360, 1)
cv2.fillConvexPoly(cur_canvas, polygon, (255, 255, 255))
self.imgs[img_id] = cv2.addWeighted(self.imgs[img_id], 0.8, cur_canvas, 0.2, 0) ```
Example #14
```def trig(a, b=' '):
if is_num(a) and isinstance(b, int):

funcs = [math.sin, math.cos, math.tan,
math.asin, math.acos, math.atan,
math.sinh, math.cosh, math.tanh,
math.asinh, math.acosh, math.atanh]

return funcs[b](a)

if is_lst(a):
width = max(len(row) for row in a)
padded_matrix = [list(row) + (width - len(row)) * [b] for row in a]
if all(isinstance(row, str) for row in a) and isinstance(b, str):
normalizer = ''.join
else:
normalizer = list
return norm_trans
return unknown_types(trig, ".t", a, b) ```
Example #15
```def angle_average(angles: np.ndarray) -> float:
"""
Function to calculate the average value of a list of angles.

Parameters
----------
angles : numpy.ndarray
Parallactic angles (deg).

Returns
-------
float
Average angle (deg).
"""

cmath_rect = sum(cmath.rect(1, math.radians(ang)) for ang in angles)
cmath_phase = cmath.phase(cmath_rect/len(angles))

return math.degrees(cmath_phase) ```
Example #16
```def reconstruct_rectangle(pa, pb, pc, pd, scale, focal):
# Calculate the coordinates of the rectangle in 3d
coords = get_lambda_d(pa, pb, pc, pd, scale, focal)
# Calculate the transformation of the rectangle
trafo = get_transformation(coords[0], coords[1], coords[2], coords[3])
# Reconstruct the rotation angles of the transformation
angles = get_rot_angles(trafo[0], trafo[1], trafo[2])
xyz_matrix = mathutils.Euler((angles[0], angles[1], angles[2]), "XYZ")
# Reconstruct the camera position and the corners of the rectangle in 3d such that it lies on the xy-plane
tr = trafo[-1]
cam_pos = apply_transformation([mathutils.Vector((0.0, 0.0, 0.0))], tr, xyz_matrix)[0]
corners = apply_transformation(coords, tr, xyz_matrix)
# Printout for debugging
print("Focal length:", focal)
print("Camera rotation:", degrees(angles[0]), degrees(angles[1]), degrees(angles[2]))
print("Camera position:", cam_pos)
length = (coords[0] - coords[1]).length
width = (coords[0] - coords[3]).length
size = max(length, width)
print("Rectangle length:", length)
print("Rectangle width:", width)
print("Rectangle corners:", corners)
return (cam_pos, xyz_matrix, corners, size) ```
Example #17
```def __init__(self, name, latitude_deg, longitude_deg, elevation_m):
"""Location.

Parameters
----------
latitude_deg : float
Latitude in degrees.
longitude_deg : float
Longitude in degrees.
elevation_m : float
Elevation in meters.

"""
self.name = name
self.latitude_deg = latitude_deg
self.longitude_deg = longitude_deg
self.elevation_m = elevation_m
self.position_ecef = coordinate_systems.geodetic_to_ecef(
elevation_m / 1000.)
self.position_llh = latitude_deg, longitude_deg, elevation_m ```
Example #18
```def calc_angle(agent1, agent2):
"""
Calculates the angle between two agents and returns the
angle
"""
pos1 = agent1.get_pos()
pos2 = agent2.get_pos()
x = pos2[X] - pos1[X]
y = pos2[Y] - pos1[Y]
angle = math.degrees(math.atan2(y, x))
if angle < 0:
angle = angle + FULL_CIRCLE
return angle ```
Example #19
```def _parse_aircraft_data(self, a, time):
alt = a.get('Alt', 0)
dist = -1
az = 0
el = 0
if 'Lat' in a and 'Long' in a:
ac_pos = (a['Lat'], a['Long'])
dist = geomath.distance(rec_pos, ac_pos)
az = geomath.bearing(rec_pos, ac_pos)
el = math.degrees(math.atan(alt / (dist * 5280)))
speed = 0
if 'Spd' in a:
speed = geomath.knot2mph(a['Spd'])
if 'PosTime' in a:
last_seen_time = datetime.fromtimestamp(a['PosTime'] / 1000.0)
seen = (time - last_seen_time).total_seconds()
else:
seen = 0
ac_data = AirCraftData(
a.get('Icao', None).upper(),
a.get('Sqk', None),
a.get('Call', None),
a.get('Reg', None),
a.get('Lat', None),
a.get('Long', None),
alt,
a.get('Vsi', 0),
a.get('Trak', None),
speed,
a.get('CMsgs', None),
seen,
a.get('Mlat', False),
None,  # NUCP
None,  # Seen pos
10.0 * math.log10(a.get('Sig', 0) / 255.0 + 1e-5),
dist,
az,
el,
time)
return ac_data ```
Example #20
```def distinct_color_sequence(hue=0.0):
# Hue is normalized from 0-1.0 for one revolution

phi = (1 + 5**0.5) / 2
golden_angle = phi #1.0 / phi**2

#print('# GA:', math.degrees(golden_angle), phi)

while(True):
yield sinebow(hue)
hue += golden_angle ```
Example #21
```def from_degrees(cls, degrees):
Example #22
```def degrees(self):
Example #23
```def __repr__(self):
return 'LatLon: {},{}'.format(math.degrees(self.__coords[0]),
math.degrees(self.__coords[1])) ```
Example #24
```def hi(self):
return LatLon.from_angles(self.lat_hi(), self.lon_hi())

# Construct a rectangle of the given size centered around the given point.
# "center" needs to be normalized, but "size" does not.  The latitude
# interval of the result is clamped to [-90,90] degrees, and the longitude
# interval of the result is Full() if and only if the longitude size is
# 360 degrees or more.  Examples of clamping (in degrees):
#
#   center=(80,170),  size=(40,60)   -> lat=[60,90],   lng=[140,-160]
#   center=(10,40),   size=(210,400) -> lat=[-90,90],  lng=[-180,180]
#   center=(-90,180), size=(20,50)   -> lat=[-90,-80], lng=[155,-155] ```
Example #25
```def _view_update_persp(v3d, camera):
lens = v3d.lens
camera['fov'] = ('FLOAT', math.degrees(2 * math.atan(64.0 / (2 * lens))))
camera['screen_window_min'] = ('VECTOR2', (-1, -1))
camera['screen_window_max'] = ('VECTOR2', (1, 1))
return (lens, ) ```
Example #26
```def two_pts_to_rectangle(point1, point2):
X = [point1[1], point2[1]]
Y = [point1[0], point2[0]]
length = ((X[0] - X[1]) ** 2 + (Y[0] - Y[1]) ** 2) ** 0.5
length = 5
alpha = math.degrees(math.atan2(X[0] - X[1], Y[0] - Y[1]))
beta = alpha - 90
if beta <= -180:
beta += 360
return [p1,p2,p3,p4] ```
Example #27
```def pose2im(all_peaks, limbSeq, limb_colors, joint_colors, H, W, _circle=True, _limb=True, imtype=np.uint8):
canvas = np.zeros(shape=(H, W, 3))
canvas.fill(255)

if _circle:
for i in range(len(joint_colors)):
cv2.circle(canvas, (int(all_peaks[i][0]), int(all_peaks[i][1])), 2, joint_colors[i], thickness=2)

if _limb:
stickwidth = 2

for i in range(len(limbSeq)):
limb = limbSeq[i]
cur_canvas = canvas.copy()
point1_index = limb[0]
point2_index = limb[1]

if len(all_peaks[point1_index]) > 0 and len(all_peaks[point2_index]) > 0:
point1 = all_peaks[point1_index][0:2]
point2 = all_peaks[point2_index][0:2]
X = [point1[1], point2[1]]
Y = [point1[0], point2[0]]
mX = np.mean(X)
mY = np.mean(Y)
# cv2.line()
length = ((X[0] - X[1]) ** 2 + (Y[0] - Y[1]) ** 2) ** 0.5
angle = math.degrees(math.atan2(X[0] - X[1], Y[0] - Y[1]))
polygon = cv2.ellipse2Poly((int(mY), int(mX)), (int(length / 2), stickwidth), int(angle), 0, 360, 1)
cv2.fillConvexPoly(cur_canvas, polygon, limb_colors[i])
canvas = cv2.addWeighted(canvas, 0.4, cur_canvas, 0.6, 0)

return canvas.astype(imtype) ```
Example #28
```def _get_tm_offset(self, _nParent, _nDriven=None, _type="t"):
"""
Get the offset between the driven and a driver node
"""
if _nDriven is None:
_nDriven = self.nSwConstRecept

mStart = om.MMatrix()
mEnd = om.MMatrix()

wmStart = _nParent.worldMatrix.get().__melobject__()
wmEnd = _nDriven.worldMatrix.get().__melobject__()

om.MScriptUtil().createMatrixFromList(wmStart, mStart)
om.MScriptUtil().createMatrixFromList(wmEnd, mEnd)

mOut = om.MTransformationMatrix(mEnd * mStart.inverse())

if _type == "t":
# Extract Translation
vTran = om.MVector(mOut.getTranslation(om.MSpace.kTransform))
vTranPymel = [vTran.x, vTran.y, vTran.z]
return vTranPymel
if _type == "r":
# Extract Rotation
ro = _nDriven.rotateOrder.get()
vRot = om.MEulerRotation(mOut.eulerRotation().reorder(ro))
vRotDeg = [math.degrees(vRot.x), math.degrees(vRot.y), math.degrees(vRot.z)]
return vRotDeg ```
Example #29
```def _pix_to_lon(j, lonpix, ntiles, _TILESIZE, zoom):
```def _pix_to_lat(k, latpix, ntiles, _TILESIZE, zoom):