test formatting, change .image to .array

Author: petercorke

tests/test_camera.py

@@ -16,7 +16,7 @@ def test_parameters(self):
 
         c = CentralCamera(f=0.2)
         nt.assert_array_almost_equal(c.f, (0.2, 0.2))
-        self.assertEqual(c.camtype, 'perspective')
+        self.assertEqual(c.camtype, "perspective")
         self.assertEqual(c.fu, 0.2)
         self.assertEqual(c.fv, 0.2)
 
@@ -71,15 +71,15 @@ def test_parameters(self):
         self.assertEqual(c.u0, 200)
         self.assertEqual(c.v0, 300)
         nt.assert_array_almost_equal(c.pp, (200, 300))
-        
+
         # Test setting focal length
         c = CentralCamera(f=0.015)
         try:
             c.f = 0.02
             self.assertAlmostEqual(c.f[0], 0.02)
         except:
             pass
-        
+
         # Test setting principal point
         try:
             c.pp = (400, 300)
@@ -93,21 +93,21 @@ def test_pose(self):
         c = CentralCamera()
         self.assertTrue(c.pose == SE3())
 
-        x = SE3(1,2,3)
-        y = SE3(4,5,6)
-        
+        x = SE3(1, 2, 3)
+        y = SE3(4, 5, 6)
+
         # Test setting pose
         c.pose = x
         self.assertTrue(c.pose == x)
-        
+
         # Test different pose
         c.pose = y
         self.assertTrue(c.pose == y)
-    
+
     def test_project_point(self):
         """Test projecting 3D points to image plane"""
         c = CentralCamera(f=0.015, rho=10e-6, imagesize=[1280, 1024])
-        
+
         # Project a single point
         try:
             P = np.array([0.1, 0.2, 3.0])
@@ -116,55 +116,55 @@ def test_project_point(self):
         except:
             # Method might not exist
             pass
-        
+
         # Project multiple points
         try:
             P_multi = np.array([[0.1, 0.2, 0.3], [0.2, 0.3, 0.4], [3.0, 3.0, 3.0]]).T
             p_multi = c.project_point(P_multi)
             self.assertEqual(p_multi.shape[1], 3)
         except:
             pass
-    
+
     def test_K_matrix(self):
         """Test camera calibration matrix"""
         c = CentralCamera(f=0.015, rho=10e-6, imagesize=[1280, 1024], pp=(640, 512))
         K = c.K
-        
+
         # Check shape
         self.assertEqual(K.shape, (3, 3))
-        
+
         # Check that K is upper triangular (mostly)
         self.assertNotEqual(K[0, 0], 0)  # fu
         self.assertNotEqual(K[1, 1], 0)  # fv
         self.assertNotEqual(K[0, 2], 0)  # u0
         self.assertNotEqual(K[1, 2], 0)  # v0
-        self.assertEqual(K[2, 2], 1.0)   # Bottom right should be 1
-    
+        self.assertEqual(K[2, 2], 1.0)  # Bottom right should be 1
+
     def test_C_matrix(self):
         """Test camera matrix"""
         c = CentralCamera(f=0.015, rho=10e-6)
         C = c.C()
-        
+
         # Check shape
         self.assertEqual(C.shape, (3, 4))
-    
+
     def test_different_camera_types(self):
         """Test different camera models"""
         # Perspective camera
         c_persp = CentralCamera(f=0.015)
-        self.assertEqual(c_persp.camtype, 'perspective')
-        
+        self.assertEqual(c_persp.camtype, "perspective")
+
         # Test camera with distortion parameters
         try:
             c_dist = CentralCamera(f=0.015, distortion=[0.1, 0.01])
             self.assertIsNotNone(c_dist.distortion)
         except:
             pass
-    
+
     def test_ray_direction(self):
         """Test computing ray directions"""
         c = CentralCamera(f=0.015, rho=10e-6, imagesize=[1280, 1024])
-        
+
         try:
             # Test getting ray for a pixel
             ray = c.ray([640, 512])
@@ -173,12 +173,12 @@ def test_ray_direction(self):
         except:
             # Method might not exist
             pass
-    
+
     @unittest.skip("move method doesn't work as expected")
     def test_move_camera(self):
         """Test moving camera in space"""
         c = CentralCamera()
-        
+
         # Move camera
         T = SE3(1, 2, 3)
         try:
@@ -200,20 +200,20 @@ def test_move_camera(self):
         self.assertTrue(c2.pose == x)
 
     def test_str(self):
-        c = CentralCamera(f=0.123, imagesize=(2000, 3000), name='fred')
+        c = CentralCamera(f=0.123, imagesize=(2000, 3000), name="fred")
         s = str(c)
         self.assertIsInstance(s, str)
-        self.assertTrue('fred' in s)
-        self.assertTrue('CentralCamera' in s)
-        self.assertTrue('2000' in s)
-        self.assertTrue('3000' in s)
-        self.assertTrue('0.123' in s)
+        self.assertTrue("fred" in s)
+        self.assertTrue("CentralCamera" in s)
+        self.assertTrue("2000" in s)
+        self.assertTrue("3000" in s)
+        self.assertTrue("0.123" in s)
 
     def test_project(self):
 
         c = CentralCamera(f=1, rho=1, pp=(0, 0))
         p = c.project_point([0, 0, 5])
-        self.assertTrue(p.shape == (2,1))
+        self.assertTrue(p.shape == (2, 1))
         nt.assert_array_almost_equal(p.flatten(), [0, 0])
 
         p = c.project_point([1, 0, 5])
@@ -243,7 +243,7 @@ def test_project(self):
         p = c.project_point([1, -1, 5], objpose=SE3(-1, 1, 0))
         nt.assert_array_almost_equal(p.flatten(), [0, 0])
 
-        c = CentralCamera(f=1, rho=1, pp=(1,1))
+        c = CentralCamera(f=1, rho=1, pp=(1, 1))
 
         p = c.project_point([0, -1, 5])
         nt.assert_array_almost_equal(p.flatten(), [1, 0.8])
@@ -288,62 +288,62 @@ def test_plucker(self):
 
         line = c.ray(p)
         self.assertTrue(line.contains(P))
-    
+
     def test_camera_attributes_access(self):
         """Test accessing various camera attributes"""
         c = CentralCamera(f=0.015, rho=10e-6, imagesize=[1280, 1024], pp=(640, 512))
-        
+
         # Test accessing imaging plane size
         self.assertEqual(c.width, 1280)
         self.assertEqual(c.height, 1024)
-        
+
         # Test pixel size
         self.assertEqual(c.rhou, 10e-6)
         self.assertEqual(c.rhov, 10e-6)
-    
+
     def test_camera_pose_transformations(self):
         """Test camera pose and transformation"""
         c = CentralCamera()
-        
+
         # Initial pose
         initial_pose = c.pose
         self.assertTrue(isinstance(initial_pose, SE3))
-        
+
         # Set new pose
         new_pose = SE3(0.5, 0.5, 0.5)
         c.pose = new_pose
         self.assertTrue(c.pose == new_pose)
-    
+
     def test_camera_matrix_access(self):
         """Test accessing camera matrices"""
         c = CentralCamera(f=0.015, rho=10e-6, pp=(640, 512))
-        
+
         try:
             # K matrix
             K = c.K
             self.assertEqual(K.shape, (3, 3))
             self.assertEqual(K[2, 2], 1.0)
         except:
             pass
-        
+
         try:
             # C matrix
             C = c.C()
             self.assertEqual(C.shape, (3, 4))
         except:
             pass
-        
+
         try:
-            # P matrix  
+            # P matrix
             P = c.P()
             self.assertEqual(P.shape, (3, 4))
         except:
             pass
-    
+
     def test_camera_clone_methods(self):
         """Test camera cloning/copying"""
         c = CentralCamera(f=0.015, pose=SE3(1, 2, 3))
-        
+
         try:
             # Some way to clone the camera
             c_copy = CentralCamera(f=0.015, pose=c.pose)
@@ -353,6 +353,6 @@ def test_camera_clone_methods(self):
 
 
 # ----------------------------------------------------------------------- #
-if __name__ == '__main__':
+if __name__ == "__main__":
 
-    unittest.main()
+    unittest.main()

tests/test_color.py

@@ -43,11 +43,11 @@ def test_gamma(self):
 
         a = Image(np.array([[0.4]]))
         g = a.gamma_encode(0.5)
-        nt.assert_array_almost_equal(g.image * g.image, a.image)
+        nt.assert_array_almost_equal(g.array * g.array, a.array)
 
         a = Image(np.array([[64.0]]))
         g = a.gamma_encode(0.5)
-        nt.assert_array_almost_equal(g.image * g.image, a.image)
+        nt.assert_array_almost_equal(g.array * g.array, a.array)
 
         # test for shape
         g = a.gamma("srgb")
@@ -56,7 +56,7 @@ def test_gamma(self):
         a = Image(np.random.rand(5, 5))
         g = a.gamma(0.5)
         nt.assert_array_almost_equal(g.shape, a.shape)
-        nt.assert_array_almost_equal(g.gamma(2).image, a.image)
+        nt.assert_array_almost_equal(g.gamma(2).array, a.array)
 
         a = Image(np.random.rand(5, 5, 3))
         g = a.gamma(0.5)
@@ -74,7 +74,7 @@ def test_colorize(self):
         self.assertAlmostEqual(out.A[0, 0, 2], 0.1)
         # TODO mask functionality not yet implemented
 
-    @unittest.skip("Code has a bug: mono.image should be mono")
+    @unittest.skip("Code has a bug: mono.array should be mono")
     def test_mono(self):
         # input an image that is not mono
         im = Image.Read("monalisa.png")

tests/test_processing.py

@@ -182,7 +182,7 @@ def test_float(self):
         im = Image(im)
         imf = im.to_float()
         nt.assert_array_almost_equal(imf.shape, im.shape)
-        nt.assert_array_almost_equal(imf, im.image.astype(np.float32) / 65535.0)
+        nt.assert_array_almost_equal(imf, im.array.astype(np.float32) / 65535.0)
 
     def test_testpattern(self):
         tp = Image.Ramp(dir="x", size=20, cycles=2)
@@ -224,10 +224,10 @@ def test_testpattern(self):
         # TODO not yet converted to python:
         # tp = im.testpattern('line', 20, np.pi / 6, 10)
         # self.assertEqual(tp.shape, (20, 20))
-        # self.assertEqual(tp.image[10, 0], 1)
-        # self.assertEqual(tp.image[11, 1], 1)
-        # self.assertEqual(tp.image[16, 11], 1)
-        # self.assertEqual(np.sum(tp.image), 17)
+        # self.assertEqual(tp.array[10, 0], 1)
+        # self.assertEqual(tp.array[11, 1], 1)
+        # self.assertEqual(tp.array[16, 11], 1)
+        # self.assertEqual(np.sum(tp.array), 17)
 
     def test_paste(self):
 
@@ -246,28 +246,28 @@ def test_paste(self):
             ]
         )
         cp = canvas.paste(im, (2, 1))
-        nt.assert_array_almost_equal(cp.image, out)
+        nt.assert_array_almost_equal(cp.array, out)
 
         canvas = np.zeros((5, 5))
         canvas = Image(canvas)
         cp = canvas.paste(im, (3, 2), position="centre")
-        nt.assert_array_almost_equal(cp.image, out)
+        nt.assert_array_almost_equal(cp.array, out)
 
         canvas = np.zeros((5, 5))
         canvas = Image(canvas)
         cp = canvas.paste(im, (2, 1), method="set")
-        nt.assert_array_almost_equal(cp.image, out)
+        nt.assert_array_almost_equal(cp.array, out)
 
         canvas = np.zeros((5, 5))
         canvas = Image(canvas)
         cp = canvas.paste(im, (2, 1), method="mean")
-        nt.assert_array_almost_equal(cp.image, out / 2)
+        nt.assert_array_almost_equal(cp.array, out / 2)
 
         canvas = np.zeros((5, 5))
         canvas = Image(canvas)
         cp = canvas.paste(im, (2, 1), method="add")
         cp2 = cp.paste(im, (2, 1), method="add")
-        nt.assert_array_almost_equal(cp2.image, out * 2)
+        nt.assert_array_almost_equal(cp2.array, out * 2)
 
     def test_choose(self):