diff --git a/3.jpg b/3.jpg new file mode 100644 index 0000000..d51c602 Binary files /dev/null and b/3.jpg differ diff --git a/4.jpg b/4.jpg new file mode 100644 index 0000000..d569f48 Binary files /dev/null and b/4.jpg differ diff --git a/a.jpg b/a.jpg new file mode 100644 index 0000000..f1cfdcd Binary files /dev/null and b/a.jpg differ diff --git a/b.jpg b/b.jpg new file mode 100644 index 0000000..e628f79 Binary files /dev/null and b/b.jpg differ diff --git a/office.jpeg b/office.jpeg deleted file mode 100644 index 6b037e4..0000000 Binary files a/office.jpeg and /dev/null differ diff --git a/pano.jpg b/pano.jpg deleted file mode 100644 index 1e77153..0000000 Binary files a/pano.jpg and /dev/null differ diff --git a/project2.py b/project2.py new file mode 100644 index 0000000..b9ae5f6 --- /dev/null +++ b/project2.py @@ -0,0 +1,283 @@ +import numpy as np +import matplotlib.pyplot as plt +import skimage.transform as skt +from math import floor, exp, sqrt +from PIL import Image + +def convolve(g, h, f=0): + (V, U) = g.shape + (j, k) = h.shape + + x = floor(j/2) # half of filter x dim + y = floor(k/2) # half of filter y dim + + C = np.zeros((V, U)) # this is where the result of our convolution will go + + padded = np.zeros((V + (2 * y), U + (2 * x))) + padded[y:V+1, x:U+1] = g + g = padded + + for u in range(x, U): + for v in range(y, V): + patch = g[v-y:v+y+1:1, u-x:u+x+1:1] + C[v - 1][u - 1] = apply_kernel(patch, h) + + return (C) + +def apply_kernel(patch, h): + (j, k) = patch.shape + z = 0 + for x in range(j): + for y in range(k): + z+= (patch[x][y] * h[x][y]) + + return(z) + +def generate_gaussian(j, k, sigma): + h = np.zeros((j, k)) + Z = 0 + for x in range(j): + for y in range(k): + val = exp(-((x - j/2)**2 + (y - k/2)**2) / (2 * sigma**2)) + h[x][y] = val + Z += val + + for x in range(j): + for y in range(k): + h[x][y] = Z * h[x][y] + + return (h) + +def harris_response(I): + w = generate_gaussian(3, 3, 2) + + s_u = np.array([[-1, 0, 1], + [-2, 0, 2], + [-1, 0, 1]]) + + s_v = np.array([[-1, -2, -1], + [ 0, 0, 0], + [ 1, 2, 1]]) + + I_u = convolve(I, s_u) + I_v = convolve(I, s_v) + I_uu = convolve(np.multiply(I_u, I_u), w) + I_vv = convolve(np.multiply(I_v, I_v), w) + I_uv = convolve(np.multiply(I_u, I_v), w) + + a = np.multiply(I_uu, I_vv) + b = np.multiply(I_uv, I_uv) + c = np.subtract(a, b) + d = np.add(I_uu, I_vv) + + (X, Y) = d.shape + + for x in range(X): + for y in range(Y): + d[x][y] += 1e-10 + + H = np.divide(c, d) + + return (H) + +def local_maxima(H, j, k): + Y, X = H.shape + maxima = [] + for x in range(0, X, j): + for y in range(0, Y, k): + #print("({}, {})\t({}, {})".format(x, x+3, y, y+3)) + patch = H[y:y+3:1, x:x+3:1] + #print(patch) + max_y, max_x = np.unravel_index(patch.argmax(), patch.shape) + max_x += x + max_y += y + + #print("({}, {})".format(max_x, max_y)) + maxima.append([max_x, max_y, H[max_y][max_x]]) + + maxima.sort(key=lambda x: x[2]) # sort by harris response intensity + maxima.reverse() + amt = int(len(maxima) * 0.15) + maxima = maxima[:amt] # take the top n% + + suppressed = adaptive_suppression(maxima) + suppressed.sort(key=lambda x: x[2]) # sort by distance + suppressed.reverse() + + + suppressed = suppressed[0:100] + return (suppressed) + +def adaptive_suppression(maxima): + suppressed = [] + cnt = len(maxima) + + for i in range(cnt): + # for every point + (x, y) = (maxima[i][0], maxima[i][1]) + closest_x = x + closest_y = y + closest_dist = float('inf') + dist = 0 + + higher_response = maxima[0:i] # we know that only 0:i have a higher harris response + for point in higher_response: + # for each point that has a higher harris response + (px, py) = (point[0], point[1]) + dist = point_distance(x, y, px, py) + + if dist < closest_dist: + closest_dist = dist + closest_x = px + closest_y = py + + suppressed.append([x, y, closest_dist]) + + return (suppressed) + +def point_distance(x1, y1, x2, y2): + #print("{}, {}\t{}, {}".format(x1,y1,x2,y2)) + x_diff = (x1 - x2)**2 + y_diff = (y1 - y2)**2 + + dist = sqrt(x_diff + y_diff) + + return (dist) + +def match_features(m1, m2, I1, I2, l): + r = 0.7 + matched = [] + V, U = I1.shape + + l = int(l/2) + + for p1 in m1: + (p1x, p1y) = (p1[0], p1[1]) # coordinates of keypoint in image 1 + + # descriptor 1 pixel boundaries + d1_x1 = p1x - l + d1_x2 = p1x + l + 1 + d1_y1 = p1y - l + d1_y2 = p1y + l + 1 + d1 = I1[d1_y1:d1_y2:1, d1_x1:d1_x2:1] + + if (d1_x1 < 0 or d1_x2 >= U or d1_y1 < 0 or d1_y2 >= V): + # if we are too close to the edge of image 1 + continue + + sum_sq_errors = [] # list of potential matched keypoints in the form [[x, y], (sum_sq_error)] + + for p2 in m2: + (p2x, p2y) = (p2[0], p2[1]) # coordinates of keypoint in image 2 + + # descriptor 2 pixel boundaries + d2_x1 = p2x - l + d2_x2 = p2x + l + 1 + d2_y1 = p2y - l + d2_y2 = p2y + l + 1 + d2 = I2[d2_y1:d2_y2:1, d2_x1:d2_x2:1] + + if (d2_x1 < 0 or d2_x2 >= U or d2_y1 < 0 or d2_y2 >= V): + # if we are too close to the edge of the image 2 + continue + + sum_sq_errors.append([[p2x, p2y], np.sum((d1-d2)**2)]) + + sum_sq_errors.sort(key=lambda x: x[1]) + + E1 = sum_sq_errors[0][1] + E2 = sum_sq_errors[1][1] + + #print("{}\t{}".format(E1, E2)) + if (E1 < r * E2): + matched.append([[p1x, p1y], sum_sq_errors[0][0]]) + + return matched + +def sum_sq_error(p1, p2): + sum = 0 + + for i, j in zip(p1, p2): + sum += (i - j)**2 + + return (sum) + + +def compute_homography(sample): + cnt = len(list(sample)) + u = sample[:, :1] + v = sample[:, 1:2] + up = sample[:, 2:3] + vp = sample[:, 3:4] + + A = np.zeros((2*len(u), 9)) + + for i in range(len(u)): + A[2*i, :] = [0, 0, 0, -u[i], -v[i], -1, vp[i]*u[i], vp[i]*v[i], vp[i]] + A[2*i+1, :] = [u[i], v[i], 1, 0, 0, 0, -up[i]*u[i], -up[i]*v[i], -up[i]] + + U,Sigma,Vt = np.linalg.svd(A) + + homog = Vt[-1].reshape(3,3) + + return homog + +def RANSAC(number_of_iterations,matches,n,r,d): + H_best = np.array([[1,0,0],[0,1,0],[0,0,1]]) + list_of_inliers = [] + inlier_best = 0 + + for i in range(number_of_iterations): + # 1. Select a random sample of length n from the matches + #print(len(matches)) + np.random.shuffle(matches) + samples = np.array(matches[:n]) + test = np.array(matches[n:]) + + # 2. Compute a homography based on these points using the methods given above + H_current = compute_homography(samples) + + # 3. Apply this homography to the remaining points that were not randomly selected + test_I1 = test[:, :2] + test_I1 = np.column_stack((test_I1, np.ones(len(test_I1)))) + test_I2 = test[:, 2:4] + + predicted = (H_current @ test_I1.T).T + #print(predicted) + predicted /= predicted[:,2][:,np.newaxis] + predicted = predicted[:,:2] + #print(test_I1) + #print(predicted) + #print(test_I2) + + # 4. Compute the residual between observed and predicted feature locations + R = [] + for obs, kwn in zip(predicted, test_I2): + #print(*obs, *kwn) + R.append(point_distance(*obs, *kwn)) + + + current_inliers = [] + for p1, p2 in zip(test_I1, predicted): + current_inliers.append([p1[:2], p2]) + + #print(R) + in_cnt = 0 + # 5. Flag predictions that lie within a predefined distance r from observations as inliers + + for x in R: + if x < r: + in_cnt +=1 + # 6. If number of inliers is greater than the previous best + # and greater than a minimum number of inliers d, + # 7. update H_best + # 8. update list_of_inliers + #print(in_cnt) + if (in_cnt > inlier_best and in_cnt > d): + H_best = H_current + inlier_best = in_cnt + list_of_inliers = current_inliers + pass + #print(in_cnt) + + return H_best, list_of_inliers \ No newline at end of file diff --git a/project_description.ipynb b/project_description.ipynb deleted file mode 100644 index 421c6d0..0000000 --- a/project_description.ipynb +++ /dev/null @@ -1,98 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Project 2: Image Stitcher\n", - "## Assigned: 02.01.2019\n", - "## Due Date: TBD (probably 02.20.2019)\n", - "\n", - "Panoramic photography is ubiquitous, with nearly every digital camera having a mode dedicated to doing it. Here's an example from the Italian Alps:\n", - "\n", - "Note the extreme aspect ratio: much larger than the 4:3 or 3:2 that is typical of most cameras; suffice to say, the camera that stook this picture did not have a sensor that was this wide. So how are these things made? Stated simply, multiple images are taken, mutually identifiable points are located in each of these images, and the images are warped such that these points are coincident. The matching stage might look like this:\n", - "\n", - "\n", - "For this project, you will code your own image stitcher from scratch. Despite the conceptual simplicity of this operation, there are a surprising number of challenges that need to be addressed. A general framework for a stitcher might look like this:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "class Stitcher(object):\n", - " def __init__(self,image_1,image_2):\n", - " self.images = [image_1,image_2]\n", - " \n", - " def find_keypoints(self):\n", - " \"\"\"\n", - " Step 1: This method locates features that are \"good\" for matching. To do this we will implement the Harris \n", - " corner detector\n", - " \"\"\"\n", - " \n", - " def generate_descriptors(self):\n", - " \"\"\"\n", - " Step 2: After identifying relevant keypoints, we need to come up with a quantitative description of the \n", - " neighborhood of that keypoint, so that we can match it to keypoints in other images.\n", - " \"\"\"\n", - " \n", - " def match_keypoints(self):\n", - " \"\"\"\n", - " Step 3: Compare keypoint descriptions between images, identify potential matches, and filter likely\n", - " mismatches\n", - " \"\"\"\n", - " \n", - " def find_homography(self):\n", - " \"\"\"\n", - " Step 4: Find a linear transformation (of various complexities) that maps pixels from the second image to \n", - " pixels in the first image\n", - " \"\"\"\n", - " \n", - " def stitch(self):\n", - " \"\"\"\n", - " Step 5: Transform second image into local coordinate system of first image, and (perhaps) perform blending\n", - " to avoid obvious seams between images.\n", - " \"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We will populate these functions over the next several weeks, a process that will involve delving into some of the most elementary operations in digital signal processing. \n", - "\n", - "As a test case, apply your stitcher to at least four overlapping images that you've taken. With a stitcher that works on two images, more images can be added by applying the method recursively." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.6.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/stitch.ipynb b/stitch.ipynb new file mode 100644 index 0000000..c74b004 --- /dev/null +++ b/stitch.ipynb @@ -0,0 +1,182 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Project 2: Image Stitcher\n", + "## Assigned: 02.01.2019\n", + "## Due Date: TBD (probably 02.20.2019)\n", + "\n", + "Panoramic photography is ubiquitous, with nearly every digital camera having a mode dedicated to doing it. Here's an example from the Italian Alps:\n", + "\n", + "Note the extreme aspect ratio: much larger than the 4:3 or 3:2 that is typical of most cameras; suffice to say, the camera that stook this picture did not have a sensor that was this wide. So how are these things made? Stated simply, multiple images are taken, mutually identifiable points are located in each of these images, and the images are warped such that these points are coincident. The matching stage might look like this:\n", + "\n", + "\n", + "For this project, you will code your own image stitcher from scratch. Despite the conceptual simplicity of this operation, there are a surprising number of challenges that need to be addressed. A general framework for a stitcher might look like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import skimage.transform as skt\n", + "from math import floor, exp, sqrt\n", + "from PIL import Image\n", + "from project2 import *\n", + "\n", + "\n", + "def stitch(I1, I2):\n", + " H1 = harris_response(I1)\n", + " H2 = harris_response(I2)\n", + "\n", + " m1 = local_maxima(H1, 3, 3)\n", + " m2 = local_maxima(H2, 3, 3)\n", + "\n", + " blah, x_diff = I1.shape\n", + "\n", + " matched = match_features(m1, m2, I1, I2, 21)\n", + " amt = len(matched)\n", + "\n", + " u = [matched[i][0][0] for i in range(amt)]\n", + " v = [matched[i][0][1] for i in range(amt)]\n", + "\n", + " up = [matched[i][1][0] for i in range(amt)]\n", + " vp = [matched[i][1][1] for i in range(amt)]\n", + "\n", + " matches = [ [u[i], v[i], up[i], vp[i] ] for i in range(amt)]\n", + "\n", + " H_best, inliers = RANSAC(1000, matches, n=4, r=3, d=10)\n", + " \n", + " # Create a projective transform based on the homography matrix $H$\n", + " proj_trans = skt.ProjectiveTransform(H_best)\n", + " \n", + " # Get the size of the warped image\n", + " H_inverse = np.linalg.inv(H_best)\n", + " diff = H_inverse @ [0,0,1] \n", + " U_diff = int(diff[0]/diff[2])\n", + " V_prime, U_prime = I1.shape\n", + " U_prime += U_diff\n", + " \n", + " # Warp the image into image 1's coordinate system\n", + " I2_prime = skt.warp(I2, proj_trans, output_shape=(V_prime, U_prime))\n", + " \n", + " return (I2_prime, H_best)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will populate these functions over the next several weeks, a process that will involve delving into some of the most elementary operations in digital signal processing. \n", + "\n", + "As a test case, apply your stitcher to at least four overlapping images that you've taken. With a stitcher that works on two images, more images can be added by applying the method recursively." + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "I1 = plt.imread('3.jpg')\n", + "I2 = plt.imread('4.jpg')\n", + "\n", + "I1 = I1.mean(axis=2) # Use this if the image is RGB\n", + "I2 = I2.mean(axis=2)\n", + "\n", + "I = np.concatenate((I1, I2), axis=1)\n", + "\n", + "plt.imshow(I, cmap=plt.cm.gray)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [], + "source": [ + "I2_prime, H_best = stitch(I1, I2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(378, 620)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(I1, cmap=plt.cm.gray, alpha=0.5)\n", + "plt.imshow(I2_prime, cmap=plt.cm.gray, alpha=0.5)\n", + "plt.show\n", + "\n", + "print(I2_prime.shape)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/trex1.jpg b/trex1.jpg new file mode 100644 index 0000000..59bb118 Binary files /dev/null and b/trex1.jpg differ diff --git a/trex2.jpg b/trex2.jpg new file mode 100644 index 0000000..f5bb52a Binary files /dev/null and b/trex2.jpg differ