import numpy as np

from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch

from .test_feature_extraction_common import FeatureExtractionSavingTestMixin
class   _lowerCAmelCase		(     __SCREAMING_SNAKE_CASE				):
							# to overwrite at feature extractactor specific tests
							_UpperCAmelCase						    =     None
							_UpperCAmelCase						    =     None







							@property
							def 				snake_case  (				self     :    Any		):
										return self.feat_extract_tester.prepare_feat_extract_dict()







							def 				snake_case  (				self     :    Tuple		):
										lowerCamelCase						:Dict						  =     self.feature_extraction_class(**self.feat_extract_dict		)
										self.assertTrue(hasattr(__snake_case	,					'''feature_size'''		)		)
										self.assertTrue(hasattr(__snake_case	,					'''sampling_rate'''		)		)
										self.assertTrue(hasattr(__snake_case	,					'''padding_value'''		)		)







							def 				snake_case  (				self     :    Dict		):
										lowerCamelCase						:int						  =     self.feat_extract_tester.prepare_inputs_for_common()
										lowerCamelCase						:Any						  =     self.feature_extraction_class(**self.feat_extract_dict		)
										lowerCamelCase						:str						  =     feat_extract.model_input_names[0]

										lowerCamelCase						:Optional[Any]						  =     BatchFeature({input_name: speech_inputs}		)

										self.assertTrue(all(len(__snake_case		) == len(__snake_case		) for x, y in zip(__snake_case	,					processed_features[input_name]		)		)		)

										lowerCamelCase						:Dict						  =     self.feat_extract_tester.prepare_inputs_for_common(equal_length=__snake_case		)
										lowerCamelCase						:List[str]						  =     BatchFeature({input_name: speech_inputs}	,					tensor_type='''np'''		)

										lowerCamelCase						:Dict						  =     processed_features[input_name]

										if len(batch_features_input.shape		) < 3:
													lowerCamelCase						:int						  =     batch_features_input[:, :, None]

										self.assertTrue(
										    batch_features_input.shape
										    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]		), self.feat_extract_tester.feature_size)		)







							@require_torch
							def 				snake_case  (				self     :    List[str]		):
										lowerCamelCase						:Dict						  =     self.feat_extract_tester.prepare_inputs_for_common(equal_length=__snake_case		)
										lowerCamelCase						:List[str]						  =     self.feature_extraction_class(**self.feat_extract_dict		)
										lowerCamelCase						:List[str]						  =     feat_extract.model_input_names[0]

										lowerCamelCase						:Union[str, Any]						  =     BatchFeature({input_name: speech_inputs}	,					tensor_type='''pt'''		)

										lowerCamelCase						:Dict						  =     processed_features[input_name]

										if len(batch_features_input.shape		) < 3:
													lowerCamelCase						:List[str]						  =     batch_features_input[:, :, None]

										self.assertTrue(
										    batch_features_input.shape
										    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]		), self.feat_extract_tester.feature_size)		)







							@require_tf
							def 				snake_case  (				self     :    Optional[Any]		):
										lowerCamelCase						:int						  =     self.feat_extract_tester.prepare_inputs_for_common(equal_length=__snake_case		)
										lowerCamelCase						:List[str]						  =     self.feature_extraction_class(**self.feat_extract_dict		)
										lowerCamelCase						:Tuple						  =     feat_extract.model_input_names[0]

										lowerCamelCase						:str						  =     BatchFeature({input_name: speech_inputs}	,					tensor_type='''tf'''		)

										lowerCamelCase						:List[Any]						  =     processed_features[input_name]

										if len(batch_features_input.shape		) < 3:
													lowerCamelCase						:Tuple						  =     batch_features_input[:, :, None]

										self.assertTrue(
										    batch_features_input.shape
										    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]		), self.feat_extract_tester.feature_size)		)







							def 				snake_case  (				self     :    Dict	,					__snake_case     :    Tuple=False		):
										def _inputs_have_equal_length(__snake_case     :    int		):
													lowerCamelCase						:Any						  =     len(input[0]		)
													for input_slice in input[1:]:
																if len(__snake_case		) != length:
																			return False
													return True

										def _inputs_are_equal(__snake_case     :    Tuple	,					__snake_case     :    Tuple		):
													if len(__snake_case		) != len(__snake_case		):
																return False

													for input_slice_a, input_slice_a in zip(__snake_case	,					__snake_case		):
																if not np.allclose(np.asarray(__snake_case		)	,					np.asarray(__snake_case		)	,					atol=1e-3		):
																			return False
													return True

										lowerCamelCase						:List[Any]						  =     self.feature_extraction_class(**self.feat_extract_dict		)
										lowerCamelCase						:Tuple						  =     self.feat_extract_tester.prepare_inputs_for_common(numpify=__snake_case		)
										lowerCamelCase						:Any						  =     feat_extract.model_input_names[0]

										lowerCamelCase						:Tuple						  =     BatchFeature({input_name: speech_inputs}		)

										lowerCamelCase						:List[Any]						  =     self.feat_extract_tester.seq_length_diff
										lowerCamelCase						:List[str]						  =     self.feat_extract_tester.max_seq_length + pad_diff
										lowerCamelCase						:List[str]						  =     self.feat_extract_tester.min_seq_length
										lowerCamelCase						:Any						  =     self.feat_extract_tester.batch_size
										lowerCamelCase						:List[Any]						  =     self.feat_extract_tester.feature_size

										# test padding for List[int] + numpy
										lowerCamelCase						:Optional[int]						  =     feat_extract.pad(__snake_case	,					padding=__snake_case		)
										lowerCamelCase						:List[str]						  =     input_a[input_name]

										lowerCamelCase						:Union[str, Any]						  =     feat_extract.pad(__snake_case	,					padding='''longest'''		)
										lowerCamelCase						:Dict						  =     input_a[input_name]

										lowerCamelCase						:List[str]						  =     feat_extract.pad(__snake_case	,					padding='''max_length'''	,					max_length=len(speech_inputs[-1]		)		)
										lowerCamelCase						:List[Any]						  =     input_a[input_name]

										lowerCamelCase						:Tuple						  =     feat_extract.pad(__snake_case	,					padding='''longest'''	,					return_tensors='''np'''		)
										lowerCamelCase						:Optional[Any]						  =     input_a[input_name]

										# max_length parameter has to be provided when setting `padding="max_length"`
										with self.assertRaises(__snake_case		):
													feat_extract.pad(__snake_case	,					padding='''max_length'''		)[input_name]

										lowerCamelCase						:Any						  =     feat_extract.pad(
										    __snake_case	,					padding='''max_length'''	,					max_length=__snake_case	,					return_tensors='''np'''		)
										lowerCamelCase						:List[str]						  =     input_a[input_name]

										self.assertFalse(_inputs_have_equal_length(__snake_case		)		)
										self.assertTrue(_inputs_have_equal_length(__snake_case		)		)
										self.assertTrue(_inputs_have_equal_length(__snake_case		)		)
										self.assertTrue(_inputs_are_equal(__snake_case	,					__snake_case		)		)
										self.assertTrue(len(input_a[0]		) == pad_min_length		)
										self.assertTrue(len(input_a[1]		) == pad_min_length + pad_diff		)
										self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0]		))		)
										self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length)		)

										if feature_size > 1:
													self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size		)

										# test padding for `pad_to_multiple_of` for List[int] + numpy
										lowerCamelCase						:Tuple						  =     feat_extract.pad(__snake_case	,					pad_to_multiple_of=10		)
										lowerCamelCase						:Union[str, Any]						  =     input_a[input_name]

										lowerCamelCase						:Dict						  =     feat_extract.pad(__snake_case	,					padding='''longest'''	,					pad_to_multiple_of=10		)
										lowerCamelCase						:Optional[int]						  =     input_a[input_name]

										lowerCamelCase						:Tuple						  =     feat_extract.pad(
										    __snake_case	,					padding='''max_length'''	,					pad_to_multiple_of=10	,					max_length=__snake_case		)
										lowerCamelCase						:Optional[Any]						  =     input_a[input_name]

										lowerCamelCase						:Tuple						  =     feat_extract.pad(
										    __snake_case	,					padding='''max_length'''	,					pad_to_multiple_of=10	,					max_length=__snake_case	,					return_tensors='''np'''	,					)
										lowerCamelCase						:str						  =     input_a[input_name]

										self.assertTrue(all(len(__snake_case		) % 10 == 0 for x in input_a		)		)
										self.assertTrue(_inputs_are_equal(__snake_case	,					__snake_case		)		)

										lowerCamelCase						:Optional[Any]						  =     pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
										self.assertTrue(all(len(__snake_case		) == expected_mult_pad_length for x in input_a		)		)
										self.assertEqual(input_a.shape[:2]	,					(batch_size, expected_mult_pad_length)		)

										if feature_size > 1:
													self.assertTrue(input_a.shape[2] == feature_size		)

										# Check padding value is correct
										lowerCamelCase						:str						  =     (np.ones(self.feat_extract_tester.feature_size		) * feat_extract.padding_value).sum()
										self.assertTrue(
										    abs(np.asarray(input_a[0]		)[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)		)
										    < 1e-3		)
										self.assertTrue(
										    abs(
										        np.asarray(input_a[1]		)[pad_min_length + pad_diff :].sum()
										        - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff)		)
										    < 1e-3		)
										self.assertTrue(
										    abs(
										        np.asarray(input_a[2]		)[pad_min_length + 2 * pad_diff :].sum()
										        - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff)		)
										    < 1e-3		)
										self.assertTrue(
										    abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)		) < 1e-3		)
										self.assertTrue(
										    abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length)		)
										    < 1e-3		)







							def 				snake_case  (				self     :    Dict	,					__snake_case     :    Union[str, Any]=False		):
										def _inputs_have_equal_length(__snake_case     :    List[str]		):
													lowerCamelCase						:str						  =     len(input[0]		)
													for input_slice in input[1:]:
																if len(__snake_case		) != length:
																			return False
													return True

										def _inputs_are_equal(__snake_case     :    Dict	,					__snake_case     :    List[str]		):
													if len(__snake_case		) != len(__snake_case		):
																return False

													for input_slice_a, input_slice_a in zip(__snake_case	,					__snake_case		):
																if not np.allclose(np.asarray(__snake_case		)	,					np.asarray(__snake_case		)	,					atol=1e-3		):
																			return False
													return True

										lowerCamelCase						:str						  =     self.feature_extraction_class(**self.feat_extract_dict		)
										lowerCamelCase						:Any						  =     self.feat_extract_tester.prepare_inputs_for_common(numpify=__snake_case		)
										lowerCamelCase						:Tuple						  =     feat_extract.model_input_names[0]

										lowerCamelCase						:Optional[int]						  =     BatchFeature({input_name: speech_inputs}		)

										# truncate to smallest
										lowerCamelCase						:List[str]						  =     feat_extract.pad(
										    __snake_case	,					padding='''max_length'''	,					max_length=len(speech_inputs[0]		)	,					truncation=__snake_case		)
										lowerCamelCase						:Optional[Any]						  =     input_a[input_name]

										lowerCamelCase						:List[Any]						  =     feat_extract.pad(__snake_case	,					padding='''max_length'''	,					max_length=len(speech_inputs[0]		)		)
										lowerCamelCase						:Any						  =     input_a[input_name]

										self.assertTrue(_inputs_have_equal_length(__snake_case		)		)
										self.assertFalse(_inputs_have_equal_length(__snake_case		)		)

										# truncate to smallest with np
										lowerCamelCase						:Optional[Any]						  =     feat_extract.pad(
										    __snake_case	,					padding='''max_length'''	,					max_length=len(speech_inputs[0]		)	,					return_tensors='''np'''	,					truncation=__snake_case	,					)
										lowerCamelCase						:int						  =     input_a[input_name]

										lowerCamelCase						:List[Any]						  =     feat_extract.pad(
										    __snake_case	,					padding='''max_length'''	,					max_length=len(speech_inputs[0]		)	,					return_tensors='''np'''		)
										lowerCamelCase						:Optional[Any]						  =     input_a[input_name]

										self.assertTrue(_inputs_have_equal_length(__snake_case		)		)
										self.assertTrue(input_a.shape[1] == len(speech_inputs[0]		)		)

										# since truncation forces padding to be smaller than longest input
										# function can't return `np.ndarray`, but has to return list
										self.assertFalse(_inputs_have_equal_length(__snake_case		)		)

										# truncate to middle
										lowerCamelCase						:Any						  =     feat_extract.pad(
										    __snake_case	,					padding='''max_length'''	,					max_length=len(speech_inputs[1]		)	,					truncation=__snake_case	,					return_tensors='''np'''	,					)
										lowerCamelCase						:Optional[int]						  =     input_a[input_name]

										lowerCamelCase						:Optional[int]						  =     feat_extract.pad(
										    __snake_case	,					padding='''max_length'''	,					max_length=len(speech_inputs[1]		)	,					truncation=__snake_case		)
										lowerCamelCase						:Dict						  =     input_a[input_name]

										lowerCamelCase						:Optional[int]						  =     feat_extract.pad(
										    __snake_case	,					padding='''max_length'''	,					max_length=len(speech_inputs[1]		)	,					return_tensors='''np'''		)
										lowerCamelCase						:List[Any]						  =     input_a[input_name]

										self.assertTrue(input_a.shape[1] == len(speech_inputs[1]		)		)
										self.assertTrue(_inputs_have_equal_length(__snake_case		)		)
										self.assertTrue(_inputs_have_equal_length(__snake_case		)		)
										self.assertTrue(_inputs_are_equal(__snake_case	,					__snake_case		)		)

										# since truncation forces padding to be smaller than longest input
										# function can't return `np.ndarray`, but has to return list
										self.assertFalse(_inputs_have_equal_length(__snake_case		)		)
										self.assertTrue(len(input_a[-1]		) == len(speech_inputs[-1]		)		)

										# padding has to be max_length when setting `truncation=True`
										with self.assertRaises(__snake_case		):
													feat_extract.pad(__snake_case	,					truncation=__snake_case		)[input_name]

										# padding has to be max_length when setting `truncation=True`
										with self.assertRaises(__snake_case		):
													feat_extract.pad(__snake_case	,					padding='''longest'''	,					truncation=__snake_case		)[input_name]

										# padding has to be max_length when setting `truncation=True`
										with self.assertRaises(__snake_case		):
													feat_extract.pad(__snake_case	,					padding='''longest'''	,					truncation=__snake_case		)[input_name]

										# max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
										with self.assertRaises(__snake_case		):
													feat_extract.pad(__snake_case	,					padding='''max_length'''	,					truncation=__snake_case		)[input_name]

										# test truncation for `pad_to_multiple_of` for List[int] + numpy
										lowerCamelCase						:Any						  =     12
										lowerCamelCase						:Dict						  =     feat_extract.pad(
										    __snake_case	,					padding='''max_length'''	,					max_length=len(speech_inputs[0]		)	,					pad_to_multiple_of=__snake_case	,					truncation=__snake_case	,					)
										lowerCamelCase						:List[str]						  =     input_a[input_name]

										lowerCamelCase						:Dict						  =     feat_extract.pad(
										    __snake_case	,					padding='''max_length'''	,					max_length=len(speech_inputs[0]		)	,					pad_to_multiple_of=__snake_case	,					)
										lowerCamelCase						:List[str]						  =     input_a[input_name]

										# retrieve expected_length as multiple of pad_to_multiple_of
										lowerCamelCase						:List[str]						  =     len(speech_inputs[0]		)
										if expected_length % pad_to_multiple_of != 0:
													lowerCamelCase						:List[Any]						  =     ((len(speech_inputs[0]		) // pad_to_multiple_of) + 1) * pad_to_multiple_of

										self.assertTrue(len(input_a[0]		) == expected_length		)
										self.assertTrue(_inputs_have_equal_length(__snake_case		)		)
										self.assertFalse(_inputs_have_equal_length(__snake_case		)		)







							def 				snake_case  (				self     :    Union[str, Any]		):
										self._check_padding(numpify=__snake_case		)







							def 				snake_case  (				self     :    int		):
										self._check_padding(numpify=__snake_case		)







							def 				snake_case  (				self     :    Union[str, Any]		):
										self._check_truncation(numpify=__snake_case		)







							def 				snake_case  (				self     :    str		):
										self._check_truncation(numpify=__snake_case		)







							@require_torch
							def 				snake_case  (				self     :    Optional[int]		):
										lowerCamelCase						:Optional[int]						  =     self.feature_extraction_class(**self.feat_extract_dict		)
										lowerCamelCase						:Optional[Any]						  =     self.feat_extract_tester.prepare_inputs_for_common()
										lowerCamelCase						:Dict						  =     feat_extract.model_input_names[0]

										lowerCamelCase						:Any						  =     BatchFeature({input_name: speech_inputs}		)

										lowerCamelCase						:Optional[Any]						  =     feat_extract.pad(__snake_case	,					padding='''longest'''	,					return_tensors='''np'''		)[input_name]
										lowerCamelCase						:Dict						  =     feat_extract.pad(__snake_case	,					padding='''longest'''	,					return_tensors='''pt'''		)[input_name]

										self.assertTrue(abs(input_np.astype(np.floataa		).sum() - input_pt.numpy().astype(np.floataa		).sum()		) < 1e-2		)







							@require_tf
							def 				snake_case  (				self     :    Optional[Any]		):
										lowerCamelCase						:List[Any]						  =     self.feature_extraction_class(**self.feat_extract_dict		)
										lowerCamelCase						:Union[str, Any]						  =     self.feat_extract_tester.prepare_inputs_for_common()
										lowerCamelCase						:Tuple						  =     feat_extract.model_input_names[0]

										lowerCamelCase						:int						  =     BatchFeature({input_name: speech_inputs}		)

										lowerCamelCase						:str						  =     feat_extract.pad(__snake_case	,					padding='''longest'''	,					return_tensors='''np'''		)[input_name]
										lowerCamelCase						:List[Any]						  =     feat_extract.pad(__snake_case	,					padding='''longest'''	,					return_tensors='''tf'''		)[input_name]

										self.assertTrue(abs(input_np.astype(np.floataa		).sum() - input_tf.numpy().astype(np.floataa		).sum()		) < 1e-2		)







							def 				snake_case  (				self     :    int		):
										lowerCamelCase						:Union[str, Any]						  =     self.feat_extract_dict
										lowerCamelCase						:Union[str, Any]						  =     True
										lowerCamelCase						:int						  =     self.feature_extraction_class(**__snake_case		)
										lowerCamelCase						:Optional[int]						  =     self.feat_extract_tester.prepare_inputs_for_common()
										lowerCamelCase						:Tuple						  =     [len(__snake_case		) for x in speech_inputs]
										lowerCamelCase						:Optional[int]						  =     feat_extract.model_input_names[0]

										lowerCamelCase						:int						  =     BatchFeature({input_name: speech_inputs}		)

										lowerCamelCase						:int						  =     feat_extract.pad(__snake_case	,					padding='''longest'''	,					return_tensors='''np'''		)
										self.assertIn('''attention_mask'''	,					__snake_case		)
										self.assertListEqual(list(processed.attention_mask.shape		)	,					list(processed[input_name].shape[:2]		)		)
										self.assertListEqual(processed.attention_mask.sum(-1		).tolist()	,					__snake_case		)







							def 				snake_case  (				self     :    Any		):
										lowerCamelCase						:str						  =     self.feat_extract_dict
										lowerCamelCase						:Optional[int]						  =     True
										lowerCamelCase						:int						  =     self.feature_extraction_class(**__snake_case		)
										lowerCamelCase						:List[Any]						  =     self.feat_extract_tester.prepare_inputs_for_common()
										lowerCamelCase						:Optional[int]						  =     [len(__snake_case		) for x in speech_inputs]
										lowerCamelCase						:List[Any]						  =     feat_extract.model_input_names[0]

										lowerCamelCase						:str						  =     BatchFeature({input_name: speech_inputs}		)
										lowerCamelCase						:str						  =     min(__snake_case		)

										lowerCamelCase						:List[str]						  =     feat_extract.pad(
										    __snake_case	,					padding='''max_length'''	,					max_length=__snake_case	,					truncation=__snake_case	,					return_tensors='''np'''		)
										self.assertIn('''attention_mask'''	,					__snake_case		)
										self.assertListEqual(
										    list(processed_pad.attention_mask.shape		)	,					[processed_pad[input_name].shape[0], max_length]		)
										self.assertListEqual(
										    processed_pad.attention_mask[:, :max_length].sum(-1		).tolist()	,					[max_length for x in speech_inputs]		)




import numpy as np
from cva import COLOR_BGR2GRAY, cvtColor, imread
from numpy import array, uinta
from PIL import Image

from digital_image_processing import change_contrast as cc
from digital_image_processing import convert_to_negative as cn
from digital_image_processing import sepia as sp
from digital_image_processing.dithering import burkes as bs
from digital_image_processing.edge_detection import canny
from digital_image_processing.filters import convolve as conv
from digital_image_processing.filters import gaussian_filter as gg
from digital_image_processing.filters import local_binary_pattern as lbp
from digital_image_processing.filters import median_filter as med
from digital_image_processing.filters import sobel_filter as sob
from digital_image_processing.resize import resize as rs

A__           =							imread(R"""digital_image_processing/image_data/lena_small.jpg""")
A__           =							cvtColor(img, COLOR_BGR2GRAY)





def  _lowerCamelCase					(   ):
			lowerCamelCase						:int						  =     cn.convert_to_negative(a_)
			# assert negative_img array for at least one True
			assert negative_img.any()





def  _lowerCamelCase					(   ):
			with Image.open('''digital_image_processing/image_data/lena_small.jpg''') as img:
						# Work around assertion for response
						assert str(cc.change_contrast(a_						,			1_10)).startswith(
						    '''<PIL.Image.Image image mode=RGB size=100x100 at''')





def  _lowerCamelCase					(   ):
			lowerCamelCase						:Optional[Any]						  =     canny.gen_gaussian_kernel(9						,			sigma=1.4)
			# Assert ambiguous array
			assert resp.all()





def  _lowerCamelCase					(   ):
			lowerCamelCase						:str						  =     imread('''digital_image_processing/image_data/lena_small.jpg'''						,			0)
			# assert ambiguous array for all == True
			assert canny_img.all()
			lowerCamelCase						:Optional[Any]						  =     canny.canny(a_)
			# assert canny array for at least one True
			assert canny_array.any()





def  _lowerCamelCase					(   ):
			assert gg.gaussian_filter(a_						,			5						,			sigma=0.9).all()





def  _lowerCamelCase					(   ):
			# laplace diagonals
			lowerCamelCase						:List[Any]						  =     array([[0.25, 0.5, 0.25], [0.5, -3, 0.5], [0.25, 0.5, 0.25]])
			lowerCamelCase						:List[Any]						  =     conv.img_convolve(a_						,			a_).astype(a_)
			assert res.any()





def  _lowerCamelCase					(   ):
			assert med.median_filter(a_						,			3).any()





def  _lowerCamelCase					(   ):
			lowerCamelCase  ,    lowerCamelCase						:Union[str, Any]						  =     sob.sobel_filter(a_)
			assert grad.any() and theta.any()





def  _lowerCamelCase					(   ):
			lowerCamelCase						:Dict						  =     sp.make_sepia(a_						,			20)
			assert sepia.all()





def  _lowerCamelCase					(   a_				: str = "digital_image_processing/image_data/lena_small.jpg"):
			lowerCamelCase						:Any						  =     bs.Burkes(imread(a_						,			1)						,			1_20)
			burkes.process()
			assert burkes.output_img.any()





def  _lowerCamelCase					(   a_				: str = "digital_image_processing/image_data/lena_small.jpg"						,			):
			lowerCamelCase						:Tuple						  =     rs.NearestNeighbour(imread(a_						,			1)						,			4_00						,			2_00)
			nn.process()
			assert nn.output.any()





def  _lowerCamelCase					(   ):
			lowerCamelCase						:Tuple						  =     '''digital_image_processing/image_data/lena.jpg'''

			# Reading the image and converting it to grayscale.
			lowerCamelCase						:Tuple						  =     imread(a_						,			0)

			# Test for get_neighbors_pixel function() return not None
			lowerCamelCase						:Dict						  =     0
			lowerCamelCase						:Optional[Any]						  =     0
			lowerCamelCase						:str						  =     image[x_coordinate][y_coordinate]

			lowerCamelCase						:Any						  =     lbp.get_neighbors_pixel(
			    a_						,			a_						,			a_						,			a_)

			assert neighbors_pixels is not None

			# Test for local_binary_pattern function()
			# Create a numpy array as the same height and width of read image
			lowerCamelCase						:int						  =     np.zeros((image.shape[0], image.shape[1]))

			# Iterating through the image and calculating the local binary pattern value
			# for each pixel.
			for i in range(0						,			image.shape[0]):
						for j in range(0						,			image.shape[1]):
									lowerCamelCase						:Optional[int]						  =     lbp.local_binary_value(a_						,			a_						,			a_)

			assert lbp_image.any()



