

'''simple docstring'''





import copy
import os

import cva
import numpy as np
from matplotlib import pyplot as plt





class 		__SCREAMING_SNAKE_CASE							:







				def __init__(       self     :		Union[str, Any]   ):
										'''simple docstring'''
										lowercase :							Tuple    		=''''''
										lowercase :							Tuple    		=''''''
										lowercase :							Tuple    		=[]
										lowercase :							int    		=0
										lowercase :							Union[str, Any]    		=256
										lowercase :							Optional[int]    		=0
										lowercase :							int    		=0
										lowercase :							List[str]    		=0
										lowercase :							Dict    		=0







				def  lowerCamelCase_	(       self     :		Any		,					UpperCAmelCase__     :		List[Any]   ):
										'''simple docstring'''
										lowercase :							Optional[Any]    		=cva.imread(UpperCAmelCase__		,					0   )
										lowercase :							List[Any]    		=copy.deepcopy(self.img   )
										lowercase		,	lowercase		,	lowercase :							Union[str, Any]    		=plt.hist(self.img.ravel()		,					256		,					[0, 256]		,					label='''x'''   )
										lowercase :							Optional[Any]    		=np.sum(UpperCAmelCase__   )
										for i in range(len(UpperCAmelCase__   )   ):
																lowercase :							List[str]    		=x[i] / self.k
																self.sk += prk
																lowercase :							List[Any]    		=(self.L - 1) * self.sk
																if self.rem != 0:
																						lowercase :							Optional[Any]    		=int(last % last   )
																lowercase :							str    		=int(last + 1 if self.rem >= 0.5 else last   )
																self.last_list.append(UpperCAmelCase__   )
																lowercase :							Optional[int]    		=int(np.ma.count(self.img   ) / self.img[1].size   )
																lowercase :							Optional[int]    		=self.img[1].size
										for i in range(self.number_of_cols   ):
																for j in range(self.number_of_rows   ):
																						lowercase :							Optional[Any]    		=self.img[j][i]
																						if num != self.last_list[num]:
																												lowercase :							List[str]    		=self.last_list[num]
										cva.imwrite('''output_data/output.jpg'''		,					self.img   )







				def  lowerCamelCase_	(       self     :		Dict   ):
										'''simple docstring'''
										plt.hist(self.img.ravel()		,					256		,					[0, 256]   )







				def  lowerCamelCase_	(       self     :		str   ):
										'''simple docstring'''
										cva.imshow('''Output-Image'''		,					self.img   )
										cva.imshow('''Input-Image'''		,					self.original_image   )
										cva.waitKey(5000   )
										cva.destroyAllWindows()


if __name__ == "__main__":
							UpperCamelCase_    						=       os.path.join(os.path.basename(__file__), """image_data/input.jpg""")
							UpperCamelCase_    						=       ConstantStretch()
							stretcher.stretch(file_path)
							stretcher.plot_histogram()
							stretcher.show_image()








'''simple docstring'''





import datasets


UpperCamelCase_    						=       """\
@InProceedings{conneau2018xnli,
  author = \"Conneau, Alexis
                 and Rinott, Ruty
                 and Lample, Guillaume
                 and Williams, Adina
                 and Bowman, Samuel R.
                 and Schwenk, Holger
                 and Stoyanov, Veselin\",
  title = \"XNLI: Evaluating Cross-lingual Sentence Representations\",
  booktitle = \"Proceedings of the 2018 Conference on Empirical Methods
               in Natural Language Processing\",
  year = \"2018\",
  publisher = \"Association for Computational Linguistics\",
  location = \"Brussels, Belgium\",
}
"""

UpperCamelCase_    						=       """\
XNLI is a subset of a few thousand examples from MNLI which has been translated
into a 14 different languages (some low-ish resource). As with MNLI, the goal is
to predict textual entailment (does sentence A imply/contradict/neither sentence
B) and is a classification task (given two sentences, predict one of three
labels).
"""

UpperCamelCase_    						=       """
Computes XNLI score which is just simple accuracy.
Args:
    predictions: Predicted labels.
    references: Ground truth labels.
Returns:
    'accuracy': accuracy
Examples:

    >>> predictions = [0, 1]
    >>> references = [0, 1]
    >>> xnli_metric = datasets.load_metric(\"xnli\")
    >>> results = xnli_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0}
"""






def 				_lowerCAmelCase			(   __magic_name__						:     Dict   , __magic_name__						:     Union[str, Any]						)				->  Union[str, Any]:
						return (preds == labels).mean()







@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION						,							_KWARGS_DESCRIPTION      )
class 		__SCREAMING_SNAKE_CASE							(			datasets.Metric      ):







				def  lowerCamelCase_	(       self     :		str   ):
										'''simple docstring'''
										return datasets.MetricInfo(
										    description=_DESCRIPTION		,					citation=_CITATION		,					inputs_description=_KWARGS_DESCRIPTION		,					features=datasets.Features(
										        {
										            '''predictions''': datasets.Value('''int64''' if self.config_name != '''sts-b''' else '''float32'''   ),
										            '''references''': datasets.Value('''int64''' if self.config_name != '''sts-b''' else '''float32'''   ),
										        }   )		,					codebase_urls=[]		,					reference_urls=[]		,					format='''numpy'''		,					)







				def  lowerCamelCase_	(       self     :		int		,					UpperCAmelCase__     :		Dict		,					UpperCAmelCase__     :		Optional[Any]   ):
										'''simple docstring'''
										return {"accuracy": simple_accuracy(UpperCAmelCase__		,					UpperCAmelCase__   )}





