def edgeDetectionSobel(img: np.ndarray, thresh: float = 0.2) -> (np.ndarray, np.ndarray):
    """
    Detects edges using the Sobel method
    :param img: Input image
    :param thresh: The minimum threshold for the edge response
    :return: opencv solution, my implementation
    """
    s = np.array([[1, 0, -1],
                  [2, 0, -2],
                  [1, 0, -1]])

    thresh *= 255
    # my_res = np.sqrt((conv2D(img, s) ** 2 + conv2D(img, s.transpose()) ** 2))
    my_res = np.sqrt((cv.filter2D(img, -1, s, borderType=cv.BORDER_REPLICATE) ** 2 + cv.filter2D(img, -1, s.transpose(),
                                                                                                 borderType=cv.BORDER_REPLICATE) ** 2))
    my = np.ndarray(my_res.shape)
    my[my_res > thresh] = 1
    my[my_res < thresh] = 0

    cv_res = cv.magnitude(cv.Sobel(img, -1, 1, 0), cv.Sobel(img, -1, 0, 1))
    v = np.ndarray(cv_res.shape)
    v[cv_res > thresh] = 1
    v[cv_res < thresh] = 0

    return cv_res, my_res
Beispiel #2
0
def encode_as_struct_elems(image):
    """
     Encode input image as an array of simple fixes sized square shaped structural elements.
    """
    # encoding params
    anchor_pos = (-1, -1)

    # structural element params
    elem_size = 30  # only a single value required to describe a square shaped structural element
    elem_cg_dist_threshold = 4  # max dist of the CG of the structural element from its center
    elem_mass_threshold = 0.1  # min required active fraction of the mass within the structural element

    mask_vals = np.array([np.arange(0, elem_size)])
    mask_col = np.repeat(mask_vals, elem_size, axis=0)
    mask_row = np.array(mask_col).T
    mask_ones = np.ones([elem_size, elem_size])

    tmp_img = np.array(image, dtype=np.uint64)

    row_conv = cv2.filter2D(tmp_img, -1, mask_row, anchor=anchor_pos)
    col_conv = cv2.filter2D(tmp_img, -1, mask_col, anchor=anchor_pos)
    ones_conv = cv2.filter2D(tmp_img, -1, mask_ones, anchor=anchor_pos).astype(
        np.float64) + 1e-6

    result_img_row = np.divide(row_conv, ones_conv)
    result_img_col = np.divide(col_conv, ones_conv)
    result_cg = np.stack([result_img_row, result_img_col], axis=2)

    result_cg_dist = np.sqrt(
        np.sum(np.power(result_cg - (elem_size / 2), 2), axis=2))
    result_cg_thresh_dist_mask = result_cg_dist <= elem_cg_dist_threshold  # get mask before calculating complement.
    result_cg_dist = 1 - scale_to_unit(
        result_cg_dist)  # Sub from 1 to get CG distance complement.
    return np.multiply(result_cg_dist, result_cg_thresh_dist_mask)
def editor(img, num):
    vvar = che49.get()
    hvar = che50.get()
    svar = che51.get()
    global output
    if num != 0:
        if vvar == 1 and hvar == 1:
            kernel_3 = np.ones((num, num), dtype=np.float32) / (num * num)
            output = cv2.filter2D(img, -1, kernel_3)
            # print('output', output)

        elif hvar == 1:
            h_blur = np.zeros((num, num))
            h_blur[num // 2, :] = np.ones(num)
            h_blur = h_blur / num
            output = cv2.filter2D(img, -1, h_blur)
            # print('output', output)

        elif vvar == 1:
            v_blur = np.zeros((num, num))
            v_blur[:, num // 2] = np.ones(num)
            v_blur = v_blur / num
            output = cv2.filter2D(img, -1, v_blur)

        elif svar == 1:
            output = unsharp_mask(img, (5, 5), 2, num, 0)
            # print('output', output)

    else:
        output = img
    return output
def AreaMuSigma(img,R):
    img = np.array(img,dtype = float)
    h = np.ones((2*R+1,2*R+1))
    n = h.sum()
    c1 = cv2.filter2D(img**2, -1, h/n, borderType=cv2.BORDER_REFLECT)
    mean = cv2.filter2D(img, -1, h/n, borderType=cv2.BORDER_REFLECT)
    c2 = mean**2
    J = np.sqrt( np.maximum(c1-c2,0) )
    return mean,J
Beispiel #5
0
def extractingShape(img_path, cell_size=8, block_size=2, bins=9):
    img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)
    img = cv2.resize(src=img, dsize=(64, 128))
    h, w = img.shape  # 128, 64

    # gradient
    xkernel = np.array([[-1, 0, 1]])
    ykernel = np.array([[-1], [0], [1]])
    dx = cv2.filter2D(img, cv2.CV_32F, xkernel)
    dy = cv2.filter2D(img, cv2.CV_32F, ykernel)

    # histogram
    magnitude = np.sqrt(np.square(dx) + np.square(dy))
    orientation = np.arctan(np.divide(dy, dx + 0.00001))  # radian
    orientation = np.degrees(orientation)  # -90 -> 90
    orientation += 90  # 0 -> 180

    num_cell_x = w // cell_size  # 8
    num_cell_y = h // cell_size  # 16

    hist_tensor = np.zeros([num_cell_y, num_cell_x, bins])  # 16 x 8 x 9
    for cx in range(num_cell_x):
        for cy in range(num_cell_y):
            ori = orientation[cy * cell_size:cy * cell_size + cell_size,
                              cx * cell_size:cx * cell_size + cell_size]
            mag = magnitude[cy * cell_size:cy * cell_size + cell_size,
                            cx * cell_size:cx * cell_size + cell_size]
            hist, _ = np.histogram(ori, bins=bins, range=(0, 180),
                                   weights=mag)  # 1-D vector, 9 elements
            hist_tensor[cy, cx, :] = hist
        pass
    pass

    # normalization
    redundant_cell = block_size - 1
    feature_tensor = np.zeros([
        num_cell_y - redundant_cell, num_cell_x - redundant_cell,
        block_size * block_size * bins
    ])
    for bx in range(num_cell_x - redundant_cell):  # 7
        for by in range(num_cell_y - redundant_cell):  # 15
            by_from = by
            by_to = by + block_size
            bx_from = bx
            bx_to = bx + block_size
            v = hist_tensor[
                by_from:by_to,
                bx_from:bx_to, :].flatten()  # to 1-D array (vector)
            feature_tensor[by, bx, :] = v / LA.norm(v, 2)
            np.seterr(divide='ignore', invalid='ignore')
            # avoid NaN:
            if np.isnan(
                    feature_tensor[by,
                                   bx, :]).any():  # avoid NaN (zero division)
                feature_tensor[by, bx, :] = v

    return feature_tensor.flatten()  # 3780 features
Beispiel #6
0
def calculate_weight_map(tar_img, ref_img, mask):
    tar_img_YUV = cv2.GaussianBlur(cv2.cvtColor(tar_img, cv2.COLOR_BGR2YUV),
                                   (5, 5), 10)
    ref_img_YUV = cv2.GaussianBlur(cv2.cvtColor(ref_img, cv2.COLOR_BGR2YUV),
                                   (5, 5), 10)
    tar_img_Y = tar_img_YUV[:, :, 0]
    ref_img_Y = ref_img_YUV[:, :, 0]

    YUV_diff = np.abs(tar_img_YUV - ref_img_YUV)
    color_diff = cv2.convertScaleAbs(YUV_diff[:, :, 0] * 0.5 +
                                     YUV_diff[:, :, 1] * 0.25 +
                                     YUV_diff[:, :, 2] * 0.25)
    color_diff[mask.overlap == 0] = 0

    print('finish YUV_diff')

    grad_diff_mag = getGradDiff(tar_img_Y, ref_img_Y)
    grad_diff_mag[mask.overlap == 0] = 0
    print('finish grad_diff')

    color_grad_diff_sum = grad_diff_mag * 100 + color_diff

    filter_bank = getGarborFilterBank(tar_img_Y, ref_img_Y)
    # print('finish gabor filter bank')

    h, w = tar_img_Y.shape
    tar_result = np.zeros((h, w))
    for i in range(len(filter_bank)):
        temp = cv2.filter2D(tar_img_Y, cv2.CV_64FC1, filter_bank[i])
        tar_result += temp**2
    tar_result = np.sqrt(tar_result)
    tar_result[mask.overlap == 0] = 0
    print('finish gabor feature target')

    ref_result = np.zeros((h, w))
    for i in range(len(filter_bank)):
        temp = cv2.filter2D(ref_img_Y, cv2.CV_64FC1, filter_bank[i])
        ref_result += temp**2

    ref_result = np.sqrt(ref_result)
    ref_result[mask.overlap == 0] = 0
    print('finish gabor feature reference')

    gabor_result = ref_result + tar_result

    weight_map = np.multiply(gabor_result, color_grad_diff_sum)
    print('finish weight map')

    # cv2.imwrite('./YUV_diff.png',color_diff)
    # cv2.imwrite('./gradian_diff.png',(grad_diff_mag/np.max(grad_diff_mag)*255).astype(np.uint8))
    # cv2.imwrite('./color_grad_diff.png',(color_grad_diff_sum/np.max(color_grad_diff_sum)*255).astype(np.uint8))
    # cv2.imwrite(f'./gabor/ref_gobar_final.png',(ref_result/np.max(ref_result)*255).astype(np.uint8) )
    # cv2.imwrite(f'./gabor/gobar_final.png',(gabor_result/np.max(gabor_result)*255).astype(np.uint8) )
    # cv2.imwrite(f'./gabor/tar_gobar_final.png',(tar_result/np.max(tar_result)*255).astype(np.uint8) )
    # cv2.imwrite(f'./gabor/W_final.png',(weight_map-np.mean(weight_map))/np.std(weight_map)*255)
    return weight_map
Beispiel #7
0
def apply_prewitt(img, *params):
    img = cv2.GaussianBlur(img, (3, 3), cv2.BORDER_DEFAULT)
    img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)

    kernel_x = np.array([[1, 1, 1], [0, 0, 0], [-1, -1, -1]])
    kernel_y = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]])

    prewittx = cv2.filter2D(img, -1, kernel_x)
    prewitty = cv2.filter2D(img, -1, kernel_y)

    return prewittx + prewitty
def edgeDetectionSobel(I: np.ndarray) -> (np.ndarray, np.ndarray):
    Gx = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])
    Gy = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]])

    Gcx = cv2.filter2D(I, -1, Gx)
    Gcy = cv2.filter2D(I, -1, Gy)

    rs = np.matmul(Gcx, Gcx) + np.matmul(Gcy, Gcy)

    rs = np.sqrt(rs)
    return rs
Beispiel #9
0
def hist_extract(image, handHist):
    hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
    dst = cv2.calcBackProject([hsv], [0, 1], handHist, [0, 180, 0, 256], 1)
    disc = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (21, 21))
    cv2.filter2D(dst, -1, disc, dst)
    # dst is now a probability map
    # Use binary thresholding to create a map of 0s and 1s
    # 1 means the pixel is part of the hand and 0 means not
    ret, thresh = cv2.threshold(dst, 150, 255, cv2.THRESH_BINARY)
    kernel = np.ones((5, 5), np.uint8)
    thresh = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel, iterations=8)
    #thresh = cv2.merge((thresh, thresh, thresh))
    return thresh
Beispiel #10
0
def prewitt():
    image = imageInit
    image = grayScale()

    edged_gaussian = cv2.GaussianBlur(image, (3, 3), 0)

    kernelx = np.array([[1, 1, 1], [0, 0, 0], [-1, -1, -1]])
    kernely = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]])
    img_prewittx = cv2.filter2D(edged_gaussian, -1, kernelx)
    img_prewitty = cv2.filter2D(edged_gaussian, -1, kernely)

    edged = img_prewittx + img_prewitty
    show_img(ImageTk.PhotoImage(Img.fromarray(edged)))
def convDerivative(inImage: np.ndarray) -> np.ndarray:
    kernel = np.array([[1, 0, -1], [1, 0, -1], [1, 0, -1]])
    rows = cv2.filter2D(inImage, -1, kernel)
    cols = cv2.filter2D(inImage, -1, np.transpose(kernel))
    rows = rows * rows
    cols = cols * cols
    power = rows * rows + cols * cols

    for i in range(0, power.shape[0]):
        for j in range(0, power.shape[1]):
            power[i, j] = power[i, j]**(0.5)

    cv2.imshow("myImage", power)
    cv2.waitKey(0)
Beispiel #12
0
    def get_driver_dlib(self, image):
        try:
            # get faces in image
            gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)  # gray image

            #faces = self.get_faces(self.face_net, image)
            #faces = self.face_cascade.detectMultiScale(gray, 1.3, 5)

            #faces = self.detector(gray, 1)
            img = image.copy()
            img = cv.filter2D(img, -1, kernel=np.array([[0, -1, 0], [-1, 5.5, -1], [0, -1, 0]], np.float32))

            # Convert to RGB image compatible to dlib.load_rgb_image(f)
            # http://dlib.net/face_landmark_detection.py.html
            img = img[:, :, [2, 1, 0]]  # BGR => RGB
            
            #faces = self.detector(img, 1)
            faces = self.detector(img)

        except Exception as ex:
            print("Exception in detect_image: %s" % ex)
            faces = None

        face = None
        area = 0
        for i in faces:
            face_area = (i.right() - i.left() + 1) * (i.bottom() - i.top() + 1)
            if face_area > area:
                face = i
                area = face_area
        
        return face
Beispiel #13
0
def sharpening(image_in):
    alpha = 1  # 扩散系数
    kernel = np.array([[0, 0, 0], [0, 1, 0], [0, 0, 0]],
                      np.float32) + alpha * np.array(
                          [[0, -1, 0], [-1, 4, -1], [0, -1, 0]], np.float32)
    image_out = cv2.filter2D(image_in, -1, kernel=kernel)
    return image_out
Beispiel #14
0
def blur_(images, m=2):
    # 設置3x3矩陣每個元素為1/9
    r = 5
    kernel = np.ones((r, r), np.float32) / (r * r)
    out = []

    if m == 1:
        for i in range(len(images)):
            # 將圖片經過3x3矩陣平均模糊化去雜訊
            dst = cv2.filter2D(images[i], -1, kernel)
            out.append(dst)

    elif m == 2:
        for i in range(len(images)):
            # 將圖片經過3x3矩陣平均模糊化去雜訊
            dst = cv2.medianBlur(images[i], r)
            out.append(dst)

    else:
        for i in range(len(images)):
            # 將圖片做高斯模糊化去雜訊
            dst = cv2.GaussianBlur(images[i], (r, r), 1)
            out.append(dst)

    return out
def ireduce(image):
    out = None
    h = np.array([1, 4, 6, 4, 1]) / 16
    filt = (h.T).dot(h)
    outimage = cv2.filter2D(image, cv2.CV_64F, filt)
    out = outimage[::2, ::2]
    return out
def edgeDetectionCanny(I: np.ndarray) -> (np.ndarray, np.ndarray):
    #https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_imgproc/py_canny/py_canny.html
    #first blur the image
    I = blurImage2(I, 5)

    #claculate magnitude and angle
    Gx = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])
    Gy = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]])

    Gcx = cv2.filter2D(I, -1, Gx)
    Gcy = cv2.filter2D(I, -1, Gy)

    rs = np.matmul(Gcx, Gcx) + np.matmul(Gcy, Gcy)

    rs = np.sqrt(rs)
    angle = np.arctan(Gcx / Gcy)
Beispiel #17
0
def edgeDetectionZeroCrossingSimple(img: np.ndarray) -> (np.ndarray):
    """
    Detecting edges using the "ZeroCrossing" method
    :param I: Input image
    :return: Edge matrix
    """
    k = np.array([[0, 1, 0],
                  [1, -4, 1],
                  [0, 1, 0]])
    d = cv.filter2D(img, -1, k, borderType=cv.BORDER_REPLICATE)
    res = np.zeros(d.shape)

    # Check for a zero crossing around (x,y)
    for i in range(0, d.shape[0]):
        for j in range(0, d.shape[1]):
            try:
                if d[i, j] == 0:
                    if (d[i, j + 1] > 0 and d[i, j - 1] < 0) or (d[i, j + 1] < 0 and d[i, j - 1] > 0) or (
                            d[i + 1, j] > 0 and d[i - 1, j] < 0) or (d[i + 1, j] < 0 and d[i - 1, j] > 0):
                        res[i, j] = 1
                elif d[i, j] > 0:
                    if d[i, j + 1] < 0 or d[i + 1, j] < 0:
                        res[i, j] = 1
                else:
                    if d[i, j + 1] > 0 or d[i + 1, j] > 0:
                        res[i, j] = 1

            except IndexError as e:
                pass
    return res
def blurImage1(inImage: np.ndarray, kernelSize: np.ndarray) -> np.ndarray:
    kernel = CreateBlurKernel(kernelSize)
    #rs = conv2D(inImage, kernel)
    rs = cv2.filter2D(inImage, -1, kernel)
    cv2.imshow("myImage", rs)
    cv2.waitKey(0)
    return rs
 def keskinlestir(self):
     if self.tmp is not None:
         sharpenKernel = np.array(
             ([[0, -1, 0], [-1, 9, -1], [0, -1, 0]]), np.float32) / 9
         sharpen = cv2.filter2D(src=self.tmp,
                                kernel=sharpenKernel,
                                ddepth=-1)
         self.setPhoto(sharpen)
 def convolution(image, filters):
     result = np.zeros_like(image, dtype=float)
     # Normalize images for better comparison.
     # image = (image - image.mean()) // image.std()
     for kern in filters:
         fimg = cv2.filter2D(image, cv2.CV_64FC3, kern)
         np.maximum(result, fimg, result)
     return result
def gaborFilter(img):
    cvimg = np.array(img.convert("L"))
    g_kernel = cv2.getGaborKernel((11, 11), 8.0, np.pi/4, 10.0, 0.5, 0, ktype=cv2.CV_32F)

    filtered_img = cv2.filter2D(cvimg, cv2.CV_8UC3, g_kernel)
    #h, w = g_kernel.shape[:2]
    #g_kernel = cv2.resize(filtered_img, (3*w, 3*h), interpolation=cv2.INTER_CUBIC)
    return Image.fromarray(filtered_img).convert('L')
Beispiel #22
0
def gray_to_gradient(img):
    if len(img.shape) == 3:
        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # row, column = img.shape[0], img.shape[1]
    img_f = np.copy(img)
    img_f = img_f.astype("float")

    kernel_horizontal = np.array([[0, 0, 0],
                                  [0, -1., 1.],
                                  [0, 0, 0]])
    kernel_vertical = np.array([[0, 0, 0],
                                [0, -1., 0],
                                [0, 1., 0]])
    dst1 = abs(cv2.filter2D(img_f, -1, kernel_horizontal))
    dst2 = abs(cv2.filter2D(img_f, -1, kernel_vertical))
    gradient = (dst1 + dst2).astype("uint8")

    return gradient
Beispiel #23
0
def custom_demo(image):
    kernel = np.array([[
        1,
        1,
        1,
    ], [1, -8, 1], [1, 1, 1]])
    dst = cv.filter2D(image, cv.CV_32F, kernel=kernel)
    custom = cv.convertScaleAbs(dst)
    cv.imshow("result", custom)
Beispiel #24
0
def addWeighted(img):
    #    img = color2gray(img)
    #    img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
    #    blur_img = cv2.GaussianBlur(img, (0,0), 25)
    #    usm = cv2.addWeighted(img, 1.5, blur_img, -0.5, 0)
    #    img = cv2.cvtColor(usm, cv2.COLOR_BGR2GRAY)
    #    return img
    kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]], np.float32)  #锐化
    return cv2.filter2D(img, -1, kernel=kernel)
Beispiel #25
0
def motion_blur(gray, degree, angle):
    gray = np.array(gray)
    M = cv2.getRotationMatrix2D((round(degree / 2), round(degree / 2)), angle, 1)
    motion_blur_kernel = np.diag(np.ones(degree))
    motion_blur_kernel = cv2.warpAffine(motion_blur_kernel, M, (degree, degree))
    PSF = motion_blur_kernel / degree
    blurred = cv2.filter2D(gray, -1, PSF)
    blurred = cv2.normalize(blurred,None, 0, 255, cv2.NORM_MINMAX)
    blurred = np.array(blurred, dtype=np.uint8)
    return blurred,PSF
def iexpand(image):
    out = None
    h = np.array([1, 4, 6, 4, 1]) / 16
    filt = (h.T).dot(h)
    outimage = np.zeros((image.shape[0] * 2, image.shape[1] * 2),
                        dtype=np.float64)
    outimage[::2, ::2] = image[:, :]
    out = cv2.filter2D(outimage, cv2.CV_64F, filt)
    return out
    '''reduce image by 1/2'''
Beispiel #27
0
def customer_blur_demo(image,
                       kernel_blur=[[0, -1, 0], [-1, 5, -1], [0, -1, 0]]):
    #定义卷积核---均值模糊的效果
    # kernel = np.ones([5,5],np.float32/25)
    # 定义卷积核---锐化
    kernel = np.array(kernel_blur, np.float32)

    dst = cv.filter2D(image, -1, kernel=kernel)
    #cv.imshow('customer_blur_demo',dst)
    return dst
Beispiel #28
0
def testBlur():
    img = cv2.imread('resource/one1.png')
    for ang in range(-360, 360, 15):
        kernel = blurKernel(length=20, angle=ang)
        motion_blur = cv2.filter2D(img, -1, kernel)
        # blur = cv2.GaussianBlur()
        winname = 'test motion {}'.format(ang)
        cv2.imshow(winname, motion_blur)
        cv2.waitKey(0)
        cv2.destroyWindow(winname)
Beispiel #29
0
def convolve(image, kernel):
    """convolve the image with the kernel.

    :param img: the image to convolve
    :type img: cv2 image
    :param kernel: the kernel to convolve with
    :type kernel: matrix
    """
    img = np.copy(image)

    return (cv2.filter2D(img, -1, flip_kernel(kernel)))
Beispiel #30
0
def blurImage2(in_image: np.ndarray, kernel_size: int) -> np.ndarray:
    """
    Blur an image using a Gaussian kernel using OpenCV built-in functions
    :param inImage: Input image
    :param kernelSize: Kernel size
    :return: The Blurred image
    """

    sigma = 0.3 * ((kernel_size - 1) * 0.5 - 1) + 0.8
    guassian = cv.getGaussianKernel(kernel_size, sigma)
    guassian = guassian * guassian.transpose()
    return cv.filter2D(in_image, -1, guassian, borderType=cv.BORDER_REPLICATE)