声明

原创文章，请勿转载！

本文内容仅限于安全研究，不公开具体源码。维护网络安全，人人有责。

本文关联文章超链接：

1. 极验点选验证码位置识别（一）：点选验证码位置识别技术总览

近期文章更新会慢一些，工作有些忙，再加上点选的识别数据集要重新做处理。太难了。
说多了都是泪，本来极验点选上个月已经破解了，准备写文章的，然后就先写了极验滑块系列的文章。回头一看点选的，卧槽，验证码图片更新了，得重新调整解决方案了。

一、技术栈

不管是极验还是其他厂家的点选验证码，都是一样的。首先要做的就是得到验证码中图标的位置和顺序信息。有了这两样，点选验证码不就和之前介绍的滑块验证码一样了吗，只需要破解对鼠标轨迹进行加密的js就行了。
本系列文章以极验为例，讲解整个点选验证码的识别到js破解的过程，小伙伴们耐心看完。

1. 验证码图片下载

因为后期会用到图片识别技术，所以需要下载大量的图片验证码，用作训练集。

2. 验证码图片预处理

将验证码图片分割成背景图和标签图，并分别做一系列预处理，提高后期图片识别准确率。

3. 标签图分割

标签图是我们要点击的图形验证码顺序，首先要将标签图中每个标签分离出来。可以看到每个标签之间还有粘连在一起的部分，因此此步骤需要用openCV对标签做图像边缘检测、分离技术。

4. 背景图图标标注

使用labelImg工具对背景图中的待检测图标进行标注，生成训练集。

5. 背景图图标训练&识别

本系列文章采用yolo5目标检测模型，检测出背景图中的图标。

5. siamese network模型训练

采用孪生神经网络模型训练第4步骤（背景图图标）和第3步骤（标签图图标）图片的相似度。

6. 相似度结果解析

对第5步骤返回的结果，对相似度进行排序，得到点选验证码的顺序和坐标。

二、结语

友情链接：极验点选验证码位置识别（二）：验证码图片下载&数据集预处理（还未更新）

本期文章结束啦，如果对您有帮助，记得收藏加关注哦，后期文章会持续更新 ~~~

之前做魔方机器人，使用的是人工输入默认的各个表面方块颜色分布，不够方便与智能，因此开始研究使用摄像头识别魔方。Opencv基本是首选而且方便简单的工具。本文将描述如何使用Opencv识别从摄像头抓取的魔方图片内魔方的各个方块边缘以及位置，用于后续的颜色的识别。

安装opencv

Pycharm支持从界面选择安装python包，在文件菜单下选择设置项，然后如下图找到安装界面：

需要用到的安装包列表：numpy，Matplotlib，opencv-python

边缘检测

从摄像头抓取的原图如下：

灰化去除颜色信息

代码：

import cv2
import numpy as np
from copy import deepcopy
import math

imgobj = cv2.imread('1.jpg')
gray = cv2.cvtColor(imgobj, cv2.COLOR_BGR2GRAY)
cv2.namedWindow("image")
cv2.imshow("image", gray)
cv2.waitKey(0)

效果如下：

高斯模糊扩大边缘效果

代码：

blurred = cv2.GaussianBlur(gray, (3, 3), 0)
cv2.imshow("image", blurred)
cv2.waitKey(0)

效果如下：

Canny算法实现边缘检测

Canny边缘检测是一种非常流行的边缘检测算法，是John Canny在1986年提出的。具体可以参考：
https://en.wikipedia.org/wiki/Canny_edge_detector

代码：

canny = cv2.Canny(blurred, 20, 40)
cv2.imshow("image", canny)
cv2.waitKey(0)

效果如下：

边缘线膨胀化

canny检测的边缘线很细，使得同一边缘有多个边缘线，这里可以用opencv dilate函数，使边缘线膨胀化，这样同一边缘的多个边缘线即可合并成同一条线。

代码：

kernel = np.ones((3,3), np.uint8)
dilated = cv2.dilate(canny, kernel, iterations=2)
cv2.imshow("image", blurred)
cv2.waitKey(0)

效果如下：

去除多余边缘

膨胀化后，可以看到很多魔方外的物体边缘，以及魔方内的小边缘，这些都需要去除。通过计算闭合边缘的面积以及中心点的位置，可以判断出哪些是魔方的边缘，哪些是多余的边缘。
在计算面积与中心点时，需要对闭合边缘使用approxPolyDP函数进行多变拟合。findContours为遍历提取所有的闭合区域，arcLength为计算闭合区域的周长，contourArea计算闭合区域的面积。
代码：

(contours, hierarchy) = cv2.findContours(dilated.copy(),
                                         cv2.RETR_TREE,
                                         cv2.CHAIN_APPROX_SIMPLE)


candidates = []
hierarchy = hierarchy[0]

index = 0
pre_cX = 0
pre_cY = 0
center = []
for component in zip(contours, hierarchy):
    contour = component[0]
    peri = cv2.arcLength(contour, True)
    approx = cv2.approxPolyDP(contour, 0.1 * peri, True)
    area = cv2.contourArea(contour)
    corners = len(approx)

    # compute the center of the contour
    M = cv2.moments(contour)

    if M["m00"]:
        cX = int(M["m10"] / M["m00"])
        cY = int(M["m01"] / M["m00"])
    else:
        cX = None
        cY = None

    if 14000 < area < 20000 and cX is not None:
        tmp = {'index': index, 'cx': cX, 'cy': cY, 'contour': contour}
        center.append(tmp)
        index += 1

center.sort(key=lambda k: (k.get('cy', 0)))
row1 = center[0:3]
row1.sort(key=lambda k: (k.get('cx', 0)))
row2 = center[3:6]
row2.sort(key=lambda k: (k.get('cx', 0)))
row3 = center[6:9]
row3.sort(key=lambda k: (k.get('cx', 0)))

center.clear()
center = row1 + row2 + row3

for component in center:
    candidates.append(component.get('contour'))

cv2.drawContours(imgobj, candidates, -1, (0, 0, 255), 3)
cv2.imshow("image", imgobj)
cv2.waitKey(0)

效果如下：

通过效果图，对于魔方的边缘及位置识别基本正确，后续即可对识别区域内的颜色进行分析，会在后续文章中进行。

整体思路：

1.过滤噪声

2.由于RGB颜色的离散性转换为HSV通道

3.对HSV空间进行量化，得到2值图像，亮的部分为手的形状

4.去除杂点造成的伪轮廓，留下手的真实轮廓

5.对凸出点连线

6.最高点到底部中点的连线即为手指方向

//部分代码：
将MFC实现部分给省略了，给出了完整的opencv部分代码，可以参考实现。
int main()
{
    cv::VideoCapture cap(0);
    if (!cap.isOpened())
    {
        return -1;
    }
    //
    cv::Mat frame;
    cv::Mat frameHSV;
    //
    std::vector< std::vector<cv::Point> > OriginalContours;//轮廓
    std::vector< cv::Vec4i > hierarchy; // 轮廓的结构信息
    //
    std::vector< std::vector<cv::Point> > FinalContours;// 筛选后的轮廓
    std::vector< cv::Point > hull;  // 凸包络的点集
    //
    CString Str;
    int i, j;
    int Width = cap.get(CV_CAP_PROP_FRAME_WIDTH), Height = cap.get(CV_CAP_PROP_FRAME_HEIGHT);
    float fHeight = ((float)2 / 3 - (float)1 / 7) * Height;
    //
    while (0 == pDlg->m_bStopFlag)
    {
        cap >> frame;
        if (frame.empty())
        {
            break;
        }
        //左右翻转
        cv::flip(frame, frame, 1);
        //中值滤波，用了这个下面的其他滤波全部异常
        //medianBlur(frame, frame, 10);
        //高斯滤波
        cv::GaussianBlur(frame, frame, cv::Size(7, 7), 1.5, 1.5);
        //通道转换
        cv::cvtColor(frame, frameHSV, CV_BGR2HSV);
        //imshow("frameHSV", frameHSV);
        /*
        S = 符号整型  U = 无符号整型  F = 浮点型
        E.g.:
        CV_8UC1 是指一个8位无符号整型单通道矩阵,
        CV_32FC2是指一个32位浮点型双通道矩阵
        CV_8UC1          CV_8SC1          CV_16U C1       CV_16SC1
        CV_8UC2          CV_8SC2          CV_16UC2        CV_16SC2
        CV_8UC3          CV_8SC3          CV_16UC3        CV_16SC3
        CV_8UC4          CV_8SC4          CV_16UC4        CV_16SC4
        CV_32SC1         CV_32FC1         CV_64FC1
        CV_32SC2         CV_32FC2         CV_64FC2
        CV_32SC3         CV_32FC3         CV_64FC3
        CV_32SC4         CV_32FC4         CV_64FC4
        */
        // 对HSV空间进行量化，得到2值图像，亮的部分为手的形状
        cv::Mat mask(frame.rows, frame.cols, CV_8UC1);
        //inRange(frameHSV, cv::Scalar(0, 30, 30), cv::Scalar(40, 170, 256), mask);
        inRange(frameHSV, cv::Scalar(5, 30, 30), cv::Scalar(40, 170, 256), mask);
        //
        // 腐蚀:去除小亮点 膨胀：连接区块
        cv::erode(mask, mask, cv::Mat(5, 5, CV_8U), cv::Point(-1, -1), 1);
        //cv::dilate(mask, mask, cv::Mat(5, 5, CV_8U), cv::Point(-1, -1), 2);
        //imshow("frameHSV", frameHSV);
        //imshow("mask", mask);
        OriginalContours.clear();
        hierarchy.clear();
        FinalContours.clear();
        // 得到手的轮廓
        cv::findContours(mask, OriginalContours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
        // 去除伪轮廓
        for (i = 0; i < OriginalContours.size(); i++)
        {
            if (fabs(cv::contourArea(cv::Mat(OriginalContours[i]))) > 25000)
            {
                FinalContours.push_back(OriginalContours[i]);
            }
        }
        // 画轮廓
        cv::drawContours(frame, FinalContours, -1, cv::Scalar(0, 0, 255), 3);
        // 得到轮廓的凸包络
        int hullcount;
        int iNumOfContours = FinalContours.size();
        cv::Point top;
        for (j = 0; j < iNumOfContours; j++)
        {
            convexHull(cv::Mat(FinalContours[j]), hull, true);
            hullcount = (int)hull.size();
            //
            for (i = 0; i<hullcount - 1; i++)
            {
                cv::line(frame, hull[i + 1], hull[i], cv::Scalar(255, 0, 0), 2, CV_AA);
            }
            cv::line(frame, hull[hullcount - 1], hull[0], cv::Scalar(255, 0, 0), 2, CV_AA);
            //画点
            GetTopPoint(hull, hullcount, top);
            cv::line(frame, top, top, cv::Scalar(255, 0, 255), 18, CV_AA);
            cv::line(frame, top, cv::Point(Width/2, Height), cv::Scalar(0, 255, 255), 2, CV_AA);
            //
            if (1 == iNumOfContours)
            {
                pDlg->m_FingerPosition.bChanged = 1;
                pDlg->m_FingerPosition.top = ((float)top.y - (float)Height / 7) / fHeight;
                pDlg->m_FingerPosition.left = (float)top.x / (float)Width;
            }
        }
        //
        cv::line(frame, cv::Point(0, Height / 7), cv::Point(Width, Height / 7), cv::Scalar(255, 255, 255), 2, CV_AA);
        cv::line(frame, cv::Point(0, 2 * Height / 3), cv::Point(Width, 2 * Height / 3), cv::Scalar(255, 255, 255), 2, CV_AA);
        imshow("frame", frame);
        cv::waitKey(33);
    }
    return 0;
}

实验效果图