import cv2

import numpy as np

from matplotlib import pyplot as plt

img = cv2.imread('messi5.jpg',0)

f = np.fft.fft2(img)

fshift = np.fft.fftshift(f)

# 这里构建振幅图的公式没学过

magnitude_spectrum = 20*np.log(np.abs(fshift))

plt.subplot(121),plt.imshow(img, cmap = 'gray')

plt.title('Input Image'), plt.xticks([]), plt.yticks([])

plt.subplot(122),plt.imshow(magnitude_spectrum, cmap = 'gray')

plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])

plt.show()

rows, cols = img.shape

crow,ccol = rows/2 , cols/2

fshift[crow-30:crow+30, ccol-30:ccol+30] = 0

f_ishift = np.fft.ifftshift(fshift)

img_back = np.fft.ifft2(f_ishift)

img_back = np.abs(img_back)

plt.subplot(131),plt.imshow(img, cmap = 'gray')

plt.title('Input Image'), plt.xticks([]), plt.yticks([])

plt.subplot(132),plt.imshow(img_back, cmap = 'gray')

plt.title('Image after HPF'), plt.xticks([]), plt.yticks([])

plt.subplot(133),plt.imshow(img_back)

plt.title('Result in JET'), plt.xticks([]), plt.yticks([])

plt.show()

import numpy as np

import cv2

from matplotlib import pyplot as plt

img = cv2.imread('messi5.jpg',0)

dft = cv2.dft(np.float32(img),flags = cv2.DFT_COMPLEX_OUTPUT)

dft_shift = np.fft.fftshift(dft)

magnitude_spectrum = 20*np.log(cv2.magnitude(dft_shift[:,:,0],dft_shift[:,:,1]))

plt.subplot(121),plt.imshow(img, cmap = 'gray')

plt.title('Input Image'), plt.xticks([]), plt.yticks([])

plt.subplot(122),plt.imshow(magnitude_spectrum, cmap = 'gray')

plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])

plt.show()

rows, cols = img.shape

crow,ccol = rows/2 , cols/2

# create a mask first, center square is 1, remaining all zeros

mask = np.zeros((rows,cols,2),np.uint8)

mask[crow-30:crow+30, ccol-30:ccol+30] = 1

# apply mask and inverse DFT

fshift = dft_shift*mask

f_ishift = np.fft.ifftshift(fshift)

img_back = cv2.idft(f_ishift)

img_back = cv2.magnitude(img_back[:,:,0],img_back[:,:,1])

plt.subplot(121),plt.imshow(img, cmap = 'gray')

plt.title('Input Image'), plt.xticks([]), plt.yticks([])

plt.subplot(122),plt.imshow(img_back, cmap = 'gray')

plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])

plt.show()

In [16]: img = cv2.imread('messi5.jpg',0)

In [17]: rows,cols = img.shape

In [18]: print rows,cols

342 548

In [19]: nrows = cv2.getOptimalDFTSize(rows)

In [20]: ncols = cv2.getOptimalDFTSize(cols)

In [21]: print nrows, ncols

360 576

nimg = np.zeros((nrows,ncols))

nimg[:rows,:cols] = img

right = ncols - cols

bottom = nrows - rows

#just to avoid line breakup in PDF file

bordertype = cv2.BORDER_CONSTANT

nimg = cv2.copyMakeBorder(img,0,bottom,0,right,bordertype, value = 0)

In [22]: %timeit fft1 = np.fft.fft2(img)

10 loops, best of 3: 40.9 ms per loop

In [23]: %timeit fft2 = np.fft.fft2(img,[nrows,ncols])

100 loops, best of 3: 10.4 ms per loop

In [24]: %timeit dft1= cv2.dft(np.float32(img),flags=cv2.DFT_COMPLEX_OUTPUT)

100 loops, best of 3: 13.5 ms per loop

In [27]: %timeit dft2= cv2.dft(np.float32(nimg),flags=cv2.DFT_COMPLEX_OUTPUT)

100 loops, best of 3: 3.11 ms per loop

import cv2

import numpy as np

from matplotlib import pyplot as plt

# simple averaging filter without scaling parameter

mean_filter = np.ones((3,3))

# creating a guassian filter

x = cv2.getGaussianKernel(5,10)

#x.T 为矩阵转置

gaussian = x*x.T

# different edge detecting filters

# scharr in x-direction

scharr = np.array([[-3, 0, 3],

[-10,0,10],

[-3, 0, 3]])

# sobel in x direction

sobel_x= np.array([[-1, 0, 1],

[-2, 0, 2],

[-1, 0, 1]])

# sobel in y direction

sobel_y= np.array([[-1,-2,-1],

[0, 0, 0],

[1, 2, 1]])

# laplacian

laplacian=np.array([[0, 1, 0],

[1,-4, 1],

[0, 1, 0]])

filters = [mean_filter, gaussian, laplacian, sobel_x, sobel_y, scharr]

filter_name = ['mean_filter', 'gaussian','laplacian', 'sobel_x', \

'sobel_y', 'scharr_x']

fft_filters = [np.fft.fft2(x) for x in filters]

fft_shift = [np.fft.fftshift(y) for y in fft_filters]

mag_spectrum = [np.log(np.abs(z)+1) for z in fft_shift]

for i in xrange(6):

plt.subplot(2,3,i+1),plt.imshow(mag_spectrum[i],cmap = 'gray')

plt.title(filter_name[i]), plt.xticks([]), plt.yticks([])

plt.show()

import cv2

import numpy as np

from matplotlib import pyplot as plt

img = cv2.imread('messi5.jpg',0)

img2 = img.copy()

template = cv2.imread('messi_face.jpg',0)

w, h = template.shape[::-1]

# All the 6 methods for comparison in a list

methods = ['cv2.TM_CCOEFF', 'cv2.TM_CCOEFF_NORMED', 'cv2.TM_CCORR',

'cv2.TM_CCORR_NORMED', 'cv2.TM_SQDIFF', 'cv2.TM_SQDIFF_NORMED']

for meth in methods:

img = img2.copy()

#exec 语句用来执行储存在字符串或文件中的 Python 语句。

# 例如，我们可以在运行时生成一个包含 Python 代码的字符串，然后使用 exec 语句执行这些语句。

#eval 语句用来计算存储在字符串中的有效 Python 表达式

method = eval(meth)

# Apply template Matching

res = cv2.matchTemplate(img,template,method)

min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)

# 使用不同的比较方法，对结果的解释不同

# If the method is TM_SQDIFF or TM_SQDIFF_NORMED, take minimum

if method in [cv2.TM_SQDIFF, cv2.TM_SQDIFF_NORMED]:

top_left = min_loc

else:

top_left = max_loc

bottom_right = (top_left[0] + w, top_left[1] + h)

cv2.rectangle(img,top_left, bottom_right, 255, 2)

plt.subplot(121),plt.imshow(res,cmap = 'gray')

plt.title('Matching Result'), plt.xticks([]), plt.yticks([])

plt.subplot(122),plt.imshow(img,cmap = 'gray')

plt.title('Detected Point'), plt.xticks([]), plt.yticks([])

plt.suptitle(meth)

plt.show()

import cv2

import numpy as np

from matplotlib import pyplot as plt

img_rgb = cv2.imread('mario.png')

img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_BGR2GRAY)

template = cv2.imread('mario_coin.png',0)

w, h = template.shape[::-1]

res = cv2.matchTemplate(img_gray,template,cv2.TM_CCOEFF_NORMED)

threshold = 0.8

loc = np.where( res >= threshold)

for pt in zip(*loc[::-1]):

    cv2.rectangle(img_rgb, pt, (pt[0] + w, pt[1] + h), (0,0,255), 2)

cv2.imwrite('res.png',img_rgb)

import cv2

import numpy as np

img = cv2.imread('dave.jpg')

gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

edges = cv2.Canny(gray,50,150,apertureSize = 3)

lines = cv2.HoughLines(edges,1,np.pi/180,200)

for rho,theta in lines[0]:

    a = np.cos(theta)

    b = np.sin(theta)

    x0 = a*rho

    y0 = b*rho

    x1 = int(x0 + 1000*(-b))

    y1 = int(y0 + 1000*(a))

    x2 = int(x0 - 1000*(-b))

    y2 = int(y0 - 1000*(a))

    cv2.line(img,(x1,y1),(x2,y2),(0,0,255),2)

cv2.imwrite('houghlines3.jpg',img)

import cv2

import numpy as np

img = cv2.imread('dave.jpg')

gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

edges = cv2.Canny(gray,50,150,apertureSize = 3)

minLineLength = 100

maxLineGap = 10

lines = cv2.HoughLinesP(edges,1,np.pi/180,100,minLineLength,maxLineGap)

for x1,y1,x2,y2 in lines[0]:

    cv2.line(img,(x1,y1),(x2,y2),(0,255,0),2)

cv2.imwrite('houghlines5.jpg',img)

import cv2

import numpy as np

img = cv2.imread('opencv_logo.png',0)

img = cv2.medianBlur(img,5)

cimg = cv2.cvtColor(img,cv2.COLOR_GRAY2BGR)

circles = cv2.HoughCircles(img,cv2.HOUGH_GRADIENT,1,20,

param1=50,param2=30,minRadius=0,maxRadius=0)

circles = np.uint16(np.around(circles))

for i in circles[0,:]:

# draw the outer circle

cv2.circle(cimg,(i[0],i[1]),i[2],(0,255,0),2)

# draw the center of the circle

cv2.circle(cimg,(i[0],i[1]),2,(0,0,255),3)

cv2.imshow('detected circles',cimg)

cv2.waitKey(0)

cv2.destroyAllWindows()

#Python: cv2.HoughCircles(image, method, dp, minDist, circles, param1, param2, minRadius, maxRadius)

#Parameters:

#image – 8-bit, single-channel, grayscale input image.

# 返回结果为 Output vector of found circles. Each vector is encoded as a

#3-element floating-point vector (x, y, radius) .

#circle_storage – In C function this is a memory storage that will contain

#the output sequence of found circles.

#method – Detection method to use. Currently, the only implemented method is

#CV_HOUGH_GRADIENT , which is basically 21HT , described in [Yuen90].

#dp – Inverse ratio of the accumulator resolution to the image resolution.

#For example, if dp=1 , the accumulator has the same resolution as the input image.

#If dp=2 , the accumulator has half as big width and height.

#minDist – Minimum distance between the centers of the detected circles.

#If the parameter is too small, multiple neighbor circles may be falsely

#detected in addition to a true one. If it is too large, some circles may be missed.

#param1 – First method-specific parameter. In case of CV_HOUGH_GRADIENT ,

#it is the higher threshold of the two passed to the Canny() edge detector

# (the lower one is twice smaller).

#param2 – Second method-specific parameter. In case of CV_HOUGH_GRADIENT ,

# it is the accumulator threshold for the circle centers at the detection stage.

#The smaller it is, the more false circles may be detected. Circles,

# corresponding to the larger accumulator values, will be returned first.

#minRadius – Minimum circle radius.

#maxRadius – Maximum circle radius.

import numpy as np

import cv2

from matplotlib import pyplot as plt

img = cv2.imread('coins.png')

gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

ret, thresh = cv2.threshold(gray,0,255,cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)

# noise removal

kernel = np.ones((3,3),np.uint8)

opening = cv2.morphologyEx(thresh,cv2.MORPH_OPEN,kernel, iterations = 2)

# sure background area

sure_bg = cv2.dilate(opening,kernel,iterations=3)

# Finding sure foreground area

# 距离变换的基本含义是计算一个图像中非零像素点到最近的零像素点的距离，也就是到零像素点的最短距离

# 个最常见的距离变换算法就是通过连续的腐蚀操作来实现，腐蚀操作的停止条件是所有前景像素都被完全

# 腐蚀。这样根据腐蚀的先后顺序，我们就得到各个前景像素点到前景中心??像素点的

# 距离。根据各个像素点的距离值，设置为不同的灰度值。这样就完成了二值图像的距离变换

#cv2.distanceTransform(src, distanceType, maskSize)

# 第二个参数 0,1,2 分别表示 CV_DIST_L1, CV_DIST_L2 , CV_DIST_C

dist_transform = cv2.distanceTransform(opening,1,5)

ret, sure_fg = cv2.threshold(dist_transform,0.7*dist_transform.max(),255,0)

# Finding unknown region

sure_fg = np.uint8(sure_fg)

unknown = cv2.subtract(sure_bg,sure_fg)

# Marker labelling

ret, markers1 = cv2.connectedComponents(sure_fg)

# Add one to all labels so that sure background is not 0, but 1

markers = markers1+1

# Now, mark the region of unknown with zero

markers[unknown==255] = 0

结果使用 JET 颜色地图表示。深蓝色区域为未知区域。肯定是硬币的区域使用不同的颜色标记。其余区域就是用浅蓝色标记的背景了。

现在标签准备好了。到最后一步：实施分水岭算法了。标签图像将会被修改，边界区域的标记将变为 -1.

markers3 = cv2.watershed(img,markers)

img[markers3 == -1] = [255,0,0]

import numpy as np

import cv2

from matplotlib import pyplot as plt

img = cv2.imread('messi5.jpg')

mask = np.zeros(img.shape[:2],np.uint8)

bgdModel = np.zeros((1,65),np.float64)

fgdModel = np.zeros((1,65),np.float64)

rect = (50,50,450,290)

# 函数的返回值是更新的 mask, bgdModel, fgdModel

cv2.grabCut(img,mask,rect,bgdModel,fgdModel,5,cv2.GC_INIT_WITH_RECT)

mask2 = np.where((mask==2)|(mask==0),0,1).astype('uint8')

img = img*mask2[:,:,np.newaxis]

plt.imshow(img),plt.colorbar(),plt.show()

# newmask is the mask image I manually labelled

newmask = cv2.imread('newmask.png',0)

# whereever it is marked white (sure foreground), change mask=1

# whereever it is marked black (sure background), change mask=0

mask[newmask == 0] = 0

mask[newmask == 255] = 1

mask, bgdModel, fgdModel = cv2.grabCut(img,mask,None,bgdModel,fgdModel,5,cv2.GC_INIT_WITH_MASK)

mask = np.where((mask==2)|(mask==0),0,1).astype('uint8')

img = img*mask[:,:,np.newaxis]

plt.imshow(img),plt.colorbar(),plt.show()