Esempio n. 1
0
def augment_hsv(img, hgain=0.5, sgain=0.5, vgain=0.5):
    r = np.random.uniform(-1, 1, 3) * [hgain, sgain, vgain] + 1  # random gains
    hue, sat, val = cv2.split(cv2.cvtColor(img, cv2.COLOR_BGR2HSV))
    dtype = img.dtype  # uint8

    x = np.arange(0, 256, dtype=np.int16)
    lut_hue = ((x * r[0]) % 180).astype(dtype)
    lut_sat = np.clip(x * r[1], 0, 255).astype(dtype)
    lut_val = np.clip(x * r[2], 0, 255).astype(dtype)

    img_hsv = cv2.merge((cv2.LUT(hue, lut_hue), cv2.LUT(sat, lut_sat), cv2.LUT(val, lut_val))).astype(dtype)
    cv2.cvtColor(img_hsv, cv2.COLOR_HSV2BGR, dst=img)  # no return needed
Esempio n. 2
0
def adjust_gamma(image, gamma=1.0):

   invGamma = 1.0 / gamma
   table = np.array([((i / 255.0) ** invGamma) * 255
      for i in np.arange(0, 256)]).astype("uint8")

   return cv2.LUT(image, table)
Esempio n. 3
0
def gm(img, gamma=1.0):
    table = []
    for i in range(256):
        table.append(((i / 255)**gamma) * 255)
    table = np.array(table).astype('uint8')
    img_dark_new = cv2.LUT(img, table)
    return img_dark_new
Esempio n. 4
0
def adjust_gamma(image, gamma=1.0):
    # build a lookup table mapping the pixel values [0, 255] to
    # their adjusted gamma values
    invGamma = 1.0 / gamma
    table = np.array([((i / 255.0) ** invGamma) * 255
        for i in np.arange(0, 256)]).astype("uint8")

    return cv2.LUT(image, table)
Esempio n. 5
0
def gamma_transform(img, gamma):
    gamma_table = [np.power(x / 255.0, gamma) * 255.0 for x in range(256)]
    gamma_table = np.round(np.array(gamma_table)).astype(np.uint8)
    dst = cv.LUT(img, gamma_table)
    # cv.imshow("1",dst)
    # cv.waitKey(0)
    # cv.destroyAllWindows()
    return dst
Esempio n. 6
0
def correct_brightness(img,
                       threshold=0.05,
                       min_white=150,
                       max_black=50,
                       _debug=True):
    blurred = cv2.medianBlur(img, 3)
    lab = cv2.cvtColor(blurred, cv2.COLOR_BGR2LAB)

    # adaptive histogram equalization
    lab[:, :, 0] = cv2.createCLAHE(clipLimit=0.7,
                                   tileGridSize=(8, 8)).apply(lab[:, :, 0])

    # calculate white and black point
    hist = calc_hist(lab[:, :, 0])
    cutoff = np.max(hist) * threshold
    white = np.max(np.arange(256)[hist > cutoff]) + 10
    white = max(white, min_white)
    black = np.min(np.arange(256)[hist > cutoff]) / 3
    black = min(black, max_black)

    # adjust lightness
    val_black = np.arange(0, 256) - black
    val_white = val_black / (white - black) * 255
    table = np.clip(val_white, 0, 255).astype(np.uint8)
    lab[:, :, 0] = cv2.LUT(lab[:, :, 0], table)

    # increase saturation
    sat = 127 * 0.15  # percent
    val_sat = (np.arange(0, 256) - sat) / (255 - 2 * sat) * 255
    table = np.clip(val_sat, 0, 255).astype(np.uint8)
    lab[:, :, 1] = cv2.LUT(lab[:, :, 1], table)
    lab[:, :, 2] = cv2.LUT(lab[:, :, 2], table)

    output = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)

    if _debug:
        import matplotlib.pyplot as plt
        plt.figure()
        plt.plot(hist)
        plt.plot(calc_hist(cv2.cvtColor(output, cv2.COLOR_BGR2LAB)[:, :, 0]))
        show_images([img, output], show=False)

    return output
Esempio n. 7
0
def c_hsv_np(img_np, h_gain=0.5, s_gain=0.5, v_gain=0.5):
    '''
    随机色域 is_safe
    :param img_np:
    :param h_gain:
    :param s_gain:
    :param v_gain:
    :return:
    '''
    r = np.random.uniform(-1, 1, 3) * [h_gain, s_gain, v_gain] + 1  # 0.5~1.5之间
    hue, sat, val = cv2.split(cv2.cvtColor(img_np, cv2.COLOR_BGR2HSV))
    dtype = img_np.dtype  # uint8

    x = np.arange(0, 256, dtype=np.int16)
    lut_hue = ((x * r[0]) % 180).astype(dtype)
    lut_sat = np.clip(x * r[1], 0, 255).astype(dtype)
    lut_val = np.clip(x * r[2], 0, 255).astype(dtype)

    img_hsv = cv2.merge((cv2.LUT(hue, lut_hue), cv2.LUT(sat, lut_sat),
                         cv2.LUT(val, lut_val))).astype(dtype)
    cv2.cvtColor(img_hsv, cv2.COLOR_HSV2BGR, dst=img_np)  # no return needed
Esempio n. 8
0
def adjust_gamma(images, gamma=1.0):
    assert (len(images.shape) == 4)
    assert (images.shape[3] == 1)

    invGamma = 1.0 / gamma
    table = np.array([((i / 255.0) ** invGamma) * 255 
                      for i in np.arange(0, 256)]).astype("uint8")
    new_images = np.empty(images.shape)
    for i in range(images.shape[0]):
        new_images[i, :, :, 0] = cv2.LUT(np.array(images[i, :, :, 0],
                                         dtype = np.uint8), table)

    return new_images
Esempio n. 9
0
def gamma(img: np.ndarray, gamma_value=1.0):
    """
    use a lookup table to calculate new gamma value of pixels

    Args:
        img: image as numpy array
        gamma_value: factor to darken or lighten image
            > 1.0 lighten, <1.0 darken, =1.0 no changes

    Returns:
        image with adjusted gamma values
    """
    inverted = 1.0 / gamma_value
    table = np.array([((i / 255.0)**inverted) * 255
                      for i in np.arange(0, 256)]).astype("uint8")
    return cv2.LUT(img, table)
 def adjust_gamma(self, image, gamma=1.0):
     """
         Image gamma correction
         Parameters
         ----------
             image: ndim np.array
                 image to be transformed by gamma correction
             gamma: float 
         Returns
         -------
             corrected image as np.array
     """
     # build a lookup table mapping the pixel values [0, 255] to their adjusted gamma values
     invGamma = 1.0 / gamma
     table = np.array([((i / 255.0)**invGamma) * 255
                       for i in np.arange(0, 256)]).astype("uint8")
     # apply gamma correction using the lookup table
     return cv2.LUT(image, table)
Esempio n. 11
0
#3. Escreva um algoritmo que leia a imagem abaixo, e então clareie somente as regiões mais escuras dela:
from cv2 import cv2
import numpy as np
img = cv2.imread("img1.jpg")

gamma = 0.6

lookUpTable = np.empty((1,256), np.uint8)

for i in range(256):
    lookUpTable[0,i] = np.clip(pow(i / 255.0, gamma) * 255.0, 0, 255)
res = cv2.LUT(img, lookUpTable)

cv2.imshow("img original", img)
cv2.imshow("res", res)
cv2.waitKey(0)
from cv2 import cv2 as cv
import numpy as np

img = cv.imread("Practica/Input/lake.jpg", 1)

#Ecualización Conjunta
gris = cv.cvtColor(img, cv.COLOR_BGR2GRAY) #conversion gris
hist = cv.calcHist(images = [gris], 
                   channels = [0],
                   mask = None,
                   histSize = [256],
                   ranges = [0, 256])

hist *= 255.0/cv.norm(hist, cv.NORM_L1)

# MAT CV_8UC1
lut = np.zeros((1, 256), dtype = "uint8")

acum = 0.0
for i in range (0,256):
    lut[0][i] = acum
    acum += hist[i]

res = cv.LUT(img,lut)

cv.imshow("Entrada", img)
cv.imshow("Ecualizada", res)
cv.waitKey(0)
def gamma_transform(img, gamma):
    gamma_table = [np.power(x / 255.0, gamma) * 255.0 for x in range(size)]

    gamma_table = np.round(np.array(gamma_table)).astype(np.uint8)

    return cv2.LUT(img, gamma_table)
Esempio n. 14
0
def gamma(image, gamma=1.0):
    invGamma = 1.0 / gamma
    table = np.array([((i / 255.0)**invGamma) * 255
                      for i in np.arange(0, 256)]).astype("uint8")
    # apply gamma correction using the lookup table
    return cv2.LUT(image, table)
Esempio n. 15
0
    def data_aug(self, data_dict):
        ### image data augmentation ###
        new_img = data_dict['Image']

        angle_aug = random.random() * self.max_rot * 2 - self.max_rot
        scale_aug = random.random() * (self.max_scale - self.min_scale) + \
              self.min_scale

        shift_aug_x = random.random() * \
          (self.max_shift * self.posmap_size) * 2 \
          - (self.max_shift * self.posmap_size)
        shift_aug_y = random.random() * \
          (self.max_shift * self.posmap_size) * 2 \
          - (self.max_shift * self.posmap_size)

        tform = tf.SimilarityTransform(scale=scale_aug,
                                       rotation=np.deg2rad(angle_aug),
                                       translation=(shift_aug_x, shift_aug_y))

        shift_y, shift_x = np.array(new_img.shape[:2]) / 2.
        tf_shift = tf.SimilarityTransform(translation=[-shift_x, -shift_y])
        tf_shift_inv = tf.SimilarityTransform(translation=[shift_x, shift_y])

        new_img = tf.warp(new_img, (tf_shift + (tform + tf_shift_inv)).inverse)

        # fill blank
        border_value = np.mean(new_img[ :3, :], axis=(0, 1)) * 0.25 + \
              np.mean(new_img[-3:, :], axis=(0, 1)) * 0.25 + \
              np.mean(new_img[:, -3:], axis=(0, 1)) * 0.25 + \
              np.mean(new_img[:,  :3], axis=(0, 1)) * 0.25

        mask = np.sum(new_img.reshape(-1, 3), axis=1) == 0
        mask = mask[:, np.newaxis]
        mask = np.concatenate((mask, mask, mask), axis=1)
        border_value = np.repeat(border_value[np.newaxis, :],
                                 mask.shape[0],
                                 axis=0)
        border_value *= mask
        new_img = (new_img.reshape(-1, 3) + border_value)
        new_img = new_img.reshape(self.img_size, self.img_size, 3)
        new_img = (new_img * 255.).astype('uint8')

        # gamma correlation
        gamma = random.random() * (1.8 - 1.0) + 1.0
        invGamma = 1.0 / gamma
        table = np.array([((i / 255.0)**invGamma) * 255
                          for i in np.arange(0, 256)]).astype(np.uint8)
        new_img = cv2.LUT(new_img, table)

        # noise
        noise_aug = random.random() * self.max_noise_var
        new_img = (skimage.util.random_noise(
            new_img, mode="gaussian", var=noise_aug) * 255).astype(np.uint8)

        # blur
        blur_aug = random.randint(self.min_blur_resize, self.img_size)
        new_img = cv2.resize(cv2.resize(new_img, (blur_aug, blur_aug)),
                             (self.img_size, self.img_size))

        # gray
        if random.random() < 0.2:
            new_img = cv2.cvtColor(new_img, cv2.COLOR_BGR2GRAY)
            new_img = np.stack((new_img, ) * 3, axis=-1)

        data_dict['Image'] = new_img

        # aug posmap
        posmap = data_dict['Posmap']
        vertices = np.reshape(posmap, [-1, 3]).T
        z = vertices[2, :].copy() / tform.params[0, 0]
        vertices[2, :] = 1
        vertices = np.dot((tf_shift + (tform + tf_shift_inv)).params, vertices)
        vertices = np.vstack((vertices[:2, :], z))
        posmap = np.reshape(vertices.T,
                            [self.posmap_size, self.posmap_size, 3])
        data_dict['Posmap'] = posmap

        return data_dict