OpenCV常用方法总结

图像导入

import cv2 as cv

src = cv.imread("lena.jpg")
cv.namedWindow("input", cv.WINDOW_AUTOSIZE)
cv.imshow('input',src)
cv.imwrite('save.jpg',src)

cv.waitKey(0)

图像滤波 / 去噪

import cv2 as cv

img_01 = cv.imread('lena-gaussnoise.jpg')

# 高斯滤波
img_Guassian_01 = cv.GaussianBlur(img_01,(5,5),0)

cv.imshow("img",img_01)
cv.imshow("img_gaussian",img_Guassian_01)

cv.waitKey()

图像灰度化

import cv2 as cv

img = cv.imread('fruit01.jpg')
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

cv.imshow("11",img)
cv.imshow("22",gray)

cv.waitKey()

图像灰度变换

import cv2 as cv

img=cv.imread('lena.jpg')
cv.imshow('output_01',img)

gray=cv.cvtColor(img,cv.COLOR_BGR2GRAY)
cv.imshow('output_02',gray)

rows=img.shape[0]
cols=img.shape[1]
k,b=-1,255
for i in range(rows):
    for j in range(cols):
        img[i,j]=k*img[i,j]+b		# 线性变换

cv.imshow('output_03',img)

cv.waitKey(0)

旋转图像

import cv2 as cv

img=cv.imread("lena.jpg")
rows,cols=img.shape[:2]

M = cv.getRotationMatrix2D(((cols-1)/2.0,(rows-1)/2.0),270,1)
dst = cv.warpAffine(img,M,(cols,rows))

cv.imshow('img',img)
cv.imshow('dst',dst)
cv.waitKey(0)

调整图片大小

import cv2 as cv

img = cv.imread("lena.jpg")
cv.imshow("img", img)

imgg = cv.resize(img, (200, 100))
cv.imshow("imgg", imgg)

cv.waitKey(0)

识别二维码（解析codeinfo，points）并框出来

import cv2 as cv
import numpy as np

src = cv.imread("images/qrcode.png")
cv.imshow("src", src)
# cv.waitKey(3000)
gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
qrcoder = cv.QRCodeDetector()
codeinfo, points, straight_qrcode = qrcoder.detectAndDecode(gray)
print(points)

result = np.copy(src)
cv.drawContours(result, [np.int32(points)], 0, (0, 0, 255), 2)
print("qrcode : %s" % codeinfo)
cv.imshow("result", result)

cv.waitKey(0)

寻找轮廓

import cv2 as cv
import numpy as np

src = cv.imread("images/qrcode.png")
cv.imshow("src", src)
# cv.waitKey(3000)
gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_OTSU | cv.THRESH_BINARY)
contours, hierarchy = cv.findContours(binary, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
for c in range(len(contours)):
    area = cv.contourArea(contours[c])
    print(area)
    if area == 50176:
        cv.drawContours(src, contours, c, (0, 0, 255), 2, 8)

cv.imshow("contours-demo", src)

cv.waitKey(0)

KNN分类

import numpy as np
import cv2 as cv
from sklearn import neighbors
from sklearn.metrics import  classification_report

# 读取数据
img = cv.imread('digits.png')
gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
#20*20对应图片中的数字的区域大小
cells = [np.hsplit(row,100) for row in np.vsplit(gray,50)]
x = np.array(cells)

# 创建训练与测试数据
train = x[:,:50].reshape(-1,400).astype(np.float32)
test = x[:,50:100].reshape(-1,400).astype(np.float32)
k = np.arange(10)
train_labels = np.repeat(k,250)[:,np.newaxis]
test_labels = train_labels.copy()

# 训练KNN
#knn=neighbors.KNeighborsClassifier(n_neighbors=5)
# knn.fit(train, train_labels)
# result=knn.predict(test)

knn = cv.ml.KNearest_create()
knn.train(train, cv.ml.ROW_SAMPLE, train_labels)
ret,result,neighbours,dist = knn.findNearest(test,k=5)


print(u'算法评价:')
print(classification_report(test_labels, result))

SVM分类

import numpy as np
from sklearn.svm import SVC
from skimage import feature as skft
from sklearn.metrics import classification_report
import cv2 as cv
# import pickle


#导入图片，同时对图像做分割，增加样本量
#划分训练集与测试集

def loadPicture():
    train_index = 0
    test_index = 0
    train_data = np.zeros( (200,171,171) )
    test_data = np.zeros( (160,171,171) )
    train_label = np.zeros( (200) )
    test_label = np.zeros( (160) )
    for i in np.arange(40):
        image = cv.imread('picture/'+str(i)+'.tiff',0)
        data = np.zeros( (513,513) )
        data[0:image.shape[0],0:image.shape[1]] = image
        #切割后的图像位于数据的位置
        index = 0
        #将图片分割成九块
        for row in np.arange(3):
            for col in np.arange(3):
                if index<5:
                    train_data[train_index,:,:] = data[171*row:171*(row+1),
                                                  171*col:171*(col+1)]
                    train_label[train_index] = i
                    train_index+=1
                    arr='picture_train/'+str(i*9+index)+'.tiff'
                    cv.imwrite(arr, data[171 * row:171 * (row + 1),171 * col:171 * (col + 1)])
                else:
                    test_data[test_index,:,:] = data[171*row:171*(row+1),171*col:171*(col+1)]
                    test_label[test_index] = i
                    test_index+=1
                    arr='picture_test/'+str(i*9+index)+'.tiff'
                    cv.imwrite(arr, data[171 * row:171 * (row + 1),171 * col:171 * (col + 1)])
                index+=1
    return train_data,test_data,train_label,test_label


radius = 1
n_point = radius * 8

#提取图片特征
def texture_detect():
    train_hist = np.zeros( (200,256) )
    test_hist = np.zeros( (160,256) )
    for i in np.arange(200):
        #使用LBP方法提取图像的纹理特征.
        lbp=skft.local_binary_pattern(train_data[i],n_point,radius,'default')
        #统计图像的直方图
        max_bins = int(lbp.max() + 1)
        #hist size:256
        train_hist[i], _ = np.histogram(lbp, normed=True, bins=max_bins, range=(0, max_bins))

    for i in np.arange(160):
        lbp = skft.local_binary_pattern(test_data[i],n_point,radius,'default')
        #统计图像的直方图
        max_bins = int(lbp.max() + 1)
        #hist size:256
        test_hist[i], _ = np.histogram(lbp, normed=True, bins=max_bins, range=(0, max_bins))


    return train_hist,test_hist

train_data,test_data,train_label,test_label= loadPicture()
train_hist,test_hist = texture_detect()
result=[]
maxid=0
max=0
id=0
kenellist=['linear', 'poly', 'rbf', 'sigmoid']
for kenel in kenellist :
    for c in range(1,2001,100):
        gama=0.1
        while(gama<=1):
            clf = SVC(kernel=kenel, C=c, gamma=gama)
            clf.fit(train_hist,train_label)
            linshi=clf.score(test_hist,test_label)
            result.append([kenel,c,gama,linshi])
            print(id,result[id])
            if max<linshi:
                max=linshi
                maxid=id

            gama=gama+0.1
            id=id+1
print(result[maxid])

clf = SVC(kernel=result[maxid][0], C=result[maxid][1], gamma=result[maxid][2])
clf.fit(train_hist,train_label)

test_predict=clf.predict(test_hist)

print(classification_report(test_label, test_predict))

#保存模型
# f=open('save_model/clf_svm.pkl',"wb")
# pickle.dump(clf,f)
# f.close()