Add files via upload

Author: jayroxis

blurlab/BoxBlur.py

@@ -0,0 +1,26 @@
+import numpy as np
+from PIL import Image
+import cv2
+
+boxKernelDims = [3,5,7,9]
+
+def BoxBlur_random(img):
+    kernelidx = np.random.randint(0, len(boxKernelDims))    
+    kerneldim = boxKernelDims[kernelidx]
+    return BoxBlur(img, kerneldim)
+
+def BoxBlur(img, dim):
+    imgarray = np.array(img, dtype="float32")
+    kernel = BoxKernel(dim)
+    # convolved = convolve2d(imgarray, kernel, mode='same', fillvalue=255.0).astype("uint8")
+    convolved = cv2.filter2D(imgarray, -1, kernel).astype("uint8")
+    img = Image.fromarray(convolved)
+
+    return img
+
+def BoxKernel(dim):
+    kernelwidth = dim
+    kernel = np.ones((kernelwidth, kernelwidth), dtype=np.float32)        
+    normalizationFactor = np.count_nonzero(kernel)
+    kernel = kernel / normalizationFactor
+    return kernel

blurlab/DefocusBlur.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+import numpy as np
+from PIL import Image
+from skimage.draw import disk
+
+import cv2
+
+defocusKernelDims = [3,5,7,9]
+
+def DefocusBlur_random(img):
+    kernelidx = np.random.randint(0, len(defocusKernelDims))    
+    kerneldim = defocusKernelDims[kernelidx]
+    return DefocusBlur(img, kerneldim)
+
+def DefocusBlur(img, dim):
+    imgarray = np.array(img, dtype="float32")
+    kernel = DiskKernel(dim)
+    # convolved = convolve2d(imgarray, kernel, mode='same', fillvalue=255.0).astype("uint8")
+    convolved = cv2.filter2D(imgarray, -1, kernel).astype("uint8")
+    img = Image.fromarray(convolved)
+    return img
+
+
+def DiskKernel(dim):
+    kernelwidth = dim
+    kernel = np.zeros((kernelwidth, kernelwidth), dtype=np.float32)
+    circleCenterCoord = dim / 2
+    circleRadius = circleCenterCoord +1
+    
+    rr, cc = disk((circleCenterCoord, circleCenterCoord), circleRadius-1)
+    kernel[rr, cc] = 1
+    
+    if(dim == 3 or dim == 5):
+        kernel = Adjust(kernel, dim)
+        
+    normalizationFactor = np.count_nonzero(kernel)
+    kernel = kernel / normalizationFactor
+    return kernel
+
+def Adjust(kernel, kernelwidth):
+    kernel[0,0] = 0
+    kernel[0,kernelwidth-1]=0
+    kernel[kernelwidth-1,0]=0
+    kernel[kernelwidth-1, kernelwidth-1] =0 
+    return kernel

blurlab/GaussianBlur.py

@@ -0,0 +1,13 @@
+import numpy as np
+from PIL import ImageFilter
+
+gaussianbandwidths = [0.5, 1, 1.5, 2, 2.5, 3, 3.5]
+
+def GaussianBlur_random(img):
+    gaussianidx = np.random.randint(0, len(gaussianbandwidths))
+    gaussianbandwidth = gaussianbandwidths[gaussianidx]
+    return GaussianBlur(img, gaussianbandwidth)
+
+def GaussianBlur(img, bandwidth):
+    img = img.filter(ImageFilter.GaussianBlur(bandwidth))
+    return img

blurlab/LineDictionary.py

@@ -0,0 +1,68 @@
+class LineDictionary:
+    def __init__(self):
+        self.lines = {}
+        self.Create3x3Lines()
+        self.Create5x5Lines()
+        self.Create7x7Lines()
+        self.Create9x9Lines()
+        return
+    
+    def Create3x3Lines(self):
+        lines = {}
+        lines[0] = [1,0,1,2]
+        lines[45] = [2,0,0,2]
+        lines[90] = [0,1,2,1]
+        lines[135] = [0,0,2,2]
+        self.lines[3] = lines
+        return
+    
+    def Create5x5Lines(self):
+        lines = {}        
+        lines[0] = [2,0,2,4]
+        lines[22.5] = [3,0,1,4]
+        lines[45] = [0,4,4,0]
+        lines[67.5] = [0,3,4,1]
+        lines[90] = [0,2,4,2]
+        lines[112.5] = [0,1,4,3]
+        lines[135] = [0,0,4,4]
+        lines[157.5]= [1,0,3,4]
+        self.lines[5] = lines
+        return
+        
+    def Create7x7Lines(self):
+        lines = {}
+        lines[0] = [3,0,3,6]
+        lines[15] = [4,0,2,6]
+        lines[30] = [5,0,1,6]
+        lines[45] = [6,0,0,6]
+        lines[60] = [6,1,0,5]
+        lines[75] = [6,2,0,4]
+        lines[90] = [0,3,6,3]
+        lines[105] = [0,2,6,4]
+        lines[120] = [0,1,6,5]
+        lines[135] = [0,0,6,6]
+        lines[150] = [1,0,5,6]
+        lines[165] = [2,0,4,6]
+        self.lines[7] = lines 
+        return
+    
+    def Create9x9Lines(self):
+        lines = {}
+        lines[0] = [4,0,4,8]
+        lines[11.25] = [5,0,3,8]
+        lines[22.5] = [6,0,2,8]
+        lines[33.75] = [7,0,1,8]
+        lines[45] = [8,0,0,8]
+        lines[56.25] = [8,1,0,7]
+        lines[67.5] = [8,2,0,6]
+        lines[78.75] = [8,3,0,5]
+        lines[90] = [8,4,0,4]
+        lines[101.25] = [0,3,8,5]
+        lines[112.5] = [0,2,8,6]
+        lines[123.75] = [0,1,8,7]
+        lines[135] = [0,0,8,8]
+        lines[146.25] = [1,0,7,8]
+        lines[157.5] = [2,0,6,8]
+        lines[168.75] = [3,0,5,8]
+        self.lines[9] = lines
+        return

blurlab/LinearMotionBlur.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+import math
+import numpy as np
+from PIL import Image
+from skimage.draw import line
+
+from .LineDictionary import LineDictionary
+import cv2
+
+lineLengths =[3,5,7,9]
+lineTypes = ["full", "right", "left"]
+
+lineDict = LineDictionary()
+
+def LinearMotionBlur_random(img):
+    lineLengthIdx = np.random.randint(0, len(lineLengths))
+    lineTypeIdx = np.random.randint(0, len(lineTypes)) 
+    lineLength = lineLengths[lineLengthIdx]
+    lineType = lineTypes[lineTypeIdx]
+    lineAngle = randomAngle(lineLength)
+    return LinearMotionBlur(img, lineLength, lineAngle, lineType)
+
+def LinearMotionBlur(img, dim, angle, linetype):
+    imgarray = np.array(img, dtype="float32")
+    kernel = LineKernel(dim, angle, linetype)
+    convolved = cv2.filter2D(imgarray, -1, kernel).astype("uint8")
+    img = Image.fromarray(convolved)
+    return img
+
+def LineKernel(dim, angle, linetype):
+    kernelwidth = dim
+    kernelCenter = int(math.floor(dim/2))
+    angle = SanitizeAngleValue(kernelCenter, angle)
+    kernel = np.zeros((kernelwidth, kernelwidth), dtype=np.float32)
+    lineAnchors = lineDict.lines[dim][angle]
+    if(linetype == 'right'):
+        lineAnchors[0] = kernelCenter
+        lineAnchors[1] = kernelCenter
+    if(linetype == 'left'):
+        lineAnchors[2] = kernelCenter
+        lineAnchors[3] = kernelCenter
+    rr,cc = line(lineAnchors[0], lineAnchors[1], lineAnchors[2], lineAnchors[3])
+    kernel[rr,cc]=1
+    normalizationFactor = np.count_nonzero(kernel)
+    kernel = kernel / normalizationFactor        
+    return kernel
+
+def SanitizeAngleValue(kernelCenter, angle):
+    numDistinctLines = kernelCenter * 4
+    angle = math.fmod(angle, 180.0)
+    validLineAngles = np.linspace(0,180, numDistinctLines, endpoint = False)
+    angle = nearestValue(angle, validLineAngles)
+    return angle
+
+def nearestValue(theta, validAngles):
+    idx = (np.abs(validAngles-theta)).argmin()
+    return validAngles[idx]
+
+def randomAngle(kerneldim):
+    kernelCenter = int(math.floor(kerneldim/2))
+    numDistinctLines = kernelCenter * 4
+    validLineAngles = np.linspace(0,180, numDistinctLines, endpoint = False)
+    angleIdx = np.random.randint(0, len(validLineAngles))
+    return int(validLineAngles[angleIdx])

blurlab/PsfBlur.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+import numpy as np
+import pickle
+from PIL import Image
+import cv2
+import os.path
+
+pickledPsfFilename =os.path.join(os.path.dirname( __file__),"psf.pkl")
+
+with open(pickledPsfFilename, 'rb') as pklfile:
+    psfDictionary = pickle.load(pklfile, encoding='latin1')
+
+
+def PsfBlur(img, psfid):
+    imgarray = np.array(img, dtype="float32")
+    kernel = psfDictionary[psfid]
+    convolved = cv2.filter2D(imgarray, -1, kernel).astype("uint8")
+    img = Image.fromarray(convolved)
+    return img
+    
+def PsfBlur_random(img):
+    psfid = np.random.randint(0, len(psfDictionary))
+    return PsfBlur(img, psfid)
+    
+    

blurlab/RandomizedBlur.py

@@ -0,0 +1,12 @@
+import numpy as np
+from .BoxBlur import BoxBlur_random
+from .DefocusBlur import  DefocusBlur_random
+from .GaussianBlur import GaussianBlur_random
+from .LinearMotionBlur import LinearMotionBlur_random
+from .PsfBlur import PsfBlur_random
+
+blurFunctions = {"0": BoxBlur_random, "1": DefocusBlur_random, "2": GaussianBlur_random, "3": LinearMotionBlur_random, "4": PsfBlur_random}
+
+def RandomizedBlur(img):
+    blurToApply = blurFunctions[str(np.random.randint(0, len(blurFunctions)))]
+    return blurToApply(img)

blurlab/__init__.py

@@ -0,0 +1,13 @@
+from .BoxBlur import BoxBlur, BoxBlur_random
+from .DefocusBlur import DefocusBlur, DefocusBlur_random
+from .GaussianBlur import GaussianBlur, GaussianBlur_random
+from .LinearMotionBlur import LinearMotionBlur, LinearMotionBlur_random
+from .PsfBlur import PsfBlur, PsfBlur_random
+from .RandomizedBlur import RandomizedBlur
+
+__all__ = ["BoxBlur", "BoxBlur_random", 
+           "DefocusBlur", "DefocusBlur_random",
+           "GaussianBlur", "GaussianBlur_random",
+           "LinearMotionBlur", "LinearMotionBlur_random",
+           "PsfBlur", "PsfBlur_random",
+           "RandomizedBlur"]