def sigmoid(self):
rb = -(self.src.shape[1] * np.tan(np.deg2rad(100 / 2))) / (
np.tan(np.deg2rad(self.fov / 2)) * np.log(99e-8))
ra = rb * np.log(99)
return np.repeat(
np.power(
1 +
np.exp(-(np.linalg.norm(self.uniform_grid, axis=2) - ra) / rb),
-1), 2).reshape(self.uniform_grid.shape)
def __init__(self,
center=(0., 0.),
semi_major_axis=2.,
semi_minor_axis=1.,
angle=90.):
self.center = center # Center of the circle
a = semi_major_axis
b = semi_minor_axis
xc = center[0]
yc = center[1]
angle = np.deg2rad(angle)
#https://en.wikipedia.org/wiki/Ellipse
A = a**2 * (np.sin(angle)**2) + b**2 * (np.cos(angle)**2)
B = 2 * (b**2 - a**2) * np.sin(angle) * np.cos(angle)
C = a**2 * (np.cos(angle)**2) + b**2 * (np.sin(angle)**2)
D = -2 * A * xc - B * yc
E = -B * xc - 2 * C * yc
F = A * xc**2 + B * xc * yc + C * yc**2 - (a**2) * (b**2)
self.a = A
self.b = B
self.c = C
self.d = D
self.e = E
self.f = F
self.update_conic_matrix()
def __init__(self):
""" Definition of a simulated camera """
self.cam = Camera()
self.cam.set_K(fx=100, fy=100, cx=640, cy=480)
self.cam.set_width_heigth(1280, 960)
""" Initial camera pose looking stratight down into the plane model """
self.cam.set_R_axisAngle(1.0, 0.0, 0.0, np.deg2rad(180))
self.cam.set_t(0.0, 0.0, 1.5, frame='world')
""" Plane for the control points """
self.sph = Sphere(radius=0.5)
self.sph.random_points(p=6, r=0.5, min_dist=0.001)
def scale_and_rotate_mnist_image(image, angle_range=15.0, scale_range=0.1):
angle = 2 * angle_range * np.random.random() - angle_range
scale = 1 + 2 * scale_range * np.random.random() - scale_range
tf_rotate = transform.SimilarityTransform(rotation=np.deg2rad(angle))
tf_scale = transform.SimilarityTransform(scale=scale)
tf_shift = transform.SimilarityTransform(translation=[-14, -14])
tf_shift_inv = transform.SimilarityTransform(translation=[14, 14])
image = transform.warp(image.reshape([28, 28]),
(tf_shift + tf_scale + tf_rotate + tf_shift_inv).inverse)
return image.reshape([28*28])
def scale_and_rotate_mnist_image(image, angle_range=15.0, scale_range=0.1):
angle = 2 * angle_range * np.random.random() - angle_range
scale = 1 + 2 * scale_range * np.random.random() - scale_range
tf_rotate = transform.SimilarityTransform(rotation=np.deg2rad(angle))
tf_scale = transform.SimilarityTransform(scale=scale)
tf_shift = transform.SimilarityTransform(translation=[-14, -14])
tf_shift_inv = transform.SimilarityTransform(translation=[14, 14])
image = transform.warp(image.reshape(
[28, 28]), (tf_shift + tf_scale + tf_rotate + tf_shift_inv).inverse)
return image.reshape([28 * 28])
def __init__(self,
ref_energy,
energy_gain,
acc_max,
alpha_max_pd_enable=20.0,
pd_gain=None):
# Set up the energy pumping controller
self.en_ctrl = EnergyCtrl(ref_energy, energy_gain, acc_max)
# Set up the PD controller
cos_al_delta = np.cos(2. * np.pi - np.deg2rad(alpha_max_pd_enable))
self.pd_enabled = lambda cos_al: cos_al > cos_al_delta
pd_gain = pd_gain if pd_gain is not None else [-1.5, 25.0, -1.5, 2.5]
self.pd_ctrl = PDCtrl(K=pd_gain)
a = 10.0 b = 8.0 c = 6.0 # set Euler angles relating BCF frame to PA frame (3-1-3) # Note on comparisons with STK: # The Body_Axes_Body_Fixed system was created as a "Fixed in Axes" type set of axes. # The reference axes is principal axis frame. # Theta1 corresponds to Euler Angle A # Theta2 corresponds to Euler Angle B # Theta3 corresponds to Euler Angle C # However, all the signs of the angles need to be reversed because the rotations are going the other direction. theta1_0 = -21.0 # deg theta2_0 = -9.0 # deg theta3_0 = -14.0 # deg theta1_0rad = np.deg2rad(theta1_0) # rad theta2_0rad = np.deg2rad(theta2_0) theta3_0rad = np.deg2rad(theta3_0) # assume the theta's can vary linearly in time with constant rates theta1dot_0 = 0.2 # deg/s theta2dot_0 = 0.1 # deg/s theta3dot_0 = 0.4 # deg/s #theta1dot_0 = 0. # deg/s #theta2dot_0 = 0. # deg/s #theta3dot_0 = 0. # deg/s theta1dot_0rad = np.deg2rad(theta1dot_0) # rad/s theta2dot_0rad = np.deg2rad(theta2dot_0) theta3dot_0rad = np.deg2rad(theta3dot_0) # calculate a point on that ellipsoid
elif number_of_points == 5:
import gdescent.hpoints_gradient5 as gd
elif number_of_points == 6:
import gdescent.hpoints_gradient6 as gd
## Define a Display plane with random initial points
pl = CircularPlane()
pl.random(n=number_of_points, r=0.01, min_sep=0.01)
## CREATE A SIMULATED CAMERA
cam = Camera()
cam.set_K(fx=800, fy=800, cx=640 / 2., cy=480 / 2.)
cam.set_width_heigth(640, 480)
## DEFINE CAMERA POSE LOOKING STRAIGTH DOWN INTO THE PLANE MODEL
cam.set_R_axisAngle(1.0, 0.0, 0.0, np.deg2rad(180.0))
cam.set_t(0.0, -0.0, 0.5, frame='world')
#cam.set_R_axisAngle(1.0, 0.0, 0.0, np.deg2rad(140.0))
#cam.set_t(0.0,-1,1.0, frame='world')
#
r = 0.8
angle = 30
x = r * np.cos(np.deg2rad(angle))
z = r * np.sin(np.deg2rad(angle))
cam.set_t(0, x, z)
cam.set_R_mat(R_matrix_from_euler_t(0.0, 0, 0))
cam.look_at([0, 0, 0])
#cam.set_R_axisAngle(1.0, 0.0, 0.0, np.deg2rad(110.0))
#cam.set_t(0.0,-0.3,0.1, frame='world')
elif number_of_points == 6:
import gdescent.hpoints_gradient6 as gd
## Define a Display plane with random initial points
pl = CircularPlane()
pl.random(n=number_of_points, r=0.01, min_sep=0.01)
## CREATE A SIMULATED CAMERA
cam = Camera()
cam.set_K(fx=800, fy=800, cx=640 / 2., cy=480 / 2.)
cam.set_width_heigth(640, 480)
## DEFINE A SET OF CAMERA POSES IN DIFFERENT POSITIONS BUT ALWAYS LOOKING
# TO THE CENTER OF THE PLANE MODEL
cam.set_R_axisAngle(1.0, 0.0, 0.0, np.deg2rad(180.0))
cam.set_t(0.0, -0.0, 0.5, frame='world')
r = 0.8
angle = 90
x = r * np.cos(np.deg2rad(angle))
z = r * np.sin(np.deg2rad(angle))
cam.set_t(0, x, z)
cam.set_R_mat(R_matrix_from_euler_t(0.0, 0, 0))
cam.look_at([0, 0, 0])
max_deviation = 0.06
deviation_range = np.arange(0, max_deviation + 0.01, 0.01)
#Now we define a distribution of cameras on the space based on this plane
#An optional paremeter is de possible deviation from uniform points
def test_deg2rad():
fun = lambda x: 3.0 * np.deg2rad(x)
check_grads(fun)(10.0 * npr.rand())
def test_deg2rad():
fun = lambda x : 3.0 * np.deg2rad(x)
check_grads(fun)(10.0*npr.rand())
def svm_fn(*args):#kappa,amplitude):
# wrapper function, using fixed uangle in degrees
return sym_von_mises_function(np.deg2rad(uangle),*args)#kappa,amplitude)
break
c = ax.imshow(imgr[i, :].reshape(npx, npy).T, origin='lower')
div = make_axes_locatable(ax)
cax = div.append_axes("right", size="10%", pad=0.05)
cbar = pl.colorbar(c, cax=cax)
ax.set_title(parn[i])
return fig
if __name__ == "__main__":
rh = 3 # half-light radius
rho = 0.5 # minor/major axis ratio
a = rh / np.sqrt(rho) # semi-major axis
b = rh * np.sqrt(rho) # semi-minor axis
theta = np.deg2rad(30) # position angle (CCW from positive x-axis)
x0 = 0.5 # center x
y0 = -0.5 # center y
ptrue = np.array([rho, theta, x0, y0])
# --- Set up the galaxy and pixels -----
minrad, maxrad, dlnr = 0.20, 28.0, np.log(2)
lnradii = np.arange(np.log(minrad), np.log(maxrad), dlnr)
lnradii = np.insert(lnradii, 0, -np.inf)
radii = np.exp(lnradii)
# n=4, r_h = 3.0
amplitudes = [3.01569009, 7.003088 , 15.02690983, 24.50030708,
38.70292664, 42.86139297, 38.57839966, 21.7422924,
10.47532463]
amplitudes = np.array(amplitudes)
number_of_points = 4
if number_of_points == 4:
import gdescent.hpoints_gradient as gd
elif number_of_points == 5:
import gdescent.hpoints_gradient5 as gd
elif number_of_points == 6:
import gdescent.hpoints_gradient6 as gd
## CREATE A SIMULATED CAMERA
cam = Camera()
cam.set_K(fx=800, fy=800, cx=640, cy=480)
cam.set_width_heigth(960, 960)
## DEFINE CAMERA POSE LOOKING STRAIGTH DOWN INTO THE PLANE MODEL
cam.set_R_axisAngle(1.0, 0.0, 0.0, np.deg2rad(180.0))
cam.set_t(0.0, -0.0, 0.5, frame='world')
#cam.set_R_axisAngle(1.0, 0.0, 0.0, np.deg2rad(140.0))
#cam.set_t(0.0,-1,1.0, frame='world')
#
#r = 0.5
#angle = 10
#x = r*np.cos(np.deg2rad(angle))
#z = r*np.sin(np.deg2rad(angle))
#cam.set_t(0, x,z)
#cam.set_R_mat(R_matrix_from_euler_t(0.0,0,0))
#cam.look_at([0,0,0])
#cam.set_R_axisAngle(1.0, 0.0, 0.0, np.deg2rad(110.0))
#cam.set_t(0.0,-0.3,0.1, frame='world')
for i, img in enumerate(imgs[:2]):
kp, d = sift.detectAndCompute(img, None)
descs.append(d)
keypoints.append(kp)
matches = bfmatcher.knnMatch(descs[0], descs[1], k=10)
x_ = []
y_ = []
for i, dd in enumerate(descs):
kps = keypoints[i]
h, w, c = imgs[i].shape
d_ = [d / np.linalg.norm(d) for d in dd[:N_points]]
dkp_ = [
list(d_[i]) + [(k.pt[0] - w / 2) / w, (k.pt[1] - h / 2) / h,
np.log(k.size),
np.deg2rad(k.angle)]
for i, k in enumerate(kps[:N_points])
]
x_.append([k.pt[0] for k in kps[:N_points]])
y_.append([k.pt[1] for k in kps[:N_points]])
print([len(d) for d in dl])
if plot > 3:
myplot = []
for i in range(len(x_)):
for j in range(len(x_[0])):
x0, y0 = int(x_[0][j]), int(y_[0][j])
x, y, _ = tuple(h_apply(H[0, i], (x0, y0, 1)))
s = keypoints[0][j].size
octave, layer, scale = unpackSIFTOctave(keypoints[0][j].octave)
theta = keypoints[0][j].angle
def test_deg2rad():
fun = lambda x : 3.0 * np.deg2rad(x)
d_fun = grad(fun)
check_grads(fun, 10.0*npr.rand())
check_grads(d_fun, 10.0*npr.rand())
def test_deg2rad():
fun = lambda x : 3.0 * np.deg2rad(x)
d_fun = grad(fun)
check_grads(fun, 10.0*npr.rand())
check_grads(d_fun, 10.0*npr.rand())
if number_of_points == 4:
import gdescent.hpoints_gradient as gd
elif number_of_points == 5:
import gdescent.hpoints_gradient5 as gd
elif number_of_points == 6:
import gdescent.hpoints_gradient6 as gd
## Define a Display plane
pl = CircularPlane()
pl.random(n=number_of_points, r=0.010, min_sep=0.001)
objectPoints_start = pl.get_points()
############################################################################
#Always the same starting points
#4 points: An ideal square
x1 = 0.15 * np.cos(np.deg2rad(45))
y1 = 0.15 * np.sin(np.deg2rad(45))
objectPoints_start = np.array([[x1, -x1, -x1, x1], [y1, y1, -y1, -y1],
[
0.,
0.,
0.,
0.,
], [
1.,
1.,
1.,
1.,
]])
##5 Points: a square and one point in the middle.
