'''simple docstring'''






# Imports
import numpy as np





class     A__							:





   """simple docstring"""





   def __init__( self     :		int						,     lowerCAmelCase__     :		int=None						,     lowerCAmelCase__     :		List[str]=None						,     lowerCAmelCase__     :		Any=None						,     lowerCAmelCase__     :		Optional[int]=None						,     lowerCAmelCase__     :		Dict=None			)       ->    List[str]:







      """simple docstring"""




      self.set_matricies(red=A_						,     green=A_						,     blue=A_						,     red_edge=A_						,     nir=A_			)




   def 			_lowerCAmelCase		( self     :		Optional[Any]						,     lowerCAmelCase__     :		List[Any]=None						,     lowerCAmelCase__     :		List[Any]=None						,     lowerCAmelCase__     :		int=None						,     lowerCAmelCase__     :		int=None						,     lowerCAmelCase__     :		List[Any]=None			)       ->    Optional[Any]:







      """simple docstring"""




      if red is not None:
         _UpperCAmelCase							:	Tuple							=   red
      if green is not None:
         _UpperCAmelCase							:	List[str]							=   green
      if blue is not None:
         _UpperCAmelCase							:	Tuple							=   blue
      if red_edge is not None:
         _UpperCAmelCase							:	List[Any]							=   red_edge
      if nir is not None:
         _UpperCAmelCase							:	Dict							=   nir
      return True




   def 			_lowerCAmelCase		( self     :		List[Any]						,     lowerCAmelCase__     :		Dict=""						,     lowerCAmelCase__     :		List[Any]=None						,     lowerCAmelCase__     :		Tuple=None						,     lowerCAmelCase__     :		List[str]=None						,     lowerCAmelCase__     :		Union[str, Any]=None						,     lowerCAmelCase__     :		str=None			)       ->    Optional[int]:







      """simple docstring"""




      self.set_matricies(red=A_						,     green=A_						,     blue=A_						,     red_edge=A_						,     nir=A_			)
      _UpperCAmelCase							:	Any							=   {
          "ARVI2": self.arvaa,
          "CCCI": self.ccci,
          "CVI": self.cvi,
          "GLI": self.gli,
          "NDVI": self.ndvi,
          "BNDVI": self.bndvi,
          "redEdgeNDVI": self.red_edge_ndvi,
          "GNDVI": self.gndvi,
          "GBNDVI": self.gbndvi,
          "GRNDVI": self.grndvi,
          "RBNDVI": self.rbndvi,
          "PNDVI": self.pndvi,
          "ATSAVI": self.atsavi,
          "BWDRVI": self.bwdrvi,
          "CIgreen": self.ci_green,
          "CIrededge": self.ci_rededge,
          "CI": self.ci,
          "CTVI": self.ctvi,
          "GDVI": self.gdvi,
          "EVI": self.evi,
          "GEMI": self.gemi,
          "GOSAVI": self.gosavi,
          "GSAVI": self.gsavi,
          "Hue": self.hue,
          "IVI": self.ivi,
          "IPVI": self.ipvi,
          "I": self.i,
          "RVI": self.rvi,
          "MRVI": self.mrvi,
          "MSAVI": self.m_savi,
          "NormG": self.norm_g,
          "NormNIR": self.norm_nir,
          "NormR": self.norm_r,
          "NGRDI": self.ngrdi,
          "RI": self.ri,
          "S": self.s,
          "IF": self._if,
          "DVI": self.dvi,
          "TVI": self.tvi,
          "NDRE": self.ndre,
      }

      try:
         return funcs[index]()
      except KeyError:
         print("Index not in the list!"			)
         return False




   def 			_lowerCAmelCase		( self     :		int			)       ->    Union[str, Any]:







      """simple docstring"""




      return -0.18 + (1.17 * ((self.nir - self.red) / (self.nir + self.red)))




   def 			_lowerCAmelCase		( self     :		Dict			)       ->    Union[str, Any]:







      """simple docstring"""




      return ((self.nir - self.redEdge) / (self.nir + self.redEdge)) / (
          (self.nir - self.red) / (self.nir + self.red)
      )




   def 			_lowerCAmelCase		( self     :		Optional[int]			)       ->    int:







      """simple docstring"""




      return self.nir * (self.red / (self.green**2))




   def 			_lowerCAmelCase		( self     :		str			)       ->    Optional[int]:







      """simple docstring"""




      return (2 * self.green - self.red - self.blue) / (
          2 * self.green + self.red + self.blue
      )




   def 			_lowerCAmelCase		( self     :		int			)       ->    int:







      """simple docstring"""




      return (self.nir - self.red) / (self.nir + self.red)




   def 			_lowerCAmelCase		( self     :		List[Any]			)       ->    int:







      """simple docstring"""




      return (self.nir - self.blue) / (self.nir + self.blue)




   def 			_lowerCAmelCase		( self     :		List[Any]			)       ->    int:







      """simple docstring"""




      return (self.redEdge - self.red) / (self.redEdge + self.red)




   def 			_lowerCAmelCase		( self     :		str			)       ->    Optional[int]:







      """simple docstring"""




      return (self.nir - self.green) / (self.nir + self.green)




   def 			_lowerCAmelCase		( self     :		str			)       ->    Optional[int]:







      """simple docstring"""




      return (self.nir - (self.green + self.blue)) / (
          self.nir + (self.green + self.blue)
      )




   def 			_lowerCAmelCase		( self     :		Dict			)       ->    List[Any]:







      """simple docstring"""




      return (self.nir - (self.green + self.red)) / (
          self.nir + (self.green + self.red)
      )




   def 			_lowerCAmelCase		( self     :		Optional[int]			)       ->    Dict:







      """simple docstring"""




      return (self.nir - (self.blue + self.red)) / (self.nir + (self.blue + self.red))




   def 			_lowerCAmelCase		( self     :		List[Any]			)       ->    Tuple:







      """simple docstring"""




      return (self.nir - (self.green + self.red + self.blue)) / (
          self.nir + (self.green + self.red + self.blue)
      )




   def 			_lowerCAmelCase		( self     :		Any						,     lowerCAmelCase__     :		Optional[int]=0.08						,     lowerCAmelCase__     :		List[Any]=1.22						,     lowerCAmelCase__     :		List[str]=0.03			)       ->    List[str]:







      """simple docstring"""




      return a * (
          (self.nir - a * self.red - b)
          / (a * self.nir + self.red - a * b + x * (1 + a**2))
      )




   def 			_lowerCAmelCase		( self     :		Any			)       ->    List[str]:







      """simple docstring"""




      return (0.1 * self.nir - self.blue) / (0.1 * self.nir + self.blue)




   def 			_lowerCAmelCase		( self     :		List[Any]			)       ->    Optional[int]:







      """simple docstring"""




      return (self.nir / self.green) - 1




   def 			_lowerCAmelCase		( self     :		Dict			)       ->    str:







      """simple docstring"""




      return (self.nir / self.redEdge) - 1




   def 			_lowerCAmelCase		( self     :		str			)       ->    int:







      """simple docstring"""




      return (self.red - self.blue) / self.red




   def 			_lowerCAmelCase		( self     :		int			)       ->    Dict:







      """simple docstring"""




      _UpperCAmelCase							:	List[Any]							=   self.ndvi()
      return ((ndvi + 0.5) / (abs(ndvi + 0.5			))) * (abs(ndvi + 0.5			) ** (1 / 2))




   def 			_lowerCAmelCase		( self     :		Union[str, Any]			)       ->    Union[str, Any]:







      """simple docstring"""




      return self.nir - self.green




   def 			_lowerCAmelCase		( self     :		Dict			)       ->    Any:







      """simple docstring"""




      return 2.5 * (
          (self.nir - self.red) / (self.nir + 6 * self.red - 7.5 * self.blue + 1)
      )




   def 			_lowerCAmelCase		( self     :		Optional[Any]			)       ->    Tuple:







      """simple docstring"""




      _UpperCAmelCase							:	Union[str, Any]							=   (2 * (self.nir**2 - self.red**2) + 1.5 * self.nir + 0.5 * self.red) / (
          self.nir + self.red + 0.5
      )
      return n * (1 - 0.25 * n) - (self.red - 0.125) / (1 - self.red)




   def 			_lowerCAmelCase		( self     :		Optional[Any]						,     lowerCAmelCase__     :		List[Any]=0.16			)       ->    Dict:







      """simple docstring"""




      return (self.nir - self.green) / (self.nir + self.green + y)




   def 			_lowerCAmelCase		( self     :		Optional[Any]						,     lowerCAmelCase__     :		Optional[Any]=0.5			)       ->    Any:







      """simple docstring"""




      return ((self.nir - self.green) / (self.nir + self.green + n)) * (1 + n)




   def 			_lowerCAmelCase		( self     :		Dict			)       ->    Optional[Any]:







      """simple docstring"""




      return np.arctan(
          ((2 * self.red - self.green - self.blue) / 30.5) * (self.green - self.blue)			)




   def 			_lowerCAmelCase		( self     :		Dict						,     lowerCAmelCase__     :		Union[str, Any]=None						,     lowerCAmelCase__     :		Optional[int]=None			)       ->    str:







      """simple docstring"""




      return (self.nir - b) / (a * self.red)




   def 			_lowerCAmelCase		( self     :		List[str]			)       ->    Optional[Any]:







      """simple docstring"""




      return (self.nir / ((self.nir + self.red) / 2)) * (self.ndvi() + 1)




   def 			_lowerCAmelCase		( self     :		Optional[int]			)       ->    str:







      """simple docstring"""




      return (self.red + self.green + self.blue) / 30.5




   def 			_lowerCAmelCase		( self     :		Optional[int]			)       ->    List[str]:







      """simple docstring"""




      return self.nir / self.red




   def 			_lowerCAmelCase		( self     :		int			)       ->    List[Any]:







      """simple docstring"""




      return (self.rvi() - 1) / (self.rvi() + 1)




   def 			_lowerCAmelCase		( self     :		Optional[Any]			)       ->    int:







      """simple docstring"""




      return (
          (2 * self.nir + 1)
          - ((2 * self.nir + 1) ** 2 - 8 * (self.nir - self.red)) ** (1 / 2)
      ) / 2




   def 			_lowerCAmelCase		( self     :		int			)       ->    List[Any]:







      """simple docstring"""




      return self.green / (self.nir + self.red + self.green)




   def 			_lowerCAmelCase		( self     :		Optional[Any]			)       ->    Optional[Any]:







      """simple docstring"""




      return self.nir / (self.nir + self.red + self.green)




   def 			_lowerCAmelCase		( self     :		Tuple			)       ->    Tuple:







      """simple docstring"""




      return self.red / (self.nir + self.red + self.green)




   def 			_lowerCAmelCase		( self     :		List[str]			)       ->    Union[str, Any]:







      """simple docstring"""




      return (self.green - self.red) / (self.green + self.red)




   def 			_lowerCAmelCase		( self     :		List[str]			)       ->    List[str]:







      """simple docstring"""




      return (self.red - self.green) / (self.red + self.green)




   def 			_lowerCAmelCase		( self     :		List[Any]			)       ->    str:







      """simple docstring"""




      _UpperCAmelCase							:	List[Any]							=   np.max([np.max(self.red			), np.max(self.green			), np.max(self.blue			)]			)
      _UpperCAmelCase							:	Dict							=   np.min([np.min(self.red			), np.min(self.green			), np.min(self.blue			)]			)
      return (max_value - min_value) / max_value




   def 			_lowerCAmelCase		( self     :		str			)       ->    Tuple:







      """simple docstring"""




      return (2 * self.red - self.green - self.blue) / (self.green - self.blue)




   def 			_lowerCAmelCase		( self     :		List[Any]			)       ->    List[Any]:







      """simple docstring"""




      return self.nir / self.red




   def 			_lowerCAmelCase		( self     :		Tuple			)       ->    Union[str, Any]:







      """simple docstring"""




      return (self.ndvi() + 0.5) ** (1 / 2)




   def 			_lowerCAmelCase		( self     :		Tuple			)       ->    List[str]:







      """simple docstring"""




      return (self.nir - self.redEdge) / (self.nir + self.redEdge)






class 					A__   :





      def __init__( self       ,							A_   ):
       '''simple docstring'''




       UpperCamelCase	:					Union[str, Any]       	=   set_counts
       UpperCamelCase	:					int       	=   max(A_   )
       UpperCamelCase	:					Optional[Any]       	=   len(A_   )
       UpperCamelCase	:					Union[str, Any]       	=   [1] * num_sets
       UpperCamelCase	:					Union[str, Any]       	=   list(range(A_   )   )





      def        __UpperCamelCase( self       ,							A_       ,							A_   ):
       '''simple docstring'''




       UpperCamelCase	:					Any       	=   self.get_parent(A_   )
       UpperCamelCase	:					Optional[int]       	=   self.get_parent(A_   )

       if src_parent == dst_parent:
        return False

       if self.ranks[dst_parent] >= self.ranks[src_parent]:
        self.set_counts[dst_parent] += self.set_counts[src_parent]
        UpperCamelCase	:					int       	=   0
        UpperCamelCase	:					Dict       	=   dst_parent
        if self.ranks[dst_parent] == self.ranks[src_parent]:
         self.ranks[dst_parent] += 1
        UpperCamelCase	:					Optional[int]       	=   self.set_counts[dst_parent]
       else:
        self.set_counts[src_parent] += self.set_counts[dst_parent]
        UpperCamelCase	:					Any       	=   0
        UpperCamelCase	:					Optional[int]       	=   src_parent
        UpperCamelCase	:					int       	=   self.set_counts[src_parent]

       UpperCamelCase	:					Any       	=   max(self.max_set       ,							A_   )
       return True





      def        __UpperCamelCase( self       ,							A_   ):
       '''simple docstring'''




       if self.parents[disj_set] == disj_set:
        return disj_set
       UpperCamelCase	:					Optional[int]       	=   self.get_parent(self.parents[disj_set]   )
       return self.parents[disj_set]
