def test_point_map(self):
h_f = Homography('f')
h_d = Homography('d')
p_af = EigenArray.from_array([[2.2, 3.3]], 'f')
p_f = p_af.get_matrix()[0]
p_ad = EigenArray.from_array([[5.5, 6.6]], 'd')
p_d = p_ad.get_matrix()[0]
# float-float
numpy.testing.assert_almost_equal(
h_f.map(p_f), p_f
)
# float-double
numpy.testing.assert_almost_equal(
h_f.map(p_d), p_d
)
# double-float
numpy.testing.assert_almost_equal(
h_d.map(p_f), p_f
)
# double-double
numpy.testing.assert_almost_equal(
h_d.map(p_d), p_d
)
# Code to generate truth
h = numpy.random.rand(3,3)
h = h/numpy.linalg.norm(h)
p0 = numpy.random.rand(3); p0[2] = 1
p1 = numpy.dot(h, p0)
p1 = p1[:2]/p1[2]
h_d = Homography.from_matrix(h, 'd')
# map from Numpy array.
numpy.testing.assert_almost_equal(
h_d.map(p0[:2]).ravel(), p1
)
# map from EigenArray
p0 = EigenArray.from_array([p0[:2]])
numpy.testing.assert_almost_equal(
h_d.map(p0.get_matrix()[0]).ravel(), p1
)
# Another explicit case.
p0 = numpy.array([1923.47,645.676,1])
h = numpy.array([[5.491496261770000276e-01,-1.125428185150000038e-01,
1.358427031619999923e+02],
[-1.429513389049999993e-02 ,6.035527375529999849e-01,
5.923971959490000216e+01],
[-2.042570000000000164e-06,-2.871670000000000197e-07,
1]])
p1 = numpy.dot(h, p0); p1 = p1[:2]/p1[2]
H = Homography.from_matrix(h)
P = EigenArray.from_array([p0[:2]])
numpy.testing.assert_almost_equal(
H.map(P.get_matrix()[0]).ravel(), p1
)
def test_normalize(self):
h = Homography.from_matrix([[-.5, -2.5, 1.5],
[-1.5, 1.5, -.5],
[1.5, .5, -.5]])
e = Homography.from_matrix([[1, 5, -3],
[3, -3, 1],
[-3, -1, 1]])
numpy.testing.assert_array_equal(h.normalize(), e.as_matrix())
def test_equal(self):
# Identity should be equal to itself
h1 = Homography()
h2 = Homography()
nose.tools.assert_equal(h1, h2)
# manually constructed homographies should be equal
m = [[.1, .2, .3],
[.4, .5, .6],
[.7, .8, .9]]
h1 = Homography.from_matrix(m)
h2 = Homography.from_matrix(m)
nose.tools.assert_equal(h1, h2)
# and should also be different than identity
nose.tools.assert_not_equal(h1, Homography())
nose.tools.assert_not_equal(h2, Homography())
def test_numeric_invertibility(self):
exp_result = Homography.from_matrix([[-.5, -2.5, 1.5],
[-1.5, 1.5, -.5],
[1.5, .5, -.5]])
h = Homography.from_matrix([[1, 1, 2],
[3, 4, 5],
[6, 7, 9]])
h_inv = h.inverse()
numpy.testing.assert_array_equal(h_inv, exp_result.as_matrix())
h = Homography.from_matrix([[1, 1, 2],
[3, 4, 5],
[6, 7, 9]],
'f')
h_inv = h.inverse()
numpy.testing.assert_array_equal(h_inv, exp_result.as_matrix())
def test_clone(self):
m = [[.1, .2, .3],
[.4, .5, .6],
[.7, .8, .9]]
# Cloning a matrix should yield a new instance that has the same value
# as the original
h1 = Homography.from_matrix(m, ctypes.c_double)
h2 = h1.clone()
nose.tools.assert_false(h1 is h2)
nose.tools.assert_not_equal(ctypes.addressof(h1.c_pointer.contents),
ctypes.addressof(h2.c_pointer.contents))
numpy.testing.assert_almost_equal(h1.as_matrix(), h2.as_matrix())
# Cloning should carry over data type
nose.tools.assert_equal(h1.type_name, h2.type_name)
h3 = Homography.from_matrix(m, ctypes.c_float)
h4 = h3.clone()
nose.tools.assert_equal(h3.type_name, h4.type_name)
def test_multiply(self):
# Test multiplying homographies together
h_ident = Homography()
h_valued = Homography.from_matrix([[1, 0, 1], [0, 1, 1], [0, 0, .5]])
r1 = h_ident * h_ident
nose.tools.assert_equal(h_ident, r1)
r2 = h_ident * h_valued
nose.tools.assert_equal(r2, h_valued)
r3 = h_valued * h_ident
nose.tools.assert_equal(r3, h_valued)
# Failure, multiplying against non-homography
def h_mult(h, v):
return h * v
nose.tools.assert_raises(ValueError, h_mult, h_ident, 1)
nose.tools.assert_raises(TypeError, h_mult, h_ident, 'a string')
def test_point_map(self):
h_f = Homography(ctypes.c_float)
h_d = Homography(ctypes.c_double)
p_f = EigenArray.from_iterable([2.2, 3.3], ctypes.c_float)
p_d = EigenArray.from_iterable([5.5, 6.6], ctypes.c_double)
# float-float
numpy.testing.assert_almost_equal(h_f.map(p_f), p_f)
# float-double
numpy.testing.assert_almost_equal(h_f.map(p_d), p_d)
# double-float
numpy.testing.assert_almost_equal(h_d.map(p_f), p_f)
# double-double
numpy.testing.assert_almost_equal(h_d.map(p_d), p_d)
def test_point_map_zero_div(self):
test_p = [1, 1]
for dtype, e in [['f', numpy.finfo('f').min],
['d', sys.float_info.min]]:
print("Dtype:", dtype)
print("E:", e)
# where [2,2] = 0
h = Homography.from_matrix([[1, 0, 1],
[0, 1, 1],
[0, 0, 0]],
dtype)
nose.tools.assert_raises(
RuntimeError,
h.map, test_p
)
# Where [2,2] = e which is approximately 0
e = sys.float_info.min
h = Homography.from_matrix([[1, 0, 1],
[0, 1, 1],
[0, 0, e]],
dtype)
print("E Matrix:", h.as_matrix())
nose.tools.assert_raises(
RuntimeError,
h.map, test_p
)
# Where [2,2] = 0.5, which should be valid
h = Homography.from_matrix([[1, 0, 1],
[0, 1, 1],
[0, 0, .5]],
dtype)
r = h.map(test_p)
nose.tools.assert_almost_equal(r[0], 4)
nose.tools.assert_almost_equal(r[1], 4)
def test_point_map_zero_div(self):
test_p = [1, 1]
for dtype, e in [[ctypes.c_float, numpy.finfo(ctypes.c_float).min],
[ctypes.c_double, sys.float_info.min]]:
print "Dtype:", dtype
print "E:", e
# where [2,2] = 0
h = Homography.from_matrix([[1, 0, 1],
[0, 1, 1],
[0, 0, 0]],
dtype)
nose.tools.assert_raises(
PointMapsToInfinityException,
h.map, test_p
)
# Where [2,2] = e which is approximately 0
e = sys.float_info.min
h = Homography.from_matrix([[1, 0, 1],
[0, 1, 1],
[0, 0, e]],
dtype)
print "E Matrix:", h.as_matrix()
nose.tools.assert_raises(
PointMapsToInfinityException,
h.map, test_p
)
# Where [2,2] = 0.5, which should be valid
h = Homography.from_matrix([[1, 0, 1],
[0, 1, 1],
[0, 0, .5]],
dtype)
r = h.map(test_p)
nose.tools.assert_almost_equal(r[0], 4)
nose.tools.assert_almost_equal(r[1], 4)
def test_read_from_file(self):
# Use a random string filename to avoid name collision.
fname = 'temp_homography_test_read_from_file.txt'
# Reference homography
h = Homography.from_matrix([[1, 0, 1], [0, 12.01321561, 1], [0, 0,
.5]])
try:
h.write_to_file(fname)
# Try reading with the string filename.
h2 = Homography.read_from_file(fname)
assert h == h2
# Try reading from an open file.
with open(fname, 'r') as f:
h2 = Homography.read_from_file(f)
numpy.testing.assert_almost_equal(h.as_matrix(), h2.as_matrix())
finally:
if os.path.isfile(fname):
os.remove(fname)
def test_as_matrix(self):
numpy.testing.assert_almost_equal(
Homography('d').as_matrix(),
[[1, 0, 0],
[0, 1, 0],
[0, 0, 1]]
)
numpy.testing.assert_almost_equal(
Homography('f').as_matrix(),
[[1, 0, 0],
[0, 1, 0],
[0, 0, 1]]
)
m = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
numpy.testing.assert_almost_equal(
Homography.from_matrix(m, 'd').as_matrix(),
m
)
numpy.testing.assert_almost_equal(
Homography.from_matrix(m, 'f').as_matrix(),
m
)
m = [[.1, .2, .3],
[.4, .5, .6],
[.7, .8, .9]]
numpy.testing.assert_almost_equal(
Homography.from_matrix(m, 'd').as_matrix(),
m
)
numpy.testing.assert_almost_equal(
Homography.from_matrix(m, 'f').as_matrix(),
m
)
def test_multiply(self):
# Test multiplying homographies together
h_ident = Homography()
h_valued = Homography.from_matrix([[1, 0, 1],
[0, 1, 1],
[0, 0, .5]])
r1 = h_ident * h_ident
nose.tools.assert_equal(h_ident, r1)
r2 = h_ident * h_valued
nose.tools.assert_equal(r2, h_valued)
r3 = h_valued * h_ident
nose.tools.assert_equal(r3, h_valued)
def test_write_to_file(self):
# Use a random string filename to avoid name collision.
fname = 'temp_homography_test_write_to_file.txt'
h = Homography.from_matrix([[1, 0, 1], [0, 12.01321561, 1], [0, 0,
.5]])
try:
# Try writing with the string filename.
h.write_to_file(fname)
# Try writing with an open file.
with open(fname, 'w') as f:
h.write_to_file(f)
finally:
if os.path.isfile(fname):
os.remove(fname)
def test_equal(self):
# Identity should be equal to itself
h1 = Homography()
h2 = Homography()
nose.tools.assert_equal(h1, h2)
# manually constructed homographies should be equal
m = [[.1, .2, .3], [.4, .5, .6], [.7, .8, .9]]
h1 = Homography.from_matrix(m)
h2 = Homography.from_matrix(m)
nose.tools.assert_equal(h1, h2)
# and should also be different than identity
nose.tools.assert_not_equal(h1, Homography())
nose.tools.assert_not_equal(h2, Homography())
def test_as_matrix(self):
numpy.testing.assert_almost_equal(
Homography('d').as_matrix(), [[1, 0, 0], [0, 1, 0], [0, 0, 1]])
numpy.testing.assert_almost_equal(
Homography('f').as_matrix(), [[1, 0, 0], [0, 1, 0], [0, 0, 1]])
m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
numpy.testing.assert_almost_equal(
Homography.from_matrix(m, 'd').as_matrix(), m)
numpy.testing.assert_almost_equal(
Homography.from_matrix(m, 'f').as_matrix(), m)
m = [[.1, .2, .3], [.4, .5, .6], [.7, .8, .9]]
numpy.testing.assert_almost_equal(
Homography.from_matrix(m, 'd').as_matrix(), m)
numpy.testing.assert_almost_equal(
Homography.from_matrix(m, 'f').as_matrix(), m)
def test_typename(self):
h_d = Homography(ctypes.c_double)
h_f = Homography(ctypes.c_float)
nose.tools.assert_equal(h_d.type_name, 'd')
nose.tools.assert_equal(h_f.type_name, 'f')
def random(self):
Homography.random(ctypes.c_double)
Homography.random(ctypes.c_float)
def test_matrix_init(self):
# Test that construction does not fail when passing valid matrices as
# initializer
m1 = [[0, 1, 3], [0.3, 0.1, 10], [-1, 8.1, 4.7]]
m2_d = EigenArray.from_iterable(m1, ctypes.c_double, (3, 3))
m2_f = EigenArray.from_iterable(m1, ctypes.c_float, (3, 3))
Homography.from_matrix(m1, ctypes.c_double)
Homography.from_matrix(m1, ctypes.c_float)
Homography.from_matrix(m2_d, ctypes.c_double)
Homography.from_matrix(m2_d, ctypes.c_float)
Homography.from_matrix(m2_f, ctypes.c_double)
Homography.from_matrix(m2_f, ctypes.c_float)
def test_ident_init(self):
h_d = Homography()
h_f = Homography(ctypes.c_float)
def test_normalize(self):
h = Homography.from_matrix([[-.5, -2.5, 1.5], [-1.5, 1.5, -.5],
[1.5, .5, -.5]])
e = Homography.from_matrix([[1, 5, -3], [3, -3, 1], [-3, -1, 1]])
numpy.testing.assert_array_equal(h.normalize(), e.as_matrix())
def test_ident_init(self):
h_d = Homography()
h_f = Homography('f')
def test_point_map(self):
h_f = Homography(ctypes.c_float)
h_d = Homography(ctypes.c_double)
p_f = EigenArray.from_iterable([2.2, 3.3], ctypes.c_float)
p_d = EigenArray.from_iterable([5.5, 6.6], ctypes.c_double)
# float-float
numpy.testing.assert_almost_equal(h_f.map(p_f), p_f)
# float-double
numpy.testing.assert_almost_equal(h_f.map(p_d), p_d)
# double-float
numpy.testing.assert_almost_equal(h_d.map(p_f), p_f)
# double-double
numpy.testing.assert_almost_equal(h_d.map(p_d), p_d)
# Code to generate truth
h = numpy.random.rand(3, 3)
h = h / numpy.linalg.norm(h)
p0 = numpy.random.rand(3)
p0[2] = 1
p1 = numpy.dot(h, p0)
p1 = p1[:2] / p1[2]
h_d = Homography.from_matrix(h, ctypes.c_double)
# map from Numpy array.
numpy.testing.assert_almost_equal(h_d.map(p0[:2]).ravel(), p1)
# map from EigenArray
p0 = EigenArray.from_iterable(p0[:2])
numpy.testing.assert_almost_equal(h_d.map(p0).ravel(), p1)
# Another explicit case.
p0 = numpy.array([1923.47, 645.676, 1])
h = numpy.array(
[[
5.491496261770000276e-01, -1.125428185150000038e-01,
1.358427031619999923e+02
],
[
-1.429513389049999993e-02, 6.035527375529999849e-01,
5.923971959490000216e+01
], [-2.042570000000000164e-06, -2.871670000000000197e-07, 1]])
p1 = numpy.dot(h, p0)
p1 = p1[:2] / p1[2]
H = Homography.from_matrix(h)
P = EigenArray.from_iterable(p0[:2])
numpy.testing.assert_almost_equal(H.map(P).ravel(), p1)
def test_normalize(self):
h = Homography.from_matrix([[-.5, -2.5, 1.5], [-1.5, 1.5, -.5],
[1.5, .5, -.5]])
e = Homography.from_matrix([[1, 5, -3], [3, -3, 1], [-3, -1, 1]])
nose.tools.assert_equal(h.normalize(), e)
def test_matrix_init(self):
# Test that construction does not fail when passing valid matrices as
# initializer
m1 = [[0, 1, 3], [0.3, 0.1, 10], [-1, 8.1, 4.7]]
m2_d = EigenArray.from_array(m1, 'd')
m2_f = EigenArray.from_array(m1, 'f')
Homography.from_matrix(m1, 'd')
Homography.from_matrix(m1, 'f')
Homography.from_matrix(m2_d.get_matrix(), 'd')
Homography.from_matrix(m2_d.get_matrix(), 'f')
Homography.from_matrix(m2_f.get_matrix(), 'd')
Homography.from_matrix(m2_f.get_matrix(), 'f')
def test_random(self):
Homography.random('d')
Homography.random('f')
def test_random(self):
Homography.random('d')
Homography.random('f')
def test_matrix_init(self):
# Test that construction does not fail when passing valid matrices as
# initializer
m1 = [[0, 1, 3],
[0.3, 0.1, 10],
[-1, 8.1, 4.7]]
m2_d = EigenArray.from_array(m1, 'd')
m2_f = EigenArray.from_array(m1, 'f')
Homography.from_matrix(m1, 'd')
Homography.from_matrix(m1, 'f')
Homography.from_matrix(m2_d.get_matrix(), 'd')
Homography.from_matrix(m2_d.get_matrix(), 'f')
Homography.from_matrix(m2_f.get_matrix(), 'd')
Homography.from_matrix(m2_f.get_matrix(), 'f')
def test_typename(self):
h_d = Homography('d')
h_f = Homography('f')
nose.tools.assert_equal(h_d.type_name, 'd')
nose.tools.assert_equal(h_f.type_name, 'f')