def func(pos, idx, verts):
cen1 = pos[from_seg][:, 3]
cen2 = pos[to_seg][:, 3]
ax1 = pos[from_seg][:, 2]
ax2 = pos[to_seg][:, 2]
if nondistinct_axes:
cen1 = cen1[:3]
cen2 = cen2[:3]
ax1 = ax1[:3]
ax2 = ax2[:3]
p, q = numba_line_line_closest_points_pa(cen1, ax1, cen2, ax2)
dist = np.sqrt(np.sum((p - q)**2))
cen = (p + q) / 2
ax1c = numba_normalized(cen1 - cen)
ax2c = numba_normalized(cen2 - cen)
if np.sum(ax1 * ax1c) < 0:
ax1 = -ax1
if np.sum(ax2 * ax2c) < 0:
ax2 = -ax2
ang = np.arccos(np.sum(ax1 * ax2))
else:
dist = hm.numba_line_line_distance_pa(cen1, ax1, cen2, ax2)
ang = np.arccos(np.abs(hm.numba_dot(ax1, ax2)))
roterr2 = (ang - tgtangle)**2
return np.sqrt(roterr2 / rot_tol**2 + (dist / tolerance)**2)
def lossfunc_Dx_Cx(pos, idx, vrts):
ax = pos[to_seg, :3, 2]
cn = pos[to_seg, :3, 3]
mn = 9e9
for i in range(d_2folds.shape[0]):
d = hm.numba_line_line_distance_pa(cn, ax, origin, d_2folds[i])
mn = min(d, mn)
carterr2 = mn**2 # close to intersecting d_2fold
angerr2 = (np.arccos(abs(ax[2])) * lever)**2 # C symaxis on z
return np.sqrt(carterr2 + angerr2)
def lossfunc_D2_C2_Z(pos, idx, vrts):
ax = pos[to_seg, :3, 2]
cn = pos[to_seg, :3, 3]
mn = 9e9
for i in range(d_2folds.shape[0]):
d = hm.numba_line_line_distance_pa(cn, ax, origin, d_2diag[i])
dot = abs(np.sum(d_2folds[i] * ax))
angerr2 = (np.arccos(dot) * lever)**2
mn = min(mn, np.sqrt(d**2 + angerr2))
return mn
def lossfunc_Dx_Cx(pos, idx, vrts):
ax = pos[to_seg, :3, 2]
cn = pos[to_seg, :3, 3]
mn = 9e9
for i in range(len(c_tgt_axis_isect)):
c_axis_isects = c_tgt_axis_isect[i, 0]
c_tgt_axis = c_tgt_axis_isect[i, 1]
d = hm.numba_line_line_distance_pa(cn, ax, origin,
c_axis_isects)
a = np.arccos(abs(np.sum(c_tgt_axis * ax)))
mn = min(mn, np.sqrt(d**2 + (a * lever)**2))
return mn
def alignment(self, segpos, out_cell_spacing=False, **kw):
ax = segpos[self.to_seg, :3, 2]
cn = segpos[self.to_seg, :3, 3]
origin = np.array([0, 0, 0])
if self.d_nfold > 2 and self.c_nfold > 2:
mn, mni = 9e9, None
for i, _ in enumerate(self.c_tgt_axis_isect):
c_axis_isects, c_tgt_axis = _
d = hm.numba_line_line_distance_pa(cn, ax, origin,
c_axis_isects)
a = np.arccos(abs(np.sum(c_tgt_axis * ax)))
err = np.sqrt(d**2 + (a * self.lever)**2)
if err < mn:
mn = err
mni = i
c_axis_isects, c_tgt_axis = self.c_tgt_axis_isect[mni]
p, q = hm.line_line_closest_points_pa(cn, ax, origin,
c_axis_isects)
cell_spacing = np.linalg.norm(p + q) / np.sqrt(2) # 2x from p+q
xalign = np.eye(4)
if np.sum(c_axis_isects * q) > 0:
xalign = hm.hrot(hm.hcross(c_axis_isects, c_tgt_axis),
180) @ xalign
xalign = self.aligners[mni] @ xalign
xalign[:3, 3] = self.to_origin * cell_spacing
d = np.linalg.norm(p - q)
a = np.arccos(abs(np.sum(c_tgt_axis * ax)))
carterr2 = d**2
angerr2 = (a * self.lever)**2
if np.sum(c_axis_isects * q) > 0:
print()
print("alignment", d, a * self.lever, self.lever)
print("ax", ax, xalign[:3, :3] @ ax)
print("cn", cn, xalign @ [cn[0], cn[1], cn[2], 1])
print("isect", p)
print("isect", q)
print("cell_spacing", cell_spacing)
print("xalign", hm.axis_angle_of(xalign))
print(xalign)
else:
raise NotImplementedError
if out_cell_spacing:
return xalign, cell_spacing
else:
return xalign
def lossfunc_D2_Cx(pos, idx, vrts):
ax = pos[to_seg, :3, 2]
cn = pos[to_seg, :3, 3]
mn, mni = 9e9, -1
mxdot, mxdoti = 0, -1
for i in range(d_2folds.shape[0]):
d = hm.numba_line_line_distance_pa(cn, ax, origin, d_2folds[i])
if d < mn:
mn, mni = d, i
dot = abs(np.sum(d_2folds[i] * ax))
if dot > mxdot:
mxdot, mxdoti = dot, i
if mxdoti == mni:
# intersect same axis as parallel to, bad
return 9e9
carterr2 = mn**2
angerr2 = (np.arccos(mxdot) * lever)**2
return np.sqrt(carterr2 + angerr2)
def lossfunc_Dx_C2(pos, idx, vrts):
ax = pos[to_seg, :3, 2]
cn = pos[to_seg, :3, 3]
if abs(ax[2]) > 0.5:
# case: c2 on z
mn = 9e9
for i in range(d_2folds.shape[0]):
d = hm.numba_line_line_distance_pa(cn, ax, origin,
d_2folds[i])
mn = min(d, mn)
carterr2 = mn**2
angerr2 = (np.arccos(abs(ax[2])) * lever)**2
return np.sqrt(carterr2 + angerr2)
else:
# case: C2 in plane of sym and perp to one of d_2folds axis
dot = 9e9
for i in range(d_2folds.shape[0]):
dot = min(dot, abs(np.sum(d_2folds[i] * ax)))
angerr2_a = (np.arcsin(dot) * lever)**2 # perp to d_2fold
angerr2_b = (np.arcsin(ax[2]) * lever)**2 # axis in plane
carterr2 = cn[2]**2 # center in plane
return np.sqrt(angerr2_a + angerr2_b + carterr2)