Stefanos

.gitignore

@@ -1 +1,5 @@
 *.zip
+__*__
+trash
+cv23_lab1_part3_material/Data/
+/Data

README.md

@@ -1,3 +1,17 @@
 # ntua-cv-lab
 
 This is a private repository for the version control of the lab projects of the Computer Vision course of ECE NTUA
+
+In order for the code to be properly run, the scripts have to executed in an environment with opencv, numpy, scikit-learn, tqdm, and matplotlib. For jupyter support, jupyter and nb_conda_kernels should also be included. Following is a command to create a virtual environment in conda.
+
+```
+conda create -n cv_lab1_env python=3.7 opencv=3.4.2 numpy scikit-learn tqdm matplotlib jupyter nb_conda_kernels
+
+conda activate cv_lab1_env
+```
+
+Numba (a just in time compiler for python) should also be installed in order for the box_detection scripts to be fast.
+
+```
+conda install numba
+```

lab1/part12/blob_detection.py

@@ -0,0 +1,67 @@
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from blob_detection_utils import BlobDetection
+from blob_detection_utils import HessianLaplacian
+from cv23_lab1_part2_utils import interest_points_visualization
+
+# TESTED AND WORKING
+
+def blobtest():
+    up = cv2.imread("cv23_lab1_part12_material/up.png")
+    up = cv2.cvtColor(up, cv2.COLOR_BGR2RGB)
+    gray = cv2.imread("cv23_lab1_part12_material/up.png", cv2.IMREAD_GRAYSCALE)
+    gray = gray.astype(np.float64)/gray.max()
+
+    # play around with the parameters
+    sigma = 2.5
+    theta = 0.05
+    scale = 1.1
+    N = 8
+
+    blobs = BlobDetection(gray, sigma, theta)
+    interest_points_visualization(up, blobs, None)
+    plt.savefig(f"image-plots/blob-detection-up.jpg")
+
+    # play around with the parameters
+    blobs = HessianLaplacian(gray, sigma, theta, scale, N)
+    interest_points_visualization(up, blobs, None)
+    plt.savefig(f"image-plots/blob-detection-multiscale-up.jpg")
+
+    cells = cv2.imread("cv23_lab1_part12_material/cells.jpg")
+    cells = cv2.cvtColor(cells, cv2.COLOR_BGR2RGB)
+    gray = cv2.imread("cv23_lab1_part12_material/cells.jpg", cv2.IMREAD_GRAYSCALE)
+    gray = gray.astype(np.float64)/gray.max()
+
+    # play around with the parameters
+    sigma = 3
+    theta = 0.05
+    scale = 1.1
+    N = 8
+
+    blobs = BlobDetection(gray, sigma, theta)
+    interest_points_visualization(cells, blobs, None)
+    plt.savefig(f"image-plots/blob-detection-cells-bad.jpg")
+
+    # play around with the parameters
+    blobs = HessianLaplacian(gray, sigma, theta, scale, N)
+    interest_points_visualization(cells, blobs, None)
+    plt.savefig(f"image-plots/blob-detection-multiscale-cells-bad.jpg")
+
+    # play around with the parameters
+    sigma = 3
+    theta = 0.15
+    scale = 1.1
+    N = 8
+
+    blobs = BlobDetection(gray, sigma, theta)
+    interest_points_visualization(cells, blobs, None)
+    plt.savefig(f"image-plots/blob-detection-cells-good.jpg")
+
+    # play around with the parameters
+    blobs = HessianLaplacian(gray, sigma, theta, scale, N)
+    interest_points_visualization(cells, blobs, None)
+    plt.savefig(f"image-plots/blob-detection-multiscale-cells-good.jpg")
+
+blobtest()
+plt.show()

lab1/part12/blob_detection_utils.py

@@ -0,0 +1,35 @@
+import numpy as np
+import time
+from intro_utils import smooth_gradient
+from intro_utils import InterestPointCoord
+from intro_utils import LogMetric
+
+def BlobDetection(image, sigma, theta):
+    gradxx, gradxy, gradyy = smooth_gradient(image, sigma, 2)
+    r = gradxx * gradyy - gradxy * gradxy # determinant of hessian
+    indices = InterestPointCoord(r, sigma, theta)
+    scale = sigma*np.ones((indices.shape[0], 1))
+    blobs = np.concatenate((indices, scale), axis=1)
+    return blobs
+
+def HessianLaplacian(image, sigma, theta, scale, N):
+    scales = [scale**i for i in list(range(N))]
+    sigmas = [scale * sigma for scale in scales]
+
+    gradsxx = []
+    gradsyy = []
+    blobs_per_scale = []
+    for s in sigmas:
+        lxx, lxy, lyy = smooth_gradient(image, s, 2)
+        r = lxx * lyy - lxy * lxy # determinant of hessian
+        indices = InterestPointCoord(r, s, theta)
+        scale = s*np.ones((indices.shape[0], 1))
+        blobs = np.concatenate((indices, scale), axis=1)
+
+        gradsxx.append(lxx)
+        gradsyy.append(lyy)
+        blobs_per_scale.append(blobs)
+
+    grads = list(zip(scales, gradsxx, gradsyy))
+    logs = [(s**2)*np.abs(xx + yy) for (s, xx, yy) in grads]
+    return LogMetric(logs, blobs_per_scale, N)

lab1/part12/box_detection.py

@@ -0,0 +1,68 @@
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from box_detection_utils import BoxFilters
+from box_detection_utils import BoxLaplacian
+from cv23_lab1_part2_utils import interest_points_visualization
+
+# THIS WORKS NOW, HOWEVER IT IS NOT SPED UP.
+# THE SPEED UP ACTUALLY DEPENDS ON HOW THE
+# SIMPLE BLOB DETECTION FUNCTION WORKS.
+
+# IF IT IS IMPLEMENTED USING THE BUILT IN
+# FILTER2D AND GAUSSIAN FUNCTIONS, THEN 
+# IT IS ALREADY REALLY FAST AND ITS TIME
+# COMPLEXITY DOES NOT DEPEND ON THE SIGMA
+# PARAMETER. IF A MANUAL CONVOLUTION HAS
+# BEEN USED, THEN A HUGE SPEEDUP (OR ACTUALLY SLOW DOWN)
+# WILL BE NOTICEABLE.
+
+def boxtest():
+    up = cv2.imread("cv23_lab1_part12_material/up.png")
+    up = cv2.cvtColor(up, cv2.COLOR_BGR2RGB)
+    gray = cv2.imread("cv23_lab1_part12_material/up.png", cv2.IMREAD_GRAYSCALE)
+    gray = gray.astype(np.float64)/gray.max()
+
+    # play around with the parameters
+    sigma = 2.5
+    theta = 0.05
+
+    blobs = BoxFilters(gray, sigma, theta)
+    interest_points_visualization(up, blobs, None)
+    plt.savefig(f"image-plots/blob-detection-ii-up.jpg")
+
+    # play around with the parameters
+    sigma = 2.5
+    theta = 0.05
+    scale = 1.1
+    N = 8
+
+    blobs = BoxLaplacian(gray, sigma, theta, scale, N)
+    interest_points_visualization(up, blobs, None)
+    plt.savefig(f"image-plots/blob-detection-multiscale-ii-up.jpg")
+
+    cells = cv2.imread("cv23_lab1_part12_material/cells.jpg")
+    cells = cv2.cvtColor(cells, cv2.COLOR_BGR2RGB)
+    gray = cv2.imread("cv23_lab1_part12_material/cells.jpg", cv2.IMREAD_GRAYSCALE)
+    gray = gray.astype(np.float64)/gray.max()
+
+    # play around with the parameters
+    sigma = 3
+    theta = 0.05
+
+    blobs = BoxFilters(gray, sigma, theta)
+    interest_points_visualization(cells, blobs, None)
+    plt.savefig(f"image-plots/blob-detection-ii-cells.jpg")
+
+    # play around with the parameters
+    sigma = 3
+    theta = 0.05
+    scale = 1.1
+    N = 8
+
+    blobs = BoxLaplacian(gray, sigma, theta, scale, N)
+    interest_points_visualization(cells, blobs, None)
+    plt.savefig(f"image-plots/blob-detection-multiscale-ii-cells.jpg")
+
+boxtest()
+plt.show()

lab1/part12/box_detection_utils.py

@@ -0,0 +1,98 @@
+import numpy as np
+import time
+from intro_utils import LogMetric
+from intro_utils import InterestPointCoord
+
+
+def IntegralImage(i):
+    # this definitely works
+    return np.cumsum(np.cumsum(i, axis=0), axis=1)
+
+def BoxDerivative(image, sigma):
+    def roi(ii, x, y, padw):
+        # rectangle of interest
+        # the input image is padded, otherwise the shifts
+        # would have peculiar results
+
+        # therefore remeber to unpad in the end
+
+        # take the whole integral image and move it around
+        # the area outside of the rectangle will cancel itself out
+        # leaving only the values inside the rectangle of interest
+        shiftx = int((x + 1)/2 - 1)
+        shifty = int((y + 1)/2 - 1)
+
+        # this isolates the upper and lower line
+        upline = np.roll(ii, shifty + 1, axis=0)
+        loline = np.roll(ii, -shifty, axis=0)
+
+        # this isolates the upper corners
+        uprigh = np.roll(upline, -shiftx, axis=1)
+        upleft = np.roll(upline, shiftx+1, axis=1)
+
+        # this isolates the lower corners
+        downri = np.roll(loline, -shiftx, axis=1)
+        downle = np.roll(loline, shiftx+1, axis=1)
+
+        result = upleft - uprigh + downri - downle
+        # unpad in the end
+        result = result[padw:-padw, padw:-padw]
+        return result
+
+    n = int(2*np.ceil(3*sigma) + 1)
+    height = int(4*np.floor(n/6) + 1)
+    width = int(2*np.floor(n/6) + 1)
+    padding = 2 * width
+
+    padded = np.pad(image, padding, 'reflect')
+    ii = IntegralImage(padded)
+
+    # sum the middle rectangle x(-3) and then add the whole rectangle
+    # (0 -3 0) + (1 1 1) = (1 -2 1)
+    lxx = -3*(roi(ii, width, height, padding)) + roi(ii, 3*width, height, padding)
+    lyy = -3*(roi(ii, height, width, padding)) + roi(ii, height, 3*width, padding)
+
+    # the xy derivative requires a little special handling
+    smallbox = roi(ii, width, width, padding)
+    padded = np.pad(smallbox, padding, 'reflect')
+    shiftv = int((width-1)/2 + 1)
+
+    ul = np.roll(padded, [shiftv, shiftv], axis=(0, 1))
+    ur = np.roll(padded, [-shiftv, shiftv], axis=(0, 1))
+    dl = np.roll(padded, [shiftv, -shiftv], axis=(0, 1))
+    dr = np.roll(padded, [-shiftv, -shiftv], axis=(0, 1))
+
+    lxy = ul + dr - ur - dl
+    lxy = lxy[padding:-padding, padding:-padding]
+
+    return (lxx, lxy, lyy)
+
+def BoxFilters(image, sigma, theta):
+    lxx, lxy, lyy = BoxDerivative(image, sigma)
+    r = lxx*lyy - (0.9*lxy)**2
+    indices = InterestPointCoord(r, sigma, theta)
+    scale = sigma*np.ones((indices.shape[0], 1))
+    blobs = np.concatenate((indices, scale), axis=1)
+    return blobs
+
+def BoxLaplacian(image, sigma, theta, scale, N):
+    scales = [scale**i for i in list(range(N))]
+    sigmas = [scale * sigma for scale in scales]
+
+    gradsxx = []
+    gradsyy = []
+    blobs_per_scale = []
+    for s in sigmas:
+        lxx, lxy, lyy = BoxDerivative(image, s)
+        r = lxx*lyy - (0.9*lxy)**2
+        indices = InterestPointCoord(r, s, theta)
+        scale = s*np.ones((indices.shape[0], 1))
+        blobs = np.concatenate((indices, scale), axis=1)
+
+        gradsxx.append(lxx)
+        gradsyy.append(lyy)
+        blobs_per_scale.append(blobs)
+
+    grads = list(zip(scales, gradsxx, gradsyy))
+    logs = [(s**2)*np.abs(xx + yy) for (s, xx, yy) in grads]
+    return LogMetric(logs, blobs_per_scale, N)