




'''simple docstring'''







import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_video_inputs


if is_torch_available():
   import torch

if is_vision_available():
   from PIL import Image

   from transformers import VideoMAEImageProcessor


class      _a    (      unittest.TestCase					):
       def __init__(      self		:      Dict  ,							lowercase		:      List[str]  ,							lowercase		:      Dict=7  ,							lowercase		:      Tuple=3  ,							lowercase		:      Optional[Any]=10  ,							lowercase		:      str=18  ,							lowercase		:      Tuple=30  ,							lowercase		:      str=400  ,							lowercase		:      Optional[Any]=True  ,							lowercase		:      Dict=None  ,							lowercase		:      Any=True  ,							lowercase		:      Optional[Any]=[0.5, 0.5, 0.5]  ,							lowercase		:      Union[str, Any]=[0.5, 0.5, 0.5]  ,							lowercase		:      Any=None  ,							):



           '''simple docstring'''

           UpperCAmelCase     			=						size if size is not None else {'''shortest_edge''': 18}
           UpperCAmelCase     			=						crop_size if crop_size is not None else {'''height''': 18, '''width''': 18}

           UpperCAmelCase     			=						parent
           UpperCAmelCase     			=						batch_size
           UpperCAmelCase     			=						num_channels
           UpperCAmelCase     			=						num_frames
           UpperCAmelCase     			=						image_size
           UpperCAmelCase     			=						min_resolution
           UpperCAmelCase     			=						max_resolution
           UpperCAmelCase     			=						do_resize
           UpperCAmelCase     			=						size
           UpperCAmelCase     			=						do_normalize
           UpperCAmelCase     			=						image_mean
           UpperCAmelCase     			=						image_std
           UpperCAmelCase     			=						crop_size







       def        A (      self		:      Optional[int]							):



           '''simple docstring'''

           return {
               "image_mean": self.image_mean,
               "image_std": self.image_std,
               "do_normalize": self.do_normalize,
               "do_resize": self.do_resize,
               "size": self.size,
               "crop_size": self.crop_size,
           }






@require_torch
@require_vision
class      _a    (      __a				,				unittest.TestCase					):
       __a							:	Dict  							=   VideoMAEImageProcessor if is_vision_available() else None
       def        A (      self		:      List[Any]							):



           '''simple docstring'''

           UpperCAmelCase     			=						VideoMAEImageProcessingTester(self							)
       @property
       def        A (      self		:      Union[str, Any]							):



           '''simple docstring'''

           return self.image_processor_tester.prepare_image_processor_dict()
       def        A (      self		:      Dict							):



           '''simple docstring'''

           UpperCAmelCase     			=						self.image_processing_class(**self.image_processor_dict							)
           self.assertTrue(hasattr(lowercase  ,							'''image_mean'''							)							)
           self.assertTrue(hasattr(lowercase  ,							'''image_std'''							)							)
           self.assertTrue(hasattr(lowercase  ,							'''do_normalize'''							)							)
           self.assertTrue(hasattr(lowercase  ,							'''do_resize'''							)							)
           self.assertTrue(hasattr(lowercase  ,							'''do_center_crop'''							)							)
           self.assertTrue(hasattr(lowercase  ,							'''size'''							)							)
       def        A (      self		:      int							):



           '''simple docstring'''

           UpperCAmelCase     			=						self.image_processing_class.from_dict(self.image_processor_dict							)
           self.assertEqual(image_processor.size  ,							{'''shortest_edge''': 18}							)
           self.assertEqual(image_processor.crop_size  ,							{'''height''': 18, '''width''': 18}							)

           UpperCAmelCase     			=						self.image_processing_class.from_dict(self.image_processor_dict  ,							size=42  ,							crop_size=84							)
           self.assertEqual(image_processor.size  ,							{'''shortest_edge''': 42}							)
           self.assertEqual(image_processor.crop_size  ,							{'''height''': 84, '''width''': 84}							)
       def        A (      self		:      Any							):



           '''simple docstring'''

           pass
       def        A (      self		:      List[str]							):



           '''simple docstring'''

           UpperCAmelCase     			=						self.image_processing_class(**self.image_processor_dict							)
           # create random PIL videos
           UpperCAmelCase     			=						prepare_video_inputs(self.image_processor_tester  ,							equal_resolution=lowercase							)
           for video in video_inputs:
               self.assertIsInstance(lowercase  ,							lowercase							)
               self.assertIsInstance(video[0]  ,							Image.Image							)

           # Test not batched input
           UpperCAmelCase     			=						image_processing(video_inputs[0]  ,							return_tensors='''pt'''							).pixel_values
           self.assertEqual(
               encoded_videos.shape  ,							(
                   1,
                   self.image_processor_tester.num_frames,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,							)

           # Test batched
           UpperCAmelCase     			=						image_processing(lowercase  ,							return_tensors='''pt'''							).pixel_values
           self.assertEqual(
               encoded_videos.shape  ,							(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_frames,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,							)
       def        A (      self		:      Optional[Any]							):



           '''simple docstring'''

           UpperCAmelCase     			=						self.image_processing_class(**self.image_processor_dict							)
           # create random numpy tensors
           UpperCAmelCase     			=						prepare_video_inputs(self.image_processor_tester  ,							equal_resolution=lowercase  ,							numpify=lowercase							)
           for video in video_inputs:
               self.assertIsInstance(lowercase  ,							lowercase							)
               self.assertIsInstance(video[0]  ,							np.ndarray							)

           # Test not batched input
           UpperCAmelCase     			=						image_processing(video_inputs[0]  ,							return_tensors='''pt'''							).pixel_values
           self.assertEqual(
               encoded_videos.shape  ,							(
                   1,
                   self.image_processor_tester.num_frames,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,							)

           # Test batched
           UpperCAmelCase     			=						image_processing(lowercase  ,							return_tensors='''pt'''							).pixel_values
           self.assertEqual(
               encoded_videos.shape  ,							(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_frames,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,							)







       def        A (      self		:      str							):



           '''simple docstring'''

           UpperCAmelCase     			=						self.image_processing_class(**self.image_processor_dict							)
           # create random PyTorch tensors
           UpperCAmelCase     			=						prepare_video_inputs(self.image_processor_tester  ,							equal_resolution=lowercase  ,							torchify=lowercase							)
           for video in video_inputs:
               self.assertIsInstance(lowercase  ,							lowercase							)
               self.assertIsInstance(video[0]  ,							torch.Tensor							)

           # Test not batched input
           UpperCAmelCase     			=						image_processing(video_inputs[0]  ,							return_tensors='''pt'''							).pixel_values
           self.assertEqual(
               encoded_videos.shape  ,							(
                   1,
                   self.image_processor_tester.num_frames,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,							)

           # Test batched
           UpperCAmelCase     			=						image_processing(lowercase  ,							return_tensors='''pt'''							).pixel_values
           self.assertEqual(
               encoded_videos.shape  ,							(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_frames,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,							)










'''simple docstring'''







def 		snake_case_				(_a      :				float       ,  _a      :				float       ,  _a      :				float	):
    if hue < 0 or hue > 3_6_0:
        raise Exception('''hue should be between 0 and 360'''	)

    if saturation < 0 or saturation > 1:
        raise Exception('''saturation should be between 0 and 1'''	)

    if value < 0 or value > 1:
        raise Exception('''value should be between 0 and 1'''	)

    UpperCAmelCase     			=						value * saturation
    UpperCAmelCase     			=						hue / 6_0
    UpperCAmelCase     			=						chroma * (1 - abs(hue_section % 2 - 1	))
    UpperCAmelCase     			=						value - chroma

    if hue_section >= 0 and hue_section <= 1:
        UpperCAmelCase     			=						round(2_5_5 * (chroma + match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (second_largest_component + match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (match_value)	)
    elif hue_section > 1 and hue_section <= 2:
        UpperCAmelCase     			=						round(2_5_5 * (second_largest_component + match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (chroma + match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (match_value)	)
    elif hue_section > 2 and hue_section <= 3:
        UpperCAmelCase     			=						round(2_5_5 * (match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (chroma + match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (second_largest_component + match_value)	)
    elif hue_section > 3 and hue_section <= 4:
        UpperCAmelCase     			=						round(2_5_5 * (match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (second_largest_component + match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (chroma + match_value)	)
    elif hue_section > 4 and hue_section <= 5:
        UpperCAmelCase     			=						round(2_5_5 * (second_largest_component + match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (chroma + match_value)	)
    else:
        UpperCAmelCase     			=						round(2_5_5 * (chroma + match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (second_largest_component + match_value)	)

    return [red, green, blue]





def 		snake_case_				(_a      :				int       ,  _a      :				int       ,  _a      :				int	):
    if red < 0 or red > 2_5_5:
        raise Exception('''red should be between 0 and 255'''	)

    if green < 0 or green > 2_5_5:
        raise Exception('''green should be between 0 and 255'''	)

    if blue < 0 or blue > 2_5_5:
        raise Exception('''blue should be between 0 and 255'''	)

    UpperCAmelCase     			=						red / 2_5_5
    UpperCAmelCase     			=						green / 2_5_5
    UpperCAmelCase     			=						blue / 2_5_5
    UpperCAmelCase     			=						max(_a       ,  _a       ,  _a	)
    UpperCAmelCase     			=						value - min(_a       ,  _a       ,  _a	)
    UpperCAmelCase     			=						0 if value == 0 else chroma / value

    if chroma == 0:
        UpperCAmelCase     			=						0.0
    elif value == float_red:
        UpperCAmelCase     			=						6_0 * (0 + (float_green - float_blue) / chroma)
    elif value == float_green:
        UpperCAmelCase     			=						6_0 * (2 + (float_blue - float_red) / chroma)
    else:
        UpperCAmelCase     			=						6_0 * (4 + (float_red - float_green) / chroma)

    UpperCAmelCase     			=						(hue + 3_6_0) % 3_6_0

    return [hue, saturation, value]







def 		snake_case_				(_a      :				list[float]       ,  _a      :				list[float]	):
    UpperCAmelCase     			=						abs(hsv_a[0] - hsv_a[0]	) < 0.2
    UpperCAmelCase     			=						abs(hsv_a[1] - hsv_a[1]	) < 0.002
    UpperCAmelCase     			=						abs(hsv_a[2] - hsv_a[2]	) < 0.002

    return check_hue and check_saturation and check_value




