


'''simple docstring'''

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

lowerCAmelCase				:Optional[Any]        =      imread(r'''digital_image_processing/image_data/lena_small.jpg''')
lowerCAmelCase				:List[Any]        =      cvtColor(img, COLOR_BGR2GRAY)





def lowerCamelCase      (      ):





 """simple docstring"""







 __magic_name__	:   Optional[int]					     =					cn.convert_to_negative(__a		)
 # assert negative_img array for at least one True
 assert negative_img.any()





def lowerCamelCase      (      ):





 """simple docstring"""







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





def lowerCamelCase      (      ):





 """simple docstring"""







 __magic_name__	:   int					     =					canny.gen_gaussian_kernel(9		,		sigma=1.4		)
 # Assert ambiguous array
 assert resp.all()





def lowerCamelCase      (      ):





 """simple docstring"""







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





def lowerCamelCase      (      ):





 """simple docstring"""







 assert gg.gaussian_filter(__a		,		5		,		sigma=0.9		).all()





def lowerCamelCase      (      ):





 """simple docstring"""







 __magic_name__	:   Union[str, Any]					     =					array([[0.25, 0.5, 0.25], [0.5, -3, 0.5], [0.25, 0.5, 0.25]]		)
 __magic_name__	:   List[Any]					     =					conv.img_convolve(__a		,		__a		).astype(__a		)
 assert res.any()





def lowerCamelCase      (      ):





 """simple docstring"""







 assert med.median_filter(__a		,		3		).any()





def lowerCamelCase      (      ):





 """simple docstring"""







 __magic_name__	:   Union[str, Any]					     =					sob.sobel_filter(__a		)
 assert grad.any() and theta.any()





def lowerCamelCase      (      ):





 """simple docstring"""







 __magic_name__	:   Union[str, Any]					     =					sp.make_sepia(__a		,		20		)
 assert sepia.all()





def lowerCamelCase      (      lowerCAmelCase    :     Dict = "digital_image_processing/image_data/lena_small.jpg"		):





 """simple docstring"""







 __magic_name__	:   Optional[int]					     =					bs.Burkes(imread(__a		,		1		)		,		120		)
 burkes.process()
 assert burkes.output_img.any()





def lowerCamelCase      (      lowerCAmelCase    :     int = "digital_image_processing/image_data/lena_small.jpg"		,		):





 """simple docstring"""







 __magic_name__	:   Union[str, Any]					     =					rs.NearestNeighbour(imread(__a		,		1		)		,		400		,		200		)
 nn.process()
 assert nn.output.any()





def lowerCamelCase      (      ):





 """simple docstring"""







 __magic_name__	:   Union[str, Any]					     =					'digital_image_processing/image_data/lena.jpg'

 # Reading the image and converting it to grayscale.
 __magic_name__	:   str					     =					imread(__a		,		0		)

 # Test for get_neighbors_pixel function() return not None
 __magic_name__	:   List[Any]					     =					0
 __magic_name__	:   Optional[int]					     =					0
 __magic_name__	:   List[Any]					     =					image[x_coordinate][y_coordinate]

 __magic_name__	:   Optional[int]					     =					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
 __magic_name__	:   Any					     =					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]		):
   __magic_name__	:   List[str]					     =					lbp.local_binary_value(__a		,		__a		,		__a		)

 assert lbp_image.any()



'''simple docstring'''

# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import doctest
import sys
import warnings
from os.path import abspath, dirname, join

import _pytest

from transformers.testing_utils import HfDoctestModule, HfDocTestParser


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
lowerCAmelCase				:Optional[int]        =      abspath(join(dirname(__file__), '''src'''))
sys.path.insert(1, git_repo_path)

# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action='''ignore''', category=FutureWarning)





def lowerCamelCase      (      lowerCAmelCase    :     Tuple		):





	"""simple docstring"""







	config.addinivalue_line(
	    'markers'		,		'is_pt_tf_cross_test: mark test to run only when PT and TF interactions are tested'		)
	config.addinivalue_line(
	    'markers'		,		'is_pt_flax_cross_test: mark test to run only when PT and FLAX interactions are tested'		)
	config.addinivalue_line('markers'		,		'is_pipeline_test: mark test to run only when pipelines are tested'		)
	config.addinivalue_line('markers'		,		'is_staging_test: mark test to run only in the staging environment'		)
	config.addinivalue_line('markers'		,		'accelerate_tests: mark test that require accelerate'		)
	config.addinivalue_line('markers'		,		'tool_tests: mark the tool tests that are run on their specific schedule'		)





def lowerCamelCase      (      lowerCAmelCase    :     Any		):





	"""simple docstring"""







	from transformers.testing_utils import pytest_addoption_shared

	pytest_addoption_shared(lowerCAmelCase		)





def lowerCamelCase      (      lowerCAmelCase    :     Dict		):





	"""simple docstring"""







	from transformers.testing_utils import pytest_terminal_summary_main

	__magic_name__	:   Tuple					     =					terminalreporter.config.getoption('--make-reports'		)
	if make_reports:
		pytest_terminal_summary_main(lowerCAmelCase		,		id=lowerCAmelCase		)





def lowerCamelCase      (      lowerCAmelCase    :     List[Any]		,		lowerCAmelCase    :     Tuple		):





	"""simple docstring"""







	if exitstatus == 5:
		__magic_name__	:   Any					     =					0


# Doctest custom flag to ignore output.
lowerCAmelCase				:List[str]        =      doctest.register_optionflag('''IGNORE_RESULT''')

lowerCAmelCase				:Union[str, Any]        =      doctest.OutputChecker
class _lowerCamelCase	(						lowercase__							):



		'''simple docstring'''







		def        __lowerCAmelCase		( self		:						List[str]  ,					_A		:						Tuple  ,					_A		:						Tuple  ,					_A		:						str      )  ->			int:
			if IGNORE_RESULT & optionflags:
				return True
			return OutputChecker.check_output(self  ,					_A  ,					_A  ,					_A      )







lowerCAmelCase				:Optional[Any]        =      CustomOutputChecker
lowerCAmelCase				:int        =      HfDoctestModule





lowerCAmelCase				:Any        =      HfDocTestParser