Beispiel #1
0
    def test_image_coord_regress(self):

        self.calibration.set_pos(np.array([0, 0, 40]))
        self.calibration.set_angles(np.array([0, 0, 0]))
        self.calibration.set_primary_point(np.array([0, 0, 10]))
        self.calibration.set_glass_vec(np.array([0, 0, 20]))
        self.calibration.set_radial_distortion(np.array([0, 0, 0]))
        self.calibration.set_decentering(np.array([0, 0]))
        self.calibration.set_affine_trans(np.array([1, 0]))

        self.mult = MultimediaParams(n1=1,
                                     n2=np.array([1]),
                                     n3=1,
                                     d=np.array([1]))

        input = np.array([[10., 5., -20.], [10., 5., -20.]])  # vec3d
        output = np.zeros((2, 2))

        x = 10. / 6.
        y = x / 2.
        correct_output = np.array([[x, y], [x, y]])

        flat_image_coordinates(input=input,
                               cal=self.calibration,
                               mult_params=self.mult,
                               output=output)
        np.testing.assert_array_equal(output, correct_output)

        output = np.full((2, 2), 999.)
        image_coordinates(input=input,
                          cal=self.calibration,
                          mult_params=self.mult,
                          output=output)

        np.testing.assert_array_equal(output, correct_output)
Beispiel #2
0
    def test_image_coord_regress(self):
        
        self.calibration.set_pos(np.array([0, 0, 40]))
        self.calibration.set_angles(np.array([0, 0, 0]))
        self.calibration.set_primary_point(np.array([0, 0, 10]))
        self.calibration.set_glass_vec(np.array([0, 0, 20]))
        self.calibration.set_radial_distortion(np.array([0, 0, 0]))
        self.calibration.set_decentering(np.array([0, 0]))
        self.calibration.set_affine_trans(np.array([1, 0]))

        self.mult = MultimediaParams(n1=1,
                                     n2=np.array([1]),
                                     n3=1,
                                     d=np.array([1]))
        
        input = np.array([[10., 5., -20.],
                          [10., 5., -20.]])  # vec3d
        output = np.zeros((2, 2))
        
        x = 10. / 6.
        y = x / 2.
        correct_output = np.array([[x, y],
                                   [x, y]])

        flat_image_coordinates(input=input, cal=self.calibration, mult_params=self.mult, output=output)
        np.testing.assert_array_equal(output, correct_output)
        
        output=np.full((2,2), 999.)
        image_coordinates(input=input, cal=self.calibration, mult_params=self.mult, output=output)

        np.testing.assert_array_equal(output, correct_output)
Beispiel #3
0
 def test_img_coord_typecheck(self):
     
     with self.assertRaises(TypeError):
         list = [[0 for x in range(3)] for x in range(10)]  # initialize a 10x3 list (but not numpy matrix)
         flat_image_coordinates(list, self.control, out=None)
     with self.assertRaises(TypeError):
         flat_image_coordinates(np.empty((10, 2)), self.calibration, self.control.get_multimedia_params(), output=None)
     with self.assertRaises(TypeError):
         image_coordinates(np.empty((10, 3)), self.calibration, self.control.get_multimedia_params(), output=np.zeros((10, 3)))
     with self.assertRaises(TypeError):
         image_coordinates(np.zeros((10, 2)), self.calibration, self.control.get_multimedia_params(), output=np.zeros((10, 2)))
Beispiel #4
0
    def test_img_coord_typecheck(self):

        with self.assertRaises(TypeError):
            list = [[0 for x in range(3)] for x in range(10)
                    ]  # initialize a 10x3 list (but not numpy matrix)
            flat_image_coordinates(list, self.control, out=None)
        with self.assertRaises(TypeError):
            flat_image_coordinates(np.empty((10, 2)),
                                   self.calibration,
                                   self.control.get_multimedia_params(),
                                   output=None)
        with self.assertRaises(TypeError):
            image_coordinates(np.empty((10, 3)),
                              self.calibration,
                              self.control.get_multimedia_params(),
                              output=np.zeros((10, 3)))
        with self.assertRaises(TypeError):
            image_coordinates(np.zeros((10, 2)),
                              self.calibration,
                              self.control.get_multimedia_params(),
                              output=np.zeros((10, 2)))
Beispiel #5
0
    def test_dumbbell(self):
        # prepare MultimediaParams
        mult_params = self.control.get_multimedia_params()
        mult_params.set_n1(1.)
        mult_params.set_layers(np.array([1.]), np.array([1.]))
        mult_params.set_n3(1.)

        # 3d point
        points = np.array([[17.5, 42, 0],
                           [-17.5, 42, 0]], dtype=float)
        
        num_cams = 4
        ori_tmpl = r'testing_fodder/dumbbell/cam{cam_num}.tif.ori'
        add_file = r'testing_fodder/calibration/cam1.tif.addpar'
        calibs = []
        targs_plain = []

        # read calibration for each camera from files
        for cam in range(num_cams):
            ori_name = ori_tmpl.format(cam_num=cam + 1)
            new_cal = Calibration()
            new_cal.from_file(ori_file=ori_name, add_file=add_file)
            calibs.append(new_cal)

        for cam_num, cam_cal in enumerate(calibs):
            new_plain_targ = flat_image_coordinates(
                points, cam_cal, self.control.get_multimedia_params())
            targs_plain.append(new_plain_targ)

        targs_plain = np.array(targs_plain).transpose(1,0,2)
        
        # The cameras are not actually fully calibrated, so the result is not 
        # an exact 0. The test is that changing the expected distance changes 
        # the measure.
        tf = dumbbell_target_func(targs_plain, self.control, calibs, 35., 0.)
        self.assertAlmostEqual(tf, 7.14860, 5) # just a regression test
        
        # As we check the db length, the measure increases...
        tf_len = dumbbell_target_func(
            targs_plain, self.control, calibs, 35., 1.)
        self.assertTrue(tf_len > tf)
        
        # ...but not as much as when giving the wrong length.
        tf_too_long = dumbbell_target_func(
            targs_plain, self.control, calibs, 25., 1.)
        self.assertTrue(tf_too_long > tf_len > tf)
    def test_dumbbell(self):
        # prepare MultimediaParams
        mult_params = self.control.get_multimedia_params()
        mult_params.set_n1(1.)
        mult_params.set_layers(np.array([1.]), np.array([1.]))
        mult_params.set_n3(1.)

        # 3d point
        points = np.array([[17.5, 42, 0], [-17.5, 42, 0]], dtype=float)

        num_cams = 4
        ori_tmpl = 'testing_fodder/dumbbell/cam{cam_num}.tif.ori'
        add_file = 'testing_fodder/calibration/cam1.tif.addpar'
        calibs = []
        targs_plain = []

        # read calibration for each camera from files
        for cam in range(num_cams):
            ori_name = ori_tmpl.format(cam_num=cam + 1)
            new_cal = Calibration()
            new_cal.from_file(ori_file=ori_name.encode(),
                              add_file=add_file.encode())
            calibs.append(new_cal)

        for cam_cal in calibs:
            new_plain_targ = flat_image_coordinates(
                points, cam_cal, self.control.get_multimedia_params())
            targs_plain.append(new_plain_targ)

        targs_plain = np.array(targs_plain).transpose(1, 0, 2)

        # The cameras are not actually fully calibrated, so the result is not
        # an exact 0. The test is that changing the expected distance changes
        # the measure.
        tf = dumbbell_target_func(targs_plain, self.control, calibs, 35., 0.)
        self.assertAlmostEqual(tf, 7.14860, 5)  # just a regression test

        # As we check the db length, the measure increases...
        tf_len = dumbbell_target_func(targs_plain, self.control, calibs, 35.,
                                      1.)
        self.assertTrue(tf_len > tf)

        # ...but not as much as when giving the wrong length.
        tf_too_long = dumbbell_target_func(targs_plain, self.control, calibs,
                                           25., 1.)
        self.assertTrue(tf_too_long > tf_len > tf)