def get_invVR_aff2Ds(kpts, H=None):
"""
Returns matplotlib keypoint transformations (circle -> ellipse)
Example:
>>> # Test CV2 ellipse vs mine using MSER
>>> import vtool as vt
>>> import cv2
>>> import wbia.plottool as pt
>>> img_fpath = ut.grab_test_imgpath(ut.get_argval('--fname', default='zebra.png'))
>>> imgBGR = vt.imread(img_fpath)
>>> imgGray = cv2.cvtColor(imgBGR, cv2.COLOR_BGR2GRAY)
>>> mser = cv2.MSER_create()
>>> regions, bboxs = mser.detectRegions(imgGray)
>>> region = regions[0]
>>> bbox = bboxs[0]
>>> vis = imgBGR.copy()
>>> vis[region.T[1], region.T[0], :] = 0
>>> hull = cv2.convexHull(region.reshape(-1, 1, 2))
>>> cv2.polylines(vis, [hull], 1, (0, 255, 0))
>>> ell = cv2.fitEllipse(region)
>>> cv2.ellipse(vis, ell, (255))
>>> ((cx, cy), (rx, ry), degrees) = ell
>>> # Convert diameter to radians
>>> rx /= 2
>>> ry /= 2
>>> # Make my version of ell
>>> theta = np.radians(degrees) # opencv lives in radians
>>> S = vt.scale_mat3x3(rx, ry)
>>> T = vt.translation_mat3x3(cx, cy)
>>> R = vt.rotation_mat3x3(theta)
>>> #R = np.eye(3)
>>> invVR = T.dot(R).dot(S)
>>> kpts = vt.flatten_invV_mats_to_kpts(np.array([invVR]))
>>> pt.imshow(vis)
>>> # MINE IS MUCH LARGER (by factor of 2)) WHY?
>>> # we start out with a unit circle not a half circle
>>> pt.draw_keypoints(pt.gca(), kpts, pts=True, ori=True, eig=True, rect=True)
"""
import vtool.keypoint as ktool
# invVR_mats = ktool.get_invV_mats(kpts, with_trans=True, with_ori=True)
invVR_mats = ktool.get_invVR_mats3x3(kpts)
if H is None:
invVR_aff2Ds = [mpl.transforms.Affine2D(invVR) for invVR in invVR_mats]
else:
invVR_aff2Ds = [
HomographyTransform(H.dot(invVR)) for invVR in invVR_mats
]
return invVR_aff2Ds
def test_affine_errors(H, kpts1, kpts2, fm, xy_thresh_sqrd, scale_thresh_sqrd,
ori_thresh):
"""
used for refinement as opposed to initial estimation
"""
kpts1_m = kpts1.take(fm.T[0], axis=0)
kpts2_m = kpts2.take(fm.T[1], axis=0)
invVR1s_m = ktool.get_invVR_mats3x3(kpts1_m)
xy2_m = ktool.get_xys(kpts2_m)
det2_m = ktool.get_sqrd_scales(kpts2_m)
ori2_m = ktool.get_oris(kpts2_m)
refined_inliers, refined_errors = _test_hypothesis_inliers(
H, invVR1s_m, xy2_m, det2_m, ori2_m, xy_thresh_sqrd, scale_thresh_sqrd,
ori_thresh)
refined_tup1 = (refined_inliers, refined_errors, H)
return refined_tup1
def test_affine_errors(H, kpts1, kpts2, fm, xy_thresh_sqrd, scale_thresh_sqrd,
ori_thresh):
"""
used for refinement as opposed to initial estimation
"""
kpts1_m = kpts1.take(fm.T[0], axis=0)
kpts2_m = kpts2.take(fm.T[1], axis=0)
invVR1s_m = ktool.get_invVR_mats3x3(kpts1_m)
xy2_m = ktool.get_xys(kpts2_m)
det2_m = ktool.get_sqrd_scales(kpts2_m)
ori2_m = ktool.get_oris(kpts2_m)
refined_inliers, refined_errors = _test_hypothesis_inliers(
H, invVR1s_m, xy2_m, det2_m, ori2_m, xy_thresh_sqrd, scale_thresh_sqrd,
ori_thresh)
refined_tup1 = (refined_inliers, refined_errors, H)
return refined_tup1
def get_invVR_aff2Ds(kpts, H=None):
"""
Returns matplotlib keypoint transformations (circle -> ellipse)
Example:
>>> # Test CV2 ellipse vs mine using MSER
>>> import plottool as pt
>>> pt.qt4ensure()
>>> img_fpath = ut.grab_test_imgpath(ut.get_argval('--fname', default='zebra.png'))
>>> imgBGR = vt.imread(img_fpath)
>>> imgGray = cv2.cvtColor(imgBGR, cv2.COLOR_BGR2GRAY)
>>> mser = cv2.MSER_create()
>>> regions, bboxs = mser.detectRegions(imgGray)
>>> region = regions[0]
>>> bbox = bboxes[0]
>>> vis = imgBGR.copy()
>>> vis[region.T[1], region.T[0], :] = 0
>>> hull = cv2.convexHull(region.reshape(-1, 1, 2))
>>> cv2.polylines(vis, [hull], 1, (0, 255, 0))
>>> ell = cv2.fitEllipse(region)
>>> cv2.ellipse(vis, ell, (255))
>>> ((cx, cy), (rx, ry), degrees) = ell
>>> # Convert diameter to radians
>>> rx /= 2
>>> ry /= 2
>>> # Make my version of ell
>>> theta = np.radians(degrees) # opencv lives in radians
>>> S = vt.scale_mat3x3(rx, ry)
>>> T = vt.translation_mat3x3(cx, cy)
>>> R = vt.rotation_mat3x3(theta)
>>> #R = np.eye(3)
>>> invVR = T.dot(R).dot(S)
>>> kpts = vt.flatten_invV_mats_to_kpts(np.array([invVR]))
>>> pt.imshow(vis)
>>> # MINE IS MUCH LARGER (by factor of 2)) WHY?
>>> # we start out with a unit circle not a half circle
>>> pt.draw_keypoints(pt.gca(), kpts, pts=True, ori=True, eig=True, rect=True)
"""
#invVR_mats = ktool.get_invV_mats(kpts, with_trans=True, with_ori=True)
invVR_mats = ktool.get_invVR_mats3x3(kpts)
if H is None:
invVR_aff2Ds = [mpl.transforms.Affine2D(invVR)
for invVR in invVR_mats]
else:
invVR_aff2Ds = [HomographyTransform(H.dot(invVR))
for invVR in invVR_mats]
return invVR_aff2Ds
def get_affine_inliers(kpts1, kpts2, fm, fs, xy_thresh_sqrd, scale_thresh_sqrd,
ori_thresh):
"""
Estimates inliers deterministically using elliptical shapes
Compute all transforms from kpts1 to kpts2 (enumerate all hypothesis)
We transform from chip1 -> chip2
The determinants are squared keypoint scales
FROM PERDOCH 2009::
H = inv(Aj).dot(Rj.T).dot(Ri).dot(Ai)
H = inv(Aj).dot(Ai)
The input invVs = perdoch.invA's
CommandLine:
python -m vtool.spatial_verification --test-get_affine_inliers
Example:
>>> # ENABLE_DOCTEST
>>> from vtool.spatial_verification import * # NOQA
>>> import vtool.tests.dummy as dummy
>>> import vtool.keypoint as ktool
>>> kpts1, kpts2 = dummy.get_dummy_kpts_pair((100, 100))
>>> fm = dummy.make_dummy_fm(len(kpts1)).astype(np.int32)
>>> fs = np.ones(len(fm), dtype=np.float64)
>>> xy_thresh_sqrd = ktool.KPTS_DTYPE(.009) ** 2
>>> scale_thresh_sqrd = ktool.KPTS_DTYPE(2)
>>> ori_thresh = ktool.KPTS_DTYPE(TAU / 4)
>>> output = get_affine_inliers(kpts1, kpts2, fm, fs, xy_thresh_sqrd,
>>> scale_thresh_sqrd, ori_thresh)
>>> result = ut.hashstr(output)
>>> print(result)
89kz8nh6p+66t!+u
Ignore::
from vtool.spatial_verification import * # NOQA
import vtool.tests.dummy as dummy
import vtool.keypoint as ktool
kpts1, kpts2 = dummy.get_dummy_kpts_pair((100, 100))
a = kpts1[fm.T[0]]
b = kpts1.take(fm.T[0])
align = fm.dtype.itemsize * fm.shape[1]
align2 = [fm.dtype.itemsize, fm.dtype.itemsize]
viewtype1 = np.dtype(np.void, align)
viewtype2 = np.dtype(np.int32, align2)
c = np.ascontiguousarray(fm).view(viewtype1)
fm_view = np.ascontiguousarray(fm).view(viewtype1)
qfx = fm.view(np.dtype(np.int32 np.int32.itemsize))
dfx = fm.view(np.dtype(np.int32, np.int32.itemsize))
d = np.ascontiguousarray(c).view(viewtype2)
fm.view(np.dtype(np.void, align))
np.ascontiguousarray(fm).view(np.dtype((np.void, Z.dtype.itemsize * Z.shape[1])))
"""
#http://ipython-books.github.io/featured-01/
kpts1_m = kpts1.take(fm.T[0], axis=0)
kpts2_m = kpts2.take(fm.T[1], axis=0)
# Get keypoints to project in matrix form
#invVR2s_m = ktool.get_invV_mats(kpts2_m, with_trans=True, with_ori=True)
#invVR1s_m = ktool.get_invV_mats(kpts1_m, with_trans=True, with_ori=True)
invVR2s_m = ktool.get_invVR_mats3x3(kpts2_m)
invVR1s_m = ktool.get_invVR_mats3x3(kpts1_m)
RV1s_m = ktool.invert_invV_mats(invVR1s_m) # 539 us
# BUILD ALL HYPOTHESIS TRANSFORMS: The transform from kp1 to kp2 is:
Aff_mats = matrix_multiply(invVR2s_m, RV1s_m)
# Get components to test projects against
xy2_m = ktool.get_xys(kpts2_m)
det2_m = ktool.get_sqrd_scales(kpts2_m)
ori2_m = ktool.get_oris(kpts2_m)
# SLOWER EQUIVALENT
# RV1s_m = ktool.get_V_mats(kpts1_m, with_trans=True, with_ori=True) # 5.2 ms
# xy2_m = ktool.get_invVR_mats_xys(invVR2s_m)
# ori2_m = ktool.get_invVR_mats_oris(invVR2s_m)
# assert np.all(ktool.get_oris(kpts2_m) == ktool.get_invVR_mats_oris(invVR2s_m))
# assert np.all(ktool.get_xys(kpts2_m) == ktool.get_invVR_mats_xys(invVR2s_m))
# The previous versions of this function were all roughly comparable.
# The for loop one was the slowest. I'm deciding to go with the one
# where there is no internal function definition. It was moderately faster,
# and it gives us access to profile that function
inliers_and_errors_list = [
_test_hypothesis_inliers(Aff, invVR1s_m, xy2_m, det2_m, ori2_m,
xy_thresh_sqrd, scale_thresh_sqrd, ori_thresh)
for Aff in Aff_mats
]
aff_inliers_list = [tup[0] for tup in inliers_and_errors_list]
aff_errors_list = [tup[1] for tup in inliers_and_errors_list]
return aff_inliers_list, aff_errors_list, Aff_mats
def get_affine_inliers(kpts1, kpts2, fm, fs,
xy_thresh_sqrd,
scale_thresh_sqrd,
ori_thresh):
"""
Estimates inliers deterministically using elliptical shapes
Compute all transforms from kpts1 to kpts2 (enumerate all hypothesis)
We transform from chip1 -> chip2
The determinants are squared keypoint scales
FROM PERDOCH 2009::
H = inv(Aj).dot(Rj.T).dot(Ri).dot(Ai)
H = inv(Aj).dot(Ai)
The input invVs = perdoch.invA's
CommandLine:
python -m vtool.spatial_verification --test-get_affine_inliers
Example:
>>> # ENABLE_DOCTEST
>>> from vtool.spatial_verification import * # NOQA
>>> import vtool.tests.dummy as dummy
>>> import vtool.keypoint as ktool
>>> kpts1, kpts2 = dummy.get_dummy_kpts_pair((100, 100))
>>> fm = dummy.make_dummy_fm(len(kpts1)).astype(np.int32)
>>> fs = np.ones(len(fm), dtype=np.float64)
>>> xy_thresh_sqrd = ktool.KPTS_DTYPE(.009) ** 2
>>> scale_thresh_sqrd = ktool.KPTS_DTYPE(2)
>>> ori_thresh = ktool.KPTS_DTYPE(TAU / 4)
>>> output = get_affine_inliers(kpts1, kpts2, fm, fs, xy_thresh_sqrd,
>>> scale_thresh_sqrd, ori_thresh)
>>> result = ut.hashstr(output)
>>> print(result)
89kz8nh6p+66t!+u
Ignore::
from vtool.spatial_verification import * # NOQA
import vtool.tests.dummy as dummy
import vtool.keypoint as ktool
kpts1, kpts2 = dummy.get_dummy_kpts_pair((100, 100))
a = kpts1[fm.T[0]]
b = kpts1.take(fm.T[0])
align = fm.dtype.itemsize * fm.shape[1]
align2 = [fm.dtype.itemsize, fm.dtype.itemsize]
viewtype1 = np.dtype(np.void, align)
viewtype2 = np.dtype(np.int32, align2)
c = np.ascontiguousarray(fm).view(viewtype1)
fm_view = np.ascontiguousarray(fm).view(viewtype1)
qfx = fm.view(np.dtype(np.int32 np.int32.itemsize))
dfx = fm.view(np.dtype(np.int32, np.int32.itemsize))
d = np.ascontiguousarray(c).view(viewtype2)
fm.view(np.dtype(np.void, align))
np.ascontiguousarray(fm).view(np.dtype((np.void, Z.dtype.itemsize * Z.shape[1])))
"""
#http://ipython-books.github.io/featured-01/
kpts1_m = kpts1.take(fm.T[0], axis=0)
kpts2_m = kpts2.take(fm.T[1], axis=0)
# Get keypoints to project in matrix form
#invVR2s_m = ktool.get_invV_mats(kpts2_m, with_trans=True, with_ori=True)
#invVR1s_m = ktool.get_invV_mats(kpts1_m, with_trans=True, with_ori=True)
invVR2s_m = ktool.get_invVR_mats3x3(kpts2_m)
invVR1s_m = ktool.get_invVR_mats3x3(kpts1_m)
RV1s_m = ktool.invert_invV_mats(invVR1s_m) # 539 us
# BUILD ALL HYPOTHESIS TRANSFORMS: The transform from kp1 to kp2 is:
Aff_mats = matrix_multiply(invVR2s_m, RV1s_m)
# Get components to test projects against
xy2_m = ktool.get_xys(kpts2_m)
det2_m = ktool.get_sqrd_scales(kpts2_m)
ori2_m = ktool.get_oris(kpts2_m)
# SLOWER EQUIVALENT
# RV1s_m = ktool.get_V_mats(kpts1_m, with_trans=True, with_ori=True) # 5.2 ms
# xy2_m = ktool.get_invVR_mats_xys(invVR2s_m)
# ori2_m = ktool.get_invVR_mats_oris(invVR2s_m)
# assert np.all(ktool.get_oris(kpts2_m) == ktool.get_invVR_mats_oris(invVR2s_m))
# assert np.all(ktool.get_xys(kpts2_m) == ktool.get_invVR_mats_xys(invVR2s_m))
# The previous versions of this function were all roughly comparable.
# The for loop one was the slowest. I'm deciding to go with the one
# where there is no internal function definition. It was moderately faster,
# and it gives us access to profile that function
inliers_and_errors_list = [_test_hypothesis_inliers(Aff, invVR1s_m, xy2_m,
det2_m, ori2_m,
xy_thresh_sqrd,
scale_thresh_sqrd,
ori_thresh)
for Aff in Aff_mats]
aff_inliers_list = [tup[0] for tup in inliers_and_errors_list]
aff_errors_list = [tup[1] for tup in inliers_and_errors_list]
return aff_inliers_list, aff_errors_list, Aff_mats
