contrasts.py

import numpy as np
import math
import cv2 as cv
from skimage import color

# TODO create generic class


class Contrast(object):
    """Base class for color contrasts"""
    def __init__(self, img):
        self._img = img


class Monochromatic(Contrast):
    """docstring for Monochromatic"""
    def __init__(self, img, method='luminance'):
        super(Monochromatic, self).__init__(img)

        meth = getattr(Monochromatic, method)
        self.ctrst = meth(self)

    def luminance(self):
        """Creates light/dark values using luminance quantifiers for RGB

           The array has the same dimensions as the image. However the third
           does only have the size 1 which contains the luminance value
        """
        # Luminance Faktoren nach
        # http://introcs.cs.princeton.edu/python/31datatype/luminance.py.html
        luminance_factors = np.array([.114, .587, .299])

        # Erzeugung eines eindimensionalen Arrays für die effizientere
        # Berechnung
        self._img = np.multiply(self._img, luminance_factors)

        # addiert alle Werte auf einer bestimmten Achse
        luminances = np.sum(self._img, axis=2)
        luminances = luminances.astype(np.uint8, copy=True)

        return luminances

    def value(self):
        """Creates light/dark values using the value channel in HSV"""
        img = cv.cvtColor(self._img, cv.COLOR_BGR2HSV)
        values = img[:, :, 2].copy()

        return values

    def lightness(self):
        """Creates light/dark values using the value channel in HSV"""
        img = cv.cvtColor(self._img, cv.COLOR_BGR2HLS)
        lightness = img[:, :, 1].copy()

        return lightness

    def redniss_lab(self):
        """Returns the redness contrast on the basis of CIE Lab

           The a channel of the representation the image in CIE Lab is
           isolated and the value 127 set as 0 to eliminate the green
           shares of a.
        """
        img = cv.cvtColor(self._img, cv.COLOR_BGR2Lab)
        lab_a = img[:, :, 1].copy()

        lab_a[lab_a < 128] = 0
        redness = np.subtract(lab_a[lab_a > 127], 128)

        return redness

    def colf_val_point(self):
        """calculates the most colourful value point in an image

        used to identify tinting or toning images with its specific colourful
        areas in very light or darker value regions
        """

        # as long as opencv is used, convert RGB to RGB
        imgrgb = self._img[:, :, ::-1]
        assert(np.array_equal(self._img,
               imgrgb[:, :, ::-1])), "opencv scikit-image conversion wrong"
        imglab = color.rgb2lab(imgrgb)
        imglch = color.lab2lch(imglab)

        value = Monochromatic(self._img, method='value')
        value = value.value()

        imgcv = imglch[:, :, 1].astype(np.uint8)
        imgcv = np.dstack((imgcv, value))

        perc90 = np.percentile(imgcv[:, :, 0], 90)
        indices_colful = np.where(imgcv[:, :, 0] > perc90)
        colful_values = imgcv[indices_colful][:, 1]
        colful_value_max = np.median(colful_values)

        return np.array([[[colful_value_max]]])


class Saturation(Contrast):
    """docstring for Saturation"""
    def __init__(self, img, method='saturation'):
        super(Saturation, self).__init__(img)

        meth = getattr(Saturation, method)
        self.ctrst = meth(self)

    def saturation(self):
        """docstring for saturation"""
        img = cv.cvtColor(self._img, cv.COLOR_BGR2HSV)
        saturations = img[:, :, 1].copy()

        return saturations

    # CTRL stimmt vom Ergebnis noch nicht, liegt es am Rückgabedatentyp Float?
    def colourfulness(self):
        """docstring for chroma"""

        imglab = color.rgb2lab(self._img)
        imglch = color.lab2lch(imglab)

        # TODO geht garnicht, weil nicht angemessen gerundet wird
        # und skimage auch davor warnt
        imglch = imglch.astype(np.uint16)
        colourfulness = imglch[:, :, 1]

        return colourfulness


class Hue(Contrast):
    """docstring for Saturation"""
    def __init__(self, img, method='hsV'):
        super(Hue, self).__init__(img)

        meth = getattr(Hue, method)
        self.ctrst = meth(self)

    def hsV(self):
        """calculates the Hue value by using the HSV colorspace"""

        img = cv.cvtColor(self._img, cv.COLOR_BGR2HSV)
        hues = img[:, :, 0].copy()

        print('hsv')

        return hues

    def labHcl(self) -> np.uint16:
        """calculates the Hue value by using the CIE LabHCL colorspace"""

        imglab = color.rgb2lab(self._img[:, :, ::-1])
        imglch = color.lab2lch(imglab)
        hues = imglch[:, :, 2]

        vdegrees = np.vectorize(math.degrees)
        hues = vdegrees(hues)

        hues = np.around(hues).astype(np.uint16)

        return hues