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 augment(
rotation_fn=lambda: np.random.random_integers(0, 360),
translation_fn=lambda: (np.random.random_integers(-20, 20), np.random.random_integers(-20, 20)),
scale_factor_fn=random_zoom_range(),
shear_fn=lambda: np.random.random_integers(-10, 10)
):
def call(x):
rotation = rotation_fn()
translation = translation_fn()
scale = scale_factor_fn()
shear = shear_fn()
tf_augment = AffineTransform(scale=scale, rotation=np.deg2rad(rotation), translation=translation, shear=np.deg2rad(shear))
tf = tf_center + tf_augment + tf_uncenter
x = warp(x, tf, order=1, preserve_range=True, mode='symmetric')
return x
return call Example 2
def affine_skew(self, tilt, phi, img, mask=None):
h, w = img.shape[:2]
if mask is None:
mask = np.zeros((h, w), np.uint8)
mask[:] = 255
A = np.float32([[1, 0, 0], [0, 1, 0]])
if phi != 0.0:
phi = np.deg2rad(phi)
s, c = np.sin(phi), np.cos(phi)
A = np.float32([[c, -s], [s, c]])
corners = [[0, 0], [w, 0], [w, h], [0, h]]
tcorners = np.int32(np.dot(corners, A.T))
x, y, w, h = cv2.boundingRect(tcorners.reshape(1, -1, 2))
A = np.hstack([A, [[-x], [-y]]])
img = cv2.warpAffine(img, A, (w, h), flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REPLICATE)
if tilt != 1.0:
s = 0.8*np.sqrt(tilt * tilt - 1)
img = cv2.GaussianBlur(img, (0, 0), sigmaX=s, sigmaY=0.01)
img = cv2.resize(img, (0, 0), fx=1.0 / tilt, fy=1.0, interpolation=cv2.INTER_NEAREST)
A[0] /= tilt
if phi != 0.0 or tilt != 1.0:
h, w = img.shape[:2]
mask = cv2.warpAffine(mask, A, (w, h), flags=cv2.INTER_NEAREST)
Ai = cv2.invertAffineTransform(A)
return img, mask, Ai Example 3
def augment_deterministic(
rotation=0,
translation=0,
scale_factor=1,
shear=0
):
def call(x):
scale = scale_factor, scale_factor
rotation_tmp = rotation
tf_augment = AffineTransform(
scale=scale,
rotation=np.deg2rad(rotation_tmp),
translation=translation,
shear=np.deg2rad(shear)
)
tf = tf_center + tf_augment + tf_uncenter
x = warp(x, tf, order=1, preserve_range=True, mode='symmetric')
return x
return call Example 4
def mass_streamfun(self):
from scipy import integrate
data = self._obj
# lonlen = len(data.lon)
if 'lon' in data.dims:
data = data.fillna(0).mean('lon')
levax = data.get_axis_num('lev')
stream = integrate.cumtrapz(data * np.cos(np.deg2rad(data.lat)), x=data.lev * 1e2, initial=0., axis=levax)
stream = stream * 2 * np.pi / cc.g * cc.rearth * 1e-9
stream = xr.DataArray(stream, coords=data.coords, dims=data.dims)
stream = stream.rename('ovt')
stream.attrs['long name'] = 'atmosphere overturning circulation'
stream.attrs['unit'] = 'Sv (1e9 kg/s)'
return stream Example 5
def draw_laser_frustum(pose, zmin=0.0, zmax=10, fov=np.deg2rad(60)):
N = 30
curve = np.vstack([(
RigidTransform.from_rpyxyz(0, 0, rad, 0, 0, 0) * np.array([[zmax, 0, 0]]))
for rad in np.linspace(-fov/2, fov/2, N)])
curve_w = pose * curve
faces, edges = [], []
for cpt1, cpt2 in zip(curve_w[:-1], curve_w[1:]):
faces.extend([pose.translation, cpt1, cpt2])
edges.extend([cpt1, cpt2])
# Connect the last pt in the curve w/ the current pose,
# then connect the the first pt in the curve w/ the curr. pose
edges.extend([edges[-1], pose.translation])
edges.extend([edges[0], pose.translation])
faces = np.vstack(faces)
edges = np.vstack(edges)
return (faces, edges) Example 6
def __init__(self, theta=np.deg2rad(20), displacement=0.25, lookup_history=10,
get_sample=lambda item: item.pose,
on_sampled_cb=lambda index, item: None, verbose=False):
PoseSampler.__init__(self, displacement=displacement, theta=theta,
lookup_history=lookup_history,
get_sample=get_sample,
on_sampled_cb=on_sampled_cb, verbose=verbose)
# class KeyframeVolumeSampler(FrustumVolumeIntersectionPoseSampler):
# def __init__(self, iou=0.5, depth=20, fov=np.deg2rad(60), lookup_history=10,
# get_sample=lambda item: item.pose,
# on_sampled_cb=lambda index, item: None, verbose=False):
# FrustumVolumeIntersectionPoseSampler.__init__(self, iou=iou, depth=depth, fov=fov,
# lookup_history=lookup_history,
# get_sample=get_sample,
# on_sampled_cb=on_sampled_cb, verbose=verbose) Example 7
def tsukuba_load_poses(fn):
"""
Retrieve poses
X Y Z R P Y - > X -Y -Z R -P -Y
np.deg2rad(p[3]),-np.deg2rad(p[4]),-np.deg2rad(p[5]),
p[0]*.01,-p[1]*.01,-p[2]*.01, axes='sxyz') for p in P ]
"""
P = np.loadtxt(os.path.expanduser(fn), dtype=np.float64, delimiter=',')
return [ RigidTransform.from_rpyxyz(np.pi, 0, 0, 0, 0, 0) * \
RigidTransform.from_rpyxyz(
np.deg2rad(p[3]),np.deg2rad(p[4]),np.deg2rad(p[5]),
p[0]*.01,p[1]*.01,p[2]*.01, axes='sxyz') * \
RigidTransform.from_rpyxyz(np.pi, 0, 0, 0, 0, 0) for p in P ]
# return [ RigidTransform.from_rpyxyz(
# np.deg2rad(p[3]),-np.deg2rad(p[4]),-np.deg2rad(p[5]),
# p[0]*.01,-p[1]*.01,-p[2]*.01, axes='sxyz') for p in P ] Example 8
def ct2lg(dX, dY, dZ, lat, lon):
n = dX.size
R = np.zeros((3, 3, n))
R[0, 0, :] = -np.multiply(np.sin(np.deg2rad(lat)), np.cos(np.deg2rad(lon)))
R[0, 1, :] = -np.multiply(np.sin(np.deg2rad(lat)), np.sin(np.deg2rad(lon)))
R[0, 2, :] = np.cos(np.deg2rad(lat))
R[1, 0, :] = -np.sin(np.deg2rad(lon))
R[1, 1, :] = np.cos(np.deg2rad(lon))
R[1, 2, :] = np.zeros((1, n))
R[2, 0, :] = np.multiply(np.cos(np.deg2rad(lat)), np.cos(np.deg2rad(lon)))
R[2, 1, :] = np.multiply(np.cos(np.deg2rad(lat)), np.sin(np.deg2rad(lon)))
R[2, 2, :] = np.sin(np.deg2rad(lat))
dxdydz = np.column_stack((np.column_stack((dX, dY)), dZ))
RR = np.reshape(R[0, :, :], (3, n))
dx = np.sum(np.multiply(RR, dxdydz.transpose()), axis=0)
RR = np.reshape(R[1, :, :], (3, n))
dy = np.sum(np.multiply(RR, dxdydz.transpose()), axis=0)
RR = np.reshape(R[2, :, :], (3, n))
dz = np.sum(np.multiply(RR, dxdydz.transpose()), axis=0)
return dx, dy, dz Example 9
def ct2lg(self, dX, dY, dZ, lat, lon):
n = dX.size
R = numpy.zeros((3, 3, n))
R[0, 0, :] = -numpy.multiply(numpy.sin(numpy.deg2rad(lat)), numpy.cos(numpy.deg2rad(lon)))
R[0, 1, :] = -numpy.multiply(numpy.sin(numpy.deg2rad(lat)), numpy.sin(numpy.deg2rad(lon)))
R[0, 2, :] = numpy.cos(numpy.deg2rad(lat))
R[1, 0, :] = -numpy.sin(numpy.deg2rad(lon))
R[1, 1, :] = numpy.cos(numpy.deg2rad(lon))
R[1, 2, :] = numpy.zeros((1, n))
R[2, 0, :] = numpy.multiply(numpy.cos(numpy.deg2rad(lat)), numpy.cos(numpy.deg2rad(lon)))
R[2, 1, :] = numpy.multiply(numpy.cos(numpy.deg2rad(lat)), numpy.sin(numpy.deg2rad(lon)))
R[2, 2, :] = numpy.sin(numpy.deg2rad(lat))
dxdydz = numpy.column_stack((numpy.column_stack((dX, dY)), dZ))
RR = numpy.reshape(R[0, :, :], (3, n))
dx = numpy.sum(numpy.multiply(RR, dxdydz.transpose()), axis=0)
RR = numpy.reshape(R[1, :, :], (3, n))
dy = numpy.sum(numpy.multiply(RR, dxdydz.transpose()), axis=0)
RR = numpy.reshape(R[2, :, :], (3, n))
dz = numpy.sum(numpy.multiply(RR, dxdydz.transpose()), axis=0)
return dx, dy, dz Example 10
def ct2lg(dX, dY, dZ, lat, lon):
n = dX.size
R = np.zeros((3, 3, n))
R[0, 0, :] = -np.multiply(np.sin(np.deg2rad(lat)), np.cos(np.deg2rad(lon)))
R[0, 1, :] = -np.multiply(np.sin(np.deg2rad(lat)), np.sin(np.deg2rad(lon)))
R[0, 2, :] = np.cos(np.deg2rad(lat))
R[1, 0, :] = -np.sin(np.deg2rad(lon))
R[1, 1, :] = np.cos(np.deg2rad(lon))
R[1, 2, :] = np.zeros((1, n))
R[2, 0, :] = np.multiply(np.cos(np.deg2rad(lat)), np.cos(np.deg2rad(lon)))
R[2, 1, :] = np.multiply(np.cos(np.deg2rad(lat)), np.sin(np.deg2rad(lon)))
R[2, 2, :] = np.sin(np.deg2rad(lat))
dxdydz = np.column_stack((np.column_stack((dX, dY)), dZ))
RR = np.reshape(R[0, :, :], (3, n))
dx = np.sum(np.multiply(RR, dxdydz.transpose()), axis=0)
RR = np.reshape(R[1, :, :], (3, n))
dy = np.sum(np.multiply(RR, dxdydz.transpose()), axis=0)
RR = np.reshape(R[2, :, :], (3, n))
dz = np.sum(np.multiply(RR, dxdydz.transpose()), axis=0)
return dx, dy, dz Example 11
def ct2lg(self, dX, dY, dZ, lat, lon):
n = dX.size
R = numpy.zeros((3, 3, n))
R[0, 0, :] = -numpy.multiply(numpy.sin(numpy.deg2rad(lat)), numpy.cos(numpy.deg2rad(lon)))
R[0, 1, :] = -numpy.multiply(numpy.sin(numpy.deg2rad(lat)), numpy.sin(numpy.deg2rad(lon)))
R[0, 2, :] = numpy.cos(numpy.deg2rad(lat))
R[1, 0, :] = -numpy.sin(numpy.deg2rad(lon))
R[1, 1, :] = numpy.cos(numpy.deg2rad(lon))
R[1, 2, :] = numpy.zeros((1, n))
R[2, 0, :] = numpy.multiply(numpy.cos(numpy.deg2rad(lat)), numpy.cos(numpy.deg2rad(lon)))
R[2, 1, :] = numpy.multiply(numpy.cos(numpy.deg2rad(lat)), numpy.sin(numpy.deg2rad(lon)))
R[2, 2, :] = numpy.sin(numpy.deg2rad(lat))
dxdydz = numpy.column_stack((numpy.column_stack((dX, dY)), dZ))
RR = numpy.reshape(R[0, :, :], (3, n))
dx = numpy.sum(numpy.multiply(RR, dxdydz.transpose()), axis=0)
RR = numpy.reshape(R[1, :, :], (3, n))
dy = numpy.sum(numpy.multiply(RR, dxdydz.transpose()), axis=0)
RR = numpy.reshape(R[2, :, :], (3, n))
dz = numpy.sum(numpy.multiply(RR, dxdydz.transpose()), axis=0)
return dx, dy, dz Example 12
def ct2lg(self, dX, dY, dZ, lat, lon):
n = dX.size
R = numpy.zeros((3, 3, n))
R[0, 0, :] = -numpy.multiply(numpy.sin(numpy.deg2rad(lat)), numpy.cos(numpy.deg2rad(lon)))
R[0, 1, :] = -numpy.multiply(numpy.sin(numpy.deg2rad(lat)), numpy.sin(numpy.deg2rad(lon)))
R[0, 2, :] = numpy.cos(numpy.deg2rad(lat))
R[1, 0, :] = -numpy.sin(numpy.deg2rad(lon))
R[1, 1, :] = numpy.cos(numpy.deg2rad(lon))
R[1, 2, :] = numpy.zeros((1, n))
R[2, 0, :] = numpy.multiply(numpy.cos(numpy.deg2rad(lat)), numpy.cos(numpy.deg2rad(lon)))
R[2, 1, :] = numpy.multiply(numpy.cos(numpy.deg2rad(lat)), numpy.sin(numpy.deg2rad(lon)))
R[2, 2, :] = numpy.sin(numpy.deg2rad(lat))
dxdydz = numpy.column_stack((numpy.column_stack((dX, dY)), dZ))
RR = numpy.reshape(R[0, :, :], (3, n))
dx = numpy.sum(numpy.multiply(RR, dxdydz.transpose()), axis=0)
RR = numpy.reshape(R[1, :, :], (3, n))
dy = numpy.sum(numpy.multiply(RR, dxdydz.transpose()), axis=0)
RR = numpy.reshape(R[2, :, :], (3, n))
dz = numpy.sum(numpy.multiply(RR, dxdydz.transpose()), axis=0)
return dx, dy, dz Example 13
def effect(self, point):
res = []
# print(self.centers)
for center in self.centers:
center_x, center_y = center
src_x, src_y = point.pos
# Check angle
angle = np.arctan((center_x - src_x) / (center_y - src_y))
if np.abs(angle) > self.angle / 2:
continue
angle = np.deg2rad(90) + angle
u_len = np.sqrt((center_x - src_x) ** 2 + (center_y - src_y) ** 2)
reverse_v = (self.r_index - 1) / self.radius - self.r_index / u_len
v_len = 1 / reverse_v
if v_len > 0:
p_type = 'real'
else:
p_type = 'fake'
target = line_end(point.pos, angle, u_len + v_len)
p = Point(target, p_type, 1)
# point.passed.append(self)
res.append(p)
return tuple(res) Example 14
def setRotation(self, rot, smallangle=True):
'''
Rotation angle in degrees
'''
rad = np.deg2rad(rot)
if smallangle:
# bring rad close to zero.
rad = np.fmod(rad, 2.*pi)
if rad > pi:
rad -= 2.*pi
if rad < -pi:
rad += 2.*pi
self.T = [ 0., -rad, rad, 0. ]
else:
cr = np.cos(rad)
sr = np.sin(rad)
self.T = [ cr - 1, -sr, sr, cr - 1 ] Example 15
def plot(self, values, *args, **kw):
"""Plot a concept's cause-effect repertoire on the radarchart.
Examples:
>>> full_rep = np.hstack([cause_rep, effect_rep])
>>> radar.plot(full_rep, '-', lw=2, label=mechanism_label)
Args:
values (np.ndarray): A flat array of state probabilitites, given in
the same order as the `titles` argument to the ConstellationRadar
constructor.
Also takes standard matplotlib linespec arguments, such as color, style,
linewidth, etc.
"""
angle = np.deg2rad(np.r_[self.angles, self.angles[0]])
values = np.r_[values, values[0]]
self.ax.plot(angle, values, *args, **kw) Example 16
def _rotate_interp(array, alpha, center, mode='constant', cval=0):
'''
Rotation around a provided center
This is the only way to be sure where exactly is the center of rotation.
'''
dtype = array.dtype
dims = array.shape
alpha_rad = -np.deg2rad(alpha)
x, y = np.meshgrid(np.arange(dims[1], dtype=dtype), np.arange(dims[0], dtype=dtype))
xp = (x-center[0])*np.cos(alpha_rad) + (y-center[1])*np.sin(alpha_rad) + center[0]
yp = -(x-center[0])*np.sin(alpha_rad) + (y-center[1])*np.cos(alpha_rad) + center[1]
rotated = ndimage.map_coordinates(img, [yp, xp], mode=mode, cval=cval, order=3)
return rotated Example 17
def calc_coord(self, transCoord, p, d, a, e, i, w):
# cx, cy, cz ?? ??
# p, ?? d, ?? ??
# a ??, e ???
# i ?? ???
unitAng = 360/p
ang = (unitAng * d) % 360
theta = np.deg2rad(ang)
b = a * np.sqrt(1 - np.power(e, 2))
x = transCoord[0] + a * np.cos(theta)
y = transCoord[1] + b * np.sin(theta)
z = 0.0
#rotate
w = np.deg2rad(w)
x1, y1 = x, y
#x = transCoord[0] + (x1 * np.cos(w) - y1 * np.sin(w))
#y = transCoord[1] + (x1 * np.sin(w) + y1 * np.cos(w))
coord = [x, y, z]
return coord Example 18
def mt_diff( mt1, mt2):
fps = np.deg2rad([mt1.get_fps(), mt2.get_fps()])
diff = [999999999, 999999999]
for i in range(2):
for j in range(2):
test = haversine(lon1=fps[0][i][0], phi1=fps[0][i][1], lon2=fps[1][j][0], phi2=fps[1][j][1], radius=1.)
while test>np.pi/2:
test -= np.pi/2
if test < diff[i]:
diff[i] = test
return np.rad2deg(np.mean(diff)) Example 19
def __init__(self, f0=997, fs=96000, duration=None, gaindb=0, nofsamples=0,
phasedeg=0, harmonics=7,):
"""Construct a square wave by adding odd harmonics with decreasing
amplitude, i.e. Fourier Series.
"""
Sinetone.__init__(self, f0=f0, phasedeg=phasedeg, fs=fs, nofsamples=nofsamples,
duration=duration, gaindb=0)
assert harmonics >= 0
self.harmonics = harmonics
self._logger.debug("fundamental f0: %.1f" %f0)
for n in range(3, 2*(self.harmonics+1), 2):
if n <= 15:
self._logger.debug("adding harmonic n: %2i with amplitude 1/%i" %(n, n))
if n == 17:
self._logger.debug("adding %i more harmonics..." %(self.harmonics-(n-3)//2))
#self.samples[:,0] += np.sin(2*np.pi*(n*f0)*self.get_time()+np.deg2rad(phasedeg*n))/n
self.samples[:,0] += (1/n)*self._sine_gen(n*f0, n*phasedeg)
self.gain(gaindb) Example 20
def construct_K(image_size, focal_len=None, fov_degrees=None, fov_radians=None):
""" create calibration matrix K using the image size and focal length or field of view angle
Assumes 0 skew and principal point at center of image
Note that image_size = (width, height)
Note that fov is assumed to be measured horizontally
"""
if not np.sum([focal_len is not None, fov_degrees is not None, fov_radians is not None]) == 1:
raise Exception('Specify exactly one of [focal_len, fov_degrees, fov_radians]')
if fov_degrees is not None:
fov_radians = np.deg2rad(fov_degrees)
if fov_radians is not None:
focal_len = image_size[0] / (2.0 * np.tan(fov_radians/2.0))
K = np.array([[focal_len, 0, image_size[0]/2.0], [0, focal_len, image_size[1]/2.0], [0, 0, 1]])
return K Example 21
def gaussian(height, center_x, center_y, width_x, width_y, rotation):
"""Returns a gaussian function with the given parameters"""
width_x = float(width_x)
width_y = float(width_y)
rotation = np.deg2rad(rotation)
center_x = center_x * np.cos(rotation) - center_y * np.sin(rotation)
center_y = center_x * np.sin(rotation) + center_y * np.cos(rotation)
def rotgauss(x,y):
xp = x * np.cos(rotation) - y * np.sin(rotation)
yp = x * np.sin(rotation) + y * np.cos(rotation)
g = height*np.exp(
-(((center_x-xp)/width_x)**2+
((center_y-yp)/width_y)**2)/2.)
return g
return rotgauss Example 22
def _add_table(self, name):
p = PoseStamped()
p.header.frame_id = self._robot.get_planning_frame()
p.header.stamp = rospy.Time.now()
p.pose.position.x = 0.2
p.pose.position.y = 0.0
p.pose.position.z = 0.1
q = quaternion_from_euler(0.0, 0.0, numpy.deg2rad(90.0))
p.pose.orientation = Quaternion(*q)
# Table size from ~/.gazebo/models/table/model.sdf, using the values
# for the surface link.
self._scene.add_box(name, p, (0.005, 0.005, 0.005))
return p.pose Example 23
def traj_diff(t1, t2):
"""Compute trajectory difference.
Parameters
----------
t1, t2 : DataFrame
Trajectories.
Returns
-------
diff : DataFrame
Trajectory difference. It can be interpreted as errors in `t1` relative
to `t2`.
"""
diff = t1 - t2
diff['lat'] *= np.deg2rad(earth.R0)
diff['lon'] *= np.deg2rad(earth.R0) * np.cos(0.5 *
np.deg2rad(t1.lat + t2.lat))
diff['h'] %= 360
diff.h[diff.h < -180] += 360
diff.h[diff.h > 180] -= 360
return diff.loc[t1.index.intersection(t2.index)] Example 24
def reset(self):
"""Clear computed trajectory except the initial point."""
lat, lon, VE, VN, h, p, r, stamp = self._init_values
self.lat_arr[0] = np.deg2rad(lat)
self.lon_arr[0] = np.deg2rad(lon)
self.VE_arr[0] = VE
self.VN_arr[0] = VN
self.Cnb_arr[0] = dcm.from_hpr(h, p, r)
self.traj = pd.DataFrame(index=pd.Index([stamp], name='stamp'))
self.traj['lat'] = [lat]
self.traj['lon'] = [lon]
self.traj['VE'] = [VE]
self.traj['VN'] = [VN]
self.traj['h'] = [h]
self.traj['p'] = [p]
self.traj['r'] = [r] Example 25
def equinox(date, eop_correction=True, terms=106, kinematic=True):
"""Equinox equation in degrees
"""
epsilon_bar, delta_psi, delta_eps = _nutation(date, eop_correction, terms)
equin = delta_psi * 3600. * np.cos(np.deg2rad(epsilon_bar))
if date.d >= 50506 and kinematic:
# Starting 1992-02-27, we apply the effect of the moon
ttt = date.change_scale('TT').julian_century
om_m = 125.04455501 - (5 * 360. + 134.1361851) * ttt\
+ 0.0020756 * ttt ** 2 + 2.139e-6 * ttt ** 3
equin += 0.00264 * np.sin(np.deg2rad(om_m)) + 6.3e-5 * np.sin(np.deg2rad(2 * om_m))
# print("esquinox = {}\n".format(equin / 3600))
return equin / 3600. Example 26
def test_read():
tle = Tle(ref)
assert tle.name == "ISS (ZARYA)"
assert tle.norad_id == 25544
assert tle.cospar_id == "1998-067A"
assert tle.epoch == Date(2008, 9, 20, 12, 25, 40, 104192)
assert tle.ndot == -2.182e-5
assert tle.ndotdot == 0.
assert tle.bstar == -0.11606e-4
assert tle.i == np.deg2rad(51.6416)
assert tle.? == np.deg2rad(247.4627)
assert tle.e == 6.703e-4
assert tle.? == np.deg2rad(130.5360)
assert tle.M == np.deg2rad(325.0288)
assert tle.n == 15.72125391 * 2 * np.pi / 86400.
tle = Tle(ref.splitlines()[1:])
assert tle.name == ""
with raises(ValueError):
ref2 = ref[:-1] + "8"
Tle(ref2) Example 27
def gaussian(height, center_x, center_y, width_x, width_y, rotation):
"""Returns a gaussian function with the given parameters"""
width_x = float(width_x)
width_y = float(width_y)
rotation = np.deg2rad(rotation)
center_x = center_x * np.cos(rotation) - center_y * np.sin(rotation)
center_y = center_x * np.sin(rotation) + center_y * np.cos(rotation)
def rotgauss(x,y):
xp = x * np.cos(rotation) - y * np.sin(rotation)
yp = x * np.sin(rotation) + y * np.cos(rotation)
g = height*np.exp(
-(((center_x-xp)/width_x)**2+
((center_y-yp)/width_y)**2)/2.)
return g
return rotgauss Example 28
def gaussian_pdf(height, center_x, center_y, width_x, width_y, rotation):
"""Returns a pdf function with the given parameters"""
width_x = float(width_x)
width_y = float(width_y)
rotation = np.deg2rad(rotation)
center_x = center_x * np.cos(rotation) - center_y * np.sin(rotation)
center_y = center_x * np.sin(rotation) + center_y * np.cos(rotation)
def rotgauss(x,y):
xp = x * np.cos(rotation) - y * np.sin(rotation)
yp = x * np.sin(rotation) + y * np.cos(rotation)
g = height*np.exp(
-(((center_x-xp)/width_x)**2+
((center_y-yp)/width_y)**2)/2.)
return g
return rotgauss
# doesn't allow for flattening or mean shifting, otherwise occasionally
# we get gaussians that are in the wrong place or drastically the wrong shape Example 29
def get_area_extent(self, size, offsets, factors, platform_height):
"""Get the area extent of the file."""
nlines, ncols = size
h = platform_height
# count starts at 1
cols = 1 - 0.5
lines = 1 - 0.5
ll_x, ll_y = self.get_xy_from_linecol(lines, cols, offsets, factors)
cols += ncols
lines += nlines
ur_x, ur_y = self.get_xy_from_linecol(lines, cols, offsets, factors)
return (np.deg2rad(ll_x) * h, np.deg2rad(ll_y) * h,
np.deg2rad(ur_x) * h, np.deg2rad(ur_y) * h) Example 30
def test_get_geostationary_angle_extent(self):
"""Get max geostationary angles."""
geos_area = mock.MagicMock()
geos_area.proj_dict = {'a': 6378169.00,
'b': 6356583.80,
'h': 35785831.00}
expected = (0.15185342867090912, 0.15133555510297725)
np.testing.assert_allclose(expected,
hf.get_geostationary_angle_extent(geos_area))
geos_area.proj_dict = {'a': 1000.0,
'b': 1000.0,
'h': np.sqrt(2) * 1000.0 - 1000.0}
expected = (np.deg2rad(45), np.deg2rad(45))
np.testing.assert_allclose(expected,
hf.get_geostationary_angle_extent(geos_area)) Example 31
def augmentate(self):
angles = [45, 90, 135, 180, 225, 270, 315]
scale = 1.0
for img in self.images:
print "image shape : ", img.shape
w = img.shape[1]
h = img.shape[0]
img_vmirror = cv2.flip(img,1)
skimage.io.imsave("testv"+".jpg", img_vmirror )
for angle in angles:
#rangle = np.deg2rad(angle)
# nw = (abs(np.sin(rangle)*h) + abs(np.cos(rangle)*w))*scale
# nh = (abs(np.cos(rangle)*h) + abs(np.sin(rangle)*w))*scale
rot_mat = cv2.getRotationMatrix2D((w*0.5, h*0.5), angle, scale)
# rot_move = np.dot(rot_mat, np.array([(nw-w)*0.5, (nh-h)*0.5,0]))
# rot_mat[0,2] += rot_move[0]
# rot_mat[1,2] += rot_move[1]
new_img = cv2.warpAffine(img, rot_mat, (int(math.ceil(w)), int(math.ceil(h))), flags=cv2.INTER_LANCZOS4)
skimage.io.imsave("test"+str(angle)+".jpg", new_img)
new_img_vmirror = cv2.flip(new_img, 1)
skimage.io.imsave("testv"+str(angle)+".jpg", new_img_vmirror)
# img_rmirror = cv2.flip(new_img, 0)
# skimage.io.imsave("testh"+str(angle)+".jpg", img_rmirror) Example 32
def sphericalToXYZ(lat,lon,radius=1):
'''
Convert spherical coordinates to x,y,z
@param lat: Latitude, scalar or array
@param lon: Longitude, scalar or array
@param radius: Sphere's radius
@return Numpy array of x,y,z coordinates
'''
phi = np.deg2rad(90.0 - lat)
theta = np.deg2rad(lon % 360)
x = radius * np.cos(theta)*np.sin(phi)
y = radius * np.sin(theta)*np.sin(phi)
z = radius * np.cos(phi)
if np.isscalar(x) == False:
return np.vstack([x,y,z]).T
else:
return np.array([x,y,z]) Example 33
def plot_chara(self, angle, step,Rstar = 1):
counter = 1000
i = np.arange(counter)
Rstar_tmp = self.Rstar_min + i / counter
Rstar_tmp = Rstar_tmp[Rstar_tmp < 1]
fai = self.chara_line(Rstar_tmp)
for j in range(0, angle, step):
x1 = self.chara_x(Rstar_tmp * Rstar, fai - self.const + np.deg2rad(j))
y1 = self.chara_y(Rstar_tmp * Rstar, fai - self.const + np.deg2rad(j))
x2 = self.chara_x(Rstar_tmp * Rstar, - (fai - self.const - np.deg2rad(j)))
y2 = self.chara_y(Rstar_tmp * Rstar, - (fai - self.const - np.deg2rad(j)))
plt.plot(x1, y1, "r")
plt.plot(x2, y2, "k")
plt.xlim(-1, 1)
plt.ylim(-1, 1)
plt.gca().set_aspect('equal', adjustable='box')
plt.show()
# top arc angle is 0
# v1 must be smaller than v2 Example 34
def make_upper_straight_line(self):
""" make upper straight line """
targetx = self.lower_concave_in_x_end
x = self.upper_convex_in_x_end
y = self.upper_convex_in_y_end
targety = np.tan(np.deg2rad(self.beta_in)) * targetx + y - np.tan(np.deg2rad(self.beta_in)) * x
self.upper_straight_in_x = [targetx, x]
self.upper_straight_in_y = [targety, y]
self.shift = - abs(self.lower_concave_in_y_end - targety)
targetx = self.lower_concave_out_x_end
x = self.upper_convex_out_x_end
y = self.upper_convex_out_y_end
targety = np.tan(np.deg2rad(self.beta_out)) * targetx + y - np.tan(np.deg2rad(self.beta_out)) * x
self.upper_straight_out_x = [targetx, x]
self.upper_straight_out_y = [targety, y] Example 35
def distort_affine_skimage(image, rotation=10.0, shear=5.0, random_state=None):
if random_state is None:
random_state = np.random.RandomState(None)
rot = np.deg2rad(np.random.uniform(-rotation, rotation))
sheer = np.deg2rad(np.random.uniform(-shear, shear))
shape = image.shape
shape_size = shape[:2]
center = np.float32(shape_size) / 2. - 0.5
pre = transform.SimilarityTransform(translation=-center)
affine = transform.AffineTransform(rotation=rot, shear=sheer, translation=center)
tform = pre + affine
distorted_image = transform.warp(image, tform.params, mode='reflect')
return distorted_image.astype(np.float32) Example 36
def __init__(self, fig, variables, ranges, n_ordinate_levels=6):
angles = np.arange(0, 360, 360./len(variables))
axes = [fig.add_axes([0,0, 1,1],polar=True,
label = "axes{}".format(i))
for i in range(len(variables))]
l, text = axes[0].set_thetagrids(angles, labels = variables)
[txt.set_rotation(angle-90) for txt, angle in zip(text, angles)]
for ax in axes[1:]:
ax.patch.set_visible(False)
ax.grid("off")
ax.xaxis.set_visible(False)
for i, ax in enumerate(axes):
grid = np.linspace(*ranges[i], num=n_ordinate_levels)
gridlabel = ["{}".format(round(x,2)) for x in grid]
if ranges[i][0] > ranges[i][1]:
grid = grid[::-1] # hack to invert grid
# gridlabels aren't reversed
gridlabel[0] = "" # clean up origin
ax.set_rgrids(grid, labels=gridlabel, angle=angles[i])
ax.set_ylim(*ranges[i])
# variables for plotting
self.angle = np.deg2rad(np.r_[angles, angles[0]])
self.ranges = ranges
self.ax = axes[0] Example 37
def generate_circle_points(radius, initial_angle, final_angle, points=199):
"""
This methods generates points in a circle shape at (0,0) with a specific radius and from a
starting angle to a final angle.
Args:
radius: radius of the circle in microns
initial_angle: initial angle of the drawing in degrees
final_angle: final angle of the drawing in degrees
points: amount of points to be generated (default 199)
Returns:
Set of points that form the circle
"""
theta = np.linspace( np.deg2rad(initial_angle),
np.deg2rad(final_angle),
points)
return radius * np.cos(theta) , radius * np.sin(theta) Example 38
def disttoedge(self, x, y, d):
rd = numpy.deg2rad(d)
dx, dy = numpy.cos(rd), numpy.sin(rd)
maxx = self.width()
maxy = self.height()
if dx == 0:
lefthit, righthit = sys.maxsize, sys.maxsize
tophit, bothit = (maxy - y) / dy, (-y) / dy
elif dy == 0:
lefthit, righthit = (-x) / dx, (maxx - x) / dx
tophit, bothit = sys.maxsize, sys.maxsize
else:
lefthit, righthit = (-x) / dx, (maxx - x) / dx
tophit, bothit = (maxy - y) / dy, (-y) / dy
# Return smallest positive
dists = list(filter(lambda s: s > 0, [lefthit, righthit, tophit, bothit]))
if len(dists) == 0:
return 0
else:
return min(dists) Example 39
def rotation_matrix_axis(C_values):
# Change coordinate system through matrix C
rx = np.deg2rad(float(C_values[0]))
ry = np.deg2rad(float(C_values[1]))
rz = np.deg2rad(float(C_values[2]))
Cx = np.matrix([[1, 0, 0],
[0, np.cos(rx), np.sin(rx)],
[0, -np.sin(rx), np.cos(rx)]])
Cy = np.matrix([[np.cos(ry), 0, -np.sin(ry)],
[0, 1, 0],
[np.sin(ry), 0, np.cos(ry)]])
Cz = np.matrix([[np.cos(rz), np.sin(rz), 0],
[-np.sin(rz), np.cos(rz), 0],
[0, 0, 1]])
C = Cx * Cy * Cz
Cinv = np.linalg.inv(C)
return C, Cinv Example 40
def rotation_matrix(bone, tx, ty, tz):
# Construct rotation matrix M
tx = np.deg2rad(tx)
ty = np.deg2rad(ty)
tz = np.deg2rad(tz)
Mx = np.matrix([[1, 0, 0],
[0, np.cos(tx), np.sin(tx)],
[0, -np.sin(tx), np.cos(tx)]])
My = np.matrix([[np.cos(ty), 0, -np.sin(ty)],
[0, 1, 0],
[np.sin(ty), 0, np.cos(ty)]])
Mz = np.matrix([[np.cos(tz), np.sin(tz), 0],
[-np.sin(tz), np.cos(tz), 0],
[0, 0, 1]])
M = Mx * My * Mz
L = bone.Cinv * M * bone.C
return L Example 41
def keyframedb(self, theta=np.deg2rad(20), displacement=0.25, lookup_history=10, verbose=True):
sampler = PoseSampler(theta=theta, displacement=displacement, lookup_history=lookup_history,
get_sample=lambda (t, channel, frame): frame.pose, verbose=verbose)
self.iterframes = partial(sampler.iteritems, self.iterframes())
return self
# def list_annotations(self, target_name=None):
# " List of lists"
# inds = self.annotated_inds
# return [ filter(lambda frame:
# target_name is None or name is in target_name,
# self.dataset.annotationdb.iterframes(inds))
# def _build_graph(self):
# # Keep a queue of finite length to ensure
# # time-sync with RGB and IMU
# self.__pose_q = deque(maxlen=10)
# self.nodes_ = []
# for (t,ch,data) in self.dataset_.itercursors(topics=[]):
# if ch == TANGO_VIO_CHANNEL:
# self.__pose_q.append(data)
# continue
# if not len(self.__pose_q):
# continue
# assert(ch == TANGO_RGB_CHANNEL)
# self.nodes_.append(dict(img=data, pose=self.__pose_q[-1]))
# Basic type for tango frame (includes pose, image, timestamp) Example 42
def draw_camera(pose, zmin=0.0, zmax=0.1, fov=np.deg2rad(60)):
frustum = Frustum(pose, zmin=zmin, zmax=zmax, fov=fov)
nul, nll, nlr, nur, ful, fll, flr, fur = frustum.vertices
# nll, nlr, nur, nul, fll, flr, fur, ful = frustum.vertices
faces = []
# Triangles: Front Face
faces.extend([ful, fur, flr])
faces.extend([flr, ful, fll])
# Triangles: Back Face
faces.extend([nul, nur, nlr])
faces.extend([nlr, nul, nll])
# Triangles: Four walls (2-triangles per face)
left, top, right, bottom = [fll, nll, ful, ful, nll, nul], \
[ful, nul, fur, fur, nul, nur], \
[fur, nur, flr, flr, nur, nlr], \
[flr, nlr, fll, fll, nlr, nll]
faces.extend([left, top, right, bottom]) # left, top, right, bottom wall
faces = np.vstack(faces)
# Lines: zmin-zmax
pts = []
pts.extend([ful, fur, flr, fll, ful])
pts.extend([ful, fll, nll, nul, ful])
pts.extend([ful, nul, nur, fur, ful])
pts.extend([fur, nur, nlr, flr, fur])
pts.extend([flr, nlr, nll, fll, flr])
pts = np.vstack(pts)
return (faces, np.hstack([pts[:-1], pts[1:]]).reshape((-1,3))) Example 43
def __init__(self, pose, zmin=0.0, zmax=0.1, fov=np.deg2rad(60)):
# FoV derived from fx,fy,cx,cy=500,500,320,240
# fovx, fovy = 65.23848614 51.28201165
rx, ry = 0.638, 0.478
self.pose = pose
arr = [np.array([-rx, -ry, 1.]) * zmin,
np.array([-rx, ry, 1.]) * zmin,
np.array([ rx, ry, 1.]) * zmin,
np.array([ rx, -ry, 1.]) * zmin,
np.array([-rx, -ry, 1.]) * zmax,
np.array([-rx, ry, 1.]) * zmax,
np.array([ rx, ry, 1.]) * zmax,
np.array([ rx, -ry, 1.]) * zmax]
# vertices: nul, nll, nlr, nur, ful, fll, flr, fur
self.vertices_ = self.pose * np.vstack(arr)
# self.near, self.far = np.array([0,0,zmin]), np.array([0,0,zmax])
# self.near_off, self.far_off = np.tan(fov / 2) * zmin, np.tan(fov / 2) * zmax
# arr = [self.near + np.array([-1, -1, 0]) * self.near_off,
# self.near + np.array([1, -1, 0]) * self.near_off,
# self.near + np.array([1, 1, 0]) * self.near_off,
# self.near + np.array([-1, 1, 0]) * self.near_off,
# self.far + np.array([-1, -1, 0]) * self.far_off,
# self.far + np.array([1, -1, 0]) * self.far_off,
# self.far + np.array([1, 1, 0]) * self.far_off,
# self.far + np.array([-1, 1, 0]) * self.far_off]
# nll, nlr, nur, nul, fll, flr, fur, ful = self.pose * np.vstack(arr)
# return nll, nlr, nur, nul, fll, flr, fur, ful Example 44
def __init__(self, theta=np.deg2rad(20), displacement=0.25, lookup_history=10,
get_sample=lambda item: item,
on_sampled_cb=lambda index, item: None, verbose=False):
Sampler.__init__(self, lookup_history=lookup_history,
get_sample=get_sample,
on_sampled_cb=on_sampled_cb, verbose=verbose)
self.displacement_ = displacement
self.theta_ = theta Example 45
def obj_set_position_target(self, handle, angle): return self.RAPI_rc(vrep.simxSetJointTargetPosition( self.cID,handle, -np.deg2rad(angle), vrep.simx_opmode_blocking))
Example 46
def getJitteredParams(self, num, center=(0.0, 0.0), maxRot=(-5.0, 5.0), maxTranslate=(-2.0, 2.0),
maxScale=(-0.1, 0.1), mirror=True):
if not (type(maxRot) is tuple):
maxRot = (-maxRot, maxRot)
if not (type(maxTranslate) is tuple):
maxTranslate = (-maxTranslate, maxTranslate)
if not (type(maxScale) is tuple):
maxScale = (-maxScale, maxScale)
alphas = self.rng.rand(num) * (maxRot[1] - maxRot[0]) + maxRot[0]
alphas = numpy.deg2rad(alphas)
tx = self.rng.rand(num) * (maxTranslate[1] - maxTranslate[0]) + maxTranslate[0]
ty = self.rng.rand(num) * (maxTranslate[1] - maxTranslate[0]) + maxTranslate[0]
sc = 2 ** -(self.rng.rand(num) * (maxScale[1] - maxScale[0]) + maxScale[0])
if mirror:
mi = self.rng.randint(2, size=num) # mirror true or false
else:
mi = numpy.zeros(num)
transformationMats = []
for i in range(num):
# First is not modified
if i == 0:
t = numpy.array([0, 0, 0, 1, 0])
else:
t = numpy.array([alphas[i], tx[i], ty[i], sc[i], mi[i]])
transformationMats.append(t)
return transformationMats Example 47
def rotate(self, deg, center = (0,0)):
''' rotates the image by set degree'''
#where c is the cosine of the angle, s is the sine of the angle and
#x0, y0 are used to correctly translate the rotated image.
# size of source image
src_dimsx = self.data.shape[0]
src_dimsy = self.data.shape[1]
# get the radians and calculate sin and cos
rad = np.deg2rad(deg)
c = np.cos(rad)
s = np.sin(rad)
# calculate center of image
cx = center[0] + src_dimsx/2
cy = center[1] + src_dimsy/2
# factor that moves the index to the center
x0 = cx - c*cx - s*cx
y0 = cy - c*cy + s*cy
# initialize destination image
dest = MyImage(self.data.shape)
for y in range(src_dimsy):
for x in range(src_dimsx):
# get the source indexes
src_x = int(c*x + s*y + x0)
src_y = int(-s*x + c*y + y0)
if src_y > 0 and src_y < src_dimsy and src_x > 0 and src_x < src_dimsx:
#paste the value in the destination image
dest.data[x][y] = self.data[src_x][src_y]
self.data = dest.data Example 48
def normalize_cord(latitude, longitude):
'''
Normalize GPS cord array, assuming the earth is shpherical
:param latitude: latitude array to normalize
:param longitude: longitude array to normalize
:return: normalized arrays (np.array)
'''
rad_lat = np.deg2rad(latitude)
rad_lon = np.deg2rad(longitude)
x = np.cos(rad_lat) * np.cos(rad_lon)
y = np.cos(rad_lat) * np.sin(rad_lon)
z = np.sin(rad_lat)
return x, y, z Example 49
def d_xy(self):
"""
The sampling interval along the (X, Y) spatial dimensions,
translated from the pixel size.
Unit: [Mpc]
Reference: Ref.[liu2014].Eq.(A7)
"""
pixelsize = self.pixelsize / 3600 # [arcsec] -> [deg]
d_xy = self.DMz * np.deg2rad(pixelsize)
return d_xy Example 50
def rotate_about_center(src, angle, scale=1.):
w = src.shape[1]
h = src.shape[0]
rangle = np.deg2rad(angle) # angle in radians
nw = (abs(np.sin(rangle)*h) + abs(np.cos(rangle)*w))*scale
nh = (abs(np.cos(rangle)*h) + abs(np.sin(rangle)*w))*scale
rot_mat = cv2.getRotationMatrix2D((nw*0.5, nh*0.5), angle, scale)
rot_move = np.dot(rot_mat, np.array([(nw-w)*0.5, (nh-h)*0.5,0]))
rot_mat[0,2] += rot_move[0]
rot_mat[1,2] += rot_move[1]
return cv2.warpAffine(src, rot_mat, (int(math.ceil(nw)), int(math.ceil(nh))), flags=cv2.INTER_LANCZOS4) 