北科資工二多媒體技術與應用 期中專案一 - 剪刀石頭布

北科上課筆記 / 多媒體與圖像辨識 Image Recognition
字數統計： 4.2k   |   閱讀時間≈ 19分鐘

筆記說明

此筆記用途在於台北科技大學資訊工程系大二下多媒體技術與應用作業紀錄
並非所有人都適用，部分對我而言稍加容易的內容並不會寫在此內。
這是學習後心得的筆記，可能不太適用會未來的學生

由於我沒有學習過裡面的理論，因此這是資工大二學生透過網路與自身理解的筆記，學習價值並不高、且可能擁有大量錯誤。

題目說明

如果不想看那麼多話，建議可以直接略過。總之就像標題說的，給兩張圖片，辨識是哪種手勢，判斷剪刀石頭布的勝負。

這裡為求方便起見，玩家的部分改成抽取圖片。
可以使用 SVC 訓練模型，選擇 hog or sift 演算法來進行實作，這邊我則使用 hog，但我 sift 也有做。(只是 sift 訊練準確率較不準)。

資料集

這裡我們則使用組員 林紀緯、郭梓琳、江大衞的手來當作圖片資料集

資料集網址

連結為個人在 google 圖片進行搜尋時的圖片，如果有版權冒犯請通知我，我會進行下架

心得

這次的程式碼，寫得還算順利。就是今天出了點慘事….，桌上型電腦的電腦供應器壞掉了…，害我今天都沒有辦法好好的去工作，只好使用筆電來進行工作，但是不太習慣筆電的鍵盤高度，總是會讓自己的手掌後半部感到不適且我覺得筆電畫面很不適合寫程式，畫面太小不容易使人閱讀，且沒有我最喜歡的雙螢幕阿QQQQQ。

總之，學到了一件事，桌上型電腦電源有問題時要用筆電RRR。

hog 演算法明顯比起 sift 演算法來說更準確些，我自己在寫 sift 遇到一堆坑QQQQ，例如 kmeans 語法如果圖片的特徵數量小於之前 sift 訓練的 model 時，就會噴錯QQQ。

我認為 sift 可以保留光影、選轉，才使得相同光影或相同選轉的手勢都被視為一樣的手勢。例如相同光影的剪刀與相同光影的石頭有可能在 sift 中被視為相同的手勢。才使得 sift 演算法辨識率過低。

因為 hog 他只對邊緣進行辨識，剪刀、石頭、布的邊緣都不一樣，其中還是會有些許的誤差，想必是在剪刀平面、布平面的情況下，才有機會被 hog 視為相同手勢。

經過這次的研究，我學會了很多。謝謝助教、老師、與我一起努力的組員呢。

參考來源

Python + OpenCV 將兩張影像合成一張 by K_程式人
random — 生成伪随机数 by Python
Day19-Random模組 by it邦幫忙
Python Raise an Exception by w3schools
Updating scikit-learn: ‘SVC’ object has no attribute ‘_probA’? by stackoverflow

圖片提供

結果畫面

svm SIFT 演算法訓練集測試結果

svm HOG 演算法訓練集測試結果

猜拳結果，使用 HOG 演算法

tie

fail

猜拳結果，使用 SIFT 演算法

需要特別注意 scipy.cluster.vq.kmean 函式，一開始會隨機選擇一座標進行分類，因此每一次使用此函數不一定回傳值永遠相同，視每次分類而定；因此在執行我這份程式碼時，準確率與我不同並沒有錯。

tie，但是辨識錯誤

win，但是辨識錯誤

程式碼

直接透過程式碼來進行說明，相信會比較好理解。

特別注意：你必須先在你的電腦環境先 train 一次要使用的演算法 model，由於每個電腦所使用的套件版本不同，在 joblib.load 會發生衝突。因此建議先在你的電腦環境先 train 一次要使用的演算法 model，就不會發生此問題。

程式碼我將它分為四部分

hw07_fn.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
# -*- coding: utf-8 -*-
"""
Created on Sun Apr 18 15:58:29 2021

@author: user
"""
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Apr 8 10:58:26 2021

"""

import cv2
import numpy as np
from skimage.feature import hog as feature_hog
from sklearn.datasets import fetch_lfw_people
from sklearn import svm
from scipy.cluster.vq import kmeans, vq
from sklearn.model_selection import train_test_split
import os 
import random

def path_check(path): #由於這裡是 path，防呆測試。避免使用者輸入路徑時
                      #後面沒有 '/'，導致路徑被合併
    if(path[-1] != '/'):
        path += '/'
    return path
        
def rename_image(folder, category): #將資料夾裡面的檔案全部重新命名
    folder = path_check(folder) #路徑防呆測試
    images = os.listdir(folder)  #讀取路徑全部資料
    i = 1 #編號從 1 開始
    
    for old_name in images:
        new_name = "%s-%d.jpg" % (category, i) #命名格式
        while (not os.path.isfile(folder+new_name)): 
            i += 1
            #判定新的檔名有沒有被使用過，如果有就放棄
        os.rename(folder+old_name, folder+new_name) #將資料改名
        print("修改當前檔案", old_name, new_name)
        i += 1 # i += 1

def read(path):
  data = list()
  images = os.listdir(path) #讀資料夾
  for image in images: #iterator 
    #print("正在讀取", path + image)
    image = cv2.imread(path + image) #必須是相對路徑
    #image = cv2.resize(image, (2375,3137))
    image = cv2.resize(image, (237,313)) #重新 resize，如果沒有那訓練模型可能會極大
    #效率極差，程式跑很久
    data.append(image) #image 加入 list
  return data #回傳資料

def sift(data): #SIFT 特徵取出 data 為讀取近 python 的原始圖片
  output = list()
  sift_feature = cv2.SIFT_create() #初始化特徵點
  for image in data:
    kp, des = sift_feature.detectAndCompute(image, None) #對圖片進行 sift 讀取
    output.append(des) 
  return output #回傳 list

def hog(data):
    output = list() 
    for image in data:
        fd, hog_image = feature_hog( #將資料透過 hog 描繪邊緣
        image, 
        orientations=8, #8方向，上下左右、左上下、右上下
        pixels_per_cell=(9,9), #(9,9) 為一個邊緣區塊
        cells_per_block=(1,1), #(1,1) 個邊緣區塊是一個大區塊
        visualize=True, #可視性 true
        )
        output.append(fd) #存入 output 
    return output #回傳 list
    
def kmeans_return_features(k, sift): #取出特徵，透過 kmeans 分辨
  #k 為要分辨的特徵類別數量，建議是資料類別乘以 10，sift 為擁有圖片特徵的 list
  descriptors = sift[0] #先給予一個值，以避免不能合併
  for it in sift[1:]:
    descriptors = np.vstack((descriptors, it)) #採用水平方式將陣列堆疊起來
  
  print(len(descriptors))
  if(len(descriptors) < k): #有可能圖片的特徵數小於 k，就無法做 kmean 演算法，因此在這邊做提醒
    raise Exception("無法辨識，因為此圖片特徵數小於 k")

  voc, train_variance = kmeans(descriptors,k,1)
  #透過 kmeans 將特徵進行分配，相似的放在一起，並分成 k 倍，只進行 1 次 iteratior
  #voc 回傳陣列，長度為 k，第 i 類有著相同的特徵，
  #variance 回傳觀察值與中心點，可能會有失真問題，如果不要失真或許可以使用 kmeans2 方法
  
  #features histogram
  im_features = np.zeros((len(sift), k), "float32") #生成一個全為 0 的陣列
  for i in range(len(sift)):
    words, distance = vq(sift[i], voc)
    #將 voc 收集到的特徵，與圖片 sift[i] 與中心點進行比較，將最相似的特徵分配給適合的圖片
    #words 回傳陣列，接受此圖片最適合的所有特徵
    #distance 觀察值與中心點的距離，可能會有失真的可能性

    for j in words:   #將特徵傳給 im_features
      im_features[i][j] += 1 #表示此圖片的 j 特徵加一
      
  return im_features #回傳 list
  
def random_image(folder): #隨機選擇資料夾圖片
    folder = path_check(folder) #防呆測試
    images = os.listdir(folder) #將資料夾全部圖片讀出
    random_filename = random.choice(images) #隨機選擇其中一張圖片
    image = cv2.imread(folder + random_filename) #路徑合併，並 opencv 讀取
    image = cv2.resize(image, (237,313)) #圖片需要 resize 與訓練模型圖片 size 相同
    print(folder + random_filename) #輸出路徑檢查
    return image #回傳圖片

hog_train.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# -*- coding: utf-8 -*-
"""
Created on Sat Apr 24 17:08:38 2021

@author: User
"""
# -*- coding: utf-8 -*-
"""
Created on Sat Apr 24 14:12:06 2021

@author: User
"""

import cv2
import numpy as np
from skimage.feature import hog
from sklearn.datasets import fetch_lfw_people
from sklearn import svm
from scipy.cluster.vq import kmeans, vq
from sklearn.model_selection import train_test_split
import joblib
import hw07_fn #這是我自己寫的 functional progamming，請自行將上面的 function python code
#與此檔案放在同個資料夾底下

#將資料夾裡面全部資料夾的名子全部統一格式，通常只需要使用一次，資料夾內容全部統一命名。
#hw07_fn.rename_image("./scissors/", "scissor")
# hw07_fn.rename_image("./papers/", "paper")
# hw07_fn.rename_image("./rocks/", "rock")

scissors = hw07_fn.read("./scissors/") #讀此資料夾資料
papers = hw07_fn.read("./papers/") #讀此資料夾資料
rocks = hw07_fn.read("./rocks/") #讀此資料夾資料

sift_scissors = hw07_fn.hog(scissors) #對剪刀圖片進行 hog 演算法
sift_papers = hw07_fn.hog(papers) #對剪刀圖片進行 hog 演算法
sift_rocks = hw07_fn.hog(rocks) #對剪刀圖片進行 hog 演算法

x = sift_scissors + sift_rocks + sift_papers #data 合併
y = ["剪刀"] * len(sift_scissors) + ["石頭"] * len(sift_rocks) + ["布"] * len(sift_papers)
#target 合併

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=0) 
#產生出訓練資料集、測試資料集

clf = svm.SVC(kernel="linear", C=1, gamma="auto", probability=True) #SVC 訓練
clf.fit(x_train, y_train) #開始進行訓練

print("accuracy") #準確率
print("train:", clf.score(x_train, y_train)) #訓練集分數
print("test:", clf.score(x_test, y_test)) #測試集分數

joblib.dump(clf, "hog_paper_scissor_rock_game.pkl") #輸出成檔案，在需要使用時 load，以方便使用。

sift_train.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
# -*- coding: utf-8 -*-
"""
Created on Sat Apr 24 14:12:06 2021

@author: User
"""

import cv2
import numpy as np
from skimage.feature import hog
from sklearn.datasets import fetch_lfw_people
from sklearn import svm
from scipy.cluster.vq import kmeans, vq
from sklearn.model_selection import train_test_split
import joblib
import hw07_fn #這是我自己寫的 functional progamming，請自行將上面的 function python code
#與此檔案放在同個資料夾底下

#將資料夾裡面全部資料夾的名子全部統一格式，通常只需要使用一次，資料夾內容全部統一命名。
#hw07_fn.rename_image("./scissors/", "scissor")
# hw07_fn.rename_image("./papers/", "paper")
# hw07_fn.rename_image("./rocks/", "rock")

scissors = hw07_fn.read("./scissors/") #讀此資料夾資料
papers = hw07_fn.read("./papers/") #讀此資料夾資料
rocks = hw07_fn.read("./rocks/") #讀此資料夾資料

sift_scissors = hw07_fn.sift(scissors) #對剪刀圖片進行 sift 演算法
sift_papers = hw07_fn.sift(papers)  #對石頭圖片進行 sift 演算法
sift_rocks = hw07_fn.sift(rocks)  #對布圖片進行 sift 演算法

#data 透過 kmeans 分類特徵
x = hw07_fn.kmeans_return_features(24, sift_scissors + sift_rocks + sift_papers)
y = ["剪刀"] * len(sift_scissors) + ["石頭"] * len(sift_rocks) + ["布"] * len(sift_papers)
#target 合併

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=0)
#產生出訓練資料集、測試資料集

clf = svm.SVC(kernel="linear", C=1, gamma="auto", probability=True) #SVC 訓練
clf.fit(x_train, y_train) #開始進行訓練

print("accuracy") #準確率
print("train:", clf.score(x_train, y_train)) #訓練集分數
print("test:", clf.score(x_test, y_test)) #測試集分數

joblib.dump(clf, "sift_paper_scissor_rock_game.pkl")
# 輸出成檔案，在需要使用時 load，以方便使用。

super_bang4.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
# -*- coding: utf-8 -*-
"""
Created on Sat Apr 24 15:26:14 2021

@author: User
"""
import cv2
import joblib
import hw07_fn
from sklearn.decomposition import PCA
import numpy as np

def sift(image): #使用 sift 辨識，讀入圖片
    clf = joblib.load("./sift_paper_scissor_rock_game.pkl") #讀入前面 sift 的模型
    sift_image = hw07_fn.sift([image]) #讀入圖片，必須是 list 格式。hw07_fn 前面要求
    x = hw07_fn.kmeans_return_features(24, sift_image) #找出圖片分類特徵
    predict = clf.predict(x) #進行預測，輸出類別
    print("sift 辨識")
    print(predict) #輸出類別
    print(clf.predict_proba(x)) #輸出判斷為每個類別機率
    return predict #回傳類別
    
def hog(image):
    clf = joblib.load("./hog_paper_scissor_rock_game.pkl") #讀入前面 hog 的模型
    x = hw07_fn.hog([image]) #讀入圖片，必須是 list 格式。hw07_fn 前面要求
    predict = clf.predict(x) #進行預測，輸出類別
    print("hog 辨識")
    print(predict) #輸出類別
    print(clf.predict_proba(x)) #輸出判斷為每個類別機率
    return predict #回傳類別

#hw07_fn.rename_image("./game/", "image")p1 = hw07_fn.random_image("./game")

p1 = hw07_fn.random_image("./game") #隨機從資料集抽一張圖片
#cv2.imshow("player1", p1) #show
p2 = hw07_fn.random_image("./game") #隨機從資料集抽一張圖片
#cv2.imshow("player1", p1) #show

#有可能 sift 的圖片特徵不夠多，小於 SVC sift 演算法的 k，就會出錯
#出錯如下 Exception: 無法辨識，因為此圖片特徵數小於 k
#predict1 = sift(p2) #進行 sift 演算法 
#predict2 = sift(p2) #進行 sift 演算法
predict1 = hog(p1) #進行 hog 演算法
predict2 = hog(p2) #進行 hog 演算法

lose = cv2.imread("lose.jpg") #讀取失敗圖片
lose = cv2.resize(lose, (400,313)) #resize
win = cv2.imread("win.jpg") #讀取勝利圖片
win = cv2.resize(lose, (400,313)) #resize
tie = cv2.imread("tie.png")  #讀取平手圖片
tie = cv2.resize(tie, (400,313)) #resize

#判斷剪刀石頭布輸贏規則
if(predict1 == "剪刀" and predict2 == "石頭"):
    result = np.hstack((p1,lose,p2))
elif(predict1 == "石頭" and predict2 == "布"):
    result = np.hstack((p1,lose,p2))
elif(predict1 == "布" and predict2 == "剪刀"):
    result = np.hstack((p1,lose,p2)) 
elif(predict1 == "剪刀" and predict2 == "布"):
    result = np.hstack((p1,win,p2))
elif(predict1 == "布" and predict2 == "石頭"):
    result = np.hstack((p1,win,p2))
elif(predict1 == "石頭" and predict2 == "剪刀"):
    result = np.hstack((p1,win,p2))
else:
    result = np.hstack((p1,tie,p2))

cv2.imshow("result", result) #輸出結果畫面
#cv2.imshow("result", np.hstack((p1,tie,p2)))

原始程式碼

下面是沒有註解程式碼

程式碼我將它分為四部分

hw07_fn.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
# -*- coding: utf-8 -*-
"""
Created on Sun Apr 18 15:58:29 2021

@author: user
"""
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Apr 8 10:58:26 2021

"""

import cv2
import numpy as np
from skimage.feature import hog as feature_hog
from sklearn.datasets import fetch_lfw_people
from sklearn import svm
from scipy.cluster.vq import kmeans, vq
from sklearn.model_selection import train_test_split
import os 
import random

def path_check(path):
    if(path[-1] != '/'):
        path += '/'
    return path
        
def rename_image(folder, category):
    folder = path_check(folder)
    images = os.listdir(folder) 
    i = 1
    
    for old_name in images:
        new_name = "%s-%d.jpg" % (category, i)
        while (not os.path.isfile(folder+new_name)): 
            i += 1
        os.rename(folder+old_name, folder+new_name)
        print("修改當前檔案", old_name, new_name)
        i += 1

def read(path):
  data = list()
  images = os.listdir(path)
  for image in images:
    #print("正在讀取", path + image)
    image = cv2.imread(path + image) #必須是相對路徑
    #image = cv2.resize(image, (2375,3137))
    image = cv2.resize(image, (237,313))
    data.append(image)
  return data

def sift(data):
  output = list()
  sift_feature = cv2.SIFT_create()
  for image in data:
    kp, des = sift_feature.detectAndCompute(image, None)
    output.append(des)
  return output

def hog(data):
    output = list()
    for image in data:
        fd, hog_image = feature_hog(
        image,
        orientations=8,
        pixels_per_cell=(9,9),
        cells_per_block=(1,1),
        visualize=True,
        )
        output.append(fd)
    return output
    
def kmeans_return_features(k, sift):
  descriptors = sift[0]
  for it in sift[1:]:
    descriptors = np.vstack((descriptors, it))  
  
  print(len(descriptors))
  if(len(descriptors) < k):
    raise Exception("無法辨識，因為此圖片特徵數小於 k")
  voc, train_variance = kmeans(descriptors,k,1)
  
  #features histogram
  im_features = np.zeros((len(sift), k), "float32")
  for i in range(len(sift)):
    words, distance = vq(sift[i], voc)
    for j in words:
      im_features[i][j] += 1
      
  return im_features    
  
def random_image(folder):
    folder = path_check(folder)
    images = os.listdir(folder)
    random_filename = random.choice(images)
    image = cv2.imread(folder + random_filename)
    image = cv2.resize(image, (237,313))
    print(folder + random_filename)
    return image

hog_train.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
# -*- coding: utf-8 -*-
"""
Created on Sat Apr 24 17:08:38 2021

@author: User
"""
# -*- coding: utf-8 -*-
"""
Created on Sat Apr 24 14:12:06 2021

@author: User
"""

import cv2
import numpy as np
from skimage.feature import hog
from sklearn.datasets import fetch_lfw_people
from sklearn import svm
from scipy.cluster.vq import kmeans, vq
from sklearn.model_selection import train_test_split
import joblib
import hw07_fn #這是我自己寫的 functional progamming，請自行將上面的 function python code
#與此檔案放在同個資料夾底下

#hw07_fn.rename_image("./scissors/", "scissor")
# hw07_fn.rename_image("./papers/", "paper")
# hw07_fn.rename_image("./rocks/", "rock")

scissors = hw07_fn.read("./scissors/")
papers = hw07_fn.read("./papers/")
rocks = hw07_fn.read("./rocks/")

sift_scissors = hw07_fn.hog(scissors)
sift_papers = hw07_fn.hog(papers)
sift_rocks = hw07_fn.hog(rocks)

x = sift_scissors + sift_rocks + sift_papers
y = ["剪刀"] * len(sift_scissors) + ["石頭"] * len(sift_rocks) + ["布"] * len(sift_papers)

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=0)

clf = svm.SVC(kernel="linear", C=1, gamma="auto", probability=True)
clf.fit(x_train, y_train) #開始進行訓練

print("accuracy") #準確率
print("train:", clf.score(x_train, y_train)) #訓練集分數
print("test:", clf.score(x_test, y_test)) #測試集分數

joblib.dump(clf, "hog_paper_scissor_rock_game.pkl")

sift_train.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# -*- coding: utf-8 -*-
"""
Created on Sat Apr 24 14:12:06 2021

@author: User
"""

import cv2
import numpy as np
from skimage.feature import hog
from sklearn.datasets import fetch_lfw_people
from sklearn import svm
from scipy.cluster.vq import kmeans, vq
from sklearn.model_selection import train_test_split
import joblib
import hw07_fn #這是我自己寫的 functional progamming，請自行將上面的 function python code
#與此檔案放在同個資料夾底下

#hw07_fn.rename_image("./scissors/", "scissor")
# hw07_fn.rename_image("./papers/", "paper")
# hw07_fn.rename_image("./rocks/", "rock")

scissors = hw07_fn.read("./scissors/")
papers = hw07_fn.read("./papers/")
rocks = hw07_fn.read("./rocks/")

sift_scissors = hw07_fn.sift(scissors)
sift_papers = hw07_fn.sift(papers)
sift_rocks = hw07_fn.sift(rocks)

x = hw07_fn.kmeans_return_features(20, sift_scissors + sift_rocks + sift_papers)
y = ["剪刀"] * len(sift_scissors) + ["石頭"] * len(sift_rocks) + ["布"] * len(sift_papers)

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=0)

clf = svm.SVC(kernel="linear", C=1, gamma="auto", probability=True)
clf.fit(x_train, y_train) #開始進行訓練

print("accuracy") #準確率
print("train:", clf.score(x_train, y_train)) #訓練集分數
print("test:", clf.score(x_test, y_test)) #測試集分數

joblib.dump(clf, "sift_paper_scissor_rock_game.pkl")

super_bang4.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
# -*- coding: utf-8 -*-
"""
Created on Sat Apr 24 15:26:14 2021

@author: User
"""
import cv2
import joblib
import hw07_fn
from sklearn.decomposition import PCA
import numpy as np
import os

def sift(image):
    clf = joblib.load("./sift_paper_scissor_rock_game.pkl") 
    sift_image = hw07_fn.sift([image])
    x = hw07_fn.kmeans_return_features(20, sift_image)
    predict = clf.predict(x)
    print("sift 辨識")
    print(predict)
    print(clf.predict_proba(x))
    return predict
    
def hog(image):
    clf = joblib.load("./hog_paper_scissor_rock_game.pkl") 
    x = hw07_fn.hog([image])
    predict = clf.predict(x)
    print("hog 辨識")
    print(predict)
    print(clf.predict_proba(x))
    return predict

#hw07_fn.rename_image("./game/", "image")p1 = hw07_fn.random_image("./game")

p1 = hw07_fn.random_image("./game")
#cv2.imshow("player1", p1)
p2 = hw07_fn.random_image("./game")
#cv2.imshow("player1", p1)

predict1 = sift(p1) 
predict2 = sift(p2) 

#predict1 = hog(p1) 
#predict2 = hog(p2)

lose = cv2.imread("lose.jpg")
lose = cv2.resize(lose, (400,313))
win = cv2.imread("win.jpg")
win = cv2.resize(win, (400,313))
tie = cv2.imread("tie.png")
tie = cv2.resize(tie, (400,313))

if(predict1 == "剪刀" and predict2 == "石頭"):
    result = np.hstack((p1,lose,p2))
elif(predict1 == "石頭" and predict2 == "布"):
    result = np.hstack((p1,lose,p2))
elif(predict1 == "布" and predict2 == "剪刀"):
    result = np.hstack((p1,lose,p2)) 
elif(predict1 == "剪刀" and predict2 == "布"):
    result = np.hstack((p1,win,p2))
elif(predict1 == "布" and predict2 == "石頭"):
    result = np.hstack((p1,win,p2))
elif(predict1 == "石頭" and predict2 == "剪刀"):
    result = np.hstack((p1,win,p2))
else:
    result = np.hstack((p1,tie,p2))

cv2.imshow("result", result)
#cv2.imshow("result", np.hstack((p1,tie,p2)))
  • 版權聲明： 本部落格所有文章除有特別聲明外，均採用 Apache License 2.0 許可協議。轉載請註明出處！
  • © 2020-2024 John Doe
  • Powered by Hexo Theme Ayer
  • PV: UV: