简单剪刀石头布的识别:问题记录

最新推荐文章于 2024-07-25 08:39:03 发布
最新推荐文章于 2024-07-25 08:39:03 发布
阅读量960 收藏 4
点赞数 2
分类专栏： visual project
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45293612/article/details/111600670
版权

手势识别首先想到两种方法, opencv计算hu, 神经网络图片分类

一. opencv计算hu
1. HU是什么?
一 原理

几何矩是由Hu(Visual pattern recognition by moment invariants)在1962年提出的，具有平移、旋转和尺度不变性。 定义如下：

① (p+q)阶不变矩定义：
在这里插入图片描述
② 对于数字图像，离散化，定义为：
在这里插入图片描述

③ 归一化中心矩定义：

在这里插入图片描述

④Hu矩定义
在这里插入图片描述
要点:
1. pq代表的是维度
2. 矩具有平移不变性(显然)
3. 均一化矩(与零维矩的比值)具有平移,旋转,缩放不变性

所以回到代码实现
首先提取手部信息,两种方法, 一是利用手的颜色提取,二是用手的轮廓提取. 手的颜色在相机中不稳定, 且容易提取到别的东西. 老方法: 二值化+图像形态学操作

        frame = cv.cvtColor(frame, cv.COLOR_RGB2GRAY)
        cv.threshold(frame, 120, 255, cv.THRESH_TOZERO, dst=frame)
        # cv.threshold(frame, 100, 255, cv.THRESH_BINARY, dst=frame)
        kernal = cv.getStructuringElement(cv.MORPH_RECT, (13, 13))
        cv.morphologyEx(frame, cv.MORPH_OPEN, kernal, dst=frame)

findContour,然后利用contour的面积进一步排除,最后调用矩对比函数(先前存好了参考图像)

		contours, hierarchy = cv.findContours(frame, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
        real_contours = []
        contours_hu = []
        for contour in contours:
            contour_area = cv.contourArea(contour)
            if contour_area < 13000 or contour_area > 45000:
                pass
            else:
                real_contours.append(contour)
                # print(contour_area)

        for real_contour in real_contours:
            s = cv.matchShapes(SCISSORS, real_contour, 1, 0.0)
            r = cv.matchShapes(ROCK, real_contour, 1, 0.0)
            p = cv.matchShapes(PAPER, real_contour, 1, 0.0)
            if s < r and s < p:
                print("SCISSORS")
            if r < s and r < p:
                print("ROCK")
            if p < r and p < s:
                print("PAPER")

矩在opencv中还有其他函数,但是原理大同小异.
矩对比, 模板匹配都可以实现图像分类的功能, 矩经过改造后也可以实现模板匹配的全部功能,可以说矩是一种高级的,抽象化,降维的模板匹配.

二. 神经网络
*从这里开始一堆破事开始出现了

  1. 首先想到的是tensorflow官方给出的基础教程
    https://tensorflow.google.cn/tutorials/keras/classification
    其中很简单的,用keras,设计了一个单层的全联通网络,在MNIST上效果很好.所以下意识的(偷懒),打算直接弄过来. 先是利用 glob模块, 和群里发布的数据集开始进行数据清理.
def getPictures():
    paths = glob.glob("E:\\03-project\\02-basketball\\01-handreconization\\pictures\\paper\\*")
    paths1 = glob.glob("E:\\03-project\\02-basketball\\01-handreconization\\pictures\\rock\\*")
    paths2 = glob.glob("E:\\03-project\\02-basketball\\01-handreconization\\pictures\\scissors\\*")
    list_images = []
    for path in paths:
        # print(path)
        src_image = cv.imread(path, -1)
        list_images.append([1, src_image])
    for path in paths1:
        # print(path)
        src_image = cv.imread(path, -1)
        list_images.append([2, src_image])
    for path in paths2:
        # print(path)
        src_image = cv.imread(path, -1)
        list_images.append([3, src_image])
    np.random.shuffle(list_images)
    return list_images

文件的读取很顺利. 但是由于给的训练图像是绿幕图, 所以要进行一个抠图. 也没有怎么百度啥的, 简单的就像根据图像去扣, 效果惨不忍睹,另外一个就是findcontours里面的contour是顺着手内部的,这个问题我在另外一个车道检测的项目中也遇到过,需要设定roi区域, 但是没有找到能根治的方法, 深度学习这一部分问题太多了,还是先等有空了再去学一下把.

	def aaaaaa():
		image = src_image

        image = src_image[:, :, 0] + src_image[:, :, 2]
        cv.threshold(image, 170, 255, cv.THRESH_BINARY, dst=image)

        kernel = cv.getStructuringElement(cv.MORPH_RECT, (57, 57))
        cv.morphologyEx(image, cv.MORPH_DILATE, kernel, image)
        kernel = cv.getStructuringElement(cv.MORPH_RECT, (37, 37))
        cv.morphologyEx(image, cv.MORPH_ERODE, kernel, image)
        low_hand_color = np.array([0, 0, 0])
        high_hand_color = np.array([255, 150, 255])
        mask = cv.inRange(image, low_hand_color, high_hand_color)
        image = cv.bitwise_and(image, image, mask=mask)

        contours, hierarchy = cv.findContours(image, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
        cv.drawContours(src_image, contours, -1, [255, 0, 0], 3)

        cv.imshow("process_frame", image)
        cv.waitKey(0)
    real_contours = []
    contours_hu = []
    for contour in contours:
        contour_area = cv.contourArea(contour)
        if contour_area < 13000 or contour_area > 45000:
            pass
        else:
            real_contours.append(contour)
            # print(contour_area)


    self.contours = real_contours

(未完待续)

全部代码:
Opencv:

import cv2 as cv
import numpy as np

import sys


def Scissors_Rock_Paper():
    scissors_frame = cv.imread("01.jpg")
    scissors_frame = cv.cvtColor(scissors_frame, cv.COLOR_BGR2GRAY)
    cv.threshold(scissors_frame, 100, 255, cv.THRESH_BINARY, dst=scissors_frame)
    kernal = cv.getStructuringElement(cv.MORPH_RECT, (13, 13))
    cv.morphologyEx(scissors_frame, cv.MORPH_OPEN, kernal, dst=scissors_frame)
    scissors_contours, his = cv.findContours(scissors_frame, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
    SCISSORS = np.zeros(scissors_frame.shape)
    cv.drawContours(SCISSORS, scissors_contours, -1, [255], 3)
    # cv.imshow("SCISSORS", SCISSORS)

    rock_frame = cv.imread("02.jpg")
    rock_frame = cv.cvtColor(rock_frame, cv.COLOR_BGR2GRAY)
    cv.threshold(rock_frame, 100, 255, cv.THRESH_BINARY, dst=rock_frame)
    kernal = cv.getStructuringElement(cv.MORPH_RECT, (13, 13))
    cv.morphologyEx(rock_frame, cv.MORPH_OPEN, kernal, dst=rock_frame)
    rock_contours, hir = cv.findContours(rock_frame, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
    ROCK = np.zeros(rock_frame.shape)
    cv.drawContours(ROCK, rock_contours, -1, [255], 3)
    # cv.imshow("ROCK", ROCK)

    paper_frame = cv.imread("03.jpg")
    paper_frame = cv.cvtColor(paper_frame, cv.COLOR_BGR2GRAY)
    cv.threshold(paper_frame, 100, 255, cv.THRESH_BINARY, dst=paper_frame)
    kernal = cv.getStructuringElement(cv.MORPH_RECT, (13, 13))
    cv.morphologyEx(paper_frame, cv.MORPH_OPEN, kernal, dst=paper_frame)
    paper_contours, hi = cv.findContours(paper_frame, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
    PAPER = np.zeros(paper_frame.shape)
    cv.drawContours(PAPER, paper_contours, -1, [255], 3)
    # cv.imshow("PAPER", PAPER)
    return scissors_contours[0], rock_contours[0], paper_contours[0]


SCISSORS, ROCK, PAPER = Scissors_Rock_Paper()


class Frame:
    def __init__(self, path):
        self.cap = cv.VideoCapture(path, cv.CAP_DSHOW)

    def __call__(self, **kwargs):
        self.ret, self.frame = self.cap.read()
        if not self.ret:
            raise Exception
        else:
            return self.frame


class Process:
    def __call__(self, frame, **kwargs):

        self.frame = np.copy(frame)
        cv.GaussianBlur(frame, (3, 3), 0, dst=frame)
        self.frame = frame

        return self.frame

    def draw_self_contours(self, frame):
        cv.drawContours(frame, self.contours, -1, [255, 0, 0], 3)
        return frame

    # 相机曝光是自动的，同时环境曝光也是自动的，无法有效提取肉色，放弃
    def get_hand_by_color(self):
        frame = self.frame
        low_hand_color = np.array([149, 136, 128])
        high_hand_color = np.array([249, 236, 218])
        mask = cv.inRange(frame, low_hand_color, high_hand_color)
        self.frame = cv.bitwise_and(frame, frame, mask=mask)
        return self.frame

    def get_hand_by_findcontours(self):
        frame = self.frame
        frame = cv.cvtColor(frame, cv.COLOR_RGB2GRAY)
        cv.threshold(frame, 120, 255, cv.THRESH_TOZERO, dst=frame)
        # cv.threshold(frame, 100, 255, cv.THRESH_BINARY, dst=frame)
        kernal = cv.getStructuringElement(cv.MORPH_RECT, (13, 13))
        cv.morphologyEx(frame, cv.MORPH_OPEN, kernal, dst=frame)
        contours, hierarchy = cv.findContours(frame, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
        real_contours = []
        contours_hu = []
        for contour in contours:
            contour_area = cv.contourArea(contour)
            if contour_area < 13000 or contour_area > 45000:
                pass
            else:
                real_contours.append(contour)
                # print(contour_area)

        for real_contour in real_contours:
            s = cv.matchShapes(SCISSORS, real_contour, 1, 0.0)
            r = cv.matchShapes(ROCK, real_contour, 1, 0.0)
            p = cv.matchShapes(PAPER, real_contour, 1, 0.0)
            if s < r and s < p:
                print("SCISSORS")
            if r < s and r < p:
                print("ROCK")
            if p < r and p < s:
                print("PAPER")

        self.contours = real_contours
        return frame

    # def decide_hand_meaning(self):


class_frame = Frame(0)
class_process = Process()

while True:
    process_frame = class_frame()
    class_process(process_frame)

    cv.imshow("processing frame", class_process.get_hand_by_findcontours())
    cv.imshow("input_frame", class_process.draw_self_contours(process_frame))

    cv.waitKey(27)

tensorflow:

import tensorflow as tf

import keras

import cv2 as cv

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

import glob


def get_picture(path, kind):
    pictures_paths = glob.iglob(path)
    pictures = []
    for pictures_path in pictures_paths:
        picture = cv.imread(pictures_path)
        pictures.append([kind, picture])
    return pictures


def getPictures():
    paths = glob.glob("E:\\03-project\\02-basketball\\01-handreconization\\pictures\\paper\\*")
    paths1 = glob.glob("E:\\03-project\\02-basketball\\01-handreconization\\pictures\\rock\\*")
    paths2 = glob.glob("E:\\03-project\\02-basketball\\01-handreconization\\pictures\\scissors\\*")
    list_images = []
    for path in paths:
        # print(path)
        src_image = cv.imread(path, -1)
        list_images.append([1, src_image])
    #     image = src_image
    #
    #     image = src_image[:, :, 0] + src_image[:, :, 2]
    #     cv.threshold(image, 170, 255, cv.THRESH_BINARY, dst=image)
    #
    #     kernel = cv.getStructuringElement(cv.MORPH_RECT, (57, 57))
    #     cv.morphologyEx(image, cv.MORPH_DILATE, kernel, image)
    #     kernel = cv.getStructuringElement(cv.MORPH_RECT, (37, 37))
    #     cv.morphologyEx(image, cv.MORPH_ERODE, kernel, image)
    #     low_hand_color = np.array([0, 0, 0])
    #     high_hand_color = np.array([255, 150, 255])
    #     mask = cv.inRange(image, low_hand_color, high_hand_color)
    #     image = cv.bitwise_and(image, image, mask=mask)
    #
    #     contours, hierarchy = cv.findContours(image, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
    #     cv.drawContours(src_image, contours, -1, [255, 0, 0], 3)
    #
    #     cv.imshow("process_frame", image)
    #     cv.waitKey(0)
    # real_contours = []
    # contours_hu = []
    # for contour in contours:
    #     contour_area = cv.contourArea(contour)
    #     if contour_area < 13000 or contour_area > 45000:
    #         pass
    #     else:
    #         real_contours.append(contour)
    #         # print(contour_area)
    #
    # for real_contour in real_contours:
    #     s = cv.matchShapes(SCISSORS, real_contour, 1, 0.0)
    #     r = cv.matchShapes(ROCK, real_contour, 1, 0.0)
    #     p = cv.matchShapes(PAPER, real_contour, 1, 0.0)
    #     if s < r and s < p:
    #         print("SCISSORS")
    #     if r < s and r < p:
    #         print("ROCK")
    #     if p < r and p < s:
    #         print("PAPER")
    #
    # self.contours = real_contours
    for path in paths1:
        # print(path)
        src_image = cv.imread(path, -1)
        list_images.append([2, src_image])
    for path in paths2:
        # print(path)
        src_image = cv.imread(path, -1)
        list_images.append([3, src_image])
    np.random.shuffle(list_images)
    return list_images


TRAIN_DATA = getPictures()
train_images = []
train_index = []
for data in TRAIN_DATA:
    train_images.append(data[1])
    train_index.append(data[0])
    # cv.imshow("data", data[1])
    # print(data[0])
    # cv.waitKey(0)


model = keras.Sequential([
    keras.layers.Flatten(input_shape=(300, 200)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10)
])

model.compile(optimizer='adam',
              loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

model.fit(train_images, train_index, epochs=30)

test_loss, test_acc = model.evaluate(train_images, train_index, verbose=2)
print("TEST accuracy:", test_acc)


SCISSOR_PICTURES = get_picture("", 0)
ROCK_PICTURES = get_picture("", 1)
PAPER_PICTURES = get_picture("", 2)
The screw
关注
专栏目录
2024华为OD机考机试E卷 +C卷 + D卷 + B卷 + A卷：真题目录 + 考点说明
算法大师！
03-18 38万+
OD，全称(Outsourcing Dispacth)模式，目前华为和德科联合招聘的简称。华为社招基本都是OD招聘，17级以下都是OD模式（13-17）。
Opencv项目实战：00 专栏内容介绍
m0_62919535的博客
07-04 1344
Opencv项目实战，持续更新中。如今更新到 24 石头剪刀布
OpenCV手势动作识别--石头剪刀布
04-22
OPENCV手势动作识别-石头剪刀布，OpenCV3.0版本，VS2012完美运行。
石头剪刀布 手势识别
onezeros的专栏
10-09 7915
优酷演示源码下载 http://download.csdn.net/source/2744141我用到的算法很简单，提取的特征值也是很简单的，但是很有效，我使用目标矩形区域的宽高比和目标像素比例作为特征值在测试图像库中测试的结果是，石头和布的识别率都接近90%，剪刀的识别率最低，只有60%，但在玩儿的时候，整体识别是不错的用了一个晚上采集样本库有点大，另找机会上传
机器学习初识之石头、剪刀、布
最新发布
书山有路
07-25 1012
机器学习：告诉计算机哪个是石头哪个是布，哪个是剪刀，让计算机自己分析其中的规律。人类很容易就能够分辨石头、剪刀布，但是对于计算机来说却是个难题。如何让计算机能够从下面的X与Y的数列中找到X与Y的规律呢？机器学习：告诉计算机数据和答案，让计算机去分析规则。手型，皮肤颜色，还有各种各样的手残手势。传统编程：收集数据、制定规则、得到答案。如何教会计算机来分辨这些手势？怎么与计算机玩石头剪刀布？
【计算机视觉40例】案例08：石头剪刀布手势识别
计算机视觉之光
08-07 1631
计算机视觉40例——从入门到深度学习（OpenCV-Python）》在介绍Python基础、OpenCV基础、计算机视觉理论基础、深度学习理论的基础上，介绍了计算机视觉领域内具有代表性的40个典型案例。这些案例中，既有传统的案例（数字识别、答题卡识别、物体计数、缺陷检测、手势识别、隐身术、以图搜图、车牌识别、图像加密、指纹识别等），也有深度学习案例（图像分类、风格迁移、姿势识别、实例分割等），还有人脸识别方面的案例（表情识别、驾驶员疲劳监测、识别性别与年龄等）。......
基于opencv与mediapipe手势关键点检测，并使用KNN近邻算法手势识别（石头、剪刀、布）的python代码实现
weixin_71894495的博客
07-28 1667
本文主要利用opencv读取摄像头的手势画面数据，利用mediapipe库提供的方法将手势图像画面转化为手部21个关节点的坐标值，通过KNN近邻算法训练坐标值的数据，从而识别石头剪刀布三个手势
opencv实现的手势识别，石头剪刀布的实现，亲测可运行
11-22
一个实现石头剪刀布的小程序，基于opencv，在vs2010和opencv2.4.4下可以完美运行。
Python实战，桌面小游戏，剪刀石头布
一个好知识的传播者
07-02 1165
虽然这个“剪刀石头布”游戏的代码相对简单，但它涵盖了编程中的许多基本概念，如循环、条件判断、函数定义和调用等。通过不断实践和扩展，你可以将这个游戏发展成一个功能更加丰富、界面更加友好的游戏作品。希望这个实战项目能够激发你对Python编程和游戏开发的热情，继续探索更多可能性！Python项目开发实战_桌面小游戏-剪刀石头布_编程案例解析实例详解课程教程.pdf。
jiandaoshitoubu.zip_game
09-24
【描述】中的关键词“剪刀石头布”是大家熟知的、源自中国的猜拳游戏，通常用于解决简单的决策问题或者娱乐。游戏规则简单：剪刀剪布、布包石头、石头砸剪刀，每种手势都有其优势和劣势，形成了一种循环克制关系。在...
2024华为OD统一考试题库清单（持续收录中）以及考点说明
热门推荐
学Java，找哪吒
07-14 4万+
每一题都有详细的答题思路、详细的代码注释、样例测试，发现新题目，随时更新，全天CSDN在线答疑。
opencv+qt 摄像头手部检测识别（剪刀石头布）
12-02
opencv+qt 摄像头手部检测识别（剪刀石头布） http://www.cnblogs.com/hebaichuanyeah/p/5014519.html
基于OpenCV+MediaPipe的手势识别（数字、石头剪刀布等手势识别）
03-03
基于OpenCV+MediaPipe的手势识别（数字、石头剪刀布等手势识别） 可识别左右手，共定义了15种手势，可以自行增加 https://blog.csdn.net/weixin_53403301/article/details/123232435
matlab手势识别，通过训练，识别剪刀石头布的手势
06-20
基于matlab手势识别，通过训练，得到识别模型来识别简单地手势
opencv实现静态手势识别 opencv实现剪刀石头布游戏
09-19
主要为大家详细介绍了opencv实现静态手势识别，opencv实现剪刀石头布游戏，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
用TensorFlowjs十分钟实现石头剪子布
08-12
Training a Rock Paper Scissors model in the browser via TFJS - Learn along style
手势识别实践 | DIY应用到剪刀石头布机器人（附代码）
gzq0723的博客
10-27 2051
欢迎关注“计算机视觉研究院”计算机视觉研究院专栏作者：Edison_G 扫描二维码关注我们微信公众号 :计算机视觉研究院回复“手势识别”获取源码知乎专栏...
卷积神经网络手势识别之剪刀石头布
fencecat的博客
04-09 2643
神经网络训练实战石头剪刀布手势识别：加载数据，数据切分，数据预处理，构建网络，训练，测试，优化网络参数，投入使用
49剪刀石头布-函数参数标注类型
roymustang的博客
01-20 306
有一种游戏在计算机科学中具有特别重要的意义，因为它本身虽然很简单，但可用于创建非常狡猾的人工智能算法，以预测对手的行为与人类（或彼此）对战。 这款古老的游戏在两个参与者之间进行，他们同时用动作-石头，布或剪刀。 如果两个人都投相同的动作，则该回合被视为平局。 否则，将应用以下规则： Rock beats Scissors (by blunting them) Scissors beat Paper...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值