def _parse_cameras(
        cls,
        input_file,
        num_cameras,
        camera_calibration_matrix,
        image_dp,
        image_fp_type,
        suppress_distortion_warnings,
        op=None,
    ):
        """
        VisualSFM CAMERA coordinate system is the standard CAMERA
        coordinate system in computer vision (not the same as
        in computer graphics like in bundler, blender, etc.)
        That means the y axis in the image is pointing downwards (not upwards)
        and the camera is looking along the positive z axis (points in front
        of the camera show a positive z value)

        The camera coordinate system in computer vision VISUALSFM uses camera
        matrices, which are rotated around the x axis by 180 degree
        i.e. the y and z axis of the CAMERA MATRICES are inverted
        therefore, the y and z axis of the TRANSLATION VECTOR are also inverted
        """
        # log_report('INFO', '_parse_cameras: ...', op)
        cameras = []

        for i in range(num_cameras):
            line = input_file.readline()

            # Read the camera section
            # From the docs:
            # <Camera> = <File name> <focal length> <quaternion WXYZ> <camera center> <radial distortion> 0
            line_values = line.split()
            relative_path = line_values[0].replace("/", os.sep)
            focal_length = float(line_values[1])

            quaternion_w = float(line_values[2])
            quaternion_x = float(line_values[3])
            quaternion_y = float(line_values[4])
            quaternion_z = float(line_values[5])
            quaternion = np.array(
                [quaternion_w, quaternion_x, quaternion_y, quaternion_z],
                dtype=float,
            )

            camera_center_x = float(line_values[6])
            camera_center_y = float(line_values[7])
            camera_center_z = float(line_values[8])
            center_vec = np.array(
                [camera_center_x, camera_center_y, camera_center_z]
            )

            radial_distortion = float(line_values[9])
            if not suppress_distortion_warnings:
                check_radial_distortion(radial_distortion, relative_path, op)

            if camera_calibration_matrix is None:
                # In this case, we have no information about the principal point
                # We assume that the principal point lies in the center
                camera_calibration_matrix = np.array(
                    [[focal_length, 0, 0], [0, focal_length, 0], [0, 0, 1]]
                )

            zero_value = float(line_values[10])
            assert zero_value == 0

            current_camera = Camera()
            # Setting the quaternion also sets the rotation matrix
            current_camera.set_rotation_with_quaternion(quaternion)

            # Set the camera center after rotation
            current_camera._center = center_vec

            # set the camera view direction as normal w.r.t world coordinates
            cam_view_vec_cam_coord = np.array([0, 0, 1]).T
            cam_rotation_matrix_inv = np.linalg.inv(
                current_camera.get_rotation_as_rotation_mat()
            )
            cam_view_vec_world_coord = cam_rotation_matrix_inv.dot(
                cam_view_vec_cam_coord
            )
            current_camera.normal = cam_view_vec_world_coord

            translation_vec = cls._compute_translation_vector(
                center_vec, current_camera.get_rotation_as_rotation_mat()
            )
            current_camera._translation_vec = translation_vec

            current_camera.set_calibration(
                camera_calibration_matrix, radial_distortion=radial_distortion
            )
            # log_report('INFO', 'Calibration mat:', op)
            # log_report('INFO', str(camera_calibration_matrix), op)

            current_camera.image_fp_type = image_fp_type
            current_camera.image_dp = image_dp
            current_camera._relative_fp = relative_path
            current_camera.id = i
            cameras.append(current_camera)
        # log_report('INFO', '_parse_cameras: Done', op)
        return cameras

        VisualSFM CAMERA coordinate system is the standard CAMERA
        coordinate system in computer vision (not the same as
        in computer graphics like in bundler, blender, etc.)
        That means the y axis in the image is pointing downwards (not upwards)
        and the camera is looking along the positive z axis (points in front
        of the camera show a positive z value)

        The camera coordinate system in computer vision VISUALSFM uses camera
        matrices, which are rotated around the x axis by 180 degree
        i.e. the y and z axis of the CAMERA MATRICES are inverted
        therefore, the y and z axis of the TRANSLATION VECTOR are also inverted
        
photogrammetry_importer/file_handlers/visualsfm_file_handler.py