# ipfml.processing.transform

Functions which can be used to extract information from image or reduce it

Functions

`get_LAB`(image) | Transforms RGB Image into Lab
`get_LAB_L`(image) | Transforms RGB Image into Lab and returns L
`get_LAB_L_SVD`(image) | Returns Singular values from LAB L Image information
`get_LAB_L_SVD_U`(image) | Returns U SVD from L of LAB Image information
`get_LAB_L_SVD_V`(image) | Returns V SVD from L of LAB Image information
`get_LAB_L_SVD_s`(image) | Returns s (Singular values) SVD from L of LAB Image information
`get_LAB_a`(image) | Transforms RGB Image into LAB and returns a
`get_LAB_b`(image) | Transforms RGB Image into LAB and returns b
`get_XYZ`(image) | Transforms RGB Image into XYZ
`get_XYZ_X`(image) | Transforms RGB Image into XYZ and returns X
`get_XYZ_Y`(image) | Transforms RGB Image into XYZ and returns Y
`get_XYZ_Z`(image) | Transforms RGB Image into XYZ and returns Z
`get_bits_img`(image, interval) | Returns only bits specified into the interval
`get_low_bits_img`(image[, nb_bits]) | Returns Image or Numpy array with data information reduced using only low bits
`get_mscn_coefficients`(image) | Compute the Mean Substracted Constrast Normalized coefficients of an image
`gray_to_mscn`(image) | Convert Grayscale Image into Mean Subtracted Contrast Normalized (MSCN)
`rgb_to_LAB_L_bits`(image, interval) | Returns only bits from LAB L canal specified into the interval
`rgb_to_LAB_L_low_bits`(image[, nb_bits]) | Convert RGB Image into Lab L channel image using only 4 low bits values
`rgb_to_grey_low_bits`(image[, nb_bits]) | Convert RGB Image into grey image using only 4 low bits values
`rgb_to_mscn`(image) | Convert RGB Image into Mean Subtracted Contrast Normalized (MSCN)

`ipfml.processing.transform.``get_LAB`(image)

  Transforms RGB Image into Lab

  Parameters: | image – image to convert
  Returns: | Lab information

  Usage:

      >>> from PIL import Image
      >>> from ipfml.processing import transform
      >>> img = Image.open('./images/test_img.png')
      >>> Lab = transform.get_LAB(img)
      >>> Lab.shape
      (200, 200, 3)

`ipfml.processing.transform.``get_LAB_L`(image)

  Transforms RGB Image into Lab and returns L

  Parameters: | image – image to convert
  Returns: | The L chanel from Lab information

      >>> from PIL import Image
      >>> from ipfml.processing import transform
      >>> img = Image.open('./images/test_img.png')
      >>> L = transform.get_LAB_L(img)
      >>> L.shape
      (200, 200)

`ipfml.processing.transform.``get_LAB_L_SVD`(image)

  Returns Singular values from LAB L Image information

  Parameters: | image – PIL Image or Numpy array
  Returns: | U, s, V information obtained from SVD compression using Lab

  Example:

      >>> from PIL import Image
      >>> from ipfml.processing import transform
      >>> img = Image.open('./images/test_img.png')
      >>> U, s, V = transform.get_LAB_L_SVD(img)
      >>> U.shape
      (200, 200)
      >>> len(s)
      200
      >>> V.shape
      (200, 200)

`ipfml.processing.transform.``get_LAB_L_SVD_U`(image)

  Returns U SVD from L of LAB Image information

  Parameters: | image – PIL Image or Numpy array
  Returns: | U matrix of SVD compression

  Example:

      >>> from PIL import Image
      >>> from ipfml.processing import transform
      >>> img = Image.open('./images/test_img.png')
      >>> U = transform.get_LAB_L_SVD_U(img)
      >>> U.shape
      (200, 200)

`ipfml.processing.transform.``get_LAB_L_SVD_V`(image)

  Returns V SVD from L of LAB Image information

  Parameters: | image – PIL Image or Numpy array
  Returns: | V matrix of SVD compression

  Example:

      >>> from PIL import Image
      >>> from ipfml.processing import transform
      >>> img = Image.open('./images/test_img.png')
      >>> V = transform.get_LAB_L_SVD_V(img)
      >>> V.shape
      (200, 200)

`ipfml.processing.transform.``get_LAB_L_SVD_s`(image)

  Returns s (Singular values) SVD from L of LAB Image information

  Parameters: | image – PIL Image or Numpy array
  Returns: | vector of singular values

  Example:

      >>> from PIL import Image
      >>> from ipfml.processing import transform
      >>> img = Image.open('./images/test_img.png')
      >>> s = transform.get_LAB_L_SVD_s(img)
      >>> len(s)
      200

`ipfml.processing.transform.``get_LAB_a`(image)

  Transforms RGB Image into LAB and returns a

  Parameters: | image – image to convert
  Returns: | The a chanel from Lab information

  Usage:

      >>> from PIL import Image
      >>> from ipfml.processing import transform
      >>> img = Image.open('./images/test_img.png')
      >>> a = transform.get_LAB_a(img)
      >>> a.shape
      (200, 200)

`ipfml.processing.transform.``get_LAB_b`(image)

  Transforms RGB Image into LAB and returns b

  Parameters: | image – image to convert
  Returns: | The b chanel from Lab information

  Usage :

      >>> from PIL import Image
      >>> from ipfml.processing import transform
      >>> img = Image.open('./images/test_img.png')
      >>> b = transform.get_LAB_b(img)
      >>> b.shape
      (200, 200)

`ipfml.processing.transform.``get_XYZ`(image)

  Transforms RGB Image into XYZ

  Parameters: | image – image to convert
  Returns: | XYZ information obtained from transformation

  Usage:

      >>> from PIL import Image
      >>> from ipfml.processing import transform
      >>> img = Image.open('./images/test_img.png')
      >>> transform.get_XYZ(img).shape
      (200, 200, 3)

`ipfml.processing.transform.``get_XYZ_X`(image)

  Transforms RGB Image into XYZ and returns X

  Parameters: | image – image to convert
  Returns: | The X chanel from XYZ information

  Usage:

      >>> from PIL import Image
      >>> from ipfml.processing import transform
      >>> img = Image.open('./images/test_img.png')
      >>> x = transform.get_XYZ_X(img)
      >>> x.shape
      (200, 200)

`ipfml.processing.transform.``get_XYZ_Y`(image)

  Transforms RGB Image into XYZ and returns Y

  Parameters: | image – image to convert
  Returns: | The Y chanel from XYZ information

  Usage:

      >>> from PIL import Image
      >>> from ipfml.processing import transform
      >>> img = Image.open('./images/test_img.png')
      >>> y = transform.get_XYZ_Y(img)
      >>> y.shape
      (200, 200)

`ipfml.processing.transform.``get_XYZ_Z`(image)

  Transforms RGB Image into XYZ and returns Z

  Parameters: | image – image to convert
  Returns: | The Z chanel from XYZ information
  Raises: | `ValueError` – If nb_bits has unexpected value. nb_bits needs to be in interval [1, 8].

  Usage:

      >>> from PIL import Image
      >>> from ipfml.processing import transform
      >>> img = Image.open('./images/test_img.png')
      >>> z = transform.get_XYZ_Z(img)
      >>> z.shape
      (200, 200)

`ipfml.processing.transform.``get_bits_img`(image, interval)

  Returns only bits specified into the interval

  Parameters:

  - image – image to convert using this interval of bits value to keep
  - interval – (begin, end) of bits values

  Returns: | Numpy array with reduced values

  Raises:

  - `ValueError` – If min value from interval is not >= 1.
  - `ValueError` – If max value from interval is not <= 8.
  - `ValueError` – If min value from interval >= max value.

  Usage:

      >>> from PIL import Image
      >>> from ipfml.processing import transform
      >>> img = Image.open('./images/test_img.png')
      >>> bits_img = transform.get_bits_img(img, (2, 5))
      >>> bits_img.shape
      (200, 200, 3)

`ipfml.processing.transform.``get_low_bits_img`(image, nb_bits=4)

  Returns Image or Numpy array with data information reduced using only low bits

  Parameters:

  - image – image to convert
  - nb_bits – optional parameter which indicates the number of bits to keep

  Returns: | Numpy array with reduced values

  Usage:

      >>> from PIL import Image
      >>> from ipfml.processing import transform
      >>> img = Image.open('./images/test_img.png')
      >>> low_bits_img = transform.get_low_bits_img(img, 5)
      >>> low_bits_img.shape
      (200, 200, 3)

`ipfml.processing.transform.``get_mscn_coefficients`(image)

  Compute the Mean Substracted Constrast Normalized coefficients of an image

  Parameters: | image – PIL Image, Numpy array or path of image
  Returns: | MSCN coefficients

  Raises:

  - `FileNotFoundError` – If image is set as str path and image was not found
  - `ValueError` – If image numpy shape are not correct

  Example:

      >>> from PIL import Image
      >>> import numpy as np
      >>> from ipfml.processing import transform
      >>> image_values = Image.open('./images/test_img.png')
      >>> mscn_coefficients = transform.get_mscn_coefficients(image_values)
      >>> mscn_coefficients.shape
      (200, 200)

`ipfml.processing.transform.``gray_to_mscn`(image)

  Convert Grayscale Image into Mean Subtracted Contrast Normalized (MSCN)

  Parameters: | image – grayscale image
  Returns: | MSCN matrix obtained from transformation

  Usage:

      >>> from PIL import Image
      >>> from ipfml.processing import transform
      >>> img = Image.open('./images/test_img.png')
      >>> img = transform.get_LAB_L(img)
      >>> img_mscn = transform.gray_to_mscn(img)
      >>> img_mscn.shape
      (200, 200)

`ipfml.processing.transform.``rgb_to_LAB_L_bits`(image, interval)

  Returns only bits from LAB L canal specified into the interval

  Parameters:

  - image – image to convert using this interval of bits value to keep
  - interval – (begin, end) of bits values

  Returns: | 2D Numpy array with reduced values

      >>> from PIL import Image
      >>> from ipfml.processing import transform
      >>> img = Image.open('./images/test_img.png')
      >>> bits_Lab_l_img = transform.rgb_to_LAB_L_bits(img, (2, 6))
      >>> bits_Lab_l_img.shape
      (200, 200)

`ipfml.processing.transform.``rgb_to_LAB_L_low_bits`(image, nb_bits=4)

  Convert RGB Image into Lab L channel image using only 4 low bits values

  Parameters:

  - image – 3D RGB image Numpy array or PIL RGB image
  - nb_bits – optional parameter which indicates the number of bits to keep (default 4)

  Returns: | 2D Numpy array with low bits information kept

  Example:

      >>> from PIL import Image
      >>> from ipfml.processing import transform
      >>> img = Image.open('./images/test_img.png')
      >>> low_bits_Lab_l_img = transform.rgb_to_LAB_L_low_bits(img, 5)
      >>> low_bits_Lab_l_img.shape
      (200, 200)

`ipfml.processing.transform.``rgb_to_grey_low_bits`(image, nb_bits=4)

  Convert RGB Image into grey image using only 4 low bits values

  Parameters:

  - image – 3D RGB image Numpy array or PIL RGB image
  - nb_bits – optional parameter which indicates the number of bits to keep (default 4)

  Returns: | 2D Numpy array with low bits information kept

  Example:

      >>> from PIL import Image
      >>> from ipfml.processing import transform
      >>> img = Image.open('./images/test_img.png')
      >>> low_bits_grey_img = transform.rgb_to_grey_low_bits(img, 5)
      >>> low_bits_grey_img.shape
      (200, 200)

`ipfml.processing.transform.``rgb_to_mscn`(image)

  Convert RGB Image into Mean Subtracted Contrast Normalized (MSCN)

  Parameters: | image – 3D RGB image Numpy array or PIL RGB image
  Returns: | 2D Numpy array with MSCN information

  Example:

      >>> from PIL import Image
      >>> from ipfml.processing import transform
      >>> img = Image.open('./images/test_img.png')
      >>> img_mscn = transform.rgb_to_mscn(img)
      >>> img_mscn.shape
      (200, 200)