def test_timestamp_from_exif(self, tmp_path, timestamp_image):
            timestamp, image_name = timestamp_image
            image_path = TestImageFile.create_temp_file(tmp_path, image_name)
            imagefile = ImageFile(image_path)

            with pytest.raises(NotImplementedError):
                imagefile.timestamp_from_exif(image_path)
        def test_image(self, image_temp_path, image_array, cache_image):
            imagefile = ImageFile(image_temp_path, cache_image=cache_image)

            assert (imagefile.image == image_array).all()
            assert (imagefile.image_gray == array([[1.]])).all()

            if cache_image:
                assert (imagefile._image == image_array).all()
            else:
                assert imagefile._image is None
        def test_init_timestamp(self, tmp_path, timestamp_image, cache_image):
            timestamp, image_name = timestamp_image
            timestamp_diff = timedelta(hours=1)
            image_path = TestImageFile.create_temp_file(tmp_path, image_name)
            imagefile = ImageFile(image_path,
                                  timestamp=timestamp,
                                  timestamp_initial=timestamp - timestamp_diff)

            assert imagefile.timestamp == timestamp
            assert imagefile.timestamp_initial == timestamp - timestamp_diff
            assert imagefile.timestamp_elapsed == timestamp_diff
        def test_init(self, tmp_path, timestamp_image, cache_image, image):
            image_path = TestImageFile.create_temp_file(tmp_path,
                                                        timestamp_image[1],
                                                        suffix="png",
                                                        file_data=image)
            imagefile = ImageFile(image_path, cache_image=cache_image)

            assert str(imagefile.file_path) == str(image_path)
            assert imagefile.timestamp == imagefile.timestamp_initial
            assert imagefile.timestamp_elapsed == timedelta()
            assert imagefile.cache_image == cache_image
        def test_from_path(self, mock_get_files_by_type, mock_file_exists,
                           timestamp_initial, tmp_path):
            results = ImageFileCollection.from_path(tmp_path, [])

            assert results.count == 1
            if timestamp_initial:
                assert results.timestamps_initial[
                    0] == ImageFile.timestamp_from_string(timestamp_initial)
            else:
                assert results.timestamps_initial[0] == results.items[
                    0].timestamp_initial
        def test_timestamp_from_string_invalid(self, tmp_path):
            image_path = TestImageFile.create_temp_file(
                tmp_path, "test_image_123456789")
            imagefile = ImageFile(image_path)

            with pytest.raises(ValueError):
                imagefile.timestamp_from_string(image_path, pattern="")
                imagefile.timestamp_from_string("")
            assert imagefile.timestamp_from_string(
                imagefile.file_path.name) is None
        def test_image_align(self, image_temp_path, image_array, align_image):
            from scipy.ndimage import affine_transform
            from skimage.transform import EuclideanTransform

            transform = EuclideanTransform(rotation=90)
            imagefile = ImageFile(image_temp_path,
                                  cache_image=True,
                                  align_image=align_image)

            # The original image should be returned if no transform is available
            assert (imagefile.image == image_array).all()
            assert (imagefile.image_gray == array([[1.]])).all()

            # The original image should be returned unless align_image is True
            imagefile.alignment_transform = transform
            if align_image:
                #assert (imagefile.image == transform_img(image_array, 1, transform.rotation, transform.translation)).all()
                assert (imagefile.image == affine_transform(image_array,
                                                            transform.params,
                                                            order=3)).all()
            else:
                assert (imagefile.image == image_array).all()
        def test_enter_exit(self, tmp_path, timestamp_image, cache_image,
                            image, image_array):
            image_path = TestImageFile.create_temp_file(tmp_path,
                                                        timestamp_image[1],
                                                        suffix="png",
                                                        file_data=image)
            imagefile = ImageFile(image_path, cache_image=cache_image)

            with imagefile as image_file:
                assert (image_file._image == image_array).all()
            if imagefile.cache_image:
                assert (imagefile._image == image_array).all()
            else:
                assert imagefile._image is None
        def test_image(self, tmp_path, timestamp_image, image, cache_image):
            _, image_name = timestamp_image
            image_path = TestImageFile.create_temp_file(tmp_path,
                                                        image_name,
                                                        suffix="png",
                                                        file_data=image)
            imagefile = ImageFile(image_path, cache_image=cache_image)

            assert (imagefile.image == array([[[255, 255, 255, 255]]])).all()
            assert (imagefile.image_gray == array([[1.]])).all()

            if cache_image:
                assert (imagefile._ImageFile__image == array(
                    [[[255, 255, 255, 255]]])).all()
            else:
                assert imagefile._ImageFile__image is None
 def test_filepath_missing(self, image_path):
     with pytest.raises(FileNotFoundError):
         ImageFile(image_path)
        def test_timestamp_from_string(self, tmp_path, timestamp_image):
            timestamp, image_name = timestamp_image
            image_path = TestImageFile.create_temp_file(tmp_path, image_name)
            imagefile = ImageFile(image_path)

            assert imagefile.timestamp_from_string(image_path) == timestamp