def harris(im, sigma=1.0, rel_thresh=0.0001, k=0.04):
im = im.astype(np.float) # Make sure im is float
# Get smoothing and derivative filters
g, _, _, _, _, _, = gaussian2(sigma)
_, gx, gy, _, _, _, = gaussian2(np.sqrt(0.5))
# Partial derivatives
Ix = conv2(im, -gx, mode='constant')
Iy = conv2(im, -gy, mode='constant')
# Components of the second moment matrix
Ix2Sm = conv2(Ix**2, g, mode='constant')
Iy2Sm = conv2(Iy**2, g, mode='constant')
IxIySm = conv2(Ix*Iy, g, mode='constant')
# Determinant and trace for calculating the corner response
detC = (Ix2Sm*IxIySm)-(Iy2Sm**2)
traceC = Ix2Sm+IxIySm
# Corner response function R
# "Corner": R > 0
# "Edge": R < 0
# "Flat": |R| = small
R = detC-k*traceC**2
maxCornerValue = np.amax(R)
# Take only the local maxima of the corner response function
fp = np.ones((3,3))
fp[1,1] = 0
maxImg = maximum_filter(R, footprint=fp, mode='constant')
# Test if cornerness is larger than neighborhood
cornerImg = R>maxImg
# Threshold for low value maxima
y, x = np.nonzero((R > rel_thresh * maxCornerValue) * cornerImg)
# Convert to float
x = x.astype(np.float)
y = y.astype(np.float)
# Remove responses from image borders to reduce false corner detections
r, c = R.shape
idx = np.nonzero((x<2)+(x>c-3)+(y<2)+(y>r-3))[0]
x = np.delete(x,idx)
y = np.delete(y,idx)
# Parabolic interpolation
for i in range(len(x)):
_,dx=maxinterp((R[int(y[i]), int(x[i])-1], R[int(y[i]), int(x[i])], R[int(y[i]), int(x[i])+1]))
_,dy=maxinterp((R[int(y[i])-1, int(x[i])], R[int(y[i]), int(x[i])], R[int(y[i])+1, int(x[i])]))
x[i]=x[i]+dx
y[i]=y[i]+dy
return x, y, cornerImg
from scipy.ndimage.filters import convolve1d as conv1
from utils import imnoise, gaussian2, bilateral_filter
# Load test images and convert to double precision in the interval [0,1].
im = imread('einsteinpic.jpg') / 255.
im = imresize(im, (256, 256))
# Generate noise
imns = imnoise(im, 'salt & pepper', 0.05) * 1. # "salt and pepper" noise
imng = im + 0.05 * np.random.randn(im.shape[0],
im.shape[1]) # zero-mean Gaussian noise
# Apply a Gaussian filter with a standard deviation of 2.5
sigmad = 2.5
g, _, _, _, _, _, = gaussian2(sigmad)
gflt_imns = conv2(imns, g, mode='reflect')
gflt_imng = conv2(imng, g, mode='reflect')
# Instead of directly filtering with g, make a separable implementation
# where you use horizontal and vertical 1D convolutions.
# Store the results again to gflt_imns and gflt_imng, use conv1 instead.
# The result should not change.
# See Szeliski's Book chapter 3.2.1 Separable filtering and numpy.linalg.svd
##--your-code-starts-here--##
a = np.matrix('1 2 1; 2 4 2; 1 2 1')
a_u, a_s, a_vh = np.linalg.svd(a, full_matrices=True)
u, s, vh = np.linalg.svd(g, full_matrices=True) # Separating sigma, v and u
u_first_row = u[:, 0]