"""simple docstring"""


from __future__ import annotations

from collections import deque
from enum import Enum
from math import atana, degrees
from sys import maxsize




class 				UpperCamelCase      (       lowerCAmelCase__     ):
       SCREAMING_SNAKE_CASE_				=   1
       SCREAMING_SNAKE_CASE_				=   2
       SCREAMING_SNAKE_CASE_				=   3







       def __repr__(				self)   ->   Any:
            return f'{self.__class__.__name__}.{self.name}'







def       UpperCAmelCase					(	UpperCAmelCase		,      UpperCAmelCase		,      UpperCAmelCase      )       ->   List[Any]:
     snake_case_       =      point
     return degrees(atana(y - miny		,      x - minx      )      )







def       UpperCAmelCase					(	UpperCAmelCase		,      UpperCAmelCase		,      UpperCAmelCase      )       ->   Any:
     snake_case_       =      starting
     snake_case_       =      via
     snake_case_       =      target
     snake_case_       =      degrees(atana(ya - ya		,      xa - xa      )      )
     via_angle %= 360
     snake_case_       =      degrees(atana(ya - ya		,      xa - xa      )      )
     target_angle %= 360
     # t-
     #  \ \
     #   \ v
     #    \|
     #     s
     # via_angle is always lower than target_angle, if direction is left.
     # If they are same, it means they are on a same line of convex hull.
     if target_angle > via_angle:
          return Direction.left
     elif target_angle == via_angle:
          return Direction.straight
     else:
          return Direction.right







def       UpperCAmelCase					(	UpperCAmelCase      )       ->   List[str]:

     if len(UpperCamelCase__      ) <= 2:
          # There is no convex hull
          raise ValueError('graham_scan: argument must contain more than 3 points.'      )
     if len(UpperCamelCase__      ) == 3:
          return points
     # find the lowest and the most left point
     snake_case_       =      0
     snake_case_       =      maxsize, maxsize
     for i, point in enumerate(UpperCamelCase__      ):
          snake_case_       =      point[0]
          snake_case_       =      point[1]
          if y < miny:
               snake_case_       =      y
               snake_case_       =      x
               snake_case_       =      i
          if y == miny and x < minx:
               snake_case_       =      x
               snake_case_       =      i

    # remove the lowest and the most left point from points for preparing for sort
     points.pop(UpperCamelCase__      )

     snake_case_       =      sorted(UpperCamelCase__		,      key=lambda UpperCAmelCase      : angle_comparer(UpperCamelCase__		,      UpperCamelCase__		,      UpperCamelCase__      )      )
     # This insert actually costs complexity,
     # and you should instead add (minx, miny) into stack later.
     # I'm using insert just for easy understanding.
     sorted_points.insert(0		,      (minx, miny)      )

     snake_case_       =      deque()
     stack.append(sorted_points[0]      )
     stack.append(sorted_points[1]      )
     stack.append(sorted_points[2]      )
     # In any ways, the first 3 points line are towards left.
     # Because we sort them the angle from minx, miny.
     snake_case_       =      Direction.left

     for i in range(3		,      len(UpperCamelCase__      )      ):
          while True:
               snake_case_       =      stack[-2]
               snake_case_       =      stack[-1]
               snake_case_       =      sorted_points[i]
               snake_case_       =      check_direction(UpperCamelCase__		,      UpperCamelCase__		,      UpperCamelCase__      )

               if next_direction == Direction.left:
                    snake_case_       =      Direction.left
                    break
               if next_direction == Direction.straight:
                    if current_direction == Direction.left:
                         # We keep current_direction as left.
                         # Because if the straight line keeps as straight,
                         # we want to know if this straight line is towards left.
                         break
                    elif current_direction == Direction.right:
                         # If the straight line is towards right,
                         # every previous points on those straigh line is not convex hull.
                         stack.pop()
               if next_direction == Direction.right:
                    stack.pop()
          stack.append(sorted_points[i]      )
     return list(UpperCamelCase__      )


"""simple docstring"""


import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


__UpperCamelCase								=    logging.get_logger(__name__)

__UpperCamelCase								=    {
    '''facebook/sam-vit-huge''': '''https://huggingface.co/facebook/sam-vit-huge/resolve/main/config.json''',
    '''facebook/sam-vit-large''': '''https://huggingface.co/facebook/sam-vit-large/resolve/main/config.json''',
    '''facebook/sam-vit-base''': '''https://huggingface.co/facebook/sam-vit-base/resolve/main/config.json''',
}




class 				UpperCamelCase      (       lowerCAmelCase__     ):







       def __init__(				self,							lowerCAmelCase__=256,							lowerCAmelCase__=1024,							lowerCAmelCase__=16,							lowerCAmelCase__=16,							lowerCAmelCase__=4,							lowerCAmelCase__="gelu",							lowerCAmelCase__=1e-6,							**lowerCAmelCase__,							)   ->   int:
            super().__init__(**lowerCAmelCase__)
            snake_case_       =      hidden_size
            snake_case_       =      image_size
            snake_case_       =      patch_size
            snake_case_       =      image_size // patch_size
            snake_case_       =      mask_input_channels
            snake_case_       =      num_point_embeddings
            snake_case_       =      hidden_act
            snake_case_       =      layer_norm_eps




class 				UpperCamelCase      (       lowerCAmelCase__     ):







       def __init__(				self,							lowerCAmelCase__=256,							lowerCAmelCase__="relu",							lowerCAmelCase__=2048,							lowerCAmelCase__=2,							lowerCAmelCase__=8,							lowerCAmelCase__=2,							lowerCAmelCase__=3,							lowerCAmelCase__=3,							lowerCAmelCase__=256,							lowerCAmelCase__=1e-6,							**lowerCAmelCase__,							)   ->   List[str]:
            super().__init__(**lowerCAmelCase__)
            snake_case_       =      hidden_size
            snake_case_       =      hidden_act
            snake_case_       =      mlp_dim
            snake_case_       =      num_hidden_layers
            snake_case_       =      num_attention_heads
            snake_case_       =      attention_downsample_rate
            snake_case_       =      num_multimask_outputs
            snake_case_       =      iou_head_depth
            snake_case_       =      iou_head_hidden_dim
            snake_case_       =      layer_norm_eps




class 				UpperCamelCase      (       lowerCAmelCase__     ):







       def __init__(				self,							lowerCAmelCase__=768,							lowerCAmelCase__=256,							lowerCAmelCase__=12,							lowerCAmelCase__=12,							lowerCAmelCase__=3,							lowerCAmelCase__=1024,							lowerCAmelCase__=16,							lowerCAmelCase__="gelu",							lowerCAmelCase__=1e-06,							lowerCAmelCase__=0.0,							lowerCAmelCase__=1e-10,							lowerCAmelCase__=True,							lowerCAmelCase__=4.0,							lowerCAmelCase__=True,							lowerCAmelCase__=True,							lowerCAmelCase__=14,							lowerCAmelCase__=[2, 5, 8, 11],							lowerCAmelCase__=128,							lowerCAmelCase__=None,							**lowerCAmelCase__,							)   ->   List[str]:
            super().__init__(**lowerCAmelCase__)

            snake_case_       =      hidden_size
            snake_case_       =      output_channels
            snake_case_       =      num_hidden_layers
            snake_case_       =      num_attention_heads
            snake_case_       =      num_channels
            snake_case_       =      image_size
            snake_case_       =      patch_size
            snake_case_       =      hidden_act
            snake_case_       =      layer_norm_eps
            snake_case_       =      attention_dropout
            snake_case_       =      initializer_range
            snake_case_       =      qkv_bias
            snake_case_       =      mlp_ratio
            snake_case_       =      use_abs_pos
            snake_case_       =      use_rel_pos
            snake_case_       =      window_size
            snake_case_       =      global_attn_indexes
            snake_case_       =      num_pos_feats
            snake_case_       =      int(hidden_size * mlp_ratio) if mlp_dim is None else mlp_dim




class 				UpperCamelCase      (       lowerCAmelCase__     ):
       SCREAMING_SNAKE_CASE_				=   "sam"
       SCREAMING_SNAKE_CASE_				=   True







       def __init__(				self,							lowerCAmelCase__=None,							lowerCAmelCase__=None,							lowerCAmelCase__=None,							lowerCAmelCase__=0.02,							**lowerCAmelCase__,							)   ->   Any:
            super().__init__(**lowerCAmelCase__)
            snake_case_       =      vision_config if vision_config is not None else {}
            snake_case_       =      prompt_encoder_config if prompt_encoder_config is not None else {}
            snake_case_       =      mask_decoder_config if mask_decoder_config is not None else {}

            if isinstance(lowerCAmelCase__,							lowerCAmelCase__):
                 snake_case_       =      vision_config.to_dict()
            if isinstance(lowerCAmelCase__,							lowerCAmelCase__):
                 snake_case_       =      prompt_encoder_config.to_dict()
            if isinstance(lowerCAmelCase__,							lowerCAmelCase__):
                 snake_case_       =      mask_decoder_config.to_dict()

            snake_case_       =      SamVisionConfig(**lowerCAmelCase__)
            snake_case_       =      SamPromptEncoderConfig(**lowerCAmelCase__)
            snake_case_       =      SamMaskDecoderConfig(**lowerCAmelCase__)
            snake_case_       =      initializer_range







       def 	a_		(				self)   ->   Dict:
            snake_case_       =      copy.deepcopy(self.__dict__)
            snake_case_       =      self.vision_config.to_dict()
            snake_case_       =      self.prompt_encoder_config.to_dict()
            snake_case_       =      self.mask_decoder_config.to_dict()
            snake_case_       =      self.__class__.model_type
            return output

