# Imports
import numpy as np
class     a_			:






 '''simple docstring'''






 def __init__(      self :  Dict      ,   lowercase__ :  Optional[Any]=None      ,   lowercase__ :  Optional[Any]=None      ,   lowercase__ :  str=None      ,   lowercase__ :  Dict=None      ,   lowercase__ :  Optional[Any]=None):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Union[str, Any]      ,   lowercase__ :  List[Any]=None      ,   lowercase__ :  Union[str, Any]=None      ,   lowercase__ :  Any=None      ,   lowercase__ :  int=None      ,   lowercase__ :  str=None):







        '''simple docstring'''



        if red is not None:
               lowerCAmelCase__					     = red
        if green is not None:
               lowerCAmelCase__					     = green
        if blue is not None:
               lowerCAmelCase__					     = blue
        if red_edge is not None:
               lowerCAmelCase__					     = red_edge
        if nir is not None:
               lowerCAmelCase__					     = nir
        return True




 def 		__snake_case						(      self :  int      ,   lowercase__ :  Dict=""      ,   lowercase__ :  Any=None      ,   lowercase__ :  Dict=None      ,   lowercase__ :  Union[str, Any]=None      ,   lowercase__ :  Dict=None      ,   lowercase__ :  Optional[int]=None):







        '''simple docstring'''



        self.set_matricies(red=lowercase__      ,   green=lowercase__      ,   blue=lowercase__      ,   red_edge=lowercase__      ,   nir=lowercase__)
        lowerCAmelCase__					     = {
            '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 		__snake_case						(      self :  Optional[int]):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  str):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Optional[int]):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  List[str]):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Any):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Optional[Any]):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Tuple):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Tuple):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  List[Any]):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Tuple):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  List[str]):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Union[str, Any]):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  List[Any]      ,   lowercase__ :  int=0.08      ,   lowercase__ :  Tuple=1.22      ,   lowercase__ :  List[str]=0.03):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  str):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Optional[int]):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  str):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Union[str, Any]):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  List[str]):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  str):







        '''simple docstring'''



        return self.nir - self.green




 def 		__snake_case						(      self :  str):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  str):







        '''simple docstring'''



        lowerCAmelCase__					     = (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 		__snake_case						(      self :  str      ,   lowercase__ :  Optional[Any]=0.16):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Dict      ,   lowercase__ :  Optional[Any]=0.5):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  List[Any]):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  List[str]      ,   lowercase__ :  Tuple=None      ,   lowercase__ :  Optional[Any]=None):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  int):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Dict):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Optional[Any]):







        '''simple docstring'''



        return self.nir / self.red




 def 		__snake_case						(      self :  Dict):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  List[Any]):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Tuple):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Tuple):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Any):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Union[str, Any]):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Any):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Any):







        '''simple docstring'''



        lowerCAmelCase__					     = np.max([np.max(self.red), np.max(self.green), np.max(self.blue)])
        lowerCAmelCase__					     = np.min([np.min(self.red), np.min(self.green), np.min(self.blue)])
        return (max_value - min_value) / max_value




 def 		__snake_case						(      self :  Any):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  List[Any]):







        '''simple docstring'''



        return self.nir / self.red




 def 		__snake_case						(      self :  str):







        '''simple docstring'''



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




 def 		__snake_case						(      self :  Union[str, Any]):







        '''simple docstring'''



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

lowerCAmelCase__     						=			'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'






def 				__lowerCamelCase		(						lowerCAmelCase__     ):
       # Make sure the supplied data is a bytes-like object
       if not isinstance(lowerCAmelCase__     ,  lowerCAmelCase__     ):
              lowerCAmelCase__					     = F"""a bytes-like object is required, not '{data.__class__.__name__}'"""
              raise TypeError(lowerCAmelCase__     )

       lowerCAmelCase__					     = ''.join(bin(lowerCAmelCase__     )[2:].zfill(8     ) for byte in data     )

       lowerCAmelCase__					     = len(lowerCAmelCase__     ) % 6 != 0

       if padding_needed:
              # The padding that will be added later
              lowerCAmelCase__					     = b'=' * ((6 - len(lowerCAmelCase__     ) % 6) // 2)

              # Append binary_stream with arbitrary binary digits (0's by default) to make its
              # length a multiple of 6.
              binary_stream += "0" * (6 - len(lowerCAmelCase__     ) % 6)
       else:
              lowerCAmelCase__					     = b''

       # Encode every 6 binary digits to their corresponding Base64 character
       return (
           "".join(
               B64_CHARSET[int(binary_stream[index : index + 6]     ,  2     )]
               for index in range(0     ,  len(lowerCAmelCase__     )     ,  6     )     ).encode()
           + padding
       )






def 				__lowerCamelCase		(						lowerCAmelCase__     ):
       # Make sure encoded_data is either a string or a bytes-like object
       if not isinstance(lowerCAmelCase__     ,  lowerCAmelCase__     ) and not isinstance(lowerCAmelCase__     ,  lowerCAmelCase__     ):
              lowerCAmelCase__					     = (
                  'argument should be a bytes-like object or ASCII string, '
                  F"""not '{encoded_data.__class__.__name__}'"""
              )
              raise TypeError(lowerCAmelCase__     )

       # In case encoded_data is a bytes-like object, make sure it contains only
       # ASCII characters so we convert it to a string object
       if isinstance(lowerCAmelCase__     ,  lowerCAmelCase__     ):
              try:
                     lowerCAmelCase__					     = encoded_data.decode('utf-8'     )
              except UnicodeDecodeError:
                     raise ValueError('base64 encoded data should only contain ASCII characters'     )

       lowerCAmelCase__					     = encoded_data.count('='     )

       # Check if the encoded string contains non base64 characters
       if padding:
              assert all(
                  char in B64_CHARSET for char in encoded_data[:-padding]     ), "Invalid base64 character(s) found."
       else:
              assert all(
                  char in B64_CHARSET for char in encoded_data     ), "Invalid base64 character(s) found."

       # Check the padding
       assert len(lowerCAmelCase__     ) % 4 == 0 and padding < 3, "Incorrect padding"

       if padding:
              # Remove padding if there is one
              lowerCAmelCase__					     = encoded_data[:-padding]

              lowerCAmelCase__					     = ''.join(
                  bin(B64_CHARSET.index(lowerCAmelCase__     )     )[2:].zfill(6     ) for char in encoded_data     )[: -padding * 2]
       else:
              lowerCAmelCase__					     = ''.join(
                  bin(B64_CHARSET.index(lowerCAmelCase__     )     )[2:].zfill(6     ) for char in encoded_data     )

       lowerCAmelCase__					     = [
           int(binary_stream[index : index + 8]     ,  2     )
           for index in range(0     ,  len(lowerCAmelCase__     )     ,  8     )
       ]

       return bytes(lowerCAmelCase__     )


if __name__ == "__main__":
    import doctest

    doctest.testmod()
