def test_homogeneous_inverse():
    e = np.eye(3) * 2
    e[2, 2] = 1
    e_inv = np.eye(3) * 0.5
    e_inv[2, 2] = 1
    h = Homogeneous(e)
    assert_allclose(h.pseudoinverse().h_matrix, e_inv)

 def __init__(self, image_shape):
     # flip axis 0 and axis 1 so indexing is as expected
     flip_xy = Homogeneous(np.array([[0, 1, 0],
                                     [1, 0, 0],
                                     [0, 0, 1]]))
     # scale to get the units correct
     scale = Scale(image_shape)
     self.flip_and_scale = flip_xy.compose_before(scale)

def test_homogeneous_apply_batched():
    e = np.eye(3) * 2
    p = np.random.rand(10, 2)
    e[2, 2] = 1
    e[:2, -1] = [2, 3]
    h = Homogeneous(e)
    p_applied = h.apply(p, batch_size=2)
    p_manual = p * 2 + np.array([2, 3])
    assert_allclose(p_applied, p_manual)

def test_homogeneous_apply():
    e = np.eye(3) * 2
    p = np.random.rand(10, 2)
    e[2, 2] = 1
    e[:2, -1] = [2, 3]
    print e
    h = Homogeneous(e)
    p_applied = h.apply(p)
    p_manual = p * 2 + np.array([2, 3])
    assert_allclose(p_applied, p_manual)

def test_homog_compose_after_uniformscale():
    homog = Homogeneous(np.array([[0, 1, 0],
                                  [1, 0, 0],
                                  [0, 0, 1]]))
    s = UniformScale(3, 2)
    res = homog.compose_after(s)
    assert(type(res) == Homogeneous)
    assert_allclose(res.h_matrix, np.array([[0, 3, 0],
                                            [3, 0, 0],
                                            [0, 0, 1]]))

def test_homog_compose_before_nonuniformscale():
    homog = Homogeneous(np.array([[0, 1, 0],
                                  [1, 0, 0],
                                  [0, 0, 1]]))
    s = NonUniformScale([3, 4])
    res = homog.compose_before(s)
    assert(type(res) == Homogeneous)
    assert_allclose(res.h_matrix, np.array([[0, 3, 0],
                                            [4, 0, 0],
                                            [0, 0, 1]]))

def test_homog_compose_after_inplace_scale():
    # this should be fine
    homog = Homogeneous(np.array([[0, 1, 0],
                                  [1, 0, 0],
                                  [0, 0, 1]]))
    s = Scale([3, 4])
    homog.compose_after_inplace(s)
    assert_allclose(homog.h_matrix, np.array([[0, 4, 0],
                                              [3, 0, 0],
                                              [0, 0, 1]]))

def test_homog_compose_after_alignment_rotation():
    homog = Homogeneous(np.array([[0, 1, 0],
                                  [1, 0, 0],
                                  [0, 0, 1]]))
    source = PointCloud(np.array([[0, 1],
                                  [1, 1],
                                  [-1, -5],
                                  [3, -5]]))
    r = AlignmentRotation(source, source)
    res = homog.compose_after(r)
    assert(type(res) == Homogeneous)

def test_homog_compose_before_alignment_nonuniformscale():
    homog = Homogeneous(np.array([[0, 1, 0],
                                  [1, 0, 0],
                                  [0, 0, 1]]))
    scale = UniformScale(2.5, 2)
    source = PointCloud(np.array([[0, 1],
                                  [1, 1],
                                  [-1, -5],
                                  [3, -5]]))
    target = scale.apply(source)
    # estimate the transform from source and target
    s = AlignmentUniformScale(source, target)
    res = homog.compose_before(s)
    assert(type(res) == Homogeneous)

def test_homogeneous_from_vector_inplace():
    h = Homogeneous(np.eye(3))
    e = np.eye(3) * 2
    e[2, 2] = 1
    h._from_vector_inplace(e.ravel())
    assert_allclose(h.h_matrix, e)

def test_homogeneous_as_vector():
    e = np.eye(3) * 2
    e[2, 2] = 1
    h = Homogeneous(e)
    assert_allclose(h.as_vector(), e.flatten())

def test_homogeneous_has_true_inverse():
    h = Homogeneous.init_identity(2)
    assert h.has_true_inverse

def test_homogeneous_eye():
    e = np.eye(3)
    h = Homogeneous.init_identity(2)
    assert_allclose(e, h.h_matrix)

def test_homogenous_set_h_matrix_raises_notimplementederror():
    s = Homogeneous(np.eye(4))
    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        with raises(NotImplementedError):
            s.set_h_matrix(s.h_matrix)