dataPath = "../Data_postiveOnly/"

import os

print(os.getcwd())

import imgaug as ia

import skimage.io

import errno

import numpy as np

import skimage.color as color

#import matplotlib.pyplot as plt

import os

#from skimage.color import gray2rgb

def bboxSetupInImage(datapath, txtFile, img):

    """

    This is the function that reads in the bounding box files and then using imgaug to set up the bounding box on images

    :param txtFile: the txt file that store bounding box information

    :param img: the image file variable to represent the img to be plotted bounding box on it

    :return bbs: the image with bounding box in it

    """

    with open(datapath + 'bounding_boxes/' + txtFile, 'r') as f:

        content = [line.rstrip('\n') for line in f]

        iaBBoxList = []

        for bbline in content:

            bbox = bbline.strip().split()

            # print(bbox[1])

            if len(bbox) == 4:

                iaBBoxList.append(ia.BoundingBox(

                    x1=float(bbox[1]),

                    y1=float(bbox[0]),

                    x2=float(bbox[3]),

                    y2=float(bbox[2])))

        bbs = ia.BoundingBoxesOnImage(iaBBoxList, shape=img.shape)

        return bbs

def saveAugbbox2TXT(txtFile, bbs):

    """

    This is the function that save the augmented bounding box files into ChainerCV bbox format

    :param txtFile: the txt file that want to save

    :param bbs: bounding box lists

    """

    with open('' + txtFile, 'w') as f:

        for i in range(len(bbs.bounding_boxes)):

            bb = bbs_aug.bounding_boxes[i]

            # print("%s %.2f %.2f %.2f %.2f"%(bb.label,bb.y1,bb.x1,bb.y2,bb.x2))

            f.write("%.2f %.2f %.2f %.2f\n" % ( bb.y1, bb.x1, bb.y2, bb.x2))

def getImageList(imageTXT):

    """

    Function to loop the testing images for test

    :param imageTXT: the txt that stores the

    :return: imageFileList: the list contains all the original test image list

    """

    imageFileList = list()

    with open(imageTXT,'r') as f:

        lines = f.readlines()

        for line in lines:

            imageFileList.append(line.strip())

    return imageFileList

def createFolder(folderName):

    """

    Safely create folder when needed

    :param folderName : the directory that you  want to safely create

    :return: None

    """

    if not os.path.exists(folderName):

        try:

            os.makedirs(folderName)

        except OSError as exc:  # Guard against race condition

            if exc.errno != errno.EEXIST:

                raise

##################################################

# 1. Define data augmentation operations

##################################################

trainImageTxtFile = dataPath + "trainimages.txt"

imageList = getImageList(trainImageTxtFile)

current_operation = "GaussianNoise"

# Add gaussian noise.

# For 50% of all images, we sample the noise once per pixel.

# For the other 50% of all images, we sample the noise per pixel AND

# channel. This can change the color (not only brightness) of the

# pixels.

from imgaug import augmenters as iaa

ia.seed(1)

seq = iaa.Sequential([

    iaa.AdditiveGaussianNoise(loc=0,

                              scale=(0.0, 0.01 * 255),

                              per_channel=0.5)

])

# seq = iaa.Sequential([

#     # Adjust contrast by scaling each pixel value to (I_ij/255.0)**gamma.

#     # Values in the range gamma=(0.5, 2.0) seem to be sensible.

#     iaa.GammaContrast((0.5, 1.5))

# ])

# Make our sequence deterministic.

# We can now apply it to the image and then to the BBs and it will

# lead to the same augmentations.

# IMPORTANT: Call this once PER BATCH, otherwise you will always get the exactly same augmentations for every batch!

seq_det = seq.to_deterministic()

##################################################

# 2. loop through images

##################################################

for img in imageList:

    print(img)

    # Grayscale images must have shape (height, width, 1) each.

    # print(os.listdir(dataPath+'images/'))

    currentimage = skimage.io.imread(dataPath + 'images/' + img).astype(np.uint8)

    # gray2rgb() simply duplicates the gray values over the three color channels.

    currentimage = color.gray2rgb(currentimage)

    bbs = bboxSetupInImage(dataPath, img.rstrip('.jpg') + '.txt', currentimage)

    # Augment BBs and images.

    # As we only have one image and list of BBs, we use

    # [image] and [bbs] to turn both into lists (batches) for the# functions and then [0] to reverse that. In a real experiment, your

    # variables would likely already be lists.

    image_aug = seq_det.augment_images([currentimage])[0]

    bbs_aug = seq_det.augment_bounding_boxes([bbs])[0]

    print(bbs_aug)

    augImgFolder = current_operation + "Images"

    augTxTFolder = current_operation + "TXT"

    createFolder(augImgFolder)

    createFolder(augTxTFolder)

    # Save aug images and bboxes

    skimage.io.imsave(augImgFolder + '/' +

                      img.rstrip('.jpg') +

                      '_' + current_operation +

                      '.jpg'

                      , image_aug)

    saveAugbbox2TXT(augTxTFolder + '/' +

                    img.rstrip('.jpg') +

                    '_' + current_operation +

                    '.txt', bbs_aug)

    # image with BBs before/after augmentation (shown below)

    # image_before = bbs.draw_on_image(currentimage, thickness=2)

    # image_after = bbs_aug.draw_on_image(image_aug,

    # thickness=2, color=[0, 0, 255])

    # image with BBs before/after augmentation (shown below)

    # plot and save figures before and after data augmentations

    # skimage.io.imshow(image_before)

    # skimage.io.imshow(image_after)

    # for i in range(len(bbs.bounding_boxes)):

    #     before = bbs.bounding_boxes[i]

    #     after = bbs_aug.bounding_boxes[i]

    #     print("BB %d: (%.4f, %.4f, %.4f, %.4f) -> (%.4f, %.4f, %.4f, %.4f)" % (

    #         i,

    #         before.x1, before.y1, before.x2, before.y2,

    #         after.x1, after.y1, after.x2, after.y2)

    #     )

##################################################

# 1. Define data augmentation operations

##################################################

trainImageTxtFile = dataPath + "trainimages.txt"

imageList = getImageList(trainImageTxtFile)

current_operation = "GaussianBlur"

# blur images with a sigma of 0 to 3.0

from imgaug import augmenters as iaa

ia.seed(1)

seq = iaa.Sequential([

  iaa.GaussianBlur(sigma=(0, 3))

])

# seq = iaa.Sequential([

#     # Adjust contrast by scaling each pixel value to (I_ij/255.0)**gamma.

#     # Values in the range gamma=(0.5, 2.0) seem to be sensible.

#     iaa.GammaContrast((0.5, 1.5))

# ])

# Make our sequence deterministic.

# We can now apply it to the image and then to the BBs and it will

# lead to the same augmentations.

# IMPORTANT: Call this once PER BATCH, otherwise you will always get the exactly same augmentations for every batch!

seq_det = seq.to_deterministic()

##################################################

# 2. loop through images

##################################################

for img in imageList:

    print(img)

    # Grayscale images must have shape (height, width, 1) each.

    #print(os.listdir(dataPath+'images/'))

    currentimage = skimage.io.imread(dataPath+'images/'+img).astype(np.uint8)

    # gray2rgb() simply duplicates the gray values over the three color channels.

    currentimage = color.gray2rgb(currentimage)

    bbs = bboxSetupInImage(dataPath , img.rstrip('.jpg') + '.txt',currentimage)

    # Augment BBs and images.

    # As we only have one image and list of BBs, we use

    # [image] and [bbs] to turn both into lists (batches) for the# functions and then [0] to reverse that. In a real experiment, your

    # variables would likely already be lists.

    image_aug = seq_det.augment_images([currentimage])[0]

    bbs_aug = seq_det.augment_bounding_boxes([bbs])[0]

    augImgFolder = current_operation + "Images"

    augTxTFolder = current_operation + "TXT"

    createFolder(augImgFolder)

    createFolder(augTxTFolder)

    # Save aug images and bboxes

    skimage.io.imsave(augImgFolder + '/'+

                      img.rstrip('.jpg') +

                      '_' + current_operation +

                      '.jpg'

                      ,image_aug)

    saveAugbbox2TXT(augTxTFolder+ '/'+

                    img.rstrip('.jpg') +

                    '_'+ current_operation +

                    '.txt',bbs_aug)

    # image with BBs before/after augmentation (shown below)

    # image_before = bbs.draw_on_image(currentimage, thickness=2)

    # image_after = bbs_aug.draw_on_image(image_aug,

    # thickness=2, color=[0, 0, 255])

    # image with BBs before/after augmentation (shown below)

    # plot and save figures before and after data augmentations

    #skimage.io.imshow(image_before)

    #skimage.io.imshow(image_after)

    # for i in range(len(bbs.bounding_boxes)):

    #     before = bbs.bounding_boxes[i]

    #     after = bbs_aug.bounding_boxes[i]

    #     print("BB %d: (%.4f, %.4f, %.4f, %.4f) -> (%.4f, %.4f, %.4f, %.4f)" % (

    #         i,

    #         before.x1, before.y1, before.x2, before.y2,

    #         after.x1, after.y1, after.x2, after.y2)

    #     )

##################################################

# 1. Define data augmentation operations

##################################################

trainImageTxtFile = dataPath + "trainimages.txt"

imageList = getImageList(trainImageTxtFile)

current_operation = "Brightness"

# Strengthen or weaken the contrast in each image.

from imgaug import augmenters as iaa

ia.seed(1)

seq = iaa.Sequential([

    iaa.Multiply((1.2, 1.5))

])

# seq = iaa.Sequential([

#     # Adjust contrast by scaling each pixel value to (I_ij/255.0)**gamma.

#     # Values in the range gamma=(0.5, 2.0) seem to be sensible.

#     iaa.GammaContrast((0.5, 1.5))

# ])

# Make our sequence deterministic.

# We can now apply it to the image and then to the BBs and it will

# lead to the same augmentations.

# IMPORTANT: Call this once PER BATCH, otherwise you will always get the exactly same augmentations for every batch!

seq_det = seq.to_deterministic()

##################################################

# 2. loop through images

##################################################

for img in imageList:

    print(img)

    # Grayscale images must have shape (height, width, 1) each.

    #print(os.listdir(dataPath+'images/'))

    currentimage = skimage.io.imread(dataPath+'images/'+img).astype(np.uint8)

    # gray2rgb() simply duplicates the gray values over the three color channels.

    currentimage = color.gray2rgb(currentimage)

    bbs = bboxSetupInImage(dataPath , img.rstrip('.jpg') + '.txt',currentimage)

    # Augment BBs and images.

    # As we only have one image and list of BBs, we use

    # [image] and [bbs] to turn both into lists (batches) for the# functions and then [0] to reverse that. In a real experiment, your

    # variables would likely already be lists.

    image_aug = seq_det.augment_images([currentimage])[0]

    bbs_aug = seq_det.augment_bounding_boxes([bbs])[0]

    augImgFolder = current_operation + "Images"

    augTxTFolder = current_operation + "TXT"

    createFolder(augImgFolder)

    createFolder(augTxTFolder)

    # Save aug images and bboxes

    skimage.io.imsave(augImgFolder + '/'+

                      img.rstrip('.jpg') +

                      '_' + current_operation +

                      '.jpg'

                      ,image_aug)

    saveAugbbox2TXT(augTxTFolder+ '/'+

                    img.rstrip('.jpg') +

                    '_'+ current_operation +

                    '.txt',bbs_aug)

    # image with BBs before/after augmentation (shown below)

    # image_before = bbs.draw_on_image(currentimage, thickness=2)

    # image_after = bbs_aug.draw_on_image(image_aug,

    # thickness=2, color=[0, 0, 255])

    # image with BBs before/after augmentation (shown below)

    # plot and save figures before and after data augmentations

    #skimage.io.imshow(image_before)

    #skimage.io.imshow(image_after)

    # for i in range(len(bbs.bounding_boxes)):

    #     before = bbs.bounding_boxes[i]

    #     after = bbs_aug.bounding_boxes[i]

    #     print("BB %d: (%.4f, %.4f, %.4f, %.4f) -> (%.4f, %.4f, %.4f, %.4f)" % (

    #         i,

    #         before.x1, before.y1, before.x2, before.y2,

    #         after.x1, after.y1, after.x2, after.y2)

    #     )

##################################################

# 1. Define data augmentation operations

##################################################

trainImageTxtFile = dataPath + "trainimages.txt"

imageList = getImageList(trainImageTxtFile)

current_operation = "Fliplr"

# Flip/mirror input images horizontally.

from imgaug import augmenters as iaa

ia.seed(1)

seq = iaa.Sequential([

    iaa.Fliplr(1.0)

])

# seq = iaa.Sequential([

#     # Adjust contrast by scaling each pixel value to (I_ij/255.0)**gamma.

#     # Values in the range gamma=(0.5, 2.0) seem to be sensible.

#     iaa.GammaContrast((0.5, 1.5))

# ])

# Make our sequence deterministic.

# We can now apply it to the image and then to the BBs and it will

# lead to the same augmentations.

# IMPORTANT: Call this once PER BATCH, otherwise you will always get the exactly same augmentations for every batch!

seq_det = seq.to_deterministic()

##################################################

# 2. loop through images

##################################################

for img in imageList:

    print(img)

    # Grayscale images must have shape (height, width, 1) each.

    # print(os.listdir(dataPath+'images/'))

    currentimage = skimage.io.imread(dataPath + 'images/' + img).astype(np.uint8)

    # gray2rgb() simply duplicates the gray values over the three color channels.

    currentimage = color.gray2rgb(currentimage)

    bbs = bboxSetupInImage(dataPath, img.rstrip('.jpg') + '.txt', currentimage)

    # Augment BBs and images.

    # As we only have one image and list of BBs, we use

    # [image] and [bbs] to turn both into lists (batches) for the# functions and then [0] to reverse that. In a real experiment, your

    # variables would likely already be lists.

    image_aug = seq_det.augment_images([currentimage])[0]

    bbs_aug = seq_det.augment_bounding_boxes([bbs])[0]

    augImgFolder = current_operation + "Images"

    augTxTFolder = current_operation + "TXT"

    createFolder(augImgFolder)

    createFolder(augTxTFolder)

    # Save aug images and bboxes

    skimage.io.imsave(augImgFolder + '/' +

                      img.rstrip('.jpg') +

                      '_' + current_operation +

                      '.jpg'

                      , image_aug)

    saveAugbbox2TXT(augTxTFolder + '/' +

                    img.rstrip('.jpg') +

                    '_' + current_operation +

                    '.txt', bbs_aug)

    # image with BBs before/after augmentation (shown below)

    # image_before = bbs.draw_on_image(currentimage, thickness=2)

    # image_after = bbs_aug.draw_on_image(image_aug,

    # thickness=2, color=[0, 0, 255])

    # image with BBs before/after augmentation (shown below)

    # plot and save figures before and after data augmentations

    # skimage.io.imshow(image_before)

    # skimage.io.imshow(image_after)

    # for i in range(len(bbs.bounding_boxes)):

    #     before = bbs.bounding_boxes[i]

    #     after = bbs_aug.bounding_boxes[i]

    #     print("BB %d: (%.4f, %.4f, %.4f, %.4f) -> (%.4f, %.4f, %.4f, %.4f)" % (

    #         i,

    #         before.x1, before.y1, before.x2, before.y2,

    #         after.x1, after.y1, after.x2, after.y2)

    #     )

##################################################

# 1. Define data augmentation operations

##################################################

trainImageTxtFile = dataPath + "trainimages.txt"

imageList = getImageList(trainImageTxtFile)

current_operation = "Flipud"

# Flip/mirror input images vertically.

from imgaug import augmenters as iaa

ia.seed(1)

seq = iaa.Sequential([

    iaa.Flipud(1.0)

])

# seq = iaa.Sequential([

#     # Adjust contrast by scaling each pixel value to (I_ij/255.0)**gamma.

#     # Values in the range gamma=(0.5, 2.0) seem to be sensible.

#     iaa.GammaContrast((0.5, 1.5))

# ])

# Make our sequence deterministic.

# We can now apply it to the image and then to the BBs and it will

# lead to the same augmentations.

# IMPORTANT: Call this once PER BATCH, otherwise you will always get the exactly same augmentations for every batch!

seq_det = seq.to_deterministic()

##################################################

# 2. loop through images

##################################################

for img in imageList:

    print(img)

    # Grayscale images must have shape (height, width, 1) each.

    # print(os.listdir(dataPath+'images/'))

    currentimage = skimage.io.imread(dataPath + 'images/' + img).astype(np.uint8)

    # gray2rgb() simply duplicates the gray values over the three color channels.

    currentimage = color.gray2rgb(currentimage)

    bbs = bboxSetupInImage(dataPath, img.rstrip('.jpg') + '.txt', currentimage)

    # Augment BBs and images.

    # As we only have one image and list of BBs, we use

    # [image] and [bbs] to turn both into lists (batches) for the# functions and then [0] to reverse that. In a real experiment, your

    # variables would likely already be lists.

    image_aug = seq_det.augment_images([currentimage])[0]

    bbs_aug = seq_det.augment_bounding_boxes([bbs])[0]

    augImgFolder = current_operation + "Images"

    augTxTFolder = current_operation + "TXT"

    createFolder(augImgFolder)

    createFolder(augTxTFolder)

    # Save aug images and bboxes

    skimage.io.imsave(augImgFolder + '/' +

                      img.rstrip('.jpg') +

                      '_' + current_operation +

                      '.jpg'

                      , image_aug)

    saveAugbbox2TXT(augTxTFolder + '/' +

                    img.rstrip('.jpg') +

                    '_' + current_operation +

                    '.txt', bbs_aug)

    # image with BBs before/after augmentation (shown below)

    # image_before = bbs.draw_on_image(currentimage, thickness=2)

    # image_after = bbs_aug.draw_on_image(image_aug,

    # thickness=2, color=[0, 0, 255])

    # image with BBs before/after augmentation (shown below)

    # plot and save figures before and after data augmentations

    # skimage.io.imshow(image_before)

    # skimage.io.imshow(image_after)

    # for i in range(len(bbs.bounding_boxes)):

    #     before = bbs.bounding_boxes[i]

    #     after = bbs_aug.bounding_boxes[i]

    #     print("BB %d: (%.4f, %.4f, %.4f, %.4f) -> (%.4f, %.4f, %.4f, %.4f)" % (

    #         i,

    #         before.x1, before.y1, before.x2, before.y2,

    #         after.x1, after.y1, after.x2, after.y2)

    #     )

##################################################

# 1. Define data augmentation operations

##################################################

trainImageTxtFile = dataPath + "trainimages.txt"

imageList = getImageList(trainImageTxtFile)

current_operation = "Rot90or270Degree"

# Rotates all images by 90 or 270 degrees.

from imgaug import augmenters as iaa

ia.seed(1)

seq = iaa.Sequential([

    iaa.Rot90([1, 3])

])

# seq = iaa.Sequential([

#     # Adjust contrast by scaling each pixel value to (I_ij/255.0)**gamma.

#     # Values in the range gamma=(0.5, 2.0) seem to be sensible.

#     iaa.GammaContrast((0.5, 1.5))

# ])

# Make our sequence deterministic.

# We can now apply it to the image and then to the BBs and it will

# lead to the same augmentations.

# IMPORTANT: Call this once PER BATCH, otherwise you will always get the exactly same augmentations for every batch!

seq_det = seq.to_deterministic()

##################################################

# 2. loop through images

##################################################

for img in imageList:

    print(img)

    # Grayscale images must have shape (height, width, 1) each.

    # print(os.listdir(dataPath+'images/'))

    currentimage = skimage.io.imread(dataPath + 'images/' + img).astype(np.uint8)

    # gray2rgb() simply duplicates the gray values over the three color channels.

    currentimage = color.gray2rgb(currentimage)

    bbs = bboxSetupInImage(dataPath, img.rstrip('.jpg') + '.txt', currentimage)

    # Augment BBs and images.

    # As we only have one image and list of BBs, we use

    # [image] and [bbs] to turn both into lists (batches) for the# functions and then [0] to reverse that. In a real experiment, your

    # variables would likely already be lists.

    image_aug = seq_det.augment_images([currentimage])[0]

    bbs_aug = seq_det.augment_bounding_boxes([bbs])[0]

    augImgFolder = current_operation + "Images"

    augTxTFolder = current_operation + "TXT"

    createFolder(augImgFolder)

    createFolder(augTxTFolder)

    # Save aug images and bboxes

    skimage.io.imsave(augImgFolder + '/' +

                      img.rstrip('.jpg') +

                      '_' + current_operation +

                      '.jpg'

                      , image_aug)

    saveAugbbox2TXT(augTxTFolder + '/' +

                    img.rstrip('.jpg') +

                    '_' + current_operation +

                    '.txt', bbs_aug)

    # image with BBs before/after augmentation (shown below)

    # image_before = bbs.draw_on_image(currentimage, thickness=2)

    # image_after = bbs_aug.draw_on_image(image_aug,

    # thickness=2, color=[0, 0, 255])

    # image with BBs before/after augmentation (shown below)

    # plot and save figures before and after data augmentations

    # skimage.io.imshow(image_before)

    # skimage.io.imshow(image_after)

    # for i in range(len(bbs.bounding_boxes)):

    #     before = bbs.bounding_boxes[i]

    #     after = bbs_aug.bounding_boxes[i]

    #     print("BB %d: (%.4f, %.4f, %.4f, %.4f) -> (%.4f, %.4f, %.4f, %.4f)" % (

    #         i,

    #         before.x1, before.y1, before.x2, before.y2,

    #         after.x1, after.y1, after.x2, after.y2)

    #     )